Pileus Git - ~andy/linux/blob - drivers/staging/vt6656/main_usb.c

   1 /*
   2  * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * File: main_usb.c
  20  *
  21  * Purpose: driver entry for initial, open, close, tx and rx.
  22  *
  23  * Author: Lyndon Chen
  24  *
  25  * Date: Dec 8, 2005
  26  *
  27  * Functions:
  28  *
  29  *   vt6656_probe - module initial (insmod) driver entry
  30  *   device_remove1 - module remove entry
  31  *   device_open - allocate dma/descripter resource & initial mac/bbp function
  32  *   device_xmit - asynchrous data tx function
  33  *   device_set_multi - set mac filter
  34  *   device_ioctl - ioctl entry
  35  *   device_close - shutdown mac/bbp & free dma/descripter resource
  36  *   device_alloc_frag_buf - rx fragement pre-allocated function
  37  *   device_free_tx_bufs - free tx buffer function
  38  *   device_dma0_tx_80211- tx 802.11 frame via dma0
  39  *   device_dma0_xmit- tx PS bufferred frame via dma0
  40  *   device_init_registers- initial MAC & BBP & RF internal registers.
  41  *   device_init_rings- initial tx/rx ring buffer
  42  *   device_init_defrag_cb- initial & allocate de-fragement buffer.
  43  *   device_tx_srv- tx interrupt service function
  44  *
  45  * Revision History:
  46  */
  47 #undef __NO_VERSION__
  48
  49 #include "device.h"
  50 #include "card.h"
  51 #include "baseband.h"
  52 #include "mac.h"
  53 #include "tether.h"
  54 #include "wmgr.h"
  55 #include "wctl.h"
  56 #include "power.h"
  57 #include "wcmd.h"
  58 #include "iocmd.h"
  59 #include "tcrc.h"
  60 #include "rxtx.h"
  61 #include "bssdb.h"
  62 #include "hostap.h"
  63 #include "wpactl.h"
  64 #include "ioctl.h"
  65 #include "iwctl.h"
  66 #include "dpc.h"
  67 #include "datarate.h"
  68 #include "rf.h"
  69 #include "firmware.h"
  70 #include "rndis.h"
  71 #include "control.h"
  72 #include "channel.h"
  73 #include "int.h"
  74 #include "iowpa.h"
  75
  76 /*---------------------  Static Definitions -------------------------*/
  77 //static int          msglevel                =MSG_LEVEL_DEBUG;
  78 static int          msglevel                =MSG_LEVEL_INFO;
  79
  80 //
  81 // Define module options
  82 //
  83
  84 // Version Information
  85 #define DRIVER_AUTHOR "VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>"
  86 MODULE_AUTHOR(DRIVER_AUTHOR);
  87 MODULE_LICENSE("GPL");
  88 MODULE_DESCRIPTION(DEVICE_FULL_DRV_NAM);
  89
  90 #define DEVICE_PARAM(N,D) \
  91         static int N[MAX_UINTS]=OPTION_DEFAULT;\
  92         module_param_array(N, int, NULL, 0);\
  93         MODULE_PARM_DESC(N, D);
  94
  95 #define RX_DESC_MIN0     16
  96 #define RX_DESC_MAX0     128
  97 #define RX_DESC_DEF0     64
  98 DEVICE_PARAM(RxDescriptors0,"Number of receive usb desc buffer");
  99
 100
 101 #define TX_DESC_MIN0     16
 102 #define TX_DESC_MAX0     128
 103 #define TX_DESC_DEF0     64
 104 DEVICE_PARAM(TxDescriptors0,"Number of transmit usb desc buffer");
 105
 106
 107 #define CHANNEL_MIN     1
 108 #define CHANNEL_MAX     14
 109 #define CHANNEL_DEF     6
 110
 111 DEVICE_PARAM(Channel, "Channel number");
 112
 113
 114 /* PreambleType[] is the preamble length used for transmit.
 115    0: indicate allows long preamble type
 116    1: indicate allows short preamble type
 117 */
 118
 119 #define PREAMBLE_TYPE_DEF     1
 120
 121 DEVICE_PARAM(PreambleType, "Preamble Type");
 122
 123
 124 #define RTS_THRESH_MIN     512
 125 #define RTS_THRESH_MAX     2347
 126 #define RTS_THRESH_DEF     2347
 127
 128 DEVICE_PARAM(RTSThreshold, "RTS threshold");
 129
 130
 131 #define FRAG_THRESH_MIN     256
 132 #define FRAG_THRESH_MAX     2346
 133 #define FRAG_THRESH_DEF     2346
 134
 135 DEVICE_PARAM(FragThreshold, "Fragmentation threshold");
 136
 137
 138 #define DATA_RATE_MIN     0
 139 #define DATA_RATE_MAX     13
 140 #define DATA_RATE_DEF     13
 141 /* datarate[] index
 142    0: indicate 1 Mbps   0x02
 143    1: indicate 2 Mbps   0x04
 144    2: indicate 5.5 Mbps 0x0B
 145    3: indicate 11 Mbps  0x16
 146    4: indicate 6 Mbps   0x0c
 147    5: indicate 9 Mbps   0x12
 148    6: indicate 12 Mbps  0x18
 149    7: indicate 18 Mbps  0x24
 150    8: indicate 24 Mbps  0x30
 151    9: indicate 36 Mbps  0x48
 152   10: indicate 48 Mbps  0x60
 153   11: indicate 54 Mbps  0x6c
 154   12: indicate 72 Mbps  0x90
 155   13: indicate auto rate
 156 */
 157
 158 DEVICE_PARAM(ConnectionRate, "Connection data rate");
 159
 160 #define OP_MODE_MAX     2
 161 #define OP_MODE_DEF     0
 162 #define OP_MODE_MIN     0
 163
 164 DEVICE_PARAM(OPMode, "Infrastruct, adhoc, AP mode ");
 165
 166 /* OpMode[] is used for transmit.
 167    0: indicate infrastruct mode used
 168    1: indicate adhoc mode used
 169    2: indicate AP mode used
 170 */
 171
 172
 173 /* PSMode[]
 174    0: indicate disable power saving mode
 175    1: indicate enable power saving mode
 176 */
 177
 178 #define PS_MODE_DEF     0
 179
 180 DEVICE_PARAM(PSMode, "Power saving mode");
 181
 182
 183 #define SHORT_RETRY_MIN     0
 184 #define SHORT_RETRY_MAX     31
 185 #define SHORT_RETRY_DEF     8
 186
 187
 188 DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits");
 189
 190 #define LONG_RETRY_MIN     0
 191 #define LONG_RETRY_MAX     15
 192 #define LONG_RETRY_DEF     4
 193
 194
 195 DEVICE_PARAM(LongRetryLimit, "long frame retry limits");
 196
 197
 198 /* BasebandType[] baseband type selected
 199    0: indicate 802.11a type
 200    1: indicate 802.11b type
 201    2: indicate 802.11g type
 202 */
 203 #define BBP_TYPE_MIN     0
 204 #define BBP_TYPE_MAX     2
 205 #define BBP_TYPE_DEF     2
 206
 207 DEVICE_PARAM(BasebandType, "baseband type");
 208
 209
 210
 211 /* 80211hEnable[]
 212    0: indicate disable 802.11h
 213    1: indicate enable 802.11h
 214 */
 215
 216 #define X80211h_MODE_DEF     0
 217
 218 DEVICE_PARAM(b80211hEnable, "802.11h mode");
 219
 220
 221 //
 222 // Static vars definitions
 223 //
 224
 225 static struct usb_device_id vt6656_table[] __devinitdata = {
 226         {USB_DEVICE(VNT_USB_VENDOR_ID, VNT_USB_PRODUCT_ID)},
 227         {}
 228 };
 229
 230 // Frequency list (map channels to frequencies)
 231 /*
 232 static const long frequency_list[] = {
 233     2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484,
 234     4915, 4920, 4925, 4935, 4940, 4945, 4960, 4980,
 235     5035, 5040, 5045, 5055, 5060, 5080, 5170, 5180, 5190, 5200, 5210, 5220, 5230, 5240,
 236     5260, 5280, 5300, 5320, 5500, 5520, 5540, 5560, 5580, 5600, 5620, 5640, 5660, 5680,
 237     5700, 5745, 5765, 5785, 5805, 5825
 238         };
 239
 240
 241 #ifndef IW_ENCODE_NOKEY
 242 #define IW_ENCODE_NOKEY         0x0800
 243 #define IW_ENCODE_MODE  (IW_ENCODE_DISABLED | IW_ENCODE_RESTRICTED | IW_ENCODE_OPEN)
 244 #endif
 245
 246 static const struct iw_handler_def      iwctl_handler_def;
 247 */
 248
 249 /*---------------------  Static Functions  --------------------------*/
 250
 251 static int vt6656_probe(struct usb_interface *intf,
 252                         const struct usb_device_id *id);
 253 static void vt6656_disconnect(struct usb_interface *intf);
 254
 255 #ifdef CONFIG_PM        /* Minimal support for suspend and resume */
 256 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message);
 257 static int vt6656_resume(struct usb_interface *intf);
 258 #endif /* CONFIG_PM */
 259
 260 static struct net_device_stats *device_get_stats(struct net_device *dev);
 261 static int  device_open(struct net_device *dev);
 262 static int  device_xmit(struct sk_buff *skb, struct net_device *dev);
 263 static void device_set_multi(struct net_device *dev);
 264 static int  device_close(struct net_device *dev);
 265 static int  device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 266
 267 static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType);
 268 static BOOL device_init_defrag_cb(PSDevice pDevice);
 269 static void device_init_diversity_timer(PSDevice pDevice);
 270 static int  device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
 271
 272 static int  ethtool_ioctl(struct net_device *dev, void *useraddr);
 273 static void device_free_tx_bufs(PSDevice pDevice);
 274 static void device_free_rx_bufs(PSDevice pDevice);
 275 static void device_free_int_bufs(PSDevice pDevice);
 276 static void device_free_frag_bufs(PSDevice pDevice);
 277 static BOOL device_alloc_bufs(PSDevice pDevice);
 278
 279 static int Read_config_file(PSDevice pDevice);
 280 static 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         usb_put_dev(interface_to_usbdev(intf));
 722
 723         return 0;
 724 }
 725
 726 static int vt6656_resume(struct usb_interface *intf)
 727 {
 728         PSDevice device = usb_get_intfdata(intf);
 729
 730         if (!device || !device->dev)
 731                 return -ENODEV;
 732
 733         usb_get_dev(interface_to_usbdev(intf));
 734
 735         if (!(device->flags & DEVICE_FLAGS_OPENED))
 736                 device_open(device->dev);
 737
 738         return 0;
 739 }
 740
 741 #endif /* CONFIG_PM */
 742
 743 static const struct net_device_ops device_netdev_ops = {
 744     .ndo_open               = device_open,
 745     .ndo_stop               = device_close,
 746     .ndo_do_ioctl           = device_ioctl,
 747     .ndo_get_stats          = device_get_stats,
 748     .ndo_start_xmit         = device_xmit,
 749     .ndo_set_rx_mode        = device_set_multi,
 750 };
 751
 752 static int __devinit
 753 vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
 754 {
 755         u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
 756         struct usb_device *udev = interface_to_usbdev(intf);
 757         int rc = 0;
 758         struct net_device *netdev = NULL;
 759         PSDevice pDevice = NULL;
 760
 761         printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
 762         printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
 763
 764         udev = usb_get_dev(udev);
 765         netdev = alloc_etherdev(sizeof(DEVICE_INFO));
 766         if (!netdev) {
 767                 printk(KERN_ERR DEVICE_NAME ": allocate net device failed\n");
 768                 rc = -ENOMEM;
 769                 goto err_nomem;
 770         }
 771
 772         pDevice = netdev_priv(netdev);
 773         memset(pDevice, 0, sizeof(DEVICE_INFO));
 774
 775         pDevice->dev = netdev;
 776         pDevice->usb = udev;
 777
 778         device_set_options(pDevice);
 779         spin_lock_init(&pDevice->lock);
 780
 781         pDevice->tx_80211 = device_dma0_tx_80211;
 782         pDevice->sMgmtObj.pAdapter = (void *) pDevice;
 783
 784         netdev->netdev_ops = &device_netdev_ops;
 785         netdev->wireless_handlers =
 786                 (struct iw_handler_def *) &iwctl_handler_def;
 787
 788         usb_set_intfdata(intf, pDevice);
 789         SET_NETDEV_DEV(netdev, &intf->dev);
 790         memcpy(pDevice->dev->dev_addr, fake_mac, ETH_ALEN);
 791         rc = register_netdev(netdev);
 792         if (rc) {
 793                 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
 794                 goto err_netdev;
 795         }
 796
 797         usb_device_reset(pDevice);
 798
 799         {
 800                 union iwreq_data wrqu;
 801                 memset(&wrqu, 0, sizeof(wrqu));
 802                 wrqu.data.flags = RT_INSMOD_EVENT_FLAG;
 803                 wrqu.data.length = IFNAMSIZ;
 804                 wireless_send_event(pDevice->dev,
 805                                     IWEVCUSTOM,
 806                                     &wrqu,
 807                                     pDevice->dev->name);
 808         }
 809
 810         return 0;
 811
 812 err_netdev:
 813         free_netdev(netdev);
 814 err_nomem:
 815         usb_put_dev(udev);
 816
 817         return rc;
 818 }
 819
 820 static void device_free_tx_bufs(PSDevice pDevice)
 821 {
 822     PUSB_SEND_CONTEXT pTxContext;
 823     int ii;
 824
 825     for (ii = 0; ii < pDevice->cbTD; ii++) {
 826
 827         pTxContext = pDevice->apTD[ii];
 828         //de-allocate URBs
 829         if (pTxContext->pUrb) {
 830             usb_kill_urb(pTxContext->pUrb);
 831             usb_free_urb(pTxContext->pUrb);
 832         }
 833         kfree(pTxContext);
 834     }
 835     return;
 836 }
 837
 838
 839 static void device_free_rx_bufs(PSDevice pDevice)
 840 {
 841     PRCB pRCB;
 842     int ii;
 843
 844     for (ii = 0; ii < pDevice->cbRD; ii++) {
 845
 846         pRCB = pDevice->apRCB[ii];
 847         //de-allocate URBs
 848         if (pRCB->pUrb) {
 849             usb_kill_urb(pRCB->pUrb);
 850             usb_free_urb(pRCB->pUrb);
 851         }
 852         //de-allocate skb
 853         if (pRCB->skb)
 854             dev_kfree_skb(pRCB->skb);
 855     }
 856     kfree(pDevice->pRCBMem);
 857
 858     return;
 859 }
 860
 861 static void usb_device_reset(PSDevice pDevice)
 862 {
 863  int status;
 864  status = usb_reset_device(pDevice->usb);
 865         if (status)
 866             printk("usb_device_reset fail status=%d\n",status);
 867         return ;
 868 }
 869
 870 static void device_free_int_bufs(PSDevice pDevice)
 871 {
 872     kfree(pDevice->intBuf.pDataBuf);
 873     return;
 874 }
 875
 876
 877 static BOOL device_alloc_bufs(PSDevice pDevice) {
 878
 879     PUSB_SEND_CONTEXT pTxContext;
 880     PRCB pRCB;
 881     int ii;
 882
 883
 884     for (ii = 0; ii < pDevice->cbTD; ii++) {
 885
 886         pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
 887         if (pTxContext == NULL) {
 888             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
 889             goto free_tx;
 890         }
 891         pDevice->apTD[ii] = pTxContext;
 892         pTxContext->pDevice = (void *) pDevice;
 893         //allocate URBs
 894         pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
 895         if (pTxContext->pUrb == NULL) {
 896             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
 897             goto free_tx;
 898         }
 899         pTxContext->bBoolInUse = FALSE;
 900     }
 901
 902     // allocate rcb mem
 903         pDevice->pRCBMem = kzalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
 904     if (pDevice->pRCBMem == NULL) {
 905         DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
 906         goto free_tx;
 907     }
 908
 909
 910     pDevice->FirstRecvFreeList = NULL;
 911     pDevice->LastRecvFreeList = NULL;
 912     pDevice->FirstRecvMngList = NULL;
 913     pDevice->LastRecvMngList = NULL;
 914     pDevice->NumRecvFreeList = 0;
 915     pRCB = (PRCB) pDevice->pRCBMem;
 916
 917     for (ii = 0; ii < pDevice->cbRD; ii++) {
 918
 919         pDevice->apRCB[ii] = pRCB;
 920         pRCB->pDevice = (void *) pDevice;
 921         //allocate URBs
 922         pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
 923
 924         if (pRCB->pUrb == NULL) {
 925             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
 926             goto free_rx_tx;
 927         }
 928         pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
 929         if (pRCB->skb == NULL) {
 930             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
 931             goto free_rx_tx;
 932         }
 933         pRCB->skb->dev = pDevice->dev;
 934         pRCB->bBoolInUse = FALSE;
 935         EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
 936         pDevice->NumRecvFreeList++;
 937         pRCB++;
 938     }
 939
 940
 941         pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
 942         if (pDevice->pControlURB == NULL) {
 943             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
 944             goto free_rx_tx;
 945         }
 946
 947         pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
 948         if (pDevice->pInterruptURB == NULL) {
 949             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
 950             usb_free_urb(pDevice->pControlURB);
 951             goto free_rx_tx;
 952         }
 953
 954     pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
 955         if (pDevice->intBuf.pDataBuf == NULL) {
 956             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
 957             usb_free_urb(pDevice->pControlURB);
 958             usb_free_urb(pDevice->pInterruptURB);
 959             goto free_rx_tx;
 960         }
 961
 962     return TRUE;
 963
 964 free_rx_tx:
 965     device_free_rx_bufs(pDevice);
 966
 967 free_tx:
 968     device_free_tx_bufs(pDevice);
 969
 970         return FALSE;
 971 }
 972
 973
 974
 975
 976 static BOOL device_init_defrag_cb(PSDevice pDevice) {
 977     int i;
 978     PSDeFragControlBlock pDeF;
 979
 980     /* Init the fragment ctl entries */
 981     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
 982         pDeF = &(pDevice->sRxDFCB[i]);
 983         if (!device_alloc_frag_buf(pDevice, pDeF)) {
 984             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
 985                 pDevice->dev->name);
 986             goto free_frag;
 987         }
 988     }
 989     pDevice->cbDFCB = CB_MAX_RX_FRAG;
 990     pDevice->cbFreeDFCB = pDevice->cbDFCB;
 991     return TRUE;
 992
 993 free_frag:
 994     device_free_frag_bufs(pDevice);
 995     return FALSE;
 996 }
 997
 998
 999
