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 * vntwusb_found1 - 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
227 static struct usb_device_id vntwusb_table
[] = {
228 {USB_DEVICE(VNT_USB_VENDOR_ID
, VNT_USB_PRODUCT_ID
)},
234 // Frequency list (map channels to frequencies)
236 static const long frequency_list[] = {
237 2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484,
238 4915, 4920, 4925, 4935, 4940, 4945, 4960, 4980,
239 5035, 5040, 5045, 5055, 5060, 5080, 5170, 5180, 5190, 5200, 5210, 5220, 5230, 5240,
240 5260, 5280, 5300, 5320, 5500, 5520, 5540, 5560, 5580, 5600, 5620, 5640, 5660, 5680,
241 5700, 5745, 5765, 5785, 5805, 5825
245 #ifndef IW_ENCODE_NOKEY
246 #define IW_ENCODE_NOKEY 0x0800
247 #define IW_ENCODE_MODE (IW_ENCODE_DISABLED | IW_ENCODE_RESTRICTED | IW_ENCODE_OPEN)
250 static const struct iw_handler_def iwctl_handler_def;
255 /*--------------------- Static Functions --------------------------*/
256 static int vntwusb_found1(struct usb_interface
*intf
, const struct usb_device_id
*id
);
257 static void vntwusb_disconnect(struct usb_interface
*intf
);
258 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
259 static int vntwusb_suspend(struct usb_interface
*intf
, pm_message_t message
);
260 static int vntwusb_resume(struct usb_interface
*intf
);
262 static struct net_device_stats
*device_get_stats(struct net_device
*dev
);
263 static int device_open(struct net_device
*dev
);
264 static int device_xmit(struct sk_buff
*skb
, struct net_device
*dev
);
265 static void device_set_multi(struct net_device
*dev
);
266 static int device_close(struct net_device
*dev
);
267 static int device_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
);
269 static BOOL
device_init_registers(PSDevice pDevice
, DEVICE_INIT_TYPE InitType
);
270 static BOOL
device_init_defrag_cb(PSDevice pDevice
);
271 static void device_init_diversity_timer(PSDevice pDevice
);
272 static int device_dma0_tx_80211(struct sk_buff
*skb
, struct net_device
*dev
);
274 static int ethtool_ioctl(struct net_device
*dev
, void *useraddr
);
275 static void device_free_tx_bufs(PSDevice pDevice
);
276 static void device_free_rx_bufs(PSDevice pDevice
);
277 static void device_free_int_bufs(PSDevice pDevice
);
278 static void device_free_frag_bufs(PSDevice pDevice
);
279 static BOOL
device_alloc_bufs(PSDevice pDevice
);
281 static int Read_config_file(PSDevice pDevice
);
282 static UCHAR
*Config_FileOperation(PSDevice pDevice
);
283 static int Config_FileGetParameter(UCHAR
*string
, UCHAR
*dest
,UCHAR
*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
[U_ETHER_ADDR_LEN
] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
301 BYTE abySNAP_RFC1042
[U_ETHER_ADDR_LEN
] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
302 BYTE abySNAP_Bridgetunnel
[U_ETHER_ADDR_LEN
] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
305 memcpy(pDevice
->abyBroadcastAddr
, abyBroadcastAddr
, U_ETHER_ADDR_LEN
);
306 memcpy(pDevice
->abySNAP_RFC1042
, abySNAP_RFC1042
, U_ETHER_ADDR_LEN
);
307 memcpy(pDevice
->abySNAP_Bridgetunnel
, abySNAP_Bridgetunnel
, U_ETHER_ADDR_LEN
);
309 pDevice
->cbTD
= TX_DESC_DEF0
;
310 pDevice
->cbRD
= RX_DESC_DEF0
;
311 pDevice
->uChannel
= CHANNEL_DEF
;
312 pDevice
->wRTSThreshold
= RTS_THRESH_DEF
;
313 pDevice
->wFragmentationThreshold
= FRAG_THRESH_DEF
;
314 pDevice
->byShortRetryLimit
= SHORT_RETRY_DEF
;
315 pDevice
->byLongRetryLimit
= LONG_RETRY_DEF
;
316 pDevice
->wMaxTransmitMSDULifetime
= DEFAULT_MSDU_LIFETIME
;
317 pDevice
->byShortPreamble
= PREAMBLE_TYPE_DEF
;
318 pDevice
->ePSMode
= PS_MODE_DEF
;
319 pDevice
->b11hEnable
= X80211h_MODE_DEF
;
320 pDevice
->eOPMode
= OP_MODE_DEF
;
321 pDevice
->uConnectionRate
= DATA_RATE_DEF
;
322 if (pDevice
->uConnectionRate
< RATE_AUTO
) pDevice
->bFixRate
= TRUE
;
323 pDevice
->byBBType
= BBP_TYPE_DEF
;
324 pDevice
->byPacketType
= pDevice
->byBBType
;
325 pDevice
->byAutoFBCtrl
= AUTO_FB_0
;
326 pDevice
->bUpdateBBVGA
= TRUE
;
327 pDevice
->byFOETuning
= 0;
328 pDevice
->byAutoPwrTunning
= 0;
329 pDevice
->wCTSDuration
= 0;
330 pDevice
->byPreambleType
= 0;
331 pDevice
->bExistSWNetAddr
= FALSE
;
332 // pDevice->bDiversityRegCtlON = TRUE;
333 pDevice
->bDiversityRegCtlON
= FALSE
;
337 static VOID
device_init_diversity_timer(PSDevice pDevice
) {
339 init_timer(&pDevice
->TimerSQ3Tmax1
);
340 pDevice
->TimerSQ3Tmax1
.data
= (ULONG
)pDevice
;
341 pDevice
->TimerSQ3Tmax1
.function
= (TimerFunction
)TimerSQ3CallBack
;
342 pDevice
->TimerSQ3Tmax1
.expires
= RUN_AT(HZ
);
344 init_timer(&pDevice
->TimerSQ3Tmax2
);
345 pDevice
->TimerSQ3Tmax2
.data
= (ULONG
)pDevice
;
346 pDevice
->TimerSQ3Tmax2
.function
= (TimerFunction
)TimerSQ3CallBack
;
347 pDevice
->TimerSQ3Tmax2
.expires
= RUN_AT(HZ
);
349 init_timer(&pDevice
->TimerSQ3Tmax3
);
350 pDevice
->TimerSQ3Tmax3
.data
= (ULONG
)pDevice
;
351 pDevice
->TimerSQ3Tmax3
.function
= (TimerFunction
)TimerSQ3Tmax3CallBack
;
352 pDevice
->TimerSQ3Tmax3
.expires
= RUN_AT(HZ
);
359 // Initialiation of MAC & BBP registers
362 static BOOL
device_init_registers(PSDevice pDevice
, DEVICE_INIT_TYPE InitType
)
364 BYTE abyBroadcastAddr
[U_ETHER_ADDR_LEN
] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
365 BYTE abySNAP_RFC1042
[U_ETHER_ADDR_LEN
] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
366 BYTE abySNAP_Bridgetunnel
[U_ETHER_ADDR_LEN
] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
369 CMD_CARD_INIT sInitCmd
;
370 NTSTATUS ntStatus
= STATUS_SUCCESS
;
371 RSP_CARD_INIT sInitRsp
;
372 PSMgmtObject pMgmt
= &(pDevice
->sMgmtObj
);
374 BYTE byCalibTXIQ
= 0;
375 BYTE byCalibTXDC
= 0;
376 BYTE byCalibRXIQ
= 0;
378 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"---->INIbInitAdapter. [%d][%d]\n", InitType
, pDevice
->byPacketType
);
379 spin_lock_irq(&pDevice
->lock
);
380 if (InitType
== DEVICE_INIT_COLD
) {
381 memcpy(pDevice
->abyBroadcastAddr
, abyBroadcastAddr
, U_ETHER_ADDR_LEN
);
382 memcpy(pDevice
->abySNAP_RFC1042
, abySNAP_RFC1042
, U_ETHER_ADDR_LEN
);
383 memcpy(pDevice
->abySNAP_Bridgetunnel
, abySNAP_Bridgetunnel
, U_ETHER_ADDR_LEN
);
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
;
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
, pDevice
->abyPermanentNetAddr
, U_ETHER_ADDR_LEN
);
610 // if exist SW network address, use SW network address.
612 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Network address = %02x-%02x-%02x=%02x-%02x-%02x\n",
613 pDevice
->abyCurrentNetAddr
[0],
614 pDevice
->abyCurrentNetAddr
[1],
615 pDevice
->abyCurrentNetAddr
[2],
616 pDevice
->abyCurrentNetAddr
[3],
617 pDevice
->abyCurrentNetAddr
[4],
618 pDevice
->abyCurrentNetAddr
[5]);
623 // Set BB and packet type at the same time.
624 // Set Short Slot Time, xIFS, and RSPINF.
625 if (pDevice
->byBBType
== BB_TYPE_11A
) {
626 CARDbAddBasicRate(pDevice
, RATE_6M
);
627 pDevice
->bShortSlotTime
= TRUE
;
629 CARDbAddBasicRate(pDevice
, RATE_1M
);
630 pDevice
->bShortSlotTime
= FALSE
;
632 BBvSetShortSlotTime(pDevice
);
633 CARDvSetBSSMode(pDevice
);
635 if (pDevice
->bUpdateBBVGA
) {
636 pDevice
->byBBVGACurrent
= pDevice
->abyBBVGA
[0];
637 pDevice
->byBBVGANew
= pDevice
->byBBVGACurrent
;
638 BBvSetVGAGainOffset(pDevice
, pDevice
->abyBBVGA
[0]);
641 pDevice
->byRadioCtl
= pDevice
->abyEEPROM
[EEP_OFS_RADIOCTL
];
642 pDevice
->bHWRadioOff
= FALSE
;
643 if ( (pDevice
->byRadioCtl
& EEP_RADIOCTL_ENABLE
) != 0 ) {
644 ntStatus
= CONTROLnsRequestIn(pDevice
,
647 MESSAGE_REQUEST_MACREG
,
651 if ( ntStatus
!= STATUS_SUCCESS
) {
652 spin_unlock_irq(&pDevice
->lock
);
655 if ( (byTmp
& GPIO3_DATA
) == 0 ) {
656 pDevice
->bHWRadioOff
= TRUE
;
657 MACvRegBitsOn(pDevice
,MAC_REG_GPIOCTL1
,GPIO3_INTMD
);
659 MACvRegBitsOff(pDevice
,MAC_REG_GPIOCTL1
,GPIO3_INTMD
);
660 pDevice
->bHWRadioOff
= FALSE
;
663 } //EEP_RADIOCTL_ENABLE
665 ControlvMaskByte(pDevice
,MESSAGE_REQUEST_MACREG
,MAC_REG_PAPEDELAY
,LEDSTS_TMLEN
,0x38);
666 ControlvMaskByte(pDevice
,MESSAGE_REQUEST_MACREG
,MAC_REG_PAPEDELAY
,LEDSTS_STS
,LEDSTS_SLOW
);
667 MACvRegBitsOn(pDevice
,MAC_REG_GPIOCTL0
,0x01);
669 if ((pDevice
->bHWRadioOff
== TRUE
) || (pDevice
->bRadioControlOff
== TRUE
)) {
670 CARDbRadioPowerOff(pDevice
);
672 CARDbRadioPowerOn(pDevice
);
675 spin_unlock_irq(&pDevice
->lock
);
676 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"<----INIbInitAdapter Exit\n");
680 static BOOL
device_release_WPADEV(PSDevice pDevice
)
682 viawget_wpa_header
*wpahdr
;
684 // wait_queue_head_t Set_wait;
685 //send device close to wpa_supplicnat layer
686 if (pDevice
->bWPADEVUp
==TRUE
) {
687 wpahdr
= (viawget_wpa_header
*)pDevice
->skb
->data
;
688 wpahdr
->type
= VIAWGET_DEVICECLOSE_MSG
;
689 wpahdr
->resp_ie_len
= 0;
690 wpahdr
->req_ie_len
= 0;
691 skb_put(pDevice
->skb
, sizeof(viawget_wpa_header
));
692 pDevice
->skb
->dev
= pDevice
->wpadev
;
693 skb_reset_mac_header(pDevice
->skb
);
694 pDevice
->skb
->pkt_type
= PACKET_HOST
;
695 pDevice
->skb
->protocol
= htons(ETH_P_802_2
);
696 memset(pDevice
->skb
->cb
, 0, sizeof(pDevice
->skb
->cb
));
697 netif_rx(pDevice
->skb
);
698 pDevice
->skb
= dev_alloc_skb((int)pDevice
->rx_buf_sz
);
700 //wait release WPADEV
701 // init_waitqueue_head(&Set_wait);
702 // wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ); //1s wait
703 while(pDevice
->bWPADEVUp
==TRUE
) {
704 set_current_state(TASK_UNINTERRUPTIBLE
);
705 schedule_timeout (HZ
/20); //wait 50ms
714 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
715 static int vntwusb_suspend(struct usb_interface
*intf
, pm_message_t message
)
717 PSDevice pDevice
= usb_get_intfdata(intf
);
718 struct net_device
*dev
= pDevice
->dev
;
720 printk("VNTWUSB Suspend Start======>\n");
722 if(pDevice
->flags
& DEVICE_FLAGS_OPENED
)
726 usb_put_dev(interface_to_usbdev(intf
));
730 static int vntwusb_resume(struct usb_interface
*intf
)
732 PSDevice pDevice
= usb_get_intfdata(intf
);
733 struct net_device
*dev
= pDevice
->dev
;
735 printk("VNTWUSB Resume Start======>\n");
737 usb_get_dev(interface_to_usbdev(intf
));
738 if(!(pDevice
->flags
& DEVICE_FLAGS_OPENED
)) {
739 if(device_open(dev
)!=0)
740 printk("VNTWUSB Resume Start======>open fail\n");
748 static const struct net_device_ops device_netdev_ops
= {
749 .ndo_open
= device_open
,
750 .ndo_stop
= device_close
,
751 .ndo_do_ioctl
= device_ioctl
,
752 .ndo_get_stats
= device_get_stats
,
753 .ndo_start_xmit
= device_xmit
,
754 .ndo_set_multicast_list
= device_set_multi
,
759 vntwusb_found1(struct usb_interface
*intf
, const struct usb_device_id
*id
)
761 BYTE fake_mac
[U_ETHER_ADDR_LEN
] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};//fake MAC address
762 struct usb_device
*udev
= interface_to_usbdev(intf
);
764 struct net_device
*netdev
= NULL
;
765 PSDevice pDevice
= NULL
;
768 printk(KERN_NOTICE
"%s Ver. %s\n",DEVICE_FULL_DRV_NAM
, DEVICE_VERSION
);
769 printk(KERN_NOTICE
"Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
771 udev
= usb_get_dev(udev
);
773 netdev
= alloc_etherdev(sizeof(DEVICE_INFO
));
775 if (netdev
== NULL
) {
776 printk(KERN_ERR DEVICE_NAME
": allocate net device failed \n");
781 pDevice
= netdev_priv(netdev
);
782 memset(pDevice
, 0, sizeof(DEVICE_INFO
));
784 pDevice
->dev
= netdev
;
787 // Set initial settings
788 device_set_options(pDevice
);
789 spin_lock_init(&pDevice
->lock
);
791 pDevice
->tx_80211
= device_dma0_tx_80211
;
792 pDevice
->sMgmtObj
.pAdapter
= (PVOID
)pDevice
;
794 netdev
->netdev_ops
= &device_netdev_ops
;
796 netdev
->wireless_handlers
= (struct iw_handler_def
*)&iwctl_handler_def
;
798 //2008-0623-01<Remark>by MikeLiu
799 //2007-0821-01<Add>by MikeLiu
800 usb_set_intfdata(intf
, pDevice
);
801 SET_NETDEV_DEV(netdev
, &intf
->dev
);
802 memcpy(pDevice
->dev
->dev_addr
, fake_mac
, U_ETHER_ADDR_LEN
); //use fake mac address
803 rc
= register_netdev(netdev
);
805 printk(KERN_ERR DEVICE_NAME
" Failed to register netdev\n");
811 //2008-07-21-01<Add>by MikeLiu
814 if(wpa_set_wpadev(pDevice
, 1)!=0) {
815 printk("Fail to Register WPADEV?\n");
816 unregister_netdev(pDevice
->dev
);
821 usb_device_reset(pDevice
);
825 union iwreq_data wrqu
;
826 memset(&wrqu
, 0, sizeof(wrqu
));
827 wrqu
.data
.flags
= RT_INSMOD_EVENT_FLAG
;
828 wrqu
.data
.length
=IFNAMSIZ
;
829 wireless_send_event(pDevice
->dev
, IWEVCUSTOM
, &wrqu
, pDevice
->dev
->name
);
837 //2008-0922-01<Add>by MikeLiu, decrease usb counter.
844 static VOID
device_free_tx_bufs(PSDevice pDevice
) {
845 PUSB_SEND_CONTEXT pTxContext
;
848 for (ii
= 0; ii
< pDevice
->cbTD
; ii
++) {
850 pTxContext
= pDevice
->apTD
[ii
];
852 if (pTxContext
->pUrb
) {
853 usb_kill_urb(pTxContext
->pUrb
);
854 usb_free_urb(pTxContext
->pUrb
);
863 static VOID
device_free_rx_bufs(PSDevice pDevice
) {
867 for (ii
= 0; ii
< pDevice
->cbRD
; ii
++) {
869 pRCB
= pDevice
->apRCB
[ii
];
872 usb_kill_urb(pRCB
->pUrb
);
873 usb_free_urb(pRCB
->pUrb
);
877 dev_kfree_skb(pRCB
->skb
);
879 if (pDevice
->pRCBMem
)
880 kfree(pDevice
->pRCBMem
);
885 //2007-1107-02<Add>by MikeLiu
886 static void usb_device_reset(PSDevice pDevice
)
889 status
= usb_reset_device(pDevice
->usb
);
891 printk("usb_device_reset fail status=%d\n",status
);
895 static VOID
device_free_int_bufs(PSDevice pDevice
) {
897 if (pDevice
->intBuf
.pDataBuf
!= NULL
)
898 kfree(pDevice
->intBuf
.pDataBuf
);
903 static BOOL
device_alloc_bufs(PSDevice pDevice
) {
905 PUSB_SEND_CONTEXT pTxContext
;
910 for (ii
= 0; ii
< pDevice
->cbTD
; ii
++) {
912 pTxContext
= kmalloc(sizeof(USB_SEND_CONTEXT
), GFP_KERNEL
);
913 if (pTxContext
== NULL
) {
914 DBG_PRT(MSG_LEVEL_ERR
,KERN_ERR
"%s : allocate tx usb context failed\n", pDevice
->dev
->name
);
917 pDevice
->apTD
[ii
] = pTxContext
;
918 pTxContext
->pDevice
= (PVOID
) pDevice
;
920 pTxContext
->pUrb
= usb_alloc_urb(0, GFP_ATOMIC
);
921 if (pTxContext
->pUrb
== NULL
) {
922 DBG_PRT(MSG_LEVEL_ERR
,KERN_ERR
"alloc tx urb failed\n");
925 pTxContext
->bBoolInUse
= FALSE
;
929 pDevice
->pRCBMem
= kmalloc((sizeof(RCB
) * pDevice
->cbRD
), GFP_KERNEL
);
930 if (pDevice
->pRCBMem
== NULL
) {
931 DBG_PRT(MSG_LEVEL_ERR
,KERN_ERR
"%s : alloc rx usb context failed\n", pDevice
->dev
->name
);
936 pDevice
->FirstRecvFreeList
= NULL
;
937 pDevice
->LastRecvFreeList
= NULL
;
938 pDevice
->FirstRecvMngList
= NULL
;
939 pDevice
->LastRecvMngList
= NULL
;
940 pDevice
->NumRecvFreeList
= 0;
941 memset(pDevice
->pRCBMem
, 0, (sizeof(RCB
) * pDevice
->cbRD
));
942 pRCB
= (PRCB
) pDevice
->pRCBMem
;
944 for (ii
= 0; ii
< pDevice
->cbRD
; ii
++) {
946 pDevice
->apRCB
[ii
] = pRCB
;
947 pRCB
->pDevice
= (PVOID
) pDevice
;
949 pRCB
->pUrb
= usb_alloc_urb(0, GFP_ATOMIC
);
951 if (pRCB
->pUrb
== NULL
) {
952 DBG_PRT(MSG_LEVEL_ERR
,KERN_ERR
" Failed to alloc rx urb\n");
955 pRCB
->skb
= dev_alloc_skb((int)pDevice
->rx_buf_sz
);
956 if (pRCB
->skb
== NULL
) {
957 DBG_PRT(MSG_LEVEL_ERR
,KERN_ERR
" Failed to alloc rx skb\n");
960 pRCB
->skb
->dev
= pDevice
->dev
;
961 pRCB
->bBoolInUse
= FALSE
;
962 EnqueueRCB(pDevice
->FirstRecvFreeList
, pDevice
->LastRecvFreeList
, pRCB
);
963 pDevice
->NumRecvFreeList
++;
968 pDevice
->pControlURB
= usb_alloc_urb(0, GFP_ATOMIC
);
969 if (pDevice
->pControlURB
== NULL
) {
970 DBG_PRT(MSG_LEVEL_ERR
,KERN_ERR
"Failed to alloc control urb\n");
974 pDevice
->pInterruptURB
= usb_alloc_urb(0, GFP_ATOMIC
);
975 if (pDevice
->pInterruptURB
== NULL
) {
976 DBG_PRT(MSG_LEVEL_ERR
,KERN_ERR
"Failed to alloc int urb\n");
977 usb_kill_urb(pDevice
->pControlURB
);
978 usb_free_urb(pDevice
->pControlURB
);
982 pDevice
->intBuf
.pDataBuf
= kmalloc(MAX_INTERRUPT_SIZE
, GFP_KERNEL
);
983 if (pDevice
->intBuf
.pDataBuf
== NULL
) {
984 DBG_PRT(MSG_LEVEL_ERR
,KERN_ERR
"Failed to alloc int buf\n");
985 usb_kill_urb(pDevice
->pControlURB
);
986 usb_kill_urb(pDevice
->pInterruptURB
);
987 usb_free_urb(pDevice
->pControlURB
);
988 usb_free_urb(pDevice
->pInterruptURB
);
995 device_free_rx_bufs(pDevice
);
998 device_free_tx_bufs(pDevice
);
1006 static BOOL
device_init_defrag_cb(PSDevice pDevice
) {
1008 PSDeFragControlBlock pDeF
;
1010 /* Init the fragment ctl entries */
1011 for (i
= 0; i
< CB_MAX_RX_FRAG
; i
++) {
1012 pDeF
= &(pDevice
->sRxDFCB
[i
]);
1013 if (!device_alloc_frag_buf(pDevice
, pDeF
)) {
1014 DBG_PRT(MSG_LEVEL_ERR
,KERN_ERR
"%s: can not alloc frag bufs\n",
1015 pDevice
->dev
->name
);
1019 pDevice
->cbDFCB
= CB_MAX_RX_FRAG
;
1020 pDevice
->cbFreeDFCB
= pDevice
->cbDFCB
;
1024 device_free_frag_bufs(pDevice
);
1030 static void device_free_frag_bufs(PSDevice pDevice
) {
1031 PSDeFragControlBlock pDeF
;
1034 for (i
= 0; i
< CB_MAX_RX_FRAG
; i
++) {
1036 pDeF
= &(pDevice
->sRxDFCB
[i
]);
1039 dev_kfree_skb(pDeF
->skb
);
1045 BOOL
device_alloc_frag_buf(PSDevice pDevice
, PSDeFragControlBlock pDeF
) {
1047 pDeF
->skb
= dev_alloc_skb((int)pDevice
->rx_buf_sz
);
1048 if (pDeF
->skb
== NULL
)
1051 pDeF
->skb
->dev
= pDevice
->dev
;
1057 /*-----------------------------------------------------------------*/
1059 static int device_open(struct net_device
*dev
) {
1060 PSDevice pDevice
=(PSDevice
) netdev_priv(dev
);
1062 #ifdef WPA_SM_Transtatus
1063 extern SWPAResult wpa_Result
;
1064 memset(wpa_Result
.ifname
,0,sizeof(wpa_Result
.ifname
));
1065 wpa_Result
.proto
= 0;
1066 wpa_Result
.key_mgmt
= 0;
1067 wpa_Result
.eap_type
= 0;
1068 wpa_Result
.authenticated
= FALSE
;
1069 pDevice
->fWPA_Authened
= FALSE
;
1072 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" device_open...\n");
1075 pDevice
->rx_buf_sz
= MAX_TOTAL_SIZE_WITH_ALL_HEADERS
;
1077 if (device_alloc_bufs(pDevice
) == FALSE
) {
1078 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" device_alloc_bufs fail... \n");
1082 if (device_init_defrag_cb(pDevice
)== FALSE
) {
1083 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" Initial defragement cb fail \n");
1087 MP_CLEAR_FLAG(pDevice
, fMP_DISCONNECTED
);
1088 MP_CLEAR_FLAG(pDevice
, fMP_CONTROL_READS
);
1089 MP_CLEAR_FLAG(pDevice
, fMP_CONTROL_WRITES
);
1090 MP_SET_FLAG(pDevice
, fMP_POST_READS
);
1091 MP_SET_FLAG(pDevice
, fMP_POST_WRITES
);
1094 Read_config_file(pDevice
);
1096 if (device_init_registers(pDevice
, DEVICE_INIT_COLD
) == FALSE
) {
1097 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" init register fail\n");
1101 device_set_multi(pDevice
->dev
);
1102 // Init for Key Management
1104 KeyvInitTable(pDevice
,&pDevice
->sKey
);
1105 memcpy(pDevice
->sMgmtObj
.abyMACAddr
, pDevice
->abyCurrentNetAddr
, U_ETHER_ADDR_LEN
);
1106 memcpy(pDevice
->dev
->dev_addr
, pDevice
->abyCurrentNetAddr
, U_ETHER_ADDR_LEN
);
1107 pDevice
->bStopTx0Pkt
= FALSE
;
1108 pDevice
->bStopDataPkt
= FALSE
;
1109 pDevice
->bRoaming
= FALSE
; //DavidWang
1110 pDevice
->bIsRoaming
= FALSE
;//DavidWang
1111 pDevice
->bEnableRoaming
= FALSE
;
1112 if (pDevice
->bDiversityRegCtlON
) {
1113 device_init_diversity_timer(pDevice
);
1116 vMgrObjectInit(pDevice
);
1117 tasklet_init(&pDevice
->RxMngWorkItem
, (void *)RXvMngWorkItem
, (unsigned long)pDevice
);
1118 tasklet_init(&pDevice
->ReadWorkItem
, (void *)RXvWorkItem
, (unsigned long)pDevice
);
1119 tasklet_init(&pDevice
->EventWorkItem
, (void *)INTvWorkItem
, (unsigned long)pDevice
);
1120 add_timer(&(pDevice
->sMgmtObj
.sTimerSecondCallback
));
1121 pDevice
->int_interval
= 100; //Max 100 microframes.
1122 pDevice
->eEncryptionStatus
= Ndis802_11EncryptionDisabled
;
1124 pDevice
->bIsRxWorkItemQueued
= TRUE
;
1125 pDevice
->fKillEventPollingThread
= FALSE
;
1126 pDevice
->bEventAvailable
= FALSE
;
1128 pDevice
->bWPADEVUp
= FALSE
;
1129 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1130 pDevice
->bwextstep0
= FALSE
;
1131 pDevice
->bwextstep1
= FALSE
;
1132 pDevice
->bwextstep2
= FALSE
;
1133 pDevice
->bwextstep3
= FALSE
;
1134 pDevice
->bWPASuppWextEnabled
= FALSE
;
1136 pDevice
->byReAssocCount
= 0;
1138 RXvWorkItem(pDevice
);
1139 INTvWorkItem(pDevice
);
1141 // Patch: if WEP key already set by iwconfig but device not yet open
1142 if ((pDevice
->bEncryptionEnable
== TRUE
) && (pDevice
->bTransmitKey
== TRUE
)) {
1143 spin_lock_irq(&pDevice
->lock
);
1144 KeybSetDefaultKey( pDevice
,
1146 pDevice
->byKeyIndex
| (1 << 31),
1147 pDevice
->uKeyLength
,
1152 spin_unlock_irq(&pDevice
->lock
);
1153 pDevice
->eEncryptionStatus
= Ndis802_11Encryption1Enabled
;
1156 if (pDevice
->sMgmtObj
.eConfigMode
== WMAC_CONFIG_AP
) {
1157 bScheduleCommand((HANDLE
)pDevice
, WLAN_CMD_RUN_AP
, NULL
);
1160 //mike:mark@2008-11-10
1161 bScheduleCommand((HANDLE
)pDevice
, WLAN_CMD_BSSID_SCAN
, NULL
);
1162 //bScheduleCommand((HANDLE)pDevice, WLAN_CMD_SSID, NULL);
1166 netif_stop_queue(pDevice
->dev
);
1167 pDevice
->flags
|= DEVICE_FLAGS_OPENED
;
1171 union iwreq_data wrqu
;
1172 memset(&wrqu
, 0, sizeof(wrqu
));
1173 wrqu
.data
.flags
= RT_UPDEV_EVENT_FLAG
;
1174 wireless_send_event(pDevice
->dev
, IWEVCUSTOM
, &wrqu
, NULL
);
1178 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"device_open success.. \n");
1182 device_free_frag_bufs(pDevice
);
1184 device_free_rx_bufs(pDevice
);
1185 device_free_tx_bufs(pDevice
);
1186 device_free_int_bufs(pDevice
);
1187 usb_kill_urb(pDevice
->pControlURB
);
1188 usb_kill_urb(pDevice
->pInterruptURB
);
1189 usb_free_urb(pDevice
->pControlURB
);
1190 usb_free_urb(pDevice
->pInterruptURB
);
1192 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"device_open fail.. \n");
1198 static int device_close(struct net_device
*dev
) {
1199 PSDevice pDevice
=(PSDevice
) netdev_priv(dev
);
1200 PSMgmtObject pMgmt
= &(pDevice
->sMgmtObj
);
1204 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"device_close1 \n");
1205 if (pDevice
== NULL
)
1210 union iwreq_data wrqu
;
1211 memset(&wrqu
, 0, sizeof(wrqu
));
1212 wrqu
.data
.flags
= RT_DOWNDEV_EVENT_FLAG
;
1213 wireless_send_event(pDevice
->dev
, IWEVCUSTOM
, &wrqu
, NULL
);
1217 //2007-1121-02<Add>by EinsnLiu
1218 if (pDevice
->bLinkPass
) {
1219 bScheduleCommand((HANDLE
)pDevice
, WLAN_CMD_DISASSOCIATE
, NULL
);
1224 //2008-0714-01<Add>by MikeLiu
1225 device_release_WPADEV(pDevice
);
1227 memset(pMgmt
->abyDesireSSID
, 0, WLAN_IEHDR_LEN
+ WLAN_SSID_MAXLEN
+ 1);
1228 pMgmt
->bShareKeyAlgorithm
= FALSE
;
1229 pDevice
->bEncryptionEnable
= FALSE
;
1230 pDevice
->eEncryptionStatus
= Ndis802_11EncryptionDisabled
;
1231 spin_lock_irq(&pDevice
->lock
);
1232 for(uu
=0;uu
<MAX_KEY_TABLE
;uu
++)
1233 MACvDisableKeyEntry(pDevice
,uu
);
1234 spin_unlock_irq(&pDevice
->lock
);
1236 if ((pDevice
->flags
& DEVICE_FLAGS_UNPLUG
) == FALSE
) {
1237 MACbShutdown(pDevice
);
1239 netif_stop_queue(pDevice
->dev
);
1240 MP_SET_FLAG(pDevice
, fMP_DISCONNECTED
);
1241 MP_CLEAR_FLAG(pDevice
, fMP_POST_WRITES
);
1242 MP_CLEAR_FLAG(pDevice
, fMP_POST_READS
);
1243 pDevice
->fKillEventPollingThread
= TRUE
;
1244 del_timer(&pDevice
->sTimerCommand
);
1245 del_timer(&pMgmt
->sTimerSecondCallback
);
1247 //2007-0115-02<Add>by MikeLiu
1249 del_timer(&pDevice
->sTimerTxData
);
1252 if (pDevice
->bDiversityRegCtlON
) {
1253 del_timer(&pDevice
->TimerSQ3Tmax1
);
1254 del_timer(&pDevice
->TimerSQ3Tmax2
);
1255 del_timer(&pDevice
->TimerSQ3Tmax3
);
1257 tasklet_kill(&pDevice
->RxMngWorkItem
);
1258 tasklet_kill(&pDevice
->ReadWorkItem
);
1259 tasklet_kill(&pDevice
->EventWorkItem
);
1261 pDevice
->bRoaming
= FALSE
; //DavidWang
1262 pDevice
->bIsRoaming
= FALSE
;//DavidWang
1263 pDevice
->bEnableRoaming
= FALSE
;
1264 pDevice
->bCmdRunning
= FALSE
;
1265 pDevice
->bLinkPass
= FALSE
;
1266 memset(pMgmt
->abyCurrBSSID
, 0, 6);
1267 pMgmt
->eCurrState
= WMAC_STATE_IDLE
;
1269 device_free_tx_bufs(pDevice
);
1270 device_free_rx_bufs(pDevice
);
1271 device_free_int_bufs(pDevice
);
1272 device_free_frag_bufs(pDevice
);
1274 usb_kill_urb(pDevice
->pControlURB
);
1275 usb_kill_urb(pDevice
->pInterruptURB
);
1276 usb_free_urb(pDevice
->pControlURB
);
1277 usb_free_urb(pDevice
->pInterruptURB
);
1279 BSSvClearNodeDBTable(pDevice
, 0);
1280 pDevice
->flags
&=(~DEVICE_FLAGS_OPENED
);
1282 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"device_close2 \n");
1288 static void vntwusb_disconnect(struct usb_interface
*intf
)
1292 PSDevice pDevice
= usb_get_intfdata(intf
);
1294 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"device_disconnect1.. \n");
1295 if (pDevice
== NULL
)
1300 union iwreq_data wrqu
;
1301 memset(&wrqu
, 0, sizeof(wrqu
));
1302 wrqu
.data
.flags
= RT_RMMOD_EVENT_FLAG
;
1303 wireless_send_event(pDevice
->dev
, IWEVCUSTOM
, &wrqu
, NULL
);
1307 //2008-0714-01<Add>by MikeLiu
1308 device_release_WPADEV(pDevice
);
1310 usb_set_intfdata(intf
, NULL
);
1311 //2008-0922-01<Add>by MikeLiu, decrease usb counter.
1312 usb_put_dev(interface_to_usbdev(intf
));
1314 pDevice
->flags
|= DEVICE_FLAGS_UNPLUG
;
1315 if (pDevice
->dev
!= NULL
) {
1316 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"unregister_netdev..\n");
1317 unregister_netdev(pDevice
->dev
);
1319 //2008-07-21-01<Add>by MikeLiu
1321 if(wpa_set_wpadev(pDevice
, 0)!=0)
1322 printk("unregister wpadev fail?\n");
1324 free_netdev(pDevice
->dev
);
1327 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"device_disconnect3.. \n");
1333 static int device_dma0_tx_80211(struct sk_buff
*skb
, struct net_device
*dev
) {
1334 PSDevice pDevice
=netdev_priv(dev
);
1339 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"device_dma0_tx_80211\n");
1340 spin_lock_irq(&pDevice
->lock
);
1342 if (pDevice
->bStopTx0Pkt
== TRUE
) {
1343 dev_kfree_skb_irq(skb
);
1344 spin_unlock_irq(&pDevice
->lock
);
1349 cbMPDULen
= skb
->len
;
1352 vDMA0_tx_80211(pDevice
, skb
);
1354 spin_unlock_irq(&pDevice
->lock
);
1361 static int device_xmit(struct sk_buff
*skb
, struct net_device
*dev
) {
1362 PSDevice pDevice
=netdev_priv(dev
);
1363 struct net_device_stats
* pStats
= &pDevice
->stats
;
1366 spin_lock_irq(&pDevice
->lock
);
1368 netif_stop_queue(pDevice
->dev
);
1370 if (pDevice
->bLinkPass
== FALSE
) {
1371 dev_kfree_skb_irq(skb
);
1372 spin_unlock_irq(&pDevice
->lock
);
1375 if (pDevice
->bStopDataPkt
== TRUE
) {
1376 dev_kfree_skb_irq(skb
);
1377 pStats
->tx_dropped
++;
1378 spin_unlock_irq(&pDevice
->lock
);
1382 if(nsDMA_tx_packet(pDevice
, TYPE_AC0DMA
, skb
) !=0) { //mike add:xmit fail!
1383 if (netif_queue_stopped(pDevice
->dev
))
1384 netif_wake_queue(pDevice
->dev
);
1387 spin_unlock_irq(&pDevice
->lock
);
1394 static unsigned const ethernet_polynomial
= 0x04c11db7U
;
1395 static inline u32
ether_crc(int length
, unsigned char *data
)
1399 while(--length
>= 0) {
1400 unsigned char current_octet
= *data
++;
1402 for (bit
= 0; bit
< 8; bit
++, current_octet
>>= 1) {
1404 ((crc
< 0) ^ (current_octet
& 1) ? ethernet_polynomial
: 0);
1410 //find out the start position of str2 from str1
1411 static UCHAR
*kstrstr(const UCHAR
*str1
,const UCHAR
*str2
) {
1412 int str1_len
=strlen(str1
);
1413 int str2_len
=strlen(str2
);
1415 while (str1_len
>= str2_len
) {
1417 if(memcmp(str1
,str2
,str2_len
)==0)
1418 return (UCHAR
*)str1
;
1424 static int Config_FileGetParameter(UCHAR
*string
, UCHAR
*dest
,UCHAR
*source
)
1428 UCHAR
*start_p
=NULL
,*end_p
=NULL
,*tmp_p
=NULL
;
1432 strcat(buf1
, string
);
1434 source
+=strlen(buf1
);
1436 //find target string start point
1437 if((start_p
= kstrstr(source
,buf1
))==NULL
)
1440 //check if current config line is marked by "#" ??
1442 if(memcmp(start_p
-ii
,"\n",1)==0)
1444 if(memcmp(start_p
-ii
,"#",1)==0)
1448 //find target string end point
1449 if((end_p
= kstrstr(start_p
,"\n"))==NULL
) { //cann't find "\n",but don't care
1450 end_p
=start_p
+strlen(start_p
); //no include "\n"
1454 memcpy(buf2
,start_p
,end_p
-start_p
); //get the tartget line
1455 buf2
[end_p
-start_p
]='\0';
1458 if((start_p
= kstrstr(buf2
,"="))==NULL
)
1461 strcpy(buf1
,start_p
+1);
1465 while(*tmp_p
!= 0x00) {
1472 memcpy(dest
,tmp_p
,strlen(tmp_p
));
1476 //if read fail,return NULL,or return data pointer;
1477 static UCHAR
*Config_FileOperation(PSDevice pDevice
) {
1478 UCHAR
*config_path
=CONFIG_PATH
;
1480 struct file
*filp
=NULL
;
1481 mm_segment_t old_fs
= get_fs();
1482 //int oldfsuid=0,oldfsgid=0;
1486 /* Can't do this anymore, so we rely on correct filesystem permissions:
1487 //Make sure a caller can read or write power as root
1488 oldfsuid=current->fsuid;
1489 oldfsgid=current->fsgid;
1495 filp
= filp_open(config_path
, O_RDWR
, 0);
1497 printk("Config_FileOperation file Not exist\n");
1502 if(!(filp
->f_op
) || !(filp
->f_op
->read
) ||!(filp
->f_op
->write
)) {
1503 printk("file %s cann't readable or writable?\n",config_path
);
1508 buffer
= (UCHAR
*)kmalloc(1024, GFP_KERNEL
);
1510 printk("alllocate mem for file fail?\n");
1515 if(filp
->f_op
->read(filp
, buffer
, 1024, &filp
->f_pos
)<0) {
1516 printk("read file error?\n");
1521 if(filp_close(filp
,NULL
))
1522 printk("Config_FileOperation:close file fail\n");
1528 current->fsuid=oldfsuid;
1529 current->fsgid=oldfsgid;
1540 //return --->-1:fail; >=0:successful
1541 static int Read_config_file(PSDevice pDevice
) {
1543 UCHAR tmpbuffer
[100];
1546 //init config setting
1547 pDevice
->config_file
.ZoneType
= -1;
1548 pDevice
->config_file
.eAuthenMode
= -1;
1549 pDevice
->config_file
.eEncryptionStatus
= -1;
1551 if((buffer
=Config_FileOperation(pDevice
)) ==NULL
) {
1558 memset(tmpbuffer
,0,sizeof(tmpbuffer
));
1559 if(Config_FileGetParameter("ZONETYPE",tmpbuffer
,buffer
) ==TRUE
) {
1560 if(memcmp(tmpbuffer
,"USA",3)==0) {
1561 pDevice
->config_file
.ZoneType
=ZoneType_USA
;
1563 else if(memcmp(tmpbuffer
,"JAPAN",5)==0) {
1564 pDevice
->config_file
.ZoneType
=ZoneType_Japan
;
1566 else if(memcmp(tmpbuffer
,"EUROPE",6)==0) {
1567 pDevice
->config_file
.ZoneType
=ZoneType_Europe
;
1570 printk("Unknown Zonetype[%s]?\n",tmpbuffer
);
1576 //get other parameter
1578 memset(tmpbuffer
,0,sizeof(tmpbuffer
));
1579 if(Config_FileGetParameter("AUTHENMODE",tmpbuffer
,buffer
)==TRUE
) {
1580 pDevice
->config_file
.eAuthenMode
= (int) simple_strtol(tmpbuffer
, NULL
, 10);
1583 memset(tmpbuffer
,0,sizeof(tmpbuffer
));
1584 if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer
,buffer
)==TRUE
) {
1585 pDevice
->config_file
.eEncryptionStatus
= (int) simple_strtol(tmpbuffer
, NULL
, 10);
1594 static void device_set_multi(struct net_device
*dev
) {
1595 PSDevice pDevice
= (PSDevice
) netdev_priv(dev
);
1596 PSMgmtObject pMgmt
= &(pDevice
->sMgmtObj
);
1599 struct dev_mc_list
*mclist
;
1600 BYTE pbyData
[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1605 spin_lock_irq(&pDevice
->lock
);
1606 rc
= CONTROLnsRequestIn(pDevice
,
1609 MESSAGE_REQUEST_MACREG
,
1613 if (rc
== 0) pDevice
->byRxMode
= byTmpMode
;
1615 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"pDevice->byRxMode in= %x\n", pDevice
->byRxMode
);
1617 if (dev
->flags
& IFF_PROMISC
) { // Set promiscuous.
1618 DBG_PRT(MSG_LEVEL_ERR
,KERN_NOTICE
"%s: Promiscuous mode enabled.\n", dev
->name
);
1619 // Unconditionally log net taps.
1620 pDevice
->byRxMode
|= (RCR_MULTICAST
|RCR_BROADCAST
|RCR_UNICAST
);
1622 else if ((netdev_mc_count(dev
) > pDevice
->multicast_limit
) ||
1623 (dev
->flags
& IFF_ALLMULTI
)) {
1624 CONTROLnsRequestOut(pDevice
,
1627 MESSAGE_REQUEST_MACREG
,
1631 pDevice
->byRxMode
|= (RCR_MULTICAST
|RCR_BROADCAST
);
1634 memset(mc_filter
, 0, sizeof(mc_filter
));
1635 for (ii
= 0, mclist
= dev
->mc_list
; mclist
&& ii
< netdev_mc_count(dev
);
1636 ii
++, mclist
= mclist
->next
) {
1637 int bit_nr
= ether_crc(ETH_ALEN
, mclist
->dmi_addr
) >> 26;
1638 mc_filter
[bit_nr
>> 5] |= cpu_to_le32(1 << (bit_nr
& 31));
1640 for (ii
= 0; ii
< 4; ii
++) {
1641 MACvWriteMultiAddr(pDevice
, ii
, *((PBYTE
)&mc_filter
[0] + ii
));
1642 MACvWriteMultiAddr(pDevice
, ii
+ 4, *((PBYTE
)&mc_filter
[1] + ii
));
1644 pDevice
->byRxMode
&= ~(RCR_UNICAST
);
1645 pDevice
->byRxMode
|= (RCR_MULTICAST
|RCR_BROADCAST
);
1648 if (pMgmt
->eConfigMode
== WMAC_CONFIG_AP
) {
1649 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1650 pDevice
->byRxMode
|= (RCR_MULTICAST
|RCR_BROADCAST
);
1651 pDevice
->byRxMode
&= ~(RCR_UNICAST
);
1653 ControlvWriteByte(pDevice
, MESSAGE_REQUEST_MACREG
, MAC_REG_RCR
, pDevice
->byRxMode
);
1654 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"pDevice->byRxMode out= %x\n", pDevice
->byRxMode
);
1655 spin_unlock_irq(&pDevice
->lock
);
1660 static struct net_device_stats
*device_get_stats(struct net_device
*dev
) {
1661 PSDevice pDevice
=(PSDevice
) netdev_priv(dev
);
1663 return &pDevice
->stats
;
1667 static int device_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
) {
1668 PSDevice pDevice
= (PSDevice
)netdev_priv(dev
);
1669 PSMgmtObject pMgmt
= &(pDevice
->sMgmtObj
);
1671 //BOOL bCommit = FALSE;
1672 struct iwreq
*wrq
= (struct iwreq
*) rq
;
1675 if (pMgmt
== NULL
) {
1683 rc
= iwctl_giwname(dev
, NULL
, (char *)&(wrq
->u
.name
), NULL
);
1690 case SIOCGIWNWID
: //0x8b03 support
1691 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1692 rc
= iwctl_giwnwid(dev
, NULL
, &(wrq
->u
.nwid
), NULL
);
1698 // Set frequency/channel
1700 rc
= iwctl_siwfreq(dev
, NULL
, &(wrq
->u
.freq
), NULL
);
1703 // Get frequency/channel
1705 rc
= iwctl_giwfreq(dev
, NULL
, &(wrq
->u
.freq
), NULL
);
1708 // Set desired network name (ESSID)
1712 char essid
[IW_ESSID_MAX_SIZE
+1];
1713 if (wrq
->u
.essid
.length
> IW_ESSID_MAX_SIZE
) {
1717 if (copy_from_user(essid
, wrq
->u
.essid
.pointer
,
1718 wrq
->u
.essid
.length
)) {
1722 rc
= iwctl_siwessid(dev
, NULL
,
1723 &(wrq
->u
.essid
), essid
);
1728 // Get current network name (ESSID)
1732 char essid
[IW_ESSID_MAX_SIZE
+1];
1733 if (wrq
->u
.essid
.pointer
)
1734 rc
= iwctl_giwessid(dev
, NULL
,
1735 &(wrq
->u
.essid
), essid
);
1736 if (copy_to_user(wrq
->u
.essid
.pointer
,
1738 wrq
->u
.essid
.length
) )
1745 rc
= iwctl_siwap(dev
, NULL
, &(wrq
->u
.ap_addr
), NULL
);
1749 // Get current Access Point (BSSID)
1751 rc
= iwctl_giwap(dev
, NULL
, &(wrq
->u
.ap_addr
), NULL
);
1755 // Set desired station name
1757 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCSIWNICKN \n");
1761 // Get current station name
1763 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCGIWNICKN \n");
1767 // Set the desired bit-rate
1769 rc
= iwctl_siwrate(dev
, NULL
, &(wrq
->u
.bitrate
), NULL
);
1772 // Get the current bit-rate
1775 rc
= iwctl_giwrate(dev
, NULL
, &(wrq
->u
.bitrate
), NULL
);
1778 // Set the desired RTS threshold
1781 rc
= iwctl_siwrts(dev
, NULL
, &(wrq
->u
.rts
), NULL
);
1784 // Get the current RTS threshold
1787 rc
= iwctl_giwrts(dev
, NULL
, &(wrq
->u
.rts
), NULL
);
1790 // Set the desired fragmentation threshold
1793 rc
= iwctl_siwfrag(dev
, NULL
, &(wrq
->u
.frag
), NULL
);
1796 // Get the current fragmentation threshold
1799 rc
= iwctl_giwfrag(dev
, NULL
, &(wrq
->u
.frag
), NULL
);
1802 // Set mode of operation
1804 rc
= iwctl_siwmode(dev
, NULL
, &(wrq
->u
.mode
), NULL
);
1807 // Get mode of operation
1809 rc
= iwctl_giwmode(dev
, NULL
, &(wrq
->u
.mode
), NULL
);
1812 // Set WEP keys and mode
1815 char abyKey
[WLAN_WEP232_KEYLEN
];
1817 if (wrq
->u
.encoding
.pointer
) {
1820 if (wrq
->u
.encoding
.length
> WLAN_WEP232_KEYLEN
) {
1824 memset(abyKey
, 0, WLAN_WEP232_KEYLEN
);
1825 if (copy_from_user(abyKey
,
1826 wrq
->u
.encoding
.pointer
,
1827 wrq
->u
.encoding
.length
)) {
1831 } else if (wrq
->u
.encoding
.length
!= 0) {
1835 rc
= iwctl_siwencode(dev
, NULL
, &(wrq
->u
.encoding
), abyKey
);
1839 // Get the WEP keys and mode
1842 if (!capable(CAP_NET_ADMIN
)) {
1847 char abyKey
[WLAN_WEP232_KEYLEN
];
1849 rc
= iwctl_giwencode(dev
, NULL
, &(wrq
->u
.encoding
), abyKey
);
1851 if (wrq
->u
.encoding
.pointer
) {
1852 if (copy_to_user(wrq
->u
.encoding
.pointer
,
1854 wrq
->u
.encoding
.length
))
1860 // Get the current Tx-Power
1862 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCGIWTXPOW \n");
1867 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCGIWTXPOW \n");
1873 rc
= iwctl_siwretry(dev
, NULL
, &(wrq
->u
.retry
), NULL
);
1878 rc
= iwctl_giwretry(dev
, NULL
, &(wrq
->u
.retry
), NULL
);
1881 // Get range of parameters
1885 struct iw_range range
;
1887 rc
= iwctl_giwrange(dev
, NULL
, &(wrq
->u
.data
), (char *) &range
);
1888 if (copy_to_user(wrq
->u
.data
.pointer
, &range
, sizeof(struct iw_range
)))
1896 rc
= iwctl_giwpower(dev
, NULL
, &(wrq
->u
.power
), NULL
);
1902 rc
= iwctl_siwpower(dev
, NULL
, &(wrq
->u
.power
), NULL
);
1908 rc
= iwctl_giwsens(dev
, NULL
, &(wrq
->u
.sens
), NULL
);
1912 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCSIWSENS \n");
1918 char buffer
[IW_MAX_AP
* (sizeof(struct sockaddr
) + sizeof(struct iw_quality
))];
1920 if (wrq
->u
.data
.pointer
) {
1921 rc
= iwctl_giwaplist(dev
, NULL
, &(wrq
->u
.data
), buffer
);
1923 if (copy_to_user(wrq
->u
.data
.pointer
,
1925 (wrq
->u
.data
.length
* (sizeof(struct sockaddr
) + sizeof(struct iw_quality
)))
1938 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCSIWSPY \n");
1945 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCSIWSPY \n");
1949 #endif // WIRELESS_SPY
1952 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCGIWPRIV \n");
1955 if(wrq->u.data.pointer) {
1956 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
1958 if(copy_to_user(wrq->u.data.pointer,
1959 (u_char *) iwctl_private_args,
1960 sizeof(iwctl_private_args)))
1967 //2008-0409-07, <Add> by Einsn Liu
1968 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1970 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCSIWAUTH \n");
1971 rc
= iwctl_siwauth(dev
, NULL
, &(wrq
->u
.param
), NULL
);
1975 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCGIWAUTH \n");
1976 rc
= iwctl_giwauth(dev
, NULL
, &(wrq
->u
.param
), NULL
);
1980 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCSIWGENIE \n");
1981 rc
= iwctl_siwgenie(dev
, NULL
, &(wrq
->u
.data
), wrq
->u
.data
.pointer
);
1985 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCGIWGENIE \n");
1986 rc
= iwctl_giwgenie(dev
, NULL
, &(wrq
->u
.data
), wrq
->u
.data
.pointer
);
1989 case SIOCSIWENCODEEXT
:
1991 char extra
[sizeof(struct iw_encode_ext
)+MAX_KEY_LEN
+1];
1992 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCSIWENCODEEXT \n");
1993 if(wrq
->u
.encoding
.pointer
){
1994 memset(extra
, 0, sizeof(struct iw_encode_ext
)+MAX_KEY_LEN
+1);
1995 if(wrq
->u
.encoding
.length
> (sizeof(struct iw_encode_ext
)+ MAX_KEY_LEN
)){
1999 if(copy_from_user(extra
, wrq
->u
.encoding
.pointer
,wrq
->u
.encoding
.length
)){
2003 }else if(wrq
->u
.encoding
.length
!= 0){
2007 rc
= iwctl_siwencodeext(dev
, NULL
, &(wrq
->u
.encoding
), extra
);
2011 case SIOCGIWENCODEEXT
:
2012 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCGIWENCODEEXT \n");
2013 rc
= iwctl_giwencodeext(dev
, NULL
, &(wrq
->u
.encoding
), NULL
);
2017 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
" SIOCSIWMLME \n");
2018 rc
= iwctl_siwmlme(dev
, NULL
, &(wrq
->u
.data
), wrq
->u
.data
.pointer
);
2021 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2022 //End Add -- //2008-0409-07, <Add> by Einsn Liu
2024 case IOCTL_CMD_TEST
:
2026 if (!(pDevice
->flags
& DEVICE_FLAGS_OPENED
)) {
2032 pReq
= (PSCmdRequest
)rq
;
2034 //20080130-01,<Remark> by Mike Liu
2035 // if(pDevice->bLinkPass==TRUE)
2036 pReq
->wResult
= MAGIC_CODE
; //Linking status:0x3142
2037 //20080130-02,<Remark> by Mike Liu
2039 // pReq->wResult = MAGIC_CODE+1; //disconnect status:0x3143
2043 if (!(pDevice
->flags
& DEVICE_FLAGS_OPENED
) &&
2044 (((PSCmdRequest
)rq
)->wCmdCode
!=WLAN_CMD_SET_WPA
))
2052 if (test_and_set_bit( 0, (void*)&(pMgmt
->uCmdBusy
))) {
2055 rc
= private_ioctl(pDevice
, rq
);
2056 clear_bit( 0, (void*)&(pMgmt
->uCmdBusy
));
2059 case IOCTL_CMD_HOSTAPD
:
2061 if (!(pDevice
->flags
& DEVICE_FLAGS_OPENED
)) {
2068 rc
= hostap_ioctl(pDevice
, &wrq
->u
.data
);
2073 if (!(pDevice
->flags
& DEVICE_FLAGS_OPENED
)) {
2080 rc
= wpa_ioctl(pDevice
, &wrq
->u
.data
);
2084 return ethtool_ioctl(dev
, (void *) rq
->ifr_data
);
2085 // All other calls are currently unsupported
2089 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Ioctl command not support..%x\n", cmd
);
2094 if (pDevice
->bCommit
) {
2095 if (pMgmt
->eConfigMode
== WMAC_CONFIG_AP
) {
2096 netif_stop_queue(pDevice
->dev
);
2097 spin_lock_irq(&pDevice
->lock
);
2098 bScheduleCommand((HANDLE
)pDevice
, WLAN_CMD_RUN_AP
, NULL
);
2099 spin_unlock_irq(&pDevice
->lock
);
2102 DBG_PRT(MSG_LEVEL_DEBUG
, KERN_INFO
"Commit the settings\n");
2103 spin_lock_irq(&pDevice
->lock
);
2104 //2007-1121-01<Modify>by EinsnLiu
2105 if (pDevice
->bLinkPass
&&
2106 memcmp(pMgmt
->abyCurrSSID
,pMgmt
->abyDesireSSID
,WLAN_IEHDR_LEN
+ WLAN_SSID_MAXLEN
)) {
2107 bScheduleCommand((HANDLE
)pDevice
, WLAN_CMD_DISASSOCIATE
, NULL
);
2109 pDevice
->bLinkPass
= FALSE
;
2110 pMgmt
->eCurrState
= WMAC_STATE_IDLE
;
2111 memset(pMgmt
->abyCurrBSSID
, 0, 6);
2113 ControlvMaskByte(pDevice
,MESSAGE_REQUEST_MACREG
,MAC_REG_PAPEDELAY
,LEDSTS_STS
,LEDSTS_SLOW
);
2115 netif_stop_queue(pDevice
->dev
);
2116 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2117 pMgmt
->eScanType
= WMAC_SCAN_ACTIVE
;
2118 if(pDevice
->bWPASuppWextEnabled
!=TRUE
)
2120 bScheduleCommand((HANDLE
) pDevice
, WLAN_CMD_BSSID_SCAN
, pMgmt
->abyDesireSSID
);
2121 bScheduleCommand((HANDLE
) pDevice
, WLAN_CMD_SSID
, NULL
);
2122 spin_unlock_irq(&pDevice
->lock
);
2124 pDevice
->bCommit
= FALSE
;
2132 static int ethtool_ioctl(struct net_device
*dev
, void *useraddr
)
2136 if (copy_from_user(ðcmd
, useraddr
, sizeof(ethcmd
)))
2140 case ETHTOOL_GDRVINFO
: {
2141 struct ethtool_drvinfo info
= {ETHTOOL_GDRVINFO
};
2142 strncpy(info
.driver
, DEVICE_NAME
, sizeof(info
.driver
)-1);
2143 strncpy(info
.version
, DEVICE_VERSION
, sizeof(info
.version
)-1);
2144 if (copy_to_user(useraddr
, &info
, sizeof(info
)))
2155 /*------------------------------------------------------------------*/
2158 MODULE_DEVICE_TABLE(usb
, vntwusb_table
);
2161 static struct usb_driver vntwusb_driver
= {
2162 .name
= DEVICE_NAME
,
2163 .probe
= vntwusb_found1
,
2164 .disconnect
= vntwusb_disconnect
,
2165 .id_table
= vntwusb_table
,
2167 //2008-0920-01<Add>by MikeLiu
2168 //for supporting S3 & S4 function
2170 .suspend
= vntwusb_suspend
,
2171 .resume
= vntwusb_resume
,
2175 static int __init
vntwusb_init_module(void)
2177 printk(KERN_NOTICE DEVICE_FULL_DRV_NAM
" " DEVICE_VERSION
);
2178 return usb_register(&vntwusb_driver
);
2181 static void __exit
vntwusb_cleanup_module(void)
2183 usb_deregister(&vntwusb_driver
);
2186 module_init(vntwusb_init_module
);
2187 module_exit(vntwusb_cleanup_module
);