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 "device.h"
64#include "card.h"
65#include "channel.h"
66#include "baseband.h"
67#include "mac.h"
68#include "tether.h"
69#include "wmgr.h"
70#include "wctl.h"
71#include "power.h"
72#include "wcmd.h"
73#include "iocmd.h"
74#include "tcrc.h"
75#include "rxtx.h"
76#include "wroute.h"
77#include "bssdb.h"
78#include "hostap.h"
79#include "wpactl.h"
80#include "ioctl.h"
81#include "iwctl.h"
82#include "dpc.h"
83#include "datarate.h"
84#include "rf.h"
85#include "iowpa.h"
86#include <linux/delay.h>
87#include <linux/kthread.h>
88#include <linux/slab.h>
89
90
91
92
93static int msglevel = MSG_LEVEL_INFO;
94
95
96
97
98
99MODULE_AUTHOR("VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>");
100MODULE_LICENSE("GPL");
101MODULE_DESCRIPTION("VIA Networking Solomon-A/B/G Wireless LAN Adapter Driver");
102
103
104 static int mlme_kill;
105
106
107
108#define DEVICE_PARAM(N,D)
109
110
111
112
113
114
115#define RX_DESC_MIN0 16
116#define RX_DESC_MAX0 128
117#define RX_DESC_DEF0 32
118DEVICE_PARAM(RxDescriptors0,"Number of receive descriptors0");
119
120#define RX_DESC_MIN1 16
121#define RX_DESC_MAX1 128
122#define RX_DESC_DEF1 32
123DEVICE_PARAM(RxDescriptors1,"Number of receive descriptors1");
124
125#define TX_DESC_MIN0 16
126#define TX_DESC_MAX0 128
127#define TX_DESC_DEF0 32
128DEVICE_PARAM(TxDescriptors0,"Number of transmit descriptors0");
129
130#define TX_DESC_MIN1 16
131#define TX_DESC_MAX1 128
132#define TX_DESC_DEF1 64
133DEVICE_PARAM(TxDescriptors1,"Number of transmit descriptors1");
134
135
136#define IP_ALIG_DEF 0
137
138
139
140
141
142
143DEVICE_PARAM(IP_byte_align,"Enable IP header dword aligned");
144
145
146#define INT_WORKS_DEF 20
147#define INT_WORKS_MIN 10
148#define INT_WORKS_MAX 64
149
150DEVICE_PARAM(int_works,"Number of packets per interrupt services");
151
152#define CHANNEL_MIN 1
153#define CHANNEL_MAX 14
154#define CHANNEL_DEF 6
155
156DEVICE_PARAM(Channel, "Channel number");
157
158
159
160
161
162
163
164#define PREAMBLE_TYPE_DEF 1
165
166DEVICE_PARAM(PreambleType, "Preamble Type");
167
168
169#define RTS_THRESH_MIN 512
170#define RTS_THRESH_MAX 2347
171#define RTS_THRESH_DEF 2347
172
173DEVICE_PARAM(RTSThreshold, "RTS threshold");
174
175
176#define FRAG_THRESH_MIN 256
177#define FRAG_THRESH_MAX 2346
178#define FRAG_THRESH_DEF 2346
179
180DEVICE_PARAM(FragThreshold, "Fragmentation threshold");
181
182
183#define DATA_RATE_MIN 0
184#define DATA_RATE_MAX 13
185#define DATA_RATE_DEF 13
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203DEVICE_PARAM(ConnectionRate, "Connection data rate");
204
205#define OP_MODE_DEF 0
206
207DEVICE_PARAM(OPMode, "Infrastruct, adhoc, AP mode ");
208
209
210
211
212
213
214
215
216
217
218
219
220
221#define PS_MODE_DEF 0
222
223DEVICE_PARAM(PSMode, "Power saving mode");
224
225
226#define SHORT_RETRY_MIN 0
227#define SHORT_RETRY_MAX 31
228#define SHORT_RETRY_DEF 8
229
230
231DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits");
232
233#define LONG_RETRY_MIN 0
234#define LONG_RETRY_MAX 15
235#define LONG_RETRY_DEF 4
236
237
238DEVICE_PARAM(LongRetryLimit, "long frame retry limits");
239
240
241
242
243
244
245
246#define BBP_TYPE_MIN 0
247#define BBP_TYPE_MAX 2
248#define BBP_TYPE_DEF 2
249
250DEVICE_PARAM(BasebandType, "baseband type");
251
252
253
254
255
256
257
258
259#define X80211h_MODE_DEF 0
260
261DEVICE_PARAM(b80211hEnable, "802.11h mode");
262
263
264
265
266
267
268#define DIVERSITY_ANT_DEF 0
269
270DEVICE_PARAM(bDiversityANTEnable, "ANT diversity mode");
271
272
273
274
275
276
277
278static int device_nics =0;
279static PSDevice pDevice_Infos =NULL;
280static struct net_device *root_device_dev = NULL;
281
282static CHIP_INFO chip_info_table[]= {
283 { VT3253, "VIA Networking Solomon-A/B/G Wireless LAN Adapter ",
284 256, 1, DEVICE_FLAGS_IP_ALIGN|DEVICE_FLAGS_TX_ALIGN },
285 {0,NULL}
286};
287
288DEFINE_PCI_DEVICE_TABLE(vt6655_pci_id_table) = {
289 { PCI_VDEVICE(VIA, 0x3253), (kernel_ulong_t)chip_info_table},
290 { 0, }
291};
292
293
294
295
296static int vt6655_probe(struct pci_dev *pcid, const struct pci_device_id *ent);
297static bool vt6655_init_info(struct pci_dev* pcid, PSDevice* ppDevice, PCHIP_INFO);
298static void device_free_info(PSDevice pDevice);
299static bool device_get_pci_info(PSDevice, struct pci_dev* pcid);
300static void device_print_info(PSDevice pDevice);
301static struct net_device_stats *device_get_stats(struct net_device *dev);
302static void device_init_diversity_timer(PSDevice pDevice);
303static int device_open(struct net_device *dev);
304static int device_xmit(struct sk_buff *skb, struct net_device *dev);
305static irqreturn_t device_intr(int irq, void*dev_instance);
306static void device_set_multi(struct net_device *dev);
307static int device_close(struct net_device *dev);
308static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
309
310#ifdef CONFIG_PM
311static int device_notify_reboot(struct notifier_block *, unsigned long event, void *ptr);
312static int viawget_suspend(struct pci_dev *pcid, pm_message_t state);
313static int viawget_resume(struct pci_dev *pcid);
314struct notifier_block device_notifier = {
315 .notifier_call = device_notify_reboot,
316 .next = NULL,
317 .priority = 0,
318};
319#endif
320
321
322static void device_init_rd0_ring(PSDevice pDevice);
323static void device_init_rd1_ring(PSDevice pDevice);
324static void device_init_defrag_cb(PSDevice pDevice);
325static void device_init_td0_ring(PSDevice pDevice);
326static void device_init_td1_ring(PSDevice pDevice);
327
328static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
329
330static bool device_release_WPADEV(PSDevice pDevice);
331
332static int ethtool_ioctl(struct net_device *dev, void *useraddr);
333static int device_rx_srv(PSDevice pDevice, unsigned int uIdx);
334static int device_tx_srv(PSDevice pDevice, unsigned int uIdx);
335static bool device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pDesc);
336static void device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType);
337static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc);
338static void device_free_td0_ring(PSDevice pDevice);
339static void device_free_td1_ring(PSDevice pDevice);
340static void device_free_rd0_ring(PSDevice pDevice);
341static void device_free_rd1_ring(PSDevice pDevice);
342static void device_free_rings(PSDevice pDevice);
343static void device_free_frag_buf(PSDevice pDevice);
344static int Config_FileGetParameter(unsigned char *string,
345 unsigned char *dest, unsigned char *source);
346
347
348
349
350
351
352
353
354static char* get_chip_name(int chip_id) {
355 int i;
356 for (i=0;chip_info_table[i].name!=NULL;i++)
357 if (chip_info_table[i].chip_id==chip_id)
358 break;
359 return chip_info_table[i].name;
360}
361
362static void __devexit vt6655_remove(struct pci_dev *pcid)
363{
364 PSDevice pDevice=pci_get_drvdata(pcid);
365
366 if (pDevice==NULL)
367 return;
368 device_free_info(pDevice);
369
370}
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404static void
405device_get_options(PSDevice pDevice, int index, char* devname) {
406
407 POPTIONS pOpts = &(pDevice->sOpts);
408 pOpts->nRxDescs0=RX_DESC_DEF0;
409 pOpts->nRxDescs1=RX_DESC_DEF1;
410 pOpts->nTxDescs[0]=TX_DESC_DEF0;
411 pOpts->nTxDescs[1]=TX_DESC_DEF1;
412pOpts->flags|=DEVICE_FLAGS_IP_ALIGN;
413 pOpts->int_works=INT_WORKS_DEF;
414 pOpts->rts_thresh=RTS_THRESH_DEF;
415 pOpts->frag_thresh=FRAG_THRESH_DEF;
416 pOpts->data_rate=DATA_RATE_DEF;
417 pOpts->channel_num=CHANNEL_DEF;
418
419pOpts->flags|=DEVICE_FLAGS_PREAMBLE_TYPE;
420pOpts->flags|=DEVICE_FLAGS_OP_MODE;
421
422 pOpts->short_retry=SHORT_RETRY_DEF;
423 pOpts->long_retry=LONG_RETRY_DEF;
424 pOpts->bbp_type=BBP_TYPE_DEF;
425pOpts->flags|=DEVICE_FLAGS_80211h_MODE;
426pOpts->flags|=DEVICE_FLAGS_DiversityANT;
427
428
429}
430
431static void
432device_set_options(PSDevice pDevice) {
433
434 unsigned char abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
435 unsigned char abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
436 unsigned char abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
437
438
439 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
440 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
441 memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, ETH_ALEN);
442
443 pDevice->uChannel = pDevice->sOpts.channel_num;
444 pDevice->wRTSThreshold = pDevice->sOpts.rts_thresh;
445 pDevice->wFragmentationThreshold = pDevice->sOpts.frag_thresh;
446 pDevice->byShortRetryLimit = pDevice->sOpts.short_retry;
447 pDevice->byLongRetryLimit = pDevice->sOpts.long_retry;
448 pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
449 pDevice->byShortPreamble = (pDevice->sOpts.flags & DEVICE_FLAGS_PREAMBLE_TYPE) ? 1 : 0;
450 pDevice->byOpMode = (pDevice->sOpts.flags & DEVICE_FLAGS_OP_MODE) ? 1 : 0;
451 pDevice->ePSMode = (pDevice->sOpts.flags & DEVICE_FLAGS_PS_MODE) ? 1 : 0;
452 pDevice->b11hEnable = (pDevice->sOpts.flags & DEVICE_FLAGS_80211h_MODE) ? 1 : 0;
453 pDevice->bDiversityRegCtlON = (pDevice->sOpts.flags & DEVICE_FLAGS_DiversityANT) ? 1 : 0;
454 pDevice->uConnectionRate = pDevice->sOpts.data_rate;
455 if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = true;
456 pDevice->byBBType = pDevice->sOpts.bbp_type;
457 pDevice->byPacketType = pDevice->byBBType;
458
459
460 pDevice->byAutoFBCtrl = AUTO_FB_0;
461
462
463pDevice->bUpdateBBVGA = true;
464 pDevice->byFOETuning = 0;
465 pDevice->wCTSDuration = 0;
466 pDevice->byPreambleType = 0;
467
468
469 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" uChannel= %d\n",(int)pDevice->uChannel);
470 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byOpMode= %d\n",(int)pDevice->byOpMode);
471 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" ePSMode= %d\n",(int)pDevice->ePSMode);
472 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" wRTSThreshold= %d\n",(int)pDevice->wRTSThreshold);
473 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byShortRetryLimit= %d\n",(int)pDevice->byShortRetryLimit);
474 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byLongRetryLimit= %d\n",(int)pDevice->byLongRetryLimit);
475 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byPreambleType= %d\n",(int)pDevice->byPreambleType);
476 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byShortPreamble= %d\n",(int)pDevice->byShortPreamble);
477 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" uConnectionRate= %d\n",(int)pDevice->uConnectionRate);
478 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" byBBType= %d\n",(int)pDevice->byBBType);
479 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" pDevice->b11hEnable= %d\n",(int)pDevice->b11hEnable);
480 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" pDevice->bDiversityRegCtlON= %d\n",(int)pDevice->bDiversityRegCtlON);
481}
482
483static void s_vCompleteCurrentMeasure (PSDevice pDevice, unsigned char byResult)
484{
485 unsigned int ii;
486 unsigned long dwDuration = 0;
487 unsigned char byRPI0 = 0;
488
489 for(ii=1;ii<8;ii++) {
490 pDevice->dwRPIs[ii] *= 255;
491 dwDuration |= *((unsigned short *) (pDevice->pCurrMeasureEID->sReq.abyDuration));
492 dwDuration <<= 10;
493 pDevice->dwRPIs[ii] /= dwDuration;
494 pDevice->abyRPIs[ii] = (unsigned char) pDevice->dwRPIs[ii];
495 byRPI0 += pDevice->abyRPIs[ii];
496 }
497 pDevice->abyRPIs[0] = (0xFF - byRPI0);
498
499 if (pDevice->uNumOfMeasureEIDs == 0) {
500 VNTWIFIbMeasureReport( pDevice->pMgmt,
501 true,
502 pDevice->pCurrMeasureEID,
503 byResult,
504 pDevice->byBasicMap,
505 pDevice->byCCAFraction,
506 pDevice->abyRPIs
507 );
508 } else {
509 VNTWIFIbMeasureReport( pDevice->pMgmt,
510 false,
511 pDevice->pCurrMeasureEID,
512 byResult,
513 pDevice->byBasicMap,
514 pDevice->byCCAFraction,
515 pDevice->abyRPIs
516 );
517 CARDbStartMeasure (pDevice, pDevice->pCurrMeasureEID++, pDevice->uNumOfMeasureEIDs);
518 }
519
520}
521
522
523
524
525
526
527
528static void device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType)
529{
530 unsigned int ii;
531 unsigned char byValue;
532 unsigned char byValue1;
533 unsigned char byCCKPwrdBm = 0;
534 unsigned char byOFDMPwrdBm = 0;
535 int zonetype=0;
536 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
537 MACbShutdown(pDevice->PortOffset);
538 BBvSoftwareReset(pDevice->PortOffset);
539
540 if ((InitType == DEVICE_INIT_COLD) ||
541 (InitType == DEVICE_INIT_DXPL)) {
542
543 MACbSoftwareReset(pDevice->PortOffset);
544
545 pDevice->bCCK = true;
546 pDevice->bAES = false;
547 pDevice->bProtectMode = false;
548 pDevice->bNonERPPresent = false;
549 pDevice->bBarkerPreambleMd = false;
550 pDevice->wCurrentRate = RATE_1M;
551 pDevice->byTopOFDMBasicRate = RATE_24M;
552 pDevice->byTopCCKBasicRate = RATE_1M;
553
554 pDevice->byRevId = 0;
555
556
557 MACvInitialize(pDevice->PortOffset);
558
559
560 VNSvInPortB(pDevice->PortOffset + MAC_REG_LOCALID, &(pDevice->byLocalID));
561
562 spin_lock_irq(&pDevice->lock);
563 SROMvReadAllContents(pDevice->PortOffset,pDevice->abyEEPROM);
564
565 spin_unlock_irq(&pDevice->lock);
566
567
568
569 pDevice->byMinChannel = 1;
570 pDevice->byMaxChannel = CB_MAX_CHANNEL;
571
572
573 byValue = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ANTENNA);
574 if (byValue & EEP_ANTINV)
575 pDevice->bTxRxAntInv = true;
576 else
577 pDevice->bTxRxAntInv = false;
578#ifdef PLICE_DEBUG
579
580#endif
581
582 byValue &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
583 if (byValue == 0)
584 byValue = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
585#ifdef PLICE_DEBUG
586
587#endif
588 pDevice->ulDiversityNValue = 100*260;
589 pDevice->ulDiversityMValue = 100*16;
590 pDevice->byTMax = 1;
591 pDevice->byTMax2 = 4;
592 pDevice->ulSQ3TH = 0;
593 pDevice->byTMax3 = 64;
594
595 if (byValue == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
596 pDevice->byAntennaCount = 2;
597 pDevice->byTxAntennaMode = ANT_B;
598 pDevice->dwTxAntennaSel = 1;
599 pDevice->dwRxAntennaSel = 1;
600 if (pDevice->bTxRxAntInv == true)
601 pDevice->byRxAntennaMode = ANT_A;
602 else
603 pDevice->byRxAntennaMode = ANT_B;
604
605byValue1 = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ANTENNA);
606
607 if((byValue1&0x08)==0)
608 pDevice->bDiversityEnable = false;
609 else
610 pDevice->bDiversityEnable = true;
611#ifdef PLICE_DEBUG
612
613#endif
614 } else {
615 pDevice->bDiversityEnable = false;
616 pDevice->byAntennaCount = 1;
617 pDevice->dwTxAntennaSel = 0;
618 pDevice->dwRxAntennaSel = 0;
619 if (byValue & EEP_ANTENNA_AUX) {
620 pDevice->byTxAntennaMode = ANT_A;
621 if (pDevice->bTxRxAntInv == true)
622 pDevice->byRxAntennaMode = ANT_B;
623 else
624 pDevice->byRxAntennaMode = ANT_A;
625 } else {
626 pDevice->byTxAntennaMode = ANT_B;
627 if (pDevice->bTxRxAntInv == true)
628 pDevice->byRxAntennaMode = ANT_A;
629 else
630 pDevice->byRxAntennaMode = ANT_B;
631 }
632 }
633#ifdef PLICE_DEBUG
634
635#endif
636 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "bDiversityEnable=[%d],NValue=[%d],MValue=[%d],TMax=[%d],TMax2=[%d]\n",
637 pDevice->bDiversityEnable,(int)pDevice->ulDiversityNValue,(int)pDevice->ulDiversityMValue,pDevice->byTMax,pDevice->byTMax2);
638
639
640
641
642 pDevice->byOriginalZonetype = pDevice->abyEEPROM[EEP_OFS_ZONETYPE];
643 zonetype = Config_FileOperation(pDevice,false,NULL);
644 if (zonetype >= 0) {
645 if ((zonetype == 0)&&
646 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] !=0x00)){
647 pDevice->abyEEPROM[EEP_OFS_ZONETYPE] = 0;
648 pDevice->abyEEPROM[EEP_OFS_MAXCHANNEL] = 0x0B;
649 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Init Zone Type :USA\n");
650 }
651 else if((zonetype == 1)&&
652 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE]!=0x01)){
653 pDevice->abyEEPROM[EEP_OFS_ZONETYPE] = 0x01;
654 pDevice->abyEEPROM[EEP_OFS_MAXCHANNEL] = 0x0D;
655 }
656 else if((zonetype == 2)&&
657 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE]!=0x02)){
658 pDevice->abyEEPROM[EEP_OFS_ZONETYPE] = 0x02;
659 pDevice->abyEEPROM[EEP_OFS_MAXCHANNEL] = 0x0D;
660 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Init Zone Type :Europe\n");
661 }
662
663else
664{
665 if(zonetype!=pDevice->abyEEPROM[EEP_OFS_ZONETYPE])
666 printk("zonetype in file[%02x] mismatch with in EEPROM[%02x]\n",zonetype,pDevice->abyEEPROM[EEP_OFS_ZONETYPE]);
667 else
668 printk("Read Zonetype file success,use default zonetype setting[%02x]\n",zonetype);
669 }
670 }
671 else
672 printk("Read Zonetype file fail,use default zonetype setting[%02x]\n",SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_ZONETYPE));
673
674
675 pDevice->byRFType = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RFTYPE);
676
677 if ((pDevice->byRFType & RF_EMU) != 0) {
678
679 pDevice->byRevId = 0x80;
680 }
681
682 pDevice->byRFType &= RF_MASK;
683 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRFType = %x\n", pDevice->byRFType);
684
685 if (pDevice->bZoneRegExist == false) {
686 pDevice->byZoneType = pDevice->abyEEPROM[EEP_OFS_ZONETYPE];
687 }
688 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byZoneType = %x\n", pDevice->byZoneType);
689
690
691 RFbInit(pDevice);
692
693
694 pDevice->byCurPwr = 0xFF;
695 pDevice->byCCKPwr = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_PWR_CCK);
696 pDevice->byOFDMPwrG = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_PWR_OFDMG);
697
698
699
700
701
702
703
704 for (ii=0;ii<CB_MAX_CHANNEL_24G;ii++) {
705 pDevice->abyCCKPwrTbl[ii+1] = SROMbyReadEmbedded(pDevice->PortOffset, (unsigned char)(ii + EEP_OFS_CCK_PWR_TBL));
706 if (pDevice->abyCCKPwrTbl[ii+1] == 0) {
707 pDevice->abyCCKPwrTbl[ii+1] = pDevice->byCCKPwr;
708 }
709 pDevice->abyOFDMPwrTbl[ii+1] = SROMbyReadEmbedded(pDevice->PortOffset, (unsigned char)(ii + EEP_OFS_OFDM_PWR_TBL));
710 if (pDevice->abyOFDMPwrTbl[ii+1] == 0) {
711 pDevice->abyOFDMPwrTbl[ii+1] = pDevice->byOFDMPwrG;
712 }
713 pDevice->abyCCKDefaultPwr[ii+1] = byCCKPwrdBm;
714 pDevice->abyOFDMDefaultPwr[ii+1] = byOFDMPwrdBm;
715 }
716
717
718 if(((pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Japan) ||
719 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Europe))&&
720 (pDevice->byOriginalZonetype == ZoneType_USA)) {
721 for(ii=11;ii<14;ii++) {
722 pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];
723 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];
724
725 }
726 }
727
728
729
730 for (ii=0;ii<CB_MAX_CHANNEL_5G;ii++) {
731 pDevice->abyOFDMPwrTbl[ii+CB_MAX_CHANNEL_24G+1] = SROMbyReadEmbedded(pDevice->PortOffset, (unsigned char)(ii + EEP_OFS_OFDMA_PWR_TBL));
732 pDevice->abyOFDMDefaultPwr[ii+CB_MAX_CHANNEL_24G+1] = SROMbyReadEmbedded(pDevice->PortOffset, (unsigned char)(ii + EEP_OFS_OFDMA_PWR_dBm));
733 }
734 init_channel_table((void *)pDevice);
735
736
737 if (pDevice->byLocalID > REV_ID_VT3253_B1) {
738 MACvSelectPage1(pDevice->PortOffset);
739 VNSvOutPortB(pDevice->PortOffset + MAC_REG_MSRCTL + 1, (MSRCTL1_TXPWR | MSRCTL1_CSAPAREN));
740 MACvSelectPage0(pDevice->PortOffset);
741 }
742
743
744
745 MACvWordRegBitsOn(pDevice->PortOffset, MAC_REG_CFG, (CFG_TKIPOPT | CFG_NOTXTIMEOUT));
746
747
748 MACvSetShortRetryLimit(pDevice->PortOffset, pDevice->byShortRetryLimit);
749 MACvSetLongRetryLimit(pDevice->PortOffset, pDevice->byLongRetryLimit);
750
751
752 VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
753
754 VNSvOutPortB(pDevice->PortOffset + MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
755
756
757 BBbVT3253Init(pDevice);
758
759 if (pDevice->bUpdateBBVGA) {
760 pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
761 pDevice->byBBVGANew = pDevice->byBBVGACurrent;
762 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
763 }
764#ifdef PLICE_DEBUG
765
766#endif
767 BBvSetRxAntennaMode(pDevice->PortOffset, pDevice->byRxAntennaMode);
768 BBvSetTxAntennaMode(pDevice->PortOffset, pDevice->byTxAntennaMode);
769
770 pDevice->byCurrentCh = 0;
771
772
773
774
775 if (pDevice->uConnectionRate == RATE_AUTO) {
776 pDevice->wCurrentRate = RATE_54M;
777 } else {
778 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
779 }
780
781
782 VNTWIFIbConfigPhyMode(pDevice->pMgmt, PHY_TYPE_11G);
783 VNTWIFIbConfigPhyMode(pDevice->pMgmt, PHY_TYPE_AUTO);
784
785 pDevice->bRadioOff = false;
786
787 pDevice->byRadioCtl = SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RADIOCTL);
788 pDevice->bHWRadioOff = false;
789
790 if (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) {
791
792 MACvGPIOIn(pDevice->PortOffset, &pDevice->byGPIO);
793
794 #ifdef FOR_LED_ON_NOTEBOOK
795if (pDevice->byGPIO & GPIO0_DATA){pDevice->bHWRadioOff = true;}
796if ( !(pDevice->byGPIO & GPIO0_DATA)){pDevice->bHWRadioOff = false;}
797
798 }
799 if ( (pDevice->bRadioControlOff == true)) {
800 CARDbRadioPowerOff(pDevice);
801 }
802else CARDbRadioPowerOn(pDevice);
803#else
804 if (((pDevice->byGPIO & GPIO0_DATA) && !(pDevice->byRadioCtl & EEP_RADIOCTL_INV)) ||
805 ( !(pDevice->byGPIO & GPIO0_DATA) && (pDevice->byRadioCtl & EEP_RADIOCTL_INV))) {
806 pDevice->bHWRadioOff = true;
807 }
808 }
809 if ((pDevice->bHWRadioOff == true) || (pDevice->bRadioControlOff == true)) {
810 CARDbRadioPowerOff(pDevice);
811 }
812
813#endif
814 }
815 pMgmt->eScanType = WMAC_SCAN_PASSIVE;
816
817 SROMvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr);
818 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %pM\n",
819 pDevice->abyCurrentNetAddr);
820
821
822 CARDvSafeResetRx(pDevice);
823
824 CARDvSafeResetTx(pDevice);
825
826 if (pDevice->byLocalID <= REV_ID_VT3253_A1) {
827 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_RCR, RCR_WPAERR);
828 }
829
830 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
831
832
833 MACvReceive0(pDevice->PortOffset);
834 MACvReceive1(pDevice->PortOffset);
835
836
837 MACvStart(pDevice->PortOffset);
838
839 netif_stop_queue(pDevice->dev);
840
841
842}
843
844
845
846static void device_init_diversity_timer(PSDevice pDevice) {
847
848 init_timer(&pDevice->TimerSQ3Tmax1);
849 pDevice->TimerSQ3Tmax1.data = (unsigned long) pDevice;
850 pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
851 pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
852
853 init_timer(&pDevice->TimerSQ3Tmax2);
854 pDevice->TimerSQ3Tmax2.data = (unsigned long) pDevice;
855 pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
856 pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
857
858 init_timer(&pDevice->TimerSQ3Tmax3);
859 pDevice->TimerSQ3Tmax3.data = (unsigned long) pDevice;
860 pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerState1CallBack;
861 pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
862
863 return;
864}
865
866
867static bool device_release_WPADEV(PSDevice pDevice)
868{
869 viawget_wpa_header *wpahdr;
870 int ii=0;
871
872
873 if (pDevice->bWPADEVUp==true) {
874 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
875 wpahdr->type = VIAWGET_DEVICECLOSE_MSG;
876 wpahdr->resp_ie_len = 0;
877 wpahdr->req_ie_len = 0;
878 skb_put(pDevice->skb, sizeof(viawget_wpa_header));
879 pDevice->skb->dev = pDevice->wpadev;
880 skb_reset_mac_header(pDevice->skb);
881 pDevice->skb->pkt_type = PACKET_HOST;
882 pDevice->skb->protocol = htons(ETH_P_802_2);
883 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
884 netif_rx(pDevice->skb);
885 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
886
887
888
889
890 while((pDevice->bWPADEVUp==true)) {
891 set_current_state(TASK_UNINTERRUPTIBLE);
892 schedule_timeout (HZ/20);
893 ii++;
894 if(ii>20)
895 break;
896 }
897 }
898 return true;
899}
900
901
902static const struct net_device_ops device_netdev_ops = {
903 .ndo_open = device_open,
904 .ndo_stop = device_close,
905 .ndo_do_ioctl = device_ioctl,
906 .ndo_get_stats = device_get_stats,
907 .ndo_start_xmit = device_xmit,
908 .ndo_set_rx_mode = device_set_multi,
909};
910
911
912
913static int __devinit
914vt6655_probe(struct pci_dev *pcid, const struct pci_device_id *ent)
915{
916 static bool bFirst = true;
917 struct net_device* dev = NULL;
918 PCHIP_INFO pChip_info = (PCHIP_INFO)ent->driver_data;
919 PSDevice pDevice;
920 int rc;
921 if (device_nics ++>= MAX_UINTS) {
922 printk(KERN_NOTICE DEVICE_NAME ": already found %d NICs\n", device_nics);
923 return -ENODEV;
924 }
925
926
927 dev = alloc_etherdev(sizeof(DEVICE_INFO));
928
929 pDevice = (PSDevice) netdev_priv(dev);
930
931 if (dev == NULL) {
932 printk(KERN_ERR DEVICE_NAME ": allocate net device failed \n");
933 return -ENODEV;
934 }
935
936
937
938 SET_NETDEV_DEV(dev, &pcid->dev);
939
940 if (bFirst) {
941 printk(KERN_NOTICE "%s Ver. %s\n",DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
942 printk(KERN_NOTICE "Copyright (c) 2003 VIA Networking Technologies, Inc.\n");
943 bFirst=false;
944 }
945
946 if (!vt6655_init_info(pcid, &pDevice, pChip_info)) {
947 return -ENOMEM;
948 }
949 pDevice->dev = dev;
950 pDevice->next_module = root_device_dev;
951 root_device_dev = dev;
952
953 if (pci_enable_device(pcid)) {
954 device_free_info(pDevice);
955 return -ENODEV;
956 }
957 dev->irq = pcid->irq;
958
959#ifdef DEBUG
960 printk("Before get pci_info memaddr is %x\n",pDevice->memaddr);
961#endif
962 if (device_get_pci_info(pDevice,pcid) == false) {
963 printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device.\n");
964 device_free_info(pDevice);
965 return -ENODEV;
966 }
967
968#if 1
969
970#ifdef DEBUG
971
972
973 printk("after get pci_info memaddr is %x, io addr is %x,io_size is %d\n",pDevice->memaddr,pDevice->ioaddr,pDevice->io_size);
974 {
975 int i;
976 u32 bar,len;
977 u32 address[] = {
978 PCI_BASE_ADDRESS_0,
979 PCI_BASE_ADDRESS_1,
980 PCI_BASE_ADDRESS_2,
981 PCI_BASE_ADDRESS_3,
982 PCI_BASE_ADDRESS_4,
983 PCI_BASE_ADDRESS_5,
984 0};
985 for (i=0;address[i];i++)
986 {
987
988 pci_read_config_dword(pcid, address[i], &bar);
989 printk("bar %d is %x\n",i,bar);
990 if (!bar)
991 {
992 printk("bar %d not implemented\n",i);
993 continue;
994 }
995 if (bar & PCI_BASE_ADDRESS_SPACE_IO) {
996
997
998 len = bar & (PCI_BASE_ADDRESS_IO_MASK & 0xFFFF);
999 len = len & ~(len - 1);
1000
1001 printk("IO space: len in IO %x, BAR %d\n", len, i);
1002 }
1003 else
1004 {
1005 len = bar & 0xFFFFFFF0;
1006 len = ~len + 1;
1007
1008 printk("len in MEM %x, BAR %d\n", len, i);
1009 }
1010 }
1011 }
1012#endif
1013
1014
1015#endif
1016
1017#ifdef DEBUG
1018
1019#endif
1020 pDevice->PortOffset = (unsigned long)ioremap(pDevice->memaddr & PCI_BASE_ADDRESS_MEM_MASK, pDevice->io_size);
1021
1022
1023 if(pDevice->PortOffset == 0) {
1024 printk(KERN_ERR DEVICE_NAME ": Failed to IO remapping ..\n");
1025 device_free_info(pDevice);
1026 return -ENODEV;
1027 }
1028
1029
1030
1031
1032 rc = pci_request_regions(pcid, DEVICE_NAME);
1033 if (rc) {
1034 printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device\n");
1035 device_free_info(pDevice);
1036 return -ENODEV;
1037 }
1038
1039 dev->base_addr = pDevice->ioaddr;
1040#ifdef PLICE_DEBUG
1041 unsigned char value;
1042
1043 VNSvInPortB(pDevice->PortOffset+0x4F, &value);
1044 printk("Before write: value is %x\n",value);
1045
1046 VNSvOutPortB(pDevice->PortOffset,value);
1047 VNSvInPortB(pDevice->PortOffset+0x4F, &value);
1048 printk("After write: value is %x\n",value);
1049#endif
1050
1051
1052
1053#ifdef IO_MAP
1054 pDevice->PortOffset = pDevice->ioaddr;
1055#endif
1056
1057 if (!MACbSoftwareReset(pDevice->PortOffset)) {
1058 printk(KERN_ERR DEVICE_NAME ": Failed to access MAC hardware..\n");
1059 device_free_info(pDevice);
1060 return -ENODEV;
1061 }
1062
1063 MACvInitialize(pDevice->PortOffset);
1064 MACvReadEtherAddress(pDevice->PortOffset, dev->dev_addr);
1065
1066 device_get_options(pDevice, device_nics-1, dev->name);
1067 device_set_options(pDevice);
1068
1069 pDevice->sOpts.flags &= pChip_info->flags;
1070
1071
1072 pDevice->flags = pDevice->sOpts.flags | (pChip_info->flags & 0xFF000000UL);
1073 pDevice->tx_80211 = device_dma0_tx_80211;
1074 pDevice->sMgmtObj.pAdapter = (void *)pDevice;
1075 pDevice->pMgmt = &(pDevice->sMgmtObj);
1076
1077 dev->irq = pcid->irq;
1078 dev->netdev_ops = &device_netdev_ops;
1079
1080 dev->wireless_handlers = (struct iw_handler_def *)&iwctl_handler_def;
1081
1082 rc = register_netdev(dev);
1083 if (rc)
1084 {
1085 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
1086 device_free_info(pDevice);
1087 return -ENODEV;
1088 }
1089
1090
1091#if 0
1092 if(wpa_set_wpadev(pDevice, 1)!=0) {
1093 printk("Fail to Register WPADEV?\n");
1094 unregister_netdev(pDevice->dev);
1095 free_netdev(dev);
1096 }
1097#endif
1098 device_print_info(pDevice);
1099 pci_set_drvdata(pcid, pDevice);
1100 return 0;
1101
1102}
1103
1104static void device_print_info(PSDevice pDevice)
1105{
1106 struct net_device* dev=pDevice->dev;
1107
1108 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: %s\n",dev->name, get_chip_name(pDevice->chip_id));
1109 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO "%s: MAC=%pM", dev->name, dev->dev_addr);
1110#ifdef IO_MAP
1111 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IO=0x%lx ",(unsigned long) pDevice->ioaddr);
1112 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IRQ=%d \n", pDevice->dev->irq);
1113#else
1114 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IO=0x%lx Mem=0x%lx ",
1115 (unsigned long) pDevice->ioaddr,(unsigned long) pDevice->PortOffset);
1116 DBG_PRT(MSG_LEVEL_INFO, KERN_INFO" IRQ=%d \n", pDevice->dev->irq);
1117#endif
1118
1119}
1120
1121static bool __devinit vt6655_init_info(struct pci_dev* pcid, PSDevice* ppDevice,
1122 PCHIP_INFO pChip_info) {
1123
1124 PSDevice p;
1125
1126 memset(*ppDevice,0,sizeof(DEVICE_INFO));
1127
1128 if (pDevice_Infos == NULL) {
1129 pDevice_Infos =*ppDevice;
1130 }
1131 else {
1132 for (p=pDevice_Infos;p->next!=NULL;p=p->next)
1133 do {} while (0);
1134 p->next = *ppDevice;
1135 (*ppDevice)->prev = p;
1136 }
1137
1138 (*ppDevice)->pcid = pcid;
1139 (*ppDevice)->chip_id = pChip_info->chip_id;
1140 (*ppDevice)->io_size = pChip_info->io_size;
1141 (*ppDevice)->nTxQueues = pChip_info->nTxQueue;
1142 (*ppDevice)->multicast_limit =32;
1143
1144 spin_lock_init(&((*ppDevice)->lock));
1145
1146 return true;
1147}
1148
1149static bool device_get_pci_info(PSDevice pDevice, struct pci_dev* pcid) {
1150
1151 u16 pci_cmd;
1152 u8 b;
1153 unsigned int cis_addr;
1154#ifdef PLICE_DEBUG
1155 unsigned char pci_config[256];
1156 unsigned char value =0x00;
1157 int ii,j;
1158 u16 max_lat=0x0000;
1159 memset(pci_config,0x00,256);
1160#endif
1161
1162 pci_read_config_byte(pcid, PCI_REVISION_ID, &pDevice->byRevId);
1163 pci_read_config_word(pcid, PCI_SUBSYSTEM_ID,&pDevice->SubSystemID);
1164 pci_read_config_word(pcid, PCI_SUBSYSTEM_VENDOR_ID, &pDevice->SubVendorID);
1165 pci_read_config_word(pcid, PCI_COMMAND, (u16 *) & (pci_cmd));
1166
1167 pci_set_master(pcid);
1168
1169 pDevice->memaddr = pci_resource_start(pcid,0);
1170 pDevice->ioaddr = pci_resource_start(pcid,1);
1171
1172#ifdef DEBUG
1173
1174
1175#endif
1176
1177 cis_addr = pci_resource_start(pcid,2);
1178
1179 pDevice->pcid = pcid;
1180
1181 pci_read_config_byte(pcid, PCI_COMMAND, &b);
1182 pci_write_config_byte(pcid, PCI_COMMAND, (b|PCI_COMMAND_MASTER));
1183
1184#ifdef PLICE_DEBUG
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194 for (ii=0;ii<0xFF;ii++)
1195 {
1196 pci_read_config_byte(pcid,ii,&value);
1197 pci_config[ii] = value;
1198 }
1199 for (ii=0,j=1;ii<0x100;ii++,j++)
1200 {
1201 if (j %16 == 0)
1202 {
1203 printk("%x:",pci_config[ii]);
1204 printk("\n");
1205 }
1206 else
1207 {
1208 printk("%x:",pci_config[ii]);
1209 }
1210 }
1211#endif
1212 return true;
1213}
1214
1215static void device_free_info(PSDevice pDevice) {
1216 PSDevice ptr;
1217 struct net_device* dev=pDevice->dev;
1218
1219 ASSERT(pDevice);
1220
1221device_release_WPADEV(pDevice);
1222
1223
1224
1225 if(wpa_set_wpadev(pDevice, 0)!=0)
1226 printk("unregister wpadev fail?\n");
1227
1228 if (pDevice_Infos==NULL)
1229 return;
1230
1231 for (ptr=pDevice_Infos;ptr && (ptr!=pDevice);ptr=ptr->next)
1232 do {} while (0);
1233
1234 if (ptr==pDevice) {
1235 if (ptr==pDevice_Infos)
1236 pDevice_Infos=ptr->next;
1237 else
1238 ptr->prev->next=ptr->next;
1239 }
1240 else {
1241 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR "info struct not found\n");
1242 return;
1243 }
1244#ifdef HOSTAP
1245 if (dev)
1246 vt6655_hostap_set_hostapd(pDevice, 0, 0);
1247#endif
1248 if (dev)
1249 unregister_netdev(dev);
1250
1251 if (pDevice->PortOffset)
1252 iounmap((void *)pDevice->PortOffset);
1253
1254 if (pDevice->pcid)
1255 pci_release_regions(pDevice->pcid);
1256 if (dev)
1257 free_netdev(dev);
1258
1259 if (pDevice->pcid) {
1260 pci_set_drvdata(pDevice->pcid,NULL);
1261 }
1262}
1263
1264static bool device_init_rings(PSDevice pDevice) {
1265 void* vir_pool;
1266
1267
1268
1269 vir_pool = pci_alloc_consistent(pDevice->pcid,
1270 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1271 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1272 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1273 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc),
1274 &pDevice->pool_dma);
1275
1276 if (vir_pool == NULL) {
1277 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate desc dma memory failed\n", pDevice->dev->name);
1278 return false;
1279 }
1280
1281 memset(vir_pool, 0,
1282 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1283 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1284 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1285 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc)
1286 );
1287
1288 pDevice->aRD0Ring = vir_pool;
1289 pDevice->aRD1Ring = vir_pool +
1290 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1291
1292
1293 pDevice->rd0_pool_dma = pDevice->pool_dma;
1294 pDevice->rd1_pool_dma = pDevice->rd0_pool_dma +
1295 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1296
1297 pDevice->tx0_bufs = pci_alloc_consistent(pDevice->pcid,
1298 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1299 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1300 CB_BEACON_BUF_SIZE +
1301 CB_MAX_BUF_SIZE,
1302 &pDevice->tx_bufs_dma0);
1303
1304 if (pDevice->tx0_bufs == NULL) {
1305 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: allocate buf dma memory failed\n", pDevice->dev->name);
1306 pci_free_consistent(pDevice->pcid,
1307 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1308 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1309 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1310 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc),
1311 vir_pool, pDevice->pool_dma
1312 );
1313 return false;
1314 }
1315
1316 memset(pDevice->tx0_bufs, 0,
1317 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1318 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1319 CB_BEACON_BUF_SIZE +
1320 CB_MAX_BUF_SIZE
1321 );
1322
1323 pDevice->td0_pool_dma = pDevice->rd1_pool_dma +
1324 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1325
1326 pDevice->td1_pool_dma = pDevice->td0_pool_dma +
1327 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1328
1329
1330
1331 pDevice->apTD0Rings = vir_pool
1332 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1333 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1334
1335 pDevice->apTD1Rings = vir_pool
1336 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1337 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc)
1338 + pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1339
1340
1341 pDevice->tx1_bufs = pDevice->tx0_bufs +
1342 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1343
1344
1345 pDevice->tx_beacon_bufs = pDevice->tx1_bufs +
1346 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1347
1348 pDevice->pbyTmpBuff = pDevice->tx_beacon_bufs +
1349 CB_BEACON_BUF_SIZE;
1350
1351 pDevice->tx_bufs_dma1 = pDevice->tx_bufs_dma0 +
1352 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1353
1354
1355 pDevice->tx_beacon_dma = pDevice->tx_bufs_dma1 +
1356 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1357
1358
1359 return true;
1360}
1361
1362static void device_free_rings(PSDevice pDevice) {
1363
1364 pci_free_consistent(pDevice->pcid,
1365 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1366 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1367 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1368 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc)
1369 ,
1370 pDevice->aRD0Ring, pDevice->pool_dma
1371 );
1372
1373 if (pDevice->tx0_bufs)
1374 pci_free_consistent(pDevice->pcid,
1375 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1376 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1377 CB_BEACON_BUF_SIZE +
1378 CB_MAX_BUF_SIZE,
1379 pDevice->tx0_bufs, pDevice->tx_bufs_dma0
1380 );
1381}
1382
1383static void device_init_rd0_ring(PSDevice pDevice) {
1384 int i;
1385 dma_addr_t curr = pDevice->rd0_pool_dma;
1386 PSRxDesc pDesc;
1387
1388
1389 for (i = 0; i < pDevice->sOpts.nRxDescs0; i ++, curr += sizeof(SRxDesc)) {
1390 pDesc = &(pDevice->aRD0Ring[i]);
1391 pDesc->pRDInfo = alloc_rd_info();
1392 ASSERT(pDesc->pRDInfo);
1393 if (!device_alloc_rx_buf(pDevice, pDesc)) {
1394 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc rx bufs\n",
1395 pDevice->dev->name);
1396 }
1397 pDesc->next = &(pDevice->aRD0Ring[(i+1) % pDevice->sOpts.nRxDescs0]);
1398 pDesc->pRDInfo->curr_desc = cpu_to_le32(curr);
1399 pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc));
1400 }
1401
1402 if (i > 0)
1403 pDevice->aRD0Ring[i-1].next_desc = cpu_to_le32(pDevice->rd0_pool_dma);
1404 pDevice->pCurrRD[0] = &(pDevice->aRD0Ring[0]);
1405}
1406
1407
1408static void device_init_rd1_ring(PSDevice pDevice) {
1409 int i;
1410 dma_addr_t curr = pDevice->rd1_pool_dma;
1411 PSRxDesc pDesc;
1412
1413
1414 for (i = 0; i < pDevice->sOpts.nRxDescs1; i ++, curr += sizeof(SRxDesc)) {
1415 pDesc = &(pDevice->aRD1Ring[i]);
1416 pDesc->pRDInfo = alloc_rd_info();
1417 ASSERT(pDesc->pRDInfo);
1418 if (!device_alloc_rx_buf(pDevice, pDesc)) {
1419 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc rx bufs\n",
1420 pDevice->dev->name);
1421 }
1422 pDesc->next = &(pDevice->aRD1Ring[(i+1) % pDevice->sOpts.nRxDescs1]);
1423 pDesc->pRDInfo->curr_desc = cpu_to_le32(curr);
1424 pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc));
1425 }
1426
1427 if (i > 0)
1428 pDevice->aRD1Ring[i-1].next_desc = cpu_to_le32(pDevice->rd1_pool_dma);
1429 pDevice->pCurrRD[1] = &(pDevice->aRD1Ring[0]);
1430}
1431
1432
1433static void device_init_defrag_cb(PSDevice pDevice) {
1434 int i;
1435 PSDeFragControlBlock pDeF;
1436
1437
1438 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1439 pDeF = &(pDevice->sRxDFCB[i]);
1440 if (!device_alloc_frag_buf(pDevice, pDeF)) {
1441 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
1442 pDevice->dev->name);
1443 }
1444 }
1445 pDevice->cbDFCB = CB_MAX_RX_FRAG;
1446 pDevice->cbFreeDFCB = pDevice->cbDFCB;
1447}
1448
1449
1450
1451
1452static void device_free_rd0_ring(PSDevice pDevice) {
1453 int i;
1454
1455 for (i = 0; i < pDevice->sOpts.nRxDescs0; i++) {
1456 PSRxDesc pDesc =&(pDevice->aRD0Ring[i]);
1457 PDEVICE_RD_INFO pRDInfo =pDesc->pRDInfo;
1458
1459 pci_unmap_single(pDevice->pcid,pRDInfo->skb_dma,
1460 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1461
1462 dev_kfree_skb(pRDInfo->skb);
1463
1464 kfree((void *)pDesc->pRDInfo);
1465 }
1466
1467}
1468
1469static void device_free_rd1_ring(PSDevice pDevice) {
1470 int i;
1471
1472
1473 for (i = 0; i < pDevice->sOpts.nRxDescs1; i++) {
1474 PSRxDesc pDesc=&(pDevice->aRD1Ring[i]);
1475 PDEVICE_RD_INFO pRDInfo=pDesc->pRDInfo;
1476
1477 pci_unmap_single(pDevice->pcid,pRDInfo->skb_dma,
1478 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1479
1480 dev_kfree_skb(pRDInfo->skb);
1481
1482 kfree((void *)pDesc->pRDInfo);
1483 }
1484
1485}
1486
1487static void device_free_frag_buf(PSDevice pDevice) {
1488 PSDeFragControlBlock pDeF;
1489 int i;
1490
1491 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1492
1493 pDeF = &(pDevice->sRxDFCB[i]);
1494
1495 if (pDeF->skb)
1496 dev_kfree_skb(pDeF->skb);
1497
1498 }
1499
1500}
1501
1502static void device_init_td0_ring(PSDevice pDevice) {
1503 int i;
1504 dma_addr_t curr;
1505 PSTxDesc pDesc;
1506
1507 curr = pDevice->td0_pool_dma;
1508 for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++, curr += sizeof(STxDesc)) {
1509 pDesc = &(pDevice->apTD0Rings[i]);
1510 pDesc->pTDInfo = alloc_td_info();
1511 ASSERT(pDesc->pTDInfo);
1512 if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) {
1513 pDesc->pTDInfo->buf = pDevice->tx0_bufs + (i)*PKT_BUF_SZ;
1514 pDesc->pTDInfo->buf_dma = pDevice->tx_bufs_dma0 + (i)*PKT_BUF_SZ;
1515 }
1516 pDesc->next =&(pDevice->apTD0Rings[(i+1) % pDevice->sOpts.nTxDescs[0]]);
1517 pDesc->pTDInfo->curr_desc = cpu_to_le32(curr);
1518 pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc));
1519 }
1520
1521 if (i > 0)
1522 pDevice->apTD0Rings[i-1].next_desc = cpu_to_le32(pDevice->td0_pool_dma);
1523 pDevice->apTailTD[0] = pDevice->apCurrTD[0] =&(pDevice->apTD0Rings[0]);
1524
1525}
1526
1527static void device_init_td1_ring(PSDevice pDevice) {
1528 int i;
1529 dma_addr_t curr;
1530 PSTxDesc pDesc;
1531
1532
1533 curr=pDevice->td1_pool_dma;
1534 for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++, curr+=sizeof(STxDesc)) {
1535 pDesc=&(pDevice->apTD1Rings[i]);
1536 pDesc->pTDInfo = alloc_td_info();
1537 ASSERT(pDesc->pTDInfo);
1538 if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) {
1539 pDesc->pTDInfo->buf=pDevice->tx1_bufs+(i)*PKT_BUF_SZ;
1540 pDesc->pTDInfo->buf_dma=pDevice->tx_bufs_dma1+(i)*PKT_BUF_SZ;
1541 }
1542 pDesc->next=&(pDevice->apTD1Rings[(i+1) % pDevice->sOpts.nTxDescs[1]]);
1543 pDesc->pTDInfo->curr_desc = cpu_to_le32(curr);
1544 pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc));
1545 }
1546
1547 if (i > 0)
1548 pDevice->apTD1Rings[i-1].next_desc = cpu_to_le32(pDevice->td1_pool_dma);
1549 pDevice->apTailTD[1] = pDevice->apCurrTD[1] = &(pDevice->apTD1Rings[0]);
1550}
1551
1552
1553
1554static void device_free_td0_ring(PSDevice pDevice) {
1555 int i;
1556 for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++) {
1557 PSTxDesc pDesc=&(pDevice->apTD0Rings[i]);
1558 PDEVICE_TD_INFO pTDInfo=pDesc->pTDInfo;
1559
1560 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma))
1561 pci_unmap_single(pDevice->pcid,pTDInfo->skb_dma,
1562 pTDInfo->skb->len, PCI_DMA_TODEVICE);
1563
1564 if (pTDInfo->skb)
1565 dev_kfree_skb(pTDInfo->skb);
1566
1567 kfree((void *)pDesc->pTDInfo);
1568 }
1569}
1570
1571static void device_free_td1_ring(PSDevice pDevice) {
1572 int i;
1573
1574 for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++) {
1575 PSTxDesc pDesc=&(pDevice->apTD1Rings[i]);
1576 PDEVICE_TD_INFO pTDInfo=pDesc->pTDInfo;
1577
1578 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma))
1579 pci_unmap_single(pDevice->pcid, pTDInfo->skb_dma,
1580 pTDInfo->skb->len, PCI_DMA_TODEVICE);
1581
1582 if (pTDInfo->skb)
1583 dev_kfree_skb(pTDInfo->skb);
1584
1585 kfree((void *)pDesc->pTDInfo);
1586 }
1587
1588}
1589
1590
1591
1592
1593
1594static int device_rx_srv(PSDevice pDevice, unsigned int uIdx) {
1595 PSRxDesc pRD;
1596 int works = 0;
1597
1598
1599 for (pRD = pDevice->pCurrRD[uIdx];
1600 pRD->m_rd0RD0.f1Owner == OWNED_BY_HOST;
1601 pRD = pRD->next) {
1602
1603 if (works++>15)
1604 break;
1605 if (device_receive_frame(pDevice, pRD)) {
1606 if (!device_alloc_rx_buf(pDevice,pRD)) {
1607 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR
1608 "%s: can not allocate rx buf\n", pDevice->dev->name);
1609 break;
1610 }
1611 }
1612 pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1613 pDevice->dev->last_rx = jiffies;
1614 }
1615
1616 pDevice->pCurrRD[uIdx]=pRD;
1617
1618 return works;
1619}
1620
1621
1622static bool device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pRD) {
1623
1624 PDEVICE_RD_INFO pRDInfo=pRD->pRDInfo;
1625
1626
1627 pRDInfo->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1628#ifdef PLICE_DEBUG
1629
1630#endif
1631 if (pRDInfo->skb==NULL)
1632 return false;
1633 ASSERT(pRDInfo->skb);
1634 pRDInfo->skb->dev = pDevice->dev;
1635 pRDInfo->skb_dma = pci_map_single(pDevice->pcid, skb_tail_pointer(pRDInfo->skb),
1636 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1637 *((unsigned int *) &(pRD->m_rd0RD0)) = 0;
1638
1639 pRD->m_rd0RD0.wResCount = cpu_to_le16(pDevice->rx_buf_sz);
1640 pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1641 pRD->m_rd1RD1.wReqCount = cpu_to_le16(pDevice->rx_buf_sz);
1642 pRD->buff_addr = cpu_to_le32(pRDInfo->skb_dma);
1643
1644 return true;
1645}
1646
1647
1648
1649bool device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1650
1651 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1652 if (pDeF->skb == NULL)
1653 return false;
1654 ASSERT(pDeF->skb);
1655 pDeF->skb->dev = pDevice->dev;
1656
1657 return true;
1658}
1659
1660
1661
1662static int device_tx_srv(PSDevice pDevice, unsigned int uIdx) {
1663 PSTxDesc pTD;
1664 bool bFull=false;
1665 int works = 0;
1666 unsigned char byTsr0;
1667 unsigned char byTsr1;
1668 unsigned int uFrameSize, uFIFOHeaderSize;
1669 PSTxBufHead pTxBufHead;
1670 struct net_device_stats* pStats = &pDevice->stats;
1671 struct sk_buff* skb;
1672 unsigned int uNodeIndex;
1673 PSMgmtObject pMgmt = pDevice->pMgmt;
1674
1675
1676 for (pTD = pDevice->apTailTD[uIdx]; pDevice->iTDUsed[uIdx] >0; pTD = pTD->next) {
1677
1678 if (pTD->m_td0TD0.f1Owner == OWNED_BY_NIC)
1679 break;
1680 if (works++>15)
1681 break;
1682
1683 byTsr0 = pTD->m_td0TD0.byTSR0;
1684 byTsr1 = pTD->m_td0TD0.byTSR1;
1685
1686
1687 if (pTD->m_td1TD1.byTCR & TCR_STP) {
1688
1689 if ((pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0) {
1690 uFIFOHeaderSize = pTD->pTDInfo->dwHeaderLength;
1691 uFrameSize = pTD->pTDInfo->dwReqCount - uFIFOHeaderSize;
1692 pTxBufHead = (PSTxBufHead) (pTD->pTDInfo->buf);
1693
1694
1695
1696 STAvUpdateTDStatCounter(&pDevice->scStatistic,
1697 byTsr0, byTsr1,
1698 (unsigned char *)(pTD->pTDInfo->buf + uFIFOHeaderSize),
1699 uFrameSize, uIdx);
1700
1701
1702 BSSvUpdateNodeTxCounter(pDevice,
1703 byTsr0, byTsr1,
1704 (unsigned char *)(pTD->pTDInfo->buf),
1705 uFIFOHeaderSize
1706 );
1707
1708 if ( !(byTsr1 & TSR1_TERR)) {
1709 if (byTsr0 != 0) {
1710 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] OK but has error. tsr1[%02X] tsr0[%02X].\n",
1711 (int)uIdx, byTsr1, byTsr0);
1712 }
1713 if ((pTxBufHead->wFragCtl & FRAGCTL_ENDFRAG) != FRAGCTL_NONFRAG) {
1714 pDevice->s802_11Counter.TransmittedFragmentCount ++;
1715 }
1716 pStats->tx_packets++;
1717 pStats->tx_bytes += pTD->pTDInfo->skb->len;
1718 }
1719 else {
1720 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] dropped & tsr1[%02X] tsr0[%02X].\n",
1721 (int)uIdx, byTsr1, byTsr0);
1722 pStats->tx_errors++;
1723 pStats->tx_dropped++;
1724 }
1725 }
1726
1727 if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
1728 if (pDevice->bEnableHostapd) {
1729 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx call back netif.. \n");
1730 skb = pTD->pTDInfo->skb;
1731 skb->dev = pDevice->apdev;
1732 skb_reset_mac_header(skb);
1733 skb->pkt_type = PACKET_OTHERHOST;
1734
1735 memset(skb->cb, 0, sizeof(skb->cb));
1736 netif_rx(skb);
1737 }
1738 }
1739
1740 if (byTsr1 & TSR1_TERR) {
1741 if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
1742 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
1743 (int)uIdx, byTsr1, byTsr0);
1744 }
1745
1746
1747
1748
1749 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) &&
1750 (pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB)) {
1751 unsigned short wAID;
1752 unsigned char byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
1753
1754 skb = pTD->pTDInfo->skb;
1755 if (BSSDBbIsSTAInNodeDB(pMgmt, (unsigned char *)(skb->data), &uNodeIndex)) {
1756 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
1757 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
1758 pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
1759
1760 wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
1761 pMgmt->abyPSTxMap[wAID >> 3] |= byMask[wAID & 7];
1762 pTD->pTDInfo->byFlags &= ~(TD_FLAGS_NETIF_SKB);
1763 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx_srv:tx fail re-queue sta index= %d, QueCnt= %d\n"
1764 ,(int)uNodeIndex, pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt);
1765 pStats->tx_errors--;
1766 pStats->tx_dropped--;
1767 }
1768 }
1769 }
1770 }
1771 device_free_tx_buf(pDevice,pTD);
1772 pDevice->iTDUsed[uIdx]--;
1773 }
1774 }
1775
1776
1777 if (uIdx == TYPE_AC0DMA) {
1778
1779
1780 if (AVAIL_TD(pDevice, uIdx) < RESERV_AC0DMA) {
1781 bFull = true;
1782 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " AC0DMA is Full = %d\n", pDevice->iTDUsed[uIdx]);
1783 }
1784 if (netif_queue_stopped(pDevice->dev) && (bFull==false)){
1785 netif_wake_queue(pDevice->dev);
1786 }
1787 }
1788
1789
1790 pDevice->apTailTD[uIdx] = pTD;
1791
1792 return works;
1793}
1794
1795
1796static void device_error(PSDevice pDevice, unsigned short status) {
1797
1798 if (status & ISR_FETALERR) {
1799 DBG_PRT(MSG_LEVEL_ERR, KERN_ERR
1800 "%s: Hardware fatal error.\n",
1801 pDevice->dev->name);
1802 netif_stop_queue(pDevice->dev);
1803 del_timer(&pDevice->sTimerCommand);
1804 del_timer(&(pDevice->pMgmt->sTimerSecondCallback));
1805 pDevice->bCmdRunning = false;
1806 MACbShutdown(pDevice->PortOffset);
1807 return;
1808 }
1809
1810}
1811
1812static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc) {
1813 PDEVICE_TD_INFO pTDInfo=pDesc->pTDInfo;
1814 struct sk_buff* skb=pTDInfo->skb;
1815
1816
1817 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma)) {
1818 pci_unmap_single(pDevice->pcid,pTDInfo->skb_dma,skb->len,
1819 PCI_DMA_TODEVICE);
1820 }
1821
1822 if ((pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0)
1823 dev_kfree_skb_irq(skb);
1824
1825 pTDInfo->skb_dma = 0;
1826 pTDInfo->skb = 0;
1827 pTDInfo->byFlags = 0;
1828}
1829
1830
1831
1832
1833void InitRxManagementQueue(PSDevice pDevice)
1834{
1835 pDevice->rxManeQueue.packet_num = 0;
1836 pDevice->rxManeQueue.head = pDevice->rxManeQueue.tail = 0;
1837}
1838
1839
1840
1841
1842
1843
1844
1845int MlmeThread(
1846 void * Context)
1847{
1848 PSDevice pDevice = (PSDevice) Context;
1849 PSRxMgmtPacket pRxMgmtPacket;
1850
1851
1852
1853
1854
1855
1856#if 1
1857 while (1)
1858 {
1859
1860
1861
1862
1863#if 1
1864 spin_lock_irq(&pDevice->lock);
1865 while(pDevice->rxManeQueue.packet_num != 0)
1866 {
1867 pRxMgmtPacket = DeQueue(pDevice);
1868
1869
1870 vMgrRxManagePacket(pDevice, pDevice->pMgmt, pRxMgmtPacket);
1871
1872
1873 }
1874 spin_unlock_irq(&pDevice->lock);
1875 if (mlme_kill == 0)
1876 break;
1877
1878#endif
1879
1880 schedule();
1881
1882 if (mlme_kill == 0)
1883 break;
1884
1885 }
1886
1887#endif
1888 return 0;
1889
1890}
1891
1892
1893
1894static int device_open(struct net_device *dev) {
1895 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1896 int i;
1897#ifdef WPA_SM_Transtatus
1898 extern SWPAResult wpa_Result;
1899#endif
1900
1901 pDevice->rx_buf_sz = PKT_BUF_SZ;
1902 if (!device_init_rings(pDevice)) {
1903 return -ENOMEM;
1904 }
1905
1906 i=request_irq(pDevice->pcid->irq, &device_intr, IRQF_SHARED, dev->name, dev);
1907 if (i)
1908 return i;
1909
1910#ifdef WPA_SM_Transtatus
1911 memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1912 wpa_Result.proto = 0;
1913 wpa_Result.key_mgmt = 0;
1914 wpa_Result.eap_type = 0;
1915 wpa_Result.authenticated = false;
1916 pDevice->fWPA_Authened = false;
1917#endif
1918DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device init rd0 ring\n");
1919device_init_rd0_ring(pDevice);
1920 device_init_rd1_ring(pDevice);
1921 device_init_defrag_cb(pDevice);
1922 device_init_td0_ring(pDevice);
1923 device_init_td1_ring(pDevice);
1924
1925
1926
1927 if (pDevice->bDiversityRegCtlON) {
1928 device_init_diversity_timer(pDevice);
1929 }
1930 vMgrObjectInit(pDevice);
1931 vMgrTimerInit(pDevice);
1932
1933
1934#ifdef TASK_LET
1935 tasklet_init (&pDevice->RxMngWorkItem,(void *)MngWorkItem,(unsigned long )pDevice);
1936#endif
1937#ifdef THREAD
1938 InitRxManagementQueue(pDevice);
1939 mlme_kill = 0;
1940 mlme_task = kthread_run(MlmeThread,(void *) pDevice, "MLME");
1941 if (IS_ERR(mlme_task)) {
1942 printk("thread create fail\n");
1943 return -1;
1944 }
1945
1946 mlme_kill = 1;
1947#endif
1948
1949
1950
1951#if 0
1952 pDevice->MLMEThr_pid = kernel_thread(MlmeThread, pDevice, CLONE_VM);
1953 if (pDevice->MLMEThr_pid <0 )
1954 {
1955 printk("unable start thread MlmeThread\n");
1956 return -1;
1957 }
1958#endif
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device_init_registers\n");
1970 device_init_registers(pDevice, DEVICE_INIT_COLD);
1971 MACvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr);
1972 memcpy(pDevice->pMgmt->abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1973 device_set_multi(pDevice->dev);
1974
1975
1976 KeyvInitTable(&pDevice->sKey, pDevice->PortOffset);
1977 add_timer(&(pDevice->pMgmt->sTimerSecondCallback));
1978
1979 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1980
1981
1982
1983
1984
1985
1986 pDevice->bwextcount=0;
1987 pDevice->bWPASuppWextEnabled = false;
1988#endif
1989 pDevice->byReAssocCount = 0;
1990 pDevice->bWPADEVUp = false;
1991
1992 if ((pDevice->bEncryptionEnable == true) && (pDevice->bTransmitKey == true)) {
1993 KeybSetDefaultKey(&(pDevice->sKey),
1994 (unsigned long)(pDevice->byKeyIndex | (1 << 31)),
1995 pDevice->uKeyLength,
1996 NULL,
1997 pDevice->abyKey,
1998 KEY_CTL_WEP,
1999 pDevice->PortOffset,
2000 pDevice->byLocalID
2001 );
2002 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
2003 }
2004
2005
2006
2007
2008DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call MACvIntEnable\n");
2009 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
2010
2011 if (pDevice->pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2012 bScheduleCommand((void *)pDevice, WLAN_CMD_RUN_AP, NULL);
2013 }
2014 else {
2015 bScheduleCommand((void *)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
2016 bScheduleCommand((void *)pDevice, WLAN_CMD_SSID, NULL);
2017 }
2018 pDevice->flags |=DEVICE_FLAGS_OPENED;
2019
2020 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
2021 return 0;
2022}
2023
2024
2025static int device_close(struct net_device *dev) {
2026 PSDevice pDevice=(PSDevice) netdev_priv(dev);
2027 PSMgmtObject pMgmt = pDevice->pMgmt;
2028
2029#ifdef THREAD
2030 mlme_kill = 0;
2031#endif
2032
2033
2034 if (pDevice->bLinkPass) {
2035 bScheduleCommand((void *)pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2036 mdelay(30);
2037 }
2038#ifdef TxInSleep
2039 del_timer(&pDevice->sTimerTxData);
2040#endif
2041 del_timer(&pDevice->sTimerCommand);
2042 del_timer(&pMgmt->sTimerSecondCallback);
2043 if (pDevice->bDiversityRegCtlON) {
2044 del_timer(&pDevice->TimerSQ3Tmax1);
2045 del_timer(&pDevice->TimerSQ3Tmax2);
2046 del_timer(&pDevice->TimerSQ3Tmax3);
2047 }
2048
2049#ifdef TASK_LET
2050 tasklet_kill(&pDevice->RxMngWorkItem);
2051#endif
2052 netif_stop_queue(dev);
2053 pDevice->bCmdRunning = false;
2054 MACbShutdown(pDevice->PortOffset);
2055 MACbSoftwareReset(pDevice->PortOffset);
2056 CARDbRadioPowerOff(pDevice);
2057
2058 pDevice->bLinkPass = false;
2059 memset(pMgmt->abyCurrBSSID, 0, 6);
2060 pMgmt->eCurrState = WMAC_STATE_IDLE;
2061 device_free_td0_ring(pDevice);
2062 device_free_td1_ring(pDevice);
2063 device_free_rd0_ring(pDevice);
2064 device_free_rd1_ring(pDevice);
2065 device_free_frag_buf(pDevice);
2066 device_free_rings(pDevice);
2067 BSSvClearNodeDBTable(pDevice, 0);
2068 free_irq(dev->irq, dev);
2069 pDevice->flags &=(~DEVICE_FLAGS_OPENED);
2070
2071device_release_WPADEV(pDevice);
2072
2073
2074
2075 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close.. \n");
2076 return 0;
2077}
2078
2079
2080
2081static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev) {
2082 PSDevice pDevice=netdev_priv(dev);
2083 unsigned char *pbMPDU;
2084 unsigned int cbMPDULen = 0;
2085
2086
2087 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211\n");
2088 spin_lock_irq(&pDevice->lock);
2089
2090 if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) {
2091 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211, td0 <=0\n");
2092 dev_kfree_skb_irq(skb);
2093 spin_unlock_irq(&pDevice->lock);
2094 return 0;
2095 }
2096
2097 if (pDevice->bStopTx0Pkt == true) {
2098 dev_kfree_skb_irq(skb);
2099 spin_unlock_irq(&pDevice->lock);
2100 return 0;
2101 }
2102
2103 cbMPDULen = skb->len;
2104 pbMPDU = skb->data;
2105
2106 vDMA0_tx_80211(pDevice, skb, pbMPDU, cbMPDULen);
2107
2108 spin_unlock_irq(&pDevice->lock);
2109
2110 return 0;
2111
2112}
2113
2114
2115
2116bool device_dma0_xmit(PSDevice pDevice, struct sk_buff *skb, unsigned int uNodeIndex) {
2117 PSMgmtObject pMgmt = pDevice->pMgmt;
2118 PSTxDesc pHeadTD, pLastTD;
2119 unsigned int cbFrameBodySize;
2120 unsigned int uMACfragNum;
2121 unsigned char byPktType;
2122 bool bNeedEncryption = false;
2123 PSKeyItem pTransmitKey = NULL;
2124 unsigned int cbHeaderSize;
2125 unsigned int ii;
2126 SKeyItem STempKey;
2127
2128
2129
2130 if (pDevice->bStopTx0Pkt == true) {
2131 dev_kfree_skb_irq(skb);
2132 return false;
2133 }
2134
2135 if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) {
2136 dev_kfree_skb_irq(skb);
2137 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, td0 <=0\n");
2138 return false;
2139 }
2140
2141 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2142 if (pDevice->uAssocCount == 0) {
2143 dev_kfree_skb_irq(skb);
2144 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, assocCount = 0\n");
2145 return false;
2146 }
2147 }
2148
2149 pHeadTD = pDevice->apCurrTD[TYPE_TXDMA0];
2150
2151 pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
2152
2153 memcpy(pDevice->sTxEthHeader.abyDstAddr, (unsigned char *)(skb->data), ETH_HLEN);
2154 cbFrameBodySize = skb->len - ETH_HLEN;
2155
2156
2157 if (ntohs(pDevice->sTxEthHeader.wType) > ETH_DATA_LEN) {
2158 cbFrameBodySize += 8;
2159 }
2160 uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
2161
2162 if ( uMACfragNum > AVAIL_TD(pDevice, TYPE_TXDMA0)) {
2163 dev_kfree_skb_irq(skb);
2164 return false;
2165 }
2166 byPktType = (unsigned char)pDevice->byPacketType;
2167
2168
2169 if (pDevice->bFixRate) {
2170 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
2171 if (pDevice->uConnectionRate >= RATE_11M) {
2172 pDevice->wCurrentRate = RATE_11M;
2173 } else {
2174 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
2175 }
2176 } else {
2177 if (pDevice->uConnectionRate >= RATE_54M)
2178 pDevice->wCurrentRate = RATE_54M;
2179 else
2180 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
2181 }
2182 }
2183 else {
2184 pDevice->wCurrentRate = pDevice->pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
2185 }
2186
2187
2188 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2189 pDevice->byPreambleType = pDevice->byShortPreamble;
2190 }
2191 else {
2192 pDevice->byPreambleType = PREAMBLE_LONG;
2193 }
2194
2195 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate);
2196
2197
2198 if (pDevice->wCurrentRate <= RATE_11M) {
2199 byPktType = PK_TYPE_11B;
2200 } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
2201 byPktType = PK_TYPE_11A;
2202 } else {
2203 if (pDevice->bProtectMode == true) {
2204 byPktType = PK_TYPE_11GB;
2205 } else {
2206 byPktType = PK_TYPE_11GA;
2207 }
2208 }
2209
2210 if (pDevice->bEncryptionEnable == true)
2211 bNeedEncryption = true;
2212
2213 if (pDevice->bEnableHostWEP) {
2214 pTransmitKey = &STempKey;
2215 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2216 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2217 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2218 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2219 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2220 memcpy(pTransmitKey->abyKey,
2221 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2222 pTransmitKey->uKeyLength
2223 );
2224 }
2225 vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption,
2226 cbFrameBodySize, TYPE_TXDMA0, pHeadTD,
2227 &pDevice->sTxEthHeader, (unsigned char *)skb->data, pTransmitKey, uNodeIndex,
2228 &uMACfragNum,
2229 &cbHeaderSize
2230 );
2231
2232 if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
2233
2234 MACbPSWakeup(pDevice->PortOffset);
2235 }
2236
2237 pDevice->bPWBitOn = false;
2238
2239 pLastTD = pHeadTD;
2240 for (ii = 0; ii < uMACfragNum; ii++) {
2241
2242 wmb();
2243 pHeadTD->m_td0TD0.f1Owner=OWNED_BY_NIC;
2244 wmb();
2245 if (ii == (uMACfragNum - 1))
2246 pLastTD = pHeadTD;
2247 pHeadTD = pHeadTD->next;
2248 }
2249
2250
2251
2252 pLastTD->pTDInfo->skb = skb;
2253 pLastTD->pTDInfo->byFlags = 0;
2254 pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
2255
2256 pDevice->apCurrTD[TYPE_TXDMA0] = pHeadTD;
2257
2258 MACvTransmit0(pDevice->PortOffset);
2259
2260
2261 return true;
2262}
2263
2264
2265static int device_xmit(struct sk_buff *skb, struct net_device *dev) {
2266 PSDevice pDevice=netdev_priv(dev);
2267
2268 PSMgmtObject pMgmt = pDevice->pMgmt;
2269 PSTxDesc pHeadTD, pLastTD;
2270 unsigned int uNodeIndex = 0;
2271 unsigned char byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
2272 unsigned short wAID;
2273 unsigned int uMACfragNum = 1;
2274 unsigned int cbFrameBodySize;
2275 unsigned char byPktType;
2276 unsigned int cbHeaderSize;
2277 bool bNeedEncryption = false;
2278 PSKeyItem pTransmitKey = NULL;
2279 SKeyItem STempKey;
2280 unsigned int ii;
2281 bool bTKIP_UseGTK = false;
2282 bool bNeedDeAuth = false;
2283 unsigned char *pbyBSSID;
2284 bool bNodeExist = false;
2285
2286
2287
2288 spin_lock_irq(&pDevice->lock);
2289 if (pDevice->bLinkPass == false) {
2290 dev_kfree_skb_irq(skb);
2291 spin_unlock_irq(&pDevice->lock);
2292 return 0;
2293 }
2294
2295 if (pDevice->bStopDataPkt) {
2296 dev_kfree_skb_irq(skb);
2297 spin_unlock_irq(&pDevice->lock);
2298 return 0;
2299 }
2300
2301
2302 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2303 if (pDevice->uAssocCount == 0) {
2304 dev_kfree_skb_irq(skb);
2305 spin_unlock_irq(&pDevice->lock);
2306 return 0;
2307 }
2308 if (is_multicast_ether_addr((unsigned char *)(skb->data))) {
2309 uNodeIndex = 0;
2310 bNodeExist = true;
2311 if (pMgmt->sNodeDBTable[0].bPSEnable) {
2312 skb_queue_tail(&(pMgmt->sNodeDBTable[0].sTxPSQueue), skb);
2313 pMgmt->sNodeDBTable[0].wEnQueueCnt++;
2314
2315 pMgmt->abyPSTxMap[0] |= byMask[0];
2316 spin_unlock_irq(&pDevice->lock);
2317 return 0;
2318 }
2319}else {
2320 if (BSSDBbIsSTAInNodeDB(pMgmt, (unsigned char *)(skb->data), &uNodeIndex)) {
2321 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
2322 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
2323 pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
2324
2325 wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
2326 pMgmt->abyPSTxMap[wAID >> 3] |= byMask[wAID & 7];
2327 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set:pMgmt->abyPSTxMap[%d]= %d\n",
2328 (wAID >> 3), pMgmt->abyPSTxMap[wAID >> 3]);
2329 spin_unlock_irq(&pDevice->lock);
2330 return 0;
2331 }
2332
2333 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2334 pDevice->byPreambleType = pDevice->byShortPreamble;
2335
2336 }else {
2337 pDevice->byPreambleType = PREAMBLE_LONG;
2338 }
2339 bNodeExist = true;
2340
2341 }
2342 }
2343
2344 if (bNodeExist == false) {
2345 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Unknown STA not found in node DB \n");
2346 dev_kfree_skb_irq(skb);
2347 spin_unlock_irq(&pDevice->lock);
2348 return 0;
2349 }
2350 }
2351
2352 pHeadTD = pDevice->apCurrTD[TYPE_AC0DMA];
2353
2354 pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
2355
2356
2357 memcpy(pDevice->sTxEthHeader.abyDstAddr, (unsigned char *)(skb->data), ETH_HLEN);
2358 cbFrameBodySize = skb->len - ETH_HLEN;
2359
2360 if (ntohs(pDevice->sTxEthHeader.wType) > ETH_DATA_LEN) {
2361 cbFrameBodySize += 8;
2362 }
2363
2364
2365 if (pDevice->bEncryptionEnable == true) {
2366 bNeedEncryption = true;
2367
2368 do {
2369 if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
2370 (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2371 pbyBSSID = pDevice->abyBSSID;
2372
2373 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == false) {
2374
2375 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == true) {
2376 bTKIP_UseGTK = true;
2377 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2378 break;
2379 }
2380 } else {
2381 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get PTK.\n");
2382 break;
2383 }
2384 }else if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2385
2386 pbyBSSID = pDevice->sTxEthHeader.abyDstAddr;
2387 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS Serach Key: \n");
2388 for (ii = 0; ii< 6; ii++)
2389 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"%x \n", *(pbyBSSID+ii));
2390 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"\n");
2391
2392
2393 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == true)
2394 break;
2395 }
2396
2397 pbyBSSID = pDevice->abyBroadcastAddr;
2398 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == false) {
2399 pTransmitKey = NULL;
2400 if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2401 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode);
2402 }
2403 else
2404 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"NOT IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode);
2405 } else {
2406 bTKIP_UseGTK = true;
2407 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2408 }
2409 } while(false);
2410 }
2411
2412 if (pDevice->bEnableHostWEP) {
2413 DBG_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"acdma0: STA index %d\n", uNodeIndex);
2414 if (pDevice->bEncryptionEnable == true) {
2415 pTransmitKey = &STempKey;
2416 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2417 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2418 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2419 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2420 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2421 memcpy(pTransmitKey->abyKey,
2422 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2423 pTransmitKey->uKeyLength
2424 );
2425 }
2426 }
2427
2428 uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
2429
2430 if (uMACfragNum > AVAIL_TD(pDevice, TYPE_AC0DMA)) {
2431 DBG_PRT(MSG_LEVEL_ERR, KERN_DEBUG "uMACfragNum > AVAIL_TD(TYPE_AC0DMA) = %d\n", uMACfragNum);
2432 dev_kfree_skb_irq(skb);
2433 spin_unlock_irq(&pDevice->lock);
2434 return 0;
2435 }
2436
2437 if (pTransmitKey != NULL) {
2438 if ((pTransmitKey->byCipherSuite == KEY_CTL_WEP) &&
2439 (pTransmitKey->uKeyLength == WLAN_WEP232_KEYLEN)) {
2440 uMACfragNum = 1;
2441 }
2442 }
2443
2444 byPktType = (unsigned char)pDevice->byPacketType;
2445
2446 if (pDevice->bFixRate) {
2447#ifdef PLICE_DEBUG
2448 printk("Fix Rate: PhyType is %d,ConnectionRate is %d\n",pDevice->eCurrentPHYType,pDevice->uConnectionRate);
2449#endif
2450
2451 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
2452 if (pDevice->uConnectionRate >= RATE_11M) {
2453 pDevice->wCurrentRate = RATE_11M;
2454 } else {
2455 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
2456 }
2457 } else {
2458 if ((pDevice->eCurrentPHYType == PHY_TYPE_11A) &&
2459 (pDevice->uConnectionRate <= RATE_6M)) {
2460 pDevice->wCurrentRate = RATE_6M;
2461 } else {
2462 if (pDevice->uConnectionRate >= RATE_54M)
2463 pDevice->wCurrentRate = RATE_54M;
2464 else
2465 pDevice->wCurrentRate = (unsigned short)pDevice->uConnectionRate;
2466
2467 }
2468 }
2469 pDevice->byACKRate = (unsigned char) pDevice->wCurrentRate;
2470 pDevice->byTopCCKBasicRate = RATE_1M;
2471 pDevice->byTopOFDMBasicRate = RATE_6M;
2472 }
2473 else {
2474
2475 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
2476 if (pDevice->eCurrentPHYType != PHY_TYPE_11A) {
2477 pDevice->wCurrentRate = RATE_1M;
2478 pDevice->byACKRate = RATE_1M;
2479 pDevice->byTopCCKBasicRate = RATE_1M;
2480 pDevice->byTopOFDMBasicRate = RATE_6M;
2481 } else {
2482 pDevice->wCurrentRate = RATE_6M;
2483 pDevice->byACKRate = RATE_6M;
2484 pDevice->byTopCCKBasicRate = RATE_1M;
2485 pDevice->byTopOFDMBasicRate = RATE_6M;
2486 }
2487 }
2488 else {
2489 VNTWIFIvGetTxRate( pDevice->pMgmt,
2490 pDevice->sTxEthHeader.abyDstAddr,
2491 &(pDevice->wCurrentRate),
2492 &(pDevice->byACKRate),
2493 &(pDevice->byTopCCKBasicRate),
2494 &(pDevice->byTopOFDMBasicRate));
2495
2496#if 0
2497printk("auto rate:Rate : %d,AckRate:%d,TopCCKRate:%d,TopOFDMRate:%d\n",
2498pDevice->wCurrentRate,pDevice->byACKRate,
2499pDevice->byTopCCKBasicRate,pDevice->byTopOFDMBasicRate);
2500
2501#endif
2502
2503#if 0
2504
2505 pDevice->wCurrentRate = 11;
2506 pDevice->byACKRate = 8;
2507 pDevice->byTopCCKBasicRate = 3;
2508 pDevice->byTopOFDMBasicRate = 8;
2509#endif
2510
2511
2512 }
2513 }
2514
2515
2516
2517 if (pDevice->wCurrentRate <= RATE_11M) {
2518 byPktType = PK_TYPE_11B;
2519 } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
2520 byPktType = PK_TYPE_11A;
2521 } else {
2522 if (pDevice->bProtectMode == true) {
2523 byPktType = PK_TYPE_11GB;
2524 } else {
2525 byPktType = PK_TYPE_11GA;
2526 }
2527 }
2528
2529
2530
2531
2532
2533 if (bNeedEncryption == true) {
2534 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ntohs Pkt Type=%04x\n", ntohs(pDevice->sTxEthHeader.wType));
2535 if ((pDevice->sTxEthHeader.wType) == TYPE_PKT_802_1x) {
2536 bNeedEncryption = false;
2537 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Pkt Type=%04x\n", (pDevice->sTxEthHeader.wType));
2538 if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2539 if (pTransmitKey == NULL) {
2540 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Don't Find TX KEY\n");
2541 }
2542 else {
2543 if (bTKIP_UseGTK == true) {
2544 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"error: KEY is GTK!!~~\n");
2545 }
2546 else {
2547 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
2548 bNeedEncryption = true;
2549 }
2550 }
2551 }
2552
2553 if (pDevice->byCntMeasure == 2) {
2554 bNeedDeAuth = true;
2555 pDevice->s802_11Counter.TKIPCounterMeasuresInvoked++;
2556 }
2557
2558 if (pDevice->bEnableHostWEP) {
2559 if ((uNodeIndex != 0) &&
2560 (pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex & PAIRWISE_KEY)) {
2561 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
2562 bNeedEncryption = true;
2563 }
2564 }
2565 }
2566 else {
2567 if (pTransmitKey == NULL) {
2568 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"return no tx key\n");
2569 dev_kfree_skb_irq(skb);
2570 spin_unlock_irq(&pDevice->lock);
2571 return 0;
2572 }
2573 }
2574 }
2575
2576
2577#ifdef PLICE_DEBUG
2578
2579
2580
2581
2582#endif
2583 vGenerateFIFOHeader(pDevice, byPktType, pDevice->pbyTmpBuff, bNeedEncryption,
2584 cbFrameBodySize, TYPE_AC0DMA, pHeadTD,
2585 &pDevice->sTxEthHeader, (unsigned char *)skb->data, pTransmitKey, uNodeIndex,
2586 &uMACfragNum,
2587 &cbHeaderSize
2588 );
2589
2590 if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
2591
2592 MACbPSWakeup(pDevice->PortOffset);
2593 }
2594 pDevice->bPWBitOn = false;
2595
2596 pLastTD = pHeadTD;
2597 for (ii = 0; ii < uMACfragNum; ii++) {
2598
2599 wmb();
2600 pHeadTD->m_td0TD0.f1Owner=OWNED_BY_NIC;
2601 wmb();
2602 if (ii == uMACfragNum - 1)
2603 pLastTD = pHeadTD;
2604 pHeadTD = pHeadTD->next;
2605 }
2606
2607
2608
2609 pLastTD->pTDInfo->skb = skb;
2610 pLastTD->pTDInfo->byFlags = 0;
2611 pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
2612#ifdef TxInSleep
2613 pDevice->nTxDataTimeCout=0;
2614 #endif
2615 if (AVAIL_TD(pDevice, TYPE_AC0DMA) <= 1) {
2616 netif_stop_queue(dev);
2617 }
2618
2619 pDevice->apCurrTD[TYPE_AC0DMA] = pHeadTD;
2620
2621 if (pDevice->bFixRate)
2622 {
2623 printk("FixRate:Rate is %d,TxPower is %d\n",pDevice->wCurrentRate,pDevice->byCurPwr);
2624 }
2625 else
2626 {
2627
2628 }
2629
2630
2631{
2632 unsigned char Protocol_Version;
2633 unsigned char Packet_Type;
2634 unsigned char Descriptor_type;
2635 unsigned short Key_info;
2636bool bTxeapol_key = false;
2637 Protocol_Version = skb->data[ETH_HLEN];
2638 Packet_Type = skb->data[ETH_HLEN+1];
2639 Descriptor_type = skb->data[ETH_HLEN+1+1+2];
2640 Key_info = (skb->data[ETH_HLEN+1+1+2+1] << 8)|(skb->data[ETH_HLEN+1+1+2+2]);
2641 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
2642 if(((Protocol_Version==1) ||(Protocol_Version==2)) &&
2643 (Packet_Type==3)) {
2644 bTxeapol_key = true;
2645 if((Descriptor_type==254)||(Descriptor_type==2)) {
2646 if(!(Key_info & BIT3) &&
2647 (Key_info & BIT8) && (Key_info & BIT9)) {
2648 pDevice->fWPA_Authened = true;
2649 if(Descriptor_type==254)
2650 printk("WPA ");
2651 else
2652 printk("WPA2 ");
2653 printk("Authentication completed!!\n");
2654 }
2655 }
2656 }
2657 }
2658}
2659
2660 MACvTransmitAC0(pDevice->PortOffset);
2661
2662
2663 dev->trans_start = jiffies;
2664
2665 spin_unlock_irq(&pDevice->lock);
2666 return 0;
2667
2668}
2669
2670static irqreturn_t device_intr(int irq, void *dev_instance) {
2671 struct net_device* dev=dev_instance;
2672 PSDevice pDevice=(PSDevice) netdev_priv(dev);
2673
2674 int max_count=0;
2675 unsigned long dwMIBCounter=0;
2676 PSMgmtObject pMgmt = pDevice->pMgmt;
2677 unsigned char byOrgPageSel=0;
2678 int handled = 0;
2679 unsigned char byData = 0;
2680 int ii= 0;
2681
2682
2683
2684 MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr);
2685
2686 if (pDevice->dwIsr == 0)
2687 return IRQ_RETVAL(handled);
2688
2689 if (pDevice->dwIsr == 0xffffffff) {
2690 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dwIsr = 0xffff\n");
2691 return IRQ_RETVAL(handled);
2692 }
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705 handled = 1;
2706 MACvIntDisable(pDevice->PortOffset);
2707 spin_lock_irq(&pDevice->lock);
2708
2709
2710 VNSvInPortB(pDevice->PortOffset + MAC_REG_PAGE1SEL, &byOrgPageSel);
2711 if (byOrgPageSel == 1) {
2712 MACvSelectPage0(pDevice->PortOffset);
2713 }
2714 else
2715 byOrgPageSel = 0;
2716
2717 MACvReadMIBCounter(pDevice->PortOffset, &dwMIBCounter);
2718
2719
2720
2721
2722 STAvUpdate802_11Counter(&pDevice->s802_11Counter, &pDevice->scStatistic , dwMIBCounter);
2723 while (pDevice->dwIsr != 0) {
2724
2725 STAvUpdateIsrStatCounter(&pDevice->scStatistic, pDevice->dwIsr);
2726 MACvWriteISR(pDevice->PortOffset, pDevice->dwIsr);
2727
2728 if (pDevice->dwIsr & ISR_FETALERR){
2729 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " ISR_FETALERR \n");
2730 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, 0);
2731 VNSvOutPortW(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPECTI);
2732 device_error(pDevice, pDevice->dwIsr);
2733 }
2734
2735 if (pDevice->byLocalID > REV_ID_VT3253_B1) {
2736
2737 if (pDevice->dwIsr & ISR_MEASURESTART) {
2738
2739 pDevice->byOrgChannel = pDevice->byCurrentCh;
2740 VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byOrgRCR));
2741 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, (RCR_RXALLTYPE | RCR_UNICAST | RCR_BROADCAST | RCR_MULTICAST | RCR_WPAERR));
2742 MACvSelectPage1(pDevice->PortOffset);
2743 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR0, &(pDevice->dwOrgMAR0));
2744 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR4, &(pDevice->dwOrgMAR4));
2745 MACvSelectPage0(pDevice->PortOffset);
2746
2747
2748 if (set_channel(pDevice, pDevice->pCurrMeasureEID->sReq.byChannel) == true) {
2749 pDevice->bMeasureInProgress = true;
2750 MACvSelectPage1(pDevice->PortOffset);
2751 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_READY);
2752 MACvSelectPage0(pDevice->PortOffset);
2753 pDevice->byBasicMap = 0;
2754 pDevice->byCCAFraction = 0;
2755 for(ii=0;ii<8;ii++) {
2756 pDevice->dwRPIs[ii] = 0;
2757 }
2758 } else {
2759
2760
2761
2762 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN);
2763 s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_INCAPABLE);
2764 MACvSelectPage1(pDevice->PortOffset);
2765 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2766 MACvSelectPage0(pDevice->PortOffset);
2767 }
2768 }
2769 if (pDevice->dwIsr & ISR_MEASUREEND) {
2770
2771 pDevice->bMeasureInProgress = false;
2772 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byOrgRCR);
2773 MACvSelectPage1(pDevice->PortOffset);
2774 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, pDevice->dwOrgMAR0);
2775 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR4, pDevice->dwOrgMAR4);
2776 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRBBSTS, &byData);
2777 pDevice->byBasicMap |= (byData >> 4);
2778 VNSvInPortB(pDevice->PortOffset + MAC_REG_CCAFRACTION, &pDevice->byCCAFraction);
2779 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRCTL, &byData);
2780
2781 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN);
2782 MACvSelectPage0(pDevice->PortOffset);
2783 set_channel(pDevice, pDevice->byOrgChannel);
2784
2785 MACvSelectPage1(pDevice->PortOffset);
2786 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2787 MACvSelectPage0(pDevice->PortOffset);
2788 if (byData & MSRCTL_FINISH) {
2789
2790 s_vCompleteCurrentMeasure(pDevice, 0);
2791 } else {
2792
2793 s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_LATE);
2794 }
2795 }
2796 if (pDevice->dwIsr & ISR_QUIETSTART) {
2797 do {
2798 ;
2799 } while (CARDbStartQuiet(pDevice) == false);
2800 }
2801 }
2802
2803 if (pDevice->dwIsr & ISR_TBTT) {
2804 if (pDevice->bEnableFirstQuiet == true) {
2805 pDevice->byQuietStartCount--;
2806 if (pDevice->byQuietStartCount == 0) {
2807 pDevice->bEnableFirstQuiet = false;
2808 MACvSelectPage1(pDevice->PortOffset);
2809 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN));
2810 MACvSelectPage0(pDevice->PortOffset);
2811 }
2812 }
2813 if ((pDevice->bChannelSwitch == true) &&
2814 (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE)) {
2815 pDevice->byChannelSwitchCount--;
2816 if (pDevice->byChannelSwitchCount == 0) {
2817 pDevice->bChannelSwitch = false;
2818 set_channel(pDevice, pDevice->byNewChannel);
2819 VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel);
2820 MACvSelectPage1(pDevice->PortOffset);
2821 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2822 MACvSelectPage0(pDevice->PortOffset);
2823 CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL);
2824
2825 }
2826 }
2827 if (pDevice->eOPMode == OP_MODE_ADHOC) {
2828
2829 } else {
2830 if ((pDevice->bUpdateBBVGA) && (pDevice->bLinkPass == true) && (pDevice->uCurrRSSI != 0)) {
2831 long ldBm;
2832
2833 RFvRSSITodBm(pDevice, (unsigned char) pDevice->uCurrRSSI, &ldBm);
2834 for (ii=0;ii<BB_VGA_LEVEL;ii++) {
2835 if (ldBm < pDevice->ldBmThreshold[ii]) {
2836 pDevice->byBBVGANew = pDevice->abyBBVGA[ii];
2837 break;
2838 }
2839 }
2840 if (pDevice->byBBVGANew != pDevice->byBBVGACurrent) {
2841 pDevice->uBBVGADiffCount++;
2842 if (pDevice->uBBVGADiffCount == 1) {
2843
2844 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew);
2845 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"First RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
2846 (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount);
2847 }
2848 if (pDevice->uBBVGADiffCount >= BB_VGA_CHANGE_THRESHOLD) {
2849 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
2850 (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount);
2851 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew);
2852 }
2853 } else {
2854 pDevice->uBBVGADiffCount = 1;
2855 }
2856 }
2857 }
2858
2859 pDevice->bBeaconSent = false;
2860 if (pDevice->bEnablePSMode) {
2861 PSbIsNextTBTTWakeUp((void *)pDevice);
2862 }
2863
2864 if ((pDevice->eOPMode == OP_MODE_AP) ||
2865 (pDevice->eOPMode == OP_MODE_ADHOC)) {
2866
2867 MACvOneShotTimer1MicroSec(pDevice->PortOffset,
2868 (pMgmt->wIBSSBeaconPeriod - MAKE_BEACON_RESERVED) << 10);
2869 }
2870
2871 if (pDevice->eOPMode == OP_MODE_ADHOC && pDevice->pMgmt->wCurrATIMWindow > 0) {
2872
2873 }
2874
2875 }
2876
2877 if (pDevice->dwIsr & ISR_BNTX) {
2878
2879 if (pDevice->eOPMode == OP_MODE_ADHOC) {
2880 pDevice->bIsBeaconBufReadySet = false;
2881 pDevice->cbBeaconBufReadySetCnt = 0;
2882 }
2883
2884 if (pDevice->eOPMode == OP_MODE_AP) {
2885 if(pMgmt->byDTIMCount > 0) {
2886 pMgmt->byDTIMCount --;
2887 pMgmt->sNodeDBTable[0].bRxPSPoll = false;
2888 }
2889 else {
2890 if(pMgmt->byDTIMCount == 0) {
2891
2892 pMgmt->byDTIMCount = pMgmt->byDTIMPeriod - 1;
2893 pMgmt->sNodeDBTable[0].bRxPSPoll = true;
2894 bScheduleCommand((void *)pDevice, WLAN_CMD_RX_PSPOLL, NULL);
2895 }
2896 }
2897 }
2898 pDevice->bBeaconSent = true;
2899
2900 if (pDevice->bChannelSwitch == true) {
2901 pDevice->byChannelSwitchCount--;
2902 if (pDevice->byChannelSwitchCount == 0) {
2903 pDevice->bChannelSwitch = false;
2904 set_channel(pDevice, pDevice->byNewChannel);
2905 VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel);
2906 MACvSelectPage1(pDevice->PortOffset);
2907 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
2908 MACvSelectPage0(pDevice->PortOffset);
2909
2910 CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL);
2911 }
2912 }
2913
2914 }
2915
2916 if (pDevice->dwIsr & ISR_RXDMA0) {
2917 max_count += device_rx_srv(pDevice, TYPE_RXDMA0);
2918 }
2919 if (pDevice->dwIsr & ISR_RXDMA1) {
2920 max_count += device_rx_srv(pDevice, TYPE_RXDMA1);
2921 }
2922 if (pDevice->dwIsr & ISR_TXDMA0){
2923 max_count += device_tx_srv(pDevice, TYPE_TXDMA0);
2924 }
2925 if (pDevice->dwIsr & ISR_AC0DMA){
2926 max_count += device_tx_srv(pDevice, TYPE_AC0DMA);
2927 }
2928 if (pDevice->dwIsr & ISR_SOFTTIMER) {
2929
2930 }
2931 if (pDevice->dwIsr & ISR_SOFTTIMER1) {
2932 if (pDevice->eOPMode == OP_MODE_AP) {
2933 if (pDevice->bShortSlotTime)
2934 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTSLOTTIME(1);
2935 else
2936 pMgmt->wCurrCapInfo &= ~(WLAN_SET_CAP_INFO_SHORTSLOTTIME(1));
2937 }
2938 bMgrPrepareBeaconToSend(pDevice, pMgmt);
2939 pDevice->byCntMeasure = 0;
2940 }
2941
2942 MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr);
2943
2944 MACvReceive0(pDevice->PortOffset);
2945 MACvReceive1(pDevice->PortOffset);
2946
2947 if (max_count>pDevice->sOpts.int_works)
2948 break;
2949 }
2950
2951 if (byOrgPageSel == 1) {
2952 MACvSelectPage1(pDevice->PortOffset);
2953 }
2954
2955 spin_unlock_irq(&pDevice->lock);
2956 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
2957
2958 return IRQ_RETVAL(handled);
2959}
2960
2961
2962static unsigned const ethernet_polynomial = 0x04c11db7U;
2963static inline u32 ether_crc(int length, unsigned char *data)
2964{
2965 int crc = -1;
2966
2967 while(--length >= 0) {
2968 unsigned char current_octet = *data++;
2969 int bit;
2970 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
2971 crc = (crc << 1) ^
2972 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
2973 }
2974 }
2975 return crc;
2976}
2977
2978
2979static int Config_FileGetParameter(unsigned char *string,
2980 unsigned char *dest, unsigned char *source)
2981{
2982 unsigned char buf1[100];
2983 int source_len = strlen(source);
2984
2985 memset(buf1,0,100);
2986 strcat(buf1, string);
2987 strcat(buf1, "=");
2988 source+=strlen(buf1);
2989
2990 memcpy(dest,source,source_len-strlen(buf1));
2991 return true;
2992}
2993
2994int Config_FileOperation(PSDevice pDevice,bool fwrite,unsigned char *Parameter) {
2995 unsigned char *config_path = CONFIG_PATH;
2996 unsigned char *buffer = NULL;
2997 unsigned char tmpbuffer[20];
2998 struct file *filp=NULL;
2999 mm_segment_t old_fs = get_fs();
3000
3001 int result=0;
3002
3003 set_fs (KERNEL_DS);
3004
3005
3006
3007
3008
3009
3010
3011
3012
3013
3014 filp = filp_open(config_path, O_RDWR, 0);
3015 if (IS_ERR(filp)) {
3016 printk("Config_FileOperation:open file fail?\n");
3017 result=-1;
3018 goto error2;
3019 }
3020
3021 if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
3022 printk("file %s cann't readable or writable?\n",config_path);
3023 result = -1;
3024 goto error1;
3025 }
3026
3027buffer = kmalloc(1024, GFP_KERNEL);
3028if(buffer==NULL) {
3029 printk("allocate mem for file fail?\n");
3030 result = -1;
3031 goto error1;
3032}
3033
3034if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
3035 printk("read file error?\n");
3036 result = -1;
3037 goto error1;
3038}
3039
3040if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer)!=true) {
3041 printk("get parameter error?\n");
3042 result = -1;
3043 goto error1;
3044}
3045
3046if(memcmp(tmpbuffer,"USA",3)==0) {
3047 result=ZoneType_USA;
3048}
3049else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
3050 result=ZoneType_Japan;
3051}
3052else if(memcmp(tmpbuffer,"EUROPE",5)==0) {
3053 result=ZoneType_Europe;
3054}
3055else {
3056 result = -1;
3057 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
3058}
3059
3060error1:
3061 kfree(buffer);
3062
3063 if(filp_close(filp,NULL))
3064 printk("Config_FileOperation:close file fail\n");
3065
3066error2:
3067 set_fs (old_fs);
3068
3069
3070
3071
3072
3073
3074 return result;
3075}
3076
3077
3078
3079static void device_set_multi(struct net_device *dev) {
3080 PSDevice pDevice = (PSDevice) netdev_priv(dev);
3081
3082 PSMgmtObject pMgmt = pDevice->pMgmt;
3083 u32 mc_filter[2];
3084 struct netdev_hw_addr *ha;
3085
3086
3087 VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byRxMode));
3088
3089 if (dev->flags & IFF_PROMISC) {
3090 DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
3091
3092 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
3093 }
3094 else if ((netdev_mc_count(dev) > pDevice->multicast_limit)
3095 || (dev->flags & IFF_ALLMULTI)) {
3096 MACvSelectPage1(pDevice->PortOffset);
3097 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, 0xffffffff);
3098 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, 0xffffffff);
3099 MACvSelectPage0(pDevice->PortOffset);
3100 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
3101 }
3102 else {
3103 memset(mc_filter, 0, sizeof(mc_filter));
3104 netdev_for_each_mc_addr(ha, dev) {
3105 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
3106 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
3107 }
3108 MACvSelectPage1(pDevice->PortOffset);
3109 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, mc_filter[0]);
3110 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, mc_filter[1]);
3111 MACvSelectPage0(pDevice->PortOffset);
3112 pDevice->byRxMode &= ~(RCR_UNICAST);
3113 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
3114 }
3115
3116 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
3117
3118 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
3119 pDevice->byRxMode &= ~(RCR_UNICAST);
3120 }
3121
3122 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byRxMode);
3123 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode = %x\n", pDevice->byRxMode );
3124}
3125
3126
3127static struct net_device_stats *device_get_stats(struct net_device *dev) {
3128 PSDevice pDevice=(PSDevice) netdev_priv(dev);
3129
3130 return &pDevice->stats;
3131}
3132
3133
3134
3135static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
3136 PSDevice pDevice = (PSDevice)netdev_priv(dev);
3137
3138 struct iwreq *wrq = (struct iwreq *) rq;
3139 int rc =0;
3140 PSMgmtObject pMgmt = pDevice->pMgmt;
3141 PSCmdRequest pReq;
3142
3143
3144 if (pMgmt == NULL) {
3145 rc = -EFAULT;
3146 return rc;
3147 }
3148
3149 switch(cmd) {
3150
3151 case SIOCGIWNAME:
3152 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
3153 break;
3154
3155 case SIOCGIWNWID:
3156 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3157 rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
3158 #else
3159 rc = -EOPNOTSUPP;
3160 #endif
3161 break;
3162
3163
3164 case SIOCSIWFREQ:
3165 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
3166 break;
3167
3168
3169 case SIOCGIWFREQ:
3170 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
3171 break;
3172
3173
3174 case SIOCSIWESSID:
3175
3176 {
3177 char essid[IW_ESSID_MAX_SIZE+1];
3178 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
3179 rc = -E2BIG;
3180 break;
3181 }
3182 if (copy_from_user(essid, wrq->u.essid.pointer,
3183 wrq->u.essid.length)) {
3184 rc = -EFAULT;
3185 break;
3186 }
3187 rc = iwctl_siwessid(dev, NULL,
3188 &(wrq->u.essid), essid);
3189 }
3190 break;
3191
3192
3193
3194 case SIOCGIWESSID:
3195
3196 {
3197 char essid[IW_ESSID_MAX_SIZE+1];
3198 if (wrq->u.essid.pointer)
3199 rc = iwctl_giwessid(dev, NULL,
3200 &(wrq->u.essid), essid);
3201 if (copy_to_user(wrq->u.essid.pointer,
3202 essid,
3203 wrq->u.essid.length) )
3204 rc = -EFAULT;
3205 }
3206 break;
3207
3208 case SIOCSIWAP:
3209
3210 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
3211 break;
3212
3213
3214
3215 case SIOCGIWAP:
3216 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
3217 break;
3218
3219
3220
3221 case SIOCSIWNICKN:
3222 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
3223 rc = -EOPNOTSUPP;
3224 break;
3225
3226
3227 case SIOCGIWNICKN:
3228 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
3229 rc = -EOPNOTSUPP;
3230 break;
3231
3232
3233 case SIOCSIWRATE:
3234 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
3235 break;
3236
3237
3238 case SIOCGIWRATE:
3239
3240 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
3241 break;
3242
3243
3244 case SIOCSIWRTS:
3245
3246 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
3247 break;
3248
3249
3250 case SIOCGIWRTS:
3251
3252 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
3253 break;
3254
3255
3256 case SIOCSIWFRAG:
3257
3258 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
3259 break;
3260
3261
3262 case SIOCGIWFRAG:
3263
3264 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
3265 break;
3266
3267
3268 case SIOCSIWMODE:
3269 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
3270 break;
3271
3272
3273 case SIOCGIWMODE:
3274 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
3275 break;
3276
3277
3278 case SIOCSIWENCODE:
3279 {
3280 char abyKey[WLAN_WEP232_KEYLEN];
3281
3282 if (wrq->u.encoding.pointer) {
3283
3284
3285 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
3286 rc = -E2BIG;
3287 break;
3288 }
3289 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
3290 if (copy_from_user(abyKey,
3291 wrq->u.encoding.pointer,
3292 wrq->u.encoding.length)) {
3293 rc = -EFAULT;
3294 break;
3295 }
3296 } else if (wrq->u.encoding.length != 0) {
3297 rc = -EINVAL;
3298 break;
3299 }
3300 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
3301 }
3302 break;
3303
3304
3305 case SIOCGIWENCODE:
3306
3307 if (!capable(CAP_NET_ADMIN)) {
3308 rc = -EPERM;
3309 break;
3310 }
3311 {
3312 char abyKey[WLAN_WEP232_KEYLEN];
3313
3314 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
3315 if (rc != 0) break;
3316 if (wrq->u.encoding.pointer) {
3317 if (copy_to_user(wrq->u.encoding.pointer,
3318 abyKey,
3319 wrq->u.encoding.length))
3320 rc = -EFAULT;
3321 }
3322 }
3323 break;
3324
3325
3326 case SIOCGIWTXPOW:
3327 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
3328 rc = -EOPNOTSUPP;
3329 break;
3330
3331 case SIOCSIWTXPOW:
3332 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWTXPOW \n");
3333 rc = -EOPNOTSUPP;
3334 break;
3335
3336 case SIOCSIWRETRY:
3337
3338 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
3339 break;
3340
3341 case SIOCGIWRETRY:
3342
3343 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
3344 break;
3345
3346
3347 case SIOCGIWRANGE:
3348
3349 {
3350 struct iw_range range;
3351
3352 rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
3353 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
3354 rc = -EFAULT;
3355 }
3356
3357 break;
3358
3359 case SIOCGIWPOWER:
3360
3361 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
3362 break;
3363
3364
3365 case SIOCSIWPOWER:
3366
3367 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
3368 break;
3369
3370
3371 case SIOCGIWSENS:
3372
3373 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
3374 break;
3375
3376 case SIOCSIWSENS:
3377 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
3378 rc = -EOPNOTSUPP;
3379 break;
3380
3381 case SIOCGIWAPLIST:
3382 {
3383 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
3384
3385 if (wrq->u.data.pointer) {
3386 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
3387 if (rc == 0) {
3388 if (copy_to_user(wrq->u.data.pointer,
3389 buffer,
3390 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality)))
3391 ))
3392 rc = -EFAULT;
3393 }
3394 }
3395 }
3396 break;
3397
3398
3399#ifdef WIRELESS_SPY
3400
3401 case SIOCSIWSPY:
3402
3403 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
3404 rc = -EOPNOTSUPP;
3405 break;
3406
3407
3408 case SIOCGIWSPY:
3409
3410 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWSPY \n");
3411 rc = -EOPNOTSUPP;
3412 break;
3413
3414#endif
3415
3416 case SIOCGIWPRIV:
3417 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
3418 rc = -EOPNOTSUPP;
3419
3420
3421
3422
3423
3424
3425
3426
3427
3428
3429 break;
3430
3431
3432
3433#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3434 case SIOCSIWAUTH:
3435 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n");
3436 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
3437 break;
3438
3439 case SIOCGIWAUTH:
3440 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
3441 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
3442 break;
3443
3444 case SIOCSIWGENIE:
3445 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
3446 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3447 break;
3448
3449 case SIOCGIWGENIE:
3450 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
3451 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3452 break;
3453
3454 case SIOCSIWENCODEEXT:
3455 {
3456 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
3457 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
3458 if(wrq->u.encoding.pointer){
3459 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
3460 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
3461 rc = -E2BIG;
3462 break;
3463 }
3464 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
3465 rc = -EFAULT;
3466 break;
3467 }
3468 }else if(wrq->u.encoding.length != 0){
3469 rc = -EINVAL;
3470 break;
3471 }
3472 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
3473 }
3474 break;
3475
3476 case SIOCGIWENCODEEXT:
3477 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
3478 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
3479 break;
3480
3481 case SIOCSIWMLME:
3482 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
3483 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3484 break;
3485
3486#endif
3487
3488
3489 case IOCTL_CMD_TEST:
3490
3491 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
3492 rc = -EFAULT;
3493 break;
3494 } else {
3495 rc = 0;
3496 }
3497 pReq = (PSCmdRequest)rq;
3498 pReq->wResult = MAGIC_CODE;
3499 break;
3500
3501 case IOCTL_CMD_SET:
3502
3503 #ifdef SndEvt_ToAPI
3504 if((((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_EVT) &&
3505 !(pDevice->flags & DEVICE_FLAGS_OPENED))
3506 #else
3507 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
3508 (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
3509 #endif
3510 {
3511 rc = -EFAULT;
3512 break;
3513 } else {
3514 rc = 0;
3515 }
3516
3517 if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
3518 return -EBUSY;
3519 }
3520 rc = private_ioctl(pDevice, rq);
3521 clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
3522 break;
3523
3524 case IOCTL_CMD_HOSTAPD:
3525
3526
3527 rc = vt6655_hostap_ioctl(pDevice, &wrq->u.data);
3528 break;
3529
3530 case IOCTL_CMD_WPA:
3531
3532 rc = wpa_ioctl(pDevice, &wrq->u.data);
3533 break;
3534
3535 case SIOCETHTOOL:
3536 return ethtool_ioctl(dev, (void *) rq->ifr_data);
3537
3538
3539 default:
3540 rc = -EOPNOTSUPP;
3541 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
3542
3543
3544 }
3545
3546 if (pDevice->bCommit) {
3547 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
3548 netif_stop_queue(pDevice->dev);
3549 spin_lock_irq(&pDevice->lock);
3550 bScheduleCommand((void *)pDevice, WLAN_CMD_RUN_AP, NULL);
3551 spin_unlock_irq(&pDevice->lock);
3552 }
3553 else {
3554 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
3555 spin_lock_irq(&pDevice->lock);
3556 pDevice->bLinkPass = false;
3557 memset(pMgmt->abyCurrBSSID, 0, 6);
3558 pMgmt->eCurrState = WMAC_STATE_IDLE;
3559 netif_stop_queue(pDevice->dev);
3560 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3561 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
3562 if(pDevice->bWPASuppWextEnabled !=true)
3563 #endif
3564 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID);
3565 bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL);
3566 spin_unlock_irq(&pDevice->lock);
3567 }
3568 pDevice->bCommit = false;
3569 }
3570
3571 return rc;
3572}
3573
3574
3575static int ethtool_ioctl(struct net_device *dev, void *useraddr)
3576{
3577 u32 ethcmd;
3578
3579 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd)))
3580 return -EFAULT;
3581
3582 switch (ethcmd) {
3583 case ETHTOOL_GDRVINFO: {
3584 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
3585 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
3586 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
3587 if (copy_to_user(useraddr, &info, sizeof(info)))
3588 return -EFAULT;
3589 return 0;
3590 }
3591
3592 }
3593
3594 return -EOPNOTSUPP;
3595}
3596
3597
3598
3599MODULE_DEVICE_TABLE(pci, vt6655_pci_id_table);
3600
3601static struct pci_driver device_driver = {
3602 .name = DEVICE_NAME,
3603 .id_table = vt6655_pci_id_table,
3604 .probe = vt6655_probe,
3605 .remove = vt6655_remove,
3606#ifdef CONFIG_PM
3607 .suspend = viawget_suspend,
3608 .resume = viawget_resume,
3609#endif
3610};
3611
3612static int __init vt6655_init_module(void)
3613{
3614 int ret;
3615
3616
3617
3618
3619 ret = pci_register_driver(&device_driver);
3620#ifdef CONFIG_PM
3621 if(ret >= 0)
3622 register_reboot_notifier(&device_notifier);
3623#endif
3624
3625 return ret;
3626}
3627
3628static void __exit vt6655_cleanup_module(void)
3629{
3630
3631
3632#ifdef CONFIG_PM
3633 unregister_reboot_notifier(&device_notifier);
3634#endif
3635 pci_unregister_driver(&device_driver);
3636
3637}
3638
3639module_init(vt6655_init_module);
3640module_exit(vt6655_cleanup_module);
3641
3642
3643#ifdef CONFIG_PM
3644static int
3645device_notify_reboot(struct notifier_block *nb, unsigned long event, void *p)
3646{
3647 struct pci_dev *pdev = NULL;
3648 switch(event) {
3649 case SYS_DOWN:
3650 case SYS_HALT:
3651 case SYS_POWER_OFF:
3652 for_each_pci_dev(pdev) {
3653 if(pci_dev_driver(pdev) == &device_driver) {
3654 if (pci_get_drvdata(pdev))
3655 viawget_suspend(pdev, PMSG_HIBERNATE);
3656 }
3657 }
3658 }
3659 return NOTIFY_DONE;
3660}
3661
3662static int
3663viawget_suspend(struct pci_dev *pcid, pm_message_t state)
3664{
3665 int power_status;
3666
3667 PSDevice pDevice=pci_get_drvdata(pcid);
3668 PSMgmtObject pMgmt = pDevice->pMgmt;
3669
3670 netif_stop_queue(pDevice->dev);
3671 spin_lock_irq(&pDevice->lock);
3672 pci_save_state(pcid);
3673 del_timer(&pDevice->sTimerCommand);
3674 del_timer(&pMgmt->sTimerSecondCallback);
3675 pDevice->cbFreeCmdQueue = CMD_Q_SIZE;
3676 pDevice->uCmdDequeueIdx = 0;
3677 pDevice->uCmdEnqueueIdx = 0;
3678 pDevice->bCmdRunning = false;
3679 MACbShutdown(pDevice->PortOffset);
3680 MACvSaveContext(pDevice->PortOffset, pDevice->abyMacContext);
3681 pDevice->bLinkPass = false;
3682 memset(pMgmt->abyCurrBSSID, 0, 6);
3683 pMgmt->eCurrState = WMAC_STATE_IDLE;
3684 pci_disable_device(pcid);
3685 power_status = pci_set_power_state(pcid, pci_choose_state(pcid, state));
3686 spin_unlock_irq(&pDevice->lock);
3687 return 0;
3688}
3689
3690static int
3691viawget_resume(struct pci_dev *pcid)
3692{
3693 PSDevice pDevice=pci_get_drvdata(pcid);
3694 PSMgmtObject pMgmt = pDevice->pMgmt;
3695 int power_status;
3696
3697
3698 power_status = pci_set_power_state(pcid, 0);
3699 power_status = pci_enable_wake(pcid, 0, 0);
3700 pci_restore_state(pcid);
3701 if (netif_running(pDevice->dev)) {
3702 spin_lock_irq(&pDevice->lock);
3703 MACvRestoreContext(pDevice->PortOffset, pDevice->abyMacContext);
3704 device_init_registers(pDevice, DEVICE_INIT_DXPL);
3705 if (pMgmt->sNodeDBTable[0].bActive == true) {
3706 pMgmt->sNodeDBTable[0].bActive = false;
3707 pDevice->bLinkPass = false;
3708 if(pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
3709
3710 pMgmt->eCurrState = WMAC_STATE_STARTED;
3711 }
3712 else {
3713 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
3714 pMgmt->eCurrState = WMAC_STATE_IDLE;
3715 }
3716 }
3717 init_timer(&pMgmt->sTimerSecondCallback);
3718 init_timer(&pDevice->sTimerCommand);
3719 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
3720 BSSvClearBSSList((void *)pDevice, pDevice->bLinkPass);
3721 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
3722 bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL);
3723 spin_unlock_irq(&pDevice->lock);
3724 }
3725 return 0;
3726}
3727
3728#endif
3729
3730
3731
3732
3733