2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
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.
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.
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.
21 * Purpose: driver entry for initial, open, close, tx and rx.
29 * vntwusb_found1 - module initial (insmod) driver entry
30 * device_remove1 - module remove entry
31 * device_open - allocate dma/descripter resource & initial mac/bbp function
32 * device_xmit - asynchrous data tx function
33 * device_set_multi - set mac filter
34 * device_ioctl - ioctl entry
35 * device_close - shutdown mac/bbp & free dma/descripter resource
36 * device_alloc_frag_buf - rx fragement pre-allocated function
37 * device_free_tx_bufs - free tx buffer function
38 * device_dma0_tx_80211- tx 802.11 frame via dma0
39 * device_dma0_xmit- tx PS bufferred frame via dma0
40 * device_init_registers- initial MAC & BBP & RF internal registers.
41 * device_init_rings- initial tx/rx ring buffer
42 * device_init_defrag_cb- initial & allocate de-fragement buffer.
43 * device_tx_srv- tx interrupt service function
49 #if !defined(__DEVICE_H__)
52 #if !defined(__CARD_H__)
55 #if !defined(__TBIT_H__)
58 #if !defined(__BASEBAND_H__)
61 #if !defined(__MAC_H__)
64 #if !defined(__TETHER_H__)
67 #if !defined(__WMGR_H__)
70 #if !defined(__WCTL_H__)
73 #if !defined(__POWER_H__)
76 #if !defined(__WCMD_H__)
79 #if !defined(__IOCMD_H__)
82 #if !defined(__TCRC_H__)
85 #if !defined(__RXTX_H__)
88 #if !defined(__BSSDB_H__)
91 #if !defined(__HOSTAP_H__)
94 #if !defined(__WPACTL_H__)
97 #if !defined(__IOCTL_H__)
100 #if !defined(__IWCTL_H__)
103 #if !defined(__DPC_H__)
106 #if !defined(__IOCMD_H__)
109 #if !defined(__DATARATE_H__)
110 #include "datarate.h"
112 #if !defined(__RF_H__)
115 #if !defined(__FIRMWARE_H__)
116 #include "firmware.h"
119 #if !defined(__MAC_H__)
123 #if !defined(__RNDIS_H__)
126 #if !defined(__CONTROL_H__)
129 #if !defined (_CHANNEL_H_)
132 #if !defined(__INT_H__)
135 #if !defined(__IOWPA_H__)
139 /*--------------------- Static Definitions -------------------------*/
140 //static int msglevel =MSG_LEVEL_DEBUG;
141 static int msglevel =MSG_LEVEL_INFO;
144 // Define module options
147 // Version Information
148 #define DRIVER_AUTHOR "VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>"
149 MODULE_AUTHOR(DRIVER_AUTHOR);
150 MODULE_LICENSE("GPL");
151 MODULE_DESCRIPTION(DEVICE_FULL_DRV_NAM);
153 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,15)
154 #define DEVICE_PARAM(N,D) \
155 static int N[MAX_UINTS]=OPTION_DEFAULT;\
156 module_param_array(N, int, NULL, 0);\
157 MODULE_PARM_DESC(N, D);
160 #define DEVICE_PARAM(N,D) \
161 static const int N[MAX_UINTS]=OPTION_DEFAULT;\
162 MODULE_PARM(N, "1-" __MODULE_STRING(MAX_UINTS) "i");\
163 MODULE_PARM_DESC(N, D);
166 #define RX_DESC_MIN0 16
167 #define RX_DESC_MAX0 128
168 #define RX_DESC_DEF0 64
169 DEVICE_PARAM(RxDescriptors0,"Number of receive usb desc buffer");
172 #define TX_DESC_MIN0 16
173 #define TX_DESC_MAX0 128
174 #define TX_DESC_DEF0 64
175 DEVICE_PARAM(TxDescriptors0,"Number of transmit usb desc buffer");
178 #define CHANNEL_MIN 1
179 #define CHANNEL_MAX 14
180 #define CHANNEL_DEF 6
182 DEVICE_PARAM(Channel, "Channel number");
185 /* PreambleType[] is the preamble length used for transmit.
186 0: indicate allows long preamble type
187 1: indicate allows short preamble type
190 #define PREAMBLE_TYPE_DEF 1
192 DEVICE_PARAM(PreambleType, "Preamble Type");
195 #define RTS_THRESH_MIN 512
196 #define RTS_THRESH_MAX 2347
197 #define RTS_THRESH_DEF 2347
199 DEVICE_PARAM(RTSThreshold, "RTS threshold");
202 #define FRAG_THRESH_MIN 256
203 #define FRAG_THRESH_MAX 2346
204 #define FRAG_THRESH_DEF 2346
206 DEVICE_PARAM(FragThreshold, "Fragmentation threshold");
209 #define DATA_RATE_MIN 0
210 #define DATA_RATE_MAX 13
211 #define DATA_RATE_DEF 13
213 0: indicate 1 Mbps 0x02
214 1: indicate 2 Mbps 0x04
215 2: indicate 5.5 Mbps 0x0B
216 3: indicate 11 Mbps 0x16
217 4: indicate 6 Mbps 0x0c
218 5: indicate 9 Mbps 0x12
219 6: indicate 12 Mbps 0x18
220 7: indicate 18 Mbps 0x24
221 8: indicate 24 Mbps 0x30
222 9: indicate 36 Mbps 0x48
223 10: indicate 48 Mbps 0x60
224 11: indicate 54 Mbps 0x6c
225 12: indicate 72 Mbps 0x90
226 13: indicate auto rate
229 DEVICE_PARAM(ConnectionRate, "Connection data rate");
231 #define OP_MODE_MAX 2
232 #define OP_MODE_DEF 0
233 #define OP_MODE_MIN 0
235 DEVICE_PARAM(OPMode, "Infrastruct, adhoc, AP mode ");
237 /* OpMode[] is used for transmit.
238 0: indicate infrastruct mode used
239 1: indicate adhoc mode used
240 2: indicate AP mode used
245 0: indicate disable power saving mode
246 1: indicate enable power saving mode
249 #define PS_MODE_DEF 0
251 DEVICE_PARAM(PSMode, "Power saving mode");
254 #define SHORT_RETRY_MIN 0
255 #define SHORT_RETRY_MAX 31
256 #define SHORT_RETRY_DEF 8
259 DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits");
261 #define LONG_RETRY_MIN 0
262 #define LONG_RETRY_MAX 15
263 #define LONG_RETRY_DEF 4
266 DEVICE_PARAM(LongRetryLimit, "long frame retry limits");
269 /* BasebandType[] baseband type selected
270 0: indicate 802.11a type
271 1: indicate 802.11b type
272 2: indicate 802.11g type
274 #define BBP_TYPE_MIN 0
275 #define BBP_TYPE_MAX 2
276 #define BBP_TYPE_DEF 2
278 DEVICE_PARAM(BasebandType, "baseband type");
283 0: indicate disable 802.11h
284 1: indicate enable 802.11h
287 #define X80211h_MODE_DEF 0
289 DEVICE_PARAM(b80211hEnable, "802.11h mode");
293 // Static vars definitions
298 static struct usb_device_id vntwusb_table[] = {
299 {USB_DEVICE(VNT_USB_VENDOR_ID, VNT_USB_PRODUCT_ID)},
306 // Frequency list (map channels to frequencies)
308 static const long frequency_list[] = {
309 2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484,
310 4915, 4920, 4925, 4935, 4940, 4945, 4960, 4980,
311 5035, 5040, 5045, 5055, 5060, 5080, 5170, 5180, 5190, 5200, 5210, 5220, 5230, 5240,
312 5260, 5280, 5300, 5320, 5500, 5520, 5540, 5560, 5580, 5600, 5620, 5640, 5660, 5680,
313 5700, 5745, 5765, 5785, 5805, 5825
317 #ifndef IW_ENCODE_NOKEY
318 #define IW_ENCODE_NOKEY 0x0800
319 #define IW_ENCODE_MODE (IW_ENCODE_DISABLED | IW_ENCODE_RESTRICTED | IW_ENCODE_OPEN)
322 #if WIRELESS_EXT > 12
323 static const struct iw_handler_def iwctl_handler_def;
325 struct iw_request_info {};
326 #endif //WIRELESS_EXT > 12
329 #endif /* WIRELESS_EXT */
333 /*--------------------- Static Functions --------------------------*/
334 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
336 static int vntwusb_found1(struct usb_interface *intf, const struct usb_device_id *id);
337 static void vntwusb_disconnect(struct usb_interface *intf);
338 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
339 static int vntwusb_suspend(struct usb_interface *intf, pm_message_t message);
340 static int vntwusb_resume(struct usb_interface *intf);
344 static void* vntwusb_found1(struct usb_device *udev, UINT interface, const struct usb_device_id *id);
345 static void vntwusb_disconnect(struct usb_device *udev, void *ptr);
347 static struct net_device_stats *device_get_stats(struct net_device *dev);
348 static int device_open(struct net_device *dev);
349 static int device_xmit(struct sk_buff *skb, struct net_device *dev);
350 static void device_set_multi(struct net_device *dev);
351 static int device_close(struct net_device *dev);
352 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
354 static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType);
355 static BOOL device_init_defrag_cb(PSDevice pDevice);
356 static void device_init_diversity_timer(PSDevice pDevice);
357 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
359 static int ethtool_ioctl(struct net_device *dev, void *useraddr);
360 static void device_free_tx_bufs(PSDevice pDevice);
361 static void device_free_rx_bufs(PSDevice pDevice);
362 static void device_free_int_bufs(PSDevice pDevice);
363 static void device_free_frag_bufs(PSDevice pDevice);
364 static BOOL device_alloc_bufs(PSDevice pDevice);
366 static int Read_config_file(PSDevice pDevice);
367 static UCHAR *Config_FileOperation(PSDevice pDevice);
368 static int Config_FileGetParameter(UCHAR *string, UCHAR *dest,UCHAR *source);
370 //2008-0714<Add>by Mike Liu
371 static BOOL device_release_WPADEV(PSDevice pDevice);
373 //2007-1107-01<Add>by MikeLiu
374 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
375 static void usb_device_reset(PSDevice pDevice);
380 /*--------------------- Export Variables --------------------------*/
382 /*--------------------- Export Functions --------------------------*/
386 device_set_options(PSDevice pDevice) {
388 BYTE abyBroadcastAddr[U_ETHER_ADDR_LEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
389 BYTE abySNAP_RFC1042[U_ETHER_ADDR_LEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
390 BYTE abySNAP_Bridgetunnel[U_ETHER_ADDR_LEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
393 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, U_ETHER_ADDR_LEN);
394 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, U_ETHER_ADDR_LEN);
395 memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, U_ETHER_ADDR_LEN);
397 pDevice->cbTD = TX_DESC_DEF0;
398 pDevice->cbRD = RX_DESC_DEF0;
399 pDevice->uChannel = CHANNEL_DEF;
400 pDevice->wRTSThreshold = RTS_THRESH_DEF;
401 pDevice->wFragmentationThreshold = FRAG_THRESH_DEF;
402 pDevice->byShortRetryLimit = SHORT_RETRY_DEF;
403 pDevice->byLongRetryLimit = LONG_RETRY_DEF;
404 pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
405 pDevice->byShortPreamble = PREAMBLE_TYPE_DEF;
406 pDevice->ePSMode = PS_MODE_DEF;
407 pDevice->b11hEnable = X80211h_MODE_DEF;
408 pDevice->eOPMode = OP_MODE_DEF;
409 pDevice->uConnectionRate = DATA_RATE_DEF;
410 if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = TRUE;
411 pDevice->byBBType = BBP_TYPE_DEF;
412 pDevice->byPacketType = pDevice->byBBType;
413 pDevice->byAutoFBCtrl = AUTO_FB_0;
414 pDevice->bUpdateBBVGA = TRUE;
415 pDevice->byFOETuning = 0;
416 pDevice->byAutoPwrTunning = 0;
417 pDevice->wCTSDuration = 0;
418 pDevice->byPreambleType = 0;
419 pDevice->bExistSWNetAddr = FALSE;
420 // pDevice->bDiversityRegCtlON = TRUE;
421 pDevice->bDiversityRegCtlON = FALSE;
425 static VOID device_init_diversity_timer(PSDevice pDevice) {
427 init_timer(&pDevice->TimerSQ3Tmax1);
428 pDevice->TimerSQ3Tmax1.data = (ULONG)pDevice;
429 pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
430 pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
432 init_timer(&pDevice->TimerSQ3Tmax2);
433 pDevice->TimerSQ3Tmax2.data = (ULONG)pDevice;
434 pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
435 pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
437 init_timer(&pDevice->TimerSQ3Tmax3);
438 pDevice->TimerSQ3Tmax3.data = (ULONG)pDevice;
439 pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerSQ3Tmax3CallBack;
440 pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
447 // Initialiation of MAC & BBP registers
450 static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType)
452 BYTE abyBroadcastAddr[U_ETHER_ADDR_LEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
453 BYTE abySNAP_RFC1042[U_ETHER_ADDR_LEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
454 BYTE abySNAP_Bridgetunnel[U_ETHER_ADDR_LEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
457 CMD_CARD_INIT sInitCmd;
458 NTSTATUS ntStatus = STATUS_SUCCESS;
459 RSP_CARD_INIT sInitRsp;
460 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
462 BYTE byCalibTXIQ = 0;
463 BYTE byCalibTXDC = 0;
464 BYTE byCalibRXIQ = 0;
466 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---->INIbInitAdapter. [%d][%d]\n", InitType, pDevice->byPacketType);
467 spin_lock_irq(&pDevice->lock);
468 if (InitType == DEVICE_INIT_COLD) {
469 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, U_ETHER_ADDR_LEN);
470 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, U_ETHER_ADDR_LEN);
471 memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, U_ETHER_ADDR_LEN);
473 if ( !FIRMWAREbCheckVersion(pDevice) ) {
474 if (FIRMWAREbDownload(pDevice) == TRUE) {
475 if (FIRMWAREbBrach2Sram(pDevice) == FALSE) {
476 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbBrach2Sram fail \n");
477 spin_unlock_irq(&pDevice->lock);
482 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbDownload fail \n");
483 spin_unlock_irq(&pDevice->lock);
488 if ( !BBbVT3184Init(pDevice) ) {
489 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" BBbVT3184Init fail \n");
490 spin_unlock_irq(&pDevice->lock);
495 sInitCmd.byInitClass = (BYTE)InitType;
496 sInitCmd.bExistSWNetAddr = (BYTE) pDevice->bExistSWNetAddr;
498 sInitCmd.bySWNetAddr[ii] = pDevice->abyCurrentNetAddr[ii];
499 sInitCmd.byShortRetryLimit = pDevice->byShortRetryLimit;
500 sInitCmd.byLongRetryLimit = pDevice->byLongRetryLimit;
502 //issue Card_init command to device
503 ntStatus = CONTROLnsRequestOut(pDevice,
504 MESSAGE_TYPE_CARDINIT,
507 sizeof(CMD_CARD_INIT),
508 (PBYTE) &(sInitCmd));
510 if ( ntStatus != STATUS_SUCCESS ) {
511 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Issue Card init fail \n");
512 spin_unlock_irq(&pDevice->lock);
515 if (InitType == DEVICE_INIT_COLD) {
517 ntStatus = CONTROLnsRequestIn(pDevice,MESSAGE_TYPE_INIT_RSP,0,0,sizeof(RSP_CARD_INIT), (PBYTE) &(sInitRsp));
519 if (ntStatus != STATUS_SUCCESS) {
520 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Cardinit request in status fail!\n");
521 spin_unlock_irq(&pDevice->lock);
525 //Local ID for AES functions
526 ntStatus = CONTROLnsRequestIn(pDevice,
529 MESSAGE_REQUEST_MACREG,
531 &pDevice->byLocalID);
533 if ( ntStatus != STATUS_SUCCESS ) {
534 spin_unlock_irq(&pDevice->lock);
538 // Do MACbSoftwareReset in MACvInitialize
540 pDevice->bCCK = TRUE;
541 pDevice->bProtectMode = FALSE; //Only used in 11g type, sync with ERP IE
542 pDevice->bNonERPPresent = FALSE;
543 pDevice->bBarkerPreambleMd = FALSE;
544 if ( pDevice->bFixRate ) {
545 pDevice->wCurrentRate = (WORD) pDevice->uConnectionRate;
547 if ( pDevice->byBBType == BB_TYPE_11B )
548 pDevice->wCurrentRate = RATE_11M;
550 pDevice->wCurrentRate = RATE_54M;
553 CHvInitChannelTable(pDevice);
555 pDevice->byTopOFDMBasicRate = RATE_24M;
556 pDevice->byTopCCKBasicRate = RATE_1M;
557 pDevice->byRevId = 0; //Target to IF pin while programming to RF chip.
558 pDevice->byCurPwr = 0xFF;
560 pDevice->byCCKPwr = pDevice->abyEEPROM[EEP_OFS_PWR_CCK];
561 pDevice->byOFDMPwrG = pDevice->abyEEPROM[EEP_OFS_PWR_OFDMG];
563 for (ii=0;ii<14;ii++) {
564 pDevice->abyCCKPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_CCK_PWR_TBL];
565 if (pDevice->abyCCKPwrTbl[ii] == 0)
566 pDevice->abyCCKPwrTbl[ii] = pDevice->byCCKPwr;
567 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDM_PWR_TBL];
568 if (pDevice->abyOFDMPwrTbl[ii] == 0)
569 pDevice->abyOFDMPwrTbl[ii] = pDevice->byOFDMPwrG;
572 //original zonetype is USA,but customize zonetype is europe,
573 // then need recover 12,13 ,14 channel with 11 channel
574 if(((pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Japan) ||
575 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Europe))&&
576 (pDevice->byOriginalZonetype == ZoneType_USA)) {
577 for(ii=11;ii<14;ii++) {
578 pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];
579 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];
583 //{{ RobertYu: 20041124
584 pDevice->byOFDMPwrA = 0x34; // same as RFbMA2829SelectChannel
585 // Load OFDM A Power Table
586 for (ii=0;ii<CB_MAX_CHANNEL_5G;ii++) { //RobertYu:20041224, bug using CB_MAX_CHANNEL
587 pDevice->abyOFDMAPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDMA_PWR_TBL];
588 if (pDevice->abyOFDMAPwrTbl[ii] == 0)
589 pDevice->abyOFDMAPwrTbl[ii] = pDevice->byOFDMPwrA;
593 byAntenna = pDevice->abyEEPROM[EEP_OFS_ANTENNA];
594 if (byAntenna & EEP_ANTINV)
595 pDevice->bTxRxAntInv = TRUE;
597 pDevice->bTxRxAntInv = FALSE;
599 byAntenna &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
601 if (byAntenna == 0) // if not set default is All
602 byAntenna = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
604 if (byAntenna == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
605 pDevice->byAntennaCount = 2;
606 pDevice->byTxAntennaMode = ANT_B;
607 pDevice->dwTxAntennaSel = 1;
608 pDevice->dwRxAntennaSel = 1;
609 if (pDevice->bTxRxAntInv == TRUE)
610 pDevice->byRxAntennaMode = ANT_A;
612 pDevice->byRxAntennaMode = ANT_B;
614 if (pDevice->bDiversityRegCtlON)
615 pDevice->bDiversityEnable = TRUE;
617 pDevice->bDiversityEnable = FALSE;
619 pDevice->bDiversityEnable = FALSE;
620 pDevice->byAntennaCount = 1;
621 pDevice->dwTxAntennaSel = 0;
622 pDevice->dwRxAntennaSel = 0;
623 if (byAntenna & EEP_ANTENNA_AUX) {
624 pDevice->byTxAntennaMode = ANT_A;
625 if (pDevice->bTxRxAntInv == TRUE)
626 pDevice->byRxAntennaMode = ANT_B;
628 pDevice->byRxAntennaMode = ANT_A;
630 pDevice->byTxAntennaMode = ANT_B;
631 if (pDevice->bTxRxAntInv == TRUE)
632 pDevice->byRxAntennaMode = ANT_A;
634 pDevice->byRxAntennaMode = ANT_B;
637 pDevice->ulDiversityNValue = 100*255;
638 pDevice->ulDiversityMValue = 100*16;
640 pDevice->byTMax2 = 4;
641 pDevice->ulSQ3TH = 0;
642 pDevice->byTMax3 = 64;
643 // -----------------------------------------------------------------
645 //Get Auto Fall Back Type
646 pDevice->byAutoFBCtrl = AUTO_FB_0;
649 pDevice->uScanTime = WLAN_SCAN_MINITIME;
652 //pDevice->NetworkType = Ndis802_11Automode;
653 pDevice->eConfigPHYMode = PHY_TYPE_AUTO;
654 pDevice->byBBType = BB_TYPE_11G;
656 // initialize BBP registers
657 pDevice->ulTxPower = 25;
660 pDevice->byMinChannel = 1;
661 pDevice->byMaxChannel = CB_MAX_CHANNEL;
664 pDevice->byRFType = sInitRsp.byRFType;
666 if ((pDevice->byRFType & RF_EMU) != 0) {
667 // force change RevID for VT3253 emu
668 pDevice->byRevId = 0x80;
671 // Load EEPROM calibrated vt3266 parameters
672 if (pDevice->byRFType == RF_VT3226D0) {
673 if((pDevice->abyEEPROM[EEP_OFS_MAJOR_VER] == 0x1) &&
674 (pDevice->abyEEPROM[EEP_OFS_MINOR_VER] >= 0x4)) {
675 byCalibTXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_IQ];
676 byCalibTXDC = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_DC];
677 byCalibRXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_RX_IQ];
678 if( (byCalibTXIQ || byCalibTXDC || byCalibRXIQ) ) {
679 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFF, 0x03); // CR255, Set BB to support TX/RX IQ and DC compensation Mode
680 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFB, byCalibTXIQ); // CR251, TX I/Q Imbalance Calibration
681 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFC, byCalibTXDC); // CR252, TX DC-Offset Calibration
682 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFD, byCalibRXIQ); // CR253, RX I/Q Imbalance Calibration
684 // turn off BB Calibration compensation
685 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFF, 0x0); // CR255
689 pMgmt->eScanType = WMAC_SCAN_PASSIVE;
690 pMgmt->uCurrChannel = pDevice->uChannel;
691 pMgmt->uIBSSChannel = pDevice->uChannel;
692 CARDbSetMediaChannel(pDevice, pMgmt->uCurrChannel);
694 // get Permanent network address
695 MEMvCopy(pDevice->abyPermanentNetAddr,&(sInitRsp.byNetAddr[0]),6)
696 MEMvCopy(pDevice->abyCurrentNetAddr, pDevice->abyPermanentNetAddr, U_ETHER_ADDR_LEN);
698 // if exist SW network address, use SW network address.
700 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %02x-%02x-%02x=%02x-%02x-%02x\n",
701 pDevice->abyCurrentNetAddr[0],
702 pDevice->abyCurrentNetAddr[1],
703 pDevice->abyCurrentNetAddr[2],
704 pDevice->abyCurrentNetAddr[3],
705 pDevice->abyCurrentNetAddr[4],
706 pDevice->abyCurrentNetAddr[5]);
711 // Set BB and packet type at the same time.
712 // Set Short Slot Time, xIFS, and RSPINF.
713 if (pDevice->byBBType == BB_TYPE_11A) {
714 CARDbAddBasicRate(pDevice, RATE_6M);
715 pDevice->bShortSlotTime = TRUE;
717 CARDbAddBasicRate(pDevice, RATE_1M);
718 pDevice->bShortSlotTime = FALSE;
720 BBvSetShortSlotTime(pDevice);
721 CARDvSetBSSMode(pDevice);
723 if (pDevice->bUpdateBBVGA) {
724 pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
725 pDevice->byBBVGANew = pDevice->byBBVGACurrent;
726 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
729 pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];
730 pDevice->bHWRadioOff = FALSE;
731 if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) {
732 ntStatus = CONTROLnsRequestIn(pDevice,
735 MESSAGE_REQUEST_MACREG,
739 if ( ntStatus != STATUS_SUCCESS ) {
740 spin_unlock_irq(&pDevice->lock);
743 if ( (byTmp & GPIO3_DATA) == 0 ) {
744 pDevice->bHWRadioOff = TRUE;
745 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
747 MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
748 pDevice->bHWRadioOff = FALSE;
751 } //EEP_RADIOCTL_ENABLE
753 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
754 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
755 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01);
757 if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) {
758 CARDbRadioPowerOff(pDevice);
760 CARDbRadioPowerOn(pDevice);
763 spin_unlock_irq(&pDevice->lock);
764 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");
768 static BOOL device_release_WPADEV(PSDevice pDevice)
770 viawget_wpa_header *wpahdr;
772 // wait_queue_head_t Set_wait;
773 //send device close to wpa_supplicnat layer
774 if (pDevice->bWPADEVUp==TRUE) {
775 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
776 wpahdr->type = VIAWGET_DEVICECLOSE_MSG;
777 wpahdr->resp_ie_len = 0;
778 wpahdr->req_ie_len = 0;
779 skb_put(pDevice->skb, sizeof(viawget_wpa_header));
780 pDevice->skb->dev = pDevice->wpadev;
781 //2008-4-3 modify by Chester for wpa
782 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
783 pDevice->skb->mac_header = pDevice->skb->data;
785 pDevice->skb->mac.raw = pDevice->skb->data;
787 pDevice->skb->pkt_type = PACKET_HOST;
788 pDevice->skb->protocol = htons(ETH_P_802_2);
789 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
790 netif_rx(pDevice->skb);
791 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
793 //wait release WPADEV
794 // init_waitqueue_head(&Set_wait);
795 // wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ); //1s wait
796 while(pDevice->bWPADEVUp==TRUE) {
797 set_current_state(TASK_UNINTERRUPTIBLE);
798 schedule_timeout (HZ/20); //wait 50ms
807 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
808 static int vntwusb_suspend(struct usb_interface *intf, pm_message_t message)
810 PSDevice pDevice = usb_get_intfdata(intf);
811 struct net_device *dev = pDevice->dev;
813 printk("VNTWUSB Suspend Start======>\n");
815 if(pDevice->flags & DEVICE_FLAGS_OPENED)
819 usb_put_dev(interface_to_usbdev(intf));
823 static int vntwusb_resume(struct usb_interface *intf)
825 PSDevice pDevice = usb_get_intfdata(intf);
826 struct net_device *dev = pDevice->dev;
828 printk("VNTWUSB Resume Start======>\n");
830 usb_get_dev(interface_to_usbdev(intf));
831 if(!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
832 if(device_open(dev)!=0)
833 printk("VNTWUSB Resume Start======>open fail\n");
840 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
843 vntwusb_found1(struct usb_interface *intf, const struct usb_device_id *id)
847 vntwusb_found1(struct usb_device *udev, UINT interface, const struct usb_device_id *id)
850 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
851 BYTE fake_mac[U_ETHER_ADDR_LEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};//fake MAC address
853 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
854 struct usb_device *udev = interface_to_usbdev(intf);
857 struct net_device *netdev = NULL;
858 PSDevice pDevice = NULL;
861 printk(KERN_NOTICE "%s Ver. %s\n",DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
862 printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
864 //2008-0922-01<Add>by MikeLiu, add usb counter.
865 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
866 udev = usb_get_dev(udev);
869 pDevice = kmalloc(sizeof(DEVICE_INFO), GFP_KERNEL);
870 if (pDevice == NULL) {
871 printk(KERN_ERR DEVICE_NAME ": allocate usb device failed \n");
874 memset(pDevice, 0, sizeof(DEVICE_INFO));
876 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
877 netdev = alloc_etherdev(0);
879 netdev = init_etherdev(netdev, 0);
882 if (netdev == NULL) {
883 printk(KERN_ERR DEVICE_NAME ": allocate net device failed \n");
887 pDevice->dev = netdev;
890 // Chain it all together
891 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
892 SET_MODULE_OWNER(netdev);
895 // Set initial settings
896 device_set_options(pDevice);
897 spin_lock_init(&pDevice->lock);
899 pDevice->tx_80211 = device_dma0_tx_80211;
900 pDevice->sMgmtObj.pAdapter = (PVOID)pDevice;
902 netdev->priv = pDevice;
903 netdev->open = device_open;
904 netdev->hard_start_xmit = device_xmit;
905 netdev->stop = device_close;
906 netdev->get_stats = device_get_stats;
907 netdev->set_multicast_list = device_set_multi;
908 netdev->do_ioctl = device_ioctl;
911 //2007-0508-01<Add>by MikeLiu
912 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
913 netdev->get_wireless_stats = iwctl_get_wireless_stats;
916 #if WIRELESS_EXT > 12
917 netdev->wireless_handlers = (struct iw_handler_def *)&iwctl_handler_def;
918 // netdev->wireless_handlers = NULL;
919 #endif /* WIRELESS_EXT > 12 */
920 #endif /* WIRELESS_EXT */
922 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
924 //2008-0623-01<Remark>by MikeLiu
925 //2007-0821-01<Add>by MikeLiu
926 // #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
927 usb_set_intfdata(intf, pDevice);
928 SET_NETDEV_DEV(netdev, &intf->dev);
930 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
931 memcpy(pDevice->dev->dev_addr, fake_mac, U_ETHER_ADDR_LEN); //use fake mac address
933 rc = register_netdev(netdev);
935 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
940 //2008-0623-02<Remark>by MikeLiu
941 //2007-0821-01<Add>by MikeLiu
942 //#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)
943 //usb_set_intfdata(intf, pDevice);
944 //SET_NETDEV_DEV(netdev, &intf->dev);
947 //2008-07-21-01<Add>by MikeLiu
949 if(wpa_set_wpadev(pDevice, 1)!=0) {
950 printk("Fail to Register WPADEV?\n");
951 unregister_netdev(pDevice->dev);
956 //2007-1107-03<Add>by MikeLiu
957 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
958 usb_device_reset(pDevice);
963 union iwreq_data wrqu;
964 memset(&wrqu, 0, sizeof(wrqu));
965 wrqu.data.flags = RT_INSMOD_EVENT_FLAG;
966 wrqu.data.length =IFNAMSIZ;
967 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, pDevice->dev->name);
978 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
980 //2008-0922-01<Add>by MikeLiu, decrease usb counter.
990 static VOID device_free_tx_bufs(PSDevice pDevice) {
991 PUSB_SEND_CONTEXT pTxContext;
994 for (ii = 0; ii < pDevice->cbTD; ii++) {
996 pTxContext = pDevice->apTD[ii];
998 if (pTxContext->pUrb) {
999 vntwusb_unlink_urb(pTxContext->pUrb);
1000 usb_free_urb(pTxContext->pUrb);
1009 static VOID device_free_rx_bufs(PSDevice pDevice) {
1013 for (ii = 0; ii < pDevice->cbRD; ii++) {
1015 pRCB = pDevice->apRCB[ii];
1018 vntwusb_unlink_urb(pRCB->pUrb);
1019 usb_free_urb(pRCB->pUrb);
1023 dev_kfree_skb(pRCB->skb);
1025 if (pDevice->pRCBMem)
1026 kfree(pDevice->pRCBMem);
1031 //2007-1107-02<Add>by MikeLiu
1032 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
1033 static void usb_device_reset(PSDevice pDevice)
1036 status = usb_reset_device(pDevice->usb);
1038 printk("usb_device_reset fail status=%d\n",status);
1043 static VOID device_free_int_bufs(PSDevice pDevice) {
1045 if (pDevice->intBuf.pDataBuf != NULL)
1046 kfree(pDevice->intBuf.pDataBuf);
1051 static BOOL device_alloc_bufs(PSDevice pDevice) {
1053 PUSB_SEND_CONTEXT pTxContext;
1058 for (ii = 0; ii < pDevice->cbTD; ii++) {
1060 pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
1061 if (pTxContext == NULL) {
1062 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
1065 pDevice->apTD[ii] = pTxContext;
1066 pTxContext->pDevice = (PVOID) pDevice;
1068 pTxContext->pUrb = vntwusb_alloc_urb(0);;
1069 if (pTxContext->pUrb == NULL) {
1070 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
1073 pTxContext->bBoolInUse = FALSE;
1077 pDevice->pRCBMem = kmalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
1078 if (pDevice->pRCBMem == NULL) {
1079 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
1084 pDevice->FirstRecvFreeList = NULL;
1085 pDevice->LastRecvFreeList = NULL;
1086 pDevice->FirstRecvMngList = NULL;
1087 pDevice->LastRecvMngList = NULL;
1088 pDevice->NumRecvFreeList = 0;
1089 memset(pDevice->pRCBMem, 0, (sizeof(RCB) * pDevice->cbRD));
1090 pRCB = (PRCB) pDevice->pRCBMem;
1092 for (ii = 0; ii < pDevice->cbRD; ii++) {
1094 pDevice->apRCB[ii] = pRCB;
1095 pRCB->pDevice = (PVOID) pDevice;
1097 pRCB->pUrb = vntwusb_alloc_urb(0);
1099 if (pRCB->pUrb == NULL) {
1100 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
1103 pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1104 if (pRCB->skb == NULL) {
1105 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
1108 pRCB->skb->dev = pDevice->dev;
1109 pRCB->bBoolInUse = FALSE;
1110 EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
1111 pDevice->NumRecvFreeList++;
1116 pDevice->pControlURB = vntwusb_alloc_urb(0);
1117 if (pDevice->pControlURB == NULL) {
1118 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
1122 pDevice->pInterruptURB = vntwusb_alloc_urb(0);
1123 if (pDevice->pInterruptURB == NULL) {
1124 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
1125 vntwusb_unlink_urb(pDevice->pControlURB);
1126 usb_free_urb(pDevice->pControlURB);
1130 pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
1131 if (pDevice->intBuf.pDataBuf == NULL) {
1132 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
1133 vntwusb_unlink_urb(pDevice->pControlURB);
1134 vntwusb_unlink_urb(pDevice->pInterruptURB);
1135 usb_free_urb(pDevice->pControlURB);
1136 usb_free_urb(pDevice->pInterruptURB);
1143 device_free_rx_bufs(pDevice);
1146 device_free_tx_bufs(pDevice);
1154 static BOOL device_init_defrag_cb(PSDevice pDevice) {
1156 PSDeFragControlBlock pDeF;
1158 /* Init the fragment ctl entries */
1159 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1160 pDeF = &(pDevice->sRxDFCB[i]);
1161 if (!device_alloc_frag_buf(pDevice, pDeF)) {
1162 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
1163 pDevice->dev->name);
1167 pDevice->cbDFCB = CB_MAX_RX_FRAG;
1168 pDevice->cbFreeDFCB = pDevice->cbDFCB;
1172 device_free_frag_bufs(pDevice);
1178 static void device_free_frag_bufs(PSDevice pDevice) {
1179 PSDeFragControlBlock pDeF;
1182 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1184 pDeF = &(pDevice->sRxDFCB[i]);
1187 dev_kfree_skb(pDeF->skb);
1193 BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1195 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1196 if (pDeF->skb == NULL)
1199 pDeF->skb->dev = pDevice->dev;
1205 /*-----------------------------------------------------------------*/
1207 static int device_open(struct net_device *dev) {
1208 PSDevice pDevice=(PSDevice) dev->priv;
1210 #ifdef WPA_SM_Transtatus
1211 extern SWPAResult wpa_Result;
1212 memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1213 wpa_Result.proto = 0;
1214 wpa_Result.key_mgmt = 0;
1215 wpa_Result.eap_type = 0;
1216 wpa_Result.authenticated = FALSE;
1217 pDevice->fWPA_Authened = FALSE;
1220 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
1223 pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
1225 if (device_alloc_bufs(pDevice) == FALSE) {
1226 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
1230 if (device_init_defrag_cb(pDevice)== FALSE) {
1231 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragement cb fail \n");
1235 MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
1236 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
1237 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
1238 MP_SET_FLAG(pDevice, fMP_POST_READS);
1239 MP_SET_FLAG(pDevice, fMP_POST_WRITES);
1242 Read_config_file(pDevice);
1244 if (device_init_registers(pDevice, DEVICE_INIT_COLD) == FALSE) {
1245 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
1249 device_set_multi(pDevice->dev);
1250 // Init for Key Management
1252 KeyvInitTable(pDevice,&pDevice->sKey);
1253 memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, U_ETHER_ADDR_LEN);
1254 memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, U_ETHER_ADDR_LEN);
1255 pDevice->bStopTx0Pkt = FALSE;
1256 pDevice->bStopDataPkt = FALSE;
1257 pDevice->bRoaming = FALSE; //DavidWang
1258 pDevice->bIsRoaming = FALSE;//DavidWang
1259 pDevice->bEnableRoaming = FALSE;
1260 if (pDevice->bDiversityRegCtlON) {
1261 device_init_diversity_timer(pDevice);
1264 vMgrObjectInit(pDevice);
1265 tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
1266 tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
1267 tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
1268 add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback));
1269 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
1270 pDevice->int_interval = 100; //Max 100 microframes.
1272 pDevice->int_interval = 0x10; //16 microframes interval(~2ms) for usb 2.0
1274 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1276 pDevice->bIsRxWorkItemQueued = TRUE;
1277 pDevice->fKillEventPollingThread = FALSE;
1278 pDevice->bEventAvailable = FALSE;
1280 pDevice->bWPADEVUp = FALSE;
1281 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1282 pDevice->bwextstep0 = FALSE;
1283 pDevice->bwextstep1 = FALSE;
1284 pDevice->bwextstep2 = FALSE;
1285 pDevice->bwextstep3 = FALSE;
1286 pDevice->bWPASuppWextEnabled = FALSE;
1288 pDevice->byReAssocCount = 0;
1290 RXvWorkItem(pDevice);
1291 INTvWorkItem(pDevice);
1293 // Patch: if WEP key already set by iwconfig but device not yet open
1294 if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1295 spin_lock_irq(&pDevice->lock);
1296 KeybSetDefaultKey( pDevice,
1298 pDevice->byKeyIndex | (1 << 31),
1299 pDevice->uKeyLength,
1304 spin_unlock_irq(&pDevice->lock);
1305 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1308 if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1309 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL);
1312 //mike:mark@2008-11-10
1313 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1314 //bScheduleCommand((HANDLE)pDevice, WLAN_CMD_SSID, NULL);
1318 netif_stop_queue(pDevice->dev);
1319 pDevice->flags |= DEVICE_FLAGS_OPENED;
1323 union iwreq_data wrqu;
1324 memset(&wrqu, 0, sizeof(wrqu));
1325 wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1326 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1330 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1334 device_free_frag_bufs(pDevice);
1336 device_free_rx_bufs(pDevice);
1337 device_free_tx_bufs(pDevice);
1338 device_free_int_bufs(pDevice);
1339 vntwusb_unlink_urb(pDevice->pControlURB);
1340 vntwusb_unlink_urb(pDevice->pInterruptURB);
1341 usb_free_urb(pDevice->pControlURB);
1342 usb_free_urb(pDevice->pInterruptURB);
1344 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1350 static int device_close(struct net_device *dev) {
1351 PSDevice pDevice=(PSDevice) dev->priv;
1352 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1354 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
1358 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1359 if (pDevice == NULL)
1364 union iwreq_data wrqu;
1365 memset(&wrqu, 0, sizeof(wrqu));
1366 wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1367 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1371 //2007-1121-02<Add>by EinsnLiu
1372 if (pDevice->bLinkPass) {
1373 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1378 //2008-0714-01<Add>by MikeLiu
1379 device_release_WPADEV(pDevice);
1381 //2007-0821-01<Add>by MikeLiu
1382 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,21)
1383 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1384 pMgmt->bShareKeyAlgorithm = FALSE;
1385 pDevice->bEncryptionEnable = FALSE;
1386 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1387 spin_lock_irq(&pDevice->lock);
1388 for(uu=0;uu<MAX_KEY_TABLE;uu++)
1389 MACvDisableKeyEntry(pDevice,uu);
1390 spin_unlock_irq(&pDevice->lock);
1393 if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1394 MACbShutdown(pDevice);
1396 netif_stop_queue(pDevice->dev);
1397 MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1398 MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1399 MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1400 pDevice->fKillEventPollingThread = TRUE;
1401 del_timer(&pDevice->sTimerCommand);
1402 del_timer(&pMgmt->sTimerSecondCallback);
1404 //2007-0115-02<Add>by MikeLiu
1406 del_timer(&pDevice->sTimerTxData);
1409 if (pDevice->bDiversityRegCtlON) {
1410 del_timer(&pDevice->TimerSQ3Tmax1);
1411 del_timer(&pDevice->TimerSQ3Tmax2);
1412 del_timer(&pDevice->TimerSQ3Tmax3);
1414 tasklet_kill(&pDevice->RxMngWorkItem);
1415 tasklet_kill(&pDevice->ReadWorkItem);
1416 tasklet_kill(&pDevice->EventWorkItem);
1418 pDevice->bRoaming = FALSE; //DavidWang
1419 pDevice->bIsRoaming = FALSE;//DavidWang
1420 pDevice->bEnableRoaming = FALSE;
1421 pDevice->bCmdRunning = FALSE;
1422 pDevice->bLinkPass = FALSE;
1423 memset(pMgmt->abyCurrBSSID, 0, 6);
1424 pMgmt->eCurrState = WMAC_STATE_IDLE;
1426 device_free_tx_bufs(pDevice);
1427 device_free_rx_bufs(pDevice);
1428 device_free_int_bufs(pDevice);
1429 device_free_frag_bufs(pDevice);
1431 vntwusb_unlink_urb(pDevice->pControlURB);
1432 vntwusb_unlink_urb(pDevice->pInterruptURB);
1433 usb_free_urb(pDevice->pControlURB);
1434 usb_free_urb(pDevice->pInterruptURB);
1436 BSSvClearNodeDBTable(pDevice, 0);
1437 pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1439 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1444 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
1446 static void vntwusb_disconnect(struct usb_interface *intf)
1450 static void vntwusb_disconnect(struct usb_device *udev, void *ptr)
1453 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
1455 PSDevice pDevice = usb_get_intfdata(intf);
1457 PSDevice pDevice = (PSDevice)ptr;
1461 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_disconnect1.. \n");
1462 if (pDevice == NULL)
1467 union iwreq_data wrqu;
1468 memset(&wrqu, 0, sizeof(wrqu));
1469 wrqu.data.flags = RT_RMMOD_EVENT_FLAG;
1470 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1474 //2008-0714-01<Add>by MikeLiu
1475 device_release_WPADEV(pDevice);
1477 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
1479 usb_set_intfdata(intf, NULL);
1480 //2008-0922-01<Add>by MikeLiu, decrease usb counter.
1481 usb_put_dev(interface_to_usbdev(intf));
1485 pDevice->flags |= DEVICE_FLAGS_UNPLUG;
1486 if (pDevice->dev != NULL) {
1487 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "unregister_netdev..\n");
1488 unregister_netdev(pDevice->dev);
1490 //2008-07-21-01<Add>by MikeLiu
1492 if(wpa_set_wpadev(pDevice, 0)!=0)
1493 printk("unregister wpadev fail?\n");
1495 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
1496 free_netdev(pDevice->dev);
1498 kfree(pDevice->dev);
1503 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_disconnect3.. \n");
1509 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev) {
1510 PSDevice pDevice=dev->priv;
1515 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211\n");
1516 spin_lock_irq(&pDevice->lock);
1518 if (pDevice->bStopTx0Pkt == TRUE) {
1519 dev_kfree_skb_irq(skb);
1520 spin_unlock_irq(&pDevice->lock);
1525 cbMPDULen = skb->len;
1528 vDMA0_tx_80211(pDevice, skb);
1530 spin_unlock_irq(&pDevice->lock);
1537 static int device_xmit(struct sk_buff *skb, struct net_device *dev) {
1538 PSDevice pDevice=dev->priv;
1539 struct net_device_stats* pStats = &pDevice->stats;
1542 spin_lock_irq(&pDevice->lock);
1544 netif_stop_queue(pDevice->dev);
1546 if (pDevice->bLinkPass == FALSE) {
1547 dev_kfree_skb_irq(skb);
1548 spin_unlock_irq(&pDevice->lock);
1551 if (pDevice->bStopDataPkt == TRUE) {
1552 dev_kfree_skb_irq(skb);
1553 pStats->tx_dropped++;
1554 spin_unlock_irq(&pDevice->lock);
1558 if(nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb) !=0) { //mike add:xmit fail!
1559 if (netif_queue_stopped(pDevice->dev))
1560 netif_wake_queue(pDevice->dev);
1563 spin_unlock_irq(&pDevice->lock);
1570 static unsigned const ethernet_polynomial = 0x04c11db7U;
1571 static inline u32 ether_crc(int length, unsigned char *data)
1575 while(--length >= 0) {
1576 unsigned char current_octet = *data++;
1578 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1580 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1586 //find out the start position of str2 from str1
1587 static UCHAR *kstrstr(const UCHAR *str1,const UCHAR *str2) {
1588 int str1_len=strlen(str1);
1589 int str2_len=strlen(str2);
1591 while (str1_len >= str2_len) {
1593 if(memcmp(str1,str2,str2_len)==0)
1594 return (UCHAR *)str1;
1600 static int Config_FileGetParameter(UCHAR *string, UCHAR *dest,UCHAR *source)
1604 UCHAR *start_p=NULL,*end_p=NULL,*tmp_p=NULL;
1608 strcat(buf1, string);
1610 source+=strlen(buf1);
1612 //find target string start point
1613 if((start_p = kstrstr(source,buf1))==NULL)
1616 //check if current config line is marked by "#" ??
1618 if(memcmp(start_p-ii,"\n",1)==0)
1620 if(memcmp(start_p-ii,"#",1)==0)
1624 //find target string end point
1625 if((end_p = kstrstr(start_p,"\n"))==NULL) { //cann't find "\n",but don't care
1626 end_p=start_p+strlen(start_p); //no include "\n"
1630 memcpy(buf2,start_p,end_p-start_p); //get the tartget line
1631 buf2[end_p-start_p]='\0';
1634 if((start_p = kstrstr(buf2,"="))==NULL)
1637 strcpy(buf1,start_p+1);
1641 while(*tmp_p != 0x00) {
1648 memcpy(dest,tmp_p,strlen(tmp_p));
1652 //if read fail,return NULL,or return data pointer;
1653 static UCHAR *Config_FileOperation(PSDevice pDevice) {
1654 UCHAR *config_path=CONFIG_PATH;
1656 struct file *filp=NULL;
1657 mm_segment_t old_fs = get_fs();
1658 int oldfsuid=0,oldfsgid=0;
1662 //Make sure a caller can read or write power as root
1663 oldfsuid=current->fsuid;
1664 oldfsgid=current->fsgid;
1669 filp = filp_open(config_path, O_RDWR, 0);
1671 printk("Config_FileOperation file Not exist\n");
1676 if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1677 printk("file %s cann't readable or writable?\n",config_path);
1682 buffer = (UCHAR *)kmalloc(1024, GFP_KERNEL);
1684 printk("alllocate mem for file fail?\n");
1689 if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1690 printk("read file error?\n");
1695 if(filp_close(filp,NULL))
1696 printk("Config_FileOperation:close file fail\n");
1700 current->fsuid=oldfsuid;
1701 current->fsgid=oldfsgid;
1711 //return --->-1:fail; >=0:sucessful
1712 static int Read_config_file(PSDevice pDevice) {
1714 UCHAR tmpbuffer[100];
1717 //init config setting
1718 pDevice->config_file.ZoneType = -1;
1719 pDevice->config_file.eAuthenMode = -1;
1720 pDevice->config_file.eEncryptionStatus = -1;
1722 if((buffer=Config_FileOperation(pDevice)) ==NULL) {
1729 memset(tmpbuffer,0,sizeof(tmpbuffer));
1730 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1731 if(memcmp(tmpbuffer,"USA",3)==0) {
1732 pDevice->config_file.ZoneType=ZoneType_USA;
1734 else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1735 pDevice->config_file.ZoneType=ZoneType_Japan;
1737 else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1738 pDevice->config_file.ZoneType=ZoneType_Europe;
1741 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1747 //get other parameter
1749 memset(tmpbuffer,0,sizeof(tmpbuffer));
1750 if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1751 pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1754 memset(tmpbuffer,0,sizeof(tmpbuffer));
1755 if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1756 pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1765 static void device_set_multi(struct net_device *dev) {
1766 PSDevice pDevice = (PSDevice) dev->priv;
1767 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1770 struct dev_mc_list *mclist;
1771 BYTE pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1776 spin_lock_irq(&pDevice->lock);
1777 rc = CONTROLnsRequestIn(pDevice,
1780 MESSAGE_REQUEST_MACREG,
1784 if (rc == 0) pDevice->byRxMode = byTmpMode;
1786 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1788 if (dev->flags & IFF_PROMISC) { // Set promiscuous.
1789 DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1790 // Unconditionally log net taps.
1791 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1793 else if ((dev->mc_count > pDevice->multicast_limit) || (dev->flags & IFF_ALLMULTI)) {
1794 CONTROLnsRequestOut(pDevice,
1797 MESSAGE_REQUEST_MACREG,
1801 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1804 memset(mc_filter, 0, sizeof(mc_filter));
1805 for (ii = 0, mclist = dev->mc_list; mclist && ii < dev->mc_count;
1806 ii++, mclist = mclist->next) {
1807 int bit_nr = ether_crc(ETH_ALEN, mclist->dmi_addr) >> 26;
1808 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1810 for (ii = 0; ii < 4; ii++) {
1811 MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1812 MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1814 pDevice->byRxMode &= ~(RCR_UNICAST);
1815 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1818 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1819 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1820 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1821 pDevice->byRxMode &= ~(RCR_UNICAST);
1823 ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1824 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1825 spin_unlock_irq(&pDevice->lock);
1830 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1831 PSDevice pDevice=(PSDevice) dev->priv;
1833 return &pDevice->stats;
1837 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1838 PSDevice pDevice = (PSDevice)dev->priv;
1839 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1841 //BOOL bCommit = FALSE;
1843 struct iwreq *wrq = (struct iwreq *) rq;
1845 #endif //WIRELESS_EXT
1848 if (pMgmt == NULL) {
1856 //#if WIRELESS_EXT < 13
1859 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1866 case SIOCGIWNWID: //0x8b03 support
1867 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1868 rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
1874 // Set frequency/channel
1876 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1879 // Get frequency/channel
1881 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1884 // Set desired network name (ESSID)
1888 char essid[IW_ESSID_MAX_SIZE+1];
1889 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1893 if (copy_from_user(essid, wrq->u.essid.pointer,
1894 wrq->u.essid.length)) {
1898 rc = iwctl_siwessid(dev, NULL,
1899 &(wrq->u.essid), essid);
1904 // Get current network name (ESSID)
1908 char essid[IW_ESSID_MAX_SIZE+1];
1909 if (wrq->u.essid.pointer)
1910 rc = iwctl_giwessid(dev, NULL,
1911 &(wrq->u.essid), essid);
1912 if (copy_to_user(wrq->u.essid.pointer,
1914 wrq->u.essid.length) )
1921 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1925 // Get current Access Point (BSSID)
1927 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1931 // Set desired station name
1933 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1937 // Get current station name
1939 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1943 // Set the desired bit-rate
1945 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1948 // Get the current bit-rate
1951 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1954 // Set the desired RTS threshold
1957 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
1960 // Get the current RTS threshold
1963 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1966 // Set the desired fragmentation threshold
1969 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1972 // Get the current fragmentation threshold
1975 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1978 // Set mode of operation
1980 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1983 // Get mode of operation
1985 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1988 // Set WEP keys and mode
1991 char abyKey[WLAN_WEP232_KEYLEN];
1993 if (wrq->u.encoding.pointer) {
1996 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
2000 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
2001 if (copy_from_user(abyKey,
2002 wrq->u.encoding.pointer,
2003 wrq->u.encoding.length)) {
2007 } else if (wrq->u.encoding.length != 0) {
2011 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
2015 // Get the WEP keys and mode
2018 if (!capable(CAP_NET_ADMIN)) {
2023 char abyKey[WLAN_WEP232_KEYLEN];
2025 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
2027 if (wrq->u.encoding.pointer) {
2028 if (copy_to_user(wrq->u.encoding.pointer,
2030 wrq->u.encoding.length))
2036 #if WIRELESS_EXT > 9
2037 // Get the current Tx-Power
2039 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
2044 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
2048 #endif // WIRELESS_EXT > 9
2050 #if WIRELESS_EXT > 10
2053 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
2058 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
2061 #endif // WIRELESS_EXT > 10
2063 // Get range of parameters
2067 struct iw_range range;
2069 rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
2070 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
2078 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
2084 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
2090 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
2094 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
2100 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
2102 if (wrq->u.data.pointer) {
2103 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
2105 if (copy_to_user(wrq->u.data.pointer,
2107 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality)))
2120 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
2127 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
2131 #endif // WIRELESS_SPY
2134 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
2137 if(wrq->u.data.pointer) {
2138 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
2140 if(copy_to_user(wrq->u.data.pointer,
2141 (u_char *) iwctl_private_args,
2142 sizeof(iwctl_private_args)))
2149 //#endif // WIRELESS_EXT < 13
2151 //2008-0409-07, <Add> by Einsn Liu
2152 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2154 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n");
2155 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
2159 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
2160 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
2164 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
2165 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
2169 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
2170 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
2173 case SIOCSIWENCODEEXT:
2175 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
2176 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
2177 if(wrq->u.encoding.pointer){
2178 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
2179 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
2183 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
2187 }else if(wrq->u.encoding.length != 0){
2191 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
2195 case SIOCGIWENCODEEXT:
2196 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
2197 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
2201 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
2202 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
2205 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2206 //End Add -- //2008-0409-07, <Add> by Einsn Liu
2208 #endif // WIRELESS_EXT
2210 case IOCTL_CMD_TEST:
2212 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2218 pReq = (PSCmdRequest)rq;
2220 //20080130-01,<Remark> by Mike Liu
2221 // if(pDevice->bLinkPass==TRUE)
2222 pReq->wResult = MAGIC_CODE; //Linking status:0x3142
2223 //20080130-02,<Remark> by Mike Liu
2225 // pReq->wResult = MAGIC_CODE+1; //disconnect status:0x3143
2229 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
2230 (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
2238 if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
2241 rc = private_ioctl(pDevice, rq);
2242 clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
2245 case IOCTL_CMD_HOSTAPD:
2247 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2254 #if WIRELESS_EXT > 8
2255 rc = hostap_ioctl(pDevice, &wrq->u.data);
2256 #else // WIRELESS_EXT > 8
2257 rc = hostap_ioctl(pDevice, (struct iw_point *) &wrq->u.data);
2258 #endif // WIRELESS_EXT > 8
2263 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2270 #if WIRELESS_EXT > 8
2271 rc = wpa_ioctl(pDevice, &wrq->u.data);
2272 #else // WIRELESS_EXT > 8
2273 rc = wpa_ioctl(pDevice, (struct iw_point *) &wrq->u.data);
2274 #endif // WIRELESS_EXT > 8
2278 return ethtool_ioctl(dev, (void *) rq->ifr_data);
2279 // All other calls are currently unsupported
2283 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2288 if (pDevice->bCommit) {
2289 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2290 netif_stop_queue(pDevice->dev);
2291 spin_lock_irq(&pDevice->lock);
2292 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL);
2293 spin_unlock_irq(&pDevice->lock);
2296 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2297 spin_lock_irq(&pDevice->lock);
2298 //2007-1121-01<Modify>by EinsnLiu
2299 if (pDevice->bLinkPass&&
2300 memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2301 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2303 pDevice->bLinkPass = FALSE;
2304 pMgmt->eCurrState = WMAC_STATE_IDLE;
2305 memset(pMgmt->abyCurrBSSID, 0, 6);
2307 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2309 netif_stop_queue(pDevice->dev);
2310 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2311 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2312 if(pDevice->bWPASuppWextEnabled !=TRUE)
2314 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID);
2315 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_SSID, NULL);
2316 spin_unlock_irq(&pDevice->lock);
2318 pDevice->bCommit = FALSE;
2326 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2330 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd)))
2334 case ETHTOOL_GDRVINFO: {
2335 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2336 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2337 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2338 if (copy_to_user(useraddr, &info, sizeof(info)))
2349 /*------------------------------------------------------------------*/
2352 MODULE_DEVICE_TABLE(usb, vntwusb_table);
2355 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
2357 static struct usb_driver vntwusb_driver = {
2358 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,15)
2359 .owner = THIS_MODULE,
2361 .name = DEVICE_NAME,
2362 .probe = vntwusb_found1,
2363 .disconnect = vntwusb_disconnect,
2364 .id_table = vntwusb_table,
2366 //2008-0920-01<Add>by MikeLiu
2367 //for supporting S3 & S4 function
2369 .suspend = vntwusb_suspend,
2370 .resume = vntwusb_resume,
2376 static struct usb_driver vntwusb_driver = {
2378 probe: vntwusb_found1,
2379 disconnect: vntwusb_disconnect,
2380 id_table: vntwusb_table,
2385 static int __init vntwusb_init_module(void)
2387 info(DEVICE_FULL_DRV_NAM " " DEVICE_VERSION);
2388 return usb_register(&vntwusb_driver);
2391 static void __exit vntwusb_cleanup_module(void)
2393 usb_deregister(&vntwusb_driver);
2396 module_init(vntwusb_init_module);
2397 module_exit(vntwusb_cleanup_module);