git.oblomov.eu Git - linux-2.6/blob - drivers/staging/rt3070/rt_profile.c

   1 /*
   2  *************************************************************************
   3  * Ralink Tech Inc.
   4  * 5F., No.36, Taiyuan St., Jhubei City,
   5  * Hsinchu County 302,
   6  * Taiwan, R.O.C.
   7  *
   8  * (c) Copyright 2002-2007, Ralink Technology, Inc.
   9  *
  10  * This program is free software; you can redistribute it and/or modify  *
  11  * it under the terms of the GNU General Public License as published by  *
  12  * the Free Software Foundation; either version 2 of the License, or     *
  13  * (at your option) any later version.                                   *
  14  *                                                                       *
  15  * This program is distributed in the hope that it will be useful,       *
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  18  * GNU General Public License for more details.                          *
  19  *                                                                       *
  20  * You should have received a copy of the GNU General Public License     *
  21  * along with this program; if not, write to the                         *
  22  * Free Software Foundation, Inc.,                                       *
  23  * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  24  *                                                                       *
  25  *************************************************************************
  26  */
  27
  28 #include "rt_config.h"
  29
  30 #ifdef DOT11_N_SUPPORT
  31 static void HTParametersHook(
  32         IN      PRTMP_ADAPTER pAd,
  33         IN      CHAR              *pValueStr,
  34         IN      CHAR              *pInput);
  35 #endif // DOT11_N_SUPPORT //
  36
  37 #define ETH_MAC_ADDR_STR_LEN 17  // in format of xx:xx:xx:xx:xx:xx
  38
  39 // We assume the s1 is a sting, s2 is a memory space with 6 bytes. and content of s1 will be changed.
  40 BOOLEAN rtstrmactohex(char *s1, char *s2)
  41 {
  42         int i = 0;
  43         char *ptokS = s1, *ptokE = s1;
  44
  45         if (strlen(s1) != ETH_MAC_ADDR_STR_LEN)
  46                 return FALSE;
  47
  48         while((*ptokS) != '\0')
  49         {
  50                 if((ptokE = strchr(ptokS, ':')) != NULL)
  51                         *ptokE++ = '\0';
  52                 if ((strlen(ptokS) != 2) || (!isxdigit(*ptokS)) || (!isxdigit(*(ptokS+1))))
  53                         break; // fail
  54                 AtoH(ptokS, &s2[i++], 1);
  55                 ptokS = ptokE;
  56                 if (i == 6)
  57                         break; // parsing finished
  58         }
  59
  60         return ( i == 6 ? TRUE : FALSE);
  61
  62 }
  63
  64
  65 // we assume the s1 and s2 both are strings.
  66 BOOLEAN rtstrcasecmp(char *s1, char *s2)
  67 {
  68         char *p1 = s1, *p2 = s2;
  69
  70         if (strlen(s1) != strlen(s2))
  71                 return FALSE;
  72
  73         while(*p1 != '\0')
  74         {
  75                 if((*p1 != *p2) && ((*p1 ^ *p2) != 0x20))
  76                         return FALSE;
  77                 p1++;
  78                 p2++;
  79         }
  80
  81         return TRUE;
  82 }
  83
  84 // we assume the s1 (buffer) and s2 (key) both are strings.
  85 char * rtstrstruncasecmp(char * s1, char * s2)
  86 {
  87         INT l1, l2, i;
  88         char temp1, temp2;
  89
  90         l2 = strlen(s2);
  91         if (!l2)
  92                 return (char *) s1;
  93
  94         l1 = strlen(s1);
  95
  96         while (l1 >= l2)
  97         {
  98                 l1--;
  99
 100                 for(i=0; i<l2; i++)
 101                 {
 102                         temp1 = *(s1+i);
 103                         temp2 = *(s2+i);
 104
 105                         if (('a' <= temp1) && (temp1 <= 'z'))
 106                                 temp1 = 'A'+(temp1-'a');
 107                         if (('a' <= temp2) && (temp2 <= 'z'))
 108                                 temp2 = 'A'+(temp2-'a');
 109
 110                         if (temp1 != temp2)
 111                                 break;
 112                 }
 113
 114                 if (i == l2)
 115                         return (char *) s1;
 116
 117                 s1++;
 118         }
 119
 120         return NULL; // not found
 121 }
 122
 123 //add by kathy
 124
 125  /**
 126   * strstr - Find the first substring in a %NUL terminated string
 127   * @s1: The string to be searched
 128   * @s2: The string to search for
 129   */
 130 char * rtstrstr(const char * s1,const char * s2)
 131 {
 132         INT l1, l2;
 133
 134         l2 = strlen(s2);
 135         if (!l2)
 136                 return (char *) s1;
 137
 138         l1 = strlen(s1);
 139
 140         while (l1 >= l2)
 141         {
 142                 l1--;
 143                 if (!memcmp(s1,s2,l2))
 144                         return (char *) s1;
 145                 s1++;
 146         }
 147
 148         return NULL;
 149 }
 150
 151 /**
 152  * rstrtok - Split a string into tokens
 153  * @s: The string to be searched
 154  * @ct: The characters to search for
 155  * * WARNING: strtok is deprecated, use strsep instead. However strsep is not compatible with old architecture.
 156  */
 157 char * __rstrtok;
 158 char * rstrtok(char * s,const char * ct)
 159 {
 160         char *sbegin, *send;
 161
 162         sbegin  = s ? s : __rstrtok;
 163         if (!sbegin)
 164         {
 165                 return NULL;
 166         }
 167
 168         sbegin += strspn(sbegin,ct);
 169         if (*sbegin == '\0')
 170         {
 171                 __rstrtok = NULL;
 172                 return( NULL );
 173         }
 174
 175         send = strpbrk( sbegin, ct);
 176         if (send && *send != '\0')
 177                 *send++ = '\0';
 178
 179         __rstrtok = send;
 180
 181         return (sbegin);
 182 }
 183
 184 /**
 185  * delimitcnt - return the count of a given delimiter in a given string.
 186  * @s: The string to be searched.
 187  * @ct: The delimiter to search for.
 188  * Notice : We suppose the delimiter is a single-char string(for example : ";").
 189  */
 190 INT delimitcnt(char * s,const char * ct)
 191 {
 192         INT count = 0;
 193         /* point to the beginning of the line */
 194         const char *token = s;
 195
 196         for ( ;; )
 197         {
 198                 token = strpbrk(token, ct); /* search for delimiters */
 199
 200         if ( token == NULL )
 201                 {
 202                         /* advanced to the terminating null character */
 203                         break;
 204                 }
 205                 /* skip the delimiter */
 206             ++token;
 207
 208                 /*
 209                  * Print the found text: use len with %.*s to specify field width.
 210                  */
 211
 212                 /* accumulate delimiter count */
 213             ++count;
 214         }
 215     return count;
 216 }
 217
 218 /*
 219   * converts the Internet host address from the standard numbers-and-dots notation
 220   * into binary data.
 221   * returns nonzero if the address is valid, zero if not.
 222   */
 223 int rtinet_aton(const char *cp, unsigned int *addr)
 224 {
 225         unsigned int    val;
 226         int             base, n;
 227         char            c;
 228         unsigned int    parts[4];
 229         unsigned int    *pp = parts;
 230
 231         for (;;)
 232     {
 233          /*
 234           * Collect number up to ``.''.
 235           * Values are specified as for C:
 236           *     0x=hex, 0=octal, other=decimal.
 237           */
 238          val = 0;
 239          base = 10;
 240          if (*cp == '0')
 241          {
 242              if (*++cp == 'x' || *cp == 'X')
 243                  base = 16, cp++;
 244              else
 245                  base = 8;
 246          }
 247          while ((c = *cp) != '\0')
 248          {
 249              if (isdigit((unsigned char) c))
 250              {
 251                  val = (val * base) + (c - '0');
 252                  cp++;
 253                  continue;
 254              }
 255              if (base == 16 && isxdigit((unsigned char) c))
 256              {
 257                  val = (val << 4) +
 258                      (c + 10 - (islower((unsigned char) c) ? 'a' : 'A'));
 259                  cp++;
 260                  continue;
 261              }
 262              break;
 263          }
 264          if (*cp == '.')
 265          {
 266              /*
 267               * Internet format: a.b.c.d a.b.c   (with c treated as 16-bits)
 268               * a.b     (with b treated as 24 bits)
 269               */
 270              if (pp >= parts + 3 || val > 0xff)
 271                  return 0;
 272              *pp++ = val, cp++;
 273          }
 274          else
 275              break;
 276      }
 277
 278      /*
 279       * Check for trailing junk.
 280       */
 281      while (*cp)
 282          if (!isspace((unsigned char) *cp++))
 283              return 0;
 284
 285      /*
 286       * Concoct the address according to the number of parts specified.
 287       */
 288      n = pp - parts + 1;
 289      switch (n)
 290      {
 291
 292          case 1:         /* a -- 32 bits */
 293              break;
 294
 295          case 2:         /* a.b -- 8.24 bits */
 296              if (val > 0xffffff)
 297                  return 0;
 298              val |= parts[0] << 24;
 299              break;
 300
 301          case 3:         /* a.b.c -- 8.8.16 bits */
 302              if (val > 0xffff)
 303                  return 0;
 304              val |= (parts[0] << 24) | (parts[1] << 16);
 305              break;
 306
 307          case 4:         /* a.b.c.d -- 8.8.8.8 bits */
 308              if (val > 0xff)
 309                  return 0;
 310              val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8);
 311              break;
 312      }
 313
 314      *addr = htonl(val);
 315      return 1;
 316
 317 }
 318
 319 /*
 320     ========================================================================
 321
 322     Routine Description:
 323         Find key section for Get key parameter.
 324
 325     Arguments:
 326         buffer                      Pointer to the buffer to start find the key section
 327         section                     the key of the secion to be find
 328
 329     Return Value:
 330         NULL                        Fail
 331         Others                      Success
 332     ========================================================================
 333 */
 334 PUCHAR  RTMPFindSection(
 335     IN  PCHAR   buffer)
 336 {
 337     CHAR temp_buf[32];
 338     PUCHAR  ptr;
 339
 340     strcpy(temp_buf, "Default");
 341
 342     if((ptr = rtstrstr(buffer, temp_buf)) != NULL)
 343             return (ptr+strlen("\n"));
 344         else
 345             return NULL;
 346 }
 347
 348 /*
 349     ========================================================================
 350
 351     Routine Description:
 352         Get key parameter.
 353
 354     Arguments:
 355         key                         Pointer to key string
 356         dest                        Pointer to destination
 357         destsize                    The datasize of the destination
 358         buffer                      Pointer to the buffer to start find the key
 359
 360     Return Value:
 361         TRUE                        Success
 362         FALSE                       Fail
 363
 364     Note:
 365         This routine get the value with the matched key (case case-sensitive)
 366     ========================================================================
 367 */
 368 INT RTMPGetKeyParameter(
 369     IN  PCHAR   key,
 370     OUT PCHAR   dest,
 371     IN  INT     destsize,
 372     IN  PCHAR   buffer)
 373 {
 374     UCHAR *temp_buf1 = NULL;
 375     UCHAR *temp_buf2 = NULL;
 376     CHAR *start_ptr;
 377     CHAR *end_ptr;
 378     CHAR *ptr;
 379     CHAR *offset = 0;
 380     INT  len;
 381
 382         //temp_buf1 = kmalloc(MAX_PARAM_BUFFER_SIZE, MEM_ALLOC_FLAG);
 383         os_alloc_mem(NULL, &temp_buf1, MAX_PARAM_BUFFER_SIZE);
 384
 385         if(temp_buf1 == NULL)
 386         return (FALSE);
 387
 388         //temp_buf2 = kmalloc(MAX_PARAM_BUFFER_SIZE, MEM_ALLOC_FLAG);
 389         os_alloc_mem(NULL, &temp_buf2, MAX_PARAM_BUFFER_SIZE);
 390         if(temp_buf2 == NULL)
 391         {
 392                 os_free_mem(NULL, temp_buf1);
 393         return (FALSE);
 394         }
 395
 396     //find section
 397     if((offset = RTMPFindSection(buffer)) == NULL)
 398     {
 399         os_free_mem(NULL, temp_buf1);
 400         os_free_mem(NULL, temp_buf2);
 401         return (FALSE);
 402     }
 403
 404     strcpy(temp_buf1, "\n");
 405     strcat(temp_buf1, key);
 406     strcat(temp_buf1, "=");
 407
 408     //search key
 409     if((start_ptr=rtstrstr(offset, temp_buf1))==NULL)
 410     {
 411                 os_free_mem(NULL, temp_buf1);
 412         os_free_mem(NULL, temp_buf2);
 413         return (FALSE);
 414     }
 415
 416     start_ptr+=strlen("\n");
 417     if((end_ptr=rtstrstr(start_ptr, "\n"))==NULL)
 418        end_ptr=start_ptr+strlen(start_ptr);
 419
 420     if (end_ptr<start_ptr)
 421     {
 422                 os_free_mem(NULL, temp_buf1);
 423         os_free_mem(NULL, temp_buf2);
 424         return (FALSE);
 425     }
 426
 427     NdisMoveMemory(temp_buf2, start_ptr, end_ptr-start_ptr);
 428     temp_buf2[end_ptr-start_ptr]='\0';
 429     len = strlen(temp_buf2);
 430     strcpy(temp_buf1, temp_buf2);
 431     if((start_ptr=rtstrstr(temp_buf1, "=")) == NULL)
 432     {
 433                 os_free_mem(NULL, temp_buf1);
 434         os_free_mem(NULL, temp_buf2);
 435         return (FALSE);
 436     }
 437
 438     strcpy(temp_buf2, start_ptr+1);
 439     ptr = temp_buf2;
 440     //trim space or tab
 441     while(*ptr != 0x00)
 442     {
 443         if( (*ptr == ' ') || (*ptr == '\t') )
 444             ptr++;
 445         else
 446            break;
 447     }
 448
 449     len = strlen(ptr);
 450     memset(dest, 0x00, destsize);
 451     strncpy(dest, ptr, len >= destsize ?  destsize: len);
 452
 453         os_free_mem(NULL, temp_buf1);
 454     os_free_mem(NULL, temp_buf2);
 455     return TRUE;
 456 }
 457
 458 /*
 459     ========================================================================
 460
 461     Routine Description:
 462         Get key parameter.
 463
 464     Arguments:
 465         key                         Pointer to key string
 466         dest                        Pointer to destination
 467         destsize                    The datasize of the destination
 468         buffer                      Pointer to the buffer to start find the key
 469
 470     Return Value:
 471         TRUE                        Success
 472         FALSE                       Fail
 473
 474     Note:
 475         This routine get the value with the matched key (case case-sensitive).
 476         It is called for parsing SSID and any key string.
 477     ========================================================================
 478 */
 479 INT RTMPGetCriticalParameter(
 480     IN  PCHAR   key,
 481     OUT PCHAR   dest,
 482     IN  INT     destsize,
 483     IN  PCHAR   buffer)
 484 {
 485     UCHAR *temp_buf1 = NULL;
 486     UCHAR *temp_buf2 = NULL;
 487     CHAR *start_ptr;
 488     CHAR *end_ptr;
 489     CHAR *ptr;
 490     CHAR *offset = 0;
 491     INT  len;
 492
 493         //temp_buf1 = kmalloc(MAX_PARAM_BUFFER_SIZE, MEM_ALLOC_FLAG);
 494         os_alloc_mem(NULL, &temp_buf1, MAX_PARAM_BUFFER_SIZE);
 495
 496         if(temp_buf1 == NULL)
 497         return (FALSE);
 498
 499         //temp_buf2 = kmalloc(MAX_PARAM_BUFFER_SIZE, MEM_ALLOC_FLAG);
 500         os_alloc_mem(NULL, &temp_buf2, MAX_PARAM_BUFFER_SIZE);
 501         if(temp_buf2 == NULL)
 502         {
 503                 os_free_mem(NULL, temp_buf1);
 504         return (FALSE);
 505         }
 506
 507     //find section
 508     if((offset = RTMPFindSection(buffer)) == NULL)
 509     {
 510         os_free_mem(NULL, temp_buf1);
 511         os_free_mem(NULL, temp_buf2);
 512         return (FALSE);
 513     }
 514
 515     strcpy(temp_buf1, "\n");
 516     strcat(temp_buf1, key);
 517     strcat(temp_buf1, "=");
 518
 519     //search key
 520     if((start_ptr=rtstrstr(offset, temp_buf1))==NULL)
 521     {
 522                 os_free_mem(NULL, temp_buf1);
 523         os_free_mem(NULL, temp_buf2);
 524         return (FALSE);
 525     }
 526
 527     start_ptr+=strlen("\n");
 528     if((end_ptr=rtstrstr(start_ptr, "\n"))==NULL)
 529        end_ptr=start_ptr+strlen(start_ptr);
 530
 531     if (end_ptr<start_ptr)
 532     {
 533                 os_free_mem(NULL, temp_buf1);
 534         os_free_mem(NULL, temp_buf2);
 535         return (FALSE);
 536     }
 537
 538     NdisMoveMemory(temp_buf2, start_ptr, end_ptr-start_ptr);
 539     temp_buf2[end_ptr-start_ptr]='\0';
 540     len = strlen(temp_buf2);
 541     strcpy(temp_buf1, temp_buf2);
 542     if((start_ptr=rtstrstr(temp_buf1, "=")) == NULL)
 543     {
 544                 os_free_mem(NULL, temp_buf1);
 545         os_free_mem(NULL, temp_buf2);
 546         return (FALSE);
 547     }
 548
 549     strcpy(temp_buf2, start_ptr+1);
 550     ptr = temp_buf2;
 551
 552     //trim tab
 553     /* We cannot trim space(' ') for SSID and key string. */
 554     while(*ptr != 0x00)
 555     {
 556         //if( (*ptr == ' ') || (*ptr == '\t') )
 557         if( (*ptr == '\t') )
 558             ptr++;
 559         else
 560            break;
 561     }
 562
 563     len = strlen(ptr);
 564     memset(dest, 0x00, destsize);
 565     strncpy(dest, ptr, len >= destsize ?  destsize: len);
 566
 567         os_free_mem(NULL, temp_buf1);
 568     os_free_mem(NULL, temp_buf2);
 569     return TRUE;
 570 }
 571
 572 /*
 573     ========================================================================
 574
 575     Routine Description:
 576         Get multiple key parameter.
 577
 578     Arguments:
 579         key                         Pointer to key string
 580         dest                        Pointer to destination
 581         destsize                    The datasize of the destination
 582         buffer                      Pointer to the buffer to start find the key
 583
 584     Return Value:
 585         TRUE                        Success
 586         FALSE                       Fail
 587
 588     Note:
 589         This routine get the value with the matched key (case case-sensitive)
 590     ========================================================================
 591 */
 592 INT RTMPGetKeyParameterWithOffset(
 593     IN  PCHAR   key,
 594     OUT PCHAR   dest,
 595     OUT USHORT  *end_offset,
 596     IN  INT     destsize,
 597     IN  PCHAR   buffer,
 598     IN  BOOLEAN bTrimSpace)
 599 {
 600     UCHAR *temp_buf1 = NULL;
 601     UCHAR *temp_buf2 = NULL;
 602     CHAR *start_ptr;
 603     CHAR *end_ptr;
 604     CHAR *ptr;
 605     CHAR *offset = 0;
 606     INT  len;
 607
 608         if (*end_offset >= MAX_INI_BUFFER_SIZE)
 609                 return (FALSE);
 610
 611         os_alloc_mem(NULL, &temp_buf1, MAX_PARAM_BUFFER_SIZE);
 612
 613         if(temp_buf1 == NULL)
 614         return (FALSE);
 615
 616         os_alloc_mem(NULL, &temp_buf2, MAX_PARAM_BUFFER_SIZE);
 617         if(temp_buf2 == NULL)
 618         {
 619                 os_free_mem(NULL, temp_buf1);
 620         return (FALSE);
 621         }
 622
 623     //find section
 624         if(*end_offset == 0)
 625     {
 626                 if ((offset = RTMPFindSection(buffer)) == NULL)
 627                 {
 628                         os_free_mem(NULL, temp_buf1);
 629                 os_free_mem(NULL, temp_buf2);
 630             return (FALSE);
 631                 }
 632     }
 633         else
 634                 offset = buffer + (*end_offset);
 635
 636     strcpy(temp_buf1, "\n");
 637     strcat(temp_buf1, key);
 638     strcat(temp_buf1, "=");
 639
 640     //search key
 641     if((start_ptr=rtstrstr(offset, temp_buf1))==NULL)
 642     {
 643                 os_free_mem(NULL, temp_buf1);
 644         os_free_mem(NULL, temp_buf2);
 645         return (FALSE);
 646     }
 647
 648     start_ptr+=strlen("\n");
 649     if((end_ptr=rtstrstr(start_ptr, "\n"))==NULL)
 650        end_ptr=start_ptr+strlen(start_ptr);
 651
 652     if (end_ptr<start_ptr)
 653     {
 654                 os_free_mem(NULL, temp_buf1);
 655         os_free_mem(NULL, temp_buf2);
 656         return (FALSE);
 657     }
 658
 659         *end_offset = end_ptr - buffer;
 660
 661     NdisMoveMemory(temp_buf2, start_ptr, end_ptr-start_ptr);
 662     temp_buf2[end_ptr-start_ptr]='\0';
 663     len = strlen(temp_buf2);
 664     strcpy(temp_buf1, temp_buf2);
 665     if((start_ptr=rtstrstr(temp_buf1, "=")) == NULL)
 666     {
 667                 os_free_mem(NULL, temp_buf1);
 668         os_free_mem(NULL, temp_buf2);
 669         return (FALSE);
 670     }
 671
 672     strcpy(temp_buf2, start_ptr+1);
 673     ptr = temp_buf2;
 674     //trim space or tab
 675     while(*ptr != 0x00)
 676     {
 677         if((bTrimSpace && (*ptr == ' ')) || (*ptr == '\t') )
 678             ptr++;
 679         else
 680            break;
 681     }
 682
 683     len = strlen(ptr);
 684     memset(dest, 0x00, destsize);
 685     strncpy(dest, ptr, len >= destsize ?  destsize: len);
 686
 687         os_free_mem(NULL, temp_buf1);
 688     os_free_mem(NULL, temp_buf2);
 689     return TRUE;
 690 }
 691
 692
 693 static int rtmp_parse_key_buffer_from_file(IN  PRTMP_ADAPTER pAd,IN  char *buffer,IN  ULONG KeyType,IN  INT BSSIdx,IN  INT KeyIdx)
 694 {
 695         PUCHAR          keybuff;
 696         INT                     i = BSSIdx, idx = KeyIdx;
 697         ULONG           KeyLen;
 698         UCHAR           CipherAlg = CIPHER_WEP64;
 699
 700         keybuff = buffer;
 701         KeyLen = strlen(keybuff);
 702
 703         if (KeyType == 1)
 704         {//Ascii
 705                 if( (KeyLen == 5) || (KeyLen == 13))
 706                 {
 707                         pAd->SharedKey[i][idx].KeyLen = KeyLen;
 708                         NdisMoveMemory(pAd->SharedKey[i][idx].Key, keybuff, KeyLen);
 709                         if (KeyLen == 5)
 710                                 CipherAlg = CIPHER_WEP64;
 711                         else
 712                                 CipherAlg = CIPHER_WEP128;
 713                         pAd->SharedKey[i][idx].CipherAlg = CipherAlg;
 714
 715                         DBGPRINT(RT_DEBUG_TRACE, ("I/F(ra%d) Key%dStr=%s and type=%s\n", i, idx+1, keybuff, (KeyType == 0) ? "Hex":"Ascii"));
 716                         return 1;
 717                 }
 718                 else
 719                 {//Invalid key length
 720                         DBGPRINT(RT_DEBUG_ERROR, ("Key%dStr is Invalid key length! KeyLen = %ld!\n", idx+1, KeyLen));
 721                         return 0;
 722                 }
 723         }
 724         else
 725         {//Hex type
 726                 if( (KeyLen == 10) || (KeyLen == 26))
 727                 {
 728                         pAd->SharedKey[i][idx].KeyLen = KeyLen / 2;
 729                         AtoH(keybuff, pAd->SharedKey[i][idx].Key, KeyLen / 2);
 730                         if (KeyLen == 10)
 731                                 CipherAlg = CIPHER_WEP64;
 732                         else
 733                                 CipherAlg = CIPHER_WEP128;
 734                         pAd->SharedKey[i][idx].CipherAlg = CipherAlg;
 735
 736                         DBGPRINT(RT_DEBUG_TRACE, ("I/F(ra%d) Key%dStr=%s and type=%s\n", i, idx+1, keybuff, (KeyType == 0) ? "Hex":"Ascii"));
 737                         return 1;
 738                 }
 739                 else
 740                 {//Invalid key length
 741                         DBGPRINT(RT_DEBUG_ERROR, ("I/F(ra%d) Key%dStr is Invalid key length! KeyLen = %ld!\n", i, idx+1, KeyLen));
 742                         return 0;
 743                 }
 744         }
 745 }
 746 static void rtmp_read_key_parms_from_file(IN  PRTMP_ADAPTER pAd, char *tmpbuf, char *buffer)
 747 {
 748         char            tok_str[16];
 749         PUCHAR          macptr;
 750         INT                     i = 0, idx;
 751         ULONG           KeyType[MAX_MBSSID_NUM];
 752         ULONG           KeyIdx;
 753
 754         NdisZeroMemory(KeyType, MAX_MBSSID_NUM);
 755
 756         //DefaultKeyID
 757         if(RTMPGetKeyParameter("DefaultKeyID", tmpbuf, 25, buffer))
 758         {
 759
 760 #ifdef CONFIG_STA_SUPPORT
 761                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
 762                 {
 763                         KeyIdx = simple_strtol(tmpbuf, 0, 10);
 764                         if((KeyIdx >= 1 ) && (KeyIdx <= 4))
 765                                 pAd->StaCfg.DefaultKeyId = (UCHAR) (KeyIdx - 1);
 766                         else
 767                                 pAd->StaCfg.DefaultKeyId = 0;
 768
 769                         DBGPRINT(RT_DEBUG_TRACE, ("DefaultKeyID(0~3)=%d\n", pAd->StaCfg.DefaultKeyId));
 770                 }
 771 #endif // CONFIG_STA_SUPPORT //
 772         }
 773
 774
 775         for (idx = 0; idx < 4; idx++)
 776         {
 777                 sprintf(tok_str, "Key%dType", idx + 1);
 778                 //Key1Type
 779                 if (RTMPGetKeyParameter(tok_str, tmpbuf, 128, buffer))
 780                 {
 781                     for (i = 0, macptr = rstrtok(tmpbuf,";"); macptr; macptr = rstrtok(NULL,";"), i++)
 782                     {
 783                             KeyType[i] = simple_strtol(macptr, 0, 10);
 784                     }
 785
 786 #ifdef CONFIG_STA_SUPPORT
 787                         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
 788                         {
 789                                 sprintf(tok_str, "Key%dStr", idx + 1);
 790                                 if (RTMPGetCriticalParameter(tok_str, tmpbuf, 128, buffer))
 791                                 {
 792                                         rtmp_parse_key_buffer_from_file(pAd, tmpbuf, KeyType[BSS0], BSS0, idx);
 793                                 }
 794                         }
 795 #endif // CONFIG_STA_SUPPORT //
 796                 }
 797         }
 798 }
 799
 800
 801 #ifdef CONFIG_STA_SUPPORT
 802 static void rtmp_read_sta_wmm_parms_from_file(IN  PRTMP_ADAPTER pAd, char *tmpbuf, char *buffer)
 803 {
 804         PUCHAR                                  macptr;
 805         INT                                             i=0;
 806         BOOLEAN                                 bWmmEnable = FALSE;
 807
 808         //WmmCapable
 809         if(RTMPGetKeyParameter("WmmCapable", tmpbuf, 32, buffer))
 810         {
 811                 if(simple_strtol(tmpbuf, 0, 10) != 0) //Enable
 812                 {
 813                         pAd->CommonCfg.bWmmCapable = TRUE;
 814                         bWmmEnable = TRUE;
 815                 }
 816                 else //Disable
 817                 {
 818                         pAd->CommonCfg.bWmmCapable = FALSE;
 819                 }
 820
 821                 DBGPRINT(RT_DEBUG_TRACE, ("WmmCapable=%d\n", pAd->CommonCfg.bWmmCapable));
 822         }
 823
 824         //AckPolicy for AC_BK, AC_BE, AC_VI, AC_VO
 825         if(RTMPGetKeyParameter("AckPolicy", tmpbuf, 32, buffer))
 826         {
 827                 for (i = 0, macptr = rstrtok(tmpbuf,";"); macptr; macptr = rstrtok(NULL,";"), i++)
 828                 {
 829                         pAd->CommonCfg.AckPolicy[i] = (UCHAR)simple_strtol(macptr, 0, 10);
 830
 831                         DBGPRINT(RT_DEBUG_TRACE, ("AckPolicy[%d]=%d\n", i, pAd->CommonCfg.AckPolicy[i]));
 832                 }
 833         }
 834
 835         if (bWmmEnable)
 836         {
 837                 //APSDCapable
 838                 if(RTMPGetKeyParameter("APSDCapable", tmpbuf, 10, buffer))
 839                 {
 840                         if(simple_strtol(tmpbuf, 0, 10) != 0)  //Enable
 841                                 pAd->CommonCfg.bAPSDCapable = TRUE;
 842                         else
 843                                 pAd->CommonCfg.bAPSDCapable = FALSE;
 844
 845                         DBGPRINT(RT_DEBUG_TRACE, ("APSDCapable=%d\n", pAd->CommonCfg.bAPSDCapable));
 846                 }
 847
 848                 //APSDAC for AC_BE, AC_BK, AC_VI, AC_VO
 849                 if(RTMPGetKeyParameter("APSDAC", tmpbuf, 32, buffer))
 850                 {
 851                         BOOLEAN apsd_ac[4];
 852
 853                         for (i = 0, macptr = rstrtok(tmpbuf,";"); macptr; macptr = rstrtok(NULL,";"), i++)
 854                         {
 855                                 apsd_ac[i] = (BOOLEAN)simple_strtol(macptr, 0, 10);
 856
 857                                 DBGPRINT(RT_DEBUG_TRACE, ("APSDAC%d  %d\n", i,  apsd_ac[i]));
 858                         }
 859
 860                         pAd->CommonCfg.bAPSDAC_BE = apsd_ac[0];
 861                         pAd->CommonCfg.bAPSDAC_BK = apsd_ac[1];
 862                         pAd->CommonCfg.bAPSDAC_VI = apsd_ac[2];
 863                         pAd->CommonCfg.bAPSDAC_VO = apsd_ac[3];
 864                 }
 865         }
 866
 867 }
 868 #endif // CONFIG_STA_SUPPORT //
 869
 870
 871 NDIS_STATUS     RTMPReadParametersHook(
 872         IN      PRTMP_ADAPTER pAd)
 873 {
 874         PUCHAR                                  src = NULL;
 875         struct file                             *srcf;
 876         INT                                     retval, orgfsuid, orgfsgid;
 877         mm_segment_t                    orgfs;
 878         CHAR                                    *buffer;
 879         CHAR                                    *tmpbuf;
 880         ULONG                                   RtsThresh;
 881         ULONG                                   FragThresh;
 882 #ifdef CONFIG_STA_SUPPORT
 883         UCHAR                   keyMaterial[40];
 884 #endif // CONFIG_STA_SUPPORT //
 885
 886
 887         PUCHAR                                  macptr;
 888         INT                                             i = 0;
 889
 890         buffer = kmalloc(MAX_INI_BUFFER_SIZE, MEM_ALLOC_FLAG);
 891         if(buffer == NULL)
 892         return NDIS_STATUS_FAILURE;
 893
 894         tmpbuf = kmalloc(MAX_PARAM_BUFFER_SIZE, MEM_ALLOC_FLAG);
 895         if(tmpbuf == NULL)
 896         {
 897                 kfree(buffer);
 898         return NDIS_STATUS_FAILURE;
 899         }
 900
 901 #ifdef CONFIG_STA_SUPPORT
 902         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
 903                 src = STA_PROFILE_PATH;
 904 #endif // CONFIG_STA_SUPPORT //
 905
 906         // Save uid and gid used for filesystem access.
 907         // Set user and group to 0 (root)
 908 #if 0
 909         orgfsuid = current->fsuid;
 910         orgfsgid = current->fsgid;
 911         current->fsuid=current->fsgid = 0;
 912 #endif
 913     orgfs = get_fs();
 914     set_fs(KERNEL_DS);
 915
 916         if (src && *src)
 917         {
 918                 srcf = filp_open(src, O_RDONLY, 0);
 919                 if (IS_ERR(srcf))
 920                 {
 921                         DBGPRINT(RT_DEBUG_ERROR, ("--> Error %ld opening %s\n", -PTR_ERR(srcf),src));
 922                 }
 923                 else
 924                 {
 925                         // The object must have a read method
 926                         if (srcf->f_op && srcf->f_op->read)
 927                         {
 928                                 memset(buffer, 0x00, MAX_INI_BUFFER_SIZE);
 929                                 retval=srcf->f_op->read(srcf, buffer, MAX_INI_BUFFER_SIZE, &srcf->f_pos);
 930                                 if (retval < 0)
 931                                 {
 932                                         DBGPRINT(RT_DEBUG_TRACE, ("--> Read %s error %d\n", src, -retval));
 933                                 }
 934                                 else
 935                                 {
 936                                         // set file parameter to portcfg
 937                                         //CountryRegion
 938                                         if(RTMPGetKeyParameter("CountryRegion", tmpbuf, 25, buffer))
 939                                         {
 940                                                 pAd->CommonCfg.CountryRegion = (UCHAR) simple_strtol(tmpbuf, 0, 10);
 941                                                 DBGPRINT(RT_DEBUG_TRACE, ("CountryRegion=%d\n", pAd->CommonCfg.CountryRegion));
 942                                         }
 943                                         //CountryRegionABand
 944                                         if(RTMPGetKeyParameter("CountryRegionABand", tmpbuf, 25, buffer))
 945                                         {
 946                                                 pAd->CommonCfg.CountryRegionForABand= (UCHAR) simple_strtol(tmpbuf, 0, 10);
 947                                                 DBGPRINT(RT_DEBUG_TRACE, ("CountryRegionABand=%d\n", pAd->CommonCfg.CountryRegionForABand));
 948                                         }
 949                                         //CountryCode
 950                                         if(RTMPGetKeyParameter("CountryCode", tmpbuf, 25, buffer))
 951                                         {
 952                                                 NdisMoveMemory(pAd->CommonCfg.CountryCode, tmpbuf , 2);
 953 #ifdef CONFIG_STA_SUPPORT
 954 #ifdef EXT_BUILD_CHANNEL_LIST
 955                                                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
 956                                                         NdisMoveMemory(pAd->StaCfg.StaOriCountryCode, tmpbuf , 2);
 957 #endif // EXT_BUILD_CHANNEL_LIST //
 958 #endif // CONFIG_STA_SUPPORT //
 959                                                 if (strlen(pAd->CommonCfg.CountryCode) != 0)
 960                                                 {
 961                                                         pAd->CommonCfg.bCountryFlag = TRUE;
 962                                                 }
 963                                                 DBGPRINT(RT_DEBUG_TRACE, ("CountryCode=%s\n", pAd->CommonCfg.CountryCode));
 964                                         }
 965                                         //ChannelGeography
 966                                         if(RTMPGetKeyParameter("ChannelGeography", tmpbuf, 25, buffer))
 967                                         {
 968                                                 UCHAR Geography = (UCHAR) simple_strtol(tmpbuf, 0, 10);
 969                                                 if (Geography <= BOTH)
 970                                                 {
 971                                                         pAd->CommonCfg.Geography = Geography;
 972                                                         pAd->CommonCfg.CountryCode[2] =
 973                                                                 (pAd->CommonCfg.Geography == BOTH) ? ' ' : ((pAd->CommonCfg.Geography == IDOR) ? 'I' : 'O');
 974 #ifdef CONFIG_STA_SUPPORT
 975 #ifdef EXT_BUILD_CHANNEL_LIST
 976                                                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
 977                                                         pAd->StaCfg.StaOriGeography = pAd->CommonCfg.Geography;
 978 #endif // EXT_BUILD_CHANNEL_LIST //
 979 #endif // CONFIG_STA_SUPPORT //
 980                                                         DBGPRINT(RT_DEBUG_TRACE, ("ChannelGeography=%d\n", pAd->CommonCfg.Geography));
 981                                                 }
 982                                         }
 983                                         else
 984                                         {
 985                                                 pAd->CommonCfg.Geography = BOTH;
 986                                                 pAd->CommonCfg.CountryCode[2] = ' ';
 987                                         }
 988
 989
 990 #ifdef CONFIG_STA_SUPPORT
 991                                         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
 992                                         {
 993                                                 //SSID
 994                                                 if (RTMPGetCriticalParameter("SSID", tmpbuf, 256, buffer))
 995                                                 {
 996                                                         if (strlen(tmpbuf) <= 32)
 997                                                         {
 998                                                                 pAd->CommonCfg.SsidLen = (UCHAR) strlen(tmpbuf);
 999                                                                 NdisZeroMemory(pAd->CommonCfg.Ssid, NDIS_802_11_LENGTH_SSID);
1000                                                                 NdisMoveMemory(pAd->CommonCfg.Ssid, tmpbuf, pAd->CommonCfg.SsidLen);
1001                                                                 pAd->MlmeAux.AutoReconnectSsidLen = pAd->CommonCfg.SsidLen;
1002                                                                 NdisZeroMemory(pAd->MlmeAux.AutoReconnectSsid, NDIS_802_11_LENGTH_SSID);
1003                                                                 NdisMoveMemory(pAd->MlmeAux.AutoReconnectSsid, tmpbuf, pAd->MlmeAux.AutoReconnectSsidLen);
1004                                                                 pAd->MlmeAux.SsidLen = pAd->CommonCfg.SsidLen;
1005                                                                 NdisZeroMemory(pAd->MlmeAux.Ssid, NDIS_802_11_LENGTH_SSID);
1006                                                                 NdisMoveMemory(pAd->MlmeAux.Ssid, tmpbuf, pAd->MlmeAux.SsidLen);
1007                                                                 DBGPRINT(RT_DEBUG_TRACE, ("%s::(SSID=%s)\n", __func__, tmpbuf));
1008                                                         }
1009                                                 }
1010                                         }
1011 #endif // CONFIG_STA_SUPPORT //
1012
1013 #ifdef CONFIG_STA_SUPPORT
1014                                         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1015                                         {
1016                                                 //NetworkType
1017                                                 if (RTMPGetKeyParameter("NetworkType", tmpbuf, 25, buffer))
1018                                                 {
1019                                                         pAd->bConfigChanged = TRUE;
1020                                                         if (strcmp(tmpbuf, "Adhoc") == 0)
1021                                                                 pAd->StaCfg.BssType = BSS_ADHOC;
1022                                                         else //Default Infrastructure mode
1023                                                                 pAd->StaCfg.BssType = BSS_INFRA;
1024                                                         // Reset Ralink supplicant to not use, it will be set to start when UI set PMK key
1025                                                         pAd->StaCfg.WpaState = SS_NOTUSE;
1026                                                         DBGPRINT(RT_DEBUG_TRACE, ("%s::(NetworkType=%d)\n", __func__, pAd->StaCfg.BssType));
1027                                                 }
1028                                         }
1029 #endif // CONFIG_STA_SUPPORT //
1030                                         //Channel
1031                                         if(RTMPGetKeyParameter("Channel", tmpbuf, 10, buffer))
1032                                         {
1033                                                 pAd->CommonCfg.Channel = (UCHAR) simple_strtol(tmpbuf, 0, 10);
1034                                                 DBGPRINT(RT_DEBUG_TRACE, ("Channel=%d\n", pAd->CommonCfg.Channel));
1035                                         }
1036                                         //WirelessMode
1037                                         if(RTMPGetKeyParameter("WirelessMode", tmpbuf, 10, buffer))
1038                                         {
1039                                                 int value  = 0, maxPhyMode = PHY_11G;
1040
1041 #ifdef DOT11_N_SUPPORT
1042                                                 maxPhyMode = PHY_11N_5G;
1043 #endif // DOT11_N_SUPPORT //
1044
1045                                                 value = simple_strtol(tmpbuf, 0, 10);
1046
1047                                                 if (value <= maxPhyMode)
1048                                                 {
1049                                                         pAd->CommonCfg.PhyMode = value;
1050                                                 }
1051                                                 DBGPRINT(RT_DEBUG_TRACE, ("PhyMode=%d\n", pAd->CommonCfg.PhyMode));
1052                                         }
1053                     //BasicRate
1054                                         if(RTMPGetKeyParameter("BasicRate", tmpbuf, 10, buffer))
1055                                         {
1056                                                 pAd->CommonCfg.BasicRateBitmap = (ULONG) simple_strtol(tmpbuf, 0, 10);
1057                                                 DBGPRINT(RT_DEBUG_TRACE, ("BasicRate=%ld\n", pAd->CommonCfg.BasicRateBitmap));
1058                                         }
1059                                         //BeaconPeriod
1060                                         if(RTMPGetKeyParameter("BeaconPeriod", tmpbuf, 10, buffer))
1061                                         {
1062                                                 pAd->CommonCfg.BeaconPeriod = (USHORT) simple_strtol(tmpbuf, 0, 10);
1063                                                 DBGPRINT(RT_DEBUG_TRACE, ("BeaconPeriod=%d\n", pAd->CommonCfg.BeaconPeriod));
1064                                         }
1065                     //TxPower
1066                                         if(RTMPGetKeyParameter("TxPower", tmpbuf, 10, buffer))
1067                                         {
1068                                                 pAd->CommonCfg.TxPowerPercentage = (ULONG) simple_strtol(tmpbuf, 0, 10);
1069 #ifdef CONFIG_STA_SUPPORT
1070                                                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1071                                                         pAd->CommonCfg.TxPowerDefault = pAd->CommonCfg.TxPowerPercentage;
1072 #endif // CONFIG_STA_SUPPORT //
1073                                                 DBGPRINT(RT_DEBUG_TRACE, ("TxPower=%ld\n", pAd->CommonCfg.TxPowerPercentage));
1074                                         }
1075                                         //BGProtection
1076                                         if(RTMPGetKeyParameter("BGProtection", tmpbuf, 10, buffer))
1077                                         {
1078                                                 switch (simple_strtol(tmpbuf, 0, 10))
1079                                                 {
1080                                                         case 1: //Always On
1081                                                                 pAd->CommonCfg.UseBGProtection = 1;
1082                                                                 break;
1083                                                         case 2: //Always OFF
1084                                                                 pAd->CommonCfg.UseBGProtection = 2;
1085                                                                 break;
1086                                                         case 0: //AUTO
1087                                                         default:
1088                                                                 pAd->CommonCfg.UseBGProtection = 0;
1089                                                                 break;
1090                                                 }
1091                                                 DBGPRINT(RT_DEBUG_TRACE, ("BGProtection=%ld\n", pAd->CommonCfg.UseBGProtection));
1092                                         }
1093                                         //OLBCDetection
1094                                         if(RTMPGetKeyParameter("DisableOLBC", tmpbuf, 10, buffer))
1095                                         {
1096                                                 switch (simple_strtol(tmpbuf, 0, 10))
1097                                                 {
1098                                                         case 1: //disable OLBC Detection
1099                                                                 pAd->CommonCfg.DisableOLBCDetect = 1;
1100                                                                 break;
1101                                                         case 0: //enable OLBC Detection
1102                                                                 pAd->CommonCfg.DisableOLBCDetect = 0;
1103                                                                 break;
1104                                                         default:
1105                                                                 pAd->CommonCfg.DisableOLBCDetect= 0;
1106                                                                 break;
1107                                                 }
1108                                                 DBGPRINT(RT_DEBUG_TRACE, ("OLBCDetection=%ld\n", pAd->CommonCfg.DisableOLBCDetect));
1109                                         }
1110                                         //TxPreamble
1111                                         if(RTMPGetKeyParameter("TxPreamble", tmpbuf, 10, buffer))
1112                                         {
1113                                                 switch (simple_strtol(tmpbuf, 0, 10))
1114                                                 {
1115                                                         case Rt802_11PreambleShort:
1116                                                                 pAd->CommonCfg.TxPreamble = Rt802_11PreambleShort;
1117                                                                 break;
1118                                                         case Rt802_11PreambleLong:
1119                                                         default:
1120                                                                 pAd->CommonCfg.TxPreamble = Rt802_11PreambleLong;
1121                                                                 break;
1122                                                 }
1123                                                 DBGPRINT(RT_DEBUG_TRACE, ("TxPreamble=%ld\n", pAd->CommonCfg.TxPreamble));
1124                                         }
1125                                         //RTSThreshold
1126                                         if(RTMPGetKeyParameter("RTSThreshold", tmpbuf, 10, buffer))
1127                                         {
1128                                                 RtsThresh = simple_strtol(tmpbuf, 0, 10);
1129                                                 if( (RtsThresh >= 1) && (RtsThresh <= MAX_RTS_THRESHOLD) )
1130                                                         pAd->CommonCfg.RtsThreshold  = (USHORT)RtsThresh;
1131                                                 else
1132                                                         pAd->CommonCfg.RtsThreshold = MAX_RTS_THRESHOLD;
1133
1134                                                 DBGPRINT(RT_DEBUG_TRACE, ("RTSThreshold=%d\n", pAd->CommonCfg.RtsThreshold));
1135                                         }
1136                                         //FragThreshold
1137                                         if(RTMPGetKeyParameter("FragThreshold", tmpbuf, 10, buffer))
1138                                         {
1139                                                 FragThresh = simple_strtol(tmpbuf, 0, 10);
1140                                                 pAd->CommonCfg.bUseZeroToDisableFragment = FALSE;
1141
1142                                                 if (FragThresh > MAX_FRAG_THRESHOLD || FragThresh < MIN_FRAG_THRESHOLD)
1143                                                 { //illegal FragThresh so we set it to default
1144                                                         pAd->CommonCfg.FragmentThreshold = MAX_FRAG_THRESHOLD;
1145                                                         pAd->CommonCfg.bUseZeroToDisableFragment = TRUE;
1146                                                 }
1147                                                 else if (FragThresh % 2 == 1)
1148                                                 {
1149                                                         // The length of each fragment shall always be an even number of octets, except for the last fragment
1150                                                         // of an MSDU or MMPDU, which may be either an even or an odd number of octets.
1151                                                         pAd->CommonCfg.FragmentThreshold = (USHORT)(FragThresh - 1);
1152                                                 }
1153                                                 else
1154                                                 {
1155                                                         pAd->CommonCfg.FragmentThreshold = (USHORT)FragThresh;
1156                                                 }
1157                                                 //pAd->CommonCfg.AllowFragSize = (pAd->CommonCfg.FragmentThreshold) - LENGTH_802_11 - LENGTH_CRC;
1158                                                 DBGPRINT(RT_DEBUG_TRACE, ("FragThreshold=%d\n", pAd->CommonCfg.FragmentThreshold));
1159                                         }
1160                                         //TxBurst
1161                                         if(RTMPGetKeyParameter("TxBurst", tmpbuf, 10, buffer))
1162                                         {
1163 //#ifdef WIFI_TEST
1164 //                                              pAd->CommonCfg.bEnableTxBurst = FALSE;
1165 //#else
1166                                                 if(simple_strtol(tmpbuf, 0, 10) != 0)  //Enable
1167                                                         pAd->CommonCfg.bEnableTxBurst = TRUE;
1168                                                 else //Disable
1169                                                         pAd->CommonCfg.bEnableTxBurst = FALSE;
1170 //#endif
1171                                                 DBGPRINT(RT_DEBUG_TRACE, ("TxBurst=%d\n", pAd->CommonCfg.bEnableTxBurst));
1172                                         }
1173
1174 #ifdef AGGREGATION_SUPPORT
1175                                         //PktAggregate
1176                                         if(RTMPGetKeyParameter("PktAggregate", tmpbuf, 10, buffer))
1177                                         {
1178                                                 if(simple_strtol(tmpbuf, 0, 10) != 0)  //Enable
1179                                                         pAd->CommonCfg.bAggregationCapable = TRUE;
1180                                                 else //Disable
1181                                                         pAd->CommonCfg.bAggregationCapable = FALSE;
1182 #ifdef PIGGYBACK_SUPPORT
1183                                                 pAd->CommonCfg.bPiggyBackCapable = pAd->CommonCfg.bAggregationCapable;
1184 #endif // PIGGYBACK_SUPPORT //
1185                                                 DBGPRINT(RT_DEBUG_TRACE, ("PktAggregate=%d\n", pAd->CommonCfg.bAggregationCapable));
1186                                         }
1187 #else
1188                                         pAd->CommonCfg.bAggregationCapable = FALSE;
1189                                         pAd->CommonCfg.bPiggyBackCapable = FALSE;
1190 #endif // AGGREGATION_SUPPORT //
1191
1192                                         // WmmCapable
1193
1194 #ifdef CONFIG_STA_SUPPORT
1195                                         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1196                                                 rtmp_read_sta_wmm_parms_from_file(pAd, tmpbuf, buffer);
1197 #endif // CONFIG_STA_SUPPORT //
1198
1199                                         //ShortSlot
1200                                         if(RTMPGetKeyParameter("ShortSlot", tmpbuf, 10, buffer))
1201                                         {
1202                                                 if(simple_strtol(tmpbuf, 0, 10) != 0)  //Enable
1203                                                         pAd->CommonCfg.bUseShortSlotTime = TRUE;
1204                                                 else //Disable
1205                                                         pAd->CommonCfg.bUseShortSlotTime = FALSE;
1206
1207                                                 DBGPRINT(RT_DEBUG_TRACE, ("ShortSlot=%d\n", pAd->CommonCfg.bUseShortSlotTime));
1208                                         }
1209                                         //IEEE80211H
1210                                         if(RTMPGetKeyParameter("IEEE80211H", tmpbuf, 10, buffer))
1211                                         {
1212                                             for (i = 0, macptr = rstrtok(tmpbuf,";"); macptr; macptr = rstrtok(NULL,";"), i++)
1213                                             {
1214                                                 if(simple_strtol(macptr, 0, 10) != 0)  //Enable
1215                                                         pAd->CommonCfg.bIEEE80211H = TRUE;
1216                                                 else //Disable
1217                                                         pAd->CommonCfg.bIEEE80211H = FALSE;
1218
1219                                                 DBGPRINT(RT_DEBUG_TRACE, ("IEEE80211H=%d\n", pAd->CommonCfg.bIEEE80211H));
1220                                             }
1221                                         }
1222                                         //CSPeriod
1223                                         if(RTMPGetKeyParameter("CSPeriod", tmpbuf, 10, buffer))
1224                                         {
1225                                             if(simple_strtol(tmpbuf, 0, 10) != 0)
1226                                                         pAd->CommonCfg.RadarDetect.CSPeriod = simple_strtol(tmpbuf, 0, 10);
1227                                                 else
1228                                                         pAd->CommonCfg.RadarDetect.CSPeriod = 0;
1229
1230                                                 DBGPRINT(RT_DEBUG_TRACE, ("CSPeriod=%d\n", pAd->CommonCfg.RadarDetect.CSPeriod));
1231                                         }
1232
1233                                         //RDRegion
1234                                         if(RTMPGetKeyParameter("RDRegion", tmpbuf, 128, buffer))
1235                                         {
1236                                                 if ((strncmp(tmpbuf, "JAP_W53", 7) == 0) || (strncmp(tmpbuf, "jap_w53", 7) == 0))
1237                                                 {
1238                                                         pAd->CommonCfg.RadarDetect.RDDurRegion = JAP_W53;
1239                                                         pAd->CommonCfg.RadarDetect.DfsSessionTime = 15;
1240                                                 }
1241                                                 else if ((strncmp(tmpbuf, "JAP_W56", 7) == 0) || (strncmp(tmpbuf, "jap_w56", 7) == 0))
1242                                                 {
1243                                                         pAd->CommonCfg.RadarDetect.RDDurRegion = JAP_W56;
1244                                                         pAd->CommonCfg.RadarDetect.DfsSessionTime = 13;
1245                                                 }
1246                                                 else if ((strncmp(tmpbuf, "JAP", 3) == 0) || (strncmp(tmpbuf, "jap", 3) == 0))
1247                                                 {
1248                                                         pAd->CommonCfg.RadarDetect.RDDurRegion = JAP;
1249                                                         pAd->CommonCfg.RadarDetect.DfsSessionTime = 5;
1250                                                 }
1251                                                 else  if ((strncmp(tmpbuf, "FCC", 3) == 0) || (strncmp(tmpbuf, "fcc", 3) == 0))
1252                                                 {
1253                                                         pAd->CommonCfg.RadarDetect.RDDurRegion = FCC;
1254                                                         pAd->CommonCfg.RadarDetect.DfsSessionTime = 5;
1255                                                 }
1256                                                 else if ((strncmp(tmpbuf, "CE", 2) == 0) || (strncmp(tmpbuf, "ce", 2) == 0))
1257                                                 {
1258                                                         pAd->CommonCfg.RadarDetect.RDDurRegion = CE;
1259                                                         pAd->CommonCfg.RadarDetect.DfsSessionTime = 13;
1260                                                 }
1261                                                 else
1262                                                 {
1263                                                         pAd->CommonCfg.RadarDetect.RDDurRegion = CE;
1264                                                         pAd->CommonCfg.RadarDetect.DfsSessionTime = 13;
1265                                                 }
1266
1267                                                 DBGPRINT(RT_DEBUG_TRACE, ("RDRegion=%d\n", pAd->CommonCfg.RadarDetect.RDDurRegion));
1268                                         }
1269                                         else
1270                                         {
1271                                                 pAd->CommonCfg.RadarDetect.RDDurRegion = CE;
1272                                                 pAd->CommonCfg.RadarDetect.DfsSessionTime = 13;
1273                                         }
1274
1275                                         //WirelessEvent
1276                                         if(RTMPGetKeyParameter("WirelessEvent", tmpbuf, 10, buffer))
1277                                         {
1278 #if WIRELESS_EXT >= 15
1279                                             if(simple_strtol(tmpbuf, 0, 10) != 0)
1280                                                         pAd->CommonCfg.bWirelessEvent = simple_strtol(tmpbuf, 0, 10);
1281                                                 else
1282                                                         pAd->CommonCfg.bWirelessEvent = 0;      // disable
1283 #else
1284                                                 pAd->CommonCfg.bWirelessEvent = 0;      // disable
1285 #endif
1286                                                 DBGPRINT(RT_DEBUG_TRACE, ("WirelessEvent=%d\n", pAd->CommonCfg.bWirelessEvent));
1287                                         }
1288                                         if(RTMPGetKeyParameter("WiFiTest", tmpbuf, 10, buffer))
1289                                         {
1290                                             if(simple_strtol(tmpbuf, 0, 10) != 0)
1291                                                         pAd->CommonCfg.bWiFiTest= simple_strtol(tmpbuf, 0, 10);
1292                                                 else
1293                                                         pAd->CommonCfg.bWiFiTest = 0;   // disable
1294
1295                                                 DBGPRINT(RT_DEBUG_TRACE, ("WiFiTest=%d\n", pAd->CommonCfg.bWiFiTest));
1296                                         }
1297                                         //AuthMode
1298                                         if(RTMPGetKeyParameter("AuthMode", tmpbuf, 128, buffer))
1299                                         {
1300 #ifdef CONFIG_STA_SUPPORT
1301                                                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1302                                                 {
1303                                                         if ((strcmp(tmpbuf, "WEPAUTO") == 0) || (strcmp(tmpbuf, "wepauto") == 0))
1304                                                             pAd->StaCfg.AuthMode = Ndis802_11AuthModeAutoSwitch;
1305                                                         else if ((strcmp(tmpbuf, "SHARED") == 0) || (strcmp(tmpbuf, "shared") == 0))
1306                                                             pAd->StaCfg.AuthMode = Ndis802_11AuthModeShared;
1307                                                         else if ((strcmp(tmpbuf, "WPAPSK") == 0) || (strcmp(tmpbuf, "wpapsk") == 0))
1308                                                             pAd->StaCfg.AuthMode = Ndis802_11AuthModeWPAPSK;
1309                                                         else if ((strcmp(tmpbuf, "WPANONE") == 0) || (strcmp(tmpbuf, "wpanone") == 0))
1310                                                             pAd->StaCfg.AuthMode = Ndis802_11AuthModeWPANone;
1311                                                         else if ((strcmp(tmpbuf, "WPA2PSK") == 0) || (strcmp(tmpbuf, "wpa2psk") == 0))
1312                                                             pAd->StaCfg.AuthMode = Ndis802_11AuthModeWPA2PSK;
1313 #ifdef WPA_SUPPLICANT_SUPPORT
1314                                                         else if ((strcmp(tmpbuf, "WPA") == 0) || (strcmp(tmpbuf, "wpa") == 0))
1315                                                             pAd->StaCfg.AuthMode = Ndis802_11AuthModeWPA;
1316                                                         else if ((strcmp(tmpbuf, "WPA2") == 0) || (strcmp(tmpbuf, "wpa2") == 0))
1317                                                             pAd->StaCfg.AuthMode = Ndis802_11AuthModeWPA2;
1318 #endif // WPA_SUPPLICANT_SUPPORT //
1319                                                         else
1320                                                             pAd->StaCfg.AuthMode = Ndis802_11AuthModeOpen;
1321
1322                                                         pAd->StaCfg.PortSecured = WPA_802_1X_PORT_NOT_SECURED;
1323
1324                                                         DBGPRINT(RT_DEBUG_TRACE, ("%s::(EncrypType=%d)\n", __func__, pAd->StaCfg.WepStatus));
1325                                                 }
1326 #endif // CONFIG_STA_SUPPORT //
1327                                         }
1328                                         //EncrypType
1329                                         if(RTMPGetKeyParameter("EncrypType", tmpbuf, 128, buffer))
1330                                         {
1331
1332 #ifdef CONFIG_STA_SUPPORT
1333                                                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1334                                                 {
1335                                                         if ((strcmp(tmpbuf, "WEP") == 0) || (strcmp(tmpbuf, "wep") == 0))
1336                                                                 pAd->StaCfg.WepStatus   = Ndis802_11WEPEnabled;
1337                                                         else if ((strcmp(tmpbuf, "TKIP") == 0) || (strcmp(tmpbuf, "tkip") == 0))
1338                                                                 pAd->StaCfg.WepStatus   = Ndis802_11Encryption2Enabled;
1339                                                         else if ((strcmp(tmpbuf, "AES") == 0) || (strcmp(tmpbuf, "aes") == 0))
1340                                                                 pAd->StaCfg.WepStatus   = Ndis802_11Encryption3Enabled;
1341                                                         else
1342                                                                 pAd->StaCfg.WepStatus   = Ndis802_11WEPDisabled;
1343
1344                                                         // Update all wepstatus related
1345                                                         pAd->StaCfg.PairCipher          = pAd->StaCfg.WepStatus;
1346                                                         pAd->StaCfg.GroupCipher         = pAd->StaCfg.WepStatus;
1347                                                         pAd->StaCfg.OrigWepStatus       = pAd->StaCfg.WepStatus;
1348                                                         pAd->StaCfg.bMixCipher          = FALSE;
1349
1350                                                         //RTMPMakeRSNIE(pAd, pAd->StaCfg.AuthMode, pAd->StaCfg.WepStatus, 0);
1351                                                         DBGPRINT(RT_DEBUG_TRACE, ("%s::(EncrypType=%d)\n", __func__, pAd->StaCfg.WepStatus));
1352                                                 }
1353 #endif // CONFIG_STA_SUPPORT //
1354                                         }
1355
1356
1357
1358 #ifdef CONFIG_STA_SUPPORT
1359                                         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1360                                         {
1361                                                 if(RTMPGetCriticalParameter("WPAPSK", tmpbuf, 512, buffer))
1362                                                 {
1363                                                         int     err=0;
1364
1365                                                         tmpbuf[strlen(tmpbuf)] = '\0'; // make STA can process .$^& for WPAPSK input
1366
1367                                                         if ((pAd->StaCfg.AuthMode != Ndis802_11AuthModeWPAPSK) &&
1368                                                                 (pAd->StaCfg.AuthMode != Ndis802_11AuthModeWPA2PSK) &&
1369                                                                 (pAd->StaCfg.AuthMode != Ndis802_11AuthModeWPANone)
1370                                                                 )
1371                                                         {
1372                                                                 err = 1;
1373                                                         }
1374                                                         else if ((strlen(tmpbuf) >= 8) && (strlen(tmpbuf) < 64))
1375                                                         {
1376                                                                 PasswordHash((char *)tmpbuf, pAd->CommonCfg.Ssid, pAd->CommonCfg.SsidLen, keyMaterial);
1377                                                                 NdisMoveMemory(pAd->StaCfg.PMK, keyMaterial, 32);
1378
1379                                                         }
1380                                                         else if (strlen(tmpbuf) == 64)
1381                                                         {
1382                                                                 AtoH(tmpbuf, keyMaterial, 32);
1383                                                                 NdisMoveMemory(pAd->StaCfg.PMK, keyMaterial, 32);
1384                                                         }
1385                                                         else
1386                                                         {
1387                                                                 err = 1;
1388                                                                 DBGPRINT(RT_DEBUG_ERROR, ("%s::(WPAPSK key-string required 8 ~ 64 characters!)\n", __func__));
1389                                                         }
1390
1391                                                         if (err == 0)
1392                                                         {
1393                                                                 if ((pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPAPSK) ||
1394                                                                         (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2PSK))
1395                                                                 {
1396                                                                         // Start STA supplicant state machine
1397                                                                         pAd->StaCfg.WpaState = SS_START;
1398                                                                 }
1399                                                                 else if (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPANone)
1400                                                                 {
1401         /*
1402                                                                         NdisZeroMemory(&pAd->SharedKey[BSS0][0], sizeof(CIPHER_KEY));
1403                                                                         pAd->SharedKey[BSS0][0].KeyLen = LEN_TKIP_EK;
1404                                                                         NdisMoveMemory(pAd->SharedKey[BSS0][0].Key, pAd->StaCfg.PMK, LEN_TKIP_EK);
1405                                                                         NdisMoveMemory(pAd->SharedKey[BSS0][0].RxMic, &pAd->StaCfg.PMK[16], LEN_TKIP_RXMICK);
1406                                                                         NdisMoveMemory(pAd->SharedKey[BSS0][0].TxMic, &pAd->StaCfg.PMK[16], LEN_TKIP_TXMICK);
1407
1408                                                                         // Decide its ChiperAlg
1409                                                                         if (pAd->StaCfg.PairCipher == Ndis802_11Encryption2Enabled)
1410                                                                                 pAd->SharedKey[BSS0][0].CipherAlg = CIPHER_TKIP;
1411                                                                         else if (pAd->StaCfg.PairCipher == Ndis802_11Encryption3Enabled)
1412                                                                                 pAd->SharedKey[BSS0][0].CipherAlg = CIPHER_AES;
1413                                                                         else
1414                                                                                 pAd->SharedKey[BSS0][0].CipherAlg = CIPHER_NONE;
1415         */
1416                                                                         pAd->StaCfg.WpaState = SS_NOTUSE;
1417                                                                 }
1418
1419                                                                 DBGPRINT(RT_DEBUG_TRACE, ("%s::(WPAPSK=%s)\n", __func__, tmpbuf));
1420                                                         }
1421                                                 }
1422                                         }
1423 #endif // CONFIG_STA_SUPPORT //
1424
1425                                         //DefaultKeyID, KeyType, KeyStr
1426                                         rtmp_read_key_parms_from_file(pAd, tmpbuf, buffer);
1427
1428
1429                                         //HSCounter
1430                                         /*if(RTMPGetKeyParameter("HSCounter", tmpbuf, 10, buffer))
1431                                         {
1432                                                 switch (simple_strtol(tmpbuf, 0, 10))
1433                                                 {
1434                                                         case 1: //Enable
1435                                                                 pAd->CommonCfg.bEnableHSCounter = TRUE;
1436                                                                 break;
1437                                                         case 0: //Disable
1438                                                         default:
1439                                                                 pAd->CommonCfg.bEnableHSCounter = FALSE;
1440                                                                 break;
1441                                                 }
1442                                                 DBGPRINT(RT_DEBUG_TRACE, "HSCounter=%d\n", pAd->CommonCfg.bEnableHSCounter);
1443                                         }*/
1444
1445 #ifdef DOT11_N_SUPPORT
1446                                         HTParametersHook(pAd, tmpbuf, buffer);
1447 #endif // DOT11_N_SUPPORT //
1448
1449 #ifdef CONFIG_STA_SUPPORT
1450                                         IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1451                                         {
1452                                                 //PSMode
1453                                                 if (RTMPGetKeyParameter("PSMode", tmpbuf, 10, buffer))
1454                                                 {
1455                                                         if (pAd->StaCfg.BssType == BSS_INFRA)
1456                                                         {
1457                                                                 if ((strcmp(tmpbuf, "MAX_PSP") == 0) || (strcmp(tmpbuf, "max_psp") == 0))
1458                                                                 {
1459                                                                         // do NOT turn on PSM bit here, wait until MlmeCheckForPsmChange()
1460                                                                         // to exclude certain situations.
1461                                                                         //         MlmeSetPsm(pAd, PWR_SAVE);
1462                                                                         OPSTATUS_SET_FLAG(pAd, fOP_STATUS_RECEIVE_DTIM);
1463                                                                         if (pAd->StaCfg.bWindowsACCAMEnable == FALSE)
1464                                                                                 pAd->StaCfg.WindowsPowerMode = Ndis802_11PowerModeMAX_PSP;
1465                                                                         pAd->StaCfg.WindowsBatteryPowerMode = Ndis802_11PowerModeMAX_PSP;
1466                                                                         pAd->StaCfg.DefaultListenCount = 5;
1467                                                                 }
1468                                                                 else if ((strcmp(tmpbuf, "Fast_PSP") == 0) || (strcmp(tmpbuf, "fast_psp") == 0)
1469                                                                         || (strcmp(tmpbuf, "FAST_PSP") == 0))
1470                                                                 {
1471                                                                         // do NOT turn on PSM bit here, wait until MlmeCheckForPsmChange()
1472                                                                         // to exclude certain situations.
1473                                                                         //         MlmeSetPsmBit(pAd, PWR_SAVE);
1474                                                                         OPSTATUS_SET_FLAG(pAd, fOP_STATUS_RECEIVE_DTIM);
1475                                                                         if (pAd->StaCfg.bWindowsACCAMEnable == FALSE)
1476                                                                                 pAd->StaCfg.WindowsPowerMode = Ndis802_11PowerModeFast_PSP;
1477                                                                         pAd->StaCfg.WindowsBatteryPowerMode = Ndis802_11PowerModeFast_PSP;
1478                                                                         pAd->StaCfg.DefaultListenCount = 3;
1479                                                                 }
1480                                                                 else if ((strcmp(tmpbuf, "Legacy_PSP") == 0) || (strcmp(tmpbuf, "legacy_psp") == 0)
1481                                                                         || (strcmp(tmpbuf, "LEGACY_PSP") == 0))
1482                                                                 {
1483                                                                         // do NOT turn on PSM bit here, wait until MlmeCheckForPsmChange()
1484                                                                         // to exclude certain situations.
1485                                                                         //         MlmeSetPsmBit(pAd, PWR_SAVE);
1486                                                                         OPSTATUS_SET_FLAG(pAd, fOP_STATUS_RECEIVE_DTIM);
1487                                                                         if (pAd->StaCfg.bWindowsACCAMEnable == FALSE)
1488                                                                                 pAd->StaCfg.WindowsPowerMode = Ndis802_11PowerModeLegacy_PSP;
1489                                                                         pAd->StaCfg.WindowsBatteryPowerMode = Ndis802_11PowerModeLegacy_PSP;
1490                                                                         pAd->StaCfg.DefaultListenCount = 3;
1491                                                                 }
1492                                                                 else
1493                                                                 { //Default Ndis802_11PowerModeCAM
1494                                                                         // clear PSM bit immediately
1495                                                                         MlmeSetPsmBit(pAd, PWR_ACTIVE);
1496                                                                         OPSTATUS_SET_FLAG(pAd, fOP_STATUS_RECEIVE_DTIM);
1497                                                                         if (pAd->StaCfg.bWindowsACCAMEnable == FALSE)
1498                                                                                 pAd->StaCfg.WindowsPowerMode = Ndis802_11PowerModeCAM;
1499                                                                         pAd->StaCfg.WindowsBatteryPowerMode = Ndis802_11PowerModeCAM;
1500                                                                 }
1501                                                                 DBGPRINT(RT_DEBUG_TRACE, ("PSMode=%ld\n", pAd->StaCfg.WindowsPowerMode));
1502                                                         }
1503                                                 }
1504                                                 // FastRoaming
1505                                                 if (RTMPGetKeyParameter("FastRoaming", tmpbuf, 32, buffer))
1506                                                 {
1507                                                         if (simple_strtol(tmpbuf, 0, 10) == 0)
1508                                                                 pAd->StaCfg.bFastRoaming = FALSE;
1509                                                         else
1510                                                                 pAd->StaCfg.bFastRoaming = TRUE;
1511
1512                                                         DBGPRINT(RT_DEBUG_TRACE, ("FastRoaming=%d\n", pAd->StaCfg.bFastRoaming));
1513                                                 }
1514                                                 // RoamThreshold
1515                                                 if (RTMPGetKeyParameter("RoamThreshold", tmpbuf, 32, buffer))
1516                                                 {
1517                                                         long lInfo = simple_strtol(tmpbuf, 0, 10);
1518
1519                                                         if (lInfo > 90 || lInfo < 60)
1520                                                                 pAd->StaCfg.dBmToRoam = -70;
1521                                                         else
1522                                                                 pAd->StaCfg.dBmToRoam = (CHAR)(-1)*lInfo;
1523
1524                                                         DBGPRINT(RT_DEBUG_TRACE, ("RoamThreshold=%d  dBm\n", pAd->StaCfg.dBmToRoam));
1525                                                 }
1526
1527                                                 if(RTMPGetKeyParameter("TGnWifiTest", tmpbuf, 10, buffer))
1528                                                 {
1529                                                         if(simple_strtol(tmpbuf, 0, 10) == 0)
1530                                                                 pAd->StaCfg.bTGnWifiTest = FALSE;
1531                                                         else
1532                                                                 pAd->StaCfg.bTGnWifiTest = TRUE;
1533                                                                 DBGPRINT(RT_DEBUG_TRACE, ("TGnWifiTest=%d\n", pAd->StaCfg.bTGnWifiTest));
1534                                                 }
1535                                         }
1536 #endif // CONFIG_STA_SUPPORT //
1537
1538
1539 #ifdef RT30xx
1540 #ifdef CONFIG_STA_SUPPORT
1541                                                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1542                                                 {
1543                                                         if(RTMPGetKeyParameter("AntDiversity", tmpbuf, 10, buffer))
1544                                                         {
1545                                                                 for (i = 0, macptr = rstrtok(tmpbuf,";"); macptr; macptr = rstrtok(NULL,";"), i++)
1546                                                                 {
1547                                                                         if(simple_strtol(macptr, 0, 10) != 0)  //Enable
1548                                                                                 pAd->CommonCfg.bRxAntDiversity = TRUE;
1549                                                                         else //Disable
1550                                                                                 pAd->CommonCfg.bRxAntDiversity = FALSE;
1551
1552                                                                         DBGPRINT(RT_DEBUG_ERROR, ("AntDiversity=%d\n", pAd->CommonCfg.bRxAntDiversity));
1553                                                                 }
1554                                                         }
1555                                                 }
1556 #endif // CONFIG_STA_SUPPORT //
1557 #endif // RT30xx //
1558                                 }
1559                         }
1560                         else
1561                         {
1562                                 DBGPRINT(RT_DEBUG_TRACE, ("--> %s does not have a write method\n", src));
1563                         }
1564
1565                         retval=filp_close(srcf,NULL);
1566
1567                         if (retval)
1568                         {
1569                                 DBGPRINT(RT_DEBUG_TRACE, ("--> Error %d closing %s\n", -retval, src));
1570                         }
1571                 }
1572         }
1573
1574         set_fs(orgfs);
1575 #if 0
1576         current->fsuid = orgfsuid;
1577         current->fsgid = orgfsgid;
1578 #endif
1579
1580         kfree(buffer);
1581         kfree(tmpbuf);
1582
1583         return (NDIS_STATUS_SUCCESS);
1584 }
1585
1586 #ifdef DOT11_N_SUPPORT
1587 static void     HTParametersHook(
1588         IN      PRTMP_ADAPTER pAd,
1589         IN      CHAR              *pValueStr,
1590         IN      CHAR              *pInput)
1591 {
1592
1593         INT Value;
1594
1595     if (RTMPGetKeyParameter("HT_PROTECT", pValueStr, 25, pInput))
1596     {
1597         Value = simple_strtol(pValueStr, 0, 10);
1598         if (Value == 0)
1599         {
1600             pAd->CommonCfg.bHTProtect = FALSE;
1601         }
1602         else
1603         {
1604             pAd->CommonCfg.bHTProtect = TRUE;
1605         }
1606         DBGPRINT(RT_DEBUG_TRACE, ("HT: Protection  = %s\n", (Value==0) ? "Disable" : "Enable"));
1607     }
1608
1609     if (RTMPGetKeyParameter("HT_MIMOPSEnable", pValueStr, 25, pInput))
1610     {
1611         Value = simple_strtol(pValueStr, 0, 10);
1612         if (Value == 0)
1613         {
1614             pAd->CommonCfg.bMIMOPSEnable = FALSE;
1615         }
1616         else
1617         {
1618             pAd->CommonCfg.bMIMOPSEnable = TRUE;
1619         }
1620         DBGPRINT(RT_DEBUG_TRACE, ("HT: MIMOPSEnable  = %s\n", (Value==0) ? "Disable" : "Enable"));
1621     }
1622
1623
1624     if (RTMPGetKeyParameter("HT_MIMOPSMode", pValueStr, 25, pInput))
1625     {
1626         Value = simple_strtol(pValueStr, 0, 10);
1627         if (Value > MMPS_ENABLE)
1628         {
1629                         pAd->CommonCfg.BACapability.field.MMPSmode = MMPS_ENABLE;
1630         }
1631         else
1632         {
1633             //TODO: add mimo power saving mechanism
1634             pAd->CommonCfg.BACapability.field.MMPSmode = MMPS_ENABLE;
1635                         //pAd->CommonCfg.BACapability.field.MMPSmode = Value;
1636         }
1637         DBGPRINT(RT_DEBUG_TRACE, ("HT: MIMOPS Mode  = %d\n", Value));
1638     }
1639
1640     if (RTMPGetKeyParameter("HT_BADecline", pValueStr, 25, pInput))
1641     {
1642         Value = simple_strtol(pValueStr, 0, 10);
1643         if (Value == 0)
1644         {
1645             pAd->CommonCfg.bBADecline = FALSE;
1646         }
1647         else
1648         {
1649             pAd->CommonCfg.bBADecline = TRUE;
1650         }
1651         DBGPRINT(RT_DEBUG_TRACE, ("HT: BA Decline  = %s\n", (Value==0) ? "Disable" : "Enable"));
1652     }
1653
1654
1655     if (RTMPGetKeyParameter("HT_DisableReordering", pValueStr, 25, pInput))
1656     {
1657         Value = simple_strtol(pValueStr, 0, 10);
1658         if (Value == 0)
1659         {
1660             pAd->CommonCfg.bDisableReordering = FALSE;
1661         }
1662         else
1663         {
1664             pAd->CommonCfg.bDisableReordering = TRUE;
1665         }
1666         DBGPRINT(RT_DEBUG_TRACE, ("HT: DisableReordering  = %s\n", (Value==0) ? "Disable" : "Enable"));
1667     }
1668
1669     if (RTMPGetKeyParameter("HT_AutoBA", pValueStr, 25, pInput))
1670     {
1671         Value = simple_strtol(pValueStr, 0, 10);
1672         if (Value == 0)
1673         {
1674             pAd->CommonCfg.BACapability.field.AutoBA = FALSE;
1675             pAd->CommonCfg.BACapability.field.Policy = BA_NOTUSE;
1676         }
1677         else
1678         {
1679             pAd->CommonCfg.BACapability.field.AutoBA = TRUE;
1680             pAd->CommonCfg.BACapability.field.Policy = IMMED_BA;
1681         }
1682         pAd->CommonCfg.REGBACapability.field.AutoBA = pAd->CommonCfg.BACapability.field.AutoBA;
1683         pAd->CommonCfg.REGBACapability.field.Policy = pAd->CommonCfg.BACapability.field.Policy;
1684         DBGPRINT(RT_DEBUG_TRACE, ("HT: Auto BA  = %s\n", (Value==0) ? "Disable" : "Enable"));
1685     }
1686
1687         // Tx_+HTC frame
1688     if (RTMPGetKeyParameter("HT_HTC", pValueStr, 25, pInput))
1689         {
1690                 Value = simple_strtol(pValueStr, 0, 10);
1691                 if (Value == 0)
1692                 {
1693                         pAd->HTCEnable = FALSE;
1694                 }
1695                 else
1696                 {
1697                         pAd->HTCEnable = TRUE;
1698                 }
1699                 DBGPRINT(RT_DEBUG_TRACE, ("HT: Tx +HTC frame = %s\n", (Value==0) ? "Disable" : "Enable"));
1700         }
1701
1702         // Enable HT Link Adaptation Control
1703         if (RTMPGetKeyParameter("HT_LinkAdapt", pValueStr, 25, pInput))
1704         {
1705                 Value = simple_strtol(pValueStr, 0, 10);
1706                 if (Value == 0)
1707                 {
1708                         pAd->bLinkAdapt = FALSE;
1709                 }
1710                 else
1711                 {
1712                         pAd->HTCEnable = TRUE;
1713                         pAd->bLinkAdapt = TRUE;
1714                 }
1715                 DBGPRINT(RT_DEBUG_TRACE, ("HT: Link Adaptation Control = %s\n", (Value==0) ? "Disable" : "Enable(+HTC)"));
1716         }
1717
1718         // Reverse Direction Mechanism
1719     if (RTMPGetKeyParameter("HT_RDG", pValueStr, 25, pInput))
1720         {
1721                 Value = simple_strtol(pValueStr, 0, 10);
1722                 if (Value == 0)
1723                 {
1724                         pAd->CommonCfg.bRdg = FALSE;
1725                 }
1726                 else
1727                 {
1728                         pAd->HTCEnable = TRUE;
1729             pAd->CommonCfg.bRdg = TRUE;
1730                 }
1731                 DBGPRINT(RT_DEBUG_TRACE, ("HT: RDG = %s\n", (Value==0) ? "Disable" : "Enable(+HTC)"));
1732         }
1733
1734
1735
1736
1737         // Tx A-MSUD ?
1738     if (RTMPGetKeyParameter("HT_AMSDU", pValueStr, 25, pInput))
1739         {
1740                 Value = simple_strtol(pValueStr, 0, 10);
1741                 if (Value == 0)
1742                 {
1743                         pAd->CommonCfg.BACapability.field.AmsduEnable = FALSE;
1744                 }
1745                 else
1746                 {
1747             pAd->CommonCfg.BACapability.field.AmsduEnable = TRUE;
1748                 }
1749                 DBGPRINT(RT_DEBUG_TRACE, ("HT: Tx A-MSDU = %s\n", (Value==0) ? "Disable" : "Enable"));
1750         }
1751
1752         // MPDU Density
1753     if (RTMPGetKeyParameter("HT_MpduDensity", pValueStr, 25, pInput))
1754         {
1755                 Value = simple_strtol(pValueStr, 0, 10);
1756                 if (Value <=7 && Value >= 0)
1757                 {
1758                         pAd->CommonCfg.BACapability.field.MpduDensity = Value;
1759                         DBGPRINT(RT_DEBUG_TRACE, ("HT: MPDU Density = %d\n", Value));
1760                 }
1761                 else
1762                 {
1763                         pAd->CommonCfg.BACapability.field.MpduDensity = 4;
1764                         DBGPRINT(RT_DEBUG_TRACE, ("HT: MPDU Density = %d (Default)\n", 4));
1765                 }
1766         }
1767
1768         // Max Rx BA Window Size
1769     if (RTMPGetKeyParameter("HT_BAWinSize", pValueStr, 25, pInput))
1770         {
1771                 Value = simple_strtol(pValueStr, 0, 10);
1772
1773                 if (Value >=1 && Value <= 64)
1774                 {
1775                         pAd->CommonCfg.REGBACapability.field.RxBAWinLimit = Value;
1776                         pAd->CommonCfg.BACapability.field.RxBAWinLimit = Value;
1777                         DBGPRINT(RT_DEBUG_TRACE, ("HT: BA Windw Size = %d\n", Value));
1778                 }
1779                 else
1780                 {
1781             pAd->CommonCfg.REGBACapability.field.RxBAWinLimit = 64;
1782                         pAd->CommonCfg.BACapability.field.RxBAWinLimit = 64;
1783                         DBGPRINT(RT_DEBUG_TRACE, ("HT: BA Windw Size = 64 (Defualt)\n"));
1784                 }
1785
1786         }
1787
1788         // Guard Interval
1789         if (RTMPGetKeyParameter("HT_GI", pValueStr, 25, pInput))
1790         {
1791                 Value = simple_strtol(pValueStr, 0, 10);
1792
1793                 if (Value == GI_400)
1794                 {
1795                         pAd->CommonCfg.RegTransmitSetting.field.ShortGI = GI_400;
1796                 }
1797                 else
1798                 {
1799                         pAd->CommonCfg.RegTransmitSetting.field.ShortGI = GI_800;
1800                 }
1801
1802                 DBGPRINT(RT_DEBUG_TRACE, ("HT: Guard Interval = %s\n", (Value==GI_400) ? "400" : "800" ));
1803         }
1804
1805         // HT Operation Mode : Mixed Mode , Green Field
1806         if (RTMPGetKeyParameter("HT_OpMode", pValueStr, 25, pInput))
1807         {
1808                 Value = simple_strtol(pValueStr, 0, 10);
1809
1810                 if (Value == HTMODE_GF)
1811                 {
1812
1813                         pAd->CommonCfg.RegTransmitSetting.field.HTMODE  = HTMODE_GF;
1814                 }
1815                 else
1816                 {
1817                         pAd->CommonCfg.RegTransmitSetting.field.HTMODE  = HTMODE_MM;
1818                 }
1819
1820                 DBGPRINT(RT_DEBUG_TRACE, ("HT: Operate Mode = %s\n", (Value==HTMODE_GF) ? "Green Field" : "Mixed Mode" ));
1821         }
1822
1823         // Fixed Tx mode : CCK, OFDM
1824         if (RTMPGetKeyParameter("FixedTxMode", pValueStr, 25, pInput))
1825         {
1826                 UCHAR   fix_tx_mode;
1827
1828 #ifdef CONFIG_STA_SUPPORT
1829                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1830                 {
1831                         fix_tx_mode = FIXED_TXMODE_HT;
1832
1833                         if (strcmp(pValueStr, "OFDM") == 0 || strcmp(pValueStr, "ofdm") == 0)
1834                         {
1835                                 fix_tx_mode = FIXED_TXMODE_OFDM;
1836                         }
1837                         else if (strcmp(pValueStr, "CCK") == 0 || strcmp(pValueStr, "cck") == 0)
1838                         {
1839                         fix_tx_mode = FIXED_TXMODE_CCK;
1840                         }
1841                         else if (strcmp(pValueStr, "HT") == 0 || strcmp(pValueStr, "ht") == 0)
1842                         {
1843                         fix_tx_mode = FIXED_TXMODE_HT;
1844                 }
1845                 else
1846                 {
1847                                 Value = simple_strtol(pValueStr, 0, 10);
1848                                 // 1 : CCK
1849                                 // 2 : OFDM
1850                                 // otherwise : HT
1851                                 if (Value == FIXED_TXMODE_CCK || Value == FIXED_TXMODE_OFDM)
1852                                         fix_tx_mode = Value;
1853                                 else
1854                                         fix_tx_mode = FIXED_TXMODE_HT;
1855                 }
1856
1857                         pAd->StaCfg.DesiredTransmitSetting.field.FixedTxMode = fix_tx_mode;
1858                         DBGPRINT(RT_DEBUG_TRACE, ("Fixed Tx Mode = %d\n", fix_tx_mode));
1859
1860                 }
1861 #endif // CONFIG_STA_SUPPORT //
1862         }
1863
1864
1865         // Channel Width
1866         if (RTMPGetKeyParameter("HT_BW", pValueStr, 25, pInput))
1867         {
1868                 Value = simple_strtol(pValueStr, 0, 10);
1869
1870                 if (Value == BW_40)
1871                 {
1872                         pAd->CommonCfg.RegTransmitSetting.field.BW  = BW_40;
1873                 }
1874                 else
1875                 {
1876             pAd->CommonCfg.RegTransmitSetting.field.BW  = BW_20;
1877                 }
1878
1879 #ifdef MCAST_RATE_SPECIFIC
1880                 pAd->CommonCfg.MCastPhyMode.field.BW = pAd->CommonCfg.RegTransmitSetting.field.BW;
1881 #endif // MCAST_RATE_SPECIFIC //
1882
1883                 DBGPRINT(RT_DEBUG_TRACE, ("HT: Channel Width = %s\n", (Value==BW_40) ? "40 MHz" : "20 MHz" ));
1884         }
1885
1886         if (RTMPGetKeyParameter("HT_EXTCHA", pValueStr, 25, pInput))
1887         {
1888                 Value = simple_strtol(pValueStr, 0, 10);
1889
1890                 if (Value == 0)
1891                 {
1892
1893                         pAd->CommonCfg.RegTransmitSetting.field.EXTCHA  = EXTCHA_BELOW;
1894                 }
1895                 else
1896                 {
1897             pAd->CommonCfg.RegTransmitSetting.field.EXTCHA = EXTCHA_ABOVE;
1898                 }
1899
1900                 DBGPRINT(RT_DEBUG_TRACE, ("HT: Ext Channel = %s\n", (Value==0) ? "BELOW" : "ABOVE" ));
1901         }
1902
1903         // MSC
1904         if (RTMPGetKeyParameter("HT_MCS", pValueStr, 50, pInput))
1905         {
1906
1907 #ifdef CONFIG_STA_SUPPORT
1908                 IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
1909                 {
1910                         Value = simple_strtol(pValueStr, 0, 10);
1911
1912 //                      if ((Value >= 0 && Value <= 15) || (Value == 32))
1913                         if ((Value >= 0 && Value <= 23) || (Value == 32)) // 3*3
1914                 {
1915                                 pAd->StaCfg.DesiredTransmitSetting.field.MCS  = Value;
1916                                 pAd->StaCfg.bAutoTxRateSwitch = FALSE;
1917                                 DBGPRINT(RT_DEBUG_TRACE, ("HT: MCS = %d\n", pAd->StaCfg.DesiredTransmitSetting.field.MCS));
1918                 }
1919                 else
1920                 {
1921                                 pAd->StaCfg.DesiredTransmitSetting.field.MCS  = MCS_AUTO;
1922                                 pAd->StaCfg.bAutoTxRateSwitch = TRUE;
1923                                 DBGPRINT(RT_DEBUG_TRACE, ("HT: MCS = AUTO\n"));
1924                 }
1925         }
1926 #endif // CONFIG_STA_SUPPORT //
1927         }
1928
1929         // STBC
1930     if (RTMPGetKeyParameter("HT_STBC", pValueStr, 25, pInput))
1931         {
1932                 Value = simple_strtol(pValueStr, 0, 10);
1933                 if (Value == STBC_USE)
1934                 {
1935                         pAd->CommonCfg.RegTransmitSetting.field.STBC = STBC_USE;
1936                 }
1937                 else
1938                 {
1939                         pAd->CommonCfg.RegTransmitSetting.field.STBC = STBC_NONE;
1940                 }
1941                 DBGPRINT(RT_DEBUG_TRACE, ("HT: STBC = %d\n", pAd->CommonCfg.RegTransmitSetting.field.STBC));
1942         }
1943
1944         // 40_Mhz_Intolerant
1945         if (RTMPGetKeyParameter("HT_40MHZ_INTOLERANT", pValueStr, 25, pInput))
1946         {
1947                 Value = simple_strtol(pValueStr, 0, 10);
1948                 if (Value == 0)
1949                 {
1950                         pAd->CommonCfg.bForty_Mhz_Intolerant = FALSE;
1951                 }
1952                 else
1953                 {
1954                         pAd->CommonCfg.bForty_Mhz_Intolerant = TRUE;
1955                 }
1956                 DBGPRINT(RT_DEBUG_TRACE, ("HT: 40MHZ INTOLERANT = %d\n", pAd->CommonCfg.bForty_Mhz_Intolerant));
1957         }
1958         //HT_TxStream
1959         if(RTMPGetKeyParameter("HT_TxStream", pValueStr, 10, pInput))
1960         {
1961                 switch (simple_strtol(pValueStr, 0, 10))
1962                 {
1963                         case 1:
1964                                 pAd->CommonCfg.TxStream = 1;
1965                                 break;
1966                         case 2:
1967                                 pAd->CommonCfg.TxStream = 2;
1968                                 break;
1969                         case 3: // 3*3
1970                         default:
1971                                 pAd->CommonCfg.TxStream = 3;
1972
1973                                 if (pAd->MACVersion < RALINK_2883_VERSION)
1974                                         pAd->CommonCfg.TxStream = 2; // only 2 tx streams for RT2860 series
1975                                 break;
1976                 }
1977                 DBGPRINT(RT_DEBUG_TRACE, ("HT: Tx Stream = %d\n", pAd->CommonCfg.TxStream));
1978         }
1979         //HT_RxStream
1980         if(RTMPGetKeyParameter("HT_RxStream", pValueStr, 10, pInput))
1981         {
1982                 switch (simple_strtol(pValueStr, 0, 10))
1983                 {
1984                         case 1:
1985                                 pAd->CommonCfg.RxStream = 1;
1986                                 break;
1987                         case 2:
1988                                 pAd->CommonCfg.RxStream = 2;
1989                                 break;
1990                         case 3:
1991                         default:
1992                                 pAd->CommonCfg.RxStream = 3;
1993
1994                                 if (pAd->MACVersion < RALINK_2883_VERSION)
1995                                         pAd->CommonCfg.RxStream = 2; // only 2 rx streams for RT2860 series
1996                                 break;
1997                 }
1998                 DBGPRINT(RT_DEBUG_TRACE, ("HT: Rx Stream = %d\n", pAd->CommonCfg.RxStream));
1999         }
2000
2001 }
2002 #endif // DOT11_N_SUPPORT //
2003