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