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