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