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