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 - asynchrous data tx function
  33  *   device_set_multi - set mac filter
  34  *   device_ioctl - ioctl entry
  35  *   device_close - shutdown mac/bbp & free dma/descripter 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 bufferred frame via dma0
  40  *   device_init_registers- initial MAC & BBP & RF internal registers.
  41  *   device_init_rings- initial tx/rx ring buffer
  42  *   device_init_defrag_cb- initial & allocate de-fragement buffer.
  43  *   device_tx_srv- tx interrupt service function
  44  *
  45  * Revision History:
  46  */
  47 #undef __NO_VERSION__
  48
  49 #include "device.h"
  50 #include "card.h"
  51 #include "baseband.h"
  52 #include "mac.h"
  53 #include "tether.h"
  54 #include "wmgr.h"
  55 #include "wctl.h"
  56 #include "power.h"
  57 #include "wcmd.h"
  58 #include "iocmd.h"
  59 #include "tcrc.h"
  60 #include "rxtx.h"
  61 #include "bssdb.h"
  62 #include "hostap.h"
  63 #include "wpactl.h"
  64 #include "ioctl.h"
  65 #include "iwctl.h"
  66 #include "dpc.h"
  67 #include "datarate.h"
  68 #include "rf.h"
  69 #include "firmware.h"
  70 #include "rndis.h"
  71 #include "control.h"
  72 #include "channel.h"
  73 #include "int.h"
  74 #include "iowpa.h"
  75
  76 /*---------------------  Static Definitions -------------------------*/
  77 //static int          msglevel                =MSG_LEVEL_DEBUG;
  78 static int          msglevel                =MSG_LEVEL_INFO;
  79
  80 //
  81 // Define module options
  82 //
  83
  84 // Version Information
  85 #define DRIVER_AUTHOR "VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>"
  86 MODULE_AUTHOR(DRIVER_AUTHOR);
  87 MODULE_LICENSE("GPL");
  88 MODULE_DESCRIPTION(DEVICE_FULL_DRV_NAM);
  89
  90 #define DEVICE_PARAM(N,D) \
  91         static int N[MAX_UINTS]=OPTION_DEFAULT;\
  92         module_param_array(N, int, NULL, 0);\
  93         MODULE_PARM_DESC(N, D);
  94
  95 #define RX_DESC_MIN0     16
  96 #define RX_DESC_MAX0     128
  97 #define RX_DESC_DEF0     64
  98 DEVICE_PARAM(RxDescriptors0,"Number of receive usb desc buffer");
  99
 100
 101 #define TX_DESC_MIN0     16
 102 #define TX_DESC_MAX0     128
 103 #define TX_DESC_DEF0     64
 104 DEVICE_PARAM(TxDescriptors0,"Number of transmit usb desc buffer");
 105
 106
 107 #define CHANNEL_MIN     1
 108 #define CHANNEL_MAX     14
 109 #define CHANNEL_DEF     6
 110
 111 DEVICE_PARAM(Channel, "Channel number");
 112
 113
 114 /* PreambleType[] is the preamble length used for transmit.
 115    0: indicate allows long preamble type
 116    1: indicate allows short preamble type
 117 */
 118
 119 #define PREAMBLE_TYPE_DEF     1
 120
 121 DEVICE_PARAM(PreambleType, "Preamble Type");
 122
 123
 124 #define RTS_THRESH_MIN     512
 125 #define RTS_THRESH_MAX     2347
 126 #define RTS_THRESH_DEF     2347
 127
 128 DEVICE_PARAM(RTSThreshold, "RTS threshold");
 129
 130
 131 #define FRAG_THRESH_MIN     256
 132 #define FRAG_THRESH_MAX     2346
 133 #define FRAG_THRESH_DEF     2346
 134
 135 DEVICE_PARAM(FragThreshold, "Fragmentation threshold");
 136
 137
 138 #define DATA_RATE_MIN     0
 139 #define DATA_RATE_MAX     13
 140 #define DATA_RATE_DEF     13
 141 /* datarate[] index
 142    0: indicate 1 Mbps   0x02
 143    1: indicate 2 Mbps   0x04
 144    2: indicate 5.5 Mbps 0x0B
 145    3: indicate 11 Mbps  0x16
 146    4: indicate 6 Mbps   0x0c
 147    5: indicate 9 Mbps   0x12
 148    6: indicate 12 Mbps  0x18
 149    7: indicate 18 Mbps  0x24
 150    8: indicate 24 Mbps  0x30
 151    9: indicate 36 Mbps  0x48
 152   10: indicate 48 Mbps  0x60
 153   11: indicate 54 Mbps  0x6c
 154   12: indicate 72 Mbps  0x90
 155   13: indicate auto rate
 156 */
 157
 158 DEVICE_PARAM(ConnectionRate, "Connection data rate");
 159
 160 #define OP_MODE_MAX     2
 161 #define OP_MODE_DEF     0
 162 #define OP_MODE_MIN     0
 163
 164 DEVICE_PARAM(OPMode, "Infrastruct, adhoc, AP mode ");
 165
 166 /* OpMode[] is used for transmit.
 167    0: indicate infrastruct mode used
 168    1: indicate adhoc mode used
 169    2: indicate AP mode used
 170 */
 171
 172
 173 /* PSMode[]
 174    0: indicate disable power saving mode
 175    1: indicate enable power saving mode
 176 */
 177
 178 #define PS_MODE_DEF     0
 179
 180 DEVICE_PARAM(PSMode, "Power saving mode");
 181
 182
 183 #define SHORT_RETRY_MIN     0
 184 #define SHORT_RETRY_MAX     31
 185 #define SHORT_RETRY_DEF     8
 186
 187
 188 DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits");
 189
 190 #define LONG_RETRY_MIN     0
 191 #define LONG_RETRY_MAX     15
 192 #define LONG_RETRY_DEF     4
 193
 194
 195 DEVICE_PARAM(LongRetryLimit, "long frame retry limits");
 196
 197
 198 /* BasebandType[] baseband type selected
 199    0: indicate 802.11a type
 200    1: indicate 802.11b type
 201    2: indicate 802.11g type
 202 */
 203 #define BBP_TYPE_MIN     0
 204 #define BBP_TYPE_MAX     2
 205 #define BBP_TYPE_DEF     2
 206
 207 DEVICE_PARAM(BasebandType, "baseband type");
 208
 209
 210
 211 /* 80211hEnable[]
 212    0: indicate disable 802.11h
 213    1: indicate enable 802.11h
 214 */
 215
 216 #define X80211h_MODE_DEF     0
 217
 218 DEVICE_PARAM(b80211hEnable, "802.11h mode");
 219
 220
 221 //
 222 // Static vars definitions
 223 //
 224
 225 static struct usb_device_id vt6656_table[] __devinitdata = {
 226         {USB_DEVICE(VNT_USB_VENDOR_ID, VNT_USB_PRODUCT_ID)},
 227         {}
 228 };
 229
 230 // Frequency list (map channels to frequencies)
 231 /*
 232 static const long frequency_list[] = {
 233     2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484,
 234     4915, 4920, 4925, 4935, 4940, 4945, 4960, 4980,
 235     5035, 5040, 5045, 5055, 5060, 5080, 5170, 5180, 5190, 5200, 5210, 5220, 5230, 5240,
 236     5260, 5280, 5300, 5320, 5500, 5520, 5540, 5560, 5580, 5600, 5620, 5640, 5660, 5680,
 237     5700, 5745, 5765, 5785, 5805, 5825
 238         };
 239
 240
 241 #ifndef IW_ENCODE_NOKEY
 242 #define IW_ENCODE_NOKEY         0x0800
 243 #define IW_ENCODE_MODE  (IW_ENCODE_DISABLED | IW_ENCODE_RESTRICTED | IW_ENCODE_OPEN)
 244 #endif
 245
 246 static const struct iw_handler_def      iwctl_handler_def;
 247 */
 248
 249 /*---------------------  Static Functions  --------------------------*/
 250
 251 static int vt6656_probe(struct usb_interface *intf,
 252                         const struct usb_device_id *id);
 253 static void vt6656_disconnect(struct usb_interface *intf);
 254
 255 #ifdef CONFIG_PM        /* Minimal support for suspend and resume */
 256 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message);
 257 static int vt6656_resume(struct usb_interface *intf);
 258 #endif /* CONFIG_PM */
 259
 260 static struct net_device_stats *device_get_stats(struct net_device *dev);
 261 static int  device_open(struct net_device *dev);
 262 static int  device_xmit(struct sk_buff *skb, struct net_device *dev);
 263 static void device_set_multi(struct net_device *dev);
 264 static int  device_close(struct net_device *dev);
 265 static int  device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 266
 267 static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType);
 268 static BOOL device_init_defrag_cb(PSDevice pDevice);
 269 static void device_init_diversity_timer(PSDevice pDevice);
 270 static int  device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
 271
 272 static int  ethtool_ioctl(struct net_device *dev, void *useraddr);
 273 static void device_free_tx_bufs(PSDevice pDevice);
 274 static void device_free_rx_bufs(PSDevice pDevice);
 275 static void device_free_int_bufs(PSDevice pDevice);
 276 static void device_free_frag_bufs(PSDevice pDevice);
 277 static BOOL device_alloc_bufs(PSDevice pDevice);
 278
 279 static int Read_config_file(PSDevice pDevice);
 280 static unsigned char *Config_FileOperation(PSDevice pDevice);
 281 static int Config_FileGetParameter(unsigned char *string,
 282                                    unsigned char *dest,
 283                                    unsigned char *source);
 284
 285 static BOOL device_release_WPADEV(PSDevice pDevice);
 286
 287 static void usb_device_reset(PSDevice pDevice);
 288
 289
 290
 291 /*---------------------  Export Variables  --------------------------*/
 292
 293 /*---------------------  Export Functions  --------------------------*/
 294
 295
 296 static void
 297 device_set_options(PSDevice pDevice) {
 298
 299     BYTE    abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 300     BYTE    abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
 301     u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
 302
 303     memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
 304     memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
 305     memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, ETH_ALEN);
 306
 307     pDevice->cbTD = TX_DESC_DEF0;
 308     pDevice->cbRD = RX_DESC_DEF0;
 309     pDevice->uChannel = CHANNEL_DEF;
 310     pDevice->wRTSThreshold = RTS_THRESH_DEF;
 311     pDevice->wFragmentationThreshold = FRAG_THRESH_DEF;
 312     pDevice->byShortRetryLimit = SHORT_RETRY_DEF;
 313     pDevice->byLongRetryLimit = LONG_RETRY_DEF;
 314     pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
 315     pDevice->byShortPreamble = PREAMBLE_TYPE_DEF;
 316     pDevice->ePSMode = PS_MODE_DEF;
 317     pDevice->b11hEnable = X80211h_MODE_DEF;
 318     pDevice->eOPMode = OP_MODE_DEF;
 319     pDevice->uConnectionRate = DATA_RATE_DEF;
 320     if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = TRUE;
 321     pDevice->byBBType = BBP_TYPE_DEF;
 322     pDevice->byPacketType = pDevice->byBBType;
 323     pDevice->byAutoFBCtrl = AUTO_FB_0;
 324     pDevice->bUpdateBBVGA = TRUE;
 325     pDevice->byFOETuning = 0;
 326     pDevice->byAutoPwrTunning = 0;
 327     pDevice->wCTSDuration = 0;
 328     pDevice->byPreambleType = 0;
 329     pDevice->bExistSWNetAddr = FALSE;
 330 //    pDevice->bDiversityRegCtlON = TRUE;
 331     pDevice->bDiversityRegCtlON = FALSE;
 332 }
 333
 334
 335 static void device_init_diversity_timer(PSDevice pDevice)
 336 {
 337     init_timer(&pDevice->TimerSQ3Tmax1);
 338     pDevice->TimerSQ3Tmax1.data = (unsigned long)pDevice;
 339     pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
 340     pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
 341
 342     init_timer(&pDevice->TimerSQ3Tmax2);
 343     pDevice->TimerSQ3Tmax2.data = (unsigned long)pDevice;
 344     pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
 345     pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
 346
 347     init_timer(&pDevice->TimerSQ3Tmax3);
 348     pDevice->TimerSQ3Tmax3.data = (unsigned long)pDevice;
 349     pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerSQ3Tmax3CallBack;
 350     pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
 351
 352     return;
 353 }
 354
 355
 356 //
 357 // Initialiation of MAC & BBP registers
 358 //
 359
 360 static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType)
 361 {
 362     u8 abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 363     u8 abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
 364     u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
 365     BYTE            byAntenna;
 366     unsigned int            ii;
 367     CMD_CARD_INIT   sInitCmd;
 368     int ntStatus = STATUS_SUCCESS;
 369     RSP_CARD_INIT   sInitRsp;
 370     PSMgmtObject    pMgmt = &(pDevice->sMgmtObj);
 371     BYTE            byTmp;
 372     BYTE            byCalibTXIQ = 0;
 373     BYTE            byCalibTXDC = 0;
 374     BYTE            byCalibRXIQ = 0;
 375
 376     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---->INIbInitAdapter. [%d][%d]\n", InitType, pDevice->byPacketType);
 377         spin_lock_irq(&pDevice->lock);
 378         if (InitType == DEVICE_INIT_COLD) {
 379                 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
 380                 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
 381                 memcpy(pDevice->abySNAP_Bridgetunnel,
 382                        abySNAP_Bridgetunnel,
 383                        ETH_ALEN);
 384
 385         if ( !FIRMWAREbCheckVersion(pDevice) ) {
 386             if (FIRMWAREbDownload(pDevice) == TRUE) {
 387                 if (FIRMWAREbBrach2Sram(pDevice) == FALSE) {
 388                     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbBrach2Sram fail \n");
 389                         spin_unlock_irq(&pDevice->lock);
 390                     return FALSE;
 391                 }
 392             } else {
 393
 394                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbDownload fail \n");
 395                 spin_unlock_irq(&pDevice->lock);
 396                 return FALSE;
 397             }
 398         }
 399
 400         if ( !BBbVT3184Init(pDevice) ) {
 401             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" BBbVT3184Init fail \n");
 402             spin_unlock_irq(&pDevice->lock);
 403             return FALSE;
 404         }
 405     }
 406
 407     sInitCmd.byInitClass = (BYTE)InitType;
 408     sInitCmd.bExistSWNetAddr = (BYTE) pDevice->bExistSWNetAddr;
 409     for (ii = 0; ii < 6; ii++)
 410         sInitCmd.bySWNetAddr[ii] = pDevice->abyCurrentNetAddr[ii];
 411     sInitCmd.byShortRetryLimit = pDevice->byShortRetryLimit;
 412     sInitCmd.byLongRetryLimit = pDevice->byLongRetryLimit;
 413
 414     //issue Card_init command to device
 415     ntStatus = CONTROLnsRequestOut(pDevice,
 416                                     MESSAGE_TYPE_CARDINIT,
 417                                     0,
 418                                     0,
 419                                     sizeof(CMD_CARD_INIT),
 420                                     (PBYTE) &(sInitCmd));
 421
 422     if ( ntStatus != STATUS_SUCCESS ) {
 423         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Issue Card init fail \n");
 424         spin_unlock_irq(&pDevice->lock);
 425         return FALSE;
 426     }
 427     if (InitType == DEVICE_INIT_COLD) {
 428
 429         ntStatus = CONTROLnsRequestIn(pDevice,MESSAGE_TYPE_INIT_RSP,0,0,sizeof(RSP_CARD_INIT), (PBYTE) &(sInitRsp));
 430
 431         if (ntStatus != STATUS_SUCCESS) {
 432             DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Cardinit request in status fail!\n");
 433             spin_unlock_irq(&pDevice->lock);
 434             return FALSE;
 435         }
 436
 437         //Local ID for AES functions
 438         ntStatus = CONTROLnsRequestIn(pDevice,
 439                                     MESSAGE_TYPE_READ,
 440                                     MAC_REG_LOCALID,
 441                                     MESSAGE_REQUEST_MACREG,
 442                                     1,
 443                                     &pDevice->byLocalID);
 444
 445         if ( ntStatus != STATUS_SUCCESS ) {
 446             spin_unlock_irq(&pDevice->lock);
 447             return FALSE;
 448         }
 449
 450         // Do MACbSoftwareReset in MACvInitialize
 451         // force CCK
 452         pDevice->bCCK = TRUE;
 453         pDevice->bProtectMode = FALSE;          //Only used in 11g type, sync with ERP IE
 454         pDevice->bNonERPPresent = FALSE;
 455         pDevice->bBarkerPreambleMd = FALSE;
 456         if ( pDevice->bFixRate ) {
 457             pDevice->wCurrentRate = (WORD) pDevice->uConnectionRate;
 458         } else {
 459             if ( pDevice->byBBType == BB_TYPE_11B )
 460                 pDevice->wCurrentRate = RATE_11M;
 461             else
 462                 pDevice->wCurrentRate = RATE_54M;
 463         }
 464
 465         CHvInitChannelTable(pDevice);
 466
 467         pDevice->byTopOFDMBasicRate = RATE_24M;
 468         pDevice->byTopCCKBasicRate = RATE_1M;
 469         pDevice->byRevId = 0;                   //Target to IF pin while programming to RF chip.
 470         pDevice->byCurPwr = 0xFF;
 471
 472         pDevice->byCCKPwr = pDevice->abyEEPROM[EEP_OFS_PWR_CCK];
 473         pDevice->byOFDMPwrG = pDevice->abyEEPROM[EEP_OFS_PWR_OFDMG];
 474         // Load power Table
 475         for (ii=0;ii<14;ii++) {
 476             pDevice->abyCCKPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_CCK_PWR_TBL];
 477             if (pDevice->abyCCKPwrTbl[ii] == 0)
 478                 pDevice->abyCCKPwrTbl[ii] = pDevice->byCCKPwr;
 479             pDevice->abyOFDMPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDM_PWR_TBL];
 480             if (pDevice->abyOFDMPwrTbl[ii] == 0)
 481                 pDevice->abyOFDMPwrTbl[ii] = pDevice->byOFDMPwrG;
 482         }
 483
 484           //original zonetype is USA,but customize zonetype is europe,
 485           // then need recover 12,13 ,14 channel  with 11 channel
 486           if(((pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Japan) ||
 487                 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Europe))&&
 488              (pDevice->byOriginalZonetype == ZoneType_USA)) {
 489                 for (ii = 11; ii < 14; ii++) {
 490                         pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];
 491                         pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];
 492                 }
 493           }
 494
 495         //{{ RobertYu: 20041124
 496         pDevice->byOFDMPwrA = 0x34; // same as RFbMA2829SelectChannel
 497         // Load OFDM A Power Table
 498         for (ii=0;ii<CB_MAX_CHANNEL_5G;ii++) { //RobertYu:20041224, bug using CB_MAX_CHANNEL
 499             pDevice->abyOFDMAPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDMA_PWR_TBL];
 500             if (pDevice->abyOFDMAPwrTbl[ii] == 0)
 501                 pDevice->abyOFDMAPwrTbl[ii] = pDevice->byOFDMPwrA;
 502         }
 503         //}} RobertYu
 504
 505         byAntenna = pDevice->abyEEPROM[EEP_OFS_ANTENNA];
 506         if (byAntenna & EEP_ANTINV)
 507             pDevice->bTxRxAntInv = TRUE;
 508         else
 509             pDevice->bTxRxAntInv = FALSE;
 510
 511         byAntenna &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
 512
 513         if (byAntenna == 0) // if not set default is All
 514             byAntenna = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
 515
 516         if (byAntenna == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
 517             pDevice->byAntennaCount = 2;
 518             pDevice->byTxAntennaMode = ANT_B;
 519             pDevice->dwTxAntennaSel = 1;
 520             pDevice->dwRxAntennaSel = 1;
 521             if (pDevice->bTxRxAntInv == TRUE)
 522                 pDevice->byRxAntennaMode = ANT_A;
 523             else
 524                 pDevice->byRxAntennaMode = ANT_B;
 525
 526             if (pDevice->bDiversityRegCtlON)
 527                 pDevice->bDiversityEnable = TRUE;
 528             else
 529                 pDevice->bDiversityEnable = FALSE;
 530         } else  {
 531             pDevice->bDiversityEnable = FALSE;
 532             pDevice->byAntennaCount = 1;
 533             pDevice->dwTxAntennaSel = 0;
 534             pDevice->dwRxAntennaSel = 0;
 535             if (byAntenna & EEP_ANTENNA_AUX) {
 536                 pDevice->byTxAntennaMode = ANT_A;
 537                 if (pDevice->bTxRxAntInv == TRUE)
 538                     pDevice->byRxAntennaMode = ANT_B;
 539                 else
 540                     pDevice->byRxAntennaMode = ANT_A;
 541             } else {
 542                 pDevice->byTxAntennaMode = ANT_B;
 543                 if (pDevice->bTxRxAntInv == TRUE)
 544                     pDevice->byRxAntennaMode = ANT_A;
 545                 else
 546                     pDevice->byRxAntennaMode = ANT_B;
 547             }
 548         }
 549         pDevice->ulDiversityNValue = 100*255;
 550         pDevice->ulDiversityMValue = 100*16;
 551         pDevice->byTMax = 1;
 552         pDevice->byTMax2 = 4;
 553         pDevice->ulSQ3TH = 0;
 554         pDevice->byTMax3 = 64;
 555         // -----------------------------------------------------------------
 556
 557         //Get Auto Fall Back Type
 558         pDevice->byAutoFBCtrl = AUTO_FB_0;
 559
 560         // Set SCAN Time
 561         pDevice->uScanTime = WLAN_SCAN_MINITIME;
 562
 563         // default Auto Mode
 564         //pDevice->NetworkType = Ndis802_11Automode;
 565         pDevice->eConfigPHYMode = PHY_TYPE_AUTO;
 566         pDevice->byBBType = BB_TYPE_11G;
 567
 568         // initialize BBP registers
 569         pDevice->ulTxPower = 25;
 570
 571         // Get Channel range
 572         pDevice->byMinChannel = 1;
 573         pDevice->byMaxChannel = CB_MAX_CHANNEL;
 574
 575         // Get RFType
 576         pDevice->byRFType = sInitRsp.byRFType;
 577
 578         if ((pDevice->byRFType & RF_EMU) != 0) {
 579             // force change RevID for VT3253 emu
 580             pDevice->byRevId = 0x80;
 581         }
 582
 583         // Load EEPROM calibrated vt3266 parameters
 584         if (pDevice->byRFType == RF_VT3226D0) {
 585             if((pDevice->abyEEPROM[EEP_OFS_MAJOR_VER] == 0x1) &&
 586                 (pDevice->abyEEPROM[EEP_OFS_MINOR_VER] >= 0x4)) {
 587                 byCalibTXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_IQ];
 588                 byCalibTXDC = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_DC];
 589                 byCalibRXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_RX_IQ];
 590                 if( (byCalibTXIQ || byCalibTXDC || byCalibRXIQ) ) {
 591                     ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFF, 0x03); // CR255, Set BB to support TX/RX IQ and DC compensation Mode
 592                     ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFB, byCalibTXIQ); // CR251, TX I/Q Imbalance Calibration
 593                     ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFC, byCalibTXDC); // CR252, TX DC-Offset Calibration
 594                     ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFD, byCalibRXIQ); // CR253, RX I/Q Imbalance Calibration
 595                 } else {
 596                 // turn off BB Calibration compensation
 597                     ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFF, 0x0); // CR255
 598                 }
 599             }
 600         }
 601         pMgmt->eScanType = WMAC_SCAN_PASSIVE;
 602         pMgmt->uCurrChannel = pDevice->uChannel;
 603         pMgmt->uIBSSChannel = pDevice->uChannel;
 604         CARDbSetMediaChannel(pDevice, pMgmt->uCurrChannel);
 605
 606         // get Permanent network address
 607         memcpy(pDevice->abyPermanentNetAddr,&(sInitRsp.byNetAddr[0]),6);
 608         memcpy(pDevice->abyCurrentNetAddr,
 609                pDevice->abyPermanentNetAddr,
 610                ETH_ALEN);
 611
 612         // if exist SW network address, use SW network address.
 613
 614         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %pM\n",
 615                 pDevice->abyCurrentNetAddr);
 616     }
 617
 618     // Set BB and packet type at the same time.
 619     // Set Short Slot Time, xIFS, and RSPINF.
 620     if (pDevice->byBBType == BB_TYPE_11A) {
 621         CARDbAddBasicRate(pDevice, RATE_6M);
 622         pDevice->bShortSlotTime = TRUE;
 623     } else {
 624         CARDbAddBasicRate(pDevice, RATE_1M);
 625         pDevice->bShortSlotTime = FALSE;
 626     }
 627     BBvSetShortSlotTime(pDevice);
 628     CARDvSetBSSMode(pDevice);
 629
 630     if (pDevice->bUpdateBBVGA) {
 631         pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
 632         pDevice->byBBVGANew = pDevice->byBBVGACurrent;
 633         BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
 634     }
 635
 636     pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];
 637     pDevice->bHWRadioOff = FALSE;
 638     if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) {
 639         ntStatus = CONTROLnsRequestIn(pDevice,
 640                                     MESSAGE_TYPE_READ,
 641                                     MAC_REG_GPIOCTL1,
 642                                     MESSAGE_REQUEST_MACREG,
 643                                     1,
 644                                     &byTmp);
 645
 646         if ( ntStatus != STATUS_SUCCESS ) {
 647             spin_unlock_irq(&pDevice->lock);
 648             return FALSE;
 649         }
 650         if ( (byTmp & GPIO3_DATA) == 0 ) {
 651             pDevice->bHWRadioOff = TRUE;
 652             MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
 653         } else {
 654             MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
 655             pDevice->bHWRadioOff = FALSE;
 656         }
 657
 658     } //EEP_RADIOCTL_ENABLE
 659
 660     ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
 661     ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
 662     MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01);
 663
 664     if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) {
 665         CARDbRadioPowerOff(pDevice);
 666     } else {
 667         CARDbRadioPowerOn(pDevice);
 668     }
 669
 670     spin_unlock_irq(&pDevice->lock);
 671     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");
 672     return TRUE;
 673 }
 674
 675 static BOOL device_release_WPADEV(PSDevice pDevice)
 676 {
 677   viawget_wpa_header *wpahdr;
 678   int ii=0;
 679  // wait_queue_head_t   Set_wait;
 680   //send device close to wpa_supplicnat layer
 681     if (pDevice->bWPADEVUp==TRUE) {
 682                  wpahdr = (viawget_wpa_header *)pDevice->skb->data;
 683                  wpahdr->type = VIAWGET_DEVICECLOSE_MSG;
 684                  wpahdr->resp_ie_len = 0;
 685                  wpahdr->req_ie_len = 0;
 686                  skb_put(pDevice->skb, sizeof(viawget_wpa_header));
 687                  pDevice->skb->dev = pDevice->wpadev;
 688                  skb_reset_mac_header(pDevice->skb);
 689                  pDevice->skb->pkt_type = PACKET_HOST;
 690                  pDevice->skb->protocol = htons(ETH_P_802_2);
 691                  memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
 692                  netif_rx(pDevice->skb);
 693                  pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
 694
 695  //wait release WPADEV
 696               //    init_waitqueue_head(&Set_wait);
 697               //    wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ);    //1s wait
 698               while(pDevice->bWPADEVUp==TRUE) {
 699                 set_current_state(TASK_UNINTERRUPTIBLE);
 700                  schedule_timeout (HZ/20);          //wait 50ms
 701                  ii++;
 702                 if(ii>20)
 703                   break;
 704               }
 705            }
 706     return TRUE;
 707 }
 708
 709 #ifdef CONFIG_PM        /* Minimal support for suspend and resume */
 710
 711 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message)
 712 {
 713         PSDevice device = usb_get_intfdata(intf);
 714
 715         if (!device || !device->dev)
 716                 return -ENODEV;
 717
 718         if (device->flags & DEVICE_FLAGS_OPENED)
 719                 device_close(device->dev);
 720
 721         usb_put_dev(interface_to_usbdev(intf));
 722
 723         return 0;
 724 }
 725
 726 static int vt6656_resume(struct usb_interface *intf)
 727 {
 728         PSDevice device = usb_get_intfdata(intf);
 729
 730         if (!device || !device->dev)
 731                 return -ENODEV;
 732
 733         usb_get_dev(interface_to_usbdev(intf));
 734
 735         if (!(device->flags & DEVICE_FLAGS_OPENED))
 736                 device_open(device->dev);
 737
 738         return 0;
 739 }
 740
 741 #endif /* CONFIG_PM */
 742
 743 static const struct net_device_ops device_netdev_ops = {
 744     .ndo_open               = device_open,
 745     .ndo_stop               = device_close,
 746     .ndo_do_ioctl           = device_ioctl,
 747     .ndo_get_stats          = device_get_stats,
 748     .ndo_start_xmit         = device_xmit,
 749     .ndo_set_rx_mode        = device_set_multi,
 750 };
 751
 752 static int __devinit
 753 vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
 754 {
 755         u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
 756         struct usb_device *udev = interface_to_usbdev(intf);
 757         int rc = 0;
 758         struct net_device *netdev = NULL;
 759         PSDevice pDevice = NULL;
 760
 761         printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
 762         printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
 763
 764         udev = usb_get_dev(udev);
 765         netdev = alloc_etherdev(sizeof(DEVICE_INFO));
 766         if (!netdev) {
 767                 printk(KERN_ERR DEVICE_NAME ": allocate net device failed\n");
 768                 rc = -ENOMEM;
 769                 goto err_nomem;
 770         }
 771
 772         pDevice = netdev_priv(netdev);
 773         memset(pDevice, 0, sizeof(DEVICE_INFO));
 774
 775         pDevice->dev = netdev;
 776         pDevice->usb = udev;
 777
 778         device_set_options(pDevice);
 779         spin_lock_init(&pDevice->lock);
 780
 781         pDevice->tx_80211 = device_dma0_tx_80211;
 782         pDevice->sMgmtObj.pAdapter = (void *) pDevice;
 783
 784         netdev->netdev_ops = &device_netdev_ops;
 785         netdev->wireless_handlers =
 786                 (struct iw_handler_def *) &iwctl_handler_def;
 787
 788         usb_set_intfdata(intf, pDevice);
 789         SET_NETDEV_DEV(netdev, &intf->dev);
 790         memcpy(pDevice->dev->dev_addr, fake_mac, ETH_ALEN);
 791         rc = register_netdev(netdev);
 792         if (rc) {
 793                 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
 794                 goto err_netdev;
 795         }
 796
 797         usb_device_reset(pDevice);
 798
 799         {
 800                 union iwreq_data wrqu;
 801                 memset(&wrqu, 0, sizeof(wrqu));
 802                 wrqu.data.flags = RT_INSMOD_EVENT_FLAG;
 803                 wrqu.data.length = IFNAMSIZ;
 804                 wireless_send_event(pDevice->dev,
 805                                     IWEVCUSTOM,
 806                                     &wrqu,
 807                                     pDevice->dev->name);
 808         }
 809
 810         return 0;
 811
 812 err_netdev:
 813         free_netdev(netdev);
 814 err_nomem:
 815         usb_put_dev(udev);
 816
 817         return rc;
 818 }
 819
 820 static void device_free_tx_bufs(PSDevice pDevice)
 821 {
 822     PUSB_SEND_CONTEXT pTxContext;
 823     int ii;
 824
 825     for (ii = 0; ii < pDevice->cbTD; ii++) {
 826
 827         pTxContext = pDevice->apTD[ii];
 828         //de-allocate URBs
 829         if (pTxContext->pUrb) {
 830             usb_kill_urb(pTxContext->pUrb);
 831             usb_free_urb(pTxContext->pUrb);
 832         }
 833         kfree(pTxContext);
 834     }
 835     return;
 836 }
 837
 838
 839 static void device_free_rx_bufs(PSDevice pDevice)
 840 {
 841     PRCB pRCB;
 842     int ii;
 843
 844     for (ii = 0; ii < pDevice->cbRD; ii++) {
 845
 846         pRCB = pDevice->apRCB[ii];
 847         //de-allocate URBs
 848         if (pRCB->pUrb) {
 849             usb_kill_urb(pRCB->pUrb);
 850             usb_free_urb(pRCB->pUrb);
 851         }
 852         //de-allocate skb
 853         if (pRCB->skb)
 854             dev_kfree_skb(pRCB->skb);
 855     }
 856     kfree(pDevice->pRCBMem);
 857
 858     return;
 859 }
 860
 861 static void usb_device_reset(PSDevice pDevice)
 862 {
 863  int status;
 864  status = usb_reset_device(pDevice->usb);
 865         if (status)
 866             printk("usb_device_reset fail status=%d\n",status);
 867         return ;
 868 }
 869
 870 static void device_free_int_bufs(PSDevice pDevice)
 871 {
 872     kfree(pDevice->intBuf.pDataBuf);
 873     return;
 874 }
 875
 876
 877 static BOOL device_alloc_bufs(PSDevice pDevice) {
 878
 879     PUSB_SEND_CONTEXT pTxContext;
 880     PRCB pRCB;
 881     int ii;
 882
 883
 884     for (ii = 0; ii < pDevice->cbTD; ii++) {
 885
 886         pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
 887         if (pTxContext == NULL) {
 888             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
 889             goto free_tx;
 890         }
 891         pDevice->apTD[ii] = pTxContext;
 892         pTxContext->pDevice = (void *) pDevice;
 893         //allocate URBs
 894         pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
 895         if (pTxContext->pUrb == NULL) {
 896             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
 897             goto free_tx;
 898         }
 899         pTxContext->bBoolInUse = FALSE;
 900     }
 901
 902     // allocate rcb mem
 903     pDevice->pRCBMem = kmalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
 904     if (pDevice->pRCBMem == NULL) {
 905         DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
 906         goto free_tx;
 907     }
 908
 909
 910     pDevice->FirstRecvFreeList = NULL;
 911     pDevice->LastRecvFreeList = NULL;
 912     pDevice->FirstRecvMngList = NULL;
 913     pDevice->LastRecvMngList = NULL;
 914     pDevice->NumRecvFreeList = 0;
 915     memset(pDevice->pRCBMem, 0, (sizeof(RCB) * pDevice->cbRD));
 916     pRCB = (PRCB) pDevice->pRCBMem;
 917
 918     for (ii = 0; ii < pDevice->cbRD; ii++) {
 919
 920         pDevice->apRCB[ii] = pRCB;
 921         pRCB->pDevice = (void *) pDevice;
 922         //allocate URBs
 923         pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
 924
 925         if (pRCB->pUrb == NULL) {
 926             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
 927             goto free_rx_tx;
 928         }
 929         pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
 930         if (pRCB->skb == NULL) {
 931             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
 932             goto free_rx_tx;
 933         }
 934         pRCB->skb->dev = pDevice->dev;
 935         pRCB->bBoolInUse = FALSE;
 936         EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
 937         pDevice->NumRecvFreeList++;
 938         pRCB++;
 939     }
 940
 941
 942         pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
 943         if (pDevice->pControlURB == NULL) {
 944             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
 945             goto free_rx_tx;
 946         }
 947
 948         pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
 949         if (pDevice->pInterruptURB == NULL) {
 950             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
 951             usb_free_urb(pDevice->pControlURB);
 952             goto free_rx_tx;
 953         }
 954
 955     pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
 956         if (pDevice->intBuf.pDataBuf == NULL) {
 957             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
 958             usb_free_urb(pDevice->pControlURB);
 959             usb_free_urb(pDevice->pInterruptURB);
 960             goto free_rx_tx;
 961         }
 962
 963     return TRUE;
 964
 965 free_rx_tx:
 966     device_free_rx_bufs(pDevice);
 967
 968 free_tx:
 969     device_free_tx_bufs(pDevice);
 970
 971         return FALSE;
 972 }
 973
 974
 975
 976
 977 static BOOL device_init_defrag_cb(PSDevice pDevice) {
 978     int i;
 979     PSDeFragControlBlock pDeF;
 980
 981     /* Init the fragment ctl entries */
 982     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
 983         pDeF = &(pDevice->sRxDFCB[i]);
 984         if (!device_alloc_frag_buf(pDevice, pDeF)) {
 985             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
 986                 pDevice->dev->name);
 987             goto free_frag;
 988         }
 989     }
 990     pDevice->cbDFCB = CB_MAX_RX_FRAG;
 991     pDevice->cbFreeDFCB = pDevice->cbDFCB;
 992     return TRUE;
 993
 994 free_frag:
 995     device_free_frag_bufs(pDevice);
 996     return FALSE;
 997 }
 998
 999
