aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless
diff options
context:
space:
mode:
authorCarlo Perassi <carlo@linux.it>2005-11-13 07:02:15 -0500
committerJohn W. Linville <linville@tuxdriver.com>2005-11-16 14:13:20 -0500
commit4d791aadf63c9d605bc9a4144e79d5756fc29fb3 (patch)
tree8a8d09d11a00a1d3487fd76c3ffc371ac2aff160 /drivers/net/wireless
parentc1120b22499d7e13e5cd2349cb2168b76d0edaca (diff)
[PATCH] atmel: CodingStyle cleanup
Reading this driver I noticed some trailing whitespaces and tabs so I removed them with some 80th column fitting and a few more similar things. Signed-off-by: Carlo Perassi <carlo@linux.it> Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com> Signed-off-by: John W. Linville <linville@tuxdriver.com>
Diffstat (limited to 'drivers/net/wireless')
-rw-r--r--drivers/net/wireless/atmel.c1487
1 files changed, 759 insertions, 728 deletions
diff --git a/drivers/net/wireless/atmel.c b/drivers/net/wireless/atmel.c
index 5e53c5258a33..050aa518d7d1 100644
--- a/drivers/net/wireless/atmel.c
+++ b/drivers/net/wireless/atmel.c
@@ -5,9 +5,9 @@
5 Copyright 2000-2001 ATMEL Corporation. 5 Copyright 2000-2001 ATMEL Corporation.
6 Copyright 2003-2004 Simon Kelley. 6 Copyright 2003-2004 Simon Kelley.
7 7
8 This code was developed from version 2.1.1 of the Atmel drivers, 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 9 released by Atmel corp. under the GPL in December 2002. It also
10 includes code from the Linux aironet drivers (C) Benjamin Reed, 10 includes code from the Linux aironet drivers (C) Benjamin Reed,
11 and the Linux PCMCIA package, (C) David Hinds and the Linux wireless 11 and the Linux PCMCIA package, (C) David Hinds and the Linux wireless
12 extensions, (C) Jean Tourrilhes. 12 extensions, (C) Jean Tourrilhes.
13 13
@@ -31,7 +31,7 @@
31 along with Atmel wireless lan drivers; if not, write to the Free Software 31 along with Atmel wireless lan drivers; if not, write to the Free Software
32 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 32 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
33 33
34 For all queries about this code, please contact the current author, 34 For all queries about this code, please contact the current author,
35 Simon Kelley <simon@thekelleys.org.uk> and not Atmel Corporation. 35 Simon Kelley <simon@thekelleys.org.uk> and not Atmel Corporation.
36 36
37 Credit is due to HP UK and Cambridge Online Systems Ltd for supplying 37 Credit is due to HP UK and Cambridge Online Systems Ltd for supplying
@@ -79,13 +79,13 @@ MODULE_DESCRIPTION("Support for Atmel at76c50x 802.11 wireless ethernet cards.")
79MODULE_LICENSE("GPL"); 79MODULE_LICENSE("GPL");
80MODULE_SUPPORTED_DEVICE("Atmel at76c50x wireless cards"); 80MODULE_SUPPORTED_DEVICE("Atmel at76c50x wireless cards");
81 81
82/* The name of the firmware file to be loaded 82/* The name of the firmware file to be loaded
83 over-rides any automatic selection */ 83 over-rides any automatic selection */
84static char *firmware = NULL; 84static char *firmware = NULL;
85module_param(firmware, charp, 0); 85module_param(firmware, charp, 0);
86 86
87/* table of firmware file names */ 87/* table of firmware file names */
88static struct { 88static struct {
89 AtmelFWType fw_type; 89 AtmelFWType fw_type;
90 const char *fw_file; 90 const char *fw_file;
91 const char *fw_file_ext; 91 const char *fw_file_ext;
@@ -104,17 +104,17 @@ static struct {
104#define MAX_SSID_LENGTH 32 104#define MAX_SSID_LENGTH 32
105#define MGMT_JIFFIES (256 * HZ / 100) 105#define MGMT_JIFFIES (256 * HZ / 100)
106 106
107#define MAX_BSS_ENTRIES 64 107#define MAX_BSS_ENTRIES 64
108 108
109/* registers */ 109/* registers */
110#define GCR 0x00 // (SIR0) General Configuration Register 110#define GCR 0x00 // (SIR0) General Configuration Register
111#define BSR 0x02 // (SIR1) Bank Switching Select Register 111#define BSR 0x02 // (SIR1) Bank Switching Select Register
112#define AR 0x04 112#define AR 0x04
113#define DR 0x08 113#define DR 0x08
114#define MR1 0x12 // Mirror Register 1 114#define MR1 0x12 // Mirror Register 1
115#define MR2 0x14 // Mirror Register 2 115#define MR2 0x14 // Mirror Register 2
116#define MR3 0x16 // Mirror Register 3 116#define MR3 0x16 // Mirror Register 3
117#define MR4 0x18 // Mirror Register 4 117#define MR4 0x18 // Mirror Register 4
118 118
119#define GPR1 0x0c 119#define GPR1 0x0c
120#define GPR2 0x0e 120#define GPR2 0x0e
@@ -123,9 +123,9 @@ static struct {
123// Constants for the GCR register. 123// Constants for the GCR register.
124// 124//
125#define GCR_REMAP 0x0400 // Remap internal SRAM to 0 125#define GCR_REMAP 0x0400 // Remap internal SRAM to 0
126#define GCR_SWRES 0x0080 // BIU reset (ARM and PAI are NOT reset) 126#define GCR_SWRES 0x0080 // BIU reset (ARM and PAI are NOT reset)
127#define GCR_CORES 0x0060 // Core Reset (ARM and PAI are reset) 127#define GCR_CORES 0x0060 // Core Reset (ARM and PAI are reset)
128#define GCR_ENINT 0x0002 // Enable Interrupts 128#define GCR_ENINT 0x0002 // Enable Interrupts
129#define GCR_ACKINT 0x0008 // Acknowledge Interrupts 129#define GCR_ACKINT 0x0008 // Acknowledge Interrupts
130 130
131#define BSS_SRAM 0x0200 // AMBA module selection --> SRAM 131#define BSS_SRAM 0x0200 // AMBA module selection --> SRAM
@@ -190,7 +190,7 @@ struct rx_desc {
190 u32 Next; 190 u32 Next;
191 u16 MsduPos; 191 u16 MsduPos;
192 u16 MsduSize; 192 u16 MsduSize;
193 193
194 u8 State; 194 u8 State;
195 u8 Status; 195 u8 Status;
196 u8 Rate; 196 u8 Rate;
@@ -199,7 +199,6 @@ struct rx_desc {
199 u8 PreambleType; 199 u8 PreambleType;
200 u16 Duration; 200 u16 Duration;
201 u32 RxTime; 201 u32 RxTime;
202
203}; 202};
204 203
205#define RX_DESC_FLAG_VALID 0x80 204#define RX_DESC_FLAG_VALID 0x80
@@ -218,16 +217,15 @@ struct rx_desc {
218#define RX_DESC_DURATION_OFFSET 14 217#define RX_DESC_DURATION_OFFSET 14
219#define RX_DESC_RX_TIME_OFFSET 16 218#define RX_DESC_RX_TIME_OFFSET 16
220 219
221
222struct tx_desc { 220struct tx_desc {
223 u32 NextDescriptor; 221 u32 NextDescriptor;
224 u16 TxStartOfFrame; 222 u16 TxStartOfFrame;
225 u16 TxLength; 223 u16 TxLength;
226 224
227 u8 TxState; 225 u8 TxState;
228 u8 TxStatus; 226 u8 TxStatus;
229 u8 RetryCount; 227 u8 RetryCount;
230 228
231 u8 TxRate; 229 u8 TxRate;
232 230
233 u8 KeyIndex; 231 u8 KeyIndex;
@@ -238,10 +236,8 @@ struct tx_desc {
238 u8 Reserved; 236 u8 Reserved;
239 u8 PacketType; 237 u8 PacketType;
240 u16 HostTxLength; 238 u16 HostTxLength;
241
242}; 239};
243 240
244
245#define TX_DESC_NEXT_OFFSET 0 241#define TX_DESC_NEXT_OFFSET 0
246#define TX_DESC_POS_OFFSET 4 242#define TX_DESC_POS_OFFSET 4
247#define TX_DESC_SIZE_OFFSET 6 243#define TX_DESC_SIZE_OFFSET 6
@@ -255,8 +251,6 @@ struct tx_desc {
255#define TX_DESC_PACKET_TYPE_OFFSET 17 251#define TX_DESC_PACKET_TYPE_OFFSET 17
256#define TX_DESC_HOST_LENGTH_OFFSET 18 252#define TX_DESC_HOST_LENGTH_OFFSET 18
257 253
258
259
260/////////////////////////////////////////////////////// 254///////////////////////////////////////////////////////
261// Host-MAC interface 255// Host-MAC interface
262/////////////////////////////////////////////////////// 256///////////////////////////////////////////////////////
@@ -266,7 +260,6 @@ struct tx_desc {
266#define TX_FIRM_OWN 0x80 260#define TX_FIRM_OWN 0x80
267#define TX_DONE 0x40 261#define TX_DONE 0x40
268 262
269
270#define TX_ERROR 0x01 263#define TX_ERROR 0x01
271 264
272#define TX_PACKET_TYPE_DATA 0x01 265#define TX_PACKET_TYPE_DATA 0x01
@@ -280,8 +273,7 @@ struct tx_desc {
280#define ISR_COMMAND_COMPLETE 0x10 // command completed 273#define ISR_COMMAND_COMPLETE 0x10 // command completed
281#define ISR_OUT_OF_RANGE 0x20 // command completed 274#define ISR_OUT_OF_RANGE 0x20 // command completed
282#define ISR_IBSS_MERGE 0x40 // (4.1.2.30): IBSS merge 275#define ISR_IBSS_MERGE 0x40 // (4.1.2.30): IBSS merge
283#define ISR_GENERIC_IRQ 0x80 276#define ISR_GENERIC_IRQ 0x80
284
285 277
286#define Local_Mib_Type 0x01 278#define Local_Mib_Type 0x01
287#define Mac_Address_Mib_Type 0x02 279#define Mac_Address_Mib_Type 0x02
@@ -317,7 +309,6 @@ struct tx_desc {
317#define LOCAL_MIB_PREAMBLE_TYPE 9 309#define LOCAL_MIB_PREAMBLE_TYPE 9
318#define MAC_ADDR_MIB_MAC_ADDR_POS 0 310#define MAC_ADDR_MIB_MAC_ADDR_POS 0
319 311
320
321#define CMD_Set_MIB_Vars 0x01 312#define CMD_Set_MIB_Vars 0x01
322#define CMD_Get_MIB_Vars 0x02 313#define CMD_Get_MIB_Vars 0x02
323#define CMD_Scan 0x03 314#define CMD_Scan 0x03
@@ -338,7 +329,6 @@ struct tx_desc {
338#define CMD_STATUS_HOST_ERROR 0xFF 329#define CMD_STATUS_HOST_ERROR 0xFF
339#define CMD_STATUS_BUSY 0xFE 330#define CMD_STATUS_BUSY 0xFE
340 331
341
342#define CMD_BLOCK_COMMAND_OFFSET 0 332#define CMD_BLOCK_COMMAND_OFFSET 0
343#define CMD_BLOCK_STATUS_OFFSET 1 333#define CMD_BLOCK_STATUS_OFFSET 1
344#define CMD_BLOCK_PARAMETERS_OFFSET 4 334#define CMD_BLOCK_PARAMETERS_OFFSET 4
@@ -347,15 +337,15 @@ struct tx_desc {
347 337
348#define MGMT_FRAME_BODY_OFFSET 24 338#define MGMT_FRAME_BODY_OFFSET 24
349#define MAX_AUTHENTICATION_RETRIES 3 339#define MAX_AUTHENTICATION_RETRIES 3
350#define MAX_ASSOCIATION_RETRIES 3 340#define MAX_ASSOCIATION_RETRIES 3
351 341
352#define AUTHENTICATION_RESPONSE_TIME_OUT 1000 342#define AUTHENTICATION_RESPONSE_TIME_OUT 1000
353 343
354#define MAX_WIRELESS_BODY 2316 /* mtu is 2312, CRC is 4 */ 344#define MAX_WIRELESS_BODY 2316 /* mtu is 2312, CRC is 4 */
355#define LOOP_RETRY_LIMIT 500000 345#define LOOP_RETRY_LIMIT 500000
356 346
357#define ACTIVE_MODE 1 347#define ACTIVE_MODE 1
358#define PS_MODE 2 348#define PS_MODE 2
359 349
360#define MAX_ENCRYPTION_KEYS 4 350#define MAX_ENCRYPTION_KEYS 4
361#define MAX_ENCRYPTION_KEY_SIZE 40 351#define MAX_ENCRYPTION_KEY_SIZE 40
@@ -377,7 +367,7 @@ struct tx_desc {
377#define REG_DOMAIN_MKK1 0x41 //Channel 1-14 Japan(MKK1) 367#define REG_DOMAIN_MKK1 0x41 //Channel 1-14 Japan(MKK1)
378#define REG_DOMAIN_ISRAEL 0x50 //Channel 3-9 ISRAEL 368#define REG_DOMAIN_ISRAEL 0x50 //Channel 3-9 ISRAEL
379 369
380#define BSS_TYPE_AD_HOC 1 370#define BSS_TYPE_AD_HOC 1
381#define BSS_TYPE_INFRASTRUCTURE 2 371#define BSS_TYPE_INFRASTRUCTURE 2
382 372
383#define SCAN_TYPE_ACTIVE 0 373#define SCAN_TYPE_ACTIVE 0
@@ -389,7 +379,7 @@ struct tx_desc {
389 379
390#define DATA_FRAME_WS_HEADER_SIZE 30 380#define DATA_FRAME_WS_HEADER_SIZE 30
391 381
392/* promiscuous mode control */ 382/* promiscuous mode control */
393#define PROM_MODE_OFF 0x0 383#define PROM_MODE_OFF 0x0
394#define PROM_MODE_UNKNOWN 0x1 384#define PROM_MODE_UNKNOWN 0x1
395#define PROM_MODE_CRC_FAILED 0x2 385#define PROM_MODE_CRC_FAILED 0x2
@@ -398,8 +388,7 @@ struct tx_desc {
398#define PROM_MODE_CTRL 0x10 388#define PROM_MODE_CTRL 0x10
399#define PROM_MODE_BAD_PROTOCOL 0x20 389#define PROM_MODE_BAD_PROTOCOL 0x20
400 390
401 391#define IFACE_INT_STATUS_OFFSET 0
402#define IFACE_INT_STATUS_OFFSET 0
403#define IFACE_INT_MASK_OFFSET 1 392#define IFACE_INT_MASK_OFFSET 1
404#define IFACE_LOCKOUT_HOST_OFFSET 2 393#define IFACE_LOCKOUT_HOST_OFFSET 2
405#define IFACE_LOCKOUT_MAC_OFFSET 3 394#define IFACE_LOCKOUT_MAC_OFFSET 3
@@ -407,7 +396,7 @@ struct tx_desc {
407#define IFACE_MAC_STAT_OFFSET 30 396#define IFACE_MAC_STAT_OFFSET 30
408#define IFACE_GENERIC_INT_TYPE_OFFSET 32 397#define IFACE_GENERIC_INT_TYPE_OFFSET 32
409 398
410#define CIPHER_SUITE_NONE 0 399#define CIPHER_SUITE_NONE 0
411#define CIPHER_SUITE_WEP_64 1 400#define CIPHER_SUITE_WEP_64 1
412#define CIPHER_SUITE_TKIP 2 401#define CIPHER_SUITE_TKIP 2
413#define CIPHER_SUITE_AES 3 402#define CIPHER_SUITE_AES 3
@@ -419,11 +408,11 @@ struct tx_desc {
419// 408//
420// 409//
421 410
422// FuncCtrl field: 411// FuncCtrl field:
423// 412//
424#define FUNC_CTRL_TxENABLE 0x10 413#define FUNC_CTRL_TxENABLE 0x10
425#define FUNC_CTRL_RxENABLE 0x20 414#define FUNC_CTRL_RxENABLE 0x20
426#define FUNC_CTRL_INIT_COMPLETE 0x01 415#define FUNC_CTRL_INIT_COMPLETE 0x01
427 416
428/* A stub firmware image which reads the MAC address from NVRAM on the card. 417/* A stub firmware image which reads the MAC address from NVRAM on the card.
429 For copyright information and source see the end of this file. */ 418 For copyright information and source see the end of this file. */
@@ -486,10 +475,10 @@ struct atmel_private {
486 struct net_device_stats stats; // device stats 475 struct net_device_stats stats; // device stats
487 spinlock_t irqlock, timerlock; // spinlocks 476 spinlock_t irqlock, timerlock; // spinlocks
488 enum { BUS_TYPE_PCCARD, BUS_TYPE_PCI } bus_type; 477 enum { BUS_TYPE_PCCARD, BUS_TYPE_PCI } bus_type;
489 enum { 478 enum {
490 CARD_TYPE_PARALLEL_FLASH, 479 CARD_TYPE_PARALLEL_FLASH,
491 CARD_TYPE_SPI_FLASH, 480 CARD_TYPE_SPI_FLASH,
492 CARD_TYPE_EEPROM 481 CARD_TYPE_EEPROM
493 } card_type; 482 } card_type;
494 int do_rx_crc; /* If we need to CRC incoming packets */ 483 int do_rx_crc; /* If we need to CRC incoming packets */
495 int probe_crc; /* set if we don't yet know */ 484 int probe_crc; /* set if we don't yet know */
@@ -497,18 +486,18 @@ struct atmel_private {
497 u16 rx_desc_head; 486 u16 rx_desc_head;
498 u16 tx_desc_free, tx_desc_head, tx_desc_tail, tx_desc_previous; 487 u16 tx_desc_free, tx_desc_head, tx_desc_tail, tx_desc_previous;
499 u16 tx_free_mem, tx_buff_head, tx_buff_tail; 488 u16 tx_free_mem, tx_buff_head, tx_buff_tail;
500 489
501 u16 frag_seq, frag_len, frag_no; 490 u16 frag_seq, frag_len, frag_no;
502 u8 frag_source[6]; 491 u8 frag_source[6];
503 492
504 u8 wep_is_on, default_key, exclude_unencrypted, encryption_level; 493 u8 wep_is_on, default_key, exclude_unencrypted, encryption_level;
505 u8 group_cipher_suite, pairwise_cipher_suite; 494 u8 group_cipher_suite, pairwise_cipher_suite;
506 u8 wep_keys[MAX_ENCRYPTION_KEYS][MAX_ENCRYPTION_KEY_SIZE]; 495 u8 wep_keys[MAX_ENCRYPTION_KEYS][MAX_ENCRYPTION_KEY_SIZE];
507 int wep_key_len[MAX_ENCRYPTION_KEYS]; 496 int wep_key_len[MAX_ENCRYPTION_KEYS];
508 int use_wpa, radio_on_broken; /* firmware dependent stuff. */ 497 int use_wpa, radio_on_broken; /* firmware dependent stuff. */
509 498
510 u16 host_info_base; 499 u16 host_info_base;
511 struct host_info_struct { 500 struct host_info_struct {
512 /* NB this is matched to the hardware, don't change. */ 501 /* NB this is matched to the hardware, don't change. */
513 u8 volatile int_status; 502 u8 volatile int_status;
514 u8 volatile int_mask; 503 u8 volatile int_mask;
@@ -524,20 +513,20 @@ struct atmel_private {
524 u16 rx_buff_size; 513 u16 rx_buff_size;
525 u16 rx_desc_pos; 514 u16 rx_desc_pos;
526 u16 rx_desc_count; 515 u16 rx_desc_count;
527 516
528 u16 build_version; 517 u16 build_version;
529 u16 command_pos; 518 u16 command_pos;
530 519
531 u16 major_version; 520 u16 major_version;
532 u16 minor_version; 521 u16 minor_version;
533 522
534 u16 func_ctrl; 523 u16 func_ctrl;
535 u16 mac_status; 524 u16 mac_status;
536 u16 generic_IRQ_type; 525 u16 generic_IRQ_type;
537 u8 reserved[2]; 526 u8 reserved[2];
538 } host_info; 527 } host_info;
539 528
540 enum { 529 enum {
541 STATION_STATE_SCANNING, 530 STATION_STATE_SCANNING,
542 STATION_STATE_JOINNING, 531 STATION_STATE_JOINNING,
543 STATION_STATE_AUTHENTICATING, 532 STATION_STATE_AUTHENTICATING,
@@ -547,7 +536,7 @@ struct atmel_private {
547 STATION_STATE_DOWN, 536 STATION_STATE_DOWN,
548 STATION_STATE_MGMT_ERROR 537 STATION_STATE_MGMT_ERROR
549 } station_state; 538 } station_state;
550 539
551 int operating_mode, power_mode; 540 int operating_mode, power_mode;
552 time_t last_qual; 541 time_t last_qual;
553 int beacons_this_sec; 542 int beacons_this_sec;
@@ -560,18 +549,18 @@ struct atmel_private {
560 int long_retry, short_retry; 549 int long_retry, short_retry;
561 int preamble; 550 int preamble;
562 int default_beacon_period, beacon_period, listen_interval; 551 int default_beacon_period, beacon_period, listen_interval;
563 int CurrentAuthentTransactionSeqNum, ExpectedAuthentTransactionSeqNum; 552 int CurrentAuthentTransactionSeqNum, ExpectedAuthentTransactionSeqNum;
564 int AuthenticationRequestRetryCnt, AssociationRequestRetryCnt, ReAssociationRequestRetryCnt; 553 int AuthenticationRequestRetryCnt, AssociationRequestRetryCnt, ReAssociationRequestRetryCnt;
565 enum { 554 enum {
566 SITE_SURVEY_IDLE, 555 SITE_SURVEY_IDLE,
567 SITE_SURVEY_IN_PROGRESS, 556 SITE_SURVEY_IN_PROGRESS,
568 SITE_SURVEY_COMPLETED 557 SITE_SURVEY_COMPLETED
569 } site_survey_state; 558 } site_survey_state;
570 time_t last_survey; 559 time_t last_survey;
571 560
572 int station_was_associated, station_is_associated; 561 int station_was_associated, station_is_associated;
573 int fast_scan; 562 int fast_scan;
574 563
575 struct bss_info { 564 struct bss_info {
576 int channel; 565 int channel;
577 int SSIDsize; 566 int SSIDsize;
@@ -584,13 +573,12 @@ struct atmel_private {
584 u8 SSID[MAX_SSID_LENGTH]; 573 u8 SSID[MAX_SSID_LENGTH];
585 } BSSinfo[MAX_BSS_ENTRIES]; 574 } BSSinfo[MAX_BSS_ENTRIES];
586 int BSS_list_entries, current_BSS; 575 int BSS_list_entries, current_BSS;
587 int connect_to_any_BSS; 576 int connect_to_any_BSS;
588 int SSID_size, new_SSID_size; 577 int SSID_size, new_SSID_size;
589 u8 CurrentBSSID[6], BSSID[6]; 578 u8 CurrentBSSID[6], BSSID[6];
590 u8 SSID[MAX_SSID_LENGTH], new_SSID[MAX_SSID_LENGTH]; 579 u8 SSID[MAX_SSID_LENGTH], new_SSID[MAX_SSID_LENGTH];
591 u64 last_beacon_timestamp; 580 u64 last_beacon_timestamp;
592 u8 rx_buf[MAX_WIRELESS_BODY]; 581 u8 rx_buf[MAX_WIRELESS_BODY];
593
594}; 582};
595 583
596static u8 atmel_basic_rates[4] = {0x82,0x84,0x0b,0x16}; 584static u8 atmel_basic_rates[4] = {0x82,0x84,0x0b,0x16};
@@ -598,39 +586,49 @@ static u8 atmel_basic_rates[4] = {0x82,0x84,0x0b,0x16};
598static const struct { 586static const struct {
599 int reg_domain; 587 int reg_domain;
600 int min, max; 588 int min, max;
601 char *name; 589 char *name;
602} channel_table[] = { { REG_DOMAIN_FCC, 1, 11, "USA" }, 590} channel_table[] = { { REG_DOMAIN_FCC, 1, 11, "USA" },
603 { REG_DOMAIN_DOC, 1, 11, "Canada" }, 591 { REG_DOMAIN_DOC, 1, 11, "Canada" },
604 { REG_DOMAIN_ETSI, 1, 13, "Europe" }, 592 { REG_DOMAIN_ETSI, 1, 13, "Europe" },
605 { REG_DOMAIN_SPAIN, 10, 11, "Spain" }, 593 { REG_DOMAIN_SPAIN, 10, 11, "Spain" },
606 { REG_DOMAIN_FRANCE, 10, 13, "France" }, 594 { REG_DOMAIN_FRANCE, 10, 13, "France" },
607 { REG_DOMAIN_MKK, 14, 14, "MKK" }, 595 { REG_DOMAIN_MKK, 14, 14, "MKK" },
608 { REG_DOMAIN_MKK1, 1, 14, "MKK1" }, 596 { REG_DOMAIN_MKK1, 1, 14, "MKK1" },
609 { REG_DOMAIN_ISRAEL, 3, 9, "Israel"} }; 597 { REG_DOMAIN_ISRAEL, 3, 9, "Israel"} };
610 598
611static void build_wpa_mib(struct atmel_private *priv); 599static void build_wpa_mib(struct atmel_private *priv);
612static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); 600static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
613static void atmel_copy_to_card(struct net_device *dev, u16 dest, unsigned char *src, u16 len); 601static void atmel_copy_to_card(struct net_device *dev, u16 dest,
614static void atmel_copy_to_host(struct net_device *dev, unsigned char *dest, u16 src, u16 len); 602 unsigned char *src, u16 len);
603static void atmel_copy_to_host(struct net_device *dev, unsigned char *dest,
604 u16 src, u16 len);
615static void atmel_set_gcr(struct net_device *dev, u16 mask); 605static void atmel_set_gcr(struct net_device *dev, u16 mask);
616static void atmel_clear_gcr(struct net_device *dev, u16 mask); 606static void atmel_clear_gcr(struct net_device *dev, u16 mask);
617static int atmel_lock_mac(struct atmel_private *priv); 607static int atmel_lock_mac(struct atmel_private *priv);
618static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data); 608static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data);
619static void atmel_command_irq(struct atmel_private *priv); 609static void atmel_command_irq(struct atmel_private *priv);
620static int atmel_validate_channel(struct atmel_private *priv, int channel); 610static int atmel_validate_channel(struct atmel_private *priv, int channel);
621static void atmel_management_frame(struct atmel_private *priv, struct ieee80211_hdr_4addr *header, 611static void atmel_management_frame(struct atmel_private *priv,
612 struct ieee80211_hdr_4addr *header,
622 u16 frame_len, u8 rssi); 613 u16 frame_len, u8 rssi);
623static void atmel_management_timer(u_long a); 614static void atmel_management_timer(u_long a);
624static void atmel_send_command(struct atmel_private *priv, int command, void *cmd, int cmd_size); 615static void atmel_send_command(struct atmel_private *priv, int command,
625static int atmel_send_command_wait(struct atmel_private *priv, int command, void *cmd, int cmd_size); 616 void *cmd, int cmd_size);
626static void atmel_transmit_management_frame(struct atmel_private *priv, struct ieee80211_hdr_4addr *header, 617static int atmel_send_command_wait(struct atmel_private *priv, int command,
618 void *cmd, int cmd_size);
619static void atmel_transmit_management_frame(struct atmel_private *priv,
620 struct ieee80211_hdr_4addr *header,
627 u8 *body, int body_len); 621 u8 *body, int body_len);
628 622
629static u8 atmel_get_mib8(struct atmel_private *priv, u8 type, u8 index); 623static u8 atmel_get_mib8(struct atmel_private *priv, u8 type, u8 index);
630static void atmel_set_mib8(struct atmel_private *priv, u8 type, u8 index, u8 data); 624static void atmel_set_mib8(struct atmel_private *priv, u8 type, u8 index,
631static void atmel_set_mib16(struct atmel_private *priv, u8 type, u8 index, u16 data); 625 u8 data);
632static void atmel_set_mib(struct atmel_private *priv, u8 type, u8 index, u8 *data, int data_len); 626static void atmel_set_mib16(struct atmel_private *priv, u8 type, u8 index,
633static void atmel_get_mib(struct atmel_private *priv, u8 type, u8 index, u8 *data, int data_len); 627 u16 data);
628static void atmel_set_mib(struct atmel_private *priv, u8 type, u8 index,
629 u8 *data, int data_len);
630static void atmel_get_mib(struct atmel_private *priv, u8 type, u8 index,
631 u8 *data, int data_len);
634static void atmel_scan(struct atmel_private *priv, int specific_ssid); 632static void atmel_scan(struct atmel_private *priv, int specific_ssid);
635static void atmel_join_bss(struct atmel_private *priv, int bss_index); 633static void atmel_join_bss(struct atmel_private *priv, int bss_index);
636static void atmel_smooth_qual(struct atmel_private *priv); 634static void atmel_smooth_qual(struct atmel_private *priv);
@@ -650,12 +648,12 @@ static inline u16 atmel_co(struct atmel_private *priv, u16 offset)
650 return priv->host_info.command_pos + offset; 648 return priv->host_info.command_pos + offset;
651} 649}
652 650
653static inline u16 atmel_rx(struct atmel_private *priv, u16 offset, u16 desc) 651static inline u16 atmel_rx(struct atmel_private *priv, u16 offset, u16 desc)
654{ 652{
655 return priv->host_info.rx_desc_pos + (sizeof(struct rx_desc) * desc) + offset; 653 return priv->host_info.rx_desc_pos + (sizeof(struct rx_desc) * desc) + offset;
656} 654}
657 655
658static inline u16 atmel_tx(struct atmel_private *priv, u16 offset, u16 desc) 656static inline u16 atmel_tx(struct atmel_private *priv, u16 offset, u16 desc)
659{ 657{
660 return priv->host_info.tx_desc_pos + (sizeof(struct tx_desc) * desc) + offset; 658 return priv->host_info.tx_desc_pos + (sizeof(struct tx_desc) * desc) + offset;
661} 659}
@@ -682,25 +680,25 @@ static inline void atmel_write16(struct net_device *dev, u16 offset, u16 data)
682 680
683static inline u8 atmel_rmem8(struct atmel_private *priv, u16 pos) 681static inline u8 atmel_rmem8(struct atmel_private *priv, u16 pos)
684{ 682{
685 atmel_writeAR(priv->dev, pos); 683 atmel_writeAR(priv->dev, pos);
686 return atmel_read8(priv->dev, DR); 684 return atmel_read8(priv->dev, DR);
687} 685}
688 686
689static inline void atmel_wmem8(struct atmel_private *priv, u16 pos, u16 data) 687static inline void atmel_wmem8(struct atmel_private *priv, u16 pos, u16 data)
690{ 688{
691 atmel_writeAR(priv->dev, pos); 689 atmel_writeAR(priv->dev, pos);
692 atmel_write8(priv->dev, DR, data); 690 atmel_write8(priv->dev, DR, data);
693} 691}
694 692
695static inline u16 atmel_rmem16(struct atmel_private *priv, u16 pos) 693static inline u16 atmel_rmem16(struct atmel_private *priv, u16 pos)
696{ 694{
697 atmel_writeAR(priv->dev, pos); 695 atmel_writeAR(priv->dev, pos);
698 return atmel_read16(priv->dev, DR); 696 return atmel_read16(priv->dev, DR);
699} 697}
700 698
701static inline void atmel_wmem16(struct atmel_private *priv, u16 pos, u16 data) 699static inline void atmel_wmem16(struct atmel_private *priv, u16 pos, u16 data)
702{ 700{
703 atmel_writeAR(priv->dev, pos); 701 atmel_writeAR(priv->dev, pos);
704 atmel_write16(priv->dev, DR, data); 702 atmel_write16(priv->dev, DR, data);
705} 703}
706 704
@@ -710,11 +708,10 @@ static void tx_done_irq(struct atmel_private *priv)
710{ 708{
711 int i; 709 int i;
712 710
713 for (i = 0; 711 for (i = 0;
714 atmel_rmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, priv->tx_desc_head)) == TX_DONE && 712 atmel_rmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, priv->tx_desc_head)) == TX_DONE &&
715 i < priv->host_info.tx_desc_count; 713 i < priv->host_info.tx_desc_count;
716 i++) { 714 i++) {
717
718 u8 status = atmel_rmem8(priv, atmel_tx(priv, TX_DESC_STATUS_OFFSET, priv->tx_desc_head)); 715 u8 status = atmel_rmem8(priv, atmel_tx(priv, TX_DESC_STATUS_OFFSET, priv->tx_desc_head));
719 u16 msdu_size = atmel_rmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, priv->tx_desc_head)); 716 u16 msdu_size = atmel_rmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, priv->tx_desc_head));
720 u8 type = atmel_rmem8(priv, atmel_tx(priv, TX_DESC_PACKET_TYPE_OFFSET, priv->tx_desc_head)); 717 u8 type = atmel_rmem8(priv, atmel_tx(priv, TX_DESC_PACKET_TYPE_OFFSET, priv->tx_desc_head));
@@ -728,16 +725,16 @@ static void tx_done_irq(struct atmel_private *priv)
728 priv->tx_buff_head = 0; 725 priv->tx_buff_head = 0;
729 else 726 else
730 priv->tx_buff_head += msdu_size; 727 priv->tx_buff_head += msdu_size;
731 728
732 if (priv->tx_desc_head < (priv->host_info.tx_desc_count - 1)) 729 if (priv->tx_desc_head < (priv->host_info.tx_desc_count - 1))
733 priv->tx_desc_head++ ; 730 priv->tx_desc_head++ ;
734 else 731 else
735 priv->tx_desc_head = 0; 732 priv->tx_desc_head = 0;
736 733
737 if (type == TX_PACKET_TYPE_DATA) { 734 if (type == TX_PACKET_TYPE_DATA) {
738 if (status == TX_STATUS_SUCCESS) 735 if (status == TX_STATUS_SUCCESS)
739 priv->stats.tx_packets++; 736 priv->stats.tx_packets++;
740 else 737 else
741 priv->stats.tx_errors++; 738 priv->stats.tx_errors++;
742 netif_wake_queue(priv->dev); 739 netif_wake_queue(priv->dev);
743 } 740 }
@@ -748,21 +745,22 @@ static u16 find_tx_buff(struct atmel_private *priv, u16 len)
748{ 745{
749 u16 bottom_free = priv->host_info.tx_buff_size - priv->tx_buff_tail; 746 u16 bottom_free = priv->host_info.tx_buff_size - priv->tx_buff_tail;
750 747
751 if (priv->tx_desc_free == 3 || priv->tx_free_mem < len) 748 if (priv->tx_desc_free == 3 || priv->tx_free_mem < len)
752 return 0; 749 return 0;
753 750
754 if (bottom_free >= len) 751 if (bottom_free >= len)
755 return priv->host_info.tx_buff_pos + priv->tx_buff_tail; 752 return priv->host_info.tx_buff_pos + priv->tx_buff_tail;
756 753
757 if (priv->tx_free_mem - bottom_free >= len) { 754 if (priv->tx_free_mem - bottom_free >= len) {
758 priv->tx_buff_tail = 0; 755 priv->tx_buff_tail = 0;
759 return priv->host_info.tx_buff_pos; 756 return priv->host_info.tx_buff_pos;
760 } 757 }
761 758
762 return 0; 759 return 0;
763} 760}
764 761
765static void tx_update_descriptor(struct atmel_private *priv, int is_bcast, u16 len, u16 buff, u8 type) 762static void tx_update_descriptor(struct atmel_private *priv, int is_bcast,
763 u16 len, u16 buff, u8 type)
766{ 764{
767 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_POS_OFFSET, priv->tx_desc_tail), buff); 765 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_POS_OFFSET, priv->tx_desc_tail), buff);
768 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, priv->tx_desc_tail), len); 766 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, priv->tx_desc_tail), len);
@@ -775,8 +773,8 @@ static void tx_update_descriptor(struct atmel_private *priv, int is_bcast, u16 l
775 int cipher_type, cipher_length; 773 int cipher_type, cipher_length;
776 if (is_bcast) { 774 if (is_bcast) {
777 cipher_type = priv->group_cipher_suite; 775 cipher_type = priv->group_cipher_suite;
778 if (cipher_type == CIPHER_SUITE_WEP_64 || 776 if (cipher_type == CIPHER_SUITE_WEP_64 ||
779 cipher_type == CIPHER_SUITE_WEP_128 ) 777 cipher_type == CIPHER_SUITE_WEP_128)
780 cipher_length = 8; 778 cipher_length = 8;
781 else if (cipher_type == CIPHER_SUITE_TKIP) 779 else if (cipher_type == CIPHER_SUITE_TKIP)
782 cipher_length = 12; 780 cipher_length = 12;
@@ -790,8 +788,8 @@ static void tx_update_descriptor(struct atmel_private *priv, int is_bcast, u16 l
790 } 788 }
791 } else { 789 } else {
792 cipher_type = priv->pairwise_cipher_suite; 790 cipher_type = priv->pairwise_cipher_suite;
793 if (cipher_type == CIPHER_SUITE_WEP_64 || 791 if (cipher_type == CIPHER_SUITE_WEP_64 ||
794 cipher_type == CIPHER_SUITE_WEP_128 ) 792 cipher_type == CIPHER_SUITE_WEP_128)
795 cipher_length = 8; 793 cipher_length = 8;
796 else if (cipher_type == CIPHER_SUITE_TKIP) 794 else if (cipher_type == CIPHER_SUITE_TKIP)
797 cipher_length = 12; 795 cipher_length = 12;
@@ -804,9 +802,9 @@ static void tx_update_descriptor(struct atmel_private *priv, int is_bcast, u16 l
804 cipher_length = 0; 802 cipher_length = 0;
805 } 803 }
806 } 804 }
807 805
808 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_CIPHER_TYPE_OFFSET, priv->tx_desc_tail), 806 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_CIPHER_TYPE_OFFSET, priv->tx_desc_tail),
809 cipher_type); 807 cipher_type);
810 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_CIPHER_LENGTH_OFFSET, priv->tx_desc_tail), 808 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_CIPHER_LENGTH_OFFSET, priv->tx_desc_tail),
811 cipher_length); 809 cipher_length);
812 } 810 }
@@ -815,46 +813,46 @@ static void tx_update_descriptor(struct atmel_private *priv, int is_bcast, u16 l
815 if (priv->tx_desc_previous != priv->tx_desc_tail) 813 if (priv->tx_desc_previous != priv->tx_desc_tail)
816 atmel_wmem32(priv, atmel_tx(priv, TX_DESC_NEXT_OFFSET, priv->tx_desc_previous), 0); 814 atmel_wmem32(priv, atmel_tx(priv, TX_DESC_NEXT_OFFSET, priv->tx_desc_previous), 0);
817 priv->tx_desc_previous = priv->tx_desc_tail; 815 priv->tx_desc_previous = priv->tx_desc_tail;
818 if (priv->tx_desc_tail < (priv->host_info.tx_desc_count -1 )) 816 if (priv->tx_desc_tail < (priv->host_info.tx_desc_count - 1))
819 priv->tx_desc_tail++; 817 priv->tx_desc_tail++;
820 else 818 else
821 priv->tx_desc_tail = 0; 819 priv->tx_desc_tail = 0;
822 priv->tx_desc_free--; 820 priv->tx_desc_free--;
823 priv->tx_free_mem -= len; 821 priv->tx_free_mem -= len;
824
825} 822}
826 823
827static int start_tx (struct sk_buff *skb, struct net_device *dev) 824static int start_tx(struct sk_buff *skb, struct net_device *dev)
828{ 825{
829 struct atmel_private *priv = netdev_priv(dev); 826 struct atmel_private *priv = netdev_priv(dev);
830 struct ieee80211_hdr_4addr header; 827 struct ieee80211_hdr_4addr header;
831 unsigned long flags; 828 unsigned long flags;
832 u16 buff, frame_ctl, len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN; 829 u16 buff, frame_ctl, len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
833 u8 SNAP_RFC1024[6] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00}; 830 u8 SNAP_RFC1024[6] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00};
834 831
835 if (priv->card && priv->present_callback && 832 if (priv->card && priv->present_callback &&
836 !(*priv->present_callback)(priv->card)) { 833 !(*priv->present_callback)(priv->card)) {
837 priv->stats.tx_errors++; 834 priv->stats.tx_errors++;
838 dev_kfree_skb(skb); 835 dev_kfree_skb(skb);
839 return 0; 836 return 0;
840 } 837 }
841 838
842 if (priv->station_state != STATION_STATE_READY) { 839 if (priv->station_state != STATION_STATE_READY) {
843 priv->stats.tx_errors++; 840 priv->stats.tx_errors++;
844 dev_kfree_skb(skb); 841 dev_kfree_skb(skb);
845 return 0; 842 return 0;
846 } 843 }
847 844
848 /* first ensure the timer func cannot run */ 845 /* first ensure the timer func cannot run */
849 spin_lock_bh(&priv->timerlock); 846 spin_lock_bh(&priv->timerlock);
850 /* then stop the hardware ISR */ 847 /* then stop the hardware ISR */
851 spin_lock_irqsave(&priv->irqlock, flags); 848 spin_lock_irqsave(&priv->irqlock, flags);
852 /* nb doing the above in the opposite order will deadlock */ 849 /* nb doing the above in the opposite order will deadlock */
853 850
854 /* The Wireless Header is 30 bytes. In the Ethernet packet we "cut" the 851 /* The Wireless Header is 30 bytes. In the Ethernet packet we "cut" the
855 12 first bytes (containing DA/SA) and put them in the appropriate fields of 852 12 first bytes (containing DA/SA) and put them in the appropriate
856 the Wireless Header. Thus the packet length is then the initial + 18 (+30-12) */ 853 fields of the Wireless Header. Thus the packet length is then the
857 854 initial + 18 (+30-12) */
855
858 if (!(buff = find_tx_buff(priv, len + 18))) { 856 if (!(buff = find_tx_buff(priv, len + 18))) {
859 priv->stats.tx_dropped++; 857 priv->stats.tx_dropped++;
860 spin_unlock_irqrestore(&priv->irqlock, flags); 858 spin_unlock_irqrestore(&priv->irqlock, flags);
@@ -862,7 +860,7 @@ static int start_tx (struct sk_buff *skb, struct net_device *dev)
862 netif_stop_queue(dev); 860 netif_stop_queue(dev);
863 return 1; 861 return 1;
864 } 862 }
865 863
866 frame_ctl = IEEE80211_FTYPE_DATA; 864 frame_ctl = IEEE80211_FTYPE_DATA;
867 header.duration_id = 0; 865 header.duration_id = 0;
868 header.seq_ctl = 0; 866 header.seq_ctl = 0;
@@ -878,7 +876,7 @@ static int start_tx (struct sk_buff *skb, struct net_device *dev)
878 memcpy(&header.addr2, dev->dev_addr, 6); 876 memcpy(&header.addr2, dev->dev_addr, 6);
879 memcpy(&header.addr3, skb->data, 6); 877 memcpy(&header.addr3, skb->data, 6);
880 } 878 }
881 879
882 if (priv->use_wpa) 880 if (priv->use_wpa)
883 memcpy(&header.addr4, SNAP_RFC1024, 6); 881 memcpy(&header.addr4, SNAP_RFC1024, 6);
884 882
@@ -888,27 +886,27 @@ static int start_tx (struct sk_buff *skb, struct net_device *dev)
888 /* Copy the packet sans its 802.3 header addresses which have been replaced */ 886 /* Copy the packet sans its 802.3 header addresses which have been replaced */
889 atmel_copy_to_card(dev, buff + DATA_FRAME_WS_HEADER_SIZE, skb->data + 12, len - 12); 887 atmel_copy_to_card(dev, buff + DATA_FRAME_WS_HEADER_SIZE, skb->data + 12, len - 12);
890 priv->tx_buff_tail += len - 12 + DATA_FRAME_WS_HEADER_SIZE; 888 priv->tx_buff_tail += len - 12 + DATA_FRAME_WS_HEADER_SIZE;
891 889
892 /* low bit of first byte of destination tells us if broadcast */ 890 /* low bit of first byte of destination tells us if broadcast */
893 tx_update_descriptor(priv, *(skb->data) & 0x01, len + 18, buff, TX_PACKET_TYPE_DATA); 891 tx_update_descriptor(priv, *(skb->data) & 0x01, len + 18, buff, TX_PACKET_TYPE_DATA);
894 dev->trans_start = jiffies; 892 dev->trans_start = jiffies;
895 priv->stats.tx_bytes += len; 893 priv->stats.tx_bytes += len;
896 894
897 spin_unlock_irqrestore(&priv->irqlock, flags); 895 spin_unlock_irqrestore(&priv->irqlock, flags);
898 spin_unlock_bh(&priv->timerlock); 896 spin_unlock_bh(&priv->timerlock);
899 dev_kfree_skb(skb); 897 dev_kfree_skb(skb);
900 898
901 return 0; 899 return 0;
902} 900}
903 901
904static void atmel_transmit_management_frame(struct atmel_private *priv, 902static void atmel_transmit_management_frame(struct atmel_private *priv,
905 struct ieee80211_hdr_4addr *header, 903 struct ieee80211_hdr_4addr *header,
906 u8 *body, int body_len) 904 u8 *body, int body_len)
907{ 905{
908 u16 buff; 906 u16 buff;
909 int len = MGMT_FRAME_BODY_OFFSET + body_len; 907 int len = MGMT_FRAME_BODY_OFFSET + body_len;
910 908
911 if (!(buff = find_tx_buff(priv, len))) 909 if (!(buff = find_tx_buff(priv, len)))
912 return; 910 return;
913 911
914 atmel_copy_to_card(priv->dev, buff, (u8 *)header, MGMT_FRAME_BODY_OFFSET); 912 atmel_copy_to_card(priv->dev, buff, (u8 *)header, MGMT_FRAME_BODY_OFFSET);
@@ -916,24 +914,25 @@ static void atmel_transmit_management_frame(struct atmel_private *priv,
916 priv->tx_buff_tail += len; 914 priv->tx_buff_tail += len;
917 tx_update_descriptor(priv, header->addr1[0] & 0x01, len, buff, TX_PACKET_TYPE_MGMT); 915 tx_update_descriptor(priv, header->addr1[0] & 0x01, len, buff, TX_PACKET_TYPE_MGMT);
918} 916}
919 917
920static void fast_rx_path(struct atmel_private *priv, struct ieee80211_hdr_4addr *header, 918static void fast_rx_path(struct atmel_private *priv,
919 struct ieee80211_hdr_4addr *header,
921 u16 msdu_size, u16 rx_packet_loc, u32 crc) 920 u16 msdu_size, u16 rx_packet_loc, u32 crc)
922{ 921{
923 /* fast path: unfragmented packet copy directly into skbuf */ 922 /* fast path: unfragmented packet copy directly into skbuf */
924 u8 mac4[6]; 923 u8 mac4[6];
925 struct sk_buff *skb; 924 struct sk_buff *skb;
926 unsigned char *skbp; 925 unsigned char *skbp;
927 926
928 /* get the final, mac 4 header field, this tells us encapsulation */ 927 /* get the final, mac 4 header field, this tells us encapsulation */
929 atmel_copy_to_host(priv->dev, mac4, rx_packet_loc + 24, 6); 928 atmel_copy_to_host(priv->dev, mac4, rx_packet_loc + 24, 6);
930 msdu_size -= 6; 929 msdu_size -= 6;
931 930
932 if (priv->do_rx_crc) { 931 if (priv->do_rx_crc) {
933 crc = crc32_le(crc, mac4, 6); 932 crc = crc32_le(crc, mac4, 6);
934 msdu_size -= 4; 933 msdu_size -= 4;
935 } 934 }
936 935
937 if (!(skb = dev_alloc_skb(msdu_size + 14))) { 936 if (!(skb = dev_alloc_skb(msdu_size + 14))) {
938 priv->stats.rx_dropped++; 937 priv->stats.rx_dropped++;
939 return; 938 return;
@@ -942,7 +941,7 @@ static void fast_rx_path(struct atmel_private *priv, struct ieee80211_hdr_4addr
942 skb_reserve(skb, 2); 941 skb_reserve(skb, 2);
943 skbp = skb_put(skb, msdu_size + 12); 942 skbp = skb_put(skb, msdu_size + 12);
944 atmel_copy_to_host(priv->dev, skbp + 12, rx_packet_loc + 30, msdu_size); 943 atmel_copy_to_host(priv->dev, skbp + 12, rx_packet_loc + 30, msdu_size);
945 944
946 if (priv->do_rx_crc) { 945 if (priv->do_rx_crc) {
947 u32 netcrc; 946 u32 netcrc;
948 crc = crc32_le(crc, skbp + 12, msdu_size); 947 crc = crc32_le(crc, skbp + 12, msdu_size);
@@ -953,24 +952,25 @@ static void fast_rx_path(struct atmel_private *priv, struct ieee80211_hdr_4addr
953 return; 952 return;
954 } 953 }
955 } 954 }
956 955
957 memcpy(skbp, header->addr1, 6); /* destination address */ 956 memcpy(skbp, header->addr1, 6); /* destination address */
958 if (le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_FROMDS) 957 if (le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_FROMDS)
959 memcpy(&skbp[6], header->addr3, 6); 958 memcpy(&skbp[6], header->addr3, 6);
960 else 959 else
961 memcpy(&skbp[6], header->addr2, 6); /* source address */ 960 memcpy(&skbp[6], header->addr2, 6); /* source address */
962 961
963 priv->dev->last_rx=jiffies; 962 priv->dev->last_rx = jiffies;
964 skb->dev = priv->dev; 963 skb->dev = priv->dev;
965 skb->protocol = eth_type_trans(skb, priv->dev); 964 skb->protocol = eth_type_trans(skb, priv->dev);
966 skb->ip_summed = CHECKSUM_NONE; 965 skb->ip_summed = CHECKSUM_NONE;
967 netif_rx(skb); 966 netif_rx(skb);
968 priv->stats.rx_bytes += 12 + msdu_size; 967 priv->stats.rx_bytes += 12 + msdu_size;
969 priv->stats.rx_packets++; 968 priv->stats.rx_packets++;
970} 969}
971 970
972/* Test to see if the packet in card memory at packet_loc has a valid CRC 971/* Test to see if the packet in card memory at packet_loc has a valid CRC
973 It doesn't matter that this is slow: it is only used to proble the first few packets. */ 972 It doesn't matter that this is slow: it is only used to proble the first few
973 packets. */
974static int probe_crc(struct atmel_private *priv, u16 packet_loc, u16 msdu_size) 974static int probe_crc(struct atmel_private *priv, u16 packet_loc, u16 msdu_size)
975{ 975{
976 int i = msdu_size - 4; 976 int i = msdu_size - 4;
@@ -980,7 +980,7 @@ static int probe_crc(struct atmel_private *priv, u16 packet_loc, u16 msdu_size)
980 return 0; 980 return 0;
981 981
982 atmel_copy_to_host(priv->dev, (void *)&netcrc, packet_loc + i, 4); 982 atmel_copy_to_host(priv->dev, (void *)&netcrc, packet_loc + i, 4);
983 983
984 atmel_writeAR(priv->dev, packet_loc); 984 atmel_writeAR(priv->dev, packet_loc);
985 while (i--) { 985 while (i--) {
986 u8 octet = atmel_read8(priv->dev, DR); 986 u8 octet = atmel_read8(priv->dev, DR);
@@ -990,20 +990,22 @@ static int probe_crc(struct atmel_private *priv, u16 packet_loc, u16 msdu_size)
990 return (crc ^ 0xffffffff) == netcrc; 990 return (crc ^ 0xffffffff) == netcrc;
991} 991}
992 992
993static void frag_rx_path(struct atmel_private *priv, struct ieee80211_hdr_4addr *header, 993static void frag_rx_path(struct atmel_private *priv,
994 u16 msdu_size, u16 rx_packet_loc, u32 crc, u16 seq_no, u8 frag_no, int more_frags) 994 struct ieee80211_hdr_4addr *header,
995 u16 msdu_size, u16 rx_packet_loc, u32 crc, u16 seq_no,
996 u8 frag_no, int more_frags)
995{ 997{
996 u8 mac4[6]; 998 u8 mac4[6];
997 u8 source[6]; 999 u8 source[6];
998 struct sk_buff *skb; 1000 struct sk_buff *skb;
999 1001
1000 if (le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_FROMDS) 1002 if (le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_FROMDS)
1001 memcpy(source, header->addr3, 6); 1003 memcpy(source, header->addr3, 6);
1002 else 1004 else
1003 memcpy(source, header->addr2, 6); 1005 memcpy(source, header->addr2, 6);
1004 1006
1005 rx_packet_loc += 24; /* skip header */ 1007 rx_packet_loc += 24; /* skip header */
1006 1008
1007 if (priv->do_rx_crc) 1009 if (priv->do_rx_crc)
1008 msdu_size -= 4; 1010 msdu_size -= 4;
1009 1011
@@ -1012,16 +1014,16 @@ static void frag_rx_path(struct atmel_private *priv, struct ieee80211_hdr_4addr
1012 msdu_size -= 6; 1014 msdu_size -= 6;
1013 rx_packet_loc += 6; 1015 rx_packet_loc += 6;
1014 1016
1015 if (priv->do_rx_crc) 1017 if (priv->do_rx_crc)
1016 crc = crc32_le(crc, mac4, 6); 1018 crc = crc32_le(crc, mac4, 6);
1017 1019
1018 priv->frag_seq = seq_no; 1020 priv->frag_seq = seq_no;
1019 priv->frag_no = 1; 1021 priv->frag_no = 1;
1020 priv->frag_len = msdu_size; 1022 priv->frag_len = msdu_size;
1021 memcpy(priv->frag_source, source, 6); 1023 memcpy(priv->frag_source, source, 6);
1022 memcpy(&priv->rx_buf[6], source, 6); 1024 memcpy(&priv->rx_buf[6], source, 6);
1023 memcpy(priv->rx_buf, header->addr1, 6); 1025 memcpy(priv->rx_buf, header->addr1, 6);
1024 1026
1025 atmel_copy_to_host(priv->dev, &priv->rx_buf[12], rx_packet_loc, msdu_size); 1027 atmel_copy_to_host(priv->dev, &priv->rx_buf[12], rx_packet_loc, msdu_size);
1026 1028
1027 if (priv->do_rx_crc) { 1029 if (priv->do_rx_crc) {
@@ -1033,17 +1035,17 @@ static void frag_rx_path(struct atmel_private *priv, struct ieee80211_hdr_4addr
1033 memset(priv->frag_source, 0xff, 6); 1035 memset(priv->frag_source, 0xff, 6);
1034 } 1036 }
1035 } 1037 }
1036 1038
1037 } else if (priv->frag_no == frag_no && 1039 } else if (priv->frag_no == frag_no &&
1038 priv->frag_seq == seq_no && 1040 priv->frag_seq == seq_no &&
1039 memcmp(priv->frag_source, source, 6) == 0) { 1041 memcmp(priv->frag_source, source, 6) == 0) {
1040 1042
1041 atmel_copy_to_host(priv->dev, &priv->rx_buf[12 + priv->frag_len], 1043 atmel_copy_to_host(priv->dev, &priv->rx_buf[12 + priv->frag_len],
1042 rx_packet_loc, msdu_size); 1044 rx_packet_loc, msdu_size);
1043 if (priv->do_rx_crc) { 1045 if (priv->do_rx_crc) {
1044 u32 netcrc; 1046 u32 netcrc;
1045 crc = crc32_le(crc, 1047 crc = crc32_le(crc,
1046 &priv->rx_buf[12 + priv->frag_len], 1048 &priv->rx_buf[12 + priv->frag_len],
1047 msdu_size); 1049 msdu_size);
1048 atmel_copy_to_host(priv->dev, (void *)&netcrc, rx_packet_loc + msdu_size, 4); 1050 atmel_copy_to_host(priv->dev, (void *)&netcrc, rx_packet_loc + msdu_size, 4);
1049 if ((crc ^ 0xffffffff) != netcrc) { 1051 if ((crc ^ 0xffffffff) != netcrc) {
@@ -1052,7 +1054,7 @@ static void frag_rx_path(struct atmel_private *priv, struct ieee80211_hdr_4addr
1052 more_frags = 1; /* don't send broken assembly */ 1054 more_frags = 1; /* don't send broken assembly */
1053 } 1055 }
1054 } 1056 }
1055 1057
1056 priv->frag_len += msdu_size; 1058 priv->frag_len += msdu_size;
1057 priv->frag_no++; 1059 priv->frag_no++;
1058 1060
@@ -1062,60 +1064,60 @@ static void frag_rx_path(struct atmel_private *priv, struct ieee80211_hdr_4addr
1062 priv->stats.rx_dropped++; 1064 priv->stats.rx_dropped++;
1063 } else { 1065 } else {
1064 skb_reserve(skb, 2); 1066 skb_reserve(skb, 2);
1065 memcpy(skb_put(skb, priv->frag_len + 12), 1067 memcpy(skb_put(skb, priv->frag_len + 12),
1066 priv->rx_buf, 1068 priv->rx_buf,
1067 priv->frag_len + 12); 1069 priv->frag_len + 12);
1068 priv->dev->last_rx = jiffies; 1070 priv->dev->last_rx = jiffies;
1069 skb->dev = priv->dev; 1071 skb->dev = priv->dev;
1070 skb->protocol = eth_type_trans(skb, priv->dev); 1072 skb->protocol = eth_type_trans(skb, priv->dev);
1071 skb->ip_summed = CHECKSUM_NONE; 1073 skb->ip_summed = CHECKSUM_NONE;
1072 netif_rx(skb); 1074 netif_rx(skb);
1073 priv->stats.rx_bytes += priv->frag_len + 12; 1075 priv->stats.rx_bytes += priv->frag_len + 12;
1074 priv->stats.rx_packets++; 1076 priv->stats.rx_packets++;
1075 } 1077 }
1076 } 1078 }
1077
1078 } else 1079 } else
1079 priv->wstats.discard.fragment++; 1080 priv->wstats.discard.fragment++;
1080} 1081}
1081 1082
1082static void rx_done_irq(struct atmel_private *priv) 1083static void rx_done_irq(struct atmel_private *priv)
1083{ 1084{
1084 int i; 1085 int i;
1085 struct ieee80211_hdr_4addr header; 1086 struct ieee80211_hdr_4addr header;
1086 1087
1087 for (i = 0; 1088 for (i = 0;
1088 atmel_rmem8(priv, atmel_rx(priv, RX_DESC_FLAGS_OFFSET, priv->rx_desc_head)) == RX_DESC_FLAG_VALID && 1089 atmel_rmem8(priv, atmel_rx(priv, RX_DESC_FLAGS_OFFSET, priv->rx_desc_head)) == RX_DESC_FLAG_VALID &&
1089 i < priv->host_info.rx_desc_count; 1090 i < priv->host_info.rx_desc_count;
1090 i++) { 1091 i++) {
1091 1092
1092 u16 msdu_size, rx_packet_loc, frame_ctl, seq_control; 1093 u16 msdu_size, rx_packet_loc, frame_ctl, seq_control;
1093 u8 status = atmel_rmem8(priv, atmel_rx(priv, RX_DESC_STATUS_OFFSET, priv->rx_desc_head)); 1094 u8 status = atmel_rmem8(priv, atmel_rx(priv, RX_DESC_STATUS_OFFSET, priv->rx_desc_head));
1094 u32 crc = 0xffffffff; 1095 u32 crc = 0xffffffff;
1095 1096
1096 if (status != RX_STATUS_SUCCESS) { 1097 if (status != RX_STATUS_SUCCESS) {
1097 if (status == 0xc1) /* determined by experiment */ 1098 if (status == 0xc1) /* determined by experiment */
1098 priv->wstats.discard.nwid++; 1099 priv->wstats.discard.nwid++;
1099 else 1100 else
1100 priv->stats.rx_errors++; 1101 priv->stats.rx_errors++;
1101 goto next; 1102 goto next;
1102 } 1103 }
1103 1104
1104 msdu_size = atmel_rmem16(priv, atmel_rx(priv, RX_DESC_MSDU_SIZE_OFFSET, priv->rx_desc_head)); 1105 msdu_size = atmel_rmem16(priv, atmel_rx(priv, RX_DESC_MSDU_SIZE_OFFSET, priv->rx_desc_head));
1105 rx_packet_loc = atmel_rmem16(priv, atmel_rx(priv, RX_DESC_MSDU_POS_OFFSET, priv->rx_desc_head)); 1106 rx_packet_loc = atmel_rmem16(priv, atmel_rx(priv, RX_DESC_MSDU_POS_OFFSET, priv->rx_desc_head));
1106 1107
1107 if (msdu_size < 30) { 1108 if (msdu_size < 30) {
1108 priv->stats.rx_errors++; 1109 priv->stats.rx_errors++;
1109 goto next; 1110 goto next;
1110 } 1111 }
1111 1112
1112 /* Get header as far as end of seq_ctl */ 1113 /* Get header as far as end of seq_ctl */
1113 atmel_copy_to_host(priv->dev, (char *)&header, rx_packet_loc, 24); 1114 atmel_copy_to_host(priv->dev, (char *)&header, rx_packet_loc, 24);
1114 frame_ctl = le16_to_cpu(header.frame_ctl); 1115 frame_ctl = le16_to_cpu(header.frame_ctl);
1115 seq_control = le16_to_cpu(header.seq_ctl); 1116 seq_control = le16_to_cpu(header.seq_ctl);
1116 1117
1117 /* probe for CRC use here if needed once five packets have arrived with 1118 /* probe for CRC use here if needed once five packets have
1118 the same crc status, we assume we know what's happening and stop probing */ 1119 arrived with the same crc status, we assume we know what's
1120 happening and stop probing */
1119 if (priv->probe_crc) { 1121 if (priv->probe_crc) {
1120 if (!priv->wep_is_on || !(frame_ctl & IEEE80211_FCTL_PROTECTED)) { 1122 if (!priv->wep_is_on || !(frame_ctl & IEEE80211_FCTL_PROTECTED)) {
1121 priv->do_rx_crc = probe_crc(priv, rx_packet_loc, msdu_size); 1123 priv->do_rx_crc = probe_crc(priv, rx_packet_loc, msdu_size);
@@ -1130,34 +1132,33 @@ static void rx_done_irq(struct atmel_private *priv)
1130 priv->probe_crc = 0; 1132 priv->probe_crc = 0;
1131 } 1133 }
1132 } 1134 }
1133 1135
1134 /* don't CRC header when WEP in use */ 1136 /* don't CRC header when WEP in use */
1135 if (priv->do_rx_crc && (!priv->wep_is_on || !(frame_ctl & IEEE80211_FCTL_PROTECTED))) { 1137 if (priv->do_rx_crc && (!priv->wep_is_on || !(frame_ctl & IEEE80211_FCTL_PROTECTED))) {
1136 crc = crc32_le(0xffffffff, (unsigned char *)&header, 24); 1138 crc = crc32_le(0xffffffff, (unsigned char *)&header, 24);
1137 } 1139 }
1138 msdu_size -= 24; /* header */ 1140 msdu_size -= 24; /* header */
1139 1141
1140 if ((frame_ctl & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA) { 1142 if ((frame_ctl & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA) {
1141
1142 int more_fragments = frame_ctl & IEEE80211_FCTL_MOREFRAGS; 1143 int more_fragments = frame_ctl & IEEE80211_FCTL_MOREFRAGS;
1143 u8 packet_fragment_no = seq_control & IEEE80211_SCTL_FRAG; 1144 u8 packet_fragment_no = seq_control & IEEE80211_SCTL_FRAG;
1144 u16 packet_sequence_no = (seq_control & IEEE80211_SCTL_SEQ) >> 4; 1145 u16 packet_sequence_no = (seq_control & IEEE80211_SCTL_SEQ) >> 4;
1145 1146
1146 if (!more_fragments && packet_fragment_no == 0 ) { 1147 if (!more_fragments && packet_fragment_no == 0) {
1147 fast_rx_path(priv, &header, msdu_size, rx_packet_loc, crc); 1148 fast_rx_path(priv, &header, msdu_size, rx_packet_loc, crc);
1148 } else { 1149 } else {
1149 frag_rx_path(priv, &header, msdu_size, rx_packet_loc, crc, 1150 frag_rx_path(priv, &header, msdu_size, rx_packet_loc, crc,
1150 packet_sequence_no, packet_fragment_no, more_fragments); 1151 packet_sequence_no, packet_fragment_no, more_fragments);
1151 } 1152 }
1152 } 1153 }
1153 1154
1154 if ((frame_ctl & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT) { 1155 if ((frame_ctl & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT) {
1155 /* copy rest of packet into buffer */ 1156 /* copy rest of packet into buffer */
1156 atmel_copy_to_host(priv->dev, (unsigned char *)&priv->rx_buf, rx_packet_loc + 24, msdu_size); 1157 atmel_copy_to_host(priv->dev, (unsigned char *)&priv->rx_buf, rx_packet_loc + 24, msdu_size);
1157 1158
1158 /* we use the same buffer for frag reassembly and control packets */ 1159 /* we use the same buffer for frag reassembly and control packets */
1159 memset(priv->frag_source, 0xff, 6); 1160 memset(priv->frag_source, 0xff, 6);
1160 1161
1161 if (priv->do_rx_crc) { 1162 if (priv->do_rx_crc) {
1162 /* last 4 octets is crc */ 1163 /* last 4 octets is crc */
1163 msdu_size -= 4; 1164 msdu_size -= 4;
@@ -1170,18 +1171,18 @@ static void rx_done_irq(struct atmel_private *priv)
1170 1171
1171 atmel_management_frame(priv, &header, msdu_size, 1172 atmel_management_frame(priv, &header, msdu_size,
1172 atmel_rmem8(priv, atmel_rx(priv, RX_DESC_RSSI_OFFSET, priv->rx_desc_head))); 1173 atmel_rmem8(priv, atmel_rx(priv, RX_DESC_RSSI_OFFSET, priv->rx_desc_head)));
1173 } 1174 }
1174 1175
1175 next: 1176next:
1176 /* release descriptor */ 1177 /* release descriptor */
1177 atmel_wmem8(priv, atmel_rx(priv, RX_DESC_FLAGS_OFFSET, priv->rx_desc_head), RX_DESC_FLAG_CONSUMED); 1178 atmel_wmem8(priv, atmel_rx(priv, RX_DESC_FLAGS_OFFSET, priv->rx_desc_head), RX_DESC_FLAG_CONSUMED);
1178 1179
1179 if (priv->rx_desc_head < (priv->host_info.rx_desc_count - 1)) 1180 if (priv->rx_desc_head < (priv->host_info.rx_desc_count - 1))
1180 priv->rx_desc_head++; 1181 priv->rx_desc_head++;
1181 else 1182 else
1182 priv->rx_desc_head = 0; 1183 priv->rx_desc_head = 0;
1183 } 1184 }
1184} 1185}
1185 1186
1186static irqreturn_t service_interrupt(int irq, void *dev_id, struct pt_regs *regs) 1187static irqreturn_t service_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1187{ 1188{
@@ -1189,7 +1190,7 @@ static irqreturn_t service_interrupt(int irq, void *dev_id, struct pt_regs *regs
1189 struct atmel_private *priv = netdev_priv(dev); 1190 struct atmel_private *priv = netdev_priv(dev);
1190 u8 isr; 1191 u8 isr;
1191 int i = -1; 1192 int i = -1;
1192 static u8 irq_order[] = { 1193 static u8 irq_order[] = {
1193 ISR_OUT_OF_RANGE, 1194 ISR_OUT_OF_RANGE,
1194 ISR_RxCOMPLETE, 1195 ISR_RxCOMPLETE,
1195 ISR_TxCOMPLETE, 1196 ISR_TxCOMPLETE,
@@ -1199,20 +1200,19 @@ static irqreturn_t service_interrupt(int irq, void *dev_id, struct pt_regs *regs
1199 ISR_IBSS_MERGE, 1200 ISR_IBSS_MERGE,
1200 ISR_GENERIC_IRQ 1201 ISR_GENERIC_IRQ
1201 }; 1202 };
1202
1203 1203
1204 if (priv->card && priv->present_callback && 1204 if (priv->card && priv->present_callback &&
1205 !(*priv->present_callback)(priv->card)) 1205 !(*priv->present_callback)(priv->card))
1206 return IRQ_HANDLED; 1206 return IRQ_HANDLED;
1207 1207
1208 /* In this state upper-level code assumes it can mess with 1208 /* In this state upper-level code assumes it can mess with
1209 the card unhampered by interrupts which may change register state. 1209 the card unhampered by interrupts which may change register state.
1210 Note that even though the card shouldn't generate interrupts 1210 Note that even though the card shouldn't generate interrupts
1211 the inturrupt line may be shared. This allows card setup 1211 the inturrupt line may be shared. This allows card setup
1212 to go on without disabling interrupts for a long time. */ 1212 to go on without disabling interrupts for a long time. */
1213 if (priv->station_state == STATION_STATE_DOWN) 1213 if (priv->station_state == STATION_STATE_DOWN)
1214 return IRQ_NONE; 1214 return IRQ_NONE;
1215 1215
1216 atmel_clear_gcr(dev, GCR_ENINT); /* disable interrupts */ 1216 atmel_clear_gcr(dev, GCR_ENINT); /* disable interrupts */
1217 1217
1218 while (1) { 1218 while (1) {
@@ -1221,36 +1221,36 @@ static irqreturn_t service_interrupt(int irq, void *dev_id, struct pt_regs *regs
1221 printk(KERN_ALERT "%s: failed to contact MAC.\n", dev->name); 1221 printk(KERN_ALERT "%s: failed to contact MAC.\n", dev->name);
1222 return IRQ_HANDLED; 1222 return IRQ_HANDLED;
1223 } 1223 }
1224 1224
1225 isr = atmel_rmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET)); 1225 isr = atmel_rmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET));
1226 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0); 1226 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0);
1227 1227
1228 if (!isr) { 1228 if (!isr) {
1229 atmel_set_gcr(dev, GCR_ENINT); /* enable interrupts */ 1229 atmel_set_gcr(dev, GCR_ENINT); /* enable interrupts */
1230 return i == -1 ? IRQ_NONE : IRQ_HANDLED; 1230 return i == -1 ? IRQ_NONE : IRQ_HANDLED;
1231 } 1231 }
1232 1232
1233 atmel_set_gcr(dev, GCR_ACKINT); /* acknowledge interrupt */ 1233 atmel_set_gcr(dev, GCR_ACKINT); /* acknowledge interrupt */
1234 1234
1235 for (i = 0; i < sizeof(irq_order)/sizeof(u8); i++) 1235 for (i = 0; i < sizeof(irq_order)/sizeof(u8); i++)
1236 if (isr & irq_order[i]) 1236 if (isr & irq_order[i])
1237 break; 1237 break;
1238 1238
1239 if (!atmel_lock_mac(priv)) { 1239 if (!atmel_lock_mac(priv)) {
1240 /* failed to contact card */ 1240 /* failed to contact card */
1241 printk(KERN_ALERT "%s: failed to contact MAC.\n", dev->name); 1241 printk(KERN_ALERT "%s: failed to contact MAC.\n", dev->name);
1242 return IRQ_HANDLED; 1242 return IRQ_HANDLED;
1243 } 1243 }
1244 1244
1245 isr = atmel_rmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET)); 1245 isr = atmel_rmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET));
1246 isr ^= irq_order[i]; 1246 isr ^= irq_order[i];
1247 atmel_wmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET), isr); 1247 atmel_wmem8(priv, atmel_hi(priv, IFACE_INT_STATUS_OFFSET), isr);
1248 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0); 1248 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0);
1249 1249
1250 switch (irq_order[i]) { 1250 switch (irq_order[i]) {
1251 1251
1252 case ISR_OUT_OF_RANGE: 1252 case ISR_OUT_OF_RANGE:
1253 if (priv->operating_mode == IW_MODE_INFRA && 1253 if (priv->operating_mode == IW_MODE_INFRA &&
1254 priv->station_state == STATION_STATE_READY) { 1254 priv->station_state == STATION_STATE_READY) {
1255 priv->station_is_associated = 0; 1255 priv->station_is_associated = 0;
1256 atmel_scan(priv, 1); 1256 atmel_scan(priv, 1);
@@ -1261,24 +1261,24 @@ static irqreturn_t service_interrupt(int irq, void *dev_id, struct pt_regs *regs
1261 priv->wstats.discard.misc++; 1261 priv->wstats.discard.misc++;
1262 /* fall through */ 1262 /* fall through */
1263 case ISR_RxCOMPLETE: 1263 case ISR_RxCOMPLETE:
1264 rx_done_irq(priv); 1264 rx_done_irq(priv);
1265 break; 1265 break;
1266 1266
1267 case ISR_TxCOMPLETE: 1267 case ISR_TxCOMPLETE:
1268 tx_done_irq(priv); 1268 tx_done_irq(priv);
1269 break; 1269 break;
1270 1270
1271 case ISR_FATAL_ERROR: 1271 case ISR_FATAL_ERROR:
1272 printk(KERN_ALERT "%s: *** FATAL error interrupt ***\n", dev->name); 1272 printk(KERN_ALERT "%s: *** FATAL error interrupt ***\n", dev->name);
1273 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR); 1273 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
1274 break; 1274 break;
1275 1275
1276 case ISR_COMMAND_COMPLETE: 1276 case ISR_COMMAND_COMPLETE:
1277 atmel_command_irq(priv); 1277 atmel_command_irq(priv);
1278 break; 1278 break;
1279 1279
1280 case ISR_IBSS_MERGE: 1280 case ISR_IBSS_MERGE:
1281 atmel_get_mib(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_CUR_BSSID_POS, 1281 atmel_get_mib(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_CUR_BSSID_POS,
1282 priv->CurrentBSSID, 6); 1282 priv->CurrentBSSID, 6);
1283 /* The WPA stuff cares about the current AP address */ 1283 /* The WPA stuff cares about the current AP address */
1284 if (priv->use_wpa) 1284 if (priv->use_wpa)
@@ -1288,24 +1288,23 @@ static irqreturn_t service_interrupt(int irq, void *dev_id, struct pt_regs *regs
1288 printk(KERN_INFO "%s: Generic_irq received.\n", dev->name); 1288 printk(KERN_INFO "%s: Generic_irq received.\n", dev->name);
1289 break; 1289 break;
1290 } 1290 }
1291 } 1291 }
1292} 1292}
1293 1293
1294 1294static struct net_device_stats *atmel_get_stats(struct net_device *dev)
1295static struct net_device_stats *atmel_get_stats (struct net_device *dev)
1296{ 1295{
1297 struct atmel_private *priv = netdev_priv(dev); 1296 struct atmel_private *priv = netdev_priv(dev);
1298 return &priv->stats; 1297 return &priv->stats;
1299} 1298}
1300 1299
1301static struct iw_statistics *atmel_get_wireless_stats (struct net_device *dev) 1300static struct iw_statistics *atmel_get_wireless_stats(struct net_device *dev)
1302{ 1301{
1303 struct atmel_private *priv = netdev_priv(dev); 1302 struct atmel_private *priv = netdev_priv(dev);
1304 1303
1305 /* update the link quality here in case we are seeing no beacons 1304 /* update the link quality here in case we are seeing no beacons
1306 at all to drive the process */ 1305 at all to drive the process */
1307 atmel_smooth_qual(priv); 1306 atmel_smooth_qual(priv);
1308 1307
1309 priv->wstats.status = priv->station_state; 1308 priv->wstats.status = priv->station_state;
1310 1309
1311 if (priv->operating_mode == IW_MODE_INFRA) { 1310 if (priv->operating_mode == IW_MODE_INFRA) {
@@ -1328,8 +1327,8 @@ static struct iw_statistics *atmel_get_wireless_stats (struct net_device *dev)
1328 | IW_QUAL_NOISE_INVALID; 1327 | IW_QUAL_NOISE_INVALID;
1329 priv->wstats.miss.beacon = 0; 1328 priv->wstats.miss.beacon = 0;
1330 } 1329 }
1331 1330
1332 return (&priv->wstats); 1331 return &priv->wstats;
1333} 1332}
1334 1333
1335static int atmel_change_mtu(struct net_device *dev, int new_mtu) 1334static int atmel_change_mtu(struct net_device *dev, int new_mtu)
@@ -1343,21 +1342,21 @@ static int atmel_change_mtu(struct net_device *dev, int new_mtu)
1343static int atmel_set_mac_address(struct net_device *dev, void *p) 1342static int atmel_set_mac_address(struct net_device *dev, void *p)
1344{ 1343{
1345 struct sockaddr *addr = p; 1344 struct sockaddr *addr = p;
1346 1345
1347 memcpy (dev->dev_addr, addr->sa_data, dev->addr_len); 1346 memcpy (dev->dev_addr, addr->sa_data, dev->addr_len);
1348 return atmel_open(dev); 1347 return atmel_open(dev);
1349} 1348}
1350 1349
1351EXPORT_SYMBOL(atmel_open); 1350EXPORT_SYMBOL(atmel_open);
1352 1351
1353int atmel_open (struct net_device *dev) 1352int atmel_open(struct net_device *dev)
1354{ 1353{
1355 struct atmel_private *priv = netdev_priv(dev); 1354 struct atmel_private *priv = netdev_priv(dev);
1356 int i, channel; 1355 int i, channel;
1357 1356
1358 /* any scheduled timer is no longer needed and might screw things up.. */ 1357 /* any scheduled timer is no longer needed and might screw things up.. */
1359 del_timer_sync(&priv->management_timer); 1358 del_timer_sync(&priv->management_timer);
1360 1359
1361 /* Interrupts will not touch the card once in this state... */ 1360 /* Interrupts will not touch the card once in this state... */
1362 priv->station_state = STATION_STATE_DOWN; 1361 priv->station_state = STATION_STATE_DOWN;
1363 1362
@@ -1377,7 +1376,7 @@ int atmel_open (struct net_device *dev)
1377 priv->site_survey_state = SITE_SURVEY_IDLE; 1376 priv->site_survey_state = SITE_SURVEY_IDLE;
1378 priv->station_is_associated = 0; 1377 priv->station_is_associated = 0;
1379 1378
1380 if (!reset_atmel_card(dev)) 1379 if (!reset_atmel_card(dev))
1381 return -EAGAIN; 1380 return -EAGAIN;
1382 1381
1383 if (priv->config_reg_domain) { 1382 if (priv->config_reg_domain) {
@@ -1391,26 +1390,26 @@ int atmel_open (struct net_device *dev)
1391 if (i == sizeof(channel_table)/sizeof(channel_table[0])) { 1390 if (i == sizeof(channel_table)/sizeof(channel_table[0])) {
1392 priv->reg_domain = REG_DOMAIN_MKK1; 1391 priv->reg_domain = REG_DOMAIN_MKK1;
1393 printk(KERN_ALERT "%s: failed to get regulatory domain: assuming MKK1.\n", dev->name); 1392 printk(KERN_ALERT "%s: failed to get regulatory domain: assuming MKK1.\n", dev->name);
1394 } 1393 }
1395 } 1394 }
1396 1395
1397 if ((channel = atmel_validate_channel(priv, priv->channel))) 1396 if ((channel = atmel_validate_channel(priv, priv->channel)))
1398 priv->channel = channel; 1397 priv->channel = channel;
1399 1398
1400 /* this moves station_state on.... */ 1399 /* this moves station_state on.... */
1401 atmel_scan(priv, 1); 1400 atmel_scan(priv, 1);
1402 1401
1403 atmel_set_gcr(priv->dev, GCR_ENINT); /* enable interrupts */ 1402 atmel_set_gcr(priv->dev, GCR_ENINT); /* enable interrupts */
1404 return 0; 1403 return 0;
1405} 1404}
1406 1405
1407static int atmel_close (struct net_device *dev) 1406static int atmel_close(struct net_device *dev)
1408{ 1407{
1409 struct atmel_private *priv = netdev_priv(dev); 1408 struct atmel_private *priv = netdev_priv(dev);
1410 1409
1411 atmel_enter_state(priv, STATION_STATE_DOWN); 1410 atmel_enter_state(priv, STATION_STATE_DOWN);
1412 1411
1413 if (priv->bus_type == BUS_TYPE_PCCARD) 1412 if (priv->bus_type == BUS_TYPE_PCCARD)
1414 atmel_write16(dev, GCR, 0x0060); 1413 atmel_write16(dev, GCR, 0x0060);
1415 atmel_write16(dev, GCR, 0x0040); 1414 atmel_write16(dev, GCR, 0x0040);
1416 return 0; 1415 return 0;
@@ -1438,43 +1437,46 @@ static int atmel_proc_output (char *buf, struct atmel_private *priv)
1438 int i; 1437 int i;
1439 char *p = buf; 1438 char *p = buf;
1440 char *s, *r, *c; 1439 char *s, *r, *c;
1441 1440
1442 p += sprintf(p, "Driver version:\t\t%d.%d\n", DRIVER_MAJOR, DRIVER_MINOR); 1441 p += sprintf(p, "Driver version:\t\t%d.%d\n",
1443 1442 DRIVER_MAJOR, DRIVER_MINOR);
1443
1444 if (priv->station_state != STATION_STATE_DOWN) { 1444 if (priv->station_state != STATION_STATE_DOWN) {
1445 p += sprintf(p, "Firmware version:\t%d.%d build %d\nFirmware location:\t", 1445 p += sprintf(p, "Firmware version:\t%d.%d build %d\n"
1446 "Firmware location:\t",
1446 priv->host_info.major_version, 1447 priv->host_info.major_version,
1447 priv->host_info.minor_version, 1448 priv->host_info.minor_version,
1448 priv->host_info.build_version); 1449 priv->host_info.build_version);
1449 1450
1450 if (priv->card_type != CARD_TYPE_EEPROM) 1451 if (priv->card_type != CARD_TYPE_EEPROM)
1451 p += sprintf(p, "on card\n"); 1452 p += sprintf(p, "on card\n");
1452 else if (priv->firmware) 1453 else if (priv->firmware)
1453 p += sprintf(p, "%s loaded by host\n", priv->firmware_id); 1454 p += sprintf(p, "%s loaded by host\n",
1455 priv->firmware_id);
1454 else 1456 else
1455 p += sprintf(p, "%s loaded by hotplug\n", priv->firmware_id); 1457 p += sprintf(p, "%s loaded by hotplug\n",
1456 1458 priv->firmware_id);
1457 switch(priv->card_type) { 1459
1460 switch (priv->card_type) {
1458 case CARD_TYPE_PARALLEL_FLASH: c = "Parallel flash"; break; 1461 case CARD_TYPE_PARALLEL_FLASH: c = "Parallel flash"; break;
1459 case CARD_TYPE_SPI_FLASH: c = "SPI flash\n"; break; 1462 case CARD_TYPE_SPI_FLASH: c = "SPI flash\n"; break;
1460 case CARD_TYPE_EEPROM: c = "EEPROM"; break; 1463 case CARD_TYPE_EEPROM: c = "EEPROM"; break;
1461 default: c = "<unknown>"; 1464 default: c = "<unknown>";
1462 } 1465 }
1463 1466
1464
1465 r = "<unknown>"; 1467 r = "<unknown>";
1466 for (i = 0; i < sizeof(channel_table)/sizeof(channel_table[0]); i++) 1468 for (i = 0; i < sizeof(channel_table)/sizeof(channel_table[0]); i++)
1467 if (priv->reg_domain == channel_table[i].reg_domain) 1469 if (priv->reg_domain == channel_table[i].reg_domain)
1468 r = channel_table[i].name; 1470 r = channel_table[i].name;
1469 1471
1470 p += sprintf(p, "MAC memory type:\t%s\n", c); 1472 p += sprintf(p, "MAC memory type:\t%s\n", c);
1471 p += sprintf(p, "Regulatory domain:\t%s\n", r); 1473 p += sprintf(p, "Regulatory domain:\t%s\n", r);
1472 p += sprintf(p, "Host CRC checking:\t%s\n", 1474 p += sprintf(p, "Host CRC checking:\t%s\n",
1473 priv->do_rx_crc ? "On" : "Off"); 1475 priv->do_rx_crc ? "On" : "Off");
1474 p += sprintf(p, "WPA-capable firmware:\t%s\n", 1476 p += sprintf(p, "WPA-capable firmware:\t%s\n",
1475 priv->use_wpa ? "Yes" : "No"); 1477 priv->use_wpa ? "Yes" : "No");
1476 } 1478 }
1477 1479
1478 switch(priv->station_state) { 1480 switch(priv->station_state) {
1479 case STATION_STATE_SCANNING: s = "Scanning"; break; 1481 case STATION_STATE_SCANNING: s = "Scanning"; break;
1480 case STATION_STATE_JOINNING: s = "Joining"; break; 1482 case STATION_STATE_JOINNING: s = "Joining"; break;
@@ -1486,9 +1488,9 @@ static int atmel_proc_output (char *buf, struct atmel_private *priv)
1486 case STATION_STATE_DOWN: s = "Down"; break; 1488 case STATION_STATE_DOWN: s = "Down"; break;
1487 default: s = "<unknown>"; 1489 default: s = "<unknown>";
1488 } 1490 }
1489 1491
1490 p += sprintf(p, "Current state:\t\t%s\n", s); 1492 p += sprintf(p, "Current state:\t\t%s\n", s);
1491 return p - buf; 1493 return p - buf;
1492} 1494}
1493 1495
1494static int atmel_read_proc(char *page, char **start, off_t off, 1496static int atmel_read_proc(char *page, char **start, off_t off,
@@ -1504,8 +1506,10 @@ static int atmel_read_proc(char *page, char **start, off_t off,
1504 return len; 1506 return len;
1505} 1507}
1506 1508
1507struct net_device *init_atmel_card( unsigned short irq, unsigned long port, const AtmelFWType fw_type, 1509struct net_device *init_atmel_card(unsigned short irq, unsigned long port,
1508 struct device *sys_dev, int (*card_present)(void *), void *card) 1510 const AtmelFWType fw_type,
1511 struct device *sys_dev,
1512 int (*card_present)(void *), void *card)
1509{ 1513{
1510 struct net_device *dev; 1514 struct net_device *dev;
1511 struct atmel_private *priv; 1515 struct atmel_private *priv;
@@ -1514,11 +1518,11 @@ struct net_device *init_atmel_card( unsigned short irq, unsigned long port, cons
1514 /* Create the network device object. */ 1518 /* Create the network device object. */
1515 dev = alloc_etherdev(sizeof(*priv)); 1519 dev = alloc_etherdev(sizeof(*priv));
1516 if (!dev) { 1520 if (!dev) {
1517 printk(KERN_ERR "atmel: Couldn't alloc_etherdev\n"); 1521 printk(KERN_ERR "atmel: Couldn't alloc_etherdev\n");
1518 return NULL; 1522 return NULL;
1519 } 1523 }
1520 if (dev_alloc_name(dev, dev->name) < 0) { 1524 if (dev_alloc_name(dev, dev->name) < 0) {
1521 printk(KERN_ERR "atmel: Couldn't get name!\n"); 1525 printk(KERN_ERR "atmel: Couldn't get name!\n");
1522 goto err_out_free; 1526 goto err_out_free;
1523 } 1527 }
1524 1528
@@ -1550,7 +1554,7 @@ struct net_device *init_atmel_card( unsigned short irq, unsigned long port, cons
1550 memset(priv->BSSID, 0, 6); 1554 memset(priv->BSSID, 0, 6);
1551 priv->CurrentBSSID[0] = 0xFF; /* Initialize to something invalid.... */ 1555 priv->CurrentBSSID[0] = 0xFF; /* Initialize to something invalid.... */
1552 priv->station_was_associated = 0; 1556 priv->station_was_associated = 0;
1553 1557
1554 priv->last_survey = jiffies; 1558 priv->last_survey = jiffies;
1555 priv->preamble = LONG_PREAMBLE; 1559 priv->preamble = LONG_PREAMBLE;
1556 priv->operating_mode = IW_MODE_INFRA; 1560 priv->operating_mode = IW_MODE_INFRA;
@@ -1586,7 +1590,7 @@ struct net_device *init_atmel_card( unsigned short irq, unsigned long port, cons
1586 spin_lock_init(&priv->timerlock); 1590 spin_lock_init(&priv->timerlock);
1587 priv->management_timer.function = atmel_management_timer; 1591 priv->management_timer.function = atmel_management_timer;
1588 priv->management_timer.data = (unsigned long) dev; 1592 priv->management_timer.data = (unsigned long) dev;
1589 1593
1590 dev->open = atmel_open; 1594 dev->open = atmel_open;
1591 dev->stop = atmel_close; 1595 dev->stop = atmel_close;
1592 dev->change_mtu = atmel_change_mtu; 1596 dev->change_mtu = atmel_change_mtu;
@@ -1597,44 +1601,44 @@ struct net_device *init_atmel_card( unsigned short irq, unsigned long port, cons
1597 dev->do_ioctl = atmel_ioctl; 1601 dev->do_ioctl = atmel_ioctl;
1598 dev->irq = irq; 1602 dev->irq = irq;
1599 dev->base_addr = port; 1603 dev->base_addr = port;
1600 1604
1601 SET_NETDEV_DEV(dev, sys_dev); 1605 SET_NETDEV_DEV(dev, sys_dev);
1602 1606
1603 if ((rc = request_irq(dev->irq, service_interrupt, SA_SHIRQ, dev->name, dev))) { 1607 if ((rc = request_irq(dev->irq, service_interrupt, SA_SHIRQ, dev->name, dev))) {
1604 printk(KERN_ERR "%s: register interrupt %d failed, rc %d\n", dev->name, irq, rc ); 1608 printk(KERN_ERR "%s: register interrupt %d failed, rc %d\n", dev->name, irq, rc);
1605 goto err_out_free; 1609 goto err_out_free;
1606 } 1610 }
1607 1611
1608 if (!request_region(dev->base_addr, 32, 1612 if (!request_region(dev->base_addr, 32,
1609 priv->bus_type == BUS_TYPE_PCCARD ? "atmel_cs" : "atmel_pci")) { 1613 priv->bus_type == BUS_TYPE_PCCARD ? "atmel_cs" : "atmel_pci")) {
1610 goto err_out_irq; 1614 goto err_out_irq;
1611 } 1615 }
1612 1616
1613 if (register_netdev(dev)) 1617 if (register_netdev(dev))
1614 goto err_out_res; 1618 goto err_out_res;
1615 1619
1616 if (!probe_atmel_card(dev)){ 1620 if (!probe_atmel_card(dev)){
1617 unregister_netdev(dev); 1621 unregister_netdev(dev);
1618 goto err_out_res; 1622 goto err_out_res;
1619 } 1623 }
1620 1624
1621 netif_carrier_off(dev); 1625 netif_carrier_off(dev);
1622 1626
1623 create_proc_read_entry ("driver/atmel", 0, NULL, atmel_read_proc, priv); 1627 create_proc_read_entry ("driver/atmel", 0, NULL, atmel_read_proc, priv);
1624 1628
1625 printk(KERN_INFO "%s: Atmel at76c50x. Version %d.%d. MAC %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n", 1629 printk(KERN_INFO "%s: Atmel at76c50x. Version %d.%d. MAC %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n",
1626 dev->name, DRIVER_MAJOR, DRIVER_MINOR, 1630 dev->name, DRIVER_MAJOR, DRIVER_MINOR,
1627 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2], 1631 dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
1628 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5] ); 1632 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5] );
1629 1633
1630 SET_MODULE_OWNER(dev); 1634 SET_MODULE_OWNER(dev);
1631 return dev; 1635 return dev;
1632 1636
1633 err_out_res: 1637err_out_res:
1634 release_region( dev->base_addr, 32); 1638 release_region( dev->base_addr, 32);
1635 err_out_irq: 1639err_out_irq:
1636 free_irq(dev->irq, dev); 1640 free_irq(dev->irq, dev);
1637 err_out_free: 1641err_out_free:
1638 free_netdev(dev); 1642 free_netdev(dev);
1639 return NULL; 1643 return NULL;
1640} 1644}
@@ -1644,12 +1648,12 @@ EXPORT_SYMBOL(init_atmel_card);
1644void stop_atmel_card(struct net_device *dev) 1648void stop_atmel_card(struct net_device *dev)
1645{ 1649{
1646 struct atmel_private *priv = netdev_priv(dev); 1650 struct atmel_private *priv = netdev_priv(dev);
1647 1651
1648 /* put a brick on it... */ 1652 /* put a brick on it... */
1649 if (priv->bus_type == BUS_TYPE_PCCARD) 1653 if (priv->bus_type == BUS_TYPE_PCCARD)
1650 atmel_write16(dev, GCR, 0x0060); 1654 atmel_write16(dev, GCR, 0x0060);
1651 atmel_write16(dev, GCR, 0x0040); 1655 atmel_write16(dev, GCR, 0x0040);
1652 1656
1653 del_timer_sync(&priv->management_timer); 1657 del_timer_sync(&priv->management_timer);
1654 unregister_netdev(dev); 1658 unregister_netdev(dev);
1655 remove_proc_entry("driver/atmel", NULL); 1659 remove_proc_entry("driver/atmel", NULL);
@@ -1675,13 +1679,13 @@ static int atmel_set_essid(struct net_device *dev,
1675 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1; 1679 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1676 1680
1677 priv->connect_to_any_BSS = 0; 1681 priv->connect_to_any_BSS = 0;
1678 1682
1679 /* Check the size of the string */ 1683 /* Check the size of the string */
1680 if (dwrq->length > MAX_SSID_LENGTH + 1) 1684 if (dwrq->length > MAX_SSID_LENGTH + 1)
1681 return -E2BIG ; 1685 return -E2BIG;
1682 if (index != 0) 1686 if (index != 0)
1683 return -EINVAL; 1687 return -EINVAL;
1684 1688
1685 memcpy(priv->new_SSID, extra, dwrq->length - 1); 1689 memcpy(priv->new_SSID, extra, dwrq->length - 1);
1686 priv->new_SSID_size = dwrq->length - 1; 1690 priv->new_SSID_size = dwrq->length - 1;
1687 } 1691 }
@@ -1706,7 +1710,7 @@ static int atmel_get_essid(struct net_device *dev,
1706 extra[priv->SSID_size] = '\0'; 1710 extra[priv->SSID_size] = '\0';
1707 dwrq->length = priv->SSID_size + 1; 1711 dwrq->length = priv->SSID_size + 1;
1708 } 1712 }
1709 1713
1710 dwrq->flags = !priv->connect_to_any_BSS; /* active */ 1714 dwrq->flags = !priv->connect_to_any_BSS; /* active */
1711 1715
1712 return 0; 1716 return 0;
@@ -1768,7 +1772,7 @@ static int atmel_set_encode(struct net_device *dev,
1768 /* WE specify that if a valid key is set, encryption 1772 /* WE specify that if a valid key is set, encryption
1769 * should be enabled (user may turn it off later) 1773 * should be enabled (user may turn it off later)
1770 * This is also how "iwconfig ethX key on" works */ 1774 * This is also how "iwconfig ethX key on" works */
1771 if (index == current_index && 1775 if (index == current_index &&
1772 priv->wep_key_len[index] > 0) { 1776 priv->wep_key_len[index] > 0) {
1773 priv->wep_is_on = 1; 1777 priv->wep_is_on = 1;
1774 priv->exclude_unencrypted = 1; 1778 priv->exclude_unencrypted = 1;
@@ -1783,18 +1787,18 @@ static int atmel_set_encode(struct net_device *dev,
1783 } else { 1787 } else {
1784 /* Do we want to just set the transmit key index ? */ 1788 /* Do we want to just set the transmit key index ? */
1785 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1; 1789 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1786 if ( index>=0 && index < 4 ) { 1790 if (index >= 0 && index < 4) {
1787 priv->default_key = index; 1791 priv->default_key = index;
1788 } else 1792 } else
1789 /* Don't complain if only change the mode */ 1793 /* Don't complain if only change the mode */
1790 if(!dwrq->flags & IW_ENCODE_MODE) { 1794 if (!dwrq->flags & IW_ENCODE_MODE) {
1791 return -EINVAL; 1795 return -EINVAL;
1792 } 1796 }
1793 } 1797 }
1794 /* Read the flags */ 1798 /* Read the flags */
1795 if(dwrq->flags & IW_ENCODE_DISABLED) { 1799 if (dwrq->flags & IW_ENCODE_DISABLED) {
1796 priv->wep_is_on = 0; 1800 priv->wep_is_on = 0;
1797 priv->encryption_level = 0; 1801 priv->encryption_level = 0;
1798 priv->pairwise_cipher_suite = CIPHER_SUITE_NONE; 1802 priv->pairwise_cipher_suite = CIPHER_SUITE_NONE;
1799 } else { 1803 } else {
1800 priv->wep_is_on = 1; 1804 priv->wep_is_on = 1;
@@ -1806,15 +1810,14 @@ static int atmel_set_encode(struct net_device *dev,
1806 priv->encryption_level = 1; 1810 priv->encryption_level = 1;
1807 } 1811 }
1808 } 1812 }
1809 if(dwrq->flags & IW_ENCODE_RESTRICTED) 1813 if (dwrq->flags & IW_ENCODE_RESTRICTED)
1810 priv->exclude_unencrypted = 1; 1814 priv->exclude_unencrypted = 1;
1811 if(dwrq->flags & IW_ENCODE_OPEN) 1815 if(dwrq->flags & IW_ENCODE_OPEN)
1812 priv->exclude_unencrypted = 0; 1816 priv->exclude_unencrypted = 0;
1813 1817
1814 return -EINPROGRESS; /* Call commit handler */ 1818 return -EINPROGRESS; /* Call commit handler */
1815} 1819}
1816 1820
1817
1818static int atmel_get_encode(struct net_device *dev, 1821static int atmel_get_encode(struct net_device *dev,
1819 struct iw_request_info *info, 1822 struct iw_request_info *info,
1820 struct iw_point *dwrq, 1823 struct iw_point *dwrq,
@@ -1822,7 +1825,7 @@ static int atmel_get_encode(struct net_device *dev,
1822{ 1825{
1823 struct atmel_private *priv = netdev_priv(dev); 1826 struct atmel_private *priv = netdev_priv(dev);
1824 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1; 1827 int index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
1825 1828
1826 if (!priv->wep_is_on) 1829 if (!priv->wep_is_on)
1827 dwrq->flags = IW_ENCODE_DISABLED; 1830 dwrq->flags = IW_ENCODE_DISABLED;
1828 else { 1831 else {
@@ -1843,7 +1846,7 @@ static int atmel_get_encode(struct net_device *dev,
1843 memset(extra, 0, 16); 1846 memset(extra, 0, 16);
1844 memcpy(extra, priv->wep_keys[index], dwrq->length); 1847 memcpy(extra, priv->wep_keys[index], dwrq->length);
1845 } 1848 }
1846 1849
1847 return 0; 1850 return 0;
1848} 1851}
1849 1852
@@ -1862,17 +1865,17 @@ static int atmel_set_rate(struct net_device *dev,
1862 char *extra) 1865 char *extra)
1863{ 1866{
1864 struct atmel_private *priv = netdev_priv(dev); 1867 struct atmel_private *priv = netdev_priv(dev);
1865 1868
1866 if (vwrq->fixed == 0) { 1869 if (vwrq->fixed == 0) {
1867 priv->tx_rate = 3; 1870 priv->tx_rate = 3;
1868 priv->auto_tx_rate = 1; 1871 priv->auto_tx_rate = 1;
1869 } else { 1872 } else {
1870 priv->auto_tx_rate = 0; 1873 priv->auto_tx_rate = 0;
1871 1874
1872 /* Which type of value ? */ 1875 /* Which type of value ? */
1873 if((vwrq->value < 4) && (vwrq->value >= 0)) { 1876 if ((vwrq->value < 4) && (vwrq->value >= 0)) {
1874 /* Setting by rate index */ 1877 /* Setting by rate index */
1875 priv->tx_rate = vwrq->value; 1878 priv->tx_rate = vwrq->value;
1876 } else { 1879 } else {
1877 /* Setting by frequency value */ 1880 /* Setting by frequency value */
1878 switch (vwrq->value) { 1881 switch (vwrq->value) {
@@ -1899,7 +1902,7 @@ static int atmel_set_mode(struct net_device *dev,
1899 return -EINVAL; 1902 return -EINVAL;
1900 1903
1901 priv->operating_mode = *uwrq; 1904 priv->operating_mode = *uwrq;
1902 return -EINPROGRESS; 1905 return -EINPROGRESS;
1903} 1906}
1904 1907
1905static int atmel_get_mode(struct net_device *dev, 1908static int atmel_get_mode(struct net_device *dev,
@@ -1908,7 +1911,7 @@ static int atmel_get_mode(struct net_device *dev,
1908 char *extra) 1911 char *extra)
1909{ 1912{
1910 struct atmel_private *priv = netdev_priv(dev); 1913 struct atmel_private *priv = netdev_priv(dev);
1911 1914
1912 *uwrq = priv->operating_mode; 1915 *uwrq = priv->operating_mode;
1913 return 0; 1916 return 0;
1914} 1917}
@@ -1962,9 +1965,9 @@ static int atmel_set_retry(struct net_device *dev,
1962 char *extra) 1965 char *extra)
1963{ 1966{
1964 struct atmel_private *priv = netdev_priv(dev); 1967 struct atmel_private *priv = netdev_priv(dev);
1965 1968
1966 if(!vwrq->disabled && (vwrq->flags & IW_RETRY_LIMIT)) { 1969 if (!vwrq->disabled && (vwrq->flags & IW_RETRY_LIMIT)) {
1967 if(vwrq->flags & IW_RETRY_MAX) 1970 if (vwrq->flags & IW_RETRY_MAX)
1968 priv->long_retry = vwrq->value; 1971 priv->long_retry = vwrq->value;
1969 else if (vwrq->flags & IW_RETRY_MIN) 1972 else if (vwrq->flags & IW_RETRY_MIN)
1970 priv->short_retry = vwrq->value; 1973 priv->short_retry = vwrq->value;
@@ -1973,9 +1976,9 @@ static int atmel_set_retry(struct net_device *dev,
1973 priv->long_retry = vwrq->value; 1976 priv->long_retry = vwrq->value;
1974 priv->short_retry = vwrq->value; 1977 priv->short_retry = vwrq->value;
1975 } 1978 }
1976 return -EINPROGRESS; 1979 return -EINPROGRESS;
1977 } 1980 }
1978 1981
1979 return -EINVAL; 1982 return -EINVAL;
1980} 1983}
1981 1984
@@ -1989,13 +1992,13 @@ static int atmel_get_retry(struct net_device *dev,
1989 vwrq->disabled = 0; /* Can't be disabled */ 1992 vwrq->disabled = 0; /* Can't be disabled */
1990 1993
1991 /* Note : by default, display the min retry number */ 1994 /* Note : by default, display the min retry number */
1992 if((vwrq->flags & IW_RETRY_MAX)) { 1995 if (vwrq->flags & IW_RETRY_MAX) {
1993 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX; 1996 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
1994 vwrq->value = priv->long_retry; 1997 vwrq->value = priv->long_retry;
1995 } else { 1998 } else {
1996 vwrq->flags = IW_RETRY_LIMIT; 1999 vwrq->flags = IW_RETRY_LIMIT;
1997 vwrq->value = priv->short_retry; 2000 vwrq->value = priv->short_retry;
1998 if(priv->long_retry != priv->short_retry) 2001 if (priv->long_retry != priv->short_retry)
1999 vwrq->flags |= IW_RETRY_MIN; 2002 vwrq->flags |= IW_RETRY_MIN;
2000 } 2003 }
2001 2004
@@ -2010,13 +2013,13 @@ static int atmel_set_rts(struct net_device *dev,
2010 struct atmel_private *priv = netdev_priv(dev); 2013 struct atmel_private *priv = netdev_priv(dev);
2011 int rthr = vwrq->value; 2014 int rthr = vwrq->value;
2012 2015
2013 if(vwrq->disabled) 2016 if (vwrq->disabled)
2014 rthr = 2347; 2017 rthr = 2347;
2015 if((rthr < 0) || (rthr > 2347)) { 2018 if ((rthr < 0) || (rthr > 2347)) {
2016 return -EINVAL; 2019 return -EINVAL;
2017 } 2020 }
2018 priv->rts_threshold = rthr; 2021 priv->rts_threshold = rthr;
2019 2022
2020 return -EINPROGRESS; /* Call commit handler */ 2023 return -EINPROGRESS; /* Call commit handler */
2021} 2024}
2022 2025
@@ -2026,7 +2029,7 @@ static int atmel_get_rts(struct net_device *dev,
2026 char *extra) 2029 char *extra)
2027{ 2030{
2028 struct atmel_private *priv = netdev_priv(dev); 2031 struct atmel_private *priv = netdev_priv(dev);
2029 2032
2030 vwrq->value = priv->rts_threshold; 2033 vwrq->value = priv->rts_threshold;
2031 vwrq->disabled = (vwrq->value >= 2347); 2034 vwrq->disabled = (vwrq->value >= 2347);
2032 vwrq->fixed = 1; 2035 vwrq->fixed = 1;
@@ -2042,14 +2045,14 @@ static int atmel_set_frag(struct net_device *dev,
2042 struct atmel_private *priv = netdev_priv(dev); 2045 struct atmel_private *priv = netdev_priv(dev);
2043 int fthr = vwrq->value; 2046 int fthr = vwrq->value;
2044 2047
2045 if(vwrq->disabled) 2048 if (vwrq->disabled)
2046 fthr = 2346; 2049 fthr = 2346;
2047 if((fthr < 256) || (fthr > 2346)) { 2050 if ((fthr < 256) || (fthr > 2346)) {
2048 return -EINVAL; 2051 return -EINVAL;
2049 } 2052 }
2050 fthr &= ~0x1; /* Get an even value - is it really needed ??? */ 2053 fthr &= ~0x1; /* Get an even value - is it really needed ??? */
2051 priv->frag_threshold = fthr; 2054 priv->frag_threshold = fthr;
2052 2055
2053 return -EINPROGRESS; /* Call commit handler */ 2056 return -EINPROGRESS; /* Call commit handler */
2054} 2057}
2055 2058
@@ -2077,21 +2080,21 @@ static int atmel_set_freq(struct net_device *dev,
2077{ 2080{
2078 struct atmel_private *priv = netdev_priv(dev); 2081 struct atmel_private *priv = netdev_priv(dev);
2079 int rc = -EINPROGRESS; /* Call commit handler */ 2082 int rc = -EINPROGRESS; /* Call commit handler */
2080 2083
2081 /* If setting by frequency, convert to a channel */ 2084 /* If setting by frequency, convert to a channel */
2082 if((fwrq->e == 1) && 2085 if ((fwrq->e == 1) &&
2083 (fwrq->m >= (int) 241200000) && 2086 (fwrq->m >= (int) 241200000) &&
2084 (fwrq->m <= (int) 248700000)) { 2087 (fwrq->m <= (int) 248700000)) {
2085 int f = fwrq->m / 100000; 2088 int f = fwrq->m / 100000;
2086 int c = 0; 2089 int c = 0;
2087 while((c < 14) && (f != frequency_list[c])) 2090 while ((c < 14) && (f != frequency_list[c]))
2088 c++; 2091 c++;
2089 /* Hack to fall through... */ 2092 /* Hack to fall through... */
2090 fwrq->e = 0; 2093 fwrq->e = 0;
2091 fwrq->m = c + 1; 2094 fwrq->m = c + 1;
2092 } 2095 }
2093 /* Setting by channel number */ 2096 /* Setting by channel number */
2094 if((fwrq->m > 1000) || (fwrq->e > 0)) 2097 if ((fwrq->m > 1000) || (fwrq->e > 0))
2095 rc = -EOPNOTSUPP; 2098 rc = -EOPNOTSUPP;
2096 else { 2099 else {
2097 int channel = fwrq->m; 2100 int channel = fwrq->m;
@@ -2099,7 +2102,7 @@ static int atmel_set_freq(struct net_device *dev,
2099 priv->channel = channel; 2102 priv->channel = channel;
2100 } else { 2103 } else {
2101 rc = -EINVAL; 2104 rc = -EINVAL;
2102 } 2105 }
2103 } 2106 }
2104 return rc; 2107 return rc;
2105} 2108}
@@ -2130,7 +2133,7 @@ static int atmel_set_scan(struct net_device *dev,
2130 * This is not an error, while the device perform scanning, 2133 * This is not an error, while the device perform scanning,
2131 * traffic doesn't flow, so it's a perfect DoS... 2134 * traffic doesn't flow, so it's a perfect DoS...
2132 * Jean II */ 2135 * Jean II */
2133 2136
2134 if (priv->station_state == STATION_STATE_DOWN) 2137 if (priv->station_state == STATION_STATE_DOWN)
2135 return -EAGAIN; 2138 return -EAGAIN;
2136 2139
@@ -2142,15 +2145,15 @@ static int atmel_set_scan(struct net_device *dev,
2142 /* Initiate a scan command */ 2145 /* Initiate a scan command */
2143 if (priv->site_survey_state == SITE_SURVEY_IN_PROGRESS) 2146 if (priv->site_survey_state == SITE_SURVEY_IN_PROGRESS)
2144 return -EBUSY; 2147 return -EBUSY;
2145 2148
2146 del_timer_sync(&priv->management_timer); 2149 del_timer_sync(&priv->management_timer);
2147 spin_lock_irqsave(&priv->irqlock, flags); 2150 spin_lock_irqsave(&priv->irqlock, flags);
2148 2151
2149 priv->site_survey_state = SITE_SURVEY_IN_PROGRESS; 2152 priv->site_survey_state = SITE_SURVEY_IN_PROGRESS;
2150 priv->fast_scan = 0; 2153 priv->fast_scan = 0;
2151 atmel_scan(priv, 0); 2154 atmel_scan(priv, 0);
2152 spin_unlock_irqrestore(&priv->irqlock, flags); 2155 spin_unlock_irqrestore(&priv->irqlock, flags);
2153 2156
2154 return 0; 2157 return 0;
2155} 2158}
2156 2159
@@ -2163,11 +2166,11 @@ static int atmel_get_scan(struct net_device *dev,
2163 int i; 2166 int i;
2164 char *current_ev = extra; 2167 char *current_ev = extra;
2165 struct iw_event iwe; 2168 struct iw_event iwe;
2166 2169
2167 if (priv->site_survey_state != SITE_SURVEY_COMPLETED) 2170 if (priv->site_survey_state != SITE_SURVEY_COMPLETED)
2168 return -EAGAIN; 2171 return -EAGAIN;
2169 2172
2170 for(i=0; i<priv->BSS_list_entries; i++) { 2173 for (i = 0; i < priv->BSS_list_entries; i++) {
2171 iwe.cmd = SIOCGIWAP; 2174 iwe.cmd = SIOCGIWAP;
2172 iwe.u.ap_addr.sa_family = ARPHRD_ETHER; 2175 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
2173 memcpy(iwe.u.ap_addr.sa_data, priv->BSSinfo[i].BSSID, 6); 2176 memcpy(iwe.u.ap_addr.sa_data, priv->BSSinfo[i].BSSID, 6);
@@ -2179,16 +2182,16 @@ static int atmel_get_scan(struct net_device *dev,
2179 iwe.cmd = SIOCGIWESSID; 2182 iwe.cmd = SIOCGIWESSID;
2180 iwe.u.data.flags = 1; 2183 iwe.u.data.flags = 1;
2181 current_ev = iwe_stream_add_point(current_ev, extra + IW_SCAN_MAX_DATA, &iwe, priv->BSSinfo[i].SSID); 2184 current_ev = iwe_stream_add_point(current_ev, extra + IW_SCAN_MAX_DATA, &iwe, priv->BSSinfo[i].SSID);
2182 2185
2183 iwe.cmd = SIOCGIWMODE; 2186 iwe.cmd = SIOCGIWMODE;
2184 iwe.u.mode = priv->BSSinfo[i].BSStype; 2187 iwe.u.mode = priv->BSSinfo[i].BSStype;
2185 current_ev = iwe_stream_add_event(current_ev, extra + IW_SCAN_MAX_DATA, &iwe, IW_EV_UINT_LEN); 2188 current_ev = iwe_stream_add_event(current_ev, extra + IW_SCAN_MAX_DATA, &iwe, IW_EV_UINT_LEN);
2186 2189
2187 iwe.cmd = SIOCGIWFREQ; 2190 iwe.cmd = SIOCGIWFREQ;
2188 iwe.u.freq.m = priv->BSSinfo[i].channel; 2191 iwe.u.freq.m = priv->BSSinfo[i].channel;
2189 iwe.u.freq.e = 0; 2192 iwe.u.freq.e = 0;
2190 current_ev = iwe_stream_add_event(current_ev, extra + IW_SCAN_MAX_DATA, &iwe, IW_EV_FREQ_LEN); 2193 current_ev = iwe_stream_add_event(current_ev, extra + IW_SCAN_MAX_DATA, &iwe, IW_EV_FREQ_LEN);
2191 2194
2192 iwe.cmd = SIOCGIWENCODE; 2195 iwe.cmd = SIOCGIWENCODE;
2193 if (priv->BSSinfo[i].UsingWEP) 2196 if (priv->BSSinfo[i].UsingWEP)
2194 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY; 2197 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
@@ -2196,13 +2199,12 @@ static int atmel_get_scan(struct net_device *dev,
2196 iwe.u.data.flags = IW_ENCODE_DISABLED; 2199 iwe.u.data.flags = IW_ENCODE_DISABLED;
2197 iwe.u.data.length = 0; 2200 iwe.u.data.length = 0;
2198 current_ev = iwe_stream_add_point(current_ev, extra + IW_SCAN_MAX_DATA, &iwe, NULL); 2201 current_ev = iwe_stream_add_point(current_ev, extra + IW_SCAN_MAX_DATA, &iwe, NULL);
2199
2200 } 2202 }
2201 2203
2202 /* Length of data */ 2204 /* Length of data */
2203 dwrq->length = (current_ev - extra); 2205 dwrq->length = (current_ev - extra);
2204 dwrq->flags = 0; 2206 dwrq->flags = 0;
2205 2207
2206 return 0; 2208 return 0;
2207} 2209}
2208 2210
@@ -2213,7 +2215,7 @@ static int atmel_get_range(struct net_device *dev,
2213{ 2215{
2214 struct atmel_private *priv = netdev_priv(dev); 2216 struct atmel_private *priv = netdev_priv(dev);
2215 struct iw_range *range = (struct iw_range *) extra; 2217 struct iw_range *range = (struct iw_range *) extra;
2216 int k,i,j; 2218 int k, i, j;
2217 2219
2218 dwrq->length = sizeof(struct iw_range); 2220 dwrq->length = sizeof(struct iw_range);
2219 memset(range, 0, sizeof(struct iw_range)); 2221 memset(range, 0, sizeof(struct iw_range));
@@ -2226,14 +2228,14 @@ static int atmel_get_range(struct net_device *dev,
2226 break; 2228 break;
2227 } 2229 }
2228 if (range->num_channels != 0) { 2230 if (range->num_channels != 0) {
2229 for(k = 0, i = channel_table[j].min; i <= channel_table[j].max; i++) { 2231 for (k = 0, i = channel_table[j].min; i <= channel_table[j].max; i++) {
2230 range->freq[k].i = i; /* List index */ 2232 range->freq[k].i = i; /* List index */
2231 range->freq[k].m = frequency_list[i-1] * 100000; 2233 range->freq[k].m = frequency_list[i - 1] * 100000;
2232 range->freq[k++].e = 1; /* Values in table in MHz -> * 10^5 * 10 */ 2234 range->freq[k++].e = 1; /* Values in table in MHz -> * 10^5 * 10 */
2233 } 2235 }
2234 range->num_frequency = k; 2236 range->num_frequency = k;
2235 } 2237 }
2236 2238
2237 range->max_qual.qual = 100; 2239 range->max_qual.qual = 100;
2238 range->max_qual.level = 100; 2240 range->max_qual.level = 100;
2239 range->max_qual.noise = 0; 2241 range->max_qual.noise = 0;
@@ -2261,11 +2263,11 @@ static int atmel_get_range(struct net_device *dev,
2261 range->encoding_size[1] = 13; 2263 range->encoding_size[1] = 13;
2262 range->num_encoding_sizes = 2; 2264 range->num_encoding_sizes = 2;
2263 range->max_encoding_tokens = 4; 2265 range->max_encoding_tokens = 4;
2264 2266
2265 range->pmp_flags = IW_POWER_ON; 2267 range->pmp_flags = IW_POWER_ON;
2266 range->pmt_flags = IW_POWER_ON; 2268 range->pmt_flags = IW_POWER_ON;
2267 range->pm_capa = 0; 2269 range->pm_capa = 0;
2268 2270
2269 range->we_version_source = WIRELESS_EXT; 2271 range->we_version_source = WIRELESS_EXT;
2270 range->we_version_compiled = WIRELESS_EXT; 2272 range->we_version_compiled = WIRELESS_EXT;
2271 range->retry_capa = IW_RETRY_LIMIT ; 2273 range->retry_capa = IW_RETRY_LIMIT ;
@@ -2289,7 +2291,7 @@ static int atmel_set_wap(struct net_device *dev,
2289 2291
2290 if (awrq->sa_family != ARPHRD_ETHER) 2292 if (awrq->sa_family != ARPHRD_ETHER)
2291 return -EINVAL; 2293 return -EINVAL;
2292 2294
2293 if (memcmp(bcast, awrq->sa_data, 6) == 0) { 2295 if (memcmp(bcast, awrq->sa_data, 6) == 0) {
2294 del_timer_sync(&priv->management_timer); 2296 del_timer_sync(&priv->management_timer);
2295 spin_lock_irqsave(&priv->irqlock, flags); 2297 spin_lock_irqsave(&priv->irqlock, flags);
@@ -2297,8 +2299,8 @@ static int atmel_set_wap(struct net_device *dev,
2297 spin_unlock_irqrestore(&priv->irqlock, flags); 2299 spin_unlock_irqrestore(&priv->irqlock, flags);
2298 return 0; 2300 return 0;
2299 } 2301 }
2300 2302
2301 for(i=0; i<priv->BSS_list_entries; i++) { 2303 for (i = 0; i < priv->BSS_list_entries; i++) {
2302 if (memcmp(priv->BSSinfo[i].BSSID, awrq->sa_data, 6) == 0) { 2304 if (memcmp(priv->BSSinfo[i].BSSID, awrq->sa_data, 6) == 0) {
2303 if (!priv->wep_is_on && priv->BSSinfo[i].UsingWEP) { 2305 if (!priv->wep_is_on && priv->BSSinfo[i].UsingWEP) {
2304 return -EINVAL; 2306 return -EINVAL;
@@ -2313,10 +2315,10 @@ static int atmel_set_wap(struct net_device *dev,
2313 } 2315 }
2314 } 2316 }
2315 } 2317 }
2316 2318
2317 return -EINVAL; 2319 return -EINVAL;
2318} 2320}
2319 2321
2320static int atmel_config_commit(struct net_device *dev, 2322static int atmel_config_commit(struct net_device *dev,
2321 struct iw_request_info *info, /* NULL */ 2323 struct iw_request_info *info, /* NULL */
2322 void *zwrq, /* NULL */ 2324 void *zwrq, /* NULL */
@@ -2325,18 +2327,18 @@ static int atmel_config_commit(struct net_device *dev,
2325 return atmel_open(dev); 2327 return atmel_open(dev);
2326} 2328}
2327 2329
2328static const iw_handler atmel_handler[] = 2330static const iw_handler atmel_handler[] =
2329{ 2331{
2330 (iw_handler) atmel_config_commit, /* SIOCSIWCOMMIT */ 2332 (iw_handler) atmel_config_commit, /* SIOCSIWCOMMIT */
2331 (iw_handler) atmel_get_name, /* SIOCGIWNAME */ 2333 (iw_handler) atmel_get_name, /* SIOCGIWNAME */
2332 (iw_handler) NULL, /* SIOCSIWNWID */ 2334 (iw_handler) NULL, /* SIOCSIWNWID */
2333 (iw_handler) NULL, /* SIOCGIWNWID */ 2335 (iw_handler) NULL, /* SIOCGIWNWID */
2334 (iw_handler) atmel_set_freq, /* SIOCSIWFREQ */ 2336 (iw_handler) atmel_set_freq, /* SIOCSIWFREQ */
2335 (iw_handler) atmel_get_freq, /* SIOCGIWFREQ */ 2337 (iw_handler) atmel_get_freq, /* SIOCGIWFREQ */
2336 (iw_handler) atmel_set_mode, /* SIOCSIWMODE */ 2338 (iw_handler) atmel_set_mode, /* SIOCSIWMODE */
2337 (iw_handler) atmel_get_mode, /* SIOCGIWMODE */ 2339 (iw_handler) atmel_get_mode, /* SIOCGIWMODE */
2338 (iw_handler) NULL, /* SIOCSIWSENS */ 2340 (iw_handler) NULL, /* SIOCSIWSENS */
2339 (iw_handler) NULL, /* SIOCGIWSENS */ 2341 (iw_handler) NULL, /* SIOCGIWSENS */
2340 (iw_handler) NULL, /* SIOCSIWRANGE */ 2342 (iw_handler) NULL, /* SIOCSIWRANGE */
2341 (iw_handler) atmel_get_range, /* SIOCGIWRANGE */ 2343 (iw_handler) atmel_get_range, /* SIOCGIWRANGE */
2342 (iw_handler) NULL, /* SIOCSIWPRIV */ 2344 (iw_handler) NULL, /* SIOCSIWPRIV */
@@ -2350,13 +2352,13 @@ static const iw_handler atmel_handler[] =
2350 (iw_handler) atmel_set_wap, /* SIOCSIWAP */ 2352 (iw_handler) atmel_set_wap, /* SIOCSIWAP */
2351 (iw_handler) atmel_get_wap, /* SIOCGIWAP */ 2353 (iw_handler) atmel_get_wap, /* SIOCGIWAP */
2352 (iw_handler) NULL, /* -- hole -- */ 2354 (iw_handler) NULL, /* -- hole -- */
2353 (iw_handler) NULL, /* SIOCGIWAPLIST */ 2355 (iw_handler) NULL, /* SIOCGIWAPLIST */
2354 (iw_handler) atmel_set_scan, /* SIOCSIWSCAN */ 2356 (iw_handler) atmel_set_scan, /* SIOCSIWSCAN */
2355 (iw_handler) atmel_get_scan, /* SIOCGIWSCAN */ 2357 (iw_handler) atmel_get_scan, /* SIOCGIWSCAN */
2356 (iw_handler) atmel_set_essid, /* SIOCSIWESSID */ 2358 (iw_handler) atmel_set_essid, /* SIOCSIWESSID */
2357 (iw_handler) atmel_get_essid, /* SIOCGIWESSID */ 2359 (iw_handler) atmel_get_essid, /* SIOCGIWESSID */
2358 (iw_handler) NULL, /* SIOCSIWNICKN */ 2360 (iw_handler) NULL, /* SIOCSIWNICKN */
2359 (iw_handler) NULL, /* SIOCGIWNICKN */ 2361 (iw_handler) NULL, /* SIOCGIWNICKN */
2360 (iw_handler) NULL, /* -- hole -- */ 2362 (iw_handler) NULL, /* -- hole -- */
2361 (iw_handler) NULL, /* -- hole -- */ 2363 (iw_handler) NULL, /* -- hole -- */
2362 (iw_handler) atmel_set_rate, /* SIOCSIWRATE */ 2364 (iw_handler) atmel_set_rate, /* SIOCSIWRATE */
@@ -2365,8 +2367,8 @@ static const iw_handler atmel_handler[] =
2365 (iw_handler) atmel_get_rts, /* SIOCGIWRTS */ 2367 (iw_handler) atmel_get_rts, /* SIOCGIWRTS */
2366 (iw_handler) atmel_set_frag, /* SIOCSIWFRAG */ 2368 (iw_handler) atmel_set_frag, /* SIOCSIWFRAG */
2367 (iw_handler) atmel_get_frag, /* SIOCGIWFRAG */ 2369 (iw_handler) atmel_get_frag, /* SIOCGIWFRAG */
2368 (iw_handler) NULL, /* SIOCSIWTXPOW */ 2370 (iw_handler) NULL, /* SIOCSIWTXPOW */
2369 (iw_handler) NULL, /* SIOCGIWTXPOW */ 2371 (iw_handler) NULL, /* SIOCGIWTXPOW */
2370 (iw_handler) atmel_set_retry, /* SIOCSIWRETRY */ 2372 (iw_handler) atmel_set_retry, /* SIOCSIWRETRY */
2371 (iw_handler) atmel_get_retry, /* SIOCGIWRETRY */ 2373 (iw_handler) atmel_get_retry, /* SIOCGIWRETRY */
2372 (iw_handler) atmel_set_encode, /* SIOCSIWENCODE */ 2374 (iw_handler) atmel_set_encode, /* SIOCSIWENCODE */
@@ -2375,39 +2377,51 @@ static const iw_handler atmel_handler[] =
2375 (iw_handler) atmel_get_power, /* SIOCGIWPOWER */ 2377 (iw_handler) atmel_get_power, /* SIOCGIWPOWER */
2376}; 2378};
2377 2379
2378 2380static const iw_handler atmel_private_handler[] =
2379static const iw_handler atmel_private_handler[] =
2380{ 2381{
2381 NULL, /* SIOCIWFIRSTPRIV */ 2382 NULL, /* SIOCIWFIRSTPRIV */
2382}; 2383};
2383 2384
2384typedef struct atmel_priv_ioctl { 2385typedef struct atmel_priv_ioctl {
2385 char id[32]; 2386 char id[32];
2386 unsigned char __user *data; 2387 unsigned char __user *data;
2387 unsigned short len; 2388 unsigned short len;
2388} atmel_priv_ioctl; 2389} atmel_priv_ioctl;
2389 2390
2390 2391#define ATMELFWL SIOCIWFIRSTPRIV
2391#define ATMELFWL SIOCIWFIRSTPRIV 2392#define ATMELIDIFC ATMELFWL + 1
2392#define ATMELIDIFC ATMELFWL + 1 2393#define ATMELRD ATMELFWL + 2
2393#define ATMELRD ATMELFWL + 2 2394#define ATMELMAGIC 0x51807
2394#define ATMELMAGIC 0x51807
2395#define REGDOMAINSZ 20 2395#define REGDOMAINSZ 20
2396 2396
2397static const struct iw_priv_args atmel_private_args[] = { 2397static const struct iw_priv_args atmel_private_args[] = {
2398/*{ cmd, set_args, get_args, name } */ 2398 {
2399 { ATMELFWL, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (atmel_priv_ioctl), IW_PRIV_TYPE_NONE, "atmelfwl" }, 2399 .cmd = ATMELFWL,
2400 { ATMELIDIFC, IW_PRIV_TYPE_NONE, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "atmelidifc" }, 2400 .set_args = IW_PRIV_TYPE_BYTE
2401 { ATMELRD, IW_PRIV_TYPE_CHAR | REGDOMAINSZ, IW_PRIV_TYPE_NONE, "regdomain" }, 2401 | IW_PRIV_SIZE_FIXED
2402 | sizeof (atmel_priv_ioctl),
2403 .get_args = IW_PRIV_TYPE_NONE,
2404 .name = "atmelfwl"
2405 }, {
2406 .cmd = ATMELIDIFC,
2407 .set_args = IW_PRIV_TYPE_NONE,
2408 .get_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
2409 .name = "atmelidifc"
2410 }, {
2411 .cmd = ATMELRD,
2412 .set_args = IW_PRIV_TYPE_CHAR | REGDOMAINSZ,
2413 .get_args = IW_PRIV_TYPE_NONE,
2414 .name = "regdomain"
2415 },
2402}; 2416};
2403 2417
2404static const struct iw_handler_def atmel_handler_def = 2418static const struct iw_handler_def atmel_handler_def =
2405{ 2419{
2406 .num_standard = sizeof(atmel_handler)/sizeof(iw_handler), 2420 .num_standard = sizeof(atmel_handler)/sizeof(iw_handler),
2407 .num_private = sizeof(atmel_private_handler)/sizeof(iw_handler), 2421 .num_private = sizeof(atmel_private_handler)/sizeof(iw_handler),
2408 .num_private_args = sizeof(atmel_private_args)/sizeof(struct iw_priv_args), 2422 .num_private_args = sizeof(atmel_private_args)/sizeof(struct iw_priv_args),
2409 .standard = (iw_handler *) atmel_handler, 2423 .standard = (iw_handler *) atmel_handler,
2410 .private = (iw_handler *) atmel_private_handler, 2424 .private = (iw_handler *) atmel_private_handler,
2411 .private_args = (struct iw_priv_args *) atmel_private_args, 2425 .private_args = (struct iw_priv_args *) atmel_private_args,
2412 .get_wireless_stats = atmel_get_wireless_stats 2426 .get_wireless_stats = atmel_get_wireless_stats
2413}; 2427};
@@ -2419,13 +2433,13 @@ static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2419 atmel_priv_ioctl com; 2433 atmel_priv_ioctl com;
2420 struct iwreq *wrq = (struct iwreq *) rq; 2434 struct iwreq *wrq = (struct iwreq *) rq;
2421 unsigned char *new_firmware; 2435 unsigned char *new_firmware;
2422 char domain[REGDOMAINSZ+1]; 2436 char domain[REGDOMAINSZ + 1];
2423 2437
2424 switch (cmd) { 2438 switch (cmd) {
2425 case ATMELIDIFC: 2439 case ATMELIDIFC:
2426 wrq->u.param.value = ATMELMAGIC; 2440 wrq->u.param.value = ATMELMAGIC;
2427 break; 2441 break;
2428 2442
2429 case ATMELFWL: 2443 case ATMELFWL:
2430 if (copy_from_user(&com, rq->ifr_data, sizeof(com))) { 2444 if (copy_from_user(&com, rq->ifr_data, sizeof(com))) {
2431 rc = -EFAULT; 2445 rc = -EFAULT;
@@ -2449,7 +2463,7 @@ static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2449 } 2463 }
2450 2464
2451 kfree(priv->firmware); 2465 kfree(priv->firmware);
2452 2466
2453 priv->firmware = new_firmware; 2467 priv->firmware = new_firmware;
2454 priv->firmware_length = com.len; 2468 priv->firmware_length = com.len;
2455 strncpy(priv->firmware_id, com.id, 31); 2469 strncpy(priv->firmware_id, com.id, 31);
@@ -2461,7 +2475,7 @@ static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2461 rc = -EFAULT; 2475 rc = -EFAULT;
2462 break; 2476 break;
2463 } 2477 }
2464 2478
2465 if (!capable(CAP_NET_ADMIN)) { 2479 if (!capable(CAP_NET_ADMIN)) {
2466 rc = -EPERM; 2480 rc = -EPERM;
2467 break; 2481 break;
@@ -2484,15 +2498,15 @@ static int atmel_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2484 rc = 0; 2498 rc = 0;
2485 } 2499 }
2486 } 2500 }
2487 2501
2488 if (rc == 0 && priv->station_state != STATION_STATE_DOWN) 2502 if (rc == 0 && priv->station_state != STATION_STATE_DOWN)
2489 rc = atmel_open(dev); 2503 rc = atmel_open(dev);
2490 break; 2504 break;
2491 2505
2492 default: 2506 default:
2493 rc = -EOPNOTSUPP; 2507 rc = -EOPNOTSUPP;
2494 } 2508 }
2495 2509
2496 return rc; 2510 return rc;
2497} 2511}
2498 2512
@@ -2503,17 +2517,17 @@ struct auth_body {
2503 u8 el_id; 2517 u8 el_id;
2504 u8 chall_text_len; 2518 u8 chall_text_len;
2505 u8 chall_text[253]; 2519 u8 chall_text[253];
2506}; 2520};
2507 2521
2508static void atmel_enter_state(struct atmel_private *priv, int new_state) 2522static void atmel_enter_state(struct atmel_private *priv, int new_state)
2509{ 2523{
2510 int old_state = priv->station_state; 2524 int old_state = priv->station_state;
2511 2525
2512 if (new_state == old_state) 2526 if (new_state == old_state)
2513 return; 2527 return;
2514 2528
2515 priv->station_state = new_state; 2529 priv->station_state = new_state;
2516 2530
2517 if (new_state == STATION_STATE_READY) { 2531 if (new_state == STATION_STATE_READY) {
2518 netif_start_queue(priv->dev); 2532 netif_start_queue(priv->dev);
2519 netif_carrier_on(priv->dev); 2533 netif_carrier_on(priv->dev);
@@ -2540,7 +2554,7 @@ static void atmel_scan(struct atmel_private *priv, int specific_ssid)
2540 u8 options; 2554 u8 options;
2541 u8 SSID_size; 2555 u8 SSID_size;
2542 } cmd; 2556 } cmd;
2543 2557
2544 memset(cmd.BSSID, 0xff, 6); 2558 memset(cmd.BSSID, 0xff, 6);
2545 2559
2546 if (priv->fast_scan) { 2560 if (priv->fast_scan) {
@@ -2554,17 +2568,17 @@ static void atmel_scan(struct atmel_private *priv, int specific_ssid)
2554 cmd.min_channel_time = cpu_to_le16(10); 2568 cmd.min_channel_time = cpu_to_le16(10);
2555 cmd.max_channel_time = cpu_to_le16(120); 2569 cmd.max_channel_time = cpu_to_le16(120);
2556 } 2570 }
2557 2571
2558 cmd.options = 0; 2572 cmd.options = 0;
2559 2573
2560 if (!specific_ssid) 2574 if (!specific_ssid)
2561 cmd.options |= SCAN_OPTIONS_SITE_SURVEY; 2575 cmd.options |= SCAN_OPTIONS_SITE_SURVEY;
2562 2576
2563 cmd.channel = (priv->channel & 0x7f); 2577 cmd.channel = (priv->channel & 0x7f);
2564 cmd.scan_type = SCAN_TYPE_ACTIVE; 2578 cmd.scan_type = SCAN_TYPE_ACTIVE;
2565 cmd.BSS_type = cpu_to_le16(priv->operating_mode == IW_MODE_ADHOC ? 2579 cmd.BSS_type = cpu_to_le16(priv->operating_mode == IW_MODE_ADHOC ?
2566 BSS_TYPE_AD_HOC : BSS_TYPE_INFRASTRUCTURE); 2580 BSS_TYPE_AD_HOC : BSS_TYPE_INFRASTRUCTURE);
2567 2581
2568 atmel_send_command(priv, CMD_Scan, &cmd, sizeof(cmd)); 2582 atmel_send_command(priv, CMD_Scan, &cmd, sizeof(cmd));
2569 2583
2570 /* This must come after all hardware access to avoid being messed up 2584 /* This must come after all hardware access to avoid being messed up
@@ -2591,16 +2605,15 @@ static void join(struct atmel_private *priv, int type)
2591 cmd.BSS_type = type; 2605 cmd.BSS_type = type;
2592 cmd.timeout = cpu_to_le16(2000); 2606 cmd.timeout = cpu_to_le16(2000);
2593 2607
2594 atmel_send_command(priv, CMD_Join, &cmd, sizeof(cmd)); 2608 atmel_send_command(priv, CMD_Join, &cmd, sizeof(cmd));
2595} 2609}
2596 2610
2597
2598static void start(struct atmel_private *priv, int type) 2611static void start(struct atmel_private *priv, int type)
2599{ 2612{
2600 struct { 2613 struct {
2601 u8 BSSID[6]; 2614 u8 BSSID[6];
2602 u8 SSID[MAX_SSID_LENGTH]; 2615 u8 SSID[MAX_SSID_LENGTH];
2603 u8 BSS_type; 2616 u8 BSS_type;
2604 u8 channel; 2617 u8 channel;
2605 u8 SSID_size; 2618 u8 SSID_size;
2606 u8 reserved[3]; 2619 u8 reserved[3];
@@ -2612,13 +2625,14 @@ static void start(struct atmel_private *priv, int type)
2612 cmd.BSS_type = type; 2625 cmd.BSS_type = type;
2613 cmd.channel = (priv->channel & 0x7f); 2626 cmd.channel = (priv->channel & 0x7f);
2614 2627
2615 atmel_send_command(priv, CMD_Start, &cmd, sizeof(cmd)); 2628 atmel_send_command(priv, CMD_Start, &cmd, sizeof(cmd));
2616} 2629}
2617 2630
2618static void handle_beacon_probe(struct atmel_private *priv, u16 capability, u8 channel) 2631static void handle_beacon_probe(struct atmel_private *priv, u16 capability,
2632 u8 channel)
2619{ 2633{
2620 int rejoin = 0; 2634 int rejoin = 0;
2621 int new = capability & C80211_MGMT_CAPABILITY_ShortPreamble ? 2635 int new = capability & C80211_MGMT_CAPABILITY_ShortPreamble ?
2622 SHORT_PREAMBLE : LONG_PREAMBLE; 2636 SHORT_PREAMBLE : LONG_PREAMBLE;
2623 2637
2624 if (priv->preamble != new) { 2638 if (priv->preamble != new) {
@@ -2626,48 +2640,48 @@ static void handle_beacon_probe(struct atmel_private *priv, u16 capability, u8 c
2626 rejoin = 1; 2640 rejoin = 1;
2627 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_PREAMBLE_TYPE, new); 2641 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_PREAMBLE_TYPE, new);
2628 } 2642 }
2629 2643
2630 if (priv->channel != channel) { 2644 if (priv->channel != channel) {
2631 priv->channel = channel; 2645 priv->channel = channel;
2632 rejoin = 1; 2646 rejoin = 1;
2633 atmel_set_mib8(priv, Phy_Mib_Type, PHY_MIB_CHANNEL_POS, channel); 2647 atmel_set_mib8(priv, Phy_Mib_Type, PHY_MIB_CHANNEL_POS, channel);
2634 } 2648 }
2635 2649
2636 if (rejoin) { 2650 if (rejoin) {
2637 priv->station_is_associated = 0; 2651 priv->station_is_associated = 0;
2638 atmel_enter_state(priv, STATION_STATE_JOINNING); 2652 atmel_enter_state(priv, STATION_STATE_JOINNING);
2639 2653
2640 if (priv->operating_mode == IW_MODE_INFRA) 2654 if (priv->operating_mode == IW_MODE_INFRA)
2641 join(priv, BSS_TYPE_INFRASTRUCTURE); 2655 join(priv, BSS_TYPE_INFRASTRUCTURE);
2642 else 2656 else
2643 join(priv, BSS_TYPE_AD_HOC); 2657 join(priv, BSS_TYPE_AD_HOC);
2644 } 2658 }
2645} 2659}
2646 2660
2647 2661static void send_authentication_request(struct atmel_private *priv, u16 system,
2648static void send_authentication_request(struct atmel_private *priv, u16 system, u8 *challenge, int challenge_len) 2662 u8 *challenge, int challenge_len)
2649{ 2663{
2650 struct ieee80211_hdr_4addr header; 2664 struct ieee80211_hdr_4addr header;
2651 struct auth_body auth; 2665 struct auth_body auth;
2652 2666
2653 header.frame_ctl = cpu_to_le16(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_AUTH); 2667 header.frame_ctl = cpu_to_le16(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_AUTH);
2654 header.duration_id = cpu_to_le16(0x8000); 2668 header.duration_id = cpu_to_le16(0x8000);
2655 header.seq_ctl = 0; 2669 header.seq_ctl = 0;
2656 memcpy(header.addr1, priv->CurrentBSSID, 6); 2670 memcpy(header.addr1, priv->CurrentBSSID, 6);
2657 memcpy(header.addr2, priv->dev->dev_addr, 6); 2671 memcpy(header.addr2, priv->dev->dev_addr, 6);
2658 memcpy(header.addr3, priv->CurrentBSSID, 6); 2672 memcpy(header.addr3, priv->CurrentBSSID, 6);
2659 2673
2660 if (priv->wep_is_on && priv->CurrentAuthentTransactionSeqNum != 1) 2674 if (priv->wep_is_on && priv->CurrentAuthentTransactionSeqNum != 1)
2661 /* no WEP for authentication frames with TrSeqNo 1 */ 2675 /* no WEP for authentication frames with TrSeqNo 1 */
2662 header.frame_ctl |= cpu_to_le16(IEEE80211_FCTL_PROTECTED); 2676 header.frame_ctl |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
2663 2677
2664 auth.alg = cpu_to_le16(system); 2678 auth.alg = cpu_to_le16(system);
2665 2679
2666 auth.status = 0; 2680 auth.status = 0;
2667 auth.trans_seq = cpu_to_le16(priv->CurrentAuthentTransactionSeqNum); 2681 auth.trans_seq = cpu_to_le16(priv->CurrentAuthentTransactionSeqNum);
2668 priv->ExpectedAuthentTransactionSeqNum = priv->CurrentAuthentTransactionSeqNum+1; 2682 priv->ExpectedAuthentTransactionSeqNum = priv->CurrentAuthentTransactionSeqNum+1;
2669 priv->CurrentAuthentTransactionSeqNum += 2; 2683 priv->CurrentAuthentTransactionSeqNum += 2;
2670 2684
2671 if (challenge_len != 0) { 2685 if (challenge_len != 0) {
2672 auth.el_id = 16; /* challenge_text */ 2686 auth.el_id = 16; /* challenge_text */
2673 auth.chall_text_len = challenge_len; 2687 auth.chall_text_len = challenge_len;
@@ -2685,7 +2699,7 @@ static void send_association_request(struct atmel_private *priv, int is_reassoc)
2685 struct ieee80211_hdr_4addr header; 2699 struct ieee80211_hdr_4addr header;
2686 struct ass_req_format { 2700 struct ass_req_format {
2687 u16 capability; 2701 u16 capability;
2688 u16 listen_interval; 2702 u16 listen_interval;
2689 u8 ap[6]; /* nothing after here directly accessible */ 2703 u8 ap[6]; /* nothing after here directly accessible */
2690 u8 ssid_el_id; 2704 u8 ssid_el_id;
2691 u8 ssid_len; 2705 u8 ssid_len;
@@ -2694,15 +2708,15 @@ static void send_association_request(struct atmel_private *priv, int is_reassoc)
2694 u8 sup_rates_len; 2708 u8 sup_rates_len;
2695 u8 rates[4]; 2709 u8 rates[4];
2696 } body; 2710 } body;
2697 2711
2698 header.frame_ctl = cpu_to_le16(IEEE80211_FTYPE_MGMT | 2712 header.frame_ctl = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2699 (is_reassoc ? IEEE80211_STYPE_REASSOC_REQ : IEEE80211_STYPE_ASSOC_REQ)); 2713 (is_reassoc ? IEEE80211_STYPE_REASSOC_REQ : IEEE80211_STYPE_ASSOC_REQ));
2700 header.duration_id = cpu_to_le16(0x8000); 2714 header.duration_id = cpu_to_le16(0x8000);
2701 header.seq_ctl = 0; 2715 header.seq_ctl = 0;
2702 2716
2703 memcpy(header.addr1, priv->CurrentBSSID, 6); 2717 memcpy(header.addr1, priv->CurrentBSSID, 6);
2704 memcpy(header.addr2, priv->dev->dev_addr, 6); 2718 memcpy(header.addr2, priv->dev->dev_addr, 6);
2705 memcpy(header.addr3, priv->CurrentBSSID, 6); 2719 memcpy(header.addr3, priv->CurrentBSSID, 6);
2706 2720
2707 body.capability = cpu_to_le16(C80211_MGMT_CAPABILITY_ESS); 2721 body.capability = cpu_to_le16(C80211_MGMT_CAPABILITY_ESS);
2708 if (priv->wep_is_on) 2722 if (priv->wep_is_on)
@@ -2711,18 +2725,18 @@ static void send_association_request(struct atmel_private *priv, int is_reassoc)
2711 body.capability |= cpu_to_le16(C80211_MGMT_CAPABILITY_ShortPreamble); 2725 body.capability |= cpu_to_le16(C80211_MGMT_CAPABILITY_ShortPreamble);
2712 2726
2713 body.listen_interval = cpu_to_le16(priv->listen_interval * priv->beacon_period); 2727 body.listen_interval = cpu_to_le16(priv->listen_interval * priv->beacon_period);
2714 2728
2715 /* current AP address - only in reassoc frame */ 2729 /* current AP address - only in reassoc frame */
2716 if (is_reassoc) { 2730 if (is_reassoc) {
2717 memcpy(body.ap, priv->CurrentBSSID, 6); 2731 memcpy(body.ap, priv->CurrentBSSID, 6);
2718 ssid_el_p = (u8 *)&body.ssid_el_id; 2732 ssid_el_p = (u8 *)&body.ssid_el_id;
2719 bodysize = 18 + priv->SSID_size; 2733 bodysize = 18 + priv->SSID_size;
2720 } else { 2734 } else {
2721 ssid_el_p = (u8 *)&body.ap[0]; 2735 ssid_el_p = (u8 *)&body.ap[0];
2722 bodysize = 12 + priv->SSID_size; 2736 bodysize = 12 + priv->SSID_size;
2723 } 2737 }
2724 2738
2725 ssid_el_p[0]= C80211_MGMT_ElementID_SSID; 2739 ssid_el_p[0] = C80211_MGMT_ElementID_SSID;
2726 ssid_el_p[1] = priv->SSID_size; 2740 ssid_el_p[1] = priv->SSID_size;
2727 memcpy(ssid_el_p + 2, priv->SSID, priv->SSID_size); 2741 memcpy(ssid_el_p + 2, priv->SSID, priv->SSID_size);
2728 ssid_el_p[2 + priv->SSID_size] = C80211_MGMT_ElementID_SupportedRates; 2742 ssid_el_p[2 + priv->SSID_size] = C80211_MGMT_ElementID_SupportedRates;
@@ -2732,7 +2746,8 @@ static void send_association_request(struct atmel_private *priv, int is_reassoc)
2732 atmel_transmit_management_frame(priv, &header, (void *)&body, bodysize); 2746 atmel_transmit_management_frame(priv, &header, (void *)&body, bodysize);
2733} 2747}
2734 2748
2735static int is_frame_from_current_bss(struct atmel_private *priv, struct ieee80211_hdr_4addr *header) 2749static int is_frame_from_current_bss(struct atmel_private *priv,
2750 struct ieee80211_hdr_4addr *header)
2736{ 2751{
2737 if (le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_FROMDS) 2752 if (le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_FROMDS)
2738 return memcmp(header->addr3, priv->CurrentBSSID, 6) == 0; 2753 return memcmp(header->addr3, priv->CurrentBSSID, 6) == 0;
@@ -2745,29 +2760,29 @@ static int retrieve_bss(struct atmel_private *priv)
2745 int i; 2760 int i;
2746 int max_rssi = -128; 2761 int max_rssi = -128;
2747 int max_index = -1; 2762 int max_index = -1;
2748 2763
2749 if (priv->BSS_list_entries == 0) 2764 if (priv->BSS_list_entries == 0)
2750 return -1; 2765 return -1;
2751 2766
2752 if (priv->connect_to_any_BSS) { 2767 if (priv->connect_to_any_BSS) {
2753 /* Select a BSS with the max-RSSI but of the same type and of the same WEP mode 2768 /* Select a BSS with the max-RSSI but of the same type and of
2754 and that it is not marked as 'bad' (i.e. we had previously failed to connect to 2769 the same WEP mode and that it is not marked as 'bad' (i.e.
2755 this BSS with the settings that we currently use) */ 2770 we had previously failed to connect to this BSS with the
2771 settings that we currently use) */
2756 priv->current_BSS = 0; 2772 priv->current_BSS = 0;
2757 for(i=0; i<priv->BSS_list_entries; i++) { 2773 for (i = 0; i < priv->BSS_list_entries; i++) {
2758 if (priv->operating_mode == priv->BSSinfo[i].BSStype && 2774 if (priv->operating_mode == priv->BSSinfo[i].BSStype &&
2759 ((!priv->wep_is_on && !priv->BSSinfo[i].UsingWEP) || 2775 ((!priv->wep_is_on && !priv->BSSinfo[i].UsingWEP) ||
2760 (priv->wep_is_on && priv->BSSinfo[i].UsingWEP)) && 2776 (priv->wep_is_on && priv->BSSinfo[i].UsingWEP)) &&
2761 !(priv->BSSinfo[i].channel & 0x80)) { 2777 !(priv->BSSinfo[i].channel & 0x80)) {
2762 max_rssi = priv->BSSinfo[i].RSSI; 2778 max_rssi = priv->BSSinfo[i].RSSI;
2763 priv->current_BSS = max_index = i; 2779 priv->current_BSS = max_index = i;
2764 } 2780 }
2765
2766 } 2781 }
2767 return max_index; 2782 return max_index;
2768 } 2783 }
2769 2784
2770 for(i=0; i<priv->BSS_list_entries; i++) { 2785 for (i = 0; i < priv->BSS_list_entries; i++) {
2771 if (priv->SSID_size == priv->BSSinfo[i].SSIDsize && 2786 if (priv->SSID_size == priv->BSSinfo[i].SSIDsize &&
2772 memcmp(priv->SSID, priv->BSSinfo[i].SSID, priv->SSID_size) == 0 && 2787 memcmp(priv->SSID, priv->BSSinfo[i].SSID, priv->SSID_size) == 0 &&
2773 priv->operating_mode == priv->BSSinfo[i].BSStype && 2788 priv->operating_mode == priv->BSSinfo[i].BSStype &&
@@ -2781,19 +2796,19 @@ static int retrieve_bss(struct atmel_private *priv)
2781 return max_index; 2796 return max_index;
2782} 2797}
2783 2798
2784 2799static void store_bss_info(struct atmel_private *priv,
2785static void store_bss_info(struct atmel_private *priv, struct ieee80211_hdr_4addr *header, 2800 struct ieee80211_hdr_4addr *header, u16 capability,
2786 u16 capability, u16 beacon_period, u8 channel, u8 rssi, 2801 u16 beacon_period, u8 channel, u8 rssi, u8 ssid_len,
2787 u8 ssid_len, u8 *ssid, int is_beacon) 2802 u8 *ssid, int is_beacon)
2788{ 2803{
2789 u8 *bss = capability & C80211_MGMT_CAPABILITY_ESS ? header->addr2 : header->addr3; 2804 u8 *bss = capability & C80211_MGMT_CAPABILITY_ESS ? header->addr2 : header->addr3;
2790 int i, index; 2805 int i, index;
2791 2806
2792 for (index = -1, i = 0; i < priv->BSS_list_entries; i++) 2807 for (index = -1, i = 0; i < priv->BSS_list_entries; i++)
2793 if (memcmp(bss, priv->BSSinfo[i].BSSID, 6) == 0) 2808 if (memcmp(bss, priv->BSSinfo[i].BSSID, 6) == 0)
2794 index = i; 2809 index = i;
2795 2810
2796 /* If we process a probe and an entry from this BSS exists 2811 /* If we process a probe and an entry from this BSS exists
2797 we will update the BSS entry with the info from this BSS. 2812 we will update the BSS entry with the info from this BSS.
2798 If we process a beacon we will only update RSSI */ 2813 If we process a beacon we will only update RSSI */
2799 2814
@@ -2820,8 +2835,8 @@ static void store_bss_info(struct atmel_private *priv, struct ieee80211_hdr_4add
2820 priv->BSSinfo[index].BSStype = IW_MODE_ADHOC; 2835 priv->BSSinfo[index].BSStype = IW_MODE_ADHOC;
2821 else if (capability & C80211_MGMT_CAPABILITY_ESS) 2836 else if (capability & C80211_MGMT_CAPABILITY_ESS)
2822 priv->BSSinfo[index].BSStype =IW_MODE_INFRA; 2837 priv->BSSinfo[index].BSStype =IW_MODE_INFRA;
2823 2838
2824 priv->BSSinfo[index].preamble = capability & C80211_MGMT_CAPABILITY_ShortPreamble ? 2839 priv->BSSinfo[index].preamble = capability & C80211_MGMT_CAPABILITY_ShortPreamble ?
2825 SHORT_PREAMBLE : LONG_PREAMBLE; 2840 SHORT_PREAMBLE : LONG_PREAMBLE;
2826} 2841}
2827 2842
@@ -2831,8 +2846,8 @@ static void authenticate(struct atmel_private *priv, u16 frame_len)
2831 u16 status = le16_to_cpu(auth->status); 2846 u16 status = le16_to_cpu(auth->status);
2832 u16 trans_seq_no = le16_to_cpu(auth->trans_seq); 2847 u16 trans_seq_no = le16_to_cpu(auth->trans_seq);
2833 u16 system = le16_to_cpu(auth->alg); 2848 u16 system = le16_to_cpu(auth->alg);
2834 2849
2835 if (status == C80211_MGMT_SC_Success && !priv->wep_is_on) { 2850 if (status == C80211_MGMT_SC_Success && !priv->wep_is_on) {
2836 /* no WEP */ 2851 /* no WEP */
2837 if (priv->station_was_associated) { 2852 if (priv->station_was_associated) {
2838 atmel_enter_state(priv, STATION_STATE_REASSOCIATING); 2853 atmel_enter_state(priv, STATION_STATE_REASSOCIATING);
@@ -2842,20 +2857,20 @@ static void authenticate(struct atmel_private *priv, u16 frame_len)
2842 atmel_enter_state(priv, STATION_STATE_ASSOCIATING); 2857 atmel_enter_state(priv, STATION_STATE_ASSOCIATING);
2843 send_association_request(priv, 0); 2858 send_association_request(priv, 0);
2844 return; 2859 return;
2845 } 2860 }
2846 } 2861 }
2847 2862
2848 if (status == C80211_MGMT_SC_Success && priv->wep_is_on) { 2863 if (status == C80211_MGMT_SC_Success && priv->wep_is_on) {
2849 /* WEP */ 2864 /* WEP */
2850 if (trans_seq_no != priv->ExpectedAuthentTransactionSeqNum) 2865 if (trans_seq_no != priv->ExpectedAuthentTransactionSeqNum)
2851 return; 2866 return;
2852 2867
2853 if (trans_seq_no == 0x0002 && 2868 if (trans_seq_no == 0x0002 &&
2854 auth->el_id == C80211_MGMT_ElementID_ChallengeText) { 2869 auth->el_id == C80211_MGMT_ElementID_ChallengeText) {
2855 send_authentication_request(priv, system, auth->chall_text, auth->chall_text_len); 2870 send_authentication_request(priv, system, auth->chall_text, auth->chall_text_len);
2856 return; 2871 return;
2857 } 2872 }
2858 2873
2859 if (trans_seq_no == 0x0004) { 2874 if (trans_seq_no == 0x0004) {
2860 if(priv->station_was_associated) { 2875 if(priv->station_was_associated) {
2861 atmel_enter_state(priv, STATION_STATE_REASSOCIATING); 2876 atmel_enter_state(priv, STATION_STATE_REASSOCIATING);
@@ -2865,10 +2880,10 @@ static void authenticate(struct atmel_private *priv, u16 frame_len)
2865 atmel_enter_state(priv, STATION_STATE_ASSOCIATING); 2880 atmel_enter_state(priv, STATION_STATE_ASSOCIATING);
2866 send_association_request(priv, 0); 2881 send_association_request(priv, 0);
2867 return; 2882 return;
2868 } 2883 }
2869 } 2884 }
2870 } 2885 }
2871 2886
2872 if (status == C80211_MGMT_SC_AuthAlgNotSupported) { 2887 if (status == C80211_MGMT_SC_AuthAlgNotSupported) {
2873 /* Do opensystem first, then try sharedkey */ 2888 /* Do opensystem first, then try sharedkey */
2874 if (system == C80211_MGMT_AAN_OPENSYSTEM) { 2889 if (system == C80211_MGMT_AAN_OPENSYSTEM) {
@@ -2876,17 +2891,16 @@ static void authenticate(struct atmel_private *priv, u16 frame_len)
2876 send_authentication_request(priv, C80211_MGMT_AAN_SHAREDKEY, NULL, 0); 2891 send_authentication_request(priv, C80211_MGMT_AAN_SHAREDKEY, NULL, 0);
2877 } else if (priv->connect_to_any_BSS) { 2892 } else if (priv->connect_to_any_BSS) {
2878 int bss_index; 2893 int bss_index;
2879 2894
2880 priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80; 2895 priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80;
2881 2896
2882 if ((bss_index = retrieve_bss(priv)) != -1) { 2897 if ((bss_index = retrieve_bss(priv)) != -1) {
2883 atmel_join_bss(priv, bss_index); 2898 atmel_join_bss(priv, bss_index);
2884 return; 2899 return;
2885 } 2900 }
2886 } 2901 }
2887 } 2902 }
2888 2903
2889
2890 priv->AuthenticationRequestRetryCnt = 0; 2904 priv->AuthenticationRequestRetryCnt = 0;
2891 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR); 2905 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
2892 priv->station_is_associated = 0; 2906 priv->station_is_associated = 0;
@@ -2902,38 +2916,44 @@ static void associate(struct atmel_private *priv, u16 frame_len, u16 subtype)
2902 u8 length; 2916 u8 length;
2903 u8 rates[4]; 2917 u8 rates[4];
2904 } *ass_resp = (struct ass_resp_format *)priv->rx_buf; 2918 } *ass_resp = (struct ass_resp_format *)priv->rx_buf;
2905 2919
2906 u16 status = le16_to_cpu(ass_resp->status); 2920 u16 status = le16_to_cpu(ass_resp->status);
2907 u16 ass_id = le16_to_cpu(ass_resp->ass_id); 2921 u16 ass_id = le16_to_cpu(ass_resp->ass_id);
2908 u16 rates_len = ass_resp->length > 4 ? 4 : ass_resp->length; 2922 u16 rates_len = ass_resp->length > 4 ? 4 : ass_resp->length;
2909 2923
2910 if (frame_len < 8 + rates_len) 2924 if (frame_len < 8 + rates_len)
2911 return; 2925 return;
2912 2926
2913 if (status == C80211_MGMT_SC_Success) { 2927 if (status == C80211_MGMT_SC_Success) {
2914 if (subtype == C80211_SUBTYPE_MGMT_ASS_RESPONSE) 2928 if (subtype == C80211_SUBTYPE_MGMT_ASS_RESPONSE)
2915 priv->AssociationRequestRetryCnt = 0; 2929 priv->AssociationRequestRetryCnt = 0;
2916 else 2930 else
2917 priv->ReAssociationRequestRetryCnt = 0; 2931 priv->ReAssociationRequestRetryCnt = 0;
2918 2932
2919 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_STATION_ID_POS, ass_id & 0x3fff); 2933 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type,
2920 atmel_set_mib(priv, Phy_Mib_Type, PHY_MIB_RATE_SET_POS, ass_resp->rates, rates_len); 2934 MAC_MGMT_MIB_STATION_ID_POS, ass_id & 0x3fff);
2935 atmel_set_mib(priv, Phy_Mib_Type,
2936 PHY_MIB_RATE_SET_POS, ass_resp->rates, rates_len);
2921 if (priv->power_mode == 0) { 2937 if (priv->power_mode == 0) {
2922 priv->listen_interval = 1; 2938 priv->listen_interval = 1;
2923 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE); 2939 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type,
2924 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1); 2940 MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE);
2941 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type,
2942 MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1);
2925 } else { 2943 } else {
2926 priv->listen_interval = 2; 2944 priv->listen_interval = 2;
2927 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_PS_MODE_POS, PS_MODE); 2945 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type,
2928 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 2); 2946 MAC_MGMT_MIB_PS_MODE_POS, PS_MODE);
2947 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type,
2948 MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 2);
2929 } 2949 }
2930 2950
2931 priv->station_is_associated = 1; 2951 priv->station_is_associated = 1;
2932 priv->station_was_associated = 1; 2952 priv->station_was_associated = 1;
2933 atmel_enter_state(priv, STATION_STATE_READY); 2953 atmel_enter_state(priv, STATION_STATE_READY);
2934 return; 2954 return;
2935 } 2955 }
2936 2956
2937 if (subtype == C80211_SUBTYPE_MGMT_ASS_RESPONSE && 2957 if (subtype == C80211_SUBTYPE_MGMT_ASS_RESPONSE &&
2938 status != C80211_MGMT_SC_AssDeniedBSSRate && 2958 status != C80211_MGMT_SC_AssDeniedBSSRate &&
2939 status != C80211_MGMT_SC_SupportCapabilities && 2959 status != C80211_MGMT_SC_SupportCapabilities &&
@@ -2943,7 +2963,7 @@ static void associate(struct atmel_private *priv, u16 frame_len, u16 subtype)
2943 send_association_request(priv, 0); 2963 send_association_request(priv, 0);
2944 return; 2964 return;
2945 } 2965 }
2946 2966
2947 if (subtype == C80211_SUBTYPE_MGMT_REASS_RESPONSE && 2967 if (subtype == C80211_SUBTYPE_MGMT_REASS_RESPONSE &&
2948 status != C80211_MGMT_SC_AssDeniedBSSRate && 2968 status != C80211_MGMT_SC_AssDeniedBSSRate &&
2949 status != C80211_MGMT_SC_SupportCapabilities && 2969 status != C80211_MGMT_SC_SupportCapabilities &&
@@ -2953,17 +2973,16 @@ static void associate(struct atmel_private *priv, u16 frame_len, u16 subtype)
2953 send_association_request(priv, 1); 2973 send_association_request(priv, 1);
2954 return; 2974 return;
2955 } 2975 }
2956 2976
2957 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR); 2977 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
2958 priv->station_is_associated = 0; 2978 priv->station_is_associated = 0;
2959 2979
2960 if(priv->connect_to_any_BSS) { 2980 if (priv->connect_to_any_BSS) {
2961 int bss_index; 2981 int bss_index;
2962 priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80; 2982 priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80;
2963 2983
2964 if ((bss_index = retrieve_bss(priv)) != -1) 2984 if ((bss_index = retrieve_bss(priv)) != -1)
2965 atmel_join_bss(priv, bss_index); 2985 atmel_join_bss(priv, bss_index);
2966
2967 } 2986 }
2968} 2987}
2969 2988
@@ -2977,7 +2996,7 @@ void atmel_join_bss(struct atmel_private *priv, int bss_index)
2977 /* The WPA stuff cares about the current AP address */ 2996 /* The WPA stuff cares about the current AP address */
2978 if (priv->use_wpa) 2997 if (priv->use_wpa)
2979 build_wpa_mib(priv); 2998 build_wpa_mib(priv);
2980 2999
2981 /* When switching to AdHoc turn OFF Power Save if needed */ 3000 /* When switching to AdHoc turn OFF Power Save if needed */
2982 3001
2983 if (bss->BSStype == IW_MODE_ADHOC && 3002 if (bss->BSStype == IW_MODE_ADHOC &&
@@ -2985,25 +3004,28 @@ void atmel_join_bss(struct atmel_private *priv, int bss_index)
2985 priv->power_mode) { 3004 priv->power_mode) {
2986 priv->power_mode = 0; 3005 priv->power_mode = 0;
2987 priv->listen_interval = 1; 3006 priv->listen_interval = 1;
2988 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE); 3007 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type,
2989 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1); 3008 MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE);
3009 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type,
3010 MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1);
2990 } 3011 }
2991 3012
2992 priv->operating_mode = bss->BSStype; 3013 priv->operating_mode = bss->BSStype;
2993 priv->channel = bss->channel & 0x7f; 3014 priv->channel = bss->channel & 0x7f;
2994 priv->beacon_period = bss->beacon_period; 3015 priv->beacon_period = bss->beacon_period;
2995 3016
2996 if (priv->preamble != bss->preamble) { 3017 if (priv->preamble != bss->preamble) {
2997 priv->preamble = bss->preamble; 3018 priv->preamble = bss->preamble;
2998 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_PREAMBLE_TYPE, bss->preamble); 3019 atmel_set_mib8(priv, Local_Mib_Type,
3020 LOCAL_MIB_PREAMBLE_TYPE, bss->preamble);
2999 } 3021 }
3000 3022
3001 if (!priv->wep_is_on && bss->UsingWEP) { 3023 if (!priv->wep_is_on && bss->UsingWEP) {
3002 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR); 3024 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3003 priv->station_is_associated = 0; 3025 priv->station_is_associated = 0;
3004 return; 3026 return;
3005 } 3027 }
3006 3028
3007 if (priv->wep_is_on && !bss->UsingWEP) { 3029 if (priv->wep_is_on && !bss->UsingWEP) {
3008 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR); 3030 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3009 priv->station_is_associated = 0; 3031 priv->station_is_associated = 0;
@@ -3011,30 +3033,28 @@ void atmel_join_bss(struct atmel_private *priv, int bss_index)
3011 } 3033 }
3012 3034
3013 atmel_enter_state(priv, STATION_STATE_JOINNING); 3035 atmel_enter_state(priv, STATION_STATE_JOINNING);
3014 3036
3015 if (priv->operating_mode == IW_MODE_INFRA) 3037 if (priv->operating_mode == IW_MODE_INFRA)
3016 join(priv, BSS_TYPE_INFRASTRUCTURE); 3038 join(priv, BSS_TYPE_INFRASTRUCTURE);
3017 else 3039 else
3018 join(priv, BSS_TYPE_AD_HOC); 3040 join(priv, BSS_TYPE_AD_HOC);
3019} 3041}
3020 3042
3021
3022static void restart_search(struct atmel_private *priv) 3043static void restart_search(struct atmel_private *priv)
3023{ 3044{
3024 int bss_index; 3045 int bss_index;
3025 3046
3026 if (!priv->connect_to_any_BSS) { 3047 if (!priv->connect_to_any_BSS) {
3027 atmel_scan(priv, 1); 3048 atmel_scan(priv, 1);
3028 } else { 3049 } else {
3029 priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80; 3050 priv->BSSinfo[(int)(priv->current_BSS)].channel |= 0x80;
3030 3051
3031 if ((bss_index = retrieve_bss(priv)) != -1) 3052 if ((bss_index = retrieve_bss(priv)) != -1)
3032 atmel_join_bss(priv, bss_index); 3053 atmel_join_bss(priv, bss_index);
3033 else 3054 else
3034 atmel_scan(priv, 0); 3055 atmel_scan(priv, 0);
3035 3056 }
3036 } 3057}
3037}
3038 3058
3039static void smooth_rssi(struct atmel_private *priv, u8 rssi) 3059static void smooth_rssi(struct atmel_private *priv, u8 rssi)
3040{ 3060{
@@ -3050,21 +3070,21 @@ static void smooth_rssi(struct atmel_private *priv, u8 rssi)
3050 } 3070 }
3051 3071
3052 rssi = rssi * 100 / max_rssi; 3072 rssi = rssi * 100 / max_rssi;
3053 if((rssi + old) % 2) 3073 if ((rssi + old) % 2)
3054 priv->wstats.qual.level = ((rssi + old)/2) + 1; 3074 priv->wstats.qual.level = (rssi + old) / 2 + 1;
3055 else 3075 else
3056 priv->wstats.qual.level = ((rssi + old)/2); 3076 priv->wstats.qual.level = (rssi + old) / 2;
3057 priv->wstats.qual.updated |= IW_QUAL_LEVEL_UPDATED; 3077 priv->wstats.qual.updated |= IW_QUAL_LEVEL_UPDATED;
3058 priv->wstats.qual.updated &= ~IW_QUAL_LEVEL_INVALID; 3078 priv->wstats.qual.updated &= ~IW_QUAL_LEVEL_INVALID;
3059} 3079}
3060 3080
3061static void atmel_smooth_qual(struct atmel_private *priv) 3081static void atmel_smooth_qual(struct atmel_private *priv)
3062{ 3082{
3063 unsigned long time_diff = (jiffies - priv->last_qual)/HZ; 3083 unsigned long time_diff = (jiffies - priv->last_qual) / HZ;
3064 while (time_diff--) { 3084 while (time_diff--) {
3065 priv->last_qual += HZ; 3085 priv->last_qual += HZ;
3066 priv->wstats.qual.qual = priv->wstats.qual.qual/2; 3086 priv->wstats.qual.qual = priv->wstats.qual.qual / 2;
3067 priv->wstats.qual.qual += 3087 priv->wstats.qual.qual +=
3068 priv->beacons_this_sec * priv->beacon_period * (priv->wstats.qual.level + 100) / 4000; 3088 priv->beacons_this_sec * priv->beacon_period * (priv->wstats.qual.level + 100) / 4000;
3069 priv->beacons_this_sec = 0; 3089 priv->beacons_this_sec = 0;
3070 } 3090 }
@@ -3073,15 +3093,17 @@ static void atmel_smooth_qual(struct atmel_private *priv)
3073} 3093}
3074 3094
3075/* deals with incoming managment frames. */ 3095/* deals with incoming managment frames. */
3076static void atmel_management_frame(struct atmel_private *priv, struct ieee80211_hdr_4addr *header, 3096static void atmel_management_frame(struct atmel_private *priv,
3077 u16 frame_len, u8 rssi) 3097 struct ieee80211_hdr_4addr *header,
3098 u16 frame_len, u8 rssi)
3078{ 3099{
3079 u16 subtype; 3100 u16 subtype;
3080 3101
3081 switch (subtype = le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_STYPE) { 3102 subtype = le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_STYPE;
3082 case C80211_SUBTYPE_MGMT_BEACON : 3103 switch (subtype) {
3104 case C80211_SUBTYPE_MGMT_BEACON:
3083 case C80211_SUBTYPE_MGMT_ProbeResponse: 3105 case C80211_SUBTYPE_MGMT_ProbeResponse:
3084 3106
3085 /* beacon frame has multiple variable-length fields - 3107 /* beacon frame has multiple variable-length fields -
3086 never let an engineer loose with a data structure design. */ 3108 never let an engineer loose with a data structure design. */
3087 { 3109 {
@@ -3099,7 +3121,7 @@ static void atmel_management_frame(struct atmel_private *priv, struct ieee80211_
3099 u8 ds_length; 3121 u8 ds_length;
3100 /* ds here */ 3122 /* ds here */
3101 } *beacon = (struct beacon_format *)priv->rx_buf; 3123 } *beacon = (struct beacon_format *)priv->rx_buf;
3102 3124
3103 u8 channel, rates_length, ssid_length; 3125 u8 channel, rates_length, ssid_length;
3104 u64 timestamp = le64_to_cpu(beacon->timestamp); 3126 u64 timestamp = le64_to_cpu(beacon->timestamp);
3105 u16 beacon_interval = le16_to_cpu(beacon->interval); 3127 u16 beacon_interval = le16_to_cpu(beacon->interval);
@@ -3107,7 +3129,7 @@ static void atmel_management_frame(struct atmel_private *priv, struct ieee80211_
3107 u8 *beaconp = priv->rx_buf; 3129 u8 *beaconp = priv->rx_buf;
3108 ssid_length = beacon->ssid_length; 3130 ssid_length = beacon->ssid_length;
3109 /* this blows chunks. */ 3131 /* this blows chunks. */
3110 if (frame_len < 14 || frame_len < ssid_length + 15) 3132 if (frame_len < 14 || frame_len < ssid_length + 15)
3111 return; 3133 return;
3112 rates_length = beaconp[beacon->ssid_length + 15]; 3134 rates_length = beaconp[beacon->ssid_length + 15];
3113 if (frame_len < ssid_length + rates_length + 18) 3135 if (frame_len < ssid_length + rates_length + 18)
@@ -3115,10 +3137,10 @@ static void atmel_management_frame(struct atmel_private *priv, struct ieee80211_
3115 if (ssid_length > MAX_SSID_LENGTH) 3137 if (ssid_length > MAX_SSID_LENGTH)
3116 return; 3138 return;
3117 channel = beaconp[ssid_length + rates_length + 18]; 3139 channel = beaconp[ssid_length + rates_length + 18];
3118 3140
3119 if (priv->station_state == STATION_STATE_READY) { 3141 if (priv->station_state == STATION_STATE_READY) {
3120 smooth_rssi(priv, rssi); 3142 smooth_rssi(priv, rssi);
3121 if (is_frame_from_current_bss(priv, header)) { 3143 if (is_frame_from_current_bss(priv, header)) {
3122 priv->beacons_this_sec++; 3144 priv->beacons_this_sec++;
3123 atmel_smooth_qual(priv); 3145 atmel_smooth_qual(priv);
3124 if (priv->last_beacon_timestamp) { 3146 if (priv->last_beacon_timestamp) {
@@ -3132,41 +3154,43 @@ static void atmel_management_frame(struct atmel_private *priv, struct ieee80211_
3132 handle_beacon_probe(priv, capability, channel); 3154 handle_beacon_probe(priv, capability, channel);
3133 } 3155 }
3134 } 3156 }
3135 3157
3136 if (priv->station_state == STATION_STATE_SCANNING ) 3158 if (priv->station_state == STATION_STATE_SCANNING)
3137 store_bss_info(priv, header, capability, beacon_interval, channel, 3159 store_bss_info(priv, header, capability,
3138 rssi, ssid_length, &beacon->rates_el_id, 3160 beacon_interval, channel, rssi,
3139 subtype == C80211_SUBTYPE_MGMT_BEACON) ; 3161 ssid_length,
3162 &beacon->rates_el_id,
3163 subtype == C80211_SUBTYPE_MGMT_BEACON);
3140 } 3164 }
3141 break; 3165 break;
3142 3166
3143 case C80211_SUBTYPE_MGMT_Authentication: 3167 case C80211_SUBTYPE_MGMT_Authentication:
3144 3168
3145 if (priv->station_state == STATION_STATE_AUTHENTICATING) 3169 if (priv->station_state == STATION_STATE_AUTHENTICATING)
3146 authenticate(priv, frame_len); 3170 authenticate(priv, frame_len);
3147 3171
3148 break; 3172 break;
3149 3173
3150 case C80211_SUBTYPE_MGMT_ASS_RESPONSE: 3174 case C80211_SUBTYPE_MGMT_ASS_RESPONSE:
3151 case C80211_SUBTYPE_MGMT_REASS_RESPONSE: 3175 case C80211_SUBTYPE_MGMT_REASS_RESPONSE:
3152 3176
3153 if (priv->station_state == STATION_STATE_ASSOCIATING || 3177 if (priv->station_state == STATION_STATE_ASSOCIATING ||
3154 priv->station_state == STATION_STATE_REASSOCIATING) 3178 priv->station_state == STATION_STATE_REASSOCIATING)
3155 associate(priv, frame_len, subtype); 3179 associate(priv, frame_len, subtype);
3156 3180
3157 break; 3181 break;
3158 3182
3159 case C80211_SUBTYPE_MGMT_DISASSOSIATION: 3183 case C80211_SUBTYPE_MGMT_DISASSOSIATION:
3160 if (priv->station_is_associated && 3184 if (priv->station_is_associated &&
3161 priv->operating_mode == IW_MODE_INFRA && 3185 priv->operating_mode == IW_MODE_INFRA &&
3162 is_frame_from_current_bss(priv, header)) { 3186 is_frame_from_current_bss(priv, header)) {
3163 priv->station_was_associated = 0; 3187 priv->station_was_associated = 0;
3164 priv->station_is_associated = 0; 3188 priv->station_is_associated = 0;
3165 3189
3166 atmel_enter_state(priv, STATION_STATE_JOINNING); 3190 atmel_enter_state(priv, STATION_STATE_JOINNING);
3167 join(priv, BSS_TYPE_INFRASTRUCTURE); 3191 join(priv, BSS_TYPE_INFRASTRUCTURE);
3168 } 3192 }
3169 3193
3170 break; 3194 break;
3171 3195
3172 case C80211_SUBTYPE_MGMT_Deauthentication: 3196 case C80211_SUBTYPE_MGMT_Deauthentication:
@@ -3177,7 +3201,7 @@ static void atmel_management_frame(struct atmel_private *priv, struct ieee80211_
3177 atmel_enter_state(priv, STATION_STATE_JOINNING); 3201 atmel_enter_state(priv, STATION_STATE_JOINNING);
3178 join(priv, BSS_TYPE_INFRASTRUCTURE); 3202 join(priv, BSS_TYPE_INFRASTRUCTURE);
3179 } 3203 }
3180 3204
3181 break; 3205 break;
3182 } 3206 }
3183} 3207}
@@ -3185,76 +3209,73 @@ static void atmel_management_frame(struct atmel_private *priv, struct ieee80211_
3185/* run when timer expires */ 3209/* run when timer expires */
3186static void atmel_management_timer(u_long a) 3210static void atmel_management_timer(u_long a)
3187{ 3211{
3188 struct net_device *dev = (struct net_device *) a; 3212 struct net_device *dev = (struct net_device *) a;
3189 struct atmel_private *priv = netdev_priv(dev); 3213 struct atmel_private *priv = netdev_priv(dev);
3190 unsigned long flags; 3214 unsigned long flags;
3191
3192 /* Check if the card has been yanked. */
3193 if (priv->card && priv->present_callback &&
3194 !(*priv->present_callback)(priv->card))
3195 return;
3196
3197 spin_lock_irqsave(&priv->irqlock, flags);
3198
3199 switch (priv->station_state) {
3200
3201 case STATION_STATE_AUTHENTICATING:
3202 if (priv->AuthenticationRequestRetryCnt >= MAX_AUTHENTICATION_RETRIES) {
3203 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3204 priv->station_is_associated = 0;
3205 priv->AuthenticationRequestRetryCnt = 0;
3206 restart_search(priv);
3207 } else {
3208 priv->AuthenticationRequestRetryCnt++;
3209 priv->CurrentAuthentTransactionSeqNum = 0x0001;
3210 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3211 send_authentication_request(priv, C80211_MGMT_AAN_OPENSYSTEM, NULL, 0);
3212 }
3213
3214 break;
3215 3215
3216 case STATION_STATE_ASSOCIATING: 3216 /* Check if the card has been yanked. */
3217 if (priv->AssociationRequestRetryCnt == MAX_ASSOCIATION_RETRIES) { 3217 if (priv->card && priv->present_callback &&
3218 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR); 3218 !(*priv->present_callback)(priv->card))
3219 priv->station_is_associated = 0; 3219 return;
3220 priv->AssociationRequestRetryCnt = 0;
3221 restart_search(priv);
3222 } else {
3223 priv->AssociationRequestRetryCnt++;
3224 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3225 send_association_request(priv, 0);
3226 }
3227 3220
3228 break; 3221 spin_lock_irqsave(&priv->irqlock, flags);
3229 3222
3230 case STATION_STATE_REASSOCIATING: 3223 switch (priv->station_state) {
3231 if (priv->ReAssociationRequestRetryCnt == MAX_ASSOCIATION_RETRIES) {
3232 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3233 priv->station_is_associated = 0;
3234 priv->ReAssociationRequestRetryCnt = 0;
3235 restart_search(priv);
3236 } else {
3237 priv->ReAssociationRequestRetryCnt++;
3238 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3239 send_association_request(priv, 1);
3240 }
3241 3224
3225 case STATION_STATE_AUTHENTICATING:
3226 if (priv->AuthenticationRequestRetryCnt >= MAX_AUTHENTICATION_RETRIES) {
3227 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3228 priv->station_is_associated = 0;
3229 priv->AuthenticationRequestRetryCnt = 0;
3230 restart_search(priv);
3231 } else {
3232 priv->AuthenticationRequestRetryCnt++;
3233 priv->CurrentAuthentTransactionSeqNum = 0x0001;
3234 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3235 send_authentication_request(priv, C80211_MGMT_AAN_OPENSYSTEM, NULL, 0);
3236 }
3242 break; 3237 break;
3243 3238
3244 default: 3239 case STATION_STATE_ASSOCIATING:
3240 if (priv->AssociationRequestRetryCnt == MAX_ASSOCIATION_RETRIES) {
3241 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3242 priv->station_is_associated = 0;
3243 priv->AssociationRequestRetryCnt = 0;
3244 restart_search(priv);
3245 } else {
3246 priv->AssociationRequestRetryCnt++;
3247 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3248 send_association_request(priv, 0);
3249 }
3245 break; 3250 break;
3246 } 3251
3247 3252 case STATION_STATE_REASSOCIATING:
3248 spin_unlock_irqrestore(&priv->irqlock, flags); 3253 if (priv->ReAssociationRequestRetryCnt == MAX_ASSOCIATION_RETRIES) {
3254 atmel_enter_state(priv, STATION_STATE_MGMT_ERROR);
3255 priv->station_is_associated = 0;
3256 priv->ReAssociationRequestRetryCnt = 0;
3257 restart_search(priv);
3258 } else {
3259 priv->ReAssociationRequestRetryCnt++;
3260 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3261 send_association_request(priv, 1);
3262 }
3263 break;
3264
3265 default:
3266 break;
3267 }
3268
3269 spin_unlock_irqrestore(&priv->irqlock, flags);
3249} 3270}
3250 3271
3251static void atmel_command_irq(struct atmel_private *priv) 3272static void atmel_command_irq(struct atmel_private *priv)
3252{ 3273{
3253 u8 status = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET)); 3274 u8 status = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET));
3254 u8 command = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_COMMAND_OFFSET)); 3275 u8 command = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_COMMAND_OFFSET));
3255 int fast_scan; 3276 int fast_scan;
3256 3277
3257 if (status == CMD_STATUS_IDLE || 3278 if (status == CMD_STATUS_IDLE ||
3258 status == CMD_STATUS_IN_PROGRESS) 3279 status == CMD_STATUS_IN_PROGRESS)
3259 return; 3280 return;
3260 3281
@@ -3266,20 +3287,20 @@ static void atmel_command_irq(struct atmel_private *priv)
3266 atmel_get_mib(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_CUR_BSSID_POS, 3287 atmel_get_mib(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_CUR_BSSID_POS,
3267 (u8 *)priv->CurrentBSSID, 6); 3288 (u8 *)priv->CurrentBSSID, 6);
3268 atmel_enter_state(priv, STATION_STATE_READY); 3289 atmel_enter_state(priv, STATION_STATE_READY);
3269 } 3290 }
3270 break; 3291 break;
3271 3292
3272 case CMD_Scan: 3293 case CMD_Scan:
3273 fast_scan = priv->fast_scan; 3294 fast_scan = priv->fast_scan;
3274 priv->fast_scan = 0; 3295 priv->fast_scan = 0;
3275 3296
3276 if (status != CMD_STATUS_COMPLETE) { 3297 if (status != CMD_STATUS_COMPLETE) {
3277 atmel_scan(priv, 1); 3298 atmel_scan(priv, 1);
3278 } else { 3299 } else {
3279 int bss_index = retrieve_bss(priv); 3300 int bss_index = retrieve_bss(priv);
3280 if (bss_index != -1) { 3301 if (bss_index != -1) {
3281 atmel_join_bss(priv, bss_index); 3302 atmel_join_bss(priv, bss_index);
3282 } else if (priv->operating_mode == IW_MODE_ADHOC && 3303 } else if (priv->operating_mode == IW_MODE_ADHOC &&
3283 priv->SSID_size != 0) { 3304 priv->SSID_size != 0) {
3284 start(priv, BSS_TYPE_AD_HOC); 3305 start(priv, BSS_TYPE_AD_HOC);
3285 } else { 3306 } else {
@@ -3289,16 +3310,16 @@ static void atmel_command_irq(struct atmel_private *priv)
3289 priv->site_survey_state = SITE_SURVEY_COMPLETED; 3310 priv->site_survey_state = SITE_SURVEY_COMPLETED;
3290 } 3311 }
3291 break; 3312 break;
3292 3313
3293 case CMD_SiteSurvey: 3314 case CMD_SiteSurvey:
3294 priv->fast_scan = 0; 3315 priv->fast_scan = 0;
3295 3316
3296 if (status != CMD_STATUS_COMPLETE) 3317 if (status != CMD_STATUS_COMPLETE)
3297 return; 3318 return;
3298 3319
3299 priv->site_survey_state = SITE_SURVEY_COMPLETED; 3320 priv->site_survey_state = SITE_SURVEY_COMPLETED;
3300 if (priv->station_is_associated) { 3321 if (priv->station_is_associated) {
3301 atmel_enter_state(priv, STATION_STATE_READY); 3322 atmel_enter_state(priv, STATION_STATE_READY);
3302 } else { 3323 } else {
3303 atmel_scan(priv, 1); 3324 atmel_scan(priv, 1);
3304 } 3325 }
@@ -3312,16 +3333,15 @@ static void atmel_command_irq(struct atmel_private *priv)
3312 } else { 3333 } else {
3313 priv->AuthenticationRequestRetryCnt = 0; 3334 priv->AuthenticationRequestRetryCnt = 0;
3314 atmel_enter_state(priv, STATION_STATE_AUTHENTICATING); 3335 atmel_enter_state(priv, STATION_STATE_AUTHENTICATING);
3315 3336
3316 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES); 3337 mod_timer(&priv->management_timer, jiffies + MGMT_JIFFIES);
3317 priv->CurrentAuthentTransactionSeqNum = 0x0001; 3338 priv->CurrentAuthentTransactionSeqNum = 0x0001;
3318 send_authentication_request(priv, C80211_MGMT_AAN_SHAREDKEY, NULL, 0); 3339 send_authentication_request(priv, C80211_MGMT_AAN_SHAREDKEY, NULL, 0);
3319 } 3340 }
3320 return; 3341 return;
3321 } 3342 }
3322 3343
3323 atmel_scan(priv, 1); 3344 atmel_scan(priv, 1);
3324
3325 } 3345 }
3326} 3346}
3327 3347
@@ -3333,20 +3353,20 @@ static int atmel_wakeup_firmware(struct atmel_private *priv)
3333 3353
3334 if (priv->card_type == CARD_TYPE_SPI_FLASH) 3354 if (priv->card_type == CARD_TYPE_SPI_FLASH)
3335 atmel_set_gcr(priv->dev, GCR_REMAP); 3355 atmel_set_gcr(priv->dev, GCR_REMAP);
3336 3356
3337 /* wake up on-board processor */ 3357 /* wake up on-board processor */
3338 atmel_clear_gcr(priv->dev, 0x0040); 3358 atmel_clear_gcr(priv->dev, 0x0040);
3339 atmel_write16(priv->dev, BSR, BSS_SRAM); 3359 atmel_write16(priv->dev, BSR, BSS_SRAM);
3340 3360
3341 if (priv->card_type == CARD_TYPE_SPI_FLASH) 3361 if (priv->card_type == CARD_TYPE_SPI_FLASH)
3342 mdelay(100); 3362 mdelay(100);
3343 3363
3344 /* and wait for it */ 3364 /* and wait for it */
3345 for (i = LOOP_RETRY_LIMIT; i; i--) { 3365 for (i = LOOP_RETRY_LIMIT; i; i--) {
3346 mr1 = atmel_read16(priv->dev, MR1); 3366 mr1 = atmel_read16(priv->dev, MR1);
3347 mr3 = atmel_read16(priv->dev, MR3); 3367 mr3 = atmel_read16(priv->dev, MR3);
3348 3368
3349 if (mr3 & MAC_BOOT_COMPLETE) 3369 if (mr3 & MAC_BOOT_COMPLETE)
3350 break; 3370 break;
3351 if (mr1 & MAC_BOOT_COMPLETE && 3371 if (mr1 & MAC_BOOT_COMPLETE &&
3352 priv->bus_type == BUS_TYPE_PCCARD) 3372 priv->bus_type == BUS_TYPE_PCCARD)
@@ -3357,35 +3377,36 @@ static int atmel_wakeup_firmware(struct atmel_private *priv)
3357 printk(KERN_ALERT "%s: MAC failed to boot.\n", priv->dev->name); 3377 printk(KERN_ALERT "%s: MAC failed to boot.\n", priv->dev->name);
3358 return 0; 3378 return 0;
3359 } 3379 }
3360 3380
3361 if ((priv->host_info_base = atmel_read16(priv->dev, MR2)) == 0xffff) { 3381 if ((priv->host_info_base = atmel_read16(priv->dev, MR2)) == 0xffff) {
3362 printk(KERN_ALERT "%s: card missing.\n", priv->dev->name); 3382 printk(KERN_ALERT "%s: card missing.\n", priv->dev->name);
3363 return 0; 3383 return 0;
3364 } 3384 }
3365 3385
3366 /* now check for completion of MAC initialization through 3386 /* now check for completion of MAC initialization through
3367 the FunCtrl field of the IFACE, poll MR1 to detect completion of 3387 the FunCtrl field of the IFACE, poll MR1 to detect completion of
3368 MAC initialization, check completion status, set interrupt mask, 3388 MAC initialization, check completion status, set interrupt mask,
3369 enables interrupts and calls Tx and Rx initialization functions */ 3389 enables interrupts and calls Tx and Rx initialization functions */
3370 3390
3371 atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET), FUNC_CTRL_INIT_COMPLETE); 3391 atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET), FUNC_CTRL_INIT_COMPLETE);
3372 3392
3373 for (i = LOOP_RETRY_LIMIT; i; i--) { 3393 for (i = LOOP_RETRY_LIMIT; i; i--) {
3374 mr1 = atmel_read16(priv->dev, MR1); 3394 mr1 = atmel_read16(priv->dev, MR1);
3375 mr3 = atmel_read16(priv->dev, MR3); 3395 mr3 = atmel_read16(priv->dev, MR3);
3376 3396
3377 if (mr3 & MAC_INIT_COMPLETE) 3397 if (mr3 & MAC_INIT_COMPLETE)
3378 break; 3398 break;
3379 if (mr1 & MAC_INIT_COMPLETE && 3399 if (mr1 & MAC_INIT_COMPLETE &&
3380 priv->bus_type == BUS_TYPE_PCCARD) 3400 priv->bus_type == BUS_TYPE_PCCARD)
3381 break; 3401 break;
3382 } 3402 }
3383 3403
3384 if (i == 0) { 3404 if (i == 0) {
3385 printk(KERN_ALERT "%s: MAC failed to initialise.\n", priv->dev->name); 3405 printk(KERN_ALERT "%s: MAC failed to initialise.\n",
3406 priv->dev->name);
3386 return 0; 3407 return 0;
3387 } 3408 }
3388 3409
3389 /* Check for MAC_INIT_OK only on the register that the MAC_INIT_OK was set */ 3410 /* Check for MAC_INIT_OK only on the register that the MAC_INIT_OK was set */
3390 if ((mr3 & MAC_INIT_COMPLETE) && 3411 if ((mr3 & MAC_INIT_COMPLETE) &&
3391 !(atmel_read16(priv->dev, MR3) & MAC_INIT_OK)) { 3412 !(atmel_read16(priv->dev, MR3) & MAC_INIT_OK)) {
@@ -3398,9 +3419,9 @@ static int atmel_wakeup_firmware(struct atmel_private *priv)
3398 return 0; 3419 return 0;
3399 } 3420 }
3400 3421
3401 atmel_copy_to_host(priv->dev, (unsigned char *)iface, 3422 atmel_copy_to_host(priv->dev, (unsigned char *)iface,
3402 priv->host_info_base, sizeof(*iface)); 3423 priv->host_info_base, sizeof(*iface));
3403 3424
3404 iface->tx_buff_pos = le16_to_cpu(iface->tx_buff_pos); 3425 iface->tx_buff_pos = le16_to_cpu(iface->tx_buff_pos);
3405 iface->tx_buff_size = le16_to_cpu(iface->tx_buff_size); 3426 iface->tx_buff_size = le16_to_cpu(iface->tx_buff_size);
3406 iface->tx_desc_pos = le16_to_cpu(iface->tx_desc_pos); 3427 iface->tx_desc_pos = le16_to_cpu(iface->tx_desc_pos);
@@ -3424,16 +3445,16 @@ static int probe_atmel_card(struct net_device *dev)
3424{ 3445{
3425 int rc = 0; 3446 int rc = 0;
3426 struct atmel_private *priv = netdev_priv(dev); 3447 struct atmel_private *priv = netdev_priv(dev);
3427 3448
3428 /* reset pccard */ 3449 /* reset pccard */
3429 if (priv->bus_type == BUS_TYPE_PCCARD) 3450 if (priv->bus_type == BUS_TYPE_PCCARD)
3430 atmel_write16(dev, GCR, 0x0060); 3451 atmel_write16(dev, GCR, 0x0060);
3431 3452
3432 atmel_write16(dev, GCR, 0x0040); 3453 atmel_write16(dev, GCR, 0x0040);
3433 mdelay(500); 3454 mdelay(500);
3434 3455
3435 if (atmel_read16(dev, MR2) == 0) { 3456 if (atmel_read16(dev, MR2) == 0) {
3436 /* No stored firmware so load a small stub which just 3457 /* No stored firmware so load a small stub which just
3437 tells us the MAC address */ 3458 tells us the MAC address */
3438 int i; 3459 int i;
3439 priv->card_type = CARD_TYPE_EEPROM; 3460 priv->card_type = CARD_TYPE_EEPROM;
@@ -3442,7 +3463,7 @@ static int probe_atmel_card(struct net_device *dev)
3442 atmel_set_gcr(dev, GCR_REMAP); 3463 atmel_set_gcr(dev, GCR_REMAP);
3443 atmel_clear_gcr(priv->dev, 0x0040); 3464 atmel_clear_gcr(priv->dev, 0x0040);
3444 atmel_write16(dev, BSR, BSS_SRAM); 3465 atmel_write16(dev, BSR, BSS_SRAM);
3445 for (i = LOOP_RETRY_LIMIT; i; i--) 3466 for (i = LOOP_RETRY_LIMIT; i; i--)
3446 if (atmel_read16(dev, MR3) & MAC_BOOT_COMPLETE) 3467 if (atmel_read16(dev, MR3) & MAC_BOOT_COMPLETE)
3447 break; 3468 break;
3448 if (i == 0) { 3469 if (i == 0) {
@@ -3451,7 +3472,7 @@ static int probe_atmel_card(struct net_device *dev)
3451 atmel_copy_to_host(dev, dev->dev_addr, atmel_read16(dev, MR2), 6); 3472 atmel_copy_to_host(dev, dev->dev_addr, atmel_read16(dev, MR2), 6);
3452 /* got address, now squash it again until the network 3473 /* got address, now squash it again until the network
3453 interface is opened */ 3474 interface is opened */
3454 if (priv->bus_type == BUS_TYPE_PCCARD) 3475 if (priv->bus_type == BUS_TYPE_PCCARD)
3455 atmel_write16(dev, GCR, 0x0060); 3476 atmel_write16(dev, GCR, 0x0060);
3456 atmel_write16(dev, GCR, 0x0040); 3477 atmel_write16(dev, GCR, 0x0040);
3457 rc = 1; 3478 rc = 1;
@@ -3459,7 +3480,7 @@ static int probe_atmel_card(struct net_device *dev)
3459 } else if (atmel_read16(dev, MR4) == 0) { 3480 } else if (atmel_read16(dev, MR4) == 0) {
3460 /* Mac address easy in this case. */ 3481 /* Mac address easy in this case. */
3461 priv->card_type = CARD_TYPE_PARALLEL_FLASH; 3482 priv->card_type = CARD_TYPE_PARALLEL_FLASH;
3462 atmel_write16(dev, BSR, 1); 3483 atmel_write16(dev, BSR, 1);
3463 atmel_copy_to_host(dev, dev->dev_addr, 0xc000, 6); 3484 atmel_copy_to_host(dev, dev->dev_addr, 0xc000, 6);
3464 atmel_write16(dev, BSR, 0x200); 3485 atmel_write16(dev, BSR, 0x200);
3465 rc = 1; 3486 rc = 1;
@@ -3469,16 +3490,16 @@ static int probe_atmel_card(struct net_device *dev)
3469 priv->card_type = CARD_TYPE_SPI_FLASH; 3490 priv->card_type = CARD_TYPE_SPI_FLASH;
3470 if (atmel_wakeup_firmware(priv)) { 3491 if (atmel_wakeup_firmware(priv)) {
3471 atmel_get_mib(priv, Mac_Address_Mib_Type, 0, dev->dev_addr, 6); 3492 atmel_get_mib(priv, Mac_Address_Mib_Type, 0, dev->dev_addr, 6);
3472 3493
3473 /* got address, now squash it again until the network 3494 /* got address, now squash it again until the network
3474 interface is opened */ 3495 interface is opened */
3475 if (priv->bus_type == BUS_TYPE_PCCARD) 3496 if (priv->bus_type == BUS_TYPE_PCCARD)
3476 atmel_write16(dev, GCR, 0x0060); 3497 atmel_write16(dev, GCR, 0x0060);
3477 atmel_write16(dev, GCR, 0x0040); 3498 atmel_write16(dev, GCR, 0x0040);
3478 rc = 1; 3499 rc = 1;
3479 } 3500 }
3480 } 3501 }
3481 3502
3482 if (rc) { 3503 if (rc) {
3483 if (dev->dev_addr[0] == 0xFF) { 3504 if (dev->dev_addr[0] == 0xFF) {
3484 u8 default_mac[] = {0x00,0x04, 0x25, 0x00, 0x00, 0x00}; 3505 u8 default_mac[] = {0x00,0x04, 0x25, 0x00, 0x00, 0x00};
@@ -3486,27 +3507,27 @@ static int probe_atmel_card(struct net_device *dev)
3486 memcpy(dev->dev_addr, default_mac, 6); 3507 memcpy(dev->dev_addr, default_mac, 6);
3487 } 3508 }
3488 } 3509 }
3489 3510
3490 return rc; 3511 return rc;
3491} 3512}
3492 3513
3493static void build_wep_mib(struct atmel_private *priv)
3494/* Move the encyption information on the MIB structure. 3514/* Move the encyption information on the MIB structure.
3495 This routine is for the pre-WPA firmware: later firmware has 3515 This routine is for the pre-WPA firmware: later firmware has
3496 a different format MIB and a different routine. */ 3516 a different format MIB and a different routine. */
3517static void build_wep_mib(struct atmel_private *priv)
3497{ 3518{
3498 struct { /* NB this is matched to the hardware, don't change. */ 3519 struct { /* NB this is matched to the hardware, don't change. */
3499 u8 wep_is_on; 3520 u8 wep_is_on;
3500 u8 default_key; /* 0..3 */ 3521 u8 default_key; /* 0..3 */
3501 u8 reserved; 3522 u8 reserved;
3502 u8 exclude_unencrypted; 3523 u8 exclude_unencrypted;
3503 3524
3504 u32 WEPICV_error_count; 3525 u32 WEPICV_error_count;
3505 u32 WEP_excluded_count; 3526 u32 WEP_excluded_count;
3506 3527
3507 u8 wep_keys[MAX_ENCRYPTION_KEYS][13]; 3528 u8 wep_keys[MAX_ENCRYPTION_KEYS][13];
3508 u8 encryption_level; /* 0, 1, 2 */ 3529 u8 encryption_level; /* 0, 1, 2 */
3509 u8 reserved2[3]; 3530 u8 reserved2[3];
3510 } mib; 3531 } mib;
3511 int i; 3532 int i;
3512 3533
@@ -3515,54 +3536,55 @@ static void build_wep_mib(struct atmel_private *priv)
3515 if (priv->wep_key_len[priv->default_key] > 5) 3536 if (priv->wep_key_len[priv->default_key] > 5)
3516 mib.encryption_level = 2; 3537 mib.encryption_level = 2;
3517 else 3538 else
3518 mib.encryption_level = 1; 3539 mib.encryption_level = 1;
3519 } else { 3540 } else {
3520 mib.encryption_level = 0; 3541 mib.encryption_level = 0;
3521 } 3542 }
3522 3543
3523 mib.default_key = priv->default_key; 3544 mib.default_key = priv->default_key;
3524 mib.exclude_unencrypted = priv->exclude_unencrypted; 3545 mib.exclude_unencrypted = priv->exclude_unencrypted;
3525 3546
3526 for(i = 0; i < MAX_ENCRYPTION_KEYS; i++) 3547 for (i = 0; i < MAX_ENCRYPTION_KEYS; i++)
3527 memcpy(mib.wep_keys[i], priv->wep_keys[i], 13); 3548 memcpy(mib.wep_keys[i], priv->wep_keys[i], 13);
3528 3549
3529 atmel_set_mib(priv, Mac_Wep_Mib_Type, 0, (u8 *)&mib, sizeof(mib)); 3550 atmel_set_mib(priv, Mac_Wep_Mib_Type, 0, (u8 *)&mib, sizeof(mib));
3530} 3551}
3531 3552
3532static void build_wpa_mib(struct atmel_private *priv) 3553static void build_wpa_mib(struct atmel_private *priv)
3533{ 3554{
3534 /* This is for the later (WPA enabled) firmware. */ 3555 /* This is for the later (WPA enabled) firmware. */
3535 3556
3536 struct { /* NB this is matched to the hardware, don't change. */ 3557 struct { /* NB this is matched to the hardware, don't change. */
3537 u8 cipher_default_key_value[MAX_ENCRYPTION_KEYS][MAX_ENCRYPTION_KEY_SIZE]; 3558 u8 cipher_default_key_value[MAX_ENCRYPTION_KEYS][MAX_ENCRYPTION_KEY_SIZE];
3538 u8 receiver_address[6]; 3559 u8 receiver_address[6];
3539 u8 wep_is_on; 3560 u8 wep_is_on;
3540 u8 default_key; /* 0..3 */ 3561 u8 default_key; /* 0..3 */
3541 u8 group_key; 3562 u8 group_key;
3542 u8 exclude_unencrypted; 3563 u8 exclude_unencrypted;
3543 u8 encryption_type; 3564 u8 encryption_type;
3544 u8 reserved; 3565 u8 reserved;
3545 3566
3546 u32 WEPICV_error_count; 3567 u32 WEPICV_error_count;
3547 u32 WEP_excluded_count; 3568 u32 WEP_excluded_count;
3548 3569
3549 u8 key_RSC[4][8]; 3570 u8 key_RSC[4][8];
3550 } mib; 3571 } mib;
3551 3572
3552 int i; 3573 int i;
3553 3574
3554 mib.wep_is_on = priv->wep_is_on; 3575 mib.wep_is_on = priv->wep_is_on;
3555 mib.exclude_unencrypted = priv->exclude_unencrypted; 3576 mib.exclude_unencrypted = priv->exclude_unencrypted;
3556 memcpy(mib.receiver_address, priv->CurrentBSSID, 6); 3577 memcpy(mib.receiver_address, priv->CurrentBSSID, 6);
3557 3578
3558 /* zero all the keys before adding in valid ones. */ 3579 /* zero all the keys before adding in valid ones. */
3559 memset(mib.cipher_default_key_value, 0, sizeof(mib.cipher_default_key_value)); 3580 memset(mib.cipher_default_key_value, 0, sizeof(mib.cipher_default_key_value));
3560 3581
3561 if (priv->wep_is_on) { 3582 if (priv->wep_is_on) {
3562 /* There's a comment in the Atmel code to the effect that this is only valid 3583 /* There's a comment in the Atmel code to the effect that this
3563 when still using WEP, it may need to be set to something to use WPA */ 3584 is only valid when still using WEP, it may need to be set to
3585 something to use WPA */
3564 memset(mib.key_RSC, 0, sizeof(mib.key_RSC)); 3586 memset(mib.key_RSC, 0, sizeof(mib.key_RSC));
3565 3587
3566 mib.default_key = mib.group_key = 255; 3588 mib.default_key = mib.group_key = 255;
3567 for (i = 0; i < MAX_ENCRYPTION_KEYS; i++) { 3589 for (i = 0; i < MAX_ENCRYPTION_KEYS; i++) {
3568 if (priv->wep_key_len[i] > 0) { 3590 if (priv->wep_key_len[i] > 0) {
@@ -3570,12 +3592,12 @@ static void build_wpa_mib(struct atmel_private *priv)
3570 if (i == priv->default_key) { 3592 if (i == priv->default_key) {
3571 mib.default_key = i; 3593 mib.default_key = i;
3572 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-1] = 7; 3594 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-1] = 7;
3573 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-2] = priv->pairwise_cipher_suite; 3595 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-2] = priv->pairwise_cipher_suite;
3574 } else { 3596 } else {
3575 mib.group_key = i; 3597 mib.group_key = i;
3576 priv->group_cipher_suite = priv->pairwise_cipher_suite; 3598 priv->group_cipher_suite = priv->pairwise_cipher_suite;
3577 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-1] = 1; 3599 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-1] = 1;
3578 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-2] = priv->group_cipher_suite; 3600 mib.cipher_default_key_value[i][MAX_ENCRYPTION_KEY_SIZE-2] = priv->group_cipher_suite;
3579 } 3601 }
3580 } 3602 }
3581 } 3603 }
@@ -3583,47 +3605,47 @@ static void build_wpa_mib(struct atmel_private *priv)
3583 mib.default_key = mib.group_key != 255 ? mib.group_key : 0; 3605 mib.default_key = mib.group_key != 255 ? mib.group_key : 0;
3584 if (mib.group_key == 255) 3606 if (mib.group_key == 255)
3585 mib.group_key = mib.default_key; 3607 mib.group_key = mib.default_key;
3586 3608
3587 } 3609 }
3588 3610
3589 atmel_set_mib(priv, Mac_Wep_Mib_Type, 0, (u8 *)&mib, sizeof(mib)); 3611 atmel_set_mib(priv, Mac_Wep_Mib_Type, 0, (u8 *)&mib, sizeof(mib));
3590} 3612}
3591 3613
3592static int reset_atmel_card(struct net_device *dev) 3614static int reset_atmel_card(struct net_device *dev)
3593{ 3615{
3594 /* do everything necessary to wake up the hardware, including 3616 /* do everything necessary to wake up the hardware, including
3595 waiting for the lightning strike and throwing the knife switch.... 3617 waiting for the lightning strike and throwing the knife switch....
3596 3618
3597 set all the Mib values which matter in the card to match 3619 set all the Mib values which matter in the card to match
3598 their settings in the atmel_private structure. Some of these 3620 their settings in the atmel_private structure. Some of these
3599 can be altered on the fly, but many (WEP, infrastucture or ad-hoc) 3621 can be altered on the fly, but many (WEP, infrastucture or ad-hoc)
3600 can only be changed by tearing down the world and coming back through 3622 can only be changed by tearing down the world and coming back through
3601 here. 3623 here.
3602 3624
3603 This routine is also responsible for initialising some 3625 This routine is also responsible for initialising some
3604 hardware-specific fields in the atmel_private structure, 3626 hardware-specific fields in the atmel_private structure,
3605 including a copy of the firmware's hostinfo stucture 3627 including a copy of the firmware's hostinfo stucture
3606 which is the route into the rest of the firmare datastructures. */ 3628 which is the route into the rest of the firmare datastructures. */
3607 3629
3608 struct atmel_private *priv = netdev_priv(dev); 3630 struct atmel_private *priv = netdev_priv(dev);
3609 u8 configuration; 3631 u8 configuration;
3610 3632
3611 /* data to add to the firmware names, in priority order 3633 /* data to add to the firmware names, in priority order
3612 this implemenents firmware versioning */ 3634 this implemenents firmware versioning */
3613 3635
3614 static char *firmware_modifier[] = { 3636 static char *firmware_modifier[] = {
3615 "-wpa", 3637 "-wpa",
3616 "", 3638 "",
3617 NULL 3639 NULL
3618 }; 3640 };
3619 3641
3620 /* reset pccard */ 3642 /* reset pccard */
3621 if (priv->bus_type == BUS_TYPE_PCCARD) 3643 if (priv->bus_type == BUS_TYPE_PCCARD)
3622 atmel_write16(priv->dev, GCR, 0x0060); 3644 atmel_write16(priv->dev, GCR, 0x0060);
3623 3645
3624 /* stop card , disable interrupts */ 3646 /* stop card , disable interrupts */
3625 atmel_write16(priv->dev, GCR, 0x0040); 3647 atmel_write16(priv->dev, GCR, 0x0040);
3626 3648
3627 if (priv->card_type == CARD_TYPE_EEPROM) { 3649 if (priv->card_type == CARD_TYPE_EEPROM) {
3628 /* copy in firmware if needed */ 3650 /* copy in firmware if needed */
3629 const struct firmware *fw_entry = NULL; 3651 const struct firmware *fw_entry = NULL;
@@ -3636,13 +3658,13 @@ static int reset_atmel_card(struct net_device *dev)
3636 "%s: card type is unknown: assuming at76c502 firmware is OK.\n", 3658 "%s: card type is unknown: assuming at76c502 firmware is OK.\n",
3637 dev->name); 3659 dev->name);
3638 printk(KERN_INFO 3660 printk(KERN_INFO
3639 "%s: if not, use the firmware= module parameter.\n", 3661 "%s: if not, use the firmware= module parameter.\n",
3640 dev->name); 3662 dev->name);
3641 strcpy(priv->firmware_id, "atmel_at76c502.bin"); 3663 strcpy(priv->firmware_id, "atmel_at76c502.bin");
3642 } 3664 }
3643 if (request_firmware(&fw_entry, priv->firmware_id, priv->sys_dev) != 0) { 3665 if (request_firmware(&fw_entry, priv->firmware_id, priv->sys_dev) != 0) {
3644 printk(KERN_ALERT 3666 printk(KERN_ALERT
3645 "%s: firmware %s is missing, cannot continue.\n", 3667 "%s: firmware %s is missing, cannot continue.\n",
3646 dev->name, priv->firmware_id); 3668 dev->name, priv->firmware_id);
3647 return 0; 3669 return 0;
3648 } 3670 }
@@ -3654,7 +3676,7 @@ static int reset_atmel_card(struct net_device *dev)
3654 while (fw_table[fw_index].fw_type != priv->firmware_type 3676 while (fw_table[fw_index].fw_type != priv->firmware_type
3655 && fw_table[fw_index].fw_type != ATMEL_FW_TYPE_NONE) 3677 && fw_table[fw_index].fw_type != ATMEL_FW_TYPE_NONE)
3656 fw_index++; 3678 fw_index++;
3657 3679
3658 /* construct the actual firmware file name */ 3680 /* construct the actual firmware file name */
3659 if (fw_table[fw_index].fw_type != ATMEL_FW_TYPE_NONE) { 3681 if (fw_table[fw_index].fw_type != ATMEL_FW_TYPE_NONE) {
3660 int i; 3682 int i;
@@ -3669,24 +3691,24 @@ static int reset_atmel_card(struct net_device *dev)
3669 } 3691 }
3670 } 3692 }
3671 if (!success) { 3693 if (!success) {
3672 printk(KERN_ALERT 3694 printk(KERN_ALERT
3673 "%s: firmware %s is missing, cannot start.\n", 3695 "%s: firmware %s is missing, cannot start.\n",
3674 dev->name, priv->firmware_id); 3696 dev->name, priv->firmware_id);
3675 priv->firmware_id[0] = '\0'; 3697 priv->firmware_id[0] = '\0';
3676 return 0; 3698 return 0;
3677 } 3699 }
3678 } 3700 }
3679 3701
3680 fw = fw_entry->data; 3702 fw = fw_entry->data;
3681 len = fw_entry->size; 3703 len = fw_entry->size;
3682 } 3704 }
3683 3705
3684 if (len <= 0x6000) { 3706 if (len <= 0x6000) {
3685 atmel_write16(priv->dev, BSR, BSS_IRAM); 3707 atmel_write16(priv->dev, BSR, BSS_IRAM);
3686 atmel_copy_to_card(priv->dev, 0, fw, len); 3708 atmel_copy_to_card(priv->dev, 0, fw, len);
3687 atmel_set_gcr(priv->dev, GCR_REMAP); 3709 atmel_set_gcr(priv->dev, GCR_REMAP);
3688 } else { 3710 } else {
3689 /* Remap */ 3711 /* Remap */
3690 atmel_set_gcr(priv->dev, GCR_REMAP); 3712 atmel_set_gcr(priv->dev, GCR_REMAP);
3691 atmel_write16(priv->dev, BSR, BSS_IRAM); 3713 atmel_write16(priv->dev, BSR, BSS_IRAM);
3692 atmel_copy_to_card(priv->dev, 0, fw, 0x6000); 3714 atmel_copy_to_card(priv->dev, 0, fw, 0x6000);
@@ -3708,45 +3730,45 @@ static int reset_atmel_card(struct net_device *dev)
3708 the 3com broken-ness filter. */ 3730 the 3com broken-ness filter. */
3709 priv->use_wpa = (priv->host_info.major_version == 4); 3731 priv->use_wpa = (priv->host_info.major_version == 4);
3710 priv->radio_on_broken = (priv->host_info.major_version == 5); 3732 priv->radio_on_broken = (priv->host_info.major_version == 5);
3711 3733
3712 /* unmask all irq sources */ 3734 /* unmask all irq sources */
3713 atmel_wmem8(priv, atmel_hi(priv, IFACE_INT_MASK_OFFSET), 0xff); 3735 atmel_wmem8(priv, atmel_hi(priv, IFACE_INT_MASK_OFFSET), 0xff);
3714 3736
3715 /* int Tx system and enable Tx */ 3737 /* int Tx system and enable Tx */
3716 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, 0), 0); 3738 atmel_wmem8(priv, atmel_tx(priv, TX_DESC_FLAGS_OFFSET, 0), 0);
3717 atmel_wmem32(priv, atmel_tx(priv, TX_DESC_NEXT_OFFSET, 0), 0x80000000L); 3739 atmel_wmem32(priv, atmel_tx(priv, TX_DESC_NEXT_OFFSET, 0), 0x80000000L);
3718 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_POS_OFFSET, 0), 0); 3740 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_POS_OFFSET, 0), 0);
3719 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, 0), 0); 3741 atmel_wmem16(priv, atmel_tx(priv, TX_DESC_SIZE_OFFSET, 0), 0);
3720 3742
3721 priv->tx_desc_free = priv->host_info.tx_desc_count; 3743 priv->tx_desc_free = priv->host_info.tx_desc_count;
3722 priv->tx_desc_head = 0; 3744 priv->tx_desc_head = 0;
3723 priv->tx_desc_tail = 0; 3745 priv->tx_desc_tail = 0;
3724 priv->tx_desc_previous = 0; 3746 priv->tx_desc_previous = 0;
3725 priv->tx_free_mem = priv->host_info.tx_buff_size; 3747 priv->tx_free_mem = priv->host_info.tx_buff_size;
3726 priv->tx_buff_head = 0; 3748 priv->tx_buff_head = 0;
3727 priv->tx_buff_tail = 0; 3749 priv->tx_buff_tail = 0;
3728 3750
3729 configuration = atmel_rmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET)); 3751 configuration = atmel_rmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET));
3730 atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET), 3752 atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET),
3731 configuration | FUNC_CTRL_TxENABLE); 3753 configuration | FUNC_CTRL_TxENABLE);
3732 3754
3733 /* init Rx system and enable */ 3755 /* init Rx system and enable */
3734 priv->rx_desc_head = 0; 3756 priv->rx_desc_head = 0;
3735 3757
3736 configuration = atmel_rmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET)); 3758 configuration = atmel_rmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET));
3737 atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET), 3759 atmel_wmem8(priv, atmel_hi(priv, IFACE_FUNC_CTRL_OFFSET),
3738 configuration | FUNC_CTRL_RxENABLE); 3760 configuration | FUNC_CTRL_RxENABLE);
3739 3761
3740 if (!priv->radio_on_broken) { 3762 if (!priv->radio_on_broken) {
3741 if (atmel_send_command_wait(priv, CMD_EnableRadio, NULL, 0) == 3763 if (atmel_send_command_wait(priv, CMD_EnableRadio, NULL, 0) ==
3742 CMD_STATUS_REJECTED_RADIO_OFF) { 3764 CMD_STATUS_REJECTED_RADIO_OFF) {
3743 printk(KERN_INFO 3765 printk(KERN_INFO
3744 "%s: cannot turn the radio on. (Hey radio, you're beautiful!)\n", 3766 "%s: cannot turn the radio on. (Hey radio, you're beautiful!)\n",
3745 dev->name); 3767 dev->name);
3746 return 0; 3768 return 0;
3747 } 3769 }
3748 } 3770 }
3749 3771
3750 /* set up enough MIB values to run. */ 3772 /* set up enough MIB values to run. */
3751 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_AUTO_TX_RATE_POS, priv->auto_tx_rate); 3773 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_AUTO_TX_RATE_POS, priv->auto_tx_rate);
3752 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_TX_PROMISCUOUS_POS, PROM_MODE_OFF); 3774 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_TX_PROMISCUOUS_POS, PROM_MODE_OFF);
@@ -3755,7 +3777,7 @@ static int reset_atmel_card(struct net_device *dev)
3755 atmel_set_mib8(priv, Mac_Mib_Type, MAC_MIB_SHORT_RETRY_POS, priv->short_retry); 3777 atmel_set_mib8(priv, Mac_Mib_Type, MAC_MIB_SHORT_RETRY_POS, priv->short_retry);
3756 atmel_set_mib8(priv, Mac_Mib_Type, MAC_MIB_LONG_RETRY_POS, priv->long_retry); 3778 atmel_set_mib8(priv, Mac_Mib_Type, MAC_MIB_LONG_RETRY_POS, priv->long_retry);
3757 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_PREAMBLE_TYPE, priv->preamble); 3779 atmel_set_mib8(priv, Local_Mib_Type, LOCAL_MIB_PREAMBLE_TYPE, priv->preamble);
3758 atmel_set_mib(priv, Mac_Address_Mib_Type, MAC_ADDR_MIB_MAC_ADDR_POS, 3780 atmel_set_mib(priv, Mac_Address_Mib_Type, MAC_ADDR_MIB_MAC_ADDR_POS,
3759 priv->dev->dev_addr, 6); 3781 priv->dev->dev_addr, 6);
3760 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE); 3782 atmel_set_mib8(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_PS_MODE_POS, ACTIVE_MODE);
3761 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1); 3783 atmel_set_mib16(priv, Mac_Mgmt_Mib_Type, MAC_MGMT_MIB_LISTEN_INTERVAL_POS, 1);
@@ -3766,42 +3788,44 @@ static int reset_atmel_card(struct net_device *dev)
3766 build_wpa_mib(priv); 3788 build_wpa_mib(priv);
3767 else 3789 else
3768 build_wep_mib(priv); 3790 build_wep_mib(priv);
3769 3791
3770 return 1; 3792 return 1;
3771} 3793}
3772 3794
3773static void atmel_send_command(struct atmel_private *priv, int command, void *cmd, int cmd_size) 3795static void atmel_send_command(struct atmel_private *priv, int command,
3796 void *cmd, int cmd_size)
3774{ 3797{
3775 if (cmd) 3798 if (cmd)
3776 atmel_copy_to_card(priv->dev, atmel_co(priv, CMD_BLOCK_PARAMETERS_OFFSET), 3799 atmel_copy_to_card(priv->dev, atmel_co(priv, CMD_BLOCK_PARAMETERS_OFFSET),
3777 cmd, cmd_size); 3800 cmd, cmd_size);
3778 3801
3779 atmel_wmem8(priv, atmel_co(priv, CMD_BLOCK_COMMAND_OFFSET), command); 3802 atmel_wmem8(priv, atmel_co(priv, CMD_BLOCK_COMMAND_OFFSET), command);
3780 atmel_wmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET), 0); 3803 atmel_wmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET), 0);
3781} 3804}
3782 3805
3783static int atmel_send_command_wait(struct atmel_private *priv, int command, void *cmd, int cmd_size) 3806static int atmel_send_command_wait(struct atmel_private *priv, int command,
3807 void *cmd, int cmd_size)
3784{ 3808{
3785 int i, status; 3809 int i, status;
3786 3810
3787 atmel_send_command(priv, command, cmd, cmd_size); 3811 atmel_send_command(priv, command, cmd, cmd_size);
3788 3812
3789 for (i = 5000; i; i--) { 3813 for (i = 5000; i; i--) {
3790 status = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET)); 3814 status = atmel_rmem8(priv, atmel_co(priv, CMD_BLOCK_STATUS_OFFSET));
3791 if (status != CMD_STATUS_IDLE && 3815 if (status != CMD_STATUS_IDLE &&
3792 status != CMD_STATUS_IN_PROGRESS) 3816 status != CMD_STATUS_IN_PROGRESS)
3793 break; 3817 break;
3794 udelay(20); 3818 udelay(20);
3795 } 3819 }
3796 3820
3797 if (i == 0) { 3821 if (i == 0) {
3798 printk(KERN_ALERT "%s: failed to contact MAC.\n", priv->dev->name); 3822 printk(KERN_ALERT "%s: failed to contact MAC.\n", priv->dev->name);
3799 status = CMD_STATUS_HOST_ERROR; 3823 status = CMD_STATUS_HOST_ERROR;
3800 } else { 3824 } else {
3801 if (command != CMD_EnableRadio) 3825 if (command != CMD_EnableRadio)
3802 status = CMD_STATUS_COMPLETE; 3826 status = CMD_STATUS_COMPLETE;
3803 } 3827 }
3804 3828
3805 return status; 3829 return status;
3806} 3830}
3807 3831
@@ -3827,7 +3851,8 @@ static void atmel_set_mib8(struct atmel_private *priv, u8 type, u8 index, u8 dat
3827 atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + 1); 3851 atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + 1);
3828} 3852}
3829 3853
3830static void atmel_set_mib16(struct atmel_private *priv, u8 type, u8 index, u16 data) 3854static void atmel_set_mib16(struct atmel_private *priv, u8 type, u8 index,
3855 u16 data)
3831{ 3856{
3832 struct get_set_mib m; 3857 struct get_set_mib m;
3833 m.type = type; 3858 m.type = type;
@@ -3839,7 +3864,8 @@ static void atmel_set_mib16(struct atmel_private *priv, u8 type, u8 index, u16 d
3839 atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + 2); 3864 atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + 2);
3840} 3865}
3841 3866
3842static void atmel_set_mib(struct atmel_private *priv, u8 type, u8 index, u8 *data, int data_len) 3867static void atmel_set_mib(struct atmel_private *priv, u8 type, u8 index,
3868 u8 *data, int data_len)
3843{ 3869{
3844 struct get_set_mib m; 3870 struct get_set_mib m;
3845 m.type = type; 3871 m.type = type;
@@ -3848,23 +3874,24 @@ static void atmel_set_mib(struct atmel_private *priv, u8 type, u8 index, u8 *dat
3848 3874
3849 if (data_len > MIB_MAX_DATA_BYTES) 3875 if (data_len > MIB_MAX_DATA_BYTES)
3850 printk(KERN_ALERT "%s: MIB buffer too small.\n", priv->dev->name); 3876 printk(KERN_ALERT "%s: MIB buffer too small.\n", priv->dev->name);
3851 3877
3852 memcpy(m.data, data, data_len); 3878 memcpy(m.data, data, data_len);
3853 atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + data_len); 3879 atmel_send_command_wait(priv, CMD_Set_MIB_Vars, &m, MIB_HEADER_SIZE + data_len);
3854} 3880}
3855 3881
3856static void atmel_get_mib(struct atmel_private *priv, u8 type, u8 index, u8 *data, int data_len) 3882static void atmel_get_mib(struct atmel_private *priv, u8 type, u8 index,
3883 u8 *data, int data_len)
3857{ 3884{
3858 struct get_set_mib m; 3885 struct get_set_mib m;
3859 m.type = type; 3886 m.type = type;
3860 m.size = data_len; 3887 m.size = data_len;
3861 m.index = index; 3888 m.index = index;
3862 3889
3863 if (data_len > MIB_MAX_DATA_BYTES) 3890 if (data_len > MIB_MAX_DATA_BYTES)
3864 printk(KERN_ALERT "%s: MIB buffer too small.\n", priv->dev->name); 3891 printk(KERN_ALERT "%s: MIB buffer too small.\n", priv->dev->name);
3865 3892
3866 atmel_send_command_wait(priv, CMD_Get_MIB_Vars, &m, MIB_HEADER_SIZE + data_len); 3893 atmel_send_command_wait(priv, CMD_Get_MIB_Vars, &m, MIB_HEADER_SIZE + data_len);
3867 atmel_copy_to_host(priv->dev, data, 3894 atmel_copy_to_host(priv->dev, data,
3868 atmel_co(priv, CMD_BLOCK_PARAMETERS_OFFSET + MIB_HEADER_SIZE), data_len); 3895 atmel_co(priv, CMD_BLOCK_PARAMETERS_OFFSET + MIB_HEADER_SIZE), data_len);
3869} 3896}
3870 3897
@@ -3873,11 +3900,12 @@ static void atmel_writeAR(struct net_device *dev, u16 data)
3873 int i; 3900 int i;
3874 outw(data, dev->base_addr + AR); 3901 outw(data, dev->base_addr + AR);
3875 /* Address register appears to need some convincing..... */ 3902 /* Address register appears to need some convincing..... */
3876 for (i = 0; data != inw(dev->base_addr + AR) && i<10; i++) 3903 for (i = 0; data != inw(dev->base_addr + AR) && i < 10; i++)
3877 outw(data, dev->base_addr + AR); 3904 outw(data, dev->base_addr + AR);
3878} 3905}
3879 3906
3880static void atmel_copy_to_card(struct net_device *dev, u16 dest, unsigned char *src, u16 len) 3907static void atmel_copy_to_card(struct net_device *dev, u16 dest,
3908 unsigned char *src, u16 len)
3881{ 3909{
3882 int i; 3910 int i;
3883 atmel_writeAR(dev, dest); 3911 atmel_writeAR(dev, dest);
@@ -3894,7 +3922,8 @@ static void atmel_copy_to_card(struct net_device *dev, u16 dest, unsigned char *
3894 atmel_write8(dev, DR, *src); 3922 atmel_write8(dev, DR, *src);
3895} 3923}
3896 3924
3897static void atmel_copy_to_host(struct net_device *dev, unsigned char *dest, u16 src, u16 len) 3925static void atmel_copy_to_host(struct net_device *dev, unsigned char *dest,
3926 u16 src, u16 len)
3898{ 3927{
3899 int i; 3928 int i;
3900 atmel_writeAR(dev, src); 3929 atmel_writeAR(dev, src);
@@ -3930,22 +3959,24 @@ static int atmel_lock_mac(struct atmel_private *priv)
3930 break; 3959 break;
3931 udelay(20); 3960 udelay(20);
3932 } 3961 }
3933 3962
3934 if (!i) return 0; /* timed out */ 3963 if (!i)
3935 3964 return 0; /* timed out */
3965
3936 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 1); 3966 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 1);
3937 if (atmel_rmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_HOST_OFFSET))) { 3967 if (atmel_rmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_HOST_OFFSET))) {
3938 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0); 3968 atmel_wmem8(priv, atmel_hi(priv, IFACE_LOCKOUT_MAC_OFFSET), 0);
3939 if (!j--) return 0; /* timed out */ 3969 if (!j--)
3970 return 0; /* timed out */
3940 goto retry; 3971 goto retry;
3941 } 3972 }
3942 3973
3943 return 1; 3974 return 1;
3944} 3975}
3945 3976
3946static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data) 3977static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data)
3947{ 3978{
3948 atmel_writeAR(priv->dev, pos); 3979 atmel_writeAR(priv->dev, pos);
3949 atmel_write16(priv->dev, DR, data); /* card is little-endian */ 3980 atmel_write16(priv->dev, DR, data); /* card is little-endian */
3950 atmel_write16(priv->dev, DR, data >> 16); 3981 atmel_write16(priv->dev, DR, data >> 16);
3951} 3982}
@@ -4017,9 +4048,9 @@ static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data)
4017 serial output, since SO is normally high. But it 4048 serial output, since SO is normally high. But it
4018 does cause 8 clock cycles and thus 8 bits to be 4049 does cause 8 clock cycles and thus 8 bits to be
4019 clocked in to the chip. See Atmel's SPI 4050 clocked in to the chip. See Atmel's SPI
4020 controller (e.g. AT91M55800) timing and 4K 4051 controller (e.g. AT91M55800) timing and 4K
4021 SPI EEPROM manuals */ 4052 SPI EEPROM manuals */
4022 4053
4023 .set NVRAM_SCRATCH, 0x02000100 /* arbitrary area for scratchpad memory */ 4054 .set NVRAM_SCRATCH, 0x02000100 /* arbitrary area for scratchpad memory */
4024 .set NVRAM_IMAGE, 0x02000200 4055 .set NVRAM_IMAGE, 0x02000200
4025 .set NVRAM_LENGTH, 0x0200 4056 .set NVRAM_LENGTH, 0x0200
@@ -4032,24 +4063,24 @@ static void atmel_wmem32(struct atmel_private *priv, u16 pos, u32 data)
4032 .set MR4, 0xC 4063 .set MR4, 0xC
4033RESET_VECTOR: 4064RESET_VECTOR:
4034 b RESET_HANDLER 4065 b RESET_HANDLER
4035UNDEF_VECTOR: 4066UNDEF_VECTOR:
4036 b HALT1 4067 b HALT1
4037SWI_VECTOR: 4068SWI_VECTOR:
4038 b HALT1 4069 b HALT1
4039IABORT_VECTOR: 4070IABORT_VECTOR:
4040 b HALT1 4071 b HALT1
4041DABORT_VECTOR: 4072DABORT_VECTOR:
4042RESERVED_VECTOR: 4073RESERVED_VECTOR:
4043 b HALT1 4074 b HALT1
4044IRQ_VECTOR: 4075IRQ_VECTOR:
4045 b HALT1 4076 b HALT1
4046FIQ_VECTOR: 4077FIQ_VECTOR:
4047 b HALT1 4078 b HALT1
4048HALT1: b HALT1 4079HALT1: b HALT1
4049RESET_HANDLER: 4080RESET_HANDLER:
4050 mov r0, #CPSR_INITIAL 4081 mov r0, #CPSR_INITIAL
4051 msr CPSR_c, r0 /* This is probably unnecessary */ 4082 msr CPSR_c, r0 /* This is probably unnecessary */
4052 4083
4053/* I'm guessing this is initializing clock generator electronics for SPI */ 4084/* I'm guessing this is initializing clock generator electronics for SPI */
4054 ldr r0, =SPI_CGEN_BASE 4085 ldr r0, =SPI_CGEN_BASE
4055 mov r1, #0 4086 mov r1, #0
@@ -4061,7 +4092,7 @@ RESET_HANDLER:
4061 str r1, [r0, #28] 4092 str r1, [r0, #28]
4062 mov r1, #1 4093 mov r1, #1
4063 str r1, [r0, #8] 4094 str r1, [r0, #8]
4064 4095
4065 ldr r0, =MRBASE 4096 ldr r0, =MRBASE
4066 mov r1, #0 4097 mov r1, #0
4067 strh r1, [r0, #MR1] 4098 strh r1, [r0, #MR1]
@@ -4094,7 +4125,7 @@ GET_WHOLE_NVRAM:
4094 ldmia sp!, {lr} 4125 ldmia sp!, {lr}
4095 bx lr 4126 bx lr
4096.endfunc 4127.endfunc
4097 4128
4098.func Get_MAC_Addr, GET_MAC_ADDR 4129.func Get_MAC_Addr, GET_MAC_ADDR
4099GET_MAC_ADDR: 4130GET_MAC_ADDR:
4100 stmdb sp!, {lr} 4131 stmdb sp!, {lr}
@@ -4110,13 +4141,13 @@ GET_MAC_ADDR:
4110.func Delay9, DELAY9 4141.func Delay9, DELAY9
4111DELAY9: 4142DELAY9:
4112 adds r0, r0, r0, LSL #3 /* r0 = r0 * 9 */ 4143 adds r0, r0, r0, LSL #3 /* r0 = r0 * 9 */
4113DELAYLOOP: 4144DELAYLOOP:
4114 beq DELAY9_done 4145 beq DELAY9_done
4115 subs r0, r0, #1 4146 subs r0, r0, #1
4116 b DELAYLOOP 4147 b DELAYLOOP
4117DELAY9_done: 4148DELAY9_done:
4118 bx lr 4149 bx lr
4119.endfunc 4150.endfunc
4120 4151
4121.func SP_Init, SP_INIT 4152.func SP_Init, SP_INIT
4122SP_INIT: 4153SP_INIT:
@@ -4145,26 +4176,26 @@ SP_INIT:
4145 ldr r0, [r0, #SP_RDR] 4176 ldr r0, [r0, #SP_RDR]
4146 bx lr 4177 bx lr
4147.endfunc 4178.endfunc
4148.func NVRAM_Init, NVRAM_INIT 4179.func NVRAM_Init, NVRAM_INIT
4149NVRAM_INIT: 4180NVRAM_INIT:
4150 ldr r1, =SP_BASE 4181 ldr r1, =SP_BASE
4151 ldr r0, [r1, #SP_RDR] 4182 ldr r0, [r1, #SP_RDR]
4152 mov r0, #NVRAM_CMD_RDSR 4183 mov r0, #NVRAM_CMD_RDSR
4153 str r0, [r1, #SP_TDR] 4184 str r0, [r1, #SP_TDR]
4154SP_loop1: 4185SP_loop1:
4155 ldr r0, [r1, #SP_SR] 4186 ldr r0, [r1, #SP_SR]
4156 tst r0, #SP_TDRE 4187 tst r0, #SP_TDRE
4157 beq SP_loop1 4188 beq SP_loop1
4158 4189
4159 mov r0, #SPI_8CLOCKS 4190 mov r0, #SPI_8CLOCKS
4160 str r0, [r1, #SP_TDR] 4191 str r0, [r1, #SP_TDR]
4161SP_loop2: 4192SP_loop2:
4162 ldr r0, [r1, #SP_SR] 4193 ldr r0, [r1, #SP_SR]
4163 tst r0, #SP_TDRE 4194 tst r0, #SP_TDRE
4164 beq SP_loop2 4195 beq SP_loop2
4165 4196
4166 ldr r0, [r1, #SP_RDR] 4197 ldr r0, [r1, #SP_RDR]
4167SP_loop3: 4198SP_loop3:
4168 ldr r0, [r1, #SP_SR] 4199 ldr r0, [r1, #SP_SR]
4169 tst r0, #SP_RDRF 4200 tst r0, #SP_RDRF
4170 beq SP_loop3 4201 beq SP_loop3
@@ -4173,7 +4204,7 @@ SP_loop3:
4173 and r0, r0, #255 4204 and r0, r0, #255
4174 bx lr 4205 bx lr
4175.endfunc 4206.endfunc
4176 4207
4177.func NVRAM_Xfer, NVRAM_XFER 4208.func NVRAM_Xfer, NVRAM_XFER
4178 /* r0 = dest address */ 4209 /* r0 = dest address */
4179 /* r1 = not used */ 4210 /* r1 = not used */
@@ -4185,11 +4216,11 @@ NVRAM_XFER:
4185 mov r4, r3 /* save r3 (length) */ 4216 mov r4, r3 /* save r3 (length) */
4186 mov r0, r2, LSR #5 /* SPI memories put A8 in the command field */ 4217 mov r0, r2, LSR #5 /* SPI memories put A8 in the command field */
4187 and r0, r0, #8 4218 and r0, r0, #8
4188 add r0, r0, #NVRAM_CMD_READ 4219 add r0, r0, #NVRAM_CMD_READ
4189 ldr r1, =NVRAM_SCRATCH 4220 ldr r1, =NVRAM_SCRATCH
4190 strb r0, [r1, #0] /* save command in NVRAM_SCRATCH[0] */ 4221 strb r0, [r1, #0] /* save command in NVRAM_SCRATCH[0] */
4191 strb r2, [r1, #1] /* save low byte of source address in NVRAM_SCRATCH[1] */ 4222 strb r2, [r1, #1] /* save low byte of source address in NVRAM_SCRATCH[1] */
4192_local1: 4223_local1:
4193 bl NVRAM_INIT 4224 bl NVRAM_INIT
4194 tst r0, #NVRAM_SR_RDY 4225 tst r0, #NVRAM_SR_RDY
4195 bne _local1 4226 bne _local1
@@ -4211,7 +4242,7 @@ NVRAM_XFER2:
4211 cmp r0, #0 4242 cmp r0, #0
4212 bls _local2 4243 bls _local2
4213 ldr r5, =NVRAM_SCRATCH 4244 ldr r5, =NVRAM_SCRATCH
4214_local4: 4245_local4:
4215 ldrb r6, [r5, r3] 4246 ldrb r6, [r5, r3]
4216 str r6, [r4, #SP_TDR] 4247 str r6, [r4, #SP_TDR]
4217_local3: 4248_local3:
@@ -4225,7 +4256,7 @@ _local2:
4225 mov r3, #SPI_8CLOCKS 4256 mov r3, #SPI_8CLOCKS
4226 str r3, [r4, #SP_TDR] 4257 str r3, [r4, #SP_TDR]
4227 ldr r0, [r4, #SP_RDR] 4258 ldr r0, [r4, #SP_RDR]
4228_local5: 4259_local5:
4229 ldr r0, [r4, #SP_SR] 4260 ldr r0, [r4, #SP_SR]
4230 tst r0, #SP_RDRF 4261 tst r0, #SP_RDRF
4231 beq _local5 4262 beq _local5
@@ -4233,12 +4264,12 @@ _local5:
4233 mov r0, #0 4264 mov r0, #0
4234 cmp r2, #0 /* r2 is # of bytes to copy in */ 4265 cmp r2, #0 /* r2 is # of bytes to copy in */
4235 bls _local6 4266 bls _local6
4236_local7: 4267_local7:
4237 ldr r5, [r4, #SP_SR] 4268 ldr r5, [r4, #SP_SR]
4238 tst r5, #SP_TDRE 4269 tst r5, #SP_TDRE
4239 beq _local7 4270 beq _local7
4240 str r3, [r4, #SP_TDR] /* r3 has SPI_8CLOCKS */ 4271 str r3, [r4, #SP_TDR] /* r3 has SPI_8CLOCKS */
4241_local8: 4272_local8:
4242 ldr r5, [r4, #SP_SR] 4273 ldr r5, [r4, #SP_SR]
4243 tst r5, #SP_RDRF 4274 tst r5, #SP_RDRF
4244 beq _local8 4275 beq _local8
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-30 16:27:17 -0500