?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'block-5.11-2021-01-10' of git://git.kernel.dk/linux-block
[linux/fpc-iii.git] / drivers / net / wireless / atmel / atmel.c
blob707fe66727f8d9c3d5066bd0b15058a0647154e8
1 /*** -*- 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
8 This code was developed from version 2.1.1 of the Atmel drivers,
9 released by Atmel corp. under the GPL in December 2002. It also
10 includes code from the Linux aironet drivers (C) Benjamin Reed,
11 and the Linux PCMCIA package, (C) David Hinds and the Linux wireless
12 extensions, (C) Jean Tourrilhes.
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, see
32 <http://www.gnu.org/licenses/>.
33
34 For all queries about this code, please contact the current author,
35 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
42 #include <linux/interrupt.h>
43
44 #include <linux/kernel.h>
45 #include <linux/ptrace.h>
46 #include <linux/slab.h>
47 #include <linux/string.h>
48 #include <linux/timer.h>
49 #include <asm/byteorder.h>
50 #include <asm/io.h>
51 #include <linux/uaccess.h>
52 #include <linux/module.h>
53 #include <linux/netdevice.h>
54 #include <linux/etherdevice.h>
55 #include <linux/skbuff.h>
56 #include <linux/if_arp.h>
57 #include <linux/ioport.h>
58 #include <linux/fcntl.h>
59 #include <linux/delay.h>
60 #include <linux/wireless.h>
61 #include <net/iw_handler.h>
62 #include <linux/crc32.h>
63 #include <linux/proc_fs.h>
64 #include <linux/seq_file.h>
65 #include <linux/device.h>
66 #include <linux/moduleparam.h>
67 #include <linux/firmware.h>
68 #include <linux/jiffies.h>
69 #include <net/cfg80211.h>
70 #include "atmel.h"
71
72 #define DRIVER_MAJOR 0
73 #define DRIVER_MINOR 98
74
75 MODULE_AUTHOR("Simon Kelley");
76 MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.");
77 MODULE_LICENSE("GPL");
78 MODULE_SUPPORTED_DEVICE("Atmel at76c50x wireless cards");
79
80 /* The name of the firmware file to be loaded
81 over-rides any automatic selection */
82 static char *firmware = NULL;
83 module_param(firmware, charp, 0);
84
85 /* table of firmware file names */
86 static struct {
87 AtmelFWType fw_type;
88 const char *fw_file;
89 const char *fw_file_ext;
90 } fw_table[] = {
91 { ATMEL_FW_TYPE_502, "atmel_at76c502", "bin" },
92 { ATMEL_FW_TYPE_502D, "atmel_at76c502d", "bin" },
93 { ATMEL_FW_TYPE_502E, "atmel_at76c502e", "bin" },
94 { ATMEL_FW_TYPE_502_3COM, "atmel_at76c502_3com", "bin" },
95 { ATMEL_FW_TYPE_504, "atmel_at76c504", "bin" },
96 { ATMEL_FW_TYPE_504_2958, "atmel_at76c504_2958", "bin" },
97 { ATMEL_FW_TYPE_504A_2958, "atmel_at76c504a_2958", "bin" },
98 { ATMEL_FW_TYPE_506, "atmel_at76c506", "bin" },
99 { ATMEL_FW_TYPE_NONE, NULL, NULL }
100 };
101 MODULE_FIRMWARE("atmel_at76c502-wpa.bin");
102 MODULE_FIRMWARE("atmel_at76c502.bin");
103 MODULE_FIRMWARE("atmel_at76c502d-wpa.bin");
104 MODULE_FIRMWARE("atmel_at76c502d.bin");
105 MODULE_FIRMWARE("atmel_at76c502e-wpa.bin");
106 MODULE_FIRMWARE("atmel_at76c502e.bin");
107 MODULE_FIRMWARE("atmel_at76c502_3com-wpa.bin");
108 MODULE_FIRMWARE("atmel_at76c502_3com.bin");
109 MODULE_FIRMWARE("atmel_at76c504-wpa.bin");
110 MODULE_FIRMWARE("atmel_at76c504.bin");
111 MODULE_FIRMWARE("atmel_at76c504_2958-wpa.bin");
112 MODULE_FIRMWARE("atmel_at76c504_2958.bin");
113 MODULE_FIRMWARE("atmel_at76c504a_2958-wpa.bin");
114 MODULE_FIRMWARE("atmel_at76c504a_2958.bin");
115 MODULE_FIRMWARE("atmel_at76c506-wpa.bin");
116 MODULE_FIRMWARE("atmel_at76c506.bin");
117
118 #define MAX_SSID_LENGTH 32
119 #define MGMT_JIFFIES (256 * HZ / 100)
120
121 #define MAX_BSS_ENTRIES 64
122
123 /* registers */
124 #define GCR 0x00 /* (SIR0) General Configuration Register */
125 #define BSR 0x02 /* (SIR1) Bank Switching Select Register */
126 #define AR 0x04
127 #define DR 0x08
128 #define MR1 0x12 /* Mirror Register 1 */
129 #define MR2 0x14 /* Mirror Register 2 */
130 #define MR3 0x16 /* Mirror Register 3 */
131 #define MR4 0x18 /* Mirror Register 4 */
132
133 #define GPR1 0x0c
134 #define GPR2 0x0e
135 #define GPR3 0x10
136 /*
137 * Constants for the GCR register.
138 */
139 #define GCR_REMAP 0x0400 /* Remap internal SRAM to 0 */
140 #define GCR_SWRES 0x0080 /* BIU reset (ARM and PAI are NOT reset) */
141 #define GCR_CORES 0x0060 /* Core Reset (ARM and PAI are reset) */
142 #define GCR_ENINT 0x0002 /* Enable Interrupts */
143 #define GCR_ACKINT 0x0008 /* Acknowledge Interrupts */
144
145 #define BSS_SRAM 0x0200 /* AMBA module selection --> SRAM */
146 #define BSS_IRAM 0x0100 /* AMBA module selection --> IRAM */
147 /*
148 *Constants for the MR registers.
149 */
150 #define MAC_INIT_COMPLETE 0x0001 /* MAC init has been completed */
151 #define MAC_BOOT_COMPLETE 0x0010 /* MAC boot has been completed */
152 #define MAC_INIT_OK 0x0002 /* MAC boot has been completed */
153
154 #define MIB_MAX_DATA_BYTES 212
155 #define MIB_HEADER_SIZE 4 /* first four fields */
156
157 struct get_set_mib {
158 u8 type;
159 u8 size;
160 u8 index;
161 u8 reserved;
162 u8 data[MIB_MAX_DATA_BYTES];
163 };
164
165 struct rx_desc {
166 u32 Next;
167 u16 MsduPos;
168 u16 MsduSize;
169
170 u8 State;
171 u8 Status;
172 u8 Rate;
173 u8 Rssi;
174 u8 LinkQuality;
175 u8 PreambleType;
176 u16 Duration;
177 u32 RxTime;
178 };
179
180 #define RX_DESC_FLAG_VALID 0x80
181 #define RX_DESC_FLAG_CONSUMED 0x40
182 #define RX_DESC_FLAG_IDLE 0x00
183
184 #define RX_STATUS_SUCCESS 0x00
185
186 #define RX_DESC_MSDU_POS_OFFSET 4
187 #define RX_DESC_MSDU_SIZE_OFFSET 6
188 #define RX_DESC_FLAGS_OFFSET 8
189 #define RX_DESC_STATUS_OFFSET 9
190 #define RX_DESC_RSSI_OFFSET 11
191 #define RX_DESC_LINK_QUALITY_OFFSET 12
192 #define RX_DESC_PREAMBLE_TYPE_OFFSET 13
193 #define RX_DESC_DURATION_OFFSET 14
194 #define RX_DESC_RX_TIME_OFFSET 16
195
196 struct tx_desc {
197 u32 NextDescriptor;
198 u16 TxStartOfFrame;
199 u16 TxLength;
200
201 u8 TxState;
202 u8 TxStatus;
203 u8 RetryCount;
204
205 u8 TxRate;
206
207 u8 KeyIndex;
208 u8 ChiperType;
209 u8 ChipreLength;
210 u8 Reserved1;
211
212 u8 Reserved;
213 u8 PacketType;
214 u16 HostTxLength;
215 };
216
217 #define TX_DESC_NEXT_OFFSET 0
218 #define TX_DESC_POS_OFFSET 4
219 #define TX_DESC_SIZE_OFFSET 6
220 #define TX_DESC_FLAGS_OFFSET 8
221 #define TX_DESC_STATUS_OFFSET 9
222 #define TX_DESC_RETRY_OFFSET 10
223 #define TX_DESC_RATE_OFFSET 11
224 #define TX_DESC_KEY_INDEX_OFFSET 12
225 #define TX_DESC_CIPHER_TYPE_OFFSET 13
226 #define TX_DESC_CIPHER_LENGTH_OFFSET 14
227 #define TX_DESC_PACKET_TYPE_OFFSET 17
228 #define TX_DESC_HOST_LENGTH_OFFSET 18
229
230 /*
231 * Host-MAC interface
232 */
233
234 #define TX_STATUS_SUCCESS 0x00
235
236 #define TX_FIRM_OWN 0x80
237 #define TX_DONE 0x40
238
239 #define TX_ERROR 0x01
240
241 #define TX_PACKET_TYPE_DATA 0x01
242 #define TX_PACKET_TYPE_MGMT 0x02
243
244 #define ISR_EMPTY 0x00 /* no bits set in ISR */
245 #define ISR_TxCOMPLETE 0x01 /* packet transmitted */
246 #define ISR_RxCOMPLETE 0x02 /* packet received */
247 #define ISR_RxFRAMELOST 0x04 /* Rx Frame lost */
248 #define ISR_FATAL_ERROR 0x08 /* Fatal error */
249 #define ISR_COMMAND_COMPLETE 0x10 /* command completed */
250 #define ISR_OUT_OF_RANGE 0x20 /* command completed */
251 #define ISR_IBSS_MERGE 0x40 /* (4.1.2.30): IBSS merge */
252 #define ISR_GENERIC_IRQ 0x80
253
254 #define Local_Mib_Type 0x01
255 #define Mac_Address_Mib_Type 0x02
256 #define Mac_Mib_Type 0x03
257 #define Statistics_Mib_Type 0x04
258 #define Mac_Mgmt_Mib_Type 0x05
259 #define Mac_Wep_Mib_Type 0x06
260 #define Phy_Mib_Type 0x07
261 #define Multi_Domain_MIB 0x08
262
263 #define MAC_MGMT_MIB_CUR_BSSID_POS 14
264 #define MAC_MIB_FRAG_THRESHOLD_POS 8
265 #define MAC_MIB_RTS_THRESHOLD_POS 10
266 #define MAC_MIB_SHORT_RETRY_POS 16
267 #define MAC_MIB_LONG_RETRY_POS 17
268 #define MAC_MIB_SHORT_RETRY_LIMIT_POS 16
269 #define MAC_MGMT_MIB_BEACON_PER_POS 0
270 #define MAC_MGMT_MIB_STATION_ID_POS 6
271 #define MAC_MGMT_MIB_CUR_PRIVACY_POS 11
272 #define MAC_MGMT_MIB_CUR_BSSID_POS 14
273 #define MAC_MGMT_MIB_PS_MODE_POS 53
274 #define MAC_MGMT_MIB_LISTEN_INTERVAL_POS 54
275 #define MAC_MGMT_MIB_MULTI_DOMAIN_IMPLEMENTED 56
276 #define MAC_MGMT_MIB_MULTI_DOMAIN_ENABLED 57
277 #define PHY_MIB_CHANNEL_POS 14
278 #define PHY_MIB_RATE_SET_POS 20
279 #define PHY_MIB_REG_DOMAIN_POS 26
280 #define LOCAL_MIB_AUTO_TX_RATE_POS 3
281 #define LOCAL_MIB_SSID_SIZE 5
282 #define LOCAL_MIB_TX_PROMISCUOUS_POS 6
283 #define LOCAL_MIB_TX_MGMT_RATE_POS 7
284 #define LOCAL_MIB_TX_CONTROL_RATE_POS 8
285 #define LOCAL_MIB_PREAMBLE_TYPE 9
286 #define MAC_ADDR_MIB_MAC_ADDR_POS 0
287
288 #define CMD_Set_MIB_Vars 0x01
289 #define CMD_Get_MIB_Vars 0x02
290 #define CMD_Scan 0x03
291 #define CMD_Join 0x04
292 #define CMD_Start 0x05
293 #define CMD_EnableRadio 0x06
294 #define CMD_DisableRadio 0x07
295 #define CMD_SiteSurvey 0x0B
296
297 #define CMD_STATUS_IDLE 0x00
298 #define CMD_STATUS_COMPLETE 0x01
299 #define CMD_STATUS_UNKNOWN 0x02
300 #define CMD_STATUS_INVALID_PARAMETER 0x03
301 #define CMD_STATUS_FUNCTION_NOT_SUPPORTED 0x04
302 #define CMD_STATUS_TIME_OUT 0x07
303 #define CMD_STATUS_IN_PROGRESS 0x08
304 #define CMD_STATUS_REJECTED_RADIO_OFF 0x09
305 #define CMD_STATUS_HOST_ERROR 0xFF
306 #define CMD_STATUS_BUSY 0xFE
307
308 #define CMD_BLOCK_COMMAND_OFFSET 0
309 #define CMD_BLOCK_STATUS_OFFSET 1
310 #define CMD_BLOCK_PARAMETERS_OFFSET 4
311
312 #define SCAN_OPTIONS_SITE_SURVEY 0x80
313
314 #define MGMT_FRAME_BODY_OFFSET 24
315 #define MAX_AUTHENTICATION_RETRIES 3
316 #define MAX_ASSOCIATION_RETRIES 3
317
318 #define AUTHENTICATION_RESPONSE_TIME_OUT 1000
319
320 #define MAX_WIRELESS_BODY 2316 /* mtu is 2312, CRC is 4 */
321 #define LOOP_RETRY_LIMIT 500000
322
323 #define ACTIVE_MODE 1
324 #define PS_MODE 2
325
326 #define MAX_ENCRYPTION_KEYS 4
327 #define MAX_ENCRYPTION_KEY_SIZE 40
328
329 /*
330 * 802.11 related definitions
331 */
332
333 /*
334 * Regulatory Domains
335 */
336
337 #define REG_DOMAIN_FCC 0x10 /* Channels 1-11 USA */
338 #define REG_DOMAIN_DOC 0x20 /* Channel 1-11 Canada */
339 #define REG_DOMAIN_ETSI 0x30 /* Channel 1-13 Europe (ex Spain/France) */
340 #define REG_DOMAIN_SPAIN 0x31 /* Channel 10-11 Spain */
341 #define REG_DOMAIN_FRANCE 0x32 /* Channel 10-13 France */
342 #define REG_DOMAIN_MKK 0x40 /* Channel 14 Japan */
343 #define REG_DOMAIN_MKK1 0x41 /* Channel 1-14 Japan(MKK1) */
344 #define REG_DOMAIN_ISRAEL 0x50 /* Channel 3-9 ISRAEL */
345
346 #define BSS_TYPE_AD_HOC 1
347 #define BSS_TYPE_INFRASTRUCTURE 2
348
349 #define SCAN_TYPE_ACTIVE 0
350 #define SCAN_TYPE_PASSIVE 1
351
352 #define LONG_PREAMBLE 0
353 #define SHORT_PREAMBLE 1
354 #define AUTO_PREAMBLE 2
355
356 #define DATA_FRAME_WS_HEADER_SIZE 30
357
358 /* promiscuous mode control */
359 #define PROM_MODE_OFF 0x0
360 #define PROM_MODE_UNKNOWN 0x1
361 #define PROM_MODE_CRC_FAILED 0x2
362 #define PROM_MODE_DUPLICATED 0x4
363 #define PROM_MODE_MGMT 0x8
364 #define PROM_MODE_CTRL 0x10
365 #define PROM_MODE_BAD_PROTOCOL 0x20
366
367 #define IFACE_INT_STATUS_OFFSET 0
368 #define IFACE_INT_MASK_OFFSET 1
369 #define IFACE_LOCKOUT_HOST_OFFSET 2
370 #define IFACE_LOCKOUT_MAC_OFFSET 3
371 #define IFACE_FUNC_CTRL_OFFSET 28
372 #define IFACE_MAC_STAT_OFFSET 30
373 #define IFACE_GENERIC_INT_TYPE_OFFSET 32
374
375 #define CIPHER_SUITE_NONE 0
376 #define CIPHER_SUITE_WEP_64 1
377 #define CIPHER_SUITE_TKIP 2
378 #define CIPHER_SUITE_AES 3
379 #define CIPHER_SUITE_CCX 4
380 #define CIPHER_SUITE_WEP_128 5
381
382 /*
383 * IFACE MACROS & definitions
384 */
385
386 /*
387 * FuncCtrl field:
388 */
389 #define FUNC_CTRL_TxENABLE 0x10
390 #define FUNC_CTRL_RxENABLE 0x20
391 #define FUNC_CTRL_INIT_COMPLETE 0x01
392
393 /* A stub firmware image which reads the MAC address from NVRAM on the card.
394 For copyright information and source see the end of this file. */
395 static u8 mac_reader[] = {
396 0x06, 0x00, 0x00, 0xea, 0x04, 0x00, 0x00, 0xea, 0x03, 0x00, 0x00, 0xea, 0x02, 0x00, 0x00, 0xea,
397 0x01, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00, 0xea, 0xff, 0xff, 0xff, 0xea, 0xfe, 0xff, 0xff, 0xea,
398 0xd3, 0x00, 0xa0, 0xe3, 0x00, 0xf0, 0x21, 0xe1, 0x0e, 0x04, 0xa0, 0xe3, 0x00, 0x10, 0xa0, 0xe3,
399 0x81, 0x11, 0xa0, 0xe1, 0x00, 0x10, 0x81, 0xe3, 0x00, 0x10, 0x80, 0xe5, 0x1c, 0x10, 0x90, 0xe5,
400 0x10, 0x10, 0xc1, 0xe3, 0x1c, 0x10, 0x80, 0xe5, 0x01, 0x10, 0xa0, 0xe3, 0x08, 0x10, 0x80, 0xe5,
401 0x02, 0x03, 0xa0, 0xe3, 0x00, 0x10, 0xa0, 0xe3, 0xb0, 0x10, 0xc0, 0xe1, 0xb4, 0x10, 0xc0, 0xe1,
402 0xb8, 0x10, 0xc0, 0xe1, 0xbc, 0x10, 0xc0, 0xe1, 0x56, 0xdc, 0xa0, 0xe3, 0x21, 0x00, 0x00, 0xeb,
403 0x0a, 0x00, 0xa0, 0xe3, 0x1a, 0x00, 0x00, 0xeb, 0x10, 0x00, 0x00, 0xeb, 0x07, 0x00, 0x00, 0xeb,
404 0x02, 0x03, 0xa0, 0xe3, 0x02, 0x14, 0xa0, 0xe3, 0xb4, 0x10, 0xc0, 0xe1, 0x4c, 0x10, 0x9f, 0xe5,
405 0xbc, 0x10, 0xc0, 0xe1, 0x10, 0x10, 0xa0, 0xe3, 0xb8, 0x10, 0xc0, 0xe1, 0xfe, 0xff, 0xff, 0xea,
406 0x00, 0x40, 0x2d, 0xe9, 0x00, 0x20, 0xa0, 0xe3, 0x02, 0x3c, 0xa0, 0xe3, 0x00, 0x10, 0xa0, 0xe3,
407 0x28, 0x00, 0x9f, 0xe5, 0x37, 0x00, 0x00, 0xeb, 0x00, 0x40, 0xbd, 0xe8, 0x1e, 0xff, 0x2f, 0xe1,
408 0x00, 0x40, 0x2d, 0xe9, 0x12, 0x2e, 0xa0, 0xe3, 0x06, 0x30, 0xa0, 0xe3, 0x00, 0x10, 0xa0, 0xe3,
409 0x02, 0x04, 0xa0, 0xe3, 0x2f, 0x00, 0x00, 0xeb, 0x00, 0x40, 0xbd, 0xe8, 0x1e, 0xff, 0x2f, 0xe1,
410 0x00, 0x02, 0x00, 0x02, 0x80, 0x01, 0x90, 0xe0, 0x01, 0x00, 0x00, 0x0a, 0x01, 0x00, 0x50, 0xe2,
411 0xfc, 0xff, 0xff, 0xea, 0x1e, 0xff, 0x2f, 0xe1, 0x80, 0x10, 0xa0, 0xe3, 0xf3, 0x06, 0xa0, 0xe3,
412 0x00, 0x10, 0x80, 0xe5, 0x00, 0x10, 0xa0, 0xe3, 0x00, 0x10, 0x80, 0xe5, 0x01, 0x10, 0xa0, 0xe3,
413 0x04, 0x10, 0x80, 0xe5, 0x00, 0x10, 0x80, 0xe5, 0x0e, 0x34, 0xa0, 0xe3, 0x1c, 0x10, 0x93, 0xe5,
414 0x02, 0x1a, 0x81, 0xe3, 0x1c, 0x10, 0x83, 0xe5, 0x58, 0x11, 0x9f, 0xe5, 0x30, 0x10, 0x80, 0xe5,
415 0x54, 0x11, 0x9f, 0xe5, 0x34, 0x10, 0x80, 0xe5, 0x38, 0x10, 0x80, 0xe5, 0x3c, 0x10, 0x80, 0xe5,
416 0x10, 0x10, 0x90, 0xe5, 0x08, 0x00, 0x90, 0xe5, 0x1e, 0xff, 0x2f, 0xe1, 0xf3, 0x16, 0xa0, 0xe3,
417 0x08, 0x00, 0x91, 0xe5, 0x05, 0x00, 0xa0, 0xe3, 0x0c, 0x00, 0x81, 0xe5, 0x10, 0x00, 0x91, 0xe5,
418 0x02, 0x00, 0x10, 0xe3, 0xfc, 0xff, 0xff, 0x0a, 0xff, 0x00, 0xa0, 0xe3, 0x0c, 0x00, 0x81, 0xe5,
419 0x10, 0x00, 0x91, 0xe5, 0x02, 0x00, 0x10, 0xe3, 0xfc, 0xff, 0xff, 0x0a, 0x08, 0x00, 0x91, 0xe5,
420 0x10, 0x00, 0x91, 0xe5, 0x01, 0x00, 0x10, 0xe3, 0xfc, 0xff, 0xff, 0x0a, 0x08, 0x00, 0x91, 0xe5,
421 0xff, 0x00, 0x00, 0xe2, 0x1e, 0xff, 0x2f, 0xe1, 0x30, 0x40, 0x2d, 0xe9, 0x00, 0x50, 0xa0, 0xe1,
422 0x03, 0x40, 0xa0, 0xe1, 0xa2, 0x02, 0xa0, 0xe1, 0x08, 0x00, 0x00, 0xe2, 0x03, 0x00, 0x80, 0xe2,
423 0xd8, 0x10, 0x9f, 0xe5, 0x00, 0x00, 0xc1, 0xe5, 0x01, 0x20, 0xc1, 0xe5, 0xe2, 0xff, 0xff, 0xeb,
424 0x01, 0x00, 0x10, 0xe3, 0xfc, 0xff, 0xff, 0x1a, 0x14, 0x00, 0xa0, 0xe3, 0xc4, 0xff, 0xff, 0xeb,
425 0x04, 0x20, 0xa0, 0xe1, 0x05, 0x10, 0xa0, 0xe1, 0x02, 0x00, 0xa0, 0xe3, 0x01, 0x00, 0x00, 0xeb,
426 0x30, 0x40, 0xbd, 0xe8, 0x1e, 0xff, 0x2f, 0xe1, 0x70, 0x40, 0x2d, 0xe9, 0xf3, 0x46, 0xa0, 0xe3,
427 0x00, 0x30, 0xa0, 0xe3, 0x00, 0x00, 0x50, 0xe3, 0x08, 0x00, 0x00, 0x9a, 0x8c, 0x50, 0x9f, 0xe5,
428 0x03, 0x60, 0xd5, 0xe7, 0x0c, 0x60, 0x84, 0xe5, 0x10, 0x60, 0x94, 0xe5, 0x02, 0x00, 0x16, 0xe3,
429 0xfc, 0xff, 0xff, 0x0a, 0x01, 0x30, 0x83, 0xe2, 0x00, 0x00, 0x53, 0xe1, 0xf7, 0xff, 0xff, 0x3a,
430 0xff, 0x30, 0xa0, 0xe3, 0x0c, 0x30, 0x84, 0xe5, 0x08, 0x00, 0x94, 0xe5, 0x10, 0x00, 0x94, 0xe5,
431 0x01, 0x00, 0x10, 0xe3, 0xfc, 0xff, 0xff, 0x0a, 0x08, 0x00, 0x94, 0xe5, 0x00, 0x00, 0xa0, 0xe3,
432 0x00, 0x00, 0x52, 0xe3, 0x0b, 0x00, 0x00, 0x9a, 0x10, 0x50, 0x94, 0xe5, 0x02, 0x00, 0x15, 0xe3,
433 0xfc, 0xff, 0xff, 0x0a, 0x0c, 0x30, 0x84, 0xe5, 0x10, 0x50, 0x94, 0xe5, 0x01, 0x00, 0x15, 0xe3,
434 0xfc, 0xff, 0xff, 0x0a, 0x08, 0x50, 0x94, 0xe5, 0x01, 0x50, 0xc1, 0xe4, 0x01, 0x00, 0x80, 0xe2,
435 0x02, 0x00, 0x50, 0xe1, 0xf3, 0xff, 0xff, 0x3a, 0xc8, 0x00, 0xa0, 0xe3, 0x98, 0xff, 0xff, 0xeb,
436 0x70, 0x40, 0xbd, 0xe8, 0x1e, 0xff, 0x2f, 0xe1, 0x01, 0x0c, 0x00, 0x02, 0x01, 0x02, 0x00, 0x02,
437 0x00, 0x01, 0x00, 0x02
438 };
439
440 struct atmel_private {
441 void *card; /* Bus dependent structure varies for PCcard */
442 int (*present_callback)(void *); /* And callback which uses it */
443 char firmware_id[32];
444 AtmelFWType firmware_type;
445 u8 *firmware;
446 int firmware_length;
447 struct timer_list management_timer;
448 struct net_device *dev;
449 struct device *sys_dev;
450 struct iw_statistics wstats;
451 spinlock_t irqlock, timerlock; /* spinlocks */
452 enum { BUS_TYPE_PCCARD, BUS_TYPE_PCI } bus_type;
453 enum {
454 CARD_TYPE_PARALLEL_FLASH,
455 CARD_TYPE_SPI_FLASH,
456 CARD_TYPE_EEPROM
457 } card_type;
458 int do_rx_crc; /* If we need to CRC incoming packets */
459 int probe_crc; /* set if we don't yet know */
460 int crc_ok_cnt, crc_ko_cnt; /* counters for probing */
461 u16 rx_desc_head;
462 u16 tx_desc_free, tx_desc_head, tx_desc_tail, tx_desc_previous;
463 u16 tx_free_mem, tx_buff_head, tx_buff_tail;
464
465 u16 frag_seq, frag_len, frag_no;
466 u8 frag_source[6];
467
468 u8 wep_is_on, default_key, exclude_unencrypted, encryption_level;
469 u8 group_cipher_suite, pairwise_cipher_suite;
470 u8 wep_keys[MAX_ENCRYPTION_KEYS][MAX_ENCRYPTION_KEY_SIZE];
471 int wep_key_len[MAX_ENCRYPTION_KEYS];
472 int use_wpa, radio_on_broken; /* firmware dependent stuff. */
473
474 u16 host_info_base;
475 struct host_info_struct {
476 /* NB this is matched to the hardware, don't change. */
477 u8 volatile int_status;
478 u8 volatile int_mask;
479 u8 volatile lockout_host;
480 u8 volatile lockout_mac;
481
482 u16 tx_buff_pos;
483 u16 tx_buff_size;
484 u16 tx_desc_pos;
485 u16 tx_desc_count;
486
487 u16 rx_buff_pos;
488 u16 rx_buff_size;
489 u16 rx_desc_pos;
490 u16 rx_desc_count;
491
492 u16 build_version;
493 u16 command_pos;
494
495 u16 major_version;
496 u16 minor_version;
497
498 u16 func_ctrl;
499 u16 mac_status;
500 u16 generic_IRQ_type;
501 u8 reserved[2];
502 } host_info;
503
504 enum {
505 STATION_STATE_SCANNING,
506 STATION_STATE_JOINNING,
507 STATION_STATE_AUTHENTICATING,
508 STATION_STATE_ASSOCIATING,
509 STATION_STATE_READY,
510 STATION_STATE_REASSOCIATING,
511 STATION_STATE_DOWN,
512 STATION_STATE_MGMT_ERROR
513 } station_state;
514
515 int operating_mode, power_mode;
516 unsigned long last_qual;
517 int beacons_this_sec;
518 int channel;
519 int reg_domain, config_reg_domain;
520 int tx_rate;
521 int auto_tx_rate;
522 int rts_threshold;
523 int frag_threshold;
524 int long_retry, short_retry;
525 int preamble;
526 int default_beacon_period, beacon_period, listen_interval;
527 int CurrentAuthentTransactionSeqNum, ExpectedAuthentTransactionSeqNum;
528 int AuthenticationRequestRetryCnt, AssociationRequestRetryCnt, ReAssociationRequestRetryCnt;
529 enum {
530 SITE_SURVEY_IDLE,
531 SITE_SURVEY_IN_PROGRESS,
532 SITE_SURVEY_COMPLETED
533 } site_survey_state;
534 unsigned long last_survey;
535
536 int station_was_associated, station_is_associated;
537 int fast_scan;
538
539 struct bss_info {
540 int channel;
541 int SSIDsize;
542 int RSSI;
543 int UsingWEP;
544 int preamble;
545 int beacon_period;
546 int BSStype;
547 u8 BSSID[6];
548 u8 SSID[MAX_SSID_LENGTH];
549 } BSSinfo[MAX_BSS_ENTRIES];
550 int BSS_list_entries, current_BSS;
551 int connect_to_any_BSS;
552 int SSID_size, new_SSID_size;
553 u8 CurrentBSSID[6], BSSID[6];
554 u8 SSID[MAX_SSID_LENGTH], new_SSID[MAX_SSID_LENGTH];
555 u64 last_beacon_timestamp;
556 u8 rx_buf[MAX_WIRELESS_BODY];
557 };
558
559 static u8 atmel_basic_rates[4] = {0x82, 0x84, 0x0b, 0x16};
560
561 static const struct {
562 int reg_domain;
563 int min, max;
564 char *name;
565 } channel_table[] = { { REG_DOMAIN_FCC, 1, 11, "USA" },
566 { REG_DOMAIN_DOC, 1, 11, "Canada" },
567 { REG_DOMAIN_ETSI, 1, 13, "Europe" },
568 { REG_DOMAIN_SPAIN, 10, 11, "Spain" },
569 { REG_DOMAIN_FRANCE, 10, 13, "France" },
570 { REG_DOMAIN_MKK, 14, 14, "MKK" },
571 { REG_DOMAIN_MKK1, 1, 14, "MKK1" },
572 { REG_DOMAIN_ISRAEL, 3, 9, "Israel"} };
573
574 static void build_wpa_mib(struct atmel_private *priv);
575 static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
576 static void atmel_copy_to_card(struct net_device *dev, u16 dest,
577 const unsigned char *src, u16 len);
578 static void atmel_copy_to_host(struct net_device *dev, unsigned char *dest,
579 u16 src, u16 len);
580 static void atmel_set_gcr(struct net_device *dev, u16 mask);
581 static void atmel_clear_gcr(struct net_device *dev, u16 mask);
582 static int atmel_lock_mac(struct atmel_private *priv);
583 static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data);
584 static void atmel_command_irq(struct atmel_private *priv);
585 static int atmel_validate_channel(struct atmel_private *priv, int channel);
586 static void atmel_management_frame(struct atmel_private *priv,
587 struct ieee80211_hdr *header,
588 u16 frame_len, u8 rssi);
589 static void atmel_management_timer(struct timer_list *t);
590 static void atmel_send_command(struct atmel_private *priv, int command,
591 void *cmd, int cmd_size);
592 static int atmel_send_command_wait(struct atmel_private *priv, int command,
593 void *cmd, int cmd_size);
594 static void atmel_transmit_management_frame(struct atmel_private *priv,
595 struct ieee80211_hdr *header,
596 u8 *body, int body_len);
597
598 static u8 atmel_get_mib8(struct atmel_private *priv, u8 type, u8 index);
599 static void atmel_set_mib8(struct atmel_private *priv, u8 type, u8 index,
600 u8 data);
601 static void atmel_set_mib16(struct atmel_private *priv, u8 type, u8 index,
602 u16 data);
603 static void atmel_set_mib(struct atmel_private *priv, u8 type, u8 index,
604 u8 *data, int data_len);
605 static void atmel_get_mib(struct atmel_private *priv, u8 type, u8 index,
606 u8 *data, int data_len);
607 static void atmel_scan(struct atmel_private *priv, int specific_ssid);
608 static void atmel_join_bss(struct atmel_private *priv, int bss_index);
609 static void atmel_smooth_qual(struct atmel_private *priv);
610 static void atmel_writeAR(struct net_device *dev, u16 data);
611 static int probe_atmel_card(struct net_device *dev);
612 static int reset_atmel_card(struct net_device *dev);
613 static void atmel_enter_state(struct atmel_private *priv, int new_state);
614 int atmel_open (struct net_device *dev);
615
616 static inline u16 atmel_hi(struct atmel_private *priv, u16 offset)
617 {
618 return priv->host_info_base + offset;
619 }
620
621 static inline u16 atmel_co(struct atmel_private *priv, u16 offset)
622 {
623 return priv->host_info.command_pos + offset;
624 }
625
626 static inline u16 atmel_rx(struct atmel_private *priv, u16 offset, u16 desc)
627 {
628 return priv->host_info.rx_desc_pos + (sizeof(struct rx_desc) * desc) + offset;
629 }
630
631 static inline u16 atmel_tx(struct atmel_private *priv, u16 offset, u16 desc)
632 {
633 return priv->host_info.tx_desc_pos + (sizeof(struct tx_desc) * desc) + offset;
634 }
635
636 static inline u8 atmel_read8(struct net_device *dev, u16 offset)
637 {
638 return inb(dev->base_addr + offset);
639 }
640
641 static inline void atmel_write8(struct net_device *dev, u16 offset, u8 data)
642 {
643 outb(data, dev->base_addr + offset);
644 }
645
646 static inline u16 atmel_read16(struct net_device *dev, u16 offset)
647 {
648 return inw(dev->base_addr + offset);
649 }
650
651 static inline void atmel_write16(struct net_device *dev, u16 offset, u16 data)
652 {
653 outw(data, dev->base_addr + offset);
654 }
655
656 static inline u8 atmel_rmem8(struct atmel_private *priv, u16 pos)
657 {
658 atmel_writeAR(priv->dev, pos);
659 return atmel_read8(priv->dev, DR);
660 }
661
662 static inline void atmel_wmem8(struct atmel_private *priv, u16 pos, u16 data)
663 {
664 atmel_writeAR(priv->dev, pos);
665 atmel_write8(priv->dev, DR, data);
666 }
667
668 static inline u16 atmel_rmem16(struct atmel_private *priv, u16 pos)
669 {
670 atmel_writeAR(priv->dev, pos);
671 return atmel_read16(priv->dev, DR);
672 }
673
674 static inline void atmel_wmem16(struct atmel_private *priv, u16 pos, u16 data)
675 {
676 atmel_writeAR(priv->dev, pos);
677 atmel_write16(priv->dev, DR, data);
678 }
679
680 static const struct iw_handler_def atmel_handler_def;
681
682 static void tx_done_irq(struct atmel_private *priv)
683 {
684 int i;
685
686 for (i = 0;
687 atmel_rmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, priv->tx_desc_head)) == TX_DONE &&
688 i < priv->host_info.tx_desc_count;
689 i++) {
690 u8 status = atmel_rmem8(priv, atmel_tx(priv, TX_DESC_STATUS_OFFSET, priv->tx_desc_head));
691 u16 msdu_size = atmel_rmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, priv->tx_desc_head));
692 u8 type = atmel_rmem8(priv, atmel_tx(priv, TX_DESC_PACKET_TYPE_OFFSET, priv->tx_desc_head));
693
694 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, priv->tx_desc_head), 0);
695
696 priv->tx_free_mem += msdu_size;
697 priv->tx_desc_free++;
698
699 if (priv->tx_buff_head + msdu_size > (priv->host_info.tx_buff_pos + priv->host_info.tx_buff_size))
700 priv->tx_buff_head = 0;
701 else
702 priv->tx_buff_head += msdu_size;
703
704 if (priv->tx_desc_head < (priv->host_info.tx_desc_count - 1))
705 priv->tx_desc_head++ ;
706 else
707 priv->tx_desc_head = 0;
708
709 if (type == TX_PACKET_TYPE_DATA) {
710 if (status == TX_STATUS_SUCCESS)
711 priv->dev->stats.tx_packets++;
712 else
713 priv->dev->stats.tx_errors++;
714 netif_wake_queue(priv->dev);
715 }
716 }
717 }
718
719 static u16 find_tx_buff(struct atmel_private *priv, u16 len)
720 {
721 u16 bottom_free = priv->host_info.tx_buff_size - priv->tx_buff_tail;
722
723 if (priv->tx_desc_free == 3 || priv->tx_free_mem < len)
724 return 0;
725
726 if (bottom_free >= len)
727 return priv->host_info.tx_buff_pos + priv->tx_buff_tail;
728
729 if (priv->tx_free_mem - bottom_free >= len) {
730 priv->tx_buff_tail = 0;
731 return priv->host_info.tx_buff_pos;
732 }
733
734 return 0;
735 }
736
737 static void tx_update_descriptor(struct atmel_private *priv, int is_bcast,
738 u16 len, u16 buff, u8 type)
739 {
740 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_POS_OFFSET, priv->tx_desc_tail), buff);
741 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, priv->tx_desc_tail), len);
742 if (!priv->use_wpa)
743 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_HOST_LENGTH_OFFSET, priv->tx_desc_tail), len);
744 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_PACKET_TYPE_OFFSET, priv->tx_desc_tail), type);
745 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_RATE_OFFSET, priv->tx_desc_tail), priv->tx_rate);
746 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_RETRY_OFFSET, priv->tx_desc_tail), 0);
747 if (priv->use_wpa) {
748 int cipher_type, cipher_length;
749 if (is_bcast) {
750 cipher_type = priv->group_cipher_suite;
751 if (cipher_type == CIPHER_SUITE_WEP_64 ||
752 cipher_type == CIPHER_SUITE_WEP_128)
753 cipher_length = 8;
754 else if (cipher_type == CIPHER_SUITE_TKIP)
755 cipher_length = 12;
756 else if (priv->pairwise_cipher_suite == CIPHER_SUITE_WEP_64 ||
757 priv->pairwise_cipher_suite == CIPHER_SUITE_WEP_128) {
758 cipher_type = priv->pairwise_cipher_suite;
759 cipher_length = 8;
760 } else {
761 cipher_type = CIPHER_SUITE_NONE;
762 cipher_length = 0;
763 }
764 } else {
765 cipher_type = priv->pairwise_cipher_suite;
766 if (cipher_type == CIPHER_SUITE_WEP_64 ||
767 cipher_type == CIPHER_SUITE_WEP_128)
768 cipher_length = 8;
769 else if (cipher_type == CIPHER_SUITE_TKIP)
770 cipher_length = 12;
771 else if (priv->group_cipher_suite == CIPHER_SUITE_WEP_64 ||
772 priv->group_cipher_suite == CIPHER_SUITE_WEP_128) {
773 cipher_type = priv->group_cipher_suite;
774 cipher_length = 8;
775 } else {
776 cipher_type = CIPHER_SUITE_NONE;
777 cipher_length = 0;
778 }
779 }
780
781 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_CIPHER_TYPE_OFFSET, priv->tx_desc_tail),
782 cipher_type);
783 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_CIPHER_LENGTH_OFFSET, priv->tx_desc_tail),
784 cipher_length);
785 }
786 atmel_wmem32(priv, atmel_tx(priv, TX_DESC_NEXT_OFFSET, priv->tx_desc_tail), 0x80000000L);
787 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, priv->tx_desc_tail), TX_FIRM_OWN);
788 if (priv->tx_desc_previous != priv->tx_desc_tail)
789 atmel_wmem32(priv, atmel_tx(priv, TX_DESC_NEXT_OFFSET, priv->tx_desc_previous), 0);
790 priv->tx_desc_previous = priv->tx_desc_tail;
791 if (priv->tx_desc_tail < (priv->host_info.tx_desc_count - 1))
792 priv->tx_desc_tail++;
793 else
794 priv->tx_desc_tail = 0;
795 priv->tx_desc_free--;
796 priv->tx_free_mem -= len;
797 }
798
799 static netdev_tx_t start_tx(struct sk_buff *skb, struct net_device *dev)
800 {
801 struct atmel_private *priv = netdev_priv(dev);
802 struct ieee80211_hdr header;
803 unsigned long flags;
804 u16 buff, frame_ctl, len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
805
806 if (priv->card && priv->present_callback &&
807 !(*priv->present_callback)(priv->card)) {
808 dev->stats.tx_errors++;
809 dev_kfree_skb(skb);
810 return NETDEV_TX_OK;
811 }
812
813 if (priv->station_state != STATION_STATE_READY) {
814 dev->stats.tx_errors++;
815 dev_kfree_skb(skb);
816 return NETDEV_TX_OK;
817 }
818
819 /* first ensure the timer func cannot run */
820 spin_lock_bh(&priv->timerlock);
821 /* then stop the hardware ISR */
822 spin_lock_irqsave(&priv->irqlock, flags);
823 /* nb doing the above in the opposite order will deadlock */
824
825 /* The Wireless Header is 30 bytes. In the Ethernet packet we "cut" the
826 12 first bytes (containing DA/SA) and put them in the appropriate
827 fields of the Wireless Header. Thus the packet length is then the
828 initial + 18 (+30-12) */
829
830 if (!(buff = find_tx_buff(priv, len + 18))) {
831 dev->stats.tx_dropped++;
832 spin_unlock_irqrestore(&priv->irqlock, flags);
833 spin_unlock_bh(&priv->timerlock);
834 netif_stop_queue(dev);
835 return NETDEV_TX_BUSY;
836 }
837
838 frame_ctl = IEEE80211_FTYPE_DATA;
839 header.duration_id = 0;
840 header.seq_ctrl = 0;
841 if (priv->wep_is_on)
842 frame_ctl |= IEEE80211_FCTL_PROTECTED;
843 if (priv->operating_mode == IW_MODE_ADHOC) {
844 skb_copy_from_linear_data(skb, &header.addr1, ETH_ALEN);
845 memcpy(&header.addr2, dev->dev_addr, ETH_ALEN);
846 memcpy(&header.addr3, priv->BSSID, ETH_ALEN);
847 } else {
848 frame_ctl |= IEEE80211_FCTL_TODS;
849 memcpy(&header.addr1, priv->CurrentBSSID, ETH_ALEN);
850 memcpy(&header.addr2, dev->dev_addr, ETH_ALEN);
851 skb_copy_from_linear_data(skb, &header.addr3, ETH_ALEN);
852 }
853
854 if (priv->use_wpa)
855 memcpy(&header.addr4, rfc1042_header, ETH_ALEN);
856
857 header.frame_control = cpu_to_le16(frame_ctl);
858 /* Copy the wireless header into the card */
859 atmel_copy_to_card(dev, buff, (unsigned char *)&header, DATA_FRAME_WS_HEADER_SIZE);
860 /* Copy the packet sans its 802.3 header addresses which have been replaced */
861 atmel_copy_to_card(dev, buff + DATA_FRAME_WS_HEADER_SIZE, skb->data + 12, len - 12);
862 priv->tx_buff_tail += len - 12 + DATA_FRAME_WS_HEADER_SIZE;
863
864 /* low bit of first byte of destination tells us if broadcast */
865 tx_update_descriptor(priv, *(skb->data) & 0x01, len + 18, buff, TX_PACKET_TYPE_DATA);
866 dev->stats.tx_bytes += len;
867
868 spin_unlock_irqrestore(&priv->irqlock, flags);
869 spin_unlock_bh(&priv->timerlock);
870 dev_kfree_skb(skb);
871
872 return NETDEV_TX_OK;
873 }
874
875 static void atmel_transmit_management_frame(struct atmel_private *priv,
876 struct ieee80211_hdr *header,
877 u8 *body, int body_len)
878 {
879 u16 buff;
880 int len = MGMT_FRAME_BODY_OFFSET + body_len;
881
882 if (!(buff = find_tx_buff(priv, len)))
883 return;
884
885 atmel_copy_to_card(priv->dev, buff, (u8 *)header, MGMT_FRAME_BODY_OFFSET);
886 atmel_copy_to_card(priv->dev, buff + MGMT_FRAME_BODY_OFFSET, body, body_len);
887 priv->tx_buff_tail += len;
888 tx_update_descriptor(priv, header->addr1[0] & 0x01, len, buff, TX_PACKET_TYPE_MGMT);
889 }
890
891 static void fast_rx_path(struct atmel_private *priv,
892 struct ieee80211_hdr *header,
893 u16 msdu_size, u16 rx_packet_loc, u32 crc)
894 {
895 /* fast path: unfragmented packet copy directly into skbuf */
896 u8 mac4[6];
897 struct sk_buff *skb;
898 unsigned char *skbp;
899
900 /* get the final, mac 4 header field, this tells us encapsulation */
901 atmel_copy_to_host(priv->dev, mac4, rx_packet_loc + 24, 6);
902 msdu_size -= 6;
903
904 if (priv->do_rx_crc) {
905 crc = crc32_le(crc, mac4, 6);
906 msdu_size -= 4;
907 }
908
909 if (!(skb = dev_alloc_skb(msdu_size + 14))) {
910 priv->dev->stats.rx_dropped++;
911 return;
912 }
913
914 skb_reserve(skb, 2);
915 skbp = skb_put(skb, msdu_size + 12);
916 atmel_copy_to_host(priv->dev, skbp + 12, rx_packet_loc + 30, msdu_size);
917
918 if (priv->do_rx_crc) {
919 u32 netcrc;
920 crc = crc32_le(crc, skbp + 12, msdu_size);
921 atmel_copy_to_host(priv->dev, (void *)&netcrc, rx_packet_loc + 30 + msdu_size, 4);
922 if ((crc ^ 0xffffffff) != netcrc) {
923 priv->dev->stats.rx_crc_errors++;
924 dev_kfree_skb(skb);
925 return;
926 }
927 }
928
929 memcpy(skbp, header->addr1, ETH_ALEN); /* destination address */
930 if (le16_to_cpu(header->frame_control) & IEEE80211_FCTL_FROMDS)
931 memcpy(&skbp[ETH_ALEN], header->addr3, ETH_ALEN);
932 else
933 memcpy(&skbp[ETH_ALEN], header->addr2, ETH_ALEN); /* source address */
934
935 skb->protocol = eth_type_trans(skb, priv->dev);
936 skb->ip_summed = CHECKSUM_NONE;
937 netif_rx(skb);
938 priv->dev->stats.rx_bytes += 12 + msdu_size;
939 priv->dev->stats.rx_packets++;
940 }
941
942 /* Test to see if the packet in card memory at packet_loc has a valid CRC
943 It doesn't matter that this is slow: it is only used to proble the first few
944 packets. */
945 static int probe_crc(struct atmel_private *priv, u16 packet_loc, u16 msdu_size)
946 {
947 int i = msdu_size - 4;
948 u32 netcrc, crc = 0xffffffff;
949
950 if (msdu_size < 4)
951 return 0;
952
953 atmel_copy_to_host(priv->dev, (void *)&netcrc, packet_loc + i, 4);
954
955 atmel_writeAR(priv->dev, packet_loc);
956 while (i--) {
957 u8 octet = atmel_read8(priv->dev, DR);
958 crc = crc32_le(crc, &octet, 1);
959 }
960
961 return (crc ^ 0xffffffff) == netcrc;
962 }
963
964 static void frag_rx_path(struct atmel_private *priv,
965 struct ieee80211_hdr *header,
966 u16 msdu_size, u16 rx_packet_loc, u32 crc, u16 seq_no,
967 u8 frag_no, int more_frags)
968 {
969 u8 mac4[ETH_ALEN];
970 u8 source[ETH_ALEN];
971 struct sk_buff *skb;
972
973 if (le16_to_cpu(header->frame_control) & IEEE80211_FCTL_FROMDS)
974 memcpy(source, header->addr3, ETH_ALEN);
975 else
976 memcpy(source, header->addr2, ETH_ALEN);
977
978 rx_packet_loc += 24; /* skip header */
979
980 if (priv->do_rx_crc)
981 msdu_size -= 4;
982
983 if (frag_no == 0) { /* first fragment */
984 atmel_copy_to_host(priv->dev, mac4, rx_packet_loc, ETH_ALEN);
985 msdu_size -= ETH_ALEN;
986 rx_packet_loc += ETH_ALEN;
987
988 if (priv->do_rx_crc)
989 crc = crc32_le(crc, mac4, 6);
990
991 priv->frag_seq = seq_no;
992 priv->frag_no = 1;
993 priv->frag_len = msdu_size;
994 memcpy(priv->frag_source, source, ETH_ALEN);
995 memcpy(&priv->rx_buf[ETH_ALEN], source, ETH_ALEN);
996 memcpy(priv->rx_buf, header->addr1, ETH_ALEN);
997
998 atmel_copy_to_host(priv->dev, &priv->rx_buf[12], rx_packet_loc, msdu_size);
999
1000 if (priv->do_rx_crc) {
1001 u32 netcrc;
1002 crc = crc32_le(crc, &priv->rx_buf[12], msdu_size);
1003 atmel_copy_to_host(priv->dev, (void *)&netcrc, rx_packet_loc + msdu_size, 4);
1004 if ((crc ^ 0xffffffff) != netcrc) {
1005 priv->dev->stats.rx_crc_errors++;
1006 eth_broadcast_addr(priv->frag_source);
1007 }
1008 }
1009
1010 } else if (priv->frag_no == frag_no &&
1011 priv->frag_seq == seq_no &&
1012 memcmp(priv->frag_source, source, ETH_ALEN) == 0) {
1013
1014 atmel_copy_to_host(priv->dev, &priv->rx_buf[12 + priv->frag_len],
1015 rx_packet_loc, msdu_size);
1016 if (priv->do_rx_crc) {
1017 u32 netcrc;
1018 crc = crc32_le(crc,
1019 &priv->rx_buf[12 + priv->frag_len],
1020 msdu_size);
1021 atmel_copy_to_host(priv->dev, (void *)&netcrc, rx_packet_loc + msdu_size, 4);
1022 if ((crc ^ 0xffffffff) != netcrc) {
1023 priv->dev->stats.rx_crc_errors++;
1024 eth_broadcast_addr(priv->frag_source);
1025 more_frags = 1; /* don't send broken assembly */
1026 }
1027 }
1028
1029 priv->frag_len += msdu_size;
1030 priv->frag_no++;
1031
1032 if (!more_frags) { /* last one */
1033 eth_broadcast_addr(priv->frag_source);
1034 if (!(skb = dev_alloc_skb(priv->frag_len + 14))) {
1035 priv->dev->stats.rx_dropped++;
1036 } else {
1037 skb_reserve(skb, 2);
1038 skb_put_data(skb, priv->rx_buf,
1039 priv->frag_len + 12);
1040 skb->protocol = eth_type_trans(skb, priv->dev);
1041 skb->ip_summed = CHECKSUM_NONE;
1042 netif_rx(skb);
1043 priv->dev->stats.rx_bytes += priv->frag_len + 12;
1044 priv->dev->stats.rx_packets++;
1045 }
1046 }
1047 } else
1048 priv->wstats.discard.fragment++;
1049 }
1050
1051 static void rx_done_irq(struct atmel_private *priv)
1052 {
1053 int i;
1054 struct ieee80211_hdr header;
1055
1056 for (i = 0;
1057 atmel_rmem8(priv, atmel_rx(priv, RX_DESC_FLAGS_OFFSET, priv->rx_desc_head)) == RX_DESC_FLAG_VALID &&
1058 i < priv->host_info.rx_desc_count;
1059 i++) {
1060
1061 u16 msdu_size, rx_packet_loc, frame_ctl, seq_control;
1062 u8 status = atmel_rmem8(priv, atmel_rx(priv, RX_DESC_STATUS_OFFSET, priv->rx_desc_head));
1063 u32 crc = 0xffffffff;
1064
1065 if (status != RX_STATUS_SUCCESS) {
1066 if (status == 0xc1) /* determined by experiment */
1067 priv->wstats.discard.nwid++;
1068 else
1069 priv->dev->stats.rx_errors++;
1070 goto next;
1071 }
1072
1073 msdu_size = atmel_rmem16(priv, atmel_rx(priv, RX_DESC_MSDU_SIZE_OFFSET, priv->rx_desc_head));
1074 rx_packet_loc = atmel_rmem16(priv, atmel_rx(priv, RX_DESC_MSDU_POS_OFFSET, priv->rx_desc_head));
1075
1076 if (msdu_size < 30) {
1077 priv->dev->stats.rx_errors++;
1078 goto next;
1079 }
1080
1081 /* Get header as far as end of seq_ctrl */
1082 atmel_copy_to_host(priv->dev, (char *)&header, rx_packet_loc, 24);
1083 frame_ctl = le16_to_cpu(header.frame_control);
1084 seq_control = le16_to_cpu(header.seq_ctrl);
1085
1086 /* probe for CRC use here if needed once five packets have
1087 arrived with the same crc status, we assume we know what's
1088 happening and stop probing */
1089 if (priv->probe_crc) {
1090 if (!priv->wep_is_on || !(frame_ctl & IEEE80211_FCTL_PROTECTED)) {
1091 priv->do_rx_crc = probe_crc(priv, rx_packet_loc, msdu_size);
1092 } else {
1093 priv->do_rx_crc = probe_crc(priv, rx_packet_loc + 24, msdu_size - 24);
1094 }
1095 if (priv->do_rx_crc) {
1096 if (priv->crc_ok_cnt++ > 5)
1097 priv->probe_crc = 0;
1098 } else {
1099 if (priv->crc_ko_cnt++ > 5)
1100 priv->probe_crc = 0;
1101 }
1102 }
1103
1104 /* don't CRC header when WEP in use */
1105 if (priv->do_rx_crc && (!priv->wep_is_on || !(frame_ctl & IEEE80211_FCTL_PROTECTED))) {
1106 crc = crc32_le(0xffffffff, (unsigned char *)&header, 24);
1107 }
1108 msdu_size -= 24; /* header */
1109
1110 if ((frame_ctl & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA) {
1111 int more_fragments = frame_ctl & IEEE80211_FCTL_MOREFRAGS;
1112 u8 packet_fragment_no = seq_control & IEEE80211_SCTL_FRAG;
1113 u16 packet_sequence_no = (seq_control & IEEE80211_SCTL_SEQ) >> 4;
1114
1115 if (!more_fragments && packet_fragment_no == 0) {
1116 fast_rx_path(priv, &header, msdu_size, rx_packet_loc, crc);
1117 } else {
1118 frag_rx_path(priv, &header, msdu_size, rx_packet_loc, crc,
1119 packet_sequence_no, packet_fragment_no, more_fragments);
1120 }
1121 }
1122
1123 if ((frame_ctl & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT) {
1124 /* copy rest of packet into buffer */
1125 atmel_copy_to_host(priv->dev, (unsigned char *)&priv->rx_buf, rx_packet_loc + 24, msdu_size);
1126
1127 /* we use the same buffer for frag reassembly and control packets */
1128 eth_broadcast_addr(priv->frag_source);
1129
1130 if (priv->do_rx_crc) {
1131 /* last 4 octets is crc */
1132 msdu_size -= 4;
1133 crc = crc32_le(crc, (unsigned char *)&priv->rx_buf, msdu_size);
1134 if ((crc ^ 0xffffffff) != (*((u32 *)&priv->rx_buf[msdu_size]))) {
1135 priv->dev->stats.rx_crc_errors++;
1136 goto next;
1137 }
1138 }
1139
1140 atmel_management_frame(priv, &header, msdu_size,
1141 atmel_rmem8(priv, atmel_rx(priv, RX_DESC_RSSI_OFFSET, priv->rx_desc_head)));
1142 }
1143
1144 next:
1145 /* release descriptor */
1146 atmel_wmem8(priv, atmel_rx(priv, RX_DESC_FLAGS_OFFSET, priv->rx_desc_head), RX_DESC_FLAG_CONSUMED);
1147
1148 if (priv->rx_desc_head < (priv->host_info.rx_desc_count - 1))
1149 priv->rx_desc_head++;
1150 else
1151 priv->rx_desc_head = 0;
1152 }
1153 }
1154
1155 static irqreturn_t service_interrupt(int irq, void *dev_id)
1156 {
1157 struct net_device *dev = (struct net_device *) dev_id;
1158 struct atmel_private *priv = netdev_priv(dev);
1159 u8 isr;
1160 int i = -1;
1161 static const u8 irq_order[] = {
1162 ISR_OUT_OF_RANGE,
1163 ISR_RxCOMPLETE,
1164 ISR_TxCOMPLETE,
1165 ISR_RxFRAMELOST,
1166 ISR_FATAL_ERROR,
1167 ISR_COMMAND_COMPLETE,
1168 ISR_IBSS_MERGE,
1169 ISR_GENERIC_IRQ
1170 };
1171
1172 if (priv->card && priv->present_callback &&
1173 !(*priv->present_callback)(priv->card))
1174 return IRQ_HANDLED;
1175
1176 /* In this state upper-level code assumes it can mess with
1177 the card unhampered by interrupts which may change register state.
1178 Note that even though the card shouldn't generate interrupts
1179 the inturrupt line may be shared. This allows card setup
1180 to go on without disabling interrupts for a long time. */
1181 if (priv->station_state == STATION_STATE_DOWN)
1182 return IRQ_NONE;
1183
1184 atmel_clear_gcr(dev, GCR_ENINT); /* disable interrupts */
1185
1186 while (1) {
1187 if (!atmel_lock_mac(priv)) {
1188 /* failed to contact card */
1189 printk(KERN_ALERT "%s: failed to contact MAC.\n", dev->name);
1190 return IRQ_HANDLED;
1191 }
1192
1193 isr = atmel_rmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET));
1194 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0);
1195
1196 if (!isr) {
1197 atmel_set_gcr(dev, GCR_ENINT); /* enable interrupts */
1198 return i == -1 ? IRQ_NONE : IRQ_HANDLED;
1199 }
1200
1201 atmel_set_gcr(dev, GCR_ACKINT); /* acknowledge interrupt */
1202
1203 for (i = 0; i < ARRAY_SIZE(irq_order); i++)
1204 if (isr & irq_order[i])
1205 break;
1206
1207 if (!atmel_lock_mac(priv)) {
1208 /* failed to contact card */
1209 printk(KERN_ALERT "%s: failed to contact MAC.\n", dev->name);
1210 return IRQ_HANDLED;
1211 }
1212
1213 isr = atmel_rmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET));
1214 isr ^= irq_order[i];
1215 atmel_wmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET), isr);
1216 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0);
1217
1218 switch (irq_order[i]) {
1219
1220 case ISR_OUT_OF_RANGE:
1221 if (priv->operating_mode == IW_MODE_INFRA &&
1222 priv->station_state == STATION_STATE_READY) {
1223 priv->station_is_associated = 0;
1224 atmel_scan(priv, 1);
1225 }
1226 break;
1227
1228 case ISR_RxFRAMELOST:
1229 priv->wstats.discard.misc++;
1230 fallthrough;
1231 case ISR_RxCOMPLETE:
1232 rx_done_irq(priv);
1233 break;
1234
1235 case ISR_TxCOMPLETE:
1236 tx_done_irq(priv);
1237 break;
1238
1239 case ISR_FATAL_ERROR:
1240 printk(KERN_ALERT "%s: *** FATAL error interrupt ***\n", dev->name);
1241 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
1242 break;
1243
1244 case ISR_COMMAND_COMPLETE:
1245 atmel_command_irq(priv);
1246 break;
1247
1248 case ISR_IBSS_MERGE:
1249 atmel_get_mib(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_CUR_BSSID_POS,
1250 priv->CurrentBSSID, 6);
1251 /* The WPA stuff cares about the current AP address */
1252 if (priv->use_wpa)
1253 build_wpa_mib(priv);
1254 break;
1255 case ISR_GENERIC_IRQ:
1256 printk(KERN_INFO "%s: Generic_irq received.\n", dev->name);
1257 break;
1258 }
1259 }
1260 }
1261
1262 static struct iw_statistics *atmel_get_wireless_stats(struct net_device *dev)
1263 {
1264 struct atmel_private *priv = netdev_priv(dev);
1265
1266 /* update the link quality here in case we are seeing no beacons
1267 at all to drive the process */
1268 atmel_smooth_qual(priv);
1269
1270 priv->wstats.status = priv->station_state;
1271
1272 if (priv->operating_mode == IW_MODE_INFRA) {
1273 if (priv->station_state != STATION_STATE_READY) {
1274 priv->wstats.qual.qual = 0;
1275 priv->wstats.qual.level = 0;
1276 priv->wstats.qual.updated = (IW_QUAL_QUAL_INVALID
1277 | IW_QUAL_LEVEL_INVALID);
1278 }
1279 priv->wstats.qual.noise = 0;
1280 priv->wstats.qual.updated |= IW_QUAL_NOISE_INVALID;
1281 } else {
1282 /* Quality levels cannot be determined in ad-hoc mode,
1283 because we can 'hear' more that one remote station. */
1284 priv->wstats.qual.qual = 0;
1285 priv->wstats.qual.level = 0;
1286 priv->wstats.qual.noise = 0;
1287 priv->wstats.qual.updated = IW_QUAL_QUAL_INVALID
1288 | IW_QUAL_LEVEL_INVALID
1289 | IW_QUAL_NOISE_INVALID;
1290 priv->wstats.miss.beacon = 0;
1291 }
1292
1293 return &priv->wstats;
1294 }
1295
1296 static int atmel_set_mac_address(struct net_device *dev, void *p)
1297 {
1298 struct sockaddr *addr = p;
1299
1300 memcpy (dev->dev_addr, addr->sa_data, dev->addr_len);
1301 return atmel_open(dev);
1302 }
1303
1304 EXPORT_SYMBOL(atmel_open);
1305
1306 int atmel_open(struct net_device *dev)
1307 {
1308 struct atmel_private *priv = netdev_priv(dev);
1309 int i, channel, err;
1310
1311 /* any scheduled timer is no longer needed and might screw things up.. */
1312 del_timer_sync(&priv->management_timer);
1313
1314 /* Interrupts will not touch the card once in this state... */
1315 priv->station_state = STATION_STATE_DOWN;
1316
1317 if (priv->new_SSID_size) {
1318 memcpy(priv->SSID, priv->new_SSID, priv->new_SSID_size);
1319 priv->SSID_size = priv->new_SSID_size;
1320 priv->new_SSID_size = 0;
1321 }
1322 priv->BSS_list_entries = 0;
1323
1324 priv->AuthenticationRequestRetryCnt = 0;
1325 priv->AssociationRequestRetryCnt = 0;
1326 priv->ReAssociationRequestRetryCnt = 0;
1327 priv->CurrentAuthentTransactionSeqNum = 0x0001;
1328 priv->ExpectedAuthentTransactionSeqNum = 0x0002;
1329
1330 priv->site_survey_state = SITE_SURVEY_IDLE;
1331 priv->station_is_associated = 0;
1332
1333 err = reset_atmel_card(dev);
1334 if (err)
1335 return err;
1336
1337 if (priv->config_reg_domain) {
1338 priv->reg_domain = priv->config_reg_domain;
1339 atmel_set_mib8(priv, Phy_Mib_Type, PHY_MIB_REG_DOMAIN_POS, priv->reg_domain);
1340 } else {
1341 priv->reg_domain = atmel_get_mib8(priv, Phy_Mib_Type, PHY_MIB_REG_DOMAIN_POS);
1342 for (i = 0; i < ARRAY_SIZE(channel_table); i++)
1343 if (priv->reg_domain == channel_table[i].reg_domain)
1344 break;
1345 if (i == ARRAY_SIZE(channel_table)) {
1346 priv->reg_domain = REG_DOMAIN_MKK1;
1347 printk(KERN_ALERT "%s: failed to get regulatory domain: assuming MKK1.\n", dev->name);
1348 }
1349 }
1350
1351 if ((channel = atmel_validate_channel(priv, priv->channel)))
1352 priv->channel = channel;
1353
1354 /* this moves station_state on.... */
1355 atmel_scan(priv, 1);
1356
1357 atmel_set_gcr(priv->dev, GCR_ENINT); /* enable interrupts */
1358 return 0;
1359 }
1360
1361 static int atmel_close(struct net_device *dev)
1362 {
1363 struct atmel_private *priv = netdev_priv(dev);
1364
1365 /* Send event to userspace that we are disassociating */
1366 if (priv->station_state == STATION_STATE_READY) {
1367 union iwreq_data wrqu;
1368
1369 wrqu.data.length = 0;
1370 wrqu.data.flags = 0;
1371 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1372 eth_zero_addr(wrqu.ap_addr.sa_data);
1373 wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
1374 }
1375
1376 atmel_enter_state(priv, STATION_STATE_DOWN);
1377
1378 if (priv->bus_type == BUS_TYPE_PCCARD)
1379 atmel_write16(dev, GCR, 0x0060);
1380 atmel_write16(dev, GCR, 0x0040);
1381 return 0;
1382 }
1383
1384 static int atmel_validate_channel(struct atmel_private *priv, int channel)
1385 {
1386 /* check that channel is OK, if so return zero,
1387 else return suitable default channel */
1388 int i;
1389
1390 for (i = 0; i < ARRAY_SIZE(channel_table); i++)
1391 if (priv->reg_domain == channel_table[i].reg_domain) {
1392 if (channel >= channel_table[i].min &&
1393 channel <= channel_table[i].max)
1394 return 0;
1395 else
1396 return channel_table[i].min;
1397 }
1398 return 0;
1399 }
1400
1401 #ifdef CONFIG_PROC_FS
1402 static int atmel_proc_show(struct seq_file *m, void *v)
1403 {
1404 struct atmel_private *priv = m->private;
1405 int i;
1406 char *s, *r, *c;
1407
1408 seq_printf(m, "Driver version:\t\t%d.%d\n", DRIVER_MAJOR, DRIVER_MINOR);
1409
1410 if (priv->station_state != STATION_STATE_DOWN) {
1411 seq_printf(m,
1412 "Firmware version:\t%d.%d build %d\n"
1413 "Firmware location:\t",
1414 priv->host_info.major_version,
1415 priv->host_info.minor_version,
1416 priv->host_info.build_version);
1417
1418 if (priv->card_type != CARD_TYPE_EEPROM)
1419 seq_puts(m, "on card\n");
1420 else if (priv->firmware)
1421 seq_printf(m, "%s loaded by host\n", priv->firmware_id);
1422 else
1423 seq_printf(m, "%s loaded by hotplug\n", priv->firmware_id);
1424
1425 switch (priv->card_type) {
1426 case CARD_TYPE_PARALLEL_FLASH:
1427 c = "Parallel flash";
1428 break;
1429 case CARD_TYPE_SPI_FLASH:
1430 c = "SPI flash\n";
1431 break;
1432 case CARD_TYPE_EEPROM:
1433 c = "EEPROM";
1434 break;
1435 default:
1436 c = "<unknown>";
1437 }
1438
1439 r = "<unknown>";
1440 for (i = 0; i < ARRAY_SIZE(channel_table); i++)
1441 if (priv->reg_domain == channel_table[i].reg_domain)
1442 r = channel_table[i].name;
1443
1444 seq_printf(m, "MAC memory type:\t%s\n", c);
1445 seq_printf(m, "Regulatory domain:\t%s\n", r);
1446 seq_printf(m, "Host CRC checking:\t%s\n",
1447 priv->do_rx_crc ? "On" : "Off");
1448 seq_printf(m, "WPA-capable firmware:\t%s\n",
1449 priv->use_wpa ? "Yes" : "No");
1450 }
1451
1452 switch (priv->station_state) {
1453 case STATION_STATE_SCANNING:
1454 s = "Scanning";
1455 break;
1456 case STATION_STATE_JOINNING:
1457 s = "Joining";
1458 break;
1459 case STATION_STATE_AUTHENTICATING:
1460 s = "Authenticating";
1461 break;
1462 case STATION_STATE_ASSOCIATING:
1463 s = "Associating";
1464 break;
1465 case STATION_STATE_READY:
1466 s = "Ready";
1467 break;
1468 case STATION_STATE_REASSOCIATING:
1469 s = "Reassociating";
1470 break;
1471 case STATION_STATE_MGMT_ERROR:
1472 s = "Management error";
1473 break;
1474 case STATION_STATE_DOWN:
1475 s = "Down";
1476 break;
1477 default:
1478 s = "<unknown>";
1479 }
1480
1481 seq_printf(m, "Current state:\t\t%s\n", s);
1482 return 0;
1483 }
1484 #endif
1485
1486 static const struct net_device_ops atmel_netdev_ops = {
1487 .ndo_open = atmel_open,
1488 .ndo_stop = atmel_close,
1489 .ndo_set_mac_address = atmel_set_mac_address,
1490 .ndo_start_xmit = start_tx,
1491 .ndo_do_ioctl = atmel_ioctl,
1492 .ndo_validate_addr = eth_validate_addr,
1493 };
1494
1495 struct net_device *init_atmel_card(unsigned short irq, unsigned long port,
1496 const AtmelFWType fw_type,
1497 struct device *sys_dev,
1498 int (*card_present)(void *), void *card)
1499 {
1500 struct net_device *dev;
1501 struct atmel_private *priv;
1502 int rc;
1503
1504 /* Create the network device object. */
1505 dev = alloc_etherdev(sizeof(*priv));
1506 if (!dev)
1507 return NULL;
1508
1509 if (dev_alloc_name(dev, dev->name) < 0) {
1510 printk(KERN_ERR "atmel: Couldn't get name!\n");
1511 goto err_out_free;
1512 }
1513
1514 priv = netdev_priv(dev);
1515 priv->dev = dev;
1516 priv->sys_dev = sys_dev;
1517 priv->present_callback = card_present;
1518 priv->card = card;
1519 priv->firmware = NULL;
1520 priv->firmware_type = fw_type;
1521 if (firmware) /* module parameter */
1522 strlcpy(priv->firmware_id, firmware, sizeof(priv->firmware_id));
1523 priv->bus_type = card_present ? BUS_TYPE_PCCARD : BUS_TYPE_PCI;
1524 priv->station_state = STATION_STATE_DOWN;
1525 priv->do_rx_crc = 0;
1526 /* For PCMCIA cards, some chips need CRC, some don't
1527 so we have to probe. */
1528 if (priv->bus_type == BUS_TYPE_PCCARD) {
1529 priv->probe_crc = 1;
1530 priv->crc_ok_cnt = priv->crc_ko_cnt = 0;
1531 } else
1532 priv->probe_crc = 0;
1533 priv->last_qual = jiffies;
1534 priv->last_beacon_timestamp = 0;
1535 memset(priv->frag_source, 0xff, sizeof(priv->frag_source));
1536 eth_zero_addr(priv->BSSID);
1537 priv->CurrentBSSID[0] = 0xFF; /* Initialize to something invalid.... */
1538 priv->station_was_associated = 0;
1539
1540 priv->last_survey = jiffies;
1541 priv->preamble = LONG_PREAMBLE;
1542 priv->operating_mode = IW_MODE_INFRA;
1543 priv->connect_to_any_BSS = 0;
1544 priv->config_reg_domain = 0;
1545 priv->reg_domain = 0;
1546 priv->tx_rate = 3;
1547 priv->auto_tx_rate = 1;
1548 priv->channel = 4;
1549 priv->power_mode = 0;
1550 priv->SSID[0] = '\0';
1551 priv->SSID_size = 0;
1552 priv->new_SSID_size = 0;
1553 priv->frag_threshold = 2346;
1554 priv->rts_threshold = 2347;
1555 priv->short_retry = 7;
1556 priv->long_retry = 4;
1557
1558 priv->wep_is_on = 0;
1559 priv->default_key = 0;
1560 priv->encryption_level = 0;
1561 priv->exclude_unencrypted = 0;
1562 priv->group_cipher_suite = priv->pairwise_cipher_suite = CIPHER_SUITE_NONE;
1563 priv->use_wpa = 0;
1564 memset(priv->wep_keys, 0, sizeof(priv->wep_keys));
1565 memset(priv->wep_key_len, 0, sizeof(priv->wep_key_len));
1566
1567 priv->default_beacon_period = priv->beacon_period = 100;
1568 priv->listen_interval = 1;
1569
1570 timer_setup(&priv->management_timer, atmel_management_timer, 0);
1571 spin_lock_init(&priv->irqlock);
1572 spin_lock_init(&priv->timerlock);
1573
1574 dev->netdev_ops = &atmel_netdev_ops;
1575 dev->wireless_handlers = &atmel_handler_def;
1576 dev->irq = irq;
1577 dev->base_addr = port;
1578
1579 /* MTU range: 68 - 2312 */
1580 dev->min_mtu = 68;
1581 dev->max_mtu = MAX_WIRELESS_BODY - ETH_FCS_LEN;
1582
1583 SET_NETDEV_DEV(dev, sys_dev);
1584
1585 if ((rc = request_irq(dev->irq, service_interrupt, IRQF_SHARED, dev->name, dev))) {
1586 printk(KERN_ERR "%s: register interrupt %d failed, rc %d\n", dev->name, irq, rc);
1587 goto err_out_free;
1588 }
1589
1590 if (!request_region(dev->base_addr, 32,
1591 priv->bus_type == BUS_TYPE_PCCARD ? "atmel_cs" : "atmel_pci")) {
1592 goto err_out_irq;
1593 }
1594
1595 if (register_netdev(dev))
1596 goto err_out_res;
1597
1598 if (!probe_atmel_card(dev)) {
1599 unregister_netdev(dev);
1600 goto err_out_res;
1601 }
1602
1603 netif_carrier_off(dev);
1604
1605 if (!proc_create_single_data("driver/atmel", 0, NULL, atmel_proc_show,
1606 priv))
1607 printk(KERN_WARNING "atmel: unable to create /proc entry.\n");
1608
1609 printk(KERN_INFO "%s: Atmel at76c50x. Version %d.%d. MAC %pM\n",
1610 dev->name, DRIVER_MAJOR, DRIVER_MINOR, dev->dev_addr);
1611
1612 return dev;
1613
1614 err_out_res:
1615 release_region(dev->base_addr, 32);
1616 err_out_irq:
1617 free_irq(dev->irq, dev);
1618 err_out_free:
1619 free_netdev(dev);
1620 return NULL;
1621 }
1622
1623 EXPORT_SYMBOL(init_atmel_card);
1624
1625 void stop_atmel_card(struct net_device *dev)
1626 {
1627 struct atmel_private *priv = netdev_priv(dev);
1628
1629 /* put a brick on it... */
1630 if (priv->bus_type == BUS_TYPE_PCCARD)
1631 atmel_write16(dev, GCR, 0x0060);
1632 atmel_write16(dev, GCR, 0x0040);
1633
1634 del_timer_sync(&priv->management_timer);
1635 unregister_netdev(dev);
1636 remove_proc_entry("driver/atmel", NULL);
1637 free_irq(dev->irq, dev);
1638 kfree(priv->firmware);
1639 release_region(dev->base_addr, 32);
1640 free_netdev(dev);
1641 }
1642
1643 EXPORT_SYMBOL(stop_atmel_card);
1644
1645 static int atmel_set_essid(struct net_device *dev,
1646 struct iw_request_info *info,
1647 struct iw_point *dwrq,
1648 char *extra)
1649 {
1650 struct atmel_private *priv = netdev_priv(dev);
1651
1652 /* Check if we asked for `any' */
1653 if (dwrq->flags == 0) {
1654 priv->connect_to_any_BSS = 1;
1655 } else {
1656 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1657
1658 priv->connect_to_any_BSS = 0;
1659
1660 /* Check the size of the string */
1661 if (dwrq->length > MAX_SSID_LENGTH)
1662 return -E2BIG;
1663 if (index != 0)
1664 return -EINVAL;
1665
1666 memcpy(priv->new_SSID, extra, dwrq->length);
1667 priv->new_SSID_size = dwrq->length;
1668 }
1669
1670 return -EINPROGRESS;
1671 }
1672
1673 static int atmel_get_essid(struct net_device *dev,
1674 struct iw_request_info *info,
1675 struct iw_point *dwrq,
1676 char *extra)
1677 {
1678 struct atmel_private *priv = netdev_priv(dev);
1679
1680 /* Get the current SSID */
1681 if (priv->new_SSID_size != 0) {
1682 memcpy(extra, priv->new_SSID, priv->new_SSID_size);
1683 dwrq->length = priv->new_SSID_size;
1684 } else {
1685 memcpy(extra, priv->SSID, priv->SSID_size);
1686 dwrq->length = priv->SSID_size;
1687 }
1688
1689 dwrq->flags = !priv->connect_to_any_BSS; /* active */
1690
1691 return 0;
1692 }
1693
1694 static int atmel_get_wap(struct net_device *dev,
1695 struct iw_request_info *info,
1696 struct sockaddr *awrq,
1697 char *extra)
1698 {
1699 struct atmel_private *priv = netdev_priv(dev);
1700 memcpy(awrq->sa_data, priv->CurrentBSSID, ETH_ALEN);
1701 awrq->sa_family = ARPHRD_ETHER;
1702
1703 return 0;
1704 }
1705
1706 static int atmel_set_encode(struct net_device *dev,
1707 struct iw_request_info *info,
1708 struct iw_point *dwrq,
1709 char *extra)
1710 {
1711 struct atmel_private *priv = netdev_priv(dev);
1712
1713 /* Basic checking: do we have a key to set ?
1714 * Note : with the new API, it's impossible to get a NULL pointer.
1715 * Therefore, we need to check a key size == 0 instead.
1716 * New version of iwconfig properly set the IW_ENCODE_NOKEY flag
1717 * when no key is present (only change flags), but older versions
1718 * don't do it. - Jean II */
1719 if (dwrq->length > 0) {
1720 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1721 int current_index = priv->default_key;
1722 /* Check the size of the key */
1723 if (dwrq->length > 13) {
1724 return -EINVAL;
1725 }
1726 /* Check the index (none -> use current) */
1727 if (index < 0 || index >= 4)
1728 index = current_index;
1729 else
1730 priv->default_key = index;
1731 /* Set the length */
1732 if (dwrq->length > 5)
1733 priv->wep_key_len[index] = 13;
1734 else
1735 if (dwrq->length > 0)
1736 priv->wep_key_len[index] = 5;
1737 else
1738 /* Disable the key */
1739 priv->wep_key_len[index] = 0;
1740 /* Check if the key is not marked as invalid */
1741 if (!(dwrq->flags & IW_ENCODE_NOKEY)) {
1742 /* Cleanup */
1743 memset(priv->wep_keys[index], 0, 13);
1744 /* Copy the key in the driver */
1745 memcpy(priv->wep_keys[index], extra, dwrq->length);
1746 }
1747 /* WE specify that if a valid key is set, encryption
1748 * should be enabled (user may turn it off later)
1749 * This is also how "iwconfig ethX key on" works */
1750 if (index == current_index &&
1751 priv->wep_key_len[index] > 0) {
1752 priv->wep_is_on = 1;
1753 priv->exclude_unencrypted = 1;
1754 if (priv->wep_key_len[index] > 5) {
1755 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_128;
1756 priv->encryption_level = 2;
1757 } else {
1758 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_64;
1759 priv->encryption_level = 1;
1760 }
1761 }
1762 } else {
1763 /* Do we want to just set the transmit key index ? */
1764 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1765 if (index >= 0 && index < 4) {
1766 priv->default_key = index;
1767 } else
1768 /* Don't complain if only change the mode */
1769 if (!(dwrq->flags & IW_ENCODE_MODE))
1770 return -EINVAL;
1771 }
1772 /* Read the flags */
1773 if (dwrq->flags & IW_ENCODE_DISABLED) {
1774 priv->wep_is_on = 0;
1775 priv->encryption_level = 0;
1776 priv->pairwise_cipher_suite = CIPHER_SUITE_NONE;
1777 } else {
1778 priv->wep_is_on = 1;
1779 if (priv->wep_key_len[priv->default_key] > 5) {
1780 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_128;
1781 priv->encryption_level = 2;
1782 } else {
1783 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_64;
1784 priv->encryption_level = 1;
1785 }
1786 }
1787 if (dwrq->flags & IW_ENCODE_RESTRICTED)
1788 priv->exclude_unencrypted = 1;
1789 if (dwrq->flags & IW_ENCODE_OPEN)
1790 priv->exclude_unencrypted = 0;
1791
1792 return -EINPROGRESS; /* Call commit handler */
1793 }
1794
1795 static int atmel_get_encode(struct net_device *dev,
1796 struct iw_request_info *info,
1797 struct iw_point *dwrq,
1798 char *extra)
1799 {
1800 struct atmel_private *priv = netdev_priv(dev);
1801 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1802
1803 if (!priv->wep_is_on)
1804 dwrq->flags = IW_ENCODE_DISABLED;
1805 else {
1806 if (priv->exclude_unencrypted)
1807 dwrq->flags = IW_ENCODE_RESTRICTED;
1808 else
1809 dwrq->flags = IW_ENCODE_OPEN;
1810 }
1811 /* Which key do we want ? -1 -> tx index */
1812 if (index < 0 || index >= 4)
1813 index = priv->default_key;
1814 dwrq->flags |= index + 1;
1815 /* Copy the key to the user buffer */
1816 dwrq->length = priv->wep_key_len[index];
1817 if (dwrq->length > 16) {
1818 dwrq->length = 0;
1819 } else {
1820 memset(extra, 0, 16);
1821 memcpy(extra, priv->wep_keys[index], dwrq->length);
1822 }
1823
1824 return 0;
1825 }
1826
1827 static int atmel_set_encodeext(struct net_device *dev,
1828 struct iw_request_info *info,
1829 union iwreq_data *wrqu,
1830 char *extra)
1831 {
1832 struct atmel_private *priv = netdev_priv(dev);
1833 struct iw_point *encoding = &wrqu->encoding;
1834 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
1835 int idx, key_len, alg = ext->alg, set_key = 1;
1836
1837 /* Determine and validate the key index */
1838 idx = encoding->flags & IW_ENCODE_INDEX;
1839 if (idx) {
1840 if (idx < 1 || idx > 4)
1841 return -EINVAL;
1842 idx--;
1843 } else
1844 idx = priv->default_key;
1845
1846 if (encoding->flags & IW_ENCODE_DISABLED)
1847 alg = IW_ENCODE_ALG_NONE;
1848
1849 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
1850 priv->default_key = idx;
1851 set_key = ext->key_len > 0 ? 1 : 0;
1852 }
1853
1854 if (set_key) {
1855 /* Set the requested key first */
1856 switch (alg) {
1857 case IW_ENCODE_ALG_NONE:
1858 priv->wep_is_on = 0;
1859 priv->encryption_level = 0;
1860 priv->pairwise_cipher_suite = CIPHER_SUITE_NONE;
1861 break;
1862 case IW_ENCODE_ALG_WEP:
1863 if (ext->key_len > 5) {
1864 priv->wep_key_len[idx] = 13;
1865 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_128;
1866 priv->encryption_level = 2;
1867 } else if (ext->key_len > 0) {
1868 priv->wep_key_len[idx] = 5;
1869 priv->pairwise_cipher_suite = CIPHER_SUITE_WEP_64;
1870 priv->encryption_level = 1;
1871 } else {
1872 return -EINVAL;
1873 }
1874 priv->wep_is_on = 1;
1875 memset(priv->wep_keys[idx], 0, 13);
1876 key_len = min ((int)ext->key_len, priv->wep_key_len[idx]);
1877 memcpy(priv->wep_keys[idx], ext->key, key_len);
1878 break;
1879 default:
1880 return -EINVAL;
1881 }
1882 }
1883
1884 return -EINPROGRESS;
1885 }
1886
1887 static int atmel_get_encodeext(struct net_device *dev,
1888 struct iw_request_info *info,
1889 union iwreq_data *wrqu,
1890 char *extra)
1891 {
1892 struct atmel_private *priv = netdev_priv(dev);
1893 struct iw_point *encoding = &wrqu->encoding;
1894 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
1895 int idx, max_key_len;
1896
1897 max_key_len = encoding->length - sizeof(*ext);
1898 if (max_key_len < 0)
1899 return -EINVAL;
1900
1901 idx = encoding->flags & IW_ENCODE_INDEX;
1902 if (idx) {
1903 if (idx < 1 || idx > 4)
1904 return -EINVAL;
1905 idx--;
1906 } else
1907 idx = priv->default_key;
1908
1909 encoding->flags = idx + 1;
1910 memset(ext, 0, sizeof(*ext));
1911
1912 if (!priv->wep_is_on) {
1913 ext->alg = IW_ENCODE_ALG_NONE;
1914 ext->key_len = 0;
1915 encoding->flags |= IW_ENCODE_DISABLED;
1916 } else {
1917 if (priv->encryption_level > 0)
1918 ext->alg = IW_ENCODE_ALG_WEP;
1919 else
1920 return -EINVAL;
1921
1922 ext->key_len = priv->wep_key_len[idx];
1923 memcpy(ext->key, priv->wep_keys[idx], ext->key_len);
1924 encoding->flags |= IW_ENCODE_ENABLED;
1925 }
1926
1927 return 0;
1928 }
1929
1930 static int atmel_set_auth(struct net_device *dev,
1931 struct iw_request_info *info,
1932 union iwreq_data *wrqu, char *extra)
1933 {
1934 struct atmel_private *priv = netdev_priv(dev);
1935 struct iw_param *param = &wrqu->param;
1936
1937 switch (param->flags & IW_AUTH_INDEX) {
1938 case IW_AUTH_WPA_VERSION:
1939 case IW_AUTH_CIPHER_PAIRWISE:
1940 case IW_AUTH_CIPHER_GROUP:
1941 case IW_AUTH_KEY_MGMT:
1942 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
1943 case IW_AUTH_PRIVACY_INVOKED:
1944 /*
1945 * atmel does not use these parameters
1946 */
1947 break;
1948
1949 case IW_AUTH_DROP_UNENCRYPTED:
1950 priv->exclude_unencrypted = param->value ? 1 : 0;
1951 break;
1952
1953 case IW_AUTH_80211_AUTH_ALG: {
1954 if (param->value & IW_AUTH_ALG_SHARED_KEY) {
1955 priv->exclude_unencrypted = 1;
1956 } else if (param->value & IW_AUTH_ALG_OPEN_SYSTEM) {
1957 priv->exclude_unencrypted = 0;
1958 } else
1959 return -EINVAL;
1960 break;
1961 }
1962
1963 case IW_AUTH_WPA_ENABLED:
1964 /* Silently accept disable of WPA */
1965 if (param->value > 0)
1966 return -EOPNOTSUPP;
1967 break;
1968
1969 default:
1970 return -EOPNOTSUPP;
1971 }
1972 return -EINPROGRESS;
1973 }
1974
1975 static int atmel_get_auth(struct net_device *dev,
1976 struct iw_request_info *info,
1977 union iwreq_data *wrqu, char *extra)
1978 {
1979 struct atmel_private *priv = netdev_priv(dev);
1980 struct iw_param *param = &wrqu->param;
1981
1982 switch (param->flags & IW_AUTH_INDEX) {
1983 case IW_AUTH_DROP_UNENCRYPTED:
1984 param->value = priv->exclude_unencrypted;
1985 break;
1986
1987 case IW_AUTH_80211_AUTH_ALG:
1988 if (priv->exclude_unencrypted == 1)
1989 param->value = IW_AUTH_ALG_SHARED_KEY;
1990 else
1991 param->value = IW_AUTH_ALG_OPEN_SYSTEM;
1992 break;
1993
1994 case IW_AUTH_WPA_ENABLED:
1995 param->value = 0;
1996 break;
1997
1998 default:
1999 return -EOPNOTSUPP;
2000 }
2001 return 0;
2002 }
2003
2004
2005 static int atmel_get_name(struct net_device *dev,
2006 struct iw_request_info *info,
2007 char *cwrq,
2008 char *extra)
2009 {
2010 strcpy(cwrq, "IEEE 802.11-DS");
2011 return 0;
2012 }
2013
2014 static int atmel_set_rate(struct net_device *dev,
2015 struct iw_request_info *info,
2016 struct iw_param *vwrq,
2017 char *extra)
2018 {
2019 struct atmel_private *priv = netdev_priv(dev);
2020
2021 if (vwrq->fixed == 0) {
2022 priv->tx_rate = 3;
2023 priv->auto_tx_rate = 1;
2024 } else {
2025 priv->auto_tx_rate = 0;
2026
2027 /* Which type of value ? */
2028 if ((vwrq->value < 4) && (vwrq->value >= 0)) {
2029 /* Setting by rate index */
2030 priv->tx_rate = vwrq->value;
2031 } else {
2032 /* Setting by frequency value */
2033 switch (vwrq->value) {
2034 case 1000000:
2035 priv->tx_rate = 0;
2036 break;
2037 case 2000000:
2038 priv->tx_rate = 1;
2039 break;
2040 case 5500000:
2041 priv->tx_rate = 2;
2042 break;
2043 case 11000000:
2044 priv->tx_rate = 3;
2045 break;
2046 default:
2047 return -EINVAL;
2048 }
2049 }
2050 }
2051
2052 return -EINPROGRESS;
2053 }
2054
2055 static int atmel_set_mode(struct net_device *dev,
2056 struct iw_request_info *info,
2057 __u32 *uwrq,
2058 char *extra)
2059 {
2060 struct atmel_private *priv = netdev_priv(dev);
2061
2062 if (*uwrq != IW_MODE_ADHOC && *uwrq != IW_MODE_INFRA)
2063 return -EINVAL;
2064
2065 priv->operating_mode = *uwrq;
2066 return -EINPROGRESS;
2067 }
2068
2069 static int atmel_get_mode(struct net_device *dev,
2070 struct iw_request_info *info,
2071 __u32 *uwrq,
2072 char *extra)
2073 {
2074 struct atmel_private *priv = netdev_priv(dev);
2075
2076 *uwrq = priv->operating_mode;
2077 return 0;
2078 }
2079
2080 static int atmel_get_rate(struct net_device *dev,
2081 struct iw_request_info *info,
2082 struct iw_param *vwrq,
2083 char *extra)
2084 {
2085 struct atmel_private *priv = netdev_priv(dev);
2086
2087 if (priv->auto_tx_rate) {
2088 vwrq->fixed = 0;
2089 vwrq->value = 11000000;
2090 } else {
2091 vwrq->fixed = 1;
2092 switch (priv->tx_rate) {
2093 case 0:
2094 vwrq->value = 1000000;
2095 break;
2096 case 1:
2097 vwrq->value = 2000000;
2098 break;
2099 case 2:
2100 vwrq->value = 5500000;
2101 break;
2102 case 3:
2103 vwrq->value = 11000000;
2104 break;
2105 }
2106 }
2107 return 0;
2108 }
2109
2110 static int atmel_set_power(struct net_device *dev,
2111 struct iw_request_info *info,
2112 struct iw_param *vwrq,
2113 char *extra)
2114 {
2115 struct atmel_private *priv = netdev_priv(dev);
2116 priv->power_mode = vwrq->disabled ? 0 : 1;
2117 return -EINPROGRESS;
2118 }
2119
2120 static int atmel_get_power(struct net_device *dev,
2121 struct iw_request_info *info,
2122 struct iw_param *vwrq,
2123 char *extra)
2124 {
2125 struct atmel_private *priv = netdev_priv(dev);
2126 vwrq->disabled = priv->power_mode ? 0 : 1;
2127 vwrq->flags = IW_POWER_ON;
2128 return 0;
2129 }
2130
2131 static int atmel_set_retry(struct net_device *dev,
2132 struct iw_request_info *info,
2133 struct iw_param *vwrq,
2134 char *extra)
2135 {
2136 struct atmel_private *priv = netdev_priv(dev);
2137
2138 if (!vwrq->disabled && (vwrq->flags & IW_RETRY_LIMIT)) {
2139 if (vwrq->flags & IW_RETRY_LONG)
2140 priv->long_retry = vwrq->value;
2141 else if (vwrq->flags & IW_RETRY_SHORT)
2142 priv->short_retry = vwrq->value;
2143 else {
2144 /* No modifier : set both */
2145 priv->long_retry = vwrq->value;
2146 priv->short_retry = vwrq->value;
2147 }
2148 return -EINPROGRESS;
2149 }
2150
2151 return -EINVAL;
2152 }
2153
2154 static int atmel_get_retry(struct net_device *dev,
2155 struct iw_request_info *info,
2156 struct iw_param *vwrq,
2157 char *extra)
2158 {
2159 struct atmel_private *priv = netdev_priv(dev);
2160
2161 vwrq->disabled = 0; /* Can't be disabled */
2162
2163 /* Note : by default, display the short retry number */
2164 if (vwrq->flags & IW_RETRY_LONG) {
2165 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
2166 vwrq->value = priv->long_retry;
2167 } else {
2168 vwrq->flags = IW_RETRY_LIMIT;
2169 vwrq->value = priv->short_retry;
2170 if (priv->long_retry != priv->short_retry)
2171 vwrq->flags |= IW_RETRY_SHORT;
2172 }
2173
2174 return 0;
2175 }
2176
2177 static int atmel_set_rts(struct net_device *dev,
2178 struct iw_request_info *info,
2179 struct iw_param *vwrq,
2180 char *extra)
2181 {
2182 struct atmel_private *priv = netdev_priv(dev);
2183 int rthr = vwrq->value;
2184
2185 if (vwrq->disabled)
2186 rthr = 2347;
2187 if ((rthr < 0) || (rthr > 2347)) {
2188 return -EINVAL;
2189 }
2190 priv->rts_threshold = rthr;
2191
2192 return -EINPROGRESS; /* Call commit handler */
2193 }
2194
2195 static int atmel_get_rts(struct net_device *dev,
2196 struct iw_request_info *info,
2197 struct iw_param *vwrq,
2198 char *extra)
2199 {
2200 struct atmel_private *priv = netdev_priv(dev);
2201
2202 vwrq->value = priv->rts_threshold;
2203 vwrq->disabled = (vwrq->value >= 2347);
2204 vwrq->fixed = 1;
2205
2206 return 0;
2207 }
2208
2209 static int atmel_set_frag(struct net_device *dev,
2210 struct iw_request_info *info,
2211 struct iw_param *vwrq,
2212 char *extra)
2213 {
2214 struct atmel_private *priv = netdev_priv(dev);
2215 int fthr = vwrq->value;
2216
2217 if (vwrq->disabled)
2218 fthr = 2346;
2219 if ((fthr < 256) || (fthr > 2346)) {
2220 return -EINVAL;
2221 }
2222 fthr &= ~0x1; /* Get an even value - is it really needed ??? */
2223 priv->frag_threshold = fthr;
2224
2225 return -EINPROGRESS; /* Call commit handler */
2226 }
2227
2228 static int atmel_get_frag(struct net_device *dev,
2229 struct iw_request_info *info,
2230 struct iw_param *vwrq,
2231 char *extra)
2232 {
2233 struct atmel_private *priv = netdev_priv(dev);
2234
2235 vwrq->value = priv->frag_threshold;
2236 vwrq->disabled = (vwrq->value >= 2346);
2237 vwrq->fixed = 1;
2238
2239 return 0;
2240 }
2241
2242 static int atmel_set_freq(struct net_device *dev,
2243 struct iw_request_info *info,
2244 struct iw_freq *fwrq,
2245 char *extra)
2246 {
2247 struct atmel_private *priv = netdev_priv(dev);
2248 int rc = -EINPROGRESS; /* Call commit handler */
2249
2250 /* If setting by frequency, convert to a channel */
2251 if (fwrq->e == 1) {
2252 int f = fwrq->m / 100000;
2253
2254 /* Hack to fall through... */
2255 fwrq->e = 0;
2256 fwrq->m = ieee80211_frequency_to_channel(f);
2257 }
2258 /* Setting by channel number */
2259 if (fwrq->m < 0 || fwrq->m > 1000 || fwrq->e > 0)
2260 rc = -EOPNOTSUPP;
2261 else {
2262 int channel = fwrq->m;
2263 if (atmel_validate_channel(priv, channel) == 0) {
2264 priv->channel = channel;
2265 } else {
2266 rc = -EINVAL;
2267 }
2268 }
2269 return rc;
2270 }
2271
2272 static int atmel_get_freq(struct net_device *dev,
2273 struct iw_request_info *info,
2274 struct iw_freq *fwrq,
2275 char *extra)
2276 {
2277 struct atmel_private *priv = netdev_priv(dev);
2278
2279 fwrq->m = priv->channel;
2280 fwrq->e = 0;
2281 return 0;
2282 }
2283
2284 static int atmel_set_scan(struct net_device *dev,
2285 struct iw_request_info *info,
2286 struct iw_point *dwrq,
2287 char *extra)
2288 {
2289 struct atmel_private *priv = netdev_priv(dev);
2290 unsigned long flags;
2291
2292 /* Note : you may have realised that, as this is a SET operation,
2293 * this is privileged and therefore a normal user can't
2294 * perform scanning.
2295 * This is not an error, while the device perform scanning,
2296 * traffic doesn't flow, so it's a perfect DoS...
2297 * Jean II */
2298
2299 if (priv->station_state == STATION_STATE_DOWN)
2300 return -EAGAIN;
2301
2302 /* Timeout old surveys. */
2303 if (time_after(jiffies, priv->last_survey + 20 * HZ))
2304 priv->site_survey_state = SITE_SURVEY_IDLE;
2305 priv->last_survey = jiffies;
2306
2307 /* Initiate a scan command */
2308 if (priv->site_survey_state == SITE_SURVEY_IN_PROGRESS)
2309 return -EBUSY;
2310
2311 del_timer_sync(&priv->management_timer);
2312 spin_lock_irqsave(&priv->irqlock, flags);
2313
2314 priv->site_survey_state = SITE_SURVEY_IN_PROGRESS;
2315 priv->fast_scan = 0;
2316 atmel_scan(priv, 0);
2317 spin_unlock_irqrestore(&priv->irqlock, flags);
2318
2319 return 0;
2320 }
2321
2322 static int atmel_get_scan(struct net_device *dev,
2323 struct iw_request_info *info,
2324 struct iw_point *dwrq,
2325 char *extra)
2326 {
2327 struct atmel_private *priv = netdev_priv(dev);
2328 int i;
2329 char *current_ev = extra;
2330 struct iw_event iwe;
2331
2332 if (priv->site_survey_state != SITE_SURVEY_COMPLETED)
2333 return -EAGAIN;
2334
2335 for (i = 0; i < priv->BSS_list_entries; i++) {
2336 iwe.cmd = SIOCGIWAP;
2337 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
2338 memcpy(iwe.u.ap_addr.sa_data, priv->BSSinfo[i].BSSID, ETH_ALEN);
2339 current_ev = iwe_stream_add_event(info, current_ev,
2340 extra + IW_SCAN_MAX_DATA,
2341 &iwe, IW_EV_ADDR_LEN);
2342
2343 iwe.u.data.length = priv->BSSinfo[i].SSIDsize;
2344 if (iwe.u.data.length > 32)
2345 iwe.u.data.length = 32;
2346 iwe.cmd = SIOCGIWESSID;
2347 iwe.u.data.flags = 1;
2348 current_ev = iwe_stream_add_point(info, current_ev,
2349 extra + IW_SCAN_MAX_DATA,
2350 &iwe, priv->BSSinfo[i].SSID);
2351
2352 iwe.cmd = SIOCGIWMODE;
2353 iwe.u.mode = priv->BSSinfo[i].BSStype;
2354 current_ev = iwe_stream_add_event(info, current_ev,
2355 extra + IW_SCAN_MAX_DATA,
2356 &iwe, IW_EV_UINT_LEN);
2357
2358 iwe.cmd = SIOCGIWFREQ;
2359 iwe.u.freq.m = priv->BSSinfo[i].channel;
2360 iwe.u.freq.e = 0;
2361 current_ev = iwe_stream_add_event(info, current_ev,
2362 extra + IW_SCAN_MAX_DATA,
2363 &iwe, IW_EV_FREQ_LEN);
2364
2365 /* Add quality statistics */
2366 iwe.cmd = IWEVQUAL;
2367 iwe.u.qual.level = priv->BSSinfo[i].RSSI;
2368 iwe.u.qual.qual = iwe.u.qual.level;
2369 /* iwe.u.qual.noise = SOMETHING */
2370 current_ev = iwe_stream_add_event(info, current_ev,
2371 extra + IW_SCAN_MAX_DATA,
2372 &iwe, IW_EV_QUAL_LEN);
2373
2374
2375 iwe.cmd = SIOCGIWENCODE;
2376 if (priv->BSSinfo[i].UsingWEP)
2377 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
2378 else
2379 iwe.u.data.flags = IW_ENCODE_DISABLED;
2380 iwe.u.data.length = 0;
2381 current_ev = iwe_stream_add_point(info, current_ev,
2382 extra + IW_SCAN_MAX_DATA,
2383 &iwe, NULL);
2384 }
2385
2386 /* Length of data */
2387 dwrq->length = (current_ev - extra);
2388 dwrq->flags = 0;
2389
2390 return 0;
2391 }
2392
2393 static int atmel_get_range(struct net_device *dev,
2394 struct iw_request_info *info,
2395 struct iw_point *dwrq,
2396 char *extra)
2397 {
2398 struct atmel_private *priv = netdev_priv(dev);
2399 struct iw_range *range = (struct iw_range *) extra;
2400 int k, i, j;
2401
2402 dwrq->length = sizeof(struct iw_range);
2403 memset(range, 0, sizeof(struct iw_range));
2404 range->min_nwid = 0x0000;
2405 range->max_nwid = 0x0000;
2406 range->num_channels = 0;
2407 for (j = 0; j < ARRAY_SIZE(channel_table); j++)
2408 if (priv->reg_domain == channel_table[j].reg_domain) {
2409 range->num_channels = channel_table[j].max - channel_table[j].min + 1;
2410 break;
2411 }
2412 if (range->num_channels != 0) {
2413 for (k = 0, i = channel_table[j].min; i <= channel_table[j].max; i++) {
2414 range->freq[k].i = i; /* List index */
2415
2416 /* Values in MHz -> * 10^5 * 10 */
2417 range->freq[k].m = 100000 *
2418 ieee80211_channel_to_frequency(i, NL80211_BAND_2GHZ);
2419 range->freq[k++].e = 1;
2420 }
2421 range->num_frequency = k;
2422 }
2423
2424 range->max_qual.qual = 100;
2425 range->max_qual.level = 100;
2426 range->max_qual.noise = 0;
2427 range->max_qual.updated = IW_QUAL_NOISE_INVALID;
2428
2429 range->avg_qual.qual = 50;
2430 range->avg_qual.level = 50;
2431 range->avg_qual.noise = 0;
2432 range->avg_qual.updated = IW_QUAL_NOISE_INVALID;
2433
2434 range->sensitivity = 0;
2435
2436 range->bitrate[0] = 1000000;
2437 range->bitrate[1] = 2000000;
2438 range->bitrate[2] = 5500000;
2439 range->bitrate[3] = 11000000;
2440 range->num_bitrates = 4;
2441
2442 range->min_rts = 0;
2443 range->max_rts = 2347;
2444 range->min_frag = 256;
2445 range->max_frag = 2346;
2446
2447 range->encoding_size[0] = 5;
2448 range->encoding_size[1] = 13;
2449 range->num_encoding_sizes = 2;
2450 range->max_encoding_tokens = 4;
2451
2452 range->pmp_flags = IW_POWER_ON;
2453 range->pmt_flags = IW_POWER_ON;
2454 range->pm_capa = 0;
2455
2456 range->we_version_source = WIRELESS_EXT;
2457 range->we_version_compiled = WIRELESS_EXT;
2458 range->retry_capa = IW_RETRY_LIMIT ;
2459 range->retry_flags = IW_RETRY_LIMIT;
2460 range->r_time_flags = 0;
2461 range->min_retry = 1;
2462 range->max_retry = 65535;
2463
2464 return 0;
2465 }
2466
2467 static int atmel_set_wap(struct net_device *dev,
2468 struct iw_request_info *info,
2469 struct sockaddr *awrq,
2470 char *extra)
2471 {
2472 struct atmel_private *priv = netdev_priv(dev);
2473 int i;
2474 static const u8 any[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
2475 static const u8 off[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
2476 unsigned long flags;
2477
2478 if (awrq->sa_family != ARPHRD_ETHER)
2479 return -EINVAL;
2480
2481 if (!memcmp(any, awrq->sa_data, 6) ||
2482 !memcmp(off, awrq->sa_data, 6)) {
2483 del_timer_sync(&priv->management_timer);
2484 spin_lock_irqsave(&priv->irqlock, flags);
2485 atmel_scan(priv, 1);
2486 spin_unlock_irqrestore(&priv->irqlock, flags);
2487 return 0;
2488 }
2489
2490 for (i = 0; i < priv->BSS_list_entries; i++) {
2491 if (memcmp(priv->BSSinfo[i].BSSID, awrq->sa_data, 6) == 0) {
2492 if (!priv->wep_is_on && priv->BSSinfo[i].UsingWEP) {
2493 return -EINVAL;
2494 } else if (priv->wep_is_on && !priv->BSSinfo[i].UsingWEP) {
2495 return -EINVAL;
2496 } else {
2497 del_timer_sync(&priv->management_timer);
2498 spin_lock_irqsave(&priv->irqlock, flags);
2499 atmel_join_bss(priv, i);
2500 spin_unlock_irqrestore(&priv->irqlock, flags);
2501 return 0;
2502 }
2503 }
2504 }
2505
2506 return -EINVAL;
2507 }
2508
2509 static int atmel_config_commit(struct net_device *dev,
2510 struct iw_request_info *info, /* NULL */
2511 void *zwrq, /* NULL */
2512 char *extra) /* NULL */
2513 {
2514 return atmel_open(dev);
2515 }
2516
2517 static const iw_handler atmel_handler[] =
2518 {
2519 (iw_handler) atmel_config_commit, /* SIOCSIWCOMMIT */
2520 (iw_handler) atmel_get_name, /* SIOCGIWNAME */
2521 (iw_handler) NULL, /* SIOCSIWNWID */
2522 (iw_handler) NULL, /* SIOCGIWNWID */
2523 (iw_handler) atmel_set_freq, /* SIOCSIWFREQ */
2524 (iw_handler) atmel_get_freq, /* SIOCGIWFREQ */
2525 (iw_handler) atmel_set_mode, /* SIOCSIWMODE */
2526 (iw_handler) atmel_get_mode, /* SIOCGIWMODE */
2527 (iw_handler) NULL, /* SIOCSIWSENS */
2528 (iw_handler) NULL, /* SIOCGIWSENS */
2529 (iw_handler) NULL, /* SIOCSIWRANGE */
2530 (iw_handler) atmel_get_range, /* SIOCGIWRANGE */
2531 (iw_handler) NULL, /* SIOCSIWPRIV */
2532 (iw_handler) NULL, /* SIOCGIWPRIV */
2533 (iw_handler) NULL, /* SIOCSIWSTATS */
2534 (iw_handler) NULL, /* SIOCGIWSTATS */
2535 (iw_handler) NULL, /* SIOCSIWSPY */
2536 (iw_handler) NULL, /* SIOCGIWSPY */
2537 (iw_handler) NULL, /* -- hole -- */
2538 (iw_handler) NULL, /* -- hole -- */
2539 (iw_handler) atmel_set_wap, /* SIOCSIWAP */
2540 (iw_handler) atmel_get_wap, /* SIOCGIWAP */
2541 (iw_handler) NULL, /* -- hole -- */
2542 (iw_handler) NULL, /* SIOCGIWAPLIST */
2543 (iw_handler) atmel_set_scan, /* SIOCSIWSCAN */
2544 (iw_handler) atmel_get_scan, /* SIOCGIWSCAN */
2545 (iw_handler) atmel_set_essid, /* SIOCSIWESSID */
2546 (iw_handler) atmel_get_essid, /* SIOCGIWESSID */
2547 (iw_handler) NULL, /* SIOCSIWNICKN */
2548 (iw_handler) NULL, /* SIOCGIWNICKN */
2549 (iw_handler) NULL, /* -- hole -- */
2550 (iw_handler) NULL, /* -- hole -- */
2551 (iw_handler) atmel_set_rate, /* SIOCSIWRATE */
2552 (iw_handler) atmel_get_rate, /* SIOCGIWRATE */
2553 (iw_handler) atmel_set_rts, /* SIOCSIWRTS */
2554 (iw_handler) atmel_get_rts, /* SIOCGIWRTS */
2555 (iw_handler) atmel_set_frag, /* SIOCSIWFRAG */
2556 (iw_handler) atmel_get_frag, /* SIOCGIWFRAG */
2557 (iw_handler) NULL, /* SIOCSIWTXPOW */
2558 (iw_handler) NULL, /* SIOCGIWTXPOW */
2559 (iw_handler) atmel_set_retry, /* SIOCSIWRETRY */
2560 (iw_handler) atmel_get_retry, /* SIOCGIWRETRY */
2561 (iw_handler) atmel_set_encode, /* SIOCSIWENCODE */
2562 (iw_handler) atmel_get_encode, /* SIOCGIWENCODE */
2563 (iw_handler) atmel_set_power, /* SIOCSIWPOWER */
2564 (iw_handler) atmel_get_power, /* SIOCGIWPOWER */
2565 (iw_handler) NULL, /* -- hole -- */
2566 (iw_handler) NULL, /* -- hole -- */
2567 (iw_handler) NULL, /* SIOCSIWGENIE */
2568 (iw_handler) NULL, /* SIOCGIWGENIE */
2569 (iw_handler) atmel_set_auth, /* SIOCSIWAUTH */
2570 (iw_handler) atmel_get_auth, /* SIOCGIWAUTH */
2571 (iw_handler) atmel_set_encodeext, /* SIOCSIWENCODEEXT */
2572 (iw_handler) atmel_get_encodeext, /* SIOCGIWENCODEEXT */
2573 (iw_handler) NULL, /* SIOCSIWPMKSA */
2574 };
2575
2576 static const iw_handler atmel_private_handler[] =
2577 {
2578 NULL, /* SIOCIWFIRSTPRIV */
2579 };
2580
2581 struct atmel_priv_ioctl {
2582 char id[32];
2583 unsigned char __user *data;
2584 unsigned short len;
2585 };
2586
2587 #define ATMELFWL SIOCIWFIRSTPRIV
2588 #define ATMELIDIFC ATMELFWL + 1
2589 #define ATMELRD ATMELFWL + 2
2590 #define ATMELMAGIC 0x51807
2591 #define REGDOMAINSZ 20
2592
2593 static const struct iw_priv_args atmel_private_args[] = {
2594 {
2595 .cmd = ATMELFWL,
2596 .set_args = IW_PRIV_TYPE_BYTE
2597 | IW_PRIV_SIZE_FIXED
2598 | sizeof(struct atmel_priv_ioctl),
2599 .get_args = IW_PRIV_TYPE_NONE,
2600 .name = "atmelfwl"
2601 }, {
2602 .cmd = ATMELIDIFC,
2603 .set_args = IW_PRIV_TYPE_NONE,
2604 .get_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
2605 .name = "atmelidifc"
2606 }, {
2607 .cmd = ATMELRD,
2608 .set_args = IW_PRIV_TYPE_CHAR | REGDOMAINSZ,
2609 .get_args = IW_PRIV_TYPE_NONE,
2610 .name = "regdomain"
2611 },
2612 };
2613
2614 static const struct iw_handler_def atmel_handler_def = {
2615 .num_standard = ARRAY_SIZE(atmel_handler),
2616 .num_private = ARRAY_SIZE(atmel_private_handler),
2617 .num_private_args = ARRAY_SIZE(atmel_private_args),
2618 .standard = (iw_handler *) atmel_handler,
2619 .private = (iw_handler *) atmel_private_handler,
2620 .private_args = (struct iw_priv_args *) atmel_private_args,
2621 .get_wireless_stats = atmel_get_wireless_stats
2622 };
2623
2624 static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2625 {
2626 int i, rc = 0;
2627 struct atmel_private *priv = netdev_priv(dev);
2628 struct atmel_priv_ioctl com;
2629 struct iwreq *wrq = (struct iwreq *) rq;
2630 unsigned char *new_firmware;
2631 char domain[REGDOMAINSZ + 1];
2632
2633 switch (cmd) {
2634 case ATMELIDIFC:
2635 wrq->u.param.value = ATMELMAGIC;
2636 break;
2637
2638 case ATMELFWL:
2639 if (copy_from_user(&com, rq->ifr_data, sizeof(com))) {
2640 rc = -EFAULT;
2641 break;
2642 }
2643
2644 if (!capable(CAP_NET_ADMIN)) {
2645 rc = -EPERM;
2646 break;
2647 }
2648
2649 new_firmware = memdup_user(com.data, com.len);
2650 if (IS_ERR(new_firmware)) {
2651 rc = PTR_ERR(new_firmware);
2652 break;
2653 }
2654
2655 kfree(priv->firmware);
2656
2657 priv->firmware = new_firmware;
2658 priv->firmware_length = com.len;
2659 strncpy(priv->firmware_id, com.id, 31);
2660 priv->firmware_id[31] = '\0';
2661 break;
2662
2663 case ATMELRD:
2664 if (copy_from_user(domain, rq->ifr_data, REGDOMAINSZ)) {
2665 rc = -EFAULT;
2666 break;
2667 }
2668
2669 if (!capable(CAP_NET_ADMIN)) {
2670 rc = -EPERM;
2671 break;
2672 }
2673
2674 domain[REGDOMAINSZ] = 0;
2675 rc = -EINVAL;
2676 for (i = 0; i < ARRAY_SIZE(channel_table); i++) {
2677 if (!strcasecmp(channel_table[i].name, domain)) {
2678 priv->config_reg_domain = channel_table[i].reg_domain;
2679 rc = 0;
2680 }
2681 }
2682
2683 if (rc == 0 && priv->station_state != STATION_STATE_DOWN)
2684 rc = atmel_open(dev);
2685 break;
2686
2687 default:
2688 rc = -EOPNOTSUPP;
2689 }
2690
2691 return rc;
2692 }
2693
2694 struct auth_body {
2695 __le16 alg;
2696 __le16 trans_seq;
2697 __le16 status;
2698 u8 el_id;
2699 u8 chall_text_len;
2700 u8 chall_text[253];
2701 };
2702
2703 static void atmel_enter_state(struct atmel_private *priv, int new_state)
2704 {
2705 int old_state = priv->station_state;
2706
2707 if (new_state == old_state)
2708 return;
2709
2710 priv->station_state = new_state;
2711
2712 if (new_state == STATION_STATE_READY) {
2713 netif_start_queue(priv->dev);
2714 netif_carrier_on(priv->dev);
2715 }
2716
2717 if (old_state == STATION_STATE_READY) {
2718 netif_carrier_off(priv->dev);
2719 if (netif_running(priv->dev))
2720 netif_stop_queue(priv->dev);
2721 priv->last_beacon_timestamp = 0;
2722 }
2723 }
2724
2725 static void atmel_scan(struct atmel_private *priv, int specific_ssid)
2726 {
2727 struct {
2728 u8 BSSID[ETH_ALEN];
2729 u8 SSID[MAX_SSID_LENGTH];
2730 u8 scan_type;
2731 u8 channel;
2732 __le16 BSS_type;
2733 __le16 min_channel_time;
2734 __le16 max_channel_time;
2735 u8 options;
2736 u8 SSID_size;
2737 } cmd;
2738
2739 eth_broadcast_addr(cmd.BSSID);
2740
2741 if (priv->fast_scan) {
2742 cmd.SSID_size = priv->SSID_size;
2743 memcpy(cmd.SSID, priv->SSID, priv->SSID_size);
2744 cmd.min_channel_time = cpu_to_le16(10);
2745 cmd.max_channel_time = cpu_to_le16(50);
2746 } else {
2747 priv->BSS_list_entries = 0;
2748 cmd.SSID_size = 0;
2749 cmd.min_channel_time = cpu_to_le16(10);
2750 cmd.max_channel_time = cpu_to_le16(120);
2751 }
2752
2753 cmd.options = 0;
2754
2755 if (!specific_ssid)
2756 cmd.options |= SCAN_OPTIONS_SITE_SURVEY;
2757
2758 cmd.channel = (priv->channel & 0x7f);
2759 cmd.scan_type = SCAN_TYPE_ACTIVE;
2760 cmd.BSS_type = cpu_to_le16(priv->operating_mode == IW_MODE_ADHOC ?
2761 BSS_TYPE_AD_HOC : BSS_TYPE_INFRASTRUCTURE);
2762
2763 atmel_send_command(priv, CMD_Scan, &cmd, sizeof(cmd));
2764
2765 /* This must come after all hardware access to avoid being messed up
2766 by stuff happening in interrupt context after we leave STATE_DOWN */
2767 atmel_enter_state(priv, STATION_STATE_SCANNING);
2768 }
2769
2770 static void join(struct atmel_private *priv, int type)
2771 {
2772 struct {
2773 u8 BSSID[6];
2774 u8 SSID[MAX_SSID_LENGTH];
2775 u8 BSS_type; /* this is a short in a scan command - weird */
2776 u8 channel;
2777 __le16 timeout;
2778 u8 SSID_size;
2779 u8 reserved;
2780 } cmd;
2781
2782 cmd.SSID_size = priv->SSID_size;
2783 memcpy(cmd.SSID, priv->SSID, priv->SSID_size);
2784 memcpy(cmd.BSSID, priv->CurrentBSSID, ETH_ALEN);
2785 cmd.channel = (priv->channel & 0x7f);
2786 cmd.BSS_type = type;
2787 cmd.timeout = cpu_to_le16(2000);
2788
2789 atmel_send_command(priv, CMD_Join, &cmd, sizeof(cmd));
2790 }
2791
2792 static void start(struct atmel_private *priv, int type)
2793 {
2794 struct {
2795 u8 BSSID[6];
2796 u8 SSID[MAX_SSID_LENGTH];
2797 u8 BSS_type;
2798 u8 channel;
2799 u8 SSID_size;
2800 u8 reserved[3];
2801 } cmd;
2802
2803 cmd.SSID_size = priv->SSID_size;
2804 memcpy(cmd.SSID, priv->SSID, priv->SSID_size);
2805 memcpy(cmd.BSSID, priv->BSSID, ETH_ALEN);
2806 cmd.BSS_type = type;
2807 cmd.channel = (priv->channel & 0x7f);
2808
2809 atmel_send_command(priv, CMD_Start, &cmd, sizeof(cmd));
2810 }
2811
2812 static void handle_beacon_probe(struct atmel_private *priv, u16 capability,
2813 u8 channel)
2814 {
2815 int rejoin = 0;
2816 int new = capability & WLAN_CAPABILITY_SHORT_PREAMBLE ?
2817 SHORT_PREAMBLE : LONG_PREAMBLE;
2818
2819 if (priv->preamble != new) {
2820 priv->preamble = new;
2821 rejoin = 1;
2822 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_PREAMBLE_TYPE, new);
2823 }
2824
2825 if (priv->channel != channel) {
2826 priv->channel = channel;
2827 rejoin = 1;
2828 atmel_set_mib8(priv, Phy_Mib_Type, PHY_MIB_CHANNEL_POS, channel);
2829 }
2830
2831 if (rejoin) {
2832 priv->station_is_associated = 0;
2833 atmel_enter_state(priv, STATION_STATE_JOINNING);
2834
2835 if (priv->operating_mode == IW_MODE_INFRA)
2836 join(priv, BSS_TYPE_INFRASTRUCTURE);
2837 else
2838 join(priv, BSS_TYPE_AD_HOC);
2839 }
2840 }
2841
2842 static void send_authentication_request(struct atmel_private *priv, u16 system,
2843 u8 *challenge, int challenge_len)
2844 {
2845 struct ieee80211_hdr header;
2846 struct auth_body auth;
2847
2848 header.frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_AUTH);
2849 header.duration_id = cpu_to_le16(0x8000);
2850 header.seq_ctrl = 0;
2851 memcpy(header.addr1, priv->CurrentBSSID, ETH_ALEN);
2852 memcpy(header.addr2, priv->dev->dev_addr, ETH_ALEN);
2853 memcpy(header.addr3, priv->CurrentBSSID, ETH_ALEN);
2854
2855 if (priv->wep_is_on && priv->CurrentAuthentTransactionSeqNum != 1)
2856 /* no WEP for authentication frames with TrSeqNo 1 */
2857 header.frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
2858
2859 auth.alg = cpu_to_le16(system);
2860
2861 auth.status = 0;
2862 auth.trans_seq = cpu_to_le16(priv->CurrentAuthentTransactionSeqNum);
2863 priv->ExpectedAuthentTransactionSeqNum = priv->CurrentAuthentTransactionSeqNum+1;
2864 priv->CurrentAuthentTransactionSeqNum += 2;
2865
2866 if (challenge_len != 0) {
2867 auth.el_id = 16; /* challenge_text */
2868 auth.chall_text_len = challenge_len;
2869 memcpy(auth.chall_text, challenge, challenge_len);
2870 atmel_transmit_management_frame(priv, &header, (u8 *)&auth, 8 + challenge_len);
2871 } else {
2872 atmel_transmit_management_frame(priv, &header, (u8 *)&auth, 6);
2873 }
2874 }
2875
2876 static void send_association_request(struct atmel_private *priv, int is_reassoc)
2877 {
2878 u8 *ssid_el_p;
2879 int bodysize;
2880 struct ieee80211_hdr header;
2881 struct ass_req_format {
2882 __le16 capability;
2883 __le16 listen_interval;
2884 u8 ap[ETH_ALEN]; /* nothing after here directly accessible */
2885 u8 ssid_el_id;
2886 u8 ssid_len;
2887 u8 ssid[MAX_SSID_LENGTH];
2888 u8 sup_rates_el_id;
2889 u8 sup_rates_len;
2890 u8 rates[4];
2891 } body;
2892
2893 header.frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2894 (is_reassoc ? IEEE80211_STYPE_REASSOC_REQ : IEEE80211_STYPE_ASSOC_REQ));
2895 header.duration_id = cpu_to_le16(0x8000);
2896 header.seq_ctrl = 0;
2897
2898 memcpy(header.addr1, priv->CurrentBSSID, ETH_ALEN);
2899 memcpy(header.addr2, priv->dev->dev_addr, ETH_ALEN);
2900 memcpy(header.addr3, priv->CurrentBSSID, ETH_ALEN);
2901
2902 body.capability = cpu_to_le16(WLAN_CAPABILITY_ESS);
2903 if (priv->wep_is_on)
2904 body.capability |= cpu_to_le16(WLAN_CAPABILITY_PRIVACY);
2905 if (priv->preamble == SHORT_PREAMBLE)
2906 body.capability |= cpu_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE);
2907
2908 body.listen_interval = cpu_to_le16(priv->listen_interval * priv->beacon_period);
2909
2910 /* current AP address - only in reassoc frame */
2911 if (is_reassoc) {
2912 memcpy(body.ap, priv->CurrentBSSID, ETH_ALEN);
2913 ssid_el_p = &body.ssid_el_id;
2914 bodysize = 18 + priv->SSID_size;
2915 } else {
2916 ssid_el_p = &body.ap[0];
2917 bodysize = 12 + priv->SSID_size;
2918 }
2919
2920 ssid_el_p[0] = WLAN_EID_SSID;
2921 ssid_el_p[1] = priv->SSID_size;
2922 memcpy(ssid_el_p + 2, priv->SSID, priv->SSID_size);
2923 ssid_el_p[2 + priv->SSID_size] = WLAN_EID_SUPP_RATES;
2924 ssid_el_p[3 + priv->SSID_size] = 4; /* len of supported rates */
2925 memcpy(ssid_el_p + 4 + priv->SSID_size, atmel_basic_rates, 4);
2926
2927 atmel_transmit_management_frame(priv, &header, (void *)&body, bodysize);
2928 }
2929
2930 static int is_frame_from_current_bss(struct atmel_private *priv,
2931 struct ieee80211_hdr *header)
2932 {
2933 if (le16_to_cpu(header->frame_control) & IEEE80211_FCTL_FROMDS)
2934 return memcmp(header->addr3, priv->CurrentBSSID, 6) == 0;
2935 else
2936 return memcmp(header->addr2, priv->CurrentBSSID, 6) == 0;
2937 }
2938
2939 static int retrieve_bss(struct atmel_private *priv)
2940 {
2941 int i;
2942 int max_rssi = -128;
2943 int max_index = -1;
2944
2945 if (priv->BSS_list_entries == 0)
2946 return -1;
2947
2948 if (priv->connect_to_any_BSS) {
2949 /* Select a BSS with the max-RSSI but of the same type and of
2950 the same WEP mode and that it is not marked as 'bad' (i.e.
2951 we had previously failed to connect to this BSS with the
2952 settings that we currently use) */
2953 priv->current_BSS = 0;
2954 for (i = 0; i < priv->BSS_list_entries; i++) {
2955 if (priv->operating_mode == priv->BSSinfo[i].BSStype &&
2956 ((!priv->wep_is_on && !priv->BSSinfo[i].UsingWEP) ||
2957 (priv->wep_is_on && priv->BSSinfo[i].UsingWEP)) &&
2958 !(priv->BSSinfo[i].channel & 0x80)) {
2959 max_rssi = priv->BSSinfo[i].RSSI;
2960 priv->current_BSS = max_index = i;
2961 }
2962 }
2963 return max_index;
2964 }
2965
2966 for (i = 0; i < priv->BSS_list_entries; i++) {
2967 if (priv->SSID_size == priv->BSSinfo[i].SSIDsize &&
2968 memcmp(priv->SSID, priv->BSSinfo[i].SSID, priv->SSID_size) == 0 &&
2969 priv->operating_mode == priv->BSSinfo[i].BSStype &&
2970 atmel_validate_channel(priv, priv->BSSinfo[i].channel) == 0) {
2971 if (priv->BSSinfo[i].RSSI >= max_rssi) {
2972 max_rssi = priv->BSSinfo[i].RSSI;
2973 max_index = i;
2974 }
2975 }
2976 }
2977 return max_index;
2978 }
2979
2980 static void store_bss_info(struct atmel_private *priv,
2981 struct ieee80211_hdr *header, u16 capability,
2982 u16 beacon_period, u8 channel, u8 rssi, u8 ssid_len,
2983 u8 *ssid, int is_beacon)
2984 {
2985 u8 *bss = capability & WLAN_CAPABILITY_ESS ? header->addr2 : header->addr3;
2986 int i, index;
2987
2988 for (index = -1, i = 0; i < priv->BSS_list_entries; i++)
2989 if (memcmp(bss, priv->BSSinfo[i].BSSID, ETH_ALEN) == 0)
2990 index = i;
2991
2992 /* If we process a probe and an entry from this BSS exists
2993 we will update the BSS entry with the info from this BSS.
2994 If we process a beacon we will only update RSSI */
2995
2996 if (index == -1) {
2997 if (priv->BSS_list_entries == MAX_BSS_ENTRIES)
2998 return;
2999 index = priv->BSS_list_entries++;
3000 memcpy(priv->BSSinfo[index].BSSID, bss, ETH_ALEN);
3001 priv->BSSinfo[index].RSSI = rssi;
3002 } else {
3003 if (rssi > priv->BSSinfo[index].RSSI)
3004 priv->BSSinfo[index].RSSI = rssi;
3005 if (is_beacon)
3006 return;
3007 }
3008
3009 priv->BSSinfo[index].channel = channel;
3010 priv->BSSinfo[index].beacon_period = beacon_period;
3011 priv->BSSinfo[index].UsingWEP = capability & WLAN_CAPABILITY_PRIVACY;
3012 memcpy(priv->BSSinfo[index].SSID, ssid, ssid_len);
3013 priv->BSSinfo[index].SSIDsize = ssid_len;
3014
3015 if (capability & WLAN_CAPABILITY_IBSS)
3016 priv->BSSinfo[index].BSStype = IW_MODE_ADHOC;
3017 else if (capability & WLAN_CAPABILITY_ESS)
3018 priv->BSSinfo[index].BSStype = IW_MODE_INFRA;
3019
3020 priv->BSSinfo[index].preamble = capability & WLAN_CAPABILITY_SHORT_PREAMBLE ?
3021 SHORT_PREAMBLE : LONG_PREAMBLE;
3022 }
3023
3024 static void authenticate(struct atmel_private *priv, u16 frame_len)
3025 {
3026 struct auth_body *auth = (struct auth_body *)priv->rx_buf;
3027 u16 status = le16_to_cpu(auth->status);
3028 u16 trans_seq_no = le16_to_cpu(auth->trans_seq);
3029 u16 system = le16_to_cpu(auth->alg);
3030
3031 if (status == WLAN_STATUS_SUCCESS && !priv->wep_is_on) {
3032 /* no WEP */
3033 if (priv->station_was_associated) {
3034 atmel_enter_state(priv, STATION_STATE_REASSOCIATING);
3035 send_association_request(priv, 1);
3036 return;
3037 } else {
3038 atmel_enter_state(priv, STATION_STATE_ASSOCIATING);
3039 send_association_request(priv, 0);
3040 return;
3041 }
3042 }
3043
3044 if (status == WLAN_STATUS_SUCCESS && priv->wep_is_on) {
3045 int should_associate = 0;
3046 /* WEP */
3047 if (trans_seq_no != priv->ExpectedAuthentTransactionSeqNum)
3048 return;
3049
3050 if (system == WLAN_AUTH_OPEN) {
3051 if (trans_seq_no == 0x0002) {
3052 should_associate = 1;
3053 }
3054 } else if (system == WLAN_AUTH_SHARED_KEY) {
3055 if (trans_seq_no == 0x0002 &&
3056 auth->el_id == WLAN_EID_CHALLENGE) {
3057 send_authentication_request(priv, system, auth->chall_text, auth->chall_text_len);
3058 return;
3059 } else if (trans_seq_no == 0x0004) {
3060 should_associate = 1;
3061 }
3062 }
3063
3064 if (should_associate) {
3065 if (priv->station_was_associated) {
3066 atmel_enter_state(priv, STATION_STATE_REASSOCIATING);
3067 send_association_request(priv, 1);
3068 return;
3069 } else {
3070 atmel_enter_state(priv, STATION_STATE_ASSOCIATING);
3071 send_association_request(priv, 0);
3072 return;
3073 }
3074 }
3075 }
3076
3077 if (status == WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG) {
3078 /* Flip back and forth between WEP auth modes until the max
3079 * authentication tries has been exceeded.
3080 */
3081 if (system == WLAN_AUTH_OPEN) {
3082 priv->CurrentAuthentTransactionSeqNum = 0x001;
3083 priv->exclude_unencrypted = 1;
3084 send_authentication_request(priv, WLAN_AUTH_SHARED_KEY, NULL, 0);
3085 return;
3086 } else if (system == WLAN_AUTH_SHARED_KEY
3087 && priv->wep_is_on) {
3088 priv->CurrentAuthentTransactionSeqNum = 0x001;
3089 priv->exclude_unencrypted = 0;
3090 send_authentication_request(priv, WLAN_AUTH_OPEN, NULL, 0);
3091 return;
3092 } else if (priv->connect_to_any_BSS) {
3093 int bss_index;
3094
3095 priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80;
3096
3097 if ((bss_index = retrieve_bss(priv)) != -1) {
3098 atmel_join_bss(priv, bss_index);
3099 return;
3100 }
3101 }
3102 }
3103
3104 priv->AuthenticationRequestRetryCnt = 0;
3105 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3106 priv->station_is_associated = 0;
3107 }
3108
3109 static void associate(struct atmel_private *priv, u16 frame_len, u16 subtype)
3110 {
3111 struct ass_resp_format {
3112 __le16 capability;
3113 __le16 status;
3114 __le16 ass_id;
3115 u8 el_id;
3116 u8 length;
3117 u8 rates[4];
3118 } *ass_resp = (struct ass_resp_format *)priv->rx_buf;
3119
3120 u16 status = le16_to_cpu(ass_resp->status);
3121 u16 ass_id = le16_to_cpu(ass_resp->ass_id);
3122 u16 rates_len = ass_resp->length > 4 ? 4 : ass_resp->length;
3123
3124 union iwreq_data wrqu;
3125
3126 if (frame_len < 8 + rates_len)
3127 return;
3128
3129 if (status == WLAN_STATUS_SUCCESS) {
3130 if (subtype == IEEE80211_STYPE_ASSOC_RESP)
3131 priv->AssociationRequestRetryCnt = 0;
3132 else
3133 priv->ReAssociationRequestRetryCnt = 0;
3134
3135 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type,
3136 MAC_MGMT_MIB_STATION_ID_POS, ass_id & 0x3fff);
3137 atmel_set_mib(priv, Phy_Mib_Type,
3138 PHY_MIB_RATE_SET_POS, ass_resp->rates, rates_len);
3139 if (priv->power_mode == 0) {
3140 priv->listen_interval = 1;
3141 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type,
3142 MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE);
3143 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type,
3144 MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1);
3145 } else {
3146 priv->listen_interval = 2;
3147 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type,
3148 MAC_MGMT_MIB_PS_MODE_POS, PS_MODE);
3149 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type,
3150 MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 2);
3151 }
3152
3153 priv->station_is_associated = 1;
3154 priv->station_was_associated = 1;
3155 atmel_enter_state(priv, STATION_STATE_READY);
3156
3157 /* Send association event to userspace */
3158 wrqu.data.length = 0;
3159 wrqu.data.flags = 0;
3160 memcpy(wrqu.ap_addr.sa_data, priv->CurrentBSSID, ETH_ALEN);
3161 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
3162 wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
3163
3164 return;
3165 }
3166
3167 if (subtype == IEEE80211_STYPE_ASSOC_RESP &&
3168 status != WLAN_STATUS_ASSOC_DENIED_RATES &&
3169 status != WLAN_STATUS_CAPS_UNSUPPORTED &&
3170 priv->AssociationRequestRetryCnt < MAX_ASSOCIATION_RETRIES) {
3171 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3172 priv->AssociationRequestRetryCnt++;
3173 send_association_request(priv, 0);
3174 return;
3175 }
3176
3177 if (subtype == IEEE80211_STYPE_REASSOC_RESP &&
3178 status != WLAN_STATUS_ASSOC_DENIED_RATES &&
3179 status != WLAN_STATUS_CAPS_UNSUPPORTED &&
3180 priv->ReAssociationRequestRetryCnt < MAX_ASSOCIATION_RETRIES) {
3181 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3182 priv->ReAssociationRequestRetryCnt++;
3183 send_association_request(priv, 1);
3184 return;
3185 }
3186
3187 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3188 priv->station_is_associated = 0;
3189
3190 if (priv->connect_to_any_BSS) {
3191 int bss_index;
3192 priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80;
3193
3194 if ((bss_index = retrieve_bss(priv)) != -1)
3195 atmel_join_bss(priv, bss_index);
3196 }
3197 }
3198
3199 static void atmel_join_bss(struct atmel_private *priv, int bss_index)
3200 {
3201 struct bss_info *bss = &priv->BSSinfo[bss_index];
3202
3203 memcpy(priv->CurrentBSSID, bss->BSSID, ETH_ALEN);
3204 memcpy(priv->SSID, bss->SSID, priv->SSID_size = bss->SSIDsize);
3205
3206 /* The WPA stuff cares about the current AP address */
3207 if (priv->use_wpa)
3208 build_wpa_mib(priv);
3209
3210 /* When switching to AdHoc turn OFF Power Save if needed */
3211
3212 if (bss->BSStype == IW_MODE_ADHOC &&
3213 priv->operating_mode != IW_MODE_ADHOC &&
3214 priv->power_mode) {
3215 priv->power_mode = 0;
3216 priv->listen_interval = 1;
3217 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type,
3218 MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE);
3219 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type,
3220 MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1);
3221 }
3222
3223 priv->operating_mode = bss->BSStype;
3224 priv->channel = bss->channel & 0x7f;
3225 priv->beacon_period = bss->beacon_period;
3226
3227 if (priv->preamble != bss->preamble) {
3228 priv->preamble = bss->preamble;
3229 atmel_set_mib8(priv, Local_Mib_Type,
3230 LOCAL_MIB_PREAMBLE_TYPE, bss->preamble);
3231 }
3232
3233 if (!priv->wep_is_on && bss->UsingWEP) {
3234 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3235 priv->station_is_associated = 0;
3236 return;
3237 }
3238
3239 if (priv->wep_is_on && !bss->UsingWEP) {
3240 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3241 priv->station_is_associated = 0;
3242 return;
3243 }
3244
3245 atmel_enter_state(priv, STATION_STATE_JOINNING);
3246
3247 if (priv->operating_mode == IW_MODE_INFRA)
3248 join(priv, BSS_TYPE_INFRASTRUCTURE);
3249 else
3250 join(priv, BSS_TYPE_AD_HOC);
3251 }
3252
3253 static void restart_search(struct atmel_private *priv)
3254 {
3255 int bss_index;
3256
3257 if (!priv->connect_to_any_BSS) {
3258 atmel_scan(priv, 1);
3259 } else {
3260 priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80;
3261
3262 if ((bss_index = retrieve_bss(priv)) != -1)
3263 atmel_join_bss(priv, bss_index);
3264 else
3265 atmel_scan(priv, 0);
3266 }
3267 }
3268
3269 static void smooth_rssi(struct atmel_private *priv, u8 rssi)
3270 {
3271 u8 old = priv->wstats.qual.level;
3272 u8 max_rssi = 42; /* 502-rmfd-revd max by experiment, default for now */
3273
3274 switch (priv->firmware_type) {
3275 case ATMEL_FW_TYPE_502E:
3276 max_rssi = 63; /* 502-rmfd-reve max by experiment */
3277 break;
3278 default:
3279 break;
3280 }
3281
3282 rssi = rssi * 100 / max_rssi;
3283 if ((rssi + old) % 2)
3284 priv->wstats.qual.level = (rssi + old) / 2 + 1;
3285 else
3286 priv->wstats.qual.level = (rssi + old) / 2;
3287 priv->wstats.qual.updated |= IW_QUAL_LEVEL_UPDATED;
3288 priv->wstats.qual.updated &= ~IW_QUAL_LEVEL_INVALID;
3289 }
3290
3291 static void atmel_smooth_qual(struct atmel_private *priv)
3292 {
3293 unsigned long time_diff = (jiffies - priv->last_qual) / HZ;
3294 while (time_diff--) {
3295 priv->last_qual += HZ;
3296 priv->wstats.qual.qual = priv->wstats.qual.qual / 2;
3297 priv->wstats.qual.qual +=
3298 priv->beacons_this_sec * priv->beacon_period * (priv->wstats.qual.level + 100) / 4000;
3299 priv->beacons_this_sec = 0;
3300 }
3301 priv->wstats.qual.updated |= IW_QUAL_QUAL_UPDATED;
3302 priv->wstats.qual.updated &= ~IW_QUAL_QUAL_INVALID;
3303 }
3304
3305 /* deals with incoming management frames. */
3306 static void atmel_management_frame(struct atmel_private *priv,
3307 struct ieee80211_hdr *header,
3308 u16 frame_len, u8 rssi)
3309 {
3310 u16 subtype;
3311
3312 subtype = le16_to_cpu(header->frame_control) & IEEE80211_FCTL_STYPE;
3313 switch (subtype) {
3314 case IEEE80211_STYPE_BEACON:
3315 case IEEE80211_STYPE_PROBE_RESP:
3316
3317 /* beacon frame has multiple variable-length fields -
3318 never let an engineer loose with a data structure design. */
3319 {
3320 struct beacon_format {
3321 __le64 timestamp;
3322 __le16 interval;
3323 __le16 capability;
3324 u8 ssid_el_id;
3325 u8 ssid_length;
3326 /* ssid here */
3327 u8 rates_el_id;
3328 u8 rates_length;
3329 /* rates here */
3330 u8 ds_el_id;
3331 u8 ds_length;
3332 /* ds here */
3333 } *beacon = (struct beacon_format *)priv->rx_buf;
3334
3335 u8 channel, rates_length, ssid_length;
3336 u64 timestamp = le64_to_cpu(beacon->timestamp);
3337 u16 beacon_interval = le16_to_cpu(beacon->interval);
3338 u16 capability = le16_to_cpu(beacon->capability);
3339 u8 *beaconp = priv->rx_buf;
3340 ssid_length = beacon->ssid_length;
3341 /* this blows chunks. */
3342 if (frame_len < 14 || frame_len < ssid_length + 15)
3343 return;
3344 rates_length = beaconp[beacon->ssid_length + 15];
3345 if (frame_len < ssid_length + rates_length + 18)
3346 return;
3347 if (ssid_length > MAX_SSID_LENGTH)
3348 return;
3349 channel = beaconp[ssid_length + rates_length + 18];
3350
3351 if (priv->station_state == STATION_STATE_READY) {
3352 smooth_rssi(priv, rssi);
3353 if (is_frame_from_current_bss(priv, header)) {
3354 priv->beacons_this_sec++;
3355 atmel_smooth_qual(priv);
3356 if (priv->last_beacon_timestamp) {
3357 /* Note truncate this to 32 bits - kernel can't divide a long long */
3358 u32 beacon_delay = timestamp - priv->last_beacon_timestamp;
3359 int beacons = beacon_delay / (beacon_interval * 1000);
3360 if (beacons > 1)
3361 priv->wstats.miss.beacon += beacons - 1;
3362 }
3363 priv->last_beacon_timestamp = timestamp;
3364 handle_beacon_probe(priv, capability, channel);
3365 }
3366 }
3367
3368 if (priv->station_state == STATION_STATE_SCANNING)
3369 store_bss_info(priv, header, capability,
3370 beacon_interval, channel, rssi,
3371 ssid_length,
3372 &beacon->rates_el_id,
3373 subtype == IEEE80211_STYPE_BEACON);
3374 }
3375 break;
3376
3377 case IEEE80211_STYPE_AUTH:
3378
3379 if (priv->station_state == STATION_STATE_AUTHENTICATING)
3380 authenticate(priv, frame_len);
3381
3382 break;
3383
3384 case IEEE80211_STYPE_ASSOC_RESP:
3385 case IEEE80211_STYPE_REASSOC_RESP:
3386
3387 if (priv->station_state == STATION_STATE_ASSOCIATING ||
3388 priv->station_state == STATION_STATE_REASSOCIATING)
3389 associate(priv, frame_len, subtype);
3390
3391 break;
3392
3393 case IEEE80211_STYPE_DISASSOC:
3394 if (priv->station_is_associated &&
3395 priv->operating_mode == IW_MODE_INFRA &&
3396 is_frame_from_current_bss(priv, header)) {
3397 priv->station_was_associated = 0;
3398 priv->station_is_associated = 0;
3399
3400 atmel_enter_state(priv, STATION_STATE_JOINNING);
3401 join(priv, BSS_TYPE_INFRASTRUCTURE);
3402 }
3403
3404 break;
3405
3406 case IEEE80211_STYPE_DEAUTH:
3407 if (priv->operating_mode == IW_MODE_INFRA &&
3408 is_frame_from_current_bss(priv, header)) {
3409 priv->station_was_associated = 0;
3410
3411 atmel_enter_state(priv, STATION_STATE_JOINNING);
3412 join(priv, BSS_TYPE_INFRASTRUCTURE);
3413 }
3414
3415 break;
3416 }
3417 }
3418
3419 /* run when timer expires */
3420 static void atmel_management_timer(struct timer_list *t)
3421 {
3422 struct atmel_private *priv = from_timer(priv, t, management_timer);
3423 unsigned long flags;
3424
3425 /* Check if the card has been yanked. */
3426 if (priv->card && priv->present_callback &&
3427 !(*priv->present_callback)(priv->card))
3428 return;
3429
3430 spin_lock_irqsave(&priv->irqlock, flags);
3431
3432 switch (priv->station_state) {
3433
3434 case STATION_STATE_AUTHENTICATING:
3435 if (priv->AuthenticationRequestRetryCnt >= MAX_AUTHENTICATION_RETRIES) {
3436 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3437 priv->station_is_associated = 0;
3438 priv->AuthenticationRequestRetryCnt = 0;
3439 restart_search(priv);
3440 } else {
3441 int auth = WLAN_AUTH_OPEN;
3442 priv->AuthenticationRequestRetryCnt++;
3443 priv->CurrentAuthentTransactionSeqNum = 0x0001;
3444 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3445 if (priv->wep_is_on && priv->exclude_unencrypted)
3446 auth = WLAN_AUTH_SHARED_KEY;
3447 send_authentication_request(priv, auth, NULL, 0);
3448 }
3449 break;
3450
3451 case STATION_STATE_ASSOCIATING:
3452 if (priv->AssociationRequestRetryCnt == MAX_ASSOCIATION_RETRIES) {
3453 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3454 priv->station_is_associated = 0;
3455 priv->AssociationRequestRetryCnt = 0;
3456 restart_search(priv);
3457 } else {
3458 priv->AssociationRequestRetryCnt++;
3459 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3460 send_association_request(priv, 0);
3461 }
3462 break;
3463
3464 case STATION_STATE_REASSOCIATING:
3465 if (priv->ReAssociationRequestRetryCnt == MAX_ASSOCIATION_RETRIES) {
3466 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3467 priv->station_is_associated = 0;
3468 priv->ReAssociationRequestRetryCnt = 0;
3469 restart_search(priv);
3470 } else {
3471 priv->ReAssociationRequestRetryCnt++;
3472 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3473 send_association_request(priv, 1);
3474 }
3475 break;
3476
3477 default:
3478 break;
3479 }
3480
3481 spin_unlock_irqrestore(&priv->irqlock, flags);
3482 }
3483
3484 static void atmel_command_irq(struct atmel_private *priv)
3485 {
3486 u8 status = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET));
3487 u8 command = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_COMMAND_OFFSET));
3488 int fast_scan;
3489 union iwreq_data wrqu;
3490
3491 if (status == CMD_STATUS_IDLE ||
3492 status == CMD_STATUS_IN_PROGRESS)
3493 return;
3494
3495 switch (command) {
3496 case CMD_Start:
3497 if (status == CMD_STATUS_COMPLETE) {
3498 priv->station_was_associated = priv->station_is_associated;
3499 atmel_get_mib(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_CUR_BSSID_POS,
3500 (u8 *)priv->CurrentBSSID, 6);
3501 atmel_enter_state(priv, STATION_STATE_READY);
3502 }
3503 break;
3504
3505 case CMD_Scan:
3506 fast_scan = priv->fast_scan;
3507 priv->fast_scan = 0;
3508
3509 if (status != CMD_STATUS_COMPLETE) {
3510 atmel_scan(priv, 1);
3511 } else {
3512 int bss_index = retrieve_bss(priv);
3513 int notify_scan_complete = 1;
3514 if (bss_index != -1) {
3515 atmel_join_bss(priv, bss_index);
3516 } else if (priv->operating_mode == IW_MODE_ADHOC &&
3517 priv->SSID_size != 0) {
3518 start(priv, BSS_TYPE_AD_HOC);
3519 } else {
3520 priv->fast_scan = !fast_scan;
3521 atmel_scan(priv, 1);
3522 notify_scan_complete = 0;
3523 }
3524 priv->site_survey_state = SITE_SURVEY_COMPLETED;
3525 if (notify_scan_complete) {
3526 wrqu.data.length = 0;
3527 wrqu.data.flags = 0;
3528 wireless_send_event(priv->dev, SIOCGIWSCAN, &wrqu, NULL);
3529 }
3530 }
3531 break;
3532
3533 case CMD_SiteSurvey:
3534 priv->fast_scan = 0;
3535
3536 if (status != CMD_STATUS_COMPLETE)
3537 return;
3538
3539 priv->site_survey_state = SITE_SURVEY_COMPLETED;
3540 if (priv->station_is_associated) {
3541 atmel_enter_state(priv, STATION_STATE_READY);
3542 wrqu.data.length = 0;
3543 wrqu.data.flags = 0;
3544 wireless_send_event(priv->dev, SIOCGIWSCAN, &wrqu, NULL);
3545 } else {
3546 atmel_scan(priv, 1);
3547 }
3548 break;
3549
3550 case CMD_Join:
3551 if (status == CMD_STATUS_COMPLETE) {
3552 if (priv->operating_mode == IW_MODE_ADHOC) {
3553 priv->station_was_associated = priv->station_is_associated;
3554 atmel_enter_state(priv, STATION_STATE_READY);
3555 } else {
3556 int auth = WLAN_AUTH_OPEN;
3557 priv->AuthenticationRequestRetryCnt = 0;
3558 atmel_enter_state(priv, STATION_STATE_AUTHENTICATING);
3559
3560 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3561 priv->CurrentAuthentTransactionSeqNum = 0x0001;
3562 if (priv->wep_is_on && priv->exclude_unencrypted)
3563 auth = WLAN_AUTH_SHARED_KEY;
3564 send_authentication_request(priv, auth, NULL, 0);
3565 }
3566 return;
3567 }
3568
3569 atmel_scan(priv, 1);
3570 }
3571 }
3572
3573 static int atmel_wakeup_firmware(struct atmel_private *priv)
3574 {
3575 struct host_info_struct *iface = &priv->host_info;
3576 u16 mr1, mr3;
3577 int i;
3578
3579 if (priv->card_type == CARD_TYPE_SPI_FLASH)
3580 atmel_set_gcr(priv->dev, GCR_REMAP);
3581
3582 /* wake up on-board processor */
3583 atmel_clear_gcr(priv->dev, 0x0040);
3584 atmel_write16(priv->dev, BSR, BSS_SRAM);
3585
3586 if (priv->card_type == CARD_TYPE_SPI_FLASH)
3587 mdelay(100);
3588
3589 /* and wait for it */
3590 for (i = LOOP_RETRY_LIMIT; i; i--) {
3591 mr1 = atmel_read16(priv->dev, MR1);
3592 mr3 = atmel_read16(priv->dev, MR3);
3593
3594 if (mr3 & MAC_BOOT_COMPLETE)
3595 break;
3596 if (mr1 & MAC_BOOT_COMPLETE &&
3597 priv->bus_type == BUS_TYPE_PCCARD)
3598 break;
3599 }
3600
3601 if (i == 0) {
3602 printk(KERN_ALERT "%s: MAC failed to boot.\n", priv->dev->name);
3603 return -EIO;
3604 }
3605
3606 if ((priv->host_info_base = atmel_read16(priv->dev, MR2)) == 0xffff) {
3607 printk(KERN_ALERT "%s: card missing.\n", priv->dev->name);
3608 return -ENODEV;
3609 }
3610
3611 /* now check for completion of MAC initialization through
3612 the FunCtrl field of the IFACE, poll MR1 to detect completion of
3613 MAC initialization, check completion status, set interrupt mask,
3614 enables interrupts and calls Tx and Rx initialization functions */
3615
3616 atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET), FUNC_CTRL_INIT_COMPLETE);
3617
3618 for (i = LOOP_RETRY_LIMIT; i; i--) {
3619 mr1 = atmel_read16(priv->dev, MR1);
3620 mr3 = atmel_read16(priv->dev, MR3);
3621
3622 if (mr3 & MAC_INIT_COMPLETE)
3623 break;
3624 if (mr1 & MAC_INIT_COMPLETE &&
3625 priv->bus_type == BUS_TYPE_PCCARD)
3626 break;
3627 }
3628
3629 if (i == 0) {
3630 printk(KERN_ALERT "%s: MAC failed to initialise.\n",
3631 priv->dev->name);
3632 return -EIO;
3633 }
3634
3635 /* Check for MAC_INIT_OK only on the register that the MAC_INIT_OK was set */
3636 if ((mr3 & MAC_INIT_COMPLETE) &&
3637 !(atmel_read16(priv->dev, MR3) & MAC_INIT_OK)) {
3638 printk(KERN_ALERT "%s: MAC failed MR3 self-test.\n", priv->dev->name);
3639 return -EIO;
3640 }
3641 if ((mr1 & MAC_INIT_COMPLETE) &&
3642 !(atmel_read16(priv->dev, MR1) & MAC_INIT_OK)) {
3643 printk(KERN_ALERT "%s: MAC failed MR1 self-test.\n", priv->dev->name);
3644 return -EIO;
3645 }
3646
3647 atmel_copy_to_host(priv->dev, (unsigned char *)iface,
3648 priv->host_info_base, sizeof(*iface));
3649
3650 iface->tx_buff_pos = le16_to_cpu(iface->tx_buff_pos);
3651 iface->tx_buff_size = le16_to_cpu(iface->tx_buff_size);
3652 iface->tx_desc_pos = le16_to_cpu(iface->tx_desc_pos);
3653 iface->tx_desc_count = le16_to_cpu(iface->tx_desc_count);
3654 iface->rx_buff_pos = le16_to_cpu(iface->rx_buff_pos);
3655 iface->rx_buff_size = le16_to_cpu(iface->rx_buff_size);
3656 iface->rx_desc_pos = le16_to_cpu(iface->rx_desc_pos);
3657 iface->rx_desc_count = le16_to_cpu(iface->rx_desc_count);
3658 iface->build_version = le16_to_cpu(iface->build_version);
3659 iface->command_pos = le16_to_cpu(iface->command_pos);
3660 iface->major_version = le16_to_cpu(iface->major_version);
3661 iface->minor_version = le16_to_cpu(iface->minor_version);
3662 iface->func_ctrl = le16_to_cpu(iface->func_ctrl);
3663 iface->mac_status = le16_to_cpu(iface->mac_status);
3664
3665 return 0;
3666 }
3667
3668 /* determine type of memory and MAC address */
3669 static int probe_atmel_card(struct net_device *dev)
3670 {
3671 int rc = 0;
3672 struct atmel_private *priv = netdev_priv(dev);
3673
3674 /* reset pccard */
3675 if (priv->bus_type == BUS_TYPE_PCCARD)
3676 atmel_write16(dev, GCR, 0x0060);
3677
3678 atmel_write16(dev, GCR, 0x0040);
3679 msleep(500);
3680
3681 if (atmel_read16(dev, MR2) == 0) {
3682 /* No stored firmware so load a small stub which just
3683 tells us the MAC address */
3684 int i;
3685 priv->card_type = CARD_TYPE_EEPROM;
3686 atmel_write16(dev, BSR, BSS_IRAM);
3687 atmel_copy_to_card(dev, 0, mac_reader, sizeof(mac_reader));
3688 atmel_set_gcr(dev, GCR_REMAP);
3689 atmel_clear_gcr(priv->dev, 0x0040);
3690 atmel_write16(dev, BSR, BSS_SRAM);
3691 for (i = LOOP_RETRY_LIMIT; i; i--)
3692 if (atmel_read16(dev, MR3) & MAC_BOOT_COMPLETE)
3693 break;
3694 if (i == 0) {
3695 printk(KERN_ALERT "%s: MAC failed to boot MAC address reader.\n", dev->name);
3696 } else {
3697 atmel_copy_to_host(dev, dev->dev_addr, atmel_read16(dev, MR2), 6);
3698 /* got address, now squash it again until the network
3699 interface is opened */
3700 if (priv->bus_type == BUS_TYPE_PCCARD)
3701 atmel_write16(dev, GCR, 0x0060);
3702 atmel_write16(dev, GCR, 0x0040);
3703 rc = 1;
3704 }
3705 } else if (atmel_read16(dev, MR4) == 0) {
3706 /* Mac address easy in this case. */
3707 priv->card_type = CARD_TYPE_PARALLEL_FLASH;
3708 atmel_write16(dev, BSR, 1);
3709 atmel_copy_to_host(dev, dev->dev_addr, 0xc000, 6);
3710 atmel_write16(dev, BSR, 0x200);
3711 rc = 1;
3712 } else {
3713 /* Standard firmware in flash, boot it up and ask
3714 for the Mac Address */
3715 priv->card_type = CARD_TYPE_SPI_FLASH;
3716 if (atmel_wakeup_firmware(priv) == 0) {
3717 atmel_get_mib(priv, Mac_Address_Mib_Type, 0, dev->dev_addr, 6);
3718
3719 /* got address, now squash it again until the network
3720 interface is opened */
3721 if (priv->bus_type == BUS_TYPE_PCCARD)
3722 atmel_write16(dev, GCR, 0x0060);
3723 atmel_write16(dev, GCR, 0x0040);
3724 rc = 1;
3725 }
3726 }
3727
3728 if (rc) {
3729 if (dev->dev_addr[0] == 0xFF) {
3730 static const u8 default_mac[] = {
3731 0x00, 0x04, 0x25, 0x00, 0x00, 0x00
3732 };
3733 printk(KERN_ALERT "%s: *** Invalid MAC address. UPGRADE Firmware ****\n", dev->name);
3734 memcpy(dev->dev_addr, default_mac, ETH_ALEN);
3735 }
3736 }
3737
3738 return rc;
3739 }
3740
3741 /* Move the encyption information on the MIB structure.
3742 This routine is for the pre-WPA firmware: later firmware has
3743 a different format MIB and a different routine. */
3744 static void build_wep_mib(struct atmel_private *priv)
3745 {
3746 struct { /* NB this is matched to the hardware, don't change. */
3747 u8 wep_is_on;
3748 u8 default_key; /* 0..3 */
3749 u8 reserved;
3750 u8 exclude_unencrypted;
3751
3752 u32 WEPICV_error_count;
3753 u32 WEP_excluded_count;
3754
3755 u8 wep_keys[MAX_ENCRYPTION_KEYS][13];
3756 u8 encryption_level; /* 0, 1, 2 */
3757 u8 reserved2[3];
3758 } mib;
3759 int i;
3760
3761 mib.wep_is_on = priv->wep_is_on;
3762 if (priv->wep_is_on) {
3763 if (priv->wep_key_len[priv->default_key] > 5)
3764 mib.encryption_level = 2;
3765 else
3766 mib.encryption_level = 1;
3767 } else {
3768 mib.encryption_level = 0;
3769 }
3770
3771 mib.default_key = priv->default_key;
3772 mib.exclude_unencrypted = priv->exclude_unencrypted;
3773
3774 for (i = 0; i < MAX_ENCRYPTION_KEYS; i++)
3775 memcpy(mib.wep_keys[i], priv->wep_keys[i], 13);
3776
3777 atmel_set_mib(priv, Mac_Wep_Mib_Type, 0, (u8 *)&mib, sizeof(mib));
3778 }
3779
3780 static void build_wpa_mib(struct atmel_private *priv)
3781 {
3782 /* This is for the later (WPA enabled) firmware. */
3783
3784 struct { /* NB this is matched to the hardware, don't change. */
3785 u8 cipher_default_key_value[MAX_ENCRYPTION_KEYS][MAX_ENCRYPTION_KEY_SIZE];
3786 u8 receiver_address[ETH_ALEN];
3787 u8 wep_is_on;
3788 u8 default_key; /* 0..3 */
3789 u8 group_key;
3790 u8 exclude_unencrypted;
3791 u8 encryption_type;
3792 u8 reserved;
3793
3794 u32 WEPICV_error_count;
3795 u32 WEP_excluded_count;
3796
3797 u8 key_RSC[4][8];
3798 } mib;
3799
3800 int i;
3801
3802 mib.wep_is_on = priv->wep_is_on;
3803 mib.exclude_unencrypted = priv->exclude_unencrypted;
3804 memcpy(mib.receiver_address, priv->CurrentBSSID, ETH_ALEN);
3805
3806 /* zero all the keys before adding in valid ones. */
3807 memset(mib.cipher_default_key_value, 0, sizeof(mib.cipher_default_key_value));
3808
3809 if (priv->wep_is_on) {
3810 /* There's a comment in the Atmel code to the effect that this
3811 is only valid when still using WEP, it may need to be set to
3812 something to use WPA */
3813 memset(mib.key_RSC, 0, sizeof(mib.key_RSC));
3814
3815 mib.default_key = mib.group_key = 255;
3816 for (i = 0; i < MAX_ENCRYPTION_KEYS; i++) {
3817 if (priv->wep_key_len[i] > 0) {
3818 memcpy(mib.cipher_default_key_value[i], priv->wep_keys[i], MAX_ENCRYPTION_KEY_SIZE);
3819 if (i == priv->default_key) {
3820 mib.default_key = i;
3821 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-1] = 7;
3822 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-2] = priv->pairwise_cipher_suite;
3823 } else {
3824 mib.group_key = i;
3825 priv->group_cipher_suite = priv->pairwise_cipher_suite;
3826 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-1] = 1;
3827 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-2] = priv->group_cipher_suite;
3828 }
3829 }
3830 }
3831 if (mib.default_key == 255)
3832 mib.default_key = mib.group_key != 255 ? mib.group_key : 0;
3833 if (mib.group_key == 255)
3834 mib.group_key = mib.default_key;
3835
3836 }
3837
3838 atmel_set_mib(priv, Mac_Wep_Mib_Type, 0, (u8 *)&mib, sizeof(mib));
3839 }
3840
3841 static int reset_atmel_card(struct net_device *dev)
3842 {
3843 /* do everything necessary to wake up the hardware, including
3844 waiting for the lightning strike and throwing the knife switch....
3845
3846 set all the Mib values which matter in the card to match
3847 their settings in the atmel_private structure. Some of these
3848 can be altered on the fly, but many (WEP, infrastructure or ad-hoc)
3849 can only be changed by tearing down the world and coming back through
3850 here.
3851
3852 This routine is also responsible for initialising some
3853 hardware-specific fields in the atmel_private structure,
3854 including a copy of the firmware's hostinfo structure
3855 which is the route into the rest of the firmware datastructures. */
3856
3857 struct atmel_private *priv = netdev_priv(dev);
3858 u8 configuration;
3859 int old_state = priv->station_state;
3860 int err = 0;
3861
3862 /* data to add to the firmware names, in priority order
3863 this implemenents firmware versioning */
3864
3865 static char *firmware_modifier[] = {
3866 "-wpa",
3867 "",
3868 NULL
3869 };
3870
3871 /* reset pccard */
3872 if (priv->bus_type == BUS_TYPE_PCCARD)
3873 atmel_write16(priv->dev, GCR, 0x0060);
3874
3875 /* stop card , disable interrupts */
3876 atmel_write16(priv->dev, GCR, 0x0040);
3877
3878 if (priv->card_type == CARD_TYPE_EEPROM) {
3879 /* copy in firmware if needed */
3880 const struct firmware *fw_entry = NULL;
3881 const unsigned char *fw;
3882 int len = priv->firmware_length;
3883 if (!(fw = priv->firmware)) {
3884 if (priv->firmware_type == ATMEL_FW_TYPE_NONE) {
3885 if (strlen(priv->firmware_id) == 0) {
3886 printk(KERN_INFO
3887 "%s: card type is unknown: assuming at76c502 firmware is OK.\n",
3888 dev->name);
3889 printk(KERN_INFO
3890 "%s: if not, use the firmware= module parameter.\n",
3891 dev->name);
3892 strcpy(priv->firmware_id, "atmel_at76c502.bin");
3893 }
3894 err = request_firmware(&fw_entry, priv->firmware_id, priv->sys_dev);
3895 if (err != 0) {
3896 printk(KERN_ALERT
3897 "%s: firmware %s is missing, cannot continue.\n",
3898 dev->name, priv->firmware_id);
3899 return err;
3900 }
3901 } else {
3902 int fw_index = 0;
3903 int success = 0;
3904
3905 /* get firmware filename entry based on firmware type ID */
3906 while (fw_table[fw_index].fw_type != priv->firmware_type
3907 && fw_table[fw_index].fw_type != ATMEL_FW_TYPE_NONE)
3908 fw_index++;
3909
3910 /* construct the actual firmware file name */
3911 if (fw_table[fw_index].fw_type != ATMEL_FW_TYPE_NONE) {
3912 int i;
3913 for (i = 0; firmware_modifier[i]; i++) {
3914 snprintf(priv->firmware_id, 32, "%s%s.%s", fw_table[fw_index].fw_file,
3915 firmware_modifier[i], fw_table[fw_index].fw_file_ext);
3916 priv->firmware_id[31] = '\0';
3917 if (request_firmware(&fw_entry, priv->firmware_id, priv->sys_dev) == 0) {
3918 success = 1;
3919 break;
3920 }
3921 }
3922 }
3923 if (!success) {
3924 printk(KERN_ALERT
3925 "%s: firmware %s is missing, cannot start.\n",
3926 dev->name, priv->firmware_id);
3927 priv->firmware_id[0] = '\0';
3928 return -ENOENT;
3929 }
3930 }
3931
3932 fw = fw_entry->data;
3933 len = fw_entry->size;
3934 }
3935
3936 if (len <= 0x6000) {
3937 atmel_write16(priv->dev, BSR, BSS_IRAM);
3938 atmel_copy_to_card(priv->dev, 0, fw, len);
3939 atmel_set_gcr(priv->dev, GCR_REMAP);
3940 } else {
3941 /* Remap */
3942 atmel_set_gcr(priv->dev, GCR_REMAP);
3943 atmel_write16(priv->dev, BSR, BSS_IRAM);
3944 atmel_copy_to_card(priv->dev, 0, fw, 0x6000);
3945 atmel_write16(priv->dev, BSR, 0x2ff);
3946 atmel_copy_to_card(priv->dev, 0x8000, &fw[0x6000], len - 0x6000);
3947 }
3948
3949 release_firmware(fw_entry);
3950 }
3951
3952 err = atmel_wakeup_firmware(priv);
3953 if (err != 0)
3954 return err;
3955
3956 /* Check the version and set the correct flag for wpa stuff,
3957 old and new firmware is incompatible.
3958 The pre-wpa 3com firmware reports major version 5,
3959 the wpa 3com firmware is major version 4 and doesn't need
3960 the 3com broken-ness filter. */
3961 priv->use_wpa = (priv->host_info.major_version == 4);
3962 priv->radio_on_broken = (priv->host_info.major_version == 5);
3963
3964 /* unmask all irq sources */
3965 atmel_wmem8(priv, atmel_hi(priv, IFACE_INT_MASK_OFFSET), 0xff);
3966
3967 /* int Tx system and enable Tx */
3968 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, 0), 0);
3969 atmel_wmem32(priv, atmel_tx(priv, TX_DESC_NEXT_OFFSET, 0), 0x80000000L);
3970 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_POS_OFFSET, 0), 0);
3971 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, 0), 0);
3972
3973 priv->tx_desc_free = priv->host_info.tx_desc_count;
3974 priv->tx_desc_head = 0;
3975 priv->tx_desc_tail = 0;
3976 priv->tx_desc_previous = 0;
3977 priv->tx_free_mem = priv->host_info.tx_buff_size;
3978 priv->tx_buff_head = 0;
3979 priv->tx_buff_tail = 0;
3980
3981 configuration = atmel_rmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET));
3982 atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET),
3983 configuration | FUNC_CTRL_TxENABLE);
3984
3985 /* init Rx system and enable */
3986 priv->rx_desc_head = 0;
3987
3988 configuration = atmel_rmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET));
3989 atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET),
3990 configuration | FUNC_CTRL_RxENABLE);
3991
3992 if (!priv->radio_on_broken) {
3993 if (atmel_send_command_wait(priv, CMD_EnableRadio, NULL, 0) ==
3994 CMD_STATUS_REJECTED_RADIO_OFF) {
3995 printk(KERN_INFO "%s: cannot turn the radio on.\n",
3996 dev->name);
3997 return -EIO;
3998 }
3999 }
4000
4001 /* set up enough MIB values to run. */
4002 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_AUTO_TX_RATE_POS, priv->auto_tx_rate);
4003 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_TX_PROMISCUOUS_POS, PROM_MODE_OFF);
4004 atmel_set_mib16(priv, Mac_Mib_Type, MAC_MIB_RTS_THRESHOLD_POS, priv->rts_threshold);
4005 atmel_set_mib16(priv, Mac_Mib_Type, MAC_MIB_FRAG_THRESHOLD_POS, priv->frag_threshold);
4006 atmel_set_mib8(priv, Mac_Mib_Type, MAC_MIB_SHORT_RETRY_POS, priv->short_retry);
4007 atmel_set_mib8(priv, Mac_Mib_Type, MAC_MIB_LONG_RETRY_POS, priv->long_retry);
4008 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_PREAMBLE_TYPE, priv->preamble);
4009 atmel_set_mib(priv, Mac_Address_Mib_Type, MAC_ADDR_MIB_MAC_ADDR_POS,
4010 priv->dev->dev_addr, 6);
4011 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE);
4012 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1);
4013 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_BEACON_PER_POS, priv->default_beacon_period);
4014 atmel_set_mib(priv, Phy_Mib_Type, PHY_MIB_RATE_SET_POS, atmel_basic_rates, 4);
4015 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_CUR_PRIVACY_POS, priv->wep_is_on);
4016 if (priv->use_wpa)
4017 build_wpa_mib(priv);
4018 else
4019 build_wep_mib(priv);
4020
4021 if (old_state == STATION_STATE_READY) {
4022 union iwreq_data wrqu;
4023
4024 wrqu.data.length = 0;
4025 wrqu.data.flags = 0;
4026 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
4027 eth_zero_addr(wrqu.ap_addr.sa_data);
4028 wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
4029 }
4030
4031 return 0;
4032 }
4033
4034 static void atmel_send_command(struct atmel_private *priv, int command,
4035 void *cmd, int cmd_size)
4036 {
4037 if (cmd)
4038 atmel_copy_to_card(priv->dev, atmel_co(priv, CMD_BLOCK_PARAMETERS_OFFSET),
4039 cmd, cmd_size);
4040
4041 atmel_wmem8(priv, atmel_co(priv, CMD_BLOCK_COMMAND_OFFSET), command);
4042 atmel_wmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET), 0);
4043 }
4044
4045 static int atmel_send_command_wait(struct atmel_private *priv, int command,
4046 void *cmd, int cmd_size)
4047 {
4048 int i, status;
4049
4050 atmel_send_command(priv, command, cmd, cmd_size);
4051
4052 for (i = 5000; i; i--) {
4053 status = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET));
4054 if (status != CMD_STATUS_IDLE &&
4055 status != CMD_STATUS_IN_PROGRESS)
4056 break;
4057 udelay(20);
4058 }
4059
4060 if (i == 0) {
4061 printk(KERN_ALERT "%s: failed to contact MAC.\n", priv->dev->name);
4062 status = CMD_STATUS_HOST_ERROR;
4063 } else {
4064 if (command != CMD_EnableRadio)
4065 status = CMD_STATUS_COMPLETE;
4066 }
4067
4068 return status;
4069 }
4070
4071 static u8 atmel_get_mib8(struct atmel_private *priv, u8 type, u8 index)
4072 {
4073 struct get_set_mib m;
4074 m.type = type;
4075 m.size = 1;
4076 m.index = index;
4077
4078 atmel_send_command_wait(priv, CMD_Get_MIB_Vars, &m, MIB_HEADER_SIZE + 1);
4079 return atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_PARAMETERS_OFFSET + MIB_HEADER_SIZE));
4080 }
4081
4082 static void atmel_set_mib8(struct atmel_private *priv, u8 type, u8 index, u8 data)
4083 {
4084 struct get_set_mib m;
4085 m.type = type;
4086 m.size = 1;
4087 m.index = index;
4088 m.data[0] = data;
4089
4090 atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + 1);
4091 }
4092
4093 static void atmel_set_mib16(struct atmel_private *priv, u8 type, u8 index,
4094 u16 data)
4095 {
4096 struct get_set_mib m;
4097 m.type = type;
4098 m.size = 2;
4099 m.index = index;
4100 m.data[0] = data;
4101 m.data[1] = data >> 8;
4102
4103 atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + 2);
4104 }
4105
4106 static void atmel_set_mib(struct atmel_private *priv, u8 type, u8 index,
4107 u8 *data, int data_len)
4108 {
4109 struct get_set_mib m;
4110 m.type = type;
4111 m.size = data_len;
4112 m.index = index;
4113
4114 if (data_len > MIB_MAX_DATA_BYTES)
4115 printk(KERN_ALERT "%s: MIB buffer too small.\n", priv->dev->name);
4116
4117 memcpy(m.data, data, data_len);
4118 atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + data_len);
4119 }
4120
4121 static void atmel_get_mib(struct atmel_private *priv, u8 type, u8 index,
4122 u8 *data, int data_len)
4123 {
4124 struct get_set_mib m;
4125 m.type = type;
4126 m.size = data_len;
4127 m.index = index;
4128
4129 if (data_len > MIB_MAX_DATA_BYTES)
4130 printk(KERN_ALERT "%s: MIB buffer too small.\n", priv->dev->name);
4131
4132 atmel_send_command_wait(priv, CMD_Get_MIB_Vars, &m, MIB_HEADER_SIZE + data_len);
4133 atmel_copy_to_host(priv->dev, data,
4134 atmel_co(priv, CMD_BLOCK_PARAMETERS_OFFSET + MIB_HEADER_SIZE), data_len);
4135 }
4136
4137 static void atmel_writeAR(struct net_device *dev, u16 data)
4138 {
4139 int i;
4140 outw(data, dev->base_addr + AR);
4141 /* Address register appears to need some convincing..... */
4142 for (i = 0; data != inw(dev->base_addr + AR) && i < 10; i++)
4143 outw(data, dev->base_addr + AR);
4144 }
4145
4146 static void atmel_copy_to_card(struct net_device *dev, u16 dest,
4147 const unsigned char *src, u16 len)
4148 {
4149 int i;
4150 atmel_writeAR(dev, dest);
4151 if (dest % 2) {
4152 atmel_write8(dev, DR, *src);
4153 src++; len--;
4154 }
4155 for (i = len; i > 1 ; i -= 2) {
4156 u8 lb = *src++;
4157 u8 hb = *src++;
4158 atmel_write16(dev, DR, lb | (hb << 8));
4159 }
4160 if (i)
4161 atmel_write8(dev, DR, *src);
4162 }
4163
4164 static void atmel_copy_to_host(struct net_device *dev, unsigned char *dest,
4165 u16 src, u16 len)
4166 {
4167 int i;
4168 atmel_writeAR(dev, src);
4169 if (src % 2) {
4170 *dest = atmel_read8(dev, DR);
4171 dest++; len--;
4172 }
4173 for (i = len; i > 1 ; i -= 2) {
4174 u16 hw = atmel_read16(dev, DR);
4175 *dest++ = hw;
4176 *dest++ = hw >> 8;
4177 }
4178 if (i)
4179 *dest = atmel_read8(dev, DR);
4180 }
4181
4182 static void atmel_set_gcr(struct net_device *dev, u16 mask)
4183 {
4184 outw(inw(dev->base_addr + GCR) | mask, dev->base_addr + GCR);
4185 }
4186
4187 static void atmel_clear_gcr(struct net_device *dev, u16 mask)
4188 {
4189 outw(inw(dev->base_addr + GCR) & ~mask, dev->base_addr + GCR);
4190 }
4191
4192 static int atmel_lock_mac(struct atmel_private *priv)
4193 {
4194 int i, j = 20;
4195 retry:
4196 for (i = 5000; i; i--) {
4197 if (!atmel_rmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_HOST_OFFSET)))
4198 break;
4199 udelay(20);
4200 }
4201
4202 if (!i)
4203 return 0; /* timed out */
4204
4205 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 1);
4206 if (atmel_rmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_HOST_OFFSET))) {
4207 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0);
4208 if (!j--)
4209 return 0; /* timed out */
4210 goto retry;
4211 }
4212
4213 return 1;
4214 }
4215
4216 static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data)
4217 {
4218 atmel_writeAR(priv->dev, pos);
4219 atmel_write16(priv->dev, DR, data); /* card is little-endian */
4220 atmel_write16(priv->dev, DR, data >> 16);
4221 }
4222
4223 /***************************************************************************/
4224 /* There follows the source form of the MAC address reading firmware */
4225 /***************************************************************************/
4226 #if 0
4227
4228 /* Copyright 2003 Matthew T. Russotto */
4229 /* But derived from the Atmel 76C502 firmware written by Atmel and */
4230 /* included in "atmel wireless lan drivers" package */
4231 /*
4232 This file is part of net.russotto.AtmelMACFW, hereto referred to
4233 as AtmelMACFW
4234
4235 AtmelMACFW is free software; you can redistribute it and/or modify
4236 it under the terms of the GNU General Public License version 2
4237 as published by the Free Software Foundation.
4238
4239 AtmelMACFW is distributed in the hope that it will be useful,
4240 but WITHOUT ANY WARRANTY; without even the implied warranty of
4241 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4242 GNU General Public License for more details.
4243
4244 You should have received a copy of the GNU General Public License
4245 along with AtmelMACFW; if not, see <http://www.gnu.org/licenses/>.
4246
4247 ****************************************************************************/
4248 /* This firmware should work on the 76C502 RFMD, RFMD_D, and RFMD_E */
4249 /* It will probably work on the 76C504 and 76C502 RFMD_3COM */
4250 /* It only works on SPI EEPROM versions of the card. */
4251
4252 /* This firmware initializes the SPI controller and clock, reads the MAC */
4253 /* address from the EEPROM into SRAM, and puts the SRAM offset of the MAC */
4254 /* address in MR2, and sets MR3 to 0x10 to indicate it is done */
4255 /* It also puts a complete copy of the EEPROM in SRAM with the offset in */
4256 /* MR4, for investigational purposes (maybe we can determine chip type */
4257 /* from that?) */
4258
4259 .org 0
4260 .set MRBASE, 0x8000000
4261 .set CPSR_INITIAL, 0xD3 /* IRQ/FIQ disabled, ARM mode, Supervisor state */
4262 .set CPSR_USER, 0xD1 /* IRQ/FIQ disabled, ARM mode, USER state */
4263 .set SRAM_BASE, 0x02000000
4264 .set SP_BASE, 0x0F300000
4265 .set UNK_BASE, 0x0F000000 /* Some internal device, but which one? */
4266 .set SPI_CGEN_BASE, 0x0E000000 /* Some internal device, but which one? */
4267 .set UNK3_BASE, 0x02014000 /* Some internal device, but which one? */
4268 .set STACK_BASE, 0x5600
4269 .set SP_SR, 0x10
4270 .set SP_TDRE, 2 /* status register bit -- TDR empty */
4271 .set SP_RDRF, 1 /* status register bit -- RDR full */
4272 .set SP_SWRST, 0x80
4273 .set SP_SPIEN, 0x1
4274 .set SP_CR, 0 /* control register */
4275 .set SP_MR, 4 /* mode register */
4276 .set SP_RDR, 0x08 /* Read Data Register */
4277 .set SP_TDR, 0x0C /* Transmit Data Register */
4278 .set SP_CSR0, 0x30 /* chip select registers */
4279 .set SP_CSR1, 0x34
4280 .set SP_CSR2, 0x38
4281 .set SP_CSR3, 0x3C
4282 .set NVRAM_CMD_RDSR, 5 /* read status register */
4283 .set NVRAM_CMD_READ, 3 /* read data */
4284 .set NVRAM_SR_RDY, 1 /* RDY bit. This bit is inverted */
4285 .set SPI_8CLOCKS, 0xFF /* Writing this to the TDR doesn't do anything to the
4286 serial output, since SO is normally high. But it
4287 does cause 8 clock cycles and thus 8 bits to be
4288 clocked in to the chip. See Atmel's SPI
4289 controller (e.g. AT91M55800) timing and 4K
4290 SPI EEPROM manuals */
4291
4292 .set NVRAM_SCRATCH, 0x02000100 /* arbitrary area for scratchpad memory */
4293 .set NVRAM_IMAGE, 0x02000200
4294 .set NVRAM_LENGTH, 0x0200
4295 .set MAC_ADDRESS_MIB, SRAM_BASE
4296 .set MAC_ADDRESS_LENGTH, 6
4297 .set MAC_BOOT_FLAG, 0x10
4298 .set MR1, 0
4299 .set MR2, 4
4300 .set MR3, 8
4301 .set MR4, 0xC
4302 RESET_VECTOR:
4303 b RESET_HANDLER
4304 UNDEF_VECTOR:
4305 b HALT1
4306 SWI_VECTOR:
4307 b HALT1
4308 IABORT_VECTOR:
4309 b HALT1
4310 DABORT_VECTOR:
4311 RESERVED_VECTOR:
4312 b HALT1
4313 IRQ_VECTOR:
4314 b HALT1
4315 FIQ_VECTOR:
4316 b HALT1
4317 HALT1: b HALT1
4318 RESET_HANDLER:
4319 mov r0, #CPSR_INITIAL
4320 msr CPSR_c, r0 /* This is probably unnecessary */
4321
4322 /* I'm guessing this is initializing clock generator electronics for SPI */
4323 ldr r0, =SPI_CGEN_BASE
4324 mov r1, #0
4325 mov r1, r1, lsl #3
4326 orr r1, r1, #0
4327 str r1, [r0]
4328 ldr r1, [r0, #28]
4329 bic r1, r1, #16
4330 str r1, [r0, #28]
4331 mov r1, #1
4332 str r1, [r0, #8]
4333
4334 ldr r0, =MRBASE
4335 mov r1, #0
4336 strh r1, [r0, #MR1]
4337 strh r1, [r0, #MR2]
4338 strh r1, [r0, #MR3]
4339 strh r1, [r0, #MR4]
4340
4341 mov sp, #STACK_BASE
4342 bl SP_INIT
4343 mov r0, #10
4344 bl DELAY9
4345 bl GET_MAC_ADDR
4346 bl GET_WHOLE_NVRAM
4347 ldr r0, =MRBASE
4348 ldr r1, =MAC_ADDRESS_MIB
4349 strh r1, [r0, #MR2]
4350 ldr r1, =NVRAM_IMAGE
4351 strh r1, [r0, #MR4]
4352 mov r1, #MAC_BOOT_FLAG
4353 strh r1, [r0, #MR3]
4354 HALT2: b HALT2
4355 .func Get_Whole_NVRAM, GET_WHOLE_NVRAM
4356 GET_WHOLE_NVRAM:
4357 stmdb sp!, {lr}
4358 mov r2, #0 /* 0th bytes of NVRAM */
4359 mov r3, #NVRAM_LENGTH
4360 mov r1, #0 /* not used in routine */
4361 ldr r0, =NVRAM_IMAGE
4362 bl NVRAM_XFER
4363 ldmia sp!, {lr}
4364 bx lr
4365 .endfunc
4366
4367 .func Get_MAC_Addr, GET_MAC_ADDR
4368 GET_MAC_ADDR:
4369 stmdb sp!, {lr}
4370 mov r2, #0x120 /* address of MAC Address within NVRAM */
4371 mov r3, #MAC_ADDRESS_LENGTH
4372 mov r1, #0 /* not used in routine */
4373 ldr r0, =MAC_ADDRESS_MIB
4374 bl NVRAM_XFER
4375 ldmia sp!, {lr}
4376 bx lr
4377 .endfunc
4378 .ltorg
4379 .func Delay9, DELAY9
4380 DELAY9:
4381 adds r0, r0, r0, LSL #3 /* r0 = r0 * 9 */
4382 DELAYLOOP:
4383 beq DELAY9_done
4384 subs r0, r0, #1
4385 b DELAYLOOP
4386 DELAY9_done:
4387 bx lr
4388 .endfunc
4389
4390 .func SP_Init, SP_INIT
4391 SP_INIT:
4392 mov r1, #SP_SWRST
4393 ldr r0, =SP_BASE
4394 str r1, [r0, #SP_CR] /* reset the SPI */
4395 mov r1, #0
4396 str r1, [r0, #SP_CR] /* release SPI from reset state */
4397 mov r1, #SP_SPIEN
4398 str r1, [r0, #SP_MR] /* set the SPI to MASTER mode*/
4399 str r1, [r0, #SP_CR] /* enable the SPI */
4400
4401 /* My guess would be this turns on the SPI clock */
4402 ldr r3, =SPI_CGEN_BASE
4403 ldr r1, [r3, #28]
4404 orr r1, r1, #0x2000
4405 str r1, [r3, #28]
4406
4407 ldr r1, =0x2000c01
4408 str r1, [r0, #SP_CSR0]
4409 ldr r1, =0x2000201
4410 str r1, [r0, #SP_CSR1]
4411 str r1, [r0, #SP_CSR2]
4412 str r1, [r0, #SP_CSR3]
4413 ldr r1, [r0, #SP_SR]
4414 ldr r0, [r0, #SP_RDR]
4415 bx lr
4416 .endfunc
4417 .func NVRAM_Init, NVRAM_INIT
4418 NVRAM_INIT:
4419 ldr r1, =SP_BASE
4420 ldr r0, [r1, #SP_RDR]
4421 mov r0, #NVRAM_CMD_RDSR
4422 str r0, [r1, #SP_TDR]
4423 SP_loop1:
4424 ldr r0, [r1, #SP_SR]
4425 tst r0, #SP_TDRE
4426 beq SP_loop1
4427
4428 mov r0, #SPI_8CLOCKS
4429 str r0, [r1, #SP_TDR]
4430 SP_loop2:
4431 ldr r0, [r1, #SP_SR]
4432 tst r0, #SP_TDRE
4433 beq SP_loop2
4434
4435 ldr r0, [r1, #SP_RDR]
4436 SP_loop3:
4437 ldr r0, [r1, #SP_SR]
4438 tst r0, #SP_RDRF
4439 beq SP_loop3
4440
4441 ldr r0, [r1, #SP_RDR]
4442 and r0, r0, #255
4443 bx lr
4444 .endfunc
4445
4446 .func NVRAM_Xfer, NVRAM_XFER
4447 /* r0 = dest address */
4448 /* r1 = not used */
4449 /* r2 = src address within NVRAM */
4450 /* r3 = length */
4451 NVRAM_XFER:
4452 stmdb sp!, {r4, r5, lr}
4453 mov r5, r0 /* save r0 (dest address) */
4454 mov r4, r3 /* save r3 (length) */
4455 mov r0, r2, LSR #5 /* SPI memories put A8 in the command field */
4456 and r0, r0, #8
4457 add r0, r0, #NVRAM_CMD_READ
4458 ldr r1, =NVRAM_SCRATCH
4459 strb r0, [r1, #0] /* save command in NVRAM_SCRATCH[0] */
4460 strb r2, [r1, #1] /* save low byte of source address in NVRAM_SCRATCH[1] */
4461 _local1:
4462 bl NVRAM_INIT
4463 tst r0, #NVRAM_SR_RDY
4464 bne _local1
4465 mov r0, #20
4466 bl DELAY9
4467 mov r2, r4 /* length */
4468 mov r1, r5 /* dest address */
4469 mov r0, #2 /* bytes to transfer in command */
4470 bl NVRAM_XFER2
4471 ldmia sp!, {r4, r5, lr}
4472 bx lr
4473 .endfunc
4474
4475 .func NVRAM_Xfer2, NVRAM_XFER2
4476 NVRAM_XFER2:
4477 stmdb sp!, {r4, r5, r6, lr}
4478 ldr r4, =SP_BASE
4479 mov r3, #0
4480 cmp r0, #0
4481 bls _local2
4482 ldr r5, =NVRAM_SCRATCH
4483 _local4:
4484 ldrb r6, [r5, r3]
4485 str r6, [r4, #SP_TDR]
4486 _local3:
4487 ldr r6, [r4, #SP_SR]
4488 tst r6, #SP_TDRE
4489 beq _local3
4490 add r3, r3, #1
4491 cmp r3, r0 /* r0 is # of bytes to send out (command+addr) */
4492 blo _local4
4493 _local2:
4494 mov r3, #SPI_8CLOCKS
4495 str r3, [r4, #SP_TDR]
4496 ldr r0, [r4, #SP_RDR]
4497 _local5:
4498 ldr r0, [r4, #SP_SR]
4499 tst r0, #SP_RDRF
4500 beq _local5
4501 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 */
4502 mov r0, #0
4503 cmp r2, #0 /* r2 is # of bytes to copy in */
4504 bls _local6
4505 _local7:
4506 ldr r5, [r4, #SP_SR]
4507 tst r5, #SP_TDRE
4508 beq _local7
4509 str r3, [r4, #SP_TDR] /* r3 has SPI_8CLOCKS */
4510 _local8:
4511 ldr r5, [r4, #SP_SR]
4512 tst r5, #SP_RDRF
4513 beq _local8
4514 ldr r5, [r4, #SP_RDR] /* but didn't we read this byte above? */
4515 strb r5, [r1], #1 /* postindexed */
4516 add r0, r0, #1
4517 cmp r0, r2
4518 blo _local7 /* since we don't send another address, the NVRAM must be capable of sequential reads */
4519 _local6:
4520 mov r0, #200
4521 bl DELAY9
4522 ldmia sp!, {r4, r5, r6, lr}
4523 bx lr
4524 #endif
Linux with added FPC-III support