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