1 /*** -*- linux-c -*- **********************************************************
3 Driver for Atmel at76c502 at76c504 and at76c506 wireless cards.
5 Copyright 2000-2001 ATMEL Corporation.
6 Copyright 2003-2004 Simon Kelley.
8 This code was developed from version 2.1.1 of the Atmel drivers,
9 released by Atmel corp. under the GPL in December 2002. It also
10 includes code from the Linux aironet drivers (C) Benjamin Reed,
11 and the Linux PCMCIA package, (C) David Hinds and the Linux wireless
12 extensions, (C) Jean Tourrilhes.
14 The firmware module for reading the MAC address of the card comes from
15 net.russotto.AtmelMACFW, written by Matthew T. Russotto and copyright
16 by him. net.russotto.AtmelMACFW is used under the GPL license version 2.
17 This file contains the module in binary form and, under the terms
18 of the GPL, in source form. The source is located at the end of the file.
20 This program is free software; you can redistribute it and/or modify
21 it under the terms of the GNU General Public License as published by
22 the Free Software Foundation; either version 2 of the License, or
23 (at your option) any later version.
25 This software is distributed in the hope that it will be useful,
26 but WITHOUT ANY WARRANTY; without even the implied warranty of
27 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 GNU General Public License for more details.
30 You should have received a copy of the GNU General Public License
31 along with Atmel wireless lan drivers; if not, see
32 <http://www.gnu.org/licenses/>.
34 For all queries about this code, please contact the current author,
35 Simon Kelley <simon@thekelleys.org.uk> and not Atmel Corporation.
37 Credit is due to HP UK and Cambridge Online Systems Ltd for supplying
38 hardware used during development of this driver.
40 ******************************************************************************/
42 #include <linux/interrupt.h>
44 #include <linux/kernel.h>
45 #include <linux/ptrace.h>
46 #include <linux/slab.h>
47 #include <linux/string.h>
48 #include <linux/timer.h>
49 #include <asm/byteorder.h>
51 #include <linux/uaccess.h>
52 #include <linux/module.h>
53 #include <linux/netdevice.h>
54 #include <linux/etherdevice.h>
55 #include <linux/skbuff.h>
56 #include <linux/if_arp.h>
57 #include <linux/ioport.h>
58 #include <linux/fcntl.h>
59 #include <linux/delay.h>
60 #include <linux/wireless.h>
61 #include <net/iw_handler.h>
62 #include <linux/crc32.h>
63 #include <linux/proc_fs.h>
64 #include <linux/seq_file.h>
65 #include <linux/device.h>
66 #include <linux/moduleparam.h>
67 #include <linux/firmware.h>
68 #include <linux/jiffies.h>
69 #include <net/cfg80211.h>
72 #define DRIVER_MAJOR 0
73 #define DRIVER_MINOR 98
75 MODULE_AUTHOR("Simon Kelley");
76 MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.");
77 MODULE_LICENSE("GPL");
79 /* The name of the firmware file to be loaded
80 over-rides any automatic selection */
81 static char *firmware = NULL;
82 module_param(firmware, charp, 0);
84 /* table of firmware file names */
88 const char *fw_file_ext;
90 { ATMEL_FW_TYPE_502, "/*(DEBLOBBED)*/", "bin" },
91 { ATMEL_FW_TYPE_502D, "/*(DEBLOBBED)*/", "bin" },
92 { ATMEL_FW_TYPE_502E, "/*(DEBLOBBED)*/", "bin" },
93 { ATMEL_FW_TYPE_502_3COM, "/*(DEBLOBBED)*/", "bin" },
94 { ATMEL_FW_TYPE_504, "/*(DEBLOBBED)*/", "bin" },
95 { ATMEL_FW_TYPE_504_2958, "/*(DEBLOBBED)*/", "bin" },
96 { ATMEL_FW_TYPE_504A_2958, "/*(DEBLOBBED)*/", "bin" },
97 { ATMEL_FW_TYPE_506, "/*(DEBLOBBED)*/", "bin" },
98 { ATMEL_FW_TYPE_NONE, NULL, NULL }
102 #define MAX_SSID_LENGTH 32
103 #define MGMT_JIFFIES (256 * HZ / 100)
105 #define MAX_BSS_ENTRIES 64
108 #define GCR 0x00 /* (SIR0) General Configuration Register */
109 #define BSR 0x02 /* (SIR1) Bank Switching Select Register */
112 #define MR1 0x12 /* Mirror Register 1 */
113 #define MR2 0x14 /* Mirror Register 2 */
114 #define MR3 0x16 /* Mirror Register 3 */
115 #define MR4 0x18 /* Mirror Register 4 */
121 * Constants for the GCR register.
123 #define GCR_REMAP 0x0400 /* Remap internal SRAM to 0 */
124 #define GCR_SWRES 0x0080 /* BIU reset (ARM and PAI are NOT reset) */
125 #define GCR_CORES 0x0060 /* Core Reset (ARM and PAI are reset) */
126 #define GCR_ENINT 0x0002 /* Enable Interrupts */
127 #define GCR_ACKINT 0x0008 /* Acknowledge Interrupts */
129 #define BSS_SRAM 0x0200 /* AMBA module selection --> SRAM */
130 #define BSS_IRAM 0x0100 /* AMBA module selection --> IRAM */
132 *Constants for the MR registers.
134 #define MAC_INIT_COMPLETE 0x0001 /* MAC init has been completed */
135 #define MAC_BOOT_COMPLETE 0x0010 /* MAC boot has been completed */
136 #define MAC_INIT_OK 0x0002 /* MAC boot has been completed */
138 #define MIB_MAX_DATA_BYTES 212
139 #define MIB_HEADER_SIZE 4 /* first four fields */
146 u8 data[MIB_MAX_DATA_BYTES];
164 #define RX_DESC_FLAG_VALID 0x80
165 #define RX_DESC_FLAG_CONSUMED 0x40
166 #define RX_DESC_FLAG_IDLE 0x00
168 #define RX_STATUS_SUCCESS 0x00
170 #define RX_DESC_MSDU_POS_OFFSET 4
171 #define RX_DESC_MSDU_SIZE_OFFSET 6
172 #define RX_DESC_FLAGS_OFFSET 8
173 #define RX_DESC_STATUS_OFFSET 9
174 #define RX_DESC_RSSI_OFFSET 11
175 #define RX_DESC_LINK_QUALITY_OFFSET 12
176 #define RX_DESC_PREAMBLE_TYPE_OFFSET 13
177 #define RX_DESC_DURATION_OFFSET 14
178 #define RX_DESC_RX_TIME_OFFSET 16
201 #define TX_DESC_NEXT_OFFSET 0
202 #define TX_DESC_POS_OFFSET 4
203 #define TX_DESC_SIZE_OFFSET 6
204 #define TX_DESC_FLAGS_OFFSET 8
205 #define TX_DESC_STATUS_OFFSET 9
206 #define TX_DESC_RETRY_OFFSET 10
207 #define TX_DESC_RATE_OFFSET 11
208 #define TX_DESC_KEY_INDEX_OFFSET 12
209 #define TX_DESC_CIPHER_TYPE_OFFSET 13
210 #define TX_DESC_CIPHER_LENGTH_OFFSET 14
211 #define TX_DESC_PACKET_TYPE_OFFSET 17
212 #define TX_DESC_HOST_LENGTH_OFFSET 18
218 #define TX_STATUS_SUCCESS 0x00
220 #define TX_FIRM_OWN 0x80
223 #define TX_ERROR 0x01
225 #define TX_PACKET_TYPE_DATA 0x01
226 #define TX_PACKET_TYPE_MGMT 0x02
228 #define ISR_EMPTY 0x00 /* no bits set in ISR */
229 #define ISR_TxCOMPLETE 0x01 /* packet transmitted */
230 #define ISR_RxCOMPLETE 0x02 /* packet received */
231 #define ISR_RxFRAMELOST 0x04 /* Rx Frame lost */
232 #define ISR_FATAL_ERROR 0x08 /* Fatal error */
233 #define ISR_COMMAND_COMPLETE 0x10 /* command completed */
234 #define ISR_OUT_OF_RANGE 0x20 /* command completed */
235 #define ISR_IBSS_MERGE 0x40 /* (4.1.2.30): IBSS merge */
236 #define ISR_GENERIC_IRQ 0x80
238 #define Local_Mib_Type 0x01
239 #define Mac_Address_Mib_Type 0x02
240 #define Mac_Mib_Type 0x03
241 #define Statistics_Mib_Type 0x04
242 #define Mac_Mgmt_Mib_Type 0x05
243 #define Mac_Wep_Mib_Type 0x06
244 #define Phy_Mib_Type 0x07
245 #define Multi_Domain_MIB 0x08
247 #define MAC_MGMT_MIB_CUR_BSSID_POS 14
248 #define MAC_MIB_FRAG_THRESHOLD_POS 8
249 #define MAC_MIB_RTS_THRESHOLD_POS 10
250 #define MAC_MIB_SHORT_RETRY_POS 16
251 #define MAC_MIB_LONG_RETRY_POS 17
252 #define MAC_MIB_SHORT_RETRY_LIMIT_POS 16
253 #define MAC_MGMT_MIB_BEACON_PER_POS 0
254 #define MAC_MGMT_MIB_STATION_ID_POS 6
255 #define MAC_MGMT_MIB_CUR_PRIVACY_POS 11
256 #define MAC_MGMT_MIB_CUR_BSSID_POS 14
257 #define MAC_MGMT_MIB_PS_MODE_POS 53
258 #define MAC_MGMT_MIB_LISTEN_INTERVAL_POS 54
259 #define MAC_MGMT_MIB_MULTI_DOMAIN_IMPLEMENTED 56
260 #define MAC_MGMT_MIB_MULTI_DOMAIN_ENABLED 57
261 #define PHY_MIB_CHANNEL_POS 14
262 #define PHY_MIB_RATE_SET_POS 20
263 #define PHY_MIB_REG_DOMAIN_POS 26
264 #define LOCAL_MIB_AUTO_TX_RATE_POS 3
265 #define LOCAL_MIB_SSID_SIZE 5
266 #define LOCAL_MIB_TX_PROMISCUOUS_POS 6
267 #define LOCAL_MIB_TX_MGMT_RATE_POS 7
268 #define LOCAL_MIB_TX_CONTROL_RATE_POS 8
269 #define LOCAL_MIB_PREAMBLE_TYPE 9
270 #define MAC_ADDR_MIB_MAC_ADDR_POS 0
272 #define CMD_Set_MIB_Vars 0x01
273 #define CMD_Get_MIB_Vars 0x02
274 #define CMD_Scan 0x03
275 #define CMD_Join 0x04
276 #define CMD_Start 0x05
277 #define CMD_EnableRadio 0x06
278 #define CMD_DisableRadio 0x07
279 #define CMD_SiteSurvey 0x0B
281 #define CMD_STATUS_IDLE 0x00
282 #define CMD_STATUS_COMPLETE 0x01
283 #define CMD_STATUS_UNKNOWN 0x02
284 #define CMD_STATUS_INVALID_PARAMETER 0x03
285 #define CMD_STATUS_FUNCTION_NOT_SUPPORTED 0x04
286 #define CMD_STATUS_TIME_OUT 0x07
287 #define CMD_STATUS_IN_PROGRESS 0x08
288 #define CMD_STATUS_REJECTED_RADIO_OFF 0x09
289 #define CMD_STATUS_HOST_ERROR 0xFF
290 #define CMD_STATUS_BUSY 0xFE
292 #define CMD_BLOCK_COMMAND_OFFSET 0
293 #define CMD_BLOCK_STATUS_OFFSET 1
294 #define CMD_BLOCK_PARAMETERS_OFFSET 4
296 #define SCAN_OPTIONS_SITE_SURVEY 0x80
298 #define MGMT_FRAME_BODY_OFFSET 24
299 #define MAX_AUTHENTICATION_RETRIES 3
300 #define MAX_ASSOCIATION_RETRIES 3
302 #define AUTHENTICATION_RESPONSE_TIME_OUT 1000
304 #define MAX_WIRELESS_BODY 2316 /* mtu is 2312, CRC is 4 */
305 #define LOOP_RETRY_LIMIT 500000
307 #define ACTIVE_MODE 1
310 #define MAX_ENCRYPTION_KEYS 4
311 #define MAX_ENCRYPTION_KEY_SIZE 40
314 * 802.11 related definitions
321 #define REG_DOMAIN_FCC 0x10 /* Channels 1-11 USA */
322 #define REG_DOMAIN_DOC 0x20 /* Channel 1-11 Canada */
323 #define REG_DOMAIN_ETSI 0x30 /* Channel 1-13 Europe (ex Spain/France) */
324 #define REG_DOMAIN_SPAIN 0x31 /* Channel 10-11 Spain */
325 #define REG_DOMAIN_FRANCE 0x32 /* Channel 10-13 France */
326 #define REG_DOMAIN_MKK 0x40 /* Channel 14 Japan */
327 #define REG_DOMAIN_MKK1 0x41 /* Channel 1-14 Japan(MKK1) */
328 #define REG_DOMAIN_ISRAEL 0x50 /* Channel 3-9 ISRAEL */
330 #define BSS_TYPE_AD_HOC 1
331 #define BSS_TYPE_INFRASTRUCTURE 2
333 #define SCAN_TYPE_ACTIVE 0
334 #define SCAN_TYPE_PASSIVE 1
336 #define LONG_PREAMBLE 0
337 #define SHORT_PREAMBLE 1
338 #define AUTO_PREAMBLE 2
340 #define DATA_FRAME_WS_HEADER_SIZE 30
342 /* promiscuous mode control */
343 #define PROM_MODE_OFF 0x0
344 #define PROM_MODE_UNKNOWN 0x1
345 #define PROM_MODE_CRC_FAILED 0x2
346 #define PROM_MODE_DUPLICATED 0x4
347 #define PROM_MODE_MGMT 0x8
348 #define PROM_MODE_CTRL 0x10
349 #define PROM_MODE_BAD_PROTOCOL 0x20
351 #define IFACE_INT_STATUS_OFFSET 0
352 #define IFACE_INT_MASK_OFFSET 1
353 #define IFACE_LOCKOUT_HOST_OFFSET 2
354 #define IFACE_LOCKOUT_MAC_OFFSET 3
355 #define IFACE_FUNC_CTRL_OFFSET 28
356 #define IFACE_MAC_STAT_OFFSET 30
357 #define IFACE_GENERIC_INT_TYPE_OFFSET 32
359 #define CIPHER_SUITE_NONE 0
360 #define CIPHER_SUITE_WEP_64 1
361 #define CIPHER_SUITE_TKIP 2
362 #define CIPHER_SUITE_AES 3
363 #define CIPHER_SUITE_CCX 4
364 #define CIPHER_SUITE_WEP_128 5
367 * IFACE MACROS & definitions
373 #define FUNC_CTRL_TxENABLE 0x10
374 #define FUNC_CTRL_RxENABLE 0x20
375 #define FUNC_CTRL_INIT_COMPLETE 0x01
377 /* A stub firmware image which reads the MAC address from NVRAM on the card.
378 For copyright information and source see the end of this file. */
379 static u8 mac_reader[] = {
380 0x06, 0x00, 0x00, 0xea, 0x04, 0x00, 0x00, 0xea, 0x03, 0x00, 0x00, 0xea, 0x02, 0x00, 0x00, 0xea,
381 0x01, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00, 0xea, 0xff, 0xff, 0xff, 0xea, 0xfe, 0xff, 0xff, 0xea,
382 0xd3, 0x00, 0xa0, 0xe3, 0x00, 0xf0, 0x21, 0xe1, 0x0e, 0x04, 0xa0, 0xe3, 0x00, 0x10, 0xa0, 0xe3,
383 0x81, 0x11, 0xa0, 0xe1, 0x00, 0x10, 0x81, 0xe3, 0x00, 0x10, 0x80, 0xe5, 0x1c, 0x10, 0x90, 0xe5,
384 0x10, 0x10, 0xc1, 0xe3, 0x1c, 0x10, 0x80, 0xe5, 0x01, 0x10, 0xa0, 0xe3, 0x08, 0x10, 0x80, 0xe5,
385 0x02, 0x03, 0xa0, 0xe3, 0x00, 0x10, 0xa0, 0xe3, 0xb0, 0x10, 0xc0, 0xe1, 0xb4, 0x10, 0xc0, 0xe1,
386 0xb8, 0x10, 0xc0, 0xe1, 0xbc, 0x10, 0xc0, 0xe1, 0x56, 0xdc, 0xa0, 0xe3, 0x21, 0x00, 0x00, 0xeb,
387 0x0a, 0x00, 0xa0, 0xe3, 0x1a, 0x00, 0x00, 0xeb, 0x10, 0x00, 0x00, 0xeb, 0x07, 0x00, 0x00, 0xeb,
388 0x02, 0x03, 0xa0, 0xe3, 0x02, 0x14, 0xa0, 0xe3, 0xb4, 0x10, 0xc0, 0xe1, 0x4c, 0x10, 0x9f, 0xe5,
389 0xbc, 0x10, 0xc0, 0xe1, 0x10, 0x10, 0xa0, 0xe3, 0xb8, 0x10, 0xc0, 0xe1, 0xfe, 0xff, 0xff, 0xea,
390 0x00, 0x40, 0x2d, 0xe9, 0x00, 0x20, 0xa0, 0xe3, 0x02, 0x3c, 0xa0, 0xe3, 0x00, 0x10, 0xa0, 0xe3,
391 0x28, 0x00, 0x9f, 0xe5, 0x37, 0x00, 0x00, 0xeb, 0x00, 0x40, 0xbd, 0xe8, 0x1e, 0xff, 0x2f, 0xe1,
392 0x00, 0x40, 0x2d, 0xe9, 0x12, 0x2e, 0xa0, 0xe3, 0x06, 0x30, 0xa0, 0xe3, 0x00, 0x10, 0xa0, 0xe3,
393 0x02, 0x04, 0xa0, 0xe3, 0x2f, 0x00, 0x00, 0xeb, 0x00, 0x40, 0xbd, 0xe8, 0x1e, 0xff, 0x2f, 0xe1,
394 0x00, 0x02, 0x00, 0x02, 0x80, 0x01, 0x90, 0xe0, 0x01, 0x00, 0x00, 0x0a, 0x01, 0x00, 0x50, 0xe2,
395 0xfc, 0xff, 0xff, 0xea, 0x1e, 0xff, 0x2f, 0xe1, 0x80, 0x10, 0xa0, 0xe3, 0xf3, 0x06, 0xa0, 0xe3,
396 0x00, 0x10, 0x80, 0xe5, 0x00, 0x10, 0xa0, 0xe3, 0x00, 0x10, 0x80, 0xe5, 0x01, 0x10, 0xa0, 0xe3,
397 0x04, 0x10, 0x80, 0xe5, 0x00, 0x10, 0x80, 0xe5, 0x0e, 0x34, 0xa0, 0xe3, 0x1c, 0x10, 0x93, 0xe5,
398 0x02, 0x1a, 0x81, 0xe3, 0x1c, 0x10, 0x83, 0xe5, 0x58, 0x11, 0x9f, 0xe5, 0x30, 0x10, 0x80, 0xe5,
399 0x54, 0x11, 0x9f, 0xe5, 0x34, 0x10, 0x80, 0xe5, 0x38, 0x10, 0x80, 0xe5, 0x3c, 0x10, 0x80, 0xe5,
400 0x10, 0x10, 0x90, 0xe5, 0x08, 0x00, 0x90, 0xe5, 0x1e, 0xff, 0x2f, 0xe1, 0xf3, 0x16, 0xa0, 0xe3,
401 0x08, 0x00, 0x91, 0xe5, 0x05, 0x00, 0xa0, 0xe3, 0x0c, 0x00, 0x81, 0xe5, 0x10, 0x00, 0x91, 0xe5,
402 0x02, 0x00, 0x10, 0xe3, 0xfc, 0xff, 0xff, 0x0a, 0xff, 0x00, 0xa0, 0xe3, 0x0c, 0x00, 0x81, 0xe5,
403 0x10, 0x00, 0x91, 0xe5, 0x02, 0x00, 0x10, 0xe3, 0xfc, 0xff, 0xff, 0x0a, 0x08, 0x00, 0x91, 0xe5,
404 0x10, 0x00, 0x91, 0xe5, 0x01, 0x00, 0x10, 0xe3, 0xfc, 0xff, 0xff, 0x0a, 0x08, 0x00, 0x91, 0xe5,
405 0xff, 0x00, 0x00, 0xe2, 0x1e, 0xff, 0x2f, 0xe1, 0x30, 0x40, 0x2d, 0xe9, 0x00, 0x50, 0xa0, 0xe1,
406 0x03, 0x40, 0xa0, 0xe1, 0xa2, 0x02, 0xa0, 0xe1, 0x08, 0x00, 0x00, 0xe2, 0x03, 0x00, 0x80, 0xe2,
407 0xd8, 0x10, 0x9f, 0xe5, 0x00, 0x00, 0xc1, 0xe5, 0x01, 0x20, 0xc1, 0xe5, 0xe2, 0xff, 0xff, 0xeb,
408 0x01, 0x00, 0x10, 0xe3, 0xfc, 0xff, 0xff, 0x1a, 0x14, 0x00, 0xa0, 0xe3, 0xc4, 0xff, 0xff, 0xeb,
409 0x04, 0x20, 0xa0, 0xe1, 0x05, 0x10, 0xa0, 0xe1, 0x02, 0x00, 0xa0, 0xe3, 0x01, 0x00, 0x00, 0xeb,
410 0x30, 0x40, 0xbd, 0xe8, 0x1e, 0xff, 0x2f, 0xe1, 0x70, 0x40, 0x2d, 0xe9, 0xf3, 0x46, 0xa0, 0xe3,
411 0x00, 0x30, 0xa0, 0xe3, 0x00, 0x00, 0x50, 0xe3, 0x08, 0x00, 0x00, 0x9a, 0x8c, 0x50, 0x9f, 0xe5,
412 0x03, 0x60, 0xd5, 0xe7, 0x0c, 0x60, 0x84, 0xe5, 0x10, 0x60, 0x94, 0xe5, 0x02, 0x00, 0x16, 0xe3,
413 0xfc, 0xff, 0xff, 0x0a, 0x01, 0x30, 0x83, 0xe2, 0x00, 0x00, 0x53, 0xe1, 0xf7, 0xff, 0xff, 0x3a,
414 0xff, 0x30, 0xa0, 0xe3, 0x0c, 0x30, 0x84, 0xe5, 0x08, 0x00, 0x94, 0xe5, 0x10, 0x00, 0x94, 0xe5,
415 0x01, 0x00, 0x10, 0xe3, 0xfc, 0xff, 0xff, 0x0a, 0x08, 0x00, 0x94, 0xe5, 0x00, 0x00, 0xa0, 0xe3,
416 0x00, 0x00, 0x52, 0xe3, 0x0b, 0x00, 0x00, 0x9a, 0x10, 0x50, 0x94, 0xe5, 0x02, 0x00, 0x15, 0xe3,
417 0xfc, 0xff, 0xff, 0x0a, 0x0c, 0x30, 0x84, 0xe5, 0x10, 0x50, 0x94, 0xe5, 0x01, 0x00, 0x15, 0xe3,
418 0xfc, 0xff, 0xff, 0x0a, 0x08, 0x50, 0x94, 0xe5, 0x01, 0x50, 0xc1, 0xe4, 0x01, 0x00, 0x80, 0xe2,
419 0x02, 0x00, 0x50, 0xe1, 0xf3, 0xff, 0xff, 0x3a, 0xc8, 0x00, 0xa0, 0xe3, 0x98, 0xff, 0xff, 0xeb,
420 0x70, 0x40, 0xbd, 0xe8, 0x1e, 0xff, 0x2f, 0xe1, 0x01, 0x0c, 0x00, 0x02, 0x01, 0x02, 0x00, 0x02,
421 0x00, 0x01, 0x00, 0x02
424 struct atmel_private {
425 void *card; /* Bus dependent structure varies for PCcard */
426 int (*present_callback)(void *); /* And callback which uses it */
427 char firmware_id[32];
428 AtmelFWType firmware_type;
431 struct timer_list management_timer;
432 struct net_device *dev;
433 struct device *sys_dev;
434 struct iw_statistics wstats;
435 spinlock_t irqlock, timerlock; /* spinlocks */
436 enum { BUS_TYPE_PCCARD, BUS_TYPE_PCI } bus_type;
438 CARD_TYPE_PARALLEL_FLASH,
442 int do_rx_crc; /* If we need to CRC incoming packets */
443 int probe_crc; /* set if we don't yet know */
444 int crc_ok_cnt, crc_ko_cnt; /* counters for probing */
446 u16 tx_desc_free, tx_desc_head, tx_desc_tail, tx_desc_previous;
447 u16 tx_free_mem, tx_buff_head, tx_buff_tail;
449 u16 frag_seq, frag_len, frag_no;
452 u8 wep_is_on, default_key, exclude_unencrypted, encryption_level;
453 u8 group_cipher_suite, pairwise_cipher_suite;
454 u8 wep_keys[MAX_ENCRYPTION_KEYS][MAX_ENCRYPTION_KEY_SIZE];
455 int wep_key_len[MAX_ENCRYPTION_KEYS];
456 int use_wpa, radio_on_broken; /* firmware dependent stuff. */
459 struct host_info_struct {
460 /* NB this is matched to the hardware, don't change. */
461 u8 volatile int_status;
462 u8 volatile int_mask;
463 u8 volatile lockout_host;
464 u8 volatile lockout_mac;
484 u16 generic_IRQ_type;
489 STATION_STATE_SCANNING,
490 STATION_STATE_JOINNING,
491 STATION_STATE_AUTHENTICATING,
492 STATION_STATE_ASSOCIATING,
494 STATION_STATE_REASSOCIATING,
496 STATION_STATE_MGMT_ERROR
499 int operating_mode, power_mode;
500 unsigned long last_qual;
501 int beacons_this_sec;
503 int reg_domain, config_reg_domain;
508 int long_retry, short_retry;
510 int default_beacon_period, beacon_period, listen_interval;
511 int CurrentAuthentTransactionSeqNum, ExpectedAuthentTransactionSeqNum;
512 int AuthenticationRequestRetryCnt, AssociationRequestRetryCnt, ReAssociationRequestRetryCnt;
515 SITE_SURVEY_IN_PROGRESS,
516 SITE_SURVEY_COMPLETED
518 unsigned long last_survey;
520 int station_was_associated, station_is_associated;
532 u8 SSID[MAX_SSID_LENGTH];
533 } BSSinfo[MAX_BSS_ENTRIES];
534 int BSS_list_entries, current_BSS;
535 int connect_to_any_BSS;
536 int SSID_size, new_SSID_size;
537 u8 CurrentBSSID[6], BSSID[6];
538 u8 SSID[MAX_SSID_LENGTH], new_SSID[MAX_SSID_LENGTH];
539 u64 last_beacon_timestamp;
540 u8 rx_buf[MAX_WIRELESS_BODY];
543 static u8 atmel_basic_rates[4] = {0x82, 0x84, 0x0b, 0x16};
545 static const struct {
549 } channel_table[] = { { REG_DOMAIN_FCC, 1, 11, "USA" },
550 { REG_DOMAIN_DOC, 1, 11, "Canada" },
551 { REG_DOMAIN_ETSI, 1, 13, "Europe" },
552 { REG_DOMAIN_SPAIN, 10, 11, "Spain" },
553 { REG_DOMAIN_FRANCE, 10, 13, "France" },
554 { REG_DOMAIN_MKK, 14, 14, "MKK" },
555 { REG_DOMAIN_MKK1, 1, 14, "MKK1" },
556 { REG_DOMAIN_ISRAEL, 3, 9, "Israel"} };
558 static void build_wpa_mib(struct atmel_private *priv);
559 static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
560 static void atmel_copy_to_card(struct net_device *dev, u16 dest,
561 const unsigned char *src, u16 len);
562 static void atmel_copy_to_host(struct net_device *dev, unsigned char *dest,
564 static void atmel_set_gcr(struct net_device *dev, u16 mask);
565 static void atmel_clear_gcr(struct net_device *dev, u16 mask);
566 static int atmel_lock_mac(struct atmel_private *priv);
567 static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data);
568 static void atmel_command_irq(struct atmel_private *priv);
569 static int atmel_validate_channel(struct atmel_private *priv, int channel);
570 static void atmel_management_frame(struct atmel_private *priv,
571 struct ieee80211_hdr *header,
572 u16 frame_len, u8 rssi);
573 static void atmel_management_timer(struct timer_list *t);
574 static void atmel_send_command(struct atmel_private *priv, int command,
575 void *cmd, int cmd_size);
576 static int atmel_send_command_wait(struct atmel_private *priv, int command,
577 void *cmd, int cmd_size);
578 static void atmel_transmit_management_frame(struct atmel_private *priv,
579 struct ieee80211_hdr *header,
580 u8 *body, int body_len);
582 static u8 atmel_get_mib8(struct atmel_private *priv, u8 type, u8 index);
583 static void atmel_set_mib8(struct atmel_private *priv, u8 type, u8 index,
585 static void atmel_set_mib16(struct atmel_private *priv, u8 type, u8 index,
587 static void atmel_set_mib(struct atmel_private *priv, u8 type, u8 index,
588 const u8 *data, int data_len);
589 static void atmel_get_mib(struct atmel_private *priv, u8 type, u8 index,
590 u8 *data, int data_len);
591 static void atmel_scan(struct atmel_private *priv, int specific_ssid);
592 static void atmel_join_bss(struct atmel_private *priv, int bss_index);
593 static void atmel_smooth_qual(struct atmel_private *priv);
594 static void atmel_writeAR(struct net_device *dev, u16 data);
595 static int probe_atmel_card(struct net_device *dev);
596 static int reset_atmel_card(struct net_device *dev);
597 static void atmel_enter_state(struct atmel_private *priv, int new_state);
598 int atmel_open (struct net_device *dev);
600 static inline u16 atmel_hi(struct atmel_private *priv, u16 offset)
602 return priv->host_info_base + offset;
605 static inline u16 atmel_co(struct atmel_private *priv, u16 offset)
607 return priv->host_info.command_pos + offset;
610 static inline u16 atmel_rx(struct atmel_private *priv, u16 offset, u16 desc)
612 return priv->host_info.rx_desc_pos + (sizeof(struct rx_desc) * desc) + offset;
615 static inline u16 atmel_tx(struct atmel_private *priv, u16 offset, u16 desc)
617 return priv->host_info.tx_desc_pos + (sizeof(struct tx_desc) * desc) + offset;
620 static inline u8 atmel_read8(struct net_device *dev, u16 offset)
622 return inb(dev->base_addr + offset);
625 static inline void atmel_write8(struct net_device *dev, u16 offset, u8 data)
627 outb(data, dev->base_addr + offset);
630 static inline u16 atmel_read16(struct net_device *dev, u16 offset)
632 return inw(dev->base_addr + offset);
635 static inline void atmel_write16(struct net_device *dev, u16 offset, u16 data)
637 outw(data, dev->base_addr + offset);
640 static inline u8 atmel_rmem8(struct atmel_private *priv, u16 pos)
642 atmel_writeAR(priv->dev, pos);
643 return atmel_read8(priv->dev, DR);
646 static inline void atmel_wmem8(struct atmel_private *priv, u16 pos, u16 data)
648 atmel_writeAR(priv->dev, pos);
649 atmel_write8(priv->dev, DR, data);
652 static inline u16 atmel_rmem16(struct atmel_private *priv, u16 pos)
654 atmel_writeAR(priv->dev, pos);
655 return atmel_read16(priv->dev, DR);
658 static inline void atmel_wmem16(struct atmel_private *priv, u16 pos, u16 data)
660 atmel_writeAR(priv->dev, pos);
661 atmel_write16(priv->dev, DR, data);
664 static const struct iw_handler_def atmel_handler_def;
666 static void tx_done_irq(struct atmel_private *priv)
671 atmel_rmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, priv->tx_desc_head)) == TX_DONE &&
672 i < priv->host_info.tx_desc_count;
674 u8 status = atmel_rmem8(priv, atmel_tx(priv, TX_DESC_STATUS_OFFSET, priv->tx_desc_head));
675 u16 msdu_size = atmel_rmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, priv->tx_desc_head));
676 u8 type = atmel_rmem8(priv, atmel_tx(priv, TX_DESC_PACKET_TYPE_OFFSET, priv->tx_desc_head));
678 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, priv->tx_desc_head), 0);
680 priv->tx_free_mem += msdu_size;
681 priv->tx_desc_free++;
683 if (priv->tx_buff_head + msdu_size > (priv->host_info.tx_buff_pos + priv->host_info.tx_buff_size))
684 priv->tx_buff_head = 0;
686 priv->tx_buff_head += msdu_size;
688 if (priv->tx_desc_head < (priv->host_info.tx_desc_count - 1))
689 priv->tx_desc_head++ ;
691 priv->tx_desc_head = 0;
693 if (type == TX_PACKET_TYPE_DATA) {
694 if (status == TX_STATUS_SUCCESS)
695 priv->dev->stats.tx_packets++;
697 priv->dev->stats.tx_errors++;
698 netif_wake_queue(priv->dev);
703 static u16 find_tx_buff(struct atmel_private *priv, u16 len)
705 u16 bottom_free = priv->host_info.tx_buff_size - priv->tx_buff_tail;
707 if (priv->tx_desc_free == 3 || priv->tx_free_mem < len)
710 if (bottom_free >= len)
711 return priv->host_info.tx_buff_pos + priv->tx_buff_tail;
713 if (priv->tx_free_mem - bottom_free >= len) {
714 priv->tx_buff_tail = 0;
715 return priv->host_info.tx_buff_pos;
721 static void tx_update_descriptor(struct atmel_private *priv, int is_bcast,
722 u16 len, u16 buff, u8 type)
724 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_POS_OFFSET, priv->tx_desc_tail), buff);
725 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, priv->tx_desc_tail), len);
727 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_HOST_LENGTH_OFFSET, priv->tx_desc_tail), len);
728 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_PACKET_TYPE_OFFSET, priv->tx_desc_tail), type);
729 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_RATE_OFFSET, priv->tx_desc_tail), priv->tx_rate);
730 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_RETRY_OFFSET, priv->tx_desc_tail), 0);
732 int cipher_type, cipher_length;
734 cipher_type = priv->group_cipher_suite;
735 if (cipher_type == CIPHER_SUITE_WEP_64 ||
736 cipher_type == CIPHER_SUITE_WEP_128)
738 else if (cipher_type == CIPHER_SUITE_TKIP)
740 else if (priv->pairwise_cipher_suite == CIPHER_SUITE_WEP_64 ||
741 priv->pairwise_cipher_suite == CIPHER_SUITE_WEP_128) {
742 cipher_type = priv->pairwise_cipher_suite;
745 cipher_type = CIPHER_SUITE_NONE;
749 cipher_type = priv->pairwise_cipher_suite;
750 if (cipher_type == CIPHER_SUITE_WEP_64 ||
751 cipher_type == CIPHER_SUITE_WEP_128)
753 else if (cipher_type == CIPHER_SUITE_TKIP)
755 else if (priv->group_cipher_suite == CIPHER_SUITE_WEP_64 ||
756 priv->group_cipher_suite == CIPHER_SUITE_WEP_128) {
757 cipher_type = priv->group_cipher_suite;
760 cipher_type = CIPHER_SUITE_NONE;
765 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_CIPHER_TYPE_OFFSET, priv->tx_desc_tail),
767 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_CIPHER_LENGTH_OFFSET, priv->tx_desc_tail),
770 atmel_wmem32(priv, atmel_tx(priv, TX_DESC_NEXT_OFFSET, priv->tx_desc_tail), 0x80000000L);
771 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, priv->tx_desc_tail), TX_FIRM_OWN);
772 if (priv->tx_desc_previous != priv->tx_desc_tail)
773 atmel_wmem32(priv, atmel_tx(priv, TX_DESC_NEXT_OFFSET, priv->tx_desc_previous), 0);
774 priv->tx_desc_previous = priv->tx_desc_tail;
775 if (priv->tx_desc_tail < (priv->host_info.tx_desc_count - 1))
776 priv->tx_desc_tail++;
778 priv->tx_desc_tail = 0;
779 priv->tx_desc_free--;
780 priv->tx_free_mem -= len;
783 static netdev_tx_t start_tx(struct sk_buff *skb, struct net_device *dev)
785 struct atmel_private *priv = netdev_priv(dev);
786 struct ieee80211_hdr header;
788 u16 buff, frame_ctl, len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
790 if (priv->card && priv->present_callback &&
791 !(*priv->present_callback)(priv->card)) {
792 dev->stats.tx_errors++;
797 if (priv->station_state != STATION_STATE_READY) {
798 dev->stats.tx_errors++;
803 /* first ensure the timer func cannot run */
804 spin_lock_bh(&priv->timerlock);
805 /* then stop the hardware ISR */
806 spin_lock_irqsave(&priv->irqlock, flags);
807 /* nb doing the above in the opposite order will deadlock */
809 /* The Wireless Header is 30 bytes. In the Ethernet packet we "cut" the
810 12 first bytes (containing DA/SA) and put them in the appropriate
811 fields of the Wireless Header. Thus the packet length is then the
812 initial + 18 (+30-12) */
814 if (!(buff = find_tx_buff(priv, len + 18))) {
815 dev->stats.tx_dropped++;
816 spin_unlock_irqrestore(&priv->irqlock, flags);
817 spin_unlock_bh(&priv->timerlock);
818 netif_stop_queue(dev);
819 return NETDEV_TX_BUSY;
822 frame_ctl = IEEE80211_FTYPE_DATA;
823 header.duration_id = 0;
826 frame_ctl |= IEEE80211_FCTL_PROTECTED;
827 if (priv->operating_mode == IW_MODE_ADHOC) {
828 skb_copy_from_linear_data(skb, &header.addr1, ETH_ALEN);
829 memcpy(&header.addr2, dev->dev_addr, ETH_ALEN);
830 memcpy(&header.addr3, priv->BSSID, ETH_ALEN);
832 frame_ctl |= IEEE80211_FCTL_TODS;
833 memcpy(&header.addr1, priv->CurrentBSSID, ETH_ALEN);
834 memcpy(&header.addr2, dev->dev_addr, ETH_ALEN);
835 skb_copy_from_linear_data(skb, &header.addr3, ETH_ALEN);
839 memcpy(&header.addr4, rfc1042_header, ETH_ALEN);
841 header.frame_control = cpu_to_le16(frame_ctl);
842 /* Copy the wireless header into the card */
843 atmel_copy_to_card(dev, buff, (unsigned char *)&header, DATA_FRAME_WS_HEADER_SIZE);
844 /* Copy the packet sans its 802.3 header addresses which have been replaced */
845 atmel_copy_to_card(dev, buff + DATA_FRAME_WS_HEADER_SIZE, skb->data + 12, len - 12);
846 priv->tx_buff_tail += len - 12 + DATA_FRAME_WS_HEADER_SIZE;
848 /* low bit of first byte of destination tells us if broadcast */
849 tx_update_descriptor(priv, *(skb->data) & 0x01, len + 18, buff, TX_PACKET_TYPE_DATA);
850 dev->stats.tx_bytes += len;
852 spin_unlock_irqrestore(&priv->irqlock, flags);
853 spin_unlock_bh(&priv->timerlock);
859 static void atmel_transmit_management_frame(struct atmel_private *priv,
860 struct ieee80211_hdr *header,
861 u8 *body, int body_len)
864 int len = MGMT_FRAME_BODY_OFFSET + body_len;
866 if (!(buff = find_tx_buff(priv, len)))
869 atmel_copy_to_card(priv->dev, buff, (u8 *)header, MGMT_FRAME_BODY_OFFSET);
870 atmel_copy_to_card(priv->dev, buff + MGMT_FRAME_BODY_OFFSET, body, body_len);
871 priv->tx_buff_tail += len;
872 tx_update_descriptor(priv, header->addr1[0] & 0x01, len, buff, TX_PACKET_TYPE_MGMT);
875 static void fast_rx_path(struct atmel_private *priv,
876 struct ieee80211_hdr *header,
877 u16 msdu_size, u16 rx_packet_loc, u32 crc)
879 /* fast path: unfragmented packet copy directly into skbuf */
884 /* get the final, mac 4 header field, this tells us encapsulation */
885 atmel_copy_to_host(priv->dev, mac4, rx_packet_loc + 24, 6);
888 if (priv->do_rx_crc) {
889 crc = crc32_le(crc, mac4, 6);
893 if (!(skb = dev_alloc_skb(msdu_size + 14))) {
894 priv->dev->stats.rx_dropped++;
899 skbp = skb_put(skb, msdu_size + 12);
900 atmel_copy_to_host(priv->dev, skbp + 12, rx_packet_loc + 30, msdu_size);
902 if (priv->do_rx_crc) {
904 crc = crc32_le(crc, skbp + 12, msdu_size);
905 atmel_copy_to_host(priv->dev, (void *)&netcrc, rx_packet_loc + 30 + msdu_size, 4);
906 if ((crc ^ 0xffffffff) != netcrc) {
907 priv->dev->stats.rx_crc_errors++;
913 memcpy(skbp, header->addr1, ETH_ALEN); /* destination address */
914 if (le16_to_cpu(header->frame_control) & IEEE80211_FCTL_FROMDS)
915 memcpy(&skbp[ETH_ALEN], header->addr3, ETH_ALEN);
917 memcpy(&skbp[ETH_ALEN], header->addr2, ETH_ALEN); /* source address */
919 skb->protocol = eth_type_trans(skb, priv->dev);
920 skb->ip_summed = CHECKSUM_NONE;
922 priv->dev->stats.rx_bytes += 12 + msdu_size;
923 priv->dev->stats.rx_packets++;
926 /* Test to see if the packet in card memory at packet_loc has a valid CRC
927 It doesn't matter that this is slow: it is only used to proble the first few
929 static int probe_crc(struct atmel_private *priv, u16 packet_loc, u16 msdu_size)
931 int i = msdu_size - 4;
932 u32 netcrc, crc = 0xffffffff;
937 atmel_copy_to_host(priv->dev, (void *)&netcrc, packet_loc + i, 4);
939 atmel_writeAR(priv->dev, packet_loc);
941 u8 octet = atmel_read8(priv->dev, DR);
942 crc = crc32_le(crc, &octet, 1);
945 return (crc ^ 0xffffffff) == netcrc;
948 static void frag_rx_path(struct atmel_private *priv,
949 struct ieee80211_hdr *header,
950 u16 msdu_size, u16 rx_packet_loc, u32 crc, u16 seq_no,
951 u8 frag_no, int more_frags)
957 if (le16_to_cpu(header->frame_control) & IEEE80211_FCTL_FROMDS)
958 memcpy(source, header->addr3, ETH_ALEN);
960 memcpy(source, header->addr2, ETH_ALEN);
962 rx_packet_loc += 24; /* skip header */
967 if (frag_no == 0) { /* first fragment */
968 atmel_copy_to_host(priv->dev, mac4, rx_packet_loc, ETH_ALEN);
969 msdu_size -= ETH_ALEN;
970 rx_packet_loc += ETH_ALEN;
973 crc = crc32_le(crc, mac4, 6);
975 priv->frag_seq = seq_no;
977 priv->frag_len = msdu_size;
978 memcpy(priv->frag_source, source, ETH_ALEN);
979 memcpy(&priv->rx_buf[ETH_ALEN], source, ETH_ALEN);
980 memcpy(priv->rx_buf, header->addr1, ETH_ALEN);
982 atmel_copy_to_host(priv->dev, &priv->rx_buf[12], rx_packet_loc, msdu_size);
984 if (priv->do_rx_crc) {
986 crc = crc32_le(crc, &priv->rx_buf[12], msdu_size);
987 atmel_copy_to_host(priv->dev, (void *)&netcrc, rx_packet_loc + msdu_size, 4);
988 if ((crc ^ 0xffffffff) != netcrc) {
989 priv->dev->stats.rx_crc_errors++;
990 eth_broadcast_addr(priv->frag_source);
994 } else if (priv->frag_no == frag_no &&
995 priv->frag_seq == seq_no &&
996 memcmp(priv->frag_source, source, ETH_ALEN) == 0) {
998 atmel_copy_to_host(priv->dev, &priv->rx_buf[12 + priv->frag_len],
999 rx_packet_loc, msdu_size);
1000 if (priv->do_rx_crc) {
1003 &priv->rx_buf[12 + priv->frag_len],
1005 atmel_copy_to_host(priv->dev, (void *)&netcrc, rx_packet_loc + msdu_size, 4);
1006 if ((crc ^ 0xffffffff) != netcrc) {
1007 priv->dev->stats.rx_crc_errors++;
1008 eth_broadcast_addr(priv->frag_source);
1009 more_frags = 1; /* don't send broken assembly */
1013 priv->frag_len += msdu_size;
1016 if (!more_frags) { /* last one */
1017 eth_broadcast_addr(priv->frag_source);
1018 if (!(skb = dev_alloc_skb(priv->frag_len + 14))) {
1019 priv->dev->stats.rx_dropped++;
1021 skb_reserve(skb, 2);
1022 skb_put_data(skb, priv->rx_buf,
1023 priv->frag_len + 12);
1024 skb->protocol = eth_type_trans(skb, priv->dev);
1025 skb->ip_summed = CHECKSUM_NONE;
1027 priv->dev->stats.rx_bytes += priv->frag_len + 12;
1028 priv->dev->stats.rx_packets++;
1032 priv->wstats.discard.fragment++;
1035 static void rx_done_irq(struct atmel_private *priv)
1038 struct ieee80211_hdr header;
1041 atmel_rmem8(priv, atmel_rx(priv, RX_DESC_FLAGS_OFFSET, priv->rx_desc_head)) == RX_DESC_FLAG_VALID &&
1042 i < priv->host_info.rx_desc_count;
1045 u16 msdu_size, rx_packet_loc, frame_ctl, seq_control;
1046 u8 status = atmel_rmem8(priv, atmel_rx(priv, RX_DESC_STATUS_OFFSET, priv->rx_desc_head));
1047 u32 crc = 0xffffffff;
1049 if (status != RX_STATUS_SUCCESS) {
1050 if (status == 0xc1) /* determined by experiment */
1051 priv->wstats.discard.nwid++;
1053 priv->dev->stats.rx_errors++;
1057 msdu_size = atmel_rmem16(priv, atmel_rx(priv, RX_DESC_MSDU_SIZE_OFFSET, priv->rx_desc_head));
1058 rx_packet_loc = atmel_rmem16(priv, atmel_rx(priv, RX_DESC_MSDU_POS_OFFSET, priv->rx_desc_head));
1060 if (msdu_size < 30) {
1061 priv->dev->stats.rx_errors++;
1065 /* Get header as far as end of seq_ctrl */
1066 atmel_copy_to_host(priv->dev, (char *)&header, rx_packet_loc, 24);
1067 frame_ctl = le16_to_cpu(header.frame_control);
1068 seq_control = le16_to_cpu(header.seq_ctrl);
1070 /* probe for CRC use here if needed once five packets have
1071 arrived with the same crc status, we assume we know what's
1072 happening and stop probing */
1073 if (priv->probe_crc) {
1074 if (!priv->wep_is_on || !(frame_ctl & IEEE80211_FCTL_PROTECTED)) {
1075 priv->do_rx_crc = probe_crc(priv, rx_packet_loc, msdu_size);
1077 priv->do_rx_crc = probe_crc(priv, rx_packet_loc + 24, msdu_size - 24);
1079 if (priv->do_rx_crc) {
1080 if (priv->crc_ok_cnt++ > 5)
1081 priv->probe_crc = 0;
1083 if (priv->crc_ko_cnt++ > 5)
1084 priv->probe_crc = 0;
1088 /* don't CRC header when WEP in use */
1089 if (priv->do_rx_crc && (!priv->wep_is_on || !(frame_ctl & IEEE80211_FCTL_PROTECTED))) {
1090 crc = crc32_le(0xffffffff, (unsigned char *)&header, 24);
1092 msdu_size -= 24; /* header */
1094 if ((frame_ctl & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA) {
1095 int more_fragments = frame_ctl & IEEE80211_FCTL_MOREFRAGS;
1096 u8 packet_fragment_no = seq_control & IEEE80211_SCTL_FRAG;
1097 u16 packet_sequence_no = (seq_control & IEEE80211_SCTL_SEQ) >> 4;
1099 if (!more_fragments && packet_fragment_no == 0) {
1100 fast_rx_path(priv, &header, msdu_size, rx_packet_loc, crc);
1102 frag_rx_path(priv, &header, msdu_size, rx_packet_loc, crc,
1103 packet_sequence_no, packet_fragment_no, more_fragments);
1107 if ((frame_ctl & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT) {
1108 /* copy rest of packet into buffer */
1109 atmel_copy_to_host(priv->dev, (unsigned char *)&priv->rx_buf, rx_packet_loc + 24, msdu_size);
1111 /* we use the same buffer for frag reassembly and control packets */
1112 eth_broadcast_addr(priv->frag_source);
1114 if (priv->do_rx_crc) {
1115 /* last 4 octets is crc */
1117 crc = crc32_le(crc, (unsigned char *)&priv->rx_buf, msdu_size);
1118 if ((crc ^ 0xffffffff) != (*((u32 *)&priv->rx_buf[msdu_size]))) {
1119 priv->dev->stats.rx_crc_errors++;
1124 atmel_management_frame(priv, &header, msdu_size,
1125 atmel_rmem8(priv, atmel_rx(priv, RX_DESC_RSSI_OFFSET, priv->rx_desc_head)));
1129 /* release descriptor */
1130 atmel_wmem8(priv, atmel_rx(priv, RX_DESC_FLAGS_OFFSET, priv->rx_desc_head), RX_DESC_FLAG_CONSUMED);
1132 if (priv->rx_desc_head < (priv->host_info.rx_desc_count - 1))
1133 priv->rx_desc_head++;
1135 priv->rx_desc_head = 0;
1139 static irqreturn_t service_interrupt(int irq, void *dev_id)
1141 struct net_device *dev = (struct net_device *) dev_id;
1142 struct atmel_private *priv = netdev_priv(dev);
1145 static const u8 irq_order[] = {
1151 ISR_COMMAND_COMPLETE,
1156 if (priv->card && priv->present_callback &&
1157 !(*priv->present_callback)(priv->card))
1160 /* In this state upper-level code assumes it can mess with
1161 the card unhampered by interrupts which may change register state.
1162 Note that even though the card shouldn't generate interrupts
1163 the inturrupt line may be shared. This allows card setup
1164 to go on without disabling interrupts for a long time. */
1165 if (priv->station_state == STATION_STATE_DOWN)
1168 atmel_clear_gcr(dev, GCR_ENINT); /* disable interrupts */
1171 if (!atmel_lock_mac(priv)) {
1172 /* failed to contact card */
1173 printk(KERN_ALERT "%s: failed to contact MAC.\n", dev->name);
1177 isr = atmel_rmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET));
1178 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0);
1181 atmel_set_gcr(dev, GCR_ENINT); /* enable interrupts */
1182 return i == -1 ? IRQ_NONE : IRQ_HANDLED;
1185 atmel_set_gcr(dev, GCR_ACKINT); /* acknowledge interrupt */
1187 for (i = 0; i < ARRAY_SIZE(irq_order); i++)
1188 if (isr & irq_order[i])
1191 if (!atmel_lock_mac(priv)) {
1192 /* failed to contact card */
1193 printk(KERN_ALERT "%s: failed to contact MAC.\n", dev->name);
1197 isr = atmel_rmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET));
1198 isr ^= irq_order[i];
1199 atmel_wmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET), isr);
1200 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0);
1202 switch (irq_order[i]) {
1204 case ISR_OUT_OF_RANGE:
1205 if (priv->operating_mode == IW_MODE_INFRA &&
1206 priv->station_state == STATION_STATE_READY) {
1207 priv->station_is_associated = 0;
1208 atmel_scan(priv, 1);
1212 case ISR_RxFRAMELOST:
1213 priv->wstats.discard.misc++;
1215 case ISR_RxCOMPLETE:
1219 case ISR_TxCOMPLETE:
1223 case ISR_FATAL_ERROR:
1224 printk(KERN_ALERT "%s: *** FATAL error interrupt ***\n", dev->name);
1225 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
1228 case ISR_COMMAND_COMPLETE:
1229 atmel_command_irq(priv);
1232 case ISR_IBSS_MERGE:
1233 atmel_get_mib(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_CUR_BSSID_POS,
1234 priv->CurrentBSSID, 6);
1235 /* The WPA stuff cares about the current AP address */
1237 build_wpa_mib(priv);
1239 case ISR_GENERIC_IRQ:
1240 printk(KERN_INFO "%s: Generic_irq received.\n", dev->name);
1246 static struct iw_statistics *atmel_get_wireless_stats(struct net_device *dev)
1248 struct atmel_private *priv = netdev_priv(dev);
1250 /* update the link quality here in case we are seeing no beacons
1251 at all to drive the process */
1252 atmel_smooth_qual(priv);
1254 priv->wstats.status = priv->station_state;
1256 if (priv->operating_mode == IW_MODE_INFRA) {
1257 if (priv->station_state != STATION_STATE_READY) {
1258 priv->wstats.qual.qual = 0;
1259 priv->wstats.qual.level = 0;
1260 priv->wstats.qual.updated = (IW_QUAL_QUAL_INVALID
1261 | IW_QUAL_LEVEL_INVALID);
1263 priv->wstats.qual.noise = 0;
1264 priv->wstats.qual.updated |= IW_QUAL_NOISE_INVALID;
1266 /* Quality levels cannot be determined in ad-hoc mode,
1267 because we can 'hear' more that one remote station. */
1268 priv->wstats.qual.qual = 0;
1269 priv->wstats.qual.level = 0;
1270 priv->wstats.qual.noise = 0;
1271 priv->wstats.qual.updated = IW_QUAL_QUAL_INVALID
1272 | IW_QUAL_LEVEL_INVALID
1273 | IW_QUAL_NOISE_INVALID;
1274 priv->wstats.miss.beacon = 0;
1277 return &priv->wstats;
1280 static int atmel_set_mac_address(struct net_device *dev, void *p)
1282 struct sockaddr *addr = p;
1284 eth_hw_addr_set(dev, addr->sa_data);
1285 return atmel_open(dev);
1288 EXPORT_SYMBOL(atmel_open);
1290 int atmel_open(struct net_device *dev)
1292 struct atmel_private *priv = netdev_priv(dev);
1293 int i, channel, err;
1295 /* any scheduled timer is no longer needed and might screw things up.. */
1296 del_timer_sync(&priv->management_timer);
1298 /* Interrupts will not touch the card once in this state... */
1299 priv->station_state = STATION_STATE_DOWN;
1301 if (priv->new_SSID_size) {
1302 memcpy(priv->SSID, priv->new_SSID, priv->new_SSID_size);
1303 priv->SSID_size = priv->new_SSID_size;
1304 priv->new_SSID_size = 0;
1306 priv->BSS_list_entries = 0;
1308 priv->AuthenticationRequestRetryCnt = 0;
1309 priv->AssociationRequestRetryCnt = 0;
1310 priv->ReAssociationRequestRetryCnt = 0;
1311 priv->CurrentAuthentTransactionSeqNum = 0x0001;
1312 priv->ExpectedAuthentTransactionSeqNum = 0x0002;
1314 priv->site_survey_state = SITE_SURVEY_IDLE;
1315 priv->station_is_associated = 0;
1317 err = reset_atmel_card(dev);
1321 if (priv->config_reg_domain) {
1322 priv->reg_domain = priv->config_reg_domain;
1323 atmel_set_mib8(priv, Phy_Mib_Type, PHY_MIB_REG_DOMAIN_POS, priv->reg_domain);
1325 priv->reg_domain = atmel_get_mib8(priv, Phy_Mib_Type, PHY_MIB_REG_DOMAIN_POS);
1326 for (i = 0; i < ARRAY_SIZE(channel_table); i++)
1327 if (priv->reg_domain == channel_table[i].reg_domain)
1329 if (i == ARRAY_SIZE(channel_table)) {
1330 priv->reg_domain = REG_DOMAIN_MKK1;
1331 printk(KERN_ALERT "%s: failed to get regulatory domain: assuming MKK1.\n", dev->name);
1335 if ((channel = atmel_validate_channel(priv, priv->channel)))
1336 priv->channel = channel;
1338 /* this moves station_state on.... */
1339 atmel_scan(priv, 1);
1341 atmel_set_gcr(priv->dev, GCR_ENINT); /* enable interrupts */
1345 static int atmel_close(struct net_device *dev)
1347 struct atmel_private *priv = netdev_priv(dev);
1349 /* Send event to userspace that we are disassociating */
1350 if (priv->station_state == STATION_STATE_READY) {
1351 union iwreq_data wrqu;
1353 wrqu.data.length = 0;
1354 wrqu.data.flags = 0;
1355 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1356 eth_zero_addr(wrqu.ap_addr.sa_data);
1357 wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
1360 atmel_enter_state(priv, STATION_STATE_DOWN);
1362 if (priv->bus_type == BUS_TYPE_PCCARD)
1363 atmel_write16(dev, GCR, 0x0060);
1364 atmel_write16(dev, GCR, 0x0040);
1368 static int atmel_validate_channel(struct atmel_private *priv, int channel)
1370 /* check that channel is OK, if so return zero,
1371 else return suitable default channel */
1374 for (i = 0; i < ARRAY_SIZE(channel_table); i++)
1375 if (priv->reg_domain == channel_table[i].reg_domain) {
1376 if (channel >= channel_table[i].min &&
1377 channel <= channel_table[i].max)
1380 return channel_table[i].min;
1385 #ifdef CONFIG_PROC_FS
1386 static int atmel_proc_show(struct seq_file *m, void *v)
1388 struct atmel_private *priv = m->private;
1392 seq_printf(m, "Driver version:\t\t%d.%d\n", DRIVER_MAJOR, DRIVER_MINOR);
1394 if (priv->station_state != STATION_STATE_DOWN) {
1396 "Firmware version:\t%d.%d build %d\n"
1397 "Firmware location:\t",
1398 priv->host_info.major_version,
1399 priv->host_info.minor_version,
1400 priv->host_info.build_version);
1402 if (priv->card_type != CARD_TYPE_EEPROM)
1403 seq_puts(m, "on card\n");
1404 else if (priv->firmware)
1405 seq_printf(m, "%s loaded by host\n", priv->firmware_id);
1407 seq_printf(m, "%s loaded by hotplug\n", priv->firmware_id);
1409 switch (priv->card_type) {
1410 case CARD_TYPE_PARALLEL_FLASH:
1411 c = "Parallel flash";
1413 case CARD_TYPE_SPI_FLASH:
1416 case CARD_TYPE_EEPROM:
1424 for (i = 0; i < ARRAY_SIZE(channel_table); i++)
1425 if (priv->reg_domain == channel_table[i].reg_domain)
1426 r = channel_table[i].name;
1428 seq_printf(m, "MAC memory type:\t%s\n", c);
1429 seq_printf(m, "Regulatory domain:\t%s\n", r);
1430 seq_printf(m, "Host CRC checking:\t%s\n",
1431 priv->do_rx_crc ? "On" : "Off");
1432 seq_printf(m, "WPA-capable firmware:\t%s\n",
1433 priv->use_wpa ? "Yes" : "No");
1436 switch (priv->station_state) {
1437 case STATION_STATE_SCANNING:
1440 case STATION_STATE_JOINNING:
1443 case STATION_STATE_AUTHENTICATING:
1444 s = "Authenticating";
1446 case STATION_STATE_ASSOCIATING:
1449 case STATION_STATE_READY:
1452 case STATION_STATE_REASSOCIATING:
1453 s = "Reassociating";
1455 case STATION_STATE_MGMT_ERROR:
1456 s = "Management error";
1458 case STATION_STATE_DOWN:
1465 seq_printf(m, "Current state:\t\t%s\n", s);
1470 static const struct net_device_ops atmel_netdev_ops = {
1471 .ndo_open = atmel_open,
1472 .ndo_stop = atmel_close,
1473 .ndo_set_mac_address = atmel_set_mac_address,
1474 .ndo_start_xmit = start_tx,
1475 .ndo_do_ioctl = atmel_ioctl,
1476 .ndo_validate_addr = eth_validate_addr,
1479 struct net_device *init_atmel_card(unsigned short irq, unsigned long port,
1480 const AtmelFWType fw_type,
1481 struct device *sys_dev,
1482 int (*card_present)(void *), void *card)
1484 struct net_device *dev;
1485 struct atmel_private *priv;
1488 /* Create the network device object. */
1489 dev = alloc_etherdev(sizeof(*priv));
1493 if (dev_alloc_name(dev, dev->name) < 0) {
1494 printk(KERN_ERR "atmel: Couldn't get name!\n");
1498 priv = netdev_priv(dev);
1500 priv->sys_dev = sys_dev;
1501 priv->present_callback = card_present;
1503 priv->firmware = NULL;
1504 priv->firmware_type = fw_type;
1505 if (firmware) /* module parameter */
1506 strlcpy(priv->firmware_id, firmware, sizeof(priv->firmware_id));
1507 priv->bus_type = card_present ? BUS_TYPE_PCCARD : BUS_TYPE_PCI;
1508 priv->station_state = STATION_STATE_DOWN;
1509 priv->do_rx_crc = 0;
1510 /* For PCMCIA cards, some chips need CRC, some don't
1511 so we have to probe. */
1512 if (priv->bus_type == BUS_TYPE_PCCARD) {
1513 priv->probe_crc = 1;
1514 priv->crc_ok_cnt = priv->crc_ko_cnt = 0;
1516 priv->probe_crc = 0;
1517 priv->last_qual = jiffies;
1518 priv->last_beacon_timestamp = 0;
1519 memset(priv->frag_source, 0xff, sizeof(priv->frag_source));
1520 eth_zero_addr(priv->BSSID);
1521 priv->CurrentBSSID[0] = 0xFF; /* Initialize to something invalid.... */
1522 priv->station_was_associated = 0;
1524 priv->last_survey = jiffies;
1525 priv->preamble = LONG_PREAMBLE;
1526 priv->operating_mode = IW_MODE_INFRA;
1527 priv->connect_to_any_BSS = 0;
1528 priv->config_reg_domain = 0;
1529 priv->reg_domain = 0;
1531 priv->auto_tx_rate = 1;
1533 priv->power_mode = 0;
1534 priv->SSID[0] = '\0';
1535 priv->SSID_size = 0;
1536 priv->new_SSID_size = 0;
1537 priv->frag_threshold = 2346;
1538 priv->rts_threshold = 2347;
1539 priv->short_retry = 7;
1540 priv->long_retry = 4;
1542 priv->wep_is_on = 0;
1543 priv->default_key = 0;
1544 priv->encryption_level = 0;
1545 priv->exclude_unencrypted = 0;
1546 priv->group_cipher_suite = priv->pairwise_cipher_suite = CIPHER_SUITE_NONE;
1548 memset(priv->wep_keys, 0, sizeof(priv->wep_keys));
1549 memset(priv->wep_key_len, 0, sizeof(priv->wep_key_len));
1551 priv->default_beacon_period = priv->beacon_period = 100;
1552 priv->listen_interval = 1;
1554 timer_setup(&priv->management_timer, atmel_management_timer, 0);
1555 spin_lock_init(&priv->irqlock);
1556 spin_lock_init(&priv->timerlock);
1558 dev->netdev_ops = &atmel_netdev_ops;
1559 dev->wireless_handlers = &atmel_handler_def;
1561 dev->base_addr = port;
1563 /* MTU range: 68 - 2312 */
1565 dev->max_mtu = MAX_WIRELESS_BODY - ETH_FCS_LEN;
1567 SET_NETDEV_DEV(dev, sys_dev);
1569 if ((rc = request_irq(dev->irq, service_interrupt, IRQF_SHARED, dev->name, dev))) {
1570 printk(KERN_ERR "%s: register interrupt %d failed, rc %d\n", dev->name, irq, rc);
1574 if (!request_region(dev->base_addr, 32,
1575 priv->bus_type == BUS_TYPE_PCCARD ? "atmel_cs" : "atmel_pci")) {
1579 if (register_netdev(dev))
1582 if (!probe_atmel_card(dev)) {
1583 unregister_netdev(dev);
1587 netif_carrier_off(dev);
1589 if (!proc_create_single_data("driver/atmel", 0, NULL, atmel_proc_show,
1591 printk(KERN_WARNING "atmel: unable to create /proc entry.\n");
1593 printk(KERN_INFO "%s: Atmel at76c50x. Version %d.%d. MAC %pM\n",
1594 dev->name, DRIVER_MAJOR, DRIVER_MINOR, dev->dev_addr);
1599 release_region(dev->base_addr, 32);
1601 free_irq(dev->irq, dev);
1607 EXPORT_SYMBOL(init_atmel_card);
1609 void stop_atmel_card(struct net_device *dev)
1611 struct atmel_private *priv = netdev_priv(dev);
1613 /* put a brick on it... */
1614 if (priv->bus_type == BUS_TYPE_PCCARD)
1615 atmel_write16(dev, GCR, 0x0060);
1616 atmel_write16(dev, GCR, 0x0040);
1618 del_timer_sync(&priv->management_timer);
1619 unregister_netdev(dev);
1620 remove_proc_entry("driver/atmel", NULL);
1621 free_irq(dev->irq, dev);
1622 kfree(priv->firmware);
1623 release_region(dev->base_addr, 32);
1627 EXPORT_SYMBOL(stop_atmel_card);
1629 static int atmel_set_essid(struct net_device *dev,
1630 struct iw_request_info *info,
1631 struct iw_point *dwrq,
1634 struct atmel_private *priv = netdev_priv(dev);
1636 /* Check if we asked for `any' */
1637 if (dwrq->flags == 0) {
1638 priv->connect_to_any_BSS = 1;
1640 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1642 priv->connect_to_any_BSS = 0;
1644 /* Check the size of the string */
1645 if (dwrq->length > MAX_SSID_LENGTH)
1650 memcpy(priv->new_SSID, extra, dwrq->length);
1651 priv->new_SSID_size = dwrq->length;
1654 return -EINPROGRESS;
1657 static int atmel_get_essid(struct net_device *dev,
1658 struct iw_request_info *info,
1659 struct iw_point *dwrq,
1662 struct atmel_private *priv = netdev_priv(dev);
1664 /* Get the current SSID */
1665 if (priv->new_SSID_size != 0) {
1666 memcpy(extra, priv->new_SSID, priv->new_SSID_size);
1667 dwrq->length = priv->new_SSID_size;
1669 memcpy(extra, priv->SSID, priv->SSID_size);
1670 dwrq->length = priv->SSID_size;
1673 dwrq->flags = !priv->connect_to_any_BSS; /* active */
1678 static int atmel_get_wap(struct net_device *dev,
1679 struct iw_request_info *info,
1680 struct sockaddr *awrq,
1683 struct atmel_private *priv = netdev_priv(dev);
1684 memcpy(awrq->sa_data, priv->CurrentBSSID, ETH_ALEN);
1685 awrq->sa_family = ARPHRD_ETHER;
1690 static int atmel_set_encode(struct net_device *dev,
1691 struct iw_request_info *info,
1692 struct iw_point *dwrq,
1695 struct atmel_private *priv = netdev_priv(dev);
1697 /* Basic checking: do we have a key to set ?
1698 * Note : with the new API, it's impossible to get a NULL pointer.
1699 * Therefore, we need to check a key size == 0 instead.
1700 * New version of iwconfig properly set the IW_ENCODE_NOKEY flag
1701 * when no key is present (only change flags), but older versions
1702 * don't do it. - Jean II */
1703 if (dwrq->length > 0) {
1704 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1705 int current_index = priv->default_key;
1706 /* Check the size of the key */
1707 if (dwrq->length > 13) {
1710 /* Check the index (none -> use current) */
1711 if (index < 0 || index >= 4)
1712 index = current_index;
1714 priv->default_key = index;
1715 /* Set the length */
1716 if (dwrq->length > 5)
1717 priv->wep_key_len[index] = 13;
1719 if (dwrq->length > 0)
1720 priv->wep_key_len[index] = 5;
1722 /* Disable the key */
1723 priv->wep_key_len[index] = 0;
1724 /* Check if the key is not marked as invalid */
1725 if (!(dwrq->flags & IW_ENCODE_NOKEY)) {
1727 memset(priv->wep_keys[index], 0, 13);
1728 /* Copy the key in the driver */
1729 memcpy(priv->wep_keys[index], extra, dwrq->length);
1731 /* WE specify that if a valid key is set, encryption
1732 * should be enabled (user may turn it off later)
1733 * This is also how "iwconfig ethX key on" works */
1734 if (index == current_index &&
1735 priv->wep_key_len[index] > 0) {
1736 priv->wep_is_on = 1;
1737 priv->exclude_unencrypted = 1;
1738 if (priv->wep_key_len[index] > 5) {
1739 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_128;
1740 priv->encryption_level = 2;
1742 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_64;
1743 priv->encryption_level = 1;
1747 /* Do we want to just set the transmit key index ? */
1748 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1749 if (index >= 0 && index < 4) {
1750 priv->default_key = index;
1752 /* Don't complain if only change the mode */
1753 if (!(dwrq->flags & IW_ENCODE_MODE))
1756 /* Read the flags */
1757 if (dwrq->flags & IW_ENCODE_DISABLED) {
1758 priv->wep_is_on = 0;
1759 priv->encryption_level = 0;
1760 priv->pairwise_cipher_suite = CIPHER_SUITE_NONE;
1762 priv->wep_is_on = 1;
1763 if (priv->wep_key_len[priv->default_key] > 5) {
1764 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_128;
1765 priv->encryption_level = 2;
1767 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_64;
1768 priv->encryption_level = 1;
1771 if (dwrq->flags & IW_ENCODE_RESTRICTED)
1772 priv->exclude_unencrypted = 1;
1773 if (dwrq->flags & IW_ENCODE_OPEN)
1774 priv->exclude_unencrypted = 0;
1776 return -EINPROGRESS; /* Call commit handler */
1779 static int atmel_get_encode(struct net_device *dev,
1780 struct iw_request_info *info,
1781 struct iw_point *dwrq,
1784 struct atmel_private *priv = netdev_priv(dev);
1785 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1787 if (!priv->wep_is_on)
1788 dwrq->flags = IW_ENCODE_DISABLED;
1790 if (priv->exclude_unencrypted)
1791 dwrq->flags = IW_ENCODE_RESTRICTED;
1793 dwrq->flags = IW_ENCODE_OPEN;
1795 /* Which key do we want ? -1 -> tx index */
1796 if (index < 0 || index >= 4)
1797 index = priv->default_key;
1798 dwrq->flags |= index + 1;
1799 /* Copy the key to the user buffer */
1800 dwrq->length = priv->wep_key_len[index];
1801 if (dwrq->length > 16) {
1804 memset(extra, 0, 16);
1805 memcpy(extra, priv->wep_keys[index], dwrq->length);
1811 static int atmel_set_encodeext(struct net_device *dev,
1812 struct iw_request_info *info,
1813 union iwreq_data *wrqu,
1816 struct atmel_private *priv = netdev_priv(dev);
1817 struct iw_point *encoding = &wrqu->encoding;
1818 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
1819 int idx, key_len, alg = ext->alg, set_key = 1;
1821 /* Determine and validate the key index */
1822 idx = encoding->flags & IW_ENCODE_INDEX;
1824 if (idx < 1 || idx > 4)
1828 idx = priv->default_key;
1830 if (encoding->flags & IW_ENCODE_DISABLED)
1831 alg = IW_ENCODE_ALG_NONE;
1833 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
1834 priv->default_key = idx;
1835 set_key = ext->key_len > 0 ? 1 : 0;
1839 /* Set the requested key first */
1841 case IW_ENCODE_ALG_NONE:
1842 priv->wep_is_on = 0;
1843 priv->encryption_level = 0;
1844 priv->pairwise_cipher_suite = CIPHER_SUITE_NONE;
1846 case IW_ENCODE_ALG_WEP:
1847 if (ext->key_len > 5) {
1848 priv->wep_key_len[idx] = 13;
1849 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_128;
1850 priv->encryption_level = 2;
1851 } else if (ext->key_len > 0) {
1852 priv->wep_key_len[idx] = 5;
1853 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_64;
1854 priv->encryption_level = 1;
1858 priv->wep_is_on = 1;
1859 memset(priv->wep_keys[idx], 0, 13);
1860 key_len = min ((int)ext->key_len, priv->wep_key_len[idx]);
1861 memcpy(priv->wep_keys[idx], ext->key, key_len);
1868 return -EINPROGRESS;
1871 static int atmel_get_encodeext(struct net_device *dev,
1872 struct iw_request_info *info,
1873 union iwreq_data *wrqu,
1876 struct atmel_private *priv = netdev_priv(dev);
1877 struct iw_point *encoding = &wrqu->encoding;
1878 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
1879 int idx, max_key_len;
1881 max_key_len = encoding->length - sizeof(*ext);
1882 if (max_key_len < 0)
1885 idx = encoding->flags & IW_ENCODE_INDEX;
1887 if (idx < 1 || idx > 4)
1891 idx = priv->default_key;
1893 encoding->flags = idx + 1;
1894 memset(ext, 0, sizeof(*ext));
1896 if (!priv->wep_is_on) {
1897 ext->alg = IW_ENCODE_ALG_NONE;
1899 encoding->flags |= IW_ENCODE_DISABLED;
1901 if (priv->encryption_level > 0)
1902 ext->alg = IW_ENCODE_ALG_WEP;
1906 ext->key_len = priv->wep_key_len[idx];
1907 memcpy(ext->key, priv->wep_keys[idx], ext->key_len);
1908 encoding->flags |= IW_ENCODE_ENABLED;
1914 static int atmel_set_auth(struct net_device *dev,
1915 struct iw_request_info *info,
1916 union iwreq_data *wrqu, char *extra)
1918 struct atmel_private *priv = netdev_priv(dev);
1919 struct iw_param *param = &wrqu->param;
1921 switch (param->flags & IW_AUTH_INDEX) {
1922 case IW_AUTH_WPA_VERSION:
1923 case IW_AUTH_CIPHER_PAIRWISE:
1924 case IW_AUTH_CIPHER_GROUP:
1925 case IW_AUTH_KEY_MGMT:
1926 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
1927 case IW_AUTH_PRIVACY_INVOKED:
1929 * atmel does not use these parameters
1933 case IW_AUTH_DROP_UNENCRYPTED:
1934 priv->exclude_unencrypted = param->value ? 1 : 0;
1937 case IW_AUTH_80211_AUTH_ALG: {
1938 if (param->value & IW_AUTH_ALG_SHARED_KEY) {
1939 priv->exclude_unencrypted = 1;
1940 } else if (param->value & IW_AUTH_ALG_OPEN_SYSTEM) {
1941 priv->exclude_unencrypted = 0;
1947 case IW_AUTH_WPA_ENABLED:
1948 /* Silently accept disable of WPA */
1949 if (param->value > 0)
1956 return -EINPROGRESS;
1959 static int atmel_get_auth(struct net_device *dev,
1960 struct iw_request_info *info,
1961 union iwreq_data *wrqu, char *extra)
1963 struct atmel_private *priv = netdev_priv(dev);
1964 struct iw_param *param = &wrqu->param;
1966 switch (param->flags & IW_AUTH_INDEX) {
1967 case IW_AUTH_DROP_UNENCRYPTED:
1968 param->value = priv->exclude_unencrypted;
1971 case IW_AUTH_80211_AUTH_ALG:
1972 if (priv->exclude_unencrypted == 1)
1973 param->value = IW_AUTH_ALG_SHARED_KEY;
1975 param->value = IW_AUTH_ALG_OPEN_SYSTEM;
1978 case IW_AUTH_WPA_ENABLED:
1989 static int atmel_get_name(struct net_device *dev,
1990 struct iw_request_info *info,
1994 strcpy(cwrq, "IEEE 802.11-DS");
1998 static int atmel_set_rate(struct net_device *dev,
1999 struct iw_request_info *info,
2000 struct iw_param *vwrq,
2003 struct atmel_private *priv = netdev_priv(dev);
2005 if (vwrq->fixed == 0) {
2007 priv->auto_tx_rate = 1;
2009 priv->auto_tx_rate = 0;
2011 /* Which type of value ? */
2012 if ((vwrq->value < 4) && (vwrq->value >= 0)) {
2013 /* Setting by rate index */
2014 priv->tx_rate = vwrq->value;
2016 /* Setting by frequency value */
2017 switch (vwrq->value) {
2036 return -EINPROGRESS;
2039 static int atmel_set_mode(struct net_device *dev,
2040 struct iw_request_info *info,
2044 struct atmel_private *priv = netdev_priv(dev);
2046 if (*uwrq != IW_MODE_ADHOC && *uwrq != IW_MODE_INFRA)
2049 priv->operating_mode = *uwrq;
2050 return -EINPROGRESS;
2053 static int atmel_get_mode(struct net_device *dev,
2054 struct iw_request_info *info,
2058 struct atmel_private *priv = netdev_priv(dev);
2060 *uwrq = priv->operating_mode;
2064 static int atmel_get_rate(struct net_device *dev,
2065 struct iw_request_info *info,
2066 struct iw_param *vwrq,
2069 struct atmel_private *priv = netdev_priv(dev);
2071 if (priv->auto_tx_rate) {
2073 vwrq->value = 11000000;
2076 switch (priv->tx_rate) {
2078 vwrq->value = 1000000;
2081 vwrq->value = 2000000;
2084 vwrq->value = 5500000;
2087 vwrq->value = 11000000;
2094 static int atmel_set_power(struct net_device *dev,
2095 struct iw_request_info *info,
2096 struct iw_param *vwrq,
2099 struct atmel_private *priv = netdev_priv(dev);
2100 priv->power_mode = vwrq->disabled ? 0 : 1;
2101 return -EINPROGRESS;
2104 static int atmel_get_power(struct net_device *dev,
2105 struct iw_request_info *info,
2106 struct iw_param *vwrq,
2109 struct atmel_private *priv = netdev_priv(dev);
2110 vwrq->disabled = priv->power_mode ? 0 : 1;
2111 vwrq->flags = IW_POWER_ON;
2115 static int atmel_set_retry(struct net_device *dev,
2116 struct iw_request_info *info,
2117 struct iw_param *vwrq,
2120 struct atmel_private *priv = netdev_priv(dev);
2122 if (!vwrq->disabled && (vwrq->flags & IW_RETRY_LIMIT)) {
2123 if (vwrq->flags & IW_RETRY_LONG)
2124 priv->long_retry = vwrq->value;
2125 else if (vwrq->flags & IW_RETRY_SHORT)
2126 priv->short_retry = vwrq->value;
2128 /* No modifier : set both */
2129 priv->long_retry = vwrq->value;
2130 priv->short_retry = vwrq->value;
2132 return -EINPROGRESS;
2138 static int atmel_get_retry(struct net_device *dev,
2139 struct iw_request_info *info,
2140 struct iw_param *vwrq,
2143 struct atmel_private *priv = netdev_priv(dev);
2145 vwrq->disabled = 0; /* Can't be disabled */
2147 /* Note : by default, display the short retry number */
2148 if (vwrq->flags & IW_RETRY_LONG) {
2149 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
2150 vwrq->value = priv->long_retry;
2152 vwrq->flags = IW_RETRY_LIMIT;
2153 vwrq->value = priv->short_retry;
2154 if (priv->long_retry != priv->short_retry)
2155 vwrq->flags |= IW_RETRY_SHORT;
2161 static int atmel_set_rts(struct net_device *dev,
2162 struct iw_request_info *info,
2163 struct iw_param *vwrq,
2166 struct atmel_private *priv = netdev_priv(dev);
2167 int rthr = vwrq->value;
2171 if ((rthr < 0) || (rthr > 2347)) {
2174 priv->rts_threshold = rthr;
2176 return -EINPROGRESS; /* Call commit handler */
2179 static int atmel_get_rts(struct net_device *dev,
2180 struct iw_request_info *info,
2181 struct iw_param *vwrq,
2184 struct atmel_private *priv = netdev_priv(dev);
2186 vwrq->value = priv->rts_threshold;
2187 vwrq->disabled = (vwrq->value >= 2347);
2193 static int atmel_set_frag(struct net_device *dev,
2194 struct iw_request_info *info,
2195 struct iw_param *vwrq,
2198 struct atmel_private *priv = netdev_priv(dev);
2199 int fthr = vwrq->value;
2203 if ((fthr < 256) || (fthr > 2346)) {
2206 fthr &= ~0x1; /* Get an even value - is it really needed ??? */
2207 priv->frag_threshold = fthr;
2209 return -EINPROGRESS; /* Call commit handler */
2212 static int atmel_get_frag(struct net_device *dev,
2213 struct iw_request_info *info,
2214 struct iw_param *vwrq,
2217 struct atmel_private *priv = netdev_priv(dev);
2219 vwrq->value = priv->frag_threshold;
2220 vwrq->disabled = (vwrq->value >= 2346);
2226 static int atmel_set_freq(struct net_device *dev,
2227 struct iw_request_info *info,
2228 struct iw_freq *fwrq,
2231 struct atmel_private *priv = netdev_priv(dev);
2232 int rc = -EINPROGRESS; /* Call commit handler */
2234 /* If setting by frequency, convert to a channel */
2236 int f = fwrq->m / 100000;
2238 /* Hack to fall through... */
2240 fwrq->m = ieee80211_frequency_to_channel(f);
2242 /* Setting by channel number */
2243 if (fwrq->m < 0 || fwrq->m > 1000 || fwrq->e > 0)
2246 int channel = fwrq->m;
2247 if (atmel_validate_channel(priv, channel) == 0) {
2248 priv->channel = channel;
2256 static int atmel_get_freq(struct net_device *dev,
2257 struct iw_request_info *info,
2258 struct iw_freq *fwrq,
2261 struct atmel_private *priv = netdev_priv(dev);
2263 fwrq->m = priv->channel;
2268 static int atmel_set_scan(struct net_device *dev,
2269 struct iw_request_info *info,
2270 struct iw_point *dwrq,
2273 struct atmel_private *priv = netdev_priv(dev);
2274 unsigned long flags;
2276 /* Note : you may have realised that, as this is a SET operation,
2277 * this is privileged and therefore a normal user can't
2279 * This is not an error, while the device perform scanning,
2280 * traffic doesn't flow, so it's a perfect DoS...
2283 if (priv->station_state == STATION_STATE_DOWN)
2286 /* Timeout old surveys. */
2287 if (time_after(jiffies, priv->last_survey + 20 * HZ))
2288 priv->site_survey_state = SITE_SURVEY_IDLE;
2289 priv->last_survey = jiffies;
2291 /* Initiate a scan command */
2292 if (priv->site_survey_state == SITE_SURVEY_IN_PROGRESS)
2295 del_timer_sync(&priv->management_timer);
2296 spin_lock_irqsave(&priv->irqlock, flags);
2298 priv->site_survey_state = SITE_SURVEY_IN_PROGRESS;
2299 priv->fast_scan = 0;
2300 atmel_scan(priv, 0);
2301 spin_unlock_irqrestore(&priv->irqlock, flags);
2306 static int atmel_get_scan(struct net_device *dev,
2307 struct iw_request_info *info,
2308 struct iw_point *dwrq,
2311 struct atmel_private *priv = netdev_priv(dev);
2313 char *current_ev = extra;
2314 struct iw_event iwe;
2316 if (priv->site_survey_state != SITE_SURVEY_COMPLETED)
2319 for (i = 0; i < priv->BSS_list_entries; i++) {
2320 iwe.cmd = SIOCGIWAP;
2321 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
2322 memcpy(iwe.u.ap_addr.sa_data, priv->BSSinfo[i].BSSID, ETH_ALEN);
2323 current_ev = iwe_stream_add_event(info, current_ev,
2324 extra + IW_SCAN_MAX_DATA,
2325 &iwe, IW_EV_ADDR_LEN);
2327 iwe.u.data.length = priv->BSSinfo[i].SSIDsize;
2328 if (iwe.u.data.length > 32)
2329 iwe.u.data.length = 32;
2330 iwe.cmd = SIOCGIWESSID;
2331 iwe.u.data.flags = 1;
2332 current_ev = iwe_stream_add_point(info, current_ev,
2333 extra + IW_SCAN_MAX_DATA,
2334 &iwe, priv->BSSinfo[i].SSID);
2336 iwe.cmd = SIOCGIWMODE;
2337 iwe.u.mode = priv->BSSinfo[i].BSStype;
2338 current_ev = iwe_stream_add_event(info, current_ev,
2339 extra + IW_SCAN_MAX_DATA,
2340 &iwe, IW_EV_UINT_LEN);
2342 iwe.cmd = SIOCGIWFREQ;
2343 iwe.u.freq.m = priv->BSSinfo[i].channel;
2345 current_ev = iwe_stream_add_event(info, current_ev,
2346 extra + IW_SCAN_MAX_DATA,
2347 &iwe, IW_EV_FREQ_LEN);
2349 /* Add quality statistics */
2351 iwe.u.qual.level = priv->BSSinfo[i].RSSI;
2352 iwe.u.qual.qual = iwe.u.qual.level;
2353 /* iwe.u.qual.noise = SOMETHING */
2354 current_ev = iwe_stream_add_event(info, current_ev,
2355 extra + IW_SCAN_MAX_DATA,
2356 &iwe, IW_EV_QUAL_LEN);
2359 iwe.cmd = SIOCGIWENCODE;
2360 if (priv->BSSinfo[i].UsingWEP)
2361 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
2363 iwe.u.data.flags = IW_ENCODE_DISABLED;
2364 iwe.u.data.length = 0;
2365 current_ev = iwe_stream_add_point(info, current_ev,
2366 extra + IW_SCAN_MAX_DATA,
2370 /* Length of data */
2371 dwrq->length = (current_ev - extra);
2377 static int atmel_get_range(struct net_device *dev,
2378 struct iw_request_info *info,
2379 struct iw_point *dwrq,
2382 struct atmel_private *priv = netdev_priv(dev);
2383 struct iw_range *range = (struct iw_range *) extra;
2386 dwrq->length = sizeof(struct iw_range);
2387 memset(range, 0, sizeof(struct iw_range));
2388 range->min_nwid = 0x0000;
2389 range->max_nwid = 0x0000;
2390 range->num_channels = 0;
2391 for (j = 0; j < ARRAY_SIZE(channel_table); j++)
2392 if (priv->reg_domain == channel_table[j].reg_domain) {
2393 range->num_channels = channel_table[j].max - channel_table[j].min + 1;
2396 if (range->num_channels != 0) {
2397 for (k = 0, i = channel_table[j].min; i <= channel_table[j].max; i++) {
2398 range->freq[k].i = i; /* List index */
2400 /* Values in MHz -> * 10^5 * 10 */
2401 range->freq[k].m = 100000 *
2402 ieee80211_channel_to_frequency(i, NL80211_BAND_2GHZ);
2403 range->freq[k++].e = 1;
2405 range->num_frequency = k;
2408 range->max_qual.qual = 100;
2409 range->max_qual.level = 100;
2410 range->max_qual.noise = 0;
2411 range->max_qual.updated = IW_QUAL_NOISE_INVALID;
2413 range->avg_qual.qual = 50;
2414 range->avg_qual.level = 50;
2415 range->avg_qual.noise = 0;
2416 range->avg_qual.updated = IW_QUAL_NOISE_INVALID;
2418 range->sensitivity = 0;
2420 range->bitrate[0] = 1000000;
2421 range->bitrate[1] = 2000000;
2422 range->bitrate[2] = 5500000;
2423 range->bitrate[3] = 11000000;
2424 range->num_bitrates = 4;
2427 range->max_rts = 2347;
2428 range->min_frag = 256;
2429 range->max_frag = 2346;
2431 range->encoding_size[0] = 5;
2432 range->encoding_size[1] = 13;
2433 range->num_encoding_sizes = 2;
2434 range->max_encoding_tokens = 4;
2436 range->pmp_flags = IW_POWER_ON;
2437 range->pmt_flags = IW_POWER_ON;
2440 range->we_version_source = WIRELESS_EXT;
2441 range->we_version_compiled = WIRELESS_EXT;
2442 range->retry_capa = IW_RETRY_LIMIT ;
2443 range->retry_flags = IW_RETRY_LIMIT;
2444 range->r_time_flags = 0;
2445 range->min_retry = 1;
2446 range->max_retry = 65535;
2451 static int atmel_set_wap(struct net_device *dev,
2452 struct iw_request_info *info,
2453 struct sockaddr *awrq,
2456 struct atmel_private *priv = netdev_priv(dev);
2458 static const u8 any[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
2459 static const u8 off[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
2460 unsigned long flags;
2462 if (awrq->sa_family != ARPHRD_ETHER)
2465 if (!memcmp(any, awrq->sa_data, 6) ||
2466 !memcmp(off, awrq->sa_data, 6)) {
2467 del_timer_sync(&priv->management_timer);
2468 spin_lock_irqsave(&priv->irqlock, flags);
2469 atmel_scan(priv, 1);
2470 spin_unlock_irqrestore(&priv->irqlock, flags);
2474 for (i = 0; i < priv->BSS_list_entries; i++) {
2475 if (memcmp(priv->BSSinfo[i].BSSID, awrq->sa_data, 6) == 0) {
2476 if (!priv->wep_is_on && priv->BSSinfo[i].UsingWEP) {
2478 } else if (priv->wep_is_on && !priv->BSSinfo[i].UsingWEP) {
2481 del_timer_sync(&priv->management_timer);
2482 spin_lock_irqsave(&priv->irqlock, flags);
2483 atmel_join_bss(priv, i);
2484 spin_unlock_irqrestore(&priv->irqlock, flags);
2493 static int atmel_config_commit(struct net_device *dev,
2494 struct iw_request_info *info, /* NULL */
2495 void *zwrq, /* NULL */
2496 char *extra) /* NULL */
2498 return atmel_open(dev);
2501 static const iw_handler atmel_handler[] =
2503 (iw_handler) atmel_config_commit, /* SIOCSIWCOMMIT */
2504 (iw_handler) atmel_get_name, /* SIOCGIWNAME */
2505 (iw_handler) NULL, /* SIOCSIWNWID */
2506 (iw_handler) NULL, /* SIOCGIWNWID */
2507 (iw_handler) atmel_set_freq, /* SIOCSIWFREQ */
2508 (iw_handler) atmel_get_freq, /* SIOCGIWFREQ */
2509 (iw_handler) atmel_set_mode, /* SIOCSIWMODE */
2510 (iw_handler) atmel_get_mode, /* SIOCGIWMODE */
2511 (iw_handler) NULL, /* SIOCSIWSENS */
2512 (iw_handler) NULL, /* SIOCGIWSENS */
2513 (iw_handler) NULL, /* SIOCSIWRANGE */
2514 (iw_handler) atmel_get_range, /* SIOCGIWRANGE */
2515 (iw_handler) NULL, /* SIOCSIWPRIV */
2516 (iw_handler) NULL, /* SIOCGIWPRIV */
2517 (iw_handler) NULL, /* SIOCSIWSTATS */
2518 (iw_handler) NULL, /* SIOCGIWSTATS */
2519 (iw_handler) NULL, /* SIOCSIWSPY */
2520 (iw_handler) NULL, /* SIOCGIWSPY */
2521 (iw_handler) NULL, /* -- hole -- */
2522 (iw_handler) NULL, /* -- hole -- */
2523 (iw_handler) atmel_set_wap, /* SIOCSIWAP */
2524 (iw_handler) atmel_get_wap, /* SIOCGIWAP */
2525 (iw_handler) NULL, /* -- hole -- */
2526 (iw_handler) NULL, /* SIOCGIWAPLIST */
2527 (iw_handler) atmel_set_scan, /* SIOCSIWSCAN */
2528 (iw_handler) atmel_get_scan, /* SIOCGIWSCAN */
2529 (iw_handler) atmel_set_essid, /* SIOCSIWESSID */
2530 (iw_handler) atmel_get_essid, /* SIOCGIWESSID */
2531 (iw_handler) NULL, /* SIOCSIWNICKN */
2532 (iw_handler) NULL, /* SIOCGIWNICKN */
2533 (iw_handler) NULL, /* -- hole -- */
2534 (iw_handler) NULL, /* -- hole -- */
2535 (iw_handler) atmel_set_rate, /* SIOCSIWRATE */
2536 (iw_handler) atmel_get_rate, /* SIOCGIWRATE */
2537 (iw_handler) atmel_set_rts, /* SIOCSIWRTS */
2538 (iw_handler) atmel_get_rts, /* SIOCGIWRTS */
2539 (iw_handler) atmel_set_frag, /* SIOCSIWFRAG */
2540 (iw_handler) atmel_get_frag, /* SIOCGIWFRAG */
2541 (iw_handler) NULL, /* SIOCSIWTXPOW */
2542 (iw_handler) NULL, /* SIOCGIWTXPOW */
2543 (iw_handler) atmel_set_retry, /* SIOCSIWRETRY */
2544 (iw_handler) atmel_get_retry, /* SIOCGIWRETRY */
2545 (iw_handler) atmel_set_encode, /* SIOCSIWENCODE */
2546 (iw_handler) atmel_get_encode, /* SIOCGIWENCODE */
2547 (iw_handler) atmel_set_power, /* SIOCSIWPOWER */
2548 (iw_handler) atmel_get_power, /* SIOCGIWPOWER */
2549 (iw_handler) NULL, /* -- hole -- */
2550 (iw_handler) NULL, /* -- hole -- */
2551 (iw_handler) NULL, /* SIOCSIWGENIE */
2552 (iw_handler) NULL, /* SIOCGIWGENIE */
2553 (iw_handler) atmel_set_auth, /* SIOCSIWAUTH */
2554 (iw_handler) atmel_get_auth, /* SIOCGIWAUTH */
2555 (iw_handler) atmel_set_encodeext, /* SIOCSIWENCODEEXT */
2556 (iw_handler) atmel_get_encodeext, /* SIOCGIWENCODEEXT */
2557 (iw_handler) NULL, /* SIOCSIWPMKSA */
2560 static const iw_handler atmel_private_handler[] =
2562 NULL, /* SIOCIWFIRSTPRIV */
2565 struct atmel_priv_ioctl {
2567 unsigned char __user *data;
2571 #define ATMELFWL SIOCIWFIRSTPRIV
2572 #define ATMELIDIFC ATMELFWL + 1
2573 #define ATMELRD ATMELFWL + 2
2574 #define ATMELMAGIC 0x51807
2575 #define REGDOMAINSZ 20
2577 static const struct iw_priv_args atmel_private_args[] = {
2580 .set_args = IW_PRIV_TYPE_BYTE
2581 | IW_PRIV_SIZE_FIXED
2582 | sizeof(struct atmel_priv_ioctl),
2583 .get_args = IW_PRIV_TYPE_NONE,
2587 .set_args = IW_PRIV_TYPE_NONE,
2588 .get_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
2589 .name = "atmelidifc"
2592 .set_args = IW_PRIV_TYPE_CHAR | REGDOMAINSZ,
2593 .get_args = IW_PRIV_TYPE_NONE,
2598 static const struct iw_handler_def atmel_handler_def = {
2599 .num_standard = ARRAY_SIZE(atmel_handler),
2600 .num_private = ARRAY_SIZE(atmel_private_handler),
2601 .num_private_args = ARRAY_SIZE(atmel_private_args),
2602 .standard = (iw_handler *) atmel_handler,
2603 .private = (iw_handler *) atmel_private_handler,
2604 .private_args = (struct iw_priv_args *) atmel_private_args,
2605 .get_wireless_stats = atmel_get_wireless_stats
2608 static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2611 struct atmel_private *priv = netdev_priv(dev);
2612 struct atmel_priv_ioctl com;
2613 struct iwreq *wrq = (struct iwreq *) rq;
2614 unsigned char *new_firmware;
2615 char domain[REGDOMAINSZ + 1];
2619 wrq->u.param.value = ATMELMAGIC;
2623 if (copy_from_user(&com, rq->ifr_data, sizeof(com))) {
2628 if (!capable(CAP_NET_ADMIN)) {
2633 new_firmware = memdup_user(com.data, com.len);
2634 if (IS_ERR(new_firmware)) {
2635 rc = PTR_ERR(new_firmware);
2639 kfree(priv->firmware);
2641 priv->firmware = new_firmware;
2642 priv->firmware_length = com.len;
2643 strncpy(priv->firmware_id, com.id, 31);
2644 priv->firmware_id[31] = '\0';
2648 if (copy_from_user(domain, rq->ifr_data, REGDOMAINSZ)) {
2653 if (!capable(CAP_NET_ADMIN)) {
2658 domain[REGDOMAINSZ] = 0;
2660 for (i = 0; i < ARRAY_SIZE(channel_table); i++) {
2661 if (!strcasecmp(channel_table[i].name, domain)) {
2662 priv->config_reg_domain = channel_table[i].reg_domain;
2667 if (rc == 0 && priv->station_state != STATION_STATE_DOWN)
2668 rc = atmel_open(dev);
2687 static void atmel_enter_state(struct atmel_private *priv, int new_state)
2689 int old_state = priv->station_state;
2691 if (new_state == old_state)
2694 priv->station_state = new_state;
2696 if (new_state == STATION_STATE_READY) {
2697 netif_start_queue(priv->dev);
2698 netif_carrier_on(priv->dev);
2701 if (old_state == STATION_STATE_READY) {
2702 netif_carrier_off(priv->dev);
2703 if (netif_running(priv->dev))
2704 netif_stop_queue(priv->dev);
2705 priv->last_beacon_timestamp = 0;
2709 static void atmel_scan(struct atmel_private *priv, int specific_ssid)
2713 u8 SSID[MAX_SSID_LENGTH];
2717 __le16 min_channel_time;
2718 __le16 max_channel_time;
2723 eth_broadcast_addr(cmd.BSSID);
2725 if (priv->fast_scan) {
2726 cmd.SSID_size = priv->SSID_size;
2727 memcpy(cmd.SSID, priv->SSID, priv->SSID_size);
2728 cmd.min_channel_time = cpu_to_le16(10);
2729 cmd.max_channel_time = cpu_to_le16(50);
2731 priv->BSS_list_entries = 0;
2733 cmd.min_channel_time = cpu_to_le16(10);
2734 cmd.max_channel_time = cpu_to_le16(120);
2740 cmd.options |= SCAN_OPTIONS_SITE_SURVEY;
2742 cmd.channel = (priv->channel & 0x7f);
2743 cmd.scan_type = SCAN_TYPE_ACTIVE;
2744 cmd.BSS_type = cpu_to_le16(priv->operating_mode == IW_MODE_ADHOC ?
2745 BSS_TYPE_AD_HOC : BSS_TYPE_INFRASTRUCTURE);
2747 atmel_send_command(priv, CMD_Scan, &cmd, sizeof(cmd));
2749 /* This must come after all hardware access to avoid being messed up
2750 by stuff happening in interrupt context after we leave STATE_DOWN */
2751 atmel_enter_state(priv, STATION_STATE_SCANNING);
2754 static void join(struct atmel_private *priv, int type)
2758 u8 SSID[MAX_SSID_LENGTH];
2759 u8 BSS_type; /* this is a short in a scan command - weird */
2766 cmd.SSID_size = priv->SSID_size;
2767 memcpy(cmd.SSID, priv->SSID, priv->SSID_size);
2768 memcpy(cmd.BSSID, priv->CurrentBSSID, ETH_ALEN);
2769 cmd.channel = (priv->channel & 0x7f);
2770 cmd.BSS_type = type;
2771 cmd.timeout = cpu_to_le16(2000);
2773 atmel_send_command(priv, CMD_Join, &cmd, sizeof(cmd));
2776 static void start(struct atmel_private *priv, int type)
2780 u8 SSID[MAX_SSID_LENGTH];
2787 cmd.SSID_size = priv->SSID_size;
2788 memcpy(cmd.SSID, priv->SSID, priv->SSID_size);
2789 memcpy(cmd.BSSID, priv->BSSID, ETH_ALEN);
2790 cmd.BSS_type = type;
2791 cmd.channel = (priv->channel & 0x7f);
2793 atmel_send_command(priv, CMD_Start, &cmd, sizeof(cmd));
2796 static void handle_beacon_probe(struct atmel_private *priv, u16 capability,
2800 int new = capability & WLAN_CAPABILITY_SHORT_PREAMBLE ?
2801 SHORT_PREAMBLE : LONG_PREAMBLE;
2803 if (priv->preamble != new) {
2804 priv->preamble = new;
2806 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_PREAMBLE_TYPE, new);
2809 if (priv->channel != channel) {
2810 priv->channel = channel;
2812 atmel_set_mib8(priv, Phy_Mib_Type, PHY_MIB_CHANNEL_POS, channel);
2816 priv->station_is_associated = 0;
2817 atmel_enter_state(priv, STATION_STATE_JOINNING);
2819 if (priv->operating_mode == IW_MODE_INFRA)
2820 join(priv, BSS_TYPE_INFRASTRUCTURE);
2822 join(priv, BSS_TYPE_AD_HOC);
2826 static void send_authentication_request(struct atmel_private *priv, u16 system,
2827 u8 *challenge, int challenge_len)
2829 struct ieee80211_hdr header;
2830 struct auth_body auth;
2832 header.frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_AUTH);
2833 header.duration_id = cpu_to_le16(0x8000);
2834 header.seq_ctrl = 0;
2835 memcpy(header.addr1, priv->CurrentBSSID, ETH_ALEN);
2836 memcpy(header.addr2, priv->dev->dev_addr, ETH_ALEN);
2837 memcpy(header.addr3, priv->CurrentBSSID, ETH_ALEN);
2839 if (priv->wep_is_on && priv->CurrentAuthentTransactionSeqNum != 1)
2840 /* no WEP for authentication frames with TrSeqNo 1 */
2841 header.frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
2843 auth.alg = cpu_to_le16(system);
2846 auth.trans_seq = cpu_to_le16(priv->CurrentAuthentTransactionSeqNum);
2847 priv->ExpectedAuthentTransactionSeqNum = priv->CurrentAuthentTransactionSeqNum+1;
2848 priv->CurrentAuthentTransactionSeqNum += 2;
2850 if (challenge_len != 0) {
2851 auth.el_id = 16; /* challenge_text */
2852 auth.chall_text_len = challenge_len;
2853 memcpy(auth.chall_text, challenge, challenge_len);
2854 atmel_transmit_management_frame(priv, &header, (u8 *)&auth, 8 + challenge_len);
2856 atmel_transmit_management_frame(priv, &header, (u8 *)&auth, 6);
2860 static void send_association_request(struct atmel_private *priv, int is_reassoc)
2864 struct ieee80211_hdr header;
2865 struct ass_req_format {
2867 __le16 listen_interval;
2868 u8 ap[ETH_ALEN]; /* nothing after here directly accessible */
2871 u8 ssid[MAX_SSID_LENGTH];
2877 header.frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2878 (is_reassoc ? IEEE80211_STYPE_REASSOC_REQ : IEEE80211_STYPE_ASSOC_REQ));
2879 header.duration_id = cpu_to_le16(0x8000);
2880 header.seq_ctrl = 0;
2882 memcpy(header.addr1, priv->CurrentBSSID, ETH_ALEN);
2883 memcpy(header.addr2, priv->dev->dev_addr, ETH_ALEN);
2884 memcpy(header.addr3, priv->CurrentBSSID, ETH_ALEN);
2886 body.capability = cpu_to_le16(WLAN_CAPABILITY_ESS);
2887 if (priv->wep_is_on)
2888 body.capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY);
2889 if (priv->preamble == SHORT_PREAMBLE)
2890 body.capability |= cpu_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE);
2892 body.listen_interval = cpu_to_le16(priv->listen_interval * priv->beacon_period);
2894 /* current AP address - only in reassoc frame */
2896 memcpy(body.ap, priv->CurrentBSSID, ETH_ALEN);
2897 ssid_el_p = &body.ssid_el_id;
2898 bodysize = 18 + priv->SSID_size;
2900 ssid_el_p = &body.ap[0];
2901 bodysize = 12 + priv->SSID_size;
2904 ssid_el_p[0] = WLAN_EID_SSID;
2905 ssid_el_p[1] = priv->SSID_size;
2906 memcpy(ssid_el_p + 2, priv->SSID, priv->SSID_size);
2907 ssid_el_p[2 + priv->SSID_size] = WLAN_EID_SUPP_RATES;
2908 ssid_el_p[3 + priv->SSID_size] = 4; /* len of supported rates */
2909 memcpy(ssid_el_p + 4 + priv->SSID_size, atmel_basic_rates, 4);
2911 atmel_transmit_management_frame(priv, &header, (void *)&body, bodysize);
2914 static int is_frame_from_current_bss(struct atmel_private *priv,
2915 struct ieee80211_hdr *header)
2917 if (le16_to_cpu(header->frame_control) & IEEE80211_FCTL_FROMDS)
2918 return memcmp(header->addr3, priv->CurrentBSSID, 6) == 0;
2920 return memcmp(header->addr2, priv->CurrentBSSID, 6) == 0;
2923 static int retrieve_bss(struct atmel_private *priv)
2926 int max_rssi = -128;
2929 if (priv->BSS_list_entries == 0)
2932 if (priv->connect_to_any_BSS) {
2933 /* Select a BSS with the max-RSSI but of the same type and of
2934 the same WEP mode and that it is not marked as 'bad' (i.e.
2935 we had previously failed to connect to this BSS with the
2936 settings that we currently use) */
2937 priv->current_BSS = 0;
2938 for (i = 0; i < priv->BSS_list_entries; i++) {
2939 if (priv->operating_mode == priv->BSSinfo[i].BSStype &&
2940 ((!priv->wep_is_on && !priv->BSSinfo[i].UsingWEP) ||
2941 (priv->wep_is_on && priv->BSSinfo[i].UsingWEP)) &&
2942 !(priv->BSSinfo[i].channel & 0x80)) {
2943 max_rssi = priv->BSSinfo[i].RSSI;
2944 priv->current_BSS = max_index = i;
2950 for (i = 0; i < priv->BSS_list_entries; i++) {
2951 if (priv->SSID_size == priv->BSSinfo[i].SSIDsize &&
2952 memcmp(priv->SSID, priv->BSSinfo[i].SSID, priv->SSID_size) == 0 &&
2953 priv->operating_mode == priv->BSSinfo[i].BSStype &&
2954 atmel_validate_channel(priv, priv->BSSinfo[i].channel) == 0) {
2955 if (priv->BSSinfo[i].RSSI >= max_rssi) {
2956 max_rssi = priv->BSSinfo[i].RSSI;
2964 static void store_bss_info(struct atmel_private *priv,
2965 struct ieee80211_hdr *header, u16 capability,
2966 u16 beacon_period, u8 channel, u8 rssi, u8 ssid_len,
2967 u8 *ssid, int is_beacon)
2969 u8 *bss = capability & WLAN_CAPABILITY_ESS ? header->addr2 : header->addr3;
2972 for (index = -1, i = 0; i < priv->BSS_list_entries; i++)
2973 if (memcmp(bss, priv->BSSinfo[i].BSSID, ETH_ALEN) == 0)
2976 /* If we process a probe and an entry from this BSS exists
2977 we will update the BSS entry with the info from this BSS.
2978 If we process a beacon we will only update RSSI */
2981 if (priv->BSS_list_entries == MAX_BSS_ENTRIES)
2983 index = priv->BSS_list_entries++;
2984 memcpy(priv->BSSinfo[index].BSSID, bss, ETH_ALEN);
2985 priv->BSSinfo[index].RSSI = rssi;
2987 if (rssi > priv->BSSinfo[index].RSSI)
2988 priv->BSSinfo[index].RSSI = rssi;
2993 priv->BSSinfo[index].channel = channel;
2994 priv->BSSinfo[index].beacon_period = beacon_period;
2995 priv->BSSinfo[index].UsingWEP = capability & WLAN_CAPABILITY_PRIVACY;
2996 memcpy(priv->BSSinfo[index].SSID, ssid, ssid_len);
2997 priv->BSSinfo[index].SSIDsize = ssid_len;
2999 if (capability & WLAN_CAPABILITY_IBSS)
3000 priv->BSSinfo[index].BSStype = IW_MODE_ADHOC;
3001 else if (capability & WLAN_CAPABILITY_ESS)
3002 priv->BSSinfo[index].BSStype = IW_MODE_INFRA;
3004 priv->BSSinfo[index].preamble = capability & WLAN_CAPABILITY_SHORT_PREAMBLE ?
3005 SHORT_PREAMBLE : LONG_PREAMBLE;
3008 static void authenticate(struct atmel_private *priv, u16 frame_len)
3010 struct auth_body *auth = (struct auth_body *)priv->rx_buf;
3011 u16 status = le16_to_cpu(auth->status);
3012 u16 trans_seq_no = le16_to_cpu(auth->trans_seq);
3013 u16 system = le16_to_cpu(auth->alg);
3015 if (status == WLAN_STATUS_SUCCESS && !priv->wep_is_on) {
3017 if (priv->station_was_associated) {
3018 atmel_enter_state(priv, STATION_STATE_REASSOCIATING);
3019 send_association_request(priv, 1);
3022 atmel_enter_state(priv, STATION_STATE_ASSOCIATING);
3023 send_association_request(priv, 0);
3028 if (status == WLAN_STATUS_SUCCESS && priv->wep_is_on) {
3029 int should_associate = 0;
3031 if (trans_seq_no != priv->ExpectedAuthentTransactionSeqNum)
3034 if (system == WLAN_AUTH_OPEN) {
3035 if (trans_seq_no == 0x0002) {
3036 should_associate = 1;
3038 } else if (system == WLAN_AUTH_SHARED_KEY) {
3039 if (trans_seq_no == 0x0002 &&
3040 auth->el_id == WLAN_EID_CHALLENGE) {
3041 send_authentication_request(priv, system, auth->chall_text, auth->chall_text_len);
3043 } else if (trans_seq_no == 0x0004) {
3044 should_associate = 1;
3048 if (should_associate) {
3049 if (priv->station_was_associated) {
3050 atmel_enter_state(priv, STATION_STATE_REASSOCIATING);
3051 send_association_request(priv, 1);
3054 atmel_enter_state(priv, STATION_STATE_ASSOCIATING);
3055 send_association_request(priv, 0);
3061 if (status == WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG) {
3062 /* Flip back and forth between WEP auth modes until the max
3063 * authentication tries has been exceeded.
3065 if (system == WLAN_AUTH_OPEN) {
3066 priv->CurrentAuthentTransactionSeqNum = 0x001;
3067 priv->exclude_unencrypted = 1;
3068 send_authentication_request(priv, WLAN_AUTH_SHARED_KEY, NULL, 0);
3070 } else if (system == WLAN_AUTH_SHARED_KEY
3071 && priv->wep_is_on) {
3072 priv->CurrentAuthentTransactionSeqNum = 0x001;
3073 priv->exclude_unencrypted = 0;
3074 send_authentication_request(priv, WLAN_AUTH_OPEN, NULL, 0);
3076 } else if (priv->connect_to_any_BSS) {
3079 priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80;
3081 if ((bss_index = retrieve_bss(priv)) != -1) {
3082 atmel_join_bss(priv, bss_index);
3088 priv->AuthenticationRequestRetryCnt = 0;
3089 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3090 priv->station_is_associated = 0;
3093 static void associate(struct atmel_private *priv, u16 frame_len, u16 subtype)
3095 struct ass_resp_format {
3102 } *ass_resp = (struct ass_resp_format *)priv->rx_buf;
3104 u16 status = le16_to_cpu(ass_resp->status);
3105 u16 ass_id = le16_to_cpu(ass_resp->ass_id);
3106 u16 rates_len = ass_resp->length > 4 ? 4 : ass_resp->length;
3108 union iwreq_data wrqu;
3110 if (frame_len < 8 + rates_len)
3113 if (status == WLAN_STATUS_SUCCESS) {
3114 if (subtype == IEEE80211_STYPE_ASSOC_RESP)
3115 priv->AssociationRequestRetryCnt = 0;
3117 priv->ReAssociationRequestRetryCnt = 0;
3119 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type,
3120 MAC_MGMT_MIB_STATION_ID_POS, ass_id & 0x3fff);
3121 atmel_set_mib(priv, Phy_Mib_Type,
3122 PHY_MIB_RATE_SET_POS, ass_resp->rates, rates_len);
3123 if (priv->power_mode == 0) {
3124 priv->listen_interval = 1;
3125 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type,
3126 MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE);
3127 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type,
3128 MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1);
3130 priv->listen_interval = 2;
3131 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type,
3132 MAC_MGMT_MIB_PS_MODE_POS, PS_MODE);
3133 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type,
3134 MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 2);
3137 priv->station_is_associated = 1;
3138 priv->station_was_associated = 1;
3139 atmel_enter_state(priv, STATION_STATE_READY);
3141 /* Send association event to userspace */
3142 wrqu.data.length = 0;
3143 wrqu.data.flags = 0;
3144 memcpy(wrqu.ap_addr.sa_data, priv->CurrentBSSID, ETH_ALEN);
3145 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
3146 wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
3151 if (subtype == IEEE80211_STYPE_ASSOC_RESP &&
3152 status != WLAN_STATUS_ASSOC_DENIED_RATES &&
3153 status != WLAN_STATUS_CAPS_UNSUPPORTED &&
3154 priv->AssociationRequestRetryCnt < MAX_ASSOCIATION_RETRIES) {
3155 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3156 priv->AssociationRequestRetryCnt++;
3157 send_association_request(priv, 0);
3161 if (subtype == IEEE80211_STYPE_REASSOC_RESP &&
3162 status != WLAN_STATUS_ASSOC_DENIED_RATES &&
3163 status != WLAN_STATUS_CAPS_UNSUPPORTED &&
3164 priv->ReAssociationRequestRetryCnt < MAX_ASSOCIATION_RETRIES) {
3165 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3166 priv->ReAssociationRequestRetryCnt++;
3167 send_association_request(priv, 1);
3171 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3172 priv->station_is_associated = 0;
3174 if (priv->connect_to_any_BSS) {
3176 priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80;
3178 if ((bss_index = retrieve_bss(priv)) != -1)
3179 atmel_join_bss(priv, bss_index);
3183 static void atmel_join_bss(struct atmel_private *priv, int bss_index)
3185 struct bss_info *bss = &priv->BSSinfo[bss_index];
3187 memcpy(priv->CurrentBSSID, bss->BSSID, ETH_ALEN);
3188 memcpy(priv->SSID, bss->SSID, priv->SSID_size = bss->SSIDsize);
3190 /* The WPA stuff cares about the current AP address */
3192 build_wpa_mib(priv);
3194 /* When switching to AdHoc turn OFF Power Save if needed */
3196 if (bss->BSStype == IW_MODE_ADHOC &&
3197 priv->operating_mode != IW_MODE_ADHOC &&
3199 priv->power_mode = 0;
3200 priv->listen_interval = 1;
3201 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type,
3202 MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE);
3203 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type,
3204 MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1);
3207 priv->operating_mode = bss->BSStype;
3208 priv->channel = bss->channel & 0x7f;
3209 priv->beacon_period = bss->beacon_period;
3211 if (priv->preamble != bss->preamble) {
3212 priv->preamble = bss->preamble;
3213 atmel_set_mib8(priv, Local_Mib_Type,
3214 LOCAL_MIB_PREAMBLE_TYPE, bss->preamble);
3217 if (!priv->wep_is_on && bss->UsingWEP) {
3218 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3219 priv->station_is_associated = 0;
3223 if (priv->wep_is_on && !bss->UsingWEP) {
3224 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3225 priv->station_is_associated = 0;
3229 atmel_enter_state(priv, STATION_STATE_JOINNING);
3231 if (priv->operating_mode == IW_MODE_INFRA)
3232 join(priv, BSS_TYPE_INFRASTRUCTURE);
3234 join(priv, BSS_TYPE_AD_HOC);
3237 static void restart_search(struct atmel_private *priv)
3241 if (!priv->connect_to_any_BSS) {
3242 atmel_scan(priv, 1);
3244 priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80;
3246 if ((bss_index = retrieve_bss(priv)) != -1)
3247 atmel_join_bss(priv, bss_index);
3249 atmel_scan(priv, 0);
3253 static void smooth_rssi(struct atmel_private *priv, u8 rssi)
3255 u8 old = priv->wstats.qual.level;
3256 u8 max_rssi = 42; /* 502-rmfd-revd max by experiment, default for now */
3258 switch (priv->firmware_type) {
3259 case ATMEL_FW_TYPE_502E:
3260 max_rssi = 63; /* 502-rmfd-reve max by experiment */
3266 rssi = rssi * 100 / max_rssi;
3267 if ((rssi + old) % 2)
3268 priv->wstats.qual.level = (rssi + old) / 2 + 1;
3270 priv->wstats.qual.level = (rssi + old) / 2;
3271 priv->wstats.qual.updated |= IW_QUAL_LEVEL_UPDATED;
3272 priv->wstats.qual.updated &= ~IW_QUAL_LEVEL_INVALID;
3275 static void atmel_smooth_qual(struct atmel_private *priv)
3277 unsigned long time_diff = (jiffies - priv->last_qual) / HZ;
3278 while (time_diff--) {
3279 priv->last_qual += HZ;
3280 priv->wstats.qual.qual = priv->wstats.qual.qual / 2;
3281 priv->wstats.qual.qual +=
3282 priv->beacons_this_sec * priv->beacon_period * (priv->wstats.qual.level + 100) / 4000;
3283 priv->beacons_this_sec = 0;
3285 priv->wstats.qual.updated |= IW_QUAL_QUAL_UPDATED;
3286 priv->wstats.qual.updated &= ~IW_QUAL_QUAL_INVALID;
3289 /* deals with incoming management frames. */
3290 static void atmel_management_frame(struct atmel_private *priv,
3291 struct ieee80211_hdr *header,
3292 u16 frame_len, u8 rssi)
3296 subtype = le16_to_cpu(header->frame_control) & IEEE80211_FCTL_STYPE;
3298 case IEEE80211_STYPE_BEACON:
3299 case IEEE80211_STYPE_PROBE_RESP:
3301 /* beacon frame has multiple variable-length fields -
3302 never let an engineer loose with a data structure design. */
3304 struct beacon_format {
3317 } *beacon = (struct beacon_format *)priv->rx_buf;
3319 u8 channel, rates_length, ssid_length;
3320 u64 timestamp = le64_to_cpu(beacon->timestamp);
3321 u16 beacon_interval = le16_to_cpu(beacon->interval);
3322 u16 capability = le16_to_cpu(beacon->capability);
3323 u8 *beaconp = priv->rx_buf;
3324 ssid_length = beacon->ssid_length;
3325 /* this blows chunks. */
3326 if (frame_len < 14 || frame_len < ssid_length + 15)
3328 rates_length = beaconp[beacon->ssid_length + 15];
3329 if (frame_len < ssid_length + rates_length + 18)
3331 if (ssid_length > MAX_SSID_LENGTH)
3333 channel = beaconp[ssid_length + rates_length + 18];
3335 if (priv->station_state == STATION_STATE_READY) {
3336 smooth_rssi(priv, rssi);
3337 if (is_frame_from_current_bss(priv, header)) {
3338 priv->beacons_this_sec++;
3339 atmel_smooth_qual(priv);
3340 if (priv->last_beacon_timestamp) {
3341 /* Note truncate this to 32 bits - kernel can't divide a long long */
3342 u32 beacon_delay = timestamp - priv->last_beacon_timestamp;
3343 int beacons = beacon_delay / (beacon_interval * 1000);
3345 priv->wstats.miss.beacon += beacons - 1;
3347 priv->last_beacon_timestamp = timestamp;
3348 handle_beacon_probe(priv, capability, channel);
3352 if (priv->station_state == STATION_STATE_SCANNING)
3353 store_bss_info(priv, header, capability,
3354 beacon_interval, channel, rssi,
3356 &beacon->rates_el_id,
3357 subtype == IEEE80211_STYPE_BEACON);
3361 case IEEE80211_STYPE_AUTH:
3363 if (priv->station_state == STATION_STATE_AUTHENTICATING)
3364 authenticate(priv, frame_len);
3368 case IEEE80211_STYPE_ASSOC_RESP:
3369 case IEEE80211_STYPE_REASSOC_RESP:
3371 if (priv->station_state == STATION_STATE_ASSOCIATING ||
3372 priv->station_state == STATION_STATE_REASSOCIATING)
3373 associate(priv, frame_len, subtype);
3377 case IEEE80211_STYPE_DISASSOC:
3378 if (priv->station_is_associated &&
3379 priv->operating_mode == IW_MODE_INFRA &&
3380 is_frame_from_current_bss(priv, header)) {
3381 priv->station_was_associated = 0;
3382 priv->station_is_associated = 0;
3384 atmel_enter_state(priv, STATION_STATE_JOINNING);
3385 join(priv, BSS_TYPE_INFRASTRUCTURE);
3390 case IEEE80211_STYPE_DEAUTH:
3391 if (priv->operating_mode == IW_MODE_INFRA &&
3392 is_frame_from_current_bss(priv, header)) {
3393 priv->station_was_associated = 0;
3395 atmel_enter_state(priv, STATION_STATE_JOINNING);
3396 join(priv, BSS_TYPE_INFRASTRUCTURE);
3403 /* run when timer expires */
3404 static void atmel_management_timer(struct timer_list *t)
3406 struct atmel_private *priv = from_timer(priv, t, management_timer);
3407 unsigned long flags;
3409 /* Check if the card has been yanked. */
3410 if (priv->card && priv->present_callback &&
3411 !(*priv->present_callback)(priv->card))
3414 spin_lock_irqsave(&priv->irqlock, flags);
3416 switch (priv->station_state) {
3418 case STATION_STATE_AUTHENTICATING:
3419 if (priv->AuthenticationRequestRetryCnt >= MAX_AUTHENTICATION_RETRIES) {
3420 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3421 priv->station_is_associated = 0;
3422 priv->AuthenticationRequestRetryCnt = 0;
3423 restart_search(priv);
3425 int auth = WLAN_AUTH_OPEN;
3426 priv->AuthenticationRequestRetryCnt++;
3427 priv->CurrentAuthentTransactionSeqNum = 0x0001;
3428 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3429 if (priv->wep_is_on && priv->exclude_unencrypted)
3430 auth = WLAN_AUTH_SHARED_KEY;
3431 send_authentication_request(priv, auth, NULL, 0);
3435 case STATION_STATE_ASSOCIATING:
3436 if (priv->AssociationRequestRetryCnt == MAX_ASSOCIATION_RETRIES) {
3437 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3438 priv->station_is_associated = 0;
3439 priv->AssociationRequestRetryCnt = 0;
3440 restart_search(priv);
3442 priv->AssociationRequestRetryCnt++;
3443 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3444 send_association_request(priv, 0);
3448 case STATION_STATE_REASSOCIATING:
3449 if (priv->ReAssociationRequestRetryCnt == MAX_ASSOCIATION_RETRIES) {
3450 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3451 priv->station_is_associated = 0;
3452 priv->ReAssociationRequestRetryCnt = 0;
3453 restart_search(priv);
3455 priv->ReAssociationRequestRetryCnt++;
3456 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3457 send_association_request(priv, 1);
3465 spin_unlock_irqrestore(&priv->irqlock, flags);
3468 static void atmel_command_irq(struct atmel_private *priv)
3470 u8 status = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET));
3471 u8 command = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_COMMAND_OFFSET));
3473 union iwreq_data wrqu;
3475 if (status == CMD_STATUS_IDLE ||
3476 status == CMD_STATUS_IN_PROGRESS)
3481 if (status == CMD_STATUS_COMPLETE) {
3482 priv->station_was_associated = priv->station_is_associated;
3483 atmel_get_mib(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_CUR_BSSID_POS,
3484 (u8 *)priv->CurrentBSSID, 6);
3485 atmel_enter_state(priv, STATION_STATE_READY);
3490 fast_scan = priv->fast_scan;
3491 priv->fast_scan = 0;
3493 if (status != CMD_STATUS_COMPLETE) {
3494 atmel_scan(priv, 1);
3496 int bss_index = retrieve_bss(priv);
3497 int notify_scan_complete = 1;
3498 if (bss_index != -1) {
3499 atmel_join_bss(priv, bss_index);
3500 } else if (priv->operating_mode == IW_MODE_ADHOC &&
3501 priv->SSID_size != 0) {
3502 start(priv, BSS_TYPE_AD_HOC);
3504 priv->fast_scan = !fast_scan;
3505 atmel_scan(priv, 1);
3506 notify_scan_complete = 0;
3508 priv->site_survey_state = SITE_SURVEY_COMPLETED;
3509 if (notify_scan_complete) {
3510 wrqu.data.length = 0;
3511 wrqu.data.flags = 0;
3512 wireless_send_event(priv->dev, SIOCGIWSCAN, &wrqu, NULL);
3517 case CMD_SiteSurvey:
3518 priv->fast_scan = 0;
3520 if (status != CMD_STATUS_COMPLETE)
3523 priv->site_survey_state = SITE_SURVEY_COMPLETED;
3524 if (priv->station_is_associated) {
3525 atmel_enter_state(priv, STATION_STATE_READY);
3526 wrqu.data.length = 0;
3527 wrqu.data.flags = 0;
3528 wireless_send_event(priv->dev, SIOCGIWSCAN, &wrqu, NULL);
3530 atmel_scan(priv, 1);
3535 if (status == CMD_STATUS_COMPLETE) {
3536 if (priv->operating_mode == IW_MODE_ADHOC) {
3537 priv->station_was_associated = priv->station_is_associated;
3538 atmel_enter_state(priv, STATION_STATE_READY);
3540 int auth = WLAN_AUTH_OPEN;
3541 priv->AuthenticationRequestRetryCnt = 0;
3542 atmel_enter_state(priv, STATION_STATE_AUTHENTICATING);
3544 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3545 priv->CurrentAuthentTransactionSeqNum = 0x0001;
3546 if (priv->wep_is_on && priv->exclude_unencrypted)
3547 auth = WLAN_AUTH_SHARED_KEY;
3548 send_authentication_request(priv, auth, NULL, 0);
3553 atmel_scan(priv, 1);
3557 static int atmel_wakeup_firmware(struct atmel_private *priv)
3559 struct host_info_struct *iface = &priv->host_info;
3563 if (priv->card_type == CARD_TYPE_SPI_FLASH)
3564 atmel_set_gcr(priv->dev, GCR_REMAP);
3566 /* wake up on-board processor */
3567 atmel_clear_gcr(priv->dev, 0x0040);
3568 atmel_write16(priv->dev, BSR, BSS_SRAM);
3570 if (priv->card_type == CARD_TYPE_SPI_FLASH)
3573 /* and wait for it */
3574 for (i = LOOP_RETRY_LIMIT; i; i--) {
3575 mr1 = atmel_read16(priv->dev, MR1);
3576 mr3 = atmel_read16(priv->dev, MR3);
3578 if (mr3 & MAC_BOOT_COMPLETE)
3580 if (mr1 & MAC_BOOT_COMPLETE &&
3581 priv->bus_type == BUS_TYPE_PCCARD)
3586 printk(KERN_ALERT "%s: MAC failed to boot.\n", priv->dev->name);
3590 if ((priv->host_info_base = atmel_read16(priv->dev, MR2)) == 0xffff) {
3591 printk(KERN_ALERT "%s: card missing.\n", priv->dev->name);
3595 /* now check for completion of MAC initialization through
3596 the FunCtrl field of the IFACE, poll MR1 to detect completion of
3597 MAC initialization, check completion status, set interrupt mask,
3598 enables interrupts and calls Tx and Rx initialization functions */
3600 atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET), FUNC_CTRL_INIT_COMPLETE);
3602 for (i = LOOP_RETRY_LIMIT; i; i--) {
3603 mr1 = atmel_read16(priv->dev, MR1);
3604 mr3 = atmel_read16(priv->dev, MR3);
3606 if (mr3 & MAC_INIT_COMPLETE)
3608 if (mr1 & MAC_INIT_COMPLETE &&
3609 priv->bus_type == BUS_TYPE_PCCARD)
3614 printk(KERN_ALERT "%s: MAC failed to initialise.\n",
3619 /* Check for MAC_INIT_OK only on the register that the MAC_INIT_OK was set */
3620 if ((mr3 & MAC_INIT_COMPLETE) &&
3621 !(atmel_read16(priv->dev, MR3) & MAC_INIT_OK)) {
3622 printk(KERN_ALERT "%s: MAC failed MR3 self-test.\n", priv->dev->name);
3625 if ((mr1 & MAC_INIT_COMPLETE) &&
3626 !(atmel_read16(priv->dev, MR1) & MAC_INIT_OK)) {
3627 printk(KERN_ALERT "%s: MAC failed MR1 self-test.\n", priv->dev->name);
3631 atmel_copy_to_host(priv->dev, (unsigned char *)iface,
3632 priv->host_info_base, sizeof(*iface));
3634 iface->tx_buff_pos = le16_to_cpu(iface->tx_buff_pos);
3635 iface->tx_buff_size = le16_to_cpu(iface->tx_buff_size);
3636 iface->tx_desc_pos = le16_to_cpu(iface->tx_desc_pos);
3637 iface->tx_desc_count = le16_to_cpu(iface->tx_desc_count);
3638 iface->rx_buff_pos = le16_to_cpu(iface->rx_buff_pos);
3639 iface->rx_buff_size = le16_to_cpu(iface->rx_buff_size);
3640 iface->rx_desc_pos = le16_to_cpu(iface->rx_desc_pos);
3641 iface->rx_desc_count = le16_to_cpu(iface->rx_desc_count);
3642 iface->build_version = le16_to_cpu(iface->build_version);
3643 iface->command_pos = le16_to_cpu(iface->command_pos);
3644 iface->major_version = le16_to_cpu(iface->major_version);
3645 iface->minor_version = le16_to_cpu(iface->minor_version);
3646 iface->func_ctrl = le16_to_cpu(iface->func_ctrl);
3647 iface->mac_status = le16_to_cpu(iface->mac_status);
3652 /* determine type of memory and MAC address */
3653 static int probe_atmel_card(struct net_device *dev)
3656 struct atmel_private *priv = netdev_priv(dev);
3657 u8 addr[ETH_ALEN] = {};
3660 if (priv->bus_type == BUS_TYPE_PCCARD)
3661 atmel_write16(dev, GCR, 0x0060);
3663 atmel_write16(dev, GCR, 0x0040);
3666 if (atmel_read16(dev, MR2) == 0) {
3667 /* No stored firmware so load a small stub which just
3668 tells us the MAC address */
3670 priv->card_type = CARD_TYPE_EEPROM;
3671 atmel_write16(dev, BSR, BSS_IRAM);
3672 atmel_copy_to_card(dev, 0, mac_reader, sizeof(mac_reader));
3673 atmel_set_gcr(dev, GCR_REMAP);
3674 atmel_clear_gcr(priv->dev, 0x0040);
3675 atmel_write16(dev, BSR, BSS_SRAM);
3676 for (i = LOOP_RETRY_LIMIT; i; i--)
3677 if (atmel_read16(dev, MR3) & MAC_BOOT_COMPLETE)
3680 printk(KERN_ALERT "%s: MAC failed to boot MAC address reader.\n", dev->name);
3683 atmel_copy_to_host(dev, addr, atmel_read16(dev, MR2), 6);
3684 eth_hw_addr_set(dev, addr);
3685 /* got address, now squash it again until the network
3686 interface is opened */
3687 if (priv->bus_type == BUS_TYPE_PCCARD)
3688 atmel_write16(dev, GCR, 0x0060);
3689 atmel_write16(dev, GCR, 0x0040);
3692 } else if (atmel_read16(dev, MR4) == 0) {
3693 /* Mac address easy in this case. */
3694 priv->card_type = CARD_TYPE_PARALLEL_FLASH;
3695 atmel_write16(dev, BSR, 1);
3696 atmel_copy_to_host(dev, addr, 0xc000, 6);
3697 eth_hw_addr_set(dev, addr);
3698 atmel_write16(dev, BSR, 0x200);
3701 /* Standard firmware in flash, boot it up and ask
3702 for the Mac Address */
3703 priv->card_type = CARD_TYPE_SPI_FLASH;
3704 if (atmel_wakeup_firmware(priv) == 0) {
3705 atmel_get_mib(priv, Mac_Address_Mib_Type, 0, addr, 6);
3706 eth_hw_addr_set(dev, addr);
3708 /* got address, now squash it again until the network
3709 interface is opened */
3710 if (priv->bus_type == BUS_TYPE_PCCARD)
3711 atmel_write16(dev, GCR, 0x0060);
3712 atmel_write16(dev, GCR, 0x0040);
3718 if (dev->dev_addr[0] == 0xFF) {
3719 static const u8 default_mac[] = {
3720 0x00, 0x04, 0x25, 0x00, 0x00, 0x00
3722 printk(KERN_ALERT "%s: *** Invalid MAC address. UPGRADE Firmware ****\n", dev->name);
3723 eth_hw_addr_set(dev, default_mac);
3730 /* Move the encyption information on the MIB structure.
3731 This routine is for the pre-WPA firmware: later firmware has
3732 a different format MIB and a different routine. */
3733 static void build_wep_mib(struct atmel_private *priv)
3735 struct { /* NB this is matched to the hardware, don't change. */
3737 u8 default_key; /* 0..3 */
3739 u8 exclude_unencrypted;
3741 u32 WEPICV_error_count;
3742 u32 WEP_excluded_count;
3744 u8 wep_keys[MAX_ENCRYPTION_KEYS][13];
3745 u8 encryption_level; /* 0, 1, 2 */
3750 mib.wep_is_on = priv->wep_is_on;
3751 if (priv->wep_is_on) {
3752 if (priv->wep_key_len[priv->default_key] > 5)
3753 mib.encryption_level = 2;
3755 mib.encryption_level = 1;
3757 mib.encryption_level = 0;
3760 mib.default_key = priv->default_key;
3761 mib.exclude_unencrypted = priv->exclude_unencrypted;
3763 for (i = 0; i < MAX_ENCRYPTION_KEYS; i++)
3764 memcpy(mib.wep_keys[i], priv->wep_keys[i], 13);
3766 atmel_set_mib(priv, Mac_Wep_Mib_Type, 0, (u8 *)&mib, sizeof(mib));
3769 static void build_wpa_mib(struct atmel_private *priv)
3771 /* This is for the later (WPA enabled) firmware. */
3773 struct { /* NB this is matched to the hardware, don't change. */
3774 u8 cipher_default_key_value[MAX_ENCRYPTION_KEYS][MAX_ENCRYPTION_KEY_SIZE];
3775 u8 receiver_address[ETH_ALEN];
3777 u8 default_key; /* 0..3 */
3779 u8 exclude_unencrypted;
3783 u32 WEPICV_error_count;
3784 u32 WEP_excluded_count;
3791 mib.wep_is_on = priv->wep_is_on;
3792 mib.exclude_unencrypted = priv->exclude_unencrypted;
3793 memcpy(mib.receiver_address, priv->CurrentBSSID, ETH_ALEN);
3795 /* zero all the keys before adding in valid ones. */
3796 memset(mib.cipher_default_key_value, 0, sizeof(mib.cipher_default_key_value));
3798 if (priv->wep_is_on) {
3799 /* There's a comment in the Atmel code to the effect that this
3800 is only valid when still using WEP, it may need to be set to
3801 something to use WPA */
3802 memset(mib.key_RSC, 0, sizeof(mib.key_RSC));
3804 mib.default_key = mib.group_key = 255;
3805 for (i = 0; i < MAX_ENCRYPTION_KEYS; i++) {
3806 if (priv->wep_key_len[i] > 0) {
3807 memcpy(mib.cipher_default_key_value[i], priv->wep_keys[i], MAX_ENCRYPTION_KEY_SIZE);
3808 if (i == priv->default_key) {
3809 mib.default_key = i;
3810 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-1] = 7;
3811 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-2] = priv->pairwise_cipher_suite;
3814 priv->group_cipher_suite = priv->pairwise_cipher_suite;
3815 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-1] = 1;
3816 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-2] = priv->group_cipher_suite;
3820 if (mib.default_key == 255)
3821 mib.default_key = mib.group_key != 255 ? mib.group_key : 0;
3822 if (mib.group_key == 255)
3823 mib.group_key = mib.default_key;
3827 atmel_set_mib(priv, Mac_Wep_Mib_Type, 0, (u8 *)&mib, sizeof(mib));
3830 static int reset_atmel_card(struct net_device *dev)
3832 /* do everything necessary to wake up the hardware, including
3833 waiting for the lightning strike and throwing the knife switch....
3835 set all the Mib values which matter in the card to match
3836 their settings in the atmel_private structure. Some of these
3837 can be altered on the fly, but many (WEP, infrastructure or ad-hoc)
3838 can only be changed by tearing down the world and coming back through
3841 This routine is also responsible for initialising some
3842 hardware-specific fields in the atmel_private structure,
3843 including a copy of the firmware's hostinfo structure
3844 which is the route into the rest of the firmware datastructures. */
3846 struct atmel_private *priv = netdev_priv(dev);
3848 int old_state = priv->station_state;
3851 /* data to add to the firmware names, in priority order
3852 this implemenents firmware versioning */
3854 static char *firmware_modifier[] = {
3861 if (priv->bus_type == BUS_TYPE_PCCARD)
3862 atmel_write16(priv->dev, GCR, 0x0060);
3864 /* stop card , disable interrupts */
3865 atmel_write16(priv->dev, GCR, 0x0040);
3867 if (priv->card_type == CARD_TYPE_EEPROM) {
3868 /* copy in firmware if needed */
3869 const struct firmware *fw_entry = NULL;
3870 const unsigned char *fw;
3871 int len = priv->firmware_length;
3872 if (!(fw = priv->firmware)) {
3873 if (priv->firmware_type == ATMEL_FW_TYPE_NONE) {
3874 if (strlen(priv->firmware_id) == 0) {
3876 "%s: card type is unknown: assuming at76c502 firmware is OK.\n",
3879 "%s: if not, use the firmware= module parameter.\n",
3881 strcpy(priv->firmware_id, "/*(DEBLOBBED)*/");
3883 err = reject_firmware(&fw_entry, priv->firmware_id, priv->sys_dev);
3886 "%s: firmware %s is missing, cannot continue.\n",
3887 dev->name, priv->firmware_id);
3894 /* get firmware filename entry based on firmware type ID */
3895 while (fw_table[fw_index].fw_type != priv->firmware_type
3896 && fw_table[fw_index].fw_type != ATMEL_FW_TYPE_NONE)
3899 /* construct the actual firmware file name */
3900 if (fw_table[fw_index].fw_type != ATMEL_FW_TYPE_NONE) {
3902 for (i = 0; firmware_modifier[i]; i++) {
3903 snprintf(priv->firmware_id, 32, "%s%s.%s", fw_table[fw_index].fw_file,
3904 firmware_modifier[i], fw_table[fw_index].fw_file_ext);
3905 priv->firmware_id[31] = '\0';
3906 if (reject_firmware(&fw_entry, priv->firmware_id, priv->sys_dev) == 0) {
3914 "%s: firmware %s is missing, cannot start.\n",
3915 dev->name, priv->firmware_id);
3916 priv->firmware_id[0] = '\0';
3921 fw = fw_entry->data;
3922 len = fw_entry->size;
3925 if (len <= 0x6000) {
3926 atmel_write16(priv->dev, BSR, BSS_IRAM);
3927 atmel_copy_to_card(priv->dev, 0, fw, len);
3928 atmel_set_gcr(priv->dev, GCR_REMAP);
3931 atmel_set_gcr(priv->dev, GCR_REMAP);
3932 atmel_write16(priv->dev, BSR, BSS_IRAM);
3933 atmel_copy_to_card(priv->dev, 0, fw, 0x6000);
3934 atmel_write16(priv->dev, BSR, 0x2ff);
3935 atmel_copy_to_card(priv->dev, 0x8000, &fw[0x6000], len - 0x6000);
3938 release_firmware(fw_entry);
3941 err = atmel_wakeup_firmware(priv);
3945 /* Check the version and set the correct flag for wpa stuff,
3946 old and new firmware is incompatible.
3947 The pre-wpa 3com firmware reports major version 5,
3948 the wpa 3com firmware is major version 4 and doesn't need
3949 the 3com broken-ness filter. */
3950 priv->use_wpa = (priv->host_info.major_version == 4);
3951 priv->radio_on_broken = (priv->host_info.major_version == 5);
3953 /* unmask all irq sources */
3954 atmel_wmem8(priv, atmel_hi(priv, IFACE_INT_MASK_OFFSET), 0xff);
3956 /* int Tx system and enable Tx */
3957 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, 0), 0);
3958 atmel_wmem32(priv, atmel_tx(priv, TX_DESC_NEXT_OFFSET, 0), 0x80000000L);
3959 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_POS_OFFSET, 0), 0);
3960 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, 0), 0);
3962 priv->tx_desc_free = priv->host_info.tx_desc_count;
3963 priv->tx_desc_head = 0;
3964 priv->tx_desc_tail = 0;
3965 priv->tx_desc_previous = 0;
3966 priv->tx_free_mem = priv->host_info.tx_buff_size;
3967 priv->tx_buff_head = 0;
3968 priv->tx_buff_tail = 0;
3970 configuration = atmel_rmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET));
3971 atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET),
3972 configuration | FUNC_CTRL_TxENABLE);
3974 /* init Rx system and enable */
3975 priv->rx_desc_head = 0;
3977 configuration = atmel_rmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET));
3978 atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET),
3979 configuration | FUNC_CTRL_RxENABLE);
3981 if (!priv->radio_on_broken) {
3982 if (atmel_send_command_wait(priv, CMD_EnableRadio, NULL, 0) ==
3983 CMD_STATUS_REJECTED_RADIO_OFF) {
3984 printk(KERN_INFO "%s: cannot turn the radio on.\n",
3990 /* set up enough MIB values to run. */
3991 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_AUTO_TX_RATE_POS, priv->auto_tx_rate);
3992 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_TX_PROMISCUOUS_POS, PROM_MODE_OFF);
3993 atmel_set_mib16(priv, Mac_Mib_Type, MAC_MIB_RTS_THRESHOLD_POS, priv->rts_threshold);
3994 atmel_set_mib16(priv, Mac_Mib_Type, MAC_MIB_FRAG_THRESHOLD_POS, priv->frag_threshold);
3995 atmel_set_mib8(priv, Mac_Mib_Type, MAC_MIB_SHORT_RETRY_POS, priv->short_retry);
3996 atmel_set_mib8(priv, Mac_Mib_Type, MAC_MIB_LONG_RETRY_POS, priv->long_retry);
3997 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_PREAMBLE_TYPE, priv->preamble);
3998 atmel_set_mib(priv, Mac_Address_Mib_Type, MAC_ADDR_MIB_MAC_ADDR_POS,
3999 priv->dev->dev_addr, 6);
4000 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE);
4001 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1);
4002 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_BEACON_PER_POS, priv->default_beacon_period);
4003 atmel_set_mib(priv, Phy_Mib_Type, PHY_MIB_RATE_SET_POS, atmel_basic_rates, 4);
4004 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_CUR_PRIVACY_POS, priv->wep_is_on);
4006 build_wpa_mib(priv);
4008 build_wep_mib(priv);
4010 if (old_state == STATION_STATE_READY) {
4011 union iwreq_data wrqu;
4013 wrqu.data.length = 0;
4014 wrqu.data.flags = 0;
4015 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
4016 eth_zero_addr(wrqu.ap_addr.sa_data);
4017 wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
4023 static void atmel_send_command(struct atmel_private *priv, int command,
4024 void *cmd, int cmd_size)
4027 atmel_copy_to_card(priv->dev, atmel_co(priv, CMD_BLOCK_PARAMETERS_OFFSET),
4030 atmel_wmem8(priv, atmel_co(priv, CMD_BLOCK_COMMAND_OFFSET), command);
4031 atmel_wmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET), 0);
4034 static int atmel_send_command_wait(struct atmel_private *priv, int command,
4035 void *cmd, int cmd_size)
4039 atmel_send_command(priv, command, cmd, cmd_size);
4041 for (i = 5000; i; i--) {
4042 status = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET));
4043 if (status != CMD_STATUS_IDLE &&
4044 status != CMD_STATUS_IN_PROGRESS)
4050 printk(KERN_ALERT "%s: failed to contact MAC.\n", priv->dev->name);
4051 status = CMD_STATUS_HOST_ERROR;
4053 if (command != CMD_EnableRadio)
4054 status = CMD_STATUS_COMPLETE;
4060 static u8 atmel_get_mib8(struct atmel_private *priv, u8 type, u8 index)
4062 struct get_set_mib m;
4067 atmel_send_command_wait(priv, CMD_Get_MIB_Vars, &m, MIB_HEADER_SIZE + 1);
4068 return atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_PARAMETERS_OFFSET + MIB_HEADER_SIZE));
4071 static void atmel_set_mib8(struct atmel_private *priv, u8 type, u8 index, u8 data)
4073 struct get_set_mib m;
4079 atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + 1);
4082 static void atmel_set_mib16(struct atmel_private *priv, u8 type, u8 index,
4085 struct get_set_mib m;
4090 m.data[1] = data >> 8;
4092 atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + 2);
4095 static void atmel_set_mib(struct atmel_private *priv, u8 type, u8 index,
4096 const u8 *data, int data_len)
4098 struct get_set_mib m;
4103 if (data_len > MIB_MAX_DATA_BYTES)
4104 printk(KERN_ALERT "%s: MIB buffer too small.\n", priv->dev->name);
4106 memcpy(m.data, data, data_len);
4107 atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + data_len);
4110 static void atmel_get_mib(struct atmel_private *priv, u8 type, u8 index,
4111 u8 *data, int data_len)
4113 struct get_set_mib m;
4118 if (data_len > MIB_MAX_DATA_BYTES)
4119 printk(KERN_ALERT "%s: MIB buffer too small.\n", priv->dev->name);
4121 atmel_send_command_wait(priv, CMD_Get_MIB_Vars, &m, MIB_HEADER_SIZE + data_len);
4122 atmel_copy_to_host(priv->dev, data,
4123 atmel_co(priv, CMD_BLOCK_PARAMETERS_OFFSET + MIB_HEADER_SIZE), data_len);
4126 static void atmel_writeAR(struct net_device *dev, u16 data)
4129 outw(data, dev->base_addr + AR);
4130 /* Address register appears to need some convincing..... */
4131 for (i = 0; data != inw(dev->base_addr + AR) && i < 10; i++)
4132 outw(data, dev->base_addr + AR);
4135 static void atmel_copy_to_card(struct net_device *dev, u16 dest,
4136 const unsigned char *src, u16 len)
4139 atmel_writeAR(dev, dest);
4141 atmel_write8(dev, DR, *src);
4144 for (i = len; i > 1 ; i -= 2) {
4147 atmel_write16(dev, DR, lb | (hb << 8));
4150 atmel_write8(dev, DR, *src);
4153 static void atmel_copy_to_host(struct net_device *dev, unsigned char *dest,
4157 atmel_writeAR(dev, src);
4159 *dest = atmel_read8(dev, DR);
4162 for (i = len; i > 1 ; i -= 2) {
4163 u16 hw = atmel_read16(dev, DR);
4168 *dest = atmel_read8(dev, DR);
4171 static void atmel_set_gcr(struct net_device *dev, u16 mask)
4173 outw(inw(dev->base_addr + GCR) | mask, dev->base_addr + GCR);
4176 static void atmel_clear_gcr(struct net_device *dev, u16 mask)
4178 outw(inw(dev->base_addr + GCR) & ~mask, dev->base_addr + GCR);
4181 static int atmel_lock_mac(struct atmel_private *priv)
4185 for (i = 5000; i; i--) {
4186 if (!atmel_rmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_HOST_OFFSET)))
4192 return 0; /* timed out */
4194 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 1);
4195 if (atmel_rmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_HOST_OFFSET))) {
4196 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0);
4198 return 0; /* timed out */
4205 static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data)
4207 atmel_writeAR(priv->dev, pos);
4208 atmel_write16(priv->dev, DR, data); /* card is little-endian */
4209 atmel_write16(priv->dev, DR, data >> 16);
4212 /***************************************************************************/
4213 /* There follows the source form of the MAC address reading firmware */
4214 /***************************************************************************/
4217 /* Copyright 2003 Matthew T. Russotto */
4218 /* But derived from the Atmel 76C502 firmware written by Atmel and */
4219 /* included in "atmel wireless lan drivers" package */
4221 This file is part of net.russotto.AtmelMACFW, hereto referred to
4224 AtmelMACFW is free software; you can redistribute it and/or modify
4225 it under the terms of the GNU General Public License version 2
4226 as published by the Free Software Foundation.
4228 AtmelMACFW is distributed in the hope that it will be useful,
4229 but WITHOUT ANY WARRANTY; without even the implied warranty of
4230 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4231 GNU General Public License for more details.
4233 You should have received a copy of the GNU General Public License
4234 along with AtmelMACFW; if not, see <http://www.gnu.org/licenses/>.
4236 ****************************************************************************/
4237 /* This firmware should work on the 76C502 RFMD, RFMD_D, and RFMD_E */
4238 /* It will probably work on the 76C504 and 76C502 RFMD_3COM */
4239 /* It only works on SPI EEPROM versions of the card. */
4241 /* This firmware initializes the SPI controller and clock, reads the MAC */
4242 /* address from the EEPROM into SRAM, and puts the SRAM offset of the MAC */
4243 /* address in MR2, and sets MR3 to 0x10 to indicate it is done */
4244 /* It also puts a complete copy of the EEPROM in SRAM with the offset in */
4245 /* MR4, for investigational purposes (maybe we can determine chip type */
4249 .set MRBASE, 0x8000000
4250 .set CPSR_INITIAL, 0xD3 /* IRQ/FIQ disabled, ARM mode, Supervisor state */
4251 .set CPSR_USER, 0xD1 /* IRQ/FIQ disabled, ARM mode, USER state */
4252 .set SRAM_BASE, 0x02000000
4253 .set SP_BASE, 0x0F300000
4254 .set UNK_BASE, 0x0F000000 /* Some internal device, but which one? */
4255 .set SPI_CGEN_BASE, 0x0E000000 /* Some internal device, but which one? */
4256 .set UNK3_BASE, 0x02014000 /* Some internal device, but which one? */
4257 .set STACK_BASE, 0x5600
4259 .set SP_TDRE, 2 /* status register bit -- TDR empty */
4260 .set SP_RDRF, 1 /* status register bit -- RDR full */
4263 .set SP_CR, 0 /* control register */
4264 .set SP_MR, 4 /* mode register */
4265 .set SP_RDR, 0x08 /* Read Data Register */
4266 .set SP_TDR, 0x0C /* Transmit Data Register */
4267 .set SP_CSR0, 0x30 /* chip select registers */
4271 .set NVRAM_CMD_RDSR, 5 /* read status register */
4272 .set NVRAM_CMD_READ, 3 /* read data */
4273 .set NVRAM_SR_RDY, 1 /* RDY bit. This bit is inverted */
4274 .set SPI_8CLOCKS, 0xFF /* Writing this to the TDR doesn't do anything to the
4275 serial output, since SO is normally high. But it
4276 does cause 8 clock cycles and thus 8 bits to be
4277 clocked in to the chip. See Atmel's SPI
4278 controller (e.g. AT91M55800) timing and 4K
4279 SPI EEPROM manuals */
4281 .set NVRAM_SCRATCH, 0x02000100 /* arbitrary area for scratchpad memory */
4282 .set NVRAM_IMAGE, 0x02000200
4283 .set NVRAM_LENGTH, 0x0200
4284 .set MAC_ADDRESS_MIB, SRAM_BASE
4285 .set MAC_ADDRESS_LENGTH, 6
4286 .set MAC_BOOT_FLAG, 0x10
4308 mov r0, #CPSR_INITIAL
4309 msr CPSR_c, r0 /* This is probably unnecessary */
4311 /* I'm guessing this is initializing clock generator electronics for SPI */
4312 ldr r0, =SPI_CGEN_BASE
4337 ldr r1, =MAC_ADDRESS_MIB
4339 ldr r1, =NVRAM_IMAGE
4341 mov r1, #MAC_BOOT_FLAG
4344 .func Get_Whole_NVRAM, GET_WHOLE_NVRAM
4347 mov r2, #0 /* 0th bytes of NVRAM */
4348 mov r3, #NVRAM_LENGTH
4349 mov r1, #0 /* not used in routine */
4350 ldr r0, =NVRAM_IMAGE
4356 .func Get_MAC_Addr, GET_MAC_ADDR
4359 mov r2, #0x120 /* address of MAC Address within NVRAM */
4360 mov r3, #MAC_ADDRESS_LENGTH
4361 mov r1, #0 /* not used in routine */
4362 ldr r0, =MAC_ADDRESS_MIB
4368 .func Delay9, DELAY9
4370 adds r0, r0, r0, LSL #3 /* r0 = r0 * 9 */
4379 .func SP_Init, SP_INIT
4383 str r1, [r0, #SP_CR] /* reset the SPI */
4385 str r1, [r0, #SP_CR] /* release SPI from reset state */
4387 str r1, [r0, #SP_MR] /* set the SPI to MASTER mode*/
4388 str r1, [r0, #SP_CR] /* enable the SPI */
4390 /* My guess would be this turns on the SPI clock */
4391 ldr r3, =SPI_CGEN_BASE
4397 str r1, [r0, #SP_CSR0]
4399 str r1, [r0, #SP_CSR1]
4400 str r1, [r0, #SP_CSR2]
4401 str r1, [r0, #SP_CSR3]
4402 ldr r1, [r0, #SP_SR]
4403 ldr r0, [r0, #SP_RDR]
4406 .func NVRAM_Init, NVRAM_INIT
4409 ldr r0, [r1, #SP_RDR]
4410 mov r0, #NVRAM_CMD_RDSR
4411 str r0, [r1, #SP_TDR]
4413 ldr r0, [r1, #SP_SR]
4417 mov r0, #SPI_8CLOCKS
4418 str r0, [r1, #SP_TDR]
4420 ldr r0, [r1, #SP_SR]
4424 ldr r0, [r1, #SP_RDR]
4426 ldr r0, [r1, #SP_SR]
4430 ldr r0, [r1, #SP_RDR]
4435 .func NVRAM_Xfer, NVRAM_XFER
4436 /* r0 = dest address */
4438 /* r2 = src address within NVRAM */
4441 stmdb sp!, {r4, r5, lr}
4442 mov r5, r0 /* save r0 (dest address) */
4443 mov r4, r3 /* save r3 (length) */
4444 mov r0, r2, LSR #5 /* SPI memories put A8 in the command field */
4446 add r0, r0, #NVRAM_CMD_READ
4447 ldr r1, =NVRAM_SCRATCH
4448 strb r0, [r1, #0] /* save command in NVRAM_SCRATCH[0] */
4449 strb r2, [r1, #1] /* save low byte of source address in NVRAM_SCRATCH[1] */
4452 tst r0, #NVRAM_SR_RDY
4456 mov r2, r4 /* length */
4457 mov r1, r5 /* dest address */
4458 mov r0, #2 /* bytes to transfer in command */
4460 ldmia sp!, {r4, r5, lr}
4464 .func NVRAM_Xfer2, NVRAM_XFER2
4466 stmdb sp!, {r4, r5, r6, lr}
4471 ldr r5, =NVRAM_SCRATCH
4474 str r6, [r4, #SP_TDR]
4476 ldr r6, [r4, #SP_SR]
4480 cmp r3, r0 /* r0 is # of bytes to send out (command+addr) */
4483 mov r3, #SPI_8CLOCKS
4484 str r3, [r4, #SP_TDR]
4485 ldr r0, [r4, #SP_RDR]
4487 ldr r0, [r4, #SP_SR]
4490 ldr r0, [r4, #SP_RDR] /* what's this byte? It's the byte read while writing the TDR -- nonsense, because the NVRAM doesn't read and write at the same time */
4492 cmp r2, #0 /* r2 is # of bytes to copy in */
4495 ldr r5, [r4, #SP_SR]
4498 str r3, [r4, #SP_TDR] /* r3 has SPI_8CLOCKS */
4500 ldr r5, [r4, #SP_SR]
4503 ldr r5, [r4, #SP_RDR] /* but didn't we read this byte above? */
4504 strb r5, [r1], #1 /* postindexed */
4507 blo _local7 /* since we don't send another address, the NVRAM must be capable of sequential reads */
4511 ldmia sp!, {r4, r5, r6, lr}