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 <linux/file.h>
  50 #include "device.h"
  51 #include "card.h"
  52 #include "baseband.h"
  53 #include "mac.h"
  54 #include "tether.h"
  55 #include "wmgr.h"
  56 #include "wctl.h"
  57 #include "power.h"
  58 #include "wcmd.h"
  59 #include "iocmd.h"
  60 #include "tcrc.h"
  61 #include "rxtx.h"
  62 #include "bssdb.h"
  63 #include "hostap.h"
  64 #include "wpactl.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 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 #define TX_DESC_DEF0     64
  99 DEVICE_PARAM(TxDescriptors0,"Number of transmit usb desc buffer");
 100
 101 #define CHANNEL_DEF     6
 102 DEVICE_PARAM(Channel, "Channel number");
 103
 104 /* PreambleType[] is the preamble length used for transmit.
 105    0: indicate allows long preamble type
 106    1: indicate allows short preamble type
 107 */
 108
 109 #define PREAMBLE_TYPE_DEF     1
 110
 111 DEVICE_PARAM(PreambleType, "Preamble Type");
 112
 113 #define RTS_THRESH_DEF     2347
 114 DEVICE_PARAM(RTSThreshold, "RTS threshold");
 115
 116 #define FRAG_THRESH_DEF     2346
 117 DEVICE_PARAM(FragThreshold, "Fragmentation threshold");
 118
 119 #define DATA_RATE_DEF     13
 120 /* datarate[] index
 121    0: indicate 1 Mbps   0x02
 122    1: indicate 2 Mbps   0x04
 123    2: indicate 5.5 Mbps 0x0B
 124    3: indicate 11 Mbps  0x16
 125    4: indicate 6 Mbps   0x0c
 126    5: indicate 9 Mbps   0x12
 127    6: indicate 12 Mbps  0x18
 128    7: indicate 18 Mbps  0x24
 129    8: indicate 24 Mbps  0x30
 130    9: indicate 36 Mbps  0x48
 131   10: indicate 48 Mbps  0x60
 132   11: indicate 54 Mbps  0x6c
 133   12: indicate 72 Mbps  0x90
 134   13: indicate auto rate
 135 */
 136
 137 DEVICE_PARAM(ConnectionRate, "Connection data rate");
 138
 139 #define OP_MODE_DEF     0
 140 DEVICE_PARAM(OPMode, "Infrastruct, adhoc, AP mode ");
 141
 142 /* OpMode[] is used for transmit.
 143    0: indicate infrastruct mode used
 144    1: indicate adhoc mode used
 145    2: indicate AP mode used
 146 */
 147
 148 /* PSMode[]
 149    0: indicate disable power saving mode
 150    1: indicate enable power saving mode
 151 */
 152
 153 #define PS_MODE_DEF     0
 154 DEVICE_PARAM(PSMode, "Power saving mode");
 155
 156 #define SHORT_RETRY_DEF     8
 157 DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits");
 158
 159 #define LONG_RETRY_DEF     4
 160 DEVICE_PARAM(LongRetryLimit, "long frame retry limits");
 161
 162 /* BasebandType[] baseband type selected
 163    0: indicate 802.11a type
 164    1: indicate 802.11b type
 165    2: indicate 802.11g type
 166 */
 167
 168 #define BBP_TYPE_DEF     2
 169 DEVICE_PARAM(BasebandType, "baseband type");
 170
 171 /* 80211hEnable[]
 172    0: indicate disable 802.11h
 173    1: indicate enable 802.11h
 174 */
 175
 176 #define X80211h_MODE_DEF     0
 177
 178 DEVICE_PARAM(b80211hEnable, "802.11h mode");
 179
 180 /*
 181  * Static vars definitions
 182  */
 183
 184 static struct usb_device_id vt6656_table[] = {
 185         {USB_DEVICE(VNT_USB_VENDOR_ID, VNT_USB_PRODUCT_ID)},
 186         {}
 187 };
 188
 189 /* frequency list (map channels to frequencies) */
 190 /*
 191 static const long frequency_list[] = {
 192     2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484,
 193     4915, 4920, 4925, 4935, 4940, 4945, 4960, 4980,
 194     5035, 5040, 5045, 5055, 5060, 5080, 5170, 5180, 5190, 5200, 5210, 5220, 5230, 5240,
 195     5260, 5280, 5300, 5320, 5500, 5520, 5540, 5560, 5580, 5600, 5620, 5640, 5660, 5680,
 196     5700, 5745, 5765, 5785, 5805, 5825
 197         };
 198
 199 static const struct iw_handler_def      iwctl_handler_def;
 200 */
 201
 202 static int vt6656_probe(struct usb_interface *intf,
 203                         const struct usb_device_id *id);
 204 static void vt6656_disconnect(struct usb_interface *intf);
 205
 206 #ifdef CONFIG_PM        /* Minimal support for suspend and resume */
 207 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message);
 208 static int vt6656_resume(struct usb_interface *intf);
 209 #endif /* CONFIG_PM */
 210
 211 static struct net_device_stats *device_get_stats(struct net_device *dev);
 212 static int  device_open(struct net_device *dev);
 213 static int  device_xmit(struct sk_buff *skb, struct net_device *dev);
 214 static void device_set_multi(struct net_device *dev);
 215 static int  device_close(struct net_device *dev);
 216 static int  device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 217
 218 static int device_init_registers(struct vnt_private *pDevice,
 219         DEVICE_INIT_TYPE InitType);
 220 static bool device_init_defrag_cb(struct vnt_private *pDevice);
 221 static void device_init_diversity_timer(struct vnt_private *pDevice);
 222 static int  device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
 223
 224 static int  ethtool_ioctl(struct net_device *dev, void *useraddr);
 225 static void device_free_tx_bufs(struct vnt_private *pDevice);
 226 static void device_free_rx_bufs(struct vnt_private *pDevice);
 227 static void device_free_int_bufs(struct vnt_private *pDevice);
 228 static void device_free_frag_bufs(struct vnt_private *pDevice);
 229 static bool device_alloc_bufs(struct vnt_private *pDevice);
 230
 231 static int Read_config_file(struct vnt_private *pDevice);
 232 static unsigned char *Config_FileOperation(struct vnt_private *pDevice);
 233 static int Config_FileGetParameter(unsigned char *string,
 234                                    unsigned char *dest,
 235                                    unsigned char *source);
 236
 237 static void usb_device_reset(struct vnt_private *pDevice);
 238
 239 static void
 240 device_set_options(struct vnt_private *pDevice) {
 241
 242     u8    abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 243     u8    abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
 244     u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
 245
 246     memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
 247     memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
 248     memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, ETH_ALEN);
 249
 250     pDevice->cbTD = TX_DESC_DEF0;
 251     pDevice->cbRD = RX_DESC_DEF0;
 252     pDevice->uChannel = CHANNEL_DEF;
 253     pDevice->wRTSThreshold = RTS_THRESH_DEF;
 254     pDevice->wFragmentationThreshold = FRAG_THRESH_DEF;
 255     pDevice->byShortRetryLimit = SHORT_RETRY_DEF;
 256     pDevice->byLongRetryLimit = LONG_RETRY_DEF;
 257     pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
 258     pDevice->byShortPreamble = PREAMBLE_TYPE_DEF;
 259     pDevice->ePSMode = PS_MODE_DEF;
 260     pDevice->b11hEnable = X80211h_MODE_DEF;
 261     pDevice->eOPMode = OP_MODE_DEF;
 262     pDevice->uConnectionRate = DATA_RATE_DEF;
 263     if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = true;
 264     pDevice->byBBType = BBP_TYPE_DEF;
 265     pDevice->byPacketType = pDevice->byBBType;
 266     pDevice->byAutoFBCtrl = AUTO_FB_0;
 267     pDevice->bUpdateBBVGA = true;
 268     pDevice->byFOETuning = 0;
 269     pDevice->byAutoPwrTunning = 0;
 270     pDevice->byPreambleType = 0;
 271     pDevice->bExistSWNetAddr = false;
 272     /* pDevice->bDiversityRegCtlON = true; */
 273     pDevice->bDiversityRegCtlON = false;
 274 }
 275
 276 static void device_init_diversity_timer(struct vnt_private *pDevice)
 277 {
 278     init_timer(&pDevice->TimerSQ3Tmax1);
 279     pDevice->TimerSQ3Tmax1.data = (unsigned long)pDevice;
 280     pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
 281     pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
 282
 283     init_timer(&pDevice->TimerSQ3Tmax2);
 284     pDevice->TimerSQ3Tmax2.data = (unsigned long)pDevice;
 285     pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
 286     pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
 287
 288     init_timer(&pDevice->TimerSQ3Tmax3);
 289     pDevice->TimerSQ3Tmax3.data = (unsigned long)pDevice;
 290     pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerSQ3Tmax3CallBack;
 291     pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
 292
 293     return;
 294 }
 295
 296 /*
 297  * initialization of MAC & BBP registers
 298  */
 299
 300 static int device_init_registers(struct vnt_private *pDevice,
 301         DEVICE_INIT_TYPE InitType)
 302 {
 303         struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
 304         u8 abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 305         u8 abySNAP_RFC1042[ETH_ALEN] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00};
 306         u8 abySNAP_Bridgetunnel[ETH_ALEN]
 307                 = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8};
 308         u8 byAntenna;
 309         int ii;
 310         CMD_CARD_INIT sInitCmd;
 311         int ntStatus = STATUS_SUCCESS;
 312         RSP_CARD_INIT   sInitRsp;
 313         u8 byTmp;
 314         u8 byCalibTXIQ = 0, byCalibTXDC = 0, byCalibRXIQ = 0;
 315
 316     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---->INIbInitAdapter. [%d][%d]\n", InitType, pDevice->byPacketType);
 317         spin_lock_irq(&pDevice->lock);
 318         if (InitType == DEVICE_INIT_COLD) {
 319                 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
 320                 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
 321                 memcpy(pDevice->abySNAP_Bridgetunnel,
 322                        abySNAP_Bridgetunnel,
 323                        ETH_ALEN);
 324
 325         if ( !FIRMWAREbCheckVersion(pDevice) ) {
 326             if (FIRMWAREbDownload(pDevice) == true) {
 327                 if (FIRMWAREbBrach2Sram(pDevice) == false) {
 328                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbBrach2Sram fail \n");
 329                         spin_unlock_irq(&pDevice->lock);
 330                     return false;
 331                 }
 332             } else {
 333
 334                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbDownload fail \n");
 335                 spin_unlock_irq(&pDevice->lock);
 336                 return false;
 337             }
 338         }
 339
 340         if ( !BBbVT3184Init(pDevice) ) {
 341             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" BBbVT3184Init fail \n");
 342             spin_unlock_irq(&pDevice->lock);
 343             return false;
 344         }
 345     }
 346
 347     sInitCmd.byInitClass = (u8)InitType;
 348     sInitCmd.bExistSWNetAddr = (u8) pDevice->bExistSWNetAddr;
 349     for (ii = 0; ii < 6; ii++)
 350         sInitCmd.bySWNetAddr[ii] = pDevice->abyCurrentNetAddr[ii];
 351     sInitCmd.byShortRetryLimit = pDevice->byShortRetryLimit;
 352     sInitCmd.byLongRetryLimit = pDevice->byLongRetryLimit;
 353
 354     /* issue card_init command to device */
 355     ntStatus = CONTROLnsRequestOut(pDevice,
 356                                     MESSAGE_TYPE_CARDINIT,
 357                                     0,
 358                                     0,
 359                                     sizeof(CMD_CARD_INIT),
 360                                     (u8 *) &(sInitCmd));
 361
 362     if ( ntStatus != STATUS_SUCCESS ) {
 363         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Issue Card init fail \n");
 364         spin_unlock_irq(&pDevice->lock);
 365         return false;
 366     }
 367     if (InitType == DEVICE_INIT_COLD) {
 368
 369         ntStatus = CONTROLnsRequestIn(pDevice,MESSAGE_TYPE_INIT_RSP,0,0,sizeof(RSP_CARD_INIT), (u8 *) &(sInitRsp));
 370
 371         if (ntStatus != STATUS_SUCCESS) {
 372             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Cardinit request in status fail!\n");
 373             spin_unlock_irq(&pDevice->lock);
 374             return false;
 375         }
 376
 377         /* local ID for AES functions */
 378         ntStatus = CONTROLnsRequestIn(pDevice,
 379                                     MESSAGE_TYPE_READ,
 380                                     MAC_REG_LOCALID,
 381                                     MESSAGE_REQUEST_MACREG,
 382                                     1,
 383                                     &pDevice->byLocalID);
 384
 385         if ( ntStatus != STATUS_SUCCESS ) {
 386             spin_unlock_irq(&pDevice->lock);
 387             return false;
 388         }
 389
 390         /* do MACbSoftwareReset in MACvInitialize */
 391
 392         /* force CCK */
 393         pDevice->bCCK = true;
 394         pDevice->bProtectMode = false;
 395         /* only used in 11g type, sync with ERP IE */
 396         pDevice->bNonERPPresent = false;
 397         pDevice->bBarkerPreambleMd = false;
 398         if ( pDevice->bFixRate ) {
 399             pDevice->wCurrentRate = (u16) pDevice->uConnectionRate;
 400         } else {
 401             if ( pDevice->byBBType == BB_TYPE_11B )
 402                 pDevice->wCurrentRate = RATE_11M;
 403             else
 404                 pDevice->wCurrentRate = RATE_54M;
 405         }
 406
 407         CHvInitChannelTable(pDevice);
 408
 409         pDevice->byTopOFDMBasicRate = RATE_24M;
 410         pDevice->byTopCCKBasicRate = RATE_1M;
 411         pDevice->byRevId = 0;
 412         /* target to IF pin while programming to RF chip */
 413         pDevice->byCurPwr = 0xFF;
 414
 415         pDevice->byCCKPwr = pDevice->abyEEPROM[EEP_OFS_PWR_CCK];
 416         pDevice->byOFDMPwrG = pDevice->abyEEPROM[EEP_OFS_PWR_OFDMG];
 417         /* load power table */
 418         for (ii = 0; ii < 14; ii++) {
 419             pDevice->abyCCKPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_CCK_PWR_TBL];
 420             if (pDevice->abyCCKPwrTbl[ii] == 0)
 421                 pDevice->abyCCKPwrTbl[ii] = pDevice->byCCKPwr;
 422             pDevice->abyOFDMPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDM_PWR_TBL];
 423             if (pDevice->abyOFDMPwrTbl[ii] == 0)
 424                 pDevice->abyOFDMPwrTbl[ii] = pDevice->byOFDMPwrG;
 425         }
 426
 427         /*
 428          * original zonetype is USA, but custom zonetype is Europe,
 429          * then need to recover 12, 13, 14 channels with 11 channel
 430          */
 431           if(((pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Japan) ||
 432                 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Europe))&&
 433              (pDevice->byOriginalZonetype == ZoneType_USA)) {
 434                 for (ii = 11; ii < 14; ii++) {
 435                         pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];
 436                         pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];
 437                 }
 438           }
 439
 440           pDevice->byOFDMPwrA = 0x34; /* same as RFbMA2829SelectChannel */
 441
 442           /* load OFDM A power table */
 443           for (ii = 0; ii < CB_MAX_CHANNEL_5G; ii++) {
 444             pDevice->abyOFDMAPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDMA_PWR_TBL];
 445             if (pDevice->abyOFDMAPwrTbl[ii] == 0)
 446                 pDevice->abyOFDMAPwrTbl[ii] = pDevice->byOFDMPwrA;
 447         }
 448
 449         byAntenna = pDevice->abyEEPROM[EEP_OFS_ANTENNA];
 450         if (byAntenna & EEP_ANTINV)
 451             pDevice->bTxRxAntInv = true;
 452         else
 453             pDevice->bTxRxAntInv = false;
 454
 455         byAntenna &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
 456
 457         if (byAntenna == 0) /* if not set default is both */
 458             byAntenna = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
 459
 460         if (byAntenna == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
 461             pDevice->byAntennaCount = 2;
 462             pDevice->byTxAntennaMode = ANT_B;
 463             pDevice->dwTxAntennaSel = 1;
 464             pDevice->dwRxAntennaSel = 1;
 465             if (pDevice->bTxRxAntInv == true)
 466                 pDevice->byRxAntennaMode = ANT_A;
 467             else
 468                 pDevice->byRxAntennaMode = ANT_B;
 469
 470             if (pDevice->bDiversityRegCtlON)
 471                 pDevice->bDiversityEnable = true;
 472             else
 473                 pDevice->bDiversityEnable = false;
 474         } else  {
 475             pDevice->bDiversityEnable = false;
 476             pDevice->byAntennaCount = 1;
 477             pDevice->dwTxAntennaSel = 0;
 478             pDevice->dwRxAntennaSel = 0;
 479             if (byAntenna & EEP_ANTENNA_AUX) {
 480                 pDevice->byTxAntennaMode = ANT_A;
 481                 if (pDevice->bTxRxAntInv == true)
 482                     pDevice->byRxAntennaMode = ANT_B;
 483                 else
 484                     pDevice->byRxAntennaMode = ANT_A;
 485             } else {
 486                 pDevice->byTxAntennaMode = ANT_B;
 487                 if (pDevice->bTxRxAntInv == true)
 488                     pDevice->byRxAntennaMode = ANT_A;
 489                 else
 490                     pDevice->byRxAntennaMode = ANT_B;
 491             }
 492         }
 493         pDevice->ulDiversityNValue = 100*255;
 494         pDevice->ulDiversityMValue = 100*16;
 495         pDevice->byTMax = 1;
 496         pDevice->byTMax2 = 4;
 497         pDevice->ulSQ3TH = 0;
 498         pDevice->byTMax3 = 64;
 499
 500         /* get Auto Fall Back type */
 501         pDevice->byAutoFBCtrl = AUTO_FB_0;
 502
 503         /* set SCAN Time */
 504         pDevice->uScanTime = WLAN_SCAN_MINITIME;
 505
 506         /* default Auto Mode */
 507         /* pDevice->NetworkType = Ndis802_11Automode; */
 508         pDevice->eConfigPHYMode = PHY_TYPE_AUTO;
 509         pDevice->byBBType = BB_TYPE_11G;
 510
 511         /* initialize BBP registers */
 512         pDevice->ulTxPower = 25;
 513
 514         /* get channel range */
 515         pDevice->byMinChannel = 1;
 516         pDevice->byMaxChannel = CB_MAX_CHANNEL;
 517
 518         /* get RFType */
 519         pDevice->byRFType = sInitRsp.byRFType;
 520
 521         if ((pDevice->byRFType & RF_EMU) != 0) {
 522                 /* force change RevID for VT3253 emu */
 523                 pDevice->byRevId = 0x80;
 524         }
 525
 526         /* load vt3266 calibration parameters in EEPROM */
 527         if (pDevice->byRFType == RF_VT3226D0) {
 528             if((pDevice->abyEEPROM[EEP_OFS_MAJOR_VER] == 0x1) &&
 529                 (pDevice->abyEEPROM[EEP_OFS_MINOR_VER] >= 0x4)) {
 530                 byCalibTXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_IQ];
 531                 byCalibTXDC = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_DC];
 532                 byCalibRXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_RX_IQ];
 533                 if( (byCalibTXIQ || byCalibTXDC || byCalibRXIQ) ) {
 534                         /* CR255, enable TX/RX IQ and DC compensation mode */
 535                         ControlvWriteByte(pDevice,
 536                                           MESSAGE_REQUEST_BBREG,
 537                                           0xFF,
 538                                           0x03);
 539                         /* CR251, TX I/Q Imbalance Calibration */
 540                         ControlvWriteByte(pDevice,
 541                                           MESSAGE_REQUEST_BBREG,
 542                                           0xFB,
 543                                           byCalibTXIQ);
 544                         /* CR252, TX DC-Offset Calibration */
 545                         ControlvWriteByte(pDevice,
 546                                           MESSAGE_REQUEST_BBREG,
 547                                           0xFC,
 548                                           byCalibTXDC);
 549                         /* CR253, RX I/Q Imbalance Calibration */
 550                         ControlvWriteByte(pDevice,
 551                                           MESSAGE_REQUEST_BBREG,
 552                                           0xFD,
 553                                           byCalibRXIQ);
 554                 } else {
 555                         /* CR255, turn off BB Calibration compensation */
 556                         ControlvWriteByte(pDevice,
 557                                           MESSAGE_REQUEST_BBREG,
 558                                           0xFF,
 559                                           0x0);
 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 it */
 575         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %pM\n",
 576                 pDevice->abyCurrentNetAddr);
 577     }
 578
 579     /*
 580      * set BB and packet type at the same time
 581      * set Short Slot Time, xIFS, and RSPINF
 582      */
 583     if (pDevice->byBBType == BB_TYPE_11A) {
 584         CARDbAddBasicRate(pDevice, RATE_6M);
 585         pDevice->bShortSlotTime = true;
 586     } else {
 587         CARDbAddBasicRate(pDevice, RATE_1M);
 588         pDevice->bShortSlotTime = false;
 589     }
 590     BBvSetShortSlotTime(pDevice);
 591     CARDvSetBSSMode(pDevice);
 592
 593     if (pDevice->bUpdateBBVGA) {
 594         pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
 595         pDevice->byBBVGANew = pDevice->byBBVGACurrent;
 596         BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
 597     }
 598
 599     pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];
 600     pDevice->bHWRadioOff = false;
 601     if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) {
 602         ntStatus = CONTROLnsRequestIn(pDevice,
 603                                     MESSAGE_TYPE_READ,
 604                                     MAC_REG_GPIOCTL1,
 605                                     MESSAGE_REQUEST_MACREG,
 606                                     1,
 607                                     &byTmp);
 608
 609         if ( ntStatus != STATUS_SUCCESS ) {
 610             spin_unlock_irq(&pDevice->lock);
 611             return false;
 612         }
 613         if ( (byTmp & GPIO3_DATA) == 0 ) {
 614             pDevice->bHWRadioOff = true;
 615             MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
 616         } else {
 617             MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
 618             pDevice->bHWRadioOff = false;
 619         }
 620
 621     }
 622
 623     ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
 624     ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
 625     MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01);
 626
 627     if ((pDevice->bHWRadioOff == true) || (pDevice->bRadioControlOff == true)) {
 628         CARDbRadioPowerOff(pDevice);
 629     } else {
 630         CARDbRadioPowerOn(pDevice);
 631     }
 632
 633     spin_unlock_irq(&pDevice->lock);
 634     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");
 635     return true;
 636 }
 637
 638 #ifdef CONFIG_PM        /* Minimal support for suspend and resume */
 639
 640 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message)
 641 {
 642         struct vnt_private *device = usb_get_intfdata(intf);
 643
 644         if (!device || !device->dev)
 645                 return -ENODEV;
 646
 647         if (device->flags & DEVICE_FLAGS_OPENED)
 648                 device_close(device->dev);
 649
 650         return 0;
 651 }
 652
 653 static int vt6656_resume(struct usb_interface *intf)
 654 {
 655         struct vnt_private *device = usb_get_intfdata(intf);
 656
 657         if (!device || !device->dev)
 658                 return -ENODEV;
 659
 660         if (!(device->flags & DEVICE_FLAGS_OPENED))
 661                 device_open(device->dev);
 662
 663         return 0;
 664 }
 665
 666 #endif /* CONFIG_PM */
 667
 668 static const struct net_device_ops device_netdev_ops = {
 669     .ndo_open               = device_open,
 670     .ndo_stop               = device_close,
 671     .ndo_do_ioctl           = device_ioctl,
 672     .ndo_get_stats          = device_get_stats,
 673     .ndo_start_xmit         = device_xmit,
 674     .ndo_set_rx_mode        = device_set_multi,
 675 };
 676
 677 static int
 678 vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
 679 {
 680         u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
 681         struct usb_device *udev = interface_to_usbdev(intf);
 682         int rc = 0;
 683         struct net_device *netdev = NULL;
 684         struct vnt_private *pDevice;
 685
 686         printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
 687         printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
 688
 689         udev = usb_get_dev(udev);
 690         netdev = alloc_etherdev(sizeof(struct vnt_private));
 691         if (!netdev) {
 692                 printk(KERN_ERR DEVICE_NAME ": allocate net device failed\n");
 693                 rc = -ENOMEM;
 694                 goto err_nomem;
 695         }
 696
 697         pDevice = netdev_priv(netdev);
 698         memset(pDevice, 0, sizeof(struct vnt_private));
 699
 700         pDevice->dev = netdev;
 701         pDevice->usb = udev;
 702
 703         device_set_options(pDevice);
 704         spin_lock_init(&pDevice->lock);
 705         INIT_DELAYED_WORK(&pDevice->run_command_work, vRunCommand);
 706         INIT_DELAYED_WORK(&pDevice->second_callback_work, BSSvSecondCallBack);
 707         INIT_WORK(&pDevice->read_work_item, RXvWorkItem);
 708         INIT_WORK(&pDevice->rx_mng_work_item, RXvMngWorkItem);
 709
 710         pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
 711         if (!pDevice->pControlURB) {
 712                 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR"Failed to alloc control urb\n");
 713                 goto err_netdev;
 714         }
 715
 716         pDevice->tx_80211 = device_dma0_tx_80211;
 717         pDevice->vnt_mgmt.pAdapter = (void *) pDevice;
 718
 719         netdev->netdev_ops = &device_netdev_ops;
 720         netdev->wireless_handlers =
 721                 (struct iw_handler_def *) &iwctl_handler_def;
 722
 723         usb_set_intfdata(intf, pDevice);
 724         SET_NETDEV_DEV(netdev, &intf->dev);
 725         memcpy(pDevice->dev->dev_addr, fake_mac, ETH_ALEN);
 726         rc = register_netdev(netdev);
 727         if (rc) {
 728                 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
 729                 goto err_netdev;
 730         }
 731
 732         usb_device_reset(pDevice);
 733
 734         return 0;
 735
 736 err_netdev:
 737         free_netdev(netdev);
 738 err_nomem:
 739         usb_put_dev(udev);
 740
 741         return rc;
 742 }
 743
 744 static void device_free_tx_bufs(struct vnt_private *pDevice)
 745 {
 746         struct vnt_usb_send_context *pTxContext;
 747     int ii;
 748
 749     for (ii = 0; ii < pDevice->cbTD; ii++) {
 750
 751         pTxContext = pDevice->apTD[ii];
 752         /* deallocate URBs */
 753         if (pTxContext->pUrb) {
 754             usb_kill_urb(pTxContext->pUrb);
 755             usb_free_urb(pTxContext->pUrb);
 756         }
 757         kfree(pTxContext);
 758     }
 759     return;
 760 }
 761
 762 static void device_free_rx_bufs(struct vnt_private *pDevice)
 763 {
 764         struct vnt_rcb *pRCB;
 765         int ii;
 766
 767     for (ii = 0; ii < pDevice->cbRD; ii++) {
 768
 769         pRCB = pDevice->apRCB[ii];
 770         /* deallocate URBs */
 771         if (pRCB->pUrb) {
 772             usb_kill_urb(pRCB->pUrb);
 773             usb_free_urb(pRCB->pUrb);
 774         }
 775         /* deallocate skb */
 776         if (pRCB->skb)
 777             dev_kfree_skb(pRCB->skb);
 778     }
 779     kfree(pDevice->pRCBMem);
 780
 781     return;
 782 }
 783
 784 static void usb_device_reset(struct vnt_private *pDevice)
 785 {
 786  int status;
 787  status = usb_reset_device(pDevice->usb);
 788         if (status)
 789             printk("usb_device_reset fail status=%d\n",status);
 790         return ;
 791 }
 792
 793 static void device_free_int_bufs(struct vnt_private *pDevice)
 794 {
 795     kfree(pDevice->intBuf.pDataBuf);
 796     return;
 797 }
 798
 799 static bool device_alloc_bufs(struct vnt_private *pDevice)
 800 {
 801         struct vnt_usb_send_context *pTxContext;
 802         struct vnt_rcb *pRCB;
 803         int ii;
 804
 805     for (ii = 0; ii < pDevice->cbTD; ii++) {
 806
 807         pTxContext = kmalloc(sizeof(struct vnt_usb_send_context), GFP_KERNEL);
 808         if (pTxContext == NULL) {
 809             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
 810             goto free_tx;
 811         }
 812         pDevice->apTD[ii] = pTxContext;
 813         pTxContext->pDevice = (void *) pDevice;
 814         /* allocate URBs */
 815         pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
 816         if (pTxContext->pUrb == NULL) {
 817             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
 818             goto free_tx;
 819         }
 820         pTxContext->bBoolInUse = false;
 821     }
 822
 823     /* allocate RCB mem */
 824         pDevice->pRCBMem = kzalloc((sizeof(struct vnt_rcb) * pDevice->cbRD),
 825                                                                 GFP_KERNEL);
 826     if (pDevice->pRCBMem == NULL) {
 827         DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
 828         goto free_tx;
 829     }
 830
 831     pDevice->FirstRecvFreeList = NULL;
 832     pDevice->LastRecvFreeList = NULL;
 833     pDevice->FirstRecvMngList = NULL;
 834     pDevice->LastRecvMngList = NULL;
 835     pDevice->NumRecvFreeList = 0;
 836
 837         pRCB = (struct vnt_rcb *)pDevice->pRCBMem;
 838
 839     for (ii = 0; ii < pDevice->cbRD; ii++) {
 840
 841         pDevice->apRCB[ii] = pRCB;
 842         pRCB->pDevice = (void *) pDevice;
 843         /* allocate URBs */
 844         pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
 845
 846         if (pRCB->pUrb == NULL) {
 847             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
 848             goto free_rx_tx;
 849         }
 850         pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
 851         if (pRCB->skb == NULL) {
 852             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
 853             goto free_rx_tx;
 854         }
 855         pRCB->skb->dev = pDevice->dev;
 856         pRCB->bBoolInUse = false;
 857         EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
 858         pDevice->NumRecvFreeList++;
 859         pRCB++;
 860     }
 861
 862         pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
 863         if (pDevice->pInterruptURB == NULL) {
 864             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
 865             goto free_rx_tx;
 866         }
 867
 868     pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
 869         if (pDevice->intBuf.pDataBuf == NULL) {
 870             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
 871             usb_free_urb(pDevice->pInterruptURB);
 872             goto free_rx_tx;
 873         }
 874
 875     return true;
 876
 877 free_rx_tx:
 878     device_free_rx_bufs(pDevice);
 879
 880 free_tx:
 881     device_free_tx_bufs(pDevice);
 882
 883         return false;
 884 }
 885
 886 static bool device_init_defrag_cb(struct vnt_private *pDevice)
 887 {
 888         int i;
 889         PSDeFragControlBlock pDeF;
 890
 891     /* Init the fragment ctl entries */
 892     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
 893         pDeF = &(pDevice->sRxDFCB[i]);
 894         if (!device_alloc_frag_buf(pDevice, pDeF)) {
 895             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
 896                 pDevice->dev->name);
 897             goto free_frag;
 898         }
 899     }
 900     pDevice->cbDFCB = CB_MAX_RX_FRAG;
 901     pDevice->cbFreeDFCB = pDevice->cbDFCB;
 902     return true;
 903
 904 free_frag:
 905     device_free_frag_bufs(pDevice);
 906     return false;
 907 }
 908
 909 static void device_free_frag_bufs(struct vnt_private *pDevice)
 910 {
 911         PSDeFragControlBlock pDeF;
 912         int i;
 913
 914     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
 915
 916         pDeF = &(pDevice->sRxDFCB[i]);
 917
 918         if (pDeF->skb)
 919             dev_kfree_skb(pDeF->skb);
 920     }
 921 }
 922
 923 int device_alloc_frag_buf(struct vnt_private *pDevice,
 924                 PSDeFragControlBlock pDeF)
 925 {
 926
 927     pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
 928     if (pDeF->skb == NULL)
 929         return false;
 930     pDeF->skb->dev = pDevice->dev;
 931
 932     return true;
 933 }
 934
 935 static int  device_open(struct net_device *dev)
 936 {
 937         struct vnt_private *pDevice = netdev_priv(dev);
 938
 939      pDevice->fWPA_Authened = false;
 940
 941     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
 942
 943     pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
 944
 945     if (device_alloc_bufs(pDevice) == false) {
 946         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
 947         return -ENOMEM;
 948     }
 949
 950     if (device_init_defrag_cb(pDevice)== false) {
 951         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragment cb fail \n");
 952         goto free_rx_tx;
 953     }
 954
 955     MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
 956     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
 957     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
 958     MP_SET_FLAG(pDevice, fMP_POST_READS);
 959     MP_SET_FLAG(pDevice, fMP_POST_WRITES);
 960
 961     /* read config file */
 962     Read_config_file(pDevice);
 963
 964     if (device_init_registers(pDevice, DEVICE_INIT_COLD) == false) {
 965         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
 966         goto free_all;
 967     }
 968
 969     device_set_multi(pDevice->dev);
 970
 971     /* init for key management */
 972     KeyvInitTable(pDevice,&pDevice->sKey);
 973         memcpy(pDevice->vnt_mgmt.abyMACAddr,
 974                 pDevice->abyCurrentNetAddr, ETH_ALEN);
 975     memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
 976     pDevice->bStopTx0Pkt = false;
 977     pDevice->bStopDataPkt = false;
 978     pDevice->bRoaming = false;
 979     pDevice->bIsRoaming = false;
 980     pDevice->bEnableRoaming = false;
 981     if (pDevice->bDiversityRegCtlON) {
 982         device_init_diversity_timer(pDevice);
 983     }
 984
 985     vMgrObjectInit(pDevice);
 986
 987     tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
 988
 989         schedule_delayed_work(&pDevice->second_callback_work, HZ);
 990
 991         pDevice->int_interval = 100;  /* max 100 microframes */
 992     pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
 993
 994     pDevice->bIsRxWorkItemQueued = true;
 995     pDevice->fKillEventPollingThread = false;
 996     pDevice->bEventAvailable = false;
 997
 998    pDevice->bWPADEVUp = false;
 999      pDevice->bwextstep0 = false;
1000      pDevice->bwextstep1 = false;
1001      pDevice->bwextstep2 = false;
1002      pDevice->bwextstep3 = false;
1003      pDevice->bWPASuppWextEnabled = false;
1004     pDevice->byReAssocCount = 0;
1005
1006         schedule_work(&pDevice->read_work_item);
1007     INTvWorkItem(pDevice);
1008
1009     /* if WEP key already set by iwconfig but device not yet open */
1010     if ((pDevice->bEncryptionEnable == true) && (pDevice->bTransmitKey == true)) {
1011          spin_lock_irq(&pDevice->lock);
1012          KeybSetDefaultKey( pDevice,
1013                             &(pDevice->sKey),
1014                             pDevice->byKeyIndex | (1 << 31),
1015                             pDevice->uKeyLength,
1016                             NULL,
1017                             pDevice->abyKey,
1018                             KEY_CTL_WEP
1019                           );
1020          spin_unlock_irq(&pDevice->lock);
1021          pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1022     }
1023
1024         if (pDevice->vnt_mgmt.eConfigMode == WMAC_CONFIG_AP)
1025                 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1026         else
1027                 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1028
1029     netif_stop_queue(pDevice->dev);
1030     pDevice->flags |= DEVICE_FLAGS_OPENED;
1031
1032         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success..\n");
1033         return 0;
1034
1035 free_all:
1036     device_free_frag_bufs(pDevice);
1037 free_rx_tx:
1038     device_free_rx_bufs(pDevice);
1039     device_free_tx_bufs(pDevice);
1040     device_free_int_bufs(pDevice);
1041         usb_kill_urb(pDevice->pInterruptURB);
1042     usb_free_urb(pDevice->pInterruptURB);
1043
1044     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1045     return -ENOMEM;
1046 }
1047
1048 static int device_close(struct net_device *dev)
1049 {
1050         struct vnt_private *pDevice = netdev_priv(dev);
1051         struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
1052         int uu;
1053
1054         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1\n");
1055     if (pDevice == NULL)
1056         return -ENODEV;
1057
1058     if (pDevice->bLinkPass) {
1059         bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1060         mdelay(30);
1061     }
1062
1063         memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1064         pMgmt->bShareKeyAlgorithm = false;
1065         pDevice->bEncryptionEnable = false;
1066         pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1067         spin_lock_irq(&pDevice->lock);
1068         for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1069                 MACvDisableKeyEntry(pDevice,uu);
1070         spin_unlock_irq(&pDevice->lock);
1071
1072     if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == false) {
1073         MACbShutdown(pDevice);
1074     }
1075     netif_stop_queue(pDevice->dev);
1076     MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1077     MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1078     MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1079     pDevice->fKillEventPollingThread = true;
1080
1081         cancel_delayed_work_sync(&pDevice->run_command_work);
1082         cancel_delayed_work_sync(&pDevice->second_callback_work);
1083
1084     del_timer(&pDevice->sTimerTxData);
1085
1086     if (pDevice->bDiversityRegCtlON) {
1087         del_timer(&pDevice->TimerSQ3Tmax1);
1088         del_timer(&pDevice->TimerSQ3Tmax2);
1089         del_timer(&pDevice->TimerSQ3Tmax3);
1090     }
1091
1092         cancel_work_sync(&pDevice->rx_mng_work_item);
1093         cancel_work_sync(&pDevice->read_work_item);
1094
1095     tasklet_kill(&pDevice->EventWorkItem);
1096
1097    pDevice->bRoaming = false;
1098    pDevice->bIsRoaming = false;
1099    pDevice->bEnableRoaming = false;
1100     pDevice->bCmdRunning = false;
1101     pDevice->bLinkPass = false;
1102     memset(pMgmt->abyCurrBSSID, 0, 6);
1103     pMgmt->eCurrState = WMAC_STATE_IDLE;
1104
1105         pDevice->flags &= ~DEVICE_FLAGS_OPENED;
1106
1107     device_free_tx_bufs(pDevice);
1108     device_free_rx_bufs(pDevice);
1109     device_free_int_bufs(pDevice);
1110     device_free_frag_bufs(pDevice);
1111
1112         usb_kill_urb(pDevice->pInterruptURB);
1113     usb_free_urb(pDevice->pInterruptURB);
1114
1115     BSSvClearNodeDBTable(pDevice, 0);
1116
1117     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1118
1119     return 0;
1120 }
1121
1122 static void vt6656_disconnect(struct usb_interface *intf)
1123 {
1124         struct vnt_private *device = usb_get_intfdata(intf);
1125
1126         if (!device)
1127                 return;
1128
1129         usb_set_intfdata(intf, NULL);
1130         usb_put_dev(interface_to_usbdev(intf));
1131
1132         device->flags |= DEVICE_FLAGS_UNPLUG;
1133
1134         if (device->dev) {
1135                 unregister_netdev(device->dev);
1136
1137                 usb_kill_urb(device->pControlURB);
1138                 usb_free_urb(device->pControlURB);
1139
1140                 free_netdev(device->dev);
1141         }
1142 }
1143
1144 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1145 {
1146         struct vnt_private *pDevice = netdev_priv(dev);
1147
1148         spin_lock_irq(&pDevice->lock);
1149
1150         if (unlikely(pDevice->bStopTx0Pkt))
1151                 dev_kfree_skb_irq(skb);
1152         else
1153                 vDMA0_tx_80211(pDevice, skb);
1154
1155         spin_unlock_irq(&pDevice->lock);
1156
1157         return NETDEV_TX_OK;
1158 }
1159
1160 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1161 {
1162         struct vnt_private *pDevice = netdev_priv(dev);
1163         struct net_device_stats *stats = &pDevice->stats;
1164
1165         spin_lock_irq(&pDevice->lock);
1166
1167         netif_stop_queue(dev);
1168
1169         if (!pDevice->bLinkPass) {
1170                 dev_kfree_skb_irq(skb);
1171                 goto out;
1172         }
1173
1174         if (pDevice->bStopDataPkt) {
1175                 dev_kfree_skb_irq(skb);
1176                 stats->tx_dropped++;
1177                 goto out;
1178         }
1179
1180         if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1181                 if (netif_queue_stopped(dev))
1182                         netif_wake_queue(dev);
1183         }
1184
1185 out:
1186         spin_unlock_irq(&pDevice->lock);
1187
1188         return NETDEV_TX_OK;
1189 }
1190
1191 static unsigned const ethernet_polynomial = 0x04c11db7U;
1192 static inline u32 ether_crc(int length, unsigned char *data)
1193 {
1194     int crc = -1;
1195
1196     while(--length >= 0) {
1197         unsigned char current_octet = *data++;
1198         int bit;
1199         for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1200             crc = (crc << 1) ^
1201                 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1202         }
1203     }
1204     return crc;
1205 }
1206
1207 /* find out the start position of str2 from str1 */
1208 static unsigned char *kstrstr(const unsigned char *str1,
1209                               const unsigned char *str2) {
1210   int str1_len = strlen(str1);
1211   int str2_len = strlen(str2);
1212
1213   while (str1_len >= str2_len) {
1214        str1_len--;
1215       if(memcmp(str1,str2,str2_len)==0)
1216         return (unsigned char *) str1;
1217         str1++;
1218   }
1219   return NULL;
1220 }
1221
1222 static int Config_FileGetParameter(unsigned char *string,
1223                                    unsigned char *dest,
1224                                    unsigned char *source)
1225 {
1226   unsigned char buf1[100];
1227   unsigned char buf2[100];
1228   unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1229   int ii;
1230
1231     memset(buf1,0,100);
1232     strcat(buf1, string);
1233     strcat(buf1, "=");
1234     source+=strlen(buf1);
1235
1236     /* find target string start point */
1237     start_p = kstrstr(source,buf1);
1238     if (start_p == NULL)
1239         return false;
1240
1241     /* check if current config line is marked by "#" */
1242     for (ii = 1; ; ii++) {
1243         if (memcmp(start_p - ii, "\n", 1) == 0)
1244                 break;
1245         if (memcmp(start_p - ii, "#", 1) == 0)
1246                 return false;
1247     }
1248
1249     /* find target string end point */
1250      end_p = kstrstr(start_p,"\n");
1251      if (end_p == NULL) {       /* can't find "\n", but don't care */
1252              end_p = start_p + strlen(start_p);   /* no include "\n" */
1253      }
1254
1255    memset(buf2,0,100);
1256    memcpy(buf2, start_p, end_p-start_p); /* get the target line */
1257    buf2[end_p-start_p]='\0';
1258
1259    /* find value */
1260    start_p = kstrstr(buf2,"=");
1261    if (start_p == NULL)
1262       return false;
1263    memset(buf1,0,100);
1264    strcpy(buf1,start_p+1);
1265
1266    /* except space */
1267   tmp_p = buf1;
1268   while(*tmp_p != 0x00) {
1269         if(*tmp_p==' ')
1270             tmp_p++;
1271          else
1272           break;
1273   }
1274
1275    memcpy(dest,tmp_p,strlen(tmp_p));
1276  return true;
1277 }
1278
1279 /* if read fails, return NULL, or return data pointer */
1280 static unsigned char *Config_FileOperation(struct vnt_private *pDevice)
1281 {
1282         unsigned char *buffer = kmalloc(1024, GFP_KERNEL);
1283         struct file   *file;
1284
1285         if (!buffer) {
1286                 printk("allocate mem for file fail?\n");
1287                 return NULL;
1288         }
1289
1290         file = filp_open(CONFIG_PATH, O_RDONLY, 0);
1291         if (IS_ERR(file)) {
1292                 kfree(buffer);
1293                 printk("Config_FileOperation file Not exist\n");
1294                 return NULL;
1295         }
1296
1297         if (kernel_read(file, 0, buffer, 1024) < 0) {
1298                 printk("read file error?\n");
1299                 kfree(buffer);
1300                 buffer = NULL;
1301         }
1302
1303         fput(file);
1304         return buffer;
1305 }
1306
1307 /* return --->-1:fail; >=0:successful */
1308 static int Read_config_file(struct vnt_private *pDevice)
1309 {
1310         int result = 0;
1311         unsigned char tmpbuffer[100];
1312         unsigned char *buffer = NULL;
1313
1314         /* init config setting */
1315  pDevice->config_file.ZoneType = -1;
1316  pDevice->config_file.eAuthenMode = -1;
1317  pDevice->config_file.eEncryptionStatus = -1;
1318
1319   buffer = Config_FileOperation(pDevice);
1320   if (buffer == NULL) {
1321      result =-1;
1322      return result;
1323   }
1324
1325 /* get zonetype */
1326 {
1327     memset(tmpbuffer,0,sizeof(tmpbuffer));
1328     if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==true) {
1329     if(memcmp(tmpbuffer,"USA",3)==0) {
1330       pDevice->config_file.ZoneType=ZoneType_USA;
1331     }
1332     else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1333       pDevice->config_file.ZoneType=ZoneType_Japan;
1334     }
1335     else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1336      pDevice->config_file.ZoneType=ZoneType_Europe;
1337     }
1338     else {
1339       printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1340    }
1341  }
1342 }
1343
1344 /* get other parameter */
1345   {
1346         memset(tmpbuffer,0,sizeof(tmpbuffer));
1347        if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==true) {
1348          pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1349        }
1350
1351         memset(tmpbuffer,0,sizeof(tmpbuffer));
1352        if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==true) {
1353          pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1354        }
1355   }
1356
1357   kfree(buffer);
1358   return result;
1359 }
1360
1361 static void device_set_multi(struct net_device *dev)
1362 {
1363         struct vnt_private *pDevice = netdev_priv(dev);
1364         struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
1365         struct netdev_hw_addr *ha;
1366         u32 mc_filter[2];
1367         int ii;
1368         u8 pbyData[8] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1369         u8 byTmpMode = 0;
1370         int rc;
1371
1372         spin_lock_irq(&pDevice->lock);
1373     rc = CONTROLnsRequestIn(pDevice,
1374                             MESSAGE_TYPE_READ,
1375                             MAC_REG_RCR,
1376                             MESSAGE_REQUEST_MACREG,
1377                             1,
1378                             &byTmpMode
1379                             );
1380     if (rc == 0) pDevice->byRxMode = byTmpMode;
1381
1382     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1383
1384     if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
1385         DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1386         /* unconditionally log net taps */
1387         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1388     }
1389     else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1390              (dev->flags & IFF_ALLMULTI)) {
1391         CONTROLnsRequestOut(pDevice,
1392                             MESSAGE_TYPE_WRITE,
1393                             MAC_REG_MAR0,
1394                             MESSAGE_REQUEST_MACREG,
1395                             8,
1396                             pbyData
1397                             );
1398         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1399     }
1400     else {
1401         memset(mc_filter, 0, sizeof(mc_filter));
1402         netdev_for_each_mc_addr(ha, dev) {
1403             int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1404             mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1405         }
1406         for (ii = 0; ii < 4; ii++) {
1407              MACvWriteMultiAddr(pDevice, ii, *((u8 *)&mc_filter[0] + ii));
1408              MACvWriteMultiAddr(pDevice, ii+ 4, *((u8 *)&mc_filter[1] + ii));
1409         }
1410         pDevice->byRxMode &= ~(RCR_UNICAST);
1411         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1412     }
1413
1414     if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1415         /*
1416          * If AP mode, don't enable RCR_UNICAST since HW only compares
1417          * addr1 with local MAC
1418          */
1419         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1420         pDevice->byRxMode &= ~(RCR_UNICAST);
1421     }
1422     ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1423     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1424         spin_unlock_irq(&pDevice->lock);
1425
1426 }
1427
1428 static struct net_device_stats *device_get_stats(struct net_device *dev)
1429 {
1430         struct vnt_private *pDevice = netdev_priv(dev);
1431
1432         return &pDevice->stats;
1433 }
1434
1435 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1436 {
1437         struct vnt_private *pDevice = netdev_priv(dev);
1438         struct iwreq *wrq = (struct iwreq *) rq;
1439         int rc = 0;
1440
1441         switch (cmd) {
1442
1443         case IOCTL_CMD_HOSTAPD:
1444
1445                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED))
1446                         rc = -EFAULT;
1447
1448                 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
1449                 break;
1450
1451         case SIOCETHTOOL:
1452                 return ethtool_ioctl(dev, (void *) rq->ifr_data);
1453
1454         }
1455
1456         return rc;
1457 }
1458
1459 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
1460 {
1461         u32 ethcmd;
1462
1463         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
1464                 return -EFAULT;
1465
1466         switch (ethcmd) {
1467         case ETHTOOL_GDRVINFO: {
1468                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
1469                 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
1470                 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
1471                 if (copy_to_user(useraddr, &info, sizeof(info)))
1472                         return -EFAULT;
1473                 return 0;
1474         }
1475
1476         }
1477
1478         return -EOPNOTSUPP;
1479 }
1480
1481 MODULE_DEVICE_TABLE(usb, vt6656_table);
1482
1483 static struct usb_driver vt6656_driver = {
1484         .name =         DEVICE_NAME,
1485         .probe =        vt6656_probe,
1486         .disconnect =   vt6656_disconnect,
1487         .id_table =     vt6656_table,
1488 #ifdef CONFIG_PM
1489         .suspend = vt6656_suspend,
1490         .resume = vt6656_resume,
1491 #endif /* CONFIG_PM */
1492 };
1493
1494 module_usb_driver(vt6656_driver);