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