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

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