?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Avoid beyond bounds copy while caching ACL
[zen-stable.git] / drivers / staging / vt6656 / main_usb.c
blob6a708f4476519a6acf6161818a09e880340a438f
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[] __devinitdata = {
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
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
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
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
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
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 usb_put_dev(interface_to_usbdev(intf));
722
723 return 0;
724 }
725
726 static int vt6656_resume(struct usb_interface *intf)
727 {
728 PSDevice device = usb_get_intfdata(intf);
729
730 if (!device || !device->dev)
731 return -ENODEV;
732
733 usb_get_dev(interface_to_usbdev(intf));
734
735 if (!(device->flags & DEVICE_FLAGS_OPENED))
736 device_open(device->dev);
737
738 return 0;
739 }
740
741 #endif /* CONFIG_PM */
742
743 static const struct net_device_ops device_netdev_ops = {
744 .ndo_open = device_open,
745 .ndo_stop = device_close,
746 .ndo_do_ioctl = device_ioctl,
747 .ndo_get_stats = device_get_stats,
748 .ndo_start_xmit = device_xmit,
749 .ndo_set_rx_mode = device_set_multi,
750 };
751
752 static int __devinit
753 vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
754 {
755 u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
756 struct usb_device *udev = interface_to_usbdev(intf);
757 int rc = 0;
758 struct net_device *netdev = NULL;
759 PSDevice pDevice = NULL;
760
761 printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
762 printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
763
764 udev = usb_get_dev(udev);
765 netdev = alloc_etherdev(sizeof(DEVICE_INFO));
766 if (!netdev) {
767 printk(KERN_ERR DEVICE_NAME ": allocate net device failed\n");
768 rc = -ENOMEM;
769 goto err_nomem;
770 }
771
772 pDevice = netdev_priv(netdev);
773 memset(pDevice, 0, sizeof(DEVICE_INFO));
774
775 pDevice->dev = netdev;
776 pDevice->usb = udev;
777
778 device_set_options(pDevice);
779 spin_lock_init(&pDevice->lock);
780
781 pDevice->tx_80211 = device_dma0_tx_80211;
782 pDevice->sMgmtObj.pAdapter = (void *) pDevice;
783
784 netdev->netdev_ops = &device_netdev_ops;
785 netdev->wireless_handlers =
786 (struct iw_handler_def *) &iwctl_handler_def;
787
788 usb_set_intfdata(intf, pDevice);
789 SET_NETDEV_DEV(netdev, &intf->dev);
790 memcpy(pDevice->dev->dev_addr, fake_mac, ETH_ALEN);
791 rc = register_netdev(netdev);
792 if (rc) {
793 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
794 goto err_netdev;
795 }
796
797 usb_device_reset(pDevice);
798
799 {
800 union iwreq_data wrqu;
801 memset(&wrqu, 0, sizeof(wrqu));
802 wrqu.data.flags = RT_INSMOD_EVENT_FLAG;
803 wrqu.data.length = IFNAMSIZ;
804 wireless_send_event(pDevice->dev,
805 IWEVCUSTOM,
806 &wrqu,
807 pDevice->dev->name);
808 }
809
810 return 0;
811
812 err_netdev:
813 free_netdev(netdev);
814 err_nomem:
815 usb_put_dev(udev);
816
817 return rc;
818 }
819
820 static void device_free_tx_bufs(PSDevice pDevice)
821 {
822 PUSB_SEND_CONTEXT pTxContext;
823 int ii;
824
825 for (ii = 0; ii < pDevice->cbTD; ii++) {
826
827 pTxContext = pDevice->apTD[ii];
828 //de-allocate URBs
829 if (pTxContext->pUrb) {
830 usb_kill_urb(pTxContext->pUrb);
831 usb_free_urb(pTxContext->pUrb);
832 }
833 kfree(pTxContext);
834 }
835 return;
836 }
837
838
839 static void device_free_rx_bufs(PSDevice pDevice)
840 {
841 PRCB pRCB;
842 int ii;
843
844 for (ii = 0; ii < pDevice->cbRD; ii++) {
845
846 pRCB = pDevice->apRCB[ii];
847 //de-allocate URBs
848 if (pRCB->pUrb) {
849 usb_kill_urb(pRCB->pUrb);
850 usb_free_urb(pRCB->pUrb);
851 }
852 //de-allocate skb
853 if (pRCB->skb)
854 dev_kfree_skb(pRCB->skb);
855 }
856 kfree(pDevice->pRCBMem);
857
858 return;
859 }
860
861 static void usb_device_reset(PSDevice pDevice)
862 {
863 int status;
864 status = usb_reset_device(pDevice->usb);
865 if (status)
866 printk("usb_device_reset fail status=%d\n",status);
867 return ;
868 }
869
870 static void device_free_int_bufs(PSDevice pDevice)
871 {
872 kfree(pDevice->intBuf.pDataBuf);
873 return;
874 }
875
876
877 static BOOL device_alloc_bufs(PSDevice pDevice) {
878
879 PUSB_SEND_CONTEXT pTxContext;
880 PRCB pRCB;
881 int ii;
882
883
884 for (ii = 0; ii < pDevice->cbTD; ii++) {
885
886 pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
887 if (pTxContext == NULL) {
888 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
889 goto free_tx;
890 }
891 pDevice->apTD[ii] = pTxContext;
892 pTxContext->pDevice = (void *) pDevice;
893 //allocate URBs
894 pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
895 if (pTxContext->pUrb == NULL) {
896 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
897 goto free_tx;
898 }
899 pTxContext->bBoolInUse = FALSE;
900 }
901
902 // allocate rcb mem
903 pDevice->pRCBMem = kzalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
904 if (pDevice->pRCBMem == NULL) {
905 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
906 goto free_tx;
907 }
908
909
910 pDevice->FirstRecvFreeList = NULL;
911 pDevice->LastRecvFreeList = NULL;
912 pDevice->FirstRecvMngList = NULL;
913 pDevice->LastRecvMngList = NULL;
914 pDevice->NumRecvFreeList = 0;
915 pRCB = (PRCB) pDevice->pRCBMem;
916
917 for (ii = 0; ii < pDevice->cbRD; ii++) {
918
919 pDevice->apRCB[ii] = pRCB;
920 pRCB->pDevice = (void *) pDevice;
921 //allocate URBs
922 pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
923
924 if (pRCB->pUrb == NULL) {
925 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
926 goto free_rx_tx;
927 }
928 pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
929 if (pRCB->skb == NULL) {
930 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
931 goto free_rx_tx;
932 }
933 pRCB->skb->dev = pDevice->dev;
934 pRCB->bBoolInUse = FALSE;
935 EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
936 pDevice->NumRecvFreeList++;
937 pRCB++;
938 }
939
940
941 pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
942 if (pDevice->pControlURB == NULL) {
943 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
944 goto free_rx_tx;
945 }
946
947 pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
948 if (pDevice->pInterruptURB == NULL) {
949 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
950 usb_free_urb(pDevice->pControlURB);
951 goto free_rx_tx;
952 }
953
954 pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
955 if (pDevice->intBuf.pDataBuf == NULL) {
956 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
957 usb_free_urb(pDevice->pControlURB);
958 usb_free_urb(pDevice->pInterruptURB);
959 goto free_rx_tx;
960 }
961
962 return TRUE;
963
964 free_rx_tx:
965 device_free_rx_bufs(pDevice);
966
967 free_tx:
968 device_free_tx_bufs(pDevice);
969
970 return FALSE;
971 }
972
973
974
975
976 static BOOL device_init_defrag_cb(PSDevice pDevice) {
977 int i;
978 PSDeFragControlBlock pDeF;
979
980 /* Init the fragment ctl entries */
981 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
982 pDeF = &(pDevice->sRxDFCB[i]);
983 if (!device_alloc_frag_buf(pDevice, pDeF)) {
984 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
985 pDevice->dev->name);
986 goto free_frag;
987 }
988 }
989 pDevice->cbDFCB = CB_MAX_RX_FRAG;
990 pDevice->cbFreeDFCB = pDevice->cbDFCB;
991 return TRUE;
992
993 free_frag:
994 device_free_frag_bufs(pDevice);
995 return FALSE;
996 }
997
998
999
1000 static void device_free_frag_bufs(PSDevice pDevice) {
1001 PSDeFragControlBlock pDeF;
1002 int i;
1003
1004 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1005
1006 pDeF = &(pDevice->sRxDFCB[i]);
1007
1008 if (pDeF->skb)
1009 dev_kfree_skb(pDeF->skb);
1010 }
1011 }
1012
1013
1014
1015 BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1016
1017 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1018 if (pDeF->skb == NULL)
1019 return FALSE;
1020 ASSERT(pDeF->skb);
1021 pDeF->skb->dev = pDevice->dev;
1022
1023 return TRUE;
1024 }
1025
1026
1027 /*-----------------------------------------------------------------*/
1028
1029 static int device_open(struct net_device *dev) {
1030 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1031
1032 extern SWPAResult wpa_Result;
1033 memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1034 wpa_Result.proto = 0;
1035 wpa_Result.key_mgmt = 0;
1036 wpa_Result.eap_type = 0;
1037 wpa_Result.authenticated = FALSE;
1038 pDevice->fWPA_Authened = FALSE;
1039
1040 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
1041
1042
1043 pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
1044
1045 if (device_alloc_bufs(pDevice) == FALSE) {
1046 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
1047 return -ENOMEM;
1048 }
1049
1050 if (device_init_defrag_cb(pDevice)== FALSE) {
1051 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragement cb fail \n");
1052 goto free_rx_tx;
1053 }
1054
1055 MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
1056 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
1057 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
1058 MP_SET_FLAG(pDevice, fMP_POST_READS);
1059 MP_SET_FLAG(pDevice, fMP_POST_WRITES);
1060
1061 //read config file
1062 Read_config_file(pDevice);
1063
1064 if (device_init_registers(pDevice, DEVICE_INIT_COLD) == FALSE) {
1065 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
1066 goto free_all;
1067 }
1068
1069 device_set_multi(pDevice->dev);
1070 // Init for Key Management
1071
1072 KeyvInitTable(pDevice,&pDevice->sKey);
1073 memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1074 memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1075 pDevice->bStopTx0Pkt = FALSE;
1076 pDevice->bStopDataPkt = FALSE;
1077 pDevice->bRoaming = FALSE;
1078 pDevice->bIsRoaming = FALSE;
1079 pDevice->bEnableRoaming = FALSE;
1080 if (pDevice->bDiversityRegCtlON) {
1081 device_init_diversity_timer(pDevice);
1082 }
1083
1084 vMgrObjectInit(pDevice);
1085 tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
1086 tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
1087 tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
1088 add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback));
1089 pDevice->int_interval = 100; //Max 100 microframes.
1090 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1091
1092 pDevice->bIsRxWorkItemQueued = TRUE;
1093 pDevice->fKillEventPollingThread = FALSE;
1094 pDevice->bEventAvailable = FALSE;
1095
1096 pDevice->bWPADEVUp = FALSE;
1097 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1098 pDevice->bwextstep0 = FALSE;
1099 pDevice->bwextstep1 = FALSE;
1100 pDevice->bwextstep2 = FALSE;
1101 pDevice->bwextstep3 = FALSE;
1102 pDevice->bWPASuppWextEnabled = FALSE;
1103 #endif
1104 pDevice->byReAssocCount = 0;
1105
1106 RXvWorkItem(pDevice);
1107 INTvWorkItem(pDevice);
1108
1109 // Patch: if WEP key already set by iwconfig but device not yet open
1110 if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1111 spin_lock_irq(&pDevice->lock);
1112 KeybSetDefaultKey( pDevice,
1113 &(pDevice->sKey),
1114 pDevice->byKeyIndex | (1 << 31),
1115 pDevice->uKeyLength,
1116 NULL,
1117 pDevice->abyKey,
1118 KEY_CTL_WEP
1119 );
1120 spin_unlock_irq(&pDevice->lock);
1121 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1122 }
1123
1124 if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1125 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1126 }
1127 else {
1128 //mike:mark@2008-11-10
1129 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1130 /* bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL); */
1131 }
1132
1133
1134 netif_stop_queue(pDevice->dev);
1135 pDevice->flags |= DEVICE_FLAGS_OPENED;
1136
1137 {
1138 union iwreq_data wrqu;
1139 memset(&wrqu, 0, sizeof(wrqu));
1140 wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1141 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1142 }
1143
1144 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1145 return 0;
1146
1147 free_all:
1148 device_free_frag_bufs(pDevice);
1149 free_rx_tx:
1150 device_free_rx_bufs(pDevice);
1151 device_free_tx_bufs(pDevice);
1152 device_free_int_bufs(pDevice);
1153 usb_kill_urb(pDevice->pControlURB);
1154 usb_kill_urb(pDevice->pInterruptURB);
1155 usb_free_urb(pDevice->pControlURB);
1156 usb_free_urb(pDevice->pInterruptURB);
1157
1158 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1159 return -ENOMEM;
1160 }
1161
1162
1163
1164 static int device_close(struct net_device *dev) {
1165 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1166 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1167
1168 int uu;
1169
1170 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1171 if (pDevice == NULL)
1172 return -ENODEV;
1173
1174 {
1175 union iwreq_data wrqu;
1176 memset(&wrqu, 0, sizeof(wrqu));
1177 wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1178 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1179 }
1180
1181 if (pDevice->bLinkPass) {
1182 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1183 mdelay(30);
1184 }
1185
1186 device_release_WPADEV(pDevice);
1187
1188 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1189 pMgmt->bShareKeyAlgorithm = FALSE;
1190 pDevice->bEncryptionEnable = FALSE;
1191 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1192 spin_lock_irq(&pDevice->lock);
1193 for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1194 MACvDisableKeyEntry(pDevice,uu);
1195 spin_unlock_irq(&pDevice->lock);
1196
1197 if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1198 MACbShutdown(pDevice);
1199 }
1200 netif_stop_queue(pDevice->dev);
1201 MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1202 MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1203 MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1204 pDevice->fKillEventPollingThread = TRUE;
1205 del_timer(&pDevice->sTimerCommand);
1206 del_timer(&pMgmt->sTimerSecondCallback);
1207
1208 del_timer(&pDevice->sTimerTxData);
1209
1210 if (pDevice->bDiversityRegCtlON) {
1211 del_timer(&pDevice->TimerSQ3Tmax1);
1212 del_timer(&pDevice->TimerSQ3Tmax2);
1213 del_timer(&pDevice->TimerSQ3Tmax3);
1214 }
1215 tasklet_kill(&pDevice->RxMngWorkItem);
1216 tasklet_kill(&pDevice->ReadWorkItem);
1217 tasklet_kill(&pDevice->EventWorkItem);
1218
1219 pDevice->bRoaming = FALSE;
1220 pDevice->bIsRoaming = FALSE;
1221 pDevice->bEnableRoaming = FALSE;
1222 pDevice->bCmdRunning = FALSE;
1223 pDevice->bLinkPass = FALSE;
1224 memset(pMgmt->abyCurrBSSID, 0, 6);
1225 pMgmt->eCurrState = WMAC_STATE_IDLE;
1226
1227 device_free_tx_bufs(pDevice);
1228 device_free_rx_bufs(pDevice);
1229 device_free_int_bufs(pDevice);
1230 device_free_frag_bufs(pDevice);
1231
1232 usb_kill_urb(pDevice->pControlURB);
1233 usb_kill_urb(pDevice->pInterruptURB);
1234 usb_free_urb(pDevice->pControlURB);
1235 usb_free_urb(pDevice->pInterruptURB);
1236
1237 BSSvClearNodeDBTable(pDevice, 0);
1238 pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1239
1240 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1241
1242 return 0;
1243 }
1244
1245 static void __devexit vt6656_disconnect(struct usb_interface *intf)
1246 {
1247 PSDevice device = usb_get_intfdata(intf);
1248
1249 if (!device)
1250 return;
1251
1252 {
1253 union iwreq_data req;
1254 memset(&req, 0, sizeof(req));
1255 req.data.flags = RT_RMMOD_EVENT_FLAG;
1256 wireless_send_event(device->dev, IWEVCUSTOM, &req, NULL);
1257 }
1258
1259 device_release_WPADEV(device);
1260
1261 if (device->firmware)
1262 release_firmware(device->firmware);
1263
1264 usb_set_intfdata(intf, NULL);
1265 usb_put_dev(interface_to_usbdev(intf));
1266
1267 device->flags |= DEVICE_FLAGS_UNPLUG;
1268
1269 if (device->dev) {
1270 unregister_netdev(device->dev);
1271 wpa_set_wpadev(device, 0);
1272 free_netdev(device->dev);
1273 }
1274 }
1275
1276 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1277 {
1278 PSDevice pDevice = netdev_priv(dev);
1279
1280 spin_lock_irq(&pDevice->lock);
1281
1282 if (unlikely(pDevice->bStopTx0Pkt))
1283 dev_kfree_skb_irq(skb);
1284 else
1285 vDMA0_tx_80211(pDevice, skb);
1286
1287 spin_unlock_irq(&pDevice->lock);
1288
1289 return NETDEV_TX_OK;
1290 }
1291
1292 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1293 {
1294 PSDevice pDevice = netdev_priv(dev);
1295 struct net_device_stats *stats = &pDevice->stats;
1296
1297 spin_lock_irq(&pDevice->lock);
1298
1299 netif_stop_queue(dev);
1300
1301 if (!pDevice->bLinkPass) {
1302 dev_kfree_skb_irq(skb);
1303 goto out;
1304 }
1305
1306 if (pDevice->bStopDataPkt) {
1307 dev_kfree_skb_irq(skb);
1308 stats->tx_dropped++;
1309 goto out;
1310 }
1311
1312 if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1313 if (netif_queue_stopped(dev))
1314 netif_wake_queue(dev);
1315 }
1316
1317 out:
1318 spin_unlock_irq(&pDevice->lock);
1319
1320 return NETDEV_TX_OK;
1321 }
1322
1323 static unsigned const ethernet_polynomial = 0x04c11db7U;
1324 static inline u32 ether_crc(int length, unsigned char *data)
1325 {
1326 int crc = -1;
1327
1328 while(--length >= 0) {
1329 unsigned char current_octet = *data++;
1330 int bit;
1331 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1332 crc = (crc << 1) ^
1333 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1334 }
1335 }
1336 return crc;
1337 }
1338
1339 //find out the start position of str2 from str1
1340 static unsigned char *kstrstr(const unsigned char *str1,
1341 const unsigned char *str2) {
1342 int str1_len = strlen(str1);
1343 int str2_len = strlen(str2);
1344
1345 while (str1_len >= str2_len) {
1346 str1_len--;
1347 if(memcmp(str1,str2,str2_len)==0)
1348 return (unsigned char *) str1;
1349 str1++;
1350 }
1351 return NULL;
1352 }
1353
1354 static int Config_FileGetParameter(unsigned char *string,
1355 unsigned char *dest,
1356 unsigned char *source)
1357 {
1358 unsigned char buf1[100];
1359 unsigned char buf2[100];
1360 unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1361 int ii;
1362
1363 memset(buf1,0,100);
1364 strcat(buf1, string);
1365 strcat(buf1, "=");
1366 source+=strlen(buf1);
1367
1368 //find target string start point
1369 start_p = kstrstr(source,buf1);
1370 if (start_p == NULL)
1371 return FALSE;
1372
1373 //check if current config line is marked by "#" ??
1374 for (ii = 1; ; ii++) {
1375 if (memcmp(start_p - ii, "\n", 1) == 0)
1376 break;
1377 if (memcmp(start_p - ii, "#", 1) == 0)
1378 return FALSE;
1379 }
1380
1381 //find target string end point
1382 end_p = kstrstr(start_p,"\n");
1383 if (end_p == NULL) { //can't find "\n",but don't care
1384 end_p=start_p+strlen(start_p); //no include "\n"
1385 }
1386
1387 memset(buf2,0,100);
1388 memcpy(buf2,start_p,end_p-start_p); //get the tartget line
1389 buf2[end_p-start_p]='\0';
1390
1391 //find value
1392 start_p = kstrstr(buf2,"=");
1393 if (start_p == NULL)
1394 return FALSE;
1395 memset(buf1,0,100);
1396 strcpy(buf1,start_p+1);
1397
1398 //except space
1399 tmp_p = buf1;
1400 while(*tmp_p != 0x00) {
1401 if(*tmp_p==' ')
1402 tmp_p++;
1403 else
1404 break;
1405 }
1406
1407 memcpy(dest,tmp_p,strlen(tmp_p));
1408 return TRUE;
1409 }
1410
1411 //if read fail,return NULL,or return data pointer;
1412 static unsigned char *Config_FileOperation(PSDevice pDevice)
1413 {
1414 unsigned char *config_path = CONFIG_PATH;
1415 unsigned char *buffer = NULL;
1416 struct file *filp=NULL;
1417 mm_segment_t old_fs = get_fs();
1418 //int oldfsuid=0,oldfsgid=0;
1419 int result = 0;
1420
1421 set_fs (KERNEL_DS);
1422 /* Can't do this anymore, so we rely on correct filesystem permissions:
1423 //Make sure a caller can read or write power as root
1424 oldfsuid=current->fsuid;
1425 oldfsgid=current->fsgid;
1426 current->fsuid = 0;
1427 current->fsgid = 0;
1428 */
1429
1430 //open file
1431 filp = filp_open(config_path, O_RDWR, 0);
1432 if (IS_ERR(filp)) {
1433 printk("Config_FileOperation file Not exist\n");
1434 result=-1;
1435 goto error2;
1436 }
1437
1438 if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1439 printk("file %s cann't readable or writable?\n",config_path);
1440 result = -1;
1441 goto error1;
1442 }
1443
1444 buffer = kmalloc(1024, GFP_KERNEL);
1445 if(buffer==NULL) {
1446 printk("allocate mem for file fail?\n");
1447 result = -1;
1448 goto error1;
1449 }
1450
1451 if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1452 printk("read file error?\n");
1453 result = -1;
1454 }
1455
1456 error1:
1457 if(filp_close(filp,NULL))
1458 printk("Config_FileOperation:close file fail\n");
1459
1460 error2:
1461 set_fs (old_fs);
1462
1463 /*
1464 current->fsuid=oldfsuid;
1465 current->fsgid=oldfsgid;
1466 */
1467
1468 if(result!=0) {
1469 kfree(buffer);
1470 buffer=NULL;
1471 }
1472 return buffer;
1473 }
1474
1475 //return --->-1:fail; >=0:successful
1476 static int Read_config_file(PSDevice pDevice) {
1477 int result = 0;
1478 unsigned char tmpbuffer[100];
1479 unsigned char *buffer = NULL;
1480
1481 //init config setting
1482 pDevice->config_file.ZoneType = -1;
1483 pDevice->config_file.eAuthenMode = -1;
1484 pDevice->config_file.eEncryptionStatus = -1;
1485
1486 buffer = Config_FileOperation(pDevice);
1487 if (buffer == NULL) {
1488 result =-1;
1489 return result;
1490 }
1491
1492 //get zonetype
1493 {
1494 memset(tmpbuffer,0,sizeof(tmpbuffer));
1495 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1496 if(memcmp(tmpbuffer,"USA",3)==0) {
1497 pDevice->config_file.ZoneType=ZoneType_USA;
1498 }
1499 else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1500 pDevice->config_file.ZoneType=ZoneType_Japan;
1501 }
1502 else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1503 pDevice->config_file.ZoneType=ZoneType_Europe;
1504 }
1505 else {
1506 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1507 }
1508 }
1509 }
1510
1511 //get other parameter
1512 {
1513 memset(tmpbuffer,0,sizeof(tmpbuffer));
1514 if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1515 pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1516 }
1517
1518 memset(tmpbuffer,0,sizeof(tmpbuffer));
1519 if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1520 pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1521 }
1522 }
1523
1524 kfree(buffer);
1525 return result;
1526 }
1527
1528 static void device_set_multi(struct net_device *dev) {
1529 PSDevice pDevice = (PSDevice) netdev_priv(dev);
1530 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1531 u32 mc_filter[2];
1532 int ii;
1533 struct netdev_hw_addr *ha;
1534 BYTE pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1535 BYTE byTmpMode = 0;
1536 int rc;
1537
1538
1539 spin_lock_irq(&pDevice->lock);
1540 rc = CONTROLnsRequestIn(pDevice,
1541 MESSAGE_TYPE_READ,
1542 MAC_REG_RCR,
1543 MESSAGE_REQUEST_MACREG,
1544 1,
1545 &byTmpMode
1546 );
1547 if (rc == 0) pDevice->byRxMode = byTmpMode;
1548
1549 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1550
1551 if (dev->flags & IFF_PROMISC) { // Set promiscuous.
1552 DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1553 // Unconditionally log net taps.
1554 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1555 }
1556 else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1557 (dev->flags & IFF_ALLMULTI)) {
1558 CONTROLnsRequestOut(pDevice,
1559 MESSAGE_TYPE_WRITE,
1560 MAC_REG_MAR0,
1561 MESSAGE_REQUEST_MACREG,
1562 8,
1563 pbyData
1564 );
1565 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1566 }
1567 else {
1568 memset(mc_filter, 0, sizeof(mc_filter));
1569 netdev_for_each_mc_addr(ha, dev) {
1570 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1571 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1572 }
1573 for (ii = 0; ii < 4; ii++) {
1574 MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1575 MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1576 }
1577 pDevice->byRxMode &= ~(RCR_UNICAST);
1578 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1579 }
1580
1581 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1582 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1583 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1584 pDevice->byRxMode &= ~(RCR_UNICAST);
1585 }
1586 ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1587 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1588 spin_unlock_irq(&pDevice->lock);
1589
1590 }
1591
1592
1593 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1594 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1595
1596 return &pDevice->stats;
1597 }
1598
1599
1600 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1601 PSDevice pDevice = (PSDevice)netdev_priv(dev);
1602 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1603 PSCmdRequest pReq;
1604 //BOOL bCommit = FALSE;
1605 struct iwreq *wrq = (struct iwreq *) rq;
1606 int rc =0;
1607
1608 if (pMgmt == NULL) {
1609 rc = -EFAULT;
1610 return rc;
1611 }
1612
1613 switch(cmd) {
1614
1615 case SIOCGIWNAME:
1616 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1617 break;
1618
1619 case SIOCSIWNWID:
1620 case SIOCGIWNWID: //0x8b03 support
1621 rc = -EOPNOTSUPP;
1622 break;
1623
1624 // Set frequency/channel
1625 case SIOCSIWFREQ:
1626 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1627 break;
1628
1629 // Get frequency/channel
1630 case SIOCGIWFREQ:
1631 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1632 break;
1633
1634 // Set desired network name (ESSID)
1635 case SIOCSIWESSID:
1636
1637 {
1638 char essid[IW_ESSID_MAX_SIZE+1];
1639 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1640 rc = -E2BIG;
1641 break;
1642 }
1643 if (copy_from_user(essid, wrq->u.essid.pointer,
1644 wrq->u.essid.length)) {
1645 rc = -EFAULT;
1646 break;
1647 }
1648 rc = iwctl_siwessid(dev, NULL,
1649 &(wrq->u.essid), essid);
1650 }
1651 break;
1652
1653
1654 // Get current network name (ESSID)
1655 case SIOCGIWESSID:
1656
1657 {
1658 char essid[IW_ESSID_MAX_SIZE+1];
1659 if (wrq->u.essid.pointer) {
1660 rc = iwctl_giwessid(dev, NULL,
1661 &(wrq->u.essid), essid);
1662 if (copy_to_user(wrq->u.essid.pointer,
1663 essid,
1664 wrq->u.essid.length) )
1665 rc = -EFAULT;
1666 }
1667 }
1668 break;
1669
1670 case SIOCSIWAP:
1671
1672 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1673 break;
1674
1675
1676 // Get current Access Point (BSSID)
1677 case SIOCGIWAP:
1678 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1679 break;
1680
1681
1682 // Set desired station name
1683 case SIOCSIWNICKN:
1684 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1685 rc = -EOPNOTSUPP;
1686 break;
1687
1688 // Get current station name
1689 case SIOCGIWNICKN:
1690 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1691 rc = -EOPNOTSUPP;
1692 break;
1693
1694 // Set the desired bit-rate
1695 case SIOCSIWRATE:
1696 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1697 break;
1698
1699 // Get the current bit-rate
1700 case SIOCGIWRATE:
1701
1702 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1703 break;
1704
1705 // Set the desired RTS threshold
1706 case SIOCSIWRTS:
1707
1708 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
1709 break;
1710
1711 // Get the current RTS threshold
1712 case SIOCGIWRTS:
1713
1714 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1715 break;
1716
1717 // Set the desired fragmentation threshold
1718 case SIOCSIWFRAG:
1719
1720 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1721 break;
1722
1723 // Get the current fragmentation threshold
1724 case SIOCGIWFRAG:
1725
1726 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1727 break;
1728
1729 // Set mode of operation
1730 case SIOCSIWMODE:
1731 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1732 break;
1733
1734 // Get mode of operation
1735 case SIOCGIWMODE:
1736 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1737 break;
1738
1739 // Set WEP keys and mode
1740 case SIOCSIWENCODE:
1741 {
1742 char abyKey[WLAN_WEP232_KEYLEN];
1743
1744 if (wrq->u.encoding.pointer) {
1745
1746
1747 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
1748 rc = -E2BIG;
1749 break;
1750 }
1751 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
1752 if (copy_from_user(abyKey,
1753 wrq->u.encoding.pointer,
1754 wrq->u.encoding.length)) {
1755 rc = -EFAULT;
1756 break;
1757 }
1758 } else if (wrq->u.encoding.length != 0) {
1759 rc = -EINVAL;
1760 break;
1761 }
1762 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1763 }
1764 break;
1765
1766 // Get the WEP keys and mode
1767 case SIOCGIWENCODE:
1768
1769 if (!capable(CAP_NET_ADMIN)) {
1770 rc = -EPERM;
1771 break;
1772 }
1773 {
1774 char abyKey[WLAN_WEP232_KEYLEN];
1775
1776 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1777 if (rc != 0) break;
1778 if (wrq->u.encoding.pointer) {
1779 if (copy_to_user(wrq->u.encoding.pointer,
1780 abyKey,
1781 wrq->u.encoding.length))
1782 rc = -EFAULT;
1783 }
1784 }
1785 break;
1786
1787 // Get the current Tx-Power
1788 case SIOCGIWTXPOW:
1789 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1790 rc = -EOPNOTSUPP;
1791 break;
1792
1793 case SIOCSIWTXPOW:
1794 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1795 rc = -EOPNOTSUPP;
1796 break;
1797
1798 case SIOCSIWRETRY:
1799
1800 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
1801 break;
1802
1803 case SIOCGIWRETRY:
1804
1805 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
1806 break;
1807
1808 // Get range of parameters
1809 case SIOCGIWRANGE:
1810
1811 {
1812 struct iw_range range;
1813
1814 rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
1815 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
1816 rc = -EFAULT;
1817 }
1818
1819 break;
1820
1821 case SIOCGIWPOWER:
1822
1823 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
1824 break;
1825
1826
1827 case SIOCSIWPOWER:
1828
1829 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
1830 break;
1831
1832
1833 case SIOCGIWSENS:
1834
1835 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
1836 break;
1837
1838 case SIOCSIWSENS:
1839 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
1840 rc = -EOPNOTSUPP;
1841 break;
1842
1843 case SIOCGIWAPLIST:
1844 {
1845 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
1846
1847 if (wrq->u.data.pointer) {
1848 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
1849 if (rc == 0) {
1850 if (copy_to_user(wrq->u.data.pointer,
1851 buffer,
1852 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality)))
1853 ))
1854 rc = -EFAULT;
1855 }
1856 }
1857 }
1858 break;
1859
1860
1861 #ifdef WIRELESS_SPY
1862 // Set the spy list
1863 case SIOCSIWSPY:
1864
1865 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1866 rc = -EOPNOTSUPP;
1867 break;
1868
1869 // Get the spy list
1870 case SIOCGIWSPY:
1871
1872 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1873 rc = -EOPNOTSUPP;
1874 break;
1875
1876 #endif // WIRELESS_SPY
1877
1878 case SIOCGIWPRIV:
1879 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
1880 rc = -EOPNOTSUPP;
1881 /*
1882 if(wrq->u.data.pointer) {
1883 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
1884
1885 if(copy_to_user(wrq->u.data.pointer,
1886 (u_char *) iwctl_private_args,
1887 sizeof(iwctl_private_args)))
1888 rc = -EFAULT;
1889 }
1890 */
1891 break;
1892
1893 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1894 case SIOCSIWAUTH:
1895 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH\n");
1896 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
1897 break;
1898
1899 case SIOCGIWAUTH:
1900 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
1901 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
1902 break;
1903
1904 case SIOCSIWGENIE:
1905 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
1906 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1907 break;
1908
1909 case SIOCGIWGENIE:
1910 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
1911 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1912 break;
1913
1914 case SIOCSIWENCODEEXT:
1915 {
1916 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
1917 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
1918 if(wrq->u.encoding.pointer){
1919 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
1920 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
1921 rc = -E2BIG;
1922 break;
1923 }
1924 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
1925 rc = -EFAULT;
1926 break;
1927 }
1928 }else if(wrq->u.encoding.length != 0){
1929 rc = -EINVAL;
1930 break;
1931 }
1932 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
1933 }
1934 break;
1935
1936 case SIOCGIWENCODEEXT:
1937 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
1938 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
1939 break;
1940
1941 case SIOCSIWMLME:
1942 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
1943 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1944 break;
1945
1946 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1947
1948 case IOCTL_CMD_TEST:
1949
1950 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1951 rc = -EFAULT;
1952 break;
1953 } else {
1954 rc = 0;
1955 }
1956 pReq = (PSCmdRequest)rq;
1957
1958 //20080130-01,<Remark> by Mike Liu
1959 // if(pDevice->bLinkPass==TRUE)
1960 pReq->wResult = MAGIC_CODE; //Linking status:0x3142
1961 //20080130-02,<Remark> by Mike Liu
1962 // else
1963 // pReq->wResult = MAGIC_CODE+1; //disconnect status:0x3143
1964 break;
1965
1966 case IOCTL_CMD_SET:
1967 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
1968 (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
1969 {
1970 rc = -EFAULT;
1971 break;
1972 } else {
1973 rc = 0;
1974 }
1975
1976 if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
1977 return -EBUSY;
1978 }
1979 rc = private_ioctl(pDevice, rq);
1980 clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
1981 break;
1982
1983 case IOCTL_CMD_HOSTAPD:
1984
1985 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1986 rc = -EFAULT;
1987 break;
1988 } else {
1989 rc = 0;
1990 }
1991
1992 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
1993 break;
1994
1995 case IOCTL_CMD_WPA:
1996
1997 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1998 rc = -EFAULT;
1999 break;
2000 } else {
2001 rc = 0;
2002 }
2003
2004 rc = wpa_ioctl(pDevice, &wrq->u.data);
2005 break;
2006
2007 case SIOCETHTOOL:
2008 return ethtool_ioctl(dev, (void *) rq->ifr_data);
2009 // All other calls are currently unsupported
2010
2011 default:
2012 rc = -EOPNOTSUPP;
2013 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2014
2015
2016 }
2017
2018 if (pDevice->bCommit) {
2019 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2020 netif_stop_queue(pDevice->dev);
2021 spin_lock_irq(&pDevice->lock);
2022 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
2023 spin_unlock_irq(&pDevice->lock);
2024 }
2025 else {
2026 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2027 spin_lock_irq(&pDevice->lock);
2028 //2007-1121-01<Modify>by EinsnLiu
2029 if (pDevice->bLinkPass &&
2030 memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2031 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2032 } else {
2033 pDevice->bLinkPass = FALSE;
2034 pMgmt->eCurrState = WMAC_STATE_IDLE;
2035 memset(pMgmt->abyCurrBSSID, 0, 6);
2036 }
2037 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2038 //End Modify
2039 netif_stop_queue(pDevice->dev);
2040 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2041 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2042 if (!pDevice->bWPASuppWextEnabled)
2043 #endif
2044 bScheduleCommand((void *) pDevice,
2045 WLAN_CMD_BSSID_SCAN,
2046 pMgmt->abyDesireSSID);
2047 bScheduleCommand((void *) pDevice,
2048 WLAN_CMD_SSID,
2049 NULL);
2050 spin_unlock_irq(&pDevice->lock);
2051 }
2052 pDevice->bCommit = FALSE;
2053 }
2054
2055
2056 return rc;
2057 }
2058
2059
2060 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2061 {
2062 u32 ethcmd;
2063
2064 if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
2065 return -EFAULT;
2066
2067 switch (ethcmd) {
2068 case ETHTOOL_GDRVINFO: {
2069 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2070 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2071 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2072 if (copy_to_user(useraddr, &info, sizeof(info)))
2073 return -EFAULT;
2074 return 0;
2075 }
2076
2077 }
2078
2079 return -EOPNOTSUPP;
2080 }
2081
2082
2083 /*------------------------------------------------------------------*/
2084
2085 MODULE_DEVICE_TABLE(usb, vt6656_table);
2086
2087 static struct usb_driver vt6656_driver = {
2088 .name = DEVICE_NAME,
2089 .probe = vt6656_probe,
2090 .disconnect = vt6656_disconnect,
2091 .id_table = vt6656_table,
2092 #ifdef CONFIG_PM
2093 .suspend = vt6656_suspend,
2094 .resume = vt6656_resume,
2095 #endif /* CONFIG_PM */
2096 };
2097
2098 module_usb_driver(vt6656_driver);