SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/staging/wlags49_h2/wl_priv.c

   1 /*******************************************************************************
   2  * Agere Systems Inc.
   3  * Wireless device driver for Linux (wlags49).
   4  *
   5  * Copyright (c) 1998-2003 Agere Systems Inc.
   6  * All rights reserved.
   7  *   http://www.agere.com
   8  *
   9  * Initially developed by TriplePoint, Inc.
  10  *   http://www.triplepoint.com
  11  *
  12  *------------------------------------------------------------------------------
  13  *
  14  *   This file defines handling routines for the private IOCTLs
  15  *
  16  *------------------------------------------------------------------------------
  17  *
  18  * SOFTWARE LICENSE
  19  *
  20  * This software is provided subject to the following terms and conditions,
  21  * which you should read carefully before using the software.  Using this
  22  * software indicates your acceptance of these terms and conditions.  If you do
  23  * not agree with these terms and conditions, do not use the software.
  24  *
  25  * Copyright © 2003 Agere Systems Inc.
  26  * All rights reserved.
  27  *
  28  * Redistribution and use in source or binary forms, with or without
  29  * modifications, are permitted provided that the following conditions are met:
  30  *
  31  * . Redistributions of source code must retain the above copyright notice, this
  32  *    list of conditions and the following Disclaimer as comments in the code as
  33  *    well as in the documentation and/or other materials provided with the
  34  *    distribution.
  35  *
  36  * . Redistributions in binary form must reproduce the above copyright notice,
  37  *    this list of conditions and the following Disclaimer in the documentation
  38  *    and/or other materials provided with the distribution.
  39  *
  40  * . Neither the name of Agere Systems Inc. nor the names of the contributors
  41  *    may be used to endorse or promote products derived from this software
  42  *    without specific prior written permission.
  43  *
  44  * Disclaimer
  45  *
  46  * THIS SOFTWARE IS PROVIDED \93AS IS\94 AND ANY EXPRESS OR IMPLIED WARRANTIES,
  47  * INCLUDING, BUT NOT LIMITED TO, INFRINGEMENT AND THE IMPLIED WARRANTIES OF
  48  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  ANY
  49  * USE, MODIFICATION OR DISTRIBUTION OF THIS SOFTWARE IS SOLELY AT THE USERS OWN
  50  * RISK. IN NO EVENT SHALL AGERE SYSTEMS INC. OR CONTRIBUTORS BE LIABLE FOR ANY
  51  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  52  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  53  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  54  * ON ANY THEORY OF LIABILITY, INCLUDING, BUT NOT LIMITED TO, CONTRACT, STRICT
  55  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  56  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  57  * DAMAGE.
  58  *
  59  ******************************************************************************/
  60
  61 /*******************************************************************************
  62  * include files
  63  ******************************************************************************/
  64 #include <wl_version.h>
  65
  66 #include <linux/if_arp.h>
  67 #include <linux/ioport.h>
  68 #include <linux/slab.h>
  69 #include <linux/delay.h>
  70 #include <asm/uaccess.h>
  71
  72 #include <debug.h>
  73 #include <hcf.h>
  74 #include <hcfdef.h>
  75
  76 #include <wl_if.h>
  77 #include <wl_internal.h>
  78 #include <wl_enc.h>
  79 #include <wl_main.h>
  80 #include <wl_priv.h>
  81 #include <wl_util.h>
  82 #include <wl_netdev.h>
  83
  84 int wvlan_uil_connect( struct uilreq *urq, struct wl_private *lp );
  85 int wvlan_uil_disconnect( struct uilreq *urq, struct wl_private *lp );
  86 int wvlan_uil_action( struct uilreq *urq, struct wl_private *lp );
  87 int wvlan_uil_block( struct uilreq *urq, struct wl_private *lp );
  88 int wvlan_uil_unblock( struct uilreq *urq, struct wl_private *lp );
  89 int wvlan_uil_send_diag_msg( struct uilreq *urq, struct wl_private *lp );
  90 int wvlan_uil_put_info( struct uilreq *urq, struct wl_private *lp );
  91 int wvlan_uil_get_info( struct uilreq *urq, struct wl_private *lp );
  92
  93 int cfg_driver_info( struct uilreq *urq, struct wl_private *lp );
  94 int cfg_driver_identity( struct uilreq *urq, struct wl_private *lp );
  95
  96
  97 /*******************************************************************************
  98  * global variables
  99  ******************************************************************************/
 100 #if DBG
 101 extern dbg_info_t *DbgInfo;
 102 #endif  // DBG
 103
 104
 105
 106
 107 /* If USE_UIL is not defined, then none of the UIL Interface code below will
 108    be included in the build */
 109 #ifdef USE_UIL
 110
 111 /*******************************************************************************
 112  *      wvlan_uil()
 113  *******************************************************************************
 114  *
 115  *  DESCRIPTION:
 116  *
 117  *      The handler function for the UIL interface.
 118  *
 119  *  PARAMETERS:
 120  *
 121  *      urq - a pointer to the UIL request buffer
 122  *      lp  - a pointer to the device's private adapter structure
 123  *
 124  *  RETURNS:
 125  *
 126  *      0 on success
 127  *      errno value otherwise
 128  *
 129  ******************************************************************************/
 130 int wvlan_uil( struct uilreq *urq, struct wl_private *lp )
 131 {
 132         int ioctl_ret = 0;
 133         /*------------------------------------------------------------------------*/
 134
 135         DBG_FUNC( "wvlan_uil" );
 136         DBG_ENTER( DbgInfo );
 137
 138         switch( urq->command ) {
 139           case UIL_FUN_CONNECT:
 140                 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_UIL -- WVLAN2_UIL_CONNECT\n");
 141                 ioctl_ret = wvlan_uil_connect( urq, lp );
 142                 break;
 143           case UIL_FUN_DISCONNECT:
 144                 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_UIL -- WVLAN2_UIL_DISCONNECT\n");
 145                 ioctl_ret = wvlan_uil_disconnect( urq, lp );
 146                 break;
 147           case UIL_FUN_ACTION:
 148                 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_UIL -- WVLAN2_UIL_ACTION\n" );
 149                 ioctl_ret = wvlan_uil_action( urq, lp );
 150                 break;
 151           case UIL_FUN_SEND_DIAG_MSG:
 152                 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_UIL -- WVLAN2_UIL_SEND_DIAG_MSG\n");
 153                 ioctl_ret = wvlan_uil_send_diag_msg( urq, lp );
 154                 break;
 155           case UIL_FUN_GET_INFO:
 156                 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_UIL -- WVLAN2_UIL_GET_INFO\n");
 157                 ioctl_ret = wvlan_uil_get_info( urq, lp );
 158                 break;
 159           case UIL_FUN_PUT_INFO:
 160                 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_UIL -- WVLAN2_UIL_PUT_INFO\n");
 161                 ioctl_ret = wvlan_uil_put_info( urq, lp );
 162                 break;
 163         default:
 164                 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_UIL -- UNSUPPORTED UIL CODE: 0x%X", urq->command );
 165                 ioctl_ret = -EOPNOTSUPP;
 166                 break;
 167         }
 168         DBG_LEAVE( DbgInfo );
 169         return ioctl_ret;
 170 } // wvlan_uil
 171 /*============================================================================*/
 172
 173
 174
 175
 176 /*******************************************************************************
 177  *      wvlan_uil_connect()
 178  *******************************************************************************
 179  *
 180  *  DESCRIPTION:
 181  *
 182  *      Connect to the UIL in order to make a request.
 183  *
 184  *  PARAMETERS:
 185  *
 186  *      urq - a pointer to the UIL request buffer
 187  *      lp  - a pointer to the device's private adapter structure
 188  *
 189  *  RETURNS:
 190  *
 191  *      UIL_SUCCESS
 192  *      UIL_ERR_xxx value otherwise
 193  *
 194  ******************************************************************************/
 195 int wvlan_uil_connect( struct uilreq *urq, struct wl_private *lp )
 196 {
 197         int result = 0;
 198         /*------------------------------------------------------------------------*/
 199
 200
 201         DBG_FUNC( "wvlan_uil_connect" );
 202         DBG_ENTER( DbgInfo );
 203
 204
 205         if( !( lp->flags & WVLAN2_UIL_CONNECTED )) {
 206                 lp->flags |= WVLAN2_UIL_CONNECTED;
 207                 urq->hcfCtx = &( lp->hcfCtx );
 208                 urq->result = UIL_SUCCESS;
 209         } else {
 210                 DBG_WARNING( DbgInfo, "UIL_ERR_IN_USE\n" );
 211                 urq->result = UIL_ERR_IN_USE;
 212         }
 213
 214         DBG_LEAVE( DbgInfo );
 215         return result;
 216 } // wvlan_uil_connect
 217 /*============================================================================*/
 218
 219
 220
 221
 222 /*******************************************************************************
 223  *      wvlan_uil_disconnect()
 224  *******************************************************************************
 225  *
 226  *  DESCRIPTION:
 227  *
 228  *      Disonnect from the UIL after a request has been completed.
 229  *
 230  *  PARAMETERS:
 231  *
 232  *      urq - a pointer to the UIL request buffer
 233  *      lp  - a pointer to the device's private adapter structure
 234  *
 235  *  RETURNS:
 236  *
 237  *      UIL_SUCCESS
 238  *      UIL_ERR_xxx value otherwise
 239  *
 240  ******************************************************************************/
 241 int wvlan_uil_disconnect( struct uilreq *urq, struct wl_private *lp )
 242 {
 243         int result = 0;
 244         /*------------------------------------------------------------------------*/
 245
 246
 247         DBG_FUNC( "wvlan_uil_disconnect" );
 248         DBG_ENTER( DbgInfo );
 249
 250
 251         if( urq->hcfCtx == &( lp->hcfCtx )) {
 252                 if (lp->flags & WVLAN2_UIL_CONNECTED) {
 253                         lp->flags &= ~WVLAN2_UIL_CONNECTED;
 254                         /*
 255                         if (lp->flags & WVLAN2_UIL_BUSY) {
 256                                 lp->flags &= ~WVLAN2_UIL_BUSY;
 257                                 netif_start_queue(lp->dev);
 258                         }
 259                         */
 260                 }
 261
 262                 urq->hcfCtx = NULL;
 263                 urq->result = UIL_SUCCESS;
 264         } else {
 265                 DBG_ERROR( DbgInfo, "UIL_ERR_WRONG_IFB\n" );
 266                 urq->result = UIL_ERR_WRONG_IFB;
 267         }
 268
 269         DBG_LEAVE( DbgInfo );
 270         return result;
 271 } // wvlan_uil_disconnect
 272 /*============================================================================*/
 273
 274
 275
 276
 277 /*******************************************************************************
 278  *      wvlan_uil_action()
 279  *******************************************************************************
 280  *
 281  *  DESCRIPTION:
 282  *
 283  *      Handler for the UIL_ACT_xxx subcodes associated with UIL_FUN_ACTION
 284  *
 285  *  PARAMETERS:
 286  *
 287  *      urq - a pointer to the UIL request buffer
 288  *      lp  - a pointer to the device's private adapter structure
 289  *
 290  *  RETURNS:
 291  *
 292  *      UIL_SUCCESS
 293  *      UIL_ERR_xxx value otherwise
 294  *
 295  ******************************************************************************/
 296 int wvlan_uil_action( struct uilreq *urq, struct wl_private *lp )
 297 {
 298         int     result = 0;
 299         ltv_t   *ltv;
 300         /*------------------------------------------------------------------------*/
 301
 302
 303         DBG_FUNC( "wvlan_uil_action" );
 304         DBG_ENTER( DbgInfo );
 305
 306
 307         if( urq->hcfCtx == &( lp->hcfCtx )) {
 308                 /* Make sure there's an LTV in the request buffer */
 309                 ltv = (ltv_t *)urq->data;
 310                 if( ltv != NULL ) {
 311                         /* Switch on the Type field of the LTV contained in the request
 312                            buffer */
 313                         switch( ltv->typ ) {
 314                         case UIL_ACT_BLOCK:
 315                                 DBG_TRACE( DbgInfo, "UIL_ACT_BLOCK\n" );
 316                                 result = wvlan_uil_block( urq, lp );
 317                                 break;
 318                         case UIL_ACT_UNBLOCK:
 319                                 DBG_TRACE( DbgInfo, "UIL_ACT_UNBLOCK\n" );
 320                                 result = wvlan_uil_unblock( urq, lp );
 321                                 break;
 322                         case UIL_ACT_SCAN:
 323                                 DBG_TRACE( DbgInfo, "UIL_ACT_SCAN\n" );
 324                                 urq->result = hcf_action( &( lp->hcfCtx ), MDD_ACT_SCAN );
 325                                 break;
 326                         case UIL_ACT_APPLY:
 327                                 DBG_TRACE( DbgInfo, "UIL_ACT_APPLY\n" );
 328                                 urq->result = wl_apply( lp );
 329                                 break;
 330                         case UIL_ACT_RESET:
 331                                 DBG_TRACE( DbgInfo, "UIL_ACT_RESET\n" );
 332                                 urq->result = wl_go( lp );
 333                                 break;
 334                         default:
 335                                 DBG_WARNING( DbgInfo, "Unknown action code: 0x%x\n", ltv->typ );
 336                                 break;
 337                         }
 338                 } else {
 339                         DBG_ERROR( DbgInfo, "Bad LTV for this action\n" );
 340                         urq->result = UIL_ERR_LEN;
 341                 }
 342         } else {
 343                 DBG_ERROR( DbgInfo, "UIL_ERR_WRONG_IFB\n" );
 344                 urq->result = UIL_ERR_WRONG_IFB;
 345         }
 346
 347         DBG_LEAVE( DbgInfo );
 348         return result;
 349 } // wvlan_uil_action
 350 /*============================================================================*/
 351
 352
 353
 354
 355 /*******************************************************************************
 356  *      wvlan_uil_block()
 357  *******************************************************************************
 358  *
 359  *  DESCRIPTION:
 360  *
 361  *      Sets a block in the driver to prevent access to the card by other
 362  *  processes.
 363  *
 364  *  PARAMETERS:
 365  *
 366  *      urq - a pointer to the UIL request buffer
 367  *      lp  - a pointer to the device's private adapter structure
 368  *
 369  *  RETURNS:
 370  *
 371  *      UIL_SUCCESS
 372  *      UIL_ERR_xxx value otherwise
 373  *
 374  ******************************************************************************/
 375
 376 int wvlan_uil_block( struct uilreq *urq, struct wl_private *lp )
 377 {
 378         int result = 0;
 379         /*------------------------------------------------------------------------*/
 380
 381
 382         DBG_FUNC( "wvlan_uil_block" );
 383         DBG_ENTER( DbgInfo );
 384
 385         if( urq->hcfCtx == &( lp->hcfCtx )) {
 386                 if( capable( CAP_NET_ADMIN )) {
 387                         lp->flags |= WVLAN2_UIL_BUSY;
 388                         netif_stop_queue(lp->dev);
 389                         WL_WDS_NETIF_STOP_QUEUE( lp );
 390                         urq->result = UIL_SUCCESS;
 391                 } else {
 392                         DBG_ERROR( DbgInfo, "EPERM\n" );
 393                         urq->result = UIL_FAILURE;
 394                         result = -EPERM;
 395                 }
 396         } else {
 397                 DBG_ERROR( DbgInfo, "UIL_ERR_WRONG_IFB\n" );
 398                 urq->result = UIL_ERR_WRONG_IFB;
 399         }
 400
 401         DBG_LEAVE( DbgInfo );
 402         return result;
 403 } // wvlan_uil_block
 404 /*============================================================================*/
 405
 406
 407
 408
 409 /*******************************************************************************
 410  *      wvlan_uil_unblock()
 411  *******************************************************************************
 412  *
 413  *  DESCRIPTION:
 414  *
 415  *      Unblocks the driver to restore access to the card by other processes.
 416  *
 417  *  PARAMETERS:
 418  *
 419  *      urq - a pointer to the UIL request buffer
 420  *      lp  - a pointer to the device's private adapter structure
 421  *
 422  *  RETURNS:
 423  *
 424  *      UIL_SUCCESS
 425  *      UIL_ERR_xxx value otherwise
 426  *
 427  ******************************************************************************/
 428 int wvlan_uil_unblock( struct uilreq *urq, struct wl_private *lp )
 429 {
 430         int result = 0;
 431         /*------------------------------------------------------------------------*/
 432
 433
 434         DBG_FUNC( "wvlan_uil_unblock" );
 435         DBG_ENTER( DbgInfo );
 436
 437         if( urq->hcfCtx == &( lp->hcfCtx )) {
 438                 if( capable( CAP_NET_ADMIN )) {
 439                         if (lp->flags & WVLAN2_UIL_BUSY) {
 440                                 lp->flags &= ~WVLAN2_UIL_BUSY;
 441                                 netif_wake_queue(lp->dev);
 442                                 WL_WDS_NETIF_WAKE_QUEUE( lp );
 443                         }
 444                 } else {
 445                         DBG_ERROR( DbgInfo, "EPERM\n" );
 446                         urq->result = UIL_FAILURE;
 447                         result = -EPERM;
 448                 }
 449         } else {
 450                 DBG_ERROR( DbgInfo, "UIL_ERR_WRONG_IFB\n" );
 451                 urq->result = UIL_ERR_WRONG_IFB;
 452         }
 453
 454         DBG_LEAVE( DbgInfo );
 455         return result;
 456 } // wvlan_uil_unblock
 457 /*============================================================================*/
 458
 459
 460
 461
 462 /*******************************************************************************
 463  *      wvlan_uil_send_diag_msg()
 464  *******************************************************************************
 465  *
 466  *  DESCRIPTION:
 467  *
 468  *      Sends a diagnostic message to the card.
 469  *
 470  *  PARAMETERS:
 471  *
 472  *      urq - a pointer to the UIL request buffer
 473  *      lp  - a pointer to the device's private adapter structure
 474  *
 475  *  RETURNS:
 476  *
 477  *      UIL_SUCCESS
 478  *      UIL_ERR_xxx value otherwise
 479  *
 480  ******************************************************************************/
 481 int wvlan_uil_send_diag_msg( struct uilreq *urq, struct wl_private *lp )
 482 {
 483         int         result = 0;
 484         DESC_STRCT  Descp[1];
 485         /*------------------------------------------------------------------------*/
 486
 487
 488         DBG_FUNC( "wvlan_uil_send_diag_msg" );
 489         DBG_ENTER( DbgInfo );
 490
 491         if( urq->hcfCtx == &( lp->hcfCtx )) {
 492                 if( capable( CAP_NET_ADMIN )) {
 493                         if ((urq->data != NULL) && (urq->len != 0)) {
 494                                 if (lp->hcfCtx.IFB_RscInd != 0) {
 495                                         u_char *data;
 496
 497                                         // Verify the user buffer
 498                                         result = verify_area(VERIFY_READ, urq->data, urq->len);
 499                                         if (result != 0) {
 500                                                 DBG_ERROR( DbgInfo, "verify_area failed, result: %d\n", result );
 501                                                 urq->result = UIL_FAILURE;
 502                                                 DBG_LEAVE( DbgInfo );
 503                                                 return result;
 504                                         }
 505
 506                                         data = kmalloc(urq->len, GFP_KERNEL);
 507                                         if (data != NULL) {
 508                                                 memset( Descp, 0, sizeof( DESC_STRCT ));
 509                                                 memcpy( data, urq->data, urq->len );
 510
 511                                                 Descp[0].buf_addr       = (wci_bufp)data;
 512                                                 Descp[0].BUF_CNT        = urq->len;
 513                                                 Descp[0].next_desc_addr = 0;    // terminate list
 514
 515                                                 hcf_send_msg( &(lp->hcfCtx),  &Descp[0], HCF_PORT_0 );
 516                                                 kfree( data );
 517                                         } else {
 518                                                 DBG_ERROR( DbgInfo, "ENOMEM\n" );
 519                                                 urq->result = UIL_FAILURE;
 520                                                 result = -ENOMEM;
 521                                                 DBG_LEAVE( DbgInfo );
 522                                                 return result;
 523                                         }
 524
 525                                 } else {
 526                                         urq->result = UIL_ERR_BUSY;
 527                                 }
 528
 529                         } else {
 530                                 urq->result = UIL_FAILURE;
 531                         }
 532                 } else {
 533                         DBG_ERROR( DbgInfo, "EPERM\n" );
 534                         urq->result = UIL_FAILURE;
 535                         result = -EPERM;
 536                 }
 537         } else {
 538                 DBG_ERROR( DbgInfo, "UIL_ERR_WRONG_IFB\n" );
 539                 urq->result = UIL_ERR_WRONG_IFB;
 540         }
 541
 542         DBG_LEAVE( DbgInfo );
 543         return result;
 544 } // wvlan_uil_send_diag_msg
 545 /*============================================================================*/
 546
 547
 548 /*******************************************************************************
 549  *      wvlan_uil_put_info()
 550  *******************************************************************************
 551  *
 552  *  DESCRIPTION:
 553  *
 554  *      Sends a specific RID directly to the driver to set configuration info.
 555  *
 556  *  PARAMETERS:
 557  *
 558  *      urq - a pointer to the UIL request buffer
 559  *      lp  - a pointer to the device's private adapter structure
 560  *
 561  *  RETURNS:
 562  *
 563  *      UIL_SUCCESS
 564  *      UIL_ERR_xxx value otherwise
 565  *
 566  ******************************************************************************/
 567 int wvlan_uil_put_info( struct uilreq *urq, struct wl_private *lp )
 568 {
 569         int                     result = 0;
 570         ltv_t                   *pLtv;
 571         bool_t                  ltvAllocated = FALSE;
 572         ENCSTRCT                sEncryption;
 573
 574 #ifdef USE_WDS
 575         hcf_16                  hcfPort  = HCF_PORT_0;
 576 #endif  /* USE_WDS */
 577         /*------------------------------------------------------------------------*/
 578         DBG_FUNC( "wvlan_uil_put_info" );
 579         DBG_ENTER( DbgInfo );
 580
 581
 582         if( urq->hcfCtx == &( lp->hcfCtx )) {
 583                 if( capable( CAP_NET_ADMIN )) {
 584                         if(( urq->data != NULL ) && ( urq->len != 0 )) {
 585                                 /* Make sure that we have at least a command and length to send. */
 586                                 if( urq->len < ( sizeof( hcf_16 ) * 2 )) {
 587                                         urq->len = sizeof( lp->ltvRecord );
 588                                         urq->result = UIL_ERR_LEN;
 589                                         DBG_ERROR( DbgInfo, "No Length/Type in LTV!!!\n" );
 590                                         DBG_ERROR( DbgInfo, "UIL_ERR_LEN\n" );
 591                                         DBG_LEAVE( DbgInfo );
 592                                         return result;
 593                                 }
 594
 595                                 /* Verify the user buffer */
 596                                 result = verify_area( VERIFY_READ, urq->data, urq->len );
 597                                 if( result != 0 ) {
 598                                         urq->result = UIL_FAILURE;
 599                                         DBG_ERROR( DbgInfo, "verify_area(), VERIFY_READ FAILED\n" );
 600                                         DBG_LEAVE( DbgInfo );
 601                                         return result;
 602                                 }
 603
 604                                 /* Get only the command and length information. */
 605                                 copy_from_user( &( lp->ltvRecord ), urq->data, sizeof( hcf_16 ) * 2 );
 606
 607                                 /* Make sure the incoming LTV record length is within the bounds of the
 608                                    IOCTL length */
 609                                 if((( lp->ltvRecord.len + 1 ) * sizeof( hcf_16 )) > urq->len ) {
 610                                         urq->len = sizeof( lp->ltvRecord );
 611                                         urq->result = UIL_ERR_LEN;
 612                                         DBG_ERROR( DbgInfo, "UIL_ERR_LEN\n" );
 613                                         DBG_LEAVE( DbgInfo );
 614                                         return result;
 615                                 }
 616
 617                                 /* If the requested length is greater than the size of our local
 618                                    LTV record, try to allocate it from the kernel stack.
 619                                    Otherwise, we just use our local LTV record. */
 620                                 if( urq->len > sizeof( lp->ltvRecord )) {
 621                                         pLtv = (ltv_t *)kmalloc( urq->len, GFP_KERNEL );
 622                                         if (pLtv != NULL) {
 623                                                 ltvAllocated = TRUE;
 624                                         } else {
 625                                                 DBG_ERROR( DbgInfo, "Alloc FAILED\n" );
 626                                                 urq->len = sizeof( lp->ltvRecord );
 627                                                 urq->result = UIL_ERR_LEN;
 628                                                 result = -ENOMEM;
 629                                                 DBG_LEAVE( DbgInfo );
 630                                                 return result;
 631                                         }
 632                                 } else {
 633                                         pLtv = &( lp->ltvRecord );
 634                                 }
 635
 636                                 /* Copy the data from the user's buffer into the local LTV
 637                                    record data area. */
 638                                 copy_from_user( pLtv, urq->data, urq->len );
 639
 640
 641                                 /* We need to snoop the commands to see if there is anything we
 642                                    need to store for the purposes of a reset or start/stop
 643                                    sequence. Perform endian translation as needed */
 644                                 switch( pLtv->typ ) {
 645                                 case CFG_CNF_PORT_TYPE:
 646                                         lp->PortType    = pLtv->u.u16[0];
 647                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 648                                         break;
 649                                 case CFG_CNF_OWN_MAC_ADDR:
 650                                         /* TODO: determine if we are going to store anything based on this */
 651                                         break;
 652                                 case CFG_CNF_OWN_CHANNEL:
 653                                         lp->Channel     = pLtv->u.u16[0];
 654                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 655                                         break;
 656                                 /* CFG_CNF_OWN_SSID currently same as CNF_DESIRED_SSID. Do we
 657                                    need seperate storage for this? */
 658                                 //case CFG_CNF_OWN_SSID:
 659                                 case CFG_CNF_OWN_ATIM_WINDOW:
 660                                         lp->atimWindow  = pLtv->u.u16[0];
 661                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 662                                         break;
 663                                 case CFG_CNF_SYSTEM_SCALE:
 664                                         lp->DistanceBetweenAPs  = pLtv->u.u16[0];
 665                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 666
 667                                 case CFG_CNF_MAX_DATA_LEN:
 668                                         /* TODO: determine if we are going to store anything based
 669                                            on this */
 670                                         break;
 671                                 case CFG_CNF_PM_ENABLED:
 672                                         lp->PMEnabled   = pLtv->u.u16[0];
 673                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 674                                         break;
 675                                 case CFG_CNF_MCAST_RX:
 676                                         lp->MulticastReceive    = pLtv->u.u16[0];
 677                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 678                                         break;
 679                                 case CFG_CNF_MAX_SLEEP_DURATION:
 680                                         lp->MaxSleepDuration    = pLtv->u.u16[0];
 681                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 682                                         break;
 683                                 case CFG_CNF_HOLDOVER_DURATION:
 684                                         lp->holdoverDuration    = pLtv->u.u16[0];
 685                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 686                                         break;
 687                                 case CFG_CNF_OWN_NAME:
 688                                         memset( lp->StationName, 0, sizeof( lp->StationName ));
 689                                         memcpy( (void *)lp->StationName, (void *)&pLtv->u.u8[2], (size_t)pLtv->u.u16[0]);
 690                                         pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 691                                         break;
 692                                 case CFG_CNF_LOAD_BALANCING:
 693                                         lp->loadBalancing       = pLtv->u.u16[0];
 694                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 695                                         break;
 696                                 case CFG_CNF_MEDIUM_DISTRIBUTION:
 697                                         lp->mediumDistribution  = pLtv->u.u16[0];
 698                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 699                                         break;
 700 #ifdef WARP
 701                                 case CFG_CNF_TX_POW_LVL:
 702                                         lp->txPowLevel          = pLtv->u.u16[0];
 703                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 704                                         break;
 705                                 //case CFG_CNF_SHORT_RETRY_LIMIT:    // Short Retry Limit
 706                                 //case 0xFC33:    // Long Retry Limit
 707                                 case CFG_SUPPORTED_RATE_SET_CNTL:        // Supported Rate Set Control
 708                                         lp->srsc[0]             = pLtv->u.u16[0];
 709                                         lp->srsc[1]             = pLtv->u.u16[1];
 710                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 711                                         pLtv->u.u16[1]          = CNV_INT_TO_LITTLE( pLtv->u.u16[1] );
 712                                         break;
 713                                 case CFG_BASIC_RATE_SET_CNTL:        // Basic Rate Set Control
 714                                         lp->brsc[0]             = pLtv->u.u16[0];
 715                                         lp->brsc[1]             = pLtv->u.u16[1];
 716                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 717                                         pLtv->u.u16[1]          = CNV_INT_TO_LITTLE( pLtv->u.u16[1] );
 718                                         break;
 719                                 case CFG_CNF_CONNECTION_CNTL:
 720                                         lp->connectionControl   = pLtv->u.u16[0];
 721                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 722                                         break;
 723                                 //case CFG_PROBE_DATA_RATE:
 724 #endif  // HERMES25
 725
 726 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
 727                 //;?should we restore this to allow smaller memory footprint
 728
 729                                 case CFG_CNF_OWN_DTIM_PERIOD:
 730                                         lp->DTIMPeriod  = pLtv->u.u16[0];
 731                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 732                                         break;
 733 #ifdef WARP
 734                                 case CFG_CNF_OWN_BEACON_INTERVAL:        // Own Beacon Interval
 735                                         lp->ownBeaconInterval   = pLtv->u.u16[0];
 736                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 737                                         break;
 738 #endif // WARP
 739                                 case CFG_COEXISTENSE_BEHAVIOUR:         // Coexistence behavior
 740                                         lp->coexistence         = pLtv->u.u16[0];
 741                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 742                                         break;
 743 #ifdef USE_WDS
 744                                 case CFG_CNF_WDS_ADDR1:
 745                                         memcpy( &lp->wds_port[0].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
 746                                         hcfPort = HCF_PORT_1;
 747                                         break;
 748                                 case CFG_CNF_WDS_ADDR2:
 749                                         memcpy( &lp->wds_port[1].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
 750                                         hcfPort = HCF_PORT_2;
 751                                         break;
 752                                 case CFG_CNF_WDS_ADDR3:
 753                                         memcpy( &lp->wds_port[2].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
 754                                         hcfPort = HCF_PORT_3;
 755                                         break;
 756                                 case CFG_CNF_WDS_ADDR4:
 757                                         memcpy( &lp->wds_port[3].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
 758                                         hcfPort = HCF_PORT_4;
 759                                         break;
 760                                 case CFG_CNF_WDS_ADDR5:
 761                                         memcpy( &lp->wds_port[4].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
 762                                         hcfPort = HCF_PORT_5;
 763                                         break;
 764                                 case CFG_CNF_WDS_ADDR6:
 765                                         memcpy( &lp->wds_port[5].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
 766                                         hcfPort = HCF_PORT_6;
 767                                         break;
 768 #endif  /* USE_WDS */
 769
 770                                 case CFG_CNF_MCAST_PM_BUF:
 771                                         lp->multicastPMBuffering    = pLtv->u.u16[0];
 772                                         pLtv->u.u16[0]              = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 773                                         break;
 774                                 case CFG_CNF_REJECT_ANY:
 775                                         lp->RejectAny   = pLtv->u.u16[0];
 776                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 777                                         break;
 778 #endif
 779
 780                                 case CFG_CNF_ENCRYPTION:
 781                                         lp->EnableEncryption    = pLtv->u.u16[0];
 782                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 783                                         break;
 784                                 case CFG_CNF_AUTHENTICATION:
 785                                         lp->authentication  = pLtv->u.u16[0];
 786                                         pLtv->u.u16[0]      = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 787                                         break;
 788 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
 789                 //;?should we restore this to allow smaller memory footprint
 790
 791                                 //case CFG_CNF_EXCL_UNENCRYPTED:
 792                                         //lp->ExcludeUnencrypted  = pLtv->u.u16[0];
 793                                         //pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 794                                         //break;
 795                                 case CFG_CNF_MCAST_RATE:
 796                                         /* TODO: determine if we are going to store anything based on this */
 797                                         break;
 798                                 case CFG_CNF_INTRA_BSS_RELAY:
 799                                         lp->intraBSSRelay   = pLtv->u.u16[0];
 800                                         pLtv->u.u16[0]      = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 801                                         break;
 802 #endif
 803
 804                                 case CFG_CNF_MICRO_WAVE:
 805                                         /* TODO: determine if we are going to store anything based on this */
 806                                         break;
 807                                 //case CFG_CNF_LOAD_BALANCING:
 808                                         /* TODO: determine if we are going to store anything based on this */
 809                                         //break;
 810                                 //case CFG_CNF_MEDIUM_DISTRIBUTION:
 811                                         /* TODO: determine if we are going to store anything based on this */
 812                                         //break;
 813                                 //case CFG_CNF_RX_ALL_GROUP_ADDRESS:
 814                                         // TODO: determine if we are going to store anything based on this
 815                                         //break;
 816                                 //case CFG_CNF_COUNTRY_INFO:
 817                                         /* TODO: determine if we are going to store anything based on this */
 818                                         //break;
 819                                 case CFG_CNF_OWN_SSID:
 820                                 //case CNF_DESIRED_SSID:
 821                                 case CFG_DESIRED_SSID:
 822                                         memset( lp->NetworkName, 0, sizeof( lp->NetworkName ));
 823                                         memcpy( (void *)lp->NetworkName, (void *)&pLtv->u.u8[2], (size_t)pLtv->u.u16[0] );
 824                                         pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 825
 826                                         /* take care of the special network name "ANY" case */
 827                                         if(( strlen( &pLtv->u.u8[2]        ) == 0 ) ||
 828                                            ( strcmp( &pLtv->u.u8[2], "ANY" ) == 0 ) ||
 829                                            ( strcmp( &pLtv->u.u8[2], "any" ) == 0 )) {
 830                                                 /* set the SSID_STRCT llen field (u16[0]) to zero, and the
 831                                                 effectually null the string u8[2] */
 832                                                 pLtv->u.u16[0] = 0;
 833                                                 pLtv->u.u8[2]  = 0;
 834                                         }
 835                                         break;
 836                                 case CFG_GROUP_ADDR:
 837                                         /* TODO: determine if we are going to store anything based on this */
 838                                         break;
 839                                 case CFG_CREATE_IBSS:
 840                                         lp->CreateIBSS  = pLtv->u.u16[0];
 841                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 842                                         break;
 843                                 case CFG_RTS_THRH:
 844                                         lp->RTSThreshold    = pLtv->u.u16[0];
 845                                         pLtv->u.u16[0]      = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 846                                         break;
 847                                 case CFG_TX_RATE_CNTL:
 848                                         lp->TxRateControl[0]    = pLtv->u.u16[0];
 849                                         lp->TxRateControl[1]    = pLtv->u.u16[1];
 850                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 851                                         pLtv->u.u16[1]          = CNV_INT_TO_LITTLE( pLtv->u.u16[1] );
 852                                         break;
 853                                 case CFG_PROMISCUOUS_MODE:
 854                                         /* TODO: determine if we are going to store anything based on this */
 855                                         break;
 856                                 //case CFG_WAKE_ON_LAN:
 857                                         /* TODO: determine if we are going to store anything based on this */
 858                                         //break;
 859 #if 1 //;? #if (HCF_TYPE) & HCF_TYPE_AP
 860                 //;?should we restore this to allow smaller memory footprint
 861                                 case CFG_RTS_THRH0:
 862                                         lp->RTSThreshold    = pLtv->u.u16[0];
 863                                         pLtv->u.u16[0]      = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 864                                         break;
 865                                 case CFG_TX_RATE_CNTL0:
 866 //;?no idea what this should be, get going so comment it out                                    lp->TxRateControl   = pLtv->u.u16[0];
 867                                         pLtv->u.u16[0]      = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 868                                         break;
 869 #ifdef USE_WDS
 870                                 case CFG_RTS_THRH1:
 871                                         lp->wds_port[0].rtsThreshold    = pLtv->u.u16[0];
 872                                         pLtv->u.u16[0]                  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 873                                         hcfPort                         = HCF_PORT_1;
 874                                         break;
 875                                 case CFG_RTS_THRH2:
 876                                         lp->wds_port[1].rtsThreshold    = pLtv->u.u16[0];
 877                                         pLtv->u.u16[0]                  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 878                                         hcfPort                         = HCF_PORT_2;
 879                                         break;
 880                                 case CFG_RTS_THRH3:
 881                                         lp->wds_port[2].rtsThreshold    = pLtv->u.u16[0];
 882                                         pLtv->u.u16[0]                  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 883                                         hcfPort                         = HCF_PORT_3;
 884                                         break;
 885                                 case CFG_RTS_THRH4:
 886                                         lp->wds_port[3].rtsThreshold    = pLtv->u.u16[0];
 887                                         pLtv->u.u16[0]                  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 888                                         hcfPort                         = HCF_PORT_4;
 889                                         break;
 890                                 case CFG_RTS_THRH5:
 891                                         lp->wds_port[4].rtsThreshold    = pLtv->u.u16[0];
 892                                         pLtv->u.u16[0]                  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 893                                         hcfPort                         = HCF_PORT_5;
 894                                         break;
 895                                 case CFG_RTS_THRH6:
 896                                         lp->wds_port[5].rtsThreshold    = pLtv->u.u16[0];
 897                                         pLtv->u.u16[0]                  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 898                                         hcfPort                         = HCF_PORT_6;
 899                                         break;
 900                                 case CFG_TX_RATE_CNTL1:
 901                                         lp->wds_port[0].txRateCntl  = pLtv->u.u16[0];
 902                                         pLtv->u.u16[0]              = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 903                                         hcfPort                     = HCF_PORT_1;
 904                                         break;
 905                                 case CFG_TX_RATE_CNTL2:
 906                                         lp->wds_port[1].txRateCntl  = pLtv->u.u16[0];
 907                                         pLtv->u.u16[0]              = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 908                                         hcfPort                     = HCF_PORT_2;
 909                                         break;
 910                                 case CFG_TX_RATE_CNTL3:
 911                                         lp->wds_port[2].txRateCntl  = pLtv->u.u16[0];
 912                                         pLtv->u.u16[0]              = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 913                                         hcfPort                     = HCF_PORT_3;
 914                                         break;
 915                                 case CFG_TX_RATE_CNTL4:
 916                                         lp->wds_port[3].txRateCntl  = pLtv->u.u16[0];
 917                                         pLtv->u.u16[0]              = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 918                                         hcfPort                     = HCF_PORT_4;
 919                                         break;
 920                                 case CFG_TX_RATE_CNTL5:
 921                                         lp->wds_port[4].txRateCntl  = pLtv->u.u16[0];
 922                                         pLtv->u.u16[0]              = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 923                                         hcfPort                     = HCF_PORT_5;
 924                                         break;
 925                                 case CFG_TX_RATE_CNTL6:
 926                                         lp->wds_port[5].txRateCntl  = pLtv->u.u16[0];
 927                                         pLtv->u.u16[0]              = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 928                                         hcfPort                     = HCF_PORT_6;
 929                                         break;
 930 #endif  /* USE_WDS */
 931 #endif  /* (HCF_TYPE) & HCF_TYPE_AP */
 932
 933                                 case CFG_DEFAULT_KEYS:
 934                                         {
 935                                                 CFG_DEFAULT_KEYS_STRCT *pKeys = (CFG_DEFAULT_KEYS_STRCT *)pLtv;
 936
 937                                                 pKeys->key[0].len = CNV_INT_TO_LITTLE( pKeys->key[0].len );
 938                                                 pKeys->key[1].len = CNV_INT_TO_LITTLE( pKeys->key[1].len );
 939                                                 pKeys->key[2].len = CNV_INT_TO_LITTLE( pKeys->key[2].len );
 940                                                 pKeys->key[3].len = CNV_INT_TO_LITTLE( pKeys->key[3].len );
 941
 942                                                 memcpy( (void *)&(lp->DefaultKeys), (void *)pKeys,
 943                                                                 sizeof( CFG_DEFAULT_KEYS_STRCT ));
 944                                         }
 945                                         break;
 946                                 case CFG_TX_KEY_ID:
 947                                         lp->TransmitKeyID   = pLtv->u.u16[0];
 948                                         pLtv->u.u16[0]      = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 949                                         break;
 950                                 case CFG_SCAN_SSID:
 951                                         /* TODO: determine if we are going to store anything based on this */
 952                                         break;
 953                                 case CFG_TICK_TIME:
 954                                         /* TODO: determine if we are going to store anything based on this */
 955                                         break;
 956                                 /* these RIDS are Info RIDs, and should they be allowed for puts??? */
 957                                 case CFG_MAX_LOAD_TIME:
 958                                 case CFG_DL_BUF:
 959                                 //case CFG_HSI_SUP_RANGE:
 960                                 case CFG_NIC_SERIAL_NUMBER:
 961                                 case CFG_NIC_IDENTITY:
 962                                 case CFG_NIC_MFI_SUP_RANGE:
 963                                 case CFG_NIC_CFI_SUP_RANGE:
 964                                 case CFG_NIC_TEMP_TYPE:
 965                                 case CFG_NIC_PROFILE:
 966                                 case CFG_FW_IDENTITY:
 967                                 case CFG_FW_SUP_RANGE:
 968                                 case CFG_MFI_ACT_RANGES_STA:
 969                                 case CFG_CFI_ACT_RANGES_STA:
 970                                 case CFG_PORT_STAT:
 971                                 case CFG_CUR_SSID:
 972                                 case CFG_CUR_BSSID:
 973                                 case CFG_COMMS_QUALITY:
 974                                 case CFG_CUR_TX_RATE:
 975                                 case CFG_CUR_BEACON_INTERVAL:
 976                                 case CFG_CUR_SCALE_THRH:
 977                                 case CFG_PROTOCOL_RSP_TIME:
 978                                 case CFG_CUR_SHORT_RETRY_LIMIT:
 979                                 case CFG_CUR_LONG_RETRY_LIMIT:
 980                                 case CFG_MAX_TX_LIFETIME:
 981                                 case CFG_MAX_RX_LIFETIME:
 982                                 case CFG_CF_POLLABLE:
 983                                 case CFG_AUTHENTICATION_ALGORITHMS:
 984                                 case CFG_PRIVACY_OPT_IMPLEMENTED:
 985                                 //case CFG_CURRENT_REMOTE_RATES:
 986                                 //case CFG_CURRENT_USED_RATES:
 987                                 //case CFG_CURRENT_SYSTEM_SCALE:
 988                                 //case CFG_CURRENT_TX_RATE1:
 989                                 //case CFG_CURRENT_TX_RATE2:
 990                                 //case CFG_CURRENT_TX_RATE3:
 991                                 //case CFG_CURRENT_TX_RATE4:
 992                                 //case CFG_CURRENT_TX_RATE5:
 993                                 //case CFG_CURRENT_TX_RATE6:
 994                                 case CFG_NIC_MAC_ADDR:
 995                                 case CFG_PCF_INFO:
 996                                 //case CFG_CURRENT_COUNTRY_INFO:
 997                                 case CFG_PHY_TYPE:
 998                                 case CFG_CUR_CHANNEL:
 999                                 //case CFG_CURRENT_POWER_STATE:
1000                                 //case CFG_CCAMODE:
1001                                 case CFG_SUPPORTED_DATA_RATES:
1002                                         break;
1003                                 case CFG_AP_MODE:
1004 //;?                            lp->DownloadFirmware = ( pLtv->u.u16[0] ) + 1;
1005                                         DBG_ERROR( DbgInfo, "set CFG_AP_MODE no longer supported\n" );
1006                                         break;
1007                                 case CFG_ENCRYPT_STRING:
1008                                         /* TODO: ENDIAN TRANSLATION HERE??? */
1009                                         memset( lp->szEncryption, 0, sizeof( lp->szEncryption ));
1010                                         memcpy( (void *)lp->szEncryption,  (void *)&pLtv->u.u8[0],
1011                                                         ( pLtv->len * sizeof( hcf_16 )) );
1012                                         wl_wep_decode( CRYPT_CODE, &sEncryption,
1013                                                                     lp->szEncryption );
1014
1015                                         /* the Linux driver likes to use 1-4 for the key IDs, and then
1016                                         convert to 0-3 when sending to the card.  The Windows code
1017                                         base used 0-3 in the API DLL, which was ported to Linux.  For
1018                                         the sake of the user experience, we decided to keep 0-3 as the
1019                                         numbers used in the DLL; and will perform the +1 conversion here.
1020                                         We could have converted  the entire Linux driver, but this is
1021                                         less obtrusive.  This may be a "todo" to convert the whole driver */
1022                                         lp->TransmitKeyID    = sEncryption.wTxKeyID + 1;
1023                                         lp->EnableEncryption = sEncryption.wEnabled;
1024
1025                                         memcpy( &lp->DefaultKeys, &sEncryption.EncStr,
1026                                                         sizeof( CFG_DEFAULT_KEYS_STRCT ));
1027                                         break;
1028                                 /*case CFG_COUNTRY_STRING:
1029                                         memset( lp->countryString, 0, sizeof( lp->countryString ));
1030                                         memcpy( (void *)lp->countryString, (void *)&pLtv->u.u8[2], (size_t)pLtv->u.u16[0]);
1031                                         break;
1032                                 */
1033
1034                                 case CFG_DRIVER_ENABLE:
1035                                         lp->driverEnable    = pLtv->u.u16[0];
1036                                         pLtv->u.u16[0]      = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
1037                                         break;
1038                                 case CFG_WOLAS_ENABLE:
1039                                         lp->wolasEnable = pLtv->u.u16[0];
1040                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
1041                                         break;
1042                                 case CFG_SET_WPA_AUTH_KEY_MGMT_SUITE:
1043                                         lp->AuthKeyMgmtSuite = pLtv->u.u16[0];
1044                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
1045                                         break;
1046                                 case CFG_DISASSOCIATE_ADDR:
1047                                         pLtv->u.u16[ETH_ALEN / 2] = CNV_INT_TO_LITTLE( pLtv->u.u16[ETH_ALEN / 2] );
1048                                         break;
1049                                 case CFG_ADD_TKIP_DEFAULT_KEY:
1050                                 case CFG_REMOVE_TKIP_DEFAULT_KEY:
1051                                         /* Endian convert the Tx Key Information */
1052                                         pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
1053                                         break;
1054                                 case CFG_ADD_TKIP_MAPPED_KEY:
1055                                         break;
1056                                 case CFG_REMOVE_TKIP_MAPPED_KEY:
1057                                         break;
1058                                 /* some RIDs just can't be put */
1059                                 case CFG_MB_INFO:
1060                                 case CFG_IFB:
1061                                 default:
1062                                         break;
1063                                 }
1064
1065                                 /* This code will prevent Static Configuration Entities from
1066                                    being sent to the card, as they require a call to
1067                                    UIL_ACT_APPLY to take effect. Dynamic Entities will be sent
1068                                    immediately */
1069                                 switch( pLtv->typ ) {
1070                                 case CFG_CNF_PORT_TYPE:
1071                                 case CFG_CNF_OWN_MAC_ADDR:
1072                                 case CFG_CNF_OWN_CHANNEL:
1073                                 case CFG_CNF_OWN_SSID:
1074                                 case CFG_CNF_OWN_ATIM_WINDOW:
1075                                 case CFG_CNF_SYSTEM_SCALE:
1076                                 case CFG_CNF_MAX_DATA_LEN:
1077                                 case CFG_CNF_PM_ENABLED:
1078                                 case CFG_CNF_MCAST_RX:
1079                                 case CFG_CNF_MAX_SLEEP_DURATION:
1080                                 case CFG_CNF_HOLDOVER_DURATION:
1081                                 case CFG_CNF_OWN_NAME:
1082                                 case CFG_CNF_LOAD_BALANCING:
1083                                 case CFG_CNF_MEDIUM_DISTRIBUTION:
1084 #ifdef WARP
1085                                 case CFG_CNF_TX_POW_LVL:
1086                                 case CFG_CNF_CONNECTION_CNTL:
1087                                 //case CFG_PROBE_DATA_RATE:
1088 #endif // HERMES25
1089 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
1090                 //;?should we restore this to allow smaller memory footprint
1091                                 case CFG_CNF_OWN_DTIM_PERIOD:
1092 #ifdef WARP
1093                                 case CFG_CNF_OWN_BEACON_INTERVAL:                    // Own Beacon Interval
1094 #endif // WARP
1095 #ifdef USE_WDS
1096                                 case CFG_CNF_WDS_ADDR1:
1097                                 case CFG_CNF_WDS_ADDR2:
1098                                 case CFG_CNF_WDS_ADDR3:
1099                                 case CFG_CNF_WDS_ADDR4:
1100                                 case CFG_CNF_WDS_ADDR5:
1101                                 case CFG_CNF_WDS_ADDR6:
1102 #endif
1103                                 case CFG_CNF_MCAST_PM_BUF:
1104                                 case CFG_CNF_REJECT_ANY:
1105 #endif
1106
1107                                 case CFG_CNF_ENCRYPTION:
1108                                 case CFG_CNF_AUTHENTICATION:
1109 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
1110                 //;?should we restore this to allow smaller memory footprint
1111
1112                                 case CFG_CNF_EXCL_UNENCRYPTED:
1113                                 case CFG_CNF_MCAST_RATE:
1114                                 case CFG_CNF_INTRA_BSS_RELAY:
1115 #endif
1116
1117                                 case CFG_CNF_MICRO_WAVE:
1118                                 //case CFG_CNF_LOAD_BALANCING:
1119                                 //case CFG_CNF_MEDIUM_DISTRIBUTION:
1120                                 //case CFG_CNF_RX_ALL_GROUP_ADDRESS:
1121                                 //case CFG_CNF_COUNTRY_INFO:
1122                                 //case CFG_COUNTRY_STRING:
1123                                 case CFG_AP_MODE:
1124                                 case CFG_ENCRYPT_STRING:
1125                                 //case CFG_DRIVER_ENABLE:
1126                                 case CFG_WOLAS_ENABLE:
1127                                 case CFG_MB_INFO:
1128                                 case CFG_IFB:
1129                                         break;
1130                                 /* Deal with this dynamic MSF RID, as it's required for WPA */
1131                                 case CFG_DRIVER_ENABLE:
1132                                         if( lp->driverEnable ) {
1133                                                 //hcf_cntl_port( &( lp->hcfCtx ),
1134                                                 //               HCF_PORT_ENABLE | HCF_PORT_0 );
1135                                                 // //hcf_cntl( &( lp->hcfCtx ),
1136                                                 // //         HCF_PORT_ENABLE | HCF_PORT_0 );
1137                                                 //hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_ENABLE );
1138                                                 // //hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_CONNECT );
1139
1140                                                 hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_ENABLE | HCF_PORT_0 );
1141                                                 hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_CONNECT );
1142                                         } else {
1143                                                 //hcf_cntl_port( &( lp->hcfCtx ),
1144                                                 //               HCF_PORT_DISABLE | HCF_PORT_0 );
1145                                                 // //hcf_cntl( &( lp->hcfCtx ),
1146                                                 // //         HCF_PORT_DISABLE | HCF_PORT_0 );
1147                                                 //hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_DISABLE );
1148                                                 // //hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_DISCONNECT );
1149
1150                                                 hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_DISABLE | HCF_PORT_0 );
1151                                                 hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_DISCONNECT );
1152                                         }
1153                                         break;
1154                                 default:
1155                                         wl_act_int_off( lp );
1156                                         urq->result = hcf_put_info(&(lp->hcfCtx), (LTVP) pLtv);
1157                                         wl_act_int_on( lp );
1158                                         break;
1159                                 }
1160
1161                                 if( ltvAllocated ) {
1162                                         kfree( pLtv );
1163                                 }
1164                         } else {
1165                                 urq->result = UIL_FAILURE;
1166                         }
1167                 } else {
1168                         DBG_ERROR( DbgInfo, "EPERM\n" );
1169                         urq->result = UIL_FAILURE;
1170                         result = -EPERM;
1171                 }
1172         } else {
1173                 DBG_ERROR( DbgInfo, "UIL_ERR_WRONG_IFB\n" );
1174                 urq->result = UIL_ERR_WRONG_IFB;
1175         }
1176
1177         DBG_LEAVE( DbgInfo );
1178         return result;
1179 } // wvlan_uil_put_info
1180 /*============================================================================*/
1181
1182 /*******************************************************************************
1183  *      wvlan_uil_get_info()
1184  *******************************************************************************
1185  *
1186  *  DESCRIPTION:
1187  *
1188  *      Sends a specific RID directly to the driver to retrieve configuration
1189  *      info.
1190  *
1191  *  PARAMETERS:
1192  *
1193  *      urq - a pointer to the UIL request buffer
1194  *      lp  - a pointer to the device's private adapter structure
1195  *
1196  *  RETURNS:
1197  *
1198  *      UIL_SUCCESS
1199  *      UIL_ERR_xxx value otherwise
1200  *
1201  ******************************************************************************/
1202 int wvlan_uil_get_info( struct uilreq *urq, struct wl_private *lp )
1203 {
1204         int result = 0;
1205         int i;
1206         /*------------------------------------------------------------------------*/
1207
1208         DBG_FUNC( "wvlan_uil_get_info" );
1209         DBG_ENTER( DbgInfo );
1210
1211         if( urq->hcfCtx == &( lp->hcfCtx )) {
1212                 if(( urq->data != NULL ) && ( urq->len != 0 )) {
1213                         ltv_t      *pLtv;
1214                         bool_t      ltvAllocated = FALSE;
1215
1216                         /* Make sure that we have at least a command and length */
1217                         if( urq->len < ( sizeof( hcf_16 ) * 2 )) {
1218                                 urq->len = sizeof( lp->ltvRecord );
1219                                 DBG_ERROR( DbgInfo, "No Length/Type in LTV!!!\n" );
1220                                 DBG_ERROR( DbgInfo, "UIL_ERR_LEN\n" );
1221                                 urq->result = UIL_ERR_LEN;
1222                                 DBG_LEAVE( DbgInfo );
1223                                 return result;
1224                         }
1225
1226                         /* Verify the user's LTV record header. */
1227                         result = verify_area( VERIFY_READ, urq->data, sizeof( hcf_16 ) * 2 );
1228                         if( result != 0 ) {
1229                                 DBG_ERROR( DbgInfo, "verify_area(), VERIFY_READ FAILED\n" );
1230                                 urq->result = UIL_FAILURE;
1231                                 DBG_LEAVE( DbgInfo );
1232                                 return result;
1233                         }
1234
1235                         /* Get only the command and length information. */
1236                         result = copy_from_user( &( lp->ltvRecord ), urq->data, sizeof( hcf_16 ) * 2 );
1237
1238                         /* Make sure the incoming LTV record length is within the bounds of
1239                            the IOCTL length. */
1240                         if((( lp->ltvRecord.len + 1 ) * sizeof( hcf_16 )) > urq->len ) {
1241                                 DBG_ERROR( DbgInfo, "Incoming LTV too big\n" );
1242                                 urq->len = sizeof( lp->ltvRecord );
1243                                 urq->result = UIL_ERR_LEN;
1244                                 DBG_LEAVE( DbgInfo );
1245                                 return result;
1246                         }
1247
1248                         /* Determine if hcf_get_info() is needed or not */
1249                         switch ( lp->ltvRecord.typ ) {
1250                         case CFG_NIC_IDENTITY:
1251                                 memcpy( &lp->ltvRecord.u.u8[0], &lp->NICIdentity, sizeof( lp->NICIdentity ));
1252                                 break;
1253                         case CFG_PRI_IDENTITY:
1254                                 memcpy( &lp->ltvRecord.u.u8[0], &lp->PrimaryIdentity, sizeof( lp->PrimaryIdentity ));
1255                                 break;
1256                         case CFG_AP_MODE:
1257                                 DBG_ERROR( DbgInfo, "set CFG_AP_MODE no longer supported, so is get useful ????\n" );
1258                                 lp->ltvRecord.u.u16[0] =
1259                                         CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP;
1260                                 break;
1261                         //case CFG_DRV_INFO:
1262                         case CFG_ENCRYPT_STRING:
1263                         case CFG_COUNTRY_STRING:
1264                         case CFG_DRIVER_ENABLE:
1265                         case CFG_WOLAS_ENABLE:
1266                                 // TODO: determine if we're going to support these
1267                                 urq->result = UIL_FAILURE;
1268                                 break;
1269                         case CFG_DRV_INFO:
1270                                 DBG_TRACE( DbgInfo, "Intercept CFG_DRV_INFO\n" );
1271                                 result = cfg_driver_info( urq, lp );
1272                                 break;
1273                         case CFG_DRV_IDENTITY:
1274                                 DBG_TRACE( DbgInfo, "Intercept CFG_DRV_IDENTITY\n" );
1275                                 result = cfg_driver_identity( urq, lp );
1276                                 break;
1277                         case CFG_IFB:
1278                                 /* IFB can be a security hole */
1279                                 if( !capable( CAP_NET_ADMIN )) {
1280                                         result = -EPERM;
1281                                         break;
1282                                 }
1283
1284                                 /* Else fall through to the default */
1285
1286                         case CFG_FW_IDENTITY:   // For Hermes-1, this is cached
1287                         default:
1288
1289                                 /* Verify the user buffer */
1290                                 result = verify_area( VERIFY_WRITE, urq->data, urq->len );
1291                                 if( result != 0 ) {
1292                                         DBG_ERROR( DbgInfo, "verify_area(), VERIFY_WRITE FAILED\n" );
1293                                         urq->result = UIL_FAILURE;
1294                                         break;
1295                                 }
1296
1297                                 /* If the requested length is greater than the size of our local
1298                                    LTV record, try to allocate it from the kernel stack.
1299                                    Otherwise, we just use our local LTV record. */
1300                                 if( urq->len > sizeof( lp->ltvRecord )) {
1301                                         pLtv = (ltv_t *)kmalloc( urq->len, GFP_KERNEL );
1302                                         if (pLtv != NULL) {
1303                                                 ltvAllocated = TRUE;
1304
1305                                                 /* Copy the command/length information into the new buffer. */
1306                                                 memcpy( pLtv, &( lp->ltvRecord ), sizeof( hcf_16 ) * 2 );
1307                                         } else {
1308                                                 urq->len = sizeof( lp->ltvRecord );
1309                                                 urq->result = UIL_ERR_LEN;
1310                                                 DBG_ERROR( DbgInfo, "kmalloc FAILED\n" );
1311                                                 DBG_ERROR( DbgInfo, "UIL_ERR_LEN\n" );
1312                                                 result = -ENOMEM;
1313                                                 break;
1314                                         }
1315                                 } else {
1316                                         pLtv = &( lp->ltvRecord );
1317                                 }
1318
1319                                 wl_act_int_off( lp );
1320                                 urq->result = hcf_get_info( &( lp->hcfCtx ), (LTVP) pLtv );
1321                                 wl_act_int_on( lp );
1322
1323                                 // Copy the LTV into the user's buffer.
1324                                 //copy_to_user( urq->data, pLtv, urq->len );
1325
1326                                 //if( ltvAllocated )
1327                                 //{
1328                                 //    kfree( pLtv );
1329                                 //}
1330
1331                                 //urq->result = UIL_SUCCESS;
1332                                 break;
1333                         }
1334
1335                         /* Handle endian conversion of special fields */
1336                         switch( lp->ltvRecord.typ ) {
1337                         /* simple int gets just need the first hcf_16 byte flipped */
1338                         case CFG_CNF_PORT_TYPE:
1339                         case CFG_CNF_OWN_CHANNEL:
1340                         case CFG_CNF_OWN_ATIM_WINDOW:
1341                         case CFG_CNF_SYSTEM_SCALE:
1342                         case CFG_CNF_MAX_DATA_LEN:
1343                         case CFG_CNF_PM_ENABLED:
1344                         case CFG_CNF_MCAST_RX:
1345                         case CFG_CNF_MAX_SLEEP_DURATION:
1346                         case CFG_CNF_HOLDOVER_DURATION:
1347                         case CFG_CNF_OWN_DTIM_PERIOD:
1348                         case CFG_CNF_MCAST_PM_BUF:
1349                         case CFG_CNF_REJECT_ANY:
1350                         case CFG_CNF_ENCRYPTION:
1351                         case CFG_CNF_AUTHENTICATION:
1352                         case CFG_CNF_EXCL_UNENCRYPTED:
1353                         case CFG_CNF_INTRA_BSS_RELAY:
1354                         case CFG_CNF_MICRO_WAVE:
1355                         case CFG_CNF_LOAD_BALANCING:
1356                         case CFG_CNF_MEDIUM_DISTRIBUTION:
1357 #ifdef WARP
1358                         case CFG_CNF_TX_POW_LVL:
1359                         case CFG_CNF_CONNECTION_CNTL:
1360                         case CFG_CNF_OWN_BEACON_INTERVAL:                          // Own Beacon Interval
1361                         case CFG_COEXISTENSE_BEHAVIOUR:                            // Coexistence Behavior
1362                         //case CFG_CNF_RX_ALL_GROUP_ADDRESS:
1363 #endif // HERMES25
1364                         case CFG_CREATE_IBSS:
1365                         case CFG_RTS_THRH:
1366                         case CFG_PROMISCUOUS_MODE:
1367                         //case CFG_WAKE_ON_LAN:
1368                         case CFG_RTS_THRH0:
1369                         case CFG_RTS_THRH1:
1370                         case CFG_RTS_THRH2:
1371                         case CFG_RTS_THRH3:
1372                         case CFG_RTS_THRH4:
1373                         case CFG_RTS_THRH5:
1374                         case CFG_RTS_THRH6:
1375                         case CFG_TX_RATE_CNTL0:
1376                         case CFG_TX_RATE_CNTL1:
1377                         case CFG_TX_RATE_CNTL2:
1378                         case CFG_TX_RATE_CNTL3:
1379                         case CFG_TX_RATE_CNTL4:
1380                         case CFG_TX_RATE_CNTL5:
1381                         case CFG_TX_RATE_CNTL6:
1382                         case CFG_TX_KEY_ID:
1383                         case CFG_TICK_TIME:
1384                         case CFG_MAX_LOAD_TIME:
1385                         case CFG_NIC_TEMP_TYPE:
1386                         case CFG_PORT_STAT:
1387                         case CFG_CUR_TX_RATE:
1388                         case CFG_CUR_BEACON_INTERVAL:
1389                         case CFG_PROTOCOL_RSP_TIME:
1390                         case CFG_CUR_SHORT_RETRY_LIMIT:
1391                         case CFG_CUR_LONG_RETRY_LIMIT:
1392                         case CFG_MAX_TX_LIFETIME:
1393                         case CFG_MAX_RX_LIFETIME:
1394                         case CFG_CF_POLLABLE:
1395                         case CFG_PRIVACY_OPT_IMPLEMENTED:
1396                         //case CFG_CURRENT_REMOTE_RATES:
1397                         //case CFG_CURRENT_USED_RATES:
1398                         //case CFG_CURRENT_SYSTEM_SCALE:
1399                         //case CFG_CURRENT_TX_RATE1:
1400                         //case CFG_CURRENT_TX_RATE2:
1401                         //case CFG_CURRENT_TX_RATE3:
1402                         //case CFG_CURRENT_TX_RATE4:
1403                         //case CFG_CURRENT_TX_RATE5:
1404                         //case CFG_CURRENT_TX_RATE6:
1405                         case CFG_PHY_TYPE:
1406                         case CFG_CUR_CHANNEL:
1407                         //case CFG_CURRENT_POWER_STATE:
1408                         //case CFG_CCAMODE:
1409                         //    lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1410                         //    break;
1411                         /* name string gets just need the first hcf_16 byte flipped (length of string) */
1412                         case CFG_CNF_OWN_SSID:
1413                         case CFG_CNF_OWN_NAME:
1414                         //case CNF_DESIRED_SSID:
1415                         case CFG_DESIRED_SSID:
1416                         case CFG_SCAN_SSID:
1417                         case CFG_CUR_SSID:
1418                                 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1419                                 break;
1420                         /* non-length counted strings need no byte flipping */
1421                         case CFG_CNF_OWN_MAC_ADDR:
1422                         /* this case is no longer valid: CFG_CNF_WDS_ADDR */
1423                         case CFG_CNF_WDS_ADDR1:
1424                         case CFG_CNF_WDS_ADDR2:
1425                         case CFG_CNF_WDS_ADDR3:
1426                         case CFG_CNF_WDS_ADDR4:
1427                         case CFG_CNF_WDS_ADDR5:
1428                         case CFG_CNF_WDS_ADDR6:
1429                         case CFG_GROUP_ADDR:
1430                         case CFG_NIC_SERIAL_NUMBER:
1431                         case CFG_CUR_BSSID:
1432                         case CFG_NIC_MAC_ADDR:
1433                         case CFG_SUPPORTED_DATA_RATES:  /* need to ensure we can treat this as a string */
1434                                 break;
1435                         //case CFG_CNF_COUNTRY_INFO:      /* special case, see page 75  of 022486, Rev C. */
1436                         //case CFG_CURRENT_COUNTRY_INFO:  /* special case, see page 101 of 022486, Rev C. */
1437                         /*
1438                                 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1439                                 lp->ltvRecord.u.u16[3] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[3] );
1440
1441                                 for( i = 4; i < lp->ltvRecord.len; i++ ) {
1442                                         lp->ltvRecord.u.u16[i] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[i] );
1443                                 }
1444                                 break;
1445                         */
1446
1447                         case CFG_DEFAULT_KEYS:
1448                                 {
1449                                         CFG_DEFAULT_KEYS_STRCT *pKeys = (CFG_DEFAULT_KEYS_STRCT *)&lp->ltvRecord.u.u8[0];
1450
1451                                         pKeys[0].len = CNV_INT_TO_LITTLE( pKeys[0].len );
1452                                         pKeys[1].len = CNV_INT_TO_LITTLE( pKeys[1].len );
1453                                         pKeys[2].len = CNV_INT_TO_LITTLE( pKeys[2].len );
1454                                         pKeys[3].len = CNV_INT_TO_LITTLE( pKeys[3].len );
1455                                 }
1456                                 break;
1457                         case CFG_CNF_MCAST_RATE:
1458                         case CFG_TX_RATE_CNTL:
1459                         case CFG_SUPPORTED_RATE_SET_CNTL:    // Supported Rate Set Control
1460                         case CFG_BASIC_RATE_SET_CNTL:    // Basic Rate Set Control
1461                                 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1462                                 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[1] );
1463                                 break;
1464                         case CFG_DL_BUF:
1465                         case CFG_NIC_IDENTITY:
1466                         case CFG_COMMS_QUALITY:
1467                         case CFG_PCF_INFO:
1468                                 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1469                                 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[1] );
1470                                 lp->ltvRecord.u.u16[2] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[2] );
1471                                 break;
1472                         case CFG_FW_IDENTITY:
1473                                 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1474                                 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[1] );
1475                                 lp->ltvRecord.u.u16[2] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[2] );
1476                                 lp->ltvRecord.u.u16[3] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[3] );
1477                                 break;
1478                         //case CFG_HSI_SUP_RANGE:
1479                         case CFG_NIC_MFI_SUP_RANGE:
1480                         case CFG_NIC_CFI_SUP_RANGE:
1481                         case CFG_NIC_PROFILE:
1482                         case CFG_FW_SUP_RANGE:
1483                                 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1484                                 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[1] );
1485                                 lp->ltvRecord.u.u16[2] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[2] );
1486                                 lp->ltvRecord.u.u16[3] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[3] );
1487                                 lp->ltvRecord.u.u16[4] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[4] );
1488                                 break;
1489                         case CFG_MFI_ACT_RANGES_STA:
1490                         case CFG_CFI_ACT_RANGES_STA:
1491                         case CFG_CUR_SCALE_THRH:
1492                         case CFG_AUTHENTICATION_ALGORITHMS:
1493                                 for( i = 0; i < ( lp->ltvRecord.len - 1 ); i++ ) {
1494                                         lp->ltvRecord.u.u16[i] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[i] );
1495                                 }
1496                                 break;
1497                         /* done at init time, and endian handled then */
1498                         case CFG_PRI_IDENTITY:
1499                                 break;
1500                         case CFG_MB_INFO:
1501                                 //wvlanEndianTranslateMailbox( pLtv );
1502                                 break;
1503                         /* MSF and HCF RIDS */
1504                         case CFG_IFB:
1505                         case CFG_DRV_INFO:
1506                         case CFG_AP_MODE:
1507                         case CFG_ENCRYPT_STRING:
1508                         case CFG_COUNTRY_STRING:
1509                         case CFG_DRIVER_ENABLE:
1510                         case CFG_WOLAS_ENABLE:
1511                         default:
1512                                 break;
1513                         }
1514
1515                         // Copy the LTV into the user's buffer.
1516                         copy_to_user( urq->data, &( lp->ltvRecord ), urq->len );
1517
1518                         if( ltvAllocated ) {
1519                                 kfree( &( lp->ltvRecord ));
1520                         }
1521
1522                         urq->result = UIL_SUCCESS;
1523                 } else {
1524                         urq->result = UIL_FAILURE;
1525                 }
1526         } else {
1527                 DBG_ERROR( DbgInfo, "UIL_ERR_WRONG_IFB\n" );
1528                 urq->result = UIL_ERR_WRONG_IFB;
1529         }
1530
1531         DBG_LEAVE( DbgInfo );
1532         return result;
1533 } // wvlan_uil_get_info
1534 /*============================================================================*/
1535
1536
1537
1538
1539
1540 /*******************************************************************************
1541  *      cfg_driver_info()
1542  *******************************************************************************
1543  *
1544  *  DESCRIPTION:
1545  *
1546  *      Retrieves driver information.
1547  *
1548  *  PARAMETERS:
1549  *
1550  *      urq - a pointer to the UIL request buffer
1551  *      lp  - a pointer to the device's private adapter structure
1552  *
1553  *  RETURNS:
1554  *
1555  *      UIL_SUCCESS
1556  *      UIL_ERR_xxx value otherwise
1557  *
1558  ******************************************************************************/
1559 int cfg_driver_info( struct uilreq *urq, struct wl_private *lp )
1560 {
1561         int result = 0;
1562         /*------------------------------------------------------------------------*/
1563
1564
1565         DBG_FUNC( "cfg_driver_info" );
1566         DBG_ENTER( DbgInfo );
1567
1568
1569         /* Make sure that user buffer can handle the driver information buffer */
1570         if( urq->len < sizeof( lp->driverInfo )) {
1571                 urq->len = sizeof( lp->driverInfo );
1572                 urq->result = UIL_ERR_LEN;
1573                 DBG_LEAVE( DbgInfo );
1574                 return result;
1575         }
1576
1577         /* Verify the user buffer. */
1578         result = verify_area( VERIFY_WRITE, urq->data, sizeof( lp->driverInfo ));
1579         if( result != 0 ) {
1580                 urq->result = UIL_FAILURE;
1581                 DBG_LEAVE( DbgInfo );
1582                 return result;
1583         }
1584
1585         lp->driverInfo.card_stat = lp->hcfCtx.IFB_CardStat;
1586
1587         // Copy the driver information into the user's buffer.
1588         urq->result = UIL_SUCCESS;
1589         copy_to_user( urq->data, &( lp->driverInfo ), sizeof( lp->driverInfo ));
1590
1591         DBG_LEAVE( DbgInfo );
1592         return result;
1593 } // cfg_driver_info
1594 /*============================================================================*/
1595
1596
1597
1598
1599 /*******************************************************************************
1600  *      cfg_driver_identity()
1601  *******************************************************************************
1602  *
1603  *  DESCRIPTION:
1604  *
1605  *      Retrieves ID information from the card.
1606  *
1607  *  PARAMETERS:
1608  *
1609  *      urq - a pointer to the UIL request buffer
1610  *      lp  - a pointer to the device's private adapter structure
1611  *
1612  *  RETURNS:
1613  *
1614  *      UIL_SUCCESS
1615  *      UIL_ERR_xxx value otherwise
1616  *
1617  ******************************************************************************/
1618 int cfg_driver_identity( struct uilreq *urq, struct wl_private *lp )
1619 {
1620         int result = 0;
1621         /*------------------------------------------------------------------------*/
1622
1623
1624         DBG_FUNC( "wvlan_driver_identity" );
1625         DBG_ENTER( DbgInfo );
1626
1627
1628         /* Make sure that user buffer can handle the driver identity structure. */
1629         if( urq->len < sizeof( lp->driverIdentity )) {
1630                 urq->len = sizeof( lp->driverIdentity );
1631                 urq->result = UIL_ERR_LEN;
1632                 DBG_LEAVE( DbgInfo );
1633                 return result;
1634         }
1635
1636         /* Verify the user buffer. */
1637         result = verify_area( VERIFY_WRITE, urq->data, sizeof( lp->driverIdentity ));
1638         if( result != 0 ) {
1639                 urq->result = UIL_FAILURE;
1640                 DBG_LEAVE( DbgInfo );
1641                 return result;
1642         }
1643
1644         /* Copy the driver identity into the user's buffer. */
1645         urq->result = UIL_SUCCESS;
1646         copy_to_user( urq->data, &( lp->driverIdentity ), sizeof( lp->driverIdentity ));
1647
1648         DBG_LEAVE( DbgInfo );
1649         return result;
1650 } // cfg_driver_identity
1651 /*============================================================================*/
1652
1653
1654 #endif  /* USE_UIL */
1655
1656
1657 /* If WIRELESS_EXT is not defined, then the functions that follow will not be
1658    included in the build. */
1659 /* NOTE: Are these still even needed? */
1660 #ifdef WIRELESS_EXT
1661
1662
1663 /*******************************************************************************
1664  *      wvlan_set_netname()
1665  *******************************************************************************
1666  *
1667  *  DESCRIPTION:
1668  *
1669  *      Set the ESSID of the card.
1670  *
1671  *  PARAMETERS:
1672  *
1673  *      wrq - a pointer to the wireless request buffer
1674  *      lp  - a pointer to the device's private adapter structure
1675  *
1676  *  RETURNS:
1677  *
1678  *      0 on success
1679  *      errno value otherwise
1680  *
1681  ******************************************************************************/
1682 int wvlan_set_netname(struct net_device *dev,
1683                       struct iw_request_info *info,
1684                       union iwreq_data *wrqu,
1685                       char *extra)
1686 {
1687         struct wl_private *lp = wl_priv(dev);
1688         unsigned long flags;
1689         int ret = 0;
1690         /*------------------------------------------------------------------------*/
1691
1692
1693         DBG_FUNC( "wvlan_set_netname" );
1694         DBG_ENTER( DbgInfo );
1695
1696         wl_lock(lp, &flags);
1697
1698         memset( lp->NetworkName, 0, sizeof( lp->NetworkName ));
1699         memcpy( lp->NetworkName, extra, wrqu->data.length);
1700
1701         /* Commit the adapter parameters */
1702         wl_apply(lp);
1703         wl_unlock(lp, &flags);
1704
1705         DBG_LEAVE( DbgInfo );
1706         return ret;
1707 } // wvlan_set_netname
1708 /*============================================================================*/
1709
1710
1711
1712
1713 /*******************************************************************************
1714  *      wvlan_get_netname()
1715  *******************************************************************************
1716  *
1717  *  DESCRIPTION:
1718  *
1719  *      Get the ESSID of the card.
1720  *
1721  *  PARAMETERS:
1722  *
1723  *      wrq - a pointer to the wireless request buffer
1724  *      lp  - a pointer to the device's private adapter structure
1725  *
1726  *  RETURNS:
1727  *
1728  *      0 on success
1729  *      errno value otherwise
1730  *
1731  ******************************************************************************/
1732 int wvlan_get_netname(struct net_device *dev,
1733                       struct iw_request_info *info,
1734                       union iwreq_data *wrqu,
1735                       char *extra)
1736 {
1737         struct wl_private *lp = wl_priv(dev);
1738         unsigned long flags;
1739         int         ret = 0;
1740         int         status = -1;
1741         wvName_t   *pName;
1742         /*------------------------------------------------------------------------*/
1743
1744
1745         DBG_FUNC( "wvlan_get_netname" );
1746         DBG_ENTER( DbgInfo );
1747
1748         wl_lock(lp, &flags);
1749
1750         /* Get the current network name */
1751         lp->ltvRecord.len = 1 + ( sizeof( *pName ) / sizeof( hcf_16 ));
1752         lp->ltvRecord.typ = CFG_CUR_SSID;
1753
1754         status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1755
1756         if( status == HCF_SUCCESS ) {
1757                 pName = (wvName_t *)&( lp->ltvRecord.u.u32 );
1758
1759                 memset(extra, '\0', HCF_MAX_NAME_LEN);
1760                 wrqu->data.length = pName->length;
1761
1762                 memcpy(extra, pName->name, pName->length);
1763         } else {
1764                 ret = -EFAULT;
1765         }
1766
1767         wl_unlock(lp, &flags);
1768
1769         DBG_LEAVE( DbgInfo );
1770         return ret;
1771 } // wvlan_get_netname
1772 /*============================================================================*/
1773
1774
1775
1776
1777 /*******************************************************************************
1778  *      wvlan_set_station_nickname()
1779  *******************************************************************************
1780  *
1781  *  DESCRIPTION:
1782  *
1783  *      Set the card's station nickname.
1784  *
1785  *  PARAMETERS:
1786  *
1787  *      wrq - a pointer to the wireless request buffer
1788  *      lp  - a pointer to the device's private adapter structure
1789  *
1790  *  RETURNS:
1791  *
1792  *      0 on success
1793  *      errno value otherwise
1794  *
1795  ******************************************************************************/
1796 int wvlan_set_station_nickname(struct net_device *dev,
1797                       struct iw_request_info *info,
1798                       union iwreq_data *wrqu,
1799                       char *extra)
1800 {
1801         struct wl_private *lp = wl_priv(dev);
1802         unsigned long flags;
1803         int         ret = 0;
1804         /*------------------------------------------------------------------------*/
1805
1806
1807         DBG_FUNC( "wvlan_set_station_nickname" );
1808         DBG_ENTER( DbgInfo );
1809
1810         wl_lock(lp, &flags);
1811
1812         memset( lp->StationName, 0, sizeof( lp->StationName ));
1813
1814         memcpy( lp->StationName, extra, wrqu->data.length);
1815
1816         /* Commit the adapter parameters */
1817         wl_apply( lp );
1818         wl_unlock(lp, &flags);
1819
1820         DBG_LEAVE( DbgInfo );
1821         return ret;
1822 } // wvlan_set_station_nickname
1823 /*============================================================================*/
1824
1825
1826
1827
1828 /*******************************************************************************
1829  *      wvlan_get_station_nickname()
1830  *******************************************************************************
1831  *
1832  *  DESCRIPTION:
1833  *
1834  *      Get the card's station nickname.
1835  *
1836  *  PARAMETERS:
1837  *
1838  *      wrq - a pointer to the wireless request buffer
1839  *      lp  - a pointer to the device's private adapter structure
1840  *
1841  *  RETURNS:
1842  *
1843  *      0 on success
1844  *      errno value otherwise
1845  *
1846  ******************************************************************************/
1847 int wvlan_get_station_nickname(struct net_device *dev,
1848                       struct iw_request_info *info,
1849                       union iwreq_data *wrqu,
1850                       char *extra)
1851 {
1852         struct wl_private *lp = wl_priv(dev);
1853         unsigned long flags;
1854         int         ret = 0;
1855         int         status = -1;
1856         wvName_t   *pName;
1857         /*------------------------------------------------------------------------*/
1858
1859
1860         DBG_FUNC( "wvlan_get_station_nickname" );
1861         DBG_ENTER( DbgInfo );
1862
1863         wl_lock( lp, &flags );
1864
1865         /* Get the current station name */
1866         lp->ltvRecord.len = 1 + ( sizeof( *pName ) / sizeof( hcf_16 ));
1867         lp->ltvRecord.typ = CFG_CNF_OWN_NAME;
1868
1869         status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1870
1871         if( status == HCF_SUCCESS ) {
1872                 pName = (wvName_t *)&( lp->ltvRecord.u.u32 );
1873
1874                 memset(extra, '\0', HCF_MAX_NAME_LEN);
1875                 wrqu->data.length = pName->length;
1876                 memcpy(extra, pName->name, pName->length);
1877         } else {
1878                 ret = -EFAULT;
1879         }
1880
1881         wl_unlock(lp, &flags);
1882
1883 //out:
1884         DBG_LEAVE( DbgInfo );
1885         return ret;
1886 } // wvlan_get_station_nickname
1887 /*============================================================================*/
1888
1889
1890
1891
1892 /*******************************************************************************
1893  *      wvlan_set_porttype()
1894  *******************************************************************************
1895  *
1896  *  DESCRIPTION:
1897  *
1898  *      Set the card's porttype
1899  *
1900  *  PARAMETERS:
1901  *
1902  *      wrq - a pointer to the wireless request buffer
1903  *      lp  - a pointer to the device's private adapter structure
1904  *
1905  *  RETURNS:
1906  *
1907  *      0 on success
1908  *      errno value otherwise
1909  *
1910  ******************************************************************************/
1911 int wvlan_set_porttype(struct net_device *dev,
1912                       struct iw_request_info *info,
1913                       union iwreq_data *wrqu,
1914                       char *extra)
1915 {
1916         struct wl_private *lp = wl_priv(dev);
1917         unsigned long flags;
1918         int     ret = 0;
1919         hcf_16  portType;
1920         /*------------------------------------------------------------------------*/
1921
1922
1923         DBG_FUNC( "wvlan_set_porttype" );
1924         DBG_ENTER( DbgInfo );
1925
1926         wl_lock(lp, &flags);
1927
1928         /* Validate the new value */
1929         portType = *((__u32 *)extra);
1930
1931         if( !(( portType == 1 ) || ( portType == 3 ))) {
1932                 ret = -EINVAL;
1933                 goto out_unlock;
1934         }
1935
1936         lp->PortType = portType;
1937
1938         /* Commit the adapter parameters */
1939         wl_apply( lp );
1940
1941 out_unlock:
1942         wl_unlock(lp, &flags);
1943
1944 //out:
1945         DBG_LEAVE( DbgInfo );
1946         return ret;
1947 }
1948
1949 /*============================================================================*/
1950
1951
1952 /*******************************************************************************
1953  *      wvlan_get_porttype()
1954  *******************************************************************************
1955  *
1956  *  DESCRIPTION:
1957  *
1958  *      Get the card's porttype
1959  *
1960  *  PARAMETERS:
1961  *
1962  *      wrq - a pointer to the wireless request buffer
1963  *      lp  - a pointer to the device's private adapter structure
1964  *
1965  *  RETURNS:
1966  *
1967  *      0 on success
1968  *      errno value otherwise
1969  *
1970  ******************************************************************************/
1971 int wvlan_get_porttype(struct net_device *dev,
1972                       struct iw_request_info *info,
1973                       union iwreq_data *wrqu,
1974                       char *extra)
1975 {
1976         struct wl_private *lp = wl_priv(dev);
1977         unsigned long flags;
1978         int     ret = 0;
1979         int     status = -1;
1980         hcf_16  *pPortType;
1981         __u32 *pData = (__u32 *)extra;
1982         /*------------------------------------------------------------------------*/
1983
1984
1985         DBG_FUNC( "wvlan_get_porttype" );
1986         DBG_ENTER( DbgInfo );
1987
1988         wl_lock( lp, &flags );
1989
1990         /* Get the current port type */
1991         lp->ltvRecord.len = 1 + ( sizeof( *pPortType ) / sizeof( hcf_16 ));
1992         lp->ltvRecord.typ = CFG_CNF_PORT_TYPE;
1993
1994         status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1995
1996         if( status == HCF_SUCCESS ) {
1997                 pPortType = (hcf_16 *)&( lp->ltvRecord.u.u32 );
1998
1999                 *pData = CNV_LITTLE_TO_INT( *pPortType );
2000         } else {
2001             ret = -EFAULT;
2002         }
2003
2004         wl_unlock(lp, &flags);
2005
2006 //out:
2007         DBG_LEAVE( DbgInfo );
2008         return ret;
2009 } // wvlan_get_porttype
2010 /*============================================================================*/
2011
2012 #endif  // WIRELESS_EXT
2013
2014
2015
2016
2017 #ifdef USE_RTS
2018 /*******************************************************************************
2019  *      wvlan_rts()
2020  *******************************************************************************
2021  *
2022  *  DESCRIPTION:
2023  *
2024  *      IOCTL handler for RTS commands
2025  *
2026  *  PARAMETERS:
2027  *
2028  *      rrq - a pointer to the rts request buffer
2029  *      lp  - a pointer to the device's private adapter structure
2030  *
2031  *  RETURNS:
2032  *
2033  *      0 on success
2034  *      errno value otherwise
2035  *
2036  ******************************************************************************/
2037 int wvlan_rts( struct rtsreq *rrq, __u32 io_base )
2038 {
2039         int ioctl_ret = 0;
2040         /*------------------------------------------------------------------------*/
2041
2042
2043         DBG_FUNC( "wvlan_rts" );
2044         DBG_ENTER( DbgInfo );
2045
2046
2047         DBG_PRINT( "io_base: 0x%08x\n", io_base );
2048
2049         switch( rrq->typ ) {
2050           case WL_IOCTL_RTS_READ:
2051                 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- WL_IOCTL_RTS_READ\n");
2052                 rrq->data[0] = IN_PORT_WORD( io_base + rrq->reg );
2053                 DBG_TRACE( DbgInfo, "  reg 0x%04x ==> 0x%04x\n", rrq->reg, CNV_LITTLE_TO_SHORT( rrq->data[0] ) );
2054                 break;
2055           case WL_IOCTL_RTS_WRITE:
2056                 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- WL_IOCTL_RTS_WRITE\n");
2057                 OUT_PORT_WORD( io_base + rrq->reg, rrq->data[0] );
2058                 DBG_TRACE( DbgInfo, "  reg 0x%04x <== 0x%04x\n", rrq->reg, CNV_LITTLE_TO_SHORT( rrq->data[0] ) );
2059                 break;
2060           case WL_IOCTL_RTS_BATCH_READ:
2061                 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- WL_IOCTL_RTS_BATCH_READ\n");
2062                 IN_PORT_STRING_16( io_base + rrq->reg, rrq->data, rrq->len );
2063                 DBG_TRACE( DbgInfo, "  reg 0x%04x ==> %d bytes\n", rrq->reg, rrq->len * sizeof (__u16 ) );
2064                 break;
2065           case WL_IOCTL_RTS_BATCH_WRITE:
2066                 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- WL_IOCTL_RTS_BATCH_WRITE\n");
2067                 OUT_PORT_STRING_16( io_base + rrq->reg, rrq->data, rrq->len );
2068                 DBG_TRACE( DbgInfo, "  reg 0x%04x <== %d bytes\n", rrq->reg, rrq->len * sizeof (__u16) );
2069                 break;
2070         default:
2071
2072                 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- UNSUPPORTED RTS CODE: 0x%X", rrq->typ );
2073                 ioctl_ret = -EOPNOTSUPP;
2074                 break;
2075         }
2076
2077         DBG_LEAVE( DbgInfo );
2078         return ioctl_ret;
2079 } // wvlan_rts
2080 /*============================================================================*/
2081
2082 #endif  /* USE_RTS */