projects / deliverable / linux.git / blob
? search:


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