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