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