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
 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      pDevice->bwextstep0 = FALSE;
1060      pDevice->bwextstep1 = FALSE;
1061      pDevice->bwextstep2 = FALSE;
1062      pDevice->bwextstep3 = FALSE;
1063      pDevice->bWPASuppWextEnabled = FALSE;
1064     pDevice->byReAssocCount = 0;
1065
1066     RXvWorkItem(pDevice);
1067     INTvWorkItem(pDevice);
1068
1069     // Patch: if WEP key already set by iwconfig but device not yet open
1070     if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1071          spin_lock_irq(&pDevice->lock);
1072          KeybSetDefaultKey( pDevice,
1073                             &(pDevice->sKey),
1074                             pDevice->byKeyIndex | (1 << 31),
1075                             pDevice->uKeyLength,
1076                             NULL,
1077                             pDevice->abyKey,
1078                             KEY_CTL_WEP
1079                           );
1080          spin_unlock_irq(&pDevice->lock);
1081          pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1082     }
1083
1084     if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1085                 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1086         }
1087         else {
1088         //mike:mark@2008-11-10
1089           bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1090           /* bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL); */
1091     }
1092
1093
1094     netif_stop_queue(pDevice->dev);
1095     pDevice->flags |= DEVICE_FLAGS_OPENED;
1096
1097 {
1098   union iwreq_data      wrqu;
1099   memset(&wrqu, 0, sizeof(wrqu));
1100   wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1101   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1102 }
1103
1104     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1105     return 0;
1106
1107 free_all:
1108     device_free_frag_bufs(pDevice);
1109 free_rx_tx:
1110     device_free_rx_bufs(pDevice);
1111     device_free_tx_bufs(pDevice);
1112     device_free_int_bufs(pDevice);
1113         usb_kill_urb(pDevice->pControlURB);
1114         usb_kill_urb(pDevice->pInterruptURB);
1115     usb_free_urb(pDevice->pControlURB);
1116     usb_free_urb(pDevice->pInterruptURB);
1117
1118     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1119     return -ENOMEM;
1120 }
1121
1122
1123
1124 static int  device_close(struct net_device *dev) {
1125     PSDevice    pDevice=(PSDevice) netdev_priv(dev);
1126     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1127
1128         int uu;
1129
1130     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1131     if (pDevice == NULL)
1132         return -ENODEV;
1133
1134 {
1135   union iwreq_data      wrqu;
1136   memset(&wrqu, 0, sizeof(wrqu));
1137   wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1138   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1139 }
1140
1141     if (pDevice->bLinkPass) {
1142         bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1143         mdelay(30);
1144     }
1145
1146 device_release_WPADEV(pDevice);
1147
1148         memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1149         pMgmt->bShareKeyAlgorithm = FALSE;
1150         pDevice->bEncryptionEnable = FALSE;
1151         pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1152         spin_lock_irq(&pDevice->lock);
1153         for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1154                 MACvDisableKeyEntry(pDevice,uu);
1155         spin_unlock_irq(&pDevice->lock);
1156
1157     if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1158         MACbShutdown(pDevice);
1159     }
1160     netif_stop_queue(pDevice->dev);
1161     MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1162     MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1163     MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1164     pDevice->fKillEventPollingThread = TRUE;
1165     del_timer(&pDevice->sTimerCommand);
1166     del_timer(&pMgmt->sTimerSecondCallback);
1167
1168     del_timer(&pDevice->sTimerTxData);
1169
1170     if (pDevice->bDiversityRegCtlON) {
1171         del_timer(&pDevice->TimerSQ3Tmax1);
1172         del_timer(&pDevice->TimerSQ3Tmax2);
1173         del_timer(&pDevice->TimerSQ3Tmax3);
1174     }
1175     tasklet_kill(&pDevice->RxMngWorkItem);
1176     tasklet_kill(&pDevice->ReadWorkItem);
1177     tasklet_kill(&pDevice->EventWorkItem);
1178
1179    pDevice->bRoaming = FALSE;
1180    pDevice->bIsRoaming = FALSE;
1181    pDevice->bEnableRoaming = FALSE;
1182     pDevice->bCmdRunning = FALSE;
1183     pDevice->bLinkPass = FALSE;
1184     memset(pMgmt->abyCurrBSSID, 0, 6);
1185     pMgmt->eCurrState = WMAC_STATE_IDLE;
1186
1187     device_free_tx_bufs(pDevice);
1188     device_free_rx_bufs(pDevice);
1189     device_free_int_bufs(pDevice);
1190     device_free_frag_bufs(pDevice);
1191
1192         usb_kill_urb(pDevice->pControlURB);
1193         usb_kill_urb(pDevice->pInterruptURB);
1194     usb_free_urb(pDevice->pControlURB);
1195     usb_free_urb(pDevice->pInterruptURB);
1196
1197     BSSvClearNodeDBTable(pDevice, 0);
1198     pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1199
1200     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1201
1202     return 0;
1203 }
1204
1205 static void vt6656_disconnect(struct usb_interface *intf)
1206 {
1207         PSDevice device = usb_get_intfdata(intf);
1208
1209         if (!device)
1210                 return;
1211
1212         {
1213                 union iwreq_data req;
1214                 memset(&req, 0, sizeof(req));
1215                 req.data.flags = RT_RMMOD_EVENT_FLAG;
1216                 wireless_send_event(device->dev, IWEVCUSTOM, &req, NULL);
1217         }
1218
1219         device_release_WPADEV(device);
1220
1221         usb_set_intfdata(intf, NULL);
1222         usb_put_dev(interface_to_usbdev(intf));
1223
1224         device->flags |= DEVICE_FLAGS_UNPLUG;
1225
1226         if (device->dev) {
1227                 unregister_netdev(device->dev);
1228                 wpa_set_wpadev(device, 0);
1229                 free_netdev(device->dev);
1230         }
1231 }
1232
1233 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1234 {
1235         PSDevice pDevice = netdev_priv(dev);
1236
1237         spin_lock_irq(&pDevice->lock);
1238
1239         if (unlikely(pDevice->bStopTx0Pkt))
1240                 dev_kfree_skb_irq(skb);
1241         else
1242                 vDMA0_tx_80211(pDevice, skb);
1243
1244         spin_unlock_irq(&pDevice->lock);
1245
1246         return NETDEV_TX_OK;
1247 }
1248
1249 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1250 {
1251         PSDevice pDevice = netdev_priv(dev);
1252         struct net_device_stats *stats = &pDevice->stats;
1253
1254         spin_lock_irq(&pDevice->lock);
1255
1256         netif_stop_queue(dev);
1257
1258         if (!pDevice->bLinkPass) {
1259                 dev_kfree_skb_irq(skb);
1260                 goto out;
1261         }
1262
1263         if (pDevice->bStopDataPkt) {
1264                 dev_kfree_skb_irq(skb);
1265                 stats->tx_dropped++;
1266                 goto out;
1267         }
1268
1269         if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1270                 if (netif_queue_stopped(dev))
1271                         netif_wake_queue(dev);
1272         }
1273
1274 out:
1275         spin_unlock_irq(&pDevice->lock);
1276
1277         return NETDEV_TX_OK;
1278 }
1279
1280 static unsigned const ethernet_polynomial = 0x04c11db7U;
1281 static inline u32 ether_crc(int length, unsigned char *data)
1282 {
1283     int crc = -1;
1284
1285     while(--length >= 0) {
1286         unsigned char current_octet = *data++;
1287         int bit;
1288         for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1289             crc = (crc << 1) ^
1290                 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1291         }
1292     }
1293     return crc;
1294 }
1295
1296 //find out the start  position of str2 from str1
1297 static unsigned char *kstrstr(const unsigned char *str1,
1298                               const unsigned char *str2) {
1299   int str1_len = strlen(str1);
1300   int str2_len = strlen(str2);
1301
1302   while (str1_len >= str2_len) {
1303        str1_len--;
1304       if(memcmp(str1,str2,str2_len)==0)
1305         return (unsigned char *) str1;
1306         str1++;
1307   }
1308   return NULL;
1309 }
1310
1311 static int Config_FileGetParameter(unsigned char *string,
1312                                    unsigned char *dest,
1313                                    unsigned char *source)
1314 {
1315   unsigned char buf1[100];
1316   unsigned char buf2[100];
1317   unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1318   int ii;
1319
1320     memset(buf1,0,100);
1321     strcat(buf1, string);
1322     strcat(buf1, "=");
1323     source+=strlen(buf1);
1324
1325 //find target string start point
1326     start_p = kstrstr(source,buf1);
1327     if (start_p == NULL)
1328         return FALSE;
1329
1330 //check if current config line is marked by "#" ??
1331     for (ii = 1; ; ii++) {
1332         if (memcmp(start_p - ii, "\n", 1) == 0)
1333                 break;
1334         if (memcmp(start_p - ii, "#", 1) == 0)
1335                 return FALSE;
1336     }
1337
1338 //find target string end point
1339      end_p = kstrstr(start_p,"\n");
1340      if (end_p == NULL) {       //can't find "\n",but don't care
1341           end_p=start_p+strlen(start_p);   //no include "\n"
1342        }
1343
1344    memset(buf2,0,100);
1345    memcpy(buf2,start_p,end_p-start_p);    //get the target line
1346    buf2[end_p-start_p]='\0';
1347
1348    //find value
1349    start_p = kstrstr(buf2,"=");
1350    if (start_p == NULL)
1351       return FALSE;
1352    memset(buf1,0,100);
1353    strcpy(buf1,start_p+1);
1354
1355   //except space
1356   tmp_p = buf1;
1357   while(*tmp_p != 0x00) {
1358         if(*tmp_p==' ')
1359             tmp_p++;
1360          else
1361           break;
1362   }
1363
1364    memcpy(dest,tmp_p,strlen(tmp_p));
1365  return TRUE;
1366 }
1367
1368 //if read fail,return NULL,or return data pointer;
1369 static unsigned char *Config_FileOperation(PSDevice pDevice)
1370 {
1371     unsigned char *config_path = CONFIG_PATH;
1372     unsigned char *buffer = NULL;
1373     struct file   *filp=NULL;
1374     mm_segment_t old_fs = get_fs();
1375     //int oldfsuid=0,oldfsgid=0;
1376     int result = 0;
1377
1378     set_fs (KERNEL_DS);
1379     /* Can't do this anymore, so we rely on correct filesystem permissions:
1380     //Make sure a caller can read or write power as root
1381     oldfsuid=current->fsuid;
1382     oldfsgid=current->fsgid;
1383     current->fsuid = 0;
1384     current->fsgid = 0;
1385     */
1386
1387     //open file
1388       filp = filp_open(config_path, O_RDWR, 0);
1389         if (IS_ERR(filp)) {
1390              printk("Config_FileOperation file Not exist\n");
1391              result=-1;
1392              goto error2;
1393           }
1394
1395      if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1396            printk("file %s is not read or writeable?\n",config_path);
1397           result = -1;
1398           goto error1;
1399         }
1400
1401     buffer = kmalloc(1024, GFP_KERNEL);
1402     if(buffer==NULL) {
1403       printk("allocate mem for file fail?\n");
1404       result = -1;
1405       goto error1;
1406     }
1407
1408     if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1409      printk("read file error?\n");
1410      result = -1;
1411     }
1412
1413 error1:
1414   if(filp_close(filp,NULL))
1415        printk("Config_FileOperation:close file fail\n");
1416
1417 error2:
1418   set_fs (old_fs);
1419
1420   /*
1421   current->fsuid=oldfsuid;
1422   current->fsgid=oldfsgid;
1423   */
1424
1425 if(result!=0) {
1426     kfree(buffer);
1427     buffer=NULL;
1428 }
1429   return buffer;
1430 }
1431
1432 //return --->-1:fail;  >=0:successful
1433 static int Read_config_file(PSDevice pDevice) {
1434   int result = 0;
1435   unsigned char tmpbuffer[100];
1436   unsigned char *buffer = NULL;
1437
1438   //init config setting
1439  pDevice->config_file.ZoneType = -1;
1440  pDevice->config_file.eAuthenMode = -1;
1441  pDevice->config_file.eEncryptionStatus = -1;
1442
1443   buffer = Config_FileOperation(pDevice);
1444   if (buffer == NULL) {
1445      result =-1;
1446      return result;
1447   }
1448
1449 //get zonetype
1450 {
1451     memset(tmpbuffer,0,sizeof(tmpbuffer));
1452     if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1453     if(memcmp(tmpbuffer,"USA",3)==0) {
1454       pDevice->config_file.ZoneType=ZoneType_USA;
1455     }
1456     else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1457       pDevice->config_file.ZoneType=ZoneType_Japan;
1458     }
1459     else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1460      pDevice->config_file.ZoneType=ZoneType_Europe;
1461     }
1462     else {
1463       printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1464    }
1465  }
1466 }
1467
1468 //get other parameter
1469   {
1470         memset(tmpbuffer,0,sizeof(tmpbuffer));
1471        if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1472          pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1473        }
1474
1475         memset(tmpbuffer,0,sizeof(tmpbuffer));
1476        if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1477          pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1478        }
1479   }
1480
1481   kfree(buffer);
1482   return result;
1483 }
1484
1485 static void device_set_multi(struct net_device *dev) {
1486     PSDevice         pDevice = (PSDevice) netdev_priv(dev);
1487     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1488     u32              mc_filter[2];
1489     int              ii;
1490     struct netdev_hw_addr *ha;
1491     BYTE             pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1492     BYTE             byTmpMode = 0;
1493     int              rc;
1494
1495
1496         spin_lock_irq(&pDevice->lock);
1497     rc = CONTROLnsRequestIn(pDevice,
1498                             MESSAGE_TYPE_READ,
1499                             MAC_REG_RCR,
1500                             MESSAGE_REQUEST_MACREG,
1501                             1,
1502                             &byTmpMode
1503                             );
1504     if (rc == 0) pDevice->byRxMode = byTmpMode;
1505
1506     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1507
1508     if (dev->flags & IFF_PROMISC) {         // Set promiscuous.
1509         DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1510         // Unconditionally log net taps.
1511         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1512     }
1513     else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1514              (dev->flags & IFF_ALLMULTI)) {
1515         CONTROLnsRequestOut(pDevice,
1516                             MESSAGE_TYPE_WRITE,
1517                             MAC_REG_MAR0,
1518                             MESSAGE_REQUEST_MACREG,
1519                             8,
1520                             pbyData
1521                             );
1522         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1523     }
1524     else {
1525         memset(mc_filter, 0, sizeof(mc_filter));
1526         netdev_for_each_mc_addr(ha, dev) {
1527             int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1528             mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1529         }
1530         for (ii = 0; ii < 4; ii++) {
1531              MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1532              MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1533         }
1534         pDevice->byRxMode &= ~(RCR_UNICAST);
1535         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1536     }
1537
1538     if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1539         // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1540         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1541         pDevice->byRxMode &= ~(RCR_UNICAST);
1542     }
1543     ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1544     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1545         spin_unlock_irq(&pDevice->lock);
1546
1547 }
1548
1549
1550 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1551     PSDevice pDevice=(PSDevice) netdev_priv(dev);
1552
1553     return &pDevice->stats;
1554 }
1555
1556
1557 static int  device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1558         PSDevice pDevice = (PSDevice)netdev_priv(dev);
1559         PSMgmtObject pMgmt = &pDevice->sMgmtObj;
1560         PSCmdRequest pReq;
1561         struct iwreq *wrq = (struct iwreq *) rq;
1562         int rc = 0;
1563
1564     if (pMgmt == NULL) {
1565         rc = -EFAULT;
1566         return rc;
1567     }
1568
1569     switch(cmd) {
1570
1571
1572     case IOCTL_CMD_TEST:
1573
1574                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1575                     rc = -EFAULT;
1576                     break;
1577                 } else {
1578                     rc = 0;
1579                 }
1580         pReq = (PSCmdRequest)rq;
1581
1582    //20080130-01,<Remark> by Mike Liu
1583       // if(pDevice->bLinkPass==TRUE)
1584           pReq->wResult = MAGIC_CODE;         //Linking status:0x3142
1585    //20080130-02,<Remark> by Mike Liu
1586       //  else
1587       //         pReq->wResult = MAGIC_CODE+1;    //disconnect status:0x3143
1588         break;
1589
1590     case IOCTL_CMD_SET:
1591                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
1592                        (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
1593                 {
1594                     rc = -EFAULT;
1595                     break;
1596                 } else {
1597                     rc = 0;
1598                 }
1599
1600             if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
1601                     return -EBUSY;
1602             }
1603         rc = private_ioctl(pDevice, rq);
1604         clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
1605         break;
1606
1607     case IOCTL_CMD_HOSTAPD:
1608
1609                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1610                     rc = -EFAULT;
1611                     break;
1612                 } else {
1613                     rc = 0;
1614                 }
1615
1616                 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
1617         break;
1618
1619     case IOCTL_CMD_WPA:
1620
1621                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1622                     rc = -EFAULT;
1623                     break;
1624                 } else {
1625                     rc = 0;
1626                 }
1627
1628                 rc = wpa_ioctl(pDevice, &wrq->u.data);
1629         break;
1630
1631         case SIOCETHTOOL:
1632         return ethtool_ioctl(dev, (void *) rq->ifr_data);
1633
1634     }
1635
1636
1637     return rc;
1638 }
1639
1640
1641 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
1642 {
1643         u32 ethcmd;
1644
1645         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
1646                 return -EFAULT;
1647
1648         switch (ethcmd) {
1649         case ETHTOOL_GDRVINFO: {
1650                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
1651                 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
1652                 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
1653                 if (copy_to_user(useraddr, &info, sizeof(info)))
1654                         return -EFAULT;
1655                 return 0;
1656         }
1657
1658         }
1659
1660         return -EOPNOTSUPP;
1661 }
1662
1663
1664 /*------------------------------------------------------------------*/
1665
1666 MODULE_DEVICE_TABLE(usb, vt6656_table);
1667
1668 static struct usb_driver vt6656_driver = {
1669         .name =         DEVICE_NAME,
1670         .probe =        vt6656_probe,
1671         .disconnect =   vt6656_disconnect,
1672         .id_table =     vt6656_table,
1673 #ifdef CONFIG_PM
1674         .suspend = vt6656_suspend,
1675         .resume = vt6656_resume,
1676 #endif /* CONFIG_PM */
1677 };
1678
1679 module_usb_driver(vt6656_driver);