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