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


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