1000
1001 static void device_free_frag_bufs(PSDevice pDevice) {
1002     PSDeFragControlBlock pDeF;
1003     int i;
1004
1005     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1006
1007         pDeF = &(pDevice->sRxDFCB[i]);
1008
1009         if (pDeF->skb)
1010             dev_kfree_skb(pDeF->skb);
1011     }
1012 }
1013
1014
1015
1016 BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1017
1018     pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1019     if (pDeF->skb == NULL)
1020         return FALSE;
1021     ASSERT(pDeF->skb);
1022     pDeF->skb->dev = pDevice->dev;
1023
1024     return TRUE;
1025 }
1026
1027
1028 /*-----------------------------------------------------------------*/
1029
1030 static int  device_open(struct net_device *dev) {
1031     PSDevice    pDevice=(PSDevice) netdev_priv(dev);
1032
1033      extern SWPAResult wpa_Result;
1034      memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1035      wpa_Result.proto = 0;
1036      wpa_Result.key_mgmt = 0;
1037      wpa_Result.eap_type = 0;
1038      wpa_Result.authenticated = FALSE;
1039      pDevice->fWPA_Authened = FALSE;
1040
1041     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
1042
1043
1044     pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
1045
1046     if (device_alloc_bufs(pDevice) == FALSE) {
1047         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
1048         return -ENOMEM;
1049     }
1050
1051     if (device_init_defrag_cb(pDevice)== FALSE) {
1052         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragement cb fail \n");
1053         goto free_rx_tx;
1054     }
1055
1056     MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
1057     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
1058     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
1059     MP_SET_FLAG(pDevice, fMP_POST_READS);
1060     MP_SET_FLAG(pDevice, fMP_POST_WRITES);
1061
1062    //read config file
1063     Read_config_file(pDevice);
1064
1065     if (device_init_registers(pDevice, DEVICE_INIT_COLD) == FALSE) {
1066         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
1067         goto free_all;
1068     }
1069
1070     device_set_multi(pDevice->dev);
1071     // Init for Key Management
1072
1073     KeyvInitTable(pDevice,&pDevice->sKey);
1074     memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1075     memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1076     pDevice->bStopTx0Pkt = FALSE;
1077     pDevice->bStopDataPkt = FALSE;
1078     pDevice->bRoaming = FALSE;
1079     pDevice->bIsRoaming = FALSE;
1080     pDevice->bEnableRoaming = FALSE;
1081     if (pDevice->bDiversityRegCtlON) {
1082         device_init_diversity_timer(pDevice);
1083     }
1084
1085     vMgrObjectInit(pDevice);
1086     tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
1087     tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
1088     tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
1089     add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback));
1090     pDevice->int_interval = 100;  //Max 100 microframes.
1091     pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1092
1093     pDevice->bIsRxWorkItemQueued = TRUE;
1094     pDevice->fKillEventPollingThread = FALSE;
1095     pDevice->bEventAvailable = FALSE;
1096
1097    pDevice->bWPADEVUp = FALSE;
1098 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1099      pDevice->bwextstep0 = FALSE;
1100      pDevice->bwextstep1 = FALSE;
1101      pDevice->bwextstep2 = FALSE;
1102      pDevice->bwextstep3 = FALSE;
1103      pDevice->bWPASuppWextEnabled = FALSE;
1104 #endif
1105     pDevice->byReAssocCount = 0;
1106
1107     RXvWorkItem(pDevice);
1108     INTvWorkItem(pDevice);
1109
1110     // Patch: if WEP key already set by iwconfig but device not yet open
1111     if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1112          spin_lock_irq(&pDevice->lock);
1113          KeybSetDefaultKey( pDevice,
1114                             &(pDevice->sKey),
1115                             pDevice->byKeyIndex | (1 << 31),
1116                             pDevice->uKeyLength,
1117                             NULL,
1118                             pDevice->abyKey,
1119                             KEY_CTL_WEP
1120                           );
1121          spin_unlock_irq(&pDevice->lock);
1122          pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1123     }
1124
1125     if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1126                 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1127         }
1128         else {
1129         //mike:mark@2008-11-10
1130           bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1131           /* bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL); */
1132     }
1133
1134
1135     netif_stop_queue(pDevice->dev);
1136     pDevice->flags |= DEVICE_FLAGS_OPENED;
1137
1138 {
1139   union iwreq_data      wrqu;
1140   memset(&wrqu, 0, sizeof(wrqu));
1141   wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1142   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1143 }
1144
1145     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1146     return 0;
1147
1148 free_all:
1149     device_free_frag_bufs(pDevice);
1150 free_rx_tx:
1151     device_free_rx_bufs(pDevice);
1152     device_free_tx_bufs(pDevice);
1153     device_free_int_bufs(pDevice);
1154         usb_kill_urb(pDevice->pControlURB);
1155         usb_kill_urb(pDevice->pInterruptURB);
1156     usb_free_urb(pDevice->pControlURB);
1157     usb_free_urb(pDevice->pInterruptURB);
1158
1159     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1160     return -ENOMEM;
1161 }
1162
1163
1164
1165 static int  device_close(struct net_device *dev) {
1166     PSDevice    pDevice=(PSDevice) netdev_priv(dev);
1167     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1168
1169         int uu;
1170
1171     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1172     if (pDevice == NULL)
1173         return -ENODEV;
1174
1175 {
1176   union iwreq_data      wrqu;
1177   memset(&wrqu, 0, sizeof(wrqu));
1178   wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1179   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1180 }
1181
1182     if (pDevice->bLinkPass) {
1183         bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1184         mdelay(30);
1185     }
1186
1187 device_release_WPADEV(pDevice);
1188
1189         memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1190         pMgmt->bShareKeyAlgorithm = FALSE;
1191         pDevice->bEncryptionEnable = FALSE;
1192         pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1193         spin_lock_irq(&pDevice->lock);
1194         for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1195                 MACvDisableKeyEntry(pDevice,uu);
1196         spin_unlock_irq(&pDevice->lock);
1197
1198     if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1199         MACbShutdown(pDevice);
1200     }
1201     netif_stop_queue(pDevice->dev);
1202     MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1203     MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1204     MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1205     pDevice->fKillEventPollingThread = TRUE;
1206     del_timer(&pDevice->sTimerCommand);
1207     del_timer(&pMgmt->sTimerSecondCallback);
1208
1209     del_timer(&pDevice->sTimerTxData);
1210
1211     if (pDevice->bDiversityRegCtlON) {
1212         del_timer(&pDevice->TimerSQ3Tmax1);
1213         del_timer(&pDevice->TimerSQ3Tmax2);
1214         del_timer(&pDevice->TimerSQ3Tmax3);
1215     }
1216     tasklet_kill(&pDevice->RxMngWorkItem);
1217     tasklet_kill(&pDevice->ReadWorkItem);
1218     tasklet_kill(&pDevice->EventWorkItem);
1219
1220    pDevice->bRoaming = FALSE;
1221    pDevice->bIsRoaming = FALSE;
1222    pDevice->bEnableRoaming = FALSE;
1223     pDevice->bCmdRunning = FALSE;
1224     pDevice->bLinkPass = FALSE;
1225     memset(pMgmt->abyCurrBSSID, 0, 6);
1226     pMgmt->eCurrState = WMAC_STATE_IDLE;
1227
1228     device_free_tx_bufs(pDevice);
1229     device_free_rx_bufs(pDevice);
1230     device_free_int_bufs(pDevice);
1231     device_free_frag_bufs(pDevice);
1232
1233         usb_kill_urb(pDevice->pControlURB);
1234         usb_kill_urb(pDevice->pInterruptURB);
1235     usb_free_urb(pDevice->pControlURB);
1236     usb_free_urb(pDevice->pInterruptURB);
1237
1238     BSSvClearNodeDBTable(pDevice, 0);
1239     pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1240
1241     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1242
1243     return 0;
1244 }
1245
1246 static void __devexit vt6656_disconnect(struct usb_interface *intf)
1247 {
1248         PSDevice device = usb_get_intfdata(intf);
1249
1250         if (!device)
1251                 return;
1252
1253         {
1254                 union iwreq_data req;
1255                 memset(&req, 0, sizeof(req));
1256                 req.data.flags = RT_RMMOD_EVENT_FLAG;
1257                 wireless_send_event(device->dev, IWEVCUSTOM, &req, NULL);
1258         }
1259
1260         device_release_WPADEV(device);
1261
1262         if (device->firmware)
1263                 release_firmware(device->firmware);
1264
1265         usb_set_intfdata(intf, NULL);
1266         usb_put_dev(interface_to_usbdev(intf));
1267
1268         device->flags |= DEVICE_FLAGS_UNPLUG;
1269
1270         if (device->dev) {
1271                 unregister_netdev(device->dev);
1272                 wpa_set_wpadev(device, 0);
1273                 free_netdev(device->dev);
1274         }
1275 }
1276
1277 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1278 {
1279         PSDevice pDevice = netdev_priv(dev);
1280
1281         spin_lock_irq(&pDevice->lock);
1282
1283         if (unlikely(pDevice->bStopTx0Pkt))
1284                 dev_kfree_skb_irq(skb);
1285         else
1286                 vDMA0_tx_80211(pDevice, skb);
1287
1288         spin_unlock_irq(&pDevice->lock);
1289
1290         return NETDEV_TX_OK;
1291 }
1292
1293 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1294 {
1295         PSDevice pDevice = netdev_priv(dev);
1296         struct net_device_stats *stats = &pDevice->stats;
1297
1298         spin_lock_irq(&pDevice->lock);
1299
1300         netif_stop_queue(dev);
1301
1302         if (!pDevice->bLinkPass) {
1303                 dev_kfree_skb_irq(skb);
1304                 goto out;
1305         }
1306
1307         if (pDevice->bStopDataPkt) {
1308                 dev_kfree_skb_irq(skb);
1309                 stats->tx_dropped++;
1310                 goto out;
1311         }
1312
1313         if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1314                 if (netif_queue_stopped(dev))
1315                         netif_wake_queue(dev);
1316         }
1317
1318 out:
1319         spin_unlock_irq(&pDevice->lock);
1320
1321         return NETDEV_TX_OK;
1322 }
1323
1324 static unsigned const ethernet_polynomial = 0x04c11db7U;
1325 static inline u32 ether_crc(int length, unsigned char *data)
1326 {
1327     int crc = -1;
1328
1329     while(--length >= 0) {
1330         unsigned char current_octet = *data++;
1331         int bit;
1332         for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1333             crc = (crc << 1) ^
1334                 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1335         }
1336     }
1337     return crc;
1338 }
1339
1340 //find out  the start  position of str2 from str1
1341 static unsigned char *kstrstr(const unsigned char *str1,
1342                               const unsigned char *str2) {
1343   int str1_len = strlen(str1);
1344   int str2_len = strlen(str2);
1345
1346   while (str1_len >= str2_len) {
1347        str1_len--;
1348       if(memcmp(str1,str2,str2_len)==0)
1349         return (unsigned char *) str1;
1350         str1++;
1351   }
1352   return NULL;
1353 }
1354
1355 static int Config_FileGetParameter(unsigned char *string,
1356                                    unsigned char *dest,
1357                                    unsigned char *source)
1358 {
1359   unsigned char buf1[100];
1360   unsigned char buf2[100];
1361   unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1362   int ii;
1363
1364     memset(buf1,0,100);
1365     strcat(buf1, string);
1366     strcat(buf1, "=");
1367     source+=strlen(buf1);
1368
1369 //find target string start point
1370     start_p = kstrstr(source,buf1);
1371     if (start_p == NULL)
1372         return FALSE;
1373
1374 //check if current config line is marked by "#" ??
1375     for (ii = 1; ; ii++) {
1376         if (memcmp(start_p - ii, "\n", 1) == 0)
1377                 break;
1378         if (memcmp(start_p - ii, "#", 1) == 0)
1379                 return FALSE;
1380     }
1381
1382 //find target string end point
1383      end_p = kstrstr(start_p,"\n");
1384      if (end_p == NULL) {       //can't find "\n",but don't care
1385           end_p=start_p+strlen(start_p);   //no include "\n"
1386        }
1387
1388    memset(buf2,0,100);
1389    memcpy(buf2,start_p,end_p-start_p);    //get the tartget line
1390    buf2[end_p-start_p]='\0';
1391
1392    //find value
1393    start_p = kstrstr(buf2,"=");
1394    if (start_p == NULL)
1395       return FALSE;
1396    memset(buf1,0,100);
1397    strcpy(buf1,start_p+1);
1398
1399   //except space
1400   tmp_p = buf1;
1401   while(*tmp_p != 0x00) {
1402         if(*tmp_p==' ')
1403             tmp_p++;
1404          else
1405           break;
1406   }
1407
1408    memcpy(dest,tmp_p,strlen(tmp_p));
1409  return TRUE;
1410 }
1411
1412 //if read fail,return NULL,or return data pointer;
1413 static unsigned char *Config_FileOperation(PSDevice pDevice)
1414 {
1415     unsigned char *config_path = CONFIG_PATH;
1416     unsigned char *buffer = NULL;
1417     struct file   *filp=NULL;
1418     mm_segment_t old_fs = get_fs();
1419     //int oldfsuid=0,oldfsgid=0;
1420     int result = 0;
1421
1422     set_fs (KERNEL_DS);
1423     /* Can't do this anymore, so we rely on correct filesystem permissions:
1424     //Make sure a caller can read or write power as root
1425     oldfsuid=current->fsuid;
1426     oldfsgid=current->fsgid;
1427     current->fsuid = 0;
1428     current->fsgid = 0;
1429     */
1430
1431     //open file
1432       filp = filp_open(config_path, O_RDWR, 0);
1433         if (IS_ERR(filp)) {
1434              printk("Config_FileOperation file Not exist\n");
1435              result=-1;
1436              goto error2;
1437           }
1438
1439      if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1440            printk("file %s cann't readable or writable?\n",config_path);
1441           result = -1;
1442           goto error1;
1443         }
1444
1445     buffer = kmalloc(1024, GFP_KERNEL);
1446     if(buffer==NULL) {
1447       printk("allocate mem for file fail?\n");
1448       result = -1;
1449       goto error1;
1450     }
1451
1452     if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1453      printk("read file error?\n");
1454      result = -1;
1455     }
1456
1457 error1:
1458   if(filp_close(filp,NULL))
1459        printk("Config_FileOperation:close file fail\n");
1460
1461 error2:
1462   set_fs (old_fs);
1463
1464   /*
1465   current->fsuid=oldfsuid;
1466   current->fsgid=oldfsgid;
1467   */
1468
1469 if(result!=0) {
1470     kfree(buffer);
1471     buffer=NULL;
1472 }
1473   return buffer;
1474 }
1475
1476 //return --->-1:fail;  >=0:successful
1477 static int Read_config_file(PSDevice pDevice) {
1478   int result = 0;
1479   unsigned char tmpbuffer[100];
1480   unsigned char *buffer = NULL;
1481
1482   //init config setting
1483  pDevice->config_file.ZoneType = -1;
1484  pDevice->config_file.eAuthenMode = -1;
1485  pDevice->config_file.eEncryptionStatus = -1;
1486
1487   buffer = Config_FileOperation(pDevice);
1488   if (buffer == NULL) {
1489      result =-1;
1490      return result;
1491   }
1492
1493 //get zonetype
1494 {
1495     memset(tmpbuffer,0,sizeof(tmpbuffer));
1496     if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1497     if(memcmp(tmpbuffer,"USA",3)==0) {
1498       pDevice->config_file.ZoneType=ZoneType_USA;
1499     }
1500     else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1501       pDevice->config_file.ZoneType=ZoneType_Japan;
1502     }
1503     else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1504      pDevice->config_file.ZoneType=ZoneType_Europe;
1505     }
1506     else {
1507       printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1508    }
1509  }
1510 }
1511
1512 //get other parameter
1513   {
1514         memset(tmpbuffer,0,sizeof(tmpbuffer));
1515        if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1516          pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1517        }
1518
1519         memset(tmpbuffer,0,sizeof(tmpbuffer));
1520        if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1521          pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1522        }
1523   }
1524
1525   kfree(buffer);
1526   return result;
1527 }
1528
1529 static void device_set_multi(struct net_device *dev) {
1530     PSDevice         pDevice = (PSDevice) netdev_priv(dev);
1531     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1532     u32              mc_filter[2];
1533     int              ii;
1534     struct netdev_hw_addr *ha;
1535     BYTE             pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1536     BYTE             byTmpMode = 0;
1537     int              rc;
1538
1539
1540         spin_lock_irq(&pDevice->lock);
1541     rc = CONTROLnsRequestIn(pDevice,
1542                             MESSAGE_TYPE_READ,
1543                             MAC_REG_RCR,
1544                             MESSAGE_REQUEST_MACREG,
1545                             1,
1546                             &byTmpMode
1547                             );
1548     if (rc == 0) pDevice->byRxMode = byTmpMode;
1549
1550     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1551
1552     if (dev->flags & IFF_PROMISC) {         // Set promiscuous.
1553         DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1554         // Unconditionally log net taps.
1555         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1556     }
1557     else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1558              (dev->flags & IFF_ALLMULTI)) {
1559         CONTROLnsRequestOut(pDevice,
1560                             MESSAGE_TYPE_WRITE,
1561                             MAC_REG_MAR0,
1562                             MESSAGE_REQUEST_MACREG,
1563                             8,
1564                             pbyData
1565                             );
1566         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1567     }
1568     else {
1569         memset(mc_filter, 0, sizeof(mc_filter));
1570         netdev_for_each_mc_addr(ha, dev) {
1571             int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1572             mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1573         }
1574         for (ii = 0; ii < 4; ii++) {
1575              MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1576              MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1577         }
1578         pDevice->byRxMode &= ~(RCR_UNICAST);
1579         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1580     }
1581
1582     if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1583         // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1584         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1585         pDevice->byRxMode &= ~(RCR_UNICAST);
1586     }
1587     ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1588     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1589         spin_unlock_irq(&pDevice->lock);
1590
1591 }
1592
1593
1594 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1595     PSDevice pDevice=(PSDevice) netdev_priv(dev);
1596
1597     return &pDevice->stats;
1598 }
1599
1600
1601 static int  device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1602         PSDevice                pDevice = (PSDevice)netdev_priv(dev);
1603     PSMgmtObject        pMgmt = &(pDevice->sMgmtObj);
1604     PSCmdRequest        pReq;
1605     //BOOL                bCommit = FALSE;
1606         struct iwreq *wrq = (struct iwreq *) rq;
1607         int                 rc =0;
1608
1609     if (pMgmt == NULL) {
1610         rc = -EFAULT;
1611         return rc;
1612     }
1613
1614     switch(cmd) {
1615
1616         case SIOCGIWNAME:
1617                 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1618                 break;
1619
1620         case SIOCSIWNWID:
1621         rc = -EOPNOTSUPP;
1622                 break;
1623
1624         case SIOCGIWNWID:     //0x8b03  support
1625         #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1626           rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
1627         #else
1628         rc = -EOPNOTSUPP;
1629         #endif
1630                 break;
1631
1632                 // Set frequency/channel
1633         case SIOCSIWFREQ:
1634             rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1635                 break;
1636
1637                 // Get frequency/channel
1638         case SIOCGIWFREQ:
1639                 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1640                 break;
1641
1642                 // Set desired network name (ESSID)
1643         case SIOCSIWESSID:
1644
1645                 {
1646                         char essid[IW_ESSID_MAX_SIZE+1];
1647                         if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1648                                 rc = -E2BIG;
1649                                 break;
1650                         }
1651                         if (copy_from_user(essid, wrq->u.essid.pointer,
1652                                            wrq->u.essid.length)) {
1653                                 rc = -EFAULT;
1654                                 break;
1655                         }
1656                         rc = iwctl_siwessid(dev, NULL,
1657                                             &(wrq->u.essid), essid);
1658                 }
1659                 break;
1660
1661
1662                 // Get current network name (ESSID)
1663         case SIOCGIWESSID:
1664
1665                 {
1666                         char essid[IW_ESSID_MAX_SIZE+1];
1667                         if (wrq->u.essid.pointer) {
1668                                 rc = iwctl_giwessid(dev, NULL,
1669                                                     &(wrq->u.essid), essid);
1670                                 if (copy_to_user(wrq->u.essid.pointer,
1671                                                          essid,
1672                                                          wrq->u.essid.length) )
1673                                         rc = -EFAULT;
1674                         }
1675                 }
1676                 break;
1677
1678         case SIOCSIWAP:
1679
1680                 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1681                 break;
1682
1683
1684                 // Get current Access Point (BSSID)
1685         case SIOCGIWAP:
1686                 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1687                 break;
1688
1689
1690                 // Set desired station name
1691         case SIOCSIWNICKN:
1692         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1693         rc = -EOPNOTSUPP;
1694                 break;
1695
1696                 // Get current station name
1697         case SIOCGIWNICKN:
1698         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1699         rc = -EOPNOTSUPP;
1700                 break;
1701
1702                 // Set the desired bit-rate
1703         case SIOCSIWRATE:
1704                 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1705                 break;
1706
1707         // Get the current bit-rate
1708         case SIOCGIWRATE:
1709
1710                 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1711                 break;
1712
1713         // Set the desired RTS threshold
1714         case SIOCSIWRTS:
1715
1716                 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
1717                 break;
1718
1719         // Get the current RTS threshold
1720         case SIOCGIWRTS:
1721
1722                 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1723                 break;
1724
1725                 // Set the desired fragmentation threshold
1726         case SIOCSIWFRAG:
1727
1728                 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1729             break;
1730
1731         // Get the current fragmentation threshold
1732         case SIOCGIWFRAG:
1733
1734                 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1735                 break;
1736
1737                 // Set mode of operation
1738         case SIOCSIWMODE:
1739         rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1740                 break;
1741
1742                 // Get mode of operation
1743         case SIOCGIWMODE:
1744                 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1745                 break;
1746
1747                 // Set WEP keys and mode
1748         case SIOCSIWENCODE:
1749                 {
1750             char abyKey[WLAN_WEP232_KEYLEN];
1751
1752                         if (wrq->u.encoding.pointer) {
1753
1754
1755                                 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
1756                                         rc = -E2BIG;
1757                                         break;
1758                                 }
1759                                 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
1760                                 if (copy_from_user(abyKey,
1761                                                   wrq->u.encoding.pointer,
1762                                                   wrq->u.encoding.length)) {
1763                                         rc = -EFAULT;
1764                                         break;
1765                                 }
1766                         } else if (wrq->u.encoding.length != 0) {
1767                                 rc = -EINVAL;
1768                                 break;
1769                         }
1770                         rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1771                 }
1772                 break;
1773
1774                 // Get the WEP keys and mode
1775         case SIOCGIWENCODE:
1776
1777                 if (!capable(CAP_NET_ADMIN)) {
1778                         rc = -EPERM;
1779                         break;
1780                 }
1781                 {
1782                     char abyKey[WLAN_WEP232_KEYLEN];
1783
1784                     rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1785                     if (rc != 0) break;
1786                         if (wrq->u.encoding.pointer) {
1787                                 if (copy_to_user(wrq->u.encoding.pointer,
1788                                                         abyKey,
1789                                                         wrq->u.encoding.length))
1790                                         rc = -EFAULT;
1791                         }
1792                 }
1793                 break;
1794
1795                 // Get the current Tx-Power
1796         case SIOCGIWTXPOW:
1797         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1798         rc = -EOPNOTSUPP;
1799                 break;
1800
1801         case SIOCSIWTXPOW:
1802         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1803         rc = -EOPNOTSUPP;
1804                 break;
1805
1806         case SIOCSIWRETRY:
1807
1808                 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
1809                 break;
1810
1811         case SIOCGIWRETRY:
1812
1813                 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
1814                 break;
1815
1816                 // Get range of parameters
1817         case SIOCGIWRANGE:
1818
1819                 {
1820                         struct iw_range range;
1821
1822                         rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
1823                         if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
1824                                 rc = -EFAULT;
1825                 }
1826
1827                 break;
1828
1829         case SIOCGIWPOWER:
1830
1831                 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
1832                 break;
1833
1834
1835         case SIOCSIWPOWER:
1836
1837                 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
1838                 break;
1839
1840
1841         case SIOCGIWSENS:
1842
1843             rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
1844                 break;
1845
1846         case SIOCSIWSENS:
1847         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
1848                 rc = -EOPNOTSUPP;
1849                 break;
1850
1851         case SIOCGIWAPLIST:
1852             {
1853             char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
1854
1855                     if (wrq->u.data.pointer) {
1856                         rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
1857                         if (rc == 0) {
1858                     if (copy_to_user(wrq->u.data.pointer,
1859                                                         buffer,
1860                                                        (wrq->u.data.length * (sizeof(struct sockaddr) +  sizeof(struct iw_quality)))
1861                                         ))
1862                                     rc = -EFAULT;
1863                         }
1864             }
1865         }
1866                 break;
1867
1868
1869 #ifdef WIRELESS_SPY
1870                 // Set the spy list
1871         case SIOCSIWSPY:
1872
1873         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1874                 rc = -EOPNOTSUPP;
1875                 break;
1876
1877                 // Get the spy list
1878         case SIOCGIWSPY:
1879
1880         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1881                 rc = -EOPNOTSUPP;
1882                 break;
1883
1884 #endif // WIRELESS_SPY
1885
1886         case SIOCGIWPRIV:
1887         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
1888                 rc = -EOPNOTSUPP;
1889 /*
1890                 if(wrq->u.data.pointer) {
1891                         wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
1892
1893                         if(copy_to_user(wrq->u.data.pointer,
1894                                         (u_char *) iwctl_private_args,
1895                                         sizeof(iwctl_private_args)))
1896                                 rc = -EFAULT;
1897                 }
1898 */
1899                 break;
1900
1901 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1902         case SIOCSIWAUTH:
1903                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH\n");
1904                 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
1905                 break;
1906
1907         case SIOCGIWAUTH:
1908                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
1909                 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
1910                 break;
1911
1912         case SIOCSIWGENIE:
1913                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
1914                 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1915                 break;
1916
1917         case SIOCGIWGENIE:
1918                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
1919                 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1920                 break;
1921
1922         case SIOCSIWENCODEEXT:
1923                 {
1924                         char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
1925                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
1926                         if(wrq->u.encoding.pointer){
1927                                 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
1928                                 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
1929                                         rc = -E2BIG;
1930                                         break;
1931                                 }
1932                                 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
1933                                         rc = -EFAULT;
1934                                         break;
1935                                 }
1936                         }else if(wrq->u.encoding.length != 0){
1937                                 rc = -EINVAL;
1938                                 break;
1939                         }
1940                         rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
1941                 }
1942                 break;
1943
1944         case SIOCGIWENCODEEXT:
1945                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
1946                 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
1947                 break;
1948
1949         case SIOCSIWMLME:
1950                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
1951                 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1952                 break;
1953
1954 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1955
1956     case IOCTL_CMD_TEST:
1957
1958                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1959                     rc = -EFAULT;
1960                     break;
1961                 } else {
1962                     rc = 0;
1963                 }
1964         pReq = (PSCmdRequest)rq;
1965
1966    //20080130-01,<Remark> by Mike Liu
1967       // if(pDevice->bLinkPass==TRUE)
1968           pReq->wResult = MAGIC_CODE;         //Linking status:0x3142
1969    //20080130-02,<Remark> by Mike Liu
1970       //  else
1971       //         pReq->wResult = MAGIC_CODE+1;    //disconnect status:0x3143
1972         break;
1973
1974     case IOCTL_CMD_SET:
1975                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
1976                        (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
1977                 {
1978                     rc = -EFAULT;
1979                     break;
1980                 } else {
1981                     rc = 0;
1982                 }
1983
1984             if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
1985                     return -EBUSY;
1986             }
1987         rc = private_ioctl(pDevice, rq);
1988         clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
1989         break;
1990
1991     case IOCTL_CMD_HOSTAPD:
1992
1993                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1994                     rc = -EFAULT;
1995                     break;
1996                 } else {
1997                     rc = 0;
1998                 }
1999
2000                 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
2001         break;
2002
2003     case IOCTL_CMD_WPA:
2004
2005                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2006                     rc = -EFAULT;
2007                     break;
2008                 } else {
2009                     rc = 0;
2010                 }
2011
2012                 rc = wpa_ioctl(pDevice, &wrq->u.data);
2013         break;
2014
2015         case SIOCETHTOOL:
2016         return ethtool_ioctl(dev, (void *) rq->ifr_data);
2017         // All other calls are currently unsupported
2018
2019         default:
2020                 rc = -EOPNOTSUPP;
2021         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2022
2023
2024     }
2025
2026     if (pDevice->bCommit) {
2027        if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2028            netif_stop_queue(pDevice->dev);
2029            spin_lock_irq(&pDevice->lock);
2030         bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
2031            spin_unlock_irq(&pDevice->lock);
2032        }
2033        else {
2034            DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2035            spin_lock_irq(&pDevice->lock);
2036 //2007-1121-01<Modify>by EinsnLiu
2037             if (pDevice->bLinkPass &&
2038                   memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2039                 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2040              } else {
2041            pDevice->bLinkPass = FALSE;
2042            pMgmt->eCurrState = WMAC_STATE_IDLE;
2043            memset(pMgmt->abyCurrBSSID, 0, 6);
2044                  }
2045            ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2046 //End Modify
2047            netif_stop_queue(pDevice->dev);
2048 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2049            pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2050            if (!pDevice->bWPASuppWextEnabled)
2051 #endif
2052                 bScheduleCommand((void *) pDevice,
2053                                  WLAN_CMD_BSSID_SCAN,
2054                                  pMgmt->abyDesireSSID);
2055                 bScheduleCommand((void *) pDevice,
2056                                  WLAN_CMD_SSID,
2057                                  NULL);
2058            spin_unlock_irq(&pDevice->lock);
2059       }
2060       pDevice->bCommit = FALSE;
2061     }
2062
2063
2064     return rc;
2065 }
2066
2067
2068 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2069 {
2070         u32 ethcmd;
2071
2072         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
2073                 return -EFAULT;
2074
2075         switch (ethcmd) {
2076         case ETHTOOL_GDRVINFO: {
2077                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2078                 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2079                 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2080                 if (copy_to_user(useraddr, &info, sizeof(info)))
2081                         return -EFAULT;
2082                 return 0;
2083         }
2084
2085         }
2086
2087         return -EOPNOTSUPP;
2088 }
2089
2090
2091 /*------------------------------------------------------------------*/
2092
2093 MODULE_DEVICE_TABLE(usb, vt6656_table);
2094
2095 static struct usb_driver vt6656_driver = {
2096         .name =         DEVICE_NAME,
2097         .probe =        vt6656_probe,
2098         .disconnect =   vt6656_disconnect,
2099         .id_table =     vt6656_table,
2100 #ifdef CONFIG_PM
2101         .suspend = vt6656_suspend,
2102         .resume = vt6656_resume,
2103 #endif /* CONFIG_PM */
2104 };
2105
2106 static int __init vt6656_init_module(void)
2107 {
2108     printk(KERN_NOTICE DEVICE_FULL_DRV_NAM " " DEVICE_VERSION);
2109     return usb_register(&vt6656_driver);
2110 }
2111
2112 static void __exit vt6656_cleanup_module(void)
2113 {
2114         usb_deregister(&vt6656_driver);
2115 }
2116
2117 module_init(vt6656_init_module);
2118 module_exit(vt6656_cleanup_module);