1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61#undef __NO_VERSION__
62
63#include <linux/file.h>
64#include "device.h"
65#include "card.h"
66#include "channel.h"
67#include "baseband.h"
68#include "mac.h"
69#include "tether.h"
70#include "wmgr.h"
71#include "wctl.h"
72#include "power.h"
73#include "wcmd.h"
74#include "iocmd.h"
75#include "tcrc.h"
76#include "rxtx.h"
77#include "wroute.h"
78#include "bssdb.h"
79#include "hostap.h"
80#include "wpactl.h"
81#include "ioctl.h"
82#include "iwctl.h"
83#include "dpc.h"
84#include "datarate.h"
85#include "rf.h"
86#include "iowpa.h"
87#include <linux/delay.h>
88#include <linux/kthread.h>
89#include <linux/slab.h>
90
91
92
93static int msglevel = MSG_LEVEL_INFO;
94
95
96
97
98MODULE_AUTHOR("VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>");
99MODULE_LICENSE("GPL");
100MODULE_DESCRIPTION("VIA Networking Solomon-A/B/G Wireless LAN Adapter Driver");
101
102static int mlme_kill;
103
104
105#define DEVICE_PARAM(N, D)
106
107
108
109
110
111
112#define RX_DESC_MIN0 16
113#define RX_DESC_MAX0 128
114#define RX_DESC_DEF0 32
115DEVICE_PARAM(RxDescriptors0, "Number of receive descriptors0");
116
117#define RX_DESC_MIN1 16
118#define RX_DESC_MAX1 128
119#define RX_DESC_DEF1 32
120DEVICE_PARAM(RxDescriptors1, "Number of receive descriptors1");
121
122#define TX_DESC_MIN0 16
123#define TX_DESC_MAX0 128
124#define TX_DESC_DEF0 32
125DEVICE_PARAM(TxDescriptors0, "Number of transmit descriptors0");
126
127#define TX_DESC_MIN1 16
128#define TX_DESC_MAX1 128
129#define TX_DESC_DEF1 64
130DEVICE_PARAM(TxDescriptors1, "Number of transmit descriptors1");
131
132#define IP_ALIG_DEF 0
133
134
135
136
137
138
139DEVICE_PARAM(IP_byte_align, "Enable IP header dword aligned");
140
141#define INT_WORKS_DEF 20
142#define INT_WORKS_MIN 10
143#define INT_WORKS_MAX 64
144
145DEVICE_PARAM(int_works, "Number of packets per interrupt services");
146
147#define CHANNEL_MIN 1
148#define CHANNEL_MAX 14
149#define CHANNEL_DEF 6
150
151DEVICE_PARAM(Channel, "Channel number");
152
153
154
155
156
157
158#define PREAMBLE_TYPE_DEF 1
159
160DEVICE_PARAM(PreambleType, "Preamble Type");
161
162#define RTS_THRESH_MIN 512
163#define RTS_THRESH_MAX 2347
164#define RTS_THRESH_DEF 2347
165
166DEVICE_PARAM(RTSThreshold, "RTS threshold");
167
168#define FRAG_THRESH_MIN 256
169#define FRAG_THRESH_MAX 2346
170#define FRAG_THRESH_DEF 2346
171
172DEVICE_PARAM(FragThreshold, "Fragmentation threshold");
173
174#define DATA_RATE_MIN 0
175#define DATA_RATE_MAX 13
176#define DATA_RATE_DEF 13
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194DEVICE_PARAM(ConnectionRate, "Connection data rate");
195
196#define OP_MODE_DEF 0
197
198DEVICE_PARAM(OPMode, "Infrastruct, adhoc, AP mode ");
199
200
201
202
203
204
205
206
207
208
209
210
211#define PS_MODE_DEF 0
212
213DEVICE_PARAM(PSMode, "Power saving mode");
214
215#define SHORT_RETRY_MIN 0
216#define SHORT_RETRY_MAX 31
217#define SHORT_RETRY_DEF 8
218
219DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits");
220
221#define LONG_RETRY_MIN 0
222#define LONG_RETRY_MAX 15
223#define LONG_RETRY_DEF 4
224
225DEVICE_PARAM(LongRetryLimit, "long frame retry limits");
226
227
228
229
230
231
232#define BBP_TYPE_MIN 0
233#define BBP_TYPE_MAX 2
234#define BBP_TYPE_DEF 2
235
236DEVICE_PARAM(BasebandType, "baseband type");
237
238
239
240
241
242
243#define X80211h_MODE_DEF 0
244
245DEVICE_PARAM(b80211hEnable, "802.11h mode");
246
247
248
249
250
251
252#define DIVERSITY_ANT_DEF 0
253
254DEVICE_PARAM(bDiversityANTEnable, "ANT diversity mode");
255
256
257
258
259
260static int device_nics = 0;
261static PSDevice pDevice_Infos = NULL;
262static struct net_device *root_device_dev = NULL;
263
264static 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 },
267 {0, NULL}
268};
269
270DEFINE_PCI_DEVICE_TABLE(vt6655_pci_id_table) = {
271 { PCI_VDEVICE(VIA, 0x3253), (kernel_ulong_t)chip_info_table},
272 { 0, }
273};
274
275
276
277static int vt6655_probe(struct pci_dev *pcid, const struct pci_device_id *ent);
278static void vt6655_init_info(struct pci_dev *pcid, PSDevice *ppDevice, PCHIP_INFO);
279static void device_free_info(PSDevice pDevice);
280static bool device_get_pci_info(PSDevice, struct pci_dev *pcid);
281static void device_print_info(PSDevice pDevice);
282static struct net_device_stats *device_get_stats(struct net_device *dev);
283static void device_init_diversity_timer(PSDevice pDevice);
284static int device_open(struct net_device *dev);
285static int device_xmit(struct sk_buff *skb, struct net_device *dev);
286static irqreturn_t device_intr(int irq, void *dev_instance);
287static void device_set_multi(struct net_device *dev);
288static int device_close(struct net_device *dev);
289static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
290
291#ifdef CONFIG_PM
292static int device_notify_reboot(struct notifier_block *, unsigned long event, void *ptr);
293static int viawget_suspend(struct pci_dev *pcid, pm_message_t state);
294static int viawget_resume(struct pci_dev *pcid);
295struct notifier_block device_notifier = {
296 .notifier_call = device_notify_reboot,
297 .next = NULL,
298 .priority = 0,
299};
300#endif
301
302static void device_init_rd0_ring(PSDevice pDevice);
303static void device_init_rd1_ring(PSDevice pDevice);
304static void device_init_defrag_cb(PSDevice pDevice);
305static void device_init_td0_ring(PSDevice pDevice);
306static void device_init_td1_ring(PSDevice pDevice);
307
308static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
309
310static bool device_release_WPADEV(PSDevice pDevice);
311
312static int ethtool_ioctl(struct net_device *dev, void *useraddr);
313static int device_rx_srv(PSDevice pDevice, unsigned int uIdx);
314static int device_tx_srv(PSDevice pDevice, unsigned int uIdx);
315static bool device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pDesc);
316static void device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType);
317static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc);
318static void device_free_td0_ring(PSDevice pDevice);
319static void device_free_td1_ring(PSDevice pDevice);
320static void device_free_rd0_ring(PSDevice pDevice);
321static void device_free_rd1_ring(PSDevice pDevice);
322static void device_free_rings(PSDevice pDevice);
323static void device_free_frag_buf(PSDevice pDevice);
324static int Config_FileGetParameter(unsigned char *string,
325 unsigned char *dest, unsigned char *source);
326
327
328
329
330
331static char *get_chip_name(int chip_id)
332{
333 int i;
334 for (i = 0; chip_info_table[i].name != NULL; i++)
335 if (chip_info_table[i].chip_id == chip_id)
336 break;
337 return chip_info_table[i].name;
338}
339
340static void vt6655_remove(struct pci_dev *pcid)
341{
342 PSDevice pDevice = pci_get_drvdata(pcid);
343
344 if (pDevice == NULL)
345 return;
346 device_free_info(pDevice);
347}
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381static void device_get_options(PSDevice pDevice, int index, char *devname)
382{
383 POPTIONS pOpts = &(pDevice->sOpts);
384
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;
395
396 pOpts->flags |= DEVICE_FLAGS_PREAMBLE_TYPE;
397 pOpts->flags |= DEVICE_FLAGS_OP_MODE;
398
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;
404}
405
406static void
407device_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};
411
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);
415
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;
431
432
433 pDevice->byAutoFBCtrl = AUTO_FB_0;
434
435
436 pDevice->bUpdateBBVGA = true;
437 pDevice->byFOETuning = 0;
438 pDevice->wCTSDuration = 0;
439 pDevice->byPreambleType = 0;
440
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);
453}
454
455static void s_vCompleteCurrentMeasure(PSDevice pDevice, unsigned char byResult)
456{
457 unsigned int ii;
458 unsigned long dwDuration = 0;
459 unsigned char byRPI0 = 0;
460
461 for (ii = 1; ii < 8; ii++) {
462 pDevice->dwRPIs[ii] *= 255;
463 dwDuration |= *((unsigned short *)(pDevice->pCurrMeasureEID->sReq.abyDuration));
464 dwDuration <<= 10;
465 pDevice->dwRPIs[ii] /= dwDuration;
466 pDevice->abyRPIs[ii] = (unsigned char)pDevice->dwRPIs[ii];
467 byRPI0 += pDevice->abyRPIs[ii];
468 }
469 pDevice->abyRPIs[0] = (0xFF - byRPI0);
470
471 if (pDevice->uNumOfMeasureEIDs == 0) {
472 VNTWIFIbMeasureReport(pDevice->pMgmt,
473 true,
474 pDevice->pCurrMeasureEID,
475 byResult,
476 pDevice->byBasicMap,
477 pDevice->byCCAFraction,
478 pDevice->abyRPIs
479 );
480 } else {
481 VNTWIFIbMeasureReport(pDevice->pMgmt,
482 false,
483 pDevice->pCurrMeasureEID,
484 byResult,
485 pDevice->byBasicMap,
486 pDevice->byCCAFraction,
487 pDevice->abyRPIs
488 );
489 CARDbStartMeasure(pDevice, pDevice->pCurrMeasureEID++, pDevice->uNumOfMeasureEIDs);
490 }
491}
492
493
494
495
496
497static void device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType)
498{
499 unsigned int ii;
500 unsigned char byValue;
501 unsigned char byValue1;
502 unsigned char byCCKPwrdBm = 0;
503 unsigned char byOFDMPwrdBm = 0;
504 int zonetype = 0;
505 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
506 MACbShutdown(pDevice->PortOffset);
507 BBvSoftwareReset(pDevice->PortOffset);
508
509 if ((InitType == DEVICE_INIT_COLD) ||
510 (InitType == DEVICE_INIT_DXPL)) {
511
512 MACbSoftwareReset(pDevice->PortOffset);
513
514 pDevice->bCCK = true;
515 pDevice->bAES = false;
516 pDevice->bProtectMode = false;
517 pDevice->bNonERPPresent = false;
518 pDevice->bBarkerPreambleMd = false;
519 pDevice->wCurrentRate = RATE_1M;
520 pDevice->byTopOFDMBasicRate = RATE_24M;
521 pDevice->byTopCCKBasicRate = RATE_1M;
522
523 pDevice->byRevId = 0;
524
525
526 MACvInitialize(pDevice->PortOffset);
527
528
529 VNSvInPortB(pDevice->PortOffset + MAC_REG_LOCALID, &(pDevice->byLocalID));
530
531 spin_lock_irq(&pDevice->lock);
532 SROMvReadAllContents(pDevice->PortOffset, pDevice->abyEEPROM);
533
534 spin_unlock_irq(&pDevice->lock);
535
536
537
538 pDevice->byMinChannel = 1;
539 pDevice->byMaxChannel = CB_MAX_CHANNEL;
540
541
542 byValue = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ANTENNA);
543 if (byValue & EEP_ANTINV)
544 pDevice->bTxRxAntInv = true;
545 else
546 pDevice->bTxRxAntInv = false;
547
548 byValue &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
549 if (byValue == 0)
550 byValue = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
551
552 pDevice->ulDiversityNValue = 100*260;
553 pDevice->ulDiversityMValue = 100*16;
554 pDevice->byTMax = 1;
555 pDevice->byTMax2 = 4;
556 pDevice->ulSQ3TH = 0;
557 pDevice->byTMax3 = 64;
558
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;
566 else
567 pDevice->byRxAntennaMode = ANT_B;
568
569 byValue1 = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ANTENNA);
570 if ((byValue1 & 0x08) == 0)
571 pDevice->bDiversityEnable = false;
572 else
573 pDevice->bDiversityEnable = true;
574 } else {
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;
583 else
584 pDevice->byRxAntennaMode = ANT_A;
585 } else {
586 pDevice->byTxAntennaMode = ANT_B;
587 if (pDevice->bTxRxAntInv == true)
588 pDevice->byRxAntennaMode = ANT_A;
589 else
590 pDevice->byRxAntennaMode = ANT_B;
591 }
592 }
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);
595
596
597
598
599 pDevice->byOriginalZonetype = pDevice->abyEEPROM[EEP_OFS_ZONETYPE];
600 zonetype = Config_FileOperation(pDevice, false, NULL);
601 if (zonetype >= 0) {
602 if ((zonetype == 0) &&
603 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] != 0x00)) {
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)) {
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)) {
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");
616 }
617
618 else {
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]);
621 else
622 printk("Read Zonetype file success,use default zonetype setting[%02x]\n", zonetype);
623 }
624 } else
625 printk("Read Zonetype file fail,use default zonetype setting[%02x]\n", SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ZONETYPE));
626
627
628 pDevice->byRFType = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RFTYPE);
629
630 if ((pDevice->byRFType & RF_EMU) != 0) {
631
632 pDevice->byRevId = 0x80;
633 }
634
635 pDevice->byRFType &= RF_MASK;
636 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRFType = %x\n", pDevice->byRFType);
637
638 if (pDevice->bZoneRegExist == false) {
639 pDevice->byZoneType = pDevice->abyEEPROM[EEP_OFS_ZONETYPE];
640 }
641 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byZoneType = %x\n", pDevice->byZoneType);
642
643
644 RFbInit(pDevice);
645
646
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
651
652
653
654
655
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;
660 }
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;
664 }
665 pDevice->abyCCKDefaultPwr[ii + 1] = byCCKPwrdBm;
666 pDevice->abyOFDMDefaultPwr[ii + 1] = byOFDMPwrdBm;
667 }
668
669
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];
676
677 }
678 }
679
680
681 for (ii = 0; ii < CB_MAX_CHANNEL_5G; ii++) {
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));
684 }
685 init_channel_table((void *)pDevice);
686
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);
691 }
692
693
694 MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_CFG, (CFG_TKIPOPT | CFG_NOTXTIMEOUT));
695
696
697 MACvSetShortRetryLimit(pDevice->PortOffset, pDevice->byShortRetryLimit);
698 MACvSetLongRetryLimit(pDevice->PortOffset, pDevice->byLongRetryLimit);
699
700
701 VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
702
703 VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
704
705
706 BBbVT3253Init(pDevice);
707
708 if (pDevice->bUpdateBBVGA) {
709 pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
710 pDevice->byBBVGANew = pDevice->byBBVGACurrent;
711 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
712 }
713 BBvSetRxAntennaMode(pDevice->PortOffset, pDevice->byRxAntennaMode);
714 BBvSetTxAntennaMode(pDevice->PortOffset, pDevice->byTxAntennaMode);
715
716 pDevice->byCurrentCh = 0;
717
718
719
720
721 if (pDevice->uConnectionRate == RATE_AUTO) {
722 pDevice->wCurrentRate = RATE_54M;
723 } else {
724 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
725 }
726
727
728 VNTWIFIbConfigPhyMode(pDevice->pMgmt, PHY_TYPE_11G);
729 VNTWIFIbConfigPhyMode(pDevice->pMgmt, PHY_TYPE_AUTO);
730
731 pDevice->bRadioOff = false;
732
733 pDevice->byRadioCtl = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RADIOCTL);
734 pDevice->bHWRadioOff = false;
735
736 if (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) {
737
738 MACvGPIOIn(pDevice->PortOffset, &pDevice->byGPIO);
739
740#ifdef FOR_LED_ON_NOTEBOOK
741 if (pDevice->byGPIO & GPIO0_DATA) { pDevice->bHWRadioOff = true; }
742 if (!(pDevice->byGPIO & GPIO0_DATA)) { pDevice->bHWRadioOff = false; }
743
744 }
745 if ((pDevice->bRadioControlOff == true)) {
746 CARDbRadioPowerOff(pDevice);
747 } else CARDbRadioPowerOn(pDevice);
748#else
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;
752 }
753 }
754 if ((pDevice->bHWRadioOff == true) || (pDevice->bRadioControlOff == true)) {
755 CARDbRadioPowerOff(pDevice);
756 }
757
758#endif
759}
760pMgmt->eScanType = WMAC_SCAN_PASSIVE;
761
762SROMvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr);
763DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Network address = %pM\n",
764 pDevice->abyCurrentNetAddr);
765
766
767CARDvSafeResetRx(pDevice);
768
769CARDvSafeResetTx(pDevice);
770
771if (pDevice->byLocalID <= REV_ID_VT3253_A1) {
772 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_RCR, RCR_WPAERR);
773}
774
775pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
776
777
778MACvReceive0(pDevice->PortOffset);
779MACvReceive1(pDevice->PortOffset);
780
781
782MACvStart(pDevice->PortOffset);
783
784netif_stop_queue(pDevice->dev);
785}
786
787static 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);
792
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);
797
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);
802
803 return;
804}
805
806static bool device_release_WPADEV(PSDevice pDevice)
807{
808 viawget_wpa_header *wpahdr;
809 int ii = 0;
810
811
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);
825
826
827
828
829 while ((pDevice->bWPADEVUp == true)) {
830 set_current_state(TASK_UNINTERRUPTIBLE);
831 schedule_timeout(HZ / 20);
832 ii++;
833 if (ii > 20)
834 break;
835 }
836 }
837 return true;
838}
839
840static 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,
847};
848
849static int
850vt6655_probe(struct pci_dev *pcid, const struct pci_device_id *ent)
851{
852 static bool bFirst = true;
853 struct net_device *dev = NULL;
854 PCHIP_INFO pChip_info = (PCHIP_INFO)ent->driver_data;
855 PSDevice pDevice;
856 int rc;
857 if (device_nics++ >= MAX_UINTS) {
858 printk(KERN_NOTICE DEVICE_NAME ": already found %d NICs\n", device_nics);
859 return -ENODEV;
860 }
861
862 dev = alloc_etherdev(sizeof(DEVICE_INFO));
863
864 pDevice = (PSDevice) netdev_priv(dev);
865
866 if (dev == NULL) {
867 printk(KERN_ERR DEVICE_NAME ": allocate net device failed \n");
868 return -ENOMEM;
869 }
870
871
872
873 SET_NETDEV_DEV(dev, &pcid->dev);
874
875 if (bFirst) {
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");
878 bFirst = false;
879 }
880
881 vt6655_init_info(pcid, &pDevice, pChip_info);
882 pDevice->dev = dev;
883 pDevice->next_module = root_device_dev;
884 root_device_dev = dev;
885
886 if (pci_enable_device(pcid)) {
887 device_free_info(pDevice);
888 return -ENODEV;
889 }
890 dev->irq = pcid->irq;
891
892#ifdef DEBUG
893 printk("Before get pci_info memaddr is %x\n", pDevice->memaddr);
894#endif
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);
898 return -ENODEV;
899 }
900
901#if 1
902
903#ifdef DEBUG
904
905
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);
907 {
908 int i;
909 u32 bar, len;
910 u32 address[] = {
911 PCI_BASE_ADDRESS_0,
912 PCI_BASE_ADDRESS_1,
913 PCI_BASE_ADDRESS_2,
914 PCI_BASE_ADDRESS_3,
915 PCI_BASE_ADDRESS_4,
916 PCI_BASE_ADDRESS_5,
917 0};
918 for (i = 0; address[i]; i++) {
919
920 pci_read_config_dword(pcid, address[i], &bar);
921 printk("bar %d is %x\n", i, bar);
922 if (!bar) {
923 printk("bar %d not implemented\n", i);
924 continue;
925 }
926 if (bar & PCI_BASE_ADDRESS_SPACE_IO) {
927
928
929 len = bar & (PCI_BASE_ADDRESS_IO_MASK & 0xFFFF);
930 len = len & ~(len - 1);
931
932 printk("IO space: len in IO %x, BAR %d\n", len, i);
933 } else {
934 len = bar & 0xFFFFFFF0;
935 len = ~len + 1;
936
937 printk("len in MEM %x, BAR %d\n", len, i);
938 }
939 }
940 }
941#endif
942
943#endif
944
945#ifdef DEBUG
946
947#endif
948 pDevice->PortOffset = (unsigned long)ioremap(pDevice->memaddr & PCI_BASE_ADDRESS_MEM_MASK, pDevice->io_size);
949
950
951 if (pDevice->PortOffset == 0) {
952 printk(KERN_ERR DEVICE_NAME ": Failed to IO remapping ..\n");
953 device_free_info(pDevice);
954 return -ENODEV;
955 }
956
957 rc = pci_request_regions(pcid, DEVICE_NAME);
958 if (rc) {
959 printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device\n");
960 device_free_info(pDevice);
961 return -ENODEV;
962 }
963
964 dev->base_addr = pDevice->ioaddr;
965#ifdef PLICE_DEBUG
966 unsigned char value;
967
968 VNSvInPortB(pDevice->PortOffset+0x4F, &value);
969 printk("Before write: value is %x\n", value);
970
971 VNSvOutPortB(pDevice->PortOffset, value);
972 VNSvInPortB(pDevice->PortOffset+0x4F, &value);
973 printk("After write: value is %x\n", value);
974#endif
975
976#ifdef IO_MAP
977 pDevice->PortOffset = pDevice->ioaddr;
978#endif
979
980 if (!MACbSoftwareReset(pDevice->PortOffset)) {
981 printk(KERN_ERR DEVICE_NAME ": Failed to access MAC hardware..\n");
982 device_free_info(pDevice);
983 return -ENODEV;
984 }
985
986 MACvInitialize(pDevice->PortOffset);
987 MACvReadEtherAddress(pDevice->PortOffset, dev->dev_addr);
988
989 device_get_options(pDevice, device_nics-1, dev->name);
990 device_set_options(pDevice);
991
992 pDevice->sOpts.flags &= pChip_info->flags;
993
994
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);
999
1000 dev->irq = pcid->irq;
1001 dev->netdev_ops = &device_netdev_ops;
1002
1003 dev->wireless_handlers = (struct iw_handler_def *)&iwctl_handler_def;
1004
1005 rc = register_netdev(dev);
1006 if (rc) {
1007 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
1008 device_free_info(pDevice);
1009 return -ENODEV;
1010 }
1011 device_print_info(pDevice);
1012 pci_set_drvdata(pcid, pDevice);
1013 return 0;
1014}
1015
1016static void device_print_info(PSDevice pDevice)
1017{
1018 struct net_device *dev = pDevice->dev;
1019
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);
1022#ifdef IO_MAP
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);
1025#else
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);
1029#endif
1030}
1031
1032static void vt6655_init_info(struct pci_dev *pcid, PSDevice *ppDevice,
1033 PCHIP_INFO pChip_info) {
1034 PSDevice p;
1035
1036 memset(*ppDevice, 0, sizeof(DEVICE_INFO));
1037
1038 if (pDevice_Infos == NULL) {
1039 pDevice_Infos = *ppDevice;
1040 } else {
1041 for (p = pDevice_Infos; p->next != NULL; p = p->next)
1042 do {} while (0);
1043 p->next = *ppDevice;
1044 (*ppDevice)->prev = p;
1045 }
1046
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;
1052
1053 spin_lock_init(&((*ppDevice)->lock));
1054}
1055
1056static bool device_get_pci_info(PSDevice pDevice, struct pci_dev *pcid) {
1057 u16 pci_cmd;
1058 u8 b;
1059 unsigned int cis_addr;
1060#ifdef PLICE_DEBUG
1061 unsigned char pci_config[256];
1062 unsigned char value = 0x00;
1063 int ii, j;
1064 u16 max_lat = 0x0000;
1065 memset(pci_config, 0x00, 256);
1066#endif
1067
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));
1072
1073 pci_set_master(pcid);
1074
1075 pDevice->memaddr = pci_resource_start(pcid, 0);
1076 pDevice->ioaddr = pci_resource_start(pcid, 1);
1077
1078#ifdef DEBUG
1079
1080
1081#endif
1082
1083 cis_addr = pci_resource_start(pcid, 2);
1084
1085 pDevice->pcid = pcid;
1086
1087 pci_read_config_byte(pcid, PCI_COMMAND, &b);
1088 pci_write_config_byte(pcid, PCI_COMMAND, (b|PCI_COMMAND_MASTER));
1089
1090#ifdef PLICE_DEBUG
1091
1092
1093
1094
1095
1096
1097
1098 for (ii = 0; ii < 0xFF; ii++) {
1099 pci_read_config_byte(pcid, ii, &value);
1100 pci_config[ii] = value;
1101 }
1102 for (ii = 0, j = 1; ii < 0x100; ii++, j++) {
1103 if (j % 16 == 0) {
1104 printk("%x:", pci_config[ii]);
1105 printk("\n");
1106 } else {
1107 printk("%x:", pci_config[ii]);
1108 }
1109 }
1110#endif
1111 return true;
1112}
1113
1114static void device_free_info(PSDevice pDevice) {
1115 PSDevice ptr;
1116 struct net_device *dev = pDevice->dev;
1117
1118 ASSERT(pDevice);
1119
1120 device_release_WPADEV(pDevice);
1121
1122
1123
1124 if (wpa_set_wpadev(pDevice, 0) != 0)
1125 printk("unregister wpadev fail?\n");
1126
1127 if (pDevice_Infos == NULL)
1128 return;
1129
1130 for (ptr = pDevice_Infos; ptr && (ptr != pDevice); ptr = ptr->next)
1131 do {} while (0);
1132
1133 if (ptr == pDevice) {
1134 if (ptr == pDevice_Infos)
1135 pDevice_Infos = ptr->next;
1136 else
1137 ptr->prev->next = ptr->next;
1138 } else {
1139 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "info struct not found\n");
1140 return;
1141 }
1142#ifdef HOSTAP
1143 if (dev)
1144 vt6655_hostap_set_hostapd(pDevice, 0, 0);
1145#endif
1146 if (dev)
1147 unregister_netdev(dev);
1148
1149 if (pDevice->PortOffset)
1150 iounmap((void *)pDevice->PortOffset);
1151
1152 if (pDevice->pcid)
1153 pci_release_regions(pDevice->pcid);
1154 if (dev)
1155 free_netdev(dev);
1156
1157 if (pDevice->pcid) {
1158 pci_set_drvdata(pDevice->pcid, NULL);
1159 }
1160}
1161
1162static bool device_init_rings(PSDevice pDevice) {
1163 void *vir_pool;
1164
1165
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);
1172
1173 if (vir_pool == NULL) {
1174 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "%s : allocate desc dma memory failed\n", pDevice->dev->name);
1175 return false;
1176 }
1177
1178 memset(vir_pool, 0,
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)
1183 );
1184
1185 pDevice->aRD0Ring = vir_pool;
1186 pDevice->aRD1Ring = vir_pool +
1187 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1188
1189 pDevice->rd0_pool_dma = pDevice->pool_dma;
1190 pDevice->rd1_pool_dma = pDevice->rd0_pool_dma +
1191 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1192
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 +
1197 CB_MAX_BUF_SIZE,
1198 &pDevice->tx_bufs_dma0);
1199
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
1208 );
1209 return false;
1210 }
1211
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 +
1216 CB_MAX_BUF_SIZE
1217 );
1218
1219 pDevice->td0_pool_dma = pDevice->rd1_pool_dma +
1220 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1221
1222 pDevice->td1_pool_dma = pDevice->td0_pool_dma +
1223 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1224
1225
1226 pDevice->apTD0Rings = vir_pool
1227 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1228 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1229
1230 pDevice->apTD1Rings = vir_pool
1231 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1232 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc)
1233 + pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1234
1235 pDevice->tx1_bufs = pDevice->tx0_bufs +
1236 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1237
1238 pDevice->tx_beacon_bufs = pDevice->tx1_bufs +
1239 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1240
1241 pDevice->pbyTmpBuff = pDevice->tx_beacon_bufs +
1242 CB_BEACON_BUF_SIZE;
1243
1244 pDevice->tx_bufs_dma1 = pDevice->tx_bufs_dma0 +
1245 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1246
1247 pDevice->tx_beacon_dma = pDevice->tx_bufs_dma1 +
1248 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1249
1250 return true;
1251}
1252
1253static 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)
1259 ,
1260 pDevice->aRD0Ring, pDevice->pool_dma
1261 );
1262
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 +
1268 CB_MAX_BUF_SIZE,
1269 pDevice->tx0_bufs, pDevice->tx_bufs_dma0
1270 );
1271}
1272
1273static void device_init_rd0_ring(PSDevice pDevice) {
1274 int i;
1275 dma_addr_t curr = pDevice->rd0_pool_dma;
1276 PSRxDesc pDesc;
1277
1278
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);
1286 }
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));
1290 }
1291
1292 if (i > 0)
1293 pDevice->aRD0Ring[i-1].next_desc = cpu_to_le32(pDevice->rd0_pool_dma);
1294 pDevice->pCurrRD[0] = &(pDevice->aRD0Ring[0]);
1295}
1296
1297static void device_init_rd1_ring(PSDevice pDevice) {
1298 int i;
1299 dma_addr_t curr = pDevice->rd1_pool_dma;
1300 PSRxDesc pDesc;
1301
1302
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);
1310 }
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));
1314 }
1315
1316 if (i > 0)
1317 pDevice->aRD1Ring[i-1].next_desc = cpu_to_le32(pDevice->rd1_pool_dma);
1318 pDevice->pCurrRD[1] = &(pDevice->aRD1Ring[0]);
1319}
1320
1321static void device_init_defrag_cb(PSDevice pDevice) {
1322 int i;
1323 PSDeFragControlBlock pDeF;
1324
1325
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);
1331 }
1332 }
1333 pDevice->cbDFCB = CB_MAX_RX_FRAG;
1334 pDevice->cbFreeDFCB = pDevice->cbDFCB;
1335}
1336
1337static void device_free_rd0_ring(PSDevice pDevice) {
1338 int i;
1339
1340 for (i = 0; i < pDevice->sOpts.nRxDescs0; i++) {
1341 PSRxDesc pDesc = &(pDevice->aRD0Ring[i]);
1342 PDEVICE_RD_INFO pRDInfo = pDesc->pRDInfo;
1343
1344 pci_unmap_single(pDevice->pcid, pRDInfo->skb_dma,
1345 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1346
1347 dev_kfree_skb(pRDInfo->skb);
1348
1349 kfree((void *)pDesc->pRDInfo);
1350 }
1351}
1352
1353static void device_free_rd1_ring(PSDevice pDevice) {
1354 int i;
1355
1356 for (i = 0; i < pDevice->sOpts.nRxDescs1; i++) {
1357 PSRxDesc pDesc = &(pDevice->aRD1Ring[i]);
1358 PDEVICE_RD_INFO pRDInfo = pDesc->pRDInfo;
1359
1360 pci_unmap_single(pDevice->pcid, pRDInfo->skb_dma,
1361 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1362
1363 dev_kfree_skb(pRDInfo->skb);
1364
1365 kfree((void *)pDesc->pRDInfo);
1366 }
1367}
1368
1369static void device_free_frag_buf(PSDevice pDevice) {
1370 PSDeFragControlBlock pDeF;
1371 int i;
1372
1373 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1374 pDeF = &(pDevice->sRxDFCB[i]);
1375
1376 if (pDeF->skb)
1377 dev_kfree_skb(pDeF->skb);
1378
1379 }
1380}
1381
1382static void device_init_td0_ring(PSDevice pDevice) {
1383 int i;
1384 dma_addr_t curr;
1385 PSTxDesc pDesc;
1386
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;
1395 }
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));
1399 }
1400
1401 if (i > 0)
1402 pDevice->apTD0Rings[i-1].next_desc = cpu_to_le32(pDevice->td0_pool_dma);
1403 pDevice->apTailTD[0] = pDevice->apCurrTD[0] = &(pDevice->apTD0Rings[0]);
1404}
1405
1406static void device_init_td1_ring(PSDevice pDevice) {
1407 int i;
1408 dma_addr_t curr;
1409 PSTxDesc pDesc;
1410
1411
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;
1420 }
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));
1424 }
1425
1426 if (i > 0)
1427 pDevice->apTD1Rings[i-1].next_desc = cpu_to_le32(pDevice->td1_pool_dma);
1428 pDevice->apTailTD[1] = pDevice->apCurrTD[1] = &(pDevice->apTD1Rings[0]);
1429}
1430
1431static void device_free_td0_ring(PSDevice pDevice) {
1432 int i;
1433 for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++) {
1434 PSTxDesc pDesc = &(pDevice->apTD0Rings[i]);
1435 PDEVICE_TD_INFO pTDInfo = pDesc->pTDInfo;
1436
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);
1440
1441 if (pTDInfo->skb)
1442 dev_kfree_skb(pTDInfo->skb);
1443
1444 kfree((void *)pDesc->pTDInfo);
1445 }
1446}
1447
1448static void device_free_td1_ring(PSDevice pDevice) {
1449 int i;
1450
1451 for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++) {
1452 PSTxDesc pDesc = &(pDevice->apTD1Rings[i]);
1453 PDEVICE_TD_INFO pTDInfo = pDesc->pTDInfo;
1454
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);
1458
1459 if (pTDInfo->skb)
1460 dev_kfree_skb(pTDInfo->skb);
1461
1462 kfree((void *)pDesc->pTDInfo);
1463 }
1464}
1465
1466
1467
1468static int device_rx_srv(PSDevice pDevice, unsigned int uIdx) {
1469 PSRxDesc pRD;
1470 int works = 0;
1471
1472 for (pRD = pDevice->pCurrRD[uIdx];
1473 pRD->m_rd0RD0.f1Owner == OWNED_BY_HOST;
1474 pRD = pRD->next) {
1475
1476 if (works++ > 15)
1477 break;
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);
1482 break;
1483 }
1484 }
1485 pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1486 pDevice->dev->last_rx = jiffies;
1487 }
1488
1489 pDevice->pCurrRD[uIdx] = pRD;
1490
1491 return works;
1492}
1493
1494static bool device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pRD) {
1495 PDEVICE_RD_INFO pRDInfo = pRD->pRDInfo;
1496
1497 pRDInfo->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1498 if (pRDInfo->skb == NULL)
1499 return false;
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;
1505
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);
1510
1511 return true;
1512}
1513
1514bool device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1515 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1516 if (pDeF->skb == NULL)
1517 return false;
1518 ASSERT(pDeF->skb);
1519 pDeF->skb->dev = pDevice->dev;
1520
1521 return true;
1522}
1523
1524static int device_tx_srv(PSDevice pDevice, unsigned int uIdx) {
1525 PSTxDesc pTD;
1526 bool bFull = false;
1527 int works = 0;
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;
1536
1537 for (pTD = pDevice->apTailTD[uIdx]; pDevice->iTDUsed[uIdx] > 0; pTD = pTD->next) {
1538 if (pTD->m_td0TD0.f1Owner == OWNED_BY_NIC)
1539 break;
1540 if (works++ > 15)
1541 break;
1542
1543 byTsr0 = pTD->m_td0TD0.byTSR0;
1544 byTsr1 = pTD->m_td0TD0.byTSR1;
1545
1546
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
1553
1554
1555 STAvUpdateTDStatCounter(&pDevice->scStatistic,
1556 byTsr0, byTsr1,
1557 (unsigned char *)(pTD->pTDInfo->buf + uFIFOHeaderSize),
1558 uFrameSize, uIdx);
1559
1560 BSSvUpdateNodeTxCounter(pDevice,
1561 byTsr0, byTsr1,
1562 (unsigned char *)(pTD->pTDInfo->buf),
1563 uFIFOHeaderSize
1564 );
1565
1566 if (!(byTsr1 & TSR1_TERR)) {
1567 if (byTsr0 != 0) {
1568 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Tx[%d] OK but has error. tsr1[%02X] tsr0[%02X].\n",
1569 (int)uIdx, byTsr1, byTsr0);
1570 }
1571 if ((pTxBufHead->wFragCtl & FRAGCTL_ENDFRAG) != FRAGCTL_NONFRAG) {
1572 pDevice->s802_11Counter.TransmittedFragmentCount++;
1573 }
1574 pStats->tx_packets++;
1575 pStats->tx_bytes += pTD->pTDInfo->skb->len;
1576 } else {
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++;
1581 }
1582 }
1583
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
1592 memset(skb->cb, 0, sizeof(skb->cb));
1593 netif_rx(skb);
1594 }
1595 }
1596
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);
1601 }
1602
1603
1604
1605
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};
1610
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++;
1616
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--;
1624 }
1625 }
1626 }
1627 }
1628 device_free_tx_buf(pDevice, pTD);
1629 pDevice->iTDUsed[uIdx]--;
1630 }
1631 }
1632
1633 if (uIdx == TYPE_AC0DMA) {
1634
1635
1636 if (AVAIL_TD(pDevice, uIdx) < RESERV_AC0DMA) {
1637 bFull = true;
1638 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " AC0DMA is Full = %d\n", pDevice->iTDUsed[uIdx]);
1639 }
1640 if (netif_queue_stopped(pDevice->dev) && (bFull == false)) {
1641 netif_wake_queue(pDevice->dev);
1642 }
1643 }
1644
1645 pDevice->apTailTD[uIdx] = pTD;
1646
1647 return works;
1648}
1649
1650static 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);
1660 return;
1661 }
1662}
1663
1664static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc) {
1665 PDEVICE_TD_INFO pTDInfo = pDesc->pTDInfo;
1666 struct sk_buff *skb = pTDInfo->skb;
1667
1668
1669 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma)) {
1670 pci_unmap_single(pDevice->pcid, pTDInfo->skb_dma, skb->len,
1671 PCI_DMA_TODEVICE);
1672 }
1673
1674 if ((pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0)
1675 dev_kfree_skb_irq(skb);
1676
1677 pTDInfo->skb_dma = 0;
1678 pTDInfo->skb = 0;
1679 pTDInfo->byFlags = 0;
1680}
1681
1682
1683void InitRxManagementQueue(PSDevice pDevice)
1684{
1685 pDevice->rxManeQueue.packet_num = 0;
1686 pDevice->rxManeQueue.head = pDevice->rxManeQueue.tail = 0;
1687}
1688
1689
1690
1691int MlmeThread(
1692 void *Context)
1693{
1694 PSDevice pDevice = (PSDevice) Context;
1695 PSRxMgmtPacket pRxMgmtPacket;
1696
1697
1698
1699
1700#if 1
1701 while (1) {
1702
1703
1704#if 1
1705 spin_lock_irq(&pDevice->lock);
1706 while (pDevice->rxManeQueue.packet_num != 0) {
1707 pRxMgmtPacket = DeQueue(pDevice);
1708
1709
1710 vMgrRxManagePacket(pDevice, pDevice->pMgmt, pRxMgmtPacket);
1711 }
1712 spin_unlock_irq(&pDevice->lock);
1713 if (mlme_kill == 0)
1714 break;
1715
1716#endif
1717 schedule();
1718 if (mlme_kill == 0)
1719 break;
1720 }
1721
1722#endif
1723 return 0;
1724}
1725
1726static int device_open(struct net_device *dev) {
1727 PSDevice pDevice = (PSDevice)netdev_priv(dev);
1728 int i;
1729#ifdef WPA_SM_Transtatus
1730 extern SWPAResult wpa_Result;
1731#endif
1732
1733 pDevice->rx_buf_sz = PKT_BUF_SZ;
1734 if (!device_init_rings(pDevice)) {
1735 return -ENOMEM;
1736 }
1737
1738 i = request_irq(pDevice->pcid->irq, &device_intr, IRQF_SHARED, dev->name, dev);
1739 if (i)
1740 return i;
1741
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;
1749#endif
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
1757
1758 if (pDevice->bDiversityRegCtlON) {
1759 device_init_diversity_timer(pDevice);
1760 }
1761 vMgrObjectInit(pDevice);
1762 vMgrTimerInit(pDevice);
1763
1764
1765#ifdef TASK_LET
1766 tasklet_init(&pDevice->RxMngWorkItem, (void *)MngWorkItem, (unsigned long)pDevice);
1767#endif
1768#ifdef THREAD
1769 InitRxManagementQueue(pDevice);
1770 mlme_kill = 0;
1771 mlme_task = kthread_run(MlmeThread, (void *)pDevice, "MLME");
1772 if (IS_ERR(mlme_task)) {
1773 printk("thread create fail\n");
1774 return -1;
1775 }
1776
1777 mlme_kill = 1;
1778#endif
1779
1780
1781
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);
1787
1788
1789 KeyvInitTable(&pDevice->sKey, pDevice->PortOffset);
1790 add_timer(&(pDevice->pMgmt->sTimerSecondCallback));
1791
1792#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1793
1794
1795
1796
1797
1798
1799 pDevice->bwextcount = 0;
1800 pDevice->bWPASuppWextEnabled = false;
1801#endif
1802 pDevice->byReAssocCount = 0;
1803 pDevice->bWPADEVUp = false;
1804
1805 if ((pDevice->bEncryptionEnable == true) && (pDevice->bTransmitKey == true)) {
1806 KeybSetDefaultKey(&(pDevice->sKey),
1807 (unsigned long)(pDevice->byKeyIndex | (1 << 31)),
1808 pDevice->uKeyLength,
1809 NULL,
1810 pDevice->abyKey,
1811 KEY_CTL_WEP,
1812 pDevice->PortOffset,
1813 pDevice->byLocalID
1814 );
1815 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1816 }
1817
1818 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call MACvIntEnable\n");
1819 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
1820
1821 if (pDevice->pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1822 bScheduleCommand((void *)pDevice, WLAN_CMD_RUN_AP, NULL);
1823 } else {
1824 bScheduleCommand((void *)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1825 bScheduleCommand((void *)pDevice, WLAN_CMD_SSID, NULL);
1826 }
1827 pDevice->flags |= DEVICE_FLAGS_OPENED;
1828
1829 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1830 return 0;
1831}
1832
1833static int device_close(struct net_device *dev) {
1834 PSDevice pDevice = (PSDevice)netdev_priv(dev);
1835 PSMgmtObject pMgmt = pDevice->pMgmt;
1836
1837#ifdef THREAD
1838 mlme_kill = 0;
1839#endif
1840
1841
1842 if (pDevice->bLinkPass) {
1843 bScheduleCommand((void *)pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1844 mdelay(30);
1845 }
1846#ifdef TxInSleep
1847 del_timer(&pDevice->sTimerTxData);
1848#endif
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);
1855 }
1856
1857#ifdef TASK_LET
1858 tasklet_kill(&pDevice->RxMngWorkItem);
1859#endif
1860 netif_stop_queue(dev);
1861 pDevice->bCmdRunning = false;
1862 MACbShutdown(pDevice->PortOffset);
1863 MACbSoftwareReset(pDevice->PortOffset);
1864 CARDbRadioPowerOff(pDevice);
1865
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
1879 device_release_WPADEV(pDevice);
1880
1881
1882
1883 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close.. \n");
1884 return 0;
1885}
1886
1887static 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;
1891
1892 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211\n");
1893 spin_lock_irq(&pDevice->lock);
1894
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);
1899 return 0;
1900 }
1901
1902 if (pDevice->bStopTx0Pkt == true) {
1903 dev_kfree_skb_irq(skb);
1904 spin_unlock_irq(&pDevice->lock);
1905 return 0;
1906 }
1907
1908 cbMPDULen = skb->len;
1909 pbMPDU = skb->data;
1910
1911 vDMA0_tx_80211(pDevice, skb, pbMPDU, cbMPDULen);
1912
1913 spin_unlock_irq(&pDevice->lock);
1914
1915 return 0;
1916}
1917
1918bool 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;
1927 unsigned int ii;
1928 SKeyItem STempKey;
1929
1930
1931 if (pDevice->bStopTx0Pkt == true) {
1932 dev_kfree_skb_irq(skb);
1933 return false;
1934 }
1935
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");
1939 return false;
1940 }
1941
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");
1946 return false;
1947 }
1948 }
1949
1950 pHeadTD = pDevice->apCurrTD[TYPE_TXDMA0];
1951
1952 pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
1953
1954 memcpy(pDevice->sTxEthHeader.abyDstAddr, (unsigned char *)(skb->data), ETH_HLEN);
1955 cbFrameBodySize = skb->len - ETH_HLEN;
1956
1957
1958 if (ntohs(pDevice->sTxEthHeader.wType) > ETH_DATA_LEN) {
1959 cbFrameBodySize += 8;
1960 }
1961 uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
1962
1963 if (uMACfragNum > AVAIL_TD(pDevice, TYPE_TXDMA0)) {
1964 dev_kfree_skb_irq(skb);
1965 return false;
1966 }
1967 byPktType = (unsigned char)pDevice->byPacketType;
1968
1969 if (pDevice->bFixRate) {
1970 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
1971 if (pDevice->uConnectionRate >= RATE_11M) {
1972 pDevice->wCurrentRate = RATE_11M;
1973 } else {
1974 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
1975 }
1976 } else {
1977 if (pDevice->uConnectionRate >= RATE_54M)
1978 pDevice->wCurrentRate = RATE_54M;
1979 else
1980 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
1981 }
1982 } else {
1983 pDevice->wCurrentRate = pDevice->pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
1984 }
1985
1986
1987 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
1988 pDevice->byPreambleType = pDevice->byShortPreamble;
1989 } else {
1990 pDevice->byPreambleType = PREAMBLE_LONG;
1991 }
1992
1993 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate);
1994
1995 if (pDevice->wCurrentRate <= RATE_11M) {
1996 byPktType = PK_TYPE_11B;
1997 } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
1998 byPktType = PK_TYPE_11A;
1999 } else {
2000 if (pDevice->bProtectMode == true) {
2001 byPktType = PK_TYPE_11GB;
2002 } else {
2003 byPktType = PK_TYPE_11GA;
2004 }
2005 }
2006
2007 if (pDevice->bEncryptionEnable == true)
2008 bNeedEncryption = true;
2009
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
2020 );
2021 }
2022 vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption,
2023 cbFrameBodySize, TYPE_TXDMA0, pHeadTD,
2024 &pDevice->sTxEthHeader, (unsigned char *)skb->data, pTransmitKey, uNodeIndex,
2025 &uMACfragNum,
2026 &cbHeaderSize
2027 );
2028
2029 if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
2030
2031 MACbPSWakeup(pDevice->PortOffset);
2032 }
2033
2034 pDevice->bPWBitOn = false;
2035
2036 pLastTD = pHeadTD;
2037 for (ii = 0; ii < uMACfragNum; ii++) {
2038
2039 wmb();
2040 pHeadTD->m_td0TD0.f1Owner = OWNED_BY_NIC;
2041 wmb();
2042 if (ii == (uMACfragNum - 1))
2043 pLastTD = pHeadTD;
2044 pHeadTD = pHeadTD->next;
2045 }
2046
2047
2048
2049 pLastTD->pTDInfo->skb = skb;
2050 pLastTD->pTDInfo->byFlags = 0;
2051 pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
2052
2053 pDevice->apCurrTD[TYPE_TXDMA0] = pHeadTD;
2054
2055 MACvTransmit0(pDevice->PortOffset);
2056
2057 return true;
2058}
2059
2060
2061static int device_xmit(struct sk_buff *skb, struct net_device *dev) {
2062 PSDevice pDevice = netdev_priv(dev);
2063
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;
2075 SKeyItem STempKey;
2076 unsigned int ii;
2077 bool bTKIP_UseGTK = false;
2078 bool bNeedDeAuth = false;
2079 unsigned char *pbyBSSID;
2080 bool bNodeExist = false;
2081
2082 spin_lock_irq(&pDevice->lock);
2083 if (pDevice->bLinkPass == false) {
2084 dev_kfree_skb_irq(skb);
2085 spin_unlock_irq(&pDevice->lock);
2086 return 0;
2087 }
2088
2089 if (pDevice->bStopDataPkt) {
2090 dev_kfree_skb_irq(skb);
2091 spin_unlock_irq(&pDevice->lock);
2092 return 0;
2093 }
2094
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);
2099 return 0;
2100 }
2101 if (is_multicast_ether_addr((unsigned char *)(skb->data))) {
2102 uNodeIndex = 0;
2103 bNodeExist = true;
2104 if (pMgmt->sNodeDBTable[0].bPSEnable) {
2105 skb_queue_tail(&(pMgmt->sNodeDBTable[0].sTxPSQueue), skb);
2106 pMgmt->sNodeDBTable[0].wEnQueueCnt++;
2107
2108 pMgmt->abyPSTxMap[0] |= byMask[0];
2109 spin_unlock_irq(&pDevice->lock);
2110 return 0;
2111 }
2112 } else {
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++;
2117
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);
2123 return 0;
2124 }
2125
2126 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2127 pDevice->byPreambleType = pDevice->byShortPreamble;
2128
2129 } else {
2130 pDevice->byPreambleType = PREAMBLE_LONG;
2131 }
2132 bNodeExist = true;
2133
2134 }
2135 }
2136
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);
2141 return 0;
2142 }
2143 }
2144
2145 pHeadTD = pDevice->apCurrTD[TYPE_AC0DMA];
2146
2147 pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
2148
2149 memcpy(pDevice->sTxEthHeader.abyDstAddr, (unsigned char *)(skb->data), ETH_HLEN);
2150 cbFrameBodySize = skb->len - ETH_HLEN;
2151
2152 if (ntohs(pDevice->sTxEthHeader.wType) > ETH_DATA_LEN) {
2153 cbFrameBodySize += 8;
2154 }
2155
2156 if (pDevice->bEncryptionEnable == true) {
2157 bNeedEncryption = true;
2158
2159 do {
2160 if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
2161 (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2162 pbyBSSID = pDevice->abyBSSID;
2163
2164 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == false) {
2165
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");
2169 break;
2170 }
2171 } else {
2172 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "Get PTK.\n");
2173 break;
2174 }
2175 } else if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2176 pbyBSSID = pDevice->sTxEthHeader.abyDstAddr;
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");
2181
2182
2183 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == true)
2184 break;
2185 }
2186
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);
2192 } else
2193 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "NOT IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode);
2194 } else {
2195 bTKIP_UseGTK = true;
2196 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG "Get GTK.\n");
2197 }
2198 } while (false);
2199 }
2200
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
2213 );
2214 }
2215 }
2216
2217 uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
2218
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);
2223 return 0;
2224 }
2225
2226 if (pTransmitKey != NULL) {
2227 if ((pTransmitKey->byCipherSuite == KEY_CTL_WEP) &&
2228 (pTransmitKey->uKeyLength == WLAN_WEP232_KEYLEN)) {
2229 uMACfragNum = 1;
2230 }
2231 }
2232
2233 byPktType = (unsigned char)pDevice->byPacketType;
2234
2235 if (pDevice->bFixRate) {
2236#ifdef PLICE_DEBUG
2237 printk("Fix Rate: PhyType is %d,ConnectionRate is %d\n", pDevice->eCurrentPHYType, pDevice->uConnectionRate);
2238#endif
2239
2240 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
2241 if (pDevice->uConnectionRate >= RATE_11M) {
2242 pDevice->wCurrentRate = RATE_11M;
2243 } else {
2244 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
2245 }
2246 } else {
2247 if ((pDevice->eCurrentPHYType == PHY_TYPE_11A) &&
2248 (pDevice->uConnectionRate <= RATE_6M)) {
2249 pDevice->wCurrentRate = RATE_6M;
2250 } else {
2251 if (pDevice->uConnectionRate >= RATE_54M)
2252 pDevice->wCurrentRate = RATE_54M;
2253 else
2254 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
2255
2256 }
2257 }
2258 pDevice->byACKRate = (unsigned char) pDevice->wCurrentRate;
2259 pDevice->byTopCCKBasicRate = RATE_1M;
2260 pDevice->byTopOFDMBasicRate = RATE_6M;
2261 } else {
2262
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;
2269 } else {
2270 pDevice->wCurrentRate = RATE_6M;
2271 pDevice->byACKRate = RATE_6M;
2272 pDevice->byTopCCKBasicRate = RATE_1M;
2273 pDevice->byTopOFDMBasicRate = RATE_6M;
2274 }
2275 } else {
2276 VNTWIFIvGetTxRate(pDevice->pMgmt,
2277 pDevice->sTxEthHeader.abyDstAddr,
2278 &(pDevice->wCurrentRate),
2279 &(pDevice->byACKRate),
2280 &(pDevice->byTopCCKBasicRate),
2281 &(pDevice->byTopOFDMBasicRate));
2282
2283 }
2284 }
2285
2286
2287
2288 if (pDevice->wCurrentRate <= RATE_11M) {
2289 byPktType = PK_TYPE_11B;
2290 } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
2291 byPktType = PK_TYPE_11A;
2292 } else {
2293 if (pDevice->bProtectMode == true) {
2294 byPktType = PK_TYPE_11GB;
2295 } else {
2296 byPktType = PK_TYPE_11GA;
2297 }
2298 }
2299
2300
2301
2302
2303
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");
2312 } else {
2313 if (bTKIP_UseGTK == true) {
2314 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "error: KEY is GTK!!~~\n");
2315 } else {
2316 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
2317 bNeedEncryption = true;
2318 }
2319 }
2320 }
2321
2322 if (pDevice->byCntMeasure == 2) {
2323 bNeedDeAuth = true;
2324 pDevice->s802_11Counter.TKIPCounterMeasuresInvoked++;
2325 }
2326
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;
2332 }
2333 }
2334 } else {
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);
2339 return 0;
2340 }
2341 }
2342 }
2343
2344 vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption,
2345 cbFrameBodySize, TYPE_AC0DMA, pHeadTD,
2346 &pDevice->sTxEthHeader, (unsigned char *)skb->data, pTransmitKey, uNodeIndex,
2347 &uMACfragNum,
2348 &cbHeaderSize
2349 );
2350
2351 if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
2352
2353 MACbPSWakeup(pDevice->PortOffset);
2354 }
2355 pDevice->bPWBitOn = false;
2356
2357 pLastTD = pHeadTD;
2358 for (ii = 0; ii < uMACfragNum; ii++) {
2359
2360 wmb();
2361 pHeadTD->m_td0TD0.f1Owner = OWNED_BY_NIC;
2362 wmb();
2363 if (ii == uMACfragNum - 1)
2364 pLastTD = pHeadTD;
2365 pHeadTD = pHeadTD->next;
2366 }
2367
2368
2369
2370 pLastTD->pTDInfo->skb = skb;
2371 pLastTD->pTDInfo->byFlags = 0;
2372 pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
2373#ifdef TxInSleep
2374 pDevice->nTxDataTimeCout = 0;
2375#endif
2376 if (AVAIL_TD(pDevice, TYPE_AC0DMA) <= 1) {
2377 netif_stop_queue(dev);
2378 }
2379
2380 pDevice->apCurrTD[TYPE_AC0DMA] = pHeadTD;
2381
2382 if (pDevice->bFixRate) {
2383 printk("FixRate:Rate is %d,TxPower is %d\n", pDevice->wCurrentRate, pDevice->byCurPwr);
2384 } else {
2385 }
2386
2387
2388 {
2389 unsigned char Protocol_Version;
2390 unsigned char Packet_Type;
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)) {
2401 bTxeapol_key = true;
2402 if ((Descriptor_type == 254) || (Descriptor_type == 2)) {
2403 if (!(Key_info & BIT3) &&
2404 (Key_info & BIT8) && (Key_info & BIT9)) {
2405 pDevice->fWPA_Authened = true;
2406 if (Descriptor_type == 254)
2407 printk("WPA ");
2408 else
2409 printk("WPA2 ");
2410 printk("Authentication completed!!\n");
2411 }
2412 }
2413 }
2414 }
2415 }
2416
2417 MACvTransmitAC0(pDevice->PortOffset);
2418
2419
2420 dev->trans_start = jiffies;
2421
2422 spin_unlock_irq(&pDevice->lock);
2423 return 0;
2424}
2425
2426static irqreturn_t device_intr(int irq, void *dev_instance) {
2427 struct net_device *dev = dev_instance;
2428 PSDevice pDevice = (PSDevice)netdev_priv(dev);
2429
2430 int max_count = 0;
2431 unsigned long dwMIBCounter = 0;
2432 PSMgmtObject pMgmt = pDevice->pMgmt;
2433 unsigned char byOrgPageSel = 0;
2434 int handled = 0;
2435 unsigned char byData = 0;
2436 int ii = 0;
2437
2438
2439 MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr);
2440
2441 if (pDevice->dwIsr == 0)
2442 return IRQ_RETVAL(handled);
2443
2444 if (pDevice->dwIsr == 0xffffffff) {
2445 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dwIsr = 0xffff\n");
2446 return IRQ_RETVAL(handled);
2447 }
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460 handled = 1;
2461 MACvIntDisable(pDevice->PortOffset);
2462 spin_lock_irq(&pDevice->lock);
2463
2464
2465 VNSvInPortB(pDevice->PortOffset + MAC_REG_PAGE1SEL, &byOrgPageSel);
2466 if (byOrgPageSel == 1) {
2467 MACvSelectPage0(pDevice->PortOffset);
2468 } else
2469 byOrgPageSel = 0;
2470
2471 MACvReadMIBCounter(pDevice->PortOffset, &dwMIBCounter);
2472
2473
2474
2475
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);
2480
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);
2486 }
2487
2488 if (pDevice->byLocalID > REV_ID_VT3253_B1) {
2489 if (pDevice->dwIsr & ISR_MEASURESTART) {
2490
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);
2498
2499
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;
2509 }
2510 } else {
2511
2512
2513
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);
2519 }
2520 }
2521 if (pDevice->dwIsr & ISR_MEASUREEND) {
2522
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
2533 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN);
2534 MACvSelectPage0(pDevice->PortOffset);
2535 set_channel(pDevice, pDevice->byOrgChannel);
2536
2537 MACvSelectPage1(pDevice->PortOffset);
2538 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2539 MACvSelectPage0(pDevice->PortOffset);
2540 if (byData & MSRCTL_FINISH) {
2541
2542 s_vCompleteCurrentMeasure(pDevice, 0);
2543 } else {
2544
2545 s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_LATE);
2546 }
2547 }
2548 if (pDevice->dwIsr & ISR_QUIETSTART) {
2549 do {
2550 ;
2551 } while (CARDbStartQuiet(pDevice) == false);
2552 }
2553 }
2554
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);
2563 }
2564 }
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);
2576
2577 }
2578 }
2579 if (pDevice->eOPMode == OP_MODE_ADHOC) {
2580
2581 } else {
2582 if ((pDevice->bUpdateBBVGA) && (pDevice->bLinkPass == true) && (pDevice->uCurrRSSI != 0)) {
2583 long ldBm;
2584
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];
2589 break;
2590 }
2591 }
2592 if (pDevice->byBBVGANew != pDevice->byBBVGACurrent) {
2593 pDevice->uBBVGADiffCount++;
2594 if (pDevice->uBBVGADiffCount == 1) {
2595
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);
2599 }
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);
2604 }
2605 } else {
2606 pDevice->uBBVGADiffCount = 1;
2607 }
2608 }
2609 }
2610
2611 pDevice->bBeaconSent = false;
2612 if (pDevice->bEnablePSMode) {
2613 PSbIsNextTBTTWakeUp((void *)pDevice);
2614 }
2615
2616 if ((pDevice->eOPMode == OP_MODE_AP) ||
2617 (pDevice->eOPMode == OP_MODE_ADHOC)) {
2618 MACvOneShotTimer1MicroSec(pDevice->PortOffset,
2619 (pMgmt->wIBSSBeaconPeriod - MAKE_BEACON_RESERVED) << 10);
2620 }
2621
2622 if (pDevice->eOPMode == OP_MODE_ADHOC && pDevice->pMgmt->wCurrATIMWindow > 0) {
2623
2624 }
2625
2626 }
2627
2628 if (pDevice->dwIsr & ISR_BNTX) {
2629 if (pDevice->eOPMode == OP_MODE_ADHOC) {
2630 pDevice->bIsBeaconBufReadySet = false;
2631 pDevice->cbBeaconBufReadySetCnt = 0;
2632 }
2633
2634 if (pDevice->eOPMode == OP_MODE_AP) {
2635 if (pMgmt->byDTIMCount > 0) {
2636 pMgmt->byDTIMCount--;
2637 pMgmt->sNodeDBTable[0].bRxPSPoll = false;
2638 } else {
2639 if (pMgmt->byDTIMCount == 0) {
2640
2641 pMgmt->byDTIMCount = pMgmt->byDTIMPeriod - 1;
2642 pMgmt->sNodeDBTable[0].bRxPSPoll = true;
2643 bScheduleCommand((void *)pDevice, WLAN_CMD_RX_PSPOLL, NULL);
2644 }
2645 }
2646 }
2647 pDevice->bBeaconSent = true;
2648
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
2659 CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL);
2660 }
2661 }
2662
2663 }
2664
2665 if (pDevice->dwIsr & ISR_RXDMA0) {
2666 max_count += device_rx_srv(pDevice, TYPE_RXDMA0);
2667 }
2668 if (pDevice->dwIsr & ISR_RXDMA1) {
2669 max_count += device_rx_srv(pDevice, TYPE_RXDMA1);
2670 }
2671 if (pDevice->dwIsr & ISR_TXDMA0) {
2672 max_count += device_tx_srv(pDevice, TYPE_TXDMA0);
2673 }
2674 if (pDevice->dwIsr & ISR_AC0DMA) {
2675 max_count += device_tx_srv(pDevice, TYPE_AC0DMA);
2676 }
2677 if (pDevice->dwIsr & ISR_SOFTTIMER) {
2678 }
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);
2683 else
2684 pMgmt->wCurrCapInfo &= ~(WLAN_SET_CAP_INFO_SHORTSLOTTIME(1));
2685 }
2686 bMgrPrepareBeaconToSend(pDevice, pMgmt);
2687 pDevice->byCntMeasure = 0;
2688 }
2689
2690 MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr);
2691
2692 MACvReceive0(pDevice->PortOffset);
2693 MACvReceive1(pDevice->PortOffset);
2694
2695 if (max_count > pDevice->sOpts.int_works)
2696 break;
2697 }
2698
2699 if (byOrgPageSel == 1) {
2700 MACvSelectPage1(pDevice->PortOffset);
2701 }
2702
2703 spin_unlock_irq(&pDevice->lock);
2704 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
2705
2706 return IRQ_RETVAL(handled);
2707}
2708
2709static unsigned const ethernet_polynomial = 0x04c11db7U;
2710static inline u32 ether_crc(int length, unsigned char *data)
2711{
2712 int crc = -1;
2713
2714 while (--length >= 0) {
2715 unsigned char current_octet = *data++;
2716 int bit;
2717 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
2718 crc = (crc << 1) ^
2719 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
2720 }
2721 }
2722 return crc;
2723}
2724
2725
2726static int Config_FileGetParameter(unsigned char *string,
2727 unsigned char *dest, unsigned char *source)
2728{
2729 unsigned char buf1[100];
2730 int source_len = strlen(source);
2731
2732 memset(buf1, 0, 100);
2733 strcat(buf1, string);
2734 strcat(buf1, "=");
2735 source += strlen(buf1);
2736
2737 memcpy(dest, source, source_len - strlen(buf1));
2738 return true;
2739}
2740
2741int Config_FileOperation(PSDevice pDevice,bool fwrite,unsigned char *Parameter)
2742{
2743 unsigned char *buffer = kmalloc(1024, GFP_KERNEL);
2744 unsigned char tmpbuffer[20];
2745 struct file *file;
2746 int result=0;
2747
2748 if (!buffer) {
2749 printk("allocate mem for file fail?\n");
2750 return -1;
2751 }
2752 file = filp_open(CONFIG_PATH, O_RDONLY, 0);
2753 if (IS_ERR(file)) {
2754 kfree(buffer);
2755 printk("Config_FileOperation:open file fail?\n");
2756 return -1;
2757 }
2758
2759 if (kernel_read(file, 0, buffer, 1024) < 0) {
2760 printk("read file error?\n");
2761 result = -1;
2762 goto error1;
2763 }
2764
2765 if (Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer)!=true) {
2766 printk("get parameter error?\n");
2767 result = -1;
2768 goto error1;
2769 }
2770
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;
2777 } else {
2778 result = -1;
2779 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
2780 }
2781
2782error1:
2783 kfree(buffer);
2784 fput(file);
2785 return result;
2786}
2787
2788static void device_set_multi(struct net_device *dev) {
2789 PSDevice pDevice = (PSDevice)netdev_priv(dev);
2790
2791 PSMgmtObject pMgmt = pDevice->pMgmt;
2792 u32 mc_filter[2];
2793 struct netdev_hw_addr *ha;
2794
2795 VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byRxMode));
2796
2797 if (dev->flags & IFF_PROMISC) {
2798 DBG_PRT(MSG_LEVEL_ERR, KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
2799
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);
2808 } else {
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));
2813 }
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);
2820 }
2821
2822 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2823
2824 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
2825 pDevice->byRxMode &= ~(RCR_UNICAST);
2826 }
2827
2828 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byRxMode);
2829 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode = %x\n", pDevice->byRxMode);
2830}
2831
2832static struct net_device_stats *device_get_stats(struct net_device *dev) {
2833 PSDevice pDevice = (PSDevice)netdev_priv(dev);
2834
2835 return &pDevice->stats;
2836}
2837
2838static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
2839 PSDevice pDevice = (PSDevice)netdev_priv(dev);
2840
2841 struct iwreq *wrq = (struct iwreq *)rq;
2842 int rc = 0;
2843 PSMgmtObject pMgmt = pDevice->pMgmt;
2844 PSCmdRequest pReq;
2845
2846 if (pMgmt == NULL) {
2847 rc = -EFAULT;
2848 return rc;
2849 }
2850
2851 switch (cmd) {
2852 case SIOCGIWNAME:
2853 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
2854 break;
2855
2856 case SIOCGIWNWID:
2857 rc = -EOPNOTSUPP;
2858 break;
2859
2860
2861 case SIOCSIWFREQ:
2862 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
2863 break;
2864
2865
2866 case SIOCGIWFREQ:
2867 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
2868 break;
2869
2870
2871 case SIOCSIWESSID:
2872
2873 {
2874 char essid[IW_ESSID_MAX_SIZE+1];
2875 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
2876 rc = -E2BIG;
2877 break;
2878 }
2879 if (copy_from_user(essid, wrq->u.essid.pointer,
2880 wrq->u.essid.length)) {
2881 rc = -EFAULT;
2882 break;
2883 }
2884 rc = iwctl_siwessid(dev, NULL,
2885 &(wrq->u.essid), essid);
2886 }
2887 break;
2888
2889
2890 case SIOCGIWESSID:
2891
2892 {
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,
2898 essid,
2899 wrq->u.essid.length))
2900 rc = -EFAULT;
2901 }
2902 break;
2903
2904 case SIOCSIWAP:
2905
2906 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
2907 break;
2908
2909
2910 case SIOCGIWAP:
2911 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
2912 break;
2913
2914
2915 case SIOCSIWNICKN:
2916 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
2917 rc = -EOPNOTSUPP;
2918 break;
2919
2920
2921 case SIOCGIWNICKN:
2922 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
2923 rc = -EOPNOTSUPP;
2924 break;
2925
2926
2927 case SIOCSIWRATE:
2928 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
2929 break;
2930
2931
2932 case SIOCGIWRATE:
2933
2934 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
2935 break;
2936
2937
2938 case SIOCSIWRTS:
2939
2940 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
2941 break;
2942
2943
2944 case SIOCGIWRTS:
2945
2946 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
2947 break;
2948
2949
2950 case SIOCSIWFRAG:
2951
2952 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
2953 break;
2954
2955
2956 case SIOCGIWFRAG:
2957
2958 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
2959 break;
2960
2961
2962 case SIOCSIWMODE:
2963 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
2964 break;
2965
2966
2967 case SIOCGIWMODE:
2968 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
2969 break;
2970
2971
2972 case SIOCSIWENCODE: {
2973 char abyKey[WLAN_WEP232_KEYLEN];
2974
2975 if (wrq->u.encoding.pointer) {
2976 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
2977 rc = -E2BIG;
2978 break;
2979 }
2980 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
2981 if (copy_from_user(abyKey,
2982 wrq->u.encoding.pointer,
2983 wrq->u.encoding.length)) {
2984 rc = -EFAULT;
2985 break;
2986 }
2987 } else if (wrq->u.encoding.length != 0) {
2988 rc = -EINVAL;
2989 break;
2990 }
2991 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
2992 }
2993 break;
2994
2995
2996 case SIOCGIWENCODE:
2997
2998 if (!capable(CAP_NET_ADMIN)) {
2999 rc = -EPERM;
3000 break;
3001 }
3002 {
3003 char abyKey[WLAN_WEP232_KEYLEN];
3004
3005 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
3006 if (rc != 0) break;
3007 if (wrq->u.encoding.pointer) {
3008 if (copy_to_user(wrq->u.encoding.pointer,
3009 abyKey,
3010 wrq->u.encoding.length))
3011 rc = -EFAULT;
3012 }
3013 }
3014 break;
3015
3016
3017 case SIOCGIWTXPOW:
3018 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
3019 rc = -EOPNOTSUPP;
3020 break;
3021
3022 case SIOCSIWTXPOW:
3023 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWTXPOW \n");
3024 rc = -EOPNOTSUPP;
3025 break;
3026
3027 case SIOCSIWRETRY:
3028
3029 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
3030 break;
3031
3032 case SIOCGIWRETRY:
3033
3034 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
3035 break;
3036
3037
3038 case SIOCGIWRANGE:
3039
3040 {
3041 struct iw_range range;
3042
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)))
3045 rc = -EFAULT;
3046 }
3047
3048 break;
3049
3050 case SIOCGIWPOWER:
3051
3052 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
3053 break;
3054
3055 case SIOCSIWPOWER:
3056
3057 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
3058 break;
3059
3060 case SIOCGIWSENS:
3061
3062 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
3063 break;
3064
3065 case SIOCSIWSENS:
3066 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
3067 rc = -EOPNOTSUPP;
3068 break;
3069
3070 case SIOCGIWAPLIST: {
3071 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
3072
3073 if (wrq->u.data.pointer) {
3074 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
3075 if (rc == 0) {
3076 if (copy_to_user(wrq->u.data.pointer,
3077 buffer,
3078 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality)))
3079 ))
3080 rc = -EFAULT;
3081 }
3082 }
3083 }
3084 break;
3085
3086#ifdef WIRELESS_SPY
3087
3088 case SIOCSIWSPY:
3089
3090 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
3091 rc = -EOPNOTSUPP;
3092 break;
3093
3094
3095 case SIOCGIWSPY:
3096
3097 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWSPY \n");
3098 rc = -EOPNOTSUPP;
3099 break;
3100
3101#endif
3102
3103 case SIOCGIWPRIV:
3104 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
3105 rc = -EOPNOTSUPP;
3106
3107
3108
3109
3110
3111
3112
3113
3114
3115
3116 break;
3117
3118
3119#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3120 case SIOCSIWAUTH:
3121 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n");
3122 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
3123 break;
3124
3125 case SIOCGIWAUTH:
3126 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
3127 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
3128 break;
3129
3130 case SIOCSIWGENIE:
3131 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
3132 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3133 break;
3134
3135 case SIOCGIWGENIE:
3136 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
3137 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3138 break;
3139
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)) {
3146 rc = -E2BIG;
3147 break;
3148 }
3149 if (copy_from_user(extra, wrq->u.encoding.pointer, wrq->u.encoding.length)) {
3150 rc = -EFAULT;
3151 break;
3152 }
3153 } else if (wrq->u.encoding.length != 0) {
3154 rc = -EINVAL;
3155 break;
3156 }
3157 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
3158 }
3159 break;
3160
3161 case SIOCGIWENCODEEXT:
3162 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
3163 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
3164 break;
3165
3166 case SIOCSIWMLME:
3167 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
3168 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3169 break;
3170
3171#endif
3172
3173
3174 case IOCTL_CMD_TEST:
3175
3176 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
3177 rc = -EFAULT;
3178 break;
3179 } else {
3180 rc = 0;
3181 }
3182 pReq = (PSCmdRequest)rq;
3183 pReq->wResult = MAGIC_CODE;
3184 break;
3185
3186 case IOCTL_CMD_SET:
3187
3188#ifdef SndEvt_ToAPI
3189 if ((((PSCmdRequest)rq)->wCmdCode != WLAN_CMD_SET_EVT) &&
3190 !(pDevice->flags & DEVICE_FLAGS_OPENED))
3191#else
3192 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
3193 (((PSCmdRequest)rq)->wCmdCode != WLAN_CMD_SET_WPA))
3194#endif
3195 {
3196 rc = -EFAULT;
3197 break;
3198 } else {
3199 rc = 0;
3200 }
3201
3202 if (test_and_set_bit(0, (void *)&(pMgmt->uCmdBusy))) {
3203 return -EBUSY;
3204 }
3205 rc = private_ioctl(pDevice, rq);
3206 clear_bit(0, (void *)&(pMgmt->uCmdBusy));
3207 break;
3208
3209 case IOCTL_CMD_HOSTAPD:
3210
3211 rc = vt6655_hostap_ioctl(pDevice, &wrq->u.data);
3212 break;
3213
3214 case IOCTL_CMD_WPA:
3215
3216 rc = wpa_ioctl(pDevice, &wrq->u.data);
3217 break;
3218
3219 case SIOCETHTOOL:
3220 return ethtool_ioctl(dev, (void *)rq->ifr_data);
3221
3222
3223 default:
3224 rc = -EOPNOTSUPP;
3225 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
3226
3227 }
3228
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);
3235 } else {
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)
3245#endif
3246 bScheduleCommand((void *)pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID);
3247 bScheduleCommand((void *)pDevice, WLAN_CMD_SSID, NULL);
3248 spin_unlock_irq(&pDevice->lock);
3249 }
3250 pDevice->bCommit = false;
3251 }
3252
3253 return rc;
3254}
3255
3256static int ethtool_ioctl(struct net_device *dev, void *useraddr)
3257{
3258 u32 ethcmd;
3259
3260 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd)))
3261 return -EFAULT;
3262
3263 switch (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)))
3269 return -EFAULT;
3270 return 0;
3271 }
3272
3273 }
3274
3275 return -EOPNOTSUPP;
3276}
3277
3278
3279
3280MODULE_DEVICE_TABLE(pci, vt6655_pci_id_table);
3281
3282static struct pci_driver device_driver = {
3283 .name = DEVICE_NAME,
3284 .id_table = vt6655_pci_id_table,
3285 .probe = vt6655_probe,
3286 .remove = vt6655_remove,
3287#ifdef CONFIG_PM
3288 .suspend = viawget_suspend,
3289 .resume = viawget_resume,
3290#endif
3291};
3292
3293static int __init vt6655_init_module(void)
3294{
3295 int ret;
3296
3297
3298
3299 ret = pci_register_driver(&device_driver);
3300#ifdef CONFIG_PM
3301 if (ret >= 0)
3302 register_reboot_notifier(&device_notifier);
3303#endif
3304
3305 return ret;
3306}
3307
3308static void __exit vt6655_cleanup_module(void)
3309{
3310#ifdef CONFIG_PM
3311 unregister_reboot_notifier(&device_notifier);
3312#endif
3313 pci_unregister_driver(&device_driver);
3314}
3315
3316module_init(vt6655_init_module);
3317module_exit(vt6655_cleanup_module);
3318
3319#ifdef CONFIG_PM
3320static int
3321device_notify_reboot(struct notifier_block *nb, unsigned long event, void *p)
3322{
3323 struct pci_dev *pdev = NULL;
3324 switch (event) {
3325 case SYS_DOWN:
3326 case SYS_HALT:
3327 case SYS_POWER_OFF:
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);
3332 }
3333 }
3334 }
3335 return NOTIFY_DONE;
3336}
3337
3338static int
3339viawget_suspend(struct pci_dev *pcid, pm_message_t state)
3340{
3341 int power_status;
3342
3343 PSDevice pDevice = pci_get_drvdata(pcid);
3344 PSMgmtObject pMgmt = pDevice->pMgmt;
3345
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);
3363 return 0;
3364}
3365
3366static int
3367viawget_resume(struct pci_dev *pcid)
3368{
3369 PSDevice pDevice = pci_get_drvdata(pcid);
3370 PSMgmtObject pMgmt = pDevice->pMgmt;
3371 int power_status;
3372
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) {
3381 pMgmt->sNodeDBTable[0].bActive = false;
3382 pDevice->bLinkPass = false;
3383 if (pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
3384
3385 pMgmt->eCurrState = WMAC_STATE_STARTED;
3386 } else {
3387 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
3388 pMgmt->eCurrState = WMAC_STATE_IDLE;
3389 }
3390 }
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);
3398 }
3399 return 0;
3400}
3401
3402#endif
3403