1 /*
2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
3 * All rights reserved.
4 *
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.
9 *
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.
14 *
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.
18 *
19 * File: main_usb.c
20 *
21 * Purpose: driver entry for initial, open, close, tx and rx.
22 *
23 * Author: Lyndon Chen
24 *
25 * Date: Dec 8, 2005
26 *
27 * Functions:
28 *
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
44 *
45 * Revision History:
46 */
47 #undef __NO_VERSION__
48
49 #include "device.h"
50 #include "card.h"
51 #include "baseband.h"
52 #include "mac.h"
53 #include "tether.h"
54 #include "wmgr.h"
55 #include "wctl.h"
56 #include "power.h"
57 #include "wcmd.h"
58 #include "iocmd.h"
59 #include "tcrc.h"
60 #include "rxtx.h"
61 #include "bssdb.h"
62 #include "hostap.h"
63 #include "wpactl.h"
64 #include "ioctl.h"
65 #include "iwctl.h"
66 #include "dpc.h"
67 #include "datarate.h"
68 #include "rf.h"
69 #include "firmware.h"
70 #include "rndis.h"
71 #include "control.h"
72 #include "channel.h"
73 #include "int.h"
74 #include "iowpa.h"
75
76 /*--------------------- Static Definitions -------------------------*/
77 //static int msglevel =MSG_LEVEL_DEBUG;
78 static int msglevel =MSG_LEVEL_INFO;
79
80 //
81 // Define module options
82 //
83
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);
89
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);
94
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");
99
100
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");
105
106
107 #define CHANNEL_MIN 1
108 #define CHANNEL_MAX 14
109 #define CHANNEL_DEF 6
110
111 DEVICE_PARAM(Channel, "Channel number");
112
113
114 /* PreambleType[] is the preamble length used for transmit.
115 0: indicate allows long preamble type
116 1: indicate allows short preamble type
117 */
118
119 #define PREAMBLE_TYPE_DEF 1
120
121 DEVICE_PARAM(PreambleType, "Preamble Type");
122
123
124 #define RTS_THRESH_MIN 512
125 #define RTS_THRESH_MAX 2347
126 #define RTS_THRESH_DEF 2347
127
128 DEVICE_PARAM(RTSThreshold, "RTS threshold");
129
130
131 #define FRAG_THRESH_MIN 256
132 #define FRAG_THRESH_MAX 2346
133 #define FRAG_THRESH_DEF 2346
134
135 DEVICE_PARAM(FragThreshold, "Fragmentation threshold");
136
137
138 #define DATA_RATE_MIN 0
139 #define DATA_RATE_MAX 13
140 #define DATA_RATE_DEF 13
141 /* datarate[] index
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
156 */
157
158 DEVICE_PARAM(ConnectionRate, "Connection data rate");
159
160 #define OP_MODE_MAX 2
161 #define OP_MODE_DEF 0
162 #define OP_MODE_MIN 0
163
164 DEVICE_PARAM(OPMode, "Infrastruct, adhoc, AP mode ");
165
166 /* OpMode[] is used for transmit.
167 0: indicate infrastruct mode used
168 1: indicate adhoc mode used
169 2: indicate AP mode used
170 */
171
172
173 /* PSMode[]
174 0: indicate disable power saving mode
175 1: indicate enable power saving mode
176 */
177
178 #define PS_MODE_DEF 0
179
180 DEVICE_PARAM(PSMode, "Power saving mode");
181
182
183 #define SHORT_RETRY_MIN 0
184 #define SHORT_RETRY_MAX 31
185 #define SHORT_RETRY_DEF 8
186
187
188 DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits");
189
190 #define LONG_RETRY_MIN 0
191 #define LONG_RETRY_MAX 15
192 #define LONG_RETRY_DEF 4
193
194
195 DEVICE_PARAM(LongRetryLimit, "long frame retry limits");
196
197
198 /* BasebandType[] baseband type selected
199 0: indicate 802.11a type
200 1: indicate 802.11b type
201 2: indicate 802.11g type
202 */
203 #define BBP_TYPE_MIN 0
204 #define BBP_TYPE_MAX 2
205 #define BBP_TYPE_DEF 2
206
207 DEVICE_PARAM(BasebandType, "baseband type");
208
209
210
211 /* 80211hEnable[]
212 0: indicate disable 802.11h
213 1: indicate enable 802.11h
214 */
215
216 #define X80211h_MODE_DEF 0
217
218 DEVICE_PARAM(b80211hEnable, "802.11h mode");
219
220
221 //
222 // Static vars definitions
223 //
224
225 static struct usb_device_id vt6656_table[] = {
226 {USB_DEVICE(VNT_USB_VENDOR_ID, VNT_USB_PRODUCT_ID)},
227 {}
228 };
229
230 // Frequency list (map channels to frequencies)
231 /*
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
238 };
239
240
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)
244 #endif
245
246 static const struct iw_handler_def iwctl_handler_def;
247 */
248
249 /*--------------------- Static Functions --------------------------*/
250
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);
254
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 */
259
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);
266
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);
271
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);
278
279 static int Read_config_file(PSDevice pDevice);
280 static unsigned char *Config_FileOperation(PSDevice pDevice);
281 static int Config_FileGetParameter(unsigned char *string,
282 unsigned char *dest,
283 unsigned char *source);
284
285 static BOOL device_release_WPADEV(PSDevice pDevice);
286
287 static void usb_device_reset(PSDevice pDevice);
288
289
290
291 /*--------------------- Export Variables --------------------------*/
292
293 /*--------------------- Export Functions --------------------------*/
294
295
296 static void
device_set_options(PSDevice pDevice)297 device_set_options(PSDevice pDevice) {
298
299 BYTE abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
300 BYTE abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
301 u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
302
303 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
304 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
305 memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, ETH_ALEN);
306
307 pDevice->cbTD = TX_DESC_DEF0;
308 pDevice->cbRD = RX_DESC_DEF0;
309 pDevice->uChannel = CHANNEL_DEF;
310 pDevice->wRTSThreshold = RTS_THRESH_DEF;
311 pDevice->wFragmentationThreshold = FRAG_THRESH_DEF;
312 pDevice->byShortRetryLimit = SHORT_RETRY_DEF;
313 pDevice->byLongRetryLimit = LONG_RETRY_DEF;
314 pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
315 pDevice->byShortPreamble = PREAMBLE_TYPE_DEF;
316 pDevice->ePSMode = PS_MODE_DEF;
317 pDevice->b11hEnable = X80211h_MODE_DEF;
318 pDevice->eOPMode = OP_MODE_DEF;
319 pDevice->uConnectionRate = DATA_RATE_DEF;
320 if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = TRUE;
321 pDevice->byBBType = BBP_TYPE_DEF;
322 pDevice->byPacketType = pDevice->byBBType;
323 pDevice->byAutoFBCtrl = AUTO_FB_0;
324 pDevice->bUpdateBBVGA = TRUE;
325 pDevice->byFOETuning = 0;
326 pDevice->byAutoPwrTunning = 0;
327 pDevice->wCTSDuration = 0;
328 pDevice->byPreambleType = 0;
329 pDevice->bExistSWNetAddr = FALSE;
330 // pDevice->bDiversityRegCtlON = TRUE;
331 pDevice->bDiversityRegCtlON = FALSE;
332 }
333
334
device_init_diversity_timer(PSDevice pDevice)335 static void device_init_diversity_timer(PSDevice pDevice)
336 {
337 init_timer(&pDevice->TimerSQ3Tmax1);
338 pDevice->TimerSQ3Tmax1.data = (unsigned long)pDevice;
339 pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
340 pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
341
342 init_timer(&pDevice->TimerSQ3Tmax2);
343 pDevice->TimerSQ3Tmax2.data = (unsigned long)pDevice;
344 pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
345 pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
346
347 init_timer(&pDevice->TimerSQ3Tmax3);
348 pDevice->TimerSQ3Tmax3.data = (unsigned long)pDevice;
349 pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerSQ3Tmax3CallBack;
350 pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
351
352 return;
353 }
354
355
356 //
357 // Initialiation of MAC & BBP registers
358 //
359
device_init_registers(PSDevice pDevice,DEVICE_INIT_TYPE InitType)360 static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType)
361 {
362 u8 abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
363 u8 abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
364 u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
365 BYTE byAntenna;
366 unsigned int ii;
367 CMD_CARD_INIT sInitCmd;
368 int ntStatus = STATUS_SUCCESS;
369 RSP_CARD_INIT sInitRsp;
370 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
371 BYTE byTmp;
372 BYTE byCalibTXIQ = 0;
373 BYTE byCalibTXDC = 0;
374 BYTE byCalibRXIQ = 0;
375
376 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---->INIbInitAdapter. [%d][%d]\n", InitType, pDevice->byPacketType);
377 spin_lock_irq(&pDevice->lock);
378 if (InitType == DEVICE_INIT_COLD) {
379 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
380 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
381 memcpy(pDevice->abySNAP_Bridgetunnel,
382 abySNAP_Bridgetunnel,
383 ETH_ALEN);
384
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);
390 return FALSE;
391 }
392 } else {
393
394 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbDownload fail \n");
395 spin_unlock_irq(&pDevice->lock);
396 return FALSE;
397 }
398 }
399
400 if ( !BBbVT3184Init(pDevice) ) {
401 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" BBbVT3184Init fail \n");
402 spin_unlock_irq(&pDevice->lock);
403 return FALSE;
404 }
405 }
406
407 sInitCmd.byInitClass = (BYTE)InitType;
408 sInitCmd.bExistSWNetAddr = (BYTE) pDevice->bExistSWNetAddr;
409 for (ii = 0; ii < 6; ii++)
410 sInitCmd.bySWNetAddr[ii] = pDevice->abyCurrentNetAddr[ii];
411 sInitCmd.byShortRetryLimit = pDevice->byShortRetryLimit;
412 sInitCmd.byLongRetryLimit = pDevice->byLongRetryLimit;
413
414 //issue Card_init command to device
415 ntStatus = CONTROLnsRequestOut(pDevice,
416 MESSAGE_TYPE_CARDINIT,
417 0,
418 0,
419 sizeof(CMD_CARD_INIT),
420 (PBYTE) &(sInitCmd));
421
422 if ( ntStatus != STATUS_SUCCESS ) {
423 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Issue Card init fail \n");
424 spin_unlock_irq(&pDevice->lock);
425 return FALSE;
426 }
427 if (InitType == DEVICE_INIT_COLD) {
428
429 ntStatus = CONTROLnsRequestIn(pDevice,MESSAGE_TYPE_INIT_RSP,0,0,sizeof(RSP_CARD_INIT), (PBYTE) &(sInitRsp));
430
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);
434 return FALSE;
435 }
436
437 //Local ID for AES functions
438 ntStatus = CONTROLnsRequestIn(pDevice,
439 MESSAGE_TYPE_READ,
440 MAC_REG_LOCALID,
441 MESSAGE_REQUEST_MACREG,
442 1,
443 &pDevice->byLocalID);
444
445 if ( ntStatus != STATUS_SUCCESS ) {
446 spin_unlock_irq(&pDevice->lock);
447 return FALSE;
448 }
449
450 // Do MACbSoftwareReset in MACvInitialize
451 // force CCK
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;
458 } else {
459 if ( pDevice->byBBType == BB_TYPE_11B )
460 pDevice->wCurrentRate = RATE_11M;
461 else
462 pDevice->wCurrentRate = RATE_54M;
463 }
464
465 CHvInitChannelTable(pDevice);
466
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;
471
472 pDevice->byCCKPwr = pDevice->abyEEPROM[EEP_OFS_PWR_CCK];
473 pDevice->byOFDMPwrG = pDevice->abyEEPROM[EEP_OFS_PWR_OFDMG];
474 // Load power Table
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;
482 }
483
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];
492 }
493 }
494
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;
502 }
503 //}} RobertYu
504
505 byAntenna = pDevice->abyEEPROM[EEP_OFS_ANTENNA];
506 if (byAntenna & EEP_ANTINV)
507 pDevice->bTxRxAntInv = TRUE;
508 else
509 pDevice->bTxRxAntInv = FALSE;
510
511 byAntenna &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
512
513 if (byAntenna == 0) // if not set default is All
514 byAntenna = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
515
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;
523 else
524 pDevice->byRxAntennaMode = ANT_B;
525
526 if (pDevice->bDiversityRegCtlON)
527 pDevice->bDiversityEnable = TRUE;
528 else
529 pDevice->bDiversityEnable = FALSE;
530 } else {
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;
539 else
540 pDevice->byRxAntennaMode = ANT_A;
541 } else {
542 pDevice->byTxAntennaMode = ANT_B;
543 if (pDevice->bTxRxAntInv == TRUE)
544 pDevice->byRxAntennaMode = ANT_A;
545 else
546 pDevice->byRxAntennaMode = ANT_B;
547 }
548 }
549 pDevice->ulDiversityNValue = 100*255;
550 pDevice->ulDiversityMValue = 100*16;
551 pDevice->byTMax = 1;
552 pDevice->byTMax2 = 4;
553 pDevice->ulSQ3TH = 0;
554 pDevice->byTMax3 = 64;
555 // -----------------------------------------------------------------
556
557 //Get Auto Fall Back Type
558 pDevice->byAutoFBCtrl = AUTO_FB_0;
559
560 // Set SCAN Time
561 pDevice->uScanTime = WLAN_SCAN_MINITIME;
562
563 // default Auto Mode
564 //pDevice->NetworkType = Ndis802_11Automode;
565 pDevice->eConfigPHYMode = PHY_TYPE_AUTO;
566 pDevice->byBBType = BB_TYPE_11G;
567
568 // initialize BBP registers
569 pDevice->ulTxPower = 25;
570
571 // Get Channel range
572 pDevice->byMinChannel = 1;
573 pDevice->byMaxChannel = CB_MAX_CHANNEL;
574
575 // Get RFType
576 pDevice->byRFType = sInitRsp.byRFType;
577
578 if ((pDevice->byRFType & RF_EMU) != 0) {
579 // force change RevID for VT3253 emu
580 pDevice->byRevId = 0x80;
581 }
582
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
595 } else {
596 // turn off BB Calibration compensation
597 ControlvWriteByte(pDevice, MESSAGE_REQUEST_BBREG, 0xFF, 0x0); // CR255
598 }
599 }
600 }
601 pMgmt->eScanType = WMAC_SCAN_PASSIVE;
602 pMgmt->uCurrChannel = pDevice->uChannel;
603 pMgmt->uIBSSChannel = pDevice->uChannel;
604 CARDbSetMediaChannel(pDevice, pMgmt->uCurrChannel);
605
606 // get Permanent network address
607 memcpy(pDevice->abyPermanentNetAddr,&(sInitRsp.byNetAddr[0]),6);
608 memcpy(pDevice->abyCurrentNetAddr,
609 pDevice->abyPermanentNetAddr,
610 ETH_ALEN);
611
612 // if exist SW network address, use SW network address.
613
614 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %pM\n",
615 pDevice->abyCurrentNetAddr);
616 }
617
618 // Set BB and packet type at the same time.
619 // Set Short Slot Time, xIFS, and RSPINF.
620 if (pDevice->byBBType == BB_TYPE_11A) {
621 CARDbAddBasicRate(pDevice, RATE_6M);
622 pDevice->bShortSlotTime = TRUE;
623 } else {
624 CARDbAddBasicRate(pDevice, RATE_1M);
625 pDevice->bShortSlotTime = FALSE;
626 }
627 BBvSetShortSlotTime(pDevice);
628 CARDvSetBSSMode(pDevice);
629
630 if (pDevice->bUpdateBBVGA) {
631 pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
632 pDevice->byBBVGANew = pDevice->byBBVGACurrent;
633 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
634 }
635
636 pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];
637 pDevice->bHWRadioOff = FALSE;
638 if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) {
639 ntStatus = CONTROLnsRequestIn(pDevice,
640 MESSAGE_TYPE_READ,
641 MAC_REG_GPIOCTL1,
642 MESSAGE_REQUEST_MACREG,
643 1,
644 &byTmp);
645
646 if ( ntStatus != STATUS_SUCCESS ) {
647 spin_unlock_irq(&pDevice->lock);
648 return FALSE;
649 }
650 if ( (byTmp & GPIO3_DATA) == 0 ) {
651 pDevice->bHWRadioOff = TRUE;
652 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
653 } else {
654 MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
655 pDevice->bHWRadioOff = FALSE;
656 }
657
658 } //EEP_RADIOCTL_ENABLE
659
660 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
661 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
662 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01);
663
664 if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) {
665 CARDbRadioPowerOff(pDevice);
666 } else {
667 CARDbRadioPowerOn(pDevice);
668 }
669
670 spin_unlock_irq(&pDevice->lock);
671 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");
672 return TRUE;
673 }
674
device_release_WPADEV(PSDevice pDevice)675 static BOOL device_release_WPADEV(PSDevice pDevice)
676 {
677 viawget_wpa_header *wpahdr;
678 int ii=0;
679 // wait_queue_head_t Set_wait;
680 //send device close to wpa_supplicnat layer
681 if (pDevice->bWPADEVUp==TRUE) {
682 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
683 wpahdr->type = VIAWGET_DEVICECLOSE_MSG;
684 wpahdr->resp_ie_len = 0;
685 wpahdr->req_ie_len = 0;
686 skb_put(pDevice->skb, sizeof(viawget_wpa_header));
687 pDevice->skb->dev = pDevice->wpadev;
688 skb_reset_mac_header(pDevice->skb);
689 pDevice->skb->pkt_type = PACKET_HOST;
690 pDevice->skb->protocol = htons(ETH_P_802_2);
691 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
692 netif_rx(pDevice->skb);
693 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
694
695 //wait release WPADEV
696 // init_waitqueue_head(&Set_wait);
697 // wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ); //1s wait
698 while(pDevice->bWPADEVUp==TRUE) {
699 set_current_state(TASK_UNINTERRUPTIBLE);
700 schedule_timeout (HZ/20); //wait 50ms
701 ii++;
702 if(ii>20)
703 break;
704 }
705 }
706 return TRUE;
707 }
708
709 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
710
vt6656_suspend(struct usb_interface * intf,pm_message_t message)711 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message)
712 {
713 PSDevice device = usb_get_intfdata(intf);
714
715 if (!device || !device->dev)
716 return -ENODEV;
717
718 if (device->flags & DEVICE_FLAGS_OPENED)
719 device_close(device->dev);
720
721 return 0;
722 }
723
vt6656_resume(struct usb_interface * intf)724 static int vt6656_resume(struct usb_interface *intf)
725 {
726 PSDevice device = usb_get_intfdata(intf);
727
728 if (!device || !device->dev)
729 return -ENODEV;
730
731 if (!(device->flags & DEVICE_FLAGS_OPENED))
732 device_open(device->dev);
733
734 return 0;
735 }
736
737 #endif /* CONFIG_PM */
738
739 static const struct net_device_ops device_netdev_ops = {
740 .ndo_open = device_open,
741 .ndo_stop = device_close,
742 .ndo_do_ioctl = device_ioctl,
743 .ndo_get_stats = device_get_stats,
744 .ndo_start_xmit = device_xmit,
745 .ndo_set_rx_mode = device_set_multi,
746 };
747
748 static int __devinit
vt6656_probe(struct usb_interface * intf,const struct usb_device_id * id)749 vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
750 {
751 u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
752 struct usb_device *udev = interface_to_usbdev(intf);
753 int rc = 0;
754 struct net_device *netdev = NULL;
755 PSDevice pDevice = NULL;
756
757 printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
758 printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
759
760 udev = usb_get_dev(udev);
761 netdev = alloc_etherdev(sizeof(DEVICE_INFO));
762 if (!netdev) {
763 printk(KERN_ERR DEVICE_NAME ": allocate net device failed\n");
764 rc = -ENOMEM;
765 goto err_nomem;
766 }
767
768 pDevice = netdev_priv(netdev);
769 memset(pDevice, 0, sizeof(DEVICE_INFO));
770
771 pDevice->dev = netdev;
772 pDevice->usb = udev;
773
774 device_set_options(pDevice);
775 spin_lock_init(&pDevice->lock);
776
777 pDevice->tx_80211 = device_dma0_tx_80211;
778 pDevice->sMgmtObj.pAdapter = (void *) pDevice;
779
780 netdev->netdev_ops = &device_netdev_ops;
781 netdev->wireless_handlers =
782 (struct iw_handler_def *) &iwctl_handler_def;
783
784 usb_set_intfdata(intf, pDevice);
785 SET_NETDEV_DEV(netdev, &intf->dev);
786 memcpy(pDevice->dev->dev_addr, fake_mac, ETH_ALEN);
787 rc = register_netdev(netdev);
788 if (rc) {
789 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
790 goto err_netdev;
791 }
792
793 usb_device_reset(pDevice);
794
795 {
796 union iwreq_data wrqu;
797 memset(&wrqu, 0, sizeof(wrqu));
798 wrqu.data.flags = RT_INSMOD_EVENT_FLAG;
799 wrqu.data.length = IFNAMSIZ;
800 wireless_send_event(pDevice->dev,
801 IWEVCUSTOM,
802 &wrqu,
803 pDevice->dev->name);
804 }
805
806 return 0;
807
808 err_netdev:
809 free_netdev(netdev);
810 err_nomem:
811 usb_put_dev(udev);
812
813 return rc;
814 }
815
device_free_tx_bufs(PSDevice pDevice)816 static void device_free_tx_bufs(PSDevice pDevice)
817 {
818 PUSB_SEND_CONTEXT pTxContext;
819 int ii;
820
821 for (ii = 0; ii < pDevice->cbTD; ii++) {
822
823 pTxContext = pDevice->apTD[ii];
824 //de-allocate URBs
825 if (pTxContext->pUrb) {
826 usb_kill_urb(pTxContext->pUrb);
827 usb_free_urb(pTxContext->pUrb);
828 }
829 kfree(pTxContext);
830 }
831 return;
832 }
833
834
device_free_rx_bufs(PSDevice pDevice)835 static void device_free_rx_bufs(PSDevice pDevice)
836 {
837 PRCB pRCB;
838 int ii;
839
840 for (ii = 0; ii < pDevice->cbRD; ii++) {
841
842 pRCB = pDevice->apRCB[ii];
843 //de-allocate URBs
844 if (pRCB->pUrb) {
845 usb_kill_urb(pRCB->pUrb);
846 usb_free_urb(pRCB->pUrb);
847 }
848 //de-allocate skb
849 if (pRCB->skb)
850 dev_kfree_skb(pRCB->skb);
851 }
852 kfree(pDevice->pRCBMem);
853
854 return;
855 }
856
usb_device_reset(PSDevice pDevice)857 static void usb_device_reset(PSDevice pDevice)
858 {
859 int status;
860 status = usb_reset_device(pDevice->usb);
861 if (status)
862 printk("usb_device_reset fail status=%d\n",status);
863 return ;
864 }
865
device_free_int_bufs(PSDevice pDevice)866 static void device_free_int_bufs(PSDevice pDevice)
867 {
868 kfree(pDevice->intBuf.pDataBuf);
869 return;
870 }
871
872
device_alloc_bufs(PSDevice pDevice)873 static BOOL device_alloc_bufs(PSDevice pDevice) {
874
875 PUSB_SEND_CONTEXT pTxContext;
876 PRCB pRCB;
877 int ii;
878
879
880 for (ii = 0; ii < pDevice->cbTD; ii++) {
881
882 pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
883 if (pTxContext == NULL) {
884 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
885 goto free_tx;
886 }
887 pDevice->apTD[ii] = pTxContext;
888 pTxContext->pDevice = (void *) pDevice;
889 //allocate URBs
890 pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
891 if (pTxContext->pUrb == NULL) {
892 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
893 goto free_tx;
894 }
895 pTxContext->bBoolInUse = FALSE;
896 }
897
898 // allocate rcb mem
899 pDevice->pRCBMem = kzalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
900 if (pDevice->pRCBMem == NULL) {
901 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
902 goto free_tx;
903 }
904
905
906 pDevice->FirstRecvFreeList = NULL;
907 pDevice->LastRecvFreeList = NULL;
908 pDevice->FirstRecvMngList = NULL;
909 pDevice->LastRecvMngList = NULL;
910 pDevice->NumRecvFreeList = 0;
911 pRCB = (PRCB) pDevice->pRCBMem;
912
913 for (ii = 0; ii < pDevice->cbRD; ii++) {
914
915 pDevice->apRCB[ii] = pRCB;
916 pRCB->pDevice = (void *) pDevice;
917 //allocate URBs
918 pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
919
920 if (pRCB->pUrb == NULL) {
921 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
922 goto free_rx_tx;
923 }
924 pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
925 if (pRCB->skb == NULL) {
926 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
927 goto free_rx_tx;
928 }
929 pRCB->skb->dev = pDevice->dev;
930 pRCB->bBoolInUse = FALSE;
931 EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
932 pDevice->NumRecvFreeList++;
933 pRCB++;
934 }
935
936
937 pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
938 if (pDevice->pControlURB == NULL) {
939 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
940 goto free_rx_tx;
941 }
942
943 pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
944 if (pDevice->pInterruptURB == NULL) {
945 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
946 usb_free_urb(pDevice->pControlURB);
947 goto free_rx_tx;
948 }
949
950 pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
951 if (pDevice->intBuf.pDataBuf == NULL) {
952 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
953 usb_free_urb(pDevice->pControlURB);
954 usb_free_urb(pDevice->pInterruptURB);
955 goto free_rx_tx;
956 }
957
958 return TRUE;
959
960 free_rx_tx:
961 device_free_rx_bufs(pDevice);
962
963 free_tx:
964 device_free_tx_bufs(pDevice);
965
966 return FALSE;
967 }
968
969
970
971
device_init_defrag_cb(PSDevice pDevice)972 static BOOL device_init_defrag_cb(PSDevice pDevice) {
973 int i;
974 PSDeFragControlBlock pDeF;
975
976 /* Init the fragment ctl entries */
977 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
978 pDeF = &(pDevice->sRxDFCB[i]);
979 if (!device_alloc_frag_buf(pDevice, pDeF)) {
980 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
981 pDevice->dev->name);
982 goto free_frag;
983 }
984 }
985 pDevice->cbDFCB = CB_MAX_RX_FRAG;
986 pDevice->cbFreeDFCB = pDevice->cbDFCB;
987 return TRUE;
988
989 free_frag:
990 device_free_frag_bufs(pDevice);
991 return FALSE;
992 }
993
994
995
device_free_frag_bufs(PSDevice pDevice)996 static void device_free_frag_bufs(PSDevice pDevice) {
997 PSDeFragControlBlock pDeF;
998 int i;
999
1000 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1001
1002 pDeF = &(pDevice->sRxDFCB[i]);
1003
1004 if (pDeF->skb)
1005 dev_kfree_skb(pDeF->skb);
1006 }
1007 }
1008
1009
1010
device_alloc_frag_buf(PSDevice pDevice,PSDeFragControlBlock pDeF)1011 BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1012
1013 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1014 if (pDeF->skb == NULL)
1015 return FALSE;
1016 ASSERT(pDeF->skb);
1017 pDeF->skb->dev = pDevice->dev;
1018
1019 return TRUE;
1020 }
1021
1022
1023 /*-----------------------------------------------------------------*/
1024
device_open(struct net_device * dev)1025 static int device_open(struct net_device *dev) {
1026 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1027
1028 extern SWPAResult wpa_Result;
1029 memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1030 wpa_Result.proto = 0;
1031 wpa_Result.key_mgmt = 0;
1032 wpa_Result.eap_type = 0;
1033 wpa_Result.authenticated = FALSE;
1034 pDevice->fWPA_Authened = FALSE;
1035
1036 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
1037
1038
1039 pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
1040
1041 if (device_alloc_bufs(pDevice) == FALSE) {
1042 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
1043 return -ENOMEM;
1044 }
1045
1046 if (device_init_defrag_cb(pDevice)== FALSE) {
1047 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragement cb fail \n");
1048 goto free_rx_tx;
1049 }
1050
1051 MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
1052 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
1053 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
1054 MP_SET_FLAG(pDevice, fMP_POST_READS);
1055 MP_SET_FLAG(pDevice, fMP_POST_WRITES);
1056
1057 //read config file
1058 Read_config_file(pDevice);
1059
1060 if (device_init_registers(pDevice, DEVICE_INIT_COLD) == FALSE) {
1061 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
1062 goto free_all;
1063 }
1064
1065 device_set_multi(pDevice->dev);
1066 // Init for Key Management
1067
1068 KeyvInitTable(pDevice,&pDevice->sKey);
1069 memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1070 memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1071 pDevice->bStopTx0Pkt = FALSE;
1072 pDevice->bStopDataPkt = FALSE;
1073 pDevice->bRoaming = FALSE;
1074 pDevice->bIsRoaming = FALSE;
1075 pDevice->bEnableRoaming = FALSE;
1076 if (pDevice->bDiversityRegCtlON) {
1077 device_init_diversity_timer(pDevice);
1078 }
1079
1080 vMgrObjectInit(pDevice);
1081 tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
1082 tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
1083 tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
1084 add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback));
1085 pDevice->int_interval = 100; //Max 100 microframes.
1086 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1087
1088 pDevice->bIsRxWorkItemQueued = TRUE;
1089 pDevice->fKillEventPollingThread = FALSE;
1090 pDevice->bEventAvailable = FALSE;
1091
1092 pDevice->bWPADEVUp = FALSE;
1093 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1094 pDevice->bwextstep0 = FALSE;
1095 pDevice->bwextstep1 = FALSE;
1096 pDevice->bwextstep2 = FALSE;
1097 pDevice->bwextstep3 = FALSE;
1098 pDevice->bWPASuppWextEnabled = FALSE;
1099 #endif
1100 pDevice->byReAssocCount = 0;
1101
1102 RXvWorkItem(pDevice);
1103 INTvWorkItem(pDevice);
1104
1105 // Patch: if WEP key already set by iwconfig but device not yet open
1106 if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1107 spin_lock_irq(&pDevice->lock);
1108 KeybSetDefaultKey( pDevice,
1109 &(pDevice->sKey),
1110 pDevice->byKeyIndex | (1 << 31),
1111 pDevice->uKeyLength,
1112 NULL,
1113 pDevice->abyKey,
1114 KEY_CTL_WEP
1115 );
1116 spin_unlock_irq(&pDevice->lock);
1117 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1118 }
1119
1120 if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1121 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1122 }
1123 else {
1124 //mike:mark@2008-11-10
1125 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1126 /* bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL); */
1127 }
1128
1129
1130 netif_stop_queue(pDevice->dev);
1131 pDevice->flags |= DEVICE_FLAGS_OPENED;
1132
1133 {
1134 union iwreq_data wrqu;
1135 memset(&wrqu, 0, sizeof(wrqu));
1136 wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1137 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1138 }
1139
1140 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1141 return 0;
1142
1143 free_all:
1144 device_free_frag_bufs(pDevice);
1145 free_rx_tx:
1146 device_free_rx_bufs(pDevice);
1147 device_free_tx_bufs(pDevice);
1148 device_free_int_bufs(pDevice);
1149 usb_kill_urb(pDevice->pControlURB);
1150 usb_kill_urb(pDevice->pInterruptURB);
1151 usb_free_urb(pDevice->pControlURB);
1152 usb_free_urb(pDevice->pInterruptURB);
1153
1154 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1155 return -ENOMEM;
1156 }
1157
1158
1159
device_close(struct net_device * dev)1160 static int device_close(struct net_device *dev) {
1161 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1162 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1163
1164 int uu;
1165
1166 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1167 if (pDevice == NULL)
1168 return -ENODEV;
1169
1170 {
1171 union iwreq_data wrqu;
1172 memset(&wrqu, 0, sizeof(wrqu));
1173 wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1174 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1175 }
1176
1177 if (pDevice->bLinkPass) {
1178 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1179 mdelay(30);
1180 }
1181
1182 device_release_WPADEV(pDevice);
1183
1184 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1185 pMgmt->bShareKeyAlgorithm = FALSE;
1186 pDevice->bEncryptionEnable = FALSE;
1187 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1188 spin_lock_irq(&pDevice->lock);
1189 for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1190 MACvDisableKeyEntry(pDevice,uu);
1191 spin_unlock_irq(&pDevice->lock);
1192
1193 if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1194 MACbShutdown(pDevice);
1195 }
1196 netif_stop_queue(pDevice->dev);
1197 MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1198 MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1199 MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1200 pDevice->fKillEventPollingThread = TRUE;
1201 del_timer(&pDevice->sTimerCommand);
1202 del_timer(&pMgmt->sTimerSecondCallback);
1203
1204 del_timer(&pDevice->sTimerTxData);
1205
1206 if (pDevice->bDiversityRegCtlON) {
1207 del_timer(&pDevice->TimerSQ3Tmax1);
1208 del_timer(&pDevice->TimerSQ3Tmax2);
1209 del_timer(&pDevice->TimerSQ3Tmax3);
1210 }
1211 tasklet_kill(&pDevice->RxMngWorkItem);
1212 tasklet_kill(&pDevice->ReadWorkItem);
1213 tasklet_kill(&pDevice->EventWorkItem);
1214
1215 pDevice->bRoaming = FALSE;
1216 pDevice->bIsRoaming = FALSE;
1217 pDevice->bEnableRoaming = FALSE;
1218 pDevice->bCmdRunning = FALSE;
1219 pDevice->bLinkPass = FALSE;
1220 memset(pMgmt->abyCurrBSSID, 0, 6);
1221 pMgmt->eCurrState = WMAC_STATE_IDLE;
1222
1223 pDevice->flags &= ~DEVICE_FLAGS_OPENED;
1224
1225 device_free_tx_bufs(pDevice);
1226 device_free_rx_bufs(pDevice);
1227 device_free_int_bufs(pDevice);
1228 device_free_frag_bufs(pDevice);
1229
1230 usb_kill_urb(pDevice->pControlURB);
1231 usb_kill_urb(pDevice->pInterruptURB);
1232 usb_free_urb(pDevice->pControlURB);
1233 usb_free_urb(pDevice->pInterruptURB);
1234
1235 BSSvClearNodeDBTable(pDevice, 0);
1236
1237 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1238
1239 return 0;
1240 }
1241
vt6656_disconnect(struct usb_interface * intf)1242 static void __devexit vt6656_disconnect(struct usb_interface *intf)
1243 {
1244 PSDevice device = usb_get_intfdata(intf);
1245
1246 if (!device)
1247 return;
1248
1249 {
1250 union iwreq_data req;
1251 memset(&req, 0, sizeof(req));
1252 req.data.flags = RT_RMMOD_EVENT_FLAG;
1253 wireless_send_event(device->dev, IWEVCUSTOM, &req, NULL);
1254 }
1255
1256 device_release_WPADEV(device);
1257
1258 if (device->firmware)
1259 release_firmware(device->firmware);
1260
1261 usb_set_intfdata(intf, NULL);
1262 usb_put_dev(interface_to_usbdev(intf));
1263
1264 device->flags |= DEVICE_FLAGS_UNPLUG;
1265
1266 if (device->dev) {
1267 unregister_netdev(device->dev);
1268 wpa_set_wpadev(device, 0);
1269 free_netdev(device->dev);
1270 }
1271 }
1272
device_dma0_tx_80211(struct sk_buff * skb,struct net_device * dev)1273 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1274 {
1275 PSDevice pDevice = netdev_priv(dev);
1276
1277 spin_lock_irq(&pDevice->lock);
1278
1279 if (unlikely(pDevice->bStopTx0Pkt))
1280 dev_kfree_skb_irq(skb);
1281 else
1282 vDMA0_tx_80211(pDevice, skb);
1283
1284 spin_unlock_irq(&pDevice->lock);
1285
1286 return NETDEV_TX_OK;
1287 }
1288
device_xmit(struct sk_buff * skb,struct net_device * dev)1289 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1290 {
1291 PSDevice pDevice = netdev_priv(dev);
1292 struct net_device_stats *stats = &pDevice->stats;
1293
1294 spin_lock_irq(&pDevice->lock);
1295
1296 netif_stop_queue(dev);
1297
1298 if (!pDevice->bLinkPass) {
1299 dev_kfree_skb_irq(skb);
1300 goto out;
1301 }
1302
1303 if (pDevice->bStopDataPkt) {
1304 dev_kfree_skb_irq(skb);
1305 stats->tx_dropped++;
1306 goto out;
1307 }
1308
1309 if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1310 if (netif_queue_stopped(dev))
1311 netif_wake_queue(dev);
1312 }
1313
1314 out:
1315 spin_unlock_irq(&pDevice->lock);
1316
1317 return NETDEV_TX_OK;
1318 }
1319
1320 static unsigned const ethernet_polynomial = 0x04c11db7U;
ether_crc(int length,unsigned char * data)1321 static inline u32 ether_crc(int length, unsigned char *data)
1322 {
1323 int crc = -1;
1324
1325 while(--length >= 0) {
1326 unsigned char current_octet = *data++;
1327 int bit;
1328 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1329 crc = (crc << 1) ^
1330 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1331 }
1332 }
1333 return crc;
1334 }
1335
1336 //find out the start position of str2 from str1
kstrstr(const unsigned char * str1,const unsigned char * str2)1337 static unsigned char *kstrstr(const unsigned char *str1,
1338 const unsigned char *str2) {
1339 int str1_len = strlen(str1);
1340 int str2_len = strlen(str2);
1341
1342 while (str1_len >= str2_len) {
1343 str1_len--;
1344 if(memcmp(str1,str2,str2_len)==0)
1345 return (unsigned char *) str1;
1346 str1++;
1347 }
1348 return NULL;
1349 }
1350
Config_FileGetParameter(unsigned char * string,unsigned char * dest,unsigned char * source)1351 static int Config_FileGetParameter(unsigned char *string,
1352 unsigned char *dest,
1353 unsigned char *source)
1354 {
1355 unsigned char buf1[100];
1356 unsigned char buf2[100];
1357 unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1358 int ii;
1359
1360 memset(buf1,0,100);
1361 strcat(buf1, string);
1362 strcat(buf1, "=");
1363 source+=strlen(buf1);
1364
1365 //find target string start point
1366 start_p = kstrstr(source,buf1);
1367 if (start_p == NULL)
1368 return FALSE;
1369
1370 //check if current config line is marked by "#" ??
1371 for (ii = 1; ; ii++) {
1372 if (memcmp(start_p - ii, "\n", 1) == 0)
1373 break;
1374 if (memcmp(start_p - ii, "#", 1) == 0)
1375 return FALSE;
1376 }
1377
1378 //find target string end point
1379 end_p = kstrstr(start_p,"\n");
1380 if (end_p == NULL) { //can't find "\n",but don't care
1381 end_p=start_p+strlen(start_p); //no include "\n"
1382 }
1383
1384 memset(buf2,0,100);
1385 memcpy(buf2,start_p,end_p-start_p); //get the tartget line
1386 buf2[end_p-start_p]='\0';
1387
1388 //find value
1389 start_p = kstrstr(buf2,"=");
1390 if (start_p == NULL)
1391 return FALSE;
1392 memset(buf1,0,100);
1393 strcpy(buf1,start_p+1);
1394
1395 //except space
1396 tmp_p = buf1;
1397 while(*tmp_p != 0x00) {
1398 if(*tmp_p==' ')
1399 tmp_p++;
1400 else
1401 break;
1402 }
1403
1404 memcpy(dest,tmp_p,strlen(tmp_p));
1405 return TRUE;
1406 }
1407
1408 //if read fail,return NULL,or return data pointer;
Config_FileOperation(PSDevice pDevice)1409 static unsigned char *Config_FileOperation(PSDevice pDevice)
1410 {
1411 unsigned char *config_path = CONFIG_PATH;
1412 unsigned char *buffer = NULL;
1413 struct file *filp=NULL;
1414 mm_segment_t old_fs = get_fs();
1415 //int oldfsuid=0,oldfsgid=0;
1416 int result = 0;
1417
1418 set_fs (KERNEL_DS);
1419 /* Can't do this anymore, so we rely on correct filesystem permissions:
1420 //Make sure a caller can read or write power as root
1421 oldfsuid=current->fsuid;
1422 oldfsgid=current->fsgid;
1423 current->fsuid = 0;
1424 current->fsgid = 0;
1425 */
1426
1427 //open file
1428 filp = filp_open(config_path, O_RDWR, 0);
1429 if (IS_ERR(filp)) {
1430 printk("Config_FileOperation file Not exist\n");
1431 result=-1;
1432 goto error2;
1433 }
1434
1435 if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1436 printk("file %s cann't readable or writable?\n",config_path);
1437 result = -1;
1438 goto error1;
1439 }
1440
1441 buffer = kmalloc(1024, GFP_KERNEL);
1442 if(buffer==NULL) {
1443 printk("allocate mem for file fail?\n");
1444 result = -1;
1445 goto error1;
1446 }
1447
1448 if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1449 printk("read file error?\n");
1450 result = -1;
1451 }
1452
1453 error1:
1454 if(filp_close(filp,NULL))
1455 printk("Config_FileOperation:close file fail\n");
1456
1457 error2:
1458 set_fs (old_fs);
1459
1460 /*
1461 current->fsuid=oldfsuid;
1462 current->fsgid=oldfsgid;
1463 */
1464
1465 if(result!=0) {
1466 kfree(buffer);
1467 buffer=NULL;
1468 }
1469 return buffer;
1470 }
1471
1472 //return --->-1:fail; >=0:successful
Read_config_file(PSDevice pDevice)1473 static int Read_config_file(PSDevice pDevice) {
1474 int result = 0;
1475 unsigned char tmpbuffer[100];
1476 unsigned char *buffer = NULL;
1477
1478 //init config setting
1479 pDevice->config_file.ZoneType = -1;
1480 pDevice->config_file.eAuthenMode = -1;
1481 pDevice->config_file.eEncryptionStatus = -1;
1482
1483 buffer = Config_FileOperation(pDevice);
1484 if (buffer == NULL) {
1485 result =-1;
1486 return result;
1487 }
1488
1489 //get zonetype
1490 {
1491 memset(tmpbuffer,0,sizeof(tmpbuffer));
1492 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1493 if(memcmp(tmpbuffer,"USA",3)==0) {
1494 pDevice->config_file.ZoneType=ZoneType_USA;
1495 }
1496 else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1497 pDevice->config_file.ZoneType=ZoneType_Japan;
1498 }
1499 else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1500 pDevice->config_file.ZoneType=ZoneType_Europe;
1501 }
1502 else {
1503 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1504 }
1505 }
1506 }
1507
1508 //get other parameter
1509 {
1510 memset(tmpbuffer,0,sizeof(tmpbuffer));
1511 if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1512 pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1513 }
1514
1515 memset(tmpbuffer,0,sizeof(tmpbuffer));
1516 if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1517 pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1518 }
1519 }
1520
1521 kfree(buffer);
1522 return result;
1523 }
1524
device_set_multi(struct net_device * dev)1525 static void device_set_multi(struct net_device *dev) {
1526 PSDevice pDevice = (PSDevice) netdev_priv(dev);
1527 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1528 u32 mc_filter[2];
1529 int ii;
1530 struct netdev_hw_addr *ha;
1531 BYTE pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1532 BYTE byTmpMode = 0;
1533 int rc;
1534
1535
1536 spin_lock_irq(&pDevice->lock);
1537 rc = CONTROLnsRequestIn(pDevice,
1538 MESSAGE_TYPE_READ,
1539 MAC_REG_RCR,
1540 MESSAGE_REQUEST_MACREG,
1541 1,
1542 &byTmpMode
1543 );
1544 if (rc == 0) pDevice->byRxMode = byTmpMode;
1545
1546 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1547
1548 if (dev->flags & IFF_PROMISC) { // Set promiscuous.
1549 DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1550 // Unconditionally log net taps.
1551 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1552 }
1553 else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1554 (dev->flags & IFF_ALLMULTI)) {
1555 CONTROLnsRequestOut(pDevice,
1556 MESSAGE_TYPE_WRITE,
1557 MAC_REG_MAR0,
1558 MESSAGE_REQUEST_MACREG,
1559 8,
1560 pbyData
1561 );
1562 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1563 }
1564 else {
1565 memset(mc_filter, 0, sizeof(mc_filter));
1566 netdev_for_each_mc_addr(ha, dev) {
1567 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1568 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1569 }
1570 for (ii = 0; ii < 4; ii++) {
1571 MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1572 MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1573 }
1574 pDevice->byRxMode &= ~(RCR_UNICAST);
1575 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1576 }
1577
1578 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1579 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1580 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1581 pDevice->byRxMode &= ~(RCR_UNICAST);
1582 }
1583 ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1584 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1585 spin_unlock_irq(&pDevice->lock);
1586
1587 }
1588
1589
device_get_stats(struct net_device * dev)1590 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1591 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1592
1593 return &pDevice->stats;
1594 }
1595
1596
device_ioctl(struct net_device * dev,struct ifreq * rq,int cmd)1597 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1598 PSDevice pDevice = (PSDevice)netdev_priv(dev);
1599 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1600 PSCmdRequest pReq;
1601 //BOOL bCommit = FALSE;
1602 struct iwreq *wrq = (struct iwreq *) rq;
1603 int rc =0;
1604
1605 if (pMgmt == NULL) {
1606 rc = -EFAULT;
1607 return rc;
1608 }
1609
1610 switch(cmd) {
1611
1612 case SIOCGIWNAME:
1613 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1614 break;
1615
1616 case SIOCSIWNWID:
1617 case SIOCGIWNWID: //0x8b03 support
1618 rc = -EOPNOTSUPP;
1619 break;
1620
1621 // Set frequency/channel
1622 case SIOCSIWFREQ:
1623 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1624 break;
1625
1626 // Get frequency/channel
1627 case SIOCGIWFREQ:
1628 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1629 break;
1630
1631 // Set desired network name (ESSID)
1632 case SIOCSIWESSID:
1633
1634 {
1635 char essid[IW_ESSID_MAX_SIZE+1];
1636 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1637 rc = -E2BIG;
1638 break;
1639 }
1640 if (copy_from_user(essid, wrq->u.essid.pointer,
1641 wrq->u.essid.length)) {
1642 rc = -EFAULT;
1643 break;
1644 }
1645 rc = iwctl_siwessid(dev, NULL,
1646 &(wrq->u.essid), essid);
1647 }
1648 break;
1649
1650
1651 // Get current network name (ESSID)
1652 case SIOCGIWESSID:
1653
1654 {
1655 char essid[IW_ESSID_MAX_SIZE+1];
1656 if (wrq->u.essid.pointer) {
1657 iwctl_giwessid(dev, NULL,
1658 &(wrq->u.essid), essid);
1659 if (copy_to_user(wrq->u.essid.pointer,
1660 essid,
1661 wrq->u.essid.length) )
1662 rc = -EFAULT;
1663 }
1664 }
1665 break;
1666
1667 case SIOCSIWAP:
1668
1669 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1670 break;
1671
1672
1673 // Get current Access Point (BSSID)
1674 case SIOCGIWAP:
1675 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1676 break;
1677
1678
1679 // Set desired station name
1680 case SIOCSIWNICKN:
1681 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1682 rc = -EOPNOTSUPP;
1683 break;
1684
1685 // Get current station name
1686 case SIOCGIWNICKN:
1687 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1688 rc = -EOPNOTSUPP;
1689 break;
1690
1691 // Set the desired bit-rate
1692 case SIOCSIWRATE:
1693 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1694 break;
1695
1696 // Get the current bit-rate
1697 case SIOCGIWRATE:
1698 iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1699 break;
1700
1701 // Set the desired RTS threshold
1702 case SIOCSIWRTS:
1703
1704 rc = iwctl_siwrts(dev, &(wrq->u.rts));
1705 break;
1706
1707 // Get the current RTS threshold
1708 case SIOCGIWRTS:
1709
1710 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1711 break;
1712
1713 // Set the desired fragmentation threshold
1714 case SIOCSIWFRAG:
1715
1716 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1717 break;
1718
1719 // Get the current fragmentation threshold
1720 case SIOCGIWFRAG:
1721
1722 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1723 break;
1724
1725 // Set mode of operation
1726 case SIOCSIWMODE:
1727 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1728 break;
1729
1730 // Get mode of operation
1731 case SIOCGIWMODE:
1732 iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1733 break;
1734
1735 // Set WEP keys and mode
1736 case SIOCSIWENCODE:
1737 {
1738 char abyKey[WLAN_WEP232_KEYLEN];
1739
1740 if (wrq->u.encoding.pointer) {
1741
1742
1743 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
1744 rc = -E2BIG;
1745 break;
1746 }
1747 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
1748 if (copy_from_user(abyKey,
1749 wrq->u.encoding.pointer,
1750 wrq->u.encoding.length)) {
1751 rc = -EFAULT;
1752 break;
1753 }
1754 } else if (wrq->u.encoding.length != 0) {
1755 rc = -EINVAL;
1756 break;
1757 }
1758 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1759 }
1760 break;
1761
1762 // Get the WEP keys and mode
1763 case SIOCGIWENCODE:
1764
1765 if (!capable(CAP_NET_ADMIN)) {
1766 rc = -EPERM;
1767 break;
1768 }
1769 {
1770 char abyKey[WLAN_WEP232_KEYLEN];
1771
1772 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1773 if (rc != 0) break;
1774 if (wrq->u.encoding.pointer) {
1775 if (copy_to_user(wrq->u.encoding.pointer,
1776 abyKey,
1777 wrq->u.encoding.length))
1778 rc = -EFAULT;
1779 }
1780 }
1781 break;
1782
1783 // Get the current Tx-Power
1784 case SIOCGIWTXPOW:
1785 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1786 rc = -EOPNOTSUPP;
1787 break;
1788
1789 case SIOCSIWTXPOW:
1790 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1791 rc = -EOPNOTSUPP;
1792 break;
1793
1794 case SIOCSIWRETRY:
1795
1796 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
1797 break;
1798
1799 case SIOCGIWRETRY:
1800
1801 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
1802 break;
1803
1804 // Get range of parameters
1805 case SIOCGIWRANGE:
1806
1807 {
1808 struct iw_range range;
1809
1810 iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
1811 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
1812 rc = -EFAULT;
1813 }
1814
1815 break;
1816
1817 case SIOCGIWPOWER:
1818
1819 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
1820 break;
1821
1822
1823 case SIOCSIWPOWER:
1824
1825 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
1826 break;
1827
1828
1829 case SIOCGIWSENS:
1830
1831 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
1832 break;
1833
1834 case SIOCSIWSENS:
1835 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
1836 rc = -EOPNOTSUPP;
1837 break;
1838
1839 case SIOCGIWAPLIST:
1840 {
1841 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
1842
1843 if (wrq->u.data.pointer) {
1844 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
1845 if (rc == 0) {
1846 if (copy_to_user(wrq->u.data.pointer,
1847 buffer,
1848 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality)))
1849 ))
1850 rc = -EFAULT;
1851 }
1852 }
1853 }
1854 break;
1855
1856
1857 #ifdef WIRELESS_SPY
1858 // Set the spy list
1859 case SIOCSIWSPY:
1860
1861 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1862 rc = -EOPNOTSUPP;
1863 break;
1864
1865 // Get the spy list
1866 case SIOCGIWSPY:
1867
1868 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1869 rc = -EOPNOTSUPP;
1870 break;
1871
1872 #endif // WIRELESS_SPY
1873
1874 case SIOCGIWPRIV:
1875 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
1876 rc = -EOPNOTSUPP;
1877 /*
1878 if(wrq->u.data.pointer) {
1879 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
1880
1881 if(copy_to_user(wrq->u.data.pointer,
1882 (u_char *) iwctl_private_args,
1883 sizeof(iwctl_private_args)))
1884 rc = -EFAULT;
1885 }
1886 */
1887 break;
1888
1889 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1890 case SIOCSIWAUTH:
1891 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH\n");
1892 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
1893 break;
1894
1895 case SIOCGIWAUTH:
1896 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
1897 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
1898 break;
1899
1900 case SIOCSIWGENIE:
1901 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
1902 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1903 break;
1904
1905 case SIOCGIWGENIE:
1906 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
1907 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1908 break;
1909
1910 case SIOCSIWENCODEEXT:
1911 {
1912 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
1913 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
1914 if(wrq->u.encoding.pointer){
1915 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
1916 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
1917 rc = -E2BIG;
1918 break;
1919 }
1920 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
1921 rc = -EFAULT;
1922 break;
1923 }
1924 }else if(wrq->u.encoding.length != 0){
1925 rc = -EINVAL;
1926 break;
1927 }
1928 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
1929 }
1930 break;
1931
1932 case SIOCGIWENCODEEXT:
1933 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
1934 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
1935 break;
1936
1937 case SIOCSIWMLME:
1938 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
1939 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1940 break;
1941
1942 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1943
1944 case IOCTL_CMD_TEST:
1945
1946 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1947 rc = -EFAULT;
1948 break;
1949 } else {
1950 rc = 0;
1951 }
1952 pReq = (PSCmdRequest)rq;
1953
1954 //20080130-01,<Remark> by Mike Liu
1955 // if(pDevice->bLinkPass==TRUE)
1956 pReq->wResult = MAGIC_CODE; //Linking status:0x3142
1957 //20080130-02,<Remark> by Mike Liu
1958 // else
1959 // pReq->wResult = MAGIC_CODE+1; //disconnect status:0x3143
1960 break;
1961
1962 case IOCTL_CMD_SET:
1963 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
1964 (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
1965 {
1966 rc = -EFAULT;
1967 break;
1968 } else {
1969 rc = 0;
1970 }
1971
1972 if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
1973 return -EBUSY;
1974 }
1975 rc = private_ioctl(pDevice, rq);
1976 clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
1977 break;
1978
1979 case IOCTL_CMD_HOSTAPD:
1980
1981 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1982 rc = -EFAULT;
1983 break;
1984 } else {
1985 rc = 0;
1986 }
1987
1988 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
1989 break;
1990
1991 case IOCTL_CMD_WPA:
1992
1993 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1994 rc = -EFAULT;
1995 break;
1996 } else {
1997 rc = 0;
1998 }
1999
2000 rc = wpa_ioctl(pDevice, &wrq->u.data);
2001 break;
2002
2003 case SIOCETHTOOL:
2004 return ethtool_ioctl(dev, (void *) rq->ifr_data);
2005 // All other calls are currently unsupported
2006
2007 default:
2008 rc = -EOPNOTSUPP;
2009 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2010
2011
2012 }
2013
2014 if (pDevice->bCommit) {
2015 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2016 netif_stop_queue(pDevice->dev);
2017 spin_lock_irq(&pDevice->lock);
2018 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
2019 spin_unlock_irq(&pDevice->lock);
2020 }
2021 else {
2022 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2023 spin_lock_irq(&pDevice->lock);
2024 //2007-1121-01<Modify>by EinsnLiu
2025 if (pDevice->bLinkPass &&
2026 memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2027 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2028 } else {
2029 pDevice->bLinkPass = FALSE;
2030 pMgmt->eCurrState = WMAC_STATE_IDLE;
2031 memset(pMgmt->abyCurrBSSID, 0, 6);
2032 }
2033 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2034 //End Modify
2035 netif_stop_queue(pDevice->dev);
2036 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2037 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2038 if (!pDevice->bWPASuppWextEnabled)
2039 #endif
2040 bScheduleCommand((void *) pDevice,
2041 WLAN_CMD_BSSID_SCAN,
2042 pMgmt->abyDesireSSID);
2043 bScheduleCommand((void *) pDevice,
2044 WLAN_CMD_SSID,
2045 NULL);
2046 spin_unlock_irq(&pDevice->lock);
2047 }
2048 pDevice->bCommit = FALSE;
2049 }
2050
2051
2052 return rc;
2053 }
2054
2055
ethtool_ioctl(struct net_device * dev,void * useraddr)2056 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2057 {
2058 u32 ethcmd;
2059
2060 if (copy_from_user(ðcmd, useraddr, sizeof(ethcmd)))
2061 return -EFAULT;
2062
2063 switch (ethcmd) {
2064 case ETHTOOL_GDRVINFO: {
2065 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2066 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2067 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2068 if (copy_to_user(useraddr, &info, sizeof(info)))
2069 return -EFAULT;
2070 return 0;
2071 }
2072
2073 }
2074
2075 return -EOPNOTSUPP;
2076 }
2077
2078
2079 /*------------------------------------------------------------------*/
2080
2081 MODULE_DEVICE_TABLE(usb, vt6656_table);
2082
2083 static struct usb_driver vt6656_driver = {
2084 .name = DEVICE_NAME,
2085 .probe = vt6656_probe,
2086 .disconnect = vt6656_disconnect,
2087 .id_table = vt6656_table,
2088 #ifdef CONFIG_PM
2089 .suspend = vt6656_suspend,
2090 .resume = vt6656_resume,
2091 #endif /* CONFIG_PM */
2092 };
2093
2094 module_usb_driver(vt6656_driver);
2095