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