drivers/staging/vt6656/main_usb.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: main_usb.c
  20  *
  21  * Purpose: driver entry for initial, open, close, tx and rx.
  22  *
  23  * Author: Lyndon Chen
  24  *
  25  * Date: Dec 8, 2005
  26  *
  27  * Functions:
  28  *
  29  *   vntwusb_found1 - module initial (insmod) driver entry
  30  *   device_remove1 - module remove entry
  31  *   device_open - allocate dma/descripter resource & initial mac/bbp function
  32  *   device_xmit - asynchrous data tx function
  33  *   device_set_multi - set mac filter
  34  *   device_ioctl - ioctl entry
  35  *   device_close - shutdown mac/bbp & free dma/descripter resource
  36  *   device_alloc_frag_buf - rx fragement pre-allocated function
  37  *   device_free_tx_bufs - free tx buffer function
  38  *   device_dma0_tx_80211- tx 802.11 frame via dma0
  39  *   device_dma0_xmit- tx PS bufferred frame via dma0
  40  *   device_init_registers- initial MAC & BBP & RF internal registers.
  41  *   device_init_rings- initial tx/rx ring buffer
  42  *   device_init_defrag_cb- initial & allocate de-fragement buffer.
  43  *   device_tx_srv- tx interrupt service function
  44  *
  45  * Revision History:
  46  */
  47 #undef __NO_VERSION__
  48
  49 #include "device.h"
  50 #include "card.h"
  51 #include "baseband.h"
  52 #include "mac.h"
  53 #include "tether.h"
  54 #include "wmgr.h"
  55 #include "wctl.h"
  56 #include "power.h"
  57 #include "wcmd.h"
  58 #include "iocmd.h"
  59 #include "tcrc.h"
  60 #include "rxtx.h"
  61 #include "bssdb.h"
  62 #include "hostap.h"
  63 #include "wpactl.h"
  64 #include "ioctl.h"
  65 #include "iwctl.h"
  66 #include "dpc.h"
  67 #include "datarate.h"
  68 #include "rf.h"
  69 #include "firmware.h"
  70 #include "rndis.h"
  71 #include "control.h"
  72 #include "channel.h"
  73 #include "int.h"
  74 #include "iowpa.h"
  75
  76 /*---------------------  Static Definitions -------------------------*/
  77 //static int          msglevel                =MSG_LEVEL_DEBUG;
  78 static int          msglevel                =MSG_LEVEL_INFO;
  79
  80 //
  81 // Define module options
  82 //
  83
  84 // Version Information
  85 #define DRIVER_AUTHOR "VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>"
  86 MODULE_AUTHOR(DRIVER_AUTHOR);
  87 MODULE_LICENSE("GPL");
  88 MODULE_DESCRIPTION(DEVICE_FULL_DRV_NAM);
  89
  90 #define DEVICE_PARAM(N,D) \
  91         static int N[MAX_UINTS]=OPTION_DEFAULT;\
  92         module_param_array(N, int, NULL, 0);\
  93         MODULE_PARM_DESC(N, D);
  94
  95 #define RX_DESC_MIN0     16
  96 #define RX_DESC_MAX0     128
  97 #define RX_DESC_DEF0     64
  98 DEVICE_PARAM(RxDescriptors0,"Number of receive usb desc buffer");
  99
 100
 101 #define TX_DESC_MIN0     16
 102 #define TX_DESC_MAX0     128
 103 #define TX_DESC_DEF0     64
 104 DEVICE_PARAM(TxDescriptors0,"Number of transmit usb desc buffer");
 105
 106
 107 #define CHANNEL_MIN     1
 108 #define CHANNEL_MAX     14
 109 #define CHANNEL_DEF     6
 110
 111 DEVICE_PARAM(Channel, "Channel number");
 112
 113
 114 /* PreambleType[] is the preamble length used for transmit.
 115    0: indicate allows long preamble type
 116    1: indicate allows short preamble type
 117 */
 118
 119 #define PREAMBLE_TYPE_DEF     1
 120
 121 DEVICE_PARAM(PreambleType, "Preamble Type");
 122
 123
 124 #define RTS_THRESH_MIN     512
 125 #define RTS_THRESH_MAX     2347
 126 #define RTS_THRESH_DEF     2347
 127
 128 DEVICE_PARAM(RTSThreshold, "RTS threshold");
 129
 130
 131 #define FRAG_THRESH_MIN     256
 132 #define FRAG_THRESH_MAX     2346
 133 #define FRAG_THRESH_DEF     2346
 134
 135 DEVICE_PARAM(FragThreshold, "Fragmentation threshold");
 136
 137
 138 #define DATA_RATE_MIN     0
 139 #define DATA_RATE_MAX     13
 140 #define DATA_RATE_DEF     13
 141 /* datarate[] index
 142    0: indicate 1 Mbps   0x02
 143    1: indicate 2 Mbps   0x04
 144    2: indicate 5.5 Mbps 0x0B
 145    3: indicate 11 Mbps  0x16
 146    4: indicate 6 Mbps   0x0c
 147    5: indicate 9 Mbps   0x12
 148    6: indicate 12 Mbps  0x18
 149    7: indicate 18 Mbps  0x24
 150    8: indicate 24 Mbps  0x30
 151    9: indicate 36 Mbps  0x48
 152   10: indicate 48 Mbps  0x60
 153   11: indicate 54 Mbps  0x6c
 154   12: indicate 72 Mbps  0x90
 155   13: indicate auto rate
 156 */
 157
 158 DEVICE_PARAM(ConnectionRate, "Connection data rate");
 159
 160 #define OP_MODE_MAX     2
 161 #define OP_MODE_DEF     0
 162 #define OP_MODE_MIN     0
 163
 164 DEVICE_PARAM(OPMode, "Infrastruct, adhoc, AP mode ");
 165
 166 /* OpMode[] is used for transmit.
 167    0: indicate infrastruct mode used
 168    1: indicate adhoc mode used
 169    2: indicate AP mode used
 170 */
 171
 172
 173 /* PSMode[]
 174    0: indicate disable power saving mode
 175    1: indicate enable power saving mode
 176 */
 177
 178 #define PS_MODE_DEF     0
 179
 180 DEVICE_PARAM(PSMode, "Power saving mode");
 181
 182
 183 #define SHORT_RETRY_MIN     0
 184 #define SHORT_RETRY_MAX     31
 185 #define SHORT_RETRY_DEF     8
 186
 187
 188 DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits");
 189
 190 #define LONG_RETRY_MIN     0
 191 #define LONG_RETRY_MAX     15
 192 #define LONG_RETRY_DEF     4
 193
 194
 195 DEVICE_PARAM(LongRetryLimit, "long frame retry limits");
 196
 197
 198 /* BasebandType[] baseband type selected
 199    0: indicate 802.11a type
 200    1: indicate 802.11b type
 201    2: indicate 802.11g type
 202 */
 203 #define BBP_TYPE_MIN     0
 204 #define BBP_TYPE_MAX     2
 205 #define BBP_TYPE_DEF     2
 206
 207 DEVICE_PARAM(BasebandType, "baseband type");
 208
 209
 210
 211 /* 80211hEnable[]
 212    0: indicate disable 802.11h
 213    1: indicate enable 802.11h
 214 */
 215
 216 #define X80211h_MODE_DEF     0
 217
 218 DEVICE_PARAM(b80211hEnable, "802.11h mode");
 219
 220
 221 //
 222 // Static vars definitions
 223 //
 224
 225
 226
 227 static struct usb_device_id vntwusb_table[] = {
 228         {USB_DEVICE(VNT_USB_VENDOR_ID, VNT_USB_PRODUCT_ID)},
 229         {}
 230 };
 231
 232
 233
 234 // Frequency list (map channels to frequencies)
 235 /*
 236 static const long frequency_list[] = {
 237     2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484,
 238     4915, 4920, 4925, 4935, 4940, 4945, 4960, 4980,
 239     5035, 5040, 5045, 5055, 5060, 5080, 5170, 5180, 5190, 5200, 5210, 5220, 5230, 5240,
 240     5260, 5280, 5300, 5320, 5500, 5520, 5540, 5560, 5580, 5600, 5620, 5640, 5660, 5680,
 241     5700, 5745, 5765, 5785, 5805, 5825
 242         };
 243
 244
 245 #ifndef IW_ENCODE_NOKEY
 246 #define IW_ENCODE_NOKEY         0x0800
 247 #define IW_ENCODE_MODE  (IW_ENCODE_DISABLED | IW_ENCODE_RESTRICTED | IW_ENCODE_OPEN)
 248 #endif
 249
 250 static const struct iw_handler_def      iwctl_handler_def;
 251 */
 252
 253
 254
 255 /*---------------------  Static Functions  --------------------------*/
 256 static int vntwusb_found1(struct usb_interface *intf, const struct usb_device_id *id);
 257 static void vntwusb_disconnect(struct usb_interface *intf);
 258 #ifdef CONFIG_PM        /* Minimal support for suspend and resume */
 259 static int vntwusb_suspend(struct usb_interface *intf, pm_message_t message);
 260 static int vntwusb_resume(struct usb_interface *intf);
 261 #endif
 262 static struct net_device_stats *device_get_stats(struct net_device *dev);
 263 static int  device_open(struct net_device *dev);
 264 static int  device_xmit(struct sk_buff *skb, struct net_device *dev);
 265 static void device_set_multi(struct net_device *dev);
 266 static int  device_close(struct net_device *dev);
 267 static int  device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 268
 269 static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType);
 270 static BOOL device_init_defrag_cb(PSDevice pDevice);
 271 static void device_init_diversity_timer(PSDevice pDevice);
 272 static int  device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
 273
 274 static int  ethtool_ioctl(struct net_device *dev, void *useraddr);
 275 static void device_free_tx_bufs(PSDevice pDevice);
 276 static void device_free_rx_bufs(PSDevice pDevice);
 277 static void device_free_int_bufs(PSDevice pDevice);
 278 static void device_free_frag_bufs(PSDevice pDevice);
 279 static BOOL device_alloc_bufs(PSDevice pDevice);
 280
 281 static int Read_config_file(PSDevice pDevice);
 282 static UCHAR *Config_FileOperation(PSDevice pDevice);
 283 static int Config_FileGetParameter(UCHAR *string, UCHAR *dest,UCHAR *source);
 284
 285 //2008-0714<Add>by Mike Liu
 286 static BOOL device_release_WPADEV(PSDevice pDevice);
 287
 288 static void usb_device_reset(PSDevice pDevice);
 289
 290
 291
 292 /*---------------------  Export Variables  --------------------------*/
 293
 294 /*---------------------  Export Functions  --------------------------*/
 295
 296
 297 static void
 298 device_set_options(PSDevice pDevice) {
 299
 300     BYTE    abyBroadcastAddr[U_ETHER_ADDR_LEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 301     BYTE    abySNAP_RFC1042[U_ETHER_ADDR_LEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
 302     BYTE    abySNAP_Bridgetunnel[U_ETHER_ADDR_LEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
 303
 304
 305     memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, U_ETHER_ADDR_LEN);
 306     memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, U_ETHER_ADDR_LEN);
 307     memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, U_ETHER_ADDR_LEN);
 308
 309     pDevice->cbTD = TX_DESC_DEF0;
 310     pDevice->cbRD = RX_DESC_DEF0;
 311     pDevice->uChannel = CHANNEL_DEF;
 312     pDevice->wRTSThreshold = RTS_THRESH_DEF;
 313     pDevice->wFragmentationThreshold = FRAG_THRESH_DEF;
 314     pDevice->byShortRetryLimit = SHORT_RETRY_DEF;
 315     pDevice->byLongRetryLimit = LONG_RETRY_DEF;
 316     pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
 317     pDevice->byShortPreamble = PREAMBLE_TYPE_DEF;
 318     pDevice->ePSMode = PS_MODE_DEF;
 319     pDevice->b11hEnable = X80211h_MODE_DEF;
 320     pDevice->eOPMode = OP_MODE_DEF;
 321     pDevice->uConnectionRate = DATA_RATE_DEF;
 322     if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = TRUE;
 323     pDevice->byBBType = BBP_TYPE_DEF;
 324     pDevice->byPacketType = pDevice->byBBType;
 325     pDevice->byAutoFBCtrl = AUTO_FB_0;
 326     pDevice->bUpdateBBVGA = TRUE;
 327     pDevice->byFOETuning = 0;
 328     pDevice->byAutoPwrTunning = 0;
 329     pDevice->wCTSDuration = 0;
 330     pDevice->byPreambleType = 0;
 331     pDevice->bExistSWNetAddr = FALSE;
 332 //    pDevice->bDiversityRegCtlON = TRUE;
 333     pDevice->bDiversityRegCtlON = FALSE;
 334 }
 335
 336
 337 static VOID device_init_diversity_timer(PSDevice pDevice) {
 338
 339     init_timer(&pDevice->TimerSQ3Tmax1);
 340     pDevice->TimerSQ3Tmax1.data = (ULONG)pDevice;
 341     pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
 342     pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
 343
 344     init_timer(&pDevice->TimerSQ3Tmax2);
 345     pDevice->TimerSQ3Tmax2.data = (ULONG)pDevice;
 346     pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
 347     pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
 348
 349     init_timer(&pDevice->TimerSQ3Tmax3);
 350     pDevice->TimerSQ3Tmax3.data = (ULONG)pDevice;
 351     pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerSQ3Tmax3CallBack;
 352     pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
 353
 354     return;
 355 }
 356
 357
 358 //
 359 // Initialiation of MAC & BBP registers
 360 //
 361
 362 static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType)
 363 {
 364     BYTE            abyBroadcastAddr[U_ETHER_ADDR_LEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 365     BYTE            abySNAP_RFC1042[U_ETHER_ADDR_LEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
 366     BYTE            abySNAP_Bridgetunnel[U_ETHER_ADDR_LEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
 367     BYTE            byAntenna;
 368     UINT            ii;
 369     CMD_CARD_INIT   sInitCmd;
 370     NTSTATUS        ntStatus = STATUS_SUCCESS;
 371     RSP_CARD_INIT   sInitRsp;
 372     PSMgmtObject    pMgmt = &(pDevice->sMgmtObj);
 373     BYTE            byTmp;
 374     BYTE            byCalibTXIQ = 0;
 375     BYTE            byCalibTXDC = 0;
 376     BYTE            byCalibRXIQ = 0;
 377
 378     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---->INIbInitAdapter. [%d][%d]\n", InitType, pDevice->byPacketType);
 379         spin_lock_irq(&pDevice->lock);
 380     if (InitType == DEVICE_INIT_COLD) {
 381         memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, U_ETHER_ADDR_LEN);
 382         memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, U_ETHER_ADDR_LEN);
 383         memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, U_ETHER_ADDR_LEN);
 384
 385         if ( !FIRMWAREbCheckVersion(pDevice) ) {
 386             if (FIRMWAREbDownload(pDevice) == TRUE) {
 387                 if (FIRMWAREbBrach2Sram(pDevice) == FALSE) {
 388                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbBrach2Sram fail \n");
 389                         spin_unlock_irq(&pDevice->lock);
 390                     return FALSE;
 391                 }
 392             } else {
 393
 394                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbDownload fail \n");
 395                 spin_unlock_irq(&pDevice->lock);
 396                 return FALSE;
 397             }
 398         }
 399
 400         if ( !BBbVT3184Init(pDevice) ) {
 401             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" BBbVT3184Init fail \n");
 402             spin_unlock_irq(&pDevice->lock);
 403             return FALSE;
 404         }
 405     }
 406
 407     sInitCmd.byInitClass = (BYTE)InitType;
 408     sInitCmd.bExistSWNetAddr = (BYTE) pDevice->bExistSWNetAddr;
 409     for(ii=0;ii<6;ii++)
 410         sInitCmd.bySWNetAddr[ii] = pDevice->abyCurrentNetAddr[ii];
 411     sInitCmd.byShortRetryLimit = pDevice->byShortRetryLimit;
 412     sInitCmd.byLongRetryLimit = pDevice->byLongRetryLimit;
 413
 414     //issue Card_init command to device
 415     ntStatus = CONTROLnsRequestOut(pDevice,
 416                                     MESSAGE_TYPE_CARDINIT,
 417                                     0,
 418                                     0,
 419                                     sizeof(CMD_CARD_INIT),
 420                                     (PBYTE) &(sInitCmd));
 421
 422     if ( ntStatus != STATUS_SUCCESS ) {
 423         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Issue Card init fail \n");
 424         spin_unlock_irq(&pDevice->lock);
 425         return FALSE;
 426     }
 427     if (InitType == DEVICE_INIT_COLD) {
 428
 429         ntStatus = CONTROLnsRequestIn(pDevice,MESSAGE_TYPE_INIT_RSP,0,0,sizeof(RSP_CARD_INIT), (PBYTE) &(sInitRsp));
 430
 431         if (ntStatus != STATUS_SUCCESS) {
 432             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Cardinit request in status fail!\n");
 433             spin_unlock_irq(&pDevice->lock);
 434             return FALSE;
 435         }
 436
 437         //Local ID for AES functions
 438         ntStatus = CONTROLnsRequestIn(pDevice,
 439                                     MESSAGE_TYPE_READ,
 440                                     MAC_REG_LOCALID,
 441                                     MESSAGE_REQUEST_MACREG,
 442                                     1,
 443                                     &pDevice->byLocalID);
 444
 445         if ( ntStatus != STATUS_SUCCESS ) {
 446             spin_unlock_irq(&pDevice->lock);
 447             return FALSE;
 448         }
 449
 450         // Do MACbSoftwareReset in MACvInitialize
 451         // force CCK
 452         pDevice->bCCK = TRUE;
 453         pDevice->bProtectMode = FALSE;          //Only used in 11g type, sync with ERP IE
 454         pDevice->bNonERPPresent = FALSE;
 455         pDevice->bBarkerPreambleMd = FALSE;
 456         if ( pDevice->bFixRate ) {
 457             pDevice->wCurrentRate = (WORD) pDevice->uConnectionRate;
 458         } else {
 459             if ( pDevice->byBBType == BB_TYPE_11B )
 460                 pDevice->wCurrentRate = RATE_11M;
 461             else
 462                 pDevice->wCurrentRate = RATE_54M;
 463         }
 464
 465         CHvInitChannelTable(pDevice);
 466
 467         pDevice->byTopOFDMBasicRate = RATE_24M;
 468         pDevice->byTopCCKBasicRate = RATE_1M;
 469         pDevice->byRevId = 0;                   //Target to IF pin while programming to RF chip.
 470         pDevice->byCurPwr = 0xFF;
 471
 472         pDevice->byCCKPwr = pDevice->abyEEPROM[EEP_OFS_PWR_CCK];
 473         pDevice->byOFDMPwrG = pDevice->abyEEPROM[EEP_OFS_PWR_OFDMG];
 474         // Load power Table
 475         for (ii=0;ii<14;ii++) {
 476             pDevice->abyCCKPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_CCK_PWR_TBL];
 477             if (pDevice->abyCCKPwrTbl[ii] == 0)
 478                 pDevice->abyCCKPwrTbl[ii] = pDevice->byCCKPwr;
 479             pDevice->abyOFDMPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDM_PWR_TBL];
 480             if (pDevice->abyOFDMPwrTbl[ii] == 0)
 481                 pDevice->abyOFDMPwrTbl[ii] = pDevice->byOFDMPwrG;
 482         }
 483
 484           //original zonetype is USA,but customize zonetype is europe,
 485           // then need recover 12,13 ,14 channel  with 11 channel
 486           if(((pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Japan) ||
 487                 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Europe))&&
 488              (pDevice->byOriginalZonetype == ZoneType_USA)) {
 489             for(ii=11;ii<14;ii++) {
 490                 pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];
 491                pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];
 492             }
 493           }
 494
 495         //{{ RobertYu: 20041124
 496         pDevice->byOFDMPwrA = 0x34; // same as RFbMA2829SelectChannel
 497         // Load OFDM A Power Table
 498         for (ii=0;ii<CB_MAX_CHANNEL_5G;ii++) { //RobertYu:20041224, bug using CB_MAX_CHANNEL
 499             pDevice->abyOFDMAPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDMA_PWR_TBL];
 500             if (pDevice->abyOFDMAPwrTbl[ii] == 0)
 501                 pDevice->abyOFDMAPwrTbl[ii] = pDevice->byOFDMPwrA;
 502         }
 503         //}} RobertYu
 504
 505         byAntenna = pDevice->abyEEPROM[EEP_OFS_ANTENNA];
 506         if (byAntenna & EEP_ANTINV)
 507             pDevice->bTxRxAntInv = TRUE;
 508         else
 509             pDevice->bTxRxAntInv = FALSE;
 510
 511         byAntenna &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
 512
 513         if (byAntenna == 0) // if not set default is All
 514             byAntenna = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
 515
 516         if (byAntenna == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
 517             pDevice->byAntennaCount = 2;
 518             pDevice->byTxAntennaMode = ANT_B;
 519             pDevice->dwTxAntennaSel = 1;
 520             pDevice->dwRxAntennaSel = 1;
 521             if (pDevice->bTxRxAntInv == TRUE)
 522                 pDevice->byRxAntennaMode = ANT_A;
 523             else
 524                 pDevice->byRxAntennaMode = ANT_B;
 525
 526             if (pDevice->bDiversityRegCtlON)
 527                 pDevice->bDiversityEnable = TRUE;
 528             else
 529                 pDevice->bDiversityEnable = FALSE;
 530         } else  {
 531             pDevice->bDiversityEnable = FALSE;
 532             pDevice->byAntennaCount = 1;
 533             pDevice->dwTxAntennaSel = 0;
 534             pDevice->dwRxAntennaSel = 0;
 535             if (byAntenna & EEP_ANTENNA_AUX) {
 536                 pDevice->byTxAntennaMode = ANT_A;
 537                 if (pDevice->bTxRxAntInv == TRUE)
 538                     pDevice->byRxAntennaMode = ANT_B;
 539                 else
 540                     pDevice->byRxAntennaMode = ANT_A;
 541             } else {
 542                 pDevice->byTxAntennaMode = ANT_B;
 543                 if (pDevice->bTxRxAntInv == TRUE)
 544                     pDevice->byRxAntennaMode = ANT_A;
 545                 else
 546                     pDevice->byRxAntennaMode = ANT_B;
 547             }
 548         }
 549         pDevice->ulDiversityNValue = 100*255;
 550         pDevice->ulDiversityMValue = 100*16;
 551         pDevice->byTMax = 1;
 552         pDevice->byTMax2 = 4;
 553         pDevice->ulSQ3TH = 0;
 554         pDevice->byTMax3 = 64;
 555         // -----------------------------------------------------------------
 556
 557         //Get Auto Fall Back Type
 558         pDevice->byAutoFBCtrl = AUTO_FB_0;
 559
 560         // Set SCAN Time
 561         pDevice->uScanTime = WLAN_SCAN_MINITIME;
 562
 563         // default Auto Mode
 564         //pDevice->NetworkType = Ndis802_11Automode;
 565         pDevice->eConfigPHYMode = PHY_TYPE_AUTO;
 566         pDevice->byBBType = BB_TYPE_11G;
 567
 568         // initialize BBP registers
 569         pDevice->ulTxPower = 25;
 570
 571         // Get Channel range
 572         pDevice->byMinChannel = 1;
 573         pDevice->byMaxChannel = CB_MAX_CHANNEL;
 574
 575         // Get RFType
 576         pDevice->byRFType = sInitRsp.byRFType;
 577
 578         if ((pDevice->byRFType & RF_EMU) != 0) {
 579             // force change RevID for VT3253 emu
 580             pDevice->byRevId = 0x80;
 581         }
 582
 583         // Load EEPROM calibrated vt3266 parameters
 584         if (pDevice->byRFType == RF_VT3226D0) {
 585             if((pDevice->abyEEPROM[EEP_OFS_MAJOR_VER] == 0x1) &&
 586                 (pDevice->abyEEPROM[EEP_OFS_MINOR_VER] >= 0x4)) {
 587                 byCalibTXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_IQ];
 588                 byCalibTXDC = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_DC];
 589                 byCalibRXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_RX_IQ];
 590                 if( (byCalibTXIQ || byCalibTXDC || byCalibRXIQ) ) {
 591                     ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFF, 0x03); // CR255, Set BB to support TX/RX IQ and DC compensation Mode
 592                     ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFB, byCalibTXIQ); // CR251, TX I/Q Imbalance Calibration
 593                     ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFC, byCalibTXDC); // CR252, TX DC-Offset Calibration
 594                     ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFD, byCalibRXIQ); // CR253, RX I/Q Imbalance Calibration
 595                 } else {
 596                 // turn off BB Calibration compensation
 597                     ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFF, 0x0); // CR255
 598                 }
 599             }
 600         }
 601         pMgmt->eScanType = WMAC_SCAN_PASSIVE;
 602         pMgmt->uCurrChannel = pDevice->uChannel;
 603         pMgmt->uIBSSChannel = pDevice->uChannel;
 604         CARDbSetMediaChannel(pDevice, pMgmt->uCurrChannel);
 605
 606         // get Permanent network address
 607         memcpy(pDevice->abyPermanentNetAddr,&(sInitRsp.byNetAddr[0]),6);
 608         memcpy(pDevice->abyCurrentNetAddr, pDevice->abyPermanentNetAddr, U_ETHER_ADDR_LEN);
 609
 610         // if exist SW network address, use SW network address.
 611
 612         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %02x-%02x-%02x=%02x-%02x-%02x\n",
 613             pDevice->abyCurrentNetAddr[0],
 614             pDevice->abyCurrentNetAddr[1],
 615             pDevice->abyCurrentNetAddr[2],
 616             pDevice->abyCurrentNetAddr[3],
 617             pDevice->abyCurrentNetAddr[4],
 618             pDevice->abyCurrentNetAddr[5]);
 619     }
 620
 621
 622
 623     // Set BB and packet type at the same time.
 624     // Set Short Slot Time, xIFS, and RSPINF.
 625     if (pDevice->byBBType == BB_TYPE_11A) {
 626         CARDbAddBasicRate(pDevice, RATE_6M);
 627         pDevice->bShortSlotTime = TRUE;
 628     } else {
 629         CARDbAddBasicRate(pDevice, RATE_1M);
 630         pDevice->bShortSlotTime = FALSE;
 631     }
 632     BBvSetShortSlotTime(pDevice);
 633     CARDvSetBSSMode(pDevice);
 634
 635     if (pDevice->bUpdateBBVGA) {
 636         pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
 637         pDevice->byBBVGANew = pDevice->byBBVGACurrent;
 638         BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
 639     }
 640
 641     pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];
 642     pDevice->bHWRadioOff = FALSE;
 643     if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) {
 644         ntStatus = CONTROLnsRequestIn(pDevice,
 645                                     MESSAGE_TYPE_READ,
 646                                     MAC_REG_GPIOCTL1,
 647                                     MESSAGE_REQUEST_MACREG,
 648                                     1,
 649                                     &byTmp);
 650
 651         if ( ntStatus != STATUS_SUCCESS ) {
 652             spin_unlock_irq(&pDevice->lock);
 653             return FALSE;
 654         }
 655         if ( (byTmp & GPIO3_DATA) == 0 ) {
 656             pDevice->bHWRadioOff = TRUE;
 657             MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
 658         } else {
 659             MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
 660             pDevice->bHWRadioOff = FALSE;
 661         }
 662
 663     } //EEP_RADIOCTL_ENABLE
 664
 665     ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
 666     ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
 667     MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01);
 668
 669     if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) {
 670         CARDbRadioPowerOff(pDevice);
 671     } else {
 672         CARDbRadioPowerOn(pDevice);
 673     }
 674
 675     spin_unlock_irq(&pDevice->lock);
 676     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");
 677     return TRUE;
 678 }
 679
 680 static BOOL device_release_WPADEV(PSDevice pDevice)
 681 {
 682   viawget_wpa_header *wpahdr;
 683   int ii=0;
 684  // wait_queue_head_t   Set_wait;
 685   //send device close to wpa_supplicnat layer
 686     if (pDevice->bWPADEVUp==TRUE) {
 687                  wpahdr = (viawget_wpa_header *)pDevice->skb->data;
 688                  wpahdr->type = VIAWGET_DEVICECLOSE_MSG;
 689                  wpahdr->resp_ie_len = 0;
 690                  wpahdr->req_ie_len = 0;
 691                  skb_put(pDevice->skb, sizeof(viawget_wpa_header));
 692                  pDevice->skb->dev = pDevice->wpadev;
 693                  skb_reset_mac_header(pDevice->skb);
 694                  pDevice->skb->pkt_type = PACKET_HOST;
 695                  pDevice->skb->protocol = htons(ETH_P_802_2);
 696                  memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
 697                  netif_rx(pDevice->skb);
 698                  pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
 699
 700  //wait release WPADEV
 701               //    init_waitqueue_head(&Set_wait);
 702               //    wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ);    //1s wait
 703               while(pDevice->bWPADEVUp==TRUE) {
 704                 set_current_state(TASK_UNINTERRUPTIBLE);
 705                  schedule_timeout (HZ/20);          //wait 50ms
 706                  ii++;
 707                 if(ii>20)
 708                   break;
 709               }
 710            };
 711     return TRUE;
 712 }
 713
 714 #ifdef CONFIG_PM        /* Minimal support for suspend and resume */
 715 static int vntwusb_suspend(struct usb_interface *intf, pm_message_t message)
 716 {
 717  PSDevice  pDevice = usb_get_intfdata(intf);
 718  struct net_device *dev = pDevice->dev;
 719
 720  printk("VNTWUSB Suspend Start======>\n");
 721 if(dev != NULL) {
 722   if(pDevice->flags & DEVICE_FLAGS_OPENED)
 723      device_close(dev);
 724 }
 725
 726  usb_put_dev(interface_to_usbdev(intf));
 727  return 0;
 728 }
 729
 730 static int vntwusb_resume(struct usb_interface *intf)
 731 {
 732  PSDevice  pDevice = usb_get_intfdata(intf);
 733  struct net_device *dev = pDevice->dev;
 734
 735  printk("VNTWUSB Resume Start======>\n");
 736  if(dev != NULL) {
 737   usb_get_dev(interface_to_usbdev(intf));
 738   if(!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
 739     if(device_open(dev)!=0)
 740         printk("VNTWUSB Resume Start======>open fail\n");
 741    }
 742  }
 743  return 0;
 744 }
 745 #endif
 746
 747
 748 static const struct net_device_ops device_netdev_ops = {
 749     .ndo_open               = device_open,
 750     .ndo_stop               = device_close,
 751     .ndo_do_ioctl           = device_ioctl,
 752     .ndo_get_stats          = device_get_stats,
 753     .ndo_start_xmit         = device_xmit,
 754     .ndo_set_multicast_list = device_set_multi,
 755 };
 756
 757
 758 static int
 759 vntwusb_found1(struct usb_interface *intf, const struct usb_device_id *id)
 760 {
 761    BYTE            fake_mac[U_ETHER_ADDR_LEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};//fake MAC address
 762         struct usb_device *udev = interface_to_usbdev(intf);
 763     int         rc = 0;
 764     struct net_device *netdev = NULL;
 765     PSDevice    pDevice = NULL;
 766
 767
 768     printk(KERN_NOTICE "%s Ver. %s\n",DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
 769     printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
 770
 771   udev = usb_get_dev(udev);
 772
 773     netdev = alloc_etherdev(sizeof(DEVICE_INFO));
 774
 775     if (netdev == NULL) {
 776         printk(KERN_ERR DEVICE_NAME ": allocate net device failed \n");
 777         kfree(pDevice);
 778             goto err_nomem;
 779     }
 780
 781     pDevice = netdev_priv(netdev);
 782     memset(pDevice, 0, sizeof(DEVICE_INFO));
 783
 784     pDevice->dev = netdev;
 785     pDevice->usb = udev;
 786
 787     // Set initial settings
 788     device_set_options(pDevice);
 789     spin_lock_init(&pDevice->lock);
 790
 791     pDevice->tx_80211 = device_dma0_tx_80211;
 792     pDevice->sMgmtObj.pAdapter = (PVOID)pDevice;
 793
 794     netdev->netdev_ops         = &device_netdev_ops;
 795
 796         netdev->wireless_handlers = (struct iw_handler_def *)&iwctl_handler_def;
 797
 798    //2008-0623-01<Remark>by MikeLiu
 799   //2007-0821-01<Add>by MikeLiu
 800          usb_set_intfdata(intf, pDevice);
 801         SET_NETDEV_DEV(netdev, &intf->dev);
 802     memcpy(pDevice->dev->dev_addr, fake_mac, U_ETHER_ADDR_LEN); //use fake mac address
 803     rc = register_netdev(netdev);
 804     if (rc != 0) {
 805         printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
 806                 free_netdev(netdev);
 807         kfree(pDevice);
 808         return -ENODEV;
 809     }
 810
 811 //2008-07-21-01<Add>by MikeLiu
 812 //register wpadev
 813 #if 0
 814    if(wpa_set_wpadev(pDevice, 1)!=0) {
 815      printk("Fail to Register WPADEV?\n");
 816         unregister_netdev(pDevice->dev);
 817         free_netdev(netdev);
 818         kfree(pDevice);
 819    }
 820 #endif
 821          usb_device_reset(pDevice);
 822
 823 #ifdef SndEvt_ToAPI
 824 {
 825   union iwreq_data      wrqu;
 826   memset(&wrqu, 0, sizeof(wrqu));
 827   wrqu.data.flags = RT_INSMOD_EVENT_FLAG;
 828   wrqu.data.length =IFNAMSIZ;
 829   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, pDevice->dev->name);
 830 }
 831 #endif
 832
 833         return 0;
 834
 835
 836 err_nomem:
 837  //2008-0922-01<Add>by MikeLiu, decrease usb counter.
 838     usb_put_dev(udev);
 839
 840     return -ENOMEM;
 841 }
 842
 843
 844 static VOID device_free_tx_bufs(PSDevice pDevice) {
 845     PUSB_SEND_CONTEXT pTxContext;
 846     int ii;
 847
 848     for (ii = 0; ii < pDevice->cbTD; ii++) {
 849
 850         pTxContext = pDevice->apTD[ii];
 851         //de-allocate URBs
 852         if (pTxContext->pUrb) {
 853             usb_kill_urb(pTxContext->pUrb);
 854             usb_free_urb(pTxContext->pUrb);
 855         }
 856         if (pTxContext)
 857             kfree(pTxContext);
 858     }
 859     return;
 860 }
 861
 862
 863 static VOID device_free_rx_bufs(PSDevice pDevice) {
 864     PRCB pRCB;
 865     int ii;
 866
 867     for (ii = 0; ii < pDevice->cbRD; ii++) {
 868
 869         pRCB = pDevice->apRCB[ii];
 870         //de-allocate URBs
 871         if (pRCB->pUrb) {
 872             usb_kill_urb(pRCB->pUrb);
 873             usb_free_urb(pRCB->pUrb);
 874         }
 875         //de-allocate skb
 876         if (pRCB->skb)
 877             dev_kfree_skb(pRCB->skb);
 878     }
 879     if (pDevice->pRCBMem)
 880         kfree(pDevice->pRCBMem);
 881
 882     return;
 883 }
 884
 885 //2007-1107-02<Add>by MikeLiu
 886 static void usb_device_reset(PSDevice pDevice)
 887 {
 888  int status;
 889  status = usb_reset_device(pDevice->usb);
 890         if (status)
 891             printk("usb_device_reset fail status=%d\n",status);
 892         return ;
 893 }
 894
 895 static VOID device_free_int_bufs(PSDevice pDevice) {
 896
 897     if (pDevice->intBuf.pDataBuf != NULL)
 898         kfree(pDevice->intBuf.pDataBuf);
 899     return;
 900 }
 901
 902
 903 static BOOL device_alloc_bufs(PSDevice pDevice) {
 904
 905     PUSB_SEND_CONTEXT pTxContext;
 906     PRCB pRCB;
 907     int ii;
 908
 909
 910     for (ii = 0; ii < pDevice->cbTD; ii++) {
 911
 912         pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
 913         if (pTxContext == NULL) {
 914             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
 915             goto free_tx;
 916         }
 917         pDevice->apTD[ii] = pTxContext;
 918         pTxContext->pDevice = (PVOID) pDevice;
 919         //allocate URBs
 920         pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
 921         if (pTxContext->pUrb == NULL) {
 922             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
 923             goto free_tx;
 924         }
 925         pTxContext->bBoolInUse = FALSE;
 926     }
 927
 928     // allocate rcb mem
 929     pDevice->pRCBMem = kmalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
 930     if (pDevice->pRCBMem == NULL) {
 931         DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
 932         goto free_tx;
 933     }
 934
 935
 936     pDevice->FirstRecvFreeList = NULL;
 937     pDevice->LastRecvFreeList = NULL;
 938     pDevice->FirstRecvMngList = NULL;
 939     pDevice->LastRecvMngList = NULL;
 940     pDevice->NumRecvFreeList = 0;
 941     memset(pDevice->pRCBMem, 0, (sizeof(RCB) * pDevice->cbRD));
 942     pRCB = (PRCB) pDevice->pRCBMem;
 943
 944     for (ii = 0; ii < pDevice->cbRD; ii++) {
 945
 946         pDevice->apRCB[ii] = pRCB;
 947         pRCB->pDevice = (PVOID) pDevice;
 948         //allocate URBs
 949         pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
 950
 951         if (pRCB->pUrb == NULL) {
 952             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
 953             goto free_rx_tx;
 954         }
 955         pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
 956         if (pRCB->skb == NULL) {
 957             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
 958             goto free_rx_tx;
 959         }
 960         pRCB->skb->dev = pDevice->dev;
 961         pRCB->bBoolInUse = FALSE;
 962         EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
 963         pDevice->NumRecvFreeList++;
 964         pRCB++;
 965     }
 966
 967
 968         pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
 969         if (pDevice->pControlURB == NULL) {
 970             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
 971             goto free_rx_tx;
 972         }
 973
 974         pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
 975         if (pDevice->pInterruptURB == NULL) {
 976             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
 977             usb_kill_urb(pDevice->pControlURB);
 978             usb_free_urb(pDevice->pControlURB);
 979             goto free_rx_tx;
 980         }
 981
 982     pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
 983         if (pDevice->intBuf.pDataBuf == NULL) {
 984             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
 985             usb_kill_urb(pDevice->pControlURB);
 986             usb_kill_urb(pDevice->pInterruptURB);
 987             usb_free_urb(pDevice->pControlURB);
 988             usb_free_urb(pDevice->pInterruptURB);
 989             goto free_rx_tx;
 990         }
 991
 992     return TRUE;
 993
 994 free_rx_tx:
 995     device_free_rx_bufs(pDevice);
 996
 997 free_tx:
 998     device_free_tx_bufs(pDevice);
 999
1000         return FALSE;
1001 }
1002
1003
1004
1005
1006 static BOOL device_init_defrag_cb(PSDevice pDevice) {
1007     int i;
1008     PSDeFragControlBlock pDeF;
1009
1010     /* Init the fragment ctl entries */
1011     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1012         pDeF = &(pDevice->sRxDFCB[i]);
1013         if (!device_alloc_frag_buf(pDevice, pDeF)) {
1014             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
1015                 pDevice->dev->name);
1016             goto free_frag;
1017         };
1018     }
1019     pDevice->cbDFCB = CB_MAX_RX_FRAG;
1020     pDevice->cbFreeDFCB = pDevice->cbDFCB;
1021     return TRUE;
1022
1023 free_frag:
1024     device_free_frag_bufs(pDevice);
1025     return FALSE;
1026 }
1027
1028
1029
1030 static void device_free_frag_bufs(PSDevice pDevice) {
1031     PSDeFragControlBlock pDeF;
1032     int i;
1033
1034     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1035
1036         pDeF = &(pDevice->sRxDFCB[i]);
1037
1038         if (pDeF->skb)
1039             dev_kfree_skb(pDeF->skb);
1040     }
1041 }
1042
1043
1044
1045 BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1046
1047     pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1048     if (pDeF->skb == NULL)
1049         return FALSE;
1050     ASSERT(pDeF->skb);
1051     pDeF->skb->dev = pDevice->dev;
1052
1053     return TRUE;
1054 }
1055
1056
1057 /*-----------------------------------------------------------------*/
1058
1059 static int  device_open(struct net_device *dev) {
1060     PSDevice    pDevice=(PSDevice) netdev_priv(dev);
1061
1062 #ifdef WPA_SM_Transtatus
1063      extern SWPAResult wpa_Result;
1064      memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1065      wpa_Result.proto = 0;
1066      wpa_Result.key_mgmt = 0;
1067      wpa_Result.eap_type = 0;
1068      wpa_Result.authenticated = FALSE;
1069      pDevice->fWPA_Authened = FALSE;
1070 #endif
1071
1072     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
1073
1074
1075     pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
1076
1077     if (device_alloc_bufs(pDevice) == FALSE) {
1078         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
1079         return -ENOMEM;
1080     }
1081
1082     if (device_init_defrag_cb(pDevice)== FALSE) {
1083         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragement cb fail \n");
1084         goto free_rx_tx;
1085     }
1086
1087     MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
1088     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
1089     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
1090     MP_SET_FLAG(pDevice, fMP_POST_READS);
1091     MP_SET_FLAG(pDevice, fMP_POST_WRITES);
1092
1093    //read config file
1094     Read_config_file(pDevice);
1095
1096     if (device_init_registers(pDevice, DEVICE_INIT_COLD) == FALSE) {
1097         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
1098         goto free_all;
1099     }
1100
1101     device_set_multi(pDevice->dev);
1102     // Init for Key Management
1103
1104     KeyvInitTable(pDevice,&pDevice->sKey);
1105     memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, U_ETHER_ADDR_LEN);
1106     memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, U_ETHER_ADDR_LEN);
1107     pDevice->bStopTx0Pkt = FALSE;
1108     pDevice->bStopDataPkt = FALSE;
1109     pDevice->bRoaming = FALSE;  //DavidWang
1110     pDevice->bIsRoaming = FALSE;//DavidWang
1111     pDevice->bEnableRoaming = FALSE;
1112     if (pDevice->bDiversityRegCtlON) {
1113         device_init_diversity_timer(pDevice);
1114     }
1115
1116     vMgrObjectInit(pDevice);
1117     tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
1118     tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
1119     tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
1120     add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback));
1121     pDevice->int_interval = 100;  //Max 100 microframes.
1122     pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1123
1124     pDevice->bIsRxWorkItemQueued = TRUE;
1125     pDevice->fKillEventPollingThread = FALSE;
1126     pDevice->bEventAvailable = FALSE;
1127
1128    pDevice->bWPADEVUp = FALSE;
1129 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1130      pDevice->bwextstep0 = FALSE;
1131      pDevice->bwextstep1 = FALSE;
1132      pDevice->bwextstep2 = FALSE;
1133      pDevice->bwextstep3 = FALSE;
1134      pDevice->bWPASuppWextEnabled = FALSE;
1135 #endif
1136     pDevice->byReAssocCount = 0;
1137
1138     RXvWorkItem(pDevice);
1139     INTvWorkItem(pDevice);
1140
1141     // Patch: if WEP key already set by iwconfig but device not yet open
1142     if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1143          spin_lock_irq(&pDevice->lock);
1144          KeybSetDefaultKey( pDevice,
1145                             &(pDevice->sKey),
1146                             pDevice->byKeyIndex | (1 << 31),
1147                             pDevice->uKeyLength,
1148                             NULL,
1149                             pDevice->abyKey,
1150                             KEY_CTL_WEP
1151                           );
1152          spin_unlock_irq(&pDevice->lock);
1153          pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1154     }
1155
1156     if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1157         bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL);
1158         }
1159         else {
1160         //mike:mark@2008-11-10
1161             bScheduleCommand((HANDLE)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1162         //bScheduleCommand((HANDLE)pDevice, WLAN_CMD_SSID, NULL);
1163     }
1164
1165
1166     netif_stop_queue(pDevice->dev);
1167     pDevice->flags |= DEVICE_FLAGS_OPENED;
1168
1169 #ifdef SndEvt_ToAPI
1170 {
1171   union iwreq_data      wrqu;
1172   memset(&wrqu, 0, sizeof(wrqu));
1173   wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1174   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1175 }
1176 #endif
1177
1178     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1179     return 0;
1180
1181 free_all:
1182     device_free_frag_bufs(pDevice);
1183 free_rx_tx:
1184     device_free_rx_bufs(pDevice);
1185     device_free_tx_bufs(pDevice);
1186     device_free_int_bufs(pDevice);
1187         usb_kill_urb(pDevice->pControlURB);
1188         usb_kill_urb(pDevice->pInterruptURB);
1189     usb_free_urb(pDevice->pControlURB);
1190     usb_free_urb(pDevice->pInterruptURB);
1191
1192     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1193     return -ENOMEM;
1194 }
1195
1196
1197
1198 static int  device_close(struct net_device *dev) {
1199     PSDevice    pDevice=(PSDevice) netdev_priv(dev);
1200     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1201
1202         int uu;
1203
1204     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1205     if (pDevice == NULL)
1206         return -ENODEV;
1207
1208 #ifdef SndEvt_ToAPI
1209 {
1210   union iwreq_data      wrqu;
1211   memset(&wrqu, 0, sizeof(wrqu));
1212   wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1213   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1214 }
1215 #endif
1216
1217 //2007-1121-02<Add>by EinsnLiu
1218     if (pDevice->bLinkPass) {
1219         bScheduleCommand((HANDLE)pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1220         mdelay(30);
1221     }
1222 //End Add
1223
1224 //2008-0714-01<Add>by MikeLiu
1225 device_release_WPADEV(pDevice);
1226
1227         memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1228         pMgmt->bShareKeyAlgorithm = FALSE;
1229         pDevice->bEncryptionEnable = FALSE;
1230         pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1231             spin_lock_irq(&pDevice->lock);
1232             for(uu=0;uu<MAX_KEY_TABLE;uu++)
1233                 MACvDisableKeyEntry(pDevice,uu);
1234             spin_unlock_irq(&pDevice->lock);
1235
1236     if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1237         MACbShutdown(pDevice);
1238     }
1239     netif_stop_queue(pDevice->dev);
1240     MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1241     MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1242     MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1243     pDevice->fKillEventPollingThread = TRUE;
1244     del_timer(&pDevice->sTimerCommand);
1245     del_timer(&pMgmt->sTimerSecondCallback);
1246
1247 //2007-0115-02<Add>by MikeLiu
1248 #ifdef TxInSleep
1249     del_timer(&pDevice->sTimerTxData);
1250 #endif
1251
1252     if (pDevice->bDiversityRegCtlON) {
1253         del_timer(&pDevice->TimerSQ3Tmax1);
1254         del_timer(&pDevice->TimerSQ3Tmax2);
1255         del_timer(&pDevice->TimerSQ3Tmax3);
1256     }
1257     tasklet_kill(&pDevice->RxMngWorkItem);
1258     tasklet_kill(&pDevice->ReadWorkItem);
1259     tasklet_kill(&pDevice->EventWorkItem);
1260
1261    pDevice->bRoaming = FALSE;  //DavidWang
1262    pDevice->bIsRoaming = FALSE;//DavidWang
1263    pDevice->bEnableRoaming = FALSE;
1264     pDevice->bCmdRunning = FALSE;
1265     pDevice->bLinkPass = FALSE;
1266     memset(pMgmt->abyCurrBSSID, 0, 6);
1267     pMgmt->eCurrState = WMAC_STATE_IDLE;
1268
1269     device_free_tx_bufs(pDevice);
1270     device_free_rx_bufs(pDevice);
1271     device_free_int_bufs(pDevice);
1272     device_free_frag_bufs(pDevice);
1273
1274         usb_kill_urb(pDevice->pControlURB);
1275         usb_kill_urb(pDevice->pInterruptURB);
1276     usb_free_urb(pDevice->pControlURB);
1277     usb_free_urb(pDevice->pInterruptURB);
1278
1279     BSSvClearNodeDBTable(pDevice, 0);
1280     pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1281
1282     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1283
1284     return 0;
1285 }
1286
1287
1288 static void vntwusb_disconnect(struct usb_interface *intf)
1289
1290 {
1291
1292         PSDevice  pDevice = usb_get_intfdata(intf);
1293
1294     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_disconnect1.. \n");
1295     if (pDevice == NULL)
1296         return;
1297
1298 #ifdef SndEvt_ToAPI
1299 {
1300   union iwreq_data      wrqu;
1301   memset(&wrqu, 0, sizeof(wrqu));
1302   wrqu.data.flags = RT_RMMOD_EVENT_FLAG;
1303   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1304 }
1305 #endif
1306
1307 //2008-0714-01<Add>by MikeLiu
1308 device_release_WPADEV(pDevice);
1309
1310         usb_set_intfdata(intf, NULL);
1311 //2008-0922-01<Add>by MikeLiu, decrease usb counter.
1312      usb_put_dev(interface_to_usbdev(intf));
1313
1314     pDevice->flags |= DEVICE_FLAGS_UNPLUG;
1315     if (pDevice->dev != NULL) {
1316         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "unregister_netdev..\n");
1317         unregister_netdev(pDevice->dev);
1318
1319 //2008-07-21-01<Add>by MikeLiu
1320 //unregister wpadev
1321    if(wpa_set_wpadev(pDevice, 0)!=0)
1322      printk("unregister wpadev fail?\n");
1323
1324         free_netdev(pDevice->dev);
1325     }
1326
1327     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_disconnect3.. \n");
1328 }
1329
1330
1331
1332
1333 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev) {
1334     PSDevice        pDevice=netdev_priv(dev);
1335     PBYTE           pbMPDU;
1336     UINT            cbMPDULen = 0;
1337
1338
1339     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211\n");
1340     spin_lock_irq(&pDevice->lock);
1341
1342     if (pDevice->bStopTx0Pkt == TRUE) {
1343         dev_kfree_skb_irq(skb);
1344         spin_unlock_irq(&pDevice->lock);
1345         return 0;
1346     };
1347
1348
1349     cbMPDULen = skb->len;
1350     pbMPDU = skb->data;
1351
1352     vDMA0_tx_80211(pDevice, skb);
1353
1354     spin_unlock_irq(&pDevice->lock);
1355
1356     return 0;
1357
1358 }
1359
1360
1361 static int  device_xmit(struct sk_buff *skb, struct net_device *dev) {
1362     PSDevice    pDevice=netdev_priv(dev);
1363     struct net_device_stats* pStats = &pDevice->stats;
1364
1365
1366     spin_lock_irq(&pDevice->lock);
1367
1368     netif_stop_queue(pDevice->dev);
1369
1370     if (pDevice->bLinkPass == FALSE) {
1371         dev_kfree_skb_irq(skb);
1372         spin_unlock_irq(&pDevice->lock);
1373         return 0;
1374     }
1375     if (pDevice->bStopDataPkt == TRUE) {
1376         dev_kfree_skb_irq(skb);
1377         pStats->tx_dropped++;
1378         spin_unlock_irq(&pDevice->lock);
1379         return 0;
1380     }
1381
1382     if(nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb) !=0) {  //mike add:xmit fail!
1383          if (netif_queue_stopped(pDevice->dev))
1384               netif_wake_queue(pDevice->dev);
1385     }
1386
1387     spin_unlock_irq(&pDevice->lock);
1388
1389     return 0;
1390 }
1391
1392
1393
1394 static unsigned const ethernet_polynomial = 0x04c11db7U;
1395 static inline u32 ether_crc(int length, unsigned char *data)
1396 {
1397     int crc = -1;
1398
1399     while(--length >= 0) {
1400         unsigned char current_octet = *data++;
1401         int bit;
1402         for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1403             crc = (crc << 1) ^
1404                 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1405         }
1406     }
1407     return crc;
1408 }
1409
1410 //find out  the start  position of str2 from str1
1411 static UCHAR *kstrstr(const UCHAR *str1,const UCHAR *str2) {
1412   int str1_len=strlen(str1);
1413   int str2_len=strlen(str2);
1414
1415   while (str1_len >= str2_len) {
1416        str1_len--;
1417       if(memcmp(str1,str2,str2_len)==0)
1418          return (UCHAR *)str1;
1419         str1++;
1420   }
1421   return NULL;
1422 }
1423
1424 static int Config_FileGetParameter(UCHAR *string, UCHAR *dest,UCHAR *source)
1425 {
1426   UCHAR buf1[100];
1427   UCHAR buf2[100];
1428   UCHAR *start_p=NULL,*end_p=NULL,*tmp_p=NULL;
1429   int ii;
1430
1431     memset(buf1,0,100);
1432     strcat(buf1, string);
1433     strcat(buf1, "=");
1434     source+=strlen(buf1);
1435
1436 //find target string start point
1437     if((start_p = kstrstr(source,buf1))==NULL)
1438         return FALSE;
1439
1440 //check if current config line is marked by "#" ??
1441 for(ii=1;;ii++) {
1442   if(memcmp(start_p-ii,"\n",1)==0)
1443       break;
1444   if(memcmp(start_p-ii,"#",1)==0)
1445       return FALSE;
1446 }
1447
1448 //find target string end point
1449      if((end_p = kstrstr(start_p,"\n"))==NULL) {       //cann't find "\n",but don't care
1450           end_p=start_p+strlen(start_p);   //no include "\n"
1451        }
1452
1453    memset(buf2,0,100);
1454    memcpy(buf2,start_p,end_p-start_p);    //get the tartget line
1455    buf2[end_p-start_p]='\0';
1456
1457    //find value
1458    if((start_p = kstrstr(buf2,"="))==NULL)
1459       return FALSE;
1460    memset(buf1,0,100);
1461    strcpy(buf1,start_p+1);
1462
1463   //except space
1464   tmp_p = buf1;
1465   while(*tmp_p != 0x00) {
1466         if(*tmp_p==' ')
1467             tmp_p++;
1468          else
1469           break;
1470   }
1471
1472    memcpy(dest,tmp_p,strlen(tmp_p));
1473  return TRUE;
1474 }
1475
1476 //if read fail,return NULL,or return data pointer;
1477 static UCHAR *Config_FileOperation(PSDevice pDevice) {
1478     UCHAR    *config_path=CONFIG_PATH;
1479     UCHAR    *buffer=NULL;
1480     struct file   *filp=NULL;
1481     mm_segment_t old_fs = get_fs();
1482     //int oldfsuid=0,oldfsgid=0;
1483     int result=0;
1484
1485     set_fs (KERNEL_DS);
1486     /* Can't do this anymore, so we rely on correct filesystem permissions:
1487     //Make sure a caller can read or write power as root
1488     oldfsuid=current->fsuid;
1489     oldfsgid=current->fsgid;
1490     current->fsuid = 0;
1491     current->fsgid = 0;
1492     */
1493
1494     //open file
1495       filp = filp_open(config_path, O_RDWR, 0);
1496         if (IS_ERR(filp)) {
1497              printk("Config_FileOperation file Not exist\n");
1498              result=-1;
1499              goto error2;
1500           }
1501
1502      if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1503            printk("file %s cann't readable or writable?\n",config_path);
1504           result = -1;
1505           goto error1;
1506         }
1507
1508     buffer = (UCHAR *)kmalloc(1024, GFP_KERNEL);
1509     if(buffer==NULL) {
1510       printk("alllocate mem for file fail?\n");
1511       result = -1;
1512       goto error1;
1513     }
1514
1515     if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1516      printk("read file error?\n");
1517      result = -1;
1518     }
1519
1520 error1:
1521   if(filp_close(filp,NULL))
1522        printk("Config_FileOperation:close file fail\n");
1523
1524 error2:
1525   set_fs (old_fs);
1526
1527   /*
1528   current->fsuid=oldfsuid;
1529   current->fsgid=oldfsgid;
1530   */
1531
1532 if(result!=0) {
1533     if(buffer)
1534          kfree(buffer);
1535     buffer=NULL;
1536 }
1537   return buffer;
1538 }
1539
1540 //return --->-1:fail;  >=0:successful
1541 static int Read_config_file(PSDevice pDevice) {
1542   int result=0;
1543   UCHAR      tmpbuffer[100];
1544   UCHAR *buffer=NULL;
1545
1546   //init config setting
1547  pDevice->config_file.ZoneType = -1;
1548  pDevice->config_file.eAuthenMode = -1;
1549  pDevice->config_file.eEncryptionStatus = -1;
1550
1551   if((buffer=Config_FileOperation(pDevice)) ==NULL) {
1552      result =-1;
1553      return result;
1554   }
1555
1556 //get zonetype
1557 {
1558     memset(tmpbuffer,0,sizeof(tmpbuffer));
1559     if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1560     if(memcmp(tmpbuffer,"USA",3)==0) {
1561       pDevice->config_file.ZoneType=ZoneType_USA;
1562     }
1563     else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1564       pDevice->config_file.ZoneType=ZoneType_Japan;
1565     }
1566     else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1567      pDevice->config_file.ZoneType=ZoneType_Europe;
1568     }
1569     else {
1570       printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1571    }
1572  }
1573 }
1574
1575 #if 1
1576 //get other parameter
1577   {
1578         memset(tmpbuffer,0,sizeof(tmpbuffer));
1579        if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1580          pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1581        }
1582
1583         memset(tmpbuffer,0,sizeof(tmpbuffer));
1584        if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1585          pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1586        }
1587   }
1588 #endif
1589
1590   kfree(buffer);
1591   return result;
1592 }
1593
1594 static void device_set_multi(struct net_device *dev) {
1595     PSDevice         pDevice = (PSDevice) netdev_priv(dev);
1596     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1597     u32              mc_filter[2];
1598     int              ii;
1599     struct dev_mc_list  *mclist;
1600     BYTE             pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1601     BYTE             byTmpMode = 0;
1602     int              rc;
1603
1604
1605         spin_lock_irq(&pDevice->lock);
1606     rc = CONTROLnsRequestIn(pDevice,
1607                             MESSAGE_TYPE_READ,
1608                             MAC_REG_RCR,
1609                             MESSAGE_REQUEST_MACREG,
1610                             1,
1611                             &byTmpMode
1612                             );
1613     if (rc == 0) pDevice->byRxMode = byTmpMode;
1614
1615     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1616
1617     if (dev->flags & IFF_PROMISC) {         // Set promiscuous.
1618         DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1619         // Unconditionally log net taps.
1620         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1621     }
1622     else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1623              (dev->flags & IFF_ALLMULTI)) {
1624         CONTROLnsRequestOut(pDevice,
1625                             MESSAGE_TYPE_WRITE,
1626                             MAC_REG_MAR0,
1627                             MESSAGE_REQUEST_MACREG,
1628                             8,
1629                             pbyData
1630                             );
1631         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1632     }
1633     else {
1634         memset(mc_filter, 0, sizeof(mc_filter));
1635         for (ii = 0, mclist = dev->mc_list; mclist && ii < netdev_mc_count(dev);
1636              ii++, mclist = mclist->next) {
1637             int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
1638             mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1639         }
1640         for (ii = 0; ii < 4; ii++) {
1641              MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1642              MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1643         }
1644         pDevice->byRxMode &= ~(RCR_UNICAST);
1645         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1646     }
1647
1648     if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1649         // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1650         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1651         pDevice->byRxMode &= ~(RCR_UNICAST);
1652     }
1653     ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1654     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1655         spin_unlock_irq(&pDevice->lock);
1656
1657 }
1658
1659
1660 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1661     PSDevice pDevice=(PSDevice) netdev_priv(dev);
1662
1663     return &pDevice->stats;
1664 }
1665
1666
1667 static int  device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1668         PSDevice                pDevice = (PSDevice)netdev_priv(dev);
1669     PSMgmtObject        pMgmt = &(pDevice->sMgmtObj);
1670     PSCmdRequest        pReq;
1671     //BOOL                bCommit = FALSE;
1672         struct iwreq *wrq = (struct iwreq *) rq;
1673         int                 rc =0;
1674
1675     if (pMgmt == NULL) {
1676         rc = -EFAULT;
1677         return rc;
1678     }
1679
1680     switch(cmd) {
1681
1682         case SIOCGIWNAME:
1683                 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1684                 break;
1685
1686         case SIOCSIWNWID:
1687         rc = -EOPNOTSUPP;
1688                 break;
1689
1690         case SIOCGIWNWID:     //0x8b03  support
1691         #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1692           rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
1693         #else
1694         rc = -EOPNOTSUPP;
1695         #endif
1696                 break;
1697
1698                 // Set frequency/channel
1699         case SIOCSIWFREQ:
1700             rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1701                 break;
1702
1703                 // Get frequency/channel
1704         case SIOCGIWFREQ:
1705                 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1706                 break;
1707
1708                 // Set desired network name (ESSID)
1709         case SIOCSIWESSID:
1710
1711                 {
1712                         char essid[IW_ESSID_MAX_SIZE+1];
1713                         if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1714                                 rc = -E2BIG;
1715                                 break;
1716                         }
1717                         if (copy_from_user(essid, wrq->u.essid.pointer,
1718                                            wrq->u.essid.length)) {
1719                                 rc = -EFAULT;
1720                                 break;
1721                         }
1722                         rc = iwctl_siwessid(dev, NULL,
1723                                             &(wrq->u.essid), essid);
1724                 }
1725                 break;
1726
1727
1728                 // Get current network name (ESSID)
1729         case SIOCGIWESSID:
1730
1731                 {
1732                         char essid[IW_ESSID_MAX_SIZE+1];
1733                         if (wrq->u.essid.pointer)
1734                                 rc = iwctl_giwessid(dev, NULL,
1735                                                     &(wrq->u.essid), essid);
1736                                 if (copy_to_user(wrq->u.essid.pointer,
1737                                                          essid,
1738                                                          wrq->u.essid.length) )
1739                                         rc = -EFAULT;
1740                 }
1741                 break;
1742
1743         case SIOCSIWAP:
1744
1745                 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1746                 break;
1747
1748
1749                 // Get current Access Point (BSSID)
1750         case SIOCGIWAP:
1751                 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1752                 break;
1753
1754
1755                 // Set desired station name
1756         case SIOCSIWNICKN:
1757         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1758         rc = -EOPNOTSUPP;
1759                 break;
1760
1761                 // Get current station name
1762         case SIOCGIWNICKN:
1763         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1764         rc = -EOPNOTSUPP;
1765                 break;
1766
1767                 // Set the desired bit-rate
1768         case SIOCSIWRATE:
1769                 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1770                 break;
1771
1772         // Get the current bit-rate
1773         case SIOCGIWRATE:
1774
1775                 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1776                 break;
1777
1778         // Set the desired RTS threshold
1779         case SIOCSIWRTS:
1780
1781                 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
1782                 break;
1783
1784         // Get the current RTS threshold
1785         case SIOCGIWRTS:
1786
1787                 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1788                 break;
1789
1790                 // Set the desired fragmentation threshold
1791         case SIOCSIWFRAG:
1792
1793                 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1794             break;
1795
1796         // Get the current fragmentation threshold
1797         case SIOCGIWFRAG:
1798
1799                 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1800                 break;
1801
1802                 // Set mode of operation
1803         case SIOCSIWMODE:
1804         rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1805                 break;
1806
1807                 // Get mode of operation
1808         case SIOCGIWMODE:
1809                 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1810                 break;
1811
1812                 // Set WEP keys and mode
1813         case SIOCSIWENCODE:
1814                 {
1815             char abyKey[WLAN_WEP232_KEYLEN];
1816
1817                         if (wrq->u.encoding.pointer) {
1818
1819
1820                                 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
1821                                         rc = -E2BIG;
1822                                         break;
1823                                 }
1824                                 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
1825                                 if (copy_from_user(abyKey,
1826                                                   wrq->u.encoding.pointer,
1827                                                   wrq->u.encoding.length)) {
1828                                         rc = -EFAULT;
1829                                         break;
1830                                 }
1831                         } else if (wrq->u.encoding.length != 0) {
1832                                 rc = -EINVAL;
1833                                 break;
1834                         }
1835                         rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1836                 }
1837                 break;
1838
1839                 // Get the WEP keys and mode
1840         case SIOCGIWENCODE:
1841
1842                 if (!capable(CAP_NET_ADMIN)) {
1843                         rc = -EPERM;
1844                         break;
1845                 }
1846                 {
1847                     char abyKey[WLAN_WEP232_KEYLEN];
1848
1849                     rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1850                     if (rc != 0) break;
1851                         if (wrq->u.encoding.pointer) {
1852                                 if (copy_to_user(wrq->u.encoding.pointer,
1853                                                         abyKey,
1854                                                         wrq->u.encoding.length))
1855                                         rc = -EFAULT;
1856                         }
1857                 }
1858                 break;
1859
1860                 // Get the current Tx-Power
1861         case SIOCGIWTXPOW:
1862         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1863         rc = -EOPNOTSUPP;
1864                 break;
1865
1866         case SIOCSIWTXPOW:
1867         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1868         rc = -EOPNOTSUPP;
1869                 break;
1870
1871         case SIOCSIWRETRY:
1872
1873                 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
1874                 break;
1875
1876         case SIOCGIWRETRY:
1877
1878                 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
1879                 break;
1880
1881                 // Get range of parameters
1882         case SIOCGIWRANGE:
1883
1884                 {
1885                         struct iw_range range;
1886
1887                         rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
1888                         if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
1889                                 rc = -EFAULT;
1890                 }
1891
1892                 break;
1893
1894         case SIOCGIWPOWER:
1895
1896                 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
1897                 break;
1898
1899
1900         case SIOCSIWPOWER:
1901
1902                 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
1903                 break;
1904
1905
1906         case SIOCGIWSENS:
1907
1908             rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
1909                 break;
1910
1911         case SIOCSIWSENS:
1912         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
1913                 rc = -EOPNOTSUPP;
1914                 break;
1915
1916         case SIOCGIWAPLIST:
1917             {
1918             char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
1919
1920                     if (wrq->u.data.pointer) {
1921                         rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
1922                         if (rc == 0) {
1923                     if (copy_to_user(wrq->u.data.pointer,
1924                                                         buffer,
1925                                                        (wrq->u.data.length * (sizeof(struct sockaddr) +  sizeof(struct iw_quality)))
1926                                         ))
1927                                     rc = -EFAULT;
1928                         }
1929             }
1930         }
1931                 break;
1932
1933
1934 #ifdef WIRELESS_SPY
1935                 // Set the spy list
1936         case SIOCSIWSPY:
1937
1938         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1939                 rc = -EOPNOTSUPP;
1940                 break;
1941
1942                 // Get the spy list
1943         case SIOCGIWSPY:
1944
1945         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1946                 rc = -EOPNOTSUPP;
1947                 break;
1948
1949 #endif // WIRELESS_SPY
1950
1951         case SIOCGIWPRIV:
1952         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
1953                 rc = -EOPNOTSUPP;
1954 /*
1955                 if(wrq->u.data.pointer) {
1956                         wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
1957
1958                         if(copy_to_user(wrq->u.data.pointer,
1959                                         (u_char *) iwctl_private_args,
1960                                         sizeof(iwctl_private_args)))
1961                                 rc = -EFAULT;
1962                 }
1963 */
1964                 break;
1965
1966
1967 //2008-0409-07, <Add> by Einsn Liu
1968 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1969         case SIOCSIWAUTH:
1970                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n");
1971                 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
1972                 break;
1973
1974         case SIOCGIWAUTH:
1975                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
1976                 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
1977                 break;
1978
1979         case SIOCSIWGENIE:
1980                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
1981                 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1982                 break;
1983
1984         case SIOCGIWGENIE:
1985                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
1986                 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1987                 break;
1988
1989         case SIOCSIWENCODEEXT:
1990                 {
1991                         char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
1992                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
1993                         if(wrq->u.encoding.pointer){
1994                                 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
1995                                 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
1996                                         rc = -E2BIG;
1997                                         break;
1998                                 }
1999                                 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
2000                                         rc = -EFAULT;
2001                                         break;
2002                                 }
2003                         }else if(wrq->u.encoding.length != 0){
2004                                 rc = -EINVAL;
2005                                 break;
2006                         }
2007                         rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
2008                 }
2009                 break;
2010
2011         case SIOCGIWENCODEEXT:
2012                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
2013                 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
2014                 break;
2015
2016         case SIOCSIWMLME:
2017                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
2018                 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
2019                 break;
2020
2021 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2022 //End Add -- //2008-0409-07, <Add> by Einsn Liu
2023
2024     case IOCTL_CMD_TEST:
2025
2026                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2027                     rc = -EFAULT;
2028                     break;
2029                 } else {
2030                     rc = 0;
2031                 }
2032         pReq = (PSCmdRequest)rq;
2033
2034    //20080130-01,<Remark> by Mike Liu
2035       // if(pDevice->bLinkPass==TRUE)
2036           pReq->wResult = MAGIC_CODE;         //Linking status:0x3142
2037    //20080130-02,<Remark> by Mike Liu
2038       //  else
2039       //         pReq->wResult = MAGIC_CODE+1;    //disconnect status:0x3143
2040         break;
2041
2042     case IOCTL_CMD_SET:
2043                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
2044                        (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
2045                 {
2046                     rc = -EFAULT;
2047                     break;
2048                 } else {
2049                     rc = 0;
2050                 }
2051
2052             if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
2053                     return -EBUSY;
2054             }
2055         rc = private_ioctl(pDevice, rq);
2056         clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
2057         break;
2058
2059     case IOCTL_CMD_HOSTAPD:
2060
2061                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2062                     rc = -EFAULT;
2063                     break;
2064                 } else {
2065                     rc = 0;
2066                 }
2067
2068                 rc = hostap_ioctl(pDevice, &wrq->u.data);
2069         break;
2070
2071     case IOCTL_CMD_WPA:
2072
2073                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2074                     rc = -EFAULT;
2075                     break;
2076                 } else {
2077                     rc = 0;
2078                 }
2079
2080                 rc = wpa_ioctl(pDevice, &wrq->u.data);
2081         break;
2082
2083         case SIOCETHTOOL:
2084         return ethtool_ioctl(dev, (void *) rq->ifr_data);
2085         // All other calls are currently unsupported
2086
2087         default:
2088                 rc = -EOPNOTSUPP;
2089         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2090
2091
2092     }
2093
2094     if (pDevice->bCommit) {
2095        if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2096            netif_stop_queue(pDevice->dev);
2097            spin_lock_irq(&pDevice->lock);
2098            bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL);
2099            spin_unlock_irq(&pDevice->lock);
2100        }
2101        else {
2102            DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2103            spin_lock_irq(&pDevice->lock);
2104 //2007-1121-01<Modify>by EinsnLiu
2105             if (pDevice->bLinkPass&&
2106                   memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2107                   bScheduleCommand((HANDLE)pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2108              } else {
2109            pDevice->bLinkPass = FALSE;
2110            pMgmt->eCurrState = WMAC_STATE_IDLE;
2111            memset(pMgmt->abyCurrBSSID, 0, 6);
2112                  }
2113            ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2114 //End Modify
2115            netif_stop_queue(pDevice->dev);
2116 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2117            pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2118            if(pDevice->bWPASuppWextEnabled !=TRUE)
2119 #endif
2120            bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID);
2121            bScheduleCommand((HANDLE) pDevice, WLAN_CMD_SSID, NULL);
2122            spin_unlock_irq(&pDevice->lock);
2123       }
2124       pDevice->bCommit = FALSE;
2125     }
2126
2127
2128     return rc;
2129 }
2130
2131
2132 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2133 {
2134         u32 ethcmd;
2135
2136         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
2137                 return -EFAULT;
2138
2139         switch (ethcmd) {
2140         case ETHTOOL_GDRVINFO: {
2141                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2142                 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2143                 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2144                 if (copy_to_user(useraddr, &info, sizeof(info)))
2145                         return -EFAULT;
2146                 return 0;
2147         }
2148
2149         }
2150
2151         return -EOPNOTSUPP;
2152 }
2153
2154
2155 /*------------------------------------------------------------------*/
2156
2157
2158 MODULE_DEVICE_TABLE(usb, vntwusb_table);
2159
2160
2161 static struct usb_driver vntwusb_driver = {
2162             .name =             DEVICE_NAME,
2163             .probe =    vntwusb_found1,
2164             .disconnect =       vntwusb_disconnect,
2165             .id_table = vntwusb_table,
2166
2167 //2008-0920-01<Add>by MikeLiu
2168 //for supporting S3 & S4 function
2169 #ifdef CONFIG_PM
2170            .suspend = vntwusb_suspend,
2171            .resume = vntwusb_resume,
2172 #endif
2173 };
2174
2175 static int __init vntwusb_init_module(void)
2176 {
2177     printk(KERN_NOTICE DEVICE_FULL_DRV_NAM " " DEVICE_VERSION);
2178     return usb_register(&vntwusb_driver);
2179 }
2180
2181 static void __exit vntwusb_cleanup_module(void)
2182 {
2183         usb_deregister(&vntwusb_driver);
2184 }
2185
2186 module_init(vntwusb_init_module);
2187 module_exit(vntwusb_cleanup_module);
2188