blob: 4223672c4432a5784befad643e91b0f74e41cbb2 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*** -*- linux-c -*- **********************************************************
2
3 Driver for Atmel at76c502 at76c504 and at76c506 wireless cards.
4
5 Copyright 2000-2001 ATMEL Corporation.
6 Copyright 2003-2004 Simon Kelley.
7
Carlo Perassi4d791aa2005-11-13 15:02:15 +03008 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,
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 and the Linux PCMCIA package, (C) David Hinds and the Linux wireless
12 extensions, (C) Jean Tourrilhes.
13
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.
19
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.
24
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.
29
30 You should have received a copy of the GNU General Public License
31 along with Atmel wireless lan drivers; if not, write to the Free Software
32 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
33
Carlo Perassi4d791aa2005-11-13 15:02:15 +030034 For all queries about this code, please contact the current author,
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 Simon Kelley <simon@thekelleys.org.uk> and not Atmel Corporation.
36
37 Credit is due to HP UK and Cambridge Online Systems Ltd for supplying
38 hardware used during development of this driver.
39
40******************************************************************************/
41
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/init.h>
43
44#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <linux/ptrace.h>
46#include <linux/slab.h>
47#include <linux/string.h>
48#include <linux/ctype.h>
49#include <linux/timer.h>
Harvey Harrison9a6ab762008-05-16 11:20:25 -070050#include <asm/byteorder.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include <asm/io.h>
52#include <asm/system.h>
53#include <asm/uaccess.h>
54#include <linux/module.h>
55#include <linux/netdevice.h>
56#include <linux/etherdevice.h>
57#include <linux/skbuff.h>
58#include <linux/if_arp.h>
59#include <linux/ioport.h>
60#include <linux/fcntl.h>
61#include <linux/delay.h>
62#include <linux/wireless.h>
63#include <net/iw_handler.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#include <linux/crc32.h>
65#include <linux/proc_fs.h>
66#include <linux/device.h>
67#include <linux/moduleparam.h>
68#include <linux/firmware.h>
S.Çağlar Onur6e33e302008-02-14 17:36:49 +020069#include <linux/jiffies.h>
Johannes Berg2c7060022008-10-30 22:09:54 +010070#include <linux/ieee80211.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070071#include "atmel.h"
72
73#define DRIVER_MAJOR 0
simon@thekelleys.org.ukb16a2282005-10-30 15:50:15 +000074#define DRIVER_MINOR 98
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
76MODULE_AUTHOR("Simon Kelley");
77MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.");
78MODULE_LICENSE("GPL");
79MODULE_SUPPORTED_DEVICE("Atmel at76c50x wireless cards");
80
Carlo Perassi4d791aa2005-11-13 15:02:15 +030081/* The name of the firmware file to be loaded
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 over-rides any automatic selection */
83static char *firmware = NULL;
84module_param(firmware, charp, 0);
85
86/* table of firmware file names */
Carlo Perassi4d791aa2005-11-13 15:02:15 +030087static struct {
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 AtmelFWType fw_type;
89 const char *fw_file;
90 const char *fw_file_ext;
91} fw_table[] = {
92 { ATMEL_FW_TYPE_502, "atmel_at76c502", "bin" },
93 { ATMEL_FW_TYPE_502D, "atmel_at76c502d", "bin" },
94 { ATMEL_FW_TYPE_502E, "atmel_at76c502e", "bin" },
95 { ATMEL_FW_TYPE_502_3COM, "atmel_at76c502_3com", "bin" },
96 { ATMEL_FW_TYPE_504, "atmel_at76c504", "bin" },
97 { ATMEL_FW_TYPE_504_2958, "atmel_at76c504_2958", "bin" },
98 { ATMEL_FW_TYPE_504A_2958,"atmel_at76c504a_2958","bin" },
99 { ATMEL_FW_TYPE_506, "atmel_at76c506", "bin" },
100 { ATMEL_FW_TYPE_NONE, NULL, NULL }
101};
102
103#define MAX_SSID_LENGTH 32
104#define MGMT_JIFFIES (256 * HZ / 100)
105
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300106#define MAX_BSS_ENTRIES 64
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
108/* registers */
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300109#define GCR 0x00 // (SIR0) General Configuration Register
110#define BSR 0x02 // (SIR1) Bank Switching Select Register
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111#define AR 0x04
112#define DR 0x08
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300113#define MR1 0x12 // Mirror Register 1
114#define MR2 0x14 // Mirror Register 2
115#define MR3 0x16 // Mirror Register 3
116#define MR4 0x18 // Mirror Register 4
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117
118#define GPR1 0x0c
119#define GPR2 0x0e
120#define GPR3 0x10
121//
122// Constants for the GCR register.
123//
124#define GCR_REMAP 0x0400 // Remap internal SRAM to 0
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300125#define GCR_SWRES 0x0080 // BIU reset (ARM and PAI are NOT reset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126#define GCR_CORES 0x0060 // Core Reset (ARM and PAI are reset)
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300127#define GCR_ENINT 0x0002 // Enable Interrupts
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128#define GCR_ACKINT 0x0008 // Acknowledge Interrupts
129
130#define BSS_SRAM 0x0200 // AMBA module selection --> SRAM
131#define BSS_IRAM 0x0100 // AMBA module selection --> IRAM
132//
133// Constants for the MR registers.
134//
135#define MAC_INIT_COMPLETE 0x0001 // MAC init has been completed
136#define MAC_BOOT_COMPLETE 0x0010 // MAC boot has been completed
137#define MAC_INIT_OK 0x0002 // MAC boot has been completed
138
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139#define MIB_MAX_DATA_BYTES 212
140#define MIB_HEADER_SIZE 4 /* first four fields */
141
142struct get_set_mib {
143 u8 type;
144 u8 size;
145 u8 index;
146 u8 reserved;
147 u8 data[MIB_MAX_DATA_BYTES];
148};
149
150struct rx_desc {
151 u32 Next;
152 u16 MsduPos;
153 u16 MsduSize;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300154
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 u8 State;
156 u8 Status;
157 u8 Rate;
158 u8 Rssi;
159 u8 LinkQuality;
160 u8 PreambleType;
161 u16 Duration;
162 u32 RxTime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163};
164
165#define RX_DESC_FLAG_VALID 0x80
166#define RX_DESC_FLAG_CONSUMED 0x40
167#define RX_DESC_FLAG_IDLE 0x00
168
169#define RX_STATUS_SUCCESS 0x00
170
171#define RX_DESC_MSDU_POS_OFFSET 4
172#define RX_DESC_MSDU_SIZE_OFFSET 6
173#define RX_DESC_FLAGS_OFFSET 8
174#define RX_DESC_STATUS_OFFSET 9
175#define RX_DESC_RSSI_OFFSET 11
176#define RX_DESC_LINK_QUALITY_OFFSET 12
177#define RX_DESC_PREAMBLE_TYPE_OFFSET 13
178#define RX_DESC_DURATION_OFFSET 14
179#define RX_DESC_RX_TIME_OFFSET 16
180
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181struct tx_desc {
182 u32 NextDescriptor;
183 u16 TxStartOfFrame;
184 u16 TxLength;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300185
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 u8 TxState;
187 u8 TxStatus;
188 u8 RetryCount;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300189
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 u8 TxRate;
191
192 u8 KeyIndex;
193 u8 ChiperType;
194 u8 ChipreLength;
195 u8 Reserved1;
196
197 u8 Reserved;
198 u8 PacketType;
199 u16 HostTxLength;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200};
201
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202#define TX_DESC_NEXT_OFFSET 0
203#define TX_DESC_POS_OFFSET 4
204#define TX_DESC_SIZE_OFFSET 6
205#define TX_DESC_FLAGS_OFFSET 8
206#define TX_DESC_STATUS_OFFSET 9
207#define TX_DESC_RETRY_OFFSET 10
208#define TX_DESC_RATE_OFFSET 11
209#define TX_DESC_KEY_INDEX_OFFSET 12
210#define TX_DESC_CIPHER_TYPE_OFFSET 13
211#define TX_DESC_CIPHER_LENGTH_OFFSET 14
212#define TX_DESC_PACKET_TYPE_OFFSET 17
213#define TX_DESC_HOST_LENGTH_OFFSET 18
214
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215///////////////////////////////////////////////////////
216// Host-MAC interface
217///////////////////////////////////////////////////////
218
219#define TX_STATUS_SUCCESS 0x00
220
221#define TX_FIRM_OWN 0x80
222#define TX_DONE 0x40
223
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224#define TX_ERROR 0x01
225
226#define TX_PACKET_TYPE_DATA 0x01
227#define TX_PACKET_TYPE_MGMT 0x02
228
229#define ISR_EMPTY 0x00 // no bits set in ISR
230#define ISR_TxCOMPLETE 0x01 // packet transmitted
231#define ISR_RxCOMPLETE 0x02 // packet received
232#define ISR_RxFRAMELOST 0x04 // Rx Frame lost
233#define ISR_FATAL_ERROR 0x08 // Fatal error
234#define ISR_COMMAND_COMPLETE 0x10 // command completed
235#define ISR_OUT_OF_RANGE 0x20 // command completed
236#define ISR_IBSS_MERGE 0x40 // (4.1.2.30): IBSS merge
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300237#define ISR_GENERIC_IRQ 0x80
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
239#define Local_Mib_Type 0x01
240#define Mac_Address_Mib_Type 0x02
241#define Mac_Mib_Type 0x03
242#define Statistics_Mib_Type 0x04
243#define Mac_Mgmt_Mib_Type 0x05
244#define Mac_Wep_Mib_Type 0x06
245#define Phy_Mib_Type 0x07
246#define Multi_Domain_MIB 0x08
247
248#define MAC_MGMT_MIB_CUR_BSSID_POS 14
249#define MAC_MIB_FRAG_THRESHOLD_POS 8
250#define MAC_MIB_RTS_THRESHOLD_POS 10
251#define MAC_MIB_SHORT_RETRY_POS 16
252#define MAC_MIB_LONG_RETRY_POS 17
253#define MAC_MIB_SHORT_RETRY_LIMIT_POS 16
254#define MAC_MGMT_MIB_BEACON_PER_POS 0
255#define MAC_MGMT_MIB_STATION_ID_POS 6
256#define MAC_MGMT_MIB_CUR_PRIVACY_POS 11
257#define MAC_MGMT_MIB_CUR_BSSID_POS 14
258#define MAC_MGMT_MIB_PS_MODE_POS 53
259#define MAC_MGMT_MIB_LISTEN_INTERVAL_POS 54
260#define MAC_MGMT_MIB_MULTI_DOMAIN_IMPLEMENTED 56
261#define MAC_MGMT_MIB_MULTI_DOMAIN_ENABLED 57
262#define PHY_MIB_CHANNEL_POS 14
263#define PHY_MIB_RATE_SET_POS 20
264#define PHY_MIB_REG_DOMAIN_POS 26
265#define LOCAL_MIB_AUTO_TX_RATE_POS 3
266#define LOCAL_MIB_SSID_SIZE 5
267#define LOCAL_MIB_TX_PROMISCUOUS_POS 6
268#define LOCAL_MIB_TX_MGMT_RATE_POS 7
269#define LOCAL_MIB_TX_CONTROL_RATE_POS 8
270#define LOCAL_MIB_PREAMBLE_TYPE 9
271#define MAC_ADDR_MIB_MAC_ADDR_POS 0
272
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273#define CMD_Set_MIB_Vars 0x01
274#define CMD_Get_MIB_Vars 0x02
275#define CMD_Scan 0x03
276#define CMD_Join 0x04
277#define CMD_Start 0x05
278#define CMD_EnableRadio 0x06
279#define CMD_DisableRadio 0x07
280#define CMD_SiteSurvey 0x0B
281
282#define CMD_STATUS_IDLE 0x00
283#define CMD_STATUS_COMPLETE 0x01
284#define CMD_STATUS_UNKNOWN 0x02
285#define CMD_STATUS_INVALID_PARAMETER 0x03
286#define CMD_STATUS_FUNCTION_NOT_SUPPORTED 0x04
287#define CMD_STATUS_TIME_OUT 0x07
288#define CMD_STATUS_IN_PROGRESS 0x08
289#define CMD_STATUS_REJECTED_RADIO_OFF 0x09
290#define CMD_STATUS_HOST_ERROR 0xFF
291#define CMD_STATUS_BUSY 0xFE
292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293#define CMD_BLOCK_COMMAND_OFFSET 0
294#define CMD_BLOCK_STATUS_OFFSET 1
295#define CMD_BLOCK_PARAMETERS_OFFSET 4
296
297#define SCAN_OPTIONS_SITE_SURVEY 0x80
298
299#define MGMT_FRAME_BODY_OFFSET 24
300#define MAX_AUTHENTICATION_RETRIES 3
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300301#define MAX_ASSOCIATION_RETRIES 3
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302
303#define AUTHENTICATION_RESPONSE_TIME_OUT 1000
304
305#define MAX_WIRELESS_BODY 2316 /* mtu is 2312, CRC is 4 */
306#define LOOP_RETRY_LIMIT 500000
307
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300308#define ACTIVE_MODE 1
309#define PS_MODE 2
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310
311#define MAX_ENCRYPTION_KEYS 4
312#define MAX_ENCRYPTION_KEY_SIZE 40
313
314///////////////////////////////////////////////////////////////////////////
315// 802.11 related definitions
316///////////////////////////////////////////////////////////////////////////
317
318//
319// Regulatory Domains
320//
321
322#define REG_DOMAIN_FCC 0x10 //Channels 1-11 USA
323#define REG_DOMAIN_DOC 0x20 //Channel 1-11 Canada
324#define REG_DOMAIN_ETSI 0x30 //Channel 1-13 Europe (ex Spain/France)
325#define REG_DOMAIN_SPAIN 0x31 //Channel 10-11 Spain
326#define REG_DOMAIN_FRANCE 0x32 //Channel 10-13 France
327#define REG_DOMAIN_MKK 0x40 //Channel 14 Japan
328#define REG_DOMAIN_MKK1 0x41 //Channel 1-14 Japan(MKK1)
329#define REG_DOMAIN_ISRAEL 0x50 //Channel 3-9 ISRAEL
330
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300331#define BSS_TYPE_AD_HOC 1
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332#define BSS_TYPE_INFRASTRUCTURE 2
333
334#define SCAN_TYPE_ACTIVE 0
335#define SCAN_TYPE_PASSIVE 1
336
337#define LONG_PREAMBLE 0
338#define SHORT_PREAMBLE 1
339#define AUTO_PREAMBLE 2
340
341#define DATA_FRAME_WS_HEADER_SIZE 30
342
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300343/* promiscuous mode control */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344#define PROM_MODE_OFF 0x0
345#define PROM_MODE_UNKNOWN 0x1
346#define PROM_MODE_CRC_FAILED 0x2
347#define PROM_MODE_DUPLICATED 0x4
348#define PROM_MODE_MGMT 0x8
349#define PROM_MODE_CTRL 0x10
350#define PROM_MODE_BAD_PROTOCOL 0x20
351
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300352#define IFACE_INT_STATUS_OFFSET 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353#define IFACE_INT_MASK_OFFSET 1
354#define IFACE_LOCKOUT_HOST_OFFSET 2
355#define IFACE_LOCKOUT_MAC_OFFSET 3
356#define IFACE_FUNC_CTRL_OFFSET 28
357#define IFACE_MAC_STAT_OFFSET 30
358#define IFACE_GENERIC_INT_TYPE_OFFSET 32
359
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300360#define CIPHER_SUITE_NONE 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361#define CIPHER_SUITE_WEP_64 1
362#define CIPHER_SUITE_TKIP 2
363#define CIPHER_SUITE_AES 3
364#define CIPHER_SUITE_CCX 4
365#define CIPHER_SUITE_WEP_128 5
366
367//
368// IFACE MACROS & definitions
369//
370//
371
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300372// FuncCtrl field:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373//
374#define FUNC_CTRL_TxENABLE 0x10
375#define FUNC_CTRL_RxENABLE 0x20
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300376#define FUNC_CTRL_INIT_COMPLETE 0x01
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
378/* A stub firmware image which reads the MAC address from NVRAM on the card.
379 For copyright information and source see the end of this file. */
380static u8 mac_reader[] = {
381 0x06,0x00,0x00,0xea,0x04,0x00,0x00,0xea,0x03,0x00,0x00,0xea,0x02,0x00,0x00,0xea,
382 0x01,0x00,0x00,0xea,0x00,0x00,0x00,0xea,0xff,0xff,0xff,0xea,0xfe,0xff,0xff,0xea,
383 0xd3,0x00,0xa0,0xe3,0x00,0xf0,0x21,0xe1,0x0e,0x04,0xa0,0xe3,0x00,0x10,0xa0,0xe3,
384 0x81,0x11,0xa0,0xe1,0x00,0x10,0x81,0xe3,0x00,0x10,0x80,0xe5,0x1c,0x10,0x90,0xe5,
385 0x10,0x10,0xc1,0xe3,0x1c,0x10,0x80,0xe5,0x01,0x10,0xa0,0xe3,0x08,0x10,0x80,0xe5,
386 0x02,0x03,0xa0,0xe3,0x00,0x10,0xa0,0xe3,0xb0,0x10,0xc0,0xe1,0xb4,0x10,0xc0,0xe1,
387 0xb8,0x10,0xc0,0xe1,0xbc,0x10,0xc0,0xe1,0x56,0xdc,0xa0,0xe3,0x21,0x00,0x00,0xeb,
388 0x0a,0x00,0xa0,0xe3,0x1a,0x00,0x00,0xeb,0x10,0x00,0x00,0xeb,0x07,0x00,0x00,0xeb,
389 0x02,0x03,0xa0,0xe3,0x02,0x14,0xa0,0xe3,0xb4,0x10,0xc0,0xe1,0x4c,0x10,0x9f,0xe5,
390 0xbc,0x10,0xc0,0xe1,0x10,0x10,0xa0,0xe3,0xb8,0x10,0xc0,0xe1,0xfe,0xff,0xff,0xea,
391 0x00,0x40,0x2d,0xe9,0x00,0x20,0xa0,0xe3,0x02,0x3c,0xa0,0xe3,0x00,0x10,0xa0,0xe3,
392 0x28,0x00,0x9f,0xe5,0x37,0x00,0x00,0xeb,0x00,0x40,0xbd,0xe8,0x1e,0xff,0x2f,0xe1,
393 0x00,0x40,0x2d,0xe9,0x12,0x2e,0xa0,0xe3,0x06,0x30,0xa0,0xe3,0x00,0x10,0xa0,0xe3,
394 0x02,0x04,0xa0,0xe3,0x2f,0x00,0x00,0xeb,0x00,0x40,0xbd,0xe8,0x1e,0xff,0x2f,0xe1,
395 0x00,0x02,0x00,0x02,0x80,0x01,0x90,0xe0,0x01,0x00,0x00,0x0a,0x01,0x00,0x50,0xe2,
396 0xfc,0xff,0xff,0xea,0x1e,0xff,0x2f,0xe1,0x80,0x10,0xa0,0xe3,0xf3,0x06,0xa0,0xe3,
397 0x00,0x10,0x80,0xe5,0x00,0x10,0xa0,0xe3,0x00,0x10,0x80,0xe5,0x01,0x10,0xa0,0xe3,
398 0x04,0x10,0x80,0xe5,0x00,0x10,0x80,0xe5,0x0e,0x34,0xa0,0xe3,0x1c,0x10,0x93,0xe5,
399 0x02,0x1a,0x81,0xe3,0x1c,0x10,0x83,0xe5,0x58,0x11,0x9f,0xe5,0x30,0x10,0x80,0xe5,
400 0x54,0x11,0x9f,0xe5,0x34,0x10,0x80,0xe5,0x38,0x10,0x80,0xe5,0x3c,0x10,0x80,0xe5,
401 0x10,0x10,0x90,0xe5,0x08,0x00,0x90,0xe5,0x1e,0xff,0x2f,0xe1,0xf3,0x16,0xa0,0xe3,
402 0x08,0x00,0x91,0xe5,0x05,0x00,0xa0,0xe3,0x0c,0x00,0x81,0xe5,0x10,0x00,0x91,0xe5,
403 0x02,0x00,0x10,0xe3,0xfc,0xff,0xff,0x0a,0xff,0x00,0xa0,0xe3,0x0c,0x00,0x81,0xe5,
404 0x10,0x00,0x91,0xe5,0x02,0x00,0x10,0xe3,0xfc,0xff,0xff,0x0a,0x08,0x00,0x91,0xe5,
405 0x10,0x00,0x91,0xe5,0x01,0x00,0x10,0xe3,0xfc,0xff,0xff,0x0a,0x08,0x00,0x91,0xe5,
406 0xff,0x00,0x00,0xe2,0x1e,0xff,0x2f,0xe1,0x30,0x40,0x2d,0xe9,0x00,0x50,0xa0,0xe1,
407 0x03,0x40,0xa0,0xe1,0xa2,0x02,0xa0,0xe1,0x08,0x00,0x00,0xe2,0x03,0x00,0x80,0xe2,
408 0xd8,0x10,0x9f,0xe5,0x00,0x00,0xc1,0xe5,0x01,0x20,0xc1,0xe5,0xe2,0xff,0xff,0xeb,
409 0x01,0x00,0x10,0xe3,0xfc,0xff,0xff,0x1a,0x14,0x00,0xa0,0xe3,0xc4,0xff,0xff,0xeb,
410 0x04,0x20,0xa0,0xe1,0x05,0x10,0xa0,0xe1,0x02,0x00,0xa0,0xe3,0x01,0x00,0x00,0xeb,
411 0x30,0x40,0xbd,0xe8,0x1e,0xff,0x2f,0xe1,0x70,0x40,0x2d,0xe9,0xf3,0x46,0xa0,0xe3,
412 0x00,0x30,0xa0,0xe3,0x00,0x00,0x50,0xe3,0x08,0x00,0x00,0x9a,0x8c,0x50,0x9f,0xe5,
413 0x03,0x60,0xd5,0xe7,0x0c,0x60,0x84,0xe5,0x10,0x60,0x94,0xe5,0x02,0x00,0x16,0xe3,
414 0xfc,0xff,0xff,0x0a,0x01,0x30,0x83,0xe2,0x00,0x00,0x53,0xe1,0xf7,0xff,0xff,0x3a,
415 0xff,0x30,0xa0,0xe3,0x0c,0x30,0x84,0xe5,0x08,0x00,0x94,0xe5,0x10,0x00,0x94,0xe5,
416 0x01,0x00,0x10,0xe3,0xfc,0xff,0xff,0x0a,0x08,0x00,0x94,0xe5,0x00,0x00,0xa0,0xe3,
417 0x00,0x00,0x52,0xe3,0x0b,0x00,0x00,0x9a,0x10,0x50,0x94,0xe5,0x02,0x00,0x15,0xe3,
418 0xfc,0xff,0xff,0x0a,0x0c,0x30,0x84,0xe5,0x10,0x50,0x94,0xe5,0x01,0x00,0x15,0xe3,
419 0xfc,0xff,0xff,0x0a,0x08,0x50,0x94,0xe5,0x01,0x50,0xc1,0xe4,0x01,0x00,0x80,0xe2,
420 0x02,0x00,0x50,0xe1,0xf3,0xff,0xff,0x3a,0xc8,0x00,0xa0,0xe3,0x98,0xff,0xff,0xeb,
421 0x70,0x40,0xbd,0xe8,0x1e,0xff,0x2f,0xe1,0x01,0x0c,0x00,0x02,0x01,0x02,0x00,0x02,
422 0x00,0x01,0x00,0x02
423};
424
425struct atmel_private {
426 void *card; /* Bus dependent stucture varies for PCcard */
427 int (*present_callback)(void *); /* And callback which uses it */
428 char firmware_id[32];
429 AtmelFWType firmware_type;
430 u8 *firmware;
431 int firmware_length;
432 struct timer_list management_timer;
433 struct net_device *dev;
434 struct device *sys_dev;
435 struct iw_statistics wstats;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 spinlock_t irqlock, timerlock; // spinlocks
437 enum { BUS_TYPE_PCCARD, BUS_TYPE_PCI } bus_type;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300438 enum {
439 CARD_TYPE_PARALLEL_FLASH,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 CARD_TYPE_SPI_FLASH,
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300441 CARD_TYPE_EEPROM
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 } card_type;
443 int do_rx_crc; /* If we need to CRC incoming packets */
444 int probe_crc; /* set if we don't yet know */
445 int crc_ok_cnt, crc_ko_cnt; /* counters for probing */
446 u16 rx_desc_head;
447 u16 tx_desc_free, tx_desc_head, tx_desc_tail, tx_desc_previous;
448 u16 tx_free_mem, tx_buff_head, tx_buff_tail;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300449
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 u16 frag_seq, frag_len, frag_no;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300451 u8 frag_source[6];
452
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 u8 wep_is_on, default_key, exclude_unencrypted, encryption_level;
454 u8 group_cipher_suite, pairwise_cipher_suite;
455 u8 wep_keys[MAX_ENCRYPTION_KEYS][MAX_ENCRYPTION_KEY_SIZE];
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300456 int wep_key_len[MAX_ENCRYPTION_KEYS];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 int use_wpa, radio_on_broken; /* firmware dependent stuff. */
458
459 u16 host_info_base;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300460 struct host_info_struct {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 /* NB this is matched to the hardware, don't change. */
462 u8 volatile int_status;
463 u8 volatile int_mask;
464 u8 volatile lockout_host;
465 u8 volatile lockout_mac;
466
467 u16 tx_buff_pos;
468 u16 tx_buff_size;
469 u16 tx_desc_pos;
470 u16 tx_desc_count;
471
472 u16 rx_buff_pos;
473 u16 rx_buff_size;
474 u16 rx_desc_pos;
475 u16 rx_desc_count;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300476
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 u16 build_version;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300478 u16 command_pos;
479
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 u16 major_version;
481 u16 minor_version;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300482
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 u16 func_ctrl;
484 u16 mac_status;
485 u16 generic_IRQ_type;
486 u8 reserved[2];
487 } host_info;
488
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300489 enum {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 STATION_STATE_SCANNING,
491 STATION_STATE_JOINNING,
492 STATION_STATE_AUTHENTICATING,
493 STATION_STATE_ASSOCIATING,
494 STATION_STATE_READY,
495 STATION_STATE_REASSOCIATING,
496 STATION_STATE_DOWN,
497 STATION_STATE_MGMT_ERROR
498 } station_state;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300499
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 int operating_mode, power_mode;
501 time_t last_qual;
502 int beacons_this_sec;
503 int channel;
504 int reg_domain, config_reg_domain;
505 int tx_rate;
506 int auto_tx_rate;
507 int rts_threshold;
508 int frag_threshold;
509 int long_retry, short_retry;
510 int preamble;
511 int default_beacon_period, beacon_period, listen_interval;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300512 int CurrentAuthentTransactionSeqNum, ExpectedAuthentTransactionSeqNum;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 int AuthenticationRequestRetryCnt, AssociationRequestRetryCnt, ReAssociationRequestRetryCnt;
514 enum {
515 SITE_SURVEY_IDLE,
516 SITE_SURVEY_IN_PROGRESS,
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300517 SITE_SURVEY_COMPLETED
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 } site_survey_state;
S.Çağlar Onur6e33e302008-02-14 17:36:49 +0200519 unsigned long last_survey;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520
521 int station_was_associated, station_is_associated;
522 int fast_scan;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300523
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 struct bss_info {
525 int channel;
526 int SSIDsize;
527 int RSSI;
528 int UsingWEP;
529 int preamble;
530 int beacon_period;
531 int BSStype;
532 u8 BSSID[6];
533 u8 SSID[MAX_SSID_LENGTH];
534 } BSSinfo[MAX_BSS_ENTRIES];
535 int BSS_list_entries, current_BSS;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300536 int connect_to_any_BSS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 int SSID_size, new_SSID_size;
538 u8 CurrentBSSID[6], BSSID[6];
539 u8 SSID[MAX_SSID_LENGTH], new_SSID[MAX_SSID_LENGTH];
540 u64 last_beacon_timestamp;
541 u8 rx_buf[MAX_WIRELESS_BODY];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542};
543
544static u8 atmel_basic_rates[4] = {0x82,0x84,0x0b,0x16};
545
546static const struct {
547 int reg_domain;
548 int min, max;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300549 char *name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550} channel_table[] = { { REG_DOMAIN_FCC, 1, 11, "USA" },
551 { REG_DOMAIN_DOC, 1, 11, "Canada" },
552 { REG_DOMAIN_ETSI, 1, 13, "Europe" },
553 { REG_DOMAIN_SPAIN, 10, 11, "Spain" },
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300554 { REG_DOMAIN_FRANCE, 10, 13, "France" },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 { REG_DOMAIN_MKK, 14, 14, "MKK" },
556 { REG_DOMAIN_MKK1, 1, 14, "MKK1" },
557 { REG_DOMAIN_ISRAEL, 3, 9, "Israel"} };
558
559static void build_wpa_mib(struct atmel_private *priv);
560static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300561static void atmel_copy_to_card(struct net_device *dev, u16 dest,
David Woodhouse2f26e8a2008-05-24 00:09:29 +0100562 const unsigned char *src, u16 len);
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300563static void atmel_copy_to_host(struct net_device *dev, unsigned char *dest,
564 u16 src, u16 len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565static void atmel_set_gcr(struct net_device *dev, u16 mask);
566static void atmel_clear_gcr(struct net_device *dev, u16 mask);
567static int atmel_lock_mac(struct atmel_private *priv);
568static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data);
569static void atmel_command_irq(struct atmel_private *priv);
570static int atmel_validate_channel(struct atmel_private *priv, int channel);
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300571static void atmel_management_frame(struct atmel_private *priv,
Johannes Berg2c7060022008-10-30 22:09:54 +0100572 struct ieee80211_hdr *header,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 u16 frame_len, u8 rssi);
574static void atmel_management_timer(u_long a);
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300575static void atmel_send_command(struct atmel_private *priv, int command,
576 void *cmd, int cmd_size);
577static int atmel_send_command_wait(struct atmel_private *priv, int command,
578 void *cmd, int cmd_size);
579static void atmel_transmit_management_frame(struct atmel_private *priv,
Johannes Berg2c7060022008-10-30 22:09:54 +0100580 struct ieee80211_hdr *header,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 u8 *body, int body_len);
582
583static u8 atmel_get_mib8(struct atmel_private *priv, u8 type, u8 index);
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300584static void atmel_set_mib8(struct atmel_private *priv, u8 type, u8 index,
585 u8 data);
586static void atmel_set_mib16(struct atmel_private *priv, u8 type, u8 index,
587 u16 data);
588static void atmel_set_mib(struct atmel_private *priv, u8 type, u8 index,
589 u8 *data, int data_len);
590static void atmel_get_mib(struct atmel_private *priv, u8 type, u8 index,
591 u8 *data, int data_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592static void atmel_scan(struct atmel_private *priv, int specific_ssid);
593static void atmel_join_bss(struct atmel_private *priv, int bss_index);
594static void atmel_smooth_qual(struct atmel_private *priv);
595static void atmel_writeAR(struct net_device *dev, u16 data);
596static int probe_atmel_card(struct net_device *dev);
Dmitry Torokhov5c877fe2006-10-08 00:14:30 -0400597static int reset_atmel_card(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598static void atmel_enter_state(struct atmel_private *priv, int new_state);
599int atmel_open (struct net_device *dev);
600
601static inline u16 atmel_hi(struct atmel_private *priv, u16 offset)
602{
603 return priv->host_info_base + offset;
604}
605
606static inline u16 atmel_co(struct atmel_private *priv, u16 offset)
607{
608 return priv->host_info.command_pos + offset;
609}
610
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300611static inline u16 atmel_rx(struct atmel_private *priv, u16 offset, u16 desc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612{
613 return priv->host_info.rx_desc_pos + (sizeof(struct rx_desc) * desc) + offset;
614}
615
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300616static inline u16 atmel_tx(struct atmel_private *priv, u16 offset, u16 desc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617{
618 return priv->host_info.tx_desc_pos + (sizeof(struct tx_desc) * desc) + offset;
619}
620
621static inline u8 atmel_read8(struct net_device *dev, u16 offset)
622{
623 return inb(dev->base_addr + offset);
624}
625
626static inline void atmel_write8(struct net_device *dev, u16 offset, u8 data)
627{
628 outb(data, dev->base_addr + offset);
629}
630
631static inline u16 atmel_read16(struct net_device *dev, u16 offset)
632{
633 return inw(dev->base_addr + offset);
634}
635
636static inline void atmel_write16(struct net_device *dev, u16 offset, u16 data)
637{
638 outw(data, dev->base_addr + offset);
639}
640
641static inline u8 atmel_rmem8(struct atmel_private *priv, u16 pos)
642{
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300643 atmel_writeAR(priv->dev, pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 return atmel_read8(priv->dev, DR);
645}
646
647static inline void atmel_wmem8(struct atmel_private *priv, u16 pos, u16 data)
648{
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300649 atmel_writeAR(priv->dev, pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 atmel_write8(priv->dev, DR, data);
651}
652
653static inline u16 atmel_rmem16(struct atmel_private *priv, u16 pos)
654{
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300655 atmel_writeAR(priv->dev, pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 return atmel_read16(priv->dev, DR);
657}
658
659static inline void atmel_wmem16(struct atmel_private *priv, u16 pos, u16 data)
660{
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300661 atmel_writeAR(priv->dev, pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 atmel_write16(priv->dev, DR, data);
663}
664
665static const struct iw_handler_def atmel_handler_def;
666
667static void tx_done_irq(struct atmel_private *priv)
668{
669 int i;
670
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300671 for (i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 atmel_rmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, priv->tx_desc_head)) == TX_DONE &&
673 i < priv->host_info.tx_desc_count;
674 i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 u8 status = atmel_rmem8(priv, atmel_tx(priv, TX_DESC_STATUS_OFFSET, priv->tx_desc_head));
676 u16 msdu_size = atmel_rmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, priv->tx_desc_head));
677 u8 type = atmel_rmem8(priv, atmel_tx(priv, TX_DESC_PACKET_TYPE_OFFSET, priv->tx_desc_head));
678
679 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, priv->tx_desc_head), 0);
680
681 priv->tx_free_mem += msdu_size;
682 priv->tx_desc_free++;
683
684 if (priv->tx_buff_head + msdu_size > (priv->host_info.tx_buff_pos + priv->host_info.tx_buff_size))
685 priv->tx_buff_head = 0;
686 else
687 priv->tx_buff_head += msdu_size;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300688
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 if (priv->tx_desc_head < (priv->host_info.tx_desc_count - 1))
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300690 priv->tx_desc_head++ ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 else
692 priv->tx_desc_head = 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300693
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 if (type == TX_PACKET_TYPE_DATA) {
695 if (status == TX_STATUS_SUCCESS)
Paulius Zaleckas736bc922008-05-06 23:50:30 +0300696 priv->dev->stats.tx_packets++;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300697 else
Paulius Zaleckas736bc922008-05-06 23:50:30 +0300698 priv->dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 netif_wake_queue(priv->dev);
700 }
701 }
702}
703
704static u16 find_tx_buff(struct atmel_private *priv, u16 len)
705{
706 u16 bottom_free = priv->host_info.tx_buff_size - priv->tx_buff_tail;
707
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300708 if (priv->tx_desc_free == 3 || priv->tx_free_mem < len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 return 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300710
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 if (bottom_free >= len)
712 return priv->host_info.tx_buff_pos + priv->tx_buff_tail;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300713
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 if (priv->tx_free_mem - bottom_free >= len) {
715 priv->tx_buff_tail = 0;
716 return priv->host_info.tx_buff_pos;
717 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300718
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 return 0;
720}
721
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300722static void tx_update_descriptor(struct atmel_private *priv, int is_bcast,
723 u16 len, u16 buff, u8 type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724{
725 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_POS_OFFSET, priv->tx_desc_tail), buff);
726 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, priv->tx_desc_tail), len);
727 if (!priv->use_wpa)
728 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_HOST_LENGTH_OFFSET, priv->tx_desc_tail), len);
729 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_PACKET_TYPE_OFFSET, priv->tx_desc_tail), type);
730 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_RATE_OFFSET, priv->tx_desc_tail), priv->tx_rate);
731 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_RETRY_OFFSET, priv->tx_desc_tail), 0);
732 if (priv->use_wpa) {
733 int cipher_type, cipher_length;
734 if (is_bcast) {
735 cipher_type = priv->group_cipher_suite;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300736 if (cipher_type == CIPHER_SUITE_WEP_64 ||
737 cipher_type == CIPHER_SUITE_WEP_128)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 cipher_length = 8;
739 else if (cipher_type == CIPHER_SUITE_TKIP)
740 cipher_length = 12;
741 else if (priv->pairwise_cipher_suite == CIPHER_SUITE_WEP_64 ||
742 priv->pairwise_cipher_suite == CIPHER_SUITE_WEP_128) {
743 cipher_type = priv->pairwise_cipher_suite;
744 cipher_length = 8;
745 } else {
746 cipher_type = CIPHER_SUITE_NONE;
747 cipher_length = 0;
748 }
749 } else {
750 cipher_type = priv->pairwise_cipher_suite;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300751 if (cipher_type == CIPHER_SUITE_WEP_64 ||
752 cipher_type == CIPHER_SUITE_WEP_128)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 cipher_length = 8;
754 else if (cipher_type == CIPHER_SUITE_TKIP)
755 cipher_length = 12;
756 else if (priv->group_cipher_suite == CIPHER_SUITE_WEP_64 ||
757 priv->group_cipher_suite == CIPHER_SUITE_WEP_128) {
758 cipher_type = priv->group_cipher_suite;
759 cipher_length = 8;
760 } else {
761 cipher_type = CIPHER_SUITE_NONE;
762 cipher_length = 0;
763 }
764 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300765
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_CIPHER_TYPE_OFFSET, priv->tx_desc_tail),
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300767 cipher_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_CIPHER_LENGTH_OFFSET, priv->tx_desc_tail),
769 cipher_length);
770 }
771 atmel_wmem32(priv, atmel_tx(priv, TX_DESC_NEXT_OFFSET, priv->tx_desc_tail), 0x80000000L);
772 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, priv->tx_desc_tail), TX_FIRM_OWN);
773 if (priv->tx_desc_previous != priv->tx_desc_tail)
774 atmel_wmem32(priv, atmel_tx(priv, TX_DESC_NEXT_OFFSET, priv->tx_desc_previous), 0);
775 priv->tx_desc_previous = priv->tx_desc_tail;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300776 if (priv->tx_desc_tail < (priv->host_info.tx_desc_count - 1))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 priv->tx_desc_tail++;
778 else
779 priv->tx_desc_tail = 0;
780 priv->tx_desc_free--;
781 priv->tx_free_mem -= len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782}
783
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300784static int start_tx(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785{
Dmitry Torokhov00a5ebf2006-10-08 00:14:28 -0400786 static const u8 SNAP_RFC1024[6] = { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 struct atmel_private *priv = netdev_priv(dev);
Johannes Berg2c7060022008-10-30 22:09:54 +0100788 struct ieee80211_hdr header;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 unsigned long flags;
790 u16 buff, frame_ctl, len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300791
792 if (priv->card && priv->present_callback &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 !(*priv->present_callback)(priv->card)) {
Paulius Zaleckas736bc922008-05-06 23:50:30 +0300794 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795 dev_kfree_skb(skb);
796 return 0;
797 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300798
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 if (priv->station_state != STATION_STATE_READY) {
Paulius Zaleckas736bc922008-05-06 23:50:30 +0300800 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 dev_kfree_skb(skb);
802 return 0;
803 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300804
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 /* first ensure the timer func cannot run */
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300806 spin_lock_bh(&priv->timerlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 /* then stop the hardware ISR */
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300808 spin_lock_irqsave(&priv->irqlock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 /* nb doing the above in the opposite order will deadlock */
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300810
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 /* The Wireless Header is 30 bytes. In the Ethernet packet we "cut" the
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300812 12 first bytes (containing DA/SA) and put them in the appropriate
813 fields of the Wireless Header. Thus the packet length is then the
814 initial + 18 (+30-12) */
815
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 if (!(buff = find_tx_buff(priv, len + 18))) {
Paulius Zaleckas736bc922008-05-06 23:50:30 +0300817 dev->stats.tx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 spin_unlock_irqrestore(&priv->irqlock, flags);
819 spin_unlock_bh(&priv->timerlock);
820 netif_stop_queue(dev);
821 return 1;
822 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300823
Jeff Garzikb4538722005-05-12 22:48:20 -0400824 frame_ctl = IEEE80211_FTYPE_DATA;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 header.duration_id = 0;
Johannes Berg2c7060022008-10-30 22:09:54 +0100826 header.seq_ctrl = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 if (priv->wep_is_on)
Jiri Bencf13baae2005-08-25 20:11:46 -0400828 frame_ctl |= IEEE80211_FCTL_PROTECTED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 if (priv->operating_mode == IW_MODE_ADHOC) {
Arnaldo Carvalho de Melod626f622007-03-27 18:55:52 -0300830 skb_copy_from_linear_data(skb, &header.addr1, 6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 memcpy(&header.addr2, dev->dev_addr, 6);
832 memcpy(&header.addr3, priv->BSSID, 6);
833 } else {
Jeff Garzikb4538722005-05-12 22:48:20 -0400834 frame_ctl |= IEEE80211_FCTL_TODS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 memcpy(&header.addr1, priv->CurrentBSSID, 6);
836 memcpy(&header.addr2, dev->dev_addr, 6);
Arnaldo Carvalho de Melod626f622007-03-27 18:55:52 -0300837 skb_copy_from_linear_data(skb, &header.addr3, 6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300839
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 if (priv->use_wpa)
841 memcpy(&header.addr4, SNAP_RFC1024, 6);
842
Johannes Berg2c7060022008-10-30 22:09:54 +0100843 header.frame_control = cpu_to_le16(frame_ctl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 /* Copy the wireless header into the card */
845 atmel_copy_to_card(dev, buff, (unsigned char *)&header, DATA_FRAME_WS_HEADER_SIZE);
846 /* Copy the packet sans its 802.3 header addresses which have been replaced */
847 atmel_copy_to_card(dev, buff + DATA_FRAME_WS_HEADER_SIZE, skb->data + 12, len - 12);
848 priv->tx_buff_tail += len - 12 + DATA_FRAME_WS_HEADER_SIZE;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300849
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 /* low bit of first byte of destination tells us if broadcast */
851 tx_update_descriptor(priv, *(skb->data) & 0x01, len + 18, buff, TX_PACKET_TYPE_DATA);
852 dev->trans_start = jiffies;
Paulius Zaleckas736bc922008-05-06 23:50:30 +0300853 dev->stats.tx_bytes += len;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300854
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 spin_unlock_irqrestore(&priv->irqlock, flags);
856 spin_unlock_bh(&priv->timerlock);
857 dev_kfree_skb(skb);
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300858
859 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860}
861
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300862static void atmel_transmit_management_frame(struct atmel_private *priv,
Johannes Berg2c7060022008-10-30 22:09:54 +0100863 struct ieee80211_hdr *header,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 u8 *body, int body_len)
865{
866 u16 buff;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300867 int len = MGMT_FRAME_BODY_OFFSET + body_len;
868
869 if (!(buff = find_tx_buff(priv, len)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 return;
871
872 atmel_copy_to_card(priv->dev, buff, (u8 *)header, MGMT_FRAME_BODY_OFFSET);
873 atmel_copy_to_card(priv->dev, buff + MGMT_FRAME_BODY_OFFSET, body, body_len);
874 priv->tx_buff_tail += len;
875 tx_update_descriptor(priv, header->addr1[0] & 0x01, len, buff, TX_PACKET_TYPE_MGMT);
876}
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300877
878static void fast_rx_path(struct atmel_private *priv,
Johannes Berg2c7060022008-10-30 22:09:54 +0100879 struct ieee80211_hdr *header,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 u16 msdu_size, u16 rx_packet_loc, u32 crc)
881{
882 /* fast path: unfragmented packet copy directly into skbuf */
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300883 u8 mac4[6];
884 struct sk_buff *skb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 unsigned char *skbp;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300886
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 /* get the final, mac 4 header field, this tells us encapsulation */
888 atmel_copy_to_host(priv->dev, mac4, rx_packet_loc + 24, 6);
889 msdu_size -= 6;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300890
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 if (priv->do_rx_crc) {
892 crc = crc32_le(crc, mac4, 6);
893 msdu_size -= 4;
894 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300895
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 if (!(skb = dev_alloc_skb(msdu_size + 14))) {
Paulius Zaleckas736bc922008-05-06 23:50:30 +0300897 priv->dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 return;
899 }
900
901 skb_reserve(skb, 2);
902 skbp = skb_put(skb, msdu_size + 12);
903 atmel_copy_to_host(priv->dev, skbp + 12, rx_packet_loc + 30, msdu_size);
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300904
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 if (priv->do_rx_crc) {
906 u32 netcrc;
907 crc = crc32_le(crc, skbp + 12, msdu_size);
908 atmel_copy_to_host(priv->dev, (void *)&netcrc, rx_packet_loc + 30 + msdu_size, 4);
909 if ((crc ^ 0xffffffff) != netcrc) {
Paulius Zaleckas736bc922008-05-06 23:50:30 +0300910 priv->dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 dev_kfree_skb(skb);
912 return;
913 }
914 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300915
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 memcpy(skbp, header->addr1, 6); /* destination address */
Johannes Berg2c7060022008-10-30 22:09:54 +0100917 if (le16_to_cpu(header->frame_control) & IEEE80211_FCTL_FROMDS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 memcpy(&skbp[6], header->addr3, 6);
919 else
920 memcpy(&skbp[6], header->addr2, 6); /* source address */
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300921
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 skb->protocol = eth_type_trans(skb, priv->dev);
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300923 skb->ip_summed = CHECKSUM_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 netif_rx(skb);
Paulius Zaleckas736bc922008-05-06 23:50:30 +0300925 priv->dev->stats.rx_bytes += 12 + msdu_size;
926 priv->dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927}
928
929/* Test to see if the packet in card memory at packet_loc has a valid CRC
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300930 It doesn't matter that this is slow: it is only used to proble the first few
931 packets. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932static int probe_crc(struct atmel_private *priv, u16 packet_loc, u16 msdu_size)
933{
934 int i = msdu_size - 4;
935 u32 netcrc, crc = 0xffffffff;
936
937 if (msdu_size < 4)
938 return 0;
939
940 atmel_copy_to_host(priv->dev, (void *)&netcrc, packet_loc + i, 4);
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300941
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 atmel_writeAR(priv->dev, packet_loc);
943 while (i--) {
944 u8 octet = atmel_read8(priv->dev, DR);
945 crc = crc32_le(crc, &octet, 1);
946 }
947
948 return (crc ^ 0xffffffff) == netcrc;
949}
950
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300951static void frag_rx_path(struct atmel_private *priv,
Johannes Berg2c7060022008-10-30 22:09:54 +0100952 struct ieee80211_hdr *header,
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300953 u16 msdu_size, u16 rx_packet_loc, u32 crc, u16 seq_no,
954 u8 frag_no, int more_frags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955{
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300956 u8 mac4[6];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 u8 source[6];
958 struct sk_buff *skb;
959
Johannes Berg2c7060022008-10-30 22:09:54 +0100960 if (le16_to_cpu(header->frame_control) & IEEE80211_FCTL_FROMDS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 memcpy(source, header->addr3, 6);
962 else
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300963 memcpy(source, header->addr2, 6);
964
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 rx_packet_loc += 24; /* skip header */
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300966
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 if (priv->do_rx_crc)
968 msdu_size -= 4;
969
970 if (frag_no == 0) { /* first fragment */
971 atmel_copy_to_host(priv->dev, mac4, rx_packet_loc, 6);
972 msdu_size -= 6;
973 rx_packet_loc += 6;
974
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300975 if (priv->do_rx_crc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 crc = crc32_le(crc, mac4, 6);
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300977
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 priv->frag_seq = seq_no;
979 priv->frag_no = 1;
980 priv->frag_len = msdu_size;
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300981 memcpy(priv->frag_source, source, 6);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 memcpy(&priv->rx_buf[6], source, 6);
983 memcpy(priv->rx_buf, header->addr1, 6);
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300984
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 atmel_copy_to_host(priv->dev, &priv->rx_buf[12], rx_packet_loc, msdu_size);
986
987 if (priv->do_rx_crc) {
988 u32 netcrc;
989 crc = crc32_le(crc, &priv->rx_buf[12], msdu_size);
990 atmel_copy_to_host(priv->dev, (void *)&netcrc, rx_packet_loc + msdu_size, 4);
991 if ((crc ^ 0xffffffff) != netcrc) {
Paulius Zaleckas736bc922008-05-06 23:50:30 +0300992 priv->dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 memset(priv->frag_source, 0xff, 6);
994 }
995 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +0300996
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 } else if (priv->frag_no == frag_no &&
998 priv->frag_seq == seq_no &&
999 memcmp(priv->frag_source, source, 6) == 0) {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001000
1001 atmel_copy_to_host(priv->dev, &priv->rx_buf[12 + priv->frag_len],
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 rx_packet_loc, msdu_size);
1003 if (priv->do_rx_crc) {
1004 u32 netcrc;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001005 crc = crc32_le(crc,
1006 &priv->rx_buf[12 + priv->frag_len],
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 msdu_size);
1008 atmel_copy_to_host(priv->dev, (void *)&netcrc, rx_packet_loc + msdu_size, 4);
1009 if ((crc ^ 0xffffffff) != netcrc) {
Paulius Zaleckas736bc922008-05-06 23:50:30 +03001010 priv->dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 memset(priv->frag_source, 0xff, 6);
1012 more_frags = 1; /* don't send broken assembly */
1013 }
1014 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001015
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 priv->frag_len += msdu_size;
1017 priv->frag_no++;
1018
1019 if (!more_frags) { /* last one */
1020 memset(priv->frag_source, 0xff, 6);
1021 if (!(skb = dev_alloc_skb(priv->frag_len + 14))) {
Paulius Zaleckas736bc922008-05-06 23:50:30 +03001022 priv->dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 } else {
1024 skb_reserve(skb, 2);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001025 memcpy(skb_put(skb, priv->frag_len + 12),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 priv->rx_buf,
1027 priv->frag_len + 12);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 skb->protocol = eth_type_trans(skb, priv->dev);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001029 skb->ip_summed = CHECKSUM_NONE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 netif_rx(skb);
Paulius Zaleckas736bc922008-05-06 23:50:30 +03001031 priv->dev->stats.rx_bytes += priv->frag_len + 12;
1032 priv->dev->stats.rx_packets++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 }
1034 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 } else
1036 priv->wstats.discard.fragment++;
1037}
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001038
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039static void rx_done_irq(struct atmel_private *priv)
1040{
1041 int i;
Johannes Berg2c7060022008-10-30 22:09:54 +01001042 struct ieee80211_hdr header;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001043
1044 for (i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 atmel_rmem8(priv, atmel_rx(priv, RX_DESC_FLAGS_OFFSET, priv->rx_desc_head)) == RX_DESC_FLAG_VALID &&
1046 i < priv->host_info.rx_desc_count;
1047 i++) {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001048
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 u16 msdu_size, rx_packet_loc, frame_ctl, seq_control;
1050 u8 status = atmel_rmem8(priv, atmel_rx(priv, RX_DESC_STATUS_OFFSET, priv->rx_desc_head));
1051 u32 crc = 0xffffffff;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001052
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 if (status != RX_STATUS_SUCCESS) {
1054 if (status == 0xc1) /* determined by experiment */
1055 priv->wstats.discard.nwid++;
1056 else
Paulius Zaleckas736bc922008-05-06 23:50:30 +03001057 priv->dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 goto next;
1059 }
1060
1061 msdu_size = atmel_rmem16(priv, atmel_rx(priv, RX_DESC_MSDU_SIZE_OFFSET, priv->rx_desc_head));
1062 rx_packet_loc = atmel_rmem16(priv, atmel_rx(priv, RX_DESC_MSDU_POS_OFFSET, priv->rx_desc_head));
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001063
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 if (msdu_size < 30) {
Paulius Zaleckas736bc922008-05-06 23:50:30 +03001065 priv->dev->stats.rx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066 goto next;
1067 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001068
Johannes Berg2c7060022008-10-30 22:09:54 +01001069 /* Get header as far as end of seq_ctrl */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 atmel_copy_to_host(priv->dev, (char *)&header, rx_packet_loc, 24);
Johannes Berg2c7060022008-10-30 22:09:54 +01001071 frame_ctl = le16_to_cpu(header.frame_control);
1072 seq_control = le16_to_cpu(header.seq_ctrl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001074 /* probe for CRC use here if needed once five packets have
1075 arrived with the same crc status, we assume we know what's
1076 happening and stop probing */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 if (priv->probe_crc) {
Jiri Bencf13baae2005-08-25 20:11:46 -04001078 if (!priv->wep_is_on || !(frame_ctl & IEEE80211_FCTL_PROTECTED)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 priv->do_rx_crc = probe_crc(priv, rx_packet_loc, msdu_size);
1080 } else {
1081 priv->do_rx_crc = probe_crc(priv, rx_packet_loc + 24, msdu_size - 24);
1082 }
1083 if (priv->do_rx_crc) {
1084 if (priv->crc_ok_cnt++ > 5)
1085 priv->probe_crc = 0;
1086 } else {
1087 if (priv->crc_ko_cnt++ > 5)
1088 priv->probe_crc = 0;
1089 }
1090 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001091
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 /* don't CRC header when WEP in use */
Jiri Bencf13baae2005-08-25 20:11:46 -04001093 if (priv->do_rx_crc && (!priv->wep_is_on || !(frame_ctl & IEEE80211_FCTL_PROTECTED))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 crc = crc32_le(0xffffffff, (unsigned char *)&header, 24);
1095 }
1096 msdu_size -= 24; /* header */
1097
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001098 if ((frame_ctl & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA) {
Jeff Garzikb4538722005-05-12 22:48:20 -04001099 int more_fragments = frame_ctl & IEEE80211_FCTL_MOREFRAGS;
1100 u8 packet_fragment_no = seq_control & IEEE80211_SCTL_FRAG;
1101 u16 packet_sequence_no = (seq_control & IEEE80211_SCTL_SEQ) >> 4;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001102
1103 if (!more_fragments && packet_fragment_no == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 fast_rx_path(priv, &header, msdu_size, rx_packet_loc, crc);
1105 } else {
1106 frag_rx_path(priv, &header, msdu_size, rx_packet_loc, crc,
1107 packet_sequence_no, packet_fragment_no, more_fragments);
1108 }
1109 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001110
Jeff Garzikb4538722005-05-12 22:48:20 -04001111 if ((frame_ctl & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 /* copy rest of packet into buffer */
1113 atmel_copy_to_host(priv->dev, (unsigned char *)&priv->rx_buf, rx_packet_loc + 24, msdu_size);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001114
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 /* we use the same buffer for frag reassembly and control packets */
1116 memset(priv->frag_source, 0xff, 6);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001117
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 if (priv->do_rx_crc) {
1119 /* last 4 octets is crc */
1120 msdu_size -= 4;
1121 crc = crc32_le(crc, (unsigned char *)&priv->rx_buf, msdu_size);
1122 if ((crc ^ 0xffffffff) != (*((u32 *)&priv->rx_buf[msdu_size]))) {
Paulius Zaleckas736bc922008-05-06 23:50:30 +03001123 priv->dev->stats.rx_crc_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 goto next;
1125 }
1126 }
1127
1128 atmel_management_frame(priv, &header, msdu_size,
1129 atmel_rmem8(priv, atmel_rx(priv, RX_DESC_RSSI_OFFSET, priv->rx_desc_head)));
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001130 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001132next:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 /* release descriptor */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001134 atmel_wmem8(priv, atmel_rx(priv, RX_DESC_FLAGS_OFFSET, priv->rx_desc_head), RX_DESC_FLAG_CONSUMED);
1135
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 if (priv->rx_desc_head < (priv->host_info.rx_desc_count - 1))
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001137 priv->rx_desc_head++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 else
1139 priv->rx_desc_head = 0;
1140 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001141}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142
David Howells7d12e782006-10-05 14:55:46 +01001143static irqreturn_t service_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144{
1145 struct net_device *dev = (struct net_device *) dev_id;
1146 struct atmel_private *priv = netdev_priv(dev);
1147 u8 isr;
1148 int i = -1;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001149 static u8 irq_order[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 ISR_OUT_OF_RANGE,
1151 ISR_RxCOMPLETE,
1152 ISR_TxCOMPLETE,
1153 ISR_RxFRAMELOST,
1154 ISR_FATAL_ERROR,
1155 ISR_COMMAND_COMPLETE,
1156 ISR_IBSS_MERGE,
1157 ISR_GENERIC_IRQ
1158 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001160 if (priv->card && priv->present_callback &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 !(*priv->present_callback)(priv->card))
1162 return IRQ_HANDLED;
1163
1164 /* In this state upper-level code assumes it can mess with
1165 the card unhampered by interrupts which may change register state.
1166 Note that even though the card shouldn't generate interrupts
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001167 the inturrupt line may be shared. This allows card setup
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 to go on without disabling interrupts for a long time. */
1169 if (priv->station_state == STATION_STATE_DOWN)
1170 return IRQ_NONE;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001171
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 atmel_clear_gcr(dev, GCR_ENINT); /* disable interrupts */
1173
1174 while (1) {
1175 if (!atmel_lock_mac(priv)) {
1176 /* failed to contact card */
1177 printk(KERN_ALERT "%s: failed to contact MAC.\n", dev->name);
1178 return IRQ_HANDLED;
1179 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001180
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 isr = atmel_rmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET));
1182 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001183
Linus Torvalds1da177e2005-04-16 15:20:36 -07001184 if (!isr) {
1185 atmel_set_gcr(dev, GCR_ENINT); /* enable interrupts */
1186 return i == -1 ? IRQ_NONE : IRQ_HANDLED;
1187 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001188
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 atmel_set_gcr(dev, GCR_ACKINT); /* acknowledge interrupt */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001190
Dmitry Torokhovb4341132006-10-08 00:14:29 -04001191 for (i = 0; i < ARRAY_SIZE(irq_order); i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 if (isr & irq_order[i])
1193 break;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001194
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 if (!atmel_lock_mac(priv)) {
1196 /* failed to contact card */
1197 printk(KERN_ALERT "%s: failed to contact MAC.\n", dev->name);
1198 return IRQ_HANDLED;
1199 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001200
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 isr = atmel_rmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET));
1202 isr ^= irq_order[i];
1203 atmel_wmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET), isr);
1204 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001205
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 switch (irq_order[i]) {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001207
1208 case ISR_OUT_OF_RANGE:
1209 if (priv->operating_mode == IW_MODE_INFRA &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 priv->station_state == STATION_STATE_READY) {
1211 priv->station_is_associated = 0;
1212 atmel_scan(priv, 1);
1213 }
1214 break;
1215
1216 case ISR_RxFRAMELOST:
1217 priv->wstats.discard.misc++;
1218 /* fall through */
1219 case ISR_RxCOMPLETE:
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001220 rx_done_irq(priv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 break;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001222
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 case ISR_TxCOMPLETE:
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001224 tx_done_irq(priv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 break;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001226
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 case ISR_FATAL_ERROR:
1228 printk(KERN_ALERT "%s: *** FATAL error interrupt ***\n", dev->name);
1229 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
1230 break;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001231
1232 case ISR_COMMAND_COMPLETE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 atmel_command_irq(priv);
1234 break;
1235
1236 case ISR_IBSS_MERGE:
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001237 atmel_get_mib(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_CUR_BSSID_POS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 priv->CurrentBSSID, 6);
1239 /* The WPA stuff cares about the current AP address */
1240 if (priv->use_wpa)
1241 build_wpa_mib(priv);
1242 break;
1243 case ISR_GENERIC_IRQ:
1244 printk(KERN_INFO "%s: Generic_irq received.\n", dev->name);
1245 break;
1246 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001247 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248}
1249
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001250static struct iw_statistics *atmel_get_wireless_stats(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251{
1252 struct atmel_private *priv = netdev_priv(dev);
1253
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001254 /* update the link quality here in case we are seeing no beacons
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 at all to drive the process */
1256 atmel_smooth_qual(priv);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001257
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 priv->wstats.status = priv->station_state;
1259
1260 if (priv->operating_mode == IW_MODE_INFRA) {
1261 if (priv->station_state != STATION_STATE_READY) {
1262 priv->wstats.qual.qual = 0;
1263 priv->wstats.qual.level = 0;
1264 priv->wstats.qual.updated = (IW_QUAL_QUAL_INVALID
1265 | IW_QUAL_LEVEL_INVALID);
1266 }
1267 priv->wstats.qual.noise = 0;
1268 priv->wstats.qual.updated |= IW_QUAL_NOISE_INVALID;
1269 } else {
1270 /* Quality levels cannot be determined in ad-hoc mode,
1271 because we can 'hear' more that one remote station. */
1272 priv->wstats.qual.qual = 0;
1273 priv->wstats.qual.level = 0;
1274 priv->wstats.qual.noise = 0;
1275 priv->wstats.qual.updated = IW_QUAL_QUAL_INVALID
1276 | IW_QUAL_LEVEL_INVALID
1277 | IW_QUAL_NOISE_INVALID;
1278 priv->wstats.miss.beacon = 0;
1279 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001280
1281 return &priv->wstats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282}
1283
1284static int atmel_change_mtu(struct net_device *dev, int new_mtu)
1285{
1286 if ((new_mtu < 68) || (new_mtu > 2312))
1287 return -EINVAL;
1288 dev->mtu = new_mtu;
1289 return 0;
1290}
1291
1292static int atmel_set_mac_address(struct net_device *dev, void *p)
1293{
1294 struct sockaddr *addr = p;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001295
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 memcpy (dev->dev_addr, addr->sa_data, dev->addr_len);
1297 return atmel_open(dev);
1298}
1299
1300EXPORT_SYMBOL(atmel_open);
1301
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001302int atmel_open(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303{
1304 struct atmel_private *priv = netdev_priv(dev);
Dan Williams3c34a5d2008-08-18 15:40:02 -04001305 int i, channel, err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306
1307 /* any scheduled timer is no longer needed and might screw things up.. */
1308 del_timer_sync(&priv->management_timer);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001309
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 /* Interrupts will not touch the card once in this state... */
1311 priv->station_state = STATION_STATE_DOWN;
1312
1313 if (priv->new_SSID_size) {
1314 memcpy(priv->SSID, priv->new_SSID, priv->new_SSID_size);
1315 priv->SSID_size = priv->new_SSID_size;
1316 priv->new_SSID_size = 0;
1317 }
1318 priv->BSS_list_entries = 0;
1319
1320 priv->AuthenticationRequestRetryCnt = 0;
1321 priv->AssociationRequestRetryCnt = 0;
1322 priv->ReAssociationRequestRetryCnt = 0;
1323 priv->CurrentAuthentTransactionSeqNum = 0x0001;
1324 priv->ExpectedAuthentTransactionSeqNum = 0x0002;
1325
1326 priv->site_survey_state = SITE_SURVEY_IDLE;
1327 priv->station_is_associated = 0;
1328
Dan Williams3c34a5d2008-08-18 15:40:02 -04001329 err = reset_atmel_card(dev);
1330 if (err)
1331 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332
1333 if (priv->config_reg_domain) {
1334 priv->reg_domain = priv->config_reg_domain;
1335 atmel_set_mib8(priv, Phy_Mib_Type, PHY_MIB_REG_DOMAIN_POS, priv->reg_domain);
1336 } else {
1337 priv->reg_domain = atmel_get_mib8(priv, Phy_Mib_Type, PHY_MIB_REG_DOMAIN_POS);
Dmitry Torokhovb4341132006-10-08 00:14:29 -04001338 for (i = 0; i < ARRAY_SIZE(channel_table); i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 if (priv->reg_domain == channel_table[i].reg_domain)
1340 break;
Dmitry Torokhovb4341132006-10-08 00:14:29 -04001341 if (i == ARRAY_SIZE(channel_table)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 priv->reg_domain = REG_DOMAIN_MKK1;
1343 printk(KERN_ALERT "%s: failed to get regulatory domain: assuming MKK1.\n", dev->name);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001344 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001346
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 if ((channel = atmel_validate_channel(priv, priv->channel)))
1348 priv->channel = channel;
1349
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001350 /* this moves station_state on.... */
1351 atmel_scan(priv, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352
1353 atmel_set_gcr(priv->dev, GCR_ENINT); /* enable interrupts */
1354 return 0;
1355}
1356
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001357static int atmel_close(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358{
1359 struct atmel_private *priv = netdev_priv(dev);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001360
Dan Williams9a6301c2006-01-10 00:56:11 -05001361 /* Send event to userspace that we are disassociating */
1362 if (priv->station_state == STATION_STATE_READY) {
1363 union iwreq_data wrqu;
1364
1365 wrqu.data.length = 0;
1366 wrqu.data.flags = 0;
1367 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1368 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
1369 wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
1370 }
1371
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 atmel_enter_state(priv, STATION_STATE_DOWN);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001373
1374 if (priv->bus_type == BUS_TYPE_PCCARD)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 atmel_write16(dev, GCR, 0x0060);
1376 atmel_write16(dev, GCR, 0x0040);
1377 return 0;
1378}
1379
1380static int atmel_validate_channel(struct atmel_private *priv, int channel)
1381{
1382 /* check that channel is OK, if so return zero,
1383 else return suitable default channel */
1384 int i;
1385
Dmitry Torokhovb4341132006-10-08 00:14:29 -04001386 for (i = 0; i < ARRAY_SIZE(channel_table); i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 if (priv->reg_domain == channel_table[i].reg_domain) {
1388 if (channel >= channel_table[i].min &&
1389 channel <= channel_table[i].max)
1390 return 0;
1391 else
1392 return channel_table[i].min;
1393 }
1394 return 0;
1395}
1396
1397static int atmel_proc_output (char *buf, struct atmel_private *priv)
1398{
1399 int i;
1400 char *p = buf;
1401 char *s, *r, *c;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001402
1403 p += sprintf(p, "Driver version:\t\t%d.%d\n",
1404 DRIVER_MAJOR, DRIVER_MINOR);
1405
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 if (priv->station_state != STATION_STATE_DOWN) {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001407 p += sprintf(p, "Firmware version:\t%d.%d build %d\n"
1408 "Firmware location:\t",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 priv->host_info.major_version,
1410 priv->host_info.minor_version,
1411 priv->host_info.build_version);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001412
1413 if (priv->card_type != CARD_TYPE_EEPROM)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 p += sprintf(p, "on card\n");
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001415 else if (priv->firmware)
1416 p += sprintf(p, "%s loaded by host\n",
1417 priv->firmware_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 else
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001419 p += sprintf(p, "%s loaded by hotplug\n",
1420 priv->firmware_id);
1421
1422 switch (priv->card_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 case CARD_TYPE_PARALLEL_FLASH: c = "Parallel flash"; break;
1424 case CARD_TYPE_SPI_FLASH: c = "SPI flash\n"; break;
1425 case CARD_TYPE_EEPROM: c = "EEPROM"; break;
1426 default: c = "<unknown>";
1427 }
1428
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429 r = "<unknown>";
Dmitry Torokhovb4341132006-10-08 00:14:29 -04001430 for (i = 0; i < ARRAY_SIZE(channel_table); i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 if (priv->reg_domain == channel_table[i].reg_domain)
1432 r = channel_table[i].name;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001433
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 p += sprintf(p, "MAC memory type:\t%s\n", c);
1435 p += sprintf(p, "Regulatory domain:\t%s\n", r);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001436 p += sprintf(p, "Host CRC checking:\t%s\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 priv->do_rx_crc ? "On" : "Off");
1438 p += sprintf(p, "WPA-capable firmware:\t%s\n",
1439 priv->use_wpa ? "Yes" : "No");
1440 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001441
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 switch(priv->station_state) {
1443 case STATION_STATE_SCANNING: s = "Scanning"; break;
1444 case STATION_STATE_JOINNING: s = "Joining"; break;
1445 case STATION_STATE_AUTHENTICATING: s = "Authenticating"; break;
1446 case STATION_STATE_ASSOCIATING: s = "Associating"; break;
1447 case STATION_STATE_READY: s = "Ready"; break;
1448 case STATION_STATE_REASSOCIATING: s = "Reassociating"; break;
1449 case STATION_STATE_MGMT_ERROR: s = "Management error"; break;
1450 case STATION_STATE_DOWN: s = "Down"; break;
1451 default: s = "<unknown>";
1452 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001453
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 p += sprintf(p, "Current state:\t\t%s\n", s);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001455 return p - buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456}
1457
1458static int atmel_read_proc(char *page, char **start, off_t off,
1459 int count, int *eof, void *data)
1460{
1461 struct atmel_private *priv = data;
1462 int len = atmel_proc_output (page, priv);
1463 if (len <= off+count) *eof = 1;
1464 *start = page + off;
1465 len -= off;
1466 if (len>count) len = count;
1467 if (len<0) len = 0;
1468 return len;
1469}
1470
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001471struct net_device *init_atmel_card(unsigned short irq, unsigned long port,
1472 const AtmelFWType fw_type,
1473 struct device *sys_dev,
1474 int (*card_present)(void *), void *card)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475{
Christophe Lucas5bc4c362005-11-12 21:58:53 +03001476 struct proc_dir_entry *ent;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477 struct net_device *dev;
1478 struct atmel_private *priv;
1479 int rc;
1480
1481 /* Create the network device object. */
1482 dev = alloc_etherdev(sizeof(*priv));
1483 if (!dev) {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001484 printk(KERN_ERR "atmel: Couldn't alloc_etherdev\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 return NULL;
1486 }
1487 if (dev_alloc_name(dev, dev->name) < 0) {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001488 printk(KERN_ERR "atmel: Couldn't get name!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 goto err_out_free;
1490 }
1491
1492 priv = netdev_priv(dev);
1493 priv->dev = dev;
1494 priv->sys_dev = sys_dev;
1495 priv->present_callback = card_present;
1496 priv->card = card;
1497 priv->firmware = NULL;
1498 priv->firmware_id[0] = '\0';
1499 priv->firmware_type = fw_type;
1500 if (firmware) /* module parameter */
1501 strcpy(priv->firmware_id, firmware);
1502 priv->bus_type = card_present ? BUS_TYPE_PCCARD : BUS_TYPE_PCI;
1503 priv->station_state = STATION_STATE_DOWN;
1504 priv->do_rx_crc = 0;
1505 /* For PCMCIA cards, some chips need CRC, some don't
1506 so we have to probe. */
1507 if (priv->bus_type == BUS_TYPE_PCCARD) {
1508 priv->probe_crc = 1;
1509 priv->crc_ok_cnt = priv->crc_ko_cnt = 0;
1510 } else
1511 priv->probe_crc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 priv->last_qual = jiffies;
1513 priv->last_beacon_timestamp = 0;
1514 memset(priv->frag_source, 0xff, sizeof(priv->frag_source));
1515 memset(priv->BSSID, 0, 6);
1516 priv->CurrentBSSID[0] = 0xFF; /* Initialize to something invalid.... */
1517 priv->station_was_associated = 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001518
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 priv->last_survey = jiffies;
1520 priv->preamble = LONG_PREAMBLE;
1521 priv->operating_mode = IW_MODE_INFRA;
1522 priv->connect_to_any_BSS = 0;
1523 priv->config_reg_domain = 0;
1524 priv->reg_domain = 0;
1525 priv->tx_rate = 3;
1526 priv->auto_tx_rate = 1;
1527 priv->channel = 4;
1528 priv->power_mode = 0;
1529 priv->SSID[0] = '\0';
1530 priv->SSID_size = 0;
1531 priv->new_SSID_size = 0;
1532 priv->frag_threshold = 2346;
1533 priv->rts_threshold = 2347;
1534 priv->short_retry = 7;
1535 priv->long_retry = 4;
1536
1537 priv->wep_is_on = 0;
1538 priv->default_key = 0;
1539 priv->encryption_level = 0;
1540 priv->exclude_unencrypted = 0;
1541 priv->group_cipher_suite = priv->pairwise_cipher_suite = CIPHER_SUITE_NONE;
1542 priv->use_wpa = 0;
1543 memset(priv->wep_keys, 0, sizeof(priv->wep_keys));
1544 memset(priv->wep_key_len, 0, sizeof(priv->wep_key_len));
1545
1546 priv->default_beacon_period = priv->beacon_period = 100;
1547 priv->listen_interval = 1;
1548
1549 init_timer(&priv->management_timer);
1550 spin_lock_init(&priv->irqlock);
1551 spin_lock_init(&priv->timerlock);
1552 priv->management_timer.function = atmel_management_timer;
1553 priv->management_timer.data = (unsigned long) dev;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001554
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 dev->open = atmel_open;
1556 dev->stop = atmel_close;
1557 dev->change_mtu = atmel_change_mtu;
1558 dev->set_mac_address = atmel_set_mac_address;
1559 dev->hard_start_xmit = start_tx;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560 dev->wireless_handlers = (struct iw_handler_def *)&atmel_handler_def;
1561 dev->do_ioctl = atmel_ioctl;
1562 dev->irq = irq;
1563 dev->base_addr = port;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001564
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 SET_NETDEV_DEV(dev, sys_dev);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001566
Thomas Gleixner1fb9df52006-07-01 19:29:39 -07001567 if ((rc = request_irq(dev->irq, service_interrupt, IRQF_SHARED, dev->name, dev))) {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001568 printk(KERN_ERR "%s: register interrupt %d failed, rc %d\n", dev->name, irq, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 goto err_out_free;
1570 }
1571
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001572 if (!request_region(dev->base_addr, 32,
simon@thekelleys.org.ukb16a2282005-10-30 15:50:15 +00001573 priv->bus_type == BUS_TYPE_PCCARD ? "atmel_cs" : "atmel_pci")) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 goto err_out_irq;
1575 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001576
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 if (register_netdev(dev))
1578 goto err_out_res;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001579
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 if (!probe_atmel_card(dev)){
1581 unregister_netdev(dev);
1582 goto err_out_res;
1583 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001584
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 netif_carrier_off(dev);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001586
Christophe Lucas5bc4c362005-11-12 21:58:53 +03001587 ent = create_proc_read_entry ("driver/atmel", 0, NULL, atmel_read_proc, priv);
1588 if (!ent)
1589 printk(KERN_WARNING "atmel: unable to create /proc entry.\n");
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001590
Johannes Berge1749612008-10-27 15:59:26 -07001591 printk(KERN_INFO "%s: Atmel at76c50x. Version %d.%d. MAC %pM\n",
1592 dev->name, DRIVER_MAJOR, DRIVER_MINOR, dev->dev_addr);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001593
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594 return dev;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001595
1596err_out_res:
simon@thekelleys.org.ukb16a2282005-10-30 15:50:15 +00001597 release_region( dev->base_addr, 32);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001598err_out_irq:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 free_irq(dev->irq, dev);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001600err_out_free:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 free_netdev(dev);
1602 return NULL;
1603}
1604
1605EXPORT_SYMBOL(init_atmel_card);
1606
simon@thekelleys.org.ukb16a2282005-10-30 15:50:15 +00001607void stop_atmel_card(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608{
1609 struct atmel_private *priv = netdev_priv(dev);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001610
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 /* put a brick on it... */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001612 if (priv->bus_type == BUS_TYPE_PCCARD)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613 atmel_write16(dev, GCR, 0x0060);
1614 atmel_write16(dev, GCR, 0x0040);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001615
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 del_timer_sync(&priv->management_timer);
1617 unregister_netdev(dev);
1618 remove_proc_entry("driver/atmel", NULL);
1619 free_irq(dev->irq, dev);
Jesper Juhlb4558ea2005-10-28 16:53:13 -04001620 kfree(priv->firmware);
simon@thekelleys.org.ukb16a2282005-10-30 15:50:15 +00001621 release_region(dev->base_addr, 32);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 free_netdev(dev);
1623}
1624
1625EXPORT_SYMBOL(stop_atmel_card);
1626
1627static int atmel_set_essid(struct net_device *dev,
1628 struct iw_request_info *info,
1629 struct iw_point *dwrq,
1630 char *extra)
1631{
1632 struct atmel_private *priv = netdev_priv(dev);
1633
1634 /* Check if we asked for `any' */
1635 if(dwrq->flags == 0) {
1636 priv->connect_to_any_BSS = 1;
1637 } else {
1638 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1639
1640 priv->connect_to_any_BSS = 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001641
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 /* Check the size of the string */
Jean Tourrilhes6a484db2006-08-29 17:59:03 -07001643 if (dwrq->length > MAX_SSID_LENGTH)
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001644 return -E2BIG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 if (index != 0)
1646 return -EINVAL;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001647
Jean Tourrilhes6a484db2006-08-29 17:59:03 -07001648 memcpy(priv->new_SSID, extra, dwrq->length);
1649 priv->new_SSID_size = dwrq->length;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 }
1651
1652 return -EINPROGRESS;
1653}
1654
1655static int atmel_get_essid(struct net_device *dev,
1656 struct iw_request_info *info,
1657 struct iw_point *dwrq,
1658 char *extra)
1659{
1660 struct atmel_private *priv = netdev_priv(dev);
1661
1662 /* Get the current SSID */
1663 if (priv->new_SSID_size != 0) {
1664 memcpy(extra, priv->new_SSID, priv->new_SSID_size);
Dan Williamsd6a13a22006-01-12 15:00:58 -05001665 dwrq->length = priv->new_SSID_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 } else {
1667 memcpy(extra, priv->SSID, priv->SSID_size);
Dan Williamsd6a13a22006-01-12 15:00:58 -05001668 dwrq->length = priv->SSID_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001670
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 dwrq->flags = !priv->connect_to_any_BSS; /* active */
1672
1673 return 0;
1674}
1675
1676static int atmel_get_wap(struct net_device *dev,
1677 struct iw_request_info *info,
1678 struct sockaddr *awrq,
1679 char *extra)
1680{
1681 struct atmel_private *priv = netdev_priv(dev);
1682 memcpy(awrq->sa_data, priv->CurrentBSSID, 6);
1683 awrq->sa_family = ARPHRD_ETHER;
1684
1685 return 0;
1686}
1687
1688static int atmel_set_encode(struct net_device *dev,
1689 struct iw_request_info *info,
1690 struct iw_point *dwrq,
1691 char *extra)
1692{
1693 struct atmel_private *priv = netdev_priv(dev);
1694
1695 /* Basic checking: do we have a key to set ?
1696 * Note : with the new API, it's impossible to get a NULL pointer.
1697 * Therefore, we need to check a key size == 0 instead.
1698 * New version of iwconfig properly set the IW_ENCODE_NOKEY flag
1699 * when no key is present (only change flags), but older versions
1700 * don't do it. - Jean II */
1701 if (dwrq->length > 0) {
1702 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1703 int current_index = priv->default_key;
1704 /* Check the size of the key */
1705 if (dwrq->length > 13) {
1706 return -EINVAL;
1707 }
1708 /* Check the index (none -> use current) */
1709 if (index < 0 || index >= 4)
1710 index = current_index;
1711 else
1712 priv->default_key = index;
1713 /* Set the length */
1714 if (dwrq->length > 5)
1715 priv->wep_key_len[index] = 13;
1716 else
1717 if (dwrq->length > 0)
1718 priv->wep_key_len[index] = 5;
1719 else
1720 /* Disable the key */
1721 priv->wep_key_len[index] = 0;
1722 /* Check if the key is not marked as invalid */
Dmitry Torokhov5c877fe2006-10-08 00:14:30 -04001723 if (!(dwrq->flags & IW_ENCODE_NOKEY)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 /* Cleanup */
1725 memset(priv->wep_keys[index], 0, 13);
1726 /* Copy the key in the driver */
1727 memcpy(priv->wep_keys[index], extra, dwrq->length);
1728 }
1729 /* WE specify that if a valid key is set, encryption
1730 * should be enabled (user may turn it off later)
1731 * This is also how "iwconfig ethX key on" works */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001732 if (index == current_index &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 priv->wep_key_len[index] > 0) {
1734 priv->wep_is_on = 1;
1735 priv->exclude_unencrypted = 1;
1736 if (priv->wep_key_len[index] > 5) {
Dan Williams9a6301c2006-01-10 00:56:11 -05001737 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_128;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 priv->encryption_level = 2;
1739 } else {
Dan Williams9a6301c2006-01-10 00:56:11 -05001740 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_64;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 priv->encryption_level = 1;
1742 }
1743 }
1744 } else {
1745 /* Do we want to just set the transmit key index ? */
1746 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001747 if (index >= 0 && index < 4) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 priv->default_key = index;
1749 } else
1750 /* Don't complain if only change the mode */
Jeff Garzik93a3b602007-11-23 21:50:20 -05001751 if (!(dwrq->flags & IW_ENCODE_MODE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 }
1754 /* Read the flags */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001755 if (dwrq->flags & IW_ENCODE_DISABLED) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756 priv->wep_is_on = 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001757 priv->encryption_level = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 priv->pairwise_cipher_suite = CIPHER_SUITE_NONE;
1759 } else {
1760 priv->wep_is_on = 1;
1761 if (priv->wep_key_len[priv->default_key] > 5) {
1762 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_128;
1763 priv->encryption_level = 2;
1764 } else {
1765 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_64;
1766 priv->encryption_level = 1;
1767 }
1768 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001769 if (dwrq->flags & IW_ENCODE_RESTRICTED)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 priv->exclude_unencrypted = 1;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001771 if(dwrq->flags & IW_ENCODE_OPEN)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 priv->exclude_unencrypted = 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001773
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 return -EINPROGRESS; /* Call commit handler */
1775}
1776
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777static int atmel_get_encode(struct net_device *dev,
1778 struct iw_request_info *info,
1779 struct iw_point *dwrq,
1780 char *extra)
1781{
1782 struct atmel_private *priv = netdev_priv(dev);
1783 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001784
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 if (!priv->wep_is_on)
1786 dwrq->flags = IW_ENCODE_DISABLED;
simon@thekelleys.org.ukb16a2282005-10-30 15:50:15 +00001787 else {
1788 if (priv->exclude_unencrypted)
1789 dwrq->flags = IW_ENCODE_RESTRICTED;
1790 else
1791 dwrq->flags = IW_ENCODE_OPEN;
1792 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 /* Which key do we want ? -1 -> tx index */
1794 if (index < 0 || index >= 4)
1795 index = priv->default_key;
1796 dwrq->flags |= index + 1;
1797 /* Copy the key to the user buffer */
1798 dwrq->length = priv->wep_key_len[index];
1799 if (dwrq->length > 16) {
1800 dwrq->length=0;
1801 } else {
1802 memset(extra, 0, 16);
1803 memcpy(extra, priv->wep_keys[index], dwrq->length);
1804 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03001805
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 return 0;
1807}
1808
Dan Williams9a6301c2006-01-10 00:56:11 -05001809static int atmel_set_encodeext(struct net_device *dev,
1810 struct iw_request_info *info,
1811 union iwreq_data *wrqu,
1812 char *extra)
1813{
1814 struct atmel_private *priv = netdev_priv(dev);
1815 struct iw_point *encoding = &wrqu->encoding;
1816 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
Dan Williams0d467502006-02-05 17:52:21 -05001817 int idx, key_len, alg = ext->alg, set_key = 1;
Dan Williams9a6301c2006-01-10 00:56:11 -05001818
1819 /* Determine and validate the key index */
1820 idx = encoding->flags & IW_ENCODE_INDEX;
1821 if (idx) {
Johannes Berg2c7060022008-10-30 22:09:54 +01001822 if (idx < 1 || idx > 4)
Dan Williams9a6301c2006-01-10 00:56:11 -05001823 return -EINVAL;
1824 idx--;
1825 } else
1826 idx = priv->default_key;
1827
Dan Williams0d467502006-02-05 17:52:21 -05001828 if (encoding->flags & IW_ENCODE_DISABLED)
1829 alg = IW_ENCODE_ALG_NONE;
1830
1831 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
1832 priv->default_key = idx;
1833 set_key = ext->key_len > 0 ? 1 : 0;
Dan Williams9a6301c2006-01-10 00:56:11 -05001834 }
1835
Dan Williams0d467502006-02-05 17:52:21 -05001836 if (set_key) {
1837 /* Set the requested key first */
1838 switch (alg) {
1839 case IW_ENCODE_ALG_NONE:
1840 priv->wep_is_on = 0;
1841 priv->encryption_level = 0;
1842 priv->pairwise_cipher_suite = CIPHER_SUITE_NONE;
1843 break;
1844 case IW_ENCODE_ALG_WEP:
1845 if (ext->key_len > 5) {
1846 priv->wep_key_len[idx] = 13;
1847 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_128;
1848 priv->encryption_level = 2;
1849 } else if (ext->key_len > 0) {
1850 priv->wep_key_len[idx] = 5;
1851 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_64;
1852 priv->encryption_level = 1;
1853 } else {
1854 return -EINVAL;
1855 }
1856 priv->wep_is_on = 1;
1857 memset(priv->wep_keys[idx], 0, 13);
1858 key_len = min ((int)ext->key_len, priv->wep_key_len[idx]);
1859 memcpy(priv->wep_keys[idx], ext->key, key_len);
1860 break;
1861 default:
Dan Williams9a6301c2006-01-10 00:56:11 -05001862 return -EINVAL;
1863 }
Dan Williams9a6301c2006-01-10 00:56:11 -05001864 }
1865
1866 return -EINPROGRESS;
1867}
1868
1869static int atmel_get_encodeext(struct net_device *dev,
1870 struct iw_request_info *info,
1871 union iwreq_data *wrqu,
1872 char *extra)
1873{
1874 struct atmel_private *priv = netdev_priv(dev);
1875 struct iw_point *encoding = &wrqu->encoding;
1876 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
1877 int idx, max_key_len;
1878
1879 max_key_len = encoding->length - sizeof(*ext);
1880 if (max_key_len < 0)
1881 return -EINVAL;
1882
1883 idx = encoding->flags & IW_ENCODE_INDEX;
1884 if (idx) {
Johannes Berg2c7060022008-10-30 22:09:54 +01001885 if (idx < 1 || idx > 4)
Dan Williams9a6301c2006-01-10 00:56:11 -05001886 return -EINVAL;
1887 idx--;
1888 } else
1889 idx = priv->default_key;
1890
1891 encoding->flags = idx + 1;
1892 memset(ext, 0, sizeof(*ext));
Dmitry Torokhov5c877fe2006-10-08 00:14:30 -04001893
Dan Williams9a6301c2006-01-10 00:56:11 -05001894 if (!priv->wep_is_on) {
1895 ext->alg = IW_ENCODE_ALG_NONE;
1896 ext->key_len = 0;
1897 encoding->flags |= IW_ENCODE_DISABLED;
1898 } else {
1899 if (priv->encryption_level > 0)
1900 ext->alg = IW_ENCODE_ALG_WEP;
1901 else
1902 return -EINVAL;
1903
1904 ext->key_len = priv->wep_key_len[idx];
1905 memcpy(ext->key, priv->wep_keys[idx], ext->key_len);
1906 encoding->flags |= IW_ENCODE_ENABLED;
1907 }
1908
1909 return 0;
1910}
1911
1912static int atmel_set_auth(struct net_device *dev,
1913 struct iw_request_info *info,
1914 union iwreq_data *wrqu, char *extra)
1915{
1916 struct atmel_private *priv = netdev_priv(dev);
1917 struct iw_param *param = &wrqu->param;
1918
1919 switch (param->flags & IW_AUTH_INDEX) {
1920 case IW_AUTH_WPA_VERSION:
1921 case IW_AUTH_CIPHER_PAIRWISE:
1922 case IW_AUTH_CIPHER_GROUP:
1923 case IW_AUTH_KEY_MGMT:
1924 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
1925 case IW_AUTH_PRIVACY_INVOKED:
1926 /*
1927 * atmel does not use these parameters
1928 */
1929 break;
1930
1931 case IW_AUTH_DROP_UNENCRYPTED:
1932 priv->exclude_unencrypted = param->value ? 1 : 0;
1933 break;
1934
1935 case IW_AUTH_80211_AUTH_ALG: {
1936 if (param->value & IW_AUTH_ALG_SHARED_KEY) {
1937 priv->exclude_unencrypted = 1;
1938 } else if (param->value & IW_AUTH_ALG_OPEN_SYSTEM) {
1939 priv->exclude_unencrypted = 0;
1940 } else
1941 return -EINVAL;
1942 break;
1943 }
1944
1945 case IW_AUTH_WPA_ENABLED:
1946 /* Silently accept disable of WPA */
1947 if (param->value > 0)
1948 return -EOPNOTSUPP;
1949 break;
1950
1951 default:
1952 return -EOPNOTSUPP;
1953 }
1954 return -EINPROGRESS;
1955}
1956
1957static int atmel_get_auth(struct net_device *dev,
1958 struct iw_request_info *info,
1959 union iwreq_data *wrqu, char *extra)
1960{
1961 struct atmel_private *priv = netdev_priv(dev);
1962 struct iw_param *param = &wrqu->param;
1963
1964 switch (param->flags & IW_AUTH_INDEX) {
1965 case IW_AUTH_DROP_UNENCRYPTED:
1966 param->value = priv->exclude_unencrypted;
1967 break;
1968
1969 case IW_AUTH_80211_AUTH_ALG:
1970 if (priv->exclude_unencrypted == 1)
1971 param->value = IW_AUTH_ALG_SHARED_KEY;
1972 else
1973 param->value = IW_AUTH_ALG_OPEN_SYSTEM;
1974 break;
1975
1976 case IW_AUTH_WPA_ENABLED:
1977 param->value = 0;
1978 break;
1979
1980 default:
1981 return -EOPNOTSUPP;
1982 }
1983 return 0;
1984}
1985
1986
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987static int atmel_get_name(struct net_device *dev,
1988 struct iw_request_info *info,
1989 char *cwrq,
1990 char *extra)
1991{
1992 strcpy(cwrq, "IEEE 802.11-DS");
1993 return 0;
1994}
1995
1996static int atmel_set_rate(struct net_device *dev,
1997 struct iw_request_info *info,
1998 struct iw_param *vwrq,
1999 char *extra)
2000{
2001 struct atmel_private *priv = netdev_priv(dev);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002002
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003 if (vwrq->fixed == 0) {
2004 priv->tx_rate = 3;
2005 priv->auto_tx_rate = 1;
2006 } else {
2007 priv->auto_tx_rate = 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002008
Linus Torvalds1da177e2005-04-16 15:20:36 -07002009 /* Which type of value ? */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002010 if ((vwrq->value < 4) && (vwrq->value >= 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011 /* Setting by rate index */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002012 priv->tx_rate = vwrq->value;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013 } else {
2014 /* Setting by frequency value */
2015 switch (vwrq->value) {
2016 case 1000000: priv->tx_rate = 0; break;
2017 case 2000000: priv->tx_rate = 1; break;
2018 case 5500000: priv->tx_rate = 2; break;
2019 case 11000000: priv->tx_rate = 3; break;
2020 default: return -EINVAL;
2021 }
2022 }
2023 }
2024
2025 return -EINPROGRESS;
2026}
2027
2028static int atmel_set_mode(struct net_device *dev,
2029 struct iw_request_info *info,
2030 __u32 *uwrq,
2031 char *extra)
2032{
2033 struct atmel_private *priv = netdev_priv(dev);
2034
2035 if (*uwrq != IW_MODE_ADHOC && *uwrq != IW_MODE_INFRA)
2036 return -EINVAL;
2037
2038 priv->operating_mode = *uwrq;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002039 return -EINPROGRESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040}
2041
2042static int atmel_get_mode(struct net_device *dev,
2043 struct iw_request_info *info,
2044 __u32 *uwrq,
2045 char *extra)
2046{
2047 struct atmel_private *priv = netdev_priv(dev);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002048
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049 *uwrq = priv->operating_mode;
2050 return 0;
2051}
2052
2053static int atmel_get_rate(struct net_device *dev,
2054 struct iw_request_info *info,
2055 struct iw_param *vwrq,
2056 char *extra)
2057{
2058 struct atmel_private *priv = netdev_priv(dev);
2059
2060 if (priv->auto_tx_rate) {
2061 vwrq->fixed = 0;
2062 vwrq->value = 11000000;
2063 } else {
2064 vwrq->fixed = 1;
2065 switch(priv->tx_rate) {
2066 case 0: vwrq->value = 1000000; break;
2067 case 1: vwrq->value = 2000000; break;
2068 case 2: vwrq->value = 5500000; break;
2069 case 3: vwrq->value = 11000000; break;
2070 }
2071 }
2072 return 0;
2073}
2074
2075static int atmel_set_power(struct net_device *dev,
2076 struct iw_request_info *info,
2077 struct iw_param *vwrq,
2078 char *extra)
2079{
2080 struct atmel_private *priv = netdev_priv(dev);
2081 priv->power_mode = vwrq->disabled ? 0 : 1;
2082 return -EINPROGRESS;
2083}
2084
2085static int atmel_get_power(struct net_device *dev,
2086 struct iw_request_info *info,
2087 struct iw_param *vwrq,
2088 char *extra)
2089{
2090 struct atmel_private *priv = netdev_priv(dev);
2091 vwrq->disabled = priv->power_mode ? 0 : 1;
2092 vwrq->flags = IW_POWER_ON;
2093 return 0;
2094}
2095
2096static int atmel_set_retry(struct net_device *dev,
2097 struct iw_request_info *info,
2098 struct iw_param *vwrq,
2099 char *extra)
2100{
2101 struct atmel_private *priv = netdev_priv(dev);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002102
2103 if (!vwrq->disabled && (vwrq->flags & IW_RETRY_LIMIT)) {
Jean Tourrilhes6a484db2006-08-29 17:59:03 -07002104 if (vwrq->flags & IW_RETRY_LONG)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105 priv->long_retry = vwrq->value;
Jean Tourrilhes6a484db2006-08-29 17:59:03 -07002106 else if (vwrq->flags & IW_RETRY_SHORT)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 priv->short_retry = vwrq->value;
2108 else {
2109 /* No modifier : set both */
2110 priv->long_retry = vwrq->value;
2111 priv->short_retry = vwrq->value;
2112 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002113 return -EINPROGRESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002115
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116 return -EINVAL;
2117}
2118
2119static int atmel_get_retry(struct net_device *dev,
2120 struct iw_request_info *info,
2121 struct iw_param *vwrq,
2122 char *extra)
2123{
2124 struct atmel_private *priv = netdev_priv(dev);
2125
2126 vwrq->disabled = 0; /* Can't be disabled */
2127
Jean Tourrilhes6a484db2006-08-29 17:59:03 -07002128 /* Note : by default, display the short retry number */
2129 if (vwrq->flags & IW_RETRY_LONG) {
2130 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131 vwrq->value = priv->long_retry;
2132 } else {
2133 vwrq->flags = IW_RETRY_LIMIT;
2134 vwrq->value = priv->short_retry;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002135 if (priv->long_retry != priv->short_retry)
Jean Tourrilhes6a484db2006-08-29 17:59:03 -07002136 vwrq->flags |= IW_RETRY_SHORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 }
2138
2139 return 0;
2140}
2141
2142static int atmel_set_rts(struct net_device *dev,
2143 struct iw_request_info *info,
2144 struct iw_param *vwrq,
2145 char *extra)
2146{
2147 struct atmel_private *priv = netdev_priv(dev);
2148 int rthr = vwrq->value;
2149
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002150 if (vwrq->disabled)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151 rthr = 2347;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002152 if ((rthr < 0) || (rthr > 2347)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153 return -EINVAL;
2154 }
2155 priv->rts_threshold = rthr;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002156
Linus Torvalds1da177e2005-04-16 15:20:36 -07002157 return -EINPROGRESS; /* Call commit handler */
2158}
2159
2160static int atmel_get_rts(struct net_device *dev,
2161 struct iw_request_info *info,
2162 struct iw_param *vwrq,
2163 char *extra)
2164{
2165 struct atmel_private *priv = netdev_priv(dev);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002166
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167 vwrq->value = priv->rts_threshold;
2168 vwrq->disabled = (vwrq->value >= 2347);
2169 vwrq->fixed = 1;
2170
2171 return 0;
2172}
2173
2174static int atmel_set_frag(struct net_device *dev,
2175 struct iw_request_info *info,
2176 struct iw_param *vwrq,
2177 char *extra)
2178{
2179 struct atmel_private *priv = netdev_priv(dev);
2180 int fthr = vwrq->value;
2181
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002182 if (vwrq->disabled)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183 fthr = 2346;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002184 if ((fthr < 256) || (fthr > 2346)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185 return -EINVAL;
2186 }
2187 fthr &= ~0x1; /* Get an even value - is it really needed ??? */
2188 priv->frag_threshold = fthr;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002189
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190 return -EINPROGRESS; /* Call commit handler */
2191}
2192
2193static int atmel_get_frag(struct net_device *dev,
2194 struct iw_request_info *info,
2195 struct iw_param *vwrq,
2196 char *extra)
2197{
2198 struct atmel_private *priv = netdev_priv(dev);
2199
2200 vwrq->value = priv->frag_threshold;
2201 vwrq->disabled = (vwrq->value >= 2346);
2202 vwrq->fixed = 1;
2203
2204 return 0;
2205}
2206
2207static const long frequency_list[] = { 2412, 2417, 2422, 2427, 2432, 2437, 2442,
2208 2447, 2452, 2457, 2462, 2467, 2472, 2484 };
2209
2210static int atmel_set_freq(struct net_device *dev,
2211 struct iw_request_info *info,
2212 struct iw_freq *fwrq,
2213 char *extra)
2214{
2215 struct atmel_private *priv = netdev_priv(dev);
2216 int rc = -EINPROGRESS; /* Call commit handler */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002217
Linus Torvalds1da177e2005-04-16 15:20:36 -07002218 /* If setting by frequency, convert to a channel */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002219 if ((fwrq->e == 1) &&
2220 (fwrq->m >= (int) 241200000) &&
2221 (fwrq->m <= (int) 248700000)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002222 int f = fwrq->m / 100000;
2223 int c = 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002224 while ((c < 14) && (f != frequency_list[c]))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 c++;
2226 /* Hack to fall through... */
2227 fwrq->e = 0;
2228 fwrq->m = c + 1;
2229 }
2230 /* Setting by channel number */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002231 if ((fwrq->m > 1000) || (fwrq->e > 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232 rc = -EOPNOTSUPP;
2233 else {
2234 int channel = fwrq->m;
2235 if (atmel_validate_channel(priv, channel) == 0) {
2236 priv->channel = channel;
2237 } else {
2238 rc = -EINVAL;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002239 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240 }
2241 return rc;
2242}
2243
2244static int atmel_get_freq(struct net_device *dev,
2245 struct iw_request_info *info,
2246 struct iw_freq *fwrq,
2247 char *extra)
2248{
2249 struct atmel_private *priv = netdev_priv(dev);
2250
2251 fwrq->m = priv->channel;
2252 fwrq->e = 0;
2253 return 0;
2254}
2255
2256static int atmel_set_scan(struct net_device *dev,
2257 struct iw_request_info *info,
David Kilroy9930cce2008-09-13 12:22:05 +01002258 struct iw_point *dwrq,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 char *extra)
2260{
2261 struct atmel_private *priv = netdev_priv(dev);
2262 unsigned long flags;
2263
2264 /* Note : you may have realised that, as this is a SET operation,
2265 * this is privileged and therefore a normal user can't
2266 * perform scanning.
2267 * This is not an error, while the device perform scanning,
2268 * traffic doesn't flow, so it's a perfect DoS...
2269 * Jean II */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002270
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271 if (priv->station_state == STATION_STATE_DOWN)
2272 return -EAGAIN;
2273
2274 /* Timeout old surveys. */
S.Çağlar Onur6e33e302008-02-14 17:36:49 +02002275 if (time_after(jiffies, priv->last_survey + 20 * HZ))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276 priv->site_survey_state = SITE_SURVEY_IDLE;
2277 priv->last_survey = jiffies;
2278
2279 /* Initiate a scan command */
2280 if (priv->site_survey_state == SITE_SURVEY_IN_PROGRESS)
2281 return -EBUSY;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002282
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 del_timer_sync(&priv->management_timer);
2284 spin_lock_irqsave(&priv->irqlock, flags);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002285
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286 priv->site_survey_state = SITE_SURVEY_IN_PROGRESS;
2287 priv->fast_scan = 0;
2288 atmel_scan(priv, 0);
2289 spin_unlock_irqrestore(&priv->irqlock, flags);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002290
Linus Torvalds1da177e2005-04-16 15:20:36 -07002291 return 0;
2292}
2293
2294static int atmel_get_scan(struct net_device *dev,
2295 struct iw_request_info *info,
2296 struct iw_point *dwrq,
2297 char *extra)
2298{
2299 struct atmel_private *priv = netdev_priv(dev);
2300 int i;
2301 char *current_ev = extra;
2302 struct iw_event iwe;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002303
Linus Torvalds1da177e2005-04-16 15:20:36 -07002304 if (priv->site_survey_state != SITE_SURVEY_COMPLETED)
2305 return -EAGAIN;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002306
2307 for (i = 0; i < priv->BSS_list_entries; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002308 iwe.cmd = SIOCGIWAP;
2309 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
2310 memcpy(iwe.u.ap_addr.sa_data, priv->BSSinfo[i].BSSID, 6);
David S. Millerccc58052008-06-16 18:50:49 -07002311 current_ev = iwe_stream_add_event(info, current_ev,
2312 extra + IW_SCAN_MAX_DATA,
2313 &iwe, IW_EV_ADDR_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314
2315 iwe.u.data.length = priv->BSSinfo[i].SSIDsize;
2316 if (iwe.u.data.length > 32)
2317 iwe.u.data.length = 32;
2318 iwe.cmd = SIOCGIWESSID;
2319 iwe.u.data.flags = 1;
David S. Millerccc58052008-06-16 18:50:49 -07002320 current_ev = iwe_stream_add_point(info, current_ev,
2321 extra + IW_SCAN_MAX_DATA,
2322 &iwe, priv->BSSinfo[i].SSID);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002323
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324 iwe.cmd = SIOCGIWMODE;
2325 iwe.u.mode = priv->BSSinfo[i].BSStype;
David S. Millerccc58052008-06-16 18:50:49 -07002326 current_ev = iwe_stream_add_event(info, current_ev,
2327 extra + IW_SCAN_MAX_DATA,
2328 &iwe, IW_EV_UINT_LEN);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002329
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 iwe.cmd = SIOCGIWFREQ;
2331 iwe.u.freq.m = priv->BSSinfo[i].channel;
2332 iwe.u.freq.e = 0;
David S. Millerccc58052008-06-16 18:50:49 -07002333 current_ev = iwe_stream_add_event(info, current_ev,
2334 extra + IW_SCAN_MAX_DATA,
2335 &iwe, IW_EV_FREQ_LEN);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002336
Holden Karau3b31dc32006-10-10 14:45:33 -07002337 /* Add quality statistics */
2338 iwe.cmd = IWEVQUAL;
2339 iwe.u.qual.level = priv->BSSinfo[i].RSSI;
2340 iwe.u.qual.qual = iwe.u.qual.level;
2341 /* iwe.u.qual.noise = SOMETHING */
David S. Millerccc58052008-06-16 18:50:49 -07002342 current_ev = iwe_stream_add_event(info, current_ev,
2343 extra + IW_SCAN_MAX_DATA,
2344 &iwe, IW_EV_QUAL_LEN);
Holden Karau3b31dc32006-10-10 14:45:33 -07002345
2346
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347 iwe.cmd = SIOCGIWENCODE;
2348 if (priv->BSSinfo[i].UsingWEP)
2349 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
2350 else
2351 iwe.u.data.flags = IW_ENCODE_DISABLED;
2352 iwe.u.data.length = 0;
David S. Millerccc58052008-06-16 18:50:49 -07002353 current_ev = iwe_stream_add_point(info, current_ev,
2354 extra + IW_SCAN_MAX_DATA,
2355 &iwe, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356 }
2357
2358 /* Length of data */
2359 dwrq->length = (current_ev - extra);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002360 dwrq->flags = 0;
2361
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362 return 0;
2363}
2364
2365static int atmel_get_range(struct net_device *dev,
2366 struct iw_request_info *info,
2367 struct iw_point *dwrq,
2368 char *extra)
2369{
2370 struct atmel_private *priv = netdev_priv(dev);
2371 struct iw_range *range = (struct iw_range *) extra;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002372 int k, i, j;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373
2374 dwrq->length = sizeof(struct iw_range);
Alexey Dobriyanf36be622005-11-08 00:41:48 +03002375 memset(range, 0, sizeof(struct iw_range));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376 range->min_nwid = 0x0000;
2377 range->max_nwid = 0x0000;
2378 range->num_channels = 0;
Dmitry Torokhovb4341132006-10-08 00:14:29 -04002379 for (j = 0; j < ARRAY_SIZE(channel_table); j++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380 if (priv->reg_domain == channel_table[j].reg_domain) {
2381 range->num_channels = channel_table[j].max - channel_table[j].min + 1;
2382 break;
2383 }
2384 if (range->num_channels != 0) {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002385 for (k = 0, i = channel_table[j].min; i <= channel_table[j].max; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386 range->freq[k].i = i; /* List index */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002387 range->freq[k].m = frequency_list[i - 1] * 100000;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002388 range->freq[k++].e = 1; /* Values in table in MHz -> * 10^5 * 10 */
2389 }
2390 range->num_frequency = k;
2391 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002392
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393 range->max_qual.qual = 100;
2394 range->max_qual.level = 100;
2395 range->max_qual.noise = 0;
2396 range->max_qual.updated = IW_QUAL_NOISE_INVALID;
2397
2398 range->avg_qual.qual = 50;
2399 range->avg_qual.level = 50;
2400 range->avg_qual.noise = 0;
2401 range->avg_qual.updated = IW_QUAL_NOISE_INVALID;
2402
2403 range->sensitivity = 0;
2404
2405 range->bitrate[0] = 1000000;
2406 range->bitrate[1] = 2000000;
2407 range->bitrate[2] = 5500000;
2408 range->bitrate[3] = 11000000;
2409 range->num_bitrates = 4;
2410
2411 range->min_rts = 0;
2412 range->max_rts = 2347;
2413 range->min_frag = 256;
2414 range->max_frag = 2346;
2415
2416 range->encoding_size[0] = 5;
2417 range->encoding_size[1] = 13;
2418 range->num_encoding_sizes = 2;
2419 range->max_encoding_tokens = 4;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002420
Linus Torvalds1da177e2005-04-16 15:20:36 -07002421 range->pmp_flags = IW_POWER_ON;
2422 range->pmt_flags = IW_POWER_ON;
2423 range->pm_capa = 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002424
Linus Torvalds1da177e2005-04-16 15:20:36 -07002425 range->we_version_source = WIRELESS_EXT;
2426 range->we_version_compiled = WIRELESS_EXT;
2427 range->retry_capa = IW_RETRY_LIMIT ;
2428 range->retry_flags = IW_RETRY_LIMIT;
2429 range->r_time_flags = 0;
2430 range->min_retry = 1;
2431 range->max_retry = 65535;
2432
2433 return 0;
2434}
2435
2436static int atmel_set_wap(struct net_device *dev,
2437 struct iw_request_info *info,
2438 struct sockaddr *awrq,
2439 char *extra)
2440{
2441 struct atmel_private *priv = netdev_priv(dev);
2442 int i;
Dan Williams9a6301c2006-01-10 00:56:11 -05002443 static const u8 any[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
2444 static const u8 off[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445 unsigned long flags;
2446
2447 if (awrq->sa_family != ARPHRD_ETHER)
2448 return -EINVAL;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002449
Dan Williams9a6301c2006-01-10 00:56:11 -05002450 if (!memcmp(any, awrq->sa_data, 6) ||
2451 !memcmp(off, awrq->sa_data, 6)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452 del_timer_sync(&priv->management_timer);
2453 spin_lock_irqsave(&priv->irqlock, flags);
2454 atmel_scan(priv, 1);
2455 spin_unlock_irqrestore(&priv->irqlock, flags);
2456 return 0;
2457 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002458
2459 for (i = 0; i < priv->BSS_list_entries; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002460 if (memcmp(priv->BSSinfo[i].BSSID, awrq->sa_data, 6) == 0) {
2461 if (!priv->wep_is_on && priv->BSSinfo[i].UsingWEP) {
2462 return -EINVAL;
2463 } else if (priv->wep_is_on && !priv->BSSinfo[i].UsingWEP) {
2464 return -EINVAL;
2465 } else {
2466 del_timer_sync(&priv->management_timer);
2467 spin_lock_irqsave(&priv->irqlock, flags);
2468 atmel_join_bss(priv, i);
2469 spin_unlock_irqrestore(&priv->irqlock, flags);
2470 return 0;
2471 }
2472 }
2473 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002474
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475 return -EINVAL;
2476}
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002477
Linus Torvalds1da177e2005-04-16 15:20:36 -07002478static int atmel_config_commit(struct net_device *dev,
2479 struct iw_request_info *info, /* NULL */
2480 void *zwrq, /* NULL */
2481 char *extra) /* NULL */
2482{
2483 return atmel_open(dev);
2484}
2485
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002486static const iw_handler atmel_handler[] =
Linus Torvalds1da177e2005-04-16 15:20:36 -07002487{
2488 (iw_handler) atmel_config_commit, /* SIOCSIWCOMMIT */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002489 (iw_handler) atmel_get_name, /* SIOCGIWNAME */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490 (iw_handler) NULL, /* SIOCSIWNWID */
2491 (iw_handler) NULL, /* SIOCGIWNWID */
2492 (iw_handler) atmel_set_freq, /* SIOCSIWFREQ */
2493 (iw_handler) atmel_get_freq, /* SIOCGIWFREQ */
2494 (iw_handler) atmel_set_mode, /* SIOCSIWMODE */
2495 (iw_handler) atmel_get_mode, /* SIOCGIWMODE */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002496 (iw_handler) NULL, /* SIOCSIWSENS */
2497 (iw_handler) NULL, /* SIOCGIWSENS */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002498 (iw_handler) NULL, /* SIOCSIWRANGE */
2499 (iw_handler) atmel_get_range, /* SIOCGIWRANGE */
2500 (iw_handler) NULL, /* SIOCSIWPRIV */
2501 (iw_handler) NULL, /* SIOCGIWPRIV */
2502 (iw_handler) NULL, /* SIOCSIWSTATS */
2503 (iw_handler) NULL, /* SIOCGIWSTATS */
2504 (iw_handler) NULL, /* SIOCSIWSPY */
2505 (iw_handler) NULL, /* SIOCGIWSPY */
2506 (iw_handler) NULL, /* -- hole -- */
2507 (iw_handler) NULL, /* -- hole -- */
2508 (iw_handler) atmel_set_wap, /* SIOCSIWAP */
2509 (iw_handler) atmel_get_wap, /* SIOCGIWAP */
2510 (iw_handler) NULL, /* -- hole -- */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002511 (iw_handler) NULL, /* SIOCGIWAPLIST */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002512 (iw_handler) atmel_set_scan, /* SIOCSIWSCAN */
2513 (iw_handler) atmel_get_scan, /* SIOCGIWSCAN */
2514 (iw_handler) atmel_set_essid, /* SIOCSIWESSID */
2515 (iw_handler) atmel_get_essid, /* SIOCGIWESSID */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002516 (iw_handler) NULL, /* SIOCSIWNICKN */
2517 (iw_handler) NULL, /* SIOCGIWNICKN */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002518 (iw_handler) NULL, /* -- hole -- */
2519 (iw_handler) NULL, /* -- hole -- */
2520 (iw_handler) atmel_set_rate, /* SIOCSIWRATE */
2521 (iw_handler) atmel_get_rate, /* SIOCGIWRATE */
2522 (iw_handler) atmel_set_rts, /* SIOCSIWRTS */
2523 (iw_handler) atmel_get_rts, /* SIOCGIWRTS */
2524 (iw_handler) atmel_set_frag, /* SIOCSIWFRAG */
2525 (iw_handler) atmel_get_frag, /* SIOCGIWFRAG */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002526 (iw_handler) NULL, /* SIOCSIWTXPOW */
2527 (iw_handler) NULL, /* SIOCGIWTXPOW */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002528 (iw_handler) atmel_set_retry, /* SIOCSIWRETRY */
2529 (iw_handler) atmel_get_retry, /* SIOCGIWRETRY */
2530 (iw_handler) atmel_set_encode, /* SIOCSIWENCODE */
2531 (iw_handler) atmel_get_encode, /* SIOCGIWENCODE */
2532 (iw_handler) atmel_set_power, /* SIOCSIWPOWER */
2533 (iw_handler) atmel_get_power, /* SIOCGIWPOWER */
Dan Williams9a6301c2006-01-10 00:56:11 -05002534 (iw_handler) NULL, /* -- hole -- */
2535 (iw_handler) NULL, /* -- hole -- */
2536 (iw_handler) NULL, /* SIOCSIWGENIE */
2537 (iw_handler) NULL, /* SIOCGIWGENIE */
2538 (iw_handler) atmel_set_auth, /* SIOCSIWAUTH */
2539 (iw_handler) atmel_get_auth, /* SIOCGIWAUTH */
2540 (iw_handler) atmel_set_encodeext, /* SIOCSIWENCODEEXT */
2541 (iw_handler) atmel_get_encodeext, /* SIOCGIWENCODEEXT */
2542 (iw_handler) NULL, /* SIOCSIWPMKSA */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002543};
2544
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002545static const iw_handler atmel_private_handler[] =
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546{
2547 NULL, /* SIOCIWFIRSTPRIV */
2548};
2549
2550typedef struct atmel_priv_ioctl {
2551 char id[32];
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002552 unsigned char __user *data;
2553 unsigned short len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002554} atmel_priv_ioctl;
2555
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002556#define ATMELFWL SIOCIWFIRSTPRIV
2557#define ATMELIDIFC ATMELFWL + 1
2558#define ATMELRD ATMELFWL + 2
2559#define ATMELMAGIC 0x51807
Linus Torvalds1da177e2005-04-16 15:20:36 -07002560#define REGDOMAINSZ 20
2561
2562static const struct iw_priv_args atmel_private_args[] = {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002563 {
2564 .cmd = ATMELFWL,
2565 .set_args = IW_PRIV_TYPE_BYTE
2566 | IW_PRIV_SIZE_FIXED
2567 | sizeof (atmel_priv_ioctl),
2568 .get_args = IW_PRIV_TYPE_NONE,
2569 .name = "atmelfwl"
2570 }, {
2571 .cmd = ATMELIDIFC,
2572 .set_args = IW_PRIV_TYPE_NONE,
2573 .get_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
2574 .name = "atmelidifc"
2575 }, {
2576 .cmd = ATMELRD,
2577 .set_args = IW_PRIV_TYPE_CHAR | REGDOMAINSZ,
2578 .get_args = IW_PRIV_TYPE_NONE,
2579 .name = "regdomain"
2580 },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581};
2582
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002583static const struct iw_handler_def atmel_handler_def =
Linus Torvalds1da177e2005-04-16 15:20:36 -07002584{
Dmitry Torokhovb4341132006-10-08 00:14:29 -04002585 .num_standard = ARRAY_SIZE(atmel_handler),
2586 .num_private = ARRAY_SIZE(atmel_private_handler),
2587 .num_private_args = ARRAY_SIZE(atmel_private_args),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002588 .standard = (iw_handler *) atmel_handler,
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002589 .private = (iw_handler *) atmel_private_handler,
Jean Tourrilhes72f98d32005-09-02 11:36:00 -07002590 .private_args = (struct iw_priv_args *) atmel_private_args,
2591 .get_wireless_stats = atmel_get_wireless_stats
Linus Torvalds1da177e2005-04-16 15:20:36 -07002592};
2593
2594static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2595{
2596 int i, rc = 0;
2597 struct atmel_private *priv = netdev_priv(dev);
2598 atmel_priv_ioctl com;
2599 struct iwreq *wrq = (struct iwreq *) rq;
2600 unsigned char *new_firmware;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002601 char domain[REGDOMAINSZ + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002602
2603 switch (cmd) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604 case ATMELIDIFC:
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002605 wrq->u.param.value = ATMELMAGIC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002606 break;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002607
Linus Torvalds1da177e2005-04-16 15:20:36 -07002608 case ATMELFWL:
2609 if (copy_from_user(&com, rq->ifr_data, sizeof(com))) {
2610 rc = -EFAULT;
2611 break;
2612 }
2613
2614 if (!capable(CAP_NET_ADMIN)) {
2615 rc = -EPERM;
2616 break;
2617 }
2618
2619 if (!(new_firmware = kmalloc(com.len, GFP_KERNEL))) {
2620 rc = -ENOMEM;
2621 break;
2622 }
2623
2624 if (copy_from_user(new_firmware, com.data, com.len)) {
2625 kfree(new_firmware);
2626 rc = -EFAULT;
2627 break;
2628 }
2629
Jesper Juhlb4558ea2005-10-28 16:53:13 -04002630 kfree(priv->firmware);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002631
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632 priv->firmware = new_firmware;
2633 priv->firmware_length = com.len;
2634 strncpy(priv->firmware_id, com.id, 31);
2635 priv->firmware_id[31] = '\0';
2636 break;
2637
2638 case ATMELRD:
2639 if (copy_from_user(domain, rq->ifr_data, REGDOMAINSZ)) {
2640 rc = -EFAULT;
2641 break;
2642 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002643
Linus Torvalds1da177e2005-04-16 15:20:36 -07002644 if (!capable(CAP_NET_ADMIN)) {
2645 rc = -EPERM;
2646 break;
2647 }
2648
2649 domain[REGDOMAINSZ] = 0;
2650 rc = -EINVAL;
Dmitry Torokhovb4341132006-10-08 00:14:29 -04002651 for (i = 0; i < ARRAY_SIZE(channel_table); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002652 /* strcasecmp doesn't exist in the library */
2653 char *a = channel_table[i].name;
2654 char *b = domain;
2655 while (*a) {
2656 char c1 = *a++;
2657 char c2 = *b++;
2658 if (tolower(c1) != tolower(c2))
2659 break;
2660 }
2661 if (!*a && !*b) {
2662 priv->config_reg_domain = channel_table[i].reg_domain;
2663 rc = 0;
2664 }
2665 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002666
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667 if (rc == 0 && priv->station_state != STATION_STATE_DOWN)
2668 rc = atmel_open(dev);
2669 break;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002670
Linus Torvalds1da177e2005-04-16 15:20:36 -07002671 default:
2672 rc = -EOPNOTSUPP;
2673 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002674
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675 return rc;
2676}
2677
2678struct auth_body {
Al Viro0e5ce1f2007-12-22 13:45:50 -05002679 __le16 alg;
2680 __le16 trans_seq;
2681 __le16 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682 u8 el_id;
2683 u8 chall_text_len;
2684 u8 chall_text[253];
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002685};
Linus Torvalds1da177e2005-04-16 15:20:36 -07002686
2687static void atmel_enter_state(struct atmel_private *priv, int new_state)
2688{
2689 int old_state = priv->station_state;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002690
Linus Torvalds1da177e2005-04-16 15:20:36 -07002691 if (new_state == old_state)
2692 return;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002693
Linus Torvalds1da177e2005-04-16 15:20:36 -07002694 priv->station_state = new_state;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002695
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696 if (new_state == STATION_STATE_READY) {
2697 netif_start_queue(priv->dev);
2698 netif_carrier_on(priv->dev);
2699 }
2700
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;
2706 }
2707}
2708
2709static void atmel_scan(struct atmel_private *priv, int specific_ssid)
2710{
2711 struct {
2712 u8 BSSID[6];
2713 u8 SSID[MAX_SSID_LENGTH];
2714 u8 scan_type;
2715 u8 channel;
Al Viro0e5ce1f2007-12-22 13:45:50 -05002716 __le16 BSS_type;
2717 __le16 min_channel_time;
2718 __le16 max_channel_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002719 u8 options;
2720 u8 SSID_size;
2721 } cmd;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002722
Linus Torvalds1da177e2005-04-16 15:20:36 -07002723 memset(cmd.BSSID, 0xff, 6);
2724
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);
2730 } else {
2731 priv->BSS_list_entries = 0;
2732 cmd.SSID_size = 0;
2733 cmd.min_channel_time = cpu_to_le16(10);
2734 cmd.max_channel_time = cpu_to_le16(120);
2735 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002736
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737 cmd.options = 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002738
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739 if (!specific_ssid)
2740 cmd.options |= SCAN_OPTIONS_SITE_SURVEY;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002741
2742 cmd.channel = (priv->channel & 0x7f);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002743 cmd.scan_type = SCAN_TYPE_ACTIVE;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002744 cmd.BSS_type = cpu_to_le16(priv->operating_mode == IW_MODE_ADHOC ?
Linus Torvalds1da177e2005-04-16 15:20:36 -07002745 BSS_TYPE_AD_HOC : BSS_TYPE_INFRASTRUCTURE);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002746
Linus Torvalds1da177e2005-04-16 15:20:36 -07002747 atmel_send_command(priv, CMD_Scan, &cmd, sizeof(cmd));
2748
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);
2752}
2753
2754static void join(struct atmel_private *priv, int type)
2755{
2756 struct {
2757 u8 BSSID[6];
2758 u8 SSID[MAX_SSID_LENGTH];
2759 u8 BSS_type; /* this is a short in a scan command - weird */
2760 u8 channel;
Al Viro0e5ce1f2007-12-22 13:45:50 -05002761 __le16 timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762 u8 SSID_size;
2763 u8 reserved;
2764 } cmd;
2765
2766 cmd.SSID_size = priv->SSID_size;
2767 memcpy(cmd.SSID, priv->SSID, priv->SSID_size);
2768 memcpy(cmd.BSSID, priv->CurrentBSSID, 6);
2769 cmd.channel = (priv->channel & 0x7f);
2770 cmd.BSS_type = type;
2771 cmd.timeout = cpu_to_le16(2000);
2772
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002773 atmel_send_command(priv, CMD_Join, &cmd, sizeof(cmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002774}
2775
Linus Torvalds1da177e2005-04-16 15:20:36 -07002776static void start(struct atmel_private *priv, int type)
2777{
2778 struct {
2779 u8 BSSID[6];
2780 u8 SSID[MAX_SSID_LENGTH];
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002781 u8 BSS_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782 u8 channel;
2783 u8 SSID_size;
2784 u8 reserved[3];
2785 } cmd;
2786
2787 cmd.SSID_size = priv->SSID_size;
2788 memcpy(cmd.SSID, priv->SSID, priv->SSID_size);
2789 memcpy(cmd.BSSID, priv->BSSID, 6);
2790 cmd.BSS_type = type;
2791 cmd.channel = (priv->channel & 0x7f);
2792
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002793 atmel_send_command(priv, CMD_Start, &cmd, sizeof(cmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002794}
2795
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002796static void handle_beacon_probe(struct atmel_private *priv, u16 capability,
2797 u8 channel)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798{
2799 int rejoin = 0;
Johannes Berg2c7060022008-10-30 22:09:54 +01002800 int new = capability & WLAN_CAPABILITY_SHORT_PREAMBLE ?
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801 SHORT_PREAMBLE : LONG_PREAMBLE;
2802
2803 if (priv->preamble != new) {
2804 priv->preamble = new;
2805 rejoin = 1;
2806 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_PREAMBLE_TYPE, new);
2807 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002808
Linus Torvalds1da177e2005-04-16 15:20:36 -07002809 if (priv->channel != channel) {
2810 priv->channel = channel;
2811 rejoin = 1;
2812 atmel_set_mib8(priv, Phy_Mib_Type, PHY_MIB_CHANNEL_POS, channel);
2813 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002814
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815 if (rejoin) {
2816 priv->station_is_associated = 0;
2817 atmel_enter_state(priv, STATION_STATE_JOINNING);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002818
Linus Torvalds1da177e2005-04-16 15:20:36 -07002819 if (priv->operating_mode == IW_MODE_INFRA)
2820 join(priv, BSS_TYPE_INFRASTRUCTURE);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002821 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002822 join(priv, BSS_TYPE_AD_HOC);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002823 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002824}
2825
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002826static void send_authentication_request(struct atmel_private *priv, u16 system,
2827 u8 *challenge, int challenge_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002828{
Johannes Berg2c7060022008-10-30 22:09:54 +01002829 struct ieee80211_hdr header;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002830 struct auth_body auth;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002831
Johannes Berg2c7060022008-10-30 22:09:54 +01002832 header.frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_AUTH);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002833 header.duration_id = cpu_to_le16(0x8000);
Johannes Berg2c7060022008-10-30 22:09:54 +01002834 header.seq_ctrl = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835 memcpy(header.addr1, priv->CurrentBSSID, 6);
2836 memcpy(header.addr2, priv->dev->dev_addr, 6);
2837 memcpy(header.addr3, priv->CurrentBSSID, 6);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002838
2839 if (priv->wep_is_on && priv->CurrentAuthentTransactionSeqNum != 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002840 /* no WEP for authentication frames with TrSeqNo 1 */
Johannes Berg2c7060022008-10-30 22:09:54 +01002841 header.frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002842
2843 auth.alg = cpu_to_le16(system);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844
2845 auth.status = 0;
2846 auth.trans_seq = cpu_to_le16(priv->CurrentAuthentTransactionSeqNum);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002847 priv->ExpectedAuthentTransactionSeqNum = priv->CurrentAuthentTransactionSeqNum+1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002848 priv->CurrentAuthentTransactionSeqNum += 2;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002849
Linus Torvalds1da177e2005-04-16 15:20:36 -07002850 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);
2855 } else {
2856 atmel_transmit_management_frame(priv, &header, (u8 *)&auth, 6);
2857 }
2858}
2859
2860static void send_association_request(struct atmel_private *priv, int is_reassoc)
2861{
2862 u8 *ssid_el_p;
2863 int bodysize;
Johannes Berg2c7060022008-10-30 22:09:54 +01002864 struct ieee80211_hdr header;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002865 struct ass_req_format {
Al Viro0e5ce1f2007-12-22 13:45:50 -05002866 __le16 capability;
2867 __le16 listen_interval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868 u8 ap[6]; /* nothing after here directly accessible */
2869 u8 ssid_el_id;
2870 u8 ssid_len;
2871 u8 ssid[MAX_SSID_LENGTH];
2872 u8 sup_rates_el_id;
2873 u8 sup_rates_len;
2874 u8 rates[4];
2875 } body;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002876
Johannes Berg2c7060022008-10-30 22:09:54 +01002877 header.frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
Jeff Garzikb4538722005-05-12 22:48:20 -04002878 (is_reassoc ? IEEE80211_STYPE_REASSOC_REQ : IEEE80211_STYPE_ASSOC_REQ));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002879 header.duration_id = cpu_to_le16(0x8000);
Johannes Berg2c7060022008-10-30 22:09:54 +01002880 header.seq_ctrl = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002882 memcpy(header.addr1, priv->CurrentBSSID, 6);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002883 memcpy(header.addr2, priv->dev->dev_addr, 6);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002884 memcpy(header.addr3, priv->CurrentBSSID, 6);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002885
Dan Williams4861dd72006-02-05 17:57:36 -05002886 body.capability = cpu_to_le16(WLAN_CAPABILITY_ESS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887 if (priv->wep_is_on)
Dan Williams4861dd72006-02-05 17:57:36 -05002888 body.capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889 if (priv->preamble == SHORT_PREAMBLE)
Johannes Berg2c7060022008-10-30 22:09:54 +01002890 body.capability |= cpu_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002891
2892 body.listen_interval = cpu_to_le16(priv->listen_interval * priv->beacon_period);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002893
Linus Torvalds1da177e2005-04-16 15:20:36 -07002894 /* current AP address - only in reassoc frame */
2895 if (is_reassoc) {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002896 memcpy(body.ap, priv->CurrentBSSID, 6);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002897 ssid_el_p = (u8 *)&body.ssid_el_id;
2898 bodysize = 18 + priv->SSID_size;
2899 } else {
2900 ssid_el_p = (u8 *)&body.ap[0];
2901 bodysize = 12 + priv->SSID_size;
2902 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002903
Johannes Berg2c7060022008-10-30 22:09:54 +01002904 ssid_el_p[0] = WLAN_EID_SSID;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002905 ssid_el_p[1] = priv->SSID_size;
2906 memcpy(ssid_el_p + 2, priv->SSID, priv->SSID_size);
Johannes Berg2c7060022008-10-30 22:09:54 +01002907 ssid_el_p[2 + priv->SSID_size] = WLAN_EID_SUPP_RATES;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002908 ssid_el_p[3 + priv->SSID_size] = 4; /* len of suported rates */
2909 memcpy(ssid_el_p + 4 + priv->SSID_size, atmel_basic_rates, 4);
2910
2911 atmel_transmit_management_frame(priv, &header, (void *)&body, bodysize);
2912}
2913
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002914static int is_frame_from_current_bss(struct atmel_private *priv,
Johannes Berg2c7060022008-10-30 22:09:54 +01002915 struct ieee80211_hdr *header)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916{
Johannes Berg2c7060022008-10-30 22:09:54 +01002917 if (le16_to_cpu(header->frame_control) & IEEE80211_FCTL_FROMDS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918 return memcmp(header->addr3, priv->CurrentBSSID, 6) == 0;
2919 else
2920 return memcmp(header->addr2, priv->CurrentBSSID, 6) == 0;
2921}
2922
2923static int retrieve_bss(struct atmel_private *priv)
2924{
2925 int i;
2926 int max_rssi = -128;
2927 int max_index = -1;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002928
Linus Torvalds1da177e2005-04-16 15:20:36 -07002929 if (priv->BSS_list_entries == 0)
2930 return -1;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002931
Linus Torvalds1da177e2005-04-16 15:20:36 -07002932 if (priv->connect_to_any_BSS) {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002933 /* 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) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937 priv->current_BSS = 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002938 for (i = 0; i < priv->BSS_list_entries; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002939 if (priv->operating_mode == priv->BSSinfo[i].BSStype &&
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002940 ((!priv->wep_is_on && !priv->BSSinfo[i].UsingWEP) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07002941 (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;
2945 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002946 }
2947 return max_index;
2948 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002949
2950 for (i = 0; i < priv->BSS_list_entries; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002951 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;
2957 max_index = i;
2958 }
2959 }
2960 }
2961 return max_index;
2962}
2963
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002964static void store_bss_info(struct atmel_private *priv,
Johannes Berg2c7060022008-10-30 22:09:54 +01002965 struct ieee80211_hdr *header, u16 capability,
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002966 u16 beacon_period, u8 channel, u8 rssi, u8 ssid_len,
2967 u8 *ssid, int is_beacon)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002968{
Dan Williams4861dd72006-02-05 17:57:36 -05002969 u8 *bss = capability & WLAN_CAPABILITY_ESS ? header->addr2 : header->addr3;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002970 int i, index;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002971
2972 for (index = -1, i = 0; i < priv->BSS_list_entries; i++)
2973 if (memcmp(bss, priv->BSSinfo[i].BSSID, 6) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002974 index = i;
2975
Carlo Perassi4d791aa2005-11-13 15:02:15 +03002976 /* If we process a probe and an entry from this BSS exists
Linus Torvalds1da177e2005-04-16 15:20:36 -07002977 we will update the BSS entry with the info from this BSS.
2978 If we process a beacon we will only update RSSI */
2979
2980 if (index == -1) {
2981 if (priv->BSS_list_entries == MAX_BSS_ENTRIES)
2982 return;
2983 index = priv->BSS_list_entries++;
2984 memcpy(priv->BSSinfo[index].BSSID, bss, 6);
2985 priv->BSSinfo[index].RSSI = rssi;
2986 } else {
2987 if (rssi > priv->BSSinfo[index].RSSI)
2988 priv->BSSinfo[index].RSSI = rssi;
2989 if (is_beacon)
2990 return;
2991 }
2992
2993 priv->BSSinfo[index].channel = channel;
2994 priv->BSSinfo[index].beacon_period = beacon_period;
Dan Williams4861dd72006-02-05 17:57:36 -05002995 priv->BSSinfo[index].UsingWEP = capability & WLAN_CAPABILITY_PRIVACY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002996 memcpy(priv->BSSinfo[index].SSID, ssid, ssid_len);
2997 priv->BSSinfo[index].SSIDsize = ssid_len;
2998
Dan Williams4861dd72006-02-05 17:57:36 -05002999 if (capability & WLAN_CAPABILITY_IBSS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003000 priv->BSSinfo[index].BSStype = IW_MODE_ADHOC;
Dan Williams4861dd72006-02-05 17:57:36 -05003001 else if (capability & WLAN_CAPABILITY_ESS)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003002 priv->BSSinfo[index].BSStype =IW_MODE_INFRA;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003003
Johannes Berg2c7060022008-10-30 22:09:54 +01003004 priv->BSSinfo[index].preamble = capability & WLAN_CAPABILITY_SHORT_PREAMBLE ?
Linus Torvalds1da177e2005-04-16 15:20:36 -07003005 SHORT_PREAMBLE : LONG_PREAMBLE;
3006}
3007
3008static void authenticate(struct atmel_private *priv, u16 frame_len)
3009{
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);
simon@thekelleys.org.ukb16a2282005-10-30 15:50:15 +00003013 u16 system = le16_to_cpu(auth->alg);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003014
Dan Williams4861dd72006-02-05 17:57:36 -05003015 if (status == WLAN_STATUS_SUCCESS && !priv->wep_is_on) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003016 /* no WEP */
3017 if (priv->station_was_associated) {
3018 atmel_enter_state(priv, STATION_STATE_REASSOCIATING);
3019 send_association_request(priv, 1);
3020 return;
3021 } else {
3022 atmel_enter_state(priv, STATION_STATE_ASSOCIATING);
3023 send_association_request(priv, 0);
3024 return;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003025 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003026 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003027
Dan Williams4861dd72006-02-05 17:57:36 -05003028 if (status == WLAN_STATUS_SUCCESS && priv->wep_is_on) {
Dan Williams73451372006-02-05 17:55:16 -05003029 int should_associate = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030 /* WEP */
3031 if (trans_seq_no != priv->ExpectedAuthentTransactionSeqNum)
3032 return;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003033
Dan Williams4861dd72006-02-05 17:57:36 -05003034 if (system == WLAN_AUTH_OPEN) {
Dan Williams73451372006-02-05 17:55:16 -05003035 if (trans_seq_no == 0x0002) {
3036 should_associate = 1;
3037 }
Dan Williams4861dd72006-02-05 17:57:36 -05003038 } else if (system == WLAN_AUTH_SHARED_KEY) {
Dan Williams73451372006-02-05 17:55:16 -05003039 if (trans_seq_no == 0x0002 &&
Johannes Berg2c7060022008-10-30 22:09:54 +01003040 auth->el_id == WLAN_EID_CHALLENGE) {
Dan Williams73451372006-02-05 17:55:16 -05003041 send_authentication_request(priv, system, auth->chall_text, auth->chall_text_len);
3042 return;
3043 } else if (trans_seq_no == 0x0004) {
3044 should_associate = 1;
3045 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003046 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003047
Dan Williams73451372006-02-05 17:55:16 -05003048 if (should_associate) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003049 if(priv->station_was_associated) {
3050 atmel_enter_state(priv, STATION_STATE_REASSOCIATING);
3051 send_association_request(priv, 1);
3052 return;
3053 } else {
3054 atmel_enter_state(priv, STATION_STATE_ASSOCIATING);
3055 send_association_request(priv, 0);
3056 return;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003057 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003058 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003059 }
3060
Dan Williams73451372006-02-05 17:55:16 -05003061 if (status == WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG) {
Dan Williamsd0c29122008-08-18 15:32:41 -04003062 /* Flip back and forth between WEP auth modes until the max
3063 * authentication tries has been exceeded.
3064 */
Dan Williams73451372006-02-05 17:55:16 -05003065 if (system == WLAN_AUTH_OPEN) {
simon@thekelleys.org.ukb16a2282005-10-30 15:50:15 +00003066 priv->CurrentAuthentTransactionSeqNum = 0x001;
Dan Williams73451372006-02-05 17:55:16 -05003067 priv->exclude_unencrypted = 1;
3068 send_authentication_request(priv, WLAN_AUTH_SHARED_KEY, NULL, 0);
3069 return;
Dan Williamsd0c29122008-08-18 15:32:41 -04003070 } 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);
3075 return;
simon@thekelleys.org.ukb16a2282005-10-30 15:50:15 +00003076 } else if (priv->connect_to_any_BSS) {
3077 int bss_index;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003078
simon@thekelleys.org.ukb16a2282005-10-30 15:50:15 +00003079 priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003080
simon@thekelleys.org.ukb16a2282005-10-30 15:50:15 +00003081 if ((bss_index = retrieve_bss(priv)) != -1) {
3082 atmel_join_bss(priv, bss_index);
3083 return;
3084 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003085 }
3086 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003087
Linus Torvalds1da177e2005-04-16 15:20:36 -07003088 priv->AuthenticationRequestRetryCnt = 0;
3089 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3090 priv->station_is_associated = 0;
3091}
3092
3093static void associate(struct atmel_private *priv, u16 frame_len, u16 subtype)
3094{
3095 struct ass_resp_format {
Al Viro0e5ce1f2007-12-22 13:45:50 -05003096 __le16 capability;
3097 __le16 status;
3098 __le16 ass_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003099 u8 el_id;
3100 u8 length;
3101 u8 rates[4];
3102 } *ass_resp = (struct ass_resp_format *)priv->rx_buf;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003103
3104 u16 status = le16_to_cpu(ass_resp->status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003105 u16 ass_id = le16_to_cpu(ass_resp->ass_id);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003106 u16 rates_len = ass_resp->length > 4 ? 4 : ass_resp->length;
3107
Dan Williams9a6301c2006-01-10 00:56:11 -05003108 union iwreq_data wrqu;
3109
Linus Torvalds1da177e2005-04-16 15:20:36 -07003110 if (frame_len < 8 + rates_len)
3111 return;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003112
Dan Williams4861dd72006-02-05 17:57:36 -05003113 if (status == WLAN_STATUS_SUCCESS) {
3114 if (subtype == IEEE80211_STYPE_ASSOC_RESP)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003115 priv->AssociationRequestRetryCnt = 0;
3116 else
3117 priv->ReAssociationRequestRetryCnt = 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003118
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);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003123 if (priv->power_mode == 0) {
3124 priv->listen_interval = 1;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003125 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003129 } else {
3130 priv->listen_interval = 2;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003131 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003135 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003136
Linus Torvalds1da177e2005-04-16 15:20:36 -07003137 priv->station_is_associated = 1;
3138 priv->station_was_associated = 1;
3139 atmel_enter_state(priv, STATION_STATE_READY);
Dan Williams9a6301c2006-01-10 00:56:11 -05003140
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);
3147
Linus Torvalds1da177e2005-04-16 15:20:36 -07003148 return;
3149 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003150
Dan Williams4861dd72006-02-05 17:57:36 -05003151 if (subtype == IEEE80211_STYPE_ASSOC_RESP &&
3152 status != WLAN_STATUS_ASSOC_DENIED_RATES &&
3153 status != WLAN_STATUS_CAPS_UNSUPPORTED &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07003154 priv->AssociationRequestRetryCnt < MAX_ASSOCIATION_RETRIES) {
3155 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3156 priv->AssociationRequestRetryCnt++;
3157 send_association_request(priv, 0);
3158 return;
3159 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003160
Dan Williams4861dd72006-02-05 17:57:36 -05003161 if (subtype == IEEE80211_STYPE_REASSOC_RESP &&
3162 status != WLAN_STATUS_ASSOC_DENIED_RATES &&
3163 status != WLAN_STATUS_CAPS_UNSUPPORTED &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07003164 priv->AssociationRequestRetryCnt < MAX_ASSOCIATION_RETRIES) {
3165 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3166 priv->ReAssociationRequestRetryCnt++;
3167 send_association_request(priv, 1);
3168 return;
3169 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003170
Linus Torvalds1da177e2005-04-16 15:20:36 -07003171 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3172 priv->station_is_associated = 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003173
3174 if (priv->connect_to_any_BSS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003175 int bss_index;
3176 priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003177
3178 if ((bss_index = retrieve_bss(priv)) != -1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003179 atmel_join_bss(priv, bss_index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003180 }
3181}
3182
Hannes Eder2ed5ba82008-12-26 00:12:59 -08003183static void atmel_join_bss(struct atmel_private *priv, int bss_index)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003184{
3185 struct bss_info *bss = &priv->BSSinfo[bss_index];
3186
3187 memcpy(priv->CurrentBSSID, bss->BSSID, 6);
3188 memcpy(priv->SSID, bss->SSID, priv->SSID_size = bss->SSIDsize);
3189
3190 /* The WPA stuff cares about the current AP address */
3191 if (priv->use_wpa)
3192 build_wpa_mib(priv);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003193
Linus Torvalds1da177e2005-04-16 15:20:36 -07003194 /* When switching to AdHoc turn OFF Power Save if needed */
3195
3196 if (bss->BSStype == IW_MODE_ADHOC &&
3197 priv->operating_mode != IW_MODE_ADHOC &&
3198 priv->power_mode) {
3199 priv->power_mode = 0;
3200 priv->listen_interval = 1;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003201 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003205 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003206
Linus Torvalds1da177e2005-04-16 15:20:36 -07003207 priv->operating_mode = bss->BSStype;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003208 priv->channel = bss->channel & 0x7f;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003209 priv->beacon_period = bss->beacon_period;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003210
Linus Torvalds1da177e2005-04-16 15:20:36 -07003211 if (priv->preamble != bss->preamble) {
3212 priv->preamble = bss->preamble;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003213 atmel_set_mib8(priv, Local_Mib_Type,
3214 LOCAL_MIB_PREAMBLE_TYPE, bss->preamble);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003215 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003216
Linus Torvalds1da177e2005-04-16 15:20:36 -07003217 if (!priv->wep_is_on && bss->UsingWEP) {
3218 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3219 priv->station_is_associated = 0;
3220 return;
3221 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003222
Linus Torvalds1da177e2005-04-16 15:20:36 -07003223 if (priv->wep_is_on && !bss->UsingWEP) {
3224 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3225 priv->station_is_associated = 0;
3226 return;
3227 }
3228
3229 atmel_enter_state(priv, STATION_STATE_JOINNING);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003230
Linus Torvalds1da177e2005-04-16 15:20:36 -07003231 if (priv->operating_mode == IW_MODE_INFRA)
3232 join(priv, BSS_TYPE_INFRASTRUCTURE);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003233 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07003234 join(priv, BSS_TYPE_AD_HOC);
3235}
3236
Linus Torvalds1da177e2005-04-16 15:20:36 -07003237static void restart_search(struct atmel_private *priv)
3238{
3239 int bss_index;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003240
Linus Torvalds1da177e2005-04-16 15:20:36 -07003241 if (!priv->connect_to_any_BSS) {
3242 atmel_scan(priv, 1);
3243 } else {
3244 priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003245
3246 if ((bss_index = retrieve_bss(priv)) != -1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003247 atmel_join_bss(priv, bss_index);
3248 else
3249 atmel_scan(priv, 0);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003250 }
3251}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003252
3253static void smooth_rssi(struct atmel_private *priv, u8 rssi)
3254{
3255 u8 old = priv->wstats.qual.level;
3256 u8 max_rssi = 42; /* 502-rmfd-revd max by experiment, default for now */
3257
3258 switch (priv->firmware_type) {
3259 case ATMEL_FW_TYPE_502E:
3260 max_rssi = 63; /* 502-rmfd-reve max by experiment */
3261 break;
3262 default:
3263 break;
3264 }
3265
3266 rssi = rssi * 100 / max_rssi;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003267 if ((rssi + old) % 2)
3268 priv->wstats.qual.level = (rssi + old) / 2 + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003269 else
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003270 priv->wstats.qual.level = (rssi + old) / 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003271 priv->wstats.qual.updated |= IW_QUAL_LEVEL_UPDATED;
3272 priv->wstats.qual.updated &= ~IW_QUAL_LEVEL_INVALID;
3273}
3274
3275static void atmel_smooth_qual(struct atmel_private *priv)
3276{
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003277 unsigned long time_diff = (jiffies - priv->last_qual) / HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003278 while (time_diff--) {
3279 priv->last_qual += HZ;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003280 priv->wstats.qual.qual = priv->wstats.qual.qual / 2;
3281 priv->wstats.qual.qual +=
Linus Torvalds1da177e2005-04-16 15:20:36 -07003282 priv->beacons_this_sec * priv->beacon_period * (priv->wstats.qual.level + 100) / 4000;
3283 priv->beacons_this_sec = 0;
3284 }
3285 priv->wstats.qual.updated |= IW_QUAL_QUAL_UPDATED;
3286 priv->wstats.qual.updated &= ~IW_QUAL_QUAL_INVALID;
3287}
3288
3289/* deals with incoming managment frames. */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003290static void atmel_management_frame(struct atmel_private *priv,
Johannes Berg2c7060022008-10-30 22:09:54 +01003291 struct ieee80211_hdr *header,
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003292 u16 frame_len, u8 rssi)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003293{
3294 u16 subtype;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003295
Johannes Berg2c7060022008-10-30 22:09:54 +01003296 subtype = le16_to_cpu(header->frame_control) & IEEE80211_FCTL_STYPE;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003297 switch (subtype) {
Dan Williams4861dd72006-02-05 17:57:36 -05003298 case IEEE80211_STYPE_BEACON:
3299 case IEEE80211_STYPE_PROBE_RESP:
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003300
Linus Torvalds1da177e2005-04-16 15:20:36 -07003301 /* beacon frame has multiple variable-length fields -
3302 never let an engineer loose with a data structure design. */
3303 {
3304 struct beacon_format {
Al Viro0e5ce1f2007-12-22 13:45:50 -05003305 __le64 timestamp;
3306 __le16 interval;
3307 __le16 capability;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003308 u8 ssid_el_id;
3309 u8 ssid_length;
3310 /* ssid here */
3311 u8 rates_el_id;
3312 u8 rates_length;
3313 /* rates here */
3314 u8 ds_el_id;
3315 u8 ds_length;
3316 /* ds here */
3317 } *beacon = (struct beacon_format *)priv->rx_buf;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003318
Linus Torvalds1da177e2005-04-16 15:20:36 -07003319 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. */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003326 if (frame_len < 14 || frame_len < ssid_length + 15)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003327 return;
3328 rates_length = beaconp[beacon->ssid_length + 15];
3329 if (frame_len < ssid_length + rates_length + 18)
3330 return;
3331 if (ssid_length > MAX_SSID_LENGTH)
3332 return;
3333 channel = beaconp[ssid_length + rates_length + 18];
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003334
Linus Torvalds1da177e2005-04-16 15:20:36 -07003335 if (priv->station_state == STATION_STATE_READY) {
3336 smooth_rssi(priv, rssi);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003337 if (is_frame_from_current_bss(priv, header)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003338 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);
3344 if (beacons > 1)
3345 priv->wstats.miss.beacon += beacons - 1;
3346 }
3347 priv->last_beacon_timestamp = timestamp;
3348 handle_beacon_probe(priv, capability, channel);
3349 }
3350 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003351
3352 if (priv->station_state == STATION_STATE_SCANNING)
3353 store_bss_info(priv, header, capability,
3354 beacon_interval, channel, rssi,
3355 ssid_length,
3356 &beacon->rates_el_id,
Dan Williams4861dd72006-02-05 17:57:36 -05003357 subtype == IEEE80211_STYPE_BEACON);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003358 }
3359 break;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003360
Dan Williams4861dd72006-02-05 17:57:36 -05003361 case IEEE80211_STYPE_AUTH:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003362
3363 if (priv->station_state == STATION_STATE_AUTHENTICATING)
3364 authenticate(priv, frame_len);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003365
Linus Torvalds1da177e2005-04-16 15:20:36 -07003366 break;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003367
Dan Williams4861dd72006-02-05 17:57:36 -05003368 case IEEE80211_STYPE_ASSOC_RESP:
3369 case IEEE80211_STYPE_REASSOC_RESP:
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003370
3371 if (priv->station_state == STATION_STATE_ASSOCIATING ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07003372 priv->station_state == STATION_STATE_REASSOCIATING)
3373 associate(priv, frame_len, subtype);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003374
Linus Torvalds1da177e2005-04-16 15:20:36 -07003375 break;
3376
Dan Williams4861dd72006-02-05 17:57:36 -05003377 case IEEE80211_STYPE_DISASSOC:
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003378 if (priv->station_is_associated &&
3379 priv->operating_mode == IW_MODE_INFRA &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07003380 is_frame_from_current_bss(priv, header)) {
3381 priv->station_was_associated = 0;
3382 priv->station_is_associated = 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003383
Linus Torvalds1da177e2005-04-16 15:20:36 -07003384 atmel_enter_state(priv, STATION_STATE_JOINNING);
3385 join(priv, BSS_TYPE_INFRASTRUCTURE);
3386 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003387
Linus Torvalds1da177e2005-04-16 15:20:36 -07003388 break;
3389
Dan Williams4861dd72006-02-05 17:57:36 -05003390 case IEEE80211_STYPE_DEAUTH:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003391 if (priv->operating_mode == IW_MODE_INFRA &&
3392 is_frame_from_current_bss(priv, header)) {
3393 priv->station_was_associated = 0;
3394
3395 atmel_enter_state(priv, STATION_STATE_JOINNING);
3396 join(priv, BSS_TYPE_INFRASTRUCTURE);
3397 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003398
Linus Torvalds1da177e2005-04-16 15:20:36 -07003399 break;
3400 }
3401}
3402
3403/* run when timer expires */
3404static void atmel_management_timer(u_long a)
3405{
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003406 struct net_device *dev = (struct net_device *) a;
3407 struct atmel_private *priv = netdev_priv(dev);
3408 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003409
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003410 /* Check if the card has been yanked. */
3411 if (priv->card && priv->present_callback &&
3412 !(*priv->present_callback)(priv->card))
3413 return;
3414
3415 spin_lock_irqsave(&priv->irqlock, flags);
3416
3417 switch (priv->station_state) {
3418
3419 case STATION_STATE_AUTHENTICATING:
3420 if (priv->AuthenticationRequestRetryCnt >= MAX_AUTHENTICATION_RETRIES) {
3421 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3422 priv->station_is_associated = 0;
3423 priv->AuthenticationRequestRetryCnt = 0;
3424 restart_search(priv);
3425 } else {
Dan Williams4861dd72006-02-05 17:57:36 -05003426 int auth = WLAN_AUTH_OPEN;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003427 priv->AuthenticationRequestRetryCnt++;
3428 priv->CurrentAuthentTransactionSeqNum = 0x0001;
3429 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
Dan Williams73451372006-02-05 17:55:16 -05003430 if (priv->wep_is_on && priv->exclude_unencrypted)
Dan Williams4861dd72006-02-05 17:57:36 -05003431 auth = WLAN_AUTH_SHARED_KEY;
Dan Williams73451372006-02-05 17:55:16 -05003432 send_authentication_request(priv, auth, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003433 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003434 break;
3435
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003436 case STATION_STATE_ASSOCIATING:
3437 if (priv->AssociationRequestRetryCnt == MAX_ASSOCIATION_RETRIES) {
3438 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3439 priv->station_is_associated = 0;
3440 priv->AssociationRequestRetryCnt = 0;
3441 restart_search(priv);
3442 } else {
3443 priv->AssociationRequestRetryCnt++;
3444 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3445 send_association_request(priv, 0);
3446 }
3447 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003448
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003449 case STATION_STATE_REASSOCIATING:
3450 if (priv->ReAssociationRequestRetryCnt == MAX_ASSOCIATION_RETRIES) {
3451 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3452 priv->station_is_associated = 0;
3453 priv->ReAssociationRequestRetryCnt = 0;
3454 restart_search(priv);
3455 } else {
3456 priv->ReAssociationRequestRetryCnt++;
3457 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3458 send_association_request(priv, 1);
3459 }
3460 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003461
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003462 default:
3463 break;
3464 }
3465
3466 spin_unlock_irqrestore(&priv->irqlock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003467}
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003468
Linus Torvalds1da177e2005-04-16 15:20:36 -07003469static void atmel_command_irq(struct atmel_private *priv)
3470{
3471 u8 status = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET));
3472 u8 command = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_COMMAND_OFFSET));
3473 int fast_scan;
Dan Williams3a1af6f2006-03-31 15:13:31 -05003474 union iwreq_data wrqu;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003475
3476 if (status == CMD_STATUS_IDLE ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07003477 status == CMD_STATUS_IN_PROGRESS)
3478 return;
3479
3480 switch (command){
3481
3482 case CMD_Start:
3483 if (status == CMD_STATUS_COMPLETE) {
3484 priv->station_was_associated = priv->station_is_associated;
3485 atmel_get_mib(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_CUR_BSSID_POS,
3486 (u8 *)priv->CurrentBSSID, 6);
3487 atmel_enter_state(priv, STATION_STATE_READY);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003488 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003489 break;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003490
Linus Torvalds1da177e2005-04-16 15:20:36 -07003491 case CMD_Scan:
3492 fast_scan = priv->fast_scan;
3493 priv->fast_scan = 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003494
Linus Torvalds1da177e2005-04-16 15:20:36 -07003495 if (status != CMD_STATUS_COMPLETE) {
3496 atmel_scan(priv, 1);
3497 } else {
3498 int bss_index = retrieve_bss(priv);
Dan Williams3a1af6f2006-03-31 15:13:31 -05003499 int notify_scan_complete = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003500 if (bss_index != -1) {
3501 atmel_join_bss(priv, bss_index);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003502 } else if (priv->operating_mode == IW_MODE_ADHOC &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07003503 priv->SSID_size != 0) {
3504 start(priv, BSS_TYPE_AD_HOC);
3505 } else {
3506 priv->fast_scan = !fast_scan;
3507 atmel_scan(priv, 1);
Dan Williams3a1af6f2006-03-31 15:13:31 -05003508 notify_scan_complete = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003509 }
3510 priv->site_survey_state = SITE_SURVEY_COMPLETED;
Dan Williams3a1af6f2006-03-31 15:13:31 -05003511 if (notify_scan_complete) {
3512 wrqu.data.length = 0;
3513 wrqu.data.flags = 0;
3514 wireless_send_event(priv->dev, SIOCGIWSCAN, &wrqu, NULL);
3515 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003516 }
3517 break;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003518
Linus Torvalds1da177e2005-04-16 15:20:36 -07003519 case CMD_SiteSurvey:
3520 priv->fast_scan = 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003521
Linus Torvalds1da177e2005-04-16 15:20:36 -07003522 if (status != CMD_STATUS_COMPLETE)
3523 return;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003524
Linus Torvalds1da177e2005-04-16 15:20:36 -07003525 priv->site_survey_state = SITE_SURVEY_COMPLETED;
3526 if (priv->station_is_associated) {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003527 atmel_enter_state(priv, STATION_STATE_READY);
Dan Williams3a1af6f2006-03-31 15:13:31 -05003528 wrqu.data.length = 0;
3529 wrqu.data.flags = 0;
3530 wireless_send_event(priv->dev, SIOCGIWSCAN, &wrqu, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003531 } else {
3532 atmel_scan(priv, 1);
3533 }
3534 break;
3535
3536 case CMD_Join:
3537 if (status == CMD_STATUS_COMPLETE) {
3538 if (priv->operating_mode == IW_MODE_ADHOC) {
3539 priv->station_was_associated = priv->station_is_associated;
3540 atmel_enter_state(priv, STATION_STATE_READY);
3541 } else {
Dan Williams4861dd72006-02-05 17:57:36 -05003542 int auth = WLAN_AUTH_OPEN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003543 priv->AuthenticationRequestRetryCnt = 0;
3544 atmel_enter_state(priv, STATION_STATE_AUTHENTICATING);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003545
Linus Torvalds1da177e2005-04-16 15:20:36 -07003546 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3547 priv->CurrentAuthentTransactionSeqNum = 0x0001;
Dan Williams73451372006-02-05 17:55:16 -05003548 if (priv->wep_is_on && priv->exclude_unencrypted)
Dan Williams4861dd72006-02-05 17:57:36 -05003549 auth = WLAN_AUTH_SHARED_KEY;
Dan Williams73451372006-02-05 17:55:16 -05003550 send_authentication_request(priv, auth, NULL, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003551 }
3552 return;
3553 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003554
Linus Torvalds1da177e2005-04-16 15:20:36 -07003555 atmel_scan(priv, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003556 }
3557}
3558
3559static int atmel_wakeup_firmware(struct atmel_private *priv)
3560{
3561 struct host_info_struct *iface = &priv->host_info;
3562 u16 mr1, mr3;
3563 int i;
3564
3565 if (priv->card_type == CARD_TYPE_SPI_FLASH)
3566 atmel_set_gcr(priv->dev, GCR_REMAP);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003567
Linus Torvalds1da177e2005-04-16 15:20:36 -07003568 /* wake up on-board processor */
3569 atmel_clear_gcr(priv->dev, 0x0040);
3570 atmel_write16(priv->dev, BSR, BSS_SRAM);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003571
Linus Torvalds1da177e2005-04-16 15:20:36 -07003572 if (priv->card_type == CARD_TYPE_SPI_FLASH)
3573 mdelay(100);
3574
3575 /* and wait for it */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003576 for (i = LOOP_RETRY_LIMIT; i; i--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003577 mr1 = atmel_read16(priv->dev, MR1);
3578 mr3 = atmel_read16(priv->dev, MR3);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003579
3580 if (mr3 & MAC_BOOT_COMPLETE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003581 break;
3582 if (mr1 & MAC_BOOT_COMPLETE &&
3583 priv->bus_type == BUS_TYPE_PCCARD)
3584 break;
3585 }
3586
3587 if (i == 0) {
3588 printk(KERN_ALERT "%s: MAC failed to boot.\n", priv->dev->name);
Dan Williams3c34a5d2008-08-18 15:40:02 -04003589 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003590 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003591
Linus Torvalds1da177e2005-04-16 15:20:36 -07003592 if ((priv->host_info_base = atmel_read16(priv->dev, MR2)) == 0xffff) {
3593 printk(KERN_ALERT "%s: card missing.\n", priv->dev->name);
Dan Williams3c34a5d2008-08-18 15:40:02 -04003594 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003595 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003596
3597 /* now check for completion of MAC initialization through
3598 the FunCtrl field of the IFACE, poll MR1 to detect completion of
3599 MAC initialization, check completion status, set interrupt mask,
3600 enables interrupts and calls Tx and Rx initialization functions */
3601
Linus Torvalds1da177e2005-04-16 15:20:36 -07003602 atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET), FUNC_CTRL_INIT_COMPLETE);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003603
3604 for (i = LOOP_RETRY_LIMIT; i; i--) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003605 mr1 = atmel_read16(priv->dev, MR1);
3606 mr3 = atmel_read16(priv->dev, MR3);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003607
3608 if (mr3 & MAC_INIT_COMPLETE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003609 break;
3610 if (mr1 & MAC_INIT_COMPLETE &&
3611 priv->bus_type == BUS_TYPE_PCCARD)
3612 break;
3613 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003614
Linus Torvalds1da177e2005-04-16 15:20:36 -07003615 if (i == 0) {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003616 printk(KERN_ALERT "%s: MAC failed to initialise.\n",
3617 priv->dev->name);
Dan Williams3c34a5d2008-08-18 15:40:02 -04003618 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003619 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003620
Linus Torvalds1da177e2005-04-16 15:20:36 -07003621 /* Check for MAC_INIT_OK only on the register that the MAC_INIT_OK was set */
3622 if ((mr3 & MAC_INIT_COMPLETE) &&
3623 !(atmel_read16(priv->dev, MR3) & MAC_INIT_OK)) {
3624 printk(KERN_ALERT "%s: MAC failed MR3 self-test.\n", priv->dev->name);
Dan Williams3c34a5d2008-08-18 15:40:02 -04003625 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003626 }
3627 if ((mr1 & MAC_INIT_COMPLETE) &&
3628 !(atmel_read16(priv->dev, MR1) & MAC_INIT_OK)) {
3629 printk(KERN_ALERT "%s: MAC failed MR1 self-test.\n", priv->dev->name);
Dan Williams3c34a5d2008-08-18 15:40:02 -04003630 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003631 }
3632
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003633 atmel_copy_to_host(priv->dev, (unsigned char *)iface,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003634 priv->host_info_base, sizeof(*iface));
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003635
Linus Torvalds1da177e2005-04-16 15:20:36 -07003636 iface->tx_buff_pos = le16_to_cpu(iface->tx_buff_pos);
3637 iface->tx_buff_size = le16_to_cpu(iface->tx_buff_size);
3638 iface->tx_desc_pos = le16_to_cpu(iface->tx_desc_pos);
3639 iface->tx_desc_count = le16_to_cpu(iface->tx_desc_count);
3640 iface->rx_buff_pos = le16_to_cpu(iface->rx_buff_pos);
3641 iface->rx_buff_size = le16_to_cpu(iface->rx_buff_size);
3642 iface->rx_desc_pos = le16_to_cpu(iface->rx_desc_pos);
3643 iface->rx_desc_count = le16_to_cpu(iface->rx_desc_count);
3644 iface->build_version = le16_to_cpu(iface->build_version);
3645 iface->command_pos = le16_to_cpu(iface->command_pos);
3646 iface->major_version = le16_to_cpu(iface->major_version);
3647 iface->minor_version = le16_to_cpu(iface->minor_version);
3648 iface->func_ctrl = le16_to_cpu(iface->func_ctrl);
3649 iface->mac_status = le16_to_cpu(iface->mac_status);
3650
Dan Williams3c34a5d2008-08-18 15:40:02 -04003651 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003652}
3653
3654/* determine type of memory and MAC address */
3655static int probe_atmel_card(struct net_device *dev)
3656{
3657 int rc = 0;
3658 struct atmel_private *priv = netdev_priv(dev);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003659
Linus Torvalds1da177e2005-04-16 15:20:36 -07003660 /* reset pccard */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003661 if (priv->bus_type == BUS_TYPE_PCCARD)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003662 atmel_write16(dev, GCR, 0x0060);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003663
Linus Torvalds1da177e2005-04-16 15:20:36 -07003664 atmel_write16(dev, GCR, 0x0040);
3665 mdelay(500);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003666
Linus Torvalds1da177e2005-04-16 15:20:36 -07003667 if (atmel_read16(dev, MR2) == 0) {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003668 /* No stored firmware so load a small stub which just
Linus Torvalds1da177e2005-04-16 15:20:36 -07003669 tells us the MAC address */
3670 int i;
3671 priv->card_type = CARD_TYPE_EEPROM;
3672 atmel_write16(dev, BSR, BSS_IRAM);
3673 atmel_copy_to_card(dev, 0, mac_reader, sizeof(mac_reader));
3674 atmel_set_gcr(dev, GCR_REMAP);
3675 atmel_clear_gcr(priv->dev, 0x0040);
3676 atmel_write16(dev, BSR, BSS_SRAM);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003677 for (i = LOOP_RETRY_LIMIT; i; i--)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003678 if (atmel_read16(dev, MR3) & MAC_BOOT_COMPLETE)
3679 break;
3680 if (i == 0) {
3681 printk(KERN_ALERT "%s: MAC failed to boot MAC address reader.\n", dev->name);
3682 } else {
3683 atmel_copy_to_host(dev, dev->dev_addr, atmel_read16(dev, MR2), 6);
3684 /* got address, now squash it again until the network
3685 interface is opened */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003686 if (priv->bus_type == BUS_TYPE_PCCARD)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003687 atmel_write16(dev, GCR, 0x0060);
3688 atmel_write16(dev, GCR, 0x0040);
3689 rc = 1;
3690 }
3691 } else if (atmel_read16(dev, MR4) == 0) {
3692 /* Mac address easy in this case. */
3693 priv->card_type = CARD_TYPE_PARALLEL_FLASH;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003694 atmel_write16(dev, BSR, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003695 atmel_copy_to_host(dev, dev->dev_addr, 0xc000, 6);
3696 atmel_write16(dev, BSR, 0x200);
3697 rc = 1;
3698 } else {
3699 /* Standard firmware in flash, boot it up and ask
3700 for the Mac Address */
3701 priv->card_type = CARD_TYPE_SPI_FLASH;
Dan Williams3c34a5d2008-08-18 15:40:02 -04003702 if (atmel_wakeup_firmware(priv) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003703 atmel_get_mib(priv, Mac_Address_Mib_Type, 0, dev->dev_addr, 6);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003704
Linus Torvalds1da177e2005-04-16 15:20:36 -07003705 /* got address, now squash it again until the network
3706 interface is opened */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003707 if (priv->bus_type == BUS_TYPE_PCCARD)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003708 atmel_write16(dev, GCR, 0x0060);
3709 atmel_write16(dev, GCR, 0x0040);
3710 rc = 1;
3711 }
3712 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003713
Linus Torvalds1da177e2005-04-16 15:20:36 -07003714 if (rc) {
3715 if (dev->dev_addr[0] == 0xFF) {
3716 u8 default_mac[] = {0x00,0x04, 0x25, 0x00, 0x00, 0x00};
3717 printk(KERN_ALERT "%s: *** Invalid MAC address. UPGRADE Firmware ****\n", dev->name);
3718 memcpy(dev->dev_addr, default_mac, 6);
3719 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003720 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003721
Linus Torvalds1da177e2005-04-16 15:20:36 -07003722 return rc;
3723}
3724
Linus Torvalds1da177e2005-04-16 15:20:36 -07003725/* Move the encyption information on the MIB structure.
3726 This routine is for the pre-WPA firmware: later firmware has
3727 a different format MIB and a different routine. */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003728static void build_wep_mib(struct atmel_private *priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003729{
3730 struct { /* NB this is matched to the hardware, don't change. */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003731 u8 wep_is_on;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003732 u8 default_key; /* 0..3 */
3733 u8 reserved;
3734 u8 exclude_unencrypted;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003735
Linus Torvalds1da177e2005-04-16 15:20:36 -07003736 u32 WEPICV_error_count;
3737 u32 WEP_excluded_count;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003738
Linus Torvalds1da177e2005-04-16 15:20:36 -07003739 u8 wep_keys[MAX_ENCRYPTION_KEYS][13];
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003740 u8 encryption_level; /* 0, 1, 2 */
3741 u8 reserved2[3];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003742 } mib;
3743 int i;
3744
3745 mib.wep_is_on = priv->wep_is_on;
3746 if (priv->wep_is_on) {
3747 if (priv->wep_key_len[priv->default_key] > 5)
3748 mib.encryption_level = 2;
3749 else
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003750 mib.encryption_level = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003751 } else {
3752 mib.encryption_level = 0;
3753 }
3754
3755 mib.default_key = priv->default_key;
3756 mib.exclude_unencrypted = priv->exclude_unencrypted;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003757
3758 for (i = 0; i < MAX_ENCRYPTION_KEYS; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003759 memcpy(mib.wep_keys[i], priv->wep_keys[i], 13);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003760
Linus Torvalds1da177e2005-04-16 15:20:36 -07003761 atmel_set_mib(priv, Mac_Wep_Mib_Type, 0, (u8 *)&mib, sizeof(mib));
3762}
3763
3764static void build_wpa_mib(struct atmel_private *priv)
3765{
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003766 /* This is for the later (WPA enabled) firmware. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003767
3768 struct { /* NB this is matched to the hardware, don't change. */
3769 u8 cipher_default_key_value[MAX_ENCRYPTION_KEYS][MAX_ENCRYPTION_KEY_SIZE];
3770 u8 receiver_address[6];
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003771 u8 wep_is_on;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003772 u8 default_key; /* 0..3 */
3773 u8 group_key;
3774 u8 exclude_unencrypted;
3775 u8 encryption_type;
3776 u8 reserved;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003777
Linus Torvalds1da177e2005-04-16 15:20:36 -07003778 u32 WEPICV_error_count;
3779 u32 WEP_excluded_count;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003780
Linus Torvalds1da177e2005-04-16 15:20:36 -07003781 u8 key_RSC[4][8];
3782 } mib;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003783
Linus Torvalds1da177e2005-04-16 15:20:36 -07003784 int i;
3785
3786 mib.wep_is_on = priv->wep_is_on;
3787 mib.exclude_unencrypted = priv->exclude_unencrypted;
3788 memcpy(mib.receiver_address, priv->CurrentBSSID, 6);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003789
Linus Torvalds1da177e2005-04-16 15:20:36 -07003790 /* zero all the keys before adding in valid ones. */
3791 memset(mib.cipher_default_key_value, 0, sizeof(mib.cipher_default_key_value));
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003792
Linus Torvalds1da177e2005-04-16 15:20:36 -07003793 if (priv->wep_is_on) {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003794 /* There's a comment in the Atmel code to the effect that this
3795 is only valid when still using WEP, it may need to be set to
3796 something to use WPA */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003797 memset(mib.key_RSC, 0, sizeof(mib.key_RSC));
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003798
Linus Torvalds1da177e2005-04-16 15:20:36 -07003799 mib.default_key = mib.group_key = 255;
3800 for (i = 0; i < MAX_ENCRYPTION_KEYS; i++) {
3801 if (priv->wep_key_len[i] > 0) {
3802 memcpy(mib.cipher_default_key_value[i], priv->wep_keys[i], MAX_ENCRYPTION_KEY_SIZE);
3803 if (i == priv->default_key) {
3804 mib.default_key = i;
3805 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-1] = 7;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003806 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-2] = priv->pairwise_cipher_suite;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003807 } else {
3808 mib.group_key = i;
3809 priv->group_cipher_suite = priv->pairwise_cipher_suite;
3810 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-1] = 1;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003811 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-2] = priv->group_cipher_suite;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003812 }
3813 }
3814 }
3815 if (mib.default_key == 255)
3816 mib.default_key = mib.group_key != 255 ? mib.group_key : 0;
3817 if (mib.group_key == 255)
3818 mib.group_key = mib.default_key;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003819
Linus Torvalds1da177e2005-04-16 15:20:36 -07003820 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003821
Linus Torvalds1da177e2005-04-16 15:20:36 -07003822 atmel_set_mib(priv, Mac_Wep_Mib_Type, 0, (u8 *)&mib, sizeof(mib));
3823}
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003824
3825static int reset_atmel_card(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003826{
3827 /* do everything necessary to wake up the hardware, including
3828 waiting for the lightning strike and throwing the knife switch....
3829
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003830 set all the Mib values which matter in the card to match
Linus Torvalds1da177e2005-04-16 15:20:36 -07003831 their settings in the atmel_private structure. Some of these
3832 can be altered on the fly, but many (WEP, infrastucture or ad-hoc)
3833 can only be changed by tearing down the world and coming back through
3834 here.
3835
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003836 This routine is also responsible for initialising some
3837 hardware-specific fields in the atmel_private structure,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003838 including a copy of the firmware's hostinfo stucture
Nick Andrewd5352952009-01-03 18:51:33 +11003839 which is the route into the rest of the firmware datastructures. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003840
3841 struct atmel_private *priv = netdev_priv(dev);
3842 u8 configuration;
Dan Williams9a6301c2006-01-10 00:56:11 -05003843 int old_state = priv->station_state;
Dan Williams3c34a5d2008-08-18 15:40:02 -04003844 int err = 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003845
Linus Torvalds1da177e2005-04-16 15:20:36 -07003846 /* data to add to the firmware names, in priority order
3847 this implemenents firmware versioning */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003848
Linus Torvalds1da177e2005-04-16 15:20:36 -07003849 static char *firmware_modifier[] = {
3850 "-wpa",
3851 "",
3852 NULL
3853 };
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003854
Linus Torvalds1da177e2005-04-16 15:20:36 -07003855 /* reset pccard */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003856 if (priv->bus_type == BUS_TYPE_PCCARD)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003857 atmel_write16(priv->dev, GCR, 0x0060);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003858
Linus Torvalds1da177e2005-04-16 15:20:36 -07003859 /* stop card , disable interrupts */
3860 atmel_write16(priv->dev, GCR, 0x0040);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003861
Linus Torvalds1da177e2005-04-16 15:20:36 -07003862 if (priv->card_type == CARD_TYPE_EEPROM) {
3863 /* copy in firmware if needed */
3864 const struct firmware *fw_entry = NULL;
David Woodhouse2f26e8a2008-05-24 00:09:29 +01003865 const unsigned char *fw;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003866 int len = priv->firmware_length;
3867 if (!(fw = priv->firmware)) {
3868 if (priv->firmware_type == ATMEL_FW_TYPE_NONE) {
3869 if (strlen(priv->firmware_id) == 0) {
3870 printk(KERN_INFO
3871 "%s: card type is unknown: assuming at76c502 firmware is OK.\n",
3872 dev->name);
3873 printk(KERN_INFO
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003874 "%s: if not, use the firmware= module parameter.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003875 dev->name);
3876 strcpy(priv->firmware_id, "atmel_at76c502.bin");
3877 }
Dan Williams3c34a5d2008-08-18 15:40:02 -04003878 err = request_firmware(&fw_entry, priv->firmware_id, priv->sys_dev);
3879 if (err != 0) {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003880 printk(KERN_ALERT
3881 "%s: firmware %s is missing, cannot continue.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003882 dev->name, priv->firmware_id);
Dan Williams3c34a5d2008-08-18 15:40:02 -04003883 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003884 }
3885 } else {
3886 int fw_index = 0;
3887 int success = 0;
3888
3889 /* get firmware filename entry based on firmware type ID */
3890 while (fw_table[fw_index].fw_type != priv->firmware_type
3891 && fw_table[fw_index].fw_type != ATMEL_FW_TYPE_NONE)
3892 fw_index++;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003893
Linus Torvalds1da177e2005-04-16 15:20:36 -07003894 /* construct the actual firmware file name */
3895 if (fw_table[fw_index].fw_type != ATMEL_FW_TYPE_NONE) {
3896 int i;
3897 for (i = 0; firmware_modifier[i]; i++) {
3898 snprintf(priv->firmware_id, 32, "%s%s.%s", fw_table[fw_index].fw_file,
3899 firmware_modifier[i], fw_table[fw_index].fw_file_ext);
3900 priv->firmware_id[31] = '\0';
3901 if (request_firmware(&fw_entry, priv->firmware_id, priv->sys_dev) == 0) {
3902 success = 1;
3903 break;
3904 }
3905 }
3906 }
3907 if (!success) {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003908 printk(KERN_ALERT
3909 "%s: firmware %s is missing, cannot start.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003910 dev->name, priv->firmware_id);
3911 priv->firmware_id[0] = '\0';
Dan Williams3c34a5d2008-08-18 15:40:02 -04003912 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003913 }
3914 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003915
Linus Torvalds1da177e2005-04-16 15:20:36 -07003916 fw = fw_entry->data;
3917 len = fw_entry->size;
3918 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003919
Linus Torvalds1da177e2005-04-16 15:20:36 -07003920 if (len <= 0x6000) {
3921 atmel_write16(priv->dev, BSR, BSS_IRAM);
3922 atmel_copy_to_card(priv->dev, 0, fw, len);
3923 atmel_set_gcr(priv->dev, GCR_REMAP);
3924 } else {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003925 /* Remap */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003926 atmel_set_gcr(priv->dev, GCR_REMAP);
3927 atmel_write16(priv->dev, BSR, BSS_IRAM);
3928 atmel_copy_to_card(priv->dev, 0, fw, 0x6000);
3929 atmel_write16(priv->dev, BSR, 0x2ff);
3930 atmel_copy_to_card(priv->dev, 0x8000, &fw[0x6000], len - 0x6000);
3931 }
3932
3933 if (fw_entry)
3934 release_firmware(fw_entry);
3935 }
3936
Dan Williams3c34a5d2008-08-18 15:40:02 -04003937 err = atmel_wakeup_firmware(priv);
3938 if (err != 0)
3939 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003940
3941 /* Check the version and set the correct flag for wpa stuff,
3942 old and new firmware is incompatible.
3943 The pre-wpa 3com firmware reports major version 5,
3944 the wpa 3com firmware is major version 4 and doesn't need
3945 the 3com broken-ness filter. */
3946 priv->use_wpa = (priv->host_info.major_version == 4);
3947 priv->radio_on_broken = (priv->host_info.major_version == 5);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003948
Linus Torvalds1da177e2005-04-16 15:20:36 -07003949 /* unmask all irq sources */
3950 atmel_wmem8(priv, atmel_hi(priv, IFACE_INT_MASK_OFFSET), 0xff);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003951
Linus Torvalds1da177e2005-04-16 15:20:36 -07003952 /* int Tx system and enable Tx */
3953 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, 0), 0);
3954 atmel_wmem32(priv, atmel_tx(priv, TX_DESC_NEXT_OFFSET, 0), 0x80000000L);
3955 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_POS_OFFSET, 0), 0);
3956 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, 0), 0);
3957
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003958 priv->tx_desc_free = priv->host_info.tx_desc_count;
3959 priv->tx_desc_head = 0;
3960 priv->tx_desc_tail = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003961 priv->tx_desc_previous = 0;
3962 priv->tx_free_mem = priv->host_info.tx_buff_size;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003963 priv->tx_buff_head = 0;
3964 priv->tx_buff_tail = 0;
3965
3966 configuration = atmel_rmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET));
3967 atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003968 configuration | FUNC_CTRL_TxENABLE);
3969
3970 /* init Rx system and enable */
3971 priv->rx_desc_head = 0;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003972
3973 configuration = atmel_rmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET));
3974 atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET),
Linus Torvalds1da177e2005-04-16 15:20:36 -07003975 configuration | FUNC_CTRL_RxENABLE);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003976
Linus Torvalds1da177e2005-04-16 15:20:36 -07003977 if (!priv->radio_on_broken) {
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003978 if (atmel_send_command_wait(priv, CMD_EnableRadio, NULL, 0) ==
Linus Torvalds1da177e2005-04-16 15:20:36 -07003979 CMD_STATUS_REJECTED_RADIO_OFF) {
Dan Williams3c34a5d2008-08-18 15:40:02 -04003980 printk(KERN_INFO "%s: cannot turn the radio on.\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003981 dev->name);
Dan Williams3c34a5d2008-08-18 15:40:02 -04003982 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003983 }
3984 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003985
Linus Torvalds1da177e2005-04-16 15:20:36 -07003986 /* set up enough MIB values to run. */
3987 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_AUTO_TX_RATE_POS, priv->auto_tx_rate);
3988 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_TX_PROMISCUOUS_POS, PROM_MODE_OFF);
3989 atmel_set_mib16(priv, Mac_Mib_Type, MAC_MIB_RTS_THRESHOLD_POS, priv->rts_threshold);
3990 atmel_set_mib16(priv, Mac_Mib_Type, MAC_MIB_FRAG_THRESHOLD_POS, priv->frag_threshold);
3991 atmel_set_mib8(priv, Mac_Mib_Type, MAC_MIB_SHORT_RETRY_POS, priv->short_retry);
3992 atmel_set_mib8(priv, Mac_Mib_Type, MAC_MIB_LONG_RETRY_POS, priv->long_retry);
3993 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_PREAMBLE_TYPE, priv->preamble);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03003994 atmel_set_mib(priv, Mac_Address_Mib_Type, MAC_ADDR_MIB_MAC_ADDR_POS,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003995 priv->dev->dev_addr, 6);
3996 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE);
3997 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1);
3998 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_BEACON_PER_POS, priv->default_beacon_period);
3999 atmel_set_mib(priv, Phy_Mib_Type, PHY_MIB_RATE_SET_POS, atmel_basic_rates, 4);
4000 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_CUR_PRIVACY_POS, priv->wep_is_on);
4001 if (priv->use_wpa)
4002 build_wpa_mib(priv);
4003 else
4004 build_wep_mib(priv);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004005
Dan Williams9a6301c2006-01-10 00:56:11 -05004006 if (old_state == STATION_STATE_READY)
4007 {
4008 union iwreq_data wrqu;
4009
4010 wrqu.data.length = 0;
4011 wrqu.data.flags = 0;
4012 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
4013 memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
4014 wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
4015 }
4016
Dan Williams3c34a5d2008-08-18 15:40:02 -04004017 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004018}
4019
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004020static void atmel_send_command(struct atmel_private *priv, int command,
4021 void *cmd, int cmd_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004022{
4023 if (cmd)
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004024 atmel_copy_to_card(priv->dev, atmel_co(priv, CMD_BLOCK_PARAMETERS_OFFSET),
Linus Torvalds1da177e2005-04-16 15:20:36 -07004025 cmd, cmd_size);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004026
Linus Torvalds1da177e2005-04-16 15:20:36 -07004027 atmel_wmem8(priv, atmel_co(priv, CMD_BLOCK_COMMAND_OFFSET), command);
4028 atmel_wmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET), 0);
4029}
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004030
4031static int atmel_send_command_wait(struct atmel_private *priv, int command,
4032 void *cmd, int cmd_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004033{
4034 int i, status;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004035
Linus Torvalds1da177e2005-04-16 15:20:36 -07004036 atmel_send_command(priv, command, cmd, cmd_size);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004037
Linus Torvalds1da177e2005-04-16 15:20:36 -07004038 for (i = 5000; i; i--) {
4039 status = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET));
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004040 if (status != CMD_STATUS_IDLE &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07004041 status != CMD_STATUS_IN_PROGRESS)
4042 break;
4043 udelay(20);
4044 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004045
Linus Torvalds1da177e2005-04-16 15:20:36 -07004046 if (i == 0) {
4047 printk(KERN_ALERT "%s: failed to contact MAC.\n", priv->dev->name);
4048 status = CMD_STATUS_HOST_ERROR;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004049 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004050 if (command != CMD_EnableRadio)
4051 status = CMD_STATUS_COMPLETE;
4052 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004053
Linus Torvalds1da177e2005-04-16 15:20:36 -07004054 return status;
4055}
4056
4057static u8 atmel_get_mib8(struct atmel_private *priv, u8 type, u8 index)
4058{
4059 struct get_set_mib m;
4060 m.type = type;
4061 m.size = 1;
4062 m.index = index;
4063
4064 atmel_send_command_wait(priv, CMD_Get_MIB_Vars, &m, MIB_HEADER_SIZE + 1);
4065 return atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_PARAMETERS_OFFSET + MIB_HEADER_SIZE));
4066}
4067
4068static void atmel_set_mib8(struct atmel_private *priv, u8 type, u8 index, u8 data)
4069{
4070 struct get_set_mib m;
4071 m.type = type;
4072 m.size = 1;
4073 m.index = index;
4074 m.data[0] = data;
4075
4076 atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + 1);
4077}
4078
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004079static void atmel_set_mib16(struct atmel_private *priv, u8 type, u8 index,
4080 u16 data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004081{
4082 struct get_set_mib m;
4083 m.type = type;
4084 m.size = 2;
4085 m.index = index;
4086 m.data[0] = data;
4087 m.data[1] = data >> 8;
4088
4089 atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + 2);
4090}
4091
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004092static void atmel_set_mib(struct atmel_private *priv, u8 type, u8 index,
4093 u8 *data, int data_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004094{
4095 struct get_set_mib m;
4096 m.type = type;
4097 m.size = data_len;
4098 m.index = index;
4099
4100 if (data_len > MIB_MAX_DATA_BYTES)
4101 printk(KERN_ALERT "%s: MIB buffer too small.\n", priv->dev->name);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004102
Linus Torvalds1da177e2005-04-16 15:20:36 -07004103 memcpy(m.data, data, data_len);
4104 atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + data_len);
4105}
4106
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004107static void atmel_get_mib(struct atmel_private *priv, u8 type, u8 index,
4108 u8 *data, int data_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004109{
4110 struct get_set_mib m;
4111 m.type = type;
4112 m.size = data_len;
4113 m.index = index;
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004114
Linus Torvalds1da177e2005-04-16 15:20:36 -07004115 if (data_len > MIB_MAX_DATA_BYTES)
4116 printk(KERN_ALERT "%s: MIB buffer too small.\n", priv->dev->name);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004117
Linus Torvalds1da177e2005-04-16 15:20:36 -07004118 atmel_send_command_wait(priv, CMD_Get_MIB_Vars, &m, MIB_HEADER_SIZE + data_len);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004119 atmel_copy_to_host(priv->dev, data,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004120 atmel_co(priv, CMD_BLOCK_PARAMETERS_OFFSET + MIB_HEADER_SIZE), data_len);
4121}
4122
4123static void atmel_writeAR(struct net_device *dev, u16 data)
4124{
4125 int i;
4126 outw(data, dev->base_addr + AR);
4127 /* Address register appears to need some convincing..... */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004128 for (i = 0; data != inw(dev->base_addr + AR) && i < 10; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004129 outw(data, dev->base_addr + AR);
4130}
4131
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004132static void atmel_copy_to_card(struct net_device *dev, u16 dest,
David Woodhouse2f26e8a2008-05-24 00:09:29 +01004133 const unsigned char *src, u16 len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004134{
4135 int i;
4136 atmel_writeAR(dev, dest);
4137 if (dest % 2) {
4138 atmel_write8(dev, DR, *src);
4139 src++; len--;
4140 }
4141 for (i = len; i > 1 ; i -= 2) {
4142 u8 lb = *src++;
4143 u8 hb = *src++;
4144 atmel_write16(dev, DR, lb | (hb << 8));
4145 }
4146 if (i)
4147 atmel_write8(dev, DR, *src);
4148}
4149
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004150static void atmel_copy_to_host(struct net_device *dev, unsigned char *dest,
4151 u16 src, u16 len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004152{
4153 int i;
4154 atmel_writeAR(dev, src);
4155 if (src % 2) {
4156 *dest = atmel_read8(dev, DR);
4157 dest++; len--;
4158 }
4159 for (i = len; i > 1 ; i -= 2) {
4160 u16 hw = atmel_read16(dev, DR);
4161 *dest++ = hw;
4162 *dest++ = hw >> 8;
4163 }
4164 if (i)
4165 *dest = atmel_read8(dev, DR);
4166}
4167
4168static void atmel_set_gcr(struct net_device *dev, u16 mask)
4169{
4170 outw(inw(dev->base_addr + GCR) | mask, dev->base_addr + GCR);
4171}
4172
4173static void atmel_clear_gcr(struct net_device *dev, u16 mask)
4174{
4175 outw(inw(dev->base_addr + GCR) & ~mask, dev->base_addr + GCR);
4176}
4177
4178static int atmel_lock_mac(struct atmel_private *priv)
4179{
4180 int i, j = 20;
4181 retry:
4182 for (i = 5000; i; i--) {
4183 if (!atmel_rmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_HOST_OFFSET)))
4184 break;
4185 udelay(20);
4186 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004187
4188 if (!i)
4189 return 0; /* timed out */
4190
Linus Torvalds1da177e2005-04-16 15:20:36 -07004191 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 1);
4192 if (atmel_rmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_HOST_OFFSET))) {
4193 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0);
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004194 if (!j--)
4195 return 0; /* timed out */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004196 goto retry;
4197 }
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004198
Linus Torvalds1da177e2005-04-16 15:20:36 -07004199 return 1;
4200}
4201
4202static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data)
4203{
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004204 atmel_writeAR(priv->dev, pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004205 atmel_write16(priv->dev, DR, data); /* card is little-endian */
4206 atmel_write16(priv->dev, DR, data >> 16);
4207}
4208
4209/***************************************************************************/
4210/* There follows the source form of the MAC address reading firmware */
4211/***************************************************************************/
4212#if 0
4213
4214/* Copyright 2003 Matthew T. Russotto */
4215/* But derived from the Atmel 76C502 firmware written by Atmel and */
4216/* included in "atmel wireless lan drivers" package */
4217/**
4218 This file is part of net.russotto.AtmelMACFW, hereto referred to
4219 as AtmelMACFW
4220
4221 AtmelMACFW is free software; you can redistribute it and/or modify
4222 it under the terms of the GNU General Public License version 2
4223 as published by the Free Software Foundation.
4224
4225 AtmelMACFW is distributed in the hope that it will be useful,
4226 but WITHOUT ANY WARRANTY; without even the implied warranty of
4227 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4228 GNU General Public License for more details.
4229
4230 You should have received a copy of the GNU General Public License
4231 along with AtmelMACFW; if not, write to the Free Software
4232 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
4233
4234****************************************************************************/
4235/* This firmware should work on the 76C502 RFMD, RFMD_D, and RFMD_E */
4236/* It will probably work on the 76C504 and 76C502 RFMD_3COM */
4237/* It only works on SPI EEPROM versions of the card. */
4238
4239/* This firmware initializes the SPI controller and clock, reads the MAC */
4240/* address from the EEPROM into SRAM, and puts the SRAM offset of the MAC */
4241/* address in MR2, and sets MR3 to 0x10 to indicate it is done */
4242/* It also puts a complete copy of the EEPROM in SRAM with the offset in */
4243/* MR4, for investigational purposes (maybe we can determine chip type */
4244/* from that?) */
4245
4246 .org 0
4247 .set MRBASE, 0x8000000
4248 .set CPSR_INITIAL, 0xD3 /* IRQ/FIQ disabled, ARM mode, Supervisor state */
4249 .set CPSR_USER, 0xD1 /* IRQ/FIQ disabled, ARM mode, USER state */
4250 .set SRAM_BASE, 0x02000000
4251 .set SP_BASE, 0x0F300000
4252 .set UNK_BASE, 0x0F000000 /* Some internal device, but which one? */
4253 .set SPI_CGEN_BASE, 0x0E000000 /* Some internal device, but which one? */
4254 .set UNK3_BASE, 0x02014000 /* Some internal device, but which one? */
4255 .set STACK_BASE, 0x5600
4256 .set SP_SR, 0x10
4257 .set SP_TDRE, 2 /* status register bit -- TDR empty */
4258 .set SP_RDRF, 1 /* status register bit -- RDR full */
4259 .set SP_SWRST, 0x80
4260 .set SP_SPIEN, 0x1
4261 .set SP_CR, 0 /* control register */
4262 .set SP_MR, 4 /* mode register */
4263 .set SP_RDR, 0x08 /* Read Data Register */
4264 .set SP_TDR, 0x0C /* Transmit Data Register */
4265 .set SP_CSR0, 0x30 /* chip select registers */
4266 .set SP_CSR1, 0x34
4267 .set SP_CSR2, 0x38
4268 .set SP_CSR3, 0x3C
4269 .set NVRAM_CMD_RDSR, 5 /* read status register */
4270 .set NVRAM_CMD_READ, 3 /* read data */
4271 .set NVRAM_SR_RDY, 1 /* RDY bit. This bit is inverted */
4272 .set SPI_8CLOCKS, 0xFF /* Writing this to the TDR doesn't do anything to the
4273 serial output, since SO is normally high. But it
4274 does cause 8 clock cycles and thus 8 bits to be
4275 clocked in to the chip. See Atmel's SPI
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004276 controller (e.g. AT91M55800) timing and 4K
Linus Torvalds1da177e2005-04-16 15:20:36 -07004277 SPI EEPROM manuals */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004278
Linus Torvalds1da177e2005-04-16 15:20:36 -07004279 .set NVRAM_SCRATCH, 0x02000100 /* arbitrary area for scratchpad memory */
4280 .set NVRAM_IMAGE, 0x02000200
4281 .set NVRAM_LENGTH, 0x0200
4282 .set MAC_ADDRESS_MIB, SRAM_BASE
4283 .set MAC_ADDRESS_LENGTH, 6
4284 .set MAC_BOOT_FLAG, 0x10
4285 .set MR1, 0
4286 .set MR2, 4
4287 .set MR3, 8
4288 .set MR4, 0xC
4289RESET_VECTOR:
4290 b RESET_HANDLER
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004291UNDEF_VECTOR:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004292 b HALT1
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004293SWI_VECTOR:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004294 b HALT1
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004295IABORT_VECTOR:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004296 b HALT1
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004297DABORT_VECTOR:
4298RESERVED_VECTOR:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004299 b HALT1
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004300IRQ_VECTOR:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004301 b HALT1
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004302FIQ_VECTOR:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004303 b HALT1
4304HALT1: b HALT1
4305RESET_HANDLER:
4306 mov r0, #CPSR_INITIAL
4307 msr CPSR_c, r0 /* This is probably unnecessary */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004308
Linus Torvalds1da177e2005-04-16 15:20:36 -07004309/* I'm guessing this is initializing clock generator electronics for SPI */
4310 ldr r0, =SPI_CGEN_BASE
4311 mov r1, #0
4312 mov r1, r1, lsl #3
4313 orr r1,r1, #0
4314 str r1, [r0]
4315 ldr r1, [r0, #28]
4316 bic r1, r1, #16
4317 str r1, [r0, #28]
4318 mov r1, #1
4319 str r1, [r0, #8]
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004320
Linus Torvalds1da177e2005-04-16 15:20:36 -07004321 ldr r0, =MRBASE
4322 mov r1, #0
4323 strh r1, [r0, #MR1]
4324 strh r1, [r0, #MR2]
4325 strh r1, [r0, #MR3]
4326 strh r1, [r0, #MR4]
4327
4328 mov sp, #STACK_BASE
4329 bl SP_INIT
4330 mov r0, #10
4331 bl DELAY9
4332 bl GET_MAC_ADDR
4333 bl GET_WHOLE_NVRAM
4334 ldr r0, =MRBASE
4335 ldr r1, =MAC_ADDRESS_MIB
4336 strh r1, [r0, #MR2]
4337 ldr r1, =NVRAM_IMAGE
4338 strh r1, [r0, #MR4]
4339 mov r1, #MAC_BOOT_FLAG
4340 strh r1, [r0, #MR3]
4341HALT2: b HALT2
4342.func Get_Whole_NVRAM, GET_WHOLE_NVRAM
4343GET_WHOLE_NVRAM:
4344 stmdb sp!, {lr}
4345 mov r2, #0 /* 0th bytes of NVRAM */
4346 mov r3, #NVRAM_LENGTH
4347 mov r1, #0 /* not used in routine */
4348 ldr r0, =NVRAM_IMAGE
4349 bl NVRAM_XFER
4350 ldmia sp!, {lr}
4351 bx lr
4352.endfunc
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004353
Linus Torvalds1da177e2005-04-16 15:20:36 -07004354.func Get_MAC_Addr, GET_MAC_ADDR
4355GET_MAC_ADDR:
4356 stmdb sp!, {lr}
4357 mov r2, #0x120 /* address of MAC Address within NVRAM */
4358 mov r3, #MAC_ADDRESS_LENGTH
4359 mov r1, #0 /* not used in routine */
4360 ldr r0, =MAC_ADDRESS_MIB
4361 bl NVRAM_XFER
4362 ldmia sp!, {lr}
4363 bx lr
4364.endfunc
4365.ltorg
4366.func Delay9, DELAY9
4367DELAY9:
4368 adds r0, r0, r0, LSL #3 /* r0 = r0 * 9 */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004369DELAYLOOP:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004370 beq DELAY9_done
4371 subs r0, r0, #1
4372 b DELAYLOOP
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004373DELAY9_done:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004374 bx lr
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004375.endfunc
Linus Torvalds1da177e2005-04-16 15:20:36 -07004376
4377.func SP_Init, SP_INIT
4378SP_INIT:
4379 mov r1, #SP_SWRST
4380 ldr r0, =SP_BASE
4381 str r1, [r0, #SP_CR] /* reset the SPI */
4382 mov r1, #0
4383 str r1, [r0, #SP_CR] /* release SPI from reset state */
4384 mov r1, #SP_SPIEN
4385 str r1, [r0, #SP_MR] /* set the SPI to MASTER mode*/
4386 str r1, [r0, #SP_CR] /* enable the SPI */
4387
4388/* My guess would be this turns on the SPI clock */
4389 ldr r3, =SPI_CGEN_BASE
4390 ldr r1, [r3, #28]
4391 orr r1, r1, #0x2000
4392 str r1, [r3, #28]
4393
4394 ldr r1, =0x2000c01
4395 str r1, [r0, #SP_CSR0]
4396 ldr r1, =0x2000201
4397 str r1, [r0, #SP_CSR1]
4398 str r1, [r0, #SP_CSR2]
4399 str r1, [r0, #SP_CSR3]
4400 ldr r1, [r0, #SP_SR]
4401 ldr r0, [r0, #SP_RDR]
4402 bx lr
4403.endfunc
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004404.func NVRAM_Init, NVRAM_INIT
Linus Torvalds1da177e2005-04-16 15:20:36 -07004405NVRAM_INIT:
4406 ldr r1, =SP_BASE
4407 ldr r0, [r1, #SP_RDR]
4408 mov r0, #NVRAM_CMD_RDSR
4409 str r0, [r1, #SP_TDR]
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004410SP_loop1:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004411 ldr r0, [r1, #SP_SR]
4412 tst r0, #SP_TDRE
4413 beq SP_loop1
4414
4415 mov r0, #SPI_8CLOCKS
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004416 str r0, [r1, #SP_TDR]
4417SP_loop2:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004418 ldr r0, [r1, #SP_SR]
4419 tst r0, #SP_TDRE
4420 beq SP_loop2
4421
4422 ldr r0, [r1, #SP_RDR]
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004423SP_loop3:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004424 ldr r0, [r1, #SP_SR]
4425 tst r0, #SP_RDRF
4426 beq SP_loop3
4427
4428 ldr r0, [r1, #SP_RDR]
4429 and r0, r0, #255
4430 bx lr
4431.endfunc
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004432
Linus Torvalds1da177e2005-04-16 15:20:36 -07004433.func NVRAM_Xfer, NVRAM_XFER
4434 /* r0 = dest address */
4435 /* r1 = not used */
4436 /* r2 = src address within NVRAM */
4437 /* r3 = length */
4438NVRAM_XFER:
4439 stmdb sp!, {r4, r5, lr}
4440 mov r5, r0 /* save r0 (dest address) */
4441 mov r4, r3 /* save r3 (length) */
4442 mov r0, r2, LSR #5 /* SPI memories put A8 in the command field */
4443 and r0, r0, #8
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004444 add r0, r0, #NVRAM_CMD_READ
Linus Torvalds1da177e2005-04-16 15:20:36 -07004445 ldr r1, =NVRAM_SCRATCH
4446 strb r0, [r1, #0] /* save command in NVRAM_SCRATCH[0] */
4447 strb r2, [r1, #1] /* save low byte of source address in NVRAM_SCRATCH[1] */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004448_local1:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004449 bl NVRAM_INIT
4450 tst r0, #NVRAM_SR_RDY
4451 bne _local1
4452 mov r0, #20
4453 bl DELAY9
4454 mov r2, r4 /* length */
4455 mov r1, r5 /* dest address */
4456 mov r0, #2 /* bytes to transfer in command */
4457 bl NVRAM_XFER2
4458 ldmia sp!, {r4, r5, lr}
4459 bx lr
4460.endfunc
4461
4462.func NVRAM_Xfer2, NVRAM_XFER2
4463NVRAM_XFER2:
4464 stmdb sp!, {r4, r5, r6, lr}
4465 ldr r4, =SP_BASE
4466 mov r3, #0
4467 cmp r0, #0
4468 bls _local2
4469 ldr r5, =NVRAM_SCRATCH
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004470_local4:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004471 ldrb r6, [r5, r3]
4472 str r6, [r4, #SP_TDR]
4473_local3:
4474 ldr r6, [r4, #SP_SR]
4475 tst r6, #SP_TDRE
4476 beq _local3
4477 add r3, r3, #1
4478 cmp r3, r0 /* r0 is # of bytes to send out (command+addr) */
4479 blo _local4
4480_local2:
4481 mov r3, #SPI_8CLOCKS
4482 str r3, [r4, #SP_TDR]
4483 ldr r0, [r4, #SP_RDR]
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004484_local5:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004485 ldr r0, [r4, #SP_SR]
4486 tst r0, #SP_RDRF
4487 beq _local5
4488 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 */
4489 mov r0, #0
4490 cmp r2, #0 /* r2 is # of bytes to copy in */
4491 bls _local6
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004492_local7:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004493 ldr r5, [r4, #SP_SR]
4494 tst r5, #SP_TDRE
4495 beq _local7
4496 str r3, [r4, #SP_TDR] /* r3 has SPI_8CLOCKS */
Carlo Perassi4d791aa2005-11-13 15:02:15 +03004497_local8:
Linus Torvalds1da177e2005-04-16 15:20:36 -07004498 ldr r5, [r4, #SP_SR]
4499 tst r5, #SP_RDRF
4500 beq _local8
4501 ldr r5, [r4, #SP_RDR] /* but didn't we read this byte above? */
4502 strb r5, [r1], #1 /* postindexed */
4503 add r0, r0, #1
4504 cmp r0, r2
4505 blo _local7 /* since we don't send another address, the NVRAM must be capable of sequential reads */
4506_local6:
4507 mov r0, #200
4508 bl DELAY9
4509 ldmia sp!, {r4, r5, r6, lr}
4510 bx lr
4511#endif