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
 841 static const struct net_device_ops device_netdev_ops = {
 842     .ndo_open               = device_open,
 843     .ndo_stop               = device_close,
 844     .ndo_do_ioctl           = device_ioctl,
 845     .ndo_get_stats          = device_get_stats,
 846     .ndo_start_xmit         = device_xmit,
 847     .ndo_set_multicast_list = device_set_multi,
 848 };
 849
 850
 851 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
 852
 853 static int
 854 vntwusb_found1(struct usb_interface *intf, const struct usb_device_id *id)
 855 #else
 856
 857 static void *
 858 vntwusb_found1(struct usb_device *udev, UINT interface, const struct usb_device_id *id)
 859 #endif
 860 {
 861 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
 862    BYTE            fake_mac[U_ETHER_ADDR_LEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};//fake MAC address
 863 #endif
 864 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
 865         struct usb_device *udev = interface_to_usbdev(intf);
 866     int         rc = 0;
 867 #endif
 868     struct net_device *netdev = NULL;
 869     PSDevice    pDevice = NULL;
 870
 871
 872     printk(KERN_NOTICE "%s Ver. %s\n",DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
 873     printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
 874
 875 //2008-0922-01<Add>by MikeLiu, add usb counter.
 876 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
 877   udev = usb_get_dev(udev);
 878 #endif
 879
 880 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
 881     netdev = alloc_etherdev(sizeof(DEVICE_INFO));
 882 #else
 883     netdev = init_etherdev(netdev, 0);
 884 #endif
 885
 886     if (netdev == NULL) {
 887         printk(KERN_ERR DEVICE_NAME ": allocate net device failed \n");
 888         kfree(pDevice);
 889             goto err_nomem;
 890     }
 891
 892     pDevice = netdev_priv(netdev);
 893     memset(pDevice, 0, sizeof(DEVICE_INFO));
 894
 895     pDevice->dev = netdev;
 896     pDevice->usb = udev;
 897
 898     // Chain it all together
 899 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
 900     SET_MODULE_OWNER(netdev);
 901 #endif
 902
 903     // Set initial settings
 904     device_set_options(pDevice);
 905     spin_lock_init(&pDevice->lock);
 906
 907     pDevice->tx_80211 = device_dma0_tx_80211;
 908     pDevice->sMgmtObj.pAdapter = (PVOID)pDevice;
 909
 910     netdev->netdev_ops         = &device_netdev_ops;
 911
 912 #ifdef WIRELESS_EXT
 913
 914 //2007-0508-01<Add>by MikeLiu
 915   #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
 916         netdev->get_wireless_stats = iwctl_get_wireless_stats;
 917   #endif
 918
 919 #if WIRELESS_EXT > 12
 920         netdev->wireless_handlers = (struct iw_handler_def *)&iwctl_handler_def;
 921 //      netdev->wireless_handlers = NULL;
 922 #endif /* WIRELESS_EXT > 12 */
 923 #endif /* WIRELESS_EXT */
 924
 925 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
 926
 927    //2008-0623-01<Remark>by MikeLiu
 928   //2007-0821-01<Add>by MikeLiu
 929   // #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
 930          usb_set_intfdata(intf, pDevice);
 931         SET_NETDEV_DEV(netdev, &intf->dev);
 932    //#endif
 933    #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
 934     memcpy(pDevice->dev->dev_addr, fake_mac, U_ETHER_ADDR_LEN); //use fake mac address
 935    #endif
 936     rc = register_netdev(netdev);
 937     if (rc != 0) {
 938         printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
 939                 free_netdev(netdev);
 940         kfree(pDevice);
 941         return -ENODEV;
 942     }
 943         //2008-0623-02<Remark>by MikeLiu
 944         //2007-0821-01<Add>by MikeLiu
 945        //#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)
 946         //usb_set_intfdata(intf, pDevice);
 947         //SET_NETDEV_DEV(netdev, &intf->dev);
 948        //#endif
 949
 950 //2008-07-21-01<Add>by MikeLiu
 951 //register wpadev
 952    if(wpa_set_wpadev(pDevice, 1)!=0) {
 953      printk("Fail to Register WPADEV?\n");
 954         unregister_netdev(pDevice->dev);
 955         free_netdev(netdev);
 956         kfree(pDevice);
 957    }
 958
 959 //2007-1107-03<Add>by MikeLiu
 960    #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
 961          usb_device_reset(pDevice);
 962    #endif
 963
 964 #ifdef SndEvt_ToAPI
 965 {
 966   union iwreq_data      wrqu;
 967   memset(&wrqu, 0, sizeof(wrqu));
 968   wrqu.data.flags = RT_INSMOD_EVENT_FLAG;
 969   wrqu.data.length =IFNAMSIZ;
 970   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, pDevice->dev->name);
 971 }
 972 #endif
 973
 974         return 0;
 975 #else
 976     return pDevice;
 977 #endif
 978
 979
 980 err_nomem:
 981 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
 982
 983  //2008-0922-01<Add>by MikeLiu, decrease usb counter.
 984     usb_put_dev(udev);
 985
 986     return -ENOMEM;
 987 #else
 988     return NULL;
 989 #endif
 990 }
 991
 992
 993 static VOID device_free_tx_bufs(PSDevice pDevice) {
 994     PUSB_SEND_CONTEXT pTxContext;
 995     int ii;
 996
 997     for (ii = 0; ii < pDevice->cbTD; ii++) {
 998
 999         pTxContext = pDevice->apTD[ii];
1000         //de-allocate URBs
1001         if (pTxContext->pUrb) {
1002             vntwusb_unlink_urb(pTxContext->pUrb);
1003             usb_free_urb(pTxContext->pUrb);
1004         }
1005         if (pTxContext)
1006             kfree(pTxContext);
1007     }
1008     return;
1009 }
1010
1011
1012 static VOID device_free_rx_bufs(PSDevice pDevice) {
1013     PRCB pRCB;
1014     int ii;
1015
1016     for (ii = 0; ii < pDevice->cbRD; ii++) {
1017
1018         pRCB = pDevice->apRCB[ii];
1019         //de-allocate URBs
1020         if (pRCB->pUrb) {
1021             vntwusb_unlink_urb(pRCB->pUrb);
1022             usb_free_urb(pRCB->pUrb);
1023         }
1024         //de-allocate skb
1025         if (pRCB->skb)
1026             dev_kfree_skb(pRCB->skb);
1027     }
1028     if (pDevice->pRCBMem)
1029         kfree(pDevice->pRCBMem);
1030
1031     return;
1032 }
1033
1034 //2007-1107-02<Add>by MikeLiu
1035 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
1036 static void usb_device_reset(PSDevice pDevice)
1037 {
1038  int status;
1039  status = usb_reset_device(pDevice->usb);
1040         if (status)
1041             printk("usb_device_reset fail status=%d\n",status);
1042         return ;
1043 }
1044 #endif
1045
1046 static VOID device_free_int_bufs(PSDevice pDevice) {
1047
1048     if (pDevice->intBuf.pDataBuf != NULL)
1049         kfree(pDevice->intBuf.pDataBuf);
1050     return;
1051 }
1052
1053
1054 static BOOL device_alloc_bufs(PSDevice pDevice) {
1055
1056     PUSB_SEND_CONTEXT pTxContext;
1057     PRCB pRCB;
1058     int ii;
1059
1060
1061     for (ii = 0; ii < pDevice->cbTD; ii++) {
1062
1063         pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
1064         if (pTxContext == NULL) {
1065             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
1066             goto free_tx;
1067         }
1068         pDevice->apTD[ii] = pTxContext;
1069         pTxContext->pDevice = (PVOID) pDevice;
1070         //allocate URBs
1071         pTxContext->pUrb = vntwusb_alloc_urb(0);;
1072         if (pTxContext->pUrb == NULL) {
1073             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
1074             goto free_tx;
1075         }
1076         pTxContext->bBoolInUse = FALSE;
1077     }
1078
1079     // allocate rcb mem
1080     pDevice->pRCBMem = kmalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
1081     if (pDevice->pRCBMem == NULL) {
1082         DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
1083         goto free_tx;
1084     }
1085
1086
1087     pDevice->FirstRecvFreeList = NULL;
1088     pDevice->LastRecvFreeList = NULL;
1089     pDevice->FirstRecvMngList = NULL;
1090     pDevice->LastRecvMngList = NULL;
1091     pDevice->NumRecvFreeList = 0;
1092     memset(pDevice->pRCBMem, 0, (sizeof(RCB) * pDevice->cbRD));
1093     pRCB = (PRCB) pDevice->pRCBMem;
1094
1095     for (ii = 0; ii < pDevice->cbRD; ii++) {
1096
1097         pDevice->apRCB[ii] = pRCB;
1098         pRCB->pDevice = (PVOID) pDevice;
1099         //allocate URBs
1100         pRCB->pUrb = vntwusb_alloc_urb(0);
1101
1102         if (pRCB->pUrb == NULL) {
1103             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
1104             goto free_rx_tx;
1105         }
1106         pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1107         if (pRCB->skb == NULL) {
1108             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
1109             goto free_rx_tx;
1110         }
1111         pRCB->skb->dev = pDevice->dev;
1112         pRCB->bBoolInUse = FALSE;
1113         EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
1114         pDevice->NumRecvFreeList++;
1115         pRCB++;
1116     }
1117
1118
1119         pDevice->pControlURB = vntwusb_alloc_urb(0);
1120         if (pDevice->pControlURB == NULL) {
1121             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
1122             goto free_rx_tx;
1123         }
1124
1125         pDevice->pInterruptURB = vntwusb_alloc_urb(0);
1126         if (pDevice->pInterruptURB == NULL) {
1127             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
1128             vntwusb_unlink_urb(pDevice->pControlURB);
1129             usb_free_urb(pDevice->pControlURB);
1130             goto free_rx_tx;
1131         }
1132
1133     pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
1134         if (pDevice->intBuf.pDataBuf == NULL) {
1135             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
1136             vntwusb_unlink_urb(pDevice->pControlURB);
1137             vntwusb_unlink_urb(pDevice->pInterruptURB);
1138             usb_free_urb(pDevice->pControlURB);
1139             usb_free_urb(pDevice->pInterruptURB);
1140             goto free_rx_tx;
1141         }
1142
1143     return TRUE;
1144
1145 free_rx_tx:
1146     device_free_rx_bufs(pDevice);
1147
1148 free_tx:
1149     device_free_tx_bufs(pDevice);
1150
1151         return FALSE;
1152 }
1153
1154
1155
1156
1157 static BOOL device_init_defrag_cb(PSDevice pDevice) {
1158     int i;
1159     PSDeFragControlBlock pDeF;
1160
1161     /* Init the fragment ctl entries */
1162     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1163         pDeF = &(pDevice->sRxDFCB[i]);
1164         if (!device_alloc_frag_buf(pDevice, pDeF)) {
1165             DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
1166                 pDevice->dev->name);
1167             goto free_frag;
1168         };
1169     }
1170     pDevice->cbDFCB = CB_MAX_RX_FRAG;
1171     pDevice->cbFreeDFCB = pDevice->cbDFCB;
1172     return TRUE;
1173
1174 free_frag:
1175     device_free_frag_bufs(pDevice);
1176     return FALSE;
1177 }
1178
1179
1180
1181 static void device_free_frag_bufs(PSDevice pDevice) {
1182     PSDeFragControlBlock pDeF;
1183     int i;
1184
1185     for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1186
1187         pDeF = &(pDevice->sRxDFCB[i]);
1188
1189         if (pDeF->skb)
1190             dev_kfree_skb(pDeF->skb);
1191     }
1192 }
1193
1194
1195
1196 BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1197
1198     pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1199     if (pDeF->skb == NULL)
1200         return FALSE;
1201     ASSERT(pDeF->skb);
1202     pDeF->skb->dev = pDevice->dev;
1203
1204     return TRUE;
1205 }
1206
1207
1208 /*-----------------------------------------------------------------*/
1209
1210 static int  device_open(struct net_device *dev) {
1211     PSDevice    pDevice=(PSDevice) netdev_priv(dev);
1212
1213 #ifdef WPA_SM_Transtatus
1214      extern SWPAResult wpa_Result;
1215      memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1216      wpa_Result.proto = 0;
1217      wpa_Result.key_mgmt = 0;
1218      wpa_Result.eap_type = 0;
1219      wpa_Result.authenticated = FALSE;
1220      pDevice->fWPA_Authened = FALSE;
1221 #endif
1222
1223     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
1224
1225
1226     pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
1227
1228     if (device_alloc_bufs(pDevice) == FALSE) {
1229         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
1230         return -ENOMEM;
1231     }
1232
1233     if (device_init_defrag_cb(pDevice)== FALSE) {
1234         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragement cb fail \n");
1235         goto free_rx_tx;
1236     }
1237
1238     MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
1239     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
1240     MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
1241     MP_SET_FLAG(pDevice, fMP_POST_READS);
1242     MP_SET_FLAG(pDevice, fMP_POST_WRITES);
1243
1244    //read config file
1245     Read_config_file(pDevice);
1246
1247     if (device_init_registers(pDevice, DEVICE_INIT_COLD) == FALSE) {
1248         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
1249         goto free_all;
1250     }
1251
1252     device_set_multi(pDevice->dev);
1253     // Init for Key Management
1254
1255     KeyvInitTable(pDevice,&pDevice->sKey);
1256     memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, U_ETHER_ADDR_LEN);
1257     memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, U_ETHER_ADDR_LEN);
1258     pDevice->bStopTx0Pkt = FALSE;
1259     pDevice->bStopDataPkt = FALSE;
1260     pDevice->bRoaming = FALSE;  //DavidWang
1261     pDevice->bIsRoaming = FALSE;//DavidWang
1262     pDevice->bEnableRoaming = FALSE;
1263     if (pDevice->bDiversityRegCtlON) {
1264         device_init_diversity_timer(pDevice);
1265     }
1266
1267     vMgrObjectInit(pDevice);
1268     tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
1269     tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
1270     tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
1271     add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback));
1272 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
1273     pDevice->int_interval = 100;  //Max 100 microframes.
1274 #else
1275     pDevice->int_interval = 0x10; //16 microframes interval(~2ms) for usb 2.0
1276 #endif
1277     pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1278
1279     pDevice->bIsRxWorkItemQueued = TRUE;
1280     pDevice->fKillEventPollingThread = FALSE;
1281     pDevice->bEventAvailable = FALSE;
1282
1283    pDevice->bWPADEVUp = FALSE;
1284 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1285      pDevice->bwextstep0 = FALSE;
1286      pDevice->bwextstep1 = FALSE;
1287      pDevice->bwextstep2 = FALSE;
1288      pDevice->bwextstep3 = FALSE;
1289      pDevice->bWPASuppWextEnabled = FALSE;
1290 #endif
1291     pDevice->byReAssocCount = 0;
1292
1293     RXvWorkItem(pDevice);
1294     INTvWorkItem(pDevice);
1295
1296     // Patch: if WEP key already set by iwconfig but device not yet open
1297     if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1298          spin_lock_irq(&pDevice->lock);
1299          KeybSetDefaultKey( pDevice,
1300                             &(pDevice->sKey),
1301                             pDevice->byKeyIndex | (1 << 31),
1302                             pDevice->uKeyLength,
1303                             NULL,
1304                             pDevice->abyKey,
1305                             KEY_CTL_WEP
1306                           );
1307          spin_unlock_irq(&pDevice->lock);
1308          pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1309     }
1310
1311     if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1312         bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL);
1313         }
1314         else {
1315         //mike:mark@2008-11-10
1316             bScheduleCommand((HANDLE)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1317         //bScheduleCommand((HANDLE)pDevice, WLAN_CMD_SSID, NULL);
1318     }
1319
1320
1321     netif_stop_queue(pDevice->dev);
1322     pDevice->flags |= DEVICE_FLAGS_OPENED;
1323
1324 #ifdef SndEvt_ToAPI
1325 {
1326   union iwreq_data      wrqu;
1327   memset(&wrqu, 0, sizeof(wrqu));
1328   wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1329   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1330 }
1331 #endif
1332
1333     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1334     return 0;
1335
1336 free_all:
1337     device_free_frag_bufs(pDevice);
1338 free_rx_tx:
1339     device_free_rx_bufs(pDevice);
1340     device_free_tx_bufs(pDevice);
1341     device_free_int_bufs(pDevice);
1342         vntwusb_unlink_urb(pDevice->pControlURB);
1343         vntwusb_unlink_urb(pDevice->pInterruptURB);
1344     usb_free_urb(pDevice->pControlURB);
1345     usb_free_urb(pDevice->pInterruptURB);
1346
1347     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1348     return -ENOMEM;
1349 }
1350
1351
1352
1353 static int  device_close(struct net_device *dev) {
1354     PSDevice    pDevice=(PSDevice) netdev_priv(dev);
1355     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1356
1357    #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
1358         int uu;
1359    #endif
1360
1361     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1362     if (pDevice == NULL)
1363         return -ENODEV;
1364
1365 #ifdef SndEvt_ToAPI
1366 {
1367   union iwreq_data      wrqu;
1368   memset(&wrqu, 0, sizeof(wrqu));
1369   wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1370   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1371 }
1372 #endif
1373
1374 //2007-1121-02<Add>by EinsnLiu
1375     if (pDevice->bLinkPass) {
1376         bScheduleCommand((HANDLE)pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1377         mdelay(30);
1378     }
1379 //End Add
1380
1381 //2008-0714-01<Add>by MikeLiu
1382 device_release_WPADEV(pDevice);
1383
1384  //2007-0821-01<Add>by MikeLiu
1385    #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
1386         memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1387         pMgmt->bShareKeyAlgorithm = FALSE;
1388         pDevice->bEncryptionEnable = FALSE;
1389         pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1390             spin_lock_irq(&pDevice->lock);
1391             for(uu=0;uu<MAX_KEY_TABLE;uu++)
1392                 MACvDisableKeyEntry(pDevice,uu);
1393             spin_unlock_irq(&pDevice->lock);
1394    #endif
1395
1396     if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1397         MACbShutdown(pDevice);
1398     }
1399     netif_stop_queue(pDevice->dev);
1400     MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1401     MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1402     MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1403     pDevice->fKillEventPollingThread = TRUE;
1404     del_timer(&pDevice->sTimerCommand);
1405     del_timer(&pMgmt->sTimerSecondCallback);
1406
1407 //2007-0115-02<Add>by MikeLiu
1408 #ifdef TxInSleep
1409     del_timer(&pDevice->sTimerTxData);
1410 #endif
1411
1412     if (pDevice->bDiversityRegCtlON) {
1413         del_timer(&pDevice->TimerSQ3Tmax1);
1414         del_timer(&pDevice->TimerSQ3Tmax2);
1415         del_timer(&pDevice->TimerSQ3Tmax3);
1416     }
1417     tasklet_kill(&pDevice->RxMngWorkItem);
1418     tasklet_kill(&pDevice->ReadWorkItem);
1419     tasklet_kill(&pDevice->EventWorkItem);
1420
1421    pDevice->bRoaming = FALSE;  //DavidWang
1422    pDevice->bIsRoaming = FALSE;//DavidWang
1423    pDevice->bEnableRoaming = FALSE;
1424     pDevice->bCmdRunning = FALSE;
1425     pDevice->bLinkPass = FALSE;
1426     memset(pMgmt->abyCurrBSSID, 0, 6);
1427     pMgmt->eCurrState = WMAC_STATE_IDLE;
1428
1429     device_free_tx_bufs(pDevice);
1430     device_free_rx_bufs(pDevice);
1431     device_free_int_bufs(pDevice);
1432     device_free_frag_bufs(pDevice);
1433
1434         vntwusb_unlink_urb(pDevice->pControlURB);
1435         vntwusb_unlink_urb(pDevice->pInterruptURB);
1436     usb_free_urb(pDevice->pControlURB);
1437     usb_free_urb(pDevice->pInterruptURB);
1438
1439     BSSvClearNodeDBTable(pDevice, 0);
1440     pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1441
1442     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1443
1444     return 0;
1445 }
1446
1447 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
1448
1449 static void vntwusb_disconnect(struct usb_interface *intf)
1450
1451 #else
1452
1453 static void vntwusb_disconnect(struct usb_device *udev, void *ptr)
1454 #endif
1455 {
1456 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
1457
1458         PSDevice  pDevice = usb_get_intfdata(intf);
1459 #else
1460         PSDevice  pDevice = (PSDevice)ptr;
1461 #endif
1462
1463
1464     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_disconnect1.. \n");
1465     if (pDevice == NULL)
1466         return;
1467
1468 #ifdef SndEvt_ToAPI
1469 {
1470   union iwreq_data      wrqu;
1471   memset(&wrqu, 0, sizeof(wrqu));
1472   wrqu.data.flags = RT_RMMOD_EVENT_FLAG;
1473   wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1474 }
1475 #endif
1476
1477 //2008-0714-01<Add>by MikeLiu
1478 device_release_WPADEV(pDevice);
1479
1480 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
1481
1482         usb_set_intfdata(intf, NULL);
1483 //2008-0922-01<Add>by MikeLiu, decrease usb counter.
1484      usb_put_dev(interface_to_usbdev(intf));
1485
1486 #endif
1487
1488     pDevice->flags |= DEVICE_FLAGS_UNPLUG;
1489     if (pDevice->dev != NULL) {
1490         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "unregister_netdev..\n");
1491         unregister_netdev(pDevice->dev);
1492
1493 //2008-07-21-01<Add>by MikeLiu
1494 //unregister wpadev
1495    if(wpa_set_wpadev(pDevice, 0)!=0)
1496      printk("unregister wpadev fail?\n");
1497
1498 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
1499         free_netdev(pDevice->dev);
1500 #else
1501             kfree(pDevice->dev);
1502 #endif
1503     }
1504
1505         kfree(pDevice);
1506     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_disconnect3.. \n");
1507 }
1508
1509
1510
1511
1512 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev) {
1513     PSDevice        pDevice=netdev_priv(dev);
1514     PBYTE           pbMPDU;
1515     UINT            cbMPDULen = 0;
1516
1517
1518     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211\n");
1519     spin_lock_irq(&pDevice->lock);
1520
1521     if (pDevice->bStopTx0Pkt == TRUE) {
1522         dev_kfree_skb_irq(skb);
1523         spin_unlock_irq(&pDevice->lock);
1524         return 0;
1525     };
1526
1527
1528     cbMPDULen = skb->len;
1529     pbMPDU = skb->data;
1530
1531     vDMA0_tx_80211(pDevice, skb);
1532
1533     spin_unlock_irq(&pDevice->lock);
1534
1535     return 0;
1536
1537 }
1538
1539
1540 static int  device_xmit(struct sk_buff *skb, struct net_device *dev) {
1541     PSDevice    pDevice=netdev_priv(dev);
1542     struct net_device_stats* pStats = &pDevice->stats;
1543
1544
1545     spin_lock_irq(&pDevice->lock);
1546
1547     netif_stop_queue(pDevice->dev);
1548
1549     if (pDevice->bLinkPass == FALSE) {
1550         dev_kfree_skb_irq(skb);
1551         spin_unlock_irq(&pDevice->lock);
1552         return 0;
1553     }
1554     if (pDevice->bStopDataPkt == TRUE) {
1555         dev_kfree_skb_irq(skb);
1556         pStats->tx_dropped++;
1557         spin_unlock_irq(&pDevice->lock);
1558         return 0;
1559     }
1560
1561     if(nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb) !=0) {  //mike add:xmit fail!
1562          if (netif_queue_stopped(pDevice->dev))
1563               netif_wake_queue(pDevice->dev);
1564     }
1565
1566     spin_unlock_irq(&pDevice->lock);
1567
1568     return 0;
1569 }
1570
1571
1572
1573 static unsigned const ethernet_polynomial = 0x04c11db7U;
1574 static inline u32 ether_crc(int length, unsigned char *data)
1575 {
1576     int crc = -1;
1577
1578     while(--length >= 0) {
1579         unsigned char current_octet = *data++;
1580         int bit;
1581         for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1582             crc = (crc << 1) ^
1583                 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1584         }
1585     }
1586     return crc;
1587 }
1588
1589 //find out  the start  position of str2 from str1
1590 static UCHAR *kstrstr(const UCHAR *str1,const UCHAR *str2) {
1591   int str1_len=strlen(str1);
1592   int str2_len=strlen(str2);
1593
1594   while (str1_len >= str2_len) {
1595        str1_len--;
1596       if(memcmp(str1,str2,str2_len)==0)
1597          return (UCHAR *)str1;
1598         str1++;
1599   }
1600   return NULL;
1601 }
1602
1603 static int Config_FileGetParameter(UCHAR *string, UCHAR *dest,UCHAR *source)
1604 {
1605   UCHAR buf1[100];
1606   UCHAR buf2[100];
1607   UCHAR *start_p=NULL,*end_p=NULL,*tmp_p=NULL;
1608   int ii;
1609
1610     memset(buf1,0,100);
1611     strcat(buf1, string);
1612     strcat(buf1, "=");
1613     source+=strlen(buf1);
1614
1615 //find target string start point
1616     if((start_p = kstrstr(source,buf1))==NULL)
1617         return FALSE;
1618
1619 //check if current config line is marked by "#" ??
1620 for(ii=1;;ii++) {
1621   if(memcmp(start_p-ii,"\n",1)==0)
1622       break;
1623   if(memcmp(start_p-ii,"#",1)==0)
1624       return FALSE;
1625 }
1626
1627 //find target string end point
1628      if((end_p = kstrstr(start_p,"\n"))==NULL) {       //cann't find "\n",but don't care
1629           end_p=start_p+strlen(start_p);   //no include "\n"
1630        }
1631
1632    memset(buf2,0,100);
1633    memcpy(buf2,start_p,end_p-start_p);    //get the tartget line
1634    buf2[end_p-start_p]='\0';
1635
1636    //find value
1637    if((start_p = kstrstr(buf2,"="))==NULL)
1638       return FALSE;
1639    memset(buf1,0,100);
1640    strcpy(buf1,start_p+1);
1641
1642   //except space
1643   tmp_p = buf1;
1644   while(*tmp_p != 0x00) {
1645         if(*tmp_p==' ')
1646             tmp_p++;
1647          else
1648           break;
1649   }
1650
1651    memcpy(dest,tmp_p,strlen(tmp_p));
1652  return TRUE;
1653 }
1654
1655 //if read fail,return NULL,or return data pointer;
1656 static UCHAR *Config_FileOperation(PSDevice pDevice) {
1657     UCHAR    *config_path=CONFIG_PATH;
1658     UCHAR    *buffer=NULL;
1659     struct file   *filp=NULL;
1660     mm_segment_t old_fs = get_fs();
1661     //int oldfsuid=0,oldfsgid=0;
1662     int result=0;
1663
1664     set_fs (KERNEL_DS);
1665     /* Can't do this anymore, so we rely on correct filesystem permissions:
1666     //Make sure a caller can read or write power as root
1667     oldfsuid=current->fsuid;
1668     oldfsgid=current->fsgid;
1669     current->fsuid = 0;
1670     current->fsgid = 0;
1671     */
1672
1673     //open file
1674       filp = filp_open(config_path, O_RDWR, 0);
1675         if (IS_ERR(filp)) {
1676              printk("Config_FileOperation file Not exist\n");
1677              result=-1;
1678              goto error2;
1679           }
1680
1681      if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1682            printk("file %s cann't readable or writable?\n",config_path);
1683           result = -1;
1684           goto error1;
1685         }
1686
1687     buffer = (UCHAR *)kmalloc(1024, GFP_KERNEL);
1688     if(buffer==NULL) {
1689       printk("alllocate mem for file fail?\n");
1690       result = -1;
1691       goto error1;
1692     }
1693
1694     if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1695      printk("read file error?\n");
1696      result = -1;
1697     }
1698
1699 error1:
1700   if(filp_close(filp,NULL))
1701        printk("Config_FileOperation:close file fail\n");
1702
1703 error2:
1704   set_fs (old_fs);
1705
1706   /*
1707   current->fsuid=oldfsuid;
1708   current->fsgid=oldfsgid;
1709   */
1710
1711 if(result!=0) {
1712     if(buffer)
1713          kfree(buffer);
1714     buffer=NULL;
1715 }
1716   return buffer;
1717 }
1718
1719 //return --->-1:fail;  >=0:sucessful
1720 static int Read_config_file(PSDevice pDevice) {
1721   int result=0;
1722   UCHAR      tmpbuffer[100];
1723   UCHAR *buffer=NULL;
1724
1725   //init config setting
1726  pDevice->config_file.ZoneType = -1;
1727  pDevice->config_file.eAuthenMode = -1;
1728  pDevice->config_file.eEncryptionStatus = -1;
1729
1730   if((buffer=Config_FileOperation(pDevice)) ==NULL) {
1731      result =-1;
1732      return result;
1733   }
1734
1735 //get zonetype
1736 {
1737     memset(tmpbuffer,0,sizeof(tmpbuffer));
1738     if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1739     if(memcmp(tmpbuffer,"USA",3)==0) {
1740       pDevice->config_file.ZoneType=ZoneType_USA;
1741     }
1742     else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1743       pDevice->config_file.ZoneType=ZoneType_Japan;
1744     }
1745     else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1746      pDevice->config_file.ZoneType=ZoneType_Europe;
1747     }
1748     else {
1749       printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1750    }
1751  }
1752 }
1753
1754 #if 1
1755 //get other parameter
1756   {
1757         memset(tmpbuffer,0,sizeof(tmpbuffer));
1758        if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1759          pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1760        }
1761
1762         memset(tmpbuffer,0,sizeof(tmpbuffer));
1763        if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1764          pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1765        }
1766   }
1767 #endif
1768
1769   kfree(buffer);
1770   return result;
1771 }
1772
1773 static void device_set_multi(struct net_device *dev) {
1774     PSDevice         pDevice = (PSDevice) netdev_priv(dev);
1775     PSMgmtObject     pMgmt = &(pDevice->sMgmtObj);
1776     u32              mc_filter[2];
1777     int              ii;
1778     struct dev_mc_list  *mclist;
1779     BYTE             pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1780     BYTE             byTmpMode = 0;
1781     int              rc;
1782
1783
1784         spin_lock_irq(&pDevice->lock);
1785     rc = CONTROLnsRequestIn(pDevice,
1786                             MESSAGE_TYPE_READ,
1787                             MAC_REG_RCR,
1788                             MESSAGE_REQUEST_MACREG,
1789                             1,
1790                             &byTmpMode
1791                             );
1792     if (rc == 0) pDevice->byRxMode = byTmpMode;
1793
1794     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1795
1796     if (dev->flags & IFF_PROMISC) {         // Set promiscuous.
1797         DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1798         // Unconditionally log net taps.
1799         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1800     }
1801     else if ((dev->mc_count > pDevice->multicast_limit) || (dev->flags & IFF_ALLMULTI)) {
1802         CONTROLnsRequestOut(pDevice,
1803                             MESSAGE_TYPE_WRITE,
1804                             MAC_REG_MAR0,
1805                             MESSAGE_REQUEST_MACREG,
1806                             8,
1807                             pbyData
1808                             );
1809         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1810     }
1811     else {
1812         memset(mc_filter, 0, sizeof(mc_filter));
1813         for (ii = 0, mclist = dev->mc_list; mclist && ii < dev->mc_count;
1814              ii++, mclist = mclist->next) {
1815             int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
1816             mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1817         }
1818         for (ii = 0; ii < 4; ii++) {
1819              MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1820              MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1821         }
1822         pDevice->byRxMode &= ~(RCR_UNICAST);
1823         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1824     }
1825
1826     if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1827         // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1828         pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1829         pDevice->byRxMode &= ~(RCR_UNICAST);
1830     }
1831     ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1832     DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1833         spin_unlock_irq(&pDevice->lock);
1834
1835 }
1836
1837
1838 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1839     PSDevice pDevice=(PSDevice) netdev_priv(dev);
1840
1841     return &pDevice->stats;
1842 }
1843
1844
1845 static int  device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1846         PSDevice                pDevice = (PSDevice)netdev_priv(dev);
1847     PSMgmtObject        pMgmt = &(pDevice->sMgmtObj);
1848     PSCmdRequest        pReq;
1849     //BOOL                bCommit = FALSE;
1850 #ifdef WIRELESS_EXT
1851         struct iwreq *wrq = (struct iwreq *) rq;
1852         int                 rc =0;
1853 #endif //WIRELESS_EXT
1854
1855
1856     if (pMgmt == NULL) {
1857         rc = -EFAULT;
1858         return rc;
1859     }
1860
1861     switch(cmd) {
1862
1863 #ifdef WIRELESS_EXT
1864 //#if WIRELESS_EXT < 13
1865
1866         case SIOCGIWNAME:
1867                 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1868                 break;
1869
1870         case SIOCSIWNWID:
1871         rc = -EOPNOTSUPP;
1872                 break;
1873
1874         case SIOCGIWNWID:     //0x8b03  support
1875         #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1876           rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
1877         #else
1878         rc = -EOPNOTSUPP;
1879         #endif
1880                 break;
1881
1882                 // Set frequency/channel
1883         case SIOCSIWFREQ:
1884             rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1885                 break;
1886
1887                 // Get frequency/channel
1888         case SIOCGIWFREQ:
1889                 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1890                 break;
1891
1892                 // Set desired network name (ESSID)
1893         case SIOCSIWESSID:
1894
1895                 {
1896                         char essid[IW_ESSID_MAX_SIZE+1];
1897                         if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1898                                 rc = -E2BIG;
1899                                 break;
1900                         }
1901                         if (copy_from_user(essid, wrq->u.essid.pointer,
1902                                            wrq->u.essid.length)) {
1903                                 rc = -EFAULT;
1904                                 break;
1905                         }
1906                         rc = iwctl_siwessid(dev, NULL,
1907                                             &(wrq->u.essid), essid);
1908                 }
1909                 break;
1910
1911
1912                 // Get current network name (ESSID)
1913         case SIOCGIWESSID:
1914
1915                 {
1916                         char essid[IW_ESSID_MAX_SIZE+1];
1917                         if (wrq->u.essid.pointer)
1918                                 rc = iwctl_giwessid(dev, NULL,
1919                                                     &(wrq->u.essid), essid);
1920                                 if (copy_to_user(wrq->u.essid.pointer,
1921                                                          essid,
1922                                                          wrq->u.essid.length) )
1923                                         rc = -EFAULT;
1924                 }
1925                 break;
1926
1927         case SIOCSIWAP:
1928
1929                 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1930                 break;
1931
1932
1933                 // Get current Access Point (BSSID)
1934         case SIOCGIWAP:
1935                 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1936                 break;
1937
1938
1939                 // Set desired station name
1940         case SIOCSIWNICKN:
1941         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1942         rc = -EOPNOTSUPP;
1943                 break;
1944
1945                 // Get current station name
1946         case SIOCGIWNICKN:
1947         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1948         rc = -EOPNOTSUPP;
1949                 break;
1950
1951                 // Set the desired bit-rate
1952         case SIOCSIWRATE:
1953                 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1954                 break;
1955
1956         // Get the current bit-rate
1957         case SIOCGIWRATE:
1958
1959                 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1960                 break;
1961
1962         // Set the desired RTS threshold
1963         case SIOCSIWRTS:
1964
1965                 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
1966                 break;
1967
1968         // Get the current RTS threshold
1969         case SIOCGIWRTS:
1970
1971                 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1972                 break;
1973
1974                 // Set the desired fragmentation threshold
1975         case SIOCSIWFRAG:
1976
1977                 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1978             break;
1979
1980         // Get the current fragmentation threshold
1981         case SIOCGIWFRAG:
1982
1983                 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1984                 break;
1985
1986                 // Set mode of operation
1987         case SIOCSIWMODE:
1988         rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1989                 break;
1990
1991                 // Get mode of operation
1992         case SIOCGIWMODE:
1993                 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1994                 break;
1995
1996                 // Set WEP keys and mode
1997         case SIOCSIWENCODE:
1998                 {
1999             char abyKey[WLAN_WEP232_KEYLEN];
2000
2001                         if (wrq->u.encoding.pointer) {
2002
2003
2004                                 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
2005                                         rc = -E2BIG;
2006                                         break;
2007                                 }
2008                                 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
2009                                 if (copy_from_user(abyKey,
2010                                                   wrq->u.encoding.pointer,
2011                                                   wrq->u.encoding.length)) {
2012                                         rc = -EFAULT;
2013                                         break;
2014                                 }
2015                         } else if (wrq->u.encoding.length != 0) {
2016                                 rc = -EINVAL;
2017                                 break;
2018                         }
2019                         rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
2020                 }
2021                 break;
2022
2023                 // Get the WEP keys and mode
2024         case SIOCGIWENCODE:
2025
2026                 if (!capable(CAP_NET_ADMIN)) {
2027                         rc = -EPERM;
2028                         break;
2029                 }
2030                 {
2031                     char abyKey[WLAN_WEP232_KEYLEN];
2032
2033                     rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
2034                     if (rc != 0) break;
2035                         if (wrq->u.encoding.pointer) {
2036                                 if (copy_to_user(wrq->u.encoding.pointer,
2037                                                         abyKey,
2038                                                         wrq->u.encoding.length))
2039                                         rc = -EFAULT;
2040                         }
2041                 }
2042                 break;
2043
2044 #if WIRELESS_EXT > 9
2045                 // Get the current Tx-Power
2046         case SIOCGIWTXPOW:
2047         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
2048         rc = -EOPNOTSUPP;
2049                 break;
2050
2051         case SIOCSIWTXPOW:
2052         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
2053         rc = -EOPNOTSUPP;
2054                 break;
2055
2056 #endif // WIRELESS_EXT > 9
2057
2058 #if WIRELESS_EXT > 10
2059         case SIOCSIWRETRY:
2060
2061                 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
2062                 break;
2063
2064         case SIOCGIWRETRY:
2065
2066                 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
2067                 break;
2068
2069 #endif // WIRELESS_EXT > 10
2070
2071                 // Get range of parameters
2072         case SIOCGIWRANGE:
2073
2074                 {
2075                         struct iw_range range;
2076
2077                         rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
2078                         if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
2079                                 rc = -EFAULT;
2080                 }
2081
2082                 break;
2083
2084         case SIOCGIWPOWER:
2085
2086                 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
2087                 break;
2088
2089
2090         case SIOCSIWPOWER:
2091
2092                 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
2093                 break;
2094
2095
2096         case SIOCGIWSENS:
2097
2098             rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
2099                 break;
2100
2101         case SIOCSIWSENS:
2102         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
2103                 rc = -EOPNOTSUPP;
2104                 break;
2105
2106         case SIOCGIWAPLIST:
2107             {
2108             char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
2109
2110                     if (wrq->u.data.pointer) {
2111                         rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
2112                         if (rc == 0) {
2113                     if (copy_to_user(wrq->u.data.pointer,
2114                                                         buffer,
2115                                                        (wrq->u.data.length * (sizeof(struct sockaddr) +  sizeof(struct iw_quality)))
2116                                         ))
2117                                     rc = -EFAULT;
2118                         }
2119             }
2120         }
2121                 break;
2122
2123
2124 #ifdef WIRELESS_SPY
2125                 // Set the spy list
2126         case SIOCSIWSPY:
2127
2128         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
2129                 rc = -EOPNOTSUPP;
2130                 break;
2131
2132                 // Get the spy list
2133         case SIOCGIWSPY:
2134
2135         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
2136                 rc = -EOPNOTSUPP;
2137                 break;
2138
2139 #endif // WIRELESS_SPY
2140
2141         case SIOCGIWPRIV:
2142         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
2143                 rc = -EOPNOTSUPP;
2144 /*
2145                 if(wrq->u.data.pointer) {
2146                         wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
2147
2148                         if(copy_to_user(wrq->u.data.pointer,
2149                                         (u_char *) iwctl_private_args,
2150                                         sizeof(iwctl_private_args)))
2151                                 rc = -EFAULT;
2152                 }
2153 */
2154                 break;
2155
2156
2157 //#endif // WIRELESS_EXT < 13
2158
2159 //2008-0409-07, <Add> by Einsn Liu
2160 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2161         case SIOCSIWAUTH:
2162                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n");
2163                 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
2164                 break;
2165
2166         case SIOCGIWAUTH:
2167                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
2168                 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
2169                 break;
2170
2171         case SIOCSIWGENIE:
2172                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
2173                 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
2174                 break;
2175
2176         case SIOCGIWGENIE:
2177                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
2178                 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
2179                 break;
2180
2181         case SIOCSIWENCODEEXT:
2182                 {
2183                         char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
2184                         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
2185                         if(wrq->u.encoding.pointer){
2186                                 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
2187                                 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
2188                                         rc = -E2BIG;
2189                                         break;
2190                                 }
2191                                 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
2192                                         rc = -EFAULT;
2193                                         break;
2194                                 }
2195                         }else if(wrq->u.encoding.length != 0){
2196                                 rc = -EINVAL;
2197                                 break;
2198                         }
2199                         rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
2200                 }
2201                 break;
2202
2203         case SIOCGIWENCODEEXT:
2204                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
2205                 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
2206                 break;
2207
2208         case SIOCSIWMLME:
2209                 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
2210                 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
2211                 break;
2212
2213 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2214 //End Add -- //2008-0409-07, <Add> by Einsn Liu
2215
2216 #endif // WIRELESS_EXT
2217
2218     case IOCTL_CMD_TEST:
2219
2220                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2221                     rc = -EFAULT;
2222                     break;
2223                 } else {
2224                     rc = 0;
2225                 }
2226         pReq = (PSCmdRequest)rq;
2227
2228    //20080130-01,<Remark> by Mike Liu
2229       // if(pDevice->bLinkPass==TRUE)
2230           pReq->wResult = MAGIC_CODE;         //Linking status:0x3142
2231    //20080130-02,<Remark> by Mike Liu
2232       //  else
2233       //         pReq->wResult = MAGIC_CODE+1;    //disconnect status:0x3143
2234         break;
2235
2236     case IOCTL_CMD_SET:
2237                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
2238                        (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
2239                 {
2240                     rc = -EFAULT;
2241                     break;
2242                 } else {
2243                     rc = 0;
2244                 }
2245
2246             if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
2247                     return -EBUSY;
2248             }
2249         rc = private_ioctl(pDevice, rq);
2250         clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
2251         break;
2252
2253     case IOCTL_CMD_HOSTAPD:
2254
2255                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2256                     rc = -EFAULT;
2257                     break;
2258                 } else {
2259                     rc = 0;
2260                 }
2261
2262 #if WIRELESS_EXT > 8
2263                 rc = hostap_ioctl(pDevice, &wrq->u.data);
2264 #else // WIRELESS_EXT > 8
2265                 rc = hostap_ioctl(pDevice, (struct iw_point *) &wrq->u.data);
2266 #endif // WIRELESS_EXT > 8
2267         break;
2268
2269     case IOCTL_CMD_WPA:
2270
2271                 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2272                     rc = -EFAULT;
2273                     break;
2274                 } else {
2275                     rc = 0;
2276                 }
2277
2278 #if WIRELESS_EXT > 8
2279                 rc = wpa_ioctl(pDevice, &wrq->u.data);
2280 #else // WIRELESS_EXT > 8
2281                 rc = wpa_ioctl(pDevice, (struct iw_point *) &wrq->u.data);
2282 #endif // WIRELESS_EXT > 8
2283         break;
2284
2285         case SIOCETHTOOL:
2286         return ethtool_ioctl(dev, (void *) rq->ifr_data);
2287         // All other calls are currently unsupported
2288
2289         default:
2290                 rc = -EOPNOTSUPP;
2291         DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2292
2293
2294     }
2295
2296     if (pDevice->bCommit) {
2297        if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2298            netif_stop_queue(pDevice->dev);
2299            spin_lock_irq(&pDevice->lock);
2300            bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL);
2301            spin_unlock_irq(&pDevice->lock);
2302        }
2303        else {
2304            DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2305            spin_lock_irq(&pDevice->lock);
2306 //2007-1121-01<Modify>by EinsnLiu
2307             if (pDevice->bLinkPass&&
2308                   memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2309                   bScheduleCommand((HANDLE)pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2310              } else {
2311            pDevice->bLinkPass = FALSE;
2312            pMgmt->eCurrState = WMAC_STATE_IDLE;
2313            memset(pMgmt->abyCurrBSSID, 0, 6);
2314                  }
2315            ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2316 //End Modify
2317            netif_stop_queue(pDevice->dev);
2318 #ifdef  WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2319            pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2320            if(pDevice->bWPASuppWextEnabled !=TRUE)
2321 #endif
2322            bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID);
2323            bScheduleCommand((HANDLE) pDevice, WLAN_CMD_SSID, NULL);
2324            spin_unlock_irq(&pDevice->lock);
2325       }
2326       pDevice->bCommit = FALSE;
2327     }
2328
2329
2330     return rc;
2331 }
2332
2333
2334 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2335 {
2336         u32 ethcmd;
2337
2338         if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
2339                 return -EFAULT;
2340
2341         switch (ethcmd) {
2342         case ETHTOOL_GDRVINFO: {
2343                 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2344                 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2345                 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2346                 if (copy_to_user(useraddr, &info, sizeof(info)))
2347                         return -EFAULT;
2348                 return 0;
2349         }
2350
2351         }
2352
2353         return -EOPNOTSUPP;
2354 }
2355
2356
2357 /*------------------------------------------------------------------*/
2358
2359
2360 MODULE_DEVICE_TABLE(usb, vntwusb_table);
2361
2362
2363 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
2364
2365 static struct usb_driver vntwusb_driver = {
2366 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15)
2367             .owner =    THIS_MODULE,
2368 #endif
2369             .name =             DEVICE_NAME,
2370             .probe =    vntwusb_found1,
2371             .disconnect =       vntwusb_disconnect,
2372             .id_table = vntwusb_table,
2373
2374 //2008-0920-01<Add>by MikeLiu
2375 //for supporting S3 & S4 function
2376 #ifdef CONFIG_PM
2377            .suspend = vntwusb_suspend,
2378            .resume = vntwusb_resume,
2379 #endif
2380 };
2381
2382 #else
2383
2384 static struct usb_driver vntwusb_driver = {
2385             name:   DEVICE_NAME,
2386             probe:  vntwusb_found1,
2387             disconnect: vntwusb_disconnect,
2388             id_table:   vntwusb_table,
2389 };
2390
2391 #endif
2392
2393 static int __init vntwusb_init_module(void)
2394 {
2395     printk(KERN_NOTICE DEVICE_FULL_DRV_NAM " " DEVICE_VERSION);
2396     return usb_register(&vntwusb_driver);
2397 }
2398
2399 static void __exit vntwusb_cleanup_module(void)
2400 {
2401         usb_deregister(&vntwusb_driver);
2402 }
2403
2404 module_init(vntwusb_init_module);
2405 module_exit(vntwusb_cleanup_module);
2406