2 * at76c503/at76c505 USB driver
4 * Copyright (c) 2002 - 2003 Oliver Kurth
5 * Copyright (c) 2004 Joerg Albert <joerg.albert@gmx.de>
6 * Copyright (c) 2004 Nick Jones
7 * Copyright (c) 2004 Balint Seeber <n0_5p4m_p13453@hotmail.com>
8 * Copyright (c) 2007 Guido Guenther <agx@sigxcpu.org>
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation; either version 2 of
13 * the License, or (at your option) any later version.
15 * This file is part of the Berlios driver for WLAN USB devices based on the
16 * Atmel AT76C503A/505/505A.
18 * Some iw_handler code was taken from airo.c, (C) 1999 Benjamin Reed
21 #include <linux/init.h>
22 #include <linux/kernel.h>
23 #include <linux/sched.h>
24 #include <linux/errno.h>
25 #include <linux/slab.h>
26 #include <linux/module.h>
27 #include <linux/spinlock.h>
28 #include <linux/list.h>
29 #include <linux/usb.h>
30 #include <linux/netdevice.h>
31 #include <linux/if_arp.h>
32 #include <linux/etherdevice.h>
33 #include <linux/ethtool.h>
34 #include <linux/wireless.h>
35 #include <net/iw_handler.h>
36 #include <net/ieee80211_radiotap.h>
37 #include <linux/firmware.h>
38 #include <linux/leds.h>
39 #include <net/ieee80211.h>
43 /* Version information */
44 #define DRIVER_NAME "at76_usb"
45 #define DRIVER_VERSION "0.17"
46 #define DRIVER_DESC "Atmel at76x USB Wireless LAN Driver"
49 #define DBG_PROGRESS 0x00000001 /* authentication/accociation */
50 #define DBG_BSS_TABLE 0x00000002 /* show BSS table after scans */
51 #define DBG_IOCTL 0x00000004 /* ioctl calls / settings */
52 #define DBG_MAC_STATE 0x00000008 /* MAC state transitions */
53 #define DBG_TX_DATA 0x00000010 /* tx header */
54 #define DBG_TX_DATA_CONTENT 0x00000020 /* tx content */
55 #define DBG_TX_MGMT 0x00000040 /* tx management */
56 #define DBG_RX_DATA 0x00000080 /* rx data header */
57 #define DBG_RX_DATA_CONTENT 0x00000100 /* rx data content */
58 #define DBG_RX_MGMT 0x00000200 /* rx mgmt frame headers */
59 #define DBG_RX_BEACON 0x00000400 /* rx beacon */
60 #define DBG_RX_CTRL 0x00000800 /* rx control */
61 #define DBG_RX_MGMT_CONTENT 0x00001000 /* rx mgmt content */
62 #define DBG_RX_FRAGS 0x00002000 /* rx data fragment handling */
63 #define DBG_DEVSTART 0x00004000 /* fw download, device start */
64 #define DBG_URB 0x00008000 /* rx urb status, ... */
65 #define DBG_RX_ATMEL_HDR 0x00010000 /* Atmel-specific Rx headers */
66 #define DBG_PROC_ENTRY 0x00020000 /* procedure entries/exits */
67 #define DBG_PM 0x00040000 /* power management settings */
68 #define DBG_BSS_MATCH 0x00080000 /* BSS match failures */
69 #define DBG_PARAMS 0x00100000 /* show configured parameters */
70 #define DBG_WAIT_COMPLETE 0x00200000 /* command completion */
71 #define DBG_RX_FRAGS_SKB 0x00400000 /* skb header of Rx fragments */
72 #define DBG_BSS_TABLE_RM 0x00800000 /* purging bss table entries */
73 #define DBG_MONITOR_MODE 0x01000000 /* monitor mode */
74 #define DBG_MIB 0x02000000 /* dump all MIBs on startup */
75 #define DBG_MGMT_TIMER 0x04000000 /* dump mgmt_timer ops */
76 #define DBG_WE_EVENTS 0x08000000 /* dump wireless events */
77 #define DBG_FW 0x10000000 /* firmware download */
78 #define DBG_DFU 0x20000000 /* device firmware upgrade */
80 #define DBG_DEFAULTS 0
82 /* Use our own dbg macro */
83 #define at76_dbg(bits, format, arg...) \
85 if (at76_debug & (bits)) \
86 printk(KERN_DEBUG DRIVER_NAME ": " format "\n" , ## arg); \
89 static int at76_debug = DBG_DEFAULTS;
91 /* Protect against concurrent firmware loading and parsing */
92 static struct mutex fw_mutex;
94 static struct fwentry firmwares[] = {
96 [BOARD_503_ISL3861] = {"atmel_at76c503-i3861.bin"},
97 [BOARD_503_ISL3863] = {"atmel_at76c503-i3863.bin"},
98 [BOARD_503] = {"atmel_at76c503-rfmd.bin"},
99 [BOARD_503_ACC] = {"atmel_at76c503-rfmd-acc.bin"},
100 [BOARD_505] = {"atmel_at76c505-rfmd.bin"},
101 [BOARD_505_2958] = {"atmel_at76c505-rfmd2958.bin"},
102 [BOARD_505A] = {"atmel_at76c505a-rfmd2958.bin"},
103 [BOARD_505AMX] = {"atmel_at76c505amx-rfmd.bin"},
106 #define USB_DEVICE_DATA(__ops) .driver_info = (kernel_ulong_t)(__ops)
108 static struct usb_device_id dev_table[] = {
112 /* Generic AT76C503/3861 device */
113 {USB_DEVICE(0x03eb, 0x7603), USB_DEVICE_DATA(BOARD_503_ISL3861)},
114 /* Linksys WUSB11 v2.1/v2.6 */
115 {USB_DEVICE(0x066b, 0x2211), USB_DEVICE_DATA(BOARD_503_ISL3861)},
116 /* Netgear MA101 rev. A */
117 {USB_DEVICE(0x0864, 0x4100), USB_DEVICE_DATA(BOARD_503_ISL3861)},
118 /* Tekram U300C / Allnet ALL0193 */
119 {USB_DEVICE(0x0b3b, 0x1612), USB_DEVICE_DATA(BOARD_503_ISL3861)},
120 /* HP HN210W J7801A */
121 {USB_DEVICE(0x03f0, 0x011c), USB_DEVICE_DATA(BOARD_503_ISL3861)},
122 /* Sitecom/Z-Com/Zyxel M4Y-750 */
123 {USB_DEVICE(0x0cde, 0x0001), USB_DEVICE_DATA(BOARD_503_ISL3861)},
124 /* Dynalink/Askey WLL013 (intersil) */
125 {USB_DEVICE(0x069a, 0x0320), USB_DEVICE_DATA(BOARD_503_ISL3861)},
126 /* EZ connect 11Mpbs Wireless USB Adapter SMC2662W v1 */
127 {USB_DEVICE(0x0d5c, 0xa001), USB_DEVICE_DATA(BOARD_503_ISL3861)},
129 {USB_DEVICE(0x04a5, 0x9000), USB_DEVICE_DATA(BOARD_503_ISL3861)},
130 /* Addtron AWU-120, Compex WLU11 */
131 {USB_DEVICE(0x05dd, 0xff31), USB_DEVICE_DATA(BOARD_503_ISL3861)},
132 /* Intel AP310 AnyPoint II USB */
133 {USB_DEVICE(0x8086, 0x0200), USB_DEVICE_DATA(BOARD_503_ISL3861)},
135 {USB_DEVICE(0x0d8e, 0x7100), USB_DEVICE_DATA(BOARD_503_ISL3861)},
136 /* Arescom WL-210, FCC id 07J-GL2411USB */
137 {USB_DEVICE(0x0d8e, 0x7110), USB_DEVICE_DATA(BOARD_503_ISL3861)},
138 /* I-O DATA WN-B11/USB */
139 {USB_DEVICE(0x04bb, 0x0919), USB_DEVICE_DATA(BOARD_503_ISL3861)},
140 /* BT Voyager 1010 */
141 {USB_DEVICE(0x069a, 0x0821), USB_DEVICE_DATA(BOARD_503_ISL3861)},
145 /* Generic AT76C503/3863 device */
146 {USB_DEVICE(0x03eb, 0x7604), USB_DEVICE_DATA(BOARD_503_ISL3863)},
147 /* Samsung SWL-2100U */
148 {USB_DEVICE(0x055d, 0xa000), USB_DEVICE_DATA(BOARD_503_ISL3863)},
152 /* Generic AT76C503/RFMD device */
153 {USB_DEVICE(0x03eb, 0x7605), USB_DEVICE_DATA(BOARD_503)},
154 /* Dynalink/Askey WLL013 (rfmd) */
155 {USB_DEVICE(0x069a, 0x0321), USB_DEVICE_DATA(BOARD_503)},
156 /* Linksys WUSB11 v2.6 */
157 {USB_DEVICE(0x077b, 0x2219), USB_DEVICE_DATA(BOARD_503)},
158 /* Network Everywhere NWU11B */
159 {USB_DEVICE(0x077b, 0x2227), USB_DEVICE_DATA(BOARD_503)},
160 /* Netgear MA101 rev. B */
161 {USB_DEVICE(0x0864, 0x4102), USB_DEVICE_DATA(BOARD_503)},
162 /* D-Link DWL-120 rev. E */
163 {USB_DEVICE(0x2001, 0x3200), USB_DEVICE_DATA(BOARD_503)},
164 /* Actiontec 802UAT1, HWU01150-01UK */
165 {USB_DEVICE(0x1668, 0x7605), USB_DEVICE_DATA(BOARD_503)},
166 /* AirVast W-Buddie WN210 */
167 {USB_DEVICE(0x03eb, 0x4102), USB_DEVICE_DATA(BOARD_503)},
168 /* Dick Smith Electronics XH1153 802.11b USB adapter */
169 {USB_DEVICE(0x1371, 0x5743), USB_DEVICE_DATA(BOARD_503)},
171 {USB_DEVICE(0x1371, 0x0001), USB_DEVICE_DATA(BOARD_503)},
172 /* FiberLine FL-WL200U */
173 {USB_DEVICE(0x1371, 0x0002), USB_DEVICE_DATA(BOARD_503)},
174 /* BenQ AWL400 USB stick */
175 {USB_DEVICE(0x04a5, 0x9001), USB_DEVICE_DATA(BOARD_503)},
176 /* 3Com 3CRSHEW696 */
177 {USB_DEVICE(0x0506, 0x0a01), USB_DEVICE_DATA(BOARD_503)},
178 /* Siemens Santis ADSL WLAN USB adapter WLL 013 */
179 {USB_DEVICE(0x0681, 0x001b), USB_DEVICE_DATA(BOARD_503)},
180 /* Belkin F5D6050, version 2 */
181 {USB_DEVICE(0x050d, 0x0050), USB_DEVICE_DATA(BOARD_503)},
182 /* iBlitzz, BWU613 (not *B or *SB) */
183 {USB_DEVICE(0x07b8, 0xb000), USB_DEVICE_DATA(BOARD_503)},
184 /* Gigabyte GN-WLBM101 */
185 {USB_DEVICE(0x1044, 0x8003), USB_DEVICE_DATA(BOARD_503)},
186 /* Planex GW-US11S */
187 {USB_DEVICE(0x2019, 0x3220), USB_DEVICE_DATA(BOARD_503)},
188 /* Internal WLAN adapter in h5[4,5]xx series iPAQs */
189 {USB_DEVICE(0x049f, 0x0032), USB_DEVICE_DATA(BOARD_503)},
190 /* Corega Wireless LAN USB-11 mini */
191 {USB_DEVICE(0x07aa, 0x0011), USB_DEVICE_DATA(BOARD_503)},
192 /* Corega Wireless LAN USB-11 mini2 */
193 {USB_DEVICE(0x07aa, 0x0018), USB_DEVICE_DATA(BOARD_503)},
195 {USB_DEVICE(0x05dd, 0xff35), USB_DEVICE_DATA(BOARD_503)},
200 {USB_DEVICE(0x083a, 0x3501), USB_DEVICE_DATA(BOARD_503_ACC)},
201 /* Belkin F5D6050, SMC2662W v2, SMC2662W-AR */
202 {USB_DEVICE(0x0d5c, 0xa002), USB_DEVICE_DATA(BOARD_503_ACC)},
206 /* Generic AT76C505/RFMD */
207 {USB_DEVICE(0x03eb, 0x7606), USB_DEVICE_DATA(BOARD_505)},
211 /* Generic AT76C505/RFMD, OvisLink WL-1130USB */
212 {USB_DEVICE(0x03eb, 0x7613), USB_DEVICE_DATA(BOARD_505_2958)},
213 /* Fiberline FL-WL240U */
214 {USB_DEVICE(0x1371, 0x0014), USB_DEVICE_DATA(BOARD_505_2958)},
215 /* CNet CNUSB-611G */
216 {USB_DEVICE(0x1371, 0x0013), USB_DEVICE_DATA(BOARD_505_2958)},
217 /* Linksys WUSB11 v2.8 */
218 {USB_DEVICE(0x1915, 0x2233), USB_DEVICE_DATA(BOARD_505_2958)},
219 /* Xterasys XN-2122B, IBlitzz BWU613B/BWU613SB */
220 {USB_DEVICE(0x12fd, 0x1001), USB_DEVICE_DATA(BOARD_505_2958)},
221 /* Corega WLAN USB Stick 11 */
222 {USB_DEVICE(0x07aa, 0x7613), USB_DEVICE_DATA(BOARD_505_2958)},
223 /* Microstar MSI Box MS6978 */
224 {USB_DEVICE(0x0db0, 0x1020), USB_DEVICE_DATA(BOARD_505_2958)},
228 /* Generic AT76C505A device */
229 {USB_DEVICE(0x03eb, 0x7614), USB_DEVICE_DATA(BOARD_505A)},
230 /* Generic AT76C505AS device */
231 {USB_DEVICE(0x03eb, 0x7617), USB_DEVICE_DATA(BOARD_505A)},
232 /* Siemens Gigaset USB WLAN Adapter 11 */
233 {USB_DEVICE(0x1690, 0x0701), USB_DEVICE_DATA(BOARD_505A)},
237 /* Generic AT76C505AMX device */
238 {USB_DEVICE(0x03eb, 0x7615), USB_DEVICE_DATA(BOARD_505AMX)},
242 MODULE_DEVICE_TABLE(usb, dev_table);
244 /* Supported rates of this hardware, bit 7 marks basic rates */
245 static const u8 hw_rates[] = { 0x82, 0x84, 0x0b, 0x16 };
247 /* Frequency of each channel in MHz */
248 static const long channel_frequency[] = {
249 2412, 2417, 2422, 2427, 2432, 2437, 2442,
250 2447, 2452, 2457, 2462, 2467, 2472, 2484
253 #define NUM_CHANNELS ARRAY_SIZE(channel_frequency)
255 static const char *const preambles[] = { "long", "short", "auto" };
257 static const char *const mac_states[] = {
259 [MAC_SCANNING] = "SCANNING",
261 [MAC_ASSOC] = "ASSOC",
262 [MAC_JOINING] = "JOINING",
263 [MAC_CONNECTED] = "CONNECTED",
264 [MAC_OWN_IBSS] = "OWN_IBSS"
267 /* Firmware download */
269 #define STATE_IDLE 0x00
270 #define STATE_DETACH 0x01
271 #define STATE_DFU_IDLE 0x02
272 #define STATE_DFU_DOWNLOAD_SYNC 0x03
273 #define STATE_DFU_DOWNLOAD_BUSY 0x04
274 #define STATE_DFU_DOWNLOAD_IDLE 0x05
275 #define STATE_DFU_MANIFEST_SYNC 0x06
276 #define STATE_DFU_MANIFEST 0x07
277 #define STATE_DFU_MANIFEST_WAIT_RESET 0x08
278 #define STATE_DFU_UPLOAD_IDLE 0x09
279 #define STATE_DFU_ERROR 0x0a
285 #define DFU_GETSTATUS 3
286 #define DFU_CLRSTATUS 4
287 #define DFU_GETSTATE 5
290 #define FW_BLOCK_SIZE 1024
293 unsigned char status;
294 unsigned char poll_timeout[3];
296 unsigned char string;
297 } __attribute__((packed));
299 static inline int at76_is_intersil(enum board_type board)
301 return (board == BOARD_503_ISL3861 || board == BOARD_503_ISL3863);
304 static inline int at76_is_503rfmd(enum board_type board)
306 return (board == BOARD_503 || board == BOARD_503_ACC);
309 static inline int at76_is_505a(enum board_type board)
311 return (board == BOARD_505A || board == BOARD_505AMX);
314 /* Load a block of the first (internal) part of the firmware */
315 static int at76_load_int_fw_block(struct usb_device *udev, int blockno,
316 void *block, int size)
318 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), DFU_DNLOAD,
319 USB_TYPE_CLASS | USB_DIR_OUT |
320 USB_RECIP_INTERFACE, blockno, 0, block, size,
321 USB_CTRL_GET_TIMEOUT);
324 static int at76_dfu_get_status(struct usb_device *udev,
325 struct dfu_status *status)
329 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), DFU_GETSTATUS,
330 USB_TYPE_CLASS | USB_DIR_IN | USB_RECIP_INTERFACE,
331 0, 0, status, sizeof(struct dfu_status),
332 USB_CTRL_GET_TIMEOUT);
336 static u8 at76_dfu_get_state(struct usb_device *udev, u8 *state)
340 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), DFU_GETSTATE,
341 USB_TYPE_CLASS | USB_DIR_IN | USB_RECIP_INTERFACE,
342 0, 0, state, 1, USB_CTRL_GET_TIMEOUT);
346 /* Convert timeout from the DFU status to jiffies */
347 static inline unsigned long at76_get_timeout(struct dfu_status *s)
349 return msecs_to_jiffies((s->poll_timeout[2] << 16)
350 | (s->poll_timeout[1] << 8)
351 | (s->poll_timeout[0]));
354 /* Load internal firmware from the buffer. If manifest_sync_timeout > 0, use
355 * its value in jiffies in the MANIFEST_SYNC state. */
356 static int at76_usbdfu_download(struct usb_device *udev, u8 *buf, u32 size,
357 int manifest_sync_timeout)
360 struct dfu_status dfu_stat_buf;
362 int need_dfu_state = 1;
369 at76_dbg(DBG_DFU, "%s( %p, %u, %d)", __func__, buf, size,
370 manifest_sync_timeout);
373 dev_printk(KERN_ERR, &udev->dev, "FW buffer length invalid!\n");
377 block = kmalloc(FW_BLOCK_SIZE, GFP_KERNEL);
382 if (need_dfu_state) {
383 ret = at76_dfu_get_state(udev, &dfu_state);
385 dev_printk(KERN_ERR, &udev->dev,
386 "cannot get DFU state: %d\n", ret);
393 case STATE_DFU_DOWNLOAD_SYNC:
394 at76_dbg(DBG_DFU, "STATE_DFU_DOWNLOAD_SYNC");
395 ret = at76_dfu_get_status(udev, &dfu_stat_buf);
397 dfu_state = dfu_stat_buf.state;
398 dfu_timeout = at76_get_timeout(&dfu_stat_buf);
401 dev_printk(KERN_ERR, &udev->dev,
402 "at76_dfu_get_status returned %d\n",
406 case STATE_DFU_DOWNLOAD_BUSY:
407 at76_dbg(DBG_DFU, "STATE_DFU_DOWNLOAD_BUSY");
410 at76_dbg(DBG_DFU, "DFU: Resetting device");
411 schedule_timeout_interruptible(dfu_timeout);
414 case STATE_DFU_DOWNLOAD_IDLE:
415 at76_dbg(DBG_DFU, "DOWNLOAD...");
418 at76_dbg(DBG_DFU, "DFU IDLE");
420 bsize = min_t(int, size, FW_BLOCK_SIZE);
421 memcpy(block, buf, bsize);
422 at76_dbg(DBG_DFU, "int fw, size left = %5d, "
423 "bsize = %4d, blockno = %2d", size, bsize,
426 at76_load_int_fw_block(udev, blockno, block, bsize);
432 dev_printk(KERN_ERR, &udev->dev,
433 "at76_load_int_fw_block "
434 "returned %d\n", ret);
438 case STATE_DFU_MANIFEST_SYNC:
439 at76_dbg(DBG_DFU, "STATE_DFU_MANIFEST_SYNC");
441 ret = at76_dfu_get_status(udev, &dfu_stat_buf);
445 dfu_state = dfu_stat_buf.state;
446 dfu_timeout = at76_get_timeout(&dfu_stat_buf);
449 /* override the timeout from the status response,
450 needed for AT76C505A */
451 if (manifest_sync_timeout > 0)
452 dfu_timeout = manifest_sync_timeout;
454 at76_dbg(DBG_DFU, "DFU: Waiting for manifest phase");
455 schedule_timeout_interruptible(dfu_timeout);
458 case STATE_DFU_MANIFEST:
459 at76_dbg(DBG_DFU, "STATE_DFU_MANIFEST");
463 case STATE_DFU_MANIFEST_WAIT_RESET:
464 at76_dbg(DBG_DFU, "STATE_DFU_MANIFEST_WAIT_RESET");
468 case STATE_DFU_UPLOAD_IDLE:
469 at76_dbg(DBG_DFU, "STATE_DFU_UPLOAD_IDLE");
472 case STATE_DFU_ERROR:
473 at76_dbg(DBG_DFU, "STATE_DFU_ERROR");
478 at76_dbg(DBG_DFU, "DFU UNKNOWN STATE (%d)", dfu_state);
482 } while (!is_done && (ret >= 0));
492 /* Report that the scan results are ready */
493 static inline void at76_iwevent_scan_complete(struct net_device *netdev)
495 union iwreq_data wrqu;
496 wrqu.data.length = 0;
498 wireless_send_event(netdev, SIOCGIWSCAN, &wrqu, NULL);
499 at76_dbg(DBG_WE_EVENTS, "%s: SIOCGIWSCAN sent", netdev->name);
502 static inline void at76_iwevent_bss_connect(struct net_device *netdev,
505 union iwreq_data wrqu;
506 wrqu.data.length = 0;
508 memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
509 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
510 wireless_send_event(netdev, SIOCGIWAP, &wrqu, NULL);
511 at76_dbg(DBG_WE_EVENTS, "%s: %s: SIOCGIWAP sent", netdev->name,
515 static inline void at76_iwevent_bss_disconnect(struct net_device *netdev)
517 union iwreq_data wrqu;
518 wrqu.data.length = 0;
520 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
521 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
522 wireless_send_event(netdev, SIOCGIWAP, &wrqu, NULL);
523 at76_dbg(DBG_WE_EVENTS, "%s: %s: SIOCGIWAP sent", netdev->name,
527 #define HEX2STR_BUFFERS 4
528 #define HEX2STR_MAX_LEN 64
529 #define BIN2HEX(x) ((x) < 10 ? '0' + (x) : (x) + 'A' - 10)
531 /* Convert binary data into hex string */
532 static char *hex2str(void *buf, int len)
534 static atomic_t a = ATOMIC_INIT(0);
535 static char bufs[HEX2STR_BUFFERS][3 * HEX2STR_MAX_LEN + 1];
536 char *ret = bufs[atomic_inc_return(&a) & (HEX2STR_BUFFERS - 1)];
540 if (len > HEX2STR_MAX_LEN)
541 len = HEX2STR_MAX_LEN;
549 *obuf++ = BIN2HEX(*ibuf >> 4);
550 *obuf++ = BIN2HEX(*ibuf & 0xf);
559 #define MAC2STR_BUFFERS 4
561 static inline char *mac2str(u8 *mac)
563 static atomic_t a = ATOMIC_INIT(0);
564 static char bufs[MAC2STR_BUFFERS][6 * 3];
567 str = bufs[atomic_inc_return(&a) & (MAC2STR_BUFFERS - 1)];
568 sprintf(str, "%02x:%02x:%02x:%02x:%02x:%02x",
569 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
574 static int tx_activity;
575 static void at76_ledtrig_tx_timerfunc(unsigned long data);
576 static DEFINE_TIMER(ledtrig_tx_timer, at76_ledtrig_tx_timerfunc, 0, 0);
577 DEFINE_LED_TRIGGER(ledtrig_tx);
579 static void at76_ledtrig_tx_timerfunc(unsigned long data)
581 static int tx_lastactivity;
583 if (tx_lastactivity != tx_activity) {
584 tx_lastactivity = tx_activity;
585 led_trigger_event(ledtrig_tx, LED_FULL);
586 mod_timer(&ledtrig_tx_timer, jiffies + HZ / 4);
588 led_trigger_event(ledtrig_tx, LED_OFF);
591 static void at76_ledtrig_tx_activity(void)
594 if (!timer_pending(&ledtrig_tx_timer))
595 mod_timer(&ledtrig_tx_timer, jiffies + HZ / 4);
598 /* Check if the given ssid is hidden */
599 static inline int at76_is_hidden_ssid(u8 *ssid, int length)
601 static const u8 zeros[32];
606 if (length == 1 && ssid[0] == ' ')
609 return (memcmp(ssid, zeros, length) == 0);
612 static inline void at76_free_bss_list(struct at76_priv *priv)
614 struct list_head *next, *ptr;
617 spin_lock_irqsave(&priv->bss_list_spinlock, flags);
619 priv->curr_bss = NULL;
621 list_for_each_safe(ptr, next, &priv->bss_list) {
623 kfree(list_entry(ptr, struct bss_info, list));
626 spin_unlock_irqrestore(&priv->bss_list_spinlock, flags);
629 static int at76_remap(struct usb_device *udev)
632 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x0a,
633 USB_TYPE_VENDOR | USB_DIR_OUT |
634 USB_RECIP_INTERFACE, 0, 0, NULL, 0,
635 USB_CTRL_GET_TIMEOUT);
641 static int at76_get_op_mode(struct usb_device *udev)
646 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x33,
647 USB_TYPE_VENDOR | USB_DIR_IN |
648 USB_RECIP_INTERFACE, 0x01, 0, &op_mode, 1,
649 USB_CTRL_GET_TIMEOUT);
658 /* Load a block of the second ("external") part of the firmware */
659 static inline int at76_load_ext_fw_block(struct usb_device *udev, int blockno,
660 void *block, int size)
662 return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x0e,
663 USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
664 0x0802, blockno, block, size,
665 USB_CTRL_GET_TIMEOUT);
668 static inline int at76_get_hw_cfg(struct usb_device *udev,
669 union at76_hwcfg *buf, int buf_size)
671 return usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x33,
672 USB_TYPE_VENDOR | USB_DIR_IN |
673 USB_RECIP_INTERFACE, 0x0a02, 0,
674 buf, buf_size, USB_CTRL_GET_TIMEOUT);
677 /* Intersil boards use a different "value" for GetHWConfig requests */
678 static inline int at76_get_hw_cfg_intersil(struct usb_device *udev,
679 union at76_hwcfg *buf, int buf_size)
681 return usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x33,
682 USB_TYPE_VENDOR | USB_DIR_IN |
683 USB_RECIP_INTERFACE, 0x0902, 0,
684 buf, buf_size, USB_CTRL_GET_TIMEOUT);
687 /* Get the hardware configuration for the adapter and put it to the appropriate
688 * fields of 'priv' (the GetHWConfig request and interpretation of the result
689 * depends on the board type) */
690 static int at76_get_hw_config(struct at76_priv *priv)
693 union at76_hwcfg *hwcfg = kmalloc(sizeof(*hwcfg), GFP_KERNEL);
698 if (at76_is_intersil(priv->board_type)) {
699 ret = at76_get_hw_cfg_intersil(priv->udev, hwcfg,
703 memcpy(priv->mac_addr, hwcfg->i.mac_addr, ETH_ALEN);
704 priv->regulatory_domain = hwcfg->i.regulatory_domain;
705 } else if (at76_is_503rfmd(priv->board_type)) {
706 ret = at76_get_hw_cfg(priv->udev, hwcfg, sizeof(hwcfg->r3));
709 memcpy(priv->mac_addr, hwcfg->r3.mac_addr, ETH_ALEN);
710 priv->regulatory_domain = hwcfg->r3.regulatory_domain;
712 ret = at76_get_hw_cfg(priv->udev, hwcfg, sizeof(hwcfg->r5));
715 memcpy(priv->mac_addr, hwcfg->r5.mac_addr, ETH_ALEN);
716 priv->regulatory_domain = hwcfg->r5.regulatory_domain;
722 printk(KERN_ERR "%s: cannot get HW Config (error %d)\n",
723 priv->netdev->name, ret);
728 static struct reg_domain const *at76_get_reg_domain(u16 code)
731 static struct reg_domain const fd_tab[] = {
732 {0x10, "FCC (USA)", 0x7ff}, /* ch 1-11 */
733 {0x20, "IC (Canada)", 0x7ff}, /* ch 1-11 */
734 {0x30, "ETSI (most of Europe)", 0x1fff}, /* ch 1-13 */
735 {0x31, "Spain", 0x600}, /* ch 10-11 */
736 {0x32, "France", 0x1e00}, /* ch 10-13 */
737 {0x40, "MKK (Japan)", 0x2000}, /* ch 14 */
738 {0x41, "MKK1 (Japan)", 0x3fff}, /* ch 1-14 */
739 {0x50, "Israel", 0x3fc}, /* ch 3-9 */
740 {0x00, "<unknown>", 0xffffffff} /* ch 1-32 */
743 /* Last entry is fallback for unknown domain code */
744 for (i = 0; i < ARRAY_SIZE(fd_tab) - 1; i++)
745 if (code == fd_tab[i].code)
751 static inline int at76_get_mib(struct usb_device *udev, u16 mib, void *buf,
756 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x33,
757 USB_TYPE_VENDOR | USB_DIR_IN |
758 USB_RECIP_INTERFACE, mib << 8, 0, buf, buf_size,
759 USB_CTRL_GET_TIMEOUT);
760 if (ret >= 0 && ret != buf_size)
765 /* Return positive number for status, negative for an error */
766 static inline int at76_get_cmd_status(struct usb_device *udev, u8 cmd)
771 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x22,
772 USB_TYPE_VENDOR | USB_DIR_IN |
773 USB_RECIP_INTERFACE, cmd, 0, stat_buf,
774 sizeof(stat_buf), USB_CTRL_GET_TIMEOUT);
781 static int at76_set_card_command(struct usb_device *udev, int cmd, void *buf,
785 struct at76_command *cmd_buf = kmalloc(sizeof(struct at76_command) +
786 buf_size, GFP_KERNEL);
792 cmd_buf->reserved = 0;
793 cmd_buf->size = cpu_to_le16(buf_size);
794 memcpy(cmd_buf->data, buf, buf_size);
796 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x0e,
797 USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
799 sizeof(struct at76_command) + buf_size,
800 USB_CTRL_GET_TIMEOUT);
805 #define MAKE_CMD_STATUS_CASE(c) case (c): return #c
806 static const char *at76_get_cmd_status_string(u8 cmd_status)
808 switch (cmd_status) {
809 MAKE_CMD_STATUS_CASE(CMD_STATUS_IDLE);
810 MAKE_CMD_STATUS_CASE(CMD_STATUS_COMPLETE);
811 MAKE_CMD_STATUS_CASE(CMD_STATUS_UNKNOWN);
812 MAKE_CMD_STATUS_CASE(CMD_STATUS_INVALID_PARAMETER);
813 MAKE_CMD_STATUS_CASE(CMD_STATUS_FUNCTION_NOT_SUPPORTED);
814 MAKE_CMD_STATUS_CASE(CMD_STATUS_TIME_OUT);
815 MAKE_CMD_STATUS_CASE(CMD_STATUS_IN_PROGRESS);
816 MAKE_CMD_STATUS_CASE(CMD_STATUS_HOST_FAILURE);
817 MAKE_CMD_STATUS_CASE(CMD_STATUS_SCAN_FAILED);
823 /* Wait until the command is completed */
824 static int at76_wait_completion(struct at76_priv *priv, int cmd)
827 unsigned long timeout = jiffies + CMD_COMPLETION_TIMEOUT;
830 status = at76_get_cmd_status(priv->udev, cmd);
832 printk(KERN_ERR "%s: at76_get_cmd_status failed: %d\n",
833 priv->netdev->name, status);
837 at76_dbg(DBG_WAIT_COMPLETE,
838 "%s: Waiting on cmd %d, status = %d (%s)",
839 priv->netdev->name, cmd, status,
840 at76_get_cmd_status_string(status));
842 if (status != CMD_STATUS_IN_PROGRESS
843 && status != CMD_STATUS_IDLE)
846 schedule_timeout_interruptible(HZ / 10); /* 100 ms */
847 if (time_after(jiffies, timeout)) {
849 "%s: completion timeout for command %d\n",
850 priv->netdev->name, cmd);
859 static int at76_set_mib(struct at76_priv *priv, struct set_mib_buffer *buf)
863 ret = at76_set_card_command(priv->udev, CMD_SET_MIB, buf,
864 offsetof(struct set_mib_buffer,
869 ret = at76_wait_completion(priv, CMD_SET_MIB);
870 if (ret != CMD_STATUS_COMPLETE) {
872 "%s: set_mib: at76_wait_completion failed "
873 "with %d\n", priv->netdev->name, ret);
880 /* Return < 0 on error, == 0 if no command sent, == 1 if cmd sent */
881 static int at76_set_radio(struct at76_priv *priv, int enable)
886 if (priv->radio_on == enable)
889 cmd = enable ? CMD_RADIO_ON : CMD_RADIO_OFF;
891 ret = at76_set_card_command(priv->udev, cmd, NULL, 0);
893 printk(KERN_ERR "%s: at76_set_card_command(%d) failed: %d\n",
894 priv->netdev->name, cmd, ret);
898 priv->radio_on = enable;
902 /* Set current power save mode (AT76_PM_OFF/AT76_PM_ON/AT76_PM_SMART) */
903 static int at76_set_pm_mode(struct at76_priv *priv)
907 priv->mib_buf.type = MIB_MAC_MGMT;
908 priv->mib_buf.size = 1;
909 priv->mib_buf.index = offsetof(struct mib_mac_mgmt, power_mgmt_mode);
910 priv->mib_buf.data.byte = priv->pm_mode;
912 ret = at76_set_mib(priv, &priv->mib_buf);
914 printk(KERN_ERR "%s: set_mib (pm_mode) failed: %d\n",
915 priv->netdev->name, ret);
920 /* Set the association id for power save mode */
921 static int at76_set_associd(struct at76_priv *priv, u16 id)
925 priv->mib_buf.type = MIB_MAC_MGMT;
926 priv->mib_buf.size = 2;
927 priv->mib_buf.index = offsetof(struct mib_mac_mgmt, station_id);
928 priv->mib_buf.data.word = cpu_to_le16(id);
930 ret = at76_set_mib(priv, &priv->mib_buf);
932 printk(KERN_ERR "%s: set_mib (associd) failed: %d\n",
933 priv->netdev->name, ret);
938 /* Set the listen interval for power save mode */
939 static int at76_set_listen_interval(struct at76_priv *priv, u16 interval)
943 priv->mib_buf.type = MIB_MAC;
944 priv->mib_buf.size = 2;
945 priv->mib_buf.index = offsetof(struct mib_mac, listen_interval);
946 priv->mib_buf.data.word = cpu_to_le16(interval);
948 ret = at76_set_mib(priv, &priv->mib_buf);
951 "%s: set_mib (listen_interval) failed: %d\n",
952 priv->netdev->name, ret);
957 static int at76_set_preamble(struct at76_priv *priv, u8 type)
961 priv->mib_buf.type = MIB_LOCAL;
962 priv->mib_buf.size = 1;
963 priv->mib_buf.index = offsetof(struct mib_local, preamble_type);
964 priv->mib_buf.data.byte = type;
966 ret = at76_set_mib(priv, &priv->mib_buf);
968 printk(KERN_ERR "%s: set_mib (preamble) failed: %d\n",
969 priv->netdev->name, ret);
974 static int at76_set_frag(struct at76_priv *priv, u16 size)
978 priv->mib_buf.type = MIB_MAC;
979 priv->mib_buf.size = 2;
980 priv->mib_buf.index = offsetof(struct mib_mac, frag_threshold);
981 priv->mib_buf.data.word = cpu_to_le16(size);
983 ret = at76_set_mib(priv, &priv->mib_buf);
985 printk(KERN_ERR "%s: set_mib (frag threshold) failed: %d\n",
986 priv->netdev->name, ret);
991 static int at76_set_rts(struct at76_priv *priv, u16 size)
995 priv->mib_buf.type = MIB_MAC;
996 priv->mib_buf.size = 2;
997 priv->mib_buf.index = offsetof(struct mib_mac, rts_threshold);
998 priv->mib_buf.data.word = cpu_to_le16(size);
1000 ret = at76_set_mib(priv, &priv->mib_buf);
1002 printk(KERN_ERR "%s: set_mib (rts) failed: %d\n",
1003 priv->netdev->name, ret);
1008 static int at76_set_autorate_fallback(struct at76_priv *priv, int onoff)
1012 priv->mib_buf.type = MIB_LOCAL;
1013 priv->mib_buf.size = 1;
1014 priv->mib_buf.index = offsetof(struct mib_local, txautorate_fallback);
1015 priv->mib_buf.data.byte = onoff;
1017 ret = at76_set_mib(priv, &priv->mib_buf);
1019 printk(KERN_ERR "%s: set_mib (autorate fallback) failed: %d\n",
1020 priv->netdev->name, ret);
1025 static int at76_add_mac_address(struct at76_priv *priv, void *addr)
1029 priv->mib_buf.type = MIB_MAC_ADDR;
1030 priv->mib_buf.size = ETH_ALEN;
1031 priv->mib_buf.index = offsetof(struct mib_mac_addr, mac_addr);
1032 memcpy(priv->mib_buf.data.addr, addr, ETH_ALEN);
1034 ret = at76_set_mib(priv, &priv->mib_buf);
1036 printk(KERN_ERR "%s: set_mib (MAC_ADDR, mac_addr) failed: %d\n",
1037 priv->netdev->name, ret);
1042 static void at76_dump_mib_mac_addr(struct at76_priv *priv)
1046 struct mib_mac_addr *m = kmalloc(sizeof(struct mib_mac_addr),
1052 ret = at76_get_mib(priv->udev, MIB_MAC_ADDR, m,
1053 sizeof(struct mib_mac_addr));
1055 printk(KERN_ERR "%s: at76_get_mib (MAC_ADDR) failed: %d\n",
1056 priv->netdev->name, ret);
1060 at76_dbg(DBG_MIB, "%s: MIB MAC_ADDR: mac_addr %s res 0x%x 0x%x",
1062 mac2str(m->mac_addr), m->res[0], m->res[1]);
1063 for (i = 0; i < ARRAY_SIZE(m->group_addr); i++)
1064 at76_dbg(DBG_MIB, "%s: MIB MAC_ADDR: group addr %d: %s, "
1065 "status %d", priv->netdev->name, i,
1066 mac2str(m->group_addr[i]), m->group_addr_status[i]);
1071 static void at76_dump_mib_mac_wep(struct at76_priv *priv)
1076 struct mib_mac_wep *m = kmalloc(sizeof(struct mib_mac_wep), GFP_KERNEL);
1081 ret = at76_get_mib(priv->udev, MIB_MAC_WEP, m,
1082 sizeof(struct mib_mac_wep));
1084 printk(KERN_ERR "%s: at76_get_mib (MAC_WEP) failed: %d\n",
1085 priv->netdev->name, ret);
1089 at76_dbg(DBG_MIB, "%s: MIB MAC_WEP: priv_invoked %u def_key_id %u "
1090 "key_len %u excl_unencr %u wep_icv_err %u wep_excluded %u "
1091 "encr_level %u key %d", priv->netdev->name,
1092 m->privacy_invoked, m->wep_default_key_id,
1093 m->wep_key_mapping_len, m->exclude_unencrypted,
1094 le32_to_cpu(m->wep_icv_error_count),
1095 le32_to_cpu(m->wep_excluded_count), m->encryption_level,
1096 m->wep_default_key_id);
1098 key_len = (m->encryption_level == 1) ?
1099 WEP_SMALL_KEY_LEN : WEP_LARGE_KEY_LEN;
1101 for (i = 0; i < WEP_KEYS; i++)
1102 at76_dbg(DBG_MIB, "%s: MIB MAC_WEP: key %d: %s",
1103 priv->netdev->name, i,
1104 hex2str(m->wep_default_keyvalue[i], key_len));
1109 static void at76_dump_mib_mac_mgmt(struct at76_priv *priv)
1112 struct mib_mac_mgmt *m = kmalloc(sizeof(struct mib_mac_mgmt),
1118 ret = at76_get_mib(priv->udev, MIB_MAC_MGMT, m,
1119 sizeof(struct mib_mac_mgmt));
1121 printk(KERN_ERR "%s: at76_get_mib (MAC_MGMT) failed: %d\n",
1122 priv->netdev->name, ret);
1126 at76_dbg(DBG_MIB, "%s: MIB MAC_MGMT: beacon_period %d CFP_max_duration "
1127 "%d medium_occupancy_limit %d station_id 0x%x ATIM_window %d "
1128 "CFP_mode %d privacy_opt_impl %d DTIM_period %d CFP_period %d "
1129 "current_bssid %s current_essid %s current_bss_type %d "
1130 "pm_mode %d ibss_change %d res %d "
1131 "multi_domain_capability_implemented %d "
1132 "international_roaming %d country_string %.3s",
1133 priv->netdev->name, le16_to_cpu(m->beacon_period),
1134 le16_to_cpu(m->CFP_max_duration),
1135 le16_to_cpu(m->medium_occupancy_limit),
1136 le16_to_cpu(m->station_id), le16_to_cpu(m->ATIM_window),
1137 m->CFP_mode, m->privacy_option_implemented, m->DTIM_period,
1138 m->CFP_period, mac2str(m->current_bssid),
1139 hex2str(m->current_essid, IW_ESSID_MAX_SIZE),
1140 m->current_bss_type, m->power_mgmt_mode, m->ibss_change,
1141 m->res, m->multi_domain_capability_implemented,
1142 m->multi_domain_capability_enabled, m->country_string);
1147 static void at76_dump_mib_mac(struct at76_priv *priv)
1150 struct mib_mac *m = kmalloc(sizeof(struct mib_mac), GFP_KERNEL);
1155 ret = at76_get_mib(priv->udev, MIB_MAC, m, sizeof(struct mib_mac));
1157 printk(KERN_ERR "%s: at76_get_mib (MAC) failed: %d\n",
1158 priv->netdev->name, ret);
1162 at76_dbg(DBG_MIB, "%s: MIB MAC: max_tx_msdu_lifetime %d "
1163 "max_rx_lifetime %d frag_threshold %d rts_threshold %d "
1164 "cwmin %d cwmax %d short_retry_time %d long_retry_time %d "
1165 "scan_type %d scan_channel %d probe_delay %u "
1166 "min_channel_time %d max_channel_time %d listen_int %d "
1167 "desired_ssid %s desired_bssid %s desired_bsstype %d",
1168 priv->netdev->name, le32_to_cpu(m->max_tx_msdu_lifetime),
1169 le32_to_cpu(m->max_rx_lifetime),
1170 le16_to_cpu(m->frag_threshold), le16_to_cpu(m->rts_threshold),
1171 le16_to_cpu(m->cwmin), le16_to_cpu(m->cwmax),
1172 m->short_retry_time, m->long_retry_time, m->scan_type,
1173 m->scan_channel, le16_to_cpu(m->probe_delay),
1174 le16_to_cpu(m->min_channel_time),
1175 le16_to_cpu(m->max_channel_time),
1176 le16_to_cpu(m->listen_interval),
1177 hex2str(m->desired_ssid, IW_ESSID_MAX_SIZE),
1178 mac2str(m->desired_bssid), m->desired_bsstype);
1183 static void at76_dump_mib_phy(struct at76_priv *priv)
1186 struct mib_phy *m = kmalloc(sizeof(struct mib_phy), GFP_KERNEL);
1191 ret = at76_get_mib(priv->udev, MIB_PHY, m, sizeof(struct mib_phy));
1193 printk(KERN_ERR "%s: at76_get_mib (PHY) failed: %d\n",
1194 priv->netdev->name, ret);
1198 at76_dbg(DBG_MIB, "%s: MIB PHY: ed_threshold %d slot_time %d "
1199 "sifs_time %d preamble_length %d plcp_header_length %d "
1200 "mpdu_max_length %d cca_mode_supported %d operation_rate_set "
1201 "0x%x 0x%x 0x%x 0x%x channel_id %d current_cca_mode %d "
1202 "phy_type %d current_reg_domain %d",
1203 priv->netdev->name, le32_to_cpu(m->ed_threshold),
1204 le16_to_cpu(m->slot_time), le16_to_cpu(m->sifs_time),
1205 le16_to_cpu(m->preamble_length),
1206 le16_to_cpu(m->plcp_header_length),
1207 le16_to_cpu(m->mpdu_max_length),
1208 le16_to_cpu(m->cca_mode_supported), m->operation_rate_set[0],
1209 m->operation_rate_set[1], m->operation_rate_set[2],
1210 m->operation_rate_set[3], m->channel_id, m->current_cca_mode,
1211 m->phy_type, m->current_reg_domain);
1216 static void at76_dump_mib_local(struct at76_priv *priv)
1219 struct mib_local *m = kmalloc(sizeof(struct mib_phy), GFP_KERNEL);
1224 ret = at76_get_mib(priv->udev, MIB_LOCAL, m, sizeof(struct mib_local));
1226 printk(KERN_ERR "%s: at76_get_mib (LOCAL) failed: %d\n",
1227 priv->netdev->name, ret);
1231 at76_dbg(DBG_MIB, "%s: MIB LOCAL: beacon_enable %d "
1232 "txautorate_fallback %d ssid_size %d promiscuous_mode %d "
1233 "preamble_type %d", priv->netdev->name, m->beacon_enable,
1234 m->txautorate_fallback, m->ssid_size, m->promiscuous_mode,
1240 static void at76_dump_mib_mdomain(struct at76_priv *priv)
1243 struct mib_mdomain *m = kmalloc(sizeof(struct mib_mdomain), GFP_KERNEL);
1248 ret = at76_get_mib(priv->udev, MIB_MDOMAIN, m,
1249 sizeof(struct mib_mdomain));
1251 printk(KERN_ERR "%s: at76_get_mib (MDOMAIN) failed: %d\n",
1252 priv->netdev->name, ret);
1256 at76_dbg(DBG_MIB, "%s: MIB MDOMAIN: channel_list %s",
1258 hex2str(m->channel_list, sizeof(m->channel_list)));
1260 at76_dbg(DBG_MIB, "%s: MIB MDOMAIN: tx_powerlevel %s",
1262 hex2str(m->tx_powerlevel, sizeof(m->tx_powerlevel)));
1267 static int at76_get_current_bssid(struct at76_priv *priv)
1270 struct mib_mac_mgmt *mac_mgmt =
1271 kmalloc(sizeof(struct mib_mac_mgmt), GFP_KERNEL);
1278 ret = at76_get_mib(priv->udev, MIB_MAC_MGMT, mac_mgmt,
1279 sizeof(struct mib_mac_mgmt));
1281 printk(KERN_ERR "%s: at76_get_mib failed: %d\n",
1282 priv->netdev->name, ret);
1285 memcpy(priv->bssid, mac_mgmt->current_bssid, ETH_ALEN);
1286 printk(KERN_INFO "%s: using BSSID %s\n", priv->netdev->name,
1287 mac2str(priv->bssid));
1294 static int at76_get_current_channel(struct at76_priv *priv)
1297 struct mib_phy *phy = kmalloc(sizeof(struct mib_phy), GFP_KERNEL);
1303 ret = at76_get_mib(priv->udev, MIB_PHY, phy, sizeof(struct mib_phy));
1305 printk(KERN_ERR "%s: at76_get_mib(MIB_PHY) failed: %d\n",
1306 priv->netdev->name, ret);
1309 priv->channel = phy->channel_id;
1317 * at76_start_scan - start a scan
1319 * @use_essid - use the configured ESSID in non passive mode
1321 static int at76_start_scan(struct at76_priv *priv, int use_essid)
1323 struct at76_req_scan scan;
1325 memset(&scan, 0, sizeof(struct at76_req_scan));
1326 memset(scan.bssid, 0xff, ETH_ALEN);
1329 memcpy(scan.essid, priv->essid, IW_ESSID_MAX_SIZE);
1330 scan.essid_size = priv->essid_size;
1332 scan.essid_size = 0;
1334 /* jal: why should we start at a certain channel? we do scan the whole
1335 range allowed by reg domain. */
1336 scan.channel = priv->channel;
1338 /* atmelwlandriver differs between scan type 0 and 1 (active/passive)
1339 For ad-hoc mode, it uses type 0 only. */
1340 scan.scan_type = priv->scan_mode;
1342 /* INFO: For probe_delay, not multiplying by 1024 as this will be
1343 slightly less than min_channel_time
1344 (per spec: probe delay < min. channel time) */
1345 scan.min_channel_time = cpu_to_le16(priv->scan_min_time);
1346 scan.max_channel_time = cpu_to_le16(priv->scan_max_time);
1347 scan.probe_delay = cpu_to_le16(priv->scan_min_time * 1000);
1348 scan.international_scan = 0;
1350 /* other values are set to 0 for type 0 */
1352 at76_dbg(DBG_PROGRESS, "%s: start_scan (use_essid = %d, intl = %d, "
1353 "channel = %d, probe_delay = %d, scan_min_time = %d, "
1354 "scan_max_time = %d)",
1355 priv->netdev->name, use_essid,
1356 scan.international_scan, scan.channel,
1357 le16_to_cpu(scan.probe_delay),
1358 le16_to_cpu(scan.min_channel_time),
1359 le16_to_cpu(scan.max_channel_time));
1361 return at76_set_card_command(priv->udev, CMD_SCAN, &scan, sizeof(scan));
1364 /* Enable monitor mode */
1365 static int at76_start_monitor(struct at76_priv *priv)
1367 struct at76_req_scan scan;
1370 memset(&scan, 0, sizeof(struct at76_req_scan));
1371 memset(scan.bssid, 0xff, ETH_ALEN);
1373 scan.channel = priv->channel;
1374 scan.scan_type = SCAN_TYPE_PASSIVE;
1375 scan.international_scan = 0;
1377 ret = at76_set_card_command(priv->udev, CMD_SCAN, &scan, sizeof(scan));
1379 ret = at76_get_cmd_status(priv->udev, CMD_SCAN);
1384 static int at76_start_ibss(struct at76_priv *priv)
1386 struct at76_req_ibss bss;
1389 WARN_ON(priv->mac_state != MAC_OWN_IBSS);
1390 if (priv->mac_state != MAC_OWN_IBSS)
1393 memset(&bss, 0, sizeof(struct at76_req_ibss));
1394 memset(bss.bssid, 0xff, ETH_ALEN);
1395 memcpy(bss.essid, priv->essid, IW_ESSID_MAX_SIZE);
1396 bss.essid_size = priv->essid_size;
1397 bss.bss_type = ADHOC_MODE;
1398 bss.channel = priv->channel;
1400 ret = at76_set_card_command(priv->udev, CMD_START_IBSS, &bss,
1401 sizeof(struct at76_req_ibss));
1403 printk(KERN_ERR "%s: start_ibss failed: %d\n",
1404 priv->netdev->name, ret);
1408 ret = at76_wait_completion(priv, CMD_START_IBSS);
1409 if (ret != CMD_STATUS_COMPLETE) {
1410 printk(KERN_ERR "%s: start_ibss failed to complete, %d\n",
1411 priv->netdev->name, ret);
1415 ret = at76_get_current_bssid(priv);
1419 ret = at76_get_current_channel(priv);
1423 /* not sure what this is good for ??? */
1424 priv->mib_buf.type = MIB_MAC_MGMT;
1425 priv->mib_buf.size = 1;
1426 priv->mib_buf.index = offsetof(struct mib_mac_mgmt, ibss_change);
1427 priv->mib_buf.data.byte = 0;
1429 ret = at76_set_mib(priv, &priv->mib_buf);
1431 printk(KERN_ERR "%s: set_mib (ibss change ok) failed: %d\n",
1432 priv->netdev->name, ret);
1436 netif_carrier_on(priv->netdev);
1437 netif_start_queue(priv->netdev);
1441 /* Request card to join BSS in managed or ad-hoc mode */
1442 static int at76_join_bss(struct at76_priv *priv, struct bss_info *ptr)
1444 struct at76_req_join join;
1448 memset(&join, 0, sizeof(struct at76_req_join));
1449 memcpy(join.bssid, ptr->bssid, ETH_ALEN);
1450 memcpy(join.essid, ptr->ssid, ptr->ssid_len);
1451 join.essid_size = ptr->ssid_len;
1452 join.bss_type = (priv->iw_mode == IW_MODE_ADHOC ? 1 : 2);
1453 join.channel = ptr->channel;
1454 join.timeout = cpu_to_le16(2000);
1456 at76_dbg(DBG_PROGRESS,
1457 "%s join addr %s ssid %s type %d ch %d timeout %d",
1458 priv->netdev->name, mac2str(join.bssid), join.essid,
1459 join.bss_type, join.channel, le16_to_cpu(join.timeout));
1460 return at76_set_card_command(priv->udev, CMD_JOIN, &join,
1461 sizeof(struct at76_req_join));
1464 /* Calculate padding from txbuf->wlength (which excludes the USB TX header),
1465 likely to compensate a flaw in the AT76C503A USB part ... */
1466 static inline int at76_calc_padding(int wlen)
1468 /* add the USB TX header */
1469 wlen += AT76_TX_HDRLEN;
1477 return 64 + 50 - wlen;
1482 /* We are doing a lot of things here in an interrupt. Need
1483 a bh handler (Watching TV with a TV card is probably
1484 a good test: if you see flickers, we are doing too much.
1485 Currently I do see flickers... even with our tasklet :-( )
1486 Maybe because the bttv driver and usb-uhci use the same interrupt
1488 /* Or maybe because our BH handler is preempting bttv's BH handler.. BHs don't
1489 * solve everything.. (alex) */
1490 static void at76_rx_callback(struct urb *urb)
1492 struct at76_priv *priv = urb->context;
1494 priv->rx_tasklet.data = (unsigned long)urb;
1495 tasklet_schedule(&priv->rx_tasklet);
1499 static void at76_tx_callback(struct urb *urb)
1501 struct at76_priv *priv = urb->context;
1502 struct net_device_stats *stats = &priv->stats;
1503 unsigned long flags;
1504 struct at76_tx_buffer *mgmt_buf;
1507 switch (urb->status) {
1509 stats->tx_packets++;
1513 /* urb has been unlinked */
1516 at76_dbg(DBG_URB, "%s - nonzero tx status received: %d",
1517 __func__, urb->status);
1522 spin_lock_irqsave(&priv->mgmt_spinlock, flags);
1523 mgmt_buf = priv->next_mgmt_bulk;
1524 priv->next_mgmt_bulk = NULL;
1525 spin_unlock_irqrestore(&priv->mgmt_spinlock, flags);
1528 netif_wake_queue(priv->netdev);
1532 /* we don't copy the padding bytes, but add them
1534 memcpy(priv->bulk_out_buffer, mgmt_buf,
1535 le16_to_cpu(mgmt_buf->wlength) + AT76_TX_HDRLEN);
1536 usb_fill_bulk_urb(priv->tx_urb, priv->udev, priv->tx_pipe,
1537 priv->bulk_out_buffer,
1538 le16_to_cpu(mgmt_buf->wlength) + mgmt_buf->padding +
1539 AT76_TX_HDRLEN, at76_tx_callback, priv);
1540 ret = usb_submit_urb(priv->tx_urb, GFP_ATOMIC);
1542 printk(KERN_ERR "%s: error in tx submit urb: %d\n",
1543 priv->netdev->name, ret);
1548 /* Send a management frame on bulk-out. txbuf->wlength must be set */
1549 static int at76_tx_mgmt(struct at76_priv *priv, struct at76_tx_buffer *txbuf)
1551 unsigned long flags;
1554 void *oldbuf = NULL;
1556 netif_carrier_off(priv->netdev); /* stop netdev watchdog */
1557 netif_stop_queue(priv->netdev); /* stop tx data packets */
1559 spin_lock_irqsave(&priv->mgmt_spinlock, flags);
1561 urb_status = priv->tx_urb->status;
1562 if (urb_status == -EINPROGRESS) {
1563 /* cannot transmit now, put in the queue */
1564 oldbuf = priv->next_mgmt_bulk;
1565 priv->next_mgmt_bulk = txbuf;
1567 spin_unlock_irqrestore(&priv->mgmt_spinlock, flags);
1570 /* a data/mgmt tx is already pending in the URB -
1571 if this is no error in some situations we must
1572 implement a queue or silently modify the old msg */
1573 printk(KERN_ERR "%s: removed pending mgmt buffer %s\n",
1574 priv->netdev->name, hex2str(oldbuf, 64));
1579 txbuf->tx_rate = TX_RATE_1MBIT;
1580 txbuf->padding = at76_calc_padding(le16_to_cpu(txbuf->wlength));
1581 memset(txbuf->reserved, 0, sizeof(txbuf->reserved));
1583 if (priv->next_mgmt_bulk)
1584 printk(KERN_ERR "%s: URB status %d, but mgmt is pending\n",
1585 priv->netdev->name, urb_status);
1587 at76_dbg(DBG_TX_MGMT,
1588 "%s: tx mgmt: wlen %d tx_rate %d pad %d %s",
1589 priv->netdev->name, le16_to_cpu(txbuf->wlength),
1590 txbuf->tx_rate, txbuf->padding,
1591 hex2str(txbuf->packet, le16_to_cpu(txbuf->wlength)));
1593 /* txbuf was not consumed above -> send mgmt msg immediately */
1594 memcpy(priv->bulk_out_buffer, txbuf,
1595 le16_to_cpu(txbuf->wlength) + AT76_TX_HDRLEN);
1596 usb_fill_bulk_urb(priv->tx_urb, priv->udev, priv->tx_pipe,
1597 priv->bulk_out_buffer,
1598 le16_to_cpu(txbuf->wlength) + txbuf->padding +
1599 AT76_TX_HDRLEN, at76_tx_callback, priv);
1600 ret = usb_submit_urb(priv->tx_urb, GFP_ATOMIC);
1602 printk(KERN_ERR "%s: error in tx submit urb: %d\n",
1603 priv->netdev->name, ret);
1610 /* Go to the next information element */
1611 static inline void next_ie(struct ieee80211_info_element **ie)
1613 *ie = (struct ieee80211_info_element *)(&(*ie)->data[(*ie)->len]);
1616 /* Challenge is the challenge string (in TLV format)
1617 we got with seq_nr 2 for shared secret authentication only and
1618 send in seq_nr 3 WEP encrypted to prove we have the correct WEP key;
1619 otherwise it is NULL */
1620 static int at76_auth_req(struct at76_priv *priv, struct bss_info *bss,
1621 int seq_nr, struct ieee80211_info_element *challenge)
1623 struct at76_tx_buffer *tx_buffer;
1624 struct ieee80211_hdr_3addr *mgmt;
1625 struct ieee80211_auth *req;
1626 int buf_len = (seq_nr != 3 ? AUTH_FRAME_SIZE :
1627 AUTH_FRAME_SIZE + 1 + 1 + challenge->len);
1630 BUG_ON(seq_nr == 3 && !challenge);
1631 tx_buffer = kmalloc(buf_len + MAX_PADDING_SIZE, GFP_ATOMIC);
1635 req = (struct ieee80211_auth *)tx_buffer->packet;
1636 mgmt = &req->header;
1638 /* make wireless header */
1639 /* first auth msg is not encrypted, only the second (seq_nr == 3) */
1641 cpu_to_le16(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_AUTH |
1642 (seq_nr == 3 ? IEEE80211_FCTL_PROTECTED : 0));
1644 mgmt->duration_id = cpu_to_le16(0x8000);
1645 memcpy(mgmt->addr1, bss->bssid, ETH_ALEN);
1646 memcpy(mgmt->addr2, priv->netdev->dev_addr, ETH_ALEN);
1647 memcpy(mgmt->addr3, bss->bssid, ETH_ALEN);
1648 mgmt->seq_ctl = cpu_to_le16(0);
1650 req->algorithm = cpu_to_le16(priv->auth_mode);
1651 req->transaction = cpu_to_le16(seq_nr);
1652 req->status = cpu_to_le16(0);
1655 memcpy(req->info_element, challenge, 1 + 1 + challenge->len);
1657 /* init. at76_priv tx header */
1658 tx_buffer->wlength = cpu_to_le16(buf_len - AT76_TX_HDRLEN);
1659 at76_dbg(DBG_TX_MGMT, "%s: AuthReq bssid %s alg %d seq_nr %d",
1660 priv->netdev->name, mac2str(mgmt->addr3),
1661 le16_to_cpu(req->algorithm), le16_to_cpu(req->transaction));
1663 at76_dbg(DBG_TX_MGMT, "%s: AuthReq challenge: %s ...",
1664 priv->netdev->name, hex2str(req->info_element, 18));
1666 /* either send immediately (if no data tx is pending
1667 or put it in pending list */
1668 return at76_tx_mgmt(priv, tx_buffer);
1671 static int at76_assoc_req(struct at76_priv *priv, struct bss_info *bss)
1673 struct at76_tx_buffer *tx_buffer;
1674 struct ieee80211_hdr_3addr *mgmt;
1675 struct ieee80211_assoc_request *req;
1676 struct ieee80211_info_element *ie;
1683 tx_buffer = kmalloc(ASSOCREQ_MAX_SIZE + MAX_PADDING_SIZE, GFP_ATOMIC);
1687 req = (struct ieee80211_assoc_request *)tx_buffer->packet;
1688 mgmt = &req->header;
1689 ie = req->info_element;
1691 /* make wireless header */
1692 mgmt->frame_ctl = cpu_to_le16(IEEE80211_FTYPE_MGMT |
1693 IEEE80211_STYPE_ASSOC_REQ);
1695 mgmt->duration_id = cpu_to_le16(0x8000);
1696 memcpy(mgmt->addr1, bss->bssid, ETH_ALEN);
1697 memcpy(mgmt->addr2, priv->netdev->dev_addr, ETH_ALEN);
1698 memcpy(mgmt->addr3, bss->bssid, ETH_ALEN);
1699 mgmt->seq_ctl = cpu_to_le16(0);
1701 /* we must set the Privacy bit in the capabilities to assure an
1702 Agere-based AP with optional WEP transmits encrypted frames
1703 to us. AP only set the Privacy bit in their capabilities
1704 if WEP is mandatory in the BSS! */
1706 if (priv->wep_enabled)
1707 capa |= WLAN_CAPABILITY_PRIVACY;
1708 if (priv->preamble_type != PREAMBLE_TYPE_LONG)
1709 capa |= WLAN_CAPABILITY_SHORT_PREAMBLE;
1710 req->capability = cpu_to_le16(capa);
1712 req->listen_interval = cpu_to_le16(2 * bss->beacon_interval);
1714 /* write TLV data elements */
1716 ie->id = MFIE_TYPE_SSID;
1717 ie->len = bss->ssid_len;
1718 memcpy(ie->data, bss->ssid, bss->ssid_len);
1721 ie->id = MFIE_TYPE_RATES;
1722 ie->len = sizeof(hw_rates);
1723 memcpy(ie->data, hw_rates, sizeof(hw_rates));
1724 next_ie(&ie); /* ie points behind the supp_rates field */
1726 /* init. at76_priv tx header */
1727 tx_buffer->wlength = cpu_to_le16((u8 *)ie - (u8 *)mgmt);
1729 ie = req->info_element;
1731 essid_len = min_t(int, IW_ESSID_MAX_SIZE, ie->len);
1733 next_ie(&ie); /* points to IE of rates now */
1734 at76_dbg(DBG_TX_MGMT,
1735 "%s: AssocReq bssid %s capa 0x%04x ssid %.*s rates %s",
1736 priv->netdev->name, mac2str(mgmt->addr3),
1737 le16_to_cpu(req->capability), essid_len, essid,
1738 hex2str(ie->data, ie->len));
1740 /* either send immediately (if no data tx is pending
1741 or put it in pending list */
1742 return at76_tx_mgmt(priv, tx_buffer);
1745 /* We got to check the bss_list for old entries */
1746 static void at76_bss_list_timeout(unsigned long par)
1748 struct at76_priv *priv = (struct at76_priv *)par;
1749 unsigned long flags;
1750 struct list_head *lptr, *nptr;
1751 struct bss_info *ptr;
1753 spin_lock_irqsave(&priv->bss_list_spinlock, flags);
1755 list_for_each_safe(lptr, nptr, &priv->bss_list) {
1757 ptr = list_entry(lptr, struct bss_info, list);
1759 if (ptr != priv->curr_bss
1760 && time_after(jiffies, ptr->last_rx + BSS_LIST_TIMEOUT)) {
1761 at76_dbg(DBG_BSS_TABLE_RM,
1762 "%s: bss_list: removing old BSS %s ch %d",
1763 priv->netdev->name, mac2str(ptr->bssid),
1765 list_del(&ptr->list);
1769 spin_unlock_irqrestore(&priv->bss_list_spinlock, flags);
1770 /* restart the timer */
1771 mod_timer(&priv->bss_list_timer, jiffies + BSS_LIST_TIMEOUT);
1774 static inline void at76_set_mac_state(struct at76_priv *priv,
1775 enum mac_state mac_state)
1777 at76_dbg(DBG_MAC_STATE, "%s state: %s", priv->netdev->name,
1778 mac_states[mac_state]);
1779 priv->mac_state = mac_state;
1782 static void at76_dump_bss_table(struct at76_priv *priv)
1784 struct bss_info *ptr;
1785 unsigned long flags;
1786 struct list_head *lptr;
1788 spin_lock_irqsave(&priv->bss_list_spinlock, flags);
1790 at76_dbg(DBG_BSS_TABLE, "%s BSS table (curr=%p):", priv->netdev->name,
1793 list_for_each(lptr, &priv->bss_list) {
1794 ptr = list_entry(lptr, struct bss_info, list);
1795 at76_dbg(DBG_BSS_TABLE, "0x%p: bssid %s channel %d ssid %.*s "
1796 "(%s) capa 0x%04x rates %s rssi %d link %d noise %d",
1797 ptr, mac2str(ptr->bssid), ptr->channel, ptr->ssid_len,
1798 ptr->ssid, hex2str(ptr->ssid, ptr->ssid_len),
1799 ptr->capa, hex2str(ptr->rates, ptr->rates_len),
1800 ptr->rssi, ptr->link_qual, ptr->noise_level);
1802 spin_unlock_irqrestore(&priv->bss_list_spinlock, flags);
1805 /* Called upon successful association to mark interface as connected */
1806 static void at76_work_assoc_done(struct work_struct *work)
1808 struct at76_priv *priv = container_of(work, struct at76_priv,
1811 mutex_lock(&priv->mtx);
1813 WARN_ON(priv->mac_state != MAC_ASSOC);
1814 WARN_ON(!priv->curr_bss);
1815 if (priv->mac_state != MAC_ASSOC || !priv->curr_bss)
1818 if (priv->iw_mode == IW_MODE_INFRA) {
1819 if (priv->pm_mode != AT76_PM_OFF) {
1820 /* calculate the listen interval in units of
1821 beacon intervals of the curr_bss */
1822 u32 pm_period_beacon = (priv->pm_period >> 10) /
1823 priv->curr_bss->beacon_interval;
1825 pm_period_beacon = max(pm_period_beacon, 2u);
1826 pm_period_beacon = min(pm_period_beacon, 0xffffu);
1829 "%s: pm_mode %d assoc id 0x%x listen int %d",
1830 priv->netdev->name, priv->pm_mode,
1831 priv->assoc_id, pm_period_beacon);
1833 at76_set_associd(priv, priv->assoc_id);
1834 at76_set_listen_interval(priv, (u16)pm_period_beacon);
1836 schedule_delayed_work(&priv->dwork_beacon, BEACON_TIMEOUT);
1838 at76_set_pm_mode(priv);
1840 netif_carrier_on(priv->netdev);
1841 netif_wake_queue(priv->netdev);
1842 at76_set_mac_state(priv, MAC_CONNECTED);
1843 at76_iwevent_bss_connect(priv->netdev, priv->curr_bss->bssid);
1844 at76_dbg(DBG_PROGRESS, "%s: connected to BSSID %s",
1845 priv->netdev->name, mac2str(priv->curr_bss->bssid));
1848 mutex_unlock(&priv->mtx);
1851 /* We only store the new mac address in netdev struct,
1852 it gets set when the netdev is opened. */
1853 static int at76_set_mac_address(struct net_device *netdev, void *addr)
1855 struct sockaddr *mac = addr;
1856 memcpy(netdev->dev_addr, mac->sa_data, ETH_ALEN);
1860 static struct net_device_stats *at76_get_stats(struct net_device *netdev)
1862 struct at76_priv *priv = netdev_priv(netdev);
1863 return &priv->stats;
1866 static struct iw_statistics *at76_get_wireless_stats(struct net_device *netdev)
1868 struct at76_priv *priv = netdev_priv(netdev);
1870 at76_dbg(DBG_IOCTL, "RETURN qual %d level %d noise %d updated %d",
1871 priv->wstats.qual.qual, priv->wstats.qual.level,
1872 priv->wstats.qual.noise, priv->wstats.qual.updated);
1874 return &priv->wstats;
1877 static void at76_set_multicast(struct net_device *netdev)
1879 struct at76_priv *priv = netdev_priv(netdev);
1882 promisc = ((netdev->flags & IFF_PROMISC) != 0);
1883 if (promisc != priv->promisc) {
1884 /* This gets called in interrupt, must reschedule */
1885 priv->promisc = promisc;
1886 schedule_work(&priv->work_set_promisc);
1890 /* Stop all network activity, flush all pending tasks */
1891 static void at76_quiesce(struct at76_priv *priv)
1893 unsigned long flags;
1895 netif_stop_queue(priv->netdev);
1896 netif_carrier_off(priv->netdev);
1898 at76_set_mac_state(priv, MAC_INIT);
1900 cancel_delayed_work(&priv->dwork_get_scan);
1901 cancel_delayed_work(&priv->dwork_beacon);
1902 cancel_delayed_work(&priv->dwork_auth);
1903 cancel_delayed_work(&priv->dwork_assoc);
1904 cancel_delayed_work(&priv->dwork_restart);
1906 spin_lock_irqsave(&priv->mgmt_spinlock, flags);
1907 kfree(priv->next_mgmt_bulk);
1908 priv->next_mgmt_bulk = NULL;
1909 spin_unlock_irqrestore(&priv->mgmt_spinlock, flags);
1912 /*******************************************************************************
1913 * at76_priv implementations of iw_handler functions:
1915 static int at76_iw_handler_commit(struct net_device *netdev,
1916 struct iw_request_info *info,
1917 void *null, char *extra)
1919 struct at76_priv *priv = netdev_priv(netdev);
1921 at76_dbg(DBG_IOCTL, "%s %s: restarting the device", netdev->name,
1924 if (priv->mac_state != MAC_INIT)
1927 /* Wait half second before the restart to process subsequent
1928 * requests from the same iwconfig in a single restart */
1929 schedule_delayed_work(&priv->dwork_restart, HZ / 2);
1934 static int at76_iw_handler_get_name(struct net_device *netdev,
1935 struct iw_request_info *info,
1936 char *name, char *extra)
1938 strcpy(name, "IEEE 802.11b");
1939 at76_dbg(DBG_IOCTL, "%s: SIOCGIWNAME - name %s", netdev->name, name);
1943 static int at76_iw_handler_set_freq(struct net_device *netdev,
1944 struct iw_request_info *info,
1945 struct iw_freq *freq, char *extra)
1947 struct at76_priv *priv = netdev_priv(netdev);
1949 int ret = -EIWCOMMIT;
1950 at76_dbg(DBG_IOCTL, "%s: SIOCSIWFREQ - freq.m %d freq.e %d",
1951 netdev->name, freq->m, freq->e);
1953 if ((freq->e == 0) && (freq->m <= 1000))
1954 /* Setting by channel number */
1957 /* Setting by frequency - search the table */
1961 for (i = 0; i < (6 - freq->e); i++)
1964 for (i = 0; i < NUM_CHANNELS; i++) {
1965 if (freq->m == (channel_frequency[i] * mult))
1970 if (chan < 1 || !priv->domain)
1971 /* non-positive channels are invalid
1972 * we need a domain info to set the channel
1973 * either that or an invalid frequency was
1974 * provided by the user */
1976 else if (!(priv->domain->channel_map & (1 << (chan - 1)))) {
1977 printk(KERN_INFO "%s: channel %d not allowed for domain %s\n",
1978 priv->netdev->name, chan, priv->domain->name);
1982 if (ret == -EIWCOMMIT) {
1983 priv->channel = chan;
1984 at76_dbg(DBG_IOCTL, "%s: SIOCSIWFREQ - ch %d", netdev->name,
1991 static int at76_iw_handler_get_freq(struct net_device *netdev,
1992 struct iw_request_info *info,
1993 struct iw_freq *freq, char *extra)
1995 struct at76_priv *priv = netdev_priv(netdev);
1997 freq->m = priv->channel;
2001 at76_dbg(DBG_IOCTL, "%s: SIOCGIWFREQ - freq %ld x 10e%d",
2002 netdev->name, channel_frequency[priv->channel - 1], 6);
2004 at76_dbg(DBG_IOCTL, "%s: SIOCGIWFREQ - ch %d", netdev->name,
2010 static int at76_iw_handler_set_mode(struct net_device *netdev,
2011 struct iw_request_info *info,
2012 __u32 *mode, char *extra)
2014 struct at76_priv *priv = netdev_priv(netdev);
2016 at76_dbg(DBG_IOCTL, "%s: SIOCSIWMODE - %d", netdev->name, *mode);
2018 if ((*mode != IW_MODE_ADHOC) && (*mode != IW_MODE_INFRA) &&
2019 (*mode != IW_MODE_MONITOR))
2022 priv->iw_mode = *mode;
2023 if (priv->iw_mode != IW_MODE_INFRA)
2024 priv->pm_mode = AT76_PM_OFF;
2029 static int at76_iw_handler_get_mode(struct net_device *netdev,
2030 struct iw_request_info *info,
2031 __u32 *mode, char *extra)
2033 struct at76_priv *priv = netdev_priv(netdev);
2035 *mode = priv->iw_mode;
2037 at76_dbg(DBG_IOCTL, "%s: SIOCGIWMODE - %d", netdev->name, *mode);
2042 static int at76_iw_handler_get_range(struct net_device *netdev,
2043 struct iw_request_info *info,
2044 struct iw_point *data, char *extra)
2046 /* inspired by atmel.c */
2047 struct at76_priv *priv = netdev_priv(netdev);
2048 struct iw_range *range = (struct iw_range *)extra;
2051 data->length = sizeof(struct iw_range);
2052 memset(range, 0, sizeof(struct iw_range));
2054 /* TODO: range->throughput = xxxxxx; */
2056 range->min_nwid = 0x0000;
2057 range->max_nwid = 0x0000;
2059 /* this driver doesn't maintain sensitivity information */
2060 range->sensitivity = 0;
2062 range->max_qual.qual = 100;
2063 range->max_qual.level = 100;
2064 range->max_qual.noise = 0;
2065 range->max_qual.updated = IW_QUAL_NOISE_INVALID;
2067 range->avg_qual.qual = 50;
2068 range->avg_qual.level = 50;
2069 range->avg_qual.noise = 0;
2070 range->avg_qual.updated = IW_QUAL_NOISE_INVALID;
2072 range->bitrate[0] = 1000000;
2073 range->bitrate[1] = 2000000;
2074 range->bitrate[2] = 5500000;
2075 range->bitrate[3] = 11000000;
2076 range->num_bitrates = 4;
2079 range->max_rts = MAX_RTS_THRESHOLD;
2081 range->min_frag = MIN_FRAG_THRESHOLD;
2082 range->max_frag = MAX_FRAG_THRESHOLD;
2084 range->pmp_flags = IW_POWER_PERIOD;
2085 range->pmt_flags = IW_POWER_ON;
2086 range->pm_capa = IW_POWER_PERIOD | IW_POWER_ALL_R;
2088 range->encoding_size[0] = WEP_SMALL_KEY_LEN;
2089 range->encoding_size[1] = WEP_LARGE_KEY_LEN;
2090 range->num_encoding_sizes = 2;
2091 range->max_encoding_tokens = WEP_KEYS;
2093 /* both WL-240U and Linksys WUSB11 v2.6 specify 15 dBm as output power
2094 - take this for all (ignore antenna gains) */
2095 range->txpower[0] = 15;
2096 range->num_txpower = 1;
2097 range->txpower_capa = IW_TXPOW_DBM;
2099 range->we_version_source = WIRELESS_EXT;
2100 range->we_version_compiled = WIRELESS_EXT;
2102 /* same as the values used in atmel.c */
2103 range->retry_capa = IW_RETRY_LIMIT;
2104 range->retry_flags = IW_RETRY_LIMIT;
2105 range->r_time_flags = 0;
2106 range->min_retry = 1;
2107 range->max_retry = 255;
2109 range->num_channels = NUM_CHANNELS;
2110 range->num_frequency = 0;
2112 for (i = 0; i < NUM_CHANNELS; i++) {
2113 /* test if channel map bit is raised */
2114 if (priv->domain->channel_map & (0x1 << i)) {
2115 range->num_frequency += 1;
2117 range->freq[i].i = i + 1;
2118 range->freq[i].m = channel_frequency[i] * 100000;
2119 range->freq[i].e = 1; /* freq * 10^1 */
2123 at76_dbg(DBG_IOCTL, "%s: SIOCGIWRANGE", netdev->name);
2128 static int at76_iw_handler_set_spy(struct net_device *netdev,
2129 struct iw_request_info *info,
2130 struct iw_point *data, char *extra)
2132 struct at76_priv *priv = netdev_priv(netdev);
2135 at76_dbg(DBG_IOCTL, "%s: SIOCSIWSPY - number of addresses %d",
2136 netdev->name, data->length);
2138 spin_lock_bh(&priv->spy_spinlock);
2139 ret = iw_handler_set_spy(priv->netdev, info, (union iwreq_data *)data,
2141 spin_unlock_bh(&priv->spy_spinlock);
2146 static int at76_iw_handler_get_spy(struct net_device *netdev,
2147 struct iw_request_info *info,
2148 struct iw_point *data, char *extra)
2151 struct at76_priv *priv = netdev_priv(netdev);
2154 spin_lock_bh(&priv->spy_spinlock);
2155 ret = iw_handler_get_spy(priv->netdev, info,
2156 (union iwreq_data *)data, extra);
2157 spin_unlock_bh(&priv->spy_spinlock);
2159 at76_dbg(DBG_IOCTL, "%s: SIOCGIWSPY - number of addresses %d",
2160 netdev->name, data->length);
2165 static int at76_iw_handler_set_thrspy(struct net_device *netdev,
2166 struct iw_request_info *info,
2167 struct iw_point *data, char *extra)
2169 struct at76_priv *priv = netdev_priv(netdev);
2172 at76_dbg(DBG_IOCTL, "%s: SIOCSIWTHRSPY - number of addresses %d)",
2173 netdev->name, data->length);
2175 spin_lock_bh(&priv->spy_spinlock);
2176 ret = iw_handler_set_thrspy(netdev, info, (union iwreq_data *)data,
2178 spin_unlock_bh(&priv->spy_spinlock);
2183 static int at76_iw_handler_get_thrspy(struct net_device *netdev,
2184 struct iw_request_info *info,
2185 struct iw_point *data, char *extra)
2187 struct at76_priv *priv = netdev_priv(netdev);
2190 spin_lock_bh(&priv->spy_spinlock);
2191 ret = iw_handler_get_thrspy(netdev, info, (union iwreq_data *)data,
2193 spin_unlock_bh(&priv->spy_spinlock);
2195 at76_dbg(DBG_IOCTL, "%s: SIOCGIWTHRSPY - number of addresses %d)",
2196 netdev->name, data->length);
2201 static int at76_iw_handler_set_wap(struct net_device *netdev,
2202 struct iw_request_info *info,
2203 struct sockaddr *ap_addr, char *extra)
2205 struct at76_priv *priv = netdev_priv(netdev);
2207 at76_dbg(DBG_IOCTL, "%s: SIOCSIWAP - wap/bssid %s", netdev->name,
2208 mac2str(ap_addr->sa_data));
2210 /* if the incoming address == ff:ff:ff:ff:ff:ff, the user has
2211 chosen any or auto AP preference */
2212 if (is_broadcast_ether_addr(ap_addr->sa_data)
2213 || is_zero_ether_addr(ap_addr->sa_data))
2214 priv->wanted_bssid_valid = 0;
2216 /* user wants to set a preferred AP address */
2217 priv->wanted_bssid_valid = 1;
2218 memcpy(priv->wanted_bssid, ap_addr->sa_data, ETH_ALEN);
2224 static int at76_iw_handler_get_wap(struct net_device *netdev,
2225 struct iw_request_info *info,
2226 struct sockaddr *ap_addr, char *extra)
2228 struct at76_priv *priv = netdev_priv(netdev);
2230 ap_addr->sa_family = ARPHRD_ETHER;
2231 memcpy(ap_addr->sa_data, priv->bssid, ETH_ALEN);
2233 at76_dbg(DBG_IOCTL, "%s: SIOCGIWAP - wap/bssid %s", netdev->name,
2234 mac2str(ap_addr->sa_data));
2239 static int at76_iw_handler_set_scan(struct net_device *netdev,
2240 struct iw_request_info *info,
2241 union iwreq_data *wrqu, char *extra)
2243 struct at76_priv *priv = netdev_priv(netdev);
2246 at76_dbg(DBG_IOCTL, "%s: SIOCSIWSCAN", netdev->name);
2248 if (mutex_lock_interruptible(&priv->mtx))
2251 if (!netif_running(netdev)) {
2256 /* jal: we don't allow "iwlist ethX scan" while we are
2258 if (priv->iw_mode == IW_MODE_MONITOR) {
2263 /* Discard old scan results */
2264 if ((jiffies - priv->last_scan) > (20 * HZ))
2265 priv->scan_state = SCAN_IDLE;
2266 priv->last_scan = jiffies;
2268 /* Initiate a scan command */
2269 if (priv->scan_state == SCAN_IN_PROGRESS) {
2274 priv->scan_state = SCAN_IN_PROGRESS;
2278 /* Try to do passive or active scan if WE asks as. */
2279 if (wrqu->data.length
2280 && wrqu->data.length == sizeof(struct iw_scan_req)) {
2281 struct iw_scan_req *req = (struct iw_scan_req *)extra;
2283 if (req->scan_type == IW_SCAN_TYPE_PASSIVE)
2284 priv->scan_mode = SCAN_TYPE_PASSIVE;
2285 else if (req->scan_type == IW_SCAN_TYPE_ACTIVE)
2286 priv->scan_mode = SCAN_TYPE_ACTIVE;
2288 /* Sanity check values? */
2289 if (req->min_channel_time > 0)
2290 priv->scan_min_time = req->min_channel_time;
2292 if (req->max_channel_time > 0)
2293 priv->scan_max_time = req->max_channel_time;
2296 /* change to scanning state */
2297 at76_set_mac_state(priv, MAC_SCANNING);
2298 schedule_work(&priv->work_start_scan);
2301 mutex_unlock(&priv->mtx);
2305 static int at76_iw_handler_get_scan(struct net_device *netdev,
2306 struct iw_request_info *info,
2307 struct iw_point *data, char *extra)
2309 struct at76_priv *priv = netdev_priv(netdev);
2310 unsigned long flags;
2311 struct list_head *lptr, *nptr;
2312 struct bss_info *curr_bss;
2313 struct iw_event *iwe = kmalloc(sizeof(struct iw_event), GFP_KERNEL);
2314 char *curr_val, *curr_pos = extra;
2317 at76_dbg(DBG_IOCTL, "%s: SIOCGIWSCAN", netdev->name);
2322 if (priv->scan_state != SCAN_COMPLETED) {
2323 /* scan not yet finished */
2328 spin_lock_irqsave(&priv->bss_list_spinlock, flags);
2330 list_for_each_safe(lptr, nptr, &priv->bss_list) {
2331 curr_bss = list_entry(lptr, struct bss_info, list);
2333 iwe->cmd = SIOCGIWAP;
2334 iwe->u.ap_addr.sa_family = ARPHRD_ETHER;
2335 memcpy(iwe->u.ap_addr.sa_data, curr_bss->bssid, 6);
2336 curr_pos = iwe_stream_add_event(info, curr_pos,
2337 extra + IW_SCAN_MAX_DATA, iwe,
2340 iwe->u.data.length = curr_bss->ssid_len;
2341 iwe->cmd = SIOCGIWESSID;
2342 iwe->u.data.flags = 1;
2344 curr_pos = iwe_stream_add_point(info, curr_pos,
2345 extra + IW_SCAN_MAX_DATA, iwe,
2348 iwe->cmd = SIOCGIWMODE;
2349 iwe->u.mode = (curr_bss->capa & WLAN_CAPABILITY_IBSS) ?
2351 (curr_bss->capa & WLAN_CAPABILITY_ESS) ?
2352 IW_MODE_MASTER : IW_MODE_AUTO;
2353 /* IW_MODE_AUTO = 0 which I thought is
2354 * the most logical value to return in this case */
2355 curr_pos = iwe_stream_add_event(info, curr_pos,
2356 extra + IW_SCAN_MAX_DATA, iwe,
2359 iwe->cmd = SIOCGIWFREQ;
2360 iwe->u.freq.m = curr_bss->channel;
2362 curr_pos = iwe_stream_add_event(info, curr_pos,
2363 extra + IW_SCAN_MAX_DATA, iwe,
2366 iwe->cmd = SIOCGIWENCODE;
2367 if (curr_bss->capa & WLAN_CAPABILITY_PRIVACY)
2368 iwe->u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
2370 iwe->u.data.flags = IW_ENCODE_DISABLED;
2372 iwe->u.data.length = 0;
2373 curr_pos = iwe_stream_add_point(info, curr_pos,
2374 extra + IW_SCAN_MAX_DATA, iwe,
2377 /* Add quality statistics */
2378 iwe->cmd = IWEVQUAL;
2379 iwe->u.qual.noise = 0;
2380 iwe->u.qual.updated =
2381 IW_QUAL_NOISE_INVALID | IW_QUAL_LEVEL_UPDATED;
2382 iwe->u.qual.level = (curr_bss->rssi * 100 / 42);
2383 if (iwe->u.qual.level > 100)
2384 iwe->u.qual.level = 100;
2385 if (at76_is_intersil(priv->board_type))
2386 iwe->u.qual.qual = curr_bss->link_qual;
2388 iwe->u.qual.qual = 0;
2389 iwe->u.qual.updated |= IW_QUAL_QUAL_INVALID;
2391 /* Add new value to event */
2392 curr_pos = iwe_stream_add_event(info, curr_pos,
2393 extra + IW_SCAN_MAX_DATA, iwe,
2396 /* Rate: stuffing multiple values in a single event requires
2397 * a bit more of magic - Jean II */
2398 curr_val = curr_pos + IW_EV_LCP_LEN;
2400 iwe->cmd = SIOCGIWRATE;
2401 /* Those two flags are ignored... */
2402 iwe->u.bitrate.fixed = 0;
2403 iwe->u.bitrate.disabled = 0;
2405 for (i = 0; i < curr_bss->rates_len; i++) {
2406 /* Bit rate given in 500 kb/s units (+ 0x80) */
2407 iwe->u.bitrate.value =
2408 ((curr_bss->rates[i] & 0x7f) * 500000);
2409 /* Add new value to event */
2410 curr_val = iwe_stream_add_value(info, curr_pos,
2413 IW_SCAN_MAX_DATA, iwe,
2417 /* Check if we added any event */
2418 if ((curr_val - curr_pos) > IW_EV_LCP_LEN)
2419 curr_pos = curr_val;
2421 /* more information may be sent back using IWECUSTOM */
2425 spin_unlock_irqrestore(&priv->bss_list_spinlock, flags);
2427 data->length = (curr_pos - extra);
2434 static int at76_iw_handler_set_essid(struct net_device *netdev,
2435 struct iw_request_info *info,
2436 struct iw_point *data, char *extra)
2438 struct at76_priv *priv = netdev_priv(netdev);
2440 at76_dbg(DBG_IOCTL, "%s: SIOCSIWESSID - %s", netdev->name, extra);
2443 memcpy(priv->essid, extra, data->length);
2444 priv->essid_size = data->length;
2446 priv->essid_size = 0; /* Use any SSID */
2451 static int at76_iw_handler_get_essid(struct net_device *netdev,
2452 struct iw_request_info *info,
2453 struct iw_point *data, char *extra)
2455 struct at76_priv *priv = netdev_priv(netdev);
2457 if (priv->essid_size) {
2458 /* not the ANY ssid in priv->essid */
2460 data->length = priv->essid_size;
2461 memcpy(extra, priv->essid, data->length);
2463 /* the ANY ssid was specified */
2464 if (priv->mac_state == MAC_CONNECTED && priv->curr_bss) {
2465 /* report the SSID we have found */
2467 data->length = priv->curr_bss->ssid_len;
2468 memcpy(extra, priv->curr_bss->ssid, data->length);
2470 /* report ANY back */
2476 at76_dbg(DBG_IOCTL, "%s: SIOCGIWESSID - %.*s", netdev->name,
2477 data->length, extra);
2482 static int at76_iw_handler_set_rate(struct net_device *netdev,
2483 struct iw_request_info *info,
2484 struct iw_param *bitrate, char *extra)
2486 struct at76_priv *priv = netdev_priv(netdev);
2487 int ret = -EIWCOMMIT;
2489 at76_dbg(DBG_IOCTL, "%s: SIOCSIWRATE - %d", netdev->name,
2492 switch (bitrate->value) {
2494 priv->txrate = TX_RATE_AUTO;
2495 break; /* auto rate */
2497 priv->txrate = TX_RATE_1MBIT;
2500 priv->txrate = TX_RATE_2MBIT;
2503 priv->txrate = TX_RATE_5_5MBIT;
2506 priv->txrate = TX_RATE_11MBIT;
2515 static int at76_iw_handler_get_rate(struct net_device *netdev,
2516 struct iw_request_info *info,
2517 struct iw_param *bitrate, char *extra)
2519 struct at76_priv *priv = netdev_priv(netdev);
2522 switch (priv->txrate) {
2523 /* return max rate if RATE_AUTO */
2525 bitrate->value = 11000000;
2528 bitrate->value = 1000000;
2531 bitrate->value = 2000000;
2533 case TX_RATE_5_5MBIT:
2534 bitrate->value = 5500000;
2536 case TX_RATE_11MBIT:
2537 bitrate->value = 11000000;
2543 bitrate->fixed = (priv->txrate != TX_RATE_AUTO);
2544 bitrate->disabled = 0;
2546 at76_dbg(DBG_IOCTL, "%s: SIOCGIWRATE - %d", netdev->name,
2552 static int at76_iw_handler_set_rts(struct net_device *netdev,
2553 struct iw_request_info *info,
2554 struct iw_param *rts, char *extra)
2556 struct at76_priv *priv = netdev_priv(netdev);
2557 int ret = -EIWCOMMIT;
2558 int rthr = rts->value;
2560 at76_dbg(DBG_IOCTL, "%s: SIOCSIWRTS - value %d disabled %s",
2561 netdev->name, rts->value, (rts->disabled) ? "true" : "false");
2564 rthr = MAX_RTS_THRESHOLD;
2566 if ((rthr < 0) || (rthr > MAX_RTS_THRESHOLD))
2569 priv->rts_threshold = rthr;
2574 static int at76_iw_handler_get_rts(struct net_device *netdev,
2575 struct iw_request_info *info,
2576 struct iw_param *rts, char *extra)
2578 struct at76_priv *priv = netdev_priv(netdev);
2580 rts->value = priv->rts_threshold;
2581 rts->disabled = (rts->value >= MAX_RTS_THRESHOLD);
2584 at76_dbg(DBG_IOCTL, "%s: SIOCGIWRTS - value %d disabled %s",
2585 netdev->name, rts->value, (rts->disabled) ? "true" : "false");
2590 static int at76_iw_handler_set_frag(struct net_device *netdev,
2591 struct iw_request_info *info,
2592 struct iw_param *frag, char *extra)
2594 struct at76_priv *priv = netdev_priv(netdev);
2595 int ret = -EIWCOMMIT;
2596 int fthr = frag->value;
2598 at76_dbg(DBG_IOCTL, "%s: SIOCSIWFRAG - value %d, disabled %s",
2599 netdev->name, frag->value,
2600 (frag->disabled) ? "true" : "false");
2603 fthr = MAX_FRAG_THRESHOLD;
2605 if ((fthr < MIN_FRAG_THRESHOLD) || (fthr > MAX_FRAG_THRESHOLD))
2608 priv->frag_threshold = fthr & ~0x1; /* get an even value */
2613 static int at76_iw_handler_get_frag(struct net_device *netdev,
2614 struct iw_request_info *info,
2615 struct iw_param *frag, char *extra)
2617 struct at76_priv *priv = netdev_priv(netdev);
2619 frag->value = priv->frag_threshold;
2620 frag->disabled = (frag->value >= MAX_FRAG_THRESHOLD);
2623 at76_dbg(DBG_IOCTL, "%s: SIOCGIWFRAG - value %d, disabled %s",
2624 netdev->name, frag->value,
2625 (frag->disabled) ? "true" : "false");
2630 static int at76_iw_handler_get_txpow(struct net_device *netdev,
2631 struct iw_request_info *info,
2632 struct iw_param *power, char *extra)
2635 power->fixed = 1; /* No power control */
2636 power->disabled = 0;
2637 power->flags = IW_TXPOW_DBM;
2639 at76_dbg(DBG_IOCTL, "%s: SIOCGIWTXPOW - txpow %d dBm", netdev->name,
2645 /* jal: short retry is handled by the firmware (at least 0.90.x),
2646 while long retry is not (?) */
2647 static int at76_iw_handler_set_retry(struct net_device *netdev,
2648 struct iw_request_info *info,
2649 struct iw_param *retry, char *extra)
2651 struct at76_priv *priv = netdev_priv(netdev);
2652 int ret = -EIWCOMMIT;
2654 at76_dbg(DBG_IOCTL, "%s: SIOCSIWRETRY disabled %d flags 0x%x val %d",
2655 netdev->name, retry->disabled, retry->flags, retry->value);
2657 if (!retry->disabled && (retry->flags & IW_RETRY_LIMIT)) {
2658 if ((retry->flags & IW_RETRY_MIN) ||
2659 !(retry->flags & IW_RETRY_MAX))
2660 priv->short_retry_limit = retry->value;
2669 /* Adapted (ripped) from atmel.c */
2670 static int at76_iw_handler_get_retry(struct net_device *netdev,
2671 struct iw_request_info *info,
2672 struct iw_param *retry, char *extra)
2674 struct at76_priv *priv = netdev_priv(netdev);
2676 at76_dbg(DBG_IOCTL, "%s: SIOCGIWRETRY", netdev->name);
2678 retry->disabled = 0; /* Can't be disabled */
2679 retry->flags = IW_RETRY_LIMIT;
2680 retry->value = priv->short_retry_limit;
2685 static int at76_iw_handler_set_encode(struct net_device *netdev,
2686 struct iw_request_info *info,
2687 struct iw_point *encoding, char *extra)
2689 struct at76_priv *priv = netdev_priv(netdev);
2690 int index = (encoding->flags & IW_ENCODE_INDEX) - 1;
2691 int len = encoding->length;
2693 at76_dbg(DBG_IOCTL, "%s: SIOCSIWENCODE - enc.flags %08x "
2694 "pointer %p len %d", netdev->name, encoding->flags,
2695 encoding->pointer, encoding->length);
2697 "%s: SIOCSIWENCODE - old wepstate: enabled %s key_id %d "
2698 "auth_mode %s", netdev->name,
2699 (priv->wep_enabled) ? "true" : "false", priv->wep_key_id,
2701 WLAN_AUTH_SHARED_KEY) ? "restricted" : "open");
2703 /* take the old default key if index is invalid */
2704 if ((index < 0) || (index >= WEP_KEYS))
2705 index = priv->wep_key_id;
2708 if (len > WEP_LARGE_KEY_LEN)
2709 len = WEP_LARGE_KEY_LEN;
2711 memset(priv->wep_keys[index], 0, WEP_KEY_LEN);
2712 memcpy(priv->wep_keys[index], extra, len);
2713 priv->wep_keys_len[index] = (len <= WEP_SMALL_KEY_LEN) ?
2714 WEP_SMALL_KEY_LEN : WEP_LARGE_KEY_LEN;
2715 priv->wep_enabled = 1;
2718 priv->wep_key_id = index;
2719 priv->wep_enabled = ((encoding->flags & IW_ENCODE_DISABLED) == 0);
2721 if (encoding->flags & IW_ENCODE_RESTRICTED)
2722 priv->auth_mode = WLAN_AUTH_SHARED_KEY;
2723 if (encoding->flags & IW_ENCODE_OPEN)
2724 priv->auth_mode = WLAN_AUTH_OPEN;
2727 "%s: SIOCSIWENCODE - new wepstate: enabled %s key_id %d "
2728 "key_len %d auth_mode %s", netdev->name,
2729 (priv->wep_enabled) ? "true" : "false", priv->wep_key_id + 1,
2730 priv->wep_keys_len[priv->wep_key_id],
2732 WLAN_AUTH_SHARED_KEY) ? "restricted" : "open");
2737 static int at76_iw_handler_get_encode(struct net_device *netdev,
2738 struct iw_request_info *info,
2739 struct iw_point *encoding, char *extra)
2741 struct at76_priv *priv = netdev_priv(netdev);
2742 int index = (encoding->flags & IW_ENCODE_INDEX) - 1;
2744 if ((index < 0) || (index >= WEP_KEYS))
2745 index = priv->wep_key_id;
2748 (priv->auth_mode == WLAN_AUTH_SHARED_KEY) ?
2749 IW_ENCODE_RESTRICTED : IW_ENCODE_OPEN;
2751 if (!priv->wep_enabled)
2752 encoding->flags |= IW_ENCODE_DISABLED;
2754 if (encoding->pointer) {
2755 encoding->length = priv->wep_keys_len[index];
2757 memcpy(extra, priv->wep_keys[index], priv->wep_keys_len[index]);
2759 encoding->flags |= (index + 1);
2762 at76_dbg(DBG_IOCTL, "%s: SIOCGIWENCODE - enc.flags %08x "
2763 "pointer %p len %d", netdev->name, encoding->flags,
2764 encoding->pointer, encoding->length);
2766 "%s: SIOCGIWENCODE - wepstate: enabled %s key_id %d "
2767 "key_len %d auth_mode %s", netdev->name,
2768 (priv->wep_enabled) ? "true" : "false", priv->wep_key_id + 1,
2769 priv->wep_keys_len[priv->wep_key_id],
2771 WLAN_AUTH_SHARED_KEY) ? "restricted" : "open");
2776 static int at76_iw_handler_set_power(struct net_device *netdev,
2777 struct iw_request_info *info,
2778 struct iw_param *prq, char *extra)
2780 int err = -EIWCOMMIT;
2781 struct at76_priv *priv = netdev_priv(netdev);
2784 "%s: SIOCSIWPOWER - disabled %s flags 0x%x value 0x%x",
2785 netdev->name, (prq->disabled) ? "true" : "false", prq->flags,
2789 priv->pm_mode = AT76_PM_OFF;
2791 switch (prq->flags & IW_POWER_MODE) {
2792 case IW_POWER_ALL_R:
2799 if (prq->flags & IW_POWER_PERIOD)
2800 priv->pm_period = prq->value;
2802 if (prq->flags & IW_POWER_TIMEOUT) {
2806 priv->pm_mode = AT76_PM_ON;
2812 static int at76_iw_handler_get_power(struct net_device *netdev,
2813 struct iw_request_info *info,
2814 struct iw_param *power, char *extra)
2816 struct at76_priv *priv = netdev_priv(netdev);
2818 power->disabled = (priv->pm_mode == AT76_PM_OFF);
2819 if (!power->disabled) {
2820 power->flags = IW_POWER_PERIOD | IW_POWER_ALL_R;
2821 power->value = priv->pm_period;
2824 at76_dbg(DBG_IOCTL, "%s: SIOCGIWPOWER - %s flags 0x%x value 0x%x",
2825 netdev->name, power->disabled ? "disabled" : "enabled",
2826 power->flags, power->value);
2831 /*******************************************************************************
2834 static int at76_iw_set_short_preamble(struct net_device *netdev,
2835 struct iw_request_info *info, char *name,
2838 struct at76_priv *priv = netdev_priv(netdev);
2839 int val = *((int *)name);
2840 int ret = -EIWCOMMIT;
2842 at76_dbg(DBG_IOCTL, "%s: AT76_SET_SHORT_PREAMBLE, %d",
2845 if (val < PREAMBLE_TYPE_LONG || val > PREAMBLE_TYPE_AUTO)
2848 priv->preamble_type = val;
2853 static int at76_iw_get_short_preamble(struct net_device *netdev,
2854 struct iw_request_info *info,
2855 union iwreq_data *wrqu, char *extra)
2857 struct at76_priv *priv = netdev_priv(netdev);
2859 snprintf(wrqu->name, sizeof(wrqu->name), "%s (%d)",
2860 preambles[priv->preamble_type], priv->preamble_type);
2864 static int at76_iw_set_debug(struct net_device *netdev,
2865 struct iw_request_info *info,
2866 struct iw_point *data, char *extra)
2871 if (data->length > 0) {
2872 val = simple_strtol(extra, &ptr, 0);
2877 at76_dbg(DBG_IOCTL, "%s: AT76_SET_DEBUG input %d: %s -> 0x%x",
2878 netdev->name, data->length, extra, val);
2882 at76_dbg(DBG_IOCTL, "%s: AT76_SET_DEBUG, old 0x%x, new 0x%x",
2883 netdev->name, at76_debug, val);
2885 /* jal: some more output to pin down lockups */
2886 at76_dbg(DBG_IOCTL, "%s: netif running %d queue_stopped %d "
2887 "carrier_ok %d", netdev->name, netif_running(netdev),
2888 netif_queue_stopped(netdev), netif_carrier_ok(netdev));
2895 static int at76_iw_get_debug(struct net_device *netdev,
2896 struct iw_request_info *info,
2897 union iwreq_data *wrqu, char *extra)
2899 snprintf(wrqu->name, sizeof(wrqu->name), "0x%08x", at76_debug);
2903 static int at76_iw_set_powersave_mode(struct net_device *netdev,
2904 struct iw_request_info *info, char *name,
2907 struct at76_priv *priv = netdev_priv(netdev);
2908 int val = *((int *)name);
2909 int ret = -EIWCOMMIT;
2911 at76_dbg(DBG_IOCTL, "%s: AT76_SET_POWERSAVE_MODE, %d (%s)",
2913 val == AT76_PM_OFF ? "active" : val == AT76_PM_ON ? "save" :
2914 val == AT76_PM_SMART ? "smart save" : "<invalid>");
2915 if (val < AT76_PM_OFF || val > AT76_PM_SMART)
2918 priv->pm_mode = val;
2923 static int at76_iw_get_powersave_mode(struct net_device *netdev,
2924 struct iw_request_info *info,
2925 union iwreq_data *wrqu, char *extra)
2927 struct at76_priv *priv = netdev_priv(netdev);
2928 int *param = (int *)extra;
2930 param[0] = priv->pm_mode;
2934 static int at76_iw_set_scan_times(struct net_device *netdev,
2935 struct iw_request_info *info, char *name,
2938 struct at76_priv *priv = netdev_priv(netdev);
2939 int mint = *((int *)name);
2940 int maxt = *((int *)name + 1);
2941 int ret = -EIWCOMMIT;
2943 at76_dbg(DBG_IOCTL, "%s: AT76_SET_SCAN_TIMES - min %d max %d",
2944 netdev->name, mint, maxt);
2945 if (mint <= 0 || maxt <= 0 || mint > maxt)
2948 priv->scan_min_time = mint;
2949 priv->scan_max_time = maxt;
2955 static int at76_iw_get_scan_times(struct net_device *netdev,
2956 struct iw_request_info *info,
2957 union iwreq_data *wrqu, char *extra)
2959 struct at76_priv *priv = netdev_priv(netdev);
2960 int *param = (int *)extra;
2962 param[0] = priv->scan_min_time;
2963 param[1] = priv->scan_max_time;
2967 static int at76_iw_set_scan_mode(struct net_device *netdev,
2968 struct iw_request_info *info, char *name,
2971 struct at76_priv *priv = netdev_priv(netdev);
2972 int val = *((int *)name);
2973 int ret = -EIWCOMMIT;
2975 at76_dbg(DBG_IOCTL, "%s: AT76_SET_SCAN_MODE - mode %s",
2976 netdev->name, (val = SCAN_TYPE_ACTIVE) ? "active" :
2977 (val = SCAN_TYPE_PASSIVE) ? "passive" : "<invalid>");
2979 if (val != SCAN_TYPE_ACTIVE && val != SCAN_TYPE_PASSIVE)
2982 priv->scan_mode = val;
2987 static int at76_iw_get_scan_mode(struct net_device *netdev,
2988 struct iw_request_info *info,
2989 union iwreq_data *wrqu, char *extra)
2991 struct at76_priv *priv = netdev_priv(netdev);
2992 int *param = (int *)extra;
2994 param[0] = priv->scan_mode;
2998 #define AT76_SET_HANDLER(h, f) [h - SIOCIWFIRST] = (iw_handler) f
3000 /* Standard wireless handlers */
3001 static const iw_handler at76_handlers[] = {
3002 AT76_SET_HANDLER(SIOCSIWCOMMIT, at76_iw_handler_commit),
3003 AT76_SET_HANDLER(SIOCGIWNAME, at76_iw_handler_get_name),
3004 AT76_SET_HANDLER(SIOCSIWFREQ, at76_iw_handler_set_freq),
3005 AT76_SET_HANDLER(SIOCGIWFREQ, at76_iw_handler_get_freq),
3006 AT76_SET_HANDLER(SIOCSIWMODE, at76_iw_handler_set_mode),
3007 AT76_SET_HANDLER(SIOCGIWMODE, at76_iw_handler_get_mode),
3008 AT76_SET_HANDLER(SIOCGIWRANGE, at76_iw_handler_get_range),
3009 AT76_SET_HANDLER(SIOCSIWSPY, at76_iw_handler_set_spy),
3010 AT76_SET_HANDLER(SIOCGIWSPY, at76_iw_handler_get_spy),
3011 AT76_SET_HANDLER(SIOCSIWTHRSPY, at76_iw_handler_set_thrspy),
3012 AT76_SET_HANDLER(SIOCGIWTHRSPY, at76_iw_handler_get_thrspy),
3013 AT76_SET_HANDLER(SIOCSIWAP, at76_iw_handler_set_wap),
3014 AT76_SET_HANDLER(SIOCGIWAP, at76_iw_handler_get_wap),
3015 AT76_SET_HANDLER(SIOCSIWSCAN, at76_iw_handler_set_scan),
3016 AT76_SET_HANDLER(SIOCGIWSCAN, at76_iw_handler_get_scan),
3017 AT76_SET_HANDLER(SIOCSIWESSID, at76_iw_handler_set_essid),
3018 AT76_SET_HANDLER(SIOCGIWESSID, at76_iw_handler_get_essid),
3019 AT76_SET_HANDLER(SIOCSIWRATE, at76_iw_handler_set_rate),
3020 AT76_SET_HANDLER(SIOCGIWRATE, at76_iw_handler_get_rate),
3021 AT76_SET_HANDLER(SIOCSIWRTS, at76_iw_handler_set_rts),
3022 AT76_SET_HANDLER(SIOCGIWRTS, at76_iw_handler_get_rts),
3023 AT76_SET_HANDLER(SIOCSIWFRAG, at76_iw_handler_set_frag),
3024 AT76_SET_HANDLER(SIOCGIWFRAG, at76_iw_handler_get_frag),
3025 AT76_SET_HANDLER(SIOCGIWTXPOW, at76_iw_handler_get_txpow),
3026 AT76_SET_HANDLER(SIOCSIWRETRY, at76_iw_handler_set_retry),
3027 AT76_SET_HANDLER(SIOCGIWRETRY, at76_iw_handler_get_retry),
3028 AT76_SET_HANDLER(SIOCSIWENCODE, at76_iw_handler_set_encode),
3029 AT76_SET_HANDLER(SIOCGIWENCODE, at76_iw_handler_get_encode),
3030 AT76_SET_HANDLER(SIOCSIWPOWER, at76_iw_handler_set_power),
3031 AT76_SET_HANDLER(SIOCGIWPOWER, at76_iw_handler_get_power)
3034 #define AT76_SET_PRIV(h, f) [h - SIOCIWFIRSTPRIV] = (iw_handler) f
3036 /* Private wireless handlers */
3037 static const iw_handler at76_priv_handlers[] = {
3038 AT76_SET_PRIV(AT76_SET_SHORT_PREAMBLE, at76_iw_set_short_preamble),
3039 AT76_SET_PRIV(AT76_GET_SHORT_PREAMBLE, at76_iw_get_short_preamble),
3040 AT76_SET_PRIV(AT76_SET_DEBUG, at76_iw_set_debug),
3041 AT76_SET_PRIV(AT76_GET_DEBUG, at76_iw_get_debug),
3042 AT76_SET_PRIV(AT76_SET_POWERSAVE_MODE, at76_iw_set_powersave_mode),
3043 AT76_SET_PRIV(AT76_GET_POWERSAVE_MODE, at76_iw_get_powersave_mode),
3044 AT76_SET_PRIV(AT76_SET_SCAN_TIMES, at76_iw_set_scan_times),
3045 AT76_SET_PRIV(AT76_GET_SCAN_TIMES, at76_iw_get_scan_times),
3046 AT76_SET_PRIV(AT76_SET_SCAN_MODE, at76_iw_set_scan_mode),
3047 AT76_SET_PRIV(AT76_GET_SCAN_MODE, at76_iw_get_scan_mode),
3050 /* Names and arguments of private wireless handlers */
3051 static const struct iw_priv_args at76_priv_args[] = {
3052 /* 0 - long, 1 - short */
3053 {AT76_SET_SHORT_PREAMBLE,
3054 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_preamble"},
3056 {AT76_GET_SHORT_PREAMBLE,
3057 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | 10, "get_preamble"},
3059 /* we must pass the new debug mask as a string, because iwpriv cannot
3060 * parse hex numbers starting with 0x :-( */
3062 IW_PRIV_TYPE_CHAR | 10, 0, "set_debug"},
3065 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | 10, "get_debug"},
3067 /* 1 - active, 2 - power save, 3 - smart power save */
3068 {AT76_SET_POWERSAVE_MODE,
3069 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_powersave"},
3071 {AT76_GET_POWERSAVE_MODE,
3072 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "get_powersave"},
3074 /* min_channel_time, max_channel_time */
3075 {AT76_SET_SCAN_TIMES,
3076 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "set_scan_times"},
3078 {AT76_GET_SCAN_TIMES,
3079 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, "get_scan_times"},
3081 /* 0 - active, 1 - passive scan */
3082 {AT76_SET_SCAN_MODE,
3083 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_scan_mode"},
3085 {AT76_GET_SCAN_MODE,
3086 0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "get_scan_mode"},
3089 static const struct iw_handler_def at76_handler_def = {
3090 .num_standard = ARRAY_SIZE(at76_handlers),
3091 .num_private = ARRAY_SIZE(at76_priv_handlers),
3092 .num_private_args = ARRAY_SIZE(at76_priv_args),
3093 .standard = at76_handlers,
3094 .private = at76_priv_handlers,
3095 .private_args = at76_priv_args,
3096 .get_wireless_stats = at76_get_wireless_stats,
3099 static const u8 snapsig[] = { 0xaa, 0xaa, 0x03 };
3101 /* RFC 1042 encapsulates Ethernet frames in 802.2 SNAP (0xaa, 0xaa, 0x03) with
3102 * a SNAP OID of 0 (0x00, 0x00, 0x00) */
3103 static const u8 rfc1042sig[] = { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
3105 static int at76_tx(struct sk_buff *skb, struct net_device *netdev)
3107 struct at76_priv *priv = netdev_priv(netdev);
3108 struct net_device_stats *stats = &priv->stats;
3112 struct at76_tx_buffer *tx_buffer = priv->bulk_out_buffer;
3113 struct ieee80211_hdr_3addr *i802_11_hdr =
3114 (struct ieee80211_hdr_3addr *)tx_buffer->packet;
3115 u8 *payload = i802_11_hdr->payload;
3116 struct ethhdr *eh = (struct ethhdr *)skb->data;
3118 if (netif_queue_stopped(netdev)) {
3119 printk(KERN_ERR "%s: %s called while netdev is stopped\n",
3120 netdev->name, __func__);
3121 /* skip this packet */
3126 if (priv->tx_urb->status == -EINPROGRESS) {
3127 printk(KERN_ERR "%s: %s called while tx urb is pending\n",
3128 netdev->name, __func__);
3129 /* skip this packet */
3134 if (skb->len < ETH_HLEN) {
3135 printk(KERN_ERR "%s: %s: skb too short (%d)\n",
3136 netdev->name, __func__, skb->len);
3141 at76_ledtrig_tx_activity(); /* tell ledtrigger we send a packet */
3143 /* we can get rid of memcpy if we set netdev->hard_header_len to
3144 reserve enough space, but we would need to keep the skb around */
3146 if (ntohs(eh->h_proto) <= ETH_DATA_LEN) {
3147 /* this is a 802.3 packet */
3148 if (skb->len >= ETH_HLEN + sizeof(rfc1042sig)
3149 && skb->data[ETH_HLEN] == rfc1042sig[0]
3150 && skb->data[ETH_HLEN + 1] == rfc1042sig[1]) {
3151 /* higher layer delivered SNAP header - keep it */
3152 memcpy(payload, skb->data + ETH_HLEN,
3153 skb->len - ETH_HLEN);
3154 wlen = IEEE80211_3ADDR_LEN + skb->len - ETH_HLEN;
3156 printk(KERN_ERR "%s: dropping non-SNAP 802.2 packet "
3157 "(DSAP 0x%02x SSAP 0x%02x cntrl 0x%02x)\n",
3158 priv->netdev->name, skb->data[ETH_HLEN],
3159 skb->data[ETH_HLEN + 1],
3160 skb->data[ETH_HLEN + 2]);
3165 /* add RFC 1042 header in front */
3166 memcpy(payload, rfc1042sig, sizeof(rfc1042sig));
3167 memcpy(payload + sizeof(rfc1042sig), &eh->h_proto,
3168 skb->len - offsetof(struct ethhdr, h_proto));
3169 wlen = IEEE80211_3ADDR_LEN + sizeof(rfc1042sig) + skb->len -
3170 offsetof(struct ethhdr, h_proto);
3173 /* make wireless header */
3174 i802_11_hdr->frame_ctl =
3175 cpu_to_le16(IEEE80211_FTYPE_DATA |
3176 (priv->wep_enabled ? IEEE80211_FCTL_PROTECTED : 0) |
3178 IW_MODE_INFRA ? IEEE80211_FCTL_TODS : 0));
3180 if (priv->iw_mode == IW_MODE_ADHOC) {
3181 memcpy(i802_11_hdr->addr1, eh->h_dest, ETH_ALEN);
3182 memcpy(i802_11_hdr->addr2, eh->h_source, ETH_ALEN);
3183 memcpy(i802_11_hdr->addr3, priv->bssid, ETH_ALEN);
3184 } else if (priv->iw_mode == IW_MODE_INFRA) {
3185 memcpy(i802_11_hdr->addr1, priv->bssid, ETH_ALEN);
3186 memcpy(i802_11_hdr->addr2, eh->h_source, ETH_ALEN);
3187 memcpy(i802_11_hdr->addr3, eh->h_dest, ETH_ALEN);
3190 i802_11_hdr->duration_id = cpu_to_le16(0);
3191 i802_11_hdr->seq_ctl = cpu_to_le16(0);
3193 /* setup 'Atmel' header */
3194 tx_buffer->wlength = cpu_to_le16(wlen);
3195 tx_buffer->tx_rate = priv->txrate;
3196 /* for broadcast destination addresses, the firmware 0.100.x
3197 seems to choose the highest rate set with CMD_STARTUP in
3198 basic_rate_set replacing this value */
3200 memset(tx_buffer->reserved, 0, sizeof(tx_buffer->reserved));
3202 tx_buffer->padding = at76_calc_padding(wlen);
3203 submit_len = wlen + AT76_TX_HDRLEN + tx_buffer->padding;
3205 at76_dbg(DBG_TX_DATA_CONTENT, "%s skb->data %s", priv->netdev->name,
3206 hex2str(skb->data, 32));
3207 at76_dbg(DBG_TX_DATA, "%s tx: wlen 0x%x pad 0x%x rate %d hdr %s",
3209 le16_to_cpu(tx_buffer->wlength),
3210 tx_buffer->padding, tx_buffer->tx_rate,
3211 hex2str(i802_11_hdr, sizeof(*i802_11_hdr)));
3212 at76_dbg(DBG_TX_DATA_CONTENT, "%s payload %s", priv->netdev->name,
3213 hex2str(payload, 48));
3216 netif_stop_queue(netdev);
3217 netdev->trans_start = jiffies;
3219 usb_fill_bulk_urb(priv->tx_urb, priv->udev, priv->tx_pipe, tx_buffer,
3220 submit_len, at76_tx_callback, priv);
3221 ret = usb_submit_urb(priv->tx_urb, GFP_ATOMIC);
3224 printk(KERN_ERR "%s: error in tx submit urb: %d\n",
3228 "%s: -EINVAL: tx urb %p hcpriv %p complete %p\n",
3229 priv->netdev->name, priv->tx_urb,
3230 priv->tx_urb->hcpriv, priv->tx_urb->complete);
3232 stats->tx_bytes += skb->len;
3239 static void at76_tx_timeout(struct net_device *netdev)
3241 struct at76_priv *priv = netdev_priv(netdev);
3245 dev_warn(&netdev->dev, "tx timeout.");
3247 usb_unlink_urb(priv->tx_urb);
3248 priv->stats.tx_errors++;
3251 static int at76_submit_rx_urb(struct at76_priv *priv)
3255 struct sk_buff *skb = priv->rx_skb;
3257 if (!priv->rx_urb) {
3258 printk(KERN_ERR "%s: %s: priv->rx_urb is NULL\n",
3259 priv->netdev->name, __func__);
3264 skb = dev_alloc_skb(sizeof(struct at76_rx_buffer));
3266 printk(KERN_ERR "%s: cannot allocate rx skbuff\n",
3267 priv->netdev->name);
3273 skb_push(skb, skb_headroom(skb));
3277 size = skb_tailroom(skb);
3278 usb_fill_bulk_urb(priv->rx_urb, priv->udev, priv->rx_pipe,
3279 skb_put(skb, size), size, at76_rx_callback, priv);
3280 ret = usb_submit_urb(priv->rx_urb, GFP_ATOMIC);
3283 at76_dbg(DBG_DEVSTART,
3284 "usb_submit_urb returned -ENODEV");
3286 printk(KERN_ERR "%s: rx, usb_submit_urb failed: %d\n",
3287 priv->netdev->name, ret);
3291 if (ret < 0 && ret != -ENODEV)
3292 printk(KERN_ERR "%s: cannot submit rx urb - please unload the "
3293 "driver and/or power cycle the device\n",
3294 priv->netdev->name);
3299 static int at76_open(struct net_device *netdev)
3301 struct at76_priv *priv = netdev_priv(netdev);
3304 at76_dbg(DBG_PROC_ENTRY, "%s(): entry", __func__);
3306 if (mutex_lock_interruptible(&priv->mtx))
3309 /* if netdev->dev_addr != priv->mac_addr we must
3310 set the mac address in the device ! */
3311 if (compare_ether_addr(netdev->dev_addr, priv->mac_addr)) {
3312 if (at76_add_mac_address(priv, netdev->dev_addr) >= 0)
3313 at76_dbg(DBG_PROGRESS, "%s: set new MAC addr %s",
3314 netdev->name, mac2str(netdev->dev_addr));
3317 priv->scan_state = SCAN_IDLE;
3318 priv->last_scan = jiffies;
3320 ret = at76_submit_rx_urb(priv);
3322 printk(KERN_ERR "%s: open: submit_rx_urb failed: %d\n",
3327 schedule_delayed_work(&priv->dwork_restart, 0);
3329 at76_dbg(DBG_PROC_ENTRY, "%s(): end", __func__);
3331 mutex_unlock(&priv->mtx);
3332 return ret < 0 ? ret : 0;
3335 static int at76_stop(struct net_device *netdev)
3337 struct at76_priv *priv = netdev_priv(netdev);
3339 at76_dbg(DBG_DEVSTART, "%s: ENTER", __func__);
3341 if (mutex_lock_interruptible(&priv->mtx))
3346 if (!priv->device_unplugged) {
3347 /* We are called by "ifconfig ethX down", not because the
3348 * device is not available anymore. */
3349 at76_set_radio(priv, 0);
3351 /* We unlink rx_urb because at76_open() re-submits it.
3352 * If unplugged, at76_delete_device() takes care of it. */
3353 usb_kill_urb(priv->rx_urb);
3356 /* free the bss_list */
3357 at76_free_bss_list(priv);
3359 mutex_unlock(&priv->mtx);
3360 at76_dbg(DBG_DEVSTART, "%s: EXIT", __func__);
3365 static void at76_ethtool_get_drvinfo(struct net_device *netdev,
3366 struct ethtool_drvinfo *info)
3368 struct at76_priv *priv = netdev_priv(netdev);
3370 strncpy(info->driver, DRIVER_NAME, sizeof(info->driver));
3371 strncpy(info->version, DRIVER_VERSION, sizeof(info->version));
3373 usb_make_path(priv->udev, info->bus_info, sizeof(info->bus_info));
3375 snprintf(info->fw_version, sizeof(info->fw_version), "%d.%d.%d-%d",
3376 priv->fw_version.major, priv->fw_version.minor,
3377 priv->fw_version.patch, priv->fw_version.build);
3380 static u32 at76_ethtool_get_link(struct net_device *netdev)
3382 struct at76_priv *priv = netdev_priv(netdev);
3383 return priv->mac_state == MAC_CONNECTED;
3386 static struct ethtool_ops at76_ethtool_ops = {
3387 .get_drvinfo = at76_ethtool_get_drvinfo,
3388 .get_link = at76_ethtool_get_link,
3391 /* Download external firmware */
3392 static int at76_load_external_fw(struct usb_device *udev, struct fwentry *fwe)
3399 u8 *buf = fwe->extfw;
3400 int size = fwe->extfw_size;
3405 op_mode = at76_get_op_mode(udev);
3406 at76_dbg(DBG_DEVSTART, "opmode %d", op_mode);
3408 if (op_mode != OPMODE_NORMAL_NIC_WITHOUT_FLASH) {
3409 dev_printk(KERN_ERR, &udev->dev, "unexpected opmode %d\n",
3414 block = kmalloc(FW_BLOCK_SIZE, GFP_KERNEL);
3418 at76_dbg(DBG_DEVSTART, "downloading external firmware");
3420 /* for fw >= 0.100, the device needs an extra empty block */
3422 bsize = min_t(int, size, FW_BLOCK_SIZE);
3423 memcpy(block, buf, bsize);
3424 at76_dbg(DBG_DEVSTART,
3425 "ext fw, size left = %5d, bsize = %4d, blockno = %2d",
3426 size, bsize, blockno);
3427 ret = at76_load_ext_fw_block(udev, blockno, block, bsize);
3429 dev_printk(KERN_ERR, &udev->dev,
3430 "loading %dth firmware block failed: %d\n",
3437 } while (bsize > 0);
3439 if (at76_is_505a(fwe->board_type)) {
3440 at76_dbg(DBG_DEVSTART, "200 ms delay for 505a");
3441 schedule_timeout_interruptible(HZ / 5 + 1);
3447 dev_printk(KERN_ERR, &udev->dev,
3448 "downloading external firmware failed: %d\n", ret);
3452 /* Download internal firmware */
3453 static int at76_load_internal_fw(struct usb_device *udev, struct fwentry *fwe)
3456 int need_remap = !at76_is_505a(fwe->board_type);
3458 ret = at76_usbdfu_download(udev, fwe->intfw, fwe->intfw_size,
3459 need_remap ? 0 : 2 * HZ);
3462 dev_printk(KERN_ERR, &udev->dev,
3463 "downloading internal fw failed with %d\n", ret);
3467 at76_dbg(DBG_DEVSTART, "sending REMAP");
3469 /* no REMAP for 505A (see SF driver) */
3471 ret = at76_remap(udev);
3473 dev_printk(KERN_ERR, &udev->dev,
3474 "sending REMAP failed with %d\n", ret);
3479 at76_dbg(DBG_DEVSTART, "sleeping for 2 seconds");
3480 schedule_timeout_interruptible(2 * HZ + 1);
3481 usb_reset_device(udev);
3487 static int at76_match_essid(struct at76_priv *priv, struct bss_info *ptr)
3489 /* common criteria for both modi */
3491 int ret = (priv->essid_size == 0 /* ANY ssid */ ||
3492 (priv->essid_size == ptr->ssid_len &&
3493 !memcmp(priv->essid, ptr->ssid, ptr->ssid_len)));
3495 at76_dbg(DBG_BSS_MATCH,
3496 "%s bss table entry %p: essid didn't match",
3497 priv->netdev->name, ptr);
3501 static inline int at76_match_mode(struct at76_priv *priv, struct bss_info *ptr)
3505 if (priv->iw_mode == IW_MODE_ADHOC)
3506 ret = ptr->capa & WLAN_CAPABILITY_IBSS;
3508 ret = ptr->capa & WLAN_CAPABILITY_ESS;
3510 at76_dbg(DBG_BSS_MATCH,
3511 "%s bss table entry %p: mode didn't match",
3512 priv->netdev->name, ptr);
3516 static int at76_match_rates(struct at76_priv *priv, struct bss_info *ptr)
3520 for (i = 0; i < ptr->rates_len; i++) {
3521 u8 rate = ptr->rates[i];
3526 /* this is a basic rate we have to support
3527 (see IEEE802.11, ch. 7.3.2.2) */
3528 if (rate != (0x80 | hw_rates[0])
3529 && rate != (0x80 | hw_rates[1])
3530 && rate != (0x80 | hw_rates[2])
3531 && rate != (0x80 | hw_rates[3])) {
3532 at76_dbg(DBG_BSS_MATCH,
3533 "%s: bss table entry %p: basic rate %02x not "
3534 "supported", priv->netdev->name, ptr, rate);
3539 /* if we use short preamble, the bss must support it */
3540 if (priv->preamble_type == PREAMBLE_TYPE_SHORT &&
3541 !(ptr->capa & WLAN_CAPABILITY_SHORT_PREAMBLE)) {
3542 at76_dbg(DBG_BSS_MATCH,
3543 "%s: %p does not support short preamble",
3544 priv->netdev->name, ptr);
3550 static inline int at76_match_wep(struct at76_priv *priv, struct bss_info *ptr)
3552 if (!priv->wep_enabled && ptr->capa & WLAN_CAPABILITY_PRIVACY) {
3553 /* we have disabled WEP, but the BSS signals privacy */
3554 at76_dbg(DBG_BSS_MATCH,
3555 "%s: bss table entry %p: requires encryption",
3556 priv->netdev->name, ptr);
3559 /* otherwise if the BSS does not signal privacy it may well
3560 accept encrypted packets from us ... */
3564 static inline int at76_match_bssid(struct at76_priv *priv, struct bss_info *ptr)
3566 if (!priv->wanted_bssid_valid ||
3567 !compare_ether_addr(ptr->bssid, priv->wanted_bssid))
3570 at76_dbg(DBG_BSS_MATCH,
3571 "%s: requested bssid - %s does not match",
3572 priv->netdev->name, mac2str(priv->wanted_bssid));
3573 at76_dbg(DBG_BSS_MATCH,
3574 " AP bssid - %s of bss table entry %p",
3575 mac2str(ptr->bssid), ptr);
3580 * at76_match_bss - try to find a matching bss in priv->bss
3582 * last - last bss tried
3584 * last == NULL signals a new round starting with priv->bss_list.next
3585 * this function must be called inside an acquired priv->bss_list_spinlock
3586 * otherwise the timeout on bss may remove the newly chosen entry
3588 static struct bss_info *at76_match_bss(struct at76_priv *priv,
3589 struct bss_info *last)
3591 struct bss_info *ptr = NULL;
3592 struct list_head *curr;
3594 curr = last ? last->list.next : priv->bss_list.next;
3595 while (curr != &priv->bss_list) {
3596 ptr = list_entry(curr, struct bss_info, list);
3597 if (at76_match_essid(priv, ptr) && at76_match_mode(priv, ptr)
3598 && at76_match_wep(priv, ptr) && at76_match_rates(priv, ptr)
3599 && at76_match_bssid(priv, ptr))
3604 if (curr == &priv->bss_list)
3606 /* otherwise ptr points to the struct bss_info we have chosen */
3608 at76_dbg(DBG_BSS_TABLE, "%s %s: returned %p", priv->netdev->name,
3613 /* Start joining a matching BSS, or create own IBSS */
3614 static void at76_work_join(struct work_struct *work)
3616 struct at76_priv *priv = container_of(work, struct at76_priv,
3619 unsigned long flags;
3621 mutex_lock(&priv->mtx);
3623 WARN_ON(priv->mac_state != MAC_JOINING);
3624 if (priv->mac_state != MAC_JOINING)
3627 /* secure the access to priv->curr_bss ! */
3628 spin_lock_irqsave(&priv->bss_list_spinlock, flags);
3629 priv->curr_bss = at76_match_bss(priv, priv->curr_bss);
3630 spin_unlock_irqrestore(&priv->bss_list_spinlock, flags);
3632 if (!priv->curr_bss) {
3633 /* here we haven't found a matching (i)bss ... */
3634 if (priv->iw_mode == IW_MODE_ADHOC) {
3635 at76_set_mac_state(priv, MAC_OWN_IBSS);
3636 at76_start_ibss(priv);
3639 /* haven't found a matching BSS in infra mode - try again */
3640 at76_set_mac_state(priv, MAC_SCANNING);
3641 schedule_work(&priv->work_start_scan);
3645 ret = at76_join_bss(priv, priv->curr_bss);
3647 printk(KERN_ERR "%s: join_bss failed with %d\n",
3648 priv->netdev->name, ret);
3652 ret = at76_wait_completion(priv, CMD_JOIN);
3653 if (ret != CMD_STATUS_COMPLETE) {
3654 if (ret != CMD_STATUS_TIME_OUT)
3655 printk(KERN_ERR "%s: join_bss completed with %d\n",
3656 priv->netdev->name, ret);
3658 printk(KERN_INFO "%s: join_bss ssid %s timed out\n",
3660 mac2str(priv->curr_bss->bssid));
3662 /* retry next BSS immediately */
3663 schedule_work(&priv->work_join);
3667 /* here we have joined the (I)BSS */
3668 if (priv->iw_mode == IW_MODE_ADHOC) {
3669 struct bss_info *bptr = priv->curr_bss;
3670 at76_set_mac_state(priv, MAC_CONNECTED);
3671 /* get ESSID, BSSID and channel for priv->curr_bss */
3672 priv->essid_size = bptr->ssid_len;
3673 memcpy(priv->essid, bptr->ssid, bptr->ssid_len);
3674 memcpy(priv->bssid, bptr->bssid, ETH_ALEN);
3675 priv->channel = bptr->channel;
3676 at76_iwevent_bss_connect(priv->netdev, bptr->bssid);
3677 netif_carrier_on(priv->netdev);
3678 netif_start_queue(priv->netdev);
3679 /* just to be sure */
3680 cancel_delayed_work(&priv->dwork_get_scan);
3681 cancel_delayed_work(&priv->dwork_auth);
3682 cancel_delayed_work(&priv->dwork_assoc);
3685 priv->retries = AUTH_RETRIES;
3686 at76_set_mac_state(priv, MAC_AUTH);
3687 at76_auth_req(priv, priv->curr_bss, 1, NULL);
3688 at76_dbg(DBG_MGMT_TIMER,
3689 "%s:%d: starting mgmt_timer + HZ", __func__, __LINE__);
3690 schedule_delayed_work(&priv->dwork_auth, AUTH_TIMEOUT);
3694 mutex_unlock(&priv->mtx);
3697 /* Reap scan results */
3698 static void at76_dwork_get_scan(struct work_struct *work)
3702 struct at76_priv *priv = container_of(work, struct at76_priv,
3703 dwork_get_scan.work);
3705 mutex_lock(&priv->mtx);
3706 WARN_ON(priv->mac_state != MAC_SCANNING);
3707 if (priv->mac_state != MAC_SCANNING)
3710 status = at76_get_cmd_status(priv->udev, CMD_SCAN);
3712 printk(KERN_ERR "%s: %s: at76_get_cmd_status failed with %d\n",
3713 priv->netdev->name, __func__, status);
3714 status = CMD_STATUS_IN_PROGRESS;
3715 /* INFO: Hope it was a one off error - if not, scanning
3716 further down the line and stop this cycle */
3718 at76_dbg(DBG_PROGRESS,
3719 "%s %s: got cmd_status %d (state %s, need_any %d)",
3720 priv->netdev->name, __func__, status,
3721 mac_states[priv->mac_state], priv->scan_need_any);
3723 if (status != CMD_STATUS_COMPLETE) {
3724 if ((status != CMD_STATUS_IN_PROGRESS) &&
3725 (status != CMD_STATUS_IDLE))
3726 printk(KERN_ERR "%s: %s: Bad scan status: %s\n",
3727 priv->netdev->name, __func__,
3728 at76_get_cmd_status_string(status));
3730 /* the first cmd status after scan start is always a IDLE ->
3731 start the timer to poll again until COMPLETED */
3732 at76_dbg(DBG_MGMT_TIMER,
3733 "%s:%d: starting mgmt_timer for %d ticks",
3734 __func__, __LINE__, SCAN_POLL_INTERVAL);
3735 schedule_delayed_work(&priv->dwork_get_scan,
3736 SCAN_POLL_INTERVAL);
3740 if (at76_debug & DBG_BSS_TABLE)
3741 at76_dump_bss_table(priv);
3743 if (priv->scan_need_any) {
3744 ret = at76_start_scan(priv, 0);
3747 "%s: %s: start_scan (ANY) failed with %d\n",
3748 priv->netdev->name, __func__, ret);
3749 at76_dbg(DBG_MGMT_TIMER,
3750 "%s:%d: starting mgmt_timer for %d ticks", __func__,
3751 __LINE__, SCAN_POLL_INTERVAL);
3752 schedule_delayed_work(&priv->dwork_get_scan,
3753 SCAN_POLL_INTERVAL);
3754 priv->scan_need_any = 0;
3756 priv->scan_state = SCAN_COMPLETED;
3757 /* report the end of scan to user space */
3758 at76_iwevent_scan_complete(priv->netdev);
3759 at76_set_mac_state(priv, MAC_JOINING);
3760 schedule_work(&priv->work_join);
3764 mutex_unlock(&priv->mtx);
3767 /* Handle loss of beacons from the AP */
3768 static void at76_dwork_beacon(struct work_struct *work)
3770 struct at76_priv *priv = container_of(work, struct at76_priv,
3773 mutex_lock(&priv->mtx);
3774 if (priv->mac_state != MAC_CONNECTED || priv->iw_mode != IW_MODE_INFRA)
3777 /* We haven't received any beacons from out AP for BEACON_TIMEOUT */
3778 printk(KERN_INFO "%s: lost beacon bssid %s\n",
3779 priv->netdev->name, mac2str(priv->curr_bss->bssid));
3781 netif_carrier_off(priv->netdev);
3782 netif_stop_queue(priv->netdev);
3783 at76_iwevent_bss_disconnect(priv->netdev);
3784 at76_set_mac_state(priv, MAC_SCANNING);
3785 schedule_work(&priv->work_start_scan);
3788 mutex_unlock(&priv->mtx);
3791 /* Handle authentication response timeout */
3792 static void at76_dwork_auth(struct work_struct *work)
3794 struct at76_priv *priv = container_of(work, struct at76_priv,
3797 mutex_lock(&priv->mtx);
3798 WARN_ON(priv->mac_state != MAC_AUTH);
3799 if (priv->mac_state != MAC_AUTH)
3802 at76_dbg(DBG_PROGRESS, "%s: authentication response timeout",
3803 priv->netdev->name);
3805 if (priv->retries-- >= 0) {
3806 at76_auth_req(priv, priv->curr_bss, 1, NULL);
3807 at76_dbg(DBG_MGMT_TIMER, "%s:%d: starting mgmt_timer + HZ",
3808 __func__, __LINE__);
3809 schedule_delayed_work(&priv->dwork_auth, AUTH_TIMEOUT);
3811 /* try to get next matching BSS */
3812 at76_set_mac_state(priv, MAC_JOINING);
3813 schedule_work(&priv->work_join);
3817 mutex_unlock(&priv->mtx);
3820 /* Handle association response timeout */
3821 static void at76_dwork_assoc(struct work_struct *work)
3823 struct at76_priv *priv = container_of(work, struct at76_priv,
3826 mutex_lock(&priv->mtx);
3827 WARN_ON(priv->mac_state != MAC_ASSOC);
3828 if (priv->mac_state != MAC_ASSOC)
3831 at76_dbg(DBG_PROGRESS, "%s: association response timeout",
3832 priv->netdev->name);
3834 if (priv->retries-- >= 0) {
3835 at76_assoc_req(priv, priv->curr_bss);
3836 at76_dbg(DBG_MGMT_TIMER, "%s:%d: starting mgmt_timer + HZ",
3837 __func__, __LINE__);
3838 schedule_delayed_work(&priv->dwork_assoc, ASSOC_TIMEOUT);
3840 /* try to get next matching BSS */
3841 at76_set_mac_state(priv, MAC_JOINING);
3842 schedule_work(&priv->work_join);
3846 mutex_unlock(&priv->mtx);
3849 /* Read new bssid in ad-hoc mode */
3850 static void at76_work_new_bss(struct work_struct *work)
3852 struct at76_priv *priv = container_of(work, struct at76_priv,
3855 struct mib_mac_mgmt mac_mgmt;
3857 mutex_lock(&priv->mtx);
3859 ret = at76_get_mib(priv->udev, MIB_MAC_MGMT, &mac_mgmt,
3860 sizeof(struct mib_mac_mgmt));
3862 printk(KERN_ERR "%s: at76_get_mib failed: %d\n",
3863 priv->netdev->name, ret);
3867 at76_dbg(DBG_PROGRESS, "ibss_change = 0x%2x", mac_mgmt.ibss_change);
3868 memcpy(priv->bssid, mac_mgmt.current_bssid, ETH_ALEN);
3869 at76_dbg(DBG_PROGRESS, "using BSSID %s", mac2str(priv->bssid));
3871 at76_iwevent_bss_connect(priv->netdev, priv->bssid);
3873 priv->mib_buf.type = MIB_MAC_MGMT;
3874 priv->mib_buf.size = 1;
3875 priv->mib_buf.index = offsetof(struct mib_mac_mgmt, ibss_change);
3876 priv->mib_buf.data.byte = 0;
3878 ret = at76_set_mib(priv, &priv->mib_buf);
3880 printk(KERN_ERR "%s: set_mib (ibss change ok) failed: %d\n",
3881 priv->netdev->name, ret);
3884 mutex_unlock(&priv->mtx);
3887 static int at76_startup_device(struct at76_priv *priv)
3889 struct at76_card_config *ccfg = &priv->card_config;
3892 at76_dbg(DBG_PARAMS,
3893 "%s param: ssid %.*s (%s) mode %s ch %d wep %s key %d "
3894 "keylen %d", priv->netdev->name, priv->essid_size, priv->essid,
3895 hex2str(priv->essid, IW_ESSID_MAX_SIZE),
3896 priv->iw_mode == IW_MODE_ADHOC ? "adhoc" : "infra",
3897 priv->channel, priv->wep_enabled ? "enabled" : "disabled",
3898 priv->wep_key_id, priv->wep_keys_len[priv->wep_key_id]);
3899 at76_dbg(DBG_PARAMS,
3900 "%s param: preamble %s rts %d retry %d frag %d "
3901 "txrate %s auth_mode %d", priv->netdev->name,
3902 preambles[priv->preamble_type], priv->rts_threshold,
3903 priv->short_retry_limit, priv->frag_threshold,
3904 priv->txrate == TX_RATE_1MBIT ? "1MBit" : priv->txrate ==
3905 TX_RATE_2MBIT ? "2MBit" : priv->txrate ==
3906 TX_RATE_5_5MBIT ? "5.5MBit" : priv->txrate ==
3907 TX_RATE_11MBIT ? "11MBit" : priv->txrate ==
3908 TX_RATE_AUTO ? "auto" : "<invalid>", priv->auth_mode);
3909 at76_dbg(DBG_PARAMS,
3910 "%s param: pm_mode %d pm_period %d auth_mode %s "
3911 "scan_times %d %d scan_mode %s",
3912 priv->netdev->name, priv->pm_mode, priv->pm_period,
3913 priv->auth_mode == WLAN_AUTH_OPEN ? "open" : "shared_secret",
3914 priv->scan_min_time, priv->scan_max_time,
3915 priv->scan_mode == SCAN_TYPE_ACTIVE ? "active" : "passive");
3917 memset(ccfg, 0, sizeof(struct at76_card_config));
3918 ccfg->promiscuous_mode = 0;
3919 ccfg->short_retry_limit = priv->short_retry_limit;
3921 if (priv->wep_enabled) {
3922 if (priv->wep_keys_len[priv->wep_key_id] > WEP_SMALL_KEY_LEN)
3923 ccfg->encryption_type = 2;
3925 ccfg->encryption_type = 1;
3927 /* jal: always exclude unencrypted if WEP is active */
3928 ccfg->exclude_unencrypted = 1;
3930 ccfg->exclude_unencrypted = 0;
3931 ccfg->encryption_type = 0;
3934 ccfg->rts_threshold = cpu_to_le16(priv->rts_threshold);
3935 ccfg->fragmentation_threshold = cpu_to_le16(priv->frag_threshold);
3937 memcpy(ccfg->basic_rate_set, hw_rates, 4);
3938 /* jal: really needed, we do a set_mib for autorate later ??? */
3939 ccfg->auto_rate_fallback = (priv->txrate == TX_RATE_AUTO ? 1 : 0);
3940 ccfg->channel = priv->channel;
3941 ccfg->privacy_invoked = priv->wep_enabled;
3942 memcpy(ccfg->current_ssid, priv->essid, IW_ESSID_MAX_SIZE);
3943 ccfg->ssid_len = priv->essid_size;
3945 ccfg->wep_default_key_id = priv->wep_key_id;
3946 memcpy(ccfg->wep_default_key_value, priv->wep_keys, 4 * WEP_KEY_LEN);
3948 ccfg->short_preamble = priv->preamble_type;
3949 ccfg->beacon_period = cpu_to_le16(priv->beacon_period);
3951 ret = at76_set_card_command(priv->udev, CMD_STARTUP, &priv->card_config,
3952 sizeof(struct at76_card_config));
3954 printk(KERN_ERR "%s: at76_set_card_command failed: %d\n",
3955 priv->netdev->name, ret);
3959 at76_wait_completion(priv, CMD_STARTUP);
3961 /* remove BSSID from previous run */
3962 memset(priv->bssid, 0, ETH_ALEN);
3964 if (at76_set_radio(priv, 1) == 1)
3965 at76_wait_completion(priv, CMD_RADIO_ON);
3967 ret = at76_set_preamble(priv, priv->preamble_type);
3971 ret = at76_set_frag(priv, priv->frag_threshold);
3975 ret = at76_set_rts(priv, priv->rts_threshold);
3979 ret = at76_set_autorate_fallback(priv,
3980 priv->txrate == TX_RATE_AUTO ? 1 : 0);
3984 ret = at76_set_pm_mode(priv);
3988 if (at76_debug & DBG_MIB) {
3989 at76_dump_mib_mac(priv);
3990 at76_dump_mib_mac_addr(priv);
3991 at76_dump_mib_mac_mgmt(priv);
3992 at76_dump_mib_mac_wep(priv);
3993 at76_dump_mib_mdomain(priv);
3994 at76_dump_mib_phy(priv);
3995 at76_dump_mib_local(priv);
4001 /* Restart the interface */
4002 static void at76_dwork_restart(struct work_struct *work)
4004 struct at76_priv *priv = container_of(work, struct at76_priv,
4005 dwork_restart.work);
4007 mutex_lock(&priv->mtx);
4009 netif_carrier_off(priv->netdev); /* stop netdev watchdog */
4010 netif_stop_queue(priv->netdev); /* stop tx data packets */
4012 at76_startup_device(priv);
4014 if (priv->iw_mode != IW_MODE_MONITOR) {
4015 priv->netdev->type = ARPHRD_ETHER;
4016 at76_set_mac_state(priv, MAC_SCANNING);
4017 schedule_work(&priv->work_start_scan);
4019 priv->netdev->type = ARPHRD_IEEE80211_RADIOTAP;
4020 at76_start_monitor(priv);
4023 mutex_unlock(&priv->mtx);
4026 /* Initiate scanning */
4027 static void at76_work_start_scan(struct work_struct *work)
4029 struct at76_priv *priv = container_of(work, struct at76_priv,
4033 mutex_lock(&priv->mtx);
4035 WARN_ON(priv->mac_state != MAC_SCANNING);
4036 if (priv->mac_state != MAC_SCANNING)
4039 /* only clear the bss list when a scan is actively initiated,
4040 * otherwise simply rely on at76_bss_list_timeout */
4041 if (priv->scan_state == SCAN_IN_PROGRESS) {
4042 at76_free_bss_list(priv);
4043 priv->scan_need_any = 1;
4045 priv->scan_need_any = 0;
4047 ret = at76_start_scan(priv, 1);
4050 printk(KERN_ERR "%s: %s: start_scan failed with %d\n",
4051 priv->netdev->name, __func__, ret);
4053 at76_dbg(DBG_MGMT_TIMER,
4054 "%s:%d: starting mgmt_timer for %d ticks",
4055 __func__, __LINE__, SCAN_POLL_INTERVAL);
4056 schedule_delayed_work(&priv->dwork_get_scan,
4057 SCAN_POLL_INTERVAL);
4061 mutex_unlock(&priv->mtx);
4064 /* Enable or disable promiscuous mode */
4065 static void at76_work_set_promisc(struct work_struct *work)
4067 struct at76_priv *priv = container_of(work, struct at76_priv,
4071 mutex_lock(&priv->mtx);
4073 priv->mib_buf.type = MIB_LOCAL;
4074 priv->mib_buf.size = 1;
4075 priv->mib_buf.index = offsetof(struct mib_local, promiscuous_mode);
4076 priv->mib_buf.data.byte = priv->promisc ? 1 : 0;
4078 ret = at76_set_mib(priv, &priv->mib_buf);
4080 printk(KERN_ERR "%s: set_mib (promiscuous_mode) failed: %d\n",
4081 priv->netdev->name, ret);
4083 mutex_unlock(&priv->mtx);
4086 /* Submit Rx urb back to the device */
4087 static void at76_work_submit_rx(struct work_struct *work)
4089 struct at76_priv *priv = container_of(work, struct at76_priv,
4092 mutex_lock(&priv->mtx);
4093 at76_submit_rx_urb(priv);
4094 mutex_unlock(&priv->mtx);
4097 /* We got an association response */
4098 static void at76_rx_mgmt_assoc(struct at76_priv *priv,
4099 struct at76_rx_buffer *buf)
4101 struct ieee80211_assoc_response *resp =
4102 (struct ieee80211_assoc_response *)buf->packet;
4103 u16 assoc_id = le16_to_cpu(resp->aid);
4104 u16 status = le16_to_cpu(resp->status);
4106 at76_dbg(DBG_RX_MGMT, "%s: rx AssocResp bssid %s capa 0x%04x status "
4107 "0x%04x assoc_id 0x%04x rates %s", priv->netdev->name,
4108 mac2str(resp->header.addr3), le16_to_cpu(resp->capability),
4109 status, assoc_id, hex2str(resp->info_element->data,
4110 resp->info_element->len));
4112 if (priv->mac_state != MAC_ASSOC) {
4113 printk(KERN_INFO "%s: AssocResp in state %s ignored\n",
4114 priv->netdev->name, mac_states[priv->mac_state]);
4118 BUG_ON(!priv->curr_bss);
4120 cancel_delayed_work(&priv->dwork_assoc);
4121 if (status == WLAN_STATUS_SUCCESS) {
4122 struct bss_info *ptr = priv->curr_bss;
4123 priv->assoc_id = assoc_id & 0x3fff;
4124 /* update iwconfig params */
4125 memcpy(priv->bssid, ptr->bssid, ETH_ALEN);
4126 memcpy(priv->essid, ptr->ssid, ptr->ssid_len);
4127 priv->essid_size = ptr->ssid_len;
4128 priv->channel = ptr->channel;
4129 schedule_work(&priv->work_assoc_done);
4131 at76_set_mac_state(priv, MAC_JOINING);
4132 schedule_work(&priv->work_join);
4136 /* Process disassociation request from the AP */
4137 static void at76_rx_mgmt_disassoc(struct at76_priv *priv,
4138 struct at76_rx_buffer *buf)
4140 struct ieee80211_disassoc *resp =
4141 (struct ieee80211_disassoc *)buf->packet;
4142 struct ieee80211_hdr_3addr *mgmt = &resp->header;
4144 at76_dbg(DBG_RX_MGMT,
4145 "%s: rx DisAssoc bssid %s reason 0x%04x destination %s",
4146 priv->netdev->name, mac2str(mgmt->addr3),
4147 le16_to_cpu(resp->reason), mac2str(mgmt->addr1));
4149 /* We are not connected, ignore */
4150 if (priv->mac_state == MAC_SCANNING || priv->mac_state == MAC_INIT
4154 /* Not our BSSID, ignore */
4155 if (compare_ether_addr(mgmt->addr3, priv->curr_bss->bssid))
4158 /* Not for our STA and not broadcast, ignore */
4159 if (compare_ether_addr(priv->netdev->dev_addr, mgmt->addr1)
4160 && !is_broadcast_ether_addr(mgmt->addr1))
4163 if (priv->mac_state != MAC_ASSOC && priv->mac_state != MAC_CONNECTED
4164 && priv->mac_state != MAC_JOINING) {
4165 printk(KERN_INFO "%s: DisAssoc in state %s ignored\n",
4166 priv->netdev->name, mac_states[priv->mac_state]);
4170 if (priv->mac_state == MAC_CONNECTED) {
4171 netif_carrier_off(priv->netdev);
4172 netif_stop_queue(priv->netdev);
4173 at76_iwevent_bss_disconnect(priv->netdev);
4175 cancel_delayed_work(&priv->dwork_get_scan);
4176 cancel_delayed_work(&priv->dwork_beacon);
4177 cancel_delayed_work(&priv->dwork_auth);
4178 cancel_delayed_work(&priv->dwork_assoc);
4179 at76_set_mac_state(priv, MAC_JOINING);
4180 schedule_work(&priv->work_join);
4183 static void at76_rx_mgmt_auth(struct at76_priv *priv,
4184 struct at76_rx_buffer *buf)
4186 struct ieee80211_auth *resp = (struct ieee80211_auth *)buf->packet;
4187 struct ieee80211_hdr_3addr *mgmt = &resp->header;
4188 int seq_nr = le16_to_cpu(resp->transaction);
4189 int alg = le16_to_cpu(resp->algorithm);
4190 int status = le16_to_cpu(resp->status);
4192 at76_dbg(DBG_RX_MGMT,
4193 "%s: rx AuthFrame bssid %s alg %d seq_nr %d status %d "
4194 "destination %s", priv->netdev->name, mac2str(mgmt->addr3),
4195 alg, seq_nr, status, mac2str(mgmt->addr1));
4197 if (alg == WLAN_AUTH_SHARED_KEY && seq_nr == 2)
4198 at76_dbg(DBG_RX_MGMT, "%s: AuthFrame challenge %s ...",
4199 priv->netdev->name, hex2str(resp->info_element, 18));
4201 if (priv->mac_state != MAC_AUTH) {
4202 printk(KERN_INFO "%s: ignored AuthFrame in state %s\n",
4203 priv->netdev->name, mac_states[priv->mac_state]);
4206 if (priv->auth_mode != alg) {
4207 printk(KERN_INFO "%s: ignored AuthFrame for alg %d\n",
4208 priv->netdev->name, alg);
4212 BUG_ON(!priv->curr_bss);
4214 /* Not our BSSID or not for our STA, ignore */
4215 if (compare_ether_addr(mgmt->addr3, priv->curr_bss->bssid)
4216 || compare_ether_addr(priv->netdev->dev_addr, mgmt->addr1))
4219 cancel_delayed_work(&priv->dwork_auth);
4220 if (status != WLAN_STATUS_SUCCESS) {
4221 /* try to join next bss */
4222 at76_set_mac_state(priv, MAC_JOINING);
4223 schedule_work(&priv->work_join);
4227 if (priv->auth_mode == WLAN_AUTH_OPEN || seq_nr == 4) {
4228 priv->retries = ASSOC_RETRIES;
4229 at76_set_mac_state(priv, MAC_ASSOC);
4230 at76_assoc_req(priv, priv->curr_bss);
4231 at76_dbg(DBG_MGMT_TIMER,
4232 "%s:%d: starting mgmt_timer + HZ", __func__, __LINE__);
4233 schedule_delayed_work(&priv->dwork_assoc, ASSOC_TIMEOUT);
4237 WARN_ON(seq_nr != 2);
4238 at76_auth_req(priv, priv->curr_bss, seq_nr + 1, resp->info_element);
4239 at76_dbg(DBG_MGMT_TIMER, "%s:%d: starting mgmt_timer + HZ", __func__,
4241 schedule_delayed_work(&priv->dwork_auth, AUTH_TIMEOUT);
4244 static void at76_rx_mgmt_deauth(struct at76_priv *priv,
4245 struct at76_rx_buffer *buf)
4247 struct ieee80211_disassoc *resp =
4248 (struct ieee80211_disassoc *)buf->packet;
4249 struct ieee80211_hdr_3addr *mgmt = &resp->header;
4251 at76_dbg(DBG_RX_MGMT | DBG_PROGRESS,
4252 "%s: rx DeAuth bssid %s reason 0x%04x destination %s",
4253 priv->netdev->name, mac2str(mgmt->addr3),
4254 le16_to_cpu(resp->reason), mac2str(mgmt->addr1));
4256 if (priv->mac_state != MAC_AUTH && priv->mac_state != MAC_ASSOC
4257 && priv->mac_state != MAC_CONNECTED) {
4258 printk(KERN_INFO "%s: DeAuth in state %s ignored\n",
4259 priv->netdev->name, mac_states[priv->mac_state]);
4263 BUG_ON(!priv->curr_bss);
4265 /* Not our BSSID, ignore */
4266 if (compare_ether_addr(mgmt->addr3, priv->curr_bss->bssid))
4269 /* Not for our STA and not broadcast, ignore */
4270 if (compare_ether_addr(priv->netdev->dev_addr, mgmt->addr1)
4271 && !is_broadcast_ether_addr(mgmt->addr1))
4274 if (priv->mac_state == MAC_CONNECTED)
4275 at76_iwevent_bss_disconnect(priv->netdev);
4277 at76_set_mac_state(priv, MAC_JOINING);
4278 schedule_work(&priv->work_join);
4279 cancel_delayed_work(&priv->dwork_get_scan);
4280 cancel_delayed_work(&priv->dwork_beacon);
4281 cancel_delayed_work(&priv->dwork_auth);
4282 cancel_delayed_work(&priv->dwork_assoc);
4285 static void at76_rx_mgmt_beacon(struct at76_priv *priv,
4286 struct at76_rx_buffer *buf)
4289 /* beacon content */
4290 struct ieee80211_beacon *bdata = (struct ieee80211_beacon *)buf->packet;
4291 struct ieee80211_hdr_3addr *mgmt = &bdata->header;
4293 struct list_head *lptr;
4294 struct bss_info *match; /* entry matching addr3 with its bssid */
4297 struct ieee80211_info_element *ie;
4300 int have_channel = 0;
4302 unsigned long flags;
4304 spin_lock_irqsave(&priv->bss_list_spinlock, flags);
4305 if (priv->mac_state == MAC_CONNECTED) {
4306 /* in state MAC_CONNECTED we use the mgmt_timer to control
4307 the beacon of the BSS */
4308 BUG_ON(!priv->curr_bss);
4310 if (!compare_ether_addr(priv->curr_bss->bssid, mgmt->addr3)) {
4311 /* We got our AP's beacon, defer the timeout handler.
4312 Kill pending work first, as schedule_delayed_work()
4314 cancel_delayed_work(&priv->dwork_beacon);
4315 schedule_delayed_work(&priv->dwork_beacon,
4317 priv->curr_bss->rssi = buf->rssi;
4318 priv->beacons_received++;
4323 /* look if we have this BSS already in the list */
4326 if (!list_empty(&priv->bss_list)) {
4327 list_for_each(lptr, &priv->bss_list) {
4328 struct bss_info *bss_ptr =
4329 list_entry(lptr, struct bss_info, list);
4330 if (!compare_ether_addr(bss_ptr->bssid, mgmt->addr3)) {
4338 /* BSS not in the list - append it */
4339 match = kzalloc(sizeof(struct bss_info), GFP_ATOMIC);
4341 at76_dbg(DBG_BSS_TABLE,
4342 "%s: cannot kmalloc new bss info (%zd byte)",
4343 priv->netdev->name, sizeof(struct bss_info));
4347 list_add_tail(&match->list, &priv->bss_list);
4350 match->capa = le16_to_cpu(bdata->capability);
4351 match->beacon_interval = le16_to_cpu(bdata->beacon_interval);
4352 match->rssi = buf->rssi;
4353 match->link_qual = buf->link_quality;
4354 match->noise_level = buf->noise_level;
4355 memcpy(match->bssid, mgmt->addr3, ETH_ALEN);
4356 at76_dbg(DBG_RX_BEACON, "%s: bssid %s", priv->netdev->name,
4357 mac2str(match->bssid));
4359 ie = bdata->info_element;
4361 /* length of var length beacon parameters */
4362 varpar_len = min_t(int, le16_to_cpu(buf->wlength) -
4363 sizeof(struct ieee80211_beacon),
4364 BEACON_MAX_DATA_LENGTH);
4366 /* This routine steps through the bdata->data array to get
4367 * some useful information about the access point.
4368 * Currently, this implementation supports receipt of: SSID,
4369 * supported transfer rates and channel, in any order, with some
4370 * tolerance for intermittent unknown codes (although this
4371 * functionality may not be necessary as the useful information will
4372 * usually arrive in consecutively, but there have been some
4373 * reports of some of the useful information fields arriving in a
4375 * It does not support any more IE types although MFIE_TYPE_TIM may
4376 * be supported (on my AP at least).
4377 * The bdata->data array is about 1500 bytes long but only ~36 of those
4378 * bytes are useful, hence the have_ssid etc optimizations. */
4380 while (keep_going &&
4381 ((&ie->data[ie->len] - (u8 *)bdata->info_element) <=
4386 case MFIE_TYPE_SSID:
4390 len = min_t(int, IW_ESSID_MAX_SIZE, ie->len);
4392 /* we copy only if this is a new entry,
4393 or the incoming SSID is not a hidden SSID. This
4394 will protect us from overwriting a real SSID read
4395 in a ProbeResponse with a hidden one from a
4396 following beacon. */
4397 if (!new_entry && at76_is_hidden_ssid(ie->data, len)) {
4402 match->ssid_len = len;
4403 memcpy(match->ssid, ie->data, len);
4404 at76_dbg(DBG_RX_BEACON, "%s: SSID - %.*s",
4405 priv->netdev->name, len, match->ssid);
4409 case MFIE_TYPE_RATES:
4414 min_t(int, sizeof(match->rates), ie->len);
4415 memcpy(match->rates, ie->data, match->rates_len);
4417 at76_dbg(DBG_RX_BEACON, "%s: SUPPORTED RATES %s",
4419 hex2str(ie->data, ie->len));
4422 case MFIE_TYPE_DS_SET:
4426 match->channel = ie->data[0];
4428 at76_dbg(DBG_RX_BEACON, "%s: CHANNEL - %d",
4429 priv->netdev->name, match->channel);
4432 case MFIE_TYPE_CF_SET:
4434 case MFIE_TYPE_IBSS_SET:
4436 at76_dbg(DBG_RX_BEACON, "%s: beacon IE id %d len %d %s",
4437 priv->netdev->name, ie->id, ie->len,
4438 hex2str(ie->data, ie->len));
4442 /* advance to the next informational element */
4445 /* Optimization: after all, the bdata->data array is
4446 * varpar_len bytes long, whereas we get all of the useful
4447 * information after only ~36 bytes, this saves us a lot of
4448 * time (and trouble as the remaining portion of the array
4449 * could be full of junk)
4450 * Comment this out if you want to see what other information
4451 * comes from the AP - although little of it may be useful */
4454 at76_dbg(DBG_RX_BEACON, "%s: Finished processing beacon data",
4455 priv->netdev->name);
4457 match->last_rx = jiffies; /* record last rx of beacon */
4460 spin_unlock_irqrestore(&priv->bss_list_spinlock, flags);
4463 /* Calculate the link level from a given rx_buffer */
4464 static void at76_calc_level(struct at76_priv *priv, struct at76_rx_buffer *buf,
4465 struct iw_quality *qual)
4467 /* just a guess for now, might be different for other chips */
4470 qual->level = (buf->rssi * 100 / max_rssi);
4471 if (qual->level > 100)
4473 qual->updated |= IW_QUAL_LEVEL_UPDATED;
4476 /* Calculate the link quality from a given rx_buffer */
4477 static void at76_calc_qual(struct at76_priv *priv, struct at76_rx_buffer *buf,
4478 struct iw_quality *qual)
4480 if (at76_is_intersil(priv->board_type))
4481 qual->qual = buf->link_quality;
4483 unsigned long elapsed;
4485 /* Update qual at most once a second */
4486 elapsed = jiffies - priv->beacons_last_qual;
4487 if (elapsed < 1 * HZ)
4490 qual->qual = qual->level * priv->beacons_received *
4491 msecs_to_jiffies(priv->beacon_period) / elapsed;
4493 priv->beacons_last_qual = jiffies;
4494 priv->beacons_received = 0;
4496 qual->qual = (qual->qual > 100) ? 100 : qual->qual;
4497 qual->updated |= IW_QUAL_QUAL_UPDATED;
4500 /* Calculate the noise quality from a given rx_buffer */
4501 static void at76_calc_noise(struct at76_priv *priv, struct at76_rx_buffer *buf,
4502 struct iw_quality *qual)
4505 qual->updated |= IW_QUAL_NOISE_INVALID;
4508 static void at76_update_wstats(struct at76_priv *priv,
4509 struct at76_rx_buffer *buf)
4511 struct iw_quality *qual = &priv->wstats.qual;
4513 if (buf->rssi && priv->mac_state == MAC_CONNECTED) {
4515 at76_calc_level(priv, buf, qual);
4516 at76_calc_qual(priv, buf, qual);
4517 at76_calc_noise(priv, buf, qual);
4522 qual->updated = IW_QUAL_ALL_INVALID;
4526 static void at76_rx_mgmt(struct at76_priv *priv, struct at76_rx_buffer *buf)
4528 struct ieee80211_hdr_3addr *mgmt =
4529 (struct ieee80211_hdr_3addr *)buf->packet;
4530 u16 framectl = le16_to_cpu(mgmt->frame_ctl);
4533 if (priv->mac_state != MAC_INIT && priv->mac_state != MAC_SCANNING) {
4534 /* jal: this is a dirty hack needed by Tim in ad-hoc mode */
4535 /* Data packets always seem to have a 0 link level, so we
4536 only read link quality info from management packets.
4537 Atmel driver actually averages the present, and previous
4538 values, we just present the raw value at the moment - TJS */
4539 if (priv->iw_mode == IW_MODE_ADHOC
4541 && !compare_ether_addr(mgmt->addr3,
4542 priv->curr_bss->bssid)))
4543 at76_update_wstats(priv, buf);
4546 at76_dbg(DBG_RX_MGMT_CONTENT, "%s rx mgmt framectl 0x%x %s",
4547 priv->netdev->name, framectl,
4548 hex2str(mgmt, le16_to_cpu(buf->wlength)));
4550 switch (framectl & IEEE80211_FCTL_STYPE) {
4551 case IEEE80211_STYPE_BEACON:
4552 case IEEE80211_STYPE_PROBE_RESP:
4553 at76_rx_mgmt_beacon(priv, buf);
4556 case IEEE80211_STYPE_ASSOC_RESP:
4557 at76_rx_mgmt_assoc(priv, buf);
4560 case IEEE80211_STYPE_DISASSOC:
4561 at76_rx_mgmt_disassoc(priv, buf);
4564 case IEEE80211_STYPE_AUTH:
4565 at76_rx_mgmt_auth(priv, buf);
4568 case IEEE80211_STYPE_DEAUTH:
4569 at76_rx_mgmt_deauth(priv, buf);
4573 printk(KERN_DEBUG "%s: ignoring frame with framectl 0x%04x\n",
4574 priv->netdev->name, framectl);
4580 /* Convert the 802.11 header into an ethernet-style header, make skb
4581 * ready for consumption by netif_rx() */
4582 static void at76_ieee80211_to_eth(struct sk_buff *skb, int iw_mode)
4584 struct ieee80211_hdr_3addr *i802_11_hdr;
4585 struct ethhdr *eth_hdr_p;
4589 i802_11_hdr = (struct ieee80211_hdr_3addr *)skb->data;
4591 /* That would be the ethernet header if the hardware converted
4592 * the frame for us. Make sure the source and the destination
4593 * match the 802.11 header. Which hardware does it? */
4594 eth_hdr_p = (struct ethhdr *)skb_pull(skb, IEEE80211_3ADDR_LEN);
4596 dest_addr = i802_11_hdr->addr1;
4597 if (iw_mode == IW_MODE_ADHOC)
4598 src_addr = i802_11_hdr->addr2;
4600 src_addr = i802_11_hdr->addr3;
4602 if (!compare_ether_addr(eth_hdr_p->h_source, src_addr) &&
4603 !compare_ether_addr(eth_hdr_p->h_dest, dest_addr))
4604 /* Yes, we already have an ethernet header */
4605 skb_reset_mac_header(skb);
4609 /* Need to build an ethernet header */
4610 if (!memcmp(skb->data, snapsig, sizeof(snapsig))) {
4611 /* SNAP frame - decapsulate, keep proto */
4612 skb_push(skb, offsetof(struct ethhdr, h_proto) -
4613 sizeof(rfc1042sig));
4616 /* 802.3 frame, proto is length */
4618 skb_push(skb, ETH_HLEN);
4621 skb_reset_mac_header(skb);
4622 eth_hdr_p = eth_hdr(skb);
4623 /* This needs to be done in this order (eth_hdr_p->h_dest may
4624 * overlap src_addr) */
4625 memcpy(eth_hdr_p->h_source, src_addr, ETH_ALEN);
4626 memcpy(eth_hdr_p->h_dest, dest_addr, ETH_ALEN);
4628 eth_hdr_p->h_proto = htons(len);
4631 skb->protocol = eth_type_trans(skb, skb->dev);
4634 /* Check for fragmented data in priv->rx_skb. If the packet was no fragment
4635 or it was the last of a fragment set a skb containing the whole packet
4636 is returned for further processing. Otherwise we get NULL and are
4637 done and the packet is either stored inside the fragment buffer
4638 or thrown away. Every returned skb starts with the ieee802_11 header
4639 and contains _no_ FCS at the end */
4640 static struct sk_buff *at76_check_for_rx_frags(struct at76_priv *priv)
4642 struct sk_buff *skb = priv->rx_skb;
4643 struct at76_rx_buffer *buf = (struct at76_rx_buffer *)skb->data;
4644 struct ieee80211_hdr_3addr *i802_11_hdr =
4645 (struct ieee80211_hdr_3addr *)buf->packet;
4646 /* seq_ctrl, fragment_number, sequence number of new packet */
4647 u16 sctl = le16_to_cpu(i802_11_hdr->seq_ctl);
4648 u16 fragnr = sctl & 0xf;
4649 u16 seqnr = sctl >> 4;
4650 u16 frame_ctl = le16_to_cpu(i802_11_hdr->frame_ctl);
4652 /* Length including the IEEE802.11 header, but without the trailing
4653 * FCS and without the Atmel Rx header */
4654 int length = le16_to_cpu(buf->wlength) - IEEE80211_FCS_LEN;
4656 /* where does the data payload start in skb->data ? */
4657 u8 *data = i802_11_hdr->payload;
4659 /* length of payload, excl. the trailing FCS */
4660 int data_len = length - IEEE80211_3ADDR_LEN;
4663 struct rx_data_buf *bptr, *optr;
4664 unsigned long oldest = ~0UL;
4666 at76_dbg(DBG_RX_FRAGS,
4667 "%s: rx data frame_ctl %04x addr2 %s seq/frag %d/%d "
4668 "length %d data %d: %s ...", priv->netdev->name, frame_ctl,
4669 mac2str(i802_11_hdr->addr2), seqnr, fragnr, length, data_len,
4672 at76_dbg(DBG_RX_FRAGS_SKB, "%s: incoming skb: head %p data %p "
4673 "tail %p end %p len %d", priv->netdev->name, skb->head,
4674 skb->data, skb_tail_pointer(skb), skb_end_pointer(skb),
4678 /* make sure data starts in the buffer */
4679 printk(KERN_INFO "%s: data frame too short\n",
4680 priv->netdev->name);
4684 WARN_ON(length <= AT76_RX_HDRLEN);
4685 if (length <= AT76_RX_HDRLEN)
4688 /* remove the at76_rx_buffer header - we don't need it anymore */
4689 /* we need the IEEE802.11 header (for the addresses) if this packet
4690 is the first of a chain */
4691 skb_pull(skb, AT76_RX_HDRLEN);
4693 /* remove FCS at end */
4694 skb_trim(skb, length);
4696 at76_dbg(DBG_RX_FRAGS_SKB, "%s: trimmed skb: head %p data %p tail %p "
4697 "end %p len %d data %p data_len %d", priv->netdev->name,
4698 skb->head, skb->data, skb_tail_pointer(skb),
4699 skb_end_pointer(skb), skb->len, data, data_len);
4701 if (fragnr == 0 && !(frame_ctl & IEEE80211_FCTL_MOREFRAGS)) {
4702 /* unfragmented packet received */
4703 /* Use a new skb for the next receive */
4704 priv->rx_skb = NULL;
4705 at76_dbg(DBG_RX_FRAGS, "%s: unfragmented", priv->netdev->name);
4709 /* look if we've got a chain for the sender address.
4710 afterwards optr points to first free or the oldest entry,
4711 or, if i < NR_RX_DATA_BUF, bptr points to the entry for the
4713 /* determining the oldest entry doesn't cope with jiffies wrapping
4714 but I don't care to delete a young entry at these rare moments ... */
4716 bptr = priv->rx_data;
4718 for (i = 0; i < NR_RX_DATA_BUF; i++, bptr++) {
4725 if (!compare_ether_addr(i802_11_hdr->addr2, bptr->sender))
4730 oldest = bptr->last_rx;
4731 } else if (bptr->last_rx < oldest)
4735 if (i < NR_RX_DATA_BUF) {
4737 at76_dbg(DBG_RX_FRAGS, "%s: %d. cacheentry (seq/frag = %d/%d) "
4738 "matched sender addr",
4739 priv->netdev->name, i, bptr->seqnr, bptr->fragnr);
4741 /* bptr points to an entry for the sender address */
4742 if (bptr->seqnr == seqnr) {
4744 /* the fragment has the current sequence number */
4745 if (((bptr->fragnr + 1) & 0xf) != fragnr) {
4746 /* wrong fragment number -> ignore it */
4747 /* is & 0xf necessary above ??? */
4748 at76_dbg(DBG_RX_FRAGS,
4749 "%s: frag nr mismatch: %d + 1 != %d",
4750 priv->netdev->name, bptr->fragnr,
4754 bptr->last_rx = jiffies;
4755 /* the next following fragment number ->
4756 add the data at the end */
4758 /* for test only ??? */
4759 left = skb_tailroom(bptr->skb);
4760 if (left < data_len)
4762 "%s: only %d byte free (need %d)\n",
4763 priv->netdev->name, left, data_len);
4765 memcpy(skb_put(bptr->skb, data_len), data,
4768 bptr->fragnr = fragnr;
4769 if (frame_ctl & IEEE80211_FCTL_MOREFRAGS)
4772 /* this was the last fragment - send it */
4774 bptr->skb = NULL; /* free the entry */
4775 at76_dbg(DBG_RX_FRAGS, "%s: last frag of seq %d",
4776 priv->netdev->name, seqnr);
4780 /* got another sequence number */
4782 /* it's the start of a new chain - replace the
4784 /* bptr->sender has the correct value already */
4785 at76_dbg(DBG_RX_FRAGS,
4786 "%s: start of new seq %d, removing old seq %d",
4787 priv->netdev->name, seqnr, bptr->seqnr);
4788 bptr->seqnr = seqnr;
4790 bptr->last_rx = jiffies;
4791 /* swap bptr->skb and priv->rx_skb */
4793 bptr->skb = priv->rx_skb;
4796 /* it from the middle of a new chain ->
4797 delete the old entry and skip the new one */
4798 at76_dbg(DBG_RX_FRAGS,
4799 "%s: middle of new seq %d (%d) "
4800 "removing old seq %d",
4801 priv->netdev->name, seqnr, fragnr,
4803 dev_kfree_skb(bptr->skb);
4809 /* if we didn't find a chain for the sender address, optr
4810 points either to the first free or the oldest entry */
4813 /* this is not the begin of a fragment chain ... */
4814 at76_dbg(DBG_RX_FRAGS,
4815 "%s: no chain for non-first fragment (%d)",
4816 priv->netdev->name, fragnr);
4822 /* swap the skb's */
4824 optr->skb = priv->rx_skb;
4827 at76_dbg(DBG_RX_FRAGS,
4828 "%s: free old contents: sender %s seq/frag %d/%d",
4829 priv->netdev->name, mac2str(optr->sender),
4830 optr->seqnr, optr->fragnr);
4833 /* take the skb from priv->rx_skb */
4834 optr->skb = priv->rx_skb;
4835 /* let at76_submit_rx_urb() allocate a new skb */
4836 priv->rx_skb = NULL;
4838 at76_dbg(DBG_RX_FRAGS, "%s: use a free entry",
4839 priv->netdev->name);
4841 memcpy(optr->sender, i802_11_hdr->addr2, ETH_ALEN);
4842 optr->seqnr = seqnr;
4844 optr->last_rx = jiffies;
4849 /* Rx interrupt: we expect the complete data buffer in priv->rx_skb */
4850 static void at76_rx_data(struct at76_priv *priv)
4852 struct net_device *netdev = priv->netdev;
4853 struct net_device_stats *stats = &priv->stats;
4854 struct sk_buff *skb = priv->rx_skb;
4855 struct at76_rx_buffer *buf = (struct at76_rx_buffer *)skb->data;
4856 struct ieee80211_hdr_3addr *i802_11_hdr;
4857 int length = le16_to_cpu(buf->wlength);
4859 at76_dbg(DBG_RX_DATA, "%s received data packet: %s", netdev->name,
4860 hex2str(skb->data, AT76_RX_HDRLEN));
4862 at76_dbg(DBG_RX_DATA_CONTENT, "rx packet: %s",
4863 hex2str(skb->data + AT76_RX_HDRLEN, length));
4865 skb = at76_check_for_rx_frags(priv);
4869 /* Atmel header and the FCS are already removed */
4870 i802_11_hdr = (struct ieee80211_hdr_3addr *)skb->data;
4873 skb->ip_summed = CHECKSUM_NONE; /* TODO: should check CRC */
4875 if (is_broadcast_ether_addr(i802_11_hdr->addr1)) {
4876 if (!compare_ether_addr(i802_11_hdr->addr1, netdev->broadcast))
4877 skb->pkt_type = PACKET_BROADCAST;
4879 skb->pkt_type = PACKET_MULTICAST;
4880 } else if (compare_ether_addr(i802_11_hdr->addr1, netdev->dev_addr))
4881 skb->pkt_type = PACKET_OTHERHOST;
4883 at76_ieee80211_to_eth(skb, priv->iw_mode);
4885 netdev->last_rx = jiffies;
4887 stats->rx_packets++;
4888 stats->rx_bytes += length;
4893 static void at76_rx_monitor_mode(struct at76_priv *priv)
4895 struct at76_rx_radiotap *rt;
4898 struct net_device *netdev = priv->netdev;
4899 struct at76_rx_buffer *buf =
4900 (struct at76_rx_buffer *)priv->rx_skb->data;
4901 /* length including the IEEE802.11 header and the trailing FCS,
4902 but not at76_rx_buffer */
4903 int length = le16_to_cpu(buf->wlength);
4904 struct sk_buff *skb = priv->rx_skb;
4905 struct net_device_stats *stats = &priv->stats;
4907 if (length < IEEE80211_FCS_LEN) {
4908 /* buffer contains no data */
4909 at76_dbg(DBG_MONITOR_MODE,
4910 "%s: MONITOR MODE: rx skb without data",
4911 priv->netdev->name);
4915 skblen = sizeof(struct at76_rx_radiotap) + length;
4917 skb = dev_alloc_skb(skblen);
4919 printk(KERN_ERR "%s: MONITOR MODE: dev_alloc_skb for radiotap "
4920 "header returned NULL\n", priv->netdev->name);
4924 skb_put(skb, skblen);
4926 rt = (struct at76_rx_radiotap *)skb->data;
4927 payload = skb->data + sizeof(struct at76_rx_radiotap);
4929 rt->rt_hdr.it_version = 0;
4930 rt->rt_hdr.it_pad = 0;
4931 rt->rt_hdr.it_len = cpu_to_le16(sizeof(struct at76_rx_radiotap));
4932 rt->rt_hdr.it_present = cpu_to_le32(AT76_RX_RADIOTAP_PRESENT);
4934 rt->rt_tsft = cpu_to_le64(le32_to_cpu(buf->rx_time));
4935 rt->rt_rate = hw_rates[buf->rx_rate] & (~0x80);
4936 rt->rt_signal = buf->rssi;
4937 rt->rt_noise = buf->noise_level;
4938 rt->rt_flags = IEEE80211_RADIOTAP_F_FCS;
4939 if (buf->fragmentation)
4940 rt->rt_flags |= IEEE80211_RADIOTAP_F_FRAG;
4942 memcpy(payload, buf->packet, length);
4944 skb->ip_summed = CHECKSUM_NONE;
4945 skb_reset_mac_header(skb);
4946 skb->pkt_type = PACKET_OTHERHOST;
4947 skb->protocol = htons(ETH_P_802_2);
4949 netdev->last_rx = jiffies;
4951 stats->rx_packets++;
4952 stats->rx_bytes += length;
4955 /* Check if we spy on the sender address in buf and update stats */
4956 static void at76_iwspy_update(struct at76_priv *priv,
4957 struct at76_rx_buffer *buf)
4959 struct ieee80211_hdr_3addr *hdr =
4960 (struct ieee80211_hdr_3addr *)buf->packet;
4961 struct iw_quality qual;
4963 /* We can only set the level here */
4964 qual.updated = IW_QUAL_QUAL_INVALID | IW_QUAL_NOISE_INVALID;
4967 at76_calc_level(priv, buf, &qual);
4969 spin_lock_bh(&priv->spy_spinlock);
4971 if (priv->spy_data.spy_number > 0)
4972 wireless_spy_update(priv->netdev, hdr->addr2, &qual);
4974 spin_unlock_bh(&priv->spy_spinlock);
4977 static void at76_rx_tasklet(unsigned long param)
4979 struct urb *urb = (struct urb *)param;
4980 struct at76_priv *priv = urb->context;
4981 struct net_device *netdev = priv->netdev;
4982 struct at76_rx_buffer *buf;
4983 struct ieee80211_hdr_3addr *i802_11_hdr;
4986 if (priv->device_unplugged) {
4987 at76_dbg(DBG_DEVSTART, "device unplugged");
4989 at76_dbg(DBG_DEVSTART, "urb status %d", urb->status);
4993 if (!priv->rx_skb || !netdev || !priv->rx_skb->data)
4996 buf = (struct at76_rx_buffer *)priv->rx_skb->data;
4998 i802_11_hdr = (struct ieee80211_hdr_3addr *)buf->packet;
5000 frame_ctl = le16_to_cpu(i802_11_hdr->frame_ctl);
5002 if (urb->status != 0) {
5003 if (urb->status != -ENOENT && urb->status != -ECONNRESET)
5005 "%s %s: - nonzero Rx bulk status received: %d",
5006 __func__, netdev->name, urb->status);
5010 at76_dbg(DBG_RX_ATMEL_HDR,
5011 "%s: rx frame: rate %d rssi %d noise %d link %d %s",
5012 priv->netdev->name, buf->rx_rate, buf->rssi, buf->noise_level,
5013 buf->link_quality, hex2str(i802_11_hdr, 48));
5014 if (priv->iw_mode == IW_MODE_MONITOR) {
5015 at76_rx_monitor_mode(priv);
5019 /* there is a new bssid around, accept it: */
5020 if (buf->newbss && priv->iw_mode == IW_MODE_ADHOC) {
5021 at76_dbg(DBG_PROGRESS, "%s: rx newbss", netdev->name);
5022 schedule_work(&priv->work_new_bss);
5025 switch (frame_ctl & IEEE80211_FCTL_FTYPE) {
5026 case IEEE80211_FTYPE_DATA:
5030 case IEEE80211_FTYPE_MGMT:
5031 /* jal: TODO: find out if we can update iwspy also on
5032 other frames than management (might depend on the
5033 radio chip / firmware version !) */
5035 at76_iwspy_update(priv, buf);
5037 at76_rx_mgmt(priv, buf);
5040 case IEEE80211_FTYPE_CTL:
5041 at76_dbg(DBG_RX_CTRL, "%s: ignored ctrl frame: %04x",
5042 priv->netdev->name, frame_ctl);
5046 printk(KERN_DEBUG "%s: ignoring frame with framectl 0x%04x\n",
5047 priv->netdev->name, frame_ctl);
5050 at76_submit_rx_urb(priv);
5053 /* Load firmware into kernel memory and parse it */
5054 static struct fwentry *at76_load_firmware(struct usb_device *udev,
5055 enum board_type board_type)
5059 struct at76_fw_header *fwh;
5060 struct fwentry *fwe = &firmwares[board_type];
5062 mutex_lock(&fw_mutex);
5065 at76_dbg(DBG_FW, "re-using previously loaded fw");
5069 at76_dbg(DBG_FW, "downloading firmware %s", fwe->fwname);
5070 ret = request_firmware(&fwe->fw, fwe->fwname, &udev->dev);
5072 dev_printk(KERN_ERR, &udev->dev, "firmware %s not found!\n",
5074 dev_printk(KERN_ERR, &udev->dev,
5075 "you may need to download the firmware from "
5076 "http://developer.berlios.de/projects/at76c503a/");
5080 at76_dbg(DBG_FW, "got it.");
5081 fwh = (struct at76_fw_header *)(fwe->fw->data);
5083 if (fwe->fw->size <= sizeof(*fwh)) {
5084 dev_printk(KERN_ERR, &udev->dev,
5085 "firmware is too short (0x%zx)\n", fwe->fw->size);
5089 /* CRC currently not checked */
5090 fwe->board_type = le32_to_cpu(fwh->board_type);
5091 if (fwe->board_type != board_type) {
5092 dev_printk(KERN_ERR, &udev->dev,
5093 "board type mismatch, requested %u, got %u\n",
5094 board_type, fwe->board_type);
5098 fwe->fw_version.major = fwh->major;
5099 fwe->fw_version.minor = fwh->minor;
5100 fwe->fw_version.patch = fwh->patch;
5101 fwe->fw_version.build = fwh->build;
5103 str = (char *)fwh + le32_to_cpu(fwh->str_offset);
5104 fwe->intfw = (u8 *)fwh + le32_to_cpu(fwh->int_fw_offset);
5105 fwe->intfw_size = le32_to_cpu(fwh->int_fw_len);
5106 fwe->extfw = (u8 *)fwh + le32_to_cpu(fwh->ext_fw_offset);
5107 fwe->extfw_size = le32_to_cpu(fwh->ext_fw_len);
5111 dev_printk(KERN_DEBUG, &udev->dev,
5112 "using firmware %s (version %d.%d.%d-%d)\n",
5113 fwe->fwname, fwh->major, fwh->minor, fwh->patch, fwh->build);
5115 at76_dbg(DBG_DEVSTART, "board %u, int %d:%d, ext %d:%d", board_type,
5116 le32_to_cpu(fwh->int_fw_offset), le32_to_cpu(fwh->int_fw_len),
5117 le32_to_cpu(fwh->ext_fw_offset), le32_to_cpu(fwh->ext_fw_len));
5118 at76_dbg(DBG_DEVSTART, "firmware id %s", str);
5121 mutex_unlock(&fw_mutex);
5129 /* Allocate network device and initialize private data */
5130 static struct at76_priv *at76_alloc_new_device(struct usb_device *udev)
5132 struct net_device *netdev;
5133 struct at76_priv *priv;
5136 /* allocate memory for our device state and initialize it */
5137 netdev = alloc_etherdev(sizeof(struct at76_priv));
5139 dev_printk(KERN_ERR, &udev->dev, "out of memory\n");
5143 priv = netdev_priv(netdev);
5146 priv->netdev = netdev;
5148 mutex_init(&priv->mtx);
5149 INIT_WORK(&priv->work_assoc_done, at76_work_assoc_done);
5150 INIT_WORK(&priv->work_join, at76_work_join);
5151 INIT_WORK(&priv->work_new_bss, at76_work_new_bss);
5152 INIT_WORK(&priv->work_start_scan, at76_work_start_scan);
5153 INIT_WORK(&priv->work_set_promisc, at76_work_set_promisc);
5154 INIT_WORK(&priv->work_submit_rx, at76_work_submit_rx);
5155 INIT_DELAYED_WORK(&priv->dwork_restart, at76_dwork_restart);
5156 INIT_DELAYED_WORK(&priv->dwork_get_scan, at76_dwork_get_scan);
5157 INIT_DELAYED_WORK(&priv->dwork_beacon, at76_dwork_beacon);
5158 INIT_DELAYED_WORK(&priv->dwork_auth, at76_dwork_auth);
5159 INIT_DELAYED_WORK(&priv->dwork_assoc, at76_dwork_assoc);
5161 spin_lock_init(&priv->mgmt_spinlock);
5162 priv->next_mgmt_bulk = NULL;
5163 priv->mac_state = MAC_INIT;
5165 /* initialize empty BSS list */
5166 priv->curr_bss = NULL;
5167 INIT_LIST_HEAD(&priv->bss_list);
5168 spin_lock_init(&priv->bss_list_spinlock);
5170 init_timer(&priv->bss_list_timer);
5171 priv->bss_list_timer.data = (unsigned long)priv;
5172 priv->bss_list_timer.function = at76_bss_list_timeout;
5174 spin_lock_init(&priv->spy_spinlock);
5176 /* mark all rx data entries as unused */
5177 for (i = 0; i < NR_RX_DATA_BUF; i++)
5178 priv->rx_data[i].skb = NULL;
5180 priv->rx_tasklet.func = at76_rx_tasklet;
5181 priv->rx_tasklet.data = 0;
5183 priv->pm_mode = AT76_PM_OFF;
5184 priv->pm_period = 0;
5189 static int at76_alloc_urbs(struct at76_priv *priv,
5190 struct usb_interface *interface)
5192 struct usb_endpoint_descriptor *endpoint, *ep_in, *ep_out;
5195 struct usb_host_interface *iface_desc;
5197 at76_dbg(DBG_PROC_ENTRY, "%s: ENTER", __func__);
5199 at76_dbg(DBG_URB, "%s: NumEndpoints %d ", __func__,
5200 interface->altsetting[0].desc.bNumEndpoints);
5204 iface_desc = interface->cur_altsetting;
5205 for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
5206 endpoint = &iface_desc->endpoint[i].desc;
5208 at76_dbg(DBG_URB, "%s: %d. endpoint: addr 0x%x attr 0x%x",
5209 __func__, i, endpoint->bEndpointAddress,
5210 endpoint->bmAttributes);
5212 if (!ep_in && usb_endpoint_is_bulk_in(endpoint))
5215 if (!ep_out && usb_endpoint_is_bulk_out(endpoint))
5219 if (!ep_in || !ep_out) {
5220 dev_printk(KERN_ERR, &interface->dev,
5221 "bulk endpoints missing\n");
5225 priv->rx_pipe = usb_rcvbulkpipe(priv->udev, ep_in->bEndpointAddress);
5226 priv->tx_pipe = usb_sndbulkpipe(priv->udev, ep_out->bEndpointAddress);
5228 priv->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
5229 priv->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
5230 if (!priv->rx_urb || !priv->tx_urb) {
5231 dev_printk(KERN_ERR, &interface->dev, "cannot allocate URB\n");
5235 buffer_size = sizeof(struct at76_tx_buffer) + MAX_PADDING_SIZE;
5236 priv->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
5237 if (!priv->bulk_out_buffer) {
5238 dev_printk(KERN_ERR, &interface->dev,
5239 "cannot allocate output buffer\n");
5243 at76_dbg(DBG_PROC_ENTRY, "%s: EXIT", __func__);
5248 /* Register network device and initialize the hardware */
5249 static int at76_init_new_device(struct at76_priv *priv,
5250 struct usb_interface *interface)
5252 struct net_device *netdev = priv->netdev;
5255 /* set up the endpoint information */
5256 /* check out the endpoints */
5258 at76_dbg(DBG_DEVSTART, "USB interface: %d endpoints",
5259 interface->cur_altsetting->desc.bNumEndpoints);
5261 ret = at76_alloc_urbs(priv, interface);
5266 ret = at76_get_hw_config(priv);
5268 dev_printk(KERN_ERR, &interface->dev,
5269 "cannot get MAC address\n");
5273 priv->domain = at76_get_reg_domain(priv->regulatory_domain);
5274 /* init. netdev->dev_addr */
5275 memcpy(netdev->dev_addr, priv->mac_addr, ETH_ALEN);
5277 priv->channel = DEF_CHANNEL;
5278 priv->iw_mode = IW_MODE_INFRA;
5279 priv->rts_threshold = DEF_RTS_THRESHOLD;
5280 priv->frag_threshold = DEF_FRAG_THRESHOLD;
5281 priv->short_retry_limit = DEF_SHORT_RETRY_LIMIT;
5282 priv->txrate = TX_RATE_AUTO;
5283 priv->preamble_type = PREAMBLE_TYPE_LONG;
5284 priv->beacon_period = 100;
5285 priv->beacons_last_qual = jiffies;
5286 priv->auth_mode = WLAN_AUTH_OPEN;
5287 priv->scan_min_time = DEF_SCAN_MIN_TIME;
5288 priv->scan_max_time = DEF_SCAN_MAX_TIME;
5289 priv->scan_mode = SCAN_TYPE_ACTIVE;
5291 netdev->flags &= ~IFF_MULTICAST; /* not yet or never */
5292 netdev->open = at76_open;
5293 netdev->stop = at76_stop;
5294 netdev->get_stats = at76_get_stats;
5295 netdev->ethtool_ops = &at76_ethtool_ops;
5297 /* Add pointers to enable iwspy support. */
5298 priv->wireless_data.spy_data = &priv->spy_data;
5299 netdev->wireless_data = &priv->wireless_data;
5301 netdev->hard_start_xmit = at76_tx;
5302 netdev->tx_timeout = at76_tx_timeout;
5303 netdev->watchdog_timeo = 2 * HZ;
5304 netdev->wireless_handlers = &at76_handler_def;
5305 netdev->set_multicast_list = at76_set_multicast;
5306 netdev->set_mac_address = at76_set_mac_address;
5307 dev_alloc_name(netdev, "wlan%d");
5309 ret = register_netdev(priv->netdev);
5311 dev_printk(KERN_ERR, &interface->dev,
5312 "cannot register netdevice (status %d)!\n", ret);
5315 priv->netdev_registered = 1;
5317 printk(KERN_INFO "%s: USB %s, MAC %s, firmware %d.%d.%d-%d\n",
5318 netdev->name, interface->dev.bus_id, mac2str(priv->mac_addr),
5319 priv->fw_version.major, priv->fw_version.minor,
5320 priv->fw_version.patch, priv->fw_version.build);
5321 printk(KERN_INFO "%s: regulatory domain 0x%02x: %s\n", netdev->name,
5322 priv->regulatory_domain, priv->domain->name);
5324 /* we let this timer run the whole time this driver instance lives */
5325 mod_timer(&priv->bss_list_timer, jiffies + BSS_LIST_TIMEOUT);
5331 static void at76_delete_device(struct at76_priv *priv)
5335 at76_dbg(DBG_PROC_ENTRY, "%s: ENTER", __func__);
5337 /* The device is gone, don't bother turning it off */
5338 priv->device_unplugged = 1;
5340 if (priv->netdev_registered)
5341 unregister_netdev(priv->netdev);
5343 /* assuming we used keventd, it must quiesce too */
5344 flush_scheduled_work();
5346 kfree(priv->bulk_out_buffer);
5349 usb_kill_urb(priv->tx_urb);
5350 usb_free_urb(priv->tx_urb);
5353 usb_kill_urb(priv->rx_urb);
5354 usb_free_urb(priv->rx_urb);
5357 at76_dbg(DBG_PROC_ENTRY, "%s: unlinked urbs", __func__);
5360 kfree_skb(priv->rx_skb);
5362 at76_free_bss_list(priv);
5363 del_timer_sync(&priv->bss_list_timer);
5364 cancel_delayed_work(&priv->dwork_get_scan);
5365 cancel_delayed_work(&priv->dwork_beacon);
5366 cancel_delayed_work(&priv->dwork_auth);
5367 cancel_delayed_work(&priv->dwork_assoc);
5369 if (priv->mac_state == MAC_CONNECTED)
5370 at76_iwevent_bss_disconnect(priv->netdev);
5372 for (i = 0; i < NR_RX_DATA_BUF; i++)
5373 if (priv->rx_data[i].skb) {
5374 dev_kfree_skb(priv->rx_data[i].skb);
5375 priv->rx_data[i].skb = NULL;
5377 usb_put_dev(priv->udev);
5379 at76_dbg(DBG_PROC_ENTRY, "%s: before freeing priv/netdev", __func__);
5380 free_netdev(priv->netdev); /* priv is in netdev */
5382 at76_dbg(DBG_PROC_ENTRY, "%s: EXIT", __func__);
5385 static int at76_probe(struct usb_interface *interface,
5386 const struct usb_device_id *id)
5389 struct at76_priv *priv;
5390 struct fwentry *fwe;
5391 struct usb_device *udev;
5393 int need_ext_fw = 0;
5394 struct mib_fw_version fwv;
5395 int board_type = (int)id->driver_info;
5397 udev = usb_get_dev(interface_to_usbdev(interface));
5399 /* Load firmware into kernel memory */
5400 fwe = at76_load_firmware(udev, board_type);
5406 op_mode = at76_get_op_mode(udev);
5408 at76_dbg(DBG_DEVSTART, "opmode %d", op_mode);
5410 /* we get OPMODE_NONE with 2.4.23, SMC2662W-AR ???
5411 we get 204 with 2.4.23, Fiberline FL-WL240u (505A+RFMD2958) ??? */
5413 if (op_mode == OPMODE_HW_CONFIG_MODE) {
5414 dev_printk(KERN_ERR, &interface->dev,
5415 "cannot handle a device in HW_CONFIG_MODE\n");
5420 if (op_mode != OPMODE_NORMAL_NIC_WITH_FLASH
5421 && op_mode != OPMODE_NORMAL_NIC_WITHOUT_FLASH) {
5422 /* download internal firmware part */
5423 dev_printk(KERN_DEBUG, &interface->dev,
5424 "downloading internal firmware\n");
5425 ret = at76_load_internal_fw(udev, fwe);
5427 dev_printk(KERN_ERR, &interface->dev,
5428 "error %d downloading internal firmware\n",
5436 /* Internal firmware already inside the device. Get firmware
5437 * version to test if external firmware is loaded.
5438 * This works only for newer firmware, e.g. the Intersil 0.90.x
5439 * says "control timeout on ep0in" and subsequent
5440 * at76_get_op_mode() fail too :-( */
5442 /* if version >= 0.100.x.y or device with built-in flash we can
5443 * query the device for the fw version */
5444 if ((fwe->fw_version.major > 0 || fwe->fw_version.minor >= 100)
5445 || (op_mode == OPMODE_NORMAL_NIC_WITH_FLASH)) {
5446 ret = at76_get_mib(udev, MIB_FW_VERSION, &fwv, sizeof(fwv));
5447 if (ret < 0 || (fwv.major | fwv.minor) == 0)
5450 /* No way to check firmware version, reload to be sure */
5454 dev_printk(KERN_DEBUG, &interface->dev,
5455 "downloading external firmware\n");
5457 ret = at76_load_external_fw(udev, fwe);
5461 /* Re-check firmware version */
5462 ret = at76_get_mib(udev, MIB_FW_VERSION, &fwv, sizeof(fwv));
5464 dev_printk(KERN_ERR, &interface->dev,
5465 "error %d getting firmware version\n", ret);
5470 priv = at76_alloc_new_device(udev);
5476 SET_NETDEV_DEV(priv->netdev, &interface->dev);
5477 usb_set_intfdata(interface, priv);
5479 memcpy(&priv->fw_version, &fwv, sizeof(struct mib_fw_version));
5480 priv->board_type = board_type;
5482 ret = at76_init_new_device(priv, interface);
5484 at76_delete_device(priv);
5493 static void at76_disconnect(struct usb_interface *interface)
5495 struct at76_priv *priv;
5497 priv = usb_get_intfdata(interface);
5498 usb_set_intfdata(interface, NULL);
5500 /* Disconnect after loading internal firmware */
5504 printk(KERN_INFO "%s: disconnecting\n", priv->netdev->name);
5505 at76_delete_device(priv);
5506 dev_printk(KERN_INFO, &interface->dev, "disconnected\n");
5509 /* Structure for registering this driver with the USB subsystem */
5510 static struct usb_driver at76_driver = {
5511 .name = DRIVER_NAME,
5512 .probe = at76_probe,
5513 .disconnect = at76_disconnect,
5514 .id_table = dev_table,
5517 static int __init at76_mod_init(void)
5521 printk(KERN_INFO DRIVER_DESC " " DRIVER_VERSION " loading\n");
5523 mutex_init(&fw_mutex);
5525 /* register this driver with the USB subsystem */
5526 result = usb_register(&at76_driver);
5528 printk(KERN_ERR DRIVER_NAME
5529 ": usb_register failed (status %d)\n", result);
5531 led_trigger_register_simple("at76_usb-tx", &ledtrig_tx);
5535 static void __exit at76_mod_exit(void)
5539 printk(KERN_INFO DRIVER_DESC " " DRIVER_VERSION " unloading\n");
5540 usb_deregister(&at76_driver);
5541 for (i = 0; i < ARRAY_SIZE(firmwares); i++) {
5542 if (firmwares[i].fw)
5543 release_firmware(firmwares[i].fw);
5545 led_trigger_unregister_simple(ledtrig_tx);
5548 module_param_named(debug, at76_debug, int, 0600);
5549 MODULE_PARM_DESC(debug, "Debugging level");
5551 module_init(at76_mod_init);
5552 module_exit(at76_mod_exit);
5554 MODULE_AUTHOR("Oliver Kurth <oku@masqmail.cx>");
5555 MODULE_AUTHOR("Joerg Albert <joerg.albert@gmx.de>");
5556 MODULE_AUTHOR("Alex <alex@foogod.com>");
5557 MODULE_AUTHOR("Nick Jones");
5558 MODULE_AUTHOR("Balint Seeber <n0_5p4m_p13453@hotmail.com>");
5559 MODULE_AUTHOR("Pavel Roskin <proski@gnu.org>");
5560 MODULE_DESCRIPTION(DRIVER_DESC);
5561 MODULE_LICENSE("GPL");