drivers/staging/vt6656/main_usb.c

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