1000 static void device_free_frag_bufs(PSDevice pDevice) {
1001     PSDeFragControlBlock pDeF;
1002     int i;
1003
1004     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1005
1006         pDeF = &(pDevice->sRxDFCB[i]);
1007
1008         if (pDeF->skb)
1009             dev_kfree_skb(pDeF->skb);
1010     }
1011 }
1012
1013
1014
1015 BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1016
1017     pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1018     if (pDeF->skb == NULL)
1019         return FALSE;
1020     ASSERT(pDeF->skb);
1021     pDeF->skb->dev = pDevice->dev;
1022
1023     return TRUE;
1024 }
1025
1026
1027 /*-----------------------------------------------------------------*/
1028
1029 static int  device_open(struct net_device *dev) {
1030     PSDevice    pDevice=(PSDevice) netdev_priv(dev);
1031
1032      extern SWPAResult wpa_Result;
1033      memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1034      wpa_Result.proto = 0;
1035      wpa_Result.key_mgmt = 0;
1036      wpa_Result.eap_type = 0;
1037      wpa_Result.authenticated = FALSE;
1038      pDevice->fWPA_Authened = FALSE;
1039
1040     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
1041
1042
1043     pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
1044
1045     if (device_alloc_bufs(pDevice) == FALSE) {
1046         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
1047         return -ENOMEM;
1048     }
1049
1050     if (device_init_defrag_cb(pDevice)== FALSE) {
1051         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragement cb fail \n");
1052         goto free_rx_tx;
1053     }
1054
1055     MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
1056     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
1057     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
1058     MP_SET_FLAG(pDevice, fMP_POST_READS);
1059     MP_SET_FLAG(pDevice, fMP_POST_WRITES);
1060
1061    //read config file
1062     Read_config_file(pDevice);
1063
1064     if (device_init_registers(pDevice, DEVICE_INIT_COLD) == FALSE) {
1065         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
1066         goto free_all;
1067     }
1068
1069     device_set_multi(pDevice->dev);
1070     // Init for Key Management
1071
1072     KeyvInitTable(pDevice,&pDevice->sKey);
1073     memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1074     memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1075     pDevice->bStopTx0Pkt = FALSE;
1076     pDevice->bStopDataPkt = FALSE;
1077     pDevice->bRoaming = FALSE;
1078     pDevice->bIsRoaming = FALSE;
1079     pDevice->bEnableRoaming = FALSE;
1080     if (pDevice->bDiversityRegCtlON) {
1081         device_init_diversity_timer(pDevice);
1082     }
1083
1084     vMgrObjectInit(pDevice);
1085     tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
1086     tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
1087     tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
1088     add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback));
1089     pDevice->int_interval = 100;  //Max 100 microframes.
1090     pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1091
1092     pDevice->bIsRxWorkItemQueued = TRUE;
1093     pDevice->fKillEventPollingThread = FALSE;
1094     pDevice->bEventAvailable = FALSE;
1095
1096    pDevice->bWPADEVUp = FALSE;
1097 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1098      pDevice->bwextstep0 = FALSE;
1099      pDevice->bwextstep1 = FALSE;
1100      pDevice->bwextstep2 = FALSE;
1101      pDevice->bwextstep3 = FALSE;
1102      pDevice->bWPASuppWextEnabled = FALSE;
1103 #endif
1104     pDevice->byReAssocCount = 0;
1105
1106     RXvWorkItem(pDevice);
1107     INTvWorkItem(pDevice);
1108
1109     // Patch: if WEP key already set by iwconfig but device not yet open
1110     if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1111          spin_lock_irq(&pDevice->lock);
1112          KeybSetDefaultKey( pDevice,
1113                             &(pDevice->sKey),
1114                             pDevice->byKeyIndex | (1 << 31),
1115                             pDevice->uKeyLength,
1116                             NULL,
1117                             pDevice->abyKey,
1118                             KEY_CTL_WEP
1119                           );
1120          spin_unlock_irq(&pDevice->lock);
1121          pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1122     }
1123
1124     if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1125                 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1126         }
1127         else {
1128         //mike:mark@2008-11-10
1129           bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1130           /* bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL); */
1131     }
1132
1133
1134     netif_stop_queue(pDevice->dev);
1135     pDevice->flags |= DEVICE_FLAGS_OPENED;
1136
1137 {
1138   union iwreq_data      wrqu;
1139   memset(&wrqu, 0, sizeof(wrqu));
1140   wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1141   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1142 }
1143
1144     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1145     return 0;
1146
1147 free_all:
1148     device_free_frag_bufs(pDevice);
1149 free_rx_tx:
1150     device_free_rx_bufs(pDevice);
1151     device_free_tx_bufs(pDevice);
1152     device_free_int_bufs(pDevice);
1153         usb_kill_urb(pDevice->pControlURB);
1154         usb_kill_urb(pDevice->pInterruptURB);
1155     usb_free_urb(pDevice->pControlURB);
1156     usb_free_urb(pDevice->pInterruptURB);
1157
1158     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1159     return -ENOMEM;
1160 }
1161
1162
1163
1164 static int  device_close(struct net_device *dev) {
1165     PSDevice    pDevice=(PSDevice) netdev_priv(dev);
1166     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1167
1168         int uu;
1169
1170     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1171     if (pDevice == NULL)
1172         return -ENODEV;
1173
1174 {
1175   union iwreq_data      wrqu;
1176   memset(&wrqu, 0, sizeof(wrqu));
1177   wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1178   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1179 }
1180
1181     if (pDevice->bLinkPass) {
1182         bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1183         mdelay(30);
1184     }
1185
1186 device_release_WPADEV(pDevice);
1187
1188         memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1189         pMgmt->bShareKeyAlgorithm = FALSE;
1190         pDevice->bEncryptionEnable = FALSE;
1191         pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1192         spin_lock_irq(&pDevice->lock);
1193         for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1194                 MACvDisableKeyEntry(pDevice,uu);
1195         spin_unlock_irq(&pDevice->lock);
1196
1197     if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1198         MACbShutdown(pDevice);
1199     }
1200     netif_stop_queue(pDevice->dev);
1201     MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1202     MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1203     MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1204     pDevice->fKillEventPollingThread = TRUE;
1205     del_timer(&pDevice->sTimerCommand);
1206     del_timer(&pMgmt->sTimerSecondCallback);
1207
1208     del_timer(&pDevice->sTimerTxData);
1209
1210     if (pDevice->bDiversityRegCtlON) {
1211         del_timer(&pDevice->TimerSQ3Tmax1);
1212         del_timer(&pDevice->TimerSQ3Tmax2);
1213         del_timer(&pDevice->TimerSQ3Tmax3);
1214     }
1215     tasklet_kill(&pDevice->RxMngWorkItem);
1216     tasklet_kill(&pDevice->ReadWorkItem);
1217     tasklet_kill(&pDevice->EventWorkItem);
1218
1219    pDevice->bRoaming = FALSE;
1220    pDevice->bIsRoaming = FALSE;
1221    pDevice->bEnableRoaming = FALSE;
1222     pDevice->bCmdRunning = FALSE;
1223     pDevice->bLinkPass = FALSE;
1224     memset(pMgmt->abyCurrBSSID, 0, 6);
1225     pMgmt->eCurrState = WMAC_STATE_IDLE;
1226
1227     device_free_tx_bufs(pDevice);
1228     device_free_rx_bufs(pDevice);
1229     device_free_int_bufs(pDevice);
1230     device_free_frag_bufs(pDevice);
1231
1232         usb_kill_urb(pDevice->pControlURB);
1233         usb_kill_urb(pDevice->pInterruptURB);
1234     usb_free_urb(pDevice->pControlURB);
1235     usb_free_urb(pDevice->pInterruptURB);
1236
1237     BSSvClearNodeDBTable(pDevice, 0);
1238     pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1239
1240     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1241
1242     return 0;
1243 }
1244
1245 static void __devexit vt6656_disconnect(struct usb_interface *intf)
1246 {
1247         PSDevice device = usb_get_intfdata(intf);
1248
1249         if (!device)
1250                 return;
1251
1252         {
1253                 union iwreq_data req;
1254                 memset(&req, 0, sizeof(req));
1255                 req.data.flags = RT_RMMOD_EVENT_FLAG;
1256                 wireless_send_event(device->dev, IWEVCUSTOM, &req, NULL);
1257         }
1258
1259         device_release_WPADEV(device);
1260
1261         if (device->firmware)
1262                 release_firmware(device->firmware);
1263
1264         usb_set_intfdata(intf, NULL);
1265         usb_put_dev(interface_to_usbdev(intf));
1266
1267         device->flags |= DEVICE_FLAGS_UNPLUG;
1268
1269         if (device->dev) {
1270                 unregister_netdev(device->dev);
1271                 wpa_set_wpadev(device, 0);
1272                 free_netdev(device->dev);
1273         }
1274 }
1275
1276 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1277 {
1278         PSDevice pDevice = netdev_priv(dev);
1279
1280         spin_lock_irq(&pDevice->lock);
1281
1282         if (unlikely(pDevice->bStopTx0Pkt))
1283                 dev_kfree_skb_irq(skb);
1284         else
1285                 vDMA0_tx_80211(pDevice, skb);
1286
1287         spin_unlock_irq(&pDevice->lock);
1288
1289         return NETDEV_TX_OK;
1290 }
1291
1292 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1293 {
1294         PSDevice pDevice = netdev_priv(dev);
1295         struct net_device_stats *stats = &pDevice->stats;
1296
1297         spin_lock_irq(&pDevice->lock);
1298
1299         netif_stop_queue(dev);
1300
1301         if (!pDevice->bLinkPass) {
1302                 dev_kfree_skb_irq(skb);
1303                 goto out;
1304         }
1305
1306         if (pDevice->bStopDataPkt) {
1307                 dev_kfree_skb_irq(skb);
1308                 stats->tx_dropped++;
1309                 goto out;
1310         }
1311
1312         if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1313                 if (netif_queue_stopped(dev))
1314                         netif_wake_queue(dev);
1315         }
1316
1317 out:
1318         spin_unlock_irq(&pDevice->lock);
1319
1320         return NETDEV_TX_OK;
1321 }
1322
1323 static unsigned const ethernet_polynomial = 0x04c11db7U;
1324 static inline u32 ether_crc(int length, unsigned char *data)
1325 {
1326     int crc = -1;
1327
1328     while(--length >= 0) {
1329         unsigned char current_octet = *data++;
1330         int bit;
1331         for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1332             crc = (crc << 1) ^
1333                 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1334         }
1335     }
1336     return crc;
1337 }
1338
1339 //find out  the start  position of str2 from str1
1340 static unsigned char *kstrstr(const unsigned char *str1,
1341                               const unsigned char *str2) {
1342   int str1_len = strlen(str1);
1343   int str2_len = strlen(str2);
1344
1345   while (str1_len >= str2_len) {
1346        str1_len--;
1347       if(memcmp(str1,str2,str2_len)==0)
1348         return (unsigned char *) str1;
1349         str1++;
1350   }
1351   return NULL;
1352 }
1353
1354 static int Config_FileGetParameter(unsigned char *string,
1355                                    unsigned char *dest,
1356                                    unsigned char *source)
1357 {
1358   unsigned char buf1[100];
1359   unsigned char buf2[100];
1360   unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1361   int ii;
1362
1363     memset(buf1,0,100);
1364     strcat(buf1, string);
1365     strcat(buf1, "=");
1366     source+=strlen(buf1);
1367
1368 //find target string start point
1369     start_p = kstrstr(source,buf1);
1370     if (start_p == NULL)
1371         return FALSE;
1372
1373 //check if current config line is marked by "#" ??
1374     for (ii = 1; ; ii++) {
1375         if (memcmp(start_p - ii, "\n", 1) == 0)
1376                 break;
1377         if (memcmp(start_p - ii, "#", 1) == 0)
1378                 return FALSE;
1379     }
1380
1381 //find target string end point
1382      end_p = kstrstr(start_p,"\n");
1383      if (end_p == NULL) {       //can't find "\n",but don't care
1384           end_p=start_p+strlen(start_p);   //no include "\n"
1385        }
1386
1387    memset(buf2,0,100);
1388    memcpy(buf2,start_p,end_p-start_p);    //get the tartget line
1389    buf2[end_p-start_p]='\0';
1390
1391    //find value
1392    start_p = kstrstr(buf2,"=");
1393    if (start_p == NULL)
1394       return FALSE;
1395    memset(buf1,0,100);
1396    strcpy(buf1,start_p+1);
1397
1398   //except space
1399   tmp_p = buf1;
1400   while(*tmp_p != 0x00) {
1401         if(*tmp_p==' ')
1402             tmp_p++;
1403          else
1404           break;
1405   }
1406
1407    memcpy(dest,tmp_p,strlen(tmp_p));
1408  return TRUE;
1409 }
1410
1411 //if read fail,return NULL,or return data pointer;
1412 static unsigned char *Config_FileOperation(PSDevice pDevice)
1413 {
1414     unsigned char *config_path = CONFIG_PATH;
1415     unsigned char *buffer = NULL;
1416     struct file   *filp=NULL;
1417     mm_segment_t old_fs = get_fs();
1418     //int oldfsuid=0,oldfsgid=0;
1419     int result = 0;
1420
1421     set_fs (KERNEL_DS);
1422     /* Can't do this anymore, so we rely on correct filesystem permissions:
1423     //Make sure a caller can read or write power as root
1424     oldfsuid=current->fsuid;
1425     oldfsgid=current->fsgid;
1426     current->fsuid = 0;
1427     current->fsgid = 0;
1428     */
1429
1430     //open file
1431       filp = filp_open(config_path, O_RDWR, 0);
1432         if (IS_ERR(filp)) {
1433              printk("Config_FileOperation file Not exist\n");
1434              result=-1;
1435              goto error2;
1436           }
1437
1438      if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1439            printk("file %s cann't readable or writable?\n",config_path);
1440           result = -1;
1441           goto error1;
1442         }
1443
1444     buffer = kmalloc(1024, GFP_KERNEL);
1445     if(buffer==NULL) {
1446       printk("allocate mem for file fail?\n");
1447       result = -1;
1448       goto error1;
1449     }
1450
1451     if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1452      printk("read file error?\n");
1453      result = -1;
1454     }
1455
1456 error1:
1457   if(filp_close(filp,NULL))
1458        printk("Config_FileOperation:close file fail\n");
1459
1460 error2:
1461   set_fs (old_fs);
1462
1463   /*
1464   current->fsuid=oldfsuid;
1465   current->fsgid=oldfsgid;
1466   */
1467
1468 if(result!=0) {
1469     kfree(buffer);
1470     buffer=NULL;
1471 }
1472   return buffer;
1473 }
1474
1475 //return --->-1:fail;  >=0:successful
1476 static int Read_config_file(PSDevice pDevice) {
1477   int result = 0;
1478   unsigned char tmpbuffer[100];
1479   unsigned char *buffer = NULL;
1480
1481   //init config setting
1482  pDevice->config_file.ZoneType = -1;
1483  pDevice->config_file.eAuthenMode = -1;
1484  pDevice->config_file.eEncryptionStatus = -1;
1485
1486   buffer = Config_FileOperation(pDevice);
1487   if (buffer == NULL) {
1488      result =-1;
1489      return result;
1490   }
1491
1492 //get zonetype
1493 {
1494     memset(tmpbuffer,0,sizeof(tmpbuffer));
1495     if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1496     if(memcmp(tmpbuffer,"USA",3)==0) {
1497       pDevice->config_file.ZoneType=ZoneType_USA;
1498     }
1499     else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1500       pDevice->config_file.ZoneType=ZoneType_Japan;
1501     }
1502     else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1503      pDevice->config_file.ZoneType=ZoneType_Europe;
1504     }
1505     else {
1506       printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1507    }
1508  }
1509 }
1510
1511 //get other parameter
1512   {
1513         memset(tmpbuffer,0,sizeof(tmpbuffer));
1514        if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1515          pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1516        }
1517
1518         memset(tmpbuffer,0,sizeof(tmpbuffer));
1519        if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1520          pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1521        }
1522   }
1523
1524   kfree(buffer);
1525   return result;
1526 }
1527
1528 static void device_set_multi(struct net_device *dev) {
1529     PSDevice         pDevice = (PSDevice) netdev_priv(dev);
1530     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1531     u32              mc_filter[2];
1532     int              ii;
1533     struct netdev_hw_addr *ha;
1534     BYTE             pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1535     BYTE             byTmpMode = 0;
1536     int              rc;
1537
1538
1539         spin_lock_irq(&pDevice->lock);
1540     rc = CONTROLnsRequestIn(pDevice,
1541                             MESSAGE_TYPE_READ,
1542                             MAC_REG_RCR,
1543                             MESSAGE_REQUEST_MACREG,
1544                             1,
1545                             &byTmpMode
1546                             );
1547     if (rc == 0) pDevice->byRxMode = byTmpMode;
1548
1549     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1550
1551     if (dev->flags & IFF_PROMISC) {         // Set promiscuous.
1552         DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1553         // Unconditionally log net taps.
1554         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1555     }
1556     else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1557              (dev->flags & IFF_ALLMULTI)) {
1558         CONTROLnsRequestOut(pDevice,
1559                             MESSAGE_TYPE_WRITE,
1560                             MAC_REG_MAR0,
1561                             MESSAGE_REQUEST_MACREG,
1562                             8,
1563                             pbyData
1564                             );
1565         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1566     }
1567     else {
1568         memset(mc_filter, 0, sizeof(mc_filter));
1569         netdev_for_each_mc_addr(ha, dev) {
1570             int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1571             mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1572         }
1573         for (ii = 0; ii < 4; ii++) {
1574              MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1575              MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1576         }
1577         pDevice->byRxMode &= ~(RCR_UNICAST);
1578         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1579     }
1580
1581     if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1582         // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1583         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1584         pDevice->byRxMode &= ~(RCR_UNICAST);
1585     }
1586     ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1587     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1588         spin_unlock_irq(&pDevice->lock);
1589
1590 }
1591
1592
1593 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1594     PSDevice pDevice=(PSDevice) netdev_priv(dev);
1595
1596     return &pDevice->stats;
1597 }
1598
1599
1600 static int  device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1601         PSDevice                pDevice = (PSDevice)netdev_priv(dev);
1602     PSMgmtObject        pMgmt = &(pDevice->sMgmtObj);
1603     PSCmdRequest        pReq;
1604     //BOOL                bCommit = FALSE;
1605         struct iwreq *wrq = (struct iwreq *) rq;
1606         int                 rc =0;
1607
1608     if (pMgmt == NULL) {
1609         rc = -EFAULT;
1610         return rc;
1611     }
1612
1613     switch(cmd) {
1614
1615         case SIOCGIWNAME:
1616                 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1617                 break;
1618
1619         case SIOCSIWNWID:
1620         case SIOCGIWNWID:     //0x8b03  support
1621                 rc = -EOPNOTSUPP;
1622                 break;
1623
1624                 // Set frequency/channel
1625         case SIOCSIWFREQ:
1626             rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1627                 break;
1628
1629                 // Get frequency/channel
1630         case SIOCGIWFREQ:
1631                 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1632                 break;
1633
1634                 // Set desired network name (ESSID)
1635         case SIOCSIWESSID:
1636
1637                 {
1638                         char essid[IW_ESSID_MAX_SIZE+1];
1639                         if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1640                                 rc = -E2BIG;
1641                                 break;
1642                         }
1643                         if (copy_from_user(essid, wrq->u.essid.pointer,
1644                                            wrq->u.essid.length)) {
1645                                 rc = -EFAULT;
1646                                 break;
1647                         }
1648                         rc = iwctl_siwessid(dev, NULL,
1649                                             &(wrq->u.essid), essid);
1650                 }
1651                 break;
1652
1653
1654                 // Get current network name (ESSID)
1655         case SIOCGIWESSID:
1656
1657                 {
1658                         char essid[IW_ESSID_MAX_SIZE+1];
1659                         if (wrq->u.essid.pointer) {
1660                                 rc = iwctl_giwessid(dev, NULL,
1661                                                     &(wrq->u.essid), essid);
1662                                 if (copy_to_user(wrq->u.essid.pointer,
1663                                                          essid,
1664                                                          wrq->u.essid.length) )
1665                                         rc = -EFAULT;
1666                         }
1667                 }
1668                 break;
1669
1670         case SIOCSIWAP:
1671
1672                 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1673                 break;
1674
1675
1676                 // Get current Access Point (BSSID)
1677         case SIOCGIWAP:
1678                 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1679                 break;
1680
1681
1682                 // Set desired station name
1683         case SIOCSIWNICKN:
1684         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1685         rc = -EOPNOTSUPP;
1686                 break;
1687
1688                 // Get current station name
1689         case SIOCGIWNICKN:
1690         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1691         rc = -EOPNOTSUPP;
1692                 break;
1693
1694                 // Set the desired bit-rate
1695         case SIOCSIWRATE:
1696                 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1697                 break;
1698
1699         // Get the current bit-rate
1700         case SIOCGIWRATE:
1701
1702                 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1703                 break;
1704
1705         // Set the desired RTS threshold
1706         case SIOCSIWRTS:
1707
1708                 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
1709                 break;
1710
1711         // Get the current RTS threshold
1712         case SIOCGIWRTS:
1713
1714                 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1715                 break;
1716
1717                 // Set the desired fragmentation threshold
1718         case SIOCSIWFRAG:
1719
1720                 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1721             break;
1722
1723         // Get the current fragmentation threshold
1724         case SIOCGIWFRAG:
1725
1726                 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1727                 break;
1728
1729                 // Set mode of operation
1730         case SIOCSIWMODE:
1731         rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1732                 break;
1733
1734                 // Get mode of operation
1735         case SIOCGIWMODE:
1736                 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1737                 break;
1738
1739                 // Set WEP keys and mode
1740         case SIOCSIWENCODE:
1741                 {
1742             char abyKey[WLAN_WEP232_KEYLEN];
1743
1744                         if (wrq->u.encoding.pointer) {
1745
1746
1747                                 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
1748                                         rc = -E2BIG;
1749                                         break;
1750                                 }
1751                                 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
1752                                 if (copy_from_user(abyKey,
1753                                                   wrq->u.encoding.pointer,
1754                                                   wrq->u.encoding.length)) {
1755                                         rc = -EFAULT;
1756                                         break;
1757                                 }
1758                         } else if (wrq->u.encoding.length != 0) {
1759                                 rc = -EINVAL;
1760                                 break;
1761                         }
1762                         rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1763                 }
1764                 break;
1765
1766                 // Get the WEP keys and mode
1767         case SIOCGIWENCODE:
1768
1769                 if (!capable(CAP_NET_ADMIN)) {
1770                         rc = -EPERM;
1771                         break;
1772                 }
1773                 {
1774                     char abyKey[WLAN_WEP232_KEYLEN];
1775
1776                     rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1777                     if (rc != 0) break;
1778                         if (wrq->u.encoding.pointer) {
1779                                 if (copy_to_user(wrq->u.encoding.pointer,
1780                                                         abyKey,
1781                                                         wrq->u.encoding.length))
1782                                         rc = -EFAULT;
1783                         }
1784                 }
1785                 break;
1786
1787                 // Get the current Tx-Power
1788         case SIOCGIWTXPOW:
1789         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1790         rc = -EOPNOTSUPP;
1791                 break;
1792
1793         case SIOCSIWTXPOW:
1794         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1795         rc = -EOPNOTSUPP;
1796                 break;
1797
1798         case SIOCSIWRETRY:
1799
1800                 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
1801                 break;
1802
1803         case SIOCGIWRETRY:
1804
1805                 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
1806                 break;
1807
1808                 // Get range of parameters
1809         case SIOCGIWRANGE:
1810
1811                 {
1812                         struct iw_range range;
1813
1814                         rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
1815                         if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
1816                                 rc = -EFAULT;
1817                 }
1818
1819                 break;
1820
1821         case SIOCGIWPOWER:
1822
1823                 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
1824                 break;
1825
1826
1827         case SIOCSIWPOWER:
1828
1829                 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
1830                 break;
1831
1832
1833         case SIOCGIWSENS:
1834
1835             rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
1836                 break;
1837
1838         case SIOCSIWSENS:
1839         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
1840                 rc = -EOPNOTSUPP;
1841                 break;
1842
1843         case SIOCGIWAPLIST:
1844             {
1845             char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
1846
1847                     if (wrq->u.data.pointer) {
1848                         rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
1849                         if (rc == 0) {
1850                     if (copy_to_user(wrq->u.data.pointer,
1851                                                         buffer,
1852                                                        (wrq->u.data.length * (sizeof(struct sockaddr) +  sizeof(struct iw_quality)))
1853                                         ))
1854                                     rc = -EFAULT;
1855                         }
1856             }
1857         }
1858                 break;
1859
1860
1861 #ifdef WIRELESS_SPY
1862                 // Set the spy list
1863         case SIOCSIWSPY:
1864
1865         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1866                 rc = -EOPNOTSUPP;
1867                 break;
1868
1869                 // Get the spy list
1870         case SIOCGIWSPY:
1871
1872         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1873                 rc = -EOPNOTSUPP;
1874                 break;
1875
1876 #endif // WIRELESS_SPY
1877
1878         case SIOCGIWPRIV:
1879         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
1880                 rc = -EOPNOTSUPP;
1881 /*
1882                 if(wrq->u.data.pointer) {
1883                         wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
1884
1885                         if(copy_to_user(wrq->u.data.pointer,
1886                                         (u_char *) iwctl_private_args,
1887                                         sizeof(iwctl_private_args)))
1888                                 rc = -EFAULT;
1889                 }
1890 */
1891                 break;
1892
1893 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1894         case SIOCSIWAUTH:
1895                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH\n");
1896                 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
1897                 break;
1898
1899         case SIOCGIWAUTH:
1900                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
1901                 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
1902                 break;
1903
1904         case SIOCSIWGENIE:
1905                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
1906                 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1907                 break;
1908
1909         case SIOCGIWGENIE:
1910                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
1911                 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1912                 break;
1913
1914         case SIOCSIWENCODEEXT:
1915                 {
1916                         char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
1917                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
1918                         if(wrq->u.encoding.pointer){
1919                                 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
1920                                 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
1921                                         rc = -E2BIG;
1922                                         break;
1923                                 }
1924                                 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
1925                                         rc = -EFAULT;
1926                                         break;
1927                                 }
1928                         }else if(wrq->u.encoding.length != 0){
1929                                 rc = -EINVAL;
1930                                 break;
1931                         }
1932                         rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
1933                 }
1934                 break;
1935
1936         case SIOCGIWENCODEEXT:
1937                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
1938                 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
1939                 break;
1940
1941         case SIOCSIWMLME:
1942                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
1943                 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1944                 break;
1945
1946 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1947
1948     case IOCTL_CMD_TEST:
1949
1950                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1951                     rc = -EFAULT;
1952                     break;
1953                 } else {
1954                     rc = 0;
1955                 }
1956         pReq = (PSCmdRequest)rq;
1957
1958    //20080130-01,<Remark> by Mike Liu
1959       // if(pDevice->bLinkPass==TRUE)
1960           pReq->wResult = MAGIC_CODE;         //Linking status:0x3142
1961    //20080130-02,<Remark> by Mike Liu
1962       //  else
1963       //         pReq->wResult = MAGIC_CODE+1;    //disconnect status:0x3143
1964         break;
1965
1966     case IOCTL_CMD_SET:
1967                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
1968                        (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
1969                 {
1970                     rc = -EFAULT;
1971                     break;
1972                 } else {
1973                     rc = 0;
1974                 }
1975
1976             if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
1977                     return -EBUSY;
1978             }
1979         rc = private_ioctl(pDevice, rq);
1980         clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
1981         break;
1982
1983     case IOCTL_CMD_HOSTAPD:
1984
1985                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1986                     rc = -EFAULT;
1987                     break;
1988                 } else {
1989                     rc = 0;
1990                 }
1991
1992                 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
1993         break;
1994
1995     case IOCTL_CMD_WPA:
1996
1997                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1998                     rc = -EFAULT;
1999                     break;
2000                 } else {
2001                     rc = 0;
2002                 }
2003
2004                 rc = wpa_ioctl(pDevice, &wrq->u.data);
2005         break;
2006
2007         case SIOCETHTOOL:
2008         return ethtool_ioctl(dev, (void *) rq->ifr_data);
2009         // All other calls are currently unsupported
2010
2011         default:
2012                 rc = -EOPNOTSUPP;
2013         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2014
2015
2016     }
2017
2018     if (pDevice->bCommit) {
2019        if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2020            netif_stop_queue(pDevice->dev);
2021            spin_lock_irq(&pDevice->lock);
2022         bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
2023            spin_unlock_irq(&pDevice->lock);
2024        }
2025        else {
2026            DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2027            spin_lock_irq(&pDevice->lock);
2028 //2007-1121-01<Modify>by EinsnLiu
2029             if (pDevice->bLinkPass &&
2030                   memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2031                 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2032              } else {
2033            pDevice->bLinkPass = FALSE;
2034            pMgmt->eCurrState = WMAC_STATE_IDLE;
2035            memset(pMgmt->abyCurrBSSID, 0, 6);
2036                  }
2037            ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2038 //End Modify
2039            netif_stop_queue(pDevice->dev);
2040 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2041            pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2042            if (!pDevice->bWPASuppWextEnabled)
2043 #endif
2044                 bScheduleCommand((void *) pDevice,
2045                                  WLAN_CMD_BSSID_SCAN,
2046                                  pMgmt->abyDesireSSID);
2047                 bScheduleCommand((void *) pDevice,
2048                                  WLAN_CMD_SSID,
2049                                  NULL);
2050            spin_unlock_irq(&pDevice->lock);
2051       }
2052       pDevice->bCommit = FALSE;
2053     }
2054
2055
2056     return rc;
2057 }
2058
2059
2060 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2061 {
2062         u32 ethcmd;
2063
2064         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
2065                 return -EFAULT;
2066
2067         switch (ethcmd) {
2068         case ETHTOOL_GDRVINFO: {
2069                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2070                 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2071                 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2072                 if (copy_to_user(useraddr, &info, sizeof(info)))
2073                         return -EFAULT;
2074                 return 0;
2075         }
2076
2077         }
2078
2079         return -EOPNOTSUPP;
2080 }
2081
2082
2083 /*------------------------------------------------------------------*/
2084
2085 MODULE_DEVICE_TABLE(usb, vt6656_table);
2086
2087 static struct usb_driver vt6656_driver = {
2088         .name =         DEVICE_NAME,
2089         .probe =        vt6656_probe,
2090         .disconnect =   vt6656_disconnect,
2091         .id_table =     vt6656_table,
2092 #ifdef CONFIG_PM
2093         .suspend = vt6656_suspend,
2094         .resume = vt6656_resume,
2095 #endif /* CONFIG_PM */
2096 };
2097
2098 module_usb_driver(vt6656_driver);