projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'staging-3.7-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh...
[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 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1060 pDevice->bwextstep0 = FALSE;
1061 pDevice->bwextstep1 = FALSE;
1062 pDevice->bwextstep2 = FALSE;
1063 pDevice->bwextstep3 = FALSE;
1064 pDevice->bWPASuppWextEnabled = FALSE;
1065 #endif
1066 pDevice->byReAssocCount = 0;
1067
1068 RXvWorkItem(pDevice);
1069 INTvWorkItem(pDevice);
1070
1071 // Patch: if WEP key already set by iwconfig but device not yet open
1072 if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1073 spin_lock_irq(&pDevice->lock);
1074 KeybSetDefaultKey( pDevice,
1075 &(pDevice->sKey),
1076 pDevice->byKeyIndex | (1 << 31),
1077 pDevice->uKeyLength,
1078 NULL,
1079 pDevice->abyKey,
1080 KEY_CTL_WEP
1081 );
1082 spin_unlock_irq(&pDevice->lock);
1083 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1084 }
1085
1086 if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1087 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1088 }
1089 else {
1090 //mike:mark@2008-11-10
1091 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1092 /* bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL); */
1093 }
1094
1095
1096 netif_stop_queue(pDevice->dev);
1097 pDevice->flags |= DEVICE_FLAGS_OPENED;
1098
1099 {
1100 union iwreq_data wrqu;
1101 memset(&wrqu, 0, sizeof(wrqu));
1102 wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1103 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1104 }
1105
1106 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1107 return 0;
1108
1109 free_all:
1110 device_free_frag_bufs(pDevice);
1111 free_rx_tx:
1112 device_free_rx_bufs(pDevice);
1113 device_free_tx_bufs(pDevice);
1114 device_free_int_bufs(pDevice);
1115 usb_kill_urb(pDevice->pControlURB);
1116 usb_kill_urb(pDevice->pInterruptURB);
1117 usb_free_urb(pDevice->pControlURB);
1118 usb_free_urb(pDevice->pInterruptURB);
1119
1120 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1121 return -ENOMEM;
1122 }
1123
1124
1125
1126 static int device_close(struct net_device *dev) {
1127 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1128 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1129
1130 int uu;
1131
1132 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1133 if (pDevice == NULL)
1134 return -ENODEV;
1135
1136 {
1137 union iwreq_data wrqu;
1138 memset(&wrqu, 0, sizeof(wrqu));
1139 wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1140 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1141 }
1142
1143 if (pDevice->bLinkPass) {
1144 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1145 mdelay(30);
1146 }
1147
1148 device_release_WPADEV(pDevice);
1149
1150 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1151 pMgmt->bShareKeyAlgorithm = FALSE;
1152 pDevice->bEncryptionEnable = FALSE;
1153 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1154 spin_lock_irq(&pDevice->lock);
1155 for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1156 MACvDisableKeyEntry(pDevice,uu);
1157 spin_unlock_irq(&pDevice->lock);
1158
1159 if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1160 MACbShutdown(pDevice);
1161 }
1162 netif_stop_queue(pDevice->dev);
1163 MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1164 MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1165 MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1166 pDevice->fKillEventPollingThread = TRUE;
1167 del_timer(&pDevice->sTimerCommand);
1168 del_timer(&pMgmt->sTimerSecondCallback);
1169
1170 del_timer(&pDevice->sTimerTxData);
1171
1172 if (pDevice->bDiversityRegCtlON) {
1173 del_timer(&pDevice->TimerSQ3Tmax1);
1174 del_timer(&pDevice->TimerSQ3Tmax2);
1175 del_timer(&pDevice->TimerSQ3Tmax3);
1176 }
1177 tasklet_kill(&pDevice->RxMngWorkItem);
1178 tasklet_kill(&pDevice->ReadWorkItem);
1179 tasklet_kill(&pDevice->EventWorkItem);
1180
1181 pDevice->bRoaming = FALSE;
1182 pDevice->bIsRoaming = FALSE;
1183 pDevice->bEnableRoaming = FALSE;
1184 pDevice->bCmdRunning = FALSE;
1185 pDevice->bLinkPass = FALSE;
1186 memset(pMgmt->abyCurrBSSID, 0, 6);
1187 pMgmt->eCurrState = WMAC_STATE_IDLE;
1188
1189 device_free_tx_bufs(pDevice);
1190 device_free_rx_bufs(pDevice);
1191 device_free_int_bufs(pDevice);
1192 device_free_frag_bufs(pDevice);
1193
1194 usb_kill_urb(pDevice->pControlURB);
1195 usb_kill_urb(pDevice->pInterruptURB);
1196 usb_free_urb(pDevice->pControlURB);
1197 usb_free_urb(pDevice->pInterruptURB);
1198
1199 BSSvClearNodeDBTable(pDevice, 0);
1200 pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1201
1202 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1203
1204 return 0;
1205 }
1206
1207 static void __devexit vt6656_disconnect(struct usb_interface *intf)
1208 {
1209 PSDevice device = usb_get_intfdata(intf);
1210
1211 if (!device)
1212 return;
1213
1214 {
1215 union iwreq_data req;
1216 memset(&req, 0, sizeof(req));
1217 req.data.flags = RT_RMMOD_EVENT_FLAG;
1218 wireless_send_event(device->dev, IWEVCUSTOM, &req, NULL);
1219 }
1220
1221 device_release_WPADEV(device);
1222 release_firmware(device->firmware);
1223
1224 usb_set_intfdata(intf, NULL);
1225 usb_put_dev(interface_to_usbdev(intf));
1226
1227 device->flags |= DEVICE_FLAGS_UNPLUG;
1228
1229 if (device->dev) {
1230 unregister_netdev(device->dev);
1231 wpa_set_wpadev(device, 0);
1232 free_netdev(device->dev);
1233 }
1234 }
1235
1236 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1237 {
1238 PSDevice pDevice = netdev_priv(dev);
1239
1240 spin_lock_irq(&pDevice->lock);
1241
1242 if (unlikely(pDevice->bStopTx0Pkt))
1243 dev_kfree_skb_irq(skb);
1244 else
1245 vDMA0_tx_80211(pDevice, skb);
1246
1247 spin_unlock_irq(&pDevice->lock);
1248
1249 return NETDEV_TX_OK;
1250 }
1251
1252 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1253 {
1254 PSDevice pDevice = netdev_priv(dev);
1255 struct net_device_stats *stats = &pDevice->stats;
1256
1257 spin_lock_irq(&pDevice->lock);
1258
1259 netif_stop_queue(dev);
1260
1261 if (!pDevice->bLinkPass) {
1262 dev_kfree_skb_irq(skb);
1263 goto out;
1264 }
1265
1266 if (pDevice->bStopDataPkt) {
1267 dev_kfree_skb_irq(skb);
1268 stats->tx_dropped++;
1269 goto out;
1270 }
1271
1272 if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1273 if (netif_queue_stopped(dev))
1274 netif_wake_queue(dev);
1275 }
1276
1277 out:
1278 spin_unlock_irq(&pDevice->lock);
1279
1280 return NETDEV_TX_OK;
1281 }
1282
1283 static unsigned const ethernet_polynomial = 0x04c11db7U;
1284 static inline u32 ether_crc(int length, unsigned char *data)
1285 {
1286 int crc = -1;
1287
1288 while(--length >= 0) {
1289 unsigned char current_octet = *data++;
1290 int bit;
1291 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1292 crc = (crc << 1) ^
1293 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1294 }
1295 }
1296 return crc;
1297 }
1298
1299 //find out the start position of str2 from str1
1300 static unsigned char *kstrstr(const unsigned char *str1,
1301 const unsigned char *str2) {
1302 int str1_len = strlen(str1);
1303 int str2_len = strlen(str2);
1304
1305 while (str1_len >= str2_len) {
1306 str1_len--;
1307 if(memcmp(str1,str2,str2_len)==0)
1308 return (unsigned char *) str1;
1309 str1++;
1310 }
1311 return NULL;
1312 }
1313
1314 static int Config_FileGetParameter(unsigned char *string,
1315 unsigned char *dest,
1316 unsigned char *source)
1317 {
1318 unsigned char buf1[100];
1319 unsigned char buf2[100];
1320 unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1321 int ii;
1322
1323 memset(buf1,0,100);
1324 strcat(buf1, string);
1325 strcat(buf1, "=");
1326 source+=strlen(buf1);
1327
1328 //find target string start point
1329 start_p = kstrstr(source,buf1);
1330 if (start_p == NULL)
1331 return FALSE;
1332
1333 //check if current config line is marked by "#" ??
1334 for (ii = 1; ; ii++) {
1335 if (memcmp(start_p - ii, "\n", 1) == 0)
1336 break;
1337 if (memcmp(start_p - ii, "#", 1) == 0)
1338 return FALSE;
1339 }
1340
1341 //find target string end point
1342 end_p = kstrstr(start_p,"\n");
1343 if (end_p == NULL) { //can't find "\n",but don't care
1344 end_p=start_p+strlen(start_p); //no include "\n"
1345 }
1346
1347 memset(buf2,0,100);
1348 memcpy(buf2,start_p,end_p-start_p); //get the target line
1349 buf2[end_p-start_p]='\0';
1350
1351 //find value
1352 start_p = kstrstr(buf2,"=");
1353 if (start_p == NULL)
1354 return FALSE;
1355 memset(buf1,0,100);
1356 strcpy(buf1,start_p+1);
1357
1358 //except space
1359 tmp_p = buf1;
1360 while(*tmp_p != 0x00) {
1361 if(*tmp_p==' ')
1362 tmp_p++;
1363 else
1364 break;
1365 }
1366
1367 memcpy(dest,tmp_p,strlen(tmp_p));
1368 return TRUE;
1369 }
1370
1371 //if read fail,return NULL,or return data pointer;
1372 static unsigned char *Config_FileOperation(PSDevice pDevice)
1373 {
1374 unsigned char *config_path = CONFIG_PATH;
1375 unsigned char *buffer = NULL;
1376 struct file *filp=NULL;
1377 mm_segment_t old_fs = get_fs();
1378 //int oldfsuid=0,oldfsgid=0;
1379 int result = 0;
1380
1381 set_fs (KERNEL_DS);
1382 /* Can't do this anymore, so we rely on correct filesystem permissions:
1383 //Make sure a caller can read or write power as root
1384 oldfsuid=current->fsuid;
1385 oldfsgid=current->fsgid;
1386 current->fsuid = 0;
1387 current->fsgid = 0;
1388 */
1389
1390 //open file
1391 filp = filp_open(config_path, O_RDWR, 0);
1392 if (IS_ERR(filp)) {
1393 printk("Config_FileOperation file Not exist\n");
1394 result=-1;
1395 goto error2;
1396 }
1397
1398 if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1399 printk("file %s is not read or writeable?\n",config_path);
1400 result = -1;
1401 goto error1;
1402 }
1403
1404 buffer = kmalloc(1024, GFP_KERNEL);
1405 if(buffer==NULL) {
1406 printk("allocate mem for file fail?\n");
1407 result = -1;
1408 goto error1;
1409 }
1410
1411 if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1412 printk("read file error?\n");
1413 result = -1;
1414 }
1415
1416 error1:
1417 if(filp_close(filp,NULL))
1418 printk("Config_FileOperation:close file fail\n");
1419
1420 error2:
1421 set_fs (old_fs);
1422
1423 /*
1424 current->fsuid=oldfsuid;
1425 current->fsgid=oldfsgid;
1426 */
1427
1428 if(result!=0) {
1429 kfree(buffer);
1430 buffer=NULL;
1431 }
1432 return buffer;
1433 }
1434
1435 //return --->-1:fail; >=0:successful
1436 static int Read_config_file(PSDevice pDevice) {
1437 int result = 0;
1438 unsigned char tmpbuffer[100];
1439 unsigned char *buffer = NULL;
1440
1441 //init config setting
1442 pDevice->config_file.ZoneType = -1;
1443 pDevice->config_file.eAuthenMode = -1;
1444 pDevice->config_file.eEncryptionStatus = -1;
1445
1446 buffer = Config_FileOperation(pDevice);
1447 if (buffer == NULL) {
1448 result =-1;
1449 return result;
1450 }
1451
1452 //get zonetype
1453 {
1454 memset(tmpbuffer,0,sizeof(tmpbuffer));
1455 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1456 if(memcmp(tmpbuffer,"USA",3)==0) {
1457 pDevice->config_file.ZoneType=ZoneType_USA;
1458 }
1459 else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1460 pDevice->config_file.ZoneType=ZoneType_Japan;
1461 }
1462 else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1463 pDevice->config_file.ZoneType=ZoneType_Europe;
1464 }
1465 else {
1466 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1467 }
1468 }
1469 }
1470
1471 //get other parameter
1472 {
1473 memset(tmpbuffer,0,sizeof(tmpbuffer));
1474 if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1475 pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1476 }
1477
1478 memset(tmpbuffer,0,sizeof(tmpbuffer));
1479 if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1480 pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1481 }
1482 }
1483
1484 kfree(buffer);
1485 return result;
1486 }
1487
1488 static void device_set_multi(struct net_device *dev) {
1489 PSDevice pDevice = (PSDevice) netdev_priv(dev);
1490 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1491 u32 mc_filter[2];
1492 int ii;
1493 struct netdev_hw_addr *ha;
1494 BYTE pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1495 BYTE byTmpMode = 0;
1496 int rc;
1497
1498
1499 spin_lock_irq(&pDevice->lock);
1500 rc = CONTROLnsRequestIn(pDevice,
1501 MESSAGE_TYPE_READ,
1502 MAC_REG_RCR,
1503 MESSAGE_REQUEST_MACREG,
1504 1,
1505 &byTmpMode
1506 );
1507 if (rc == 0) pDevice->byRxMode = byTmpMode;
1508
1509 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1510
1511 if (dev->flags & IFF_PROMISC) { // Set promiscuous.
1512 DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1513 // Unconditionally log net taps.
1514 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1515 }
1516 else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1517 (dev->flags & IFF_ALLMULTI)) {
1518 CONTROLnsRequestOut(pDevice,
1519 MESSAGE_TYPE_WRITE,
1520 MAC_REG_MAR0,
1521 MESSAGE_REQUEST_MACREG,
1522 8,
1523 pbyData
1524 );
1525 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1526 }
1527 else {
1528 memset(mc_filter, 0, sizeof(mc_filter));
1529 netdev_for_each_mc_addr(ha, dev) {
1530 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1531 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1532 }
1533 for (ii = 0; ii < 4; ii++) {
1534 MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1535 MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1536 }
1537 pDevice->byRxMode &= ~(RCR_UNICAST);
1538 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1539 }
1540
1541 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1542 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1543 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1544 pDevice->byRxMode &= ~(RCR_UNICAST);
1545 }
1546 ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1547 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1548 spin_unlock_irq(&pDevice->lock);
1549
1550 }
1551
1552
1553 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1554 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1555
1556 return &pDevice->stats;
1557 }
1558
1559
1560 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1561 PSDevice pDevice = (PSDevice)netdev_priv(dev);
1562 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1563 PSCmdRequest pReq;
1564 //BOOL bCommit = FALSE;
1565 struct iwreq *wrq = (struct iwreq *) rq;
1566 int rc =0;
1567
1568 if (pMgmt == NULL) {
1569 rc = -EFAULT;
1570 return rc;
1571 }
1572
1573 switch(cmd) {
1574
1575 case SIOCGIWNAME:
1576 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1577 break;
1578
1579 case SIOCSIWNWID:
1580 case SIOCGIWNWID: //0x8b03 support
1581 rc = -EOPNOTSUPP;
1582 break;
1583
1584 // Set frequency/channel
1585 case SIOCSIWFREQ:
1586 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1587 break;
1588
1589 // Get frequency/channel
1590 case SIOCGIWFREQ:
1591 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1592 break;
1593
1594 // Set desired network name (ESSID)
1595 case SIOCSIWESSID:
1596
1597 {
1598 char essid[IW_ESSID_MAX_SIZE+1];
1599 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1600 rc = -E2BIG;
1601 break;
1602 }
1603 if (copy_from_user(essid, wrq->u.essid.pointer,
1604 wrq->u.essid.length)) {
1605 rc = -EFAULT;
1606 break;
1607 }
1608 rc = iwctl_siwessid(dev, NULL,
1609 &(wrq->u.essid), essid);
1610 }
1611 break;
1612
1613
1614 // Get current network name (ESSID)
1615 case SIOCGIWESSID:
1616
1617 {
1618 char essid[IW_ESSID_MAX_SIZE+1];
1619 if (wrq->u.essid.pointer) {
1620 iwctl_giwessid(dev, NULL,
1621 &(wrq->u.essid), essid);
1622 if (copy_to_user(wrq->u.essid.pointer,
1623 essid,
1624 wrq->u.essid.length) )
1625 rc = -EFAULT;
1626 }
1627 }
1628 break;
1629
1630 case SIOCSIWAP:
1631
1632 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1633 break;
1634
1635
1636 // Get current Access Point (BSSID)
1637 case SIOCGIWAP:
1638 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1639 break;
1640
1641
1642 // Set desired station name
1643 case SIOCSIWNICKN:
1644 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1645 rc = -EOPNOTSUPP;
1646 break;
1647
1648 // Get current station name
1649 case SIOCGIWNICKN:
1650 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1651 rc = -EOPNOTSUPP;
1652 break;
1653
1654 // Set the desired bit-rate
1655 case SIOCSIWRATE:
1656 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1657 break;
1658
1659 // Get the current bit-rate
1660 case SIOCGIWRATE:
1661 iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1662 break;
1663
1664 // Set the desired RTS threshold
1665 case SIOCSIWRTS:
1666
1667 rc = iwctl_siwrts(dev, &(wrq->u.rts));
1668 break;
1669
1670 // Get the current RTS threshold
1671 case SIOCGIWRTS:
1672
1673 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1674 break;
1675
1676 // Set the desired fragmentation threshold
1677 case SIOCSIWFRAG:
1678
1679 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1680 break;
1681
1682 // Get the current fragmentation threshold
1683 case SIOCGIWFRAG:
1684
1685 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1686 break;
1687
1688 // Set mode of operation
1689 case SIOCSIWMODE:
1690 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1691 break;
1692
1693 // Get mode of operation
1694 case SIOCGIWMODE:
1695 iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1696 break;
1697
1698 // Set WEP keys and mode
1699 case SIOCSIWENCODE:
1700 {
1701 char abyKey[WLAN_WEP232_KEYLEN];
1702
1703 if (wrq->u.encoding.pointer) {
1704
1705
1706 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
1707 rc = -E2BIG;
1708 break;
1709 }
1710 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
1711 if (copy_from_user(abyKey,
1712 wrq->u.encoding.pointer,
1713 wrq->u.encoding.length)) {
1714 rc = -EFAULT;
1715 break;
1716 }
1717 } else if (wrq->u.encoding.length != 0) {
1718 rc = -EINVAL;
1719 break;
1720 }
1721 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1722 }
1723 break;
1724
1725 // Get the WEP keys and mode
1726 case SIOCGIWENCODE:
1727
1728 if (!capable(CAP_NET_ADMIN)) {
1729 rc = -EPERM;
1730 break;
1731 }
1732 {
1733 char abyKey[WLAN_WEP232_KEYLEN];
1734
1735 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1736 if (rc != 0) break;
1737 if (wrq->u.encoding.pointer) {
1738 if (copy_to_user(wrq->u.encoding.pointer,
1739 abyKey,
1740 wrq->u.encoding.length))
1741 rc = -EFAULT;
1742 }
1743 }
1744 break;
1745
1746 // Get the current Tx-Power
1747 case SIOCGIWTXPOW:
1748 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1749 rc = -EOPNOTSUPP;
1750 break;
1751
1752 case SIOCSIWTXPOW:
1753 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1754 rc = -EOPNOTSUPP;
1755 break;
1756
1757 case SIOCSIWRETRY:
1758
1759 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
1760 break;
1761
1762 case SIOCGIWRETRY:
1763
1764 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
1765 break;
1766
1767 // Get range of parameters
1768 case SIOCGIWRANGE:
1769
1770 {
1771 struct iw_range range;
1772
1773 iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
1774 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
1775 rc = -EFAULT;
1776 }
1777
1778 break;
1779
1780 case SIOCGIWPOWER:
1781
1782 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
1783 break;
1784
1785
1786 case SIOCSIWPOWER:
1787
1788 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
1789 break;
1790
1791
1792 case SIOCGIWSENS:
1793
1794 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
1795 break;
1796
1797 case SIOCSIWSENS:
1798 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
1799 rc = -EOPNOTSUPP;
1800 break;
1801
1802 case SIOCGIWAPLIST:
1803 {
1804 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
1805
1806 if (wrq->u.data.pointer) {
1807 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
1808 if (rc == 0) {
1809 if (copy_to_user(wrq->u.data.pointer,
1810 buffer,
1811 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality)))
1812 ))
1813 rc = -EFAULT;
1814 }
1815 }
1816 }
1817 break;
1818
1819
1820 #ifdef WIRELESS_SPY
1821 // Set the spy list
1822 case SIOCSIWSPY:
1823
1824 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1825 rc = -EOPNOTSUPP;
1826 break;
1827
1828 // Get the spy list
1829 case SIOCGIWSPY:
1830
1831 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1832 rc = -EOPNOTSUPP;
1833 break;
1834
1835 #endif // WIRELESS_SPY
1836
1837 case SIOCGIWPRIV:
1838 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
1839 rc = -EOPNOTSUPP;
1840 /*
1841 if(wrq->u.data.pointer) {
1842 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
1843
1844 if(copy_to_user(wrq->u.data.pointer,
1845 (u_char *) iwctl_private_args,
1846 sizeof(iwctl_private_args)))
1847 rc = -EFAULT;
1848 }
1849 */
1850 break;
1851
1852 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1853 case SIOCSIWAUTH:
1854 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH\n");
1855 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
1856 break;
1857
1858 case SIOCGIWAUTH:
1859 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
1860 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
1861 break;
1862
1863 case SIOCSIWGENIE:
1864 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
1865 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1866 break;
1867
1868 case SIOCGIWGENIE:
1869 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
1870 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1871 break;
1872
1873 case SIOCSIWENCODEEXT:
1874 {
1875 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
1876 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
1877 if(wrq->u.encoding.pointer){
1878 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
1879 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
1880 rc = -E2BIG;
1881 break;
1882 }
1883 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
1884 rc = -EFAULT;
1885 break;
1886 }
1887 }else if(wrq->u.encoding.length != 0){
1888 rc = -EINVAL;
1889 break;
1890 }
1891 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
1892 }
1893 break;
1894
1895 case SIOCGIWENCODEEXT:
1896 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
1897 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
1898 break;
1899
1900 case SIOCSIWMLME:
1901 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
1902 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1903 break;
1904
1905 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1906
1907 case IOCTL_CMD_TEST:
1908
1909 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1910 rc = -EFAULT;
1911 break;
1912 } else {
1913 rc = 0;
1914 }
1915 pReq = (PSCmdRequest)rq;
1916
1917 //20080130-01,<Remark> by Mike Liu
1918 // if(pDevice->bLinkPass==TRUE)
1919 pReq->wResult = MAGIC_CODE; //Linking status:0x3142
1920 //20080130-02,<Remark> by Mike Liu
1921 // else
1922 // pReq->wResult = MAGIC_CODE+1; //disconnect status:0x3143
1923 break;
1924
1925 case IOCTL_CMD_SET:
1926 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
1927 (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
1928 {
1929 rc = -EFAULT;
1930 break;
1931 } else {
1932 rc = 0;
1933 }
1934
1935 if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
1936 return -EBUSY;
1937 }
1938 rc = private_ioctl(pDevice, rq);
1939 clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
1940 break;
1941
1942 case IOCTL_CMD_HOSTAPD:
1943
1944 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1945 rc = -EFAULT;
1946 break;
1947 } else {
1948 rc = 0;
1949 }
1950
1951 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
1952 break;
1953
1954 case IOCTL_CMD_WPA:
1955
1956 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
1957 rc = -EFAULT;
1958 break;
1959 } else {
1960 rc = 0;
1961 }
1962
1963 rc = wpa_ioctl(pDevice, &wrq->u.data);
1964 break;
1965
1966 case SIOCETHTOOL:
1967 return ethtool_ioctl(dev, (void *) rq->ifr_data);
1968 // All other calls are currently unsupported
1969
1970 default:
1971 rc = -EOPNOTSUPP;
1972 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not supported..%x\n", cmd);
1973
1974
1975 }
1976
1977 if (pDevice->bCommit) {
1978 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1979 netif_stop_queue(pDevice->dev);
1980 spin_lock_irq(&pDevice->lock);
1981 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1982 spin_unlock_irq(&pDevice->lock);
1983 }
1984 else {
1985 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
1986 spin_lock_irq(&pDevice->lock);
1987 //2007-1121-01<Modify>by EinsnLiu
1988 if (pDevice->bLinkPass &&
1989 memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
1990 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1991 } else {
1992 pDevice->bLinkPass = FALSE;
1993 pMgmt->eCurrState = WMAC_STATE_IDLE;
1994 memset(pMgmt->abyCurrBSSID, 0, 6);
1995 }
1996 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
1997 //End Modify
1998 netif_stop_queue(pDevice->dev);
1999 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2000 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2001 if (!pDevice->bWPASuppWextEnabled)
2002 #endif
2003 bScheduleCommand((void *) pDevice,
2004 WLAN_CMD_BSSID_SCAN,
2005 pMgmt->abyDesireSSID);
2006 bScheduleCommand((void *) pDevice,
2007 WLAN_CMD_SSID,
2008 NULL);
2009 spin_unlock_irq(&pDevice->lock);
2010 }
2011 pDevice->bCommit = FALSE;
2012 }
2013
2014
2015 return rc;
2016 }
2017
2018
2019 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2020 {
2021 u32 ethcmd;
2022
2023 if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
2024 return -EFAULT;
2025
2026 switch (ethcmd) {
2027 case ETHTOOL_GDRVINFO: {
2028 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2029 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2030 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2031 if (copy_to_user(useraddr, &info, sizeof(info)))
2032 return -EFAULT;
2033 return 0;
2034 }
2035
2036 }
2037
2038 return -EOPNOTSUPP;
2039 }
2040
2041
2042 /*------------------------------------------------------------------*/
2043
2044 MODULE_DEVICE_TABLE(usb, vt6656_table);
2045
2046 static struct usb_driver vt6656_driver = {
2047 .name = DEVICE_NAME,
2048 .probe = vt6656_probe,
2049 .disconnect = vt6656_disconnect,
2050 .id_table = vt6656_table,
2051 #ifdef CONFIG_PM
2052 .suspend = vt6656_suspend,
2053 .resume = vt6656_resume,
2054 #endif /* CONFIG_PM */
2055 };
2056
2057 module_usb_driver(vt6656_driver);
kernel source for telekom puls (alcatel/mediatek)