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