1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47#undef __NO_VERSION__
48
49#include "device.h"
50#include "card.h"
51#include "baseband.h"
52#include "mac.h"
53#include "tether.h"
54#include "wmgr.h"
55#include "wctl.h"
56#include "power.h"
57#include "wcmd.h"
58#include "iocmd.h"
59#include "tcrc.h"
60#include "rxtx.h"
61#include "bssdb.h"
62#include "hostap.h"
63#include "wpactl.h"
64#include "ioctl.h"
65#include "iwctl.h"
66#include "dpc.h"
67#include "datarate.h"
68#include "rf.h"
69#include "firmware.h"
70#include "rndis.h"
71#include "control.h"
72#include "channel.h"
73#include "int.h"
74#include "iowpa.h"
75
76
77
78static int msglevel =MSG_LEVEL_INFO;
79
80
81
82
83
84
85#define DRIVER_AUTHOR "VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>"
86MODULE_AUTHOR(DRIVER_AUTHOR);
87MODULE_LICENSE("GPL");
88MODULE_DESCRIPTION(DEVICE_FULL_DRV_NAM);
89
90#define DEVICE_PARAM(N,D) \
91 static int N[MAX_UINTS]=OPTION_DEFAULT;\
92 module_param_array(N, int, NULL, 0);\
93 MODULE_PARM_DESC(N, D);
94
95#define RX_DESC_MIN0 16
96#define RX_DESC_MAX0 128
97#define RX_DESC_DEF0 64
98DEVICE_PARAM(RxDescriptors0,"Number of receive usb desc buffer");
99
100
101#define TX_DESC_MIN0 16
102#define TX_DESC_MAX0 128
103#define TX_DESC_DEF0 64
104DEVICE_PARAM(TxDescriptors0,"Number of transmit usb desc buffer");
105
106
107#define CHANNEL_MIN 1
108#define CHANNEL_MAX 14
109#define CHANNEL_DEF 6
110
111DEVICE_PARAM(Channel, "Channel number");
112
113
114
115
116
117
118
119#define PREAMBLE_TYPE_DEF 1
120
121DEVICE_PARAM(PreambleType, "Preamble Type");
122
123
124#define RTS_THRESH_MIN 512
125#define RTS_THRESH_MAX 2347
126#define RTS_THRESH_DEF 2347
127
128DEVICE_PARAM(RTSThreshold, "RTS threshold");
129
130
131#define FRAG_THRESH_MIN 256
132#define FRAG_THRESH_MAX 2346
133#define FRAG_THRESH_DEF 2346
134
135DEVICE_PARAM(FragThreshold, "Fragmentation threshold");
136
137
138#define DATA_RATE_MIN 0
139#define DATA_RATE_MAX 13
140#define DATA_RATE_DEF 13
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158DEVICE_PARAM(ConnectionRate, "Connection data rate");
159
160#define OP_MODE_MAX 2
161#define OP_MODE_DEF 0
162#define OP_MODE_MIN 0
163
164DEVICE_PARAM(OPMode, "Infrastruct, adhoc, AP mode ");
165
166
167
168
169
170
171
172
173
174
175
176
177
178#define PS_MODE_DEF 0
179
180DEVICE_PARAM(PSMode, "Power saving mode");
181
182
183#define SHORT_RETRY_MIN 0
184#define SHORT_RETRY_MAX 31
185#define SHORT_RETRY_DEF 8
186
187
188DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits");
189
190#define LONG_RETRY_MIN 0
191#define LONG_RETRY_MAX 15
192#define LONG_RETRY_DEF 4
193
194
195DEVICE_PARAM(LongRetryLimit, "long frame retry limits");
196
197
198
199
200
201
202
203#define BBP_TYPE_MIN 0
204#define BBP_TYPE_MAX 2
205#define BBP_TYPE_DEF 2
206
207DEVICE_PARAM(BasebandType, "baseband type");
208
209
210
211
212
213
214
215
216#define X80211h_MODE_DEF 0
217
218DEVICE_PARAM(b80211hEnable, "802.11h mode");
219
220
221
222
223
224
225static struct usb_device_id vt6656_table[] __devinitdata = {
226 {USB_DEVICE(VNT_USB_VENDOR_ID, VNT_USB_PRODUCT_ID)},
227 {}
228};
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251static int vt6656_probe(struct usb_interface *intf,
252 const struct usb_device_id *id);
253static void vt6656_disconnect(struct usb_interface *intf);
254
255#ifdef CONFIG_PM
256static int vt6656_suspend(struct usb_interface *intf, pm_message_t message);
257static int vt6656_resume(struct usb_interface *intf);
258#endif
259
260static struct net_device_stats *device_get_stats(struct net_device *dev);
261static int device_open(struct net_device *dev);
262static int device_xmit(struct sk_buff *skb, struct net_device *dev);
263static void device_set_multi(struct net_device *dev);
264static int device_close(struct net_device *dev);
265static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
266
267static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType);
268static BOOL device_init_defrag_cb(PSDevice pDevice);
269static void device_init_diversity_timer(PSDevice pDevice);
270static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
271
272static int ethtool_ioctl(struct net_device *dev, void *useraddr);
273static void device_free_tx_bufs(PSDevice pDevice);
274static void device_free_rx_bufs(PSDevice pDevice);
275static void device_free_int_bufs(PSDevice pDevice);
276static void device_free_frag_bufs(PSDevice pDevice);
277static BOOL device_alloc_bufs(PSDevice pDevice);
278
279static int Read_config_file(PSDevice pDevice);
280static unsigned char *Config_FileOperation(PSDevice pDevice);
281static int Config_FileGetParameter(unsigned char *string,
282 unsigned char *dest,
283 unsigned char *source);
284
285static BOOL device_release_WPADEV(PSDevice pDevice);
286
287static void usb_device_reset(PSDevice pDevice);
288
289
290
291
292
293
294
295
296static void
297device_set_options(PSDevice pDevice) {
298
299 BYTE abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
300 BYTE abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
301 u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
302
303 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
304 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
305 memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, ETH_ALEN);
306
307 pDevice->cbTD = TX_DESC_DEF0;
308 pDevice->cbRD = RX_DESC_DEF0;
309 pDevice->uChannel = CHANNEL_DEF;
310 pDevice->wRTSThreshold = RTS_THRESH_DEF;
311 pDevice->wFragmentationThreshold = FRAG_THRESH_DEF;
312 pDevice->byShortRetryLimit = SHORT_RETRY_DEF;
313 pDevice->byLongRetryLimit = LONG_RETRY_DEF;
314 pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
315 pDevice->byShortPreamble = PREAMBLE_TYPE_DEF;
316 pDevice->ePSMode = PS_MODE_DEF;
317 pDevice->b11hEnable = X80211h_MODE_DEF;
318 pDevice->eOPMode = OP_MODE_DEF;
319 pDevice->uConnectionRate = DATA_RATE_DEF;
320 if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = TRUE;
321 pDevice->byBBType = BBP_TYPE_DEF;
322 pDevice->byPacketType = pDevice->byBBType;
323 pDevice->byAutoFBCtrl = AUTO_FB_0;
324 pDevice->bUpdateBBVGA = TRUE;
325 pDevice->byFOETuning = 0;
326 pDevice->byAutoPwrTunning = 0;
327 pDevice->wCTSDuration = 0;
328 pDevice->byPreambleType = 0;
329 pDevice->bExistSWNetAddr = FALSE;
330
331 pDevice->bDiversityRegCtlON = FALSE;
332}
333
334
335static void device_init_diversity_timer(PSDevice pDevice)
336{
337 init_timer(&pDevice->TimerSQ3Tmax1);
338 pDevice->TimerSQ3Tmax1.data = (unsigned long)pDevice;
339 pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
340 pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
341
342 init_timer(&pDevice->TimerSQ3Tmax2);
343 pDevice->TimerSQ3Tmax2.data = (unsigned long)pDevice;
344 pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
345 pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
346
347 init_timer(&pDevice->TimerSQ3Tmax3);
348 pDevice->TimerSQ3Tmax3.data = (unsigned long)pDevice;
349 pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerSQ3Tmax3CallBack;
350 pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
351
352 return;
353}
354
355
356
357
358
359
360static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType)
361{
362 u8 abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
363 u8 abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
364 u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
365 BYTE byAntenna;
366 unsigned int ii;
367 CMD_CARD_INIT sInitCmd;
368 int ntStatus = STATUS_SUCCESS;
369 RSP_CARD_INIT sInitRsp;
370 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
371 BYTE byTmp;
372 BYTE byCalibTXIQ = 0;
373 BYTE byCalibTXDC = 0;
374 BYTE byCalibRXIQ = 0;
375
376 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---->INIbInitAdapter. [%d][%d]\n", InitType, pDevice->byPacketType);
377 spin_lock_irq(&pDevice->lock);
378 if (InitType == DEVICE_INIT_COLD) {
379 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
380 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
381 memcpy(pDevice->abySNAP_Bridgetunnel,
382 abySNAP_Bridgetunnel,
383 ETH_ALEN);
384
385 if ( !FIRMWAREbCheckVersion(pDevice) ) {
386 if (FIRMWAREbDownload(pDevice) == TRUE) {
387 if (FIRMWAREbBrach2Sram(pDevice) == FALSE) {
388 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbBrach2Sram fail \n");
389 spin_unlock_irq(&pDevice->lock);
390 return FALSE;
391 }
392 } else {
393
394 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbDownload fail \n");
395 spin_unlock_irq(&pDevice->lock);
396 return FALSE;
397 }
398 }
399
400 if ( !BBbVT3184Init(pDevice) ) {
401 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" BBbVT3184Init fail \n");
402 spin_unlock_irq(&pDevice->lock);
403 return FALSE;
404 }
405 }
406
407 sInitCmd.byInitClass = (BYTE)InitType;
408 sInitCmd.bExistSWNetAddr = (BYTE) pDevice->bExistSWNetAddr;
409 for (ii = 0; ii < 6; ii++)
410 sInitCmd.bySWNetAddr[ii] = pDevice->abyCurrentNetAddr[ii];
411 sInitCmd.byShortRetryLimit = pDevice->byShortRetryLimit;
412 sInitCmd.byLongRetryLimit = pDevice->byLongRetryLimit;
413
414
415 ntStatus = CONTROLnsRequestOut(pDevice,
416 MESSAGE_TYPE_CARDINIT,
417 0,
418 0,
419 sizeof(CMD_CARD_INIT),
420 (PBYTE) &(sInitCmd));
421
422 if ( ntStatus != STATUS_SUCCESS ) {
423 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Issue Card init fail \n");
424 spin_unlock_irq(&pDevice->lock);
425 return FALSE;
426 }
427 if (InitType == DEVICE_INIT_COLD) {
428
429 ntStatus = CONTROLnsRequestIn(pDevice,MESSAGE_TYPE_INIT_RSP,0,0,sizeof(RSP_CARD_INIT), (PBYTE) &(sInitRsp));
430
431 if (ntStatus != STATUS_SUCCESS) {
432 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Cardinit request in status fail!\n");
433 spin_unlock_irq(&pDevice->lock);
434 return FALSE;
435 }
436
437
438 ntStatus = CONTROLnsRequestIn(pDevice,
439 MESSAGE_TYPE_READ,
440 MAC_REG_LOCALID,
441 MESSAGE_REQUEST_MACREG,
442 1,
443 &pDevice->byLocalID);
444
445 if ( ntStatus != STATUS_SUCCESS ) {
446 spin_unlock_irq(&pDevice->lock);
447 return FALSE;
448 }
449
450
451
452 pDevice->bCCK = TRUE;
453 pDevice->bProtectMode = FALSE;
454 pDevice->bNonERPPresent = FALSE;
455 pDevice->bBarkerPreambleMd = FALSE;
456 if ( pDevice->bFixRate ) {
457 pDevice->wCurrentRate = (WORD) pDevice->uConnectionRate;
458 } else {
459 if ( pDevice->byBBType == BB_TYPE_11B )
460 pDevice->wCurrentRate = RATE_11M;
461 else
462 pDevice->wCurrentRate = RATE_54M;
463 }
464
465 CHvInitChannelTable(pDevice);
466
467 pDevice->byTopOFDMBasicRate = RATE_24M;
468 pDevice->byTopCCKBasicRate = RATE_1M;
469 pDevice->byRevId = 0;
470 pDevice->byCurPwr = 0xFF;
471
472 pDevice->byCCKPwr = pDevice->abyEEPROM[EEP_OFS_PWR_CCK];
473 pDevice->byOFDMPwrG = pDevice->abyEEPROM[EEP_OFS_PWR_OFDMG];
474
475 for (ii=0;ii<14;ii++) {
476 pDevice->abyCCKPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_CCK_PWR_TBL];
477 if (pDevice->abyCCKPwrTbl[ii] == 0)
478 pDevice->abyCCKPwrTbl[ii] = pDevice->byCCKPwr;
479 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDM_PWR_TBL];
480 if (pDevice->abyOFDMPwrTbl[ii] == 0)
481 pDevice->abyOFDMPwrTbl[ii] = pDevice->byOFDMPwrG;
482 }
483
484
485
486 if(((pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Japan) ||
487 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Europe))&&
488 (pDevice->byOriginalZonetype == ZoneType_USA)) {
489 for (ii = 11; ii < 14; ii++) {
490 pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];
491 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];
492 }
493 }
494
495
496 pDevice->byOFDMPwrA = 0x34;
497
498 for (ii=0;ii<CB_MAX_CHANNEL_5G;ii++) {
499 pDevice->abyOFDMAPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDMA_PWR_TBL];
500 if (pDevice->abyOFDMAPwrTbl[ii] == 0)
501 pDevice->abyOFDMAPwrTbl[ii] = pDevice->byOFDMPwrA;
502 }
503
504
505 byAntenna = pDevice->abyEEPROM[EEP_OFS_ANTENNA];
506 if (byAntenna & EEP_ANTINV)
507 pDevice->bTxRxAntInv = TRUE;
508 else
509 pDevice->bTxRxAntInv = FALSE;
510
511 byAntenna &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
512
513 if (byAntenna == 0)
514 byAntenna = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
515
516 if (byAntenna == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
517 pDevice->byAntennaCount = 2;
518 pDevice->byTxAntennaMode = ANT_B;
519 pDevice->dwTxAntennaSel = 1;
520 pDevice->dwRxAntennaSel = 1;
521 if (pDevice->bTxRxAntInv == TRUE)
522 pDevice->byRxAntennaMode = ANT_A;
523 else
524 pDevice->byRxAntennaMode = ANT_B;
525
526 if (pDevice->bDiversityRegCtlON)
527 pDevice->bDiversityEnable = TRUE;
528 else
529 pDevice->bDiversityEnable = FALSE;
530 } else {
531 pDevice->bDiversityEnable = FALSE;
532 pDevice->byAntennaCount = 1;
533 pDevice->dwTxAntennaSel = 0;
534 pDevice->dwRxAntennaSel = 0;
535 if (byAntenna & EEP_ANTENNA_AUX) {
536 pDevice->byTxAntennaMode = ANT_A;
537 if (pDevice->bTxRxAntInv == TRUE)
538 pDevice->byRxAntennaMode = ANT_B;
539 else
540 pDevice->byRxAntennaMode = ANT_A;
541 } else {
542 pDevice->byTxAntennaMode = ANT_B;
543 if (pDevice->bTxRxAntInv == TRUE)
544 pDevice->byRxAntennaMode = ANT_A;
545 else
546 pDevice->byRxAntennaMode = ANT_B;
547 }
548 }
549 pDevice->ulDiversityNValue = 100*255;
550 pDevice->ulDiversityMValue = 100*16;
551 pDevice->byTMax = 1;
552 pDevice->byTMax2 = 4;
553 pDevice->ulSQ3TH = 0;
554 pDevice->byTMax3 = 64;
555
556
557
558 pDevice->byAutoFBCtrl = AUTO_FB_0;
559
560
561 pDevice->uScanTime = WLAN_SCAN_MINITIME;
562
563
564
565 pDevice->eConfigPHYMode = PHY_TYPE_AUTO;
566 pDevice->byBBType = BB_TYPE_11G;
567
568
569 pDevice->ulTxPower = 25;
570
571
572 pDevice->byMinChannel = 1;
573 pDevice->byMaxChannel = CB_MAX_CHANNEL;
574
575
576 pDevice->byRFType = sInitRsp.byRFType;
577
578 if ((pDevice->byRFType & RF_EMU) != 0) {
579
580 pDevice->byRevId = 0x80;
581 }
582
583
584 if (pDevice->byRFType == RF_VT3226D0) {
585 if((pDevice->abyEEPROM[EEP_OFS_MAJOR_VER] == 0x1) &&
586 (pDevice->abyEEPROM[EEP_OFS_MINOR_VER] >= 0x4)) {
587 byCalibTXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_IQ];
588 byCalibTXDC = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_DC];
589 byCalibRXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_RX_IQ];
590 if( (byCalibTXIQ || byCalibTXDC || byCalibRXIQ) ) {
591 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFF, 0x03);
592 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFB, byCalibTXIQ);
593 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFC, byCalibTXDC);
594 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFD, byCalibRXIQ);
595 } else {
596
597 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFF, 0x0);
598 }
599 }
600 }
601 pMgmt->eScanType = WMAC_SCAN_PASSIVE;
602 pMgmt->uCurrChannel = pDevice->uChannel;
603 pMgmt->uIBSSChannel = pDevice->uChannel;
604 CARDbSetMediaChannel(pDevice, pMgmt->uCurrChannel);
605
606
607 memcpy(pDevice->abyPermanentNetAddr,&(sInitRsp.byNetAddr[0]),6);
608 memcpy(pDevice->abyCurrentNetAddr,
609 pDevice->abyPermanentNetAddr,
610 ETH_ALEN);
611
612
613
614 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %02x-%02x-%02x=%02x-%02x-%02x\n",
615 pDevice->abyCurrentNetAddr[0],
616 pDevice->abyCurrentNetAddr[1],
617 pDevice->abyCurrentNetAddr[2],
618 pDevice->abyCurrentNetAddr[3],
619 pDevice->abyCurrentNetAddr[4],
620 pDevice->abyCurrentNetAddr[5]);
621 }
622
623
624
625
626
627 if (pDevice->byBBType == BB_TYPE_11A) {
628 CARDbAddBasicRate(pDevice, RATE_6M);
629 pDevice->bShortSlotTime = TRUE;
630 } else {
631 CARDbAddBasicRate(pDevice, RATE_1M);
632 pDevice->bShortSlotTime = FALSE;
633 }
634 BBvSetShortSlotTime(pDevice);
635 CARDvSetBSSMode(pDevice);
636
637 if (pDevice->bUpdateBBVGA) {
638 pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
639 pDevice->byBBVGANew = pDevice->byBBVGACurrent;
640 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
641 }
642
643 pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];
644 pDevice->bHWRadioOff = FALSE;
645 if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) {
646 ntStatus = CONTROLnsRequestIn(pDevice,
647 MESSAGE_TYPE_READ,
648 MAC_REG_GPIOCTL1,
649 MESSAGE_REQUEST_MACREG,
650 1,
651 &byTmp);
652
653 if ( ntStatus != STATUS_SUCCESS ) {
654 spin_unlock_irq(&pDevice->lock);
655 return FALSE;
656 }
657 if ( (byTmp & GPIO3_DATA) == 0 ) {
658 pDevice->bHWRadioOff = TRUE;
659 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
660 } else {
661 MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
662 pDevice->bHWRadioOff = FALSE;
663 }
664
665 }
666
667 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
668 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
669 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01);
670
671 if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) {
672 CARDbRadioPowerOff(pDevice);
673 } else {
674 CARDbRadioPowerOn(pDevice);
675 }
676
677 spin_unlock_irq(&pDevice->lock);
678 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");
679 return TRUE;
680}
681
682static BOOL device_release_WPADEV(PSDevice pDevice)
683{
684 viawget_wpa_header *wpahdr;
685 int ii=0;
686
687
688 if (pDevice->bWPADEVUp==TRUE) {
689 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
690 wpahdr->type = VIAWGET_DEVICECLOSE_MSG;
691 wpahdr->resp_ie_len = 0;
692 wpahdr->req_ie_len = 0;
693 skb_put(pDevice->skb, sizeof(viawget_wpa_header));
694 pDevice->skb->dev = pDevice->wpadev;
695 skb_reset_mac_header(pDevice->skb);
696 pDevice->skb->pkt_type = PACKET_HOST;
697 pDevice->skb->protocol = htons(ETH_P_802_2);
698 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
699 netif_rx(pDevice->skb);
700 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
701
702
703
704
705 while(pDevice->bWPADEVUp==TRUE) {
706 set_current_state(TASK_UNINTERRUPTIBLE);
707 schedule_timeout (HZ/20);
708 ii++;
709 if(ii>20)
710 break;
711 }
712 };
713 return TRUE;
714}
715
716#ifdef CONFIG_PM
717
718static int vt6656_suspend(struct usb_interface *intf, pm_message_t message)
719{
720 PSDevice device = usb_get_intfdata(intf);
721
722 if (!device || !device->dev)
723 return -ENODEV;
724
725 if (device->flags & DEVICE_FLAGS_OPENED)
726 device_close(device->dev);
727
728 usb_put_dev(interface_to_usbdev(intf));
729
730 return 0;
731}
732
733static int vt6656_resume(struct usb_interface *intf)
734{
735 PSDevice device = usb_get_intfdata(intf);
736
737 if (!device || !device->dev)
738 return -ENODEV;
739
740 usb_get_dev(interface_to_usbdev(intf));
741
742 if (!(device->flags & DEVICE_FLAGS_OPENED))
743 device_open(device->dev);
744
745 return 0;
746}
747
748#endif
749
750static const struct net_device_ops device_netdev_ops = {
751 .ndo_open = device_open,
752 .ndo_stop = device_close,
753 .ndo_do_ioctl = device_ioctl,
754 .ndo_get_stats = device_get_stats,
755 .ndo_start_xmit = device_xmit,
756 .ndo_set_multicast_list = device_set_multi,
757};
758
759static int __devinit
760vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
761{
762 u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
763 struct usb_device *udev = interface_to_usbdev(intf);
764 int rc = 0;
765 struct net_device *netdev = NULL;
766 PSDevice pDevice = NULL;
767
768 printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
769 printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
770
771 udev = usb_get_dev(udev);
772 netdev = alloc_etherdev(sizeof(DEVICE_INFO));
773 if (!netdev) {
774 printk(KERN_ERR DEVICE_NAME ": allocate net device failed\n");
775 rc = -ENOMEM;
776 goto err_nomem;
777 }
778
779 pDevice = netdev_priv(netdev);
780 memset(pDevice, 0, sizeof(DEVICE_INFO));
781
782 pDevice->dev = netdev;
783 pDevice->usb = udev;
784
785 device_set_options(pDevice);
786 spin_lock_init(&pDevice->lock);
787
788 pDevice->tx_80211 = device_dma0_tx_80211;
789 pDevice->sMgmtObj.pAdapter = (void *) pDevice;
790
791 netdev->netdev_ops = &device_netdev_ops;
792 netdev->wireless_handlers =
793 (struct iw_handler_def *) &iwctl_handler_def;
794
795 usb_set_intfdata(intf, pDevice);
796 SET_NETDEV_DEV(netdev, &intf->dev);
797 memcpy(pDevice->dev->dev_addr, fake_mac, ETH_ALEN);
798 rc = register_netdev(netdev);
799 if (rc) {
800 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
801 goto err_netdev;
802 }
803
804 usb_device_reset(pDevice);
805
806 {
807 union iwreq_data wrqu;
808 memset(&wrqu, 0, sizeof(wrqu));
809 wrqu.data.flags = RT_INSMOD_EVENT_FLAG;
810 wrqu.data.length = IFNAMSIZ;
811 wireless_send_event(pDevice->dev,
812 IWEVCUSTOM,
813 &wrqu,
814 pDevice->dev->name);
815 }
816
817 return 0;
818
819err_netdev:
820 free_netdev(netdev);
821err_nomem:
822 usb_put_dev(udev);
823
824 return rc;
825}
826
827static void device_free_tx_bufs(PSDevice pDevice)
828{
829 PUSB_SEND_CONTEXT pTxContext;
830 int ii;
831
832 for (ii = 0; ii < pDevice->cbTD; ii++) {
833
834 pTxContext = pDevice->apTD[ii];
835
836 if (pTxContext->pUrb) {
837 usb_kill_urb(pTxContext->pUrb);
838 usb_free_urb(pTxContext->pUrb);
839 }
840 kfree(pTxContext);
841 }
842 return;
843}
844
845
846static void device_free_rx_bufs(PSDevice pDevice)
847{
848 PRCB pRCB;
849 int ii;
850
851 for (ii = 0; ii < pDevice->cbRD; ii++) {
852
853 pRCB = pDevice->apRCB[ii];
854
855 if (pRCB->pUrb) {
856 usb_kill_urb(pRCB->pUrb);
857 usb_free_urb(pRCB->pUrb);
858 }
859
860 if (pRCB->skb)
861 dev_kfree_skb(pRCB->skb);
862 }
863 kfree(pDevice->pRCBMem);
864
865 return;
866}
867
868static void usb_device_reset(PSDevice pDevice)
869{
870 int status;
871 status = usb_reset_device(pDevice->usb);
872 if (status)
873 printk("usb_device_reset fail status=%d\n",status);
874 return ;
875}
876
877static void device_free_int_bufs(PSDevice pDevice)
878{
879 kfree(pDevice->intBuf.pDataBuf);
880 return;
881}
882
883
884static BOOL device_alloc_bufs(PSDevice pDevice) {
885
886 PUSB_SEND_CONTEXT pTxContext;
887 PRCB pRCB;
888 int ii;
889
890
891 for (ii = 0; ii < pDevice->cbTD; ii++) {
892
893 pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
894 if (pTxContext == NULL) {
895 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
896 goto free_tx;
897 }
898 pDevice->apTD[ii] = pTxContext;
899 pTxContext->pDevice = (void *) pDevice;
900
901 pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
902 if (pTxContext->pUrb == NULL) {
903 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
904 goto free_tx;
905 }
906 pTxContext->bBoolInUse = FALSE;
907 }
908
909
910 pDevice->pRCBMem = kmalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
911 if (pDevice->pRCBMem == NULL) {
912 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
913 goto free_tx;
914 }
915
916
917 pDevice->FirstRecvFreeList = NULL;
918 pDevice->LastRecvFreeList = NULL;
919 pDevice->FirstRecvMngList = NULL;
920 pDevice->LastRecvMngList = NULL;
921 pDevice->NumRecvFreeList = 0;
922 memset(pDevice->pRCBMem, 0, (sizeof(RCB) * pDevice->cbRD));
923 pRCB = (PRCB) pDevice->pRCBMem;
924
925 for (ii = 0; ii < pDevice->cbRD; ii++) {
926
927 pDevice->apRCB[ii] = pRCB;
928 pRCB->pDevice = (void *) pDevice;
929
930 pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
931
932 if (pRCB->pUrb == NULL) {
933 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
934 goto free_rx_tx;
935 }
936 pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
937 if (pRCB->skb == NULL) {
938 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
939 goto free_rx_tx;
940 }
941 pRCB->skb->dev = pDevice->dev;
942 pRCB->bBoolInUse = FALSE;
943 EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
944 pDevice->NumRecvFreeList++;
945 pRCB++;
946 }
947
948
949 pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
950 if (pDevice->pControlURB == NULL) {
951 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
952 goto free_rx_tx;
953 }
954
955 pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
956 if (pDevice->pInterruptURB == NULL) {
957 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
958 usb_kill_urb(pDevice->pControlURB);
959 usb_free_urb(pDevice->pControlURB);
960 goto free_rx_tx;
961 }
962
963 pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
964 if (pDevice->intBuf.pDataBuf == NULL) {
965 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
966 usb_kill_urb(pDevice->pControlURB);
967 usb_kill_urb(pDevice->pInterruptURB);
968 usb_free_urb(pDevice->pControlURB);
969 usb_free_urb(pDevice->pInterruptURB);
970 goto free_rx_tx;
971 }
972
973 return TRUE;
974
975free_rx_tx:
976 device_free_rx_bufs(pDevice);
977
978free_tx:
979 device_free_tx_bufs(pDevice);
980
981 return FALSE;
982}
983
984
985
986
987static BOOL device_init_defrag_cb(PSDevice pDevice) {
988 int i;
989 PSDeFragControlBlock pDeF;
990
991
992 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
993 pDeF = &(pDevice->sRxDFCB[i]);
994 if (!device_alloc_frag_buf(pDevice, pDeF)) {
995 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
996 pDevice->dev->name);
997 goto free_frag;
998 };
999 }
1000 pDevice->cbDFCB = CB_MAX_RX_FRAG;
1001 pDevice->cbFreeDFCB = pDevice->cbDFCB;
1002 return TRUE;
1003
1004free_frag:
1005 device_free_frag_bufs(pDevice);
1006 return FALSE;
1007}
1008
1009
1010
1011static void device_free_frag_bufs(PSDevice pDevice) {
1012 PSDeFragControlBlock pDeF;
1013 int i;
1014
1015 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1016
1017 pDeF = &(pDevice->sRxDFCB[i]);
1018
1019 if (pDeF->skb)
1020 dev_kfree_skb(pDeF->skb);
1021 }
1022}
1023
1024
1025
1026BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1027
1028 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1029 if (pDeF->skb == NULL)
1030 return FALSE;
1031 ASSERT(pDeF->skb);
1032 pDeF->skb->dev = pDevice->dev;
1033
1034 return TRUE;
1035}
1036
1037
1038
1039
1040static int device_open(struct net_device *dev) {
1041 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1042
1043 extern SWPAResult wpa_Result;
1044 memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1045 wpa_Result.proto = 0;
1046 wpa_Result.key_mgmt = 0;
1047 wpa_Result.eap_type = 0;
1048 wpa_Result.authenticated = FALSE;
1049 pDevice->fWPA_Authened = FALSE;
1050
1051 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
1052
1053
1054 pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
1055
1056 if (device_alloc_bufs(pDevice) == FALSE) {
1057 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
1058 return -ENOMEM;
1059 }
1060
1061 if (device_init_defrag_cb(pDevice)== FALSE) {
1062 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragement cb fail \n");
1063 goto free_rx_tx;
1064 }
1065
1066 MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
1067 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
1068 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
1069 MP_SET_FLAG(pDevice, fMP_POST_READS);
1070 MP_SET_FLAG(pDevice, fMP_POST_WRITES);
1071
1072
1073 Read_config_file(pDevice);
1074
1075 if (device_init_registers(pDevice, DEVICE_INIT_COLD) == FALSE) {
1076 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
1077 goto free_all;
1078 }
1079
1080 device_set_multi(pDevice->dev);
1081
1082
1083 KeyvInitTable(pDevice,&pDevice->sKey);
1084 memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1085 memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1086 pDevice->bStopTx0Pkt = FALSE;
1087 pDevice->bStopDataPkt = FALSE;
1088 pDevice->bRoaming = FALSE;
1089 pDevice->bIsRoaming = FALSE;
1090 pDevice->bEnableRoaming = FALSE;
1091 if (pDevice->bDiversityRegCtlON) {
1092 device_init_diversity_timer(pDevice);
1093 }
1094
1095 vMgrObjectInit(pDevice);
1096 tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
1097 tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
1098 tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
1099 add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback));
1100 pDevice->int_interval = 100;
1101 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1102
1103 pDevice->bIsRxWorkItemQueued = TRUE;
1104 pDevice->fKillEventPollingThread = FALSE;
1105 pDevice->bEventAvailable = FALSE;
1106
1107 pDevice->bWPADEVUp = FALSE;
1108#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1109 pDevice->bwextstep0 = FALSE;
1110 pDevice->bwextstep1 = FALSE;
1111 pDevice->bwextstep2 = FALSE;
1112 pDevice->bwextstep3 = FALSE;
1113 pDevice->bWPASuppWextEnabled = FALSE;
1114#endif
1115 pDevice->byReAssocCount = 0;
1116
1117 RXvWorkItem(pDevice);
1118 INTvWorkItem(pDevice);
1119
1120
1121 if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1122 spin_lock_irq(&pDevice->lock);
1123 KeybSetDefaultKey( pDevice,
1124 &(pDevice->sKey),
1125 pDevice->byKeyIndex | (1 << 31),
1126 pDevice->uKeyLength,
1127 NULL,
1128 pDevice->abyKey,
1129 KEY_CTL_WEP
1130 );
1131 spin_unlock_irq(&pDevice->lock);
1132 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1133 }
1134
1135 if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1136 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1137 }
1138 else {
1139
1140 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1141
1142 }
1143
1144
1145 netif_stop_queue(pDevice->dev);
1146 pDevice->flags |= DEVICE_FLAGS_OPENED;
1147
1148{
1149 union iwreq_data wrqu;
1150 memset(&wrqu, 0, sizeof(wrqu));
1151 wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1152 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1153}
1154
1155 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1156 return 0;
1157
1158free_all:
1159 device_free_frag_bufs(pDevice);
1160free_rx_tx:
1161 device_free_rx_bufs(pDevice);
1162 device_free_tx_bufs(pDevice);
1163 device_free_int_bufs(pDevice);
1164 usb_kill_urb(pDevice->pControlURB);
1165 usb_kill_urb(pDevice->pInterruptURB);
1166 usb_free_urb(pDevice->pControlURB);
1167 usb_free_urb(pDevice->pInterruptURB);
1168
1169 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1170 return -ENOMEM;
1171}
1172
1173
1174
1175static int device_close(struct net_device *dev) {
1176 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1177 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1178
1179 int uu;
1180
1181 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1182 if (pDevice == NULL)
1183 return -ENODEV;
1184
1185{
1186 union iwreq_data wrqu;
1187 memset(&wrqu, 0, sizeof(wrqu));
1188 wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1189 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1190}
1191
1192 if (pDevice->bLinkPass) {
1193 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1194 mdelay(30);
1195 }
1196
1197device_release_WPADEV(pDevice);
1198
1199 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1200 pMgmt->bShareKeyAlgorithm = FALSE;
1201 pDevice->bEncryptionEnable = FALSE;
1202 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1203 spin_lock_irq(&pDevice->lock);
1204 for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1205 MACvDisableKeyEntry(pDevice,uu);
1206 spin_unlock_irq(&pDevice->lock);
1207
1208 if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1209 MACbShutdown(pDevice);
1210 }
1211 netif_stop_queue(pDevice->dev);
1212 MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1213 MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1214 MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1215 pDevice->fKillEventPollingThread = TRUE;
1216 del_timer(&pDevice->sTimerCommand);
1217 del_timer(&pMgmt->sTimerSecondCallback);
1218
1219 del_timer(&pDevice->sTimerTxData);
1220
1221 if (pDevice->bDiversityRegCtlON) {
1222 del_timer(&pDevice->TimerSQ3Tmax1);
1223 del_timer(&pDevice->TimerSQ3Tmax2);
1224 del_timer(&pDevice->TimerSQ3Tmax3);
1225 }
1226 tasklet_kill(&pDevice->RxMngWorkItem);
1227 tasklet_kill(&pDevice->ReadWorkItem);
1228 tasklet_kill(&pDevice->EventWorkItem);
1229
1230 pDevice->bRoaming = FALSE;
1231 pDevice->bIsRoaming = FALSE;
1232 pDevice->bEnableRoaming = FALSE;
1233 pDevice->bCmdRunning = FALSE;
1234 pDevice->bLinkPass = FALSE;
1235 memset(pMgmt->abyCurrBSSID, 0, 6);
1236 pMgmt->eCurrState = WMAC_STATE_IDLE;
1237
1238 device_free_tx_bufs(pDevice);
1239 device_free_rx_bufs(pDevice);
1240 device_free_int_bufs(pDevice);
1241 device_free_frag_bufs(pDevice);
1242
1243 usb_kill_urb(pDevice->pControlURB);
1244 usb_kill_urb(pDevice->pInterruptURB);
1245 usb_free_urb(pDevice->pControlURB);
1246 usb_free_urb(pDevice->pInterruptURB);
1247
1248 BSSvClearNodeDBTable(pDevice, 0);
1249 pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1250
1251 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1252
1253 return 0;
1254}
1255
1256static void __devexit vt6656_disconnect(struct usb_interface *intf)
1257{
1258 PSDevice device = usb_get_intfdata(intf);
1259
1260 if (!device)
1261 return;
1262
1263 {
1264 union iwreq_data req;
1265 memset(&req, 0, sizeof(req));
1266 req.data.flags = RT_RMMOD_EVENT_FLAG;
1267 wireless_send_event(device->dev, IWEVCUSTOM, &req, NULL);
1268 }
1269
1270 device_release_WPADEV(device);
1271
1272 if (device->firmware)
1273 release_firmware(device->firmware);
1274
1275 usb_set_intfdata(intf, NULL);
1276 usb_put_dev(interface_to_usbdev(intf));
1277
1278 device->flags |= DEVICE_FLAGS_UNPLUG;
1279
1280 if (device->dev) {
1281 unregister_netdev(device->dev);
1282 wpa_set_wpadev(device, 0);
1283 free_netdev(device->dev);
1284 }
1285}
1286
1287static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1288{
1289 PSDevice pDevice = netdev_priv(dev);
1290
1291 spin_lock_irq(&pDevice->lock);
1292
1293 if (unlikely(pDevice->bStopTx0Pkt))
1294 dev_kfree_skb_irq(skb);
1295 else
1296 vDMA0_tx_80211(pDevice, skb);
1297
1298 spin_unlock_irq(&pDevice->lock);
1299
1300 return NETDEV_TX_OK;
1301}
1302
1303static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1304{
1305 PSDevice pDevice = netdev_priv(dev);
1306 struct net_device_stats *stats = &pDevice->stats;
1307
1308 spin_lock_irq(&pDevice->lock);
1309
1310 netif_stop_queue(dev);
1311
1312 if (!pDevice->bLinkPass) {
1313 dev_kfree_skb_irq(skb);
1314 goto out;
1315 }
1316
1317 if (pDevice->bStopDataPkt) {
1318 dev_kfree_skb_irq(skb);
1319 stats->tx_dropped++;
1320 goto out;
1321 }
1322
1323 if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1324 if (netif_queue_stopped(dev))
1325 netif_wake_queue(dev);
1326 }
1327
1328out:
1329 spin_unlock_irq(&pDevice->lock);
1330
1331 return NETDEV_TX_OK;
1332}
1333
1334static unsigned const ethernet_polynomial = 0x04c11db7U;
1335static inline u32 ether_crc(int length, unsigned char *data)
1336{
1337 int crc = -1;
1338
1339 while(--length >= 0) {
1340 unsigned char current_octet = *data++;
1341 int bit;
1342 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1343 crc = (crc << 1) ^
1344 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1345 }
1346 }
1347 return crc;
1348}
1349
1350
1351static unsigned char *kstrstr(const unsigned char *str1,
1352 const unsigned char *str2) {
1353 int str1_len = strlen(str1);
1354 int str2_len = strlen(str2);
1355
1356 while (str1_len >= str2_len) {
1357 str1_len--;
1358 if(memcmp(str1,str2,str2_len)==0)
1359 return (unsigned char *) str1;
1360 str1++;
1361 }
1362 return NULL;
1363}
1364
1365static int Config_FileGetParameter(unsigned char *string,
1366 unsigned char *dest,
1367 unsigned char *source)
1368{
1369 unsigned char buf1[100];
1370 unsigned char buf2[100];
1371 unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1372 int ii;
1373
1374 memset(buf1,0,100);
1375 strcat(buf1, string);
1376 strcat(buf1, "=");
1377 source+=strlen(buf1);
1378
1379
1380 start_p = kstrstr(source,buf1);
1381 if (start_p == NULL)
1382 return FALSE;
1383
1384
1385 for (ii = 1; ; ii++) {
1386 if (memcmp(start_p - ii, "\n", 1) == 0)
1387 break;
1388 if (memcmp(start_p - ii, "#", 1) == 0)
1389 return FALSE;
1390 }
1391
1392
1393 end_p = kstrstr(start_p,"\n");
1394 if (end_p == NULL) {
1395 end_p=start_p+strlen(start_p);
1396 }
1397
1398 memset(buf2,0,100);
1399 memcpy(buf2,start_p,end_p-start_p);
1400 buf2[end_p-start_p]='\0';
1401
1402
1403 start_p = kstrstr(buf2,"=");
1404 if (start_p == NULL)
1405 return FALSE;
1406 memset(buf1,0,100);
1407 strcpy(buf1,start_p+1);
1408
1409
1410 tmp_p = buf1;
1411 while(*tmp_p != 0x00) {
1412 if(*tmp_p==' ')
1413 tmp_p++;
1414 else
1415 break;
1416 }
1417
1418 memcpy(dest,tmp_p,strlen(tmp_p));
1419 return TRUE;
1420}
1421
1422
1423static unsigned char *Config_FileOperation(PSDevice pDevice)
1424{
1425 unsigned char *config_path = CONFIG_PATH;
1426 unsigned char *buffer = NULL;
1427 struct file *filp=NULL;
1428 mm_segment_t old_fs = get_fs();
1429
1430 int result = 0;
1431
1432 set_fs (KERNEL_DS);
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442 filp = filp_open(config_path, O_RDWR, 0);
1443 if (IS_ERR(filp)) {
1444 printk("Config_FileOperation file Not exist\n");
1445 result=-1;
1446 goto error2;
1447 }
1448
1449 if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1450 printk("file %s cann't readable or writable?\n",config_path);
1451 result = -1;
1452 goto error1;
1453 }
1454
1455 buffer = kmalloc(1024, GFP_KERNEL);
1456 if(buffer==NULL) {
1457 printk("allocate mem for file fail?\n");
1458 result = -1;
1459 goto error1;
1460 }
1461
1462 if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1463 printk("read file error?\n");
1464 result = -1;
1465 }
1466
1467error1:
1468 if(filp_close(filp,NULL))
1469 printk("Config_FileOperation:close file fail\n");
1470
1471error2:
1472 set_fs (old_fs);
1473
1474
1475
1476
1477
1478
1479if(result!=0) {
1480 kfree(buffer);
1481 buffer=NULL;
1482}
1483 return buffer;
1484}
1485
1486
1487static int Read_config_file(PSDevice pDevice) {
1488 int result = 0;
1489 unsigned char tmpbuffer[100];
1490 unsigned char *buffer = NULL;
1491
1492
1493 pDevice->config_file.ZoneType = -1;
1494 pDevice->config_file.eAuthenMode = -1;
1495 pDevice->config_file.eEncryptionStatus = -1;
1496
1497 buffer = Config_FileOperation(pDevice);
1498 if (buffer == NULL) {
1499 result =-1;
1500 return result;
1501 }
1502
1503
1504{
1505 memset(tmpbuffer,0,sizeof(tmpbuffer));
1506 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1507 if(memcmp(tmpbuffer,"USA",3)==0) {
1508 pDevice->config_file.ZoneType=ZoneType_USA;
1509 }
1510 else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1511 pDevice->config_file.ZoneType=ZoneType_Japan;
1512 }
1513 else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1514 pDevice->config_file.ZoneType=ZoneType_Europe;
1515 }
1516 else {
1517 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1518 }
1519 }
1520}
1521
1522
1523 {
1524 memset(tmpbuffer,0,sizeof(tmpbuffer));
1525 if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1526 pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1527 }
1528
1529 memset(tmpbuffer,0,sizeof(tmpbuffer));
1530 if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1531 pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1532 }
1533 }
1534
1535 kfree(buffer);
1536 return result;
1537}
1538
1539static void device_set_multi(struct net_device *dev) {
1540 PSDevice pDevice = (PSDevice) netdev_priv(dev);
1541 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1542 u32 mc_filter[2];
1543 int ii;
1544 struct netdev_hw_addr *ha;
1545 BYTE pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1546 BYTE byTmpMode = 0;
1547 int rc;
1548
1549
1550 spin_lock_irq(&pDevice->lock);
1551 rc = CONTROLnsRequestIn(pDevice,
1552 MESSAGE_TYPE_READ,
1553 MAC_REG_RCR,
1554 MESSAGE_REQUEST_MACREG,
1555 1,
1556 &byTmpMode
1557 );
1558 if (rc == 0) pDevice->byRxMode = byTmpMode;
1559
1560 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1561
1562 if (dev->flags & IFF_PROMISC) {
1563 DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1564
1565 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1566 }
1567 else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1568 (dev->flags & IFF_ALLMULTI)) {
1569 CONTROLnsRequestOut(pDevice,
1570 MESSAGE_TYPE_WRITE,
1571 MAC_REG_MAR0,
1572 MESSAGE_REQUEST_MACREG,
1573 8,
1574 pbyData
1575 );
1576 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1577 }
1578 else {
1579 memset(mc_filter, 0, sizeof(mc_filter));
1580 netdev_for_each_mc_addr(ha, dev) {
1581 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1582 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1583 }
1584 for (ii = 0; ii < 4; ii++) {
1585 MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1586 MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1587 }
1588 pDevice->byRxMode &= ~(RCR_UNICAST);
1589 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1590 }
1591
1592 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1593
1594 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1595 pDevice->byRxMode &= ~(RCR_UNICAST);
1596 }
1597 ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1598 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1599 spin_unlock_irq(&pDevice->lock);
1600
1601}
1602
1603
1604static struct net_device_stats *device_get_stats(struct net_device *dev) {
1605 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1606
1607 return &pDevice->stats;
1608}
1609
1610
1611static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1612 PSDevice pDevice = (PSDevice)netdev_priv(dev);
1613 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1614 PSCmdRequest pReq;
1615
1616 struct iwreq *wrq = (struct iwreq *) rq;
1617 int rc =0;
1618
1619 if (pMgmt == NULL) {
1620 rc = -EFAULT;
1621 return rc;
1622 }
1623
1624 switch(cmd) {
1625
1626 case SIOCGIWNAME:
1627 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1628 break;
1629
1630 case SIOCSIWNWID:
1631 rc = -EOPNOTSUPP;
1632 break;
1633
1634 case SIOCGIWNWID:
1635 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1636 rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
1637 #else
1638 rc = -EOPNOTSUPP;
1639 #endif
1640 break;
1641
1642
1643 case SIOCSIWFREQ:
1644 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1645 break;
1646
1647
1648 case SIOCGIWFREQ:
1649 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1650 break;
1651
1652
1653 case SIOCSIWESSID:
1654
1655 {
1656 char essid[IW_ESSID_MAX_SIZE+1];
1657 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1658 rc = -E2BIG;
1659 break;
1660 }
1661 if (copy_from_user(essid, wrq->u.essid.pointer,
1662 wrq->u.essid.length)) {
1663 rc = -EFAULT;
1664 break;
1665 }
1666 rc = iwctl_siwessid(dev, NULL,
1667 &(wrq->u.essid), essid);
1668 }
1669 break;
1670
1671
1672
1673 case SIOCGIWESSID:
1674
1675 {
1676 char essid[IW_ESSID_MAX_SIZE+1];
1677 if (wrq->u.essid.pointer) {
1678 rc = iwctl_giwessid(dev, NULL,
1679 &(wrq->u.essid), essid);
1680 if (copy_to_user(wrq->u.essid.pointer,
1681 essid,
1682 wrq->u.essid.length) )
1683 rc = -EFAULT;
1684 }
1685 }
1686 break;
1687
1688 case SIOCSIWAP:
1689
1690 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1691 break;
1692
1693
1694
1695 case SIOCGIWAP:
1696 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1697 break;
1698
1699
1700
1701 case SIOCSIWNICKN:
1702 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1703 rc = -EOPNOTSUPP;
1704 break;
1705
1706
1707 case SIOCGIWNICKN:
1708 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1709 rc = -EOPNOTSUPP;
1710 break;
1711
1712
1713 case SIOCSIWRATE:
1714 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1715 break;
1716
1717
1718 case SIOCGIWRATE:
1719
1720 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1721 break;
1722
1723
1724 case SIOCSIWRTS:
1725
1726 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
1727 break;
1728
1729
1730 case SIOCGIWRTS:
1731
1732 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1733 break;
1734
1735
1736 case SIOCSIWFRAG:
1737
1738 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1739 break;
1740
1741
1742 case SIOCGIWFRAG:
1743
1744 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1745 break;
1746
1747
1748 case SIOCSIWMODE:
1749 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1750 break;
1751
1752
1753 case SIOCGIWMODE:
1754 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1755 break;
1756
1757
1758 case SIOCSIWENCODE:
1759 {
1760 char abyKey[WLAN_WEP232_KEYLEN];
1761
1762 if (wrq->u.encoding.pointer) {
1763
1764
1765 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
1766 rc = -E2BIG;
1767 break;
1768 }
1769 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
1770 if (copy_from_user(abyKey,
1771 wrq->u.encoding.pointer,
1772 wrq->u.encoding.length)) {
1773 rc = -EFAULT;
1774 break;
1775 }
1776 } else if (wrq->u.encoding.length != 0) {
1777 rc = -EINVAL;
1778 break;
1779 }
1780 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1781 }
1782 break;
1783
1784
1785 case SIOCGIWENCODE:
1786
1787 if (!capable(CAP_NET_ADMIN)) {
1788 rc = -EPERM;
1789 break;
1790 }
1791 {
1792 char abyKey[WLAN_WEP232_KEYLEN];
1793
1794 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1795 if (rc != 0) break;
1796 if (wrq->u.encoding.pointer) {
1797 if (copy_to_user(wrq->u.encoding.pointer,
1798 abyKey,
1799 wrq->u.encoding.length))
1800 rc = -EFAULT;
1801 }
1802 }
1803 break;
1804
1805
1806 case SIOCGIWTXPOW:
1807 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1808 rc = -EOPNOTSUPP;
1809 break;
1810
1811 case SIOCSIWTXPOW:
1812 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1813 rc = -EOPNOTSUPP;
1814 break;
1815
1816 case SIOCSIWRETRY:
1817
1818 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
1819 break;
1820
1821 case SIOCGIWRETRY:
1822
1823 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
1824 break;
1825
1826
1827 case SIOCGIWRANGE:
1828
1829 {
1830 struct iw_range range;
1831
1832 rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
1833 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
1834 rc = -EFAULT;
1835 }
1836
1837 break;
1838
1839 case SIOCGIWPOWER:
1840
1841 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
1842 break;
1843
1844
1845 case SIOCSIWPOWER:
1846
1847 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
1848 break;
1849
1850
1851 case SIOCGIWSENS:
1852
1853 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
1854 break;
1855
1856 case SIOCSIWSENS:
1857 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
1858 rc = -EOPNOTSUPP;
1859 break;
1860
1861 case SIOCGIWAPLIST:
1862 {
1863 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
1864
1865 if (wrq->u.data.pointer) {
1866 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
1867 if (rc == 0) {
1868 if (copy_to_user(wrq->u.data.pointer,
1869 buffer,
1870 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality)))
1871 ))
1872 rc = -EFAULT;
1873 }
1874 }
1875 }
1876 break;
1877
1878
1879#ifdef WIRELESS_SPY
1880
1881 case SIOCSIWSPY:
1882
1883 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1884 rc = -EOPNOTSUPP;
1885 break;
1886
1887
1888 case SIOCGIWSPY:
1889
1890 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1891 rc = -EOPNOTSUPP;
1892 break;
1893
1894#endif
1895
1896 case SIOCGIWPRIV:
1897 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
1898 rc = -EOPNOTSUPP;
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909 break;
1910
1911#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1912 case SIOCSIWAUTH:
1913 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH\n");
1914 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
1915 break;
1916
1917 case SIOCGIWAUTH:
1918 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
1919 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
1920 break;
1921
1922 case SIOCSIWGENIE:
1923 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
1924 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1925 break;
1926
1927 case SIOCGIWGENIE:
1928 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
1929 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1930 break;
1931
1932 case SIOCSIWENCODEEXT:
1933 {
1934 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
1935 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
1936 if(wrq->u.encoding.pointer){
1937 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
1938 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
1939 rc = -E2BIG;
1940 break;
1941 }
1942 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
1943 rc = -EFAULT;
1944 break;
1945 }
1946 }else if(wrq->u.encoding.length != 0){
1947 rc = -EINVAL;
1948 break;
1949 }
1950 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
1951 }
1952 break;
1953
1954 case SIOCGIWENCODEEXT:
1955 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
1956 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
1957 break;
1958
1959 case SIOCSIWMLME:
1960 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
1961 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1962 break;
1963
1964#endif
1965
1966 case IOCTL_CMD_TEST:
1967
1968 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1969 rc = -EFAULT;
1970 break;
1971 } else {
1972 rc = 0;
1973 }
1974 pReq = (PSCmdRequest)rq;
1975
1976
1977
1978 pReq->wResult = MAGIC_CODE;
1979
1980
1981
1982 break;
1983
1984 case IOCTL_CMD_SET:
1985 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
1986 (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
1987 {
1988 rc = -EFAULT;
1989 break;
1990 } else {
1991 rc = 0;
1992 }
1993
1994 if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
1995 return -EBUSY;
1996 }
1997 rc = private_ioctl(pDevice, rq);
1998 clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
1999 break;
2000
2001 case IOCTL_CMD_HOSTAPD:
2002
2003 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2004 rc = -EFAULT;
2005 break;
2006 } else {
2007 rc = 0;
2008 }
2009
2010 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
2011 break;
2012
2013 case IOCTL_CMD_WPA:
2014
2015 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2016 rc = -EFAULT;
2017 break;
2018 } else {
2019 rc = 0;
2020 }
2021
2022 rc = wpa_ioctl(pDevice, &wrq->u.data);
2023 break;
2024
2025 case SIOCETHTOOL:
2026 return ethtool_ioctl(dev, (void *) rq->ifr_data);
2027
2028
2029 default:
2030 rc = -EOPNOTSUPP;
2031 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2032
2033
2034 }
2035
2036 if (pDevice->bCommit) {
2037 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2038 netif_stop_queue(pDevice->dev);
2039 spin_lock_irq(&pDevice->lock);
2040 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
2041 spin_unlock_irq(&pDevice->lock);
2042 }
2043 else {
2044 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2045 spin_lock_irq(&pDevice->lock);
2046
2047 if (pDevice->bLinkPass &&
2048 memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2049 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2050 } else {
2051 pDevice->bLinkPass = FALSE;
2052 pMgmt->eCurrState = WMAC_STATE_IDLE;
2053 memset(pMgmt->abyCurrBSSID, 0, 6);
2054 }
2055 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2056
2057 netif_stop_queue(pDevice->dev);
2058#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2059 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2060 if (!pDevice->bWPASuppWextEnabled)
2061#endif
2062 bScheduleCommand((void *) pDevice,
2063 WLAN_CMD_BSSID_SCAN,
2064 pMgmt->abyDesireSSID);
2065 bScheduleCommand((void *) pDevice,
2066 WLAN_CMD_SSID,
2067 NULL);
2068 spin_unlock_irq(&pDevice->lock);
2069 }
2070 pDevice->bCommit = FALSE;
2071 }
2072
2073
2074 return rc;
2075}
2076
2077
2078static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2079{
2080 u32 ethcmd;
2081
2082 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd)))
2083 return -EFAULT;
2084
2085 switch (ethcmd) {
2086 case ETHTOOL_GDRVINFO: {
2087 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2088 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2089 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2090 if (copy_to_user(useraddr, &info, sizeof(info)))
2091 return -EFAULT;
2092 return 0;
2093 }
2094
2095 }
2096
2097 return -EOPNOTSUPP;
2098}
2099
2100
2101
2102
2103MODULE_DEVICE_TABLE(usb, vt6656_table);
2104
2105static struct usb_driver vt6656_driver = {
2106 .name = DEVICE_NAME,
2107 .probe = vt6656_probe,
2108 .disconnect = vt6656_disconnect,
2109 .id_table = vt6656_table,
2110#ifdef CONFIG_PM
2111 .suspend = vt6656_suspend,
2112 .resume = vt6656_resume,
2113#endif
2114};
2115
2116static int __init vt6656_init_module(void)
2117{
2118 printk(KERN_NOTICE DEVICE_FULL_DRV_NAM " " DEVICE_VERSION);
2119 return usb_register(&vt6656_driver);
2120}
2121
2122static void __exit vt6656_cleanup_module(void)
2123{
2124 usb_deregister(&vt6656_driver);
2125}
2126
2127module_init(vt6656_init_module);
2128module_exit(vt6656_cleanup_module);
2129
