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     device_free_tx_bufs(pDevice);
1225     device_free_rx_bufs(pDevice);
1226     device_free_int_bufs(pDevice);
1227     device_free_frag_bufs(pDevice);
1228
1229         usb_kill_urb(pDevice->pControlURB);
1230         usb_kill_urb(pDevice->pInterruptURB);
1231     usb_free_urb(pDevice->pControlURB);
1232     usb_free_urb(pDevice->pInterruptURB);
1233
1234     BSSvClearNodeDBTable(pDevice, 0);
1235     pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1236
1237     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1238
1239     return 0;
1240 }
1241
1242 static void __devexit vt6656_disconnect(struct usb_interface *intf)
1243 {
1244         PSDevice device = usb_get_intfdata(intf);
1245
1246         if (!device)
1247                 return;
1248
1249         {
1250                 union iwreq_data req;
1251                 memset(&req, 0, sizeof(req));
1252                 req.data.flags = RT_RMMOD_EVENT_FLAG;
1253                 wireless_send_event(device->dev, IWEVCUSTOM, &req, NULL);
1254         }
1255
1256         device_release_WPADEV(device);
1257
1258         if (device->firmware)
1259                 release_firmware(device->firmware);
1260
1261         usb_set_intfdata(intf, NULL);
1262         usb_put_dev(interface_to_usbdev(intf));
1263
1264         device->flags |= DEVICE_FLAGS_UNPLUG;
1265
1266         if (device->dev) {
1267                 unregister_netdev(device->dev);
1268                 wpa_set_wpadev(device, 0);
1269                 free_netdev(device->dev);
1270         }
1271 }
1272
1273 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1274 {
1275         PSDevice pDevice = netdev_priv(dev);
1276
1277         spin_lock_irq(&pDevice->lock);
1278
1279         if (unlikely(pDevice->bStopTx0Pkt))
1280                 dev_kfree_skb_irq(skb);
1281         else
1282                 vDMA0_tx_80211(pDevice, skb);
1283
1284         spin_unlock_irq(&pDevice->lock);
1285
1286         return NETDEV_TX_OK;
1287 }
1288
1289 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1290 {
1291         PSDevice pDevice = netdev_priv(dev);
1292         struct net_device_stats *stats = &pDevice->stats;
1293
1294         spin_lock_irq(&pDevice->lock);
1295
1296         netif_stop_queue(dev);
1297
1298         if (!pDevice->bLinkPass) {
1299                 dev_kfree_skb_irq(skb);
1300                 goto out;
1301         }
1302
1303         if (pDevice->bStopDataPkt) {
1304                 dev_kfree_skb_irq(skb);
1305                 stats->tx_dropped++;
1306                 goto out;
1307         }
1308
1309         if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1310                 if (netif_queue_stopped(dev))
1311                         netif_wake_queue(dev);
1312         }
1313
1314 out:
1315         spin_unlock_irq(&pDevice->lock);
1316
1317         return NETDEV_TX_OK;
1318 }
1319
1320 static unsigned const ethernet_polynomial = 0x04c11db7U;
1321 static inline u32 ether_crc(int length, unsigned char *data)
1322 {
1323     int crc = -1;
1324
1325     while(--length >= 0) {
1326         unsigned char current_octet = *data++;
1327         int bit;
1328         for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1329             crc = (crc << 1) ^
1330                 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1331         }
1332     }
1333     return crc;
1334 }
1335
1336 //find out  the start  position of str2 from str1
1337 static unsigned char *kstrstr(const unsigned char *str1,
1338                               const unsigned char *str2) {
1339   int str1_len = strlen(str1);
1340   int str2_len = strlen(str2);
1341
1342   while (str1_len >= str2_len) {
1343        str1_len--;
1344       if(memcmp(str1,str2,str2_len)==0)
1345         return (unsigned char *) str1;
1346         str1++;
1347   }
1348   return NULL;
1349 }
1350
1351 static int Config_FileGetParameter(unsigned char *string,
1352                                    unsigned char *dest,
1353                                    unsigned char *source)
1354 {
1355   unsigned char buf1[100];
1356   unsigned char buf2[100];
1357   unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1358   int ii;
1359
1360     memset(buf1,0,100);
1361     strcat(buf1, string);
1362     strcat(buf1, "=");
1363     source+=strlen(buf1);
1364
1365 //find target string start point
1366     start_p = kstrstr(source,buf1);
1367     if (start_p == NULL)
1368         return FALSE;
1369
1370 //check if current config line is marked by "#" ??
1371     for (ii = 1; ; ii++) {
1372         if (memcmp(start_p - ii, "\n", 1) == 0)
1373                 break;
1374         if (memcmp(start_p - ii, "#", 1) == 0)
1375                 return FALSE;
1376     }
1377
1378 //find target string end point
1379      end_p = kstrstr(start_p,"\n");
1380      if (end_p == NULL) {       //can't find "\n",but don't care
1381           end_p=start_p+strlen(start_p);   //no include "\n"
1382        }
1383
1384    memset(buf2,0,100);
1385    memcpy(buf2,start_p,end_p-start_p);    //get the tartget line
1386    buf2[end_p-start_p]='\0';
1387
1388    //find value
1389    start_p = kstrstr(buf2,"=");
1390    if (start_p == NULL)
1391       return FALSE;
1392    memset(buf1,0,100);
1393    strcpy(buf1,start_p+1);
1394
1395   //except space
1396   tmp_p = buf1;
1397   while(*tmp_p != 0x00) {
1398         if(*tmp_p==' ')
1399             tmp_p++;
1400          else
1401           break;
1402   }
1403
1404    memcpy(dest,tmp_p,strlen(tmp_p));
1405  return TRUE;
1406 }
1407
1408 //if read fail,return NULL,or return data pointer;
1409 static unsigned char *Config_FileOperation(PSDevice pDevice)
1410 {
1411     unsigned char *config_path = CONFIG_PATH;
1412     unsigned char *buffer = NULL;
1413     struct file   *filp=NULL;
1414     mm_segment_t old_fs = get_fs();
1415     //int oldfsuid=0,oldfsgid=0;
1416     int result = 0;
1417
1418     set_fs (KERNEL_DS);
1419     /* Can't do this anymore, so we rely on correct filesystem permissions:
1420     //Make sure a caller can read or write power as root
1421     oldfsuid=current->fsuid;
1422     oldfsgid=current->fsgid;
1423     current->fsuid = 0;
1424     current->fsgid = 0;
1425     */
1426
1427     //open file
1428       filp = filp_open(config_path, O_RDWR, 0);
1429         if (IS_ERR(filp)) {
1430              printk("Config_FileOperation file Not exist\n");
1431              result=-1;
1432              goto error2;
1433           }
1434
1435      if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1436            printk("file %s cann't readable or writable?\n",config_path);
1437           result = -1;
1438           goto error1;
1439         }
1440
1441     buffer = kmalloc(1024, GFP_KERNEL);
1442     if(buffer==NULL) {
1443       printk("allocate mem for file fail?\n");
1444       result = -1;
1445       goto error1;
1446     }
1447
1448     if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1449      printk("read file error?\n");
1450      result = -1;
1451     }
1452
1453 error1:
1454   if(filp_close(filp,NULL))
1455        printk("Config_FileOperation:close file fail\n");
1456
1457 error2:
1458   set_fs (old_fs);
1459
1460   /*
1461   current->fsuid=oldfsuid;
1462   current->fsgid=oldfsgid;
1463   */
1464
1465 if(result!=0) {
1466     kfree(buffer);
1467     buffer=NULL;
1468 }
1469   return buffer;
1470 }
1471
1472 //return --->-1:fail;  >=0:successful
1473 static int Read_config_file(PSDevice pDevice) {
1474   int result = 0;
1475   unsigned char tmpbuffer[100];
1476   unsigned char *buffer = NULL;
1477
1478   //init config setting
1479  pDevice->config_file.ZoneType = -1;
1480  pDevice->config_file.eAuthenMode = -1;
1481  pDevice->config_file.eEncryptionStatus = -1;
1482
1483   buffer = Config_FileOperation(pDevice);
1484   if (buffer == NULL) {
1485      result =-1;
1486      return result;
1487   }
1488
1489 //get zonetype
1490 {
1491     memset(tmpbuffer,0,sizeof(tmpbuffer));
1492     if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1493     if(memcmp(tmpbuffer,"USA",3)==0) {
1494       pDevice->config_file.ZoneType=ZoneType_USA;
1495     }
1496     else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1497       pDevice->config_file.ZoneType=ZoneType_Japan;
1498     }
1499     else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1500      pDevice->config_file.ZoneType=ZoneType_Europe;
1501     }
1502     else {
1503       printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1504    }
1505  }
1506 }
1507
1508 //get other parameter
1509   {
1510         memset(tmpbuffer,0,sizeof(tmpbuffer));
1511        if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1512          pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1513        }
1514
1515         memset(tmpbuffer,0,sizeof(tmpbuffer));
1516        if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1517          pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1518        }
1519   }
1520
1521   kfree(buffer);
1522   return result;
1523 }
1524
1525 static void device_set_multi(struct net_device *dev) {
1526     PSDevice         pDevice = (PSDevice) netdev_priv(dev);
1527     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1528     u32              mc_filter[2];
1529     int              ii;
1530     struct netdev_hw_addr *ha;
1531     BYTE             pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1532     BYTE             byTmpMode = 0;
1533     int              rc;
1534
1535
1536         spin_lock_irq(&pDevice->lock);
1537     rc = CONTROLnsRequestIn(pDevice,
1538                             MESSAGE_TYPE_READ,
1539                             MAC_REG_RCR,
1540                             MESSAGE_REQUEST_MACREG,
1541                             1,
1542                             &byTmpMode
1543                             );
1544     if (rc == 0) pDevice->byRxMode = byTmpMode;
1545
1546     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1547
1548     if (dev->flags & IFF_PROMISC) {         // Set promiscuous.
1549         DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1550         // Unconditionally log net taps.
1551         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1552     }
1553     else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1554              (dev->flags & IFF_ALLMULTI)) {
1555         CONTROLnsRequestOut(pDevice,
1556                             MESSAGE_TYPE_WRITE,
1557                             MAC_REG_MAR0,
1558                             MESSAGE_REQUEST_MACREG,
1559                             8,
1560                             pbyData
1561                             );
1562         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1563     }
1564     else {
1565         memset(mc_filter, 0, sizeof(mc_filter));
1566         netdev_for_each_mc_addr(ha, dev) {
1567             int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1568             mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1569         }
1570         for (ii = 0; ii < 4; ii++) {
1571              MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1572              MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1573         }
1574         pDevice->byRxMode &= ~(RCR_UNICAST);
1575         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1576     }
1577
1578     if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1579         // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1580         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1581         pDevice->byRxMode &= ~(RCR_UNICAST);
1582     }
1583     ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1584     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1585         spin_unlock_irq(&pDevice->lock);
1586
1587 }
1588
1589
1590 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1591     PSDevice pDevice=(PSDevice) netdev_priv(dev);
1592
1593     return &pDevice->stats;
1594 }
1595
1596
1597 static int  device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1598         PSDevice                pDevice = (PSDevice)netdev_priv(dev);
1599     PSMgmtObject        pMgmt = &(pDevice->sMgmtObj);
1600     PSCmdRequest        pReq;
1601     //BOOL                bCommit = FALSE;
1602         struct iwreq *wrq = (struct iwreq *) rq;
1603         int                 rc =0;
1604
1605     if (pMgmt == NULL) {
1606         rc = -EFAULT;
1607         return rc;
1608     }
1609
1610     switch(cmd) {
1611
1612         case SIOCGIWNAME:
1613                 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1614                 break;
1615
1616         case SIOCSIWNWID:
1617         rc = -EOPNOTSUPP;
1618                 break;
1619
1620         case SIOCGIWNWID:     //0x8b03  support
1621         #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1622           rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
1623         #else
1624         rc = -EOPNOTSUPP;
1625         #endif
1626                 break;
1627
1628                 // Set frequency/channel
1629         case SIOCSIWFREQ:
1630             rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1631                 break;
1632
1633                 // Get frequency/channel
1634         case SIOCGIWFREQ:
1635                 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1636                 break;
1637
1638                 // Set desired network name (ESSID)
1639         case SIOCSIWESSID:
1640
1641                 {
1642                         char essid[IW_ESSID_MAX_SIZE+1];
1643                         if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1644                                 rc = -E2BIG;
1645                                 break;
1646                         }
1647                         if (copy_from_user(essid, wrq->u.essid.pointer,
1648                                            wrq->u.essid.length)) {
1649                                 rc = -EFAULT;
1650                                 break;
1651                         }
1652                         rc = iwctl_siwessid(dev, NULL,
1653                                             &(wrq->u.essid), essid);
1654                 }
1655                 break;
1656
1657
1658                 // Get current network name (ESSID)
1659         case SIOCGIWESSID:
1660
1661                 {
1662                         char essid[IW_ESSID_MAX_SIZE+1];
1663                         if (wrq->u.essid.pointer) {
1664                                 rc = iwctl_giwessid(dev, NULL,
1665                                                     &(wrq->u.essid), essid);
1666                                 if (copy_to_user(wrq->u.essid.pointer,
1667                                                          essid,
1668                                                          wrq->u.essid.length) )
1669                                         rc = -EFAULT;
1670                         }
1671                 }
1672                 break;
1673
1674         case SIOCSIWAP:
1675
1676                 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1677                 break;
1678
1679
1680                 // Get current Access Point (BSSID)
1681         case SIOCGIWAP:
1682                 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1683                 break;
1684
1685
1686                 // Set desired station name
1687         case SIOCSIWNICKN:
1688         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1689         rc = -EOPNOTSUPP;
1690                 break;
1691
1692                 // Get current station name
1693         case SIOCGIWNICKN:
1694         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1695         rc = -EOPNOTSUPP;
1696                 break;
1697
1698                 // Set the desired bit-rate
1699         case SIOCSIWRATE:
1700                 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1701                 break;
1702
1703         // Get the current bit-rate
1704         case SIOCGIWRATE:
1705
1706                 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1707                 break;
1708
1709         // Set the desired RTS threshold
1710         case SIOCSIWRTS:
1711
1712                 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
1713                 break;
1714
1715         // Get the current RTS threshold
1716         case SIOCGIWRTS:
1717
1718                 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1719                 break;
1720
1721                 // Set the desired fragmentation threshold
1722         case SIOCSIWFRAG:
1723
1724                 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1725             break;
1726
1727         // Get the current fragmentation threshold
1728         case SIOCGIWFRAG:
1729
1730                 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1731                 break;
1732
1733                 // Set mode of operation
1734         case SIOCSIWMODE:
1735         rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1736                 break;
1737
1738                 // Get mode of operation
1739         case SIOCGIWMODE:
1740                 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1741                 break;
1742
1743                 // Set WEP keys and mode
1744         case SIOCSIWENCODE:
1745                 {
1746             char abyKey[WLAN_WEP232_KEYLEN];
1747
1748                         if (wrq->u.encoding.pointer) {
1749
1750
1751                                 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
1752                                         rc = -E2BIG;
1753                                         break;
1754                                 }
1755                                 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
1756                                 if (copy_from_user(abyKey,
1757                                                   wrq->u.encoding.pointer,
1758                                                   wrq->u.encoding.length)) {
1759                                         rc = -EFAULT;
1760                                         break;
1761                                 }
1762                         } else if (wrq->u.encoding.length != 0) {
1763                                 rc = -EINVAL;
1764                                 break;
1765                         }
1766                         rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1767                 }
1768                 break;
1769
1770                 // Get the WEP keys and mode
1771         case SIOCGIWENCODE:
1772
1773                 if (!capable(CAP_NET_ADMIN)) {
1774                         rc = -EPERM;
1775                         break;
1776                 }
1777                 {
1778                     char abyKey[WLAN_WEP232_KEYLEN];
1779
1780                     rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1781                     if (rc != 0) break;
1782                         if (wrq->u.encoding.pointer) {
1783                                 if (copy_to_user(wrq->u.encoding.pointer,
1784                                                         abyKey,
1785                                                         wrq->u.encoding.length))
1786                                         rc = -EFAULT;
1787                         }
1788                 }
1789                 break;
1790
1791                 // Get the current Tx-Power
1792         case SIOCGIWTXPOW:
1793         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1794         rc = -EOPNOTSUPP;
1795                 break;
1796
1797         case SIOCSIWTXPOW:
1798         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1799         rc = -EOPNOTSUPP;
1800                 break;
1801
1802         case SIOCSIWRETRY:
1803
1804                 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
1805                 break;
1806
1807         case SIOCGIWRETRY:
1808
1809                 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
1810                 break;
1811
1812                 // Get range of parameters
1813         case SIOCGIWRANGE:
1814
1815                 {
1816                         struct iw_range range;
1817
1818                         rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
1819                         if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
1820                                 rc = -EFAULT;
1821                 }
1822
1823                 break;
1824
1825         case SIOCGIWPOWER:
1826
1827                 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
1828                 break;
1829
1830
1831         case SIOCSIWPOWER:
1832
1833                 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
1834                 break;
1835
1836
1837         case SIOCGIWSENS:
1838
1839             rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
1840                 break;
1841
1842         case SIOCSIWSENS:
1843         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
1844                 rc = -EOPNOTSUPP;
1845                 break;
1846
1847         case SIOCGIWAPLIST:
1848             {
1849             char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
1850
1851                     if (wrq->u.data.pointer) {
1852                         rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
1853                         if (rc == 0) {
1854                     if (copy_to_user(wrq->u.data.pointer,
1855                                                         buffer,
1856                                                        (wrq->u.data.length * (sizeof(struct sockaddr) +  sizeof(struct iw_quality)))
1857                                         ))
1858                                     rc = -EFAULT;
1859                         }
1860             }
1861         }
1862                 break;
1863
1864
1865 #ifdef WIRELESS_SPY
1866                 // Set the spy list
1867         case SIOCSIWSPY:
1868
1869         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1870                 rc = -EOPNOTSUPP;
1871                 break;
1872
1873                 // Get the spy list
1874         case SIOCGIWSPY:
1875
1876         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1877                 rc = -EOPNOTSUPP;
1878                 break;
1879
1880 #endif // WIRELESS_SPY
1881
1882         case SIOCGIWPRIV:
1883         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
1884                 rc = -EOPNOTSUPP;
1885 /*
1886                 if(wrq->u.data.pointer) {
1887                         wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
1888
1889                         if(copy_to_user(wrq->u.data.pointer,
1890                                         (u_char *) iwctl_private_args,
1891                                         sizeof(iwctl_private_args)))
1892                                 rc = -EFAULT;
1893                 }
1894 */
1895                 break;
1896
1897 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1898         case SIOCSIWAUTH:
1899                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH\n");
1900                 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
1901                 break;
1902
1903         case SIOCGIWAUTH:
1904                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
1905                 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
1906                 break;
1907
1908         case SIOCSIWGENIE:
1909                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
1910                 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1911                 break;
1912
1913         case SIOCGIWGENIE:
1914                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
1915                 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1916                 break;
1917
1918         case SIOCSIWENCODEEXT:
1919                 {
1920                         char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
1921                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
1922                         if(wrq->u.encoding.pointer){
1923                                 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
1924                                 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
1925                                         rc = -E2BIG;
1926                                         break;
1927                                 }
1928                                 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
1929                                         rc = -EFAULT;
1930                                         break;
1931                                 }
1932                         }else if(wrq->u.encoding.length != 0){
1933                                 rc = -EINVAL;
1934                                 break;
1935                         }
1936                         rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
1937                 }
1938                 break;
1939
1940         case SIOCGIWENCODEEXT:
1941                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
1942                 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
1943                 break;
1944
1945         case SIOCSIWMLME:
1946                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
1947                 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1948                 break;
1949
1950 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1951
1952     case IOCTL_CMD_TEST:
1953
1954                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1955                     rc = -EFAULT;
1956                     break;
1957                 } else {
1958                     rc = 0;
1959                 }
1960         pReq = (PSCmdRequest)rq;
1961
1962    //20080130-01,<Remark> by Mike Liu
1963       // if(pDevice->bLinkPass==TRUE)
1964           pReq->wResult = MAGIC_CODE;         //Linking status:0x3142
1965    //20080130-02,<Remark> by Mike Liu
1966       //  else
1967       //         pReq->wResult = MAGIC_CODE+1;    //disconnect status:0x3143
1968         break;
1969
1970     case IOCTL_CMD_SET:
1971                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
1972                        (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
1973                 {
1974                     rc = -EFAULT;
1975                     break;
1976                 } else {
1977                     rc = 0;
1978                 }
1979
1980             if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
1981                     return -EBUSY;
1982             }
1983         rc = private_ioctl(pDevice, rq);
1984         clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
1985         break;
1986
1987     case IOCTL_CMD_HOSTAPD:
1988
1989                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1990                     rc = -EFAULT;
1991                     break;
1992                 } else {
1993                     rc = 0;
1994                 }
1995
1996                 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
1997         break;
1998
1999     case IOCTL_CMD_WPA:
2000
2001                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2002                     rc = -EFAULT;
2003                     break;
2004                 } else {
2005                     rc = 0;
2006                 }
2007
2008                 rc = wpa_ioctl(pDevice, &wrq->u.data);
2009         break;
2010
2011         case SIOCETHTOOL:
2012         return ethtool_ioctl(dev, (void *) rq->ifr_data);
2013         // All other calls are currently unsupported
2014
2015         default:
2016                 rc = -EOPNOTSUPP;
2017         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2018
2019
2020     }
2021
2022     if (pDevice->bCommit) {
2023        if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2024            netif_stop_queue(pDevice->dev);
2025            spin_lock_irq(&pDevice->lock);
2026         bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
2027            spin_unlock_irq(&pDevice->lock);
2028        }
2029        else {
2030            DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2031            spin_lock_irq(&pDevice->lock);
2032 //2007-1121-01<Modify>by EinsnLiu
2033             if (pDevice->bLinkPass &&
2034                   memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2035                 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2036              } else {
2037            pDevice->bLinkPass = FALSE;
2038            pMgmt->eCurrState = WMAC_STATE_IDLE;
2039            memset(pMgmt->abyCurrBSSID, 0, 6);
2040                  }
2041            ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2042 //End Modify
2043            netif_stop_queue(pDevice->dev);
2044 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2045            pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2046            if (!pDevice->bWPASuppWextEnabled)
2047 #endif
2048                 bScheduleCommand((void *) pDevice,
2049                                  WLAN_CMD_BSSID_SCAN,
2050                                  pMgmt->abyDesireSSID);
2051                 bScheduleCommand((void *) pDevice,
2052                                  WLAN_CMD_SSID,
2053                                  NULL);
2054            spin_unlock_irq(&pDevice->lock);
2055       }
2056       pDevice->bCommit = FALSE;
2057     }
2058
2059
2060     return rc;
2061 }
2062
2063
2064 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2065 {
2066         u32 ethcmd;
2067
2068         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
2069                 return -EFAULT;
2070
2071         switch (ethcmd) {
2072         case ETHTOOL_GDRVINFO: {
2073                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2074                 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2075                 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2076                 if (copy_to_user(useraddr, &info, sizeof(info)))
2077                         return -EFAULT;
2078                 return 0;
2079         }
2080
2081         }
2082
2083         return -EOPNOTSUPP;
2084 }
2085
2086
2087 /*------------------------------------------------------------------*/
2088
2089 MODULE_DEVICE_TABLE(usb, vt6656_table);
2090
2091 static struct usb_driver vt6656_driver = {
2092         .name =         DEVICE_NAME,
2093         .probe =        vt6656_probe,
2094         .disconnect =   vt6656_disconnect,
2095         .id_table =     vt6656_table,
2096 #ifdef CONFIG_PM
2097         .suspend = vt6656_suspend,
2098         .resume = vt6656_resume,
2099 #endif /* CONFIG_PM */
2100 };
2101
2102 static int __init vt6656_init_module(void)
2103 {
2104     printk(KERN_NOTICE DEVICE_FULL_DRV_NAM " " DEVICE_VERSION);
2105     return usb_register(&vt6656_driver);
2106 }
2107
2108 static void __exit vt6656_cleanup_module(void)
2109 {
2110         usb_deregister(&vt6656_driver);
2111 }
2112
2113 module_init(vt6656_init_module);
2114 module_exit(vt6656_cleanup_module);