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