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[] = {
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 = %pM\n",
615 pDevice->abyCurrentNetAddr);
618 // Set BB and packet type at the same time.
619 // Set Short Slot Time, xIFS, and RSPINF.
620 if (pDevice->byBBType == BB_TYPE_11A) {
621 CARDbAddBasicRate(pDevice, RATE_6M);
622 pDevice->bShortSlotTime = TRUE;
624 CARDbAddBasicRate(pDevice, RATE_1M);
625 pDevice->bShortSlotTime = FALSE;
627 BBvSetShortSlotTime(pDevice);
628 CARDvSetBSSMode(pDevice);
630 if (pDevice->bUpdateBBVGA) {
631 pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
632 pDevice->byBBVGANew = pDevice->byBBVGACurrent;
633 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
636 pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];
637 pDevice->bHWRadioOff = FALSE;
638 if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) {
639 ntStatus = CONTROLnsRequestIn(pDevice,
642 MESSAGE_REQUEST_MACREG,
646 if ( ntStatus != STATUS_SUCCESS ) {
647 spin_unlock_irq(&pDevice->lock);
650 if ( (byTmp & GPIO3_DATA) == 0 ) {
651 pDevice->bHWRadioOff = TRUE;
652 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
654 MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
655 pDevice->bHWRadioOff = FALSE;
658 } //EEP_RADIOCTL_ENABLE
660 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
661 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
662 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01);
664 if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) {
665 CARDbRadioPowerOff(pDevice);
667 CARDbRadioPowerOn(pDevice);
670 spin_unlock_irq(&pDevice->lock);
671 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");
675 static BOOL device_release_WPADEV(PSDevice pDevice)
677 viawget_wpa_header *wpahdr;
679 // wait_queue_head_t Set_wait;
680 //send device close to wpa_supplicnat layer
681 if (pDevice->bWPADEVUp==TRUE) {
682 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
683 wpahdr->type = VIAWGET_DEVICECLOSE_MSG;
684 wpahdr->resp_ie_len = 0;
685 wpahdr->req_ie_len = 0;
686 skb_put(pDevice->skb, sizeof(viawget_wpa_header));
687 pDevice->skb->dev = pDevice->wpadev;
688 skb_reset_mac_header(pDevice->skb);
689 pDevice->skb->pkt_type = PACKET_HOST;
690 pDevice->skb->protocol = htons(ETH_P_802_2);
691 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
692 netif_rx(pDevice->skb);
693 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
695 //wait release WPADEV
696 // init_waitqueue_head(&Set_wait);
697 // wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ); //1s wait
698 while(pDevice->bWPADEVUp==TRUE) {
699 set_current_state(TASK_UNINTERRUPTIBLE);
700 schedule_timeout (HZ/20); //wait 50ms
709 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
711 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message)
713 PSDevice device = usb_get_intfdata(intf);
715 if (!device || !device->dev)
718 if (device->flags & DEVICE_FLAGS_OPENED)
719 device_close(device->dev);
724 static int vt6656_resume(struct usb_interface *intf)
726 PSDevice device = usb_get_intfdata(intf);
728 if (!device || !device->dev)
731 if (!(device->flags & DEVICE_FLAGS_OPENED))
732 device_open(device->dev);
737 #endif /* CONFIG_PM */
739 static const struct net_device_ops device_netdev_ops = {
740 .ndo_open = device_open,
741 .ndo_stop = device_close,
742 .ndo_do_ioctl = device_ioctl,
743 .ndo_get_stats = device_get_stats,
744 .ndo_start_xmit = device_xmit,
745 .ndo_set_rx_mode = device_set_multi,
749 vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
751 u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
752 struct usb_device *udev = interface_to_usbdev(intf);
754 struct net_device *netdev = NULL;
755 PSDevice pDevice = NULL;
757 printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
758 printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
760 udev = usb_get_dev(udev);
761 netdev = alloc_etherdev(sizeof(DEVICE_INFO));
763 printk(KERN_ERR DEVICE_NAME ": allocate net device failed\n");
768 pDevice = netdev_priv(netdev);
769 memset(pDevice, 0, sizeof(DEVICE_INFO));
771 pDevice->dev = netdev;
774 device_set_options(pDevice);
775 spin_lock_init(&pDevice->lock);
777 pDevice->tx_80211 = device_dma0_tx_80211;
778 pDevice->sMgmtObj.pAdapter = (void *) pDevice;
780 netdev->netdev_ops = &device_netdev_ops;
781 netdev->wireless_handlers =
782 (struct iw_handler_def *) &iwctl_handler_def;
784 usb_set_intfdata(intf, pDevice);
785 SET_NETDEV_DEV(netdev, &intf->dev);
786 memcpy(pDevice->dev->dev_addr, fake_mac, ETH_ALEN);
787 rc = register_netdev(netdev);
789 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
793 usb_device_reset(pDevice);
796 union iwreq_data wrqu;
797 memset(&wrqu, 0, sizeof(wrqu));
798 wrqu.data.flags = RT_INSMOD_EVENT_FLAG;
799 wrqu.data.length = IFNAMSIZ;
800 wireless_send_event(pDevice->dev,
816 static void device_free_tx_bufs(PSDevice pDevice)
818 PUSB_SEND_CONTEXT pTxContext;
821 for (ii = 0; ii < pDevice->cbTD; ii++) {
823 pTxContext = pDevice->apTD[ii];
825 if (pTxContext->pUrb) {
826 usb_kill_urb(pTxContext->pUrb);
827 usb_free_urb(pTxContext->pUrb);
835 static void device_free_rx_bufs(PSDevice pDevice)
840 for (ii = 0; ii < pDevice->cbRD; ii++) {
842 pRCB = pDevice->apRCB[ii];
845 usb_kill_urb(pRCB->pUrb);
846 usb_free_urb(pRCB->pUrb);
850 dev_kfree_skb(pRCB->skb);
852 kfree(pDevice->pRCBMem);
857 static void usb_device_reset(PSDevice pDevice)
860 status = usb_reset_device(pDevice->usb);
862 printk("usb_device_reset fail status=%d\n",status);
866 static void device_free_int_bufs(PSDevice pDevice)
868 kfree(pDevice->intBuf.pDataBuf);
873 static BOOL device_alloc_bufs(PSDevice pDevice) {
875 PUSB_SEND_CONTEXT pTxContext;
880 for (ii = 0; ii < pDevice->cbTD; ii++) {
882 pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
883 if (pTxContext == NULL) {
884 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
887 pDevice->apTD[ii] = pTxContext;
888 pTxContext->pDevice = (void *) pDevice;
890 pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
891 if (pTxContext->pUrb == NULL) {
892 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
895 pTxContext->bBoolInUse = FALSE;
899 pDevice->pRCBMem = kmalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
900 if (pDevice->pRCBMem == NULL) {
901 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
906 pDevice->FirstRecvFreeList = NULL;
907 pDevice->LastRecvFreeList = NULL;
908 pDevice->FirstRecvMngList = NULL;
909 pDevice->LastRecvMngList = NULL;
910 pDevice->NumRecvFreeList = 0;
911 memset(pDevice->pRCBMem, 0, (sizeof(RCB) * pDevice->cbRD));
912 pRCB = (PRCB) pDevice->pRCBMem;
914 for (ii = 0; ii < pDevice->cbRD; ii++) {
916 pDevice->apRCB[ii] = pRCB;
917 pRCB->pDevice = (void *) pDevice;
919 pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
921 if (pRCB->pUrb == NULL) {
922 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
925 pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
926 if (pRCB->skb == NULL) {
927 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
930 pRCB->skb->dev = pDevice->dev;
931 pRCB->bBoolInUse = FALSE;
932 EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
933 pDevice->NumRecvFreeList++;
938 pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
939 if (pDevice->pControlURB == NULL) {
940 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
944 pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
945 if (pDevice->pInterruptURB == NULL) {
946 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
947 usb_free_urb(pDevice->pControlURB);
951 pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
952 if (pDevice->intBuf.pDataBuf == NULL) {
953 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
954 usb_free_urb(pDevice->pControlURB);
955 usb_free_urb(pDevice->pInterruptURB);
962 device_free_rx_bufs(pDevice);
965 device_free_tx_bufs(pDevice);
973 static BOOL device_init_defrag_cb(PSDevice pDevice) {
975 PSDeFragControlBlock pDeF;
977 /* Init the fragment ctl entries */
978 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
979 pDeF = &(pDevice->sRxDFCB[i]);
980 if (!device_alloc_frag_buf(pDevice, pDeF)) {
981 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
986 pDevice->cbDFCB = CB_MAX_RX_FRAG;
987 pDevice->cbFreeDFCB = pDevice->cbDFCB;
991 device_free_frag_bufs(pDevice);
997 static void device_free_frag_bufs(PSDevice pDevice) {
998 PSDeFragControlBlock pDeF;
1001 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1003 pDeF = &(pDevice->sRxDFCB[i]);
1006 dev_kfree_skb(pDeF->skb);
1012 BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1014 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1015 if (pDeF->skb == NULL)
1018 pDeF->skb->dev = pDevice->dev;
1024 /*-----------------------------------------------------------------*/
1026 static int device_open(struct net_device *dev) {
1027 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1029 extern SWPAResult wpa_Result;
1030 memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1031 wpa_Result.proto = 0;
1032 wpa_Result.key_mgmt = 0;
1033 wpa_Result.eap_type = 0;
1034 wpa_Result.authenticated = FALSE;
1035 pDevice->fWPA_Authened = FALSE;
1037 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
1040 pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
1042 if (device_alloc_bufs(pDevice) == FALSE) {
1043 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
1047 if (device_init_defrag_cb(pDevice)== FALSE) {
1048 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragement cb fail \n");
1052 MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
1053 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
1054 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
1055 MP_SET_FLAG(pDevice, fMP_POST_READS);
1056 MP_SET_FLAG(pDevice, fMP_POST_WRITES);
1059 Read_config_file(pDevice);
1061 if (device_init_registers(pDevice, DEVICE_INIT_COLD) == FALSE) {
1062 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
1066 device_set_multi(pDevice->dev);
1067 // Init for Key Management
1069 KeyvInitTable(pDevice,&pDevice->sKey);
1070 memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1071 memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1072 pDevice->bStopTx0Pkt = FALSE;
1073 pDevice->bStopDataPkt = FALSE;
1074 pDevice->bRoaming = FALSE;
1075 pDevice->bIsRoaming = FALSE;
1076 pDevice->bEnableRoaming = FALSE;
1077 if (pDevice->bDiversityRegCtlON) {
1078 device_init_diversity_timer(pDevice);
1081 vMgrObjectInit(pDevice);
1082 tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
1083 tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
1084 tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
1085 add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback));
1086 pDevice->int_interval = 100; //Max 100 microframes.
1087 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1089 pDevice->bIsRxWorkItemQueued = TRUE;
1090 pDevice->fKillEventPollingThread = FALSE;
1091 pDevice->bEventAvailable = FALSE;
1093 pDevice->bWPADEVUp = FALSE;
1094 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1095 pDevice->bwextstep0 = FALSE;
1096 pDevice->bwextstep1 = FALSE;
1097 pDevice->bwextstep2 = FALSE;
1098 pDevice->bwextstep3 = FALSE;
1099 pDevice->bWPASuppWextEnabled = FALSE;
1101 pDevice->byReAssocCount = 0;
1103 RXvWorkItem(pDevice);
1104 INTvWorkItem(pDevice);
1106 // Patch: if WEP key already set by iwconfig but device not yet open
1107 if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1108 spin_lock_irq(&pDevice->lock);
1109 KeybSetDefaultKey( pDevice,
1111 pDevice->byKeyIndex | (1 << 31),
1112 pDevice->uKeyLength,
1117 spin_unlock_irq(&pDevice->lock);
1118 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1121 if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1122 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1125 //mike:mark@2008-11-10
1126 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1127 /* bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL); */
1131 netif_stop_queue(pDevice->dev);
1132 pDevice->flags |= DEVICE_FLAGS_OPENED;
1135 union iwreq_data wrqu;
1136 memset(&wrqu, 0, sizeof(wrqu));
1137 wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1138 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1141 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1145 device_free_frag_bufs(pDevice);
1147 device_free_rx_bufs(pDevice);
1148 device_free_tx_bufs(pDevice);
1149 device_free_int_bufs(pDevice);
1150 usb_kill_urb(pDevice->pControlURB);
1151 usb_kill_urb(pDevice->pInterruptURB);
1152 usb_free_urb(pDevice->pControlURB);
1153 usb_free_urb(pDevice->pInterruptURB);
1155 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1161 static int device_close(struct net_device *dev) {
1162 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1163 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1167 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1168 if (pDevice == NULL)
1172 union iwreq_data wrqu;
1173 memset(&wrqu, 0, sizeof(wrqu));
1174 wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1175 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1178 if (pDevice->bLinkPass) {
1179 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1183 device_release_WPADEV(pDevice);
1185 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1186 pMgmt->bShareKeyAlgorithm = FALSE;
1187 pDevice->bEncryptionEnable = FALSE;
1188 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1189 spin_lock_irq(&pDevice->lock);
1190 for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1191 MACvDisableKeyEntry(pDevice,uu);
1192 spin_unlock_irq(&pDevice->lock);
1194 if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1195 MACbShutdown(pDevice);
1197 netif_stop_queue(pDevice->dev);
1198 MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1199 MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1200 MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1201 pDevice->fKillEventPollingThread = TRUE;
1202 del_timer(&pDevice->sTimerCommand);
1203 del_timer(&pMgmt->sTimerSecondCallback);
1205 del_timer(&pDevice->sTimerTxData);
1207 if (pDevice->bDiversityRegCtlON) {
1208 del_timer(&pDevice->TimerSQ3Tmax1);
1209 del_timer(&pDevice->TimerSQ3Tmax2);
1210 del_timer(&pDevice->TimerSQ3Tmax3);
1212 tasklet_kill(&pDevice->RxMngWorkItem);
1213 tasklet_kill(&pDevice->ReadWorkItem);
1214 tasklet_kill(&pDevice->EventWorkItem);
1216 pDevice->bRoaming = FALSE;
1217 pDevice->bIsRoaming = FALSE;
1218 pDevice->bEnableRoaming = FALSE;
1219 pDevice->bCmdRunning = FALSE;
1220 pDevice->bLinkPass = FALSE;
1221 memset(pMgmt->abyCurrBSSID, 0, 6);
1222 pMgmt->eCurrState = WMAC_STATE_IDLE;
1224 pDevice->flags &= ~DEVICE_FLAGS_OPENED;
1226 device_free_tx_bufs(pDevice);
1227 device_free_rx_bufs(pDevice);
1228 device_free_int_bufs(pDevice);
1229 device_free_frag_bufs(pDevice);
1231 usb_kill_urb(pDevice->pControlURB);
1232 usb_kill_urb(pDevice->pInterruptURB);
1233 usb_free_urb(pDevice->pControlURB);
1234 usb_free_urb(pDevice->pInterruptURB);
1236 BSSvClearNodeDBTable(pDevice, 0);
1238 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1243 static void __devexit vt6656_disconnect(struct usb_interface *intf)
1245 PSDevice device = usb_get_intfdata(intf);
1251 union iwreq_data req;
1252 memset(&req, 0, sizeof(req));
1253 req.data.flags = RT_RMMOD_EVENT_FLAG;
1254 wireless_send_event(device->dev, IWEVCUSTOM, &req, NULL);
1257 device_release_WPADEV(device);
1259 if (device->firmware)
1260 release_firmware(device->firmware);
1262 usb_set_intfdata(intf, NULL);
1263 usb_put_dev(interface_to_usbdev(intf));
1265 device->flags |= DEVICE_FLAGS_UNPLUG;
1268 unregister_netdev(device->dev);
1269 wpa_set_wpadev(device, 0);
1270 free_netdev(device->dev);
1274 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1276 PSDevice pDevice = netdev_priv(dev);
1278 spin_lock_irq(&pDevice->lock);
1280 if (unlikely(pDevice->bStopTx0Pkt))
1281 dev_kfree_skb_irq(skb);
1283 vDMA0_tx_80211(pDevice, skb);
1285 spin_unlock_irq(&pDevice->lock);
1287 return NETDEV_TX_OK;
1290 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1292 PSDevice pDevice = netdev_priv(dev);
1293 struct net_device_stats *stats = &pDevice->stats;
1295 spin_lock_irq(&pDevice->lock);
1297 netif_stop_queue(dev);
1299 if (!pDevice->bLinkPass) {
1300 dev_kfree_skb_irq(skb);
1304 if (pDevice->bStopDataPkt) {
1305 dev_kfree_skb_irq(skb);
1306 stats->tx_dropped++;
1310 if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1311 if (netif_queue_stopped(dev))
1312 netif_wake_queue(dev);
1316 spin_unlock_irq(&pDevice->lock);
1318 return NETDEV_TX_OK;
1321 static unsigned const ethernet_polynomial = 0x04c11db7U;
1322 static inline u32 ether_crc(int length, unsigned char *data)
1326 while(--length >= 0) {
1327 unsigned char current_octet = *data++;
1329 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1331 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1337 //find out the start position of str2 from str1
1338 static unsigned char *kstrstr(const unsigned char *str1,
1339 const unsigned char *str2) {
1340 int str1_len = strlen(str1);
1341 int str2_len = strlen(str2);
1343 while (str1_len >= str2_len) {
1345 if(memcmp(str1,str2,str2_len)==0)
1346 return (unsigned char *) str1;
1352 static int Config_FileGetParameter(unsigned char *string,
1353 unsigned char *dest,
1354 unsigned char *source)
1356 unsigned char buf1[100];
1357 unsigned char buf2[100];
1358 unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1362 strcat(buf1, string);
1364 source+=strlen(buf1);
1366 //find target string start point
1367 start_p = kstrstr(source,buf1);
1368 if (start_p == NULL)
1371 //check if current config line is marked by "#" ??
1372 for (ii = 1; ; ii++) {
1373 if (memcmp(start_p - ii, "\n", 1) == 0)
1375 if (memcmp(start_p - ii, "#", 1) == 0)
1379 //find target string end point
1380 end_p = kstrstr(start_p,"\n");
1381 if (end_p == NULL) { //can't find "\n",but don't care
1382 end_p=start_p+strlen(start_p); //no include "\n"
1386 memcpy(buf2,start_p,end_p-start_p); //get the tartget line
1387 buf2[end_p-start_p]='\0';
1390 start_p = kstrstr(buf2,"=");
1391 if (start_p == NULL)
1394 strcpy(buf1,start_p+1);
1398 while(*tmp_p != 0x00) {
1405 memcpy(dest,tmp_p,strlen(tmp_p));
1409 //if read fail,return NULL,or return data pointer;
1410 static unsigned char *Config_FileOperation(PSDevice pDevice)
1412 unsigned char *config_path = CONFIG_PATH;
1413 unsigned char *buffer = NULL;
1414 struct file *filp=NULL;
1415 mm_segment_t old_fs = get_fs();
1416 //int oldfsuid=0,oldfsgid=0;
1420 /* Can't do this anymore, so we rely on correct filesystem permissions:
1421 //Make sure a caller can read or write power as root
1422 oldfsuid=current->fsuid;
1423 oldfsgid=current->fsgid;
1429 filp = filp_open(config_path, O_RDWR, 0);
1431 printk("Config_FileOperation file Not exist\n");
1436 if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1437 printk("file %s cann't readable or writable?\n",config_path);
1442 buffer = kmalloc(1024, GFP_KERNEL);
1444 printk("allocate mem for file fail?\n");
1449 if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1450 printk("read file error?\n");
1455 if(filp_close(filp,NULL))
1456 printk("Config_FileOperation:close file fail\n");
1462 current->fsuid=oldfsuid;
1463 current->fsgid=oldfsgid;
1473 //return --->-1:fail; >=0:successful
1474 static int Read_config_file(PSDevice pDevice) {
1476 unsigned char tmpbuffer[100];
1477 unsigned char *buffer = NULL;
1479 //init config setting
1480 pDevice->config_file.ZoneType = -1;
1481 pDevice->config_file.eAuthenMode = -1;
1482 pDevice->config_file.eEncryptionStatus = -1;
1484 buffer = Config_FileOperation(pDevice);
1485 if (buffer == NULL) {
1492 memset(tmpbuffer,0,sizeof(tmpbuffer));
1493 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1494 if(memcmp(tmpbuffer,"USA",3)==0) {
1495 pDevice->config_file.ZoneType=ZoneType_USA;
1497 else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1498 pDevice->config_file.ZoneType=ZoneType_Japan;
1500 else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1501 pDevice->config_file.ZoneType=ZoneType_Europe;
1504 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1509 //get other parameter
1511 memset(tmpbuffer,0,sizeof(tmpbuffer));
1512 if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1513 pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1516 memset(tmpbuffer,0,sizeof(tmpbuffer));
1517 if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1518 pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1526 static void device_set_multi(struct net_device *dev) {
1527 PSDevice pDevice = (PSDevice) netdev_priv(dev);
1528 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1531 struct netdev_hw_addr *ha;
1532 BYTE pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1537 spin_lock_irq(&pDevice->lock);
1538 rc = CONTROLnsRequestIn(pDevice,
1541 MESSAGE_REQUEST_MACREG,
1545 if (rc == 0) pDevice->byRxMode = byTmpMode;
1547 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1549 if (dev->flags & IFF_PROMISC) { // Set promiscuous.
1550 DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1551 // Unconditionally log net taps.
1552 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1554 else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1555 (dev->flags & IFF_ALLMULTI)) {
1556 CONTROLnsRequestOut(pDevice,
1559 MESSAGE_REQUEST_MACREG,
1563 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1566 memset(mc_filter, 0, sizeof(mc_filter));
1567 netdev_for_each_mc_addr(ha, dev) {
1568 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1569 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1571 for (ii = 0; ii < 4; ii++) {
1572 MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1573 MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1575 pDevice->byRxMode &= ~(RCR_UNICAST);
1576 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1579 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1580 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1581 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1582 pDevice->byRxMode &= ~(RCR_UNICAST);
1584 ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1585 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1586 spin_unlock_irq(&pDevice->lock);
1591 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1592 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1594 return &pDevice->stats;
1598 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1599 PSDevice pDevice = (PSDevice)netdev_priv(dev);
1600 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1602 //BOOL bCommit = FALSE;
1603 struct iwreq *wrq = (struct iwreq *) rq;
1606 if (pMgmt == NULL) {
1614 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1621 case SIOCGIWNWID: //0x8b03 support
1622 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1623 rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
1629 // Set frequency/channel
1631 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1634 // Get frequency/channel
1636 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1639 // Set desired network name (ESSID)
1643 char essid[IW_ESSID_MAX_SIZE+1];
1644 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1648 if (copy_from_user(essid, wrq->u.essid.pointer,
1649 wrq->u.essid.length)) {
1653 rc = iwctl_siwessid(dev, NULL,
1654 &(wrq->u.essid), essid);
1659 // Get current network name (ESSID)
1663 char essid[IW_ESSID_MAX_SIZE+1];
1664 if (wrq->u.essid.pointer) {
1665 rc = iwctl_giwessid(dev, NULL,
1666 &(wrq->u.essid), essid);
1667 if (copy_to_user(wrq->u.essid.pointer,
1669 wrq->u.essid.length) )
1677 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1681 // Get current Access Point (BSSID)
1683 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1687 // Set desired station name
1689 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1693 // Get current station name
1695 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1699 // Set the desired bit-rate
1701 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1704 // Get the current bit-rate
1707 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1710 // Set the desired RTS threshold
1713 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
1716 // Get the current RTS threshold
1719 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1722 // Set the desired fragmentation threshold
1725 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1728 // Get the current fragmentation threshold
1731 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1734 // Set mode of operation
1736 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1739 // Get mode of operation
1741 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1744 // Set WEP keys and mode
1747 char abyKey[WLAN_WEP232_KEYLEN];
1749 if (wrq->u.encoding.pointer) {
1752 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
1756 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
1757 if (copy_from_user(abyKey,
1758 wrq->u.encoding.pointer,
1759 wrq->u.encoding.length)) {
1763 } else if (wrq->u.encoding.length != 0) {
1767 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1771 // Get the WEP keys and mode
1774 if (!capable(CAP_NET_ADMIN)) {
1779 char abyKey[WLAN_WEP232_KEYLEN];
1781 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1783 if (wrq->u.encoding.pointer) {
1784 if (copy_to_user(wrq->u.encoding.pointer,
1786 wrq->u.encoding.length))
1792 // Get the current Tx-Power
1794 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1799 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1805 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
1810 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
1813 // Get range of parameters
1817 struct iw_range range;
1819 rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
1820 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
1828 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
1834 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
1840 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
1844 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
1850 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
1852 if (wrq->u.data.pointer) {
1853 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
1855 if (copy_to_user(wrq->u.data.pointer,
1857 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality)))
1870 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1877 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1881 #endif // WIRELESS_SPY
1884 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
1887 if(wrq->u.data.pointer) {
1888 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
1890 if(copy_to_user(wrq->u.data.pointer,
1891 (u_char *) iwctl_private_args,
1892 sizeof(iwctl_private_args)))
1898 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1900 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH\n");
1901 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
1905 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
1906 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
1910 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
1911 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1915 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
1916 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1919 case SIOCSIWENCODEEXT:
1921 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
1922 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
1923 if(wrq->u.encoding.pointer){
1924 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
1925 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
1929 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
1933 }else if(wrq->u.encoding.length != 0){
1937 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
1941 case SIOCGIWENCODEEXT:
1942 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
1943 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
1947 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
1948 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1951 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1953 case IOCTL_CMD_TEST:
1955 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1961 pReq = (PSCmdRequest)rq;
1963 //20080130-01,<Remark> by Mike Liu
1964 // if(pDevice->bLinkPass==TRUE)
1965 pReq->wResult = MAGIC_CODE; //Linking status:0x3142
1966 //20080130-02,<Remark> by Mike Liu
1968 // pReq->wResult = MAGIC_CODE+1; //disconnect status:0x3143
1972 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
1973 (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
1981 if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
1984 rc = private_ioctl(pDevice, rq);
1985 clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
1988 case IOCTL_CMD_HOSTAPD:
1990 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1997 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
2002 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2009 rc = wpa_ioctl(pDevice, &wrq->u.data);
2013 return ethtool_ioctl(dev, (void *) rq->ifr_data);
2014 // All other calls are currently unsupported
2018 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2023 if (pDevice->bCommit) {
2024 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2025 netif_stop_queue(pDevice->dev);
2026 spin_lock_irq(&pDevice->lock);
2027 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
2028 spin_unlock_irq(&pDevice->lock);
2031 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2032 spin_lock_irq(&pDevice->lock);
2033 //2007-1121-01<Modify>by EinsnLiu
2034 if (pDevice->bLinkPass &&
2035 memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2036 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2038 pDevice->bLinkPass = FALSE;
2039 pMgmt->eCurrState = WMAC_STATE_IDLE;
2040 memset(pMgmt->abyCurrBSSID, 0, 6);
2042 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2044 netif_stop_queue(pDevice->dev);
2045 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2046 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2047 if (!pDevice->bWPASuppWextEnabled)
2049 bScheduleCommand((void *) pDevice,
2050 WLAN_CMD_BSSID_SCAN,
2051 pMgmt->abyDesireSSID);
2052 bScheduleCommand((void *) pDevice,
2055 spin_unlock_irq(&pDevice->lock);
2057 pDevice->bCommit = FALSE;
2065 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2069 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd)))
2073 case ETHTOOL_GDRVINFO: {
2074 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2075 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2076 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2077 if (copy_to_user(useraddr, &info, sizeof(info)))
2088 /*------------------------------------------------------------------*/
2090 MODULE_DEVICE_TABLE(usb, vt6656_table);
2092 static struct usb_driver vt6656_driver = {
2093 .name = DEVICE_NAME,
2094 .probe = vt6656_probe,
2095 .disconnect = vt6656_disconnect,
2096 .id_table = vt6656_table,
2098 .suspend = vt6656_suspend,
2099 .resume = vt6656_resume,
2100 #endif /* CONFIG_PM */
2103 static int __init vt6656_init_module(void)
2105 printk(KERN_NOTICE DEVICE_FULL_DRV_NAM " " DEVICE_VERSION);
2106 return usb_register(&vt6656_driver);
2109 static void __exit vt6656_cleanup_module(void)
2111 usb_deregister(&vt6656_driver);
2114 module_init(vt6656_init_module);
2115 module_exit(vt6656_cleanup_module);