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