projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'asoc-3.7' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/sound...
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / vt6656 / main_usb.c
CommitLineData
92b96797
FB		 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 *
26e5b65b 29 * vt6656_probe - module initial (insmod) driver entry
92b96797
FB		 30 * device_remove1 - module remove entry
31 * device_open - allocate dma/descripter resource & initial mac/bbp function
a0a1f61a 32 * device_xmit - asynchronous data tx function
92b96797
FB		 33 * device_set_multi - set mac filter
34 * device_ioctl - ioctl entry
a0a1f61a 35 * device_close - shutdown mac/bbp & free dma/descriptor resource
92b96797
FB		 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
a0a1f61a 39 * device_dma0_xmit- tx PS buffered frame via dma0
92b96797
FB		 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
92b96797 49#include "device.h"
92b96797 50#include "card.h"
92b96797 51#include "baseband.h"
92b96797 52#include "mac.h"
92b96797 53#include "tether.h"
92b96797 54#include "wmgr.h"
92b96797 55#include "wctl.h"
92b96797 56#include "power.h"
92b96797 57#include "wcmd.h"
92b96797 58#include "iocmd.h"
92b96797 59#include "tcrc.h"
92b96797 60#include "rxtx.h"
92b96797 61#include "bssdb.h"
92b96797 62#include "hostap.h"
92b96797 63#include "wpactl.h"
92b96797 64#include "ioctl.h"
92b96797 65#include "iwctl.h"
92b96797 66#include "dpc.h"
92b96797 67#include "datarate.h"
92b96797 68#include "rf.h"
92b96797 69#include "firmware.h"
92b96797 70#include "rndis.h"
92b96797 71#include "control.h"
92b96797 72#include "channel.h"
92b96797 73#include "int.h"
92b96797 74#include "iowpa.h"
92b96797
FB		 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
92b96797
FB		 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
92b96797
FB		 95#define RX_DESC_DEF0 64
96DEVICE_PARAM(RxDescriptors0,"Number of receive usb desc buffer");
97
98
92b96797
FB		 99#define TX_DESC_DEF0 64
100DEVICE_PARAM(TxDescriptors0,"Number of transmit usb desc buffer");
101
92b96797 102#define CHANNEL_DEF 6
92b96797
FB		 103DEVICE_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
113DEVICE_PARAM(PreambleType, "Preamble Type");
114
92b96797 115#define RTS_THRESH_DEF 2347
92b96797
FB		 116DEVICE_PARAM(RTSThreshold, "RTS threshold");
117
92b96797 118#define FRAG_THRESH_DEF 2346
92b96797
FB		 119DEVICE_PARAM(FragThreshold, "Fragmentation threshold");
120
121
92b96797
FB		 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
140DEVICE_PARAM(ConnectionRate, "Connection data rate");
141
92b96797 142#define OP_MODE_DEF 0
92b96797
FB		 143DEVICE_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
92b96797
FB		 158DEVICE_PARAM(PSMode, "Power saving mode");
159
160
92b96797 161#define SHORT_RETRY_DEF 8
92b96797
FB		 162DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits");
163
92b96797 164#define LONG_RETRY_DEF 4
92b96797
FB		 165DEVICE_PARAM(LongRetryLimit, "long frame retry limits");
166
92b96797
FB		 167/* BasebandType[] baseband type selected
168 0: indicate 802.11a type
169 1: indicate 802.11b type
170 2: indicate 802.11g type
171*/
92b96797 172
24b46f9e 173#define BBP_TYPE_DEF 2
92b96797
FB		 174DEVICE_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
185DEVICE_PARAM(b80211hEnable, "802.11h mode");
186
187
188//
189// Static vars definitions
190//
191
4d088876 192static struct usb_device_id vt6656_table[] = {
92b96797
FB		 193 {USB_DEVICE(VNT_USB_VENDOR_ID, VNT_USB_PRODUCT_ID)},
194 {}
195};
196
92b96797
FB		 197// Frequency list (map channels to frequencies)
198/*
199static 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
92b96797 208static const struct iw_handler_def iwctl_handler_def;
92b96797
FB		 209*/
210
26e5b65b 211/*--------------------- Static Functions --------------------------*/
92b96797 212
26e5b65b
AM		 213static int vt6656_probe(struct usb_interface *intf,
214 const struct usb_device_id *id);
215static void vt6656_disconnect(struct usb_interface *intf);
92b96797 216
92b96797 217#ifdef CONFIG_PM /* Minimal support for suspend and resume */
26e5b65b
AM		 218static int vt6656_suspend(struct usb_interface *intf, pm_message_t message);
219static int vt6656_resume(struct usb_interface *intf);
220#endif /* CONFIG_PM */
221
92b96797
FB		 222static struct net_device_stats *device_get_stats(struct net_device *dev);
223static int device_open(struct net_device *dev);
224static int device_xmit(struct sk_buff *skb, struct net_device *dev);
225static void device_set_multi(struct net_device *dev);
226static int device_close(struct net_device *dev);
227static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
228
229static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType);
230static BOOL device_init_defrag_cb(PSDevice pDevice);
231static void device_init_diversity_timer(PSDevice pDevice);
232static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
233
234static int ethtool_ioctl(struct net_device *dev, void *useraddr);
235static void device_free_tx_bufs(PSDevice pDevice);
236static void device_free_rx_bufs(PSDevice pDevice);
237static void device_free_int_bufs(PSDevice pDevice);
238static void device_free_frag_bufs(PSDevice pDevice);
239static BOOL device_alloc_bufs(PSDevice pDevice);
240
241static int Read_config_file(PSDevice pDevice);
cc856e61
AM		 242static unsigned char *Config_FileOperation(PSDevice pDevice);
243static int Config_FileGetParameter(unsigned char *string,
244 unsigned char *dest,
245 unsigned char *source);
92b96797 246
92b96797
FB		 247static BOOL device_release_WPADEV(PSDevice pDevice);
248
92b96797 249static void usb_device_reset(PSDevice pDevice);
92b96797
FB		 250
251
252
253/*--------------------- Export Variables --------------------------*/
254
255/*--------------------- Export Functions --------------------------*/
256
257
258static void
259device_set_options(PSDevice pDevice) {
260
9a0e756c
AM		 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};
92b96797 264
9a0e756c
AM		 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);
92b96797
FB		 268
269 pDevice->cbTD = TX_DESC_DEF0;
270 pDevice->cbRD = RX_DESC_DEF0;
271 pDevice->uChannel = CHANNEL_DEF;
272 pDevice->wRTSThreshold = RTS_THRESH_DEF;
273 pDevice->wFragmentationThreshold = FRAG_THRESH_DEF;
274 pDevice->byShortRetryLimit = SHORT_RETRY_DEF;
275 pDevice->byLongRetryLimit = LONG_RETRY_DEF;
276 pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
277 pDevice->byShortPreamble = PREAMBLE_TYPE_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
8611a29a
AM		 297static void device_init_diversity_timer(PSDevice pDevice)
298{
92b96797 299 init_timer(&pDevice->TimerSQ3Tmax1);
cc856e61 300 pDevice->TimerSQ3Tmax1.data = (unsigned long)pDevice;
92b96797
FB		 301 pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
302 pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
303
304 init_timer(&pDevice->TimerSQ3Tmax2);
cc856e61 305 pDevice->TimerSQ3Tmax2.data = (unsigned long)pDevice;
92b96797
FB		 306 pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
307 pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
308
309 init_timer(&pDevice->TimerSQ3Tmax3);
cc856e61 310 pDevice->TimerSQ3Tmax3.data = (unsigned long)pDevice;
92b96797
FB		 311 pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerSQ3Tmax3CallBack;
312 pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
313
314 return;
315}
316
317
318//
a0a1f61a 319// Initialization of MAC & BBP registers
92b96797
FB		 320//
321
322static BOOL device_init_registers(PSDevice pDevice, DEVICE_INIT_TYPE InitType)
323{
9a0e756c
AM		 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};
92b96797 327 BYTE byAntenna;
cc856e61 328 unsigned int ii;
92b96797 329 CMD_CARD_INIT sInitCmd;
6487c49e 330 int ntStatus = STATUS_SUCCESS;
92b96797
FB		 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);
9a0e756c
AM		 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);
92b96797
FB		 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;
33d33e42
AM		 371 for (ii = 0; ii < 6; ii++)
372 sInitCmd.bySWNetAddr[ii] = pDevice->abyCurrentNetAddr[ii];
92b96797
FB		 373 sInitCmd.byShortRetryLimit = pDevice->byShortRetryLimit;
374 sInitCmd.byLongRetryLimit = pDevice->byLongRetryLimit;
375
376 //issue Card_init command to device
377 ntStatus = CONTROLnsRequestOut(pDevice,
378 MESSAGE_TYPE_CARDINIT,
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,
401 MESSAGE_TYPE_READ,
402 MAC_REG_LOCALID,
403 MESSAGE_REQUEST_MACREG,
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)) {
33d33e42
AM		 451 for (ii = 11; ii < 14; ii++) {
452 pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];
453 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];
454 }
92b96797
FB		 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
3e362598 569 memcpy(pDevice->abyPermanentNetAddr,&(sInitRsp.byNetAddr[0]),6);
9a0e756c
AM		 570 memcpy(pDevice->abyCurrentNetAddr,
571 pDevice->abyPermanentNetAddr,
572 ETH_ALEN);
92b96797
FB		 573
574 // if exist SW network address, use SW network address.
575
d6a32aa1
AS		 576 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %pM\n",
577 pDevice->abyCurrentNetAddr);
92b96797
FB		 578 }
579
92b96797
FB		 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,
602 MESSAGE_TYPE_READ,
603 MAC_REG_GPIOCTL1,
604 MESSAGE_REQUEST_MACREG,
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;
614 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
615 } else {
616 MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
617 pDevice->bHWRadioOff = FALSE;
618 }
619
620 } //EEP_RADIOCTL_ENABLE
621
622 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
623 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
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
637static BOOL device_release_WPADEV(PSDevice pDevice)
638{
639 viawget_wpa_header *wpahdr;
640 int ii=0;
641 // wait_queue_head_t Set_wait;
a0a1f61a 642 //send device close to wpa_supplicant layer
92b96797
FB		 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;
d899d403 650 skb_reset_mac_header(pDevice->skb);
92b96797
FB		 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) {
661 set_current_state(TASK_UNINTERRUPTIBLE);
662 schedule_timeout (HZ/20); //wait 50ms
663 ii++;
664 if(ii>20)
665 break;
666 }
9fc86028 667 }
92b96797
FB		 668 return TRUE;
669}
670
671#ifdef CONFIG_PM /* Minimal support for suspend and resume */
26e5b65b
AM		 672
673static int vt6656_suspend(struct usb_interface *intf, pm_message_t message)
92b96797 674{
e54d9eb9 675 PSDevice device = usb_get_intfdata(intf);
92b96797 676
e54d9eb9
AM		 677 if (!device || !device->dev)
678 return -ENODEV;
679
680 if (device->flags & DEVICE_FLAGS_OPENED)
681 device_close(device->dev);
92b96797 682
e54d9eb9
AM		 683 usb_put_dev(interface_to_usbdev(intf));
684
685 return 0;
92b96797
FB		 686}
687
26e5b65b 688static int vt6656_resume(struct usb_interface *intf)
92b96797 689{
e54d9eb9
AM		 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;
92b96797 701}
92b96797 702
26e5b65b 703#endif /* CONFIG_PM */
dd8db704
FB		 704
705static 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,
afc4b13d 711 .ndo_set_rx_mode = device_set_multi,
dd8db704
FB		 712};
713
26e5b65b
AM		 714static int __devinit
715vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
92b96797 716{
9a0e756c 717 u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
92b96797 718 struct usb_device *udev = interface_to_usbdev(intf);
7a8b0055
AM		 719 int rc = 0;
720 struct net_device *netdev = NULL;
721 PSDevice pDevice = NULL;
92b96797 722
7a8b0055
AM		 723 printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
724 printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
92b96797 725
7a8b0055
AM		 726 udev = usb_get_dev(udev);
727 netdev = alloc_etherdev(sizeof(DEVICE_INFO));
7a8b0055
AM		 728 if (!netdev) {
729 printk(KERN_ERR DEVICE_NAME ": allocate net device failed\n");
e3a92cde 730 rc = -ENOMEM;
7a8b0055
AM		 731 goto err_nomem;
732 }
1e28efa3 733
7a8b0055
AM		 734 pDevice = netdev_priv(netdev);
735 memset(pDevice, 0, sizeof(DEVICE_INFO));
92b96797 736
7a8b0055
AM		 737 pDevice->dev = netdev;
738 pDevice->usb = udev;
92b96797 739
7a8b0055
AM		 740 device_set_options(pDevice);
741 spin_lock_init(&pDevice->lock);
92b96797 742
7a8b0055
AM		 743 pDevice->tx_80211 = device_dma0_tx_80211;
744 pDevice->sMgmtObj.pAdapter = (void *) pDevice;
dd8db704 745
7a8b0055
AM		 746 netdev->netdev_ops = &device_netdev_ops;
747 netdev->wireless_handlers =
748 (struct iw_handler_def *) &iwctl_handler_def;
92b96797 749
7a8b0055 750 usb_set_intfdata(intf, pDevice);
92b96797 751 SET_NETDEV_DEV(netdev, &intf->dev);
7a8b0055
AM		 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");
e3a92cde 756 goto err_netdev;
7a8b0055 757 }
92b96797 758
7a8b0055 759 usb_device_reset(pDevice);
92b96797 760
7a8b0055
AM		 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 }
92b96797
FB		 771
772 return 0;
92b96797 773
e3a92cde
DC		 774err_netdev:
775 free_netdev(netdev);
92b96797 776err_nomem:
7a8b0055 777 usb_put_dev(udev);
92b96797 778
e3a92cde 779 return rc;
92b96797
FB		 780}
781
8611a29a
AM		 782static void device_free_tx_bufs(PSDevice pDevice)
783{
92b96797
FB		 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) {
dad72fed 792 usb_kill_urb(pTxContext->pUrb);
92b96797
FB		 793 usb_free_urb(pTxContext->pUrb);
794 }
1d5c536e 795 kfree(pTxContext);
92b96797
FB		 796 }
797 return;
798}
799
800
8611a29a
AM		 801static void device_free_rx_bufs(PSDevice pDevice)
802{
92b96797
FB		 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) {
dad72fed 811 usb_kill_urb(pRCB->pUrb);
92b96797
FB		 812 usb_free_urb(pRCB->pUrb);
813 }
814 //de-allocate skb
815 if (pRCB->skb)
816 dev_kfree_skb(pRCB->skb);
817 }
1d5c536e 818 kfree(pDevice->pRCBMem);
92b96797
FB		 819
820 return;
821}
822
92b96797
FB		 823static 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}
92b96797 831
8611a29a
AM		 832static void device_free_int_bufs(PSDevice pDevice)
833{
1d5c536e 834 kfree(pDevice->intBuf.pDataBuf);
92b96797
FB		 835 return;
836}
837
838
839static 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;
8611a29a 854 pTxContext->pDevice = (void *) pDevice;
92b96797 855 //allocate URBs
dad72fed 856 pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
92b96797
FB		 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
ac31e9e8 865 pDevice->pRCBMem = kzalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
92b96797
FB		 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;
92b96797
FB		 877 pRCB = (PRCB) pDevice->pRCBMem;
878
879 for (ii = 0; ii < pDevice->cbRD; ii++) {
880
881 pDevice->apRCB[ii] = pRCB;
8611a29a 882 pRCB->pDevice = (void *) pDevice;
92b96797 883 //allocate URBs
dad72fed 884 pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
92b96797
FB		 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
dad72fed 903 pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
92b96797
FB		 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
dad72fed 909 pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
92b96797
FB		 910 if (pDevice->pInterruptURB == NULL) {
911 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
92b96797
FB		 912 usb_free_urb(pDevice->pControlURB);
913 goto free_rx_tx;
914 }
915
916 pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
917 if (pDevice->intBuf.pDataBuf == NULL) {
918 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
92b96797
FB		 919 usb_free_urb(pDevice->pControlURB);
920 usb_free_urb(pDevice->pInterruptURB);
921 goto free_rx_tx;
922 }
923
924 return TRUE;
925
926free_rx_tx:
927 device_free_rx_bufs(pDevice);
928
929free_tx:
930 device_free_tx_bufs(pDevice);
931
932 return FALSE;
933}
934
935
936
937
938static BOOL device_init_defrag_cb(PSDevice pDevice) {
939 int i;
940 PSDeFragControlBlock pDeF;
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;
9fc86028 949 }
92b96797
FB		 950 }
951 pDevice->cbDFCB = CB_MAX_RX_FRAG;
952 pDevice->cbFreeDFCB = pDevice->cbDFCB;
953 return TRUE;
954
955free_frag:
956 device_free_frag_bufs(pDevice);
957 return FALSE;
958}
959
960
961
962static void device_free_frag_bufs(PSDevice pDevice) {
963 PSDeFragControlBlock pDeF;
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
977BOOL device_alloc_frag_buf(PSDevice pDevice, PSDeFragControlBlock pDeF) {
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
991static int device_open(struct net_device *dev) {
1e28efa3 992 PSDevice pDevice=(PSDevice) netdev_priv(dev);
92b96797 993
92b96797
FB		 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;
92b96797
FB		 1001
1002 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
1003
1004
1005 pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
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) {
a0a1f61a 1013 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragment cb fail \n");
92b96797
FB		 1014 goto free_rx_tx;
1015 }
1016
1017 MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
1018 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
1019 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
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);
9a0e756c
AM		 1035 memcpy(pDevice->sMgmtObj.abyMACAddr, pDevice->abyCurrentNetAddr, ETH_ALEN);
1036 memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
92b96797
FB		 1037 pDevice->bStopTx0Pkt = FALSE;
1038 pDevice->bStopDataPkt = FALSE;
465711b3
AM		 1039 pDevice->bRoaming = FALSE;
1040 pDevice->bIsRoaming = FALSE;
92b96797
FB		 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);
1050 add_timer(&(pDevice->sMgmtObj.sTimerSecondCallback));
92b96797 1051 pDevice->int_interval = 100; //Max 100 microframes.
92b96797
FB		 1052 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
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);
1083 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1084 }
1085
1086 if (pDevice->sMgmtObj.eConfigMode == WMAC_CONFIG_AP) {
0cbd8d98 1087 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
92b96797
FB		 1088 }
1089 else {
1090 //mike:mark@2008-11-10
0cbd8d98
AM		 1091 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1092 /* bScheduleCommand((void *) pDevice, WLAN_CMD_SSID, NULL); */
92b96797
FB		 1093 }
1094
1095
1096 netif_stop_queue(pDevice->dev);
1097 pDevice->flags |= DEVICE_FLAGS_OPENED;
1098
92b96797
FB		 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}
92b96797
FB		 1105
1106 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success.. \n");
1107 return 0;
1108
1109free_all:
1110 device_free_frag_bufs(pDevice);
1111free_rx_tx:
1112 device_free_rx_bufs(pDevice);
1113 device_free_tx_bufs(pDevice);
1114 device_free_int_bufs(pDevice);
dad72fed
JL		 1115 usb_kill_urb(pDevice->pControlURB);
1116 usb_kill_urb(pDevice->pInterruptURB);
92b96797
FB		 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
1126static int device_close(struct net_device *dev) {
1e28efa3 1127 PSDevice pDevice=(PSDevice) netdev_priv(dev);
92b96797
FB		 1128 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1129
92b96797 1130 int uu;
92b96797
FB		 1131
1132 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1 \n");
1133 if (pDevice == NULL)
1134 return -ENODEV;
1135
92b96797
FB		 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}
92b96797 1142
92b96797 1143 if (pDevice->bLinkPass) {
0cbd8d98 1144 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
92b96797
FB		 1145 mdelay(30);
1146 }
92b96797 1147
92b96797
FB		 1148device_release_WPADEV(pDevice);
1149
92b96797
FB		 1150 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1151 pMgmt->bShareKeyAlgorithm = FALSE;
1152 pDevice->bEncryptionEnable = FALSE;
1153 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
33d33e42
AM		 1154 spin_lock_irq(&pDevice->lock);
1155 for (uu = 0; uu < MAX_KEY_TABLE; uu++)
92b96797 1156 MACvDisableKeyEntry(pDevice,uu);
33d33e42 1157 spin_unlock_irq(&pDevice->lock);
92b96797
FB		 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);
1168 del_timer(&pMgmt->sTimerSecondCallback);
1169
92b96797 1170 del_timer(&pDevice->sTimerTxData);
92b96797
FB		 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
465711b3
AM		 1181 pDevice->bRoaming = FALSE;
1182 pDevice->bIsRoaming = FALSE;
92b96797
FB		 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
dad72fed
JL		 1194 usb_kill_urb(pDevice->pControlURB);
1195 usb_kill_urb(pDevice->pInterruptURB);
92b96797
FB		 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
26e5b65b 1207static void __devexit vt6656_disconnect(struct usb_interface *intf)
92b96797 1208{
6cda24f5 1209 PSDevice device = usb_get_intfdata(intf);
92b96797 1210
6cda24f5
AM		 1211 if (!device)
1212 return;
92b96797 1213
6cda24f5
AM		 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 }
92b96797 1220
6cda24f5 1221 device_release_WPADEV(device);
a6c8ef95 1222 release_firmware(device->firmware);
31d5bbf3 1223
92b96797 1224 usb_set_intfdata(intf, NULL);
6cda24f5 1225 usb_put_dev(interface_to_usbdev(intf));
92b96797 1226
6cda24f5 1227 device->flags |= DEVICE_FLAGS_UNPLUG;
92b96797 1228
6cda24f5
AM		 1229 if (device->dev) {
1230 unregister_netdev(device->dev);
1231 wpa_set_wpadev(device, 0);
1232 free_netdev(device->dev);
1233 }
92b96797
FB		 1234}
1235
e1669ed0
AM		 1236static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1237{
1238 PSDevice pDevice = netdev_priv(dev);
92b96797 1239
e1669ed0 1240 spin_lock_irq(&pDevice->lock);
92b96797 1241
e1669ed0
AM		 1242 if (unlikely(pDevice->bStopTx0Pkt))
1243 dev_kfree_skb_irq(skb);
1244 else
1245 vDMA0_tx_80211(pDevice, skb);
92b96797 1246
e1669ed0 1247 spin_unlock_irq(&pDevice->lock);
92b96797 1248
e1669ed0 1249 return NETDEV_TX_OK;
92b96797
FB		 1250}
1251
529e5b32
AM		 1252static 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;
92b96797 1256
529e5b32 1257 spin_lock_irq(&pDevice->lock);
92b96797 1258
529e5b32 1259 netif_stop_queue(dev);
92b96797 1260
529e5b32
AM		 1261 if (!pDevice->bLinkPass) {
1262 dev_kfree_skb_irq(skb);
1263 goto out;
1264 }
92b96797 1265
529e5b32
AM		 1266 if (pDevice->bStopDataPkt) {
1267 dev_kfree_skb_irq(skb);
1268 stats->tx_dropped++;
1269 goto out;
1270 }
92b96797 1271
529e5b32
AM		 1272 if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1273 if (netif_queue_stopped(dev))
1274 netif_wake_queue(dev);
1275 }
92b96797 1276
529e5b32
AM		 1277out:
1278 spin_unlock_irq(&pDevice->lock);
92b96797 1279
529e5b32 1280 return NETDEV_TX_OK;
92b96797
FB		 1281}
1282
92b96797
FB		 1283static unsigned const ethernet_polynomial = 0x04c11db7U;
1284static 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
a0a1f61a 1299//find out the start position of str2 from str1
cc856e61
AM		 1300static unsigned char *kstrstr(const unsigned char *str1,
1301 const unsigned char *str2) {
1302 int str1_len = strlen(str1);
1303 int str2_len = strlen(str2);
92b96797
FB		 1304
1305 while (str1_len >= str2_len) {
1306 str1_len--;
1307 if(memcmp(str1,str2,str2_len)==0)
cc856e61 1308 return (unsigned char *) str1;
92b96797
FB		 1309 str1++;
1310 }
1311 return NULL;
1312}
1313
cc856e61
AM		 1314static int Config_FileGetParameter(unsigned char *string,
1315 unsigned char *dest,
1316 unsigned char *source)
92b96797 1317{
cc856e61
AM		 1318 unsigned char buf1[100];
1319 unsigned char buf2[100];
1320 unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
92b96797
FB		 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
bfbfeecc
JP		 1329 start_p = kstrstr(source,buf1);
1330 if (start_p == NULL)
92b96797
FB		 1331 return FALSE;
1332
1333//check if current config line is marked by "#" ??
33d33e42
AM		 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 }
92b96797
FB		 1340
1341//find target string end point
bfbfeecc
JP		 1342 end_p = kstrstr(start_p,"\n");
1343 if (end_p == NULL) { //can't find "\n",but don't care
92b96797
FB		 1344 end_p=start_p+strlen(start_p); //no include "\n"
1345 }
1346
1347 memset(buf2,0,100);
a0a1f61a 1348 memcpy(buf2,start_p,end_p-start_p); //get the target line
92b96797
FB		 1349 buf2[end_p-start_p]='\0';
1350
1351 //find value
bfbfeecc
JP		 1352 start_p = kstrstr(buf2,"=");
1353 if (start_p == NULL)
92b96797
FB		 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;
cc856e61
AM		 1372static unsigned char *Config_FileOperation(PSDevice pDevice)
1373{
1374 unsigned char *config_path = CONFIG_PATH;
1375 unsigned char *buffer = NULL;
92b96797
FB		 1376 struct file *filp=NULL;
1377 mm_segment_t old_fs = get_fs();
8f9c466f 1378 //int oldfsuid=0,oldfsgid=0;
cc856e61 1379 int result = 0;
92b96797
FB		 1380
1381 set_fs (KERNEL_DS);
8f9c466f
FB		 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;
92b96797
FB		 1386 current->fsuid = 0;
1387 current->fsgid = 0;
8f9c466f 1388 */
92b96797
FB		 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)) {
a0a1f61a 1399 printk("file %s is not read or writeable?\n",config_path);
92b96797
FB		 1400 result = -1;
1401 goto error1;
1402 }
1403
32414878 1404 buffer = kmalloc(1024, GFP_KERNEL);
92b96797 1405 if(buffer==NULL) {
682a4538 1406 printk("allocate mem for file fail?\n");
92b96797
FB		 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
1416error1:
1417 if(filp_close(filp,NULL))
1418 printk("Config_FileOperation:close file fail\n");
1419
1420error2:
1421 set_fs (old_fs);
8f9c466f
FB		 1422
1423 /*
92b96797
FB		 1424 current->fsuid=oldfsuid;
1425 current->fsgid=oldfsgid;
8f9c466f 1426 */
92b96797
FB		 1427
1428if(result!=0) {
1d5c536e 1429 kfree(buffer);
92b96797
FB		 1430 buffer=NULL;
1431}
1432 return buffer;
1433}
1434
bbc9a991 1435//return --->-1:fail; >=0:successful
92b96797 1436static int Read_config_file(PSDevice pDevice) {
cc856e61
AM		 1437 int result = 0;
1438 unsigned char tmpbuffer[100];
1439 unsigned char *buffer = NULL;
92b96797
FB		 1440
1441 //init config setting
1442 pDevice->config_file.ZoneType = -1;
1443 pDevice->config_file.eAuthenMode = -1;
1444 pDevice->config_file.eEncryptionStatus = -1;
1445
bfbfeecc
JP		 1446 buffer = Config_FileOperation(pDevice);
1447 if (buffer == NULL) {
92b96797
FB		 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) {
1457 pDevice->config_file.ZoneType=ZoneType_USA;
1458 }
1459 else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1460 pDevice->config_file.ZoneType=ZoneType_Japan;
1461 }
1462 else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1463 pDevice->config_file.ZoneType=ZoneType_Europe;
1464 }
1465 else {
1466 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1467 }
1468 }
1469}
1470
92b96797
FB		 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 }
92b96797
FB		 1483
1484 kfree(buffer);
1485 return result;
1486}
1487
1488static void device_set_multi(struct net_device *dev) {
1e28efa3 1489 PSDevice pDevice = (PSDevice) netdev_priv(dev);
92b96797
FB		 1490 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1491 u32 mc_filter[2];
1492 int ii;
22bedad3 1493 struct netdev_hw_addr *ha;
92b96797
FB		 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,
1501 MESSAGE_TYPE_READ,
1502 MAC_REG_RCR,
1503 MESSAGE_REQUEST_MACREG,
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.
1514 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1515 }
4cd24eaf
JP		 1516 else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1517 (dev->flags & IFF_ALLMULTI)) {
92b96797
FB		 1518 CONTROLnsRequestOut(pDevice,
1519 MESSAGE_TYPE_WRITE,
1520 MAC_REG_MAR0,
1521 MESSAGE_REQUEST_MACREG,
1522 8,
1523 pbyData
1524 );
1525 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1526 }
1527 else {
1528 memset(mc_filter, 0, sizeof(mc_filter));
22bedad3
JP		 1529 netdev_for_each_mc_addr(ha, dev) {
1530 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
92b96797
FB		 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 }
1546 ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
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
1553static struct net_device_stats *device_get_stats(struct net_device *dev) {
1e28efa3 1554 PSDevice pDevice=(PSDevice) netdev_priv(dev);
92b96797
FB		 1555
1556 return &pDevice->stats;
1557}
1558
1559
1560static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) {
1e28efa3 1561 PSDevice pDevice = (PSDevice)netdev_priv(dev);
92b96797
FB		 1562 PSMgmtObject pMgmt = &(pDevice->sMgmtObj);
1563 PSCmdRequest pReq;
1564 //BOOL bCommit = FALSE;
92b96797
FB		 1565 struct iwreq *wrq = (struct iwreq *) rq;
1566 int rc =0;
92b96797
FB		 1567
1568 if (pMgmt == NULL) {
1569 rc = -EFAULT;
1570 return rc;
1571 }
1572
1573 switch(cmd) {
1574
92b96797
FB		 1575 case SIOCGIWNAME:
1576 rc = iwctl_giwname(dev, NULL, (char *)&(wrq->u.name), NULL);
1577 break;
1578
1579 case SIOCSIWNWID:
92b96797 1580 case SIOCGIWNWID: //0x8b03 support
428c1fb5 1581 rc = -EOPNOTSUPP;
92b96797
FB		 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];
eacd121c 1619 if (wrq->u.essid.pointer) {
caa20de8
MPS		 1620 iwctl_giwessid(dev, NULL,
1621 &(wrq->u.essid), essid);
92b96797
FB		 1622 if (copy_to_user(wrq->u.essid.pointer,
1623 essid,
1624 wrq->u.essid.length) )
1625 rc = -EFAULT;
eacd121c 1626 }
92b96797
FB		 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:
739ea076 1661 iwctl_giwrate(dev, NULL, &(wrq->u.bitrate), NULL);
92b96797
FB		 1662 break;
1663
1664 // Set the desired RTS threshold
1665 case SIOCSIWRTS:
1666
2fdde902 1667 rc = iwctl_siwrts(dev, &(wrq->u.rts));
92b96797
FB		 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:
5d11b173 1695 iwctl_giwmode(dev, NULL, &(wrq->u.mode), NULL);
92b96797
FB		 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
92b96797
FB		 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
92b96797
FB		 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
92b96797
FB		 1767 // Get range of parameters
1768 case SIOCGIWRANGE:
1769
1770 {
1771 struct iw_range range;
1772
f9b9f934 1773 iwctl_giwrange(dev, NULL, &(wrq->u.data), (char *) &range);
92b96797
FB		 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
92b96797
FB		 1852#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
1853 case SIOCSIWAUTH:
465711b3 1854 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " SIOCSIWAUTH\n");
92b96797
FB		 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
92b96797 1906
92b96797
FB		 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
c30d7973 1951 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
92b96797
FB		 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
92b96797 1963 rc = wpa_ioctl(pDevice, &wrq->u.data);
92b96797
FB		 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;
a0a1f61a 1972 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Ioctl command not supported..%x\n", cmd);
92b96797
FB		 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);
0cbd8d98 1981 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
92b96797
FB		 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
0cbd8d98 1988 if (pDevice->bLinkPass &&
92b96797 1989 memcmp(pMgmt->abyCurrSSID,pMgmt->abyDesireSSID,WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN)) {
0cbd8d98 1990 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
92b96797
FB		 1991 } else {
1992 pDevice->bLinkPass = FALSE;
1993 pMgmt->eCurrState = WMAC_STATE_IDLE;
1994 memset(pMgmt->abyCurrBSSID, 0, 6);
1995 }
1996 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
1997//End Modify
1998 netif_stop_queue(pDevice->dev);
1999#ifdef WPA_SUPPLICANT_DRIVER_WEXT_SUPPORT
2000 pMgmt->eScanType = WMAC_SCAN_ACTIVE;
0cbd8d98 2001 if (!pDevice->bWPASuppWextEnabled)
92b96797 2002#endif
0cbd8d98
AM		 2003 bScheduleCommand((void *) pDevice,
2004 WLAN_CMD_BSSID_SCAN,
2005 pMgmt->abyDesireSSID);
2006 bScheduleCommand((void *) pDevice,
2007 WLAN_CMD_SSID,
2008 NULL);
92b96797
FB		 2009 spin_unlock_irq(&pDevice->lock);
2010 }
2011 pDevice->bCommit = FALSE;
2012 }
2013
2014
2015 return rc;
2016}
2017
2018
2019static 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: {
2028 struct ethtool_drvinfo info = {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
26e5b65b 2044MODULE_DEVICE_TABLE(usb, vt6656_table);
92b96797 2045
26e5b65b
AM		 2046static struct usb_driver vt6656_driver = {
2047 .name = DEVICE_NAME,
2048 .probe = vt6656_probe,
2049 .disconnect = vt6656_disconnect,
2050 .id_table = vt6656_table,
92b96797 2051#ifdef CONFIG_PM
26e5b65b
AM		 2052 .suspend = vt6656_suspend,
2053 .resume = vt6656_resume,
2054#endif /* CONFIG_PM */
92b96797
FB		 2055};
2056
bac2c126 2057module_usb_driver(vt6656_driver);
kernel source for telekom puls (alcatel/mediatek)