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