drivers/staging/vt6655/key.c

   1 /*
   2  * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  *
  20  * File: key.c
  21  *
  22  * Purpose: Implement functions for 802.11i Key management
  23  *
  24  * Author: Jerry Chen
  25  *
  26  * Date: May 29, 2003
  27  *
  28  * Functions:
  29  *      KeyvInitTable - Init Key management table
  30  *      KeybGetKey - Get Key from table
  31  *      KeybSetKey - Set Key to table
  32  *      KeybRemoveKey - Remove Key from table
  33  *      KeybGetTransmitKey - Get Transmit Key from table
  34  *
  35  * Revision History:
  36  *
  37  */
  38
  39 #include "tmacro.h"
  40 #include "key.h"
  41 #include "mac.h"
  42
  43 /*---------------------  Static Definitions -------------------------*/
  44
  45 /*---------------------  Static Classes  ----------------------------*/
  46
  47 /*---------------------  Static Functions  --------------------------*/
  48
  49 /*---------------------  Export Variables  --------------------------*/
  50
  51 /*---------------------  Static Definitions -------------------------*/
  52
  53 /*---------------------  Static Classes  ----------------------------*/
  54
  55 /*---------------------  Static Variables  --------------------------*/
  56
  57 /*---------------------  Static Functions  --------------------------*/
  58 static void
  59 s_vCheckKeyTableValid(PSKeyManagement pTable, void __iomem *dwIoBase)
  60 {
  61         int i;
  62
  63         for (i = 0; i < MAX_KEY_TABLE; i++) {
  64                 if (pTable->KeyTable[i].bInUse &&
  65                     !pTable->KeyTable[i].PairwiseKey.bKeyValid &&
  66                     !pTable->KeyTable[i].GroupKey[0].bKeyValid &&
  67                     !pTable->KeyTable[i].GroupKey[1].bKeyValid &&
  68                     !pTable->KeyTable[i].GroupKey[2].bKeyValid &&
  69                     !pTable->KeyTable[i].GroupKey[3].bKeyValid) {
  70                         pTable->KeyTable[i].bInUse = false;
  71                         pTable->KeyTable[i].wKeyCtl = 0;
  72                         pTable->KeyTable[i].bSoftWEP = false;
  73                         MACvDisableKeyEntry(dwIoBase, i);
  74                 }
  75         }
  76 }
  77
  78 /*---------------------  Export Functions  --------------------------*/
  79
  80 /*
  81  * Description: Init Key management table
  82  *
  83  * Parameters:
  84  *  In:
  85  *      pTable          - Pointer to Key table
  86  *  Out:
  87  *      none
  88  *
  89  * Return Value: none
  90  *
  91  */
  92 void KeyvInitTable(PSKeyManagement pTable, void __iomem *dwIoBase)
  93 {
  94         int i;
  95         int jj;
  96
  97         for (i = 0; i < MAX_KEY_TABLE; i++) {
  98                 pTable->KeyTable[i].bInUse = false;
  99                 pTable->KeyTable[i].PairwiseKey.bKeyValid = false;
 100                 pTable->KeyTable[i].PairwiseKey.pvKeyTable = (void *)&pTable->KeyTable[i];
 101                 for (jj = 0; jj < MAX_GROUP_KEY; jj++) {
 102                         pTable->KeyTable[i].GroupKey[jj].bKeyValid = false;
 103                         pTable->KeyTable[i].GroupKey[jj].pvKeyTable = (void *)&pTable->KeyTable[i];
 104                 }
 105                 pTable->KeyTable[i].wKeyCtl = 0;
 106                 pTable->KeyTable[i].dwGTKeyIndex = 0;
 107                 pTable->KeyTable[i].bSoftWEP = false;
 108                 MACvDisableKeyEntry(dwIoBase, i);
 109         }
 110 }
 111
 112 /*
 113  * Description: Get Key from table
 114  *
 115  * Parameters:
 116  *  In:
 117  *      pTable          - Pointer to Key table
 118  *      pbyBSSID        - BSSID of Key
 119  *      dwKeyIndex      - Key Index (0xFFFFFFFF means pairwise key)
 120  *  Out:
 121  *      pKey            - Key return
 122  *
 123  * Return Value: true if found otherwise false
 124  *
 125  */
 126 bool KeybGetKey(
 127         PSKeyManagement pTable,
 128         unsigned char *pbyBSSID,
 129         unsigned long dwKeyIndex,
 130         PSKeyItem       *pKey
 131 )
 132 {
 133         int i;
 134
 135         pr_debug("KeybGetKey()\n");
 136
 137         *pKey = NULL;
 138         for (i = 0; i < MAX_KEY_TABLE; i++) {
 139                 if (pTable->KeyTable[i].bInUse &&
 140                     ether_addr_equal(pTable->KeyTable[i].abyBSSID, pbyBSSID)) {
 141                         if (dwKeyIndex == 0xFFFFFFFF) {
 142                                 if (pTable->KeyTable[i].PairwiseKey.bKeyValid) {
 143                                         *pKey = &(pTable->KeyTable[i].PairwiseKey);
 144                                         return true;
 145                                 } else {
 146                                         return false;
 147                                 }
 148                         } else if (dwKeyIndex < MAX_GROUP_KEY) {
 149                                 if (pTable->KeyTable[i].GroupKey[dwKeyIndex].bKeyValid) {
 150                                         *pKey = &(pTable->KeyTable[i].GroupKey[dwKeyIndex]);
 151                                         return true;
 152                                 } else {
 153                                         return false;
 154                                 }
 155                         } else {
 156                                 return false;
 157                         }
 158                 }
 159         }
 160         return false;
 161 }
 162
 163 /*
 164  * Description: Set Key to table
 165  *
 166  * Parameters:
 167  *  In:
 168  *      pTable          - Pointer to Key table
 169  *      pbyBSSID        - BSSID of Key
 170  *      dwKeyIndex      - Key index (reference to NDIS DDK)
 171  *      uKeyLength      - Key length
 172  *      KeyRSC          - Key RSC
 173  *      pbyKey          - Pointer to key
 174  *  Out:
 175  *      none
 176  *
 177  * Return Value: true if success otherwise false
 178  *
 179  */
 180 bool KeybSetKey(
 181         PSKeyManagement pTable,
 182         unsigned char *pbyBSSID,
 183         unsigned long dwKeyIndex,
 184         unsigned long uKeyLength,
 185         u64 *pKeyRSC,
 186         unsigned char *pbyKey,
 187         unsigned char byKeyDecMode,
 188         void __iomem *dwIoBase,
 189         unsigned char byLocalID
 190 )
 191 {
 192         int i, j;
 193         unsigned int ii;
 194         PSKeyItem   pKey;
 195         unsigned int uKeyIdx;
 196
 197         pr_debug("Enter KeybSetKey: %lX\n", dwKeyIndex);
 198
 199         j = (MAX_KEY_TABLE-1);
 200         for (i = 0; i < (MAX_KEY_TABLE - 1); i++) {
 201                 if (!pTable->KeyTable[i].bInUse && (j == (MAX_KEY_TABLE-1))) {
 202                         // found empty table
 203                         j = i;
 204                 }
 205                 if (pTable->KeyTable[i].bInUse &&
 206                     ether_addr_equal(pTable->KeyTable[i].abyBSSID, pbyBSSID)) {
 207                         // found table already exist
 208                         if ((dwKeyIndex & PAIRWISE_KEY) != 0) {
 209                                 // Pairwise key
 210                                 pKey = &(pTable->KeyTable[i].PairwiseKey);
 211                                 pTable->KeyTable[i].wKeyCtl &= 0xFFF0;          // clear pairwise key control filed
 212                                 pTable->KeyTable[i].wKeyCtl |= byKeyDecMode;
 213                                 uKeyIdx = 4;                                    // use HW key entry 4 for pairwise key
 214                         } else {
 215                                 // Group key
 216                                 if ((dwKeyIndex & 0x000000FF) >= MAX_GROUP_KEY)
 217                                         return false;
 218                                 pKey = &(pTable->KeyTable[i].GroupKey[dwKeyIndex & 0x000000FF]);
 219                                 if ((dwKeyIndex & TRANSMIT_KEY) != 0)  {
 220                                         // Group transmit key
 221                                         pTable->KeyTable[i].dwGTKeyIndex = dwKeyIndex;
 222                                         pr_debug("Group transmit key(R)[%lX]: %d\n",
 223                                                  pTable->KeyTable[i].dwGTKeyIndex, i);
 224                                 }
 225                                 pTable->KeyTable[i].wKeyCtl &= 0xFF0F;          // clear group key control filed
 226                                 pTable->KeyTable[i].wKeyCtl |= (byKeyDecMode << 4);
 227                                 pTable->KeyTable[i].wKeyCtl |= 0x0040;          // use group key for group address
 228                                 uKeyIdx = (dwKeyIndex & 0x000000FF);
 229                         }
 230                         pTable->KeyTable[i].wKeyCtl |= 0x8000;              // enable on-fly
 231
 232                         pKey->bKeyValid = true;
 233                         pKey->uKeyLength = uKeyLength;
 234                         pKey->dwKeyIndex = dwKeyIndex;
 235                         pKey->byCipherSuite = byKeyDecMode;
 236                         memcpy(pKey->abyKey, pbyKey, uKeyLength);
 237                         if (byKeyDecMode == KEY_CTL_WEP) {
 238                                 if (uKeyLength == WLAN_WEP40_KEYLEN)
 239                                         pKey->abyKey[15] &= 0x7F;
 240                                 if (uKeyLength == WLAN_WEP104_KEYLEN)
 241                                         pKey->abyKey[15] |= 0x80;
 242                         }
 243                         MACvSetKeyEntry(dwIoBase, pTable->KeyTable[i].wKeyCtl, i, uKeyIdx, pbyBSSID, (u32 *)pKey->abyKey, byLocalID);
 244
 245                         if ((dwKeyIndex & USE_KEYRSC) == 0) {
 246                                 // RSC set by NIC
 247                                 pKey->KeyRSC = 0;
 248                         } else {
 249                                 pKey->KeyRSC = *pKeyRSC;
 250                         }
 251                         pKey->dwTSC47_16 = 0;
 252                         pKey->wTSC15_0 = 0;
 253
 254                         pr_debug("KeybSetKey(R):\n");
 255                         pr_debug("pKey->bKeyValid: %d\n ", pKey->bKeyValid);
 256                         pr_debug("pKey->abyKey: ");
 257                         for (ii = 0; ii < pKey->uKeyLength; ii++)
 258                                 pr_debug("%02x ", pKey->abyKey[ii]);
 259
 260                         pr_debug("\n");
 261
 262                         pr_debug("pKey->dwTSC47_16: %lx\n ", pKey->dwTSC47_16);
 263                         pr_debug("pKey->wTSC15_0: %x\n ", pKey->wTSC15_0);
 264                         pr_debug("pKey->dwKeyIndex: %lx\n ", pKey->dwKeyIndex);
 265
 266                         return true;
 267                 }
 268         }
 269         if (j < (MAX_KEY_TABLE-1)) {
 270                 memcpy(pTable->KeyTable[j].abyBSSID, pbyBSSID, ETH_ALEN);
 271                 pTable->KeyTable[j].bInUse = true;
 272                 if ((dwKeyIndex & PAIRWISE_KEY) != 0)  {
 273                         // Pairwise key
 274                         pKey = &(pTable->KeyTable[j].PairwiseKey);
 275                         pTable->KeyTable[j].wKeyCtl &= 0xFFF0;          // clear pairwise key control filed
 276                         pTable->KeyTable[j].wKeyCtl |= byKeyDecMode;
 277                         uKeyIdx = 4;                                    // use HW key entry 4 for pairwise key
 278                 } else {
 279                         // Group key
 280                         if ((dwKeyIndex & 0x000000FF) >= MAX_GROUP_KEY)
 281                                 return false;
 282                         pKey = &(pTable->KeyTable[j].GroupKey[dwKeyIndex & 0x000000FF]);
 283                         if ((dwKeyIndex & TRANSMIT_KEY) != 0)  {
 284                                 // Group transmit key
 285                                 pTable->KeyTable[j].dwGTKeyIndex = dwKeyIndex;
 286                                 pr_debug("Group transmit key(N)[%lX]: %d\n",
 287                                          pTable->KeyTable[j].dwGTKeyIndex, j);
 288                         }
 289                         pTable->KeyTable[j].wKeyCtl &= 0xFF0F;          // clear group key control filed
 290                         pTable->KeyTable[j].wKeyCtl |= (byKeyDecMode << 4);
 291                         pTable->KeyTable[j].wKeyCtl |= 0x0040;          // use group key for group address
 292                         uKeyIdx = (dwKeyIndex & 0x000000FF);
 293                 }
 294                 pTable->KeyTable[j].wKeyCtl |= 0x8000;              // enable on-fly
 295
 296                 pKey->bKeyValid = true;
 297                 pKey->uKeyLength = uKeyLength;
 298                 pKey->dwKeyIndex = dwKeyIndex;
 299                 pKey->byCipherSuite = byKeyDecMode;
 300                 memcpy(pKey->abyKey, pbyKey, uKeyLength);
 301                 if (byKeyDecMode == KEY_CTL_WEP) {
 302                         if (uKeyLength == WLAN_WEP40_KEYLEN)
 303                                 pKey->abyKey[15] &= 0x7F;
 304                         if (uKeyLength == WLAN_WEP104_KEYLEN)
 305                                 pKey->abyKey[15] |= 0x80;
 306                 }
 307                 MACvSetKeyEntry(dwIoBase, pTable->KeyTable[j].wKeyCtl, j, uKeyIdx, pbyBSSID, (u32 *)pKey->abyKey, byLocalID);
 308
 309                 if ((dwKeyIndex & USE_KEYRSC) == 0) {
 310                         // RSC set by NIC
 311                         pKey->KeyRSC = 0;
 312                 } else {
 313                         pKey->KeyRSC = *pKeyRSC;
 314                 }
 315                 pKey->dwTSC47_16 = 0;
 316                 pKey->wTSC15_0 = 0;
 317
 318                 pr_debug("KeybSetKey(N):\n");
 319                 pr_debug("pKey->bKeyValid: %d\n ", pKey->bKeyValid);
 320                 pr_debug("pKey->uKeyLength: %d\n ", (int)pKey->uKeyLength);
 321                 pr_debug("pKey->abyKey: ");
 322                 for (ii = 0; ii < pKey->uKeyLength; ii++)
 323                         pr_debug("%02x ", pKey->abyKey[ii]);
 324
 325                 pr_debug("\n");
 326
 327                 pr_debug("pKey->dwTSC47_16: %lx\n ", pKey->dwTSC47_16);
 328                 pr_debug("pKey->wTSC15_0: %x\n ", pKey->wTSC15_0);
 329                 pr_debug("pKey->dwKeyIndex: %lx\n ", pKey->dwKeyIndex);
 330
 331                 return true;
 332         }
 333         return false;
 334 }
 335
 336 /*
 337  * Description: Remove Key from table
 338  *
 339  * Parameters:
 340  *  In:
 341  *      pTable          - Pointer to Key table
 342  *      pbyBSSID        - BSSID of Key
 343  *      dwKeyIndex      - Key Index (reference to NDIS DDK)
 344  *  Out:
 345  *      none
 346  *
 347  * Return Value: true if success otherwise false
 348  *
 349  */
 350 bool KeybRemoveKey(
 351         PSKeyManagement pTable,
 352         unsigned char *pbyBSSID,
 353         unsigned long dwKeyIndex,
 354         void __iomem *dwIoBase
 355 )
 356 {
 357         int  i;
 358
 359         if (is_broadcast_ether_addr(pbyBSSID)) {
 360                 // delete all keys
 361                 if ((dwKeyIndex & PAIRWISE_KEY) != 0) {
 362                         for (i = 0; i < MAX_KEY_TABLE; i++)
 363                                 pTable->KeyTable[i].PairwiseKey.bKeyValid = false;
 364
 365                         s_vCheckKeyTableValid(pTable, dwIoBase);
 366                         return true;
 367                 } else if ((dwKeyIndex & 0x000000FF) < MAX_GROUP_KEY) {
 368                         for (i = 0; i < MAX_KEY_TABLE; i++) {
 369                                 pTable->KeyTable[i].GroupKey[dwKeyIndex & 0x000000FF].bKeyValid = false;
 370                                 if ((dwKeyIndex & 0x7FFFFFFF) == (pTable->KeyTable[i].dwGTKeyIndex & 0x7FFFFFFF)) {
 371                                         // remove Group transmit key
 372                                         pTable->KeyTable[i].dwGTKeyIndex = 0;
 373                                 }
 374                         }
 375                         s_vCheckKeyTableValid(pTable, dwIoBase);
 376                         return true;
 377                 } else {
 378                         return false;
 379                 }
 380         }
 381
 382         for (i = 0; i < MAX_KEY_TABLE; i++) {
 383                 if (pTable->KeyTable[i].bInUse &&
 384                     ether_addr_equal(pTable->KeyTable[i].abyBSSID, pbyBSSID)) {
 385                         if ((dwKeyIndex & PAIRWISE_KEY) != 0) {
 386                                 pTable->KeyTable[i].PairwiseKey.bKeyValid = false;
 387                                 s_vCheckKeyTableValid(pTable, dwIoBase);
 388                                 return true;
 389                         } else if ((dwKeyIndex & 0x000000FF) < MAX_GROUP_KEY) {
 390                                 pTable->KeyTable[i].GroupKey[dwKeyIndex & 0x000000FF].bKeyValid = false;
 391                                 if ((dwKeyIndex & 0x7FFFFFFF) == (pTable->KeyTable[i].dwGTKeyIndex & 0x7FFFFFFF)) {
 392                                         // remove Group transmit key
 393                                         pTable->KeyTable[i].dwGTKeyIndex = 0;
 394                                 }
 395                                 s_vCheckKeyTableValid(pTable, dwIoBase);
 396                                 return true;
 397                         } else {
 398                                 return false;
 399                         }
 400                 }
 401         }
 402         return false;
 403 }
 404
 405 /*
 406  * Description: Remove Key from table
 407  *
 408  * Parameters:
 409  *  In:
 410  *      pTable          - Pointer to Key table
 411  *      pbyBSSID        - BSSID of Key
 412  *  Out:
 413  *      none
 414  *
 415  * Return Value: true if success otherwise false
 416  *
 417  */
 418 bool KeybRemoveAllKey(
 419         PSKeyManagement pTable,
 420         unsigned char *pbyBSSID,
 421         void __iomem *dwIoBase
 422 )
 423 {
 424         int i, u;
 425
 426         for (i = 0; i < MAX_KEY_TABLE; i++) {
 427                 if (pTable->KeyTable[i].bInUse &&
 428                     ether_addr_equal(pTable->KeyTable[i].abyBSSID, pbyBSSID)) {
 429                         pTable->KeyTable[i].PairwiseKey.bKeyValid = false;
 430                         for (u = 0; u < MAX_GROUP_KEY; u++)
 431                                 pTable->KeyTable[i].GroupKey[u].bKeyValid = false;
 432
 433                         pTable->KeyTable[i].dwGTKeyIndex = 0;
 434                         s_vCheckKeyTableValid(pTable, dwIoBase);
 435                         return true;
 436                 }
 437         }
 438         return false;
 439 }
 440
 441 /*
 442  * Description: Remove WEP Key from table
 443  *
 444  * Parameters:
 445  *  In:
 446  *      pTable          - Pointer to Key table
 447  *  Out:
 448  *      none
 449  *
 450  * Return Value: true if success otherwise false
 451  *
 452  */
 453 void KeyvRemoveWEPKey(
 454         PSKeyManagement pTable,
 455         unsigned long dwKeyIndex,
 456         void __iomem *dwIoBase
 457 )
 458 {
 459         if ((dwKeyIndex & 0x000000FF) < MAX_GROUP_KEY) {
 460                 if (pTable->KeyTable[MAX_KEY_TABLE-1].bInUse) {
 461                         if (pTable->KeyTable[MAX_KEY_TABLE-1].GroupKey[dwKeyIndex & 0x000000FF].byCipherSuite == KEY_CTL_WEP) {
 462                                 pTable->KeyTable[MAX_KEY_TABLE-1].GroupKey[dwKeyIndex & 0x000000FF].bKeyValid = false;
 463                                 if ((dwKeyIndex & 0x7FFFFFFF) == (pTable->KeyTable[MAX_KEY_TABLE-1].dwGTKeyIndex & 0x7FFFFFFF)) {
 464                                         // remove Group transmit key
 465                                         pTable->KeyTable[MAX_KEY_TABLE-1].dwGTKeyIndex = 0;
 466                                 }
 467                         }
 468                 }
 469                 s_vCheckKeyTableValid(pTable, dwIoBase);
 470         }
 471 }
 472
 473 void KeyvRemoveAllWEPKey(
 474         PSKeyManagement pTable,
 475         void __iomem *dwIoBase
 476 )
 477 {
 478         int i;
 479
 480         for (i = 0; i < MAX_GROUP_KEY; i++)
 481                 KeyvRemoveWEPKey(pTable, i, dwIoBase);
 482 }
 483
 484 /*
 485  * Description: Get Transmit Key from table
 486  *
 487  * Parameters:
 488  *  In:
 489  *      pTable          - Pointer to Key table
 490  *      pbyBSSID        - BSSID of Key
 491  *  Out:
 492  *      pKey            - Key return
 493  *
 494  * Return Value: true if found otherwise false
 495  *
 496  */
 497 bool KeybGetTransmitKey(
 498         PSKeyManagement pTable,
 499         unsigned char *pbyBSSID,
 500         unsigned long dwKeyType,
 501         PSKeyItem       *pKey
 502 )
 503 {
 504         int i, ii;
 505
 506         *pKey = NULL;
 507         for (i = 0; i < MAX_KEY_TABLE; i++) {
 508                 if (pTable->KeyTable[i].bInUse &&
 509                     ether_addr_equal(pTable->KeyTable[i].abyBSSID, pbyBSSID)) {
 510                         if (dwKeyType == PAIRWISE_KEY) {
 511                                 if (pTable->KeyTable[i].PairwiseKey.bKeyValid) {
 512                                         *pKey = &(pTable->KeyTable[i].PairwiseKey);
 513
 514                                         pr_debug("KeybGetTransmitKey:");
 515                                         pr_debug("PAIRWISE_KEY: KeyTable.abyBSSID: ");
 516                                         for (ii = 0; ii < 6; ii++)
 517                                                 pr_debug("%x ",
 518                                                          pTable->KeyTable[i].abyBSSID[ii]);
 519
 520                                         pr_debug("\n");
 521
 522                                         return true;
 523                                 } else {
 524                                         pr_debug("PairwiseKey.bKeyValid == false\n");
 525                                         return false;
 526                                 }
 527                         } // End of Type == PAIRWISE
 528                         else {
 529                                 if (pTable->KeyTable[i].dwGTKeyIndex == 0) {
 530                                         pr_debug("ERROR: dwGTKeyIndex == 0 !!!\n");
 531                                         return false;
 532                                 }
 533                                 if (pTable->KeyTable[i].GroupKey[(pTable->KeyTable[i].dwGTKeyIndex&0x000000FF)].bKeyValid) {
 534                                         *pKey = &(pTable->KeyTable[i].GroupKey[(pTable->KeyTable[i].dwGTKeyIndex&0x000000FF)]);
 535
 536                                         pr_debug("KeybGetTransmitKey:");
 537                                         pr_debug("GROUP_KEY: KeyTable.abyBSSID\n");
 538                                         for (ii = 0; ii < 6; ii++)
 539                                                 pr_debug("%x ",
 540                                                          pTable->KeyTable[i].abyBSSID[ii]);
 541
 542                                         pr_debug("\n");
 543                                         pr_debug("dwGTKeyIndex: %lX\n",
 544                                                  pTable->KeyTable[i].dwGTKeyIndex);
 545
 546                                         return true;
 547                                 } else {
 548                                         pr_debug("GroupKey.bKeyValid == false\n");
 549                                         return false;
 550                                 }
 551                         } // End of Type = GROUP
 552                 } // BSSID match
 553         }
 554         pr_debug("ERROR: NO Match BSSID !!! ");
 555         for (ii = 0; ii < 6; ii++)
 556                 pr_debug("%02x ", *(pbyBSSID+ii));
 557
 558         pr_debug("\n");
 559         return false;
 560 }
 561
 562 /*
 563  * Description: Check Pairewise Key
 564  *
 565  * Parameters:
 566  *  In:
 567  *      pTable          - Pointer to Key table
 568  *  Out:
 569  *      none
 570  *
 571  * Return Value: true if found otherwise false
 572  *
 573  */
 574 bool KeybCheckPairewiseKey(
 575         PSKeyManagement pTable,
 576         PSKeyItem       *pKey
 577 )
 578 {
 579         int i;
 580
 581         *pKey = NULL;
 582         for (i = 0; i < MAX_KEY_TABLE; i++) {
 583                 if (pTable->KeyTable[i].bInUse &&
 584                     pTable->KeyTable[i].PairwiseKey.bKeyValid) {
 585                         *pKey = &(pTable->KeyTable[i].PairwiseKey);
 586                         return true;
 587                 }
 588         }
 589         return false;
 590 }
 591
 592 /*
 593  * Description: Set Key to table
 594  *
 595  * Parameters:
 596  *  In:
 597  *      pTable          - Pointer to Key table
 598  *      dwKeyIndex      - Key index (reference to NDIS DDK)
 599  *      uKeyLength      - Key length
 600  *      KeyRSC          - Key RSC
 601  *      pbyKey          - Pointer to key
 602  *  Out:
 603  *      none
 604  *
 605  * Return Value: true if success otherwise false
 606  *
 607  */
 608 bool KeybSetDefaultKey(
 609         PSKeyManagement pTable,
 610         unsigned long dwKeyIndex,
 611         unsigned long uKeyLength,
 612         u64 *pKeyRSC,
 613         unsigned char *pbyKey,
 614         unsigned char byKeyDecMode,
 615         void __iomem *dwIoBase,
 616         unsigned char byLocalID
 617 )
 618 {
 619         unsigned int ii;
 620         PSKeyItem   pKey;
 621         unsigned int uKeyIdx;
 622
 623         pr_debug("Enter KeybSetDefaultKey: %1x, %d\n",
 624                  (int)dwKeyIndex, (int)uKeyLength);
 625
 626         if ((dwKeyIndex & PAIRWISE_KEY) != 0) // Pairwise key
 627                 return false;
 628         else if ((dwKeyIndex & 0x000000FF) >= MAX_GROUP_KEY)
 629                 return false;
 630
 631         if (uKeyLength > MAX_KEY_LEN)
 632                 return false;
 633
 634         pTable->KeyTable[MAX_KEY_TABLE - 1].bInUse = true;
 635         for (ii = 0; ii < ETH_ALEN; ii++)
 636                 pTable->KeyTable[MAX_KEY_TABLE - 1].abyBSSID[ii] = 0xFF;
 637
 638         // Group key
 639         pKey = &(pTable->KeyTable[MAX_KEY_TABLE - 1].GroupKey[dwKeyIndex & 0x000000FF]);
 640         if ((dwKeyIndex & TRANSMIT_KEY) != 0)  {
 641                 // Group transmit key
 642                 pTable->KeyTable[MAX_KEY_TABLE-1].dwGTKeyIndex = dwKeyIndex;
 643                 pr_debug("Group transmit key(R)[%lX]: %d\n",
 644                          pTable->KeyTable[MAX_KEY_TABLE-1].dwGTKeyIndex,
 645                          MAX_KEY_TABLE-1);
 646
 647         }
 648         pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl &= 0x7F00;          // clear all key control filed
 649         pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= (byKeyDecMode << 4);
 650         pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= (byKeyDecMode);
 651         pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= 0x0044;          // use group key for all address
 652         uKeyIdx = (dwKeyIndex & 0x000000FF);
 653
 654         if ((uKeyLength == WLAN_WEP232_KEYLEN) &&
 655             (byKeyDecMode == KEY_CTL_WEP)) {
 656                 pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= 0x4000;              // disable on-fly disable address match
 657                 pTable->KeyTable[MAX_KEY_TABLE-1].bSoftWEP = true;
 658         } else {
 659                 if (!pTable->KeyTable[MAX_KEY_TABLE-1].bSoftWEP)
 660                         pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl |= 0xC000;          // enable on-fly disable address match
 661         }
 662
 663         pKey->bKeyValid = true;
 664         pKey->uKeyLength = uKeyLength;
 665         pKey->dwKeyIndex = dwKeyIndex;
 666         pKey->byCipherSuite = byKeyDecMode;
 667         memcpy(pKey->abyKey, pbyKey, uKeyLength);
 668         if (byKeyDecMode == KEY_CTL_WEP) {
 669                 if (uKeyLength == WLAN_WEP40_KEYLEN)
 670                         pKey->abyKey[15] &= 0x7F;
 671                 if (uKeyLength == WLAN_WEP104_KEYLEN)
 672                         pKey->abyKey[15] |= 0x80;
 673         }
 674         MACvSetKeyEntry(dwIoBase, pTable->KeyTable[MAX_KEY_TABLE-1].wKeyCtl, MAX_KEY_TABLE-1, uKeyIdx, pTable->KeyTable[MAX_KEY_TABLE-1].abyBSSID, (u32 *)pKey->abyKey, byLocalID);
 675
 676         if ((dwKeyIndex & USE_KEYRSC) == 0) {
 677                 // RSC set by NIC
 678                 pKey->KeyRSC = 0;
 679         } else {
 680                 pKey->KeyRSC = *pKeyRSC;
 681         }
 682         pKey->dwTSC47_16 = 0;
 683         pKey->wTSC15_0 = 0;
 684
 685         pr_debug("KeybSetKey(R):\n");
 686         pr_debug("pKey->bKeyValid: %d\n", pKey->bKeyValid);
 687         pr_debug("pKey->uKeyLength: %d\n", (int)pKey->uKeyLength);
 688         pr_debug("pKey->abyKey:\n");
 689         for (ii = 0; ii < pKey->uKeyLength; ii++)
 690                 pr_debug("%x", pKey->abyKey[ii]);
 691
 692         pr_debug("\n");
 693
 694         pr_debug("pKey->dwTSC47_16: %lx\n", pKey->dwTSC47_16);
 695         pr_debug("pKey->wTSC15_0: %x\n", pKey->wTSC15_0);
 696         pr_debug("pKey->dwKeyIndex: %lx\n", pKey->dwKeyIndex);
 697
 698         return true;
 699 }
 700
 701 /*
 702  * Description: Set Key to table
 703  *
 704  * Parameters:
 705  *  In:
 706  *      pTable          - Pointer to Key table
 707  *      dwKeyIndex      - Key index (reference to NDIS DDK)
 708  *      uKeyLength      - Key length
 709  *      KeyRSC          - Key RSC
 710  *      pbyKey          - Pointer to key
 711  *  Out:
 712  *      none
 713  *
 714  * Return Value: true if success otherwise false
 715  *
 716  */
 717 bool KeybSetAllGroupKey(
 718         PSKeyManagement pTable,
 719         unsigned long dwKeyIndex,
 720         unsigned long uKeyLength,
 721         u64 *pKeyRSC,
 722         unsigned char *pbyKey,
 723         unsigned char byKeyDecMode,
 724         void __iomem *dwIoBase,
 725         unsigned char byLocalID
 726 )
 727 {
 728         int         i;
 729         unsigned int ii;
 730         PSKeyItem   pKey;
 731         unsigned int uKeyIdx;
 732
 733         pr_debug("Enter KeybSetAllGroupKey: %lX\n", dwKeyIndex);
 734
 735         if ((dwKeyIndex & PAIRWISE_KEY) != 0) // Pairwise key
 736                 return false;
 737         else if ((dwKeyIndex & 0x000000FF) >= MAX_GROUP_KEY)
 738                 return false;
 739
 740         for (i = 0; i < MAX_KEY_TABLE - 1; i++) {
 741                 if (pTable->KeyTable[i].bInUse) {
 742                         // found table already exist
 743                         // Group key
 744                         pKey = &(pTable->KeyTable[i].GroupKey[dwKeyIndex & 0x000000FF]);
 745                         if ((dwKeyIndex & TRANSMIT_KEY) != 0)  {
 746                                 // Group transmit key
 747                                 pTable->KeyTable[i].dwGTKeyIndex = dwKeyIndex;
 748                                 pr_debug("Group transmit key(R)[%lX]: %d\n",
 749                                          pTable->KeyTable[i].dwGTKeyIndex, i);
 750
 751                         }
 752                         pTable->KeyTable[i].wKeyCtl &= 0xFF0F;          // clear group key control filed
 753                         pTable->KeyTable[i].wKeyCtl |= (byKeyDecMode << 4);
 754                         pTable->KeyTable[i].wKeyCtl |= 0x0040;          // use group key for group address
 755                         uKeyIdx = (dwKeyIndex & 0x000000FF);
 756
 757                         pTable->KeyTable[i].wKeyCtl |= 0x8000;              // enable on-fly
 758
 759                         pKey->bKeyValid = true;
 760                         pKey->uKeyLength = uKeyLength;
 761                         pKey->dwKeyIndex = dwKeyIndex;
 762                         pKey->byCipherSuite = byKeyDecMode;
 763                         memcpy(pKey->abyKey, pbyKey, uKeyLength);
 764                         if (byKeyDecMode == KEY_CTL_WEP) {
 765                                 if (uKeyLength == WLAN_WEP40_KEYLEN)
 766                                         pKey->abyKey[15] &= 0x7F;
 767                                 if (uKeyLength == WLAN_WEP104_KEYLEN)
 768                                         pKey->abyKey[15] |= 0x80;
 769                         }
 770                         MACvSetKeyEntry(dwIoBase, pTable->KeyTable[i].wKeyCtl, i, uKeyIdx, pTable->KeyTable[i].abyBSSID, (u32 *)pKey->abyKey, byLocalID);
 771
 772                         if ((dwKeyIndex & USE_KEYRSC) == 0) {
 773                                 // RSC set by NIC
 774                                 pKey->KeyRSC = 0;
 775                         } else {
 776                                 pKey->KeyRSC = *pKeyRSC;
 777                         }
 778                         pKey->dwTSC47_16 = 0;
 779                         pKey->wTSC15_0 = 0;
 780
 781                         pr_debug("KeybSetKey(R):\n");
 782                         pr_debug("pKey->bKeyValid: %d\n ", pKey->bKeyValid);
 783                         pr_debug("pKey->uKeyLength: %d\n ",
 784                                  (int)pKey->uKeyLength);
 785                         pr_debug("pKey->abyKey: ");
 786                         for (ii = 0; ii < pKey->uKeyLength; ii++)
 787                                 pr_debug("%02x ", pKey->abyKey[ii]);
 788
 789                         pr_debug("\n");
 790
 791                 } // (pTable->KeyTable[i].bInUse == true)
 792         }
 793         return true;
 794 }