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