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 DEFINE_PCI_DEVICE_TABLE(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 == true)
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 == true)
582 pDevice->byRxAntennaMode = ANT_B;
584 pDevice->byRxAntennaMode = ANT_A;
586 pDevice->byTxAntennaMode = ANT_B;
587 if (pDevice->bTxRxAntInv == true)
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 == false) {
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 == true)) {
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 == true) || (pDevice->bRadioControlOff == true)) {
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 == true) {
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 == true)) {
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) == false) {
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);
1157 if (pDevice->pcid) {
1158 pci_set_drvdata(pDevice->pcid, NULL);
1162 static bool device_init_rings(PSDevice pDevice) {
1165 /*allocate all RD/TD rings a single pool*/
1166 vir_pool = pci_alloc_consistent(pDevice->pcid,
1167 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1168 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1169 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1170 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc),
1171 &pDevice->pool_dma);
1173 if (vir_pool == NULL) {
1174 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s : allocate desc dma memory failed\n", pDevice->dev->name);
1179 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1180 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1181 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1182 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc)
1185 pDevice->aRD0Ring = vir_pool;
1186 pDevice->aRD1Ring = vir_pool +
1187 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1189 pDevice->rd0_pool_dma = pDevice->pool_dma;
1190 pDevice->rd1_pool_dma = pDevice->rd0_pool_dma +
1191 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1193 pDevice->tx0_bufs = pci_alloc_consistent(pDevice->pcid,
1194 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1195 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1196 CB_BEACON_BUF_SIZE +
1198 &pDevice->tx_bufs_dma0);
1200 if (pDevice->tx0_bufs == NULL) {
1201 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s: allocate buf dma memory failed\n", pDevice->dev->name);
1202 pci_free_consistent(pDevice->pcid,
1203 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1204 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1205 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1206 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc),
1207 vir_pool, pDevice->pool_dma
1212 memset(pDevice->tx0_bufs, 0,
1213 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1214 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1215 CB_BEACON_BUF_SIZE +
1219 pDevice->td0_pool_dma = pDevice->rd1_pool_dma +
1220 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1222 pDevice->td1_pool_dma = pDevice->td0_pool_dma +
1223 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1225 // vir_pool: pvoid type
1226 pDevice->apTD0Rings = vir_pool
1227 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1228 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1230 pDevice->apTD1Rings = vir_pool
1231 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1232 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc)
1233 + pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1235 pDevice->tx1_bufs = pDevice->tx0_bufs +
1236 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1238 pDevice->tx_beacon_bufs = pDevice->tx1_bufs +
1239 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1241 pDevice->pbyTmpBuff = pDevice->tx_beacon_bufs +
1244 pDevice->tx_bufs_dma1 = pDevice->tx_bufs_dma0 +
1245 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1247 pDevice->tx_beacon_dma = pDevice->tx_bufs_dma1 +
1248 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1253 static void device_free_rings(PSDevice pDevice) {
1254 pci_free_consistent(pDevice->pcid,
1255 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1256 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1257 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1258 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc)
1260 pDevice->aRD0Ring, pDevice->pool_dma
1263 if (pDevice->tx0_bufs)
1264 pci_free_consistent(pDevice->pcid,
1265 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1266 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1267 CB_BEACON_BUF_SIZE +
1269 pDevice->tx0_bufs, pDevice->tx_bufs_dma0
1273 static void device_init_rd0_ring(PSDevice pDevice) {
1275 dma_addr_t curr = pDevice->rd0_pool_dma;
1278 /* Init the RD0 ring entries */
1279 for (i = 0; i < pDevice->sOpts.nRxDescs0; i ++, curr += sizeof(SRxDesc)) {
1280 pDesc = &(pDevice->aRD0Ring[i]);
1281 pDesc->pRDInfo = alloc_rd_info();
1282 ASSERT(pDesc->pRDInfo);
1283 if (!device_alloc_rx_buf(pDevice, pDesc)) {
1284 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s: can not alloc rx bufs\n",
1285 pDevice->dev->name);
1287 pDesc->next = &(pDevice->aRD0Ring[(i+1) % pDevice->sOpts.nRxDescs0]);
1288 pDesc->pRDInfo->curr_desc = cpu_to_le32(curr);
1289 pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc));
1293 pDevice->aRD0Ring[i-1].next_desc = cpu_to_le32(pDevice->rd0_pool_dma);
1294 pDevice->pCurrRD[0] = &(pDevice->aRD0Ring[0]);
1297 static void device_init_rd1_ring(PSDevice pDevice) {
1299 dma_addr_t curr = pDevice->rd1_pool_dma;
1302 /* Init the RD1 ring entries */
1303 for (i = 0; i < pDevice->sOpts.nRxDescs1; i ++, curr += sizeof(SRxDesc)) {
1304 pDesc = &(pDevice->aRD1Ring[i]);
1305 pDesc->pRDInfo = alloc_rd_info();
1306 ASSERT(pDesc->pRDInfo);
1307 if (!device_alloc_rx_buf(pDevice, pDesc)) {
1308 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s: can not alloc rx bufs\n",
1309 pDevice->dev->name);
1311 pDesc->next = &(pDevice->aRD1Ring[(i+1) % pDevice->sOpts.nRxDescs1]);
1312 pDesc->pRDInfo->curr_desc = cpu_to_le32(curr);
1313 pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc));
1317 pDevice->aRD1Ring[i-1].next_desc = cpu_to_le32(pDevice->rd1_pool_dma);
1318 pDevice->pCurrRD[1] = &(pDevice->aRD1Ring[0]);
1321 static void device_init_defrag_cb(PSDevice pDevice) {
1323 PSDeFragControlBlock pDeF;
1325 /* Init the fragment ctl entries */
1326 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1327 pDeF = &(pDevice->sRxDFCB[i]);
1328 if (!device_alloc_frag_buf(pDevice, pDeF)) {
1329 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s: can not alloc frag bufs\n",
1330 pDevice->dev->name);
1333 pDevice->cbDFCB = CB_MAX_RX_FRAG;
1334 pDevice->cbFreeDFCB = pDevice->cbDFCB;
1337 static void device_free_rd0_ring(PSDevice pDevice) {
1340 for (i = 0; i < pDevice->sOpts.nRxDescs0; i++) {
1341 PSRxDesc pDesc = &(pDevice->aRD0Ring[i]);
1342 PDEVICE_RD_INFO pRDInfo = pDesc->pRDInfo;
1344 pci_unmap_single(pDevice->pcid, pRDInfo->skb_dma,
1345 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1347 dev_kfree_skb(pRDInfo->skb);
1349 kfree((void *)pDesc->pRDInfo);
1353 static void device_free_rd1_ring(PSDevice pDevice) {
1356 for (i = 0; i < pDevice->sOpts.nRxDescs1; i++) {
1357 PSRxDesc pDesc = &(pDevice->aRD1Ring[i]);
1358 PDEVICE_RD_INFO pRDInfo = pDesc->pRDInfo;
1360 pci_unmap_single(pDevice->pcid, pRDInfo->skb_dma,
1361 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1363 dev_kfree_skb(pRDInfo->skb);
1365 kfree((void *)pDesc->pRDInfo);
1369 static void device_free_frag_buf(PSDevice pDevice) {
1370 PSDeFragControlBlock pDeF;
1373 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1374 pDeF = &(pDevice->sRxDFCB[i]);
1377 dev_kfree_skb(pDeF->skb);
1382 static void device_init_td0_ring(PSDevice pDevice) {
1387 curr = pDevice->td0_pool_dma;
1388 for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++, curr += sizeof(STxDesc)) {
1389 pDesc = &(pDevice->apTD0Rings[i]);
1390 pDesc->pTDInfo = alloc_td_info();
1391 ASSERT(pDesc->pTDInfo);
1392 if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) {
1393 pDesc->pTDInfo->buf = pDevice->tx0_bufs + (i)*PKT_BUF_SZ;
1394 pDesc->pTDInfo->buf_dma = pDevice->tx_bufs_dma0 + (i)*PKT_BUF_SZ;
1396 pDesc->next = &(pDevice->apTD0Rings[(i+1) % pDevice->sOpts.nTxDescs[0]]);
1397 pDesc->pTDInfo->curr_desc = cpu_to_le32(curr);
1398 pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc));
1402 pDevice->apTD0Rings[i-1].next_desc = cpu_to_le32(pDevice->td0_pool_dma);
1403 pDevice->apTailTD[0] = pDevice->apCurrTD[0] = &(pDevice->apTD0Rings[0]);
1406 static void device_init_td1_ring(PSDevice pDevice) {
1411 /* Init the TD ring entries */
1412 curr = pDevice->td1_pool_dma;
1413 for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++, curr += sizeof(STxDesc)) {
1414 pDesc = &(pDevice->apTD1Rings[i]);
1415 pDesc->pTDInfo = alloc_td_info();
1416 ASSERT(pDesc->pTDInfo);
1417 if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) {
1418 pDesc->pTDInfo->buf = pDevice->tx1_bufs + (i) * PKT_BUF_SZ;
1419 pDesc->pTDInfo->buf_dma = pDevice->tx_bufs_dma1 + (i) * PKT_BUF_SZ;
1421 pDesc->next = &(pDevice->apTD1Rings[(i + 1) % pDevice->sOpts.nTxDescs[1]]);
1422 pDesc->pTDInfo->curr_desc = cpu_to_le32(curr);
1423 pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc));
1427 pDevice->apTD1Rings[i-1].next_desc = cpu_to_le32(pDevice->td1_pool_dma);
1428 pDevice->apTailTD[1] = pDevice->apCurrTD[1] = &(pDevice->apTD1Rings[0]);
1431 static void device_free_td0_ring(PSDevice pDevice) {
1433 for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++) {
1434 PSTxDesc pDesc = &(pDevice->apTD0Rings[i]);
1435 PDEVICE_TD_INFO pTDInfo = pDesc->pTDInfo;
1437 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma))
1438 pci_unmap_single(pDevice->pcid, pTDInfo->skb_dma,
1439 pTDInfo->skb->len, PCI_DMA_TODEVICE);
1442 dev_kfree_skb(pTDInfo->skb);
1444 kfree((void *)pDesc->pTDInfo);
1448 static void device_free_td1_ring(PSDevice pDevice) {
1451 for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++) {
1452 PSTxDesc pDesc = &(pDevice->apTD1Rings[i]);
1453 PDEVICE_TD_INFO pTDInfo = pDesc->pTDInfo;
1455 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma))
1456 pci_unmap_single(pDevice->pcid, pTDInfo->skb_dma,
1457 pTDInfo->skb->len, PCI_DMA_TODEVICE);
1460 dev_kfree_skb(pTDInfo->skb);
1462 kfree((void *)pDesc->pTDInfo);
1466 /*-----------------------------------------------------------------*/
1468 static int device_rx_srv(PSDevice pDevice, unsigned int uIdx) {
1472 for (pRD = pDevice->pCurrRD[uIdx];
1473 pRD->m_rd0RD0.f1Owner == OWNED_BY_HOST;
1475 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->pCurrRD = %x, works = %d\n", pRD, works);
1478 if (device_receive_frame(pDevice, pRD)) {
1479 if (!device_alloc_rx_buf(pDevice, pRD)) {
1480 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR
1481 "%s: can not allocate rx buf\n", pDevice->dev->name);
1485 pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1486 pDevice->dev->last_rx = jiffies;
1489 pDevice->pCurrRD[uIdx] = pRD;
1494 static bool device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pRD) {
1495 PDEVICE_RD_INFO pRDInfo = pRD->pRDInfo;
1497 pRDInfo->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1498 if (pRDInfo->skb == NULL)
1500 ASSERT(pRDInfo->skb);
1501 pRDInfo->skb->dev = pDevice->dev;
1502 pRDInfo->skb_dma = pci_map_single(pDevice->pcid, skb_tail_pointer(pRDInfo->skb),
1503 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1504 *((unsigned int *)&(pRD->m_rd0RD0)) = 0; /* FIX cast */
1506 pRD->m_rd0RD0.wResCount = cpu_to_le16(pDevice->rx_buf_sz);
1507 pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1508 pRD->m_rd1RD1.wReqCount = cpu_to_le16(pDevice->rx_buf_sz);
1509 pRD->buff_addr = cpu_to_le32(pRDInfo->skb_dma);
1514 bool device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1515 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1516 if (pDeF->skb == NULL)
1519 pDeF->skb->dev = pDevice->dev;
1524 static int device_tx_srv(PSDevice pDevice, unsigned int uIdx) {
1528 unsigned char byTsr0;
1529 unsigned char byTsr1;
1530 unsigned int uFrameSize, uFIFOHeaderSize;
1531 PSTxBufHead pTxBufHead;
1532 struct net_device_stats *pStats = &pDevice->stats;
1533 struct sk_buff *skb;
1534 unsigned int uNodeIndex;
1535 PSMgmtObject pMgmt = pDevice->pMgmt;
1537 for (pTD = pDevice->apTailTD[uIdx]; pDevice->iTDUsed[uIdx] > 0; pTD = pTD->next) {
1538 if (pTD->m_td0TD0.f1Owner == OWNED_BY_NIC)
1543 byTsr0 = pTD->m_td0TD0.byTSR0;
1544 byTsr1 = pTD->m_td0TD0.byTSR1;
1546 //Only the status of first TD in the chain is correct
1547 if (pTD->m_td1TD1.byTCR & TCR_STP) {
1548 if ((pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0) {
1549 uFIFOHeaderSize = pTD->pTDInfo->dwHeaderLength;
1550 uFrameSize = pTD->pTDInfo->dwReqCount - uFIFOHeaderSize;
1551 pTxBufHead = (PSTxBufHead) (pTD->pTDInfo->buf);
1552 // Update the statistics based on the Transmit status
1553 // now, we DONT check TSR0_CDH
1555 STAvUpdateTDStatCounter(&pDevice->scStatistic,
1557 (unsigned char *)(pTD->pTDInfo->buf + uFIFOHeaderSize),
1560 BSSvUpdateNodeTxCounter(pDevice,
1562 (unsigned char *)(pTD->pTDInfo->buf),
1566 if (!(byTsr1 & TSR1_TERR)) {
1568 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Tx[%d] OK but has error. tsr1[%02X] tsr0[%02X].\n",
1569 (int)uIdx, byTsr1, byTsr0);
1571 if ((pTxBufHead->wFragCtl & FRAGCTL_ENDFRAG) != FRAGCTL_NONFRAG) {
1572 pDevice->s802_11Counter.TransmittedFragmentCount++;
1574 pStats->tx_packets++;
1575 pStats->tx_bytes += pTD->pTDInfo->skb->len;
1577 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Tx[%d] dropped & tsr1[%02X] tsr0[%02X].\n",
1578 (int)uIdx, byTsr1, byTsr0);
1579 pStats->tx_errors++;
1580 pStats->tx_dropped++;
1584 if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
1585 if (pDevice->bEnableHostapd) {
1586 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx call back netif.. \n");
1587 skb = pTD->pTDInfo->skb;
1588 skb->dev = pDevice->apdev;
1589 skb_reset_mac_header(skb);
1590 skb->pkt_type = PACKET_OTHERHOST;
1591 //skb->protocol = htons(ETH_P_802_2);
1592 memset(skb->cb, 0, sizeof(skb->cb));
1597 if (byTsr1 & TSR1_TERR) {
1598 if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
1599 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
1600 (int)uIdx, byTsr1, byTsr0);
1603 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
1604 // (int)uIdx, byTsr1, byTsr0);
1606 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) &&
1607 (pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB)) {
1608 unsigned short wAID;
1609 unsigned char byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
1611 skb = pTD->pTDInfo->skb;
1612 if (BSSDBbIsSTAInNodeDB(pMgmt, (unsigned char *)(skb->data), &uNodeIndex)) {
1613 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
1614 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
1615 pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
1617 wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
1618 pMgmt->abyPSTxMap[wAID >> 3] |= byMask[wAID & 7];
1619 pTD->pTDInfo->byFlags &= ~(TD_FLAGS_NETIF_SKB);
1620 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx_srv:tx fail re-queue sta index= %d, QueCnt= %d\n"
1621 , (int)uNodeIndex, pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt);
1622 pStats->tx_errors--;
1623 pStats->tx_dropped--;
1628 device_free_tx_buf(pDevice, pTD);
1629 pDevice->iTDUsed[uIdx]--;
1633 if (uIdx == TYPE_AC0DMA) {
1634 // RESERV_AC0DMA reserved for relay
1636 if (AVAIL_TD(pDevice, uIdx) < RESERV_AC0DMA) {
1638 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " AC0DMA is Full = %d\n", pDevice->iTDUsed[uIdx]);
1640 if (netif_queue_stopped(pDevice->dev) && (bFull == false)) {
1641 netif_wake_queue(pDevice->dev);
1645 pDevice->apTailTD[uIdx] = pTD;
1650 static void device_error(PSDevice pDevice, unsigned short status) {
1651 if (status & ISR_FETALERR) {
1652 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR
1653 "%s: Hardware fatal error.\n",
1654 pDevice->dev->name);
1655 netif_stop_queue(pDevice->dev);
1656 del_timer(&pDevice->sTimerCommand);
1657 del_timer(&(pDevice->pMgmt->sTimerSecondCallback));
1658 pDevice->bCmdRunning = false;
1659 MACbShutdown(pDevice->PortOffset);
1664 static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc) {
1665 PDEVICE_TD_INFO pTDInfo = pDesc->pTDInfo;
1666 struct sk_buff *skb = pTDInfo->skb;
1668 // pre-allocated buf_dma can't be unmapped.
1669 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma)) {
1670 pci_unmap_single(pDevice->pcid, pTDInfo->skb_dma, skb->len,
1674 if ((pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0)
1675 dev_kfree_skb_irq(skb);
1677 pTDInfo->skb_dma = 0;
1679 pTDInfo->byFlags = 0;
1683 void InitRxManagementQueue(PSDevice pDevice)
1685 pDevice->rxManeQueue.packet_num = 0;
1686 pDevice->rxManeQueue.head = pDevice->rxManeQueue.tail = 0;
1694 PSDevice pDevice = (PSDevice) Context;
1695 PSRxMgmtPacket pRxMgmtPacket;
1697 //complete(&pDevice->notify);
1702 //down(&pDevice->mlme_semaphore);
1703 // pRxMgmtPacket = DeQueue(pDevice);
1705 spin_lock_irq(&pDevice->lock);
1706 while (pDevice->rxManeQueue.packet_num != 0) {
1707 pRxMgmtPacket = DeQueue(pDevice);
1709 //DequeueManageObject(pDevice->FirstRecvMngList, pDevice->LastRecvMngList);
1710 vMgrRxManagePacket(pDevice, pDevice->pMgmt, pRxMgmtPacket);
1712 spin_unlock_irq(&pDevice->lock);
1726 static int device_open(struct net_device *dev) {
1727 PSDevice pDevice = (PSDevice)netdev_priv(dev);
1729 #ifdef WPA_SM_Transtatus
1730 extern SWPAResult wpa_Result;
1733 pDevice->rx_buf_sz = PKT_BUF_SZ;
1734 if (!device_init_rings(pDevice)) {
1737 //2008-5-13 <add> by chester
1738 i = request_irq(pDevice->pcid->irq, &device_intr, IRQF_SHARED, dev->name, dev);
1742 #ifdef WPA_SM_Transtatus
1743 memset(wpa_Result.ifname, 0, sizeof(wpa_Result.ifname));
1744 wpa_Result.proto = 0;
1745 wpa_Result.key_mgmt = 0;
1746 wpa_Result.eap_type = 0;
1747 wpa_Result.authenticated = false;
1748 pDevice->fWPA_Authened = false;
1750 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device init rd0 ring\n");
1751 device_init_rd0_ring(pDevice);
1752 device_init_rd1_ring(pDevice);
1753 device_init_defrag_cb(pDevice);
1754 device_init_td0_ring(pDevice);
1755 device_init_td1_ring(pDevice);
1756 // VNTWIFIvSet11h(pDevice->pMgmt, pDevice->b11hEnable);
1758 if (pDevice->bDiversityRegCtlON) {
1759 device_init_diversity_timer(pDevice);
1761 vMgrObjectInit(pDevice);
1762 vMgrTimerInit(pDevice);
1766 tasklet_init(&pDevice->RxMngWorkItem, (void *)MngWorkItem, (unsigned long)pDevice);
1769 InitRxManagementQueue(pDevice);
1771 mlme_task = kthread_run(MlmeThread, (void *)pDevice, "MLME");
1772 if (IS_ERR(mlme_task)) {
1773 printk("thread create fail\n");
1780 //wait_for_completion(&pDevice->notify);
1782 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device_init_registers\n");
1783 device_init_registers(pDevice, DEVICE_INIT_COLD);
1784 MACvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr);
1785 memcpy(pDevice->pMgmt->abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1786 device_set_multi(pDevice->dev);
1788 // Init for Key Management
1789 KeyvInitTable(&pDevice->sKey, pDevice->PortOffset);
1790 add_timer(&(pDevice->pMgmt->sTimerSecondCallback));
1792 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1794 pDevice->bwextstep0 = false;
1795 pDevice->bwextstep1 = false;
1796 pDevice->bwextstep2 = false;
1797 pDevice->bwextstep3 = false;
1799 pDevice->bwextcount = 0;
1800 pDevice->bWPASuppWextEnabled = false;
1802 pDevice->byReAssocCount = 0;
1803 pDevice->bWPADEVUp = false;
1804 // Patch: if WEP key already set by iwconfig but device not yet open
1805 if ((pDevice->bEncryptionEnable == true) && (pDevice->bTransmitKey == true)) {
1806 KeybSetDefaultKey(&(pDevice->sKey),
1807 (unsigned long)(pDevice->byKeyIndex | (1 << 31)),
1808 pDevice->uKeyLength,
1812 pDevice->PortOffset,
1815 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1818 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call MACvIntEnable\n");
1819 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
1821 if (pDevice->pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1822 bScheduleCommand((void *)pDevice, WLAN_CMD_RUN_AP, NULL);
1824 bScheduleCommand((void *)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1825 bScheduleCommand((void *)pDevice, WLAN_CMD_SSID, NULL);
1827 pDevice->flags |= DEVICE_FLAGS_OPENED;
1829 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1833 static int device_close(struct net_device *dev) {
1834 PSDevice pDevice = (PSDevice)netdev_priv(dev);
1835 PSMgmtObject pMgmt = pDevice->pMgmt;
1841 //2007-1121-02<Add>by EinsnLiu
1842 if (pDevice->bLinkPass) {
1843 bScheduleCommand((void *)pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1847 del_timer(&pDevice->sTimerTxData);
1849 del_timer(&pDevice->sTimerCommand);
1850 del_timer(&pMgmt->sTimerSecondCallback);
1851 if (pDevice->bDiversityRegCtlON) {
1852 del_timer(&pDevice->TimerSQ3Tmax1);
1853 del_timer(&pDevice->TimerSQ3Tmax2);
1854 del_timer(&pDevice->TimerSQ3Tmax3);
1858 tasklet_kill(&pDevice->RxMngWorkItem);
1860 netif_stop_queue(dev);
1861 pDevice->bCmdRunning = false;
1862 MACbShutdown(pDevice->PortOffset);
1863 MACbSoftwareReset(pDevice->PortOffset);
1864 CARDbRadioPowerOff(pDevice);
1866 pDevice->bLinkPass = false;
1867 memset(pMgmt->abyCurrBSSID, 0, 6);
1868 pMgmt->eCurrState = WMAC_STATE_IDLE;
1869 device_free_td0_ring(pDevice);
1870 device_free_td1_ring(pDevice);
1871 device_free_rd0_ring(pDevice);
1872 device_free_rd1_ring(pDevice);
1873 device_free_frag_buf(pDevice);
1874 device_free_rings(pDevice);
1875 BSSvClearNodeDBTable(pDevice, 0);
1876 free_irq(dev->irq, dev);
1877 pDevice->flags &= (~DEVICE_FLAGS_OPENED);
1878 //2008-0714-01<Add>by chester
1879 device_release_WPADEV(pDevice);
1881 //tasklet_kill(&pDevice->RxMngWorkItem);
1883 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close.. \n");
1887 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev) {
1888 PSDevice pDevice = netdev_priv(dev);
1889 unsigned char *pbMPDU;
1890 unsigned int cbMPDULen = 0;
1892 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211\n");
1893 spin_lock_irq(&pDevice->lock);
1895 if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) {
1896 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211, td0 <=0\n");
1897 dev_kfree_skb_irq(skb);
1898 spin_unlock_irq(&pDevice->lock);
1902 if (pDevice->bStopTx0Pkt == true) {
1903 dev_kfree_skb_irq(skb);
1904 spin_unlock_irq(&pDevice->lock);
1908 cbMPDULen = skb->len;
1911 vDMA0_tx_80211(pDevice, skb, pbMPDU, cbMPDULen);
1913 spin_unlock_irq(&pDevice->lock);
1918 bool device_dma0_xmit(PSDevice pDevice, struct sk_buff *skb, unsigned int uNodeIndex) {
1919 PSMgmtObject pMgmt = pDevice->pMgmt;
1920 PSTxDesc pHeadTD, pLastTD;
1921 unsigned int cbFrameBodySize;
1922 unsigned int uMACfragNum;
1923 unsigned char byPktType;
1924 bool bNeedEncryption = false;
1925 PSKeyItem pTransmitKey = NULL;
1926 unsigned int cbHeaderSize;
1929 // unsigned char byKeyIndex = 0;
1931 if (pDevice->bStopTx0Pkt == true) {
1932 dev_kfree_skb_irq(skb);
1936 if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) {
1937 dev_kfree_skb_irq(skb);
1938 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, td0 <=0\n");
1942 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
1943 if (pDevice->uAssocCount == 0) {
1944 dev_kfree_skb_irq(skb);
1945 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, assocCount = 0\n");
1950 pHeadTD = pDevice->apCurrTD[TYPE_TXDMA0];
1952 pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
1954 memcpy(pDevice->sTxEthHeader.abyDstAddr, (unsigned char *)(skb->data), ETH_HLEN);
1955 cbFrameBodySize = skb->len - ETH_HLEN;
1958 if (ntohs(pDevice->sTxEthHeader.wType) > ETH_DATA_LEN) {
1959 cbFrameBodySize += 8;
1961 uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
1963 if (uMACfragNum > AVAIL_TD(pDevice, TYPE_TXDMA0)) {
1964 dev_kfree_skb_irq(skb);
1967 byPktType = (unsigned char)pDevice->byPacketType;
1969 if (pDevice->bFixRate) {
1970 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
1971 if (pDevice->uConnectionRate >= RATE_11M) {
1972 pDevice->wCurrentRate = RATE_11M;
1974 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
1977 if (pDevice->uConnectionRate >= RATE_54M)
1978 pDevice->wCurrentRate = RATE_54M;
1980 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
1983 pDevice->wCurrentRate = pDevice->pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
1987 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
1988 pDevice->byPreambleType = pDevice->byShortPreamble;
1990 pDevice->byPreambleType = PREAMBLE_LONG;
1993 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate);
1995 if (pDevice->wCurrentRate <= RATE_11M) {
1996 byPktType = PK_TYPE_11B;
1997 } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
1998 byPktType = PK_TYPE_11A;
2000 if (pDevice->bProtectMode == true) {
2001 byPktType = PK_TYPE_11GB;
2003 byPktType = PK_TYPE_11GA;
2007 if (pDevice->bEncryptionEnable == true)
2008 bNeedEncryption = true;
2010 if (pDevice->bEnableHostWEP) {
2011 pTransmitKey = &STempKey;
2012 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2013 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2014 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2015 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2016 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2017 memcpy(pTransmitKey->abyKey,
2018 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2019 pTransmitKey->uKeyLength
2022 vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption,
2023 cbFrameBodySize, TYPE_TXDMA0, pHeadTD,
2024 &pDevice->sTxEthHeader, (unsigned char *)skb->data, pTransmitKey, uNodeIndex,
2029 if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
2031 MACbPSWakeup(pDevice->PortOffset);
2034 pDevice->bPWBitOn = false;
2037 for (ii = 0; ii < uMACfragNum; ii++) {
2038 // Poll Transmit the adapter
2040 pHeadTD->m_td0TD0.f1Owner = OWNED_BY_NIC;
2042 if (ii == (uMACfragNum - 1))
2044 pHeadTD = pHeadTD->next;
2047 // Save the information needed by the tx interrupt handler
2048 // to complete the Send request
2049 pLastTD->pTDInfo->skb = skb;
2050 pLastTD->pTDInfo->byFlags = 0;
2051 pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
2053 pDevice->apCurrTD[TYPE_TXDMA0] = pHeadTD;
2055 MACvTransmit0(pDevice->PortOffset);
2060 //TYPE_AC0DMA data tx
2061 static int device_xmit(struct sk_buff *skb, struct net_device *dev) {
2062 PSDevice pDevice = netdev_priv(dev);
2064 PSMgmtObject pMgmt = pDevice->pMgmt;
2065 PSTxDesc pHeadTD, pLastTD;
2066 unsigned int uNodeIndex = 0;
2067 unsigned char byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
2068 unsigned short wAID;
2069 unsigned int uMACfragNum = 1;
2070 unsigned int cbFrameBodySize;
2071 unsigned char byPktType;
2072 unsigned int cbHeaderSize;
2073 bool bNeedEncryption = false;
2074 PSKeyItem pTransmitKey = NULL;
2077 bool bTKIP_UseGTK = false;
2078 bool bNeedDeAuth = false;
2079 unsigned char *pbyBSSID;
2080 bool bNodeExist = false;
2082 spin_lock_irq(&pDevice->lock);
2083 if (pDevice->bLinkPass == false) {
2084 dev_kfree_skb_irq(skb);
2085 spin_unlock_irq(&pDevice->lock);
2089 if (pDevice->bStopDataPkt) {
2090 dev_kfree_skb_irq(skb);
2091 spin_unlock_irq(&pDevice->lock);
2095 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2096 if (pDevice->uAssocCount == 0) {
2097 dev_kfree_skb_irq(skb);
2098 spin_unlock_irq(&pDevice->lock);
2101 if (is_multicast_ether_addr((unsigned char *)(skb->data))) {
2104 if (pMgmt->sNodeDBTable[0].bPSEnable) {
2105 skb_queue_tail(&(pMgmt->sNodeDBTable[0].sTxPSQueue), skb);
2106 pMgmt->sNodeDBTable[0].wEnQueueCnt++;
2108 pMgmt->abyPSTxMap[0] |= byMask[0];
2109 spin_unlock_irq(&pDevice->lock);
2113 if (BSSDBbIsSTAInNodeDB(pMgmt, (unsigned char *)(skb->data), &uNodeIndex)) {
2114 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
2115 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
2116 pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
2118 wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
2119 pMgmt->abyPSTxMap[wAID >> 3] |= byMask[wAID & 7];
2120 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set:pMgmt->abyPSTxMap[%d]= %d\n",
2121 (wAID >> 3), pMgmt->abyPSTxMap[wAID >> 3]);
2122 spin_unlock_irq(&pDevice->lock);
2126 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2127 pDevice->byPreambleType = pDevice->byShortPreamble;
2130 pDevice->byPreambleType = PREAMBLE_LONG;
2137 if (bNodeExist == false) {
2138 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "Unknown STA not found in node DB \n");
2139 dev_kfree_skb_irq(skb);
2140 spin_unlock_irq(&pDevice->lock);
2145 pHeadTD = pDevice->apCurrTD[TYPE_AC0DMA];
2147 pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
2149 memcpy(pDevice->sTxEthHeader.abyDstAddr, (unsigned char *)(skb->data), ETH_HLEN);
2150 cbFrameBodySize = skb->len - ETH_HLEN;
2152 if (ntohs(pDevice->sTxEthHeader.wType) > ETH_DATA_LEN) {
2153 cbFrameBodySize += 8;
2156 if (pDevice->bEncryptionEnable == true) {
2157 bNeedEncryption = true;
2160 if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
2161 (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2162 pbyBSSID = pDevice->abyBSSID;
2164 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == false) {
2166 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == true) {
2167 bTKIP_UseGTK = true;
2168 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "Get GTK.\n");
2172 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "Get PTK.\n");
2175 } else if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2176 pbyBSSID = pDevice->sTxEthHeader.abyDstAddr; //TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1
2177 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "IBSS Serach Key: \n");
2178 for (ii = 0; ii < 6; ii++)
2179 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "%x \n", *(pbyBSSID+ii));
2180 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "\n");
2183 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == true)
2187 pbyBSSID = pDevice->abyBroadcastAddr;
2188 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == false) {
2189 pTransmitKey = NULL;
2190 if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2191 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode);
2193 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "NOT IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode);
2195 bTKIP_UseGTK = true;
2196 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "Get GTK.\n");
2201 if (pDevice->bEnableHostWEP) {
2202 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "acdma0: STA index %d\n", uNodeIndex);
2203 if (pDevice->bEncryptionEnable == true) {
2204 pTransmitKey = &STempKey;
2205 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2206 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2207 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2208 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2209 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2210 memcpy(pTransmitKey->abyKey,
2211 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2212 pTransmitKey->uKeyLength
2217 uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
2219 if (uMACfragNum > AVAIL_TD(pDevice, TYPE_AC0DMA)) {
2220 DBG_PRT(MSG_LEVEL_ERR, KERN_DEBUG "uMACfragNum > AVAIL_TD(TYPE_AC0DMA) = %d\n", uMACfragNum);
2221 dev_kfree_skb_irq(skb);
2222 spin_unlock_irq(&pDevice->lock);
2226 if (pTransmitKey != NULL) {
2227 if ((pTransmitKey->byCipherSuite == KEY_CTL_WEP) &&
2228 (pTransmitKey->uKeyLength == WLAN_WEP232_KEYLEN)) {
2229 uMACfragNum = 1; //WEP256 doesn't support fragment
2233 byPktType = (unsigned char)pDevice->byPacketType;
2235 if (pDevice->bFixRate) {
2237 printk("Fix Rate: PhyType is %d,ConnectionRate is %d\n", pDevice->eCurrentPHYType, pDevice->uConnectionRate);
2240 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
2241 if (pDevice->uConnectionRate >= RATE_11M) {
2242 pDevice->wCurrentRate = RATE_11M;
2244 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
2247 if ((pDevice->eCurrentPHYType == PHY_TYPE_11A) &&
2248 (pDevice->uConnectionRate <= RATE_6M)) {
2249 pDevice->wCurrentRate = RATE_6M;
2251 if (pDevice->uConnectionRate >= RATE_54M)
2252 pDevice->wCurrentRate = RATE_54M;
2254 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
2258 pDevice->byACKRate = (unsigned char) pDevice->wCurrentRate;
2259 pDevice->byTopCCKBasicRate = RATE_1M;
2260 pDevice->byTopOFDMBasicRate = RATE_6M;
2263 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
2264 if (pDevice->eCurrentPHYType != PHY_TYPE_11A) {
2265 pDevice->wCurrentRate = RATE_1M;
2266 pDevice->byACKRate = RATE_1M;
2267 pDevice->byTopCCKBasicRate = RATE_1M;
2268 pDevice->byTopOFDMBasicRate = RATE_6M;
2270 pDevice->wCurrentRate = RATE_6M;
2271 pDevice->byACKRate = RATE_6M;
2272 pDevice->byTopCCKBasicRate = RATE_1M;
2273 pDevice->byTopOFDMBasicRate = RATE_6M;
2276 VNTWIFIvGetTxRate(pDevice->pMgmt,
2277 pDevice->sTxEthHeader.abyDstAddr,
2278 &(pDevice->wCurrentRate),
2279 &(pDevice->byACKRate),
2280 &(pDevice->byTopCCKBasicRate),
2281 &(pDevice->byTopOFDMBasicRate));
2286 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate);
2288 if (pDevice->wCurrentRate <= RATE_11M) {
2289 byPktType = PK_TYPE_11B;
2290 } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
2291 byPktType = PK_TYPE_11A;
2293 if (pDevice->bProtectMode == true) {
2294 byPktType = PK_TYPE_11GB;
2296 byPktType = PK_TYPE_11GA;
2300 //#ifdef PLICE_DEBUG
2301 // printk("FIX RATE:CurrentRate is %d");
2304 if (bNeedEncryption == true) {
2305 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "ntohs Pkt Type=%04x\n", ntohs(pDevice->sTxEthHeader.wType));
2306 if ((pDevice->sTxEthHeader.wType) == TYPE_PKT_802_1x) {
2307 bNeedEncryption = false;
2308 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Pkt Type=%04x\n", (pDevice->sTxEthHeader.wType));
2309 if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2310 if (pTransmitKey == NULL) {
2311 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Don't Find TX KEY\n");
2313 if (bTKIP_UseGTK == true) {
2314 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "error: KEY is GTK!!~~\n");
2316 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
2317 bNeedEncryption = true;
2322 if (pDevice->byCntMeasure == 2) {
2324 pDevice->s802_11Counter.TKIPCounterMeasuresInvoked++;
2327 if (pDevice->bEnableHostWEP) {
2328 if ((uNodeIndex != 0) &&
2329 (pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex & PAIRWISE_KEY)) {
2330 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
2331 bNeedEncryption = true;
2335 if (pTransmitKey == NULL) {
2336 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "return no tx key\n");
2337 dev_kfree_skb_irq(skb);
2338 spin_unlock_irq(&pDevice->lock);
2344 vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption,
2345 cbFrameBodySize, TYPE_AC0DMA, pHeadTD,
2346 &pDevice->sTxEthHeader, (unsigned char *)skb->data, pTransmitKey, uNodeIndex,
2351 if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
2353 MACbPSWakeup(pDevice->PortOffset);
2355 pDevice->bPWBitOn = false;
2358 for (ii = 0; ii < uMACfragNum; ii++) {
2359 // Poll Transmit the adapter
2361 pHeadTD->m_td0TD0.f1Owner = OWNED_BY_NIC;
2363 if (ii == uMACfragNum - 1)
2365 pHeadTD = pHeadTD->next;
2368 // Save the information needed by the tx interrupt handler
2369 // to complete the Send request
2370 pLastTD->pTDInfo->skb = skb;
2371 pLastTD->pTDInfo->byFlags = 0;
2372 pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
2374 pDevice->nTxDataTimeCout = 0; //2008-8-21 chester <add> for send null packet
2376 if (AVAIL_TD(pDevice, TYPE_AC0DMA) <= 1) {
2377 netif_stop_queue(dev);
2380 pDevice->apCurrTD[TYPE_AC0DMA] = pHeadTD;
2381 //#ifdef PLICE_DEBUG
2382 if (pDevice->bFixRate) {
2383 printk("FixRate:Rate is %d,TxPower is %d\n", pDevice->wCurrentRate, pDevice->byCurPwr);
2389 unsigned char Protocol_Version; //802.1x Authentication
2390 unsigned char Packet_Type; //802.1x Authentication
2391 unsigned char Descriptor_type;
2392 unsigned short Key_info;
2393 bool bTxeapol_key = false;
2394 Protocol_Version = skb->data[ETH_HLEN];
2395 Packet_Type = skb->data[ETH_HLEN+1];
2396 Descriptor_type = skb->data[ETH_HLEN+1+1+2];
2397 Key_info = (skb->data[ETH_HLEN+1+1+2+1] << 8)|(skb->data[ETH_HLEN+1+1+2+2]);
2398 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
2399 if (((Protocol_Version == 1) || (Protocol_Version == 2)) &&
2400 (Packet_Type == 3)) { //802.1x OR eapol-key challenge frame transfer
2401 bTxeapol_key = true;
2402 if ((Descriptor_type == 254) || (Descriptor_type == 2)) { //WPA or RSN
2403 if (!(Key_info & BIT3) && //group-key challenge
2404 (Key_info & BIT8) && (Key_info & BIT9)) { //send 2/2 key
2405 pDevice->fWPA_Authened = true;
2406 if (Descriptor_type == 254)
2410 printk("Authentication completed!!\n");
2417 MACvTransmitAC0(pDevice->PortOffset);
2418 // DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0:pDevice->apCurrTD= %p\n", pHeadTD);
2420 dev->trans_start = jiffies;
2422 spin_unlock_irq(&pDevice->lock);
2426 static irqreturn_t device_intr(int irq, void *dev_instance) {
2427 struct net_device *dev = dev_instance;
2428 PSDevice pDevice = (PSDevice)netdev_priv(dev);
2431 unsigned long dwMIBCounter = 0;
2432 PSMgmtObject pMgmt = pDevice->pMgmt;
2433 unsigned char byOrgPageSel = 0;
2435 unsigned char byData = 0;
2437 // unsigned char byRSSI;
2439 MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr);
2441 if (pDevice->dwIsr == 0)
2442 return IRQ_RETVAL(handled);
2444 if (pDevice->dwIsr == 0xffffffff) {
2445 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dwIsr = 0xffff\n");
2446 return IRQ_RETVAL(handled);
2449 // 2008-05-21 <mark> by Richardtai, we can't read RSSI here, because no packet bound with RSSI
2451 if ((pDevice->dwIsr & ISR_RXDMA0) &&
2452 (pDevice->byLocalID != REV_ID_VT3253_B0) &&
2453 (pDevice->bBSSIDFilter == true)) {
2455 //BBbReadEmbedded(pDevice->PortOffset, 0x3E, &byRSSI);
2456 //pDevice->uCurrRSSI = byRSSI;
2461 MACvIntDisable(pDevice->PortOffset);
2462 spin_lock_irq(&pDevice->lock);
2464 //Make sure current page is 0
2465 VNSvInPortB(pDevice->PortOffset + MAC_REG_PAGE1SEL, &byOrgPageSel);
2466 if (byOrgPageSel == 1) {
2467 MACvSelectPage0(pDevice->PortOffset);
2471 MACvReadMIBCounter(pDevice->PortOffset, &dwMIBCounter);
2473 // Must do this after doing rx/tx, cause ISR bit is slow
2474 // than RD/TD write back
2475 // update ISR counter
2476 STAvUpdate802_11Counter(&pDevice->s802_11Counter, &pDevice->scStatistic , dwMIBCounter);
2477 while (pDevice->dwIsr != 0) {
2478 STAvUpdateIsrStatCounter(&pDevice->scStatistic, pDevice->dwIsr);
2479 MACvWriteISR(pDevice->PortOffset, pDevice->dwIsr);
2481 if (pDevice->dwIsr & ISR_FETALERR) {
2482 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " ISR_FETALERR \n");
2483 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, 0);
2484 VNSvOutPortW(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPECTI);
2485 device_error(pDevice, pDevice->dwIsr);
2488 if (pDevice->byLocalID > REV_ID_VT3253_B1) {
2489 if (pDevice->dwIsr & ISR_MEASURESTART) {
2490 // 802.11h measure start
2491 pDevice->byOrgChannel = pDevice->byCurrentCh;
2492 VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byOrgRCR));
2493 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, (RCR_RXALLTYPE | RCR_UNICAST | RCR_BROADCAST | RCR_MULTICAST | RCR_WPAERR));
2494 MACvSelectPage1(pDevice->PortOffset);
2495 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR0, &(pDevice->dwOrgMAR0));
2496 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR4, &(pDevice->dwOrgMAR4));
2497 MACvSelectPage0(pDevice->PortOffset);
2499 // WCMDbFlushCommandQueue(pDevice->pMgmt, true);
2500 if (set_channel(pDevice, pDevice->pCurrMeasureEID->sReq.byChannel) == true) {
2501 pDevice->bMeasureInProgress = true;
2502 MACvSelectPage1(pDevice->PortOffset);
2503 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_READY);
2504 MACvSelectPage0(pDevice->PortOffset);
2505 pDevice->byBasicMap = 0;
2506 pDevice->byCCAFraction = 0;
2507 for (ii = 0; ii < 8; ii++) {
2508 pDevice->dwRPIs[ii] = 0;
2511 // can not measure because set channel fail
2512 // WCMDbResetCommandQueue(pDevice->pMgmt);
2513 // clear measure control
2514 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN);
2515 s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_INCAPABLE);
2516 MACvSelectPage1(pDevice->PortOffset);
2517 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2518 MACvSelectPage0(pDevice->PortOffset);
2521 if (pDevice->dwIsr & ISR_MEASUREEND) {
2522 // 802.11h measure end
2523 pDevice->bMeasureInProgress = false;
2524 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byOrgRCR);
2525 MACvSelectPage1(pDevice->PortOffset);
2526 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, pDevice->dwOrgMAR0);
2527 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR4, pDevice->dwOrgMAR4);
2528 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRBBSTS, &byData);
2529 pDevice->byBasicMap |= (byData >> 4);
2530 VNSvInPortB(pDevice->PortOffset + MAC_REG_CCAFRACTION, &pDevice->byCCAFraction);
2531 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRCTL, &byData);
2532 // clear measure control
2533 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN);
2534 MACvSelectPage0(pDevice->PortOffset);
2535 set_channel(pDevice, pDevice->byOrgChannel);
2536 // WCMDbResetCommandQueue(pDevice->pMgmt);
2537 MACvSelectPage1(pDevice->PortOffset);
2538 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2539 MACvSelectPage0(pDevice->PortOffset);
2540 if (byData & MSRCTL_FINISH) {
2542 s_vCompleteCurrentMeasure(pDevice, 0);
2544 // can not measure because not ready before end of measure time
2545 s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_LATE);
2548 if (pDevice->dwIsr & ISR_QUIETSTART) {
2551 } while (CARDbStartQuiet(pDevice) == false);
2555 if (pDevice->dwIsr & ISR_TBTT) {
2556 if (pDevice->bEnableFirstQuiet == true) {
2557 pDevice->byQuietStartCount--;
2558 if (pDevice->byQuietStartCount == 0) {
2559 pDevice->bEnableFirstQuiet = false;
2560 MACvSelectPage1(pDevice->PortOffset);
2561 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN));
2562 MACvSelectPage0(pDevice->PortOffset);
2565 if ((pDevice->bChannelSwitch == true) &&
2566 (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE)) {
2567 pDevice->byChannelSwitchCount--;
2568 if (pDevice->byChannelSwitchCount == 0) {
2569 pDevice->bChannelSwitch = false;
2570 set_channel(pDevice, pDevice->byNewChannel);
2571 VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel);
2572 MACvSelectPage1(pDevice->PortOffset);
2573 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2574 MACvSelectPage0(pDevice->PortOffset);
2575 CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL);
2579 if (pDevice->eOPMode == OP_MODE_ADHOC) {
2580 //pDevice->bBeaconSent = false;
2582 if ((pDevice->bUpdateBBVGA) && (pDevice->bLinkPass == true) && (pDevice->uCurrRSSI != 0)) {
2585 RFvRSSITodBm(pDevice, (unsigned char) pDevice->uCurrRSSI, &ldBm);
2586 for (ii = 0; ii < BB_VGA_LEVEL; ii++) {
2587 if (ldBm < pDevice->ldBmThreshold[ii]) {
2588 pDevice->byBBVGANew = pDevice->abyBBVGA[ii];
2592 if (pDevice->byBBVGANew != pDevice->byBBVGACurrent) {
2593 pDevice->uBBVGADiffCount++;
2594 if (pDevice->uBBVGADiffCount == 1) {
2595 // first VGA diff gain
2596 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew);
2597 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "First RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
2598 (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount);
2600 if (pDevice->uBBVGADiffCount >= BB_VGA_CHANGE_THRESHOLD) {
2601 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
2602 (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount);
2603 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew);
2606 pDevice->uBBVGADiffCount = 1;
2611 pDevice->bBeaconSent = false;
2612 if (pDevice->bEnablePSMode) {
2613 PSbIsNextTBTTWakeUp((void *)pDevice);
2616 if ((pDevice->eOPMode == OP_MODE_AP) ||
2617 (pDevice->eOPMode == OP_MODE_ADHOC)) {
2618 MACvOneShotTimer1MicroSec(pDevice->PortOffset,
2619 (pMgmt->wIBSSBeaconPeriod - MAKE_BEACON_RESERVED) << 10);
2622 if (pDevice->eOPMode == OP_MODE_ADHOC && pDevice->pMgmt->wCurrATIMWindow > 0) {
2623 // todo adhoc PS mode
2628 if (pDevice->dwIsr & ISR_BNTX) {
2629 if (pDevice->eOPMode == OP_MODE_ADHOC) {
2630 pDevice->bIsBeaconBufReadySet = false;
2631 pDevice->cbBeaconBufReadySetCnt = 0;
2634 if (pDevice->eOPMode == OP_MODE_AP) {
2635 if (pMgmt->byDTIMCount > 0) {
2636 pMgmt->byDTIMCount--;
2637 pMgmt->sNodeDBTable[0].bRxPSPoll = false;
2639 if (pMgmt->byDTIMCount == 0) {
2640 // check if mutltcast tx bufferring
2641 pMgmt->byDTIMCount = pMgmt->byDTIMPeriod - 1;
2642 pMgmt->sNodeDBTable[0].bRxPSPoll = true;
2643 bScheduleCommand((void *)pDevice, WLAN_CMD_RX_PSPOLL, NULL);
2647 pDevice->bBeaconSent = true;
2649 if (pDevice->bChannelSwitch == true) {
2650 pDevice->byChannelSwitchCount--;
2651 if (pDevice->byChannelSwitchCount == 0) {
2652 pDevice->bChannelSwitch = false;
2653 set_channel(pDevice, pDevice->byNewChannel);
2654 VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel);
2655 MACvSelectPage1(pDevice->PortOffset);
2656 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2657 MACvSelectPage0(pDevice->PortOffset);
2658 //VNTWIFIbSendBeacon(pDevice->pMgmt);
2659 CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL);
2665 if (pDevice->dwIsr & ISR_RXDMA0) {
2666 max_count += device_rx_srv(pDevice, TYPE_RXDMA0);
2668 if (pDevice->dwIsr & ISR_RXDMA1) {
2669 max_count += device_rx_srv(pDevice, TYPE_RXDMA1);
2671 if (pDevice->dwIsr & ISR_TXDMA0) {
2672 max_count += device_tx_srv(pDevice, TYPE_TXDMA0);
2674 if (pDevice->dwIsr & ISR_AC0DMA) {
2675 max_count += device_tx_srv(pDevice, TYPE_AC0DMA);
2677 if (pDevice->dwIsr & ISR_SOFTTIMER) {
2679 if (pDevice->dwIsr & ISR_SOFTTIMER1) {
2680 if (pDevice->eOPMode == OP_MODE_AP) {
2681 if (pDevice->bShortSlotTime)
2682 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTSLOTTIME(1);
2684 pMgmt->wCurrCapInfo &= ~(WLAN_SET_CAP_INFO_SHORTSLOTTIME(1));
2686 bMgrPrepareBeaconToSend(pDevice, pMgmt);
2687 pDevice->byCntMeasure = 0;
2690 MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr);
2692 MACvReceive0(pDevice->PortOffset);
2693 MACvReceive1(pDevice->PortOffset);
2695 if (max_count > pDevice->sOpts.int_works)
2699 if (byOrgPageSel == 1) {
2700 MACvSelectPage1(pDevice->PortOffset);
2703 spin_unlock_irq(&pDevice->lock);
2704 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
2706 return IRQ_RETVAL(handled);
2709 static unsigned const ethernet_polynomial = 0x04c11db7U;
2710 static inline u32 ether_crc(int length, unsigned char *data)
2714 while (--length >= 0) {
2715 unsigned char current_octet = *data++;
2717 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
2719 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
2725 //2008-8-4 <add> by chester
2726 static int Config_FileGetParameter(unsigned char *string,
2727 unsigned char *dest, unsigned char *source)
2729 unsigned char buf1[100];
2730 int source_len = strlen(source);
2732 memset(buf1, 0, 100);
2733 strcat(buf1, string);
2735 source += strlen(buf1);
2737 memcpy(dest, source, source_len - strlen(buf1));
2741 int Config_FileOperation(PSDevice pDevice,bool fwrite,unsigned char *Parameter)
2743 unsigned char *buffer = kmalloc(1024, GFP_KERNEL);
2744 unsigned char tmpbuffer[20];
2749 printk("allocate mem for file fail?\n");
2752 file = filp_open(CONFIG_PATH, O_RDONLY, 0);
2755 printk("Config_FileOperation:open file fail?\n");
2759 if (kernel_read(file, 0, buffer, 1024) < 0) {
2760 printk("read file error?\n");
2765 if (Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer)!=true) {
2766 printk("get parameter error?\n");
2771 if (memcmp(tmpbuffer,"USA",3)==0) {
2772 result = ZoneType_USA;
2773 } else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
2774 result = ZoneType_Japan;
2775 } else if(memcmp(tmpbuffer,"EUROPE",5)==0) {
2776 result = ZoneType_Europe;
2779 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
2788 static void device_set_multi(struct net_device *dev) {
2789 PSDevice pDevice = (PSDevice)netdev_priv(dev);
2791 PSMgmtObject pMgmt = pDevice->pMgmt;
2793 struct netdev_hw_addr *ha;
2795 VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byRxMode));
2797 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
2798 DBG_PRT(MSG_LEVEL_ERR, KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
2799 /* Unconditionally log net taps. */
2800 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
2801 } else if ((netdev_mc_count(dev) > pDevice->multicast_limit)
2802 || (dev->flags & IFF_ALLMULTI)) {
2803 MACvSelectPage1(pDevice->PortOffset);
2804 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, 0xffffffff);
2805 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, 0xffffffff);
2806 MACvSelectPage0(pDevice->PortOffset);
2807 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
2809 memset(mc_filter, 0, sizeof(mc_filter));
2810 netdev_for_each_mc_addr(ha, dev) {
2811 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
2812 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
2814 MACvSelectPage1(pDevice->PortOffset);
2815 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, mc_filter[0]);
2816 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, mc_filter[1]);
2817 MACvSelectPage0(pDevice->PortOffset);
2818 pDevice->byRxMode &= ~(RCR_UNICAST);
2819 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
2822 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2823 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
2824 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
2825 pDevice->byRxMode &= ~(RCR_UNICAST);
2828 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byRxMode);
2829 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode = %x\n", pDevice->byRxMode);
2832 static struct net_device_stats *device_get_stats(struct net_device *dev) {
2833 PSDevice pDevice = (PSDevice)netdev_priv(dev);
2835 return &pDevice->stats;
2838 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
2839 PSDevice pDevice = (PSDevice)netdev_priv(dev);
2841 struct iwreq *wrq = (struct iwreq *)rq;
2843 PSMgmtObject pMgmt = pDevice->pMgmt;
2846 if (pMgmt == NULL) {
2853 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
2856 case SIOCGIWNWID: //0x8b03 support
2860 // Set frequency/channel
2862 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
2865 // Get frequency/channel
2867 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
2870 // Set desired network name (ESSID)
2874 char essid[IW_ESSID_MAX_SIZE+1];
2875 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
2879 if (copy_from_user(essid, wrq->u.essid.pointer,
2880 wrq->u.essid.length)) {
2884 rc = iwctl_siwessid(dev, NULL,
2885 &(wrq->u.essid), essid);
2889 // Get current network name (ESSID)
2893 char essid[IW_ESSID_MAX_SIZE+1];
2894 if (wrq->u.essid.pointer)
2895 rc = iwctl_giwessid(dev, NULL,
2896 &(wrq->u.essid), essid);
2897 if (copy_to_user(wrq->u.essid.pointer,
2899 wrq->u.essid.length))
2906 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
2909 // Get current Access Point (BSSID)
2911 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
2914 // Set desired station name
2916 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
2920 // Get current station name
2922 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
2926 // Set the desired bit-rate
2928 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
2931 // Get the current bit-rate
2934 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
2937 // Set the desired RTS threshold
2940 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
2943 // Get the current RTS threshold
2946 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
2949 // Set the desired fragmentation threshold
2952 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
2955 // Get the current fragmentation threshold
2958 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
2961 // Set mode of operation
2963 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
2966 // Get mode of operation
2968 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
2971 // Set WEP keys and mode
2972 case SIOCSIWENCODE: {
2973 char abyKey[WLAN_WEP232_KEYLEN];
2975 if (wrq->u.encoding.pointer) {
2976 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
2980 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
2981 if (copy_from_user(abyKey,
2982 wrq->u.encoding.pointer,
2983 wrq->u.encoding.length)) {
2987 } else if (wrq->u.encoding.length != 0) {
2991 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
2995 // Get the WEP keys and mode
2998 if (!capable(CAP_NET_ADMIN)) {
3003 char abyKey[WLAN_WEP232_KEYLEN];
3005 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
3007 if (wrq->u.encoding.pointer) {
3008 if (copy_to_user(wrq->u.encoding.pointer,
3010 wrq->u.encoding.length))
3016 // Get the current Tx-Power
3018 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
3023 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWTXPOW \n");
3029 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
3034 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
3037 // Get range of parameters
3041 struct iw_range range;
3043 rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *)&range);
3044 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
3052 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
3057 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
3062 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
3066 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
3070 case SIOCGIWAPLIST: {
3071 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
3073 if (wrq->u.data.pointer) {
3074 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
3076 if (copy_to_user(wrq->u.data.pointer,
3078 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality)))
3090 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
3097 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWSPY \n");
3101 #endif // WIRELESS_SPY
3104 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
3107 if (wrq->u.data.pointer) {
3108 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof(iwctl_private_args[0]);
3110 if (copy_to_user(wrq->u.data.pointer,
3111 (u_char *) iwctl_private_args,
3112 sizeof(iwctl_private_args)))
3118 //2008-0409-07, <Add> by Einsn Liu
3119 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3121 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n");
3122 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
3126 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
3127 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
3131 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
3132 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3136 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
3137 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3140 case SIOCSIWENCODEEXT: {
3141 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
3142 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
3143 if (wrq->u.encoding.pointer) {
3144 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN + 1);
3145 if (wrq->u.encoding.length > (sizeof(struct iw_encode_ext) + MAX_KEY_LEN)) {
3149 if (copy_from_user(extra, wrq->u.encoding.pointer, wrq->u.encoding.length)) {
3153 } else if (wrq->u.encoding.length != 0) {
3157 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
3161 case SIOCGIWENCODEEXT:
3162 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
3163 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
3167 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
3168 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3171 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3172 //End Add -- //2008-0409-07, <Add> by Einsn Liu
3174 case IOCTL_CMD_TEST:
3176 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
3182 pReq = (PSCmdRequest)rq;
3183 pReq->wResult = MAGIC_CODE;
3189 if ((((PSCmdRequest)rq)->wCmdCode != WLAN_CMD_SET_EVT) &&
3190 !(pDevice->flags & DEVICE_FLAGS_OPENED))
3192 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
3193 (((PSCmdRequest)rq)->wCmdCode != WLAN_CMD_SET_WPA))
3202 if (test_and_set_bit(0, (void *)&(pMgmt->uCmdBusy))) {
3205 rc = private_ioctl(pDevice, rq);
3206 clear_bit(0, (void *)&(pMgmt->uCmdBusy));
3209 case IOCTL_CMD_HOSTAPD:
3211 rc = vt6655_hostap_ioctl(pDevice, &wrq->u.data);
3216 rc = wpa_ioctl(pDevice, &wrq->u.data);
3220 return ethtool_ioctl(dev, (void *)rq->ifr_data);
3221 // All other calls are currently unsupported
3225 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
3229 if (pDevice->bCommit) {
3230 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
3231 netif_stop_queue(pDevice->dev);
3232 spin_lock_irq(&pDevice->lock);
3233 bScheduleCommand((void *)pDevice, WLAN_CMD_RUN_AP, NULL);
3234 spin_unlock_irq(&pDevice->lock);
3236 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
3237 spin_lock_irq(&pDevice->lock);
3238 pDevice->bLinkPass = false;
3239 memset(pMgmt->abyCurrBSSID, 0, 6);
3240 pMgmt->eCurrState = WMAC_STATE_IDLE;
3241 netif_stop_queue(pDevice->dev);
3242 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3243 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
3244 if (pDevice->bWPASuppWextEnabled != true)
3246 bScheduleCommand((void *)pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID);
3247 bScheduleCommand((void *)pDevice, WLAN_CMD_SSID, NULL);
3248 spin_unlock_irq(&pDevice->lock);
3250 pDevice->bCommit = false;
3256 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
3260 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd)))
3264 case ETHTOOL_GDRVINFO: {
3265 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
3266 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
3267 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
3268 if (copy_to_user(useraddr, &info, sizeof(info)))
3278 /*------------------------------------------------------------------*/
3280 MODULE_DEVICE_TABLE(pci, vt6655_pci_id_table);
3282 static struct pci_driver device_driver = {
3283 .name = DEVICE_NAME,
3284 .id_table = vt6655_pci_id_table,
3285 .probe = vt6655_probe,
3286 .remove = vt6655_remove,
3288 .suspend = viawget_suspend,
3289 .resume = viawget_resume,
3293 static int __init vt6655_init_module(void)
3297 // ret=pci_module_init(&device_driver);
3298 //ret = pcie_port_service_register(&device_driver);
3299 ret = pci_register_driver(&device_driver);
3302 register_reboot_notifier(&device_notifier);
3308 static void __exit vt6655_cleanup_module(void)
3311 unregister_reboot_notifier(&device_notifier);
3313 pci_unregister_driver(&device_driver);
3316 module_init(vt6655_init_module);
3317 module_exit(vt6655_cleanup_module);
3321 device_notify_reboot(struct notifier_block *nb, unsigned long event, void *p)
3323 struct pci_dev *pdev = NULL;
3328 for_each_pci_dev(pdev) {
3329 if (pci_dev_driver(pdev) == &device_driver) {
3330 if (pci_get_drvdata(pdev))
3331 viawget_suspend(pdev, PMSG_HIBERNATE);
3339 viawget_suspend(struct pci_dev *pcid, pm_message_t state)
3341 int power_status; // to silence the compiler
3343 PSDevice pDevice = pci_get_drvdata(pcid);
3344 PSMgmtObject pMgmt = pDevice->pMgmt;
3346 netif_stop_queue(pDevice->dev);
3347 spin_lock_irq(&pDevice->lock);
3348 pci_save_state(pcid);
3349 del_timer(&pDevice->sTimerCommand);
3350 del_timer(&pMgmt->sTimerSecondCallback);
3351 pDevice->cbFreeCmdQueue = CMD_Q_SIZE;
3352 pDevice->uCmdDequeueIdx = 0;
3353 pDevice->uCmdEnqueueIdx = 0;
3354 pDevice->bCmdRunning = false;
3355 MACbShutdown(pDevice->PortOffset);
3356 MACvSaveContext(pDevice->PortOffset, pDevice->abyMacContext);
3357 pDevice->bLinkPass = false;
3358 memset(pMgmt->abyCurrBSSID, 0, 6);
3359 pMgmt->eCurrState = WMAC_STATE_IDLE;
3360 pci_disable_device(pcid);
3361 power_status = pci_set_power_state(pcid, pci_choose_state(pcid, state));
3362 spin_unlock_irq(&pDevice->lock);
3367 viawget_resume(struct pci_dev *pcid)
3369 PSDevice pDevice = pci_get_drvdata(pcid);
3370 PSMgmtObject pMgmt = pDevice->pMgmt;
3371 int power_status; // to silence the compiler
3373 power_status = pci_set_power_state(pcid, 0);
3374 power_status = pci_enable_wake(pcid, 0, 0);
3375 pci_restore_state(pcid);
3376 if (netif_running(pDevice->dev)) {
3377 spin_lock_irq(&pDevice->lock);
3378 MACvRestoreContext(pDevice->PortOffset, pDevice->abyMacContext);
3379 device_init_registers(pDevice, DEVICE_INIT_DXPL);
3380 if (pMgmt->sNodeDBTable[0].bActive == true) { // Assoc with BSS
3381 pMgmt->sNodeDBTable[0].bActive = false;
3382 pDevice->bLinkPass = false;
3383 if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
3384 // In Adhoc, BSS state set back to started.
3385 pMgmt->eCurrState = WMAC_STATE_STARTED;
3387 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
3388 pMgmt->eCurrState = WMAC_STATE_IDLE;
3391 init_timer(&pMgmt->sTimerSecondCallback);
3392 init_timer(&pDevice->sTimerCommand);
3393 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
3394 BSSvClearBSSList((void *)pDevice, pDevice->bLinkPass);
3395 bScheduleCommand((void *)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
3396 bScheduleCommand((void *)pDevice, WLAN_CMD_SSID, NULL);
3397 spin_unlock_irq(&pDevice->lock);