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