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         kfree(pTxContext);
 841     }
 842     return;
 843 }
 844
 845
 846 static void device_free_rx_bufs(PSDevice pDevice)
 847 {
 848     PRCB pRCB;
 849     int ii;
 850
 851     for (ii = 0; ii < pDevice->cbRD; ii++) {
 852
 853         pRCB = pDevice->apRCB[ii];
 854         //de-allocate URBs
 855         if (pRCB->pUrb) {
 856             usb_kill_urb(pRCB->pUrb);
 857             usb_free_urb(pRCB->pUrb);
 858         }
 859         //de-allocate skb
 860         if (pRCB->skb)
 861             dev_kfree_skb(pRCB->skb);
 862     }
 863     kfree(pDevice->pRCBMem);
 864
 865     return;
 866 }
 867
 868 static void usb_device_reset(PSDevice pDevice)
 869 {
 870  int status;
 871  status = usb_reset_device(pDevice->usb);
 872         if (status)
 873             printk("usb_device_reset fail status=%d\n",status);
 874         return ;
 875 }
 876
 877 static void device_free_int_bufs(PSDevice pDevice)
 878 {
 879     kfree(pDevice->intBuf.pDataBuf);
 880     return;
 881 }
 882
 883
 884 static BOOL device_alloc_bufs(PSDevice pDevice) {
 885
 886     PUSB_SEND_CONTEXT pTxContext;
 887     PRCB pRCB;
 888     int ii;
 889
 890
 891     for (ii = 0; ii < pDevice->cbTD; ii++) {
 892
 893         pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
 894         if (pTxContext == NULL) {
 895             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
 896             goto free_tx;
 897         }
 898         pDevice->apTD[ii] = pTxContext;
 899         pTxContext->pDevice = (void *) pDevice;
 900         //allocate URBs
 901         pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
 902         if (pTxContext->pUrb == NULL) {
 903             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
 904             goto free_tx;
 905         }
 906         pTxContext->bBoolInUse = FALSE;
 907     }
 908
 909     // allocate rcb mem
 910     pDevice->pRCBMem = kmalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
 911     if (pDevice->pRCBMem == NULL) {
 912         DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
 913         goto free_tx;
 914     }
 915
 916
 917     pDevice->FirstRecvFreeList = NULL;
 918     pDevice->LastRecvFreeList = NULL;
 919     pDevice->FirstRecvMngList = NULL;
 920     pDevice->LastRecvMngList = NULL;
 921     pDevice->NumRecvFreeList = 0;
 922     memset(pDevice->pRCBMem, 0, (sizeof(RCB) * pDevice->cbRD));
 923     pRCB = (PRCB) pDevice->pRCBMem;
 924
 925     for (ii = 0; ii < pDevice->cbRD; ii++) {
 926
 927         pDevice->apRCB[ii] = pRCB;
 928         pRCB->pDevice = (void *) pDevice;
 929         //allocate URBs
 930         pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
 931
 932         if (pRCB->pUrb == NULL) {
 933             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
 934             goto free_rx_tx;
 935         }
 936         pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
 937         if (pRCB->skb == NULL) {
 938             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
 939             goto free_rx_tx;
 940         }
 941         pRCB->skb->dev = pDevice->dev;
 942         pRCB->bBoolInUse = FALSE;
 943         EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
 944         pDevice->NumRecvFreeList++;
 945         pRCB++;
 946     }
 947
 948
 949         pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
 950         if (pDevice->pControlURB == NULL) {
 951             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
 952             goto free_rx_tx;
 953         }
 954
 955         pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
 956         if (pDevice->pInterruptURB == NULL) {
 957             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
 958             usb_kill_urb(pDevice->pControlURB);
 959             usb_free_urb(pDevice->pControlURB);
 960             goto free_rx_tx;
 961         }
 962
 963     pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
 964         if (pDevice->intBuf.pDataBuf == NULL) {
 965             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
 966             usb_kill_urb(pDevice->pControlURB);
 967             usb_kill_urb(pDevice->pInterruptURB);
 968             usb_free_urb(pDevice->pControlURB);
 969             usb_free_urb(pDevice->pInterruptURB);
 970             goto free_rx_tx;
 971         }
 972
 973     return TRUE;
 974
 975 free_rx_tx:
 976     device_free_rx_bufs(pDevice);
 977
 978 free_tx:
 979     device_free_tx_bufs(pDevice);
 980
 981         return FALSE;
 982 }
 983
 984
 985
 986
 987 static BOOL device_init_defrag_cb(PSDevice pDevice) {
 988     int i;
 989     PSDeFragControlBlock pDeF;
 990
 991     /* Init the fragment ctl entries */
 992     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
 993         pDeF = &(pDevice->sRxDFCB[i]);
 994         if (!device_alloc_frag_buf(pDevice, pDeF)) {
 995             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
 996                 pDevice->dev->name);
 997             goto free_frag;
 998         };
 999     }
