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 * vt6656_probe - 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
76 /*--------------------- Static Definitions -------------------------*/
77 //static int msglevel =MSG_LEVEL_DEBUG;
78 static int msglevel =MSG_LEVEL_INFO;
81 // Define module options
84 // Version Information
85 #define DRIVER_AUTHOR "VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>"
86 MODULE_AUTHOR(DRIVER_AUTHOR);
87 MODULE_LICENSE("GPL");
88 MODULE_DESCRIPTION(DEVICE_FULL_DRV_NAM);
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);
95 #define RX_DESC_MIN0 16
96 #define RX_DESC_MAX0 128
97 #define RX_DESC_DEF0 64
98 DEVICE_PARAM(RxDescriptors0,"Number of receive usb desc buffer");
101 #define TX_DESC_MIN0 16
102 #define TX_DESC_MAX0 128
103 #define TX_DESC_DEF0 64
104 DEVICE_PARAM(TxDescriptors0,"Number of transmit usb desc buffer");
107 #define CHANNEL_MIN 1
108 #define CHANNEL_MAX 14
109 #define CHANNEL_DEF 6
111 DEVICE_PARAM(Channel, "Channel number");
114 /* PreambleType[] is the preamble length used for transmit.
115 0: indicate allows long preamble type
116 1: indicate allows short preamble type
119 #define PREAMBLE_TYPE_DEF 1
121 DEVICE_PARAM(PreambleType, "Preamble Type");
124 #define RTS_THRESH_MIN 512
125 #define RTS_THRESH_MAX 2347
126 #define RTS_THRESH_DEF 2347
128 DEVICE_PARAM(RTSThreshold, "RTS threshold");
131 #define FRAG_THRESH_MIN 256
132 #define FRAG_THRESH_MAX 2346
133 #define FRAG_THRESH_DEF 2346
135 DEVICE_PARAM(FragThreshold, "Fragmentation threshold");
138 #define DATA_RATE_MIN 0
139 #define DATA_RATE_MAX 13
140 #define DATA_RATE_DEF 13
142 0: indicate 1 Mbps 0x02
143 1: indicate 2 Mbps 0x04
144 2: indicate 5.5 Mbps 0x0B
145 3: indicate 11 Mbps 0x16
146 4: indicate 6 Mbps 0x0c
147 5: indicate 9 Mbps 0x12
148 6: indicate 12 Mbps 0x18
149 7: indicate 18 Mbps 0x24
150 8: indicate 24 Mbps 0x30
151 9: indicate 36 Mbps 0x48
152 10: indicate 48 Mbps 0x60
153 11: indicate 54 Mbps 0x6c
154 12: indicate 72 Mbps 0x90
155 13: indicate auto rate
158 DEVICE_PARAM(ConnectionRate, "Connection data rate");
160 #define OP_MODE_MAX 2
161 #define OP_MODE_DEF 0
162 #define OP_MODE_MIN 0
164 DEVICE_PARAM(OPMode, "Infrastruct, adhoc, AP mode ");
166 /* OpMode[] is used for transmit.
167 0: indicate infrastruct mode used
168 1: indicate adhoc mode used
169 2: indicate AP mode used
174 0: indicate disable power saving mode
175 1: indicate enable power saving mode
178 #define PS_MODE_DEF 0
180 DEVICE_PARAM(PSMode, "Power saving mode");
183 #define SHORT_RETRY_MIN 0
184 #define SHORT_RETRY_MAX 31
185 #define SHORT_RETRY_DEF 8
188 DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits");
190 #define LONG_RETRY_MIN 0
191 #define LONG_RETRY_MAX 15
192 #define LONG_RETRY_DEF 4
195 DEVICE_PARAM(LongRetryLimit, "long frame retry limits");
198 /* BasebandType[] baseband type selected
199 0: indicate 802.11a type
200 1: indicate 802.11b type
201 2: indicate 802.11g type
203 #define BBP_TYPE_MIN 0
204 #define BBP_TYPE_MAX 2
205 #define BBP_TYPE_DEF 2
207 DEVICE_PARAM(BasebandType, "baseband type");
212 0: indicate disable 802.11h
213 1: indicate enable 802.11h
216 #define X80211h_MODE_DEF 0
218 DEVICE_PARAM(b80211hEnable, "802.11h mode");
222 // Static vars definitions
225 static struct usb_device_id vt6656_table[] __devinitdata = {
226 {USB_DEVICE(VNT_USB_VENDOR_ID, VNT_USB_PRODUCT_ID)},
230 // Frequency list (map channels to frequencies)
232 static const long frequency_list[] = {
233 2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484,
234 4915, 4920, 4925, 4935, 4940, 4945, 4960, 4980,
235 5035, 5040, 5045, 5055, 5060, 5080, 5170, 5180, 5190, 5200, 5210, 5220, 5230, 5240,
236 5260, 5280, 5300, 5320, 5500, 5520, 5540, 5560, 5580, 5600, 5620, 5640, 5660, 5680,
237 5700, 5745, 5765, 5785, 5805, 5825
241 #ifndef IW_ENCODE_NOKEY
242 #define IW_ENCODE_NOKEY 0x0800
243 #define IW_ENCODE_MODE (IW_ENCODE_DISABLED | IW_ENCODE_RESTRICTED | IW_ENCODE_OPEN)
246 static const struct iw_handler_def iwctl_handler_def;
249 /*--------------------- Static Functions --------------------------*/
251 static int vt6656_probe(struct usb_interface *intf,
252 const struct usb_device_id *id);
253 static void vt6656_disconnect(struct usb_interface *intf);
255 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
256 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message);
257 static int vt6656_resume(struct usb_interface *intf);
258 #endif /* CONFIG_PM */
260 static struct net_device_stats *device_get_stats(struct net_device *dev);
261 static int device_open(struct net_device *dev);
262 static int device_xmit(struct sk_buff *skb, struct net_device *dev);
263 static void device_set_multi(struct net_device *dev);
264 static int device_close(struct net_device *dev);
265 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
267 static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType);
268 static BOOL device_init_defrag_cb(PSDevice pDevice);
269 static void device_init_diversity_timer(PSDevice pDevice);
270 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
272 static int ethtool_ioctl(struct net_device *dev, void *useraddr);
273 static void device_free_tx_bufs(PSDevice pDevice);
274 static void device_free_rx_bufs(PSDevice pDevice);
275 static void device_free_int_bufs(PSDevice pDevice);
276 static void device_free_frag_bufs(PSDevice pDevice);
277 static BOOL device_alloc_bufs(PSDevice pDevice);
279 static int Read_config_file(PSDevice pDevice);
280 static unsigned char *Config_FileOperation(PSDevice pDevice);
281 static int Config_FileGetParameter(unsigned char *string,
283 unsigned char *source);
285 //2008-0714<Add>by Mike Liu
286 static BOOL device_release_WPADEV(PSDevice pDevice);
288 static void usb_device_reset(PSDevice pDevice);
292 /*--------------------- Export Variables --------------------------*/
294 /*--------------------- Export Functions --------------------------*/
298 device_set_options(PSDevice pDevice) {
300 BYTE abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
301 BYTE abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
302 u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
304 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
305 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
306 memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, ETH_ALEN);
308 pDevice->cbTD = TX_DESC_DEF0;
309 pDevice->cbRD = RX_DESC_DEF0;
310 pDevice->uChannel = CHANNEL_DEF;
311 pDevice->wRTSThreshold = RTS_THRESH_DEF;
312 pDevice->wFragmentationThreshold = FRAG_THRESH_DEF;
313 pDevice->byShortRetryLimit = SHORT_RETRY_DEF;
314 pDevice->byLongRetryLimit = LONG_RETRY_DEF;
315 pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
316 pDevice->byShortPreamble = PREAMBLE_TYPE_DEF;
317 pDevice->ePSMode = PS_MODE_DEF;
318 pDevice->b11hEnable = X80211h_MODE_DEF;
319 pDevice->eOPMode = OP_MODE_DEF;
320 pDevice->uConnectionRate = DATA_RATE_DEF;
321 if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = TRUE;
322 pDevice->byBBType = BBP_TYPE_DEF;
323 pDevice->byPacketType = pDevice->byBBType;
324 pDevice->byAutoFBCtrl = AUTO_FB_0;
325 pDevice->bUpdateBBVGA = TRUE;
326 pDevice->byFOETuning = 0;
327 pDevice->byAutoPwrTunning = 0;
328 pDevice->wCTSDuration = 0;
329 pDevice->byPreambleType = 0;
330 pDevice->bExistSWNetAddr = FALSE;
331 // pDevice->bDiversityRegCtlON = TRUE;
332 pDevice->bDiversityRegCtlON = FALSE;
336 static void device_init_diversity_timer(PSDevice pDevice)
338 init_timer(&pDevice->TimerSQ3Tmax1);
339 pDevice->TimerSQ3Tmax1.data = (unsigned long)pDevice;
340 pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
341 pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
343 init_timer(&pDevice->TimerSQ3Tmax2);
344 pDevice->TimerSQ3Tmax2.data = (unsigned long)pDevice;
345 pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
346 pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
348 init_timer(&pDevice->TimerSQ3Tmax3);
349 pDevice->TimerSQ3Tmax3.data = (unsigned long)pDevice;
350 pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerSQ3Tmax3CallBack;
351 pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
358 // Initialiation of MAC & BBP registers
361 static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType)
363 u8 abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
364 u8 abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
365 u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
368 CMD_CARD_INIT sInitCmd;
369 int ntStatus = STATUS_SUCCESS;
370 RSP_CARD_INIT sInitRsp;
371 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
373 BYTE byCalibTXIQ = 0;
374 BYTE byCalibTXDC = 0;
375 BYTE byCalibRXIQ = 0;
377 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---->INIbInitAdapter. [%d][%d]\n", InitType, pDevice->byPacketType);
378 spin_lock_irq(&pDevice->lock);
379 if (InitType == DEVICE_INIT_COLD) {
380 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
381 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
382 memcpy(pDevice->abySNAP_Bridgetunnel,
383 abySNAP_Bridgetunnel,
386 if ( !FIRMWAREbCheckVersion(pDevice) ) {
387 if (FIRMWAREbDownload(pDevice) == TRUE) {
388 if (FIRMWAREbBrach2Sram(pDevice) == FALSE) {
389 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbBrach2Sram fail \n");
390 spin_unlock_irq(&pDevice->lock);
395 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbDownload fail \n");
396 spin_unlock_irq(&pDevice->lock);
401 if ( !BBbVT3184Init(pDevice) ) {
402 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" BBbVT3184Init fail \n");
403 spin_unlock_irq(&pDevice->lock);
408 sInitCmd.byInitClass = (BYTE)InitType;
409 sInitCmd.bExistSWNetAddr = (BYTE) pDevice->bExistSWNetAddr;
410 for (ii = 0; ii < 6; ii++)
411 sInitCmd.bySWNetAddr[ii] = pDevice->abyCurrentNetAddr[ii];
412 sInitCmd.byShortRetryLimit = pDevice->byShortRetryLimit;
413 sInitCmd.byLongRetryLimit = pDevice->byLongRetryLimit;
415 //issue Card_init command to device
416 ntStatus = CONTROLnsRequestOut(pDevice,
417 MESSAGE_TYPE_CARDINIT,
420 sizeof(CMD_CARD_INIT),
421 (PBYTE) &(sInitCmd));
423 if ( ntStatus != STATUS_SUCCESS ) {
424 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Issue Card init fail \n");
425 spin_unlock_irq(&pDevice->lock);
428 if (InitType == DEVICE_INIT_COLD) {
430 ntStatus = CONTROLnsRequestIn(pDevice,MESSAGE_TYPE_INIT_RSP,0,0,sizeof(RSP_CARD_INIT), (PBYTE) &(sInitRsp));
432 if (ntStatus != STATUS_SUCCESS) {
433 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Cardinit request in status fail!\n");
434 spin_unlock_irq(&pDevice->lock);
438 //Local ID for AES functions
439 ntStatus = CONTROLnsRequestIn(pDevice,
442 MESSAGE_REQUEST_MACREG,
444 &pDevice->byLocalID);
446 if ( ntStatus != STATUS_SUCCESS ) {
447 spin_unlock_irq(&pDevice->lock);
451 // Do MACbSoftwareReset in MACvInitialize
453 pDevice->bCCK = TRUE;
454 pDevice->bProtectMode = FALSE; //Only used in 11g type, sync with ERP IE
455 pDevice->bNonERPPresent = FALSE;
456 pDevice->bBarkerPreambleMd = FALSE;
457 if ( pDevice->bFixRate ) {
458 pDevice->wCurrentRate = (WORD) pDevice->uConnectionRate;
460 if ( pDevice->byBBType == BB_TYPE_11B )
461 pDevice->wCurrentRate = RATE_11M;
463 pDevice->wCurrentRate = RATE_54M;
466 CHvInitChannelTable(pDevice);
468 pDevice->byTopOFDMBasicRate = RATE_24M;
469 pDevice->byTopCCKBasicRate = RATE_1M;
470 pDevice->byRevId = 0; //Target to IF pin while programming to RF chip.
471 pDevice->byCurPwr = 0xFF;
473 pDevice->byCCKPwr = pDevice->abyEEPROM[EEP_OFS_PWR_CCK];
474 pDevice->byOFDMPwrG = pDevice->abyEEPROM[EEP_OFS_PWR_OFDMG];
476 for (ii=0;ii<14;ii++) {
477 pDevice->abyCCKPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_CCK_PWR_TBL];
478 if (pDevice->abyCCKPwrTbl[ii] == 0)
479 pDevice->abyCCKPwrTbl[ii] = pDevice->byCCKPwr;
480 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDM_PWR_TBL];
481 if (pDevice->abyOFDMPwrTbl[ii] == 0)
482 pDevice->abyOFDMPwrTbl[ii] = pDevice->byOFDMPwrG;
485 //original zonetype is USA,but customize zonetype is europe,
486 // then need recover 12,13 ,14 channel with 11 channel
487 if(((pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Japan) ||
488 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Europe))&&
489 (pDevice->byOriginalZonetype == ZoneType_USA)) {
490 for (ii = 11; ii < 14; ii++) {
491 pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];
492 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];
496 //{{ RobertYu: 20041124
497 pDevice->byOFDMPwrA = 0x34; // same as RFbMA2829SelectChannel
498 // Load OFDM A Power Table
499 for (ii=0;ii<CB_MAX_CHANNEL_5G;ii++) { //RobertYu:20041224, bug using CB_MAX_CHANNEL
500 pDevice->abyOFDMAPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDMA_PWR_TBL];
501 if (pDevice->abyOFDMAPwrTbl[ii] == 0)
502 pDevice->abyOFDMAPwrTbl[ii] = pDevice->byOFDMPwrA;
506 byAntenna = pDevice->abyEEPROM[EEP_OFS_ANTENNA];
507 if (byAntenna & EEP_ANTINV)
508 pDevice->bTxRxAntInv = TRUE;
510 pDevice->bTxRxAntInv = FALSE;
512 byAntenna &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
514 if (byAntenna == 0) // if not set default is All
515 byAntenna = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
517 if (byAntenna == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
518 pDevice->byAntennaCount = 2;
519 pDevice->byTxAntennaMode = ANT_B;
520 pDevice->dwTxAntennaSel = 1;
521 pDevice->dwRxAntennaSel = 1;
522 if (pDevice->bTxRxAntInv == TRUE)
523 pDevice->byRxAntennaMode = ANT_A;
525 pDevice->byRxAntennaMode = ANT_B;
527 if (pDevice->bDiversityRegCtlON)
528 pDevice->bDiversityEnable = TRUE;
530 pDevice->bDiversityEnable = FALSE;
532 pDevice->bDiversityEnable = FALSE;
533 pDevice->byAntennaCount = 1;
534 pDevice->dwTxAntennaSel = 0;
535 pDevice->dwRxAntennaSel = 0;
536 if (byAntenna & EEP_ANTENNA_AUX) {
537 pDevice->byTxAntennaMode = ANT_A;
538 if (pDevice->bTxRxAntInv == TRUE)
539 pDevice->byRxAntennaMode = ANT_B;
541 pDevice->byRxAntennaMode = ANT_A;
543 pDevice->byTxAntennaMode = ANT_B;
544 if (pDevice->bTxRxAntInv == TRUE)
545 pDevice->byRxAntennaMode = ANT_A;
547 pDevice->byRxAntennaMode = ANT_B;
550 pDevice->ulDiversityNValue = 100*255;
551 pDevice->ulDiversityMValue = 100*16;
553 pDevice->byTMax2 = 4;
554 pDevice->ulSQ3TH = 0;
555 pDevice->byTMax3 = 64;
556 // -----------------------------------------------------------------
558 //Get Auto Fall Back Type
559 pDevice->byAutoFBCtrl = AUTO_FB_0;
562 pDevice->uScanTime = WLAN_SCAN_MINITIME;
565 //pDevice->NetworkType = Ndis802_11Automode;
566 pDevice->eConfigPHYMode = PHY_TYPE_AUTO;
567 pDevice->byBBType = BB_TYPE_11G;
569 // initialize BBP registers
570 pDevice->ulTxPower = 25;
573 pDevice->byMinChannel = 1;
574 pDevice->byMaxChannel = CB_MAX_CHANNEL;
577 pDevice->byRFType = sInitRsp.byRFType;
579 if ((pDevice->byRFType & RF_EMU) != 0) {
580 // force change RevID for VT3253 emu
581 pDevice->byRevId = 0x80;
584 // Load EEPROM calibrated vt3266 parameters
585 if (pDevice->byRFType == RF_VT3226D0) {
586 if((pDevice->abyEEPROM[EEP_OFS_MAJOR_VER] == 0x1) &&
587 (pDevice->abyEEPROM[EEP_OFS_MINOR_VER] >= 0x4)) {
588 byCalibTXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_IQ];
589 byCalibTXDC = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_DC];
590 byCalibRXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_RX_IQ];
591 if( (byCalibTXIQ || byCalibTXDC || byCalibRXIQ) ) {
592 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFF, 0x03); // CR255, Set BB to support TX/RX IQ and DC compensation Mode
593 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFB, byCalibTXIQ); // CR251, TX I/Q Imbalance Calibration
594 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFC, byCalibTXDC); // CR252, TX DC-Offset Calibration
595 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFD, byCalibRXIQ); // CR253, RX I/Q Imbalance Calibration
597 // turn off BB Calibration compensation
598 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFF, 0x0); // CR255
602 pMgmt->eScanType = WMAC_SCAN_PASSIVE;
603 pMgmt->uCurrChannel = pDevice->uChannel;
604 pMgmt->uIBSSChannel = pDevice->uChannel;
605 CARDbSetMediaChannel(pDevice, pMgmt->uCurrChannel);
607 // get Permanent network address
608 memcpy(pDevice->abyPermanentNetAddr,&(sInitRsp.byNetAddr[0]),6);
609 memcpy(pDevice->abyCurrentNetAddr,
610 pDevice->abyPermanentNetAddr,
613 // if exist SW network address, use SW network address.
615 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %02x-%02x-%02x=%02x-%02x-%02x\n",
616 pDevice->abyCurrentNetAddr[0],
617 pDevice->abyCurrentNetAddr[1],
618 pDevice->abyCurrentNetAddr[2],
619 pDevice->abyCurrentNetAddr[3],
620 pDevice->abyCurrentNetAddr[4],
621 pDevice->abyCurrentNetAddr[5]);
626 // Set BB and packet type at the same time.
627 // Set Short Slot Time, xIFS, and RSPINF.
628 if (pDevice->byBBType == BB_TYPE_11A) {
629 CARDbAddBasicRate(pDevice, RATE_6M);
630 pDevice->bShortSlotTime = TRUE;
632 CARDbAddBasicRate(pDevice, RATE_1M);
633 pDevice->bShortSlotTime = FALSE;
635 BBvSetShortSlotTime(pDevice);
636 CARDvSetBSSMode(pDevice);
638 if (pDevice->bUpdateBBVGA) {
639 pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
640 pDevice->byBBVGANew = pDevice->byBBVGACurrent;
641 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
644 pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];
645 pDevice->bHWRadioOff = FALSE;
646 if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) {
647 ntStatus = CONTROLnsRequestIn(pDevice,
650 MESSAGE_REQUEST_MACREG,
654 if ( ntStatus != STATUS_SUCCESS ) {
655 spin_unlock_irq(&pDevice->lock);
658 if ( (byTmp & GPIO3_DATA) == 0 ) {
659 pDevice->bHWRadioOff = TRUE;
660 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
662 MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
663 pDevice->bHWRadioOff = FALSE;
666 } //EEP_RADIOCTL_ENABLE
668 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
669 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
670 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01);
672 if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) {
673 CARDbRadioPowerOff(pDevice);
675 CARDbRadioPowerOn(pDevice);
678 spin_unlock_irq(&pDevice->lock);
679 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");
683 static BOOL device_release_WPADEV(PSDevice pDevice)
685 viawget_wpa_header *wpahdr;
687 // wait_queue_head_t Set_wait;
688 //send device close to wpa_supplicnat layer
689 if (pDevice->bWPADEVUp==TRUE) {
690 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
691 wpahdr->type = VIAWGET_DEVICECLOSE_MSG;
692 wpahdr->resp_ie_len = 0;
693 wpahdr->req_ie_len = 0;
694 skb_put(pDevice->skb, sizeof(viawget_wpa_header));
695 pDevice->skb->dev = pDevice->wpadev;
696 skb_reset_mac_header(pDevice->skb);
697 pDevice->skb->pkt_type = PACKET_HOST;
698 pDevice->skb->protocol = htons(ETH_P_802_2);
699 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
700 netif_rx(pDevice->skb);
701 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
703 //wait release WPADEV
704 // init_waitqueue_head(&Set_wait);
705 // wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ); //1s wait
706 while(pDevice->bWPADEVUp==TRUE) {
707 set_current_state(TASK_UNINTERRUPTIBLE);
708 schedule_timeout (HZ/20); //wait 50ms
717 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
719 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message)
721 PSDevice device = usb_get_intfdata(intf);
723 if (!device || !device->dev)
726 if (device->flags & DEVICE_FLAGS_OPENED)
727 device_close(device->dev);
729 usb_put_dev(interface_to_usbdev(intf));
734 static int vt6656_resume(struct usb_interface *intf)
736 PSDevice device = usb_get_intfdata(intf);
738 if (!device || !device->dev)
741 usb_get_dev(interface_to_usbdev(intf));
743 if (!(device->flags & DEVICE_FLAGS_OPENED))
744 device_open(device->dev);
749 #endif /* CONFIG_PM */
751 static const struct net_device_ops device_netdev_ops = {
752 .ndo_open = device_open,
753 .ndo_stop = device_close,
754 .ndo_do_ioctl = device_ioctl,
755 .ndo_get_stats = device_get_stats,
756 .ndo_start_xmit = device_xmit,
757 .ndo_set_multicast_list = device_set_multi,
761 vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
763 u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
764 struct usb_device *udev = interface_to_usbdev(intf);
766 struct net_device *netdev = NULL;
767 PSDevice pDevice = NULL;
769 printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
770 printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
772 udev = usb_get_dev(udev);
773 netdev = alloc_etherdev(sizeof(DEVICE_INFO));
776 printk(KERN_ERR DEVICE_NAME ": allocate net device failed\n");
781 pDevice = netdev_priv(netdev);
782 memset(pDevice, 0, sizeof(DEVICE_INFO));
784 pDevice->dev = netdev;
787 device_set_options(pDevice);
788 spin_lock_init(&pDevice->lock);
790 pDevice->tx_80211 = device_dma0_tx_80211;
791 pDevice->sMgmtObj.pAdapter = (void *) pDevice;
793 netdev->netdev_ops = &device_netdev_ops;
794 netdev->wireless_handlers =
795 (struct iw_handler_def *) &iwctl_handler_def;
797 usb_set_intfdata(intf, pDevice);
798 SET_NETDEV_DEV(netdev, &intf->dev);
799 memcpy(pDevice->dev->dev_addr, fake_mac, ETH_ALEN);
800 rc = register_netdev(netdev);
802 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
808 usb_device_reset(pDevice);
811 union iwreq_data wrqu;
812 memset(&wrqu, 0, sizeof(wrqu));
813 wrqu.data.flags = RT_INSMOD_EVENT_FLAG;
814 wrqu.data.length = IFNAMSIZ;
815 wireless_send_event(pDevice->dev,
829 static void device_free_tx_bufs(PSDevice pDevice)
831 PUSB_SEND_CONTEXT pTxContext;
834 for (ii = 0; ii < pDevice->cbTD; ii++) {
836 pTxContext = pDevice->apTD[ii];
838 if (pTxContext->pUrb) {
839 usb_kill_urb(pTxContext->pUrb);
840 usb_free_urb(pTxContext->pUrb);
849 static void device_free_rx_bufs(PSDevice pDevice)
854 for (ii = 0; ii < pDevice->cbRD; ii++) {
856 pRCB = pDevice->apRCB[ii];
859 usb_kill_urb(pRCB->pUrb);
860 usb_free_urb(pRCB->pUrb);
864 dev_kfree_skb(pRCB->skb);
866 if (pDevice->pRCBMem)
867 kfree(pDevice->pRCBMem);
872 //2007-1107-02<Add>by MikeLiu
873 static void usb_device_reset(PSDevice pDevice)
876 status = usb_reset_device(pDevice->usb);
878 printk("usb_device_reset fail status=%d\n",status);
882 static void device_free_int_bufs(PSDevice pDevice)
884 if (pDevice->intBuf.pDataBuf != NULL)
885 kfree(pDevice->intBuf.pDataBuf);
890 static BOOL device_alloc_bufs(PSDevice pDevice) {
892 PUSB_SEND_CONTEXT pTxContext;
897 for (ii = 0; ii < pDevice->cbTD; ii++) {
899 pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
900 if (pTxContext == NULL) {
901 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
904 pDevice->apTD[ii] = pTxContext;
905 pTxContext->pDevice = (void *) pDevice;
907 pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
908 if (pTxContext->pUrb == NULL) {
909 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
912 pTxContext->bBoolInUse = FALSE;
916 pDevice->pRCBMem = kmalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
917 if (pDevice->pRCBMem == NULL) {
918 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
923 pDevice->FirstRecvFreeList = NULL;
924 pDevice->LastRecvFreeList = NULL;
925 pDevice->FirstRecvMngList = NULL;
926 pDevice->LastRecvMngList = NULL;
927 pDevice->NumRecvFreeList = 0;
928 memset(pDevice->pRCBMem, 0, (sizeof(RCB) * pDevice->cbRD));
929 pRCB = (PRCB) pDevice->pRCBMem;
931 for (ii = 0; ii < pDevice->cbRD; ii++) {
933 pDevice->apRCB[ii] = pRCB;
934 pRCB->pDevice = (void *) pDevice;
936 pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
938 if (pRCB->pUrb == NULL) {
939 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
942 pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
943 if (pRCB->skb == NULL) {
944 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
947 pRCB->skb->dev = pDevice->dev;
948 pRCB->bBoolInUse = FALSE;
949 EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
950 pDevice->NumRecvFreeList++;
955 pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
956 if (pDevice->pControlURB == NULL) {
957 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
961 pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
962 if (pDevice->pInterruptURB == NULL) {
963 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
964 usb_kill_urb(pDevice->pControlURB);
965 usb_free_urb(pDevice->pControlURB);
969 pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
970 if (pDevice->intBuf.pDataBuf == NULL) {
971 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
972 usb_kill_urb(pDevice->pControlURB);
973 usb_kill_urb(pDevice->pInterruptURB);
974 usb_free_urb(pDevice->pControlURB);
975 usb_free_urb(pDevice->pInterruptURB);
982 device_free_rx_bufs(pDevice);
985 device_free_tx_bufs(pDevice);
993 static BOOL device_init_defrag_cb(PSDevice pDevice) {
995 PSDeFragControlBlock pDeF;
997 /* Init the fragment ctl entries */
998 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
999 pDeF = &(pDevice->sRxDFCB[i]);
1000 if (!device_alloc_frag_buf(pDevice, pDeF)) {
1001 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
1002 pDevice->dev->name);
1006 pDevice->cbDFCB = CB_MAX_RX_FRAG;
1007 pDevice->cbFreeDFCB = pDevice->cbDFCB;
1011 device_free_frag_bufs(pDevice);
1017 static void device_free_frag_bufs(PSDevice pDevice) {
1018 PSDeFragControlBlock pDeF;
1021 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1023 pDeF = &(pDevice->sRxDFCB[i]);
1026 dev_kfree_skb(pDeF->skb);
1032 BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1034 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1035 if (pDeF->skb == NULL)
1038 pDeF->skb->dev = pDevice->dev;
1044 /*-----------------------------------------------------------------*/
1046 static int device_open(struct net_device *dev) {
1047 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1049 extern SWPAResult wpa_Result;
1050 memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1051 wpa_Result.proto = 0;
1052 wpa_Result.key_mgmt = 0;
1053 wpa_Result.eap_type = 0;
1054 wpa_Result.authenticated = FALSE;
1055 pDevice->fWPA_Authened = FALSE;
1057 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
1060 pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
1062 if (device_alloc_bufs(pDevice) == FALSE) {
1063 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
1067 if (device_init_defrag_cb(pDevice)== FALSE) {
1068 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragement cb fail \n");
1072 MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
1073 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
1074 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
1075 MP_SET_FLAG(pDevice, fMP_POST_READS);
1076 MP_SET_FLAG(pDevice, fMP_POST_WRITES);
1079 Read_config_file(pDevice);
1081 if (device_init_registers(pDevice, DEVICE_INIT_COLD) == FALSE) {
1082 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
1086 device_set_multi(pDevice->dev);
1087 // Init for Key Management
1089 KeyvInitTable(pDevice,&pDevice->sKey);
1090 memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1091 memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1092 pDevice->bStopTx0Pkt = FALSE;
1093 pDevice->bStopDataPkt = FALSE;
1094 pDevice->bRoaming = FALSE; //DavidWang
1095 pDevice->bIsRoaming = FALSE;//DavidWang
1096 pDevice->bEnableRoaming = FALSE;
1097 if (pDevice->bDiversityRegCtlON) {
1098 device_init_diversity_timer(pDevice);
1101 vMgrObjectInit(pDevice);
1102 tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
1103 tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
1104 tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
1105 add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback));
1106 pDevice->int_interval = 100; //Max 100 microframes.
1107 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1109 pDevice->bIsRxWorkItemQueued = TRUE;
1110 pDevice->fKillEventPollingThread = FALSE;
1111 pDevice->bEventAvailable = FALSE;
1113 pDevice->bWPADEVUp = FALSE;
1114 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1115 pDevice->bwextstep0 = FALSE;
1116 pDevice->bwextstep1 = FALSE;
1117 pDevice->bwextstep2 = FALSE;
1118 pDevice->bwextstep3 = FALSE;
1119 pDevice->bWPASuppWextEnabled = FALSE;
1121 pDevice->byReAssocCount = 0;
1123 RXvWorkItem(pDevice);
1124 INTvWorkItem(pDevice);
1126 // Patch: if WEP key already set by iwconfig but device not yet open
1127 if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1128 spin_lock_irq(&pDevice->lock);
1129 KeybSetDefaultKey( pDevice,
1131 pDevice->byKeyIndex | (1 << 31),
1132 pDevice->uKeyLength,
1137 spin_unlock_irq(&pDevice->lock);
1138 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1141 if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1142 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1145 //mike:mark@2008-11-10
1146 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1147 /* bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL); */
1151 netif_stop_queue(pDevice->dev);
1152 pDevice->flags |= DEVICE_FLAGS_OPENED;
1155 union iwreq_data wrqu;
1156 memset(&wrqu, 0, sizeof(wrqu));
1157 wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1158 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1161 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1165 device_free_frag_bufs(pDevice);
1167 device_free_rx_bufs(pDevice);
1168 device_free_tx_bufs(pDevice);
1169 device_free_int_bufs(pDevice);
1170 usb_kill_urb(pDevice->pControlURB);
1171 usb_kill_urb(pDevice->pInterruptURB);
1172 usb_free_urb(pDevice->pControlURB);
1173 usb_free_urb(pDevice->pInterruptURB);
1175 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1181 static int device_close(struct net_device *dev) {
1182 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1183 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1187 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1188 if (pDevice == NULL)
1192 union iwreq_data wrqu;
1193 memset(&wrqu, 0, sizeof(wrqu));
1194 wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1195 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1198 //2007-1121-02<Add>by EinsnLiu
1199 if (pDevice->bLinkPass) {
1200 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1205 //2008-0714-01<Add>by MikeLiu
1206 device_release_WPADEV(pDevice);
1208 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1209 pMgmt->bShareKeyAlgorithm = FALSE;
1210 pDevice->bEncryptionEnable = FALSE;
1211 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1212 spin_lock_irq(&pDevice->lock);
1213 for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1214 MACvDisableKeyEntry(pDevice,uu);
1215 spin_unlock_irq(&pDevice->lock);
1217 if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1218 MACbShutdown(pDevice);
1220 netif_stop_queue(pDevice->dev);
1221 MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1222 MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1223 MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1224 pDevice->fKillEventPollingThread = TRUE;
1225 del_timer(&pDevice->sTimerCommand);
1226 del_timer(&pMgmt->sTimerSecondCallback);
1228 del_timer(&pDevice->sTimerTxData);
1230 if (pDevice->bDiversityRegCtlON) {
1231 del_timer(&pDevice->TimerSQ3Tmax1);
1232 del_timer(&pDevice->TimerSQ3Tmax2);
1233 del_timer(&pDevice->TimerSQ3Tmax3);
1235 tasklet_kill(&pDevice->RxMngWorkItem);
1236 tasklet_kill(&pDevice->ReadWorkItem);
1237 tasklet_kill(&pDevice->EventWorkItem);
1239 pDevice->bRoaming = FALSE; //DavidWang
1240 pDevice->bIsRoaming = FALSE;//DavidWang
1241 pDevice->bEnableRoaming = FALSE;
1242 pDevice->bCmdRunning = FALSE;
1243 pDevice->bLinkPass = FALSE;
1244 memset(pMgmt->abyCurrBSSID, 0, 6);
1245 pMgmt->eCurrState = WMAC_STATE_IDLE;
1247 device_free_tx_bufs(pDevice);
1248 device_free_rx_bufs(pDevice);
1249 device_free_int_bufs(pDevice);
1250 device_free_frag_bufs(pDevice);
1252 usb_kill_urb(pDevice->pControlURB);
1253 usb_kill_urb(pDevice->pInterruptURB);
1254 usb_free_urb(pDevice->pControlURB);
1255 usb_free_urb(pDevice->pInterruptURB);
1257 BSSvClearNodeDBTable(pDevice, 0);
1258 pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1260 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1265 static void __devexit vt6656_disconnect(struct usb_interface *intf)
1267 PSDevice device = usb_get_intfdata(intf);
1273 union iwreq_data req;
1274 memset(&req, 0, sizeof(req));
1275 req.data.flags = RT_RMMOD_EVENT_FLAG;
1276 wireless_send_event(device->dev, IWEVCUSTOM, &req, NULL);
1279 device_release_WPADEV(device);
1281 usb_set_intfdata(intf, NULL);
1282 usb_put_dev(interface_to_usbdev(intf));
1284 device->flags |= DEVICE_FLAGS_UNPLUG;
1287 unregister_netdev(device->dev);
1288 wpa_set_wpadev(device, 0);
1289 free_netdev(device->dev);
1293 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1295 PSDevice pDevice = netdev_priv(dev);
1297 spin_lock_irq(&pDevice->lock);
1299 if (unlikely(pDevice->bStopTx0Pkt))
1300 dev_kfree_skb_irq(skb);
1302 vDMA0_tx_80211(pDevice, skb);
1304 spin_unlock_irq(&pDevice->lock);
1306 return NETDEV_TX_OK;
1309 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1311 PSDevice pDevice = netdev_priv(dev);
1312 struct net_device_stats *stats = &pDevice->stats;
1314 spin_lock_irq(&pDevice->lock);
1316 netif_stop_queue(dev);
1318 if (!pDevice->bLinkPass) {
1319 dev_kfree_skb_irq(skb);
1323 if (pDevice->bStopDataPkt) {
1324 dev_kfree_skb_irq(skb);
1325 stats->tx_dropped++;
1329 if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1330 if (netif_queue_stopped(dev))
1331 netif_wake_queue(dev);
1335 spin_unlock_irq(&pDevice->lock);
1337 return NETDEV_TX_OK;
1340 static unsigned const ethernet_polynomial = 0x04c11db7U;
1341 static inline u32 ether_crc(int length, unsigned char *data)
1345 while(--length >= 0) {
1346 unsigned char current_octet = *data++;
1348 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1350 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1356 //find out the start position of str2 from str1
1357 static unsigned char *kstrstr(const unsigned char *str1,
1358 const unsigned char *str2) {
1359 int str1_len = strlen(str1);
1360 int str2_len = strlen(str2);
1362 while (str1_len >= str2_len) {
1364 if(memcmp(str1,str2,str2_len)==0)
1365 return (unsigned char *) str1;
1371 static int Config_FileGetParameter(unsigned char *string,
1372 unsigned char *dest,
1373 unsigned char *source)
1375 unsigned char buf1[100];
1376 unsigned char buf2[100];
1377 unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1381 strcat(buf1, string);
1383 source+=strlen(buf1);
1385 //find target string start point
1386 start_p = kstrstr(source,buf1);
1387 if (start_p == NULL)
1390 //check if current config line is marked by "#" ??
1391 for (ii = 1; ; ii++) {
1392 if (memcmp(start_p - ii, "\n", 1) == 0)
1394 if (memcmp(start_p - ii, "#", 1) == 0)
1398 //find target string end point
1399 end_p = kstrstr(start_p,"\n");
1400 if (end_p == NULL) { //can't find "\n",but don't care
1401 end_p=start_p+strlen(start_p); //no include "\n"
1405 memcpy(buf2,start_p,end_p-start_p); //get the tartget line
1406 buf2[end_p-start_p]='\0';
1409 start_p = kstrstr(buf2,"=");
1410 if (start_p == NULL)
1413 strcpy(buf1,start_p+1);
1417 while(*tmp_p != 0x00) {
1424 memcpy(dest,tmp_p,strlen(tmp_p));
1428 //if read fail,return NULL,or return data pointer;
1429 static unsigned char *Config_FileOperation(PSDevice pDevice)
1431 unsigned char *config_path = CONFIG_PATH;
1432 unsigned char *buffer = NULL;
1433 struct file *filp=NULL;
1434 mm_segment_t old_fs = get_fs();
1435 //int oldfsuid=0,oldfsgid=0;
1439 /* Can't do this anymore, so we rely on correct filesystem permissions:
1440 //Make sure a caller can read or write power as root
1441 oldfsuid=current->fsuid;
1442 oldfsgid=current->fsgid;
1448 filp = filp_open(config_path, O_RDWR, 0);
1450 printk("Config_FileOperation file Not exist\n");
1455 if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1456 printk("file %s cann't readable or writable?\n",config_path);
1461 buffer = kmalloc(1024, GFP_KERNEL);
1463 printk("alllocate mem for file fail?\n");
1468 if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1469 printk("read file error?\n");
1474 if(filp_close(filp,NULL))
1475 printk("Config_FileOperation:close file fail\n");
1481 current->fsuid=oldfsuid;
1482 current->fsgid=oldfsgid;
1493 //return --->-1:fail; >=0:successful
1494 static int Read_config_file(PSDevice pDevice) {
1496 unsigned char tmpbuffer[100];
1497 unsigned char *buffer = NULL;
1499 //init config setting
1500 pDevice->config_file.ZoneType = -1;
1501 pDevice->config_file.eAuthenMode = -1;
1502 pDevice->config_file.eEncryptionStatus = -1;
1504 buffer = Config_FileOperation(pDevice);
1505 if (buffer == NULL) {
1512 memset(tmpbuffer,0,sizeof(tmpbuffer));
1513 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1514 if(memcmp(tmpbuffer,"USA",3)==0) {
1515 pDevice->config_file.ZoneType=ZoneType_USA;
1517 else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1518 pDevice->config_file.ZoneType=ZoneType_Japan;
1520 else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1521 pDevice->config_file.ZoneType=ZoneType_Europe;
1524 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1529 //get other parameter
1531 memset(tmpbuffer,0,sizeof(tmpbuffer));
1532 if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1533 pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1536 memset(tmpbuffer,0,sizeof(tmpbuffer));
1537 if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1538 pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1546 static void device_set_multi(struct net_device *dev) {
1547 PSDevice pDevice = (PSDevice) netdev_priv(dev);
1548 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1551 struct netdev_hw_addr *ha;
1552 BYTE pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1557 spin_lock_irq(&pDevice->lock);
1558 rc = CONTROLnsRequestIn(pDevice,
1561 MESSAGE_REQUEST_MACREG,
1565 if (rc == 0) pDevice->byRxMode = byTmpMode;
1567 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1569 if (dev->flags & IFF_PROMISC) { // Set promiscuous.
1570 DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1571 // Unconditionally log net taps.
1572 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1574 else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1575 (dev->flags & IFF_ALLMULTI)) {
1576 CONTROLnsRequestOut(pDevice,
1579 MESSAGE_REQUEST_MACREG,
1583 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1586 memset(mc_filter, 0, sizeof(mc_filter));
1587 netdev_for_each_mc_addr(ha, dev) {
1588 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1589 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1591 for (ii = 0; ii < 4; ii++) {
1592 MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1593 MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1595 pDevice->byRxMode &= ~(RCR_UNICAST);
1596 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1599 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1600 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1601 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1602 pDevice->byRxMode &= ~(RCR_UNICAST);
1604 ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1605 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1606 spin_unlock_irq(&pDevice->lock);
1611 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1612 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1614 return &pDevice->stats;
1618 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1619 PSDevice pDevice = (PSDevice)netdev_priv(dev);
1620 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1622 //BOOL bCommit = FALSE;
1623 struct iwreq *wrq = (struct iwreq *) rq;
1626 if (pMgmt == NULL) {
1634 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1641 case SIOCGIWNWID: //0x8b03 support
1642 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1643 rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
1649 // Set frequency/channel
1651 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1654 // Get frequency/channel
1656 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1659 // Set desired network name (ESSID)
1663 char essid[IW_ESSID_MAX_SIZE+1];
1664 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1668 if (copy_from_user(essid, wrq->u.essid.pointer,
1669 wrq->u.essid.length)) {
1673 rc = iwctl_siwessid(dev, NULL,
1674 &(wrq->u.essid), essid);
1679 // Get current network name (ESSID)
1683 char essid[IW_ESSID_MAX_SIZE+1];
1684 if (wrq->u.essid.pointer)
1685 rc = iwctl_giwessid(dev, NULL,
1686 &(wrq->u.essid), essid);
1687 if (copy_to_user(wrq->u.essid.pointer,
1689 wrq->u.essid.length) )
1696 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1700 // Get current Access Point (BSSID)
1702 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1706 // Set desired station name
1708 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1712 // Get current station name
1714 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1718 // Set the desired bit-rate
1720 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1723 // Get the current bit-rate
1726 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1729 // Set the desired RTS threshold
1732 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
1735 // Get the current RTS threshold
1738 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1741 // Set the desired fragmentation threshold
1744 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1747 // Get the current fragmentation threshold
1750 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1753 // Set mode of operation
1755 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1758 // Get mode of operation
1760 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1763 // Set WEP keys and mode
1766 char abyKey[WLAN_WEP232_KEYLEN];
1768 if (wrq->u.encoding.pointer) {
1771 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
1775 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
1776 if (copy_from_user(abyKey,
1777 wrq->u.encoding.pointer,
1778 wrq->u.encoding.length)) {
1782 } else if (wrq->u.encoding.length != 0) {
1786 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1790 // Get the WEP keys and mode
1793 if (!capable(CAP_NET_ADMIN)) {
1798 char abyKey[WLAN_WEP232_KEYLEN];
1800 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1802 if (wrq->u.encoding.pointer) {
1803 if (copy_to_user(wrq->u.encoding.pointer,
1805 wrq->u.encoding.length))
1811 // Get the current Tx-Power
1813 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1818 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1824 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
1829 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
1832 // Get range of parameters
1836 struct iw_range range;
1838 rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
1839 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
1847 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
1853 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
1859 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
1863 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
1869 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
1871 if (wrq->u.data.pointer) {
1872 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
1874 if (copy_to_user(wrq->u.data.pointer,
1876 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality)))
1889 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1896 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1900 #endif // WIRELESS_SPY
1903 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
1906 if(wrq->u.data.pointer) {
1907 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
1909 if(copy_to_user(wrq->u.data.pointer,
1910 (u_char *) iwctl_private_args,
1911 sizeof(iwctl_private_args)))
1918 //2008-0409-07, <Add> by Einsn Liu
1919 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1921 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n");
1922 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
1926 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
1927 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
1931 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
1932 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1936 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
1937 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1940 case SIOCSIWENCODEEXT:
1942 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
1943 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
1944 if(wrq->u.encoding.pointer){
1945 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
1946 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
1950 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
1954 }else if(wrq->u.encoding.length != 0){
1958 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
1962 case SIOCGIWENCODEEXT:
1963 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
1964 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
1968 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
1969 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1972 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1973 //End Add -- //2008-0409-07, <Add> by Einsn Liu
1975 case IOCTL_CMD_TEST:
1977 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1983 pReq = (PSCmdRequest)rq;
1985 //20080130-01,<Remark> by Mike Liu
1986 // if(pDevice->bLinkPass==TRUE)
1987 pReq->wResult = MAGIC_CODE; //Linking status:0x3142
1988 //20080130-02,<Remark> by Mike Liu
1990 // pReq->wResult = MAGIC_CODE+1; //disconnect status:0x3143
1994 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
1995 (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
2003 if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
2006 rc = private_ioctl(pDevice, rq);
2007 clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
2010 case IOCTL_CMD_HOSTAPD:
2012 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2019 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
2024 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2031 rc = wpa_ioctl(pDevice, &wrq->u.data);
2035 return ethtool_ioctl(dev, (void *) rq->ifr_data);
2036 // All other calls are currently unsupported
2040 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2045 if (pDevice->bCommit) {
2046 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2047 netif_stop_queue(pDevice->dev);
2048 spin_lock_irq(&pDevice->lock);
2049 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
2050 spin_unlock_irq(&pDevice->lock);
2053 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2054 spin_lock_irq(&pDevice->lock);
2055 //2007-1121-01<Modify>by EinsnLiu
2056 if (pDevice->bLinkPass &&
2057 memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2058 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2060 pDevice->bLinkPass = FALSE;
2061 pMgmt->eCurrState = WMAC_STATE_IDLE;
2062 memset(pMgmt->abyCurrBSSID, 0, 6);
2064 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2066 netif_stop_queue(pDevice->dev);
2067 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2068 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2069 if (!pDevice->bWPASuppWextEnabled)
2071 bScheduleCommand((void *) pDevice,
2072 WLAN_CMD_BSSID_SCAN,
2073 pMgmt->abyDesireSSID);
2074 bScheduleCommand((void *) pDevice,
2077 spin_unlock_irq(&pDevice->lock);
2079 pDevice->bCommit = FALSE;
2087 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2091 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd)))
2095 case ETHTOOL_GDRVINFO: {
2096 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2097 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2098 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2099 if (copy_to_user(useraddr, &info, sizeof(info)))
2110 /*------------------------------------------------------------------*/
2112 MODULE_DEVICE_TABLE(usb, vt6656_table);
2114 static struct usb_driver vt6656_driver = {
2115 .name = DEVICE_NAME,
2116 .probe = vt6656_probe,
2117 .disconnect = vt6656_disconnect,
2118 .id_table = vt6656_table,
2120 .suspend = vt6656_suspend,
2121 .resume = vt6656_resume,
2122 #endif /* CONFIG_PM */
2125 static int __init vt6656_init_module(void)
2127 printk(KERN_NOTICE DEVICE_FULL_DRV_NAM " " DEVICE_VERSION);
2128 return usb_register(&vt6656_driver);
2131 static void __exit vt6656_cleanup_module(void)
2133 usb_deregister(&vt6656_driver);
2136 module_init(vt6656_init_module);
2137 module_exit(vt6656_cleanup_module);