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