?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
net: convert multicast list to list_head
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / staging / vt6656 / main_usb.c
blob49270db98fbb64d01225e3c3b1f2c8c789485c51
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 * vntwusb_found1 - 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
226
227 static struct usb_device_id vntwusb_table[] = {
228 {USB_DEVICE(VNT_USB_VENDOR_ID, VNT_USB_PRODUCT_ID)},
229 {}
230 };
231
232
233
234 // Frequency list (map channels to frequencies)
235 /*
236 static const long frequency_list[] = {
237 2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484,
238 4915, 4920, 4925, 4935, 4940, 4945, 4960, 4980,
239 5035, 5040, 5045, 5055, 5060, 5080, 5170, 5180, 5190, 5200, 5210, 5220, 5230, 5240,
240 5260, 5280, 5300, 5320, 5500, 5520, 5540, 5560, 5580, 5600, 5620, 5640, 5660, 5680,
241 5700, 5745, 5765, 5785, 5805, 5825
242 };
243
244
245 #ifndef IW_ENCODE_NOKEY
246 #define IW_ENCODE_NOKEY 0x0800
247 #define IW_ENCODE_MODE (IW_ENCODE_DISABLED | IW_ENCODE_RESTRICTED | IW_ENCODE_OPEN)
248 #endif
249
250 static const struct iw_handler_def iwctl_handler_def;
251 */
252
253
254
255 /*--------------------- Static Functions --------------------------*/
256 static int vntwusb_found1(struct usb_interface *intf, const struct usb_device_id *id);
257 static void vntwusb_disconnect(struct usb_interface *intf);
258 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
259 static int vntwusb_suspend(struct usb_interface *intf, pm_message_t message);
260 static int vntwusb_resume(struct usb_interface *intf);
261 #endif
262 static struct net_device_stats *device_get_stats(struct net_device *dev);
263 static int device_open(struct net_device *dev);
264 static int device_xmit(struct sk_buff *skb, struct net_device *dev);
265 static void device_set_multi(struct net_device *dev);
266 static int device_close(struct net_device *dev);
267 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
268
269 static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType);
270 static BOOL device_init_defrag_cb(PSDevice pDevice);
271 static void device_init_diversity_timer(PSDevice pDevice);
272 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
273
274 static int ethtool_ioctl(struct net_device *dev, void *useraddr);
275 static void device_free_tx_bufs(PSDevice pDevice);
276 static void device_free_rx_bufs(PSDevice pDevice);
277 static void device_free_int_bufs(PSDevice pDevice);
278 static void device_free_frag_bufs(PSDevice pDevice);
279 static BOOL device_alloc_bufs(PSDevice pDevice);
280
281 static int Read_config_file(PSDevice pDevice);
282 static UCHAR *Config_FileOperation(PSDevice pDevice);
283 static int Config_FileGetParameter(UCHAR *string, UCHAR *dest,UCHAR *source);
284
285 //2008-0714<Add>by Mike Liu
286 static BOOL device_release_WPADEV(PSDevice pDevice);
287
288 static void usb_device_reset(PSDevice pDevice);
289
290
291
292 /*--------------------- Export Variables --------------------------*/
293
294 /*--------------------- Export Functions --------------------------*/
295
296
297 static void
298 device_set_options(PSDevice pDevice) {
299
300 BYTE abyBroadcastAddr[U_ETHER_ADDR_LEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
301 BYTE abySNAP_RFC1042[U_ETHER_ADDR_LEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
302 BYTE abySNAP_Bridgetunnel[U_ETHER_ADDR_LEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
303
304
305 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, U_ETHER_ADDR_LEN);
306 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, U_ETHER_ADDR_LEN);
307 memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, U_ETHER_ADDR_LEN);
308
309 pDevice->cbTD = TX_DESC_DEF0;
310 pDevice->cbRD = RX_DESC_DEF0;
311 pDevice->uChannel = CHANNEL_DEF;
312 pDevice->wRTSThreshold = RTS_THRESH_DEF;
313 pDevice->wFragmentationThreshold = FRAG_THRESH_DEF;
314 pDevice->byShortRetryLimit = SHORT_RETRY_DEF;
315 pDevice->byLongRetryLimit = LONG_RETRY_DEF;
316 pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
317 pDevice->byShortPreamble = PREAMBLE_TYPE_DEF;
318 pDevice->ePSMode = PS_MODE_DEF;
319 pDevice->b11hEnable = X80211h_MODE_DEF;
320 pDevice->eOPMode = OP_MODE_DEF;
321 pDevice->uConnectionRate = DATA_RATE_DEF;
322 if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = TRUE;
323 pDevice->byBBType = BBP_TYPE_DEF;
324 pDevice->byPacketType = pDevice->byBBType;
325 pDevice->byAutoFBCtrl = AUTO_FB_0;
326 pDevice->bUpdateBBVGA = TRUE;
327 pDevice->byFOETuning = 0;
328 pDevice->byAutoPwrTunning = 0;
329 pDevice->wCTSDuration = 0;
330 pDevice->byPreambleType = 0;
331 pDevice->bExistSWNetAddr = FALSE;
332 // pDevice->bDiversityRegCtlON = TRUE;
333 pDevice->bDiversityRegCtlON = FALSE;
334 }
335
336
337 static VOID device_init_diversity_timer(PSDevice pDevice) {
338
339 init_timer(&pDevice->TimerSQ3Tmax1);
340 pDevice->TimerSQ3Tmax1.data = (ULONG)pDevice;
341 pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
342 pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
343
344 init_timer(&pDevice->TimerSQ3Tmax2);
345 pDevice->TimerSQ3Tmax2.data = (ULONG)pDevice;
346 pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
347 pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
348
349 init_timer(&pDevice->TimerSQ3Tmax3);
350 pDevice->TimerSQ3Tmax3.data = (ULONG)pDevice;
351 pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerSQ3Tmax3CallBack;
352 pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
353
354 return;
355 }
356
357
358 //
359 // Initialiation of MAC & BBP registers
360 //
361
362 static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType)
363 {
364 BYTE abyBroadcastAddr[U_ETHER_ADDR_LEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
365 BYTE abySNAP_RFC1042[U_ETHER_ADDR_LEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
366 BYTE abySNAP_Bridgetunnel[U_ETHER_ADDR_LEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
367 BYTE byAntenna;
368 UINT ii;
369 CMD_CARD_INIT sInitCmd;
370 NTSTATUS ntStatus = STATUS_SUCCESS;
371 RSP_CARD_INIT sInitRsp;
372 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
373 BYTE byTmp;
374 BYTE byCalibTXIQ = 0;
375 BYTE byCalibTXDC = 0;
376 BYTE byCalibRXIQ = 0;
377
378 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---->INIbInitAdapter. [%d][%d]\n", InitType, pDevice->byPacketType);
379 spin_lock_irq(&pDevice->lock);
380 if (InitType == DEVICE_INIT_COLD) {
381 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, U_ETHER_ADDR_LEN);
382 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, U_ETHER_ADDR_LEN);
383 memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, U_ETHER_ADDR_LEN);
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, pDevice->abyPermanentNetAddr, U_ETHER_ADDR_LEN);
609
610 // if exist SW network address, use SW network address.
611
612 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %02x-%02x-%02x=%02x-%02x-%02x\n",
613 pDevice->abyCurrentNetAddr[0],
614 pDevice->abyCurrentNetAddr[1],
615 pDevice->abyCurrentNetAddr[2],
616 pDevice->abyCurrentNetAddr[3],
617 pDevice->abyCurrentNetAddr[4],
618 pDevice->abyCurrentNetAddr[5]);
619 }
620
621
622
623 // Set BB and packet type at the same time.
624 // Set Short Slot Time, xIFS, and RSPINF.
625 if (pDevice->byBBType == BB_TYPE_11A) {
626 CARDbAddBasicRate(pDevice, RATE_6M);
627 pDevice->bShortSlotTime = TRUE;
628 } else {
629 CARDbAddBasicRate(pDevice, RATE_1M);
630 pDevice->bShortSlotTime = FALSE;
631 }
632 BBvSetShortSlotTime(pDevice);
633 CARDvSetBSSMode(pDevice);
634
635 if (pDevice->bUpdateBBVGA) {
636 pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
637 pDevice->byBBVGANew = pDevice->byBBVGACurrent;
638 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
639 }
640
641 pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];
642 pDevice->bHWRadioOff = FALSE;
643 if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) {
644 ntStatus = CONTROLnsRequestIn(pDevice,
645 MESSAGE_TYPE_READ,
646 MAC_REG_GPIOCTL1,
647 MESSAGE_REQUEST_MACREG,
648 1,
649 &byTmp);
650
651 if ( ntStatus != STATUS_SUCCESS ) {
652 spin_unlock_irq(&pDevice->lock);
653 return FALSE;
654 }
655 if ( (byTmp & GPIO3_DATA) == 0 ) {
656 pDevice->bHWRadioOff = TRUE;
657 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
658 } else {
659 MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
660 pDevice->bHWRadioOff = FALSE;
661 }
662
663 } //EEP_RADIOCTL_ENABLE
664
665 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
666 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
667 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01);
668
669 if ((pDevice->bHWRadioOff == TRUE) || (pDevice->bRadioControlOff == TRUE)) {
670 CARDbRadioPowerOff(pDevice);
671 } else {
672 CARDbRadioPowerOn(pDevice);
673 }
674
675 spin_unlock_irq(&pDevice->lock);
676 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");
677 return TRUE;
678 }
679
680 static BOOL device_release_WPADEV(PSDevice pDevice)
681 {
682 viawget_wpa_header *wpahdr;
683 int ii=0;
684 // wait_queue_head_t Set_wait;
685 //send device close to wpa_supplicnat layer
686 if (pDevice->bWPADEVUp==TRUE) {
687 wpahdr = (viawget_wpa_header *)pDevice->skb->data;
688 wpahdr->type = VIAWGET_DEVICECLOSE_MSG;
689 wpahdr->resp_ie_len = 0;
690 wpahdr->req_ie_len = 0;
691 skb_put(pDevice->skb, sizeof(viawget_wpa_header));
692 pDevice->skb->dev = pDevice->wpadev;
693 skb_reset_mac_header(pDevice->skb);
694 pDevice->skb->pkt_type = PACKET_HOST;
695 pDevice->skb->protocol = htons(ETH_P_802_2);
696 memset(pDevice->skb->cb, 0, sizeof(pDevice->skb->cb));
697 netif_rx(pDevice->skb);
698 pDevice->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
699
700 //wait release WPADEV
701 // init_waitqueue_head(&Set_wait);
702 // wait_event_timeout(Set_wait, ((pDevice->wpadev==NULL)&&(pDevice->skb == NULL)),5*HZ); //1s wait
703 while(pDevice->bWPADEVUp==TRUE) {
704 set_current_state(TASK_UNINTERRUPTIBLE);
705 schedule_timeout (HZ/20); //wait 50ms
706 ii++;
707 if(ii>20)
708 break;
709 }
710 };
711 return TRUE;
712 }
713
714 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
715 static int vntwusb_suspend(struct usb_interface *intf, pm_message_t message)
716 {
717 PSDevice pDevice = usb_get_intfdata(intf);
718 struct net_device *dev = pDevice->dev;
719
720 printk("VNTWUSB Suspend Start======>\n");
721 if(dev != NULL) {
722 if(pDevice->flags & DEVICE_FLAGS_OPENED)
723 device_close(dev);
724 }
725
726 usb_put_dev(interface_to_usbdev(intf));
727 return 0;
728 }
729
730 static int vntwusb_resume(struct usb_interface *intf)
731 {
732 PSDevice pDevice = usb_get_intfdata(intf);
733 struct net_device *dev = pDevice->dev;
734
735 printk("VNTWUSB Resume Start======>\n");
736 if(dev != NULL) {
737 usb_get_dev(interface_to_usbdev(intf));
738 if(!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
739 if(device_open(dev)!=0)
740 printk("VNTWUSB Resume Start======>open fail\n");
741 }
742 }
743 return 0;
744 }
745 #endif
746
747
748 static const struct net_device_ops device_netdev_ops = {
749 .ndo_open = device_open,
750 .ndo_stop = device_close,
751 .ndo_do_ioctl = device_ioctl,
752 .ndo_get_stats = device_get_stats,
753 .ndo_start_xmit = device_xmit,
754 .ndo_set_multicast_list = device_set_multi,
755 };
756
757
758 static int
759 vntwusb_found1(struct usb_interface *intf, const struct usb_device_id *id)
760 {
761 BYTE fake_mac[U_ETHER_ADDR_LEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};//fake MAC address
762 struct usb_device *udev = interface_to_usbdev(intf);
763 int rc = 0;
764 struct net_device *netdev = NULL;
765 PSDevice pDevice = NULL;
766
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
773 netdev = alloc_etherdev(sizeof(DEVICE_INFO));
774
775 if (netdev == NULL) {
776 printk(KERN_ERR DEVICE_NAME ": allocate net device failed \n");
777 kfree(pDevice);
778 goto err_nomem;
779 }
780
781 pDevice = netdev_priv(netdev);
782 memset(pDevice, 0, sizeof(DEVICE_INFO));
783
784 pDevice->dev = netdev;
785 pDevice->usb = udev;
786
787 // Set initial settings
788 device_set_options(pDevice);
789 spin_lock_init(&pDevice->lock);
790
791 pDevice->tx_80211 = device_dma0_tx_80211;
792 pDevice->sMgmtObj.pAdapter = (PVOID)pDevice;
793
794 netdev->netdev_ops = &device_netdev_ops;
795
796 netdev->wireless_handlers = (struct iw_handler_def *)&iwctl_handler_def;
797
798 //2008-0623-01<Remark>by MikeLiu
799 //2007-0821-01<Add>by MikeLiu
800 usb_set_intfdata(intf, pDevice);
801 SET_NETDEV_DEV(netdev, &intf->dev);
802 memcpy(pDevice->dev->dev_addr, fake_mac, U_ETHER_ADDR_LEN); //use fake mac address
803 rc = register_netdev(netdev);
804 if (rc != 0) {
805 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
806 free_netdev(netdev);
807 kfree(pDevice);
808 return -ENODEV;
809 }
810
811 //2008-07-21-01<Add>by MikeLiu
812 //register wpadev
813 #if 0
814 if(wpa_set_wpadev(pDevice, 1)!=0) {
815 printk("Fail to Register WPADEV?\n");
816 unregister_netdev(pDevice->dev);
817 free_netdev(netdev);
818 kfree(pDevice);
819 }
820 #endif
821 usb_device_reset(pDevice);
822
823 #ifdef SndEvt_ToAPI
824 {
825 union iwreq_data wrqu;
826 memset(&wrqu, 0, sizeof(wrqu));
827 wrqu.data.flags = RT_INSMOD_EVENT_FLAG;
828 wrqu.data.length =IFNAMSIZ;
829 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, pDevice->dev->name);
830 }
831 #endif
832
833 return 0;
834
835
836 err_nomem:
837 //2008-0922-01<Add>by MikeLiu, decrease usb counter.
838 usb_put_dev(udev);
839
840 return -ENOMEM;
841 }
842
843
844 static VOID device_free_tx_bufs(PSDevice pDevice) {
845 PUSB_SEND_CONTEXT pTxContext;
846 int ii;
847
848 for (ii = 0; ii < pDevice->cbTD; ii++) {
849
850 pTxContext = pDevice->apTD[ii];
851 //de-allocate URBs
852 if (pTxContext->pUrb) {
853 usb_kill_urb(pTxContext->pUrb);
854 usb_free_urb(pTxContext->pUrb);
855 }
856 if (pTxContext)
857 kfree(pTxContext);
858 }
859 return;
860 }
861
862
863 static VOID device_free_rx_bufs(PSDevice pDevice) {
864 PRCB pRCB;
865 int ii;
866
867 for (ii = 0; ii < pDevice->cbRD; ii++) {
868
869 pRCB = pDevice->apRCB[ii];
870 //de-allocate URBs
871 if (pRCB->pUrb) {
872 usb_kill_urb(pRCB->pUrb);
873 usb_free_urb(pRCB->pUrb);
874 }
875 //de-allocate skb
876 if (pRCB->skb)
877 dev_kfree_skb(pRCB->skb);
878 }
879 if (pDevice->pRCBMem)
880 kfree(pDevice->pRCBMem);
881
882 return;
883 }
884
885 //2007-1107-02<Add>by MikeLiu
886 static void usb_device_reset(PSDevice pDevice)
887 {
888 int status;
889 status = usb_reset_device(pDevice->usb);
890 if (status)
891 printk("usb_device_reset fail status=%d\n",status);
892 return ;
893 }
894
895 static VOID device_free_int_bufs(PSDevice pDevice) {
896
897 if (pDevice->intBuf.pDataBuf != NULL)
898 kfree(pDevice->intBuf.pDataBuf);
899 return;
900 }
901
902
903 static BOOL device_alloc_bufs(PSDevice pDevice) {
904
905 PUSB_SEND_CONTEXT pTxContext;
906 PRCB pRCB;
907 int ii;
908
909
910 for (ii = 0; ii < pDevice->cbTD; ii++) {
911
912 pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
913 if (pTxContext == NULL) {
914 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
915 goto free_tx;
916 }
917 pDevice->apTD[ii] = pTxContext;
918 pTxContext->pDevice = (PVOID) pDevice;
919 //allocate URBs
920 pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
921 if (pTxContext->pUrb == NULL) {
922 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
923 goto free_tx;
924 }
925 pTxContext->bBoolInUse = FALSE;
926 }
927
928 // allocate rcb mem
929 pDevice->pRCBMem = kmalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
930 if (pDevice->pRCBMem == NULL) {
931 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
932 goto free_tx;
933 }
934
935
936 pDevice->FirstRecvFreeList = NULL;
937 pDevice->LastRecvFreeList = NULL;
938 pDevice->FirstRecvMngList = NULL;
939 pDevice->LastRecvMngList = NULL;
940 pDevice->NumRecvFreeList = 0;
941 memset(pDevice->pRCBMem, 0, (sizeof(RCB) * pDevice->cbRD));
942 pRCB = (PRCB) pDevice->pRCBMem;
943
944 for (ii = 0; ii < pDevice->cbRD; ii++) {
945
946 pDevice->apRCB[ii] = pRCB;
947 pRCB->pDevice = (PVOID) pDevice;
948 //allocate URBs
949 pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
950
951 if (pRCB->pUrb == NULL) {
952 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
953 goto free_rx_tx;
954 }
955 pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
956 if (pRCB->skb == NULL) {
957 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
958 goto free_rx_tx;
959 }
960 pRCB->skb->dev = pDevice->dev;
961 pRCB->bBoolInUse = FALSE;
962 EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
963 pDevice->NumRecvFreeList++;
964 pRCB++;
965 }
966
967
968 pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
969 if (pDevice->pControlURB == NULL) {
970 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
971 goto free_rx_tx;
972 }
973
974 pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
975 if (pDevice->pInterruptURB == NULL) {
976 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
977 usb_kill_urb(pDevice->pControlURB);
978 usb_free_urb(pDevice->pControlURB);
979 goto free_rx_tx;
980 }
981
982 pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
983 if (pDevice->intBuf.pDataBuf == NULL) {
984 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
985 usb_kill_urb(pDevice->pControlURB);
986 usb_kill_urb(pDevice->pInterruptURB);
987 usb_free_urb(pDevice->pControlURB);
988 usb_free_urb(pDevice->pInterruptURB);
989 goto free_rx_tx;
990 }
991
992 return TRUE;
993
994 free_rx_tx:
995 device_free_rx_bufs(pDevice);
996
997 free_tx:
998 device_free_tx_bufs(pDevice);
999
1000 return FALSE;
1001 }
1002
1003
1004
1005
1006 static BOOL device_init_defrag_cb(PSDevice pDevice) {
1007 int i;
1008 PSDeFragControlBlock pDeF;
1009
1010 /* Init the fragment ctl entries */
1011 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1012 pDeF = &(pDevice->sRxDFCB[i]);
1013 if (!device_alloc_frag_buf(pDevice, pDeF)) {
1014 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
1015 pDevice->dev->name);
1016 goto free_frag;
1017 };
1018 }
1019 pDevice->cbDFCB = CB_MAX_RX_FRAG;
1020 pDevice->cbFreeDFCB = pDevice->cbDFCB;
1021 return TRUE;
1022
1023 free_frag:
1024 device_free_frag_bufs(pDevice);
1025 return FALSE;
1026 }
1027
1028
1029
1030 static void device_free_frag_bufs(PSDevice pDevice) {
1031 PSDeFragControlBlock pDeF;
1032 int i;
1033
1034 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
1035
1036 pDeF = &(pDevice->sRxDFCB[i]);
1037
1038 if (pDeF->skb)
1039 dev_kfree_skb(pDeF->skb);
1040 }
1041 }
1042
1043
1044
1045 BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
1046
1047 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
1048 if (pDeF->skb == NULL)
1049 return FALSE;
1050 ASSERT(pDeF->skb);
1051 pDeF->skb->dev = pDevice->dev;
1052
1053 return TRUE;
1054 }
1055
1056
1057 /*-----------------------------------------------------------------*/
1058
1059 static int device_open(struct net_device *dev) {
1060 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1061
1062 #ifdef WPA_SM_Transtatus
1063 extern SWPAResult wpa_Result;
1064 memset(wpa_Result.ifname,0,sizeof(wpa_Result.ifname));
1065 wpa_Result.proto = 0;
1066 wpa_Result.key_mgmt = 0;
1067 wpa_Result.eap_type = 0;
1068 wpa_Result.authenticated = FALSE;
1069 pDevice->fWPA_Authened = FALSE;
1070 #endif
1071
1072 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
1073
1074
1075 pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
1076
1077 if (device_alloc_bufs(pDevice) == FALSE) {
1078 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
1079 return -ENOMEM;
1080 }
1081
1082 if (device_init_defrag_cb(pDevice)== FALSE) {
1083 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragement cb fail \n");
1084 goto free_rx_tx;
1085 }
1086
1087 MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
1088 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
1089 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
1090 MP_SET_FLAG(pDevice, fMP_POST_READS);
1091 MP_SET_FLAG(pDevice, fMP_POST_WRITES);
1092
1093 //read config file
1094 Read_config_file(pDevice);
1095
1096 if (device_init_registers(pDevice, DEVICE_INIT_COLD) == FALSE) {
1097 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
1098 goto free_all;
1099 }
1100
1101 device_set_multi(pDevice->dev);
1102 // Init for Key Management
1103
1104 KeyvInitTable(pDevice,&pDevice->sKey);
1105 memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, U_ETHER_ADDR_LEN);
1106 memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, U_ETHER_ADDR_LEN);
1107 pDevice->bStopTx0Pkt = FALSE;
1108 pDevice->bStopDataPkt = FALSE;
1109 pDevice->bRoaming = FALSE; //DavidWang
1110 pDevice->bIsRoaming = FALSE;//DavidWang
1111 pDevice->bEnableRoaming = FALSE;
1112 if (pDevice->bDiversityRegCtlON) {
1113 device_init_diversity_timer(pDevice);
1114 }
1115
1116 vMgrObjectInit(pDevice);
1117 tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
1118 tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
1119 tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
1120 add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback));
1121 pDevice->int_interval = 100; //Max 100 microframes.
1122 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1123
1124 pDevice->bIsRxWorkItemQueued = TRUE;
1125 pDevice->fKillEventPollingThread = FALSE;
1126 pDevice->bEventAvailable = FALSE;
1127
1128 pDevice->bWPADEVUp = FALSE;
1129 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1130 pDevice->bwextstep0 = FALSE;
1131 pDevice->bwextstep1 = FALSE;
1132 pDevice->bwextstep2 = FALSE;
1133 pDevice->bwextstep3 = FALSE;
1134 pDevice->bWPASuppWextEnabled = FALSE;
1135 #endif
1136 pDevice->byReAssocCount = 0;
1137
1138 RXvWorkItem(pDevice);
1139 INTvWorkItem(pDevice);
1140
1141 // Patch: if WEP key already set by iwconfig but device not yet open
1142 if ((pDevice->bEncryptionEnable == TRUE) && (pDevice->bTransmitKey == TRUE)) {
1143 spin_lock_irq(&pDevice->lock);
1144 KeybSetDefaultKey( pDevice,
1145 &(pDevice->sKey),
1146 pDevice->byKeyIndex | (1 << 31),
1147 pDevice->uKeyLength,
1148 NULL,
1149 pDevice->abyKey,
1150 KEY_CTL_WEP
1151 );
1152 spin_unlock_irq(&pDevice->lock);
1153 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1154 }
1155
1156 if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
1157 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL);
1158 }
1159 else {
1160 //mike:mark@2008-11-10
1161 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1162 //bScheduleCommand((HANDLE)pDevice, WLAN_CMD_SSID, NULL);
1163 }
1164
1165
1166 netif_stop_queue(pDevice->dev);
1167 pDevice->flags |= DEVICE_FLAGS_OPENED;
1168
1169 #ifdef SndEvt_ToAPI
1170 {
1171 union iwreq_data wrqu;
1172 memset(&wrqu, 0, sizeof(wrqu));
1173 wrqu.data.flags = RT_UPDEV_EVENT_FLAG;
1174 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1175 }
1176 #endif
1177
1178 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1179 return 0;
1180
1181 free_all:
1182 device_free_frag_bufs(pDevice);
1183 free_rx_tx:
1184 device_free_rx_bufs(pDevice);
1185 device_free_tx_bufs(pDevice);
1186 device_free_int_bufs(pDevice);
1187 usb_kill_urb(pDevice->pControlURB);
1188 usb_kill_urb(pDevice->pInterruptURB);
1189 usb_free_urb(pDevice->pControlURB);
1190 usb_free_urb(pDevice->pInterruptURB);
1191
1192 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1193 return -ENOMEM;
1194 }
1195
1196
1197
1198 static int device_close(struct net_device *dev) {
1199 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1200 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1201
1202 int uu;
1203
1204 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1205 if (pDevice == NULL)
1206 return -ENODEV;
1207
1208 #ifdef SndEvt_ToAPI
1209 {
1210 union iwreq_data wrqu;
1211 memset(&wrqu, 0, sizeof(wrqu));
1212 wrqu.data.flags = RT_DOWNDEV_EVENT_FLAG;
1213 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1214 }
1215 #endif
1216
1217 //2007-1121-02<Add>by EinsnLiu
1218 if (pDevice->bLinkPass) {
1219 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1220 mdelay(30);
1221 }
1222 //End Add
1223
1224 //2008-0714-01<Add>by MikeLiu
1225 device_release_WPADEV(pDevice);
1226
1227 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1228 pMgmt->bShareKeyAlgorithm = FALSE;
1229 pDevice->bEncryptionEnable = FALSE;
1230 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1231 spin_lock_irq(&pDevice->lock);
1232 for(uu=0;uu<MAX_KEY_TABLE;uu++)
1233 MACvDisableKeyEntry(pDevice,uu);
1234 spin_unlock_irq(&pDevice->lock);
1235
1236 if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == FALSE) {
1237 MACbShutdown(pDevice);
1238 }
1239 netif_stop_queue(pDevice->dev);
1240 MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1241 MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1242 MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1243 pDevice->fKillEventPollingThread = TRUE;
1244 del_timer(&pDevice->sTimerCommand);
1245 del_timer(&pMgmt->sTimerSecondCallback);
1246
1247 //2007-0115-02<Add>by MikeLiu
1248 #ifdef TxInSleep
1249 del_timer(&pDevice->sTimerTxData);
1250 #endif
1251
1252 if (pDevice->bDiversityRegCtlON) {
1253 del_timer(&pDevice->TimerSQ3Tmax1);
1254 del_timer(&pDevice->TimerSQ3Tmax2);
1255 del_timer(&pDevice->TimerSQ3Tmax3);
1256 }
1257 tasklet_kill(&pDevice->RxMngWorkItem);
1258 tasklet_kill(&pDevice->ReadWorkItem);
1259 tasklet_kill(&pDevice->EventWorkItem);
1260
1261 pDevice->bRoaming = FALSE; //DavidWang
1262 pDevice->bIsRoaming = FALSE;//DavidWang
1263 pDevice->bEnableRoaming = FALSE;
1264 pDevice->bCmdRunning = FALSE;
1265 pDevice->bLinkPass = FALSE;
1266 memset(pMgmt->abyCurrBSSID, 0, 6);
1267 pMgmt->eCurrState = WMAC_STATE_IDLE;
1268
1269 device_free_tx_bufs(pDevice);
1270 device_free_rx_bufs(pDevice);
1271 device_free_int_bufs(pDevice);
1272 device_free_frag_bufs(pDevice);
1273
1274 usb_kill_urb(pDevice->pControlURB);
1275 usb_kill_urb(pDevice->pInterruptURB);
1276 usb_free_urb(pDevice->pControlURB);
1277 usb_free_urb(pDevice->pInterruptURB);
1278
1279 BSSvClearNodeDBTable(pDevice, 0);
1280 pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1281
1282 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1283
1284 return 0;
1285 }
1286
1287
1288 static void vntwusb_disconnect(struct usb_interface *intf)
1289
1290 {
1291
1292 PSDevice pDevice = usb_get_intfdata(intf);
1293
1294 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_disconnect1.. \n");
1295 if (pDevice == NULL)
1296 return;
1297
1298 #ifdef SndEvt_ToAPI
1299 {
1300 union iwreq_data wrqu;
1301 memset(&wrqu, 0, sizeof(wrqu));
1302 wrqu.data.flags = RT_RMMOD_EVENT_FLAG;
1303 wireless_send_event(pDevice->dev, IWEVCUSTOM, &wrqu, NULL);
1304 }
1305 #endif
1306
1307 //2008-0714-01<Add>by MikeLiu
1308 device_release_WPADEV(pDevice);
1309
1310 usb_set_intfdata(intf, NULL);
1311 //2008-0922-01<Add>by MikeLiu, decrease usb counter.
1312 usb_put_dev(interface_to_usbdev(intf));
1313
1314 pDevice->flags |= DEVICE_FLAGS_UNPLUG;
1315 if (pDevice->dev != NULL) {
1316 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "unregister_netdev..\n");
1317 unregister_netdev(pDevice->dev);
1318
1319 //2008-07-21-01<Add>by MikeLiu
1320 //unregister wpadev
1321 if(wpa_set_wpadev(pDevice, 0)!=0)
1322 printk("unregister wpadev fail?\n");
1323
1324 free_netdev(pDevice->dev);
1325 }
1326
1327 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_disconnect3.. \n");
1328 }
1329
1330
1331
1332
1333 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev) {
1334 PSDevice pDevice=netdev_priv(dev);
1335 PBYTE pbMPDU;
1336 UINT cbMPDULen = 0;
1337
1338
1339 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_dma0_tx_80211\n");
1340 spin_lock_irq(&pDevice->lock);
1341
1342 if (pDevice->bStopTx0Pkt == TRUE) {
1343 dev_kfree_skb_irq(skb);
1344 spin_unlock_irq(&pDevice->lock);
1345 return 0;
1346 };
1347
1348
1349 cbMPDULen = skb->len;
1350 pbMPDU = skb->data;
1351
1352 vDMA0_tx_80211(pDevice, skb);
1353
1354 spin_unlock_irq(&pDevice->lock);
1355
1356 return 0;
1357
1358 }
1359
1360
1361 static int device_xmit(struct sk_buff *skb, struct net_device *dev) {
1362 PSDevice pDevice=netdev_priv(dev);
1363 struct net_device_stats* pStats = &pDevice->stats;
1364
1365
1366 spin_lock_irq(&pDevice->lock);
1367
1368 netif_stop_queue(pDevice->dev);
1369
1370 if (pDevice->bLinkPass == FALSE) {
1371 dev_kfree_skb_irq(skb);
1372 spin_unlock_irq(&pDevice->lock);
1373 return 0;
1374 }
1375 if (pDevice->bStopDataPkt == TRUE) {
1376 dev_kfree_skb_irq(skb);
1377 pStats->tx_dropped++;
1378 spin_unlock_irq(&pDevice->lock);
1379 return 0;
1380 }
1381
1382 if(nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb) !=0) { //mike add:xmit fail!
1383 if (netif_queue_stopped(pDevice->dev))
1384 netif_wake_queue(pDevice->dev);
1385 }
1386
1387 spin_unlock_irq(&pDevice->lock);
1388
1389 return 0;
1390 }
1391
1392
1393
1394 static unsigned const ethernet_polynomial = 0x04c11db7U;
1395 static inline u32 ether_crc(int length, unsigned char *data)
1396 {
1397 int crc = -1;
1398
1399 while(--length >= 0) {
1400 unsigned char current_octet = *data++;
1401 int bit;
1402 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1403 crc = (crc << 1) ^
1404 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1405 }
1406 }
1407 return crc;
1408 }
1409
1410 //find out the start position of str2 from str1
1411 static UCHAR *kstrstr(const UCHAR *str1,const UCHAR *str2) {
1412 int str1_len=strlen(str1);
1413 int str2_len=strlen(str2);
1414
1415 while (str1_len >= str2_len) {
1416 str1_len--;
1417 if(memcmp(str1,str2,str2_len)==0)
1418 return (UCHAR *)str1;
1419 str1++;
1420 }
1421 return NULL;
1422 }
1423
1424 static int Config_FileGetParameter(UCHAR *string, UCHAR *dest,UCHAR *source)
1425 {
1426 UCHAR buf1[100];
1427 UCHAR buf2[100];
1428 UCHAR *start_p=NULL,*end_p=NULL,*tmp_p=NULL;
1429 int ii;
1430
1431 memset(buf1,0,100);
1432 strcat(buf1, string);
1433 strcat(buf1, "=");
1434 source+=strlen(buf1);
1435
1436 //find target string start point
1437 if((start_p = kstrstr(source,buf1))==NULL)
1438 return FALSE;
1439
1440 //check if current config line is marked by "#" ??
1441 for(ii=1;;ii++) {
1442 if(memcmp(start_p-ii,"\n",1)==0)
1443 break;
1444 if(memcmp(start_p-ii,"#",1)==0)
1445 return FALSE;
1446 }
1447
1448 //find target string end point
1449 if((end_p = kstrstr(start_p,"\n"))==NULL) { //cann't find "\n",but don't care
1450 end_p=start_p+strlen(start_p); //no include "\n"
1451 }
1452
1453 memset(buf2,0,100);
1454 memcpy(buf2,start_p,end_p-start_p); //get the tartget line
1455 buf2[end_p-start_p]='\0';
1456
1457 //find value
1458 if((start_p = kstrstr(buf2,"="))==NULL)
1459 return FALSE;
1460 memset(buf1,0,100);
1461 strcpy(buf1,start_p+1);
1462
1463 //except space
1464 tmp_p = buf1;
1465 while(*tmp_p != 0x00) {
1466 if(*tmp_p==' ')
1467 tmp_p++;
1468 else
1469 break;
1470 }
1471
1472 memcpy(dest,tmp_p,strlen(tmp_p));
1473 return TRUE;
1474 }
1475
1476 //if read fail,return NULL,or return data pointer;
1477 static UCHAR *Config_FileOperation(PSDevice pDevice) {
1478 UCHAR *config_path=CONFIG_PATH;
1479 UCHAR *buffer=NULL;
1480 struct file *filp=NULL;
1481 mm_segment_t old_fs = get_fs();
1482 //int oldfsuid=0,oldfsgid=0;
1483 int result=0;
1484
1485 set_fs (KERNEL_DS);
1486 /* Can't do this anymore, so we rely on correct filesystem permissions:
1487 //Make sure a caller can read or write power as root
1488 oldfsuid=current->fsuid;
1489 oldfsgid=current->fsgid;
1490 current->fsuid = 0;
1491 current->fsgid = 0;
1492 */
1493
1494 //open file
1495 filp = filp_open(config_path, O_RDWR, 0);
1496 if (IS_ERR(filp)) {
1497 printk("Config_FileOperation file Not exist\n");
1498 result=-1;
1499 goto error2;
1500 }
1501
1502 if(!(filp->f_op) || !(filp->f_op->read) ||!(filp->f_op->write)) {
1503 printk("file %s cann't readable or writable?\n",config_path);
1504 result = -1;
1505 goto error1;
1506 }
1507
1508 buffer = (UCHAR *)kmalloc(1024, GFP_KERNEL);
1509 if(buffer==NULL) {
1510 printk("alllocate mem for file fail?\n");
1511 result = -1;
1512 goto error1;
1513 }
1514
1515 if(filp->f_op->read(filp, buffer, 1024, &filp->f_pos)<0) {
1516 printk("read file error?\n");
1517 result = -1;
1518 }
1519
1520 error1:
1521 if(filp_close(filp,NULL))
1522 printk("Config_FileOperation:close file fail\n");
1523
1524 error2:
1525 set_fs (old_fs);
1526
1527 /*
1528 current->fsuid=oldfsuid;
1529 current->fsgid=oldfsgid;
1530 */
1531
1532 if(result!=0) {
1533 if(buffer)
1534 kfree(buffer);
1535 buffer=NULL;
1536 }
1537 return buffer;
1538 }
1539
1540 //return --->-1:fail; >=0:successful
1541 static int Read_config_file(PSDevice pDevice) {
1542 int result=0;
1543 UCHAR tmpbuffer[100];
1544 UCHAR *buffer=NULL;
1545
1546 //init config setting
1547 pDevice->config_file.ZoneType = -1;
1548 pDevice->config_file.eAuthenMode = -1;
1549 pDevice->config_file.eEncryptionStatus = -1;
1550
1551 if((buffer=Config_FileOperation(pDevice)) ==NULL) {
1552 result =-1;
1553 return result;
1554 }
1555
1556 //get zonetype
1557 {
1558 memset(tmpbuffer,0,sizeof(tmpbuffer));
1559 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==TRUE) {
1560 if(memcmp(tmpbuffer,"USA",3)==0) {
1561 pDevice->config_file.ZoneType=ZoneType_USA;
1562 }
1563 else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1564 pDevice->config_file.ZoneType=ZoneType_Japan;
1565 }
1566 else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1567 pDevice->config_file.ZoneType=ZoneType_Europe;
1568 }
1569 else {
1570 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1571 }
1572 }
1573 }
1574
1575 #if 1
1576 //get other parameter
1577 {
1578 memset(tmpbuffer,0,sizeof(tmpbuffer));
1579 if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==TRUE) {
1580 pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1581 }
1582
1583 memset(tmpbuffer,0,sizeof(tmpbuffer));
1584 if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==TRUE) {
1585 pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1586 }
1587 }
1588 #endif
1589
1590 kfree(buffer);
1591 return result;
1592 }
1593
1594 static void device_set_multi(struct net_device *dev) {
1595 PSDevice pDevice = (PSDevice) netdev_priv(dev);
1596 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1597 u32 mc_filter[2];
1598 int ii;
1599 struct netdev_hw_addr *ha;
1600 BYTE pbyData[8] = {0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
1601 BYTE byTmpMode = 0;
1602 int rc;
1603
1604
1605 spin_lock_irq(&pDevice->lock);
1606 rc = CONTROLnsRequestIn(pDevice,
1607 MESSAGE_TYPE_READ,
1608 MAC_REG_RCR,
1609 MESSAGE_REQUEST_MACREG,
1610 1,
1611 &byTmpMode
1612 );
1613 if (rc == 0) pDevice->byRxMode = byTmpMode;
1614
1615 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1616
1617 if (dev->flags & IFF_PROMISC) { // Set promiscuous.
1618 DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1619 // Unconditionally log net taps.
1620 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1621 }
1622 else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1623 (dev->flags & IFF_ALLMULTI)) {
1624 CONTROLnsRequestOut(pDevice,
1625 MESSAGE_TYPE_WRITE,
1626 MAC_REG_MAR0,
1627 MESSAGE_REQUEST_MACREG,
1628 8,
1629 pbyData
1630 );
1631 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1632 }
1633 else {
1634 memset(mc_filter, 0, sizeof(mc_filter));
1635 netdev_for_each_mc_addr(ha, dev) {
1636 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1637 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1638 }
1639 for (ii = 0; ii < 4; ii++) {
1640 MACvWriteMultiAddr(pDevice, ii, *((PBYTE)&mc_filter[0] + ii));
1641 MACvWriteMultiAddr(pDevice, ii+ 4, *((PBYTE)&mc_filter[1] + ii));
1642 }
1643 pDevice->byRxMode &= ~(RCR_UNICAST);
1644 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1645 }
1646
1647 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1648 // If AP mode, don't enable RCR_UNICAST. Since hw only compare addr1 with local mac.
1649 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1650 pDevice->byRxMode &= ~(RCR_UNICAST);
1651 }
1652 ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1653 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1654 spin_unlock_irq(&pDevice->lock);
1655
1656 }
1657
1658
1659 static struct net_device_stats *device_get_stats(struct net_device *dev) {
1660 PSDevice pDevice=(PSDevice) netdev_priv(dev);
1661
1662 return &pDevice->stats;
1663 }
1664
1665
1666 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1667 PSDevice pDevice = (PSDevice)netdev_priv(dev);
1668 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1669 PSCmdRequest pReq;
1670 //BOOL bCommit = FALSE;
1671 struct iwreq *wrq = (struct iwreq *) rq;
1672 int rc =0;
1673
1674 if (pMgmt == NULL) {
1675 rc = -EFAULT;
1676 return rc;
1677 }
1678
1679 switch(cmd) {
1680
1681 case SIOCGIWNAME:
1682 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1683 break;
1684
1685 case SIOCSIWNWID:
1686 rc = -EOPNOTSUPP;
1687 break;
1688
1689 case SIOCGIWNWID: //0x8b03 support
1690 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1691 rc = iwctl_giwnwid(dev, NULL, &(wrq->u.nwid), NULL);
1692 #else
1693 rc = -EOPNOTSUPP;
1694 #endif
1695 break;
1696
1697 // Set frequency/channel
1698 case SIOCSIWFREQ:
1699 rc = iwctl_siwfreq(dev, NULL, &(wrq->u.freq), NULL);
1700 break;
1701
1702 // Get frequency/channel
1703 case SIOCGIWFREQ:
1704 rc = iwctl_giwfreq(dev, NULL, &(wrq->u.freq), NULL);
1705 break;
1706
1707 // Set desired network name (ESSID)
1708 case SIOCSIWESSID:
1709
1710 {
1711 char essid[IW_ESSID_MAX_SIZE+1];
1712 if (wrq->u.essid.length > IW_ESSID_MAX_SIZE) {
1713 rc = -E2BIG;
1714 break;
1715 }
1716 if (copy_from_user(essid, wrq->u.essid.pointer,
1717 wrq->u.essid.length)) {
1718 rc = -EFAULT;
1719 break;
1720 }
1721 rc = iwctl_siwessid(dev, NULL,
1722 &(wrq->u.essid), essid);
1723 }
1724 break;
1725
1726
1727 // Get current network name (ESSID)
1728 case SIOCGIWESSID:
1729
1730 {
1731 char essid[IW_ESSID_MAX_SIZE+1];
1732 if (wrq->u.essid.pointer)
1733 rc = iwctl_giwessid(dev, NULL,
1734 &(wrq->u.essid), essid);
1735 if (copy_to_user(wrq->u.essid.pointer,
1736 essid,
1737 wrq->u.essid.length) )
1738 rc = -EFAULT;
1739 }
1740 break;
1741
1742 case SIOCSIWAP:
1743
1744 rc = iwctl_siwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1745 break;
1746
1747
1748 // Get current Access Point (BSSID)
1749 case SIOCGIWAP:
1750 rc = iwctl_giwap(dev, NULL, &(wrq->u.ap_addr), NULL);
1751 break;
1752
1753
1754 // Set desired station name
1755 case SIOCSIWNICKN:
1756 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWNICKN \n");
1757 rc = -EOPNOTSUPP;
1758 break;
1759
1760 // Get current station name
1761 case SIOCGIWNICKN:
1762 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWNICKN \n");
1763 rc = -EOPNOTSUPP;
1764 break;
1765
1766 // Set the desired bit-rate
1767 case SIOCSIWRATE:
1768 rc = iwctl_siwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1769 break;
1770
1771 // Get the current bit-rate
1772 case SIOCGIWRATE:
1773
1774 rc = iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
1775 break;
1776
1777 // Set the desired RTS threshold
1778 case SIOCSIWRTS:
1779
1780 rc = iwctl_siwrts(dev, NULL, &(wrq->u.rts), NULL);
1781 break;
1782
1783 // Get the current RTS threshold
1784 case SIOCGIWRTS:
1785
1786 rc = iwctl_giwrts(dev, NULL, &(wrq->u.rts), NULL);
1787 break;
1788
1789 // Set the desired fragmentation threshold
1790 case SIOCSIWFRAG:
1791
1792 rc = iwctl_siwfrag(dev, NULL, &(wrq->u.frag), NULL);
1793 break;
1794
1795 // Get the current fragmentation threshold
1796 case SIOCGIWFRAG:
1797
1798 rc = iwctl_giwfrag(dev, NULL, &(wrq->u.frag), NULL);
1799 break;
1800
1801 // Set mode of operation
1802 case SIOCSIWMODE:
1803 rc = iwctl_siwmode(dev, NULL, &(wrq->u.mode), NULL);
1804 break;
1805
1806 // Get mode of operation
1807 case SIOCGIWMODE:
1808 rc = iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
1809 break;
1810
1811 // Set WEP keys and mode
1812 case SIOCSIWENCODE:
1813 {
1814 char abyKey[WLAN_WEP232_KEYLEN];
1815
1816 if (wrq->u.encoding.pointer) {
1817
1818
1819 if (wrq->u.encoding.length > WLAN_WEP232_KEYLEN) {
1820 rc = -E2BIG;
1821 break;
1822 }
1823 memset(abyKey, 0, WLAN_WEP232_KEYLEN);
1824 if (copy_from_user(abyKey,
1825 wrq->u.encoding.pointer,
1826 wrq->u.encoding.length)) {
1827 rc = -EFAULT;
1828 break;
1829 }
1830 } else if (wrq->u.encoding.length != 0) {
1831 rc = -EINVAL;
1832 break;
1833 }
1834 rc = iwctl_siwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1835 }
1836 break;
1837
1838 // Get the WEP keys and mode
1839 case SIOCGIWENCODE:
1840
1841 if (!capable(CAP_NET_ADMIN)) {
1842 rc = -EPERM;
1843 break;
1844 }
1845 {
1846 char abyKey[WLAN_WEP232_KEYLEN];
1847
1848 rc = iwctl_giwencode(dev, NULL, &(wrq->u.encoding), abyKey);
1849 if (rc != 0) break;
1850 if (wrq->u.encoding.pointer) {
1851 if (copy_to_user(wrq->u.encoding.pointer,
1852 abyKey,
1853 wrq->u.encoding.length))
1854 rc = -EFAULT;
1855 }
1856 }
1857 break;
1858
1859 // Get the current Tx-Power
1860 case SIOCGIWTXPOW:
1861 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1862 rc = -EOPNOTSUPP;
1863 break;
1864
1865 case SIOCSIWTXPOW:
1866 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWTXPOW \n");
1867 rc = -EOPNOTSUPP;
1868 break;
1869
1870 case SIOCSIWRETRY:
1871
1872 rc = iwctl_siwretry(dev, NULL, &(wrq->u.retry), NULL);
1873 break;
1874
1875 case SIOCGIWRETRY:
1876
1877 rc = iwctl_giwretry(dev, NULL, &(wrq->u.retry), NULL);
1878 break;
1879
1880 // Get range of parameters
1881 case SIOCGIWRANGE:
1882
1883 {
1884 struct iw_range range;
1885
1886 rc = iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
1887 if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
1888 rc = -EFAULT;
1889 }
1890
1891 break;
1892
1893 case SIOCGIWPOWER:
1894
1895 rc = iwctl_giwpower(dev, NULL, &(wrq->u.power), NULL);
1896 break;
1897
1898
1899 case SIOCSIWPOWER:
1900
1901 rc = iwctl_siwpower(dev, NULL, &(wrq->u.power), NULL);
1902 break;
1903
1904
1905 case SIOCGIWSENS:
1906
1907 rc = iwctl_giwsens(dev, NULL, &(wrq->u.sens), NULL);
1908 break;
1909
1910 case SIOCSIWSENS:
1911 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSENS \n");
1912 rc = -EOPNOTSUPP;
1913 break;
1914
1915 case SIOCGIWAPLIST:
1916 {
1917 char buffer[IW_MAX_AP * (sizeof(struct sockaddr) + sizeof(struct iw_quality))];
1918
1919 if (wrq->u.data.pointer) {
1920 rc = iwctl_giwaplist(dev, NULL, &(wrq->u.data), buffer);
1921 if (rc == 0) {
1922 if (copy_to_user(wrq->u.data.pointer,
1923 buffer,
1924 (wrq->u.data.length * (sizeof(struct sockaddr) + sizeof(struct iw_quality)))
1925 ))
1926 rc = -EFAULT;
1927 }
1928 }
1929 }
1930 break;
1931
1932
1933 #ifdef WIRELESS_SPY
1934 // Set the spy list
1935 case SIOCSIWSPY:
1936
1937 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1938 rc = -EOPNOTSUPP;
1939 break;
1940
1941 // Get the spy list
1942 case SIOCGIWSPY:
1943
1944 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWSPY \n");
1945 rc = -EOPNOTSUPP;
1946 break;
1947
1948 #endif // WIRELESS_SPY
1949
1950 case SIOCGIWPRIV:
1951 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWPRIV \n");
1952 rc = -EOPNOTSUPP;
1953 /*
1954 if(wrq->u.data.pointer) {
1955 wrq->u.data.length = sizeof(iwctl_private_args) / sizeof( iwctl_private_args[0]);
1956
1957 if(copy_to_user(wrq->u.data.pointer,
1958 (u_char *) iwctl_private_args,
1959 sizeof(iwctl_private_args)))
1960 rc = -EFAULT;
1961 }
1962 */
1963 break;
1964
1965
1966 //2008-0409-07, <Add> by Einsn Liu
1967 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1968 case SIOCSIWAUTH:
1969 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH \n");
1970 rc = iwctl_siwauth(dev, NULL, &(wrq->u.param), NULL);
1971 break;
1972
1973 case SIOCGIWAUTH:
1974 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWAUTH \n");
1975 rc = iwctl_giwauth(dev, NULL, &(wrq->u.param), NULL);
1976 break;
1977
1978 case SIOCSIWGENIE:
1979 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWGENIE \n");
1980 rc = iwctl_siwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1981 break;
1982
1983 case SIOCGIWGENIE:
1984 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWGENIE \n");
1985 rc = iwctl_giwgenie(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
1986 break;
1987
1988 case SIOCSIWENCODEEXT:
1989 {
1990 char extra[sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1];
1991 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWENCODEEXT \n");
1992 if(wrq->u.encoding.pointer){
1993 memset(extra, 0, sizeof(struct iw_encode_ext)+MAX_KEY_LEN+1);
1994 if(wrq->u.encoding.length > (sizeof(struct iw_encode_ext)+ MAX_KEY_LEN)){
1995 rc = -E2BIG;
1996 break;
1997 }
1998 if(copy_from_user(extra, wrq->u.encoding.pointer,wrq->u.encoding.length)){
1999 rc = -EFAULT;
2000 break;
2001 }
2002 }else if(wrq->u.encoding.length != 0){
2003 rc = -EINVAL;
2004 break;
2005 }
2006 rc = iwctl_siwencodeext(dev, NULL, &(wrq->u.encoding), extra);
2007 }
2008 break;
2009
2010 case SIOCGIWENCODEEXT:
2011 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCGIWENCODEEXT \n");
2012 rc = iwctl_giwencodeext(dev, NULL, &(wrq->u.encoding), NULL);
2013 break;
2014
2015 case SIOCSIWMLME:
2016 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWMLME \n");
2017 rc = iwctl_siwmlme(dev, NULL, &(wrq->u.data), wrq->u.data.pointer);
2018 break;
2019
2020 #endif // #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2021 //End Add -- //2008-0409-07, <Add> by Einsn Liu
2022
2023 case IOCTL_CMD_TEST:
2024
2025 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2026 rc = -EFAULT;
2027 break;
2028 } else {
2029 rc = 0;
2030 }
2031 pReq = (PSCmdRequest)rq;
2032
2033 //20080130-01,<Remark> by Mike Liu
2034 // if(pDevice->bLinkPass==TRUE)
2035 pReq->wResult = MAGIC_CODE; //Linking status:0x3142
2036 //20080130-02,<Remark> by Mike Liu
2037 // else
2038 // pReq->wResult = MAGIC_CODE+1; //disconnect status:0x3143
2039 break;
2040
2041 case IOCTL_CMD_SET:
2042 if (!(pDevice->flags & DEVICE_FLAGS_OPENED) &&
2043 (((PSCmdRequest)rq)->wCmdCode !=WLAN_CMD_SET_WPA))
2044 {
2045 rc = -EFAULT;
2046 break;
2047 } else {
2048 rc = 0;
2049 }
2050
2051 if (test_and_set_bit( 0, (void*)&(pMgmt->uCmdBusy))) {
2052 return -EBUSY;
2053 }
2054 rc = private_ioctl(pDevice, rq);
2055 clear_bit( 0, (void*)&(pMgmt->uCmdBusy));
2056 break;
2057
2058 case IOCTL_CMD_HOSTAPD:
2059
2060 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2061 rc = -EFAULT;
2062 break;
2063 } else {
2064 rc = 0;
2065 }
2066
2067 rc = hostap_ioctl(pDevice, &wrq->u.data);
2068 break;
2069
2070 case IOCTL_CMD_WPA:
2071
2072 if (!(pDevice->flags & DEVICE_FLAGS_OPENED)) {
2073 rc = -EFAULT;
2074 break;
2075 } else {
2076 rc = 0;
2077 }
2078
2079 rc = wpa_ioctl(pDevice, &wrq->u.data);
2080 break;
2081
2082 case SIOCETHTOOL:
2083 return ethtool_ioctl(dev, (void *) rq->ifr_data);
2084 // All other calls are currently unsupported
2085
2086 default:
2087 rc = -EOPNOTSUPP;
2088 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not support..%x\n", cmd);
2089
2090
2091 }
2092
2093 if (pDevice->bCommit) {
2094 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
2095 netif_stop_queue(pDevice->dev);
2096 spin_lock_irq(&pDevice->lock);
2097 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_RUN_AP, NULL);
2098 spin_unlock_irq(&pDevice->lock);
2099 }
2100 else {
2101 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Commit the settings\n");
2102 spin_lock_irq(&pDevice->lock);
2103 //2007-1121-01<Modify>by EinsnLiu
2104 if (pDevice->bLinkPass&&
2105 memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
2106 bScheduleCommand((HANDLE)pDevice, WLAN_CMD_DISASSOCIATE, NULL);
2107 } else {
2108 pDevice->bLinkPass = FALSE;
2109 pMgmt->eCurrState = WMAC_STATE_IDLE;
2110 memset(pMgmt->abyCurrBSSID, 0, 6);
2111 }
2112 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
2113 //End Modify
2114 netif_stop_queue(pDevice->dev);
2115 #ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2116 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
2117 if(pDevice->bWPASuppWextEnabled !=TRUE)
2118 #endif
2119 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_BSSID_SCAN, pMgmt->abyDesireSSID);
2120 bScheduleCommand((HANDLE) pDevice, WLAN_CMD_SSID, NULL);
2121 spin_unlock_irq(&pDevice->lock);
2122 }
2123 pDevice->bCommit = FALSE;
2124 }
2125
2126
2127 return rc;
2128 }
2129
2130
2131 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
2132 {
2133 u32 ethcmd;
2134
2135 if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
2136 return -EFAULT;
2137
2138 switch (ethcmd) {
2139 case ETHTOOL_GDRVINFO: {
2140 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
2141 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
2142 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
2143 if (copy_to_user(useraddr, &info, sizeof(info)))
2144 return -EFAULT;
2145 return 0;
2146 }
2147
2148 }
2149
2150 return -EOPNOTSUPP;
2151 }
2152
2153
2154 /*------------------------------------------------------------------*/
2155
2156
2157 MODULE_DEVICE_TABLE(usb, vntwusb_table);
2158
2159
2160 static struct usb_driver vntwusb_driver = {
2161 .name = DEVICE_NAME,
2162 .probe = vntwusb_found1,
2163 .disconnect = vntwusb_disconnect,
2164 .id_table = vntwusb_table,
2165
2166 //2008-0920-01<Add>by MikeLiu
2167 //for supporting S3 & S4 function
2168 #ifdef CONFIG_PM
2169 .suspend = vntwusb_suspend,
2170 .resume = vntwusb_resume,
2171 #endif
2172 };
2173
2174 static int __init vntwusb_init_module(void)
2175 {
2176 printk(KERN_NOTICE DEVICE_FULL_DRV_NAM " " DEVICE_VERSION);
2177 return usb_register(&vntwusb_driver);
2178 }
2179
2180 static void __exit vntwusb_cleanup_module(void)
2181 {
2182 usb_deregister(&vntwusb_driver);
2183 }
2184
2185 module_init(vntwusb_init_module);
2186 module_exit(vntwusb_cleanup_module);
2187
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree