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; 93 static int msglevel = MSG_LEVEL_INFO; 94 95 //#define PLICE_DEBUG 96 // 97 // Define module options 98 // 99 MODULE_AUTHOR("VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>"); 100 MODULE_LICENSE("GPL"); 101 MODULE_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 118 DEVICE_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 123 DEVICE_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 128 DEVICE_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 133 DEVICE_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 enviroment, the IP header should be unsigned long byte aligned, 141 or the packet will be droped when we receive it. (eg: IPVS) 142 */ 143 DEVICE_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 150 DEVICE_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 156 DEVICE_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 166 DEVICE_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 173 DEVICE_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 180 DEVICE_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 203 DEVICE_PARAM(ConnectionRate, "Connection data rate"); 204 205 #define OP_MODE_DEF 0 206 207 DEVICE_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 223 DEVICE_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 231 DEVICE_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 238 DEVICE_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 250 DEVICE_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 261 DEVICE_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 270 DEVICE_PARAM(bDiversityANTEnable, "ANT diversity mode"); 271 272 273 // 274 // Static vars definitions 275 // 276 277 278 static int device_nics =0; 279 static PSDevice pDevice_Infos =NULL; 280 static struct net_device *root_device_dev = NULL; 281 282 static 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 288 DEFINE_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 296 static int vt6655_probe(struct pci_dev *pcid, const struct pci_device_id *ent); 297 static bool vt6655_init_info(struct pci_dev* pcid, PSDevice* ppDevice, PCHIP_INFO); 298 static void device_free_info(PSDevice pDevice); 299 static bool device_get_pci_info(PSDevice, struct pci_dev* pcid); 300 static void device_print_info(PSDevice pDevice); 301 static struct net_device_stats *device_get_stats(struct net_device *dev); 302 static void device_init_diversity_timer(PSDevice pDevice); 303 static int device_open(struct net_device *dev); 304 static int device_xmit(struct sk_buff *skb, struct net_device *dev); 305 static irqreturn_t device_intr(int irq, void*dev_instance); 306 static void device_set_multi(struct net_device *dev); 307 static int device_close(struct net_device *dev); 308 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); 309 310 #ifdef CONFIG_PM 311 static int device_notify_reboot(struct notifier_block *, unsigned long event, void *ptr); 312 static int viawget_suspend(struct pci_dev *pcid, pm_message_t state); 313 static int viawget_resume(struct pci_dev *pcid); 314 struct notifier_block device_notifier = { 315 notifier_call: device_notify_reboot, 316 next: NULL, 317 priority: 0 318 }; 319 #endif 320 321 322 static void device_init_rd0_ring(PSDevice pDevice); 323 static void device_init_rd1_ring(PSDevice pDevice); 324 static void device_init_defrag_cb(PSDevice pDevice); 325 static void device_init_td0_ring(PSDevice pDevice); 326 static void device_init_td1_ring(PSDevice pDevice); 327 328 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev); 329 //2008-0714<Add>by Mike Liu 330 static bool device_release_WPADEV(PSDevice pDevice); 331 332 static int ethtool_ioctl(struct net_device *dev, void *useraddr); 333 static int device_rx_srv(PSDevice pDevice, unsigned int uIdx); 334 static int device_tx_srv(PSDevice pDevice, unsigned int uIdx); 335 static bool device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pDesc); 336 static void device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType); 337 static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc); 338 static void device_free_td0_ring(PSDevice pDevice); 339 static void device_free_td1_ring(PSDevice pDevice); 340 static void device_free_rd0_ring(PSDevice pDevice); 341 static void device_free_rd1_ring(PSDevice pDevice); 342 static void device_free_rings(PSDevice pDevice); 343 static void device_free_frag_buf(PSDevice pDevice); 344 static 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 354 static 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 362 static 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 /* 373 static void 374 device_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 388 static void 389 device_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 */ 404 static void 405 device_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; 412 pOpts->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 419 pOpts->flags|=DEVICE_FLAGS_PREAMBLE_TYPE; 420 pOpts->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; 425 pOpts->flags|=DEVICE_FLAGS_80211h_MODE; 426 pOpts->flags|=DEVICE_FLAGS_DiversityANT; 427 428 429 } 430 431 static void 432 device_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<- 463 pDevice->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 483 static 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 528 static 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 605 byValue1 = 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 663 else 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 795 if (pDevice->byGPIO & GPIO0_DATA){pDevice->bHWRadioOff = true;} 796 if ( !(pDevice->byGPIO & GPIO0_DATA)){pDevice->bHWRadioOff = false;} 797 798 } 799 if ( (pDevice->bRadioControlOff == true)) { 800 CARDbRadioPowerOff(pDevice); 801 } 802 else 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 = %02x-%02x-%02x=%02x-%02x-%02x\n", 819 pDevice->abyCurrentNetAddr[0], 820 pDevice->abyCurrentNetAddr[1], 821 pDevice->abyCurrentNetAddr[2], 822 pDevice->abyCurrentNetAddr[3], 823 pDevice->abyCurrentNetAddr[4], 824 pDevice->abyCurrentNetAddr[5]); 825 826 827 // reset Tx pointer 828 CARDvSafeResetRx(pDevice); 829 // reset Rx pointer 830 CARDvSafeResetTx(pDevice); 831 832 if (pDevice->byLocalID <= REV_ID_VT3253_A1) { 833 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_RCR, RCR_WPAERR); 834 } 835 836 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled; 837 838 // Turn On Rx DMA 839 MACvReceive0(pDevice->PortOffset); 840 MACvReceive1(pDevice->PortOffset); 841 842 // start the adapter 843 MACvStart(pDevice->PortOffset); 844 845 netif_stop_queue(pDevice->dev); 846 847 848 } 849 850 851 852 static void device_init_diversity_timer(PSDevice pDevice) { 853 854 init_timer(&pDevice->TimerSQ3Tmax1); 855 pDevice->TimerSQ3Tmax1.data = (unsigned long) pDevice; 856 pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack; 857 pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ); 858 859 init_timer(&pDevice->TimerSQ3Tmax2); 860 pDevice->TimerSQ3Tmax2.data = (unsigned long) pDevice; 861 pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack; 862 pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ); 863 864 init_timer(&pDevice->TimerSQ3Tmax3); 865 pDevice->TimerSQ3Tmax3.data = (unsigned long) pDevice; 866 pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerState1CallBack; 867 pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ); 868 869 return; 870 } 871 872 873 static bool device_release_WPADEV(PSDevice pDevice) 874 { 875 viawget_wpa_header *wpahdr; 876 int ii=0; 877 // wait_queue_head_t Set_wait; 878 //send device close to wpa_supplicnat layer 879 if (pDevice->bWPADEVUp==true) { 880 wpahdr = (viawget_wpa_header *)pDevice->skb->data; 881 wpahdr->type = VIAWGET_DEVICECLOSE_MSG; 882 wpahdr->resp_ie_len = 0; 883 wpahdr->req_ie_len = 0; 884 skb_put(pDevice->skb, sizeof(viawget_wpa_header)); 885 pDevice->skb->dev = pDevice->wpadev; 886 skb_reset_mac_header(pDevice->skb); 887 pDevice->skb->pkt_type = PACKET_HOST; 888 pDevice->skb->protocol = htons(ETH_P_802_2); 889 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb)); 890 netif_rx(pDevice->skb); 891 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz); 892 893 //wait release WPADEV 894 // init_waitqueue_head(&Set_wait); 895 // wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ); //1s wait 896 while((pDevice->bWPADEVUp==true)) { 897 set_current_state(TASK_UNINTERRUPTIBLE); 898 schedule_timeout (HZ/20); //wait 50ms 899 ii++; 900 if(ii>20) 901 break; 902 } 903 }; 904 return true; 905 } 906 907 908 static const struct net_device_ops device_netdev_ops = { 909 .ndo_open = device_open, 910 .ndo_stop = device_close, 911 .ndo_do_ioctl = device_ioctl, 912 .ndo_get_stats = device_get_stats, 913 .ndo_start_xmit = device_xmit, 914 .ndo_set_multicast_list = device_set_multi, 915 }; 916 917 918 919 static int __devinit 920 vt6655_probe(struct pci_dev *pcid, const struct pci_device_id *ent) 921 { 922 static bool bFirst = true; 923 struct net_device* dev = NULL; 924 PCHIP_INFO pChip_info = (PCHIP_INFO)ent->driver_data; 925 PSDevice pDevice; 926 int rc; 927 if (device_nics ++>= MAX_UINTS) { 928 printk(KERN_NOTICE DEVICE_NAME ": already found %d NICs\n", device_nics); 929 return -ENODEV; 930 } 931 932 933 dev = alloc_etherdev(sizeof(DEVICE_INFO)); 934 935 pDevice = (PSDevice) netdev_priv(dev); 936 937 if (dev == NULL) { 938 printk(KERN_ERR DEVICE_NAME ": allocate net device failed \n"); 939 return -ENODEV; 940 } 941 942 // Chain it all together 943 // SET_MODULE_OWNER(dev); 944 SET_NETDEV_DEV(dev, &pcid->dev); 945 946 if (bFirst) { 947 printk(KERN_NOTICE "%s Ver. %s\n",DEVICE_FULL_DRV_NAM, DEVICE_VERSION); 948 printk(KERN_NOTICE "Copyright (c) 2003 VIA Networking Technologies, Inc.\n"); 949 bFirst=false; 950 } 951 952 if (!vt6655_init_info(pcid, &pDevice, pChip_info)) { 953 return -ENOMEM; 954 } 955 pDevice->dev = dev; 956 pDevice->next_module = root_device_dev; 957 root_device_dev = dev; 958 959 if (pci_enable_device(pcid)) { 960 device_free_info(pDevice); 961 return -ENODEV; 962 } 963 dev->irq = pcid->irq; 964 965 #ifdef DEBUG 966 printk("Before get pci_info memaddr is %x\n",pDevice->memaddr); 967 #endif 968 if (device_get_pci_info(pDevice,pcid) == false) { 969 printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device.\n"); 970 device_free_info(pDevice); 971 return -ENODEV; 972 } 973 974 #if 1 975 976 #ifdef DEBUG 977 978 //pci_read_config_byte(pcid, PCI_BASE_ADDRESS_0, &pDevice->byRevId); 979 printk("after get pci_info memaddr is %x, io addr is %x,io_size is %d\n",pDevice->memaddr,pDevice->ioaddr,pDevice->io_size); 980 { 981 int i; 982 u32 bar,len; 983 u32 address[] = { 984 PCI_BASE_ADDRESS_0, 985 PCI_BASE_ADDRESS_1, 986 PCI_BASE_ADDRESS_2, 987 PCI_BASE_ADDRESS_3, 988 PCI_BASE_ADDRESS_4, 989 PCI_BASE_ADDRESS_5, 990 0}; 991 for (i=0;address[i];i++) 992 { 993 //pci_write_config_dword(pcid,address[i], 0xFFFFFFFF); 994 pci_read_config_dword(pcid, address[i], &bar); 995 printk("bar %d is %x\n",i,bar); 996 if (!bar) 997 { 998 printk("bar %d not implemented\n",i); 999 continue; 1000 } 1001 if (bar & PCI_BASE_ADDRESS_SPACE_IO) { 1002 /* This is IO */ 1003 1004 len = bar & (PCI_BASE_ADDRESS_IO_MASK & 0xFFFF); 1005 len = len & ~(len - 1); 1006 1007 printk("IO space: len in IO %x, BAR %d\n", len, i); 1008 } 1009 else 1010 { 1011 len = bar & 0xFFFFFFF0; 1012 len = ~len + 1; 1013 1014 printk("len in MEM %x, BAR %d\n", len, i); 1015 } 1016 } 1017 } 1018 #endif 1019 1020 1021 #endif 1022 1023 #ifdef DEBUG 1024 //return 0 ; 1025 #endif 1026 pDevice->PortOffset = (unsigned long)ioremap(pDevice->memaddr & PCI_BASE_ADDRESS_MEM_MASK, pDevice->io_size); 1027 //pDevice->PortOffset = (unsigned long)ioremap(pDevice->ioaddr & PCI_BASE_ADDRESS_IO_MASK, pDevice->io_size); 1028 1029 if(pDevice->PortOffset == 0) { 1030 printk(KERN_ERR DEVICE_NAME ": Failed to IO remapping ..\n"); 1031 device_free_info(pDevice); 1032 return -ENODEV; 1033 } 1034 1035 1036 1037 1038 rc = pci_request_regions(pcid, DEVICE_NAME); 1039 if (rc) { 1040 printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device\n"); 1041 device_free_info(pDevice); 1042 return -ENODEV; 1043 } 1044 1045 dev->base_addr = pDevice->ioaddr; 1046 #ifdef PLICE_DEBUG 1047 unsigned char value; 1048 1049 VNSvInPortB(pDevice->PortOffset+0x4F, &value); 1050 printk("Before write: value is %x\n",value); 1051 //VNSvInPortB(pDevice->PortOffset+0x3F, 0x00); 1052 VNSvOutPortB(pDevice->PortOffset,value); 1053 VNSvInPortB(pDevice->PortOffset+0x4F, &value); 1054 printk("After write: value is %x\n",value); 1055 #endif 1056 1057 1058 1059 #ifdef IO_MAP 1060 pDevice->PortOffset = pDevice->ioaddr; 1061 #endif 1062 // do reset 1063 if (!MACbSoftwareReset(pDevice->PortOffset)) { 1064 printk(KERN_ERR DEVICE_NAME ": Failed to access MAC hardware..\n"); 1065 device_free_info(pDevice); 1066 return -ENODEV; 1067 } 1068 // initial to reload eeprom 1069 MACvInitialize(pDevice->PortOffset); 1070 MACvReadEtherAddress(pDevice->PortOffset, dev->dev_addr); 1071 1072 device_get_options(pDevice, device_nics-1, dev->name); 1073 device_set_options(pDevice); 1074 //Mask out the options cannot be set to the chip 1075 pDevice->sOpts.flags &= pChip_info->flags; 1076 1077 //Enable the chip specified capbilities 1078 pDevice->flags = pDevice->sOpts.flags | (pChip_info->flags & 0xFF000000UL); 1079 pDevice->tx_80211 = device_dma0_tx_80211; 1080 pDevice->sMgmtObj.pAdapter = (void *)pDevice; 1081 pDevice->pMgmt = &(pDevice->sMgmtObj); 1082 1083 dev->irq = pcid->irq; 1084 dev->netdev_ops = &device_netdev_ops; 1085 1086 dev->wireless_handlers = (struct iw_handler_def *)&iwctl_handler_def; 1087 1088 rc = register_netdev(dev); 1089 if (rc) 1090 { 1091 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n"); 1092 device_free_info(pDevice); 1093 return -ENODEV; 1094 } 1095 //2008-07-21-01<Add>by MikeLiu 1096 //register wpadev 1097 #if 0 1098 if(wpa_set_wpadev(pDevice, 1)!=0) { 1099 printk("Fail to Register WPADEV?\n"); 1100 unregister_netdev(pDevice->dev); 1101 free_netdev(dev); 1102 } 1103 #endif 1104 device_print_info(pDevice); 1105 pci_set_drvdata(pcid, pDevice); 1106 return 0; 1107 1108 } 1109 1110 static void device_print_info(PSDevice pDevice) 1111 { 1112 struct net_device* dev=pDevice->dev; 1113 1114 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: %s\n",dev->name, get_chip_name(pDevice->chip_id)); 1115 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: MAC=%pM", dev->name, dev->dev_addr); 1116 #ifdef IO_MAP 1117 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IO=0x%lx ",(unsigned long) pDevice->ioaddr); 1118 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IRQ=%d \n", pDevice->dev->irq); 1119 #else 1120 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IO=0x%lx Mem=0x%lx ", 1121 (unsigned long) pDevice->ioaddr,(unsigned long) pDevice->PortOffset); 1122 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IRQ=%d \n", pDevice->dev->irq); 1123 #endif 1124 1125 } 1126 1127 static bool __devinit vt6655_init_info(struct pci_dev* pcid, PSDevice* ppDevice, 1128 PCHIP_INFO pChip_info) { 1129 1130 PSDevice p; 1131 1132 memset(*ppDevice,0,sizeof(DEVICE_INFO)); 1133 1134 if (pDevice_Infos == NULL) { 1135 pDevice_Infos =*ppDevice; 1136 } 1137 else { 1138 for (p=pDevice_Infos;p->next!=NULL;p=p->next) 1139 do {} while (0); 1140 p->next = *ppDevice; 1141 (*ppDevice)->prev = p; 1142 } 1143 1144 (*ppDevice)->pcid = pcid; 1145 (*ppDevice)->chip_id = pChip_info->chip_id; 1146 (*ppDevice)->io_size = pChip_info->io_size; 1147 (*ppDevice)->nTxQueues = pChip_info->nTxQueue; 1148 (*ppDevice)->multicast_limit =32; 1149 1150 spin_lock_init(&((*ppDevice)->lock)); 1151 1152 return true; 1153 } 1154 1155 static bool device_get_pci_info(PSDevice pDevice, struct pci_dev* pcid) { 1156 1157 u16 pci_cmd; 1158 u8 b; 1159 unsigned int cis_addr; 1160 #ifdef PLICE_DEBUG 1161 unsigned char pci_config[256]; 1162 unsigned char value =0x00; 1163 int ii,j; 1164 u16 max_lat=0x0000; 1165 memset(pci_config,0x00,256); 1166 #endif 1167 1168 pci_read_config_byte(pcid, PCI_REVISION_ID, &pDevice->byRevId); 1169 pci_read_config_word(pcid, PCI_SUBSYSTEM_ID,&pDevice->SubSystemID); 1170 pci_read_config_word(pcid, PCI_SUBSYSTEM_VENDOR_ID, &pDevice->SubVendorID); 1171 pci_read_config_word(pcid, PCI_COMMAND, (u16 *) & (pci_cmd)); 1172 1173 pci_set_master(pcid); 1174 1175 pDevice->memaddr = pci_resource_start(pcid,0); 1176 pDevice->ioaddr = pci_resource_start(pcid,1); 1177 1178 #ifdef DEBUG 1179 // pDevice->ioaddr = pci_resource_start(pcid, 0); 1180 // pDevice->memaddr = pci_resource_start(pcid,1); 1181 #endif 1182 1183 cis_addr = pci_resource_start(pcid,2); 1184 1185 pDevice->pcid = pcid; 1186 1187 pci_read_config_byte(pcid, PCI_COMMAND, &b); 1188 pci_write_config_byte(pcid, PCI_COMMAND, (b|PCI_COMMAND_MASTER)); 1189 1190 #ifdef PLICE_DEBUG 1191 //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat); 1192 //printk("max lat is %x,SubSystemID is %x\n",max_lat,pDevice->SubSystemID); 1193 //for (ii=0;ii<0xFF;ii++) 1194 //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat); 1195 //max_lat = 0x20; 1196 //pci_write_config_word(pcid,PCI_MAX_LAT,max_lat); 1197 //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat); 1198 //printk("max lat is %x\n",max_lat); 1199 1200 for (ii=0;ii<0xFF;ii++) 1201 { 1202 pci_read_config_byte(pcid,ii,&value); 1203 pci_config[ii] = value; 1204 } 1205 for (ii=0,j=1;ii<0x100;ii++,j++) 1206 { 1207 if (j %16 == 0) 1208 { 1209 printk("%x:",pci_config[ii]); 1210 printk("\n"); 1211 } 1212 else 1213 { 1214 printk("%x:",pci_config[ii]); 1215 } 1216 } 1217 #endif 1218 return true; 1219 } 1220 1221 static void device_free_info(PSDevice pDevice) { 1222 PSDevice ptr; 1223 struct net_device* dev=pDevice->dev; 1224 1225 ASSERT(pDevice); 1226 //2008-0714-01<Add>by chester 1227 device_release_WPADEV(pDevice); 1228 1229 //2008-07-21-01<Add>by MikeLiu 1230 //unregister wpadev 1231 if(wpa_set_wpadev(pDevice, 0)!=0) 1232 printk("unregister wpadev fail?\n"); 1233 1234 if (pDevice_Infos==NULL) 1235 return; 1236 1237 for (ptr=pDevice_Infos;ptr && (ptr!=pDevice);ptr=ptr->next) 1238 do {} while (0); 1239 1240 if (ptr==pDevice) { 1241 if (ptr==pDevice_Infos) 1242 pDevice_Infos=ptr->next; 1243 else 1244 ptr->prev->next=ptr->next; 1245 } 1246 else { 1247 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "info struct not found\n"); 1248 return; 1249 } 1250 #ifdef HOSTAP 1251 if (dev) 1252 vt6655_hostap_set_hostapd(pDevice, 0, 0); 1253 #endif 1254 if (dev) 1255 unregister_netdev(dev); 1256 1257 if (pDevice->PortOffset) 1258 iounmap((void *)pDevice->PortOffset); 1259 1260 if (pDevice->pcid) 1261 pci_release_regions(pDevice->pcid); 1262 if (dev) 1263 free_netdev(dev); 1264 1265 if (pDevice->pcid) { 1266 pci_set_drvdata(pDevice->pcid,NULL); 1267 } 1268 } 1269 1270 static bool device_init_rings(PSDevice pDevice) { 1271 void* vir_pool; 1272 1273 1274 /*allocate all RD/TD rings a single pool*/ 1275 vir_pool = pci_alloc_consistent(pDevice->pcid, 1276 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) + 1277 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) + 1278 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) + 1279 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc), 1280 &pDevice->pool_dma); 1281 1282 if (vir_pool == NULL) { 1283 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate desc dma memory failed\n", pDevice->dev->name); 1284 return false; 1285 } 1286 1287 memset(vir_pool, 0, 1288 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) + 1289 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) + 1290 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) + 1291 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc) 1292 ); 1293 1294 pDevice->aRD0Ring = vir_pool; 1295 pDevice->aRD1Ring = vir_pool + 1296 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc); 1297 1298 1299 pDevice->rd0_pool_dma = pDevice->pool_dma; 1300 pDevice->rd1_pool_dma = pDevice->rd0_pool_dma + 1301 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc); 1302 1303 pDevice->tx0_bufs = pci_alloc_consistent(pDevice->pcid, 1304 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ + 1305 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ + 1306 CB_BEACON_BUF_SIZE + 1307 CB_MAX_BUF_SIZE, 1308 &pDevice->tx_bufs_dma0); 1309 1310 if (pDevice->tx0_bufs == NULL) { 1311 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: allocate buf dma memory failed\n", pDevice->dev->name); 1312 pci_free_consistent(pDevice->pcid, 1313 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) + 1314 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) + 1315 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) + 1316 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc), 1317 vir_pool, pDevice->pool_dma 1318 ); 1319 return false; 1320 } 1321 1322 memset(pDevice->tx0_bufs, 0, 1323 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ + 1324 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ + 1325 CB_BEACON_BUF_SIZE + 1326 CB_MAX_BUF_SIZE 1327 ); 1328 1329 pDevice->td0_pool_dma = pDevice->rd1_pool_dma + 1330 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc); 1331 1332 pDevice->td1_pool_dma = pDevice->td0_pool_dma + 1333 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc); 1334 1335 1336 // vir_pool: pvoid type 1337 pDevice->apTD0Rings = vir_pool 1338 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) 1339 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc); 1340 1341 pDevice->apTD1Rings = vir_pool 1342 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) 1343 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) 1344 + pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc); 1345 1346 1347 pDevice->tx1_bufs = pDevice->tx0_bufs + 1348 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ; 1349 1350 1351 pDevice->tx_beacon_bufs = pDevice->tx1_bufs + 1352 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ; 1353 1354 pDevice->pbyTmpBuff = pDevice->tx_beacon_bufs + 1355 CB_BEACON_BUF_SIZE; 1356 1357 pDevice->tx_bufs_dma1 = pDevice->tx_bufs_dma0 + 1358 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ; 1359 1360 1361 pDevice->tx_beacon_dma = pDevice->tx_bufs_dma1 + 1362 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ; 1363 1364 1365 return true; 1366 } 1367 1368 static void device_free_rings(PSDevice pDevice) { 1369 1370 pci_free_consistent(pDevice->pcid, 1371 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) + 1372 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) + 1373 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) + 1374 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc) 1375 , 1376 pDevice->aRD0Ring, pDevice->pool_dma 1377 ); 1378 1379 if (pDevice->tx0_bufs) 1380 pci_free_consistent(pDevice->pcid, 1381 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ + 1382 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ + 1383 CB_BEACON_BUF_SIZE + 1384 CB_MAX_BUF_SIZE, 1385 pDevice->tx0_bufs, pDevice->tx_bufs_dma0 1386 ); 1387 } 1388 1389 static void device_init_rd0_ring(PSDevice pDevice) { 1390 int i; 1391 dma_addr_t curr = pDevice->rd0_pool_dma; 1392 PSRxDesc pDesc; 1393 1394 /* Init the RD0 ring entries */ 1395 for (i = 0; i < pDevice->sOpts.nRxDescs0; i ++, curr += sizeof(SRxDesc)) { 1396 pDesc = &(pDevice->aRD0Ring[i]); 1397 pDesc->pRDInfo = alloc_rd_info(); 1398 ASSERT(pDesc->pRDInfo); 1399 if (!device_alloc_rx_buf(pDevice, pDesc)) { 1400 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc rx bufs\n", 1401 pDevice->dev->name); 1402 } 1403 pDesc->next = &(pDevice->aRD0Ring[(i+1) % pDevice->sOpts.nRxDescs0]); 1404 pDesc->pRDInfo->curr_desc = cpu_to_le32(curr); 1405 pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc)); 1406 } 1407 1408 if (i > 0) 1409 pDevice->aRD0Ring[i-1].next_desc = cpu_to_le32(pDevice->rd0_pool_dma); 1410 pDevice->pCurrRD[0] = &(pDevice->aRD0Ring[0]); 1411 } 1412 1413 1414 static void device_init_rd1_ring(PSDevice pDevice) { 1415 int i; 1416 dma_addr_t curr = pDevice->rd1_pool_dma; 1417 PSRxDesc pDesc; 1418 1419 /* Init the RD1 ring entries */ 1420 for (i = 0; i < pDevice->sOpts.nRxDescs1; i ++, curr += sizeof(SRxDesc)) { 1421 pDesc = &(pDevice->aRD1Ring[i]); 1422 pDesc->pRDInfo = alloc_rd_info(); 1423 ASSERT(pDesc->pRDInfo); 1424 if (!device_alloc_rx_buf(pDevice, pDesc)) { 1425 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc rx bufs\n", 1426 pDevice->dev->name); 1427 } 1428 pDesc->next = &(pDevice->aRD1Ring[(i+1) % pDevice->sOpts.nRxDescs1]); 1429 pDesc->pRDInfo->curr_desc = cpu_to_le32(curr); 1430 pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc)); 1431 } 1432 1433 if (i > 0) 1434 pDevice->aRD1Ring[i-1].next_desc = cpu_to_le32(pDevice->rd1_pool_dma); 1435 pDevice->pCurrRD[1] = &(pDevice->aRD1Ring[0]); 1436 } 1437 1438 1439 static void device_init_defrag_cb(PSDevice pDevice) { 1440 int i; 1441 PSDeFragControlBlock pDeF; 1442 1443 /* Init the fragment ctl entries */ 1444 for (i = 0; i < CB_MAX_RX_FRAG; i++) { 1445 pDeF = &(pDevice->sRxDFCB[i]); 1446 if (!device_alloc_frag_buf(pDevice, pDeF)) { 1447 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n", 1448 pDevice->dev->name); 1449 }; 1450 } 1451 pDevice->cbDFCB = CB_MAX_RX_FRAG; 1452 pDevice->cbFreeDFCB = pDevice->cbDFCB; 1453 } 1454 1455 1456 1457 1458 static void device_free_rd0_ring(PSDevice pDevice) { 1459 int i; 1460 1461 for (i = 0; i < pDevice->sOpts.nRxDescs0; i++) { 1462 PSRxDesc pDesc =&(pDevice->aRD0Ring[i]); 1463 PDEVICE_RD_INFO pRDInfo =pDesc->pRDInfo; 1464 1465 pci_unmap_single(pDevice->pcid,pRDInfo->skb_dma, 1466 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE); 1467 1468 dev_kfree_skb(pRDInfo->skb); 1469 1470 kfree((void *)pDesc->pRDInfo); 1471 } 1472 1473 } 1474 1475 static void device_free_rd1_ring(PSDevice pDevice) { 1476 int i; 1477 1478 1479 for (i = 0; i < pDevice->sOpts.nRxDescs1; i++) { 1480 PSRxDesc pDesc=&(pDevice->aRD1Ring[i]); 1481 PDEVICE_RD_INFO pRDInfo=pDesc->pRDInfo; 1482 1483 pci_unmap_single(pDevice->pcid,pRDInfo->skb_dma, 1484 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE); 1485 1486 dev_kfree_skb(pRDInfo->skb); 1487 1488 kfree((void *)pDesc->pRDInfo); 1489 } 1490 1491 } 1492 1493 static void device_free_frag_buf(PSDevice pDevice) { 1494 PSDeFragControlBlock pDeF; 1495 int i; 1496 1497 for (i = 0; i < CB_MAX_RX_FRAG; i++) { 1498 1499 pDeF = &(pDevice->sRxDFCB[i]); 1500 1501 if (pDeF->skb) 1502 dev_kfree_skb(pDeF->skb); 1503 1504 } 1505 1506 } 1507 1508 static void device_init_td0_ring(PSDevice pDevice) { 1509 int i; 1510 dma_addr_t curr; 1511 PSTxDesc pDesc; 1512 1513 curr = pDevice->td0_pool_dma; 1514 for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++, curr += sizeof(STxDesc)) { 1515 pDesc = &(pDevice->apTD0Rings[i]); 1516 pDesc->pTDInfo = alloc_td_info(); 1517 ASSERT(pDesc->pTDInfo); 1518 if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) { 1519 pDesc->pTDInfo->buf = pDevice->tx0_bufs + (i)*PKT_BUF_SZ; 1520 pDesc->pTDInfo->buf_dma = pDevice->tx_bufs_dma0 + (i)*PKT_BUF_SZ; 1521 } 1522 pDesc->next =&(pDevice->apTD0Rings[(i+1) % pDevice->sOpts.nTxDescs[0]]); 1523 pDesc->pTDInfo->curr_desc = cpu_to_le32(curr); 1524 pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc)); 1525 } 1526 1527 if (i > 0) 1528 pDevice->apTD0Rings[i-1].next_desc = cpu_to_le32(pDevice->td0_pool_dma); 1529 pDevice->apTailTD[0] = pDevice->apCurrTD[0] =&(pDevice->apTD0Rings[0]); 1530 1531 } 1532 1533 static void device_init_td1_ring(PSDevice pDevice) { 1534 int i; 1535 dma_addr_t curr; 1536 PSTxDesc pDesc; 1537 1538 /* Init the TD ring entries */ 1539 curr=pDevice->td1_pool_dma; 1540 for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++, curr+=sizeof(STxDesc)) { 1541 pDesc=&(pDevice->apTD1Rings[i]); 1542 pDesc->pTDInfo = alloc_td_info(); 1543 ASSERT(pDesc->pTDInfo); 1544 if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) { 1545 pDesc->pTDInfo->buf=pDevice->tx1_bufs+(i)*PKT_BUF_SZ; 1546 pDesc->pTDInfo->buf_dma=pDevice->tx_bufs_dma1+(i)*PKT_BUF_SZ; 1547 } 1548 pDesc->next=&(pDevice->apTD1Rings[(i+1) % pDevice->sOpts.nTxDescs[1]]); 1549 pDesc->pTDInfo->curr_desc = cpu_to_le32(curr); 1550 pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc)); 1551 } 1552 1553 if (i > 0) 1554 pDevice->apTD1Rings[i-1].next_desc = cpu_to_le32(pDevice->td1_pool_dma); 1555 pDevice->apTailTD[1] = pDevice->apCurrTD[1] = &(pDevice->apTD1Rings[0]); 1556 } 1557 1558 1559 1560 static void device_free_td0_ring(PSDevice pDevice) { 1561 int i; 1562 for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++) { 1563 PSTxDesc pDesc=&(pDevice->apTD0Rings[i]); 1564 PDEVICE_TD_INFO pTDInfo=pDesc->pTDInfo; 1565 1566 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma)) 1567 pci_unmap_single(pDevice->pcid,pTDInfo->skb_dma, 1568 pTDInfo->skb->len, PCI_DMA_TODEVICE); 1569 1570 if (pTDInfo->skb) 1571 dev_kfree_skb(pTDInfo->skb); 1572 1573 kfree((void *)pDesc->pTDInfo); 1574 } 1575 } 1576 1577 static void device_free_td1_ring(PSDevice pDevice) { 1578 int i; 1579 1580 for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++) { 1581 PSTxDesc pDesc=&(pDevice->apTD1Rings[i]); 1582 PDEVICE_TD_INFO pTDInfo=pDesc->pTDInfo; 1583 1584 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma)) 1585 pci_unmap_single(pDevice->pcid, pTDInfo->skb_dma, 1586 pTDInfo->skb->len, PCI_DMA_TODEVICE); 1587 1588 if (pTDInfo->skb) 1589 dev_kfree_skb(pTDInfo->skb); 1590 1591 kfree((void *)pDesc->pTDInfo); 1592 } 1593 1594 } 1595 1596 1597 1598 /*-----------------------------------------------------------------*/ 1599 1600 static int device_rx_srv(PSDevice pDevice, unsigned int uIdx) { 1601 PSRxDesc pRD; 1602 int works = 0; 1603 1604 1605 for (pRD = pDevice->pCurrRD[uIdx]; 1606 pRD->m_rd0RD0.f1Owner == OWNED_BY_HOST; 1607 pRD = pRD->next) { 1608 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->pCurrRD = %x, works = %d\n", pRD, works); 1609 if (works++>15) 1610 break; 1611 if (device_receive_frame(pDevice, pRD)) { 1612 if (!device_alloc_rx_buf(pDevice,pRD)) { 1613 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR 1614 "%s: can not allocate rx buf\n", pDevice->dev->name); 1615 break; 1616 } 1617 } 1618 pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC; 1619 pDevice->dev->last_rx = jiffies; 1620 } 1621 1622 pDevice->pCurrRD[uIdx]=pRD; 1623 1624 return works; 1625 } 1626 1627 1628 static bool device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pRD) { 1629 1630 PDEVICE_RD_INFO pRDInfo=pRD->pRDInfo; 1631 1632 1633 pRDInfo->skb = dev_alloc_skb((int)pDevice->rx_buf_sz); 1634 #ifdef PLICE_DEBUG 1635 //printk("device_alloc_rx_buf:skb is %x\n",pRDInfo->skb); 1636 #endif 1637 if (pRDInfo->skb==NULL) 1638 return false; 1639 ASSERT(pRDInfo->skb); 1640 pRDInfo->skb->dev = pDevice->dev; 1641 pRDInfo->skb_dma = pci_map_single(pDevice->pcid, skb_tail_pointer(pRDInfo->skb), 1642 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE); 1643 *((unsigned int *) &(pRD->m_rd0RD0)) = 0; /* FIX cast */ 1644 1645 pRD->m_rd0RD0.wResCount = cpu_to_le16(pDevice->rx_buf_sz); 1646 pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC; 1647 pRD->m_rd1RD1.wReqCount = cpu_to_le16(pDevice->rx_buf_sz); 1648 pRD->buff_addr = cpu_to_le32(pRDInfo->skb_dma); 1649 1650 return true; 1651 } 1652 1653 1654 1655 bool device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) { 1656 1657 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz); 1658 if (pDeF->skb == NULL) 1659 return false; 1660 ASSERT(pDeF->skb); 1661 pDeF->skb->dev = pDevice->dev; 1662 1663 return true; 1664 } 1665 1666 1667 1668 static int device_tx_srv(PSDevice pDevice, unsigned int uIdx) { 1669 PSTxDesc pTD; 1670 bool bFull=false; 1671 int works = 0; 1672 unsigned char byTsr0; 1673 unsigned char byTsr1; 1674 unsigned int uFrameSize, uFIFOHeaderSize; 1675 PSTxBufHead pTxBufHead; 1676 struct net_device_stats* pStats = &pDevice->stats; 1677 struct sk_buff* skb; 1678 unsigned int uNodeIndex; 1679 PSMgmtObject pMgmt = pDevice->pMgmt; 1680 1681 1682 for (pTD = pDevice->apTailTD[uIdx]; pDevice->iTDUsed[uIdx] >0; pTD = pTD->next) { 1683 1684 if (pTD->m_td0TD0.f1Owner == OWNED_BY_NIC) 1685 break; 1686 if (works++>15) 1687 break; 1688 1689 byTsr0 = pTD->m_td0TD0.byTSR0; 1690 byTsr1 = pTD->m_td0TD0.byTSR1; 1691 1692 //Only the status of first TD in the chain is correct 1693 if (pTD->m_td1TD1.byTCR & TCR_STP) { 1694 1695 if ((pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0) { 1696 uFIFOHeaderSize = pTD->pTDInfo->dwHeaderLength; 1697 uFrameSize = pTD->pTDInfo->dwReqCount - uFIFOHeaderSize; 1698 pTxBufHead = (PSTxBufHead) (pTD->pTDInfo->buf); 1699 // Update the statistics based on the Transmit status 1700 // now, we DO'NT check TSR0_CDH 1701 1702 STAvUpdateTDStatCounter(&pDevice->scStatistic, 1703 byTsr0, byTsr1, 1704 (unsigned char *)(pTD->pTDInfo->buf + uFIFOHeaderSize), 1705 uFrameSize, uIdx); 1706 1707 1708 BSSvUpdateNodeTxCounter(pDevice, 1709 byTsr0, byTsr1, 1710 (unsigned char *)(pTD->pTDInfo->buf), 1711 uFIFOHeaderSize 1712 ); 1713 1714 if ( !(byTsr1 & TSR1_TERR)) { 1715 if (byTsr0 != 0) { 1716 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] OK but has error. tsr1[%02X] tsr0[%02X].\n", 1717 (int)uIdx, byTsr1, byTsr0); 1718 } 1719 if ((pTxBufHead->wFragCtl & FRAGCTL_ENDFRAG) != FRAGCTL_NONFRAG) { 1720 pDevice->s802_11Counter.TransmittedFragmentCount ++; 1721 } 1722 pStats->tx_packets++; 1723 pStats->tx_bytes += pTD->pTDInfo->skb->len; 1724 } 1725 else { 1726 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] dropped & tsr1[%02X] tsr0[%02X].\n", 1727 (int)uIdx, byTsr1, byTsr0); 1728 pStats->tx_errors++; 1729 pStats->tx_dropped++; 1730 } 1731 } 1732 1733 if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) { 1734 if (pDevice->bEnableHostapd) { 1735 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx call back netif.. \n"); 1736 skb = pTD->pTDInfo->skb; 1737 skb->dev = pDevice->apdev; 1738 skb_reset_mac_header(skb); 1739 skb->pkt_type = PACKET_OTHERHOST; 1740 //skb->protocol = htons(ETH_P_802_2); 1741 memset(skb->cb, 0, sizeof(skb->cb)); 1742 netif_rx(skb); 1743 } 1744 } 1745 1746 if (byTsr1 & TSR1_TERR) { 1747 if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) { 1748 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n", 1749 (int)uIdx, byTsr1, byTsr0); 1750 } 1751 1752 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n", 1753 // (int)uIdx, byTsr1, byTsr0); 1754 1755 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) && 1756 (pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB)) { 1757 unsigned short wAID; 1758 unsigned char byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80}; 1759 1760 skb = pTD->pTDInfo->skb; 1761 if (BSSDBbIsSTAInNodeDB(pMgmt, (unsigned char *)(skb->data), &uNodeIndex)) { 1762 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) { 1763 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb); 1764 pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++; 1765 // set tx map 1766 wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID; 1767 pMgmt->abyPSTxMap[wAID >> 3] |= byMask[wAID & 7]; 1768 pTD->pTDInfo->byFlags &= ~(TD_FLAGS_NETIF_SKB); 1769 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx_srv:tx fail re-queue sta index= %d, QueCnt= %d\n" 1770 ,(int)uNodeIndex, pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt); 1771 pStats->tx_errors--; 1772 pStats->tx_dropped--; 1773 } 1774 } 1775 } 1776 } 1777 device_free_tx_buf(pDevice,pTD); 1778 pDevice->iTDUsed[uIdx]--; 1779 } 1780 } 1781 1782 1783 if (uIdx == TYPE_AC0DMA) { 1784 // RESERV_AC0DMA reserved for relay 1785 1786 if (AVAIL_TD(pDevice, uIdx) < RESERV_AC0DMA) { 1787 bFull = true; 1788 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " AC0DMA is Full = %d\n", pDevice->iTDUsed[uIdx]); 1789 } 1790 if (netif_queue_stopped(pDevice->dev) && (bFull==false)){ 1791 netif_wake_queue(pDevice->dev); 1792 } 1793 } 1794 1795 1796 pDevice->apTailTD[uIdx] = pTD; 1797 1798 return works; 1799 } 1800 1801 1802 static void device_error(PSDevice pDevice, unsigned short status) { 1803 1804 if (status & ISR_FETALERR) { 1805 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR 1806 "%s: Hardware fatal error.\n", 1807 pDevice->dev->name); 1808 netif_stop_queue(pDevice->dev); 1809 del_timer(&pDevice->sTimerCommand); 1810 del_timer(&(pDevice->pMgmt->sTimerSecondCallback)); 1811 pDevice->bCmdRunning = false; 1812 MACbShutdown(pDevice->PortOffset); 1813 return; 1814 } 1815 1816 } 1817 1818 static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc) { 1819 PDEVICE_TD_INFO pTDInfo=pDesc->pTDInfo; 1820 struct sk_buff* skb=pTDInfo->skb; 1821 1822 // pre-allocated buf_dma can't be unmapped. 1823 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma)) { 1824 pci_unmap_single(pDevice->pcid,pTDInfo->skb_dma,skb->len, 1825 PCI_DMA_TODEVICE); 1826 } 1827 1828 if ((pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0) 1829 dev_kfree_skb_irq(skb); 1830 1831 pTDInfo->skb_dma = 0; 1832 pTDInfo->skb = 0; 1833 pTDInfo->byFlags = 0; 1834 } 1835 1836 1837 1838 //PLICE_DEBUG -> 1839 void InitRxManagementQueue(PSDevice pDevice) 1840 { 1841 pDevice->rxManeQueue.packet_num = 0; 1842 pDevice->rxManeQueue.head = pDevice->rxManeQueue.tail = 0; 1843 } 1844 //PLICE_DEBUG<- 1845 1846 1847 1848 1849 1850 //PLICE_DEBUG -> 1851 int MlmeThread( 1852 void * Context) 1853 { 1854 PSDevice pDevice = (PSDevice) Context; 1855 PSRxMgmtPacket pRxMgmtPacket; 1856 // int i ; 1857 //complete(&pDevice->notify); 1858 //printk("Enter MngWorkItem,Queue packet num is %d\n",pDevice->rxManeQueue.packet_num); 1859 1860 //printk("Enter MlmeThread,packet _num is %d\n",pDevice->rxManeQueue.packet_num); 1861 //i = 0; 1862 #if 1 1863 while (1) 1864 { 1865 1866 //printk("DDDD\n"); 1867 //down(&pDevice->mlme_semaphore); 1868 // pRxMgmtPacket = DeQueue(pDevice); 1869 #if 1 1870 spin_lock_irq(&pDevice->lock); 1871 while(pDevice->rxManeQueue.packet_num != 0) 1872 { 1873 pRxMgmtPacket = DeQueue(pDevice); 1874 //pDevice; 1875 //DequeueManageObject(pDevice->FirstRecvMngList, pDevice->LastRecvMngList); 1876 vMgrRxManagePacket(pDevice, pDevice->pMgmt, pRxMgmtPacket); 1877 //printk("packet_num is %d\n",pDevice->rxManeQueue.packet_num); 1878 1879 } 1880 spin_unlock_irq(&pDevice->lock); 1881 if (mlme_kill == 0) 1882 break; 1883 //udelay(200); 1884 #endif 1885 //printk("Before schedule thread jiffies is %x\n",jiffies); 1886 schedule(); 1887 //printk("after schedule thread jiffies is %x\n",jiffies); 1888 if (mlme_kill == 0) 1889 break; 1890 //printk("i is %d\n",i); 1891 } 1892 1893 #endif 1894 return 0; 1895 1896 } 1897 1898 1899 1900 static int device_open(struct net_device *dev) { 1901 PSDevice pDevice=(PSDevice) netdev_priv(dev); 1902 int i; 1903 #ifdef WPA_SM_Transtatus 1904 extern SWPAResult wpa_Result; 1905 #endif 1906 1907 pDevice->rx_buf_sz = PKT_BUF_SZ; 1908 if (!device_init_rings(pDevice)) { 1909 return -ENOMEM; 1910 } 1911 //2008-5-13 <add> by chester 1912 i=request_irq(pDevice->pcid->irq, &device_intr, IRQF_SHARED, dev->name, dev); 1913 if (i) 1914 return i; 1915 //printk("DEBUG1\n"); 1916 #ifdef WPA_SM_Transtatus 1917 memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname)); 1918 wpa_Result.proto = 0; 1919 wpa_Result.key_mgmt = 0; 1920 wpa_Result.eap_type = 0; 1921 wpa_Result.authenticated = false; 1922 pDevice->fWPA_Authened = false; 1923 #endif 1924 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device init rd0 ring\n"); 1925 device_init_rd0_ring(pDevice); 1926 device_init_rd1_ring(pDevice); 1927 device_init_defrag_cb(pDevice); 1928 device_init_td0_ring(pDevice); 1929 device_init_td1_ring(pDevice); 1930 // VNTWIFIvSet11h(pDevice->pMgmt, pDevice->b11hEnable); 1931 1932 1933 if (pDevice->bDiversityRegCtlON) { 1934 device_init_diversity_timer(pDevice); 1935 } 1936 vMgrObjectInit(pDevice); 1937 vMgrTimerInit(pDevice); 1938 1939 //PLICE_DEBUG-> 1940 #ifdef TASK_LET 1941 tasklet_init (&pDevice->RxMngWorkItem,(void *)MngWorkItem,(unsigned long )pDevice); 1942 #endif 1943 #ifdef THREAD 1944 InitRxManagementQueue(pDevice); 1945 mlme_kill = 0; 1946 mlme_task = kthread_run(MlmeThread,(void *) pDevice, "MLME"); 1947 if (IS_ERR(mlme_task)) { 1948 printk("thread create fail\n"); 1949 return -1; 1950 } 1951 1952 mlme_kill = 1; 1953 #endif 1954 1955 1956 1957 #if 0 1958 pDevice->MLMEThr_pid = kernel_thread(MlmeThread, pDevice, CLONE_VM); 1959 if (pDevice->MLMEThr_pid <0 ) 1960 { 1961 printk("unable start thread MlmeThread\n"); 1962 return -1; 1963 } 1964 #endif 1965 1966 //printk("thread id is %d\n",pDevice->MLMEThr_pid); 1967 //printk("Create thread time is %x\n",jiffies); 1968 //wait_for_completion(&pDevice->notify); 1969 1970 1971 1972 1973 // if (( SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RADIOCTL)&0x06)==0x04) 1974 // return -ENOMEM; 1975 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device_init_registers\n"); 1976 device_init_registers(pDevice, DEVICE_INIT_COLD); 1977 MACvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr); 1978 memcpy(pDevice->pMgmt->abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN); 1979 device_set_multi(pDevice->dev); 1980 1981 // Init for Key Management 1982 KeyvInitTable(&pDevice->sKey, pDevice->PortOffset); 1983 add_timer(&(pDevice->pMgmt->sTimerSecondCallback)); 1984 1985 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 1986 /* 1987 pDevice->bwextstep0 = false; 1988 pDevice->bwextstep1 = false; 1989 pDevice->bwextstep2 = false; 1990 pDevice->bwextstep3 = false; 1991 */ 1992 pDevice->bwextcount=0; 1993 pDevice->bWPASuppWextEnabled = false; 1994 #endif 1995 pDevice->byReAssocCount = 0; 1996 pDevice->bWPADEVUp = false; 1997 // Patch: if WEP key already set by iwconfig but device not yet open 1998 if ((pDevice->bEncryptionEnable == true) && (pDevice->bTransmitKey == true)) { 1999 KeybSetDefaultKey(&(pDevice->sKey), 2000 (unsigned long)(pDevice->byKeyIndex | (1 << 31)), 2001 pDevice->uKeyLength, 2002 NULL, 2003 pDevice->abyKey, 2004 KEY_CTL_WEP, 2005 pDevice->PortOffset, 2006 pDevice->byLocalID 2007 ); 2008 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled; 2009 } 2010 2011 //printk("DEBUG2\n"); 2012 2013 2014 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call MACvIntEnable\n"); 2015 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE); 2016 2017 if (pDevice->pMgmt->eConfigMode == WMAC_CONFIG_AP) { 2018 bScheduleCommand((void *)pDevice, WLAN_CMD_RUN_AP, NULL); 2019 } 2020 else { 2021 bScheduleCommand((void *)pDevice, WLAN_CMD_BSSID_SCAN, NULL); 2022 bScheduleCommand((void *)pDevice, WLAN_CMD_SSID, NULL); 2023 } 2024 pDevice->flags |=DEVICE_FLAGS_OPENED; 2025 2026 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n"); 2027 return 0; 2028 } 2029 2030 2031 static int device_close(struct net_device *dev) { 2032 PSDevice pDevice=(PSDevice) netdev_priv(dev); 2033 PSMgmtObject pMgmt = pDevice->pMgmt; 2034 //PLICE_DEBUG-> 2035 #ifdef THREAD 2036 mlme_kill = 0; 2037 #endif 2038 //PLICE_DEBUG<- 2039 //2007-1121-02<Add>by EinsnLiu 2040 if (pDevice->bLinkPass) { 2041 bScheduleCommand((void *)pDevice, WLAN_CMD_DISASSOCIATE, NULL); 2042 mdelay(30); 2043 } 2044 #ifdef TxInSleep 2045 del_timer(&pDevice->sTimerTxData); 2046 #endif 2047 del_timer(&pDevice->sTimerCommand); 2048 del_timer(&pMgmt->sTimerSecondCallback); 2049 if (pDevice->bDiversityRegCtlON) { 2050 del_timer(&pDevice->TimerSQ3Tmax1); 2051 del_timer(&pDevice->TimerSQ3Tmax2); 2052 del_timer(&pDevice->TimerSQ3Tmax3); 2053 } 2054 2055 #ifdef TASK_LET 2056 tasklet_kill(&pDevice->RxMngWorkItem); 2057 #endif 2058 netif_stop_queue(dev); 2059 pDevice->bCmdRunning = false; 2060 MACbShutdown(pDevice->PortOffset); 2061 MACbSoftwareReset(pDevice->PortOffset); 2062 CARDbRadioPowerOff(pDevice); 2063 2064 pDevice->bLinkPass = false; 2065 memset(pMgmt->abyCurrBSSID, 0, 6); 2066 pMgmt->eCurrState = WMAC_STATE_IDLE; 2067 device_free_td0_ring(pDevice); 2068 device_free_td1_ring(pDevice); 2069 device_free_rd0_ring(pDevice); 2070 device_free_rd1_ring(pDevice); 2071 device_free_frag_buf(pDevice); 2072 device_free_rings(pDevice); 2073 BSSvClearNodeDBTable(pDevice, 0); 2074 free_irq(dev->irq, dev); 2075 pDevice->flags &=(~DEVICE_FLAGS_OPENED); 2076 //2008-0714-01<Add>by chester 2077 device_release_WPADEV(pDevice); 2078 //PLICE_DEBUG-> 2079 //tasklet_kill(&pDevice->RxMngWorkItem); 2080 //PLICE_DEBUG<- 2081 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close.. \n"); 2082 return 0; 2083 } 2084 2085 2086 2087 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev) { 2088 PSDevice pDevice=netdev_priv(dev); 2089 unsigned char *pbMPDU; 2090 unsigned int cbMPDULen = 0; 2091 2092 2093 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211\n"); 2094 spin_lock_irq(&pDevice->lock); 2095 2096 if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) { 2097 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211, td0 <=0\n"); 2098 dev_kfree_skb_irq(skb); 2099 spin_unlock_irq(&pDevice->lock); 2100 return 0; 2101 } 2102 2103 if (pDevice->bStopTx0Pkt == true) { 2104 dev_kfree_skb_irq(skb); 2105 spin_unlock_irq(&pDevice->lock); 2106 return 0; 2107 }; 2108 2109 cbMPDULen = skb->len; 2110 pbMPDU = skb->data; 2111 2112 vDMA0_tx_80211(pDevice, skb, pbMPDU, cbMPDULen); 2113 2114 spin_unlock_irq(&pDevice->lock); 2115 2116 return 0; 2117 2118 } 2119 2120 2121 2122 bool device_dma0_xmit(PSDevice pDevice, struct sk_buff *skb, unsigned int uNodeIndex) { 2123 PSMgmtObject pMgmt = pDevice->pMgmt; 2124 PSTxDesc pHeadTD, pLastTD; 2125 unsigned int cbFrameBodySize; 2126 unsigned int uMACfragNum; 2127 unsigned char byPktType; 2128 bool bNeedEncryption = false; 2129 PSKeyItem pTransmitKey = NULL; 2130 unsigned int cbHeaderSize; 2131 unsigned int ii; 2132 SKeyItem STempKey; 2133 // unsigned char byKeyIndex = 0; 2134 2135 2136 if (pDevice->bStopTx0Pkt == true) { 2137 dev_kfree_skb_irq(skb); 2138 return false; 2139 }; 2140 2141 if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) { 2142 dev_kfree_skb_irq(skb); 2143 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, td0 <=0\n"); 2144 return false; 2145 } 2146 2147 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) { 2148 if (pDevice->uAssocCount == 0) { 2149 dev_kfree_skb_irq(skb); 2150 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, assocCount = 0\n"); 2151 return false; 2152 } 2153 } 2154 2155 pHeadTD = pDevice->apCurrTD[TYPE_TXDMA0]; 2156 2157 pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP); 2158 2159 memcpy(pDevice->sTxEthHeader.abyDstAddr, (unsigned char *)(skb->data), ETH_HLEN); 2160 cbFrameBodySize = skb->len - ETH_HLEN; 2161 2162 // 802.1H 2163 if (ntohs(pDevice->sTxEthHeader.wType) > ETH_DATA_LEN) { 2164 cbFrameBodySize += 8; 2165 } 2166 uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader); 2167 2168 if ( uMACfragNum > AVAIL_TD(pDevice, TYPE_TXDMA0)) { 2169 dev_kfree_skb_irq(skb); 2170 return false; 2171 } 2172 byPktType = (unsigned char)pDevice->byPacketType; 2173 2174 2175 if (pDevice->bFixRate) { 2176 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) { 2177 if (pDevice->uConnectionRate >= RATE_11M) { 2178 pDevice->wCurrentRate = RATE_11M; 2179 } else { 2180 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate; 2181 } 2182 } else { 2183 if (pDevice->uConnectionRate >= RATE_54M) 2184 pDevice->wCurrentRate = RATE_54M; 2185 else 2186 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate; 2187 } 2188 } 2189 else { 2190 pDevice->wCurrentRate = pDevice->pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate; 2191 } 2192 2193 //preamble type 2194 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) { 2195 pDevice->byPreambleType = pDevice->byShortPreamble; 2196 } 2197 else { 2198 pDevice->byPreambleType = PREAMBLE_LONG; 2199 } 2200 2201 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate); 2202 2203 2204 if (pDevice->wCurrentRate <= RATE_11M) { 2205 byPktType = PK_TYPE_11B; 2206 } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) { 2207 byPktType = PK_TYPE_11A; 2208 } else { 2209 if (pDevice->bProtectMode == true) { 2210 byPktType = PK_TYPE_11GB; 2211 } else { 2212 byPktType = PK_TYPE_11GA; 2213 } 2214 } 2215 2216 if (pDevice->bEncryptionEnable == true) 2217 bNeedEncryption = true; 2218 2219 if (pDevice->bEnableHostWEP) { 2220 pTransmitKey = &STempKey; 2221 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite; 2222 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex; 2223 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength; 2224 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16; 2225 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0; 2226 memcpy(pTransmitKey->abyKey, 2227 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0], 2228 pTransmitKey->uKeyLength 2229 ); 2230 } 2231 vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption, 2232 cbFrameBodySize, TYPE_TXDMA0, pHeadTD, 2233 &pDevice->sTxEthHeader, (unsigned char *)skb->data, pTransmitKey, uNodeIndex, 2234 &uMACfragNum, 2235 &cbHeaderSize 2236 ); 2237 2238 if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) { 2239 // Disable PS 2240 MACbPSWakeup(pDevice->PortOffset); 2241 } 2242 2243 pDevice->bPWBitOn = false; 2244 2245 pLastTD = pHeadTD; 2246 for (ii = 0; ii < uMACfragNum; ii++) { 2247 // Poll Transmit the adapter 2248 wmb(); 2249 pHeadTD->m_td0TD0.f1Owner=OWNED_BY_NIC; 2250 wmb(); 2251 if (ii == (uMACfragNum - 1)) 2252 pLastTD = pHeadTD; 2253 pHeadTD = pHeadTD->next; 2254 } 2255 2256 // Save the information needed by the tx interrupt handler 2257 // to complete the Send request 2258 pLastTD->pTDInfo->skb = skb; 2259 pLastTD->pTDInfo->byFlags = 0; 2260 pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB; 2261 2262 pDevice->apCurrTD[TYPE_TXDMA0] = pHeadTD; 2263 2264 MACvTransmit0(pDevice->PortOffset); 2265 2266 2267 return true; 2268 } 2269 2270 //TYPE_AC0DMA data tx 2271 static int device_xmit(struct sk_buff *skb, struct net_device *dev) { 2272 PSDevice pDevice=netdev_priv(dev); 2273 2274 PSMgmtObject pMgmt = pDevice->pMgmt; 2275 PSTxDesc pHeadTD, pLastTD; 2276 unsigned int uNodeIndex = 0; 2277 unsigned char byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80}; 2278 unsigned short wAID; 2279 unsigned int uMACfragNum = 1; 2280 unsigned int cbFrameBodySize; 2281 unsigned char byPktType; 2282 unsigned int cbHeaderSize; 2283 bool bNeedEncryption = false; 2284 PSKeyItem pTransmitKey = NULL; 2285 SKeyItem STempKey; 2286 unsigned int ii; 2287 bool bTKIP_UseGTK = false; 2288 bool bNeedDeAuth = false; 2289 unsigned char *pbyBSSID; 2290 bool bNodeExist = false; 2291 2292 2293 2294 spin_lock_irq(&pDevice->lock); 2295 if (pDevice->bLinkPass == false) { 2296 dev_kfree_skb_irq(skb); 2297 spin_unlock_irq(&pDevice->lock); 2298 return 0; 2299 } 2300 2301 if (pDevice->bStopDataPkt) { 2302 dev_kfree_skb_irq(skb); 2303 spin_unlock_irq(&pDevice->lock); 2304 return 0; 2305 } 2306 2307 2308 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) { 2309 if (pDevice->uAssocCount == 0) { 2310 dev_kfree_skb_irq(skb); 2311 spin_unlock_irq(&pDevice->lock); 2312 return 0; 2313 } 2314 if (is_multicast_ether_addr((unsigned char *)(skb->data))) { 2315 uNodeIndex = 0; 2316 bNodeExist = true; 2317 if (pMgmt->sNodeDBTable[0].bPSEnable) { 2318 skb_queue_tail(&(pMgmt->sNodeDBTable[0].sTxPSQueue), skb); 2319 pMgmt->sNodeDBTable[0].wEnQueueCnt++; 2320 // set tx map 2321 pMgmt->abyPSTxMap[0] |= byMask[0]; 2322 spin_unlock_irq(&pDevice->lock); 2323 return 0; 2324 } 2325 }else { 2326 if (BSSDBbIsSTAInNodeDB(pMgmt, (unsigned char *)(skb->data), &uNodeIndex)) { 2327 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) { 2328 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb); 2329 pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++; 2330 // set tx map 2331 wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID; 2332 pMgmt->abyPSTxMap[wAID >> 3] |= byMask[wAID & 7]; 2333 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set:pMgmt->abyPSTxMap[%d]= %d\n", 2334 (wAID >> 3), pMgmt->abyPSTxMap[wAID >> 3]); 2335 spin_unlock_irq(&pDevice->lock); 2336 return 0; 2337 } 2338 2339 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) { 2340 pDevice->byPreambleType = pDevice->byShortPreamble; 2341 2342 }else { 2343 pDevice->byPreambleType = PREAMBLE_LONG; 2344 } 2345 bNodeExist = true; 2346 2347 } 2348 } 2349 2350 if (bNodeExist == false) { 2351 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Unknown STA not found in node DB \n"); 2352 dev_kfree_skb_irq(skb); 2353 spin_unlock_irq(&pDevice->lock); 2354 return 0; 2355 } 2356 } 2357 2358 pHeadTD = pDevice->apCurrTD[TYPE_AC0DMA]; 2359 2360 pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP); 2361 2362 2363 memcpy(pDevice->sTxEthHeader.abyDstAddr, (unsigned char *)(skb->data), ETH_HLEN); 2364 cbFrameBodySize = skb->len - ETH_HLEN; 2365 // 802.1H 2366 if (ntohs(pDevice->sTxEthHeader.wType) > ETH_DATA_LEN) { 2367 cbFrameBodySize += 8; 2368 } 2369 2370 2371 if (pDevice->bEncryptionEnable == true) { 2372 bNeedEncryption = true; 2373 // get Transmit key 2374 do { 2375 if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && 2376 (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) { 2377 pbyBSSID = pDevice->abyBSSID; 2378 // get pairwise key 2379 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == false) { 2380 // get group key 2381 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == true) { 2382 bTKIP_UseGTK = true; 2383 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n"); 2384 break; 2385 } 2386 } else { 2387 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get PTK.\n"); 2388 break; 2389 } 2390 }else if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) { 2391 2392 pbyBSSID = pDevice->sTxEthHeader.abyDstAddr; //TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1 2393 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS Serach Key: \n"); 2394 for (ii = 0; ii< 6; ii++) 2395 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"%x \n", *(pbyBSSID+ii)); 2396 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"\n"); 2397 2398 // get pairwise key 2399 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == true) 2400 break; 2401 } 2402 // get group key 2403 pbyBSSID = pDevice->abyBroadcastAddr; 2404 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == false) { 2405 pTransmitKey = NULL; 2406 if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) { 2407 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode); 2408 } 2409 else 2410 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"NOT IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode); 2411 } else { 2412 bTKIP_UseGTK = true; 2413 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n"); 2414 } 2415 } while(false); 2416 } 2417 2418 if (pDevice->bEnableHostWEP) { 2419 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"acdma0: STA index %d\n", uNodeIndex); 2420 if (pDevice->bEncryptionEnable == true) { 2421 pTransmitKey = &STempKey; 2422 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite; 2423 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex; 2424 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength; 2425 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16; 2426 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0; 2427 memcpy(pTransmitKey->abyKey, 2428 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0], 2429 pTransmitKey->uKeyLength 2430 ); 2431 } 2432 } 2433 2434 uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader); 2435 2436 if (uMACfragNum > AVAIL_TD(pDevice, TYPE_AC0DMA)) { 2437 DBG_PRT(MSG_LEVEL_ERR, KERN_DEBUG "uMACfragNum > AVAIL_TD(TYPE_AC0DMA) = %d\n", uMACfragNum); 2438 dev_kfree_skb_irq(skb); 2439 spin_unlock_irq(&pDevice->lock); 2440 return 0; 2441 } 2442 2443 if (pTransmitKey != NULL) { 2444 if ((pTransmitKey->byCipherSuite == KEY_CTL_WEP) && 2445 (pTransmitKey->uKeyLength == WLAN_WEP232_KEYLEN)) { 2446 uMACfragNum = 1; //WEP256 doesn't support fragment 2447 } 2448 } 2449 2450 byPktType = (unsigned char)pDevice->byPacketType; 2451 2452 if (pDevice->bFixRate) { 2453 #ifdef PLICE_DEBUG 2454 printk("Fix Rate: PhyType is %d,ConnectionRate is %d\n",pDevice->eCurrentPHYType,pDevice->uConnectionRate); 2455 #endif 2456 2457 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) { 2458 if (pDevice->uConnectionRate >= RATE_11M) { 2459 pDevice->wCurrentRate = RATE_11M; 2460 } else { 2461 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate; 2462 } 2463 } else { 2464 if ((pDevice->eCurrentPHYType == PHY_TYPE_11A) && 2465 (pDevice->uConnectionRate <= RATE_6M)) { 2466 pDevice->wCurrentRate = RATE_6M; 2467 } else { 2468 if (pDevice->uConnectionRate >= RATE_54M) 2469 pDevice->wCurrentRate = RATE_54M; 2470 else 2471 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate; 2472 2473 } 2474 } 2475 pDevice->byACKRate = (unsigned char) pDevice->wCurrentRate; 2476 pDevice->byTopCCKBasicRate = RATE_1M; 2477 pDevice->byTopOFDMBasicRate = RATE_6M; 2478 } 2479 else { 2480 //auto rate 2481 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) { 2482 if (pDevice->eCurrentPHYType != PHY_TYPE_11A) { 2483 pDevice->wCurrentRate = RATE_1M; 2484 pDevice->byACKRate = RATE_1M; 2485 pDevice->byTopCCKBasicRate = RATE_1M; 2486 pDevice->byTopOFDMBasicRate = RATE_6M; 2487 } else { 2488 pDevice->wCurrentRate = RATE_6M; 2489 pDevice->byACKRate = RATE_6M; 2490 pDevice->byTopCCKBasicRate = RATE_1M; 2491 pDevice->byTopOFDMBasicRate = RATE_6M; 2492 } 2493 } 2494 else { 2495 VNTWIFIvGetTxRate( pDevice->pMgmt, 2496 pDevice->sTxEthHeader.abyDstAddr, 2497 &(pDevice->wCurrentRate), 2498 &(pDevice->byACKRate), 2499 &(pDevice->byTopCCKBasicRate), 2500 &(pDevice->byTopOFDMBasicRate)); 2501 2502 #if 0 2503 printk("auto rate:Rate : %d,AckRate:%d,TopCCKRate:%d,TopOFDMRate:%d\n", 2504 pDevice->wCurrentRate,pDevice->byACKRate, 2505 pDevice->byTopCCKBasicRate,pDevice->byTopOFDMBasicRate); 2506 2507 #endif 2508 2509 #if 0 2510 2511 pDevice->wCurrentRate = 11; 2512 pDevice->byACKRate = 8; 2513 pDevice->byTopCCKBasicRate = 3; 2514 pDevice->byTopOFDMBasicRate = 8; 2515 #endif 2516 2517 2518 } 2519 } 2520 2521 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate); 2522 2523 if (pDevice->wCurrentRate <= RATE_11M) { 2524 byPktType = PK_TYPE_11B; 2525 } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) { 2526 byPktType = PK_TYPE_11A; 2527 } else { 2528 if (pDevice->bProtectMode == true) { 2529 byPktType = PK_TYPE_11GB; 2530 } else { 2531 byPktType = PK_TYPE_11GA; 2532 } 2533 } 2534 2535 //#ifdef PLICE_DEBUG 2536 // printk("FIX RATE:CurrentRate is %d"); 2537 //#endif 2538 2539 if (bNeedEncryption == true) { 2540 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ntohs Pkt Type=%04x\n", ntohs(pDevice->sTxEthHeader.wType)); 2541 if ((pDevice->sTxEthHeader.wType) == TYPE_PKT_802_1x) { 2542 bNeedEncryption = false; 2543 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Pkt Type=%04x\n", (pDevice->sTxEthHeader.wType)); 2544 if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) { 2545 if (pTransmitKey == NULL) { 2546 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Don't Find TX KEY\n"); 2547 } 2548 else { 2549 if (bTKIP_UseGTK == true) { 2550 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"error: KEY is GTK!!~~\n"); 2551 } 2552 else { 2553 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%lX]\n", pTransmitKey->dwKeyIndex); 2554 bNeedEncryption = true; 2555 } 2556 } 2557 } 2558 2559 if (pDevice->byCntMeasure == 2) { 2560 bNeedDeAuth = true; 2561 pDevice->s802_11Counter.TKIPCounterMeasuresInvoked++; 2562 } 2563 2564 if (pDevice->bEnableHostWEP) { 2565 if ((uNodeIndex != 0) && 2566 (pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex & PAIRWISE_KEY)) { 2567 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%lX]\n", pTransmitKey->dwKeyIndex); 2568 bNeedEncryption = true; 2569 } 2570 } 2571 } 2572 else { 2573 if (pTransmitKey == NULL) { 2574 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"return no tx key\n"); 2575 dev_kfree_skb_irq(skb); 2576 spin_unlock_irq(&pDevice->lock); 2577 return 0; 2578 } 2579 } 2580 } 2581 2582 2583 #ifdef PLICE_DEBUG 2584 //if (skb->len == 98) 2585 //{ 2586 // printk("ping:len is %d\n"); 2587 //} 2588 #endif 2589 vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption, 2590 cbFrameBodySize, TYPE_AC0DMA, pHeadTD, 2591 &pDevice->sTxEthHeader, (unsigned char *)skb->data, pTransmitKey, uNodeIndex, 2592 &uMACfragNum, 2593 &cbHeaderSize 2594 ); 2595 2596 if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) { 2597 // Disable PS 2598 MACbPSWakeup(pDevice->PortOffset); 2599 } 2600 pDevice->bPWBitOn = false; 2601 2602 pLastTD = pHeadTD; 2603 for (ii = 0; ii < uMACfragNum; ii++) { 2604 // Poll Transmit the adapter 2605 wmb(); 2606 pHeadTD->m_td0TD0.f1Owner=OWNED_BY_NIC; 2607 wmb(); 2608 if (ii == uMACfragNum - 1) 2609 pLastTD = pHeadTD; 2610 pHeadTD = pHeadTD->next; 2611 } 2612 2613 // Save the information needed by the tx interrupt handler 2614 // to complete the Send request 2615 pLastTD->pTDInfo->skb = skb; 2616 pLastTD->pTDInfo->byFlags = 0; 2617 pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB; 2618 #ifdef TxInSleep 2619 pDevice->nTxDataTimeCout=0; //2008-8-21 chester <add> for send null packet 2620 #endif 2621 if (AVAIL_TD(pDevice, TYPE_AC0DMA) <= 1) { 2622 netif_stop_queue(dev); 2623 } 2624 2625 pDevice->apCurrTD[TYPE_AC0DMA] = pHeadTD; 2626 //#ifdef PLICE_DEBUG 2627 if (pDevice->bFixRate) 2628 { 2629 printk("FixRate:Rate is %d,TxPower is %d\n",pDevice->wCurrentRate,pDevice->byCurPwr); 2630 } 2631 else 2632 { 2633 //printk("Auto Rate:Rate is %d,TxPower is %d\n",pDevice->wCurrentRate,pDevice->byCurPwr); 2634 } 2635 //#endif 2636 2637 { 2638 unsigned char Protocol_Version; //802.1x Authentication 2639 unsigned char Packet_Type; //802.1x Authentication 2640 unsigned char Descriptor_type; 2641 unsigned short Key_info; 2642 bool bTxeapol_key = false; 2643 Protocol_Version = skb->data[ETH_HLEN]; 2644 Packet_Type = skb->data[ETH_HLEN+1]; 2645 Descriptor_type = skb->data[ETH_HLEN+1+1+2]; 2646 Key_info = (skb->data[ETH_HLEN+1+1+2+1] << 8)|(skb->data[ETH_HLEN+1+1+2+2]); 2647 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) { 2648 if(((Protocol_Version==1) ||(Protocol_Version==2)) && 2649 (Packet_Type==3)) { //802.1x OR eapol-key challenge frame transfer 2650 bTxeapol_key = true; 2651 if((Descriptor_type==254)||(Descriptor_type==2)) { //WPA or RSN 2652 if(!(Key_info & BIT3) && //group-key challenge 2653 (Key_info & BIT8) && (Key_info & BIT9)) { //send 2/2 key 2654 pDevice->fWPA_Authened = true; 2655 if(Descriptor_type==254) 2656 printk("WPA "); 2657 else 2658 printk("WPA2 "); 2659 printk("Authentication completed!!\n"); 2660 } 2661 } 2662 } 2663 } 2664 } 2665 2666 MACvTransmitAC0(pDevice->PortOffset); 2667 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0:pDevice->apCurrTD= %p\n", pHeadTD); 2668 2669 dev->trans_start = jiffies; 2670 2671 spin_unlock_irq(&pDevice->lock); 2672 return 0; 2673 2674 } 2675 2676 static irqreturn_t device_intr(int irq, void *dev_instance) { 2677 struct net_device* dev=dev_instance; 2678 PSDevice pDevice=(PSDevice) netdev_priv(dev); 2679 2680 int max_count=0; 2681 unsigned long dwMIBCounter=0; 2682 PSMgmtObject pMgmt = pDevice->pMgmt; 2683 unsigned char byOrgPageSel=0; 2684 int handled = 0; 2685 unsigned char byData = 0; 2686 int ii= 0; 2687 // unsigned char byRSSI; 2688 2689 2690 MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr); 2691 2692 if (pDevice->dwIsr == 0) 2693 return IRQ_RETVAL(handled); 2694 2695 if (pDevice->dwIsr == 0xffffffff) { 2696 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dwIsr = 0xffff\n"); 2697 return IRQ_RETVAL(handled); 2698 } 2699 /* 2700 // 2008-05-21 <mark> by Richardtai, we can't read RSSI here, because no packet bound with RSSI 2701 2702 if ((pDevice->dwIsr & ISR_RXDMA0) && 2703 (pDevice->byLocalID != REV_ID_VT3253_B0) && 2704 (pDevice->bBSSIDFilter == true)) { 2705 // update RSSI 2706 //BBbReadEmbeded(pDevice->PortOffset, 0x3E, &byRSSI); 2707 //pDevice->uCurrRSSI = byRSSI; 2708 } 2709 */ 2710 2711 handled = 1; 2712 MACvIntDisable(pDevice->PortOffset); 2713 spin_lock_irq(&pDevice->lock); 2714 2715 //Make sure current page is 0 2716 VNSvInPortB(pDevice->PortOffset + MAC_REG_PAGE1SEL, &byOrgPageSel); 2717 if (byOrgPageSel == 1) { 2718 MACvSelectPage0(pDevice->PortOffset); 2719 } 2720 else 2721 byOrgPageSel = 0; 2722 2723 MACvReadMIBCounter(pDevice->PortOffset, &dwMIBCounter); 2724 // TBD.... 2725 // Must do this after doing rx/tx, cause ISR bit is slow 2726 // than RD/TD write back 2727 // update ISR counter 2728 STAvUpdate802_11Counter(&pDevice->s802_11Counter, &pDevice->scStatistic , dwMIBCounter); 2729 while (pDevice->dwIsr != 0) { 2730 2731 STAvUpdateIsrStatCounter(&pDevice->scStatistic, pDevice->dwIsr); 2732 MACvWriteISR(pDevice->PortOffset, pDevice->dwIsr); 2733 2734 if (pDevice->dwIsr & ISR_FETALERR){ 2735 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " ISR_FETALERR \n"); 2736 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, 0); 2737 VNSvOutPortW(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPECTI); 2738 device_error(pDevice, pDevice->dwIsr); 2739 } 2740 2741 if (pDevice->byLocalID > REV_ID_VT3253_B1) { 2742 2743 if (pDevice->dwIsr & ISR_MEASURESTART) { 2744 // 802.11h measure start 2745 pDevice->byOrgChannel = pDevice->byCurrentCh; 2746 VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byOrgRCR)); 2747 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, (RCR_RXALLTYPE | RCR_UNICAST | RCR_BROADCAST | RCR_MULTICAST | RCR_WPAERR)); 2748 MACvSelectPage1(pDevice->PortOffset); 2749 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR0, &(pDevice->dwOrgMAR0)); 2750 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR4, &(pDevice->dwOrgMAR4)); 2751 MACvSelectPage0(pDevice->PortOffset); 2752 //xxxx 2753 // WCMDbFlushCommandQueue(pDevice->pMgmt, true); 2754 if (set_channel(pDevice, pDevice->pCurrMeasureEID->sReq.byChannel) == true) { 2755 pDevice->bMeasureInProgress = true; 2756 MACvSelectPage1(pDevice->PortOffset); 2757 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_READY); 2758 MACvSelectPage0(pDevice->PortOffset); 2759 pDevice->byBasicMap = 0; 2760 pDevice->byCCAFraction = 0; 2761 for(ii=0;ii<8;ii++) { 2762 pDevice->dwRPIs[ii] = 0; 2763 } 2764 } else { 2765 // can not measure because set channel fail 2766 // WCMDbResetCommandQueue(pDevice->pMgmt); 2767 // clear measure control 2768 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN); 2769 s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_INCAPABLE); 2770 MACvSelectPage1(pDevice->PortOffset); 2771 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE); 2772 MACvSelectPage0(pDevice->PortOffset); 2773 } 2774 } 2775 if (pDevice->dwIsr & ISR_MEASUREEND) { 2776 // 802.11h measure end 2777 pDevice->bMeasureInProgress = false; 2778 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byOrgRCR); 2779 MACvSelectPage1(pDevice->PortOffset); 2780 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, pDevice->dwOrgMAR0); 2781 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR4, pDevice->dwOrgMAR4); 2782 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRBBSTS, &byData); 2783 pDevice->byBasicMap |= (byData >> 4); 2784 VNSvInPortB(pDevice->PortOffset + MAC_REG_CCAFRACTION, &pDevice->byCCAFraction); 2785 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRCTL, &byData); 2786 // clear measure control 2787 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN); 2788 MACvSelectPage0(pDevice->PortOffset); 2789 set_channel(pDevice, pDevice->byOrgChannel); 2790 // WCMDbResetCommandQueue(pDevice->pMgmt); 2791 MACvSelectPage1(pDevice->PortOffset); 2792 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE); 2793 MACvSelectPage0(pDevice->PortOffset); 2794 if (byData & MSRCTL_FINISH) { 2795 // measure success 2796 s_vCompleteCurrentMeasure(pDevice, 0); 2797 } else { 2798 // can not measure because not ready before end of measure time 2799 s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_LATE); 2800 } 2801 } 2802 if (pDevice->dwIsr & ISR_QUIETSTART) { 2803 do { 2804 ; 2805 } while (CARDbStartQuiet(pDevice) == false); 2806 } 2807 } 2808 2809 if (pDevice->dwIsr & ISR_TBTT) { 2810 if (pDevice->bEnableFirstQuiet == true) { 2811 pDevice->byQuietStartCount--; 2812 if (pDevice->byQuietStartCount == 0) { 2813 pDevice->bEnableFirstQuiet = false; 2814 MACvSelectPage1(pDevice->PortOffset); 2815 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN)); 2816 MACvSelectPage0(pDevice->PortOffset); 2817 } 2818 } 2819 if ((pDevice->bChannelSwitch == true) && 2820 (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE)) { 2821 pDevice->byChannelSwitchCount--; 2822 if (pDevice->byChannelSwitchCount == 0) { 2823 pDevice->bChannelSwitch = false; 2824 set_channel(pDevice, pDevice->byNewChannel); 2825 VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel); 2826 MACvSelectPage1(pDevice->PortOffset); 2827 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE); 2828 MACvSelectPage0(pDevice->PortOffset); 2829 CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL); 2830 2831 } 2832 } 2833 if (pDevice->eOPMode == OP_MODE_ADHOC) { 2834 //pDevice->bBeaconSent = false; 2835 } else { 2836 if ((pDevice->bUpdateBBVGA) && (pDevice->bLinkPass == true) && (pDevice->uCurrRSSI != 0)) { 2837 long ldBm; 2838 2839 RFvRSSITodBm(pDevice, (unsigned char) pDevice->uCurrRSSI, &ldBm); 2840 for (ii=0;ii<BB_VGA_LEVEL;ii++) { 2841 if (ldBm < pDevice->ldBmThreshold[ii]) { 2842 pDevice->byBBVGANew = pDevice->abyBBVGA[ii]; 2843 break; 2844 } 2845 } 2846 if (pDevice->byBBVGANew != pDevice->byBBVGACurrent) { 2847 pDevice->uBBVGADiffCount++; 2848 if (pDevice->uBBVGADiffCount == 1) { 2849 // first VGA diff gain 2850 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew); 2851 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"First RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n", 2852 (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount); 2853 } 2854 if (pDevice->uBBVGADiffCount >= BB_VGA_CHANGE_THRESHOLD) { 2855 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n", 2856 (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount); 2857 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew); 2858 } 2859 } else { 2860 pDevice->uBBVGADiffCount = 1; 2861 } 2862 } 2863 } 2864 2865 pDevice->bBeaconSent = false; 2866 if (pDevice->bEnablePSMode) { 2867 PSbIsNextTBTTWakeUp((void *)pDevice); 2868 }; 2869 2870 if ((pDevice->eOPMode == OP_MODE_AP) || 2871 (pDevice->eOPMode == OP_MODE_ADHOC)) { 2872 2873 MACvOneShotTimer1MicroSec(pDevice->PortOffset, 2874 (pMgmt->wIBSSBeaconPeriod - MAKE_BEACON_RESERVED) << 10); 2875 } 2876 2877 if (pDevice->eOPMode == OP_MODE_ADHOC && pDevice->pMgmt->wCurrATIMWindow > 0) { 2878 // todo adhoc PS mode 2879 }; 2880 2881 } 2882 2883 if (pDevice->dwIsr & ISR_BNTX) { 2884 2885 if (pDevice->eOPMode == OP_MODE_ADHOC) { 2886 pDevice->bIsBeaconBufReadySet = false; 2887 pDevice->cbBeaconBufReadySetCnt = 0; 2888 }; 2889 2890 if (pDevice->eOPMode == OP_MODE_AP) { 2891 if(pMgmt->byDTIMCount > 0) { 2892 pMgmt->byDTIMCount --; 2893 pMgmt->sNodeDBTable[0].bRxPSPoll = false; 2894 } 2895 else { 2896 if(pMgmt->byDTIMCount == 0) { 2897 // check if mutltcast tx bufferring 2898 pMgmt->byDTIMCount = pMgmt->byDTIMPeriod - 1; 2899 pMgmt->sNodeDBTable[0].bRxPSPoll = true; 2900 bScheduleCommand((void *)pDevice, WLAN_CMD_RX_PSPOLL, NULL); 2901 } 2902 } 2903 } 2904 pDevice->bBeaconSent = true; 2905 2906 if (pDevice->bChannelSwitch == true) { 2907 pDevice->byChannelSwitchCount--; 2908 if (pDevice->byChannelSwitchCount == 0) { 2909 pDevice->bChannelSwitch = false; 2910 set_channel(pDevice, pDevice->byNewChannel); 2911 VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel); 2912 MACvSelectPage1(pDevice->PortOffset); 2913 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE); 2914 MACvSelectPage0(pDevice->PortOffset); 2915 //VNTWIFIbSendBeacon(pDevice->pMgmt); 2916 CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL); 2917 } 2918 } 2919 2920 } 2921 2922 if (pDevice->dwIsr & ISR_RXDMA0) { 2923 max_count += device_rx_srv(pDevice, TYPE_RXDMA0); 2924 } 2925 if (pDevice->dwIsr & ISR_RXDMA1) { 2926 max_count += device_rx_srv(pDevice, TYPE_RXDMA1); 2927 } 2928 if (pDevice->dwIsr & ISR_TXDMA0){ 2929 max_count += device_tx_srv(pDevice, TYPE_TXDMA0); 2930 } 2931 if (pDevice->dwIsr & ISR_AC0DMA){ 2932 max_count += device_tx_srv(pDevice, TYPE_AC0DMA); 2933 } 2934 if (pDevice->dwIsr & ISR_SOFTTIMER) { 2935 2936 } 2937 if (pDevice->dwIsr & ISR_SOFTTIMER1) { 2938 if (pDevice->eOPMode == OP_MODE_AP) { 2939 if (pDevice->bShortSlotTime) 2940 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTSLOTTIME(1); 2941 else 2942 pMgmt->wCurrCapInfo &= ~(WLAN_SET_CAP_INFO_SHORTSLOTTIME(1)); 2943 } 2944 bMgrPrepareBeaconToSend(pDevice, pMgmt); 2945 pDevice->byCntMeasure = 0; 2946 } 2947 2948 MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr); 2949 2950 MACvReceive0(pDevice->PortOffset); 2951 MACvReceive1(pDevice->PortOffset); 2952 2953 if (max_count>pDevice->sOpts.int_works) 2954 break; 2955 } 2956 2957 if (byOrgPageSel == 1) { 2958 MACvSelectPage1(pDevice->PortOffset); 2959 } 2960 2961 spin_unlock_irq(&pDevice->lock); 2962 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE); 2963 2964 return IRQ_RETVAL(handled); 2965 } 2966 2967 2968 static unsigned const ethernet_polynomial = 0x04c11db7U; 2969 static inline u32 ether_crc(int length, unsigned char *data) 2970 { 2971 int crc = -1; 2972 2973 while(--length >= 0) { 2974 unsigned char current_octet = *data++; 2975 int bit; 2976 for (bit = 0; bit < 8; bit++, current_octet >>= 1) { 2977 crc = (crc << 1) ^ 2978 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0); 2979 } 2980 } 2981 return crc; 2982 } 2983 2984 //2008-8-4 <add> by chester 2985 static int Config_FileGetParameter(unsigned char *string, 2986 unsigned char *dest, unsigned char *source) 2987 { 2988 unsigned char buf1[100]; 2989 int source_len = strlen(source); 2990 2991 memset(buf1,0,100); 2992 strcat(buf1, string); 2993 strcat(buf1, "="); 2994 source+=strlen(buf1); 2995 2996 memcpy(dest,source,source_len-strlen(buf1)); 2997 return true; 2998 } 2999 3000 int Config_FileOperation(PSDevice pDevice,bool fwrite,unsigned char *Parameter) { 3001 unsigned char *config_path = CONFIG_PATH; 3002 unsigned char *buffer = NULL; 3003 unsigned char tmpbuffer[20]; 3004 struct file *filp=NULL; 3005 mm_segment_t old_fs = get_fs(); 3006 //int oldfsuid=0,oldfsgid=0; 3007 int result=0; 3008 3009 set_fs (KERNEL_DS); 3010 3011 /* Can't do this anymore, so we rely on correct filesystem permissions: 3012 //Make sure a caller can read or write power as root 3013 oldfsuid=current->cred->fsuid; 3014 oldfsgid=current->cred->fsgid; 3015 current->cred->fsuid = 0; 3016 current->cred->fsgid = 0; 3017 */ 3018 3019 //open file 3020 filp = filp_open(config_path, O_RDWR, 0); 3021 if (IS_ERR(filp)) { 3022 printk("Config_FileOperation:open file fail?\n"); 3023 result=-1; 3024 goto error2; 3025 } 3026 3027 if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) { 3028 printk("file %s cann't readable or writable?\n",config_path); 3029 result = -1; 3030 goto error1; 3031 } 3032 3033 buffer = kmalloc(1024, GFP_KERNEL); 3034 if(buffer==NULL) { 3035 printk("alllocate mem for file fail?\n"); 3036 result = -1; 3037 goto error1; 3038 } 3039 3040 if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) { 3041 printk("read file error?\n"); 3042 result = -1; 3043 goto error1; 3044 } 3045 3046 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer)!=true) { 3047 printk("get parameter error?\n"); 3048 result = -1; 3049 goto error1; 3050 } 3051 3052 if(memcmp(tmpbuffer,"USA",3)==0) { 3053 result=ZoneType_USA; 3054 } 3055 else if(memcmp(tmpbuffer,"JAPAN",5)==0) { 3056 result=ZoneType_Japan; 3057 } 3058 else if(memcmp(tmpbuffer,"EUROPE",5)==0) { 3059 result=ZoneType_Europe; 3060 } 3061 else { 3062 result = -1; 3063 printk("Unknown Zonetype[%s]?\n",tmpbuffer); 3064 } 3065 3066 error1: 3067 if(buffer) 3068 kfree(buffer); 3069 3070 if(filp_close(filp,NULL)) 3071 printk("Config_FileOperation:close file fail\n"); 3072 3073 error2: 3074 set_fs (old_fs); 3075 3076 /* 3077 current->cred->fsuid=oldfsuid; 3078 current->cred->fsgid=oldfsgid; 3079 */ 3080 3081 return result; 3082 } 3083 3084 3085 3086 static void device_set_multi(struct net_device *dev) { 3087 PSDevice pDevice = (PSDevice) netdev_priv(dev); 3088 3089 PSMgmtObject pMgmt = pDevice->pMgmt; 3090 u32 mc_filter[2]; 3091 struct netdev_hw_addr *ha; 3092 3093 3094 VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byRxMode)); 3095 3096 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */ 3097 DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name); 3098 /* Unconditionally log net taps. */ 3099 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST); 3100 } 3101 else if ((netdev_mc_count(dev) > pDevice->multicast_limit) 3102 || (dev->flags & IFF_ALLMULTI)) { 3103 MACvSelectPage1(pDevice->PortOffset); 3104 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, 0xffffffff); 3105 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, 0xffffffff); 3106 MACvSelectPage0(pDevice->PortOffset); 3107 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST); 3108 } 3109 else { 3110 memset(mc_filter, 0, sizeof(mc_filter)); 3111 netdev_for_each_mc_addr(ha, dev) { 3112 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26; 3113 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31)); 3114 } 3115 MACvSelectPage1(pDevice->PortOffset); 3116 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, mc_filter[0]); 3117 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, mc_filter[1]); 3118 MACvSelectPage0(pDevice->PortOffset); 3119 pDevice->byRxMode &= ~(RCR_UNICAST); 3120 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST); 3121 } 3122 3123 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) { 3124 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac. 3125 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST); 3126 pDevice->byRxMode &= ~(RCR_UNICAST); 3127 } 3128 3129 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byRxMode); 3130 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode = %x\n", pDevice->byRxMode ); 3131 } 3132 3133 3134 static struct net_device_stats *device_get_stats(struct net_device *dev) { 3135 PSDevice pDevice=(PSDevice) netdev_priv(dev); 3136 3137 return &pDevice->stats; 3138 } 3139 3140 3141 3142 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) { 3143 PSDevice pDevice = (PSDevice)netdev_priv(dev); 3144 3145 struct iwreq *wrq = (struct iwreq *) rq; 3146 int rc =0; 3147 PSMgmtObject pMgmt = pDevice->pMgmt; 3148 PSCmdRequest pReq; 3149 3150 3151 if (pMgmt == NULL) { 3152 rc = -EFAULT; 3153 return rc; 3154 } 3155 3156 switch(cmd) { 3157 3158 case SIOCGIWNAME: 3159 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL); 3160 break; 3161 3162 case SIOCGIWNWID: //0x8b03 support 3163 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 3164 rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL); 3165 #else 3166 rc = -EOPNOTSUPP; 3167 #endif 3168 break; 3169 3170 // Set frequency/channel 3171 case SIOCSIWFREQ: 3172 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL); 3173 break; 3174 3175 // Get frequency/channel 3176 case SIOCGIWFREQ: 3177 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL); 3178 break; 3179 3180 // Set desired network name (ESSID) 3181 case SIOCSIWESSID: 3182 3183 { 3184 char essid[IW_ESSID_MAX_SIZE+1]; 3185 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) { 3186 rc = -E2BIG; 3187 break; 3188 } 3189 if (copy_from_user(essid, wrq->u.essid.pointer, 3190 wrq->u.essid.length)) { 3191 rc = -EFAULT; 3192 break; 3193 } 3194 rc = iwctl_siwessid(dev, NULL, 3195 &(wrq->u.essid), essid); 3196 } 3197 break; 3198 3199 3200 // Get current network name (ESSID) 3201 case SIOCGIWESSID: 3202 3203 { 3204 char essid[IW_ESSID_MAX_SIZE+1]; 3205 if (wrq->u.essid.pointer) 3206 rc = iwctl_giwessid(dev, NULL, 3207 &(wrq->u.essid), essid); 3208 if (copy_to_user(wrq->u.essid.pointer, 3209 essid, 3210 wrq->u.essid.length) ) 3211 rc = -EFAULT; 3212 } 3213 break; 3214 3215 case SIOCSIWAP: 3216 3217 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL); 3218 break; 3219 3220 3221 // Get current Access Point (BSSID) 3222 case SIOCGIWAP: 3223 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL); 3224 break; 3225 3226 3227 // Set desired station name 3228 case SIOCSIWNICKN: 3229 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n"); 3230 rc = -EOPNOTSUPP; 3231 break; 3232 3233 // Get current station name 3234 case SIOCGIWNICKN: 3235 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n"); 3236 rc = -EOPNOTSUPP; 3237 break; 3238 3239 // Set the desired bit-rate 3240 case SIOCSIWRATE: 3241 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL); 3242 break; 3243 3244 // Get the current bit-rate 3245 case SIOCGIWRATE: 3246 3247 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL); 3248 break; 3249 3250 // Set the desired RTS threshold 3251 case SIOCSIWRTS: 3252 3253 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL); 3254 break; 3255 3256 // Get the current RTS threshold 3257 case SIOCGIWRTS: 3258 3259 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL); 3260 break; 3261 3262 // Set the desired fragmentation threshold 3263 case SIOCSIWFRAG: 3264 3265 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL); 3266 break; 3267 3268 // Get the current fragmentation threshold 3269 case SIOCGIWFRAG: 3270 3271 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL); 3272 break; 3273 3274 // Set mode of operation 3275 case SIOCSIWMODE: 3276 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL); 3277 break; 3278 3279 // Get mode of operation 3280 case SIOCGIWMODE: 3281 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL); 3282 break; 3283 3284 // Set WEP keys and mode 3285 case SIOCSIWENCODE: 3286 { 3287 char abyKey[WLAN_WEP232_KEYLEN]; 3288 3289 if (wrq->u.encoding.pointer) { 3290 3291 3292 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) { 3293 rc = -E2BIG; 3294 break; 3295 } 3296 memset(abyKey, 0, WLAN_WEP232_KEYLEN); 3297 if (copy_from_user(abyKey, 3298 wrq->u.encoding.pointer, 3299 wrq->u.encoding.length)) { 3300 rc = -EFAULT; 3301 break; 3302 } 3303 } else if (wrq->u.encoding.length != 0) { 3304 rc = -EINVAL; 3305 break; 3306 } 3307 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey); 3308 } 3309 break; 3310 3311 // Get the WEP keys and mode 3312 case SIOCGIWENCODE: 3313 3314 if (!capable(CAP_NET_ADMIN)) { 3315 rc = -EPERM; 3316 break; 3317 } 3318 { 3319 char abyKey[WLAN_WEP232_KEYLEN]; 3320 3321 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey); 3322 if (rc != 0) break; 3323 if (wrq->u.encoding.pointer) { 3324 if (copy_to_user(wrq->u.encoding.pointer, 3325 abyKey, 3326 wrq->u.encoding.length)) 3327 rc = -EFAULT; 3328 } 3329 } 3330 break; 3331 3332 // Get the current Tx-Power 3333 case SIOCGIWTXPOW: 3334 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n"); 3335 rc = -EOPNOTSUPP; 3336 break; 3337 3338 case SIOCSIWTXPOW: 3339 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWTXPOW \n"); 3340 rc = -EOPNOTSUPP; 3341 break; 3342 3343 case SIOCSIWRETRY: 3344 3345 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL); 3346 break; 3347 3348 case SIOCGIWRETRY: 3349 3350 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL); 3351 break; 3352 3353 // Get range of parameters 3354 case SIOCGIWRANGE: 3355 3356 { 3357 struct iw_range range; 3358 3359 rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range); 3360 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range))) 3361 rc = -EFAULT; 3362 } 3363 3364 break; 3365 3366 case SIOCGIWPOWER: 3367 3368 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL); 3369 break; 3370 3371 3372 case SIOCSIWPOWER: 3373 3374 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL); 3375 break; 3376 3377 3378 case SIOCGIWSENS: 3379 3380 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL); 3381 break; 3382 3383 case SIOCSIWSENS: 3384 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n"); 3385 rc = -EOPNOTSUPP; 3386 break; 3387 3388 case SIOCGIWAPLIST: 3389 { 3390 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))]; 3391 3392 if (wrq->u.data.pointer) { 3393 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer); 3394 if (rc == 0) { 3395 if (copy_to_user(wrq->u.data.pointer, 3396 buffer, 3397 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality))) 3398 )) 3399 rc = -EFAULT; 3400 } 3401 } 3402 } 3403 break; 3404 3405 3406 #ifdef WIRELESS_SPY 3407 // Set the spy list 3408 case SIOCSIWSPY: 3409 3410 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n"); 3411 rc = -EOPNOTSUPP; 3412 break; 3413 3414 // Get the spy list 3415 case SIOCGIWSPY: 3416 3417 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWSPY \n"); 3418 rc = -EOPNOTSUPP; 3419 break; 3420 3421 #endif // WIRELESS_SPY 3422 3423 case SIOCGIWPRIV: 3424 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n"); 3425 rc = -EOPNOTSUPP; 3426 /* 3427 if(wrq->u.data.pointer) { 3428 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]); 3429 3430 if(copy_to_user(wrq->u.data.pointer, 3431 (u_char *) iwctl_private_args, 3432 sizeof(iwctl_private_args))) 3433 rc = -EFAULT; 3434 } 3435 */ 3436 break; 3437 3438 3439 //2008-0409-07, <Add> by Einsn Liu 3440 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 3441 case SIOCSIWAUTH: 3442 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n"); 3443 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL); 3444 break; 3445 3446 case SIOCGIWAUTH: 3447 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n"); 3448 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL); 3449 break; 3450 3451 case SIOCSIWGENIE: 3452 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n"); 3453 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer); 3454 break; 3455 3456 case SIOCGIWGENIE: 3457 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n"); 3458 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer); 3459 break; 3460 3461 case SIOCSIWENCODEEXT: 3462 { 3463 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1]; 3464 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n"); 3465 if(wrq->u.encoding.pointer){ 3466 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1); 3467 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){ 3468 rc = -E2BIG; 3469 break; 3470 } 3471 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){ 3472 rc = -EFAULT; 3473 break; 3474 } 3475 }else if(wrq->u.encoding.length != 0){ 3476 rc = -EINVAL; 3477 break; 3478 } 3479 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra); 3480 } 3481 break; 3482 3483 case SIOCGIWENCODEEXT: 3484 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n"); 3485 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL); 3486 break; 3487 3488 case SIOCSIWMLME: 3489 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n"); 3490 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer); 3491 break; 3492 3493 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 3494 //End Add -- //2008-0409-07, <Add> by Einsn Liu 3495 3496 case IOCTL_CMD_TEST: 3497 3498 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) { 3499 rc = -EFAULT; 3500 break; 3501 } else { 3502 rc = 0; 3503 } 3504 pReq = (PSCmdRequest)rq; 3505 pReq->wResult = MAGIC_CODE; 3506 break; 3507 3508 case IOCTL_CMD_SET: 3509 3510 #ifdef SndEvt_ToAPI 3511 if((((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_EVT) && 3512 !(pDevice->flags & DEVICE_FLAGS_OPENED)) 3513 #else 3514 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) && 3515 (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA)) 3516 #endif 3517 { 3518 rc = -EFAULT; 3519 break; 3520 } else { 3521 rc = 0; 3522 } 3523 3524 if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) { 3525 return -EBUSY; 3526 } 3527 rc = private_ioctl(pDevice, rq); 3528 clear_bit( 0, (void*)&(pMgmt->uCmdBusy)); 3529 break; 3530 3531 case IOCTL_CMD_HOSTAPD: 3532 3533 3534 rc = vt6655_hostap_ioctl(pDevice, &wrq->u.data); 3535 break; 3536 3537 case IOCTL_CMD_WPA: 3538 3539 rc = wpa_ioctl(pDevice, &wrq->u.data); 3540 break; 3541 3542 case SIOCETHTOOL: 3543 return ethtool_ioctl(dev, (void *) rq->ifr_data); 3544 // All other calls are currently unsupported 3545 3546 default: 3547 rc = -EOPNOTSUPP; 3548 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd); 3549 3550 3551 } 3552 3553 if (pDevice->bCommit) { 3554 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) { 3555 netif_stop_queue(pDevice->dev); 3556 spin_lock_irq(&pDevice->lock); 3557 bScheduleCommand((void *)pDevice, WLAN_CMD_RUN_AP, NULL); 3558 spin_unlock_irq(&pDevice->lock); 3559 } 3560 else { 3561 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n"); 3562 spin_lock_irq(&pDevice->lock); 3563 pDevice->bLinkPass = false; 3564 memset(pMgmt->abyCurrBSSID, 0, 6); 3565 pMgmt->eCurrState = WMAC_STATE_IDLE; 3566 netif_stop_queue(pDevice->dev); 3567 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT 3568 pMgmt->eScanType = WMAC_SCAN_ACTIVE; 3569 if(pDevice->bWPASuppWextEnabled !=true) 3570 #endif 3571 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID); 3572 bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL); 3573 spin_unlock_irq(&pDevice->lock); 3574 } 3575 pDevice->bCommit = false; 3576 } 3577 3578 return rc; 3579 } 3580 3581 3582 static int ethtool_ioctl(struct net_device *dev, void *useraddr) 3583 { 3584 u32 ethcmd; 3585 3586 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd))) 3587 return -EFAULT; 3588 3589 switch (ethcmd) { 3590 case ETHTOOL_GDRVINFO: { 3591 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO}; 3592 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1); 3593 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1); 3594 if (copy_to_user(useraddr, &info, sizeof(info))) 3595 return -EFAULT; 3596 return 0; 3597 } 3598 3599 } 3600 3601 return -EOPNOTSUPP; 3602 } 3603 3604 /*------------------------------------------------------------------*/ 3605 3606 MODULE_DEVICE_TABLE(pci, vt6655_pci_id_table); 3607 3608 static struct pci_driver device_driver = { 3609 name: DEVICE_NAME, 3610 id_table: vt6655_pci_id_table, 3611 probe: vt6655_probe, 3612 remove: vt6655_remove, 3613 #ifdef CONFIG_PM 3614 suspend: viawget_suspend, 3615 resume: viawget_resume, 3616 #endif 3617 }; 3618 3619 static int __init vt6655_init_module(void) 3620 { 3621 int ret; 3622 3623 3624 // ret=pci_module_init(&device_driver); 3625 //ret = pcie_port_service_register(&device_driver); 3626 ret = pci_register_driver(&device_driver); 3627 #ifdef CONFIG_PM 3628 if(ret >= 0) 3629 register_reboot_notifier(&device_notifier); 3630 #endif 3631 3632 return ret; 3633 } 3634 3635 static void __exit vt6655_cleanup_module(void) 3636 { 3637 3638 3639 #ifdef CONFIG_PM 3640 unregister_reboot_notifier(&device_notifier); 3641 #endif 3642 pci_unregister_driver(&device_driver); 3643 3644 } 3645 3646 module_init(vt6655_init_module); 3647 module_exit(vt6655_cleanup_module); 3648 3649 3650 #ifdef CONFIG_PM 3651 static int 3652 device_notify_reboot(struct notifier_block *nb, unsigned long event, void *p) 3653 { 3654 struct pci_dev *pdev = NULL; 3655 switch(event) { 3656 case SYS_DOWN: 3657 case SYS_HALT: 3658 case SYS_POWER_OFF: 3659 for_each_pci_dev(pdev) { 3660 if(pci_dev_driver(pdev) == &device_driver) { 3661 if (pci_get_drvdata(pdev)) 3662 viawget_suspend(pdev, PMSG_HIBERNATE); 3663 } 3664 } 3665 } 3666 return NOTIFY_DONE; 3667 } 3668 3669 static int 3670 viawget_suspend(struct pci_dev *pcid, pm_message_t state) 3671 { 3672 int power_status; // to silence the compiler 3673 3674 PSDevice pDevice=pci_get_drvdata(pcid); 3675 PSMgmtObject pMgmt = pDevice->pMgmt; 3676 3677 netif_stop_queue(pDevice->dev); 3678 spin_lock_irq(&pDevice->lock); 3679 pci_save_state(pcid); 3680 del_timer(&pDevice->sTimerCommand); 3681 del_timer(&pMgmt->sTimerSecondCallback); 3682 pDevice->cbFreeCmdQueue = CMD_Q_SIZE; 3683 pDevice->uCmdDequeueIdx = 0; 3684 pDevice->uCmdEnqueueIdx = 0; 3685 pDevice->bCmdRunning = false; 3686 MACbShutdown(pDevice->PortOffset); 3687 MACvSaveContext(pDevice->PortOffset, pDevice->abyMacContext); 3688 pDevice->bLinkPass = false; 3689 memset(pMgmt->abyCurrBSSID, 0, 6); 3690 pMgmt->eCurrState = WMAC_STATE_IDLE; 3691 pci_disable_device(pcid); 3692 power_status = pci_set_power_state(pcid, pci_choose_state(pcid, state)); 3693 spin_unlock_irq(&pDevice->lock); 3694 return 0; 3695 } 3696 3697 static int 3698 viawget_resume(struct pci_dev *pcid) 3699 { 3700 PSDevice pDevice=pci_get_drvdata(pcid); 3701 PSMgmtObject pMgmt = pDevice->pMgmt; 3702 int power_status; // to silence the compiler 3703 3704 3705 power_status = pci_set_power_state(pcid, 0); 3706 power_status = pci_enable_wake(pcid, 0, 0); 3707 pci_restore_state(pcid); 3708 if (netif_running(pDevice->dev)) { 3709 spin_lock_irq(&pDevice->lock); 3710 MACvRestoreContext(pDevice->PortOffset, pDevice->abyMacContext); 3711 device_init_registers(pDevice, DEVICE_INIT_DXPL); 3712 if (pMgmt->sNodeDBTable[0].bActive == true) { // Assoc with BSS 3713 pMgmt->sNodeDBTable[0].bActive = false; 3714 pDevice->bLinkPass = false; 3715 if(pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) { 3716 // In Adhoc, BSS state set back to started. 3717 pMgmt->eCurrState = WMAC_STATE_STARTED; 3718 } 3719 else { 3720 pMgmt->eCurrMode = WMAC_MODE_STANDBY; 3721 pMgmt->eCurrState = WMAC_STATE_IDLE; 3722 } 3723 } 3724 init_timer(&pMgmt->sTimerSecondCallback); 3725 init_timer(&pDevice->sTimerCommand); 3726 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE); 3727 BSSvClearBSSList((void *)pDevice, pDevice->bLinkPass); 3728 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL); 3729 bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL); 3730 spin_unlock_irq(&pDevice->lock); 3731 } 3732 return 0; 3733 } 3734 3735 #endif 3736 3737 3738 3739 3740