main_usb.c revision 5d11b1737d52b6f9428c2daea72457cd477e0122
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 unsigned char *Config_FileOperation(PSDevice pDevice); 281static int Config_FileGetParameter(unsigned char *string, 282 unsigned char *dest, 283 unsigned char *source); 284 285static BOOL device_release_WPADEV(PSDevice pDevice); 286 287static void usb_device_reset(PSDevice pDevice); 288 289 290 291/*--------------------- Export Variables --------------------------*/ 292 293/*--------------------- Export Functions --------------------------*/ 294 295 296static void 297device_set_options(PSDevice pDevice) { 298 299 BYTE abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; 300 BYTE abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00}; 301 u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8}; 302 303 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN); 304 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN); 305 memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, ETH_ALEN); 306 307 pDevice->cbTD = TX_DESC_DEF0; 308 pDevice->cbRD = RX_DESC_DEF0; 309 pDevice->uChannel = CHANNEL_DEF; 310 pDevice->wRTSThreshold = RTS_THRESH_DEF; 311 pDevice->wFragmentationThreshold = FRAG_THRESH_DEF; 312 pDevice->byShortRetryLimit = SHORT_RETRY_DEF; 313 pDevice->byLongRetryLimit = LONG_RETRY_DEF; 314 pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME; 315 pDevice->byShortPreamble = PREAMBLE_TYPE_DEF; 316 pDevice->ePSMode = PS_MODE_DEF; 317 pDevice->b11hEnable = X80211h_MODE_DEF; 318 pDevice->eOPMode = OP_MODE_DEF; 319 pDevice->uConnectionRate = DATA_RATE_DEF; 320 if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = TRUE; 321 pDevice->byBBType = BBP_TYPE_DEF; 322 pDevice->byPacketType = pDevice->byBBType; 323 pDevice->byAutoFBCtrl = AUTO_FB_0; 324 pDevice->bUpdateBBVGA = TRUE; 325 pDevice->byFOETuning = 0; 326 pDevice->byAutoPwrTunning = 0; 327 pDevice->wCTSDuration = 0; 328 pDevice->byPreambleType = 0; 329 pDevice->bExistSWNetAddr = FALSE; 330// pDevice->bDiversityRegCtlON = TRUE; 331 pDevice->bDiversityRegCtlON = FALSE; 332} 333 334 335static void device_init_diversity_timer(PSDevice pDevice) 336{ 337 init_timer(&pDevice->TimerSQ3Tmax1); 338 pDevice->TimerSQ3Tmax1.data = (unsigned long)pDevice; 339 pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack; 340 pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ); 341 342 init_timer(&pDevice->TimerSQ3Tmax2); 343 pDevice->TimerSQ3Tmax2.data = (unsigned long)pDevice; 344 pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack; 345 pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ); 346 347 init_timer(&pDevice->TimerSQ3Tmax3); 348 pDevice->TimerSQ3Tmax3.data = (unsigned long)pDevice; 349 pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerSQ3Tmax3CallBack; 350 pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ); 351 352 return; 353} 354 355 356// 357// Initialiation of MAC & BBP registers 358// 359 360static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType) 361{ 362 u8 abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; 363 u8 abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00}; 364 u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8}; 365 BYTE byAntenna; 366 unsigned int ii; 367 CMD_CARD_INIT sInitCmd; 368 int ntStatus = STATUS_SUCCESS; 369 RSP_CARD_INIT sInitRsp; 370 PSMgmtObject pMgmt = &(pDevice->sMgmtObj); 371 BYTE byTmp; 372 BYTE byCalibTXIQ = 0; 373 BYTE byCalibTXDC = 0; 374 BYTE byCalibRXIQ = 0; 375 376 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---->INIbInitAdapter. [%d][%d]\n", InitType, pDevice->byPacketType); 377 spin_lock_irq(&pDevice->lock); 378 if (InitType == DEVICE_INIT_COLD) { 379 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN); 380 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN); 381 memcpy(pDevice->abySNAP_Bridgetunnel, 382 abySNAP_Bridgetunnel, 383 ETH_ALEN); 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, 609 pDevice->abyPermanentNetAddr, 610 ETH_ALEN); 611 612 // if exist SW network address, use SW network address. 613 614 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %pM\n", 615 pDevice->abyCurrentNetAddr); 616 } 617 618 // Set BB and packet type at the same time. 619 // Set Short Slot Time, xIFS, and RSPINF. 620 if (pDevice->byBBType == BB_TYPE_11A) { 621 CARDbAddBasicRate(pDevice, RATE_6M); 622 pDevice->bShortSlotTime = TRUE; 623 } else { 624 CARDbAddBasicRate(pDevice, RATE_1M); 625 pDevice->bShortSlotTime = FALSE; 626 } 627 BBvSetShortSlotTime(pDevice); 628 CARDvSetBSSMode(pDevice); 629 630 if (pDevice->bUpdateBBVGA) { 631 pDevice->byBBVGACurrent = pDevice->abyBBVGA[0]; 632 pDevice->byBBVGANew = pDevice->byBBVGACurrent; 633 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]); 634 } 635 636 pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL]; 637 pDevice->bHWRadioOff = FALSE; 638 if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) { 639 ntStatus = CONTROLnsRequestIn(pDevice, 640 MESSAGE_TYPE_READ, 641 MAC_REG_GPIOCTL1, 642 MESSAGE_REQUEST_MACREG, 643 1, 644 &byTmp); 645 646 if ( ntStatus != STATUS_SUCCESS ) { 647 spin_unlock_irq(&pDevice->lock); 648 return FALSE; 649 } 650 if ( (byTmp & GPIO3_DATA) == 0 ) { 651 pDevice->bHWRadioOff = TRUE; 652 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD); 653 } else { 654 MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD); 655 pDevice->bHWRadioOff = FALSE; 656 } 657 658 } //EEP_RADIOCTL_ENABLE 659 660 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38); 661 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW); 662 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01); 663 664 if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) { 665 CARDbRadioPowerOff(pDevice); 666 } else { 667 CARDbRadioPowerOn(pDevice); 668 } 669 670 spin_unlock_irq(&pDevice->lock); 671 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n"); 672 return TRUE; 673} 674 675static BOOL device_release_WPADEV(PSDevice pDevice) 676{ 677 viawget_wpa_header *wpahdr; 678 int ii=0; 679 // wait_queue_head_t Set_wait; 680 //send device close to wpa_supplicnat layer 681 if (pDevice->bWPADEVUp==TRUE) { 682 wpahdr = (viawget_wpa_header *)pDevice->skb->data; 683 wpahdr->type = VIAWGET_DEVICECLOSE_MSG; 684 wpahdr->resp_ie_len = 0; 685 wpahdr->req_ie_len = 0; 686 skb_put(pDevice->skb, sizeof(viawget_wpa_header)); 687 pDevice->skb->dev = pDevice->wpadev; 688 skb_reset_mac_header(pDevice->skb); 689 pDevice->skb->pkt_type = PACKET_HOST; 690 pDevice->skb->protocol = htons(ETH_P_802_2); 691 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb)); 692 netif_rx(pDevice->skb); 693 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz); 694 695 //wait release WPADEV 696 // init_waitqueue_head(&Set_wait); 697 // wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ); //1s wait 698 while(pDevice->bWPADEVUp==TRUE) { 699 set_current_state(TASK_UNINTERRUPTIBLE); 700 schedule_timeout (HZ/20); //wait 50ms 701 ii++; 702 if(ii>20) 703 break; 704 } 705 } 706 return TRUE; 707} 708 709#ifdef CONFIG_PM /* Minimal support for suspend and resume */ 710 711static int vt6656_suspend(struct usb_interface *intf, pm_message_t message) 712{ 713 PSDevice device = usb_get_intfdata(intf); 714 715 if (!device || !device->dev) 716 return -ENODEV; 717 718 if (device->flags & DEVICE_FLAGS_OPENED) 719 device_close(device->dev); 720 721 usb_put_dev(interface_to_usbdev(intf)); 722 723 return 0; 724} 725 726static int vt6656_resume(struct usb_interface *intf) 727{ 728 PSDevice device = usb_get_intfdata(intf); 729 730 if (!device || !device->dev) 731 return -ENODEV; 732 733 usb_get_dev(interface_to_usbdev(intf)); 734 735 if (!(device->flags & DEVICE_FLAGS_OPENED)) 736 device_open(device->dev); 737 738 return 0; 739} 740 741#endif /* CONFIG_PM */ 742 743static const struct net_device_ops device_netdev_ops = { 744 .ndo_open = device_open, 745 .ndo_stop = device_close, 746 .ndo_do_ioctl = device_ioctl, 747 .ndo_get_stats = device_get_stats, 748 .ndo_start_xmit = device_xmit, 749 .ndo_set_rx_mode = device_set_multi, 750}; 751 752static int __devinit 753vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id) 754{ 755 u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01}; 756 struct usb_device *udev = interface_to_usbdev(intf); 757 int rc = 0; 758 struct net_device *netdev = NULL; 759 PSDevice pDevice = NULL; 760 761 printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION); 762 printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n"); 763 764 udev = usb_get_dev(udev); 765 netdev = alloc_etherdev(sizeof(DEVICE_INFO)); 766 if (!netdev) { 767 printk(KERN_ERR DEVICE_NAME ": allocate net device failed\n"); 768 rc = -ENOMEM; 769 goto err_nomem; 770 } 771 772 pDevice = netdev_priv(netdev); 773 memset(pDevice, 0, sizeof(DEVICE_INFO)); 774 775 pDevice->dev = netdev; 776 pDevice->usb = udev; 777 778 device_set_options(pDevice); 779 spin_lock_init(&pDevice->lock); 780 781 pDevice->tx_80211 = device_dma0_tx_80211; 782 pDevice->sMgmtObj.pAdapter = (void *) pDevice; 783 784 netdev->netdev_ops = &device_netdev_ops; 785 netdev->wireless_handlers = 786 (struct iw_handler_def *) &iwctl_handler_def; 787 788 usb_set_intfdata(intf, pDevice); 789 SET_NETDEV_DEV(netdev, &intf->dev); 790 memcpy(pDevice->dev->dev_addr, fake_mac, ETH_ALEN); 791 rc = register_netdev(netdev); 792 if (rc) { 793 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n"); 794 goto err_netdev; 795 } 796 797 usb_device_reset(pDevice); 798 799 { 800 union iwreq_data wrqu; 801 memset(&wrqu, 0, sizeof(wrqu)); 802 wrqu.data.flags = RT_INSMOD_EVENT_FLAG; 803 wrqu.data.length = IFNAMSIZ; 804 wireless_send_event(pDevice->dev, 805 IWEVCUSTOM, 806 &wrqu, 807 pDevice->dev->name); 808 } 809 810 return 0; 811 812err_netdev: 813 free_netdev(netdev); 814err_nomem: 815 usb_put_dev(udev); 816 817 return rc; 818} 819 820static void device_free_tx_bufs(PSDevice pDevice) 821{ 822 PUSB_SEND_CONTEXT pTxContext; 823 int ii; 824 825 for (ii = 0; ii < pDevice->cbTD; ii++) { 826 827 pTxContext = pDevice->apTD[ii]; 828 //de-allocate URBs 829 if (pTxContext->pUrb) { 830 usb_kill_urb(pTxContext->pUrb); 831 usb_free_urb(pTxContext->pUrb); 832 } 833 kfree(pTxContext); 834 } 835 return; 836} 837 838 839static void device_free_rx_bufs(PSDevice pDevice) 840{ 841 PRCB pRCB; 842 int ii; 843 844 for (ii = 0; ii < pDevice->cbRD; ii++) { 845 846 pRCB = pDevice->apRCB[ii]; 847 //de-allocate URBs 848 if (pRCB->pUrb) { 849 usb_kill_urb(pRCB->pUrb); 850 usb_free_urb(pRCB->pUrb); 851 } 852 //de-allocate skb 853 if (pRCB->skb) 854 dev_kfree_skb(pRCB->skb); 855 } 856 kfree(pDevice->pRCBMem); 857 858 return; 859} 860 861static void usb_device_reset(PSDevice pDevice) 862{ 863 int status; 864 status = usb_reset_device(pDevice->usb); 865 if (status) 866 printk("usb_device_reset fail status=%d\n",status); 867 return ; 868} 869 870static void device_free_int_bufs(PSDevice pDevice) 871{ 872 kfree(pDevice->intBuf.pDataBuf); 873 return; 874} 875 876 877static BOOL device_alloc_bufs(PSDevice pDevice) { 878 879 PUSB_SEND_CONTEXT pTxContext; 880 PRCB pRCB; 881 int ii; 882 883 884 for (ii = 0; ii < pDevice->cbTD; ii++) { 885 886 pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL); 887 if (pTxContext == NULL) { 888 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name); 889 goto free_tx; 890 } 891 pDevice->apTD[ii] = pTxContext; 892 pTxContext->pDevice = (void *) pDevice; 893 //allocate URBs 894 pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC); 895 if (pTxContext->pUrb == NULL) { 896 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n"); 897 goto free_tx; 898 } 899 pTxContext->bBoolInUse = FALSE; 900 } 901 902 // allocate rcb mem 903 pDevice->pRCBMem = kzalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL); 904 if (pDevice->pRCBMem == NULL) { 905 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name); 906 goto free_tx; 907 } 908 909 910 pDevice->FirstRecvFreeList = NULL; 911 pDevice->LastRecvFreeList = NULL; 912 pDevice->FirstRecvMngList = NULL; 913 pDevice->LastRecvMngList = NULL; 914 pDevice->NumRecvFreeList = 0; 915 pRCB = (PRCB) pDevice->pRCBMem; 916 917 for (ii = 0; ii < pDevice->cbRD; ii++) { 918 919 pDevice->apRCB[ii] = pRCB; 920 pRCB->pDevice = (void *) pDevice; 921 //allocate URBs 922 pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC); 923 924 if (pRCB->pUrb == NULL) { 925 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n"); 926 goto free_rx_tx; 927 } 928 pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz); 929 if (pRCB->skb == NULL) { 930 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n"); 931 goto free_rx_tx; 932 } 933 pRCB->skb->dev = pDevice->dev; 934 pRCB->bBoolInUse = FALSE; 935 EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB); 936 pDevice->NumRecvFreeList++; 937 pRCB++; 938 } 939 940 941 pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC); 942 if (pDevice->pControlURB == NULL) { 943 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n"); 944 goto free_rx_tx; 945 } 946 947 pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC); 948 if (pDevice->pInterruptURB == NULL) { 949 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n"); 950 usb_free_urb(pDevice->pControlURB); 951 goto free_rx_tx; 952 } 953 954 pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL); 955 if (pDevice->intBuf.pDataBuf == NULL) { 956 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n"); 957 usb_free_urb(pDevice->pControlURB); 958 usb_free_urb(pDevice->pInterruptURB); 959 goto free_rx_tx; 960 } 961 962 return TRUE; 963 964free_rx_tx: 965 device_free_rx_bufs(pDevice); 966 967free_tx: 968 device_free_tx_bufs(pDevice); 969 970 return FALSE; 971} 972 973 974 975 976static BOOL device_init_defrag_cb(PSDevice pDevice) { 977 int i; 978 PSDeFragControlBlock pDeF; 979 980 /* Init the fragment ctl entries */ 981 for (i = 0; i < CB_MAX_RX_FRAG; i++) { 982 pDeF = &(pDevice->sRxDFCB[i]); 983 if (!device_alloc_frag_buf(pDevice, pDeF)) { 984 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n", 985 pDevice->dev->name); 986 goto free_frag; 987 } 988 } 989 pDevice->cbDFCB = CB_MAX_RX_FRAG; 990 pDevice->cbFreeDFCB = pDevice->cbDFCB; 991 return TRUE; 992 993free_frag: 994 device_free_frag_bufs(pDevice); 995 return FALSE; 996} 997 998 999 1000static void device_free_frag_bufs(PSDevice pDevice) { 1001 PSDeFragControlBlock pDeF; 1002 int i; 1003 1004 for (i = 0; i < CB_MAX_RX_FRAG; i++) { 1005 1006 pDeF = &(pDevice->sRxDFCB[i]); 1007 1008 if (pDeF->skb) 1009 dev_kfree_skb(pDeF->skb); 1010 } 1011} 1012 1013 1014 1015BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) { 1016 1017 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz); 1018 if (pDeF->skb == NULL) 1019 return FALSE; 1020 ASSERT(pDeF->skb); 1021 pDeF->skb->dev = pDevice->dev; 1022 1023 return TRUE; 1024} 1025 1026 1027/*-----------------------------------------------------------------*/ 1028 1029static int device_open(struct net_device *dev) { 1030 PSDevice pDevice=(PSDevice) netdev_priv(dev); 1031 1032 extern SWPAResult wpa_Result; 1033 memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname)); 1034 wpa_Result.proto = 0; 1035 wpa_Result.key_mgmt = 0; 1036 wpa_Result.eap_type = 0; 1037 wpa_Result.authenticated = FALSE; 1038 pDevice->fWPA_Authened = FALSE; 1039 1040 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n"); 1041 1042 1043 pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS; 1044 1045 if (device_alloc_bufs(pDevice) == FALSE) { 1046 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n"); 1047 return -ENOMEM; 1048 } 1049 1050 if (device_init_defrag_cb(pDevice)== FALSE) { 1051 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragement cb fail \n"); 1052 goto free_rx_tx; 1053 } 1054 1055 MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED); 1056 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS); 1057 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES); 1058 MP_SET_FLAG(pDevice, fMP_POST_READS); 1059 MP_SET_FLAG(pDevice, fMP_POST_WRITES); 1060 1061 //read config file 1062 Read_config_file(pDevice); 1063 1064 if (device_init_registers(pDevice, DEVICE_INIT_COLD) == FALSE) { 1065 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n"); 1066 goto free_all; 1067 } 1068 1069 device_set_multi(pDevice->dev); 1070 // Init for Key Management 1071 1072 KeyvInitTable(pDevice,&pDevice->sKey); 1073 memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN); 1074 memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN); 1075 pDevice->bStopTx0Pkt = FALSE; 1076 pDevice->bStopDataPkt = FALSE; 1077 pDevice->bRoaming = FALSE; 1078 pDevice->bIsRoaming = FALSE; 1079 pDevice->bEnableRoaming = FALSE; 1080 if (pDevice->bDiversityRegCtlON) { 1081 device_init_diversity_timer(pDevice); 1082 } 1083 1084 vMgrObjectInit(pDevice); 1085 tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice); 1086 tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice); 1087 tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice); 1088 add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback)); 1089 pDevice->int_interval = 100; //Max 100 microframes. 1090 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled; 1091 1092 pDevice->bIsRxWorkItemQueued = TRUE; 1093 pDevice->fKillEventPollingThread = FALSE; 1094 pDevice->bEventAvailable = FALSE; 1095 1096 pDevice->bWPADEVUp = FALSE; 1097#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 1098 pDevice->bwextstep0 = FALSE; 1099 pDevice->bwextstep1 = FALSE; 1100 pDevice->bwextstep2 = FALSE; 1101 pDevice->bwextstep3 = FALSE; 1102 pDevice->bWPASuppWextEnabled = FALSE; 1103#endif 1104 pDevice->byReAssocCount = 0; 1105 1106 RXvWorkItem(pDevice); 1107 INTvWorkItem(pDevice); 1108 1109 // Patch: if WEP key already set by iwconfig but device not yet open 1110 if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) { 1111 spin_lock_irq(&pDevice->lock); 1112 KeybSetDefaultKey( pDevice, 1113 &(pDevice->sKey), 1114 pDevice->byKeyIndex | (1 << 31), 1115 pDevice->uKeyLength, 1116 NULL, 1117 pDevice->abyKey, 1118 KEY_CTL_WEP 1119 ); 1120 spin_unlock_irq(&pDevice->lock); 1121 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled; 1122 } 1123 1124 if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) { 1125 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL); 1126 } 1127 else { 1128 //mike:mark@2008-11-10 1129 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL); 1130 /* bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL); */ 1131 } 1132 1133 1134 netif_stop_queue(pDevice->dev); 1135 pDevice->flags |= DEVICE_FLAGS_OPENED; 1136 1137{ 1138 union iwreq_data wrqu; 1139 memset(&wrqu, 0, sizeof(wrqu)); 1140 wrqu.data.flags = RT_UPDEV_EVENT_FLAG; 1141 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL); 1142} 1143 1144 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n"); 1145 return 0; 1146 1147free_all: 1148 device_free_frag_bufs(pDevice); 1149free_rx_tx: 1150 device_free_rx_bufs(pDevice); 1151 device_free_tx_bufs(pDevice); 1152 device_free_int_bufs(pDevice); 1153 usb_kill_urb(pDevice->pControlURB); 1154 usb_kill_urb(pDevice->pInterruptURB); 1155 usb_free_urb(pDevice->pControlURB); 1156 usb_free_urb(pDevice->pInterruptURB); 1157 1158 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n"); 1159 return -ENOMEM; 1160} 1161 1162 1163 1164static int device_close(struct net_device *dev) { 1165 PSDevice pDevice=(PSDevice) netdev_priv(dev); 1166 PSMgmtObject pMgmt = &(pDevice->sMgmtObj); 1167 1168 int uu; 1169 1170 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n"); 1171 if (pDevice == NULL) 1172 return -ENODEV; 1173 1174{ 1175 union iwreq_data wrqu; 1176 memset(&wrqu, 0, sizeof(wrqu)); 1177 wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG; 1178 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL); 1179} 1180 1181 if (pDevice->bLinkPass) { 1182 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL); 1183 mdelay(30); 1184 } 1185 1186device_release_WPADEV(pDevice); 1187 1188 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1); 1189 pMgmt->bShareKeyAlgorithm = FALSE; 1190 pDevice->bEncryptionEnable = FALSE; 1191 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled; 1192 spin_lock_irq(&pDevice->lock); 1193 for (uu = 0; uu < MAX_KEY_TABLE; uu++) 1194 MACvDisableKeyEntry(pDevice,uu); 1195 spin_unlock_irq(&pDevice->lock); 1196 1197 if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) { 1198 MACbShutdown(pDevice); 1199 } 1200 netif_stop_queue(pDevice->dev); 1201 MP_SET_FLAG(pDevice, fMP_DISCONNECTED); 1202 MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES); 1203 MP_CLEAR_FLAG(pDevice, fMP_POST_READS); 1204 pDevice->fKillEventPollingThread = TRUE; 1205 del_timer(&pDevice->sTimerCommand); 1206 del_timer(&pMgmt->sTimerSecondCallback); 1207 1208 del_timer(&pDevice->sTimerTxData); 1209 1210 if (pDevice->bDiversityRegCtlON) { 1211 del_timer(&pDevice->TimerSQ3Tmax1); 1212 del_timer(&pDevice->TimerSQ3Tmax2); 1213 del_timer(&pDevice->TimerSQ3Tmax3); 1214 } 1215 tasklet_kill(&pDevice->RxMngWorkItem); 1216 tasklet_kill(&pDevice->ReadWorkItem); 1217 tasklet_kill(&pDevice->EventWorkItem); 1218 1219 pDevice->bRoaming = FALSE; 1220 pDevice->bIsRoaming = FALSE; 1221 pDevice->bEnableRoaming = FALSE; 1222 pDevice->bCmdRunning = FALSE; 1223 pDevice->bLinkPass = FALSE; 1224 memset(pMgmt->abyCurrBSSID, 0, 6); 1225 pMgmt->eCurrState = WMAC_STATE_IDLE; 1226 1227 device_free_tx_bufs(pDevice); 1228 device_free_rx_bufs(pDevice); 1229 device_free_int_bufs(pDevice); 1230 device_free_frag_bufs(pDevice); 1231 1232 usb_kill_urb(pDevice->pControlURB); 1233 usb_kill_urb(pDevice->pInterruptURB); 1234 usb_free_urb(pDevice->pControlURB); 1235 usb_free_urb(pDevice->pInterruptURB); 1236 1237 BSSvClearNodeDBTable(pDevice, 0); 1238 pDevice->flags &=(~DEVICE_FLAGS_OPENED); 1239 1240 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n"); 1241 1242 return 0; 1243} 1244 1245static void __devexit vt6656_disconnect(struct usb_interface *intf) 1246{ 1247 PSDevice device = usb_get_intfdata(intf); 1248 1249 if (!device) 1250 return; 1251 1252 { 1253 union iwreq_data req; 1254 memset(&req, 0, sizeof(req)); 1255 req.data.flags = RT_RMMOD_EVENT_FLAG; 1256 wireless_send_event(device->dev, IWEVCUSTOM, &req, NULL); 1257 } 1258 1259 device_release_WPADEV(device); 1260 1261 if (device->firmware) 1262 release_firmware(device->firmware); 1263 1264 usb_set_intfdata(intf, NULL); 1265 usb_put_dev(interface_to_usbdev(intf)); 1266 1267 device->flags |= DEVICE_FLAGS_UNPLUG; 1268 1269 if (device->dev) { 1270 unregister_netdev(device->dev); 1271 wpa_set_wpadev(device, 0); 1272 free_netdev(device->dev); 1273 } 1274} 1275 1276static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev) 1277{ 1278 PSDevice pDevice = netdev_priv(dev); 1279 1280 spin_lock_irq(&pDevice->lock); 1281 1282 if (unlikely(pDevice->bStopTx0Pkt)) 1283 dev_kfree_skb_irq(skb); 1284 else 1285 vDMA0_tx_80211(pDevice, skb); 1286 1287 spin_unlock_irq(&pDevice->lock); 1288 1289 return NETDEV_TX_OK; 1290} 1291 1292static int device_xmit(struct sk_buff *skb, struct net_device *dev) 1293{ 1294 PSDevice pDevice = netdev_priv(dev); 1295 struct net_device_stats *stats = &pDevice->stats; 1296 1297 spin_lock_irq(&pDevice->lock); 1298 1299 netif_stop_queue(dev); 1300 1301 if (!pDevice->bLinkPass) { 1302 dev_kfree_skb_irq(skb); 1303 goto out; 1304 } 1305 1306 if (pDevice->bStopDataPkt) { 1307 dev_kfree_skb_irq(skb); 1308 stats->tx_dropped++; 1309 goto out; 1310 } 1311 1312 if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) { 1313 if (netif_queue_stopped(dev)) 1314 netif_wake_queue(dev); 1315 } 1316 1317out: 1318 spin_unlock_irq(&pDevice->lock); 1319 1320 return NETDEV_TX_OK; 1321} 1322 1323static unsigned const ethernet_polynomial = 0x04c11db7U; 1324static inline u32 ether_crc(int length, unsigned char *data) 1325{ 1326 int crc = -1; 1327 1328 while(--length >= 0) { 1329 unsigned char current_octet = *data++; 1330 int bit; 1331 for (bit = 0; bit < 8; bit++, current_octet >>= 1) { 1332 crc = (crc << 1) ^ 1333 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0); 1334 } 1335 } 1336 return crc; 1337} 1338 1339//find out the start position of str2 from str1 1340static unsigned char *kstrstr(const unsigned char *str1, 1341 const unsigned char *str2) { 1342 int str1_len = strlen(str1); 1343 int str2_len = strlen(str2); 1344 1345 while (str1_len >= str2_len) { 1346 str1_len--; 1347 if(memcmp(str1,str2,str2_len)==0) 1348 return (unsigned char *) str1; 1349 str1++; 1350 } 1351 return NULL; 1352} 1353 1354static int Config_FileGetParameter(unsigned char *string, 1355 unsigned char *dest, 1356 unsigned char *source) 1357{ 1358 unsigned char buf1[100]; 1359 unsigned char buf2[100]; 1360 unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL; 1361 int ii; 1362 1363 memset(buf1,0,100); 1364 strcat(buf1, string); 1365 strcat(buf1, "="); 1366 source+=strlen(buf1); 1367 1368//find target string start point 1369 start_p = kstrstr(source,buf1); 1370 if (start_p == NULL) 1371 return FALSE; 1372 1373//check if current config line is marked by "#" ?? 1374 for (ii = 1; ; ii++) { 1375 if (memcmp(start_p - ii, "\n", 1) == 0) 1376 break; 1377 if (memcmp(start_p - ii, "#", 1) == 0) 1378 return FALSE; 1379 } 1380 1381//find target string end point 1382 end_p = kstrstr(start_p,"\n"); 1383 if (end_p == NULL) { //can't find "\n",but don't care 1384 end_p=start_p+strlen(start_p); //no include "\n" 1385 } 1386 1387 memset(buf2,0,100); 1388 memcpy(buf2,start_p,end_p-start_p); //get the tartget line 1389 buf2[end_p-start_p]='\0'; 1390 1391 //find value 1392 start_p = kstrstr(buf2,"="); 1393 if (start_p == NULL) 1394 return FALSE; 1395 memset(buf1,0,100); 1396 strcpy(buf1,start_p+1); 1397 1398 //except space 1399 tmp_p = buf1; 1400 while(*tmp_p != 0x00) { 1401 if(*tmp_p==' ') 1402 tmp_p++; 1403 else 1404 break; 1405 } 1406 1407 memcpy(dest,tmp_p,strlen(tmp_p)); 1408 return TRUE; 1409} 1410 1411//if read fail,return NULL,or return data pointer; 1412static unsigned char *Config_FileOperation(PSDevice pDevice) 1413{ 1414 unsigned char *config_path = CONFIG_PATH; 1415 unsigned char *buffer = NULL; 1416 struct file *filp=NULL; 1417 mm_segment_t old_fs = get_fs(); 1418 //int oldfsuid=0,oldfsgid=0; 1419 int result = 0; 1420 1421 set_fs (KERNEL_DS); 1422 /* Can't do this anymore, so we rely on correct filesystem permissions: 1423 //Make sure a caller can read or write power as root 1424 oldfsuid=current->fsuid; 1425 oldfsgid=current->fsgid; 1426 current->fsuid = 0; 1427 current->fsgid = 0; 1428 */ 1429 1430 //open file 1431 filp = filp_open(config_path, O_RDWR, 0); 1432 if (IS_ERR(filp)) { 1433 printk("Config_FileOperation file Not exist\n"); 1434 result=-1; 1435 goto error2; 1436 } 1437 1438 if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) { 1439 printk("file %s cann't readable or writable?\n",config_path); 1440 result = -1; 1441 goto error1; 1442 } 1443 1444 buffer = kmalloc(1024, GFP_KERNEL); 1445 if(buffer==NULL) { 1446 printk("allocate mem for file fail?\n"); 1447 result = -1; 1448 goto error1; 1449 } 1450 1451 if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) { 1452 printk("read file error?\n"); 1453 result = -1; 1454 } 1455 1456error1: 1457 if(filp_close(filp,NULL)) 1458 printk("Config_FileOperation:close file fail\n"); 1459 1460error2: 1461 set_fs (old_fs); 1462 1463 /* 1464 current->fsuid=oldfsuid; 1465 current->fsgid=oldfsgid; 1466 */ 1467 1468if(result!=0) { 1469 kfree(buffer); 1470 buffer=NULL; 1471} 1472 return buffer; 1473} 1474 1475//return --->-1:fail; >=0:successful 1476static int Read_config_file(PSDevice pDevice) { 1477 int result = 0; 1478 unsigned char tmpbuffer[100]; 1479 unsigned char *buffer = NULL; 1480 1481 //init config setting 1482 pDevice->config_file.ZoneType = -1; 1483 pDevice->config_file.eAuthenMode = -1; 1484 pDevice->config_file.eEncryptionStatus = -1; 1485 1486 buffer = Config_FileOperation(pDevice); 1487 if (buffer == NULL) { 1488 result =-1; 1489 return result; 1490 } 1491 1492//get zonetype 1493{ 1494 memset(tmpbuffer,0,sizeof(tmpbuffer)); 1495 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) { 1496 if(memcmp(tmpbuffer,"USA",3)==0) { 1497 pDevice->config_file.ZoneType=ZoneType_USA; 1498 } 1499 else if(memcmp(tmpbuffer,"JAPAN",5)==0) { 1500 pDevice->config_file.ZoneType=ZoneType_Japan; 1501 } 1502 else if(memcmp(tmpbuffer,"EUROPE",6)==0) { 1503 pDevice->config_file.ZoneType=ZoneType_Europe; 1504 } 1505 else { 1506 printk("Unknown Zonetype[%s]?\n",tmpbuffer); 1507 } 1508 } 1509} 1510 1511//get other parameter 1512 { 1513 memset(tmpbuffer,0,sizeof(tmpbuffer)); 1514 if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) { 1515 pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10); 1516 } 1517 1518 memset(tmpbuffer,0,sizeof(tmpbuffer)); 1519 if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) { 1520 pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10); 1521 } 1522 } 1523 1524 kfree(buffer); 1525 return result; 1526} 1527 1528static void device_set_multi(struct net_device *dev) { 1529 PSDevice pDevice = (PSDevice) netdev_priv(dev); 1530 PSMgmtObject pMgmt = &(pDevice->sMgmtObj); 1531 u32 mc_filter[2]; 1532 int ii; 1533 struct netdev_hw_addr *ha; 1534 BYTE pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff}; 1535 BYTE byTmpMode = 0; 1536 int rc; 1537 1538 1539 spin_lock_irq(&pDevice->lock); 1540 rc = CONTROLnsRequestIn(pDevice, 1541 MESSAGE_TYPE_READ, 1542 MAC_REG_RCR, 1543 MESSAGE_REQUEST_MACREG, 1544 1, 1545 &byTmpMode 1546 ); 1547 if (rc == 0) pDevice->byRxMode = byTmpMode; 1548 1549 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode); 1550 1551 if (dev->flags & IFF_PROMISC) { // Set promiscuous. 1552 DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name); 1553 // Unconditionally log net taps. 1554 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST); 1555 } 1556 else if ((netdev_mc_count(dev) > pDevice->multicast_limit) || 1557 (dev->flags & IFF_ALLMULTI)) { 1558 CONTROLnsRequestOut(pDevice, 1559 MESSAGE_TYPE_WRITE, 1560 MAC_REG_MAR0, 1561 MESSAGE_REQUEST_MACREG, 1562 8, 1563 pbyData 1564 ); 1565 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST); 1566 } 1567 else { 1568 memset(mc_filter, 0, sizeof(mc_filter)); 1569 netdev_for_each_mc_addr(ha, dev) { 1570 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26; 1571 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31)); 1572 } 1573 for (ii = 0; ii < 4; ii++) { 1574 MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii)); 1575 MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii)); 1576 } 1577 pDevice->byRxMode &= ~(RCR_UNICAST); 1578 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST); 1579 } 1580 1581 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) { 1582 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac. 1583 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST); 1584 pDevice->byRxMode &= ~(RCR_UNICAST); 1585 } 1586 ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode); 1587 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode); 1588 spin_unlock_irq(&pDevice->lock); 1589 1590} 1591 1592 1593static struct net_device_stats *device_get_stats(struct net_device *dev) { 1594 PSDevice pDevice=(PSDevice) netdev_priv(dev); 1595 1596 return &pDevice->stats; 1597} 1598 1599 1600static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) { 1601 PSDevice pDevice = (PSDevice)netdev_priv(dev); 1602 PSMgmtObject pMgmt = &(pDevice->sMgmtObj); 1603 PSCmdRequest pReq; 1604 //BOOL bCommit = FALSE; 1605 struct iwreq *wrq = (struct iwreq *) rq; 1606 int rc =0; 1607 1608 if (pMgmt == NULL) { 1609 rc = -EFAULT; 1610 return rc; 1611 } 1612 1613 switch(cmd) { 1614 1615 case SIOCGIWNAME: 1616 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL); 1617 break; 1618 1619 case SIOCSIWNWID: 1620 case SIOCGIWNWID: //0x8b03 support 1621 rc = -EOPNOTSUPP; 1622 break; 1623 1624 // Set frequency/channel 1625 case SIOCSIWFREQ: 1626 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL); 1627 break; 1628 1629 // Get frequency/channel 1630 case SIOCGIWFREQ: 1631 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL); 1632 break; 1633 1634 // Set desired network name (ESSID) 1635 case SIOCSIWESSID: 1636 1637 { 1638 char essid[IW_ESSID_MAX_SIZE+1]; 1639 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) { 1640 rc = -E2BIG; 1641 break; 1642 } 1643 if (copy_from_user(essid, wrq->u.essid.pointer, 1644 wrq->u.essid.length)) { 1645 rc = -EFAULT; 1646 break; 1647 } 1648 rc = iwctl_siwessid(dev, NULL, 1649 &(wrq->u.essid), essid); 1650 } 1651 break; 1652 1653 1654 // Get current network name (ESSID) 1655 case SIOCGIWESSID: 1656 1657 { 1658 char essid[IW_ESSID_MAX_SIZE+1]; 1659 if (wrq->u.essid.pointer) { 1660 rc = iwctl_giwessid(dev, NULL, 1661 &(wrq->u.essid), essid); 1662 if (copy_to_user(wrq->u.essid.pointer, 1663 essid, 1664 wrq->u.essid.length) ) 1665 rc = -EFAULT; 1666 } 1667 } 1668 break; 1669 1670 case SIOCSIWAP: 1671 1672 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL); 1673 break; 1674 1675 1676 // Get current Access Point (BSSID) 1677 case SIOCGIWAP: 1678 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL); 1679 break; 1680 1681 1682 // Set desired station name 1683 case SIOCSIWNICKN: 1684 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n"); 1685 rc = -EOPNOTSUPP; 1686 break; 1687 1688 // Get current station name 1689 case SIOCGIWNICKN: 1690 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n"); 1691 rc = -EOPNOTSUPP; 1692 break; 1693 1694 // Set the desired bit-rate 1695 case SIOCSIWRATE: 1696 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL); 1697 break; 1698 1699 // Get the current bit-rate 1700 case SIOCGIWRATE: 1701 1702 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL); 1703 break; 1704 1705 // Set the desired RTS threshold 1706 case SIOCSIWRTS: 1707 1708 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL); 1709 break; 1710 1711 // Get the current RTS threshold 1712 case SIOCGIWRTS: 1713 1714 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL); 1715 break; 1716 1717 // Set the desired fragmentation threshold 1718 case SIOCSIWFRAG: 1719 1720 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL); 1721 break; 1722 1723 // Get the current fragmentation threshold 1724 case SIOCGIWFRAG: 1725 1726 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL); 1727 break; 1728 1729 // Set mode of operation 1730 case SIOCSIWMODE: 1731 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL); 1732 break; 1733 1734 // Get mode of operation 1735 case SIOCGIWMODE: 1736 iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL); 1737 break; 1738 1739 // Set WEP keys and mode 1740 case SIOCSIWENCODE: 1741 { 1742 char abyKey[WLAN_WEP232_KEYLEN]; 1743 1744 if (wrq->u.encoding.pointer) { 1745 1746 1747 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) { 1748 rc = -E2BIG; 1749 break; 1750 } 1751 memset(abyKey, 0, WLAN_WEP232_KEYLEN); 1752 if (copy_from_user(abyKey, 1753 wrq->u.encoding.pointer, 1754 wrq->u.encoding.length)) { 1755 rc = -EFAULT; 1756 break; 1757 } 1758 } else if (wrq->u.encoding.length != 0) { 1759 rc = -EINVAL; 1760 break; 1761 } 1762 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey); 1763 } 1764 break; 1765 1766 // Get the WEP keys and mode 1767 case SIOCGIWENCODE: 1768 1769 if (!capable(CAP_NET_ADMIN)) { 1770 rc = -EPERM; 1771 break; 1772 } 1773 { 1774 char abyKey[WLAN_WEP232_KEYLEN]; 1775 1776 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey); 1777 if (rc != 0) break; 1778 if (wrq->u.encoding.pointer) { 1779 if (copy_to_user(wrq->u.encoding.pointer, 1780 abyKey, 1781 wrq->u.encoding.length)) 1782 rc = -EFAULT; 1783 } 1784 } 1785 break; 1786 1787 // Get the current Tx-Power 1788 case SIOCGIWTXPOW: 1789 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n"); 1790 rc = -EOPNOTSUPP; 1791 break; 1792 1793 case SIOCSIWTXPOW: 1794 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n"); 1795 rc = -EOPNOTSUPP; 1796 break; 1797 1798 case SIOCSIWRETRY: 1799 1800 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL); 1801 break; 1802 1803 case SIOCGIWRETRY: 1804 1805 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL); 1806 break; 1807 1808 // Get range of parameters 1809 case SIOCGIWRANGE: 1810 1811 { 1812 struct iw_range range; 1813 1814 rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range); 1815 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range))) 1816 rc = -EFAULT; 1817 } 1818 1819 break; 1820 1821 case SIOCGIWPOWER: 1822 1823 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL); 1824 break; 1825 1826 1827 case SIOCSIWPOWER: 1828 1829 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL); 1830 break; 1831 1832 1833 case SIOCGIWSENS: 1834 1835 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL); 1836 break; 1837 1838 case SIOCSIWSENS: 1839 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n"); 1840 rc = -EOPNOTSUPP; 1841 break; 1842 1843 case SIOCGIWAPLIST: 1844 { 1845 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))]; 1846 1847 if (wrq->u.data.pointer) { 1848 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer); 1849 if (rc == 0) { 1850 if (copy_to_user(wrq->u.data.pointer, 1851 buffer, 1852 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality))) 1853 )) 1854 rc = -EFAULT; 1855 } 1856 } 1857 } 1858 break; 1859 1860 1861#ifdef WIRELESS_SPY 1862 // Set the spy list 1863 case SIOCSIWSPY: 1864 1865 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n"); 1866 rc = -EOPNOTSUPP; 1867 break; 1868 1869 // Get the spy list 1870 case SIOCGIWSPY: 1871 1872 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n"); 1873 rc = -EOPNOTSUPP; 1874 break; 1875 1876#endif // WIRELESS_SPY 1877 1878 case SIOCGIWPRIV: 1879 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n"); 1880 rc = -EOPNOTSUPP; 1881/* 1882 if(wrq->u.data.pointer) { 1883 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]); 1884 1885 if(copy_to_user(wrq->u.data.pointer, 1886 (u_char *) iwctl_private_args, 1887 sizeof(iwctl_private_args))) 1888 rc = -EFAULT; 1889 } 1890*/ 1891 break; 1892 1893#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 1894 case SIOCSIWAUTH: 1895 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH\n"); 1896 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL); 1897 break; 1898 1899 case SIOCGIWAUTH: 1900 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n"); 1901 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL); 1902 break; 1903 1904 case SIOCSIWGENIE: 1905 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n"); 1906 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer); 1907 break; 1908 1909 case SIOCGIWGENIE: 1910 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n"); 1911 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer); 1912 break; 1913 1914 case SIOCSIWENCODEEXT: 1915 { 1916 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1]; 1917 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n"); 1918 if(wrq->u.encoding.pointer){ 1919 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1); 1920 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){ 1921 rc = -E2BIG; 1922 break; 1923 } 1924 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){ 1925 rc = -EFAULT; 1926 break; 1927 } 1928 }else if(wrq->u.encoding.length != 0){ 1929 rc = -EINVAL; 1930 break; 1931 } 1932 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra); 1933 } 1934 break; 1935 1936 case SIOCGIWENCODEEXT: 1937 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n"); 1938 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL); 1939 break; 1940 1941 case SIOCSIWMLME: 1942 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n"); 1943 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer); 1944 break; 1945 1946#endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 1947 1948 case IOCTL_CMD_TEST: 1949 1950 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) { 1951 rc = -EFAULT; 1952 break; 1953 } else { 1954 rc = 0; 1955 } 1956 pReq = (PSCmdRequest)rq; 1957 1958 //20080130-01,<Remark> by Mike Liu 1959 // if(pDevice->bLinkPass==TRUE) 1960 pReq->wResult = MAGIC_CODE; //Linking status:0x3142 1961 //20080130-02,<Remark> by Mike Liu 1962 // else 1963 // pReq->wResult = MAGIC_CODE+1; //disconnect status:0x3143 1964 break; 1965 1966 case IOCTL_CMD_SET: 1967 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) && 1968 (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA)) 1969 { 1970 rc = -EFAULT; 1971 break; 1972 } else { 1973 rc = 0; 1974 } 1975 1976 if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) { 1977 return -EBUSY; 1978 } 1979 rc = private_ioctl(pDevice, rq); 1980 clear_bit( 0, (void*)&(pMgmt->uCmdBusy)); 1981 break; 1982 1983 case IOCTL_CMD_HOSTAPD: 1984 1985 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) { 1986 rc = -EFAULT; 1987 break; 1988 } else { 1989 rc = 0; 1990 } 1991 1992 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data); 1993 break; 1994 1995 case IOCTL_CMD_WPA: 1996 1997 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) { 1998 rc = -EFAULT; 1999 break; 2000 } else { 2001 rc = 0; 2002 } 2003 2004 rc = wpa_ioctl(pDevice, &wrq->u.data); 2005 break; 2006 2007 case SIOCETHTOOL: 2008 return ethtool_ioctl(dev, (void *) rq->ifr_data); 2009 // All other calls are currently unsupported 2010 2011 default: 2012 rc = -EOPNOTSUPP; 2013 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd); 2014 2015 2016 } 2017 2018 if (pDevice->bCommit) { 2019 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) { 2020 netif_stop_queue(pDevice->dev); 2021 spin_lock_irq(&pDevice->lock); 2022 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL); 2023 spin_unlock_irq(&pDevice->lock); 2024 } 2025 else { 2026 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n"); 2027 spin_lock_irq(&pDevice->lock); 2028//2007-1121-01<Modify>by EinsnLiu 2029 if (pDevice->bLinkPass && 2030 memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) { 2031 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL); 2032 } else { 2033 pDevice->bLinkPass = FALSE; 2034 pMgmt->eCurrState = WMAC_STATE_IDLE; 2035 memset(pMgmt->abyCurrBSSID, 0, 6); 2036 } 2037 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW); 2038//End Modify 2039 netif_stop_queue(pDevice->dev); 2040#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 2041 pMgmt->eScanType = WMAC_SCAN_ACTIVE; 2042 if (!pDevice->bWPASuppWextEnabled) 2043#endif 2044 bScheduleCommand((void *) pDevice, 2045 WLAN_CMD_BSSID_SCAN, 2046 pMgmt->abyDesireSSID); 2047 bScheduleCommand((void *) pDevice, 2048 WLAN_CMD_SSID, 2049 NULL); 2050 spin_unlock_irq(&pDevice->lock); 2051 } 2052 pDevice->bCommit = FALSE; 2053 } 2054 2055 2056 return rc; 2057} 2058 2059 2060static int ethtool_ioctl(struct net_device *dev, void *useraddr) 2061{ 2062 u32 ethcmd; 2063 2064 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd))) 2065 return -EFAULT; 2066 2067 switch (ethcmd) { 2068 case ETHTOOL_GDRVINFO: { 2069 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO}; 2070 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1); 2071 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1); 2072 if (copy_to_user(useraddr, &info, sizeof(info))) 2073 return -EFAULT; 2074 return 0; 2075 } 2076 2077 } 2078 2079 return -EOPNOTSUPP; 2080} 2081 2082 2083/*------------------------------------------------------------------*/ 2084 2085MODULE_DEVICE_TABLE(usb, vt6656_table); 2086 2087static struct usb_driver vt6656_driver = { 2088 .name = DEVICE_NAME, 2089 .probe = vt6656_probe, 2090 .disconnect = vt6656_disconnect, 2091 .id_table = vt6656_table, 2092#ifdef CONFIG_PM 2093 .suspend = vt6656_suspend, 2094 .resume = vt6656_resume, 2095#endif /* CONFIG_PM */ 2096}; 2097 2098module_usb_driver(vt6656_driver); 2099