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