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[] = {
 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 unsigned char *Config_FileOperation(PSDevice pDevice);
 281 static int Config_FileGetParameter(unsigned char *string,
 282                                    unsigned char *dest,
 283                                    unsigned char *source);
 284
 285 static BOOL device_release_WPADEV(PSDevice pDevice);
 286
 287 static void usb_device_reset(PSDevice pDevice);
 288
 289
 290
 291 /*---------------------  Export Variables  --------------------------*/
 292
 293 /*---------------------  Export Functions  --------------------------*/
 294
 295
 296 static void
 297 device_set_options(PSDevice pDevice) {
 298
 299     BYTE    abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 300     BYTE    abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
 301     u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
 302
 303     memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
 304     memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
 305     memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, ETH_ALEN);
 306
 307     pDevice->cbTD = TX_DESC_DEF0;
 308     pDevice->cbRD = RX_DESC_DEF0;
 309     pDevice->uChannel = CHANNEL_DEF;
 310     pDevice->wRTSThreshold = RTS_THRESH_DEF;
 311     pDevice->wFragmentationThreshold = FRAG_THRESH_DEF;
 312     pDevice->byShortRetryLimit = SHORT_RETRY_DEF;
 313     pDevice->byLongRetryLimit = LONG_RETRY_DEF;
 314     pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
 315     pDevice->byShortPreamble = PREAMBLE_TYPE_DEF;
 316     pDevice->ePSMode = PS_MODE_DEF;
 317     pDevice->b11hEnable = X80211h_MODE_DEF;
 318     pDevice->eOPMode = OP_MODE_DEF;
 319     pDevice->uConnectionRate = DATA_RATE_DEF;
 320     if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = TRUE;
 321     pDevice->byBBType = BBP_TYPE_DEF;
 322     pDevice->byPacketType = pDevice->byBBType;
 323     pDevice->byAutoFBCtrl = AUTO_FB_0;
 324     pDevice->bUpdateBBVGA = TRUE;
 325     pDevice->byFOETuning = 0;
 326     pDevice->byAutoPwrTunning = 0;
 327     pDevice->wCTSDuration = 0;
 328     pDevice->byPreambleType = 0;
 329     pDevice->bExistSWNetAddr = FALSE;
 330 //    pDevice->bDiversityRegCtlON = TRUE;
 331     pDevice->bDiversityRegCtlON = FALSE;
 332 }
 333
 334
 335 static void device_init_diversity_timer(PSDevice pDevice)
 336 {
 337     init_timer(&pDevice->TimerSQ3Tmax1);
 338     pDevice->TimerSQ3Tmax1.data = (unsigned long)pDevice;
 339     pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
 340     pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
 341
 342     init_timer(&pDevice->TimerSQ3Tmax2);
 343     pDevice->TimerSQ3Tmax2.data = (unsigned long)pDevice;
 344     pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
 345     pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
 346
 347     init_timer(&pDevice->TimerSQ3Tmax3);
 348     pDevice->TimerSQ3Tmax3.data = (unsigned long)pDevice;
 349     pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerSQ3Tmax3CallBack;
 350     pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
 351
 352     return;
 353 }
 354
 355
 356 //
 357 // Initialiation of MAC & BBP registers
 358 //
 359
 360 static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType)
 361 {
 362     u8 abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 363     u8 abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
 364     u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
 365     BYTE            byAntenna;
 366     unsigned int            ii;
 367     CMD_CARD_INIT   sInitCmd;
 368     int ntStatus = STATUS_SUCCESS;
 369     RSP_CARD_INIT   sInitRsp;
 370     PSMgmtObject    pMgmt = &(pDevice->sMgmtObj);
 371     BYTE            byTmp;
 372     BYTE            byCalibTXIQ = 0;
 373     BYTE            byCalibTXDC = 0;
 374     BYTE            byCalibRXIQ = 0;
 375
 376     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---->INIbInitAdapter. [%d][%d]\n", InitType, pDevice->byPacketType);
 377         spin_lock_irq(&pDevice->lock);
 378         if (InitType == DEVICE_INIT_COLD) {
 379                 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
 380                 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
 381                 memcpy(pDevice->abySNAP_Bridgetunnel,
 382                        abySNAP_Bridgetunnel,
 383                        ETH_ALEN);
 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,
 609                pDevice->abyPermanentNetAddr,
 610                ETH_ALEN);
 611
 612         // if exist SW network address, use SW network address.
 613
 614         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %pM\n",
 615                 pDevice->abyCurrentNetAddr);
 616     }
 617
 618     // Set BB and packet type at the same time.
 619     // Set Short Slot Time, xIFS, and RSPINF.
 620     if (pDevice->byBBType == BB_TYPE_11A) {
 621         CARDbAddBasicRate(pDevice, RATE_6M);
 622         pDevice->bShortSlotTime = TRUE;
 623     } else {
 624         CARDbAddBasicRate(pDevice, RATE_1M);
 625         pDevice->bShortSlotTime = FALSE;
 626     }
 627     BBvSetShortSlotTime(pDevice);
 628     CARDvSetBSSMode(pDevice);
 629
 630     if (pDevice->bUpdateBBVGA) {
 631         pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
 632         pDevice->byBBVGANew = pDevice->byBBVGACurrent;
 633         BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
 634     }
 635
 636     pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];
 637     pDevice->bHWRadioOff = FALSE;
 638     if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) {
 639         ntStatus = CONTROLnsRequestIn(pDevice,
 640                                     MESSAGE_TYPE_READ,
 641                                     MAC_REG_GPIOCTL1,
 642                                     MESSAGE_REQUEST_MACREG,
 643                                     1,
 644                                     &byTmp);
 645
 646         if ( ntStatus != STATUS_SUCCESS ) {
 647             spin_unlock_irq(&pDevice->lock);
 648             return FALSE;
 649         }
 650         if ( (byTmp & GPIO3_DATA) == 0 ) {
 651             pDevice->bHWRadioOff = TRUE;
 652             MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
 653         } else {
 654             MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
 655             pDevice->bHWRadioOff = FALSE;
 656         }
 657
 658     } //EEP_RADIOCTL_ENABLE
 659
 660     ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
 661     ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
 662     MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01);
 663
 664     if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) {
 665         CARDbRadioPowerOff(pDevice);
 666     } else {
 667         CARDbRadioPowerOn(pDevice);
 668     }
 669
 670     spin_unlock_irq(&pDevice->lock);
 671     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");
 672     return TRUE;
 673 }
 674
 675 static BOOL device_release_WPADEV(PSDevice pDevice)
 676 {
 677   viawget_wpa_header *wpahdr;
 678   int ii=0;
 679  // wait_queue_head_t   Set_wait;
 680   //send device close to wpa_supplicnat layer
 681     if (pDevice->bWPADEVUp==TRUE) {
 682                  wpahdr = (viawget_wpa_header *)pDevice->skb->data;
 683                  wpahdr->type = VIAWGET_DEVICECLOSE_MSG;
 684                  wpahdr->resp_ie_len = 0;
 685                  wpahdr->req_ie_len = 0;
 686                  skb_put(pDevice->skb, sizeof(viawget_wpa_header));
 687                  pDevice->skb->dev = pDevice->wpadev;
 688                  skb_reset_mac_header(pDevice->skb);
 689                  pDevice->skb->pkt_type = PACKET_HOST;
 690                  pDevice->skb->protocol = htons(ETH_P_802_2);
 691                  memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
 692                  netif_rx(pDevice->skb);
 693                  pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
 694
 695  //wait release WPADEV
 696               //    init_waitqueue_head(&Set_wait);
 697               //    wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ);    //1s wait
 698               while(pDevice->bWPADEVUp==TRUE) {
 699                 set_current_state(TASK_UNINTERRUPTIBLE);
 700                  schedule_timeout (HZ/20);          //wait 50ms
 701                  ii++;
 702                 if(ii>20)
 703                   break;
 704               }
 705            }
 706     return TRUE;
 707 }
 708
 709 #ifdef CONFIG_PM        /* Minimal support for suspend and resume */
 710
 711 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message)
 712 {
 713         PSDevice device = usb_get_intfdata(intf);
 714
 715         if (!device || !device->dev)
 716                 return -ENODEV;
 717
 718         if (device->flags & DEVICE_FLAGS_OPENED)
 719                 device_close(device->dev);
 720
 721         return 0;
 722 }
 723
 724 static int vt6656_resume(struct usb_interface *intf)
 725 {
 726         PSDevice device = usb_get_intfdata(intf);
 727
 728         if (!device || !device->dev)
 729                 return -ENODEV;
 730
 731         if (!(device->flags & DEVICE_FLAGS_OPENED))
 732                 device_open(device->dev);
 733
 734         return 0;
 735 }
 736
 737 #endif /* CONFIG_PM */
 738
 739 static const struct net_device_ops device_netdev_ops = {
 740     .ndo_open               = device_open,
 741     .ndo_stop               = device_close,
 742     .ndo_do_ioctl           = device_ioctl,
 743     .ndo_get_stats          = device_get_stats,
 744     .ndo_start_xmit         = device_xmit,
 745     .ndo_set_rx_mode        = device_set_multi,
 746 };
 747
 748 static int __devinit
 749 vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
 750 {
 751         u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
 752         struct usb_device *udev = interface_to_usbdev(intf);
 753         int rc = 0;
 754         struct net_device *netdev = NULL;
 755         PSDevice pDevice = NULL;
 756
 757         printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
 758         printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
 759
 760         udev = usb_get_dev(udev);
 761         netdev = alloc_etherdev(sizeof(DEVICE_INFO));
 762         if (!netdev) {
 763                 printk(KERN_ERR DEVICE_NAME ": allocate net device failed\n");
 764                 rc = -ENOMEM;
 765                 goto err_nomem;
 766         }
 767
 768         pDevice = netdev_priv(netdev);
 769         memset(pDevice, 0, sizeof(DEVICE_INFO));
 770
 771         pDevice->dev = netdev;
 772         pDevice->usb = udev;
 773
 774         device_set_options(pDevice);
 775         spin_lock_init(&pDevice->lock);
 776
 777         pDevice->tx_80211 = device_dma0_tx_80211;
 778         pDevice->sMgmtObj.pAdapter = (void *) pDevice;
 779
 780         netdev->netdev_ops = &device_netdev_ops;
 781         netdev->wireless_handlers =
 782                 (struct iw_handler_def *) &iwctl_handler_def;
 783
 784         usb_set_intfdata(intf, pDevice);
 785         SET_NETDEV_DEV(netdev, &intf->dev);
 786         memcpy(pDevice->dev->dev_addr, fake_mac, ETH_ALEN);
 787         rc = register_netdev(netdev);
 788         if (rc) {
 789                 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
 790                 goto err_netdev;
 791         }
 792
 793         usb_device_reset(pDevice);
 794
 795         {
 796                 union iwreq_data wrqu;
 797                 memset(&wrqu, 0, sizeof(wrqu));
 798                 wrqu.data.flags = RT_INSMOD_EVENT_FLAG;
 799                 wrqu.data.length = IFNAMSIZ;
 800                 wireless_send_event(pDevice->dev,
 801                                     IWEVCUSTOM,
 802                                     &wrqu,
 803                                     pDevice->dev->name);
 804         }
 805
 806         return 0;
 807
 808 err_netdev:
 809         free_netdev(netdev);
 810 err_nomem:
 811         usb_put_dev(udev);
 812
 813         return rc;
 814 }
 815
 816 static void device_free_tx_bufs(PSDevice pDevice)
 817 {
 818     PUSB_SEND_CONTEXT pTxContext;
 819     int ii;
 820
 821     for (ii = 0; ii < pDevice->cbTD; ii++) {
 822
 823         pTxContext = pDevice->apTD[ii];
 824         //de-allocate URBs
 825         if (pTxContext->pUrb) {
 826             usb_kill_urb(pTxContext->pUrb);
 827             usb_free_urb(pTxContext->pUrb);
 828         }
 829         kfree(pTxContext);
 830     }
 831     return;
 832 }
 833
 834
 835 static void device_free_rx_bufs(PSDevice pDevice)
 836 {
 837     PRCB pRCB;
 838     int ii;
 839
 840     for (ii = 0; ii < pDevice->cbRD; ii++) {
 841
 842         pRCB = pDevice->apRCB[ii];
 843         //de-allocate URBs
 844         if (pRCB->pUrb) {
 845             usb_kill_urb(pRCB->pUrb);
 846             usb_free_urb(pRCB->pUrb);
 847         }
 848         //de-allocate skb
 849         if (pRCB->skb)
 850             dev_kfree_skb(pRCB->skb);
 851     }
 852     kfree(pDevice->pRCBMem);
 853
 854     return;
 855 }
 856
 857 static void usb_device_reset(PSDevice pDevice)
 858 {
 859  int status;
 860  status = usb_reset_device(pDevice->usb);
 861         if (status)
 862             printk("usb_device_reset fail status=%d\n",status);
 863         return ;
 864 }
 865
 866 static void device_free_int_bufs(PSDevice pDevice)
 867 {
 868     kfree(pDevice->intBuf.pDataBuf);
 869     return;
 870 }
 871
 872
 873 static BOOL device_alloc_bufs(PSDevice pDevice) {
 874
 875     PUSB_SEND_CONTEXT pTxContext;
 876     PRCB pRCB;
 877     int ii;
 878
 879
 880     for (ii = 0; ii < pDevice->cbTD; ii++) {
 881
 882         pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
 883         if (pTxContext == NULL) {
 884             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
 885             goto free_tx;
 886         }
 887         pDevice->apTD[ii] = pTxContext;
 888         pTxContext->pDevice = (void *) pDevice;
 889         //allocate URBs
 890         pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
 891         if (pTxContext->pUrb == NULL) {
 892             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
 893             goto free_tx;
 894         }
 895         pTxContext->bBoolInUse = FALSE;
 896     }
 897
 898     // allocate rcb mem
 899     pDevice->pRCBMem = kmalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
 900     if (pDevice->pRCBMem == NULL) {
 901         DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
 902         goto free_tx;
 903     }
 904
 905
 906     pDevice->FirstRecvFreeList = NULL;
 907     pDevice->LastRecvFreeList = NULL;
 908     pDevice->FirstRecvMngList = NULL;
 909     pDevice->LastRecvMngList = NULL;
 910     pDevice->NumRecvFreeList = 0;
 911     memset(pDevice->pRCBMem, 0, (sizeof(RCB) * pDevice->cbRD));
 912     pRCB = (PRCB) pDevice->pRCBMem;
 913
 914     for (ii = 0; ii < pDevice->cbRD; ii++) {
 915
 916         pDevice->apRCB[ii] = pRCB;
 917         pRCB->pDevice = (void *) pDevice;
 918         //allocate URBs
 919         pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
 920
 921         if (pRCB->pUrb == NULL) {
 922             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
 923             goto free_rx_tx;
 924         }
 925         pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
 926         if (pRCB->skb == NULL) {
 927             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
 928             goto free_rx_tx;
 929         }
 930         pRCB->skb->dev = pDevice->dev;
 931         pRCB->bBoolInUse = FALSE;
 932         EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
 933         pDevice->NumRecvFreeList++;
 934         pRCB++;
 935     }
 936
 937
 938         pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
 939         if (pDevice->pControlURB == NULL) {
 940             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
 941             goto free_rx_tx;
 942         }
 943
 944         pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
 945         if (pDevice->pInterruptURB == NULL) {
 946             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
 947             usb_free_urb(pDevice->pControlURB);
 948             goto free_rx_tx;
 949         }
 950
 951     pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
 952         if (pDevice->intBuf.pDataBuf == NULL) {
 953             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
 954             usb_free_urb(pDevice->pControlURB);
 955             usb_free_urb(pDevice->pInterruptURB);
 956             goto free_rx_tx;
 957         }
 958
 959     return TRUE;
 960
 961 free_rx_tx:
 962     device_free_rx_bufs(pDevice);
 963
 964 free_tx:
 965     device_free_tx_bufs(pDevice);
 966
 967         return FALSE;
 968 }
 969
 970
 971
 972
 973 static BOOL device_init_defrag_cb(PSDevice pDevice) {
 974     int i;
 975     PSDeFragControlBlock pDeF;
 976
 977     /* Init the fragment ctl entries */
 978     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
 979         pDeF = &(pDevice->sRxDFCB[i]);
 980         if (!device_alloc_frag_buf(pDevice, pDeF)) {
 981             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
 982                 pDevice->dev->name);
 983             goto free_frag;
 984         }
 985     }
 986     pDevice->cbDFCB = CB_MAX_RX_FRAG;
 987     pDevice->cbFreeDFCB = pDevice->cbDFCB;
 988     return TRUE;
 989
 990 free_frag:
 991     device_free_frag_bufs(pDevice);
 992     return FALSE;
 993 }
 994
 995
 996
 997 static void device_free_frag_bufs(PSDevice pDevice) {
 998     PSDeFragControlBlock pDeF;
 999     int i;
1000
1001     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1002
1003         pDeF = &(pDevice->sRxDFCB[i]);
1004
1005         if (pDeF->skb)
1006             dev_kfree_skb(pDeF->skb);
1007     }
1008 }
1009
1010
1011
1012 BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1013
1014     pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1015     if (pDeF->skb == NULL)
1016         return FALSE;
1017     ASSERT(pDeF->skb);
1018     pDeF->skb->dev = pDevice->dev;
1019
1020     return TRUE;
1021 }
1022
1023
1024 /*-----------------------------------------------------------------*/
1025
1026 static int  device_open(struct net_device *dev) {
1027     PSDevice    pDevice=(PSDevice) netdev_priv(dev);
1028
1029      extern SWPAResult wpa_Result;
1030      memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1031      wpa_Result.proto = 0;
1032      wpa_Result.key_mgmt = 0;
1033      wpa_Result.eap_type = 0;
1034      wpa_Result.authenticated = FALSE;
1035      pDevice->fWPA_Authened = FALSE;
1036
1037     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
1038
1039
1040     pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
1041
1042     if (device_alloc_bufs(pDevice) == FALSE) {
1043         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
1044         return -ENOMEM;
1045     }
1046
1047     if (device_init_defrag_cb(pDevice)== FALSE) {
1048         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragement cb fail \n");
1049         goto free_rx_tx;
1050     }
1051
1052     MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
1053     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
1054     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
1055     MP_SET_FLAG(pDevice, fMP_POST_READS);
1056     MP_SET_FLAG(pDevice, fMP_POST_WRITES);
1057
1058    //read config file
1059     Read_config_file(pDevice);
1060
1061     if (device_init_registers(pDevice, DEVICE_INIT_COLD) == FALSE) {
1062         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
1063         goto free_all;
1064     }
1065
1066     device_set_multi(pDevice->dev);
1067     // Init for Key Management
1068
1069     KeyvInitTable(pDevice,&pDevice->sKey);
1070     memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1071     memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1072     pDevice->bStopTx0Pkt = FALSE;
1073     pDevice->bStopDataPkt = FALSE;
1074     pDevice->bRoaming = FALSE;
1075     pDevice->bIsRoaming = FALSE;
1076     pDevice->bEnableRoaming = FALSE;
1077     if (pDevice->bDiversityRegCtlON) {
1078         device_init_diversity_timer(pDevice);
1079     }
1080
1081     vMgrObjectInit(pDevice);
1082     tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
1083     tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
1084     tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
1085     add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback));
1086     pDevice->int_interval = 100;  //Max 100 microframes.
1087     pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1088
1089     pDevice->bIsRxWorkItemQueued = TRUE;
1090     pDevice->fKillEventPollingThread = FALSE;
1091     pDevice->bEventAvailable = FALSE;
1092
1093    pDevice->bWPADEVUp = FALSE;
1094 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1095      pDevice->bwextstep0 = FALSE;
1096      pDevice->bwextstep1 = FALSE;
1097      pDevice->bwextstep2 = FALSE;
1098      pDevice->bwextstep3 = FALSE;
1099      pDevice->bWPASuppWextEnabled = FALSE;
1100 #endif
1101     pDevice->byReAssocCount = 0;
1102
1103     RXvWorkItem(pDevice);
1104     INTvWorkItem(pDevice);
1105
1106     // Patch: if WEP key already set by iwconfig but device not yet open
1107     if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1108          spin_lock_irq(&pDevice->lock);
1109          KeybSetDefaultKey( pDevice,
1110                             &(pDevice->sKey),
1111                             pDevice->byKeyIndex | (1 << 31),
1112                             pDevice->uKeyLength,
1113                             NULL,
1114                             pDevice->abyKey,
1115                             KEY_CTL_WEP
1116                           );
1117          spin_unlock_irq(&pDevice->lock);
1118          pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1119     }
1120
1121     if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1122                 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1123         }
1124         else {
1125         //mike:mark@2008-11-10
1126           bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1127           /* bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL); */
1128     }
1129
1130
1131     netif_stop_queue(pDevice->dev);
1132     pDevice->flags |= DEVICE_FLAGS_OPENED;
1133
1134 {
1135   union iwreq_data      wrqu;
1136   memset(&wrqu, 0, sizeof(wrqu));
1137   wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1138   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1139 }
1140
1141     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1142     return 0;
1143
1144 free_all:
1145     device_free_frag_bufs(pDevice);
1146 free_rx_tx:
1147     device_free_rx_bufs(pDevice);
1148     device_free_tx_bufs(pDevice);
1149     device_free_int_bufs(pDevice);
1150         usb_kill_urb(pDevice->pControlURB);
1151         usb_kill_urb(pDevice->pInterruptURB);
1152     usb_free_urb(pDevice->pControlURB);
1153     usb_free_urb(pDevice->pInterruptURB);
1154
1155     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1156     return -ENOMEM;
1157 }
1158
1159
1160
1161 static int  device_close(struct net_device *dev) {
1162     PSDevice    pDevice=(PSDevice) netdev_priv(dev);
1163     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1164
1165         int uu;
1166
1167     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1168     if (pDevice == NULL)
1169         return -ENODEV;
1170
1171 {
1172   union iwreq_data      wrqu;
1173   memset(&wrqu, 0, sizeof(wrqu));
1174   wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1175   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1176 }
1177
1178     if (pDevice->bLinkPass) {
1179         bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1180         mdelay(30);
1181     }
1182
1183 device_release_WPADEV(pDevice);
1184
1185         memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1186         pMgmt->bShareKeyAlgorithm = FALSE;
1187         pDevice->bEncryptionEnable = FALSE;
1188         pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1189         spin_lock_irq(&pDevice->lock);
1190         for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1191                 MACvDisableKeyEntry(pDevice,uu);
1192         spin_unlock_irq(&pDevice->lock);
1193
1194     if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1195         MACbShutdown(pDevice);
1196     }
1197     netif_stop_queue(pDevice->dev);
1198     MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1199     MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1200     MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1201     pDevice->fKillEventPollingThread = TRUE;
1202     del_timer(&pDevice->sTimerCommand);
1203     del_timer(&pMgmt->sTimerSecondCallback);
1204
1205     del_timer(&pDevice->sTimerTxData);
1206
1207     if (pDevice->bDiversityRegCtlON) {
1208         del_timer(&pDevice->TimerSQ3Tmax1);
1209         del_timer(&pDevice->TimerSQ3Tmax2);
1210         del_timer(&pDevice->TimerSQ3Tmax3);
1211     }
1212     tasklet_kill(&pDevice->RxMngWorkItem);
1213     tasklet_kill(&pDevice->ReadWorkItem);
1214     tasklet_kill(&pDevice->EventWorkItem);
1215
1216    pDevice->bRoaming = FALSE;
1217    pDevice->bIsRoaming = FALSE;
1218    pDevice->bEnableRoaming = FALSE;
1219     pDevice->bCmdRunning = FALSE;
1220     pDevice->bLinkPass = FALSE;
1221     memset(pMgmt->abyCurrBSSID, 0, 6);
1222     pMgmt->eCurrState = WMAC_STATE_IDLE;
1223
1224         pDevice->flags &= ~DEVICE_FLAGS_OPENED;
1225
1226     device_free_tx_bufs(pDevice);
1227     device_free_rx_bufs(pDevice);
1228     device_free_int_bufs(pDevice);
1229     device_free_frag_bufs(pDevice);
1230
1231         usb_kill_urb(pDevice->pControlURB);
1232         usb_kill_urb(pDevice->pInterruptURB);
1233     usb_free_urb(pDevice->pControlURB);
1234     usb_free_urb(pDevice->pInterruptURB);
1235
1236     BSSvClearNodeDBTable(pDevice, 0);
1237
1238     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1239
1240     return 0;
1241 }
1242
1243 static void __devexit vt6656_disconnect(struct usb_interface *intf)
1244 {
1245         PSDevice device = usb_get_intfdata(intf);
1246
1247         if (!device)
1248                 return;
1249
1250         {
1251                 union iwreq_data req;
1252                 memset(&req, 0, sizeof(req));
1253                 req.data.flags = RT_RMMOD_EVENT_FLAG;
1254                 wireless_send_event(device->dev, IWEVCUSTOM, &req, NULL);
1255         }
1256
1257         device_release_WPADEV(device);
1258
1259         if (device->firmware)
1260                 release_firmware(device->firmware);
1261
1262         usb_set_intfdata(intf, NULL);
1263         usb_put_dev(interface_to_usbdev(intf));
1264
1265         device->flags |= DEVICE_FLAGS_UNPLUG;
1266
1267         if (device->dev) {
1268                 unregister_netdev(device->dev);
1269                 wpa_set_wpadev(device, 0);
1270                 free_netdev(device->dev);
1271         }
1272 }
1273
1274 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1275 {
1276         PSDevice pDevice = netdev_priv(dev);
1277
1278         spin_lock_irq(&pDevice->lock);
1279
1280         if (unlikely(pDevice->bStopTx0Pkt))
1281                 dev_kfree_skb_irq(skb);
1282         else
1283                 vDMA0_tx_80211(pDevice, skb);
1284
1285         spin_unlock_irq(&pDevice->lock);
1286
1287         return NETDEV_TX_OK;
1288 }
1289
1290 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1291 {
1292         PSDevice pDevice = netdev_priv(dev);
1293         struct net_device_stats *stats = &pDevice->stats;
1294
1295         spin_lock_irq(&pDevice->lock);
1296
1297         netif_stop_queue(dev);
1298
1299         if (!pDevice->bLinkPass) {
1300                 dev_kfree_skb_irq(skb);
1301                 goto out;
1302         }
1303
1304         if (pDevice->bStopDataPkt) {
1305                 dev_kfree_skb_irq(skb);
1306                 stats->tx_dropped++;
1307                 goto out;
1308         }
1309
1310         if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1311                 if (netif_queue_stopped(dev))
1312                         netif_wake_queue(dev);
1313         }
1314
1315 out:
1316         spin_unlock_irq(&pDevice->lock);
1317
1318         return NETDEV_TX_OK;
1319 }
1320
1321 static unsigned const ethernet_polynomial = 0x04c11db7U;
1322 static inline u32 ether_crc(int length, unsigned char *data)
1323 {
1324     int crc = -1;
1325
1326     while(--length >= 0) {
1327         unsigned char current_octet = *data++;
1328         int bit;
1329         for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1330             crc = (crc << 1) ^
1331                 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1332         }
1333     }
1334     return crc;
1335 }
1336
1337 //find out  the start  position of str2 from str1
1338 static unsigned char *kstrstr(const unsigned char *str1,
1339                               const unsigned char *str2) {
1340   int str1_len = strlen(str1);
1341   int str2_len = strlen(str2);
1342
1343   while (str1_len >= str2_len) {
1344        str1_len--;
1345       if(memcmp(str1,str2,str2_len)==0)
1346         return (unsigned char *) str1;
1347         str1++;
1348   }
1349   return NULL;
1350 }
1351
1352 static int Config_FileGetParameter(unsigned char *string,
1353                                    unsigned char *dest,
1354                                    unsigned char *source)
1355 {
1356   unsigned char buf1[100];
1357   unsigned char buf2[100];
1358   unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1359   int ii;
1360
1361     memset(buf1,0,100);
1362     strcat(buf1, string);
1363     strcat(buf1, "=");
1364     source+=strlen(buf1);
1365
1366 //find target string start point
1367     start_p = kstrstr(source,buf1);
1368     if (start_p == NULL)
1369         return FALSE;
1370
1371 //check if current config line is marked by "#" ??
1372     for (ii = 1; ; ii++) {
1373         if (memcmp(start_p - ii, "\n", 1) == 0)
1374                 break;
1375         if (memcmp(start_p - ii, "#", 1) == 0)
1376                 return FALSE;
1377     }
1378
1379 //find target string end point
1380      end_p = kstrstr(start_p,"\n");
1381      if (end_p == NULL) {       //can't find "\n",but don't care
1382           end_p=start_p+strlen(start_p);   //no include "\n"
1383        }
1384
1385    memset(buf2,0,100);
1386    memcpy(buf2,start_p,end_p-start_p);    //get the tartget line
1387    buf2[end_p-start_p]='\0';
1388
1389    //find value
1390    start_p = kstrstr(buf2,"=");
1391    if (start_p == NULL)
1392       return FALSE;
1393    memset(buf1,0,100);
1394    strcpy(buf1,start_p+1);
1395
1396   //except space
1397   tmp_p = buf1;
1398   while(*tmp_p != 0x00) {
1399         if(*tmp_p==' ')
1400             tmp_p++;
1401          else
1402           break;
1403   }
1404
1405    memcpy(dest,tmp_p,strlen(tmp_p));
1406  return TRUE;
1407 }
1408
1409 //if read fail,return NULL,or return data pointer;
1410 static unsigned char *Config_FileOperation(PSDevice pDevice)
1411 {
1412     unsigned char *config_path = CONFIG_PATH;
1413     unsigned char *buffer = NULL;
1414     struct file   *filp=NULL;
1415     mm_segment_t old_fs = get_fs();
1416     //int oldfsuid=0,oldfsgid=0;
1417     int result = 0;
1418
1419     set_fs (KERNEL_DS);
1420     /* Can't do this anymore, so we rely on correct filesystem permissions:
1421     //Make sure a caller can read or write power as root
1422     oldfsuid=current->fsuid;
1423     oldfsgid=current->fsgid;
1424     current->fsuid = 0;
1425     current->fsgid = 0;
1426     */
1427
1428     //open file
1429       filp = filp_open(config_path, O_RDWR, 0);
1430         if (IS_ERR(filp)) {
1431              printk("Config_FileOperation file Not exist\n");
1432              result=-1;
1433              goto error2;
1434           }
1435
1436      if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1437            printk("file %s cann't readable or writable?\n",config_path);
1438           result = -1;
1439           goto error1;
1440         }
1441
1442     buffer = kmalloc(1024, GFP_KERNEL);
1443     if(buffer==NULL) {
1444       printk("allocate mem for file fail?\n");
1445       result = -1;
1446       goto error1;
1447     }
1448
1449     if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1450      printk("read file error?\n");
1451      result = -1;
1452     }
1453
1454 error1:
1455   if(filp_close(filp,NULL))
1456        printk("Config_FileOperation:close file fail\n");
1457
1458 error2:
1459   set_fs (old_fs);
1460
1461   /*
1462   current->fsuid=oldfsuid;
1463   current->fsgid=oldfsgid;
1464   */
1465
1466 if(result!=0) {
1467     kfree(buffer);
1468     buffer=NULL;
1469 }
1470   return buffer;
1471 }
1472
1473 //return --->-1:fail;  >=0:successful
1474 static int Read_config_file(PSDevice pDevice) {
1475   int result = 0;
1476   unsigned char tmpbuffer[100];
1477   unsigned char *buffer = NULL;
1478
1479   //init config setting
1480  pDevice->config_file.ZoneType = -1;
1481  pDevice->config_file.eAuthenMode = -1;
1482  pDevice->config_file.eEncryptionStatus = -1;
1483
1484   buffer = Config_FileOperation(pDevice);
1485   if (buffer == NULL) {
1486      result =-1;
1487      return result;
1488   }
1489
1490 //get zonetype
1491 {
1492     memset(tmpbuffer,0,sizeof(tmpbuffer));
1493     if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1494     if(memcmp(tmpbuffer,"USA",3)==0) {
1495       pDevice->config_file.ZoneType=ZoneType_USA;
1496     }
1497     else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1498       pDevice->config_file.ZoneType=ZoneType_Japan;
1499     }
1500     else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1501      pDevice->config_file.ZoneType=ZoneType_Europe;
1502     }
1503     else {
1504       printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1505    }
1506  }
1507 }
1508
1509 //get other parameter
1510   {
1511         memset(tmpbuffer,0,sizeof(tmpbuffer));
1512        if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1513          pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1514        }
1515
1516         memset(tmpbuffer,0,sizeof(tmpbuffer));
1517        if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1518          pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1519        }
1520   }
1521
1522   kfree(buffer);
1523   return result;
1524 }
1525
1526 static void device_set_multi(struct net_device *dev) {
1527     PSDevice         pDevice = (PSDevice) netdev_priv(dev);
1528     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1529     u32              mc_filter[2];
1530     int              ii;
1531     struct netdev_hw_addr *ha;
1532     BYTE             pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1533     BYTE             byTmpMode = 0;
1534     int              rc;
1535
1536
1537         spin_lock_irq(&pDevice->lock);
1538     rc = CONTROLnsRequestIn(pDevice,
1539                             MESSAGE_TYPE_READ,
1540                             MAC_REG_RCR,
1541                             MESSAGE_REQUEST_MACREG,
1542                             1,
1543                             &byTmpMode
1544                             );
1545     if (rc == 0) pDevice->byRxMode = byTmpMode;
1546
1547     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1548
1549     if (dev->flags & IFF_PROMISC) {         // Set promiscuous.
1550         DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1551         // Unconditionally log net taps.
1552         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1553     }
1554     else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1555              (dev->flags & IFF_ALLMULTI)) {
1556         CONTROLnsRequestOut(pDevice,
1557                             MESSAGE_TYPE_WRITE,
1558                             MAC_REG_MAR0,
1559                             MESSAGE_REQUEST_MACREG,
1560                             8,
1561                             pbyData
1562                             );
1563         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1564     }
1565     else {
1566         memset(mc_filter, 0, sizeof(mc_filter));
1567         netdev_for_each_mc_addr(ha, dev) {
1568             int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1569             mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1570         }
1571         for (ii = 0; ii < 4; ii++) {
1572              MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1573              MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1574         }
1575         pDevice->byRxMode &= ~(RCR_UNICAST);
1576         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1577     }
1578
1579     if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1580         // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1581         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1582         pDevice->byRxMode &= ~(RCR_UNICAST);
1583     }
1584     ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1585     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1586         spin_unlock_irq(&pDevice->lock);
1587
1588 }
1589
1590
1591 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1592     PSDevice pDevice=(PSDevice) netdev_priv(dev);
1593
1594     return &pDevice->stats;
1595 }
1596
1597
1598 static int  device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1599         PSDevice                pDevice = (PSDevice)netdev_priv(dev);
1600     PSMgmtObject        pMgmt = &(pDevice->sMgmtObj);
1601     PSCmdRequest        pReq;
1602     //BOOL                bCommit = FALSE;
1603         struct iwreq *wrq = (struct iwreq *) rq;
1604         int                 rc =0;
1605
1606     if (pMgmt == NULL) {
1607         rc = -EFAULT;
1608         return rc;
1609     }
1610
1611     switch(cmd) {
1612
1613         case SIOCGIWNAME:
1614                 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1615                 break;
1616
1617         case SIOCSIWNWID:
1618         rc = -EOPNOTSUPP;
1619                 break;
1620
1621         case SIOCGIWNWID:     //0x8b03  support
1622         #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1623           rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
1624         #else
1625         rc = -EOPNOTSUPP;
1626         #endif
1627                 break;
1628
1629                 // Set frequency/channel
1630         case SIOCSIWFREQ:
1631             rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1632                 break;
1633
1634                 // Get frequency/channel
1635         case SIOCGIWFREQ:
1636                 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1637                 break;
1638
1639                 // Set desired network name (ESSID)
1640         case SIOCSIWESSID:
1641
1642                 {
1643                         char essid[IW_ESSID_MAX_SIZE+1];
1644                         if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1645                                 rc = -E2BIG;
1646                                 break;
1647                         }
1648                         if (copy_from_user(essid, wrq->u.essid.pointer,
1649                                            wrq->u.essid.length)) {
1650                                 rc = -EFAULT;
1651                                 break;
1652                         }
1653                         rc = iwctl_siwessid(dev, NULL,
1654                                             &(wrq->u.essid), essid);
1655                 }
1656                 break;
1657
1658
1659                 // Get current network name (ESSID)
1660         case SIOCGIWESSID:
1661
1662                 {
1663                         char essid[IW_ESSID_MAX_SIZE+1];
1664                         if (wrq->u.essid.pointer) {
1665                                 rc = iwctl_giwessid(dev, NULL,
1666                                                     &(wrq->u.essid), essid);
1667                                 if (copy_to_user(wrq->u.essid.pointer,
1668                                                          essid,
1669                                                          wrq->u.essid.length) )
1670                                         rc = -EFAULT;
1671                         }
1672                 }
1673                 break;
1674
1675         case SIOCSIWAP:
1676
1677                 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1678                 break;
1679
1680
1681                 // Get current Access Point (BSSID)
1682         case SIOCGIWAP:
1683                 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1684                 break;
1685
1686
1687                 // Set desired station name
1688         case SIOCSIWNICKN:
1689         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1690         rc = -EOPNOTSUPP;
1691                 break;
1692
1693                 // Get current station name
1694         case SIOCGIWNICKN:
1695         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1696         rc = -EOPNOTSUPP;
1697                 break;
1698
1699                 // Set the desired bit-rate
1700         case SIOCSIWRATE:
1701                 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1702                 break;
1703
1704         // Get the current bit-rate
1705         case SIOCGIWRATE:
1706
1707                 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1708                 break;
1709
1710         // Set the desired RTS threshold
1711         case SIOCSIWRTS:
1712
1713                 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
1714                 break;
1715
1716         // Get the current RTS threshold
1717         case SIOCGIWRTS:
1718
1719                 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1720                 break;
1721
1722                 // Set the desired fragmentation threshold
1723         case SIOCSIWFRAG:
1724
1725                 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1726             break;
1727
1728         // Get the current fragmentation threshold
1729         case SIOCGIWFRAG:
1730
1731                 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1732                 break;
1733
1734                 // Set mode of operation
1735         case SIOCSIWMODE:
1736         rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1737                 break;
1738
1739                 // Get mode of operation
1740         case SIOCGIWMODE:
1741                 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1742                 break;
1743
1744                 // Set WEP keys and mode
1745         case SIOCSIWENCODE:
1746                 {
1747             char abyKey[WLAN_WEP232_KEYLEN];
1748
1749                         if (wrq->u.encoding.pointer) {
1750
1751
1752                                 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
1753                                         rc = -E2BIG;
1754                                         break;
1755                                 }
1756                                 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
1757                                 if (copy_from_user(abyKey,
1758                                                   wrq->u.encoding.pointer,
1759                                                   wrq->u.encoding.length)) {
1760                                         rc = -EFAULT;
1761                                         break;
1762                                 }
1763                         } else if (wrq->u.encoding.length != 0) {
1764                                 rc = -EINVAL;
1765                                 break;
1766                         }
1767                         rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1768                 }
1769                 break;
1770
1771                 // Get the WEP keys and mode
1772         case SIOCGIWENCODE:
1773
1774                 if (!capable(CAP_NET_ADMIN)) {
1775                         rc = -EPERM;
1776                         break;
1777                 }
1778                 {
1779                     char abyKey[WLAN_WEP232_KEYLEN];
1780
1781                     rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1782                     if (rc != 0) break;
1783                         if (wrq->u.encoding.pointer) {
1784                                 if (copy_to_user(wrq->u.encoding.pointer,
1785                                                         abyKey,
1786                                                         wrq->u.encoding.length))
1787                                         rc = -EFAULT;
1788                         }
1789                 }
1790                 break;
1791
1792                 // Get the current Tx-Power
1793         case SIOCGIWTXPOW:
1794         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1795         rc = -EOPNOTSUPP;
1796                 break;
1797
1798         case SIOCSIWTXPOW:
1799         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1800         rc = -EOPNOTSUPP;
1801                 break;
1802
1803         case SIOCSIWRETRY:
1804
1805                 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
1806                 break;
1807
1808         case SIOCGIWRETRY:
1809
1810                 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
1811                 break;
1812
1813                 // Get range of parameters
1814         case SIOCGIWRANGE:
1815
1816                 {
1817                         struct iw_range range;
1818
1819                         rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
1820                         if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
1821                                 rc = -EFAULT;
1822                 }
1823
1824                 break;
1825
1826         case SIOCGIWPOWER:
1827
1828                 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
1829                 break;
1830
1831
1832         case SIOCSIWPOWER:
1833
1834                 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
1835                 break;
1836
1837
1838         case SIOCGIWSENS:
1839
1840             rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
1841                 break;
1842
1843         case SIOCSIWSENS:
1844         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
1845                 rc = -EOPNOTSUPP;
1846                 break;
1847
1848         case SIOCGIWAPLIST:
1849             {
1850             char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
1851
1852                     if (wrq->u.data.pointer) {
1853                         rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
1854                         if (rc == 0) {
1855                     if (copy_to_user(wrq->u.data.pointer,
1856                                                         buffer,
1857                                                        (wrq->u.data.length * (sizeof(struct sockaddr) +  sizeof(struct iw_quality)))
1858                                         ))
1859                                     rc = -EFAULT;
1860                         }
1861             }
1862         }
1863                 break;
1864
1865
1866 #ifdef WIRELESS_SPY
1867                 // Set the spy list
1868         case SIOCSIWSPY:
1869
1870         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1871                 rc = -EOPNOTSUPP;
1872                 break;
1873
1874                 // Get the spy list
1875         case SIOCGIWSPY:
1876
1877         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1878                 rc = -EOPNOTSUPP;
1879                 break;
1880
1881 #endif // WIRELESS_SPY
1882
1883         case SIOCGIWPRIV:
1884         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
1885                 rc = -EOPNOTSUPP;
1886 /*
1887                 if(wrq->u.data.pointer) {
1888                         wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
1889
1890                         if(copy_to_user(wrq->u.data.pointer,
1891                                         (u_char *) iwctl_private_args,
1892                                         sizeof(iwctl_private_args)))
1893                                 rc = -EFAULT;
1894                 }
1895 */
1896                 break;
1897
1898 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1899         case SIOCSIWAUTH:
1900                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH\n");
1901                 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
1902                 break;
1903
1904         case SIOCGIWAUTH:
1905                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
1906                 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
1907                 break;
1908
1909         case SIOCSIWGENIE:
1910                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
1911                 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1912                 break;
1913
1914         case SIOCGIWGENIE:
1915                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
1916                 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1917                 break;
1918
1919         case SIOCSIWENCODEEXT:
1920                 {
1921                         char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
1922                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
1923                         if(wrq->u.encoding.pointer){
1924                                 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
1925                                 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
1926                                         rc = -E2BIG;
1927                                         break;
1928                                 }
1929                                 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
1930                                         rc = -EFAULT;
1931                                         break;
1932                                 }
1933                         }else if(wrq->u.encoding.length != 0){
1934                                 rc = -EINVAL;
1935                                 break;
1936                         }
1937                         rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
1938                 }
1939                 break;
1940
1941         case SIOCGIWENCODEEXT:
1942                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
1943                 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
1944                 break;
1945
1946         case SIOCSIWMLME:
1947                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
1948                 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1949                 break;
1950
1951 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1952
1953     case IOCTL_CMD_TEST:
1954
1955                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1956                     rc = -EFAULT;
1957                     break;
1958                 } else {
1959                     rc = 0;
1960                 }
1961         pReq = (PSCmdRequest)rq;
1962
1963    //20080130-01,<Remark> by Mike Liu
1964       // if(pDevice->bLinkPass==TRUE)
1965           pReq->wResult = MAGIC_CODE;         //Linking status:0x3142
1966    //20080130-02,<Remark> by Mike Liu
1967       //  else
1968       //         pReq->wResult = MAGIC_CODE+1;    //disconnect status:0x3143
1969         break;
1970
1971     case IOCTL_CMD_SET:
1972                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
1973                        (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
1974                 {
1975                     rc = -EFAULT;
1976                     break;
1977                 } else {
1978                     rc = 0;
1979                 }
1980
1981             if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
1982                     return -EBUSY;
1983             }
1984         rc = private_ioctl(pDevice, rq);
1985         clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
1986         break;
1987
1988     case IOCTL_CMD_HOSTAPD:
1989
1990                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1991                     rc = -EFAULT;
1992                     break;
1993                 } else {
1994                     rc = 0;
1995                 }
1996
1997                 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
1998         break;
1999
2000     case IOCTL_CMD_WPA:
2001
2002                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2003                     rc = -EFAULT;
2004                     break;
2005                 } else {
2006                     rc = 0;
2007                 }
2008
2009                 rc = wpa_ioctl(pDevice, &wrq->u.data);
2010         break;
2011
2012         case SIOCETHTOOL:
2013         return ethtool_ioctl(dev, (void *) rq->ifr_data);
2014         // All other calls are currently unsupported
2015
2016         default:
2017                 rc = -EOPNOTSUPP;
2018         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2019
2020
2021     }
2022
2023     if (pDevice->bCommit) {
2024        if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2025            netif_stop_queue(pDevice->dev);
2026            spin_lock_irq(&pDevice->lock);
2027         bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
2028            spin_unlock_irq(&pDevice->lock);
2029        }
2030        else {
2031            DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2032            spin_lock_irq(&pDevice->lock);
2033 //2007-1121-01<Modify>by EinsnLiu
2034             if (pDevice->bLinkPass &&
2035                   memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2036                 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2037              } else {
2038            pDevice->bLinkPass = FALSE;
2039            pMgmt->eCurrState = WMAC_STATE_IDLE;
2040            memset(pMgmt->abyCurrBSSID, 0, 6);
2041                  }
2042            ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2043 //End Modify
2044            netif_stop_queue(pDevice->dev);
2045 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2046            pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2047            if (!pDevice->bWPASuppWextEnabled)
2048 #endif
2049                 bScheduleCommand((void *) pDevice,
2050                                  WLAN_CMD_BSSID_SCAN,
2051                                  pMgmt->abyDesireSSID);
2052                 bScheduleCommand((void *) pDevice,
2053                                  WLAN_CMD_SSID,
2054                                  NULL);
2055            spin_unlock_irq(&pDevice->lock);
2056       }
2057       pDevice->bCommit = FALSE;
2058     }
2059
2060
2061     return rc;
2062 }
2063
2064
2065 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2066 {
2067         u32 ethcmd;
2068
2069         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
2070                 return -EFAULT;
2071
2072         switch (ethcmd) {
2073         case ETHTOOL_GDRVINFO: {
2074                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2075                 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2076                 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2077                 if (copy_to_user(useraddr, &info, sizeof(info)))
2078                         return -EFAULT;
2079                 return 0;
2080         }
2081
2082         }
2083
2084         return -EOPNOTSUPP;
2085 }
2086
2087
2088 /*------------------------------------------------------------------*/
2089
2090 MODULE_DEVICE_TABLE(usb, vt6656_table);
2091
2092 static struct usb_driver vt6656_driver = {
2093         .name =         DEVICE_NAME,
2094         .probe =        vt6656_probe,
2095         .disconnect =   vt6656_disconnect,
2096         .id_table =     vt6656_table,
2097 #ifdef CONFIG_PM
2098         .suspend = vt6656_suspend,
2099         .resume = vt6656_resume,
2100 #endif /* CONFIG_PM */
2101 };
2102
2103 static int __init vt6656_init_module(void)
2104 {
2105     printk(KERN_NOTICE DEVICE_FULL_DRV_NAM " " DEVICE_VERSION);
2106     return usb_register(&vt6656_driver);
2107 }
2108
2109 static void __exit vt6656_cleanup_module(void)
2110 {
2111         usb_deregister(&vt6656_driver);
2112 }
2113
2114 module_init(vt6656_init_module);
2115 module_exit(vt6656_cleanup_module);