git.oblomov.eu Git - linux-2.6/blob - drivers/net/wireless/atmel.c

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