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