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