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 - asynchronous data tx function
33 * device_set_multi - set mac filter
34 * device_ioctl - ioctl entry
35 * device_close - shutdown mac/bbp & free dma/descriptor 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 buffered frame via dma0
40 * device_init_registers- initial MAC & BBP & RF internal registers.
41 * device_init_rings- initial tx/rx ring buffer
42 * device_init_defrag_cb- initial & allocate de-fragement buffer.
43 * device_tx_srv- tx interrupt service function
49 #include <linux/file.h>
76 /* static int msglevel = MSG_LEVEL_DEBUG; */
77 static int msglevel =MSG_LEVEL_INFO;
80 * define module options
83 /* version information */
84 #define DRIVER_AUTHOR \
85 "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_DEF0 64
96 DEVICE_PARAM(RxDescriptors0,"Number of receive usb desc buffer");
98 #define TX_DESC_DEF0 64
99 DEVICE_PARAM(TxDescriptors0,"Number of transmit usb desc buffer");
101 #define CHANNEL_DEF 6
102 DEVICE_PARAM(Channel, "Channel number");
104 /* PreambleType[] is the preamble length used for transmit.
105 0: indicate allows long preamble type
106 1: indicate allows short preamble type
109 #define PREAMBLE_TYPE_DEF 1
111 DEVICE_PARAM(PreambleType, "Preamble Type");
113 #define RTS_THRESH_DEF 2347
114 DEVICE_PARAM(RTSThreshold, "RTS threshold");
116 #define FRAG_THRESH_DEF 2346
117 DEVICE_PARAM(FragThreshold, "Fragmentation threshold");
119 #define DATA_RATE_DEF 13
121 0: indicate 1 Mbps 0x02
122 1: indicate 2 Mbps 0x04
123 2: indicate 5.5 Mbps 0x0B
124 3: indicate 11 Mbps 0x16
125 4: indicate 6 Mbps 0x0c
126 5: indicate 9 Mbps 0x12
127 6: indicate 12 Mbps 0x18
128 7: indicate 18 Mbps 0x24
129 8: indicate 24 Mbps 0x30
130 9: indicate 36 Mbps 0x48
131 10: indicate 48 Mbps 0x60
132 11: indicate 54 Mbps 0x6c
133 12: indicate 72 Mbps 0x90
134 13: indicate auto rate
137 DEVICE_PARAM(ConnectionRate, "Connection data rate");
139 #define OP_MODE_DEF 0
140 DEVICE_PARAM(OPMode, "Infrastruct, adhoc, AP mode ");
142 /* OpMode[] is used for transmit.
143 0: indicate infrastruct mode used
144 1: indicate adhoc mode used
145 2: indicate AP mode used
149 0: indicate disable power saving mode
150 1: indicate enable power saving mode
153 #define PS_MODE_DEF 0
154 DEVICE_PARAM(PSMode, "Power saving mode");
156 #define SHORT_RETRY_DEF 8
157 DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits");
159 #define LONG_RETRY_DEF 4
160 DEVICE_PARAM(LongRetryLimit, "long frame retry limits");
162 /* BasebandType[] baseband type selected
163 0: indicate 802.11a type
164 1: indicate 802.11b type
165 2: indicate 802.11g type
168 #define BBP_TYPE_DEF 2
169 DEVICE_PARAM(BasebandType, "baseband type");
172 0: indicate disable 802.11h
173 1: indicate enable 802.11h
176 #define X80211h_MODE_DEF 0
178 DEVICE_PARAM(b80211hEnable, "802.11h mode");
181 * Static vars definitions
184 static struct usb_device_id vt6656_table[] = {
185 {USB_DEVICE(VNT_USB_VENDOR_ID, VNT_USB_PRODUCT_ID)},
189 /* frequency list (map channels to frequencies) */
191 static const long frequency_list[] = {
192 2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484,
193 4915, 4920, 4925, 4935, 4940, 4945, 4960, 4980,
194 5035, 5040, 5045, 5055, 5060, 5080, 5170, 5180, 5190, 5200, 5210, 5220, 5230, 5240,
195 5260, 5280, 5300, 5320, 5500, 5520, 5540, 5560, 5580, 5600, 5620, 5640, 5660, 5680,
196 5700, 5745, 5765, 5785, 5805, 5825
199 static const struct iw_handler_def iwctl_handler_def;
202 static int vt6656_probe(struct usb_interface *intf,
203 const struct usb_device_id *id);
204 static void vt6656_disconnect(struct usb_interface *intf);
206 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
207 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message);
208 static int vt6656_resume(struct usb_interface *intf);
209 #endif /* CONFIG_PM */
211 static struct net_device_stats *device_get_stats(struct net_device *dev);
212 static int device_open(struct net_device *dev);
213 static int device_xmit(struct sk_buff *skb, struct net_device *dev);
214 static void device_set_multi(struct net_device *dev);
215 static int device_close(struct net_device *dev);
216 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
218 static int device_init_registers(struct vnt_private *pDevice,
219 DEVICE_INIT_TYPE InitType);
220 static bool device_init_defrag_cb(struct vnt_private *pDevice);
221 static void device_init_diversity_timer(struct vnt_private *pDevice);
222 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
224 static int ethtool_ioctl(struct net_device *dev, void *useraddr);
225 static void device_free_tx_bufs(struct vnt_private *pDevice);
226 static void device_free_rx_bufs(struct vnt_private *pDevice);
227 static void device_free_int_bufs(struct vnt_private *pDevice);
228 static void device_free_frag_bufs(struct vnt_private *pDevice);
229 static bool device_alloc_bufs(struct vnt_private *pDevice);
231 static int Read_config_file(struct vnt_private *pDevice);
232 static unsigned char *Config_FileOperation(struct vnt_private *pDevice);
233 static int Config_FileGetParameter(unsigned char *string,
235 unsigned char *source);
237 static void usb_device_reset(struct vnt_private *pDevice);
240 device_set_options(struct vnt_private *pDevice) {
242 u8 abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
243 u8 abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
244 u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
246 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
247 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
248 memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, ETH_ALEN);
250 pDevice->cbTD = TX_DESC_DEF0;
251 pDevice->cbRD = RX_DESC_DEF0;
252 pDevice->uChannel = CHANNEL_DEF;
253 pDevice->wRTSThreshold = RTS_THRESH_DEF;
254 pDevice->wFragmentationThreshold = FRAG_THRESH_DEF;
255 pDevice->byShortRetryLimit = SHORT_RETRY_DEF;
256 pDevice->byLongRetryLimit = LONG_RETRY_DEF;
257 pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
258 pDevice->byShortPreamble = PREAMBLE_TYPE_DEF;
259 pDevice->ePSMode = PS_MODE_DEF;
260 pDevice->b11hEnable = X80211h_MODE_DEF;
261 pDevice->eOPMode = OP_MODE_DEF;
262 pDevice->uConnectionRate = DATA_RATE_DEF;
263 if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = true;
264 pDevice->byBBType = BBP_TYPE_DEF;
265 pDevice->byPacketType = pDevice->byBBType;
266 pDevice->byAutoFBCtrl = AUTO_FB_0;
267 pDevice->bUpdateBBVGA = true;
268 pDevice->byFOETuning = 0;
269 pDevice->byAutoPwrTunning = 0;
270 pDevice->wCTSDuration = 0;
271 pDevice->byPreambleType = 0;
272 pDevice->bExistSWNetAddr = false;
273 /* pDevice->bDiversityRegCtlON = true; */
274 pDevice->bDiversityRegCtlON = false;
277 static void device_init_diversity_timer(struct vnt_private *pDevice)
279 init_timer(&pDevice->TimerSQ3Tmax1);
280 pDevice->TimerSQ3Tmax1.data = (unsigned long)pDevice;
281 pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
282 pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
284 init_timer(&pDevice->TimerSQ3Tmax2);
285 pDevice->TimerSQ3Tmax2.data = (unsigned long)pDevice;
286 pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
287 pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
289 init_timer(&pDevice->TimerSQ3Tmax3);
290 pDevice->TimerSQ3Tmax3.data = (unsigned long)pDevice;
291 pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerSQ3Tmax3CallBack;
292 pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
298 * initialization of MAC & BBP registers
301 static int device_init_registers(struct vnt_private *pDevice,
302 DEVICE_INIT_TYPE InitType)
304 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
305 u8 abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
306 u8 abySNAP_RFC1042[ETH_ALEN] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00};
307 u8 abySNAP_Bridgetunnel[ETH_ALEN]
308 = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8};
311 CMD_CARD_INIT sInitCmd;
312 int ntStatus = STATUS_SUCCESS;
313 RSP_CARD_INIT sInitRsp;
315 u8 byCalibTXIQ = 0, byCalibTXDC = 0, byCalibRXIQ = 0;
317 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---->INIbInitAdapter. [%d][%d]\n", InitType, pDevice->byPacketType);
318 spin_lock_irq(&pDevice->lock);
319 if (InitType == DEVICE_INIT_COLD) {
320 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
321 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
322 memcpy(pDevice->abySNAP_Bridgetunnel,
323 abySNAP_Bridgetunnel,
326 if ( !FIRMWAREbCheckVersion(pDevice) ) {
327 if (FIRMWAREbDownload(pDevice) == true) {
328 if (FIRMWAREbBrach2Sram(pDevice) == false) {
329 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbBrach2Sram fail \n");
330 spin_unlock_irq(&pDevice->lock);
335 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbDownload fail \n");
336 spin_unlock_irq(&pDevice->lock);
341 if ( !BBbVT3184Init(pDevice) ) {
342 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" BBbVT3184Init fail \n");
343 spin_unlock_irq(&pDevice->lock);
348 sInitCmd.byInitClass = (u8)InitType;
349 sInitCmd.bExistSWNetAddr = (u8) pDevice->bExistSWNetAddr;
350 for (ii = 0; ii < 6; ii++)
351 sInitCmd.bySWNetAddr[ii] = pDevice->abyCurrentNetAddr[ii];
352 sInitCmd.byShortRetryLimit = pDevice->byShortRetryLimit;
353 sInitCmd.byLongRetryLimit = pDevice->byLongRetryLimit;
355 /* issue card_init command to device */
356 ntStatus = CONTROLnsRequestOut(pDevice,
357 MESSAGE_TYPE_CARDINIT,
360 sizeof(CMD_CARD_INIT),
363 if ( ntStatus != STATUS_SUCCESS ) {
364 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Issue Card init fail \n");
365 spin_unlock_irq(&pDevice->lock);
368 if (InitType == DEVICE_INIT_COLD) {
370 ntStatus = CONTROLnsRequestIn(pDevice,MESSAGE_TYPE_INIT_RSP,0,0,sizeof(RSP_CARD_INIT), (u8 *) &(sInitRsp));
372 if (ntStatus != STATUS_SUCCESS) {
373 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Cardinit request in status fail!\n");
374 spin_unlock_irq(&pDevice->lock);
378 /* local ID for AES functions */
379 ntStatus = CONTROLnsRequestIn(pDevice,
382 MESSAGE_REQUEST_MACREG,
384 &pDevice->byLocalID);
386 if ( ntStatus != STATUS_SUCCESS ) {
387 spin_unlock_irq(&pDevice->lock);
391 /* do MACbSoftwareReset in MACvInitialize */
394 pDevice->bCCK = true;
395 pDevice->bProtectMode = false;
396 /* only used in 11g type, sync with ERP IE */
397 pDevice->bNonERPPresent = false;
398 pDevice->bBarkerPreambleMd = false;
399 if ( pDevice->bFixRate ) {
400 pDevice->wCurrentRate = (u16) pDevice->uConnectionRate;
402 if ( pDevice->byBBType == BB_TYPE_11B )
403 pDevice->wCurrentRate = RATE_11M;
405 pDevice->wCurrentRate = RATE_54M;
408 CHvInitChannelTable(pDevice);
410 pDevice->byTopOFDMBasicRate = RATE_24M;
411 pDevice->byTopCCKBasicRate = RATE_1M;
412 pDevice->byRevId = 0;
413 /* target to IF pin while programming to RF chip */
414 pDevice->byCurPwr = 0xFF;
416 pDevice->byCCKPwr = pDevice->abyEEPROM[EEP_OFS_PWR_CCK];
417 pDevice->byOFDMPwrG = pDevice->abyEEPROM[EEP_OFS_PWR_OFDMG];
418 /* load power table */
419 for (ii = 0; ii < 14; ii++) {
420 pDevice->abyCCKPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_CCK_PWR_TBL];
421 if (pDevice->abyCCKPwrTbl[ii] == 0)
422 pDevice->abyCCKPwrTbl[ii] = pDevice->byCCKPwr;
423 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDM_PWR_TBL];
424 if (pDevice->abyOFDMPwrTbl[ii] == 0)
425 pDevice->abyOFDMPwrTbl[ii] = pDevice->byOFDMPwrG;
429 * original zonetype is USA, but custom zonetype is Europe,
430 * then need to recover 12, 13, 14 channels with 11 channel
432 if(((pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Japan) ||
433 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Europe))&&
434 (pDevice->byOriginalZonetype == ZoneType_USA)) {
435 for (ii = 11; ii < 14; ii++) {
436 pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];
437 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];
441 pDevice->byOFDMPwrA = 0x34; /* same as RFbMA2829SelectChannel */
443 /* load OFDM A power table */
444 for (ii = 0; ii < CB_MAX_CHANNEL_5G; ii++) {
445 pDevice->abyOFDMAPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDMA_PWR_TBL];
446 if (pDevice->abyOFDMAPwrTbl[ii] == 0)
447 pDevice->abyOFDMAPwrTbl[ii] = pDevice->byOFDMPwrA;
450 byAntenna = pDevice->abyEEPROM[EEP_OFS_ANTENNA];
451 if (byAntenna & EEP_ANTINV)
452 pDevice->bTxRxAntInv = true;
454 pDevice->bTxRxAntInv = false;
456 byAntenna &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
458 if (byAntenna == 0) /* if not set default is both */
459 byAntenna = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
461 if (byAntenna == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
462 pDevice->byAntennaCount = 2;
463 pDevice->byTxAntennaMode = ANT_B;
464 pDevice->dwTxAntennaSel = 1;
465 pDevice->dwRxAntennaSel = 1;
466 if (pDevice->bTxRxAntInv == true)
467 pDevice->byRxAntennaMode = ANT_A;
469 pDevice->byRxAntennaMode = ANT_B;
471 if (pDevice->bDiversityRegCtlON)
472 pDevice->bDiversityEnable = true;
474 pDevice->bDiversityEnable = false;
476 pDevice->bDiversityEnable = false;
477 pDevice->byAntennaCount = 1;
478 pDevice->dwTxAntennaSel = 0;
479 pDevice->dwRxAntennaSel = 0;
480 if (byAntenna & EEP_ANTENNA_AUX) {
481 pDevice->byTxAntennaMode = ANT_A;
482 if (pDevice->bTxRxAntInv == true)
483 pDevice->byRxAntennaMode = ANT_B;
485 pDevice->byRxAntennaMode = ANT_A;
487 pDevice->byTxAntennaMode = ANT_B;
488 if (pDevice->bTxRxAntInv == true)
489 pDevice->byRxAntennaMode = ANT_A;
491 pDevice->byRxAntennaMode = ANT_B;
494 pDevice->ulDiversityNValue = 100*255;
495 pDevice->ulDiversityMValue = 100*16;
497 pDevice->byTMax2 = 4;
498 pDevice->ulSQ3TH = 0;
499 pDevice->byTMax3 = 64;
501 /* get Auto Fall Back type */
502 pDevice->byAutoFBCtrl = AUTO_FB_0;
505 pDevice->uScanTime = WLAN_SCAN_MINITIME;
507 /* default Auto Mode */
508 /* pDevice->NetworkType = Ndis802_11Automode; */
509 pDevice->eConfigPHYMode = PHY_TYPE_AUTO;
510 pDevice->byBBType = BB_TYPE_11G;
512 /* initialize BBP registers */
513 pDevice->ulTxPower = 25;
515 /* get channel range */
516 pDevice->byMinChannel = 1;
517 pDevice->byMaxChannel = CB_MAX_CHANNEL;
520 pDevice->byRFType = sInitRsp.byRFType;
522 if ((pDevice->byRFType & RF_EMU) != 0) {
523 /* force change RevID for VT3253 emu */
524 pDevice->byRevId = 0x80;
527 /* load vt3266 calibration parameters in EEPROM */
528 if (pDevice->byRFType == RF_VT3226D0) {
529 if((pDevice->abyEEPROM[EEP_OFS_MAJOR_VER] == 0x1) &&
530 (pDevice->abyEEPROM[EEP_OFS_MINOR_VER] >= 0x4)) {
531 byCalibTXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_IQ];
532 byCalibTXDC = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_DC];
533 byCalibRXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_RX_IQ];
534 if( (byCalibTXIQ || byCalibTXDC || byCalibRXIQ) ) {
535 /* CR255, enable TX/RX IQ and DC compensation mode */
536 ControlvWriteByte(pDevice,
537 MESSAGE_REQUEST_BBREG,
540 /* CR251, TX I/Q Imbalance Calibration */
541 ControlvWriteByte(pDevice,
542 MESSAGE_REQUEST_BBREG,
545 /* CR252, TX DC-Offset Calibration */
546 ControlvWriteByte(pDevice,
547 MESSAGE_REQUEST_BBREG,
550 /* CR253, RX I/Q Imbalance Calibration */
551 ControlvWriteByte(pDevice,
552 MESSAGE_REQUEST_BBREG,
556 /* CR255, turn off BB Calibration compensation */
557 ControlvWriteByte(pDevice,
558 MESSAGE_REQUEST_BBREG,
564 pMgmt->eScanType = WMAC_SCAN_PASSIVE;
565 pMgmt->uCurrChannel = pDevice->uChannel;
566 pMgmt->uIBSSChannel = pDevice->uChannel;
567 CARDbSetMediaChannel(pDevice, pMgmt->uCurrChannel);
569 /* get permanent network address */
570 memcpy(pDevice->abyPermanentNetAddr,&(sInitRsp.byNetAddr[0]),6);
571 memcpy(pDevice->abyCurrentNetAddr,
572 pDevice->abyPermanentNetAddr,
575 /* if exist SW network address, use it */
576 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %pM\n",
577 pDevice->abyCurrentNetAddr);
581 * set BB and packet type at the same time
582 * set Short Slot Time, xIFS, and RSPINF
584 if (pDevice->byBBType == BB_TYPE_11A) {
585 CARDbAddBasicRate(pDevice, RATE_6M);
586 pDevice->bShortSlotTime = true;
588 CARDbAddBasicRate(pDevice, RATE_1M);
589 pDevice->bShortSlotTime = false;
591 BBvSetShortSlotTime(pDevice);
592 CARDvSetBSSMode(pDevice);
594 if (pDevice->bUpdateBBVGA) {
595 pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
596 pDevice->byBBVGANew = pDevice->byBBVGACurrent;
597 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
600 pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];
601 pDevice->bHWRadioOff = false;
602 if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) {
603 ntStatus = CONTROLnsRequestIn(pDevice,
606 MESSAGE_REQUEST_MACREG,
610 if ( ntStatus != STATUS_SUCCESS ) {
611 spin_unlock_irq(&pDevice->lock);
614 if ( (byTmp & GPIO3_DATA) == 0 ) {
615 pDevice->bHWRadioOff = true;
616 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
618 MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
619 pDevice->bHWRadioOff = false;
624 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
625 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
626 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01);
628 if ((pDevice->bHWRadioOff == true) || (pDevice->bRadioControlOff == true)) {
629 CARDbRadioPowerOff(pDevice);
631 CARDbRadioPowerOn(pDevice);
634 spin_unlock_irq(&pDevice->lock);
635 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");
639 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
641 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message)
643 struct vnt_private *device = usb_get_intfdata(intf);
645 if (!device || !device->dev)
648 if (device->flags & DEVICE_FLAGS_OPENED)
649 device_close(device->dev);
654 static int vt6656_resume(struct usb_interface *intf)
656 struct vnt_private *device = usb_get_intfdata(intf);
658 if (!device || !device->dev)
661 if (!(device->flags & DEVICE_FLAGS_OPENED))
662 device_open(device->dev);
667 #endif /* CONFIG_PM */
669 static const struct net_device_ops device_netdev_ops = {
670 .ndo_open = device_open,
671 .ndo_stop = device_close,
672 .ndo_do_ioctl = device_ioctl,
673 .ndo_get_stats = device_get_stats,
674 .ndo_start_xmit = device_xmit,
675 .ndo_set_rx_mode = device_set_multi,
679 vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
681 u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
682 struct usb_device *udev = interface_to_usbdev(intf);
684 struct net_device *netdev = NULL;
685 struct vnt_private *pDevice;
687 printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
688 printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
690 udev = usb_get_dev(udev);
691 netdev = alloc_etherdev(sizeof(struct vnt_private));
693 printk(KERN_ERR DEVICE_NAME ": allocate net device failed\n");
698 pDevice = netdev_priv(netdev);
699 memset(pDevice, 0, sizeof(struct vnt_private));
701 pDevice->dev = netdev;
704 device_set_options(pDevice);
705 spin_lock_init(&pDevice->lock);
707 pDevice->tx_80211 = device_dma0_tx_80211;
708 pDevice->vnt_mgmt.pAdapter = (void *) pDevice;
710 netdev->netdev_ops = &device_netdev_ops;
711 netdev->wireless_handlers =
712 (struct iw_handler_def *) &iwctl_handler_def;
714 usb_set_intfdata(intf, pDevice);
715 SET_NETDEV_DEV(netdev, &intf->dev);
716 memcpy(pDevice->dev->dev_addr, fake_mac, ETH_ALEN);
717 rc = register_netdev(netdev);
719 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
723 usb_device_reset(pDevice);
735 static void device_free_tx_bufs(struct vnt_private *pDevice)
737 PUSB_SEND_CONTEXT pTxContext;
740 for (ii = 0; ii < pDevice->cbTD; ii++) {
742 pTxContext = pDevice->apTD[ii];
743 /* deallocate URBs */
744 if (pTxContext->pUrb) {
745 usb_kill_urb(pTxContext->pUrb);
746 usb_free_urb(pTxContext->pUrb);
753 static void device_free_rx_bufs(struct vnt_private *pDevice)
758 for (ii = 0; ii < pDevice->cbRD; ii++) {
760 pRCB = pDevice->apRCB[ii];
761 /* deallocate URBs */
763 usb_kill_urb(pRCB->pUrb);
764 usb_free_urb(pRCB->pUrb);
768 dev_kfree_skb(pRCB->skb);
770 kfree(pDevice->pRCBMem);
775 static void usb_device_reset(struct vnt_private *pDevice)
778 status = usb_reset_device(pDevice->usb);
780 printk("usb_device_reset fail status=%d\n",status);
784 static void device_free_int_bufs(struct vnt_private *pDevice)
786 kfree(pDevice->intBuf.pDataBuf);
790 static bool device_alloc_bufs(struct vnt_private *pDevice)
793 PUSB_SEND_CONTEXT pTxContext;
797 for (ii = 0; ii < pDevice->cbTD; ii++) {
799 pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
800 if (pTxContext == NULL) {
801 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
804 pDevice->apTD[ii] = pTxContext;
805 pTxContext->pDevice = (void *) pDevice;
807 pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
808 if (pTxContext->pUrb == NULL) {
809 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
812 pTxContext->bBoolInUse = false;
815 /* allocate RCB mem */
816 pDevice->pRCBMem = kzalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
817 if (pDevice->pRCBMem == NULL) {
818 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
822 pDevice->FirstRecvFreeList = NULL;
823 pDevice->LastRecvFreeList = NULL;
824 pDevice->FirstRecvMngList = NULL;
825 pDevice->LastRecvMngList = NULL;
826 pDevice->NumRecvFreeList = 0;
827 pRCB = (PRCB) pDevice->pRCBMem;
829 for (ii = 0; ii < pDevice->cbRD; ii++) {
831 pDevice->apRCB[ii] = pRCB;
832 pRCB->pDevice = (void *) pDevice;
834 pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
836 if (pRCB->pUrb == NULL) {
837 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
840 pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
841 if (pRCB->skb == NULL) {
842 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
845 pRCB->skb->dev = pDevice->dev;
846 pRCB->bBoolInUse = false;
847 EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
848 pDevice->NumRecvFreeList++;
852 pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
853 if (pDevice->pControlURB == NULL) {
854 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
858 pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
859 if (pDevice->pInterruptURB == NULL) {
860 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
861 usb_free_urb(pDevice->pControlURB);
865 pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
866 if (pDevice->intBuf.pDataBuf == NULL) {
867 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
868 usb_free_urb(pDevice->pControlURB);
869 usb_free_urb(pDevice->pInterruptURB);
876 device_free_rx_bufs(pDevice);
879 device_free_tx_bufs(pDevice);
884 static bool device_init_defrag_cb(struct vnt_private *pDevice)
887 PSDeFragControlBlock pDeF;
889 /* Init the fragment ctl entries */
890 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
891 pDeF = &(pDevice->sRxDFCB[i]);
892 if (!device_alloc_frag_buf(pDevice, pDeF)) {
893 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
898 pDevice->cbDFCB = CB_MAX_RX_FRAG;
899 pDevice->cbFreeDFCB = pDevice->cbDFCB;
903 device_free_frag_bufs(pDevice);
907 static void device_free_frag_bufs(struct vnt_private *pDevice)
909 PSDeFragControlBlock pDeF;
912 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
914 pDeF = &(pDevice->sRxDFCB[i]);
917 dev_kfree_skb(pDeF->skb);
921 int device_alloc_frag_buf(struct vnt_private *pDevice,
922 PSDeFragControlBlock pDeF)
925 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
926 if (pDeF->skb == NULL)
929 pDeF->skb->dev = pDevice->dev;
934 static int device_open(struct net_device *dev)
936 struct vnt_private *pDevice = netdev_priv(dev);
938 pDevice->fWPA_Authened = false;
940 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
942 pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
944 if (device_alloc_bufs(pDevice) == false) {
945 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
949 if (device_init_defrag_cb(pDevice)== false) {
950 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragment cb fail \n");
954 MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
955 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
956 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
957 MP_SET_FLAG(pDevice, fMP_POST_READS);
958 MP_SET_FLAG(pDevice, fMP_POST_WRITES);
960 /* read config file */
961 Read_config_file(pDevice);
963 if (device_init_registers(pDevice, DEVICE_INIT_COLD) == false) {
964 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
968 device_set_multi(pDevice->dev);
970 /* init for key management */
971 KeyvInitTable(pDevice,&pDevice->sKey);
972 memcpy(pDevice->vnt_mgmt.abyMACAddr,
973 pDevice->abyCurrentNetAddr, ETH_ALEN);
974 memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
975 pDevice->bStopTx0Pkt = false;
976 pDevice->bStopDataPkt = false;
977 pDevice->bRoaming = false;
978 pDevice->bIsRoaming = false;
979 pDevice->bEnableRoaming = false;
980 if (pDevice->bDiversityRegCtlON) {
981 device_init_diversity_timer(pDevice);
984 vMgrObjectInit(pDevice);
985 tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
986 tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
987 tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
988 add_timer(&pDevice->vnt_mgmt.sTimerSecondCallback);
989 pDevice->int_interval = 100; /* max 100 microframes */
990 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
992 pDevice->bIsRxWorkItemQueued = true;
993 pDevice->fKillEventPollingThread = false;
994 pDevice->bEventAvailable = false;
996 pDevice->bWPADEVUp = false;
997 pDevice->bwextstep0 = false;
998 pDevice->bwextstep1 = false;
999 pDevice->bwextstep2 = false;
1000 pDevice->bwextstep3 = false;
1001 pDevice->bWPASuppWextEnabled = false;
1002 pDevice->byReAssocCount = 0;
1004 RXvWorkItem(pDevice);
1005 INTvWorkItem(pDevice);
1007 /* if WEP key already set by iwconfig but device not yet open */
1008 if ((pDevice->bEncryptionEnable == true) && (pDevice->bTransmitKey == true)) {
1009 spin_lock_irq(&pDevice->lock);
1010 KeybSetDefaultKey( pDevice,
1012 pDevice->byKeyIndex | (1 << 31),
1013 pDevice->uKeyLength,
1018 spin_unlock_irq(&pDevice->lock);
1019 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1022 if (pDevice->vnt_mgmt.eConfigMode == WMAC_CONFIG_AP)
1023 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1025 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1027 netif_stop_queue(pDevice->dev);
1028 pDevice->flags |= DEVICE_FLAGS_OPENED;
1030 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success..\n");
1034 device_free_frag_bufs(pDevice);
1036 device_free_rx_bufs(pDevice);
1037 device_free_tx_bufs(pDevice);
1038 device_free_int_bufs(pDevice);
1039 usb_kill_urb(pDevice->pControlURB);
1040 usb_kill_urb(pDevice->pInterruptURB);
1041 usb_free_urb(pDevice->pControlURB);
1042 usb_free_urb(pDevice->pInterruptURB);
1044 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1048 static int device_close(struct net_device *dev)
1050 struct vnt_private *pDevice = netdev_priv(dev);
1051 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
1054 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1\n");
1055 if (pDevice == NULL)
1058 if (pDevice->bLinkPass) {
1059 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1063 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1064 pMgmt->bShareKeyAlgorithm = false;
1065 pDevice->bEncryptionEnable = false;
1066 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1067 spin_lock_irq(&pDevice->lock);
1068 for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1069 MACvDisableKeyEntry(pDevice,uu);
1070 spin_unlock_irq(&pDevice->lock);
1072 if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == false) {
1073 MACbShutdown(pDevice);
1075 netif_stop_queue(pDevice->dev);
1076 MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1077 MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1078 MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1079 pDevice->fKillEventPollingThread = true;
1080 del_timer(&pDevice->sTimerCommand);
1081 del_timer(&pMgmt->sTimerSecondCallback);
1083 del_timer(&pDevice->sTimerTxData);
1085 if (pDevice->bDiversityRegCtlON) {
1086 del_timer(&pDevice->TimerSQ3Tmax1);
1087 del_timer(&pDevice->TimerSQ3Tmax2);
1088 del_timer(&pDevice->TimerSQ3Tmax3);
1090 tasklet_kill(&pDevice->RxMngWorkItem);
1091 tasklet_kill(&pDevice->ReadWorkItem);
1092 tasklet_kill(&pDevice->EventWorkItem);
1094 pDevice->bRoaming = false;
1095 pDevice->bIsRoaming = false;
1096 pDevice->bEnableRoaming = false;
1097 pDevice->bCmdRunning = false;
1098 pDevice->bLinkPass = false;
1099 memset(pMgmt->abyCurrBSSID, 0, 6);
1100 pMgmt->eCurrState = WMAC_STATE_IDLE;
1102 pDevice->flags &= ~DEVICE_FLAGS_OPENED;
1104 device_free_tx_bufs(pDevice);
1105 device_free_rx_bufs(pDevice);
1106 device_free_int_bufs(pDevice);
1107 device_free_frag_bufs(pDevice);
1109 usb_kill_urb(pDevice->pControlURB);
1110 usb_kill_urb(pDevice->pInterruptURB);
1111 usb_free_urb(pDevice->pControlURB);
1112 usb_free_urb(pDevice->pInterruptURB);
1114 BSSvClearNodeDBTable(pDevice, 0);
1116 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1121 static void vt6656_disconnect(struct usb_interface *intf)
1123 struct vnt_private *device = usb_get_intfdata(intf);
1128 usb_set_intfdata(intf, NULL);
1129 usb_put_dev(interface_to_usbdev(intf));
1131 device->flags |= DEVICE_FLAGS_UNPLUG;
1134 unregister_netdev(device->dev);
1135 free_netdev(device->dev);
1140 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1142 struct vnt_private *pDevice = netdev_priv(dev);
1144 spin_lock_irq(&pDevice->lock);
1146 if (unlikely(pDevice->bStopTx0Pkt))
1147 dev_kfree_skb_irq(skb);
1149 vDMA0_tx_80211(pDevice, skb);
1151 spin_unlock_irq(&pDevice->lock);
1153 return NETDEV_TX_OK;
1156 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1158 struct vnt_private *pDevice = netdev_priv(dev);
1159 struct net_device_stats *stats = &pDevice->stats;
1161 spin_lock_irq(&pDevice->lock);
1163 netif_stop_queue(dev);
1165 if (!pDevice->bLinkPass) {
1166 dev_kfree_skb_irq(skb);
1170 if (pDevice->bStopDataPkt) {
1171 dev_kfree_skb_irq(skb);
1172 stats->tx_dropped++;
1176 if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1177 if (netif_queue_stopped(dev))
1178 netif_wake_queue(dev);
1182 spin_unlock_irq(&pDevice->lock);
1184 return NETDEV_TX_OK;
1187 static unsigned const ethernet_polynomial = 0x04c11db7U;
1188 static inline u32 ether_crc(int length, unsigned char *data)
1192 while(--length >= 0) {
1193 unsigned char current_octet = *data++;
1195 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1197 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1203 /* find out the start position of str2 from str1 */
1204 static unsigned char *kstrstr(const unsigned char *str1,
1205 const unsigned char *str2) {
1206 int str1_len = strlen(str1);
1207 int str2_len = strlen(str2);
1209 while (str1_len >= str2_len) {
1211 if(memcmp(str1,str2,str2_len)==0)
1212 return (unsigned char *) str1;
1218 static int Config_FileGetParameter(unsigned char *string,
1219 unsigned char *dest,
1220 unsigned char *source)
1222 unsigned char buf1[100];
1223 unsigned char buf2[100];
1224 unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1228 strcat(buf1, string);
1230 source+=strlen(buf1);
1232 /* find target string start point */
1233 start_p = kstrstr(source,buf1);
1234 if (start_p == NULL)
1237 /* check if current config line is marked by "#" */
1238 for (ii = 1; ; ii++) {
1239 if (memcmp(start_p - ii, "\n", 1) == 0)
1241 if (memcmp(start_p - ii, "#", 1) == 0)
1245 /* find target string end point */
1246 end_p = kstrstr(start_p,"\n");
1247 if (end_p == NULL) { /* can't find "\n", but don't care */
1248 end_p = start_p + strlen(start_p); /* no include "\n" */
1252 memcpy(buf2, start_p, end_p-start_p); /* get the target line */
1253 buf2[end_p-start_p]='\0';
1256 start_p = kstrstr(buf2,"=");
1257 if (start_p == NULL)
1260 strcpy(buf1,start_p+1);
1264 while(*tmp_p != 0x00) {
1271 memcpy(dest,tmp_p,strlen(tmp_p));
1275 /* if read fails, return NULL, or return data pointer */
1276 static unsigned char *Config_FileOperation(struct vnt_private *pDevice)
1278 unsigned char *buffer = kmalloc(1024, GFP_KERNEL);
1282 printk("allocate mem for file fail?\n");
1286 file = filp_open(CONFIG_PATH, O_RDONLY, 0);
1289 printk("Config_FileOperation file Not exist\n");
1293 if (kernel_read(file, 0, buffer, 1024) < 0) {
1294 printk("read file error?\n");
1303 /* return --->-1:fail; >=0:successful */
1304 static int Read_config_file(struct vnt_private *pDevice)
1307 unsigned char tmpbuffer[100];
1308 unsigned char *buffer = NULL;
1310 /* init config setting */
1311 pDevice->config_file.ZoneType = -1;
1312 pDevice->config_file.eAuthenMode = -1;
1313 pDevice->config_file.eEncryptionStatus = -1;
1315 buffer = Config_FileOperation(pDevice);
1316 if (buffer == NULL) {
1323 memset(tmpbuffer,0,sizeof(tmpbuffer));
1324 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==true) {
1325 if(memcmp(tmpbuffer,"USA",3)==0) {
1326 pDevice->config_file.ZoneType=ZoneType_USA;
1328 else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1329 pDevice->config_file.ZoneType=ZoneType_Japan;
1331 else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1332 pDevice->config_file.ZoneType=ZoneType_Europe;
1335 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1340 /* get other parameter */
1342 memset(tmpbuffer,0,sizeof(tmpbuffer));
1343 if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==true) {
1344 pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1347 memset(tmpbuffer,0,sizeof(tmpbuffer));
1348 if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==true) {
1349 pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1357 static void device_set_multi(struct net_device *dev)
1359 struct vnt_private *pDevice = netdev_priv(dev);
1360 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
1361 struct netdev_hw_addr *ha;
1364 u8 pbyData[8] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1368 spin_lock_irq(&pDevice->lock);
1369 rc = CONTROLnsRequestIn(pDevice,
1372 MESSAGE_REQUEST_MACREG,
1376 if (rc == 0) pDevice->byRxMode = byTmpMode;
1378 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1380 if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
1381 DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1382 /* unconditionally log net taps */
1383 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1385 else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1386 (dev->flags & IFF_ALLMULTI)) {
1387 CONTROLnsRequestOut(pDevice,
1390 MESSAGE_REQUEST_MACREG,
1394 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1397 memset(mc_filter, 0, sizeof(mc_filter));
1398 netdev_for_each_mc_addr(ha, dev) {
1399 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1400 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1402 for (ii = 0; ii < 4; ii++) {
1403 MACvWriteMultiAddr(pDevice, ii, *((u8 *)&mc_filter[0] + ii));
1404 MACvWriteMultiAddr(pDevice, ii+ 4, *((u8 *)&mc_filter[1] + ii));
1406 pDevice->byRxMode &= ~(RCR_UNICAST);
1407 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1410 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1412 * If AP mode, don't enable RCR_UNICAST since HW only compares
1413 * addr1 with local MAC
1415 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1416 pDevice->byRxMode &= ~(RCR_UNICAST);
1418 ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1419 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1420 spin_unlock_irq(&pDevice->lock);
1424 static struct net_device_stats *device_get_stats(struct net_device *dev)
1426 struct vnt_private *pDevice = netdev_priv(dev);
1428 return &pDevice->stats;
1431 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1433 struct vnt_private *pDevice = netdev_priv(dev);
1434 struct iwreq *wrq = (struct iwreq *) rq;
1439 case IOCTL_CMD_HOSTAPD:
1441 if (!(pDevice->flags & DEVICE_FLAGS_OPENED))
1444 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
1448 return ethtool_ioctl(dev, (void *) rq->ifr_data);
1455 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
1459 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd)))
1463 case ETHTOOL_GDRVINFO: {
1464 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
1465 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
1466 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
1467 if (copy_to_user(useraddr, &info, sizeof(info)))
1477 MODULE_DEVICE_TABLE(usb, vt6656_table);
1479 static struct usb_driver vt6656_driver = {
1480 .name = DEVICE_NAME,
1481 .probe = vt6656_probe,
1482 .disconnect = vt6656_disconnect,
1483 .id_table = vt6656_table,
1485 .suspend = vt6656_suspend,
1486 .resume = vt6656_resume,
1487 #endif /* CONFIG_PM */
1490 module_usb_driver(vt6656_driver);