net: convert multicast list to list_head
[linux-2.6.git] / drivers / staging / vt6656 / main_usb.c
1 /*
2  * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
3  * All rights reserved.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License along
16  * with this program; if not, write to the Free Software Foundation, Inc.,
17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18  *
19  * File: main_usb.c
20  *
21  * Purpose: driver entry for initial, open, close, tx and rx.
22  *
23  * Author: Lyndon Chen
24  *
25  * Date: Dec 8, 2005
26  *
27  * Functions:
28  *
29  *   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