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 static BOOL device_release_WPADEV(PSDevice pDevice);
287 static void usb_device_reset(PSDevice pDevice);
291 /*--------------------- Export Variables --------------------------*/
293 /*--------------------- Export Functions --------------------------*/
297 device_set_options(PSDevice pDevice) {
299 BYTE abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
300 BYTE abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
301 u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
303 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
304 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
305 memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, ETH_ALEN);
307 pDevice->cbTD = TX_DESC_DEF0;
308 pDevice->cbRD = RX_DESC_DEF0;
309 pDevice->uChannel = CHANNEL_DEF;
310 pDevice->wRTSThreshold = RTS_THRESH_DEF;
311 pDevice->wFragmentationThreshold = FRAG_THRESH_DEF;
312 pDevice->byShortRetryLimit = SHORT_RETRY_DEF;
313 pDevice->byLongRetryLimit = LONG_RETRY_DEF;
314 pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
315 pDevice->byShortPreamble = PREAMBLE_TYPE_DEF;
316 pDevice->ePSMode = PS_MODE_DEF;
317 pDevice->b11hEnable = X80211h_MODE_DEF;
318 pDevice->eOPMode = OP_MODE_DEF;
319 pDevice->uConnectionRate = DATA_RATE_DEF;
320 if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = TRUE;
321 pDevice->byBBType = BBP_TYPE_DEF;
322 pDevice->byPacketType = pDevice->byBBType;
323 pDevice->byAutoFBCtrl = AUTO_FB_0;
324 pDevice->bUpdateBBVGA = TRUE;
325 pDevice->byFOETuning = 0;
326 pDevice->byAutoPwrTunning = 0;
327 pDevice->wCTSDuration = 0;
328 pDevice->byPreambleType = 0;
329 pDevice->bExistSWNetAddr = FALSE;
330 // pDevice->bDiversityRegCtlON = TRUE;
331 pDevice->bDiversityRegCtlON = FALSE;
335 static void device_init_diversity_timer(PSDevice pDevice)
337 init_timer(&pDevice->TimerSQ3Tmax1);
338 pDevice->TimerSQ3Tmax1.data = (unsigned long)pDevice;
339 pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
340 pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
342 init_timer(&pDevice->TimerSQ3Tmax2);
343 pDevice->TimerSQ3Tmax2.data = (unsigned long)pDevice;
344 pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
345 pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
347 init_timer(&pDevice->TimerSQ3Tmax3);
348 pDevice->TimerSQ3Tmax3.data = (unsigned long)pDevice;
349 pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerSQ3Tmax3CallBack;
350 pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
357 // Initialiation of MAC & BBP registers
360 static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType)
362 u8 abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
363 u8 abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
364 u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
367 CMD_CARD_INIT sInitCmd;
368 int ntStatus = STATUS_SUCCESS;
369 RSP_CARD_INIT sInitRsp;
370 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
372 BYTE byCalibTXIQ = 0;
373 BYTE byCalibTXDC = 0;
374 BYTE byCalibRXIQ = 0;
376 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---->INIbInitAdapter. [%d][%d]\n", InitType, pDevice->byPacketType);
377 spin_lock_irq(&pDevice->lock);
378 if (InitType == DEVICE_INIT_COLD) {
379 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
380 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
381 memcpy(pDevice->abySNAP_Bridgetunnel,
382 abySNAP_Bridgetunnel,
385 if ( !FIRMWAREbCheckVersion(pDevice) ) {
386 if (FIRMWAREbDownload(pDevice) == TRUE) {
387 if (FIRMWAREbBrach2Sram(pDevice) == FALSE) {
388 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbBrach2Sram fail \n");
389 spin_unlock_irq(&pDevice->lock);
394 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbDownload fail \n");
395 spin_unlock_irq(&pDevice->lock);
400 if ( !BBbVT3184Init(pDevice) ) {
401 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" BBbVT3184Init fail \n");
402 spin_unlock_irq(&pDevice->lock);
407 sInitCmd.byInitClass = (BYTE)InitType;
408 sInitCmd.bExistSWNetAddr = (BYTE) pDevice->bExistSWNetAddr;
409 for (ii = 0; ii < 6; ii++)
410 sInitCmd.bySWNetAddr[ii] = pDevice->abyCurrentNetAddr[ii];
411 sInitCmd.byShortRetryLimit = pDevice->byShortRetryLimit;
412 sInitCmd.byLongRetryLimit = pDevice->byLongRetryLimit;
414 //issue Card_init command to device
415 ntStatus = CONTROLnsRequestOut(pDevice,
416 MESSAGE_TYPE_CARDINIT,
419 sizeof(CMD_CARD_INIT),
420 (PBYTE) &(sInitCmd));
422 if ( ntStatus != STATUS_SUCCESS ) {
423 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Issue Card init fail \n");
424 spin_unlock_irq(&pDevice->lock);
427 if (InitType == DEVICE_INIT_COLD) {
429 ntStatus = CONTROLnsRequestIn(pDevice,MESSAGE_TYPE_INIT_RSP,0,0,sizeof(RSP_CARD_INIT), (PBYTE) &(sInitRsp));
431 if (ntStatus != STATUS_SUCCESS) {
432 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Cardinit request in status fail!\n");
433 spin_unlock_irq(&pDevice->lock);
437 //Local ID for AES functions
438 ntStatus = CONTROLnsRequestIn(pDevice,
441 MESSAGE_REQUEST_MACREG,
443 &pDevice->byLocalID);
445 if ( ntStatus != STATUS_SUCCESS ) {
446 spin_unlock_irq(&pDevice->lock);
450 // Do MACbSoftwareReset in MACvInitialize
452 pDevice->bCCK = TRUE;
453 pDevice->bProtectMode = FALSE; //Only used in 11g type, sync with ERP IE
454 pDevice->bNonERPPresent = FALSE;
455 pDevice->bBarkerPreambleMd = FALSE;
456 if ( pDevice->bFixRate ) {
457 pDevice->wCurrentRate = (WORD) pDevice->uConnectionRate;
459 if ( pDevice->byBBType == BB_TYPE_11B )
460 pDevice->wCurrentRate = RATE_11M;
462 pDevice->wCurrentRate = RATE_54M;
465 CHvInitChannelTable(pDevice);
467 pDevice->byTopOFDMBasicRate = RATE_24M;
468 pDevice->byTopCCKBasicRate = RATE_1M;
469 pDevice->byRevId = 0; //Target to IF pin while programming to RF chip.
470 pDevice->byCurPwr = 0xFF;
472 pDevice->byCCKPwr = pDevice->abyEEPROM[EEP_OFS_PWR_CCK];
473 pDevice->byOFDMPwrG = pDevice->abyEEPROM[EEP_OFS_PWR_OFDMG];
475 for (ii=0;ii<14;ii++) {
476 pDevice->abyCCKPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_CCK_PWR_TBL];
477 if (pDevice->abyCCKPwrTbl[ii] == 0)
478 pDevice->abyCCKPwrTbl[ii] = pDevice->byCCKPwr;
479 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDM_PWR_TBL];
480 if (pDevice->abyOFDMPwrTbl[ii] == 0)
481 pDevice->abyOFDMPwrTbl[ii] = pDevice->byOFDMPwrG;
484 //original zonetype is USA,but customize zonetype is europe,
485 // then need recover 12,13 ,14 channel with 11 channel
486 if(((pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Japan) ||
487 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Europe))&&
488 (pDevice->byOriginalZonetype == ZoneType_USA)) {
489 for (ii = 11; ii < 14; ii++) {
490 pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];
491 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];
495 //{{ RobertYu: 20041124
496 pDevice->byOFDMPwrA = 0x34; // same as RFbMA2829SelectChannel
497 // Load OFDM A Power Table
498 for (ii=0;ii<CB_MAX_CHANNEL_5G;ii++) { //RobertYu:20041224, bug using CB_MAX_CHANNEL
499 pDevice->abyOFDMAPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDMA_PWR_TBL];
500 if (pDevice->abyOFDMAPwrTbl[ii] == 0)
501 pDevice->abyOFDMAPwrTbl[ii] = pDevice->byOFDMPwrA;
505 byAntenna = pDevice->abyEEPROM[EEP_OFS_ANTENNA];
506 if (byAntenna & EEP_ANTINV)
507 pDevice->bTxRxAntInv = TRUE;
509 pDevice->bTxRxAntInv = FALSE;
511 byAntenna &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
513 if (byAntenna == 0) // if not set default is All
514 byAntenna = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
516 if (byAntenna == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
517 pDevice->byAntennaCount = 2;
518 pDevice->byTxAntennaMode = ANT_B;
519 pDevice->dwTxAntennaSel = 1;
520 pDevice->dwRxAntennaSel = 1;
521 if (pDevice->bTxRxAntInv == TRUE)
522 pDevice->byRxAntennaMode = ANT_A;
524 pDevice->byRxAntennaMode = ANT_B;
526 if (pDevice->bDiversityRegCtlON)
527 pDevice->bDiversityEnable = TRUE;
529 pDevice->bDiversityEnable = FALSE;
531 pDevice->bDiversityEnable = FALSE;
532 pDevice->byAntennaCount = 1;
533 pDevice->dwTxAntennaSel = 0;
534 pDevice->dwRxAntennaSel = 0;
535 if (byAntenna & EEP_ANTENNA_AUX) {
536 pDevice->byTxAntennaMode = ANT_A;
537 if (pDevice->bTxRxAntInv == TRUE)
538 pDevice->byRxAntennaMode = ANT_B;
540 pDevice->byRxAntennaMode = ANT_A;
542 pDevice->byTxAntennaMode = ANT_B;
543 if (pDevice->bTxRxAntInv == TRUE)
544 pDevice->byRxAntennaMode = ANT_A;
546 pDevice->byRxAntennaMode = ANT_B;
549 pDevice->ulDiversityNValue = 100*255;
550 pDevice->ulDiversityMValue = 100*16;
552 pDevice->byTMax2 = 4;
553 pDevice->ulSQ3TH = 0;
554 pDevice->byTMax3 = 64;
555 // -----------------------------------------------------------------
557 //Get Auto Fall Back Type
558 pDevice->byAutoFBCtrl = AUTO_FB_0;
561 pDevice->uScanTime = WLAN_SCAN_MINITIME;
564 //pDevice->NetworkType = Ndis802_11Automode;
565 pDevice->eConfigPHYMode = PHY_TYPE_AUTO;
566 pDevice->byBBType = BB_TYPE_11G;
568 // initialize BBP registers
569 pDevice->ulTxPower = 25;
572 pDevice->byMinChannel = 1;
573 pDevice->byMaxChannel = CB_MAX_CHANNEL;
576 pDevice->byRFType = sInitRsp.byRFType;
578 if ((pDevice->byRFType & RF_EMU) != 0) {
579 // force change RevID for VT3253 emu
580 pDevice->byRevId = 0x80;
583 // Load EEPROM calibrated vt3266 parameters
584 if (pDevice->byRFType == RF_VT3226D0) {
585 if((pDevice->abyEEPROM[EEP_OFS_MAJOR_VER] == 0x1) &&
586 (pDevice->abyEEPROM[EEP_OFS_MINOR_VER] >= 0x4)) {
587 byCalibTXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_IQ];
588 byCalibTXDC = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_DC];
589 byCalibRXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_RX_IQ];
590 if( (byCalibTXIQ || byCalibTXDC || byCalibRXIQ) ) {
591 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFF, 0x03); // CR255, Set BB to support TX/RX IQ and DC compensation Mode
592 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFB, byCalibTXIQ); // CR251, TX I/Q Imbalance Calibration
593 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFC, byCalibTXDC); // CR252, TX DC-Offset Calibration
594 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFD, byCalibRXIQ); // CR253, RX I/Q Imbalance Calibration
596 // turn off BB Calibration compensation
597 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFF, 0x0); // CR255
601 pMgmt->eScanType = WMAC_SCAN_PASSIVE;
602 pMgmt->uCurrChannel = pDevice->uChannel;
603 pMgmt->uIBSSChannel = pDevice->uChannel;
604 CARDbSetMediaChannel(pDevice, pMgmt->uCurrChannel);
606 // get Permanent network address
607 memcpy(pDevice->abyPermanentNetAddr,&(sInitRsp.byNetAddr[0]),6);
608 memcpy(pDevice->abyCurrentNetAddr,
609 pDevice->abyPermanentNetAddr,
612 // if exist SW network address, use SW network address.
614 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %02x-%02x-%02x=%02x-%02x-%02x\n",
615 pDevice->abyCurrentNetAddr[0],
616 pDevice->abyCurrentNetAddr[1],
617 pDevice->abyCurrentNetAddr[2],
618 pDevice->abyCurrentNetAddr[3],
619 pDevice->abyCurrentNetAddr[4],
620 pDevice->abyCurrentNetAddr[5]);
625 // Set BB and packet type at the same time.
626 // Set Short Slot Time, xIFS, and RSPINF.
627 if (pDevice->byBBType == BB_TYPE_11A) {
628 CARDbAddBasicRate(pDevice, RATE_6M);
629 pDevice->bShortSlotTime = TRUE;
631 CARDbAddBasicRate(pDevice, RATE_1M);
632 pDevice->bShortSlotTime = FALSE;
634 BBvSetShortSlotTime(pDevice);
635 CARDvSetBSSMode(pDevice);
637 if (pDevice->bUpdateBBVGA) {
638 pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
639 pDevice->byBBVGANew = pDevice->byBBVGACurrent;
640 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
643 pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];
644 pDevice->bHWRadioOff = FALSE;
645 if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) {
646 ntStatus = CONTROLnsRequestIn(pDevice,
649 MESSAGE_REQUEST_MACREG,
653 if ( ntStatus != STATUS_SUCCESS ) {
654 spin_unlock_irq(&pDevice->lock);
657 if ( (byTmp & GPIO3_DATA) == 0 ) {
658 pDevice->bHWRadioOff = TRUE;
659 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
661 MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
662 pDevice->bHWRadioOff = FALSE;
665 } //EEP_RADIOCTL_ENABLE
667 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
668 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
669 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01);
671 if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) {
672 CARDbRadioPowerOff(pDevice);
674 CARDbRadioPowerOn(pDevice);
677 spin_unlock_irq(&pDevice->lock);
678 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");
682 static BOOL device_release_WPADEV(PSDevice pDevice)
684 viawget_wpa_header *wpahdr;
686 // wait_queue_head_t Set_wait;
687 //send device close to wpa_supplicnat layer
688 if (pDevice->bWPADEVUp==TRUE) {
689 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
690 wpahdr->type = VIAWGET_DEVICECLOSE_MSG;
691 wpahdr->resp_ie_len = 0;
692 wpahdr->req_ie_len = 0;
693 skb_put(pDevice->skb, sizeof(viawget_wpa_header));
694 pDevice->skb->dev = pDevice->wpadev;
695 skb_reset_mac_header(pDevice->skb);
696 pDevice->skb->pkt_type = PACKET_HOST;
697 pDevice->skb->protocol = htons(ETH_P_802_2);
698 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
699 netif_rx(pDevice->skb);
700 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
702 //wait release WPADEV
703 // init_waitqueue_head(&Set_wait);
704 // wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ); //1s wait
705 while(pDevice->bWPADEVUp==TRUE) {
706 set_current_state(TASK_UNINTERRUPTIBLE);
707 schedule_timeout (HZ/20); //wait 50ms
716 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
718 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message)
720 PSDevice device = usb_get_intfdata(intf);
722 if (!device || !device->dev)
725 if (device->flags & DEVICE_FLAGS_OPENED)
726 device_close(device->dev);
728 usb_put_dev(interface_to_usbdev(intf));
733 static int vt6656_resume(struct usb_interface *intf)
735 PSDevice device = usb_get_intfdata(intf);
737 if (!device || !device->dev)
740 usb_get_dev(interface_to_usbdev(intf));
742 if (!(device->flags & DEVICE_FLAGS_OPENED))
743 device_open(device->dev);
748 #endif /* CONFIG_PM */
750 static const struct net_device_ops device_netdev_ops = {
751 .ndo_open = device_open,
752 .ndo_stop = device_close,
753 .ndo_do_ioctl = device_ioctl,
754 .ndo_get_stats = device_get_stats,
755 .ndo_start_xmit = device_xmit,
756 .ndo_set_multicast_list = device_set_multi,
760 vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
762 u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
763 struct usb_device *udev = interface_to_usbdev(intf);
765 struct net_device *netdev = NULL;
766 PSDevice pDevice = NULL;
768 printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
769 printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
771 udev = usb_get_dev(udev);
772 netdev = alloc_etherdev(sizeof(DEVICE_INFO));
774 printk(KERN_ERR DEVICE_NAME ": allocate net device failed\n");
779 pDevice = netdev_priv(netdev);
780 memset(pDevice, 0, sizeof(DEVICE_INFO));
782 pDevice->dev = netdev;
785 device_set_options(pDevice);
786 spin_lock_init(&pDevice->lock);
788 pDevice->tx_80211 = device_dma0_tx_80211;
789 pDevice->sMgmtObj.pAdapter = (void *) pDevice;
791 netdev->netdev_ops = &device_netdev_ops;
792 netdev->wireless_handlers =
793 (struct iw_handler_def *) &iwctl_handler_def;
795 usb_set_intfdata(intf, pDevice);
796 SET_NETDEV_DEV(netdev, &intf->dev);
797 memcpy(pDevice->dev->dev_addr, fake_mac, ETH_ALEN);
798 rc = register_netdev(netdev);
800 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
804 usb_device_reset(pDevice);
807 union iwreq_data wrqu;
808 memset(&wrqu, 0, sizeof(wrqu));
809 wrqu.data.flags = RT_INSMOD_EVENT_FLAG;
810 wrqu.data.length = IFNAMSIZ;
811 wireless_send_event(pDevice->dev,
827 static void device_free_tx_bufs(PSDevice pDevice)
829 PUSB_SEND_CONTEXT pTxContext;
832 for (ii = 0; ii < pDevice->cbTD; ii++) {
834 pTxContext = pDevice->apTD[ii];
836 if (pTxContext->pUrb) {
837 usb_kill_urb(pTxContext->pUrb);
838 usb_free_urb(pTxContext->pUrb);
847 static void device_free_rx_bufs(PSDevice pDevice)
852 for (ii = 0; ii < pDevice->cbRD; ii++) {
854 pRCB = pDevice->apRCB[ii];
857 usb_kill_urb(pRCB->pUrb);
858 usb_free_urb(pRCB->pUrb);
862 dev_kfree_skb(pRCB->skb);
864 if (pDevice->pRCBMem)
865 kfree(pDevice->pRCBMem);
870 static void usb_device_reset(PSDevice pDevice)
873 status = usb_reset_device(pDevice->usb);
875 printk("usb_device_reset fail status=%d\n",status);
879 static void device_free_int_bufs(PSDevice pDevice)
881 if (pDevice->intBuf.pDataBuf != NULL)
882 kfree(pDevice->intBuf.pDataBuf);
887 static BOOL device_alloc_bufs(PSDevice pDevice) {
889 PUSB_SEND_CONTEXT pTxContext;
894 for (ii = 0; ii < pDevice->cbTD; ii++) {
896 pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
897 if (pTxContext == NULL) {
898 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
901 pDevice->apTD[ii] = pTxContext;
902 pTxContext->pDevice = (void *) pDevice;
904 pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
905 if (pTxContext->pUrb == NULL) {
906 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
909 pTxContext->bBoolInUse = FALSE;
913 pDevice->pRCBMem = kmalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
914 if (pDevice->pRCBMem == NULL) {
915 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
920 pDevice->FirstRecvFreeList = NULL;
921 pDevice->LastRecvFreeList = NULL;
922 pDevice->FirstRecvMngList = NULL;
923 pDevice->LastRecvMngList = NULL;
924 pDevice->NumRecvFreeList = 0;
925 memset(pDevice->pRCBMem, 0, (sizeof(RCB) * pDevice->cbRD));
926 pRCB = (PRCB) pDevice->pRCBMem;
928 for (ii = 0; ii < pDevice->cbRD; ii++) {
930 pDevice->apRCB[ii] = pRCB;
931 pRCB->pDevice = (void *) pDevice;
933 pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
935 if (pRCB->pUrb == NULL) {
936 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
939 pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
940 if (pRCB->skb == NULL) {
941 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
944 pRCB->skb->dev = pDevice->dev;
945 pRCB->bBoolInUse = FALSE;
946 EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
947 pDevice->NumRecvFreeList++;
952 pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
953 if (pDevice->pControlURB == NULL) {
954 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
958 pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
959 if (pDevice->pInterruptURB == NULL) {
960 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
961 usb_kill_urb(pDevice->pControlURB);
962 usb_free_urb(pDevice->pControlURB);
966 pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
967 if (pDevice->intBuf.pDataBuf == NULL) {
968 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
969 usb_kill_urb(pDevice->pControlURB);
970 usb_kill_urb(pDevice->pInterruptURB);
971 usb_free_urb(pDevice->pControlURB);
972 usb_free_urb(pDevice->pInterruptURB);
979 device_free_rx_bufs(pDevice);
982 device_free_tx_bufs(pDevice);
990 static BOOL device_init_defrag_cb(PSDevice pDevice) {
992 PSDeFragControlBlock pDeF;
994 /* Init the fragment ctl entries */
995 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
996 pDeF = &(pDevice->sRxDFCB[i]);
997 if (!device_alloc_frag_buf(pDevice, pDeF)) {
998 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
1003 pDevice->cbDFCB = CB_MAX_RX_FRAG;
1004 pDevice->cbFreeDFCB = pDevice->cbDFCB;
1008 device_free_frag_bufs(pDevice);
1014 static void device_free_frag_bufs(PSDevice pDevice) {
1015 PSDeFragControlBlock pDeF;
1018 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1020 pDeF = &(pDevice->sRxDFCB[i]);
1023 dev_kfree_skb(pDeF->skb);
1029 BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1031 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1032 if (pDeF->skb == NULL)
1035 pDeF->skb->dev = pDevice->dev;
1041 /*-----------------------------------------------------------------*/
1043 static int device_open(struct net_device *dev) {
1044 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1046 extern SWPAResult wpa_Result;
1047 memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1048 wpa_Result.proto = 0;
1049 wpa_Result.key_mgmt = 0;
1050 wpa_Result.eap_type = 0;
1051 wpa_Result.authenticated = FALSE;
1052 pDevice->fWPA_Authened = FALSE;
1054 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
1057 pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
1059 if (device_alloc_bufs(pDevice) == FALSE) {
1060 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
1064 if (device_init_defrag_cb(pDevice)== FALSE) {
1065 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragement cb fail \n");
1069 MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
1070 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
1071 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
1072 MP_SET_FLAG(pDevice, fMP_POST_READS);
1073 MP_SET_FLAG(pDevice, fMP_POST_WRITES);
1076 Read_config_file(pDevice);
1078 if (device_init_registers(pDevice, DEVICE_INIT_COLD) == FALSE) {
1079 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
1083 device_set_multi(pDevice->dev);
1084 // Init for Key Management
1086 KeyvInitTable(pDevice,&pDevice->sKey);
1087 memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1088 memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1089 pDevice->bStopTx0Pkt = FALSE;
1090 pDevice->bStopDataPkt = FALSE;
1091 pDevice->bRoaming = FALSE;
1092 pDevice->bIsRoaming = FALSE;
1093 pDevice->bEnableRoaming = FALSE;
1094 if (pDevice->bDiversityRegCtlON) {
1095 device_init_diversity_timer(pDevice);
1098 vMgrObjectInit(pDevice);
1099 tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
1100 tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
1101 tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
1102 add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback));
1103 pDevice->int_interval = 100; //Max 100 microframes.
1104 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1106 pDevice->bIsRxWorkItemQueued = TRUE;
1107 pDevice->fKillEventPollingThread = FALSE;
1108 pDevice->bEventAvailable = FALSE;
1110 pDevice->bWPADEVUp = FALSE;
1111 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1112 pDevice->bwextstep0 = FALSE;
1113 pDevice->bwextstep1 = FALSE;
1114 pDevice->bwextstep2 = FALSE;
1115 pDevice->bwextstep3 = FALSE;
1116 pDevice->bWPASuppWextEnabled = FALSE;
1118 pDevice->byReAssocCount = 0;
1120 RXvWorkItem(pDevice);
1121 INTvWorkItem(pDevice);
1123 // Patch: if WEP key already set by iwconfig but device not yet open
1124 if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1125 spin_lock_irq(&pDevice->lock);
1126 KeybSetDefaultKey( pDevice,
1128 pDevice->byKeyIndex | (1 << 31),
1129 pDevice->uKeyLength,
1134 spin_unlock_irq(&pDevice->lock);
1135 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1138 if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1139 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1142 //mike:mark@2008-11-10
1143 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1144 /* bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL); */
1148 netif_stop_queue(pDevice->dev);
1149 pDevice->flags |= DEVICE_FLAGS_OPENED;
1152 union iwreq_data wrqu;
1153 memset(&wrqu, 0, sizeof(wrqu));
1154 wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1155 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1158 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1162 device_free_frag_bufs(pDevice);
1164 device_free_rx_bufs(pDevice);
1165 device_free_tx_bufs(pDevice);
1166 device_free_int_bufs(pDevice);
1167 usb_kill_urb(pDevice->pControlURB);
1168 usb_kill_urb(pDevice->pInterruptURB);
1169 usb_free_urb(pDevice->pControlURB);
1170 usb_free_urb(pDevice->pInterruptURB);
1172 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1178 static int device_close(struct net_device *dev) {
1179 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1180 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1184 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1185 if (pDevice == NULL)
1189 union iwreq_data wrqu;
1190 memset(&wrqu, 0, sizeof(wrqu));
1191 wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1192 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1195 if (pDevice->bLinkPass) {
1196 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1200 device_release_WPADEV(pDevice);
1202 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1203 pMgmt->bShareKeyAlgorithm = FALSE;
1204 pDevice->bEncryptionEnable = FALSE;
1205 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1206 spin_lock_irq(&pDevice->lock);
1207 for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1208 MACvDisableKeyEntry(pDevice,uu);
1209 spin_unlock_irq(&pDevice->lock);
1211 if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1212 MACbShutdown(pDevice);
1214 netif_stop_queue(pDevice->dev);
1215 MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1216 MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1217 MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1218 pDevice->fKillEventPollingThread = TRUE;
1219 del_timer(&pDevice->sTimerCommand);
1220 del_timer(&pMgmt->sTimerSecondCallback);
1222 del_timer(&pDevice->sTimerTxData);
1224 if (pDevice->bDiversityRegCtlON) {
1225 del_timer(&pDevice->TimerSQ3Tmax1);
1226 del_timer(&pDevice->TimerSQ3Tmax2);
1227 del_timer(&pDevice->TimerSQ3Tmax3);
1229 tasklet_kill(&pDevice->RxMngWorkItem);
1230 tasklet_kill(&pDevice->ReadWorkItem);
1231 tasklet_kill(&pDevice->EventWorkItem);
1233 pDevice->bRoaming = FALSE;
1234 pDevice->bIsRoaming = FALSE;
1235 pDevice->bEnableRoaming = FALSE;
1236 pDevice->bCmdRunning = FALSE;
1237 pDevice->bLinkPass = FALSE;
1238 memset(pMgmt->abyCurrBSSID, 0, 6);
1239 pMgmt->eCurrState = WMAC_STATE_IDLE;
1241 device_free_tx_bufs(pDevice);
1242 device_free_rx_bufs(pDevice);
1243 device_free_int_bufs(pDevice);
1244 device_free_frag_bufs(pDevice);
1246 usb_kill_urb(pDevice->pControlURB);
1247 usb_kill_urb(pDevice->pInterruptURB);
1248 usb_free_urb(pDevice->pControlURB);
1249 usb_free_urb(pDevice->pInterruptURB);
1251 BSSvClearNodeDBTable(pDevice, 0);
1252 pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1254 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1259 static void __devexit vt6656_disconnect(struct usb_interface *intf)
1261 PSDevice device = usb_get_intfdata(intf);
1267 union iwreq_data req;
1268 memset(&req, 0, sizeof(req));
1269 req.data.flags = RT_RMMOD_EVENT_FLAG;
1270 wireless_send_event(device->dev, IWEVCUSTOM, &req, NULL);
1273 device_release_WPADEV(device);
1275 if (device->firmware)
1276 release_firmware(device->firmware);
1278 usb_set_intfdata(intf, NULL);
1279 usb_put_dev(interface_to_usbdev(intf));
1281 device->flags |= DEVICE_FLAGS_UNPLUG;
1284 unregister_netdev(device->dev);
1285 wpa_set_wpadev(device, 0);
1286 free_netdev(device->dev);
1290 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1292 PSDevice pDevice = netdev_priv(dev);
1294 spin_lock_irq(&pDevice->lock);
1296 if (unlikely(pDevice->bStopTx0Pkt))
1297 dev_kfree_skb_irq(skb);
1299 vDMA0_tx_80211(pDevice, skb);
1301 spin_unlock_irq(&pDevice->lock);
1303 return NETDEV_TX_OK;
1306 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1308 PSDevice pDevice = netdev_priv(dev);
1309 struct net_device_stats *stats = &pDevice->stats;
1311 spin_lock_irq(&pDevice->lock);
1313 netif_stop_queue(dev);
1315 if (!pDevice->bLinkPass) {
1316 dev_kfree_skb_irq(skb);
1320 if (pDevice->bStopDataPkt) {
1321 dev_kfree_skb_irq(skb);
1322 stats->tx_dropped++;
1326 if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1327 if (netif_queue_stopped(dev))
1328 netif_wake_queue(dev);
1332 spin_unlock_irq(&pDevice->lock);
1334 return NETDEV_TX_OK;
1337 static unsigned const ethernet_polynomial = 0x04c11db7U;
1338 static inline u32 ether_crc(int length, unsigned char *data)
1342 while(--length >= 0) {
1343 unsigned char current_octet = *data++;
1345 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1347 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1353 //find out the start position of str2 from str1
1354 static unsigned char *kstrstr(const unsigned char *str1,
1355 const unsigned char *str2) {
1356 int str1_len = strlen(str1);
1357 int str2_len = strlen(str2);
1359 while (str1_len >= str2_len) {
1361 if(memcmp(str1,str2,str2_len)==0)
1362 return (unsigned char *) str1;
1368 static int Config_FileGetParameter(unsigned char *string,
1369 unsigned char *dest,
1370 unsigned char *source)
1372 unsigned char buf1[100];
1373 unsigned char buf2[100];
1374 unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1378 strcat(buf1, string);
1380 source+=strlen(buf1);
1382 //find target string start point
1383 start_p = kstrstr(source,buf1);
1384 if (start_p == NULL)
1387 //check if current config line is marked by "#" ??
1388 for (ii = 1; ; ii++) {
1389 if (memcmp(start_p - ii, "\n", 1) == 0)
1391 if (memcmp(start_p - ii, "#", 1) == 0)
1395 //find target string end point
1396 end_p = kstrstr(start_p,"\n");
1397 if (end_p == NULL) { //can't find "\n",but don't care
1398 end_p=start_p+strlen(start_p); //no include "\n"
1402 memcpy(buf2,start_p,end_p-start_p); //get the tartget line
1403 buf2[end_p-start_p]='\0';
1406 start_p = kstrstr(buf2,"=");
1407 if (start_p == NULL)
1410 strcpy(buf1,start_p+1);
1414 while(*tmp_p != 0x00) {
1421 memcpy(dest,tmp_p,strlen(tmp_p));
1425 //if read fail,return NULL,or return data pointer;
1426 static unsigned char *Config_FileOperation(PSDevice pDevice)
1428 unsigned char *config_path = CONFIG_PATH;
1429 unsigned char *buffer = NULL;
1430 struct file *filp=NULL;
1431 mm_segment_t old_fs = get_fs();
1432 //int oldfsuid=0,oldfsgid=0;
1436 /* Can't do this anymore, so we rely on correct filesystem permissions:
1437 //Make sure a caller can read or write power as root
1438 oldfsuid=current->fsuid;
1439 oldfsgid=current->fsgid;
1445 filp = filp_open(config_path, O_RDWR, 0);
1447 printk("Config_FileOperation file Not exist\n");
1452 if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1453 printk("file %s cann't readable or writable?\n",config_path);
1458 buffer = kmalloc(1024, GFP_KERNEL);
1460 printk("alllocate mem for file fail?\n");
1465 if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1466 printk("read file error?\n");
1471 if(filp_close(filp,NULL))
1472 printk("Config_FileOperation:close file fail\n");
1478 current->fsuid=oldfsuid;
1479 current->fsgid=oldfsgid;
1490 //return --->-1:fail; >=0:successful
1491 static int Read_config_file(PSDevice pDevice) {
1493 unsigned char tmpbuffer[100];
1494 unsigned char *buffer = NULL;
1496 //init config setting
1497 pDevice->config_file.ZoneType = -1;
1498 pDevice->config_file.eAuthenMode = -1;
1499 pDevice->config_file.eEncryptionStatus = -1;
1501 buffer = Config_FileOperation(pDevice);
1502 if (buffer == NULL) {
1509 memset(tmpbuffer,0,sizeof(tmpbuffer));
1510 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1511 if(memcmp(tmpbuffer,"USA",3)==0) {
1512 pDevice->config_file.ZoneType=ZoneType_USA;
1514 else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1515 pDevice->config_file.ZoneType=ZoneType_Japan;
1517 else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1518 pDevice->config_file.ZoneType=ZoneType_Europe;
1521 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1526 //get other parameter
1528 memset(tmpbuffer,0,sizeof(tmpbuffer));
1529 if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1530 pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1533 memset(tmpbuffer,0,sizeof(tmpbuffer));
1534 if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1535 pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1543 static void device_set_multi(struct net_device *dev) {
1544 PSDevice pDevice = (PSDevice) netdev_priv(dev);
1545 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1548 struct netdev_hw_addr *ha;
1549 BYTE pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1554 spin_lock_irq(&pDevice->lock);
1555 rc = CONTROLnsRequestIn(pDevice,
1558 MESSAGE_REQUEST_MACREG,
1562 if (rc == 0) pDevice->byRxMode = byTmpMode;
1564 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1566 if (dev->flags & IFF_PROMISC) { // Set promiscuous.
1567 DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1568 // Unconditionally log net taps.
1569 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1571 else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1572 (dev->flags & IFF_ALLMULTI)) {
1573 CONTROLnsRequestOut(pDevice,
1576 MESSAGE_REQUEST_MACREG,
1580 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1583 memset(mc_filter, 0, sizeof(mc_filter));
1584 netdev_for_each_mc_addr(ha, dev) {
1585 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1586 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1588 for (ii = 0; ii < 4; ii++) {
1589 MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1590 MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1592 pDevice->byRxMode &= ~(RCR_UNICAST);
1593 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1596 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1597 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1598 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1599 pDevice->byRxMode &= ~(RCR_UNICAST);
1601 ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1602 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1603 spin_unlock_irq(&pDevice->lock);
1608 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1609 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1611 return &pDevice->stats;
1615 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1616 PSDevice pDevice = (PSDevice)netdev_priv(dev);
1617 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1619 //BOOL bCommit = FALSE;
1620 struct iwreq *wrq = (struct iwreq *) rq;
1623 if (pMgmt == NULL) {
1631 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1638 case SIOCGIWNWID: //0x8b03 support
1639 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1640 rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
1646 // Set frequency/channel
1648 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1651 // Get frequency/channel
1653 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1656 // Set desired network name (ESSID)
1660 char essid[IW_ESSID_MAX_SIZE+1];
1661 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1665 if (copy_from_user(essid, wrq->u.essid.pointer,
1666 wrq->u.essid.length)) {
1670 rc = iwctl_siwessid(dev, NULL,
1671 &(wrq->u.essid), essid);
1676 // Get current network name (ESSID)
1680 char essid[IW_ESSID_MAX_SIZE+1];
1681 if (wrq->u.essid.pointer) {
1682 rc = iwctl_giwessid(dev, NULL,
1683 &(wrq->u.essid), essid);
1684 if (copy_to_user(wrq->u.essid.pointer,
1686 wrq->u.essid.length) )
1694 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1698 // Get current Access Point (BSSID)
1700 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1704 // Set desired station name
1706 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1710 // Get current station name
1712 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1716 // Set the desired bit-rate
1718 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1721 // Get the current bit-rate
1724 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1727 // Set the desired RTS threshold
1730 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
1733 // Get the current RTS threshold
1736 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1739 // Set the desired fragmentation threshold
1742 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1745 // Get the current fragmentation threshold
1748 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1751 // Set mode of operation
1753 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1756 // Get mode of operation
1758 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1761 // Set WEP keys and mode
1764 char abyKey[WLAN_WEP232_KEYLEN];
1766 if (wrq->u.encoding.pointer) {
1769 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
1773 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
1774 if (copy_from_user(abyKey,
1775 wrq->u.encoding.pointer,
1776 wrq->u.encoding.length)) {
1780 } else if (wrq->u.encoding.length != 0) {
1784 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1788 // Get the WEP keys and mode
1791 if (!capable(CAP_NET_ADMIN)) {
1796 char abyKey[WLAN_WEP232_KEYLEN];
1798 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1800 if (wrq->u.encoding.pointer) {
1801 if (copy_to_user(wrq->u.encoding.pointer,
1803 wrq->u.encoding.length))
1809 // Get the current Tx-Power
1811 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1816 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1822 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
1827 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
1830 // Get range of parameters
1834 struct iw_range range;
1836 rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
1837 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
1845 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
1851 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
1857 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
1861 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
1867 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
1869 if (wrq->u.data.pointer) {
1870 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
1872 if (copy_to_user(wrq->u.data.pointer,
1874 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality)))
1887 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1894 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1898 #endif // WIRELESS_SPY
1901 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
1904 if(wrq->u.data.pointer) {
1905 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
1907 if(copy_to_user(wrq->u.data.pointer,
1908 (u_char *) iwctl_private_args,
1909 sizeof(iwctl_private_args)))
1915 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1917 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH\n");
1918 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
1922 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
1923 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
1927 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
1928 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1932 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
1933 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1936 case SIOCSIWENCODEEXT:
1938 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
1939 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
1940 if(wrq->u.encoding.pointer){
1941 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
1942 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
1946 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
1950 }else if(wrq->u.encoding.length != 0){
1954 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
1958 case SIOCGIWENCODEEXT:
1959 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
1960 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
1964 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
1965 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1968 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1970 case IOCTL_CMD_TEST:
1972 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1978 pReq = (PSCmdRequest)rq;
1980 //20080130-01,<Remark> by Mike Liu
1981 // if(pDevice->bLinkPass==TRUE)
1982 pReq->wResult = MAGIC_CODE; //Linking status:0x3142
1983 //20080130-02,<Remark> by Mike Liu
1985 // pReq->wResult = MAGIC_CODE+1; //disconnect status:0x3143
1989 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
1990 (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
1998 if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
2001 rc = private_ioctl(pDevice, rq);
2002 clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
2005 case IOCTL_CMD_HOSTAPD:
2007 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2014 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
2019 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2026 rc = wpa_ioctl(pDevice, &wrq->u.data);
2030 return ethtool_ioctl(dev, (void *) rq->ifr_data);
2031 // All other calls are currently unsupported
2035 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2040 if (pDevice->bCommit) {
2041 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2042 netif_stop_queue(pDevice->dev);
2043 spin_lock_irq(&pDevice->lock);
2044 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
2045 spin_unlock_irq(&pDevice->lock);
2048 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2049 spin_lock_irq(&pDevice->lock);
2050 //2007-1121-01<Modify>by EinsnLiu
2051 if (pDevice->bLinkPass &&
2052 memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2053 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2055 pDevice->bLinkPass = FALSE;
2056 pMgmt->eCurrState = WMAC_STATE_IDLE;
2057 memset(pMgmt->abyCurrBSSID, 0, 6);
2059 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2061 netif_stop_queue(pDevice->dev);
2062 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2063 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2064 if (!pDevice->bWPASuppWextEnabled)
2066 bScheduleCommand((void *) pDevice,
2067 WLAN_CMD_BSSID_SCAN,
2068 pMgmt->abyDesireSSID);
2069 bScheduleCommand((void *) pDevice,
2072 spin_unlock_irq(&pDevice->lock);
2074 pDevice->bCommit = FALSE;
2082 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2086 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd)))
2090 case ETHTOOL_GDRVINFO: {
2091 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2092 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2093 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2094 if (copy_to_user(useraddr, &info, sizeof(info)))
2105 /*------------------------------------------------------------------*/
2107 MODULE_DEVICE_TABLE(usb, vt6656_table);
2109 static struct usb_driver vt6656_driver = {
2110 .name = DEVICE_NAME,
2111 .probe = vt6656_probe,
2112 .disconnect = vt6656_disconnect,
2113 .id_table = vt6656_table,
2115 .suspend = vt6656_suspend,
2116 .resume = vt6656_resume,
2117 #endif /* CONFIG_PM */
2120 static int __init vt6656_init_module(void)
2122 printk(KERN_NOTICE DEVICE_FULL_DRV_NAM " " DEVICE_VERSION);
2123 return usb_register(&vt6656_driver);
2126 static void __exit vt6656_cleanup_module(void)
2128 usb_deregister(&vt6656_driver);
2131 module_init(vt6656_init_module);
2132 module_exit(vt6656_cleanup_module);