projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
misc: mic: depend on X86 for both host and card drivers.
[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 <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->byPreambleType = 0;
271 pDevice->bExistSWNetAddr = false;
272 /* pDevice->bDiversityRegCtlON = true; */
273 pDevice->bDiversityRegCtlON = false;
274 }
275
276 static void device_init_diversity_timer(struct vnt_private *pDevice)
277 {
278 init_timer(&pDevice->TimerSQ3Tmax1);
279 pDevice->TimerSQ3Tmax1.data = (unsigned long)pDevice;
280 pDevice->TimerSQ3Tmax1.function = (TimerFunction)TimerSQ3CallBack;
281 pDevice->TimerSQ3Tmax1.expires = RUN_AT(HZ);
282
283 init_timer(&pDevice->TimerSQ3Tmax2);
284 pDevice->TimerSQ3Tmax2.data = (unsigned long)pDevice;
285 pDevice->TimerSQ3Tmax2.function = (TimerFunction)TimerSQ3CallBack;
286 pDevice->TimerSQ3Tmax2.expires = RUN_AT(HZ);
287
288 init_timer(&pDevice->TimerSQ3Tmax3);
289 pDevice->TimerSQ3Tmax3.data = (unsigned long)pDevice;
290 pDevice->TimerSQ3Tmax3.function = (TimerFunction)TimerSQ3Tmax3CallBack;
291 pDevice->TimerSQ3Tmax3.expires = RUN_AT(HZ);
292
293 return;
294 }
295
296 /*
297 * initialization of MAC & BBP registers
298 */
299
300 static int device_init_registers(struct vnt_private *pDevice,
301 DEVICE_INIT_TYPE InitType)
302 {
303 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
304 u8 abyBroadcastAddr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
305 u8 abySNAP_RFC1042[ETH_ALEN] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00};
306 u8 abySNAP_Bridgetunnel[ETH_ALEN]
307 = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0xf8};
308 u8 byAntenna;
309 int ii;
310 CMD_CARD_INIT sInitCmd;
311 int ntStatus = STATUS_SUCCESS;
312 RSP_CARD_INIT sInitRsp;
313 u8 byTmp;
314 u8 byCalibTXIQ = 0, byCalibTXDC = 0, byCalibRXIQ = 0;
315
316 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "---->INIbInitAdapter. [%d][%d]\n", InitType, pDevice->byPacketType);
317 spin_lock_irq(&pDevice->lock);
318 if (InitType == DEVICE_INIT_COLD) {
319 memcpy(pDevice->abyBroadcastAddr, abyBroadcastAddr, ETH_ALEN);
320 memcpy(pDevice->abySNAP_RFC1042, abySNAP_RFC1042, ETH_ALEN);
321 memcpy(pDevice->abySNAP_Bridgetunnel,
322 abySNAP_Bridgetunnel,
323 ETH_ALEN);
324
325 if ( !FIRMWAREbCheckVersion(pDevice) ) {
326 if (FIRMWAREbDownload(pDevice) == true) {
327 if (FIRMWAREbBrach2Sram(pDevice) == false) {
328 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbBrach2Sram fail \n");
329 spin_unlock_irq(&pDevice->lock);
330 return false;
331 }
332 } else {
333
334 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" FIRMWAREbDownload fail \n");
335 spin_unlock_irq(&pDevice->lock);
336 return false;
337 }
338 }
339
340 if ( !BBbVT3184Init(pDevice) ) {
341 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" BBbVT3184Init fail \n");
342 spin_unlock_irq(&pDevice->lock);
343 return false;
344 }
345 }
346
347 sInitCmd.byInitClass = (u8)InitType;
348 sInitCmd.bExistSWNetAddr = (u8) pDevice->bExistSWNetAddr;
349 for (ii = 0; ii < 6; ii++)
350 sInitCmd.bySWNetAddr[ii] = pDevice->abyCurrentNetAddr[ii];
351 sInitCmd.byShortRetryLimit = pDevice->byShortRetryLimit;
352 sInitCmd.byLongRetryLimit = pDevice->byLongRetryLimit;
353
354 /* issue card_init command to device */
355 ntStatus = CONTROLnsRequestOut(pDevice,
356 MESSAGE_TYPE_CARDINIT,
357 0,
358 0,
359 sizeof(CMD_CARD_INIT),
360 (u8 *) &(sInitCmd));
361
362 if ( ntStatus != STATUS_SUCCESS ) {
363 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO" Issue Card init fail \n");
364 spin_unlock_irq(&pDevice->lock);
365 return false;
366 }
367 if (InitType == DEVICE_INIT_COLD) {
368
369 ntStatus = CONTROLnsRequestIn(pDevice,MESSAGE_TYPE_INIT_RSP,0,0,sizeof(RSP_CARD_INIT), (u8 *) &(sInitRsp));
370
371 if (ntStatus != STATUS_SUCCESS) {
372 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "Cardinit request in status fail!\n");
373 spin_unlock_irq(&pDevice->lock);
374 return false;
375 }
376
377 /* local ID for AES functions */
378 ntStatus = CONTROLnsRequestIn(pDevice,
379 MESSAGE_TYPE_READ,
380 MAC_REG_LOCALID,
381 MESSAGE_REQUEST_MACREG,
382 1,
383 &pDevice->byLocalID);
384
385 if ( ntStatus != STATUS_SUCCESS ) {
386 spin_unlock_irq(&pDevice->lock);
387 return false;
388 }
389
390 /* do MACbSoftwareReset in MACvInitialize */
391
392 /* force CCK */
393 pDevice->bCCK = true;
394 pDevice->bProtectMode = false;
395 /* only used in 11g type, sync with ERP IE */
396 pDevice->bNonERPPresent = false;
397 pDevice->bBarkerPreambleMd = false;
398 if ( pDevice->bFixRate ) {
399 pDevice->wCurrentRate = (u16) pDevice->uConnectionRate;
400 } else {
401 if ( pDevice->byBBType == BB_TYPE_11B )
402 pDevice->wCurrentRate = RATE_11M;
403 else
404 pDevice->wCurrentRate = RATE_54M;
405 }
406
407 CHvInitChannelTable(pDevice);
408
409 pDevice->byTopOFDMBasicRate = RATE_24M;
410 pDevice->byTopCCKBasicRate = RATE_1M;
411 pDevice->byRevId = 0;
412 /* target to IF pin while programming to RF chip */
413 pDevice->byCurPwr = 0xFF;
414
415 pDevice->byCCKPwr = pDevice->abyEEPROM[EEP_OFS_PWR_CCK];
416 pDevice->byOFDMPwrG = pDevice->abyEEPROM[EEP_OFS_PWR_OFDMG];
417 /* load power table */
418 for (ii = 0; ii < 14; ii++) {
419 pDevice->abyCCKPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_CCK_PWR_TBL];
420 if (pDevice->abyCCKPwrTbl[ii] == 0)
421 pDevice->abyCCKPwrTbl[ii] = pDevice->byCCKPwr;
422 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDM_PWR_TBL];
423 if (pDevice->abyOFDMPwrTbl[ii] == 0)
424 pDevice->abyOFDMPwrTbl[ii] = pDevice->byOFDMPwrG;
425 }
426
427 /*
428 * original zonetype is USA, but custom zonetype is Europe,
429 * then need to recover 12, 13, 14 channels with 11 channel
430 */
431 if(((pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Japan) ||
432 (pDevice->abyEEPROM[EEP_OFS_ZONETYPE] == ZoneType_Europe))&&
433 (pDevice->byOriginalZonetype == ZoneType_USA)) {
434 for (ii = 11; ii < 14; ii++) {
435 pDevice->abyCCKPwrTbl[ii] = pDevice->abyCCKPwrTbl[10];
436 pDevice->abyOFDMPwrTbl[ii] = pDevice->abyOFDMPwrTbl[10];
437 }
438 }
439
440 pDevice->byOFDMPwrA = 0x34; /* same as RFbMA2829SelectChannel */
441
442 /* load OFDM A power table */
443 for (ii = 0; ii < CB_MAX_CHANNEL_5G; ii++) {
444 pDevice->abyOFDMAPwrTbl[ii] = pDevice->abyEEPROM[ii + EEP_OFS_OFDMA_PWR_TBL];
445 if (pDevice->abyOFDMAPwrTbl[ii] == 0)
446 pDevice->abyOFDMAPwrTbl[ii] = pDevice->byOFDMPwrA;
447 }
448
449 byAntenna = pDevice->abyEEPROM[EEP_OFS_ANTENNA];
450 if (byAntenna & EEP_ANTINV)
451 pDevice->bTxRxAntInv = true;
452 else
453 pDevice->bTxRxAntInv = false;
454
455 byAntenna &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
456
457 if (byAntenna == 0) /* if not set default is both */
458 byAntenna = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
459
460 if (byAntenna == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
461 pDevice->byAntennaCount = 2;
462 pDevice->byTxAntennaMode = ANT_B;
463 pDevice->dwTxAntennaSel = 1;
464 pDevice->dwRxAntennaSel = 1;
465 if (pDevice->bTxRxAntInv == true)
466 pDevice->byRxAntennaMode = ANT_A;
467 else
468 pDevice->byRxAntennaMode = ANT_B;
469
470 if (pDevice->bDiversityRegCtlON)
471 pDevice->bDiversityEnable = true;
472 else
473 pDevice->bDiversityEnable = false;
474 } else {
475 pDevice->bDiversityEnable = false;
476 pDevice->byAntennaCount = 1;
477 pDevice->dwTxAntennaSel = 0;
478 pDevice->dwRxAntennaSel = 0;
479 if (byAntenna & EEP_ANTENNA_AUX) {
480 pDevice->byTxAntennaMode = ANT_A;
481 if (pDevice->bTxRxAntInv == true)
482 pDevice->byRxAntennaMode = ANT_B;
483 else
484 pDevice->byRxAntennaMode = ANT_A;
485 } else {
486 pDevice->byTxAntennaMode = ANT_B;
487 if (pDevice->bTxRxAntInv == true)
488 pDevice->byRxAntennaMode = ANT_A;
489 else
490 pDevice->byRxAntennaMode = ANT_B;
491 }
492 }
493 pDevice->ulDiversityNValue = 100*255;
494 pDevice->ulDiversityMValue = 100*16;
495 pDevice->byTMax = 1;
496 pDevice->byTMax2 = 4;
497 pDevice->ulSQ3TH = 0;
498 pDevice->byTMax3 = 64;
499
500 /* get Auto Fall Back type */
501 pDevice->byAutoFBCtrl = AUTO_FB_0;
502
503 /* set SCAN Time */
504 pDevice->uScanTime = WLAN_SCAN_MINITIME;
505
506 /* default Auto Mode */
507 /* pDevice->NetworkType = Ndis802_11Automode; */
508 pDevice->eConfigPHYMode = PHY_TYPE_AUTO;
509 pDevice->byBBType = BB_TYPE_11G;
510
511 /* initialize BBP registers */
512 pDevice->ulTxPower = 25;
513
514 /* get channel range */
515 pDevice->byMinChannel = 1;
516 pDevice->byMaxChannel = CB_MAX_CHANNEL;
517
518 /* get RFType */
519 pDevice->byRFType = sInitRsp.byRFType;
520
521 if ((pDevice->byRFType & RF_EMU) != 0) {
522 /* force change RevID for VT3253 emu */
523 pDevice->byRevId = 0x80;
524 }
525
526 /* load vt3266 calibration parameters in EEPROM */
527 if (pDevice->byRFType == RF_VT3226D0) {
528 if((pDevice->abyEEPROM[EEP_OFS_MAJOR_VER] == 0x1) &&
529 (pDevice->abyEEPROM[EEP_OFS_MINOR_VER] >= 0x4)) {
530 byCalibTXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_IQ];
531 byCalibTXDC = pDevice->abyEEPROM[EEP_OFS_CALIB_TX_DC];
532 byCalibRXIQ = pDevice->abyEEPROM[EEP_OFS_CALIB_RX_IQ];
533 if( (byCalibTXIQ || byCalibTXDC || byCalibRXIQ) ) {
534 /* CR255, enable TX/RX IQ and DC compensation mode */
535 ControlvWriteByte(pDevice,
536 MESSAGE_REQUEST_BBREG,
537 0xFF,
538 0x03);
539 /* CR251, TX I/Q Imbalance Calibration */
540 ControlvWriteByte(pDevice,
541 MESSAGE_REQUEST_BBREG,
542 0xFB,
543 byCalibTXIQ);
544 /* CR252, TX DC-Offset Calibration */
545 ControlvWriteByte(pDevice,
546 MESSAGE_REQUEST_BBREG,
547 0xFC,
548 byCalibTXDC);
549 /* CR253, RX I/Q Imbalance Calibration */
550 ControlvWriteByte(pDevice,
551 MESSAGE_REQUEST_BBREG,
552 0xFD,
553 byCalibRXIQ);
554 } else {
555 /* CR255, turn off BB Calibration compensation */
556 ControlvWriteByte(pDevice,
557 MESSAGE_REQUEST_BBREG,
558 0xFF,
559 0x0);
560 }
561 }
562 }
563 pMgmt->eScanType = WMAC_SCAN_PASSIVE;
564 pMgmt->uCurrChannel = pDevice->uChannel;
565 pMgmt->uIBSSChannel = pDevice->uChannel;
566 CARDbSetMediaChannel(pDevice, pMgmt->uCurrChannel);
567
568 /* get permanent network address */
569 memcpy(pDevice->abyPermanentNetAddr,&(sInitRsp.byNetAddr[0]),6);
570 memcpy(pDevice->abyCurrentNetAddr,
571 pDevice->abyPermanentNetAddr,
572 ETH_ALEN);
573
574 /* if exist SW network address, use it */
575 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"Network address = %pM\n",
576 pDevice->abyCurrentNetAddr);
577 }
578
579 /*
580 * set BB and packet type at the same time
581 * set Short Slot Time, xIFS, and RSPINF
582 */
583 if (pDevice->byBBType == BB_TYPE_11A) {
584 CARDbAddBasicRate(pDevice, RATE_6M);
585 pDevice->bShortSlotTime = true;
586 } else {
587 CARDbAddBasicRate(pDevice, RATE_1M);
588 pDevice->bShortSlotTime = false;
589 }
590 BBvSetShortSlotTime(pDevice);
591 CARDvSetBSSMode(pDevice);
592
593 if (pDevice->bUpdateBBVGA) {
594 pDevice->byBBVGACurrent = pDevice->abyBBVGA[0];
595 pDevice->byBBVGANew = pDevice->byBBVGACurrent;
596 BBvSetVGAGainOffset(pDevice, pDevice->abyBBVGA[0]);
597 }
598
599 pDevice->byRadioCtl = pDevice->abyEEPROM[EEP_OFS_RADIOCTL];
600 pDevice->bHWRadioOff = false;
601 if ( (pDevice->byRadioCtl & EEP_RADIOCTL_ENABLE) != 0 ) {
602 ntStatus = CONTROLnsRequestIn(pDevice,
603 MESSAGE_TYPE_READ,
604 MAC_REG_GPIOCTL1,
605 MESSAGE_REQUEST_MACREG,
606 1,
607 &byTmp);
608
609 if ( ntStatus != STATUS_SUCCESS ) {
610 spin_unlock_irq(&pDevice->lock);
611 return false;
612 }
613 if ( (byTmp & GPIO3_DATA) == 0 ) {
614 pDevice->bHWRadioOff = true;
615 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
616 } else {
617 MACvRegBitsOff(pDevice,MAC_REG_GPIOCTL1,GPIO3_INTMD);
618 pDevice->bHWRadioOff = false;
619 }
620
621 }
622
623 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_TMLEN,0x38);
624 ControlvMaskByte(pDevice,MESSAGE_REQUEST_MACREG,MAC_REG_PAPEDELAY,LEDSTS_STS,LEDSTS_SLOW);
625 MACvRegBitsOn(pDevice,MAC_REG_GPIOCTL0,0x01);
626
627 if ((pDevice->bHWRadioOff == true) || (pDevice->bRadioControlOff == true)) {
628 CARDbRadioPowerOff(pDevice);
629 } else {
630 CARDbRadioPowerOn(pDevice);
631 }
632
633 spin_unlock_irq(&pDevice->lock);
634 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO"<----INIbInitAdapter Exit\n");
635 return true;
636 }
637
638 #ifdef CONFIG_PM /* Minimal support for suspend and resume */
639
640 static int vt6656_suspend(struct usb_interface *intf, pm_message_t message)
641 {
642 struct vnt_private *device = usb_get_intfdata(intf);
643
644 if (!device || !device->dev)
645 return -ENODEV;
646
647 if (device->flags & DEVICE_FLAGS_OPENED)
648 device_close(device->dev);
649
650 return 0;
651 }
652
653 static int vt6656_resume(struct usb_interface *intf)
654 {
655 struct vnt_private *device = usb_get_intfdata(intf);
656
657 if (!device || !device->dev)
658 return -ENODEV;
659
660 if (!(device->flags & DEVICE_FLAGS_OPENED))
661 device_open(device->dev);
662
663 return 0;
664 }
665
666 #endif /* CONFIG_PM */
667
668 static const struct net_device_ops device_netdev_ops = {
669 .ndo_open = device_open,
670 .ndo_stop = device_close,
671 .ndo_do_ioctl = device_ioctl,
672 .ndo_get_stats = device_get_stats,
673 .ndo_start_xmit = device_xmit,
674 .ndo_set_rx_mode = device_set_multi,
675 };
676
677 static int
678 vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
679 {
680 u8 fake_mac[ETH_ALEN] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
681 struct usb_device *udev = interface_to_usbdev(intf);
682 int rc = 0;
683 struct net_device *netdev = NULL;
684 struct vnt_private *pDevice;
685
686 printk(KERN_NOTICE "%s Ver. %s\n", DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
687 printk(KERN_NOTICE "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
688
689 udev = usb_get_dev(udev);
690 netdev = alloc_etherdev(sizeof(struct vnt_private));
691 if (!netdev) {
692 printk(KERN_ERR DEVICE_NAME ": allocate net device failed\n");
693 rc = -ENOMEM;
694 goto err_nomem;
695 }
696
697 pDevice = netdev_priv(netdev);
698 memset(pDevice, 0, sizeof(struct vnt_private));
699
700 pDevice->dev = netdev;
701 pDevice->usb = udev;
702
703 device_set_options(pDevice);
704 spin_lock_init(&pDevice->lock);
705
706 pDevice->tx_80211 = device_dma0_tx_80211;
707 pDevice->vnt_mgmt.pAdapter = (void *) pDevice;
708
709 netdev->netdev_ops = &device_netdev_ops;
710 netdev->wireless_handlers =
711 (struct iw_handler_def *) &iwctl_handler_def;
712
713 usb_set_intfdata(intf, pDevice);
714 SET_NETDEV_DEV(netdev, &intf->dev);
715 memcpy(pDevice->dev->dev_addr, fake_mac, ETH_ALEN);
716 rc = register_netdev(netdev);
717 if (rc) {
718 printk(KERN_ERR DEVICE_NAME " Failed to register netdev\n");
719 goto err_netdev;
720 }
721
722 usb_device_reset(pDevice);
723
724 return 0;
725
726 err_netdev:
727 free_netdev(netdev);
728 err_nomem:
729 usb_put_dev(udev);
730
731 return rc;
732 }
733
734 static void device_free_tx_bufs(struct vnt_private *pDevice)
735 {
736 struct vnt_usb_send_context *pTxContext;
737 int ii;
738
739 for (ii = 0; ii < pDevice->cbTD; ii++) {
740
741 pTxContext = pDevice->apTD[ii];
742 /* deallocate URBs */
743 if (pTxContext->pUrb) {
744 usb_kill_urb(pTxContext->pUrb);
745 usb_free_urb(pTxContext->pUrb);
746 }
747 kfree(pTxContext);
748 }
749 return;
750 }
751
752 static void device_free_rx_bufs(struct vnt_private *pDevice)
753 {
754 struct vnt_rcb *pRCB;
755 int ii;
756
757 for (ii = 0; ii < pDevice->cbRD; ii++) {
758
759 pRCB = pDevice->apRCB[ii];
760 /* deallocate URBs */
761 if (pRCB->pUrb) {
762 usb_kill_urb(pRCB->pUrb);
763 usb_free_urb(pRCB->pUrb);
764 }
765 /* deallocate skb */
766 if (pRCB->skb)
767 dev_kfree_skb(pRCB->skb);
768 }
769 kfree(pDevice->pRCBMem);
770
771 return;
772 }
773
774 static void usb_device_reset(struct vnt_private *pDevice)
775 {
776 int status;
777 status = usb_reset_device(pDevice->usb);
778 if (status)
779 printk("usb_device_reset fail status=%d\n",status);
780 return ;
781 }
782
783 static void device_free_int_bufs(struct vnt_private *pDevice)
784 {
785 kfree(pDevice->intBuf.pDataBuf);
786 return;
787 }
788
789 static bool device_alloc_bufs(struct vnt_private *pDevice)
790 {
791 struct vnt_usb_send_context *pTxContext;
792 struct vnt_rcb *pRCB;
793 int ii;
794
795 for (ii = 0; ii < pDevice->cbTD; ii++) {
796
797 pTxContext = kmalloc(sizeof(struct vnt_usb_send_context), GFP_KERNEL);
798 if (pTxContext == NULL) {
799 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : allocate tx usb context failed\n", pDevice->dev->name);
800 goto free_tx;
801 }
802 pDevice->apTD[ii] = pTxContext;
803 pTxContext->pDevice = (void *) pDevice;
804 /* allocate URBs */
805 pTxContext->pUrb = usb_alloc_urb(0, GFP_ATOMIC);
806 if (pTxContext->pUrb == NULL) {
807 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "alloc tx urb failed\n");
808 goto free_tx;
809 }
810 pTxContext->bBoolInUse = false;
811 }
812
813 /* allocate RCB mem */
814 pDevice->pRCBMem = kzalloc((sizeof(struct vnt_rcb) * pDevice->cbRD),
815 GFP_KERNEL);
816 if (pDevice->pRCBMem == NULL) {
817 DBG_PRT(MSG_LEVEL_ERR,KERN_ERR "%s : alloc rx usb context failed\n", pDevice->dev->name);
818 goto free_tx;
819 }
820
821 pDevice->FirstRecvFreeList = NULL;
822 pDevice->LastRecvFreeList = NULL;
823 pDevice->FirstRecvMngList = NULL;
824 pDevice->LastRecvMngList = NULL;
825 pDevice->NumRecvFreeList = 0;
826
827 pRCB = (struct vnt_rcb *)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 pDeF->skb->dev = pDevice->dev;
929
930 return true;
931 }
932
933 static int device_open(struct net_device *dev)
934 {
935 struct vnt_private *pDevice = netdev_priv(dev);
936
937 pDevice->fWPA_Authened = false;
938
939 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_open...\n");
940
941 pDevice->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
942
943 if (device_alloc_bufs(pDevice) == false) {
944 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " device_alloc_bufs fail... \n");
945 return -ENOMEM;
946 }
947
948 if (device_init_defrag_cb(pDevice)== false) {
949 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " Initial defragment cb fail \n");
950 goto free_rx_tx;
951 }
952
953 MP_CLEAR_FLAG(pDevice, fMP_DISCONNECTED);
954 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_READS);
955 MP_CLEAR_FLAG(pDevice, fMP_CONTROL_WRITES);
956 MP_SET_FLAG(pDevice, fMP_POST_READS);
957 MP_SET_FLAG(pDevice, fMP_POST_WRITES);
958
959 /* read config file */
960 Read_config_file(pDevice);
961
962 if (device_init_registers(pDevice, DEVICE_INIT_COLD) == false) {
963 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO " init register fail\n");
964 goto free_all;
965 }
966
967 device_set_multi(pDevice->dev);
968
969 /* init for key management */
970 KeyvInitTable(pDevice,&pDevice->sKey);
971 memcpy(pDevice->vnt_mgmt.abyMACAddr,
972 pDevice->abyCurrentNetAddr, ETH_ALEN);
973 memcpy(pDevice->dev->dev_addr, pDevice->abyCurrentNetAddr, ETH_ALEN);
974 pDevice->bStopTx0Pkt = false;
975 pDevice->bStopDataPkt = false;
976 pDevice->bRoaming = false;
977 pDevice->bIsRoaming = false;
978 pDevice->bEnableRoaming = false;
979 if (pDevice->bDiversityRegCtlON) {
980 device_init_diversity_timer(pDevice);
981 }
982
983 vMgrObjectInit(pDevice);
984 tasklet_init(&pDevice->RxMngWorkItem, (void *)RXvMngWorkItem, (unsigned long)pDevice);
985 tasklet_init(&pDevice->ReadWorkItem, (void *)RXvWorkItem, (unsigned long)pDevice);
986 tasklet_init(&pDevice->EventWorkItem, (void *)INTvWorkItem, (unsigned long)pDevice);
987 add_timer(&pDevice->vnt_mgmt.sTimerSecondCallback);
988 pDevice->int_interval = 100; /* max 100 microframes */
989 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
990
991 pDevice->bIsRxWorkItemQueued = true;
992 pDevice->fKillEventPollingThread = false;
993 pDevice->bEventAvailable = false;
994
995 pDevice->bWPADEVUp = false;
996 pDevice->bwextstep0 = false;
997 pDevice->bwextstep1 = false;
998 pDevice->bwextstep2 = false;
999 pDevice->bwextstep3 = false;
1000 pDevice->bWPASuppWextEnabled = false;
1001 pDevice->byReAssocCount = 0;
1002
1003 RXvWorkItem(pDevice);
1004 INTvWorkItem(pDevice);
1005
1006 /* if WEP key already set by iwconfig but device not yet open */
1007 if ((pDevice->bEncryptionEnable == true) && (pDevice->bTransmitKey == true)) {
1008 spin_lock_irq(&pDevice->lock);
1009 KeybSetDefaultKey( pDevice,
1010 &(pDevice->sKey),
1011 pDevice->byKeyIndex | (1 << 31),
1012 pDevice->uKeyLength,
1013 NULL,
1014 pDevice->abyKey,
1015 KEY_CTL_WEP
1016 );
1017 spin_unlock_irq(&pDevice->lock);
1018 pDevice->eEncryptionStatus = Ndis802_11Encryption1Enabled;
1019 }
1020
1021 if (pDevice->vnt_mgmt.eConfigMode == WMAC_CONFIG_AP)
1022 bScheduleCommand((void *) pDevice, WLAN_CMD_RUN_AP, NULL);
1023 else
1024 bScheduleCommand((void *) pDevice, WLAN_CMD_BSSID_SCAN, NULL);
1025
1026 netif_stop_queue(pDevice->dev);
1027 pDevice->flags |= DEVICE_FLAGS_OPENED;
1028
1029 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open success..\n");
1030 return 0;
1031
1032 free_all:
1033 device_free_frag_bufs(pDevice);
1034 free_rx_tx:
1035 device_free_rx_bufs(pDevice);
1036 device_free_tx_bufs(pDevice);
1037 device_free_int_bufs(pDevice);
1038 usb_kill_urb(pDevice->pControlURB);
1039 usb_kill_urb(pDevice->pInterruptURB);
1040 usb_free_urb(pDevice->pControlURB);
1041 usb_free_urb(pDevice->pInterruptURB);
1042
1043 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_open fail.. \n");
1044 return -ENOMEM;
1045 }
1046
1047 static int device_close(struct net_device *dev)
1048 {
1049 struct vnt_private *pDevice = netdev_priv(dev);
1050 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
1051 int uu;
1052
1053 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close1\n");
1054 if (pDevice == NULL)
1055 return -ENODEV;
1056
1057 if (pDevice->bLinkPass) {
1058 bScheduleCommand((void *) pDevice, WLAN_CMD_DISASSOCIATE, NULL);
1059 mdelay(30);
1060 }
1061
1062 memset(pMgmt->abyDesireSSID, 0, WLAN_IEHDR_LEN + WLAN_SSID_MAXLEN + 1);
1063 pMgmt->bShareKeyAlgorithm = false;
1064 pDevice->bEncryptionEnable = false;
1065 pDevice->eEncryptionStatus = Ndis802_11EncryptionDisabled;
1066 spin_lock_irq(&pDevice->lock);
1067 for (uu = 0; uu < MAX_KEY_TABLE; uu++)
1068 MACvDisableKeyEntry(pDevice,uu);
1069 spin_unlock_irq(&pDevice->lock);
1070
1071 if ((pDevice->flags & DEVICE_FLAGS_UNPLUG) == false) {
1072 MACbShutdown(pDevice);
1073 }
1074 netif_stop_queue(pDevice->dev);
1075 MP_SET_FLAG(pDevice, fMP_DISCONNECTED);
1076 MP_CLEAR_FLAG(pDevice, fMP_POST_WRITES);
1077 MP_CLEAR_FLAG(pDevice, fMP_POST_READS);
1078 pDevice->fKillEventPollingThread = true;
1079 del_timer(&pDevice->sTimerCommand);
1080 del_timer(&pMgmt->sTimerSecondCallback);
1081
1082 del_timer(&pDevice->sTimerTxData);
1083
1084 if (pDevice->bDiversityRegCtlON) {
1085 del_timer(&pDevice->TimerSQ3Tmax1);
1086 del_timer(&pDevice->TimerSQ3Tmax2);
1087 del_timer(&pDevice->TimerSQ3Tmax3);
1088 }
1089 tasklet_kill(&pDevice->RxMngWorkItem);
1090 tasklet_kill(&pDevice->ReadWorkItem);
1091 tasklet_kill(&pDevice->EventWorkItem);
1092
1093 pDevice->bRoaming = false;
1094 pDevice->bIsRoaming = false;
1095 pDevice->bEnableRoaming = false;
1096 pDevice->bCmdRunning = false;
1097 pDevice->bLinkPass = false;
1098 memset(pMgmt->abyCurrBSSID, 0, 6);
1099 pMgmt->eCurrState = WMAC_STATE_IDLE;
1100
1101 device_free_tx_bufs(pDevice);
1102 device_free_rx_bufs(pDevice);
1103 device_free_int_bufs(pDevice);
1104 device_free_frag_bufs(pDevice);
1105
1106 usb_kill_urb(pDevice->pControlURB);
1107 usb_kill_urb(pDevice->pInterruptURB);
1108 usb_free_urb(pDevice->pControlURB);
1109 usb_free_urb(pDevice->pInterruptURB);
1110
1111 BSSvClearNodeDBTable(pDevice, 0);
1112 pDevice->flags &=(~DEVICE_FLAGS_OPENED);
1113
1114 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "device_close2 \n");
1115
1116 return 0;
1117 }
1118
1119 static void vt6656_disconnect(struct usb_interface *intf)
1120 {
1121 struct vnt_private *device = usb_get_intfdata(intf);
1122
1123 if (!device)
1124 return;
1125
1126 usb_set_intfdata(intf, NULL);
1127 usb_put_dev(interface_to_usbdev(intf));
1128
1129 device->flags |= DEVICE_FLAGS_UNPLUG;
1130
1131 if (device->dev) {
1132 unregister_netdev(device->dev);
1133 free_netdev(device->dev);
1134 }
1135
1136 }
1137
1138 static int device_dma0_tx_80211(struct sk_buff *skb, struct net_device *dev)
1139 {
1140 struct vnt_private *pDevice = netdev_priv(dev);
1141
1142 spin_lock_irq(&pDevice->lock);
1143
1144 if (unlikely(pDevice->bStopTx0Pkt))
1145 dev_kfree_skb_irq(skb);
1146 else
1147 vDMA0_tx_80211(pDevice, skb);
1148
1149 spin_unlock_irq(&pDevice->lock);
1150
1151 return NETDEV_TX_OK;
1152 }
1153
1154 static int device_xmit(struct sk_buff *skb, struct net_device *dev)
1155 {
1156 struct vnt_private *pDevice = netdev_priv(dev);
1157 struct net_device_stats *stats = &pDevice->stats;
1158
1159 spin_lock_irq(&pDevice->lock);
1160
1161 netif_stop_queue(dev);
1162
1163 if (!pDevice->bLinkPass) {
1164 dev_kfree_skb_irq(skb);
1165 goto out;
1166 }
1167
1168 if (pDevice->bStopDataPkt) {
1169 dev_kfree_skb_irq(skb);
1170 stats->tx_dropped++;
1171 goto out;
1172 }
1173
1174 if (nsDMA_tx_packet(pDevice, TYPE_AC0DMA, skb)) {
1175 if (netif_queue_stopped(dev))
1176 netif_wake_queue(dev);
1177 }
1178
1179 out:
1180 spin_unlock_irq(&pDevice->lock);
1181
1182 return NETDEV_TX_OK;
1183 }
1184
1185 static unsigned const ethernet_polynomial = 0x04c11db7U;
1186 static inline u32 ether_crc(int length, unsigned char *data)
1187 {
1188 int crc = -1;
1189
1190 while(--length >= 0) {
1191 unsigned char current_octet = *data++;
1192 int bit;
1193 for (bit = 0; bit < 8; bit++, current_octet >>= 1) {
1194 crc = (crc << 1) ^
1195 ((crc < 0) ^ (current_octet & 1) ? ethernet_polynomial : 0);
1196 }
1197 }
1198 return crc;
1199 }
1200
1201 /* find out the start position of str2 from str1 */
1202 static unsigned char *kstrstr(const unsigned char *str1,
1203 const unsigned char *str2) {
1204 int str1_len = strlen(str1);
1205 int str2_len = strlen(str2);
1206
1207 while (str1_len >= str2_len) {
1208 str1_len--;
1209 if(memcmp(str1,str2,str2_len)==0)
1210 return (unsigned char *) str1;
1211 str1++;
1212 }
1213 return NULL;
1214 }
1215
1216 static int Config_FileGetParameter(unsigned char *string,
1217 unsigned char *dest,
1218 unsigned char *source)
1219 {
1220 unsigned char buf1[100];
1221 unsigned char buf2[100];
1222 unsigned char *start_p = NULL, *end_p = NULL, *tmp_p = NULL;
1223 int ii;
1224
1225 memset(buf1,0,100);
1226 strcat(buf1, string);
1227 strcat(buf1, "=");
1228 source+=strlen(buf1);
1229
1230 /* find target string start point */
1231 start_p = kstrstr(source,buf1);
1232 if (start_p == NULL)
1233 return false;
1234
1235 /* check if current config line is marked by "#" */
1236 for (ii = 1; ; ii++) {
1237 if (memcmp(start_p - ii, "\n", 1) == 0)
1238 break;
1239 if (memcmp(start_p - ii, "#", 1) == 0)
1240 return false;
1241 }
1242
1243 /* find target string end point */
1244 end_p = kstrstr(start_p,"\n");
1245 if (end_p == NULL) { /* can't find "\n", but don't care */
1246 end_p = start_p + strlen(start_p); /* no include "\n" */
1247 }
1248
1249 memset(buf2,0,100);
1250 memcpy(buf2, start_p, end_p-start_p); /* get the target line */
1251 buf2[end_p-start_p]='\0';
1252
1253 /* find value */
1254 start_p = kstrstr(buf2,"=");
1255 if (start_p == NULL)
1256 return false;
1257 memset(buf1,0,100);
1258 strcpy(buf1,start_p+1);
1259
1260 /* except space */
1261 tmp_p = buf1;
1262 while(*tmp_p != 0x00) {
1263 if(*tmp_p==' ')
1264 tmp_p++;
1265 else
1266 break;
1267 }
1268
1269 memcpy(dest,tmp_p,strlen(tmp_p));
1270 return true;
1271 }
1272
1273 /* if read fails, return NULL, or return data pointer */
1274 static unsigned char *Config_FileOperation(struct vnt_private *pDevice)
1275 {
1276 unsigned char *buffer = kmalloc(1024, GFP_KERNEL);
1277 struct file *file;
1278
1279 if (!buffer) {
1280 printk("allocate mem for file fail?\n");
1281 return NULL;
1282 }
1283
1284 file = filp_open(CONFIG_PATH, O_RDONLY, 0);
1285 if (IS_ERR(file)) {
1286 kfree(buffer);
1287 printk("Config_FileOperation file Not exist\n");
1288 return NULL;
1289 }
1290
1291 if (kernel_read(file, 0, buffer, 1024) < 0) {
1292 printk("read file error?\n");
1293 kfree(buffer);
1294 buffer = NULL;
1295 }
1296
1297 fput(file);
1298 return buffer;
1299 }
1300
1301 /* return --->-1:fail; >=0:successful */
1302 static int Read_config_file(struct vnt_private *pDevice)
1303 {
1304 int result = 0;
1305 unsigned char tmpbuffer[100];
1306 unsigned char *buffer = NULL;
1307
1308 /* init config setting */
1309 pDevice->config_file.ZoneType = -1;
1310 pDevice->config_file.eAuthenMode = -1;
1311 pDevice->config_file.eEncryptionStatus = -1;
1312
1313 buffer = Config_FileOperation(pDevice);
1314 if (buffer == NULL) {
1315 result =-1;
1316 return result;
1317 }
1318
1319 /* get zonetype */
1320 {
1321 memset(tmpbuffer,0,sizeof(tmpbuffer));
1322 if(Config_FileGetParameter("ZONETYPE",tmpbuffer,buffer) ==true) {
1323 if(memcmp(tmpbuffer,"USA",3)==0) {
1324 pDevice->config_file.ZoneType=ZoneType_USA;
1325 }
1326 else if(memcmp(tmpbuffer,"JAPAN",5)==0) {
1327 pDevice->config_file.ZoneType=ZoneType_Japan;
1328 }
1329 else if(memcmp(tmpbuffer,"EUROPE",6)==0) {
1330 pDevice->config_file.ZoneType=ZoneType_Europe;
1331 }
1332 else {
1333 printk("Unknown Zonetype[%s]?\n",tmpbuffer);
1334 }
1335 }
1336 }
1337
1338 /* get other parameter */
1339 {
1340 memset(tmpbuffer,0,sizeof(tmpbuffer));
1341 if(Config_FileGetParameter("AUTHENMODE",tmpbuffer,buffer)==true) {
1342 pDevice->config_file.eAuthenMode = (int) simple_strtol(tmpbuffer, NULL, 10);
1343 }
1344
1345 memset(tmpbuffer,0,sizeof(tmpbuffer));
1346 if(Config_FileGetParameter("ENCRYPTIONMODE",tmpbuffer,buffer)==true) {
1347 pDevice->config_file.eEncryptionStatus= (int) simple_strtol(tmpbuffer, NULL, 10);
1348 }
1349 }
1350
1351 kfree(buffer);
1352 return result;
1353 }
1354
1355 static void device_set_multi(struct net_device *dev)
1356 {
1357 struct vnt_private *pDevice = netdev_priv(dev);
1358 struct vnt_manager *pMgmt = &pDevice->vnt_mgmt;
1359 struct netdev_hw_addr *ha;
1360 u32 mc_filter[2];
1361 int ii;
1362 u8 pbyData[8] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1363 u8 byTmpMode = 0;
1364 int rc;
1365
1366 spin_lock_irq(&pDevice->lock);
1367 rc = CONTROLnsRequestIn(pDevice,
1368 MESSAGE_TYPE_READ,
1369 MAC_REG_RCR,
1370 MESSAGE_REQUEST_MACREG,
1371 1,
1372 &byTmpMode
1373 );
1374 if (rc == 0) pDevice->byRxMode = byTmpMode;
1375
1376 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode in= %x\n", pDevice->byRxMode);
1377
1378 if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
1379 DBG_PRT(MSG_LEVEL_ERR,KERN_NOTICE "%s: Promiscuous mode enabled.\n", dev->name);
1380 /* unconditionally log net taps */
1381 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST|RCR_UNICAST);
1382 }
1383 else if ((netdev_mc_count(dev) > pDevice->multicast_limit) ||
1384 (dev->flags & IFF_ALLMULTI)) {
1385 CONTROLnsRequestOut(pDevice,
1386 MESSAGE_TYPE_WRITE,
1387 MAC_REG_MAR0,
1388 MESSAGE_REQUEST_MACREG,
1389 8,
1390 pbyData
1391 );
1392 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1393 }
1394 else {
1395 memset(mc_filter, 0, sizeof(mc_filter));
1396 netdev_for_each_mc_addr(ha, dev) {
1397 int bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
1398 mc_filter[bit_nr >> 5] |= cpu_to_le32(1 << (bit_nr & 31));
1399 }
1400 for (ii = 0; ii < 4; ii++) {
1401 MACvWriteMultiAddr(pDevice, ii, *((u8 *)&mc_filter[0] + ii));
1402 MACvWriteMultiAddr(pDevice, ii+ 4, *((u8 *)&mc_filter[1] + ii));
1403 }
1404 pDevice->byRxMode &= ~(RCR_UNICAST);
1405 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1406 }
1407
1408 if (pMgmt->eConfigMode == WMAC_CONFIG_AP) {
1409 /*
1410 * If AP mode, don't enable RCR_UNICAST since HW only compares
1411 * addr1 with local MAC
1412 */
1413 pDevice->byRxMode |= (RCR_MULTICAST|RCR_BROADCAST);
1414 pDevice->byRxMode &= ~(RCR_UNICAST);
1415 }
1416 ControlvWriteByte(pDevice, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, pDevice->byRxMode);
1417 DBG_PRT(MSG_LEVEL_DEBUG, KERN_INFO "pDevice->byRxMode out= %x\n", pDevice->byRxMode);
1418 spin_unlock_irq(&pDevice->lock);
1419
1420 }
1421
1422 static struct net_device_stats *device_get_stats(struct net_device *dev)
1423 {
1424 struct vnt_private *pDevice = netdev_priv(dev);
1425
1426 return &pDevice->stats;
1427 }
1428
1429 static int device_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1430 {
1431 struct vnt_private *pDevice = netdev_priv(dev);
1432 struct iwreq *wrq = (struct iwreq *) rq;
1433 int rc = 0;
1434
1435 switch (cmd) {
1436
1437 case IOCTL_CMD_HOSTAPD:
1438
1439 if (!(pDevice->flags & DEVICE_FLAGS_OPENED))
1440 rc = -EFAULT;
1441
1442 rc = vt6656_hostap_ioctl(pDevice, &wrq->u.data);
1443 break;
1444
1445 case SIOCETHTOOL:
1446 return ethtool_ioctl(dev, (void *) rq->ifr_data);
1447
1448 }
1449
1450 return rc;
1451 }
1452
1453 static int ethtool_ioctl(struct net_device *dev, void *useraddr)
1454 {
1455 u32 ethcmd;
1456
1457 if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
1458 return -EFAULT;
1459
1460 switch (ethcmd) {
1461 case ETHTOOL_GDRVINFO: {
1462 struct ethtool_drvinfo info = {ETHTOOL_GDRVINFO};
1463 strncpy(info.driver, DEVICE_NAME, sizeof(info.driver)-1);
1464 strncpy(info.version, DEVICE_VERSION, sizeof(info.version)-1);
1465 if (copy_to_user(useraddr, &info, sizeof(info)))
1466 return -EFAULT;
1467 return 0;
1468 }
1469
1470 }
1471
1472 return -EOPNOTSUPP;
1473 }
1474
1475 MODULE_DEVICE_TABLE(usb, vt6656_table);
1476
1477 static struct usb_driver vt6656_driver = {
1478 .name = DEVICE_NAME,
1479 .probe = vt6656_probe,
1480 .disconnect = vt6656_disconnect,
1481 .id_table = vt6656_table,
1482 #ifdef CONFIG_PM
1483 .suspend = vt6656_suspend,
1484 .resume = vt6656_resume,
1485 #endif /* CONFIG_PM */
1486 };
1487
1488 module_usb_driver(vt6656_driver);
Linux kernel - Deliverables
This page took 0.068416 seconds and 5 git commands to generate.