projects / deliverable / linux.git / blob
? search:


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