drivers/staging/wlags49_h2/wl_wext.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  * SOFTWARE LICENSE
  15  *
  16  * This software is provided subject to the following terms and conditions,
  17  * which you should read carefully before using the software.  Using this
  18  * software indicates your acceptance of these terms and conditions.  If you do
  19  * not agree with these terms and conditions, do not use the software.
  20  *
  21  * Copyright © 2003 Agere Systems Inc.
  22  * All rights reserved.
  23  *
  24  * Redistribution and use in source or binary forms, with or without
  25  * modifications, are permitted provided that the following conditions are met:
  26  *
  27  * . Redistributions of source code must retain the above copyright notice, this
  28  *    list of conditions and the following Disclaimer as comments in the code as
  29  *    well as in the documentation and/or other materials provided with the
  30  *    distribution.
  31  *
  32  * . Redistributions in binary form must reproduce the above copyright notice,
  33  *    this list of conditions and the following Disclaimer in the documentation
  34  *    and/or other materials provided with the distribution.
  35  *
  36  * . Neither the name of Agere Systems Inc. nor the names of the contributors
  37  *    may be used to endorse or promote products derived from this software
  38  *    without specific prior written permission.
  39  *
  40  * Disclaimer
  41  *
  42  * THIS SOFTWARE IS PROVIDED \93AS IS\94 AND ANY EXPRESS OR IMPLIED WARRANTIES,
  43  * INCLUDING, BUT NOT LIMITED TO, INFRINGEMENT AND THE IMPLIED WARRANTIES OF
  44  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  ANY
  45  * USE, MODIFICATION OR DISTRIBUTION OF THIS SOFTWARE IS SOLELY AT THE USERS OWN
  46  * RISK. IN NO EVENT SHALL AGERE SYSTEMS INC. OR CONTRIBUTORS BE LIABLE FOR ANY
  47  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  48  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  49  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  50  * ON ANY THEORY OF LIABILITY, INCLUDING, BUT NOT LIMITED TO, CONTRACT, STRICT
  51  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  52  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  53  * DAMAGE.
  54  *
  55  ******************************************************************************/
  56
  57 /*******************************************************************************
  58  *  include files
  59  ******************************************************************************/
  60 #include <wl_version.h>
  61
  62 #include <linux/if_arp.h>
  63 #include <linux/ioport.h>
  64 #include <linux/delay.h>
  65 #include <linux/etherdevice.h>
  66 #include <asm/uaccess.h>
  67
  68 #include <debug.h>
  69 #include <hcf.h>
  70 #include <hcfdef.h>
  71
  72 #include <wl_if.h>
  73 #include <wl_internal.h>
  74 #include <wl_util.h>
  75 #include <wl_main.h>
  76 #include <wl_wext.h>
  77 #include <wl_priv.h>
  78
  79 /* Set up the LTV to program the appropriate key */
  80 static int hermes_set_tkip_keys(ltv_t *ltv, u16 key_idx, u8 *addr,
  81                                 int set_tx, u8 *seq, u8 *key, size_t key_len)
  82 {
  83         int ret = -EINVAL;
  84         int buf_idx = 0;
  85         hcf_8 tsc[IW_ENCODE_SEQ_MAX_SIZE] =
  86                 { 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00 };
  87
  88         /*
  89          * Check the key index here; if 0, load as Pairwise Key, otherwise,
  90          * load as a group key. Note that for the Hermes, the RIDs for
  91          * group/pairwise keys are different from each other and different
  92          * than the default WEP keys as well.
  93          */
  94         switch (key_idx) {
  95         case 0:
  96                 ltv->len = 28;
  97                 ltv->typ = CFG_ADD_TKIP_MAPPED_KEY;
  98
  99                 /* Load the BSSID */
 100                 memcpy(&ltv->u.u8[buf_idx], addr, ETH_ALEN);
 101                 buf_idx += ETH_ALEN;
 102
 103                 /* Load the TKIP key */
 104                 memcpy(&ltv->u.u8[buf_idx], &key[0], 16);
 105                 buf_idx += 16;
 106
 107                 /* Load the TSC */
 108                 memcpy(&ltv->u.u8[buf_idx], tsc, IW_ENCODE_SEQ_MAX_SIZE);
 109                 buf_idx += IW_ENCODE_SEQ_MAX_SIZE;
 110
 111                 /* Load the RSC */
 112                 memcpy(&ltv->u.u8[buf_idx], seq, IW_ENCODE_SEQ_MAX_SIZE);
 113                 buf_idx += IW_ENCODE_SEQ_MAX_SIZE;
 114
 115                 /* Load the TxMIC key */
 116                 memcpy(&ltv->u.u8[buf_idx], &key[16], 8);
 117                 buf_idx += 8;
 118
 119                 /* Load the RxMIC key */
 120                 memcpy(&ltv->u.u8[buf_idx], &key[24], 8);
 121
 122                 ret = 0;
 123                 break;
 124         case 1:
 125         case 2:
 126         case 3:
 127                 ltv->len = 26;
 128                 ltv->typ = CFG_ADD_TKIP_DEFAULT_KEY;
 129
 130                 /* Load the key Index */
 131
 132                 /* If this is a Tx Key, set bit 8000 */
 133                 if (set_tx)
 134                         key_idx |= 0x8000;
 135                 ltv->u.u16[buf_idx] = cpu_to_le16(key_idx);
 136                 buf_idx += 2;
 137
 138                 /* Load the RSC */
 139                 memcpy(&ltv->u.u8[buf_idx], seq, IW_ENCODE_SEQ_MAX_SIZE);
 140                 buf_idx += IW_ENCODE_SEQ_MAX_SIZE;
 141
 142                 /* Load the TKIP, TxMIC, and RxMIC keys in one shot, because in
 143                    CFG_ADD_TKIP_DEFAULT_KEY they are back-to-back */
 144                 memcpy(&ltv->u.u8[buf_idx], key, key_len);
 145                 buf_idx += key_len;
 146
 147                 /* Load the TSC */
 148                 memcpy(&ltv->u.u8[buf_idx], tsc, IW_ENCODE_SEQ_MAX_SIZE);
 149
 150                 ret = 0;
 151                 break;
 152         default:
 153                 break;
 154         }
 155
 156         return ret;
 157 }
 158
 159 /* Set up the LTV to clear the appropriate key */
 160 static int hermes_clear_tkip_keys(ltv_t *ltv, u16 key_idx, u8 *addr)
 161 {
 162         int ret;
 163
 164         switch (key_idx) {
 165         case 0:
 166                 if (!is_broadcast_ether_addr(addr)) {
 167                         ltv->len = 7;
 168                         ltv->typ = CFG_REMOVE_TKIP_MAPPED_KEY;
 169                         memcpy(&ltv->u.u8[0], addr, ETH_ALEN);
 170                         ret = 0;
 171                 }
 172                 break;
 173         case 1:
 174         case 2:
 175         case 3:
 176                 /* Clear the Group TKIP keys by index */
 177                 ltv->len = 2;
 178                 ltv->typ = CFG_REMOVE_TKIP_DEFAULT_KEY;
 179                 ltv->u.u16[0] = cpu_to_le16(key_idx);
 180
 181                 ret = 0;
 182                 break;
 183         default:
 184                 break;
 185         }
 186
 187         return ret;
 188 }
 189
 190 /* Set the WEP keys in the wl_private structure */
 191 static int hermes_set_wep_keys(struct wl_private *lp, u16 key_idx,
 192                                u8 *key, size_t key_len,
 193                                bool enable, bool set_tx)
 194 {
 195         hcf_8  encryption_state = lp->EnableEncryption;
 196         int tk = lp->TransmitKeyID - 1; /* current key */
 197         int ret = 0;
 198
 199         /* Is encryption supported? */
 200         if (!wl_has_wep(&(lp->hcfCtx))) {
 201                 DBG_WARNING(DbgInfo, "WEP not supported on this device\n");
 202                 ret = -EOPNOTSUPP;
 203                 goto out;
 204         }
 205
 206         DBG_NOTICE(DbgInfo, "pointer: %p, length: %d\n",
 207                    key, key_len);
 208
 209         /* Check the size of the key */
 210         switch (key_len) {
 211         case MIN_KEY_SIZE:
 212         case MAX_KEY_SIZE:
 213
 214                 /* Check the index */
 215                 if ((key_idx < 0) || (key_idx >= MAX_KEYS))
 216                         key_idx = tk;
 217
 218                 /* Cleanup */
 219                 memset(lp->DefaultKeys.key[key_idx].key, 0, MAX_KEY_SIZE);
 220
 221                 /* Copy the key in the driver */
 222                 memcpy(lp->DefaultKeys.key[key_idx].key, key, key_len);
 223
 224                 /* Set the length */
 225                 lp->DefaultKeys.key[key_idx].len = key_len;
 226
 227                 DBG_NOTICE(DbgInfo, "encoding.length: %d\n", key_len);
 228                 DBG_NOTICE(DbgInfo, "set key: %s(%d) [%d]\n",
 229                            lp->DefaultKeys.key[key_idx].key,
 230                            lp->DefaultKeys.key[key_idx].len, key_idx);
 231
 232                 /* Enable WEP (if possible) */
 233                 if ((key_idx == tk) && (lp->DefaultKeys.key[tk].len > 0))
 234                         lp->EnableEncryption = 1;
 235
 236                 break;
 237
 238         case 0:
 239                 /* Do we want to just set the current transmit key? */
 240                 if (set_tx && (key_idx >= 0) && (key_idx < MAX_KEYS)) {
 241                         DBG_NOTICE(DbgInfo, "index: %d; len: %d\n", key_idx,
 242                                    lp->DefaultKeys.key[key_idx].len);
 243
 244                         if (lp->DefaultKeys.key[key_idx].len > 0) {
 245                                 lp->TransmitKeyID    = key_idx + 1;
 246                                 lp->EnableEncryption = 1;
 247                         } else {
 248                                 DBG_WARNING(DbgInfo, "Problem setting the current TxKey\n");
 249                                 ret = -EINVAL;
 250                         }
 251                 }
 252                 break;
 253
 254         default:
 255                 DBG_WARNING(DbgInfo, "Invalid Key length\n");
 256                 ret = -EINVAL;
 257                 goto out;
 258         }
 259
 260         /* Read the flags */
 261         if (enable) {
 262                 lp->EnableEncryption = 1;
 263                 lp->wext_enc = IW_ENCODE_ALG_WEP;
 264         } else {
 265                 lp->EnableEncryption = 0;       /* disable encryption */
 266                 lp->wext_enc = IW_ENCODE_ALG_NONE;
 267         }
 268
 269         DBG_TRACE(DbgInfo, "encryption_state :     %d\n", encryption_state);
 270         DBG_TRACE(DbgInfo, "lp->EnableEncryption : %d\n", lp->EnableEncryption);
 271         DBG_TRACE(DbgInfo, "erq->length          : %d\n", key_len);
 272
 273         /* Write the changes to the card */
 274         if (ret == 0) {
 275                 DBG_NOTICE(DbgInfo, "encrypt: %d, ID: %d\n", lp->EnableEncryption,
 276                            lp->TransmitKeyID);
 277
 278                 if (lp->EnableEncryption == encryption_state) {
 279                         if (key_len != 0) {
 280                                 /* Dynamic WEP key update */
 281                                 wl_set_wep_keys(lp);
 282                         }
 283                 } else {
 284                         /* To switch encryption on/off, soft reset is
 285                          * required */
 286                         wl_apply(lp);
 287                 }
 288         }
 289
 290 out:
 291         return ret;
 292 }
 293
 294 /*******************************************************************************
 295  *      wireless_commit()
 296  *******************************************************************************
 297  *
 298  *  DESCRIPTION:
 299  *
 300  *      Commit
 301  *  protocol used.
 302  *
 303  *  PARAMETERS:
 304  *
 305  *      wrq - the wireless request buffer
 306  *
 307  *  RETURNS:
 308  *
 309  *      N/A
 310  *
 311  ******************************************************************************/
 312 static int wireless_commit(struct net_device *dev,
 313                            struct iw_request_info *info,
 314                            union iwreq_data *rqu, char *extra)
 315 {
 316         struct wl_private *lp = wl_priv(dev);
 317         unsigned long flags;
 318         int ret = 0;
 319
 320         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
 321                 ret = -EBUSY;
 322                 goto out;
 323         }
 324
 325         wl_lock( lp, &flags );
 326
 327         wl_act_int_off( lp );
 328
 329         wl_apply(lp);
 330
 331         wl_act_int_on( lp );
 332
 333         wl_unlock(lp, &flags);
 334
 335 out:
 336         return ret;
 337 } // wireless_commit
 338 /*============================================================================*/
 339
 340
 341
 342
 343 /*******************************************************************************
 344  *      wireless_get_protocol()
 345  *******************************************************************************
 346  *
 347  *  DESCRIPTION:
 348  *
 349  *      Returns a vendor-defined string that should identify the wireless
 350  *  protocol used.
 351  *
 352  *  PARAMETERS:
 353  *
 354  *      wrq - the wireless request buffer
 355  *
 356  *  RETURNS:
 357  *
 358  *      N/A
 359  *
 360  ******************************************************************************/
 361 static int wireless_get_protocol(struct net_device *dev, struct iw_request_info *info, char *name, char *extra)
 362 {
 363         /* Originally, the driver was placing the string "Wireless" here. However,
 364            the wireless extensions (/linux/wireless.h) indicate this string should
 365            describe the wireless protocol. */
 366
 367         strcpy(name, "IEEE 802.11b");
 368
 369         return 0;
 370 } // wireless_get_protocol
 371 /*============================================================================*/
 372
 373
 374
 375
 376 /*******************************************************************************
 377  *      wireless_set_frequency()
 378  *******************************************************************************
 379  *
 380  *  DESCRIPTION:
 381  *
 382  *      Sets the frequency (channel) on which the card should Tx/Rx.
 383  *
 384  *  PARAMETERS:
 385  *
 386  *      wrq - the wireless request buffer
 387  *      lp  - the device's private adapter structure
 388  *
 389  *  RETURNS:
 390  *
 391  *      0 on success
 392  *      errno value otherwise
 393  *
 394  ******************************************************************************/
 395 static int wireless_set_frequency(struct net_device *dev, struct iw_request_info *info, struct iw_freq *freq, char *extra)
 396 {
 397         struct wl_private *lp = wl_priv(dev);
 398         unsigned long flags;
 399         int channel = 0;
 400         int ret     = 0;
 401
 402         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
 403                 ret = -EBUSY;
 404                 goto out;
 405         }
 406
 407         if( !capable( CAP_NET_ADMIN )) {
 408                 ret = -EPERM;
 409                 return ret;
 410         }
 411
 412
 413         /* If frequency specified, look up channel */
 414         if( freq->e == 1 ) {
 415                 int f = freq->m / 100000;
 416                 channel = wl_get_chan_from_freq( f );
 417         }
 418
 419
 420         /* Channel specified */
 421         if( freq->e == 0 ) {
 422                 channel = freq->m;
 423         }
 424
 425
 426         /* If the channel is an 802.11a channel, set Bit 8 */
 427         if( channel > 14 ) {
 428                 channel = channel | 0x100;
 429         }
 430
 431
 432         wl_lock( lp, &flags );
 433
 434         wl_act_int_off( lp );
 435
 436         lp->Channel = channel;
 437
 438
 439         /* Commit the adapter parameters */
 440         wl_apply( lp );
 441
 442         /* Send an event that channel/freq has been set */
 443         wl_wext_event_freq( lp->dev );
 444
 445         wl_act_int_on( lp );
 446
 447         wl_unlock(lp, &flags);
 448
 449 out:
 450         return ret;
 451 } // wireless_set_frequency
 452 /*============================================================================*/
 453
 454
 455
 456
 457 /*******************************************************************************
 458  *      wireless_get_frequency()
 459  *******************************************************************************
 460  *
 461  *  DESCRIPTION:
 462  *
 463  *      Gets the frequency (channel) on which the card is Tx/Rx.
 464  *
 465  *  PARAMETERS:
 466  *
 467  *      wrq - the wireless request buffer
 468  *      lp  - the device's private adapter structure
 469  *
 470  *  RETURNS:
 471  *
 472  *      N/A
 473  *
 474  ******************************************************************************/
 475 static int wireless_get_frequency(struct net_device *dev, struct iw_request_info *info, struct iw_freq *freq, char *extra)
 476
 477 {
 478         struct wl_private *lp = wl_priv(dev);
 479         unsigned long flags;
 480         int ret = -1;
 481
 482         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
 483                 ret = -EBUSY;
 484                 goto out;
 485         }
 486
 487         wl_lock( lp, &flags );
 488
 489         wl_act_int_off( lp );
 490
 491         lp->ltvRecord.len = 2;
 492         lp->ltvRecord.typ = CFG_CUR_CHANNEL;
 493
 494         ret = hcf_get_info( &(lp->hcfCtx), (LTVP)&( lp->ltvRecord ));
 495         if( ret == HCF_SUCCESS ) {
 496                 hcf_16 channel = CNV_LITTLE_TO_INT( lp->ltvRecord.u.u16[0] );
 497
 498                 freq->m = wl_get_freq_from_chan( channel ) * 100000;
 499                 freq->e = 1;
 500         }
 501
 502         wl_act_int_on( lp );
 503
 504         wl_unlock(lp, &flags);
 505
 506         ret = (ret == HCF_SUCCESS ? 0 : -EFAULT);
 507
 508 out:
 509         return ret;
 510 } // wireless_get_frequency
 511 /*============================================================================*/
 512
 513
 514
 515
 516 /*******************************************************************************
 517  *      wireless_get_range()
 518  *******************************************************************************
 519  *
 520  *  DESCRIPTION:
 521  *
 522  *      This function is used to provide misc info and statistics about the
 523  *  wireless device.
 524  *
 525  *  PARAMETERS:
 526  *
 527  *      wrq - the wireless request buffer
 528  *      lp  - the device's private adapter structure
 529  *
 530  *  RETURNS:
 531  *
 532  *      0 on success
 533  *      errno value otherwise
 534  *
 535  ******************************************************************************/
 536 static int wireless_get_range(struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *extra)
 537 {
 538         struct wl_private *lp = wl_priv(dev);
 539         unsigned long      flags;
 540         struct iw_range   *range = (struct iw_range *) extra;
 541         int                ret = 0;
 542         int                status = -1;
 543         int                count;
 544         __u16             *pTxRate;
 545         int                retries = 0;
 546
 547         /* Set range information */
 548         data->length = sizeof(struct iw_range);
 549         memset(range, 0, sizeof(struct iw_range));
 550
 551         wl_lock( lp, &flags );
 552
 553         wl_act_int_off( lp );
 554
 555         /* Set range information */
 556         memset( range, 0, sizeof( struct iw_range ));
 557
 558 retry:
 559         /* Get the current transmit rate from the adapter */
 560         lp->ltvRecord.len = 1 + (sizeof(*pTxRate) / sizeof(hcf_16));
 561         lp->ltvRecord.typ = CFG_CUR_TX_RATE;
 562
 563         status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
 564         if( status != HCF_SUCCESS ) {
 565                 /* Recovery action: reset and retry up to 10 times */
 566                 DBG_TRACE( DbgInfo, "Get CFG_CUR_TX_RATE failed: 0x%x\n", status );
 567
 568                 if (retries < 10) {
 569                         retries++;
 570
 571                         /* Holding the lock too long, makes a gap to allow other processes */
 572                         wl_unlock(lp, &flags);
 573                         wl_lock( lp, &flags );
 574
 575                         status = wl_reset( dev );
 576                         if ( status != HCF_SUCCESS ) {
 577                                 DBG_TRACE( DbgInfo, "reset failed: 0x%x\n", status );
 578
 579                                 ret = -EFAULT;
 580                                 goto out_unlock;
 581                         }
 582
 583                         /* Holding the lock too long, makes a gap to allow other processes */
 584                         wl_unlock(lp, &flags);
 585                         wl_lock( lp, &flags );
 586
 587                         goto retry;
 588
 589                 } else {
 590                         DBG_TRACE( DbgInfo, "Get CFG_CUR_TX_RATE failed: %d retries\n", retries );
 591                         ret = -EFAULT;
 592                         goto out_unlock;
 593                 }
 594         }
 595
 596         /* Holding the lock too long, makes a gap to allow other processes */
 597         wl_unlock(lp, &flags);
 598         wl_lock( lp, &flags );
 599
 600         pTxRate = (__u16 *)&( lp->ltvRecord.u.u32 );
 601
 602         range->throughput = CNV_LITTLE_TO_INT( *pTxRate ) * MEGABIT;
 603
 604         if (retries > 0) {
 605                 DBG_TRACE( DbgInfo, "Get CFG_CUR_TX_RATE succes: %d retries\n", retries );
 606         }
 607
 608         // NWID - NOT SUPPORTED
 609
 610
 611         /* Channel/Frequency Info */
 612         range->num_channels = RADIO_CHANNELS;
 613
 614
 615         /* Signal Level Thresholds */
 616         range->sensitivity = RADIO_SENSITIVITY_LEVELS;
 617
 618
 619         /* Link quality */
 620         range->max_qual.qual     = (u_char)HCF_MAX_COMM_QUALITY;
 621
 622         /* If the value returned in /proc/net/wireless is greater than the maximum range,
 623            iwconfig assumes that the value is in dBm. Because an unsigned char is used,
 624            it requires a bit of contorsion... */
 625
 626         range->max_qual.level   = (u_char)( dbm( HCF_MIN_SIGNAL_LEVEL ) - 1 );
 627         range->max_qual.noise   = (u_char)( dbm( HCF_MIN_NOISE_LEVEL ) - 1 );
 628
 629
 630         /* Set available rates */
 631         range->num_bitrates = 0;
 632
 633         lp->ltvRecord.len = 6;
 634         lp->ltvRecord.typ = CFG_SUPPORTED_DATA_RATES;
 635
 636         status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
 637         if( status == HCF_SUCCESS ) {
 638                 for( count = 0; count < MAX_RATES; count++ )
 639                         if( lp->ltvRecord.u.u8[count+2] != 0 ) {
 640                                 range->bitrate[count] = lp->ltvRecord.u.u8[count+2] * MEGABIT / 2;
 641                                 range->num_bitrates++;
 642                         }
 643         } else {
 644                 DBG_TRACE( DbgInfo, "CFG_SUPPORTED_DATA_RATES: 0x%x\n", status );
 645                 ret = -EFAULT;
 646                 goto out_unlock;
 647         }
 648
 649         /* RTS Threshold info */
 650         range->min_rts   = MIN_RTS_BYTES;
 651         range->max_rts   = MAX_RTS_BYTES;
 652
 653         // Frag Threshold info - NOT SUPPORTED
 654
 655         // Power Management info - NOT SUPPORTED
 656
 657         /* Encryption */
 658
 659         /* Holding the lock too long, makes a gap to allow other processes */
 660         wl_unlock(lp, &flags);
 661         wl_lock( lp, &flags );
 662
 663         /* Is WEP supported? */
 664
 665         if( wl_has_wep( &( lp->hcfCtx ))) {
 666                 /* WEP: RC4 40 bits */
 667                 range->encoding_size[0]      = MIN_KEY_SIZE;
 668
 669                 /* RC4 ~128 bits */
 670                 range->encoding_size[1]      = MAX_KEY_SIZE;
 671                 range->num_encoding_sizes    = 2;
 672                 range->max_encoding_tokens   = MAX_KEYS;
 673         }
 674
 675         /* Tx Power Info */
 676         range->txpower_capa  = IW_TXPOW_MWATT;
 677         range->num_txpower   = 1;
 678         range->txpower[0]    = RADIO_TX_POWER_MWATT;
 679
 680         /* Wireless Extension Info */
 681         range->we_version_compiled   = WIRELESS_EXT;
 682         range->we_version_source     = WIRELESS_SUPPORT;
 683
 684         // Retry Limits and Lifetime - NOT SUPPORTED
 685
 686         /* Holding the lock too long, makes a gap to allow other processes */
 687         wl_unlock(lp, &flags);
 688         wl_lock( lp, &flags );
 689
 690         DBG_TRACE( DbgInfo, "calling wl_wireless_stats\n" );
 691         wl_wireless_stats( lp->dev );
 692         range->avg_qual = lp->wstats.qual;
 693         DBG_TRACE( DbgInfo, "wl_wireless_stats done\n" );
 694
 695         /* Event capability (kernel + driver) */
 696         IW_EVENT_CAPA_SET_KERNEL(range->event_capa);
 697         IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWAP);
 698         IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWSCAN);
 699         IW_EVENT_CAPA_SET(range->event_capa, IWEVREGISTERED);
 700         IW_EVENT_CAPA_SET(range->event_capa, IWEVEXPIRED);
 701         IW_EVENT_CAPA_SET(range->event_capa, IWEVMICHAELMICFAILURE);
 702         IW_EVENT_CAPA_SET(range->event_capa, IWEVASSOCREQIE);
 703         IW_EVENT_CAPA_SET(range->event_capa, IWEVASSOCRESPIE);
 704
 705         range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_CIPHER_TKIP;
 706         range->scan_capa = IW_SCAN_CAPA_NONE;
 707
 708 out_unlock:
 709         wl_act_int_on( lp );
 710
 711         wl_unlock(lp, &flags);
 712
 713         return ret;
 714 } // wireless_get_range
 715 /*============================================================================*/
 716
 717
 718 /*******************************************************************************
 719  *      wireless_get_bssid()
 720  *******************************************************************************
 721  *
 722  *  DESCRIPTION:
 723  *
 724  *      Gets the BSSID the wireless device is currently associated with.
 725  *
 726  *  PARAMETERS:
 727  *
 728  *      wrq - the wireless request buffer
 729  *      lp  - the device's private adapter structure
 730  *
 731  *  RETURNS:
 732  *
 733  *      0 on success
 734  *      errno value otherwise
 735  *
 736  ******************************************************************************/
 737 static int wireless_get_bssid(struct net_device *dev, struct iw_request_info *info, struct sockaddr *ap_addr, char *extra)
 738 {
 739         struct wl_private *lp = wl_priv(dev);
 740         unsigned long flags;
 741         int ret = 0;
 742 #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
 743         int status = -1;
 744 #endif /* (HCF_TYPE) & HCF_TYPE_STA */
 745
 746         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
 747                 ret = -EBUSY;
 748                 goto out;
 749         }
 750
 751         wl_lock( lp, &flags );
 752
 753         wl_act_int_off( lp );
 754
 755         ap_addr->sa_family = ARPHRD_ETHER;
 756
 757         /* Assume AP mode here, which means the BSSID is our own MAC address. In
 758            STA mode, this address will be overwritten with the actual BSSID using
 759            the code below. */
 760         memcpy(&ap_addr->sa_data, lp->dev->dev_addr, ETH_ALEN);
 761
 762
 763 #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
 764                                         //;?should we return an error status in AP mode
 765
 766         if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_STA  ) {
 767                 /* Get Current BSSID */
 768                 lp->ltvRecord.typ = CFG_CUR_BSSID;
 769                 lp->ltvRecord.len = 4;
 770                 status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
 771
 772                 if( status == HCF_SUCCESS ) {
 773                         /* Copy info into sockaddr struct */
 774                         memcpy(&ap_addr->sa_data, lp->ltvRecord.u.u8, ETH_ALEN);
 775                 } else {
 776                         ret = -EFAULT;
 777                 }
 778         }
 779
 780 #endif // (HCF_TYPE) & HCF_TYPE_STA
 781
 782         wl_act_int_on( lp );
 783
 784         wl_unlock(lp, &flags);
 785
 786 out:
 787         return ret;
 788 } // wireless_get_bssid
 789 /*============================================================================*/
 790
 791
 792
 793
 794 /*******************************************************************************
 795  *      wireless_get_ap_list()
 796  *******************************************************************************
 797  *
 798  *  DESCRIPTION:
 799  *
 800  *      Gets the results of a network scan.
 801  *
 802  *  PARAMETERS:
 803  *
 804  *      wrq - the wireless request buffer
 805  *      lp  - the device's private adapter structure
 806  *
 807  *  RETURNS:
 808  *
 809  *      0 on success
 810  *      errno value otherwise
 811  *
 812  *  NOTE: SIOCGIWAPLIST has been deprecated by SIOCSIWSCAN. This function
 813  *       implements SIOCGIWAPLIST only to provide backwards compatibility. For
 814  *       all systems using WIRELESS_EXT v14 and higher, use SIOCSIWSCAN!
 815  *
 816  ******************************************************************************/
 817 static int wireless_get_ap_list (struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *extra)
 818 {
 819         struct wl_private *lp = wl_priv(dev);
 820         unsigned long     flags;
 821         int                 ret;
 822         int                 num_aps = -1;
 823         int                 sec_count = 0;
 824         hcf_32              count;
 825         struct sockaddr     *hwa = NULL;
 826         struct iw_quality   *qual = NULL;
 827 #ifdef WARP
 828         ScanResult                      *p = &lp->scan_results;
 829 #else
 830         ProbeResult         *p = &lp->probe_results;
 831 #endif  // WARP
 832
 833         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
 834                 ret = -EBUSY;
 835                 goto out;
 836         }
 837
 838         wl_lock( lp, &flags );
 839
 840         wl_act_int_off( lp );
 841
 842         /* Set the completion state to FALSE */
 843         lp->scan_results.scan_complete = FALSE;
 844         lp->probe_results.scan_complete = FALSE;
 845         /* Channels to scan */
 846         lp->ltvRecord.len       = 2;
 847         lp->ltvRecord.typ       = CFG_SCAN_CHANNELS_2GHZ;
 848         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( 0x7FFF );
 849         ret = hcf_put_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
 850         DBG_TRACE( DbgInfo, "CFG_SCAN_CHANNELS_2GHZ result: 0x%x\n", ret );
 851
 852         /* Set the SCAN_SSID to "ANY". Using this RID for scan prevents the need to
 853            disassociate from the network we are currently on */
 854         lp->ltvRecord.len       = 2;
 855         lp->ltvRecord.typ       = CFG_SCAN_SSID;
 856         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( 0 );
 857         ret = hcf_put_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
 858         DBG_TRACE( DbgInfo, "CFG_SCAN_SSID to 'any' ret: 0x%x\n", ret );
 859
 860         /* Initiate the scan */
 861 #ifdef WARP
 862         ret = hcf_action( &( lp->hcfCtx ), MDD_ACT_SCAN );
 863 #else
 864         ret = hcf_action( &( lp->hcfCtx ), HCF_ACT_ACS_SCAN );
 865 #endif  // WARP
 866
 867         wl_act_int_on( lp );
 868
 869         //;? unlock? what about the access to lp below? is it broken?
 870         wl_unlock(lp, &flags);
 871
 872         if( ret == HCF_SUCCESS ) {
 873                 DBG_TRACE( DbgInfo, "SUCCESSFULLY INITIATED SCAN...\n" );
 874                 while( (*p).scan_complete == FALSE && ret == HCF_SUCCESS ) {
 875                         DBG_TRACE( DbgInfo, "Waiting for scan results...\n" );
 876                         /* Abort the scan if we've waited for more than MAX_SCAN_TIME_SEC */
 877                         if( sec_count++ > MAX_SCAN_TIME_SEC ) {
 878                                 ret = -EIO;
 879                         } else {
 880                                 /* Wait for 1 sec in 10ms intervals, scheduling the kernel to do
 881                                    other things in the meantime, This prevents system lockups by
 882                                    giving some time back to the kernel */
 883                                 for( count = 0; count < 100; count ++ ) {
 884                                         mdelay( 10 );
 885                                         schedule( );
 886                                 }
 887                         }
 888                 }
 889
 890                 rmb();
 891
 892                 if ( ret != HCF_SUCCESS ) {
 893                         DBG_ERROR( DbgInfo, "timeout waiting for scan results\n" );
 894                 } else {
 895                         num_aps             = (*p)/*lp->probe_results*/.num_aps;
 896                         if (num_aps > IW_MAX_AP) {
 897                                 num_aps = IW_MAX_AP;
 898                         }
 899                         data->length = num_aps;
 900                         hwa = (struct sockaddr *)extra;
 901                         qual = (struct iw_quality *) extra +
 902                                         ( sizeof( struct sockaddr ) * num_aps );
 903
 904                         /* This flag is used to tell the user if we provide quality
 905                            information. Since we provide signal/noise levels but no
 906                            quality info on a scan, this is set to 0. Setting to 1 and
 907                            providing a quality of 0 produces weird results. If we ever
 908                            provide quality (or can calculate it), this can be changed */
 909                         data->flags = 0;
 910
 911                         for( count = 0; count < num_aps; count++ ) {
 912 #ifdef WARP
 913                                 memcpy( hwa[count].sa_data,
 914                                                 (*p)/*lp->scan_results*/.APTable[count].bssid, ETH_ALEN );
 915 #else  //;?why use BSSID and bssid as names in seemingly very comparable situations
 916                                 DBG_PRINT("BSSID: %pM\n",
 917                                                 (*p).ProbeTable[count].BSSID);
 918                                 memcpy( hwa[count].sa_data,
 919                                                 (*p)/*lp->probe_results*/.ProbeTable[count].BSSID, ETH_ALEN );
 920 #endif // WARP
 921                         }
 922                         /* Once the data is copied to the wireless struct, invalidate the
 923                            scan result to initiate a rescan on the next request */
 924                         (*p)/*lp->probe_results*/.scan_complete = FALSE;
 925                         /* Send the wireless event that the scan has completed, just in case
 926                            it's needed */
 927                         wl_wext_event_scan_complete( lp->dev );
 928                 }
 929         }
 930 out:
 931         return ret;
 932 } // wireless_get_ap_list
 933 /*============================================================================*/
 934
 935
 936
 937
 938 /*******************************************************************************
 939  *      wireless_set_sensitivity()
 940  *******************************************************************************
 941  *
 942  *  DESCRIPTION:
 943  *
 944  *      Sets the sensitivity (distance between APs) of the wireless card.
 945  *
 946  *  PARAMETERS:
 947  *
 948  *      wrq - the wireless request buffer
 949  *      lp  - the device's private adapter structure
 950  *
 951  *  RETURNS:
 952  *
 953  *      0 on success
 954  *      errno value otherwise
 955  *
 956  ******************************************************************************/
 957 static int wireless_set_sensitivity(struct net_device *dev, struct iw_request_info *info, struct iw_param *sens, char *extra)
 958 {
 959         struct wl_private *lp = wl_priv(dev);
 960         unsigned long flags;
 961         int ret = 0;
 962         int dens = sens->value;
 963
 964         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
 965                 ret = -EBUSY;
 966                 goto out;
 967         }
 968
 969         if(( dens < 1 ) || ( dens > 3 )) {
 970                 ret = -EINVAL;
 971                 goto out;
 972         }
 973
 974         wl_lock( lp, &flags );
 975
 976         wl_act_int_off( lp );
 977
 978         lp->DistanceBetweenAPs = dens;
 979         wl_apply( lp );
 980
 981         wl_act_int_on( lp );
 982
 983         wl_unlock(lp, &flags);
 984
 985 out:
 986         return ret;
 987 } // wireless_set_sensitivity
 988 /*============================================================================*/
 989
 990
 991
 992
 993 /*******************************************************************************
 994  *      wireless_get_sensitivity()
 995  *******************************************************************************
 996  *
 997  *  DESCRIPTION:
 998  *
 999  *      Gets the sensitivity (distance between APs) of the wireless card.
1000  *
1001  *  PARAMETERS:
1002  *
1003  *      wrq - the wireless request buffer
1004  *      lp  - the device's private adapter structure
1005  *
1006  *  RETURNS:
1007  *
1008  *      0 on success
1009  *      errno value otherwise
1010  *
1011  ******************************************************************************/
1012 static int wireless_get_sensitivity(struct net_device *dev, struct iw_request_info *info, struct iw_param *sens, char *extra)
1013 {
1014         struct wl_private *lp = wl_priv(dev);
1015         int ret = 0;
1016
1017         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1018                 ret = -EBUSY;
1019                 goto out;
1020         }
1021
1022         /* not worth locking ... */
1023         sens->value = lp->DistanceBetweenAPs;
1024         sens->fixed = 0;        /* auto */
1025 out:
1026         return ret;
1027 } // wireless_get_sensitivity
1028 /*============================================================================*/
1029
1030
1031
1032
1033 /*******************************************************************************
1034  *      wireless_set_essid()
1035  *******************************************************************************
1036  *
1037  *  DESCRIPTION:
1038  *
1039  *      Sets the ESSID (network name) that the wireless device should associate
1040  *  with.
1041  *
1042  *  PARAMETERS:
1043  *
1044  *      wrq - the wireless request buffer
1045  *      lp  - the device's private adapter structure
1046  *
1047  *  RETURNS:
1048  *
1049  *      0 on success
1050  *      errno value otherwise
1051  *
1052  ******************************************************************************/
1053 static int wireless_set_essid(struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *ssid)
1054 {
1055         struct wl_private *lp = wl_priv(dev);
1056         unsigned long flags;
1057         int ret = 0;
1058
1059         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1060                 ret = -EBUSY;
1061                 goto out;
1062         }
1063
1064         if (data->flags != 0 && data->length > HCF_MAX_NAME_LEN) {
1065                 ret = -EINVAL;
1066                 goto out;
1067         }
1068
1069         wl_lock( lp, &flags );
1070
1071         wl_act_int_off( lp );
1072
1073         memset( lp->NetworkName, 0, sizeof( lp->NetworkName ));
1074
1075         /* data->flags is zero to ask for "any" */
1076         if( data->flags == 0 ) {
1077                 /* Need this because in STAP build PARM_DEFAULT_SSID is "LinuxAP"
1078                  * ;?but there ain't no STAP anymore*/
1079                 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_STA  ) {
1080                         strcpy( lp->NetworkName, "ANY" );
1081                 } else {
1082                         //strcpy( lp->NetworkName, "ANY" );
1083                         strcpy( lp->NetworkName, PARM_DEFAULT_SSID );
1084                 }
1085         } else {
1086                 memcpy( lp->NetworkName, ssid, data->length );
1087         }
1088
1089         DBG_NOTICE( DbgInfo, "set NetworkName: %s\n", ssid );
1090
1091         /* Commit the adapter parameters */
1092         wl_apply( lp );
1093
1094         /* Send an event that ESSID has been set */
1095         wl_wext_event_essid( lp->dev );
1096
1097         wl_act_int_on( lp );
1098
1099         wl_unlock(lp, &flags);
1100
1101 out:
1102         return ret;
1103 } // wireless_set_essid
1104 /*============================================================================*/
1105
1106
1107
1108
1109 /*******************************************************************************
1110  *      wireless_get_essid()
1111  *******************************************************************************
1112  *
1113  *  DESCRIPTION:
1114  *
1115  *      Gets the ESSID (network name) that the wireless device is associated
1116  *  with.
1117  *
1118  *  PARAMETERS:
1119  *
1120  *      wrq - the wireless request buffer
1121  *      lp  - the device's private adapter structure
1122  *
1123  *  RETURNS:
1124  *
1125  *      0 on success
1126  *      errno value otherwise
1127  *
1128  ******************************************************************************/
1129 static int wireless_get_essid(struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *essid)
1130
1131 {
1132         struct wl_private *lp = wl_priv(dev);
1133         unsigned long flags;
1134         int         ret = 0;
1135         int         status = -1;
1136         wvName_t    *pName;
1137
1138         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1139                 ret = -EBUSY;
1140                 goto out;
1141         }
1142
1143         wl_lock( lp, &flags );
1144
1145         wl_act_int_off( lp );
1146
1147         /* Get the desired network name */
1148         lp->ltvRecord.len = 1 + ( sizeof( *pName ) / sizeof( hcf_16 ));
1149
1150
1151 #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
1152                                         //;?should we return an error status in AP mode
1153
1154         lp->ltvRecord.typ = CFG_DESIRED_SSID;
1155
1156 #endif
1157
1158
1159 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
1160                 //;?should we restore this to allow smaller memory footprint
1161
1162         if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP  ) {
1163                 lp->ltvRecord.typ = CFG_CNF_OWN_SSID;
1164         }
1165
1166 #endif // HCF_AP
1167
1168
1169         status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1170         if( status == HCF_SUCCESS ) {
1171                 pName = (wvName_t *)&( lp->ltvRecord.u.u32 );
1172
1173                 /* Endian translate the string length */
1174                 pName->length = CNV_LITTLE_TO_INT( pName->length );
1175
1176                 /* Copy the information into the user buffer */
1177                 data->length = pName->length;
1178
1179                 if( pName->length < HCF_MAX_NAME_LEN ) {
1180                         pName->name[pName->length] = '\0';
1181                 }
1182
1183                 data->flags = 1;
1184
1185
1186 #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
1187                                         //;?should we return an error status in AP mode
1188
1189                 /* if desired is null ("any"), return current or "any" */
1190                 if( pName->name[0] == '\0' ) {
1191                         /* Get the current network name */
1192                         lp->ltvRecord.len = 1 + ( sizeof(*pName ) / sizeof( hcf_16 ));
1193                         lp->ltvRecord.typ = CFG_CUR_SSID;
1194
1195                         status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1196
1197                         if( status == HCF_SUCCESS ) {
1198                                 pName = (wvName_t *)&( lp->ltvRecord.u.u32 );
1199
1200                                 /* Endian translate the string length */
1201                                 pName->length = CNV_LITTLE_TO_INT( pName->length );
1202
1203                                 /* Copy the information into the user buffer */
1204                                 data->length = pName->length;
1205                                 data->flags = 1;
1206                         } else {
1207                                 ret = -EFAULT;
1208                                 goto out_unlock;
1209                         }
1210                 }
1211
1212 #endif // HCF_STA
1213
1214                 if (pName->length > IW_ESSID_MAX_SIZE) {
1215                         ret = -EFAULT;
1216                         goto out_unlock;
1217                 }
1218
1219                 memcpy(essid, pName->name, pName->length);
1220         } else {
1221                 ret = -EFAULT;
1222                 goto out_unlock;
1223         }
1224
1225 out_unlock:
1226         wl_act_int_on( lp );
1227
1228         wl_unlock(lp, &flags);
1229
1230 out:
1231         return ret;
1232 } // wireless_get_essid
1233 /*============================================================================*/
1234
1235
1236
1237
1238 /*******************************************************************************
1239  *      wireless_set_encode()
1240  *******************************************************************************
1241  *
1242  *  DESCRIPTION:
1243  *
1244  *     Sets the encryption keys and status (enable or disable).
1245  *
1246  *  PARAMETERS:
1247  *
1248  *      wrq - the wireless request buffer
1249  *      lp  - the device's private adapter structure
1250  *
1251  *  RETURNS:
1252  *
1253  *      0 on success
1254  *      errno value otherwise
1255  *
1256  ******************************************************************************/
1257 static int wireless_set_encode(struct net_device *dev, struct iw_request_info *info, struct iw_point *erq, char *keybuf)
1258 {
1259         struct wl_private *lp = wl_priv(dev);
1260         unsigned long flags;
1261         int key_idx = (erq->flags & IW_ENCODE_INDEX) - 1;
1262         int ret = 0;
1263         bool enable = true;
1264
1265         if (lp->portState == WVLAN_PORT_STATE_DISABLED) {
1266                 ret = -EBUSY;
1267                 goto out;
1268         }
1269
1270         if (erq->flags & IW_ENCODE_DISABLED)
1271                 enable = false;
1272
1273         wl_lock(lp, &flags);
1274
1275         wl_act_int_off(lp);
1276
1277         ret = hermes_set_wep_keys(lp, key_idx, keybuf, erq->length,
1278                                   enable, true);
1279
1280         /* Send an event that Encryption has been set */
1281         if (ret == 0)
1282                 wl_wext_event_encode(dev);
1283
1284         wl_act_int_on(lp);
1285
1286         wl_unlock(lp, &flags);
1287
1288 out:
1289         return ret;
1290 }
1291
1292 /*******************************************************************************
1293  *      wireless_get_encode()
1294  *******************************************************************************
1295  *
1296  *  DESCRIPTION:
1297  *
1298  *     Gets the encryption keys and status.
1299  *
1300  *  PARAMETERS:
1301  *
1302  *      wrq - the wireless request buffer
1303  *      lp  - the device's private adapter structure
1304  *
1305  *  RETURNS:
1306  *
1307  *      0 on success
1308  *      errno value otherwise
1309  *
1310  ******************************************************************************/
1311 static int wireless_get_encode(struct net_device *dev, struct iw_request_info *info, struct iw_point *erq, char *key)
1312
1313 {
1314         struct wl_private *lp = wl_priv(dev);
1315         unsigned long flags;
1316         int ret = 0;
1317         int index;
1318
1319         DBG_NOTICE(DbgInfo, "GIWENCODE: encrypt: %d, ID: %d\n", lp->EnableEncryption, lp->TransmitKeyID);
1320
1321         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1322                 ret = -EBUSY;
1323                 goto out;
1324         }
1325
1326         /* Only super-user can see WEP key */
1327         if( !capable( CAP_NET_ADMIN )) {
1328                 ret = -EPERM;
1329                 return ret;
1330         }
1331
1332         wl_lock( lp, &flags );
1333
1334         wl_act_int_off( lp );
1335
1336         /* Is it supported? */
1337         if( !wl_has_wep( &( lp->hcfCtx ))) {
1338                 ret = -EOPNOTSUPP;
1339                 goto out_unlock;
1340         }
1341
1342         /* Basic checking */
1343         index = (erq->flags & IW_ENCODE_INDEX ) - 1;
1344
1345
1346         /* Set the flags */
1347         erq->flags = 0;
1348
1349         if( lp->EnableEncryption == 0 ) {
1350                 erq->flags |= IW_ENCODE_DISABLED;
1351         }
1352
1353         /* Which key do we want */
1354         if(( index < 0 ) || ( index >= MAX_KEYS )) {
1355                 index = lp->TransmitKeyID - 1;
1356         }
1357
1358         erq->flags |= index + 1;
1359
1360         /* Copy the key to the user buffer */
1361         erq->length = lp->DefaultKeys.key[index].len;
1362
1363         memcpy(key, lp->DefaultKeys.key[index].key, erq->length);
1364
1365 out_unlock:
1366
1367         wl_act_int_on( lp );
1368
1369         wl_unlock(lp, &flags);
1370
1371 out:
1372         return ret;
1373 } // wireless_get_encode
1374 /*============================================================================*/
1375
1376
1377
1378
1379 /*******************************************************************************
1380  *      wireless_set_nickname()
1381  *******************************************************************************
1382  *
1383  *  DESCRIPTION:
1384  *
1385  *     Sets the nickname, or station name, of the wireless device.
1386  *
1387  *  PARAMETERS:
1388  *
1389  *      wrq - the wireless request buffer
1390  *      lp  - the device's private adapter structure
1391  *
1392  *  RETURNS:
1393  *
1394  *      0 on success
1395  *      errno value otherwise
1396  *
1397  ******************************************************************************/
1398 static int wireless_set_nickname(struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *nickname)
1399 {
1400         struct wl_private *lp = wl_priv(dev);
1401         unsigned long flags;
1402         int ret = 0;
1403
1404         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1405                 ret = -EBUSY;
1406                 goto out;
1407         }
1408
1409 #if 0 //;? Needed, was present in original code but not in 7.18 Linux 2.6 kernel version
1410         if( !capable(CAP_NET_ADMIN )) {
1411                 ret = -EPERM;
1412                 return ret;
1413         }
1414 #endif
1415
1416         /* Validate the new value */
1417         if(data->length > HCF_MAX_NAME_LEN) {
1418                 ret = -EINVAL;
1419                 goto out;
1420         }
1421
1422         wl_lock( lp, &flags );
1423
1424         wl_act_int_off( lp );
1425
1426         memset( lp->StationName, 0, sizeof( lp->StationName ));
1427
1428         memcpy( lp->StationName, nickname, data->length );
1429
1430         /* Commit the adapter parameters */
1431         wl_apply( lp );
1432
1433         wl_act_int_on( lp );
1434
1435         wl_unlock(lp, &flags);
1436
1437 out:
1438         return ret;
1439 } // wireless_set_nickname
1440 /*============================================================================*/
1441
1442
1443
1444
1445 /*******************************************************************************
1446  *      wireless_get_nickname()
1447  *******************************************************************************
1448  *
1449  *  DESCRIPTION:
1450  *
1451  *     Gets the nickname, or station name, of the wireless device.
1452  *
1453  *  PARAMETERS:
1454  *
1455  *      wrq - the wireless request buffer
1456  *      lp  - the device's private adapter structure
1457  *
1458  *  RETURNS:
1459  *
1460  *      0 on success
1461  *      errno value otherwise
1462  *
1463  ******************************************************************************/
1464 static int wireless_get_nickname(struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *nickname)
1465 {
1466         struct wl_private *lp = wl_priv(dev);
1467         unsigned long flags;
1468         int         ret = 0;
1469         int         status = -1;
1470         wvName_t    *pName;
1471
1472         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1473                 ret = -EBUSY;
1474                 goto out;
1475         }
1476
1477         wl_lock( lp, &flags );
1478
1479         wl_act_int_off( lp );
1480
1481         /* Get the current station name */
1482         lp->ltvRecord.len = 1 + ( sizeof( *pName ) / sizeof( hcf_16 ));
1483         lp->ltvRecord.typ = CFG_CNF_OWN_NAME;
1484
1485         status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1486
1487         if( status == HCF_SUCCESS ) {
1488                 pName = (wvName_t *)&( lp->ltvRecord.u.u32 );
1489
1490                 /* Endian translate the length */
1491                 pName->length = CNV_LITTLE_TO_INT( pName->length );
1492
1493                 if ( pName->length > IW_ESSID_MAX_SIZE ) {
1494                         ret = -EFAULT;
1495                 } else {
1496                         /* Copy the information into the user buffer */
1497                         data->length = pName->length;
1498                         memcpy(nickname, pName->name, pName->length);
1499                 }
1500         } else {
1501                 ret = -EFAULT;
1502         }
1503
1504         wl_act_int_on( lp );
1505
1506         wl_unlock(lp, &flags);
1507
1508 out:
1509         return ret;
1510 } // wireless_get_nickname
1511 /*============================================================================*/
1512
1513
1514
1515
1516 /*******************************************************************************
1517  *      wireless_set_porttype()
1518  *******************************************************************************
1519  *
1520  *  DESCRIPTION:
1521  *
1522  *     Sets the port type of the wireless device.
1523  *
1524  *  PARAMETERS:
1525  *
1526  *      wrq - the wireless request buffer
1527  *      lp  - the device's private adapter structure
1528  *
1529  *  RETURNS:
1530  *
1531  *      0 on success
1532  *      errno value otherwise
1533  *
1534  ******************************************************************************/
1535 static int wireless_set_porttype(struct net_device *dev, struct iw_request_info *info, __u32 *mode, char *extra)
1536 {
1537         struct wl_private *lp = wl_priv(dev);
1538         unsigned long flags;
1539         int ret = 0;
1540         hcf_16  portType;
1541         hcf_16  createIBSS;
1542
1543         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1544                 ret = -EBUSY;
1545                 goto out;
1546         }
1547
1548         wl_lock( lp, &flags );
1549
1550         wl_act_int_off( lp );
1551
1552         /* Validate the new value */
1553         switch( *mode ) {
1554         case IW_MODE_ADHOC:
1555
1556                 /* When user requests ad-hoc, set IBSS mode! */
1557                 portType         = 1;
1558                 createIBSS       = 1;
1559
1560                 lp->DownloadFirmware = WVLAN_DRV_MODE_STA; //1;
1561
1562                 break;
1563
1564
1565         case IW_MODE_AUTO:
1566         case IW_MODE_INFRA:
1567
1568                 /* Both automatic and infrastructure set port to BSS/STA mode */
1569                 portType         = 1;
1570                 createIBSS       = 0;
1571
1572                 lp->DownloadFirmware = WVLAN_DRV_MODE_STA; //1;
1573
1574                 break;
1575
1576
1577 #if 0 //;? (HCF_TYPE) & HCF_TYPE_AP
1578
1579         case IW_MODE_MASTER:
1580
1581                 /* Set BSS/AP mode */
1582                 portType             = 1;
1583
1584                 lp->CreateIBSS       = 0;
1585                 lp->DownloadFirmware = WVLAN_DRV_MODE_AP; //2;
1586
1587                 break;
1588
1589 #endif /* (HCF_TYPE) & HCF_TYPE_AP */
1590
1591
1592         default:
1593
1594                 portType   = 0;
1595                 createIBSS = 0;
1596                 ret = -EINVAL;
1597         }
1598
1599         if( portType != 0 ) {
1600                 /* Only do something if there is a mode change */
1601                 if( ( lp->PortType != portType ) || (lp->CreateIBSS != createIBSS)) {
1602                         lp->PortType   = portType;
1603                         lp->CreateIBSS = createIBSS;
1604
1605                         /* Commit the adapter parameters */
1606                         wl_go( lp );
1607
1608                         /* Send an event that mode has been set */
1609                         wl_wext_event_mode( lp->dev );
1610                 }
1611         }
1612
1613         wl_act_int_on( lp );
1614
1615         wl_unlock(lp, &flags);
1616
1617 out:
1618         return ret;
1619 } // wireless_set_porttype
1620 /*============================================================================*/
1621
1622
1623
1624
1625 /*******************************************************************************
1626  *      wireless_get_porttype()
1627  *******************************************************************************
1628  *
1629  *  DESCRIPTION:
1630  *
1631  *     Gets the port type of the wireless device.
1632  *
1633  *  PARAMETERS:
1634  *
1635  *      wrq - the wireless request buffer
1636  *      lp  - the device's private adapter structure
1637  *
1638  *  RETURNS:
1639  *
1640  *      0 on success
1641  *      errno value otherwise
1642  *
1643  ******************************************************************************/
1644 static int wireless_get_porttype(struct net_device *dev, struct iw_request_info *info, __u32 *mode, char *extra)
1645
1646 {
1647         struct wl_private *lp = wl_priv(dev);
1648         unsigned long flags;
1649         int     ret = 0;
1650         int     status = -1;
1651         hcf_16  *pPortType;
1652
1653         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1654                 ret = -EBUSY;
1655                 goto out;
1656         }
1657
1658         wl_lock( lp, &flags );
1659
1660         wl_act_int_off( lp );
1661
1662         /* Get the current port type */
1663         lp->ltvRecord.len = 1 + ( sizeof( *pPortType ) / sizeof( hcf_16 ));
1664         lp->ltvRecord.typ = CFG_CNF_PORT_TYPE;
1665
1666         status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
1667
1668         if( status == HCF_SUCCESS ) {
1669                 pPortType = (hcf_16 *)&( lp->ltvRecord.u.u32 );
1670
1671                 *pPortType = CNV_LITTLE_TO_INT( *pPortType );
1672
1673                 switch( *pPortType ) {
1674                 case 1:
1675
1676 #if 0
1677 #if (HCF_TYPE) & HCF_TYPE_AP
1678
1679                         if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP  ) {
1680                                 *mode = IW_MODE_MASTER;
1681                         } else {
1682                                 *mode = IW_MODE_INFRA;
1683                         }
1684
1685 #else
1686
1687                         *mode = IW_MODE_INFRA;
1688
1689 #endif  /* (HCF_TYPE) & HCF_TYPE_AP */
1690 #endif
1691
1692                         if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP  ) {
1693                                 *mode =  IW_MODE_MASTER;
1694                         } else {
1695                                 if( lp->CreateIBSS ) {
1696                                         *mode = IW_MODE_ADHOC;
1697                                 } else {
1698                                         *mode = IW_MODE_INFRA;
1699                                 }
1700                         }
1701
1702                         break;
1703
1704
1705                 case 3:
1706                         *mode = IW_MODE_ADHOC;
1707                         break;
1708
1709                 default:
1710                         ret = -EFAULT;
1711                         break;
1712                 }
1713         } else {
1714                 ret = -EFAULT;
1715         }
1716
1717         wl_act_int_on( lp );
1718
1719         wl_unlock(lp, &flags);
1720
1721 out:
1722         return ret;
1723 } // wireless_get_porttype
1724 /*============================================================================*/
1725
1726
1727
1728
1729 /*******************************************************************************
1730  *      wireless_set_power()
1731  *******************************************************************************
1732  *
1733  *  DESCRIPTION:
1734  *
1735  *     Sets the power management settings of the wireless device.
1736  *
1737  *  PARAMETERS:
1738  *
1739  *      wrq - the wireless request buffer
1740  *      lp  - the device's private adapter structure
1741  *
1742  *  RETURNS:
1743  *
1744  *      0 on success
1745  *      errno value otherwise
1746  *
1747  ******************************************************************************/
1748 static int wireless_set_power(struct net_device *dev, struct iw_request_info *info, struct iw_param *wrq, char *extra)
1749 {
1750         struct wl_private *lp = wl_priv(dev);
1751         unsigned long flags;
1752         int ret = 0;
1753
1754         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1755                 ret = -EBUSY;
1756                 goto out;
1757         }
1758
1759         DBG_PRINT( "THIS CORRUPTS PMEnabled ;?!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n" );
1760
1761 #if 0 //;? Needed, was present in original code but not in 7.18 Linux 2.6 kernel version
1762         if( !capable( CAP_NET_ADMIN )) {
1763                 ret = -EPERM;
1764                 return ret;
1765         }
1766 #endif
1767
1768         wl_lock( lp, &flags );
1769
1770         wl_act_int_off( lp );
1771
1772         /* Set the power management state based on the 'disabled' value */
1773         if( wrq->disabled ) {
1774                 lp->PMEnabled = 0;
1775         } else {
1776                 lp->PMEnabled = 1;
1777         }
1778
1779         /* Commit the adapter parameters */
1780         wl_apply( lp );
1781
1782         wl_act_int_on( lp );
1783
1784         wl_unlock(lp, &flags);
1785
1786 out:
1787         return ret;
1788 } // wireless_set_power
1789 /*============================================================================*/
1790
1791
1792
1793
1794 /*******************************************************************************
1795  *      wireless_get_power()
1796  *******************************************************************************
1797  *
1798  *  DESCRIPTION:
1799  *
1800  *     Gets the power management settings of the wireless device.
1801  *
1802  *  PARAMETERS:
1803  *
1804  *      wrq - the wireless request buffer
1805  *      lp  - the device's private adapter structure
1806  *
1807  *  RETURNS:
1808  *
1809  *      0 on success
1810  *      errno value otherwise
1811  *
1812  ******************************************************************************/
1813 static int wireless_get_power(struct net_device *dev, struct iw_request_info *info, struct iw_param *rrq, char *extra)
1814
1815 {
1816         struct wl_private *lp = wl_priv(dev);
1817         unsigned long flags;
1818         int ret = 0;
1819
1820         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1821                 ret = -EBUSY;
1822                 goto out;
1823         }
1824
1825         DBG_PRINT( "THIS IS PROBABLY AN OVER-SIMPLIFICATION ;?!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n" );
1826
1827         wl_lock( lp, &flags );
1828
1829         wl_act_int_off( lp );
1830
1831         rrq->flags = 0;
1832         rrq->value = 0;
1833
1834         if( lp->PMEnabled ) {
1835                 rrq->disabled = 0;
1836         } else {
1837                 rrq->disabled = 1;
1838         }
1839
1840         wl_act_int_on( lp );
1841
1842         wl_unlock(lp, &flags);
1843
1844 out:
1845         return ret;
1846 } // wireless_get_power
1847 /*============================================================================*/
1848
1849
1850
1851
1852 /*******************************************************************************
1853  *      wireless_get_tx_power()
1854  *******************************************************************************
1855  *
1856  *  DESCRIPTION:
1857  *
1858  *     Gets the transmit power of the wireless device's radio.
1859  *
1860  *  PARAMETERS:
1861  *
1862  *      wrq - the wireless request buffer
1863  *      lp  - the device's private adapter structure
1864  *
1865  *  RETURNS:
1866  *
1867  *      0 on success
1868  *      errno value otherwise
1869  *
1870  ******************************************************************************/
1871 static int wireless_get_tx_power(struct net_device *dev, struct iw_request_info *info, struct iw_param *rrq, char *extra)
1872 {
1873         struct wl_private *lp = wl_priv(dev);
1874         unsigned long flags;
1875         int ret = 0;
1876
1877         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1878                 ret = -EBUSY;
1879                 goto out;
1880         }
1881
1882         wl_lock( lp, &flags );
1883
1884         wl_act_int_off( lp );
1885
1886 #ifdef USE_POWER_DBM
1887         rrq->value = RADIO_TX_POWER_DBM;
1888         rrq->flags = IW_TXPOW_DBM;
1889 #else
1890         rrq->value = RADIO_TX_POWER_MWATT;
1891         rrq->flags = IW_TXPOW_MWATT;
1892 #endif
1893         rrq->fixed = 1;
1894         rrq->disabled = 0;
1895
1896         wl_act_int_on( lp );
1897
1898         wl_unlock(lp, &flags);
1899
1900 out:
1901         return ret;
1902 } // wireless_get_tx_power
1903 /*============================================================================*/
1904
1905
1906
1907
1908 /*******************************************************************************
1909  *      wireless_set_rts_threshold()
1910  *******************************************************************************
1911  *
1912  *  DESCRIPTION:
1913  *
1914  *     Sets the RTS threshold for the wireless card.
1915  *
1916  *  PARAMETERS:
1917  *
1918  *      wrq - the wireless request buffer
1919  *      lp  - the device's private adapter structure
1920  *
1921  *  RETURNS:
1922  *
1923  *      0 on success
1924  *      errno value otherwise
1925  *
1926  ******************************************************************************/
1927 static int wireless_set_rts_threshold (struct net_device *dev, struct iw_request_info *info, struct iw_param *rts, char *extra)
1928 {
1929         int ret = 0;
1930         struct wl_private *lp = wl_priv(dev);
1931         unsigned long flags;
1932         int rthr = rts->value;
1933
1934         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1935                 ret = -EBUSY;
1936                 goto out;
1937         }
1938
1939         if(rts->fixed == 0) {
1940                 ret = -EINVAL;
1941                 goto out;
1942         }
1943
1944         if( rts->disabled ) {
1945                 rthr = 2347;
1946         }
1947
1948         if(( rthr < 256 ) || ( rthr > 2347 )) {
1949                 ret = -EINVAL;
1950                 goto out;
1951         }
1952
1953         wl_lock( lp, &flags );
1954
1955         wl_act_int_off( lp );
1956
1957         lp->RTSThreshold = rthr;
1958
1959         wl_apply( lp );
1960
1961         wl_act_int_on( lp );
1962
1963         wl_unlock(lp, &flags);
1964
1965 out:
1966         return ret;
1967 } // wireless_set_rts_threshold
1968 /*============================================================================*/
1969
1970
1971
1972
1973 /*******************************************************************************
1974  *      wireless_get_rts_threshold()
1975  *******************************************************************************
1976  *
1977  *  DESCRIPTION:
1978  *
1979  *     Gets the RTS threshold for the wireless card.
1980  *
1981  *  PARAMETERS:
1982  *
1983  *      wrq - the wireless request buffer
1984  *      lp  - the device's private adapter structure
1985  *
1986  *  RETURNS:
1987  *
1988  *      0 on success
1989  *      errno value otherwise
1990  *
1991  ******************************************************************************/
1992 static int wireless_get_rts_threshold (struct net_device *dev, struct iw_request_info *info, struct iw_param *rts, char *extra)
1993 {
1994         int ret = 0;
1995         struct wl_private *lp = wl_priv(dev);
1996         unsigned long flags;
1997
1998         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
1999                 ret = -EBUSY;
2000                 goto out;
2001         }
2002
2003         wl_lock( lp, &flags );
2004
2005         wl_act_int_off( lp );
2006
2007         rts->value = lp->RTSThreshold;
2008
2009         rts->disabled = ( rts->value == 2347 );
2010
2011         rts->fixed = 1;
2012
2013         wl_act_int_on( lp );
2014
2015         wl_unlock(lp, &flags);
2016
2017 out:
2018         return ret;
2019 } // wireless_get_rts_threshold
2020 /*============================================================================*/
2021
2022
2023
2024
2025
2026 /*******************************************************************************
2027  *      wireless_set_rate()
2028  *******************************************************************************
2029  *
2030  *  DESCRIPTION:
2031  *
2032  *      Set the default data rate setting used by the wireless device.
2033  *
2034  *  PARAMETERS:
2035  *
2036  *      wrq - the wireless request buffer
2037  *      lp  - the device's private adapter structure
2038  *
2039  *  RETURNS:
2040  *
2041  *      0 on success
2042  *      errno value otherwise
2043  *
2044  ******************************************************************************/
2045 static int wireless_set_rate(struct net_device *dev, struct iw_request_info *info, struct iw_param *rrq, char *extra)
2046 {
2047         struct wl_private *lp = wl_priv(dev);
2048         unsigned long flags;
2049         int ret = 0;
2050 #ifdef WARP
2051         int status = -1;
2052         int index = 0;
2053 #endif  // WARP
2054
2055         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
2056                 ret = -EBUSY;
2057                 goto out;
2058         }
2059
2060         wl_lock( lp, &flags );
2061
2062         wl_act_int_off( lp );
2063
2064 #ifdef WARP
2065
2066         /* Determine if the card is operating in the 2.4 or 5.0 GHz band; check
2067            if Bit 9 is set in the current channel RID */
2068         lp->ltvRecord.len = 2;
2069         lp->ltvRecord.typ = CFG_CUR_CHANNEL;
2070
2071         status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
2072
2073         if( status == HCF_SUCCESS ) {
2074                 index = ( CNV_LITTLE_TO_INT( lp->ltvRecord.u.u16[0] ) & 0x100 ) ? 1 : 0;
2075
2076                 DBG_PRINT( "Index: %d\n", index );
2077         } else {
2078                 DBG_ERROR( DbgInfo, "Could not determine radio frequency\n" );
2079                 ret = -EINVAL;
2080                 goto out_unlock;
2081         }
2082
2083         if( rrq->value > 0 &&
2084                 rrq->value <= 1 * MEGABIT ) {
2085                 lp->TxRateControl[index] = 0x0001;
2086         }
2087         else if( rrq->value > 1 * MEGABIT &&
2088                         rrq->value <= 2 * MEGABIT ) {
2089                 if( rrq->fixed == 1 ) {
2090                         lp->TxRateControl[index] = 0x0002;
2091                 } else {
2092                         lp->TxRateControl[index] = 0x0003;
2093                 }
2094         }
2095         else if( rrq->value > 2 * MEGABIT &&
2096                         rrq->value <= 5 * MEGABIT ) {
2097                 if( rrq->fixed == 1 ) {
2098                         lp->TxRateControl[index] = 0x0004;
2099                 } else {
2100                         lp->TxRateControl[index] = 0x0007;
2101                 }
2102         }
2103         else if( rrq->value > 5 * MEGABIT &&
2104                         rrq->value <= 6 * MEGABIT ) {
2105                 if( rrq->fixed == 1 ) {
2106                         lp->TxRateControl[index] = 0x0010;
2107                 } else {
2108                         lp->TxRateControl[index] = 0x0017;
2109                 }
2110         }
2111         else if( rrq->value > 6 * MEGABIT &&
2112                         rrq->value <= 9 * MEGABIT ) {
2113                 if( rrq->fixed == 1 ) {
2114                         lp->TxRateControl[index] = 0x0020;
2115                 } else {
2116                         lp->TxRateControl[index] = 0x0037;
2117                 }
2118         }
2119         else if( rrq->value > 9 * MEGABIT &&
2120                         rrq->value <= 11 * MEGABIT ) {
2121                 if( rrq->fixed == 1 ) {
2122                         lp->TxRateControl[index] = 0x0008;
2123                 } else {
2124                         lp->TxRateControl[index] = 0x003F;
2125                 }
2126         }
2127         else if( rrq->value > 11 * MEGABIT &&
2128                         rrq->value <= 12 * MEGABIT ) {
2129                 if( rrq->fixed == 1 ) {
2130                         lp->TxRateControl[index] = 0x0040;
2131                 } else {
2132                         lp->TxRateControl[index] = 0x007F;
2133                 }
2134         }
2135         else if( rrq->value > 12 * MEGABIT &&
2136                         rrq->value <= 18 * MEGABIT ) {
2137                 if( rrq->fixed == 1 ) {
2138                         lp->TxRateControl[index] = 0x0080;
2139                 } else {
2140                         lp->TxRateControl[index] = 0x00FF;
2141                 }
2142         }
2143         else if( rrq->value > 18 * MEGABIT &&
2144                         rrq->value <= 24 * MEGABIT ) {
2145                 if( rrq->fixed == 1 ) {
2146                         lp->TxRateControl[index] = 0x0100;
2147                 } else {
2148                         lp->TxRateControl[index] = 0x01FF;
2149                 }
2150         }
2151         else if( rrq->value > 24 * MEGABIT &&
2152                         rrq->value <= 36 * MEGABIT ) {
2153                 if( rrq->fixed == 1 ) {
2154                         lp->TxRateControl[index] = 0x0200;
2155                 } else {
2156                         lp->TxRateControl[index] = 0x03FF;
2157                 }
2158         }
2159         else if( rrq->value > 36 * MEGABIT &&
2160                         rrq->value <= 48 * MEGABIT ) {
2161                 if( rrq->fixed == 1 ) {
2162                         lp->TxRateControl[index] = 0x0400;
2163                 } else {
2164                         lp->TxRateControl[index] = 0x07FF;
2165                 }
2166         }
2167         else if( rrq->value > 48 * MEGABIT &&
2168                         rrq->value <= 54 * MEGABIT ) {
2169                 if( rrq->fixed == 1 ) {
2170                         lp->TxRateControl[index] = 0x0800;
2171                 } else {
2172                         lp->TxRateControl[index] = 0x0FFF;
2173                 }
2174         }
2175         else if( rrq->fixed == 0 ) {
2176                 /* In this case, the user has not specified a bitrate, only the "auto"
2177                    moniker. So, set to all supported rates */
2178                 lp->TxRateControl[index] = PARM_MAX_TX_RATE;
2179         } else {
2180                 rrq->value = 0;
2181                 ret = -EINVAL;
2182                 goto out_unlock;
2183         }
2184
2185
2186 #else
2187
2188         if( rrq->value > 0 &&
2189                         rrq->value <= 1 * MEGABIT ) {
2190                 lp->TxRateControl[0] = 1;
2191         }
2192         else if( rrq->value > 1 * MEGABIT &&
2193                         rrq->value <= 2 * MEGABIT ) {
2194                 if( rrq->fixed ) {
2195                         lp->TxRateControl[0] = 2;
2196                 } else {
2197                         lp->TxRateControl[0] = 6;
2198                 }
2199         }
2200         else if( rrq->value > 2 * MEGABIT &&
2201                         rrq->value <= 5 * MEGABIT ) {
2202                 if( rrq->fixed ) {
2203                         lp->TxRateControl[0] = 4;
2204                 } else {
2205                         lp->TxRateControl[0] = 7;
2206                 }
2207         }
2208         else if( rrq->value > 5 * MEGABIT &&
2209                         rrq->value <= 11 * MEGABIT ) {
2210                 if( rrq->fixed)  {
2211                         lp->TxRateControl[0] = 5;
2212                 } else {
2213                         lp->TxRateControl[0] = 3;
2214                 }
2215         }
2216         else if( rrq->fixed == 0 ) {
2217                 /* In this case, the user has not specified a bitrate, only the "auto"
2218                    moniker. So, set the rate to 11Mb auto */
2219                 lp->TxRateControl[0] = 3;
2220         } else {
2221                 rrq->value = 0;
2222                 ret = -EINVAL;
2223                 goto out_unlock;
2224         }
2225
2226 #endif  // WARP
2227
2228
2229         /* Commit the adapter parameters */
2230         wl_apply( lp );
2231
2232 out_unlock:
2233
2234         wl_act_int_on( lp );
2235
2236         wl_unlock(lp, &flags);
2237
2238 out:
2239         return ret;
2240 } // wireless_set_rate
2241 /*============================================================================*/
2242
2243
2244
2245
2246 /*******************************************************************************
2247  *      wireless_get_rate()
2248  *******************************************************************************
2249  *
2250  *  DESCRIPTION:
2251  *
2252  *      Get the default data rate setting used by the wireless device.
2253  *
2254  *  PARAMETERS:
2255  *
2256  *      wrq - the wireless request buffer
2257  *      lp  - the device's private adapter structure
2258  *
2259  *  RETURNS:
2260  *
2261  *      0 on success
2262  *      errno value otherwise
2263  *
2264  ******************************************************************************/
2265 static int wireless_get_rate(struct net_device *dev, struct iw_request_info *info, struct iw_param *rrq, char *extra)
2266
2267 {
2268         struct wl_private *lp = wl_priv(dev);
2269         unsigned long flags;
2270         int     ret = 0;
2271         int     status = -1;
2272         hcf_16  txRate;
2273
2274         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
2275                 ret = -EBUSY;
2276                 goto out;
2277         }
2278
2279         wl_lock( lp, &flags );
2280
2281         wl_act_int_off( lp );
2282
2283         /* Get the current transmit rate from the adapter */
2284         lp->ltvRecord.len = 1 + ( sizeof(txRate)/sizeof(hcf_16));
2285         lp->ltvRecord.typ = CFG_CUR_TX_RATE;
2286
2287         status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
2288
2289         if( status == HCF_SUCCESS ) {
2290 #ifdef WARP
2291
2292                 txRate = CNV_LITTLE_TO_INT( lp->ltvRecord.u.u16[0] );
2293
2294                 if( txRate & 0x0001 ) {
2295                         txRate = 1;
2296                 }
2297                 else if( txRate & 0x0002 ) {
2298                         txRate = 2;
2299                 }
2300                 else if( txRate & 0x0004 ) {
2301                         txRate = 5;
2302                 }
2303                 else if( txRate & 0x0008 ) {
2304                         txRate = 11;
2305                 }
2306                 else if( txRate & 0x00010 ) {
2307                         txRate = 6;
2308                 }
2309                 else if( txRate & 0x00020 ) {
2310                         txRate = 9;
2311                 }
2312                 else if( txRate & 0x00040 ) {
2313                         txRate = 12;
2314                 }
2315                 else if( txRate & 0x00080 ) {
2316                         txRate = 18;
2317                 }
2318                 else if( txRate & 0x00100 ) {
2319                         txRate = 24;
2320                 }
2321                 else if( txRate & 0x00200 ) {
2322                         txRate = 36;
2323                 }
2324                 else if( txRate & 0x00400 ) {
2325                         txRate = 48;
2326                 }
2327                 else if( txRate & 0x00800 ) {
2328                         txRate = 54;
2329                 }
2330
2331 #else
2332
2333                 txRate = (hcf_16)CNV_LITTLE_TO_LONG( lp->ltvRecord.u.u32[0] );
2334
2335 #endif  // WARP
2336
2337                 rrq->value = txRate * MEGABIT;
2338         } else {
2339                 rrq->value = 0;
2340                 ret = -EFAULT;
2341         }
2342
2343         wl_act_int_on( lp );
2344
2345         wl_unlock(lp, &flags);
2346
2347 out:
2348         return ret;
2349 } // wireless_get_rate
2350 /*============================================================================*/
2351
2352
2353
2354
2355 #if 0 //;? Not used anymore
2356 /*******************************************************************************
2357  *      wireless_get_private_interface()
2358  *******************************************************************************
2359  *
2360  *  DESCRIPTION:
2361  *
2362  *      Returns the Linux Wireless Extensions' compatible private interface of
2363  *  the driver.
2364  *
2365  *  PARAMETERS:
2366  *
2367  *      wrq - the wireless request buffer
2368  *      lp  - the device's private adapter structure
2369  *
2370  *  RETURNS:
2371  *
2372  *      0 on success
2373  *      errno value otherwise
2374  *
2375  ******************************************************************************/
2376 int wireless_get_private_interface( struct iwreq *wrq, struct wl_private *lp )
2377 {
2378         int ret = 0;
2379
2380         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
2381                 ret = -EBUSY;
2382                 goto out;
2383         }
2384
2385         if( wrq->u.data.pointer != NULL ) {
2386                 struct iw_priv_args priv[] =
2387                 {
2388                         { SIOCSIWNETNAME, IW_PRIV_TYPE_CHAR | HCF_MAX_NAME_LEN, 0, "snetwork_name" },
2389                         { SIOCGIWNETNAME, 0, IW_PRIV_TYPE_CHAR | HCF_MAX_NAME_LEN, "gnetwork_name" },
2390                         { SIOCSIWSTANAME, IW_PRIV_TYPE_CHAR | HCF_MAX_NAME_LEN, 0, "sstation_name" },
2391                         { SIOCGIWSTANAME, 0, IW_PRIV_TYPE_CHAR | HCF_MAX_NAME_LEN, "gstation_name" },
2392                         { SIOCSIWPORTTYPE, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, 0, "sport_type" },
2393                         { SIOCGIWPORTTYPE, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, "gport_type" },
2394                 };
2395
2396                 /* Verify the user buffer */
2397                 ret = verify_area( VERIFY_WRITE, wrq->u.data.pointer, sizeof( priv ));
2398
2399                 if( ret != 0 )
2400                         return ret;
2401
2402                 /* Copy the data into the user's buffer */
2403                 wrq->u.data.length = NELEM( priv );
2404                 copy_to_user( wrq->u.data.pointer, &priv, sizeof( priv ));
2405         }
2406
2407 out:
2408         return ret;
2409 } // wireless_get_private_interface
2410 /*============================================================================*/
2411 #endif
2412
2413
2414
2415 /*******************************************************************************
2416  *      wireless_set_scan()
2417  *******************************************************************************
2418  *
2419  *  DESCRIPTION:
2420  *
2421  *      Instructs the driver to initiate a network scan.
2422  *
2423  *  PARAMETERS:
2424  *
2425  *      wrq - the wireless request buffer
2426  *      lp  - the device's private adapter structure
2427  *
2428  *  RETURNS:
2429  *
2430  *      0 on success
2431  *      errno value otherwise
2432  *
2433  ******************************************************************************/
2434 static int wireless_set_scan(struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *extra)
2435 {
2436         struct wl_private *lp = wl_priv(dev);
2437         unsigned long flags;
2438         int                 ret = 0;
2439         int                 status = -1;
2440         int                 retries = 0;
2441
2442         //;? Note: shows results as trace, returns always 0 unless BUSY
2443
2444         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
2445                 ret = -EBUSY;
2446                 goto out;
2447         }
2448
2449         wl_lock( lp, &flags );
2450
2451         wl_act_int_off( lp );
2452
2453         /*
2454          * This looks like a nice place to test if the HCF is still
2455          * communicating with the card. It seems that sometimes BAP_1
2456          * gets corrupted. By looking at the comments in HCF the
2457          * cause is still a mystery. Okay, the communication to the
2458          * card is dead, reset the card to revive.
2459          */
2460         if((lp->hcfCtx.IFB_CardStat & CARD_STAT_DEFUNCT) != 0)
2461         {
2462                 DBG_TRACE( DbgInfo, "CARD is in DEFUNCT mode, reset it to bring it back to life\n" );
2463                 wl_reset( dev );
2464         }
2465
2466 retry:
2467         /* Set the completion state to FALSE */
2468         lp->probe_results.scan_complete = FALSE;
2469
2470
2471         /* Channels to scan */
2472 #ifdef WARP
2473         lp->ltvRecord.len       = 5;
2474         lp->ltvRecord.typ       = CFG_SCAN_CHANNEL;
2475         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( 0x3FFF );  // 2.4 GHz Band
2476         lp->ltvRecord.u.u16[1]  = CNV_INT_TO_LITTLE( 0xFFFF );  // 5.0 GHz Band
2477         lp->ltvRecord.u.u16[2]  = CNV_INT_TO_LITTLE( 0xFFFF );  //      ..
2478         lp->ltvRecord.u.u16[3]  = CNV_INT_TO_LITTLE( 0x0007 );  //      ..
2479 #else
2480         lp->ltvRecord.len       = 2;
2481         lp->ltvRecord.typ       = CFG_SCAN_CHANNEL;
2482         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( 0x7FFF );
2483 #endif  // WARP
2484
2485         status = hcf_put_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
2486
2487         DBG_TRACE( DbgInfo, "CFG_SCAN_CHANNEL result      : 0x%x\n", status );
2488
2489         // Holding the lock too long, makes a gap to allow other processes
2490         wl_unlock(lp, &flags);
2491         wl_lock( lp, &flags );
2492
2493         if( status != HCF_SUCCESS ) {
2494                 //Recovery
2495                 retries++;
2496                 if(retries <= 10) {
2497                         DBG_TRACE( DbgInfo, "Reset card to recover, attempt: %d\n", retries );
2498                         wl_reset( dev );
2499
2500                         // Holding the lock too long, makes a gap to allow other processes
2501                         wl_unlock(lp, &flags);
2502                         wl_lock( lp, &flags );
2503
2504                         goto retry;
2505                 }
2506         }
2507
2508         /* Set the SCAN_SSID to "ANY". Using this RID for scan prevents the need to
2509            disassociate from the network we are currently on */
2510         lp->ltvRecord.len       = 18;
2511         lp->ltvRecord.typ       = CFG_SCAN_SSID;
2512         lp->ltvRecord.u.u16[0]  = CNV_INT_TO_LITTLE( 0 );
2513         lp->ltvRecord.u.u16[1]  = CNV_INT_TO_LITTLE( 0 );
2514
2515         status = hcf_put_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
2516
2517         // Holding the lock too long, makes a gap to allow other processes
2518         wl_unlock(lp, &flags);
2519         wl_lock( lp, &flags );
2520
2521         DBG_TRACE( DbgInfo, "CFG_SCAN_SSID to 'any' status: 0x%x\n", status );
2522
2523         /* Initiate the scan */
2524         /* NOTE: Using HCF_ACT_SCAN has been removed, as using HCF_ACT_ACS_SCAN to
2525            retrieve probe response must always be used to support WPA */
2526         status = hcf_action( &( lp->hcfCtx ), HCF_ACT_ACS_SCAN );
2527
2528         if( status == HCF_SUCCESS ) {
2529                 DBG_TRACE( DbgInfo, "SUCCESSFULLY INITIATED SCAN...\n" );
2530         } else {
2531                 DBG_TRACE( DbgInfo, "INITIATE SCAN FAILED...\n" );
2532         }
2533
2534         wl_act_int_on( lp );
2535
2536         wl_unlock(lp, &flags);
2537
2538 out:
2539         return ret;
2540 } // wireless_set_scan
2541 /*============================================================================*/
2542
2543
2544
2545
2546 /*******************************************************************************
2547  *      wireless_get_scan()
2548  *******************************************************************************
2549  *
2550  *  DESCRIPTION:
2551  *
2552  *      Instructs the driver to gather and return the results of a network scan.
2553  *
2554  *  PARAMETERS:
2555  *
2556  *      wrq - the wireless request buffer
2557  *      lp  - the device's private adapter structure
2558  *
2559  *  RETURNS:
2560  *
2561  *      0 on success
2562  *      errno value otherwise
2563  *
2564  ******************************************************************************/
2565 static int wireless_get_scan(struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *extra)
2566 {
2567         struct wl_private *lp = wl_priv(dev);
2568         unsigned long flags;
2569         int                 ret = 0;
2570         int                 count;
2571         char                *buf;
2572         char                *buf_end;
2573         struct iw_event     iwe;
2574         PROBE_RESP          *probe_resp;
2575         hcf_8               msg[512];
2576         hcf_8               *wpa_ie;
2577         hcf_16              wpa_ie_len;
2578
2579         if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
2580                 ret = -EBUSY;
2581                 goto out;
2582         }
2583
2584         wl_lock( lp, &flags );
2585
2586         wl_act_int_off( lp );
2587
2588         /* If the scan is not done, tell the calling process to try again later */
2589         if( !lp->probe_results.scan_complete ) {
2590                 ret = -EAGAIN;
2591                 goto out_unlock;
2592         }
2593
2594         DBG_TRACE( DbgInfo, "SCAN COMPLETE, Num of APs: %d\n",
2595                            lp->probe_results.num_aps );
2596
2597         buf     = extra;
2598         buf_end = extra + IW_SCAN_MAX_DATA;
2599
2600         for( count = 0; count < lp->probe_results.num_aps; count++ ) {
2601                 /* Reference the probe response from the table */
2602                 probe_resp = (PROBE_RESP *)&lp->probe_results.ProbeTable[count];
2603
2604
2605                 /* First entry MUST be the MAC address */
2606                 memset( &iwe, 0, sizeof( iwe ));
2607
2608                 iwe.cmd                 = SIOCGIWAP;
2609                 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
2610                 memcpy( iwe.u.ap_addr.sa_data, probe_resp->BSSID, ETH_ALEN);
2611                 iwe.len                 = IW_EV_ADDR_LEN;
2612
2613                 buf = iwe_stream_add_event(info, buf, buf_end,
2614                                            &iwe, IW_EV_ADDR_LEN);
2615
2616                 /* Use the mode to indicate if it's a station or AP */
2617                 /* Won't always be an AP if in IBSS mode */
2618                 memset( &iwe, 0, sizeof( iwe ));
2619
2620                 iwe.cmd = SIOCGIWMODE;
2621
2622                 if( probe_resp->capability & CAPABILITY_IBSS ) {
2623                         iwe.u.mode = IW_MODE_INFRA;
2624                 } else {
2625                         iwe.u.mode = IW_MODE_MASTER;
2626                 }
2627
2628                 iwe.len = IW_EV_UINT_LEN;
2629
2630                 buf = iwe_stream_add_event(info, buf, buf_end,
2631                                            &iwe, IW_EV_UINT_LEN);
2632
2633                 /* Any quality information */
2634                 memset(&iwe, 0, sizeof(iwe));
2635
2636                 iwe.cmd             = IWEVQUAL;
2637                 iwe.u.qual.level    = dbm(probe_resp->signal);
2638                 iwe.u.qual.noise    = dbm(probe_resp->silence);
2639                 iwe.u.qual.qual     = iwe.u.qual.level - iwe.u.qual.noise;
2640                 iwe.u.qual.updated  = lp->probe_results.scan_complete | IW_QUAL_DBM;
2641                 iwe.len             = IW_EV_QUAL_LEN;
2642
2643                 buf = iwe_stream_add_event(info, buf, buf_end,
2644                                            &iwe, IW_EV_QUAL_LEN);
2645
2646
2647                 /* ESSID information */
2648                 if( probe_resp->rawData[1] > 0 ) {
2649                         memset( &iwe, 0, sizeof( iwe ));
2650
2651                         iwe.cmd = SIOCGIWESSID;
2652                         iwe.u.data.length = probe_resp->rawData[1];
2653                         iwe.u.data.flags = 1;
2654
2655                         buf = iwe_stream_add_point(info, buf, buf_end,
2656                                                &iwe, &probe_resp->rawData[2]);
2657                 }
2658
2659
2660                 /* Encryption Information */
2661                 memset( &iwe, 0, sizeof( iwe ));
2662
2663                 iwe.cmd             = SIOCGIWENCODE;
2664                 iwe.u.data.length   = 0;
2665
2666                 /* Check the capabilities field of the Probe Response to see if
2667                    'privacy' is supported on the AP in question */
2668                 if( probe_resp->capability & CAPABILITY_PRIVACY ) {
2669                         iwe.u.data.flags |= IW_ENCODE_ENABLED;
2670                 } else {
2671                         iwe.u.data.flags |= IW_ENCODE_DISABLED;
2672                 }
2673
2674                 buf = iwe_stream_add_point(info, buf, buf_end, &iwe, NULL);
2675
2676
2677                 /* Frequency Info */
2678                 memset( &iwe, 0, sizeof( iwe ));
2679
2680                 iwe.cmd = SIOCGIWFREQ;
2681                 iwe.len = IW_EV_FREQ_LEN;
2682                 iwe.u.freq.m = wl_parse_ds_ie( probe_resp );
2683                 iwe.u.freq.e = 0;
2684
2685                 buf = iwe_stream_add_event(info, buf, buf_end,
2686                                            &iwe, IW_EV_FREQ_LEN);
2687
2688
2689                 /* Custom info (Beacon Interval) */
2690                 memset( &iwe, 0, sizeof( iwe ));
2691                 memset( msg, 0, sizeof( msg ));
2692
2693                 iwe.cmd = IWEVCUSTOM;
2694                 sprintf( msg, "beacon_interval=%d", probe_resp->beaconInterval );
2695                 iwe.u.data.length = strlen( msg );
2696
2697                 buf = iwe_stream_add_point(info, buf, buf_end, &iwe, msg);
2698
2699
2700                 /* WPA-IE */
2701                 wpa_ie = NULL;
2702                 wpa_ie_len = 0;
2703
2704                 wpa_ie = wl_parse_wpa_ie( probe_resp, &wpa_ie_len );
2705                 if( wpa_ie != NULL ) {
2706                         memset(&iwe, 0, sizeof(iwe));
2707
2708                         iwe.cmd = IWEVGENIE;
2709                         iwe.u.data.length = wpa_ie_len;
2710
2711                         buf = iwe_stream_add_point(info, buf, buf_end,
2712                                                    &iwe, wpa_ie);
2713                 }
2714
2715                 /* Add other custom info in formatted string format as needed... */
2716         }
2717
2718         data->length = buf - extra;
2719
2720 out_unlock:
2721
2722         wl_act_int_on( lp );
2723
2724         wl_unlock(lp, &flags);
2725
2726 out:
2727         return ret;
2728 } // wireless_get_scan
2729 /*============================================================================*/
2730
2731 #if DBG
2732 static const char * const auth_names[] = {
2733         "IW_AUTH_WPA_VERSION",
2734         "IW_AUTH_CIPHER_PAIRWISE",
2735         "IW_AUTH_CIPHER_GROUP",
2736         "IW_AUTH_KEY_MGMT",
2737         "IW_AUTH_TKIP_COUNTERMEASURES",
2738         "IW_AUTH_DROP_UNENCRYPTED",
2739         "IW_AUTH_80211_AUTH_ALG",
2740         "IW_AUTH_WPA_ENABLED",
2741         "IW_AUTH_RX_UNENCRYPTED_EAPOL",
2742         "IW_AUTH_ROAMING_CONTROL",
2743         "IW_AUTH_PRIVACY_INVOKED",
2744         "IW_AUTH_CIPHER_GROUP_MGMT",
2745         "IW_AUTH_MFP",
2746         "Unsupported"
2747 };
2748 #endif
2749
2750 static int wireless_set_auth(struct net_device *dev,
2751                           struct iw_request_info *info,
2752                           struct iw_param *data, char *extra)
2753 {
2754         struct wl_private *lp = wl_priv(dev);
2755         unsigned long flags;
2756         ltv_t ltv;
2757         int ret;
2758         int iwa_idx = data->flags & IW_AUTH_INDEX;
2759         int iwa_val = data->value;
2760
2761         if (lp->portState == WVLAN_PORT_STATE_DISABLED) {
2762                 ret = -EBUSY;
2763                 goto out;
2764         }
2765
2766         wl_lock( lp, &flags );
2767
2768         wl_act_int_off( lp );
2769
2770         if (iwa_idx > IW_AUTH_MFP)
2771                 iwa_idx = IW_AUTH_MFP + 1;
2772         DBG_TRACE(DbgInfo, "%s\n", auth_names[iwa_idx]);
2773         switch (iwa_idx) {
2774         case IW_AUTH_WPA_VERSION:
2775                 /* We do support WPA */
2776                 if ((iwa_val == IW_AUTH_WPA_VERSION_WPA) ||
2777                     (iwa_val == IW_AUTH_WPA_VERSION_DISABLED))
2778                         ret = 0;
2779                 else
2780                         ret = -EINVAL;
2781                 break;
2782
2783         case IW_AUTH_WPA_ENABLED:
2784                 DBG_TRACE(DbgInfo, "val = %d\n", iwa_val);
2785                 if (iwa_val)
2786                         lp->EnableEncryption = 2;
2787                 else
2788                         lp->EnableEncryption = 0;
2789
2790                 /* Write straight to the card */
2791                 ltv.len = 2;
2792                 ltv.typ = CFG_CNF_ENCRYPTION;
2793                 ltv.u.u16[0] = cpu_to_le16(lp->EnableEncryption);
2794                 ret = hcf_put_info(&lp->hcfCtx, (LTVP)&ltv);
2795
2796                 break;
2797
2798         case IW_AUTH_TKIP_COUNTERMEASURES:
2799
2800                 /* Immediately disable card */
2801                 lp->driverEnable = !iwa_val;
2802                 if (lp->driverEnable)
2803                         hcf_cntl(&(lp->hcfCtx), HCF_CNTL_ENABLE | HCF_PORT_0);
2804                 else
2805                         hcf_cntl(&(lp->hcfCtx), HCF_CNTL_DISABLE | HCF_PORT_0);
2806                 ret = 0;
2807                 break;
2808
2809         case IW_AUTH_MFP:
2810                 /* Management Frame Protection not supported.
2811                  * Only fail if set to required.
2812                  */
2813                 if (iwa_val == IW_AUTH_MFP_REQUIRED)
2814                         ret = -EINVAL;
2815                 else
2816                         ret = 0;
2817                 break;
2818
2819         case IW_AUTH_KEY_MGMT:
2820
2821                 /* Record required management suite.
2822                  * Will take effect on next commit */
2823                 if (iwa_val != 0)
2824                         lp->AuthKeyMgmtSuite = 4;
2825                 else
2826                         lp->AuthKeyMgmtSuite = 0;
2827
2828                 ret = -EINPROGRESS;
2829                 break;
2830
2831         case IW_AUTH_80211_AUTH_ALG:
2832
2833                 /* Just record whether open or shared is required.
2834                  * Will take effect on next commit */
2835                 ret = -EINPROGRESS;
2836
2837                 if (iwa_val & IW_AUTH_ALG_SHARED_KEY)
2838                         lp->authentication = 1;
2839                 else if (iwa_val & IW_AUTH_ALG_OPEN_SYSTEM)
2840                         lp->authentication = 0;
2841                 else
2842                         ret = -EINVAL;
2843                 break;
2844
2845         case IW_AUTH_DROP_UNENCRYPTED:
2846                 /* Only needed for AP */
2847                 lp->ExcludeUnencrypted = iwa_val;
2848                 ret = -EINPROGRESS;
2849                 break;
2850
2851         case IW_AUTH_CIPHER_PAIRWISE:
2852         case IW_AUTH_CIPHER_GROUP:
2853         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
2854         case IW_AUTH_ROAMING_CONTROL:
2855         case IW_AUTH_PRIVACY_INVOKED:
2856                 /* Not used. May need to do something with
2857                  * CIPHER_PAIRWISE and CIPHER_GROUP*/
2858                 ret = -EINPROGRESS;
2859                 break;
2860
2861         default:
2862                 DBG_TRACE(DbgInfo, "IW_AUTH_?? (%d) unknown\n", iwa_idx);
2863                 /* return an error */
2864                 ret = -EOPNOTSUPP;
2865                 break;
2866         }
2867
2868         wl_act_int_on( lp );
2869
2870         wl_unlock(lp, &flags);
2871
2872 out:
2873         return ret;
2874 } // wireless_set_auth
2875 /*============================================================================*/
2876
2877
2878 static void flush_tx(struct wl_private *lp)
2879 {
2880         ltv_t ltv;
2881         int count;
2882
2883         /*
2884          * Make sure that there is no data queued up in the firmware
2885          * before setting the TKIP keys. If this check is not
2886          * performed, some data may be sent out with incorrect MIC
2887          * and cause synchronization errors with the AP
2888          */
2889         /* Check every 1ms for 100ms */
2890         for (count = 0; count < 100; count++) {
2891                 udelay(1000);
2892
2893                 ltv.len = 2;
2894                 ltv.typ = 0xFD91;  /* This RID not defined in HCF yet!!! */
2895                 ltv.u.u16[0] = 0;
2896
2897                 hcf_get_info(&(lp->hcfCtx), (LTVP)&ltv);
2898
2899                 if (ltv.u.u16[0] == 0)
2900                         break;
2901         }
2902
2903         if (count >= 100)
2904                 DBG_TRACE(DbgInfo, "Timed out waiting for TxQ flush!\n");
2905
2906 }
2907
2908 static int wireless_set_encodeext(struct net_device *dev,
2909                                   struct iw_request_info *info,
2910                                   struct iw_point *erq, char *keybuf)
2911 {
2912         struct wl_private *lp = wl_priv(dev);
2913         unsigned long flags;
2914         int ret;
2915         int key_idx = (erq->flags & IW_ENCODE_INDEX) - 1;
2916         ltv_t ltv;
2917         struct iw_encode_ext *ext = (struct iw_encode_ext *)keybuf;
2918         bool enable = true;
2919         bool set_tx = false;
2920
2921         if (lp->portState == WVLAN_PORT_STATE_DISABLED) {
2922                 ret = -EBUSY;
2923                 goto out;
2924         }
2925
2926         if (erq->flags & IW_ENCODE_DISABLED) {
2927                 ext->alg = IW_ENCODE_ALG_NONE;
2928                 enable = false;
2929         }
2930
2931         if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
2932                 set_tx = true;
2933
2934         wl_lock(lp, &flags);
2935
2936         wl_act_int_off(lp);
2937
2938         memset(&ltv, 0, sizeof(ltv));
2939
2940         switch (ext->alg) {
2941         case IW_ENCODE_ALG_TKIP:
2942                 DBG_TRACE(DbgInfo, "IW_ENCODE_ALG_TKIP: key(%d)\n", key_idx);
2943
2944                 if (sizeof(ext->rx_seq) != 8) {
2945                         DBG_TRACE(DbgInfo, "rx_seq size mismatch\n");
2946                         ret = -EINVAL;
2947                         goto out_unlock;
2948                 }
2949
2950                 ret = hermes_set_tkip_keys(&ltv, key_idx, ext->addr.sa_data,
2951                                            set_tx,
2952                                            ext->rx_seq, ext->key, ext->key_len);
2953
2954                 if (ret != 0) {
2955                         DBG_TRACE(DbgInfo, "hermes_set_tkip_keys returned != 0, key not set\n");
2956                         goto out_unlock;
2957                 }
2958
2959                 flush_tx(lp);
2960
2961                 lp->wext_enc = IW_ENCODE_ALG_TKIP;
2962
2963                 /* Write the key */
2964                 ret = hcf_put_info(&(lp->hcfCtx), (LTVP)&ltv);
2965                 break;
2966
2967         case IW_ENCODE_ALG_WEP:
2968                 DBG_TRACE(DbgInfo, "IW_ENCODE_ALG_WEP: key(%d)\n", key_idx);
2969
2970                 if (erq->flags & IW_ENCODE_RESTRICTED) {
2971                         DBG_WARNING(DbgInfo, "IW_ENCODE_RESTRICTED invalid\n");
2972                         ret = -EINVAL;
2973                         goto out_unlock;
2974                 }
2975
2976                 ret = hermes_set_wep_keys(lp, key_idx, ext->key, ext->key_len,
2977                                           enable, set_tx);
2978
2979                 break;
2980
2981         case IW_ENCODE_ALG_CCMP:
2982                 DBG_TRACE(DbgInfo, "IW_ENCODE_ALG_CCMP: key(%d)\n", key_idx);
2983                 ret = -EOPNOTSUPP;
2984                 break;
2985
2986         case IW_ENCODE_ALG_NONE:
2987                 DBG_TRACE(DbgInfo, "IW_ENCODE_ALG_NONE: key(%d)\n", key_idx);
2988
2989                 if (lp->wext_enc == IW_ENCODE_ALG_TKIP) {
2990                         ret = hermes_clear_tkip_keys(&ltv, key_idx,
2991                                                      ext->addr.sa_data);
2992                         flush_tx(lp);
2993                         lp->wext_enc = IW_ENCODE_ALG_NONE;
2994                         ret = hcf_put_info(&(lp->hcfCtx), (LTVP)&ltv);
2995
2996                 } else if (lp->wext_enc == IW_ENCODE_ALG_WEP) {
2997                         ret = hermes_set_wep_keys(lp, key_idx,
2998                                                   ext->key, ext->key_len,
2999                                                   false, false);
3000                 } else {
3001                         ret = 0;
3002                 }
3003
3004                 break;
3005
3006         default:
3007                 DBG_TRACE( DbgInfo, "IW_ENCODE_??: key(%d)\n", key_idx);
3008                 ret = -EOPNOTSUPP;
3009                 break;
3010         }
3011
3012 out_unlock:
3013
3014         wl_act_int_on(lp);
3015
3016         wl_unlock(lp, &flags);
3017
3018 out:
3019         return ret;
3020 }
3021 /*============================================================================*/
3022
3023
3024
3025 static int wireless_set_genie(struct net_device *dev,
3026                               struct iw_request_info *info,
3027                               struct iw_point *data, char *extra)
3028
3029 {
3030         int   ret = 0;
3031
3032         /* We can't write this to the card, but apparently this
3033          * operation needs to succeed */
3034         ret = 0;
3035
3036         return ret;
3037 }
3038 /*============================================================================*/
3039
3040
3041 /*******************************************************************************
3042  *      wl_wireless_stats()
3043  *******************************************************************************
3044  *
3045  *  DESCRIPTION:
3046  *
3047  *      Return the current device wireless statistics.
3048  *
3049  *  PARAMETERS:
3050  *
3051  *      wrq - the wireless request buffer
3052  *      lp  - the device's private adapter structure
3053  *
3054  *  RETURNS:
3055  *
3056  *      0 on success
3057  *      errno value otherwise
3058  *
3059  ******************************************************************************/
3060 struct iw_statistics * wl_wireless_stats( struct net_device *dev )
3061 {
3062         struct iw_statistics    *pStats;
3063         struct wl_private       *lp = wl_priv(dev);
3064
3065         DBG_PARAM(DbgInfo, "dev", "%s (0x%p)", dev->name, dev);
3066
3067         pStats = NULL;
3068
3069         /* Initialize the statistics */
3070         pStats                  = &( lp->wstats );
3071         pStats->qual.updated    = 0x00;
3072
3073         if( !( lp->flags & WVLAN2_UIL_BUSY ))
3074         {
3075                 CFG_COMMS_QUALITY_STRCT *pQual;
3076                 CFG_HERMES_TALLIES_STRCT tallies;
3077                 int                         status;
3078
3079                 /* Update driver status */
3080                 pStats->status = 0;
3081
3082                 /* Get the current link quality information */
3083                 lp->ltvRecord.len = 1 + ( sizeof( *pQual ) / sizeof( hcf_16 ));
3084                 lp->ltvRecord.typ = CFG_COMMS_QUALITY;
3085                 status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
3086
3087                 if( status == HCF_SUCCESS ) {
3088                         pQual = (CFG_COMMS_QUALITY_STRCT *)&( lp->ltvRecord );
3089
3090                         pStats->qual.qual  = (u_char) CNV_LITTLE_TO_INT( pQual->coms_qual );
3091                         pStats->qual.level = (u_char) dbm( CNV_LITTLE_TO_INT( pQual->signal_lvl ));
3092                         pStats->qual.noise = (u_char) dbm( CNV_LITTLE_TO_INT( pQual->noise_lvl ));
3093
3094                         pStats->qual.updated |= (IW_QUAL_QUAL_UPDATED  |
3095                                                  IW_QUAL_LEVEL_UPDATED |
3096                                                  IW_QUAL_NOISE_UPDATED |
3097                                                  IW_QUAL_DBM);
3098                 } else {
3099                         memset( &( pStats->qual ), 0, sizeof( pStats->qual ));
3100                 }
3101
3102                 /* Get the current tallies from the adapter */
3103                 /* Only possible when the device is open */
3104                 if(lp->portState == WVLAN_PORT_STATE_DISABLED) {
3105                         if( wl_get_tallies( lp, &tallies ) == 0 ) {
3106                                 /* No endian translation is needed here, as CFG_TALLIES is an
3107                                    MSF RID; all processing is done on the host, not the card! */
3108                                 pStats->discard.nwid = 0L;
3109                                 pStats->discard.code = tallies.RxWEPUndecryptable;
3110                                 pStats->discard.misc = tallies.TxDiscards +
3111                                                        tallies.RxFCSErrors +
3112                                                        //tallies.RxDiscardsNoBuffer +
3113                                                        tallies.TxDiscardsWrongSA;
3114                                 //;? Extra taken over from Linux driver based on 7.18 version
3115                                 pStats->discard.retries = tallies.TxRetryLimitExceeded;
3116                                 pStats->discard.fragment = tallies.RxMsgInBadMsgFragments;
3117                         } else {
3118                                 memset( &( pStats->discard ), 0, sizeof( pStats->discard ));
3119                         }
3120                 } else {
3121                         memset( &( pStats->discard ), 0, sizeof( pStats->discard ));
3122                 }
3123         }
3124
3125         return pStats;
3126 } // wl_wireless_stats
3127 /*============================================================================*/
3128
3129
3130
3131
3132 /*******************************************************************************
3133  *      wl_get_wireless_stats()
3134  *******************************************************************************
3135  *
3136  *  DESCRIPTION:
3137  *
3138  *      Return the current device wireless statistics. This function calls
3139  *      wl_wireless_stats, but acquires spinlocks first as it can be called
3140  *      directly by the network layer.
3141  *
3142  *  PARAMETERS:
3143  *
3144  *      wrq - the wireless request buffer
3145  *      lp  - the device's private adapter structure
3146  *
3147  *  RETURNS:
3148  *
3149  *      0 on success
3150  *      errno value otherwise
3151  *
3152  ******************************************************************************/
3153 struct iw_statistics * wl_get_wireless_stats( struct net_device *dev )
3154 {
3155         unsigned long           flags;
3156         struct wl_private       *lp = wl_priv(dev);
3157         struct iw_statistics    *pStats = NULL;
3158
3159         wl_lock( lp, &flags );
3160
3161         wl_act_int_off( lp );
3162
3163 #ifdef USE_RTS
3164         if( lp->useRTS == 1 ) {
3165                 DBG_TRACE( DbgInfo, "Skipping wireless stats, in RTS mode\n" );
3166         } else
3167 #endif
3168         {
3169                 pStats = wl_wireless_stats( dev );
3170         }
3171         wl_act_int_on( lp );
3172
3173         wl_unlock(lp, &flags);
3174
3175         return pStats;
3176 } // wl_get_wireless_stats
3177
3178
3179 /*******************************************************************************
3180  *      wl_spy_gather()
3181  *******************************************************************************
3182  *
3183  *  DESCRIPTION:
3184  *
3185  *      Gather wireless spy statistics.
3186  *
3187  *  PARAMETERS:
3188  *
3189  *      wrq - the wireless request buffer
3190  *      lp  - the device's private adapter structure
3191  *
3192  *  RETURNS:
3193  *
3194  *      0 on success
3195  *      errno value otherwise
3196  *
3197  ******************************************************************************/
3198 inline void wl_spy_gather( struct net_device *dev, u_char *mac )
3199 {
3200         struct iw_quality wstats;
3201         int                     status;
3202         u_char                  stats[2];
3203         DESC_STRCT              desc[1];
3204         struct wl_private   *lp = wl_priv(dev);
3205         /*------------------------------------------------------------------------*/
3206
3207         /* shortcut */
3208         if (!lp->spy_data.spy_number) {
3209                 return;
3210         }
3211
3212         /* Gather wireless spy statistics: for each packet, compare the source
3213            address with out list, and if match, get the stats. */
3214         memset( stats, 0, sizeof(stats));
3215         memset( desc, 0, sizeof(DESC_STRCT));
3216
3217         desc[0].buf_addr        = stats;
3218         desc[0].BUF_SIZE        = sizeof(stats);
3219         desc[0].next_desc_addr  = 0;            // terminate list
3220
3221         status = hcf_rcv_msg( &( lp->hcfCtx ), &desc[0], 0 );
3222
3223         if( status == HCF_SUCCESS ) {
3224                 wstats.level = (u_char) dbm(stats[1]);
3225                 wstats.noise = (u_char) dbm(stats[0]);
3226                 wstats.qual  = wstats.level > wstats.noise ? wstats.level - wstats.noise : 0;
3227
3228                 wstats.updated = (IW_QUAL_QUAL_UPDATED  |
3229                                   IW_QUAL_LEVEL_UPDATED |
3230                                   IW_QUAL_NOISE_UPDATED |
3231                                   IW_QUAL_DBM);
3232
3233                 wireless_spy_update( dev, mac, &wstats );
3234         }
3235 } // wl_spy_gather
3236 /*============================================================================*/
3237
3238
3239
3240
3241 /*******************************************************************************
3242  *      wl_wext_event_freq()
3243  *******************************************************************************
3244  *
3245  *  DESCRIPTION:
3246  *
3247  *      This function is used to send an event that the channel/freq
3248  *      configuration for a specific device has changed.
3249  *
3250  *
3251  *  PARAMETERS:
3252  *
3253  *      dev - the network device for which this event is to be issued
3254  *
3255  *  RETURNS:
3256  *
3257  *      N/A
3258  *
3259  ******************************************************************************/
3260 void wl_wext_event_freq( struct net_device *dev )
3261 {
3262         union iwreq_data wrqu;
3263         struct wl_private *lp = wl_priv(dev);
3264         /*------------------------------------------------------------------------*/
3265
3266
3267         memset( &wrqu, 0, sizeof( wrqu ));
3268
3269         wrqu.freq.m = lp->Channel;
3270         wrqu.freq.e = 0;
3271
3272         wireless_send_event( dev, SIOCSIWFREQ, &wrqu, NULL );
3273
3274         return;
3275 } // wl_wext_event_freq
3276 /*============================================================================*/
3277
3278
3279
3280
3281 /*******************************************************************************
3282  *      wl_wext_event_mode()
3283  *******************************************************************************
3284  *
3285  *  DESCRIPTION:
3286  *
3287  *      This function is used to send an event that the mode of operation
3288  *      for a specific device has changed.
3289  *
3290  *
3291  *  PARAMETERS:
3292  *
3293  *      dev - the network device for which this event is to be issued
3294  *
3295  *  RETURNS:
3296  *
3297  *      N/A
3298  *
3299  ******************************************************************************/
3300 void wl_wext_event_mode( struct net_device *dev )
3301 {
3302         union iwreq_data wrqu;
3303         struct wl_private *lp = wl_priv(dev);
3304         /*------------------------------------------------------------------------*/
3305
3306
3307         memset( &wrqu, 0, sizeof( wrqu ));
3308
3309         if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_STA  ) {
3310                 wrqu.mode = IW_MODE_INFRA;
3311         } else {
3312                 wrqu.mode = IW_MODE_MASTER;
3313         }
3314
3315         wireless_send_event( dev, SIOCSIWMODE, &wrqu, NULL );
3316
3317         return;
3318 } // wl_wext_event_mode
3319 /*============================================================================*/
3320
3321
3322
3323
3324 /*******************************************************************************
3325  *      wl_wext_event_essid()
3326  *******************************************************************************
3327  *
3328  *  DESCRIPTION:
3329  *
3330  *      This function is used to send an event that the ESSID configuration for
3331  *      a specific device has changed.
3332  *
3333  *
3334  *  PARAMETERS:
3335  *
3336  *      dev - the network device for which this event is to be issued
3337  *
3338  *  RETURNS:
3339  *
3340  *      N/A
3341  *
3342  ******************************************************************************/
3343 void wl_wext_event_essid( struct net_device *dev )
3344 {
3345         union iwreq_data wrqu;
3346         struct wl_private *lp = wl_priv(dev);
3347         /*------------------------------------------------------------------------*/
3348
3349
3350         memset( &wrqu, 0, sizeof( wrqu ));
3351
3352         /* Fill out the buffer. Note that the buffer doesn't actually contain the
3353            ESSID, but a pointer to the contents. In addition, the 'extra' field of
3354            the call to wireless_send_event() must also point to where the ESSID
3355            lives */
3356         wrqu.essid.length  = strlen( lp->NetworkName );
3357         wrqu.essid.pointer = (caddr_t)lp->NetworkName;
3358         wrqu.essid.flags   = 1;
3359
3360         wireless_send_event( dev, SIOCSIWESSID, &wrqu, lp->NetworkName );
3361
3362         return;
3363 } // wl_wext_event_essid
3364 /*============================================================================*/
3365
3366
3367
3368
3369 /*******************************************************************************
3370  *      wl_wext_event_encode()
3371  *******************************************************************************
3372  *
3373  *  DESCRIPTION:
3374  *
3375  *      This function is used to send an event that the encryption configuration
3376  *      for a specific device has changed.
3377  *
3378  *
3379  *  PARAMETERS:
3380  *
3381  *      dev - the network device for which this event is to be issued
3382  *
3383  *  RETURNS:
3384  *
3385  *      N/A
3386  *
3387  ******************************************************************************/
3388 void wl_wext_event_encode( struct net_device *dev )
3389 {
3390         union iwreq_data wrqu;
3391         struct wl_private *lp = wl_priv(dev);
3392         int index = 0;
3393         /*------------------------------------------------------------------------*/
3394
3395
3396         memset( &wrqu, 0, sizeof( wrqu ));
3397
3398         if( lp->EnableEncryption == 0 ) {
3399                 wrqu.encoding.flags = IW_ENCODE_DISABLED;
3400         } else {
3401                 wrqu.encoding.flags |= lp->TransmitKeyID;
3402
3403                 index = lp->TransmitKeyID - 1;
3404
3405                 /* Only set IW_ENCODE_RESTRICTED/OPEN flag using lp->ExcludeUnencrypted
3406                    if we're in AP mode */
3407 #if 1 //;? (HCF_TYPE) & HCF_TYPE_AP
3408                 //;?should we restore this to allow smaller memory footprint
3409
3410                 if ( CNV_INT_TO_LITTLE( lp->hcfCtx.IFB_FWIdentity.comp_id ) == COMP_ID_FW_AP  ) {
3411                         if( lp->ExcludeUnencrypted ) {
3412                                 wrqu.encoding.flags |= IW_ENCODE_RESTRICTED;
3413                         } else {
3414                                 wrqu.encoding.flags |= IW_ENCODE_OPEN;
3415                         }
3416                 }
3417
3418 #endif  // HCF_TYPE_AP
3419
3420                 /* Only provide the key if permissions allow */
3421                 if( capable( CAP_NET_ADMIN )) {
3422                         wrqu.encoding.pointer = (caddr_t)lp->DefaultKeys.key[index].key;
3423                         wrqu.encoding.length  = lp->DefaultKeys.key[index].len;
3424                 } else {
3425                         wrqu.encoding.flags |= IW_ENCODE_NOKEY;
3426                 }
3427         }
3428
3429         wireless_send_event( dev, SIOCSIWENCODE, &wrqu,
3430                                                  lp->DefaultKeys.key[index].key );
3431
3432         return;
3433 } // wl_wext_event_encode
3434 /*============================================================================*/
3435
3436
3437
3438
3439 /*******************************************************************************
3440  *      wl_wext_event_ap()
3441  *******************************************************************************
3442  *
3443  *  DESCRIPTION:
3444  *
3445  *      This function is used to send an event that the device has been
3446  *      associated to a new AP.
3447  *
3448  *
3449  *  PARAMETERS:
3450  *
3451  *      dev - the network device for which this event is to be issued
3452  *
3453  *  RETURNS:
3454  *
3455  *      N/A
3456  *
3457  ******************************************************************************/
3458 void wl_wext_event_ap( struct net_device *dev )
3459 {
3460         union iwreq_data wrqu;
3461         struct wl_private *lp = wl_priv(dev);
3462         int status;
3463         /*------------------------------------------------------------------------*/
3464
3465
3466         /* Retrieve the WPA-IEs used by the firmware and send an event. We must send
3467            this event BEFORE sending the association event, as there are timing
3468            issues with the hostap supplicant. The supplicant will attempt to process
3469            an EAPOL-Key frame from an AP before receiving this information, which
3470            is required for a proper processed frame. */
3471         wl_wext_event_assoc_ie( dev );
3472
3473         /* Get the BSSID */
3474         lp->ltvRecord.typ = CFG_CUR_BSSID;
3475         lp->ltvRecord.len = 4;
3476
3477         status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
3478         if( status == HCF_SUCCESS ) {
3479                 memset( &wrqu, 0, sizeof( wrqu ));
3480
3481                 memcpy( wrqu.addr.sa_data, lp->ltvRecord.u.u8, ETH_ALEN );
3482
3483                 wrqu.addr.sa_family = ARPHRD_ETHER;
3484
3485                 wireless_send_event( dev, SIOCGIWAP, &wrqu, NULL );
3486         }
3487
3488         return;
3489 } // wl_wext_event_ap
3490 /*============================================================================*/
3491
3492
3493
3494 /*******************************************************************************
3495  *      wl_wext_event_scan_complete()
3496  *******************************************************************************
3497  *
3498  *  DESCRIPTION:
3499  *
3500  *      This function is used to send an event that a request for a network scan
3501  *      has completed.
3502  *
3503  *
3504  *  PARAMETERS:
3505  *
3506  *      dev - the network device for which this event is to be issued
3507  *
3508  *  RETURNS:
3509  *
3510  *      N/A
3511  *
3512  ******************************************************************************/
3513 void wl_wext_event_scan_complete( struct net_device *dev )
3514 {
3515         union iwreq_data wrqu;
3516         /*------------------------------------------------------------------------*/
3517
3518
3519         memset( &wrqu, 0, sizeof( wrqu ));
3520
3521         wrqu.addr.sa_family = ARPHRD_ETHER;
3522         wireless_send_event( dev, SIOCGIWSCAN, &wrqu, NULL );
3523
3524         return;
3525 } // wl_wext_event_scan_complete
3526 /*============================================================================*/
3527
3528
3529
3530
3531 /*******************************************************************************
3532  *      wl_wext_event_new_sta()
3533  *******************************************************************************
3534  *
3535  *  DESCRIPTION:
3536  *
3537  *      This function is used to send an event that an AP has registered a new
3538  *      station.
3539  *
3540  *
3541  *  PARAMETERS:
3542  *
3543  *      dev - the network device for which this event is to be issued
3544  *
3545  *  RETURNS:
3546  *
3547  *      N/A
3548  *
3549  ******************************************************************************/
3550 void wl_wext_event_new_sta( struct net_device *dev )
3551 {
3552         union iwreq_data wrqu;
3553         /*------------------------------------------------------------------------*/
3554
3555
3556         memset( &wrqu, 0, sizeof( wrqu ));
3557
3558         /* Send the station's mac address here */
3559         memcpy( wrqu.addr.sa_data, dev->dev_addr, ETH_ALEN );
3560         wrqu.addr.sa_family = ARPHRD_ETHER;
3561         wireless_send_event( dev, IWEVREGISTERED, &wrqu, NULL );
3562
3563         return;
3564 } // wl_wext_event_new_sta
3565 /*============================================================================*/
3566
3567
3568
3569
3570 /*******************************************************************************
3571  *      wl_wext_event_expired_sta()
3572  *******************************************************************************
3573  *
3574  *  DESCRIPTION:
3575  *
3576  *      This function is used to send an event that an AP has deregistered a
3577  *      station.
3578  *
3579  *
3580  *  PARAMETERS:
3581  *
3582  *      dev - the network device for which this event is to be issued
3583  *
3584  *  RETURNS:
3585  *
3586  *      N/A
3587  *
3588  ******************************************************************************/
3589 void wl_wext_event_expired_sta( struct net_device *dev )
3590 {
3591         union iwreq_data wrqu;
3592         /*------------------------------------------------------------------------*/
3593
3594
3595         memset( &wrqu, 0, sizeof( wrqu ));
3596
3597         memcpy( wrqu.addr.sa_data, dev->dev_addr, ETH_ALEN );
3598         wrqu.addr.sa_family = ARPHRD_ETHER;
3599         wireless_send_event( dev, IWEVEXPIRED, &wrqu, NULL );
3600
3601         return;
3602 } // wl_wext_event_expired_sta
3603 /*============================================================================*/
3604
3605
3606
3607
3608 /*******************************************************************************
3609  *      wl_wext_event_mic_failed()
3610  *******************************************************************************
3611  *
3612  *  DESCRIPTION:
3613  *
3614  *      This function is used to send an event that MIC calculations failed.
3615  *
3616  *
3617  *  PARAMETERS:
3618  *
3619  *      dev - the network device for which this event is to be issued
3620  *
3621  *  RETURNS:
3622  *
3623  *      N/A
3624  *
3625  ******************************************************************************/
3626 void wl_wext_event_mic_failed( struct net_device *dev )
3627 {
3628         union iwreq_data   wrqu;
3629         struct wl_private *lp = wl_priv(dev);
3630         struct iw_michaelmicfailure wxmic;
3631         int                key_idx;
3632         char              *addr1;
3633         char              *addr2;
3634         WVLAN_RX_WMP_HDR  *hdr;
3635         /*------------------------------------------------------------------------*/
3636
3637
3638         key_idx = lp->lookAheadBuf[HFS_STAT+1] >> 3;
3639         key_idx &= 0x03;
3640
3641         /* Cast the lookahead buffer into a RFS format */
3642         hdr = (WVLAN_RX_WMP_HDR *)&lp->lookAheadBuf[HFS_STAT];
3643
3644         /* Cast the addresses to byte buffers, as in the above RFS they are word
3645            length */
3646         addr1 = (char *)hdr->address1;
3647         addr2 = (char *)hdr->address2;
3648
3649         DBG_PRINT( "MIC FAIL - KEY USED : %d, STATUS : 0x%04x\n", key_idx,
3650                            hdr->status );
3651
3652         memset(&wrqu, 0, sizeof(wrqu));
3653         memset(&wxmic, 0, sizeof(wxmic));
3654
3655         wxmic.flags = key_idx & IW_MICFAILURE_KEY_ID;
3656         wxmic.flags |= (addr1[0] & 1) ?
3657                 IW_MICFAILURE_GROUP : IW_MICFAILURE_PAIRWISE;
3658         wxmic.src_addr.sa_family = ARPHRD_ETHER;
3659         memcpy(wxmic.src_addr.sa_data, addr2, ETH_ALEN);
3660
3661         wrqu.data.length = sizeof(wxmic);
3662         wireless_send_event(dev, IWEVMICHAELMICFAILURE, &wrqu, (char *)&wxmic);
3663
3664         return;
3665 } // wl_wext_event_mic_failed
3666 /*============================================================================*/
3667
3668
3669
3670
3671 /*******************************************************************************
3672  *      wl_wext_event_assoc_ie()
3673  *******************************************************************************
3674  *
3675  *  DESCRIPTION:
3676  *
3677  *      This function is used to send an event containing the WPA-IE generated
3678  *      by the firmware in an association request.
3679  *
3680  *
3681  *  PARAMETERS:
3682  *
3683  *      dev - the network device for which this event is to be issued
3684  *
3685  *  RETURNS:
3686  *
3687  *      N/A
3688  *
3689  ******************************************************************************/
3690 void wl_wext_event_assoc_ie( struct net_device *dev )
3691 {
3692         union iwreq_data   wrqu;
3693         struct wl_private *lp = wl_priv(dev);
3694         int status;
3695         PROBE_RESP         data;
3696         hcf_16             length;
3697         hcf_8              *wpa_ie;
3698         /*------------------------------------------------------------------------*/
3699
3700
3701         memset( &wrqu, 0, sizeof( wrqu ));
3702
3703         /* Retrieve the Association Request IE */
3704         lp->ltvRecord.len = 45;
3705         lp->ltvRecord.typ = CFG_CUR_ASSOC_REQ_INFO;
3706
3707         status = hcf_get_info( &( lp->hcfCtx ), (LTVP)&( lp->ltvRecord ));
3708         if( status == HCF_SUCCESS )
3709         {
3710                 length = 0;
3711                 memcpy( &data.rawData, &( lp->ltvRecord.u.u8[1] ), 88 );
3712                 wpa_ie = wl_parse_wpa_ie( &data, &length );
3713
3714                 if( length != 0 )
3715                 {
3716                         wrqu.data.length = wpa_ie[1] + 2;
3717                         wireless_send_event(dev, IWEVASSOCREQIE,
3718                                             &wrqu, wpa_ie);
3719
3720                         /* This bit is a hack. We send the respie
3721                          * event at the same time */
3722                         wireless_send_event(dev, IWEVASSOCRESPIE,
3723                                             &wrqu, wpa_ie);
3724                 }
3725         }
3726
3727         return;
3728 }  // wl_wext_event_assoc_ie
3729 /*============================================================================*/
3730 /* Structures to export the Wireless Handlers */
3731
3732 static const iw_handler wl_handler[] =
3733 {
3734         IW_HANDLER(SIOCSIWCOMMIT, (iw_handler) wireless_commit),
3735         IW_HANDLER(SIOCGIWNAME, (iw_handler) wireless_get_protocol),
3736         IW_HANDLER(SIOCSIWFREQ, (iw_handler) wireless_set_frequency),
3737         IW_HANDLER(SIOCGIWFREQ, (iw_handler) wireless_get_frequency),
3738         IW_HANDLER(SIOCSIWMODE, (iw_handler) wireless_set_porttype),
3739         IW_HANDLER(SIOCGIWMODE, (iw_handler) wireless_get_porttype),
3740         IW_HANDLER(SIOCSIWSENS, (iw_handler) wireless_set_sensitivity),
3741         IW_HANDLER(SIOCGIWSENS, (iw_handler) wireless_get_sensitivity),
3742         IW_HANDLER(SIOCGIWRANGE, (iw_handler) wireless_get_range),
3743         IW_HANDLER(SIOCSIWSPY, iw_handler_set_spy),
3744         IW_HANDLER(SIOCGIWSPY, iw_handler_get_spy),
3745 #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
3746         IW_HANDLER(SIOCGIWAP, (iw_handler) wireless_get_bssid),
3747 #endif
3748         IW_HANDLER(SIOCGIWAPLIST, (iw_handler) wireless_get_ap_list),
3749         IW_HANDLER(SIOCSIWSCAN, (iw_handler) wireless_set_scan),
3750         IW_HANDLER(SIOCGIWSCAN, (iw_handler) wireless_get_scan),
3751         IW_HANDLER(SIOCSIWESSID, (iw_handler) wireless_set_essid),
3752         IW_HANDLER(SIOCGIWESSID, (iw_handler) wireless_get_essid),
3753         IW_HANDLER(SIOCSIWNICKN, (iw_handler) wireless_set_nickname),
3754         IW_HANDLER(SIOCGIWNICKN, (iw_handler) wireless_get_nickname),
3755         IW_HANDLER(SIOCSIWRATE, (iw_handler) wireless_set_rate),
3756         IW_HANDLER(SIOCGIWRATE, (iw_handler) wireless_get_rate),
3757         IW_HANDLER(SIOCSIWRTS, (iw_handler) wireless_set_rts_threshold),
3758         IW_HANDLER(SIOCGIWRTS, (iw_handler) wireless_get_rts_threshold),
3759         IW_HANDLER(SIOCGIWTXPOW, (iw_handler) wireless_get_tx_power),
3760         IW_HANDLER(SIOCSIWENCODE, (iw_handler) wireless_set_encode),
3761         IW_HANDLER(SIOCGIWENCODE, (iw_handler) wireless_get_encode),
3762         IW_HANDLER(SIOCSIWPOWER, (iw_handler) wireless_set_power),
3763         IW_HANDLER(SIOCGIWPOWER, (iw_handler) wireless_get_power),
3764         IW_HANDLER(SIOCSIWGENIE, (iw_handler) wireless_set_genie),
3765         IW_HANDLER(SIOCSIWAUTH, (iw_handler) wireless_set_auth),
3766         IW_HANDLER(SIOCSIWENCODEEXT, (iw_handler) wireless_set_encodeext),
3767 };
3768
3769 static const iw_handler wl_private_handler[] =
3770 {                                                       /* SIOCIWFIRSTPRIV + */
3771                 wvlan_set_netname,                      /* 0: SIOCSIWNETNAME */
3772                 wvlan_get_netname,                      /* 1: SIOCGIWNETNAME */
3773                 wvlan_set_station_nickname,             /* 2: SIOCSIWSTANAME */
3774                 wvlan_get_station_nickname,             /* 3: SIOCGIWSTANAME */
3775 #if 1 //;? (HCF_TYPE) & HCF_TYPE_STA
3776                 wvlan_set_porttype,                     /* 4: SIOCSIWPORTTYPE */
3777                 wvlan_get_porttype,                     /* 5: SIOCGIWPORTTYPE */
3778 #endif
3779 };
3780
3781 struct iw_priv_args wl_priv_args[] = {
3782         {SIOCSIWNETNAME,    IW_PRIV_TYPE_CHAR | HCF_MAX_NAME_LEN, 0, "snetwork_name" },
3783         {SIOCGIWNETNAME, 0, IW_PRIV_TYPE_CHAR | HCF_MAX_NAME_LEN,    "gnetwork_name" },
3784         {SIOCSIWSTANAME,    IW_PRIV_TYPE_CHAR | HCF_MAX_NAME_LEN, 0, "sstation_name" },
3785         {SIOCGIWSTANAME, 0, IW_PRIV_TYPE_CHAR | HCF_MAX_NAME_LEN,    "gstation_name" },
3786 #if 1 //;? #if (HCF_TYPE) & HCF_TYPE_STA
3787         {SIOCSIWPORTTYPE,    IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "sport_type" },
3788         {SIOCGIWPORTTYPE, 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,    "gport_type" },
3789 #endif
3790 };
3791
3792 const struct iw_handler_def wl_iw_handler_def =
3793 {
3794         .num_private        = sizeof(wl_private_handler) / sizeof(iw_handler),
3795         .private            = (iw_handler *) wl_private_handler,
3796         .private_args       = (struct iw_priv_args *) wl_priv_args,
3797         .num_private_args   = sizeof(wl_priv_args) / sizeof(struct iw_priv_args),
3798         .num_standard       = sizeof(wl_handler) / sizeof(iw_handler),
3799         .standard           = (iw_handler *) wl_handler,
3800         .get_wireless_stats = wl_get_wireless_stats,
3801 };