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