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