Gitiles
Code Review Sign In
gerrit-public.fairphone.software / kernel / msm-4.9 / 756f94e6386519696455a3b1a15f3d451bcf73c7 / . / drivers / staging / vt6655 / device_main.c
blob: d8f7f4f7bac417bc7a0918961e0f06eea31e8a0e [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)
1000 dev = alloc_etherdev(0);
1001#else
1002 dev = init_etherdev(dev, 0);
1003#endif
1004
1005 if (dev == NULL) {
1006 printk(KERN_ERR DEVICE_NAME ": allocate net device failed \n");
1007 return -ENODEV;
1008 }
1009
1010#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
1011 // Chain it all together
1012 // SET_MODULE_OWNER(dev);
1013 SET_NETDEV_DEV(dev, &pcid->dev);
1014#endif
1015
1016 if (bFirst) {
1017 printk(KERN_NOTICE "%s Ver. %s\n",DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
1018 printk(KERN_NOTICE "Copyright (c) 2003 VIA Networking Technologies, Inc.\n");
1019 bFirst=FALSE;
1020 }
1021
1022 if (!device_init_info(pcid, &pDevice, pChip_info)) {
1023 return -ENOMEM;
1024 }
1025 pDevice->dev = dev;
1026 pDevice->next_module = root_device_dev;
1027 root_device_dev = dev;
1028 dev->priv = pDevice;
1029 dev->irq = pcid->irq;
1030
1031 if (pci_enable_device(pcid)) {
1032 device_free_info(pDevice);
1033 return -ENODEV;
1034 }
1035#ifdef DEBUG
1036 printk("Before get pci_info memaddr is %x\n",pDevice->memaddr);
1037#endif
1038 if (device_get_pci_info(pDevice,pcid) == FALSE) {
1039 printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device.\n");
1040 device_free_info(pDevice);
1041 return -ENODEV;
1042 }
1043
1044#if 1
1045
1046#ifdef DEBUG
1047
1048 //pci_read_config_byte(pcid, PCI_BASE_ADDRESS_0, &pDevice->byRevId);
1049 printk("after get pci_info memaddr is %x, io addr is %x,io_size is %d\n",pDevice->memaddr,pDevice->ioaddr,pDevice->io_size);
1050 {
1051 int i;
1052 U32 bar,len;
1053 u32 address[] = {
1054 PCI_BASE_ADDRESS_0,
1055 PCI_BASE_ADDRESS_1,
1056 PCI_BASE_ADDRESS_2,
1057 PCI_BASE_ADDRESS_3,
1058 PCI_BASE_ADDRESS_4,
1059 PCI_BASE_ADDRESS_5,
1060 0};
1061 for (i=0;address[i];i++)
1062 {
1063 //pci_write_config_dword(pcid,address[i], 0xFFFFFFFF);
1064 pci_read_config_dword(pcid, address[i], &bar);
1065 printk("bar %d is %x\n",i,bar);
1066 if (!bar)
1067 {
1068 printk("bar %d not implemented\n",i);
1069 continue;
1070 }
1071 if (bar & PCI_BASE_ADDRESS_SPACE_IO) {
1072 /* This is IO */
1073
1074 len = bar & (PCI_BASE_ADDRESS_IO_MASK & 0xFFFF);
1075 len = len & ~(len - 1);
1076
1077 printk("IO space: len in IO %x, BAR %d\n", len, i);
1078 }
1079 else
1080 {
1081 len = bar & 0xFFFFFFF0;
1082 len = ~len + 1;
1083
1084 printk("len in MEM %x, BAR %d\n", len, i);
1085 }
1086 }
1087 }
1088#endif
1089
1090
1091#endif
1092
1093#ifdef DEBUG
1094 //return 0 ;
1095#endif
1096 pDevice->PortOffset = (DWORD)ioremap(pDevice->memaddr & PCI_BASE_ADDRESS_MEM_MASK, pDevice->io_size);
1097 //pDevice->PortOffset = (DWORD)ioremap(pDevice->ioaddr & PCI_BASE_ADDRESS_IO_MASK, pDevice->io_size);
1098
1099 if(pDevice->PortOffset == 0) {
1100 printk(KERN_ERR DEVICE_NAME ": Failed to IO remapping ..\n");
1101 device_free_info(pDevice);
1102 return -ENODEV;
1103 }
1104
1105
1106
1107
1108#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
1109 rc = pci_request_regions(pcid, DEVICE_NAME);
1110 if (rc) {
1111 printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device\n");
1112 device_free_info(pDevice);
1113 return -ENODEV;
1114 }
1115#else
1116 if (check_region(pDevice->ioaddr, pDevice->io_size)) {
1117 printk(KERN_ERR DEVICE_NAME ": Failed to find PCI device\n");
1118 device_free_info(pDevice);
1119 return -ENODEV;
1120 }
1121 request_region(pDevice->ioaddr, pDevice->io_size, DEVICE_NAME);
1122#endif
1123
1124 dev->base_addr = pDevice->ioaddr;
1125#ifdef PLICE_DEBUG
1126 BYTE value;
1127
1128 VNSvInPortB(pDevice->PortOffset+0x4F, &value);
1129 printk("Before write: value is %x\n",value);
1130 //VNSvInPortB(pDevice->PortOffset+0x3F, 0x00);
1131 VNSvOutPortB(pDevice->PortOffset,value);
1132 VNSvInPortB(pDevice->PortOffset+0x4F, &value);
1133 printk("After write: value is %x\n",value);
1134#endif
1135
1136
1137
1138#ifdef IO_MAP
1139 pDevice->PortOffset = pDevice->ioaddr;
1140#endif
1141 // do reset
1142 if (!MACbSoftwareReset(pDevice->PortOffset)) {
1143 printk(KERN_ERR DEVICE_NAME ": Failed to access MAC hardware..\n");
1144 device_free_info(pDevice);
1145 return -ENODEV;
1146 }
1147 // initial to reload eeprom
1148 MACvInitialize(pDevice->PortOffset);
1149 MACvReadEtherAddress(pDevice->PortOffset, dev->dev_addr);
1150
1151 device_get_options(pDevice, device_nics-1, dev->name);
1152 device_set_options(pDevice);
1153 //Mask out the options cannot be set to the chip
1154 pDevice->sOpts.flags &= pChip_info->flags;
1155
1156 //Enable the chip specified capbilities
1157 pDevice->flags = pDevice->sOpts.flags | (pChip_info->flags & 0xFF000000UL);
1158 pDevice->tx_80211 = device_dma0_tx_80211;
1159 pDevice->sMgmtObj.pAdapter = (PVOID)pDevice;
1160 pDevice->pMgmt = &(pDevice->sMgmtObj);
1161
1162 dev->irq = pcid->irq;
1163 dev->open = device_open;
1164 dev->hard_start_xmit = device_xmit;
1165 dev->stop = device_close;
1166 dev->get_stats = device_get_stats;
1167 dev->set_multicast_list = device_set_multi;
1168 dev->do_ioctl = device_ioctl;
1169
1170#ifdef WIRELESS_EXT
1171//Einsn Modify for ubuntu-7.04
1172// dev->wireless_handlers->get_wireless_stats = iwctl_get_wireless_stats;
1173#if WIRELESS_EXT > 12
1174 dev->wireless_handlers = (struct iw_handler_def *)&iwctl_handler_def;
1175// netdev->wireless_handlers = NULL;
1176#endif /* WIRELESS_EXT > 12 */
1177#endif /* WIRELESS_EXT */
1178
1179 // #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
1180 // memcpy(pDevice->dev->dev_addr, fake_mac, U_ETHER_ADDR_LEN); //use fake mac address
1181 // #endif
1182#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
1183 rc = register_netdev(dev);
1184 if (rc)
1185 {
1186 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
1187 device_free_info(pDevice);
1188 return -ENODEV;
1189 }
1190#endif
1191//2008-07-21-01<Add>by MikeLiu
1192//register wpadev
1193 if(wpa_set_wpadev(pDevice, 1)!=0) {
1194 printk("Fail to Register WPADEV?\n");
1195 unregister_netdev(pDevice->dev);
1196 free_netdev(dev);
1197 kfree(pDevice);
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
1229 *ppDevice = kmalloc(sizeof(DEVICE_INFO),GFP_ATOMIC);
1230
1231 if (*ppDevice == NULL)
1232 return FALSE;
1233
1234 memset(*ppDevice,0,sizeof(DEVICE_INFO));
1235
1236 if (pDevice_Infos == NULL) {
1237 pDevice_Infos =*ppDevice;
1238 }
1239 else {
1240 for (p=pDevice_Infos;p->next!=NULL;p=p->next)
1241 do {} while (0);
1242 p->next = *ppDevice;
1243 (*ppDevice)->prev = p;
1244 }
1245
1246 (*ppDevice)->pcid = pcid;
1247 (*ppDevice)->chip_id = pChip_info->chip_id;
1248 (*ppDevice)->io_size = pChip_info->io_size;
1249 (*ppDevice)->nTxQueues = pChip_info->nTxQueue;
1250 (*ppDevice)->multicast_limit =32;
1251
1252 spin_lock_init(&((*ppDevice)->lock));
1253
1254 return TRUE;
1255}
1256
1257static BOOL device_get_pci_info(PSDevice pDevice, struct pci_dev* pcid) {
1258
1259 U16 pci_cmd;
1260 U8 b;
1261 UINT cis_addr;
1262#ifdef PLICE_DEBUG
1263 BYTE pci_config[256];
1264 BYTE value =0x00;
1265 int ii,j;
1266 U16 max_lat=0x0000;
1267 memset(pci_config,0x00,256);
1268#endif
1269
1270 pci_read_config_byte(pcid, PCI_REVISION_ID, &pDevice->byRevId);
1271 pci_read_config_word(pcid, PCI_SUBSYSTEM_ID,&pDevice->SubSystemID);
1272 pci_read_config_word(pcid, PCI_SUBSYSTEM_VENDOR_ID, &pDevice->SubVendorID);
1273 pci_read_config_word(pcid, PCI_COMMAND, (u16 *) & (pci_cmd));
1274
1275 pci_set_master(pcid);
1276
1277 pDevice->memaddr = pci_resource_start(pcid,0);
1278 pDevice->ioaddr = pci_resource_start(pcid,1);
1279
1280#ifdef DEBUG
1281// pDevice->ioaddr = pci_resource_start(pcid, 0);
1282// pDevice->memaddr = pci_resource_start(pcid,1);
1283#endif
1284
1285 cis_addr = pci_resource_start(pcid,2);
1286
1287 pDevice->pcid = pcid;
1288
1289 pci_read_config_byte(pcid, PCI_REG_COMMAND, &b);
1290 pci_write_config_byte(pcid, PCI_REG_COMMAND, (b|COMMAND_BUSM));
1291
1292#ifdef PLICE_DEBUG
1293 //pci_read_config_word(pcid,PCI_REG_MAX_LAT,&max_lat);
1294 //printk("max lat is %x,SubSystemID is %x\n",max_lat,pDevice->SubSystemID);
1295 //for (ii=0;ii<0xFF;ii++)
1296 //pci_read_config_word(pcid,PCI_REG_MAX_LAT,&max_lat);
1297 //max_lat = 0x20;
1298 //pci_write_config_word(pcid,PCI_REG_MAX_LAT,max_lat);
1299 //pci_read_config_word(pcid,PCI_REG_MAX_LAT,&max_lat);
1300 //printk("max lat is %x\n",max_lat);
1301
1302 for (ii=0;ii<0xFF;ii++)
1303 {
1304 pci_read_config_byte(pcid,ii,&value);
1305 pci_config[ii] = value;
1306 }
1307 for (ii=0,j=1;ii<0x100;ii++,j++)
1308 {
1309 if (j %16 == 0)
1310 {
1311 printk("%x:",pci_config[ii]);
1312 printk("\n");
1313 }
1314 else
1315 {
1316 printk("%x:",pci_config[ii]);
1317 }
1318 }
1319#endif
1320 return TRUE;
1321}
1322
1323static void device_free_info(PSDevice pDevice) {
1324 PSDevice ptr;
1325 struct net_device* dev=pDevice->dev;
1326
1327 ASSERT(pDevice);
1328//2008-0714-01<Add>by chester
1329device_release_WPADEV(pDevice);
1330
1331//2008-07-21-01<Add>by MikeLiu
1332//unregister wpadev
1333 if(wpa_set_wpadev(pDevice, 0)!=0)
1334 printk("unregister wpadev fail?\n");
1335
1336 if (pDevice_Infos==NULL)
1337 return;
1338
1339 for (ptr=pDevice_Infos;ptr && (ptr!=pDevice);ptr=ptr->next)
1340 do {} while (0);
1341
1342 if (ptr==pDevice) {
1343 if (ptr==pDevice_Infos)
1344 pDevice_Infos=ptr->next;
1345 else
1346 ptr->prev->next=ptr->next;
1347 }
1348 else {
1349 DEVICE_PRT(MSG_LEVEL_ERR, KERN_ERR "info struct not found\n");
1350 return;
1351 }
1352#ifdef HOSTAP
1353 if (dev)
1354 hostap_set_hostapd(pDevice, 0, 0);
1355#endif
1356 if (dev)
1357 unregister_netdev(dev);
1358
1359 if (pDevice->PortOffset)
1360 iounmap((PVOID)pDevice->PortOffset);
1361
1362#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
1363 if (pDevice->pcid)
1364 pci_release_regions(pDevice->pcid);
1365 if (dev)
1366 free_netdev(dev);
1367#else
1368 if (pDevice->ioaddr)
1369 release_region(pDevice->ioaddr,pDevice->io_size);
1370 if (dev)
1371 kfree(dev);
1372#endif
1373
1374 if (pDevice->pcid) {
1375 pci_set_drvdata(pDevice->pcid,NULL);
1376 }
1377 kfree(pDevice);
1378
1379}
1380#endif// ifndef PRIVATE_OBJ
1381
1382static BOOL device_init_rings(PSDevice pDevice) {
1383 void* vir_pool;
1384
1385
1386 /*allocate all RD/TD rings a single pool*/
1387 vir_pool = pci_alloc_consistent(pDevice->pcid,
1388 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1389 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1390 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1391 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc),
1392 &pDevice->pool_dma);
1393
1394 if (vir_pool == NULL) {
1395 DEVICE_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate desc dma memory failed\n", pDevice->dev->name);
1396 return FALSE;
1397 }
1398
1399 memset(vir_pool, 0,
1400 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1401 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1402 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1403 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc)
1404 );
1405
1406 pDevice->aRD0Ring = vir_pool;
1407 pDevice->aRD1Ring = vir_pool +
1408 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1409
1410
1411 pDevice->rd0_pool_dma = pDevice->pool_dma;
1412 pDevice->rd1_pool_dma = pDevice->rd0_pool_dma +
1413 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc);
1414
1415 pDevice->tx0_bufs = pci_alloc_consistent(pDevice->pcid,
1416 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1417 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1418 CB_BEACON_BUF_SIZE +
1419 CB_MAX_BUF_SIZE,
1420 &pDevice->tx_bufs_dma0);
1421
1422 if (pDevice->tx0_bufs == NULL) {
1423 DEVICE_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: allocate buf dma memory failed\n", pDevice->dev->name);
1424 pci_free_consistent(pDevice->pcid,
1425 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1426 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1427 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1428 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc),
1429 vir_pool, pDevice->pool_dma
1430 );
1431 return FALSE;
1432 }
1433
1434 memset(pDevice->tx0_bufs, 0,
1435 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1436 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1437 CB_BEACON_BUF_SIZE +
1438 CB_MAX_BUF_SIZE
1439 );
1440
1441 pDevice->td0_pool_dma = pDevice->rd1_pool_dma +
1442 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1443
1444 pDevice->td1_pool_dma = pDevice->td0_pool_dma +
1445 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1446
1447
1448 // vir_pool: pvoid type
1449 pDevice->apTD0Rings = vir_pool
1450 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1451 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc);
1452
1453 pDevice->apTD1Rings = vir_pool
1454 + pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc)
1455 + pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc)
1456 + pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc);
1457
1458
1459 pDevice->tx1_bufs = pDevice->tx0_bufs +
1460 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1461
1462
1463 pDevice->tx_beacon_bufs = pDevice->tx1_bufs +
1464 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1465
1466 pDevice->pbyTmpBuff = pDevice->tx_beacon_bufs +
1467 CB_BEACON_BUF_SIZE;
1468
1469 pDevice->tx_bufs_dma1 = pDevice->tx_bufs_dma0 +
1470 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ;
1471
1472
1473 pDevice->tx_beacon_dma = pDevice->tx_bufs_dma1 +
1474 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ;
1475
1476
1477 return TRUE;
1478}
1479
1480static void device_free_rings(PSDevice pDevice) {
1481
1482 pci_free_consistent(pDevice->pcid,
1483 pDevice->sOpts.nRxDescs0 * sizeof(SRxDesc) +
1484 pDevice->sOpts.nRxDescs1 * sizeof(SRxDesc) +
1485 pDevice->sOpts.nTxDescs[0] * sizeof(STxDesc) +
1486 pDevice->sOpts.nTxDescs[1] * sizeof(STxDesc)
1487 ,
1488 pDevice->aRD0Ring, pDevice->pool_dma
1489 );
1490
1491 if (pDevice->tx0_bufs)
1492 pci_free_consistent(pDevice->pcid,
1493 pDevice->sOpts.nTxDescs[0] * PKT_BUF_SZ +
1494 pDevice->sOpts.nTxDescs[1] * PKT_BUF_SZ +
1495 CB_BEACON_BUF_SIZE +
1496 CB_MAX_BUF_SIZE,
1497 pDevice->tx0_bufs, pDevice->tx_bufs_dma0
1498 );
1499}
1500
1501static void device_init_rd0_ring(PSDevice pDevice) {
1502 int i;
1503 dma_addr_t curr = pDevice->rd0_pool_dma;
1504 PSRxDesc pDesc;
1505
1506 /* Init the RD0 ring entries */
1507 for (i = 0; i < pDevice->sOpts.nRxDescs0; i ++, curr += sizeof(SRxDesc)) {
1508 pDesc = &(pDevice->aRD0Ring[i]);
1509 pDesc->pRDInfo = alloc_rd_info();
1510 ASSERT(pDesc->pRDInfo);
1511 if (!device_alloc_rx_buf(pDevice, pDesc)) {
1512 DEVICE_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc rx bufs\n",
1513 pDevice->dev->name);
1514 }
1515 pDesc->next = &(pDevice->aRD0Ring[(i+1) % pDevice->sOpts.nRxDescs0]);
1516 pDesc->pRDInfo->curr_desc = cpu_to_le32(curr);
1517 pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc));
1518 }
1519
1520 pDevice->aRD0Ring[i-1].next_desc = cpu_to_le32(pDevice->rd0_pool_dma);
1521 pDevice->pCurrRD[0] = &(pDevice->aRD0Ring[0]);
1522}
1523
1524
1525static void device_init_rd1_ring(PSDevice pDevice) {
1526 int i;
1527 dma_addr_t curr = pDevice->rd1_pool_dma;
1528 PSRxDesc pDesc;
1529
1530 /* Init the RD1 ring entries */
1531 for (i = 0; i < pDevice->sOpts.nRxDescs1; i ++, curr += sizeof(SRxDesc)) {
1532 pDesc = &(pDevice->aRD1Ring[i]);
1533 pDesc->pRDInfo = alloc_rd_info();
1534 ASSERT(pDesc->pRDInfo);
1535 if (!device_alloc_rx_buf(pDevice, pDesc)) {
1536 DEVICE_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc rx bufs\n",
1537 pDevice->dev->name);
1538 }
1539 pDesc->next = &(pDevice->aRD1Ring[(i+1) % pDevice->sOpts.nRxDescs1]);
1540 pDesc->pRDInfo->curr_desc = cpu_to_le32(curr);
1541 pDesc->next_desc = cpu_to_le32(curr + sizeof(SRxDesc));
1542 }
1543
1544 pDevice->aRD1Ring[i-1].next_desc = cpu_to_le32(pDevice->rd1_pool_dma);
1545 pDevice->pCurrRD[1] = &(pDevice->aRD1Ring[0]);
1546}
1547
1548
1549static void device_init_defrag_cb(PSDevice pDevice) {
1550 int i;
1551 PSDeFragControlBlock pDeF;
1552
1553 /* Init the fragment ctl entries */
1554 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1555 pDeF = &(pDevice->sRxDFCB[i]);
1556 if (!device_alloc_frag_buf(pDevice, pDeF)) {
1557 DEVICE_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
1558 pDevice->dev->name);
1559 };
1560 }
1561 pDevice->cbDFCB = CB_MAX_RX_FRAG;
1562 pDevice->cbFreeDFCB = pDevice->cbDFCB;
1563}
1564
1565
1566
1567
1568static void device_free_rd0_ring(PSDevice pDevice) {
1569 int i;
1570
1571 for (i = 0; i < pDevice->sOpts.nRxDescs0; i++) {
1572 PSRxDesc pDesc =&(pDevice->aRD0Ring[i]);
1573 PDEVICE_RD_INFO pRDInfo =pDesc->pRDInfo;
1574
1575 pci_unmap_single(pDevice->pcid,pRDInfo->skb_dma,
1576 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1577
1578 dev_kfree_skb(pRDInfo->skb);
1579
1580 kfree((PVOID)pDesc->pRDInfo);
1581 }
1582
1583}
1584
1585static void device_free_rd1_ring(PSDevice pDevice) {
1586 int i;
1587
1588
1589 for (i = 0; i < pDevice->sOpts.nRxDescs1; i++) {
1590 PSRxDesc pDesc=&(pDevice->aRD1Ring[i]);
1591 PDEVICE_RD_INFO pRDInfo=pDesc->pRDInfo;
1592
1593 pci_unmap_single(pDevice->pcid,pRDInfo->skb_dma,
1594 pDevice->rx_buf_sz, PCI_DMA_FROMDEVICE);
1595
1596 dev_kfree_skb(pRDInfo->skb);
1597
1598 kfree((PVOID)pDesc->pRDInfo);
1599 }
1600
1601}
1602
1603static void device_free_frag_buf(PSDevice pDevice) {
1604 PSDeFragControlBlock pDeF;
1605 int i;
1606
1607 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1608
1609 pDeF = &(pDevice->sRxDFCB[i]);
1610
1611 if (pDeF->skb)
1612 dev_kfree_skb(pDeF->skb);
1613
1614 }
1615
1616}
1617
1618static void device_init_td0_ring(PSDevice pDevice) {
1619 int i;
1620 dma_addr_t curr;
1621 PSTxDesc pDesc;
1622
1623 curr = pDevice->td0_pool_dma;
1624 for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++, curr += sizeof(STxDesc)) {
1625 pDesc = &(pDevice->apTD0Rings[i]);
1626 pDesc->pTDInfo = alloc_td_info();
1627 ASSERT(pDesc->pTDInfo);
1628 if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) {
1629 pDesc->pTDInfo->buf = pDevice->tx0_bufs + (i)*PKT_BUF_SZ;
1630 pDesc->pTDInfo->buf_dma = pDevice->tx_bufs_dma0 + (i)*PKT_BUF_SZ;
1631 }
1632 pDesc->next =&(pDevice->apTD0Rings[(i+1) % pDevice->sOpts.nTxDescs[0]]);
1633 pDesc->pTDInfo->curr_desc = cpu_to_le32(curr);
1634 pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc));
1635 }
1636
1637 pDevice->apTD0Rings[i-1].next_desc = cpu_to_le32(pDevice->td0_pool_dma);
1638 pDevice->apTailTD[0] = pDevice->apCurrTD[0] =&(pDevice->apTD0Rings[0]);
1639
1640}
1641
1642static void device_init_td1_ring(PSDevice pDevice) {
1643 int i;
1644 dma_addr_t curr;
1645 PSTxDesc pDesc;
1646
1647 /* Init the TD ring entries */
1648 curr=pDevice->td1_pool_dma;
1649 for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++, curr+=sizeof(STxDesc)) {
1650 pDesc=&(pDevice->apTD1Rings[i]);
1651 pDesc->pTDInfo = alloc_td_info();
1652 ASSERT(pDesc->pTDInfo);
1653 if (pDevice->flags & DEVICE_FLAGS_TX_ALIGN) {
1654 pDesc->pTDInfo->buf=pDevice->tx1_bufs+(i)*PKT_BUF_SZ;
1655 pDesc->pTDInfo->buf_dma=pDevice->tx_bufs_dma1+(i)*PKT_BUF_SZ;
1656 }
1657 pDesc->next=&(pDevice->apTD1Rings[(i+1) % pDevice->sOpts.nTxDescs[1]]);
1658 pDesc->pTDInfo->curr_desc = cpu_to_le32(curr);
1659 pDesc->next_desc = cpu_to_le32(curr+sizeof(STxDesc));
1660 }
1661
1662 pDevice->apTD1Rings[i-1].next_desc = cpu_to_le32(pDevice->td1_pool_dma);
1663 pDevice->apTailTD[1] = pDevice->apCurrTD[1] = &(pDevice->apTD1Rings[0]);
1664}
1665
1666
1667
1668static void device_free_td0_ring(PSDevice pDevice) {
1669 int i;
1670 for (i = 0; i < pDevice->sOpts.nTxDescs[0]; i++) {
1671 PSTxDesc pDesc=&(pDevice->apTD0Rings[i]);
1672 PDEVICE_TD_INFO pTDInfo=pDesc->pTDInfo;
1673
1674 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma))
1675 pci_unmap_single(pDevice->pcid,pTDInfo->skb_dma,
1676 pTDInfo->skb->len, PCI_DMA_TODEVICE);
1677
1678 if (pTDInfo->skb)
1679 dev_kfree_skb(pTDInfo->skb);
1680
1681 kfree((PVOID)pDesc->pTDInfo);
1682 }
1683}
1684
1685static void device_free_td1_ring(PSDevice pDevice) {
1686 int i;
1687
1688 for (i = 0; i < pDevice->sOpts.nTxDescs[1]; i++) {
1689 PSTxDesc pDesc=&(pDevice->apTD1Rings[i]);
1690 PDEVICE_TD_INFO pTDInfo=pDesc->pTDInfo;
1691
1692 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma))
1693 pci_unmap_single(pDevice->pcid, pTDInfo->skb_dma,
1694 pTDInfo->skb->len, PCI_DMA_TODEVICE);
1695
1696 if (pTDInfo->skb)
1697 dev_kfree_skb(pTDInfo->skb);
1698
1699 kfree((PVOID)pDesc->pTDInfo);
1700 }
1701
1702}
1703
1704
1705
1706/*-----------------------------------------------------------------*/
1707
1708static int device_rx_srv(PSDevice pDevice, UINT uIdx) {
1709 PSRxDesc pRD;
1710 int works = 0;
1711
1712
1713 for (pRD = pDevice->pCurrRD[uIdx];
1714 pRD->m_rd0RD0.f1Owner == OWNED_BY_HOST;
1715 pRD = pRD->next) {
1716// DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->pCurrRD = %x, works = %d\n", pRD, works);
1717 if (works++>15)
1718 break;
1719 if (device_receive_frame(pDevice, pRD)) {
1720 if (!device_alloc_rx_buf(pDevice,pRD)) {
1721 DEVICE_PRT(MSG_LEVEL_ERR, KERN_ERR
1722 "%s: can not allocate rx buf\n", pDevice->dev->name);
1723 break;
1724 }
1725 }
1726 pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1727#ifdef PRIVATE_OBJ
1728 ref_set_rx_jiffies(pDevice->dev);
1729#else
1730 pDevice->dev->last_rx = jiffies;
1731#endif
1732 }
1733
1734 pDevice->pCurrRD[uIdx]=pRD;
1735
1736 return works;
1737}
1738
1739
1740static BOOL device_alloc_rx_buf(PSDevice pDevice, PSRxDesc pRD) {
1741
1742 PDEVICE_RD_INFO pRDInfo=pRD->pRDInfo;
1743
1744#ifdef PRIVATE_OBJ
1745
1746 pRDInfo->skb=dev_alloc_skb(pDevice->rx_buf_sz);
1747 if (pRDInfo->skb==NULL)
1748 return FALSE;
1749 ref_skb_remap(pDevice->dev, &(pRDInfo->ref_skb), pRDInfo->skb);
1750 pRDInfo->skb_dma = pci_map_single(pDevice->pcid, pRDInfo->ref_skb.tail, pDevice->rx_buf_sz,
1751 PCI_DMA_FROMDEVICE);
1752#else
1753
1754 pRDInfo->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1755#ifdef PLICE_DEBUG
1756 //printk("device_alloc_rx_buf:skb is %x\n",pRDInfo->skb);
1757#endif
1758 if (pRDInfo->skb==NULL)
1759 return FALSE;
1760 ASSERT(pRDInfo->skb);
1761 pRDInfo->skb->dev = pDevice->dev;
1762 pRDInfo->skb_dma = pci_map_single(pDevice->pcid, pRDInfo->skb->tail, pDevice->rx_buf_sz,
1763 PCI_DMA_FROMDEVICE);
1764#endif
1765 *((PU32) &(pRD->m_rd0RD0)) = 0;
1766
1767 pRD->m_rd0RD0.wResCount = cpu_to_le16(pDevice->rx_buf_sz);
1768 pRD->m_rd0RD0.f1Owner = OWNED_BY_NIC;
1769 pRD->m_rd1RD1.wReqCount = cpu_to_le16(pDevice->rx_buf_sz);
1770 pRD->buff_addr = cpu_to_le32(pRDInfo->skb_dma);
1771
1772 return TRUE;
1773}
1774
1775
1776
1777BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1778
1779#ifdef PRIVATE_OBJ
1780
1781 pDeF->skb=dev_alloc_skb(pDevice->rx_buf_sz);
1782 if (pDeF->skb==NULL)
1783 return FALSE;
1784 ref_skb_remap(pDevice->dev, &(pDeF->ref_skb), pDeF->skb);
1785
1786#else
1787 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1788 if (pDeF->skb == NULL)
1789 return FALSE;
1790 ASSERT(pDeF->skb);
1791 pDeF->skb->dev = pDevice->dev;
1792#endif
1793
1794 return TRUE;
1795}
1796
1797
1798
1799static int device_tx_srv(PSDevice pDevice, UINT uIdx) {
1800 PSTxDesc pTD;
1801 BOOL bFull=FALSE;
1802 int works = 0;
1803 BYTE byTsr0;
1804 BYTE byTsr1;
1805 UINT uFrameSize, uFIFOHeaderSize;
1806 PSTxBufHead pTxBufHead;
1807 struct net_device_stats* pStats = &pDevice->stats;
1808 struct sk_buff* skb;
1809 UINT uNodeIndex;
1810 PSMgmtObject pMgmt = pDevice->pMgmt;
1811#ifdef PRIVATE_OBJ
1812 ref_sk_buff ref_skb;
1813#endif
1814
1815
1816 for (pTD = pDevice->apTailTD[uIdx]; pDevice->iTDUsed[uIdx] >0; pTD = pTD->next) {
1817
1818 if (pTD->m_td0TD0.f1Owner == OWNED_BY_NIC)
1819 break;
1820 if (works++>15)
1821 break;
1822
1823 byTsr0 = pTD->m_td0TD0.byTSR0;
1824 byTsr1 = pTD->m_td0TD0.byTSR1;
1825
1826 //Only the status of first TD in the chain is correct
1827 if (pTD->m_td1TD1.byTCR & TCR_STP) {
1828
1829 if ((pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0) {
1830 uFIFOHeaderSize = pTD->pTDInfo->dwHeaderLength;
1831 uFrameSize = pTD->pTDInfo->dwReqCount - uFIFOHeaderSize;
1832 pTxBufHead = (PSTxBufHead) (pTD->pTDInfo->buf);
1833#ifdef PRIVATE_OBJ
1834 ref_skb_remap(pDevice->dev, &ref_skb, pTD->pTDInfo->skb);
1835#endif
1836 // Update the statistics based on the Transmit status
1837 // now, we DO'NT check TSR0_CDH
1838
1839 STAvUpdateTDStatCounter(&pDevice->scStatistic,
1840 byTsr0, byTsr1,
1841 (PBYTE)(pTD->pTDInfo->buf + uFIFOHeaderSize),
1842 uFrameSize, uIdx);
1843
1844
1845 BSSvUpdateNodeTxCounter(pDevice,
1846 byTsr0, byTsr1,
1847 (PBYTE)(pTD->pTDInfo->buf),
1848 uFIFOHeaderSize
1849 );
1850
1851 if (BITbIsBitOff(byTsr1, TSR1_TERR)) {
1852 if (byTsr0 != 0) {
1853 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] OK but has error. tsr1[%02X] tsr0[%02X].\n",
1854 (INT)uIdx, byTsr1, byTsr0);
1855 }
1856 if ((pTxBufHead->wFragCtl & FRAGCTL_ENDFRAG) != FRAGCTL_NONFRAG) {
1857 pDevice->s802_11Counter.TransmittedFragmentCount ++;
1858 }
1859 pStats->tx_packets++;
1860#ifdef PRIVATE_OBJ
1861 pStats->tx_bytes += *(ref_skb.len);
1862#else
1863 pStats->tx_bytes += pTD->pTDInfo->skb->len;
1864#endif
1865 }
1866 else {
1867 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] dropped & tsr1[%02X] tsr0[%02X].\n",
1868 (INT)uIdx, byTsr1, byTsr0);
1869 pStats->tx_errors++;
1870 pStats->tx_dropped++;
1871 }
1872 }
1873
1874 if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
1875 if (pDevice->bEnableHostapd) {
1876 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx call back netif.. \n");
1877#ifdef PRIVATE_OBJ
1878 ref_skb_remap(pDevice->apdev, &(ref_skb), pTD->pTDInfo->skb);
1879 ref_skb.mac.raw = ref_skb.data;
1880 *(ref_skb.pkt_type) = PACKET_OTHERHOST;
1881 //*(ref_skb.protocol) = htons(ETH_P_802_2);
1882 memset(ref_skb.cb, 0, sizeof(ref_skb.cb));
1883 netif_rx(ref_skb.skb);
1884#else
1885 skb = pTD->pTDInfo->skb;
1886 skb->dev = pDevice->apdev;
1887#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
1888 skb->mac_header = skb->data;
1889#else
1890 skb->mac.raw = skb->data;
1891#endif
1892 skb->pkt_type = PACKET_OTHERHOST;
1893 //skb->protocol = htons(ETH_P_802_2);
1894 memset(skb->cb, 0, sizeof(skb->cb));
1895 netif_rx(skb);
1896#endif
1897 }
1898 }
1899
1900 if (BITbIsBitOn(byTsr1, TSR1_TERR)) {
1901 if ((pTD->pTDInfo->byFlags & TD_FLAGS_PRIV_SKB) != 0) {
1902 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
1903 (INT)uIdx, byTsr1, byTsr0);
1904 }
1905
1906// DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Tx[%d] fail has error. tsr1[%02X] tsr0[%02X].\n",
1907// (INT)uIdx, byTsr1, byTsr0);
1908
1909 if ((pMgmt->eCurrMode == WMAC_MODE_ESS_AP) &&
1910 (pTD->pTDInfo->byFlags & TD_FLAGS_NETIF_SKB)) {
1911 WORD wAID;
1912 BYTE byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
1913
1914 skb = pTD->pTDInfo->skb;
1915 if (BSSDBbIsSTAInNodeDB(pMgmt, (PBYTE)(skb->data), &uNodeIndex)) {
1916 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
1917 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
1918 pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
1919 // set tx map
1920 wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
1921 pMgmt->abyPSTxMap[wAID >> 3] |= byMask[wAID & 7];
1922 pTD->pTDInfo->byFlags &= ~(TD_FLAGS_NETIF_SKB);
1923 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "tx_srv:tx fail re-queue sta index= %d, QueCnt= %d\n"
1924 ,(INT)uNodeIndex, pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt);
1925 pStats->tx_errors--;
1926 pStats->tx_dropped--;
1927 }
1928 }
1929 }
1930 }
1931 device_free_tx_buf(pDevice,pTD);
1932 pDevice->iTDUsed[uIdx]--;
1933 }
1934 }
1935
1936
1937 if (uIdx == TYPE_AC0DMA) {
1938 // RESERV_AC0DMA reserved for relay
1939
1940 if (AVAIL_TD(pDevice, uIdx) < RESERV_AC0DMA) {
1941 bFull = TRUE;
1942 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " AC0DMA is Full = %d\n", pDevice->iTDUsed[uIdx]);
1943 }
1944 if (netif_queue_stopped(pDevice->dev) && (bFull==FALSE)){
1945 netif_wake_queue(pDevice->dev);
1946 }
1947 }
1948
1949
1950 pDevice->apTailTD[uIdx] = pTD;
1951
1952 return works;
1953}
1954
1955
1956static void device_error(PSDevice pDevice, WORD status) {
1957
1958 if (status & ISR_FETALERR) {
1959 DEVICE_PRT(MSG_LEVEL_ERR, KERN_ERR
1960 "%s: Hardware fatal error.\n",
1961 pDevice->dev->name);
1962 netif_stop_queue(pDevice->dev);
1963 del_timer(&pDevice->sTimerCommand);
1964 del_timer(&(pDevice->pMgmt->sTimerSecondCallback));
1965 pDevice->bCmdRunning = FALSE;
1966 MACbShutdown(pDevice->PortOffset);
1967 return;
1968 }
1969
1970}
1971
1972static void device_free_tx_buf(PSDevice pDevice, PSTxDesc pDesc) {
1973 PDEVICE_TD_INFO pTDInfo=pDesc->pTDInfo;
1974 struct sk_buff* skb=pTDInfo->skb;
1975
1976 // pre-allocated buf_dma can't be unmapped.
1977 if (pTDInfo->skb_dma && (pTDInfo->skb_dma != pTDInfo->buf_dma)) {
1978 pci_unmap_single(pDevice->pcid,pTDInfo->skb_dma,skb->len,
1979 PCI_DMA_TODEVICE);
1980 }
1981
1982 if ((pTDInfo->byFlags & TD_FLAGS_NETIF_SKB) != 0)
1983 dev_kfree_skb_irq(skb);
1984
1985 pTDInfo->skb_dma = 0;
1986 pTDInfo->skb = 0;
1987 pTDInfo->byFlags = 0;
1988}
1989
1990
1991
1992//PLICE_DEBUG ->
1993VOID InitRxManagementQueue(PSDevice pDevice)
1994{
1995 pDevice->rxManeQueue.packet_num = 0;
1996 pDevice->rxManeQueue.head = pDevice->rxManeQueue.tail = 0;
1997}
1998//PLICE_DEBUG<-
1999
2000
2001
2002
2003
2004//PLICE_DEBUG ->
2005INT MlmeThread(
2006 void * Context)
2007{
2008 PSDevice pDevice = (PSDevice) Context;
2009 PSRxMgmtPacket pRxMgmtPacket;
2010 // int i ;
2011 //complete(&pDevice->notify);
2012//printk("Enter MngWorkItem,Queue packet num is %d\n",pDevice->rxManeQueue.packet_num);
2013
2014 //printk("Enter MlmeThread,packet _num is %d\n",pDevice->rxManeQueue.packet_num);
2015 //i = 0;
2016#if 1
2017 while (1)
2018 {
2019
2020 //printk("DDDD\n");
2021 //down(&pDevice->mlme_semaphore);
2022 // pRxMgmtPacket = DeQueue(pDevice);
2023#if 1
2024 spin_lock_irq(&pDevice->lock);
2025 while(pDevice->rxManeQueue.packet_num != 0)
2026 {
2027 pRxMgmtPacket = DeQueue(pDevice);
2028 //pDevice;
2029 //DequeueManageObject(pDevice->FirstRecvMngList, pDevice->LastRecvMngList);
2030 vMgrRxManagePacket(pDevice, pDevice->pMgmt, pRxMgmtPacket);
2031 //printk("packet_num is %d\n",pDevice->rxManeQueue.packet_num);
2032
2033 }
2034 spin_unlock_irq(&pDevice->lock);
2035 if (mlme_kill == 0)
2036 break;
2037 //udelay(200);
2038#endif
2039 //printk("Before schedule thread jiffies is %x\n",jiffies);
2040 schedule();
2041 //printk("after schedule thread jiffies is %x\n",jiffies);
2042 if (mlme_kill == 0)
2043 break;
2044 //printk("i is %d\n",i);
2045 }
2046
2047#endif
2048 return 0;
2049
2050}
2051
2052
2053#ifdef PRIVATE_OBJ
2054
2055int __device_open(HANDLE pExDevice) {
2056 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
2057 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
2058
2059#else
2060
2061static int device_open(struct net_device *dev) {
2062 PSDevice pDevice=(PSDevice) dev->priv;
2063 int i;
2064#endif
2065 pDevice->rx_buf_sz = PKT_BUF_SZ;
2066 if (!device_init_rings(pDevice)) {
2067 return -ENOMEM;
2068 }
2069//2008-5-13 <add> by chester
2070#ifndef PRIVATE_OBJ
2071#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,16)
2072 i=request_irq(pDevice->pcid->irq, &device_intr, IRQF_SHARED, dev->name, dev);
2073#else
2074 i=request_irq(pDevice->pcid->irq, &device_intr, (unsigned long)SA_SHIRQ, dev->name, dev);
2075#endif
2076 if (i)
2077 return i;
2078#endif
2079 //printk("DEBUG1\n");
2080#ifdef WPA_SM_Transtatus
2081 extern SWPAResult wpa_Result;
2082 memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
2083 wpa_Result.proto = 0;
2084 wpa_Result.key_mgmt = 0;
2085 wpa_Result.eap_type = 0;
2086 wpa_Result.authenticated = FALSE;
2087 pDevice->fWPA_Authened = FALSE;
2088#endif
2089DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device init rd0 ring\n");
2090device_init_rd0_ring(pDevice);
2091 device_init_rd1_ring(pDevice);
2092 device_init_defrag_cb(pDevice);
2093 device_init_td0_ring(pDevice);
2094 device_init_td1_ring(pDevice);
2095// VNTWIFIvSet11h(pDevice->pMgmt, pDevice->b11hEnable);
2096
2097
2098 if (pDevice->bDiversityRegCtlON) {
2099 device_init_diversity_timer(pDevice);
2100 }
2101 vMgrObjectInit(pDevice);
2102 vMgrTimerInit(pDevice);
2103
2104//PLICE_DEBUG->
2105#ifdef TASK_LET
2106 tasklet_init (&pDevice->RxMngWorkItem,(void *)MngWorkItem,(unsigned long )pDevice);
2107#endif
2108#ifdef THREAD
2109 InitRxManagementQueue(pDevice);
2110 mlme_kill = 0;
2111 mlme_task = kthread_run(MlmeThread,(void *) pDevice, "MLME");
2112 if (IS_ERR(mlme_task)) {
2113 printk("thread create fail\n");
2114 return -1;
2115 }
2116
2117 mlme_kill = 1;
2118#endif
2119
2120
2121
2122#if 0
2123 pDevice->MLMEThr_pid = kernel_thread(MlmeThread, pDevice, CLONE_VM);
2124 if (pDevice->MLMEThr_pid <0 )
2125 {
2126 printk("unable start thread MlmeThread\n");
2127 return -1;
2128 }
2129#endif
2130
2131 //printk("thread id is %d\n",pDevice->MLMEThr_pid);
2132 //printk("Create thread time is %x\n",jiffies);
2133 //wait_for_completion(&pDevice->notify);
2134
2135
2136
2137
2138 // if (( SROMbyReadEmbedded(pDevice->PortOffset, EEP_OFS_RADIOCTL)&0x06)==0x04)
2139 // return -ENOMEM;
2140DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call device_init_registers\n");
2141 device_init_registers(pDevice, DEVICE_INIT_COLD);
2142 MACvReadEtherAddress(pDevice->PortOffset, pDevice->abyCurrentNetAddr);
2143 memcpy(pDevice->pMgmt->abyMACAddr, pDevice->abyCurrentNetAddr, U_ETHER_ADDR_LEN);
2144#ifdef PRIVATE_OBJ
2145 __device_set_multi(pExDevice);
2146#else
2147 device_set_multi(pDevice->dev);
2148#endif
2149
2150 // Init for Key Management
2151 KeyvInitTable(&pDevice->sKey, pDevice->PortOffset);
2152 add_timer(&(pDevice->pMgmt->sTimerSecondCallback));
2153
2154 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2155 /*
2156 pDevice->bwextstep0 = FALSE;
2157 pDevice->bwextstep1 = FALSE;
2158 pDevice->bwextstep2 = FALSE;
2159 pDevice->bwextstep3 = FALSE;
2160 */
2161 pDevice->bwextcount=0;
2162 pDevice->bWPASuppWextEnabled = FALSE;
2163#endif
2164 pDevice->byReAssocCount = 0;
2165 pDevice->bWPADEVUp = FALSE;
2166 // Patch: if WEP key already set by iwconfig but device not yet open
2167 if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
2168 KeybSetDefaultKey(&(pDevice->sKey),
2169 (DWORD)(pDevice->byKeyIndex | (1 << 31)),
2170 pDevice->uKeyLength,
2171 NULL,
2172 pDevice->abyKey,
2173 KEY_CTL_WEP,
2174 pDevice->PortOffset,
2175 pDevice->byLocalID
2176 );
2177 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
2178 }
2179
2180//printk("DEBUG2\n");
2181
2182
2183DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "call MACvIntEnable\n");
2184 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
2185
2186 if (pDevice->pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2187 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL);
2188 }
2189 else {
2190 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
2191 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_SSID, NULL);
2192 }
2193 pDevice->flags |=DEVICE_FLAGS_OPENED;
2194
2195#ifndef PRIVATE_OBJ
2196#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
2197 MOD_INC_USE_COUNT;
2198#endif
2199#endif
2200
2201 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
2202 return 0;
2203}
2204
2205
2206#ifdef PRIVATE_OBJ
2207
2208int __device_close(HANDLE pExDevice) {
2209 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
2210 struct net_device *dev = pDevice_info->dev;
2211 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
2212
2213#else
2214static int device_close(struct net_device *dev) {
2215 PSDevice pDevice=(PSDevice) dev->priv;
2216#endif
2217 PSMgmtObject pMgmt = pDevice->pMgmt;
2218 //PLICE_DEBUG->
2219#ifdef THREAD
2220 mlme_kill = 0;
2221#endif
2222//PLICE_DEBUG<-
2223//2007-1121-02<Add>by EinsnLiu
2224 if (pDevice->bLinkPass) {
2225 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2226 mdelay(30);
2227 }
2228#ifdef TxInSleep
2229 del_timer(&pDevice->sTimerTxData);
2230#endif
2231 del_timer(&pDevice->sTimerCommand);
2232 del_timer(&pMgmt->sTimerSecondCallback);
2233 if (pDevice->bDiversityRegCtlON) {
2234 del_timer(&pDevice->TimerSQ3Tmax1);
2235 del_timer(&pDevice->TimerSQ3Tmax2);
2236 del_timer(&pDevice->TimerSQ3Tmax3);
2237 }
2238
2239#ifdef TASK_LET
2240 tasklet_kill(&pDevice->RxMngWorkItem);
2241#endif
2242 netif_stop_queue(dev);
2243 pDevice->bCmdRunning = FALSE;
2244 MACbShutdown(pDevice->PortOffset);
2245 MACbSoftwareReset(pDevice->PortOffset);
2246 CARDbRadioPowerOff(pDevice);
2247
2248 pDevice->bLinkPass = FALSE;
2249 memset(pMgmt->abyCurrBSSID, 0, 6);
2250 pMgmt->eCurrState = WMAC_STATE_IDLE;
2251 device_free_td0_ring(pDevice);
2252 device_free_td1_ring(pDevice);
2253 device_free_rd0_ring(pDevice);
2254 device_free_rd1_ring(pDevice);
2255 device_free_frag_buf(pDevice);
2256 device_free_rings(pDevice);
2257 BSSvClearNodeDBTable(pDevice, 0);
2258 free_irq(dev->irq, dev);
2259 pDevice->flags &=(~DEVICE_FLAGS_OPENED);
2260 //2008-0714-01<Add>by chester
2261device_release_WPADEV(pDevice);
2262//PLICE_DEBUG->
2263 //tasklet_kill(&pDevice->RxMngWorkItem);
2264//PLICE_DEBUG<-
2265#ifndef PRIVATE_OBJ
2266#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)
2267 MOD_DEC_USE_COUNT;
2268#endif
2269#endif
2270 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close.. \n");
2271 return 0;
2272}
2273
2274#ifdef PRIVATE_OBJ
2275
2276int __device_dma0_tx_80211(HANDLE pExDevice, struct sk_buff *skb) {
2277 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
2278 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
2279 ref_sk_buff ref_skb;
2280
2281#else
2282
2283
2284static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev) {
2285 PSDevice pDevice=dev->priv;
2286#endif
2287 PBYTE pbMPDU;
2288 UINT cbMPDULen = 0;
2289
2290
2291 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211\n");
2292 spin_lock_irq(&pDevice->lock);
2293
2294 if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) {
2295 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211, td0 <=0\n");
2296 dev_kfree_skb_irq(skb);
2297 spin_unlock_irq(&pDevice->lock);
2298 return 0;
2299 }
2300
2301 if (pDevice->bStopTx0Pkt == TRUE) {
2302 dev_kfree_skb_irq(skb);
2303 spin_unlock_irq(&pDevice->lock);
2304 return 0;
2305 };
2306
2307#ifdef PRIVATE_OBJ
2308 ref_skb_remap(pDevice->dev, &ref_skb, skb);
2309 cbMPDULen = *(ref_skb.len);
2310 pbMPDU = ref_skb.data;
2311#else
2312 cbMPDULen = skb->len;
2313 pbMPDU = skb->data;
2314#endif
2315
2316 vDMA0_tx_80211(pDevice, skb, pbMPDU, cbMPDULen);
2317
2318 spin_unlock_irq(&pDevice->lock);
2319
2320 return 0;
2321
2322}
2323
2324
2325
2326BOOL device_dma0_xmit(PSDevice pDevice, struct sk_buff *skb, UINT uNodeIndex) {
2327 PSMgmtObject pMgmt = pDevice->pMgmt;
2328 PSTxDesc pHeadTD, pLastTD;
2329 UINT cbFrameBodySize;
2330 UINT uMACfragNum;
2331 BYTE byPktTyp;
2332 BOOL bNeedEncryption = FALSE;
2333 PSKeyItem pTransmitKey = NULL;
2334 UINT cbHeaderSize;
2335 UINT ii;
2336 SKeyItem STempKey;
2337// BYTE byKeyIndex = 0;
2338#ifdef PRIVATE_OBJ
2339 ref_sk_buff ref_skb;
2340#endif
2341
2342
2343 if (pDevice->bStopTx0Pkt == TRUE) {
2344 dev_kfree_skb_irq(skb);
2345 return FALSE;
2346 };
2347
2348 if (AVAIL_TD(pDevice, TYPE_TXDMA0) <= 0) {
2349 dev_kfree_skb_irq(skb);
2350 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, td0 <=0\n");
2351 return FALSE;
2352 }
2353
2354 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2355 if (pDevice->uAssocCount == 0) {
2356 dev_kfree_skb_irq(skb);
2357 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_xmit, assocCount = 0\n");
2358 return FALSE;
2359 }
2360 }
2361
2362#ifdef PRIVATE_OBJ
2363 ref_skb_remap(pDevice->dev, &(ref_skb), skb);
2364#endif
2365 pHeadTD = pDevice->apCurrTD[TYPE_TXDMA0];
2366
2367 pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
2368
2369#ifdef PRIVATE_OBJ
2370 memcpy(pDevice->sTxEthHeader.abyDstAddr, (PBYTE)(ref_skb.data), U_HEADER_LEN);
2371 cbFrameBodySize = *(ref_skb.len) - U_HEADER_LEN;
2372
2373#else
2374 memcpy(pDevice->sTxEthHeader.abyDstAddr, (PBYTE)(skb->data), U_HEADER_LEN);
2375 cbFrameBodySize = skb->len - U_HEADER_LEN;
2376#endif
2377
2378 // 802.1H
2379 if (ntohs(pDevice->sTxEthHeader.wType) > MAX_DATA_LEN) {
2380 cbFrameBodySize += 8;
2381 }
2382 uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
2383
2384 if ( uMACfragNum > AVAIL_TD(pDevice, TYPE_TXDMA0)) {
2385 dev_kfree_skb_irq(skb);
2386 return FALSE;
2387 }
2388 byPktTyp = (BYTE)pDevice->byPacketType;
2389
2390
2391 if (pDevice->bFixRate) {
2392 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
2393 if (pDevice->uConnectionRate >= RATE_11M) {
2394 pDevice->wCurrentRate = RATE_11M;
2395 } else {
2396 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
2397 }
2398 } else {
2399 if (pDevice->uConnectionRate >= RATE_54M)
2400 pDevice->wCurrentRate = RATE_54M;
2401 else
2402 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
2403 }
2404 }
2405 else {
2406 pDevice->wCurrentRate = pDevice->pMgmt->sNodeDBTable[uNodeIndex].wTxDataRate;
2407 }
2408
2409 //preamble type
2410 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2411 pDevice->byPreambleType = pDevice->byShortPreamble;
2412 }
2413 else {
2414 pDevice->byPreambleType = PREAMBLE_LONG;
2415 }
2416
2417 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate);
2418
2419
2420 if (pDevice->wCurrentRate <= RATE_11M) {
2421 byPktTyp = PK_TYPE_11B;
2422 } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
2423 byPktTyp = PK_TYPE_11A;
2424 } else {
2425 if (pDevice->bProtectMode == TRUE) {
2426 byPktTyp = PK_TYPE_11GB;
2427 } else {
2428 byPktTyp = PK_TYPE_11GA;
2429 }
2430 }
2431
2432 if (pDevice->bEncryptionEnable == TRUE)
2433 bNeedEncryption = TRUE;
2434
2435 if (pDevice->bEnableHostWEP) {
2436 pTransmitKey = &STempKey;
2437 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2438 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2439 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2440 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2441 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2442 memcpy(pTransmitKey->abyKey,
2443 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2444 pTransmitKey->uKeyLength
2445 );
2446 }
2447 vGenerateFIFOHeader(pDevice, byPktTyp, pDevice->pbyTmpBuff, bNeedEncryption,
2448 cbFrameBodySize, TYPE_TXDMA0, pHeadTD,
2449 &pDevice->sTxEthHeader, (PBYTE)skb->data, pTransmitKey, uNodeIndex,
2450 &uMACfragNum,
2451 &cbHeaderSize
2452 );
2453
2454 if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
2455 // Disable PS
2456 MACbPSWakeup(pDevice->PortOffset);
2457 }
2458
2459 pDevice->bPWBitOn = FALSE;
2460
2461 pLastTD = pHeadTD;
2462 for (ii = 0; ii < uMACfragNum; ii++) {
2463 // Poll Transmit the adapter
2464 wmb();
2465 pHeadTD->m_td0TD0.f1Owner=OWNED_BY_NIC;
2466 wmb();
2467 if (ii == (uMACfragNum - 1))
2468 pLastTD = pHeadTD;
2469 pHeadTD = pHeadTD->next;
2470 }
2471
2472 // Save the information needed by the tx interrupt handler
2473 // to complete the Send request
2474 pLastTD->pTDInfo->skb = skb;
2475 pLastTD->pTDInfo->byFlags = 0;
2476 pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
2477
2478 pDevice->apCurrTD[TYPE_TXDMA0] = pHeadTD;
2479
2480 MACvTransmit0(pDevice->PortOffset);
2481
2482
2483 return TRUE;
2484}
2485
2486//TYPE_AC0DMA data tx
2487#ifdef PRIVATE_OBJ
2488
2489int __device_xmit(HANDLE pExDevice, struct sk_buff *skb) {
2490 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
2491 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
2492 struct net_device *dev = pDevice_info->dev;
2493 ref_sk_buff ref_skb;
2494
2495#else
2496static int device_xmit(struct sk_buff *skb, struct net_device *dev) {
2497 PSDevice pDevice=dev->priv;
2498
2499#endif
2500 PSMgmtObject pMgmt = pDevice->pMgmt;
2501 PSTxDesc pHeadTD, pLastTD;
2502 UINT uNodeIndex = 0;
2503 BYTE byMask[8] = {1, 2, 4, 8, 0x10, 0x20, 0x40, 0x80};
2504 WORD wAID;
2505 UINT uMACfragNum = 1;
2506 UINT cbFrameBodySize;
2507 BYTE byPktTyp;
2508 UINT cbHeaderSize;
2509 BOOL bNeedEncryption = FALSE;
2510 PSKeyItem pTransmitKey = NULL;
2511 SKeyItem STempKey;
2512 UINT ii;
2513 BOOL bTKIP_UseGTK = FALSE;
2514 BOOL bNeedDeAuth = FALSE;
2515 PBYTE pbyBSSID;
2516 BOOL bNodeExist = FALSE;
2517
2518
2519
2520 spin_lock_irq(&pDevice->lock);
2521 if (pDevice->bLinkPass == FALSE) {
2522 dev_kfree_skb_irq(skb);
2523 spin_unlock_irq(&pDevice->lock);
2524 return 0;
2525 }
2526
2527 if (pDevice->bStopDataPkt) {
2528 dev_kfree_skb_irq(skb);
2529 spin_unlock_irq(&pDevice->lock);
2530 return 0;
2531 }
2532
2533#ifdef PRIVATE_OBJ
2534 ref_skb_remap(pDevice->dev, &ref_skb, skb);
2535#endif
2536
2537 if (pMgmt->eCurrMode == WMAC_MODE_ESS_AP) {
2538 if (pDevice->uAssocCount == 0) {
2539 dev_kfree_skb_irq(skb);
2540 spin_unlock_irq(&pDevice->lock);
2541 return 0;
2542 }
2543#ifdef PRIVATE_OBJ
2544 if (IS_MULTICAST_ADDRESS((PBYTE)(ref_skb.data))) {
2545#else
2546 if (IS_MULTICAST_ADDRESS((PBYTE)(skb->data))) {
2547#endif
2548 uNodeIndex = 0;
2549 bNodeExist = TRUE;
2550 if (pMgmt->sNodeDBTable[0].bPSEnable) {
2551#ifdef PRIVATE_OBJ
2552 skb_queue_tail(&(pMgmt->sNodeDBTable[0].sTxPSQueue), ref_skb.skb);
2553#else
2554 skb_queue_tail(&(pMgmt->sNodeDBTable[0].sTxPSQueue), skb);
2555#endif
2556 pMgmt->sNodeDBTable[0].wEnQueueCnt++;
2557 // set tx map
2558 pMgmt->abyPSTxMap[0] |= byMask[0];
2559 spin_unlock_irq(&pDevice->lock);
2560 return 0;
2561 }
2562}else {
2563#ifdef PRIVATE_OBJ
2564 if (BSSDBbIsSTAInNodeDB(pMgmt, (PBYTE)(ref_skb.data), &uNodeIndex)) {
2565#else
2566 if (BSSDBbIsSTAInNodeDB(pMgmt, (PBYTE)(skb->data), &uNodeIndex)) {
2567#endif
2568 if (pMgmt->sNodeDBTable[uNodeIndex].bPSEnable) {
2569#ifdef PRIVATE_OBJ
2570 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, ref_skb.skb);
2571#else
2572 skb_queue_tail(&pMgmt->sNodeDBTable[uNodeIndex].sTxPSQueue, skb);
2573#endif
2574 pMgmt->sNodeDBTable[uNodeIndex].wEnQueueCnt++;
2575 // set tx map
2576 wAID = pMgmt->sNodeDBTable[uNodeIndex].wAID;
2577 pMgmt->abyPSTxMap[wAID >> 3] |= byMask[wAID & 7];
2578 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Set:pMgmt->abyPSTxMap[%d]= %d\n",
2579 (wAID >> 3), pMgmt->abyPSTxMap[wAID >> 3]);
2580 spin_unlock_irq(&pDevice->lock);
2581 return 0;
2582 }
2583
2584 if (pMgmt->sNodeDBTable[uNodeIndex].bShortPreamble) {
2585 pDevice->byPreambleType = pDevice->byShortPreamble;
2586
2587 }else {
2588 pDevice->byPreambleType = PREAMBLE_LONG;
2589 }
2590 bNodeExist = TRUE;
2591
2592 }
2593 }
2594
2595 if (bNodeExist == FALSE) {
2596 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Unknown STA not found in node DB \n");
2597 dev_kfree_skb_irq(skb);
2598 spin_unlock_irq(&pDevice->lock);
2599 return 0;
2600 }
2601 }
2602
2603 pHeadTD = pDevice->apCurrTD[TYPE_AC0DMA];
2604
2605 pHeadTD->m_td1TD1.byTCR = (TCR_EDP|TCR_STP);
2606
2607
2608#ifdef PRIVATE_OBJ
2609 memcpy(pDevice->sTxEthHeader.abyDstAddr, (PBYTE)(ref_skb.data), U_HEADER_LEN);
2610 cbFrameBodySize = *(ref_skb.len) - U_HEADER_LEN;
2611#else
2612 memcpy(pDevice->sTxEthHeader.abyDstAddr, (PBYTE)(skb->data), U_HEADER_LEN);
2613 cbFrameBodySize = skb->len - U_HEADER_LEN;
2614#endif
2615 // 802.1H
2616 if (ntohs(pDevice->sTxEthHeader.wType) > MAX_DATA_LEN) {
2617 cbFrameBodySize += 8;
2618 }
2619
2620
2621 if (pDevice->bEncryptionEnable == TRUE) {
2622 bNeedEncryption = TRUE;
2623 // get Transmit key
2624 do {
2625 if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) &&
2626 (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2627 pbyBSSID = pDevice->abyBSSID;
2628 // get pairwise key
2629 if (KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == FALSE) {
2630 // get group key
2631 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == TRUE) {
2632 bTKIP_UseGTK = TRUE;
2633 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2634 break;
2635 }
2636 } else {
2637 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get PTK.\n");
2638 break;
2639 }
2640 }else if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2641
2642 pbyBSSID = pDevice->sTxEthHeader.abyDstAddr; //TO_DS = 0 and FROM_DS = 0 --> 802.11 MAC Address1
2643 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS Serach Key: \n");
2644 for (ii = 0; ii< 6; ii++)
2645 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"%x \n", *(pbyBSSID+ii));
2646 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"\n");
2647
2648 // get pairwise key
2649 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, PAIRWISE_KEY, &pTransmitKey) == TRUE)
2650 break;
2651 }
2652 // get group key
2653 pbyBSSID = pDevice->abyBroadcastAddr;
2654 if(KeybGetTransmitKey(&(pDevice->sKey), pbyBSSID, GROUP_KEY, &pTransmitKey) == FALSE) {
2655 pTransmitKey = NULL;
2656 if (pDevice->pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
2657 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode);
2658 }
2659 else
2660 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"NOT IBSS and KEY is NULL. [%d]\n", pDevice->pMgmt->eCurrMode);
2661 } else {
2662 bTKIP_UseGTK = TRUE;
2663 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"Get GTK.\n");
2664 }
2665 } while(FALSE);
2666 }
2667
2668 if (pDevice->bEnableHostWEP) {
2669 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_DEBUG"acdma0: STA index %d\n", uNodeIndex);
2670 if (pDevice->bEncryptionEnable == TRUE) {
2671 pTransmitKey = &STempKey;
2672 pTransmitKey->byCipherSuite = pMgmt->sNodeDBTable[uNodeIndex].byCipherSuite;
2673 pTransmitKey->dwKeyIndex = pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex;
2674 pTransmitKey->uKeyLength = pMgmt->sNodeDBTable[uNodeIndex].uWepKeyLength;
2675 pTransmitKey->dwTSC47_16 = pMgmt->sNodeDBTable[uNodeIndex].dwTSC47_16;
2676 pTransmitKey->wTSC15_0 = pMgmt->sNodeDBTable[uNodeIndex].wTSC15_0;
2677 memcpy(pTransmitKey->abyKey,
2678 &pMgmt->sNodeDBTable[uNodeIndex].abyWepKey[0],
2679 pTransmitKey->uKeyLength
2680 );
2681 }
2682 }
2683
2684 uMACfragNum = cbGetFragCount(pDevice, pTransmitKey, cbFrameBodySize, &pDevice->sTxEthHeader);
2685
2686 if (uMACfragNum > AVAIL_TD(pDevice, TYPE_AC0DMA)) {
2687 DEVICE_PRT(MSG_LEVEL_ERR, KERN_DEBUG "uMACfragNum > AVAIL_TD(TYPE_AC0DMA) = %d\n", uMACfragNum);
2688 dev_kfree_skb_irq(skb);
2689 spin_unlock_irq(&pDevice->lock);
2690 return 0;
2691 }
2692
2693 if (pTransmitKey != NULL) {
2694 if ((pTransmitKey->byCipherSuite == KEY_CTL_WEP) &&
2695 (pTransmitKey->uKeyLength == WLAN_WEP232_KEYLEN)) {
2696 uMACfragNum = 1; //WEP256 doesn't support fragment
2697 }
2698 }
2699
2700 byPktTyp = (BYTE)pDevice->byPacketType;
2701
2702 if (pDevice->bFixRate) {
2703#ifdef PLICE_DEBUG
2704 printk("Fix Rate: PhyType is %d,ConnectionRate is %d\n",pDevice->eCurrentPHYType,pDevice->uConnectionRate);
2705#endif
2706
2707 if (pDevice->eCurrentPHYType == PHY_TYPE_11B) {
2708 if (pDevice->uConnectionRate >= RATE_11M) {
2709 pDevice->wCurrentRate = RATE_11M;
2710 } else {
2711 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
2712 }
2713 } else {
2714 if ((pDevice->eCurrentPHYType == PHY_TYPE_11A) &&
2715 (pDevice->uConnectionRate <= RATE_6M)) {
2716 pDevice->wCurrentRate = RATE_6M;
2717 } else {
2718 if (pDevice->uConnectionRate >= RATE_54M)
2719 pDevice->wCurrentRate = RATE_54M;
2720 else
2721 pDevice->wCurrentRate = (WORD)pDevice->uConnectionRate;
2722
2723 }
2724 }
2725 pDevice->byACKRate = (BYTE) pDevice->wCurrentRate;
2726 pDevice->byTopCCKBasicRate = RATE_1M;
2727 pDevice->byTopOFDMBasicRate = RATE_6M;
2728 }
2729 else {
2730 //auto rate
2731 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
2732 if (pDevice->eCurrentPHYType != PHY_TYPE_11A) {
2733 pDevice->wCurrentRate = RATE_1M;
2734 pDevice->byACKRate = RATE_1M;
2735 pDevice->byTopCCKBasicRate = RATE_1M;
2736 pDevice->byTopOFDMBasicRate = RATE_6M;
2737 } else {
2738 pDevice->wCurrentRate = RATE_6M;
2739 pDevice->byACKRate = RATE_6M;
2740 pDevice->byTopCCKBasicRate = RATE_1M;
2741 pDevice->byTopOFDMBasicRate = RATE_6M;
2742 }
2743 }
2744 else {
2745 VNTWIFIvGetTxRate( pDevice->pMgmt,
2746 pDevice->sTxEthHeader.abyDstAddr,
2747 &(pDevice->wCurrentRate),
2748 &(pDevice->byACKRate),
2749 &(pDevice->byTopCCKBasicRate),
2750 &(pDevice->byTopOFDMBasicRate));
2751
2752#if 0
2753printk("auto rate:Rate : %d,AckRate:%d,TopCCKRate:%d,TopOFDMRate:%d\n",
2754pDevice->wCurrentRate,pDevice->byACKRate,
2755pDevice->byTopCCKBasicRate,pDevice->byTopOFDMBasicRate);
2756
2757#endif
2758
2759#if 0
2760
2761 pDevice->wCurrentRate = 11;
2762 pDevice->byACKRate = 8;
2763 pDevice->byTopCCKBasicRate = 3;
2764 pDevice->byTopOFDMBasicRate = 8;
2765#endif
2766
2767
2768 }
2769 }
2770
2771// DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0: pDevice->wCurrentRate = %d \n", pDevice->wCurrentRate);
2772
2773 if (pDevice->wCurrentRate <= RATE_11M) {
2774 byPktTyp = PK_TYPE_11B;
2775 } else if (pDevice->eCurrentPHYType == PHY_TYPE_11A) {
2776 byPktTyp = PK_TYPE_11A;
2777 } else {
2778 if (pDevice->bProtectMode == TRUE) {
2779 byPktTyp = PK_TYPE_11GB;
2780 } else {
2781 byPktTyp = PK_TYPE_11GA;
2782 }
2783 }
2784
2785//#ifdef PLICE_DEBUG
2786// printk("FIX RATE:CurrentRate is %d");
2787//#endif
2788
2789 if (bNeedEncryption == TRUE) {
2790 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"ntohs Pkt Type=%04x\n", ntohs(pDevice->sTxEthHeader.wType));
2791 if ((pDevice->sTxEthHeader.wType) == TYPE_PKT_802_1x) {
2792 bNeedEncryption = FALSE;
2793 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Pkt Type=%04x\n", (pDevice->sTxEthHeader.wType));
2794 if ((pDevice->pMgmt->eCurrMode == WMAC_MODE_ESS_STA) && (pDevice->pMgmt->eCurrState == WMAC_STATE_ASSOC)) {
2795 if (pTransmitKey == NULL) {
2796 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Don't Find TX KEY\n");
2797 }
2798 else {
2799 if (bTKIP_UseGTK == TRUE) {
2800 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"error: KEY is GTK!!~~\n");
2801 }
2802 else {
2803 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
2804 bNeedEncryption = TRUE;
2805 }
2806 }
2807 }
2808
2809 if (pDevice->byCntMeasure == 2) {
2810 bNeedDeAuth = TRUE;
2811 pDevice->s802_11Counter.TKIPCounterMeasuresInvoked++;
2812 }
2813
2814 if (pDevice->bEnableHostWEP) {
2815 if ((uNodeIndex != 0) &&
2816 (pMgmt->sNodeDBTable[uNodeIndex].dwKeyIndex & PAIRWISE_KEY)) {
2817 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Find PTK [%lX]\n", pTransmitKey->dwKeyIndex);
2818 bNeedEncryption = TRUE;
2819 }
2820 }
2821 }
2822 else {
2823 if (pTransmitKey == NULL) {
2824 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"return no tx key\n");
2825 dev_kfree_skb_irq(skb);
2826 spin_unlock_irq(&pDevice->lock);
2827 return 0;
2828 }
2829 }
2830 }
2831
2832
2833#ifdef PRIVATE_OBJ
2834 vGenerateFIFOHeader(pDevice, byPktTyp, pDevice->pbyTmpBuff, bNeedEncryption,
2835 cbFrameBodySize, TYPE_AC0DMA, pHeadTD,
2836 &pDevice->sTxEthHeader, (PBYTE)ref_skb.data, pTransmitKey, uNodeIndex,
2837 &uMACfragNum,
2838 &cbHeaderSize
2839 );
2840#else
2841#ifdef PLICE_DEBUG
2842 //if (skb->len == 98)
2843 //{
2844 // printk("ping:len is %d\n");
2845 //}
2846#endif
2847 vGenerateFIFOHeader(pDevice, byPktTyp, pDevice->pbyTmpBuff, bNeedEncryption,
2848 cbFrameBodySize, TYPE_AC0DMA, pHeadTD,
2849 &pDevice->sTxEthHeader, (PBYTE)skb->data, pTransmitKey, uNodeIndex,
2850 &uMACfragNum,
2851 &cbHeaderSize
2852 );
2853#endif
2854
2855 if (MACbIsRegBitsOn(pDevice->PortOffset, MAC_REG_PSCTL, PSCTL_PS)) {
2856 // Disable PS
2857 MACbPSWakeup(pDevice->PortOffset);
2858 }
2859 pDevice->bPWBitOn = FALSE;
2860
2861 pLastTD = pHeadTD;
2862 for (ii = 0; ii < uMACfragNum; ii++) {
2863 // Poll Transmit the adapter
2864 wmb();
2865 pHeadTD->m_td0TD0.f1Owner=OWNED_BY_NIC;
2866 wmb();
2867 if (ii == uMACfragNum - 1)
2868 pLastTD = pHeadTD;
2869 pHeadTD = pHeadTD->next;
2870 }
2871
2872 // Save the information needed by the tx interrupt handler
2873 // to complete the Send request
2874#ifdef PRIVATE_OBJ
2875 pLastTD->pTDInfo->skb = ref_skb.skb;
2876#else
2877 pLastTD->pTDInfo->skb = skb;
2878#endif
2879 pLastTD->pTDInfo->byFlags = 0;
2880 pLastTD->pTDInfo->byFlags |= TD_FLAGS_NETIF_SKB;
2881#ifdef TxInSleep
2882 pDevice->nTxDataTimeCout=0; //2008-8-21 chester <add> for send null packet
2883 #endif
2884 if (AVAIL_TD(pDevice, TYPE_AC0DMA) <= 1) {
2885 netif_stop_queue(dev);
2886 }
2887
2888 pDevice->apCurrTD[TYPE_AC0DMA] = pHeadTD;
2889//#ifdef PLICE_DEBUG
2890 if (pDevice->bFixRate)
2891 {
2892 printk("FixRate:Rate is %d,TxPower is %d\n",pDevice->wCurrentRate,pDevice->byCurPwr);
2893 }
2894 else
2895 {
2896 //printk("Auto Rate:Rate is %d,TxPower is %d\n",pDevice->wCurrentRate,pDevice->byCurPwr);
2897 }
2898//#endif
2899
2900{
2901 BYTE Protocol_Version; //802.1x Authentication
2902 BYTE Packet_Type; //802.1x Authentication
2903 BYTE Descriptor_type;
2904 WORD Key_info;
2905BOOL bTxeapol_key = FALSE;
2906 Protocol_Version = skb->data[U_HEADER_LEN];
2907 Packet_Type = skb->data[U_HEADER_LEN+1];
2908 Descriptor_type = skb->data[U_HEADER_LEN+1+1+2];
2909 Key_info = (skb->data[U_HEADER_LEN+1+1+2+1] << 8)|(skb->data[U_HEADER_LEN+1+1+2+2]);
2910 if (pDevice->sTxEthHeader.wType == TYPE_PKT_802_1x) {
2911 if(((Protocol_Version==1) ||(Protocol_Version==2)) &&
2912 (Packet_Type==3)) { //802.1x OR eapol-key challenge frame transfer
2913 bTxeapol_key = TRUE;
2914 if((Descriptor_type==254)||(Descriptor_type==2)) { //WPA or RSN
2915 if(!(Key_info & BIT3) && //group-key challenge
2916 (Key_info & BIT8) && (Key_info & BIT9)) { //send 2/2 key
2917 pDevice->fWPA_Authened = TRUE;
2918 if(Descriptor_type==254)
2919 printk("WPA ");
2920 else
2921 printk("WPA2 ");
2922 printk("Authentication completed!!\n");
2923 }
2924 }
2925 }
2926 }
2927}
2928
2929 MACvTransmitAC0(pDevice->PortOffset);
2930// DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "acdma0:pDevice->apCurrTD= %p\n", pHeadTD);
2931
2932#ifdef PRIVATE_OBJ
2933 ref_set_tx_jiffies(pDevice->dev);
2934#else
2935 dev->trans_start = jiffies;
2936#endif
2937
2938 spin_unlock_irq(&pDevice->lock);
2939 return 0;
2940
2941}
2942
2943#ifdef PRIVATE_OBJ
2944
2945int __device_intr(int irq, HANDLE pExDevice, struct pt_regs *regs) {
2946 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
2947 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
2948
2949
2950#else
2951static irqreturn_t device_intr(int irq, void *dev_instance) {
2952 struct net_device* dev=dev_instance;
2953 PSDevice pDevice=(PSDevice) dev->priv;
2954#endif
2955
2956 int max_count=0;
2957 DWORD dwMIBCounter=0;
2958 PSMgmtObject pMgmt = pDevice->pMgmt;
2959 BYTE byOrgPageSel=0;
2960 int handled = 0;
2961 BYTE byData = 0;
2962 int ii= 0;
2963// BYTE byRSSI;
2964
2965
2966 MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr);
2967
2968 if (pDevice->dwIsr == 0)
2969 return IRQ_RETVAL(handled);
2970
2971 if (pDevice->dwIsr == 0xffffffff) {
2972 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "dwIsr = 0xffff\n");
2973 return IRQ_RETVAL(handled);
2974 }
2975 /*
2976 // 2008-05-21 <mark> by Richardtai, we can't read RSSI here, because no packet bound with RSSI
2977
2978 if ((BITbIsBitOn(pDevice->dwIsr, ISR_RXDMA0)) &&
2979 (pDevice->byLocalID != REV_ID_VT3253_B0) &&
2980 (pDevice->bBSSIDFilter == TRUE)) {
2981 // update RSSI
2982 //BBbReadEmbeded(pDevice->PortOffset, 0x3E, &byRSSI);
2983 //pDevice->uCurrRSSI = byRSSI;
2984 }
2985 */
2986
2987 handled = 1;
2988 MACvIntDisable(pDevice->PortOffset);
2989 spin_lock_irq(&pDevice->lock);
2990
2991 //Make sure current page is 0
2992 VNSvInPortB(pDevice->PortOffset + MAC_REG_PAGE1SEL, &byOrgPageSel);
2993 if (byOrgPageSel == 1) {
2994 MACvSelectPage0(pDevice->PortOffset);
2995 }
2996 else
2997 byOrgPageSel = 0;
2998
2999 MACvReadMIBCounter(pDevice->PortOffset, &dwMIBCounter);
3000 // TBD....
3001 // Must do this after doing rx/tx, cause ISR bit is slow
3002 // than RD/TD write back
3003 // update ISR counter
3004 STAvUpdate802_11Counter(&pDevice->s802_11Counter, &pDevice->scStatistic , dwMIBCounter);
3005 while (pDevice->dwIsr != 0) {
3006
3007 STAvUpdateIsrStatCounter(&pDevice->scStatistic, pDevice->dwIsr);
3008 MACvWriteISR(pDevice->PortOffset, pDevice->dwIsr);
3009
3010 if (pDevice->dwIsr & ISR_FETALERR){
3011 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " ISR_FETALERR \n");
3012 VNSvOutPortB(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, 0);
3013 VNSvOutPortW(pDevice->PortOffset + MAC_REG_SOFTPWRCTL, SOFTPWRCTL_SWPECTI);
3014 device_error(pDevice, pDevice->dwIsr);
3015 }
3016
3017 if (pDevice->byLocalID > REV_ID_VT3253_B1) {
3018
3019 if (BITbIsBitOn(pDevice->dwIsr, ISR_MEASURESTART)) {
3020 // 802.11h measure start
3021 pDevice->byOrgChannel = pDevice->byCurrentCh;
3022 VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byOrgRCR));
3023 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, (RCR_RXALLTYPE | RCR_UNICAST | RCR_BROADCAST | RCR_MULTICAST | RCR_WPAERR));
3024 MACvSelectPage1(pDevice->PortOffset);
3025 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR0, &(pDevice->dwOrgMAR0));
3026 VNSvInPortD(pDevice->PortOffset + MAC_REG_MAR4, &(pDevice->dwOrgMAR4));
3027 MACvSelectPage0(pDevice->PortOffset);
3028 //xxxx
3029 // WCMDbFlushCommandQueue(pDevice->pMgmt, TRUE);
3030 if (CARDbSetChannel(pDevice, pDevice->pCurrMeasureEID->sReq.byChannel) == TRUE) {
3031 pDevice->bMeasureInProgress = TRUE;
3032 MACvSelectPage1(pDevice->PortOffset);
3033 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_READY);
3034 MACvSelectPage0(pDevice->PortOffset);
3035 pDevice->byBasicMap = 0;
3036 pDevice->byCCAFraction = 0;
3037 for(ii=0;ii<8;ii++) {
3038 pDevice->dwRPIs[ii] = 0;
3039 }
3040 } else {
3041 // can not measure because set channel fail
3042 // WCMDbResetCommandQueue(pDevice->pMgmt);
3043 // clear measure control
3044 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN);
3045 s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_INCAPABLE);
3046 MACvSelectPage1(pDevice->PortOffset);
3047 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
3048 MACvSelectPage0(pDevice->PortOffset);
3049 }
3050 }
3051 if (BITbIsBitOn(pDevice->dwIsr, ISR_MEASUREEND)) {
3052 // 802.11h measure end
3053 pDevice->bMeasureInProgress = FALSE;
3054 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byOrgRCR);
3055 MACvSelectPage1(pDevice->PortOffset);
3056 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, pDevice->dwOrgMAR0);
3057 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR4, pDevice->dwOrgMAR4);
3058 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRBBSTS, &byData);
3059 pDevice->byBasicMap |= (byData >> 4);
3060 VNSvInPortB(pDevice->PortOffset + MAC_REG_CCAFRACTION, &pDevice->byCCAFraction);
3061 VNSvInPortB(pDevice->PortOffset + MAC_REG_MSRCTL, &byData);
3062 // clear measure control
3063 MACvRegBitsOff(pDevice->PortOffset, MAC_REG_MSRCTL, MSRCTL_EN);
3064 MACvSelectPage0(pDevice->PortOffset);
3065 CARDbSetChannel(pDevice, pDevice->byOrgChannel);
3066 // WCMDbResetCommandQueue(pDevice->pMgmt);
3067 MACvSelectPage1(pDevice->PortOffset);
3068 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
3069 MACvSelectPage0(pDevice->PortOffset);
3070 if (BITbIsBitOn(byData, MSRCTL_FINISH)) {
3071 // measure success
3072 s_vCompleteCurrentMeasure(pDevice, 0);
3073 } else {
3074 // can not measure because not ready before end of measure time
3075 s_vCompleteCurrentMeasure(pDevice, MEASURE_MODE_LATE);
3076 }
3077 }
3078 if (BITbIsBitOn(pDevice->dwIsr, ISR_QUIETSTART)) {
3079 do {
3080 ;
3081 } while (CARDbStartQuiet(pDevice) == FALSE);
3082 }
3083 }
3084
3085 if (pDevice->dwIsr & ISR_TBTT) {
3086 if (pDevice->bEnableFirstQuiet == TRUE) {
3087 pDevice->byQuietStartCount--;
3088 if (pDevice->byQuietStartCount == 0) {
3089 pDevice->bEnableFirstQuiet = FALSE;
3090 MACvSelectPage1(pDevice->PortOffset);
3091 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL, (MSRCTL_QUIETTXCHK | MSRCTL_QUIETEN));
3092 MACvSelectPage0(pDevice->PortOffset);
3093 }
3094 }
3095 if ((pDevice->bChannelSwitch == TRUE) &&
3096 (pDevice->eOPMode == OP_MODE_INFRASTRUCTURE)) {
3097 pDevice->byChannelSwitchCount--;
3098 if (pDevice->byChannelSwitchCount == 0) {
3099 pDevice->bChannelSwitch = FALSE;
3100 CARDbSetChannel(pDevice, pDevice->byNewChannel);
3101 VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel);
3102 MACvSelectPage1(pDevice->PortOffset);
3103 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
3104 MACvSelectPage0(pDevice->PortOffset);
3105 CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL);
3106
3107 }
3108 }
3109 if (pDevice->eOPMode == OP_MODE_ADHOC) {
3110 //pDevice->bBeaconSent = FALSE;
3111 } else {
3112 if ((pDevice->bUpdateBBVGA) && (pDevice->bLinkPass == TRUE) && (pDevice->uCurrRSSI != 0)) {
3113 LONG ldBm;
3114
3115 RFvRSSITodBm(pDevice, (BYTE) pDevice->uCurrRSSI, &ldBm);
3116 for (ii=0;ii<BB_VGA_LEVEL;ii++) {
3117 if (ldBm < pDevice->ldBmThreshold[ii]) {
3118 pDevice->byBBVGANew = pDevice->abyBBVGA[ii];
3119 break;
3120 }
3121 }
3122 if (pDevice->byBBVGANew != pDevice->byBBVGACurrent) {
3123 pDevice->uBBVGADiffCount++;
3124 if (pDevice->uBBVGADiffCount == 1) {
3125 // first VGA diff gain
3126 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew);
3127 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"First RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
3128 (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount);
3129 }
3130 if (pDevice->uBBVGADiffCount >= BB_VGA_CHANGE_THRESHOLD) {
3131 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO"RSSI[%d] NewGain[%d] OldGain[%d] Count[%d]\n",
3132 (int)ldBm, pDevice->byBBVGANew, pDevice->byBBVGACurrent, (int)pDevice->uBBVGADiffCount);
3133 BBvSetVGAGainOffset(pDevice, pDevice->byBBVGANew);
3134 }
3135 } else {
3136 pDevice->uBBVGADiffCount = 1;
3137 }
3138 }
3139 }
3140
3141 pDevice->bBeaconSent = FALSE;
3142 if (pDevice->bEnablePSMode) {
3143 PSbIsNextTBTTWakeUp((HANDLE)pDevice);
3144 };
3145
3146 if ((pDevice->eOPMode == OP_MODE_AP) ||
3147 (pDevice->eOPMode == OP_MODE_ADHOC)) {
3148
3149 MACvOneShotTimer1MicroSec(pDevice->PortOffset,
3150 (pMgmt->wIBSSBeaconPeriod - MAKE_BEACON_RESERVED) << 10);
3151 }
3152
3153 if (pDevice->eOPMode == OP_MODE_ADHOC && pDevice->pMgmt->wCurrATIMWindow > 0) {
3154 // todo adhoc PS mode
3155 };
3156
3157 }
3158
3159 if (pDevice->dwIsr & ISR_BNTX) {
3160
3161 if (pDevice->eOPMode == OP_MODE_ADHOC) {
3162 pDevice->bIsBeaconBufReadySet = FALSE;
3163 pDevice->cbBeaconBufReadySetCnt = 0;
3164 };
3165
3166 if (pDevice->eOPMode == OP_MODE_AP) {
3167 if(pMgmt->byDTIMCount > 0) {
3168 pMgmt->byDTIMCount --;
3169 pMgmt->sNodeDBTable[0].bRxPSPoll = FALSE;
3170 }
3171 else {
3172 if(pMgmt->byDTIMCount == 0) {
3173 // check if mutltcast tx bufferring
3174 pMgmt->byDTIMCount = pMgmt->byDTIMPeriod - 1;
3175 pMgmt->sNodeDBTable[0].bRxPSPoll = TRUE;
3176 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RX_PSPOLL, NULL);
3177 }
3178 }
3179 }
3180 pDevice->bBeaconSent = TRUE;
3181
3182 if (pDevice->bChannelSwitch == TRUE) {
3183 pDevice->byChannelSwitchCount--;
3184 if (pDevice->byChannelSwitchCount == 0) {
3185 pDevice->bChannelSwitch = FALSE;
3186 CARDbSetChannel(pDevice, pDevice->byNewChannel);
3187 VNTWIFIbChannelSwitch(pDevice->pMgmt, pDevice->byNewChannel);
3188 MACvSelectPage1(pDevice->PortOffset);
3189 MACvRegBitsOn(pDevice->PortOffset, MAC_REG_MSRCTL+1, MSRCTL1_TXPAUSE);
3190 MACvSelectPage0(pDevice->PortOffset);
3191 //VNTWIFIbSendBeacon(pDevice->pMgmt);
3192 CARDbStartTxPacket(pDevice, PKT_TYPE_802_11_ALL);
3193 }
3194 }
3195
3196 }
3197
3198 if (pDevice->dwIsr & ISR_RXDMA0) {
3199 max_count += device_rx_srv(pDevice, TYPE_RXDMA0);
3200 }
3201 if (pDevice->dwIsr & ISR_RXDMA1) {
3202 max_count += device_rx_srv(pDevice, TYPE_RXDMA1);
3203 }
3204 if (pDevice->dwIsr & ISR_TXDMA0){
3205 max_count += device_tx_srv(pDevice, TYPE_TXDMA0);
3206 }
3207 if (pDevice->dwIsr & ISR_AC0DMA){
3208 max_count += device_tx_srv(pDevice, TYPE_AC0DMA);
3209 }
3210 if (pDevice->dwIsr & ISR_SOFTTIMER) {
3211
3212 }
3213 if (pDevice->dwIsr & ISR_SOFTTIMER1) {
3214 if (pDevice->eOPMode == OP_MODE_AP) {
3215 if (pDevice->bShortSlotTime)
3216 pMgmt->wCurrCapInfo |= WLAN_SET_CAP_INFO_SHORTSLOTTIME(1);
3217 else
3218 pMgmt->wCurrCapInfo &= ~(WLAN_SET_CAP_INFO_SHORTSLOTTIME(1));
3219 }
3220 bMgrPrepareBeaconToSend(pDevice, pMgmt);
3221 pDevice->byCntMeasure = 0;
3222 }
3223
3224 MACvReadISR(pDevice->PortOffset, &pDevice->dwIsr);
3225
3226 MACvReceive0(pDevice->PortOffset);
3227 MACvReceive1(pDevice->PortOffset);
3228
3229 if (max_count>pDevice->sOpts.int_works)
3230 break;
3231 }
3232
3233 if (byOrgPageSel == 1) {
3234 MACvSelectPage1(pDevice->PortOffset);
3235 }
3236
3237 spin_unlock_irq(&pDevice->lock);
3238 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
3239
3240 return IRQ_RETVAL(handled);
3241}
3242
3243
3244static unsigned const ethernet_polynomial = 0x04c11db7U;
3245static inline u32 ether_crc(int length, unsigned char *data)
3246{
3247 int crc = -1;
3248
3249 while(--length >= 0) {
3250 unsigned char current_octet = *data++;
3251 int bit;
3252 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
3253 crc = (crc << 1) ^
3254 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
3255 }
3256 }
3257 return crc;
3258}
3259
3260//2008-8-4 <add> by chester
3261static int Config_FileGetParameter(UCHAR *string, UCHAR *dest,UCHAR *source)
3262{
3263 UCHAR buf1[100];
3264 int source_len = strlen(source);
3265
3266 memset(buf1,0,100);
3267 strcat(buf1, string);
3268 strcat(buf1, "=");
3269 source+=strlen(buf1);
3270
3271 memcpy(dest,source,source_len-strlen(buf1));
3272 return TRUE;
3273}
3274
3275int Config_FileOperation(PSDevice pDevice,BOOL fwrite,unsigned char *Parameter) {
3276 UCHAR *config_path=CONFIG_PATH;
3277 UCHAR *buffer=NULL;
3278 UCHAR tmpbuffer[20];
3279 struct file *filp=NULL;
3280 mm_segment_t old_fs = get_fs();
Forest Bond756f94e2009-04-25 10:32:25 -0400[diff] [blame^]3281 //int oldfsuid=0,oldfsgid=0;
Forest Bond5449c682009-04-25 10:30:44 -0400[diff] [blame]3282 int result=0;
3283
3284 set_fs (KERNEL_DS);
Forest Bond756f94e2009-04-25 10:32:25 -0400[diff] [blame^]3285
3286 /* Can't do this anymore, so we rely on correct filesystem permissions:
3287 //Make sure a caller can read or write power as root
3288 oldfsuid=current->cred->fsuid;
3289 oldfsgid=current->cred->fsgid;
3290 current->cred->fsuid = 0;
3291 current->cred->fsgid = 0;
3292 */
Forest Bond5449c682009-04-25 10:30:44 -0400[diff] [blame]3293
3294 //open file
3295 filp = filp_open(config_path, O_RDWR, 0);
3296 if (IS_ERR(filp)) {
3297 printk("Config_FileOperation:open file fail?\n");
3298 result=-1;
3299 goto error2;
3300 }
3301
3302 if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
3303 printk("file %s cann't readable or writable?\n",config_path);
3304 result = -1;
3305 goto error1;
3306 }
3307
3308buffer = (UCHAR *)kmalloc(1024, GFP_KERNEL);
3309if(buffer==NULL) {
3310 printk("alllocate mem for file fail?\n");
3311 result = -1;
3312 goto error1;
3313}
3314
3315if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
3316 printk("read file error?\n");
3317 result = -1;
3318 goto error1;
3319}
3320
3321if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer)!=TRUE) {
3322 printk("get parameter error?\n");
3323 result = -1;
3324 goto error1;
3325}
3326
3327if(memcmp(tmpbuffer,"USA",3)==0) {
3328 result=ZoneType_USA;
3329}
3330else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
3331 result=ZoneType_Japan;
3332}
3333else if(memcmp(tmpbuffer,"EUROPE",5)==0) {
3334 result=ZoneType_Europe;
3335}
3336else {
3337 result = -1;
3338 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
3339}
3340
3341error1:
3342 if(buffer)
3343 kfree(buffer);
3344
3345 if(filp_close(filp,NULL))
3346 printk("Config_FileOperation:close file fail\n");
3347
3348error2:
3349 set_fs (old_fs);
Forest Bond756f94e2009-04-25 10:32:25 -0400[diff] [blame^]3350
3351 /*
3352 current->cred->fsuid=oldfsuid;
3353 current->cred->fsgid=oldfsgid;
3354 */
Forest Bond5449c682009-04-25 10:30:44 -0400[diff] [blame]3355
3356 return result;
3357}
3358
3359
3360#ifdef PRIVATE_OBJ
3361
3362void __device_set_multi(HANDLE pExDevice) {
3363 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
3364 ref_net_device *dev = &(pDevice_info->ref_dev);
3365 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
3366
3367#else
3368
3369static void device_set_multi(struct net_device *dev) {
3370 PSDevice pDevice = (PSDevice) dev->priv;
3371#endif
3372
3373 PSMgmtObject pMgmt = pDevice->pMgmt;
3374 u32 mc_filter[2];
3375 int i;
3376 struct dev_mc_list *mclist;
3377
3378
3379 VNSvInPortB(pDevice->PortOffset + MAC_REG_RCR, &(pDevice->byRxMode));
3380
3381#ifdef PRIVATE_OBJ
3382 if (*(dev->flags) & IFF_PROMISC) { /* Set promiscuous. */
3383 DEVICE_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: Promiscuous mode enabled.\n", pDevice->dev->name);
3384
3385#else
3386 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
3387 DEVICE_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
3388#endif
3389 /* Unconditionally log net taps. */
3390 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
3391 }
3392#ifdef PRIVATE_OBJ
3393 else if ((*(dev->mc_count) > pDevice->multicast_limit)
3394 || (*(dev->flags) & IFF_ALLMULTI)) {
3395#else
3396 else if ((dev->mc_count > pDevice->multicast_limit)
3397 || (dev->flags & IFF_ALLMULTI)) {
3398#endif
3399 MACvSelectPage1(pDevice->PortOffset);
3400 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, 0xffffffff);
3401 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, 0xffffffff);
3402 MACvSelectPage0(pDevice->PortOffset);
3403 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
3404 }
3405 else {
3406 memset(mc_filter, 0, sizeof(mc_filter));
3407#ifdef PRIVATE_OBJ
3408 for (i = 0, mclist = dev->mc_list; mclist && i < *(dev->mc_count);
3409 i++, mclist = mclist->next) {
3410#else
3411 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
3412 i++, mclist = mclist->next) {
3413#endif
3414 int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
3415 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
3416 }
3417 MACvSelectPage1(pDevice->PortOffset);
3418 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0, mc_filter[0]);
3419 VNSvOutPortD(pDevice->PortOffset + MAC_REG_MAR0 + 4, mc_filter[1]);
3420 MACvSelectPage0(pDevice->PortOffset);
3421 pDevice->byRxMode &= ~(RCR_UNICAST);
3422 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
3423 }
3424
3425 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
3426 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
3427 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
3428 pDevice->byRxMode &= ~(RCR_UNICAST);
3429 }
3430
3431 VNSvOutPortB(pDevice->PortOffset + MAC_REG_RCR, pDevice->byRxMode);
3432 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode = %x\n", pDevice->byRxMode );
3433}
3434
3435
3436#ifdef PRIVATE_OBJ
3437
3438struct net_device_stats *__device_get_stats(HANDLE pExDevice) {
3439 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
3440 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
3441
3442#else
3443static struct net_device_stats *device_get_stats(struct net_device *dev) {
3444 PSDevice pDevice=(PSDevice) dev->priv;
3445#endif
3446
3447 return &pDevice->stats;
3448}
3449
3450
3451#ifdef PRIVATE_OBJ
3452
3453int __device_ioctl(HANDLE pExDevice, struct ifreq *rq, int cmd) {
3454 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
3455 struct net_device *dev = pDevice_info->dev;
3456 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
3457
3458#else
3459
3460static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
3461 PSDevice pDevice = (PSDevice)dev->priv;
3462#endif
3463
3464#ifdef WIRELESS_EXT
3465 struct iwreq *wrq = (struct iwreq *) rq;
3466 int rc =0;
3467#endif
3468 PSMgmtObject pMgmt = pDevice->pMgmt;
3469 PSCmdRequest pReq;
3470
3471
3472 if (pMgmt == NULL) {
3473 rc = -EFAULT;
3474 return rc;
3475 }
3476
3477 switch(cmd) {
3478
3479#ifdef WIRELESS_EXT
3480//#if WIRELESS_EXT < 13
3481
3482 case SIOCGIWNAME:
3483 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
3484 break;
3485
3486 case SIOCGIWNWID: //0x8b03 support
3487 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3488 rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
3489 #else
3490 rc = -EOPNOTSUPP;
3491 #endif
3492 break;
3493
3494 // Set frequency/channel
3495 case SIOCSIWFREQ:
3496 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
3497 break;
3498
3499 // Get frequency/channel
3500 case SIOCGIWFREQ:
3501 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
3502 break;
3503
3504 // Set desired network name (ESSID)
3505 case SIOCSIWESSID:
3506
3507 {
3508 char essid[IW_ESSID_MAX_SIZE+1];
3509 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
3510 rc = -E2BIG;
3511 break;
3512 }
3513 if (copy_from_user(essid, wrq->u.essid.pointer,
3514 wrq->u.essid.length)) {
3515 rc = -EFAULT;
3516 break;
3517 }
3518 rc = iwctl_siwessid(dev, NULL,
3519 &(wrq->u.essid), essid);
3520 }
3521 break;
3522
3523
3524 // Get current network name (ESSID)
3525 case SIOCGIWESSID:
3526
3527 {
3528 char essid[IW_ESSID_MAX_SIZE+1];
3529 if (wrq->u.essid.pointer)
3530 rc = iwctl_giwessid(dev, NULL,
3531 &(wrq->u.essid), essid);
3532 if (copy_to_user(wrq->u.essid.pointer,
3533 essid,
3534 wrq->u.essid.length) )
3535 rc = -EFAULT;
3536 }
3537 break;
3538
3539 case SIOCSIWAP:
3540
3541 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
3542 break;
3543
3544
3545 // Get current Access Point (BSSID)
3546 case SIOCGIWAP:
3547 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
3548 break;
3549
3550
3551 // Set desired station name
3552 case SIOCSIWNICKN:
3553 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
3554 rc = -EOPNOTSUPP;
3555 break;
3556
3557 // Get current station name
3558 case SIOCGIWNICKN:
3559 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
3560 rc = -EOPNOTSUPP;
3561 break;
3562
3563 // Set the desired bit-rate
3564 case SIOCSIWRATE:
3565 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
3566 break;
3567
3568 // Get the current bit-rate
3569 case SIOCGIWRATE:
3570
3571 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
3572 break;
3573
3574 // Set the desired RTS threshold
3575 case SIOCSIWRTS:
3576
3577 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
3578 break;
3579
3580 // Get the current RTS threshold
3581 case SIOCGIWRTS:
3582
3583 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
3584 break;
3585
3586 // Set the desired fragmentation threshold
3587 case SIOCSIWFRAG:
3588
3589 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
3590 break;
3591
3592 // Get the current fragmentation threshold
3593 case SIOCGIWFRAG:
3594
3595 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
3596 break;
3597
3598 // Set mode of operation
3599 case SIOCSIWMODE:
3600 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
3601 break;
3602
3603 // Get mode of operation
3604 case SIOCGIWMODE:
3605 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
3606 break;
3607
3608 // Set WEP keys and mode
3609 case SIOCSIWENCODE:
3610 {
3611 char abyKey[WLAN_WEP232_KEYLEN];
3612
3613 if (wrq->u.encoding.pointer) {
3614
3615
3616 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
3617 rc = -E2BIG;
3618 break;
3619 }
3620 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
3621 if (copy_from_user(abyKey,
3622 wrq->u.encoding.pointer,
3623 wrq->u.encoding.length)) {
3624 rc = -EFAULT;
3625 break;
3626 }
3627 } else if (wrq->u.encoding.length != 0) {
3628 rc = -EINVAL;
3629 break;
3630 }
3631 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
3632 }
3633 break;
3634
3635 // Get the WEP keys and mode
3636 case SIOCGIWENCODE:
3637
3638 if (!capable(CAP_NET_ADMIN)) {
3639 rc = -EPERM;
3640 break;
3641 }
3642 {
3643 char abyKey[WLAN_WEP232_KEYLEN];
3644
3645 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
3646 if (rc != 0) break;
3647 if (wrq->u.encoding.pointer) {
3648 if (copy_to_user(wrq->u.encoding.pointer,
3649 abyKey,
3650 wrq->u.encoding.length))
3651 rc = -EFAULT;
3652 }
3653 }
3654 break;
3655
3656#if WIRELESS_EXT > 9
3657 // Get the current Tx-Power
3658 case SIOCGIWTXPOW:
3659 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
3660 rc = -EOPNOTSUPP;
3661 break;
3662
3663 case SIOCSIWTXPOW:
3664 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
3665 rc = -EOPNOTSUPP;
3666 break;
3667
3668#endif // WIRELESS_EXT > 9
3669
3670#if WIRELESS_EXT > 10
3671 case SIOCSIWRETRY:
3672
3673 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
3674 break;
3675
3676 case SIOCGIWRETRY:
3677
3678 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
3679 break;
3680
3681#endif // WIRELESS_EXT > 10
3682
3683 // Get range of parameters
3684 case SIOCGIWRANGE:
3685
3686 {
3687 struct iw_range range;
3688
3689 rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
3690 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
3691 rc = -EFAULT;
3692 }
3693
3694 break;
3695
3696 case SIOCGIWPOWER:
3697
3698 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
3699 break;
3700
3701
3702 case SIOCSIWPOWER:
3703
3704 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
3705 break;
3706
3707
3708 case SIOCGIWSENS:
3709
3710 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
3711 break;
3712
3713 case SIOCSIWSENS:
3714 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
3715 rc = -EOPNOTSUPP;
3716 break;
3717
3718 case SIOCGIWAPLIST:
3719 {
3720 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
3721
3722 if (wrq->u.data.pointer) {
3723 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
3724 if (rc == 0) {
3725 if (copy_to_user(wrq->u.data.pointer,
3726 buffer,
3727 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality)))
3728 ))
3729 rc = -EFAULT;
3730 }
3731 }
3732 }
3733 break;
3734
3735
3736#ifdef WIRELESS_SPY
3737 // Set the spy list
3738 case SIOCSIWSPY:
3739
3740 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
3741 rc = -EOPNOTSUPP;
3742 break;
3743
3744 // Get the spy list
3745 case SIOCGIWSPY:
3746
3747 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
3748 rc = -EOPNOTSUPP;
3749 break;
3750
3751#endif // WIRELESS_SPY
3752
3753 case SIOCGIWPRIV:
3754 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
3755 rc = -EOPNOTSUPP;
3756/*
3757 if(wrq->u.data.pointer) {
3758 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
3759
3760 if(copy_to_user(wrq->u.data.pointer,
3761 (u_char *) iwctl_private_args,
3762 sizeof(iwctl_private_args)))
3763 rc = -EFAULT;
3764 }
3765*/
3766 break;
3767
3768
3769//#endif // WIRELESS_EXT < 13
3770//2008-0409-07, <Add> by Einsn Liu
3771#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3772 case SIOCSIWAUTH:
3773 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n");
3774 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
3775 break;
3776
3777 case SIOCGIWAUTH:
3778 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
3779 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
3780 break;
3781
3782 case SIOCSIWGENIE:
3783 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
3784 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3785 break;
3786
3787 case SIOCGIWGENIE:
3788 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
3789 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3790 break;
3791
3792 case SIOCSIWENCODEEXT:
3793 {
3794 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
3795 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
3796 if(wrq->u.encoding.pointer){
3797 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
3798 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
3799 rc = -E2BIG;
3800 break;
3801 }
3802 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
3803 rc = -EFAULT;
3804 break;
3805 }
3806 }else if(wrq->u.encoding.length != 0){
3807 rc = -EINVAL;
3808 break;
3809 }
3810 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
3811 }
3812 break;
3813
3814 case SIOCGIWENCODEEXT:
3815 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
3816 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
3817 break;
3818
3819 case SIOCSIWMLME:
3820 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
3821 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
3822 break;
3823
3824#endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3825//End Add -- //2008-0409-07, <Add> by Einsn Liu
3826
3827#endif // WIRELESS_EXT
3828
3829 case IOCTL_CMD_TEST:
3830
3831 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
3832 rc = -EFAULT;
3833 break;
3834 } else {
3835 rc = 0;
3836 }
3837 pReq = (PSCmdRequest)rq;
3838 pReq->wResult = MAGIC_CODE;
3839 break;
3840
3841 case IOCTL_CMD_SET:
3842
3843 #ifdef SndEvt_ToAPI
3844 if((((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_EVT) &&
3845 !(pDevice->flags & DEVICE_FLAGS_OPENED))
3846 #else
3847 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
3848 (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
3849 #endif
3850 {
3851 rc = -EFAULT;
3852 break;
3853 } else {
3854 rc = 0;
3855 }
3856
3857 if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
3858 return -EBUSY;
3859 }
3860 rc = private_ioctl(pDevice, rq);
3861 clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
3862 break;
3863
3864 case IOCTL_CMD_HOSTAPD:
3865
3866
3867#if WIRELESS_EXT > 8
3868 rc = hostap_ioctl(pDevice, &wrq->u.data);
3869#else // WIRELESS_EXT > 8
3870 rc = hostap_ioctl(pDevice, (struct iw_point *) &wrq->u.data);
3871#endif // WIRELESS_EXT > 8
3872 break;
3873
3874 case IOCTL_CMD_WPA:
3875
3876#if WIRELESS_EXT > 8
3877 rc = wpa_ioctl(pDevice, &wrq->u.data);
3878#else // WIRELESS_EXT > 8
3879 rc = wpa_ioctl(pDevice, (struct iw_point *) &wrq->u.data);
3880#endif // WIRELESS_EXT > 8
3881 break;
3882
3883 case SIOCETHTOOL:
3884 return ethtool_ioctl(dev, (void *) rq->ifr_data);
3885 // All other calls are currently unsupported
3886
3887 default:
3888 rc = -EOPNOTSUPP;
3889 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
3890
3891
3892 }
3893
3894 if (pDevice->bCommit) {
3895 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
3896 netif_stop_queue(pDevice->dev);
3897 spin_lock_irq(&pDevice->lock);
3898 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL);
3899 spin_unlock_irq(&pDevice->lock);
3900 }
3901 else {
3902 DEVICE_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
3903 spin_lock_irq(&pDevice->lock);
3904 pDevice->bLinkPass = FALSE;
3905 memset(pMgmt->abyCurrBSSID, 0, 6);
3906 pMgmt->eCurrState = WMAC_STATE_IDLE;
3907 netif_stop_queue(pDevice->dev);
3908 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
3909 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
3910 if(pDevice->bWPASuppWextEnabled !=TRUE)
3911 #endif
3912 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID);
3913 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_SSID, NULL);
3914 spin_unlock_irq(&pDevice->lock);
3915 }
3916 pDevice->bCommit = FALSE;
3917 }
3918
3919 return rc;
3920}
3921
3922
3923static int ethtool_ioctl(struct net_device *dev, void *useraddr)
3924{
3925 u32 ethcmd;
3926
3927 if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
3928 return -EFAULT;
3929
3930 switch (ethcmd) {
3931 case ETHTOOL_GDRVINFO: {
3932 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
3933 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
3934 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
3935 if (copy_to_user(useraddr, &info, sizeof(info)))
3936 return -EFAULT;
3937 return 0;
3938 }
3939
3940 }
3941
3942 return -EOPNOTSUPP;
3943}
3944
3945/*------------------------------------------------------------------*/
3946#ifndef PRIVATE_OBJ
3947
3948MODULE_DEVICE_TABLE(pci, device_id_table);
3949
3950static struct pci_driver device_driver = {
3951 name: DEVICE_NAME,
3952 id_table: device_id_table,
3953 probe: device_found1,
3954 remove: device_remove1,
3955#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,9)
3956#ifdef CONFIG_PM
3957 suspend: viawget_suspend,
3958 resume: viawget_resume,
3959#endif
3960#endif
3961};
3962
3963static int __init device_init_module(void)
3964{
3965 int ret;
3966
3967
3968// ret=pci_module_init(&device_driver);
3969 //ret = pcie_port_service_register(&device_driver);
3970#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
3971 ret = pci_register_driver(&device_driver);
3972#else
3973 ret = pci_module_init(&device_driver);
3974#endif
3975#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,9)
3976#ifdef CONFIG_PM
3977 if(ret >= 0)
3978 register_reboot_notifier(&device_notifier);
3979#endif
3980#endif
3981
3982 return ret;
3983}
3984
3985static void __exit device_cleanup_module(void)
3986{
3987
3988
3989#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,9)
3990#ifdef CONFIG_PM
3991 unregister_reboot_notifier(&device_notifier);
3992#endif
3993#endif
3994 pci_unregister_driver(&device_driver);
3995
3996}
3997
3998module_init(device_init_module);
3999module_exit(device_cleanup_module);
4000
4001
4002#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,9)
4003#ifdef CONFIG_PM
4004static int
4005device_notify_reboot(struct notifier_block *nb, unsigned long event, void *p)
4006{
4007 struct pci_dev *pdev = NULL;
4008 switch(event) {
4009 case SYS_DOWN:
4010 case SYS_HALT:
4011 case SYS_POWER_OFF:
4012#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
4013 while ((pdev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, pdev)) != NULL) {
4014#else
4015 pci_for_each_dev(pdev) {
4016#endif
4017 if(pci_dev_driver(pdev) == &device_driver) {
4018 if (pci_get_drvdata(pdev))
4019 viawget_suspend(pdev, 3);
4020 }
4021 }
4022 }
4023 return NOTIFY_DONE;
4024}
4025
4026static int
4027viawget_suspend(struct pci_dev *pcid, u32 state)
4028{
4029 int power_status; // to silence the compiler
4030
4031 PSDevice pDevice=pci_get_drvdata(pcid);
4032 PSMgmtObject pMgmt = pDevice->pMgmt;
4033
4034 netif_stop_queue(pDevice->dev);
4035 spin_lock_irq(&pDevice->lock);
4036#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10)
4037 pci_save_state(pcid);
4038#else
4039 pci_save_state(pcid, pDevice->pci_state);
4040#endif
4041 del_timer(&pDevice->sTimerCommand);
4042 del_timer(&pMgmt->sTimerSecondCallback);
4043 pDevice->cbFreeCmdQueue = CMD_Q_SIZE;
4044 pDevice->uCmdDequeueIdx = 0;
4045 pDevice->uCmdEnqueueIdx = 0;
4046 pDevice->bCmdRunning = FALSE;
4047 MACbShutdown(pDevice->PortOffset);
4048 MACvSaveContext(pDevice->PortOffset, pDevice->abyMacContext);
4049 pDevice->bLinkPass = FALSE;
4050 memset(pMgmt->abyCurrBSSID, 0, 6);
4051 pMgmt->eCurrState = WMAC_STATE_IDLE;
4052 pci_disable_device(pcid);
4053 power_status = pci_set_power_state(pcid, state);
4054 spin_unlock_irq(&pDevice->lock);
4055 return 0;
4056}
4057
4058static int
4059viawget_resume(struct pci_dev *pcid)
4060{
4061 PSDevice pDevice=pci_get_drvdata(pcid);
4062 PSMgmtObject pMgmt = pDevice->pMgmt;
4063 int power_status; // to silence the compiler
4064
4065
4066 power_status = pci_set_power_state(pcid, 0);
4067 power_status = pci_enable_wake(pcid, 0, 0);
4068#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,10)
4069 pci_restore_state(pcid);
4070#else
4071 pci_restore_state(pcid, pDevice->pci_state);
4072#endif
4073 if (netif_running(pDevice->dev)) {
4074 spin_lock_irq(&pDevice->lock);
4075 MACvRestoreContext(pDevice->PortOffset, pDevice->abyMacContext);
4076 device_init_registers(pDevice, DEVICE_INIT_DXPL);
4077 if (pMgmt->sNodeDBTable[0].bActive == TRUE) { // Assoc with BSS
4078 pMgmt->sNodeDBTable[0].bActive = FALSE;
4079 pDevice->bLinkPass = FALSE;
4080 if(pMgmt->eCurrMode == WMAC_MODE_IBSS_STA) {
4081 // In Adhoc, BSS state set back to started.
4082 pMgmt->eCurrState = WMAC_STATE_STARTED;
4083 }
4084 else {
4085 pMgmt->eCurrMode = WMAC_MODE_STANDBY;
4086 pMgmt->eCurrState = WMAC_STATE_IDLE;
4087 }
4088 }
4089 init_timer(&pMgmt->sTimerSecondCallback);
4090 init_timer(&pDevice->sTimerCommand);
4091 MACvIntEnable(pDevice->PortOffset, IMR_MASK_VALUE);
4092 BSSvClearBSSList((HANDLE)pDevice, pDevice->bLinkPass);
4093 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
4094 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_SSID, NULL);
4095 spin_unlock_irq(&pDevice->lock);
4096 }
4097 return 0;
4098}
4099
4100#endif
4101#endif
4102
4103#endif //#ifndef PRIVATE_OBJ
4104
4105#ifdef PRIVATE_OBJ
4106
4107
4108int __device_hw_reset(HANDLE pExDevice){
4109 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
4110
4111 return MACbSoftwareReset(pDevice_info->port_offset);
4112}
4113
4114
4115int __device_hw_init(HANDLE pExDevice){
4116 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
4117 PSDevice pDevice;
4118
4119
4120 pDevice = (PSDevice)kmalloc(sizeof(DEVICE_INFO), (int)GFP_ATOMIC);
4121 if (pDevice == NULL)
4122 return FALSE;
4123
4124 memset(pDevice, 0, sizeof(DEVICE_INFO));
4125 pDevice_info->pWDevice = pDevice;
4126 pDevice->PortOffset = pDevice_info->port_offset;
4127 pDevice->dev = pDevice_info->dev;
4128 pDevice->pcid = pDevice_info->pcid;
4129 pDevice->chip_id = pDevice_info->chip_id;
4130 pDevice->memaddr = pDevice_info->mem_addr;
4131 pDevice->ioaddr = pDevice_info->io_addr;
4132 pDevice->io_size = pDevice_info->io_size;
4133 pDevice->nTxQueues = pDevice_info->nTxQueues;
4134 pDevice->multicast_limit = pDevice_info->multicast_limit;
4135 pDevice->sMgmtObj.pAdapter = (PVOID)pDevice;
4136 pDevice->pMgmt = &(pDevice->sMgmtObj);
4137 MACvInitialize(pDevice->PortOffset);
4138 device_get_options(pDevice, 0 , pDevice_info->dev->name);
4139 device_set_options(pDevice);
4140 pDevice->sOpts.flags &= pDevice_info->flags;
4141 pDevice->flags = pDevice->sOpts.flags | (pDevice_info->flags & 0xFF000000UL);
4142 spin_lock_init(&(pDevice->lock));
4143
4144 return TRUE;
4145}
4146
4147
4148void __device_read_mac(HANDLE pExDevice, PBYTE dev_addr){
4149 PSDevice_info pDevice_info = (PSDevice_info)pExDevice;
4150 PSDevice pDevice = (PSDevice)(pDevice_info->pWDevice);
4151
4152 MACvReadEtherAddress(pDevice->PortOffset, dev_addr);
4153 return;
4154}
4155
4156
4157#endif
4158
4159