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