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 = %02x-%02x-%02x=%02x-%02x-%02x\n",
 615             pDevice->abyCurrentNetAddr[0],
 616             pDevice->abyCurrentNetAddr[1],
 617             pDevice->abyCurrentNetAddr[2],
 618             pDevice->abyCurrentNetAddr[3],
 619             pDevice->abyCurrentNetAddr[4],
 620             pDevice->abyCurrentNetAddr[5]);
 621     }
 622
 623
 624
 625     // Set BB and packet type at the same time.
 626     // Set Short Slot Time, xIFS, and RSPINF.
 627     if (pDevice->byBBType == BB_TYPE_11A) {
 628         CARDbAddBasicRate(pDevice, RATE_6M);
 629         pDevice->bShortSlotTime = TRUE;
 630     } else {
 631         CARDbAddBasicRate(pDevice, RATE_1M);
 632         pDevice->bShortSlotTime = FALSE;
 633     }
 634     BBvSetShortSlotTime(pDevice);
 635     CARDvSetBSSMode(pDevice);
 636
 637     if (pDevice->bUpdateBBVGA) {
 638         pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
 639         pDevice->byBBVGANew = pDevice->byBBVGACurrent;
 640         BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
 641     }
 642
 643     pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];
 644     pDevice->bHWRadioOff = FALSE;
 645     if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) {
 646         ntStatus = CONTROLnsRequestIn(pDevice,
 647                                     MESSAGE_TYPE_READ,
 648                                     MAC_REG_GPIOCTL1,
 649                                     MESSAGE_REQUEST_MACREG,
 650                                     1,
 651                                     &byTmp);
 652
 653         if ( ntStatus != STATUS_SUCCESS ) {
 654             spin_unlock_irq(&pDevice->lock);
 655             return FALSE;
 656         }
 657         if ( (byTmp & GPIO3_DATA) == 0 ) {
 658             pDevice->bHWRadioOff = TRUE;
 659             MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
 660         } else {
 661             MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
 662             pDevice->bHWRadioOff = FALSE;
 663         }
 664
 665     } //EEP_RADIOCTL_ENABLE
 666
 667     ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
 668     ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
 669     MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01);
 670
 671     if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) {
 672         CARDbRadioPowerOff(pDevice);
 673     } else {
 674         CARDbRadioPowerOn(pDevice);
 675     }
 676
 677     spin_unlock_irq(&pDevice->lock);
 678     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");
 679     return TRUE;
 680 }
 681
 682 static BOOL device_release_WPADEV(PSDevice pDevice)
 683 {
 684   viawget_wpa_header *wpahdr;
 685   int ii=0;
 686  // wait_queue_head_t   Set_wait;
 687   //send device close to wpa_supplicnat layer
 688     if (pDevice->bWPADEVUp==TRUE) {
 689                  wpahdr = (viawget_wpa_header *)pDevice->skb->data;
 690                  wpahdr->type = VIAWGET_DEVICECLOSE_MSG;
 691                  wpahdr->resp_ie_len = 0;
 692                  wpahdr->req_ie_len = 0;
 693                  skb_put(pDevice->skb, sizeof(viawget_wpa_header));
 694                  pDevice->skb->dev = pDevice->wpadev;
 695                  skb_reset_mac_header(pDevice->skb);
 696                  pDevice->skb->pkt_type = PACKET_HOST;
 697                  pDevice->skb->protocol = htons(ETH_P_802_2);
 698                  memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
 699                  netif_rx(pDevice->skb);
 700                  pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
 701
 702  //wait release WPADEV
 703               //    init_waitqueue_head(&Set_wait);
 704               //    wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ);    //1s wait
 705               while(pDevice->bWPADEVUp==TRUE) {
 706                 set_current_state(TASK_UNINTERRUPTIBLE);
 707                  schedule_timeout (HZ/20);          //wait 50ms
 708                  ii++;
 709                 if(ii>20)
 710                   break;
 711               }
 712            };
 713     return TRUE;
 714 }
 715
 716 #ifdef CONFIG_PM        /* Minimal support for suspend and resume */
 717
 718 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message)
 719 {
 720         PSDevice device = usb_get_intfdata(intf);
 721
 722         if (!device || !device->dev)
 723                 return -ENODEV;
 724
 725         if (device->flags & DEVICE_FLAGS_OPENED)
 726                 device_close(device->dev);
 727
 728         usb_put_dev(interface_to_usbdev(intf));
 729
 730         return 0;
 731 }
 732
 733 static int vt6656_resume(struct usb_interface *intf)
 734 {
 735         PSDevice device = usb_get_intfdata(intf);
 736
 737         if (!device || !device->dev)
 738                 return -ENODEV;
 739
 740         usb_get_dev(interface_to_usbdev(intf));
 741
 742         if (!(device->flags & DEVICE_FLAGS_OPENED))
 743                 device_open(device->dev);
 744
 745         return 0;
 746 }
 747
 748 #endif /* CONFIG_PM */
 749
 750 static const struct net_device_ops device_netdev_ops = {
 751     .ndo_open               = device_open,
 752     .ndo_stop               = device_close,
 753     .ndo_do_ioctl           = device_ioctl,
 754     .ndo_get_stats          = device_get_stats,
 755     .ndo_start_xmit         = device_xmit,
 756     .ndo_set_multicast_list = device_set_multi,
 757 };
 758
 759 static int __devinit
 760 vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
 761 {
 762         u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
 763         struct usb_device *udev = interface_to_usbdev(intf);
 764         int rc = 0;
 765         struct net_device *netdev = NULL;
 766         PSDevice pDevice = NULL;
 767
 768         printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
 769         printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
 770
 771         udev = usb_get_dev(udev);
 772         netdev = alloc_etherdev(sizeof(DEVICE_INFO));
 773         if (!netdev) {
 774                 printk(KERN_ERR DEVICE_NAME ": allocate net device failed\n");
 775                 rc = -ENOMEM;
 776                 goto err_nomem;
 777         }
 778
 779         pDevice = netdev_priv(netdev);
 780         memset(pDevice, 0, sizeof(DEVICE_INFO));
 781
 782         pDevice->dev = netdev;
 783         pDevice->usb = udev;
 784
 785         device_set_options(pDevice);
 786         spin_lock_init(&pDevice->lock);
 787
 788         pDevice->tx_80211 = device_dma0_tx_80211;
 789         pDevice->sMgmtObj.pAdapter = (void *) pDevice;
 790
 791         netdev->netdev_ops = &device_netdev_ops;
 792         netdev->wireless_handlers =
 793                 (struct iw_handler_def *) &iwctl_handler_def;
 794
 795         usb_set_intfdata(intf, pDevice);
 796         SET_NETDEV_DEV(netdev, &intf->dev);
 797         memcpy(pDevice->dev->dev_addr, fake_mac, ETH_ALEN);
 798         rc = register_netdev(netdev);
 799         if (rc) {
 800                 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
 801                 goto err_netdev;
 802         }
 803
 804         usb_device_reset(pDevice);
 805
 806         {
 807                 union iwreq_data wrqu;
 808                 memset(&wrqu, 0, sizeof(wrqu));
 809                 wrqu.data.flags = RT_INSMOD_EVENT_FLAG;
 810                 wrqu.data.length = IFNAMSIZ;
 811                 wireless_send_event(pDevice->dev,
 812                                     IWEVCUSTOM,
 813                                     &wrqu,
 814                                     pDevice->dev->name);
 815         }
 816
 817         return 0;
 818
 819 err_netdev:
 820         free_netdev(netdev);
 821 err_nomem:
 822         usb_put_dev(udev);
 823
 824         return rc;
 825 }
 826
 827 static void device_free_tx_bufs(PSDevice pDevice)
 828 {
 829     PUSB_SEND_CONTEXT pTxContext;
 830     int ii;
 831
 832     for (ii = 0; ii < pDevice->cbTD; ii++) {
 833
 834         pTxContext = pDevice->apTD[ii];
 835         //de-allocate URBs
 836         if (pTxContext->pUrb) {
 837             usb_kill_urb(pTxContext->pUrb);
 838             usb_free_urb(pTxContext->pUrb);
 839         }
 840         if (pTxContext)
 841             kfree(pTxContext);
 842     }
 843     return;
 844 }
 845
 846
 847 static void device_free_rx_bufs(PSDevice pDevice)
 848 {
 849     PRCB pRCB;
 850     int ii;
 851
 852     for (ii = 0; ii < pDevice->cbRD; ii++) {
 853
 854         pRCB = pDevice->apRCB[ii];
 855         //de-allocate URBs
 856         if (pRCB->pUrb) {
 857             usb_kill_urb(pRCB->pUrb);
 858             usb_free_urb(pRCB->pUrb);
 859         }
 860         //de-allocate skb
 861         if (pRCB->skb)
 862             dev_kfree_skb(pRCB->skb);
 863     }
 864     if (pDevice->pRCBMem)
 865         kfree(pDevice->pRCBMem);
 866
 867     return;
 868 }
 869
 870 static void usb_device_reset(PSDevice pDevice)
 871 {
 872  int status;
 873  status = usb_reset_device(pDevice->usb);
 874         if (status)
 875             printk("usb_device_reset fail status=%d\n",status);
 876         return ;
 877 }
 878
 879 static void device_free_int_bufs(PSDevice pDevice)
 880 {
 881     if (pDevice->intBuf.pDataBuf != NULL)
 882         kfree(pDevice->intBuf.pDataBuf);
 883     return;
 884 }
 885
 886
 887 static BOOL device_alloc_bufs(PSDevice pDevice) {
 888
 889     PUSB_SEND_CONTEXT pTxContext;
 890     PRCB pRCB;
 891     int ii;
 892
 893
 894     for (ii = 0; ii < pDevice->cbTD; ii++) {
 895
 896         pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
 897         if (pTxContext == NULL) {
 898             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
 899             goto free_tx;
 900         }
 901         pDevice->apTD[ii] = pTxContext;
 902         pTxContext->pDevice = (void *) pDevice;
 903         //allocate URBs
 904         pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
 905         if (pTxContext->pUrb == NULL) {
 906             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
 907             goto free_tx;
 908         }
 909         pTxContext->bBoolInUse = FALSE;
 910     }
 911
 912     // allocate rcb mem
 913     pDevice->pRCBMem = kmalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
 914     if (pDevice->pRCBMem == NULL) {
 915         DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
 916         goto free_tx;
 917     }
 918
 919
 920     pDevice->FirstRecvFreeList = NULL;
 921     pDevice->LastRecvFreeList = NULL;
 922     pDevice->FirstRecvMngList = NULL;
 923     pDevice->LastRecvMngList = NULL;
 924     pDevice->NumRecvFreeList = 0;
 925     memset(pDevice->pRCBMem, 0, (sizeof(RCB) * pDevice->cbRD));
 926     pRCB = (PRCB) pDevice->pRCBMem;
 927
 928     for (ii = 0; ii < pDevice->cbRD; ii++) {
 929
 930         pDevice->apRCB[ii] = pRCB;
 931         pRCB->pDevice = (void *) pDevice;
 932         //allocate URBs
 933         pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
 934
 935         if (pRCB->pUrb == NULL) {
 936             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
 937             goto free_rx_tx;
 938         }
 939         pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
 940         if (pRCB->skb == NULL) {
 941             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
 942             goto free_rx_tx;
 943         }
 944         pRCB->skb->dev = pDevice->dev;
 945         pRCB->bBoolInUse = FALSE;
 946         EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
 947         pDevice->NumRecvFreeList++;
 948         pRCB++;
 949     }
 950
 951
 952         pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
 953         if (pDevice->pControlURB == NULL) {
 954             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
 955             goto free_rx_tx;
 956         }
 957
 958         pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
 959         if (pDevice->pInterruptURB == NULL) {
 960             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
 961             usb_kill_urb(pDevice->pControlURB);
 962             usb_free_urb(pDevice->pControlURB);
 963             goto free_rx_tx;
 964         }
 965
 966     pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
 967         if (pDevice->intBuf.pDataBuf == NULL) {
 968             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
 969             usb_kill_urb(pDevice->pControlURB);
 970             usb_kill_urb(pDevice->pInterruptURB);
 971             usb_free_urb(pDevice->pControlURB);
 972             usb_free_urb(pDevice->pInterruptURB);
 973             goto free_rx_tx;
 974         }
 975
 976     return TRUE;
 977
 978 free_rx_tx:
 979     device_free_rx_bufs(pDevice);
 980
 981 free_tx:
 982     device_free_tx_bufs(pDevice);
 983
 984         return FALSE;
 985 }
 986
 987
 988
 989
 990 static BOOL device_init_defrag_cb(PSDevice pDevice) {
 991     int i;
 992     PSDeFragControlBlock pDeF;
 993
 994     /* Init the fragment ctl entries */
 995     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
 996         pDeF = &(pDevice->sRxDFCB[i]);
 997         if (!device_alloc_frag_buf(pDevice, pDeF)) {
 998             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
 999                 pDevice->dev->name);
1000             goto free_frag;
1001         };
1002     }
1003     pDevice->cbDFCB = CB_MAX_RX_FRAG;
1004     pDevice->cbFreeDFCB = pDevice->cbDFCB;
1005     return TRUE;
1006
1007 free_frag:
1008     device_free_frag_bufs(pDevice);
1009     return FALSE;
1010 }
1011
1012
1013
1014 static void device_free_frag_bufs(PSDevice pDevice) {
1015     PSDeFragControlBlock pDeF;
1016     int i;
1017
1018     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1019
1020         pDeF = &(pDevice->sRxDFCB[i]);
1021
1022         if (pDeF->skb)
1023             dev_kfree_skb(pDeF->skb);
1024     }
1025 }
1026
1027
1028
1029 BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1030
1031     pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1032     if (pDeF->skb == NULL)
1033         return FALSE;
1034     ASSERT(pDeF->skb);
1035     pDeF->skb->dev = pDevice->dev;
1036
1037     return TRUE;
1038 }
1039
1040
1041 /*-----------------------------------------------------------------*/
1042
1043 static int  device_open(struct net_device *dev) {
1044     PSDevice    pDevice=(PSDevice) netdev_priv(dev);
1045
1046      extern SWPAResult wpa_Result;
1047      memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1048      wpa_Result.proto = 0;
1049      wpa_Result.key_mgmt = 0;
1050      wpa_Result.eap_type = 0;
1051      wpa_Result.authenticated = FALSE;
1052      pDevice->fWPA_Authened = FALSE;
1053
1054     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
1055
1056
1057     pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
1058
1059     if (device_alloc_bufs(pDevice) == FALSE) {
1060         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
1061         return -ENOMEM;
1062     }
1063
1064     if (device_init_defrag_cb(pDevice)== FALSE) {
1065         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragement cb fail \n");
1066         goto free_rx_tx;
1067     }
1068
1069     MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
1070     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
1071     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
1072     MP_SET_FLAG(pDevice, fMP_POST_READS);
1073     MP_SET_FLAG(pDevice, fMP_POST_WRITES);
1074
1075    //read config file
1076     Read_config_file(pDevice);
1077
1078     if (device_init_registers(pDevice, DEVICE_INIT_COLD) == FALSE) {
1079         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
1080         goto free_all;
1081     }
1082
1083     device_set_multi(pDevice->dev);
1084     // Init for Key Management
1085
1086     KeyvInitTable(pDevice,&pDevice->sKey);
1087     memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1088     memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1089     pDevice->bStopTx0Pkt = FALSE;
1090     pDevice->bStopDataPkt = FALSE;
1091     pDevice->bRoaming = FALSE;
1092     pDevice->bIsRoaming = FALSE;
1093     pDevice->bEnableRoaming = FALSE;
1094     if (pDevice->bDiversityRegCtlON) {
1095         device_init_diversity_timer(pDevice);
1096     }
1097
1098     vMgrObjectInit(pDevice);
1099     tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
1100     tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
1101     tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
1102     add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback));
1103     pDevice->int_interval = 100;  //Max 100 microframes.
1104     pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1105
1106     pDevice->bIsRxWorkItemQueued = TRUE;
1107     pDevice->fKillEventPollingThread = FALSE;
1108     pDevice->bEventAvailable = FALSE;
1109
1110    pDevice->bWPADEVUp = FALSE;
1111 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1112      pDevice->bwextstep0 = FALSE;
1113      pDevice->bwextstep1 = FALSE;
1114      pDevice->bwextstep2 = FALSE;
1115      pDevice->bwextstep3 = FALSE;
1116      pDevice->bWPASuppWextEnabled = FALSE;
1117 #endif
1118     pDevice->byReAssocCount = 0;
1119
1120     RXvWorkItem(pDevice);
1121     INTvWorkItem(pDevice);
1122
1123     // Patch: if WEP key already set by iwconfig but device not yet open
1124     if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1125          spin_lock_irq(&pDevice->lock);
1126          KeybSetDefaultKey( pDevice,
1127                             &(pDevice->sKey),
1128                             pDevice->byKeyIndex | (1 << 31),
1129                             pDevice->uKeyLength,
1130                             NULL,
1131                             pDevice->abyKey,
1132                             KEY_CTL_WEP
1133                           );
1134          spin_unlock_irq(&pDevice->lock);
1135          pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1136     }
1137
1138     if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1139                 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1140         }
1141         else {
1142         //mike:mark@2008-11-10
1143           bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1144           /* bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL); */
1145     }
1146
1147
1148     netif_stop_queue(pDevice->dev);
1149     pDevice->flags |= DEVICE_FLAGS_OPENED;
1150
1151 {
1152   union iwreq_data      wrqu;
1153   memset(&wrqu, 0, sizeof(wrqu));
1154   wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1155   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1156 }
1157
1158     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1159     return 0;
1160
1161 free_all:
1162     device_free_frag_bufs(pDevice);
1163 free_rx_tx:
1164     device_free_rx_bufs(pDevice);
1165     device_free_tx_bufs(pDevice);
1166     device_free_int_bufs(pDevice);
1167         usb_kill_urb(pDevice->pControlURB);
1168         usb_kill_urb(pDevice->pInterruptURB);
1169     usb_free_urb(pDevice->pControlURB);
1170     usb_free_urb(pDevice->pInterruptURB);
1171
1172     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1173     return -ENOMEM;
1174 }
1175
1176
1177
1178 static int  device_close(struct net_device *dev) {
1179     PSDevice    pDevice=(PSDevice) netdev_priv(dev);
1180     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1181
1182         int uu;
1183
1184     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1185     if (pDevice == NULL)
1186         return -ENODEV;
1187
1188 {
1189   union iwreq_data      wrqu;
1190   memset(&wrqu, 0, sizeof(wrqu));
1191   wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1192   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1193 }
1194
1195     if (pDevice->bLinkPass) {
1196         bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1197         mdelay(30);
1198     }
1199
1200 device_release_WPADEV(pDevice);
1201
1202         memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1203         pMgmt->bShareKeyAlgorithm = FALSE;
1204         pDevice->bEncryptionEnable = FALSE;
1205         pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1206         spin_lock_irq(&pDevice->lock);
1207         for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1208                 MACvDisableKeyEntry(pDevice,uu);
1209         spin_unlock_irq(&pDevice->lock);
1210
1211     if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1212         MACbShutdown(pDevice);
1213     }
1214     netif_stop_queue(pDevice->dev);
1215     MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1216     MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1217     MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1218     pDevice->fKillEventPollingThread = TRUE;
1219     del_timer(&pDevice->sTimerCommand);
1220     del_timer(&pMgmt->sTimerSecondCallback);
1221
1222     del_timer(&pDevice->sTimerTxData);
1223
1224     if (pDevice->bDiversityRegCtlON) {
1225         del_timer(&pDevice->TimerSQ3Tmax1);
1226         del_timer(&pDevice->TimerSQ3Tmax2);
1227         del_timer(&pDevice->TimerSQ3Tmax3);
1228     }
1229     tasklet_kill(&pDevice->RxMngWorkItem);
1230     tasklet_kill(&pDevice->ReadWorkItem);
1231     tasklet_kill(&pDevice->EventWorkItem);
1232
1233    pDevice->bRoaming = FALSE;
1234    pDevice->bIsRoaming = FALSE;
1235    pDevice->bEnableRoaming = FALSE;
1236     pDevice->bCmdRunning = FALSE;
1237     pDevice->bLinkPass = FALSE;
1238     memset(pMgmt->abyCurrBSSID, 0, 6);
1239     pMgmt->eCurrState = WMAC_STATE_IDLE;
1240
1241     device_free_tx_bufs(pDevice);
1242     device_free_rx_bufs(pDevice);
1243     device_free_int_bufs(pDevice);
1244     device_free_frag_bufs(pDevice);
1245
1246         usb_kill_urb(pDevice->pControlURB);
1247         usb_kill_urb(pDevice->pInterruptURB);
1248     usb_free_urb(pDevice->pControlURB);
1249     usb_free_urb(pDevice->pInterruptURB);
1250
1251     BSSvClearNodeDBTable(pDevice, 0);
1252     pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1253
1254     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1255
1256     return 0;
1257 }
1258
1259 static void __devexit vt6656_disconnect(struct usb_interface *intf)
1260 {
1261         PSDevice device = usb_get_intfdata(intf);
1262
1263         if (!device)
1264                 return;
1265
1266         {
1267                 union iwreq_data req;
1268                 memset(&req, 0, sizeof(req));
1269                 req.data.flags = RT_RMMOD_EVENT_FLAG;
1270                 wireless_send_event(device->dev, IWEVCUSTOM, &req, NULL);
1271         }
1272
1273         device_release_WPADEV(device);
1274
1275         if (device->firmware)
1276                 release_firmware(device->firmware);
1277
1278         usb_set_intfdata(intf, NULL);
1279         usb_put_dev(interface_to_usbdev(intf));
1280
1281         device->flags |= DEVICE_FLAGS_UNPLUG;
1282
1283         if (device->dev) {
1284                 unregister_netdev(device->dev);
1285                 wpa_set_wpadev(device, 0);
1286                 free_netdev(device->dev);
1287         }
1288 }
1289
1290 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1291 {
1292         PSDevice pDevice = netdev_priv(dev);
1293
1294         spin_lock_irq(&pDevice->lock);
1295
1296         if (unlikely(pDevice->bStopTx0Pkt))
1297                 dev_kfree_skb_irq(skb);
1298         else
1299                 vDMA0_tx_80211(pDevice, skb);
1300
1301         spin_unlock_irq(&pDevice->lock);
1302
1303         return NETDEV_TX_OK;
1304 }
1305
1306 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1307 {
1308         PSDevice pDevice = netdev_priv(dev);
1309         struct net_device_stats *stats = &pDevice->stats;
1310
1311         spin_lock_irq(&pDevice->lock);
1312
1313         netif_stop_queue(dev);
1314
1315         if (!pDevice->bLinkPass) {
1316                 dev_kfree_skb_irq(skb);
1317                 goto out;
1318         }
1319
1320         if (pDevice->bStopDataPkt) {
1321                 dev_kfree_skb_irq(skb);
1322                 stats->tx_dropped++;
1323                 goto out;
1324         }
1325
1326         if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1327                 if (netif_queue_stopped(dev))
1328                         netif_wake_queue(dev);
1329         }
1330
1331 out:
1332         spin_unlock_irq(&pDevice->lock);
1333
1334         return NETDEV_TX_OK;
1335 }
1336
1337 static unsigned const ethernet_polynomial = 0x04c11db7U;
1338 static inline u32 ether_crc(int length, unsigned char *data)
1339 {
1340     int crc = -1;
1341
1342     while(--length >= 0) {
1343         unsigned char current_octet = *data++;
1344         int bit;
1345         for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1346             crc = (crc << 1) ^
1347                 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1348         }
1349     }
1350     return crc;
1351 }
1352
1353 //find out  the start  position of str2 from str1
1354 static unsigned char *kstrstr(const unsigned char *str1,
1355                               const unsigned char *str2) {
1356   int str1_len = strlen(str1);
1357   int str2_len = strlen(str2);
1358
1359   while (str1_len >= str2_len) {
1360        str1_len--;
1361       if(memcmp(str1,str2,str2_len)==0)
1362         return (unsigned char *) str1;
1363         str1++;
1364   }
1365   return NULL;
1366 }
1367
1368 static int Config_FileGetParameter(unsigned char *string,
1369                                    unsigned char *dest,
1370                                    unsigned char *source)
1371 {
1372   unsigned char buf1[100];
1373   unsigned char buf2[100];
1374   unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1375   int ii;
1376
1377     memset(buf1,0,100);
1378     strcat(buf1, string);
1379     strcat(buf1, "=");
1380     source+=strlen(buf1);
1381
1382 //find target string start point
1383     start_p = kstrstr(source,buf1);
1384     if (start_p == NULL)
1385         return FALSE;
1386
1387 //check if current config line is marked by "#" ??
1388     for (ii = 1; ; ii++) {
1389         if (memcmp(start_p - ii, "\n", 1) == 0)
1390                 break;
1391         if (memcmp(start_p - ii, "#", 1) == 0)
1392                 return FALSE;
1393     }
1394
1395 //find target string end point
1396      end_p = kstrstr(start_p,"\n");
1397      if (end_p == NULL) {       //can't find "\n",but don't care
1398           end_p=start_p+strlen(start_p);   //no include "\n"
1399        }
1400
1401    memset(buf2,0,100);
1402    memcpy(buf2,start_p,end_p-start_p);    //get the tartget line
1403    buf2[end_p-start_p]='\0';
1404
1405    //find value
1406    start_p = kstrstr(buf2,"=");
1407    if (start_p == NULL)
1408       return FALSE;
1409    memset(buf1,0,100);
1410    strcpy(buf1,start_p+1);
1411
1412   //except space
1413   tmp_p = buf1;
1414   while(*tmp_p != 0x00) {
1415         if(*tmp_p==' ')
1416             tmp_p++;
1417          else
1418           break;
1419   }
1420
1421    memcpy(dest,tmp_p,strlen(tmp_p));
1422  return TRUE;
1423 }
1424
1425 //if read fail,return NULL,or return data pointer;
1426 static unsigned char *Config_FileOperation(PSDevice pDevice)
1427 {
1428     unsigned char *config_path = CONFIG_PATH;
1429     unsigned char *buffer = NULL;
1430     struct file   *filp=NULL;
1431     mm_segment_t old_fs = get_fs();
1432     //int oldfsuid=0,oldfsgid=0;
1433     int result = 0;
1434
1435     set_fs (KERNEL_DS);
1436     /* Can't do this anymore, so we rely on correct filesystem permissions:
1437     //Make sure a caller can read or write power as root
1438     oldfsuid=current->fsuid;
1439     oldfsgid=current->fsgid;
1440     current->fsuid = 0;
1441     current->fsgid = 0;
1442     */
1443
1444     //open file
1445       filp = filp_open(config_path, O_RDWR, 0);
1446         if (IS_ERR(filp)) {
1447              printk("Config_FileOperation file Not exist\n");
1448              result=-1;
1449              goto error2;
1450           }
1451
1452      if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1453            printk("file %s cann't readable or writable?\n",config_path);
1454           result = -1;
1455           goto error1;
1456         }
1457
1458     buffer = kmalloc(1024, GFP_KERNEL);
1459     if(buffer==NULL) {
1460       printk("allocate mem for file fail?\n");
1461       result = -1;
1462       goto error1;
1463     }
1464
1465     if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1466      printk("read file error?\n");
1467      result = -1;
1468     }
1469
1470 error1:
1471   if(filp_close(filp,NULL))
1472        printk("Config_FileOperation:close file fail\n");
1473
1474 error2:
1475   set_fs (old_fs);
1476
1477   /*
1478   current->fsuid=oldfsuid;
1479   current->fsgid=oldfsgid;
1480   */
1481
1482 if(result!=0) {
1483     if(buffer)
1484          kfree(buffer);
1485     buffer=NULL;
1486 }
1487   return buffer;
1488 }
1489
1490 //return --->-1:fail;  >=0:successful
1491 static int Read_config_file(PSDevice pDevice) {
1492   int result = 0;
1493   unsigned char tmpbuffer[100];
1494   unsigned char *buffer = NULL;
1495
1496   //init config setting
1497  pDevice->config_file.ZoneType = -1;
1498  pDevice->config_file.eAuthenMode = -1;
1499  pDevice->config_file.eEncryptionStatus = -1;
1500
1501   buffer = Config_FileOperation(pDevice);
1502   if (buffer == NULL) {
1503      result =-1;
1504      return result;
1505   }
1506
1507 //get zonetype
1508 {
1509     memset(tmpbuffer,0,sizeof(tmpbuffer));
1510     if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1511     if(memcmp(tmpbuffer,"USA",3)==0) {
1512       pDevice->config_file.ZoneType=ZoneType_USA;
1513     }
1514     else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1515       pDevice->config_file.ZoneType=ZoneType_Japan;
1516     }
1517     else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1518      pDevice->config_file.ZoneType=ZoneType_Europe;
1519     }
1520     else {
1521       printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1522    }
1523  }
1524 }
1525
1526 //get other parameter
1527   {
1528         memset(tmpbuffer,0,sizeof(tmpbuffer));
1529        if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1530          pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1531        }
1532
1533         memset(tmpbuffer,0,sizeof(tmpbuffer));
1534        if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1535          pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1536        }
1537   }
1538
1539   kfree(buffer);
1540   return result;
1541 }
1542
1543 static void device_set_multi(struct net_device *dev) {
1544     PSDevice         pDevice = (PSDevice) netdev_priv(dev);
1545     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1546     u32              mc_filter[2];
1547     int              ii;
1548     struct netdev_hw_addr *ha;
1549     BYTE             pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1550     BYTE             byTmpMode = 0;
1551     int              rc;
1552
1553
1554         spin_lock_irq(&pDevice->lock);
1555     rc = CONTROLnsRequestIn(pDevice,
1556                             MESSAGE_TYPE_READ,
1557                             MAC_REG_RCR,
1558                             MESSAGE_REQUEST_MACREG,
1559                             1,
1560                             &byTmpMode
1561                             );
1562     if (rc == 0) pDevice->byRxMode = byTmpMode;
1563
1564     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1565
1566     if (dev->flags & IFF_PROMISC) {         // Set promiscuous.
1567         DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1568         // Unconditionally log net taps.
1569         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1570     }
1571     else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1572              (dev->flags & IFF_ALLMULTI)) {
1573         CONTROLnsRequestOut(pDevice,
1574                             MESSAGE_TYPE_WRITE,
1575                             MAC_REG_MAR0,
1576                             MESSAGE_REQUEST_MACREG,
1577                             8,
1578                             pbyData
1579                             );
1580         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1581     }
1582     else {
1583         memset(mc_filter, 0, sizeof(mc_filter));
1584         netdev_for_each_mc_addr(ha, dev) {
1585             int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1586             mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1587         }
1588         for (ii = 0; ii < 4; ii++) {
1589              MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1590              MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1591         }
1592         pDevice->byRxMode &= ~(RCR_UNICAST);
1593         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1594     }
1595
1596     if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1597         // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1598         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1599         pDevice->byRxMode &= ~(RCR_UNICAST);
1600     }
1601     ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1602     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1603         spin_unlock_irq(&pDevice->lock);
1604
1605 }
1606
1607
1608 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1609     PSDevice pDevice=(PSDevice) netdev_priv(dev);
1610
1611     return &pDevice->stats;
1612 }
1613
1614
1615 static int  device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1616         PSDevice                pDevice = (PSDevice)netdev_priv(dev);
1617     PSMgmtObject        pMgmt = &(pDevice->sMgmtObj);
1618     PSCmdRequest        pReq;
1619     //BOOL                bCommit = FALSE;
1620         struct iwreq *wrq = (struct iwreq *) rq;
1621         int                 rc =0;
1622
1623     if (pMgmt == NULL) {
1624         rc = -EFAULT;
1625         return rc;
1626     }
1627
1628     switch(cmd) {
1629
1630         case SIOCGIWNAME:
1631                 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1632                 break;
1633
1634         case SIOCSIWNWID:
1635         rc = -EOPNOTSUPP;
1636                 break;
1637
1638         case SIOCGIWNWID:     //0x8b03  support
1639         #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1640           rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
1641         #else
1642         rc = -EOPNOTSUPP;
1643         #endif
1644                 break;
1645
1646                 // Set frequency/channel
1647         case SIOCSIWFREQ:
1648             rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1649                 break;
1650
1651                 // Get frequency/channel
1652         case SIOCGIWFREQ:
1653                 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1654                 break;
1655
1656                 // Set desired network name (ESSID)
1657         case SIOCSIWESSID:
1658
1659                 {
1660                         char essid[IW_ESSID_MAX_SIZE+1];
1661                         if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1662                                 rc = -E2BIG;
1663                                 break;
1664                         }
1665                         if (copy_from_user(essid, wrq->u.essid.pointer,
1666                                            wrq->u.essid.length)) {
1667                                 rc = -EFAULT;
1668                                 break;
1669                         }
1670                         rc = iwctl_siwessid(dev, NULL,
1671                                             &(wrq->u.essid), essid);
1672                 }
1673                 break;
1674
1675
1676                 // Get current network name (ESSID)
1677         case SIOCGIWESSID:
1678
1679                 {
1680                         char essid[IW_ESSID_MAX_SIZE+1];
1681                         if (wrq->u.essid.pointer) {
1682                                 rc = iwctl_giwessid(dev, NULL,
1683                                                     &(wrq->u.essid), essid);
1684                                 if (copy_to_user(wrq->u.essid.pointer,
1685                                                          essid,
1686                                                          wrq->u.essid.length) )
1687                                         rc = -EFAULT;
1688                         }
1689                 }
1690                 break;
1691
1692         case SIOCSIWAP:
1693
1694                 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1695                 break;
1696
1697
1698                 // Get current Access Point (BSSID)
1699         case SIOCGIWAP:
1700                 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1701                 break;
1702
1703
1704                 // Set desired station name
1705         case SIOCSIWNICKN:
1706         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1707         rc = -EOPNOTSUPP;
1708                 break;
1709
1710                 // Get current station name
1711         case SIOCGIWNICKN:
1712         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1713         rc = -EOPNOTSUPP;
1714                 break;
1715
1716                 // Set the desired bit-rate
1717         case SIOCSIWRATE:
1718                 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1719                 break;
1720
1721         // Get the current bit-rate
1722         case SIOCGIWRATE:
1723
1724                 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1725                 break;
1726
1727         // Set the desired RTS threshold
1728         case SIOCSIWRTS:
1729
1730                 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
1731                 break;
1732
1733         // Get the current RTS threshold
1734         case SIOCGIWRTS:
1735
1736                 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1737                 break;
1738
1739                 // Set the desired fragmentation threshold
1740         case SIOCSIWFRAG:
1741
1742                 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1743             break;
1744
1745         // Get the current fragmentation threshold
1746         case SIOCGIWFRAG:
1747
1748                 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1749                 break;
1750
1751                 // Set mode of operation
1752         case SIOCSIWMODE:
1753         rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1754                 break;
1755
1756                 // Get mode of operation
1757         case SIOCGIWMODE:
1758                 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1759                 break;
1760
1761                 // Set WEP keys and mode
1762         case SIOCSIWENCODE:
1763                 {
1764             char abyKey[WLAN_WEP232_KEYLEN];
1765
1766                         if (wrq->u.encoding.pointer) {
1767
1768
1769                                 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
1770                                         rc = -E2BIG;
1771                                         break;
1772                                 }
1773                                 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
1774                                 if (copy_from_user(abyKey,
1775                                                   wrq->u.encoding.pointer,
1776                                                   wrq->u.encoding.length)) {
1777                                         rc = -EFAULT;
1778                                         break;
1779                                 }
1780                         } else if (wrq->u.encoding.length != 0) {
1781                                 rc = -EINVAL;
1782                                 break;
1783                         }
1784                         rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1785                 }
1786                 break;
1787
1788                 // Get the WEP keys and mode
1789         case SIOCGIWENCODE:
1790
1791                 if (!capable(CAP_NET_ADMIN)) {
1792                         rc = -EPERM;
1793                         break;
1794                 }
1795                 {
1796                     char abyKey[WLAN_WEP232_KEYLEN];
1797
1798                     rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1799                     if (rc != 0) break;
1800                         if (wrq->u.encoding.pointer) {
1801                                 if (copy_to_user(wrq->u.encoding.pointer,
1802                                                         abyKey,
1803                                                         wrq->u.encoding.length))
1804                                         rc = -EFAULT;
1805                         }
1806                 }
1807                 break;
1808
1809                 // Get the current Tx-Power
1810         case SIOCGIWTXPOW:
1811         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1812         rc = -EOPNOTSUPP;
1813                 break;
1814
1815         case SIOCSIWTXPOW:
1816         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1817         rc = -EOPNOTSUPP;
1818                 break;
1819
1820         case SIOCSIWRETRY:
1821
1822                 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
1823                 break;
1824
1825         case SIOCGIWRETRY:
1826
1827                 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
1828                 break;
1829
1830                 // Get range of parameters
1831         case SIOCGIWRANGE:
1832
1833                 {
1834                         struct iw_range range;
1835
1836                         rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
1837                         if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
1838                                 rc = -EFAULT;
1839                 }
1840
1841                 break;
1842
1843         case SIOCGIWPOWER:
1844
1845                 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
1846                 break;
1847
1848
1849         case SIOCSIWPOWER:
1850
1851                 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
1852                 break;
1853
1854
1855         case SIOCGIWSENS:
1856
1857             rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
1858                 break;
1859
1860         case SIOCSIWSENS:
1861         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
1862                 rc = -EOPNOTSUPP;
1863                 break;
1864
1865         case SIOCGIWAPLIST:
1866             {
1867             char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
1868
1869                     if (wrq->u.data.pointer) {
1870                         rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
1871                         if (rc == 0) {
1872                     if (copy_to_user(wrq->u.data.pointer,
1873                                                         buffer,
1874                                                        (wrq->u.data.length * (sizeof(struct sockaddr) +  sizeof(struct iw_quality)))
1875                                         ))
1876                                     rc = -EFAULT;
1877                         }
1878             }
1879         }
1880                 break;
1881
1882
1883 #ifdef WIRELESS_SPY
1884                 // Set the spy list
1885         case SIOCSIWSPY:
1886
1887         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1888                 rc = -EOPNOTSUPP;
1889                 break;
1890
1891                 // Get the spy list
1892         case SIOCGIWSPY:
1893
1894         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1895                 rc = -EOPNOTSUPP;
1896                 break;
1897
1898 #endif // WIRELESS_SPY
1899
1900         case SIOCGIWPRIV:
1901         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
1902                 rc = -EOPNOTSUPP;
1903 /*
1904                 if(wrq->u.data.pointer) {
1905                         wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
1906
1907                         if(copy_to_user(wrq->u.data.pointer,
1908                                         (u_char *) iwctl_private_args,
1909                                         sizeof(iwctl_private_args)))
1910                                 rc = -EFAULT;
1911                 }
1912 */
1913                 break;
1914
1915 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1916         case SIOCSIWAUTH:
1917                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH\n");
1918                 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
1919                 break;
1920
1921         case SIOCGIWAUTH:
1922                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
1923                 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
1924                 break;
1925
1926         case SIOCSIWGENIE:
1927                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
1928                 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1929                 break;
1930
1931         case SIOCGIWGENIE:
1932                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
1933                 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1934                 break;
1935
1936         case SIOCSIWENCODEEXT:
1937                 {
1938                         char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
1939                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
1940                         if(wrq->u.encoding.pointer){
1941                                 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
1942                                 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
1943                                         rc = -E2BIG;
1944                                         break;
1945                                 }
1946                                 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
1947                                         rc = -EFAULT;
1948                                         break;
1949                                 }
1950                         }else if(wrq->u.encoding.length != 0){
1951                                 rc = -EINVAL;
1952                                 break;
1953                         }
1954                         rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
1955                 }
1956                 break;
1957
1958         case SIOCGIWENCODEEXT:
1959                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
1960                 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
1961                 break;
1962
1963         case SIOCSIWMLME:
1964                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
1965                 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1966                 break;
1967
1968 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1969
1970     case IOCTL_CMD_TEST:
1971
1972                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1973                     rc = -EFAULT;
1974                     break;
1975                 } else {
1976                     rc = 0;
1977                 }
1978         pReq = (PSCmdRequest)rq;
1979
1980    //20080130-01,<Remark> by Mike Liu
1981       // if(pDevice->bLinkPass==TRUE)
1982           pReq->wResult = MAGIC_CODE;         //Linking status:0x3142
1983    //20080130-02,<Remark> by Mike Liu
1984       //  else
1985       //         pReq->wResult = MAGIC_CODE+1;    //disconnect status:0x3143
1986         break;
1987
1988     case IOCTL_CMD_SET:
1989                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
1990                        (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
1991                 {
1992                     rc = -EFAULT;
1993                     break;
1994                 } else {
1995                     rc = 0;
1996                 }
1997
1998             if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
1999                     return -EBUSY;
2000             }
2001         rc = private_ioctl(pDevice, rq);
2002         clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
2003         break;
2004
2005     case IOCTL_CMD_HOSTAPD:
2006
2007                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2008                     rc = -EFAULT;
2009                     break;
2010                 } else {
2011                     rc = 0;
2012                 }
2013
2014                 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
2015         break;
2016
2017     case IOCTL_CMD_WPA:
2018
2019                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2020                     rc = -EFAULT;
2021                     break;
2022                 } else {
2023                     rc = 0;
2024                 }
2025
2026                 rc = wpa_ioctl(pDevice, &wrq->u.data);
2027         break;
2028
2029         case SIOCETHTOOL:
2030         return ethtool_ioctl(dev, (void *) rq->ifr_data);
2031         // All other calls are currently unsupported
2032
2033         default:
2034                 rc = -EOPNOTSUPP;
2035         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2036
2037
2038     }
2039
2040     if (pDevice->bCommit) {
2041        if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2042            netif_stop_queue(pDevice->dev);
2043            spin_lock_irq(&pDevice->lock);
2044         bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
2045            spin_unlock_irq(&pDevice->lock);
2046        }
2047        else {
2048            DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2049            spin_lock_irq(&pDevice->lock);
2050 //2007-1121-01<Modify>by EinsnLiu
2051             if (pDevice->bLinkPass &&
2052                   memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2053                 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2054              } else {
2055            pDevice->bLinkPass = FALSE;
2056            pMgmt->eCurrState = WMAC_STATE_IDLE;
2057            memset(pMgmt->abyCurrBSSID, 0, 6);
2058                  }
2059            ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2060 //End Modify
2061            netif_stop_queue(pDevice->dev);
2062 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2063            pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2064            if (!pDevice->bWPASuppWextEnabled)
2065 #endif
2066                 bScheduleCommand((void *) pDevice,
2067                                  WLAN_CMD_BSSID_SCAN,
2068                                  pMgmt->abyDesireSSID);
2069                 bScheduleCommand((void *) pDevice,
2070                                  WLAN_CMD_SSID,
2071                                  NULL);
2072            spin_unlock_irq(&pDevice->lock);
2073       }
2074       pDevice->bCommit = FALSE;
2075     }
2076
2077
2078     return rc;
2079 }
2080
2081
2082 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2083 {
2084         u32 ethcmd;
2085
2086         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
2087                 return -EFAULT;
2088
2089         switch (ethcmd) {
2090         case ETHTOOL_GDRVINFO: {
2091                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2092                 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2093                 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2094                 if (copy_to_user(useraddr, &info, sizeof(info)))
2095                         return -EFAULT;
2096                 return 0;
2097         }
2098
2099         }
2100
2101         return -EOPNOTSUPP;
2102 }
2103
2104
2105 /*------------------------------------------------------------------*/
2106
2107 MODULE_DEVICE_TABLE(usb, vt6656_table);
2108
2109 static struct usb_driver vt6656_driver = {
2110         .name =         DEVICE_NAME,
2111         .probe =        vt6656_probe,
2112         .disconnect =   vt6656_disconnect,
2113         .id_table =     vt6656_table,
2114 #ifdef CONFIG_PM
2115         .suspend = vt6656_suspend,
2116         .resume = vt6656_resume,
2117 #endif /* CONFIG_PM */
2118 };
2119
2120 static int __init vt6656_init_module(void)
2121 {
2122     printk(KERN_NOTICE DEVICE_FULL_DRV_NAM " " DEVICE_VERSION);
2123     return usb_register(&vt6656_driver);
2124 }
2125
2126 static void __exit vt6656_cleanup_module(void)
2127 {
2128         usb_deregister(&vt6656_driver);
2129 }
2130
2131 module_init(vt6656_init_module);
2132 module_exit(vt6656_cleanup_module);