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