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
63 #include <linux/file.h>
87 #include <linux/delay.h>
88 #include <linux/kthread.h>
89 #include <linux/slab.h>
91 /*--------------------- Static Definitions -------------------------*/
92 //static int msglevel =MSG_LEVEL_DEBUG;
93 static int msglevel = MSG_LEVEL_INFO;
96 // Define module options
98 MODULE_AUTHOR("VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>");
99 MODULE_LICENSE("GPL");
100 MODULE_DESCRIPTION("VIA Networking Solomon-A/B/G Wireless LAN Adapter Driver");
102 static int mlme_kill;
103 //static struct task_struct * mlme_task;
105 #define DEVICE_PARAM(N, D)
107 static const int N[MAX_UINTS]=OPTION_DEFAULT;\
108 MODULE_PARM(N, "1-" __MODULE_STRING(MAX_UINTS) "i");\
109 MODULE_PARM_DESC(N, D);
112 #define RX_DESC_MIN0 16
113 #define RX_DESC_MAX0 128
114 #define RX_DESC_DEF0 32
115 DEVICE_PARAM(RxDescriptors0, "Number of receive descriptors0");
117 #define RX_DESC_MIN1 16
118 #define RX_DESC_MAX1 128
119 #define RX_DESC_DEF1 32
120 DEVICE_PARAM(RxDescriptors1, "Number of receive descriptors1");
122 #define TX_DESC_MIN0 16
123 #define TX_DESC_MAX0 128
124 #define TX_DESC_DEF0 32
125 DEVICE_PARAM(TxDescriptors0, "Number of transmit descriptors0");
127 #define TX_DESC_MIN1 16
128 #define TX_DESC_MAX1 128
129 #define TX_DESC_DEF1 64
130 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");
141 #define INT_WORKS_DEF 20
142 #define INT_WORKS_MIN 10
143 #define INT_WORKS_MAX 64
145 DEVICE_PARAM(int_works, "Number of packets per interrupt services");
147 #define CHANNEL_MIN 1
148 #define CHANNEL_MAX 14
149 #define CHANNEL_DEF 6
151 DEVICE_PARAM(Channel, "Channel number");
153 /* PreambleType[] is the preamble length used for transmit.
154 0: indicate allows long preamble type
155 1: indicate allows short preamble type
158 #define PREAMBLE_TYPE_DEF 1
160 DEVICE_PARAM(PreambleType, "Preamble Type");
162 #define RTS_THRESH_MIN 512
163 #define RTS_THRESH_MAX 2347
164 #define RTS_THRESH_DEF 2347
166 DEVICE_PARAM(RTSThreshold, "RTS threshold");
168 #define FRAG_THRESH_MIN 256
169 #define FRAG_THRESH_MAX 2346
170 #define FRAG_THRESH_DEF 2346
172 DEVICE_PARAM(FragThreshold, "Fragmentation threshold");
174 #define DATA_RATE_MIN 0
175 #define DATA_RATE_MAX 13
176 #define DATA_RATE_DEF 13
178 0: indicate 1 Mbps 0x02
179 1: indicate 2 Mbps 0x04
180 2: indicate 5.5 Mbps 0x0B
181 3: indicate 11 Mbps 0x16
182 4: indicate 6 Mbps 0x0c
183 5: indicate 9 Mbps 0x12
184 6: indicate 12 Mbps 0x18
185 7: indicate 18 Mbps 0x24
186 8: indicate 24 Mbps 0x30
187 9: indicate 36 Mbps 0x48
188 10: indicate 48 Mbps 0x60
189 11: indicate 54 Mbps 0x6c
190 12: indicate 72 Mbps 0x90
191 13: indicate auto rate
194 DEVICE_PARAM(ConnectionRate, "Connection data rate");
196 #define OP_MODE_DEF 0
198 DEVICE_PARAM(OPMode, "Infrastruct, adhoc, AP mode ");
200 /* OpMode[] is used for transmit.
201 0: indicate infrastruct mode used
202 1: indicate adhoc mode used
203 2: indicate AP mode used
207 0: indicate disable power saving mode
208 1: indicate enable power saving mode
211 #define PS_MODE_DEF 0
213 DEVICE_PARAM(PSMode, "Power saving mode");
215 #define SHORT_RETRY_MIN 0
216 #define SHORT_RETRY_MAX 31
217 #define SHORT_RETRY_DEF 8
219 DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits");
221 #define LONG_RETRY_MIN 0
222 #define LONG_RETRY_MAX 15
223 #define LONG_RETRY_DEF 4
225 DEVICE_PARAM(LongRetryLimit, "long frame retry limits");
227 /* BasebandType[] baseband type selected
228 0: indicate 802.11a type
229 1: indicate 802.11b type
230 2: indicate 802.11g type
232 #define BBP_TYPE_MIN 0
233 #define BBP_TYPE_MAX 2
234 #define BBP_TYPE_DEF 2
236 DEVICE_PARAM(BasebandType, "baseband type");
239 0: indicate disable 802.11h
240 1: indicate enable 802.11h
243 #define X80211h_MODE_DEF 0
245 DEVICE_PARAM(b80211hEnable, "802.11h mode");
248 0: indicate disable 802.11h
249 1: indicate enable 802.11h
252 #define DIVERSITY_ANT_DEF 0
254 DEVICE_PARAM(bDiversityANTEnable, "ANT diversity mode");
257 // Static vars definitions
260 static int device_nics = 0;
261 static PSDevice pDevice_Infos = NULL;
262 static struct net_device *root_device_dev = NULL;
264 static CHIP_INFO chip_info_table[] = {
265 { VT3253, "VIA Networking Solomon-A/B/G Wireless LAN Adapter ",
266 256, 1, DEVICE_FLAGS_IP_ALIGN|DEVICE_FLAGS_TX_ALIGN },
270 const struct pci_device_id vt6655_pci_id_table[] = {
271 { PCI_VDEVICE(VIA, 0x3253), (kernel_ulong_t)chip_info_table},
275 /*--------------------- Static Functions --------------------------*/
277 static int vt6655_probe(struct pci_dev *pcid, const struct pci_device_id *ent);
278 static void vt6655_init_info(struct pci_dev *pcid, PSDevice *ppDevice, PCHIP_INFO);
279 static void device_free_info(PSDevice pDevice);
280 static bool device_get_pci_info(PSDevice, struct pci_dev *pcid);
281 static void device_print_info(PSDevice pDevice);
282 static struct net_device_stats *device_get_stats(struct net_device *dev);
283 static void device_init_diversity_timer(PSDevice pDevice);
284 static int device_open(struct net_device *dev);
285 static int device_xmit(struct sk_buff *skb, struct net_device *dev);
286 static irqreturn_t device_intr(int irq, void *dev_instance);
287 static void device_set_multi(struct net_device *dev);
288 static int device_close(struct net_device *dev);
289 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
292 static int device_notify_reboot(struct notifier_block *, unsigned long event, void *ptr);
293 static int viawget_suspend(struct pci_dev *pcid, pm_message_t state);
294 static int viawget_resume(struct pci_dev *pcid);
295 struct notifier_block device_notifier = {
296 .notifier_call = device_notify_reboot,
302 static void device_init_rd0_ring(PSDevice pDevice);
303 static void device_init_rd1_ring(PSDevice pDevice);
304 static void device_init_defrag_cb(PSDevice pDevice);
305 static void device_init_td0_ring(PSDevice pDevice);
306 static void device_init_td1_ring(PSDevice pDevice);
308 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
309 //2008-0714<Add>by Mike Liu
310 static bool device_release_WPADEV(PSDevice pDevice);
312 static int ethtool_ioctl(struct net_device *dev, void *useraddr);
313 static int device_rx_srv(PSDevice pDevice, unsigned int uIdx);
314 static int device_tx_srv(PSDevice pDevice, unsigned int uIdx);
315 static bool device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pDesc);
316 static void device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType);
317 static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc);
318 static void device_free_td0_ring(PSDevice pDevice);
319 static void device_free_td1_ring(PSDevice pDevice);
320 static void device_free_rd0_ring(PSDevice pDevice);
321 static void device_free_rd1_ring(PSDevice pDevice);
322 static void device_free_rings(PSDevice pDevice);
323 static void device_free_frag_buf(PSDevice pDevice);
324 static int Config_FileGetParameter(unsigned char *string,
325 unsigned char *dest, unsigned char *source);
327 /*--------------------- Export Variables --------------------------*/
329 /*--------------------- Export Functions --------------------------*/
331 static char *get_chip_name(int chip_id)
334 for (i = 0; chip_info_table[i].name != NULL; i++)
335 if (chip_info_table[i].chip_id == chip_id)
337 return chip_info_table[i].name;
340 static void vt6655_remove(struct pci_dev *pcid)
342 PSDevice pDevice = pci_get_drvdata(pcid);
346 device_free_info(pDevice);
351 device_set_int_opt(int *opt, int val, int min, int max, int def,char* name,char* devname) {
354 else if (val<min || val>max) {
355 DBG_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: the value of parameter %s is invalid, the valid range is (%d-%d)\n" ,
356 devname,name, min,max);
359 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: set value of parameter %s to %d\n",
366 device_set_bool_opt(unsigned int *opt, int val,bool def,u32 flag, char* name,char* devname) {
369 *opt|=(def ? flag : 0);
370 else if (val<0 || val>1) {
371 DBG_PRT(MSG_LEVEL_INFO, KERN_NOTICE
372 "%s: the value of parameter %s is invalid, the valid range is (0-1)\n",devname,name);
373 *opt|=(def ? flag : 0);
375 DBG_PRT(MSG_LEVEL_INFO, KERN_NOTICE "%s: set parameter %s to %s\n",
376 devname,name , val ? "true" : "false");
377 *opt|=(val ? flag : 0);
381 static void device_get_options(PSDevice pDevice, int index, char *devname)
383 POPTIONS pOpts = &(pDevice->sOpts);
385 pOpts->nRxDescs0 = RX_DESC_DEF0;
386 pOpts->nRxDescs1 = RX_DESC_DEF1;
387 pOpts->nTxDescs[0] = TX_DESC_DEF0;
388 pOpts->nTxDescs[1] = TX_DESC_DEF1;
389 pOpts->flags |= DEVICE_FLAGS_IP_ALIGN;
390 pOpts->int_works = INT_WORKS_DEF;
391 pOpts->rts_thresh = RTS_THRESH_DEF;
392 pOpts->frag_thresh = FRAG_THRESH_DEF;
393 pOpts->data_rate = DATA_RATE_DEF;
394 pOpts->channel_num = CHANNEL_DEF;
396 pOpts->flags |= DEVICE_FLAGS_PREAMBLE_TYPE;
397 pOpts->flags |= DEVICE_FLAGS_OP_MODE;
398 //pOpts->flags|=DEVICE_FLAGS_PS_MODE;
399 pOpts->short_retry = SHORT_RETRY_DEF;
400 pOpts->long_retry = LONG_RETRY_DEF;
401 pOpts->bbp_type = BBP_TYPE_DEF;
402 pOpts->flags |= DEVICE_FLAGS_80211h_MODE;
403 pOpts->flags |= DEVICE_FLAGS_DiversityANT;
407 device_set_options(PSDevice pDevice) {
408 unsigned char abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
409 unsigned char abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
410 unsigned char abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
412 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
413 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
414 memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, ETH_ALEN);
416 pDevice->uChannel = pDevice->sOpts.channel_num;
417 pDevice->wRTSThreshold = pDevice->sOpts.rts_thresh;
418 pDevice->wFragmentationThreshold = pDevice->sOpts.frag_thresh;
419 pDevice->byShortRetryLimit = pDevice->sOpts.short_retry;
420 pDevice->byLongRetryLimit = pDevice->sOpts.long_retry;
421 pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
422 pDevice->byShortPreamble = (pDevice->sOpts.flags & DEVICE_FLAGS_PREAMBLE_TYPE) ? 1 : 0;
423 pDevice->byOpMode = (pDevice->sOpts.flags & DEVICE_FLAGS_OP_MODE) ? 1 : 0;
424 pDevice->ePSMode = (pDevice->sOpts.flags & DEVICE_FLAGS_PS_MODE) ? 1 : 0;
425 pDevice->b11hEnable = (pDevice->sOpts.flags & DEVICE_FLAGS_80211h_MODE) ? 1 : 0;
426 pDevice->bDiversityRegCtlON = (pDevice->sOpts.flags & DEVICE_FLAGS_DiversityANT) ? 1 : 0;
427 pDevice->uConnectionRate = pDevice->sOpts.data_rate;
428 if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = true;
429 pDevice->byBBType = pDevice->sOpts.bbp_type;
430 pDevice->byPacketType = pDevice->byBBType;
433 pDevice->byAutoFBCtrl = AUTO_FB_0;
434 //pDevice->byAutoFBCtrl = AUTO_FB_1;
436 pDevice->bUpdateBBVGA = true;
437 pDevice->byFOETuning = 0;
438 pDevice->wCTSDuration = 0;
439 pDevice->byPreambleType = 0;
441 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " uChannel= %d\n", (int)pDevice->uChannel);
442 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " byOpMode= %d\n", (int)pDevice->byOpMode);
443 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " ePSMode= %d\n", (int)pDevice->ePSMode);
444 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " wRTSThreshold= %d\n", (int)pDevice->wRTSThreshold);
445 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " byShortRetryLimit= %d\n", (int)pDevice->byShortRetryLimit);
446 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " byLongRetryLimit= %d\n", (int)pDevice->byLongRetryLimit);
447 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " byPreambleType= %d\n", (int)pDevice->byPreambleType);
448 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " byShortPreamble= %d\n", (int)pDevice->byShortPreamble);
449 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " uConnectionRate= %d\n", (int)pDevice->uConnectionRate);
450 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " byBBType= %d\n", (int)pDevice->byBBType);
451 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " pDevice->b11hEnable= %d\n", (int)pDevice->b11hEnable);
452 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " pDevice->bDiversityRegCtlON= %d\n", (int)pDevice->bDiversityRegCtlON);
455 static void s_vCompleteCurrentMeasure(PSDevice pDevice, unsigned char byResult)
458 unsigned long dwDuration = 0;
459 unsigned char byRPI0 = 0;
461 for (ii = 1; ii < 8; ii++) {
462 pDevice->dwRPIs[ii] *= 255;
463 dwDuration |= *((unsigned short *)(pDevice->pCurrMeasureEID->sReq.abyDuration));
465 pDevice->dwRPIs[ii] /= dwDuration;
466 pDevice->abyRPIs[ii] = (unsigned char)pDevice->dwRPIs[ii];
467 byRPI0 += pDevice->abyRPIs[ii];
469 pDevice->abyRPIs[0] = (0xFF - byRPI0);
471 if (pDevice->uNumOfMeasureEIDs == 0) {
472 VNTWIFIbMeasureReport(pDevice->pMgmt,
474 pDevice->pCurrMeasureEID,
477 pDevice->byCCAFraction,
481 VNTWIFIbMeasureReport(pDevice->pMgmt,
483 pDevice->pCurrMeasureEID,
486 pDevice->byCCAFraction,
489 CARDbStartMeasure(pDevice, pDevice->pCurrMeasureEID++, pDevice->uNumOfMeasureEIDs);
494 // Initialisation of MAC & BBP registers
497 static void device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType)
500 unsigned char byValue;
501 unsigned char byValue1;
502 unsigned char byCCKPwrdBm = 0;
503 unsigned char byOFDMPwrdBm = 0;
505 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
506 MACbShutdown(pDevice->PortOffset);
507 BBvSoftwareReset(pDevice->PortOffset);
509 if ((InitType == DEVICE_INIT_COLD) ||
510 (InitType == DEVICE_INIT_DXPL)) {
511 // Do MACbSoftwareReset in MACvInitialize
512 MACbSoftwareReset(pDevice->PortOffset);
514 pDevice->bCCK = true;
515 pDevice->bAES = false;
516 pDevice->bProtectMode = false; //Only used in 11g type, sync with ERP IE
517 pDevice->bNonERPPresent = false;
518 pDevice->bBarkerPreambleMd = false;
519 pDevice->wCurrentRate = RATE_1M;
520 pDevice->byTopOFDMBasicRate = RATE_24M;
521 pDevice->byTopCCKBasicRate = RATE_1M;
523 pDevice->byRevId = 0; //Target to IF pin while programming to RF chip.
526 MACvInitialize(pDevice->PortOffset);
529 VNSvInPortB(pDevice->PortOffset + MAC_REG_LOCALID, &(pDevice->byLocalID));
531 spin_lock_irq(&pDevice->lock);
532 SROMvReadAllContents(pDevice->PortOffset, pDevice->abyEEPROM);
534 spin_unlock_irq(&pDevice->lock);
538 pDevice->byMinChannel = 1;
539 pDevice->byMaxChannel = CB_MAX_CHANNEL;
542 byValue = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ANTENNA);
543 if (byValue & EEP_ANTINV)
544 pDevice->bTxRxAntInv = true;
546 pDevice->bTxRxAntInv = false;
548 byValue &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
549 if (byValue == 0) // if not set default is All
550 byValue = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
552 pDevice->ulDiversityNValue = 100*260;//100*SROMbyReadEmbedded(pDevice->PortOffset, 0x51);
553 pDevice->ulDiversityMValue = 100*16;//SROMbyReadEmbedded(pDevice->PortOffset, 0x52);
554 pDevice->byTMax = 1;//SROMbyReadEmbedded(pDevice->PortOffset, 0x53);
555 pDevice->byTMax2 = 4;//SROMbyReadEmbedded(pDevice->PortOffset, 0x54);
556 pDevice->ulSQ3TH = 0;//(unsigned long) SROMbyReadEmbedded(pDevice->PortOffset, 0x55);
557 pDevice->byTMax3 = 64;//SROMbyReadEmbedded(pDevice->PortOffset, 0x56);
559 if (byValue == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
560 pDevice->byAntennaCount = 2;
561 pDevice->byTxAntennaMode = ANT_B;
562 pDevice->dwTxAntennaSel = 1;
563 pDevice->dwRxAntennaSel = 1;
564 if (pDevice->bTxRxAntInv)
565 pDevice->byRxAntennaMode = ANT_A;
567 pDevice->byRxAntennaMode = ANT_B;
568 // chester for antenna
569 byValue1 = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ANTENNA);
570 if ((byValue1 & 0x08) == 0)
571 pDevice->bDiversityEnable = false;//SROMbyReadEmbedded(pDevice->PortOffset, 0x50);
573 pDevice->bDiversityEnable = true;
575 pDevice->bDiversityEnable = false;
576 pDevice->byAntennaCount = 1;
577 pDevice->dwTxAntennaSel = 0;
578 pDevice->dwRxAntennaSel = 0;
579 if (byValue & EEP_ANTENNA_AUX) {
580 pDevice->byTxAntennaMode = ANT_A;
581 if (pDevice->bTxRxAntInv)
582 pDevice->byRxAntennaMode = ANT_B;
584 pDevice->byRxAntennaMode = ANT_A;
586 pDevice->byTxAntennaMode = ANT_B;
587 if (pDevice->bTxRxAntInv)
588 pDevice->byRxAntennaMode = ANT_A;
590 pDevice->byRxAntennaMode = ANT_B;
593 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "bDiversityEnable=[%d],NValue=[%d],MValue=[%d],TMax=[%d],TMax2=[%d]\n",
594 pDevice->bDiversityEnable, (int)pDevice->ulDiversityNValue, (int)pDevice->ulDiversityMValue, pDevice->byTMax, pDevice->byTMax2);
596 //#ifdef ZoneType_DefaultSetting
597 //2008-8-4 <add> by chester
599 pDevice->byOriginalZonetype = pDevice->abyEEPROM[EEP_OFS_ZONETYPE];
600 zonetype = Config_FileOperation(pDevice, false, NULL);
601 if (zonetype >= 0) { //read zonetype file ok!
602 if ((zonetype == 0) &&
603 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] != 0x00)) { //for USA
604 pDevice->abyEEPROM[EEP_OFS_ZONETYPE] = 0;
605 pDevice->abyEEPROM[EEP_OFS_MAXCHANNEL] = 0x0B;
606 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Init Zone Type :USA\n");
607 } else if ((zonetype == 1) &&
608 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] != 0x01)) { //for Japan
609 pDevice->abyEEPROM[EEP_OFS_ZONETYPE] = 0x01;
610 pDevice->abyEEPROM[EEP_OFS_MAXCHANNEL] = 0x0D;
611 } else if ((zonetype == 2) &&
612 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] != 0x02)) { //for Europe
613 pDevice->abyEEPROM[EEP_OFS_ZONETYPE] = 0x02;
614 pDevice->abyEEPROM[EEP_OFS_MAXCHANNEL] = 0x0D;
615 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Init Zone Type :Europe\n");
619 if (zonetype != pDevice->abyEEPROM[EEP_OFS_ZONETYPE])
620 printk("zonetype in file[%02x] mismatch with in EEPROM[%02x]\n", zonetype, pDevice->abyEEPROM[EEP_OFS_ZONETYPE]);
622 printk("Read Zonetype file success,use default zonetype setting[%02x]\n", zonetype);
625 printk("Read Zonetype file fail,use default zonetype setting[%02x]\n", SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ZONETYPE));
628 pDevice->byRFType = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RFTYPE);
630 if ((pDevice->byRFType & RF_EMU) != 0) {
631 // force change RevID for VT3253 emu
632 pDevice->byRevId = 0x80;
635 pDevice->byRFType &= RF_MASK;
636 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRFType = %x\n", pDevice->byRFType);
638 if (!pDevice->bZoneRegExist) {
639 pDevice->byZoneType = pDevice->abyEEPROM[EEP_OFS_ZONETYPE];
641 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byZoneType = %x\n", pDevice->byZoneType);
646 //Get Desire Power Value
647 pDevice->byCurPwr = 0xFF;
648 pDevice->byCCKPwr = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_PWR_CCK);
649 pDevice->byOFDMPwrG = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_PWR_OFDMG);
650 //byCCKPwrdBm = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_CCK_PWR_dBm);
652 //byOFDMPwrdBm = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_OFDM_PWR_dBm);
656 for (ii = 0; ii < CB_MAX_CHANNEL_24G; ii++) {
657 pDevice->abyCCKPwrTbl[ii + 1] = SROMbyReadEmbedded(pDevice->PortOffset, (unsigned char)(ii + EEP_OFS_CCK_PWR_TBL));
658 if (pDevice->abyCCKPwrTbl[ii + 1] == 0) {
659 pDevice->abyCCKPwrTbl[ii+1] = pDevice->byCCKPwr;
661 pDevice->abyOFDMPwrTbl[ii + 1] = SROMbyReadEmbedded(pDevice->PortOffset, (unsigned char)(ii + EEP_OFS_OFDM_PWR_TBL));
662 if (pDevice->abyOFDMPwrTbl[ii + 1] == 0) {
663 pDevice->abyOFDMPwrTbl[ii + 1] = pDevice->byOFDMPwrG;
665 pDevice->abyCCKDefaultPwr[ii + 1] = byCCKPwrdBm;
666 pDevice->abyOFDMDefaultPwr[ii + 1] = byOFDMPwrdBm;
668 //2008-8-4 <add> by chester
669 //recover 12,13 ,14channel for EUROPE by 11 channel
670 if (((pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Japan) ||
671 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Europe)) &&
672 (pDevice->byOriginalZonetype == ZoneType_USA)) {
673 for (ii = 11; ii < 14; ii++) {
674 pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];
675 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];
680 // Load OFDM A Power Table
681 for (ii = 0; ii < CB_MAX_CHANNEL_5G; ii++) { //RobertYu:20041224, bug using CB_MAX_CHANNEL
682 pDevice->abyOFDMPwrTbl[ii + CB_MAX_CHANNEL_24G + 1] = SROMbyReadEmbedded(pDevice->PortOffset, (unsigned char)(ii + EEP_OFS_OFDMA_PWR_TBL));
683 pDevice->abyOFDMDefaultPwr[ii + CB_MAX_CHANNEL_24G + 1] = SROMbyReadEmbedded(pDevice->PortOffset, (unsigned char)(ii + EEP_OFS_OFDMA_PWR_dBm));
685 init_channel_table((void *)pDevice);
687 if (pDevice->byLocalID > REV_ID_VT3253_B1) {
688 MACvSelectPage1(pDevice->PortOffset);
689 VNSvOutPortB(pDevice->PortOffset + MAC_REG_MSRCTL + 1, (MSRCTL1_TXPWR | MSRCTL1_CSAPAREN));
690 MACvSelectPage0(pDevice->PortOffset);
693 // use relative tx timeout and 802.11i D4
694 MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_CFG, (CFG_TKIPOPT | CFG_NOTXTIMEOUT));
696 // set performance parameter by registry
697 MACvSetShortRetryLimit(pDevice->PortOffset, pDevice->byShortRetryLimit);
698 MACvSetLongRetryLimit(pDevice->PortOffset, pDevice->byLongRetryLimit);
701 VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
702 // enable TSF counter
703 VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
705 // initialize BBP registers
706 BBbVT3253Init(pDevice);
708 if (pDevice->bUpdateBBVGA) {
709 pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
710 pDevice->byBBVGANew = pDevice->byBBVGACurrent;
711 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
713 BBvSetRxAntennaMode(pDevice->PortOffset, pDevice->byRxAntennaMode);
714 BBvSetTxAntennaMode(pDevice->PortOffset, pDevice->byTxAntennaMode);
716 pDevice->byCurrentCh = 0;
718 //pDevice->NetworkType = Ndis802_11Automode;
719 // Set BB and packet type at the same time.
720 // Set Short Slot Time, xIFS, and RSPINF.
721 if (pDevice->uConnectionRate == RATE_AUTO) {
722 pDevice->wCurrentRate = RATE_54M;
724 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
728 VNTWIFIbConfigPhyMode(pDevice->pMgmt, PHY_TYPE_11G);
729 VNTWIFIbConfigPhyMode(pDevice->pMgmt, PHY_TYPE_AUTO);
731 pDevice->bRadioOff = false;
733 pDevice->byRadioCtl = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RADIOCTL);
734 pDevice->bHWRadioOff = false;
736 if (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) {
738 MACvGPIOIn(pDevice->PortOffset, &pDevice->byGPIO);
739 //2008-4-14 <add> by chester for led issue
740 #ifdef FOR_LED_ON_NOTEBOOK
741 if (pDevice->byGPIO & GPIO0_DATA) { pDevice->bHWRadioOff = true; }
742 if (!(pDevice->byGPIO & GPIO0_DATA)) { pDevice->bHWRadioOff = false; }
745 if (pDevice->bRadioControlOff) {
746 CARDbRadioPowerOff(pDevice);
747 } else CARDbRadioPowerOn(pDevice);
749 if (((pDevice->byGPIO & GPIO0_DATA) && !(pDevice->byRadioCtl & EEP_RADIOCTL_INV)) ||
750 (!(pDevice->byGPIO & GPIO0_DATA) && (pDevice->byRadioCtl & EEP_RADIOCTL_INV))) {
751 pDevice->bHWRadioOff = true;
754 if (pDevice->bHWRadioOff || pDevice->bRadioControlOff) {
755 CARDbRadioPowerOff(pDevice);
760 pMgmt->eScanType = WMAC_SCAN_PASSIVE;
761 // get Permanent network address
762 SROMvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr);
763 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Network address = %pM\n",
764 pDevice->abyCurrentNetAddr);
767 CARDvSafeResetRx(pDevice);
769 CARDvSafeResetTx(pDevice);
771 if (pDevice->byLocalID <= REV_ID_VT3253_A1) {
772 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_RCR, RCR_WPAERR);
775 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
778 MACvReceive0(pDevice->PortOffset);
779 MACvReceive1(pDevice->PortOffset);
782 MACvStart(pDevice->PortOffset);
784 netif_stop_queue(pDevice->dev);
787 static void device_init_diversity_timer(PSDevice pDevice) {
788 init_timer(&pDevice->TimerSQ3Tmax1);
789 pDevice->TimerSQ3Tmax1.data = (unsigned long) pDevice;
790 pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
791 pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
793 init_timer(&pDevice->TimerSQ3Tmax2);
794 pDevice->TimerSQ3Tmax2.data = (unsigned long) pDevice;
795 pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
796 pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
798 init_timer(&pDevice->TimerSQ3Tmax3);
799 pDevice->TimerSQ3Tmax3.data = (unsigned long) pDevice;
800 pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerState1CallBack;
801 pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
806 static bool device_release_WPADEV(PSDevice pDevice)
808 viawget_wpa_header *wpahdr;
810 // wait_queue_head_t Set_wait;
811 //send device close to wpa_supplicnat layer
812 if (pDevice->bWPADEVUp) {
813 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
814 wpahdr->type = VIAWGET_DEVICECLOSE_MSG;
815 wpahdr->resp_ie_len = 0;
816 wpahdr->req_ie_len = 0;
817 skb_put(pDevice->skb, sizeof(viawget_wpa_header));
818 pDevice->skb->dev = pDevice->wpadev;
819 skb_reset_mac_header(pDevice->skb);
820 pDevice->skb->pkt_type = PACKET_HOST;
821 pDevice->skb->protocol = htons(ETH_P_802_2);
822 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
823 netif_rx(pDevice->skb);
824 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
826 //wait release WPADEV
827 // init_waitqueue_head(&Set_wait);
828 // wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ); //1s wait
829 while (pDevice->bWPADEVUp) {
830 set_current_state(TASK_UNINTERRUPTIBLE);
831 schedule_timeout(HZ / 20); //wait 50ms
840 static const struct net_device_ops device_netdev_ops = {
841 .ndo_open = device_open,
842 .ndo_stop = device_close,
843 .ndo_do_ioctl = device_ioctl,
844 .ndo_get_stats = device_get_stats,
845 .ndo_start_xmit = device_xmit,
846 .ndo_set_rx_mode = device_set_multi,
850 vt6655_probe(struct pci_dev *pcid, const struct pci_device_id *ent)
852 static bool bFirst = true;
853 struct net_device *dev = NULL;
854 PCHIP_INFO pChip_info = (PCHIP_INFO)ent->driver_data;
857 if (device_nics++ >= MAX_UINTS) {
858 printk(KERN_NOTICE DEVICE_NAME ": already found %d NICs\n", device_nics);
862 dev = alloc_etherdev(sizeof(DEVICE_INFO));
864 pDevice = (PSDevice) netdev_priv(dev);
867 printk(KERN_ERR DEVICE_NAME ": allocate net device failed \n");
871 // Chain it all together
872 // SET_MODULE_OWNER(dev);
873 SET_NETDEV_DEV(dev, &pcid->dev);
876 printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
877 printk(KERN_NOTICE "Copyright (c) 2003 VIA Networking Technologies, Inc.\n");
881 vt6655_init_info(pcid, &pDevice, pChip_info);
883 pDevice->next_module = root_device_dev;
884 root_device_dev = dev;
886 if (pci_enable_device(pcid)) {
887 device_free_info(pDevice);
890 dev->irq = pcid->irq;
893 printk("Before get pci_info memaddr is %x\n", pDevice->memaddr);
895 if (!device_get_pci_info(pDevice, pcid)) {
896 printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device.\n");
897 device_free_info(pDevice);
905 //pci_read_config_byte(pcid, PCI_BASE_ADDRESS_0, &pDevice->byRevId);
906 printk("after get pci_info memaddr is %x, io addr is %x,io_size is %d\n", pDevice->memaddr, pDevice->ioaddr, pDevice->io_size);
918 for (i = 0; address[i]; i++) {
919 //pci_write_config_dword(pcid,address[i], 0xFFFFFFFF);
920 pci_read_config_dword(pcid, address[i], &bar);
921 printk("bar %d is %x\n", i, bar);
923 printk("bar %d not implemented\n", i);
926 if (bar & PCI_BASE_ADDRESS_SPACE_IO) {
929 len = bar & (PCI_BASE_ADDRESS_IO_MASK & 0xFFFF);
930 len = len & ~(len - 1);
932 printk("IO space: len in IO %x, BAR %d\n", len, i);
934 len = bar & 0xFFFFFFF0;
937 printk("len in MEM %x, BAR %d\n", len, i);
948 pDevice->PortOffset = (unsigned long)ioremap(pDevice->memaddr & PCI_BASE_ADDRESS_MEM_MASK, pDevice->io_size);
949 //pDevice->PortOffset = (unsigned long)ioremap(pDevice->ioaddr & PCI_BASE_ADDRESS_IO_MASK, pDevice->io_size);
951 if (pDevice->PortOffset == 0) {
952 printk(KERN_ERR DEVICE_NAME ": Failed to IO remapping ..\n");
953 device_free_info(pDevice);
957 rc = pci_request_regions(pcid, DEVICE_NAME);
959 printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device\n");
960 device_free_info(pDevice);
964 dev->base_addr = pDevice->ioaddr;
968 VNSvInPortB(pDevice->PortOffset+0x4F, &value);
969 printk("Before write: value is %x\n", value);
970 //VNSvInPortB(pDevice->PortOffset+0x3F, 0x00);
971 VNSvOutPortB(pDevice->PortOffset, value);
972 VNSvInPortB(pDevice->PortOffset+0x4F, &value);
973 printk("After write: value is %x\n", value);
977 pDevice->PortOffset = pDevice->ioaddr;
980 if (!MACbSoftwareReset(pDevice->PortOffset)) {
981 printk(KERN_ERR DEVICE_NAME ": Failed to access MAC hardware..\n");
982 device_free_info(pDevice);
985 // initial to reload eeprom
986 MACvInitialize(pDevice->PortOffset);
987 MACvReadEtherAddress(pDevice->PortOffset, dev->dev_addr);
989 device_get_options(pDevice, device_nics-1, dev->name);
990 device_set_options(pDevice);
991 //Mask out the options cannot be set to the chip
992 pDevice->sOpts.flags &= pChip_info->flags;
994 //Enable the chip specified capabilities
995 pDevice->flags = pDevice->sOpts.flags | (pChip_info->flags & 0xFF000000UL);
996 pDevice->tx_80211 = device_dma0_tx_80211;
997 pDevice->sMgmtObj.pAdapter = (void *)pDevice;
998 pDevice->pMgmt = &(pDevice->sMgmtObj);
1000 dev->irq = pcid->irq;
1001 dev->netdev_ops = &device_netdev_ops;
1003 dev->wireless_handlers = (struct iw_handler_def *)&iwctl_handler_def;
1005 rc = register_netdev(dev);
1007 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
1008 device_free_info(pDevice);
1011 device_print_info(pDevice);
1012 pci_set_drvdata(pcid, pDevice);
1016 static void device_print_info(PSDevice pDevice)
1018 struct net_device *dev = pDevice->dev;
1020 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: %s\n", dev->name, get_chip_name(pDevice->chip_id));
1021 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: MAC=%pM", dev->name, dev->dev_addr);
1023 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO " IO=0x%lx ", (unsigned long)pDevice->ioaddr);
1024 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO " IRQ=%d \n", pDevice->dev->irq);
1026 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO " IO=0x%lx Mem=0x%lx ",
1027 (unsigned long)pDevice->ioaddr, (unsigned long)pDevice->PortOffset);
1028 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO " IRQ=%d \n", pDevice->dev->irq);
1032 static void vt6655_init_info(struct pci_dev *pcid, PSDevice *ppDevice,
1033 PCHIP_INFO pChip_info) {
1036 memset(*ppDevice, 0, sizeof(DEVICE_INFO));
1038 if (pDevice_Infos == NULL) {
1039 pDevice_Infos = *ppDevice;
1041 for (p = pDevice_Infos; p->next != NULL; p = p->next)
1043 p->next = *ppDevice;
1044 (*ppDevice)->prev = p;
1047 (*ppDevice)->pcid = pcid;
1048 (*ppDevice)->chip_id = pChip_info->chip_id;
1049 (*ppDevice)->io_size = pChip_info->io_size;
1050 (*ppDevice)->nTxQueues = pChip_info->nTxQueue;
1051 (*ppDevice)->multicast_limit = 32;
1053 spin_lock_init(&((*ppDevice)->lock));
1056 static bool device_get_pci_info(PSDevice pDevice, struct pci_dev *pcid) {
1059 unsigned int cis_addr;
1061 unsigned char pci_config[256];
1062 unsigned char value = 0x00;
1064 u16 max_lat = 0x0000;
1065 memset(pci_config, 0x00, 256);
1068 pci_read_config_byte(pcid, PCI_REVISION_ID, &pDevice->byRevId);
1069 pci_read_config_word(pcid, PCI_SUBSYSTEM_ID, &pDevice->SubSystemID);
1070 pci_read_config_word(pcid, PCI_SUBSYSTEM_VENDOR_ID, &pDevice->SubVendorID);
1071 pci_read_config_word(pcid, PCI_COMMAND, (u16 *)&(pci_cmd));
1073 pci_set_master(pcid);
1075 pDevice->memaddr = pci_resource_start(pcid, 0);
1076 pDevice->ioaddr = pci_resource_start(pcid, 1);
1079 // pDevice->ioaddr = pci_resource_start(pcid, 0);
1080 // pDevice->memaddr = pci_resource_start(pcid,1);
1083 cis_addr = pci_resource_start(pcid, 2);
1085 pDevice->pcid = pcid;
1087 pci_read_config_byte(pcid, PCI_COMMAND, &b);
1088 pci_write_config_byte(pcid, PCI_COMMAND, (b|PCI_COMMAND_MASTER));
1091 //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat);
1092 //for (ii=0;ii<0xFF;ii++)
1093 //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat);
1095 //pci_write_config_word(pcid,PCI_MAX_LAT,max_lat);
1096 //pci_read_config_word(pcid,PCI_MAX_LAT,&max_lat);
1098 for (ii = 0; ii < 0xFF; ii++) {
1099 pci_read_config_byte(pcid, ii, &value);
1100 pci_config[ii] = value;
1102 for (ii = 0, j = 1; ii < 0x100; ii++, j++) {
1104 printk("%x:", pci_config[ii]);
1107 printk("%x:", pci_config[ii]);
1114 static void device_free_info(PSDevice pDevice) {
1116 struct net_device *dev = pDevice->dev;
1119 //2008-0714-01<Add>by chester
1120 device_release_WPADEV(pDevice);
1122 //2008-07-21-01<Add>by MikeLiu
1124 if (wpa_set_wpadev(pDevice, 0) != 0)
1125 printk("unregister wpadev fail?\n");
1127 if (pDevice_Infos == NULL)
1130 for (ptr = pDevice_Infos; ptr && (ptr != pDevice); ptr = ptr->next)
1133 if (ptr == pDevice) {
1134 if (ptr == pDevice_Infos)
1135 pDevice_Infos = ptr->next;
1137 ptr->prev->next = ptr->next;
1139 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "info struct not found\n");
1144 vt6655_hostap_set_hostapd(pDevice, 0, 0);
1147 unregister_netdev(dev);
1149 if (pDevice->PortOffset)
1150 iounmap((void *)pDevice->PortOffset);
1153 pci_release_regions(pDevice->pcid);
1158 static bool device_init_rings(PSDevice pDevice) {
1161 /*allocate all RD/TD rings a single pool*/
1162 vir_pool = pci_alloc_consistent(pDevice->pcid,
1163 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1164 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1165 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1166 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc),
1167 &pDevice->pool_dma);
1169 if (vir_pool == NULL) {
1170 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s : allocate desc dma memory failed\n", pDevice->dev->name);
1175 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1176 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1177 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1178 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc)
1181 pDevice->aRD0Ring = vir_pool;
1182 pDevice->aRD1Ring = vir_pool +
1183 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1185 pDevice->rd0_pool_dma = pDevice->pool_dma;
1186 pDevice->rd1_pool_dma = pDevice->rd0_pool_dma +
1187 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1189 pDevice->tx0_bufs = pci_alloc_consistent(pDevice->pcid,
1190 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1191 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1192 CB_BEACON_BUF_SIZE +
1194 &pDevice->tx_bufs_dma0);
1196 if (pDevice->tx0_bufs == NULL) {
1197 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s: allocate buf dma memory failed\n", pDevice->dev->name);
1198 pci_free_consistent(pDevice->pcid,
1199 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1200 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1201 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1202 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc),
1203 vir_pool, pDevice->pool_dma
1208 memset(pDevice->tx0_bufs, 0,
1209 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1210 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1211 CB_BEACON_BUF_SIZE +
1215 pDevice->td0_pool_dma = pDevice->rd1_pool_dma +
1216 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1218 pDevice->td1_pool_dma = pDevice->td0_pool_dma +
1219 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1221 // vir_pool: pvoid type
1222 pDevice->apTD0Rings = vir_pool
1223 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1224 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1226 pDevice->apTD1Rings = vir_pool
1227 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1228 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc)
1229 + pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1231 pDevice->tx1_bufs = pDevice->tx0_bufs +
1232 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1234 pDevice->tx_beacon_bufs = pDevice->tx1_bufs +
1235 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1237 pDevice->pbyTmpBuff = pDevice->tx_beacon_bufs +
1240 pDevice->tx_bufs_dma1 = pDevice->tx_bufs_dma0 +
1241 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1243 pDevice->tx_beacon_dma = pDevice->tx_bufs_dma1 +
1244 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1249 static void device_free_rings(PSDevice pDevice) {
1250 pci_free_consistent(pDevice->pcid,
1251 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1252 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1253 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1254 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc)
1256 pDevice->aRD0Ring, pDevice->pool_dma
1259 if (pDevice->tx0_bufs)
1260 pci_free_consistent(pDevice->pcid,
1261 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1262 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1263 CB_BEACON_BUF_SIZE +
1265 pDevice->tx0_bufs, pDevice->tx_bufs_dma0
1269 static void device_init_rd0_ring(PSDevice pDevice) {
1271 dma_addr_t curr = pDevice->rd0_pool_dma;
1274 /* Init the RD0 ring entries */
1275 for (i = 0; i < pDevice->sOpts.nRxDescs0; i ++, curr += sizeof(SRxDesc)) {
1276 pDesc = &(pDevice->aRD0Ring[i]);
1277 pDesc->pRDInfo = alloc_rd_info();
1278 ASSERT(pDesc->pRDInfo);
1279 if (!device_alloc_rx_buf(pDevice, pDesc)) {
1280 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s: can not alloc rx bufs\n",
1281 pDevice->dev->name);
1283 pDesc->next = &(pDevice->aRD0Ring[(i+1) % pDevice->sOpts.nRxDescs0]);
1284 pDesc->pRDInfo->curr_desc = cpu_to_le32(curr);
1285 pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc));
1289 pDevice->aRD0Ring[i-1].next_desc = cpu_to_le32(pDevice->rd0_pool_dma);
1290 pDevice->pCurrRD[0] = &(pDevice->aRD0Ring[0]);
1293 static void device_init_rd1_ring(PSDevice pDevice) {
1295 dma_addr_t curr = pDevice->rd1_pool_dma;
1298 /* Init the RD1 ring entries */
1299 for (i = 0; i < pDevice->sOpts.nRxDescs1; i ++, curr += sizeof(SRxDesc)) {
1300 pDesc = &(pDevice->aRD1Ring[i]);
1301 pDesc->pRDInfo = alloc_rd_info();
1302 ASSERT(pDesc->pRDInfo);
1303 if (!device_alloc_rx_buf(pDevice, pDesc)) {
1304 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s: can not alloc rx bufs\n",
1305 pDevice->dev->name);
1307 pDesc->next = &(pDevice->aRD1Ring[(i+1) % pDevice->sOpts.nRxDescs1]);
1308 pDesc->pRDInfo->curr_desc = cpu_to_le32(curr);
1309 pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc));
1313 pDevice->aRD1Ring[i-1].next_desc = cpu_to_le32(pDevice->rd1_pool_dma);
1314 pDevice->pCurrRD[1] = &(pDevice->aRD1Ring[0]);
1317 static void device_init_defrag_cb(PSDevice pDevice) {
1319 PSDeFragControlBlock pDeF;
1321 /* Init the fragment ctl entries */
1322 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1323 pDeF = &(pDevice->sRxDFCB[i]);
1324 if (!device_alloc_frag_buf(pDevice, pDeF)) {
1325 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s: can not alloc frag bufs\n",
1326 pDevice->dev->name);
1329 pDevice->cbDFCB = CB_MAX_RX_FRAG;
1330 pDevice->cbFreeDFCB = pDevice->cbDFCB;
1333 static void device_free_rd0_ring(PSDevice pDevice) {
1336 for (i = 0; i < pDevice->sOpts.nRxDescs0; i++) {
1337 PSRxDesc pDesc = &(pDevice->aRD0Ring[i]);
1338 PDEVICE_RD_INFO pRDInfo = pDesc->pRDInfo;
1340 pci_unmap_single(pDevice->pcid, pRDInfo->skb_dma,
1341 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1343 dev_kfree_skb(pRDInfo->skb);
1345 kfree((void *)pDesc->pRDInfo);
1349 static void device_free_rd1_ring(PSDevice pDevice) {
1352 for (i = 0; i < pDevice->sOpts.nRxDescs1; i++) {
1353 PSRxDesc pDesc = &(pDevice->aRD1Ring[i]);
1354 PDEVICE_RD_INFO pRDInfo = pDesc->pRDInfo;
1356 pci_unmap_single(pDevice->pcid, pRDInfo->skb_dma,
1357 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1359 dev_kfree_skb(pRDInfo->skb);
1361 kfree((void *)pDesc->pRDInfo);
1365 static void device_free_frag_buf(PSDevice pDevice) {
1366 PSDeFragControlBlock pDeF;
1369 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1370 pDeF = &(pDevice->sRxDFCB[i]);
1373 dev_kfree_skb(pDeF->skb);
1378 static void device_init_td0_ring(PSDevice pDevice) {
1383 curr = pDevice->td0_pool_dma;
1384 for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++, curr += sizeof(STxDesc)) {
1385 pDesc = &(pDevice->apTD0Rings[i]);
1386 pDesc->pTDInfo = alloc_td_info();
1387 ASSERT(pDesc->pTDInfo);
1388 if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) {
1389 pDesc->pTDInfo->buf = pDevice->tx0_bufs + (i)*PKT_BUF_SZ;
1390 pDesc->pTDInfo->buf_dma = pDevice->tx_bufs_dma0 + (i)*PKT_BUF_SZ;
1392 pDesc->next = &(pDevice->apTD0Rings[(i+1) % pDevice->sOpts.nTxDescs[0]]);
1393 pDesc->pTDInfo->curr_desc = cpu_to_le32(curr);
1394 pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc));
1398 pDevice->apTD0Rings[i-1].next_desc = cpu_to_le32(pDevice->td0_pool_dma);
1399 pDevice->apTailTD[0] = pDevice->apCurrTD[0] = &(pDevice->apTD0Rings[0]);
1402 static void device_init_td1_ring(PSDevice pDevice) {
1407 /* Init the TD ring entries */
1408 curr = pDevice->td1_pool_dma;
1409 for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++, curr += sizeof(STxDesc)) {
1410 pDesc = &(pDevice->apTD1Rings[i]);
1411 pDesc->pTDInfo = alloc_td_info();
1412 ASSERT(pDesc->pTDInfo);
1413 if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) {
1414 pDesc->pTDInfo->buf = pDevice->tx1_bufs + (i) * PKT_BUF_SZ;
1415 pDesc->pTDInfo->buf_dma = pDevice->tx_bufs_dma1 + (i) * PKT_BUF_SZ;
1417 pDesc->next = &(pDevice->apTD1Rings[(i + 1) % pDevice->sOpts.nTxDescs[1]]);
1418 pDesc->pTDInfo->curr_desc = cpu_to_le32(curr);
1419 pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc));
1423 pDevice->apTD1Rings[i-1].next_desc = cpu_to_le32(pDevice->td1_pool_dma);
1424 pDevice->apTailTD[1] = pDevice->apCurrTD[1] = &(pDevice->apTD1Rings[0]);
1427 static void device_free_td0_ring(PSDevice pDevice) {
1429 for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++) {
1430 PSTxDesc pDesc = &(pDevice->apTD0Rings[i]);
1431 PDEVICE_TD_INFO pTDInfo = pDesc->pTDInfo;
1433 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma))
1434 pci_unmap_single(pDevice->pcid, pTDInfo->skb_dma,
1435 pTDInfo->skb->len, PCI_DMA_TODEVICE);
1438 dev_kfree_skb(pTDInfo->skb);
1440 kfree((void *)pDesc->pTDInfo);
1444 static void device_free_td1_ring(PSDevice pDevice) {
1447 for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++) {
1448 PSTxDesc pDesc = &(pDevice->apTD1Rings[i]);
1449 PDEVICE_TD_INFO pTDInfo = pDesc->pTDInfo;
1451 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma))
1452 pci_unmap_single(pDevice->pcid, pTDInfo->skb_dma,
1453 pTDInfo->skb->len, PCI_DMA_TODEVICE);
1456 dev_kfree_skb(pTDInfo->skb);
1458 kfree((void *)pDesc->pTDInfo);
1462 /*-----------------------------------------------------------------*/
1464 static int device_rx_srv(PSDevice pDevice, unsigned int uIdx) {
1468 for (pRD = pDevice->pCurrRD[uIdx];
1469 pRD->m_rd0RD0.f1Owner == OWNED_BY_HOST;
1471 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->pCurrRD = %x, works = %d\n", pRD, works);
1474 if (device_receive_frame(pDevice, pRD)) {
1475 if (!device_alloc_rx_buf(pDevice, pRD)) {
1476 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR
1477 "%s: can not allocate rx buf\n", pDevice->dev->name);
1481 pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1482 pDevice->dev->last_rx = jiffies;
1485 pDevice->pCurrRD[uIdx] = pRD;
1490 static bool device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pRD) {
1491 PDEVICE_RD_INFO pRDInfo = pRD->pRDInfo;
1493 pRDInfo->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1494 if (pRDInfo->skb == NULL)
1496 ASSERT(pRDInfo->skb);
1497 pRDInfo->skb->dev = pDevice->dev;
1498 pRDInfo->skb_dma = pci_map_single(pDevice->pcid, skb_tail_pointer(pRDInfo->skb),
1499 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1500 *((unsigned int *)&(pRD->m_rd0RD0)) = 0; /* FIX cast */
1502 pRD->m_rd0RD0.wResCount = cpu_to_le16(pDevice->rx_buf_sz);
1503 pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1504 pRD->m_rd1RD1.wReqCount = cpu_to_le16(pDevice->rx_buf_sz);
1505 pRD->buff_addr = cpu_to_le32(pRDInfo->skb_dma);
1510 bool device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1511 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1512 if (pDeF->skb == NULL)
1515 pDeF->skb->dev = pDevice->dev;
1520 static int device_tx_srv(PSDevice pDevice, unsigned int uIdx) {
1524 unsigned char byTsr0;
1525 unsigned char byTsr1;
1526 unsigned int uFrameSize, uFIFOHeaderSize;
1527 PSTxBufHead pTxBufHead;
1528 struct net_device_stats *pStats = &pDevice->stats;
1529 struct sk_buff *skb;
1530 unsigned int uNodeIndex;
1531 PSMgmtObject pMgmt = pDevice->pMgmt;
1533 for (pTD = pDevice->apTailTD[uIdx]; pDevice->iTDUsed[uIdx] > 0; pTD = pTD->next) {
1534 if (pTD->m_td0TD0.f1Owner == OWNED_BY_NIC)
1539 byTsr0 = pTD->m_td0TD0.byTSR0;
1540 byTsr1 = pTD->m_td0TD0.byTSR1;
1542 //Only the status of first TD in the chain is correct
1543 if (pTD->m_td1TD1.byTCR & TCR_STP) {
1544 if ((pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0) {
1545 uFIFOHeaderSize = pTD->pTDInfo->dwHeaderLength;
1546 uFrameSize = pTD->pTDInfo->dwReqCount - uFIFOHeaderSize;
1547 pTxBufHead = (PSTxBufHead) (pTD->pTDInfo->buf);
1548 // Update the statistics based on the Transmit status
1549 // now, we DONT check TSR0_CDH
1551 STAvUpdateTDStatCounter(&pDevice->scStatistic,
1553 (unsigned char *)(pTD->pTDInfo->buf + uFIFOHeaderSize),
1556 BSSvUpdateNodeTxCounter(pDevice,
1558 (unsigned char *)(pTD->pTDInfo->buf),
1562 if (!(byTsr1 & TSR1_TERR)) {
1564 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Tx[%d] OK but has error. tsr1[%02X] tsr0[%02X].\n",
1565 (int)uIdx, byTsr1, byTsr0);
1567 if ((pTxBufHead->wFragCtl & FRAGCTL_ENDFRAG) != FRAGCTL_NONFRAG) {
1568 pDevice->s802_11Counter.TransmittedFragmentCount++;
1570 pStats->tx_packets++;
1571 pStats->tx_bytes += pTD->pTDInfo->skb->len;
1573 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Tx[%d] dropped & tsr1[%02X] tsr0[%02X].\n",
1574 (int)uIdx, byTsr1, byTsr0);
1575 pStats->tx_errors++;
1576 pStats->tx_dropped++;
1580 if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
1581 if (pDevice->bEnableHostapd) {
1582 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx call back netif.. \n");
1583 skb = pTD->pTDInfo->skb;
1584 skb->dev = pDevice->apdev;
1585 skb_reset_mac_header(skb);
1586 skb->pkt_type = PACKET_OTHERHOST;
1587 //skb->protocol = htons(ETH_P_802_2);
1588 memset(skb->cb, 0, sizeof(skb->cb));
1593 if (byTsr1 & TSR1_TERR) {
1594 if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
1595 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
1596 (int)uIdx, byTsr1, byTsr0);
1599 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
1600 // (int)uIdx, byTsr1, byTsr0);
1602 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) &&
1603 (pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB)) {
1604 unsigned short wAID;
1605 unsigned char byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
1607 skb = pTD->pTDInfo->skb;
1608 if (BSSDBbIsSTAInNodeDB(pMgmt, (unsigned char *)(skb->data), &uNodeIndex)) {
1609 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
1610 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
1611 pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
1613 wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
1614 pMgmt->abyPSTxMap[wAID >> 3] |= byMask[wAID & 7];
1615 pTD->pTDInfo->byFlags &= ~(TD_FLAGS_NETIF_SKB);
1616 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx_srv:tx fail re-queue sta index= %d, QueCnt= %d\n"
1617 , (int)uNodeIndex, pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt);
1618 pStats->tx_errors--;
1619 pStats->tx_dropped--;
1624 device_free_tx_buf(pDevice, pTD);
1625 pDevice->iTDUsed[uIdx]--;
1629 if (uIdx == TYPE_AC0DMA) {
1630 // RESERV_AC0DMA reserved for relay
1632 if (AVAIL_TD(pDevice, uIdx) < RESERV_AC0DMA) {
1634 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " AC0DMA is Full = %d\n", pDevice->iTDUsed[uIdx]);
1636 if (netif_queue_stopped(pDevice->dev) && !bFull) {
1637 netif_wake_queue(pDevice->dev);
1641 pDevice->apTailTD[uIdx] = pTD;
1646 static void device_error(PSDevice pDevice, unsigned short status) {
1647 if (status & ISR_FETALERR) {
1648 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR
1649 "%s: Hardware fatal error.\n",
1650 pDevice->dev->name);
1651 netif_stop_queue(pDevice->dev);
1652 del_timer(&pDevice->sTimerCommand);
1653 del_timer(&(pDevice->pMgmt->sTimerSecondCallback));
1654 pDevice->bCmdRunning = false;
1655 MACbShutdown(pDevice->PortOffset);
1660 static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc) {
1661 PDEVICE_TD_INFO pTDInfo = pDesc->pTDInfo;
1662 struct sk_buff *skb = pTDInfo->skb;
1664 // pre-allocated buf_dma can't be unmapped.
1665 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma)) {
1666 pci_unmap_single(pDevice->pcid, pTDInfo->skb_dma, skb->len,
1670 if ((pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0)
1671 dev_kfree_skb_irq(skb);
1673 pTDInfo->skb_dma = 0;
1675 pTDInfo->byFlags = 0;
1679 void InitRxManagementQueue(PSDevice pDevice)
1681 pDevice->rxManeQueue.packet_num = 0;
1682 pDevice->rxManeQueue.head = pDevice->rxManeQueue.tail = 0;
1690 PSDevice pDevice = (PSDevice) Context;
1691 PSRxMgmtPacket pRxMgmtPacket;
1693 //complete(&pDevice->notify);
1698 //down(&pDevice->mlme_semaphore);
1699 // pRxMgmtPacket = DeQueue(pDevice);
1701 spin_lock_irq(&pDevice->lock);
1702 while (pDevice->rxManeQueue.packet_num != 0) {
1703 pRxMgmtPacket = DeQueue(pDevice);
1705 //DequeueManageObject(pDevice->FirstRecvMngList, pDevice->LastRecvMngList);
1706 vMgrRxManagePacket(pDevice, pDevice->pMgmt, pRxMgmtPacket);
1708 spin_unlock_irq(&pDevice->lock);
1722 static int device_open(struct net_device *dev) {
1723 PSDevice pDevice = (PSDevice)netdev_priv(dev);
1725 #ifdef WPA_SM_Transtatus
1726 extern SWPAResult wpa_Result;
1729 pDevice->rx_buf_sz = PKT_BUF_SZ;
1730 if (!device_init_rings(pDevice)) {
1733 //2008-5-13 <add> by chester
1734 i = request_irq(pDevice->pcid->irq, &device_intr, IRQF_SHARED, dev->name, dev);
1738 #ifdef WPA_SM_Transtatus
1739 memset(wpa_Result.ifname, 0, sizeof(wpa_Result.ifname));
1740 wpa_Result.proto = 0;
1741 wpa_Result.key_mgmt = 0;
1742 wpa_Result.eap_type = 0;
1743 wpa_Result.authenticated = false;
1744 pDevice->fWPA_Authened = false;
1746 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device init rd0 ring\n");
1747 device_init_rd0_ring(pDevice);
1748 device_init_rd1_ring(pDevice);
1749 device_init_defrag_cb(pDevice);
1750 device_init_td0_ring(pDevice);
1751 device_init_td1_ring(pDevice);
1752 // VNTWIFIvSet11h(pDevice->pMgmt, pDevice->b11hEnable);
1754 if (pDevice->bDiversityRegCtlON) {
1755 device_init_diversity_timer(pDevice);
1757 vMgrObjectInit(pDevice);
1758 vMgrTimerInit(pDevice);
1762 tasklet_init(&pDevice->RxMngWorkItem, (void *)MngWorkItem, (unsigned long)pDevice);
1765 InitRxManagementQueue(pDevice);
1767 mlme_task = kthread_run(MlmeThread, (void *)pDevice, "MLME");
1768 if (IS_ERR(mlme_task)) {
1769 printk("thread create fail\n");
1776 //wait_for_completion(&pDevice->notify);
1778 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device_init_registers\n");
1779 device_init_registers(pDevice, DEVICE_INIT_COLD);
1780 MACvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr);
1781 memcpy(pDevice->pMgmt->abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1782 device_set_multi(pDevice->dev);
1784 // Init for Key Management
1785 KeyvInitTable(&pDevice->sKey, pDevice->PortOffset);
1786 add_timer(&(pDevice->pMgmt->sTimerSecondCallback));
1788 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1790 pDevice->bwextstep0 = false;
1791 pDevice->bwextstep1 = false;
1792 pDevice->bwextstep2 = false;
1793 pDevice->bwextstep3 = false;
1795 pDevice->bwextcount = 0;
1796 pDevice->bWPASuppWextEnabled = false;
1798 pDevice->byReAssocCount = 0;
1799 pDevice->bWPADEVUp = false;
1800 // Patch: if WEP key already set by iwconfig but device not yet open
1801 if (pDevice->bEncryptionEnable && pDevice->bTransmitKey) {
1802 KeybSetDefaultKey(&(pDevice->sKey),
1803 (unsigned long)(pDevice->byKeyIndex | (1 << 31)),
1804 pDevice->uKeyLength,
1808 pDevice->PortOffset,
1811 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1814 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call MACvIntEnable\n");
1815 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
1817 if (pDevice->pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1818 bScheduleCommand((void *)pDevice, WLAN_CMD_RUN_AP, NULL);
1820 bScheduleCommand((void *)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1821 bScheduleCommand((void *)pDevice, WLAN_CMD_SSID, NULL);
1823 pDevice->flags |= DEVICE_FLAGS_OPENED;
1825 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1829 static int device_close(struct net_device *dev) {
1830 PSDevice pDevice = (PSDevice)netdev_priv(dev);
1831 PSMgmtObject pMgmt = pDevice->pMgmt;
1837 //2007-1121-02<Add>by EinsnLiu
1838 if (pDevice->bLinkPass) {
1839 bScheduleCommand((void *)pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1843 del_timer(&pDevice->sTimerTxData);
1845 del_timer(&pDevice->sTimerCommand);
1846 del_timer(&pMgmt->sTimerSecondCallback);
1847 if (pDevice->bDiversityRegCtlON) {
1848 del_timer(&pDevice->TimerSQ3Tmax1);
1849 del_timer(&pDevice->TimerSQ3Tmax2);
1850 del_timer(&pDevice->TimerSQ3Tmax3);
1854 tasklet_kill(&pDevice->RxMngWorkItem);
1856 netif_stop_queue(dev);
1857 pDevice->bCmdRunning = false;
1858 MACbShutdown(pDevice->PortOffset);
1859 MACbSoftwareReset(pDevice->PortOffset);
1860 CARDbRadioPowerOff(pDevice);
1862 pDevice->bLinkPass = false;
1863 memset(pMgmt->abyCurrBSSID, 0, 6);
1864 pMgmt->eCurrState = WMAC_STATE_IDLE;
1865 device_free_td0_ring(pDevice);
1866 device_free_td1_ring(pDevice);
1867 device_free_rd0_ring(pDevice);
1868 device_free_rd1_ring(pDevice);
1869 device_free_frag_buf(pDevice);
1870 device_free_rings(pDevice);
1871 BSSvClearNodeDBTable(pDevice, 0);
1872 free_irq(dev->irq, dev);
1873 pDevice->flags &= (~DEVICE_FLAGS_OPENED);
1874 //2008-0714-01<Add>by chester
1875 device_release_WPADEV(pDevice);
1877 //tasklet_kill(&pDevice->RxMngWorkItem);
1879 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close.. \n");
1883 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev) {
1884 PSDevice pDevice = netdev_priv(dev);
1885 unsigned char *pbMPDU;
1886 unsigned int cbMPDULen = 0;
1888 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211\n");
1889 spin_lock_irq(&pDevice->lock);
1891 if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) {
1892 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211, td0 <=0\n");
1893 dev_kfree_skb_irq(skb);
1894 spin_unlock_irq(&pDevice->lock);
1898 if (pDevice->bStopTx0Pkt) {
1899 dev_kfree_skb_irq(skb);
1900 spin_unlock_irq(&pDevice->lock);
1904 cbMPDULen = skb->len;
1907 vDMA0_tx_80211(pDevice, skb, pbMPDU, cbMPDULen);
1909 spin_unlock_irq(&pDevice->lock);
1914 bool device_dma0_xmit(PSDevice pDevice, struct sk_buff *skb, unsigned int uNodeIndex) {
1915 PSMgmtObject pMgmt = pDevice->pMgmt;
1916 PSTxDesc pHeadTD, pLastTD;
1917 unsigned int cbFrameBodySize;
1918 unsigned int uMACfragNum;
1919 unsigned char byPktType;
1920 bool bNeedEncryption = false;
1921 PSKeyItem pTransmitKey = NULL;
1922 unsigned int cbHeaderSize;
1925 // unsigned char byKeyIndex = 0;
1927 if (pDevice->bStopTx0Pkt) {
1928 dev_kfree_skb_irq(skb);
1932 if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) {
1933 dev_kfree_skb_irq(skb);
1934 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, td0 <=0\n");
1938 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
1939 if (pDevice->uAssocCount == 0) {
1940 dev_kfree_skb_irq(skb);
1941 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, assocCount = 0\n");
1946 pHeadTD = pDevice->apCurrTD[TYPE_TXDMA0];
1948 pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
1950 memcpy(pDevice->sTxEthHeader.abyDstAddr, (unsigned char *)(skb->data), ETH_HLEN);
1951 cbFrameBodySize = skb->len - ETH_HLEN;
1954 if (ntohs(pDevice->sTxEthHeader.wType) > ETH_DATA_LEN) {
1955 cbFrameBodySize += 8;
1957 uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
1959 if (uMACfragNum > AVAIL_TD(pDevice, TYPE_TXDMA0)) {
1960 dev_kfree_skb_irq(skb);
1963 byPktType = (unsigned char)pDevice->byPacketType;
1965 if (pDevice->bFixRate) {
1966 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
1967 if (pDevice->uConnectionRate >= RATE_11M) {
1968 pDevice->wCurrentRate = RATE_11M;
1970 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
1973 if (pDevice->uConnectionRate >= RATE_54M)
1974 pDevice->wCurrentRate = RATE_54M;
1976 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
1979 pDevice->wCurrentRate = pDevice->pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
1983 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
1984 pDevice->byPreambleType = pDevice->byShortPreamble;
1986 pDevice->byPreambleType = PREAMBLE_LONG;
1989 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate);
1991 if (pDevice->wCurrentRate <= RATE_11M) {
1992 byPktType = PK_TYPE_11B;
1993 } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
1994 byPktType = PK_TYPE_11A;
1996 if (pDevice->bProtectMode) {
1997 byPktType = PK_TYPE_11GB;
1999 byPktType = PK_TYPE_11GA;
2003 if (pDevice->bEncryptionEnable)
2004 bNeedEncryption = true;
2006 if (pDevice->bEnableHostWEP) {
2007 pTransmitKey = &STempKey;
2008 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2009 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2010 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2011 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2012 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2013 memcpy(pTransmitKey->abyKey,
2014 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2015 pTransmitKey->uKeyLength
2018 vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption,
2019 cbFrameBodySize, TYPE_TXDMA0, pHeadTD,
2020 &pDevice->sTxEthHeader, (unsigned char *)skb->data, pTransmitKey, uNodeIndex,
2025 if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
2027 MACbPSWakeup(pDevice->PortOffset);
2030 pDevice->bPWBitOn = false;
2033 for (ii = 0; ii < uMACfragNum; ii++) {
2034 // Poll Transmit the adapter
2036 pHeadTD->m_td0TD0.f1Owner = OWNED_BY_NIC;
2038 if (ii == (uMACfragNum - 1))
2040 pHeadTD = pHeadTD->next;
2043 // Save the information needed by the tx interrupt handler
2044 // to complete the Send request
2045 pLastTD->pTDInfo->skb = skb;
2046 pLastTD->pTDInfo->byFlags = 0;
2047 pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
2049 pDevice->apCurrTD[TYPE_TXDMA0] = pHeadTD;
2051 MACvTransmit0(pDevice->PortOffset);
2056 //TYPE_AC0DMA data tx
2057 static int device_xmit(struct sk_buff *skb, struct net_device *dev) {
2058 PSDevice pDevice = netdev_priv(dev);
2060 PSMgmtObject pMgmt = pDevice->pMgmt;
2061 PSTxDesc pHeadTD, pLastTD;
2062 unsigned int uNodeIndex = 0;
2063 unsigned char byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
2064 unsigned short wAID;
2065 unsigned int uMACfragNum = 1;
2066 unsigned int cbFrameBodySize;
2067 unsigned char byPktType;
2068 unsigned int cbHeaderSize;
2069 bool bNeedEncryption = false;
2070 PSKeyItem pTransmitKey = NULL;
2073 bool bTKIP_UseGTK = false;
2074 bool bNeedDeAuth = false;
2075 unsigned char *pbyBSSID;
2076 bool bNodeExist = false;
2078 spin_lock_irq(&pDevice->lock);
2079 if (!pDevice->bLinkPass) {
2080 dev_kfree_skb_irq(skb);
2081 spin_unlock_irq(&pDevice->lock);
2085 if (pDevice->bStopDataPkt) {
2086 dev_kfree_skb_irq(skb);
2087 spin_unlock_irq(&pDevice->lock);
2091 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2092 if (pDevice->uAssocCount == 0) {
2093 dev_kfree_skb_irq(skb);
2094 spin_unlock_irq(&pDevice->lock);
2097 if (is_multicast_ether_addr((unsigned char *)(skb->data))) {
2100 if (pMgmt->sNodeDBTable[0].bPSEnable) {
2101 skb_queue_tail(&(pMgmt->sNodeDBTable[0].sTxPSQueue), skb);
2102 pMgmt->sNodeDBTable[0].wEnQueueCnt++;
2104 pMgmt->abyPSTxMap[0] |= byMask[0];
2105 spin_unlock_irq(&pDevice->lock);
2109 if (BSSDBbIsSTAInNodeDB(pMgmt, (unsigned char *)(skb->data), &uNodeIndex)) {
2110 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
2111 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
2112 pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
2114 wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
2115 pMgmt->abyPSTxMap[wAID >> 3] |= byMask[wAID & 7];
2116 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set:pMgmt->abyPSTxMap[%d]= %d\n",
2117 (wAID >> 3), pMgmt->abyPSTxMap[wAID >> 3]);
2118 spin_unlock_irq(&pDevice->lock);
2122 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2123 pDevice->byPreambleType = pDevice->byShortPreamble;
2126 pDevice->byPreambleType = PREAMBLE_LONG;
2134 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "Unknown STA not found in node DB \n");
2135 dev_kfree_skb_irq(skb);
2136 spin_unlock_irq(&pDevice->lock);
2141 pHeadTD = pDevice->apCurrTD[TYPE_AC0DMA];
2143 pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
2145 memcpy(pDevice->sTxEthHeader.abyDstAddr, (unsigned char *)(skb->data), ETH_HLEN);
2146 cbFrameBodySize = skb->len - ETH_HLEN;
2148 if (ntohs(pDevice->sTxEthHeader.wType) > ETH_DATA_LEN) {
2149 cbFrameBodySize += 8;
2152 if (pDevice->bEncryptionEnable) {
2153 bNeedEncryption = true;
2156 if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
2157 (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2158 pbyBSSID = pDevice->abyBSSID;
2160 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == false) {
2162 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == true) {
2163 bTKIP_UseGTK = true;
2164 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "Get GTK.\n");
2168 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "Get PTK.\n");
2171 } else if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2172 pbyBSSID = pDevice->sTxEthHeader.abyDstAddr; //TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1
2173 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "IBSS Serach Key: \n");
2174 for (ii = 0; ii < 6; ii++)
2175 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "%x \n", *(pbyBSSID+ii));
2176 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "\n");
2179 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == true)
2183 pbyBSSID = pDevice->abyBroadcastAddr;
2184 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == false) {
2185 pTransmitKey = NULL;
2186 if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2187 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode);
2189 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "NOT IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode);
2191 bTKIP_UseGTK = true;
2192 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "Get GTK.\n");
2197 if (pDevice->bEnableHostWEP) {
2198 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "acdma0: STA index %d\n", uNodeIndex);
2199 if (pDevice->bEncryptionEnable) {
2200 pTransmitKey = &STempKey;
2201 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2202 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2203 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2204 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2205 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2206 memcpy(pTransmitKey->abyKey,
2207 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2208 pTransmitKey->uKeyLength
2213 uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
2215 if (uMACfragNum > AVAIL_TD(pDevice, TYPE_AC0DMA)) {
2216 DBG_PRT(MSG_LEVEL_ERR, KERN_DEBUG "uMACfragNum > AVAIL_TD(TYPE_AC0DMA) = %d\n", uMACfragNum);
2217 dev_kfree_skb_irq(skb);
2218 spin_unlock_irq(&pDevice->lock);
2222 if (pTransmitKey != NULL) {
2223 if ((pTransmitKey->byCipherSuite == KEY_CTL_WEP) &&
2224 (pTransmitKey->uKeyLength == WLAN_WEP232_KEYLEN)) {
2225 uMACfragNum = 1; //WEP256 doesn't support fragment
2229 byPktType = (unsigned char)pDevice->byPacketType;
2231 if (pDevice->bFixRate) {
2233 printk("Fix Rate: PhyType is %d,ConnectionRate is %d\n", pDevice->eCurrentPHYType, pDevice->uConnectionRate);
2236 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
2237 if (pDevice->uConnectionRate >= RATE_11M) {
2238 pDevice->wCurrentRate = RATE_11M;
2240 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
2243 if ((pDevice->eCurrentPHYType == PHY_TYPE_11A) &&
2244 (pDevice->uConnectionRate <= RATE_6M)) {
2245 pDevice->wCurrentRate = RATE_6M;
2247 if (pDevice->uConnectionRate >= RATE_54M)
2248 pDevice->wCurrentRate = RATE_54M;
2250 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
2254 pDevice->byACKRate = (unsigned char) pDevice->wCurrentRate;
2255 pDevice->byTopCCKBasicRate = RATE_1M;
2256 pDevice->byTopOFDMBasicRate = RATE_6M;
2259 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
2260 if (pDevice->eCurrentPHYType != PHY_TYPE_11A) {
2261 pDevice->wCurrentRate = RATE_1M;
2262 pDevice->byACKRate = RATE_1M;
2263 pDevice->byTopCCKBasicRate = RATE_1M;
2264 pDevice->byTopOFDMBasicRate = RATE_6M;
2266 pDevice->wCurrentRate = RATE_6M;
2267 pDevice->byACKRate = RATE_6M;
2268 pDevice->byTopCCKBasicRate = RATE_1M;
2269 pDevice->byTopOFDMBasicRate = RATE_6M;
2272 VNTWIFIvGetTxRate(pDevice->pMgmt,
2273 pDevice->sTxEthHeader.abyDstAddr,
2274 &(pDevice->wCurrentRate),
2275 &(pDevice->byACKRate),
2276 &(pDevice->byTopCCKBasicRate),
2277 &(pDevice->byTopOFDMBasicRate));
2282 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate);
2284 if (pDevice->wCurrentRate <= RATE_11M) {
2285 byPktType = PK_TYPE_11B;
2286 } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
2287 byPktType = PK_TYPE_11A;
2289 if (pDevice->bProtectMode) {
2290 byPktType = PK_TYPE_11GB;
2292 byPktType = PK_TYPE_11GA;
2296 //#ifdef PLICE_DEBUG
2297 // printk("FIX RATE:CurrentRate is %d");
2300 if (bNeedEncryption) {
2301 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "ntohs Pkt Type=%04x\n", ntohs(pDevice->sTxEthHeader.wType));
2302 if ((pDevice->sTxEthHeader.wType) == TYPE_PKT_802_1x) {
2303 bNeedEncryption = false;
2304 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pkt Type=%04x\n", (pDevice->sTxEthHeader.wType));
2305 if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2306 if (pTransmitKey == NULL) {
2307 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Don't Find TX KEY\n");
2310 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "error: KEY is GTK!!~~\n");
2312 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
2313 bNeedEncryption = true;
2318 if (pDevice->byCntMeasure == 2) {
2320 pDevice->s802_11Counter.TKIPCounterMeasuresInvoked++;
2323 if (pDevice->bEnableHostWEP) {
2324 if ((uNodeIndex != 0) &&
2325 (pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex & PAIRWISE_KEY)) {
2326 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
2327 bNeedEncryption = true;
2331 if (pTransmitKey == NULL) {
2332 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return no tx key\n");
2333 dev_kfree_skb_irq(skb);
2334 spin_unlock_irq(&pDevice->lock);
2340 vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption,
2341 cbFrameBodySize, TYPE_AC0DMA, pHeadTD,
2342 &pDevice->sTxEthHeader, (unsigned char *)skb->data, pTransmitKey, uNodeIndex,
2347 if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
2349 MACbPSWakeup(pDevice->PortOffset);
2351 pDevice->bPWBitOn = false;
2354 for (ii = 0; ii < uMACfragNum; ii++) {
2355 // Poll Transmit the adapter
2357 pHeadTD->m_td0TD0.f1Owner = OWNED_BY_NIC;
2359 if (ii == uMACfragNum - 1)
2361 pHeadTD = pHeadTD->next;
2364 // Save the information needed by the tx interrupt handler
2365 // to complete the Send request
2366 pLastTD->pTDInfo->skb = skb;
2367 pLastTD->pTDInfo->byFlags = 0;
2368 pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
2370 pDevice->nTxDataTimeCout = 0; //2008-8-21 chester <add> for send null packet
2372 if (AVAIL_TD(pDevice, TYPE_AC0DMA) <= 1) {
2373 netif_stop_queue(dev);
2376 pDevice->apCurrTD[TYPE_AC0DMA] = pHeadTD;
2377 //#ifdef PLICE_DEBUG
2378 if (pDevice->bFixRate) {
2379 printk("FixRate:Rate is %d,TxPower is %d\n", pDevice->wCurrentRate, pDevice->byCurPwr);
2385 unsigned char Protocol_Version; //802.1x Authentication
2386 unsigned char Packet_Type; //802.1x Authentication
2387 unsigned char Descriptor_type;
2388 unsigned short Key_info;
2389 bool bTxeapol_key = false;
2390 Protocol_Version = skb->data[ETH_HLEN];
2391 Packet_Type = skb->data[ETH_HLEN+1];
2392 Descriptor_type = skb->data[ETH_HLEN+1+1+2];
2393 Key_info = (skb->data[ETH_HLEN+1+1+2+1] << 8)|(skb->data[ETH_HLEN+1+1+2+2]);
2394 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
2395 if (((Protocol_Version == 1) || (Protocol_Version == 2)) &&
2396 (Packet_Type == 3)) { //802.1x OR eapol-key challenge frame transfer
2397 bTxeapol_key = true;
2398 if ((Descriptor_type == 254) || (Descriptor_type == 2)) { //WPA or RSN
2399 if (!(Key_info & BIT3) && //group-key challenge
2400 (Key_info & BIT8) && (Key_info & BIT9)) { //send 2/2 key
2401 pDevice->fWPA_Authened = true;
2402 if (Descriptor_type == 254)
2406 printk("Authentication completed!!\n");
2413 MACvTransmitAC0(pDevice->PortOffset);
2414 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0:pDevice->apCurrTD= %p\n", pHeadTD);
2416 dev->trans_start = jiffies;
2418 spin_unlock_irq(&pDevice->lock);
2422 static irqreturn_t device_intr(int irq, void *dev_instance) {
2423 struct net_device *dev = dev_instance;
2424 PSDevice pDevice = (PSDevice)netdev_priv(dev);
2427 unsigned long dwMIBCounter = 0;
2428 PSMgmtObject pMgmt = pDevice->pMgmt;
2429 unsigned char byOrgPageSel = 0;
2431 unsigned char byData = 0;
2433 // unsigned char byRSSI;
2435 MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr);
2437 if (pDevice->dwIsr == 0)
2438 return IRQ_RETVAL(handled);
2440 if (pDevice->dwIsr == 0xffffffff) {
2441 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dwIsr = 0xffff\n");
2442 return IRQ_RETVAL(handled);
2445 // 2008-05-21 <mark> by Richardtai, we can't read RSSI here, because no packet bound with RSSI
2447 if ((pDevice->dwIsr & ISR_RXDMA0) &&
2448 (pDevice->byLocalID != REV_ID_VT3253_B0) &&
2449 (pDevice->bBSSIDFilter == true)) {
2451 //BBbReadEmbedded(pDevice->PortOffset, 0x3E, &byRSSI);
2452 //pDevice->uCurrRSSI = byRSSI;
2457 MACvIntDisable(pDevice->PortOffset);
2458 spin_lock_irq(&pDevice->lock);
2460 //Make sure current page is 0
2461 VNSvInPortB(pDevice->PortOffset + MAC_REG_PAGE1SEL, &byOrgPageSel);
2462 if (byOrgPageSel == 1) {
2463 MACvSelectPage0(pDevice->PortOffset);
2467 MACvReadMIBCounter(pDevice->PortOffset, &dwMIBCounter);
2469 // Must do this after doing rx/tx, cause ISR bit is slow
2470 // than RD/TD write back
2471 // update ISR counter
2472 STAvUpdate802_11Counter(&pDevice->s802_11Counter, &pDevice->scStatistic , dwMIBCounter);
2473 while (pDevice->dwIsr != 0) {
2474 STAvUpdateIsrStatCounter(&pDevice->scStatistic, pDevice->dwIsr);
2475 MACvWriteISR(pDevice->PortOffset, pDevice->dwIsr);
2477 if (pDevice->dwIsr & ISR_FETALERR) {
2478 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " ISR_FETALERR \n");
2479 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, 0);
2480 VNSvOutPortW(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPECTI);
2481 device_error(pDevice, pDevice->dwIsr);
2484 if (pDevice->byLocalID > REV_ID_VT3253_B1) {
2485 if (pDevice->dwIsr & ISR_MEASURESTART) {
2486 // 802.11h measure start
2487 pDevice->byOrgChannel = pDevice->byCurrentCh;
2488 VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byOrgRCR));
2489 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, (RCR_RXALLTYPE | RCR_UNICAST | RCR_BROADCAST | RCR_MULTICAST | RCR_WPAERR));
2490 MACvSelectPage1(pDevice->PortOffset);
2491 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR0, &(pDevice->dwOrgMAR0));
2492 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR4, &(pDevice->dwOrgMAR4));
2493 MACvSelectPage0(pDevice->PortOffset);
2495 // WCMDbFlushCommandQueue(pDevice->pMgmt, true);
2496 if (set_channel(pDevice, pDevice->pCurrMeasureEID->sReq.byChannel)) {
2497 pDevice->bMeasureInProgress = true;
2498 MACvSelectPage1(pDevice->PortOffset);
2499 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_READY);
2500 MACvSelectPage0(pDevice->PortOffset);
2501 pDevice->byBasicMap = 0;
2502 pDevice->byCCAFraction = 0;
2503 for (ii = 0; ii < 8; ii++) {
2504 pDevice->dwRPIs[ii] = 0;
2507 // can not measure because set channel fail
2508 // WCMDbResetCommandQueue(pDevice->pMgmt);
2509 // clear measure control
2510 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN);
2511 s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_INCAPABLE);
2512 MACvSelectPage1(pDevice->PortOffset);
2513 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2514 MACvSelectPage0(pDevice->PortOffset);
2517 if (pDevice->dwIsr & ISR_MEASUREEND) {
2518 // 802.11h measure end
2519 pDevice->bMeasureInProgress = false;
2520 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byOrgRCR);
2521 MACvSelectPage1(pDevice->PortOffset);
2522 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, pDevice->dwOrgMAR0);
2523 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR4, pDevice->dwOrgMAR4);
2524 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRBBSTS, &byData);
2525 pDevice->byBasicMap |= (byData >> 4);
2526 VNSvInPortB(pDevice->PortOffset + MAC_REG_CCAFRACTION, &pDevice->byCCAFraction);
2527 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRCTL, &byData);
2528 // clear measure control
2529 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN);
2530 MACvSelectPage0(pDevice->PortOffset);
2531 set_channel(pDevice, pDevice->byOrgChannel);
2532 // WCMDbResetCommandQueue(pDevice->pMgmt);
2533 MACvSelectPage1(pDevice->PortOffset);
2534 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2535 MACvSelectPage0(pDevice->PortOffset);
2536 if (byData & MSRCTL_FINISH) {
2538 s_vCompleteCurrentMeasure(pDevice, 0);
2540 // can not measure because not ready before end of measure time
2541 s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_LATE);
2544 if (pDevice->dwIsr & ISR_QUIETSTART) {
2547 } while (!CARDbStartQuiet(pDevice));
2551 if (pDevice->dwIsr & ISR_TBTT) {
2552 if (pDevice->bEnableFirstQuiet) {
2553 pDevice->byQuietStartCount--;
2554 if (pDevice->byQuietStartCount == 0) {
2555 pDevice->bEnableFirstQuiet = false;
2556 MACvSelectPage1(pDevice->PortOffset);
2557 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN));
2558 MACvSelectPage0(pDevice->PortOffset);
2561 if (pDevice->bChannelSwitch &&
2562 (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE)) {
2563 pDevice->byChannelSwitchCount--;
2564 if (pDevice->byChannelSwitchCount == 0) {
2565 pDevice->bChannelSwitch = false;
2566 set_channel(pDevice, pDevice->byNewChannel);
2567 VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel);
2568 MACvSelectPage1(pDevice->PortOffset);
2569 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2570 MACvSelectPage0(pDevice->PortOffset);
2571 CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL);
2575 if (pDevice->eOPMode == OP_MODE_ADHOC) {
2576 //pDevice->bBeaconSent = false;
2578 if ((pDevice->bUpdateBBVGA) && pDevice->bLinkPass && (pDevice->uCurrRSSI != 0)) {
2581 RFvRSSITodBm(pDevice, (unsigned char) pDevice->uCurrRSSI, &ldBm);
2582 for (ii = 0; ii < BB_VGA_LEVEL; ii++) {
2583 if (ldBm < pDevice->ldBmThreshold[ii]) {
2584 pDevice->byBBVGANew = pDevice->abyBBVGA[ii];
2588 if (pDevice->byBBVGANew != pDevice->byBBVGACurrent) {
2589 pDevice->uBBVGADiffCount++;
2590 if (pDevice->uBBVGADiffCount == 1) {
2591 // first VGA diff gain
2592 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew);
2593 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "First RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
2594 (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount);
2596 if (pDevice->uBBVGADiffCount >= BB_VGA_CHANGE_THRESHOLD) {
2597 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
2598 (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount);
2599 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew);
2602 pDevice->uBBVGADiffCount = 1;
2607 pDevice->bBeaconSent = false;
2608 if (pDevice->bEnablePSMode) {
2609 PSbIsNextTBTTWakeUp((void *)pDevice);
2612 if ((pDevice->eOPMode == OP_MODE_AP) ||
2613 (pDevice->eOPMode == OP_MODE_ADHOC)) {
2614 MACvOneShotTimer1MicroSec(pDevice->PortOffset,
2615 (pMgmt->wIBSSBeaconPeriod - MAKE_BEACON_RESERVED) << 10);
2618 if (pDevice->eOPMode == OP_MODE_ADHOC && pDevice->pMgmt->wCurrATIMWindow > 0) {
2619 // todo adhoc PS mode
2624 if (pDevice->dwIsr & ISR_BNTX) {
2625 if (pDevice->eOPMode == OP_MODE_ADHOC) {
2626 pDevice->bIsBeaconBufReadySet = false;
2627 pDevice->cbBeaconBufReadySetCnt = 0;
2630 if (pDevice->eOPMode == OP_MODE_AP) {
2631 if (pMgmt->byDTIMCount > 0) {
2632 pMgmt->byDTIMCount--;
2633 pMgmt->sNodeDBTable[0].bRxPSPoll = false;
2635 if (pMgmt->byDTIMCount == 0) {
2636 // check if mutltcast tx bufferring
2637 pMgmt->byDTIMCount = pMgmt->byDTIMPeriod - 1;
2638 pMgmt->sNodeDBTable[0].bRxPSPoll = true;
2639 bScheduleCommand((void *)pDevice, WLAN_CMD_RX_PSPOLL, NULL);
2643 pDevice->bBeaconSent = true;
2645 if (pDevice->bChannelSwitch) {
2646 pDevice->byChannelSwitchCount--;
2647 if (pDevice->byChannelSwitchCount == 0) {
2648 pDevice->bChannelSwitch = false;
2649 set_channel(pDevice, pDevice->byNewChannel);
2650 VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel);
2651 MACvSelectPage1(pDevice->PortOffset);
2652 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2653 MACvSelectPage0(pDevice->PortOffset);
2654 //VNTWIFIbSendBeacon(pDevice->pMgmt);
2655 CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL);
2661 if (pDevice->dwIsr & ISR_RXDMA0) {
2662 max_count += device_rx_srv(pDevice, TYPE_RXDMA0);
2664 if (pDevice->dwIsr & ISR_RXDMA1) {
2665 max_count += device_rx_srv(pDevice, TYPE_RXDMA1);
2667 if (pDevice->dwIsr & ISR_TXDMA0) {
2668 max_count += device_tx_srv(pDevice, TYPE_TXDMA0);
2670 if (pDevice->dwIsr & ISR_AC0DMA) {
2671 max_count += device_tx_srv(pDevice, TYPE_AC0DMA);
2673 if (pDevice->dwIsr & ISR_SOFTTIMER) {
2675 if (pDevice->dwIsr & ISR_SOFTTIMER1) {
2676 if (pDevice->eOPMode == OP_MODE_AP) {
2677 if (pDevice->bShortSlotTime)
2678 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTSLOTTIME(1);
2680 pMgmt->wCurrCapInfo &= ~(WLAN_SET_CAP_INFO_SHORTSLOTTIME(1));
2682 bMgrPrepareBeaconToSend(pDevice, pMgmt);
2683 pDevice->byCntMeasure = 0;
2686 MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr);
2688 MACvReceive0(pDevice->PortOffset);
2689 MACvReceive1(pDevice->PortOffset);
2691 if (max_count > pDevice->sOpts.int_works)
2695 if (byOrgPageSel == 1) {
2696 MACvSelectPage1(pDevice->PortOffset);
2699 spin_unlock_irq(&pDevice->lock);
2700 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
2702 return IRQ_RETVAL(handled);
2705 static unsigned const ethernet_polynomial = 0x04c11db7U;
2706 static inline u32 ether_crc(int length, unsigned char *data)
2710 while (--length >= 0) {
2711 unsigned char current_octet = *data++;
2713 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
2715 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
2721 //2008-8-4 <add> by chester
2722 static int Config_FileGetParameter(unsigned char *string,
2723 unsigned char *dest, unsigned char *source)
2725 unsigned char buf1[100];
2726 int source_len = strlen(source);
2728 memset(buf1, 0, 100);
2729 strcat(buf1, string);
2731 source += strlen(buf1);
2733 memcpy(dest, source, source_len - strlen(buf1));
2737 int Config_FileOperation(PSDevice pDevice,bool fwrite,unsigned char *Parameter)
2739 unsigned char *buffer = kmalloc(1024, GFP_KERNEL);
2740 unsigned char tmpbuffer[20];
2745 printk("allocate mem for file fail?\n");
2748 file = filp_open(CONFIG_PATH, O_RDONLY, 0);
2751 printk("Config_FileOperation:open file fail?\n");
2755 if (kernel_read(file, 0, buffer, 1024) < 0) {
2756 printk("read file error?\n");
2761 if (Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer)!=true) {
2762 printk("get parameter error?\n");
2767 if (memcmp(tmpbuffer,"USA",3)==0) {
2768 result = ZoneType_USA;
2769 } else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
2770 result = ZoneType_Japan;
2771 } else if(memcmp(tmpbuffer,"EUROPE",5)==0) {
2772 result = ZoneType_Europe;
2775 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
2784 static void device_set_multi(struct net_device *dev) {
2785 PSDevice pDevice = (PSDevice)netdev_priv(dev);
2787 PSMgmtObject pMgmt = pDevice->pMgmt;
2789 struct netdev_hw_addr *ha;
2791 VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byRxMode));
2793 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
2794 DBG_PRT(MSG_LEVEL_ERR, KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
2795 /* Unconditionally log net taps. */
2796 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
2797 } else if ((netdev_mc_count(dev) > pDevice->multicast_limit)
2798 || (dev->flags & IFF_ALLMULTI)) {
2799 MACvSelectPage1(pDevice->PortOffset);
2800 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, 0xffffffff);
2801 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, 0xffffffff);
2802 MACvSelectPage0(pDevice->PortOffset);
2803 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
2805 memset(mc_filter, 0, sizeof(mc_filter));
2806 netdev_for_each_mc_addr(ha, dev) {
2807 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
2808 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
2810 MACvSelectPage1(pDevice->PortOffset);
2811 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, mc_filter[0]);
2812 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, mc_filter[1]);
2813 MACvSelectPage0(pDevice->PortOffset);
2814 pDevice->byRxMode &= ~(RCR_UNICAST);
2815 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
2818 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2819 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
2820 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
2821 pDevice->byRxMode &= ~(RCR_UNICAST);
2824 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byRxMode);
2825 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode = %x\n", pDevice->byRxMode);
2828 static struct net_device_stats *device_get_stats(struct net_device *dev) {
2829 PSDevice pDevice = (PSDevice)netdev_priv(dev);
2831 return &pDevice->stats;
2834 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
2835 PSDevice pDevice = (PSDevice)netdev_priv(dev);
2837 struct iwreq *wrq = (struct iwreq *)rq;
2839 PSMgmtObject pMgmt = pDevice->pMgmt;
2842 if (pMgmt == NULL) {
2849 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
2852 case SIOCGIWNWID: //0x8b03 support
2856 // Set frequency/channel
2858 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
2861 // Get frequency/channel
2863 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
2866 // Set desired network name (ESSID)
2870 char essid[IW_ESSID_MAX_SIZE+1];
2871 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
2875 if (copy_from_user(essid, wrq->u.essid.pointer,
2876 wrq->u.essid.length)) {
2880 rc = iwctl_siwessid(dev, NULL,
2881 &(wrq->u.essid), essid);
2885 // Get current network name (ESSID)
2889 char essid[IW_ESSID_MAX_SIZE+1];
2890 if (wrq->u.essid.pointer)
2891 rc = iwctl_giwessid(dev, NULL,
2892 &(wrq->u.essid), essid);
2893 if (copy_to_user(wrq->u.essid.pointer,
2895 wrq->u.essid.length))
2902 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
2905 // Get current Access Point (BSSID)
2907 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
2910 // Set desired station name
2912 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
2916 // Get current station name
2918 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
2922 // Set the desired bit-rate
2924 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
2927 // Get the current bit-rate
2930 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
2933 // Set the desired RTS threshold
2936 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
2939 // Get the current RTS threshold
2942 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
2945 // Set the desired fragmentation threshold
2948 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
2951 // Get the current fragmentation threshold
2954 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
2957 // Set mode of operation
2959 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
2962 // Get mode of operation
2964 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
2967 // Set WEP keys and mode
2968 case SIOCSIWENCODE: {
2969 char abyKey[WLAN_WEP232_KEYLEN];
2971 if (wrq->u.encoding.pointer) {
2972 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
2976 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
2977 if (copy_from_user(abyKey,
2978 wrq->u.encoding.pointer,
2979 wrq->u.encoding.length)) {
2983 } else if (wrq->u.encoding.length != 0) {
2987 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
2991 // Get the WEP keys and mode
2994 if (!capable(CAP_NET_ADMIN)) {
2999 char abyKey[WLAN_WEP232_KEYLEN];
3001 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
3003 if (wrq->u.encoding.pointer) {
3004 if (copy_to_user(wrq->u.encoding.pointer,
3006 wrq->u.encoding.length))
3012 // Get the current Tx-Power
3014 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
3019 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWTXPOW \n");
3025 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
3030 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
3033 // Get range of parameters
3037 struct iw_range range;
3039 rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *)&range);
3040 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
3048 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
3053 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
3058 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
3062 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
3066 case SIOCGIWAPLIST: {
3067 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
3069 if (wrq->u.data.pointer) {
3070 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
3072 if (copy_to_user(wrq->u.data.pointer,
3074 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality)))
3086 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
3093 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWSPY \n");
3097 #endif // WIRELESS_SPY
3100 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
3103 if (wrq->u.data.pointer) {
3104 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof(iwctl_private_args[0]);
3106 if (copy_to_user(wrq->u.data.pointer,
3107 (u_char *) iwctl_private_args,
3108 sizeof(iwctl_private_args)))
3114 //2008-0409-07, <Add> by Einsn Liu
3115 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3117 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n");
3118 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
3122 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
3123 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
3127 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
3128 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3132 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
3133 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3136 case SIOCSIWENCODEEXT: {
3137 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
3138 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
3139 if (wrq->u.encoding.pointer) {
3140 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN + 1);
3141 if (wrq->u.encoding.length > (sizeof(struct iw_encode_ext) + MAX_KEY_LEN)) {
3145 if (copy_from_user(extra, wrq->u.encoding.pointer, wrq->u.encoding.length)) {
3149 } else if (wrq->u.encoding.length != 0) {
3153 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
3157 case SIOCGIWENCODEEXT:
3158 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
3159 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
3163 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
3164 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3167 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3168 //End Add -- //2008-0409-07, <Add> by Einsn Liu
3170 case IOCTL_CMD_TEST:
3172 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
3178 pReq = (PSCmdRequest)rq;
3179 pReq->wResult = MAGIC_CODE;
3185 if ((((PSCmdRequest)rq)->wCmdCode != WLAN_CMD_SET_EVT) &&
3186 !(pDevice->flags & DEVICE_FLAGS_OPENED))
3188 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
3189 (((PSCmdRequest)rq)->wCmdCode != WLAN_CMD_SET_WPA))
3198 if (test_and_set_bit(0, (void *)&(pMgmt->uCmdBusy))) {
3201 rc = private_ioctl(pDevice, rq);
3202 clear_bit(0, (void *)&(pMgmt->uCmdBusy));
3205 case IOCTL_CMD_HOSTAPD:
3207 rc = vt6655_hostap_ioctl(pDevice, &wrq->u.data);
3212 rc = wpa_ioctl(pDevice, &wrq->u.data);
3216 return ethtool_ioctl(dev, (void *)rq->ifr_data);
3217 // All other calls are currently unsupported
3221 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
3225 if (pDevice->bCommit) {
3226 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
3227 netif_stop_queue(pDevice->dev);
3228 spin_lock_irq(&pDevice->lock);
3229 bScheduleCommand((void *)pDevice, WLAN_CMD_RUN_AP, NULL);
3230 spin_unlock_irq(&pDevice->lock);
3232 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
3233 spin_lock_irq(&pDevice->lock);
3234 pDevice->bLinkPass = false;
3235 memset(pMgmt->abyCurrBSSID, 0, 6);
3236 pMgmt->eCurrState = WMAC_STATE_IDLE;
3237 netif_stop_queue(pDevice->dev);
3238 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3239 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
3240 if (!pDevice->bWPASuppWextEnabled)
3242 bScheduleCommand((void *)pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID);
3243 bScheduleCommand((void *)pDevice, WLAN_CMD_SSID, NULL);
3244 spin_unlock_irq(&pDevice->lock);
3246 pDevice->bCommit = false;
3252 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
3256 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd)))
3260 case ETHTOOL_GDRVINFO: {
3261 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
3262 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
3263 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
3264 if (copy_to_user(useraddr, &info, sizeof(info)))
3274 /*------------------------------------------------------------------*/
3276 MODULE_DEVICE_TABLE(pci, vt6655_pci_id_table);
3278 static struct pci_driver device_driver = {
3279 .name = DEVICE_NAME,
3280 .id_table = vt6655_pci_id_table,
3281 .probe = vt6655_probe,
3282 .remove = vt6655_remove,
3284 .suspend = viawget_suspend,
3285 .resume = viawget_resume,
3289 static int __init vt6655_init_module(void)
3293 // ret=pci_module_init(&device_driver);
3294 //ret = pcie_port_service_register(&device_driver);
3295 ret = pci_register_driver(&device_driver);
3298 register_reboot_notifier(&device_notifier);
3304 static void __exit vt6655_cleanup_module(void)
3307 unregister_reboot_notifier(&device_notifier);
3309 pci_unregister_driver(&device_driver);
3312 module_init(vt6655_init_module);
3313 module_exit(vt6655_cleanup_module);
3317 device_notify_reboot(struct notifier_block *nb, unsigned long event, void *p)
3319 struct pci_dev *pdev = NULL;
3324 for_each_pci_dev(pdev) {
3325 if (pci_dev_driver(pdev) == &device_driver) {
3326 if (pci_get_drvdata(pdev))
3327 viawget_suspend(pdev, PMSG_HIBERNATE);
3335 viawget_suspend(struct pci_dev *pcid, pm_message_t state)
3337 int power_status; // to silence the compiler
3339 PSDevice pDevice = pci_get_drvdata(pcid);
3340 PSMgmtObject pMgmt = pDevice->pMgmt;
3342 netif_stop_queue(pDevice->dev);
3343 spin_lock_irq(&pDevice->lock);
3344 pci_save_state(pcid);
3345 del_timer(&pDevice->sTimerCommand);
3346 del_timer(&pMgmt->sTimerSecondCallback);
3347 pDevice->cbFreeCmdQueue = CMD_Q_SIZE;
3348 pDevice->uCmdDequeueIdx = 0;
3349 pDevice->uCmdEnqueueIdx = 0;
3350 pDevice->bCmdRunning = false;
3351 MACbShutdown(pDevice->PortOffset);
3352 MACvSaveContext(pDevice->PortOffset, pDevice->abyMacContext);
3353 pDevice->bLinkPass = false;
3354 memset(pMgmt->abyCurrBSSID, 0, 6);
3355 pMgmt->eCurrState = WMAC_STATE_IDLE;
3356 pci_disable_device(pcid);
3357 power_status = pci_set_power_state(pcid, pci_choose_state(pcid, state));
3358 spin_unlock_irq(&pDevice->lock);
3363 viawget_resume(struct pci_dev *pcid)
3365 PSDevice pDevice = pci_get_drvdata(pcid);
3366 PSMgmtObject pMgmt = pDevice->pMgmt;
3367 int power_status; // to silence the compiler
3369 power_status = pci_set_power_state(pcid, PCI_D0);
3370 power_status = pci_enable_wake(pcid, PCI_D0, 0);
3371 pci_restore_state(pcid);
3372 if (netif_running(pDevice->dev)) {
3373 spin_lock_irq(&pDevice->lock);
3374 MACvRestoreContext(pDevice->PortOffset, pDevice->abyMacContext);
3375 device_init_registers(pDevice, DEVICE_INIT_DXPL);
3376 if (pMgmt->sNodeDBTable[0].bActive) { // Assoc with BSS
3377 pMgmt->sNodeDBTable[0].bActive = false;
3378 pDevice->bLinkPass = false;
3379 if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
3380 // In Adhoc, BSS state set back to started.
3381 pMgmt->eCurrState = WMAC_STATE_STARTED;
3383 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
3384 pMgmt->eCurrState = WMAC_STATE_IDLE;
3387 init_timer(&pMgmt->sTimerSecondCallback);
3388 init_timer(&pDevice->sTimerCommand);
3389 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
3390 BSSvClearBSSList((void *)pDevice, pDevice->bLinkPass);
3391 bScheduleCommand((void *)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
3392 bScheduleCommand((void *)pDevice, WLAN_CMD_SSID, NULL);
3393 spin_unlock_irq(&pDevice->lock);