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