?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
perf callchain: Remove unnecessary validation
[linux-2.6/btrfs-unstable.git] / drivers / staging / vt6656 / main_usb.c
blob3a3fdc58b6da1028032c5c742e76edccd89ab91b
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 <linux/file.h>
50 #include "device.h"
51 #include "card.h"
52 #include "baseband.h"
53 #include "mac.h"
54 #include "tether.h"
55 #include "wmgr.h"
56 #include "wctl.h"
57 #include "power.h"
58 #include "wcmd.h"
59 #include "iocmd.h"
60 #include "tcrc.h"
61 #include "rxtx.h"
62 #include "bssdb.h"
63 #include "hostap.h"
64 #include "wpactl.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 int msglevel = MSG_LEVEL_DEBUG; */
77 static int msglevel =MSG_LEVEL_INFO;
78
79 /*
80 * define module options
81 */
82
83 /* version information */
84 #define DRIVER_AUTHOR \
85 "VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>"
86 MODULE_AUTHOR(DRIVER_AUTHOR);
87 MODULE_LICENSE("GPL");
88 MODULE_DESCRIPTION(DEVICE_FULL_DRV_NAM);
89
90 #define DEVICE_PARAM(N,D) \
91 static int N[MAX_UINTS]=OPTION_DEFAULT;\
92 module_param_array(N, int, NULL, 0);\
93 MODULE_PARM_DESC(N, D);
94
95 #define RX_DESC_DEF0 64
96 DEVICE_PARAM(RxDescriptors0,"Number of receive usb desc buffer");
97
98 #define TX_DESC_DEF0 64
99 DEVICE_PARAM(TxDescriptors0,"Number of transmit usb desc buffer");
100
101 #define CHANNEL_DEF 6
102 DEVICE_PARAM(Channel, "Channel number");
103
104 /* PreambleType[] is the preamble length used for transmit.
105 0: indicate allows long preamble type
106 1: indicate allows short preamble type
107 */
108
109 #define PREAMBLE_TYPE_DEF 1
110
111 DEVICE_PARAM(PreambleType, "Preamble Type");
112
113 #define RTS_THRESH_DEF 2347
114 DEVICE_PARAM(RTSThreshold, "RTS threshold");
115
116 #define FRAG_THRESH_DEF 2346
117 DEVICE_PARAM(FragThreshold, "Fragmentation threshold");
118
119 #define DATA_RATE_DEF 13
120 /* datarate[] index
121 0: indicate 1 Mbps 0x02
122 1: indicate 2 Mbps 0x04
123 2: indicate 5.5 Mbps 0x0B
124 3: indicate 11 Mbps 0x16
125 4: indicate 6 Mbps 0x0c
126 5: indicate 9 Mbps 0x12
127 6: indicate 12 Mbps 0x18
128 7: indicate 18 Mbps 0x24
129 8: indicate 24 Mbps 0x30
130 9: indicate 36 Mbps 0x48
131 10: indicate 48 Mbps 0x60
132 11: indicate 54 Mbps 0x6c
133 12: indicate 72 Mbps 0x90
134 13: indicate auto rate
135 */
136
137 DEVICE_PARAM(ConnectionRate, "Connection data rate");
138
139 #define OP_MODE_DEF 0
140 DEVICE_PARAM(OPMode, "Infrastruct, adhoc, AP mode ");
141
142 /* OpMode[] is used for transmit.
143 0: indicate infrastruct mode used
144 1: indicate adhoc mode used
145 2: indicate AP mode used
146 */
147
148 /* PSMode[]
149 0: indicate disable power saving mode
150 1: indicate enable power saving mode
151 */
152
153 #define PS_MODE_DEF 0
154 DEVICE_PARAM(PSMode, "Power saving mode");
155
156 #define SHORT_RETRY_DEF 8
157 DEVICE_PARAM(ShortRetryLimit, "Short frame retry limits");
158
159 #define LONG_RETRY_DEF 4
160 DEVICE_PARAM(LongRetryLimit, "long frame retry limits");
161
162 /* BasebandType[] baseband type selected
163 0: indicate 802.11a type
164 1: indicate 802.11b type
165 2: indicate 802.11g type
166 */
167
168 #define BBP_TYPE_DEF 2
169 DEVICE_PARAM(BasebandType, "baseband type");
170
171 /* 80211hEnable[]
172 0: indicate disable 802.11h
173 1: indicate enable 802.11h
174 */
175
176 #define X80211h_MODE_DEF 0
177
178 DEVICE_PARAM(b80211hEnable, "802.11h mode");
179
180 /*
181 * Static vars definitions
182 */
183
184 static struct usb_device_id vt6656_table[] = {
185 {USB_DEVICE(VNT_USB_VENDOR_ID, VNT_USB_PRODUCT_ID)},
186 {}
187 };
188
189 /* frequency list (map channels to frequencies) */
190 /*
191 static const long frequency_list[] = {
192 2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 2467, 2472, 2484,
193 4915, 4920, 4925, 4935, 4940, 4945, 4960, 4980,
194 5035, 5040, 5045, 5055, 5060, 5080, 5170, 5180, 5190, 5200, 5210, 5220, 5230, 5240,
195 5260, 5280, 5300, 5320, 5500, 5520, 5540, 5560, 5580, 5600, 5620, 5640, 5660, 5680,
196 5700, 5745, 5765, 5785, 5805, 5825
197 };
198
199 static const struct iw_handler_def iwctl_handler_def;
200 */
201
202 static int vt6656_probe(struct usb_interface *intf,
203 const struct usb_device_id *id);
204 static void vt6656_disconnect(struct usb_interface *intf);
205
206 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
207 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message);
208 static int vt6656_resume(struct usb_interface *intf);
209 #endif /* CONFIG_PM */
210
211 static struct net_device_stats *device_get_stats(struct net_device *dev);
212 static int device_open(struct net_device *dev);
213 static int device_xmit(struct sk_buff *skb, struct net_device *dev);
214 static void device_set_multi(struct net_device *dev);
215 static int device_close(struct net_device *dev);
216 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
217
218 static int device_init_registers(struct vnt_private *pDevice,
219 DEVICE_INIT_TYPE InitType);
220 static bool device_init_defrag_cb(struct vnt_private *pDevice);
221 static void device_init_diversity_timer(struct vnt_private *pDevice);
222 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev);
223
224 static int ethtool_ioctl(struct net_device *dev, void *useraddr);
225 static void device_free_tx_bufs(struct vnt_private *pDevice);
226 static void device_free_rx_bufs(struct vnt_private *pDevice);
227 static void device_free_int_bufs(struct vnt_private *pDevice);
228 static void device_free_frag_bufs(struct vnt_private *pDevice);
229 static bool device_alloc_bufs(struct vnt_private *pDevice);
230
231 static int Read_config_file(struct vnt_private *pDevice);
232 static unsigned char *Config_FileOperation(struct vnt_private *pDevice);
233 static int Config_FileGetParameter(unsigned char *string,
234 unsigned char *dest,
235 unsigned char *source);
236
237 static void usb_device_reset(struct vnt_private *pDevice);
238
239 static void
240 device_set_options(struct vnt_private *pDevice) {
241
242 u8 abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
243 u8 abySNAP_RFC1042[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00};
244 u8 abySNAP_Bridgetunnel[ETH_ALEN] = {0xAA, 0xAA, 0x03, 0x00, 0x00, 0xF8};
245
246 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
247 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
248 memcpy(pDevice->abySNAP_Bridgetunnel, abySNAP_Bridgetunnel, ETH_ALEN);
249
250 pDevice->cbTD = TX_DESC_DEF0;
251 pDevice->cbRD = RX_DESC_DEF0;
252 pDevice->uChannel = CHANNEL_DEF;
253 pDevice->wRTSThreshold = RTS_THRESH_DEF;
254 pDevice->wFragmentationThreshold = FRAG_THRESH_DEF;
255 pDevice->byShortRetryLimit = SHORT_RETRY_DEF;
256 pDevice->byLongRetryLimit = LONG_RETRY_DEF;
257 pDevice->wMaxTransmitMSDULifetime = DEFAULT_MSDU_LIFETIME;
258 pDevice->byShortPreamble = PREAMBLE_TYPE_DEF;
259 pDevice->ePSMode = PS_MODE_DEF;
260 pDevice->b11hEnable = X80211h_MODE_DEF;
261 pDevice->eOPMode = OP_MODE_DEF;
262 pDevice->uConnectionRate = DATA_RATE_DEF;
263 if (pDevice->uConnectionRate < RATE_AUTO) pDevice->bFixRate = true;
264 pDevice->byBBType = BBP_TYPE_DEF;
265 pDevice->byPacketType = pDevice->byBBType;
266 pDevice->byAutoFBCtrl = AUTO_FB_0;
267 pDevice->bUpdateBBVGA = true;
268 pDevice->byFOETuning = 0;
269 pDevice->byAutoPwrTunning = 0;
270 pDevice->wCTSDuration = 0;
271 pDevice->byPreambleType = 0;
272 pDevice->bExistSWNetAddr = false;
273 /* pDevice->bDiversityRegCtlON = true; */
274 pDevice->bDiversityRegCtlON = false;
275 }
276
277 static void device_init_diversity_timer(struct vnt_private *pDevice)
278 {
279 init_timer(&pDevice->TimerSQ3Tmax1);
280 pDevice->TimerSQ3Tmax1.data = (unsigned long)pDevice;
281 pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
282 pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
283
284 init_timer(&pDevice->TimerSQ3Tmax2);
285 pDevice->TimerSQ3Tmax2.data = (unsigned long)pDevice;
286 pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
287 pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
288
289 init_timer(&pDevice->TimerSQ3Tmax3);
290 pDevice->TimerSQ3Tmax3.data = (unsigned long)pDevice;
291 pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerSQ3Tmax3CallBack;
292 pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
293
294 return;
295 }
296
297 /*
298 * initialization of MAC & BBP registers
299 */
300
301 static int device_init_registers(struct vnt_private *pDevice,
302 DEVICE_INIT_TYPE InitType)
303 {
304 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
305 u8 abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
306 u8 abySNAP_RFC1042[ETH_ALEN] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00};
307 u8 abySNAP_Bridgetunnel[ETH_ALEN]
308 = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8};
309 u8 byAntenna;
310 int ii;
311 CMD_CARD_INIT sInitCmd;
312 int ntStatus = STATUS_SUCCESS;
313 RSP_CARD_INIT sInitRsp;
314 u8 byTmp;
315 u8 byCalibTXIQ = 0, byCalibTXDC = 0, byCalibRXIQ = 0;
316
317 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---->INIbInitAdapter. [%d][%d]\n", InitType, pDevice->byPacketType);
318 spin_lock_irq(&pDevice->lock);
319 if (InitType == DEVICE_INIT_COLD) {
320 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
321 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
322 memcpy(pDevice->abySNAP_Bridgetunnel,
323 abySNAP_Bridgetunnel,
324 ETH_ALEN);
325
326 if ( !FIRMWAREbCheckVersion(pDevice) ) {
327 if (FIRMWAREbDownload(pDevice) == true) {
328 if (FIRMWAREbBrach2Sram(pDevice) == false) {
329 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbBrach2Sram fail \n");
330 spin_unlock_irq(&pDevice->lock);
331 return false;
332 }
333 } else {
334
335 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbDownload fail \n");
336 spin_unlock_irq(&pDevice->lock);
337 return false;
338 }
339 }
340
341 if ( !BBbVT3184Init(pDevice) ) {
342 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" BBbVT3184Init fail \n");
343 spin_unlock_irq(&pDevice->lock);
344 return false;
345 }
346 }
347
348 sInitCmd.byInitClass = (u8)InitType;
349 sInitCmd.bExistSWNetAddr = (u8) pDevice->bExistSWNetAddr;
350 for (ii = 0; ii < 6; ii++)
351 sInitCmd.bySWNetAddr[ii] = pDevice->abyCurrentNetAddr[ii];
352 sInitCmd.byShortRetryLimit = pDevice->byShortRetryLimit;
353 sInitCmd.byLongRetryLimit = pDevice->byLongRetryLimit;
354
355 /* issue card_init command to device */
356 ntStatus = CONTROLnsRequestOut(pDevice,
357 MESSAGE_TYPE_CARDINIT,
358 0,
359 0,
360 sizeof(CMD_CARD_INIT),
361 (u8 *) &(sInitCmd));
362
363 if ( ntStatus != STATUS_SUCCESS ) {
364 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Issue Card init fail \n");
365 spin_unlock_irq(&pDevice->lock);
366 return false;
367 }
368 if (InitType == DEVICE_INIT_COLD) {
369
370 ntStatus = CONTROLnsRequestIn(pDevice,MESSAGE_TYPE_INIT_RSP,0,0,sizeof(RSP_CARD_INIT), (u8 *) &(sInitRsp));
371
372 if (ntStatus != STATUS_SUCCESS) {
373 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Cardinit request in status fail!\n");
374 spin_unlock_irq(&pDevice->lock);
375 return false;
376 }
377
378 /* local ID for AES functions */
379 ntStatus = CONTROLnsRequestIn(pDevice,
380 MESSAGE_TYPE_READ,
381 MAC_REG_LOCALID,
382 MESSAGE_REQUEST_MACREG,
383 1,
384 &pDevice->byLocalID);
385
386 if ( ntStatus != STATUS_SUCCESS ) {
387 spin_unlock_irq(&pDevice->lock);
388 return false;
389 }
390
391 /* do MACbSoftwareReset in MACvInitialize */
392
393 /* force CCK */
394 pDevice->bCCK = true;
395 pDevice->bProtectMode = false;
396 /* only used in 11g type, sync with ERP IE */
397 pDevice->bNonERPPresent = false;
398 pDevice->bBarkerPreambleMd = false;
399 if ( pDevice->bFixRate ) {
400 pDevice->wCurrentRate = (u16) pDevice->uConnectionRate;
401 } else {
402 if ( pDevice->byBBType == BB_TYPE_11B )
403 pDevice->wCurrentRate = RATE_11M;
404 else
405 pDevice->wCurrentRate = RATE_54M;
406 }
407
408 CHvInitChannelTable(pDevice);
409
410 pDevice->byTopOFDMBasicRate = RATE_24M;
411 pDevice->byTopCCKBasicRate = RATE_1M;
412 pDevice->byRevId = 0;
413 /* target to IF pin while programming to RF chip */
414 pDevice->byCurPwr = 0xFF;
415
416 pDevice->byCCKPwr = pDevice->abyEEPROM[EEP_OFS_PWR_CCK];
417 pDevice->byOFDMPwrG = pDevice->abyEEPROM[EEP_OFS_PWR_OFDMG];
418 /* load power table */
419 for (ii = 0; ii < 14; ii++) {
420 pDevice->abyCCKPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_CCK_PWR_TBL];
421 if (pDevice->abyCCKPwrTbl[ii] == 0)
422 pDevice->abyCCKPwrTbl[ii] = pDevice->byCCKPwr;
423 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDM_PWR_TBL];
424 if (pDevice->abyOFDMPwrTbl[ii] == 0)
425 pDevice->abyOFDMPwrTbl[ii] = pDevice->byOFDMPwrG;
426 }
427
428 /*
429 * original zonetype is USA, but custom zonetype is Europe,
430 * then need to recover 12, 13, 14 channels with 11 channel
431 */
432 if(((pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Japan) ||
433 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Europe))&&
434 (pDevice->byOriginalZonetype == ZoneType_USA)) {
435 for (ii = 11; ii < 14; ii++) {
436 pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];
437 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];
438 }
439 }
440
441 pDevice->byOFDMPwrA = 0x34; /* same as RFbMA2829SelectChannel */
442
443 /* load OFDM A power table */
444 for (ii = 0; ii < CB_MAX_CHANNEL_5G; ii++) {
445 pDevice->abyOFDMAPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDMA_PWR_TBL];
446 if (pDevice->abyOFDMAPwrTbl[ii] == 0)
447 pDevice->abyOFDMAPwrTbl[ii] = pDevice->byOFDMPwrA;
448 }
449
450 byAntenna = pDevice->abyEEPROM[EEP_OFS_ANTENNA];
451 if (byAntenna & EEP_ANTINV)
452 pDevice->bTxRxAntInv = true;
453 else
454 pDevice->bTxRxAntInv = false;
455
456 byAntenna &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
457
458 if (byAntenna == 0) /* if not set default is both */
459 byAntenna = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
460
461 if (byAntenna == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
462 pDevice->byAntennaCount = 2;
463 pDevice->byTxAntennaMode = ANT_B;
464 pDevice->dwTxAntennaSel = 1;
465 pDevice->dwRxAntennaSel = 1;
466 if (pDevice->bTxRxAntInv == true)
467 pDevice->byRxAntennaMode = ANT_A;
468 else
469 pDevice->byRxAntennaMode = ANT_B;
470
471 if (pDevice->bDiversityRegCtlON)
472 pDevice->bDiversityEnable = true;
473 else
474 pDevice->bDiversityEnable = false;
475 } else {
476 pDevice->bDiversityEnable = false;
477 pDevice->byAntennaCount = 1;
478 pDevice->dwTxAntennaSel = 0;
479 pDevice->dwRxAntennaSel = 0;
480 if (byAntenna & EEP_ANTENNA_AUX) {
481 pDevice->byTxAntennaMode = ANT_A;
482 if (pDevice->bTxRxAntInv == true)
483 pDevice->byRxAntennaMode = ANT_B;
484 else
485 pDevice->byRxAntennaMode = ANT_A;
486 } else {
487 pDevice->byTxAntennaMode = ANT_B;
488 if (pDevice->bTxRxAntInv == true)
489 pDevice->byRxAntennaMode = ANT_A;
490 else
491 pDevice->byRxAntennaMode = ANT_B;
492 }
493 }
494 pDevice->ulDiversityNValue = 100*255;
495 pDevice->ulDiversityMValue = 100*16;
496 pDevice->byTMax = 1;
497 pDevice->byTMax2 = 4;
498 pDevice->ulSQ3TH = 0;
499 pDevice->byTMax3 = 64;
500
501 /* get Auto Fall Back type */
502 pDevice->byAutoFBCtrl = AUTO_FB_0;
503
504 /* set SCAN Time */
505 pDevice->uScanTime = WLAN_SCAN_MINITIME;
506
507 /* default Auto Mode */
508 /* pDevice->NetworkType = Ndis802_11Automode; */
509 pDevice->eConfigPHYMode = PHY_TYPE_AUTO;
510 pDevice->byBBType = BB_TYPE_11G;
511
512 /* initialize BBP registers */
513 pDevice->ulTxPower = 25;
514
515 /* get channel range */
516 pDevice->byMinChannel = 1;
517 pDevice->byMaxChannel = CB_MAX_CHANNEL;
518
519 /* get RFType */
520 pDevice->byRFType = sInitRsp.byRFType;
521
522 if ((pDevice->byRFType & RF_EMU) != 0) {
523 /* force change RevID for VT3253 emu */
524 pDevice->byRevId = 0x80;
525 }
526
527 /* load vt3266 calibration parameters in EEPROM */
528 if (pDevice->byRFType == RF_VT3226D0) {
529 if((pDevice->abyEEPROM[EEP_OFS_MAJOR_VER] == 0x1) &&
530 (pDevice->abyEEPROM[EEP_OFS_MINOR_VER] >= 0x4)) {
531 byCalibTXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_IQ];
532 byCalibTXDC = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_DC];
533 byCalibRXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_RX_IQ];
534 if( (byCalibTXIQ || byCalibTXDC || byCalibRXIQ) ) {
535 /* CR255, enable TX/RX IQ and DC compensation mode */
536 ControlvWriteByte(pDevice,
537 MESSAGE_REQUEST_BBREG,
538 0xFF,
539 0x03);
540 /* CR251, TX I/Q Imbalance Calibration */
541 ControlvWriteByte(pDevice,
542 MESSAGE_REQUEST_BBREG,
543 0xFB,
544 byCalibTXIQ);
545 /* CR252, TX DC-Offset Calibration */
546 ControlvWriteByte(pDevice,
547 MESSAGE_REQUEST_BBREG,
548 0xFC,
549 byCalibTXDC);
550 /* CR253, RX I/Q Imbalance Calibration */
551 ControlvWriteByte(pDevice,
552 MESSAGE_REQUEST_BBREG,
553 0xFD,
554 byCalibRXIQ);
555 } else {
556 /* CR255, turn off BB Calibration compensation */
557 ControlvWriteByte(pDevice,
558 MESSAGE_REQUEST_BBREG,
559 0xFF,
560 0x0);
561 }
562 }
563 }
564 pMgmt->eScanType = WMAC_SCAN_PASSIVE;
565 pMgmt->uCurrChannel = pDevice->uChannel;
566 pMgmt->uIBSSChannel = pDevice->uChannel;
567 CARDbSetMediaChannel(pDevice, pMgmt->uCurrChannel);
568
569 /* get permanent network address */
570 memcpy(pDevice->abyPermanentNetAddr,&(sInitRsp.byNetAddr[0]),6);
571 memcpy(pDevice->abyCurrentNetAddr,
572 pDevice->abyPermanentNetAddr,
573 ETH_ALEN);
574
575 /* if exist SW network address, use it */
576 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %pM\n",
577 pDevice->abyCurrentNetAddr);
578 }
579
580 /*
581 * set BB and packet type at the same time
582 * set Short Slot Time, xIFS, and RSPINF
583 */
584 if (pDevice->byBBType == BB_TYPE_11A) {
585 CARDbAddBasicRate(pDevice, RATE_6M);
586 pDevice->bShortSlotTime = true;
587 } else {
588 CARDbAddBasicRate(pDevice, RATE_1M);
589 pDevice->bShortSlotTime = false;
590 }
591 BBvSetShortSlotTime(pDevice);
592 CARDvSetBSSMode(pDevice);
593
594 if (pDevice->bUpdateBBVGA) {
595 pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
596 pDevice->byBBVGANew = pDevice->byBBVGACurrent;
597 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
598 }
599
600 pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];
601 pDevice->bHWRadioOff = false;
602 if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) {
603 ntStatus = CONTROLnsRequestIn(pDevice,
604 MESSAGE_TYPE_READ,
605 MAC_REG_GPIOCTL1,
606 MESSAGE_REQUEST_MACREG,
607 1,
608 &byTmp);
609
610 if ( ntStatus != STATUS_SUCCESS ) {
611 spin_unlock_irq(&pDevice->lock);
612 return false;
613 }
614 if ( (byTmp & GPIO3_DATA) == 0 ) {
615 pDevice->bHWRadioOff = true;
616 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
617 } else {
618 MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
619 pDevice->bHWRadioOff = false;
620 }
621
622 }
623
624 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
625 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
626 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01);
627
628 if ((pDevice->bHWRadioOff == true) || (pDevice->bRadioControlOff == true)) {
629 CARDbRadioPowerOff(pDevice);
630 } else {
631 CARDbRadioPowerOn(pDevice);
632 }
633
634 spin_unlock_irq(&pDevice->lock);
635 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");
636 return true;
637 }
638
639 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
640
641 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message)
642 {
643 struct vnt_private *device = usb_get_intfdata(intf);
644
645 if (!device || !device->dev)
646 return -ENODEV;
647
648 if (device->flags & DEVICE_FLAGS_OPENED)
649 device_close(device->dev);
650
651 return 0;
652 }
653
654 static int vt6656_resume(struct usb_interface *intf)
655 {
656 struct vnt_private *device = usb_get_intfdata(intf);
657
658 if (!device || !device->dev)
659 return -ENODEV;
660
661 if (!(device->flags & DEVICE_FLAGS_OPENED))
662 device_open(device->dev);
663
664 return 0;
665 }
666
667 #endif /* CONFIG_PM */
668
669 static const struct net_device_ops device_netdev_ops = {
670 .ndo_open = device_open,
671 .ndo_stop = device_close,
672 .ndo_do_ioctl = device_ioctl,
673 .ndo_get_stats = device_get_stats,
674 .ndo_start_xmit = device_xmit,
675 .ndo_set_rx_mode = device_set_multi,
676 };
677
678 static int
679 vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
680 {
681 u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
682 struct usb_device *udev = interface_to_usbdev(intf);
683 int rc = 0;
684 struct net_device *netdev = NULL;
685 struct vnt_private *pDevice;
686
687 printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
688 printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
689
690 udev = usb_get_dev(udev);
691 netdev = alloc_etherdev(sizeof(struct vnt_private));
692 if (!netdev) {
693 printk(KERN_ERR DEVICE_NAME ": allocate net device failed\n");
694 rc = -ENOMEM;
695 goto err_nomem;
696 }
697
698 pDevice = netdev_priv(netdev);
699 memset(pDevice, 0, sizeof(struct vnt_private));
700
701 pDevice->dev = netdev;
702 pDevice->usb = udev;
703
704 device_set_options(pDevice);
705 spin_lock_init(&pDevice->lock);
706
707 pDevice->tx_80211 = device_dma0_tx_80211;
708 pDevice->vnt_mgmt.pAdapter = (void *) pDevice;
709
710 netdev->netdev_ops = &device_netdev_ops;
711 netdev->wireless_handlers =
712 (struct iw_handler_def *) &iwctl_handler_def;
713
714 usb_set_intfdata(intf, pDevice);
715 SET_NETDEV_DEV(netdev, &intf->dev);
716 memcpy(pDevice->dev->dev_addr, fake_mac, ETH_ALEN);
717 rc = register_netdev(netdev);
718 if (rc) {
719 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
720 goto err_netdev;
721 }
722
723 usb_device_reset(pDevice);
724
725 return 0;
726
727 err_netdev:
728 free_netdev(netdev);
729 err_nomem:
730 usb_put_dev(udev);
731
732 return rc;
733 }
734
735 static void device_free_tx_bufs(struct vnt_private *pDevice)
736 {
737 PUSB_SEND_CONTEXT pTxContext;
738 int ii;
739
740 for (ii = 0; ii < pDevice->cbTD; ii++) {
741
742 pTxContext = pDevice->apTD[ii];
743 /* deallocate URBs */
744 if (pTxContext->pUrb) {
745 usb_kill_urb(pTxContext->pUrb);
746 usb_free_urb(pTxContext->pUrb);
747 }
748 kfree(pTxContext);
749 }
750 return;
751 }
752
753 static void device_free_rx_bufs(struct vnt_private *pDevice)
754 {
755 PRCB pRCB;
756 int ii;
757
758 for (ii = 0; ii < pDevice->cbRD; ii++) {
759
760 pRCB = pDevice->apRCB[ii];
761 /* deallocate URBs */
762 if (pRCB->pUrb) {
763 usb_kill_urb(pRCB->pUrb);
764 usb_free_urb(pRCB->pUrb);
765 }
766 /* deallocate skb */
767 if (pRCB->skb)
768 dev_kfree_skb(pRCB->skb);
769 }
770 kfree(pDevice->pRCBMem);
771
772 return;
773 }
774
775 static void usb_device_reset(struct vnt_private *pDevice)
776 {
777 int status;
778 status = usb_reset_device(pDevice->usb);
779 if (status)
780 printk("usb_device_reset fail status=%d\n",status);
781 return ;
782 }
783
784 static void device_free_int_bufs(struct vnt_private *pDevice)
785 {
786 kfree(pDevice->intBuf.pDataBuf);
787 return;
788 }
789
790 static bool device_alloc_bufs(struct vnt_private *pDevice)
791 {
792
793 PUSB_SEND_CONTEXT pTxContext;
794 PRCB pRCB;
795 int ii;
796
797 for (ii = 0; ii < pDevice->cbTD; ii++) {
798
799 pTxContext = kmalloc(sizeof(USB_SEND_CONTEXT), GFP_KERNEL);
800 if (pTxContext == NULL) {
801 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
802 goto free_tx;
803 }
804 pDevice->apTD[ii] = pTxContext;
805 pTxContext->pDevice = (void *) pDevice;
806 /* allocate URBs */
807 pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
808 if (pTxContext->pUrb == NULL) {
809 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
810 goto free_tx;
811 }
812 pTxContext->bBoolInUse = false;
813 }
814
815 /* allocate RCB mem */
816 pDevice->pRCBMem = kzalloc((sizeof(RCB) * pDevice->cbRD), GFP_KERNEL);
817 if (pDevice->pRCBMem == NULL) {
818 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
819 goto free_tx;
820 }
821
822 pDevice->FirstRecvFreeList = NULL;
823 pDevice->LastRecvFreeList = NULL;
824 pDevice->FirstRecvMngList = NULL;
825 pDevice->LastRecvMngList = NULL;
826 pDevice->NumRecvFreeList = 0;
827 pRCB = (PRCB) pDevice->pRCBMem;
828
829 for (ii = 0; ii < pDevice->cbRD; ii++) {
830
831 pDevice->apRCB[ii] = pRCB;
832 pRCB->pDevice = (void *) pDevice;
833 /* allocate URBs */
834 pRCB->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
835
836 if (pRCB->pUrb == NULL) {
837 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx urb\n");
838 goto free_rx_tx;
839 }
840 pRCB->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
841 if (pRCB->skb == NULL) {
842 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR" Failed to alloc rx skb\n");
843 goto free_rx_tx;
844 }
845 pRCB->skb->dev = pDevice->dev;
846 pRCB->bBoolInUse = false;
847 EnqueueRCB(pDevice->FirstRecvFreeList, pDevice->LastRecvFreeList, pRCB);
848 pDevice->NumRecvFreeList++;
849 pRCB++;
850 }
851
852 pDevice->pControlURB = usb_alloc_urb(0, GFP_ATOMIC);
853 if (pDevice->pControlURB == NULL) {
854 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc control urb\n");
855 goto free_rx_tx;
856 }
857
858 pDevice->pInterruptURB = usb_alloc_urb(0, GFP_ATOMIC);
859 if (pDevice->pInterruptURB == NULL) {
860 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int urb\n");
861 usb_free_urb(pDevice->pControlURB);
862 goto free_rx_tx;
863 }
864
865 pDevice->intBuf.pDataBuf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
866 if (pDevice->intBuf.pDataBuf == NULL) {
867 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR"Failed to alloc int buf\n");
868 usb_free_urb(pDevice->pControlURB);
869 usb_free_urb(pDevice->pInterruptURB);
870 goto free_rx_tx;
871 }
872
873 return true;
874
875 free_rx_tx:
876 device_free_rx_bufs(pDevice);
877
878 free_tx:
879 device_free_tx_bufs(pDevice);
880
881 return false;
882 }
883
884 static bool device_init_defrag_cb(struct vnt_private *pDevice)
885 {
886 int i;
887 PSDeFragControlBlock pDeF;
888
889 /* Init the fragment ctl entries */
890 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
891 pDeF = &(pDevice->sRxDFCB[i]);
892 if (!device_alloc_frag_buf(pDevice, pDeF)) {
893 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s: can not alloc frag bufs\n",
894 pDevice->dev->name);
895 goto free_frag;
896 }
897 }
898 pDevice->cbDFCB = CB_MAX_RX_FRAG;
899 pDevice->cbFreeDFCB = pDevice->cbDFCB;
900 return true;
901
902 free_frag:
903 device_free_frag_bufs(pDevice);
904 return false;
905 }
906
907 static void device_free_frag_bufs(struct vnt_private *pDevice)
908 {
909 PSDeFragControlBlock pDeF;
910 int i;
911
912 for (i = 0; i < CB_MAX_RX_FRAG; i++) {
913
914 pDeF = &(pDevice->sRxDFCB[i]);
915
916 if (pDeF->skb)
917 dev_kfree_skb(pDeF->skb);
918 }
919 }
920
921 int device_alloc_frag_buf(struct vnt_private *pDevice,
922 PSDeFragControlBlock pDeF)
923 {
924
925 pDeF->skb = dev_alloc_skb((int)pDevice->rx_buf_sz);
926 if (pDeF->skb == NULL)
927 return false;
928 ASSERT(pDeF->skb);
929 pDeF->skb->dev = pDevice->dev;
930
931 return true;
932 }
933
934 static int device_open(struct net_device *dev)
935 {
936 struct vnt_private *pDevice = netdev_priv(dev);
937
938 pDevice->fWPA_Authened = false;
939
940 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
941
942 pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
943
944 if (device_alloc_bufs(pDevice) == false) {
945 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
946 return -ENOMEM;
947 }
948
949 if (device_init_defrag_cb(pDevice)== false) {
950 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragment cb fail \n");
951 goto free_rx_tx;
952 }
953
954 MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
955 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
956 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
957 MP_SET_FLAG(pDevice, fMP_POST_READS);
958 MP_SET_FLAG(pDevice, fMP_POST_WRITES);
959
960 /* read config file */
961 Read_config_file(pDevice);
962
963 if (device_init_registers(pDevice, DEVICE_INIT_COLD) == false) {
964 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
965 goto free_all;
966 }
967
968 device_set_multi(pDevice->dev);
969
970 /* init for key management */
971 KeyvInitTable(pDevice,&pDevice->sKey);
972 memcpy(pDevice->vnt_mgmt.abyMACAddr,
973 pDevice->abyCurrentNetAddr, ETH_ALEN);
974 memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
975 pDevice->bStopTx0Pkt = false;
976 pDevice->bStopDataPkt = false;
977 pDevice->bRoaming = false;
978 pDevice->bIsRoaming = false;
979 pDevice->bEnableRoaming = false;
980 if (pDevice->bDiversityRegCtlON) {
981 device_init_diversity_timer(pDevice);
982 }
983
984 vMgrObjectInit(pDevice);
985 tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
986 tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
987 tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
988 add_timer(&pDevice->vnt_mgmt.sTimerSecondCallback);
989 pDevice->int_interval = 100; /* max 100 microframes */
990 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
991
992 pDevice->bIsRxWorkItemQueued = true;
993 pDevice->fKillEventPollingThread = false;
994 pDevice->bEventAvailable = false;
995
996 pDevice->bWPADEVUp = false;
997 pDevice->bwextstep0 = false;
998 pDevice->bwextstep1 = false;
999 pDevice->bwextstep2 = false;
1000 pDevice->bwextstep3 = false;
1001 pDevice->bWPASuppWextEnabled = false;
1002 pDevice->byReAssocCount = 0;
1003
1004 RXvWorkItem(pDevice);
1005 INTvWorkItem(pDevice);
1006
1007 /* if WEP key already set by iwconfig but device not yet open */
1008 if ((pDevice->bEncryptionEnable == true) && (pDevice->bTransmitKey == true)) {
1009 spin_lock_irq(&pDevice->lock);
1010 KeybSetDefaultKey( pDevice,
1011 &(pDevice->sKey),
1012 pDevice->byKeyIndex | (1 << 31),
1013 pDevice->uKeyLength,
1014 NULL,
1015 pDevice->abyKey,
1016 KEY_CTL_WEP
1017 );
1018 spin_unlock_irq(&pDevice->lock);
1019 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1020 }
1021
1022 if (pDevice->vnt_mgmt.eConfigMode == WMAC_CONFIG_AP)
1023 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1024 else
1025 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1026
1027 netif_stop_queue(pDevice->dev);
1028 pDevice->flags |= DEVICE_FLAGS_OPENED;
1029
1030 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success..\n");
1031 return 0;
1032
1033 free_all:
1034 device_free_frag_bufs(pDevice);
1035 free_rx_tx:
1036 device_free_rx_bufs(pDevice);
1037 device_free_tx_bufs(pDevice);
1038 device_free_int_bufs(pDevice);
1039 usb_kill_urb(pDevice->pControlURB);
1040 usb_kill_urb(pDevice->pInterruptURB);
1041 usb_free_urb(pDevice->pControlURB);
1042 usb_free_urb(pDevice->pInterruptURB);
1043
1044 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1045 return -ENOMEM;
1046 }
1047
1048 static int device_close(struct net_device *dev)
1049 {
1050 struct vnt_private *pDevice = netdev_priv(dev);
1051 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
1052 int uu;
1053
1054 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1\n");
1055 if (pDevice == NULL)
1056 return -ENODEV;
1057
1058 if (pDevice->bLinkPass) {
1059 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1060 mdelay(30);
1061 }
1062
1063 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1064 pMgmt->bShareKeyAlgorithm = false;
1065 pDevice->bEncryptionEnable = false;
1066 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1067 spin_lock_irq(&pDevice->lock);
1068 for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1069 MACvDisableKeyEntry(pDevice,uu);
1070 spin_unlock_irq(&pDevice->lock);
1071
1072 if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == false) {
1073 MACbShutdown(pDevice);
1074 }
1075 netif_stop_queue(pDevice->dev);
1076 MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1077 MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1078 MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1079 pDevice->fKillEventPollingThread = true;
1080 del_timer(&pDevice->sTimerCommand);
1081 del_timer(&pMgmt->sTimerSecondCallback);
1082
1083 del_timer(&pDevice->sTimerTxData);
1084
1085 if (pDevice->bDiversityRegCtlON) {
1086 del_timer(&pDevice->TimerSQ3Tmax1);
1087 del_timer(&pDevice->TimerSQ3Tmax2);
1088 del_timer(&pDevice->TimerSQ3Tmax3);
1089 }
1090 tasklet_kill(&pDevice->RxMngWorkItem);
1091 tasklet_kill(&pDevice->ReadWorkItem);
1092 tasklet_kill(&pDevice->EventWorkItem);
1093
1094 pDevice->bRoaming = false;
1095 pDevice->bIsRoaming = false;
1096 pDevice->bEnableRoaming = false;
1097 pDevice->bCmdRunning = false;
1098 pDevice->bLinkPass = false;
1099 memset(pMgmt->abyCurrBSSID, 0, 6);
1100 pMgmt->eCurrState = WMAC_STATE_IDLE;
1101
1102 device_free_tx_bufs(pDevice);
1103 device_free_rx_bufs(pDevice);
1104 device_free_int_bufs(pDevice);
1105 device_free_frag_bufs(pDevice);
1106
1107 usb_kill_urb(pDevice->pControlURB);
1108 usb_kill_urb(pDevice->pInterruptURB);
1109 usb_free_urb(pDevice->pControlURB);
1110 usb_free_urb(pDevice->pInterruptURB);
1111
1112 BSSvClearNodeDBTable(pDevice, 0);
1113 pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1114
1115 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1116
1117 return 0;
1118 }
1119
1120 static void vt6656_disconnect(struct usb_interface *intf)
1121 {
1122 struct vnt_private *device = usb_get_intfdata(intf);
1123
1124 if (!device)
1125 return;
1126
1127 usb_set_intfdata(intf, NULL);
1128 usb_put_dev(interface_to_usbdev(intf));
1129
1130 device->flags |= DEVICE_FLAGS_UNPLUG;
1131
1132 if (device->dev) {
1133 unregister_netdev(device->dev);
1134 free_netdev(device->dev);
1135 }
1136
1137 }
1138
1139 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1140 {
1141 struct vnt_private *pDevice = netdev_priv(dev);
1142
1143 spin_lock_irq(&pDevice->lock);
1144
1145 if (unlikely(pDevice->bStopTx0Pkt))
1146 dev_kfree_skb_irq(skb);
1147 else
1148 vDMA0_tx_80211(pDevice, skb);
1149
1150 spin_unlock_irq(&pDevice->lock);
1151
1152 return NETDEV_TX_OK;
1153 }
1154
1155 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1156 {
1157 struct vnt_private *pDevice = netdev_priv(dev);
1158 struct net_device_stats *stats = &pDevice->stats;
1159
1160 spin_lock_irq(&pDevice->lock);
1161
1162 netif_stop_queue(dev);
1163
1164 if (!pDevice->bLinkPass) {
1165 dev_kfree_skb_irq(skb);
1166 goto out;
1167 }
1168
1169 if (pDevice->bStopDataPkt) {
1170 dev_kfree_skb_irq(skb);
1171 stats->tx_dropped++;
1172 goto out;
1173 }
1174
1175 if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1176 if (netif_queue_stopped(dev))
1177 netif_wake_queue(dev);
1178 }
1179
1180 out:
1181 spin_unlock_irq(&pDevice->lock);
1182
1183 return NETDEV_TX_OK;
1184 }
1185
1186 static unsigned const ethernet_polynomial = 0x04c11db7U;
1187 static inline u32 ether_crc(int length, unsigned char *data)
1188 {
1189 int crc = -1;
1190
1191 while(--length >= 0) {
1192 unsigned char current_octet = *data++;
1193 int bit;
1194 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1195 crc = (crc << 1) ^
1196 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1197 }
1198 }
1199 return crc;
1200 }
1201
1202 /* find out the start position of str2 from str1 */
1203 static unsigned char *kstrstr(const unsigned char *str1,
1204 const unsigned char *str2) {
1205 int str1_len = strlen(str1);
1206 int str2_len = strlen(str2);
1207
1208 while (str1_len >= str2_len) {
1209 str1_len--;
1210 if(memcmp(str1,str2,str2_len)==0)
1211 return (unsigned char *) str1;
1212 str1++;
1213 }
1214 return NULL;
1215 }
1216
1217 static int Config_FileGetParameter(unsigned char *string,
1218 unsigned char *dest,
1219 unsigned char *source)
1220 {
1221 unsigned char buf1[100];
1222 unsigned char buf2[100];
1223 unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1224 int ii;
1225
1226 memset(buf1,0,100);
1227 strcat(buf1, string);
1228 strcat(buf1, "=");
1229 source+=strlen(buf1);
1230
1231 /* find target string start point */
1232 start_p = kstrstr(source,buf1);
1233 if (start_p == NULL)
1234 return false;
1235
1236 /* check if current config line is marked by "#" */
1237 for (ii = 1; ; ii++) {
1238 if (memcmp(start_p - ii, "\n", 1) == 0)
1239 break;
1240 if (memcmp(start_p - ii, "#", 1) == 0)
1241 return false;
1242 }
1243
1244 /* find target string end point */
1245 end_p = kstrstr(start_p,"\n");
1246 if (end_p == NULL) { /* can't find "\n", but don't care */
1247 end_p = start_p + strlen(start_p); /* no include "\n" */
1248 }
1249
1250 memset(buf2,0,100);
1251 memcpy(buf2, start_p, end_p-start_p); /* get the target line */
1252 buf2[end_p-start_p]='\0';
1253
1254 /* find value */
1255 start_p = kstrstr(buf2,"=");
1256 if (start_p == NULL)
1257 return false;
1258 memset(buf1,0,100);
1259 strcpy(buf1,start_p+1);
1260
1261 /* except space */
1262 tmp_p = buf1;
1263 while(*tmp_p != 0x00) {
1264 if(*tmp_p==' ')
1265 tmp_p++;
1266 else
1267 break;
1268 }
1269
1270 memcpy(dest,tmp_p,strlen(tmp_p));
1271 return true;
1272 }
1273
1274 /* if read fails, return NULL, or return data pointer */
1275 static unsigned char *Config_FileOperation(struct vnt_private *pDevice)
1276 {
1277 unsigned char *buffer = kmalloc(1024, GFP_KERNEL);
1278 struct file *file;
1279
1280 if (!buffer) {
1281 printk("allocate mem for file fail?\n");
1282 return NULL;
1283 }
1284
1285 file = filp_open(CONFIG_PATH, O_RDONLY, 0);
1286 if (IS_ERR(file)) {
1287 kfree(buffer);
1288 printk("Config_FileOperation file Not exist\n");
1289 return NULL;
1290 }
1291
1292 if (kernel_read(file, 0, buffer, 1024) < 0) {
1293 printk("read file error?\n");
1294 kfree(buffer);
1295 buffer = NULL;
1296 }
1297
1298 fput(file);
1299 return buffer;
1300 }
1301
1302 /* return --->-1:fail; >=0:successful */
1303 static int Read_config_file(struct vnt_private *pDevice)
1304 {
1305 int result = 0;
1306 unsigned char tmpbuffer[100];
1307 unsigned char *buffer = NULL;
1308
1309 /* init config setting */
1310 pDevice->config_file.ZoneType = -1;
1311 pDevice->config_file.eAuthenMode = -1;
1312 pDevice->config_file.eEncryptionStatus = -1;
1313
1314 buffer = Config_FileOperation(pDevice);
1315 if (buffer == NULL) {
1316 result =-1;
1317 return result;
1318 }
1319
1320 /* get zonetype */
1321 {
1322 memset(tmpbuffer,0,sizeof(tmpbuffer));
1323 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==true) {
1324 if(memcmp(tmpbuffer,"USA",3)==0) {
1325 pDevice->config_file.ZoneType=ZoneType_USA;
1326 }
1327 else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1328 pDevice->config_file.ZoneType=ZoneType_Japan;
1329 }
1330 else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1331 pDevice->config_file.ZoneType=ZoneType_Europe;
1332 }
1333 else {
1334 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1335 }
1336 }
1337 }
1338
1339 /* get other parameter */
1340 {
1341 memset(tmpbuffer,0,sizeof(tmpbuffer));
1342 if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==true) {
1343 pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1344 }
1345
1346 memset(tmpbuffer,0,sizeof(tmpbuffer));
1347 if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==true) {
1348 pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1349 }
1350 }
1351
1352 kfree(buffer);
1353 return result;
1354 }
1355
1356 static void device_set_multi(struct net_device *dev)
1357 {
1358 struct vnt_private *pDevice = netdev_priv(dev);
1359 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
1360 struct netdev_hw_addr *ha;
1361 u32 mc_filter[2];
1362 int ii;
1363 u8 pbyData[8] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1364 u8 byTmpMode = 0;
1365 int rc;
1366
1367 spin_lock_irq(&pDevice->lock);
1368 rc = CONTROLnsRequestIn(pDevice,
1369 MESSAGE_TYPE_READ,
1370 MAC_REG_RCR,
1371 MESSAGE_REQUEST_MACREG,
1372 1,
1373 &byTmpMode
1374 );
1375 if (rc == 0) pDevice->byRxMode = byTmpMode;
1376
1377 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1378
1379 if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
1380 DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1381 /* unconditionally log net taps */
1382 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1383 }
1384 else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1385 (dev->flags & IFF_ALLMULTI)) {
1386 CONTROLnsRequestOut(pDevice,
1387 MESSAGE_TYPE_WRITE,
1388 MAC_REG_MAR0,
1389 MESSAGE_REQUEST_MACREG,
1390 8,
1391 pbyData
1392 );
1393 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1394 }
1395 else {
1396 memset(mc_filter, 0, sizeof(mc_filter));
1397 netdev_for_each_mc_addr(ha, dev) {
1398 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1399 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1400 }
1401 for (ii = 0; ii < 4; ii++) {
1402 MACvWriteMultiAddr(pDevice, ii, *((u8 *)&mc_filter[0] + ii));
1403 MACvWriteMultiAddr(pDevice, ii+ 4, *((u8 *)&mc_filter[1] + ii));
1404 }
1405 pDevice->byRxMode &= ~(RCR_UNICAST);
1406 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1407 }
1408
1409 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1410 /*
1411 * If AP mode, don't enable RCR_UNICAST since HW only compares
1412 * addr1 with local MAC
1413 */
1414 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1415 pDevice->byRxMode &= ~(RCR_UNICAST);
1416 }
1417 ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1418 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1419 spin_unlock_irq(&pDevice->lock);
1420
1421 }
1422
1423 static struct net_device_stats *device_get_stats(struct net_device *dev)
1424 {
1425 struct vnt_private *pDevice = netdev_priv(dev);
1426
1427 return &pDevice->stats;
1428 }
1429
1430 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1431 {
1432 struct vnt_private *pDevice = netdev_priv(dev);
1433 struct iwreq *wrq = (struct iwreq *) rq;
1434 int rc = 0;
1435
1436 switch (cmd) {
1437
1438 case IOCTL_CMD_HOSTAPD:
1439
1440 if (!(pDevice->flags & DEVICE_FLAGS_OPENED))
1441 rc = -EFAULT;
1442
1443 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
1444 break;
1445
1446 case SIOCETHTOOL:
1447 return ethtool_ioctl(dev, (void *) rq->ifr_data);
1448
1449 }
1450
1451 return rc;
1452 }
1453
1454 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
1455 {
1456 u32 ethcmd;
1457
1458 if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
1459 return -EFAULT;
1460
1461 switch (ethcmd) {
1462 case ETHTOOL_GDRVINFO: {
1463 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
1464 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
1465 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
1466 if (copy_to_user(useraddr, &info, sizeof(info)))
1467 return -EFAULT;
1468 return 0;
1469 }
1470
1471 }
1472
1473 return -EOPNOTSUPP;
1474 }
1475
1476 MODULE_DEVICE_TABLE(usb, vt6656_table);
1477
1478 static struct usb_driver vt6656_driver = {
1479 .name = DEVICE_NAME,
1480 .probe = vt6656_probe,
1481 .disconnect = vt6656_disconnect,
1482 .id_table = vt6656_table,
1483 #ifdef CONFIG_PM
1484 .suspend = vt6656_suspend,
1485 .resume = vt6656_resume,
1486 #endif /* CONFIG_PM */
1487 };
1488
1489 module_usb_driver(vt6656_driver);
(deprecated) Btrfs devel tree