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