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