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