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