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 * vt6655_probe - module initial (insmod) driver entry
30 * vt6655_remove - module remove entry
31 * vt6655_init_info - device structure resource allocation function
32 * device_free_info - device structure resource free function
33 * device_get_pci_info - get allocated pci io/mem resource
34 * device_print_info - print out resource
35 * device_open - allocate dma/descripter resource & initial mac/bbp function
36 * device_xmit - asynchrous data tx function
37 * device_intr - interrupt handle function
38 * device_set_multi - set mac filter
39 * device_ioctl - ioctl entry
40 * device_close - shutdown mac/bbp & free dma/descripter resource
41 * device_rx_srv - rx service function
42 * device_receive_frame - rx data function
43 * device_alloc_rx_buf - rx buffer pre-allocated function
44 * device_alloc_frag_buf - rx fragement pre-allocated function
45 * device_free_tx_buf - free tx buffer function
46 * device_free_frag_buf- free de-fragement buffer
47 * device_dma0_tx_80211- tx 802.11 frame via dma0
48 * device_dma0_xmit- tx PS bufferred frame via dma0
49 * device_init_rd0_ring- initial rd dma0 ring
50 * device_init_rd1_ring- initial rd dma1 ring
51 * device_init_td0_ring- initial tx dma0 ring buffer
52 * device_init_td1_ring- initial tx dma1 ring buffer
53 * device_init_registers- initial MAC & BBP & RF internal registers.
54 * device_init_rings- initial tx/rx ring buffer
55 * device_init_defrag_cb- initial & allocate de-fragement buffer.
56 * device_free_rings- free all allocated ring buffer
57 * device_tx_srv- tx interrupt service function
86 #include <linux/delay.h>
87 #include <linux/kthread.h>
88 #include <linux/slab.h>
90 /*--------------------- Static Definitions -------------------------*/
91 //static int msglevel =MSG_LEVEL_DEBUG;
92 static int msglevel
= MSG_LEVEL_INFO
;
95 // Define module options
97 MODULE_AUTHOR("VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>");
98 MODULE_LICENSE("GPL");
99 MODULE_DESCRIPTION("VIA Networking Solomon-A/B/G Wireless LAN Adapter Driver");
101 static int mlme_kill
;
102 //static struct task_struct * mlme_task;
104 #define DEVICE_PARAM(N,D)
106 static const int N[MAX_UINTS]=OPTION_DEFAULT;\
107 MODULE_PARM(N, "1-" __MODULE_STRING(MAX_UINTS) "i");\
108 MODULE_PARM_DESC(N, D);
111 #define RX_DESC_MIN0 16
112 #define RX_DESC_MAX0 128
113 #define RX_DESC_DEF0 32
114 DEVICE_PARAM(RxDescriptors0
,"Number of receive descriptors0");
116 #define RX_DESC_MIN1 16
117 #define RX_DESC_MAX1 128
118 #define RX_DESC_DEF1 32
119 DEVICE_PARAM(RxDescriptors1
,"Number of receive descriptors1");
121 #define TX_DESC_MIN0 16
122 #define TX_DESC_MAX0 128
123 #define TX_DESC_DEF0 32
124 DEVICE_PARAM(TxDescriptors0
,"Number of transmit descriptors0");
126 #define TX_DESC_MIN1 16
127 #define TX_DESC_MAX1 128
128 #define TX_DESC_DEF1 64
129 DEVICE_PARAM(TxDescriptors1
,"Number of transmit descriptors1");
132 #define IP_ALIG_DEF 0
133 /* IP_byte_align[] is used for IP header unsigned long byte aligned
134 0: indicate the IP header won't be unsigned long byte aligned.(Default) .
135 1: indicate the IP header will be unsigned long byte aligned.
136 In some environment, the IP header should be unsigned long byte aligned,
137 or the packet will be droped when we receive it. (eg: IPVS)
139 DEVICE_PARAM(IP_byte_align
,"Enable IP header dword aligned");
142 #define INT_WORKS_DEF 20
143 #define INT_WORKS_MIN 10
144 #define INT_WORKS_MAX 64
146 DEVICE_PARAM(int_works
,"Number of packets per interrupt services");
148 #define CHANNEL_MIN 1
149 #define CHANNEL_MAX 14
150 #define CHANNEL_DEF 6
152 DEVICE_PARAM(Channel
, "Channel number");
155 /* PreambleType[] is the preamble length used for transmit.
156 0: indicate allows long preamble type
157 1: indicate allows short preamble type
160 #define PREAMBLE_TYPE_DEF 1
162 DEVICE_PARAM(PreambleType
, "Preamble Type");
165 #define RTS_THRESH_MIN 512
166 #define RTS_THRESH_MAX 2347
167 #define RTS_THRESH_DEF 2347
169 DEVICE_PARAM(RTSThreshold
, "RTS threshold");
172 #define FRAG_THRESH_MIN 256
173 #define FRAG_THRESH_MAX 2346
174 #define FRAG_THRESH_DEF 2346
176 DEVICE_PARAM(FragThreshold
, "Fragmentation threshold");
179 #define DATA_RATE_MIN 0
180 #define DATA_RATE_MAX 13
181 #define DATA_RATE_DEF 13
183 0: indicate 1 Mbps 0x02
184 1: indicate 2 Mbps 0x04
185 2: indicate 5.5 Mbps 0x0B
186 3: indicate 11 Mbps 0x16
187 4: indicate 6 Mbps 0x0c
188 5: indicate 9 Mbps 0x12
189 6: indicate 12 Mbps 0x18
190 7: indicate 18 Mbps 0x24
191 8: indicate 24 Mbps 0x30
192 9: indicate 36 Mbps 0x48
193 10: indicate 48 Mbps 0x60
194 11: indicate 54 Mbps 0x6c
195 12: indicate 72 Mbps 0x90
196 13: indicate auto rate
199 DEVICE_PARAM(ConnectionRate
, "Connection data rate");
201 #define OP_MODE_DEF 0
203 DEVICE_PARAM(OPMode
, "Infrastruct, adhoc, AP mode ");
205 /* OpMode[] is used for transmit.
206 0: indicate infrastruct mode used
207 1: indicate adhoc mode used
208 2: indicate AP mode used
213 0: indicate disable power saving mode
214 1: indicate enable power saving mode
217 #define PS_MODE_DEF 0
219 DEVICE_PARAM(PSMode
, "Power saving mode");
222 #define SHORT_RETRY_MIN 0
223 #define SHORT_RETRY_MAX 31
224 #define SHORT_RETRY_DEF 8
227 DEVICE_PARAM(ShortRetryLimit
, "Short frame retry limits");
229 #define LONG_RETRY_MIN 0
230 #define LONG_RETRY_MAX 15
231 #define LONG_RETRY_DEF 4
234 DEVICE_PARAM(LongRetryLimit
, "long frame retry limits");
237 /* BasebandType[] baseband type selected
238 0: indicate 802.11a type
239 1: indicate 802.11b type
240 2: indicate 802.11g type
242 #define BBP_TYPE_MIN 0
243 #define BBP_TYPE_MAX 2
244 #define BBP_TYPE_DEF 2
246 DEVICE_PARAM(BasebandType
, "baseband type");
251 0: indicate disable 802.11h
252 1: indicate enable 802.11h
255 #define X80211h_MODE_DEF 0
257 DEVICE_PARAM(b80211hEnable
, "802.11h mode");
260 0: indicate disable 802.11h
261 1: indicate enable 802.11h
264 #define DIVERSITY_ANT_DEF 0
266 DEVICE_PARAM(bDiversityANTEnable
, "ANT diversity mode");
270 // Static vars definitions
274 static int device_nics
=0;
275 static PSDevice pDevice_Infos
=NULL
;
276 static struct net_device
*root_device_dev
= NULL
;
278 static CHIP_INFO chip_info_table
[]= {
279 { VT3253
, "VIA Networking Solomon-A/B/G Wireless LAN Adapter ",
280 256, 1, DEVICE_FLAGS_IP_ALIGN
|DEVICE_FLAGS_TX_ALIGN
},
284 DEFINE_PCI_DEVICE_TABLE(vt6655_pci_id_table
) = {
285 { PCI_VDEVICE(VIA
, 0x3253), (kernel_ulong_t
)chip_info_table
},
289 /*--------------------- Static Functions --------------------------*/
292 static int vt6655_probe(struct pci_dev
*pcid
, const struct pci_device_id
*ent
);
293 static bool vt6655_init_info(struct pci_dev
* pcid
, PSDevice
* ppDevice
, PCHIP_INFO
);
294 static void device_free_info(PSDevice pDevice
);
295 static bool device_get_pci_info(PSDevice
, struct pci_dev
* pcid
);
296 static void device_print_info(PSDevice pDevice
);
297 static struct net_device_stats
*device_get_stats(struct net_device
*dev
);
298 static void device_init_diversity_timer(PSDevice pDevice
);
299 static int device_open(struct net_device
*dev
);
300 static int device_xmit(struct sk_buff
*skb
, struct net_device
*dev
);
301 static irqreturn_t
device_intr(int irq
, void*dev_instance
);
302 static void device_set_multi(struct net_device
*dev
);
303 static int device_close(struct net_device
*dev
);
304 static int device_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
);
307 static int device_notify_reboot(struct notifier_block
*, unsigned long event
, void *ptr
);
308 static int viawget_suspend(struct pci_dev
*pcid
, pm_message_t state
);
309 static int viawget_resume(struct pci_dev
*pcid
);
310 struct notifier_block device_notifier
= {
311 .notifier_call
= device_notify_reboot
,
318 static void device_init_rd0_ring(PSDevice pDevice
);
319 static void device_init_rd1_ring(PSDevice pDevice
);
320 static void device_init_defrag_cb(PSDevice pDevice
);
321 static void device_init_td0_ring(PSDevice pDevice
);
322 static void device_init_td1_ring(PSDevice pDevice
);
324 static int device_dma0_tx_80211(struct sk_buff
*skb
, struct net_device
*dev
);
325 //2008-0714<Add>by Mike Liu
326 static bool device_release_WPADEV(PSDevice pDevice
);
328 static int ethtool_ioctl(struct net_device
*dev
, void *useraddr
);
329 static int device_rx_srv(PSDevice pDevice
, unsigned int uIdx
);
330 static int device_tx_srv(PSDevice pDevice
, unsigned int uIdx
);
331 static bool device_alloc_rx_buf(PSDevice pDevice
, PSRxDesc pDesc
);
332 static void device_init_registers(PSDevice pDevice
, DEVICE_INIT_TYPE InitType
);
333 static void device_free_tx_buf(PSDevice pDevice
, PSTxDesc pDesc
);
334 static void device_free_td0_ring(PSDevice pDevice
);
335 static void device_free_td1_ring(PSDevice pDevice
);
336 static void device_free_rd0_ring(PSDevice pDevice
);
337 static void device_free_rd1_ring(PSDevice pDevice
);
338 static void device_free_rings(PSDevice pDevice
);
339 static void device_free_frag_buf(PSDevice pDevice
);
340 static int Config_FileGetParameter(unsigned char *string
,
341 unsigned char *dest
, unsigned char *source
);
344 /*--------------------- Export Variables --------------------------*/
346 /*--------------------- Export Functions --------------------------*/
350 static char* get_chip_name(int chip_id
) {
352 for (i
=0;chip_info_table
[i
].name
!=NULL
;i
++)
353 if (chip_info_table
[i
].chip_id
==chip_id
)
355 return chip_info_table
[i
].name
;
358 static void __devexit
vt6655_remove(struct pci_dev
*pcid
)
360 PSDevice pDevice
=pci_get_drvdata(pcid
);
364 device_free_info(pDevice
);
370 device_set_int_opt(int *opt, int val, int min, int max, int def,char* name,char* devname) {
373 else if (val<min || val>max) {
374 DBG_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: the value of parameter %s is invalid, the valid range is (%d-%d)\n" ,
375 devname,name, min,max);
378 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: set value of parameter %s to %d\n",
385 device_set_bool_opt(unsigned int *opt, int val,bool def,u32 flag, char* name,char* devname) {
388 *opt|=(def ? flag : 0);
389 else if (val<0 || val>1) {
390 DBG_PRT(MSG_LEVEL_INFO, KERN_NOTICE
391 "%s: the value of parameter %s is invalid, the valid range is (0-1)\n",devname,name);
392 *opt|=(def ? flag : 0);
394 DBG_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: set parameter %s to %s\n",
395 devname,name , val ? "true" : "false");
396 *opt|=(val ? flag : 0);
401 device_get_options(PSDevice pDevice
, int index
, char* devname
) {
403 POPTIONS pOpts
= &(pDevice
->sOpts
);
404 pOpts
->nRxDescs0
=RX_DESC_DEF0
;
405 pOpts
->nRxDescs1
=RX_DESC_DEF1
;
406 pOpts
->nTxDescs
[0]=TX_DESC_DEF0
;
407 pOpts
->nTxDescs
[1]=TX_DESC_DEF1
;
408 pOpts
->flags
|=DEVICE_FLAGS_IP_ALIGN
;
409 pOpts
->int_works
=INT_WORKS_DEF
;
410 pOpts
->rts_thresh
=RTS_THRESH_DEF
;
411 pOpts
->frag_thresh
=FRAG_THRESH_DEF
;
412 pOpts
->data_rate
=DATA_RATE_DEF
;
413 pOpts
->channel_num
=CHANNEL_DEF
;
415 pOpts
->flags
|=DEVICE_FLAGS_PREAMBLE_TYPE
;
416 pOpts
->flags
|=DEVICE_FLAGS_OP_MODE
;
417 //pOpts->flags|=DEVICE_FLAGS_PS_MODE;
418 pOpts
->short_retry
=SHORT_RETRY_DEF
;
419 pOpts
->long_retry
=LONG_RETRY_DEF
;
420 pOpts
->bbp_type
=BBP_TYPE_DEF
;
421 pOpts
->flags
|=DEVICE_FLAGS_80211h_MODE
;
422 pOpts
->flags
|=DEVICE_FLAGS_DiversityANT
;
428 device_set_options(PSDevice pDevice
) {
430 unsigned char abyBroadcastAddr
[ETH_ALEN
] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
431 unsigned char abySNAP_RFC1042
[ETH_ALEN
] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
432 unsigned char abySNAP_Bridgetunnel
[ETH_ALEN
] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
435 memcpy(pDevice
->abyBroadcastAddr
, abyBroadcastAddr
, ETH_ALEN
);
436 memcpy(pDevice
->abySNAP_RFC1042
, abySNAP_RFC1042
, ETH_ALEN
);
437 memcpy(pDevice
->abySNAP_Bridgetunnel
, abySNAP_Bridgetunnel
, ETH_ALEN
);
439 pDevice
->uChannel
= pDevice
->sOpts
.channel_num
;
440 pDevice
->wRTSThreshold
= pDevice
->sOpts
.rts_thresh
;
441 pDevice
->wFragmentationThreshold
= pDevice
->sOpts
.frag_thresh
;
442 pDevice
->byShortRetryLimit
= pDevice
->sOpts
.short_retry
;
443 pDevice
->byLongRetryLimit
= pDevice
->sOpts
.long_retry
;
444 pDevice
->wMaxTransmitMSDULifetime
= DEFAULT_MSDU_LIFETIME
;
445 pDevice
->byShortPreamble
= (pDevice
->sOpts
.flags
& DEVICE_FLAGS_PREAMBLE_TYPE
) ? 1 : 0;
446 pDevice
->byOpMode
= (pDevice
->sOpts
.flags
& DEVICE_FLAGS_OP_MODE
) ? 1 : 0;
447 pDevice
->ePSMode
= (pDevice
->sOpts
.flags
& DEVICE_FLAGS_PS_MODE
) ? 1 : 0;
448 pDevice
->b11hEnable
= (pDevice
->sOpts
.flags
& DEVICE_FLAGS_80211h_MODE
) ? 1 : 0;
449 pDevice
->bDiversityRegCtlON
= (pDevice
->sOpts
.flags
& DEVICE_FLAGS_DiversityANT
) ? 1 : 0;
450 pDevice
->uConnectionRate
= pDevice
->sOpts
.data_rate
;
451 if (pDevice
->uConnectionRate
< RATE_AUTO
) pDevice
->bFixRate
= true;
452 pDevice
->byBBType
= pDevice
->sOpts
.bbp_type
;
453 pDevice
->byPacketType
= pDevice
->byBBType
;
456 pDevice
->byAutoFBCtrl
= AUTO_FB_0
;
457 //pDevice->byAutoFBCtrl = AUTO_FB_1;
459 pDevice
->bUpdateBBVGA
= true;
460 pDevice
->byFOETuning
= 0;
461 pDevice
->wCTSDuration
= 0;
462 pDevice
->byPreambleType
= 0;
465 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" uChannel= %d\n",(int)pDevice
->uChannel
);
466 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" byOpMode= %d\n",(int)pDevice
->byOpMode
);
467 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" ePSMode= %d\n",(int)pDevice
->ePSMode
);
468 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" wRTSThreshold= %d\n",(int)pDevice
->wRTSThreshold
);
469 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" byShortRetryLimit= %d\n",(int)pDevice
->byShortRetryLimit
);
470 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" byLongRetryLimit= %d\n",(int)pDevice
->byLongRetryLimit
);
471 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" byPreambleType= %d\n",(int)pDevice
->byPreambleType
);
472 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" byShortPreamble= %d\n",(int)pDevice
->byShortPreamble
);
473 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" uConnectionRate= %d\n",(int)pDevice
->uConnectionRate
);
474 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" byBBType= %d\n",(int)pDevice
->byBBType
);
475 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" pDevice->b11hEnable= %d\n",(int)pDevice
->b11hEnable
);
476 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" pDevice->bDiversityRegCtlON= %d\n",(int)pDevice
->bDiversityRegCtlON
);
479 static void s_vCompleteCurrentMeasure (PSDevice pDevice
, unsigned char byResult
)
482 unsigned long dwDuration
= 0;
483 unsigned char byRPI0
= 0;
485 for(ii
=1;ii
<8;ii
++) {
486 pDevice
->dwRPIs
[ii
] *= 255;
487 dwDuration
|= *((unsigned short *) (pDevice
->pCurrMeasureEID
->sReq
.abyDuration
));
489 pDevice
->dwRPIs
[ii
] /= dwDuration
;
490 pDevice
->abyRPIs
[ii
] = (unsigned char) pDevice
->dwRPIs
[ii
];
491 byRPI0
+= pDevice
->abyRPIs
[ii
];
493 pDevice
->abyRPIs
[0] = (0xFF - byRPI0
);
495 if (pDevice
->uNumOfMeasureEIDs
== 0) {
496 VNTWIFIbMeasureReport( pDevice
->pMgmt
,
498 pDevice
->pCurrMeasureEID
,
501 pDevice
->byCCAFraction
,
505 VNTWIFIbMeasureReport( pDevice
->pMgmt
,
507 pDevice
->pCurrMeasureEID
,
510 pDevice
->byCCAFraction
,
513 CARDbStartMeasure (pDevice
, pDevice
->pCurrMeasureEID
++, pDevice
->uNumOfMeasureEIDs
);
521 // Initialiation of MAC & BBP registers
524 static void device_init_registers(PSDevice pDevice
, DEVICE_INIT_TYPE InitType
)
527 unsigned char byValue
;
528 unsigned char byValue1
;
529 unsigned char byCCKPwrdBm
= 0;
530 unsigned char byOFDMPwrdBm
= 0;
532 PSMgmtObject pMgmt
= &(pDevice
->sMgmtObj
);
533 MACbShutdown(pDevice
->PortOffset
);
534 BBvSoftwareReset(pDevice
->PortOffset
);
536 if ((InitType
== DEVICE_INIT_COLD
) ||
537 (InitType
== DEVICE_INIT_DXPL
)) {
538 // Do MACbSoftwareReset in MACvInitialize
539 MACbSoftwareReset(pDevice
->PortOffset
);
541 pDevice
->bCCK
= true;
542 pDevice
->bAES
= false;
543 pDevice
->bProtectMode
= false; //Only used in 11g type, sync with ERP IE
544 pDevice
->bNonERPPresent
= false;
545 pDevice
->bBarkerPreambleMd
= false;
546 pDevice
->wCurrentRate
= RATE_1M
;
547 pDevice
->byTopOFDMBasicRate
= RATE_24M
;
548 pDevice
->byTopCCKBasicRate
= RATE_1M
;
550 pDevice
->byRevId
= 0; //Target to IF pin while programming to RF chip.
553 MACvInitialize(pDevice
->PortOffset
);
556 VNSvInPortB(pDevice
->PortOffset
+ MAC_REG_LOCALID
, &(pDevice
->byLocalID
));
558 spin_lock_irq(&pDevice
->lock
);
559 SROMvReadAllContents(pDevice
->PortOffset
,pDevice
->abyEEPROM
);
561 spin_unlock_irq(&pDevice
->lock
);
565 pDevice
->byMinChannel
= 1;
566 pDevice
->byMaxChannel
= CB_MAX_CHANNEL
;
569 byValue
= SROMbyReadEmbedded(pDevice
->PortOffset
, EEP_OFS_ANTENNA
);
570 if (byValue
& EEP_ANTINV
)
571 pDevice
->bTxRxAntInv
= true;
573 pDevice
->bTxRxAntInv
= false;
575 //printk("init_register:TxRxAntInv is %d,byValue is %d\n",pDevice->bTxRxAntInv,byValue);
578 byValue
&= (EEP_ANTENNA_AUX
| EEP_ANTENNA_MAIN
);
579 if (byValue
== 0) // if not set default is All
580 byValue
= (EEP_ANTENNA_AUX
| EEP_ANTENNA_MAIN
);
582 //printk("init_register:byValue is %d\n",byValue);
584 pDevice
->ulDiversityNValue
= 100*260;//100*SROMbyReadEmbedded(pDevice->PortOffset, 0x51);
585 pDevice
->ulDiversityMValue
= 100*16;//SROMbyReadEmbedded(pDevice->PortOffset, 0x52);
586 pDevice
->byTMax
= 1;//SROMbyReadEmbedded(pDevice->PortOffset, 0x53);
587 pDevice
->byTMax2
= 4;//SROMbyReadEmbedded(pDevice->PortOffset, 0x54);
588 pDevice
->ulSQ3TH
= 0;//(unsigned long) SROMbyReadEmbedded(pDevice->PortOffset, 0x55);
589 pDevice
->byTMax3
= 64;//SROMbyReadEmbedded(pDevice->PortOffset, 0x56);
591 if (byValue
== (EEP_ANTENNA_AUX
| EEP_ANTENNA_MAIN
)) {
592 pDevice
->byAntennaCount
= 2;
593 pDevice
->byTxAntennaMode
= ANT_B
;
594 pDevice
->dwTxAntennaSel
= 1;
595 pDevice
->dwRxAntennaSel
= 1;
596 if (pDevice
->bTxRxAntInv
== true)
597 pDevice
->byRxAntennaMode
= ANT_A
;
599 pDevice
->byRxAntennaMode
= ANT_B
;
600 // chester for antenna
601 byValue1
= SROMbyReadEmbedded(pDevice
->PortOffset
, EEP_OFS_ANTENNA
);
602 // if (pDevice->bDiversityRegCtlON)
603 if((byValue1
&0x08)==0)
604 pDevice
->bDiversityEnable
= false;//SROMbyReadEmbedded(pDevice->PortOffset, 0x50);
606 pDevice
->bDiversityEnable
= true;
608 //printk("aux |main antenna: RxAntennaMode is %d\n",pDevice->byRxAntennaMode);
611 pDevice
->bDiversityEnable
= false;
612 pDevice
->byAntennaCount
= 1;
613 pDevice
->dwTxAntennaSel
= 0;
614 pDevice
->dwRxAntennaSel
= 0;
615 if (byValue
& EEP_ANTENNA_AUX
) {
616 pDevice
->byTxAntennaMode
= ANT_A
;
617 if (pDevice
->bTxRxAntInv
== true)
618 pDevice
->byRxAntennaMode
= ANT_B
;
620 pDevice
->byRxAntennaMode
= ANT_A
;
622 pDevice
->byTxAntennaMode
= ANT_B
;
623 if (pDevice
->bTxRxAntInv
== true)
624 pDevice
->byRxAntennaMode
= ANT_A
;
626 pDevice
->byRxAntennaMode
= ANT_B
;
630 //printk("init registers: TxAntennaMode is %d\n",pDevice->byTxAntennaMode);
632 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"bDiversityEnable=[%d],NValue=[%d],MValue=[%d],TMax=[%d],TMax2=[%d]\n",
633 pDevice
->bDiversityEnable
,(int)pDevice
->ulDiversityNValue
,(int)pDevice
->ulDiversityMValue
,pDevice
->byTMax
,pDevice
->byTMax2
);
635 //#ifdef ZoneType_DefaultSetting
636 //2008-8-4 <add> by chester
638 pDevice
->byOriginalZonetype
= pDevice
->abyEEPROM
[EEP_OFS_ZONETYPE
];
639 zonetype
= Config_FileOperation(pDevice
,false,NULL
);
640 if (zonetype
>= 0) { //read zonetype file ok!
641 if ((zonetype
== 0)&&
642 (pDevice
->abyEEPROM
[EEP_OFS_ZONETYPE
] !=0x00)){ //for USA
643 pDevice
->abyEEPROM
[EEP_OFS_ZONETYPE
] = 0;
644 pDevice
->abyEEPROM
[EEP_OFS_MAXCHANNEL
] = 0x0B;
645 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Init Zone Type :USA\n");
647 else if((zonetype
== 1)&&
648 (pDevice
->abyEEPROM
[EEP_OFS_ZONETYPE
]!=0x01)){ //for Japan
649 pDevice
->abyEEPROM
[EEP_OFS_ZONETYPE
] = 0x01;
650 pDevice
->abyEEPROM
[EEP_OFS_MAXCHANNEL
] = 0x0D;
652 else if((zonetype
== 2)&&
653 (pDevice
->abyEEPROM
[EEP_OFS_ZONETYPE
]!=0x02)){ //for Europe
654 pDevice
->abyEEPROM
[EEP_OFS_ZONETYPE
] = 0x02;
655 pDevice
->abyEEPROM
[EEP_OFS_MAXCHANNEL
] = 0x0D;
656 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Init Zone Type :Europe\n");
661 if(zonetype
!=pDevice
->abyEEPROM
[EEP_OFS_ZONETYPE
])
662 printk("zonetype in file[%02x] mismatch with in EEPROM[%02x]\n",zonetype
,pDevice
->abyEEPROM
[EEP_OFS_ZONETYPE
]);
664 printk("Read Zonetype file success,use default zonetype setting[%02x]\n",zonetype
);
668 printk("Read Zonetype file fail,use default zonetype setting[%02x]\n",SROMbyReadEmbedded(pDevice
->PortOffset
, EEP_OFS_ZONETYPE
));
671 pDevice
->byRFType
= SROMbyReadEmbedded(pDevice
->PortOffset
, EEP_OFS_RFTYPE
);
673 if ((pDevice
->byRFType
& RF_EMU
) != 0) {
674 // force change RevID for VT3253 emu
675 pDevice
->byRevId
= 0x80;
678 pDevice
->byRFType
&= RF_MASK
;
679 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"pDevice->byRFType = %x\n", pDevice
->byRFType
);
681 if (pDevice
->bZoneRegExist
== false) {
682 pDevice
->byZoneType
= pDevice
->abyEEPROM
[EEP_OFS_ZONETYPE
];
684 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"pDevice->byZoneType = %x\n", pDevice
->byZoneType
);
689 //Get Desire Power Value
690 pDevice
->byCurPwr
= 0xFF;
691 pDevice
->byCCKPwr
= SROMbyReadEmbedded(pDevice
->PortOffset
, EEP_OFS_PWR_CCK
);
692 pDevice
->byOFDMPwrG
= SROMbyReadEmbedded(pDevice
->PortOffset
, EEP_OFS_PWR_OFDMG
);
693 //byCCKPwrdBm = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_CCK_PWR_dBm);
695 //byOFDMPwrdBm = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_OFDM_PWR_dBm);
696 //printk("CCKPwrdBm is 0x%x,byOFDMPwrdBm is 0x%x\n",byCCKPwrdBm,byOFDMPwrdBm);
700 for (ii
=0;ii
<CB_MAX_CHANNEL_24G
;ii
++) {
701 pDevice
->abyCCKPwrTbl
[ii
+1] = SROMbyReadEmbedded(pDevice
->PortOffset
, (unsigned char)(ii
+ EEP_OFS_CCK_PWR_TBL
));
702 if (pDevice
->abyCCKPwrTbl
[ii
+1] == 0) {
703 pDevice
->abyCCKPwrTbl
[ii
+1] = pDevice
->byCCKPwr
;
705 pDevice
->abyOFDMPwrTbl
[ii
+1] = SROMbyReadEmbedded(pDevice
->PortOffset
, (unsigned char)(ii
+ EEP_OFS_OFDM_PWR_TBL
));
706 if (pDevice
->abyOFDMPwrTbl
[ii
+1] == 0) {
707 pDevice
->abyOFDMPwrTbl
[ii
+1] = pDevice
->byOFDMPwrG
;
709 pDevice
->abyCCKDefaultPwr
[ii
+1] = byCCKPwrdBm
;
710 pDevice
->abyOFDMDefaultPwr
[ii
+1] = byOFDMPwrdBm
;
712 //2008-8-4 <add> by chester
713 //recover 12,13 ,14channel for EUROPE by 11 channel
714 if(((pDevice
->abyEEPROM
[EEP_OFS_ZONETYPE
] == ZoneType_Japan
) ||
715 (pDevice
->abyEEPROM
[EEP_OFS_ZONETYPE
] == ZoneType_Europe
))&&
716 (pDevice
->byOriginalZonetype
== ZoneType_USA
)) {
717 for(ii
=11;ii
<14;ii
++) {
718 pDevice
->abyCCKPwrTbl
[ii
] = pDevice
->abyCCKPwrTbl
[10];
719 pDevice
->abyOFDMPwrTbl
[ii
] = pDevice
->abyOFDMPwrTbl
[10];
725 // Load OFDM A Power Table
726 for (ii
=0;ii
<CB_MAX_CHANNEL_5G
;ii
++) { //RobertYu:20041224, bug using CB_MAX_CHANNEL
727 pDevice
->abyOFDMPwrTbl
[ii
+CB_MAX_CHANNEL_24G
+1] = SROMbyReadEmbedded(pDevice
->PortOffset
, (unsigned char)(ii
+ EEP_OFS_OFDMA_PWR_TBL
));
728 pDevice
->abyOFDMDefaultPwr
[ii
+CB_MAX_CHANNEL_24G
+1] = SROMbyReadEmbedded(pDevice
->PortOffset
, (unsigned char)(ii
+ EEP_OFS_OFDMA_PWR_dBm
));
730 init_channel_table((void *)pDevice
);
733 if (pDevice
->byLocalID
> REV_ID_VT3253_B1
) {
734 MACvSelectPage1(pDevice
->PortOffset
);
735 VNSvOutPortB(pDevice
->PortOffset
+ MAC_REG_MSRCTL
+ 1, (MSRCTL1_TXPWR
| MSRCTL1_CSAPAREN
));
736 MACvSelectPage0(pDevice
->PortOffset
);
740 // use relative tx timeout and 802.11i D4
741 MACvWordRegBitsOn(pDevice
->PortOffset
, MAC_REG_CFG
, (CFG_TKIPOPT
| CFG_NOTXTIMEOUT
));
743 // set performance parameter by registry
744 MACvSetShortRetryLimit(pDevice
->PortOffset
, pDevice
->byShortRetryLimit
);
745 MACvSetLongRetryLimit(pDevice
->PortOffset
, pDevice
->byLongRetryLimit
);
748 VNSvOutPortB(pDevice
->PortOffset
+ MAC_REG_TFTCTL
, TFTCTL_TSFCNTRST
);
749 // enable TSF counter
750 VNSvOutPortB(pDevice
->PortOffset
+ MAC_REG_TFTCTL
, TFTCTL_TSFCNTREN
);
752 // initialize BBP registers
753 BBbVT3253Init(pDevice
);
755 if (pDevice
->bUpdateBBVGA
) {
756 pDevice
->byBBVGACurrent
= pDevice
->abyBBVGA
[0];
757 pDevice
->byBBVGANew
= pDevice
->byBBVGACurrent
;
758 BBvSetVGAGainOffset(pDevice
, pDevice
->abyBBVGA
[0]);
761 //printk("init registers:RxAntennaMode is %x,TxAntennaMode is %x\n",pDevice->byRxAntennaMode,pDevice->byTxAntennaMode);
763 BBvSetRxAntennaMode(pDevice
->PortOffset
, pDevice
->byRxAntennaMode
);
764 BBvSetTxAntennaMode(pDevice
->PortOffset
, pDevice
->byTxAntennaMode
);
766 pDevice
->byCurrentCh
= 0;
768 //pDevice->NetworkType = Ndis802_11Automode;
769 // Set BB and packet type at the same time.
770 // Set Short Slot Time, xIFS, and RSPINF.
771 if (pDevice
->uConnectionRate
== RATE_AUTO
) {
772 pDevice
->wCurrentRate
= RATE_54M
;
774 pDevice
->wCurrentRate
= (unsigned short)pDevice
->uConnectionRate
;
778 VNTWIFIbConfigPhyMode(pDevice
->pMgmt
, PHY_TYPE_11G
);
779 VNTWIFIbConfigPhyMode(pDevice
->pMgmt
, PHY_TYPE_AUTO
);
781 pDevice
->bRadioOff
= false;
783 pDevice
->byRadioCtl
= SROMbyReadEmbedded(pDevice
->PortOffset
, EEP_OFS_RADIOCTL
);
784 pDevice
->bHWRadioOff
= false;
786 if (pDevice
->byRadioCtl
& EEP_RADIOCTL_ENABLE
) {
788 MACvGPIOIn(pDevice
->PortOffset
, &pDevice
->byGPIO
);
789 //2008-4-14 <add> by chester for led issue
790 #ifdef FOR_LED_ON_NOTEBOOK
791 if (pDevice
->byGPIO
& GPIO0_DATA
){pDevice
->bHWRadioOff
= true;}
792 if ( !(pDevice
->byGPIO
& GPIO0_DATA
)){pDevice
->bHWRadioOff
= false;}
795 if ( (pDevice
->bRadioControlOff
== true)) {
796 CARDbRadioPowerOff(pDevice
);
798 else CARDbRadioPowerOn(pDevice
);
800 if (((pDevice
->byGPIO
& GPIO0_DATA
) && !(pDevice
->byRadioCtl
& EEP_RADIOCTL_INV
)) ||
801 ( !(pDevice
->byGPIO
& GPIO0_DATA
) && (pDevice
->byRadioCtl
& EEP_RADIOCTL_INV
))) {
802 pDevice
->bHWRadioOff
= true;
805 if ((pDevice
->bHWRadioOff
== true) || (pDevice
->bRadioControlOff
== true)) {
806 CARDbRadioPowerOff(pDevice
);
811 pMgmt
->eScanType
= WMAC_SCAN_PASSIVE
;
812 // get Permanent network address
813 SROMvReadEtherAddress(pDevice
->PortOffset
, pDevice
->abyCurrentNetAddr
);
814 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Network address = %pM\n",
815 pDevice
->abyCurrentNetAddr
);
818 CARDvSafeResetRx(pDevice
);
820 CARDvSafeResetTx(pDevice
);
822 if (pDevice
->byLocalID
<= REV_ID_VT3253_A1
) {
823 MACvRegBitsOn(pDevice
->PortOffset
, MAC_REG_RCR
, RCR_WPAERR
);
826 pDevice
->eEncryptionStatus
= Ndis802_11EncryptionDisabled
;
829 MACvReceive0(pDevice
->PortOffset
);
830 MACvReceive1(pDevice
->PortOffset
);
833 MACvStart(pDevice
->PortOffset
);
835 netif_stop_queue(pDevice
->dev
);
842 static void device_init_diversity_timer(PSDevice pDevice
) {
844 init_timer(&pDevice
->TimerSQ3Tmax1
);
845 pDevice
->TimerSQ3Tmax1
.data
= (unsigned long) pDevice
;
846 pDevice
->TimerSQ3Tmax1
.function
= (TimerFunction
)TimerSQ3CallBack
;
847 pDevice
->TimerSQ3Tmax1
.expires
= RUN_AT(HZ
);
849 init_timer(&pDevice
->TimerSQ3Tmax2
);
850 pDevice
->TimerSQ3Tmax2
.data
= (unsigned long) pDevice
;
851 pDevice
->TimerSQ3Tmax2
.function
= (TimerFunction
)TimerSQ3CallBack
;
852 pDevice
->TimerSQ3Tmax2
.expires
= RUN_AT(HZ
);
854 init_timer(&pDevice
->TimerSQ3Tmax3
);
855 pDevice
->TimerSQ3Tmax3
.data
= (unsigned long) pDevice
;
856 pDevice
->TimerSQ3Tmax3
.function
= (TimerFunction
)TimerState1CallBack
;
857 pDevice
->TimerSQ3Tmax3
.expires
= RUN_AT(HZ
);
863 static bool device_release_WPADEV(PSDevice pDevice
)
865 viawget_wpa_header
*wpahdr
;
867 // wait_queue_head_t Set_wait;
868 //send device close to wpa_supplicnat layer
869 if (pDevice
->bWPADEVUp
==true) {
870 wpahdr
= (viawget_wpa_header
*)pDevice
->skb
->data
;
871 wpahdr
->type
= VIAWGET_DEVICECLOSE_MSG
;
872 wpahdr
->resp_ie_len
= 0;
873 wpahdr
->req_ie_len
= 0;
874 skb_put(pDevice
->skb
, sizeof(viawget_wpa_header
));
875 pDevice
->skb
->dev
= pDevice
->wpadev
;
876 skb_reset_mac_header(pDevice
->skb
);
877 pDevice
->skb
->pkt_type
= PACKET_HOST
;
878 pDevice
->skb
->protocol
= htons(ETH_P_802_2
);
879 memset(pDevice
->skb
->cb
, 0, sizeof(pDevice
->skb
->cb
));
880 netif_rx(pDevice
->skb
);
881 pDevice
->skb
= dev_alloc_skb((int)pDevice
->rx_buf_sz
);
883 //wait release WPADEV
884 // init_waitqueue_head(&Set_wait);
885 // wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ); //1s wait
886 while((pDevice
->bWPADEVUp
==true)) {
887 set_current_state(TASK_UNINTERRUPTIBLE
);
888 schedule_timeout (HZ
/20); //wait 50ms
898 static const struct net_device_ops device_netdev_ops
= {
899 .ndo_open
= device_open
,
900 .ndo_stop
= device_close
,
901 .ndo_do_ioctl
= device_ioctl
,
902 .ndo_get_stats
= device_get_stats
,
903 .ndo_start_xmit
= device_xmit
,
904 .ndo_set_rx_mode
= device_set_multi
,
910 vt6655_probe(struct pci_dev
*pcid
, const struct pci_device_id
*ent
)
912 static bool bFirst
= true;
913 struct net_device
* dev
= NULL
;
914 PCHIP_INFO pChip_info
= (PCHIP_INFO
)ent
->driver_data
;
917 if (device_nics
++>= MAX_UINTS
) {
918 printk(KERN_NOTICE DEVICE_NAME
": already found %d NICs\n", device_nics
);
923 dev
= alloc_etherdev(sizeof(DEVICE_INFO
));
925 pDevice
= (PSDevice
) netdev_priv(dev
);
928 printk(KERN_ERR DEVICE_NAME
": allocate net device failed \n");
932 // Chain it all together
933 // SET_MODULE_OWNER(dev);
934 SET_NETDEV_DEV(dev
, &pcid
->dev
);
937 printk(KERN_NOTICE
"%s Ver. %s\n",DEVICE_FULL_DRV_NAM
, DEVICE_VERSION
);
938 printk(KERN_NOTICE
"Copyright (c) 2003 VIA Networking Technologies, Inc.\n");
942 if (!vt6655_init_info(pcid
, &pDevice
, pChip_info
)) {
946 pDevice
->next_module
= root_device_dev
;
947 root_device_dev
= dev
;
949 if (pci_enable_device(pcid
)) {
950 device_free_info(pDevice
);
953 dev
->irq
= pcid
->irq
;
956 printk("Before get pci_info memaddr is %x\n",pDevice
->memaddr
);
958 if (device_get_pci_info(pDevice
,pcid
) == false) {
959 printk(KERN_ERR DEVICE_NAME
": Failed to find PCI device.\n");
960 device_free_info(pDevice
);
968 //pci_read_config_byte(pcid, PCI_BASE_ADDRESS_0, &pDevice->byRevId);
969 printk("after get pci_info memaddr is %x, io addr is %x,io_size is %d\n",pDevice
->memaddr
,pDevice
->ioaddr
,pDevice
->io_size
);
981 for (i
=0;address
[i
];i
++)
983 //pci_write_config_dword(pcid,address[i], 0xFFFFFFFF);
984 pci_read_config_dword(pcid
, address
[i
], &bar
);
985 printk("bar %d is %x\n",i
,bar
);
988 printk("bar %d not implemented\n",i
);
991 if (bar
& PCI_BASE_ADDRESS_SPACE_IO
) {
994 len
= bar
& (PCI_BASE_ADDRESS_IO_MASK
& 0xFFFF);
995 len
= len
& ~(len
- 1);
997 printk("IO space: len in IO %x, BAR %d\n", len
, i
);
1001 len
= bar
& 0xFFFFFFF0;
1004 printk("len in MEM %x, BAR %d\n", len
, i
);
1016 pDevice
->PortOffset
= (unsigned long)ioremap(pDevice
->memaddr
& PCI_BASE_ADDRESS_MEM_MASK
, pDevice
->io_size
);
1017 //pDevice->PortOffset = (unsigned long)ioremap(pDevice->ioaddr & PCI_BASE_ADDRESS_IO_MASK, pDevice->io_size);
1019 if(pDevice
->PortOffset
== 0) {
1020 printk(KERN_ERR DEVICE_NAME
": Failed to IO remapping ..\n");
1021 device_free_info(pDevice
);
1028 rc
= pci_request_regions(pcid
, DEVICE_NAME
);
1030 printk(KERN_ERR DEVICE_NAME
": Failed to find PCI device\n");
1031 device_free_info(pDevice
);
1035 dev
->base_addr
= pDevice
->ioaddr
;
1037 unsigned char value
;
1039 VNSvInPortB(pDevice
->PortOffset
+0x4F, &value
);
1040 printk("Before write: value is %x\n",value
);
1041 //VNSvInPortB(pDevice->PortOffset+0x3F, 0x00);
1042 VNSvOutPortB(pDevice
->PortOffset
,value
);
1043 VNSvInPortB(pDevice
->PortOffset
+0x4F, &value
);
1044 printk("After write: value is %x\n",value
);
1050 pDevice
->PortOffset
= pDevice
->ioaddr
;
1053 if (!MACbSoftwareReset(pDevice
->PortOffset
)) {
1054 printk(KERN_ERR DEVICE_NAME
": Failed to access MAC hardware..\n");
1055 device_free_info(pDevice
);
1058 // initial to reload eeprom
1059 MACvInitialize(pDevice
->PortOffset
);
1060 MACvReadEtherAddress(pDevice
->PortOffset
, dev
->dev_addr
);
1062 device_get_options(pDevice
, device_nics
-1, dev
->name
);
1063 device_set_options(pDevice
);
1064 //Mask out the options cannot be set to the chip
1065 pDevice
->sOpts
.flags
&= pChip_info
->flags
;
1067 //Enable the chip specified capbilities
1068 pDevice
->flags
= pDevice
->sOpts
.flags
| (pChip_info
->flags
& 0xFF000000UL
);
1069 pDevice
->tx_80211
= device_dma0_tx_80211
;
1070 pDevice
->sMgmtObj
.pAdapter
= (void *)pDevice
;
1071 pDevice
->pMgmt
= &(pDevice
->sMgmtObj
);
1073 dev
->irq
= pcid
->irq
;
1074 dev
->netdev_ops
= &device_netdev_ops
;
1076 dev
->wireless_handlers
= (struct iw_handler_def
*)&iwctl_handler_def
;
1078 rc
= register_netdev(dev
);
1081 printk(KERN_ERR DEVICE_NAME
" Failed to register netdev\n");
1082 device_free_info(pDevice
);
1085 device_print_info(pDevice
);
1086 pci_set_drvdata(pcid
, pDevice
);
1091 static void device_print_info(PSDevice pDevice
)
1093 struct net_device
* dev
=pDevice
->dev
;
1095 DBG_PRT(MSG_LEVEL_INFO
, KERN_INFO
"%s: %s\n",dev
->name
, get_chip_name(pDevice
->chip_id
));
1096 DBG_PRT(MSG_LEVEL_INFO
, KERN_INFO
"%s: MAC=%pM", dev
->name
, dev
->dev_addr
);
1098 DBG_PRT(MSG_LEVEL_INFO
, KERN_INFO
" IO=0x%lx ",(unsigned long) pDevice
->ioaddr
);
1099 DBG_PRT(MSG_LEVEL_INFO
, KERN_INFO
" IRQ=%d \n", pDevice
->dev
->irq
);
1101 DBG_PRT(MSG_LEVEL_INFO
, KERN_INFO
" IO=0x%lx Mem=0x%lx ",
1102 (unsigned long) pDevice
->ioaddr
,(unsigned long) pDevice
->PortOffset
);
1103 DBG_PRT(MSG_LEVEL_INFO
, KERN_INFO
" IRQ=%d \n", pDevice
->dev
->irq
);
1108 static bool __devinit
vt6655_init_info(struct pci_dev
* pcid
, PSDevice
* ppDevice
,
1109 PCHIP_INFO pChip_info
) {
1113 memset(*ppDevice
,0,sizeof(DEVICE_INFO
));
1115 if (pDevice_Infos
== NULL
) {
1116 pDevice_Infos
=*ppDevice
;
1119 for (p
=pDevice_Infos
;p
->next
!=NULL
;p
=p
->next
)
1121 p
->next
= *ppDevice
;
1122 (*ppDevice
)->prev
= p
;
1125 (*ppDevice
)->pcid
= pcid
;
1126 (*ppDevice
)->chip_id
= pChip_info
->chip_id
;
1127 (*ppDevice
)->io_size
= pChip_info
->io_size
;
1128 (*ppDevice
)->nTxQueues
= pChip_info
->nTxQueue
;
1129 (*ppDevice
)->multicast_limit
=32;
1131 spin_lock_init(&((*ppDevice
)->lock
));
1136 static bool device_get_pci_info(PSDevice pDevice
, struct pci_dev
* pcid
) {
1140 unsigned int cis_addr
;
1142 unsigned char pci_config
[256];
1143 unsigned char value
=0x00;
1146 memset(pci_config
,0x00,256);
1149 pci_read_config_byte(pcid
, PCI_REVISION_ID
, &pDevice
->byRevId
);
1150 pci_read_config_word(pcid
, PCI_SUBSYSTEM_ID
,&pDevice
->SubSystemID
);
1151 pci_read_config_word(pcid
, PCI_SUBSYSTEM_VENDOR_ID
, &pDevice
->SubVendorID
);
1152 pci_read_config_word(pcid
, PCI_COMMAND
, (u16
*) & (pci_cmd
));
1154 pci_set_master(pcid
);
1156 pDevice
->memaddr
= pci_resource_start(pcid
,0);
1157 pDevice
->ioaddr
= pci_resource_start(pcid
,1);
1160 // pDevice->ioaddr = pci_resource_start(pcid, 0);
1161 // pDevice->memaddr = pci_resource_start(pcid,1);
1164 cis_addr
= pci_resource_start(pcid
,2);
1166 pDevice
->pcid
= pcid
;
1168 pci_read_config_byte(pcid
, PCI_COMMAND
, &b
);
1169 pci_write_config_byte(pcid
, PCI_COMMAND
, (b
|PCI_COMMAND_MASTER
));
1172 //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat);
1173 //printk("max lat is %x,SubSystemID is %x\n",max_lat,pDevice->SubSystemID);
1174 //for (ii=0;ii<0xFF;ii++)
1175 //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat);
1177 //pci_write_config_word(pcid,PCI_MAX_LAT,max_lat);
1178 //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat);
1179 //printk("max lat is %x\n",max_lat);
1181 for (ii
=0;ii
<0xFF;ii
++)
1183 pci_read_config_byte(pcid
,ii
,&value
);
1184 pci_config
[ii
] = value
;
1186 for (ii
=0,j
=1;ii
<0x100;ii
++,j
++)
1190 printk("%x:",pci_config
[ii
]);
1195 printk("%x:",pci_config
[ii
]);
1202 static void device_free_info(PSDevice pDevice
) {
1204 struct net_device
* dev
=pDevice
->dev
;
1207 //2008-0714-01<Add>by chester
1208 device_release_WPADEV(pDevice
);
1210 //2008-07-21-01<Add>by MikeLiu
1212 if(wpa_set_wpadev(pDevice
, 0)!=0)
1213 printk("unregister wpadev fail?\n");
1215 if (pDevice_Infos
==NULL
)
1218 for (ptr
=pDevice_Infos
;ptr
&& (ptr
!=pDevice
);ptr
=ptr
->next
)
1222 if (ptr
==pDevice_Infos
)
1223 pDevice_Infos
=ptr
->next
;
1225 ptr
->prev
->next
=ptr
->next
;
1228 DBG_PRT(MSG_LEVEL_ERR
, KERN_ERR
"info struct not found\n");
1233 vt6655_hostap_set_hostapd(pDevice
, 0, 0);
1236 unregister_netdev(dev
);
1238 if (pDevice
->PortOffset
)
1239 iounmap((void *)pDevice
->PortOffset
);
1242 pci_release_regions(pDevice
->pcid
);
1246 if (pDevice
->pcid
) {
1247 pci_set_drvdata(pDevice
->pcid
,NULL
);
1251 static bool device_init_rings(PSDevice pDevice
) {
1255 /*allocate all RD/TD rings a single pool*/
1256 vir_pool
= pci_alloc_consistent(pDevice
->pcid
,
1257 pDevice
->sOpts
.nRxDescs0
* sizeof(SRxDesc
) +
1258 pDevice
->sOpts
.nRxDescs1
* sizeof(SRxDesc
) +
1259 pDevice
->sOpts
.nTxDescs
[0] * sizeof(STxDesc
) +
1260 pDevice
->sOpts
.nTxDescs
[1] * sizeof(STxDesc
),
1261 &pDevice
->pool_dma
);
1263 if (vir_pool
== NULL
) {
1264 DBG_PRT(MSG_LEVEL_ERR
,KERN_ERR
"%s : allocate desc dma memory failed\n", pDevice
->dev
->name
);
1269 pDevice
->sOpts
.nRxDescs0
* sizeof(SRxDesc
) +
1270 pDevice
->sOpts
.nRxDescs1
* sizeof(SRxDesc
) +
1271 pDevice
->sOpts
.nTxDescs
[0] * sizeof(STxDesc
) +
1272 pDevice
->sOpts
.nTxDescs
[1] * sizeof(STxDesc
)
1275 pDevice
->aRD0Ring
= vir_pool
;
1276 pDevice
->aRD1Ring
= vir_pool
+
1277 pDevice
->sOpts
.nRxDescs0
* sizeof(SRxDesc
);
1280 pDevice
->rd0_pool_dma
= pDevice
->pool_dma
;
1281 pDevice
->rd1_pool_dma
= pDevice
->rd0_pool_dma
+
1282 pDevice
->sOpts
.nRxDescs0
* sizeof(SRxDesc
);
1284 pDevice
->tx0_bufs
= pci_alloc_consistent(pDevice
->pcid
,
1285 pDevice
->sOpts
.nTxDescs
[0] * PKT_BUF_SZ
+
1286 pDevice
->sOpts
.nTxDescs
[1] * PKT_BUF_SZ
+
1287 CB_BEACON_BUF_SIZE
+
1289 &pDevice
->tx_bufs_dma0
);
1291 if (pDevice
->tx0_bufs
== NULL
) {
1292 DBG_PRT(MSG_LEVEL_ERR
,KERN_ERR
"%s: allocate buf dma memory failed\n", pDevice
->dev
->name
);
1293 pci_free_consistent(pDevice
->pcid
,
1294 pDevice
->sOpts
.nRxDescs0
* sizeof(SRxDesc
) +
1295 pDevice
->sOpts
.nRxDescs1
* sizeof(SRxDesc
) +
1296 pDevice
->sOpts
.nTxDescs
[0] * sizeof(STxDesc
) +
1297 pDevice
->sOpts
.nTxDescs
[1] * sizeof(STxDesc
),
1298 vir_pool
, pDevice
->pool_dma
1303 memset(pDevice
->tx0_bufs
, 0,
1304 pDevice
->sOpts
.nTxDescs
[0] * PKT_BUF_SZ
+
1305 pDevice
->sOpts
.nTxDescs
[1] * PKT_BUF_SZ
+
1306 CB_BEACON_BUF_SIZE
+
1310 pDevice
->td0_pool_dma
= pDevice
->rd1_pool_dma
+
1311 pDevice
->sOpts
.nRxDescs1
* sizeof(SRxDesc
);
1313 pDevice
->td1_pool_dma
= pDevice
->td0_pool_dma
+
1314 pDevice
->sOpts
.nTxDescs
[0] * sizeof(STxDesc
);
1317 // vir_pool: pvoid type
1318 pDevice
->apTD0Rings
= vir_pool
1319 + pDevice
->sOpts
.nRxDescs0
* sizeof(SRxDesc
)
1320 + pDevice
->sOpts
.nRxDescs1
* sizeof(SRxDesc
);
1322 pDevice
->apTD1Rings
= vir_pool
1323 + pDevice
->sOpts
.nRxDescs0
* sizeof(SRxDesc
)
1324 + pDevice
->sOpts
.nRxDescs1
* sizeof(SRxDesc
)
1325 + pDevice
->sOpts
.nTxDescs
[0] * sizeof(STxDesc
);
1328 pDevice
->tx1_bufs
= pDevice
->tx0_bufs
+
1329 pDevice
->sOpts
.nTxDescs
[0] * PKT_BUF_SZ
;
1332 pDevice
->tx_beacon_bufs
= pDevice
->tx1_bufs
+
1333 pDevice
->sOpts
.nTxDescs
[1] * PKT_BUF_SZ
;
1335 pDevice
->pbyTmpBuff
= pDevice
->tx_beacon_bufs
+
1338 pDevice
->tx_bufs_dma1
= pDevice
->tx_bufs_dma0
+
1339 pDevice
->sOpts
.nTxDescs
[0] * PKT_BUF_SZ
;
1342 pDevice
->tx_beacon_dma
= pDevice
->tx_bufs_dma1
+
1343 pDevice
->sOpts
.nTxDescs
[1] * PKT_BUF_SZ
;
1349 static void device_free_rings(PSDevice pDevice
) {
1351 pci_free_consistent(pDevice
->pcid
,
1352 pDevice
->sOpts
.nRxDescs0
* sizeof(SRxDesc
) +
1353 pDevice
->sOpts
.nRxDescs1
* sizeof(SRxDesc
) +
1354 pDevice
->sOpts
.nTxDescs
[0] * sizeof(STxDesc
) +
1355 pDevice
->sOpts
.nTxDescs
[1] * sizeof(STxDesc
)
1357 pDevice
->aRD0Ring
, pDevice
->pool_dma
1360 if (pDevice
->tx0_bufs
)
1361 pci_free_consistent(pDevice
->pcid
,
1362 pDevice
->sOpts
.nTxDescs
[0] * PKT_BUF_SZ
+
1363 pDevice
->sOpts
.nTxDescs
[1] * PKT_BUF_SZ
+
1364 CB_BEACON_BUF_SIZE
+
1366 pDevice
->tx0_bufs
, pDevice
->tx_bufs_dma0
1370 static void device_init_rd0_ring(PSDevice pDevice
) {
1372 dma_addr_t curr
= pDevice
->rd0_pool_dma
;
1375 /* Init the RD0 ring entries */
1376 for (i
= 0; i
< pDevice
->sOpts
.nRxDescs0
; i
++, curr
+= sizeof(SRxDesc
)) {
1377 pDesc
= &(pDevice
->aRD0Ring
[i
]);
1378 pDesc
->pRDInfo
= alloc_rd_info();
1379 ASSERT(pDesc
->pRDInfo
);
1380 if (!device_alloc_rx_buf(pDevice
, pDesc
)) {
1381 DBG_PRT(MSG_LEVEL_ERR
,KERN_ERR
"%s: can not alloc rx bufs\n",
1382 pDevice
->dev
->name
);
1384 pDesc
->next
= &(pDevice
->aRD0Ring
[(i
+1) % pDevice
->sOpts
.nRxDescs0
]);
1385 pDesc
->pRDInfo
->curr_desc
= cpu_to_le32(curr
);
1386 pDesc
->next_desc
= cpu_to_le32(curr
+ sizeof(SRxDesc
));
1390 pDevice
->aRD0Ring
[i
-1].next_desc
= cpu_to_le32(pDevice
->rd0_pool_dma
);
1391 pDevice
->pCurrRD
[0] = &(pDevice
->aRD0Ring
[0]);
1395 static void device_init_rd1_ring(PSDevice pDevice
) {
1397 dma_addr_t curr
= pDevice
->rd1_pool_dma
;
1400 /* Init the RD1 ring entries */
1401 for (i
= 0; i
< pDevice
->sOpts
.nRxDescs1
; i
++, curr
+= sizeof(SRxDesc
)) {
1402 pDesc
= &(pDevice
->aRD1Ring
[i
]);
1403 pDesc
->pRDInfo
= alloc_rd_info();
1404 ASSERT(pDesc
->pRDInfo
);
1405 if (!device_alloc_rx_buf(pDevice
, pDesc
)) {
1406 DBG_PRT(MSG_LEVEL_ERR
,KERN_ERR
"%s: can not alloc rx bufs\n",
1407 pDevice
->dev
->name
);
1409 pDesc
->next
= &(pDevice
->aRD1Ring
[(i
+1) % pDevice
->sOpts
.nRxDescs1
]);
1410 pDesc
->pRDInfo
->curr_desc
= cpu_to_le32(curr
);
1411 pDesc
->next_desc
= cpu_to_le32(curr
+ sizeof(SRxDesc
));
1415 pDevice
->aRD1Ring
[i
-1].next_desc
= cpu_to_le32(pDevice
->rd1_pool_dma
);
1416 pDevice
->pCurrRD
[1] = &(pDevice
->aRD1Ring
[0]);
1420 static void device_init_defrag_cb(PSDevice pDevice
) {
1422 PSDeFragControlBlock pDeF
;
1424 /* Init the fragment ctl entries */
1425 for (i
= 0; i
< CB_MAX_RX_FRAG
; i
++) {
1426 pDeF
= &(pDevice
->sRxDFCB
[i
]);
1427 if (!device_alloc_frag_buf(pDevice
, pDeF
)) {
1428 DBG_PRT(MSG_LEVEL_ERR
,KERN_ERR
"%s: can not alloc frag bufs\n",
1429 pDevice
->dev
->name
);
1432 pDevice
->cbDFCB
= CB_MAX_RX_FRAG
;
1433 pDevice
->cbFreeDFCB
= pDevice
->cbDFCB
;
1439 static void device_free_rd0_ring(PSDevice pDevice
) {
1442 for (i
= 0; i
< pDevice
->sOpts
.nRxDescs0
; i
++) {
1443 PSRxDesc pDesc
=&(pDevice
->aRD0Ring
[i
]);
1444 PDEVICE_RD_INFO pRDInfo
=pDesc
->pRDInfo
;
1446 pci_unmap_single(pDevice
->pcid
,pRDInfo
->skb_dma
,
1447 pDevice
->rx_buf_sz
, PCI_DMA_FROMDEVICE
);
1449 dev_kfree_skb(pRDInfo
->skb
);
1451 kfree((void *)pDesc
->pRDInfo
);
1456 static void device_free_rd1_ring(PSDevice pDevice
) {
1460 for (i
= 0; i
< pDevice
->sOpts
.nRxDescs1
; i
++) {
1461 PSRxDesc pDesc
=&(pDevice
->aRD1Ring
[i
]);
1462 PDEVICE_RD_INFO pRDInfo
=pDesc
->pRDInfo
;
1464 pci_unmap_single(pDevice
->pcid
,pRDInfo
->skb_dma
,
1465 pDevice
->rx_buf_sz
, PCI_DMA_FROMDEVICE
);
1467 dev_kfree_skb(pRDInfo
->skb
);
1469 kfree((void *)pDesc
->pRDInfo
);
1474 static void device_free_frag_buf(PSDevice pDevice
) {
1475 PSDeFragControlBlock pDeF
;
1478 for (i
= 0; i
< CB_MAX_RX_FRAG
; i
++) {
1480 pDeF
= &(pDevice
->sRxDFCB
[i
]);
1483 dev_kfree_skb(pDeF
->skb
);
1489 static void device_init_td0_ring(PSDevice pDevice
) {
1494 curr
= pDevice
->td0_pool_dma
;
1495 for (i
= 0; i
< pDevice
->sOpts
.nTxDescs
[0]; i
++, curr
+= sizeof(STxDesc
)) {
1496 pDesc
= &(pDevice
->apTD0Rings
[i
]);
1497 pDesc
->pTDInfo
= alloc_td_info();
1498 ASSERT(pDesc
->pTDInfo
);
1499 if (pDevice
->flags
& DEVICE_FLAGS_TX_ALIGN
) {
1500 pDesc
->pTDInfo
->buf
= pDevice
->tx0_bufs
+ (i
)*PKT_BUF_SZ
;
1501 pDesc
->pTDInfo
->buf_dma
= pDevice
->tx_bufs_dma0
+ (i
)*PKT_BUF_SZ
;
1503 pDesc
->next
=&(pDevice
->apTD0Rings
[(i
+1) % pDevice
->sOpts
.nTxDescs
[0]]);
1504 pDesc
->pTDInfo
->curr_desc
= cpu_to_le32(curr
);
1505 pDesc
->next_desc
= cpu_to_le32(curr
+sizeof(STxDesc
));
1509 pDevice
->apTD0Rings
[i
-1].next_desc
= cpu_to_le32(pDevice
->td0_pool_dma
);
1510 pDevice
->apTailTD
[0] = pDevice
->apCurrTD
[0] =&(pDevice
->apTD0Rings
[0]);
1514 static void device_init_td1_ring(PSDevice pDevice
) {
1519 /* Init the TD ring entries */
1520 curr
=pDevice
->td1_pool_dma
;
1521 for (i
= 0; i
< pDevice
->sOpts
.nTxDescs
[1]; i
++, curr
+=sizeof(STxDesc
)) {
1522 pDesc
=&(pDevice
->apTD1Rings
[i
]);
1523 pDesc
->pTDInfo
= alloc_td_info();
1524 ASSERT(pDesc
->pTDInfo
);
1525 if (pDevice
->flags
& DEVICE_FLAGS_TX_ALIGN
) {
1526 pDesc
->pTDInfo
->buf
=pDevice
->tx1_bufs
+(i
)*PKT_BUF_SZ
;
1527 pDesc
->pTDInfo
->buf_dma
=pDevice
->tx_bufs_dma1
+(i
)*PKT_BUF_SZ
;
1529 pDesc
->next
=&(pDevice
->apTD1Rings
[(i
+1) % pDevice
->sOpts
.nTxDescs
[1]]);
1530 pDesc
->pTDInfo
->curr_desc
= cpu_to_le32(curr
);
1531 pDesc
->next_desc
= cpu_to_le32(curr
+sizeof(STxDesc
));
1535 pDevice
->apTD1Rings
[i
-1].next_desc
= cpu_to_le32(pDevice
->td1_pool_dma
);
1536 pDevice
->apTailTD
[1] = pDevice
->apCurrTD
[1] = &(pDevice
->apTD1Rings
[0]);
1541 static void device_free_td0_ring(PSDevice pDevice
) {
1543 for (i
= 0; i
< pDevice
->sOpts
.nTxDescs
[0]; i
++) {
1544 PSTxDesc pDesc
=&(pDevice
->apTD0Rings
[i
]);
1545 PDEVICE_TD_INFO pTDInfo
=pDesc
->pTDInfo
;
1547 if (pTDInfo
->skb_dma
&& (pTDInfo
->skb_dma
!= pTDInfo
->buf_dma
))
1548 pci_unmap_single(pDevice
->pcid
,pTDInfo
->skb_dma
,
1549 pTDInfo
->skb
->len
, PCI_DMA_TODEVICE
);
1552 dev_kfree_skb(pTDInfo
->skb
);
1554 kfree((void *)pDesc
->pTDInfo
);
1558 static void device_free_td1_ring(PSDevice pDevice
) {
1561 for (i
= 0; i
< pDevice
->sOpts
.nTxDescs
[1]; i
++) {
1562 PSTxDesc pDesc
=&(pDevice
->apTD1Rings
[i
]);
1563 PDEVICE_TD_INFO pTDInfo
=pDesc
->pTDInfo
;
1565 if (pTDInfo
->skb_dma
&& (pTDInfo
->skb_dma
!= pTDInfo
->buf_dma
))
1566 pci_unmap_single(pDevice
->pcid
, pTDInfo
->skb_dma
,
1567 pTDInfo
->skb
->len
, PCI_DMA_TODEVICE
);
1570 dev_kfree_skb(pTDInfo
->skb
);
1572 kfree((void *)pDesc
->pTDInfo
);
1579 /*-----------------------------------------------------------------*/
1581 static int device_rx_srv(PSDevice pDevice
, unsigned int uIdx
) {
1586 for (pRD
= pDevice
->pCurrRD
[uIdx
];
1587 pRD
->m_rd0RD0
.f1Owner
== OWNED_BY_HOST
;
1589 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->pCurrRD = %x, works = %d\n", pRD, works);
1592 if (device_receive_frame(pDevice
, pRD
)) {
1593 if (!device_alloc_rx_buf(pDevice
,pRD
)) {
1594 DBG_PRT(MSG_LEVEL_ERR
, KERN_ERR
1595 "%s: can not allocate rx buf\n", pDevice
->dev
->name
);
1599 pRD
->m_rd0RD0
.f1Owner
= OWNED_BY_NIC
;
1600 pDevice
->dev
->last_rx
= jiffies
;
1603 pDevice
->pCurrRD
[uIdx
]=pRD
;
1609 static bool device_alloc_rx_buf(PSDevice pDevice
, PSRxDesc pRD
) {
1611 PDEVICE_RD_INFO pRDInfo
=pRD
->pRDInfo
;
1614 pRDInfo
->skb
= dev_alloc_skb((int)pDevice
->rx_buf_sz
);
1616 //printk("device_alloc_rx_buf:skb is %x\n",pRDInfo->skb);
1618 if (pRDInfo
->skb
==NULL
)
1620 ASSERT(pRDInfo
->skb
);
1621 pRDInfo
->skb
->dev
= pDevice
->dev
;
1622 pRDInfo
->skb_dma
= pci_map_single(pDevice
->pcid
, skb_tail_pointer(pRDInfo
->skb
),
1623 pDevice
->rx_buf_sz
, PCI_DMA_FROMDEVICE
);
1624 *((unsigned int *) &(pRD
->m_rd0RD0
)) = 0; /* FIX cast */
1626 pRD
->m_rd0RD0
.wResCount
= cpu_to_le16(pDevice
->rx_buf_sz
);
1627 pRD
->m_rd0RD0
.f1Owner
= OWNED_BY_NIC
;
1628 pRD
->m_rd1RD1
.wReqCount
= cpu_to_le16(pDevice
->rx_buf_sz
);
1629 pRD
->buff_addr
= cpu_to_le32(pRDInfo
->skb_dma
);
1636 bool device_alloc_frag_buf(PSDevice pDevice
, PSDeFragControlBlock pDeF
) {
1638 pDeF
->skb
= dev_alloc_skb((int)pDevice
->rx_buf_sz
);
1639 if (pDeF
->skb
== NULL
)
1642 pDeF
->skb
->dev
= pDevice
->dev
;
1649 static int device_tx_srv(PSDevice pDevice
, unsigned int uIdx
) {
1653 unsigned char byTsr0
;
1654 unsigned char byTsr1
;
1655 unsigned int uFrameSize
, uFIFOHeaderSize
;
1656 PSTxBufHead pTxBufHead
;
1657 struct net_device_stats
* pStats
= &pDevice
->stats
;
1658 struct sk_buff
* skb
;
1659 unsigned int uNodeIndex
;
1660 PSMgmtObject pMgmt
= pDevice
->pMgmt
;
1663 for (pTD
= pDevice
->apTailTD
[uIdx
]; pDevice
->iTDUsed
[uIdx
] >0; pTD
= pTD
->next
) {
1665 if (pTD
->m_td0TD0
.f1Owner
== OWNED_BY_NIC
)
1670 byTsr0
= pTD
->m_td0TD0
.byTSR0
;
1671 byTsr1
= pTD
->m_td0TD0
.byTSR1
;
1673 //Only the status of first TD in the chain is correct
1674 if (pTD
->m_td1TD1
.byTCR
& TCR_STP
) {
1676 if ((pTD
->pTDInfo
->byFlags
& TD_FLAGS_NETIF_SKB
) != 0) {
1677 uFIFOHeaderSize
= pTD
->pTDInfo
->dwHeaderLength
;
1678 uFrameSize
= pTD
->pTDInfo
->dwReqCount
- uFIFOHeaderSize
;
1679 pTxBufHead
= (PSTxBufHead
) (pTD
->pTDInfo
->buf
);
1680 // Update the statistics based on the Transmit status
1681 // now, we DO'NT check TSR0_CDH
1683 STAvUpdateTDStatCounter(&pDevice
->scStatistic
,
1685 (unsigned char *)(pTD
->pTDInfo
->buf
+ uFIFOHeaderSize
),
1689 BSSvUpdateNodeTxCounter(pDevice
,
1691 (unsigned char *)(pTD
->pTDInfo
->buf
),
1695 if ( !(byTsr1
& TSR1_TERR
)) {
1697 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" Tx[%d] OK but has error. tsr1[%02X] tsr0[%02X].\n",
1698 (int)uIdx
, byTsr1
, byTsr0
);
1700 if ((pTxBufHead
->wFragCtl
& FRAGCTL_ENDFRAG
) != FRAGCTL_NONFRAG
) {
1701 pDevice
->s802_11Counter
.TransmittedFragmentCount
++;
1703 pStats
->tx_packets
++;
1704 pStats
->tx_bytes
+= pTD
->pTDInfo
->skb
->len
;
1707 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" Tx[%d] dropped & tsr1[%02X] tsr0[%02X].\n",
1708 (int)uIdx
, byTsr1
, byTsr0
);
1709 pStats
->tx_errors
++;
1710 pStats
->tx_dropped
++;
1714 if ((pTD
->pTDInfo
->byFlags
& TD_FLAGS_PRIV_SKB
) != 0) {
1715 if (pDevice
->bEnableHostapd
) {
1716 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"tx call back netif.. \n");
1717 skb
= pTD
->pTDInfo
->skb
;
1718 skb
->dev
= pDevice
->apdev
;
1719 skb_reset_mac_header(skb
);
1720 skb
->pkt_type
= PACKET_OTHERHOST
;
1721 //skb->protocol = htons(ETH_P_802_2);
1722 memset(skb
->cb
, 0, sizeof(skb
->cb
));
1727 if (byTsr1
& TSR1_TERR
) {
1728 if ((pTD
->pTDInfo
->byFlags
& TD_FLAGS_PRIV_SKB
) != 0) {
1729 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
1730 (int)uIdx
, byTsr1
, byTsr0
);
1733 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
1734 // (int)uIdx, byTsr1, byTsr0);
1736 if ((pMgmt
->eCurrMode
== WMAC_MODE_ESS_AP
) &&
1737 (pTD
->pTDInfo
->byFlags
& TD_FLAGS_NETIF_SKB
)) {
1738 unsigned short wAID
;
1739 unsigned char byMask
[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
1741 skb
= pTD
->pTDInfo
->skb
;
1742 if (BSSDBbIsSTAInNodeDB(pMgmt
, (unsigned char *)(skb
->data
), &uNodeIndex
)) {
1743 if (pMgmt
->sNodeDBTable
[uNodeIndex
].bPSEnable
) {
1744 skb_queue_tail(&pMgmt
->sNodeDBTable
[uNodeIndex
].sTxPSQueue
, skb
);
1745 pMgmt
->sNodeDBTable
[uNodeIndex
].wEnQueueCnt
++;
1747 wAID
= pMgmt
->sNodeDBTable
[uNodeIndex
].wAID
;
1748 pMgmt
->abyPSTxMap
[wAID
>> 3] |= byMask
[wAID
& 7];
1749 pTD
->pTDInfo
->byFlags
&= ~(TD_FLAGS_NETIF_SKB
);
1750 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"tx_srv:tx fail re-queue sta index= %d, QueCnt= %d\n"
1751 ,(int)uNodeIndex
, pMgmt
->sNodeDBTable
[uNodeIndex
].wEnQueueCnt
);
1752 pStats
->tx_errors
--;
1753 pStats
->tx_dropped
--;
1758 device_free_tx_buf(pDevice
,pTD
);
1759 pDevice
->iTDUsed
[uIdx
]--;
1764 if (uIdx
== TYPE_AC0DMA
) {
1765 // RESERV_AC0DMA reserved for relay
1767 if (AVAIL_TD(pDevice
, uIdx
) < RESERV_AC0DMA
) {
1769 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" AC0DMA is Full = %d\n", pDevice
->iTDUsed
[uIdx
]);
1771 if (netif_queue_stopped(pDevice
->dev
) && (bFull
==false)){
1772 netif_wake_queue(pDevice
->dev
);
1777 pDevice
->apTailTD
[uIdx
] = pTD
;
1783 static void device_error(PSDevice pDevice
, unsigned short status
) {
1785 if (status
& ISR_FETALERR
) {
1786 DBG_PRT(MSG_LEVEL_ERR
, KERN_ERR
1787 "%s: Hardware fatal error.\n",
1788 pDevice
->dev
->name
);
1789 netif_stop_queue(pDevice
->dev
);
1790 del_timer(&pDevice
->sTimerCommand
);
1791 del_timer(&(pDevice
->pMgmt
->sTimerSecondCallback
));
1792 pDevice
->bCmdRunning
= false;
1793 MACbShutdown(pDevice
->PortOffset
);
1799 static void device_free_tx_buf(PSDevice pDevice
, PSTxDesc pDesc
) {
1800 PDEVICE_TD_INFO pTDInfo
=pDesc
->pTDInfo
;
1801 struct sk_buff
* skb
=pTDInfo
->skb
;
1803 // pre-allocated buf_dma can't be unmapped.
1804 if (pTDInfo
->skb_dma
&& (pTDInfo
->skb_dma
!= pTDInfo
->buf_dma
)) {
1805 pci_unmap_single(pDevice
->pcid
,pTDInfo
->skb_dma
,skb
->len
,
1809 if ((pTDInfo
->byFlags
& TD_FLAGS_NETIF_SKB
) != 0)
1810 dev_kfree_skb_irq(skb
);
1812 pTDInfo
->skb_dma
= 0;
1814 pTDInfo
->byFlags
= 0;
1820 void InitRxManagementQueue(PSDevice pDevice
)
1822 pDevice
->rxManeQueue
.packet_num
= 0;
1823 pDevice
->rxManeQueue
.head
= pDevice
->rxManeQueue
.tail
= 0;
1835 PSDevice pDevice
= (PSDevice
) Context
;
1836 PSRxMgmtPacket pRxMgmtPacket
;
1838 //complete(&pDevice->notify);
1839 //printk("Enter MngWorkItem,Queue packet num is %d\n",pDevice->rxManeQueue.packet_num);
1841 //printk("Enter MlmeThread,packet _num is %d\n",pDevice->rxManeQueue.packet_num);
1848 //down(&pDevice->mlme_semaphore);
1849 // pRxMgmtPacket = DeQueue(pDevice);
1851 spin_lock_irq(&pDevice
->lock
);
1852 while(pDevice
->rxManeQueue
.packet_num
!= 0)
1854 pRxMgmtPacket
= DeQueue(pDevice
);
1856 //DequeueManageObject(pDevice->FirstRecvMngList, pDevice->LastRecvMngList);
1857 vMgrRxManagePacket(pDevice
, pDevice
->pMgmt
, pRxMgmtPacket
);
1858 //printk("packet_num is %d\n",pDevice->rxManeQueue.packet_num);
1861 spin_unlock_irq(&pDevice
->lock
);
1866 //printk("Before schedule thread jiffies is %x\n",jiffies);
1868 //printk("after schedule thread jiffies is %x\n",jiffies);
1871 //printk("i is %d\n",i);
1881 static int device_open(struct net_device
*dev
) {
1882 PSDevice pDevice
=(PSDevice
) netdev_priv(dev
);
1884 #ifdef WPA_SM_Transtatus
1885 extern SWPAResult wpa_Result
;
1888 pDevice
->rx_buf_sz
= PKT_BUF_SZ
;
1889 if (!device_init_rings(pDevice
)) {
1892 //2008-5-13 <add> by chester
1893 i
=request_irq(pDevice
->pcid
->irq
, &device_intr
, IRQF_SHARED
, dev
->name
, dev
);
1896 //printk("DEBUG1\n");
1897 #ifdef WPA_SM_Transtatus
1898 memset(wpa_Result
.ifname
,0,sizeof(wpa_Result
.ifname
));
1899 wpa_Result
.proto
= 0;
1900 wpa_Result
.key_mgmt
= 0;
1901 wpa_Result
.eap_type
= 0;
1902 wpa_Result
.authenticated
= false;
1903 pDevice
->fWPA_Authened
= false;
1905 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"call device init rd0 ring\n");
1906 device_init_rd0_ring(pDevice
);
1907 device_init_rd1_ring(pDevice
);
1908 device_init_defrag_cb(pDevice
);
1909 device_init_td0_ring(pDevice
);
1910 device_init_td1_ring(pDevice
);
1911 // VNTWIFIvSet11h(pDevice->pMgmt, pDevice->b11hEnable);
1914 if (pDevice
->bDiversityRegCtlON
) {
1915 device_init_diversity_timer(pDevice
);
1917 vMgrObjectInit(pDevice
);
1918 vMgrTimerInit(pDevice
);
1922 tasklet_init (&pDevice
->RxMngWorkItem
,(void *)MngWorkItem
,(unsigned long )pDevice
);
1925 InitRxManagementQueue(pDevice
);
1927 mlme_task
= kthread_run(MlmeThread
,(void *) pDevice
, "MLME");
1928 if (IS_ERR(mlme_task
)) {
1929 printk("thread create fail\n");
1938 //printk("thread id is %d\n",pDevice->MLMEThr_pid);
1939 //printk("Create thread time is %x\n",jiffies);
1940 //wait_for_completion(&pDevice->notify);
1945 // if (( SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RADIOCTL)&0x06)==0x04)
1947 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"call device_init_registers\n");
1948 device_init_registers(pDevice
, DEVICE_INIT_COLD
);
1949 MACvReadEtherAddress(pDevice
->PortOffset
, pDevice
->abyCurrentNetAddr
);
1950 memcpy(pDevice
->pMgmt
->abyMACAddr
, pDevice
->abyCurrentNetAddr
, ETH_ALEN
);
1951 device_set_multi(pDevice
->dev
);
1953 // Init for Key Management
1954 KeyvInitTable(&pDevice
->sKey
, pDevice
->PortOffset
);
1955 add_timer(&(pDevice
->pMgmt
->sTimerSecondCallback
));
1957 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1959 pDevice->bwextstep0 = false;
1960 pDevice->bwextstep1 = false;
1961 pDevice->bwextstep2 = false;
1962 pDevice->bwextstep3 = false;
1964 pDevice
->bwextcount
=0;
1965 pDevice
->bWPASuppWextEnabled
= false;
1967 pDevice
->byReAssocCount
= 0;
1968 pDevice
->bWPADEVUp
= false;
1969 // Patch: if WEP key already set by iwconfig but device not yet open
1970 if ((pDevice
->bEncryptionEnable
== true) && (pDevice
->bTransmitKey
== true)) {
1971 KeybSetDefaultKey(&(pDevice
->sKey
),
1972 (unsigned long)(pDevice
->byKeyIndex
| (1 << 31)),
1973 pDevice
->uKeyLength
,
1977 pDevice
->PortOffset
,
1980 pDevice
->eEncryptionStatus
= Ndis802_11Encryption1Enabled
;
1983 //printk("DEBUG2\n");
1986 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"call MACvIntEnable\n");
1987 MACvIntEnable(pDevice
->PortOffset
, IMR_MASK_VALUE
);
1989 if (pDevice
->pMgmt
->eConfigMode
== WMAC_CONFIG_AP
) {
1990 bScheduleCommand((void *)pDevice
, WLAN_CMD_RUN_AP
, NULL
);
1993 bScheduleCommand((void *)pDevice
, WLAN_CMD_BSSID_SCAN
, NULL
);
1994 bScheduleCommand((void *)pDevice
, WLAN_CMD_SSID
, NULL
);
1996 pDevice
->flags
|=DEVICE_FLAGS_OPENED
;
1998 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"device_open success.. \n");
2003 static int device_close(struct net_device
*dev
) {
2004 PSDevice pDevice
=(PSDevice
) netdev_priv(dev
);
2005 PSMgmtObject pMgmt
= pDevice
->pMgmt
;
2011 //2007-1121-02<Add>by EinsnLiu
2012 if (pDevice
->bLinkPass
) {
2013 bScheduleCommand((void *)pDevice
, WLAN_CMD_DISASSOCIATE
, NULL
);
2017 del_timer(&pDevice
->sTimerTxData
);
2019 del_timer(&pDevice
->sTimerCommand
);
2020 del_timer(&pMgmt
->sTimerSecondCallback
);
2021 if (pDevice
->bDiversityRegCtlON
) {
2022 del_timer(&pDevice
->TimerSQ3Tmax1
);
2023 del_timer(&pDevice
->TimerSQ3Tmax2
);
2024 del_timer(&pDevice
->TimerSQ3Tmax3
);
2028 tasklet_kill(&pDevice
->RxMngWorkItem
);
2030 netif_stop_queue(dev
);
2031 pDevice
->bCmdRunning
= false;
2032 MACbShutdown(pDevice
->PortOffset
);
2033 MACbSoftwareReset(pDevice
->PortOffset
);
2034 CARDbRadioPowerOff(pDevice
);
2036 pDevice
->bLinkPass
= false;
2037 memset(pMgmt
->abyCurrBSSID
, 0, 6);
2038 pMgmt
->eCurrState
= WMAC_STATE_IDLE
;
2039 device_free_td0_ring(pDevice
);
2040 device_free_td1_ring(pDevice
);
2041 device_free_rd0_ring(pDevice
);
2042 device_free_rd1_ring(pDevice
);
2043 device_free_frag_buf(pDevice
);
2044 device_free_rings(pDevice
);
2045 BSSvClearNodeDBTable(pDevice
, 0);
2046 free_irq(dev
->irq
, dev
);
2047 pDevice
->flags
&=(~DEVICE_FLAGS_OPENED
);
2048 //2008-0714-01<Add>by chester
2049 device_release_WPADEV(pDevice
);
2051 //tasklet_kill(&pDevice->RxMngWorkItem);
2053 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"device_close.. \n");
2059 static int device_dma0_tx_80211(struct sk_buff
*skb
, struct net_device
*dev
) {
2060 PSDevice pDevice
=netdev_priv(dev
);
2061 unsigned char *pbMPDU
;
2062 unsigned int cbMPDULen
= 0;
2065 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"device_dma0_tx_80211\n");
2066 spin_lock_irq(&pDevice
->lock
);
2068 if (AVAIL_TD(pDevice
, TYPE_TXDMA0
) <= 0) {
2069 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"device_dma0_tx_80211, td0 <=0\n");
2070 dev_kfree_skb_irq(skb
);
2071 spin_unlock_irq(&pDevice
->lock
);
2075 if (pDevice
->bStopTx0Pkt
== true) {
2076 dev_kfree_skb_irq(skb
);
2077 spin_unlock_irq(&pDevice
->lock
);
2081 cbMPDULen
= skb
->len
;
2084 vDMA0_tx_80211(pDevice
, skb
, pbMPDU
, cbMPDULen
);
2086 spin_unlock_irq(&pDevice
->lock
);
2094 bool device_dma0_xmit(PSDevice pDevice
, struct sk_buff
*skb
, unsigned int uNodeIndex
) {
2095 PSMgmtObject pMgmt
= pDevice
->pMgmt
;
2096 PSTxDesc pHeadTD
, pLastTD
;
2097 unsigned int cbFrameBodySize
;
2098 unsigned int uMACfragNum
;
2099 unsigned char byPktType
;
2100 bool bNeedEncryption
= false;
2101 PSKeyItem pTransmitKey
= NULL
;
2102 unsigned int cbHeaderSize
;
2105 // unsigned char byKeyIndex = 0;
2108 if (pDevice
->bStopTx0Pkt
== true) {
2109 dev_kfree_skb_irq(skb
);
2113 if (AVAIL_TD(pDevice
, TYPE_TXDMA0
) <= 0) {
2114 dev_kfree_skb_irq(skb
);
2115 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"device_dma0_xmit, td0 <=0\n");
2119 if (pMgmt
->eCurrMode
== WMAC_MODE_ESS_AP
) {
2120 if (pDevice
->uAssocCount
== 0) {
2121 dev_kfree_skb_irq(skb
);
2122 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"device_dma0_xmit, assocCount = 0\n");
2127 pHeadTD
= pDevice
->apCurrTD
[TYPE_TXDMA0
];
2129 pHeadTD
->m_td1TD1
.byTCR
= (TCR_EDP
|TCR_STP
);
2131 memcpy(pDevice
->sTxEthHeader
.abyDstAddr
, (unsigned char *)(skb
->data
), ETH_HLEN
);
2132 cbFrameBodySize
= skb
->len
- ETH_HLEN
;
2135 if (ntohs(pDevice
->sTxEthHeader
.wType
) > ETH_DATA_LEN
) {
2136 cbFrameBodySize
+= 8;
2138 uMACfragNum
= cbGetFragCount(pDevice
, pTransmitKey
, cbFrameBodySize
, &pDevice
->sTxEthHeader
);
2140 if ( uMACfragNum
> AVAIL_TD(pDevice
, TYPE_TXDMA0
)) {
2141 dev_kfree_skb_irq(skb
);
2144 byPktType
= (unsigned char)pDevice
->byPacketType
;
2147 if (pDevice
->bFixRate
) {
2148 if (pDevice
->eCurrentPHYType
== PHY_TYPE_11B
) {
2149 if (pDevice
->uConnectionRate
>= RATE_11M
) {
2150 pDevice
->wCurrentRate
= RATE_11M
;
2152 pDevice
->wCurrentRate
= (unsigned short)pDevice
->uConnectionRate
;
2155 if (pDevice
->uConnectionRate
>= RATE_54M
)
2156 pDevice
->wCurrentRate
= RATE_54M
;
2158 pDevice
->wCurrentRate
= (unsigned short)pDevice
->uConnectionRate
;
2162 pDevice
->wCurrentRate
= pDevice
->pMgmt
->sNodeDBTable
[uNodeIndex
].wTxDataRate
;
2166 if (pMgmt
->sNodeDBTable
[uNodeIndex
].bShortPreamble
) {
2167 pDevice
->byPreambleType
= pDevice
->byShortPreamble
;
2170 pDevice
->byPreambleType
= PREAMBLE_LONG
;
2173 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"dma0: pDevice->wCurrentRate = %d \n", pDevice
->wCurrentRate
);
2176 if (pDevice
->wCurrentRate
<= RATE_11M
) {
2177 byPktType
= PK_TYPE_11B
;
2178 } else if (pDevice
->eCurrentPHYType
== PHY_TYPE_11A
) {
2179 byPktType
= PK_TYPE_11A
;
2181 if (pDevice
->bProtectMode
== true) {
2182 byPktType
= PK_TYPE_11GB
;
2184 byPktType
= PK_TYPE_11GA
;
2188 if (pDevice
->bEncryptionEnable
== true)
2189 bNeedEncryption
= true;
2191 if (pDevice
->bEnableHostWEP
) {
2192 pTransmitKey
= &STempKey
;
2193 pTransmitKey
->byCipherSuite
= pMgmt
->sNodeDBTable
[uNodeIndex
].byCipherSuite
;
2194 pTransmitKey
->dwKeyIndex
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwKeyIndex
;
2195 pTransmitKey
->uKeyLength
= pMgmt
->sNodeDBTable
[uNodeIndex
].uWepKeyLength
;
2196 pTransmitKey
->dwTSC47_16
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwTSC47_16
;
2197 pTransmitKey
->wTSC15_0
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTSC15_0
;
2198 memcpy(pTransmitKey
->abyKey
,
2199 &pMgmt
->sNodeDBTable
[uNodeIndex
].abyWepKey
[0],
2200 pTransmitKey
->uKeyLength
2203 vGenerateFIFOHeader(pDevice
, byPktType
, pDevice
->pbyTmpBuff
, bNeedEncryption
,
2204 cbFrameBodySize
, TYPE_TXDMA0
, pHeadTD
,
2205 &pDevice
->sTxEthHeader
, (unsigned char *)skb
->data
, pTransmitKey
, uNodeIndex
,
2210 if (MACbIsRegBitsOn(pDevice
->PortOffset
, MAC_REG_PSCTL
, PSCTL_PS
)) {
2212 MACbPSWakeup(pDevice
->PortOffset
);
2215 pDevice
->bPWBitOn
= false;
2218 for (ii
= 0; ii
< uMACfragNum
; ii
++) {
2219 // Poll Transmit the adapter
2221 pHeadTD
->m_td0TD0
.f1Owner
=OWNED_BY_NIC
;
2223 if (ii
== (uMACfragNum
- 1))
2225 pHeadTD
= pHeadTD
->next
;
2228 // Save the information needed by the tx interrupt handler
2229 // to complete the Send request
2230 pLastTD
->pTDInfo
->skb
= skb
;
2231 pLastTD
->pTDInfo
->byFlags
= 0;
2232 pLastTD
->pTDInfo
->byFlags
|= TD_FLAGS_NETIF_SKB
;
2234 pDevice
->apCurrTD
[TYPE_TXDMA0
] = pHeadTD
;
2236 MACvTransmit0(pDevice
->PortOffset
);
2242 //TYPE_AC0DMA data tx
2243 static int device_xmit(struct sk_buff
*skb
, struct net_device
*dev
) {
2244 PSDevice pDevice
=netdev_priv(dev
);
2246 PSMgmtObject pMgmt
= pDevice
->pMgmt
;
2247 PSTxDesc pHeadTD
, pLastTD
;
2248 unsigned int uNodeIndex
= 0;
2249 unsigned char byMask
[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
2250 unsigned short wAID
;
2251 unsigned int uMACfragNum
= 1;
2252 unsigned int cbFrameBodySize
;
2253 unsigned char byPktType
;
2254 unsigned int cbHeaderSize
;
2255 bool bNeedEncryption
= false;
2256 PSKeyItem pTransmitKey
= NULL
;
2259 bool bTKIP_UseGTK
= false;
2260 bool bNeedDeAuth
= false;
2261 unsigned char *pbyBSSID
;
2262 bool bNodeExist
= false;
2266 spin_lock_irq(&pDevice
->lock
);
2267 if (pDevice
->bLinkPass
== false) {
2268 dev_kfree_skb_irq(skb
);
2269 spin_unlock_irq(&pDevice
->lock
);
2273 if (pDevice
->bStopDataPkt
) {
2274 dev_kfree_skb_irq(skb
);
2275 spin_unlock_irq(&pDevice
->lock
);
2280 if (pMgmt
->eCurrMode
== WMAC_MODE_ESS_AP
) {
2281 if (pDevice
->uAssocCount
== 0) {
2282 dev_kfree_skb_irq(skb
);
2283 spin_unlock_irq(&pDevice
->lock
);
2286 if (is_multicast_ether_addr((unsigned char *)(skb
->data
))) {
2289 if (pMgmt
->sNodeDBTable
[0].bPSEnable
) {
2290 skb_queue_tail(&(pMgmt
->sNodeDBTable
[0].sTxPSQueue
), skb
);
2291 pMgmt
->sNodeDBTable
[0].wEnQueueCnt
++;
2293 pMgmt
->abyPSTxMap
[0] |= byMask
[0];
2294 spin_unlock_irq(&pDevice
->lock
);
2298 if (BSSDBbIsSTAInNodeDB(pMgmt
, (unsigned char *)(skb
->data
), &uNodeIndex
)) {
2299 if (pMgmt
->sNodeDBTable
[uNodeIndex
].bPSEnable
) {
2300 skb_queue_tail(&pMgmt
->sNodeDBTable
[uNodeIndex
].sTxPSQueue
, skb
);
2301 pMgmt
->sNodeDBTable
[uNodeIndex
].wEnQueueCnt
++;
2303 wAID
= pMgmt
->sNodeDBTable
[uNodeIndex
].wAID
;
2304 pMgmt
->abyPSTxMap
[wAID
>> 3] |= byMask
[wAID
& 7];
2305 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Set:pMgmt->abyPSTxMap[%d]= %d\n",
2306 (wAID
>> 3), pMgmt
->abyPSTxMap
[wAID
>> 3]);
2307 spin_unlock_irq(&pDevice
->lock
);
2311 if (pMgmt
->sNodeDBTable
[uNodeIndex
].bShortPreamble
) {
2312 pDevice
->byPreambleType
= pDevice
->byShortPreamble
;
2315 pDevice
->byPreambleType
= PREAMBLE_LONG
;
2322 if (bNodeExist
== false) {
2323 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Unknown STA not found in node DB \n");
2324 dev_kfree_skb_irq(skb
);
2325 spin_unlock_irq(&pDevice
->lock
);
2330 pHeadTD
= pDevice
->apCurrTD
[TYPE_AC0DMA
];
2332 pHeadTD
->m_td1TD1
.byTCR
= (TCR_EDP
|TCR_STP
);
2335 memcpy(pDevice
->sTxEthHeader
.abyDstAddr
, (unsigned char *)(skb
->data
), ETH_HLEN
);
2336 cbFrameBodySize
= skb
->len
- ETH_HLEN
;
2338 if (ntohs(pDevice
->sTxEthHeader
.wType
) > ETH_DATA_LEN
) {
2339 cbFrameBodySize
+= 8;
2343 if (pDevice
->bEncryptionEnable
== true) {
2344 bNeedEncryption
= true;
2347 if ((pDevice
->pMgmt
->eCurrMode
== WMAC_MODE_ESS_STA
) &&
2348 (pDevice
->pMgmt
->eCurrState
== WMAC_STATE_ASSOC
)) {
2349 pbyBSSID
= pDevice
->abyBSSID
;
2351 if (KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, PAIRWISE_KEY
, &pTransmitKey
) == false) {
2353 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, GROUP_KEY
, &pTransmitKey
) == true) {
2354 bTKIP_UseGTK
= true;
2355 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Get GTK.\n");
2359 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Get PTK.\n");
2362 }else if (pDevice
->pMgmt
->eCurrMode
== WMAC_MODE_IBSS_STA
) {
2364 pbyBSSID
= pDevice
->sTxEthHeader
.abyDstAddr
; //TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1
2365 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"IBSS Serach Key: \n");
2366 for (ii
= 0; ii
< 6; ii
++)
2367 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"%x \n", *(pbyBSSID
+ii
));
2368 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"\n");
2371 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, PAIRWISE_KEY
, &pTransmitKey
) == true)
2375 pbyBSSID
= pDevice
->abyBroadcastAddr
;
2376 if(KeybGetTransmitKey(&(pDevice
->sKey
), pbyBSSID
, GROUP_KEY
, &pTransmitKey
) == false) {
2377 pTransmitKey
= NULL
;
2378 if (pDevice
->pMgmt
->eCurrMode
== WMAC_MODE_IBSS_STA
) {
2379 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"IBSS and KEY is NULL. [%d]\n", pDevice
->pMgmt
->eCurrMode
);
2382 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"NOT IBSS and KEY is NULL. [%d]\n", pDevice
->pMgmt
->eCurrMode
);
2384 bTKIP_UseGTK
= true;
2385 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"Get GTK.\n");
2390 if (pDevice
->bEnableHostWEP
) {
2391 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_DEBUG
"acdma0: STA index %d\n", uNodeIndex
);
2392 if (pDevice
->bEncryptionEnable
== true) {
2393 pTransmitKey
= &STempKey
;
2394 pTransmitKey
->byCipherSuite
= pMgmt
->sNodeDBTable
[uNodeIndex
].byCipherSuite
;
2395 pTransmitKey
->dwKeyIndex
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwKeyIndex
;
2396 pTransmitKey
->uKeyLength
= pMgmt
->sNodeDBTable
[uNodeIndex
].uWepKeyLength
;
2397 pTransmitKey
->dwTSC47_16
= pMgmt
->sNodeDBTable
[uNodeIndex
].dwTSC47_16
;
2398 pTransmitKey
->wTSC15_0
= pMgmt
->sNodeDBTable
[uNodeIndex
].wTSC15_0
;
2399 memcpy(pTransmitKey
->abyKey
,
2400 &pMgmt
->sNodeDBTable
[uNodeIndex
].abyWepKey
[0],
2401 pTransmitKey
->uKeyLength
2406 uMACfragNum
= cbGetFragCount(pDevice
, pTransmitKey
, cbFrameBodySize
, &pDevice
->sTxEthHeader
);
2408 if (uMACfragNum
> AVAIL_TD(pDevice
, TYPE_AC0DMA
)) {
2409 DBG_PRT(MSG_LEVEL_ERR
, KERN_DEBUG
"uMACfragNum > AVAIL_TD(TYPE_AC0DMA) = %d\n", uMACfragNum
);
2410 dev_kfree_skb_irq(skb
);
2411 spin_unlock_irq(&pDevice
->lock
);
2415 if (pTransmitKey
!= NULL
) {
2416 if ((pTransmitKey
->byCipherSuite
== KEY_CTL_WEP
) &&
2417 (pTransmitKey
->uKeyLength
== WLAN_WEP232_KEYLEN
)) {
2418 uMACfragNum
= 1; //WEP256 doesn't support fragment
2422 byPktType
= (unsigned char)pDevice
->byPacketType
;
2424 if (pDevice
->bFixRate
) {
2426 printk("Fix Rate: PhyType is %d,ConnectionRate is %d\n",pDevice
->eCurrentPHYType
,pDevice
->uConnectionRate
);
2429 if (pDevice
->eCurrentPHYType
== PHY_TYPE_11B
) {
2430 if (pDevice
->uConnectionRate
>= RATE_11M
) {
2431 pDevice
->wCurrentRate
= RATE_11M
;
2433 pDevice
->wCurrentRate
= (unsigned short)pDevice
->uConnectionRate
;
2436 if ((pDevice
->eCurrentPHYType
== PHY_TYPE_11A
) &&
2437 (pDevice
->uConnectionRate
<= RATE_6M
)) {
2438 pDevice
->wCurrentRate
= RATE_6M
;
2440 if (pDevice
->uConnectionRate
>= RATE_54M
)
2441 pDevice
->wCurrentRate
= RATE_54M
;
2443 pDevice
->wCurrentRate
= (unsigned short)pDevice
->uConnectionRate
;
2447 pDevice
->byACKRate
= (unsigned char) pDevice
->wCurrentRate
;
2448 pDevice
->byTopCCKBasicRate
= RATE_1M
;
2449 pDevice
->byTopOFDMBasicRate
= RATE_6M
;
2453 if (pDevice
->sTxEthHeader
.wType
== TYPE_PKT_802_1x
) {
2454 if (pDevice
->eCurrentPHYType
!= PHY_TYPE_11A
) {
2455 pDevice
->wCurrentRate
= RATE_1M
;
2456 pDevice
->byACKRate
= RATE_1M
;
2457 pDevice
->byTopCCKBasicRate
= RATE_1M
;
2458 pDevice
->byTopOFDMBasicRate
= RATE_6M
;
2460 pDevice
->wCurrentRate
= RATE_6M
;
2461 pDevice
->byACKRate
= RATE_6M
;
2462 pDevice
->byTopCCKBasicRate
= RATE_1M
;
2463 pDevice
->byTopOFDMBasicRate
= RATE_6M
;
2467 VNTWIFIvGetTxRate( pDevice
->pMgmt
,
2468 pDevice
->sTxEthHeader
.abyDstAddr
,
2469 &(pDevice
->wCurrentRate
),
2470 &(pDevice
->byACKRate
),
2471 &(pDevice
->byTopCCKBasicRate
),
2472 &(pDevice
->byTopOFDMBasicRate
));
2478 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate);
2480 if (pDevice
->wCurrentRate
<= RATE_11M
) {
2481 byPktType
= PK_TYPE_11B
;
2482 } else if (pDevice
->eCurrentPHYType
== PHY_TYPE_11A
) {
2483 byPktType
= PK_TYPE_11A
;
2485 if (pDevice
->bProtectMode
== true) {
2486 byPktType
= PK_TYPE_11GB
;
2488 byPktType
= PK_TYPE_11GA
;
2492 //#ifdef PLICE_DEBUG
2493 // printk("FIX RATE:CurrentRate is %d");
2496 if (bNeedEncryption
== true) {
2497 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"ntohs Pkt Type=%04x\n", ntohs(pDevice
->sTxEthHeader
.wType
));
2498 if ((pDevice
->sTxEthHeader
.wType
) == TYPE_PKT_802_1x
) {
2499 bNeedEncryption
= false;
2500 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Pkt Type=%04x\n", (pDevice
->sTxEthHeader
.wType
));
2501 if ((pDevice
->pMgmt
->eCurrMode
== WMAC_MODE_ESS_STA
) && (pDevice
->pMgmt
->eCurrState
== WMAC_STATE_ASSOC
)) {
2502 if (pTransmitKey
== NULL
) {
2503 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Don't Find TX KEY\n");
2506 if (bTKIP_UseGTK
== true) {
2507 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"error: KEY is GTK!!~~\n");
2510 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Find PTK [%lX]\n", pTransmitKey
->dwKeyIndex
);
2511 bNeedEncryption
= true;
2516 if (pDevice
->byCntMeasure
== 2) {
2518 pDevice
->s802_11Counter
.TKIPCounterMeasuresInvoked
++;
2521 if (pDevice
->bEnableHostWEP
) {
2522 if ((uNodeIndex
!= 0) &&
2523 (pMgmt
->sNodeDBTable
[uNodeIndex
].dwKeyIndex
& PAIRWISE_KEY
)) {
2524 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Find PTK [%lX]\n", pTransmitKey
->dwKeyIndex
);
2525 bNeedEncryption
= true;
2530 if (pTransmitKey
== NULL
) {
2531 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"return no tx key\n");
2532 dev_kfree_skb_irq(skb
);
2533 spin_unlock_irq(&pDevice
->lock
);
2541 //if (skb->len == 98)
2543 // printk("ping:len is %d\n");
2546 vGenerateFIFOHeader(pDevice
, byPktType
, pDevice
->pbyTmpBuff
, bNeedEncryption
,
2547 cbFrameBodySize
, TYPE_AC0DMA
, pHeadTD
,
2548 &pDevice
->sTxEthHeader
, (unsigned char *)skb
->data
, pTransmitKey
, uNodeIndex
,
2553 if (MACbIsRegBitsOn(pDevice
->PortOffset
, MAC_REG_PSCTL
, PSCTL_PS
)) {
2555 MACbPSWakeup(pDevice
->PortOffset
);
2557 pDevice
->bPWBitOn
= false;
2560 for (ii
= 0; ii
< uMACfragNum
; ii
++) {
2561 // Poll Transmit the adapter
2563 pHeadTD
->m_td0TD0
.f1Owner
=OWNED_BY_NIC
;
2565 if (ii
== uMACfragNum
- 1)
2567 pHeadTD
= pHeadTD
->next
;
2570 // Save the information needed by the tx interrupt handler
2571 // to complete the Send request
2572 pLastTD
->pTDInfo
->skb
= skb
;
2573 pLastTD
->pTDInfo
->byFlags
= 0;
2574 pLastTD
->pTDInfo
->byFlags
|= TD_FLAGS_NETIF_SKB
;
2576 pDevice
->nTxDataTimeCout
=0; //2008-8-21 chester <add> for send null packet
2578 if (AVAIL_TD(pDevice
, TYPE_AC0DMA
) <= 1) {
2579 netif_stop_queue(dev
);
2582 pDevice
->apCurrTD
[TYPE_AC0DMA
] = pHeadTD
;
2583 //#ifdef PLICE_DEBUG
2584 if (pDevice
->bFixRate
)
2586 printk("FixRate:Rate is %d,TxPower is %d\n",pDevice
->wCurrentRate
,pDevice
->byCurPwr
);
2590 //printk("Auto Rate:Rate is %d,TxPower is %d\n",pDevice->wCurrentRate,pDevice->byCurPwr);
2595 unsigned char Protocol_Version
; //802.1x Authentication
2596 unsigned char Packet_Type
; //802.1x Authentication
2597 unsigned char Descriptor_type
;
2598 unsigned short Key_info
;
2599 bool bTxeapol_key
= false;
2600 Protocol_Version
= skb
->data
[ETH_HLEN
];
2601 Packet_Type
= skb
->data
[ETH_HLEN
+1];
2602 Descriptor_type
= skb
->data
[ETH_HLEN
+1+1+2];
2603 Key_info
= (skb
->data
[ETH_HLEN
+1+1+2+1] << 8)|(skb
->data
[ETH_HLEN
+1+1+2+2]);
2604 if (pDevice
->sTxEthHeader
.wType
== TYPE_PKT_802_1x
) {
2605 if(((Protocol_Version
==1) ||(Protocol_Version
==2)) &&
2606 (Packet_Type
==3)) { //802.1x OR eapol-key challenge frame transfer
2607 bTxeapol_key
= true;
2608 if((Descriptor_type
==254)||(Descriptor_type
==2)) { //WPA or RSN
2609 if(!(Key_info
& BIT3
) && //group-key challenge
2610 (Key_info
& BIT8
) && (Key_info
& BIT9
)) { //send 2/2 key
2611 pDevice
->fWPA_Authened
= true;
2612 if(Descriptor_type
==254)
2616 printk("Authentication completed!!\n");
2623 MACvTransmitAC0(pDevice
->PortOffset
);
2624 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0:pDevice->apCurrTD= %p\n", pHeadTD);
2626 dev
->trans_start
= jiffies
;
2628 spin_unlock_irq(&pDevice
->lock
);
2633 static irqreturn_t
device_intr(int irq
, void *dev_instance
) {
2634 struct net_device
* dev
=dev_instance
;
2635 PSDevice pDevice
=(PSDevice
) netdev_priv(dev
);
2638 unsigned long dwMIBCounter
=0;
2639 PSMgmtObject pMgmt
= pDevice
->pMgmt
;
2640 unsigned char byOrgPageSel
=0;
2642 unsigned char byData
= 0;
2644 // unsigned char byRSSI;
2647 MACvReadISR(pDevice
->PortOffset
, &pDevice
->dwIsr
);
2649 if (pDevice
->dwIsr
== 0)
2650 return IRQ_RETVAL(handled
);
2652 if (pDevice
->dwIsr
== 0xffffffff) {
2653 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"dwIsr = 0xffff\n");
2654 return IRQ_RETVAL(handled
);
2657 // 2008-05-21 <mark> by Richardtai, we can't read RSSI here, because no packet bound with RSSI
2659 if ((pDevice->dwIsr & ISR_RXDMA0) &&
2660 (pDevice->byLocalID != REV_ID_VT3253_B0) &&
2661 (pDevice->bBSSIDFilter == true)) {
2663 //BBbReadEmbeded(pDevice->PortOffset, 0x3E, &byRSSI);
2664 //pDevice->uCurrRSSI = byRSSI;
2669 MACvIntDisable(pDevice
->PortOffset
);
2670 spin_lock_irq(&pDevice
->lock
);
2672 //Make sure current page is 0
2673 VNSvInPortB(pDevice
->PortOffset
+ MAC_REG_PAGE1SEL
, &byOrgPageSel
);
2674 if (byOrgPageSel
== 1) {
2675 MACvSelectPage0(pDevice
->PortOffset
);
2680 MACvReadMIBCounter(pDevice
->PortOffset
, &dwMIBCounter
);
2682 // Must do this after doing rx/tx, cause ISR bit is slow
2683 // than RD/TD write back
2684 // update ISR counter
2685 STAvUpdate802_11Counter(&pDevice
->s802_11Counter
, &pDevice
->scStatistic
, dwMIBCounter
);
2686 while (pDevice
->dwIsr
!= 0) {
2688 STAvUpdateIsrStatCounter(&pDevice
->scStatistic
, pDevice
->dwIsr
);
2689 MACvWriteISR(pDevice
->PortOffset
, pDevice
->dwIsr
);
2691 if (pDevice
->dwIsr
& ISR_FETALERR
){
2692 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" ISR_FETALERR \n");
2693 VNSvOutPortB(pDevice
->PortOffset
+ MAC_REG_SOFTPWRCTL
, 0);
2694 VNSvOutPortW(pDevice
->PortOffset
+ MAC_REG_SOFTPWRCTL
, SOFTPWRCTL_SWPECTI
);
2695 device_error(pDevice
, pDevice
->dwIsr
);
2698 if (pDevice
->byLocalID
> REV_ID_VT3253_B1
) {
2700 if (pDevice
->dwIsr
& ISR_MEASURESTART
) {
2701 // 802.11h measure start
2702 pDevice
->byOrgChannel
= pDevice
->byCurrentCh
;
2703 VNSvInPortB(pDevice
->PortOffset
+ MAC_REG_RCR
, &(pDevice
->byOrgRCR
));
2704 VNSvOutPortB(pDevice
->PortOffset
+ MAC_REG_RCR
, (RCR_RXALLTYPE
| RCR_UNICAST
| RCR_BROADCAST
| RCR_MULTICAST
| RCR_WPAERR
));
2705 MACvSelectPage1(pDevice
->PortOffset
);
2706 VNSvInPortD(pDevice
->PortOffset
+ MAC_REG_MAR0
, &(pDevice
->dwOrgMAR0
));
2707 VNSvInPortD(pDevice
->PortOffset
+ MAC_REG_MAR4
, &(pDevice
->dwOrgMAR4
));
2708 MACvSelectPage0(pDevice
->PortOffset
);
2710 // WCMDbFlushCommandQueue(pDevice->pMgmt, true);
2711 if (set_channel(pDevice
, pDevice
->pCurrMeasureEID
->sReq
.byChannel
) == true) {
2712 pDevice
->bMeasureInProgress
= true;
2713 MACvSelectPage1(pDevice
->PortOffset
);
2714 MACvRegBitsOn(pDevice
->PortOffset
, MAC_REG_MSRCTL
, MSRCTL_READY
);
2715 MACvSelectPage0(pDevice
->PortOffset
);
2716 pDevice
->byBasicMap
= 0;
2717 pDevice
->byCCAFraction
= 0;
2718 for(ii
=0;ii
<8;ii
++) {
2719 pDevice
->dwRPIs
[ii
] = 0;
2722 // can not measure because set channel fail
2723 // WCMDbResetCommandQueue(pDevice->pMgmt);
2724 // clear measure control
2725 MACvRegBitsOff(pDevice
->PortOffset
, MAC_REG_MSRCTL
, MSRCTL_EN
);
2726 s_vCompleteCurrentMeasure(pDevice
, MEASURE_MODE_INCAPABLE
);
2727 MACvSelectPage1(pDevice
->PortOffset
);
2728 MACvRegBitsOn(pDevice
->PortOffset
, MAC_REG_MSRCTL
+1, MSRCTL1_TXPAUSE
);
2729 MACvSelectPage0(pDevice
->PortOffset
);
2732 if (pDevice
->dwIsr
& ISR_MEASUREEND
) {
2733 // 802.11h measure end
2734 pDevice
->bMeasureInProgress
= false;
2735 VNSvOutPortB(pDevice
->PortOffset
+ MAC_REG_RCR
, pDevice
->byOrgRCR
);
2736 MACvSelectPage1(pDevice
->PortOffset
);
2737 VNSvOutPortD(pDevice
->PortOffset
+ MAC_REG_MAR0
, pDevice
->dwOrgMAR0
);
2738 VNSvOutPortD(pDevice
->PortOffset
+ MAC_REG_MAR4
, pDevice
->dwOrgMAR4
);
2739 VNSvInPortB(pDevice
->PortOffset
+ MAC_REG_MSRBBSTS
, &byData
);
2740 pDevice
->byBasicMap
|= (byData
>> 4);
2741 VNSvInPortB(pDevice
->PortOffset
+ MAC_REG_CCAFRACTION
, &pDevice
->byCCAFraction
);
2742 VNSvInPortB(pDevice
->PortOffset
+ MAC_REG_MSRCTL
, &byData
);
2743 // clear measure control
2744 MACvRegBitsOff(pDevice
->PortOffset
, MAC_REG_MSRCTL
, MSRCTL_EN
);
2745 MACvSelectPage0(pDevice
->PortOffset
);
2746 set_channel(pDevice
, pDevice
->byOrgChannel
);
2747 // WCMDbResetCommandQueue(pDevice->pMgmt);
2748 MACvSelectPage1(pDevice
->PortOffset
);
2749 MACvRegBitsOn(pDevice
->PortOffset
, MAC_REG_MSRCTL
+1, MSRCTL1_TXPAUSE
);
2750 MACvSelectPage0(pDevice
->PortOffset
);
2751 if (byData
& MSRCTL_FINISH
) {
2753 s_vCompleteCurrentMeasure(pDevice
, 0);
2755 // can not measure because not ready before end of measure time
2756 s_vCompleteCurrentMeasure(pDevice
, MEASURE_MODE_LATE
);
2759 if (pDevice
->dwIsr
& ISR_QUIETSTART
) {
2762 } while (CARDbStartQuiet(pDevice
) == false);
2766 if (pDevice
->dwIsr
& ISR_TBTT
) {
2767 if (pDevice
->bEnableFirstQuiet
== true) {
2768 pDevice
->byQuietStartCount
--;
2769 if (pDevice
->byQuietStartCount
== 0) {
2770 pDevice
->bEnableFirstQuiet
= false;
2771 MACvSelectPage1(pDevice
->PortOffset
);
2772 MACvRegBitsOn(pDevice
->PortOffset
, MAC_REG_MSRCTL
, (MSRCTL_QUIETTXCHK
| MSRCTL_QUIETEN
));
2773 MACvSelectPage0(pDevice
->PortOffset
);
2776 if ((pDevice
->bChannelSwitch
== true) &&
2777 (pDevice
->eOPMode
== OP_MODE_INFRASTRUCTURE
)) {
2778 pDevice
->byChannelSwitchCount
--;
2779 if (pDevice
->byChannelSwitchCount
== 0) {
2780 pDevice
->bChannelSwitch
= false;
2781 set_channel(pDevice
, pDevice
->byNewChannel
);
2782 VNTWIFIbChannelSwitch(pDevice
->pMgmt
, pDevice
->byNewChannel
);
2783 MACvSelectPage1(pDevice
->PortOffset
);
2784 MACvRegBitsOn(pDevice
->PortOffset
, MAC_REG_MSRCTL
+1, MSRCTL1_TXPAUSE
);
2785 MACvSelectPage0(pDevice
->PortOffset
);
2786 CARDbStartTxPacket(pDevice
, PKT_TYPE_802_11_ALL
);
2790 if (pDevice
->eOPMode
== OP_MODE_ADHOC
) {
2791 //pDevice->bBeaconSent = false;
2793 if ((pDevice
->bUpdateBBVGA
) && (pDevice
->bLinkPass
== true) && (pDevice
->uCurrRSSI
!= 0)) {
2796 RFvRSSITodBm(pDevice
, (unsigned char) pDevice
->uCurrRSSI
, &ldBm
);
2797 for (ii
=0;ii
<BB_VGA_LEVEL
;ii
++) {
2798 if (ldBm
< pDevice
->ldBmThreshold
[ii
]) {
2799 pDevice
->byBBVGANew
= pDevice
->abyBBVGA
[ii
];
2803 if (pDevice
->byBBVGANew
!= pDevice
->byBBVGACurrent
) {
2804 pDevice
->uBBVGADiffCount
++;
2805 if (pDevice
->uBBVGADiffCount
== 1) {
2806 // first VGA diff gain
2807 BBvSetVGAGainOffset(pDevice
, pDevice
->byBBVGANew
);
2808 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"First RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
2809 (int)ldBm
, pDevice
->byBBVGANew
, pDevice
->byBBVGACurrent
, (int)pDevice
->uBBVGADiffCount
);
2811 if (pDevice
->uBBVGADiffCount
>= BB_VGA_CHANGE_THRESHOLD
) {
2812 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
2813 (int)ldBm
, pDevice
->byBBVGANew
, pDevice
->byBBVGACurrent
, (int)pDevice
->uBBVGADiffCount
);
2814 BBvSetVGAGainOffset(pDevice
, pDevice
->byBBVGANew
);
2817 pDevice
->uBBVGADiffCount
= 1;
2822 pDevice
->bBeaconSent
= false;
2823 if (pDevice
->bEnablePSMode
) {
2824 PSbIsNextTBTTWakeUp((void *)pDevice
);
2827 if ((pDevice
->eOPMode
== OP_MODE_AP
) ||
2828 (pDevice
->eOPMode
== OP_MODE_ADHOC
)) {
2830 MACvOneShotTimer1MicroSec(pDevice
->PortOffset
,
2831 (pMgmt
->wIBSSBeaconPeriod
- MAKE_BEACON_RESERVED
) << 10);
2834 if (pDevice
->eOPMode
== OP_MODE_ADHOC
&& pDevice
->pMgmt
->wCurrATIMWindow
> 0) {
2835 // todo adhoc PS mode
2840 if (pDevice
->dwIsr
& ISR_BNTX
) {
2842 if (pDevice
->eOPMode
== OP_MODE_ADHOC
) {
2843 pDevice
->bIsBeaconBufReadySet
= false;
2844 pDevice
->cbBeaconBufReadySetCnt
= 0;
2847 if (pDevice
->eOPMode
== OP_MODE_AP
) {
2848 if(pMgmt
->byDTIMCount
> 0) {
2849 pMgmt
->byDTIMCount
--;
2850 pMgmt
->sNodeDBTable
[0].bRxPSPoll
= false;
2853 if(pMgmt
->byDTIMCount
== 0) {
2854 // check if mutltcast tx bufferring
2855 pMgmt
->byDTIMCount
= pMgmt
->byDTIMPeriod
- 1;
2856 pMgmt
->sNodeDBTable
[0].bRxPSPoll
= true;
2857 bScheduleCommand((void *)pDevice
, WLAN_CMD_RX_PSPOLL
, NULL
);
2861 pDevice
->bBeaconSent
= true;
2863 if (pDevice
->bChannelSwitch
== true) {
2864 pDevice
->byChannelSwitchCount
--;
2865 if (pDevice
->byChannelSwitchCount
== 0) {
2866 pDevice
->bChannelSwitch
= false;
2867 set_channel(pDevice
, pDevice
->byNewChannel
);
2868 VNTWIFIbChannelSwitch(pDevice
->pMgmt
, pDevice
->byNewChannel
);
2869 MACvSelectPage1(pDevice
->PortOffset
);
2870 MACvRegBitsOn(pDevice
->PortOffset
, MAC_REG_MSRCTL
+1, MSRCTL1_TXPAUSE
);
2871 MACvSelectPage0(pDevice
->PortOffset
);
2872 //VNTWIFIbSendBeacon(pDevice->pMgmt);
2873 CARDbStartTxPacket(pDevice
, PKT_TYPE_802_11_ALL
);
2879 if (pDevice
->dwIsr
& ISR_RXDMA0
) {
2880 max_count
+= device_rx_srv(pDevice
, TYPE_RXDMA0
);
2882 if (pDevice
->dwIsr
& ISR_RXDMA1
) {
2883 max_count
+= device_rx_srv(pDevice
, TYPE_RXDMA1
);
2885 if (pDevice
->dwIsr
& ISR_TXDMA0
){
2886 max_count
+= device_tx_srv(pDevice
, TYPE_TXDMA0
);
2888 if (pDevice
->dwIsr
& ISR_AC0DMA
){
2889 max_count
+= device_tx_srv(pDevice
, TYPE_AC0DMA
);
2891 if (pDevice
->dwIsr
& ISR_SOFTTIMER
) {
2894 if (pDevice
->dwIsr
& ISR_SOFTTIMER1
) {
2895 if (pDevice
->eOPMode
== OP_MODE_AP
) {
2896 if (pDevice
->bShortSlotTime
)
2897 pMgmt
->wCurrCapInfo
|= WLAN_SET_CAP_INFO_SHORTSLOTTIME(1);
2899 pMgmt
->wCurrCapInfo
&= ~(WLAN_SET_CAP_INFO_SHORTSLOTTIME(1));
2901 bMgrPrepareBeaconToSend(pDevice
, pMgmt
);
2902 pDevice
->byCntMeasure
= 0;
2905 MACvReadISR(pDevice
->PortOffset
, &pDevice
->dwIsr
);
2907 MACvReceive0(pDevice
->PortOffset
);
2908 MACvReceive1(pDevice
->PortOffset
);
2910 if (max_count
>pDevice
->sOpts
.int_works
)
2914 if (byOrgPageSel
== 1) {
2915 MACvSelectPage1(pDevice
->PortOffset
);
2918 spin_unlock_irq(&pDevice
->lock
);
2919 MACvIntEnable(pDevice
->PortOffset
, IMR_MASK_VALUE
);
2921 return IRQ_RETVAL(handled
);
2925 static unsigned const ethernet_polynomial
= 0x04c11db7U
;
2926 static inline u32
ether_crc(int length
, unsigned char *data
)
2930 while(--length
>= 0) {
2931 unsigned char current_octet
= *data
++;
2933 for (bit
= 0; bit
< 8; bit
++, current_octet
>>= 1) {
2935 ((crc
< 0) ^ (current_octet
& 1) ? ethernet_polynomial
: 0);
2941 //2008-8-4 <add> by chester
2942 static int Config_FileGetParameter(unsigned char *string
,
2943 unsigned char *dest
, unsigned char *source
)
2945 unsigned char buf1
[100];
2946 int source_len
= strlen(source
);
2949 strcat(buf1
, string
);
2951 source
+=strlen(buf1
);
2953 memcpy(dest
,source
,source_len
-strlen(buf1
));
2957 int Config_FileOperation(PSDevice pDevice
,bool fwrite
,unsigned char *Parameter
) {
2958 unsigned char *config_path
= CONFIG_PATH
;
2959 unsigned char *buffer
= NULL
;
2960 unsigned char tmpbuffer
[20];
2961 struct file
*filp
=NULL
;
2962 mm_segment_t old_fs
= get_fs();
2963 //int oldfsuid=0,oldfsgid=0;
2968 /* Can't do this anymore, so we rely on correct filesystem permissions:
2969 //Make sure a caller can read or write power as root
2970 oldfsuid=current->cred->fsuid;
2971 oldfsgid=current->cred->fsgid;
2972 current->cred->fsuid = 0;
2973 current->cred->fsgid = 0;
2977 filp
= filp_open(config_path
, O_RDWR
, 0);
2979 printk("Config_FileOperation:open file fail?\n");
2984 if(!(filp
->f_op
) || !(filp
->f_op
->read
) ||!(filp
->f_op
->write
)) {
2985 printk("file %s cann't readable or writable?\n",config_path
);
2990 buffer
= kmalloc(1024, GFP_KERNEL
);
2992 printk("allocate mem for file fail?\n");
2997 if(filp
->f_op
->read(filp
, buffer
, 1024, &filp
->f_pos
)<0) {
2998 printk("read file error?\n");
3003 if(Config_FileGetParameter("ZONETYPE",tmpbuffer
,buffer
)!=true) {
3004 printk("get parameter error?\n");
3009 if(memcmp(tmpbuffer
,"USA",3)==0) {
3010 result
=ZoneType_USA
;
3012 else if(memcmp(tmpbuffer
,"JAPAN",5)==0) {
3013 result
=ZoneType_Japan
;
3015 else if(memcmp(tmpbuffer
,"EUROPE",5)==0) {
3016 result
=ZoneType_Europe
;
3020 printk("Unknown Zonetype[%s]?\n",tmpbuffer
);
3026 if(filp_close(filp
,NULL
))
3027 printk("Config_FileOperation:close file fail\n");
3033 current->cred->fsuid=oldfsuid;
3034 current->cred->fsgid=oldfsgid;
3042 static void device_set_multi(struct net_device
*dev
) {
3043 PSDevice pDevice
= (PSDevice
) netdev_priv(dev
);
3045 PSMgmtObject pMgmt
= pDevice
->pMgmt
;
3047 struct netdev_hw_addr
*ha
;
3050 VNSvInPortB(pDevice
->PortOffset
+ MAC_REG_RCR
, &(pDevice
->byRxMode
));
3052 if (dev
->flags
& IFF_PROMISC
) { /* Set promiscuous. */
3053 DBG_PRT(MSG_LEVEL_ERR
,KERN_NOTICE
"%s: Promiscuous mode enabled.\n", dev
->name
);
3054 /* Unconditionally log net taps. */
3055 pDevice
->byRxMode
|= (RCR_MULTICAST
|RCR_BROADCAST
|RCR_UNICAST
);
3057 else if ((netdev_mc_count(dev
) > pDevice
->multicast_limit
)
3058 || (dev
->flags
& IFF_ALLMULTI
)) {
3059 MACvSelectPage1(pDevice
->PortOffset
);
3060 VNSvOutPortD(pDevice
->PortOffset
+ MAC_REG_MAR0
, 0xffffffff);
3061 VNSvOutPortD(pDevice
->PortOffset
+ MAC_REG_MAR0
+ 4, 0xffffffff);
3062 MACvSelectPage0(pDevice
->PortOffset
);
3063 pDevice
->byRxMode
|= (RCR_MULTICAST
|RCR_BROADCAST
);
3066 memset(mc_filter
, 0, sizeof(mc_filter
));
3067 netdev_for_each_mc_addr(ha
, dev
) {
3068 int bit_nr
= ether_crc(ETH_ALEN
, ha
->addr
) >> 26;
3069 mc_filter
[bit_nr
>> 5] |= cpu_to_le32(1 << (bit_nr
& 31));
3071 MACvSelectPage1(pDevice
->PortOffset
);
3072 VNSvOutPortD(pDevice
->PortOffset
+ MAC_REG_MAR0
, mc_filter
[0]);
3073 VNSvOutPortD(pDevice
->PortOffset
+ MAC_REG_MAR0
+ 4, mc_filter
[1]);
3074 MACvSelectPage0(pDevice
->PortOffset
);
3075 pDevice
->byRxMode
&= ~(RCR_UNICAST
);
3076 pDevice
->byRxMode
|= (RCR_MULTICAST
|RCR_BROADCAST
);
3079 if (pMgmt
->eConfigMode
== WMAC_CONFIG_AP
) {
3080 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
3081 pDevice
->byRxMode
|= (RCR_MULTICAST
|RCR_BROADCAST
);
3082 pDevice
->byRxMode
&= ~(RCR_UNICAST
);
3085 VNSvOutPortB(pDevice
->PortOffset
+ MAC_REG_RCR
, pDevice
->byRxMode
);
3086 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"pDevice->byRxMode = %x\n", pDevice
->byRxMode
);
3090 static struct net_device_stats
*device_get_stats(struct net_device
*dev
) {
3091 PSDevice pDevice
=(PSDevice
) netdev_priv(dev
);
3093 return &pDevice
->stats
;
3098 static int device_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
) {
3099 PSDevice pDevice
= (PSDevice
)netdev_priv(dev
);
3101 struct iwreq
*wrq
= (struct iwreq
*) rq
;
3103 PSMgmtObject pMgmt
= pDevice
->pMgmt
;
3107 if (pMgmt
== NULL
) {
3115 rc
= iwctl_giwname(dev
, NULL
, (char *)&(wrq
->u
.name
), NULL
);
3118 case SIOCGIWNWID
: //0x8b03 support
3122 // Set frequency/channel
3124 rc
= iwctl_siwfreq(dev
, NULL
, &(wrq
->u
.freq
), NULL
);
3127 // Get frequency/channel
3129 rc
= iwctl_giwfreq(dev
, NULL
, &(wrq
->u
.freq
), NULL
);
3132 // Set desired network name (ESSID)
3136 char essid
[IW_ESSID_MAX_SIZE
+1];
3137 if (wrq
->u
.essid
.length
> IW_ESSID_MAX_SIZE
) {
3141 if (copy_from_user(essid
, wrq
->u
.essid
.pointer
,
3142 wrq
->u
.essid
.length
)) {
3146 rc
= iwctl_siwessid(dev
, NULL
,
3147 &(wrq
->u
.essid
), essid
);
3152 // Get current network name (ESSID)
3156 char essid
[IW_ESSID_MAX_SIZE
+1];
3157 if (wrq
->u
.essid
.pointer
)
3158 rc
= iwctl_giwessid(dev
, NULL
,
3159 &(wrq
->u
.essid
), essid
);
3160 if (copy_to_user(wrq
->u
.essid
.pointer
,
3162 wrq
->u
.essid
.length
) )
3169 rc
= iwctl_siwap(dev
, NULL
, &(wrq
->u
.ap_addr
), NULL
);
3173 // Get current Access Point (BSSID)
3175 rc
= iwctl_giwap(dev
, NULL
, &(wrq
->u
.ap_addr
), NULL
);
3179 // Set desired station name
3181 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCSIWNICKN \n");
3185 // Get current station name
3187 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCGIWNICKN \n");
3191 // Set the desired bit-rate
3193 rc
= iwctl_siwrate(dev
, NULL
, &(wrq
->u
.bitrate
), NULL
);
3196 // Get the current bit-rate
3199 rc
= iwctl_giwrate(dev
, NULL
, &(wrq
->u
.bitrate
), NULL
);
3202 // Set the desired RTS threshold
3205 rc
= iwctl_siwrts(dev
, NULL
, &(wrq
->u
.rts
), NULL
);
3208 // Get the current RTS threshold
3211 rc
= iwctl_giwrts(dev
, NULL
, &(wrq
->u
.rts
), NULL
);
3214 // Set the desired fragmentation threshold
3217 rc
= iwctl_siwfrag(dev
, NULL
, &(wrq
->u
.frag
), NULL
);
3220 // Get the current fragmentation threshold
3223 rc
= iwctl_giwfrag(dev
, NULL
, &(wrq
->u
.frag
), NULL
);
3226 // Set mode of operation
3228 rc
= iwctl_siwmode(dev
, NULL
, &(wrq
->u
.mode
), NULL
);
3231 // Get mode of operation
3233 rc
= iwctl_giwmode(dev
, NULL
, &(wrq
->u
.mode
), NULL
);
3236 // Set WEP keys and mode
3239 char abyKey
[WLAN_WEP232_KEYLEN
];
3241 if (wrq
->u
.encoding
.pointer
) {
3244 if (wrq
->u
.encoding
.length
> WLAN_WEP232_KEYLEN
) {
3248 memset(abyKey
, 0, WLAN_WEP232_KEYLEN
);
3249 if (copy_from_user(abyKey
,
3250 wrq
->u
.encoding
.pointer
,
3251 wrq
->u
.encoding
.length
)) {
3255 } else if (wrq
->u
.encoding
.length
!= 0) {
3259 rc
= iwctl_siwencode(dev
, NULL
, &(wrq
->u
.encoding
), abyKey
);
3263 // Get the WEP keys and mode
3266 if (!capable(CAP_NET_ADMIN
)) {
3271 char abyKey
[WLAN_WEP232_KEYLEN
];
3273 rc
= iwctl_giwencode(dev
, NULL
, &(wrq
->u
.encoding
), abyKey
);
3275 if (wrq
->u
.encoding
.pointer
) {
3276 if (copy_to_user(wrq
->u
.encoding
.pointer
,
3278 wrq
->u
.encoding
.length
))
3284 // Get the current Tx-Power
3286 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCGIWTXPOW \n");
3291 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCSIWTXPOW \n");
3297 rc
= iwctl_siwretry(dev
, NULL
, &(wrq
->u
.retry
), NULL
);
3302 rc
= iwctl_giwretry(dev
, NULL
, &(wrq
->u
.retry
), NULL
);
3305 // Get range of parameters
3309 struct iw_range range
;
3311 rc
= iwctl_giwrange(dev
, NULL
, &(wrq
->u
.data
), (char *) &range
);
3312 if (copy_to_user(wrq
->u
.data
.pointer
, &range
, sizeof(struct iw_range
)))
3320 rc
= iwctl_giwpower(dev
, NULL
, &(wrq
->u
.power
), NULL
);
3326 rc
= iwctl_siwpower(dev
, NULL
, &(wrq
->u
.power
), NULL
);
3332 rc
= iwctl_giwsens(dev
, NULL
, &(wrq
->u
.sens
), NULL
);
3336 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCSIWSENS \n");
3342 char buffer
[IW_MAX_AP
* (sizeof(struct sockaddr
) + sizeof(struct iw_quality
))];
3344 if (wrq
->u
.data
.pointer
) {
3345 rc
= iwctl_giwaplist(dev
, NULL
, &(wrq
->u
.data
), buffer
);
3347 if (copy_to_user(wrq
->u
.data
.pointer
,
3349 (wrq
->u
.data
.length
* (sizeof(struct sockaddr
) + sizeof(struct iw_quality
)))
3362 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCSIWSPY \n");
3369 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCGIWSPY \n");
3373 #endif // WIRELESS_SPY
3376 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCGIWPRIV \n");
3379 if(wrq->u.data.pointer) {
3380 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
3382 if(copy_to_user(wrq->u.data.pointer,
3383 (u_char *) iwctl_private_args,
3384 sizeof(iwctl_private_args)))
3391 //2008-0409-07, <Add> by Einsn Liu
3392 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3394 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCSIWAUTH \n");
3395 rc
= iwctl_siwauth(dev
, NULL
, &(wrq
->u
.param
), NULL
);
3399 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCGIWAUTH \n");
3400 rc
= iwctl_giwauth(dev
, NULL
, &(wrq
->u
.param
), NULL
);
3404 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCSIWGENIE \n");
3405 rc
= iwctl_siwgenie(dev
, NULL
, &(wrq
->u
.data
), wrq
->u
.data
.pointer
);
3409 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCGIWGENIE \n");
3410 rc
= iwctl_giwgenie(dev
, NULL
, &(wrq
->u
.data
), wrq
->u
.data
.pointer
);
3413 case SIOCSIWENCODEEXT
:
3415 char extra
[sizeof(struct iw_encode_ext
)+MAX_KEY_LEN
+1];
3416 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCSIWENCODEEXT \n");
3417 if(wrq
->u
.encoding
.pointer
){
3418 memset(extra
, 0, sizeof(struct iw_encode_ext
)+MAX_KEY_LEN
+1);
3419 if(wrq
->u
.encoding
.length
> (sizeof(struct iw_encode_ext
)+ MAX_KEY_LEN
)){
3423 if(copy_from_user(extra
, wrq
->u
.encoding
.pointer
,wrq
->u
.encoding
.length
)){
3427 }else if(wrq
->u
.encoding
.length
!= 0){
3431 rc
= iwctl_siwencodeext(dev
, NULL
, &(wrq
->u
.encoding
), extra
);
3435 case SIOCGIWENCODEEXT
:
3436 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCGIWENCODEEXT \n");
3437 rc
= iwctl_giwencodeext(dev
, NULL
, &(wrq
->u
.encoding
), NULL
);
3441 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCSIWMLME \n");
3442 rc
= iwctl_siwmlme(dev
, NULL
, &(wrq
->u
.data
), wrq
->u
.data
.pointer
);
3445 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3446 //End Add -- //2008-0409-07, <Add> by Einsn Liu
3448 case IOCTL_CMD_TEST
:
3450 if (!(pDevice
->flags
& DEVICE_FLAGS_OPENED
)) {
3456 pReq
= (PSCmdRequest
)rq
;
3457 pReq
->wResult
= MAGIC_CODE
;
3463 if((((PSCmdRequest
)rq
)->wCmdCode
!=WLAN_CMD_SET_EVT
) &&
3464 !(pDevice
->flags
& DEVICE_FLAGS_OPENED
))
3466 if (!(pDevice
->flags
& DEVICE_FLAGS_OPENED
) &&
3467 (((PSCmdRequest
)rq
)->wCmdCode
!=WLAN_CMD_SET_WPA
))
3476 if (test_and_set_bit( 0, (void*)&(pMgmt
->uCmdBusy
))) {
3479 rc
= private_ioctl(pDevice
, rq
);
3480 clear_bit( 0, (void*)&(pMgmt
->uCmdBusy
));
3483 case IOCTL_CMD_HOSTAPD
:
3486 rc
= vt6655_hostap_ioctl(pDevice
, &wrq
->u
.data
);
3491 rc
= wpa_ioctl(pDevice
, &wrq
->u
.data
);
3495 return ethtool_ioctl(dev
, (void *) rq
->ifr_data
);
3496 // All other calls are currently unsupported
3500 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Ioctl command not support..%x\n", cmd
);
3505 if (pDevice
->bCommit
) {
3506 if (pMgmt
->eConfigMode
== WMAC_CONFIG_AP
) {
3507 netif_stop_queue(pDevice
->dev
);
3508 spin_lock_irq(&pDevice
->lock
);
3509 bScheduleCommand((void *)pDevice
, WLAN_CMD_RUN_AP
, NULL
);
3510 spin_unlock_irq(&pDevice
->lock
);
3513 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Commit the settings\n");
3514 spin_lock_irq(&pDevice
->lock
);
3515 pDevice
->bLinkPass
= false;
3516 memset(pMgmt
->abyCurrBSSID
, 0, 6);
3517 pMgmt
->eCurrState
= WMAC_STATE_IDLE
;
3518 netif_stop_queue(pDevice
->dev
);
3519 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3520 pMgmt
->eScanType
= WMAC_SCAN_ACTIVE
;
3521 if(pDevice
->bWPASuppWextEnabled
!=true)
3523 bScheduleCommand((void *) pDevice
, WLAN_CMD_BSSID_SCAN
, pMgmt
->abyDesireSSID
);
3524 bScheduleCommand((void *) pDevice
, WLAN_CMD_SSID
, NULL
);
3525 spin_unlock_irq(&pDevice
->lock
);
3527 pDevice
->bCommit
= false;
3534 static int ethtool_ioctl(struct net_device
*dev
, void *useraddr
)
3538 if (copy_from_user(ðcmd
, useraddr
, sizeof(ethcmd
)))
3542 case ETHTOOL_GDRVINFO
: {
3543 struct ethtool_drvinfo info
= {ETHTOOL_GDRVINFO
};
3544 strncpy(info
.driver
, DEVICE_NAME
, sizeof(info
.driver
)-1);
3545 strncpy(info
.version
, DEVICE_VERSION
, sizeof(info
.version
)-1);
3546 if (copy_to_user(useraddr
, &info
, sizeof(info
)))
3556 /*------------------------------------------------------------------*/
3558 MODULE_DEVICE_TABLE(pci
, vt6655_pci_id_table
);
3560 static struct pci_driver device_driver
= {
3561 .name
= DEVICE_NAME
,
3562 .id_table
= vt6655_pci_id_table
,
3563 .probe
= vt6655_probe
,
3564 .remove
= vt6655_remove
,
3566 .suspend
= viawget_suspend
,
3567 .resume
= viawget_resume
,
3571 static int __init
vt6655_init_module(void)
3576 // ret=pci_module_init(&device_driver);
3577 //ret = pcie_port_service_register(&device_driver);
3578 ret
= pci_register_driver(&device_driver
);
3581 register_reboot_notifier(&device_notifier
);
3587 static void __exit
vt6655_cleanup_module(void)
3592 unregister_reboot_notifier(&device_notifier
);
3594 pci_unregister_driver(&device_driver
);
3598 module_init(vt6655_init_module
);
3599 module_exit(vt6655_cleanup_module
);
3604 device_notify_reboot(struct notifier_block
*nb
, unsigned long event
, void *p
)
3606 struct pci_dev
*pdev
= NULL
;
3611 for_each_pci_dev(pdev
) {
3612 if(pci_dev_driver(pdev
) == &device_driver
) {
3613 if (pci_get_drvdata(pdev
))
3614 viawget_suspend(pdev
, PMSG_HIBERNATE
);
3622 viawget_suspend(struct pci_dev
*pcid
, pm_message_t state
)
3624 int power_status
; // to silence the compiler
3626 PSDevice pDevice
=pci_get_drvdata(pcid
);
3627 PSMgmtObject pMgmt
= pDevice
->pMgmt
;
3629 netif_stop_queue(pDevice
->dev
);
3630 spin_lock_irq(&pDevice
->lock
);
3631 pci_save_state(pcid
);
3632 del_timer(&pDevice
->sTimerCommand
);
3633 del_timer(&pMgmt
->sTimerSecondCallback
);
3634 pDevice
->cbFreeCmdQueue
= CMD_Q_SIZE
;
3635 pDevice
->uCmdDequeueIdx
= 0;
3636 pDevice
->uCmdEnqueueIdx
= 0;
3637 pDevice
->bCmdRunning
= false;
3638 MACbShutdown(pDevice
->PortOffset
);
3639 MACvSaveContext(pDevice
->PortOffset
, pDevice
->abyMacContext
);
3640 pDevice
->bLinkPass
= false;
3641 memset(pMgmt
->abyCurrBSSID
, 0, 6);
3642 pMgmt
->eCurrState
= WMAC_STATE_IDLE
;
3643 pci_disable_device(pcid
);
3644 power_status
= pci_set_power_state(pcid
, pci_choose_state(pcid
, state
));
3645 spin_unlock_irq(&pDevice
->lock
);
3650 viawget_resume(struct pci_dev
*pcid
)
3652 PSDevice pDevice
=pci_get_drvdata(pcid
);
3653 PSMgmtObject pMgmt
= pDevice
->pMgmt
;
3654 int power_status
; // to silence the compiler
3657 power_status
= pci_set_power_state(pcid
, 0);
3658 power_status
= pci_enable_wake(pcid
, 0, 0);
3659 pci_restore_state(pcid
);
3660 if (netif_running(pDevice
->dev
)) {
3661 spin_lock_irq(&pDevice
->lock
);
3662 MACvRestoreContext(pDevice
->PortOffset
, pDevice
->abyMacContext
);
3663 device_init_registers(pDevice
, DEVICE_INIT_DXPL
);
3664 if (pMgmt
->sNodeDBTable
[0].bActive
== true) { // Assoc with BSS
3665 pMgmt
->sNodeDBTable
[0].bActive
= false;
3666 pDevice
->bLinkPass
= false;
3667 if(pMgmt
->eCurrMode
== WMAC_MODE_IBSS_STA
) {
3668 // In Adhoc, BSS state set back to started.
3669 pMgmt
->eCurrState
= WMAC_STATE_STARTED
;
3672 pMgmt
->eCurrMode
= WMAC_MODE_STANDBY
;
3673 pMgmt
->eCurrState
= WMAC_STATE_IDLE
;
3676 init_timer(&pMgmt
->sTimerSecondCallback
);
3677 init_timer(&pDevice
->sTimerCommand
);
3678 MACvIntEnable(pDevice
->PortOffset
, IMR_MASK_VALUE
);
3679 BSSvClearBSSList((void *)pDevice
, pDevice
->bLinkPass
);
3680 bScheduleCommand((void *) pDevice
, WLAN_CMD_BSSID_SCAN
, NULL
);
3681 bScheduleCommand((void *) pDevice
, WLAN_CMD_SSID
, NULL
);
3682 spin_unlock_irq(&pDevice
->lock
);