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         usb_set_intfdata(intf, NULL);
1276         usb_put_dev(interface_to_usbdev(intf));
1277
1278         device->flags |= DEVICE_FLAGS_UNPLUG;
1279
1280         if (device->dev) {
1281                 unregister_netdev(device->dev);
1282                 wpa_set_wpadev(device, 0);
1283                 free_netdev(device->dev);
1284         }
1285 }
1286
1287 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1288 {
1289         PSDevice pDevice = netdev_priv(dev);
1290
1291         spin_lock_irq(&pDevice->lock);
1292
1293         if (unlikely(pDevice->bStopTx0Pkt))
1294                 dev_kfree_skb_irq(skb);
1295         else
1296                 vDMA0_tx_80211(pDevice, skb);
1297
1298         spin_unlock_irq(&pDevice->lock);
1299
1300         return NETDEV_TX_OK;
1301 }
1302
1303 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1304 {
1305         PSDevice pDevice = netdev_priv(dev);
1306         struct net_device_stats *stats = &pDevice->stats;
1307
1308         spin_lock_irq(&pDevice->lock);
1309
1310         netif_stop_queue(dev);
1311
1312         if (!pDevice->bLinkPass) {
1313                 dev_kfree_skb_irq(skb);
1314                 goto out;
1315         }
1316
1317         if (pDevice->bStopDataPkt) {
1318                 dev_kfree_skb_irq(skb);
1319                 stats->tx_dropped++;
1320                 goto out;
1321         }
1322
1323         if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1324                 if (netif_queue_stopped(dev))
1325                         netif_wake_queue(dev);
1326         }
1327
1328 out:
1329         spin_unlock_irq(&pDevice->lock);
1330
1331         return NETDEV_TX_OK;
1332 }
1333
1334 static unsigned const ethernet_polynomial = 0x04c11db7U;
1335 static inline u32 ether_crc(int length, unsigned char *data)
1336 {
1337     int crc = -1;
1338
1339     while(--length >= 0) {
1340         unsigned char current_octet = *data++;
1341         int bit;
1342         for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1343             crc = (crc << 1) ^
1344                 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1345         }
1346     }
1347     return crc;
1348 }
1349
1350 //find out  the start  position of str2 from str1
1351 static unsigned char *kstrstr(const unsigned char *str1,
1352                               const unsigned char *str2) {
1353   int str1_len = strlen(str1);
1354   int str2_len = strlen(str2);
1355
1356   while (str1_len >= str2_len) {
1357        str1_len--;
1358       if(memcmp(str1,str2,str2_len)==0)
1359         return (unsigned char *) str1;
1360         str1++;
1361   }
1362   return NULL;
1363 }
1364
1365 static int Config_FileGetParameter(unsigned char *string,
1366                                    unsigned char *dest,
1367                                    unsigned char *source)
1368 {
1369   unsigned char buf1[100];
1370   unsigned char buf2[100];
1371   unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1372   int ii;
1373
1374     memset(buf1,0,100);
1375     strcat(buf1, string);
1376     strcat(buf1, "=");
1377     source+=strlen(buf1);
1378
1379 //find target string start point
1380     start_p = kstrstr(source,buf1);
1381     if (start_p == NULL)
1382         return FALSE;
1383
1384 //check if current config line is marked by "#" ??
1385     for (ii = 1; ; ii++) {
1386         if (memcmp(start_p - ii, "\n", 1) == 0)
1387                 break;
1388         if (memcmp(start_p - ii, "#", 1) == 0)
1389                 return FALSE;
1390     }
1391
1392 //find target string end point
1393      end_p = kstrstr(start_p,"\n");
1394      if (end_p == NULL) {       //can't find "\n",but don't care
1395           end_p=start_p+strlen(start_p);   //no include "\n"
1396        }
1397
1398    memset(buf2,0,100);
1399    memcpy(buf2,start_p,end_p-start_p);    //get the tartget line
1400    buf2[end_p-start_p]='\0';
1401
1402    //find value
1403    start_p = kstrstr(buf2,"=");
1404    if (start_p == NULL)
1405       return FALSE;
1406    memset(buf1,0,100);
1407    strcpy(buf1,start_p+1);
1408
1409   //except space
1410   tmp_p = buf1;
1411   while(*tmp_p != 0x00) {
1412         if(*tmp_p==' ')
1413             tmp_p++;
1414          else
1415           break;
1416   }
1417
1418    memcpy(dest,tmp_p,strlen(tmp_p));
1419  return TRUE;
1420 }
1421
1422 //if read fail,return NULL,or return data pointer;
1423 static unsigned char *Config_FileOperation(PSDevice pDevice)
1424 {
1425     unsigned char *config_path = CONFIG_PATH;
1426     unsigned char *buffer = NULL;
1427     struct file   *filp=NULL;
1428     mm_segment_t old_fs = get_fs();
1429     //int oldfsuid=0,oldfsgid=0;
1430     int result = 0;
1431
1432     set_fs (KERNEL_DS);
1433     /* Can't do this anymore, so we rely on correct filesystem permissions:
1434     //Make sure a caller can read or write power as root
1435     oldfsuid=current->fsuid;
1436     oldfsgid=current->fsgid;
1437     current->fsuid = 0;
1438     current->fsgid = 0;
1439     */
1440
1441     //open file
1442       filp = filp_open(config_path, O_RDWR, 0);
1443         if (IS_ERR(filp)) {
1444              printk("Config_FileOperation file Not exist\n");
1445              result=-1;
1446              goto error2;
1447           }
1448
1449      if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1450            printk("file %s cann't readable or writable?\n",config_path);
1451           result = -1;
1452           goto error1;
1453         }
1454
1455     buffer = kmalloc(1024, GFP_KERNEL);
1456     if(buffer==NULL) {
1457       printk("alllocate mem for file fail?\n");
1458       result = -1;
1459       goto error1;
1460     }
1461
1462     if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1463      printk("read file error?\n");
1464      result = -1;
1465     }
1466
1467 error1:
1468   if(filp_close(filp,NULL))
1469        printk("Config_FileOperation:close file fail\n");
1470
1471 error2:
1472   set_fs (old_fs);
1473
1474   /*
1475   current->fsuid=oldfsuid;
1476   current->fsgid=oldfsgid;
1477   */
1478
1479 if(result!=0) {
1480     if(buffer)
1481          kfree(buffer);
1482     buffer=NULL;
1483 }
1484   return buffer;
1485 }
1486
1487 //return --->-1:fail;  >=0:successful
1488 static int Read_config_file(PSDevice pDevice) {
1489   int result = 0;
1490   unsigned char tmpbuffer[100];
1491   unsigned char *buffer = NULL;
1492
1493   //init config setting
1494  pDevice->config_file.ZoneType = -1;
1495  pDevice->config_file.eAuthenMode = -1;
1496  pDevice->config_file.eEncryptionStatus = -1;
1497
1498   buffer = Config_FileOperation(pDevice);
1499   if (buffer == NULL) {
1500      result =-1;
1501      return result;
1502   }
1503
1504 //get zonetype
1505 {
1506     memset(tmpbuffer,0,sizeof(tmpbuffer));
1507     if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1508     if(memcmp(tmpbuffer,"USA",3)==0) {
1509       pDevice->config_file.ZoneType=ZoneType_USA;
1510     }
1511     else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1512       pDevice->config_file.ZoneType=ZoneType_Japan;
1513     }
1514     else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1515      pDevice->config_file.ZoneType=ZoneType_Europe;
1516     }
1517     else {
1518       printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1519    }
1520  }
1521 }
1522
1523 //get other parameter
1524   {
1525         memset(tmpbuffer,0,sizeof(tmpbuffer));
1526        if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1527          pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1528        }
1529
1530         memset(tmpbuffer,0,sizeof(tmpbuffer));
1531        if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1532          pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1533        }
1534   }
1535
1536   kfree(buffer);
1537   return result;
1538 }
1539
1540 static void device_set_multi(struct net_device *dev) {
1541     PSDevice         pDevice = (PSDevice) netdev_priv(dev);
1542     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1543     u32              mc_filter[2];
1544     int              ii;
1545     struct netdev_hw_addr *ha;
1546     BYTE             pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1547     BYTE             byTmpMode = 0;
1548     int              rc;
1549
1550
1551         spin_lock_irq(&pDevice->lock);
1552     rc = CONTROLnsRequestIn(pDevice,
1553                             MESSAGE_TYPE_READ,
1554                             MAC_REG_RCR,
1555                             MESSAGE_REQUEST_MACREG,
1556                             1,
1557                             &byTmpMode
1558                             );
1559     if (rc == 0) pDevice->byRxMode = byTmpMode;
1560
1561     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1562
1563     if (dev->flags & IFF_PROMISC) {         // Set promiscuous.
1564         DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1565         // Unconditionally log net taps.
1566         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1567     }
1568     else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1569              (dev->flags & IFF_ALLMULTI)) {
1570         CONTROLnsRequestOut(pDevice,
1571                             MESSAGE_TYPE_WRITE,
1572                             MAC_REG_MAR0,
1573                             MESSAGE_REQUEST_MACREG,
1574                             8,
1575                             pbyData
1576                             );
1577         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1578     }
1579     else {
1580         memset(mc_filter, 0, sizeof(mc_filter));
1581         netdev_for_each_mc_addr(ha, dev) {
1582             int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1583             mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1584         }
1585         for (ii = 0; ii < 4; ii++) {
1586              MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1587              MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1588         }
1589         pDevice->byRxMode &= ~(RCR_UNICAST);
1590         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1591     }
1592
1593     if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1594         // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1595         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1596         pDevice->byRxMode &= ~(RCR_UNICAST);
1597     }
1598     ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1599     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1600         spin_unlock_irq(&pDevice->lock);
1601
1602 }
1603
1604
1605 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1606     PSDevice pDevice=(PSDevice) netdev_priv(dev);
1607
1608     return &pDevice->stats;
1609 }
1610
1611
1612 static int  device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1613         PSDevice                pDevice = (PSDevice)netdev_priv(dev);
1614     PSMgmtObject        pMgmt = &(pDevice->sMgmtObj);
1615     PSCmdRequest        pReq;
1616     //BOOL                bCommit = FALSE;
1617         struct iwreq *wrq = (struct iwreq *) rq;
1618         int                 rc =0;
1619
1620     if (pMgmt == NULL) {
1621         rc = -EFAULT;
1622         return rc;
1623     }
1624
1625     switch(cmd) {
1626
1627         case SIOCGIWNAME:
1628                 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1629                 break;
1630
1631         case SIOCSIWNWID:
1632         rc = -EOPNOTSUPP;
1633                 break;
1634
1635         case SIOCGIWNWID:     //0x8b03  support
1636         #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1637           rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
1638         #else
1639         rc = -EOPNOTSUPP;
1640         #endif
1641                 break;
1642
1643                 // Set frequency/channel
1644         case SIOCSIWFREQ:
1645             rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1646                 break;
1647
1648                 // Get frequency/channel
1649         case SIOCGIWFREQ:
1650                 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1651                 break;
1652
1653                 // Set desired network name (ESSID)
1654         case SIOCSIWESSID:
1655
1656                 {
1657                         char essid[IW_ESSID_MAX_SIZE+1];
1658                         if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1659                                 rc = -E2BIG;
1660                                 break;
1661                         }
1662                         if (copy_from_user(essid, wrq->u.essid.pointer,
1663                                            wrq->u.essid.length)) {
1664                                 rc = -EFAULT;
1665                                 break;
1666                         }
1667                         rc = iwctl_siwessid(dev, NULL,
1668                                             &(wrq->u.essid), essid);
1669                 }
1670                 break;
1671
1672
1673                 // Get current network name (ESSID)
1674         case SIOCGIWESSID:
1675
1676                 {
1677                         char essid[IW_ESSID_MAX_SIZE+1];
1678                         if (wrq->u.essid.pointer) {
1679                                 rc = iwctl_giwessid(dev, NULL,
1680                                                     &(wrq->u.essid), essid);
1681                                 if (copy_to_user(wrq->u.essid.pointer,
1682                                                          essid,
1683                                                          wrq->u.essid.length) )
1684                                         rc = -EFAULT;
1685                         }
1686                 }
1687                 break;
1688
1689         case SIOCSIWAP:
1690
1691                 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1692                 break;
1693
1694
1695                 // Get current Access Point (BSSID)
1696         case SIOCGIWAP:
1697                 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1698                 break;
1699
1700
1701                 // Set desired station name
1702         case SIOCSIWNICKN:
1703         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1704         rc = -EOPNOTSUPP;
1705                 break;
1706
1707                 // Get current station name
1708         case SIOCGIWNICKN:
1709         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1710         rc = -EOPNOTSUPP;
1711                 break;
1712
1713                 // Set the desired bit-rate
1714         case SIOCSIWRATE:
1715                 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1716                 break;
1717
1718         // Get the current bit-rate
1719         case SIOCGIWRATE:
1720
1721                 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1722                 break;
1723
1724         // Set the desired RTS threshold
1725         case SIOCSIWRTS:
1726
1727                 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
1728                 break;
1729
1730         // Get the current RTS threshold
1731         case SIOCGIWRTS:
1732
1733                 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1734                 break;
1735
1736                 // Set the desired fragmentation threshold
1737         case SIOCSIWFRAG:
1738
1739                 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1740             break;
1741
1742         // Get the current fragmentation threshold
1743         case SIOCGIWFRAG:
1744
1745                 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1746                 break;
1747
1748                 // Set mode of operation
1749         case SIOCSIWMODE:
1750         rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1751                 break;
1752
1753                 // Get mode of operation
1754         case SIOCGIWMODE:
1755                 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1756                 break;
1757
1758                 // Set WEP keys and mode
1759         case SIOCSIWENCODE:
1760                 {
1761             char abyKey[WLAN_WEP232_KEYLEN];
1762
1763                         if (wrq->u.encoding.pointer) {
1764
1765
1766                                 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
1767                                         rc = -E2BIG;
1768                                         break;
1769                                 }
1770                                 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
1771                                 if (copy_from_user(abyKey,
1772                                                   wrq->u.encoding.pointer,
1773                                                   wrq->u.encoding.length)) {
1774                                         rc = -EFAULT;
1775                                         break;
1776                                 }
1777                         } else if (wrq->u.encoding.length != 0) {
1778                                 rc = -EINVAL;
1779                                 break;
1780                         }
1781                         rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1782                 }
1783                 break;
1784
1785                 // Get the WEP keys and mode
1786         case SIOCGIWENCODE:
1787
1788                 if (!capable(CAP_NET_ADMIN)) {
1789                         rc = -EPERM;
1790                         break;
1791                 }
1792                 {
1793                     char abyKey[WLAN_WEP232_KEYLEN];
1794
1795                     rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1796                     if (rc != 0) break;
1797                         if (wrq->u.encoding.pointer) {
1798                                 if (copy_to_user(wrq->u.encoding.pointer,
1799                                                         abyKey,
1800                                                         wrq->u.encoding.length))
1801                                         rc = -EFAULT;
1802                         }
1803                 }
1804                 break;
1805
1806                 // Get the current Tx-Power
1807         case SIOCGIWTXPOW:
1808         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1809         rc = -EOPNOTSUPP;
1810                 break;
1811
1812         case SIOCSIWTXPOW:
1813         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1814         rc = -EOPNOTSUPP;
1815                 break;
1816
1817         case SIOCSIWRETRY:
1818
1819                 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
1820                 break;
1821
1822         case SIOCGIWRETRY:
1823
1824                 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
1825                 break;
1826
1827                 // Get range of parameters
1828         case SIOCGIWRANGE:
1829
1830                 {
1831                         struct iw_range range;
1832
1833                         rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
1834                         if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
1835                                 rc = -EFAULT;
1836                 }
1837
1838                 break;
1839
1840         case SIOCGIWPOWER:
1841
1842                 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
1843                 break;
1844
1845
1846         case SIOCSIWPOWER:
1847
1848                 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
1849                 break;
1850
1851
1852         case SIOCGIWSENS:
1853
1854             rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
1855                 break;
1856
1857         case SIOCSIWSENS:
1858         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
1859                 rc = -EOPNOTSUPP;
1860                 break;
1861
1862         case SIOCGIWAPLIST:
1863             {
1864             char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
1865
1866                     if (wrq->u.data.pointer) {
1867                         rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
1868                         if (rc == 0) {
1869                     if (copy_to_user(wrq->u.data.pointer,
1870                                                         buffer,
1871                                                        (wrq->u.data.length * (sizeof(struct sockaddr) +  sizeof(struct iw_quality)))
1872                                         ))
1873                                     rc = -EFAULT;
1874                         }
1875             }
1876         }
1877                 break;
1878
1879
1880 #ifdef WIRELESS_SPY
1881                 // Set the spy list
1882         case SIOCSIWSPY:
1883
1884         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1885                 rc = -EOPNOTSUPP;
1886                 break;
1887
1888                 // Get the spy list
1889         case SIOCGIWSPY:
1890
1891         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1892                 rc = -EOPNOTSUPP;
1893                 break;
1894
1895 #endif // WIRELESS_SPY
1896
1897         case SIOCGIWPRIV:
1898         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
1899                 rc = -EOPNOTSUPP;
1900 /*
1901                 if(wrq->u.data.pointer) {
1902                         wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
1903
1904                         if(copy_to_user(wrq->u.data.pointer,
1905                                         (u_char *) iwctl_private_args,
1906                                         sizeof(iwctl_private_args)))
1907                                 rc = -EFAULT;
1908                 }
1909 */
1910                 break;
1911
1912 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1913         case SIOCSIWAUTH:
1914                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH\n");
1915                 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
1916                 break;
1917
1918         case SIOCGIWAUTH:
1919                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
1920                 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
1921                 break;
1922
1923         case SIOCSIWGENIE:
1924                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
1925                 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1926                 break;
1927
1928         case SIOCGIWGENIE:
1929                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
1930                 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1931                 break;
1932
1933         case SIOCSIWENCODEEXT:
1934                 {
1935                         char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
1936                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
1937                         if(wrq->u.encoding.pointer){
1938                                 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
1939                                 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
1940                                         rc = -E2BIG;
1941                                         break;
1942                                 }
1943                                 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
1944                                         rc = -EFAULT;
1945                                         break;
1946                                 }
1947                         }else if(wrq->u.encoding.length != 0){
1948                                 rc = -EINVAL;
1949                                 break;
1950                         }
1951                         rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
1952                 }
1953                 break;
1954
1955         case SIOCGIWENCODEEXT:
1956                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
1957                 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
1958                 break;
1959
1960         case SIOCSIWMLME:
1961                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
1962                 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1963                 break;
1964
1965 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1966
1967     case IOCTL_CMD_TEST:
1968
1969                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1970                     rc = -EFAULT;
1971                     break;
1972                 } else {
1973                     rc = 0;
1974                 }
1975         pReq = (PSCmdRequest)rq;
1976
1977    //20080130-01,<Remark> by Mike Liu
1978       // if(pDevice->bLinkPass==TRUE)
1979           pReq->wResult = MAGIC_CODE;         //Linking status:0x3142
1980    //20080130-02,<Remark> by Mike Liu
1981       //  else
1982       //         pReq->wResult = MAGIC_CODE+1;    //disconnect status:0x3143
1983         break;
1984
1985     case IOCTL_CMD_SET:
1986                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
1987                        (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
1988                 {
1989                     rc = -EFAULT;
1990                     break;
1991                 } else {
1992                     rc = 0;
1993                 }
1994
1995             if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
1996                     return -EBUSY;
1997             }
1998         rc = private_ioctl(pDevice, rq);
1999         clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
2000         break;
2001
2002     case IOCTL_CMD_HOSTAPD:
2003
2004                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2005                     rc = -EFAULT;
2006                     break;
2007                 } else {
2008                     rc = 0;
2009                 }
2010
2011                 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
2012         break;
2013
2014     case IOCTL_CMD_WPA:
2015
2016                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2017                     rc = -EFAULT;
2018                     break;
2019                 } else {
2020                     rc = 0;
2021                 }
2022
2023                 rc = wpa_ioctl(pDevice, &wrq->u.data);
2024         break;
2025
2026         case SIOCETHTOOL:
2027         return ethtool_ioctl(dev, (void *) rq->ifr_data);
2028         // All other calls are currently unsupported
2029
2030         default:
2031                 rc = -EOPNOTSUPP;
2032         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2033
2034
2035     }
2036
2037     if (pDevice->bCommit) {
2038        if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2039            netif_stop_queue(pDevice->dev);
2040            spin_lock_irq(&pDevice->lock);
2041         bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
2042            spin_unlock_irq(&pDevice->lock);
2043        }
2044        else {
2045            DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2046            spin_lock_irq(&pDevice->lock);
2047 //2007-1121-01<Modify>by EinsnLiu
2048             if (pDevice->bLinkPass &&
2049                   memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2050                 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2051              } else {
2052            pDevice->bLinkPass = FALSE;
2053            pMgmt->eCurrState = WMAC_STATE_IDLE;
2054            memset(pMgmt->abyCurrBSSID, 0, 6);
2055                  }
2056            ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2057 //End Modify
2058            netif_stop_queue(pDevice->dev);
2059 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2060            pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2061            if (!pDevice->bWPASuppWextEnabled)
2062 #endif
2063                 bScheduleCommand((void *) pDevice,
2064                                  WLAN_CMD_BSSID_SCAN,
2065                                  pMgmt->abyDesireSSID);
2066                 bScheduleCommand((void *) pDevice,
2067                                  WLAN_CMD_SSID,
2068                                  NULL);
2069            spin_unlock_irq(&pDevice->lock);
2070       }
2071       pDevice->bCommit = FALSE;
2072     }
2073
2074
2075     return rc;
2076 }
2077
2078
2079 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2080 {
2081         u32 ethcmd;
2082
2083         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
2084                 return -EFAULT;
2085
2086         switch (ethcmd) {
2087         case ETHTOOL_GDRVINFO: {
2088                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2089                 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2090                 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2091                 if (copy_to_user(useraddr, &info, sizeof(info)))
2092                         return -EFAULT;
2093                 return 0;
2094         }
2095
2096         }
2097
2098         return -EOPNOTSUPP;
2099 }
2100
2101
2102 /*------------------------------------------------------------------*/
2103
2104 MODULE_DEVICE_TABLE(usb, vt6656_table);
2105
2106 static struct usb_driver vt6656_driver = {
2107         .name =         DEVICE_NAME,
2108         .probe =        vt6656_probe,
2109         .disconnect =   vt6656_disconnect,
2110         .id_table =     vt6656_table,
2111 #ifdef CONFIG_PM
2112         .suspend = vt6656_suspend,
2113         .resume = vt6656_resume,
2114 #endif /* CONFIG_PM */
2115 };
2116
2117 static int __init vt6656_init_module(void)
2118 {
2119     printk(KERN_NOTICE DEVICE_FULL_DRV_NAM " " DEVICE_VERSION);
2120     return usb_register(&vt6656_driver);
2121 }
2122
2123 static void __exit vt6656_cleanup_module(void)
2124 {
2125         usb_deregister(&vt6656_driver);
2126 }
2127
2128 module_init(vt6656_init_module);
2129 module_exit(vt6656_cleanup_module);