drivers/staging/vt6655/hostap.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  * File: hostap.c
  20  *
  21  * Purpose: handle hostap deamon ioctl input/out functions
  22  *
  23  * Author: Lyndon Chen
  24  *
  25  * Date: Oct. 20, 2003
  26  *
  27  * Functions:
  28  *
  29  * Revision History:
  30  *
  31  */
  32
  33 #include "hostap.h"
  34 #include "iocmd.h"
  35 #include "mac.h"
  36 #include "card.h"
  37 #include "baseband.h"
  38 #include "wpactl.h"
  39 #include "key.h"
  40
  41 #define VIAWGET_HOSTAPD_MAX_BUF_SIZE 1024
  42 #define HOSTAP_CRYPT_FLAG_SET_TX_KEY BIT0
  43 #define HOSTAP_CRYPT_ERR_UNKNOWN_ADDR 3
  44 #define HOSTAP_CRYPT_ERR_KEY_SET_FAILED 5
  45
  46 /*---------------------  Static Definitions -------------------------*/
  47
  48 /*---------------------  Static Classes  ----------------------------*/
  49
  50 /*---------------------  Static Variables  --------------------------*/
  51 //static int          msglevel                =MSG_LEVEL_DEBUG;
  52 static int msglevel = MSG_LEVEL_INFO;
  53
  54 /*---------------------  Static Functions  --------------------------*/
  55
  56 /*---------------------  Export Variables  --------------------------*/
  57
  58 /*
  59  * Description:
  60  *      register net_device (AP) for hostap deamon
  61  *
  62  * Parameters:
  63  *  In:
  64  *      pDevice             -
  65  *      rtnl_locked         -
  66  *  Out:
  67  *
  68  * Return Value:
  69  *
  70  */
  71
  72 static int hostap_enable_hostapd(PSDevice pDevice, int rtnl_locked)
  73 {
  74         PSDevice apdev_priv;
  75         struct net_device *dev = pDevice->dev;
  76         int ret;
  77         const struct net_device_ops apdev_netdev_ops = {
  78                 .ndo_start_xmit         = pDevice->tx_80211,
  79         };
  80
  81         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%s: Enabling hostapd mode\n", dev->name);
  82
  83         pDevice->apdev = alloc_etherdev(sizeof(*apdev_priv));
  84         if (pDevice->apdev == NULL)
  85                 return -ENOMEM;
  86
  87         apdev_priv = netdev_priv(pDevice->apdev);
  88         *apdev_priv = *pDevice;
  89         eth_hw_addr_inherit(pDevice->apdev, dev);
  90
  91         pDevice->apdev->netdev_ops = &apdev_netdev_ops;
  92
  93         pDevice->apdev->type = ARPHRD_IEEE80211;
  94
  95         pDevice->apdev->base_addr = dev->base_addr;
  96         pDevice->apdev->irq = dev->irq;
  97         pDevice->apdev->mem_start = dev->mem_start;
  98         pDevice->apdev->mem_end = dev->mem_end;
  99         sprintf(pDevice->apdev->name, "%sap", dev->name);
 100         if (rtnl_locked)
 101                 ret = register_netdevice(pDevice->apdev);
 102         else
 103                 ret = register_netdev(pDevice->apdev);
 104         if (ret) {
 105                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%s: register_netdevice(AP) failed!\n",
 106                         dev->name);
 107                 free_netdev(pDevice->apdev);
 108                 pDevice->apdev = NULL;
 109                 return -1;
 110         }
 111
 112         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%s: Registered netdevice %s for AP management\n",
 113                 dev->name, pDevice->apdev->name);
 114
 115         KeyvInitTable(&pDevice->sKey, pDevice->PortOffset);
 116
 117         return 0;
 118 }
 119
 120 /*
 121  * Description:
 122  *      unregister net_device(AP)
 123  *
 124  * Parameters:
 125  *  In:
 126  *      pDevice             -
 127  *      rtnl_locked         -
 128  *  Out:
 129  *
 130  * Return Value:
 131  *
 132  */
 133
 134 static int hostap_disable_hostapd(PSDevice pDevice, int rtnl_locked)
 135 {
 136         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%s: disabling hostapd mode\n", pDevice->dev->name);
 137
 138         if (pDevice->apdev && pDevice->apdev->name && pDevice->apdev->name[0]) {
 139                 if (rtnl_locked)
 140                         unregister_netdevice(pDevice->apdev);
 141                 else
 142                         unregister_netdev(pDevice->apdev);
 143                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "%s: Netdevice %s unregistered\n",
 144                         pDevice->dev->name, pDevice->apdev->name);
 145         }
 146         if (pDevice->apdev)
 147                 free_netdev(pDevice->apdev);
 148         pDevice->apdev = NULL;
 149         pDevice->bEnable8021x = false;
 150         pDevice->bEnableHostWEP = false;
 151         pDevice->bEncryptionEnable = false;
 152
 153 //4.2007-0118-03,<Add> by EinsnLiu
 154 //execute some clear work
 155         pDevice->pMgmt->byCSSPK = KEY_CTL_NONE;
 156         pDevice->pMgmt->byCSSGK = KEY_CTL_NONE;
 157         KeyvInitTable(&pDevice->sKey, pDevice->PortOffset);
 158
 159         return 0;
 160 }
 161
 162 /*
 163  * Description:
 164  *      Set enable/disable hostapd mode
 165  *
 166  * Parameters:
 167  *  In:
 168  *      pDevice             -
 169  *      rtnl_locked         -
 170  *  Out:
 171  *
 172  * Return Value:
 173  *
 174  */
 175
 176 int vt6655_hostap_set_hostapd(PSDevice pDevice, int val, int rtnl_locked)
 177 {
 178         if (val < 0 || val > 1)
 179                 return -EINVAL;
 180
 181         if (pDevice->bEnableHostapd == val)
 182                 return 0;
 183
 184         pDevice->bEnableHostapd = val;
 185
 186         if (val)
 187                 return hostap_enable_hostapd(pDevice, rtnl_locked);
 188         else
 189                 return hostap_disable_hostapd(pDevice, rtnl_locked);
 190 }
 191
 192 /*
 193  * Description:
 194  *      remove station function supported for hostap deamon
 195  *
 196  * Parameters:
 197  *  In:
 198  *      pDevice   -
 199  *      param     -
 200  *  Out:
 201  *
 202  * Return Value:
 203  *
 204  */
 205 static int hostap_remove_sta(PSDevice pDevice,
 206                              struct viawget_hostapd_param *param)
 207 {
 208         unsigned int uNodeIndex;
 209
 210         if (BSSDBbIsSTAInNodeDB(pDevice->pMgmt, param->sta_addr, &uNodeIndex)) {
 211                 BSSvRemoveOneNode(pDevice, uNodeIndex);
 212         } else {
 213                 return -ENOENT;
 214         }
 215         return 0;
 216 }
 217
 218 /*
 219  * Description:
 220  *      add a station from hostap deamon
 221  *
 222  * Parameters:
 223  *  In:
 224  *      pDevice   -
 225  *      param     -
 226  *  Out:
 227  *
 228  * Return Value:
 229  *
 230  */
 231 static int hostap_add_sta(PSDevice pDevice,
 232                           struct viawget_hostapd_param *param)
 233 {
 234         PSMgmtObject    pMgmt = pDevice->pMgmt;
 235         unsigned int uNodeIndex;
 236
 237         if (!BSSDBbIsSTAInNodeDB(pMgmt, param->sta_addr, &uNodeIndex)) {
 238                 BSSvCreateOneNode((PSDevice)pDevice, &uNodeIndex);
 239         }
 240         memcpy(pMgmt->sNodeDBTable[uNodeIndex].abyMACAddr, param->sta_addr, WLAN_ADDR_LEN);
 241         pMgmt->sNodeDBTable[uNodeIndex].eNodeState = NODE_ASSOC;
 242         pMgmt->sNodeDBTable[uNodeIndex].wCapInfo = param->u.add_sta.capability;
 243 // TODO listenInterval
 244 //    pMgmt->sNodeDBTable[uNodeIndex].wListenInterval = 1;
 245         pMgmt->sNodeDBTable[uNodeIndex].bPSEnable = false;
 246         pMgmt->sNodeDBTable[uNodeIndex].bySuppRate = param->u.add_sta.tx_supp_rates;
 247
 248         // set max tx rate
 249         pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate =
 250                 pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate;
 251         // set max basic rate
 252         pMgmt->sNodeDBTable[uNodeIndex].wMaxBasicRate = RATE_2M;
 253         // Todo: check sta preamble, if ap can't support, set status code
 254         pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble =
 255                 WLAN_GET_CAP_INFO_SHORTPREAMBLE(pMgmt->sNodeDBTable[uNodeIndex].wCapInfo);
 256
 257         pMgmt->sNodeDBTable[uNodeIndex].wAID = (unsigned short)param->u.add_sta.aid;
 258
 259         pMgmt->sNodeDBTable[uNodeIndex].ulLastRxJiffer = jiffies;
 260
 261         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Add STA AID= %d \n", pMgmt->sNodeDBTable[uNodeIndex].wAID);
 262         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "MAC=%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X \n",
 263                 param->sta_addr[0],
 264                 param->sta_addr[1],
 265                 param->sta_addr[2],
 266                 param->sta_addr[3],
 267                 param->sta_addr[4],
 268                 param->sta_addr[5]
 269                 );
 270         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Max Support rate = %d \n",
 271                 pMgmt->sNodeDBTable[uNodeIndex].wMaxSuppRate);
 272
 273         return 0;
 274 }
 275
 276 /*
 277  * Description:
 278  *      get station info
 279  *
 280  * Parameters:
 281  *  In:
 282  *      pDevice   -
 283  *      param     -
 284  *  Out:
 285  *
 286  * Return Value:
 287  *
 288  */
 289
 290 static int hostap_get_info_sta(PSDevice pDevice,
 291                                struct viawget_hostapd_param *param)
 292 {
 293         PSMgmtObject    pMgmt = pDevice->pMgmt;
 294         unsigned int uNodeIndex;
 295
 296         if (BSSDBbIsSTAInNodeDB(pMgmt, param->sta_addr, &uNodeIndex)) {
 297                 param->u.get_info_sta.inactive_sec =
 298                         (jiffies - pMgmt->sNodeDBTable[uNodeIndex].ulLastRxJiffer) / HZ;
 299
 300                 //param->u.get_info_sta.txexc = pMgmt->sNodeDBTable[uNodeIndex].uTxAttempts;
 301         } else {
 302                 return -ENOENT;
 303         }
 304
 305         return 0;
 306 }
 307
 308 /*
 309  * Description:
 310  *      reset txexec
 311  *
 312  * Parameters:
 313  *  In:
 314  *      pDevice   -
 315  *      param     -
 316  *  Out:
 317  *      true, false
 318  *
 319  * Return Value:
 320  *
 321  */
 322 /*
 323   static int hostap_reset_txexc_sta(PSDevice pDevice,
 324   struct viawget_hostapd_param *param)
 325   {
 326   PSMgmtObject    pMgmt = pDevice->pMgmt;
 327   unsigned int uNodeIndex;
 328
 329   if (BSSDBbIsSTAInNodeDB(pMgmt, param->sta_addr, &uNodeIndex)) {
 330   pMgmt->sNodeDBTable[uNodeIndex].uTxAttempts = 0;
 331   } else {
 332   return -ENOENT;
 333   }
 334
 335   return 0;
 336   }
 337 */
 338
 339 /*
 340  * Description:
 341  *      set station flag
 342  *
 343  * Parameters:
 344  *  In:
 345  *      pDevice   -
 346  *      param     -
 347  *  Out:
 348  *
 349  * Return Value:
 350  *
 351  */
 352 static int hostap_set_flags_sta(PSDevice pDevice,
 353                                 struct viawget_hostapd_param *param)
 354 {
 355         PSMgmtObject    pMgmt = pDevice->pMgmt;
 356         unsigned int uNodeIndex;
 357
 358         if (BSSDBbIsSTAInNodeDB(pMgmt, param->sta_addr, &uNodeIndex)) {
 359                 pMgmt->sNodeDBTable[uNodeIndex].dwFlags |= param->u.set_flags_sta.flags_or;
 360                 pMgmt->sNodeDBTable[uNodeIndex].dwFlags &= param->u.set_flags_sta.flags_and;
 361                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " dwFlags = %x \n",
 362                         (unsigned int)pMgmt->sNodeDBTable[uNodeIndex].dwFlags);
 363         } else {
 364                 return -ENOENT;
 365         }
 366
 367         return 0;
 368 }
 369
 370 /*
 371  * Description:
 372  *      set generic element (wpa ie)
 373  *
 374  * Parameters:
 375  *  In:
 376  *      pDevice   -
 377  *      param     -
 378  *  Out:
 379  *
 380  * Return Value:
 381  *
 382  */
 383 static int hostap_set_generic_element(PSDevice pDevice,
 384                                       struct viawget_hostapd_param *param)
 385 {
 386         PSMgmtObject    pMgmt = pDevice->pMgmt;
 387
 388         memcpy(pMgmt->abyWPAIE,
 389                param->u.generic_elem.data,
 390                param->u.generic_elem.len
 391                 );
 392
 393         pMgmt->wWPAIELen = param->u.generic_elem.len;
 394
 395         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pMgmt->wWPAIELen = %d\n", pMgmt->wWPAIELen);
 396
 397         // disable wpa
 398         if (pMgmt->wWPAIELen == 0) {
 399                 pMgmt->eAuthenMode = WMAC_AUTH_OPEN;
 400                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " No WPAIE, Disable WPA \n");
 401         } else  {
 402                 // enable wpa
 403                 if ((pMgmt->abyWPAIE[0] == WLAN_EID_RSN_WPA) ||
 404                     (pMgmt->abyWPAIE[0] == WLAN_EID_RSN)) {
 405                         pMgmt->eAuthenMode = WMAC_AUTH_WPANONE;
 406                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set WPAIE enable WPA\n");
 407                 } else
 408                         return -EINVAL;
 409         }
 410
 411         return 0;
 412 }
 413
 414 /*
 415  * Description:
 416  *      flush station nodes table.
 417  *
 418  * Parameters:
 419  *  In:
 420  *      pDevice   -
 421  *  Out:
 422  *
 423  * Return Value:
 424  *
 425  */
 426
 427 static void hostap_flush_sta(PSDevice pDevice)
 428 {
 429         // reserved node index =0 for multicast node.
 430         BSSvClearNodeDBTable(pDevice, 1);
 431         pDevice->uAssocCount = 0;
 432
 433         return;
 434 }
 435
 436 /*
 437  * Description:
 438  *      set each stations encryption key
 439  *
 440  * Parameters:
 441  *  In:
 442  *      pDevice   -
 443  *      param     -
 444  *  Out:
 445  *
 446  * Return Value:
 447  *
 448  */
 449 static int hostap_set_encryption(PSDevice pDevice,
 450                                  struct viawget_hostapd_param *param,
 451                                  int param_len)
 452 {
 453         PSMgmtObject    pMgmt = pDevice->pMgmt;
 454         unsigned long dwKeyIndex = 0;
 455         unsigned char abyKey[MAX_KEY_LEN];
 456         unsigned char abySeq[MAX_KEY_LEN];
 457         unsigned long long KeyRSC;
 458         unsigned char byKeyDecMode = KEY_CTL_WEP;
 459         int     ret = 0;
 460         int     iNodeIndex = -1;
 461         int     ii;
 462         bool bKeyTableFull = false;
 463         unsigned short wKeyCtl = 0;
 464
 465         param->u.crypt.err = 0;
 466 /*
 467   if (param_len !=
 468   (int) ((char *) param->u.crypt.key - (char *) param) +
 469   param->u.crypt.key_len)
 470   return -EINVAL;
 471 */
 472
 473         if (param->u.crypt.alg > WPA_ALG_CCMP)
 474                 return -EINVAL;
 475
 476         if ((param->u.crypt.idx > 3) || (param->u.crypt.key_len > MAX_KEY_LEN)) {
 477                 param->u.crypt.err = HOSTAP_CRYPT_ERR_KEY_SET_FAILED;
 478                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " HOSTAP_CRYPT_ERR_KEY_SET_FAILED\n");
 479                 return -EINVAL;
 480         }
 481
 482         if (is_broadcast_ether_addr(param->sta_addr)) {
 483                 if (param->u.crypt.idx >= MAX_GROUP_KEY)
 484                         return -EINVAL;
 485                 iNodeIndex = 0;
 486
 487         } else {
 488                 if (BSSDBbIsSTAInNodeDB(pMgmt, param->sta_addr, &iNodeIndex) == false) {
 489                         param->u.crypt.err = HOSTAP_CRYPT_ERR_UNKNOWN_ADDR;
 490                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " HOSTAP_CRYPT_ERR_UNKNOWN_ADDR\n");
 491                         return -EINVAL;
 492                 }
 493         }
 494         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " hostap_set_encryption: sta_index %d \n", iNodeIndex);
 495         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " hostap_set_encryption: alg %d \n", param->u.crypt.alg);
 496
 497         if (param->u.crypt.alg == WPA_ALG_NONE) {
 498                 if (pMgmt->sNodeDBTable[iNodeIndex].bOnFly) {
 499                         if (!KeybRemoveKey(&(pDevice->sKey),
 500                                           param->sta_addr,
 501                                           pMgmt->sNodeDBTable[iNodeIndex].dwKeyIndex,
 502                                           pDevice->PortOffset)) {
 503                                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "KeybRemoveKey fail \n");
 504                         }
 505                         pMgmt->sNodeDBTable[iNodeIndex].bOnFly = false;
 506                 }
 507                 pMgmt->sNodeDBTable[iNodeIndex].byKeyIndex = 0;
 508                 pMgmt->sNodeDBTable[iNodeIndex].dwKeyIndex = 0;
 509                 pMgmt->sNodeDBTable[iNodeIndex].uWepKeyLength = 0;
 510                 pMgmt->sNodeDBTable[iNodeIndex].KeyRSC = 0;
 511                 pMgmt->sNodeDBTable[iNodeIndex].dwTSC47_16 = 0;
 512                 pMgmt->sNodeDBTable[iNodeIndex].wTSC15_0 = 0;
 513                 pMgmt->sNodeDBTable[iNodeIndex].byCipherSuite = 0;
 514                 memset(&pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[0],
 515                        0,
 516                        MAX_KEY_LEN
 517 );
 518
 519                 return ret;
 520         }
 521
 522         memcpy(abyKey, param->u.crypt.key, param->u.crypt.key_len);
 523         // copy to node key tbl
 524         pMgmt->sNodeDBTable[iNodeIndex].byKeyIndex = param->u.crypt.idx;
 525         pMgmt->sNodeDBTable[iNodeIndex].uWepKeyLength = param->u.crypt.key_len;
 526         memcpy(&pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[0],
 527                param->u.crypt.key,
 528                param->u.crypt.key_len
 529 );
 530
 531         dwKeyIndex = (unsigned long)(param->u.crypt.idx);
 532         if (param->u.crypt.flags & HOSTAP_CRYPT_FLAG_SET_TX_KEY) {
 533                 pDevice->byKeyIndex = (unsigned char)dwKeyIndex;
 534                 pDevice->bTransmitKey = true;
 535                 dwKeyIndex |= (1 << 31);
 536         }
 537
 538         if (param->u.crypt.alg == WPA_ALG_WEP) {
 539                 if ((pDevice->bEnable8021x == false) || (iNodeIndex == 0)) {
 540                         KeybSetDefaultKey(&(pDevice->sKey),
 541                                           dwKeyIndex & ~(BIT30 | USE_KEYRSC),
 542                                           param->u.crypt.key_len,
 543                                           NULL,
 544                                           abyKey,
 545                                           KEY_CTL_WEP,
 546                                           pDevice->PortOffset,
 547                                           pDevice->byLocalID);
 548
 549                 } else {
 550                         // 8021x enable, individual key
 551                         dwKeyIndex |= (1 << 30); // set pairwise key
 552                         if (KeybSetKey(&(pDevice->sKey),
 553                                        &param->sta_addr[0],
 554                                        dwKeyIndex & ~(USE_KEYRSC),
 555                                        param->u.crypt.key_len,
 556                                        (PQWORD) &(KeyRSC),
 557                                        (unsigned char *)abyKey,
 558                                        KEY_CTL_WEP,
 559                                        pDevice->PortOffset,
 560                                        pDevice->byLocalID)) {
 561                                 pMgmt->sNodeDBTable[iNodeIndex].bOnFly = true;
 562
 563                         } else {
 564                                 // Key Table Full
 565                                 pMgmt->sNodeDBTable[iNodeIndex].bOnFly = false;
 566                                 bKeyTableFull = true;
 567                         }
 568                 }
 569                 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
 570                 pDevice->bEncryptionEnable = true;
 571                 pMgmt->byCSSPK = KEY_CTL_WEP;
 572                 pMgmt->byCSSGK = KEY_CTL_WEP;
 573                 pMgmt->sNodeDBTable[iNodeIndex].byCipherSuite = KEY_CTL_WEP;
 574                 pMgmt->sNodeDBTable[iNodeIndex].dwKeyIndex = dwKeyIndex;
 575                 return ret;
 576         }
 577
 578         if (param->u.crypt.seq) {
 579                 memcpy(&abySeq, param->u.crypt.seq, 8);
 580                 for (ii = 0; ii < 8; ii++)
 581                         KeyRSC |= (unsigned long)abySeq[ii] << (ii * 8);
 582
 583                 dwKeyIndex |= 1 << 29;
 584                 pMgmt->sNodeDBTable[iNodeIndex].KeyRSC = KeyRSC;
 585         }
 586
 587         if (param->u.crypt.alg == WPA_ALG_TKIP) {
 588                 if (param->u.crypt.key_len != MAX_KEY_LEN)
 589                         return -EINVAL;
 590                 pDevice->eEncryptionStatus = Ndis802_11Encryption2Enabled;
 591                 byKeyDecMode = KEY_CTL_TKIP;
 592                 pMgmt->byCSSPK = KEY_CTL_TKIP;
 593                 pMgmt->byCSSGK = KEY_CTL_TKIP;
 594         }
 595
 596         if (param->u.crypt.alg == WPA_ALG_CCMP) {
 597                 if ((param->u.crypt.key_len != AES_KEY_LEN) ||
 598                     (pDevice->byLocalID <= REV_ID_VT3253_A1))
 599                         return -EINVAL;
 600                 pDevice->eEncryptionStatus = Ndis802_11Encryption3Enabled;
 601                 byKeyDecMode = KEY_CTL_CCMP;
 602                 pMgmt->byCSSPK = KEY_CTL_CCMP;
 603                 pMgmt->byCSSGK = KEY_CTL_CCMP;
 604         }
 605
 606         if (iNodeIndex == 0) {
 607                 KeybSetDefaultKey(&(pDevice->sKey),
 608                                   dwKeyIndex,
 609                                   param->u.crypt.key_len,
 610                                   (PQWORD) &(KeyRSC),
 611                                   abyKey,
 612                                   byKeyDecMode,
 613                                   pDevice->PortOffset,
 614                                   pDevice->byLocalID);
 615                 pMgmt->sNodeDBTable[iNodeIndex].bOnFly = true;
 616
 617         } else {
 618                 dwKeyIndex |= (1 << 30); // set pairwise key
 619                 if (KeybSetKey(&(pDevice->sKey),
 620                                &param->sta_addr[0],
 621                                dwKeyIndex,
 622                                param->u.crypt.key_len,
 623                                (PQWORD) &(KeyRSC),
 624                                (unsigned char *)abyKey,
 625                                byKeyDecMode,
 626                                pDevice->PortOffset,
 627                                pDevice->byLocalID)) {
 628                         pMgmt->sNodeDBTable[iNodeIndex].bOnFly = true;
 629
 630                 } else {
 631                         // Key Table Full
 632                         pMgmt->sNodeDBTable[iNodeIndex].bOnFly = false;
 633                         bKeyTableFull = true;
 634                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Key Table Full\n");
 635                 }
 636
 637         }
 638
 639         if (bKeyTableFull) {
 640                 wKeyCtl &= 0x7F00;              // clear all key control filed
 641                 wKeyCtl |= (byKeyDecMode << 4);
 642                 wKeyCtl |= (byKeyDecMode);
 643                 wKeyCtl |= 0x0044;              // use group key for all address
 644                 wKeyCtl |= 0x4000;              // disable KeyTable[MAX_KEY_TABLE-1] on-fly to genernate rx int
 645                 MACvSetDefaultKeyCtl(pDevice->PortOffset, wKeyCtl, MAX_KEY_TABLE-1, pDevice->byLocalID);
 646         }
 647
 648         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Set key sta_index= %d \n", iNodeIndex);
 649         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " tx_index=%d len=%d \n", param->u.crypt.idx,
 650                 param->u.crypt.key_len);
 651         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " key=%x-%x-%x-%x-%x-xxxxx \n",
 652                 pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[0],
 653                 pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[1],
 654                 pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[2],
 655                 pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[3],
 656                 pMgmt->sNodeDBTable[iNodeIndex].abyWepKey[4]
 657 );
 658
 659         // set wep key
 660         pDevice->bEncryptionEnable = true;
 661         pMgmt->sNodeDBTable[iNodeIndex].byCipherSuite = byKeyDecMode;
 662         pMgmt->sNodeDBTable[iNodeIndex].dwKeyIndex = dwKeyIndex;
 663         pMgmt->sNodeDBTable[iNodeIndex].dwTSC47_16 = 0;
 664         pMgmt->sNodeDBTable[iNodeIndex].wTSC15_0 = 0;
 665
 666         return ret;
 667 }
 668
 669 /*
 670  * Description:
 671  *      get each stations encryption key
 672  *
 673  * Parameters:
 674  *  In:
 675  *      pDevice   -
 676  *      param     -
 677  *  Out:
 678  *
 679  * Return Value:
 680  *
 681  */
 682 static int hostap_get_encryption(PSDevice pDevice,
 683                                  struct viawget_hostapd_param *param,
 684                                  int param_len)
 685 {
 686         PSMgmtObject    pMgmt = pDevice->pMgmt;
 687         int     ret = 0;
 688         int     ii;
 689         int     iNodeIndex = 0;
 690
 691         param->u.crypt.err = 0;
 692
 693         if (is_broadcast_ether_addr(param->sta_addr)) {
 694                 iNodeIndex = 0;
 695         } else {
 696                 if (BSSDBbIsSTAInNodeDB(pMgmt, param->sta_addr, &iNodeIndex) == false) {
 697                         param->u.crypt.err = HOSTAP_CRYPT_ERR_UNKNOWN_ADDR;
 698                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "hostap_get_encryption: HOSTAP_CRYPT_ERR_UNKNOWN_ADDR\n");
 699                         return -EINVAL;
 700                 }
 701         }
 702         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "hostap_get_encryption: %d\n", iNodeIndex);
 703         memset(param->u.crypt.seq, 0, 8);
 704         for (ii = 0; ii < 8; ii++) {
 705                 param->u.crypt.seq[ii] = (unsigned char)pMgmt->sNodeDBTable[iNodeIndex].KeyRSC >> (ii * 8);
 706         }
 707
 708         return ret;
 709 }
 710
 711 /*
 712  * Description:
 713  *      vt6655_hostap_ioctl main function supported for hostap deamon.
 714  *
 715  * Parameters:
 716  *  In:
 717  *      pDevice   -
 718  *      iw_point  -
 719  *  Out:
 720  *
 721  * Return Value:
 722  *
 723  */
 724 int vt6655_hostap_ioctl(PSDevice pDevice, struct iw_point *p)
 725 {
 726         struct viawget_hostapd_param *param;
 727         int ret = 0;
 728         int ap_ioctl = 0;
 729
 730         if (p->length < sizeof(struct viawget_hostapd_param) ||
 731             p->length > VIAWGET_HOSTAPD_MAX_BUF_SIZE || !p->pointer)
 732                 return -EINVAL;
 733
 734         param = kmalloc((int)p->length, GFP_KERNEL);
 735         if (param == NULL)
 736                 return -ENOMEM;
 737
 738         if (copy_from_user(param, p->pointer, p->length)) {
 739                 ret = -EFAULT;
 740                 goto out;
 741         }
 742
 743         switch (param->cmd) {
 744         case VIAWGET_HOSTAPD_SET_ENCRYPTION:
 745                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_SET_ENCRYPTION \n");
 746                 spin_lock_irq(&pDevice->lock);
 747                 ret = hostap_set_encryption(pDevice, param, p->length);
 748                 spin_unlock_irq(&pDevice->lock);
 749                 break;
 750         case VIAWGET_HOSTAPD_GET_ENCRYPTION:
 751                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_GET_ENCRYPTION \n");
 752                 spin_lock_irq(&pDevice->lock);
 753                 ret = hostap_get_encryption(pDevice, param, p->length);
 754                 spin_unlock_irq(&pDevice->lock);
 755                 break;
 756         case VIAWGET_HOSTAPD_SET_ASSOC_AP_ADDR:
 757                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_SET_ASSOC_AP_ADDR \n");
 758                 ret = -EOPNOTSUPP;
 759                 goto out;
 760         case VIAWGET_HOSTAPD_FLUSH:
 761                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_FLUSH \n");
 762                 spin_lock_irq(&pDevice->lock);
 763                 hostap_flush_sta(pDevice);
 764                 spin_unlock_irq(&pDevice->lock);
 765                 break;
 766         case VIAWGET_HOSTAPD_ADD_STA:
 767                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_ADD_STA \n");
 768                 spin_lock_irq(&pDevice->lock);
 769                 ret = hostap_add_sta(pDevice, param);
 770                 spin_unlock_irq(&pDevice->lock);
 771                 break;
 772         case VIAWGET_HOSTAPD_REMOVE_STA:
 773                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_REMOVE_STA \n");
 774                 spin_lock_irq(&pDevice->lock);
 775                 ret = hostap_remove_sta(pDevice, param);
 776                 spin_unlock_irq(&pDevice->lock);
 777                 break;
 778         case VIAWGET_HOSTAPD_GET_INFO_STA:
 779                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_GET_INFO_STA \n");
 780                 ret = hostap_get_info_sta(pDevice, param);
 781                 ap_ioctl = 1;
 782                 break;
 783 /*
 784         case VIAWGET_HOSTAPD_RESET_TXEXC_STA:
 785                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_RESET_TXEXC_STA \n");
 786                 ret = hostap_reset_txexc_sta(pDevice, param);
 787                 break;
 788 */
 789         case VIAWGET_HOSTAPD_SET_FLAGS_STA:
 790                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_SET_FLAGS_STA \n");
 791                 ret = hostap_set_flags_sta(pDevice, param);
 792                 break;
 793         case VIAWGET_HOSTAPD_MLME:
 794                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_MLME \n");
 795                 ret = -EOPNOTSUPP;
 796                 goto out;
 797         case VIAWGET_HOSTAPD_SET_GENERIC_ELEMENT:
 798                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_SET_GENERIC_ELEMENT \n");
 799                 ret = hostap_set_generic_element(pDevice, param);
 800                 break;
 801         case VIAWGET_HOSTAPD_SCAN_REQ:
 802                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_SCAN_REQ \n");
 803                 ret = -EOPNOTSUPP;
 804                 goto out;
 805         case VIAWGET_HOSTAPD_STA_CLEAR_STATS:
 806                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "VIAWGET_HOSTAPD_STA_CLEAR_STATS \n");
 807                 ret = -EOPNOTSUPP;
 808                 goto out;
 809         default:
 810                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "vt6655_hostap_ioctl: unknown cmd=%d\n",
 811                         (int)param->cmd);
 812                 ret = -EOPNOTSUPP;
 813                 goto out;
 814         }
 815
 816         if ((ret == 0) && ap_ioctl) {
 817                 if (copy_to_user(p->pointer, param, p->length)) {
 818                         ret = -EFAULT;
 819                 }
 820         }
 821
 822 out:
 823         kfree(param);
 824         return ret;
 825 }