device_main.c revision d59079425f6f1be0da995926b5ad1d54d9e4545d
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: device_main.c 20 * 21 * Purpose: driver entry for initial, open, close, tx and rx. 22 * 23 * Author: Lyndon Chen 24 * 25 * Date: Jan 8, 2003 26 * 27 * Functions: 28 * 29 * device_found1 - module initial (insmod) driver entry 30 * device_remove1 - module remove entry 31 * device_init_info - device structure resource allocation function 32 * device_free_info - device structure resource free function 33 * device_get_pci_info - get allocated pci io/mem resource 34 * device_print_info - print out resource 35 * device_open - allocate dma/descripter resource & initial mac/bbp function 36 * device_xmit - asynchrous data tx function 37 * device_intr - interrupt handle function 38 * device_set_multi - set mac filter 39 * device_ioctl - ioctl entry 40 * device_close - shutdown mac/bbp & free dma/descripter resource 41 * device_rx_srv - rx service function 42 * device_receive_frame - rx data function 43 * device_alloc_rx_buf - rx buffer pre-allocated function 44 * device_alloc_frag_buf - rx fragement pre-allocated function 45 * device_free_tx_buf - free tx buffer function 46 * device_free_frag_buf- free de-fragement buffer 47 * device_dma0_tx_80211- tx 802.11 frame via dma0 48 * device_dma0_xmit- tx PS bufferred frame via dma0 49 * device_init_rd0_ring- initial rd dma0 ring 50 * device_init_rd1_ring- initial rd dma1 ring 51 * device_init_td0_ring- initial tx dma0 ring buffer 52 * device_init_td1_ring- initial tx dma1 ring buffer 53 * device_init_registers- initial MAC & BBP & RF internal registers. 54 * device_init_rings- initial tx/rx ring buffer 55 * device_init_defrag_cb- initial & allocate de-fragement buffer. 56 * device_free_rings- free all allocated ring buffer 57 * device_tx_srv- tx interrupt service function 58 * 59 * Revision History: 60 */ 61#undef __NO_VERSION__ 62 63#include "device.h" 64#include "card.h" 65#include "baseband.h" 66#include "mac.h" 67#include "tether.h" 68#include "wmgr.h" 69#include "wctl.h" 70#include "power.h" 71#include "wcmd.h" 72#include "iocmd.h" 73#include "tcrc.h" 74#include "rxtx.h" 75#include "wroute.h" 76#include "bssdb.h" 77#include "hostap.h" 78#include "wpactl.h" 79#include "ioctl.h" 80#include "iwctl.h" 81#include "dpc.h" 82#include "datarate.h" 83#include "rf.h" 84#include "iowpa.h" 85#include <linux/delay.h> 86#include <linux/kthread.h> 87 88//#define DEBUG 89/*--------------------- Static Definitions -------------------------*/ 90//static int msglevel =MSG_LEVEL_DEBUG; 91static int msglevel = MSG_LEVEL_INFO; 92 93//#define PLICE_DEBUG 94// 95// Define module options 96// 97MODULE_AUTHOR("VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>"); 98MODULE_LICENSE("GPL"); 99MODULE_DESCRIPTION("VIA Networking Solomon-A/B/G Wireless LAN Adapter Driver"); 100 101//PLICE_DEBUG -> 102 static int mlme_kill; 103 //static struct task_struct * mlme_task; 104//PLICE_DEBUG <- 105 106#define DEVICE_PARAM(N,D) 107/* 108 static const int N[MAX_UINTS]=OPTION_DEFAULT;\ 109 MODULE_PARM(N, "1-" __MODULE_STRING(MAX_UINTS) "i");\ 110 MODULE_PARM_DESC(N, D); 111*/ 112 113#define RX_DESC_MIN0 16 114#define RX_DESC_MAX0 128 115#define RX_DESC_DEF0 32 116DEVICE_PARAM(RxDescriptors0,"Number of receive descriptors0"); 117 118#define RX_DESC_MIN1 16 119#define RX_DESC_MAX1 128 120#define RX_DESC_DEF1 32 121DEVICE_PARAM(RxDescriptors1,"Number of receive descriptors1"); 122 123#define TX_DESC_MIN0 16 124#define TX_DESC_MAX0 128 125#define TX_DESC_DEF0 32 126DEVICE_PARAM(TxDescriptors0,"Number of transmit descriptors0"); 127 128#define TX_DESC_MIN1 16 129#define TX_DESC_MAX1 128 130#define TX_DESC_DEF1 64 131DEVICE_PARAM(TxDescriptors1,"Number of transmit descriptors1"); 132 133 134#define IP_ALIG_DEF 0 135/* IP_byte_align[] is used for IP header DWORD byte aligned 136 0: indicate the IP header won't be DWORD byte aligned.(Default) . 137 1: indicate the IP header will be DWORD byte aligned. 138 In some enviroment, the IP header should be DWORD byte aligned, 139 or the packet will be droped when we receive it. (eg: IPVS) 140*/ 141DEVICE_PARAM(IP_byte_align,"Enable IP header dword aligned"); 142 143 144#define INT_WORKS_DEF 20 145#define INT_WORKS_MIN 10 146#define INT_WORKS_MAX 64 147 148DEVICE_PARAM(int_works,"Number of packets per interrupt services"); 149 150#define CHANNEL_MIN 1 151#define CHANNEL_MAX 14 152#define CHANNEL_DEF 6 153 154DEVICE_PARAM(Channel, "Channel number"); 155 156 157/* PreambleType[] is the preamble length used for transmit. 158 0: indicate allows long preamble type 159 1: indicate allows short preamble type 160*/ 161 162#define PREAMBLE_TYPE_DEF 1 163 164DEVICE_PARAM(PreambleType, "Preamble Type"); 165 166 167#define RTS_THRESH_MIN 512 168#define RTS_THRESH_MAX 2347 169#define RTS_THRESH_DEF 2347 170 171DEVICE_PARAM(RTSThreshold, "RTS threshold"); 172 173 174#define FRAG_THRESH_MIN 256 175#define FRAG_THRESH_MAX 2346 176#define FRAG_THRESH_DEF 2346 177 178DEVICE_PARAM(FragThreshold, "Fragmentation threshold"); 179 180 181#define DATA_RATE_MIN 0 182#define DATA_RATE_MAX 13 183#define DATA_RATE_DEF 13 184/* datarate[] index 185 0: indicate 1 Mbps 0x02 186 1: indicate 2 Mbps 0x04 187 2: indicate 5.5 Mbps 0x0B 188 3: indicate 11 Mbps 0x16 189 4: indicate 6 Mbps 0x0c 190 5: indicate 9 Mbps 0x12 191 6: indicate 12 Mbps 0x18 192 7: indicate 18 Mbps 0x24 193 8: indicate 24 Mbps 0x30 194 9: indicate 36 Mbps 0x48 195 10: indicate 48 Mbps 0x60 196 11: indicate 54 Mbps 0x6c 197 12: indicate 72 Mbps 0x90 198 13: indicate auto rate 199*/ 200 201DEVICE_PARAM(ConnectionRate, "Connection data rate"); 202 203#define OP_MODE_DEF 0 204 205DEVICE_PARAM(OPMode, "Infrastruct, adhoc, AP mode "); 206 207/* OpMode[] is used for transmit. 208 0: indicate infrastruct mode used 209 1: indicate adhoc mode used 210 2: indicate AP mode used 211*/ 212 213 214/* PSMode[] 215 0: indicate disable power saving mode 216 1: indicate enable power saving mode 217*/ 218 219#define PS_MODE_DEF 0 220 221DEVICE_PARAM(PSMode, "Power saving mode"); 222 223 224#define SHORT_RETRY_MIN 0 225#define SHORT_RETRY_MAX 31 226#define SHORT_RETRY_DEF 8 227 228 229DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits"); 230 231#define LONG_RETRY_MIN 0 232#define LONG_RETRY_MAX 15 233#define LONG_RETRY_DEF 4 234 235 236DEVICE_PARAM(LongRetryLimit, "long frame retry limits"); 237 238 239/* BasebandType[] baseband type selected 240 0: indicate 802.11a type 241 1: indicate 802.11b type 242 2: indicate 802.11g type 243*/ 244#define BBP_TYPE_MIN 0 245#define BBP_TYPE_MAX 2 246#define BBP_TYPE_DEF 2 247 248DEVICE_PARAM(BasebandType, "baseband type"); 249 250 251 252/* 80211hEnable[] 253 0: indicate disable 802.11h 254 1: indicate enable 802.11h 255*/ 256 257#define X80211h_MODE_DEF 0 258 259DEVICE_PARAM(b80211hEnable, "802.11h mode"); 260 261/* 80211hEnable[] 262 0: indicate disable 802.11h 263 1: indicate enable 802.11h 264*/ 265 266#define DIVERSITY_ANT_DEF 0 267 268DEVICE_PARAM(bDiversityANTEnable, "ANT diversity mode"); 269 270 271// 272// Static vars definitions 273// 274 275 276static int device_nics =0; 277static PSDevice pDevice_Infos =NULL; 278static struct net_device *root_device_dev = NULL; 279 280static CHIP_INFO chip_info_table[]= { 281 { VT3253, "VIA Networking Solomon-A/B/G Wireless LAN Adapter ", 282 256, 1, DEVICE_FLAGS_IP_ALIGN|DEVICE_FLAGS_TX_ALIGN }, 283 {0,NULL} 284}; 285 286DEFINE_PCI_DEVICE_TABLE(device_id_table) = { 287 { PCI_VDEVICE(VIA, 0x3253), (kernel_ulong_t)chip_info_table}, 288 { 0, } 289}; 290 291/*--------------------- Static Functions --------------------------*/ 292 293 294static int device_found1(struct pci_dev *pcid, const struct pci_device_id *ent); 295static BOOL device_init_info(struct pci_dev* pcid, PSDevice* ppDevice, PCHIP_INFO); 296static void device_free_info(PSDevice pDevice); 297static BOOL device_get_pci_info(PSDevice, struct pci_dev* pcid); 298static void device_print_info(PSDevice pDevice); 299static struct net_device_stats *device_get_stats(struct net_device *dev); 300static void device_init_diversity_timer(PSDevice pDevice); 301static int device_open(struct net_device *dev); 302static int device_xmit(struct sk_buff *skb, struct net_device *dev); 303static irqreturn_t device_intr(int irq, void*dev_instance); 304static void device_set_multi(struct net_device *dev); 305static int device_close(struct net_device *dev); 306static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); 307 308#ifdef CONFIG_PM 309static int device_notify_reboot(struct notifier_block *, unsigned long event, void *ptr); 310static int viawget_suspend(struct pci_dev *pcid, pm_message_t state); 311static int viawget_resume(struct pci_dev *pcid); 312struct notifier_block device_notifier = { 313 notifier_call: device_notify_reboot, 314 next: NULL, 315 priority: 0 316}; 317#endif 318 319 320static void device_init_rd0_ring(PSDevice pDevice); 321static void device_init_rd1_ring(PSDevice pDevice); 322static void device_init_defrag_cb(PSDevice pDevice); 323static void device_init_td0_ring(PSDevice pDevice); 324static void device_init_td1_ring(PSDevice pDevice); 325 326static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev); 327//2008-0714<Add>by Mike Liu 328static BOOL device_release_WPADEV(PSDevice pDevice); 329 330static int ethtool_ioctl(struct net_device *dev, void *useraddr); 331static int device_rx_srv(PSDevice pDevice, UINT uIdx); 332static int device_tx_srv(PSDevice pDevice, UINT uIdx); 333static BOOL device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pDesc); 334static void device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType); 335static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc); 336static void device_free_td0_ring(PSDevice pDevice); 337static void device_free_td1_ring(PSDevice pDevice); 338static void device_free_rd0_ring(PSDevice pDevice); 339static void device_free_rd1_ring(PSDevice pDevice); 340static void device_free_rings(PSDevice pDevice); 341static void device_free_frag_buf(PSDevice pDevice); 342static int Config_FileGetParameter(UCHAR *string, UCHAR *dest,UCHAR *source); 343 344 345/*--------------------- Export Variables --------------------------*/ 346 347/*--------------------- Export Functions --------------------------*/ 348 349 350 351static char* get_chip_name(int chip_id) { 352 int i; 353 for (i=0;chip_info_table[i].name!=NULL;i++) 354 if (chip_info_table[i].chip_id==chip_id) 355 break; 356 return chip_info_table[i].name; 357} 358 359static void device_remove1(struct pci_dev *pcid) 360{ 361 PSDevice pDevice=pci_get_drvdata(pcid); 362 363 if (pDevice==NULL) 364 return; 365 device_free_info(pDevice); 366 367} 368 369/* 370static void 371device_set_int_opt(int *opt, int val, int min, int max, int def,char* name,char* devname) { 372 if (val==-1) 373 *opt=def; 374 else if (val<min || val>max) { 375 DBG_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: the value of parameter %s is invalid, the valid range is (%d-%d)\n" , 376 devname,name, min,max); 377 *opt=def; 378 } else { 379 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: set value of parameter %s to %d\n", 380 devname, name, val); 381 *opt=val; 382 } 383} 384 385static void 386device_set_bool_opt(unsigned int *opt, int val,BOOL def,U32 flag, char* name,char* devname) { 387 (*opt)&=(~flag); 388 if (val==-1) 389 *opt|=(def ? flag : 0); 390 else if (val<0 || val>1) { 391 DBG_PRT(MSG_LEVEL_INFO, KERN_NOTICE 392 "%s: the value of parameter %s is invalid, the valid range is (0-1)\n",devname,name); 393 *opt|=(def ? flag : 0); 394 } else { 395 DBG_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: set parameter %s to %s\n", 396 devname,name , val ? "TRUE" : "FALSE"); 397 *opt|=(val ? flag : 0); 398 } 399} 400*/ 401static void 402device_get_options(PSDevice pDevice, int index, char* devname) { 403 404 POPTIONS pOpts = &(pDevice->sOpts); 405 pOpts->nRxDescs0=RX_DESC_DEF0; 406 pOpts->nRxDescs1=RX_DESC_DEF1; 407 pOpts->nTxDescs[0]=TX_DESC_DEF0; 408 pOpts->nTxDescs[1]=TX_DESC_DEF1; 409pOpts->flags|=DEVICE_FLAGS_IP_ALIGN; 410 pOpts->int_works=INT_WORKS_DEF; 411 pOpts->rts_thresh=RTS_THRESH_DEF; 412 pOpts->frag_thresh=FRAG_THRESH_DEF; 413 pOpts->data_rate=DATA_RATE_DEF; 414 pOpts->channel_num=CHANNEL_DEF; 415 416pOpts->flags|=DEVICE_FLAGS_PREAMBLE_TYPE; 417pOpts->flags|=DEVICE_FLAGS_OP_MODE; 418//pOpts->flags|=DEVICE_FLAGS_PS_MODE; 419 pOpts->short_retry=SHORT_RETRY_DEF; 420 pOpts->long_retry=LONG_RETRY_DEF; 421 pOpts->bbp_type=BBP_TYPE_DEF; 422pOpts->flags|=DEVICE_FLAGS_80211h_MODE; 423pOpts->flags|=DEVICE_FLAGS_DiversityANT; 424 425 426} 427 428static void 429device_set_options(PSDevice pDevice) { 430 431 BYTE abyBroadcastAddr[U_ETHER_ADDR_LEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; 432 BYTE abySNAP_RFC1042[U_ETHER_ADDR_LEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00}; 433 BYTE abySNAP_Bridgetunnel[U_ETHER_ADDR_LEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8}; 434 435 436 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, U_ETHER_ADDR_LEN); 437 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, U_ETHER_ADDR_LEN); 438 memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, U_ETHER_ADDR_LEN); 439 440 pDevice->uChannel = pDevice->sOpts.channel_num; 441 pDevice->wRTSThreshold = pDevice->sOpts.rts_thresh; 442 pDevice->wFragmentationThreshold = pDevice->sOpts.frag_thresh; 443 pDevice->byShortRetryLimit = pDevice->sOpts.short_retry; 444 pDevice->byLongRetryLimit = pDevice->sOpts.long_retry; 445 pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME; 446 pDevice->byShortPreamble = (pDevice->sOpts.flags & DEVICE_FLAGS_PREAMBLE_TYPE) ? 1 : 0; 447 pDevice->byOpMode = (pDevice->sOpts.flags & DEVICE_FLAGS_OP_MODE) ? 1 : 0; 448 pDevice->ePSMode = (pDevice->sOpts.flags & DEVICE_FLAGS_PS_MODE) ? 1 : 0; 449 pDevice->b11hEnable = (pDevice->sOpts.flags & DEVICE_FLAGS_80211h_MODE) ? 1 : 0; 450 pDevice->bDiversityRegCtlON = (pDevice->sOpts.flags & DEVICE_FLAGS_DiversityANT) ? 1 : 0; 451 pDevice->uConnectionRate = pDevice->sOpts.data_rate; 452 if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = TRUE; 453 pDevice->byBBType = pDevice->sOpts.bbp_type; 454 pDevice->byPacketType = pDevice->byBBType; 455 456//PLICE_DEBUG-> 457 pDevice->byAutoFBCtrl = AUTO_FB_0; 458 //pDevice->byAutoFBCtrl = AUTO_FB_1; 459//PLICE_DEBUG<- 460pDevice->bUpdateBBVGA = TRUE; 461 pDevice->byFOETuning = 0; 462 pDevice->wCTSDuration = 0; 463 pDevice->byPreambleType = 0; 464 465 466 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" uChannel= %d\n",(INT)pDevice->uChannel); 467 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byOpMode= %d\n",(INT)pDevice->byOpMode); 468 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" ePSMode= %d\n",(INT)pDevice->ePSMode); 469 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" wRTSThreshold= %d\n",(INT)pDevice->wRTSThreshold); 470 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byShortRetryLimit= %d\n",(INT)pDevice->byShortRetryLimit); 471 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byLongRetryLimit= %d\n",(INT)pDevice->byLongRetryLimit); 472 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byPreambleType= %d\n",(INT)pDevice->byPreambleType); 473 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byShortPreamble= %d\n",(INT)pDevice->byShortPreamble); 474 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" uConnectionRate= %d\n",(INT)pDevice->uConnectionRate); 475 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byBBType= %d\n",(INT)pDevice->byBBType); 476 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" pDevice->b11hEnable= %d\n",(INT)pDevice->b11hEnable); 477 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" pDevice->bDiversityRegCtlON= %d\n",(INT)pDevice->bDiversityRegCtlON); 478} 479 480static VOID s_vCompleteCurrentMeasure (IN PSDevice pDevice, IN BYTE byResult) 481{ 482 UINT ii; 483 DWORD dwDuration = 0; 484 BYTE byRPI0 = 0; 485 486 for(ii=1;ii<8;ii++) { 487 pDevice->dwRPIs[ii] *= 255; 488 dwDuration |= *((PWORD) (pDevice->pCurrMeasureEID->sReq.abyDuration)); 489 dwDuration <<= 10; 490 pDevice->dwRPIs[ii] /= dwDuration; 491 pDevice->abyRPIs[ii] = (BYTE) pDevice->dwRPIs[ii]; 492 byRPI0 += pDevice->abyRPIs[ii]; 493 } 494 pDevice->abyRPIs[0] = (0xFF - byRPI0); 495 496 if (pDevice->uNumOfMeasureEIDs == 0) { 497 VNTWIFIbMeasureReport( pDevice->pMgmt, 498 TRUE, 499 pDevice->pCurrMeasureEID, 500 byResult, 501 pDevice->byBasicMap, 502 pDevice->byCCAFraction, 503 pDevice->abyRPIs 504 ); 505 } else { 506 VNTWIFIbMeasureReport( pDevice->pMgmt, 507 FALSE, 508 pDevice->pCurrMeasureEID, 509 byResult, 510 pDevice->byBasicMap, 511 pDevice->byCCAFraction, 512 pDevice->abyRPIs 513 ); 514 CARDbStartMeasure (pDevice, pDevice->pCurrMeasureEID++, pDevice->uNumOfMeasureEIDs); 515 } 516 517} 518 519 520 521// 522// Initialiation of MAC & BBP registers 523// 524 525static void device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType) 526{ 527 UINT ii; 528 BYTE byValue; 529 BYTE byValue1; 530 BYTE byCCKPwrdBm = 0; 531 BYTE byOFDMPwrdBm = 0; 532 INT zonetype=0; 533 PSMgmtObject pMgmt = &(pDevice->sMgmtObj); 534 MACbShutdown(pDevice->PortOffset); 535 BBvSoftwareReset(pDevice->PortOffset); 536 537 if ((InitType == DEVICE_INIT_COLD) || 538 (InitType == DEVICE_INIT_DXPL)) { 539 // Do MACbSoftwareReset in MACvInitialize 540 MACbSoftwareReset(pDevice->PortOffset); 541 // force CCK 542 pDevice->bCCK = TRUE; 543 pDevice->bAES = FALSE; 544 pDevice->bProtectMode = FALSE; //Only used in 11g type, sync with ERP IE 545 pDevice->bNonERPPresent = FALSE; 546 pDevice->bBarkerPreambleMd = FALSE; 547 pDevice->wCurrentRate = RATE_1M; 548 pDevice->byTopOFDMBasicRate = RATE_24M; 549 pDevice->byTopCCKBasicRate = RATE_1M; 550 551 pDevice->byRevId = 0; //Target to IF pin while programming to RF chip. 552 553 // init MAC 554 MACvInitialize(pDevice->PortOffset); 555 556 // Get Local ID 557 VNSvInPortB(pDevice->PortOffset + MAC_REG_LOCALID, &(pDevice->byLocalID)); 558 559 spin_lock_irq(&pDevice->lock); 560 SROMvReadAllContents(pDevice->PortOffset,pDevice->abyEEPROM); 561 562 spin_unlock_irq(&pDevice->lock); 563 564 // Get Channel range 565 566 pDevice->byMinChannel = 1; 567 pDevice->byMaxChannel = CB_MAX_CHANNEL; 568 569 // Get Antena 570 byValue = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ANTENNA); 571 if (byValue & EEP_ANTINV) 572 pDevice->bTxRxAntInv = TRUE; 573 else 574 pDevice->bTxRxAntInv = FALSE; 575#ifdef PLICE_DEBUG 576 //printk("init_register:TxRxAntInv is %d,byValue is %d\n",pDevice->bTxRxAntInv,byValue); 577#endif 578 579 byValue &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN); 580 if (byValue == 0) // if not set default is All 581 byValue = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN); 582#ifdef PLICE_DEBUG 583 //printk("init_register:byValue is %d\n",byValue); 584#endif 585 pDevice->ulDiversityNValue = 100*260;//100*SROMbyReadEmbedded(pDevice->PortOffset, 0x51); 586 pDevice->ulDiversityMValue = 100*16;//SROMbyReadEmbedded(pDevice->PortOffset, 0x52); 587 pDevice->byTMax = 1;//SROMbyReadEmbedded(pDevice->PortOffset, 0x53); 588 pDevice->byTMax2 = 4;//SROMbyReadEmbedded(pDevice->PortOffset, 0x54); 589 pDevice->ulSQ3TH = 0;//(ULONG) SROMbyReadEmbedded(pDevice->PortOffset, 0x55); 590 pDevice->byTMax3 = 64;//SROMbyReadEmbedded(pDevice->PortOffset, 0x56); 591 592 if (byValue == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) { 593 pDevice->byAntennaCount = 2; 594 pDevice->byTxAntennaMode = ANT_B; 595 pDevice->dwTxAntennaSel = 1; 596 pDevice->dwRxAntennaSel = 1; 597 if (pDevice->bTxRxAntInv == TRUE) 598 pDevice->byRxAntennaMode = ANT_A; 599 else 600 pDevice->byRxAntennaMode = ANT_B; 601 // chester for antenna 602byValue1 = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ANTENNA); 603 // if (pDevice->bDiversityRegCtlON) 604 if((byValue1&0x08)==0) 605 pDevice->bDiversityEnable = FALSE;//SROMbyReadEmbedded(pDevice->PortOffset, 0x50); 606 else 607 pDevice->bDiversityEnable = TRUE; 608#ifdef PLICE_DEBUG 609 //printk("aux |main antenna: RxAntennaMode is %d\n",pDevice->byRxAntennaMode); 610#endif 611 } else { 612 pDevice->bDiversityEnable = FALSE; 613 pDevice->byAntennaCount = 1; 614 pDevice->dwTxAntennaSel = 0; 615 pDevice->dwRxAntennaSel = 0; 616 if (byValue & EEP_ANTENNA_AUX) { 617 pDevice->byTxAntennaMode = ANT_A; 618 if (pDevice->bTxRxAntInv == TRUE) 619 pDevice->byRxAntennaMode = ANT_B; 620 else 621 pDevice->byRxAntennaMode = ANT_A; 622 } else { 623 pDevice->byTxAntennaMode = ANT_B; 624 if (pDevice->bTxRxAntInv == TRUE) 625 pDevice->byRxAntennaMode = ANT_A; 626 else 627 pDevice->byRxAntennaMode = ANT_B; 628 } 629 } 630#ifdef PLICE_DEBUG 631 //printk("init registers: TxAntennaMode is %d\n",pDevice->byTxAntennaMode); 632#endif 633 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "bDiversityEnable=[%d],NValue=[%d],MValue=[%d],TMax=[%d],TMax2=[%d]\n", 634 pDevice->bDiversityEnable,(int)pDevice->ulDiversityNValue,(int)pDevice->ulDiversityMValue,pDevice->byTMax,pDevice->byTMax2); 635 636//#ifdef ZoneType_DefaultSetting 637//2008-8-4 <add> by chester 638//zonetype initial 639 pDevice->byOriginalZonetype = pDevice->abyEEPROM[EEP_OFS_ZONETYPE]; 640 if((zonetype=Config_FileOperation(pDevice,FALSE,NULL)) >= 0) { //read zonetype file ok! 641 if ((zonetype == 0)&& 642 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] !=0x00)){ //for USA 643 pDevice->abyEEPROM[EEP_OFS_ZONETYPE] = 0; 644 pDevice->abyEEPROM[EEP_OFS_MAXCHANNEL] = 0x0B; 645 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Init Zone Type :USA\n"); 646 } 647 else if((zonetype == 1)&& 648 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE]!=0x01)){ //for Japan 649 pDevice->abyEEPROM[EEP_OFS_ZONETYPE] = 0x01; 650 pDevice->abyEEPROM[EEP_OFS_MAXCHANNEL] = 0x0D; 651 } 652 else if((zonetype == 2)&& 653 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE]!=0x02)){ //for Europe 654 pDevice->abyEEPROM[EEP_OFS_ZONETYPE] = 0x02; 655 pDevice->abyEEPROM[EEP_OFS_MAXCHANNEL] = 0x0D; 656 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Init Zone Type :Europe\n"); 657 } 658 659else 660{ 661 if(zonetype!=pDevice->abyEEPROM[EEP_OFS_ZONETYPE]) 662 printk("zonetype in file[%02x] mismatch with in EEPROM[%02x]\n",zonetype,pDevice->abyEEPROM[EEP_OFS_ZONETYPE]); 663 else 664 printk("Read Zonetype file success,use default zonetype setting[%02x]\n",zonetype); 665 } 666 } 667 else 668 printk("Read Zonetype file fail,use default zonetype setting[%02x]\n",SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ZONETYPE)); 669 670 // Get RFType 671 pDevice->byRFType = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RFTYPE); 672 673 if ((pDevice->byRFType & RF_EMU) != 0) { 674 // force change RevID for VT3253 emu 675 pDevice->byRevId = 0x80; 676 } 677 678 pDevice->byRFType &= RF_MASK; 679 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRFType = %x\n", pDevice->byRFType); 680 681 if (pDevice->bZoneRegExist == FALSE) { 682 pDevice->byZoneType = pDevice->abyEEPROM[EEP_OFS_ZONETYPE]; 683 } 684 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byZoneType = %x\n", pDevice->byZoneType); 685 686 //Init RF module 687 RFbInit(pDevice); 688 689 //Get Desire Power Value 690 pDevice->byCurPwr = 0xFF; 691 pDevice->byCCKPwr = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_PWR_CCK); 692 pDevice->byOFDMPwrG = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_PWR_OFDMG); 693 //byCCKPwrdBm = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_CCK_PWR_dBm); 694 695 //byOFDMPwrdBm = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_OFDM_PWR_dBm); 696//printk("CCKPwrdBm is 0x%x,byOFDMPwrdBm is 0x%x\n",byCCKPwrdBm,byOFDMPwrdBm); 697 // Load power Table 698 699 700 for (ii=0;ii<CB_MAX_CHANNEL_24G;ii++) { 701 pDevice->abyCCKPwrTbl[ii+1] = SROMbyReadEmbedded(pDevice->PortOffset, (BYTE)(ii + EEP_OFS_CCK_PWR_TBL)); 702 if (pDevice->abyCCKPwrTbl[ii+1] == 0) { 703 pDevice->abyCCKPwrTbl[ii+1] = pDevice->byCCKPwr; 704 } 705 pDevice->abyOFDMPwrTbl[ii+1] = SROMbyReadEmbedded(pDevice->PortOffset, (BYTE)(ii + EEP_OFS_OFDM_PWR_TBL)); 706 if (pDevice->abyOFDMPwrTbl[ii+1] == 0) { 707 pDevice->abyOFDMPwrTbl[ii+1] = pDevice->byOFDMPwrG; 708 } 709 pDevice->abyCCKDefaultPwr[ii+1] = byCCKPwrdBm; 710 pDevice->abyOFDMDefaultPwr[ii+1] = byOFDMPwrdBm; 711 } 712 //2008-8-4 <add> by chester 713 //recover 12,13 ,14channel for EUROPE by 11 channel 714 if(((pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Japan) || 715 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Europe))&& 716 (pDevice->byOriginalZonetype == ZoneType_USA)) { 717 for(ii=11;ii<14;ii++) { 718 pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10]; 719 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10]; 720 721 } 722 } 723 724 725 // Load OFDM A Power Table 726 for (ii=0;ii<CB_MAX_CHANNEL_5G;ii++) { //RobertYu:20041224, bug using CB_MAX_CHANNEL 727 pDevice->abyOFDMPwrTbl[ii+CB_MAX_CHANNEL_24G+1] = SROMbyReadEmbedded(pDevice->PortOffset, (BYTE)(ii + EEP_OFS_OFDMA_PWR_TBL)); 728 pDevice->abyOFDMDefaultPwr[ii+CB_MAX_CHANNEL_24G+1] = SROMbyReadEmbedded(pDevice->PortOffset, (BYTE)(ii + EEP_OFS_OFDMA_PWR_dBm)); 729 } 730 CARDvInitChannelTable((PVOID)pDevice); 731 732 733 if (pDevice->byLocalID > REV_ID_VT3253_B1) { 734 MACvSelectPage1(pDevice->PortOffset); 735 VNSvOutPortB(pDevice->PortOffset + MAC_REG_MSRCTL + 1, (MSRCTL1_TXPWR | MSRCTL1_CSAPAREN)); 736 MACvSelectPage0(pDevice->PortOffset); 737 } 738 739 740 // use relative tx timeout and 802.11i D4 741 MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_CFG, (CFG_TKIPOPT | CFG_NOTXTIMEOUT)); 742 743 // set performance parameter by registry 744 MACvSetShortRetryLimit(pDevice->PortOffset, pDevice->byShortRetryLimit); 745 MACvSetLongRetryLimit(pDevice->PortOffset, pDevice->byLongRetryLimit); 746 747 // reset TSF counter 748 VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST); 749 // enable TSF counter 750 VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN); 751 752 // initialize BBP registers 753 BBbVT3253Init(pDevice); 754 755 if (pDevice->bUpdateBBVGA) { 756 pDevice->byBBVGACurrent = pDevice->abyBBVGA[0]; 757 pDevice->byBBVGANew = pDevice->byBBVGACurrent; 758 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]); 759 } 760#ifdef PLICE_DEBUG 761 //printk("init registers:RxAntennaMode is %x,TxAntennaMode is %x\n",pDevice->byRxAntennaMode,pDevice->byTxAntennaMode); 762#endif 763 BBvSetRxAntennaMode(pDevice->PortOffset, pDevice->byRxAntennaMode); 764 BBvSetTxAntennaMode(pDevice->PortOffset, pDevice->byTxAntennaMode); 765 766 pDevice->byCurrentCh = 0; 767 768 //pDevice->NetworkType = Ndis802_11Automode; 769 // Set BB and packet type at the same time. 770 // Set Short Slot Time, xIFS, and RSPINF. 771 if (pDevice->uConnectionRate == RATE_AUTO) { 772 pDevice->wCurrentRate = RATE_54M; 773 } else { 774 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate; 775 } 776 777 // default G Mode 778 VNTWIFIbConfigPhyMode(pDevice->pMgmt, PHY_TYPE_11G); 779 VNTWIFIbConfigPhyMode(pDevice->pMgmt, PHY_TYPE_AUTO); 780 781 pDevice->bRadioOff = FALSE; 782 783 pDevice->byRadioCtl = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RADIOCTL); 784 pDevice->bHWRadioOff = FALSE; 785 786 if (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) { 787 // Get GPIO 788 MACvGPIOIn(pDevice->PortOffset, &pDevice->byGPIO); 789//2008-4-14 <add> by chester for led issue 790 #ifdef FOR_LED_ON_NOTEBOOK 791if (pDevice->byGPIO & GPIO0_DATA){pDevice->bHWRadioOff = TRUE;} 792if ( !(pDevice->byGPIO & GPIO0_DATA)){pDevice->bHWRadioOff = FALSE;} 793 794 } 795 if ( (pDevice->bRadioControlOff == TRUE)) { 796 CARDbRadioPowerOff(pDevice); 797 } 798else CARDbRadioPowerOn(pDevice); 799#else 800 if (((pDevice->byGPIO & GPIO0_DATA) && !(pDevice->byRadioCtl & EEP_RADIOCTL_INV)) || 801 ( !(pDevice->byGPIO & GPIO0_DATA) && (pDevice->byRadioCtl & EEP_RADIOCTL_INV))) { 802 pDevice->bHWRadioOff = TRUE; 803 } 804 } 805 if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) { 806 CARDbRadioPowerOff(pDevice); 807 } 808 809#endif 810 } 811 pMgmt->eScanType = WMAC_SCAN_PASSIVE; 812 // get Permanent network address 813 SROMvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr); 814 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %02x-%02x-%02x=%02x-%02x-%02x\n", 815 pDevice->abyCurrentNetAddr[0], 816 pDevice->abyCurrentNetAddr[1], 817 pDevice->abyCurrentNetAddr[2], 818 pDevice->abyCurrentNetAddr[3], 819 pDevice->abyCurrentNetAddr[4], 820 pDevice->abyCurrentNetAddr[5]); 821 822 823 // reset Tx pointer 824 CARDvSafeResetRx(pDevice); 825 // reset Rx pointer 826 CARDvSafeResetTx(pDevice); 827 828 if (pDevice->byLocalID <= REV_ID_VT3253_A1) { 829 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_RCR, RCR_WPAERR); 830 } 831 832 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled; 833 834 // Turn On Rx DMA 835 MACvReceive0(pDevice->PortOffset); 836 MACvReceive1(pDevice->PortOffset); 837 838 // start the adapter 839 MACvStart(pDevice->PortOffset); 840 841 netif_stop_queue(pDevice->dev); 842 843 844} 845 846 847 848static VOID device_init_diversity_timer(PSDevice pDevice) { 849 850 init_timer(&pDevice->TimerSQ3Tmax1); 851 pDevice->TimerSQ3Tmax1.data = (ULONG)pDevice; 852 pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack; 853 pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ); 854 855 init_timer(&pDevice->TimerSQ3Tmax2); 856 pDevice->TimerSQ3Tmax2.data = (ULONG)pDevice; 857 pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack; 858 pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ); 859 860 init_timer(&pDevice->TimerSQ3Tmax3); 861 pDevice->TimerSQ3Tmax3.data = (ULONG)pDevice; 862 pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerState1CallBack; 863 pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ); 864 865 return; 866} 867 868 869static BOOL device_release_WPADEV(PSDevice pDevice) 870{ 871 viawget_wpa_header *wpahdr; 872 int ii=0; 873 // wait_queue_head_t Set_wait; 874 //send device close to wpa_supplicnat layer 875 if (pDevice->bWPADEVUp==TRUE) { 876 wpahdr = (viawget_wpa_header *)pDevice->skb->data; 877 wpahdr->type = VIAWGET_DEVICECLOSE_MSG; 878 wpahdr->resp_ie_len = 0; 879 wpahdr->req_ie_len = 0; 880 skb_put(pDevice->skb, sizeof(viawget_wpa_header)); 881 pDevice->skb->dev = pDevice->wpadev; 882 skb_reset_mac_header(pDevice->skb); 883 pDevice->skb->pkt_type = PACKET_HOST; 884 pDevice->skb->protocol = htons(ETH_P_802_2); 885 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb)); 886 netif_rx(pDevice->skb); 887 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz); 888 889 //wait release WPADEV 890 // init_waitqueue_head(&Set_wait); 891 // wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ); //1s wait 892 while((pDevice->bWPADEVUp==TRUE)) { 893 set_current_state(TASK_UNINTERRUPTIBLE); 894 schedule_timeout (HZ/20); //wait 50ms 895 ii++; 896 if(ii>20) 897 break; 898 } 899 }; 900 return TRUE; 901} 902 903 904static const struct net_device_ops device_netdev_ops = { 905 .ndo_open = device_open, 906 .ndo_stop = device_close, 907 .ndo_do_ioctl = device_ioctl, 908 .ndo_get_stats = device_get_stats, 909 .ndo_start_xmit = device_xmit, 910 .ndo_set_multicast_list = device_set_multi, 911}; 912 913 914 915static int 916device_found1(struct pci_dev *pcid, const struct pci_device_id *ent) 917{ 918 static BOOL bFirst = TRUE; 919 struct net_device* dev = NULL; 920 PCHIP_INFO pChip_info = (PCHIP_INFO)ent->driver_data; 921 PSDevice pDevice; 922 int rc; 923 if (device_nics ++>= MAX_UINTS) { 924 printk(KERN_NOTICE DEVICE_NAME ": already found %d NICs\n", device_nics); 925 return -ENODEV; 926 } 927 928 929 dev = alloc_etherdev(sizeof(DEVICE_INFO)); 930 931 pDevice = (PSDevice) netdev_priv(dev); 932 933 if (dev == NULL) { 934 printk(KERN_ERR DEVICE_NAME ": allocate net device failed \n"); 935 return -ENODEV; 936 } 937 938 // Chain it all together 939 // SET_MODULE_OWNER(dev); 940 SET_NETDEV_DEV(dev, &pcid->dev); 941 942 if (bFirst) { 943 printk(KERN_NOTICE "%s Ver. %s\n",DEVICE_FULL_DRV_NAM, DEVICE_VERSION); 944 printk(KERN_NOTICE "Copyright (c) 2003 VIA Networking Technologies, Inc.\n"); 945 bFirst=FALSE; 946 } 947 948 if (!device_init_info(pcid, &pDevice, pChip_info)) { 949 return -ENOMEM; 950 } 951 pDevice->dev = dev; 952 pDevice->next_module = root_device_dev; 953 root_device_dev = dev; 954 dev->irq = pcid->irq; 955 956 if (pci_enable_device(pcid)) { 957 device_free_info(pDevice); 958 return -ENODEV; 959 } 960#ifdef DEBUG 961 printk("Before get pci_info memaddr is %x\n",pDevice->memaddr); 962#endif 963 if (device_get_pci_info(pDevice,pcid) == FALSE) { 964 printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device.\n"); 965 device_free_info(pDevice); 966 return -ENODEV; 967 } 968 969#if 1 970 971#ifdef DEBUG 972 973 //pci_read_config_byte(pcid, PCI_BASE_ADDRESS_0, &pDevice->byRevId); 974 printk("after get pci_info memaddr is %x, io addr is %x,io_size is %d\n",pDevice->memaddr,pDevice->ioaddr,pDevice->io_size); 975 { 976 int i; 977 U32 bar,len; 978 u32 address[] = { 979 PCI_BASE_ADDRESS_0, 980 PCI_BASE_ADDRESS_1, 981 PCI_BASE_ADDRESS_2, 982 PCI_BASE_ADDRESS_3, 983 PCI_BASE_ADDRESS_4, 984 PCI_BASE_ADDRESS_5, 985 0}; 986 for (i=0;address[i];i++) 987 { 988 //pci_write_config_dword(pcid,address[i], 0xFFFFFFFF); 989 pci_read_config_dword(pcid, address[i], &bar); 990 printk("bar %d is %x\n",i,bar); 991 if (!bar) 992 { 993 printk("bar %d not implemented\n",i); 994 continue; 995 } 996 if (bar & PCI_BASE_ADDRESS_SPACE_IO) { 997 /* This is IO */ 998 999 len = bar & (PCI_BASE_ADDRESS_IO_MASK & 0xFFFF); 1000 len = len & ~(len - 1); 1001 1002 printk("IO space: len in IO %x, BAR %d\n", len, i); 1003 } 1004 else 1005 { 1006 len = bar & 0xFFFFFFF0; 1007 len = ~len + 1; 1008 1009 printk("len in MEM %x, BAR %d\n", len, i); 1010 } 1011 } 1012 } 1013#endif 1014 1015 1016#endif 1017 1018#ifdef DEBUG 1019 //return 0 ; 1020#endif 1021 pDevice->PortOffset = (DWORD)ioremap(pDevice->memaddr & PCI_BASE_ADDRESS_MEM_MASK, pDevice->io_size); 1022 //pDevice->PortOffset = (DWORD)ioremap(pDevice->ioaddr & PCI_BASE_ADDRESS_IO_MASK, pDevice->io_size); 1023 1024 if(pDevice->PortOffset == 0) { 1025 printk(KERN_ERR DEVICE_NAME ": Failed to IO remapping ..\n"); 1026 device_free_info(pDevice); 1027 return -ENODEV; 1028 } 1029 1030 1031 1032 1033 rc = pci_request_regions(pcid, DEVICE_NAME); 1034 if (rc) { 1035 printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device\n"); 1036 device_free_info(pDevice); 1037 return -ENODEV; 1038 } 1039 1040 dev->base_addr = pDevice->ioaddr; 1041#ifdef PLICE_DEBUG 1042 BYTE value; 1043 1044 VNSvInPortB(pDevice->PortOffset+0x4F, &value); 1045 printk("Before write: value is %x\n",value); 1046 //VNSvInPortB(pDevice->PortOffset+0x3F, 0x00); 1047 VNSvOutPortB(pDevice->PortOffset,value); 1048 VNSvInPortB(pDevice->PortOffset+0x4F, &value); 1049 printk("After write: value is %x\n",value); 1050#endif 1051 1052 1053 1054#ifdef IO_MAP 1055 pDevice->PortOffset = pDevice->ioaddr; 1056#endif 1057 // do reset 1058 if (!MACbSoftwareReset(pDevice->PortOffset)) { 1059 printk(KERN_ERR DEVICE_NAME ": Failed to access MAC hardware..\n"); 1060 device_free_info(pDevice); 1061 return -ENODEV; 1062 } 1063 // initial to reload eeprom 1064 MACvInitialize(pDevice->PortOffset); 1065 MACvReadEtherAddress(pDevice->PortOffset, dev->dev_addr); 1066 1067 device_get_options(pDevice, device_nics-1, dev->name); 1068 device_set_options(pDevice); 1069 //Mask out the options cannot be set to the chip 1070 pDevice->sOpts.flags &= pChip_info->flags; 1071 1072 //Enable the chip specified capbilities 1073 pDevice->flags = pDevice->sOpts.flags | (pChip_info->flags & 0xFF000000UL); 1074 pDevice->tx_80211 = device_dma0_tx_80211; 1075 pDevice->sMgmtObj.pAdapter = (PVOID)pDevice; 1076 pDevice->pMgmt = &(pDevice->sMgmtObj); 1077 1078 dev->irq = pcid->irq; 1079 dev->netdev_ops = &device_netdev_ops; 1080 1081 dev->wireless_handlers = (struct iw_handler_def *)&iwctl_handler_def; 1082 1083 rc = register_netdev(dev); 1084 if (rc) 1085 { 1086 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n"); 1087 device_free_info(pDevice); 1088 return -ENODEV; 1089 } 1090//2008-07-21-01<Add>by MikeLiu 1091//register wpadev 1092 if(wpa_set_wpadev(pDevice, 1)!=0) { 1093 printk("Fail to Register WPADEV?\n"); 1094 unregister_netdev(pDevice->dev); 1095 free_netdev(dev); 1096 } 1097 device_print_info(pDevice); 1098 pci_set_drvdata(pcid, pDevice); 1099 return 0; 1100 1101} 1102 1103static void device_print_info(PSDevice pDevice) 1104{ 1105 struct net_device* dev=pDevice->dev; 1106 1107 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: %s\n",dev->name, get_chip_name(pDevice->chip_id)); 1108 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: MAC=%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X", 1109 dev->name, 1110 dev->dev_addr[0],dev->dev_addr[1],dev->dev_addr[2], 1111 dev->dev_addr[3],dev->dev_addr[4],dev->dev_addr[5]); 1112#ifdef IO_MAP 1113 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IO=0x%lx ",(ULONG) pDevice->ioaddr); 1114 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IRQ=%d \n", pDevice->dev->irq); 1115#else 1116 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IO=0x%lx Mem=0x%lx ",(ULONG) pDevice->ioaddr,(ULONG) pDevice->PortOffset); 1117 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IRQ=%d \n", pDevice->dev->irq); 1118#endif 1119 1120} 1121 1122static BOOL device_init_info(struct pci_dev* pcid, PSDevice* ppDevice, 1123 PCHIP_INFO pChip_info) { 1124 1125 PSDevice p; 1126 1127 memset(*ppDevice,0,sizeof(DEVICE_INFO)); 1128 1129 if (pDevice_Infos == NULL) { 1130 pDevice_Infos =*ppDevice; 1131 } 1132 else { 1133 for (p=pDevice_Infos;p->next!=NULL;p=p->next) 1134 do {} while (0); 1135 p->next = *ppDevice; 1136 (*ppDevice)->prev = p; 1137 } 1138 1139 (*ppDevice)->pcid = pcid; 1140 (*ppDevice)->chip_id = pChip_info->chip_id; 1141 (*ppDevice)->io_size = pChip_info->io_size; 1142 (*ppDevice)->nTxQueues = pChip_info->nTxQueue; 1143 (*ppDevice)->multicast_limit =32; 1144 1145 spin_lock_init(&((*ppDevice)->lock)); 1146 1147 return TRUE; 1148} 1149 1150static BOOL device_get_pci_info(PSDevice pDevice, struct pci_dev* pcid) { 1151 1152 U16 pci_cmd; 1153 U8 b; 1154 UINT cis_addr; 1155#ifdef PLICE_DEBUG 1156 BYTE pci_config[256]; 1157 BYTE value =0x00; 1158 int ii,j; 1159 U16 max_lat=0x0000; 1160 memset(pci_config,0x00,256); 1161#endif 1162 1163 pci_read_config_byte(pcid, PCI_REVISION_ID, &pDevice->byRevId); 1164 pci_read_config_word(pcid, PCI_SUBSYSTEM_ID,&pDevice->SubSystemID); 1165 pci_read_config_word(pcid, PCI_SUBSYSTEM_VENDOR_ID, &pDevice->SubVendorID); 1166 pci_read_config_word(pcid, PCI_COMMAND, (u16 *) & (pci_cmd)); 1167 1168 pci_set_master(pcid); 1169 1170 pDevice->memaddr = pci_resource_start(pcid,0); 1171 pDevice->ioaddr = pci_resource_start(pcid,1); 1172 1173#ifdef DEBUG 1174// pDevice->ioaddr = pci_resource_start(pcid, 0); 1175// pDevice->memaddr = pci_resource_start(pcid,1); 1176#endif 1177 1178 cis_addr = pci_resource_start(pcid,2); 1179 1180 pDevice->pcid = pcid; 1181 1182 pci_read_config_byte(pcid, PCI_COMMAND, &b); 1183 pci_write_config_byte(pcid, PCI_COMMAND, (b|PCI_COMMAND_MASTER)); 1184 1185#ifdef PLICE_DEBUG 1186 //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat); 1187 //printk("max lat is %x,SubSystemID is %x\n",max_lat,pDevice->SubSystemID); 1188 //for (ii=0;ii<0xFF;ii++) 1189 //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat); 1190 //max_lat = 0x20; 1191 //pci_write_config_word(pcid,PCI_MAX_LAT,max_lat); 1192 //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat); 1193 //printk("max lat is %x\n",max_lat); 1194 1195 for (ii=0;ii<0xFF;ii++) 1196 { 1197 pci_read_config_byte(pcid,ii,&value); 1198 pci_config[ii] = value; 1199 } 1200 for (ii=0,j=1;ii<0x100;ii++,j++) 1201 { 1202 if (j %16 == 0) 1203 { 1204 printk("%x:",pci_config[ii]); 1205 printk("\n"); 1206 } 1207 else 1208 { 1209 printk("%x:",pci_config[ii]); 1210 } 1211 } 1212#endif 1213 return TRUE; 1214} 1215 1216static void device_free_info(PSDevice pDevice) { 1217 PSDevice ptr; 1218 struct net_device* dev=pDevice->dev; 1219 1220 ASSERT(pDevice); 1221//2008-0714-01<Add>by chester 1222device_release_WPADEV(pDevice); 1223 1224//2008-07-21-01<Add>by MikeLiu 1225//unregister wpadev 1226 if(wpa_set_wpadev(pDevice, 0)!=0) 1227 printk("unregister wpadev fail?\n"); 1228 1229 if (pDevice_Infos==NULL) 1230 return; 1231 1232 for (ptr=pDevice_Infos;ptr && (ptr!=pDevice);ptr=ptr->next) 1233 do {} while (0); 1234 1235 if (ptr==pDevice) { 1236 if (ptr==pDevice_Infos) 1237 pDevice_Infos=ptr->next; 1238 else 1239 ptr->prev->next=ptr->next; 1240 } 1241 else { 1242 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "info struct not found\n"); 1243 return; 1244 } 1245#ifdef HOSTAP 1246 if (dev) 1247 hostap_set_hostapd(pDevice, 0, 0); 1248#endif 1249 if (dev) 1250 unregister_netdev(dev); 1251 1252 if (pDevice->PortOffset) 1253 iounmap((PVOID)pDevice->PortOffset); 1254 1255 if (pDevice->pcid) 1256 pci_release_regions(pDevice->pcid); 1257 if (dev) 1258 free_netdev(dev); 1259 1260 if (pDevice->pcid) { 1261 pci_set_drvdata(pDevice->pcid,NULL); 1262 } 1263} 1264 1265static BOOL device_init_rings(PSDevice pDevice) { 1266 void* vir_pool; 1267 1268 1269 /*allocate all RD/TD rings a single pool*/ 1270 vir_pool = pci_alloc_consistent(pDevice->pcid, 1271 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) + 1272 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) + 1273 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) + 1274 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc), 1275 &pDevice->pool_dma); 1276 1277 if (vir_pool == NULL) { 1278 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate desc dma memory failed\n", pDevice->dev->name); 1279 return FALSE; 1280 } 1281 1282 memset(vir_pool, 0, 1283 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) + 1284 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) + 1285 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) + 1286 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc) 1287 ); 1288 1289 pDevice->aRD0Ring = vir_pool; 1290 pDevice->aRD1Ring = vir_pool + 1291 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc); 1292 1293 1294 pDevice->rd0_pool_dma = pDevice->pool_dma; 1295 pDevice->rd1_pool_dma = pDevice->rd0_pool_dma + 1296 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc); 1297 1298 pDevice->tx0_bufs = pci_alloc_consistent(pDevice->pcid, 1299 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ + 1300 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ + 1301 CB_BEACON_BUF_SIZE + 1302 CB_MAX_BUF_SIZE, 1303 &pDevice->tx_bufs_dma0); 1304 1305 if (pDevice->tx0_bufs == NULL) { 1306 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: allocate buf dma memory failed\n", pDevice->dev->name); 1307 pci_free_consistent(pDevice->pcid, 1308 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) + 1309 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) + 1310 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) + 1311 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc), 1312 vir_pool, pDevice->pool_dma 1313 ); 1314 return FALSE; 1315 } 1316 1317 memset(pDevice->tx0_bufs, 0, 1318 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ + 1319 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ + 1320 CB_BEACON_BUF_SIZE + 1321 CB_MAX_BUF_SIZE 1322 ); 1323 1324 pDevice->td0_pool_dma = pDevice->rd1_pool_dma + 1325 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc); 1326 1327 pDevice->td1_pool_dma = pDevice->td0_pool_dma + 1328 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc); 1329 1330 1331 // vir_pool: pvoid type 1332 pDevice->apTD0Rings = vir_pool 1333 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) 1334 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc); 1335 1336 pDevice->apTD1Rings = vir_pool 1337 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) 1338 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) 1339 + pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc); 1340 1341 1342 pDevice->tx1_bufs = pDevice->tx0_bufs + 1343 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ; 1344 1345 1346 pDevice->tx_beacon_bufs = pDevice->tx1_bufs + 1347 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ; 1348 1349 pDevice->pbyTmpBuff = pDevice->tx_beacon_bufs + 1350 CB_BEACON_BUF_SIZE; 1351 1352 pDevice->tx_bufs_dma1 = pDevice->tx_bufs_dma0 + 1353 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ; 1354 1355 1356 pDevice->tx_beacon_dma = pDevice->tx_bufs_dma1 + 1357 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ; 1358 1359 1360 return TRUE; 1361} 1362 1363static void device_free_rings(PSDevice pDevice) { 1364 1365 pci_free_consistent(pDevice->pcid, 1366 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) + 1367 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) + 1368 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) + 1369 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc) 1370 , 1371 pDevice->aRD0Ring, pDevice->pool_dma 1372 ); 1373 1374 if (pDevice->tx0_bufs) 1375 pci_free_consistent(pDevice->pcid, 1376 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ + 1377 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ + 1378 CB_BEACON_BUF_SIZE + 1379 CB_MAX_BUF_SIZE, 1380 pDevice->tx0_bufs, pDevice->tx_bufs_dma0 1381 ); 1382} 1383 1384static void device_init_rd0_ring(PSDevice pDevice) { 1385 int i; 1386 dma_addr_t curr = pDevice->rd0_pool_dma; 1387 PSRxDesc pDesc; 1388 1389 /* Init the RD0 ring entries */ 1390 for (i = 0; i < pDevice->sOpts.nRxDescs0; i ++, curr += sizeof(SRxDesc)) { 1391 pDesc = &(pDevice->aRD0Ring[i]); 1392 pDesc->pRDInfo = alloc_rd_info(); 1393 ASSERT(pDesc->pRDInfo); 1394 if (!device_alloc_rx_buf(pDevice, pDesc)) { 1395 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc rx bufs\n", 1396 pDevice->dev->name); 1397 } 1398 pDesc->next = &(pDevice->aRD0Ring[(i+1) % pDevice->sOpts.nRxDescs0]); 1399 pDesc->pRDInfo->curr_desc = cpu_to_le32(curr); 1400 pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc)); 1401 } 1402 1403 if (i > 0) 1404 pDevice->aRD0Ring[i-1].next_desc = cpu_to_le32(pDevice->rd0_pool_dma); 1405 pDevice->pCurrRD[0] = &(pDevice->aRD0Ring[0]); 1406} 1407 1408 1409static void device_init_rd1_ring(PSDevice pDevice) { 1410 int i; 1411 dma_addr_t curr = pDevice->rd1_pool_dma; 1412 PSRxDesc pDesc; 1413 1414 /* Init the RD1 ring entries */ 1415 for (i = 0; i < pDevice->sOpts.nRxDescs1; i ++, curr += sizeof(SRxDesc)) { 1416 pDesc = &(pDevice->aRD1Ring[i]); 1417 pDesc->pRDInfo = alloc_rd_info(); 1418 ASSERT(pDesc->pRDInfo); 1419 if (!device_alloc_rx_buf(pDevice, pDesc)) { 1420 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc rx bufs\n", 1421 pDevice->dev->name); 1422 } 1423 pDesc->next = &(pDevice->aRD1Ring[(i+1) % pDevice->sOpts.nRxDescs1]); 1424 pDesc->pRDInfo->curr_desc = cpu_to_le32(curr); 1425 pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc)); 1426 } 1427 1428 if (i > 0) 1429 pDevice->aRD1Ring[i-1].next_desc = cpu_to_le32(pDevice->rd1_pool_dma); 1430 pDevice->pCurrRD[1] = &(pDevice->aRD1Ring[0]); 1431} 1432 1433 1434static void device_init_defrag_cb(PSDevice pDevice) { 1435 int i; 1436 PSDeFragControlBlock pDeF; 1437 1438 /* Init the fragment ctl entries */ 1439 for (i = 0; i < CB_MAX_RX_FRAG; i++) { 1440 pDeF = &(pDevice->sRxDFCB[i]); 1441 if (!device_alloc_frag_buf(pDevice, pDeF)) { 1442 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n", 1443 pDevice->dev->name); 1444 }; 1445 } 1446 pDevice->cbDFCB = CB_MAX_RX_FRAG; 1447 pDevice->cbFreeDFCB = pDevice->cbDFCB; 1448} 1449 1450 1451 1452 1453static void device_free_rd0_ring(PSDevice pDevice) { 1454 int i; 1455 1456 for (i = 0; i < pDevice->sOpts.nRxDescs0; i++) { 1457 PSRxDesc pDesc =&(pDevice->aRD0Ring[i]); 1458 PDEVICE_RD_INFO pRDInfo =pDesc->pRDInfo; 1459 1460 pci_unmap_single(pDevice->pcid,pRDInfo->skb_dma, 1461 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE); 1462 1463 dev_kfree_skb(pRDInfo->skb); 1464 1465 kfree((PVOID)pDesc->pRDInfo); 1466 } 1467 1468} 1469 1470static void device_free_rd1_ring(PSDevice pDevice) { 1471 int i; 1472 1473 1474 for (i = 0; i < pDevice->sOpts.nRxDescs1; i++) { 1475 PSRxDesc pDesc=&(pDevice->aRD1Ring[i]); 1476 PDEVICE_RD_INFO pRDInfo=pDesc->pRDInfo; 1477 1478 pci_unmap_single(pDevice->pcid,pRDInfo->skb_dma, 1479 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE); 1480 1481 dev_kfree_skb(pRDInfo->skb); 1482 1483 kfree((PVOID)pDesc->pRDInfo); 1484 } 1485 1486} 1487 1488static void device_free_frag_buf(PSDevice pDevice) { 1489 PSDeFragControlBlock pDeF; 1490 int i; 1491 1492 for (i = 0; i < CB_MAX_RX_FRAG; i++) { 1493 1494 pDeF = &(pDevice->sRxDFCB[i]); 1495 1496 if (pDeF->skb) 1497 dev_kfree_skb(pDeF->skb); 1498 1499 } 1500 1501} 1502 1503static void device_init_td0_ring(PSDevice pDevice) { 1504 int i; 1505 dma_addr_t curr; 1506 PSTxDesc pDesc; 1507 1508 curr = pDevice->td0_pool_dma; 1509 for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++, curr += sizeof(STxDesc)) { 1510 pDesc = &(pDevice->apTD0Rings[i]); 1511 pDesc->pTDInfo = alloc_td_info(); 1512 ASSERT(pDesc->pTDInfo); 1513 if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) { 1514 pDesc->pTDInfo->buf = pDevice->tx0_bufs + (i)*PKT_BUF_SZ; 1515 pDesc->pTDInfo->buf_dma = pDevice->tx_bufs_dma0 + (i)*PKT_BUF_SZ; 1516 } 1517 pDesc->next =&(pDevice->apTD0Rings[(i+1) % pDevice->sOpts.nTxDescs[0]]); 1518 pDesc->pTDInfo->curr_desc = cpu_to_le32(curr); 1519 pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc)); 1520 } 1521 1522 if (i > 0) 1523 pDevice->apTD0Rings[i-1].next_desc = cpu_to_le32(pDevice->td0_pool_dma); 1524 pDevice->apTailTD[0] = pDevice->apCurrTD[0] =&(pDevice->apTD0Rings[0]); 1525 1526} 1527 1528static void device_init_td1_ring(PSDevice pDevice) { 1529 int i; 1530 dma_addr_t curr; 1531 PSTxDesc pDesc; 1532 1533 /* Init the TD ring entries */ 1534 curr=pDevice->td1_pool_dma; 1535 for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++, curr+=sizeof(STxDesc)) { 1536 pDesc=&(pDevice->apTD1Rings[i]); 1537 pDesc->pTDInfo = alloc_td_info(); 1538 ASSERT(pDesc->pTDInfo); 1539 if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) { 1540 pDesc->pTDInfo->buf=pDevice->tx1_bufs+(i)*PKT_BUF_SZ; 1541 pDesc->pTDInfo->buf_dma=pDevice->tx_bufs_dma1+(i)*PKT_BUF_SZ; 1542 } 1543 pDesc->next=&(pDevice->apTD1Rings[(i+1) % pDevice->sOpts.nTxDescs[1]]); 1544 pDesc->pTDInfo->curr_desc = cpu_to_le32(curr); 1545 pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc)); 1546 } 1547 1548 if (i > 0) 1549 pDevice->apTD1Rings[i-1].next_desc = cpu_to_le32(pDevice->td1_pool_dma); 1550 pDevice->apTailTD[1] = pDevice->apCurrTD[1] = &(pDevice->apTD1Rings[0]); 1551} 1552 1553 1554 1555static void device_free_td0_ring(PSDevice pDevice) { 1556 int i; 1557 for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++) { 1558 PSTxDesc pDesc=&(pDevice->apTD0Rings[i]); 1559 PDEVICE_TD_INFO pTDInfo=pDesc->pTDInfo; 1560 1561 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma)) 1562 pci_unmap_single(pDevice->pcid,pTDInfo->skb_dma, 1563 pTDInfo->skb->len, PCI_DMA_TODEVICE); 1564 1565 if (pTDInfo->skb) 1566 dev_kfree_skb(pTDInfo->skb); 1567 1568 kfree((PVOID)pDesc->pTDInfo); 1569 } 1570} 1571 1572static void device_free_td1_ring(PSDevice pDevice) { 1573 int i; 1574 1575 for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++) { 1576 PSTxDesc pDesc=&(pDevice->apTD1Rings[i]); 1577 PDEVICE_TD_INFO pTDInfo=pDesc->pTDInfo; 1578 1579 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma)) 1580 pci_unmap_single(pDevice->pcid, pTDInfo->skb_dma, 1581 pTDInfo->skb->len, PCI_DMA_TODEVICE); 1582 1583 if (pTDInfo->skb) 1584 dev_kfree_skb(pTDInfo->skb); 1585 1586 kfree((PVOID)pDesc->pTDInfo); 1587 } 1588 1589} 1590 1591 1592 1593/*-----------------------------------------------------------------*/ 1594 1595static int device_rx_srv(PSDevice pDevice, UINT uIdx) { 1596 PSRxDesc pRD; 1597 int works = 0; 1598 1599 1600 for (pRD = pDevice->pCurrRD[uIdx]; 1601 pRD->m_rd0RD0.f1Owner == OWNED_BY_HOST; 1602 pRD = pRD->next) { 1603// DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->pCurrRD = %x, works = %d\n", pRD, works); 1604 if (works++>15) 1605 break; 1606 if (device_receive_frame(pDevice, pRD)) { 1607 if (!device_alloc_rx_buf(pDevice,pRD)) { 1608 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR 1609 "%s: can not allocate rx buf\n", pDevice->dev->name); 1610 break; 1611 } 1612 } 1613 pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC; 1614 pDevice->dev->last_rx = jiffies; 1615 } 1616 1617 pDevice->pCurrRD[uIdx]=pRD; 1618 1619 return works; 1620} 1621 1622 1623static BOOL device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pRD) { 1624 1625 PDEVICE_RD_INFO pRDInfo=pRD->pRDInfo; 1626 1627 1628 pRDInfo->skb = dev_alloc_skb((int)pDevice->rx_buf_sz); 1629#ifdef PLICE_DEBUG 1630 //printk("device_alloc_rx_buf:skb is %x\n",pRDInfo->skb); 1631#endif 1632 if (pRDInfo->skb==NULL) 1633 return FALSE; 1634 ASSERT(pRDInfo->skb); 1635 pRDInfo->skb->dev = pDevice->dev; 1636 pRDInfo->skb_dma = pci_map_single(pDevice->pcid, skb_tail_pointer(pRDInfo->skb), 1637 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE); 1638 *((unsigned int *) &(pRD->m_rd0RD0)) = 0; /* FIX cast */ 1639 1640 pRD->m_rd0RD0.wResCount = cpu_to_le16(pDevice->rx_buf_sz); 1641 pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC; 1642 pRD->m_rd1RD1.wReqCount = cpu_to_le16(pDevice->rx_buf_sz); 1643 pRD->buff_addr = cpu_to_le32(pRDInfo->skb_dma); 1644 1645 return TRUE; 1646} 1647 1648 1649 1650BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) { 1651 1652 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz); 1653 if (pDeF->skb == NULL) 1654 return FALSE; 1655 ASSERT(pDeF->skb); 1656 pDeF->skb->dev = pDevice->dev; 1657 1658 return TRUE; 1659} 1660 1661 1662 1663static int device_tx_srv(PSDevice pDevice, UINT uIdx) { 1664 PSTxDesc pTD; 1665 BOOL bFull=FALSE; 1666 int works = 0; 1667 BYTE byTsr0; 1668 BYTE byTsr1; 1669 UINT uFrameSize, uFIFOHeaderSize; 1670 PSTxBufHead pTxBufHead; 1671 struct net_device_stats* pStats = &pDevice->stats; 1672 struct sk_buff* skb; 1673 UINT uNodeIndex; 1674 PSMgmtObject pMgmt = pDevice->pMgmt; 1675 1676 1677 for (pTD = pDevice->apTailTD[uIdx]; pDevice->iTDUsed[uIdx] >0; pTD = pTD->next) { 1678 1679 if (pTD->m_td0TD0.f1Owner == OWNED_BY_NIC) 1680 break; 1681 if (works++>15) 1682 break; 1683 1684 byTsr0 = pTD->m_td0TD0.byTSR0; 1685 byTsr1 = pTD->m_td0TD0.byTSR1; 1686 1687 //Only the status of first TD in the chain is correct 1688 if (pTD->m_td1TD1.byTCR & TCR_STP) { 1689 1690 if ((pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0) { 1691 uFIFOHeaderSize = pTD->pTDInfo->dwHeaderLength; 1692 uFrameSize = pTD->pTDInfo->dwReqCount - uFIFOHeaderSize; 1693 pTxBufHead = (PSTxBufHead) (pTD->pTDInfo->buf); 1694 // Update the statistics based on the Transmit status 1695 // now, we DO'NT check TSR0_CDH 1696 1697 STAvUpdateTDStatCounter(&pDevice->scStatistic, 1698 byTsr0, byTsr1, 1699 (PBYTE)(pTD->pTDInfo->buf + uFIFOHeaderSize), 1700 uFrameSize, uIdx); 1701 1702 1703 BSSvUpdateNodeTxCounter(pDevice, 1704 byTsr0, byTsr1, 1705 (PBYTE)(pTD->pTDInfo->buf), 1706 uFIFOHeaderSize 1707 ); 1708 1709 if ( !(byTsr1 & TSR1_TERR)) { 1710 if (byTsr0 != 0) { 1711 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] OK but has error. tsr1[%02X] tsr0[%02X].\n", 1712 (INT)uIdx, byTsr1, byTsr0); 1713 } 1714 if ((pTxBufHead->wFragCtl & FRAGCTL_ENDFRAG) != FRAGCTL_NONFRAG) { 1715 pDevice->s802_11Counter.TransmittedFragmentCount ++; 1716 } 1717 pStats->tx_packets++; 1718 pStats->tx_bytes += pTD->pTDInfo->skb->len; 1719 } 1720 else { 1721 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] dropped & tsr1[%02X] tsr0[%02X].\n", 1722 (INT)uIdx, byTsr1, byTsr0); 1723 pStats->tx_errors++; 1724 pStats->tx_dropped++; 1725 } 1726 } 1727 1728 if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) { 1729 if (pDevice->bEnableHostapd) { 1730 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx call back netif.. \n"); 1731 skb = pTD->pTDInfo->skb; 1732 skb->dev = pDevice->apdev; 1733 skb_reset_mac_header(skb); 1734 skb->pkt_type = PACKET_OTHERHOST; 1735 //skb->protocol = htons(ETH_P_802_2); 1736 memset(skb->cb, 0, sizeof(skb->cb)); 1737 netif_rx(skb); 1738 } 1739 } 1740 1741 if (byTsr1 & TSR1_TERR) { 1742 if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) { 1743 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n", 1744 (INT)uIdx, byTsr1, byTsr0); 1745 } 1746 1747// DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n", 1748// (INT)uIdx, byTsr1, byTsr0); 1749 1750 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) && 1751 (pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB)) { 1752 WORD wAID; 1753 BYTE byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80}; 1754 1755 skb = pTD->pTDInfo->skb; 1756 if (BSSDBbIsSTAInNodeDB(pMgmt, (PBYTE)(skb->data), &uNodeIndex)) { 1757 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) { 1758 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb); 1759 pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++; 1760 // set tx map 1761 wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID; 1762 pMgmt->abyPSTxMap[wAID >> 3] |= byMask[wAID & 7]; 1763 pTD->pTDInfo->byFlags &= ~(TD_FLAGS_NETIF_SKB); 1764 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx_srv:tx fail re-queue sta index= %d, QueCnt= %d\n" 1765 ,(INT)uNodeIndex, pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt); 1766 pStats->tx_errors--; 1767 pStats->tx_dropped--; 1768 } 1769 } 1770 } 1771 } 1772 device_free_tx_buf(pDevice,pTD); 1773 pDevice->iTDUsed[uIdx]--; 1774 } 1775 } 1776 1777 1778 if (uIdx == TYPE_AC0DMA) { 1779 // RESERV_AC0DMA reserved for relay 1780 1781 if (AVAIL_TD(pDevice, uIdx) < RESERV_AC0DMA) { 1782 bFull = TRUE; 1783 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " AC0DMA is Full = %d\n", pDevice->iTDUsed[uIdx]); 1784 } 1785 if (netif_queue_stopped(pDevice->dev) && (bFull==FALSE)){ 1786 netif_wake_queue(pDevice->dev); 1787 } 1788 } 1789 1790 1791 pDevice->apTailTD[uIdx] = pTD; 1792 1793 return works; 1794} 1795 1796 1797static void device_error(PSDevice pDevice, WORD status) { 1798 1799 if (status & ISR_FETALERR) { 1800 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR 1801 "%s: Hardware fatal error.\n", 1802 pDevice->dev->name); 1803 netif_stop_queue(pDevice->dev); 1804 del_timer(&pDevice->sTimerCommand); 1805 del_timer(&(pDevice->pMgmt->sTimerSecondCallback)); 1806 pDevice->bCmdRunning = FALSE; 1807 MACbShutdown(pDevice->PortOffset); 1808 return; 1809 } 1810 1811} 1812 1813static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc) { 1814 PDEVICE_TD_INFO pTDInfo=pDesc->pTDInfo; 1815 struct sk_buff* skb=pTDInfo->skb; 1816 1817 // pre-allocated buf_dma can't be unmapped. 1818 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma)) { 1819 pci_unmap_single(pDevice->pcid,pTDInfo->skb_dma,skb->len, 1820 PCI_DMA_TODEVICE); 1821 } 1822 1823 if ((pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0) 1824 dev_kfree_skb_irq(skb); 1825 1826 pTDInfo->skb_dma = 0; 1827 pTDInfo->skb = 0; 1828 pTDInfo->byFlags = 0; 1829} 1830 1831 1832 1833//PLICE_DEBUG -> 1834VOID InitRxManagementQueue(PSDevice pDevice) 1835{ 1836 pDevice->rxManeQueue.packet_num = 0; 1837 pDevice->rxManeQueue.head = pDevice->rxManeQueue.tail = 0; 1838} 1839//PLICE_DEBUG<- 1840 1841 1842 1843 1844 1845//PLICE_DEBUG -> 1846INT MlmeThread( 1847 void * Context) 1848{ 1849 PSDevice pDevice = (PSDevice) Context; 1850 PSRxMgmtPacket pRxMgmtPacket; 1851 // int i ; 1852 //complete(&pDevice->notify); 1853//printk("Enter MngWorkItem,Queue packet num is %d\n",pDevice->rxManeQueue.packet_num); 1854 1855 //printk("Enter MlmeThread,packet _num is %d\n",pDevice->rxManeQueue.packet_num); 1856 //i = 0; 1857#if 1 1858 while (1) 1859 { 1860 1861 //printk("DDDD\n"); 1862 //down(&pDevice->mlme_semaphore); 1863 // pRxMgmtPacket = DeQueue(pDevice); 1864#if 1 1865 spin_lock_irq(&pDevice->lock); 1866 while(pDevice->rxManeQueue.packet_num != 0) 1867 { 1868 pRxMgmtPacket = DeQueue(pDevice); 1869 //pDevice; 1870 //DequeueManageObject(pDevice->FirstRecvMngList, pDevice->LastRecvMngList); 1871 vMgrRxManagePacket(pDevice, pDevice->pMgmt, pRxMgmtPacket); 1872 //printk("packet_num is %d\n",pDevice->rxManeQueue.packet_num); 1873 1874 } 1875 spin_unlock_irq(&pDevice->lock); 1876 if (mlme_kill == 0) 1877 break; 1878 //udelay(200); 1879#endif 1880 //printk("Before schedule thread jiffies is %x\n",jiffies); 1881 schedule(); 1882 //printk("after schedule thread jiffies is %x\n",jiffies); 1883 if (mlme_kill == 0) 1884 break; 1885 //printk("i is %d\n",i); 1886 } 1887 1888#endif 1889 return 0; 1890 1891} 1892 1893 1894 1895static int device_open(struct net_device *dev) { 1896 PSDevice pDevice=(PSDevice) netdev_priv(dev); 1897 int i; 1898#ifdef WPA_SM_Transtatus 1899 extern SWPAResult wpa_Result; 1900#endif 1901 1902 pDevice->rx_buf_sz = PKT_BUF_SZ; 1903 if (!device_init_rings(pDevice)) { 1904 return -ENOMEM; 1905 } 1906//2008-5-13 <add> by chester 1907 i=request_irq(pDevice->pcid->irq, &device_intr, IRQF_SHARED, dev->name, dev); 1908 if (i) 1909 return i; 1910 //printk("DEBUG1\n"); 1911#ifdef WPA_SM_Transtatus 1912 memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname)); 1913 wpa_Result.proto = 0; 1914 wpa_Result.key_mgmt = 0; 1915 wpa_Result.eap_type = 0; 1916 wpa_Result.authenticated = FALSE; 1917 pDevice->fWPA_Authened = FALSE; 1918#endif 1919DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device init rd0 ring\n"); 1920device_init_rd0_ring(pDevice); 1921 device_init_rd1_ring(pDevice); 1922 device_init_defrag_cb(pDevice); 1923 device_init_td0_ring(pDevice); 1924 device_init_td1_ring(pDevice); 1925// VNTWIFIvSet11h(pDevice->pMgmt, pDevice->b11hEnable); 1926 1927 1928 if (pDevice->bDiversityRegCtlON) { 1929 device_init_diversity_timer(pDevice); 1930 } 1931 vMgrObjectInit(pDevice); 1932 vMgrTimerInit(pDevice); 1933 1934//PLICE_DEBUG-> 1935#ifdef TASK_LET 1936 tasklet_init (&pDevice->RxMngWorkItem,(void *)MngWorkItem,(unsigned long )pDevice); 1937#endif 1938#ifdef THREAD 1939 InitRxManagementQueue(pDevice); 1940 mlme_kill = 0; 1941 mlme_task = kthread_run(MlmeThread,(void *) pDevice, "MLME"); 1942 if (IS_ERR(mlme_task)) { 1943 printk("thread create fail\n"); 1944 return -1; 1945 } 1946 1947 mlme_kill = 1; 1948#endif 1949 1950 1951 1952#if 0 1953 pDevice->MLMEThr_pid = kernel_thread(MlmeThread, pDevice, CLONE_VM); 1954 if (pDevice->MLMEThr_pid <0 ) 1955 { 1956 printk("unable start thread MlmeThread\n"); 1957 return -1; 1958 } 1959#endif 1960 1961 //printk("thread id is %d\n",pDevice->MLMEThr_pid); 1962 //printk("Create thread time is %x\n",jiffies); 1963 //wait_for_completion(&pDevice->notify); 1964 1965 1966 1967 1968 // if (( SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RADIOCTL)&0x06)==0x04) 1969 // return -ENOMEM; 1970DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device_init_registers\n"); 1971 device_init_registers(pDevice, DEVICE_INIT_COLD); 1972 MACvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr); 1973 memcpy(pDevice->pMgmt->abyMACAddr, pDevice->abyCurrentNetAddr, U_ETHER_ADDR_LEN); 1974 device_set_multi(pDevice->dev); 1975 1976 // Init for Key Management 1977 KeyvInitTable(&pDevice->sKey, pDevice->PortOffset); 1978 add_timer(&(pDevice->pMgmt->sTimerSecondCallback)); 1979 1980 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 1981 /* 1982 pDevice->bwextstep0 = FALSE; 1983 pDevice->bwextstep1 = FALSE; 1984 pDevice->bwextstep2 = FALSE; 1985 pDevice->bwextstep3 = FALSE; 1986 */ 1987 pDevice->bwextcount=0; 1988 pDevice->bWPASuppWextEnabled = FALSE; 1989#endif 1990 pDevice->byReAssocCount = 0; 1991 pDevice->bWPADEVUp = FALSE; 1992 // Patch: if WEP key already set by iwconfig but device not yet open 1993 if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) { 1994 KeybSetDefaultKey(&(pDevice->sKey), 1995 (DWORD)(pDevice->byKeyIndex | (1 << 31)), 1996 pDevice->uKeyLength, 1997 NULL, 1998 pDevice->abyKey, 1999 KEY_CTL_WEP, 2000 pDevice->PortOffset, 2001 pDevice->byLocalID 2002 ); 2003 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled; 2004 } 2005 2006//printk("DEBUG2\n"); 2007 2008 2009DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call MACvIntEnable\n"); 2010 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE); 2011 2012 if (pDevice->pMgmt->eConfigMode == WMAC_CONFIG_AP) { 2013 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL); 2014 } 2015 else { 2016 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_BSSID_SCAN, NULL); 2017 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_SSID, NULL); 2018 } 2019 pDevice->flags |=DEVICE_FLAGS_OPENED; 2020 2021 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n"); 2022 return 0; 2023} 2024 2025 2026static int device_close(struct net_device *dev) { 2027 PSDevice pDevice=(PSDevice) netdev_priv(dev); 2028 PSMgmtObject pMgmt = pDevice->pMgmt; 2029 //PLICE_DEBUG-> 2030#ifdef THREAD 2031 mlme_kill = 0; 2032#endif 2033//PLICE_DEBUG<- 2034//2007-1121-02<Add>by EinsnLiu 2035 if (pDevice->bLinkPass) { 2036 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_DISASSOCIATE, NULL); 2037 mdelay(30); 2038 } 2039#ifdef TxInSleep 2040 del_timer(&pDevice->sTimerTxData); 2041#endif 2042 del_timer(&pDevice->sTimerCommand); 2043 del_timer(&pMgmt->sTimerSecondCallback); 2044 if (pDevice->bDiversityRegCtlON) { 2045 del_timer(&pDevice->TimerSQ3Tmax1); 2046 del_timer(&pDevice->TimerSQ3Tmax2); 2047 del_timer(&pDevice->TimerSQ3Tmax3); 2048 } 2049 2050#ifdef TASK_LET 2051 tasklet_kill(&pDevice->RxMngWorkItem); 2052#endif 2053 netif_stop_queue(dev); 2054 pDevice->bCmdRunning = FALSE; 2055 MACbShutdown(pDevice->PortOffset); 2056 MACbSoftwareReset(pDevice->PortOffset); 2057 CARDbRadioPowerOff(pDevice); 2058 2059 pDevice->bLinkPass = FALSE; 2060 memset(pMgmt->abyCurrBSSID, 0, 6); 2061 pMgmt->eCurrState = WMAC_STATE_IDLE; 2062 device_free_td0_ring(pDevice); 2063 device_free_td1_ring(pDevice); 2064 device_free_rd0_ring(pDevice); 2065 device_free_rd1_ring(pDevice); 2066 device_free_frag_buf(pDevice); 2067 device_free_rings(pDevice); 2068 BSSvClearNodeDBTable(pDevice, 0); 2069 free_irq(dev->irq, dev); 2070 pDevice->flags &=(~DEVICE_FLAGS_OPENED); 2071 //2008-0714-01<Add>by chester 2072device_release_WPADEV(pDevice); 2073//PLICE_DEBUG-> 2074 //tasklet_kill(&pDevice->RxMngWorkItem); 2075//PLICE_DEBUG<- 2076 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close.. \n"); 2077 return 0; 2078} 2079 2080 2081 2082static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev) { 2083 PSDevice pDevice=netdev_priv(dev); 2084 PBYTE pbMPDU; 2085 UINT cbMPDULen = 0; 2086 2087 2088 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211\n"); 2089 spin_lock_irq(&pDevice->lock); 2090 2091 if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) { 2092 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211, td0 <=0\n"); 2093 dev_kfree_skb_irq(skb); 2094 spin_unlock_irq(&pDevice->lock); 2095 return 0; 2096 } 2097 2098 if (pDevice->bStopTx0Pkt == TRUE) { 2099 dev_kfree_skb_irq(skb); 2100 spin_unlock_irq(&pDevice->lock); 2101 return 0; 2102 }; 2103 2104 cbMPDULen = skb->len; 2105 pbMPDU = skb->data; 2106 2107 vDMA0_tx_80211(pDevice, skb, pbMPDU, cbMPDULen); 2108 2109 spin_unlock_irq(&pDevice->lock); 2110 2111 return 0; 2112 2113} 2114 2115 2116 2117BOOL device_dma0_xmit(PSDevice pDevice, struct sk_buff *skb, UINT uNodeIndex) { 2118 PSMgmtObject pMgmt = pDevice->pMgmt; 2119 PSTxDesc pHeadTD, pLastTD; 2120 UINT cbFrameBodySize; 2121 UINT uMACfragNum; 2122 BYTE byPktType; 2123 BOOL bNeedEncryption = FALSE; 2124 PSKeyItem pTransmitKey = NULL; 2125 UINT cbHeaderSize; 2126 UINT ii; 2127 SKeyItem STempKey; 2128// BYTE byKeyIndex = 0; 2129 2130 2131 if (pDevice->bStopTx0Pkt == TRUE) { 2132 dev_kfree_skb_irq(skb); 2133 return FALSE; 2134 }; 2135 2136 if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) { 2137 dev_kfree_skb_irq(skb); 2138 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, td0 <=0\n"); 2139 return FALSE; 2140 } 2141 2142 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) { 2143 if (pDevice->uAssocCount == 0) { 2144 dev_kfree_skb_irq(skb); 2145 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, assocCount = 0\n"); 2146 return FALSE; 2147 } 2148 } 2149 2150 pHeadTD = pDevice->apCurrTD[TYPE_TXDMA0]; 2151 2152 pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP); 2153 2154 memcpy(pDevice->sTxEthHeader.abyDstAddr, (PBYTE)(skb->data), U_HEADER_LEN); 2155 cbFrameBodySize = skb->len - U_HEADER_LEN; 2156 2157 // 802.1H 2158 if (ntohs(pDevice->sTxEthHeader.wType) > MAX_DATA_LEN) { 2159 cbFrameBodySize += 8; 2160 } 2161 uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader); 2162 2163 if ( uMACfragNum > AVAIL_TD(pDevice, TYPE_TXDMA0)) { 2164 dev_kfree_skb_irq(skb); 2165 return FALSE; 2166 } 2167 byPktType = (BYTE)pDevice->byPacketType; 2168 2169 2170 if (pDevice->bFixRate) { 2171 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) { 2172 if (pDevice->uConnectionRate >= RATE_11M) { 2173 pDevice->wCurrentRate = RATE_11M; 2174 } else { 2175 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate; 2176 } 2177 } else { 2178 if (pDevice->uConnectionRate >= RATE_54M) 2179 pDevice->wCurrentRate = RATE_54M; 2180 else 2181 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate; 2182 } 2183 } 2184 else { 2185 pDevice->wCurrentRate = pDevice->pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate; 2186 } 2187 2188 //preamble type 2189 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) { 2190 pDevice->byPreambleType = pDevice->byShortPreamble; 2191 } 2192 else { 2193 pDevice->byPreambleType = PREAMBLE_LONG; 2194 } 2195 2196 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate); 2197 2198 2199 if (pDevice->wCurrentRate <= RATE_11M) { 2200 byPktType = PK_TYPE_11B; 2201 } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) { 2202 byPktType = PK_TYPE_11A; 2203 } else { 2204 if (pDevice->bProtectMode == TRUE) { 2205 byPktType = PK_TYPE_11GB; 2206 } else { 2207 byPktType = PK_TYPE_11GA; 2208 } 2209 } 2210 2211 if (pDevice->bEncryptionEnable == TRUE) 2212 bNeedEncryption = TRUE; 2213 2214 if (pDevice->bEnableHostWEP) { 2215 pTransmitKey = &STempKey; 2216 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite; 2217 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex; 2218 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength; 2219 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16; 2220 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0; 2221 memcpy(pTransmitKey->abyKey, 2222 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0], 2223 pTransmitKey->uKeyLength 2224 ); 2225 } 2226 vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption, 2227 cbFrameBodySize, TYPE_TXDMA0, pHeadTD, 2228 &pDevice->sTxEthHeader, (PBYTE)skb->data, pTransmitKey, uNodeIndex, 2229 &uMACfragNum, 2230 &cbHeaderSize 2231 ); 2232 2233 if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) { 2234 // Disable PS 2235 MACbPSWakeup(pDevice->PortOffset); 2236 } 2237 2238 pDevice->bPWBitOn = FALSE; 2239 2240 pLastTD = pHeadTD; 2241 for (ii = 0; ii < uMACfragNum; ii++) { 2242 // Poll Transmit the adapter 2243 wmb(); 2244 pHeadTD->m_td0TD0.f1Owner=OWNED_BY_NIC; 2245 wmb(); 2246 if (ii == (uMACfragNum - 1)) 2247 pLastTD = pHeadTD; 2248 pHeadTD = pHeadTD->next; 2249 } 2250 2251 // Save the information needed by the tx interrupt handler 2252 // to complete the Send request 2253 pLastTD->pTDInfo->skb = skb; 2254 pLastTD->pTDInfo->byFlags = 0; 2255 pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB; 2256 2257 pDevice->apCurrTD[TYPE_TXDMA0] = pHeadTD; 2258 2259 MACvTransmit0(pDevice->PortOffset); 2260 2261 2262 return TRUE; 2263} 2264 2265//TYPE_AC0DMA data tx 2266static int device_xmit(struct sk_buff *skb, struct net_device *dev) { 2267 PSDevice pDevice=netdev_priv(dev); 2268 2269 PSMgmtObject pMgmt = pDevice->pMgmt; 2270 PSTxDesc pHeadTD, pLastTD; 2271 UINT uNodeIndex = 0; 2272 BYTE byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80}; 2273 WORD wAID; 2274 UINT uMACfragNum = 1; 2275 UINT cbFrameBodySize; 2276 BYTE byPktType; 2277 UINT cbHeaderSize; 2278 BOOL bNeedEncryption = FALSE; 2279 PSKeyItem pTransmitKey = NULL; 2280 SKeyItem STempKey; 2281 UINT ii; 2282 BOOL bTKIP_UseGTK = FALSE; 2283 BOOL bNeedDeAuth = FALSE; 2284 PBYTE pbyBSSID; 2285 BOOL bNodeExist = FALSE; 2286 2287 2288 2289 spin_lock_irq(&pDevice->lock); 2290 if (pDevice->bLinkPass == FALSE) { 2291 dev_kfree_skb_irq(skb); 2292 spin_unlock_irq(&pDevice->lock); 2293 return 0; 2294 } 2295 2296 if (pDevice->bStopDataPkt) { 2297 dev_kfree_skb_irq(skb); 2298 spin_unlock_irq(&pDevice->lock); 2299 return 0; 2300 } 2301 2302 2303 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) { 2304 if (pDevice->uAssocCount == 0) { 2305 dev_kfree_skb_irq(skb); 2306 spin_unlock_irq(&pDevice->lock); 2307 return 0; 2308 } 2309 if (IS_MULTICAST_ADDRESS((PBYTE)(skb->data))) { 2310 uNodeIndex = 0; 2311 bNodeExist = TRUE; 2312 if (pMgmt->sNodeDBTable[0].bPSEnable) { 2313 skb_queue_tail(&(pMgmt->sNodeDBTable[0].sTxPSQueue), skb); 2314 pMgmt->sNodeDBTable[0].wEnQueueCnt++; 2315 // set tx map 2316 pMgmt->abyPSTxMap[0] |= byMask[0]; 2317 spin_unlock_irq(&pDevice->lock); 2318 return 0; 2319 } 2320}else { 2321 if (BSSDBbIsSTAInNodeDB(pMgmt, (PBYTE)(skb->data), &uNodeIndex)) { 2322 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) { 2323 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb); 2324 pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++; 2325 // set tx map 2326 wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID; 2327 pMgmt->abyPSTxMap[wAID >> 3] |= byMask[wAID & 7]; 2328 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set:pMgmt->abyPSTxMap[%d]= %d\n", 2329 (wAID >> 3), pMgmt->abyPSTxMap[wAID >> 3]); 2330 spin_unlock_irq(&pDevice->lock); 2331 return 0; 2332 } 2333 2334 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) { 2335 pDevice->byPreambleType = pDevice->byShortPreamble; 2336 2337 }else { 2338 pDevice->byPreambleType = PREAMBLE_LONG; 2339 } 2340 bNodeExist = TRUE; 2341 2342 } 2343 } 2344 2345 if (bNodeExist == FALSE) { 2346 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Unknown STA not found in node DB \n"); 2347 dev_kfree_skb_irq(skb); 2348 spin_unlock_irq(&pDevice->lock); 2349 return 0; 2350 } 2351 } 2352 2353 pHeadTD = pDevice->apCurrTD[TYPE_AC0DMA]; 2354 2355 pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP); 2356 2357 2358 memcpy(pDevice->sTxEthHeader.abyDstAddr, (PBYTE)(skb->data), U_HEADER_LEN); 2359 cbFrameBodySize = skb->len - U_HEADER_LEN; 2360 // 802.1H 2361 if (ntohs(pDevice->sTxEthHeader.wType) > MAX_DATA_LEN) { 2362 cbFrameBodySize += 8; 2363 } 2364 2365 2366 if (pDevice->bEncryptionEnable == TRUE) { 2367 bNeedEncryption = TRUE; 2368 // get Transmit key 2369 do { 2370 if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && 2371 (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) { 2372 pbyBSSID = pDevice->abyBSSID; 2373 // get pairwise key 2374 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == FALSE) { 2375 // get group key 2376 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == TRUE) { 2377 bTKIP_UseGTK = TRUE; 2378 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n"); 2379 break; 2380 } 2381 } else { 2382 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get PTK.\n"); 2383 break; 2384 } 2385 }else if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) { 2386 2387 pbyBSSID = pDevice->sTxEthHeader.abyDstAddr; //TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1 2388 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS Serach Key: \n"); 2389 for (ii = 0; ii< 6; ii++) 2390 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"%x \n", *(pbyBSSID+ii)); 2391 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"\n"); 2392 2393 // get pairwise key 2394 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == TRUE) 2395 break; 2396 } 2397 // get group key 2398 pbyBSSID = pDevice->abyBroadcastAddr; 2399 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == FALSE) { 2400 pTransmitKey = NULL; 2401 if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) { 2402 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode); 2403 } 2404 else 2405 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"NOT IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode); 2406 } else { 2407 bTKIP_UseGTK = TRUE; 2408 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n"); 2409 } 2410 } while(FALSE); 2411 } 2412 2413 if (pDevice->bEnableHostWEP) { 2414 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"acdma0: STA index %d\n", uNodeIndex); 2415 if (pDevice->bEncryptionEnable == TRUE) { 2416 pTransmitKey = &STempKey; 2417 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite; 2418 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex; 2419 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength; 2420 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16; 2421 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0; 2422 memcpy(pTransmitKey->abyKey, 2423 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0], 2424 pTransmitKey->uKeyLength 2425 ); 2426 } 2427 } 2428 2429 uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader); 2430 2431 if (uMACfragNum > AVAIL_TD(pDevice, TYPE_AC0DMA)) { 2432 DBG_PRT(MSG_LEVEL_ERR, KERN_DEBUG "uMACfragNum > AVAIL_TD(TYPE_AC0DMA) = %d\n", uMACfragNum); 2433 dev_kfree_skb_irq(skb); 2434 spin_unlock_irq(&pDevice->lock); 2435 return 0; 2436 } 2437 2438 if (pTransmitKey != NULL) { 2439 if ((pTransmitKey->byCipherSuite == KEY_CTL_WEP) && 2440 (pTransmitKey->uKeyLength == WLAN_WEP232_KEYLEN)) { 2441 uMACfragNum = 1; //WEP256 doesn't support fragment 2442 } 2443 } 2444 2445 byPktType = (BYTE)pDevice->byPacketType; 2446 2447 if (pDevice->bFixRate) { 2448#ifdef PLICE_DEBUG 2449 printk("Fix Rate: PhyType is %d,ConnectionRate is %d\n",pDevice->eCurrentPHYType,pDevice->uConnectionRate); 2450#endif 2451 2452 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) { 2453 if (pDevice->uConnectionRate >= RATE_11M) { 2454 pDevice->wCurrentRate = RATE_11M; 2455 } else { 2456 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate; 2457 } 2458 } else { 2459 if ((pDevice->eCurrentPHYType == PHY_TYPE_11A) && 2460 (pDevice->uConnectionRate <= RATE_6M)) { 2461 pDevice->wCurrentRate = RATE_6M; 2462 } else { 2463 if (pDevice->uConnectionRate >= RATE_54M) 2464 pDevice->wCurrentRate = RATE_54M; 2465 else 2466 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate; 2467 2468 } 2469 } 2470 pDevice->byACKRate = (BYTE) pDevice->wCurrentRate; 2471 pDevice->byTopCCKBasicRate = RATE_1M; 2472 pDevice->byTopOFDMBasicRate = RATE_6M; 2473 } 2474 else { 2475 //auto rate 2476 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) { 2477 if (pDevice->eCurrentPHYType != PHY_TYPE_11A) { 2478 pDevice->wCurrentRate = RATE_1M; 2479 pDevice->byACKRate = RATE_1M; 2480 pDevice->byTopCCKBasicRate = RATE_1M; 2481 pDevice->byTopOFDMBasicRate = RATE_6M; 2482 } else { 2483 pDevice->wCurrentRate = RATE_6M; 2484 pDevice->byACKRate = RATE_6M; 2485 pDevice->byTopCCKBasicRate = RATE_1M; 2486 pDevice->byTopOFDMBasicRate = RATE_6M; 2487 } 2488 } 2489 else { 2490 VNTWIFIvGetTxRate( pDevice->pMgmt, 2491 pDevice->sTxEthHeader.abyDstAddr, 2492 &(pDevice->wCurrentRate), 2493 &(pDevice->byACKRate), 2494 &(pDevice->byTopCCKBasicRate), 2495 &(pDevice->byTopOFDMBasicRate)); 2496 2497#if 0 2498printk("auto rate:Rate : %d,AckRate:%d,TopCCKRate:%d,TopOFDMRate:%d\n", 2499pDevice->wCurrentRate,pDevice->byACKRate, 2500pDevice->byTopCCKBasicRate,pDevice->byTopOFDMBasicRate); 2501 2502#endif 2503 2504#if 0 2505 2506 pDevice->wCurrentRate = 11; 2507 pDevice->byACKRate = 8; 2508 pDevice->byTopCCKBasicRate = 3; 2509 pDevice->byTopOFDMBasicRate = 8; 2510#endif 2511 2512 2513 } 2514 } 2515 2516// DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate); 2517 2518 if (pDevice->wCurrentRate <= RATE_11M) { 2519 byPktType = PK_TYPE_11B; 2520 } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) { 2521 byPktType = PK_TYPE_11A; 2522 } else { 2523 if (pDevice->bProtectMode == TRUE) { 2524 byPktType = PK_TYPE_11GB; 2525 } else { 2526 byPktType = PK_TYPE_11GA; 2527 } 2528 } 2529 2530//#ifdef PLICE_DEBUG 2531// printk("FIX RATE:CurrentRate is %d"); 2532//#endif 2533 2534 if (bNeedEncryption == TRUE) { 2535 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ntohs Pkt Type=%04x\n", ntohs(pDevice->sTxEthHeader.wType)); 2536 if ((pDevice->sTxEthHeader.wType) == TYPE_PKT_802_1x) { 2537 bNeedEncryption = FALSE; 2538 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Pkt Type=%04x\n", (pDevice->sTxEthHeader.wType)); 2539 if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) { 2540 if (pTransmitKey == NULL) { 2541 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Don't Find TX KEY\n"); 2542 } 2543 else { 2544 if (bTKIP_UseGTK == TRUE) { 2545 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"error: KEY is GTK!!~~\n"); 2546 } 2547 else { 2548 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%lX]\n", pTransmitKey->dwKeyIndex); 2549 bNeedEncryption = TRUE; 2550 } 2551 } 2552 } 2553 2554 if (pDevice->byCntMeasure == 2) { 2555 bNeedDeAuth = TRUE; 2556 pDevice->s802_11Counter.TKIPCounterMeasuresInvoked++; 2557 } 2558 2559 if (pDevice->bEnableHostWEP) { 2560 if ((uNodeIndex != 0) && 2561 (pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex & PAIRWISE_KEY)) { 2562 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%lX]\n", pTransmitKey->dwKeyIndex); 2563 bNeedEncryption = TRUE; 2564 } 2565 } 2566 } 2567 else { 2568 if (pTransmitKey == NULL) { 2569 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"return no tx key\n"); 2570 dev_kfree_skb_irq(skb); 2571 spin_unlock_irq(&pDevice->lock); 2572 return 0; 2573 } 2574 } 2575 } 2576 2577 2578#ifdef PLICE_DEBUG 2579 //if (skb->len == 98) 2580 //{ 2581 // printk("ping:len is %d\n"); 2582 //} 2583#endif 2584 vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption, 2585 cbFrameBodySize, TYPE_AC0DMA, pHeadTD, 2586 &pDevice->sTxEthHeader, (PBYTE)skb->data, pTransmitKey, uNodeIndex, 2587 &uMACfragNum, 2588 &cbHeaderSize 2589 ); 2590 2591 if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) { 2592 // Disable PS 2593 MACbPSWakeup(pDevice->PortOffset); 2594 } 2595 pDevice->bPWBitOn = FALSE; 2596 2597 pLastTD = pHeadTD; 2598 for (ii = 0; ii < uMACfragNum; ii++) { 2599 // Poll Transmit the adapter 2600 wmb(); 2601 pHeadTD->m_td0TD0.f1Owner=OWNED_BY_NIC; 2602 wmb(); 2603 if (ii == uMACfragNum - 1) 2604 pLastTD = pHeadTD; 2605 pHeadTD = pHeadTD->next; 2606 } 2607 2608 // Save the information needed by the tx interrupt handler 2609 // to complete the Send request 2610 pLastTD->pTDInfo->skb = skb; 2611 pLastTD->pTDInfo->byFlags = 0; 2612 pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB; 2613#ifdef TxInSleep 2614 pDevice->nTxDataTimeCout=0; //2008-8-21 chester <add> for send null packet 2615 #endif 2616 if (AVAIL_TD(pDevice, TYPE_AC0DMA) <= 1) { 2617 netif_stop_queue(dev); 2618 } 2619 2620 pDevice->apCurrTD[TYPE_AC0DMA] = pHeadTD; 2621//#ifdef PLICE_DEBUG 2622 if (pDevice->bFixRate) 2623 { 2624 printk("FixRate:Rate is %d,TxPower is %d\n",pDevice->wCurrentRate,pDevice->byCurPwr); 2625 } 2626 else 2627 { 2628 //printk("Auto Rate:Rate is %d,TxPower is %d\n",pDevice->wCurrentRate,pDevice->byCurPwr); 2629 } 2630//#endif 2631 2632{ 2633 BYTE Protocol_Version; //802.1x Authentication 2634 BYTE Packet_Type; //802.1x Authentication 2635 BYTE Descriptor_type; 2636 WORD Key_info; 2637BOOL bTxeapol_key = FALSE; 2638 Protocol_Version = skb->data[U_HEADER_LEN]; 2639 Packet_Type = skb->data[U_HEADER_LEN+1]; 2640 Descriptor_type = skb->data[U_HEADER_LEN+1+1+2]; 2641 Key_info = (skb->data[U_HEADER_LEN+1+1+2+1] << 8)|(skb->data[U_HEADER_LEN+1+1+2+2]); 2642 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) { 2643 if(((Protocol_Version==1) ||(Protocol_Version==2)) && 2644 (Packet_Type==3)) { //802.1x OR eapol-key challenge frame transfer 2645 bTxeapol_key = TRUE; 2646 if((Descriptor_type==254)||(Descriptor_type==2)) { //WPA or RSN 2647 if(!(Key_info & BIT3) && //group-key challenge 2648 (Key_info & BIT8) && (Key_info & BIT9)) { //send 2/2 key 2649 pDevice->fWPA_Authened = TRUE; 2650 if(Descriptor_type==254) 2651 printk("WPA "); 2652 else 2653 printk("WPA2 "); 2654 printk("Authentication completed!!\n"); 2655 } 2656 } 2657 } 2658 } 2659} 2660 2661 MACvTransmitAC0(pDevice->PortOffset); 2662// DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0:pDevice->apCurrTD= %p\n", pHeadTD); 2663 2664 dev->trans_start = jiffies; 2665 2666 spin_unlock_irq(&pDevice->lock); 2667 return 0; 2668 2669} 2670 2671static irqreturn_t device_intr(int irq, void *dev_instance) { 2672 struct net_device* dev=dev_instance; 2673 PSDevice pDevice=(PSDevice) netdev_priv(dev); 2674 2675 int max_count=0; 2676 DWORD dwMIBCounter=0; 2677 PSMgmtObject pMgmt = pDevice->pMgmt; 2678 BYTE byOrgPageSel=0; 2679 int handled = 0; 2680 BYTE byData = 0; 2681 int ii= 0; 2682// BYTE byRSSI; 2683 2684 2685 MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr); 2686 2687 if (pDevice->dwIsr == 0) 2688 return IRQ_RETVAL(handled); 2689 2690 if (pDevice->dwIsr == 0xffffffff) { 2691 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dwIsr = 0xffff\n"); 2692 return IRQ_RETVAL(handled); 2693 } 2694 /* 2695 // 2008-05-21 <mark> by Richardtai, we can't read RSSI here, because no packet bound with RSSI 2696 2697 if ((pDevice->dwIsr & ISR_RXDMA0) && 2698 (pDevice->byLocalID != REV_ID_VT3253_B0) && 2699 (pDevice->bBSSIDFilter == TRUE)) { 2700 // update RSSI 2701 //BBbReadEmbeded(pDevice->PortOffset, 0x3E, &byRSSI); 2702 //pDevice->uCurrRSSI = byRSSI; 2703 } 2704 */ 2705 2706 handled = 1; 2707 MACvIntDisable(pDevice->PortOffset); 2708 spin_lock_irq(&pDevice->lock); 2709 2710 //Make sure current page is 0 2711 VNSvInPortB(pDevice->PortOffset + MAC_REG_PAGE1SEL, &byOrgPageSel); 2712 if (byOrgPageSel == 1) { 2713 MACvSelectPage0(pDevice->PortOffset); 2714 } 2715 else 2716 byOrgPageSel = 0; 2717 2718 MACvReadMIBCounter(pDevice->PortOffset, &dwMIBCounter); 2719 // TBD.... 2720 // Must do this after doing rx/tx, cause ISR bit is slow 2721 // than RD/TD write back 2722 // update ISR counter 2723 STAvUpdate802_11Counter(&pDevice->s802_11Counter, &pDevice->scStatistic , dwMIBCounter); 2724 while (pDevice->dwIsr != 0) { 2725 2726 STAvUpdateIsrStatCounter(&pDevice->scStatistic, pDevice->dwIsr); 2727 MACvWriteISR(pDevice->PortOffset, pDevice->dwIsr); 2728 2729 if (pDevice->dwIsr & ISR_FETALERR){ 2730 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " ISR_FETALERR \n"); 2731 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, 0); 2732 VNSvOutPortW(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPECTI); 2733 device_error(pDevice, pDevice->dwIsr); 2734 } 2735 2736 if (pDevice->byLocalID > REV_ID_VT3253_B1) { 2737 2738 if (pDevice->dwIsr & ISR_MEASURESTART) { 2739 // 802.11h measure start 2740 pDevice->byOrgChannel = pDevice->byCurrentCh; 2741 VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byOrgRCR)); 2742 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, (RCR_RXALLTYPE | RCR_UNICAST | RCR_BROADCAST | RCR_MULTICAST | RCR_WPAERR)); 2743 MACvSelectPage1(pDevice->PortOffset); 2744 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR0, &(pDevice->dwOrgMAR0)); 2745 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR4, &(pDevice->dwOrgMAR4)); 2746 MACvSelectPage0(pDevice->PortOffset); 2747 //xxxx 2748 // WCMDbFlushCommandQueue(pDevice->pMgmt, TRUE); 2749 if (CARDbSetChannel(pDevice, pDevice->pCurrMeasureEID->sReq.byChannel) == TRUE) { 2750 pDevice->bMeasureInProgress = TRUE; 2751 MACvSelectPage1(pDevice->PortOffset); 2752 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_READY); 2753 MACvSelectPage0(pDevice->PortOffset); 2754 pDevice->byBasicMap = 0; 2755 pDevice->byCCAFraction = 0; 2756 for(ii=0;ii<8;ii++) { 2757 pDevice->dwRPIs[ii] = 0; 2758 } 2759 } else { 2760 // can not measure because set channel fail 2761 // WCMDbResetCommandQueue(pDevice->pMgmt); 2762 // clear measure control 2763 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN); 2764 s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_INCAPABLE); 2765 MACvSelectPage1(pDevice->PortOffset); 2766 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE); 2767 MACvSelectPage0(pDevice->PortOffset); 2768 } 2769 } 2770 if (pDevice->dwIsr & ISR_MEASUREEND) { 2771 // 802.11h measure end 2772 pDevice->bMeasureInProgress = FALSE; 2773 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byOrgRCR); 2774 MACvSelectPage1(pDevice->PortOffset); 2775 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, pDevice->dwOrgMAR0); 2776 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR4, pDevice->dwOrgMAR4); 2777 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRBBSTS, &byData); 2778 pDevice->byBasicMap |= (byData >> 4); 2779 VNSvInPortB(pDevice->PortOffset + MAC_REG_CCAFRACTION, &pDevice->byCCAFraction); 2780 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRCTL, &byData); 2781 // clear measure control 2782 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN); 2783 MACvSelectPage0(pDevice->PortOffset); 2784 CARDbSetChannel(pDevice, pDevice->byOrgChannel); 2785 // WCMDbResetCommandQueue(pDevice->pMgmt); 2786 MACvSelectPage1(pDevice->PortOffset); 2787 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE); 2788 MACvSelectPage0(pDevice->PortOffset); 2789 if (byData & MSRCTL_FINISH) { 2790 // measure success 2791 s_vCompleteCurrentMeasure(pDevice, 0); 2792 } else { 2793 // can not measure because not ready before end of measure time 2794 s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_LATE); 2795 } 2796 } 2797 if (pDevice->dwIsr & ISR_QUIETSTART) { 2798 do { 2799 ; 2800 } while (CARDbStartQuiet(pDevice) == FALSE); 2801 } 2802 } 2803 2804 if (pDevice->dwIsr & ISR_TBTT) { 2805 if (pDevice->bEnableFirstQuiet == TRUE) { 2806 pDevice->byQuietStartCount--; 2807 if (pDevice->byQuietStartCount == 0) { 2808 pDevice->bEnableFirstQuiet = FALSE; 2809 MACvSelectPage1(pDevice->PortOffset); 2810 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN)); 2811 MACvSelectPage0(pDevice->PortOffset); 2812 } 2813 } 2814 if ((pDevice->bChannelSwitch == TRUE) && 2815 (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE)) { 2816 pDevice->byChannelSwitchCount--; 2817 if (pDevice->byChannelSwitchCount == 0) { 2818 pDevice->bChannelSwitch = FALSE; 2819 CARDbSetChannel(pDevice, pDevice->byNewChannel); 2820 VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel); 2821 MACvSelectPage1(pDevice->PortOffset); 2822 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE); 2823 MACvSelectPage0(pDevice->PortOffset); 2824 CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL); 2825 2826 } 2827 } 2828 if (pDevice->eOPMode == OP_MODE_ADHOC) { 2829 //pDevice->bBeaconSent = FALSE; 2830 } else { 2831 if ((pDevice->bUpdateBBVGA) && (pDevice->bLinkPass == TRUE) && (pDevice->uCurrRSSI != 0)) { 2832 LONG ldBm; 2833 2834 RFvRSSITodBm(pDevice, (BYTE) pDevice->uCurrRSSI, &ldBm); 2835 for (ii=0;ii<BB_VGA_LEVEL;ii++) { 2836 if (ldBm < pDevice->ldBmThreshold[ii]) { 2837 pDevice->byBBVGANew = pDevice->abyBBVGA[ii]; 2838 break; 2839 } 2840 } 2841 if (pDevice->byBBVGANew != pDevice->byBBVGACurrent) { 2842 pDevice->uBBVGADiffCount++; 2843 if (pDevice->uBBVGADiffCount == 1) { 2844 // first VGA diff gain 2845 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew); 2846 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"First RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n", 2847 (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount); 2848 } 2849 if (pDevice->uBBVGADiffCount >= BB_VGA_CHANGE_THRESHOLD) { 2850 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n", 2851 (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount); 2852 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew); 2853 } 2854 } else { 2855 pDevice->uBBVGADiffCount = 1; 2856 } 2857 } 2858 } 2859 2860 pDevice->bBeaconSent = FALSE; 2861 if (pDevice->bEnablePSMode) { 2862 PSbIsNextTBTTWakeUp((HANDLE)pDevice); 2863 }; 2864 2865 if ((pDevice->eOPMode == OP_MODE_AP) || 2866 (pDevice->eOPMode == OP_MODE_ADHOC)) { 2867 2868 MACvOneShotTimer1MicroSec(pDevice->PortOffset, 2869 (pMgmt->wIBSSBeaconPeriod - MAKE_BEACON_RESERVED) << 10); 2870 } 2871 2872 if (pDevice->eOPMode == OP_MODE_ADHOC && pDevice->pMgmt->wCurrATIMWindow > 0) { 2873 // todo adhoc PS mode 2874 }; 2875 2876 } 2877 2878 if (pDevice->dwIsr & ISR_BNTX) { 2879 2880 if (pDevice->eOPMode == OP_MODE_ADHOC) { 2881 pDevice->bIsBeaconBufReadySet = FALSE; 2882 pDevice->cbBeaconBufReadySetCnt = 0; 2883 }; 2884 2885 if (pDevice->eOPMode == OP_MODE_AP) { 2886 if(pMgmt->byDTIMCount > 0) { 2887 pMgmt->byDTIMCount --; 2888 pMgmt->sNodeDBTable[0].bRxPSPoll = FALSE; 2889 } 2890 else { 2891 if(pMgmt->byDTIMCount == 0) { 2892 // check if mutltcast tx bufferring 2893 pMgmt->byDTIMCount = pMgmt->byDTIMPeriod - 1; 2894 pMgmt->sNodeDBTable[0].bRxPSPoll = TRUE; 2895 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RX_PSPOLL, NULL); 2896 } 2897 } 2898 } 2899 pDevice->bBeaconSent = TRUE; 2900 2901 if (pDevice->bChannelSwitch == TRUE) { 2902 pDevice->byChannelSwitchCount--; 2903 if (pDevice->byChannelSwitchCount == 0) { 2904 pDevice->bChannelSwitch = FALSE; 2905 CARDbSetChannel(pDevice, pDevice->byNewChannel); 2906 VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel); 2907 MACvSelectPage1(pDevice->PortOffset); 2908 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE); 2909 MACvSelectPage0(pDevice->PortOffset); 2910 //VNTWIFIbSendBeacon(pDevice->pMgmt); 2911 CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL); 2912 } 2913 } 2914 2915 } 2916 2917 if (pDevice->dwIsr & ISR_RXDMA0) { 2918 max_count += device_rx_srv(pDevice, TYPE_RXDMA0); 2919 } 2920 if (pDevice->dwIsr & ISR_RXDMA1) { 2921 max_count += device_rx_srv(pDevice, TYPE_RXDMA1); 2922 } 2923 if (pDevice->dwIsr & ISR_TXDMA0){ 2924 max_count += device_tx_srv(pDevice, TYPE_TXDMA0); 2925 } 2926 if (pDevice->dwIsr & ISR_AC0DMA){ 2927 max_count += device_tx_srv(pDevice, TYPE_AC0DMA); 2928 } 2929 if (pDevice->dwIsr & ISR_SOFTTIMER) { 2930 2931 } 2932 if (pDevice->dwIsr & ISR_SOFTTIMER1) { 2933 if (pDevice->eOPMode == OP_MODE_AP) { 2934 if (pDevice->bShortSlotTime) 2935 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTSLOTTIME(1); 2936 else 2937 pMgmt->wCurrCapInfo &= ~(WLAN_SET_CAP_INFO_SHORTSLOTTIME(1)); 2938 } 2939 bMgrPrepareBeaconToSend(pDevice, pMgmt); 2940 pDevice->byCntMeasure = 0; 2941 } 2942 2943 MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr); 2944 2945 MACvReceive0(pDevice->PortOffset); 2946 MACvReceive1(pDevice->PortOffset); 2947 2948 if (max_count>pDevice->sOpts.int_works) 2949 break; 2950 } 2951 2952 if (byOrgPageSel == 1) { 2953 MACvSelectPage1(pDevice->PortOffset); 2954 } 2955 2956 spin_unlock_irq(&pDevice->lock); 2957 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE); 2958 2959 return IRQ_RETVAL(handled); 2960} 2961 2962 2963static unsigned const ethernet_polynomial = 0x04c11db7U; 2964static inline u32 ether_crc(int length, unsigned char *data) 2965{ 2966 int crc = -1; 2967 2968 while(--length >= 0) { 2969 unsigned char current_octet = *data++; 2970 int bit; 2971 for (bit = 0; bit < 8; bit++, current_octet >>= 1) { 2972 crc = (crc << 1) ^ 2973 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0); 2974 } 2975 } 2976 return crc; 2977} 2978 2979//2008-8-4 <add> by chester 2980static int Config_FileGetParameter(UCHAR *string, UCHAR *dest,UCHAR *source) 2981{ 2982 UCHAR buf1[100]; 2983 int source_len = strlen(source); 2984 2985 memset(buf1,0,100); 2986 strcat(buf1, string); 2987 strcat(buf1, "="); 2988 source+=strlen(buf1); 2989 2990 memcpy(dest,source,source_len-strlen(buf1)); 2991 return TRUE; 2992} 2993 2994int Config_FileOperation(PSDevice pDevice,BOOL fwrite,unsigned char *Parameter) { 2995 UCHAR *config_path=CONFIG_PATH; 2996 UCHAR *buffer=NULL; 2997 UCHAR tmpbuffer[20]; 2998 struct file *filp=NULL; 2999 mm_segment_t old_fs = get_fs(); 3000 //int oldfsuid=0,oldfsgid=0; 3001 int result=0; 3002 3003 set_fs (KERNEL_DS); 3004 3005 /* Can't do this anymore, so we rely on correct filesystem permissions: 3006 //Make sure a caller can read or write power as root 3007 oldfsuid=current->cred->fsuid; 3008 oldfsgid=current->cred->fsgid; 3009 current->cred->fsuid = 0; 3010 current->cred->fsgid = 0; 3011 */ 3012 3013 //open file 3014 filp = filp_open(config_path, O_RDWR, 0); 3015 if (IS_ERR(filp)) { 3016 printk("Config_FileOperation:open file fail?\n"); 3017 result=-1; 3018 goto error2; 3019 } 3020 3021 if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) { 3022 printk("file %s cann't readable or writable?\n",config_path); 3023 result = -1; 3024 goto error1; 3025 } 3026 3027buffer = (UCHAR *)kmalloc(1024, GFP_KERNEL); 3028if(buffer==NULL) { 3029 printk("alllocate mem for file fail?\n"); 3030 result = -1; 3031 goto error1; 3032} 3033 3034if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) { 3035 printk("read file error?\n"); 3036 result = -1; 3037 goto error1; 3038} 3039 3040if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer)!=TRUE) { 3041 printk("get parameter error?\n"); 3042 result = -1; 3043 goto error1; 3044} 3045 3046if(memcmp(tmpbuffer,"USA",3)==0) { 3047 result=ZoneType_USA; 3048} 3049else if(memcmp(tmpbuffer,"JAPAN",5)==0) { 3050 result=ZoneType_Japan; 3051} 3052else if(memcmp(tmpbuffer,"EUROPE",5)==0) { 3053 result=ZoneType_Europe; 3054} 3055else { 3056 result = -1; 3057 printk("Unknown Zonetype[%s]?\n",tmpbuffer); 3058} 3059 3060error1: 3061 if(buffer) 3062 kfree(buffer); 3063 3064 if(filp_close(filp,NULL)) 3065 printk("Config_FileOperation:close file fail\n"); 3066 3067error2: 3068 set_fs (old_fs); 3069 3070 /* 3071 current->cred->fsuid=oldfsuid; 3072 current->cred->fsgid=oldfsgid; 3073 */ 3074 3075 return result; 3076} 3077 3078 3079 3080static void device_set_multi(struct net_device *dev) { 3081 PSDevice pDevice = (PSDevice) netdev_priv(dev); 3082 3083 PSMgmtObject pMgmt = pDevice->pMgmt; 3084 u32 mc_filter[2]; 3085 struct dev_mc_list *mclist; 3086 3087 3088 VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byRxMode)); 3089 3090 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */ 3091 DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name); 3092 /* Unconditionally log net taps. */ 3093 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST); 3094 } 3095 else if ((netdev_mc_count(dev) > pDevice->multicast_limit) 3096 || (dev->flags & IFF_ALLMULTI)) { 3097 MACvSelectPage1(pDevice->PortOffset); 3098 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, 0xffffffff); 3099 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, 0xffffffff); 3100 MACvSelectPage0(pDevice->PortOffset); 3101 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST); 3102 } 3103 else { 3104 memset(mc_filter, 0, sizeof(mc_filter)); 3105 netdev_for_each_mc_addr(mclist, dev) { 3106 int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26; 3107 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31)); 3108 } 3109 MACvSelectPage1(pDevice->PortOffset); 3110 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, mc_filter[0]); 3111 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, mc_filter[1]); 3112 MACvSelectPage0(pDevice->PortOffset); 3113 pDevice->byRxMode &= ~(RCR_UNICAST); 3114 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST); 3115 } 3116 3117 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) { 3118 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac. 3119 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST); 3120 pDevice->byRxMode &= ~(RCR_UNICAST); 3121 } 3122 3123 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byRxMode); 3124 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode = %x\n", pDevice->byRxMode ); 3125} 3126 3127 3128static struct net_device_stats *device_get_stats(struct net_device *dev) { 3129 PSDevice pDevice=(PSDevice) netdev_priv(dev); 3130 3131 return &pDevice->stats; 3132} 3133 3134 3135 3136static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) { 3137 PSDevice pDevice = (PSDevice)netdev_priv(dev); 3138 3139 struct iwreq *wrq = (struct iwreq *) rq; 3140 int rc =0; 3141 PSMgmtObject pMgmt = pDevice->pMgmt; 3142 PSCmdRequest pReq; 3143 3144 3145 if (pMgmt == NULL) { 3146 rc = -EFAULT; 3147 return rc; 3148 } 3149 3150 switch(cmd) { 3151 3152 case SIOCGIWNAME: 3153 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL); 3154 break; 3155 3156 case SIOCGIWNWID: //0x8b03 support 3157 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 3158 rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL); 3159 #else 3160 rc = -EOPNOTSUPP; 3161 #endif 3162 break; 3163 3164 // Set frequency/channel 3165 case SIOCSIWFREQ: 3166 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL); 3167 break; 3168 3169 // Get frequency/channel 3170 case SIOCGIWFREQ: 3171 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL); 3172 break; 3173 3174 // Set desired network name (ESSID) 3175 case SIOCSIWESSID: 3176 3177 { 3178 char essid[IW_ESSID_MAX_SIZE+1]; 3179 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) { 3180 rc = -E2BIG; 3181 break; 3182 } 3183 if (copy_from_user(essid, wrq->u.essid.pointer, 3184 wrq->u.essid.length)) { 3185 rc = -EFAULT; 3186 break; 3187 } 3188 rc = iwctl_siwessid(dev, NULL, 3189 &(wrq->u.essid), essid); 3190 } 3191 break; 3192 3193 3194 // Get current network name (ESSID) 3195 case SIOCGIWESSID: 3196 3197 { 3198 char essid[IW_ESSID_MAX_SIZE+1]; 3199 if (wrq->u.essid.pointer) 3200 rc = iwctl_giwessid(dev, NULL, 3201 &(wrq->u.essid), essid); 3202 if (copy_to_user(wrq->u.essid.pointer, 3203 essid, 3204 wrq->u.essid.length) ) 3205 rc = -EFAULT; 3206 } 3207 break; 3208 3209 case SIOCSIWAP: 3210 3211 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL); 3212 break; 3213 3214 3215 // Get current Access Point (BSSID) 3216 case SIOCGIWAP: 3217 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL); 3218 break; 3219 3220 3221 // Set desired station name 3222 case SIOCSIWNICKN: 3223 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n"); 3224 rc = -EOPNOTSUPP; 3225 break; 3226 3227 // Get current station name 3228 case SIOCGIWNICKN: 3229 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n"); 3230 rc = -EOPNOTSUPP; 3231 break; 3232 3233 // Set the desired bit-rate 3234 case SIOCSIWRATE: 3235 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL); 3236 break; 3237 3238 // Get the current bit-rate 3239 case SIOCGIWRATE: 3240 3241 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL); 3242 break; 3243 3244 // Set the desired RTS threshold 3245 case SIOCSIWRTS: 3246 3247 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL); 3248 break; 3249 3250 // Get the current RTS threshold 3251 case SIOCGIWRTS: 3252 3253 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL); 3254 break; 3255 3256 // Set the desired fragmentation threshold 3257 case SIOCSIWFRAG: 3258 3259 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL); 3260 break; 3261 3262 // Get the current fragmentation threshold 3263 case SIOCGIWFRAG: 3264 3265 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL); 3266 break; 3267 3268 // Set mode of operation 3269 case SIOCSIWMODE: 3270 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL); 3271 break; 3272 3273 // Get mode of operation 3274 case SIOCGIWMODE: 3275 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL); 3276 break; 3277 3278 // Set WEP keys and mode 3279 case SIOCSIWENCODE: 3280 { 3281 char abyKey[WLAN_WEP232_KEYLEN]; 3282 3283 if (wrq->u.encoding.pointer) { 3284 3285 3286 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) { 3287 rc = -E2BIG; 3288 break; 3289 } 3290 memset(abyKey, 0, WLAN_WEP232_KEYLEN); 3291 if (copy_from_user(abyKey, 3292 wrq->u.encoding.pointer, 3293 wrq->u.encoding.length)) { 3294 rc = -EFAULT; 3295 break; 3296 } 3297 } else if (wrq->u.encoding.length != 0) { 3298 rc = -EINVAL; 3299 break; 3300 } 3301 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey); 3302 } 3303 break; 3304 3305 // Get the WEP keys and mode 3306 case SIOCGIWENCODE: 3307 3308 if (!capable(CAP_NET_ADMIN)) { 3309 rc = -EPERM; 3310 break; 3311 } 3312 { 3313 char abyKey[WLAN_WEP232_KEYLEN]; 3314 3315 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey); 3316 if (rc != 0) break; 3317 if (wrq->u.encoding.pointer) { 3318 if (copy_to_user(wrq->u.encoding.pointer, 3319 abyKey, 3320 wrq->u.encoding.length)) 3321 rc = -EFAULT; 3322 } 3323 } 3324 break; 3325 3326 // Get the current Tx-Power 3327 case SIOCGIWTXPOW: 3328 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n"); 3329 rc = -EOPNOTSUPP; 3330 break; 3331 3332 case SIOCSIWTXPOW: 3333 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n"); 3334 rc = -EOPNOTSUPP; 3335 break; 3336 3337 case SIOCSIWRETRY: 3338 3339 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL); 3340 break; 3341 3342 case SIOCGIWRETRY: 3343 3344 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL); 3345 break; 3346 3347 // Get range of parameters 3348 case SIOCGIWRANGE: 3349 3350 { 3351 struct iw_range range; 3352 3353 rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range); 3354 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range))) 3355 rc = -EFAULT; 3356 } 3357 3358 break; 3359 3360 case SIOCGIWPOWER: 3361 3362 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL); 3363 break; 3364 3365 3366 case SIOCSIWPOWER: 3367 3368 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL); 3369 break; 3370 3371 3372 case SIOCGIWSENS: 3373 3374 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL); 3375 break; 3376 3377 case SIOCSIWSENS: 3378 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n"); 3379 rc = -EOPNOTSUPP; 3380 break; 3381 3382 case SIOCGIWAPLIST: 3383 { 3384 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))]; 3385 3386 if (wrq->u.data.pointer) { 3387 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer); 3388 if (rc == 0) { 3389 if (copy_to_user(wrq->u.data.pointer, 3390 buffer, 3391 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality))) 3392 )) 3393 rc = -EFAULT; 3394 } 3395 } 3396 } 3397 break; 3398 3399 3400#ifdef WIRELESS_SPY 3401 // Set the spy list 3402 case SIOCSIWSPY: 3403 3404 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n"); 3405 rc = -EOPNOTSUPP; 3406 break; 3407 3408 // Get the spy list 3409 case SIOCGIWSPY: 3410 3411 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n"); 3412 rc = -EOPNOTSUPP; 3413 break; 3414 3415#endif // WIRELESS_SPY 3416 3417 case SIOCGIWPRIV: 3418 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n"); 3419 rc = -EOPNOTSUPP; 3420/* 3421 if(wrq->u.data.pointer) { 3422 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]); 3423 3424 if(copy_to_user(wrq->u.data.pointer, 3425 (u_char *) iwctl_private_args, 3426 sizeof(iwctl_private_args))) 3427 rc = -EFAULT; 3428 } 3429*/ 3430 break; 3431 3432 3433//2008-0409-07, <Add> by Einsn Liu 3434#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 3435 case SIOCSIWAUTH: 3436 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n"); 3437 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL); 3438 break; 3439 3440 case SIOCGIWAUTH: 3441 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n"); 3442 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL); 3443 break; 3444 3445 case SIOCSIWGENIE: 3446 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n"); 3447 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer); 3448 break; 3449 3450 case SIOCGIWGENIE: 3451 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n"); 3452 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer); 3453 break; 3454 3455 case SIOCSIWENCODEEXT: 3456 { 3457 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1]; 3458 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n"); 3459 if(wrq->u.encoding.pointer){ 3460 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1); 3461 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){ 3462 rc = -E2BIG; 3463 break; 3464 } 3465 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){ 3466 rc = -EFAULT; 3467 break; 3468 } 3469 }else if(wrq->u.encoding.length != 0){ 3470 rc = -EINVAL; 3471 break; 3472 } 3473 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra); 3474 } 3475 break; 3476 3477 case SIOCGIWENCODEEXT: 3478 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n"); 3479 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL); 3480 break; 3481 3482 case SIOCSIWMLME: 3483 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n"); 3484 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer); 3485 break; 3486 3487#endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 3488//End Add -- //2008-0409-07, <Add> by Einsn Liu 3489 3490 case IOCTL_CMD_TEST: 3491 3492 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) { 3493 rc = -EFAULT; 3494 break; 3495 } else { 3496 rc = 0; 3497 } 3498 pReq = (PSCmdRequest)rq; 3499 pReq->wResult = MAGIC_CODE; 3500 break; 3501 3502 case IOCTL_CMD_SET: 3503 3504 #ifdef SndEvt_ToAPI 3505 if((((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_EVT) && 3506 !(pDevice->flags & DEVICE_FLAGS_OPENED)) 3507 #else 3508 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) && 3509 (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA)) 3510 #endif 3511 { 3512 rc = -EFAULT; 3513 break; 3514 } else { 3515 rc = 0; 3516 } 3517 3518 if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) { 3519 return -EBUSY; 3520 } 3521 rc = private_ioctl(pDevice, rq); 3522 clear_bit( 0, (void*)&(pMgmt->uCmdBusy)); 3523 break; 3524 3525 case IOCTL_CMD_HOSTAPD: 3526 3527 3528 rc = hostap_ioctl(pDevice, &wrq->u.data); 3529 break; 3530 3531 case IOCTL_CMD_WPA: 3532 3533 rc = wpa_ioctl(pDevice, &wrq->u.data); 3534 break; 3535 3536 case SIOCETHTOOL: 3537 return ethtool_ioctl(dev, (void *) rq->ifr_data); 3538 // All other calls are currently unsupported 3539 3540 default: 3541 rc = -EOPNOTSUPP; 3542 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd); 3543 3544 3545 } 3546 3547 if (pDevice->bCommit) { 3548 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) { 3549 netif_stop_queue(pDevice->dev); 3550 spin_lock_irq(&pDevice->lock); 3551 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL); 3552 spin_unlock_irq(&pDevice->lock); 3553 } 3554 else { 3555 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n"); 3556 spin_lock_irq(&pDevice->lock); 3557 pDevice->bLinkPass = FALSE; 3558 memset(pMgmt->abyCurrBSSID, 0, 6); 3559 pMgmt->eCurrState = WMAC_STATE_IDLE; 3560 netif_stop_queue(pDevice->dev); 3561 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 3562 pMgmt->eScanType = WMAC_SCAN_ACTIVE; 3563 if(pDevice->bWPASuppWextEnabled !=TRUE) 3564 #endif 3565 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID); 3566 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_SSID, NULL); 3567 spin_unlock_irq(&pDevice->lock); 3568 } 3569 pDevice->bCommit = FALSE; 3570 } 3571 3572 return rc; 3573} 3574 3575 3576static int ethtool_ioctl(struct net_device *dev, void *useraddr) 3577{ 3578 u32 ethcmd; 3579 3580 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd))) 3581 return -EFAULT; 3582 3583 switch (ethcmd) { 3584 case ETHTOOL_GDRVINFO: { 3585 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO}; 3586 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1); 3587 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1); 3588 if (copy_to_user(useraddr, &info, sizeof(info))) 3589 return -EFAULT; 3590 return 0; 3591 } 3592 3593 } 3594 3595 return -EOPNOTSUPP; 3596} 3597 3598/*------------------------------------------------------------------*/ 3599 3600MODULE_DEVICE_TABLE(pci, device_id_table); 3601 3602static struct pci_driver device_driver = { 3603 name: DEVICE_NAME, 3604 id_table: device_id_table, 3605 probe: device_found1, 3606 remove: device_remove1, 3607#ifdef CONFIG_PM 3608 suspend: viawget_suspend, 3609 resume: viawget_resume, 3610#endif 3611}; 3612 3613static int __init device_init_module(void) 3614{ 3615 int ret; 3616 3617 3618// ret=pci_module_init(&device_driver); 3619 //ret = pcie_port_service_register(&device_driver); 3620 ret = pci_register_driver(&device_driver); 3621#ifdef CONFIG_PM 3622 if(ret >= 0) 3623 register_reboot_notifier(&device_notifier); 3624#endif 3625 3626 return ret; 3627} 3628 3629static void __exit device_cleanup_module(void) 3630{ 3631 3632 3633#ifdef CONFIG_PM 3634 unregister_reboot_notifier(&device_notifier); 3635#endif 3636 pci_unregister_driver(&device_driver); 3637 3638} 3639 3640module_init(device_init_module); 3641module_exit(device_cleanup_module); 3642 3643 3644#ifdef CONFIG_PM 3645static int 3646device_notify_reboot(struct notifier_block *nb, unsigned long event, void *p) 3647{ 3648 struct pci_dev *pdev = NULL; 3649 switch(event) { 3650 case SYS_DOWN: 3651 case SYS_HALT: 3652 case SYS_POWER_OFF: 3653 while ((pdev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pdev)) != NULL) { 3654 if(pci_dev_driver(pdev) == &device_driver) { 3655 if (pci_get_drvdata(pdev)) 3656 viawget_suspend(pdev, PMSG_HIBERNATE); 3657 } 3658 } 3659 } 3660 return NOTIFY_DONE; 3661} 3662 3663static int 3664viawget_suspend(struct pci_dev *pcid, pm_message_t state) 3665{ 3666 int power_status; // to silence the compiler 3667 3668 PSDevice pDevice=pci_get_drvdata(pcid); 3669 PSMgmtObject pMgmt = pDevice->pMgmt; 3670 3671 netif_stop_queue(pDevice->dev); 3672 spin_lock_irq(&pDevice->lock); 3673 pci_save_state(pcid); 3674 del_timer(&pDevice->sTimerCommand); 3675 del_timer(&pMgmt->sTimerSecondCallback); 3676 pDevice->cbFreeCmdQueue = CMD_Q_SIZE; 3677 pDevice->uCmdDequeueIdx = 0; 3678 pDevice->uCmdEnqueueIdx = 0; 3679 pDevice->bCmdRunning = FALSE; 3680 MACbShutdown(pDevice->PortOffset); 3681 MACvSaveContext(pDevice->PortOffset, pDevice->abyMacContext); 3682 pDevice->bLinkPass = FALSE; 3683 memset(pMgmt->abyCurrBSSID, 0, 6); 3684 pMgmt->eCurrState = WMAC_STATE_IDLE; 3685 pci_disable_device(pcid); 3686 power_status = pci_set_power_state(pcid, pci_choose_state(pcid, state)); 3687 spin_unlock_irq(&pDevice->lock); 3688 return 0; 3689} 3690 3691static int 3692viawget_resume(struct pci_dev *pcid) 3693{ 3694 PSDevice pDevice=pci_get_drvdata(pcid); 3695 PSMgmtObject pMgmt = pDevice->pMgmt; 3696 int power_status; // to silence the compiler 3697 3698 3699 power_status = pci_set_power_state(pcid, 0); 3700 power_status = pci_enable_wake(pcid, 0, 0); 3701 pci_restore_state(pcid); 3702 if (netif_running(pDevice->dev)) { 3703 spin_lock_irq(&pDevice->lock); 3704 MACvRestoreContext(pDevice->PortOffset, pDevice->abyMacContext); 3705 device_init_registers(pDevice, DEVICE_INIT_DXPL); 3706 if (pMgmt->sNodeDBTable[0].bActive == TRUE) { // Assoc with BSS 3707 pMgmt->sNodeDBTable[0].bActive = FALSE; 3708 pDevice->bLinkPass = FALSE; 3709 if(pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) { 3710 // In Adhoc, BSS state set back to started. 3711 pMgmt->eCurrState = WMAC_STATE_STARTED; 3712 } 3713 else { 3714 pMgmt->eCurrMode = WMAC_MODE_STANDBY; 3715 pMgmt->eCurrState = WMAC_STATE_IDLE; 3716 } 3717 } 3718 init_timer(&pMgmt->sTimerSecondCallback); 3719 init_timer(&pDevice->sTimerCommand); 3720 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE); 3721 BSSvClearBSSList((HANDLE)pDevice, pDevice->bLinkPass); 3722 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, NULL); 3723 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_SSID, NULL); 3724 spin_unlock_irq(&pDevice->lock); 3725 } 3726 return 0; 3727} 3728 3729#endif 3730 3731 3732 3733 3734