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