2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21 * Purpose: driver entry for initial, open, close, tx and rx.
29 * vt6656_probe - module initial (insmod) driver entry
30 * device_remove1 - module remove entry
31 * device_open - allocate dma/descripter resource & initial mac/bbp function
32 * device_xmit - asynchrous data tx function
33 * device_set_multi - set mac filter
34 * device_ioctl - ioctl entry
35 * device_close - shutdown mac/bbp & free dma/descripter resource
36 * device_alloc_frag_buf - rx fragement pre-allocated function
37 * device_free_tx_bufs - free tx buffer function
38 * device_dma0_tx_80211- tx 802.11 frame via dma0
39 * device_dma0_xmit- tx PS bufferred frame via dma0
40 * device_init_registers- initial MAC & BBP & RF internal registers.
41 * device_init_rings- initial tx/rx ring buffer
42 * device_init_defrag_cb- initial & allocate de-fragement buffer.
43 * device_tx_srv- tx interrupt service function
76 /*--------------------- Static Definitions -------------------------*/
77 //static int msglevel =MSG_LEVEL_DEBUG;
78 static int msglevel =MSG_LEVEL_INFO;
81 // Define module options
84 // Version Information
85 #define DRIVER_AUTHOR "VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>"
86 MODULE_AUTHOR(DRIVER_AUTHOR);
87 MODULE_LICENSE("GPL");
88 MODULE_DESCRIPTION(DEVICE_FULL_DRV_NAM);
90 #define DEVICE_PARAM(N,D) \
91 static int N[MAX_UINTS]=OPTION_DEFAULT;\
92 module_param_array(N, int, NULL, 0);\
93 MODULE_PARM_DESC(N, D);
95 #define RX_DESC_MIN0 16
96 #define RX_DESC_MAX0 128
97 #define RX_DESC_DEF0 64
98 DEVICE_PARAM(RxDescriptors0,"Number of receive usb desc buffer");
101 #define TX_DESC_MIN0 16
102 #define TX_DESC_MAX0 128
103 #define TX_DESC_DEF0 64
104 DEVICE_PARAM(TxDescriptors0,"Number of transmit usb desc buffer");
107 #define CHANNEL_MIN 1
108 #define CHANNEL_MAX 14
109 #define CHANNEL_DEF 6
111 DEVICE_PARAM(Channel, "Channel number");
114 /* PreambleType[] is the preamble length used for transmit.
115 0: indicate allows long preamble type
116 1: indicate allows short preamble type
119 #define PREAMBLE_TYPE_DEF 1
121 DEVICE_PARAM(PreambleType, "Preamble Type");
124 #define RTS_THRESH_MIN 512
125 #define RTS_THRESH_MAX 2347
126 #define RTS_THRESH_DEF 2347
128 DEVICE_PARAM(RTSThreshold, "RTS threshold");
131 #define FRAG_THRESH_MIN 256
132 #define FRAG_THRESH_MAX 2346
133 #define FRAG_THRESH_DEF 2346
135 DEVICE_PARAM(FragThreshold, "Fragmentation threshold");
138 #define DATA_RATE_MIN 0
139 #define DATA_RATE_MAX 13
140 #define DATA_RATE_DEF 13
142 0: indicate 1 Mbps 0x02
143 1: indicate 2 Mbps 0x04
144 2: indicate 5.5 Mbps 0x0B
145 3: indicate 11 Mbps 0x16
146 4: indicate 6 Mbps 0x0c
147 5: indicate 9 Mbps 0x12
148 6: indicate 12 Mbps 0x18
149 7: indicate 18 Mbps 0x24
150 8: indicate 24 Mbps 0x30
151 9: indicate 36 Mbps 0x48
152 10: indicate 48 Mbps 0x60
153 11: indicate 54 Mbps 0x6c
154 12: indicate 72 Mbps 0x90
155 13: indicate auto rate
158 DEVICE_PARAM(ConnectionRate, "Connection data rate");
160 #define OP_MODE_MAX 2
161 #define OP_MODE_DEF 0
162 #define OP_MODE_MIN 0
164 DEVICE_PARAM(OPMode, "Infrastruct, adhoc, AP mode ");
166 /* OpMode[] is used for transmit.
167 0: indicate infrastruct mode used
168 1: indicate adhoc mode used
169 2: indicate AP mode used
174 0: indicate disable power saving mode
175 1: indicate enable power saving mode
178 #define PS_MODE_DEF 0
180 DEVICE_PARAM(PSMode, "Power saving mode");
183 #define SHORT_RETRY_MIN 0
184 #define SHORT_RETRY_MAX 31
185 #define SHORT_RETRY_DEF 8
188 DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits");
190 #define LONG_RETRY_MIN 0
191 #define LONG_RETRY_MAX 15
192 #define LONG_RETRY_DEF 4
195 DEVICE_PARAM(LongRetryLimit, "long frame retry limits");
198 /* BasebandType[] baseband type selected
199 0: indicate 802.11a type
200 1: indicate 802.11b type
201 2: indicate 802.11g type
203 #define BBP_TYPE_MIN 0
204 #define BBP_TYPE_MAX 2
205 #define BBP_TYPE_DEF 2
207 DEVICE_PARAM(BasebandType, "baseband type");
212 0: indicate disable 802.11h
213 1: indicate enable 802.11h
216 #define X80211h_MODE_DEF 0
218 DEVICE_PARAM(b80211hEnable, "802.11h mode");
222 // Static vars definitions
225 static struct usb_device_id vt6656_table[] __devinitdata = {
226 {USB_DEVICE(VNT_USB_VENDOR_ID, VNT_USB_PRODUCT_ID)},
230 // Frequency list (map channels to frequencies)
232 static const long frequency_list[] = {
233 2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484,
234 4915, 4920, 4925, 4935, 4940, 4945, 4960, 4980,
235 5035, 5040, 5045, 5055, 5060, 5080, 5170, 5180, 5190, 5200, 5210, 5220, 5230, 5240,
236 5260, 5280, 5300, 5320, 5500, 5520, 5540, 5560, 5580, 5600, 5620, 5640, 5660, 5680,
237 5700, 5745, 5765, 5785, 5805, 5825
241 #ifndef IW_ENCODE_NOKEY
242 #define IW_ENCODE_NOKEY 0x0800
243 #define IW_ENCODE_MODE (IW_ENCODE_DISABLED | IW_ENCODE_RESTRICTED | IW_ENCODE_OPEN)
246 static const struct iw_handler_def iwctl_handler_def;
249 /*--------------------- Static Functions --------------------------*/
251 static int vt6656_probe(struct usb_interface *intf,
252 const struct usb_device_id *id);
253 static void vt6656_disconnect(struct usb_interface *intf);
255 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
256 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message);
257 static int vt6656_resume(struct usb_interface *intf);
258 #endif /* CONFIG_PM */
260 static struct net_device_stats *device_get_stats(struct net_device *dev);
261 static int device_open(struct net_device *dev);
262 static int device_xmit(struct sk_buff *skb, struct net_device *dev);
263 static void device_set_multi(struct net_device *dev);
264 static int device_close(struct net_device *dev);
265 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
267 static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType);
268 static BOOL device_init_defrag_cb(PSDevice pDevice);
269 static void device_init_diversity_timer(PSDevice pDevice);
270 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
272 static int ethtool_ioctl(struct net_device *dev, void *useraddr);
273 static void device_free_tx_bufs(PSDevice pDevice);
274 static void device_free_rx_bufs(PSDevice pDevice);
275 static void device_free_int_bufs(PSDevice pDevice);
276 static void device_free_frag_bufs(PSDevice pDevice);
277 static BOOL device_alloc_bufs(PSDevice pDevice);
279 static int Read_config_file(PSDevice pDevice);
280 static unsigned char *Config_FileOperation(PSDevice pDevice);
281 static int Config_FileGetParameter(unsigned char *string,
283 unsigned char *source);
285 //2008-0714<Add>by Mike Liu
286 static BOOL device_release_WPADEV(PSDevice pDevice);
288 static void usb_device_reset(PSDevice pDevice);
292 /*--------------------- Export Variables --------------------------*/
294 /*--------------------- Export Functions --------------------------*/
298 device_set_options(PSDevice pDevice) {
300 BYTE abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
301 BYTE abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
302 u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
304 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
305 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
306 memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, ETH_ALEN);
308 pDevice->cbTD = TX_DESC_DEF0;
309 pDevice->cbRD = RX_DESC_DEF0;
310 pDevice->uChannel = CHANNEL_DEF;
311 pDevice->wRTSThreshold = RTS_THRESH_DEF;
312 pDevice->wFragmentationThreshold = FRAG_THRESH_DEF;
313 pDevice->byShortRetryLimit = SHORT_RETRY_DEF;
314 pDevice->byLongRetryLimit = LONG_RETRY_DEF;
315 pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
316 pDevice->byShortPreamble = PREAMBLE_TYPE_DEF;
317 pDevice->ePSMode = PS_MODE_DEF;
318 pDevice->b11hEnable = X80211h_MODE_DEF;
319 pDevice->eOPMode = OP_MODE_DEF;
320 pDevice->uConnectionRate = DATA_RATE_DEF;
321 if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = TRUE;
322 pDevice->byBBType = BBP_TYPE_DEF;
323 pDevice->byPacketType = pDevice->byBBType;
324 pDevice->byAutoFBCtrl = AUTO_FB_0;
325 pDevice->bUpdateBBVGA = TRUE;
326 pDevice->byFOETuning = 0;
327 pDevice->byAutoPwrTunning = 0;
328 pDevice->wCTSDuration = 0;
329 pDevice->byPreambleType = 0;
330 pDevice->bExistSWNetAddr = FALSE;
331 // pDevice->bDiversityRegCtlON = TRUE;
332 pDevice->bDiversityRegCtlON = FALSE;
336 static void device_init_diversity_timer(PSDevice pDevice)
338 init_timer(&pDevice->TimerSQ3Tmax1);
339 pDevice->TimerSQ3Tmax1.data = (unsigned long)pDevice;
340 pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
341 pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
343 init_timer(&pDevice->TimerSQ3Tmax2);
344 pDevice->TimerSQ3Tmax2.data = (unsigned long)pDevice;
345 pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
346 pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
348 init_timer(&pDevice->TimerSQ3Tmax3);
349 pDevice->TimerSQ3Tmax3.data = (unsigned long)pDevice;
350 pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerSQ3Tmax3CallBack;
351 pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
358 // Initialiation of MAC & BBP registers
361 static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType)
363 u8 abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
364 u8 abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
365 u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
368 CMD_CARD_INIT sInitCmd;
369 NTSTATUS ntStatus = STATUS_SUCCESS;
370 RSP_CARD_INIT sInitRsp;
371 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
373 BYTE byCalibTXIQ = 0;
374 BYTE byCalibTXDC = 0;
375 BYTE byCalibRXIQ = 0;
377 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---->INIbInitAdapter. [%d][%d]\n", InitType, pDevice->byPacketType);
378 spin_lock_irq(&pDevice->lock);
379 if (InitType == DEVICE_INIT_COLD) {
380 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
381 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
382 memcpy(pDevice->abySNAP_Bridgetunnel,
383 abySNAP_Bridgetunnel,
386 if ( !FIRMWAREbCheckVersion(pDevice) ) {
387 if (FIRMWAREbDownload(pDevice) == TRUE) {
388 if (FIRMWAREbBrach2Sram(pDevice) == FALSE) {
389 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbBrach2Sram fail \n");
390 spin_unlock_irq(&pDevice->lock);
395 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbDownload fail \n");
396 spin_unlock_irq(&pDevice->lock);
401 if ( !BBbVT3184Init(pDevice) ) {
402 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" BBbVT3184Init fail \n");
403 spin_unlock_irq(&pDevice->lock);
408 sInitCmd.byInitClass = (BYTE)InitType;
409 sInitCmd.bExistSWNetAddr = (BYTE) pDevice->bExistSWNetAddr;
411 sInitCmd.bySWNetAddr[ii] = pDevice->abyCurrentNetAddr[ii];
412 sInitCmd.byShortRetryLimit = pDevice->byShortRetryLimit;
413 sInitCmd.byLongRetryLimit = pDevice->byLongRetryLimit;
415 //issue Card_init command to device
416 ntStatus = CONTROLnsRequestOut(pDevice,
417 MESSAGE_TYPE_CARDINIT,
420 sizeof(CMD_CARD_INIT),
421 (PBYTE) &(sInitCmd));
423 if ( ntStatus != STATUS_SUCCESS ) {
424 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Issue Card init fail \n");
425 spin_unlock_irq(&pDevice->lock);
428 if (InitType == DEVICE_INIT_COLD) {
430 ntStatus = CONTROLnsRequestIn(pDevice,MESSAGE_TYPE_INIT_RSP,0,0,sizeof(RSP_CARD_INIT), (PBYTE) &(sInitRsp));
432 if (ntStatus != STATUS_SUCCESS) {
433 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Cardinit request in status fail!\n");
434 spin_unlock_irq(&pDevice->lock);
438 //Local ID for AES functions
439 ntStatus = CONTROLnsRequestIn(pDevice,
442 MESSAGE_REQUEST_MACREG,
444 &pDevice->byLocalID);
446 if ( ntStatus != STATUS_SUCCESS ) {
447 spin_unlock_irq(&pDevice->lock);
451 // Do MACbSoftwareReset in MACvInitialize
453 pDevice->bCCK = TRUE;
454 pDevice->bProtectMode = FALSE; //Only used in 11g type, sync with ERP IE
455 pDevice->bNonERPPresent = FALSE;
456 pDevice->bBarkerPreambleMd = FALSE;
457 if ( pDevice->bFixRate ) {
458 pDevice->wCurrentRate = (WORD) pDevice->uConnectionRate;
460 if ( pDevice->byBBType == BB_TYPE_11B )
461 pDevice->wCurrentRate = RATE_11M;
463 pDevice->wCurrentRate = RATE_54M;
466 CHvInitChannelTable(pDevice);
468 pDevice->byTopOFDMBasicRate = RATE_24M;
469 pDevice->byTopCCKBasicRate = RATE_1M;
470 pDevice->byRevId = 0; //Target to IF pin while programming to RF chip.
471 pDevice->byCurPwr = 0xFF;
473 pDevice->byCCKPwr = pDevice->abyEEPROM[EEP_OFS_PWR_CCK];
474 pDevice->byOFDMPwrG = pDevice->abyEEPROM[EEP_OFS_PWR_OFDMG];
476 for (ii=0;ii<14;ii++) {
477 pDevice->abyCCKPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_CCK_PWR_TBL];
478 if (pDevice->abyCCKPwrTbl[ii] == 0)
479 pDevice->abyCCKPwrTbl[ii] = pDevice->byCCKPwr;
480 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDM_PWR_TBL];
481 if (pDevice->abyOFDMPwrTbl[ii] == 0)
482 pDevice->abyOFDMPwrTbl[ii] = pDevice->byOFDMPwrG;
485 //original zonetype is USA,but customize zonetype is europe,
486 // then need recover 12,13 ,14 channel with 11 channel
487 if(((pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Japan) ||
488 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Europe))&&
489 (pDevice->byOriginalZonetype == ZoneType_USA)) {
490 for(ii=11;ii<14;ii++) {
491 pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];
492 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];
496 //{{ RobertYu: 20041124
497 pDevice->byOFDMPwrA = 0x34; // same as RFbMA2829SelectChannel
498 // Load OFDM A Power Table
499 for (ii=0;ii<CB_MAX_CHANNEL_5G;ii++) { //RobertYu:20041224, bug using CB_MAX_CHANNEL
500 pDevice->abyOFDMAPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDMA_PWR_TBL];
501 if (pDevice->abyOFDMAPwrTbl[ii] == 0)
502 pDevice->abyOFDMAPwrTbl[ii] = pDevice->byOFDMPwrA;
506 byAntenna = pDevice->abyEEPROM[EEP_OFS_ANTENNA];
507 if (byAntenna & EEP_ANTINV)
508 pDevice->bTxRxAntInv = TRUE;
510 pDevice->bTxRxAntInv = FALSE;
512 byAntenna &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
514 if (byAntenna == 0) // if not set default is All
515 byAntenna = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
517 if (byAntenna == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
518 pDevice->byAntennaCount = 2;
519 pDevice->byTxAntennaMode = ANT_B;
520 pDevice->dwTxAntennaSel = 1;
521 pDevice->dwRxAntennaSel = 1;
522 if (pDevice->bTxRxAntInv == TRUE)
523 pDevice->byRxAntennaMode = ANT_A;
525 pDevice->byRxAntennaMode = ANT_B;
527 if (pDevice->bDiversityRegCtlON)
528 pDevice->bDiversityEnable = TRUE;
530 pDevice->bDiversityEnable = FALSE;
532 pDevice->bDiversityEnable = FALSE;
533 pDevice->byAntennaCount = 1;
534 pDevice->dwTxAntennaSel = 0;
535 pDevice->dwRxAntennaSel = 0;
536 if (byAntenna & EEP_ANTENNA_AUX) {
537 pDevice->byTxAntennaMode = ANT_A;
538 if (pDevice->bTxRxAntInv == TRUE)
539 pDevice->byRxAntennaMode = ANT_B;
541 pDevice->byRxAntennaMode = ANT_A;
543 pDevice->byTxAntennaMode = ANT_B;
544 if (pDevice->bTxRxAntInv == TRUE)
545 pDevice->byRxAntennaMode = ANT_A;
547 pDevice->byRxAntennaMode = ANT_B;
550 pDevice->ulDiversityNValue = 100*255;
551 pDevice->ulDiversityMValue = 100*16;
553 pDevice->byTMax2 = 4;
554 pDevice->ulSQ3TH = 0;
555 pDevice->byTMax3 = 64;
556 // -----------------------------------------------------------------
558 //Get Auto Fall Back Type
559 pDevice->byAutoFBCtrl = AUTO_FB_0;
562 pDevice->uScanTime = WLAN_SCAN_MINITIME;
565 //pDevice->NetworkType = Ndis802_11Automode;
566 pDevice->eConfigPHYMode = PHY_TYPE_AUTO;
567 pDevice->byBBType = BB_TYPE_11G;
569 // initialize BBP registers
570 pDevice->ulTxPower = 25;
573 pDevice->byMinChannel = 1;
574 pDevice->byMaxChannel = CB_MAX_CHANNEL;
577 pDevice->byRFType = sInitRsp.byRFType;
579 if ((pDevice->byRFType & RF_EMU) != 0) {
580 // force change RevID for VT3253 emu
581 pDevice->byRevId = 0x80;
584 // Load EEPROM calibrated vt3266 parameters
585 if (pDevice->byRFType == RF_VT3226D0) {
586 if((pDevice->abyEEPROM[EEP_OFS_MAJOR_VER] == 0x1) &&
587 (pDevice->abyEEPROM[EEP_OFS_MINOR_VER] >= 0x4)) {
588 byCalibTXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_IQ];
589 byCalibTXDC = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_DC];
590 byCalibRXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_RX_IQ];
591 if( (byCalibTXIQ || byCalibTXDC || byCalibRXIQ) ) {
592 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFF, 0x03); // CR255, Set BB to support TX/RX IQ and DC compensation Mode
593 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFB, byCalibTXIQ); // CR251, TX I/Q Imbalance Calibration
594 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFC, byCalibTXDC); // CR252, TX DC-Offset Calibration
595 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFD, byCalibRXIQ); // CR253, RX I/Q Imbalance Calibration
597 // turn off BB Calibration compensation
598 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFF, 0x0); // CR255
602 pMgmt->eScanType = WMAC_SCAN_PASSIVE;
603 pMgmt->uCurrChannel = pDevice->uChannel;
604 pMgmt->uIBSSChannel = pDevice->uChannel;
605 CARDbSetMediaChannel(pDevice, pMgmt->uCurrChannel);
607 // get Permanent network address
608 memcpy(pDevice->abyPermanentNetAddr,&(sInitRsp.byNetAddr[0]),6);
609 memcpy(pDevice->abyCurrentNetAddr,
610 pDevice->abyPermanentNetAddr,
613 // if exist SW network address, use SW network address.
615 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %02x-%02x-%02x=%02x-%02x-%02x\n",
616 pDevice->abyCurrentNetAddr[0],
617 pDevice->abyCurrentNetAddr[1],
618 pDevice->abyCurrentNetAddr[2],
619 pDevice->abyCurrentNetAddr[3],
620 pDevice->abyCurrentNetAddr[4],
621 pDevice->abyCurrentNetAddr[5]);
626 // Set BB and packet type at the same time.
627 // Set Short Slot Time, xIFS, and RSPINF.
628 if (pDevice->byBBType == BB_TYPE_11A) {
629 CARDbAddBasicRate(pDevice, RATE_6M);
630 pDevice->bShortSlotTime = TRUE;
632 CARDbAddBasicRate(pDevice, RATE_1M);
633 pDevice->bShortSlotTime = FALSE;
635 BBvSetShortSlotTime(pDevice);
636 CARDvSetBSSMode(pDevice);
638 if (pDevice->bUpdateBBVGA) {
639 pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
640 pDevice->byBBVGANew = pDevice->byBBVGACurrent;
641 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
644 pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];
645 pDevice->bHWRadioOff = FALSE;
646 if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) {
647 ntStatus = CONTROLnsRequestIn(pDevice,
650 MESSAGE_REQUEST_MACREG,
654 if ( ntStatus != STATUS_SUCCESS ) {
655 spin_unlock_irq(&pDevice->lock);
658 if ( (byTmp & GPIO3_DATA) == 0 ) {
659 pDevice->bHWRadioOff = TRUE;
660 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
662 MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
663 pDevice->bHWRadioOff = FALSE;
666 } //EEP_RADIOCTL_ENABLE
668 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
669 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
670 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01);
672 if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) {
673 CARDbRadioPowerOff(pDevice);
675 CARDbRadioPowerOn(pDevice);
678 spin_unlock_irq(&pDevice->lock);
679 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");
683 static BOOL device_release_WPADEV(PSDevice pDevice)
685 viawget_wpa_header *wpahdr;
687 // wait_queue_head_t Set_wait;
688 //send device close to wpa_supplicnat layer
689 if (pDevice->bWPADEVUp==TRUE) {
690 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
691 wpahdr->type = VIAWGET_DEVICECLOSE_MSG;
692 wpahdr->resp_ie_len = 0;
693 wpahdr->req_ie_len = 0;
694 skb_put(pDevice->skb, sizeof(viawget_wpa_header));
695 pDevice->skb->dev = pDevice->wpadev;
696 skb_reset_mac_header(pDevice->skb);
697 pDevice->skb->pkt_type = PACKET_HOST;
698 pDevice->skb->protocol = htons(ETH_P_802_2);
699 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
700 netif_rx(pDevice->skb);
701 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
703 //wait release WPADEV
704 // init_waitqueue_head(&Set_wait);
705 // wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ); //1s wait
706 while(pDevice->bWPADEVUp==TRUE) {
707 set_current_state(TASK_UNINTERRUPTIBLE);
708 schedule_timeout (HZ/20); //wait 50ms
717 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
719 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message)
721 PSDevice pDevice = usb_get_intfdata(intf);
722 struct net_device *dev = pDevice->dev;
724 printk("VNTWUSB Suspend Start======>\n");
726 if(pDevice->flags & DEVICE_FLAGS_OPENED)
730 usb_put_dev(interface_to_usbdev(intf));
734 static int vt6656_resume(struct usb_interface *intf)
736 PSDevice pDevice = usb_get_intfdata(intf);
737 struct net_device *dev = pDevice->dev;
739 printk("VNTWUSB Resume Start======>\n");
741 usb_get_dev(interface_to_usbdev(intf));
742 if(!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
743 if(device_open(dev)!=0)
744 printk("VNTWUSB Resume Start======>open fail\n");
750 #endif /* CONFIG_PM */
752 static const struct net_device_ops device_netdev_ops = {
753 .ndo_open = device_open,
754 .ndo_stop = device_close,
755 .ndo_do_ioctl = device_ioctl,
756 .ndo_get_stats = device_get_stats,
757 .ndo_start_xmit = device_xmit,
758 .ndo_set_multicast_list = device_set_multi,
763 vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
765 u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
766 struct usb_device *udev = interface_to_usbdev(intf);
768 struct net_device *netdev = NULL;
769 PSDevice pDevice = NULL;
772 printk(KERN_NOTICE "%s Ver. %s\n",DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
773 printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
775 udev = usb_get_dev(udev);
777 netdev = alloc_etherdev(sizeof(DEVICE_INFO));
779 if (netdev == NULL) {
780 printk(KERN_ERR DEVICE_NAME ": allocate net device failed \n");
785 pDevice = netdev_priv(netdev);
786 memset(pDevice, 0, sizeof(DEVICE_INFO));
788 pDevice->dev = netdev;
791 // Set initial settings
792 device_set_options(pDevice);
793 spin_lock_init(&pDevice->lock);
795 pDevice->tx_80211 = device_dma0_tx_80211;
796 pDevice->sMgmtObj.pAdapter = (void *)pDevice;
798 netdev->netdev_ops = &device_netdev_ops;
800 netdev->wireless_handlers = (struct iw_handler_def *)&iwctl_handler_def;
802 //2008-0623-01<Remark>by MikeLiu
803 //2007-0821-01<Add>by MikeLiu
804 usb_set_intfdata(intf, pDevice);
805 SET_NETDEV_DEV(netdev, &intf->dev);
806 memcpy(pDevice->dev->dev_addr, fake_mac, ETH_ALEN);
807 rc = register_netdev(netdev);
809 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
815 //2008-07-21-01<Add>by MikeLiu
818 if(wpa_set_wpadev(pDevice, 1)!=0) {
819 printk("Fail to Register WPADEV?\n");
820 unregister_netdev(pDevice->dev);
825 usb_device_reset(pDevice);
829 union iwreq_data wrqu;
830 memset(&wrqu, 0, sizeof(wrqu));
831 wrqu.data.flags = RT_INSMOD_EVENT_FLAG;
832 wrqu.data.length =IFNAMSIZ;
833 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, pDevice->dev->name);
841 //2008-0922-01<Add>by MikeLiu, decrease usb counter.
848 static void device_free_tx_bufs(PSDevice pDevice)
850 PUSB_SEND_CONTEXT pTxContext;
853 for (ii = 0; ii < pDevice->cbTD; ii++) {
855 pTxContext = pDevice->apTD[ii];
857 if (pTxContext->pUrb) {
858 usb_kill_urb(pTxContext->pUrb);
859 usb_free_urb(pTxContext->pUrb);
868 static void device_free_rx_bufs(PSDevice pDevice)
873 for (ii = 0; ii < pDevice->cbRD; ii++) {
875 pRCB = pDevice->apRCB[ii];
878 usb_kill_urb(pRCB->pUrb);
879 usb_free_urb(pRCB->pUrb);
883 dev_kfree_skb(pRCB->skb);
885 if (pDevice->pRCBMem)
886 kfree(pDevice->pRCBMem);
891 //2007-1107-02<Add>by MikeLiu
892 static void usb_device_reset(PSDevice pDevice)
895 status = usb_reset_device(pDevice->usb);
897 printk("usb_device_reset fail status=%d\n",status);
901 static void device_free_int_bufs(PSDevice pDevice)
903 if (pDevice->intBuf.pDataBuf != NULL)
904 kfree(pDevice->intBuf.pDataBuf);
909 static BOOL device_alloc_bufs(PSDevice pDevice) {
911 PUSB_SEND_CONTEXT pTxContext;
916 for (ii = 0; ii < pDevice->cbTD; ii++) {
918 pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
919 if (pTxContext == NULL) {
920 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
923 pDevice->apTD[ii] = pTxContext;
924 pTxContext->pDevice = (void *) pDevice;
926 pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
927 if (pTxContext->pUrb == NULL) {
928 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
931 pTxContext->bBoolInUse = FALSE;
935 pDevice->pRCBMem = kmalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
936 if (pDevice->pRCBMem == NULL) {
937 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
942 pDevice->FirstRecvFreeList = NULL;
943 pDevice->LastRecvFreeList = NULL;
944 pDevice->FirstRecvMngList = NULL;
945 pDevice->LastRecvMngList = NULL;
946 pDevice->NumRecvFreeList = 0;
947 memset(pDevice->pRCBMem, 0, (sizeof(RCB) * pDevice->cbRD));
948 pRCB = (PRCB) pDevice->pRCBMem;
950 for (ii = 0; ii < pDevice->cbRD; ii++) {
952 pDevice->apRCB[ii] = pRCB;
953 pRCB->pDevice = (void *) pDevice;
955 pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
957 if (pRCB->pUrb == NULL) {
958 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
961 pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
962 if (pRCB->skb == NULL) {
963 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
966 pRCB->skb->dev = pDevice->dev;
967 pRCB->bBoolInUse = FALSE;
968 EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
969 pDevice->NumRecvFreeList++;
974 pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
975 if (pDevice->pControlURB == NULL) {
976 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
980 pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
981 if (pDevice->pInterruptURB == NULL) {
982 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
983 usb_kill_urb(pDevice->pControlURB);
984 usb_free_urb(pDevice->pControlURB);
988 pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
989 if (pDevice->intBuf.pDataBuf == NULL) {
990 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
991 usb_kill_urb(pDevice->pControlURB);
992 usb_kill_urb(pDevice->pInterruptURB);
993 usb_free_urb(pDevice->pControlURB);
994 usb_free_urb(pDevice->pInterruptURB);
1001 device_free_rx_bufs(pDevice);
1004 device_free_tx_bufs(pDevice);
1012 static BOOL device_init_defrag_cb(PSDevice pDevice) {
1014 PSDeFragControlBlock pDeF;
1016 /* Init the fragment ctl entries */
1017 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1018 pDeF = &(pDevice->sRxDFCB[i]);
1019 if (!device_alloc_frag_buf(pDevice, pDeF)) {
1020 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
1021 pDevice->dev->name);
1025 pDevice->cbDFCB = CB_MAX_RX_FRAG;
1026 pDevice->cbFreeDFCB = pDevice->cbDFCB;
1030 device_free_frag_bufs(pDevice);
1036 static void device_free_frag_bufs(PSDevice pDevice) {
1037 PSDeFragControlBlock pDeF;
1040 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1042 pDeF = &(pDevice->sRxDFCB[i]);
1045 dev_kfree_skb(pDeF->skb);
1051 BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1053 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1054 if (pDeF->skb == NULL)
1057 pDeF->skb->dev = pDevice->dev;
1063 /*-----------------------------------------------------------------*/
1065 static int device_open(struct net_device *dev) {
1066 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1068 #ifdef WPA_SM_Transtatus
1069 extern SWPAResult wpa_Result;
1070 memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1071 wpa_Result.proto = 0;
1072 wpa_Result.key_mgmt = 0;
1073 wpa_Result.eap_type = 0;
1074 wpa_Result.authenticated = FALSE;
1075 pDevice->fWPA_Authened = FALSE;
1078 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
1081 pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
1083 if (device_alloc_bufs(pDevice) == FALSE) {
1084 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
1088 if (device_init_defrag_cb(pDevice)== FALSE) {
1089 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragement cb fail \n");
1093 MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
1094 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
1095 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
1096 MP_SET_FLAG(pDevice, fMP_POST_READS);
1097 MP_SET_FLAG(pDevice, fMP_POST_WRITES);
1100 Read_config_file(pDevice);
1102 if (device_init_registers(pDevice, DEVICE_INIT_COLD) == FALSE) {
1103 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
1107 device_set_multi(pDevice->dev);
1108 // Init for Key Management
1110 KeyvInitTable(pDevice,&pDevice->sKey);
1111 memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1112 memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1113 pDevice->bStopTx0Pkt = FALSE;
1114 pDevice->bStopDataPkt = FALSE;
1115 pDevice->bRoaming = FALSE; //DavidWang
1116 pDevice->bIsRoaming = FALSE;//DavidWang
1117 pDevice->bEnableRoaming = FALSE;
1118 if (pDevice->bDiversityRegCtlON) {
1119 device_init_diversity_timer(pDevice);
1122 vMgrObjectInit(pDevice);
1123 tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
1124 tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
1125 tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
1126 add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback));
1127 pDevice->int_interval = 100; //Max 100 microframes.
1128 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1130 pDevice->bIsRxWorkItemQueued = TRUE;
1131 pDevice->fKillEventPollingThread = FALSE;
1132 pDevice->bEventAvailable = FALSE;
1134 pDevice->bWPADEVUp = FALSE;
1135 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1136 pDevice->bwextstep0 = FALSE;
1137 pDevice->bwextstep1 = FALSE;
1138 pDevice->bwextstep2 = FALSE;
1139 pDevice->bwextstep3 = FALSE;
1140 pDevice->bWPASuppWextEnabled = FALSE;
1142 pDevice->byReAssocCount = 0;
1144 RXvWorkItem(pDevice);
1145 INTvWorkItem(pDevice);
1147 // Patch: if WEP key already set by iwconfig but device not yet open
1148 if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1149 spin_lock_irq(&pDevice->lock);
1150 KeybSetDefaultKey( pDevice,
1152 pDevice->byKeyIndex | (1 << 31),
1153 pDevice->uKeyLength,
1158 spin_unlock_irq(&pDevice->lock);
1159 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1162 if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1163 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1166 //mike:mark@2008-11-10
1167 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1168 /* bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL); */
1172 netif_stop_queue(pDevice->dev);
1173 pDevice->flags |= DEVICE_FLAGS_OPENED;
1177 union iwreq_data wrqu;
1178 memset(&wrqu, 0, sizeof(wrqu));
1179 wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1180 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1184 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1188 device_free_frag_bufs(pDevice);
1190 device_free_rx_bufs(pDevice);
1191 device_free_tx_bufs(pDevice);
1192 device_free_int_bufs(pDevice);
1193 usb_kill_urb(pDevice->pControlURB);
1194 usb_kill_urb(pDevice->pInterruptURB);
1195 usb_free_urb(pDevice->pControlURB);
1196 usb_free_urb(pDevice->pInterruptURB);
1198 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1204 static int device_close(struct net_device *dev) {
1205 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1206 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1210 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1211 if (pDevice == NULL)
1216 union iwreq_data wrqu;
1217 memset(&wrqu, 0, sizeof(wrqu));
1218 wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1219 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1223 //2007-1121-02<Add>by EinsnLiu
1224 if (pDevice->bLinkPass) {
1225 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1230 //2008-0714-01<Add>by MikeLiu
1231 device_release_WPADEV(pDevice);
1233 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1234 pMgmt->bShareKeyAlgorithm = FALSE;
1235 pDevice->bEncryptionEnable = FALSE;
1236 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1237 spin_lock_irq(&pDevice->lock);
1238 for(uu=0;uu<MAX_KEY_TABLE;uu++)
1239 MACvDisableKeyEntry(pDevice,uu);
1240 spin_unlock_irq(&pDevice->lock);
1242 if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1243 MACbShutdown(pDevice);
1245 netif_stop_queue(pDevice->dev);
1246 MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1247 MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1248 MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1249 pDevice->fKillEventPollingThread = TRUE;
1250 del_timer(&pDevice->sTimerCommand);
1251 del_timer(&pMgmt->sTimerSecondCallback);
1253 //2007-0115-02<Add>by MikeLiu
1255 del_timer(&pDevice->sTimerTxData);
1258 if (pDevice->bDiversityRegCtlON) {
1259 del_timer(&pDevice->TimerSQ3Tmax1);
1260 del_timer(&pDevice->TimerSQ3Tmax2);
1261 del_timer(&pDevice->TimerSQ3Tmax3);
1263 tasklet_kill(&pDevice->RxMngWorkItem);
1264 tasklet_kill(&pDevice->ReadWorkItem);
1265 tasklet_kill(&pDevice->EventWorkItem);
1267 pDevice->bRoaming = FALSE; //DavidWang
1268 pDevice->bIsRoaming = FALSE;//DavidWang
1269 pDevice->bEnableRoaming = FALSE;
1270 pDevice->bCmdRunning = FALSE;
1271 pDevice->bLinkPass = FALSE;
1272 memset(pMgmt->abyCurrBSSID, 0, 6);
1273 pMgmt->eCurrState = WMAC_STATE_IDLE;
1275 device_free_tx_bufs(pDevice);
1276 device_free_rx_bufs(pDevice);
1277 device_free_int_bufs(pDevice);
1278 device_free_frag_bufs(pDevice);
1280 usb_kill_urb(pDevice->pControlURB);
1281 usb_kill_urb(pDevice->pInterruptURB);
1282 usb_free_urb(pDevice->pControlURB);
1283 usb_free_urb(pDevice->pInterruptURB);
1285 BSSvClearNodeDBTable(pDevice, 0);
1286 pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1288 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1294 static void __devexit vt6656_disconnect(struct usb_interface *intf)
1297 PSDevice pDevice = usb_get_intfdata(intf);
1299 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_disconnect1.. \n");
1300 if (pDevice == NULL)
1305 union iwreq_data wrqu;
1306 memset(&wrqu, 0, sizeof(wrqu));
1307 wrqu.data.flags = RT_RMMOD_EVENT_FLAG;
1308 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1312 //2008-0714-01<Add>by MikeLiu
1313 device_release_WPADEV(pDevice);
1315 usb_set_intfdata(intf, NULL);
1316 //2008-0922-01<Add>by MikeLiu, decrease usb counter.
1317 usb_put_dev(interface_to_usbdev(intf));
1319 pDevice->flags |= DEVICE_FLAGS_UNPLUG;
1320 if (pDevice->dev != NULL) {
1321 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "unregister_netdev..\n");
1322 unregister_netdev(pDevice->dev);
1324 //2008-07-21-01<Add>by MikeLiu
1326 if(wpa_set_wpadev(pDevice, 0)!=0)
1327 printk("unregister wpadev fail?\n");
1329 free_netdev(pDevice->dev);
1332 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_disconnect3.. \n");
1338 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev) {
1339 PSDevice pDevice=netdev_priv(dev);
1341 unsigned int cbMPDULen = 0;
1344 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211\n");
1345 spin_lock_irq(&pDevice->lock);
1347 if (pDevice->bStopTx0Pkt == TRUE) {
1348 dev_kfree_skb_irq(skb);
1349 spin_unlock_irq(&pDevice->lock);
1354 cbMPDULen = skb->len;
1357 vDMA0_tx_80211(pDevice, skb);
1359 spin_unlock_irq(&pDevice->lock);
1366 static int device_xmit(struct sk_buff *skb, struct net_device *dev) {
1367 PSDevice pDevice=netdev_priv(dev);
1368 struct net_device_stats* pStats = &pDevice->stats;
1371 spin_lock_irq(&pDevice->lock);
1373 netif_stop_queue(pDevice->dev);
1375 if (pDevice->bLinkPass == FALSE) {
1376 dev_kfree_skb_irq(skb);
1377 spin_unlock_irq(&pDevice->lock);
1380 if (pDevice->bStopDataPkt == TRUE) {
1381 dev_kfree_skb_irq(skb);
1382 pStats->tx_dropped++;
1383 spin_unlock_irq(&pDevice->lock);
1387 if(nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb) !=0) { //mike add:xmit fail!
1388 if (netif_queue_stopped(pDevice->dev))
1389 netif_wake_queue(pDevice->dev);
1392 spin_unlock_irq(&pDevice->lock);
1399 static unsigned const ethernet_polynomial = 0x04c11db7U;
1400 static inline u32 ether_crc(int length, unsigned char *data)
1404 while(--length >= 0) {
1405 unsigned char current_octet = *data++;
1407 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1409 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1415 //find out the start position of str2 from str1
1416 static unsigned char *kstrstr(const unsigned char *str1,
1417 const unsigned char *str2) {
1418 int str1_len = strlen(str1);
1419 int str2_len = strlen(str2);
1421 while (str1_len >= str2_len) {
1423 if(memcmp(str1,str2,str2_len)==0)
1424 return (unsigned char *) str1;
1430 static int Config_FileGetParameter(unsigned char *string,
1431 unsigned char *dest,
1432 unsigned char *source)
1434 unsigned char buf1[100];
1435 unsigned char buf2[100];
1436 unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1440 strcat(buf1, string);
1442 source+=strlen(buf1);
1444 //find target string start point
1445 start_p = kstrstr(source,buf1);
1446 if (start_p == NULL)
1449 //check if current config line is marked by "#" ??
1451 if(memcmp(start_p-ii,"\n",1)==0)
1453 if(memcmp(start_p-ii,"#",1)==0)
1457 //find target string end point
1458 end_p = kstrstr(start_p,"\n");
1459 if (end_p == NULL) { //can't find "\n",but don't care
1460 end_p=start_p+strlen(start_p); //no include "\n"
1464 memcpy(buf2,start_p,end_p-start_p); //get the tartget line
1465 buf2[end_p-start_p]='\0';
1468 start_p = kstrstr(buf2,"=");
1469 if (start_p == NULL)
1472 strcpy(buf1,start_p+1);
1476 while(*tmp_p != 0x00) {
1483 memcpy(dest,tmp_p,strlen(tmp_p));
1487 //if read fail,return NULL,or return data pointer;
1488 static unsigned char *Config_FileOperation(PSDevice pDevice)
1490 unsigned char *config_path = CONFIG_PATH;
1491 unsigned char *buffer = NULL;
1492 struct file *filp=NULL;
1493 mm_segment_t old_fs = get_fs();
1494 //int oldfsuid=0,oldfsgid=0;
1498 /* Can't do this anymore, so we rely on correct filesystem permissions:
1499 //Make sure a caller can read or write power as root
1500 oldfsuid=current->fsuid;
1501 oldfsgid=current->fsgid;
1507 filp = filp_open(config_path, O_RDWR, 0);
1509 printk("Config_FileOperation file Not exist\n");
1514 if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1515 printk("file %s cann't readable or writable?\n",config_path);
1520 buffer = kmalloc(1024, GFP_KERNEL);
1522 printk("alllocate mem for file fail?\n");
1527 if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1528 printk("read file error?\n");
1533 if(filp_close(filp,NULL))
1534 printk("Config_FileOperation:close file fail\n");
1540 current->fsuid=oldfsuid;
1541 current->fsgid=oldfsgid;
1552 //return --->-1:fail; >=0:successful
1553 static int Read_config_file(PSDevice pDevice) {
1555 unsigned char tmpbuffer[100];
1556 unsigned char *buffer = NULL;
1558 //init config setting
1559 pDevice->config_file.ZoneType = -1;
1560 pDevice->config_file.eAuthenMode = -1;
1561 pDevice->config_file.eEncryptionStatus = -1;
1563 buffer = Config_FileOperation(pDevice);
1564 if (buffer == NULL) {
1571 memset(tmpbuffer,0,sizeof(tmpbuffer));
1572 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1573 if(memcmp(tmpbuffer,"USA",3)==0) {
1574 pDevice->config_file.ZoneType=ZoneType_USA;
1576 else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1577 pDevice->config_file.ZoneType=ZoneType_Japan;
1579 else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1580 pDevice->config_file.ZoneType=ZoneType_Europe;
1583 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1589 //get other parameter
1591 memset(tmpbuffer,0,sizeof(tmpbuffer));
1592 if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1593 pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1596 memset(tmpbuffer,0,sizeof(tmpbuffer));
1597 if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1598 pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1607 static void device_set_multi(struct net_device *dev) {
1608 PSDevice pDevice = (PSDevice) netdev_priv(dev);
1609 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1612 struct netdev_hw_addr *ha;
1613 BYTE pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1618 spin_lock_irq(&pDevice->lock);
1619 rc = CONTROLnsRequestIn(pDevice,
1622 MESSAGE_REQUEST_MACREG,
1626 if (rc == 0) pDevice->byRxMode = byTmpMode;
1628 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1630 if (dev->flags & IFF_PROMISC) { // Set promiscuous.
1631 DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1632 // Unconditionally log net taps.
1633 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1635 else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1636 (dev->flags & IFF_ALLMULTI)) {
1637 CONTROLnsRequestOut(pDevice,
1640 MESSAGE_REQUEST_MACREG,
1644 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1647 memset(mc_filter, 0, sizeof(mc_filter));
1648 netdev_for_each_mc_addr(ha, dev) {
1649 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1650 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1652 for (ii = 0; ii < 4; ii++) {
1653 MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1654 MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1656 pDevice->byRxMode &= ~(RCR_UNICAST);
1657 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1660 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1661 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1662 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1663 pDevice->byRxMode &= ~(RCR_UNICAST);
1665 ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1666 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1667 spin_unlock_irq(&pDevice->lock);
1672 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1673 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1675 return &pDevice->stats;
1679 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1680 PSDevice pDevice = (PSDevice)netdev_priv(dev);
1681 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1683 //BOOL bCommit = FALSE;
1684 struct iwreq *wrq = (struct iwreq *) rq;
1687 if (pMgmt == NULL) {
1695 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1702 case SIOCGIWNWID: //0x8b03 support
1703 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1704 rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
1710 // Set frequency/channel
1712 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1715 // Get frequency/channel
1717 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1720 // Set desired network name (ESSID)
1724 char essid[IW_ESSID_MAX_SIZE+1];
1725 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1729 if (copy_from_user(essid, wrq->u.essid.pointer,
1730 wrq->u.essid.length)) {
1734 rc = iwctl_siwessid(dev, NULL,
1735 &(wrq->u.essid), essid);
1740 // Get current network name (ESSID)
1744 char essid[IW_ESSID_MAX_SIZE+1];
1745 if (wrq->u.essid.pointer)
1746 rc = iwctl_giwessid(dev, NULL,
1747 &(wrq->u.essid), essid);
1748 if (copy_to_user(wrq->u.essid.pointer,
1750 wrq->u.essid.length) )
1757 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1761 // Get current Access Point (BSSID)
1763 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1767 // Set desired station name
1769 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1773 // Get current station name
1775 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1779 // Set the desired bit-rate
1781 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1784 // Get the current bit-rate
1787 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1790 // Set the desired RTS threshold
1793 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
1796 // Get the current RTS threshold
1799 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1802 // Set the desired fragmentation threshold
1805 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1808 // Get the current fragmentation threshold
1811 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1814 // Set mode of operation
1816 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1819 // Get mode of operation
1821 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1824 // Set WEP keys and mode
1827 char abyKey[WLAN_WEP232_KEYLEN];
1829 if (wrq->u.encoding.pointer) {
1832 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
1836 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
1837 if (copy_from_user(abyKey,
1838 wrq->u.encoding.pointer,
1839 wrq->u.encoding.length)) {
1843 } else if (wrq->u.encoding.length != 0) {
1847 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1851 // Get the WEP keys and mode
1854 if (!capable(CAP_NET_ADMIN)) {
1859 char abyKey[WLAN_WEP232_KEYLEN];
1861 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1863 if (wrq->u.encoding.pointer) {
1864 if (copy_to_user(wrq->u.encoding.pointer,
1866 wrq->u.encoding.length))
1872 // Get the current Tx-Power
1874 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1879 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1885 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
1890 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
1893 // Get range of parameters
1897 struct iw_range range;
1899 rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
1900 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
1908 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
1914 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
1920 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
1924 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
1930 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
1932 if (wrq->u.data.pointer) {
1933 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
1935 if (copy_to_user(wrq->u.data.pointer,
1937 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality)))
1950 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1957 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1961 #endif // WIRELESS_SPY
1964 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
1967 if(wrq->u.data.pointer) {
1968 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
1970 if(copy_to_user(wrq->u.data.pointer,
1971 (u_char *) iwctl_private_args,
1972 sizeof(iwctl_private_args)))
1979 //2008-0409-07, <Add> by Einsn Liu
1980 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1982 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n");
1983 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
1987 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
1988 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
1992 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
1993 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1997 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
1998 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
2001 case SIOCSIWENCODEEXT:
2003 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
2004 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
2005 if(wrq->u.encoding.pointer){
2006 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
2007 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
2011 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
2015 }else if(wrq->u.encoding.length != 0){
2019 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
2023 case SIOCGIWENCODEEXT:
2024 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
2025 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
2029 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
2030 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
2033 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2034 //End Add -- //2008-0409-07, <Add> by Einsn Liu
2036 case IOCTL_CMD_TEST:
2038 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2044 pReq = (PSCmdRequest)rq;
2046 //20080130-01,<Remark> by Mike Liu
2047 // if(pDevice->bLinkPass==TRUE)
2048 pReq->wResult = MAGIC_CODE; //Linking status:0x3142
2049 //20080130-02,<Remark> by Mike Liu
2051 // pReq->wResult = MAGIC_CODE+1; //disconnect status:0x3143
2055 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
2056 (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
2064 if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
2067 rc = private_ioctl(pDevice, rq);
2068 clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
2071 case IOCTL_CMD_HOSTAPD:
2073 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2080 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
2085 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2092 rc = wpa_ioctl(pDevice, &wrq->u.data);
2096 return ethtool_ioctl(dev, (void *) rq->ifr_data);
2097 // All other calls are currently unsupported
2101 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2106 if (pDevice->bCommit) {
2107 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2108 netif_stop_queue(pDevice->dev);
2109 spin_lock_irq(&pDevice->lock);
2110 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
2111 spin_unlock_irq(&pDevice->lock);
2114 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2115 spin_lock_irq(&pDevice->lock);
2116 //2007-1121-01<Modify>by EinsnLiu
2117 if (pDevice->bLinkPass &&
2118 memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2119 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2121 pDevice->bLinkPass = FALSE;
2122 pMgmt->eCurrState = WMAC_STATE_IDLE;
2123 memset(pMgmt->abyCurrBSSID, 0, 6);
2125 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2127 netif_stop_queue(pDevice->dev);
2128 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2129 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2130 if (!pDevice->bWPASuppWextEnabled)
2132 bScheduleCommand((void *) pDevice,
2133 WLAN_CMD_BSSID_SCAN,
2134 pMgmt->abyDesireSSID);
2135 bScheduleCommand((void *) pDevice,
2138 spin_unlock_irq(&pDevice->lock);
2140 pDevice->bCommit = FALSE;
2148 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2152 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd)))
2156 case ETHTOOL_GDRVINFO: {
2157 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2158 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2159 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2160 if (copy_to_user(useraddr, &info, sizeof(info)))
2171 /*------------------------------------------------------------------*/
2173 MODULE_DEVICE_TABLE(usb, vt6656_table);
2175 static struct usb_driver vt6656_driver = {
2176 .name = DEVICE_NAME,
2177 .probe = vt6656_probe,
2178 .disconnect = vt6656_disconnect,
2179 .id_table = vt6656_table,
2181 .suspend = vt6656_suspend,
2182 .resume = vt6656_resume,
2183 #endif /* CONFIG_PM */
2186 static int __init vt6656_init_module(void)
2188 printk(KERN_NOTICE DEVICE_FULL_DRV_NAM " " DEVICE_VERSION);
2189 return usb_register(&vt6656_driver);
2192 static void __exit vt6656_cleanup_module(void)
2194 usb_deregister(&vt6656_driver);
2197 module_init(vt6656_init_module);
2198 module_exit(vt6656_cleanup_module);