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 "iwctl.h"
  65 #include "dpc.h"
  66 #include "datarate.h"
  67 #include "rf.h"
  68 #include "firmware.h"
  69 #include "rndis.h"
  70 #include "control.h"
  71 #include "channel.h"
  72 #include "int.h"
  73 #include "iowpa.h"
  74
  75 /*---------------------  Static Definitions -------------------------*/
  76 /* static int msglevel = MSG_LEVEL_DEBUG; */
  77 static int          msglevel                =MSG_LEVEL_INFO;
  78
  79 /*
  80  * define module options
  81  */
  82
  83 /* version information */
  84 #define DRIVER_AUTHOR \
  85         "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 int device_init_registers(struct vnt_private *pDevice,
 230         DEVICE_INIT_TYPE InitType);
 231 static bool device_init_defrag_cb(struct vnt_private *pDevice);
 232 static void device_init_diversity_timer(struct vnt_private *pDevice);
 233 static int  device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
 234
 235 static int  ethtool_ioctl(struct net_device *dev, void *useraddr);
 236 static void device_free_tx_bufs(struct vnt_private *pDevice);
 237 static void device_free_rx_bufs(struct vnt_private *pDevice);
 238 static void device_free_int_bufs(struct vnt_private *pDevice);
 239 static void device_free_frag_bufs(struct vnt_private *pDevice);
 240 static bool device_alloc_bufs(struct vnt_private *pDevice);
 241
 242 static int Read_config_file(struct vnt_private *pDevice);
 243 static unsigned char *Config_FileOperation(struct vnt_private *pDevice);
 244 static int Config_FileGetParameter(unsigned char *string,
 245                                    unsigned char *dest,
 246                                    unsigned char *source);
 247
 248
 249 static void usb_device_reset(struct vnt_private *pDevice);
 250
 251
 252
 253 /*---------------------  Export Variables  --------------------------*/
 254
 255 /*---------------------  Export Functions  --------------------------*/
 256
 257
 258 static void
 259 device_set_options(struct vnt_private *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(struct vnt_private *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 int device_init_registers(struct vnt_private *pDevice,
 323         DEVICE_INIT_TYPE InitType)
 324 {
 325         struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
 326         u8 abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 327         u8 abySNAP_RFC1042[ETH_ALEN] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00};
 328         u8 abySNAP_Bridgetunnel[ETH_ALEN]
 329                 = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8};
 330         u8 byAntenna;
 331         int ii;
 332         CMD_CARD_INIT sInitCmd;
 333         int ntStatus = STATUS_SUCCESS;
 334         RSP_CARD_INIT   sInitRsp;
 335         u8 byTmp;
 336         u8 byCalibTXIQ = 0, byCalibTXDC = 0, 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
 414         /* force CCK */
 415         pDevice->bCCK = true;
 416         pDevice->bProtectMode = false;
 417         /* only used in 11g type, sync with ERP IE */
 418         pDevice->bNonERPPresent = false;
 419         pDevice->bBarkerPreambleMd = false;
 420         if ( pDevice->bFixRate ) {
 421             pDevice->wCurrentRate = (WORD) pDevice->uConnectionRate;
 422         } else {
 423             if ( pDevice->byBBType == BB_TYPE_11B )
 424                 pDevice->wCurrentRate = RATE_11M;
 425             else
 426                 pDevice->wCurrentRate = RATE_54M;
 427         }
 428
 429         CHvInitChannelTable(pDevice);
 430
 431         pDevice->byTopOFDMBasicRate = RATE_24M;
 432         pDevice->byTopCCKBasicRate = RATE_1M;
 433         pDevice->byRevId = 0;
 434         /* target to IF pin while programming to RF chip */
 435         pDevice->byCurPwr = 0xFF;
 436
 437         pDevice->byCCKPwr = pDevice->abyEEPROM[EEP_OFS_PWR_CCK];
 438         pDevice->byOFDMPwrG = pDevice->abyEEPROM[EEP_OFS_PWR_OFDMG];
 439         /* load power table */
 440         for (ii = 0; ii < 14; ii++) {
 441             pDevice->abyCCKPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_CCK_PWR_TBL];
 442             if (pDevice->abyCCKPwrTbl[ii] == 0)
 443                 pDevice->abyCCKPwrTbl[ii] = pDevice->byCCKPwr;
 444             pDevice->abyOFDMPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDM_PWR_TBL];
 445             if (pDevice->abyOFDMPwrTbl[ii] == 0)
 446                 pDevice->abyOFDMPwrTbl[ii] = pDevice->byOFDMPwrG;
 447         }
 448
 449         /*
 450          * original zonetype is USA, but custom zonetype is Europe,
 451          * then need to recover 12, 13, 14 channels with 11 channel
 452          */
 453           if(((pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Japan) ||
 454                 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Europe))&&
 455              (pDevice->byOriginalZonetype == ZoneType_USA)) {
 456                 for (ii = 11; ii < 14; ii++) {
 457                         pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];
 458                         pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];
 459                 }
 460           }
 461
 462           pDevice->byOFDMPwrA = 0x34; /* same as RFbMA2829SelectChannel */
 463
 464           /* load OFDM A power table */
 465           for (ii = 0; ii < CB_MAX_CHANNEL_5G; ii++) {
 466             pDevice->abyOFDMAPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDMA_PWR_TBL];
 467             if (pDevice->abyOFDMAPwrTbl[ii] == 0)
 468                 pDevice->abyOFDMAPwrTbl[ii] = pDevice->byOFDMPwrA;
 469         }
 470
 471         byAntenna = pDevice->abyEEPROM[EEP_OFS_ANTENNA];
 472         if (byAntenna & EEP_ANTINV)
 473             pDevice->bTxRxAntInv = true;
 474         else
 475             pDevice->bTxRxAntInv = false;
 476
 477         byAntenna &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
 478
 479         if (byAntenna == 0) /* if not set default is both */
 480             byAntenna = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
 481
 482         if (byAntenna == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
 483             pDevice->byAntennaCount = 2;
 484             pDevice->byTxAntennaMode = ANT_B;
 485             pDevice->dwTxAntennaSel = 1;
 486             pDevice->dwRxAntennaSel = 1;
 487             if (pDevice->bTxRxAntInv == true)
 488                 pDevice->byRxAntennaMode = ANT_A;
 489             else
 490                 pDevice->byRxAntennaMode = ANT_B;
 491
 492             if (pDevice->bDiversityRegCtlON)
 493                 pDevice->bDiversityEnable = true;
 494             else
 495                 pDevice->bDiversityEnable = false;
 496         } else  {
 497             pDevice->bDiversityEnable = false;
 498             pDevice->byAntennaCount = 1;
 499             pDevice->dwTxAntennaSel = 0;
 500             pDevice->dwRxAntennaSel = 0;
 501             if (byAntenna & EEP_ANTENNA_AUX) {
 502                 pDevice->byTxAntennaMode = ANT_A;
 503                 if (pDevice->bTxRxAntInv == true)
 504                     pDevice->byRxAntennaMode = ANT_B;
 505                 else
 506                     pDevice->byRxAntennaMode = ANT_A;
 507             } else {
 508                 pDevice->byTxAntennaMode = ANT_B;
 509                 if (pDevice->bTxRxAntInv == true)
 510                     pDevice->byRxAntennaMode = ANT_A;
 511                 else
 512                     pDevice->byRxAntennaMode = ANT_B;
 513             }
 514         }
 515         pDevice->ulDiversityNValue = 100*255;
 516         pDevice->ulDiversityMValue = 100*16;
 517         pDevice->byTMax = 1;
 518         pDevice->byTMax2 = 4;
 519         pDevice->ulSQ3TH = 0;
 520         pDevice->byTMax3 = 64;
 521
 522         /* get Auto Fall Back type */
 523         pDevice->byAutoFBCtrl = AUTO_FB_0;
 524
 525         /* set SCAN Time */
 526         pDevice->uScanTime = WLAN_SCAN_MINITIME;
 527
 528         /* default Auto Mode */
 529         /* pDevice->NetworkType = Ndis802_11Automode; */
 530         pDevice->eConfigPHYMode = PHY_TYPE_AUTO;
 531         pDevice->byBBType = BB_TYPE_11G;
 532
 533         /* initialize BBP registers */
 534         pDevice->ulTxPower = 25;
 535
 536         /* get channel range */
 537         pDevice->byMinChannel = 1;
 538         pDevice->byMaxChannel = CB_MAX_CHANNEL;
 539
 540         /* get RFType */
 541         pDevice->byRFType = sInitRsp.byRFType;
 542
 543         if ((pDevice->byRFType & RF_EMU) != 0) {
 544                 /* force change RevID for VT3253 emu */
 545                 pDevice->byRevId = 0x80;
 546         }
 547
 548         /* load vt3266 calibration parameters in EEPROM */
 549         if (pDevice->byRFType == RF_VT3226D0) {
 550             if((pDevice->abyEEPROM[EEP_OFS_MAJOR_VER] == 0x1) &&
 551                 (pDevice->abyEEPROM[EEP_OFS_MINOR_VER] >= 0x4)) {
 552                 byCalibTXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_IQ];
 553                 byCalibTXDC = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_DC];
 554                 byCalibRXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_RX_IQ];
 555                 if( (byCalibTXIQ || byCalibTXDC || byCalibRXIQ) ) {
 556                         /* CR255, enable TX/RX IQ and DC compensation mode */
 557                         ControlvWriteByte(pDevice,
 558                                           MESSAGE_REQUEST_BBREG,
 559                                           0xFF,
 560                                           0x03);
 561                         /* CR251, TX I/Q Imbalance Calibration */
 562                         ControlvWriteByte(pDevice,
 563                                           MESSAGE_REQUEST_BBREG,
 564                                           0xFB,
 565                                           byCalibTXIQ);
 566                         /* CR252, TX DC-Offset Calibration */
 567                         ControlvWriteByte(pDevice,
 568                                           MESSAGE_REQUEST_BBREG,
 569                                           0xFC,
 570                                           byCalibTXDC);
 571                         /* CR253, RX I/Q Imbalance Calibration */
 572                         ControlvWriteByte(pDevice,
 573                                           MESSAGE_REQUEST_BBREG,
 574                                           0xFD,
 575                                           byCalibRXIQ);
 576                 } else {
 577                         /* CR255, turn off BB Calibration compensation */
 578                         ControlvWriteByte(pDevice,
 579                                           MESSAGE_REQUEST_BBREG,
 580                                           0xFF,
 581                                           0x0);
 582                 }
 583             }
 584         }
 585         pMgmt->eScanType = WMAC_SCAN_PASSIVE;
 586         pMgmt->uCurrChannel = pDevice->uChannel;
 587         pMgmt->uIBSSChannel = pDevice->uChannel;
 588         CARDbSetMediaChannel(pDevice, pMgmt->uCurrChannel);
 589
 590         /* get permanent network address */
 591         memcpy(pDevice->abyPermanentNetAddr,&(sInitRsp.byNetAddr[0]),6);
 592         memcpy(pDevice->abyCurrentNetAddr,
 593                pDevice->abyPermanentNetAddr,
 594                ETH_ALEN);
 595
 596         /* if exist SW network address, use it */
 597         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %pM\n",
 598                 pDevice->abyCurrentNetAddr);
 599     }
 600
 601     /*
 602      * set BB and packet type at the same time
 603      * set Short Slot Time, xIFS, and RSPINF
 604      */
 605     if (pDevice->byBBType == BB_TYPE_11A) {
 606         CARDbAddBasicRate(pDevice, RATE_6M);
 607         pDevice->bShortSlotTime = true;
 608     } else {
 609         CARDbAddBasicRate(pDevice, RATE_1M);
 610         pDevice->bShortSlotTime = false;
 611     }
 612     BBvSetShortSlotTime(pDevice);
 613     CARDvSetBSSMode(pDevice);
 614
 615     if (pDevice->bUpdateBBVGA) {
 616         pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
 617         pDevice->byBBVGANew = pDevice->byBBVGACurrent;
 618         BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
 619     }
 620
 621     pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];
 622     pDevice->bHWRadioOff = false;
 623     if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) {
 624         ntStatus = CONTROLnsRequestIn(pDevice,
 625                                     MESSAGE_TYPE_READ,
 626                                     MAC_REG_GPIOCTL1,
 627                                     MESSAGE_REQUEST_MACREG,
 628                                     1,
 629                                     &byTmp);
 630
 631         if ( ntStatus != STATUS_SUCCESS ) {
 632             spin_unlock_irq(&pDevice->lock);
 633             return false;
 634         }
 635         if ( (byTmp & GPIO3_DATA) == 0 ) {
 636             pDevice->bHWRadioOff = true;
 637             MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
 638         } else {
 639             MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
 640             pDevice->bHWRadioOff = false;
 641         }
 642
 643     }
 644
 645     ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
 646     ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
 647     MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01);
 648
 649     if ((pDevice->bHWRadioOff == true) || (pDevice->bRadioControlOff == true)) {
 650         CARDbRadioPowerOff(pDevice);
 651     } else {
 652         CARDbRadioPowerOn(pDevice);
 653     }
 654
 655     spin_unlock_irq(&pDevice->lock);
 656     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");
 657     return true;
 658 }
 659
 660 #ifdef CONFIG_PM        /* Minimal support for suspend and resume */
 661
 662 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message)
 663 {
 664         struct vnt_private *device = usb_get_intfdata(intf);
 665
 666         if (!device || !device->dev)
 667                 return -ENODEV;
 668
 669         if (device->flags & DEVICE_FLAGS_OPENED)
 670                 device_close(device->dev);
 671
 672         usb_put_dev(interface_to_usbdev(intf));
 673
 674         return 0;
 675 }
 676
 677 static int vt6656_resume(struct usb_interface *intf)
 678 {
 679         struct vnt_private *device = usb_get_intfdata(intf);
 680
 681         if (!device || !device->dev)
 682                 return -ENODEV;
 683
 684         usb_get_dev(interface_to_usbdev(intf));
 685
 686         if (!(device->flags & DEVICE_FLAGS_OPENED))
 687                 device_open(device->dev);
 688
 689         return 0;
 690 }
 691
 692 #endif /* CONFIG_PM */
 693
 694 static const struct net_device_ops device_netdev_ops = {
 695     .ndo_open               = device_open,
 696     .ndo_stop               = device_close,
 697     .ndo_do_ioctl           = device_ioctl,
 698     .ndo_get_stats          = device_get_stats,
 699     .ndo_start_xmit         = device_xmit,
 700     .ndo_set_rx_mode        = device_set_multi,
 701 };
 702
 703 static int
 704 vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
 705 {
 706         u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
 707         struct usb_device *udev = interface_to_usbdev(intf);
 708         int rc = 0;
 709         struct net_device *netdev = NULL;
 710         struct vnt_private *pDevice;
 711
 712         printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
 713         printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
 714
 715         udev = usb_get_dev(udev);
 716         netdev = alloc_etherdev(sizeof(struct vnt_private));
 717         if (!netdev) {
 718                 printk(KERN_ERR DEVICE_NAME ": allocate net device failed\n");
 719                 rc = -ENOMEM;
 720                 goto err_nomem;
 721         }
 722
 723         pDevice = netdev_priv(netdev);
 724         memset(pDevice, 0, sizeof(struct vnt_private));
 725
 726         pDevice->dev = netdev;
 727         pDevice->usb = udev;
 728
 729         device_set_options(pDevice);
 730         spin_lock_init(&pDevice->lock);
 731
 732         pDevice->tx_80211 = device_dma0_tx_80211;
 733         pDevice->vnt_mgmt.pAdapter = (void *) pDevice;
 734
 735         netdev->netdev_ops = &device_netdev_ops;
 736         netdev->wireless_handlers =
 737                 (struct iw_handler_def *) &iwctl_handler_def;
 738
 739         usb_set_intfdata(intf, pDevice);
 740         SET_NETDEV_DEV(netdev, &intf->dev);
 741         memcpy(pDevice->dev->dev_addr, fake_mac, ETH_ALEN);
 742         rc = register_netdev(netdev);
 743         if (rc) {
 744                 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
 745                 goto err_netdev;
 746         }
 747
 748         usb_device_reset(pDevice);
 749
 750         return 0;
 751
 752 err_netdev:
 753         free_netdev(netdev);
 754 err_nomem:
 755         usb_put_dev(udev);
 756
 757         return rc;
 758 }
 759
 760 static void device_free_tx_bufs(struct vnt_private *pDevice)
 761 {
 762     PUSB_SEND_CONTEXT pTxContext;
 763     int ii;
 764
 765     for (ii = 0; ii < pDevice->cbTD; ii++) {
 766
 767         pTxContext = pDevice->apTD[ii];
 768         /* deallocate URBs */
 769         if (pTxContext->pUrb) {
 770             usb_kill_urb(pTxContext->pUrb);
 771             usb_free_urb(pTxContext->pUrb);
 772         }
 773         kfree(pTxContext);
 774     }
 775     return;
 776 }
 777
 778
 779 static void device_free_rx_bufs(struct vnt_private *pDevice)
 780 {
 781     PRCB pRCB;
 782     int ii;
 783
 784     for (ii = 0; ii < pDevice->cbRD; ii++) {
 785
 786         pRCB = pDevice->apRCB[ii];
 787         /* deallocate URBs */
 788         if (pRCB->pUrb) {
 789             usb_kill_urb(pRCB->pUrb);
 790             usb_free_urb(pRCB->pUrb);
 791         }
 792         /* deallocate skb */
 793         if (pRCB->skb)
 794             dev_kfree_skb(pRCB->skb);
 795     }
 796     kfree(pDevice->pRCBMem);
 797
 798     return;
 799 }
 800
 801 static void usb_device_reset(struct vnt_private *pDevice)
 802 {
 803  int status;
 804  status = usb_reset_device(pDevice->usb);
 805         if (status)
 806             printk("usb_device_reset fail status=%d\n",status);
 807         return ;
 808 }
 809
 810 static void device_free_int_bufs(struct vnt_private *pDevice)
 811 {
 812     kfree(pDevice->intBuf.pDataBuf);
 813     return;
 814 }
 815
 816
 817 static bool device_alloc_bufs(struct vnt_private *pDevice)
 818 {
 819
 820     PUSB_SEND_CONTEXT pTxContext;
 821     PRCB pRCB;
 822     int ii;
 823
 824
 825     for (ii = 0; ii < pDevice->cbTD; ii++) {
 826
 827         pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
 828         if (pTxContext == NULL) {
 829             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
 830             goto free_tx;
 831         }
 832         pDevice->apTD[ii] = pTxContext;
 833         pTxContext->pDevice = (void *) pDevice;
 834         /* allocate URBs */
 835         pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
 836         if (pTxContext->pUrb == NULL) {
 837             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
 838             goto free_tx;
 839         }
 840         pTxContext->bBoolInUse = false;
 841     }
 842
 843     /* allocate RCB mem */
 844         pDevice->pRCBMem = kzalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
 845     if (pDevice->pRCBMem == NULL) {
 846         DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
 847         goto free_tx;
 848     }
 849
 850
 851     pDevice->FirstRecvFreeList = NULL;
 852     pDevice->LastRecvFreeList = NULL;
 853     pDevice->FirstRecvMngList = NULL;
 854     pDevice->LastRecvMngList = NULL;
 855     pDevice->NumRecvFreeList = 0;
 856     pRCB = (PRCB) pDevice->pRCBMem;
 857
 858     for (ii = 0; ii < pDevice->cbRD; ii++) {
 859
 860         pDevice->apRCB[ii] = pRCB;
 861         pRCB->pDevice = (void *) pDevice;
 862         /* allocate URBs */
 863         pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
 864
 865         if (pRCB->pUrb == NULL) {
 866             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
 867             goto free_rx_tx;
 868         }
 869         pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
 870         if (pRCB->skb == NULL) {
 871             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
 872             goto free_rx_tx;
 873         }
 874         pRCB->skb->dev = pDevice->dev;
 875         pRCB->bBoolInUse = false;
 876         EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
 877         pDevice->NumRecvFreeList++;
 878         pRCB++;
 879     }
 880
 881
 882         pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
 883         if (pDevice->pControlURB == NULL) {
 884             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
 885             goto free_rx_tx;
 886         }
 887
 888         pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
 889         if (pDevice->pInterruptURB == NULL) {
 890             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
 891             usb_free_urb(pDevice->pControlURB);
 892             goto free_rx_tx;
 893         }
 894
 895     pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
 896         if (pDevice->intBuf.pDataBuf == NULL) {
 897             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
 898             usb_free_urb(pDevice->pControlURB);
 899             usb_free_urb(pDevice->pInterruptURB);
 900             goto free_rx_tx;
 901         }
 902
 903     return true;
 904
 905 free_rx_tx:
 906     device_free_rx_bufs(pDevice);
 907
 908 free_tx:
 909     device_free_tx_bufs(pDevice);
 910
 911         return false;
 912 }
 913
 914
 915
 916
 917 static bool device_init_defrag_cb(struct vnt_private *pDevice)
 918 {
 919         int i;
 920         PSDeFragControlBlock pDeF;
 921
 922     /* Init the fragment ctl entries */
 923     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
 924         pDeF = &(pDevice->sRxDFCB[i]);
 925         if (!device_alloc_frag_buf(pDevice, pDeF)) {
 926             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
 927                 pDevice->dev->name);
 928             goto free_frag;
 929         }
 930     }
 931     pDevice->cbDFCB = CB_MAX_RX_FRAG;
 932     pDevice->cbFreeDFCB = pDevice->cbDFCB;
 933     return true;
 934
 935 free_frag:
 936     device_free_frag_bufs(pDevice);
 937     return false;
 938 }
 939
 940
 941
 942 static void device_free_frag_bufs(struct vnt_private *pDevice)
 943 {
 944         PSDeFragControlBlock pDeF;
 945         int i;
 946
 947     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
 948
 949         pDeF = &(pDevice->sRxDFCB[i]);
 950
 951         if (pDeF->skb)
 952             dev_kfree_skb(pDeF->skb);
 953     }
 954 }
 955
 956
 957
 958 int device_alloc_frag_buf(struct vnt_private *pDevice,
 959                 PSDeFragControlBlock pDeF)
 960 {
 961
 962     pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
 963     if (pDeF->skb == NULL)
 964         return false;
 965     ASSERT(pDeF->skb);
 966     pDeF->skb->dev = pDevice->dev;
 967
 968     return true;
 969 }
 970
 971
 972 /*-----------------------------------------------------------------*/
 973
 974 static int  device_open(struct net_device *dev)
 975 {
 976         struct vnt_private *pDevice = netdev_priv(dev);
 977
 978      pDevice->fWPA_Authened = false;
 979
 980     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
 981
 982
 983     pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
 984
 985     if (device_alloc_bufs(pDevice) == false) {
 986         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
 987         return -ENOMEM;
 988     }
 989
 990     if (device_init_defrag_cb(pDevice)== false) {
 991         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragment cb fail \n");
 992         goto free_rx_tx;
 993     }
 994
 995     MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
 996     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
 997     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
 998     MP_SET_FLAG(pDevice, fMP_POST_READS);
 999     MP_SET_FLAG(pDevice, fMP_POST_WRITES);
1000
1001     /* read config file */
1002     Read_config_file(pDevice);
1003
1004     if (device_init_registers(pDevice, DEVICE_INIT_COLD) == false) {
1005         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
1006         goto free_all;
1007     }
1008
1009     device_set_multi(pDevice->dev);
1010
1011     /* init for key management */
1012     KeyvInitTable(pDevice,&pDevice->sKey);
1013         memcpy(pDevice->vnt_mgmt.abyMACAddr,
1014                 pDevice->abyCurrentNetAddr, ETH_ALEN);
1015     memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1016     pDevice->bStopTx0Pkt = false;
1017     pDevice->bStopDataPkt = false;
1018     pDevice->bRoaming = false;
1019     pDevice->bIsRoaming = false;
1020     pDevice->bEnableRoaming = false;
1021     if (pDevice->bDiversityRegCtlON) {
1022         device_init_diversity_timer(pDevice);
1023     }
1024
1025     vMgrObjectInit(pDevice);
1026     tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
1027     tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
1028     tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
1029         add_timer(&pDevice->vnt_mgmt.sTimerSecondCallback);
1030         pDevice->int_interval = 100;  /* max 100 microframes */
1031     pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1032
1033     pDevice->bIsRxWorkItemQueued = true;
1034     pDevice->fKillEventPollingThread = false;
1035     pDevice->bEventAvailable = false;
1036
1037    pDevice->bWPADEVUp = false;
1038      pDevice->bwextstep0 = false;
1039      pDevice->bwextstep1 = false;
1040      pDevice->bwextstep2 = false;
1041      pDevice->bwextstep3 = false;
1042      pDevice->bWPASuppWextEnabled = false;
1043     pDevice->byReAssocCount = 0;
1044
1045     RXvWorkItem(pDevice);
1046     INTvWorkItem(pDevice);
1047
1048     /* if WEP key already set by iwconfig but device not yet open */
1049     if ((pDevice->bEncryptionEnable == true) && (pDevice->bTransmitKey == true)) {
1050          spin_lock_irq(&pDevice->lock);
1051          KeybSetDefaultKey( pDevice,
1052                             &(pDevice->sKey),
1053                             pDevice->byKeyIndex | (1 << 31),
1054                             pDevice->uKeyLength,
1055                             NULL,
1056                             pDevice->abyKey,
1057                             KEY_CTL_WEP
1058                           );
1059          spin_unlock_irq(&pDevice->lock);
1060          pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1061     }
1062
1063         if (pDevice->vnt_mgmt.eConfigMode == WMAC_CONFIG_AP)
1064                 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1065         else
1066                 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1067
1068
1069     netif_stop_queue(pDevice->dev);
1070     pDevice->flags |= DEVICE_FLAGS_OPENED;
1071
1072         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success..\n");
1073         return 0;
1074
1075 free_all:
1076     device_free_frag_bufs(pDevice);
1077 free_rx_tx:
1078     device_free_rx_bufs(pDevice);
1079     device_free_tx_bufs(pDevice);
1080     device_free_int_bufs(pDevice);
1081         usb_kill_urb(pDevice->pControlURB);
1082         usb_kill_urb(pDevice->pInterruptURB);
1083     usb_free_urb(pDevice->pControlURB);
1084     usb_free_urb(pDevice->pInterruptURB);
1085
1086     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1087     return -ENOMEM;
1088 }
1089
1090
1091
1092 static int device_close(struct net_device *dev)
1093 {
1094         struct vnt_private *pDevice = netdev_priv(dev);
1095         struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
1096         int uu;
1097
1098         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1\n");
1099     if (pDevice == NULL)
1100         return -ENODEV;
1101
1102     if (pDevice->bLinkPass) {
1103         bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1104         mdelay(30);
1105     }
1106
1107
1108         memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1109         pMgmt->bShareKeyAlgorithm = false;
1110         pDevice->bEncryptionEnable = false;
1111         pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1112         spin_lock_irq(&pDevice->lock);
1113         for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1114                 MACvDisableKeyEntry(pDevice,uu);
1115         spin_unlock_irq(&pDevice->lock);
1116
1117     if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == false) {
1118         MACbShutdown(pDevice);
1119     }
1120     netif_stop_queue(pDevice->dev);
1121     MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1122     MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1123     MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1124     pDevice->fKillEventPollingThread = true;
1125     del_timer(&pDevice->sTimerCommand);
1126     del_timer(&pMgmt->sTimerSecondCallback);
1127
1128     del_timer(&pDevice->sTimerTxData);
1129
1130     if (pDevice->bDiversityRegCtlON) {
1131         del_timer(&pDevice->TimerSQ3Tmax1);
1132         del_timer(&pDevice->TimerSQ3Tmax2);
1133         del_timer(&pDevice->TimerSQ3Tmax3);
1134     }
1135     tasklet_kill(&pDevice->RxMngWorkItem);
1136     tasklet_kill(&pDevice->ReadWorkItem);
1137     tasklet_kill(&pDevice->EventWorkItem);
1138
1139    pDevice->bRoaming = false;
1140    pDevice->bIsRoaming = false;
1141    pDevice->bEnableRoaming = false;
1142     pDevice->bCmdRunning = false;
1143     pDevice->bLinkPass = false;
1144     memset(pMgmt->abyCurrBSSID, 0, 6);
1145     pMgmt->eCurrState = WMAC_STATE_IDLE;
1146
1147     device_free_tx_bufs(pDevice);
1148     device_free_rx_bufs(pDevice);
1149     device_free_int_bufs(pDevice);
1150     device_free_frag_bufs(pDevice);
1151
1152         usb_kill_urb(pDevice->pControlURB);
1153         usb_kill_urb(pDevice->pInterruptURB);
1154     usb_free_urb(pDevice->pControlURB);
1155     usb_free_urb(pDevice->pInterruptURB);
1156
1157     BSSvClearNodeDBTable(pDevice, 0);
1158     pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1159
1160     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1161
1162     return 0;
1163 }
1164
1165 static void vt6656_disconnect(struct usb_interface *intf)
1166 {
1167         struct vnt_private *device = usb_get_intfdata(intf);
1168
1169         if (!device)
1170                 return;
1171
1172
1173         usb_set_intfdata(intf, NULL);
1174         usb_put_dev(interface_to_usbdev(intf));
1175
1176         device->flags |= DEVICE_FLAGS_UNPLUG;
1177
1178         if (device->dev) {
1179                 unregister_netdev(device->dev);
1180                 free_netdev(device->dev);
1181         }
1182
1183 }
1184
1185 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1186 {
1187         struct vnt_private *pDevice = netdev_priv(dev);
1188
1189         spin_lock_irq(&pDevice->lock);
1190
1191         if (unlikely(pDevice->bStopTx0Pkt))
1192                 dev_kfree_skb_irq(skb);
1193         else
1194                 vDMA0_tx_80211(pDevice, skb);
1195
1196         spin_unlock_irq(&pDevice->lock);
1197
1198         return NETDEV_TX_OK;
1199 }
1200
1201 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1202 {
1203         struct vnt_private *pDevice = netdev_priv(dev);
1204         struct net_device_stats *stats = &pDevice->stats;
1205
1206         spin_lock_irq(&pDevice->lock);
1207
1208         netif_stop_queue(dev);
1209
1210         if (!pDevice->bLinkPass) {
1211                 dev_kfree_skb_irq(skb);
1212                 goto out;
1213         }
1214
1215         if (pDevice->bStopDataPkt) {
1216                 dev_kfree_skb_irq(skb);
1217                 stats->tx_dropped++;
1218                 goto out;
1219         }
1220
1221         if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1222                 if (netif_queue_stopped(dev))
1223                         netif_wake_queue(dev);
1224         }
1225
1226 out:
1227         spin_unlock_irq(&pDevice->lock);
1228
1229         return NETDEV_TX_OK;
1230 }
1231
1232 static unsigned const ethernet_polynomial = 0x04c11db7U;
1233 static inline u32 ether_crc(int length, unsigned char *data)
1234 {
1235     int crc = -1;
1236
1237     while(--length >= 0) {
1238         unsigned char current_octet = *data++;
1239         int bit;
1240         for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1241             crc = (crc << 1) ^
1242                 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1243         }
1244     }
1245     return crc;
1246 }
1247
1248 /* find out the start position of str2 from str1 */
1249 static unsigned char *kstrstr(const unsigned char *str1,
1250                               const unsigned char *str2) {
1251   int str1_len = strlen(str1);
1252   int str2_len = strlen(str2);
1253
1254   while (str1_len >= str2_len) {
1255        str1_len--;
1256       if(memcmp(str1,str2,str2_len)==0)
1257         return (unsigned char *) str1;
1258         str1++;
1259   }
1260   return NULL;
1261 }
1262
1263 static int Config_FileGetParameter(unsigned char *string,
1264                                    unsigned char *dest,
1265                                    unsigned char *source)
1266 {
1267   unsigned char buf1[100];
1268   unsigned char buf2[100];
1269   unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1270   int ii;
1271
1272     memset(buf1,0,100);
1273     strcat(buf1, string);
1274     strcat(buf1, "=");
1275     source+=strlen(buf1);
1276
1277     /* find target string start point */
1278     start_p = kstrstr(source,buf1);
1279     if (start_p == NULL)
1280         return false;
1281
1282     /* check if current config line is marked by "#" */
1283     for (ii = 1; ; ii++) {
1284         if (memcmp(start_p - ii, "\n", 1) == 0)
1285                 break;
1286         if (memcmp(start_p - ii, "#", 1) == 0)
1287                 return false;
1288     }
1289
1290     /* find target string end point */
1291      end_p = kstrstr(start_p,"\n");
1292      if (end_p == NULL) {       /* can't find "\n", but don't care */
1293              end_p = start_p + strlen(start_p);   /* no include "\n" */
1294      }
1295
1296    memset(buf2,0,100);
1297    memcpy(buf2, start_p, end_p-start_p); /* get the target line */
1298    buf2[end_p-start_p]='\0';
1299
1300    /* find value */
1301    start_p = kstrstr(buf2,"=");
1302    if (start_p == NULL)
1303       return false;
1304    memset(buf1,0,100);
1305    strcpy(buf1,start_p+1);
1306
1307    /* except space */
1308   tmp_p = buf1;
1309   while(*tmp_p != 0x00) {
1310         if(*tmp_p==' ')
1311             tmp_p++;
1312          else
1313           break;
1314   }
1315
1316    memcpy(dest,tmp_p,strlen(tmp_p));
1317  return true;
1318 }
1319
1320 /* if read fails, return NULL, or return data pointer */
1321 static unsigned char *Config_FileOperation(struct vnt_private *pDevice)
1322 {
1323     unsigned char *config_path = CONFIG_PATH;
1324     unsigned char *buffer = NULL;
1325     struct file   *filp=NULL;
1326     mm_segment_t old_fs = get_fs();
1327
1328     int result = 0;
1329
1330     set_fs (KERNEL_DS);
1331
1332     /* open file */
1333       filp = filp_open(config_path, O_RDWR, 0);
1334         if (IS_ERR(filp)) {
1335              printk("Config_FileOperation file Not exist\n");
1336              result=-1;
1337              goto error2;
1338           }
1339
1340      if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1341            printk("file %s is not read or writeable?\n",config_path);
1342           result = -1;
1343           goto error1;
1344         }
1345
1346     buffer = kmalloc(1024, GFP_KERNEL);
1347     if(buffer==NULL) {
1348       printk("allocate mem for file fail?\n");
1349       result = -1;
1350       goto error1;
1351     }
1352
1353     if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1354      printk("read file error?\n");
1355      result = -1;
1356     }
1357
1358 error1:
1359   if(filp_close(filp,NULL))
1360        printk("Config_FileOperation:close file fail\n");
1361
1362 error2:
1363   set_fs (old_fs);
1364
1365 if(result!=0) {
1366     kfree(buffer);
1367     buffer=NULL;
1368 }
1369   return buffer;
1370 }
1371
1372 /* return --->-1:fail; >=0:successful */
1373 static int Read_config_file(struct vnt_private *pDevice)
1374 {
1375         int result = 0;
1376         unsigned char tmpbuffer[100];
1377         unsigned char *buffer = NULL;
1378
1379         /* init config setting */
1380  pDevice->config_file.ZoneType = -1;
1381  pDevice->config_file.eAuthenMode = -1;
1382  pDevice->config_file.eEncryptionStatus = -1;
1383
1384   buffer = Config_FileOperation(pDevice);
1385   if (buffer == NULL) {
1386      result =-1;
1387      return result;
1388   }
1389
1390 /* get zonetype */
1391 {
1392     memset(tmpbuffer,0,sizeof(tmpbuffer));
1393     if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==true) {
1394     if(memcmp(tmpbuffer,"USA",3)==0) {
1395       pDevice->config_file.ZoneType=ZoneType_USA;
1396     }
1397     else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1398       pDevice->config_file.ZoneType=ZoneType_Japan;
1399     }
1400     else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1401      pDevice->config_file.ZoneType=ZoneType_Europe;
1402     }
1403     else {
1404       printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1405    }
1406  }
1407 }
1408
1409 /* get other parameter */
1410   {
1411         memset(tmpbuffer,0,sizeof(tmpbuffer));
1412        if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==true) {
1413          pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1414        }
1415
1416         memset(tmpbuffer,0,sizeof(tmpbuffer));
1417        if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==true) {
1418          pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1419        }
1420   }
1421
1422   kfree(buffer);
1423   return result;
1424 }
1425
1426 static void device_set_multi(struct net_device *dev)
1427 {
1428         struct vnt_private *pDevice = netdev_priv(dev);
1429         struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
1430         struct netdev_hw_addr *ha;
1431         u32 mc_filter[2];
1432         int ii;
1433         u8 pbyData[8] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1434         u8 byTmpMode = 0;
1435         int rc;
1436
1437
1438         spin_lock_irq(&pDevice->lock);
1439     rc = CONTROLnsRequestIn(pDevice,
1440                             MESSAGE_TYPE_READ,
1441                             MAC_REG_RCR,
1442                             MESSAGE_REQUEST_MACREG,
1443                             1,
1444                             &byTmpMode
1445                             );
1446     if (rc == 0) pDevice->byRxMode = byTmpMode;
1447
1448     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1449
1450     if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
1451         DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1452         /* unconditionally log net taps */
1453         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1454     }
1455     else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1456              (dev->flags & IFF_ALLMULTI)) {
1457         CONTROLnsRequestOut(pDevice,
1458                             MESSAGE_TYPE_WRITE,
1459                             MAC_REG_MAR0,
1460                             MESSAGE_REQUEST_MACREG,
1461                             8,
1462                             pbyData
1463                             );
1464         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1465     }
1466     else {
1467         memset(mc_filter, 0, sizeof(mc_filter));
1468         netdev_for_each_mc_addr(ha, dev) {
1469             int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1470             mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1471         }
1472         for (ii = 0; ii < 4; ii++) {
1473              MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1474              MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1475         }
1476         pDevice->byRxMode &= ~(RCR_UNICAST);
1477         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1478     }
1479
1480     if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1481         /*
1482          * If AP mode, don't enable RCR_UNICAST since HW only compares
1483          * addr1 with local MAC
1484          */
1485         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1486         pDevice->byRxMode &= ~(RCR_UNICAST);
1487     }
1488     ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1489     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1490         spin_unlock_irq(&pDevice->lock);
1491
1492 }
1493
1494 static struct net_device_stats *device_get_stats(struct net_device *dev)
1495 {
1496         struct vnt_private *pDevice = netdev_priv(dev);
1497
1498         return &pDevice->stats;
1499 }
1500
1501 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1502 {
1503         struct vnt_private *pDevice = netdev_priv(dev);
1504         struct iwreq *wrq = (struct iwreq *) rq;
1505         int rc = 0;
1506
1507         switch (cmd) {
1508
1509         case IOCTL_CMD_HOSTAPD:
1510
1511                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED))
1512                         rc = -EFAULT;
1513
1514                 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
1515                 break;
1516
1517         case SIOCETHTOOL:
1518                 return ethtool_ioctl(dev, (void *) rq->ifr_data);
1519
1520         }
1521
1522         return rc;
1523 }
1524
1525
1526 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
1527 {
1528         u32 ethcmd;
1529
1530         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
1531                 return -EFAULT;
1532
1533         switch (ethcmd) {
1534         case ETHTOOL_GDRVINFO: {
1535                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
1536                 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
1537                 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
1538                 if (copy_to_user(useraddr, &info, sizeof(info)))
1539                         return -EFAULT;
1540                 return 0;
1541         }
1542
1543         }
1544
1545         return -EOPNOTSUPP;
1546 }
1547
1548 MODULE_DEVICE_TABLE(usb, vt6656_table);
1549
1550 static struct usb_driver vt6656_driver = {
1551         .name =         DEVICE_NAME,
1552         .probe =        vt6656_probe,
1553         .disconnect =   vt6656_disconnect,
1554         .id_table =     vt6656_table,
1555 #ifdef CONFIG_PM
1556         .suspend = vt6656_suspend,
1557         .resume = vt6656_resume,
1558 #endif /* CONFIG_PM */
1559 };
1560
1561 module_usb_driver(vt6656_driver);