2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
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.
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.
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.
21 * Purpose: driver entry for initial, open, close, tx and rx.
29 * device_found1 - module initial (insmod) driver entry
30 * device_remove1 - module remove entry
31 * device_init_info - device structure resource allocation function
32 * device_free_info - device structure resource free function
33 * device_get_pci_info - get allocated pci io/mem resource
34 * device_print_info - print out resource
35 * device_open - allocate dma/descripter resource & initial mac/bbp function
36 * device_xmit - asynchrous data tx function
37 * device_intr - interrupt handle function
38 * device_set_multi - set mac filter
39 * device_ioctl - ioctl entry
40 * device_close - shutdown mac/bbp & free dma/descripter resource
41 * device_rx_srv - rx service function
42 * device_receive_frame - rx data function
43 * device_alloc_rx_buf - rx buffer pre-allocated function
44 * device_alloc_frag_buf - rx fragement pre-allocated function
45 * device_free_tx_buf - free tx buffer function
46 * device_free_frag_buf- free de-fragement buffer
47 * device_dma0_tx_80211- tx 802.11 frame via dma0
48 * device_dma0_xmit- tx PS bufferred frame via dma0
49 * device_init_rd0_ring- initial rd dma0 ring
50 * device_init_rd1_ring- initial rd dma1 ring
51 * device_init_td0_ring- initial tx dma0 ring buffer
52 * device_init_td1_ring- initial tx dma1 ring buffer
53 * device_init_registers- initial MAC & BBP & RF internal registers.
54 * device_init_rings- initial tx/rx ring buffer
55 * device_init_defrag_cb- initial & allocate de-fragement buffer.
56 * device_free_rings- free all allocated ring buffer
57 * device_tx_srv- tx interrupt service function
63 #if !defined(__DEVICE_H__)
66 #if !defined(__CARD_H__)
69 #if !defined(__TBIT_H__)
72 #if !defined(__BASEBAND_H__)
75 #if !defined(__MAC_H__)
78 #if !defined(__TETHER_H__)
81 #if !defined(__WMGR_H__)
84 #if !defined(__WCTL_H__)
87 #if !defined(__POWER_H__)
90 #if !defined(__WCMD_H__)
93 #if !defined(__IOCMD_H__)
96 #if !defined(__TCRC_H__)
99 #if !defined(__RXTX_H__)
102 #if !defined(__WROUTE_H__)
105 #if !defined(__BSSDB_H__)
108 #if !defined(__HOSTAP_H__)
111 #if !defined(__WPACTL_H__)
114 #if !defined(__IOCTL_H__)
117 #if !defined(__IWCTL_H__)
120 #if !defined(__DPC_H__)
123 #if !defined(__DATARATE_H__)
124 #include "datarate.h"
126 #if !defined(__RF_H__)
129 #if !defined(__IOWPA_H__)
133 #include <linux/delay.h>
134 #include <linux/kthread.h>
135 // #ifdef PRIVATE_OBJ
136 //#if !defined(__DEVICE_EXP_H)
137 //#include "device_exp.h"
139 //#if !defined(__DEVICE_MODULE_H)
140 //#include "device_module.h"
146 /*--------------------- Static Definitions -------------------------*/
147 //static int msglevel =MSG_LEVEL_DEBUG;
148 static int msglevel = MSG_LEVEL_INFO;
150 //#define PLICE_DEBUG
152 // Define module options
155 MODULE_AUTHOR("VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>");
156 MODULE_LICENSE("GPL");
157 MODULE_DESCRIPTION("VIA Networking Solomon-A/B/G Wireless LAN Adapter Driver");
161 static int mlme_kill;
162 //static struct task_struct * mlme_task;
165 #define DEVICE_PARAM(N,D)
167 static const int N[MAX_UINTS]=OPTION_DEFAULT;\
168 MODULE_PARM(N, "1-" __MODULE_STRING(MAX_UINTS) "i");\
169 MODULE_PARM_DESC(N, D);
172 #define RX_DESC_MIN0 16
173 #define RX_DESC_MAX0 128
174 #define RX_DESC_DEF0 32
175 DEVICE_PARAM(RxDescriptors0,"Number of receive descriptors0");
177 #define RX_DESC_MIN1 16
178 #define RX_DESC_MAX1 128
179 #define RX_DESC_DEF1 32
180 DEVICE_PARAM(RxDescriptors1,"Number of receive descriptors1");
182 #define TX_DESC_MIN0 16
183 #define TX_DESC_MAX0 128
184 #define TX_DESC_DEF0 32
185 DEVICE_PARAM(TxDescriptors0,"Number of transmit descriptors0");
187 #define TX_DESC_MIN1 16
188 #define TX_DESC_MAX1 128
189 #define TX_DESC_DEF1 64
190 DEVICE_PARAM(TxDescriptors1,"Number of transmit descriptors1");
193 #define IP_ALIG_DEF 0
194 /* IP_byte_align[] is used for IP header DWORD byte aligned
195 0: indicate the IP header won't be DWORD byte aligned.(Default) .
196 1: indicate the IP header will be DWORD byte aligned.
197 In some enviroment, the IP header should be DWORD byte aligned,
198 or the packet will be droped when we receive it. (eg: IPVS)
200 DEVICE_PARAM(IP_byte_align,"Enable IP header dword aligned");
203 #define INT_WORKS_DEF 20
204 #define INT_WORKS_MIN 10
205 #define INT_WORKS_MAX 64
207 DEVICE_PARAM(int_works,"Number of packets per interrupt services");
209 #define CHANNEL_MIN 1
210 #define CHANNEL_MAX 14
211 #define CHANNEL_DEF 6
213 DEVICE_PARAM(Channel, "Channel number");
216 /* PreambleType[] is the preamble length used for transmit.
217 0: indicate allows long preamble type
218 1: indicate allows short preamble type
221 #define PREAMBLE_TYPE_DEF 1
223 DEVICE_PARAM(PreambleType, "Preamble Type");
226 #define RTS_THRESH_MIN 512
227 #define RTS_THRESH_MAX 2347
228 #define RTS_THRESH_DEF 2347
230 DEVICE_PARAM(RTSThreshold, "RTS threshold");
233 #define FRAG_THRESH_MIN 256
234 #define FRAG_THRESH_MAX 2346
235 #define FRAG_THRESH_DEF 2346
237 DEVICE_PARAM(FragThreshold, "Fragmentation threshold");
240 #define DATA_RATE_MIN 0
241 #define DATA_RATE_MAX 13
242 #define DATA_RATE_DEF 13
244 0: indicate 1 Mbps 0x02
245 1: indicate 2 Mbps 0x04
246 2: indicate 5.5 Mbps 0x0B
247 3: indicate 11 Mbps 0x16
248 4: indicate 6 Mbps 0x0c
249 5: indicate 9 Mbps 0x12
250 6: indicate 12 Mbps 0x18
251 7: indicate 18 Mbps 0x24
252 8: indicate 24 Mbps 0x30
253 9: indicate 36 Mbps 0x48
254 10: indicate 48 Mbps 0x60
255 11: indicate 54 Mbps 0x6c
256 12: indicate 72 Mbps 0x90
257 13: indicate auto rate
260 DEVICE_PARAM(ConnectionRate, "Connection data rate");
262 #define OP_MODE_DEF 0
264 DEVICE_PARAM(OPMode, "Infrastruct, adhoc, AP mode ");
266 /* OpMode[] is used for transmit.
267 0: indicate infrastruct mode used
268 1: indicate adhoc mode used
269 2: indicate AP mode used
274 0: indicate disable power saving mode
275 1: indicate enable power saving mode
278 #define PS_MODE_DEF 0
280 DEVICE_PARAM(PSMode, "Power saving mode");
283 #define SHORT_RETRY_MIN 0
284 #define SHORT_RETRY_MAX 31
285 #define SHORT_RETRY_DEF 8
288 DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits");
290 #define LONG_RETRY_MIN 0
291 #define LONG_RETRY_MAX 15
292 #define LONG_RETRY_DEF 4
295 DEVICE_PARAM(LongRetryLimit, "long frame retry limits");
298 /* BasebandType[] baseband type selected
299 0: indicate 802.11a type
300 1: indicate 802.11b type
301 2: indicate 802.11g type
303 #define BBP_TYPE_MIN 0
304 #define BBP_TYPE_MAX 2
305 #define BBP_TYPE_DEF 2
307 DEVICE_PARAM(BasebandType, "baseband type");
312 0: indicate disable 802.11h
313 1: indicate enable 802.11h
316 #define X80211h_MODE_DEF 0
318 DEVICE_PARAM(b80211hEnable, "802.11h mode");
321 0: indicate disable 802.11h
322 1: indicate enable 802.11h
325 #define DIVERSITY_ANT_DEF 0
327 DEVICE_PARAM(bDiversityANTEnable, "ANT diversity mode");
331 // Static vars definitions
336 static int device_nics =0;
337 static PSDevice pDevice_Infos =NULL;
338 static struct net_device *root_device_dev = NULL;
340 static CHIP_INFO chip_info_table[]= {
341 { VT3253, "VIA Networking Solomon-A/B/G Wireless LAN Adapter ",
342 256, 1, DEVICE_FLAGS_IP_ALIGN|DEVICE_FLAGS_TX_ALIGN },
346 static struct pci_device_id device_id_table[] __devinitdata = {
347 { 0x1106, 0x3253, PCI_ANY_ID, PCI_ANY_ID, 0, 0, (int)&chip_info_table[0]},
352 /*--------------------- Static Functions --------------------------*/
356 static int device_found1(struct pci_dev *pcid, const struct pci_device_id *ent);
357 static BOOL device_init_info(struct pci_dev* pcid, PSDevice* ppDevice, PCHIP_INFO);
358 static void device_free_info(PSDevice pDevice);
359 static BOOL device_get_pci_info(PSDevice, struct pci_dev* pcid);
360 static void device_print_info(PSDevice pDevice);
361 static struct net_device_stats *device_get_stats(struct net_device *dev);
362 static void device_init_diversity_timer(PSDevice pDevice);
363 static int device_open(struct net_device *dev);
364 static int device_xmit(struct sk_buff *skb, struct net_device *dev);
365 static irqreturn_t device_intr(int irq, void*dev_instance);
366 static void device_set_multi(struct net_device *dev);
367 static int device_close(struct net_device *dev);
368 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
371 static int device_notify_reboot(struct notifier_block *, unsigned long event, void *ptr);
372 static int viawget_suspend(struct pci_dev *pcid, u32 state);
373 static int viawget_resume(struct pci_dev *pcid);
374 struct notifier_block device_notifier = {
375 notifier_call: device_notify_reboot,
381 #endif // #ifndef PRIVATE_OBJ
383 static void device_init_rd0_ring(PSDevice pDevice);
384 static void device_init_rd1_ring(PSDevice pDevice);
385 static void device_init_defrag_cb(PSDevice pDevice);
386 static void device_init_td0_ring(PSDevice pDevice);
387 static void device_init_td1_ring(PSDevice pDevice);
390 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
392 //2008-0714<Add>by Mike Liu
393 static BOOL device_release_WPADEV(PSDevice pDevice);
395 static int ethtool_ioctl(struct net_device *dev, void *useraddr);
396 static int device_rx_srv(PSDevice pDevice, UINT uIdx);
397 static int device_tx_srv(PSDevice pDevice, UINT uIdx);
398 static BOOL device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pDesc);
399 static void device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType);
400 static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc);
401 static void device_free_td0_ring(PSDevice pDevice);
402 static void device_free_td1_ring(PSDevice pDevice);
403 static void device_free_rd0_ring(PSDevice pDevice);
404 static void device_free_rd1_ring(PSDevice pDevice);
405 static void device_free_rings(PSDevice pDevice);
406 static void device_free_frag_buf(PSDevice pDevice);
407 static int Config_FileGetParameter(UCHAR *string, UCHAR *dest,UCHAR *source);
410 /*--------------------- Export Variables --------------------------*/
412 /*--------------------- Export Functions --------------------------*/
417 static char* get_chip_name(int chip_id) {
419 for (i=0;chip_info_table[i].name!=NULL;i++)
420 if (chip_info_table[i].chip_id==chip_id)
422 return chip_info_table[i].name;
425 static void __devexit device_remove1(struct pci_dev *pcid)
427 PSDevice pDevice=pci_get_drvdata(pcid);
431 device_free_info(pDevice);
438 device_set_int_opt(int *opt, int val, int min, int max, int def,char* name,char* devname) {
441 else if (val<min || val>max) {
442 DEVICE_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: the value of parameter %s is invalid, the valid range is (%d-%d)\n" ,
443 devname,name, min,max);
446 DEVICE_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: set value of parameter %s to %d\n",
453 device_set_bool_opt(PU32 opt, int val,BOOL def,U32 flag, char* name,char* devname) {
456 *opt|=(def ? flag : 0);
457 else if (val<0 || val>1) {
458 DEVICE_PRT(MSG_LEVEL_INFO, KERN_NOTICE
459 "%s: the value of parameter %s is invalid, the valid range is (0-1)\n",devname,name);
460 *opt|=(def ? flag : 0);
462 DEVICE_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: set parameter %s to %s\n",
463 devname,name , val ? "TRUE" : "FALSE");
464 *opt|=(val ? flag : 0);
469 device_get_options(PSDevice pDevice, int index, char* devname) {
471 POPTIONS pOpts = &(pDevice->sOpts);
472 pOpts->nRxDescs0=RX_DESC_DEF0;
473 pOpts->nRxDescs1=RX_DESC_DEF1;
474 pOpts->nTxDescs[0]=TX_DESC_DEF0;
475 pOpts->nTxDescs[1]=TX_DESC_DEF1;
476 pOpts->flags|=DEVICE_FLAGS_IP_ALIGN;
477 pOpts->int_works=INT_WORKS_DEF;
478 pOpts->rts_thresh=RTS_THRESH_DEF;
479 pOpts->frag_thresh=FRAG_THRESH_DEF;
480 pOpts->data_rate=DATA_RATE_DEF;
481 pOpts->channel_num=CHANNEL_DEF;
483 pOpts->flags|=DEVICE_FLAGS_PREAMBLE_TYPE;
484 pOpts->flags|=DEVICE_FLAGS_OP_MODE;
485 //pOpts->flags|=DEVICE_FLAGS_PS_MODE;
486 pOpts->short_retry=SHORT_RETRY_DEF;
487 pOpts->long_retry=LONG_RETRY_DEF;
488 pOpts->bbp_type=BBP_TYPE_DEF;
489 pOpts->flags|=DEVICE_FLAGS_80211h_MODE;
490 pOpts->flags|=DEVICE_FLAGS_DiversityANT;
496 device_set_options(PSDevice pDevice) {
498 BYTE abyBroadcastAddr[U_ETHER_ADDR_LEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
499 BYTE abySNAP_RFC1042[U_ETHER_ADDR_LEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
500 BYTE abySNAP_Bridgetunnel[U_ETHER_ADDR_LEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
503 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, U_ETHER_ADDR_LEN);
504 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, U_ETHER_ADDR_LEN);
505 memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, U_ETHER_ADDR_LEN);
507 pDevice->uChannel = pDevice->sOpts.channel_num;
508 pDevice->wRTSThreshold = pDevice->sOpts.rts_thresh;
509 pDevice->wFragmentationThreshold = pDevice->sOpts.frag_thresh;
510 pDevice->byShortRetryLimit = pDevice->sOpts.short_retry;
511 pDevice->byLongRetryLimit = pDevice->sOpts.long_retry;
512 pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
513 pDevice->byShortPreamble = (pDevice->sOpts.flags & DEVICE_FLAGS_PREAMBLE_TYPE) ? 1 : 0;
514 pDevice->byOpMode = (pDevice->sOpts.flags & DEVICE_FLAGS_OP_MODE) ? 1 : 0;
515 pDevice->ePSMode = (pDevice->sOpts.flags & DEVICE_FLAGS_PS_MODE) ? 1 : 0;
516 pDevice->b11hEnable = (pDevice->sOpts.flags & DEVICE_FLAGS_80211h_MODE) ? 1 : 0;
517 pDevice->bDiversityRegCtlON = (pDevice->sOpts.flags & DEVICE_FLAGS_DiversityANT) ? 1 : 0;
518 pDevice->uConnectionRate = pDevice->sOpts.data_rate;
519 if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = TRUE;
520 pDevice->byBBType = pDevice->sOpts.bbp_type;
521 pDevice->byPacketType = pDevice->byBBType;
524 pDevice->byAutoFBCtrl = AUTO_FB_0;
525 //pDevice->byAutoFBCtrl = AUTO_FB_1;
527 pDevice->bUpdateBBVGA = TRUE;
528 pDevice->byFOETuning = 0;
529 pDevice->wCTSDuration = 0;
530 pDevice->byPreambleType = 0;
533 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" uChannel= %d\n",(INT)pDevice->uChannel);
534 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byOpMode= %d\n",(INT)pDevice->byOpMode);
535 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" ePSMode= %d\n",(INT)pDevice->ePSMode);
536 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" wRTSThreshold= %d\n",(INT)pDevice->wRTSThreshold);
537 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byShortRetryLimit= %d\n",(INT)pDevice->byShortRetryLimit);
538 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byLongRetryLimit= %d\n",(INT)pDevice->byLongRetryLimit);
539 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byPreambleType= %d\n",(INT)pDevice->byPreambleType);
540 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byShortPreamble= %d\n",(INT)pDevice->byShortPreamble);
541 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" uConnectionRate= %d\n",(INT)pDevice->uConnectionRate);
542 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byBBType= %d\n",(INT)pDevice->byBBType);
543 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" pDevice->b11hEnable= %d\n",(INT)pDevice->b11hEnable);
544 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" pDevice->bDiversityRegCtlON= %d\n",(INT)pDevice->bDiversityRegCtlON);
547 static VOID s_vCompleteCurrentMeasure (IN PSDevice pDevice, IN BYTE byResult)
550 DWORD dwDuration = 0;
553 for(ii=1;ii<8;ii++) {
554 pDevice->dwRPIs[ii] *= 255;
555 dwDuration |= *((PWORD) (pDevice->pCurrMeasureEID->sReq.abyDuration));
557 pDevice->dwRPIs[ii] /= dwDuration;
558 pDevice->abyRPIs[ii] = (BYTE) pDevice->dwRPIs[ii];
559 byRPI0 += pDevice->abyRPIs[ii];
561 pDevice->abyRPIs[0] = (0xFF - byRPI0);
563 if (pDevice->uNumOfMeasureEIDs == 0) {
564 VNTWIFIbMeasureReport( pDevice->pMgmt,
566 pDevice->pCurrMeasureEID,
569 pDevice->byCCAFraction,
573 VNTWIFIbMeasureReport( pDevice->pMgmt,
575 pDevice->pCurrMeasureEID,
578 pDevice->byCCAFraction,
581 CARDbStartMeasure (pDevice, pDevice->pCurrMeasureEID++, pDevice->uNumOfMeasureEIDs);
589 // Initialiation of MAC & BBP registers
592 static void device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType)
597 BYTE byCCKPwrdBm = 0;
598 BYTE byOFDMPwrdBm = 0;
600 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
601 MACbShutdown(pDevice->PortOffset);
602 BBvSoftwareReset(pDevice->PortOffset);
604 if ((InitType == DEVICE_INIT_COLD) ||
605 (InitType == DEVICE_INIT_DXPL)) {
606 // Do MACbSoftwareReset in MACvInitialize
607 MACbSoftwareReset(pDevice->PortOffset);
609 pDevice->bCCK = TRUE;
610 pDevice->bAES = FALSE;
611 pDevice->bProtectMode = FALSE; //Only used in 11g type, sync with ERP IE
612 pDevice->bNonERPPresent = FALSE;
613 pDevice->bBarkerPreambleMd = FALSE;
614 pDevice->wCurrentRate = RATE_1M;
615 pDevice->byTopOFDMBasicRate = RATE_24M;
616 pDevice->byTopCCKBasicRate = RATE_1M;
618 pDevice->byRevId = 0; //Target to IF pin while programming to RF chip.
621 MACvInitialize(pDevice->PortOffset);
624 VNSvInPortB(pDevice->PortOffset + MAC_REG_LOCALID, &(pDevice->byLocalID));
626 spin_lock_irq(&pDevice->lock);
627 SROMvReadAllContents(pDevice->PortOffset,pDevice->abyEEPROM);
629 spin_unlock_irq(&pDevice->lock);
633 pDevice->byMinChannel = 1;
634 pDevice->byMaxChannel = CB_MAX_CHANNEL;
637 byValue = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ANTENNA);
638 if (byValue & EEP_ANTINV)
639 pDevice->bTxRxAntInv = TRUE;
641 pDevice->bTxRxAntInv = FALSE;
643 //printk("init_register:TxRxAntInv is %d,byValue is %d\n",pDevice->bTxRxAntInv,byValue);
646 byValue &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
647 if (byValue == 0) // if not set default is All
648 byValue = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
650 //printk("init_register:byValue is %d\n",byValue);
652 pDevice->ulDiversityNValue = 100*260;//100*SROMbyReadEmbedded(pDevice->PortOffset, 0x51);
653 pDevice->ulDiversityMValue = 100*16;//SROMbyReadEmbedded(pDevice->PortOffset, 0x52);
654 pDevice->byTMax = 1;//SROMbyReadEmbedded(pDevice->PortOffset, 0x53);
655 pDevice->byTMax2 = 4;//SROMbyReadEmbedded(pDevice->PortOffset, 0x54);
656 pDevice->ulSQ3TH = 0;//(ULONG) SROMbyReadEmbedded(pDevice->PortOffset, 0x55);
657 pDevice->byTMax3 = 64;//SROMbyReadEmbedded(pDevice->PortOffset, 0x56);
659 if (byValue == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
660 pDevice->byAntennaCount = 2;
661 pDevice->byTxAntennaMode = ANT_B;
662 pDevice->dwTxAntennaSel = 1;
663 pDevice->dwRxAntennaSel = 1;
664 if (pDevice->bTxRxAntInv == TRUE)
665 pDevice->byRxAntennaMode = ANT_A;
667 pDevice->byRxAntennaMode = ANT_B;
668 // chester for antenna
669 byValue1 = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ANTENNA);
670 // if (pDevice->bDiversityRegCtlON)
671 if((byValue1&0x08)==0)
672 pDevice->bDiversityEnable = FALSE;//SROMbyReadEmbedded(pDevice->PortOffset, 0x50);
674 pDevice->bDiversityEnable = TRUE;
676 //printk("aux |main antenna: RxAntennaMode is %d\n",pDevice->byRxAntennaMode);
679 pDevice->bDiversityEnable = FALSE;
680 pDevice->byAntennaCount = 1;
681 pDevice->dwTxAntennaSel = 0;
682 pDevice->dwRxAntennaSel = 0;
683 if (byValue & EEP_ANTENNA_AUX) {
684 pDevice->byTxAntennaMode = ANT_A;
685 if (pDevice->bTxRxAntInv == TRUE)
686 pDevice->byRxAntennaMode = ANT_B;
688 pDevice->byRxAntennaMode = ANT_A;
690 pDevice->byTxAntennaMode = ANT_B;
691 if (pDevice->bTxRxAntInv == TRUE)
692 pDevice->byRxAntennaMode = ANT_A;
694 pDevice->byRxAntennaMode = ANT_B;
698 //printk("init registers: TxAntennaMode is %d\n",pDevice->byTxAntennaMode);
700 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "bDiversityEnable=[%d],NValue=[%d],MValue=[%d],TMax=[%d],TMax2=[%d]\n",
701 pDevice->bDiversityEnable,(int)pDevice->ulDiversityNValue,(int)pDevice->ulDiversityMValue,pDevice->byTMax,pDevice->byTMax2);
703 //#ifdef ZoneType_DefaultSetting
704 //2008-8-4 <add> by chester
706 pDevice->byOriginalZonetype = pDevice->abyEEPROM[EEP_OFS_ZONETYPE];
707 if((zonetype=Config_FileOperation(pDevice,FALSE,NULL)) >= 0) { //read zonetype file ok!
708 if ((zonetype == 0)&&
709 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] !=0x00)){ //for USA
710 pDevice->abyEEPROM[EEP_OFS_ZONETYPE] = 0;
711 pDevice->abyEEPROM[EEP_OFS_MAXCHANNEL] = 0x0B;
712 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Init Zone Type :USA\n");
714 else if((zonetype == 1)&&
715 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE]!=0x01)){ //for Japan
716 pDevice->abyEEPROM[EEP_OFS_ZONETYPE] = 0x01;
717 pDevice->abyEEPROM[EEP_OFS_MAXCHANNEL] = 0x0D;
719 else if((zonetype == 2)&&
720 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE]!=0x02)){ //for Europe
721 pDevice->abyEEPROM[EEP_OFS_ZONETYPE] = 0x02;
722 pDevice->abyEEPROM[EEP_OFS_MAXCHANNEL] = 0x0D;
723 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Init Zone Type :Europe\n");
728 if(zonetype!=pDevice->abyEEPROM[EEP_OFS_ZONETYPE])
729 printk("zonetype in file[%02x] mismatch with in EEPROM[%02x]\n",zonetype,pDevice->abyEEPROM[EEP_OFS_ZONETYPE]);
731 printk("Read Zonetype file sucess,use default zonetype setting[%02x]\n",zonetype);
735 printk("Read Zonetype file fail,use default zonetype setting[%02x]\n",SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ZONETYPE));
738 pDevice->byRFType = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RFTYPE);
740 if ((pDevice->byRFType & RF_EMU) != 0) {
741 // force change RevID for VT3253 emu
742 pDevice->byRevId = 0x80;
745 pDevice->byRFType &= RF_MASK;
746 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRFType = %x\n", pDevice->byRFType);
748 if (pDevice->bZoneRegExist == FALSE) {
749 pDevice->byZoneType = pDevice->abyEEPROM[EEP_OFS_ZONETYPE];
751 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byZoneType = %x\n", pDevice->byZoneType);
756 //Get Desire Power Value
757 pDevice->byCurPwr = 0xFF;
758 pDevice->byCCKPwr = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_PWR_CCK);
759 pDevice->byOFDMPwrG = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_PWR_OFDMG);
760 //byCCKPwrdBm = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_CCK_PWR_dBm);
762 //byOFDMPwrdBm = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_OFDM_PWR_dBm);
763 //printk("CCKPwrdBm is 0x%x,byOFDMPwrdBm is 0x%x\n",byCCKPwrdBm,byOFDMPwrdBm);
767 for (ii=0;ii<CB_MAX_CHANNEL_24G;ii++) {
768 pDevice->abyCCKPwrTbl[ii+1] = SROMbyReadEmbedded(pDevice->PortOffset, (BYTE)(ii + EEP_OFS_CCK_PWR_TBL));
769 if (pDevice->abyCCKPwrTbl[ii+1] == 0) {
770 pDevice->abyCCKPwrTbl[ii+1] = pDevice->byCCKPwr;
772 pDevice->abyOFDMPwrTbl[ii+1] = SROMbyReadEmbedded(pDevice->PortOffset, (BYTE)(ii + EEP_OFS_OFDM_PWR_TBL));
773 if (pDevice->abyOFDMPwrTbl[ii+1] == 0) {
774 pDevice->abyOFDMPwrTbl[ii+1] = pDevice->byOFDMPwrG;
776 pDevice->abyCCKDefaultPwr[ii+1] = byCCKPwrdBm;
777 pDevice->abyOFDMDefaultPwr[ii+1] = byOFDMPwrdBm;
779 //2008-8-4 <add> by chester
780 //recover 12,13 ,14channel for EUROPE by 11 channel
781 if(((pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Japan) ||
782 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Europe))&&
783 (pDevice->byOriginalZonetype == ZoneType_USA)) {
784 for(ii=11;ii<14;ii++) {
785 pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];
786 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];
792 // Load OFDM A Power Table
793 for (ii=0;ii<CB_MAX_CHANNEL_5G;ii++) { //RobertYu:20041224, bug using CB_MAX_CHANNEL
794 pDevice->abyOFDMPwrTbl[ii+CB_MAX_CHANNEL_24G+1] = SROMbyReadEmbedded(pDevice->PortOffset, (BYTE)(ii + EEP_OFS_OFDMA_PWR_TBL));
795 pDevice->abyOFDMDefaultPwr[ii+CB_MAX_CHANNEL_24G+1] = SROMbyReadEmbedded(pDevice->PortOffset, (BYTE)(ii + EEP_OFS_OFDMA_PWR_dBm));
797 CARDvInitChannelTable((PVOID)pDevice);
800 if (pDevice->byLocalID > REV_ID_VT3253_B1) {
801 MACvSelectPage1(pDevice->PortOffset);
802 VNSvOutPortB(pDevice->PortOffset + MAC_REG_MSRCTL + 1, (MSRCTL1_TXPWR | MSRCTL1_CSAPAREN));
803 MACvSelectPage0(pDevice->PortOffset);
807 // use relative tx timeout and 802.11i D4
808 MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_CFG, (CFG_TKIPOPT | CFG_NOTXTIMEOUT));
810 // set performance parameter by registry
811 MACvSetShortRetryLimit(pDevice->PortOffset, pDevice->byShortRetryLimit);
812 MACvSetLongRetryLimit(pDevice->PortOffset, pDevice->byLongRetryLimit);
815 VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
816 // enable TSF counter
817 VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
819 // initialize BBP registers
820 BBbVT3253Init(pDevice);
822 if (pDevice->bUpdateBBVGA) {
823 pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
824 pDevice->byBBVGANew = pDevice->byBBVGACurrent;
825 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
828 //printk("init registers:RxAntennaMode is %x,TxAntennaMode is %x\n",pDevice->byRxAntennaMode,pDevice->byTxAntennaMode);
830 BBvSetRxAntennaMode(pDevice->PortOffset, pDevice->byRxAntennaMode);
831 BBvSetTxAntennaMode(pDevice->PortOffset, pDevice->byTxAntennaMode);
833 pDevice->byCurrentCh = 0;
835 //pDevice->NetworkType = Ndis802_11Automode;
836 // Set BB and packet type at the same time.
837 // Set Short Slot Time, xIFS, and RSPINF.
838 if (pDevice->uConnectionRate == RATE_AUTO) {
839 pDevice->wCurrentRate = RATE_54M;
841 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
845 VNTWIFIbConfigPhyMode(pDevice->pMgmt, PHY_TYPE_11G);
846 VNTWIFIbConfigPhyMode(pDevice->pMgmt, PHY_TYPE_AUTO);
848 pDevice->bRadioOff = FALSE;
850 pDevice->byRadioCtl = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RADIOCTL);
851 pDevice->bHWRadioOff = FALSE;
853 if (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) {
855 MACvGPIOIn(pDevice->PortOffset, &pDevice->byGPIO);
856 //2008-4-14 <add> by chester for led issue
857 #ifdef FOR_LED_ON_NOTEBOOK
858 if (BITbIsBitOn(pDevice->byGPIO,GPIO0_DATA)){pDevice->bHWRadioOff = TRUE;}
859 if (BITbIsBitOff(pDevice->byGPIO,GPIO0_DATA)){pDevice->bHWRadioOff = FALSE;}
862 if ( (pDevice->bRadioControlOff == TRUE)) {
863 CARDbRadioPowerOff(pDevice);
865 else CARDbRadioPowerOn(pDevice);
867 if ((BITbIsBitOn(pDevice->byGPIO,GPIO0_DATA) && BITbIsBitOff(pDevice->byRadioCtl, EEP_RADIOCTL_INV)) ||
868 (BITbIsBitOff(pDevice->byGPIO,GPIO0_DATA) && BITbIsBitOn(pDevice->byRadioCtl, EEP_RADIOCTL_INV))) {
869 pDevice->bHWRadioOff = TRUE;
872 if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) {
873 CARDbRadioPowerOff(pDevice);
878 pMgmt->eScanType = WMAC_SCAN_PASSIVE;
879 // get Permanent network address
880 SROMvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr);
881 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %02x-%02x-%02x=%02x-%02x-%02x\n",
882 pDevice->abyCurrentNetAddr[0],
883 pDevice->abyCurrentNetAddr[1],
884 pDevice->abyCurrentNetAddr[2],
885 pDevice->abyCurrentNetAddr[3],
886 pDevice->abyCurrentNetAddr[4],
887 pDevice->abyCurrentNetAddr[5]);
891 CARDvSafeResetRx(pDevice);
893 CARDvSafeResetTx(pDevice);
895 if (pDevice->byLocalID <= REV_ID_VT3253_A1) {
896 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_RCR, RCR_WPAERR);
899 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
902 MACvReceive0(pDevice->PortOffset);
903 MACvReceive1(pDevice->PortOffset);
906 MACvStart(pDevice->PortOffset);
908 netif_stop_queue(pDevice->dev);
915 static VOID device_init_diversity_timer(PSDevice pDevice) {
917 init_timer(&pDevice->TimerSQ3Tmax1);
918 pDevice->TimerSQ3Tmax1.data = (ULONG)pDevice;
919 pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
920 pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
922 init_timer(&pDevice->TimerSQ3Tmax2);
923 pDevice->TimerSQ3Tmax2.data = (ULONG)pDevice;
924 pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
925 pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
927 init_timer(&pDevice->TimerSQ3Tmax3);
928 pDevice->TimerSQ3Tmax3.data = (ULONG)pDevice;
929 pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerState1CallBack;
930 pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
936 static BOOL device_release_WPADEV(PSDevice pDevice)
938 viawget_wpa_header *wpahdr;
940 // wait_queue_head_t Set_wait;
941 //send device close to wpa_supplicnat layer
942 if (pDevice->bWPADEVUp==TRUE) {
943 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
944 wpahdr->type = VIAWGET_DEVICECLOSE_MSG;
945 wpahdr->resp_ie_len = 0;
946 wpahdr->req_ie_len = 0;
947 skb_put(pDevice->skb, sizeof(viawget_wpa_header));
948 pDevice->skb->dev = pDevice->wpadev;
949 pDevice->skb->mac_header = pDevice->skb->data;
950 pDevice->skb->pkt_type = PACKET_HOST;
951 pDevice->skb->protocol = htons(ETH_P_802_2);
952 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
953 netif_rx(pDevice->skb);
954 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
956 //wait release WPADEV
957 // init_waitqueue_head(&Set_wait);
958 // wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ); //1s wait
959 while((pDevice->bWPADEVUp==TRUE)) {
960 set_current_state(TASK_UNINTERRUPTIBLE);
961 schedule_timeout (HZ/20); //wait 50ms
971 static const struct net_device_ops device_netdev_ops = {
972 .ndo_open = device_open,
973 .ndo_stop = device_close,
974 .ndo_do_ioctl = device_ioctl,
975 .ndo_get_stats = device_get_stats,
976 .ndo_start_xmit = device_xmit,
977 .ndo_set_multicast_list = device_set_multi,
984 device_found1(struct pci_dev *pcid, const struct pci_device_id *ent)
986 static BOOL bFirst = TRUE;
987 struct net_device* dev = NULL;
988 PCHIP_INFO pChip_info = (PCHIP_INFO)ent->driver_data;
991 if (device_nics ++>= MAX_UINTS) {
992 printk(KERN_NOTICE DEVICE_NAME ": already found %d NICs\n", device_nics);
997 dev = alloc_etherdev(sizeof(DEVICE_INFO));
999 pDevice = (PSDevice) netdev_priv(dev);
1002 printk(KERN_ERR DEVICE_NAME ": allocate net device failed \n");
1006 // Chain it all together
1007 // SET_MODULE_OWNER(dev);
1008 SET_NETDEV_DEV(dev, &pcid->dev);
1011 printk(KERN_NOTICE "%s Ver. %s\n",DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
1012 printk(KERN_NOTICE "Copyright (c) 2003 VIA Networking Technologies, Inc.\n");
1016 if (!device_init_info(pcid, &pDevice, pChip_info)) {
1020 pDevice->next_module = root_device_dev;
1021 root_device_dev = dev;
1022 dev->irq = pcid->irq;
1024 if (pci_enable_device(pcid)) {
1025 device_free_info(pDevice);
1029 printk("Before get pci_info memaddr is %x\n",pDevice->memaddr);
1031 if (device_get_pci_info(pDevice,pcid) == FALSE) {
1032 printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device.\n");
1033 device_free_info(pDevice);
1041 //pci_read_config_byte(pcid, PCI_BASE_ADDRESS_0, &pDevice->byRevId);
1042 printk("after get pci_info memaddr is %x, io addr is %x,io_size is %d\n",pDevice->memaddr,pDevice->ioaddr,pDevice->io_size);
1054 for (i=0;address[i];i++)
1056 //pci_write_config_dword(pcid,address[i], 0xFFFFFFFF);
1057 pci_read_config_dword(pcid, address[i], &bar);
1058 printk("bar %d is %x\n",i,bar);
1061 printk("bar %d not implemented\n",i);
1064 if (bar & PCI_BASE_ADDRESS_SPACE_IO) {
1067 len = bar & (PCI_BASE_ADDRESS_IO_MASK & 0xFFFF);
1068 len = len & ~(len - 1);
1070 printk("IO space: len in IO %x, BAR %d\n", len, i);
1074 len = bar & 0xFFFFFFF0;
1077 printk("len in MEM %x, BAR %d\n", len, i);
1089 pDevice->PortOffset = (DWORD)ioremap(pDevice->memaddr & PCI_BASE_ADDRESS_MEM_MASK, pDevice->io_size);
1090 //pDevice->PortOffset = (DWORD)ioremap(pDevice->ioaddr & PCI_BASE_ADDRESS_IO_MASK, pDevice->io_size);
1092 if(pDevice->PortOffset == 0) {
1093 printk(KERN_ERR DEVICE_NAME ": Failed to IO remapping ..\n");
1094 device_free_info(pDevice);
1101 rc = pci_request_regions(pcid, DEVICE_NAME);
1103 printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device\n");
1104 device_free_info(pDevice);
1108 dev->base_addr = pDevice->ioaddr;
1112 VNSvInPortB(pDevice->PortOffset+0x4F, &value);
1113 printk("Before write: value is %x\n",value);
1114 //VNSvInPortB(pDevice->PortOffset+0x3F, 0x00);
1115 VNSvOutPortB(pDevice->PortOffset,value);
1116 VNSvInPortB(pDevice->PortOffset+0x4F, &value);
1117 printk("After write: value is %x\n",value);
1123 pDevice->PortOffset = pDevice->ioaddr;
1126 if (!MACbSoftwareReset(pDevice->PortOffset)) {
1127 printk(KERN_ERR DEVICE_NAME ": Failed to access MAC hardware..\n");
1128 device_free_info(pDevice);
1131 // initial to reload eeprom
1132 MACvInitialize(pDevice->PortOffset);
1133 MACvReadEtherAddress(pDevice->PortOffset, dev->dev_addr);
1135 device_get_options(pDevice, device_nics-1, dev->name);
1136 device_set_options(pDevice);
1137 //Mask out the options cannot be set to the chip
1138 pDevice->sOpts.flags &= pChip_info->flags;
1140 //Enable the chip specified capbilities
1141 pDevice->flags = pDevice->sOpts.flags | (pChip_info->flags & 0xFF000000UL);
1142 pDevice->tx_80211 = device_dma0_tx_80211;
1143 pDevice->sMgmtObj.pAdapter = (PVOID)pDevice;
1144 pDevice->pMgmt = &(pDevice->sMgmtObj);
1146 dev->irq = pcid->irq;
1147 dev->netdev_ops = &device_netdev_ops;
1150 //Einsn Modify for ubuntu-7.04
1151 // dev->wireless_handlers->get_wireless_stats = iwctl_get_wireless_stats;
1152 #if WIRELESS_EXT > 12
1153 dev->wireless_handlers = (struct iw_handler_def *)&iwctl_handler_def;
1154 // netdev->wireless_handlers = NULL;
1155 #endif /* WIRELESS_EXT > 12 */
1156 #endif /* WIRELESS_EXT */
1158 rc = register_netdev(dev);
1161 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
1162 device_free_info(pDevice);
1165 //2008-07-21-01<Add>by MikeLiu
1167 if(wpa_set_wpadev(pDevice, 1)!=0) {
1168 printk("Fail to Register WPADEV?\n");
1169 unregister_netdev(pDevice->dev);
1172 device_print_info(pDevice);
1173 pci_set_drvdata(pcid, pDevice);
1178 static void device_print_info(PSDevice pDevice)
1180 struct net_device* dev=pDevice->dev;
1182 DEVICE_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: %s\n",dev->name, get_chip_name(pDevice->chip_id));
1183 DEVICE_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: MAC=%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X",
1185 dev->dev_addr[0],dev->dev_addr[1],dev->dev_addr[2],
1186 dev->dev_addr[3],dev->dev_addr[4],dev->dev_addr[5]);
1188 DEVICE_PRT(MSG_LEVEL_INFO, KERN_INFO" IO=0x%lx ",(ULONG) pDevice->ioaddr);
1189 DEVICE_PRT(MSG_LEVEL_INFO, KERN_INFO" IRQ=%d \n", pDevice->dev->irq);
1191 DEVICE_PRT(MSG_LEVEL_INFO, KERN_INFO" IO=0x%lx Mem=0x%lx ",(ULONG) pDevice->ioaddr,(ULONG) pDevice->PortOffset);
1192 DEVICE_PRT(MSG_LEVEL_INFO, KERN_INFO" IRQ=%d \n", pDevice->dev->irq);
1197 static BOOL device_init_info(struct pci_dev* pcid, PSDevice* ppDevice,
1198 PCHIP_INFO pChip_info) {
1202 memset(*ppDevice,0,sizeof(DEVICE_INFO));
1204 if (pDevice_Infos == NULL) {
1205 pDevice_Infos =*ppDevice;
1208 for (p=pDevice_Infos;p->next!=NULL;p=p->next)
1210 p->next = *ppDevice;
1211 (*ppDevice)->prev = p;
1214 (*ppDevice)->pcid = pcid;
1215 (*ppDevice)->chip_id = pChip_info->chip_id;
1216 (*ppDevice)->io_size = pChip_info->io_size;
1217 (*ppDevice)->nTxQueues = pChip_info->nTxQueue;
1218 (*ppDevice)->multicast_limit =32;
1220 spin_lock_init(&((*ppDevice)->lock));
1225 static BOOL device_get_pci_info(PSDevice pDevice, struct pci_dev* pcid) {
1231 BYTE pci_config[256];
1235 memset(pci_config,0x00,256);
1238 pci_read_config_byte(pcid, PCI_REVISION_ID, &pDevice->byRevId);
1239 pci_read_config_word(pcid, PCI_SUBSYSTEM_ID,&pDevice->SubSystemID);
1240 pci_read_config_word(pcid, PCI_SUBSYSTEM_VENDOR_ID, &pDevice->SubVendorID);
1241 pci_read_config_word(pcid, PCI_COMMAND, (u16 *) & (pci_cmd));
1243 pci_set_master(pcid);
1245 pDevice->memaddr = pci_resource_start(pcid,0);
1246 pDevice->ioaddr = pci_resource_start(pcid,1);
1249 // pDevice->ioaddr = pci_resource_start(pcid, 0);
1250 // pDevice->memaddr = pci_resource_start(pcid,1);
1253 cis_addr = pci_resource_start(pcid,2);
1255 pDevice->pcid = pcid;
1257 pci_read_config_byte(pcid, PCI_REG_COMMAND, &b);
1258 pci_write_config_byte(pcid, PCI_REG_COMMAND, (b|COMMAND_BUSM));
1261 //pci_read_config_word(pcid,PCI_REG_MAX_LAT,&max_lat);
1262 //printk("max lat is %x,SubSystemID is %x\n",max_lat,pDevice->SubSystemID);
1263 //for (ii=0;ii<0xFF;ii++)
1264 //pci_read_config_word(pcid,PCI_REG_MAX_LAT,&max_lat);
1266 //pci_write_config_word(pcid,PCI_REG_MAX_LAT,max_lat);
1267 //pci_read_config_word(pcid,PCI_REG_MAX_LAT,&max_lat);
1268 //printk("max lat is %x\n",max_lat);
1270 for (ii=0;ii<0xFF;ii++)
1272 pci_read_config_byte(pcid,ii,&value);
1273 pci_config[ii] = value;
1275 for (ii=0,j=1;ii<0x100;ii++,j++)
1279 printk("%x:",pci_config[ii]);
1284 printk("%x:",pci_config[ii]);
1291 static void device_free_info(PSDevice pDevice) {
1293 struct net_device* dev=pDevice->dev;
1296 //2008-0714-01<Add>by chester
1297 device_release_WPADEV(pDevice);
1299 //2008-07-21-01<Add>by MikeLiu
1301 if(wpa_set_wpadev(pDevice, 0)!=0)
1302 printk("unregister wpadev fail?\n");
1304 if (pDevice_Infos==NULL)
1307 for (ptr=pDevice_Infos;ptr && (ptr!=pDevice);ptr=ptr->next)
1311 if (ptr==pDevice_Infos)
1312 pDevice_Infos=ptr->next;
1314 ptr->prev->next=ptr->next;
1317 DEVICE_PRT(MSG_LEVEL_ERR, KERN_ERR "info struct not found\n");
1322 hostap_set_hostapd(pDevice, 0, 0);
1325 unregister_netdev(dev);
1327 if (pDevice->PortOffset)
1328 iounmap((PVOID)pDevice->PortOffset);
1331 pci_release_regions(pDevice->pcid);
1335 if (pDevice->pcid) {
1336 pci_set_drvdata(pDevice->pcid,NULL);
1339 #endif// ifndef PRIVATE_OBJ
1341 static BOOL device_init_rings(PSDevice pDevice) {
1345 /*allocate all RD/TD rings a single pool*/
1346 vir_pool = pci_alloc_consistent(pDevice->pcid,
1347 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1348 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1349 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1350 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc),
1351 &pDevice->pool_dma);
1353 if (vir_pool == NULL) {
1354 DEVICE_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate desc dma memory failed\n", pDevice->dev->name);
1359 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1360 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1361 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1362 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc)
1365 pDevice->aRD0Ring = vir_pool;
1366 pDevice->aRD1Ring = vir_pool +
1367 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1370 pDevice->rd0_pool_dma = pDevice->pool_dma;
1371 pDevice->rd1_pool_dma = pDevice->rd0_pool_dma +
1372 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1374 pDevice->tx0_bufs = pci_alloc_consistent(pDevice->pcid,
1375 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1376 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1377 CB_BEACON_BUF_SIZE +
1379 &pDevice->tx_bufs_dma0);
1381 if (pDevice->tx0_bufs == NULL) {
1382 DEVICE_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: allocate buf dma memory failed\n", pDevice->dev->name);
1383 pci_free_consistent(pDevice->pcid,
1384 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1385 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1386 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1387 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc),
1388 vir_pool, pDevice->pool_dma
1393 memset(pDevice->tx0_bufs, 0,
1394 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1395 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1396 CB_BEACON_BUF_SIZE +
1400 pDevice->td0_pool_dma = pDevice->rd1_pool_dma +
1401 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1403 pDevice->td1_pool_dma = pDevice->td0_pool_dma +
1404 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1407 // vir_pool: pvoid type
1408 pDevice->apTD0Rings = vir_pool
1409 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1410 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1412 pDevice->apTD1Rings = vir_pool
1413 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1414 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc)
1415 + pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1418 pDevice->tx1_bufs = pDevice->tx0_bufs +
1419 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1422 pDevice->tx_beacon_bufs = pDevice->tx1_bufs +
1423 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1425 pDevice->pbyTmpBuff = pDevice->tx_beacon_bufs +
1428 pDevice->tx_bufs_dma1 = pDevice->tx_bufs_dma0 +
1429 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1432 pDevice->tx_beacon_dma = pDevice->tx_bufs_dma1 +
1433 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1439 static void device_free_rings(PSDevice pDevice) {
1441 pci_free_consistent(pDevice->pcid,
1442 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1443 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1444 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1445 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc)
1447 pDevice->aRD0Ring, pDevice->pool_dma
1450 if (pDevice->tx0_bufs)
1451 pci_free_consistent(pDevice->pcid,
1452 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1453 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1454 CB_BEACON_BUF_SIZE +
1456 pDevice->tx0_bufs, pDevice->tx_bufs_dma0
1460 static void device_init_rd0_ring(PSDevice pDevice) {
1462 dma_addr_t curr = pDevice->rd0_pool_dma;
1465 /* Init the RD0 ring entries */
1466 for (i = 0; i < pDevice->sOpts.nRxDescs0; i ++, curr += sizeof(SRxDesc)) {
1467 pDesc = &(pDevice->aRD0Ring[i]);
1468 pDesc->pRDInfo = alloc_rd_info();
1469 ASSERT(pDesc->pRDInfo);
1470 if (!device_alloc_rx_buf(pDevice, pDesc)) {
1471 DEVICE_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc rx bufs\n",
1472 pDevice->dev->name);
1474 pDesc->next = &(pDevice->aRD0Ring[(i+1) % pDevice->sOpts.nRxDescs0]);
1475 pDesc->pRDInfo->curr_desc = cpu_to_le32(curr);
1476 pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc));
1479 pDevice->aRD0Ring[i-1].next_desc = cpu_to_le32(pDevice->rd0_pool_dma);
1480 pDevice->pCurrRD[0] = &(pDevice->aRD0Ring[0]);
1484 static void device_init_rd1_ring(PSDevice pDevice) {
1486 dma_addr_t curr = pDevice->rd1_pool_dma;
1489 /* Init the RD1 ring entries */
1490 for (i = 0; i < pDevice->sOpts.nRxDescs1; i ++, curr += sizeof(SRxDesc)) {
1491 pDesc = &(pDevice->aRD1Ring[i]);
1492 pDesc->pRDInfo = alloc_rd_info();
1493 ASSERT(pDesc->pRDInfo);
1494 if (!device_alloc_rx_buf(pDevice, pDesc)) {
1495 DEVICE_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc rx bufs\n",
1496 pDevice->dev->name);
1498 pDesc->next = &(pDevice->aRD1Ring[(i+1) % pDevice->sOpts.nRxDescs1]);
1499 pDesc->pRDInfo->curr_desc = cpu_to_le32(curr);
1500 pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc));
1503 pDevice->aRD1Ring[i-1].next_desc = cpu_to_le32(pDevice->rd1_pool_dma);
1504 pDevice->pCurrRD[1] = &(pDevice->aRD1Ring[0]);
1508 static void device_init_defrag_cb(PSDevice pDevice) {
1510 PSDeFragControlBlock pDeF;
1512 /* Init the fragment ctl entries */
1513 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1514 pDeF = &(pDevice->sRxDFCB[i]);
1515 if (!device_alloc_frag_buf(pDevice, pDeF)) {
1516 DEVICE_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
1517 pDevice->dev->name);
1520 pDevice->cbDFCB = CB_MAX_RX_FRAG;
1521 pDevice->cbFreeDFCB = pDevice->cbDFCB;
1527 static void device_free_rd0_ring(PSDevice pDevice) {
1530 for (i = 0; i < pDevice->sOpts.nRxDescs0; i++) {
1531 PSRxDesc pDesc =&(pDevice->aRD0Ring[i]);
1532 PDEVICE_RD_INFO pRDInfo =pDesc->pRDInfo;
1534 pci_unmap_single(pDevice->pcid,pRDInfo->skb_dma,
1535 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1537 dev_kfree_skb(pRDInfo->skb);
1539 kfree((PVOID)pDesc->pRDInfo);
1544 static void device_free_rd1_ring(PSDevice pDevice) {
1548 for (i = 0; i < pDevice->sOpts.nRxDescs1; i++) {
1549 PSRxDesc pDesc=&(pDevice->aRD1Ring[i]);
1550 PDEVICE_RD_INFO pRDInfo=pDesc->pRDInfo;
1552 pci_unmap_single(pDevice->pcid,pRDInfo->skb_dma,
1553 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1555 dev_kfree_skb(pRDInfo->skb);
1557 kfree((PVOID)pDesc->pRDInfo);
1562 static void device_free_frag_buf(PSDevice pDevice) {
1563 PSDeFragControlBlock pDeF;
1566 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1568 pDeF = &(pDevice->sRxDFCB[i]);
1571 dev_kfree_skb(pDeF->skb);
1577 static void device_init_td0_ring(PSDevice pDevice) {
1582 curr = pDevice->td0_pool_dma;
1583 for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++, curr += sizeof(STxDesc)) {
1584 pDesc = &(pDevice->apTD0Rings[i]);
1585 pDesc->pTDInfo = alloc_td_info();
1586 ASSERT(pDesc->pTDInfo);
1587 if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) {
1588 pDesc->pTDInfo->buf = pDevice->tx0_bufs + (i)*PKT_BUF_SZ;
1589 pDesc->pTDInfo->buf_dma = pDevice->tx_bufs_dma0 + (i)*PKT_BUF_SZ;
1591 pDesc->next =&(pDevice->apTD0Rings[(i+1) % pDevice->sOpts.nTxDescs[0]]);
1592 pDesc->pTDInfo->curr_desc = cpu_to_le32(curr);
1593 pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc));
1596 pDevice->apTD0Rings[i-1].next_desc = cpu_to_le32(pDevice->td0_pool_dma);
1597 pDevice->apTailTD[0] = pDevice->apCurrTD[0] =&(pDevice->apTD0Rings[0]);
1601 static void device_init_td1_ring(PSDevice pDevice) {
1606 /* Init the TD ring entries */
1607 curr=pDevice->td1_pool_dma;
1608 for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++, curr+=sizeof(STxDesc)) {
1609 pDesc=&(pDevice->apTD1Rings[i]);
1610 pDesc->pTDInfo = alloc_td_info();
1611 ASSERT(pDesc->pTDInfo);
1612 if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) {
1613 pDesc->pTDInfo->buf=pDevice->tx1_bufs+(i)*PKT_BUF_SZ;
1614 pDesc->pTDInfo->buf_dma=pDevice->tx_bufs_dma1+(i)*PKT_BUF_SZ;
1616 pDesc->next=&(pDevice->apTD1Rings[(i+1) % pDevice->sOpts.nTxDescs[1]]);
1617 pDesc->pTDInfo->curr_desc = cpu_to_le32(curr);
1618 pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc));
1621 pDevice->apTD1Rings[i-1].next_desc = cpu_to_le32(pDevice->td1_pool_dma);
1622 pDevice->apTailTD[1] = pDevice->apCurrTD[1] = &(pDevice->apTD1Rings[0]);
1627 static void device_free_td0_ring(PSDevice pDevice) {
1629 for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++) {
1630 PSTxDesc pDesc=&(pDevice->apTD0Rings[i]);
1631 PDEVICE_TD_INFO pTDInfo=pDesc->pTDInfo;
1633 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma))
1634 pci_unmap_single(pDevice->pcid,pTDInfo->skb_dma,
1635 pTDInfo->skb->len, PCI_DMA_TODEVICE);
1638 dev_kfree_skb(pTDInfo->skb);
1640 kfree((PVOID)pDesc->pTDInfo);
1644 static void device_free_td1_ring(PSDevice pDevice) {
1647 for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++) {
1648 PSTxDesc pDesc=&(pDevice->apTD1Rings[i]);
1649 PDEVICE_TD_INFO pTDInfo=pDesc->pTDInfo;
1651 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma))
1652 pci_unmap_single(pDevice->pcid, pTDInfo->skb_dma,
1653 pTDInfo->skb->len, PCI_DMA_TODEVICE);
1656 dev_kfree_skb(pTDInfo->skb);
1658 kfree((PVOID)pDesc->pTDInfo);
1665 /*-----------------------------------------------------------------*/
1667 static int device_rx_srv(PSDevice pDevice, UINT uIdx) {
1672 for (pRD = pDevice->pCurrRD[uIdx];
1673 pRD->m_rd0RD0.f1Owner == OWNED_BY_HOST;
1675 // DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->pCurrRD = %x, works = %d\n", pRD, works);
1678 if (device_receive_frame(pDevice, pRD)) {
1679 if (!device_alloc_rx_buf(pDevice,pRD)) {
1680 DEVICE_PRT(MSG_LEVEL_ERR, KERN_ERR
1681 "%s: can not allocate rx buf\n", pDevice->dev->name);
1685 pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1687 ref_set_rx_jiffies(pDevice->dev);
1689 pDevice->dev->last_rx = jiffies;
1693 pDevice->pCurrRD[uIdx]=pRD;
1699 static BOOL device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pRD) {
1701 PDEVICE_RD_INFO pRDInfo=pRD->pRDInfo;
1705 pRDInfo->skb=dev_alloc_skb(pDevice->rx_buf_sz);
1706 if (pRDInfo->skb==NULL)
1708 ref_skb_remap(pDevice->dev, &(pRDInfo->ref_skb), pRDInfo->skb);
1709 pRDInfo->skb_dma = pci_map_single(pDevice->pcid, pRDInfo->ref_skb.tail, pDevice->rx_buf_sz,
1710 PCI_DMA_FROMDEVICE);
1713 pRDInfo->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1715 //printk("device_alloc_rx_buf:skb is %x\n",pRDInfo->skb);
1717 if (pRDInfo->skb==NULL)
1719 ASSERT(pRDInfo->skb);
1720 pRDInfo->skb->dev = pDevice->dev;
1721 pRDInfo->skb_dma = pci_map_single(pDevice->pcid, pRDInfo->skb->tail, pDevice->rx_buf_sz,
1722 PCI_DMA_FROMDEVICE);
1724 *((PU32) &(pRD->m_rd0RD0)) = 0;
1726 pRD->m_rd0RD0.wResCount = cpu_to_le16(pDevice->rx_buf_sz);
1727 pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1728 pRD->m_rd1RD1.wReqCount = cpu_to_le16(pDevice->rx_buf_sz);
1729 pRD->buff_addr = cpu_to_le32(pRDInfo->skb_dma);
1736 BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1740 pDeF->skb=dev_alloc_skb(pDevice->rx_buf_sz);
1741 if (pDeF->skb==NULL)
1743 ref_skb_remap(pDevice->dev, &(pDeF->ref_skb), pDeF->skb);
1746 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1747 if (pDeF->skb == NULL)
1750 pDeF->skb->dev = pDevice->dev;
1758 static int device_tx_srv(PSDevice pDevice, UINT uIdx) {
1764 UINT uFrameSize, uFIFOHeaderSize;
1765 PSTxBufHead pTxBufHead;
1766 struct net_device_stats* pStats = &pDevice->stats;
1767 struct sk_buff* skb;
1769 PSMgmtObject pMgmt = pDevice->pMgmt;
1771 ref_sk_buff ref_skb;
1775 for (pTD = pDevice->apTailTD[uIdx]; pDevice->iTDUsed[uIdx] >0; pTD = pTD->next) {
1777 if (pTD->m_td0TD0.f1Owner == OWNED_BY_NIC)
1782 byTsr0 = pTD->m_td0TD0.byTSR0;
1783 byTsr1 = pTD->m_td0TD0.byTSR1;
1785 //Only the status of first TD in the chain is correct
1786 if (pTD->m_td1TD1.byTCR & TCR_STP) {
1788 if ((pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0) {
1789 uFIFOHeaderSize = pTD->pTDInfo->dwHeaderLength;
1790 uFrameSize = pTD->pTDInfo->dwReqCount - uFIFOHeaderSize;
1791 pTxBufHead = (PSTxBufHead) (pTD->pTDInfo->buf);
1793 ref_skb_remap(pDevice->dev, &ref_skb, pTD->pTDInfo->skb);
1795 // Update the statistics based on the Transmit status
1796 // now, we DO'NT check TSR0_CDH
1798 STAvUpdateTDStatCounter(&pDevice->scStatistic,
1800 (PBYTE)(pTD->pTDInfo->buf + uFIFOHeaderSize),
1804 BSSvUpdateNodeTxCounter(pDevice,
1806 (PBYTE)(pTD->pTDInfo->buf),
1810 if (BITbIsBitOff(byTsr1, TSR1_TERR)) {
1812 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] OK but has error. tsr1[%02X] tsr0[%02X].\n",
1813 (INT)uIdx, byTsr1, byTsr0);
1815 if ((pTxBufHead->wFragCtl & FRAGCTL_ENDFRAG) != FRAGCTL_NONFRAG) {
1816 pDevice->s802_11Counter.TransmittedFragmentCount ++;
1818 pStats->tx_packets++;
1820 pStats->tx_bytes += *(ref_skb.len);
1822 pStats->tx_bytes += pTD->pTDInfo->skb->len;
1826 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] dropped & tsr1[%02X] tsr0[%02X].\n",
1827 (INT)uIdx, byTsr1, byTsr0);
1828 pStats->tx_errors++;
1829 pStats->tx_dropped++;
1833 if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
1834 if (pDevice->bEnableHostapd) {
1835 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx call back netif.. \n");
1837 ref_skb_remap(pDevice->apdev, &(ref_skb), pTD->pTDInfo->skb);
1838 ref_skb.mac.raw = ref_skb.data;
1839 *(ref_skb.pkt_type) = PACKET_OTHERHOST;
1840 //*(ref_skb.protocol) = htons(ETH_P_802_2);
1841 memset(ref_skb.cb, 0, sizeof(ref_skb.cb));
1842 netif_rx(ref_skb.skb);
1844 skb = pTD->pTDInfo->skb;
1845 skb->dev = pDevice->apdev;
1846 skb->mac_header = skb->data;
1847 skb->pkt_type = PACKET_OTHERHOST;
1848 //skb->protocol = htons(ETH_P_802_2);
1849 memset(skb->cb, 0, sizeof(skb->cb));
1855 if (BITbIsBitOn(byTsr1, TSR1_TERR)) {
1856 if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
1857 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
1858 (INT)uIdx, byTsr1, byTsr0);
1861 // DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
1862 // (INT)uIdx, byTsr1, byTsr0);
1864 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) &&
1865 (pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB)) {
1867 BYTE byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
1869 skb = pTD->pTDInfo->skb;
1870 if (BSSDBbIsSTAInNodeDB(pMgmt, (PBYTE)(skb->data), &uNodeIndex)) {
1871 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
1872 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
1873 pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
1875 wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
1876 pMgmt->abyPSTxMap[wAID >> 3] |= byMask[wAID & 7];
1877 pTD->pTDInfo->byFlags &= ~(TD_FLAGS_NETIF_SKB);
1878 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx_srv:tx fail re-queue sta index= %d, QueCnt= %d\n"
1879 ,(INT)uNodeIndex, pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt);
1880 pStats->tx_errors--;
1881 pStats->tx_dropped--;
1886 device_free_tx_buf(pDevice,pTD);
1887 pDevice->iTDUsed[uIdx]--;
1892 if (uIdx == TYPE_AC0DMA) {
1893 // RESERV_AC0DMA reserved for relay
1895 if (AVAIL_TD(pDevice, uIdx) < RESERV_AC0DMA) {
1897 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " AC0DMA is Full = %d\n", pDevice->iTDUsed[uIdx]);
1899 if (netif_queue_stopped(pDevice->dev) && (bFull==FALSE)){
1900 netif_wake_queue(pDevice->dev);
1905 pDevice->apTailTD[uIdx] = pTD;
1911 static void device_error(PSDevice pDevice, WORD status) {
1913 if (status & ISR_FETALERR) {
1914 DEVICE_PRT(MSG_LEVEL_ERR, KERN_ERR
1915 "%s: Hardware fatal error.\n",
1916 pDevice->dev->name);
1917 netif_stop_queue(pDevice->dev);
1918 del_timer(&pDevice->sTimerCommand);
1919 del_timer(&(pDevice->pMgmt->sTimerSecondCallback));
1920 pDevice->bCmdRunning = FALSE;
1921 MACbShutdown(pDevice->PortOffset);
1927 static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc) {
1928 PDEVICE_TD_INFO pTDInfo=pDesc->pTDInfo;
1929 struct sk_buff* skb=pTDInfo->skb;
1931 // pre-allocated buf_dma can't be unmapped.
1932 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma)) {
1933 pci_unmap_single(pDevice->pcid,pTDInfo->skb_dma,skb->len,
1937 if ((pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0)
1938 dev_kfree_skb_irq(skb);
1940 pTDInfo->skb_dma = 0;
1942 pTDInfo->byFlags = 0;
1948 VOID InitRxManagementQueue(PSDevice pDevice)
1950 pDevice->rxManeQueue.packet_num = 0;
1951 pDevice->rxManeQueue.head = pDevice->rxManeQueue.tail = 0;
1963 PSDevice pDevice = (PSDevice) Context;
1964 PSRxMgmtPacket pRxMgmtPacket;
1966 //complete(&pDevice->notify);
1967 //printk("Enter MngWorkItem,Queue packet num is %d\n",pDevice->rxManeQueue.packet_num);
1969 //printk("Enter MlmeThread,packet _num is %d\n",pDevice->rxManeQueue.packet_num);
1976 //down(&pDevice->mlme_semaphore);
1977 // pRxMgmtPacket = DeQueue(pDevice);
1979 spin_lock_irq(&pDevice->lock);
1980 while(pDevice->rxManeQueue.packet_num != 0)
1982 pRxMgmtPacket = DeQueue(pDevice);
1984 //DequeueManageObject(pDevice->FirstRecvMngList, pDevice->LastRecvMngList);
1985 vMgrRxManagePacket(pDevice, pDevice->pMgmt, pRxMgmtPacket);
1986 //printk("packet_num is %d\n",pDevice->rxManeQueue.packet_num);
1989 spin_unlock_irq(&pDevice->lock);
1994 //printk("Before schedule thread jiffies is %x\n",jiffies);
1996 //printk("after schedule thread jiffies is %x\n",jiffies);
1999 //printk("i is %d\n",i);
2010 int __device_open(HANDLE pExDevice) {
2011 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
2012 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
2016 static int device_open(struct net_device *dev) {
2017 PSDevice pDevice=(PSDevice) netdev_priv(dev);
2020 pDevice->rx_buf_sz = PKT_BUF_SZ;
2021 if (!device_init_rings(pDevice)) {
2024 //2008-5-13 <add> by chester
2026 i=request_irq(pDevice->pcid->irq, &device_intr, IRQF_SHARED, dev->name, dev);
2030 //printk("DEBUG1\n");
2031 #ifdef WPA_SM_Transtatus
2032 extern SWPAResult wpa_Result;
2033 memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
2034 wpa_Result.proto = 0;
2035 wpa_Result.key_mgmt = 0;
2036 wpa_Result.eap_type = 0;
2037 wpa_Result.authenticated = FALSE;
2038 pDevice->fWPA_Authened = FALSE;
2040 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device init rd0 ring\n");
2041 device_init_rd0_ring(pDevice);
2042 device_init_rd1_ring(pDevice);
2043 device_init_defrag_cb(pDevice);
2044 device_init_td0_ring(pDevice);
2045 device_init_td1_ring(pDevice);
2046 // VNTWIFIvSet11h(pDevice->pMgmt, pDevice->b11hEnable);
2049 if (pDevice->bDiversityRegCtlON) {
2050 device_init_diversity_timer(pDevice);
2052 vMgrObjectInit(pDevice);
2053 vMgrTimerInit(pDevice);
2057 tasklet_init (&pDevice->RxMngWorkItem,(void *)MngWorkItem,(unsigned long )pDevice);
2060 InitRxManagementQueue(pDevice);
2062 mlme_task = kthread_run(MlmeThread,(void *) pDevice, "MLME");
2063 if (IS_ERR(mlme_task)) {
2064 printk("thread create fail\n");
2074 pDevice->MLMEThr_pid = kernel_thread(MlmeThread, pDevice, CLONE_VM);
2075 if (pDevice->MLMEThr_pid <0 )
2077 printk("unable start thread MlmeThread\n");
2082 //printk("thread id is %d\n",pDevice->MLMEThr_pid);
2083 //printk("Create thread time is %x\n",jiffies);
2084 //wait_for_completion(&pDevice->notify);
2089 // if (( SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RADIOCTL)&0x06)==0x04)
2091 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device_init_registers\n");
2092 device_init_registers(pDevice, DEVICE_INIT_COLD);
2093 MACvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr);
2094 memcpy(pDevice->pMgmt->abyMACAddr, pDevice->abyCurrentNetAddr, U_ETHER_ADDR_LEN);
2096 __device_set_multi(pExDevice);
2098 device_set_multi(pDevice->dev);
2101 // Init for Key Management
2102 KeyvInitTable(&pDevice->sKey, pDevice->PortOffset);
2103 add_timer(&(pDevice->pMgmt->sTimerSecondCallback));
2105 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2107 pDevice->bwextstep0 = FALSE;
2108 pDevice->bwextstep1 = FALSE;
2109 pDevice->bwextstep2 = FALSE;
2110 pDevice->bwextstep3 = FALSE;
2112 pDevice->bwextcount=0;
2113 pDevice->bWPASuppWextEnabled = FALSE;
2115 pDevice->byReAssocCount = 0;
2116 pDevice->bWPADEVUp = FALSE;
2117 // Patch: if WEP key already set by iwconfig but device not yet open
2118 if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
2119 KeybSetDefaultKey(&(pDevice->sKey),
2120 (DWORD)(pDevice->byKeyIndex | (1 << 31)),
2121 pDevice->uKeyLength,
2125 pDevice->PortOffset,
2128 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
2131 //printk("DEBUG2\n");
2134 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call MACvIntEnable\n");
2135 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
2137 if (pDevice->pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2138 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL);
2141 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
2142 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_SSID, NULL);
2144 pDevice->flags |=DEVICE_FLAGS_OPENED;
2146 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
2153 int __device_close(HANDLE pExDevice) {
2154 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
2155 struct net_device *dev = pDevice_info->dev;
2156 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
2159 static int device_close(struct net_device *dev) {
2160 PSDevice pDevice=(PSDevice) netdev_priv(dev);
2162 PSMgmtObject pMgmt = pDevice->pMgmt;
2168 //2007-1121-02<Add>by EinsnLiu
2169 if (pDevice->bLinkPass) {
2170 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2174 del_timer(&pDevice->sTimerTxData);
2176 del_timer(&pDevice->sTimerCommand);
2177 del_timer(&pMgmt->sTimerSecondCallback);
2178 if (pDevice->bDiversityRegCtlON) {
2179 del_timer(&pDevice->TimerSQ3Tmax1);
2180 del_timer(&pDevice->TimerSQ3Tmax2);
2181 del_timer(&pDevice->TimerSQ3Tmax3);
2185 tasklet_kill(&pDevice->RxMngWorkItem);
2187 netif_stop_queue(dev);
2188 pDevice->bCmdRunning = FALSE;
2189 MACbShutdown(pDevice->PortOffset);
2190 MACbSoftwareReset(pDevice->PortOffset);
2191 CARDbRadioPowerOff(pDevice);
2193 pDevice->bLinkPass = FALSE;
2194 memset(pMgmt->abyCurrBSSID, 0, 6);
2195 pMgmt->eCurrState = WMAC_STATE_IDLE;
2196 device_free_td0_ring(pDevice);
2197 device_free_td1_ring(pDevice);
2198 device_free_rd0_ring(pDevice);
2199 device_free_rd1_ring(pDevice);
2200 device_free_frag_buf(pDevice);
2201 device_free_rings(pDevice);
2202 BSSvClearNodeDBTable(pDevice, 0);
2203 free_irq(dev->irq, dev);
2204 pDevice->flags &=(~DEVICE_FLAGS_OPENED);
2205 //2008-0714-01<Add>by chester
2206 device_release_WPADEV(pDevice);
2208 //tasklet_kill(&pDevice->RxMngWorkItem);
2210 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close.. \n");
2216 int __device_dma0_tx_80211(HANDLE pExDevice, struct sk_buff *skb) {
2217 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
2218 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
2219 ref_sk_buff ref_skb;
2224 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev) {
2225 PSDevice pDevice=netdev_priv(dev);
2231 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211\n");
2232 spin_lock_irq(&pDevice->lock);
2234 if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) {
2235 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211, td0 <=0\n");
2236 dev_kfree_skb_irq(skb);
2237 spin_unlock_irq(&pDevice->lock);
2241 if (pDevice->bStopTx0Pkt == TRUE) {
2242 dev_kfree_skb_irq(skb);
2243 spin_unlock_irq(&pDevice->lock);
2248 ref_skb_remap(pDevice->dev, &ref_skb, skb);
2249 cbMPDULen = *(ref_skb.len);
2250 pbMPDU = ref_skb.data;
2252 cbMPDULen = skb->len;
2256 vDMA0_tx_80211(pDevice, skb, pbMPDU, cbMPDULen);
2258 spin_unlock_irq(&pDevice->lock);
2266 BOOL device_dma0_xmit(PSDevice pDevice, struct sk_buff *skb, UINT uNodeIndex) {
2267 PSMgmtObject pMgmt = pDevice->pMgmt;
2268 PSTxDesc pHeadTD, pLastTD;
2269 UINT cbFrameBodySize;
2272 BOOL bNeedEncryption = FALSE;
2273 PSKeyItem pTransmitKey = NULL;
2277 // BYTE byKeyIndex = 0;
2279 ref_sk_buff ref_skb;
2283 if (pDevice->bStopTx0Pkt == TRUE) {
2284 dev_kfree_skb_irq(skb);
2288 if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) {
2289 dev_kfree_skb_irq(skb);
2290 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, td0 <=0\n");
2294 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2295 if (pDevice->uAssocCount == 0) {
2296 dev_kfree_skb_irq(skb);
2297 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, assocCount = 0\n");
2303 ref_skb_remap(pDevice->dev, &(ref_skb), skb);
2305 pHeadTD = pDevice->apCurrTD[TYPE_TXDMA0];
2307 pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
2310 memcpy(pDevice->sTxEthHeader.abyDstAddr, (PBYTE)(ref_skb.data), U_HEADER_LEN);
2311 cbFrameBodySize = *(ref_skb.len) - U_HEADER_LEN;
2314 memcpy(pDevice->sTxEthHeader.abyDstAddr, (PBYTE)(skb->data), U_HEADER_LEN);
2315 cbFrameBodySize = skb->len - U_HEADER_LEN;
2319 if (ntohs(pDevice->sTxEthHeader.wType) > MAX_DATA_LEN) {
2320 cbFrameBodySize += 8;
2322 uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
2324 if ( uMACfragNum > AVAIL_TD(pDevice, TYPE_TXDMA0)) {
2325 dev_kfree_skb_irq(skb);
2328 byPktTyp = (BYTE)pDevice->byPacketType;
2331 if (pDevice->bFixRate) {
2332 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
2333 if (pDevice->uConnectionRate >= RATE_11M) {
2334 pDevice->wCurrentRate = RATE_11M;
2336 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
2339 if (pDevice->uConnectionRate >= RATE_54M)
2340 pDevice->wCurrentRate = RATE_54M;
2342 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
2346 pDevice->wCurrentRate = pDevice->pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
2350 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2351 pDevice->byPreambleType = pDevice->byShortPreamble;
2354 pDevice->byPreambleType = PREAMBLE_LONG;
2357 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate);
2360 if (pDevice->wCurrentRate <= RATE_11M) {
2361 byPktTyp = PK_TYPE_11B;
2362 } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
2363 byPktTyp = PK_TYPE_11A;
2365 if (pDevice->bProtectMode == TRUE) {
2366 byPktTyp = PK_TYPE_11GB;
2368 byPktTyp = PK_TYPE_11GA;
2372 if (pDevice->bEncryptionEnable == TRUE)
2373 bNeedEncryption = TRUE;
2375 if (pDevice->bEnableHostWEP) {
2376 pTransmitKey = &STempKey;
2377 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2378 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2379 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2380 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2381 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2382 memcpy(pTransmitKey->abyKey,
2383 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2384 pTransmitKey->uKeyLength
2387 vGenerateFIFOHeader(pDevice, byPktTyp, pDevice->pbyTmpBuff, bNeedEncryption,
2388 cbFrameBodySize, TYPE_TXDMA0, pHeadTD,
2389 &pDevice->sTxEthHeader, (PBYTE)skb->data, pTransmitKey, uNodeIndex,
2394 if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
2396 MACbPSWakeup(pDevice->PortOffset);
2399 pDevice->bPWBitOn = FALSE;
2402 for (ii = 0; ii < uMACfragNum; ii++) {
2403 // Poll Transmit the adapter
2405 pHeadTD->m_td0TD0.f1Owner=OWNED_BY_NIC;
2407 if (ii == (uMACfragNum - 1))
2409 pHeadTD = pHeadTD->next;
2412 // Save the information needed by the tx interrupt handler
2413 // to complete the Send request
2414 pLastTD->pTDInfo->skb = skb;
2415 pLastTD->pTDInfo->byFlags = 0;
2416 pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
2418 pDevice->apCurrTD[TYPE_TXDMA0] = pHeadTD;
2420 MACvTransmit0(pDevice->PortOffset);
2426 //TYPE_AC0DMA data tx
2429 int __device_xmit(HANDLE pExDevice, struct sk_buff *skb) {
2430 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
2431 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
2432 struct net_device *dev = pDevice_info->dev;
2433 ref_sk_buff ref_skb;
2436 static int device_xmit(struct sk_buff *skb, struct net_device *dev) {
2437 PSDevice pDevice=netdev_priv(dev);
2440 PSMgmtObject pMgmt = pDevice->pMgmt;
2441 PSTxDesc pHeadTD, pLastTD;
2442 UINT uNodeIndex = 0;
2443 BYTE byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
2445 UINT uMACfragNum = 1;
2446 UINT cbFrameBodySize;
2449 BOOL bNeedEncryption = FALSE;
2450 PSKeyItem pTransmitKey = NULL;
2453 BOOL bTKIP_UseGTK = FALSE;
2454 BOOL bNeedDeAuth = FALSE;
2456 BOOL bNodeExist = FALSE;
2460 spin_lock_irq(&pDevice->lock);
2461 if (pDevice->bLinkPass == FALSE) {
2462 dev_kfree_skb_irq(skb);
2463 spin_unlock_irq(&pDevice->lock);
2467 if (pDevice->bStopDataPkt) {
2468 dev_kfree_skb_irq(skb);
2469 spin_unlock_irq(&pDevice->lock);
2474 ref_skb_remap(pDevice->dev, &ref_skb, skb);
2477 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2478 if (pDevice->uAssocCount == 0) {
2479 dev_kfree_skb_irq(skb);
2480 spin_unlock_irq(&pDevice->lock);
2484 if (IS_MULTICAST_ADDRESS((PBYTE)(ref_skb.data))) {
2486 if (IS_MULTICAST_ADDRESS((PBYTE)(skb->data))) {
2490 if (pMgmt->sNodeDBTable[0].bPSEnable) {
2492 skb_queue_tail(&(pMgmt->sNodeDBTable[0].sTxPSQueue), ref_skb.skb);
2494 skb_queue_tail(&(pMgmt->sNodeDBTable[0].sTxPSQueue), skb);
2496 pMgmt->sNodeDBTable[0].wEnQueueCnt++;
2498 pMgmt->abyPSTxMap[0] |= byMask[0];
2499 spin_unlock_irq(&pDevice->lock);
2504 if (BSSDBbIsSTAInNodeDB(pMgmt, (PBYTE)(ref_skb.data), &uNodeIndex)) {
2506 if (BSSDBbIsSTAInNodeDB(pMgmt, (PBYTE)(skb->data), &uNodeIndex)) {
2508 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
2510 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, ref_skb.skb);
2512 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
2514 pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
2516 wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
2517 pMgmt->abyPSTxMap[wAID >> 3] |= byMask[wAID & 7];
2518 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set:pMgmt->abyPSTxMap[%d]= %d\n",
2519 (wAID >> 3), pMgmt->abyPSTxMap[wAID >> 3]);
2520 spin_unlock_irq(&pDevice->lock);
2524 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2525 pDevice->byPreambleType = pDevice->byShortPreamble;
2528 pDevice->byPreambleType = PREAMBLE_LONG;
2535 if (bNodeExist == FALSE) {
2536 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Unknown STA not found in node DB \n");
2537 dev_kfree_skb_irq(skb);
2538 spin_unlock_irq(&pDevice->lock);
2543 pHeadTD = pDevice->apCurrTD[TYPE_AC0DMA];
2545 pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
2549 memcpy(pDevice->sTxEthHeader.abyDstAddr, (PBYTE)(ref_skb.data), U_HEADER_LEN);
2550 cbFrameBodySize = *(ref_skb.len) - U_HEADER_LEN;
2552 memcpy(pDevice->sTxEthHeader.abyDstAddr, (PBYTE)(skb->data), U_HEADER_LEN);
2553 cbFrameBodySize = skb->len - U_HEADER_LEN;
2556 if (ntohs(pDevice->sTxEthHeader.wType) > MAX_DATA_LEN) {
2557 cbFrameBodySize += 8;
2561 if (pDevice->bEncryptionEnable == TRUE) {
2562 bNeedEncryption = TRUE;
2565 if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
2566 (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2567 pbyBSSID = pDevice->abyBSSID;
2569 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == FALSE) {
2571 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == TRUE) {
2572 bTKIP_UseGTK = TRUE;
2573 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2577 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get PTK.\n");
2580 }else if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2582 pbyBSSID = pDevice->sTxEthHeader.abyDstAddr; //TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1
2583 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS Serach Key: \n");
2584 for (ii = 0; ii< 6; ii++)
2585 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"%x \n", *(pbyBSSID+ii));
2586 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"\n");
2589 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == TRUE)
2593 pbyBSSID = pDevice->abyBroadcastAddr;
2594 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == FALSE) {
2595 pTransmitKey = NULL;
2596 if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2597 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode);
2600 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"NOT IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode);
2602 bTKIP_UseGTK = TRUE;
2603 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2608 if (pDevice->bEnableHostWEP) {
2609 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"acdma0: STA index %d\n", uNodeIndex);
2610 if (pDevice->bEncryptionEnable == TRUE) {
2611 pTransmitKey = &STempKey;
2612 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2613 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2614 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2615 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2616 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2617 memcpy(pTransmitKey->abyKey,
2618 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2619 pTransmitKey->uKeyLength
2624 uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
2626 if (uMACfragNum > AVAIL_TD(pDevice, TYPE_AC0DMA)) {
2627 DEVICE_PRT(MSG_LEVEL_ERR, KERN_DEBUG "uMACfragNum > AVAIL_TD(TYPE_AC0DMA) = %d\n", uMACfragNum);
2628 dev_kfree_skb_irq(skb);
2629 spin_unlock_irq(&pDevice->lock);
2633 if (pTransmitKey != NULL) {
2634 if ((pTransmitKey->byCipherSuite == KEY_CTL_WEP) &&
2635 (pTransmitKey->uKeyLength == WLAN_WEP232_KEYLEN)) {
2636 uMACfragNum = 1; //WEP256 doesn't support fragment
2640 byPktTyp = (BYTE)pDevice->byPacketType;
2642 if (pDevice->bFixRate) {
2644 printk("Fix Rate: PhyType is %d,ConnectionRate is %d\n",pDevice->eCurrentPHYType,pDevice->uConnectionRate);
2647 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
2648 if (pDevice->uConnectionRate >= RATE_11M) {
2649 pDevice->wCurrentRate = RATE_11M;
2651 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
2654 if ((pDevice->eCurrentPHYType == PHY_TYPE_11A) &&
2655 (pDevice->uConnectionRate <= RATE_6M)) {
2656 pDevice->wCurrentRate = RATE_6M;
2658 if (pDevice->uConnectionRate >= RATE_54M)
2659 pDevice->wCurrentRate = RATE_54M;
2661 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
2665 pDevice->byACKRate = (BYTE) pDevice->wCurrentRate;
2666 pDevice->byTopCCKBasicRate = RATE_1M;
2667 pDevice->byTopOFDMBasicRate = RATE_6M;
2671 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
2672 if (pDevice->eCurrentPHYType != PHY_TYPE_11A) {
2673 pDevice->wCurrentRate = RATE_1M;
2674 pDevice->byACKRate = RATE_1M;
2675 pDevice->byTopCCKBasicRate = RATE_1M;
2676 pDevice->byTopOFDMBasicRate = RATE_6M;
2678 pDevice->wCurrentRate = RATE_6M;
2679 pDevice->byACKRate = RATE_6M;
2680 pDevice->byTopCCKBasicRate = RATE_1M;
2681 pDevice->byTopOFDMBasicRate = RATE_6M;
2685 VNTWIFIvGetTxRate( pDevice->pMgmt,
2686 pDevice->sTxEthHeader.abyDstAddr,
2687 &(pDevice->wCurrentRate),
2688 &(pDevice->byACKRate),
2689 &(pDevice->byTopCCKBasicRate),
2690 &(pDevice->byTopOFDMBasicRate));
2693 printk("auto rate:Rate : %d,AckRate:%d,TopCCKRate:%d,TopOFDMRate:%d\n",
2694 pDevice->wCurrentRate,pDevice->byACKRate,
2695 pDevice->byTopCCKBasicRate,pDevice->byTopOFDMBasicRate);
2701 pDevice->wCurrentRate = 11;
2702 pDevice->byACKRate = 8;
2703 pDevice->byTopCCKBasicRate = 3;
2704 pDevice->byTopOFDMBasicRate = 8;
2711 // DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate);
2713 if (pDevice->wCurrentRate <= RATE_11M) {
2714 byPktTyp = PK_TYPE_11B;
2715 } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
2716 byPktTyp = PK_TYPE_11A;
2718 if (pDevice->bProtectMode == TRUE) {
2719 byPktTyp = PK_TYPE_11GB;
2721 byPktTyp = PK_TYPE_11GA;
2725 //#ifdef PLICE_DEBUG
2726 // printk("FIX RATE:CurrentRate is %d");
2729 if (bNeedEncryption == TRUE) {
2730 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ntohs Pkt Type=%04x\n", ntohs(pDevice->sTxEthHeader.wType));
2731 if ((pDevice->sTxEthHeader.wType) == TYPE_PKT_802_1x) {
2732 bNeedEncryption = FALSE;
2733 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Pkt Type=%04x\n", (pDevice->sTxEthHeader.wType));
2734 if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2735 if (pTransmitKey == NULL) {
2736 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Don't Find TX KEY\n");
2739 if (bTKIP_UseGTK == TRUE) {
2740 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"error: KEY is GTK!!~~\n");
2743 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
2744 bNeedEncryption = TRUE;
2749 if (pDevice->byCntMeasure == 2) {
2751 pDevice->s802_11Counter.TKIPCounterMeasuresInvoked++;
2754 if (pDevice->bEnableHostWEP) {
2755 if ((uNodeIndex != 0) &&
2756 (pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex & PAIRWISE_KEY)) {
2757 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
2758 bNeedEncryption = TRUE;
2763 if (pTransmitKey == NULL) {
2764 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"return no tx key\n");
2765 dev_kfree_skb_irq(skb);
2766 spin_unlock_irq(&pDevice->lock);
2774 vGenerateFIFOHeader(pDevice, byPktTyp, pDevice->pbyTmpBuff, bNeedEncryption,
2775 cbFrameBodySize, TYPE_AC0DMA, pHeadTD,
2776 &pDevice->sTxEthHeader, (PBYTE)ref_skb.data, pTransmitKey, uNodeIndex,
2782 //if (skb->len == 98)
2784 // printk("ping:len is %d\n");
2787 vGenerateFIFOHeader(pDevice, byPktTyp, pDevice->pbyTmpBuff, bNeedEncryption,
2788 cbFrameBodySize, TYPE_AC0DMA, pHeadTD,
2789 &pDevice->sTxEthHeader, (PBYTE)skb->data, pTransmitKey, uNodeIndex,
2795 if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
2797 MACbPSWakeup(pDevice->PortOffset);
2799 pDevice->bPWBitOn = FALSE;
2802 for (ii = 0; ii < uMACfragNum; ii++) {
2803 // Poll Transmit the adapter
2805 pHeadTD->m_td0TD0.f1Owner=OWNED_BY_NIC;
2807 if (ii == uMACfragNum - 1)
2809 pHeadTD = pHeadTD->next;
2812 // Save the information needed by the tx interrupt handler
2813 // to complete the Send request
2815 pLastTD->pTDInfo->skb = ref_skb.skb;
2817 pLastTD->pTDInfo->skb = skb;
2819 pLastTD->pTDInfo->byFlags = 0;
2820 pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
2822 pDevice->nTxDataTimeCout=0; //2008-8-21 chester <add> for send null packet
2824 if (AVAIL_TD(pDevice, TYPE_AC0DMA) <= 1) {
2825 netif_stop_queue(dev);
2828 pDevice->apCurrTD[TYPE_AC0DMA] = pHeadTD;
2829 //#ifdef PLICE_DEBUG
2830 if (pDevice->bFixRate)
2832 printk("FixRate:Rate is %d,TxPower is %d\n",pDevice->wCurrentRate,pDevice->byCurPwr);
2836 //printk("Auto Rate:Rate is %d,TxPower is %d\n",pDevice->wCurrentRate,pDevice->byCurPwr);
2841 BYTE Protocol_Version; //802.1x Authentication
2842 BYTE Packet_Type; //802.1x Authentication
2843 BYTE Descriptor_type;
2845 BOOL bTxeapol_key = FALSE;
2846 Protocol_Version = skb->data[U_HEADER_LEN];
2847 Packet_Type = skb->data[U_HEADER_LEN+1];
2848 Descriptor_type = skb->data[U_HEADER_LEN+1+1+2];
2849 Key_info = (skb->data[U_HEADER_LEN+1+1+2+1] << 8)|(skb->data[U_HEADER_LEN+1+1+2+2]);
2850 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
2851 if(((Protocol_Version==1) ||(Protocol_Version==2)) &&
2852 (Packet_Type==3)) { //802.1x OR eapol-key challenge frame transfer
2853 bTxeapol_key = TRUE;
2854 if((Descriptor_type==254)||(Descriptor_type==2)) { //WPA or RSN
2855 if(!(Key_info & BIT3) && //group-key challenge
2856 (Key_info & BIT8) && (Key_info & BIT9)) { //send 2/2 key
2857 pDevice->fWPA_Authened = TRUE;
2858 if(Descriptor_type==254)
2862 printk("Authentication completed!!\n");
2869 MACvTransmitAC0(pDevice->PortOffset);
2870 // DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0:pDevice->apCurrTD= %p\n", pHeadTD);
2873 ref_set_tx_jiffies(pDevice->dev);
2875 dev->trans_start = jiffies;
2878 spin_unlock_irq(&pDevice->lock);
2885 int __device_intr(int irq, HANDLE pExDevice, struct pt_regs *regs) {
2886 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
2887 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
2891 static irqreturn_t device_intr(int irq, void *dev_instance) {
2892 struct net_device* dev=dev_instance;
2893 PSDevice pDevice=(PSDevice) netdev_priv(dev);
2897 DWORD dwMIBCounter=0;
2898 PSMgmtObject pMgmt = pDevice->pMgmt;
2899 BYTE byOrgPageSel=0;
2906 MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr);
2908 if (pDevice->dwIsr == 0)
2909 return IRQ_RETVAL(handled);
2911 if (pDevice->dwIsr == 0xffffffff) {
2912 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dwIsr = 0xffff\n");
2913 return IRQ_RETVAL(handled);
2916 // 2008-05-21 <mark> by Richardtai, we can't read RSSI here, because no packet bound with RSSI
2918 if ((BITbIsBitOn(pDevice->dwIsr, ISR_RXDMA0)) &&
2919 (pDevice->byLocalID != REV_ID_VT3253_B0) &&
2920 (pDevice->bBSSIDFilter == TRUE)) {
2922 //BBbReadEmbeded(pDevice->PortOffset, 0x3E, &byRSSI);
2923 //pDevice->uCurrRSSI = byRSSI;
2928 MACvIntDisable(pDevice->PortOffset);
2929 spin_lock_irq(&pDevice->lock);
2931 //Make sure current page is 0
2932 VNSvInPortB(pDevice->PortOffset + MAC_REG_PAGE1SEL, &byOrgPageSel);
2933 if (byOrgPageSel == 1) {
2934 MACvSelectPage0(pDevice->PortOffset);
2939 MACvReadMIBCounter(pDevice->PortOffset, &dwMIBCounter);
2941 // Must do this after doing rx/tx, cause ISR bit is slow
2942 // than RD/TD write back
2943 // update ISR counter
2944 STAvUpdate802_11Counter(&pDevice->s802_11Counter, &pDevice->scStatistic , dwMIBCounter);
2945 while (pDevice->dwIsr != 0) {
2947 STAvUpdateIsrStatCounter(&pDevice->scStatistic, pDevice->dwIsr);
2948 MACvWriteISR(pDevice->PortOffset, pDevice->dwIsr);
2950 if (pDevice->dwIsr & ISR_FETALERR){
2951 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " ISR_FETALERR \n");
2952 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, 0);
2953 VNSvOutPortW(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPECTI);
2954 device_error(pDevice, pDevice->dwIsr);
2957 if (pDevice->byLocalID > REV_ID_VT3253_B1) {
2959 if (BITbIsBitOn(pDevice->dwIsr, ISR_MEASURESTART)) {
2960 // 802.11h measure start
2961 pDevice->byOrgChannel = pDevice->byCurrentCh;
2962 VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byOrgRCR));
2963 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, (RCR_RXALLTYPE | RCR_UNICAST | RCR_BROADCAST | RCR_MULTICAST | RCR_WPAERR));
2964 MACvSelectPage1(pDevice->PortOffset);
2965 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR0, &(pDevice->dwOrgMAR0));
2966 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR4, &(pDevice->dwOrgMAR4));
2967 MACvSelectPage0(pDevice->PortOffset);
2969 // WCMDbFlushCommandQueue(pDevice->pMgmt, TRUE);
2970 if (CARDbSetChannel(pDevice, pDevice->pCurrMeasureEID->sReq.byChannel) == TRUE) {
2971 pDevice->bMeasureInProgress = TRUE;
2972 MACvSelectPage1(pDevice->PortOffset);
2973 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_READY);
2974 MACvSelectPage0(pDevice->PortOffset);
2975 pDevice->byBasicMap = 0;
2976 pDevice->byCCAFraction = 0;
2977 for(ii=0;ii<8;ii++) {
2978 pDevice->dwRPIs[ii] = 0;
2981 // can not measure because set channel fail
2982 // WCMDbResetCommandQueue(pDevice->pMgmt);
2983 // clear measure control
2984 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN);
2985 s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_INCAPABLE);
2986 MACvSelectPage1(pDevice->PortOffset);
2987 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2988 MACvSelectPage0(pDevice->PortOffset);
2991 if (BITbIsBitOn(pDevice->dwIsr, ISR_MEASUREEND)) {
2992 // 802.11h measure end
2993 pDevice->bMeasureInProgress = FALSE;
2994 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byOrgRCR);
2995 MACvSelectPage1(pDevice->PortOffset);
2996 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, pDevice->dwOrgMAR0);
2997 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR4, pDevice->dwOrgMAR4);
2998 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRBBSTS, &byData);
2999 pDevice->byBasicMap |= (byData >> 4);
3000 VNSvInPortB(pDevice->PortOffset + MAC_REG_CCAFRACTION, &pDevice->byCCAFraction);
3001 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRCTL, &byData);
3002 // clear measure control
3003 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN);
3004 MACvSelectPage0(pDevice->PortOffset);
3005 CARDbSetChannel(pDevice, pDevice->byOrgChannel);
3006 // WCMDbResetCommandQueue(pDevice->pMgmt);
3007 MACvSelectPage1(pDevice->PortOffset);
3008 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
3009 MACvSelectPage0(pDevice->PortOffset);
3010 if (BITbIsBitOn(byData, MSRCTL_FINISH)) {
3012 s_vCompleteCurrentMeasure(pDevice, 0);
3014 // can not measure because not ready before end of measure time
3015 s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_LATE);
3018 if (BITbIsBitOn(pDevice->dwIsr, ISR_QUIETSTART)) {
3021 } while (CARDbStartQuiet(pDevice) == FALSE);
3025 if (pDevice->dwIsr & ISR_TBTT) {
3026 if (pDevice->bEnableFirstQuiet == TRUE) {
3027 pDevice->byQuietStartCount--;
3028 if (pDevice->byQuietStartCount == 0) {
3029 pDevice->bEnableFirstQuiet = FALSE;
3030 MACvSelectPage1(pDevice->PortOffset);
3031 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN));
3032 MACvSelectPage0(pDevice->PortOffset);
3035 if ((pDevice->bChannelSwitch == TRUE) &&
3036 (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE)) {
3037 pDevice->byChannelSwitchCount--;
3038 if (pDevice->byChannelSwitchCount == 0) {
3039 pDevice->bChannelSwitch = FALSE;
3040 CARDbSetChannel(pDevice, pDevice->byNewChannel);
3041 VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel);
3042 MACvSelectPage1(pDevice->PortOffset);
3043 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
3044 MACvSelectPage0(pDevice->PortOffset);
3045 CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL);
3049 if (pDevice->eOPMode == OP_MODE_ADHOC) {
3050 //pDevice->bBeaconSent = FALSE;
3052 if ((pDevice->bUpdateBBVGA) && (pDevice->bLinkPass == TRUE) && (pDevice->uCurrRSSI != 0)) {
3055 RFvRSSITodBm(pDevice, (BYTE) pDevice->uCurrRSSI, &ldBm);
3056 for (ii=0;ii<BB_VGA_LEVEL;ii++) {
3057 if (ldBm < pDevice->ldBmThreshold[ii]) {
3058 pDevice->byBBVGANew = pDevice->abyBBVGA[ii];
3062 if (pDevice->byBBVGANew != pDevice->byBBVGACurrent) {
3063 pDevice->uBBVGADiffCount++;
3064 if (pDevice->uBBVGADiffCount == 1) {
3065 // first VGA diff gain
3066 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew);
3067 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"First RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
3068 (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount);
3070 if (pDevice->uBBVGADiffCount >= BB_VGA_CHANGE_THRESHOLD) {
3071 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
3072 (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount);
3073 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew);
3076 pDevice->uBBVGADiffCount = 1;
3081 pDevice->bBeaconSent = FALSE;
3082 if (pDevice->bEnablePSMode) {
3083 PSbIsNextTBTTWakeUp((HANDLE)pDevice);
3086 if ((pDevice->eOPMode == OP_MODE_AP) ||
3087 (pDevice->eOPMode == OP_MODE_ADHOC)) {
3089 MACvOneShotTimer1MicroSec(pDevice->PortOffset,
3090 (pMgmt->wIBSSBeaconPeriod - MAKE_BEACON_RESERVED) << 10);
3093 if (pDevice->eOPMode == OP_MODE_ADHOC && pDevice->pMgmt->wCurrATIMWindow > 0) {
3094 // todo adhoc PS mode
3099 if (pDevice->dwIsr & ISR_BNTX) {
3101 if (pDevice->eOPMode == OP_MODE_ADHOC) {
3102 pDevice->bIsBeaconBufReadySet = FALSE;
3103 pDevice->cbBeaconBufReadySetCnt = 0;
3106 if (pDevice->eOPMode == OP_MODE_AP) {
3107 if(pMgmt->byDTIMCount > 0) {
3108 pMgmt->byDTIMCount --;
3109 pMgmt->sNodeDBTable[0].bRxPSPoll = FALSE;
3112 if(pMgmt->byDTIMCount == 0) {
3113 // check if mutltcast tx bufferring
3114 pMgmt->byDTIMCount = pMgmt->byDTIMPeriod - 1;
3115 pMgmt->sNodeDBTable[0].bRxPSPoll = TRUE;
3116 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RX_PSPOLL, NULL);
3120 pDevice->bBeaconSent = TRUE;
3122 if (pDevice->bChannelSwitch == TRUE) {
3123 pDevice->byChannelSwitchCount--;
3124 if (pDevice->byChannelSwitchCount == 0) {
3125 pDevice->bChannelSwitch = FALSE;
3126 CARDbSetChannel(pDevice, pDevice->byNewChannel);
3127 VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel);
3128 MACvSelectPage1(pDevice->PortOffset);
3129 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
3130 MACvSelectPage0(pDevice->PortOffset);
3131 //VNTWIFIbSendBeacon(pDevice->pMgmt);
3132 CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL);
3138 if (pDevice->dwIsr & ISR_RXDMA0) {
3139 max_count += device_rx_srv(pDevice, TYPE_RXDMA0);
3141 if (pDevice->dwIsr & ISR_RXDMA1) {
3142 max_count += device_rx_srv(pDevice, TYPE_RXDMA1);
3144 if (pDevice->dwIsr & ISR_TXDMA0){
3145 max_count += device_tx_srv(pDevice, TYPE_TXDMA0);
3147 if (pDevice->dwIsr & ISR_AC0DMA){
3148 max_count += device_tx_srv(pDevice, TYPE_AC0DMA);
3150 if (pDevice->dwIsr & ISR_SOFTTIMER) {
3153 if (pDevice->dwIsr & ISR_SOFTTIMER1) {
3154 if (pDevice->eOPMode == OP_MODE_AP) {
3155 if (pDevice->bShortSlotTime)
3156 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTSLOTTIME(1);
3158 pMgmt->wCurrCapInfo &= ~(WLAN_SET_CAP_INFO_SHORTSLOTTIME(1));
3160 bMgrPrepareBeaconToSend(pDevice, pMgmt);
3161 pDevice->byCntMeasure = 0;
3164 MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr);
3166 MACvReceive0(pDevice->PortOffset);
3167 MACvReceive1(pDevice->PortOffset);
3169 if (max_count>pDevice->sOpts.int_works)
3173 if (byOrgPageSel == 1) {
3174 MACvSelectPage1(pDevice->PortOffset);
3177 spin_unlock_irq(&pDevice->lock);
3178 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
3180 return IRQ_RETVAL(handled);
3184 static unsigned const ethernet_polynomial = 0x04c11db7U;
3185 static inline u32 ether_crc(int length, unsigned char *data)
3189 while(--length >= 0) {
3190 unsigned char current_octet = *data++;
3192 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
3194 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
3200 //2008-8-4 <add> by chester
3201 static int Config_FileGetParameter(UCHAR *string, UCHAR *dest,UCHAR *source)
3204 int source_len = strlen(source);
3207 strcat(buf1, string);
3209 source+=strlen(buf1);
3211 memcpy(dest,source,source_len-strlen(buf1));
3215 int Config_FileOperation(PSDevice pDevice,BOOL fwrite,unsigned char *Parameter) {
3216 UCHAR *config_path=CONFIG_PATH;
3218 UCHAR tmpbuffer[20];
3219 struct file *filp=NULL;
3220 mm_segment_t old_fs = get_fs();
3221 //int oldfsuid=0,oldfsgid=0;
3226 /* Can't do this anymore, so we rely on correct filesystem permissions:
3227 //Make sure a caller can read or write power as root
3228 oldfsuid=current->cred->fsuid;
3229 oldfsgid=current->cred->fsgid;
3230 current->cred->fsuid = 0;
3231 current->cred->fsgid = 0;
3235 filp = filp_open(config_path, O_RDWR, 0);
3237 printk("Config_FileOperation:open file fail?\n");
3242 if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
3243 printk("file %s cann't readable or writable?\n",config_path);
3248 buffer = (UCHAR *)kmalloc(1024, GFP_KERNEL);
3250 printk("alllocate mem for file fail?\n");
3255 if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
3256 printk("read file error?\n");
3261 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer)!=TRUE) {
3262 printk("get parameter error?\n");
3267 if(memcmp(tmpbuffer,"USA",3)==0) {
3268 result=ZoneType_USA;
3270 else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
3271 result=ZoneType_Japan;
3273 else if(memcmp(tmpbuffer,"EUROPE",5)==0) {
3274 result=ZoneType_Europe;
3278 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
3285 if(filp_close(filp,NULL))
3286 printk("Config_FileOperation:close file fail\n");
3292 current->cred->fsuid=oldfsuid;
3293 current->cred->fsgid=oldfsgid;
3302 void __device_set_multi(HANDLE pExDevice) {
3303 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
3304 ref_net_device *dev = &(pDevice_info->ref_dev);
3305 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
3309 static void device_set_multi(struct net_device *dev) {
3310 PSDevice pDevice = (PSDevice) netdev_priv(dev);
3313 PSMgmtObject pMgmt = pDevice->pMgmt;
3316 struct dev_mc_list *mclist;
3319 VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byRxMode));
3322 if (*(dev->flags) & IFF_PROMISC) { /* Set promiscuous. */
3323 DEVICE_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: Promiscuous mode enabled.\n", pDevice->dev->name);
3326 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
3327 DEVICE_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
3329 /* Unconditionally log net taps. */
3330 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
3333 else if ((*(dev->mc_count) > pDevice->multicast_limit)
3334 || (*(dev->flags) & IFF_ALLMULTI)) {
3336 else if ((dev->mc_count > pDevice->multicast_limit)
3337 || (dev->flags & IFF_ALLMULTI)) {
3339 MACvSelectPage1(pDevice->PortOffset);
3340 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, 0xffffffff);
3341 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, 0xffffffff);
3342 MACvSelectPage0(pDevice->PortOffset);
3343 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
3346 memset(mc_filter, 0, sizeof(mc_filter));
3348 for (i = 0, mclist = dev->mc_list; mclist && i < *(dev->mc_count);
3349 i++, mclist = mclist->next) {
3351 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
3352 i++, mclist = mclist->next) {
3354 int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
3355 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
3357 MACvSelectPage1(pDevice->PortOffset);
3358 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, mc_filter[0]);
3359 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, mc_filter[1]);
3360 MACvSelectPage0(pDevice->PortOffset);
3361 pDevice->byRxMode &= ~(RCR_UNICAST);
3362 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
3365 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
3366 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
3367 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
3368 pDevice->byRxMode &= ~(RCR_UNICAST);
3371 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byRxMode);
3372 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode = %x\n", pDevice->byRxMode );
3378 struct net_device_stats *__device_get_stats(HANDLE pExDevice) {
3379 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
3380 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
3383 static struct net_device_stats *device_get_stats(struct net_device *dev) {
3384 PSDevice pDevice=(PSDevice) netdev_priv(dev);
3387 return &pDevice->stats;
3393 int __device_ioctl(HANDLE pExDevice, struct ifreq *rq, int cmd) {
3394 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
3395 struct net_device *dev = pDevice_info->dev;
3396 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
3400 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
3401 PSDevice pDevice = (PSDevice)netdev_priv(dev);
3405 struct iwreq *wrq = (struct iwreq *) rq;
3408 PSMgmtObject pMgmt = pDevice->pMgmt;
3412 if (pMgmt == NULL) {
3420 //#if WIRELESS_EXT < 13
3423 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
3426 case SIOCGIWNWID: //0x8b03 support
3427 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3428 rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
3434 // Set frequency/channel
3436 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
3439 // Get frequency/channel
3441 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
3444 // Set desired network name (ESSID)
3448 char essid[IW_ESSID_MAX_SIZE+1];
3449 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
3453 if (copy_from_user(essid, wrq->u.essid.pointer,
3454 wrq->u.essid.length)) {
3458 rc = iwctl_siwessid(dev, NULL,
3459 &(wrq->u.essid), essid);
3464 // Get current network name (ESSID)
3468 char essid[IW_ESSID_MAX_SIZE+1];
3469 if (wrq->u.essid.pointer)
3470 rc = iwctl_giwessid(dev, NULL,
3471 &(wrq->u.essid), essid);
3472 if (copy_to_user(wrq->u.essid.pointer,
3474 wrq->u.essid.length) )
3481 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
3485 // Get current Access Point (BSSID)
3487 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
3491 // Set desired station name
3493 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
3497 // Get current station name
3499 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
3503 // Set the desired bit-rate
3505 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
3508 // Get the current bit-rate
3511 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
3514 // Set the desired RTS threshold
3517 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
3520 // Get the current RTS threshold
3523 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
3526 // Set the desired fragmentation threshold
3529 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
3532 // Get the current fragmentation threshold
3535 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
3538 // Set mode of operation
3540 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
3543 // Get mode of operation
3545 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
3548 // Set WEP keys and mode
3551 char abyKey[WLAN_WEP232_KEYLEN];
3553 if (wrq->u.encoding.pointer) {
3556 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
3560 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
3561 if (copy_from_user(abyKey,
3562 wrq->u.encoding.pointer,
3563 wrq->u.encoding.length)) {
3567 } else if (wrq->u.encoding.length != 0) {
3571 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
3575 // Get the WEP keys and mode
3578 if (!capable(CAP_NET_ADMIN)) {
3583 char abyKey[WLAN_WEP232_KEYLEN];
3585 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
3587 if (wrq->u.encoding.pointer) {
3588 if (copy_to_user(wrq->u.encoding.pointer,
3590 wrq->u.encoding.length))
3596 #if WIRELESS_EXT > 9
3597 // Get the current Tx-Power
3599 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
3604 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
3608 #endif // WIRELESS_EXT > 9
3610 #if WIRELESS_EXT > 10
3613 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
3618 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
3621 #endif // WIRELESS_EXT > 10
3623 // Get range of parameters
3627 struct iw_range range;
3629 rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
3630 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
3638 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
3644 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
3650 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
3654 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
3660 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
3662 if (wrq->u.data.pointer) {
3663 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
3665 if (copy_to_user(wrq->u.data.pointer,
3667 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality)))
3680 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
3687 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
3691 #endif // WIRELESS_SPY
3694 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
3697 if(wrq->u.data.pointer) {
3698 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
3700 if(copy_to_user(wrq->u.data.pointer,
3701 (u_char *) iwctl_private_args,
3702 sizeof(iwctl_private_args)))
3709 //#endif // WIRELESS_EXT < 13
3710 //2008-0409-07, <Add> by Einsn Liu
3711 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3713 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n");
3714 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
3718 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
3719 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
3723 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
3724 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3728 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
3729 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3732 case SIOCSIWENCODEEXT:
3734 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
3735 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
3736 if(wrq->u.encoding.pointer){
3737 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
3738 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
3742 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
3746 }else if(wrq->u.encoding.length != 0){
3750 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
3754 case SIOCGIWENCODEEXT:
3755 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
3756 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
3760 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
3761 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3764 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3765 //End Add -- //2008-0409-07, <Add> by Einsn Liu
3767 #endif // WIRELESS_EXT
3769 case IOCTL_CMD_TEST:
3771 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
3777 pReq = (PSCmdRequest)rq;
3778 pReq->wResult = MAGIC_CODE;
3784 if((((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_EVT) &&
3785 !(pDevice->flags & DEVICE_FLAGS_OPENED))
3787 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
3788 (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
3797 if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
3800 rc = private_ioctl(pDevice, rq);
3801 clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
3804 case IOCTL_CMD_HOSTAPD:
3807 #if WIRELESS_EXT > 8
3808 rc = hostap_ioctl(pDevice, &wrq->u.data);
3809 #else // WIRELESS_EXT > 8
3810 rc = hostap_ioctl(pDevice, (struct iw_point *) &wrq->u.data);
3811 #endif // WIRELESS_EXT > 8
3816 #if WIRELESS_EXT > 8
3817 rc = wpa_ioctl(pDevice, &wrq->u.data);
3818 #else // WIRELESS_EXT > 8
3819 rc = wpa_ioctl(pDevice, (struct iw_point *) &wrq->u.data);
3820 #endif // WIRELESS_EXT > 8
3824 return ethtool_ioctl(dev, (void *) rq->ifr_data);
3825 // All other calls are currently unsupported
3829 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
3834 if (pDevice->bCommit) {
3835 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
3836 netif_stop_queue(pDevice->dev);
3837 spin_lock_irq(&pDevice->lock);
3838 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL);
3839 spin_unlock_irq(&pDevice->lock);
3842 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
3843 spin_lock_irq(&pDevice->lock);
3844 pDevice->bLinkPass = FALSE;
3845 memset(pMgmt->abyCurrBSSID, 0, 6);
3846 pMgmt->eCurrState = WMAC_STATE_IDLE;
3847 netif_stop_queue(pDevice->dev);
3848 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3849 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
3850 if(pDevice->bWPASuppWextEnabled !=TRUE)
3852 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID);
3853 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_SSID, NULL);
3854 spin_unlock_irq(&pDevice->lock);
3856 pDevice->bCommit = FALSE;
3863 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
3867 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd)))
3871 case ETHTOOL_GDRVINFO: {
3872 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
3873 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
3874 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
3875 if (copy_to_user(useraddr, &info, sizeof(info)))
3885 /*------------------------------------------------------------------*/
3888 MODULE_DEVICE_TABLE(pci, device_id_table);
3890 static struct pci_driver device_driver = {
3892 id_table: device_id_table,
3893 probe: device_found1,
3894 remove: device_remove1,
3896 suspend: viawget_suspend,
3897 resume: viawget_resume,
3901 static int __init device_init_module(void)
3906 // ret=pci_module_init(&device_driver);
3907 //ret = pcie_port_service_register(&device_driver);
3908 ret = pci_register_driver(&device_driver);
3911 register_reboot_notifier(&device_notifier);
3917 static void __exit device_cleanup_module(void)
3922 unregister_reboot_notifier(&device_notifier);
3924 pci_unregister_driver(&device_driver);
3928 module_init(device_init_module);
3929 module_exit(device_cleanup_module);
3934 device_notify_reboot(struct notifier_block *nb, unsigned long event, void *p)
3936 struct pci_dev *pdev = NULL;
3941 while ((pdev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pdev)) != NULL) {
3942 if(pci_dev_driver(pdev) == &device_driver) {
3943 if (pci_get_drvdata(pdev))
3944 viawget_suspend(pdev, 3);
3952 viawget_suspend(struct pci_dev *pcid, u32 state)
3954 int power_status; // to silence the compiler
3956 PSDevice pDevice=pci_get_drvdata(pcid);
3957 PSMgmtObject pMgmt = pDevice->pMgmt;
3959 netif_stop_queue(pDevice->dev);
3960 spin_lock_irq(&pDevice->lock);
3961 pci_save_state(pcid);
3962 del_timer(&pDevice->sTimerCommand);
3963 del_timer(&pMgmt->sTimerSecondCallback);
3964 pDevice->cbFreeCmdQueue = CMD_Q_SIZE;
3965 pDevice->uCmdDequeueIdx = 0;
3966 pDevice->uCmdEnqueueIdx = 0;
3967 pDevice->bCmdRunning = FALSE;
3968 MACbShutdown(pDevice->PortOffset);
3969 MACvSaveContext(pDevice->PortOffset, pDevice->abyMacContext);
3970 pDevice->bLinkPass = FALSE;
3971 memset(pMgmt->abyCurrBSSID, 0, 6);
3972 pMgmt->eCurrState = WMAC_STATE_IDLE;
3973 pci_disable_device(pcid);
3974 power_status = pci_set_power_state(pcid, state);
3975 spin_unlock_irq(&pDevice->lock);
3980 viawget_resume(struct pci_dev *pcid)
3982 PSDevice pDevice=pci_get_drvdata(pcid);
3983 PSMgmtObject pMgmt = pDevice->pMgmt;
3984 int power_status; // to silence the compiler
3987 power_status = pci_set_power_state(pcid, 0);
3988 power_status = pci_enable_wake(pcid, 0, 0);
3989 pci_restore_state(pcid);
3990 if (netif_running(pDevice->dev)) {
3991 spin_lock_irq(&pDevice->lock);
3992 MACvRestoreContext(pDevice->PortOffset, pDevice->abyMacContext);
3993 device_init_registers(pDevice, DEVICE_INIT_DXPL);
3994 if (pMgmt->sNodeDBTable[0].bActive == TRUE) { // Assoc with BSS
3995 pMgmt->sNodeDBTable[0].bActive = FALSE;
3996 pDevice->bLinkPass = FALSE;
3997 if(pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
3998 // In Adhoc, BSS state set back to started.
3999 pMgmt->eCurrState = WMAC_STATE_STARTED;
4002 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
4003 pMgmt->eCurrState = WMAC_STATE_IDLE;
4006 init_timer(&pMgmt->sTimerSecondCallback);
4007 init_timer(&pDevice->sTimerCommand);
4008 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
4009 BSSvClearBSSList((HANDLE)pDevice, pDevice->bLinkPass);
4010 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
4011 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_SSID, NULL);
4012 spin_unlock_irq(&pDevice->lock);
4019 #endif //#ifndef PRIVATE_OBJ
4024 int __device_hw_reset(HANDLE pExDevice){
4025 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
4027 return MACbSoftwareReset(pDevice_info->port_offset);
4031 int __device_hw_init(HANDLE pExDevice){
4032 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
4035 pDevice = (PSDevice)kmalloc(sizeof(DEVICE_INFO), (int)GFP_ATOMIC);
4036 if (pDevice == NULL)
4039 memset(pDevice, 0, sizeof(DEVICE_INFO));
4040 pDevice_info->pWDevice = pDevice;
4041 pDevice->PortOffset = pDevice_info->port_offset;
4042 pDevice->dev = pDevice_info->dev;
4043 pDevice->pcid = pDevice_info->pcid;
4044 pDevice->chip_id = pDevice_info->chip_id;
4045 pDevice->memaddr = pDevice_info->mem_addr;
4046 pDevice->ioaddr = pDevice_info->io_addr;
4047 pDevice->io_size = pDevice_info->io_size;
4048 pDevice->nTxQueues = pDevice_info->nTxQueues;
4049 pDevice->multicast_limit = pDevice_info->multicast_limit;
4050 pDevice->sMgmtObj.pAdapter = (PVOID)pDevice;
4051 pDevice->pMgmt = &(pDevice->sMgmtObj);
4052 MACvInitialize(pDevice->PortOffset);
4053 device_get_options(pDevice, 0 , pDevice_info->dev->name);
4054 device_set_options(pDevice);
4055 pDevice->sOpts.flags &= pDevice_info->flags;
4056 pDevice->flags = pDevice->sOpts.flags | (pDevice_info->flags & 0xFF000000UL);
4057 spin_lock_init(&(pDevice->lock));
4063 void __device_read_mac(HANDLE pExDevice, PBYTE dev_addr){
4064 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
4065 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
4067 MACvReadEtherAddress(pDevice->PortOffset, dev_addr);