1000     pDevice->cbDFCB = CB_MAX_RX_FRAG;
1001     pDevice->cbFreeDFCB = pDevice->cbDFCB;
1002     return TRUE;
1003
1004 free_frag:
1005     device_free_frag_bufs(pDevice);
1006     return FALSE;
1007 }
1008
1009
1010
1011 static void device_free_frag_bufs(PSDevice pDevice) {
1012     PSDeFragControlBlock pDeF;
1013     int i;
1014
1015     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1016
1017         pDeF = &(pDevice->sRxDFCB[i]);
1018
1019         if (pDeF->skb)
1020             dev_kfree_skb(pDeF->skb);
1021     }
1022 }
1023
1024
1025
1026 BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1027
1028     pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1029     if (pDeF->skb == NULL)
1030         return FALSE;
1031     ASSERT(pDeF->skb);
1032     pDeF->skb->dev = pDevice->dev;
1033
1034     return TRUE;
1035 }
1036
1037
1038 /*-----------------------------------------------------------------*/
1039
1040 static int  device_open(struct net_device *dev) {
1041     PSDevice    pDevice=(PSDevice) netdev_priv(dev);
1042
1043      extern SWPAResult wpa_Result;
1044      memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1045      wpa_Result.proto = 0;
1046      wpa_Result.key_mgmt = 0;
1047      wpa_Result.eap_type = 0;
1048      wpa_Result.authenticated = FALSE;
1049      pDevice->fWPA_Authened = FALSE;
1050
1051     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
1052
1053
1054     pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
1055
1056     if (device_alloc_bufs(pDevice) == FALSE) {
1057         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
1058         return -ENOMEM;
1059     }
1060
1061     if (device_init_defrag_cb(pDevice)== FALSE) {
1062         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragement cb fail \n");
1063         goto free_rx_tx;
1064     }
1065
1066     MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
1067     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
1068     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
1069     MP_SET_FLAG(pDevice, fMP_POST_READS);
1070     MP_SET_FLAG(pDevice, fMP_POST_WRITES);
1071
1072    //read config file
1073     Read_config_file(pDevice);
1074
1075     if (device_init_registers(pDevice, DEVICE_INIT_COLD) == FALSE) {
1076         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
1077         goto free_all;
1078     }
1079
1080     device_set_multi(pDevice->dev);
1081     // Init for Key Management
1082
1083     KeyvInitTable(pDevice,&pDevice->sKey);
1084     memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1085     memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1086     pDevice->bStopTx0Pkt = FALSE;
1087     pDevice->bStopDataPkt = FALSE;
1088     pDevice->bRoaming = FALSE;
1089     pDevice->bIsRoaming = FALSE;
1090     pDevice->bEnableRoaming = FALSE;
1091     if (pDevice->bDiversityRegCtlON) {
1092         device_init_diversity_timer(pDevice);
1093     }
1094
1095     vMgrObjectInit(pDevice);
1096     tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
1097     tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
1098     tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
1099     add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback));
1100     pDevice->int_interval = 100;  //Max 100 microframes.
1101     pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1102
1103     pDevice->bIsRxWorkItemQueued = TRUE;
1104     pDevice->fKillEventPollingThread = FALSE;
1105     pDevice->bEventAvailable = FALSE;
1106
1107    pDevice->bWPADEVUp = FALSE;
1108 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1109      pDevice->bwextstep0 = FALSE;
1110      pDevice->bwextstep1 = FALSE;
1111      pDevice->bwextstep2 = FALSE;
1112      pDevice->bwextstep3 = FALSE;
1113      pDevice->bWPASuppWextEnabled = FALSE;
1114 #endif
1115     pDevice->byReAssocCount = 0;
1116
1117     RXvWorkItem(pDevice);
1118     INTvWorkItem(pDevice);
1119
1120     // Patch: if WEP key already set by iwconfig but device not yet open
1121     if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1122          spin_lock_irq(&pDevice->lock);
1123          KeybSetDefaultKey( pDevice,
1124                             &(pDevice->sKey),
1125                             pDevice->byKeyIndex | (1 << 31),
1126                             pDevice->uKeyLength,
1127                             NULL,
1128                             pDevice->abyKey,
1129                             KEY_CTL_WEP
1130                           );
1131          spin_unlock_irq(&pDevice->lock);
1132          pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1133     }
1134
1135     if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1136                 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1137         }
1138         else {
1139         //mike:mark@2008-11-10
1140           bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1141           /* bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL); */
1142     }
1143
1144
1145     netif_stop_queue(pDevice->dev);
1146     pDevice->flags |= DEVICE_FLAGS_OPENED;
1147
1148 {
1149   union iwreq_data      wrqu;
1150   memset(&wrqu, 0, sizeof(wrqu));
1151   wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1152   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1153 }
1154
1155     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1156     return 0;
1157
1158 free_all:
1159     device_free_frag_bufs(pDevice);
1160 free_rx_tx:
1161     device_free_rx_bufs(pDevice);
1162     device_free_tx_bufs(pDevice);
1163     device_free_int_bufs(pDevice);
1164         usb_kill_urb(pDevice->pControlURB);
1165         usb_kill_urb(pDevice->pInterruptURB);
1166     usb_free_urb(pDevice->pControlURB);
1167     usb_free_urb(pDevice->pInterruptURB);
1168
1169     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1170     return -ENOMEM;
1171 }
1172
1173
1174
1175 static int  device_close(struct net_device *dev) {
1176     PSDevice    pDevice=(PSDevice) netdev_priv(dev);
1177     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1178
1179         int uu;
1180
1181     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1182     if (pDevice == NULL)
1183         return -ENODEV;
1184
1185 {
1186   union iwreq_data      wrqu;
1187   memset(&wrqu, 0, sizeof(wrqu));
1188   wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1189   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1190 }
1191
1192     if (pDevice->bLinkPass) {
1193         bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1194         mdelay(30);
1195     }
1196
1197 device_release_WPADEV(pDevice);
1198
1199         memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1200         pMgmt->bShareKeyAlgorithm = FALSE;
1201         pDevice->bEncryptionEnable = FALSE;
1202         pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1203         spin_lock_irq(&pDevice->lock);
1204         for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1205                 MACvDisableKeyEntry(pDevice,uu);
1206         spin_unlock_irq(&pDevice->lock);
1207
1208     if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1209         MACbShutdown(pDevice);
1210     }
1211     netif_stop_queue(pDevice->dev);
1212     MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1213     MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1214     MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1215     pDevice->fKillEventPollingThread = TRUE;
1216     del_timer(&pDevice->sTimerCommand);
1217     del_timer(&pMgmt->sTimerSecondCallback);
1218
1219     del_timer(&pDevice->sTimerTxData);
1220
1221     if (pDevice->bDiversityRegCtlON) {
1222         del_timer(&pDevice->TimerSQ3Tmax1);
1223         del_timer(&pDevice->TimerSQ3Tmax2);
1224         del_timer(&pDevice->TimerSQ3Tmax3);
1225     }
1226     tasklet_kill(&pDevice->RxMngWorkItem);
1227     tasklet_kill(&pDevice->ReadWorkItem);
1228     tasklet_kill(&pDevice->EventWorkItem);
1229
1230    pDevice->bRoaming = FALSE;
1231    pDevice->bIsRoaming = FALSE;
1232    pDevice->bEnableRoaming = FALSE;
1233     pDevice->bCmdRunning = FALSE;
1234     pDevice->bLinkPass = FALSE;
1235     memset(pMgmt->abyCurrBSSID, 0, 6);
1236     pMgmt->eCurrState = WMAC_STATE_IDLE;
1237
1238     device_free_tx_bufs(pDevice);
1239     device_free_rx_bufs(pDevice);
1240     device_free_int_bufs(pDevice);
1241     device_free_frag_bufs(pDevice);
1242
1243         usb_kill_urb(pDevice->pControlURB);
1244         usb_kill_urb(pDevice->pInterruptURB);
1245     usb_free_urb(pDevice->pControlURB);
1246     usb_free_urb(pDevice->pInterruptURB);
1247
1248     BSSvClearNodeDBTable(pDevice, 0);
1249     pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1250
1251     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1252
1253     return 0;
1254 }
1255
1256 static void __devexit vt6656_disconnect(struct usb_interface *intf)
1257 {
1258         PSDevice device = usb_get_intfdata(intf);
1259
1260         if (!device)
1261                 return;
1262
1263         {
1264                 union iwreq_data req;
1265                 memset(&req, 0, sizeof(req));
1266                 req.data.flags = RT_RMMOD_EVENT_FLAG;
1267                 wireless_send_event(device->dev, IWEVCUSTOM, &req, NULL);
1268         }
1269
1270         device_release_WPADEV(device);
1271
1272         if (device->firmware)
1273                 release_firmware(device->firmware);
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("allocate 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     kfree(buffer);
1481     buffer=NULL;
1482 }
1483   return buffer;
1484 }
1485
1486 //return --->-1:fail;  >=0:successful
1487 static int Read_config_file(PSDevice pDevice) {
1488   int result = 0;
1489   unsigned char tmpbuffer[100];
1490   unsigned char *buffer = NULL;
1491
1492   //init config setting
1493  pDevice->config_file.ZoneType = -1;
1494  pDevice->config_file.eAuthenMode = -1;
1495  pDevice->config_file.eEncryptionStatus = -1;
1496
1497   buffer = Config_FileOperation(pDevice);
1498   if (buffer == NULL) {
1499      result =-1;
1500      return result;
1501   }
1502
1503 //get zonetype
1504 {
1505     memset(tmpbuffer,0,sizeof(tmpbuffer));
1506     if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1507     if(memcmp(tmpbuffer,"USA",3)==0) {
1508       pDevice->config_file.ZoneType=ZoneType_USA;
1509     }
1510     else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1511       pDevice->config_file.ZoneType=ZoneType_Japan;
1512     }
1513     else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1514      pDevice->config_file.ZoneType=ZoneType_Europe;
1515     }
1516     else {
1517       printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1518    }
1519  }
1520 }
1521
1522 //get other parameter
1523   {
1524         memset(tmpbuffer,0,sizeof(tmpbuffer));
1525        if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1526          pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1527        }
1528
1529         memset(tmpbuffer,0,sizeof(tmpbuffer));
1530        if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1531          pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1532        }
1533   }
1534
1535   kfree(buffer);
1536   return result;
1537 }
1538
1539 static void device_set_multi(struct net_device *dev) {
1540     PSDevice         pDevice = (PSDevice) netdev_priv(dev);
1541     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1542     u32              mc_filter[2];
1543     int              ii;
1544     struct netdev_hw_addr *ha;
1545     BYTE             pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1546     BYTE             byTmpMode = 0;
1547     int              rc;
1548
1549
1550         spin_lock_irq(&pDevice->lock);
1551     rc = CONTROLnsRequestIn(pDevice,
1552                             MESSAGE_TYPE_READ,
1553                             MAC_REG_RCR,
1554                             MESSAGE_REQUEST_MACREG,
1555                             1,
1556                             &byTmpMode
1557                             );
1558     if (rc == 0) pDevice->byRxMode = byTmpMode;
1559
1560     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1561
1562     if (dev->flags & IFF_PROMISC) {         // Set promiscuous.
1563         DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1564         // Unconditionally log net taps.
1565         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1566     }
1567     else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1568              (dev->flags & IFF_ALLMULTI)) {
1569         CONTROLnsRequestOut(pDevice,
1570                             MESSAGE_TYPE_WRITE,
1571                             MAC_REG_MAR0,
1572                             MESSAGE_REQUEST_MACREG,
1573                             8,
1574                             pbyData
1575                             );
1576         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1577     }
1578     else {
1579         memset(mc_filter, 0, sizeof(mc_filter));
1580         netdev_for_each_mc_addr(ha, dev) {
1581             int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1582             mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1583         }
1584         for (ii = 0; ii < 4; ii++) {
1585              MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1586              MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1587         }
1588         pDevice->byRxMode &= ~(RCR_UNICAST);
1589         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1590     }
1591
1592     if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1593         // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1594         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1595         pDevice->byRxMode &= ~(RCR_UNICAST);
1596     }
1597     ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1598     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1599         spin_unlock_irq(&pDevice->lock);
1600
1601 }
1602
1603
1604 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1605     PSDevice pDevice=(PSDevice) netdev_priv(dev);
1606
1607     return &pDevice->stats;
1608 }
1609
1610
1611 static int  device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1612         PSDevice                pDevice = (PSDevice)netdev_priv(dev);
1613     PSMgmtObject        pMgmt = &(pDevice->sMgmtObj);
1614     PSCmdRequest        pReq;
1615     //BOOL                bCommit = FALSE;
1616         struct iwreq *wrq = (struct iwreq *) rq;
1617         int                 rc =0;
1618
1619     if (pMgmt == NULL) {
1620         rc = -EFAULT;
1621         return rc;
1622     }
1623
1624     switch(cmd) {
1625
1626         case SIOCGIWNAME:
1627                 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1628                 break;
1629
1630         case SIOCSIWNWID:
1631         rc = -EOPNOTSUPP;
1632                 break;
1633
1634         case SIOCGIWNWID:     //0x8b03  support
1635         #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1636           rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
1637         #else
1638         rc = -EOPNOTSUPP;
1639         #endif
1640                 break;
1641
1642                 // Set frequency/channel
1643         case SIOCSIWFREQ:
1644             rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1645                 break;
1646
1647                 // Get frequency/channel
1648         case SIOCGIWFREQ:
1649                 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1650                 break;
1651
1652                 // Set desired network name (ESSID)
1653         case SIOCSIWESSID:
1654
1655                 {
1656                         char essid[IW_ESSID_MAX_SIZE+1];
1657                         if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1658                                 rc = -E2BIG;
1659                                 break;
1660                         }
1661                         if (copy_from_user(essid, wrq->u.essid.pointer,
1662                                            wrq->u.essid.length)) {
1663                                 rc = -EFAULT;
1664                                 break;
1665                         }
1666                         rc = iwctl_siwessid(dev, NULL,
1667                                             &(wrq->u.essid), essid);
1668                 }
1669                 break;
1670
1671
1672                 // Get current network name (ESSID)
1673         case SIOCGIWESSID:
1674
1675                 {
1676                         char essid[IW_ESSID_MAX_SIZE+1];
1677                         if (wrq->u.essid.pointer) {
1678                                 rc = iwctl_giwessid(dev, NULL,
1679                                                     &(wrq->u.essid), essid);
1680                                 if (copy_to_user(wrq->u.essid.pointer,
1681                                                          essid,
1682                                                          wrq->u.essid.length) )
1683                                         rc = -EFAULT;
1684                         }
1685                 }
1686                 break;
1687
1688         case SIOCSIWAP:
1689
1690                 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1691                 break;
1692
1693
1694                 // Get current Access Point (BSSID)
1695         case SIOCGIWAP:
1696                 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1697                 break;
1698
1699
1700                 // Set desired station name
1701         case SIOCSIWNICKN:
1702         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1703         rc = -EOPNOTSUPP;
1704                 break;
1705
1706                 // Get current station name
1707         case SIOCGIWNICKN:
1708         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1709         rc = -EOPNOTSUPP;
1710                 break;
1711
1712                 // Set the desired bit-rate
1713         case SIOCSIWRATE:
1714                 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1715                 break;
1716
1717         // Get the current bit-rate
1718         case SIOCGIWRATE:
1719
1720                 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1721                 break;
1722
1723         // Set the desired RTS threshold
1724         case SIOCSIWRTS:
1725
1726                 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
1727                 break;
1728
1729         // Get the current RTS threshold
1730         case SIOCGIWRTS:
1731
1732                 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1733                 break;
1734
1735                 // Set the desired fragmentation threshold
1736         case SIOCSIWFRAG:
1737
1738                 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1739             break;
1740
1741         // Get the current fragmentation threshold
1742         case SIOCGIWFRAG:
1743
1744                 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1745                 break;
1746
1747                 // Set mode of operation
1748         case SIOCSIWMODE:
1749         rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1750                 break;
1751
1752                 // Get mode of operation
1753         case SIOCGIWMODE:
1754                 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1755                 break;
1756
1757                 // Set WEP keys and mode
1758         case SIOCSIWENCODE:
1759                 {
1760             char abyKey[WLAN_WEP232_KEYLEN];
1761
1762                         if (wrq->u.encoding.pointer) {
1763
1764
1765                                 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
1766                                         rc = -E2BIG;
1767                                         break;
1768                                 }
1769                                 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
1770                                 if (copy_from_user(abyKey,
1771                                                   wrq->u.encoding.pointer,
1772                                                   wrq->u.encoding.length)) {
1773                                         rc = -EFAULT;
1774                                         break;
1775                                 }
1776                         } else if (wrq->u.encoding.length != 0) {
1777                                 rc = -EINVAL;
1778                                 break;
1779                         }
1780                         rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1781                 }
1782                 break;
1783
1784                 // Get the WEP keys and mode
1785         case SIOCGIWENCODE:
1786
1787                 if (!capable(CAP_NET_ADMIN)) {
1788                         rc = -EPERM;
1789                         break;
1790                 }
1791                 {
1792                     char abyKey[WLAN_WEP232_KEYLEN];
1793
1794                     rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1795                     if (rc != 0) break;
1796                         if (wrq->u.encoding.pointer) {
1797                                 if (copy_to_user(wrq->u.encoding.pointer,
1798                                                         abyKey,
1799                                                         wrq->u.encoding.length))
1800                                         rc = -EFAULT;
1801                         }
1802                 }
1803                 break;
1804
1805                 // Get the current Tx-Power
1806         case SIOCGIWTXPOW:
1807         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1808         rc = -EOPNOTSUPP;
1809                 break;
1810
1811         case SIOCSIWTXPOW:
1812         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1813         rc = -EOPNOTSUPP;
1814                 break;
1815
1816         case SIOCSIWRETRY:
1817
1818                 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
1819                 break;
1820
1821         case SIOCGIWRETRY:
1822
1823                 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
1824                 break;
1825
1826                 // Get range of parameters
1827         case SIOCGIWRANGE:
1828
1829                 {
1830                         struct iw_range range;
1831
1832                         rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
1833                         if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
1834                                 rc = -EFAULT;
1835                 }
1836
1837                 break;
1838
1839         case SIOCGIWPOWER:
1840
1841                 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
1842                 break;
1843
1844
1845         case SIOCSIWPOWER:
1846
1847                 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
1848                 break;
1849
1850
1851         case SIOCGIWSENS:
1852
1853             rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
1854                 break;
1855
1856         case SIOCSIWSENS:
1857         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
1858                 rc = -EOPNOTSUPP;
1859                 break;
1860
1861         case SIOCGIWAPLIST:
1862             {
1863             char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
1864
1865                     if (wrq->u.data.pointer) {
1866                         rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
1867                         if (rc == 0) {
1868                     if (copy_to_user(wrq->u.data.pointer,
1869                                                         buffer,
1870                                                        (wrq->u.data.length * (sizeof(struct sockaddr) +  sizeof(struct iw_quality)))
1871                                         ))
1872                                     rc = -EFAULT;
1873                         }
1874             }
1875         }
1876                 break;
1877
1878
1879 #ifdef WIRELESS_SPY
1880                 // Set the spy list
1881         case SIOCSIWSPY:
1882
1883         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1884                 rc = -EOPNOTSUPP;
1885                 break;
1886
1887                 // Get the spy list
1888         case SIOCGIWSPY:
1889
1890         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1891                 rc = -EOPNOTSUPP;
1892                 break;
1893
1894 #endif // WIRELESS_SPY
1895
1896         case SIOCGIWPRIV:
1897         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
1898                 rc = -EOPNOTSUPP;
1899 /*
1900                 if(wrq->u.data.pointer) {
1901                         wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
1902
1903                         if(copy_to_user(wrq->u.data.pointer,
1904                                         (u_char *) iwctl_private_args,
1905                                         sizeof(iwctl_private_args)))
1906                                 rc = -EFAULT;
1907                 }
1908 */
1909                 break;
1910
1911 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1912         case SIOCSIWAUTH:
1913                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH\n");
1914                 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
1915                 break;
1916
1917         case SIOCGIWAUTH:
1918                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
1919                 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
1920                 break;
1921
1922         case SIOCSIWGENIE:
1923                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
1924                 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1925                 break;
1926
1927         case SIOCGIWGENIE:
1928                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
1929                 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1930                 break;
1931
1932         case SIOCSIWENCODEEXT:
1933                 {
1934                         char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
1935                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
1936                         if(wrq->u.encoding.pointer){
1937                                 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
1938                                 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
1939                                         rc = -E2BIG;
1940                                         break;
1941                                 }
1942                                 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
1943                                         rc = -EFAULT;
1944                                         break;
1945                                 }
1946                         }else if(wrq->u.encoding.length != 0){
1947                                 rc = -EINVAL;
1948                                 break;
1949                         }
1950                         rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
1951                 }
1952                 break;
1953
1954         case SIOCGIWENCODEEXT:
1955                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
1956                 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
1957                 break;
1958
1959         case SIOCSIWMLME:
1960                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
1961                 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1962                 break;
1963
1964 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1965
1966     case IOCTL_CMD_TEST:
1967
1968                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1969                     rc = -EFAULT;
1970                     break;
1971                 } else {
1972                     rc = 0;
1973                 }
1974         pReq = (PSCmdRequest)rq;
1975
1976    //20080130-01,<Remark> by Mike Liu
1977       // if(pDevice->bLinkPass==TRUE)
1978           pReq->wResult = MAGIC_CODE;         //Linking status:0x3142
1979    //20080130-02,<Remark> by Mike Liu
1980       //  else
1981       //         pReq->wResult = MAGIC_CODE+1;    //disconnect status:0x3143
1982         break;
1983
1984     case IOCTL_CMD_SET:
1985                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
1986                        (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
1987                 {
1988                     rc = -EFAULT;
1989                     break;
1990                 } else {
1991                     rc = 0;
1992                 }
1993
1994             if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
1995                     return -EBUSY;
1996             }
1997         rc = private_ioctl(pDevice, rq);
1998         clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
1999         break;
2000
2001     case IOCTL_CMD_HOSTAPD:
2002
2003                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2004                     rc = -EFAULT;
2005                     break;
2006                 } else {
2007                     rc = 0;
2008                 }
2009
2010                 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
2011         break;
2012
2013     case IOCTL_CMD_WPA:
2014
2015                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2016                     rc = -EFAULT;
2017                     break;
2018                 } else {
2019                     rc = 0;
2020                 }
2021
2022                 rc = wpa_ioctl(pDevice, &wrq->u.data);
2023         break;
2024
2025         case SIOCETHTOOL:
2026         return ethtool_ioctl(dev, (void *) rq->ifr_data);
2027         // All other calls are currently unsupported
2028
2029         default:
2030                 rc = -EOPNOTSUPP;
2031         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2032
2033
2034     }
2035
2036     if (pDevice->bCommit) {
2037        if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2038            netif_stop_queue(pDevice->dev);
2039            spin_lock_irq(&pDevice->lock);
2040         bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
2041            spin_unlock_irq(&pDevice->lock);
2042        }
2043        else {
2044            DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2045            spin_lock_irq(&pDevice->lock);
2046 //2007-1121-01<Modify>by EinsnLiu
2047             if (pDevice->bLinkPass &&
2048                   memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2049                 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2050              } else {
2051            pDevice->bLinkPass = FALSE;
2052            pMgmt->eCurrState = WMAC_STATE_IDLE;
2053            memset(pMgmt->abyCurrBSSID, 0, 6);
2054                  }
2055            ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2056 //End Modify
2057            netif_stop_queue(pDevice->dev);
2058 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2059            pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2060            if (!pDevice->bWPASuppWextEnabled)
2061 #endif
2062                 bScheduleCommand((void *) pDevice,
2063                                  WLAN_CMD_BSSID_SCAN,
2064                                  pMgmt->abyDesireSSID);
2065                 bScheduleCommand((void *) pDevice,
2066                                  WLAN_CMD_SSID,
2067                                  NULL);
2068            spin_unlock_irq(&pDevice->lock);
2069       }
2070       pDevice->bCommit = FALSE;
2071     }
2072
2073
2074     return rc;
2075 }
2076
2077
2078 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2079 {
2080         u32 ethcmd;
2081
2082         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
2083                 return -EFAULT;
2084
2085         switch (ethcmd) {
2086         case ETHTOOL_GDRVINFO: {
2087                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2088                 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2089                 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2090                 if (copy_to_user(useraddr, &info, sizeof(info)))
2091                         return -EFAULT;
2092                 return 0;
2093         }
2094
2095         }
2096
2097         return -EOPNOTSUPP;
2098 }
2099
2100
2101 /*------------------------------------------------------------------*/
2102
2103 MODULE_DEVICE_TABLE(usb, vt6656_table);
2104
2105 static struct usb_driver vt6656_driver = {
2106         .name =         DEVICE_NAME,
2107         .probe =        vt6656_probe,
2108         .disconnect =   vt6656_disconnect,
2109         .id_table =     vt6656_table,
2110 #ifdef CONFIG_PM
2111         .suspend = vt6656_suspend,
2112         .resume = vt6656_resume,
2113 #endif /* CONFIG_PM */
2114 };
2115
2116 static int __init vt6656_init_module(void)
2117 {
2118     printk(KERN_NOTICE DEVICE_FULL_DRV_NAM " " DEVICE_VERSION);
2119     return usb_register(&vt6656_driver);
2120 }
2121
2122 static void __exit vt6656_cleanup_module(void)
2123 {
2124         usb_deregister(&vt6656_driver);
2125 }
2126
2127 module_init(vt6656_init_module);
2128 module_exit(vt6656_cleanup_module);