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