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                                         if ((data = kmalloc(urq->len, GFP_KERNEL)) != NULL) {
 507                                                 memset( Descp, 0, sizeof( DESC_STRCT ));
 508                                                 memcpy( data, urq->data, urq->len );
 509
 510                                                 Descp[0].buf_addr       = (wci_bufp)data;
 511                                                 Descp[0].BUF_CNT        = urq->len;
 512                                                 Descp[0].next_desc_addr = 0;    // terminate list
 513
 514                                                 hcf_send_msg( &(lp->hcfCtx),  &Descp[0], HCF_PORT_0 );
 515                                                 kfree( data );
 516                                         } else {
 517                                                 DBG_ERROR( DbgInfo, "ENOMEM\n" );
 518                                                 urq->result = UIL_FAILURE;
 519                                                 result = -ENOMEM;
 520                                                 DBG_LEAVE( DbgInfo );
 521                                                 return result;
 522                                         }
 523
 524                                 } else {
 525                                         urq->result = UIL_ERR_BUSY;
 526                                 }
 527
 528                         } else {
 529                                 urq->result = UIL_FAILURE;
 530                         }
 531                 } else {
 532                         DBG_ERROR( DbgInfo, "EPERM\n" );
 533                         urq->result = UIL_FAILURE;
 534                         result = -EPERM;
 535                 }
 536         } else {
 537                 DBG_ERROR( DbgInfo, "UIL_ERR_WRONG_IFB\n" );
 538                 urq->result = UIL_ERR_WRONG_IFB;
 539         }
 540
 541         DBG_LEAVE( DbgInfo );
 542         return result;
 543 } // wvlan_uil_send_diag_msg
 544 /*============================================================================*/
 545
 546
 547 /*******************************************************************************
 548  *      wvlan_uil_put_info()
 549  *******************************************************************************
 550  *
 551  *  DESCRIPTION:
 552  *
 553  *      Sends a specific RID directly to the driver to set configuration info.
 554  *
 555  *  PARAMETERS:
 556  *
 557  *      urq - a pointer to the UIL request buffer
 558  *      lp  - a pointer to the device's private adapter structure
 559  *
 560  *  RETURNS:
 561  *
 562  *      UIL_SUCCESS
 563  *      UIL_ERR_xxx value otherwise
 564  *
 565  ******************************************************************************/
 566 int wvlan_uil_put_info( struct uilreq *urq, struct wl_private *lp )
 567 {
 568         int                     result = 0;
 569         ltv_t                   *pLtv;
 570         bool_t                  ltvAllocated = FALSE;
 571         ENCSTRCT                sEncryption;
 572
 573 #ifdef USE_WDS
 574         hcf_16                  hcfPort  = HCF_PORT_0;
 575 #endif  /* USE_WDS */
 576         /*------------------------------------------------------------------------*/
 577         DBG_FUNC( "wvlan_uil_put_info" );
 578         DBG_ENTER( DbgInfo );
 579
 580
 581         if( urq->hcfCtx == &( lp->hcfCtx )) {
 582                 if( capable( CAP_NET_ADMIN )) {
 583                         if(( urq->data != NULL ) && ( urq->len != 0 )) {
 584                                 /* Make sure that we have at least a command and length to send. */
 585                                 if( urq->len < ( sizeof( hcf_16 ) * 2 )) {
 586                                         urq->len = sizeof( lp->ltvRecord );
 587                                         urq->result = UIL_ERR_LEN;
 588                                         DBG_ERROR( DbgInfo, "No Length/Type in LTV!!!\n" );
 589                                         DBG_ERROR( DbgInfo, "UIL_ERR_LEN\n" );
 590                                         DBG_LEAVE( DbgInfo );
 591                                         return result;
 592                                 }
 593
 594                                 /* Verify the user buffer */
 595                                 result = verify_area( VERIFY_READ, urq->data, urq->len );
 596                                 if( result != 0 ) {
 597                                         urq->result = UIL_FAILURE;
 598                                         DBG_ERROR( DbgInfo, "verify_area(), VERIFY_READ FAILED\n" );
 599                                         DBG_LEAVE( DbgInfo );
 600                                         return result;
 601                                 }
 602
 603                                 /* Get only the command and length information. */
 604                                 copy_from_user( &( lp->ltvRecord ), urq->data, sizeof( hcf_16 ) * 2 );
 605
 606                                 /* Make sure the incoming LTV record length is within the bounds of the
 607                                    IOCTL length */
 608                                 if((( lp->ltvRecord.len + 1 ) * sizeof( hcf_16 )) > urq->len ) {
 609                                         urq->len = sizeof( lp->ltvRecord );
 610                                         urq->result = UIL_ERR_LEN;
 611                                         DBG_ERROR( DbgInfo, "UIL_ERR_LEN\n" );
 612                                         DBG_LEAVE( DbgInfo );
 613                                         return result;
 614                                 }
 615
 616                                 /* If the requested length is greater than the size of our local
 617                                    LTV record, try to allocate it from the kernel stack.
 618                                    Otherwise, we just use our local LTV record. */
 619                                 if( urq->len > sizeof( lp->ltvRecord )) {
 620                                         if(( pLtv = (ltv_t *)kmalloc( urq->len, GFP_KERNEL )) != NULL ) {
 621                                                 ltvAllocated = TRUE;
 622                                         } else {
 623                                                 DBG_ERROR( DbgInfo, "Alloc FAILED\n" );
 624                                                 urq->len = sizeof( lp->ltvRecord );
 625                                                 urq->result = UIL_ERR_LEN;
 626                                                 result = -ENOMEM;
 627                                                 DBG_LEAVE( DbgInfo );
 628                                                 return result;
 629                                         }
 630                                 } else {
 631                                         pLtv = &( lp->ltvRecord );
 632                                 }
 633
 634                                 /* Copy the data from the user's buffer into the local LTV
 635                                    record data area. */
 636                                 copy_from_user( pLtv, urq->data, urq->len );
 637
 638
 639                                 /* We need to snoop the commands to see if there is anything we
 640                                    need to store for the purposes of a reset or start/stop
 641                                    sequence. Perform endian translation as needed */
 642                                 switch( pLtv->typ ) {
 643                                 case CFG_CNF_PORT_TYPE:
 644                                         lp->PortType    = pLtv->u.u16[0];
 645                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 646                                         break;
 647                                 case CFG_CNF_OWN_MAC_ADDR:
 648                                         /* TODO: determine if we are going to store anything based on this */
 649                                         break;
 650                                 case CFG_CNF_OWN_CHANNEL:
 651                                         lp->Channel     = pLtv->u.u16[0];
 652                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 653                                         break;
 654                                 /* CFG_CNF_OWN_SSID currently same as CNF_DESIRED_SSID. Do we
 655                                    need seperate storage for this? */
 656                                 //case CFG_CNF_OWN_SSID:
 657                                 case CFG_CNF_OWN_ATIM_WINDOW:
 658                                         lp->atimWindow  = pLtv->u.u16[0];
 659                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 660                                         break;
 661                                 case CFG_CNF_SYSTEM_SCALE:
 662                                         lp->DistanceBetweenAPs  = pLtv->u.u16[0];
 663                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 664
 665                                 case CFG_CNF_MAX_DATA_LEN:
 666                                         /* TODO: determine if we are going to store anything based
 667                                            on this */
 668                                         break;
 669                                 case CFG_CNF_PM_ENABLED:
 670                                         lp->PMEnabled   = pLtv->u.u16[0];
 671                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 672                                         break;
 673                                 case CFG_CNF_MCAST_RX:
 674                                         lp->MulticastReceive    = pLtv->u.u16[0];
 675                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 676                                         break;
 677                                 case CFG_CNF_MAX_SLEEP_DURATION:
 678                                         lp->MaxSleepDuration    = pLtv->u.u16[0];
 679                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 680                                         break;
 681                                 case CFG_CNF_HOLDOVER_DURATION:
 682                                         lp->holdoverDuration    = pLtv->u.u16[0];
 683                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 684                                         break;
 685                                 case CFG_CNF_OWN_NAME:
 686                                         memset( lp->StationName, 0, sizeof( lp->StationName ));
 687                                         memcpy( (void *)lp->StationName, (void *)&pLtv->u.u8[2], (size_t)pLtv->u.u16[0]);
 688                                         pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 689                                         break;
 690                                 case CFG_CNF_LOAD_BALANCING:
 691                                         lp->loadBalancing       = pLtv->u.u16[0];
 692                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 693                                         break;
 694                                 case CFG_CNF_MEDIUM_DISTRIBUTION:
 695                                         lp->mediumDistribution  = pLtv->u.u16[0];
 696                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 697                                         break;
 698 #ifdef WARP
 699                                 case CFG_CNF_TX_POW_LVL:
 700                                         lp->txPowLevel          = pLtv->u.u16[0];
 701                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 702                                         break;
 703                                 //case CFG_CNF_SHORT_RETRY_LIMIT:    // Short Retry Limit
 704                                 //case 0xFC33:    // Long Retry Limit
 705                                 case CFG_SUPPORTED_RATE_SET_CNTL:        // Supported Rate Set Control
 706                                         lp->srsc[0]             = pLtv->u.u16[0];
 707                                         lp->srsc[1]             = pLtv->u.u16[1];
 708                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 709                                         pLtv->u.u16[1]          = CNV_INT_TO_LITTLE( pLtv->u.u16[1] );
 710                                         break;
 711                                 case CFG_BASIC_RATE_SET_CNTL:        // Basic Rate Set Control
 712                                         lp->brsc[0]             = pLtv->u.u16[0];
 713                                         lp->brsc[1]             = pLtv->u.u16[1];
 714                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 715                                         pLtv->u.u16[1]          = CNV_INT_TO_LITTLE( pLtv->u.u16[1] );
 716                                         break;
 717                                 case CFG_CNF_CONNECTION_CNTL:
 718                                         lp->connectionControl   = pLtv->u.u16[0];
 719                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 720                                         break;
 721                                 //case CFG_PROBE_DATA_RATE:
 722 #endif  // HERMES25
 723
 724 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
 725                 //;?should we restore this to allow smaller memory footprint
 726
 727                                 case CFG_CNF_OWN_DTIM_PERIOD:
 728                                         lp->DTIMPeriod  = pLtv->u.u16[0];
 729                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 730                                         break;
 731 #ifdef WARP
 732                                 case CFG_CNF_OWN_BEACON_INTERVAL:        // Own Beacon Interval
 733                                         lp->ownBeaconInterval   = pLtv->u.u16[0];
 734                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 735                                         break;
 736 #endif // WARP
 737                                 case CFG_COEXISTENSE_BEHAVIOUR:         // Coexistence behavior
 738                                         lp->coexistence         = pLtv->u.u16[0];
 739                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 740                                         break;
 741 #ifdef USE_WDS
 742                                 case CFG_CNF_WDS_ADDR1:
 743                                         memcpy( &lp->wds_port[0].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
 744                                         hcfPort = HCF_PORT_1;
 745                                         break;
 746                                 case CFG_CNF_WDS_ADDR2:
 747                                         memcpy( &lp->wds_port[1].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
 748                                         hcfPort = HCF_PORT_2;
 749                                         break;
 750                                 case CFG_CNF_WDS_ADDR3:
 751                                         memcpy( &lp->wds_port[2].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
 752                                         hcfPort = HCF_PORT_3;
 753                                         break;
 754                                 case CFG_CNF_WDS_ADDR4:
 755                                         memcpy( &lp->wds_port[3].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
 756                                         hcfPort = HCF_PORT_4;
 757                                         break;
 758                                 case CFG_CNF_WDS_ADDR5:
 759                                         memcpy( &lp->wds_port[4].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
 760                                         hcfPort = HCF_PORT_5;
 761                                         break;
 762                                 case CFG_CNF_WDS_ADDR6:
 763                                         memcpy( &lp->wds_port[5].wdsAddress, &pLtv->u.u8[0], ETH_ALEN );
 764                                         hcfPort = HCF_PORT_6;
 765                                         break;
 766 #endif  /* USE_WDS */
 767
 768                                 case CFG_CNF_MCAST_PM_BUF:
 769                                         lp->multicastPMBuffering    = pLtv->u.u16[0];
 770                                         pLtv->u.u16[0]              = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 771                                         break;
 772                                 case CFG_CNF_REJECT_ANY:
 773                                         lp->RejectAny   = pLtv->u.u16[0];
 774                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 775                                         break;
 776 #endif
 777
 778                                 case CFG_CNF_ENCRYPTION:
 779                                         lp->EnableEncryption    = pLtv->u.u16[0];
 780                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 781                                         break;
 782                                 case CFG_CNF_AUTHENTICATION:
 783                                         lp->authentication  = pLtv->u.u16[0];
 784                                         pLtv->u.u16[0]      = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 785                                         break;
 786 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
 787                 //;?should we restore this to allow smaller memory footprint
 788
 789                                 //case CFG_CNF_EXCL_UNENCRYPTED:
 790                                         //lp->ExcludeUnencrypted  = pLtv->u.u16[0];
 791                                         //pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 792                                         //break;
 793                                 case CFG_CNF_MCAST_RATE:
 794                                         /* TODO: determine if we are going to store anything based on this */
 795                                         break;
 796                                 case CFG_CNF_INTRA_BSS_RELAY:
 797                                         lp->intraBSSRelay   = pLtv->u.u16[0];
 798                                         pLtv->u.u16[0]      = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 799                                         break;
 800 #endif
 801
 802                                 case CFG_CNF_MICRO_WAVE:
 803                                         /* TODO: determine if we are going to store anything based on this */
 804                                         break;
 805                                 //case CFG_CNF_LOAD_BALANCING:
 806                                         /* TODO: determine if we are going to store anything based on this */
 807                                         //break;
 808                                 //case CFG_CNF_MEDIUM_DISTRIBUTION:
 809                                         /* TODO: determine if we are going to store anything based on this */
 810                                         //break;
 811                                 //case CFG_CNF_RX_ALL_GROUP_ADDRESS:
 812                                         // TODO: determine if we are going to store anything based on this
 813                                         //break;
 814                                 //case CFG_CNF_COUNTRY_INFO:
 815                                         /* TODO: determine if we are going to store anything based on this */
 816                                         //break;
 817                                 case CFG_CNF_OWN_SSID:
 818                                 //case CNF_DESIRED_SSID:
 819                                 case CFG_DESIRED_SSID:
 820                                         memset( lp->NetworkName, 0, sizeof( lp->NetworkName ));
 821                                         memcpy( (void *)lp->NetworkName, (void *)&pLtv->u.u8[2], (size_t)pLtv->u.u16[0] );
 822                                         pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 823
 824                                         /* take care of the special network name "ANY" case */
 825                                         if(( strlen( &pLtv->u.u8[2]        ) == 0 ) ||
 826                                            ( strcmp( &pLtv->u.u8[2], "ANY" ) == 0 ) ||
 827                                            ( strcmp( &pLtv->u.u8[2], "any" ) == 0 )) {
 828                                                 /* set the SSID_STRCT llen field (u16[0]) to zero, and the
 829                                                 effectually null the string u8[2] */
 830                                                 pLtv->u.u16[0] = 0;
 831                                                 pLtv->u.u8[2]  = 0;
 832                                         }
 833                                         break;
 834                                 case CFG_GROUP_ADDR:
 835                                         /* TODO: determine if we are going to store anything based on this */
 836                                         break;
 837                                 case CFG_CREATE_IBSS:
 838                                         lp->CreateIBSS  = pLtv->u.u16[0];
 839                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 840                                         break;
 841                                 case CFG_RTS_THRH:
 842                                         lp->RTSThreshold    = pLtv->u.u16[0];
 843                                         pLtv->u.u16[0]      = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 844                                         break;
 845                                 case CFG_TX_RATE_CNTL:
 846                                         lp->TxRateControl[0]    = pLtv->u.u16[0];
 847                                         lp->TxRateControl[1]    = pLtv->u.u16[1];
 848                                         pLtv->u.u16[0]          = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 849                                         pLtv->u.u16[1]          = CNV_INT_TO_LITTLE( pLtv->u.u16[1] );
 850                                         break;
 851                                 case CFG_PROMISCUOUS_MODE:
 852                                         /* TODO: determine if we are going to store anything based on this */
 853                                         break;
 854                                 //case CFG_WAKE_ON_LAN:
 855                                         /* TODO: determine if we are going to store anything based on this */
 856                                         //break;
 857 #if 1 //;? #if (HCF_TYPE) & HCF_TYPE_AP
 858                 //;?should we restore this to allow smaller memory footprint
 859                                 case CFG_RTS_THRH0:
 860                                         lp->RTSThreshold    = pLtv->u.u16[0];
 861                                         pLtv->u.u16[0]      = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 862                                         break;
 863                                 case CFG_TX_RATE_CNTL0:
 864 //;?no idea what this should be, get going so comment it out                                    lp->TxRateControl   = pLtv->u.u16[0];
 865                                         pLtv->u.u16[0]      = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 866                                         break;
 867 #ifdef USE_WDS
 868                                 case CFG_RTS_THRH1:
 869                                         lp->wds_port[0].rtsThreshold    = pLtv->u.u16[0];
 870                                         pLtv->u.u16[0]                  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 871                                         hcfPort                         = HCF_PORT_1;
 872                                         break;
 873                                 case CFG_RTS_THRH2:
 874                                         lp->wds_port[1].rtsThreshold    = pLtv->u.u16[0];
 875                                         pLtv->u.u16[0]                  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 876                                         hcfPort                         = HCF_PORT_2;
 877                                         break;
 878                                 case CFG_RTS_THRH3:
 879                                         lp->wds_port[2].rtsThreshold    = pLtv->u.u16[0];
 880                                         pLtv->u.u16[0]                  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 881                                         hcfPort                         = HCF_PORT_3;
 882                                         break;
 883                                 case CFG_RTS_THRH4:
 884                                         lp->wds_port[3].rtsThreshold    = pLtv->u.u16[0];
 885                                         pLtv->u.u16[0]                  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 886                                         hcfPort                         = HCF_PORT_4;
 887                                         break;
 888                                 case CFG_RTS_THRH5:
 889                                         lp->wds_port[4].rtsThreshold    = pLtv->u.u16[0];
 890                                         pLtv->u.u16[0]                  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 891                                         hcfPort                         = HCF_PORT_5;
 892                                         break;
 893                                 case CFG_RTS_THRH6:
 894                                         lp->wds_port[5].rtsThreshold    = pLtv->u.u16[0];
 895                                         pLtv->u.u16[0]                  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 896                                         hcfPort                         = HCF_PORT_6;
 897                                         break;
 898                                 case CFG_TX_RATE_CNTL1:
 899                                         lp->wds_port[0].txRateCntl  = pLtv->u.u16[0];
 900                                         pLtv->u.u16[0]              = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 901                                         hcfPort                     = HCF_PORT_1;
 902                                         break;
 903                                 case CFG_TX_RATE_CNTL2:
 904                                         lp->wds_port[1].txRateCntl  = pLtv->u.u16[0];
 905                                         pLtv->u.u16[0]              = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 906                                         hcfPort                     = HCF_PORT_2;
 907                                         break;
 908                                 case CFG_TX_RATE_CNTL3:
 909                                         lp->wds_port[2].txRateCntl  = pLtv->u.u16[0];
 910                                         pLtv->u.u16[0]              = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 911                                         hcfPort                     = HCF_PORT_3;
 912                                         break;
 913                                 case CFG_TX_RATE_CNTL4:
 914                                         lp->wds_port[3].txRateCntl  = pLtv->u.u16[0];
 915                                         pLtv->u.u16[0]              = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 916                                         hcfPort                     = HCF_PORT_4;
 917                                         break;
 918                                 case CFG_TX_RATE_CNTL5:
 919                                         lp->wds_port[4].txRateCntl  = pLtv->u.u16[0];
 920                                         pLtv->u.u16[0]              = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 921                                         hcfPort                     = HCF_PORT_5;
 922                                         break;
 923                                 case CFG_TX_RATE_CNTL6:
 924                                         lp->wds_port[5].txRateCntl  = pLtv->u.u16[0];
 925                                         pLtv->u.u16[0]              = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 926                                         hcfPort                     = HCF_PORT_6;
 927                                         break;
 928 #endif  /* USE_WDS */
 929 #endif  /* (HCF_TYPE) & HCF_TYPE_AP */
 930
 931                                 case CFG_DEFAULT_KEYS:
 932                                         {
 933                                                 CFG_DEFAULT_KEYS_STRCT *pKeys = (CFG_DEFAULT_KEYS_STRCT *)pLtv;
 934
 935                                                 pKeys->key[0].len = CNV_INT_TO_LITTLE( pKeys->key[0].len );
 936                                                 pKeys->key[1].len = CNV_INT_TO_LITTLE( pKeys->key[1].len );
 937                                                 pKeys->key[2].len = CNV_INT_TO_LITTLE( pKeys->key[2].len );
 938                                                 pKeys->key[3].len = CNV_INT_TO_LITTLE( pKeys->key[3].len );
 939
 940                                                 memcpy( (void *)&(lp->DefaultKeys), (void *)pKeys,
 941                                                                 sizeof( CFG_DEFAULT_KEYS_STRCT ));
 942                                         }
 943                                         break;
 944                                 case CFG_TX_KEY_ID:
 945                                         lp->TransmitKeyID   = pLtv->u.u16[0];
 946                                         pLtv->u.u16[0]      = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
 947                                         break;
 948                                 case CFG_SCAN_SSID:
 949                                         /* TODO: determine if we are going to store anything based on this */
 950                                         break;
 951                                 case CFG_TICK_TIME:
 952                                         /* TODO: determine if we are going to store anything based on this */
 953                                         break;
 954                                 /* these RIDS are Info RIDs, and should they be allowed for puts??? */
 955                                 case CFG_MAX_LOAD_TIME:
 956                                 case CFG_DL_BUF:
 957                                 //case CFG_HSI_SUP_RANGE:
 958                                 case CFG_NIC_SERIAL_NUMBER:
 959                                 case CFG_NIC_IDENTITY:
 960                                 case CFG_NIC_MFI_SUP_RANGE:
 961                                 case CFG_NIC_CFI_SUP_RANGE:
 962                                 case CFG_NIC_TEMP_TYPE:
 963                                 case CFG_NIC_PROFILE:
 964                                 case CFG_FW_IDENTITY:
 965                                 case CFG_FW_SUP_RANGE:
 966                                 case CFG_MFI_ACT_RANGES_STA:
 967                                 case CFG_CFI_ACT_RANGES_STA:
 968                                 case CFG_PORT_STAT:
 969                                 case CFG_CUR_SSID:
 970                                 case CFG_CUR_BSSID:
 971                                 case CFG_COMMS_QUALITY:
 972                                 case CFG_CUR_TX_RATE:
 973                                 case CFG_CUR_BEACON_INTERVAL:
 974                                 case CFG_CUR_SCALE_THRH:
 975                                 case CFG_PROTOCOL_RSP_TIME:
 976                                 case CFG_CUR_SHORT_RETRY_LIMIT:
 977                                 case CFG_CUR_LONG_RETRY_LIMIT:
 978                                 case CFG_MAX_TX_LIFETIME:
 979                                 case CFG_MAX_RX_LIFETIME:
 980                                 case CFG_CF_POLLABLE:
 981                                 case CFG_AUTHENTICATION_ALGORITHMS:
 982                                 case CFG_PRIVACY_OPT_IMPLEMENTED:
 983                                 //case CFG_CURRENT_REMOTE_RATES:
 984                                 //case CFG_CURRENT_USED_RATES:
 985                                 //case CFG_CURRENT_SYSTEM_SCALE:
 986                                 //case CFG_CURRENT_TX_RATE1:
 987                                 //case CFG_CURRENT_TX_RATE2:
 988                                 //case CFG_CURRENT_TX_RATE3:
 989                                 //case CFG_CURRENT_TX_RATE4:
 990                                 //case CFG_CURRENT_TX_RATE5:
 991                                 //case CFG_CURRENT_TX_RATE6:
 992                                 case CFG_NIC_MAC_ADDR:
 993                                 case CFG_PCF_INFO:
 994                                 //case CFG_CURRENT_COUNTRY_INFO:
 995                                 case CFG_PHY_TYPE:
 996                                 case CFG_CUR_CHANNEL:
 997                                 //case CFG_CURRENT_POWER_STATE:
 998                                 //case CFG_CCAMODE:
 999                                 case CFG_SUPPORTED_DATA_RATES:
1000                                         break;
1001                                 case CFG_AP_MODE:
1002 //;?                            lp->DownloadFirmware = ( pLtv->u.u16[0] ) + 1;
1003                                         DBG_ERROR( DbgInfo, "set CFG_AP_MODE no longer supported\n" );
1004                                         break;
1005                                 case CFG_ENCRYPT_STRING:
1006                                         /* TODO: ENDIAN TRANSLATION HERE??? */
1007                                         memset( lp->szEncryption, 0, sizeof( lp->szEncryption ));
1008                                         memcpy( (void *)lp->szEncryption,  (void *)&pLtv->u.u8[0],
1009                                                         ( pLtv->len * sizeof( hcf_16 )) );
1010                                         wl_wep_decode( CRYPT_CODE, &sEncryption,
1011                                                                     lp->szEncryption );
1012
1013                                         /* the Linux driver likes to use 1-4 for the key IDs, and then
1014                                         convert to 0-3 when sending to the card.  The Windows code
1015                                         base used 0-3 in the API DLL, which was ported to Linux.  For
1016                                         the sake of the user experience, we decided to keep 0-3 as the
1017                                         numbers used in the DLL; and will perform the +1 conversion here.
1018                                         We could have converted  the entire Linux driver, but this is
1019                                         less obtrusive.  This may be a "todo" to convert the whole driver */
1020                                         lp->TransmitKeyID    = sEncryption.wTxKeyID + 1;
1021                                         lp->EnableEncryption = sEncryption.wEnabled;
1022
1023                                         memcpy( &lp->DefaultKeys, &sEncryption.EncStr,
1024                                                         sizeof( CFG_DEFAULT_KEYS_STRCT ));
1025                                         break;
1026                                 /*case CFG_COUNTRY_STRING:
1027                                         memset( lp->countryString, 0, sizeof( lp->countryString ));
1028                                         memcpy( (void *)lp->countryString, (void *)&pLtv->u.u8[2], (size_t)pLtv->u.u16[0]);
1029                                         break;
1030                                 */
1031
1032                                 case CFG_DRIVER_ENABLE:
1033                                         lp->driverEnable    = pLtv->u.u16[0];
1034                                         pLtv->u.u16[0]      = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
1035                                         break;
1036                                 case CFG_WOLAS_ENABLE:
1037                                         lp->wolasEnable = pLtv->u.u16[0];
1038                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
1039                                         break;
1040                                 case CFG_SET_WPA_AUTH_KEY_MGMT_SUITE:
1041                                         lp->AuthKeyMgmtSuite = pLtv->u.u16[0];
1042                                         pLtv->u.u16[0]  = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
1043                                         break;
1044                                 case CFG_DISASSOCIATE_ADDR:
1045                                         pLtv->u.u16[ETH_ALEN / 2] = CNV_INT_TO_LITTLE( pLtv->u.u16[ETH_ALEN / 2] );
1046                                         break;
1047                                 case CFG_ADD_TKIP_DEFAULT_KEY:
1048                                 case CFG_REMOVE_TKIP_DEFAULT_KEY:
1049                                         /* Endian convert the Tx Key Information */
1050                                         pLtv->u.u16[0] = CNV_INT_TO_LITTLE( pLtv->u.u16[0] );
1051                                         break;
1052                                 case CFG_ADD_TKIP_MAPPED_KEY:
1053                                         break;
1054                                 case CFG_REMOVE_TKIP_MAPPED_KEY:
1055                                         break;
1056                                 /* some RIDs just can't be put */
1057                                 case CFG_MB_INFO:
1058                                 case CFG_IFB:
1059                                 default:
1060                                         break;
1061                                 }
1062
1063                                 /* This code will prevent Static Configuration Entities from
1064                                    being sent to the card, as they require a call to
1065                                    UIL_ACT_APPLY to take effect. Dynamic Entities will be sent
1066                                    immediately */
1067                                 switch( pLtv->typ ) {
1068                                 case CFG_CNF_PORT_TYPE:
1069                                 case CFG_CNF_OWN_MAC_ADDR:
1070                                 case CFG_CNF_OWN_CHANNEL:
1071                                 case CFG_CNF_OWN_SSID:
1072                                 case CFG_CNF_OWN_ATIM_WINDOW:
1073                                 case CFG_CNF_SYSTEM_SCALE:
1074                                 case CFG_CNF_MAX_DATA_LEN:
1075                                 case CFG_CNF_PM_ENABLED:
1076                                 case CFG_CNF_MCAST_RX:
1077                                 case CFG_CNF_MAX_SLEEP_DURATION:
1078                                 case CFG_CNF_HOLDOVER_DURATION:
1079                                 case CFG_CNF_OWN_NAME:
1080                                 case CFG_CNF_LOAD_BALANCING:
1081                                 case CFG_CNF_MEDIUM_DISTRIBUTION:
1082 #ifdef WARP
1083                                 case CFG_CNF_TX_POW_LVL:
1084                                 case CFG_CNF_CONNECTION_CNTL:
1085                                 //case CFG_PROBE_DATA_RATE:
1086 #endif // HERMES25
1087 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
1088                 //;?should we restore this to allow smaller memory footprint
1089                                 case CFG_CNF_OWN_DTIM_PERIOD:
1090 #ifdef WARP
1091                                 case CFG_CNF_OWN_BEACON_INTERVAL:                    // Own Beacon Interval
1092 #endif // WARP
1093 #ifdef USE_WDS
1094                                 case CFG_CNF_WDS_ADDR1:
1095                                 case CFG_CNF_WDS_ADDR2:
1096                                 case CFG_CNF_WDS_ADDR3:
1097                                 case CFG_CNF_WDS_ADDR4:
1098                                 case CFG_CNF_WDS_ADDR5:
1099                                 case CFG_CNF_WDS_ADDR6:
1100 #endif
1101                                 case CFG_CNF_MCAST_PM_BUF:
1102                                 case CFG_CNF_REJECT_ANY:
1103 #endif
1104
1105                                 case CFG_CNF_ENCRYPTION:
1106                                 case CFG_CNF_AUTHENTICATION:
1107 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
1108                 //;?should we restore this to allow smaller memory footprint
1109
1110                                 case CFG_CNF_EXCL_UNENCRYPTED:
1111                                 case CFG_CNF_MCAST_RATE:
1112                                 case CFG_CNF_INTRA_BSS_RELAY:
1113 #endif
1114
1115                                 case CFG_CNF_MICRO_WAVE:
1116                                 //case CFG_CNF_LOAD_BALANCING:
1117                                 //case CFG_CNF_MEDIUM_DISTRIBUTION:
1118                                 //case CFG_CNF_RX_ALL_GROUP_ADDRESS:
1119                                 //case CFG_CNF_COUNTRY_INFO:
1120                                 //case CFG_COUNTRY_STRING:
1121                                 case CFG_AP_MODE:
1122                                 case CFG_ENCRYPT_STRING:
1123                                 //case CFG_DRIVER_ENABLE:
1124                                 case CFG_WOLAS_ENABLE:
1125                                 case CFG_MB_INFO:
1126                                 case CFG_IFB:
1127                                         break;
1128                                 /* Deal with this dynamic MSF RID, as it's required for WPA */
1129                                 case CFG_DRIVER_ENABLE:
1130                                         if( lp->driverEnable ) {
1131                                                 //hcf_cntl_port( &( lp->hcfCtx ),
1132                                                 //               HCF_PORT_ENABLE | HCF_PORT_0 );
1133                                                 // //hcf_cntl( &( lp->hcfCtx ),
1134                                                 // //         HCF_PORT_ENABLE | HCF_PORT_0 );
1135                                                 //hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_ENABLE );
1136                                                 // //hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_CONNECT );
1137
1138                                                 hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_ENABLE | HCF_PORT_0 );
1139                                                 hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_CONNECT );
1140                                         } else {
1141                                                 //hcf_cntl_port( &( lp->hcfCtx ),
1142                                                 //               HCF_PORT_DISABLE | HCF_PORT_0 );
1143                                                 // //hcf_cntl( &( lp->hcfCtx ),
1144                                                 // //         HCF_PORT_DISABLE | HCF_PORT_0 );
1145                                                 //hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_DISABLE );
1146                                                 // //hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_DISCONNECT );
1147
1148                                                 hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_DISABLE | HCF_PORT_0 );
1149                                                 hcf_cntl( &( lp->hcfCtx ), HCF_CNTL_DISCONNECT );
1150                                         }
1151                                         break;
1152                                 default:
1153                                         wl_act_int_off( lp );
1154                                         urq->result = hcf_put_info(&(lp->hcfCtx), (LTVP) pLtv);
1155                                         wl_act_int_on( lp );
1156                                         break;
1157                                 }
1158
1159                                 if( ltvAllocated ) {
1160                                         kfree( pLtv );
1161                                 }
1162                         } else {
1163                                 urq->result = UIL_FAILURE;
1164                         }
1165                 } else {
1166                         DBG_ERROR( DbgInfo, "EPERM\n" );
1167                         urq->result = UIL_FAILURE;
1168                         result = -EPERM;
1169                 }
1170         } else {
1171                 DBG_ERROR( DbgInfo, "UIL_ERR_WRONG_IFB\n" );
1172                 urq->result = UIL_ERR_WRONG_IFB;
1173         }
1174
1175         DBG_LEAVE( DbgInfo );
1176         return result;
1177 } // wvlan_uil_put_info
1178 /*============================================================================*/
1179
1180 /*******************************************************************************
1181  *      wvlan_uil_get_info()
1182  *******************************************************************************
1183  *
1184  *  DESCRIPTION:
1185  *
1186  *      Sends a specific RID directly to the driver to retrieve configuration
1187  *      info.
1188  *
1189  *  PARAMETERS:
1190  *
1191  *      urq - a pointer to the UIL request buffer
1192  *      lp  - a pointer to the device's private adapter structure
1193  *
1194  *  RETURNS:
1195  *
1196  *      UIL_SUCCESS
1197  *      UIL_ERR_xxx value otherwise
1198  *
1199  ******************************************************************************/
1200 int wvlan_uil_get_info( struct uilreq *urq, struct wl_private *lp )
1201 {
1202         int result = 0;
1203         int i;
1204         /*------------------------------------------------------------------------*/
1205
1206         DBG_FUNC( "wvlan_uil_get_info" );
1207         DBG_ENTER( DbgInfo );
1208
1209         if( urq->hcfCtx == &( lp->hcfCtx )) {
1210                 if(( urq->data != NULL ) && ( urq->len != 0 )) {
1211                         ltv_t      *pLtv;
1212                         bool_t      ltvAllocated = FALSE;
1213
1214                         /* Make sure that we have at least a command and length */
1215                         if( urq->len < ( sizeof( hcf_16 ) * 2 )) {
1216                                 urq->len = sizeof( lp->ltvRecord );
1217                                 DBG_ERROR( DbgInfo, "No Length/Type in LTV!!!\n" );
1218                                 DBG_ERROR( DbgInfo, "UIL_ERR_LEN\n" );
1219                                 urq->result = UIL_ERR_LEN;
1220                                 DBG_LEAVE( DbgInfo );
1221                                 return result;
1222                         }
1223
1224                         /* Verify the user's LTV record header. */
1225                         result = verify_area( VERIFY_READ, urq->data, sizeof( hcf_16 ) * 2 );
1226                         if( result != 0 ) {
1227                                 DBG_ERROR( DbgInfo, "verify_area(), VERIFY_READ FAILED\n" );
1228                                 urq->result = UIL_FAILURE;
1229                                 DBG_LEAVE( DbgInfo );
1230                                 return result;
1231                         }
1232
1233                         /* Get only the command and length information. */
1234                         result = copy_from_user( &( lp->ltvRecord ), urq->data, sizeof( hcf_16 ) * 2 );
1235
1236                         /* Make sure the incoming LTV record length is within the bounds of
1237                            the IOCTL length. */
1238                         if((( lp->ltvRecord.len + 1 ) * sizeof( hcf_16 )) > urq->len ) {
1239                                 DBG_ERROR( DbgInfo, "Incoming LTV too big\n" );
1240                                 urq->len = sizeof( lp->ltvRecord );
1241                                 urq->result = UIL_ERR_LEN;
1242                                 DBG_LEAVE( DbgInfo );
1243                                 return result;
1244                         }
1245
1246                         /* Determine if hcf_get_info() is needed or not */
1247                         switch ( lp->ltvRecord.typ ) {
1248                         case CFG_NIC_IDENTITY:
1249                                 memcpy( &lp->ltvRecord.u.u8[0], &lp->NICIdentity, sizeof( lp->NICIdentity ));
1250                                 break;
1251                         case CFG_PRI_IDENTITY:
1252                                 memcpy( &lp->ltvRecord.u.u8[0], &lp->PrimaryIdentity, sizeof( lp->PrimaryIdentity ));
1253                                 break;
1254                         case CFG_AP_MODE:
1255                                 DBG_ERROR( DbgInfo, "set CFG_AP_MODE no longer supported, so is get useful ????\n" );
1256                                 lp->ltvRecord.u.u16[0] =
1257                                         CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP;
1258                                 break;
1259                         //case CFG_DRV_INFO:
1260                         case CFG_ENCRYPT_STRING:
1261                         case CFG_COUNTRY_STRING:
1262                         case CFG_DRIVER_ENABLE:
1263                         case CFG_WOLAS_ENABLE:
1264                                 // TODO: determine if we're going to support these
1265                                 urq->result = UIL_FAILURE;
1266                                 break;
1267                         case CFG_DRV_INFO:
1268                                 DBG_TRACE( DbgInfo, "Intercept CFG_DRV_INFO\n" );
1269                                 result = cfg_driver_info( urq, lp );
1270                                 break;
1271                         case CFG_DRV_IDENTITY:
1272                                 DBG_TRACE( DbgInfo, "Intercept CFG_DRV_IDENTITY\n" );
1273                                 result = cfg_driver_identity( urq, lp );
1274                                 break;
1275                         case CFG_IFB:
1276                                 /* IFB can be a security hole */
1277                                 if( !capable( CAP_NET_ADMIN )) {
1278                                         result = -EPERM;
1279                                         break;
1280                                 }
1281
1282                                 /* Else fall through to the default */
1283
1284                         case CFG_FW_IDENTITY:   // For Hermes-1, this is cached
1285                         default:
1286
1287                                 /* Verify the user buffer */
1288                                 result = verify_area( VERIFY_WRITE, urq->data, urq->len );
1289                                 if( result != 0 ) {
1290                                         DBG_ERROR( DbgInfo, "verify_area(), VERIFY_WRITE FAILED\n" );
1291                                         urq->result = UIL_FAILURE;
1292                                         break;
1293                                 }
1294
1295                                 /* If the requested length is greater than the size of our local
1296                                    LTV record, try to allocate it from the kernel stack.
1297                                    Otherwise, we just use our local LTV record. */
1298                                 if( urq->len > sizeof( lp->ltvRecord )) {
1299                                         if(( pLtv = (ltv_t *)kmalloc( urq->len, GFP_KERNEL )) != NULL ) {
1300                                                 ltvAllocated = TRUE;
1301
1302                                                 /* Copy the command/length information into the new buffer. */
1303                                                 memcpy( pLtv, &( lp->ltvRecord ), sizeof( hcf_16 ) * 2 );
1304                                         } else {
1305                                                 urq->len = sizeof( lp->ltvRecord );
1306                                                 urq->result = UIL_ERR_LEN;
1307                                                 DBG_ERROR( DbgInfo, "kmalloc FAILED\n" );
1308                                                 DBG_ERROR( DbgInfo, "UIL_ERR_LEN\n" );
1309                                                 result = -ENOMEM;
1310                                                 break;
1311                                         }
1312                                 } else {
1313                                         pLtv = &( lp->ltvRecord );
1314                                 }
1315
1316                                 wl_act_int_off( lp );
1317                                 urq->result = hcf_get_info( &( lp->hcfCtx ), (LTVP) pLtv );
1318                                 wl_act_int_on( lp );
1319
1320                                 // Copy the LTV into the user's buffer.
1321                                 //copy_to_user( urq->data, pLtv, urq->len );
1322
1323                                 //if( ltvAllocated )
1324                                 //{
1325                                 //    kfree( pLtv );
1326                                 //}
1327
1328                                 //urq->result = UIL_SUCCESS;
1329                                 break;
1330                         }
1331
1332                         /* Handle endian conversion of special fields */
1333                         switch( lp->ltvRecord.typ ) {
1334                         /* simple int gets just need the first hcf_16 byte flipped */
1335                         case CFG_CNF_PORT_TYPE:
1336                         case CFG_CNF_OWN_CHANNEL:
1337                         case CFG_CNF_OWN_ATIM_WINDOW:
1338                         case CFG_CNF_SYSTEM_SCALE:
1339                         case CFG_CNF_MAX_DATA_LEN:
1340                         case CFG_CNF_PM_ENABLED:
1341                         case CFG_CNF_MCAST_RX:
1342                         case CFG_CNF_MAX_SLEEP_DURATION:
1343                         case CFG_CNF_HOLDOVER_DURATION:
1344                         case CFG_CNF_OWN_DTIM_PERIOD:
1345                         case CFG_CNF_MCAST_PM_BUF:
1346                         case CFG_CNF_REJECT_ANY:
1347                         case CFG_CNF_ENCRYPTION:
1348                         case CFG_CNF_AUTHENTICATION:
1349                         case CFG_CNF_EXCL_UNENCRYPTED:
1350                         case CFG_CNF_INTRA_BSS_RELAY:
1351                         case CFG_CNF_MICRO_WAVE:
1352                         case CFG_CNF_LOAD_BALANCING:
1353                         case CFG_CNF_MEDIUM_DISTRIBUTION:
1354 #ifdef WARP
1355                         case CFG_CNF_TX_POW_LVL:
1356                         case CFG_CNF_CONNECTION_CNTL:
1357                         case CFG_CNF_OWN_BEACON_INTERVAL:                          // Own Beacon Interval
1358                         case CFG_COEXISTENSE_BEHAVIOUR:                            // Coexistence Behavior
1359                         //case CFG_CNF_RX_ALL_GROUP_ADDRESS:
1360 #endif // HERMES25
1361                         case CFG_CREATE_IBSS:
1362                         case CFG_RTS_THRH:
1363                         case CFG_PROMISCUOUS_MODE:
1364                         //case CFG_WAKE_ON_LAN:
1365                         case CFG_RTS_THRH0:
1366                         case CFG_RTS_THRH1:
1367                         case CFG_RTS_THRH2:
1368                         case CFG_RTS_THRH3:
1369                         case CFG_RTS_THRH4:
1370                         case CFG_RTS_THRH5:
1371                         case CFG_RTS_THRH6:
1372                         case CFG_TX_RATE_CNTL0:
1373                         case CFG_TX_RATE_CNTL1:
1374                         case CFG_TX_RATE_CNTL2:
1375                         case CFG_TX_RATE_CNTL3:
1376                         case CFG_TX_RATE_CNTL4:
1377                         case CFG_TX_RATE_CNTL5:
1378                         case CFG_TX_RATE_CNTL6:
1379                         case CFG_TX_KEY_ID:
1380                         case CFG_TICK_TIME:
1381                         case CFG_MAX_LOAD_TIME:
1382                         case CFG_NIC_TEMP_TYPE:
1383                         case CFG_PORT_STAT:
1384                         case CFG_CUR_TX_RATE:
1385                         case CFG_CUR_BEACON_INTERVAL:
1386                         case CFG_PROTOCOL_RSP_TIME:
1387                         case CFG_CUR_SHORT_RETRY_LIMIT:
1388                         case CFG_CUR_LONG_RETRY_LIMIT:
1389                         case CFG_MAX_TX_LIFETIME:
1390                         case CFG_MAX_RX_LIFETIME:
1391                         case CFG_CF_POLLABLE:
1392                         case CFG_PRIVACY_OPT_IMPLEMENTED:
1393                         //case CFG_CURRENT_REMOTE_RATES:
1394                         //case CFG_CURRENT_USED_RATES:
1395                         //case CFG_CURRENT_SYSTEM_SCALE:
1396                         //case CFG_CURRENT_TX_RATE1:
1397                         //case CFG_CURRENT_TX_RATE2:
1398                         //case CFG_CURRENT_TX_RATE3:
1399                         //case CFG_CURRENT_TX_RATE4:
1400                         //case CFG_CURRENT_TX_RATE5:
1401                         //case CFG_CURRENT_TX_RATE6:
1402                         case CFG_PHY_TYPE:
1403                         case CFG_CUR_CHANNEL:
1404                         //case CFG_CURRENT_POWER_STATE:
1405                         //case CFG_CCAMODE:
1406                         //    lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1407                         //    break;
1408                         /* name string gets just need the first hcf_16 byte flipped (length of string) */
1409                         case CFG_CNF_OWN_SSID:
1410                         case CFG_CNF_OWN_NAME:
1411                         //case CNF_DESIRED_SSID:
1412                         case CFG_DESIRED_SSID:
1413                         case CFG_SCAN_SSID:
1414                         case CFG_CUR_SSID:
1415                                 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1416                                 break;
1417                         /* non-length counted strings need no byte flipping */
1418                         case CFG_CNF_OWN_MAC_ADDR:
1419                         /* this case is no longer valid: CFG_CNF_WDS_ADDR */
1420                         case CFG_CNF_WDS_ADDR1:
1421                         case CFG_CNF_WDS_ADDR2:
1422                         case CFG_CNF_WDS_ADDR3:
1423                         case CFG_CNF_WDS_ADDR4:
1424                         case CFG_CNF_WDS_ADDR5:
1425                         case CFG_CNF_WDS_ADDR6:
1426                         case CFG_GROUP_ADDR:
1427                         case CFG_NIC_SERIAL_NUMBER:
1428                         case CFG_CUR_BSSID:
1429                         case CFG_NIC_MAC_ADDR:
1430                         case CFG_SUPPORTED_DATA_RATES:  /* need to ensure we can treat this as a string */
1431                                 break;
1432                         //case CFG_CNF_COUNTRY_INFO:      /* special case, see page 75  of 022486, Rev C. */
1433                         //case CFG_CURRENT_COUNTRY_INFO:  /* special case, see page 101 of 022486, Rev C. */
1434                         /*
1435                                 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1436                                 lp->ltvRecord.u.u16[3] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[3] );
1437
1438                                 for( i = 4; i < lp->ltvRecord.len; i++ ) {
1439                                         lp->ltvRecord.u.u16[i] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[i] );
1440                                 }
1441                                 break;
1442                         */
1443
1444                         case CFG_DEFAULT_KEYS:
1445                                 {
1446                                         CFG_DEFAULT_KEYS_STRCT *pKeys = (CFG_DEFAULT_KEYS_STRCT *)&lp->ltvRecord.u.u8[0];
1447
1448                                         pKeys[0].len = CNV_INT_TO_LITTLE( pKeys[0].len );
1449                                         pKeys[1].len = CNV_INT_TO_LITTLE( pKeys[1].len );
1450                                         pKeys[2].len = CNV_INT_TO_LITTLE( pKeys[2].len );
1451                                         pKeys[3].len = CNV_INT_TO_LITTLE( pKeys[3].len );
1452                                 }
1453                                 break;
1454                         case CFG_CNF_MCAST_RATE:
1455                         case CFG_TX_RATE_CNTL:
1456                         case CFG_SUPPORTED_RATE_SET_CNTL:    // Supported Rate Set Control
1457                         case CFG_BASIC_RATE_SET_CNTL:    // Basic Rate Set Control
1458                                 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1459                                 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[1] );
1460                                 break;
1461                         case CFG_DL_BUF:
1462                         case CFG_NIC_IDENTITY:
1463                         case CFG_COMMS_QUALITY:
1464                         case CFG_PCF_INFO:
1465                                 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1466                                 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[1] );
1467                                 lp->ltvRecord.u.u16[2] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[2] );
1468                                 break;
1469                         case CFG_FW_IDENTITY:
1470                                 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1471                                 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[1] );
1472                                 lp->ltvRecord.u.u16[2] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[2] );
1473                                 lp->ltvRecord.u.u16[3] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[3] );
1474                                 break;
1475                         //case CFG_HSI_SUP_RANGE:
1476                         case CFG_NIC_MFI_SUP_RANGE:
1477                         case CFG_NIC_CFI_SUP_RANGE:
1478                         case CFG_NIC_PROFILE:
1479                         case CFG_FW_SUP_RANGE:
1480                                 lp->ltvRecord.u.u16[0] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[0] );
1481                                 lp->ltvRecord.u.u16[1] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[1] );
1482                                 lp->ltvRecord.u.u16[2] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[2] );
1483                                 lp->ltvRecord.u.u16[3] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[3] );
1484                                 lp->ltvRecord.u.u16[4] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[4] );
1485                                 break;
1486                         case CFG_MFI_ACT_RANGES_STA:
1487                         case CFG_CFI_ACT_RANGES_STA:
1488                         case CFG_CUR_SCALE_THRH:
1489                         case CFG_AUTHENTICATION_ALGORITHMS:
1490                                 for( i = 0; i < ( lp->ltvRecord.len - 1 ); i++ ) {
1491                                         lp->ltvRecord.u.u16[i] = CNV_INT_TO_LITTLE( lp->ltvRecord.u.u16[i] );
1492                                 }
1493                                 break;
1494                         /* done at init time, and endian handled then */
1495                         case CFG_PRI_IDENTITY:
1496                                 break;
1497                         case CFG_MB_INFO:
1498                                 //wvlanEndianTranslateMailbox( pLtv );
1499                                 break;
1500                         /* MSF and HCF RIDS */
1501                         case CFG_IFB:
1502                         case CFG_DRV_INFO:
1503                         case CFG_AP_MODE:
1504                         case CFG_ENCRYPT_STRING:
1505                         case CFG_COUNTRY_STRING:
1506                         case CFG_DRIVER_ENABLE:
1507                         case CFG_WOLAS_ENABLE:
1508                         default:
1509                                 break;
1510                         }
1511
1512                         // Copy the LTV into the user's buffer.
1513                         copy_to_user( urq->data, &( lp->ltvRecord ), urq->len );
1514
1515                         if( ltvAllocated ) {
1516                                 kfree( &( lp->ltvRecord ));
1517                         }
1518
1519                         urq->result = UIL_SUCCESS;
1520                 } else {
1521                         urq->result = UIL_FAILURE;
1522                 }
1523         } else {
1524                 DBG_ERROR( DbgInfo, "UIL_ERR_WRONG_IFB\n" );
1525                 urq->result = UIL_ERR_WRONG_IFB;
1526         }
1527
1528         DBG_LEAVE( DbgInfo );
1529         return result;
1530 } // wvlan_uil_get_info
1531 /*============================================================================*/
1532
1533
1534
1535
1536
1537 /*******************************************************************************
1538  *      cfg_driver_info()
1539  *******************************************************************************
1540  *
1541  *  DESCRIPTION:
1542  *
1543  *      Retrieves driver information.
1544  *
1545  *  PARAMETERS:
1546  *
1547  *      urq - a pointer to the UIL request buffer
1548  *      lp  - a pointer to the device's private adapter structure
1549  *
1550  *  RETURNS:
1551  *
1552  *      UIL_SUCCESS
1553  *      UIL_ERR_xxx value otherwise
1554  *
1555  ******************************************************************************/
1556 int cfg_driver_info( struct uilreq *urq, struct wl_private *lp )
1557 {
1558         int result = 0;
1559         /*------------------------------------------------------------------------*/
1560
1561
1562         DBG_FUNC( "cfg_driver_info" );
1563         DBG_ENTER( DbgInfo );
1564
1565
1566         /* Make sure that user buffer can handle the driver information buffer */
1567         if( urq->len < sizeof( lp->driverInfo )) {
1568                 urq->len = sizeof( lp->driverInfo );
1569                 urq->result = UIL_ERR_LEN;
1570                 DBG_LEAVE( DbgInfo );
1571                 return result;
1572         }
1573
1574         /* Verify the user buffer. */
1575         result = verify_area( VERIFY_WRITE, urq->data, sizeof( lp->driverInfo ));
1576         if( result != 0 ) {
1577                 urq->result = UIL_FAILURE;
1578                 DBG_LEAVE( DbgInfo );
1579                 return result;
1580         }
1581
1582         lp->driverInfo.card_stat = lp->hcfCtx.IFB_CardStat;
1583
1584         // Copy the driver information into the user's buffer.
1585         urq->result = UIL_SUCCESS;
1586         copy_to_user( urq->data, &( lp->driverInfo ), sizeof( lp->driverInfo ));
1587
1588         DBG_LEAVE( DbgInfo );
1589         return result;
1590 } // cfg_driver_info
1591 /*============================================================================*/
1592
1593
1594
1595
1596 /*******************************************************************************
1597  *      cfg_driver_identity()
1598  *******************************************************************************
1599  *
1600  *  DESCRIPTION:
1601  *
1602  *      Retrieves ID information from the card.
1603  *
1604  *  PARAMETERS:
1605  *
1606  *      urq - a pointer to the UIL request buffer
1607  *      lp  - a pointer to the device's private adapter structure
1608  *
1609  *  RETURNS:
1610  *
1611  *      UIL_SUCCESS
1612  *      UIL_ERR_xxx value otherwise
1613  *
1614  ******************************************************************************/
1615 int cfg_driver_identity( struct uilreq *urq, struct wl_private *lp )
1616 {
1617         int result = 0;
1618         /*------------------------------------------------------------------------*/
1619
1620
1621         DBG_FUNC( "wvlan_driver_identity" );
1622         DBG_ENTER( DbgInfo );
1623
1624
1625         /* Make sure that user buffer can handle the driver identity structure. */
1626         if( urq->len < sizeof( lp->driverIdentity )) {
1627                 urq->len = sizeof( lp->driverIdentity );
1628                 urq->result = UIL_ERR_LEN;
1629                 DBG_LEAVE( DbgInfo );
1630                 return result;
1631         }
1632
1633         /* Verify the user buffer. */
1634         result = verify_area( VERIFY_WRITE, urq->data, sizeof( lp->driverIdentity ));
1635         if( result != 0 ) {
1636                 urq->result = UIL_FAILURE;
1637                 DBG_LEAVE( DbgInfo );
1638                 return result;
1639         }
1640
1641         /* Copy the driver identity into the user's buffer. */
1642         urq->result = UIL_SUCCESS;
1643         copy_to_user( urq->data, &( lp->driverIdentity ), sizeof( lp->driverIdentity ));
1644
1645         DBG_LEAVE( DbgInfo );
1646         return result;
1647 } // cfg_driver_identity
1648 /*============================================================================*/
1649
1650
1651 #endif  /* USE_UIL */
1652
1653
1654 /* If WIRELESS_EXT is not defined, then the functions that follow will not be
1655    included in the build. */
1656 /* NOTE: Are these still even needed? */
1657 #ifdef WIRELESS_EXT
1658
1659
1660 /*******************************************************************************
1661  *      wvlan_set_netname()
1662  *******************************************************************************
1663  *
1664  *  DESCRIPTION:
1665  *
1666  *      Set the ESSID of the card.
1667  *
1668  *  PARAMETERS:
1669  *
1670  *      wrq - a pointer to the wireless request buffer
1671  *      lp  - a pointer to the device's private adapter structure
1672  *
1673  *  RETURNS:
1674  *
1675  *      0 on success
1676  *      errno value otherwise
1677  *
1678  ******************************************************************************/
1679 int wvlan_set_netname(struct net_device *dev,
1680                       struct iw_request_info *info,
1681                       union iwreq_data *wrqu,
1682                       char *extra)
1683 {
1684         struct wl_private *lp = wl_priv(dev);
1685         unsigned long flags;
1686         int ret = 0;
1687         /*------------------------------------------------------------------------*/
1688
1689
1690         DBG_FUNC( "wvlan_set_netname" );
1691         DBG_ENTER( DbgInfo );
1692
1693         wl_lock(lp, &flags);
1694
1695         memset( lp->NetworkName, 0, sizeof( lp->NetworkName ));
1696         memcpy( lp->NetworkName, extra, wrqu->data.length);
1697
1698         /* Commit the adapter parameters */
1699         wl_apply(lp);
1700         wl_unlock(lp, &flags);
1701
1702         DBG_LEAVE( DbgInfo );
1703         return ret;
1704 } // wvlan_set_netname
1705 /*============================================================================*/
1706
1707
1708
1709
1710 /*******************************************************************************
1711  *      wvlan_get_netname()
1712  *******************************************************************************
1713  *
1714  *  DESCRIPTION:
1715  *
1716  *      Get the ESSID of the card.
1717  *
1718  *  PARAMETERS:
1719  *
1720  *      wrq - a pointer to the wireless request buffer
1721  *      lp  - a pointer to the device's private adapter structure
1722  *
1723  *  RETURNS:
1724  *
1725  *      0 on success
1726  *      errno value otherwise
1727  *
1728  ******************************************************************************/
1729 int wvlan_get_netname(struct net_device *dev,
1730                       struct iw_request_info *info,
1731                       union iwreq_data *wrqu,
1732                       char *extra)
1733 {
1734         struct wl_private *lp = wl_priv(dev);
1735         unsigned long flags;
1736         int         ret = 0;
1737         int         status = -1;
1738         wvName_t   *pName;
1739         /*------------------------------------------------------------------------*/
1740
1741
1742         DBG_FUNC( "wvlan_get_netname" );
1743         DBG_ENTER( DbgInfo );
1744
1745         wl_lock(lp, &flags);
1746
1747         /* Get the current network name */
1748         lp->ltvRecord.len = 1 + ( sizeof( *pName ) / sizeof( hcf_16 ));
1749         lp->ltvRecord.typ = CFG_CUR_SSID;
1750
1751         status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1752
1753         if( status == HCF_SUCCESS ) {
1754                 pName = (wvName_t *)&( lp->ltvRecord.u.u32 );
1755
1756                 memset(extra, '\0', HCF_MAX_NAME_LEN);
1757                 wrqu->data.length = pName->length;
1758
1759                 memcpy(extra, pName->name, pName->length);
1760         } else {
1761                 ret = -EFAULT;
1762         }
1763
1764         wl_unlock(lp, &flags);
1765
1766         DBG_LEAVE( DbgInfo );
1767         return ret;
1768 } // wvlan_get_netname
1769 /*============================================================================*/
1770
1771
1772
1773
1774 /*******************************************************************************
1775  *      wvlan_set_station_nickname()
1776  *******************************************************************************
1777  *
1778  *  DESCRIPTION:
1779  *
1780  *      Set the card's station nickname.
1781  *
1782  *  PARAMETERS:
1783  *
1784  *      wrq - a pointer to the wireless request buffer
1785  *      lp  - a pointer to the device's private adapter structure
1786  *
1787  *  RETURNS:
1788  *
1789  *      0 on success
1790  *      errno value otherwise
1791  *
1792  ******************************************************************************/
1793 int wvlan_set_station_nickname(struct net_device *dev,
1794                       struct iw_request_info *info,
1795                       union iwreq_data *wrqu,
1796                       char *extra)
1797 {
1798         struct wl_private *lp = wl_priv(dev);
1799         unsigned long flags;
1800         int         ret = 0;
1801         /*------------------------------------------------------------------------*/
1802
1803
1804         DBG_FUNC( "wvlan_set_station_nickname" );
1805         DBG_ENTER( DbgInfo );
1806
1807         wl_lock(lp, &flags);
1808
1809         memset( lp->StationName, 0, sizeof( lp->StationName ));
1810
1811         memcpy( lp->StationName, extra, wrqu->data.length);
1812
1813         /* Commit the adapter parameters */
1814         wl_apply( lp );
1815         wl_unlock(lp, &flags);
1816
1817         DBG_LEAVE( DbgInfo );
1818         return ret;
1819 } // wvlan_set_station_nickname
1820 /*============================================================================*/
1821
1822
1823
1824
1825 /*******************************************************************************
1826  *      wvlan_get_station_nickname()
1827  *******************************************************************************
1828  *
1829  *  DESCRIPTION:
1830  *
1831  *      Get the card's station nickname.
1832  *
1833  *  PARAMETERS:
1834  *
1835  *      wrq - a pointer to the wireless request buffer
1836  *      lp  - a pointer to the device's private adapter structure
1837  *
1838  *  RETURNS:
1839  *
1840  *      0 on success
1841  *      errno value otherwise
1842  *
1843  ******************************************************************************/
1844 int wvlan_get_station_nickname(struct net_device *dev,
1845                       struct iw_request_info *info,
1846                       union iwreq_data *wrqu,
1847                       char *extra)
1848 {
1849         struct wl_private *lp = wl_priv(dev);
1850         unsigned long flags;
1851         int         ret = 0;
1852         int         status = -1;
1853         wvName_t   *pName;
1854         /*------------------------------------------------------------------------*/
1855
1856
1857         DBG_FUNC( "wvlan_get_station_nickname" );
1858         DBG_ENTER( DbgInfo );
1859
1860         wl_lock( lp, &flags );
1861
1862         /* Get the current station name */
1863         lp->ltvRecord.len = 1 + ( sizeof( *pName ) / sizeof( hcf_16 ));
1864         lp->ltvRecord.typ = CFG_CNF_OWN_NAME;
1865
1866         status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1867
1868         if( status == HCF_SUCCESS ) {
1869                 pName = (wvName_t *)&( lp->ltvRecord.u.u32 );
1870
1871                 memset(extra, '\0', HCF_MAX_NAME_LEN);
1872                 wrqu->data.length = pName->length;
1873                 memcpy(extra, pName->name, pName->length);
1874         } else {
1875                 ret = -EFAULT;
1876         }
1877
1878         wl_unlock(lp, &flags);
1879
1880 //out:
1881         DBG_LEAVE( DbgInfo );
1882         return ret;
1883 } // wvlan_get_station_nickname
1884 /*============================================================================*/
1885
1886
1887
1888
1889 /*******************************************************************************
1890  *      wvlan_set_porttype()
1891  *******************************************************************************
1892  *
1893  *  DESCRIPTION:
1894  *
1895  *      Set the card's porttype
1896  *
1897  *  PARAMETERS:
1898  *
1899  *      wrq - a pointer to the wireless request buffer
1900  *      lp  - a pointer to the device's private adapter structure
1901  *
1902  *  RETURNS:
1903  *
1904  *      0 on success
1905  *      errno value otherwise
1906  *
1907  ******************************************************************************/
1908 int wvlan_set_porttype(struct net_device *dev,
1909                       struct iw_request_info *info,
1910                       union iwreq_data *wrqu,
1911                       char *extra)
1912 {
1913         struct wl_private *lp = wl_priv(dev);
1914         unsigned long flags;
1915         int     ret = 0;
1916         hcf_16  portType;
1917         /*------------------------------------------------------------------------*/
1918
1919
1920         DBG_FUNC( "wvlan_set_porttype" );
1921         DBG_ENTER( DbgInfo );
1922
1923         wl_lock(lp, &flags);
1924
1925         /* Validate the new value */
1926         portType = *((__u32 *)extra);
1927
1928         if( !(( portType == 1 ) || ( portType == 3 ))) {
1929                 ret = -EINVAL;
1930                 goto out_unlock;
1931         }
1932
1933         lp->PortType = portType;
1934
1935         /* Commit the adapter parameters */
1936         wl_apply( lp );
1937
1938 out_unlock:
1939         wl_unlock(lp, &flags);
1940
1941 //out:
1942         DBG_LEAVE( DbgInfo );
1943         return ret;
1944 }
1945
1946 /*============================================================================*/
1947
1948
1949 /*******************************************************************************
1950  *      wvlan_get_porttype()
1951  *******************************************************************************
1952  *
1953  *  DESCRIPTION:
1954  *
1955  *      Get the card's porttype
1956  *
1957  *  PARAMETERS:
1958  *
1959  *      wrq - a pointer to the wireless request buffer
1960  *      lp  - a pointer to the device's private adapter structure
1961  *
1962  *  RETURNS:
1963  *
1964  *      0 on success
1965  *      errno value otherwise
1966  *
1967  ******************************************************************************/
1968 int wvlan_get_porttype(struct net_device *dev,
1969                       struct iw_request_info *info,
1970                       union iwreq_data *wrqu,
1971                       char *extra)
1972 {
1973         struct wl_private *lp = wl_priv(dev);
1974         unsigned long flags;
1975         int     ret = 0;
1976         int     status = -1;
1977         hcf_16  *pPortType;
1978         __u32 *pData = (__u32 *)extra;
1979         /*------------------------------------------------------------------------*/
1980
1981
1982         DBG_FUNC( "wvlan_get_porttype" );
1983         DBG_ENTER( DbgInfo );
1984
1985         wl_lock( lp, &flags );
1986
1987         /* Get the current port type */
1988         lp->ltvRecord.len = 1 + ( sizeof( *pPortType ) / sizeof( hcf_16 ));
1989         lp->ltvRecord.typ = CFG_CNF_PORT_TYPE;
1990
1991         status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1992
1993         if( status == HCF_SUCCESS ) {
1994                 pPortType = (hcf_16 *)&( lp->ltvRecord.u.u32 );
1995
1996                 *pData = CNV_LITTLE_TO_INT( *pPortType );
1997         } else {
1998             ret = -EFAULT;
1999         }
2000
2001         wl_unlock(lp, &flags);
2002
2003 //out:
2004         DBG_LEAVE( DbgInfo );
2005         return ret;
2006 } // wvlan_get_porttype
2007 /*============================================================================*/
2008
2009 #endif  // WIRELESS_EXT
2010
2011
2012
2013
2014 #ifdef USE_RTS
2015 /*******************************************************************************
2016  *      wvlan_rts()
2017  *******************************************************************************
2018  *
2019  *  DESCRIPTION:
2020  *
2021  *      IOCTL handler for RTS commands
2022  *
2023  *  PARAMETERS:
2024  *
2025  *      rrq - a pointer to the rts request buffer
2026  *      lp  - a pointer to the device's private adapter structure
2027  *
2028  *  RETURNS:
2029  *
2030  *      0 on success
2031  *      errno value otherwise
2032  *
2033  ******************************************************************************/
2034 int wvlan_rts( struct rtsreq *rrq, __u32 io_base )
2035 {
2036         int ioctl_ret = 0;
2037         /*------------------------------------------------------------------------*/
2038
2039
2040         DBG_FUNC( "wvlan_rts" );
2041         DBG_ENTER( DbgInfo );
2042
2043
2044         DBG_PRINT( "io_base: 0x%08x\n", io_base );
2045
2046         switch( rrq->typ ) {
2047           case WL_IOCTL_RTS_READ:
2048                 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- WL_IOCTL_RTS_READ\n");
2049                 rrq->data[0] = IN_PORT_WORD( io_base + rrq->reg );
2050                 DBG_TRACE( DbgInfo, "  reg 0x%04x ==> 0x%04x\n", rrq->reg, CNV_LITTLE_TO_SHORT( rrq->data[0] ) );
2051                 break;
2052           case WL_IOCTL_RTS_WRITE:
2053                 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- WL_IOCTL_RTS_WRITE\n");
2054                 OUT_PORT_WORD( io_base + rrq->reg, rrq->data[0] );
2055                 DBG_TRACE( DbgInfo, "  reg 0x%04x <== 0x%04x\n", rrq->reg, CNV_LITTLE_TO_SHORT( rrq->data[0] ) );
2056                 break;
2057           case WL_IOCTL_RTS_BATCH_READ:
2058                 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- WL_IOCTL_RTS_BATCH_READ\n");
2059                 IN_PORT_STRING_16( io_base + rrq->reg, rrq->data, rrq->len );
2060                 DBG_TRACE( DbgInfo, "  reg 0x%04x ==> %d bytes\n", rrq->reg, rrq->len * sizeof (__u16 ) );
2061                 break;
2062           case WL_IOCTL_RTS_BATCH_WRITE:
2063                 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- WL_IOCTL_RTS_BATCH_WRITE\n");
2064                 OUT_PORT_STRING_16( io_base + rrq->reg, rrq->data, rrq->len );
2065                 DBG_TRACE( DbgInfo, "  reg 0x%04x <== %d bytes\n", rrq->reg, rrq->len * sizeof (__u16) );
2066                 break;
2067         default:
2068
2069                 DBG_TRACE(DbgInfo, "IOCTL: WVLAN2_IOCTL_RTS -- UNSUPPORTED RTS CODE: 0x%X", rrq->typ );
2070                 ioctl_ret = -EOPNOTSUPP;
2071                 break;
2072         }
2073
2074         DBG_LEAVE( DbgInfo );
2075         return ioctl_ret;
2076 } // wvlan_rts
2077 /*============================================================================*/
2078
2079 #endif  /* USE_RTS */