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