drivers/staging/at76_usb/at76_usb.c

   1 /*
   2  * at76c503/at76c505 USB driver
   3  *
   4  * Copyright (c) 2002 - 2003 Oliver Kurth
   5  * Copyright (c) 2004 Joerg Albert <joerg.albert@gmx.de>
   6  * Copyright (c) 2004 Nick Jones
   7  * Copyright (c) 2004 Balint Seeber <n0_5p4m_p13453@hotmail.com>
   8  * Copyright (c) 2007 Guido Guenther <agx@sigxcpu.org>
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License as
  12  * published by the Free Software Foundation; either version 2 of
  13  * the License, or (at your option) any later version.
  14  *
  15  * This file is part of the Berlios driver for WLAN USB devices based on the
  16  * Atmel AT76C503A/505/505A.
  17  *
  18  * Some iw_handler code was taken from airo.c, (C) 1999 Benjamin Reed
  19  */
  20
  21 #include <linux/init.h>
  22 #include <linux/kernel.h>
  23 #include <linux/sched.h>
  24 #include <linux/errno.h>
  25 #include <linux/slab.h>
  26 #include <linux/module.h>
  27 #include <linux/spinlock.h>
  28 #include <linux/list.h>
  29 #include <linux/usb.h>
  30 #include <linux/netdevice.h>
  31 #include <linux/if_arp.h>
  32 #include <linux/etherdevice.h>
  33 #include <linux/ethtool.h>
  34 #include <linux/wireless.h>
  35 #include <net/iw_handler.h>
  36 #include <net/ieee80211_radiotap.h>
  37 #include <linux/firmware.h>
  38 #include <linux/leds.h>
  39 #include <linux/ieee80211.h>
  40
  41 #include "at76_usb.h"
  42
  43 /* Version information */
  44 #define DRIVER_NAME "at76_usb"
  45 #define DRIVER_VERSION  "0.17"
  46 #define DRIVER_DESC "Atmel at76x USB Wireless LAN Driver"
  47
  48 /* at76_debug bits */
  49 #define DBG_PROGRESS            0x00000001      /* authentication/accociation */
  50 #define DBG_BSS_TABLE           0x00000002      /* show BSS table after scans */
  51 #define DBG_IOCTL               0x00000004      /* ioctl calls / settings */
  52 #define DBG_MAC_STATE           0x00000008      /* MAC state transitions */
  53 #define DBG_TX_DATA             0x00000010      /* tx header */
  54 #define DBG_TX_DATA_CONTENT     0x00000020      /* tx content */
  55 #define DBG_TX_MGMT             0x00000040      /* tx management */
  56 #define DBG_RX_DATA             0x00000080      /* rx data header */
  57 #define DBG_RX_DATA_CONTENT     0x00000100      /* rx data content */
  58 #define DBG_RX_MGMT             0x00000200      /* rx mgmt frame headers */
  59 #define DBG_RX_BEACON           0x00000400      /* rx beacon */
  60 #define DBG_RX_CTRL             0x00000800      /* rx control */
  61 #define DBG_RX_MGMT_CONTENT     0x00001000      /* rx mgmt content */
  62 #define DBG_RX_FRAGS            0x00002000      /* rx data fragment handling */
  63 #define DBG_DEVSTART            0x00004000      /* fw download, device start */
  64 #define DBG_URB                 0x00008000      /* rx urb status, ... */
  65 #define DBG_RX_ATMEL_HDR        0x00010000      /* Atmel-specific Rx headers */
  66 #define DBG_PROC_ENTRY          0x00020000      /* procedure entries/exits */
  67 #define DBG_PM                  0x00040000      /* power management settings */
  68 #define DBG_BSS_MATCH           0x00080000      /* BSS match failures */
  69 #define DBG_PARAMS              0x00100000      /* show configured parameters */
  70 #define DBG_WAIT_COMPLETE       0x00200000      /* command completion */
  71 #define DBG_RX_FRAGS_SKB        0x00400000      /* skb header of Rx fragments */
  72 #define DBG_BSS_TABLE_RM        0x00800000      /* purging bss table entries */
  73 #define DBG_MONITOR_MODE        0x01000000      /* monitor mode */
  74 #define DBG_MIB                 0x02000000      /* dump all MIBs on startup */
  75 #define DBG_MGMT_TIMER          0x04000000      /* dump mgmt_timer ops */
  76 #define DBG_WE_EVENTS           0x08000000      /* dump wireless events */
  77 #define DBG_FW                  0x10000000      /* firmware download */
  78 #define DBG_DFU                 0x20000000      /* device firmware upgrade */
  79
  80 #define DBG_DEFAULTS            0
  81
  82 /* Use our own dbg macro */
  83 #define at76_dbg(bits, format, arg...) \
  84         do { \
  85                 if (at76_debug & (bits)) \
  86                 printk(KERN_DEBUG DRIVER_NAME ": " format "\n" , ## arg); \
  87         } while (0)
  88
  89 static int at76_debug = DBG_DEFAULTS;
  90
  91 /* Protect against concurrent firmware loading and parsing */
  92 static struct mutex fw_mutex;
  93
  94 static struct fwentry firmwares[] = {
  95         [0] = {""},
  96         [BOARD_503_ISL3861] = {"atmel_at76c503-i3861.bin"},
  97         [BOARD_503_ISL3863] = {"atmel_at76c503-i3863.bin"},
  98         [BOARD_503] = {"atmel_at76c503-rfmd.bin"},
  99         [BOARD_503_ACC] = {"atmel_at76c503-rfmd-acc.bin"},
 100         [BOARD_505] = {"atmel_at76c505-rfmd.bin"},
 101         [BOARD_505_2958] = {"atmel_at76c505-rfmd2958.bin"},
 102         [BOARD_505A] = {"atmel_at76c505a-rfmd2958.bin"},
 103         [BOARD_505AMX] = {"atmel_at76c505amx-rfmd.bin"},
 104 };
 105
 106 #define USB_DEVICE_DATA(__ops)  .driver_info = (kernel_ulong_t)(__ops)
 107
 108 static struct usb_device_id dev_table[] = {
 109         /*
 110          * at76c503-i3861
 111          */
 112         /* Generic AT76C503/3861 device */
 113         {USB_DEVICE(0x03eb, 0x7603), USB_DEVICE_DATA(BOARD_503_ISL3861)},
 114         /* Linksys WUSB11 v2.1/v2.6 */
 115         {USB_DEVICE(0x066b, 0x2211), USB_DEVICE_DATA(BOARD_503_ISL3861)},
 116         /* Netgear MA101 rev. A */
 117         {USB_DEVICE(0x0864, 0x4100), USB_DEVICE_DATA(BOARD_503_ISL3861)},
 118         /* Tekram U300C / Allnet ALL0193 */
 119         {USB_DEVICE(0x0b3b, 0x1612), USB_DEVICE_DATA(BOARD_503_ISL3861)},
 120         /* HP HN210W J7801A */
 121         {USB_DEVICE(0x03f0, 0x011c), USB_DEVICE_DATA(BOARD_503_ISL3861)},
 122         /* Sitecom/Z-Com/Zyxel M4Y-750 */
 123         {USB_DEVICE(0x0cde, 0x0001), USB_DEVICE_DATA(BOARD_503_ISL3861)},
 124         /* Dynalink/Askey WLL013 (intersil) */
 125         {USB_DEVICE(0x069a, 0x0320), USB_DEVICE_DATA(BOARD_503_ISL3861)},
 126         /* EZ connect 11Mpbs Wireless USB Adapter SMC2662W v1 */
 127         {USB_DEVICE(0x0d5c, 0xa001), USB_DEVICE_DATA(BOARD_503_ISL3861)},
 128         /* BenQ AWL300 */
 129         {USB_DEVICE(0x04a5, 0x9000), USB_DEVICE_DATA(BOARD_503_ISL3861)},
 130         /* Addtron AWU-120, Compex WLU11 */
 131         {USB_DEVICE(0x05dd, 0xff31), USB_DEVICE_DATA(BOARD_503_ISL3861)},
 132         /* Intel AP310 AnyPoint II USB */
 133         {USB_DEVICE(0x8086, 0x0200), USB_DEVICE_DATA(BOARD_503_ISL3861)},
 134         /* Dynalink L11U */
 135         {USB_DEVICE(0x0d8e, 0x7100), USB_DEVICE_DATA(BOARD_503_ISL3861)},
 136         /* Arescom WL-210, FCC id 07J-GL2411USB */
 137         {USB_DEVICE(0x0d8e, 0x7110), USB_DEVICE_DATA(BOARD_503_ISL3861)},
 138         /* I-O DATA WN-B11/USB */
 139         {USB_DEVICE(0x04bb, 0x0919), USB_DEVICE_DATA(BOARD_503_ISL3861)},
 140         /* BT Voyager 1010 */
 141         {USB_DEVICE(0x069a, 0x0821), USB_DEVICE_DATA(BOARD_503_ISL3861)},
 142         /*
 143          * at76c503-i3863
 144          */
 145         /* Generic AT76C503/3863 device */
 146         {USB_DEVICE(0x03eb, 0x7604), USB_DEVICE_DATA(BOARD_503_ISL3863)},
 147         /* Samsung SWL-2100U */
 148         {USB_DEVICE(0x055d, 0xa000), USB_DEVICE_DATA(BOARD_503_ISL3863)},
 149         /*
 150          * at76c503-rfmd
 151          */
 152         /* Generic AT76C503/RFMD device */
 153         {USB_DEVICE(0x03eb, 0x7605), USB_DEVICE_DATA(BOARD_503)},
 154         /* Dynalink/Askey WLL013 (rfmd) */
 155         {USB_DEVICE(0x069a, 0x0321), USB_DEVICE_DATA(BOARD_503)},
 156         /* Linksys WUSB11 v2.6 */
 157         {USB_DEVICE(0x077b, 0x2219), USB_DEVICE_DATA(BOARD_503)},
 158         /* Network Everywhere NWU11B */
 159         {USB_DEVICE(0x077b, 0x2227), USB_DEVICE_DATA(BOARD_503)},
 160         /* Netgear MA101 rev. B */
 161         {USB_DEVICE(0x0864, 0x4102), USB_DEVICE_DATA(BOARD_503)},
 162         /* D-Link DWL-120 rev. E */
 163         {USB_DEVICE(0x2001, 0x3200), USB_DEVICE_DATA(BOARD_503)},
 164         /* Actiontec 802UAT1, HWU01150-01UK */
 165         {USB_DEVICE(0x1668, 0x7605), USB_DEVICE_DATA(BOARD_503)},
 166         /* AirVast W-Buddie WN210 */
 167         {USB_DEVICE(0x03eb, 0x4102), USB_DEVICE_DATA(BOARD_503)},
 168         /* Dick Smith Electronics XH1153 802.11b USB adapter */
 169         {USB_DEVICE(0x1371, 0x5743), USB_DEVICE_DATA(BOARD_503)},
 170         /* CNet CNUSB611 */
 171         {USB_DEVICE(0x1371, 0x0001), USB_DEVICE_DATA(BOARD_503)},
 172         /* FiberLine FL-WL200U */
 173         {USB_DEVICE(0x1371, 0x0002), USB_DEVICE_DATA(BOARD_503)},
 174         /* BenQ AWL400 USB stick */
 175         {USB_DEVICE(0x04a5, 0x9001), USB_DEVICE_DATA(BOARD_503)},
 176         /* 3Com 3CRSHEW696 */
 177         {USB_DEVICE(0x0506, 0x0a01), USB_DEVICE_DATA(BOARD_503)},
 178         /* Siemens Santis ADSL WLAN USB adapter WLL 013 */
 179         {USB_DEVICE(0x0681, 0x001b), USB_DEVICE_DATA(BOARD_503)},
 180         /* Belkin F5D6050, version 2 */
 181         {USB_DEVICE(0x050d, 0x0050), USB_DEVICE_DATA(BOARD_503)},
 182         /* iBlitzz, BWU613 (not *B or *SB) */
 183         {USB_DEVICE(0x07b8, 0xb000), USB_DEVICE_DATA(BOARD_503)},
 184         /* Gigabyte GN-WLBM101 */
 185         {USB_DEVICE(0x1044, 0x8003), USB_DEVICE_DATA(BOARD_503)},
 186         /* Planex GW-US11S */
 187         {USB_DEVICE(0x2019, 0x3220), USB_DEVICE_DATA(BOARD_503)},
 188         /* Internal WLAN adapter in h5[4,5]xx series iPAQs */
 189         {USB_DEVICE(0x049f, 0x0032), USB_DEVICE_DATA(BOARD_503)},
 190         /* Corega Wireless LAN USB-11 mini */
 191         {USB_DEVICE(0x07aa, 0x0011), USB_DEVICE_DATA(BOARD_503)},
 192         /* Corega Wireless LAN USB-11 mini2 */
 193         {USB_DEVICE(0x07aa, 0x0018), USB_DEVICE_DATA(BOARD_503)},
 194         /* Uniden PCW100 */
 195         {USB_DEVICE(0x05dd, 0xff35), USB_DEVICE_DATA(BOARD_503)},
 196         /*
 197          * at76c503-rfmd-acc
 198          */
 199         /* SMC2664W */
 200         {USB_DEVICE(0x083a, 0x3501), USB_DEVICE_DATA(BOARD_503_ACC)},
 201         /* Belkin F5D6050, SMC2662W v2, SMC2662W-AR */
 202         {USB_DEVICE(0x0d5c, 0xa002), USB_DEVICE_DATA(BOARD_503_ACC)},
 203         /*
 204          * at76c505-rfmd
 205          */
 206         /* Generic AT76C505/RFMD */
 207         {USB_DEVICE(0x03eb, 0x7606), USB_DEVICE_DATA(BOARD_505)},
 208         /*
 209          * at76c505-rfmd2958
 210          */
 211         /* Generic AT76C505/RFMD, OvisLink WL-1130USB */
 212         {USB_DEVICE(0x03eb, 0x7613), USB_DEVICE_DATA(BOARD_505_2958)},
 213         /* Fiberline FL-WL240U */
 214         {USB_DEVICE(0x1371, 0x0014), USB_DEVICE_DATA(BOARD_505_2958)},
 215         /* CNet CNUSB-611G */
 216         {USB_DEVICE(0x1371, 0x0013), USB_DEVICE_DATA(BOARD_505_2958)},
 217         /* Linksys WUSB11 v2.8 */
 218         {USB_DEVICE(0x1915, 0x2233), USB_DEVICE_DATA(BOARD_505_2958)},
 219         /* Xterasys XN-2122B, IBlitzz BWU613B/BWU613SB */
 220         {USB_DEVICE(0x12fd, 0x1001), USB_DEVICE_DATA(BOARD_505_2958)},
 221         /* Corega WLAN USB Stick 11 */
 222         {USB_DEVICE(0x07aa, 0x7613), USB_DEVICE_DATA(BOARD_505_2958)},
 223         /* Microstar MSI Box MS6978 */
 224         {USB_DEVICE(0x0db0, 0x1020), USB_DEVICE_DATA(BOARD_505_2958)},
 225         /*
 226          * at76c505a-rfmd2958
 227          */
 228         /* Generic AT76C505A device */
 229         {USB_DEVICE(0x03eb, 0x7614), USB_DEVICE_DATA(BOARD_505A)},
 230         /* Generic AT76C505AS device */
 231         {USB_DEVICE(0x03eb, 0x7617), USB_DEVICE_DATA(BOARD_505A)},
 232         /* Siemens Gigaset USB WLAN Adapter 11 */
 233         {USB_DEVICE(0x1690, 0x0701), USB_DEVICE_DATA(BOARD_505A)},
 234         /* OQO Model 01+ Internal Wi-Fi */
 235         {USB_DEVICE(0x1557, 0x0002), USB_DEVICE_DATA(BOARD_505A)},
 236         /*
 237          * at76c505amx-rfmd
 238          */
 239         /* Generic AT76C505AMX device */
 240         {USB_DEVICE(0x03eb, 0x7615), USB_DEVICE_DATA(BOARD_505AMX)},
 241         {}
 242 };
 243
 244 MODULE_DEVICE_TABLE(usb, dev_table);
 245
 246 /* Supported rates of this hardware, bit 7 marks basic rates */
 247 static const u8 hw_rates[] = { 0x82, 0x84, 0x0b, 0x16 };
 248
 249 /* Frequency of each channel in MHz */
 250 static const long channel_frequency[] = {
 251         2412, 2417, 2422, 2427, 2432, 2437, 2442,
 252         2447, 2452, 2457, 2462, 2467, 2472, 2484
 253 };
 254
 255 #define NUM_CHANNELS ARRAY_SIZE(channel_frequency)
 256
 257 static const char *const preambles[] = { "long", "short", "auto" };
 258
 259 static const char *const mac_states[] = {
 260         [MAC_INIT] = "INIT",
 261         [MAC_SCANNING] = "SCANNING",
 262         [MAC_AUTH] = "AUTH",
 263         [MAC_ASSOC] = "ASSOC",
 264         [MAC_JOINING] = "JOINING",
 265         [MAC_CONNECTED] = "CONNECTED",
 266         [MAC_OWN_IBSS] = "OWN_IBSS"
 267 };
 268
 269 /* Firmware download */
 270 /* DFU states */
 271 #define STATE_IDLE                      0x00
 272 #define STATE_DETACH                    0x01
 273 #define STATE_DFU_IDLE                  0x02
 274 #define STATE_DFU_DOWNLOAD_SYNC         0x03
 275 #define STATE_DFU_DOWNLOAD_BUSY         0x04
 276 #define STATE_DFU_DOWNLOAD_IDLE         0x05
 277 #define STATE_DFU_MANIFEST_SYNC         0x06
 278 #define STATE_DFU_MANIFEST              0x07
 279 #define STATE_DFU_MANIFEST_WAIT_RESET   0x08
 280 #define STATE_DFU_UPLOAD_IDLE           0x09
 281 #define STATE_DFU_ERROR                 0x0a
 282
 283 /* DFU commands */
 284 #define DFU_DETACH                      0
 285 #define DFU_DNLOAD                      1
 286 #define DFU_UPLOAD                      2
 287 #define DFU_GETSTATUS                   3
 288 #define DFU_CLRSTATUS                   4
 289 #define DFU_GETSTATE                    5
 290 #define DFU_ABORT                       6
 291
 292 #define FW_BLOCK_SIZE 1024
 293
 294 struct dfu_status {
 295         unsigned char status;
 296         unsigned char poll_timeout[3];
 297         unsigned char state;
 298         unsigned char string;
 299 } __attribute__((packed));
 300
 301 static inline int at76_is_intersil(enum board_type board)
 302 {
 303         return (board == BOARD_503_ISL3861 || board == BOARD_503_ISL3863);
 304 }
 305
 306 static inline int at76_is_503rfmd(enum board_type board)
 307 {
 308         return (board == BOARD_503 || board == BOARD_503_ACC);
 309 }
 310
 311 static inline int at76_is_505a(enum board_type board)
 312 {
 313         return (board == BOARD_505A || board == BOARD_505AMX);
 314 }
 315
 316 /* Load a block of the first (internal) part of the firmware */
 317 static int at76_load_int_fw_block(struct usb_device *udev, int blockno,
 318                                   void *block, int size)
 319 {
 320         return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), DFU_DNLOAD,
 321                                USB_TYPE_CLASS | USB_DIR_OUT |
 322                                USB_RECIP_INTERFACE, blockno, 0, block, size,
 323                                USB_CTRL_GET_TIMEOUT);
 324 }
 325
 326 static int at76_dfu_get_status(struct usb_device *udev,
 327                                struct dfu_status *status)
 328 {
 329         int ret;
 330
 331         ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), DFU_GETSTATUS,
 332                               USB_TYPE_CLASS | USB_DIR_IN | USB_RECIP_INTERFACE,
 333                               0, 0, status, sizeof(struct dfu_status),
 334                               USB_CTRL_GET_TIMEOUT);
 335         return ret;
 336 }
 337
 338 static u8 at76_dfu_get_state(struct usb_device *udev, u8 *state)
 339 {
 340         int ret;
 341
 342         ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), DFU_GETSTATE,
 343                               USB_TYPE_CLASS | USB_DIR_IN | USB_RECIP_INTERFACE,
 344                               0, 0, state, 1, USB_CTRL_GET_TIMEOUT);
 345         return ret;
 346 }
 347
 348 /* Convert timeout from the DFU status to jiffies */
 349 static inline unsigned long at76_get_timeout(struct dfu_status *s)
 350 {
 351         return msecs_to_jiffies((s->poll_timeout[2] << 16)
 352                                 | (s->poll_timeout[1] << 8)
 353                                 | (s->poll_timeout[0]));
 354 }
 355
 356 /* Load internal firmware from the buffer.  If manifest_sync_timeout > 0, use
 357  * its value in jiffies in the MANIFEST_SYNC state.  */
 358 static int at76_usbdfu_download(struct usb_device *udev, u8 *buf, u32 size,
 359                                 int manifest_sync_timeout)
 360 {
 361         u8 *block;
 362         struct dfu_status dfu_stat_buf;
 363         int ret = 0;
 364         int need_dfu_state = 1;
 365         int is_done = 0;
 366         u8 dfu_state = 0;
 367         u32 dfu_timeout = 0;
 368         int bsize = 0;
 369         int blockno = 0;
 370
 371         at76_dbg(DBG_DFU, "%s( %p, %u, %d)", __func__, buf, size,
 372                  manifest_sync_timeout);
 373
 374         if (!size) {
 375                 dev_printk(KERN_ERR, &udev->dev, "FW buffer length invalid!\n");
 376                 return -EINVAL;
 377         }
 378
 379         block = kmalloc(FW_BLOCK_SIZE, GFP_KERNEL);
 380         if (!block)
 381                 return -ENOMEM;
 382
 383         do {
 384                 if (need_dfu_state) {
 385                         ret = at76_dfu_get_state(udev, &dfu_state);
 386                         if (ret < 0) {
 387                                 dev_printk(KERN_ERR, &udev->dev,
 388                                            "cannot get DFU state: %d\n", ret);
 389                                 goto exit;
 390                         }
 391                         need_dfu_state = 0;
 392                 }
 393
 394                 switch (dfu_state) {
 395                 case STATE_DFU_DOWNLOAD_SYNC:
 396                         at76_dbg(DBG_DFU, "STATE_DFU_DOWNLOAD_SYNC");
 397                         ret = at76_dfu_get_status(udev, &dfu_stat_buf);
 398                         if (ret >= 0) {
 399                                 dfu_state = dfu_stat_buf.state;
 400                                 dfu_timeout = at76_get_timeout(&dfu_stat_buf);
 401                                 need_dfu_state = 0;
 402                         } else
 403                                 dev_printk(KERN_ERR, &udev->dev,
 404                                            "at76_dfu_get_status returned %d\n",
 405                                            ret);
 406                         break;
 407
 408                 case STATE_DFU_DOWNLOAD_BUSY:
 409                         at76_dbg(DBG_DFU, "STATE_DFU_DOWNLOAD_BUSY");
 410                         need_dfu_state = 1;
 411
 412                         at76_dbg(DBG_DFU, "DFU: Resetting device");
 413                         schedule_timeout_interruptible(dfu_timeout);
 414                         break;
 415
 416                 case STATE_DFU_DOWNLOAD_IDLE:
 417                         at76_dbg(DBG_DFU, "DOWNLOAD...");
 418                         /* fall through */
 419                 case STATE_DFU_IDLE:
 420                         at76_dbg(DBG_DFU, "DFU IDLE");
 421
 422                         bsize = min_t(int, size, FW_BLOCK_SIZE);
 423                         memcpy(block, buf, bsize);
 424                         at76_dbg(DBG_DFU, "int fw, size left = %5d, "
 425                                  "bsize = %4d, blockno = %2d", size, bsize,
 426                                  blockno);
 427                         ret =
 428                             at76_load_int_fw_block(udev, blockno, block, bsize);
 429                         buf += bsize;
 430                         size -= bsize;
 431                         blockno++;
 432
 433                         if (ret != bsize)
 434                                 dev_printk(KERN_ERR, &udev->dev,
 435                                            "at76_load_int_fw_block "
 436                                            "returned %d\n", ret);
 437                         need_dfu_state = 1;
 438                         break;
 439
 440                 case STATE_DFU_MANIFEST_SYNC:
 441                         at76_dbg(DBG_DFU, "STATE_DFU_MANIFEST_SYNC");
 442
 443                         ret = at76_dfu_get_status(udev, &dfu_stat_buf);
 444                         if (ret < 0)
 445                                 break;
 446
 447                         dfu_state = dfu_stat_buf.state;
 448                         dfu_timeout = at76_get_timeout(&dfu_stat_buf);
 449                         need_dfu_state = 0;
 450
 451                         /* override the timeout from the status response,
 452                            needed for AT76C505A */
 453                         if (manifest_sync_timeout > 0)
 454                                 dfu_timeout = manifest_sync_timeout;
 455
 456                         at76_dbg(DBG_DFU, "DFU: Waiting for manifest phase");
 457                         schedule_timeout_interruptible(dfu_timeout);
 458                         break;
 459
 460                 case STATE_DFU_MANIFEST:
 461                         at76_dbg(DBG_DFU, "STATE_DFU_MANIFEST");
 462                         is_done = 1;
 463                         break;
 464
 465                 case STATE_DFU_MANIFEST_WAIT_RESET:
 466                         at76_dbg(DBG_DFU, "STATE_DFU_MANIFEST_WAIT_RESET");
 467                         is_done = 1;
 468                         break;
 469
 470                 case STATE_DFU_UPLOAD_IDLE:
 471                         at76_dbg(DBG_DFU, "STATE_DFU_UPLOAD_IDLE");
 472                         break;
 473
 474                 case STATE_DFU_ERROR:
 475                         at76_dbg(DBG_DFU, "STATE_DFU_ERROR");
 476                         ret = -EPIPE;
 477                         break;
 478
 479                 default:
 480                         at76_dbg(DBG_DFU, "DFU UNKNOWN STATE (%d)", dfu_state);
 481                         ret = -EINVAL;
 482                         break;
 483                 }
 484         } while (!is_done && (ret >= 0));
 485
 486 exit:
 487         kfree(block);
 488         if (ret >= 0)
 489                 ret = 0;
 490
 491         return ret;
 492 }
 493
 494 /* Report that the scan results are ready */
 495 static inline void at76_iwevent_scan_complete(struct net_device *netdev)
 496 {
 497         union iwreq_data wrqu;
 498         wrqu.data.length = 0;
 499         wrqu.data.flags = 0;
 500         wireless_send_event(netdev, SIOCGIWSCAN, &wrqu, NULL);
 501         at76_dbg(DBG_WE_EVENTS, "%s: SIOCGIWSCAN sent", netdev->name);
 502 }
 503
 504 static inline void at76_iwevent_bss_connect(struct net_device *netdev,
 505                                             u8 *bssid)
 506 {
 507         union iwreq_data wrqu;
 508         wrqu.data.length = 0;
 509         wrqu.data.flags = 0;
 510         memcpy(wrqu.ap_addr.sa_data, bssid, ETH_ALEN);
 511         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
 512         wireless_send_event(netdev, SIOCGIWAP, &wrqu, NULL);
 513         at76_dbg(DBG_WE_EVENTS, "%s: %s: SIOCGIWAP sent", netdev->name,
 514                  __func__);
 515 }
 516
 517 static inline void at76_iwevent_bss_disconnect(struct net_device *netdev)
 518 {
 519         union iwreq_data wrqu;
 520         wrqu.data.length = 0;
 521         wrqu.data.flags = 0;
 522         memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
 523         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
 524         wireless_send_event(netdev, SIOCGIWAP, &wrqu, NULL);
 525         at76_dbg(DBG_WE_EVENTS, "%s: %s: SIOCGIWAP sent", netdev->name,
 526                  __func__);
 527 }
 528
 529 #define HEX2STR_BUFFERS 4
 530 #define HEX2STR_MAX_LEN 64
 531 #define BIN2HEX(x) ((x) < 10 ? '0' + (x) : (x) + 'A' - 10)
 532
 533 /* Convert binary data into hex string */
 534 static char *hex2str(void *buf, int len)
 535 {
 536         static atomic_t a = ATOMIC_INIT(0);
 537         static char bufs[HEX2STR_BUFFERS][3 * HEX2STR_MAX_LEN + 1];
 538         char *ret = bufs[atomic_inc_return(&a) & (HEX2STR_BUFFERS - 1)];
 539         char *obuf = ret;
 540         u8 *ibuf = buf;
 541
 542         if (len > HEX2STR_MAX_LEN)
 543                 len = HEX2STR_MAX_LEN;
 544
 545         if (len <= 0) {
 546                 ret[0] = '\0';
 547                 return ret;
 548         }
 549
 550         while (len--) {
 551                 *obuf++ = BIN2HEX(*ibuf >> 4);
 552                 *obuf++ = BIN2HEX(*ibuf & 0xf);
 553                 *obuf++ = '-';
 554                 ibuf++;
 555         }
 556         *(--obuf) = '\0';
 557
 558         return ret;
 559 }
 560
 561 /* LED trigger */
 562 static int tx_activity;
 563 static void at76_ledtrig_tx_timerfunc(unsigned long data);
 564 static DEFINE_TIMER(ledtrig_tx_timer, at76_ledtrig_tx_timerfunc, 0, 0);
 565 DEFINE_LED_TRIGGER(ledtrig_tx);
 566
 567 static void at76_ledtrig_tx_timerfunc(unsigned long data)
 568 {
 569         static int tx_lastactivity;
 570
 571         if (tx_lastactivity != tx_activity) {
 572                 tx_lastactivity = tx_activity;
 573                 led_trigger_event(ledtrig_tx, LED_FULL);
 574                 mod_timer(&ledtrig_tx_timer, jiffies + HZ / 4);
 575         } else
 576                 led_trigger_event(ledtrig_tx, LED_OFF);
 577 }
 578
 579 static void at76_ledtrig_tx_activity(void)
 580 {
 581         tx_activity++;
 582         if (!timer_pending(&ledtrig_tx_timer))
 583                 mod_timer(&ledtrig_tx_timer, jiffies + HZ / 4);
 584 }
 585
 586 /* Check if the given ssid is hidden */
 587 static inline int at76_is_hidden_ssid(u8 *ssid, int length)
 588 {
 589         static const u8 zeros[32];
 590
 591         if (length == 0)
 592                 return 1;
 593
 594         if (length == 1 && ssid[0] == ' ')
 595                 return 1;
 596
 597         return (memcmp(ssid, zeros, length) == 0);
 598 }
 599
 600 static inline void at76_free_bss_list(struct at76_priv *priv)
 601 {
 602         struct list_head *next, *ptr;
 603         unsigned long flags;
 604
 605         spin_lock_irqsave(&priv->bss_list_spinlock, flags);
 606
 607         priv->curr_bss = NULL;
 608
 609         list_for_each_safe(ptr, next, &priv->bss_list) {
 610                 list_del(ptr);
 611                 kfree(list_entry(ptr, struct bss_info, list));
 612         }
 613
 614         spin_unlock_irqrestore(&priv->bss_list_spinlock, flags);
 615 }
 616
 617 static int at76_remap(struct usb_device *udev)
 618 {
 619         int ret;
 620         ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x0a,
 621                               USB_TYPE_VENDOR | USB_DIR_OUT |
 622                               USB_RECIP_INTERFACE, 0, 0, NULL, 0,
 623                               USB_CTRL_GET_TIMEOUT);
 624         if (ret < 0)
 625                 return ret;
 626         return 0;
 627 }
 628
 629 static int at76_get_op_mode(struct usb_device *udev)
 630 {
 631         int ret;
 632         u8 saved;
 633         u8 *op_mode;
 634
 635         op_mode = kmalloc(1, GFP_NOIO);
 636         if (!op_mode)
 637                 return -ENOMEM;
 638         ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x33,
 639                               USB_TYPE_VENDOR | USB_DIR_IN |
 640                               USB_RECIP_INTERFACE, 0x01, 0, op_mode, 1,
 641                               USB_CTRL_GET_TIMEOUT);
 642         saved = *op_mode;
 643         kfree(op_mode);
 644
 645         if (ret < 0)
 646                 return ret;
 647         else if (ret < 1)
 648                 return -EIO;
 649         else
 650                 return saved;
 651 }
 652
 653 /* Load a block of the second ("external") part of the firmware */
 654 static inline int at76_load_ext_fw_block(struct usb_device *udev, int blockno,
 655                                          void *block, int size)
 656 {
 657         return usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x0e,
 658                                USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
 659                                0x0802, blockno, block, size,
 660                                USB_CTRL_GET_TIMEOUT);
 661 }
 662
 663 static inline int at76_get_hw_cfg(struct usb_device *udev,
 664                                   union at76_hwcfg *buf, int buf_size)
 665 {
 666         return usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x33,
 667                                USB_TYPE_VENDOR | USB_DIR_IN |
 668                                USB_RECIP_INTERFACE, 0x0a02, 0,
 669                                buf, buf_size, USB_CTRL_GET_TIMEOUT);
 670 }
 671
 672 /* Intersil boards use a different "value" for GetHWConfig requests */
 673 static inline int at76_get_hw_cfg_intersil(struct usb_device *udev,
 674                                            union at76_hwcfg *buf, int buf_size)
 675 {
 676         return usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x33,
 677                                USB_TYPE_VENDOR | USB_DIR_IN |
 678                                USB_RECIP_INTERFACE, 0x0902, 0,
 679                                buf, buf_size, USB_CTRL_GET_TIMEOUT);
 680 }
 681
 682 /* Get the hardware configuration for the adapter and put it to the appropriate
 683  * fields of 'priv' (the GetHWConfig request and interpretation of the result
 684  * depends on the board type) */
 685 static int at76_get_hw_config(struct at76_priv *priv)
 686 {
 687         int ret;
 688         union at76_hwcfg *hwcfg = kmalloc(sizeof(*hwcfg), GFP_KERNEL);
 689
 690         if (!hwcfg)
 691                 return -ENOMEM;
 692
 693         if (at76_is_intersil(priv->board_type)) {
 694                 ret = at76_get_hw_cfg_intersil(priv->udev, hwcfg,
 695                                                sizeof(hwcfg->i));
 696                 if (ret < 0)
 697                         goto exit;
 698                 memcpy(priv->mac_addr, hwcfg->i.mac_addr, ETH_ALEN);
 699                 priv->regulatory_domain = hwcfg->i.regulatory_domain;
 700         } else if (at76_is_503rfmd(priv->board_type)) {
 701                 ret = at76_get_hw_cfg(priv->udev, hwcfg, sizeof(hwcfg->r3));
 702                 if (ret < 0)
 703                         goto exit;
 704                 memcpy(priv->mac_addr, hwcfg->r3.mac_addr, ETH_ALEN);
 705                 priv->regulatory_domain = hwcfg->r3.regulatory_domain;
 706         } else {
 707                 ret = at76_get_hw_cfg(priv->udev, hwcfg, sizeof(hwcfg->r5));
 708                 if (ret < 0)
 709                         goto exit;
 710                 memcpy(priv->mac_addr, hwcfg->r5.mac_addr, ETH_ALEN);
 711                 priv->regulatory_domain = hwcfg->r5.regulatory_domain;
 712         }
 713
 714 exit:
 715         kfree(hwcfg);
 716         if (ret < 0)
 717                 printk(KERN_ERR "%s: cannot get HW Config (error %d)\n",
 718                        priv->netdev->name, ret);
 719
 720         return ret;
 721 }
 722
 723 static struct reg_domain const *at76_get_reg_domain(u16 code)
 724 {
 725         int i;
 726         static struct reg_domain const fd_tab[] = {
 727                 {0x10, "FCC (USA)", 0x7ff},     /* ch 1-11 */
 728                 {0x20, "IC (Canada)", 0x7ff},   /* ch 1-11 */
 729                 {0x30, "ETSI (most of Europe)", 0x1fff},        /* ch 1-13 */
 730                 {0x31, "Spain", 0x600}, /* ch 10-11 */
 731                 {0x32, "France", 0x1e00},       /* ch 10-13 */
 732                 {0x40, "MKK (Japan)", 0x2000},  /* ch 14 */
 733                 {0x41, "MKK1 (Japan)", 0x3fff}, /* ch 1-14 */
 734                 {0x50, "Israel", 0x3fc},        /* ch 3-9 */
 735                 {0x00, "<unknown>", 0xffffffff} /* ch 1-32 */
 736         };
 737
 738         /* Last entry is fallback for unknown domain code */
 739         for (i = 0; i < ARRAY_SIZE(fd_tab) - 1; i++)
 740                 if (code == fd_tab[i].code)
 741                         break;
 742
 743         return &fd_tab[i];
 744 }
 745
 746 static inline int at76_get_mib(struct usb_device *udev, u16 mib, void *buf,
 747                                int buf_size)
 748 {
 749         int ret;
 750
 751         ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x33,
 752                               USB_TYPE_VENDOR | USB_DIR_IN |
 753                               USB_RECIP_INTERFACE, mib << 8, 0, buf, buf_size,
 754                               USB_CTRL_GET_TIMEOUT);
 755         if (ret >= 0 && ret != buf_size)
 756                 return -EIO;
 757         return ret;
 758 }
 759
 760 /* Return positive number for status, negative for an error */
 761 static inline int at76_get_cmd_status(struct usb_device *udev, u8 cmd)
 762 {
 763         u8 *stat_buf;
 764         int ret;
 765
 766         stat_buf = kmalloc(40, GFP_NOIO);
 767         if (!stat_buf)
 768                 return -ENOMEM;
 769
 770         ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x22,
 771                               USB_TYPE_VENDOR | USB_DIR_IN |
 772                               USB_RECIP_INTERFACE, cmd, 0, stat_buf,
 773                               40, USB_CTRL_GET_TIMEOUT);
 774         if (ret >= 0)
 775                 ret = stat_buf[5];
 776         kfree(stat_buf);
 777
 778         return ret;
 779 }
 780
 781 static int at76_set_card_command(struct usb_device *udev, u8 cmd, void *buf,
 782                                  int buf_size)
 783 {
 784         int ret;
 785         struct at76_command *cmd_buf = kmalloc(sizeof(struct at76_command) +
 786                                                buf_size, GFP_KERNEL);
 787
 788         if (!cmd_buf)
 789                 return -ENOMEM;
 790
 791         cmd_buf->cmd = cmd;
 792         cmd_buf->reserved = 0;
 793         cmd_buf->size = cpu_to_le16(buf_size);
 794         memcpy(cmd_buf->data, buf, buf_size);
 795
 796         ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x0e,
 797                               USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
 798                               0, 0, cmd_buf,
 799                               sizeof(struct at76_command) + buf_size,
 800                               USB_CTRL_GET_TIMEOUT);
 801         kfree(cmd_buf);
 802         return ret;
 803 }
 804
 805 #define MAKE_CMD_STATUS_CASE(c) case (c): return #c
 806 static const char *at76_get_cmd_status_string(u8 cmd_status)
 807 {
 808         switch (cmd_status) {
 809                 MAKE_CMD_STATUS_CASE(CMD_STATUS_IDLE);
 810                 MAKE_CMD_STATUS_CASE(CMD_STATUS_COMPLETE);
 811                 MAKE_CMD_STATUS_CASE(CMD_STATUS_UNKNOWN);
 812                 MAKE_CMD_STATUS_CASE(CMD_STATUS_INVALID_PARAMETER);
 813                 MAKE_CMD_STATUS_CASE(CMD_STATUS_FUNCTION_NOT_SUPPORTED);
 814                 MAKE_CMD_STATUS_CASE(CMD_STATUS_TIME_OUT);
 815                 MAKE_CMD_STATUS_CASE(CMD_STATUS_IN_PROGRESS);
 816                 MAKE_CMD_STATUS_CASE(CMD_STATUS_HOST_FAILURE);
 817                 MAKE_CMD_STATUS_CASE(CMD_STATUS_SCAN_FAILED);
 818         }
 819
 820         return "UNKNOWN";
 821 }
 822
 823 /* Wait until the command is completed */
 824 static int at76_wait_completion(struct at76_priv *priv, int cmd)
 825 {
 826         int status = 0;
 827         unsigned long timeout = jiffies + CMD_COMPLETION_TIMEOUT;
 828
 829         do {
 830                 status = at76_get_cmd_status(priv->udev, cmd);
 831                 if (status < 0) {
 832                         printk(KERN_ERR "%s: at76_get_cmd_status failed: %d\n",
 833                                priv->netdev->name, status);
 834                         break;
 835                 }
 836
 837                 at76_dbg(DBG_WAIT_COMPLETE,
 838                          "%s: Waiting on cmd %d, status = %d (%s)",
 839                          priv->netdev->name, cmd, status,
 840                          at76_get_cmd_status_string(status));
 841
 842                 if (status != CMD_STATUS_IN_PROGRESS
 843                     && status != CMD_STATUS_IDLE)
 844                         break;
 845
 846                 schedule_timeout_interruptible(HZ / 10);        /* 100 ms */
 847                 if (time_after(jiffies, timeout)) {
 848                         printk(KERN_ERR
 849                                "%s: completion timeout for command %d\n",
 850                                priv->netdev->name, cmd);
 851                         status = -ETIMEDOUT;
 852                         break;
 853                 }
 854         } while (1);
 855
 856         return status;
 857 }
 858
 859 static int at76_set_mib(struct at76_priv *priv, struct set_mib_buffer *buf)
 860 {
 861         int ret;
 862
 863         ret = at76_set_card_command(priv->udev, CMD_SET_MIB, buf,
 864                                     offsetof(struct set_mib_buffer,
 865                                              data) + buf->size);
 866         if (ret < 0)
 867                 return ret;
 868
 869         ret = at76_wait_completion(priv, CMD_SET_MIB);
 870         if (ret != CMD_STATUS_COMPLETE) {
 871                 printk(KERN_INFO
 872                        "%s: set_mib: at76_wait_completion failed "
 873                        "with %d\n", priv->netdev->name, ret);
 874                 ret = -EIO;
 875         }
 876
 877         return ret;
 878 }
 879
 880 /* Return < 0 on error, == 0 if no command sent, == 1 if cmd sent */
 881 static int at76_set_radio(struct at76_priv *priv, int enable)
 882 {
 883         int ret;
 884         int cmd;
 885
 886         if (priv->radio_on == enable)
 887                 return 0;
 888
 889         cmd = enable ? CMD_RADIO_ON : CMD_RADIO_OFF;
 890
 891         ret = at76_set_card_command(priv->udev, cmd, NULL, 0);
 892         if (ret < 0)
 893                 printk(KERN_ERR "%s: at76_set_card_command(%d) failed: %d\n",
 894                        priv->netdev->name, cmd, ret);
 895         else
 896                 ret = 1;
 897
 898         priv->radio_on = enable;
 899         return ret;
 900 }
 901
 902 /* Set current power save mode (AT76_PM_OFF/AT76_PM_ON/AT76_PM_SMART) */
 903 static int at76_set_pm_mode(struct at76_priv *priv)
 904 {
 905         int ret = 0;
 906
 907         priv->mib_buf.type = MIB_MAC_MGMT;
 908         priv->mib_buf.size = 1;
 909         priv->mib_buf.index = offsetof(struct mib_mac_mgmt, power_mgmt_mode);
 910         priv->mib_buf.data.byte = priv->pm_mode;
 911
 912         ret = at76_set_mib(priv, &priv->mib_buf);
 913         if (ret < 0)
 914                 printk(KERN_ERR "%s: set_mib (pm_mode) failed: %d\n",
 915                        priv->netdev->name, ret);
 916
 917         return ret;
 918 }
 919
 920 /* Set the association id for power save mode */
 921 static int at76_set_associd(struct at76_priv *priv, u16 id)
 922 {
 923         int ret = 0;
 924
 925         priv->mib_buf.type = MIB_MAC_MGMT;
 926         priv->mib_buf.size = 2;
 927         priv->mib_buf.index = offsetof(struct mib_mac_mgmt, station_id);
 928         priv->mib_buf.data.word = cpu_to_le16(id);
 929
 930         ret = at76_set_mib(priv, &priv->mib_buf);
 931         if (ret < 0)
 932                 printk(KERN_ERR "%s: set_mib (associd) failed: %d\n",
 933                        priv->netdev->name, ret);
 934
 935         return ret;
 936 }
 937
 938 /* Set the listen interval for power save mode */
 939 static int at76_set_listen_interval(struct at76_priv *priv, u16 interval)
 940 {
 941         int ret = 0;
 942
 943         priv->mib_buf.type = MIB_MAC;
 944         priv->mib_buf.size = 2;
 945         priv->mib_buf.index = offsetof(struct mib_mac, listen_interval);
 946         priv->mib_buf.data.word = cpu_to_le16(interval);
 947
 948         ret = at76_set_mib(priv, &priv->mib_buf);
 949         if (ret < 0)
 950                 printk(KERN_ERR
 951                        "%s: set_mib (listen_interval) failed: %d\n",
 952                        priv->netdev->name, ret);
 953
 954         return ret;
 955 }
 956
 957 static int at76_set_preamble(struct at76_priv *priv, u8 type)
 958 {
 959         int ret = 0;
 960
 961         priv->mib_buf.type = MIB_LOCAL;
 962         priv->mib_buf.size = 1;
 963         priv->mib_buf.index = offsetof(struct mib_local, preamble_type);
 964         priv->mib_buf.data.byte = type;
 965
 966         ret = at76_set_mib(priv, &priv->mib_buf);
 967         if (ret < 0)
 968                 printk(KERN_ERR "%s: set_mib (preamble) failed: %d\n",
 969                        priv->netdev->name, ret);
 970
 971         return ret;
 972 }
 973
 974 static int at76_set_frag(struct at76_priv *priv, u16 size)
 975 {
 976         int ret = 0;
 977
 978         priv->mib_buf.type = MIB_MAC;
 979         priv->mib_buf.size = 2;
 980         priv->mib_buf.index = offsetof(struct mib_mac, frag_threshold);
 981         priv->mib_buf.data.word = cpu_to_le16(size);
 982
 983         ret = at76_set_mib(priv, &priv->mib_buf);
 984         if (ret < 0)
 985                 printk(KERN_ERR "%s: set_mib (frag threshold) failed: %d\n",
 986                        priv->netdev->name, ret);
 987
 988         return ret;
 989 }
 990
 991 static int at76_set_rts(struct at76_priv *priv, u16 size)
 992 {
 993         int ret = 0;
 994
 995         priv->mib_buf.type = MIB_MAC;
 996         priv->mib_buf.size = 2;
 997         priv->mib_buf.index = offsetof(struct mib_mac, rts_threshold);
 998         priv->mib_buf.data.word = cpu_to_le16(size);
 999
1000         ret = at76_set_mib(priv, &priv->mib_buf);
1001         if (ret < 0)
1002                 printk(KERN_ERR "%s: set_mib (rts) failed: %d\n",
1003                        priv->netdev->name, ret);
1004
1005         return ret;
1006 }
1007
1008 static int at76_set_autorate_fallback(struct at76_priv *priv, int onoff)
1009 {
1010         int ret = 0;
1011
1012         priv->mib_buf.type = MIB_LOCAL;
1013         priv->mib_buf.size = 1;
1014         priv->mib_buf.index = offsetof(struct mib_local, txautorate_fallback);
1015         priv->mib_buf.data.byte = onoff;
1016
1017         ret = at76_set_mib(priv, &priv->mib_buf);
1018         if (ret < 0)
1019                 printk(KERN_ERR "%s: set_mib (autorate fallback) failed: %d\n",
1020                        priv->netdev->name, ret);
1021
1022         return ret;
1023 }
1024
1025 static int at76_add_mac_address(struct at76_priv *priv, void *addr)
1026 {
1027         int ret = 0;
1028
1029         priv->mib_buf.type = MIB_MAC_ADDR;
1030         priv->mib_buf.size = ETH_ALEN;
1031         priv->mib_buf.index = offsetof(struct mib_mac_addr, mac_addr);
1032         memcpy(priv->mib_buf.data.addr, addr, ETH_ALEN);
1033
1034         ret = at76_set_mib(priv, &priv->mib_buf);
1035         if (ret < 0)
1036                 printk(KERN_ERR "%s: set_mib (MAC_ADDR, mac_addr) failed: %d\n",
1037                        priv->netdev->name, ret);
1038
1039         return ret;
1040 }
1041
1042 static void at76_dump_mib_mac_addr(struct at76_priv *priv)
1043 {
1044         int i;
1045         int ret;
1046         struct mib_mac_addr *m = kmalloc(sizeof(struct mib_mac_addr),
1047                                          GFP_KERNEL);
1048
1049         if (!m)
1050                 return;
1051
1052         ret = at76_get_mib(priv->udev, MIB_MAC_ADDR, m,
1053                            sizeof(struct mib_mac_addr));
1054         if (ret < 0) {
1055                 printk(KERN_ERR "%s: at76_get_mib (MAC_ADDR) failed: %d\n",
1056                        priv->netdev->name, ret);
1057                 goto exit;
1058         }
1059
1060         at76_dbg(DBG_MIB, "%s: MIB MAC_ADDR: mac_addr %pM res 0x%x 0x%x",
1061                  priv->netdev->name, m->mac_addr, m->res[0], m->res[1]);
1062         for (i = 0; i < ARRAY_SIZE(m->group_addr); i++)
1063                 at76_dbg(DBG_MIB, "%s: MIB MAC_ADDR: group addr %d: %pM, "
1064                          "status %d", priv->netdev->name, i,
1065                          m->group_addr[i], m->group_addr_status[i]);
1066 exit:
1067         kfree(m);
1068 }
1069
1070 static void at76_dump_mib_mac_wep(struct at76_priv *priv)
1071 {
1072         int i;
1073         int ret;
1074         int key_len;
1075         struct mib_mac_wep *m = kmalloc(sizeof(struct mib_mac_wep), GFP_KERNEL);
1076
1077         if (!m)
1078                 return;
1079
1080         ret = at76_get_mib(priv->udev, MIB_MAC_WEP, m,
1081                            sizeof(struct mib_mac_wep));
1082         if (ret < 0) {
1083                 printk(KERN_ERR "%s: at76_get_mib (MAC_WEP) failed: %d\n",
1084                        priv->netdev->name, ret);
1085                 goto exit;
1086         }
1087
1088         at76_dbg(DBG_MIB, "%s: MIB MAC_WEP: priv_invoked %u def_key_id %u "
1089                  "key_len %u excl_unencr %u wep_icv_err %u wep_excluded %u "
1090                  "encr_level %u key %d", priv->netdev->name,
1091                  m->privacy_invoked, m->wep_default_key_id,
1092                  m->wep_key_mapping_len, m->exclude_unencrypted,
1093                  le32_to_cpu(m->wep_icv_error_count),
1094                  le32_to_cpu(m->wep_excluded_count), m->encryption_level,
1095                  m->wep_default_key_id);
1096
1097         key_len = (m->encryption_level == 1) ?
1098             WEP_SMALL_KEY_LEN : WEP_LARGE_KEY_LEN;
1099
1100         for (i = 0; i < WEP_KEYS; i++)
1101                 at76_dbg(DBG_MIB, "%s: MIB MAC_WEP: key %d: %s",
1102                          priv->netdev->name, i,
1103                          hex2str(m->wep_default_keyvalue[i], key_len));
1104 exit:
1105         kfree(m);
1106 }
1107
1108 static void at76_dump_mib_mac_mgmt(struct at76_priv *priv)
1109 {
1110         int ret;
1111         struct mib_mac_mgmt *m = kmalloc(sizeof(struct mib_mac_mgmt),
1112                                          GFP_KERNEL);
1113
1114         if (!m)
1115                 return;
1116
1117         ret = at76_get_mib(priv->udev, MIB_MAC_MGMT, m,
1118                            sizeof(struct mib_mac_mgmt));
1119         if (ret < 0) {
1120                 printk(KERN_ERR "%s: at76_get_mib (MAC_MGMT) failed: %d\n",
1121                        priv->netdev->name, ret);
1122                 goto exit;
1123         }
1124
1125         at76_dbg(DBG_MIB, "%s: MIB MAC_MGMT: beacon_period %d CFP_max_duration "
1126                  "%d medium_occupancy_limit %d station_id 0x%x ATIM_window %d "
1127                  "CFP_mode %d privacy_opt_impl %d DTIM_period %d CFP_period %d "
1128                  "current_bssid %pM scurrent_essid %s current_bss_type %d "
1129                  "pm_mode %d ibss_change %d res %d "
1130                  "multi_domain_capability_implemented %d "
1131                  "international_roaming %d country_string %.3s",
1132                  priv->netdev->name, le16_to_cpu(m->beacon_period),
1133                  le16_to_cpu(m->CFP_max_duration),
1134                  le16_to_cpu(m->medium_occupancy_limit),
1135                  le16_to_cpu(m->station_id), le16_to_cpu(m->ATIM_window),
1136                  m->CFP_mode, m->privacy_option_implemented, m->DTIM_period,
1137                  m->CFP_period, m->current_bssid,
1138                  hex2str(m->current_essid, IW_ESSID_MAX_SIZE),
1139                  m->current_bss_type, m->power_mgmt_mode, m->ibss_change,
1140                  m->res, m->multi_domain_capability_implemented,
1141                  m->multi_domain_capability_enabled, m->country_string);
1142 exit:
1143         kfree(m);
1144 }
1145
1146 static void at76_dump_mib_mac(struct at76_priv *priv)
1147 {
1148         int ret;
1149         struct mib_mac *m = kmalloc(sizeof(struct mib_mac), GFP_KERNEL);
1150
1151         if (!m)
1152                 return;
1153
1154         ret = at76_get_mib(priv->udev, MIB_MAC, m, sizeof(struct mib_mac));
1155         if (ret < 0) {
1156                 printk(KERN_ERR "%s: at76_get_mib (MAC) failed: %d\n",
1157                        priv->netdev->name, ret);
1158                 goto exit;
1159         }
1160
1161         at76_dbg(DBG_MIB, "%s: MIB MAC: max_tx_msdu_lifetime %d "
1162                  "max_rx_lifetime %d frag_threshold %d rts_threshold %d "
1163                  "cwmin %d cwmax %d short_retry_time %d long_retry_time %d "
1164                  "scan_type %d scan_channel %d probe_delay %u "
1165                  "min_channel_time %d max_channel_time %d listen_int %d "
1166                  "desired_ssid %s desired_bssid %pM desired_bsstype %d",
1167                  priv->netdev->name, le32_to_cpu(m->max_tx_msdu_lifetime),
1168                  le32_to_cpu(m->max_rx_lifetime),
1169                  le16_to_cpu(m->frag_threshold), le16_to_cpu(m->rts_threshold),
1170                  le16_to_cpu(m->cwmin), le16_to_cpu(m->cwmax),
1171                  m->short_retry_time, m->long_retry_time, m->scan_type,
1172                  m->scan_channel, le16_to_cpu(m->probe_delay),
1173                  le16_to_cpu(m->min_channel_time),
1174                  le16_to_cpu(m->max_channel_time),
1175                  le16_to_cpu(m->listen_interval),
1176                  hex2str(m->desired_ssid, IW_ESSID_MAX_SIZE),
1177                  m->desired_bssid, m->desired_bsstype);
1178 exit:
1179         kfree(m);
1180 }
1181
1182 static void at76_dump_mib_phy(struct at76_priv *priv)
1183 {
1184         int ret;
1185         struct mib_phy *m = kmalloc(sizeof(struct mib_phy), GFP_KERNEL);
1186
1187         if (!m)
1188                 return;
1189
1190         ret = at76_get_mib(priv->udev, MIB_PHY, m, sizeof(struct mib_phy));
1191         if (ret < 0) {
1192                 printk(KERN_ERR "%s: at76_get_mib (PHY) failed: %d\n",
1193                        priv->netdev->name, ret);
1194                 goto exit;
1195         }
1196
1197         at76_dbg(DBG_MIB, "%s: MIB PHY: ed_threshold %d slot_time %d "
1198                  "sifs_time %d preamble_length %d plcp_header_length %d "
1199                  "mpdu_max_length %d cca_mode_supported %d operation_rate_set "
1200                  "0x%x 0x%x 0x%x 0x%x channel_id %d current_cca_mode %d "
1201                  "phy_type %d current_reg_domain %d",
1202                  priv->netdev->name, le32_to_cpu(m->ed_threshold),
1203                  le16_to_cpu(m->slot_time), le16_to_cpu(m->sifs_time),
1204                  le16_to_cpu(m->preamble_length),
1205                  le16_to_cpu(m->plcp_header_length),
1206                  le16_to_cpu(m->mpdu_max_length),
1207                  le16_to_cpu(m->cca_mode_supported), m->operation_rate_set[0],
1208                  m->operation_rate_set[1], m->operation_rate_set[2],
1209                  m->operation_rate_set[3], m->channel_id, m->current_cca_mode,
1210                  m->phy_type, m->current_reg_domain);
1211 exit:
1212         kfree(m);
1213 }
1214
1215 static void at76_dump_mib_local(struct at76_priv *priv)
1216 {
1217         int ret;
1218         struct mib_local *m = kmalloc(sizeof(struct mib_phy), GFP_KERNEL);
1219
1220         if (!m)
1221                 return;
1222
1223         ret = at76_get_mib(priv->udev, MIB_LOCAL, m, sizeof(struct mib_local));
1224         if (ret < 0) {
1225                 printk(KERN_ERR "%s: at76_get_mib (LOCAL) failed: %d\n",
1226                        priv->netdev->name, ret);
1227                 goto exit;
1228         }
1229
1230         at76_dbg(DBG_MIB, "%s: MIB LOCAL: beacon_enable %d "
1231                  "txautorate_fallback %d ssid_size %d promiscuous_mode %d "
1232                  "preamble_type %d", priv->netdev->name, m->beacon_enable,
1233                  m->txautorate_fallback, m->ssid_size, m->promiscuous_mode,
1234                  m->preamble_type);
1235 exit:
1236         kfree(m);
1237 }
1238
1239 static void at76_dump_mib_mdomain(struct at76_priv *priv)
1240 {
1241         int ret;
1242         struct mib_mdomain *m = kmalloc(sizeof(struct mib_mdomain), GFP_KERNEL);
1243
1244         if (!m)
1245                 return;
1246
1247         ret = at76_get_mib(priv->udev, MIB_MDOMAIN, m,
1248                            sizeof(struct mib_mdomain));
1249         if (ret < 0) {
1250                 printk(KERN_ERR "%s: at76_get_mib (MDOMAIN) failed: %d\n",
1251                        priv->netdev->name, ret);
1252                 goto exit;
1253         }
1254
1255         at76_dbg(DBG_MIB, "%s: MIB MDOMAIN: channel_list %s",
1256                  priv->netdev->name,
1257                  hex2str(m->channel_list, sizeof(m->channel_list)));
1258
1259         at76_dbg(DBG_MIB, "%s: MIB MDOMAIN: tx_powerlevel %s",
1260                  priv->netdev->name,
1261                  hex2str(m->tx_powerlevel, sizeof(m->tx_powerlevel)));
1262 exit:
1263         kfree(m);
1264 }
1265
1266 static int at76_get_current_bssid(struct at76_priv *priv)
1267 {
1268         int ret = 0;
1269         struct mib_mac_mgmt *mac_mgmt =
1270             kmalloc(sizeof(struct mib_mac_mgmt), GFP_KERNEL);
1271
1272         if (!mac_mgmt) {
1273                 ret = -ENOMEM;
1274                 goto exit;
1275         }
1276
1277         ret = at76_get_mib(priv->udev, MIB_MAC_MGMT, mac_mgmt,
1278                            sizeof(struct mib_mac_mgmt));
1279         if (ret < 0) {
1280                 printk(KERN_ERR "%s: at76_get_mib failed: %d\n",
1281                        priv->netdev->name, ret);
1282                 goto error;
1283         }
1284         memcpy(priv->bssid, mac_mgmt->current_bssid, ETH_ALEN);
1285         printk(KERN_INFO "%s: using BSSID %pM\n", priv->netdev->name,
1286                priv->bssid);
1287 error:
1288         kfree(mac_mgmt);
1289 exit:
1290         return ret;
1291 }
1292
1293 static int at76_get_current_channel(struct at76_priv *priv)
1294 {
1295         int ret = 0;
1296         struct mib_phy *phy = kmalloc(sizeof(struct mib_phy), GFP_KERNEL);
1297
1298         if (!phy) {
1299                 ret = -ENOMEM;
1300                 goto exit;
1301         }
1302         ret = at76_get_mib(priv->udev, MIB_PHY, phy, sizeof(struct mib_phy));
1303         if (ret < 0) {
1304                 printk(KERN_ERR "%s: at76_get_mib(MIB_PHY) failed: %d\n",
1305                        priv->netdev->name, ret);
1306                 goto error;
1307         }
1308         priv->channel = phy->channel_id;
1309 error:
1310         kfree(phy);
1311 exit:
1312         return ret;
1313 }
1314
1315 /**
1316  * at76_start_scan - start a scan
1317  *
1318  * @use_essid - use the configured ESSID in non passive mode
1319  */
1320 static int at76_start_scan(struct at76_priv *priv, int use_essid)
1321 {
1322         struct at76_req_scan scan;
1323
1324         memset(&scan, 0, sizeof(struct at76_req_scan));
1325         memset(scan.bssid, 0xff, ETH_ALEN);
1326
1327         if (use_essid) {
1328                 memcpy(scan.essid, priv->essid, IW_ESSID_MAX_SIZE);
1329                 scan.essid_size = priv->essid_size;
1330         } else
1331                 scan.essid_size = 0;
1332
1333         /* jal: why should we start at a certain channel? we do scan the whole
1334            range allowed by reg domain. */
1335         scan.channel = priv->channel;
1336
1337         /* atmelwlandriver differs between scan type 0 and 1 (active/passive)
1338            For ad-hoc mode, it uses type 0 only. */
1339         scan.scan_type = priv->scan_mode;
1340
1341         /* INFO: For probe_delay, not multiplying by 1024 as this will be
1342            slightly less than min_channel_time
1343            (per spec: probe delay < min. channel time) */
1344         scan.min_channel_time = cpu_to_le16(priv->scan_min_time);
1345         scan.max_channel_time = cpu_to_le16(priv->scan_max_time);
1346         scan.probe_delay = cpu_to_le16(priv->scan_min_time * 1000);
1347         scan.international_scan = 0;
1348
1349         /* other values are set to 0 for type 0 */
1350
1351         at76_dbg(DBG_PROGRESS, "%s: start_scan (use_essid = %d, intl = %d, "
1352                  "channel = %d, probe_delay = %d, scan_min_time = %d, "
1353                  "scan_max_time = %d)",
1354                  priv->netdev->name, use_essid,
1355                  scan.international_scan, scan.channel,
1356                  le16_to_cpu(scan.probe_delay),
1357                  le16_to_cpu(scan.min_channel_time),
1358                  le16_to_cpu(scan.max_channel_time));
1359
1360         return at76_set_card_command(priv->udev, CMD_SCAN, &scan, sizeof(scan));
1361 }
1362
1363 /* Enable monitor mode */
1364 static int at76_start_monitor(struct at76_priv *priv)
1365 {
1366         struct at76_req_scan scan;
1367         int ret;
1368
1369         memset(&scan, 0, sizeof(struct at76_req_scan));
1370         memset(scan.bssid, 0xff, ETH_ALEN);
1371
1372         scan.channel = priv->channel;
1373         scan.scan_type = SCAN_TYPE_PASSIVE;
1374         scan.international_scan = 0;
1375
1376         ret = at76_set_card_command(priv->udev, CMD_SCAN, &scan, sizeof(scan));
1377         if (ret >= 0)
1378                 ret = at76_get_cmd_status(priv->udev, CMD_SCAN);
1379
1380         return ret;
1381 }
1382
1383 static int at76_start_ibss(struct at76_priv *priv)
1384 {
1385         struct at76_req_ibss bss;
1386         int ret;
1387
1388         WARN_ON(priv->mac_state != MAC_OWN_IBSS);
1389         if (priv->mac_state != MAC_OWN_IBSS)
1390                 return -EBUSY;
1391
1392         memset(&bss, 0, sizeof(struct at76_req_ibss));
1393         memset(bss.bssid, 0xff, ETH_ALEN);
1394         memcpy(bss.essid, priv->essid, IW_ESSID_MAX_SIZE);
1395         bss.essid_size = priv->essid_size;
1396         bss.bss_type = ADHOC_MODE;
1397         bss.channel = priv->channel;
1398
1399         ret = at76_set_card_command(priv->udev, CMD_START_IBSS, &bss,
1400                                     sizeof(struct at76_req_ibss));
1401         if (ret < 0) {
1402                 printk(KERN_ERR "%s: start_ibss failed: %d\n",
1403                        priv->netdev->name, ret);
1404                 return ret;
1405         }
1406
1407         ret = at76_wait_completion(priv, CMD_START_IBSS);
1408         if (ret != CMD_STATUS_COMPLETE) {
1409                 printk(KERN_ERR "%s: start_ibss failed to complete, %d\n",
1410                        priv->netdev->name, ret);
1411                 return ret;
1412         }
1413
1414         ret = at76_get_current_bssid(priv);
1415         if (ret < 0)
1416                 return ret;
1417
1418         ret = at76_get_current_channel(priv);
1419         if (ret < 0)
1420                 return ret;
1421
1422         /* not sure what this is good for ??? */
1423         priv->mib_buf.type = MIB_MAC_MGMT;
1424         priv->mib_buf.size = 1;
1425         priv->mib_buf.index = offsetof(struct mib_mac_mgmt, ibss_change);
1426         priv->mib_buf.data.byte = 0;
1427
1428         ret = at76_set_mib(priv, &priv->mib_buf);
1429         if (ret < 0) {
1430                 printk(KERN_ERR "%s: set_mib (ibss change ok) failed: %d\n",
1431                        priv->netdev->name, ret);
1432                 return ret;
1433         }
1434
1435         netif_carrier_on(priv->netdev);
1436         netif_start_queue(priv->netdev);
1437         return 0;
1438 }
1439
1440 /* Request card to join BSS in managed or ad-hoc mode */
1441 static int at76_join_bss(struct at76_priv *priv, struct bss_info *ptr)
1442 {
1443         struct at76_req_join join;
1444
1445         BUG_ON(!ptr);
1446
1447         memset(&join, 0, sizeof(struct at76_req_join));
1448         memcpy(join.bssid, ptr->bssid, ETH_ALEN);
1449         memcpy(join.essid, ptr->ssid, ptr->ssid_len);
1450         join.essid_size = ptr->ssid_len;
1451         join.bss_type = (priv->iw_mode == IW_MODE_ADHOC ? 1 : 2);
1452         join.channel = ptr->channel;
1453         join.timeout = cpu_to_le16(2000);
1454
1455         at76_dbg(DBG_PROGRESS,
1456                  "%s join addr %pM ssid %s stype %d ch %d timeout %d",
1457                  priv->netdev->name, join.bssid, join.essid,
1458                  join.bss_type, join.channel, le16_to_cpu(join.timeout));
1459         return at76_set_card_command(priv->udev, CMD_JOIN, &join,
1460                                      sizeof(struct at76_req_join));
1461 }
1462
1463 /* Calculate padding from txbuf->wlength (which excludes the USB TX header),
1464    likely to compensate a flaw in the AT76C503A USB part ... */
1465 static inline int at76_calc_padding(int wlen)
1466 {
1467         /* add the USB TX header */
1468         wlen += AT76_TX_HDRLEN;
1469
1470         wlen = wlen % 64;
1471
1472         if (wlen < 50)
1473                 return 50 - wlen;
1474
1475         if (wlen >= 61)
1476                 return 64 + 50 - wlen;
1477
1478         return 0;
1479 }
1480
1481 /* We are doing a lot of things here in an interrupt. Need
1482    a bh handler (Watching TV with a TV card is probably
1483    a good test: if you see flickers, we are doing too much.
1484    Currently I do see flickers... even with our tasklet :-( )
1485    Maybe because the bttv driver and usb-uhci use the same interrupt
1486 */
1487 /* Or maybe because our BH handler is preempting bttv's BH handler.. BHs don't
1488  * solve everything.. (alex) */
1489 static void at76_rx_callback(struct urb *urb)
1490 {
1491         struct at76_priv *priv = urb->context;
1492
1493         priv->rx_tasklet.data = (unsigned long)urb;
1494         tasklet_schedule(&priv->rx_tasklet);
1495         return;
1496 }
1497
1498 static void at76_tx_callback(struct urb *urb)
1499 {
1500         struct at76_priv *priv = urb->context;
1501         struct net_device_stats *stats = &priv->stats;
1502         unsigned long flags;
1503         struct at76_tx_buffer *mgmt_buf;
1504         int ret;
1505
1506         switch (urb->status) {
1507         case 0:
1508                 stats->tx_packets++;
1509                 break;
1510         case -ENOENT:
1511         case -ECONNRESET:
1512                 /* urb has been unlinked */
1513                 return;
1514         default:
1515                 at76_dbg(DBG_URB, "%s - nonzero tx status received: %d",
1516                          __func__, urb->status);
1517                 stats->tx_errors++;
1518                 break;
1519         }
1520
1521         spin_lock_irqsave(&priv->mgmt_spinlock, flags);
1522         mgmt_buf = priv->next_mgmt_bulk;
1523         priv->next_mgmt_bulk = NULL;
1524         spin_unlock_irqrestore(&priv->mgmt_spinlock, flags);
1525
1526         if (!mgmt_buf) {
1527                 netif_wake_queue(priv->netdev);
1528                 return;
1529         }
1530
1531         /* we don't copy the padding bytes, but add them
1532            to the length */
1533         memcpy(priv->bulk_out_buffer, mgmt_buf,
1534                le16_to_cpu(mgmt_buf->wlength) + AT76_TX_HDRLEN);
1535         usb_fill_bulk_urb(priv->tx_urb, priv->udev, priv->tx_pipe,
1536                           priv->bulk_out_buffer,
1537                           le16_to_cpu(mgmt_buf->wlength) + mgmt_buf->padding +
1538                           AT76_TX_HDRLEN, at76_tx_callback, priv);
1539         ret = usb_submit_urb(priv->tx_urb, GFP_ATOMIC);
1540         if (ret)
1541                 printk(KERN_ERR "%s: error in tx submit urb: %d\n",
1542                        priv->netdev->name, ret);
1543
1544         kfree(mgmt_buf);
1545 }
1546
1547 /* Send a management frame on bulk-out.  txbuf->wlength must be set */
1548 static int at76_tx_mgmt(struct at76_priv *priv, struct at76_tx_buffer *txbuf)
1549 {
1550         unsigned long flags;
1551         int ret;
1552         int urb_status;
1553         void *oldbuf = NULL;
1554
1555         netif_carrier_off(priv->netdev);        /* stop netdev watchdog */
1556         netif_stop_queue(priv->netdev); /* stop tx data packets */
1557
1558         spin_lock_irqsave(&priv->mgmt_spinlock, flags);
1559
1560         urb_status = priv->tx_urb->status;
1561         if (urb_status == -EINPROGRESS) {
1562                 /* cannot transmit now, put in the queue */
1563                 oldbuf = priv->next_mgmt_bulk;
1564                 priv->next_mgmt_bulk = txbuf;
1565         }
1566         spin_unlock_irqrestore(&priv->mgmt_spinlock, flags);
1567
1568         if (oldbuf) {
1569                 /* a data/mgmt tx is already pending in the URB -
1570                    if this is no error in some situations we must
1571                    implement a queue or silently modify the old msg */
1572                 printk(KERN_ERR "%s: removed pending mgmt buffer %s\n",
1573                        priv->netdev->name, hex2str(oldbuf, 64));
1574                 kfree(oldbuf);
1575                 return 0;
1576         }
1577
1578         txbuf->tx_rate = TX_RATE_1MBIT;
1579         txbuf->padding = at76_calc_padding(le16_to_cpu(txbuf->wlength));
1580         memset(txbuf->reserved, 0, sizeof(txbuf->reserved));
1581
1582         if (priv->next_mgmt_bulk)
1583                 printk(KERN_ERR "%s: URB status %d, but mgmt is pending\n",
1584                        priv->netdev->name, urb_status);
1585
1586         at76_dbg(DBG_TX_MGMT,
1587                  "%s: tx mgmt: wlen %d tx_rate %d pad %d %s",
1588                  priv->netdev->name, le16_to_cpu(txbuf->wlength),
1589                  txbuf->tx_rate, txbuf->padding,
1590                  hex2str(txbuf->packet, le16_to_cpu(txbuf->wlength)));
1591
1592         /* txbuf was not consumed above -> send mgmt msg immediately */
1593         memcpy(priv->bulk_out_buffer, txbuf,
1594                le16_to_cpu(txbuf->wlength) + AT76_TX_HDRLEN);
1595         usb_fill_bulk_urb(priv->tx_urb, priv->udev, priv->tx_pipe,
1596                           priv->bulk_out_buffer,
1597                           le16_to_cpu(txbuf->wlength) + txbuf->padding +
1598                           AT76_TX_HDRLEN, at76_tx_callback, priv);
1599         ret = usb_submit_urb(priv->tx_urb, GFP_ATOMIC);
1600         if (ret)
1601                 printk(KERN_ERR "%s: error in tx submit urb: %d\n",
1602                        priv->netdev->name, ret);
1603
1604         kfree(txbuf);
1605
1606         return ret;
1607 }
1608
1609 /* Go to the next information element */
1610 static inline void next_ie(struct ieee80211_info_element **ie)
1611 {
1612         *ie = (struct ieee80211_info_element *)(&(*ie)->data[(*ie)->len]);
1613 }
1614
1615 /* Challenge is the challenge string (in TLV format)
1616    we got with seq_nr 2 for shared secret authentication only and
1617    send in seq_nr 3 WEP encrypted to prove we have the correct WEP key;
1618    otherwise it is NULL */
1619 static int at76_auth_req(struct at76_priv *priv, struct bss_info *bss,
1620                          int seq_nr, struct ieee80211_info_element *challenge)
1621 {
1622         struct at76_tx_buffer *tx_buffer;
1623         struct ieee80211_hdr_3addr *mgmt;
1624         struct ieee80211_auth *req;
1625         int buf_len = (seq_nr != 3 ? AUTH_FRAME_SIZE :
1626                        AUTH_FRAME_SIZE + 1 + 1 + challenge->len);
1627
1628         BUG_ON(!bss);
1629         BUG_ON(seq_nr == 3 && !challenge);
1630         tx_buffer = kmalloc(buf_len + MAX_PADDING_SIZE, GFP_ATOMIC);
1631         if (!tx_buffer)
1632                 return -ENOMEM;
1633
1634         req = (struct ieee80211_auth *)tx_buffer->packet;
1635         mgmt = &req->header;
1636
1637         /* make wireless header */
1638         /* first auth msg is not encrypted, only the second (seq_nr == 3) */
1639         mgmt->frame_ctl =
1640             cpu_to_le16(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_AUTH |
1641                         (seq_nr == 3 ? IEEE80211_FCTL_PROTECTED : 0));
1642
1643         mgmt->duration_id = cpu_to_le16(0x8000);
1644         memcpy(mgmt->addr1, bss->bssid, ETH_ALEN);
1645         memcpy(mgmt->addr2, priv->netdev->dev_addr, ETH_ALEN);
1646         memcpy(mgmt->addr3, bss->bssid, ETH_ALEN);
1647         mgmt->seq_ctl = cpu_to_le16(0);
1648
1649         req->algorithm = cpu_to_le16(priv->auth_mode);
1650         req->transaction = cpu_to_le16(seq_nr);
1651         req->status = cpu_to_le16(0);
1652
1653         if (seq_nr == 3)
1654                 memcpy(req->info_element, challenge, 1 + 1 + challenge->len);
1655
1656         /* init. at76_priv tx header */
1657         tx_buffer->wlength = cpu_to_le16(buf_len - AT76_TX_HDRLEN);
1658         at76_dbg(DBG_TX_MGMT, "%s: AuthReq bssid %pM alg %d seq_nr %d",
1659                  priv->netdev->name, mgmt->addr3,
1660                  le16_to_cpu(req->algorithm), le16_to_cpu(req->transaction));
1661         if (seq_nr == 3)
1662                 at76_dbg(DBG_TX_MGMT, "%s: AuthReq challenge: %s ...",
1663                          priv->netdev->name, hex2str(req->info_element, 18));
1664
1665         /* either send immediately (if no data tx is pending
1666            or put it in pending list */
1667         return at76_tx_mgmt(priv, tx_buffer);
1668 }
1669
1670 static int at76_assoc_req(struct at76_priv *priv, struct bss_info *bss)
1671 {
1672         struct at76_tx_buffer *tx_buffer;
1673         struct ieee80211_hdr_3addr *mgmt;
1674         struct ieee80211_assoc_request *req;
1675         struct ieee80211_info_element *ie;
1676         char *essid;
1677         int essid_len;
1678         u16 capa;
1679
1680         BUG_ON(!bss);
1681
1682         tx_buffer = kmalloc(ASSOCREQ_MAX_SIZE + MAX_PADDING_SIZE, GFP_ATOMIC);
1683         if (!tx_buffer)
1684                 return -ENOMEM;
1685
1686         req = (struct ieee80211_assoc_request *)tx_buffer->packet;
1687         mgmt = &req->header;
1688         ie = req->info_element;
1689
1690         /* make wireless header */
1691         mgmt->frame_ctl = cpu_to_le16(IEEE80211_FTYPE_MGMT |
1692                                       IEEE80211_STYPE_ASSOC_REQ);
1693
1694         mgmt->duration_id = cpu_to_le16(0x8000);
1695         memcpy(mgmt->addr1, bss->bssid, ETH_ALEN);
1696         memcpy(mgmt->addr2, priv->netdev->dev_addr, ETH_ALEN);
1697         memcpy(mgmt->addr3, bss->bssid, ETH_ALEN);
1698         mgmt->seq_ctl = cpu_to_le16(0);
1699
1700         /* we must set the Privacy bit in the capabilities to assure an
1701            Agere-based AP with optional WEP transmits encrypted frames
1702            to us.  AP only set the Privacy bit in their capabilities
1703            if WEP is mandatory in the BSS! */
1704         capa = bss->capa;
1705         if (priv->wep_enabled)
1706                 capa |= WLAN_CAPABILITY_PRIVACY;
1707         if (priv->preamble_type != PREAMBLE_TYPE_LONG)
1708                 capa |= WLAN_CAPABILITY_SHORT_PREAMBLE;
1709         req->capability = cpu_to_le16(capa);
1710
1711         req->listen_interval = cpu_to_le16(2 * bss->beacon_interval);
1712
1713         /* write TLV data elements */
1714
1715         ie->id = WLAN_EID_SSID;
1716         ie->len = bss->ssid_len;
1717         memcpy(ie->data, bss->ssid, bss->ssid_len);
1718         next_ie(&ie);
1719
1720         ie->id = WLAN_EID_SUPP_RATES;
1721         ie->len = sizeof(hw_rates);
1722         memcpy(ie->data, hw_rates, sizeof(hw_rates));
1723         next_ie(&ie);           /* ie points behind the supp_rates field */
1724
1725         /* init. at76_priv tx header */
1726         tx_buffer->wlength = cpu_to_le16((u8 *)ie - (u8 *)mgmt);
1727
1728         ie = req->info_element;
1729         essid = ie->data;
1730         essid_len = min_t(int, IW_ESSID_MAX_SIZE, ie->len);
1731
1732         next_ie(&ie);           /* points to IE of rates now */
1733         at76_dbg(DBG_TX_MGMT,
1734                  "%s: AssocReq bssid %pM capa 0x%04x ssid %.*s rates %s",
1735                  priv->netdev->name, mgmt->addr3,
1736                  le16_to_cpu(req->capability), essid_len, essid,
1737                  hex2str(ie->data, ie->len));
1738
1739         /* either send immediately (if no data tx is pending
1740            or put it in pending list */
1741         return at76_tx_mgmt(priv, tx_buffer);
1742 }
1743
1744 /* We got to check the bss_list for old entries */
1745 static void at76_bss_list_timeout(unsigned long par)
1746 {
1747         struct at76_priv *priv = (struct at76_priv *)par;
1748         unsigned long flags;
1749         struct list_head *lptr, *nptr;
1750         struct bss_info *ptr;
1751
1752         spin_lock_irqsave(&priv->bss_list_spinlock, flags);
1753
1754         list_for_each_safe(lptr, nptr, &priv->bss_list) {
1755
1756                 ptr = list_entry(lptr, struct bss_info, list);
1757
1758                 if (ptr != priv->curr_bss
1759                     && time_after(jiffies, ptr->last_rx + BSS_LIST_TIMEOUT)) {
1760                         at76_dbg(DBG_BSS_TABLE_RM,
1761                                  "%s: bss_list: removing old BSS %pM ch %d",
1762                                  priv->netdev->name, ptr->bssid,
1763                                  ptr->channel);
1764                         list_del(&ptr->list);
1765                         kfree(ptr);
1766                 }
1767         }
1768         spin_unlock_irqrestore(&priv->bss_list_spinlock, flags);
1769         /* restart the timer */
1770         mod_timer(&priv->bss_list_timer, jiffies + BSS_LIST_TIMEOUT);
1771 }
1772
1773 static inline void at76_set_mac_state(struct at76_priv *priv,
1774                                       enum mac_state mac_state)
1775 {
1776         at76_dbg(DBG_MAC_STATE, "%s state: %s", priv->netdev->name,
1777                  mac_states[mac_state]);
1778         priv->mac_state = mac_state;
1779 }
1780
1781 static void at76_dump_bss_table(struct at76_priv *priv)
1782 {
1783         struct bss_info *ptr;
1784         unsigned long flags;
1785         struct list_head *lptr;
1786
1787         spin_lock_irqsave(&priv->bss_list_spinlock, flags);
1788
1789         at76_dbg(DBG_BSS_TABLE, "%s BSS table (curr=%p):", priv->netdev->name,
1790                  priv->curr_bss);
1791
1792         list_for_each(lptr, &priv->bss_list) {
1793                 ptr = list_entry(lptr, struct bss_info, list);
1794                 at76_dbg(DBG_BSS_TABLE, "0x%p: bssid %pM channel %d ssid %.*s "
1795                          "(%s) capa 0x%04x rates %s rssi %d link %d noise %d",
1796                          ptr, ptr->bssid, ptr->channel, ptr->ssid_len,
1797                          ptr->ssid, hex2str(ptr->ssid, ptr->ssid_len),
1798                          ptr->capa, hex2str(ptr->rates, ptr->rates_len),
1799                          ptr->rssi, ptr->link_qual, ptr->noise_level);
1800         }
1801         spin_unlock_irqrestore(&priv->bss_list_spinlock, flags);
1802 }
1803
1804 /* Called upon successful association to mark interface as connected */
1805 static void at76_work_assoc_done(struct work_struct *work)
1806 {
1807         struct at76_priv *priv = container_of(work, struct at76_priv,
1808                                               work_assoc_done);
1809
1810         mutex_lock(&priv->mtx);
1811
1812         WARN_ON(priv->mac_state != MAC_ASSOC);
1813         WARN_ON(!priv->curr_bss);
1814         if (priv->mac_state != MAC_ASSOC || !priv->curr_bss)
1815                 goto exit;
1816
1817         if (priv->iw_mode == IW_MODE_INFRA) {
1818                 if (priv->pm_mode != AT76_PM_OFF) {
1819                         /* calculate the listen interval in units of
1820                            beacon intervals of the curr_bss */
1821                         u32 pm_period_beacon = (priv->pm_period >> 10) /
1822                             priv->curr_bss->beacon_interval;
1823
1824                         pm_period_beacon = max(pm_period_beacon, 2u);
1825                         pm_period_beacon = min(pm_period_beacon, 0xffffu);
1826
1827                         at76_dbg(DBG_PM,
1828                                  "%s: pm_mode %d assoc id 0x%x listen int %d",
1829                                  priv->netdev->name, priv->pm_mode,
1830                                  priv->assoc_id, pm_period_beacon);
1831
1832                         at76_set_associd(priv, priv->assoc_id);
1833                         at76_set_listen_interval(priv, (u16)pm_period_beacon);
1834                 }
1835                 schedule_delayed_work(&priv->dwork_beacon, BEACON_TIMEOUT);
1836         }
1837         at76_set_pm_mode(priv);
1838
1839         netif_carrier_on(priv->netdev);
1840         netif_wake_queue(priv->netdev);
1841         at76_set_mac_state(priv, MAC_CONNECTED);
1842         at76_iwevent_bss_connect(priv->netdev, priv->curr_bss->bssid);
1843         at76_dbg(DBG_PROGRESS, "%s: connected to BSSID %pM",
1844                  priv->netdev->name, priv->curr_bss->bssid);
1845
1846 exit:
1847         mutex_unlock(&priv->mtx);
1848 }
1849
1850 /* We only store the new mac address in netdev struct,
1851    it gets set when the netdev is opened. */
1852 static int at76_set_mac_address(struct net_device *netdev, void *addr)
1853 {
1854         struct sockaddr *mac = addr;
1855         memcpy(netdev->dev_addr, mac->sa_data, ETH_ALEN);
1856         return 1;
1857 }
1858
1859 static struct net_device_stats *at76_get_stats(struct net_device *netdev)
1860 {
1861         struct at76_priv *priv = netdev_priv(netdev);
1862         return &priv->stats;
1863 }
1864
1865 static struct iw_statistics *at76_get_wireless_stats(struct net_device *netdev)
1866 {
1867         struct at76_priv *priv = netdev_priv(netdev);
1868
1869         at76_dbg(DBG_IOCTL, "RETURN qual %d level %d noise %d updated %d",
1870                  priv->wstats.qual.qual, priv->wstats.qual.level,
1871                  priv->wstats.qual.noise, priv->wstats.qual.updated);
1872
1873         return &priv->wstats;
1874 }
1875
1876 static void at76_set_multicast(struct net_device *netdev)
1877 {
1878         struct at76_priv *priv = netdev_priv(netdev);
1879         int promisc;
1880
1881         promisc = ((netdev->flags & IFF_PROMISC) != 0);
1882         if (promisc != priv->promisc) {
1883                 /* This gets called in interrupt, must reschedule */
1884                 priv->promisc = promisc;
1885                 schedule_work(&priv->work_set_promisc);
1886         }
1887 }
1888
1889 /* Stop all network activity, flush all pending tasks */
1890 static void at76_quiesce(struct at76_priv *priv)
1891 {
1892         unsigned long flags;
1893
1894         netif_stop_queue(priv->netdev);
1895         netif_carrier_off(priv->netdev);
1896
1897         at76_set_mac_state(priv, MAC_INIT);
1898
1899         cancel_delayed_work(&priv->dwork_get_scan);
1900         cancel_delayed_work(&priv->dwork_beacon);
1901         cancel_delayed_work(&priv->dwork_auth);
1902         cancel_delayed_work(&priv->dwork_assoc);
1903         cancel_delayed_work(&priv->dwork_restart);
1904
1905         spin_lock_irqsave(&priv->mgmt_spinlock, flags);
1906         kfree(priv->next_mgmt_bulk);
1907         priv->next_mgmt_bulk = NULL;
1908         spin_unlock_irqrestore(&priv->mgmt_spinlock, flags);
1909 }
1910
1911 /*******************************************************************************
1912  * at76_priv implementations of iw_handler functions:
1913  */
1914 static int at76_iw_handler_commit(struct net_device *netdev,
1915                                   struct iw_request_info *info,
1916                                   void *null, char *extra)
1917 {
1918         struct at76_priv *priv = netdev_priv(netdev);
1919
1920         at76_dbg(DBG_IOCTL, "%s %s: restarting the device", netdev->name,
1921                  __func__);
1922
1923         if (priv->mac_state != MAC_INIT)
1924                 at76_quiesce(priv);
1925
1926         /* Wait half second before the restart to process subsequent
1927          * requests from the same iwconfig in a single restart */
1928         schedule_delayed_work(&priv->dwork_restart, HZ / 2);
1929
1930         return 0;
1931 }
1932
1933 static int at76_iw_handler_get_name(struct net_device *netdev,
1934                                     struct iw_request_info *info,
1935                                     char *name, char *extra)
1936 {
1937         strcpy(name, "IEEE 802.11b");
1938         at76_dbg(DBG_IOCTL, "%s: SIOCGIWNAME - name %s", netdev->name, name);
1939         return 0;
1940 }
1941
1942 static int at76_iw_handler_set_freq(struct net_device *netdev,
1943                                     struct iw_request_info *info,
1944                                     struct iw_freq *freq, char *extra)
1945 {
1946         struct at76_priv *priv = netdev_priv(netdev);
1947         int chan = -1;
1948         int ret = -EIWCOMMIT;
1949         at76_dbg(DBG_IOCTL, "%s: SIOCSIWFREQ - freq.m %d freq.e %d",
1950                  netdev->name, freq->m, freq->e);
1951
1952         if ((freq->e == 0) && (freq->m <= 1000))
1953                 /* Setting by channel number */
1954                 chan = freq->m;
1955         else {
1956                 /* Setting by frequency - search the table */
1957                 int mult = 1;
1958                 int i;
1959
1960                 for (i = 0; i < (6 - freq->e); i++)
1961                         mult *= 10;
1962
1963                 for (i = 0; i < NUM_CHANNELS; i++) {
1964                         if (freq->m == (channel_frequency[i] * mult))
1965                                 chan = i + 1;
1966                 }
1967         }
1968
1969         if (chan < 1 || !priv->domain)
1970                 /* non-positive channels are invalid
1971                  * we need a domain info to set the channel
1972                  * either that or an invalid frequency was
1973                  * provided by the user */
1974                 ret = -EINVAL;
1975         else if (!(priv->domain->channel_map & (1 << (chan - 1)))) {
1976                 printk(KERN_INFO "%s: channel %d not allowed for domain %s\n",
1977                        priv->netdev->name, chan, priv->domain->name);
1978                 ret = -EINVAL;
1979         }
1980
1981         if (ret == -EIWCOMMIT) {
1982                 priv->channel = chan;
1983                 at76_dbg(DBG_IOCTL, "%s: SIOCSIWFREQ - ch %d", netdev->name,
1984                          chan);
1985         }
1986
1987         return ret;
1988 }
1989
1990 static int at76_iw_handler_get_freq(struct net_device *netdev,
1991                                     struct iw_request_info *info,
1992                                     struct iw_freq *freq, char *extra)
1993 {
1994         struct at76_priv *priv = netdev_priv(netdev);
1995
1996         freq->m = priv->channel;
1997         freq->e = 0;
1998
1999         if (priv->channel)
2000                 at76_dbg(DBG_IOCTL, "%s: SIOCGIWFREQ - freq %ld x 10e%d",
2001                          netdev->name, channel_frequency[priv->channel - 1], 6);
2002
2003         at76_dbg(DBG_IOCTL, "%s: SIOCGIWFREQ - ch %d", netdev->name,
2004                  priv->channel);
2005
2006         return 0;
2007 }
2008
2009 static int at76_iw_handler_set_mode(struct net_device *netdev,
2010                                     struct iw_request_info *info,
2011                                     __u32 *mode, char *extra)
2012 {
2013         struct at76_priv *priv = netdev_priv(netdev);
2014
2015         at76_dbg(DBG_IOCTL, "%s: SIOCSIWMODE - %d", netdev->name, *mode);
2016
2017         if ((*mode != IW_MODE_ADHOC) && (*mode != IW_MODE_INFRA) &&
2018             (*mode != IW_MODE_MONITOR))
2019                 return -EINVAL;
2020
2021         priv->iw_mode = *mode;
2022         if (priv->iw_mode != IW_MODE_INFRA)
2023                 priv->pm_mode = AT76_PM_OFF;
2024
2025         return -EIWCOMMIT;
2026 }
2027
2028 static int at76_iw_handler_get_mode(struct net_device *netdev,
2029                                     struct iw_request_info *info,
2030                                     __u32 *mode, char *extra)
2031 {
2032         struct at76_priv *priv = netdev_priv(netdev);
2033
2034         *mode = priv->iw_mode;
2035
2036         at76_dbg(DBG_IOCTL, "%s: SIOCGIWMODE - %d", netdev->name, *mode);
2037
2038         return 0;
2039 }
2040
2041 static int at76_iw_handler_get_range(struct net_device *netdev,
2042                                      struct iw_request_info *info,
2043                                      struct iw_point *data, char *extra)
2044 {
2045         /* inspired by atmel.c */
2046         struct at76_priv *priv = netdev_priv(netdev);
2047         struct iw_range *range = (struct iw_range *)extra;
2048         int i;
2049
2050         data->length = sizeof(struct iw_range);
2051         memset(range, 0, sizeof(struct iw_range));
2052
2053         /* TODO: range->throughput = xxxxxx; */
2054
2055         range->min_nwid = 0x0000;
2056         range->max_nwid = 0x0000;
2057
2058         /* this driver doesn't maintain sensitivity information */
2059         range->sensitivity = 0;
2060
2061         range->max_qual.qual = 100;
2062         range->max_qual.level = 100;
2063         range->max_qual.noise = 0;
2064         range->max_qual.updated = IW_QUAL_NOISE_INVALID;
2065
2066         range->avg_qual.qual = 50;
2067         range->avg_qual.level = 50;
2068         range->avg_qual.noise = 0;
2069         range->avg_qual.updated = IW_QUAL_NOISE_INVALID;
2070
2071         range->bitrate[0] = 1000000;
2072         range->bitrate[1] = 2000000;
2073         range->bitrate[2] = 5500000;
2074         range->bitrate[3] = 11000000;
2075         range->num_bitrates = 4;
2076
2077         range->min_rts = 0;
2078         range->max_rts = MAX_RTS_THRESHOLD;
2079
2080         range->min_frag = MIN_FRAG_THRESHOLD;
2081         range->max_frag = MAX_FRAG_THRESHOLD;
2082
2083         range->pmp_flags = IW_POWER_PERIOD;
2084         range->pmt_flags = IW_POWER_ON;
2085         range->pm_capa = IW_POWER_PERIOD | IW_POWER_ALL_R;
2086
2087         range->encoding_size[0] = WEP_SMALL_KEY_LEN;
2088         range->encoding_size[1] = WEP_LARGE_KEY_LEN;
2089         range->num_encoding_sizes = 2;
2090         range->max_encoding_tokens = WEP_KEYS;
2091
2092         /* both WL-240U and Linksys WUSB11 v2.6 specify 15 dBm as output power
2093            - take this for all (ignore antenna gains) */
2094         range->txpower[0] = 15;
2095         range->num_txpower = 1;
2096         range->txpower_capa = IW_TXPOW_DBM;
2097
2098         range->we_version_source = WIRELESS_EXT;
2099         range->we_version_compiled = WIRELESS_EXT;
2100
2101         /* same as the values used in atmel.c */
2102         range->retry_capa = IW_RETRY_LIMIT;
2103         range->retry_flags = IW_RETRY_LIMIT;
2104         range->r_time_flags = 0;
2105         range->min_retry = 1;
2106         range->max_retry = 255;
2107
2108         range->num_channels = NUM_CHANNELS;
2109         range->num_frequency = 0;
2110
2111         for (i = 0; i < NUM_CHANNELS; i++) {
2112                 /* test if channel map bit is raised */
2113                 if (priv->domain->channel_map & (0x1 << i)) {
2114                         range->num_frequency += 1;
2115
2116                         range->freq[i].i = i + 1;
2117                         range->freq[i].m = channel_frequency[i] * 100000;
2118                         range->freq[i].e = 1;   /* freq * 10^1 */
2119                 }
2120         }
2121
2122         at76_dbg(DBG_IOCTL, "%s: SIOCGIWRANGE", netdev->name);
2123
2124         return 0;
2125 }
2126
2127 static int at76_iw_handler_set_spy(struct net_device *netdev,
2128                                    struct iw_request_info *info,
2129                                    struct iw_point *data, char *extra)
2130 {
2131         struct at76_priv *priv = netdev_priv(netdev);
2132         int ret = 0;
2133
2134         at76_dbg(DBG_IOCTL, "%s: SIOCSIWSPY - number of addresses %d",
2135                  netdev->name, data->length);
2136
2137         spin_lock_bh(&priv->spy_spinlock);
2138         ret = iw_handler_set_spy(priv->netdev, info, (union iwreq_data *)data,
2139                                  extra);
2140         spin_unlock_bh(&priv->spy_spinlock);
2141
2142         return ret;
2143 }
2144
2145 static int at76_iw_handler_get_spy(struct net_device *netdev,
2146                                    struct iw_request_info *info,
2147                                    struct iw_point *data, char *extra)
2148 {
2149
2150         struct at76_priv *priv = netdev_priv(netdev);
2151         int ret = 0;
2152
2153         spin_lock_bh(&priv->spy_spinlock);
2154         ret = iw_handler_get_spy(priv->netdev, info,
2155                                  (union iwreq_data *)data, extra);
2156         spin_unlock_bh(&priv->spy_spinlock);
2157
2158         at76_dbg(DBG_IOCTL, "%s: SIOCGIWSPY - number of addresses %d",
2159                  netdev->name, data->length);
2160
2161         return ret;
2162 }
2163
2164 static int at76_iw_handler_set_thrspy(struct net_device *netdev,
2165                                       struct iw_request_info *info,
2166                                       struct iw_point *data, char *extra)
2167 {
2168         struct at76_priv *priv = netdev_priv(netdev);
2169         int ret;
2170
2171         at76_dbg(DBG_IOCTL, "%s: SIOCSIWTHRSPY - number of addresses %d)",
2172                  netdev->name, data->length);
2173
2174         spin_lock_bh(&priv->spy_spinlock);
2175         ret = iw_handler_set_thrspy(netdev, info, (union iwreq_data *)data,
2176                                     extra);
2177         spin_unlock_bh(&priv->spy_spinlock);
2178
2179         return ret;
2180 }
2181
2182 static int at76_iw_handler_get_thrspy(struct net_device *netdev,
2183                                       struct iw_request_info *info,
2184                                       struct iw_point *data, char *extra)
2185 {
2186         struct at76_priv *priv = netdev_priv(netdev);
2187         int ret;
2188
2189         spin_lock_bh(&priv->spy_spinlock);
2190         ret = iw_handler_get_thrspy(netdev, info, (union iwreq_data *)data,
2191                                     extra);
2192         spin_unlock_bh(&priv->spy_spinlock);
2193
2194         at76_dbg(DBG_IOCTL, "%s: SIOCGIWTHRSPY - number of addresses %d)",
2195                  netdev->name, data->length);
2196
2197         return ret;
2198 }
2199
2200 static int at76_iw_handler_set_wap(struct net_device *netdev,
2201                                    struct iw_request_info *info,
2202                                    struct sockaddr *ap_addr, char *extra)
2203 {
2204         struct at76_priv *priv = netdev_priv(netdev);
2205
2206         at76_dbg(DBG_IOCTL, "%s: SIOCSIWAP - wap/bssid %pM", netdev->name,
2207                  ap_addr->sa_data);
2208
2209         /* if the incoming address == ff:ff:ff:ff:ff:ff, the user has
2210            chosen any or auto AP preference */
2211         if (is_broadcast_ether_addr(ap_addr->sa_data)
2212             || is_zero_ether_addr(ap_addr->sa_data))
2213                 priv->wanted_bssid_valid = 0;
2214         else {
2215                 /* user wants to set a preferred AP address */
2216                 priv->wanted_bssid_valid = 1;
2217                 memcpy(priv->wanted_bssid, ap_addr->sa_data, ETH_ALEN);
2218         }
2219
2220         return -EIWCOMMIT;
2221 }
2222
2223 static int at76_iw_handler_get_wap(struct net_device *netdev,
2224                                    struct iw_request_info *info,
2225                                    struct sockaddr *ap_addr, char *extra)
2226 {
2227         struct at76_priv *priv = netdev_priv(netdev);
2228
2229         ap_addr->sa_family = ARPHRD_ETHER;
2230         memcpy(ap_addr->sa_data, priv->bssid, ETH_ALEN);
2231
2232         at76_dbg(DBG_IOCTL, "%s: SIOCGIWAP - wap/bssid %pM", netdev->name,
2233                  ap_addr->sa_data);
2234
2235         return 0;
2236 }
2237
2238 static int at76_iw_handler_set_scan(struct net_device *netdev,
2239                                     struct iw_request_info *info,
2240                                     union iwreq_data *wrqu, char *extra)
2241 {
2242         struct at76_priv *priv = netdev_priv(netdev);
2243         int ret = 0;
2244
2245         at76_dbg(DBG_IOCTL, "%s: SIOCSIWSCAN", netdev->name);
2246
2247         if (mutex_lock_interruptible(&priv->mtx))
2248                 return -EINTR;
2249
2250         if (!netif_running(netdev)) {
2251                 ret = -ENETDOWN;
2252                 goto exit;
2253         }
2254
2255         /* jal: we don't allow "iwlist ethX scan" while we are
2256            in monitor mode */
2257         if (priv->iw_mode == IW_MODE_MONITOR) {
2258                 ret = -EBUSY;
2259                 goto exit;
2260         }
2261
2262         /* Discard old scan results */
2263         if ((jiffies - priv->last_scan) > (20 * HZ))
2264                 priv->scan_state = SCAN_IDLE;
2265         priv->last_scan = jiffies;
2266
2267         /* Initiate a scan command */
2268         if (priv->scan_state == SCAN_IN_PROGRESS) {
2269                 ret = -EBUSY;
2270                 goto exit;
2271         }
2272
2273         priv->scan_state = SCAN_IN_PROGRESS;
2274
2275         at76_quiesce(priv);
2276
2277         /* Try to do passive or active scan if WE asks as. */
2278         if (wrqu->data.length
2279             && wrqu->data.length == sizeof(struct iw_scan_req)) {
2280                 struct iw_scan_req *req = (struct iw_scan_req *)extra;
2281
2282                 if (req->scan_type == IW_SCAN_TYPE_PASSIVE)
2283                         priv->scan_mode = SCAN_TYPE_PASSIVE;
2284                 else if (req->scan_type == IW_SCAN_TYPE_ACTIVE)
2285                         priv->scan_mode = SCAN_TYPE_ACTIVE;
2286
2287                 /* Sanity check values? */
2288                 if (req->min_channel_time > 0)
2289                         priv->scan_min_time = req->min_channel_time;
2290
2291                 if (req->max_channel_time > 0)
2292                         priv->scan_max_time = req->max_channel_time;
2293         }
2294
2295         /* change to scanning state */
2296         at76_set_mac_state(priv, MAC_SCANNING);
2297         schedule_work(&priv->work_start_scan);
2298
2299 exit:
2300         mutex_unlock(&priv->mtx);
2301         return ret;
2302 }
2303
2304 static int at76_iw_handler_get_scan(struct net_device *netdev,
2305                                     struct iw_request_info *info,
2306                                     struct iw_point *data, char *extra)
2307 {
2308         struct at76_priv *priv = netdev_priv(netdev);
2309         unsigned long flags;
2310         struct list_head *lptr, *nptr;
2311         struct bss_info *curr_bss;
2312         struct iw_event *iwe = kmalloc(sizeof(struct iw_event), GFP_KERNEL);
2313         char *curr_val, *curr_pos = extra;
2314         int i;
2315
2316         at76_dbg(DBG_IOCTL, "%s: SIOCGIWSCAN", netdev->name);
2317
2318         if (!iwe)
2319                 return -ENOMEM;
2320
2321         if (priv->scan_state != SCAN_COMPLETED) {
2322                 /* scan not yet finished */
2323                 kfree(iwe);
2324                 return -EAGAIN;
2325         }
2326
2327         spin_lock_irqsave(&priv->bss_list_spinlock, flags);
2328
2329         list_for_each_safe(lptr, nptr, &priv->bss_list) {
2330                 curr_bss = list_entry(lptr, struct bss_info, list);
2331
2332                 iwe->cmd = SIOCGIWAP;
2333                 iwe->u.ap_addr.sa_family = ARPHRD_ETHER;
2334                 memcpy(iwe->u.ap_addr.sa_data, curr_bss->bssid, 6);
2335                 curr_pos = iwe_stream_add_event(info, curr_pos,
2336                                                 extra + IW_SCAN_MAX_DATA, iwe,
2337                                                 IW_EV_ADDR_LEN);
2338
2339                 iwe->u.data.length = curr_bss->ssid_len;
2340                 iwe->cmd = SIOCGIWESSID;
2341                 iwe->u.data.flags = 1;
2342
2343                 curr_pos = iwe_stream_add_point(info, curr_pos,
2344                                                 extra + IW_SCAN_MAX_DATA, iwe,
2345                                                 curr_bss->ssid);
2346
2347                 iwe->cmd = SIOCGIWMODE;
2348                 iwe->u.mode = (curr_bss->capa & WLAN_CAPABILITY_IBSS) ?
2349                     IW_MODE_ADHOC :
2350                     (curr_bss->capa & WLAN_CAPABILITY_ESS) ?
2351                     IW_MODE_MASTER : IW_MODE_AUTO;
2352                 /* IW_MODE_AUTO = 0 which I thought is
2353                  * the most logical value to return in this case */
2354                 curr_pos = iwe_stream_add_event(info, curr_pos,
2355                                                 extra + IW_SCAN_MAX_DATA, iwe,
2356                                                 IW_EV_UINT_LEN);
2357
2358                 iwe->cmd = SIOCGIWFREQ;
2359                 iwe->u.freq.m = curr_bss->channel;
2360                 iwe->u.freq.e = 0;
2361                 curr_pos = iwe_stream_add_event(info, curr_pos,
2362                                                 extra + IW_SCAN_MAX_DATA, iwe,
2363                                                 IW_EV_FREQ_LEN);
2364
2365                 iwe->cmd = SIOCGIWENCODE;
2366                 if (curr_bss->capa & WLAN_CAPABILITY_PRIVACY)
2367                         iwe->u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
2368                 else
2369                         iwe->u.data.flags = IW_ENCODE_DISABLED;
2370
2371                 iwe->u.data.length = 0;
2372                 curr_pos = iwe_stream_add_point(info, curr_pos,
2373                                                 extra + IW_SCAN_MAX_DATA, iwe,
2374                                                 NULL);
2375
2376                 /* Add quality statistics */
2377                 iwe->cmd = IWEVQUAL;
2378                 iwe->u.qual.noise = 0;
2379                 iwe->u.qual.updated =
2380                     IW_QUAL_NOISE_INVALID | IW_QUAL_LEVEL_UPDATED;
2381                 iwe->u.qual.level = (curr_bss->rssi * 100 / 42);
2382                 if (iwe->u.qual.level > 100)
2383                         iwe->u.qual.level = 100;
2384                 if (at76_is_intersil(priv->board_type))
2385                         iwe->u.qual.qual = curr_bss->link_qual;
2386                 else {
2387                         iwe->u.qual.qual = 0;
2388                         iwe->u.qual.updated |= IW_QUAL_QUAL_INVALID;
2389                 }
2390                 /* Add new value to event */
2391                 curr_pos = iwe_stream_add_event(info, curr_pos,
2392                                                 extra + IW_SCAN_MAX_DATA, iwe,
2393                                                 IW_EV_QUAL_LEN);
2394
2395                 /* Rate: stuffing multiple values in a single event requires
2396                  * a bit more of magic - Jean II */
2397                 curr_val = curr_pos + IW_EV_LCP_LEN;
2398
2399                 iwe->cmd = SIOCGIWRATE;
2400                 /* Those two flags are ignored... */
2401                 iwe->u.bitrate.fixed = 0;
2402                 iwe->u.bitrate.disabled = 0;
2403                 /* Max 8 values */
2404                 for (i = 0; i < curr_bss->rates_len; i++) {
2405                         /* Bit rate given in 500 kb/s units (+ 0x80) */
2406                         iwe->u.bitrate.value =
2407                             ((curr_bss->rates[i] & 0x7f) * 500000);
2408                         /* Add new value to event */
2409                         curr_val = iwe_stream_add_value(info, curr_pos,
2410                                                         curr_val,
2411                                                         extra +
2412                                                         IW_SCAN_MAX_DATA, iwe,
2413                                                         IW_EV_PARAM_LEN);
2414                 }
2415
2416                 /* Check if we added any event */
2417                 if ((curr_val - curr_pos) > IW_EV_LCP_LEN)
2418                         curr_pos = curr_val;
2419
2420                 /* more information may be sent back using IWECUSTOM */
2421
2422         }
2423
2424         spin_unlock_irqrestore(&priv->bss_list_spinlock, flags);
2425
2426         data->length = (curr_pos - extra);
2427         data->flags = 0;
2428
2429         kfree(iwe);
2430         return 0;
2431 }
2432
2433 static int at76_iw_handler_set_essid(struct net_device *netdev,
2434                                      struct iw_request_info *info,
2435                                      struct iw_point *data, char *extra)
2436 {
2437         struct at76_priv *priv = netdev_priv(netdev);
2438
2439         at76_dbg(DBG_IOCTL, "%s: SIOCSIWESSID - %s", netdev->name, extra);
2440
2441         if (data->flags) {
2442                 memcpy(priv->essid, extra, data->length);
2443                 priv->essid_size = data->length;
2444         } else
2445                 priv->essid_size = 0;   /* Use any SSID */
2446
2447         return -EIWCOMMIT;
2448 }
2449
2450 static int at76_iw_handler_get_essid(struct net_device *netdev,
2451                                      struct iw_request_info *info,
2452                                      struct iw_point *data, char *extra)
2453 {
2454         struct at76_priv *priv = netdev_priv(netdev);
2455
2456         if (priv->essid_size) {
2457                 /* not the ANY ssid in priv->essid */
2458                 data->flags = 1;
2459                 data->length = priv->essid_size;
2460                 memcpy(extra, priv->essid, data->length);
2461         } else {
2462                 /* the ANY ssid was specified */
2463                 if (priv->mac_state == MAC_CONNECTED && priv->curr_bss) {
2464                         /* report the SSID we have found */
2465                         data->flags = 1;
2466                         data->length = priv->curr_bss->ssid_len;
2467                         memcpy(extra, priv->curr_bss->ssid, data->length);
2468                 } else {
2469                         /* report ANY back */
2470                         data->flags = 0;
2471                         data->length = 0;
2472                 }
2473         }
2474
2475         at76_dbg(DBG_IOCTL, "%s: SIOCGIWESSID - %.*s", netdev->name,
2476                  data->length, extra);
2477
2478         return 0;
2479 }
2480
2481 static int at76_iw_handler_set_rate(struct net_device *netdev,
2482                                     struct iw_request_info *info,
2483                                     struct iw_param *bitrate, char *extra)
2484 {
2485         struct at76_priv *priv = netdev_priv(netdev);
2486         int ret = -EIWCOMMIT;
2487
2488         at76_dbg(DBG_IOCTL, "%s: SIOCSIWRATE - %d", netdev->name,
2489                  bitrate->value);
2490
2491         switch (bitrate->value) {
2492         case -1:
2493                 priv->txrate = TX_RATE_AUTO;
2494                 break;          /* auto rate */
2495         case 1000000:
2496                 priv->txrate = TX_RATE_1MBIT;
2497                 break;
2498         case 2000000:
2499                 priv->txrate = TX_RATE_2MBIT;
2500                 break;
2501         case 5500000:
2502                 priv->txrate = TX_RATE_5_5MBIT;
2503                 break;
2504         case 11000000:
2505                 priv->txrate = TX_RATE_11MBIT;
2506                 break;
2507         default:
2508                 ret = -EINVAL;
2509         }
2510
2511         return ret;
2512 }
2513
2514 static int at76_iw_handler_get_rate(struct net_device *netdev,
2515                                     struct iw_request_info *info,
2516                                     struct iw_param *bitrate, char *extra)
2517 {
2518         struct at76_priv *priv = netdev_priv(netdev);
2519         int ret = 0;
2520
2521         switch (priv->txrate) {
2522                 /* return max rate if RATE_AUTO */
2523         case TX_RATE_AUTO:
2524                 bitrate->value = 11000000;
2525                 break;
2526         case TX_RATE_1MBIT:
2527                 bitrate->value = 1000000;
2528                 break;
2529         case TX_RATE_2MBIT:
2530                 bitrate->value = 2000000;
2531                 break;
2532         case TX_RATE_5_5MBIT:
2533                 bitrate->value = 5500000;
2534                 break;
2535         case TX_RATE_11MBIT:
2536                 bitrate->value = 11000000;
2537                 break;
2538         default:
2539                 ret = -EINVAL;
2540         }
2541
2542         bitrate->fixed = (priv->txrate != TX_RATE_AUTO);
2543         bitrate->disabled = 0;
2544
2545         at76_dbg(DBG_IOCTL, "%s: SIOCGIWRATE - %d", netdev->name,
2546                  bitrate->value);
2547
2548         return ret;
2549 }
2550
2551 static int at76_iw_handler_set_rts(struct net_device *netdev,
2552                                    struct iw_request_info *info,
2553                                    struct iw_param *rts, char *extra)
2554 {
2555         struct at76_priv *priv = netdev_priv(netdev);
2556         int ret = -EIWCOMMIT;
2557         int rthr = rts->value;
2558
2559         at76_dbg(DBG_IOCTL, "%s: SIOCSIWRTS - value %d disabled %s",
2560                  netdev->name, rts->value, (rts->disabled) ? "true" : "false");
2561
2562         if (rts->disabled)
2563                 rthr = MAX_RTS_THRESHOLD;
2564
2565         if ((rthr < 0) || (rthr > MAX_RTS_THRESHOLD))
2566                 ret = -EINVAL;
2567         else
2568                 priv->rts_threshold = rthr;
2569
2570         return ret;
2571 }
2572
2573 static int at76_iw_handler_get_rts(struct net_device *netdev,
2574                                    struct iw_request_info *info,
2575                                    struct iw_param *rts, char *extra)
2576 {
2577         struct at76_priv *priv = netdev_priv(netdev);
2578
2579         rts->value = priv->rts_threshold;
2580         rts->disabled = (rts->value >= MAX_RTS_THRESHOLD);
2581         rts->fixed = 1;
2582
2583         at76_dbg(DBG_IOCTL, "%s: SIOCGIWRTS - value %d disabled %s",
2584                  netdev->name, rts->value, (rts->disabled) ? "true" : "false");
2585
2586         return 0;
2587 }
2588
2589 static int at76_iw_handler_set_frag(struct net_device *netdev,
2590                                     struct iw_request_info *info,
2591                                     struct iw_param *frag, char *extra)
2592 {
2593         struct at76_priv *priv = netdev_priv(netdev);
2594         int ret = -EIWCOMMIT;
2595         int fthr = frag->value;
2596
2597         at76_dbg(DBG_IOCTL, "%s: SIOCSIWFRAG - value %d, disabled %s",
2598                  netdev->name, frag->value,
2599                  (frag->disabled) ? "true" : "false");
2600
2601         if (frag->disabled)
2602                 fthr = MAX_FRAG_THRESHOLD;
2603
2604         if ((fthr < MIN_FRAG_THRESHOLD) || (fthr > MAX_FRAG_THRESHOLD))
2605                 ret = -EINVAL;
2606         else
2607                 priv->frag_threshold = fthr & ~0x1;     /* get an even value */
2608
2609         return ret;
2610 }
2611
2612 static int at76_iw_handler_get_frag(struct net_device *netdev,
2613                                     struct iw_request_info *info,
2614                                     struct iw_param *frag, char *extra)
2615 {
2616         struct at76_priv *priv = netdev_priv(netdev);
2617
2618         frag->value = priv->frag_threshold;
2619         frag->disabled = (frag->value >= MAX_FRAG_THRESHOLD);
2620         frag->fixed = 1;
2621
2622         at76_dbg(DBG_IOCTL, "%s: SIOCGIWFRAG - value %d, disabled %s",
2623                  netdev->name, frag->value,
2624                  (frag->disabled) ? "true" : "false");
2625
2626         return 0;
2627 }
2628
2629 static int at76_iw_handler_get_txpow(struct net_device *netdev,
2630                                      struct iw_request_info *info,
2631                                      struct iw_param *power, char *extra)
2632 {
2633         power->value = 15;
2634         power->fixed = 1;       /* No power control */
2635         power->disabled = 0;
2636         power->flags = IW_TXPOW_DBM;
2637
2638         at76_dbg(DBG_IOCTL, "%s: SIOCGIWTXPOW - txpow %d dBm", netdev->name,
2639                  power->value);
2640
2641         return 0;
2642 }
2643
2644 /* jal: short retry is handled by the firmware (at least 0.90.x),
2645    while long retry is not (?) */
2646 static int at76_iw_handler_set_retry(struct net_device *netdev,
2647                                      struct iw_request_info *info,
2648                                      struct iw_param *retry, char *extra)
2649 {
2650         struct at76_priv *priv = netdev_priv(netdev);
2651         int ret = -EIWCOMMIT;
2652
2653         at76_dbg(DBG_IOCTL, "%s: SIOCSIWRETRY disabled %d flags 0x%x val %d",
2654                  netdev->name, retry->disabled, retry->flags, retry->value);
2655
2656         if (!retry->disabled && (retry->flags & IW_RETRY_LIMIT)) {
2657                 if ((retry->flags & IW_RETRY_MIN) ||
2658                     !(retry->flags & IW_RETRY_MAX))
2659                         priv->short_retry_limit = retry->value;
2660                 else
2661                         ret = -EINVAL;
2662         } else
2663                 ret = -EINVAL;
2664
2665         return ret;
2666 }
2667
2668 /* Adapted (ripped) from atmel.c */
2669 static int at76_iw_handler_get_retry(struct net_device *netdev,
2670                                      struct iw_request_info *info,
2671                                      struct iw_param *retry, char *extra)
2672 {
2673         struct at76_priv *priv = netdev_priv(netdev);
2674
2675         at76_dbg(DBG_IOCTL, "%s: SIOCGIWRETRY", netdev->name);
2676
2677         retry->disabled = 0;    /* Can't be disabled */
2678         retry->flags = IW_RETRY_LIMIT;
2679         retry->value = priv->short_retry_limit;
2680
2681         return 0;
2682 }
2683
2684 static int at76_iw_handler_set_encode(struct net_device *netdev,
2685                                       struct iw_request_info *info,
2686                                       struct iw_point *encoding, char *extra)
2687 {
2688         struct at76_priv *priv = netdev_priv(netdev);
2689         int index = (encoding->flags & IW_ENCODE_INDEX) - 1;
2690         int len = encoding->length;
2691
2692         at76_dbg(DBG_IOCTL, "%s: SIOCSIWENCODE - enc.flags %08x "
2693                  "pointer %p len %d", netdev->name, encoding->flags,
2694                  encoding->pointer, encoding->length);
2695         at76_dbg(DBG_IOCTL,
2696                  "%s: SIOCSIWENCODE - old wepstate: enabled %s key_id %d "
2697                  "auth_mode %s", netdev->name,
2698                  (priv->wep_enabled) ? "true" : "false", priv->wep_key_id,
2699                  (priv->auth_mode ==
2700                   WLAN_AUTH_SHARED_KEY) ? "restricted" : "open");
2701
2702         /* take the old default key if index is invalid */
2703         if ((index < 0) || (index >= WEP_KEYS))
2704                 index = priv->wep_key_id;
2705
2706         if (len > 0) {
2707                 if (len > WEP_LARGE_KEY_LEN)
2708                         len = WEP_LARGE_KEY_LEN;
2709
2710                 memset(priv->wep_keys[index], 0, WEP_KEY_LEN);
2711                 memcpy(priv->wep_keys[index], extra, len);
2712                 priv->wep_keys_len[index] = (len <= WEP_SMALL_KEY_LEN) ?
2713                     WEP_SMALL_KEY_LEN : WEP_LARGE_KEY_LEN;
2714                 priv->wep_enabled = 1;
2715         }
2716
2717         priv->wep_key_id = index;
2718         priv->wep_enabled = ((encoding->flags & IW_ENCODE_DISABLED) == 0);
2719
2720         if (encoding->flags & IW_ENCODE_RESTRICTED)
2721                 priv->auth_mode = WLAN_AUTH_SHARED_KEY;
2722         if (encoding->flags & IW_ENCODE_OPEN)
2723                 priv->auth_mode = WLAN_AUTH_OPEN;
2724
2725         at76_dbg(DBG_IOCTL,
2726                  "%s: SIOCSIWENCODE - new wepstate: enabled %s key_id %d "
2727                  "key_len %d auth_mode %s", netdev->name,
2728                  (priv->wep_enabled) ? "true" : "false", priv->wep_key_id + 1,
2729                  priv->wep_keys_len[priv->wep_key_id],
2730                  (priv->auth_mode ==
2731                   WLAN_AUTH_SHARED_KEY) ? "restricted" : "open");
2732
2733         return -EIWCOMMIT;
2734 }
2735
2736 static int at76_iw_handler_get_encode(struct net_device *netdev,
2737                                       struct iw_request_info *info,
2738                                       struct iw_point *encoding, char *extra)
2739 {
2740         struct at76_priv *priv = netdev_priv(netdev);
2741         int index = (encoding->flags & IW_ENCODE_INDEX) - 1;
2742
2743         if ((index < 0) || (index >= WEP_KEYS))
2744                 index = priv->wep_key_id;
2745
2746         encoding->flags =
2747             (priv->auth_mode == WLAN_AUTH_SHARED_KEY) ?
2748             IW_ENCODE_RESTRICTED : IW_ENCODE_OPEN;
2749
2750         if (!priv->wep_enabled)
2751                 encoding->flags |= IW_ENCODE_DISABLED;
2752
2753         if (encoding->pointer) {
2754                 encoding->length = priv->wep_keys_len[index];
2755
2756                 memcpy(extra, priv->wep_keys[index], priv->wep_keys_len[index]);
2757
2758                 encoding->flags |= (index + 1);
2759         }
2760
2761         at76_dbg(DBG_IOCTL, "%s: SIOCGIWENCODE - enc.flags %08x "
2762                  "pointer %p len %d", netdev->name, encoding->flags,
2763                  encoding->pointer, encoding->length);
2764         at76_dbg(DBG_IOCTL,
2765                  "%s: SIOCGIWENCODE - wepstate: enabled %s key_id %d "
2766                  "key_len %d auth_mode %s", netdev->name,
2767                  (priv->wep_enabled) ? "true" : "false", priv->wep_key_id + 1,
2768                  priv->wep_keys_len[priv->wep_key_id],
2769                  (priv->auth_mode ==
2770                   WLAN_AUTH_SHARED_KEY) ? "restricted" : "open");
2771
2772         return 0;
2773 }
2774
2775 static int at76_iw_handler_set_power(struct net_device *netdev,
2776                                      struct iw_request_info *info,
2777                                      struct iw_param *prq, char *extra)
2778 {
2779         int err = -EIWCOMMIT;
2780         struct at76_priv *priv = netdev_priv(netdev);
2781
2782         at76_dbg(DBG_IOCTL,
2783                  "%s: SIOCSIWPOWER - disabled %s flags 0x%x value 0x%x",
2784                  netdev->name, (prq->disabled) ? "true" : "false", prq->flags,
2785                  prq->value);
2786
2787         if (prq->disabled)
2788                 priv->pm_mode = AT76_PM_OFF;
2789         else {
2790                 switch (prq->flags & IW_POWER_MODE) {
2791                 case IW_POWER_ALL_R:
2792                 case IW_POWER_ON:
2793                         break;
2794                 default:
2795                         err = -EINVAL;
2796                         goto exit;
2797                 }
2798                 if (prq->flags & IW_POWER_PERIOD)
2799                         priv->pm_period = prq->value;
2800
2801                 if (prq->flags & IW_POWER_TIMEOUT) {
2802                         err = -EINVAL;
2803                         goto exit;
2804                 }
2805                 priv->pm_mode = AT76_PM_ON;
2806         }
2807 exit:
2808         return err;
2809 }
2810
2811 static int at76_iw_handler_get_power(struct net_device *netdev,
2812                                      struct iw_request_info *info,
2813                                      struct iw_param *power, char *extra)
2814 {
2815         struct at76_priv *priv = netdev_priv(netdev);
2816
2817         power->disabled = (priv->pm_mode == AT76_PM_OFF);
2818         if (!power->disabled) {
2819                 power->flags = IW_POWER_PERIOD | IW_POWER_ALL_R;
2820                 power->value = priv->pm_period;
2821         }
2822
2823         at76_dbg(DBG_IOCTL, "%s: SIOCGIWPOWER - %s flags 0x%x value 0x%x",
2824                  netdev->name, power->disabled ? "disabled" : "enabled",
2825                  power->flags, power->value);
2826
2827         return 0;
2828 }
2829
2830 /*******************************************************************************
2831  * Private IOCTLS
2832  */
2833 static int at76_iw_set_short_preamble(struct net_device *netdev,
2834                                       struct iw_request_info *info, char *name,
2835                                       char *extra)
2836 {
2837         struct at76_priv *priv = netdev_priv(netdev);
2838         int val = *((int *)name);
2839         int ret = -EIWCOMMIT;
2840
2841         at76_dbg(DBG_IOCTL, "%s: AT76_SET_SHORT_PREAMBLE, %d",
2842                  netdev->name, val);
2843
2844         if (val < PREAMBLE_TYPE_LONG || val > PREAMBLE_TYPE_AUTO)
2845                 ret = -EINVAL;
2846         else
2847                 priv->preamble_type = val;
2848
2849         return ret;
2850 }
2851
2852 static int at76_iw_get_short_preamble(struct net_device *netdev,
2853                                       struct iw_request_info *info,
2854                                       union iwreq_data *wrqu, char *extra)
2855 {
2856         struct at76_priv *priv = netdev_priv(netdev);
2857
2858         snprintf(wrqu->name, sizeof(wrqu->name), "%s (%d)",
2859                  preambles[priv->preamble_type], priv->preamble_type);
2860         return 0;
2861 }
2862
2863 static int at76_iw_set_debug(struct net_device *netdev,
2864                              struct iw_request_info *info,
2865                              struct iw_point *data, char *extra)
2866 {
2867         char *ptr;
2868         u32 val;
2869
2870         if (data->length > 0) {
2871                 val = simple_strtol(extra, &ptr, 0);
2872
2873                 if (ptr == extra)
2874                         val = DBG_DEFAULTS;
2875
2876                 at76_dbg(DBG_IOCTL, "%s: AT76_SET_DEBUG input %d: %s -> 0x%x",
2877                          netdev->name, data->length, extra, val);
2878         } else
2879                 val = DBG_DEFAULTS;
2880
2881         at76_dbg(DBG_IOCTL, "%s: AT76_SET_DEBUG, old 0x%x, new 0x%x",
2882                  netdev->name, at76_debug, val);
2883
2884         /* jal: some more output to pin down lockups */
2885         at76_dbg(DBG_IOCTL, "%s: netif running %d queue_stopped %d "
2886                  "carrier_ok %d", netdev->name, netif_running(netdev),
2887                  netif_queue_stopped(netdev), netif_carrier_ok(netdev));
2888
2889         at76_debug = val;
2890
2891         return 0;
2892 }
2893
2894 static int at76_iw_get_debug(struct net_device *netdev,
2895                              struct iw_request_info *info,
2896                              union iwreq_data *wrqu, char *extra)
2897 {
2898         snprintf(wrqu->name, sizeof(wrqu->name), "0x%08x", at76_debug);
2899         return 0;
2900 }
2901
2902 static int at76_iw_set_powersave_mode(struct net_device *netdev,
2903                                       struct iw_request_info *info, char *name,
2904                                       char *extra)
2905 {
2906         struct at76_priv *priv = netdev_priv(netdev);
2907         int val = *((int *)name);
2908         int ret = -EIWCOMMIT;
2909
2910         at76_dbg(DBG_IOCTL, "%s: AT76_SET_POWERSAVE_MODE, %d (%s)",
2911                  netdev->name, val,
2912                  val == AT76_PM_OFF ? "active" : val == AT76_PM_ON ? "save" :
2913                  val == AT76_PM_SMART ? "smart save" : "<invalid>");
2914         if (val < AT76_PM_OFF || val > AT76_PM_SMART)
2915                 ret = -EINVAL;
2916         else
2917                 priv->pm_mode = val;
2918
2919         return ret;
2920 }
2921
2922 static int at76_iw_get_powersave_mode(struct net_device *netdev,
2923                                       struct iw_request_info *info,
2924                                       union iwreq_data *wrqu, char *extra)
2925 {
2926         struct at76_priv *priv = netdev_priv(netdev);
2927         int *param = (int *)extra;
2928
2929         param[0] = priv->pm_mode;
2930         return 0;
2931 }
2932
2933 static int at76_iw_set_scan_times(struct net_device *netdev,
2934                                   struct iw_request_info *info, char *name,
2935                                   char *extra)
2936 {
2937         struct at76_priv *priv = netdev_priv(netdev);
2938         int mint = *((int *)name);
2939         int maxt = *((int *)name + 1);
2940         int ret = -EIWCOMMIT;
2941
2942         at76_dbg(DBG_IOCTL, "%s: AT76_SET_SCAN_TIMES - min %d max %d",
2943                  netdev->name, mint, maxt);
2944         if (mint <= 0 || maxt <= 0 || mint > maxt)
2945                 ret = -EINVAL;
2946         else {
2947                 priv->scan_min_time = mint;
2948                 priv->scan_max_time = maxt;
2949         }
2950
2951         return ret;
2952 }
2953
2954 static int at76_iw_get_scan_times(struct net_device *netdev,
2955                                   struct iw_request_info *info,
2956                                   union iwreq_data *wrqu, char *extra)
2957 {
2958         struct at76_priv *priv = netdev_priv(netdev);
2959         int *param = (int *)extra;
2960
2961         param[0] = priv->scan_min_time;
2962         param[1] = priv->scan_max_time;
2963         return 0;
2964 }
2965
2966 static int at76_iw_set_scan_mode(struct net_device *netdev,
2967                                  struct iw_request_info *info, char *name,
2968                                  char *extra)
2969 {
2970         struct at76_priv *priv = netdev_priv(netdev);
2971         int val = *((int *)name);
2972         int ret = -EIWCOMMIT;
2973
2974         at76_dbg(DBG_IOCTL, "%s: AT76_SET_SCAN_MODE - mode %s",
2975                  netdev->name, (val = SCAN_TYPE_ACTIVE) ? "active" :
2976                  (val = SCAN_TYPE_PASSIVE) ? "passive" : "<invalid>");
2977
2978         if (val != SCAN_TYPE_ACTIVE && val != SCAN_TYPE_PASSIVE)
2979                 ret = -EINVAL;
2980         else
2981                 priv->scan_mode = val;
2982
2983         return ret;
2984 }
2985
2986 static int at76_iw_get_scan_mode(struct net_device *netdev,
2987                                  struct iw_request_info *info,
2988                                  union iwreq_data *wrqu, char *extra)
2989 {
2990         struct at76_priv *priv = netdev_priv(netdev);
2991         int *param = (int *)extra;
2992
2993         param[0] = priv->scan_mode;
2994         return 0;
2995 }
2996
2997 #define AT76_SET_HANDLER(h, f) [h - SIOCIWFIRST] = (iw_handler) f
2998
2999 /* Standard wireless handlers */
3000 static const iw_handler at76_handlers[] = {
3001         AT76_SET_HANDLER(SIOCSIWCOMMIT, at76_iw_handler_commit),
3002         AT76_SET_HANDLER(SIOCGIWNAME, at76_iw_handler_get_name),
3003         AT76_SET_HANDLER(SIOCSIWFREQ, at76_iw_handler_set_freq),
3004         AT76_SET_HANDLER(SIOCGIWFREQ, at76_iw_handler_get_freq),
3005         AT76_SET_HANDLER(SIOCSIWMODE, at76_iw_handler_set_mode),
3006         AT76_SET_HANDLER(SIOCGIWMODE, at76_iw_handler_get_mode),
3007         AT76_SET_HANDLER(SIOCGIWRANGE, at76_iw_handler_get_range),
3008         AT76_SET_HANDLER(SIOCSIWSPY, at76_iw_handler_set_spy),
3009         AT76_SET_HANDLER(SIOCGIWSPY, at76_iw_handler_get_spy),
3010         AT76_SET_HANDLER(SIOCSIWTHRSPY, at76_iw_handler_set_thrspy),
3011         AT76_SET_HANDLER(SIOCGIWTHRSPY, at76_iw_handler_get_thrspy),
3012         AT76_SET_HANDLER(SIOCSIWAP, at76_iw_handler_set_wap),
3013         AT76_SET_HANDLER(SIOCGIWAP, at76_iw_handler_get_wap),
3014         AT76_SET_HANDLER(SIOCSIWSCAN, at76_iw_handler_set_scan),
3015         AT76_SET_HANDLER(SIOCGIWSCAN, at76_iw_handler_get_scan),
3016         AT76_SET_HANDLER(SIOCSIWESSID, at76_iw_handler_set_essid),
3017         AT76_SET_HANDLER(SIOCGIWESSID, at76_iw_handler_get_essid),
3018         AT76_SET_HANDLER(SIOCSIWRATE, at76_iw_handler_set_rate),
3019         AT76_SET_HANDLER(SIOCGIWRATE, at76_iw_handler_get_rate),
3020         AT76_SET_HANDLER(SIOCSIWRTS, at76_iw_handler_set_rts),
3021         AT76_SET_HANDLER(SIOCGIWRTS, at76_iw_handler_get_rts),
3022         AT76_SET_HANDLER(SIOCSIWFRAG, at76_iw_handler_set_frag),
3023         AT76_SET_HANDLER(SIOCGIWFRAG, at76_iw_handler_get_frag),
3024         AT76_SET_HANDLER(SIOCGIWTXPOW, at76_iw_handler_get_txpow),
3025         AT76_SET_HANDLER(SIOCSIWRETRY, at76_iw_handler_set_retry),
3026         AT76_SET_HANDLER(SIOCGIWRETRY, at76_iw_handler_get_retry),
3027         AT76_SET_HANDLER(SIOCSIWENCODE, at76_iw_handler_set_encode),
3028         AT76_SET_HANDLER(SIOCGIWENCODE, at76_iw_handler_get_encode),
3029         AT76_SET_HANDLER(SIOCSIWPOWER, at76_iw_handler_set_power),
3030         AT76_SET_HANDLER(SIOCGIWPOWER, at76_iw_handler_get_power)
3031 };
3032
3033 #define AT76_SET_PRIV(h, f) [h - SIOCIWFIRSTPRIV] = (iw_handler) f
3034
3035 /* Private wireless handlers */
3036 static const iw_handler at76_priv_handlers[] = {
3037         AT76_SET_PRIV(AT76_SET_SHORT_PREAMBLE, at76_iw_set_short_preamble),
3038         AT76_SET_PRIV(AT76_GET_SHORT_PREAMBLE, at76_iw_get_short_preamble),
3039         AT76_SET_PRIV(AT76_SET_DEBUG, at76_iw_set_debug),
3040         AT76_SET_PRIV(AT76_GET_DEBUG, at76_iw_get_debug),
3041         AT76_SET_PRIV(AT76_SET_POWERSAVE_MODE, at76_iw_set_powersave_mode),
3042         AT76_SET_PRIV(AT76_GET_POWERSAVE_MODE, at76_iw_get_powersave_mode),
3043         AT76_SET_PRIV(AT76_SET_SCAN_TIMES, at76_iw_set_scan_times),
3044         AT76_SET_PRIV(AT76_GET_SCAN_TIMES, at76_iw_get_scan_times),
3045         AT76_SET_PRIV(AT76_SET_SCAN_MODE, at76_iw_set_scan_mode),
3046         AT76_SET_PRIV(AT76_GET_SCAN_MODE, at76_iw_get_scan_mode),
3047 };
3048
3049 /* Names and arguments of private wireless handlers */
3050 static const struct iw_priv_args at76_priv_args[] = {
3051         /* 0 - long, 1 - short */
3052         {AT76_SET_SHORT_PREAMBLE,
3053          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_preamble"},
3054
3055         {AT76_GET_SHORT_PREAMBLE,
3056          0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | 10, "get_preamble"},
3057
3058         /* we must pass the new debug mask as a string, because iwpriv cannot
3059          * parse hex numbers starting with 0x :-(  */
3060         {AT76_SET_DEBUG,
3061          IW_PRIV_TYPE_CHAR | 10, 0, "set_debug"},
3062
3063         {AT76_GET_DEBUG,
3064          0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | 10, "get_debug"},
3065
3066         /* 1 - active, 2 - power save, 3 - smart power save */
3067         {AT76_SET_POWERSAVE_MODE,
3068          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_powersave"},
3069
3070         {AT76_GET_POWERSAVE_MODE,
3071          0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "get_powersave"},
3072
3073         /* min_channel_time, max_channel_time */
3074         {AT76_SET_SCAN_TIMES,
3075          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "set_scan_times"},
3076
3077         {AT76_GET_SCAN_TIMES,
3078          0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, "get_scan_times"},
3079
3080         /* 0 - active, 1 - passive scan */
3081         {AT76_SET_SCAN_MODE,
3082          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "set_scan_mode"},
3083
3084         {AT76_GET_SCAN_MODE,
3085          0, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "get_scan_mode"},
3086 };
3087
3088 static const struct iw_handler_def at76_handler_def = {
3089         .num_standard = ARRAY_SIZE(at76_handlers),
3090         .num_private = ARRAY_SIZE(at76_priv_handlers),
3091         .num_private_args = ARRAY_SIZE(at76_priv_args),
3092         .standard = at76_handlers,
3093         .private = at76_priv_handlers,
3094         .private_args = at76_priv_args,
3095         .get_wireless_stats = at76_get_wireless_stats,
3096 };
3097
3098 static const u8 snapsig[] = { 0xaa, 0xaa, 0x03 };
3099
3100 /* RFC 1042 encapsulates Ethernet frames in 802.2 SNAP (0xaa, 0xaa, 0x03) with
3101  * a SNAP OID of 0 (0x00, 0x00, 0x00) */
3102 static const u8 rfc1042sig[] = { 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00 };
3103
3104 static int at76_tx(struct sk_buff *skb, struct net_device *netdev)
3105 {
3106         struct at76_priv *priv = netdev_priv(netdev);
3107         struct net_device_stats *stats = &priv->stats;
3108         int ret = 0;
3109         int wlen;
3110         int submit_len;
3111         struct at76_tx_buffer *tx_buffer = priv->bulk_out_buffer;
3112         struct ieee80211_hdr_3addr *i802_11_hdr =
3113             (struct ieee80211_hdr_3addr *)tx_buffer->packet;
3114         u8 *payload = i802_11_hdr->payload;
3115         struct ethhdr *eh = (struct ethhdr *)skb->data;
3116
3117         if (netif_queue_stopped(netdev)) {
3118                 printk(KERN_ERR "%s: %s called while netdev is stopped\n",
3119                        netdev->name, __func__);
3120                 /* skip this packet */
3121                 dev_kfree_skb(skb);
3122                 return NETDEV_TX_OK;
3123         }
3124
3125         if (priv->tx_urb->status == -EINPROGRESS) {
3126                 printk(KERN_ERR "%s: %s called while tx urb is pending\n",
3127                        netdev->name, __func__);
3128                 /* skip this packet */
3129                 dev_kfree_skb(skb);
3130                 return NETDEV_TX_OK;
3131         }
3132
3133         if (skb->len < ETH_HLEN) {
3134                 printk(KERN_ERR "%s: %s: skb too short (%d)\n",
3135                        netdev->name, __func__, skb->len);
3136                 dev_kfree_skb(skb);
3137                 return NETDEV_TX_OK;
3138         }
3139
3140         at76_ledtrig_tx_activity();     /* tell ledtrigger we send a packet */
3141
3142         /* we can get rid of memcpy if we set netdev->hard_header_len to
3143            reserve enough space, but we would need to keep the skb around */
3144
3145         if (ntohs(eh->h_proto) <= ETH_DATA_LEN) {
3146                 /* this is a 802.3 packet */
3147                 if (skb->len >= ETH_HLEN + sizeof(rfc1042sig)
3148                     && skb->data[ETH_HLEN] == rfc1042sig[0]
3149                     && skb->data[ETH_HLEN + 1] == rfc1042sig[1]) {
3150                         /* higher layer delivered SNAP header - keep it */
3151                         memcpy(payload, skb->data + ETH_HLEN,
3152                                skb->len - ETH_HLEN);
3153                         wlen = IEEE80211_3ADDR_LEN + skb->len - ETH_HLEN;
3154                 } else {
3155                         printk(KERN_ERR "%s: dropping non-SNAP 802.2 packet "
3156                                "(DSAP 0x%02x SSAP 0x%02x cntrl 0x%02x)\n",
3157                                priv->netdev->name, skb->data[ETH_HLEN],
3158                                skb->data[ETH_HLEN + 1],
3159                                skb->data[ETH_HLEN + 2]);
3160                         dev_kfree_skb(skb);
3161                         return NETDEV_TX_OK;
3162                 }
3163         } else {
3164                 /* add RFC 1042 header in front */
3165                 memcpy(payload, rfc1042sig, sizeof(rfc1042sig));
3166                 memcpy(payload + sizeof(rfc1042sig), &eh->h_proto,
3167                        skb->len - offsetof(struct ethhdr, h_proto));
3168                 wlen = IEEE80211_3ADDR_LEN + sizeof(rfc1042sig) + skb->len -
3169                     offsetof(struct ethhdr, h_proto);
3170         }
3171
3172         /* make wireless header */
3173         i802_11_hdr->frame_ctl =
3174             cpu_to_le16(IEEE80211_FTYPE_DATA |
3175                         (priv->wep_enabled ? IEEE80211_FCTL_PROTECTED : 0) |
3176                         (priv->iw_mode ==
3177                          IW_MODE_INFRA ? IEEE80211_FCTL_TODS : 0));
3178
3179         if (priv->iw_mode == IW_MODE_ADHOC) {
3180                 memcpy(i802_11_hdr->addr1, eh->h_dest, ETH_ALEN);
3181                 memcpy(i802_11_hdr->addr2, eh->h_source, ETH_ALEN);
3182                 memcpy(i802_11_hdr->addr3, priv->bssid, ETH_ALEN);
3183         } else if (priv->iw_mode == IW_MODE_INFRA) {
3184                 memcpy(i802_11_hdr->addr1, priv->bssid, ETH_ALEN);
3185                 memcpy(i802_11_hdr->addr2, eh->h_source, ETH_ALEN);
3186                 memcpy(i802_11_hdr->addr3, eh->h_dest, ETH_ALEN);
3187         }
3188
3189         i802_11_hdr->duration_id = cpu_to_le16(0);
3190         i802_11_hdr->seq_ctl = cpu_to_le16(0);
3191
3192         /* setup 'Atmel' header */
3193         tx_buffer->wlength = cpu_to_le16(wlen);
3194         tx_buffer->tx_rate = priv->txrate;
3195         /* for broadcast destination addresses, the firmware 0.100.x
3196            seems to choose the highest rate set with CMD_STARTUP in
3197            basic_rate_set replacing this value */
3198
3199         memset(tx_buffer->reserved, 0, sizeof(tx_buffer->reserved));
3200
3201         tx_buffer->padding = at76_calc_padding(wlen);
3202         submit_len = wlen + AT76_TX_HDRLEN + tx_buffer->padding;
3203
3204         at76_dbg(DBG_TX_DATA_CONTENT, "%s skb->data %s", priv->netdev->name,
3205                  hex2str(skb->data, 32));
3206         at76_dbg(DBG_TX_DATA, "%s tx: wlen 0x%x pad 0x%x rate %d hdr %s",
3207                  priv->netdev->name,
3208                  le16_to_cpu(tx_buffer->wlength),
3209                  tx_buffer->padding, tx_buffer->tx_rate,
3210                  hex2str(i802_11_hdr, sizeof(*i802_11_hdr)));
3211         at76_dbg(DBG_TX_DATA_CONTENT, "%s payload %s", priv->netdev->name,
3212                  hex2str(payload, 48));
3213
3214         /* send stuff */
3215         netif_stop_queue(netdev);
3216         netdev->trans_start = jiffies;
3217
3218         usb_fill_bulk_urb(priv->tx_urb, priv->udev, priv->tx_pipe, tx_buffer,
3219                           submit_len, at76_tx_callback, priv);
3220         ret = usb_submit_urb(priv->tx_urb, GFP_ATOMIC);
3221         if (ret) {
3222                 stats->tx_errors++;
3223                 printk(KERN_ERR "%s: error in tx submit urb: %d\n",
3224                        netdev->name, ret);
3225                 if (ret == -EINVAL)
3226                         printk(KERN_ERR
3227                                "%s: -EINVAL: tx urb %p hcpriv %p complete %p\n",
3228                                priv->netdev->name, priv->tx_urb,
3229                                priv->tx_urb->hcpriv, priv->tx_urb->complete);
3230         } else
3231                 stats->tx_bytes += skb->len;
3232
3233         dev_kfree_skb(skb);
3234         return NETDEV_TX_OK;
3235 }
3236
3237 static void at76_tx_timeout(struct net_device *netdev)
3238 {
3239         struct at76_priv *priv = netdev_priv(netdev);
3240
3241         if (!priv)
3242                 return;
3243         dev_warn(&netdev->dev, "tx timeout.");
3244
3245         usb_unlink_urb(priv->tx_urb);
3246         priv->stats.tx_errors++;
3247 }
3248
3249 static int at76_submit_rx_urb(struct at76_priv *priv)
3250 {
3251         int ret;
3252         int size;
3253         struct sk_buff *skb = priv->rx_skb;
3254
3255         if (!priv->rx_urb) {
3256                 printk(KERN_ERR "%s: %s: priv->rx_urb is NULL\n",
3257                        priv->netdev->name, __func__);
3258                 return -EFAULT;
3259         }
3260
3261         if (!skb) {
3262                 skb = dev_alloc_skb(sizeof(struct at76_rx_buffer));
3263                 if (!skb) {
3264                         printk(KERN_ERR "%s: cannot allocate rx skbuff\n",
3265                                priv->netdev->name);
3266                         ret = -ENOMEM;
3267                         goto exit;
3268                 }
3269                 priv->rx_skb = skb;
3270         } else {
3271                 skb_push(skb, skb_headroom(skb));
3272                 skb_trim(skb, 0);
3273         }
3274
3275         size = skb_tailroom(skb);
3276         usb_fill_bulk_urb(priv->rx_urb, priv->udev, priv->rx_pipe,
3277                           skb_put(skb, size), size, at76_rx_callback, priv);
3278         ret = usb_submit_urb(priv->rx_urb, GFP_ATOMIC);
3279         if (ret < 0) {
3280                 if (ret == -ENODEV)
3281                         at76_dbg(DBG_DEVSTART,
3282                                  "usb_submit_urb returned -ENODEV");
3283                 else
3284                         printk(KERN_ERR "%s: rx, usb_submit_urb failed: %d\n",
3285                                priv->netdev->name, ret);
3286         }
3287
3288 exit:
3289         if (ret < 0 && ret != -ENODEV)
3290                 printk(KERN_ERR "%s: cannot submit rx urb - please unload the "
3291                        "driver and/or power cycle the device\n",
3292                        priv->netdev->name);
3293
3294         return ret;
3295 }
3296
3297 static int at76_open(struct net_device *netdev)
3298 {
3299         struct at76_priv *priv = netdev_priv(netdev);
3300         int ret = 0;
3301
3302         at76_dbg(DBG_PROC_ENTRY, "%s(): entry", __func__);
3303
3304         if (mutex_lock_interruptible(&priv->mtx))
3305                 return -EINTR;
3306
3307         /* if netdev->dev_addr != priv->mac_addr we must
3308            set the mac address in the device ! */
3309         if (compare_ether_addr(netdev->dev_addr, priv->mac_addr)) {
3310                 if (at76_add_mac_address(priv, netdev->dev_addr) >= 0)
3311                         at76_dbg(DBG_PROGRESS, "%s: set new MAC addr %pM",
3312                                  netdev->name, netdev->dev_addr);
3313         }
3314
3315         priv->scan_state = SCAN_IDLE;
3316         priv->last_scan = jiffies;
3317
3318         ret = at76_submit_rx_urb(priv);
3319         if (ret < 0) {
3320                 printk(KERN_ERR "%s: open: submit_rx_urb failed: %d\n",
3321                        netdev->name, ret);
3322                 goto error;
3323         }
3324
3325         schedule_delayed_work(&priv->dwork_restart, 0);
3326
3327         at76_dbg(DBG_PROC_ENTRY, "%s(): end", __func__);
3328 error:
3329         mutex_unlock(&priv->mtx);
3330         return ret < 0 ? ret : 0;
3331 }
3332
3333 static int at76_stop(struct net_device *netdev)
3334 {
3335         struct at76_priv *priv = netdev_priv(netdev);
3336
3337         at76_dbg(DBG_DEVSTART, "%s: ENTER", __func__);
3338
3339         if (mutex_lock_interruptible(&priv->mtx))
3340                 return -EINTR;
3341
3342         at76_quiesce(priv);
3343
3344         if (!priv->device_unplugged) {
3345                 /* We are called by "ifconfig ethX down", not because the
3346                  * device is not available anymore. */
3347                 at76_set_radio(priv, 0);
3348
3349                 /* We unlink rx_urb because at76_open() re-submits it.
3350                  * If unplugged, at76_delete_device() takes care of it. */
3351                 usb_kill_urb(priv->rx_urb);
3352         }
3353
3354         /* free the bss_list */
3355         at76_free_bss_list(priv);
3356
3357         mutex_unlock(&priv->mtx);
3358         at76_dbg(DBG_DEVSTART, "%s: EXIT", __func__);
3359
3360         return 0;
3361 }
3362
3363 static void at76_ethtool_get_drvinfo(struct net_device *netdev,
3364                                      struct ethtool_drvinfo *info)
3365 {
3366         struct at76_priv *priv = netdev_priv(netdev);
3367
3368         strncpy(info->driver, DRIVER_NAME, sizeof(info->driver));
3369         strncpy(info->version, DRIVER_VERSION, sizeof(info->version));
3370
3371         usb_make_path(priv->udev, info->bus_info, sizeof(info->bus_info));
3372
3373         snprintf(info->fw_version, sizeof(info->fw_version), "%d.%d.%d-%d",
3374                  priv->fw_version.major, priv->fw_version.minor,
3375                  priv->fw_version.patch, priv->fw_version.build);
3376 }
3377
3378 static u32 at76_ethtool_get_link(struct net_device *netdev)
3379 {
3380         struct at76_priv *priv = netdev_priv(netdev);
3381         return priv->mac_state == MAC_CONNECTED;
3382 }
3383
3384 static const struct ethtool_ops at76_ethtool_ops = {
3385         .get_drvinfo = at76_ethtool_get_drvinfo,
3386         .get_link = at76_ethtool_get_link,
3387 };
3388
3389 /* Download external firmware */
3390 static int at76_load_external_fw(struct usb_device *udev, struct fwentry *fwe)
3391 {
3392         int ret;
3393         int op_mode;
3394         int blockno = 0;
3395         int bsize;
3396         u8 *block;
3397         u8 *buf = fwe->extfw;
3398         int size = fwe->extfw_size;
3399
3400         if (!buf || !size)
3401                 return -ENOENT;
3402
3403         op_mode = at76_get_op_mode(udev);
3404         at76_dbg(DBG_DEVSTART, "opmode %d", op_mode);
3405
3406         if (op_mode != OPMODE_NORMAL_NIC_WITHOUT_FLASH) {
3407                 dev_printk(KERN_ERR, &udev->dev, "unexpected opmode %d\n",
3408                            op_mode);
3409                 return -EINVAL;
3410         }
3411
3412         block = kmalloc(FW_BLOCK_SIZE, GFP_KERNEL);
3413         if (!block)
3414                 return -ENOMEM;
3415
3416         at76_dbg(DBG_DEVSTART, "downloading external firmware");
3417
3418         /* for fw >= 0.100, the device needs an extra empty block */
3419         do {
3420                 bsize = min_t(int, size, FW_BLOCK_SIZE);
3421                 memcpy(block, buf, bsize);
3422                 at76_dbg(DBG_DEVSTART,
3423                          "ext fw, size left = %5d, bsize = %4d, blockno = %2d",
3424                          size, bsize, blockno);
3425                 ret = at76_load_ext_fw_block(udev, blockno, block, bsize);
3426                 if (ret != bsize) {
3427                         dev_printk(KERN_ERR, &udev->dev,
3428                                    "loading %dth firmware block failed: %d\n",
3429                                    blockno, ret);
3430                         goto exit;
3431                 }
3432                 buf += bsize;
3433                 size -= bsize;
3434                 blockno++;
3435         } while (bsize > 0);
3436
3437         if (at76_is_505a(fwe->board_type)) {
3438                 at76_dbg(DBG_DEVSTART, "200 ms delay for 505a");
3439                 schedule_timeout_interruptible(HZ / 5 + 1);
3440         }
3441
3442 exit:
3443         kfree(block);
3444         if (ret < 0)
3445                 dev_printk(KERN_ERR, &udev->dev,
3446                            "downloading external firmware failed: %d\n", ret);
3447         return ret;
3448 }
3449
3450 /* Download internal firmware */
3451 static int at76_load_internal_fw(struct usb_device *udev, struct fwentry *fwe)
3452 {
3453         int ret;
3454         int need_remap = !at76_is_505a(fwe->board_type);
3455
3456         ret = at76_usbdfu_download(udev, fwe->intfw, fwe->intfw_size,
3457                                    need_remap ? 0 : 2 * HZ);
3458
3459         if (ret < 0) {
3460                 dev_printk(KERN_ERR, &udev->dev,
3461                            "downloading internal fw failed with %d\n", ret);
3462                 goto exit;
3463         }
3464
3465         at76_dbg(DBG_DEVSTART, "sending REMAP");
3466
3467         /* no REMAP for 505A (see SF driver) */
3468         if (need_remap) {
3469                 ret = at76_remap(udev);
3470                 if (ret < 0) {
3471                         dev_printk(KERN_ERR, &udev->dev,
3472                                    "sending REMAP failed with %d\n", ret);
3473                         goto exit;
3474                 }
3475         }
3476
3477         at76_dbg(DBG_DEVSTART, "sleeping for 2 seconds");
3478         schedule_timeout_interruptible(2 * HZ + 1);
3479         usb_reset_device(udev);
3480
3481 exit:
3482         return ret;
3483 }
3484
3485 static int at76_match_essid(struct at76_priv *priv, struct bss_info *ptr)
3486 {
3487         /* common criteria for both modi */
3488
3489         int ret = (priv->essid_size == 0 /* ANY ssid */  ||
3490                    (priv->essid_size == ptr->ssid_len &&
3491                     !memcmp(priv->essid, ptr->ssid, ptr->ssid_len)));
3492         if (!ret)
3493                 at76_dbg(DBG_BSS_MATCH,
3494                          "%s bss table entry %p: essid didn't match",
3495                          priv->netdev->name, ptr);
3496         return ret;
3497 }
3498
3499 static inline int at76_match_mode(struct at76_priv *priv, struct bss_info *ptr)
3500 {
3501         int ret;
3502
3503         if (priv->iw_mode == IW_MODE_ADHOC)
3504                 ret = ptr->capa & WLAN_CAPABILITY_IBSS;
3505         else
3506                 ret = ptr->capa & WLAN_CAPABILITY_ESS;
3507         if (!ret)
3508                 at76_dbg(DBG_BSS_MATCH,
3509                          "%s bss table entry %p: mode didn't match",
3510                          priv->netdev->name, ptr);
3511         return ret;
3512 }
3513
3514 static int at76_match_rates(struct at76_priv *priv, struct bss_info *ptr)
3515 {
3516         int i;
3517
3518         for (i = 0; i < ptr->rates_len; i++) {
3519                 u8 rate = ptr->rates[i];
3520
3521                 if (!(rate & 0x80))
3522                         continue;
3523
3524                 /* this is a basic rate we have to support
3525                    (see IEEE802.11, ch. 7.3.2.2) */
3526                 if (rate != (0x80 | hw_rates[0])
3527                     && rate != (0x80 | hw_rates[1])
3528                     && rate != (0x80 | hw_rates[2])
3529                     && rate != (0x80 | hw_rates[3])) {
3530                         at76_dbg(DBG_BSS_MATCH,
3531                                  "%s: bss table entry %p: basic rate %02x not "
3532                                  "supported", priv->netdev->name, ptr, rate);
3533                         return 0;
3534                 }
3535         }
3536
3537         /* if we use short preamble, the bss must support it */
3538         if (priv->preamble_type == PREAMBLE_TYPE_SHORT &&
3539             !(ptr->capa & WLAN_CAPABILITY_SHORT_PREAMBLE)) {
3540                 at76_dbg(DBG_BSS_MATCH,
3541                          "%s: %p does not support short preamble",
3542                          priv->netdev->name, ptr);
3543                 return 0;
3544         } else
3545                 return 1;
3546 }
3547
3548 static inline int at76_match_wep(struct at76_priv *priv, struct bss_info *ptr)
3549 {
3550         if (!priv->wep_enabled && ptr->capa & WLAN_CAPABILITY_PRIVACY) {
3551                 /* we have disabled WEP, but the BSS signals privacy */
3552                 at76_dbg(DBG_BSS_MATCH,
3553                          "%s: bss table entry %p: requires encryption",
3554                          priv->netdev->name, ptr);
3555                 return 0;
3556         }
3557         /* otherwise if the BSS does not signal privacy it may well
3558            accept encrypted packets from us ... */
3559         return 1;
3560 }
3561
3562 static inline int at76_match_bssid(struct at76_priv *priv, struct bss_info *ptr)
3563 {
3564         if (!priv->wanted_bssid_valid ||
3565             !compare_ether_addr(ptr->bssid, priv->wanted_bssid))
3566                 return 1;
3567
3568         at76_dbg(DBG_BSS_MATCH,
3569                  "%s: requested bssid - %pM does not match",
3570                  priv->netdev->name, priv->wanted_bssid);
3571         at76_dbg(DBG_BSS_MATCH,
3572                  "      AP bssid - %pM of bss table entry %p",
3573                  ptr->bssid, ptr);
3574         return 0;
3575 }
3576
3577 /**
3578  * at76_match_bss - try to find a matching bss in priv->bss
3579  *
3580  * last - last bss tried
3581  *
3582  * last == NULL signals a new round starting with priv->bss_list.next
3583  * this function must be called inside an acquired priv->bss_list_spinlock
3584  * otherwise the timeout on bss may remove the newly chosen entry
3585  */
3586 static struct bss_info *at76_match_bss(struct at76_priv *priv,
3587                                        struct bss_info *last)
3588 {
3589         struct bss_info *ptr = NULL;
3590         struct list_head *curr;
3591
3592         curr = last ? last->list.next : priv->bss_list.next;
3593         while (curr != &priv->bss_list) {
3594                 ptr = list_entry(curr, struct bss_info, list);
3595                 if (at76_match_essid(priv, ptr) && at76_match_mode(priv, ptr)
3596                     && at76_match_wep(priv, ptr) && at76_match_rates(priv, ptr)
3597                     && at76_match_bssid(priv, ptr))
3598                         break;
3599                 curr = curr->next;
3600         }
3601
3602         if (curr == &priv->bss_list)
3603                 ptr = NULL;
3604         /* otherwise ptr points to the struct bss_info we have chosen */
3605
3606         at76_dbg(DBG_BSS_TABLE, "%s %s: returned %p", priv->netdev->name,
3607                  __func__, ptr);
3608         return ptr;
3609 }
3610
3611 /* Start joining a matching BSS, or create own IBSS */
3612 static void at76_work_join(struct work_struct *work)
3613 {
3614         struct at76_priv *priv = container_of(work, struct at76_priv,
3615                                               work_join);
3616         int ret;
3617         unsigned long flags;
3618
3619         mutex_lock(&priv->mtx);
3620
3621         WARN_ON(priv->mac_state != MAC_JOINING);
3622         if (priv->mac_state != MAC_JOINING)
3623                 goto exit;
3624
3625         /* secure the access to priv->curr_bss ! */
3626         spin_lock_irqsave(&priv->bss_list_spinlock, flags);
3627         priv->curr_bss = at76_match_bss(priv, priv->curr_bss);
3628         spin_unlock_irqrestore(&priv->bss_list_spinlock, flags);
3629
3630         if (!priv->curr_bss) {
3631                 /* here we haven't found a matching (i)bss ... */
3632                 if (priv->iw_mode == IW_MODE_ADHOC) {
3633                         at76_set_mac_state(priv, MAC_OWN_IBSS);
3634                         at76_start_ibss(priv);
3635                         goto exit;
3636                 }
3637                 /* haven't found a matching BSS in infra mode - try again */
3638                 at76_set_mac_state(priv, MAC_SCANNING);
3639                 schedule_work(&priv->work_start_scan);
3640                 goto exit;
3641         }
3642
3643         ret = at76_join_bss(priv, priv->curr_bss);
3644         if (ret < 0) {
3645                 printk(KERN_ERR "%s: join_bss failed with %d\n",
3646                        priv->netdev->name, ret);
3647                 goto exit;
3648         }
3649
3650         ret = at76_wait_completion(priv, CMD_JOIN);
3651         if (ret != CMD_STATUS_COMPLETE) {
3652                 if (ret != CMD_STATUS_TIME_OUT)
3653                         printk(KERN_ERR "%s: join_bss completed with %d\n",
3654                                priv->netdev->name, ret);
3655                 else
3656                         printk(KERN_INFO "%s: join_bss ssid %pM timed out\n",
3657                                priv->netdev->name,
3658                                priv->curr_bss->bssid);
3659
3660                 /* retry next BSS immediately */
3661                 schedule_work(&priv->work_join);
3662                 goto exit;
3663         }
3664
3665         /* here we have joined the (I)BSS */
3666         if (priv->iw_mode == IW_MODE_ADHOC) {
3667                 struct bss_info *bptr = priv->curr_bss;
3668                 at76_set_mac_state(priv, MAC_CONNECTED);
3669                 /* get ESSID, BSSID and channel for priv->curr_bss */
3670                 priv->essid_size = bptr->ssid_len;
3671                 memcpy(priv->essid, bptr->ssid, bptr->ssid_len);
3672                 memcpy(priv->bssid, bptr->bssid, ETH_ALEN);
3673                 priv->channel = bptr->channel;
3674                 at76_iwevent_bss_connect(priv->netdev, bptr->bssid);
3675                 netif_carrier_on(priv->netdev);
3676                 netif_start_queue(priv->netdev);
3677                 /* just to be sure */
3678                 cancel_delayed_work(&priv->dwork_get_scan);
3679                 cancel_delayed_work(&priv->dwork_auth);
3680                 cancel_delayed_work(&priv->dwork_assoc);
3681         } else {
3682                 /* send auth req */
3683                 priv->retries = AUTH_RETRIES;
3684                 at76_set_mac_state(priv, MAC_AUTH);
3685                 at76_auth_req(priv, priv->curr_bss, 1, NULL);
3686                 at76_dbg(DBG_MGMT_TIMER,
3687                          "%s:%d: starting mgmt_timer + HZ", __func__, __LINE__);
3688                 schedule_delayed_work(&priv->dwork_auth, AUTH_TIMEOUT);
3689         }
3690
3691 exit:
3692         mutex_unlock(&priv->mtx);
3693 }
3694
3695 /* Reap scan results */
3696 static void at76_dwork_get_scan(struct work_struct *work)
3697 {
3698         int status;
3699         int ret;
3700         struct at76_priv *priv = container_of(work, struct at76_priv,
3701                                               dwork_get_scan.work);
3702
3703         mutex_lock(&priv->mtx);
3704         WARN_ON(priv->mac_state != MAC_SCANNING);
3705         if (priv->mac_state != MAC_SCANNING)
3706                 goto exit;
3707
3708         status = at76_get_cmd_status(priv->udev, CMD_SCAN);
3709         if (status < 0) {
3710                 printk(KERN_ERR "%s: %s: at76_get_cmd_status failed with %d\n",
3711                        priv->netdev->name, __func__, status);
3712                 status = CMD_STATUS_IN_PROGRESS;
3713                 /* INFO: Hope it was a one off error - if not, scanning
3714                    further down the line and stop this cycle */
3715         }
3716         at76_dbg(DBG_PROGRESS,
3717                  "%s %s: got cmd_status %d (state %s, need_any %d)",
3718                  priv->netdev->name, __func__, status,
3719                  mac_states[priv->mac_state], priv->scan_need_any);
3720
3721         if (status != CMD_STATUS_COMPLETE) {
3722                 if ((status != CMD_STATUS_IN_PROGRESS) &&
3723                     (status != CMD_STATUS_IDLE))
3724                         printk(KERN_ERR "%s: %s: Bad scan status: %s\n",
3725                                priv->netdev->name, __func__,
3726                                at76_get_cmd_status_string(status));
3727
3728                 /* the first cmd status after scan start is always a IDLE ->
3729                    start the timer to poll again until COMPLETED */
3730                 at76_dbg(DBG_MGMT_TIMER,
3731                          "%s:%d: starting mgmt_timer for %d ticks",
3732                          __func__, __LINE__, SCAN_POLL_INTERVAL);
3733                 schedule_delayed_work(&priv->dwork_get_scan,
3734                                       SCAN_POLL_INTERVAL);
3735                 goto exit;
3736         }
3737
3738         if (at76_debug & DBG_BSS_TABLE)
3739                 at76_dump_bss_table(priv);
3740
3741         if (priv->scan_need_any) {
3742                 ret = at76_start_scan(priv, 0);
3743                 if (ret < 0)
3744                         printk(KERN_ERR
3745                                "%s: %s: start_scan (ANY) failed with %d\n",
3746                                priv->netdev->name, __func__, ret);
3747                 at76_dbg(DBG_MGMT_TIMER,
3748                          "%s:%d: starting mgmt_timer for %d ticks", __func__,
3749                          __LINE__, SCAN_POLL_INTERVAL);
3750                 schedule_delayed_work(&priv->dwork_get_scan,
3751                                       SCAN_POLL_INTERVAL);
3752                 priv->scan_need_any = 0;
3753         } else {
3754                 priv->scan_state = SCAN_COMPLETED;
3755                 /* report the end of scan to user space */
3756                 at76_iwevent_scan_complete(priv->netdev);
3757                 at76_set_mac_state(priv, MAC_JOINING);
3758                 schedule_work(&priv->work_join);
3759         }
3760
3761 exit:
3762         mutex_unlock(&priv->mtx);
3763 }
3764
3765 /* Handle loss of beacons from the AP */
3766 static void at76_dwork_beacon(struct work_struct *work)
3767 {
3768         struct at76_priv *priv = container_of(work, struct at76_priv,
3769                                               dwork_beacon.work);
3770
3771         mutex_lock(&priv->mtx);
3772         if (priv->mac_state != MAC_CONNECTED || priv->iw_mode != IW_MODE_INFRA)
3773                 goto exit;
3774
3775         /* We haven't received any beacons from out AP for BEACON_TIMEOUT */
3776         printk(KERN_INFO "%s: lost beacon bssid %pM\n",
3777                priv->netdev->name, priv->curr_bss->bssid);
3778
3779         netif_carrier_off(priv->netdev);
3780         netif_stop_queue(priv->netdev);
3781         at76_iwevent_bss_disconnect(priv->netdev);
3782         at76_set_mac_state(priv, MAC_SCANNING);
3783         schedule_work(&priv->work_start_scan);
3784
3785 exit:
3786         mutex_unlock(&priv->mtx);
3787 }
3788
3789 /* Handle authentication response timeout */
3790 static void at76_dwork_auth(struct work_struct *work)
3791 {
3792         struct at76_priv *priv = container_of(work, struct at76_priv,
3793                                               dwork_auth.work);
3794
3795         mutex_lock(&priv->mtx);
3796         WARN_ON(priv->mac_state != MAC_AUTH);
3797         if (priv->mac_state != MAC_AUTH)
3798                 goto exit;
3799
3800         at76_dbg(DBG_PROGRESS, "%s: authentication response timeout",
3801                  priv->netdev->name);
3802
3803         if (priv->retries-- >= 0) {
3804                 at76_auth_req(priv, priv->curr_bss, 1, NULL);
3805                 at76_dbg(DBG_MGMT_TIMER, "%s:%d: starting mgmt_timer + HZ",
3806                          __func__, __LINE__);
3807                 schedule_delayed_work(&priv->dwork_auth, AUTH_TIMEOUT);
3808         } else {
3809                 /* try to get next matching BSS */
3810                 at76_set_mac_state(priv, MAC_JOINING);
3811                 schedule_work(&priv->work_join);
3812         }
3813
3814 exit:
3815         mutex_unlock(&priv->mtx);
3816 }
3817
3818 /* Handle association response timeout */
3819 static void at76_dwork_assoc(struct work_struct *work)
3820 {
3821         struct at76_priv *priv = container_of(work, struct at76_priv,
3822                                               dwork_assoc.work);
3823
3824         mutex_lock(&priv->mtx);
3825         WARN_ON(priv->mac_state != MAC_ASSOC);
3826         if (priv->mac_state != MAC_ASSOC)
3827                 goto exit;
3828
3829         at76_dbg(DBG_PROGRESS, "%s: association response timeout",
3830                  priv->netdev->name);
3831
3832         if (priv->retries-- >= 0) {
3833                 at76_assoc_req(priv, priv->curr_bss);
3834                 at76_dbg(DBG_MGMT_TIMER, "%s:%d: starting mgmt_timer + HZ",
3835                          __func__, __LINE__);
3836                 schedule_delayed_work(&priv->dwork_assoc, ASSOC_TIMEOUT);
3837         } else {
3838                 /* try to get next matching BSS */
3839                 at76_set_mac_state(priv, MAC_JOINING);
3840                 schedule_work(&priv->work_join);
3841         }
3842
3843 exit:
3844         mutex_unlock(&priv->mtx);
3845 }
3846
3847 /* Read new bssid in ad-hoc mode */
3848 static void at76_work_new_bss(struct work_struct *work)
3849 {
3850         struct at76_priv *priv = container_of(work, struct at76_priv,
3851                                               work_new_bss);
3852         int ret;
3853         struct mib_mac_mgmt mac_mgmt;
3854
3855         mutex_lock(&priv->mtx);
3856
3857         ret = at76_get_mib(priv->udev, MIB_MAC_MGMT, &mac_mgmt,
3858                            sizeof(struct mib_mac_mgmt));
3859         if (ret < 0) {
3860                 printk(KERN_ERR "%s: at76_get_mib failed: %d\n",
3861                        priv->netdev->name, ret);
3862                 goto exit;
3863         }
3864
3865         at76_dbg(DBG_PROGRESS, "ibss_change = 0x%2x", mac_mgmt.ibss_change);
3866         memcpy(priv->bssid, mac_mgmt.current_bssid, ETH_ALEN);
3867         at76_dbg(DBG_PROGRESS, "using BSSID %pM", priv->bssid);
3868
3869         at76_iwevent_bss_connect(priv->netdev, priv->bssid);
3870
3871         priv->mib_buf.type = MIB_MAC_MGMT;
3872         priv->mib_buf.size = 1;
3873         priv->mib_buf.index = offsetof(struct mib_mac_mgmt, ibss_change);
3874         priv->mib_buf.data.byte = 0;
3875
3876         ret = at76_set_mib(priv, &priv->mib_buf);
3877         if (ret < 0)
3878                 printk(KERN_ERR "%s: set_mib (ibss change ok) failed: %d\n",
3879                        priv->netdev->name, ret);
3880
3881 exit:
3882         mutex_unlock(&priv->mtx);
3883 }
3884
3885 static int at76_startup_device(struct at76_priv *priv)
3886 {
3887         struct at76_card_config *ccfg = &priv->card_config;
3888         int ret;
3889
3890         at76_dbg(DBG_PARAMS,
3891                  "%s param: ssid %.*s (%s) mode %s ch %d wep %s key %d "
3892                  "keylen %d", priv->netdev->name, priv->essid_size, priv->essid,
3893                  hex2str(priv->essid, IW_ESSID_MAX_SIZE),
3894                  priv->iw_mode == IW_MODE_ADHOC ? "adhoc" : "infra",
3895                  priv->channel, priv->wep_enabled ? "enabled" : "disabled",
3896                  priv->wep_key_id, priv->wep_keys_len[priv->wep_key_id]);
3897         at76_dbg(DBG_PARAMS,
3898                  "%s param: preamble %s rts %d retry %d frag %d "
3899                  "txrate %s auth_mode %d", priv->netdev->name,
3900                  preambles[priv->preamble_type], priv->rts_threshold,
3901                  priv->short_retry_limit, priv->frag_threshold,
3902                  priv->txrate == TX_RATE_1MBIT ? "1MBit" : priv->txrate ==
3903                  TX_RATE_2MBIT ? "2MBit" : priv->txrate ==
3904                  TX_RATE_5_5MBIT ? "5.5MBit" : priv->txrate ==
3905                  TX_RATE_11MBIT ? "11MBit" : priv->txrate ==
3906                  TX_RATE_AUTO ? "auto" : "<invalid>", priv->auth_mode);
3907         at76_dbg(DBG_PARAMS,
3908                  "%s param: pm_mode %d pm_period %d auth_mode %s "
3909                  "scan_times %d %d scan_mode %s",
3910                  priv->netdev->name, priv->pm_mode, priv->pm_period,
3911                  priv->auth_mode == WLAN_AUTH_OPEN ? "open" : "shared_secret",
3912                  priv->scan_min_time, priv->scan_max_time,
3913                  priv->scan_mode == SCAN_TYPE_ACTIVE ? "active" : "passive");
3914
3915         memset(ccfg, 0, sizeof(struct at76_card_config));
3916         ccfg->promiscuous_mode = 0;
3917         ccfg->short_retry_limit = priv->short_retry_limit;
3918
3919         if (priv->wep_enabled) {
3920                 if (priv->wep_keys_len[priv->wep_key_id] > WEP_SMALL_KEY_LEN)
3921                         ccfg->encryption_type = 2;
3922                 else
3923                         ccfg->encryption_type = 1;
3924
3925                 /* jal: always exclude unencrypted if WEP is active */
3926                 ccfg->exclude_unencrypted = 1;
3927         } else {
3928                 ccfg->exclude_unencrypted = 0;
3929                 ccfg->encryption_type = 0;
3930         }
3931
3932         ccfg->rts_threshold = cpu_to_le16(priv->rts_threshold);
3933         ccfg->fragmentation_threshold = cpu_to_le16(priv->frag_threshold);
3934
3935         memcpy(ccfg->basic_rate_set, hw_rates, 4);
3936         /* jal: really needed, we do a set_mib for autorate later ??? */
3937         ccfg->auto_rate_fallback = (priv->txrate == TX_RATE_AUTO ? 1 : 0);
3938         ccfg->channel = priv->channel;
3939         ccfg->privacy_invoked = priv->wep_enabled;
3940         memcpy(ccfg->current_ssid, priv->essid, IW_ESSID_MAX_SIZE);
3941         ccfg->ssid_len = priv->essid_size;
3942
3943         ccfg->wep_default_key_id = priv->wep_key_id;
3944         memcpy(ccfg->wep_default_key_value, priv->wep_keys, 4 * WEP_KEY_LEN);
3945
3946         ccfg->short_preamble = priv->preamble_type;
3947         ccfg->beacon_period = cpu_to_le16(priv->beacon_period);
3948
3949         ret = at76_set_card_command(priv->udev, CMD_STARTUP, &priv->card_config,
3950                                     sizeof(struct at76_card_config));
3951         if (ret < 0) {
3952                 printk(KERN_ERR "%s: at76_set_card_command failed: %d\n",
3953                        priv->netdev->name, ret);
3954                 return ret;
3955         }
3956
3957         at76_wait_completion(priv, CMD_STARTUP);
3958
3959         /* remove BSSID from previous run */
3960         memset(priv->bssid, 0, ETH_ALEN);
3961
3962         if (at76_set_radio(priv, 1) == 1)
3963                 at76_wait_completion(priv, CMD_RADIO_ON);
3964
3965         ret = at76_set_preamble(priv, priv->preamble_type);
3966         if (ret < 0)
3967                 return ret;
3968
3969         ret = at76_set_frag(priv, priv->frag_threshold);
3970         if (ret < 0)
3971                 return ret;
3972
3973         ret = at76_set_rts(priv, priv->rts_threshold);
3974         if (ret < 0)
3975                 return ret;
3976
3977         ret = at76_set_autorate_fallback(priv,
3978                                          priv->txrate == TX_RATE_AUTO ? 1 : 0);
3979         if (ret < 0)
3980                 return ret;
3981
3982         ret = at76_set_pm_mode(priv);
3983         if (ret < 0)
3984                 return ret;
3985
3986         if (at76_debug & DBG_MIB) {
3987                 at76_dump_mib_mac(priv);
3988                 at76_dump_mib_mac_addr(priv);
3989                 at76_dump_mib_mac_mgmt(priv);
3990                 at76_dump_mib_mac_wep(priv);
3991                 at76_dump_mib_mdomain(priv);
3992                 at76_dump_mib_phy(priv);
3993                 at76_dump_mib_local(priv);
3994         }
3995
3996         return 0;
3997 }
3998
3999 /* Restart the interface */
4000 static void at76_dwork_restart(struct work_struct *work)
4001 {
4002         struct at76_priv *priv = container_of(work, struct at76_priv,
4003                                               dwork_restart.work);
4004
4005         mutex_lock(&priv->mtx);
4006
4007         netif_carrier_off(priv->netdev);        /* stop netdev watchdog */
4008         netif_stop_queue(priv->netdev); /* stop tx data packets */
4009
4010         at76_startup_device(priv);
4011
4012         if (priv->iw_mode != IW_MODE_MONITOR) {
4013                 priv->netdev->type = ARPHRD_ETHER;
4014                 at76_set_mac_state(priv, MAC_SCANNING);
4015                 schedule_work(&priv->work_start_scan);
4016         } else {
4017                 priv->netdev->type = ARPHRD_IEEE80211_RADIOTAP;
4018                 at76_start_monitor(priv);
4019         }
4020
4021         mutex_unlock(&priv->mtx);
4022 }
4023
4024 /* Initiate scanning */
4025 static void at76_work_start_scan(struct work_struct *work)
4026 {
4027         struct at76_priv *priv = container_of(work, struct at76_priv,
4028                                               work_start_scan);
4029         int ret;
4030
4031         mutex_lock(&priv->mtx);
4032
4033         WARN_ON(priv->mac_state != MAC_SCANNING);
4034         if (priv->mac_state != MAC_SCANNING)
4035                 goto exit;
4036
4037         /* only clear the bss list when a scan is actively initiated,
4038          * otherwise simply rely on at76_bss_list_timeout */
4039         if (priv->scan_state == SCAN_IN_PROGRESS) {
4040                 at76_free_bss_list(priv);
4041                 priv->scan_need_any = 1;
4042         } else
4043                 priv->scan_need_any = 0;
4044
4045         ret = at76_start_scan(priv, 1);
4046
4047         if (ret < 0)
4048                 printk(KERN_ERR "%s: %s: start_scan failed with %d\n",
4049                        priv->netdev->name, __func__, ret);
4050         else {
4051                 at76_dbg(DBG_MGMT_TIMER,
4052                          "%s:%d: starting mgmt_timer for %d ticks",
4053                          __func__, __LINE__, SCAN_POLL_INTERVAL);
4054                 schedule_delayed_work(&priv->dwork_get_scan,
4055                                       SCAN_POLL_INTERVAL);
4056         }
4057
4058 exit:
4059         mutex_unlock(&priv->mtx);
4060 }
4061
4062 /* Enable or disable promiscuous mode */
4063 static void at76_work_set_promisc(struct work_struct *work)
4064 {
4065         struct at76_priv *priv = container_of(work, struct at76_priv,
4066                                               work_set_promisc);
4067         int ret = 0;
4068
4069         mutex_lock(&priv->mtx);
4070
4071         priv->mib_buf.type = MIB_LOCAL;
4072         priv->mib_buf.size = 1;
4073         priv->mib_buf.index = offsetof(struct mib_local, promiscuous_mode);
4074         priv->mib_buf.data.byte = priv->promisc ? 1 : 0;
4075
4076         ret = at76_set_mib(priv, &priv->mib_buf);
4077         if (ret < 0)
4078                 printk(KERN_ERR "%s: set_mib (promiscuous_mode) failed: %d\n",
4079                        priv->netdev->name, ret);
4080
4081         mutex_unlock(&priv->mtx);
4082 }
4083
4084 /* Submit Rx urb back to the device */
4085 static void at76_work_submit_rx(struct work_struct *work)
4086 {
4087         struct at76_priv *priv = container_of(work, struct at76_priv,
4088                                               work_submit_rx);
4089
4090         mutex_lock(&priv->mtx);
4091         at76_submit_rx_urb(priv);
4092         mutex_unlock(&priv->mtx);
4093 }
4094
4095 /* We got an association response */
4096 static void at76_rx_mgmt_assoc(struct at76_priv *priv,
4097                                struct at76_rx_buffer *buf)
4098 {
4099         struct ieee80211_assoc_response *resp =
4100             (struct ieee80211_assoc_response *)buf->packet;
4101         u16 assoc_id = le16_to_cpu(resp->aid);
4102         u16 status = le16_to_cpu(resp->status);
4103
4104         at76_dbg(DBG_RX_MGMT, "%s: rx AssocResp bssid %pM capa 0x%04x status "
4105                  "0x%04x assoc_id 0x%04x rates %s", priv->netdev->name,
4106                  resp->header.addr3, le16_to_cpu(resp->capability),
4107                  status, assoc_id, hex2str(resp->info_element->data,
4108                                            resp->info_element->len));
4109
4110         if (priv->mac_state != MAC_ASSOC) {
4111                 printk(KERN_INFO "%s: AssocResp in state %s ignored\n",
4112                        priv->netdev->name, mac_states[priv->mac_state]);
4113                 return;
4114         }
4115
4116         BUG_ON(!priv->curr_bss);
4117
4118         cancel_delayed_work(&priv->dwork_assoc);
4119         if (status == WLAN_STATUS_SUCCESS) {
4120                 struct bss_info *ptr = priv->curr_bss;
4121                 priv->assoc_id = assoc_id & 0x3fff;
4122                 /* update iwconfig params */
4123                 memcpy(priv->bssid, ptr->bssid, ETH_ALEN);
4124                 memcpy(priv->essid, ptr->ssid, ptr->ssid_len);
4125                 priv->essid_size = ptr->ssid_len;
4126                 priv->channel = ptr->channel;
4127                 schedule_work(&priv->work_assoc_done);
4128         } else {
4129                 at76_set_mac_state(priv, MAC_JOINING);
4130                 schedule_work(&priv->work_join);
4131         }
4132 }
4133
4134 /* Process disassociation request from the AP */
4135 static void at76_rx_mgmt_disassoc(struct at76_priv *priv,
4136                                   struct at76_rx_buffer *buf)
4137 {
4138         struct ieee80211_disassoc *resp =
4139             (struct ieee80211_disassoc *)buf->packet;
4140         struct ieee80211_hdr_3addr *mgmt = &resp->header;
4141
4142         at76_dbg(DBG_RX_MGMT,
4143                  "%s: rx DisAssoc bssid %pM reason 0x%04x destination %pM",
4144                  priv->netdev->name, mgmt->addr3,
4145                  le16_to_cpu(resp->reason), mgmt->addr1);
4146
4147         /* We are not connected, ignore */
4148         if (priv->mac_state == MAC_SCANNING || priv->mac_state == MAC_INIT
4149             || !priv->curr_bss)
4150                 return;
4151
4152         /* Not our BSSID, ignore */
4153         if (compare_ether_addr(mgmt->addr3, priv->curr_bss->bssid))
4154                 return;
4155
4156         /* Not for our STA and not broadcast, ignore */
4157         if (compare_ether_addr(priv->netdev->dev_addr, mgmt->addr1)
4158             && !is_broadcast_ether_addr(mgmt->addr1))
4159                 return;
4160
4161         if (priv->mac_state != MAC_ASSOC && priv->mac_state != MAC_CONNECTED
4162             && priv->mac_state != MAC_JOINING) {
4163                 printk(KERN_INFO "%s: DisAssoc in state %s ignored\n",
4164                        priv->netdev->name, mac_states[priv->mac_state]);
4165                 return;
4166         }
4167
4168         if (priv->mac_state == MAC_CONNECTED) {
4169                 netif_carrier_off(priv->netdev);
4170                 netif_stop_queue(priv->netdev);
4171                 at76_iwevent_bss_disconnect(priv->netdev);
4172         }
4173         cancel_delayed_work(&priv->dwork_get_scan);
4174         cancel_delayed_work(&priv->dwork_beacon);
4175         cancel_delayed_work(&priv->dwork_auth);
4176         cancel_delayed_work(&priv->dwork_assoc);
4177         at76_set_mac_state(priv, MAC_JOINING);
4178         schedule_work(&priv->work_join);
4179 }
4180
4181 static void at76_rx_mgmt_auth(struct at76_priv *priv,
4182                               struct at76_rx_buffer *buf)
4183 {
4184         struct ieee80211_auth *resp = (struct ieee80211_auth *)buf->packet;
4185         struct ieee80211_hdr_3addr *mgmt = &resp->header;
4186         int seq_nr = le16_to_cpu(resp->transaction);
4187         int alg = le16_to_cpu(resp->algorithm);
4188         int status = le16_to_cpu(resp->status);
4189
4190         at76_dbg(DBG_RX_MGMT,
4191                  "%s: rx AuthFrame bssid %pM alg %d seq_nr %d status %d "
4192                  "destination %pM", priv->netdev->name, mgmt->addr3,
4193                  alg, seq_nr, status, mgmt->addr1);
4194
4195         if (alg == WLAN_AUTH_SHARED_KEY && seq_nr == 2)
4196                 at76_dbg(DBG_RX_MGMT, "%s: AuthFrame challenge %s ...",
4197                          priv->netdev->name, hex2str(resp->info_element, 18));
4198
4199         if (priv->mac_state != MAC_AUTH) {
4200                 printk(KERN_INFO "%s: ignored AuthFrame in state %s\n",
4201                        priv->netdev->name, mac_states[priv->mac_state]);
4202                 return;
4203         }
4204         if (priv->auth_mode != alg) {
4205                 printk(KERN_INFO "%s: ignored AuthFrame for alg %d\n",
4206                        priv->netdev->name, alg);
4207                 return;
4208         }
4209
4210         BUG_ON(!priv->curr_bss);
4211
4212         /* Not our BSSID or not for our STA, ignore */
4213         if (compare_ether_addr(mgmt->addr3, priv->curr_bss->bssid)
4214             || compare_ether_addr(priv->netdev->dev_addr, mgmt->addr1))
4215                 return;
4216
4217         cancel_delayed_work(&priv->dwork_auth);
4218         if (status != WLAN_STATUS_SUCCESS) {
4219                 /* try to join next bss */
4220                 at76_set_mac_state(priv, MAC_JOINING);
4221                 schedule_work(&priv->work_join);
4222                 return;
4223         }
4224
4225         if (priv->auth_mode == WLAN_AUTH_OPEN || seq_nr == 4) {
4226                 priv->retries = ASSOC_RETRIES;
4227                 at76_set_mac_state(priv, MAC_ASSOC);
4228                 at76_assoc_req(priv, priv->curr_bss);
4229                 at76_dbg(DBG_MGMT_TIMER,
4230                          "%s:%d: starting mgmt_timer + HZ", __func__, __LINE__);
4231                 schedule_delayed_work(&priv->dwork_assoc, ASSOC_TIMEOUT);
4232                 return;
4233         }
4234
4235         WARN_ON(seq_nr != 2);
4236         at76_auth_req(priv, priv->curr_bss, seq_nr + 1, resp->info_element);
4237         at76_dbg(DBG_MGMT_TIMER, "%s:%d: starting mgmt_timer + HZ", __func__,
4238                  __LINE__);
4239         schedule_delayed_work(&priv->dwork_auth, AUTH_TIMEOUT);
4240 }
4241
4242 static void at76_rx_mgmt_deauth(struct at76_priv *priv,
4243                                 struct at76_rx_buffer *buf)
4244 {
4245         struct ieee80211_disassoc *resp =
4246             (struct ieee80211_disassoc *)buf->packet;
4247         struct ieee80211_hdr_3addr *mgmt = &resp->header;
4248
4249         at76_dbg(DBG_RX_MGMT | DBG_PROGRESS,
4250                  "%s: rx DeAuth bssid %pM reason 0x%04x destination %pM",
4251                  priv->netdev->name, mgmt->addr3,
4252                  le16_to_cpu(resp->reason), mgmt->addr1);
4253
4254         if (priv->mac_state != MAC_AUTH && priv->mac_state != MAC_ASSOC
4255             && priv->mac_state != MAC_CONNECTED) {
4256                 printk(KERN_INFO "%s: DeAuth in state %s ignored\n",
4257                        priv->netdev->name, mac_states[priv->mac_state]);
4258                 return;
4259         }
4260
4261         BUG_ON(!priv->curr_bss);
4262
4263         /* Not our BSSID, ignore */
4264         if (compare_ether_addr(mgmt->addr3, priv->curr_bss->bssid))
4265                 return;
4266
4267         /* Not for our STA and not broadcast, ignore */
4268         if (compare_ether_addr(priv->netdev->dev_addr, mgmt->addr1)
4269             && !is_broadcast_ether_addr(mgmt->addr1))
4270                 return;
4271
4272         if (priv->mac_state == MAC_CONNECTED)
4273                 at76_iwevent_bss_disconnect(priv->netdev);
4274
4275         at76_set_mac_state(priv, MAC_JOINING);
4276         schedule_work(&priv->work_join);
4277         cancel_delayed_work(&priv->dwork_get_scan);
4278         cancel_delayed_work(&priv->dwork_beacon);
4279         cancel_delayed_work(&priv->dwork_auth);
4280         cancel_delayed_work(&priv->dwork_assoc);
4281 }
4282
4283 static void at76_rx_mgmt_beacon(struct at76_priv *priv,
4284                                 struct at76_rx_buffer *buf)
4285 {
4286         int varpar_len;
4287         /* beacon content */
4288         struct ieee80211_beacon *bdata = (struct ieee80211_beacon *)buf->packet;
4289         struct ieee80211_hdr_3addr *mgmt = &bdata->header;
4290
4291         struct list_head *lptr;
4292         struct bss_info *match; /* entry matching addr3 with its bssid */
4293         int new_entry = 0;
4294         int len;
4295         struct ieee80211_info_element *ie;
4296         int have_ssid = 0;
4297         int have_rates = 0;
4298         int have_channel = 0;
4299         int keep_going = 1;
4300         unsigned long flags;
4301
4302         spin_lock_irqsave(&priv->bss_list_spinlock, flags);
4303         if (priv->mac_state == MAC_CONNECTED) {
4304                 /* in state MAC_CONNECTED we use the mgmt_timer to control
4305                    the beacon of the BSS */
4306                 BUG_ON(!priv->curr_bss);
4307
4308                 if (!compare_ether_addr(priv->curr_bss->bssid, mgmt->addr3)) {
4309                         /* We got our AP's beacon, defer the timeout handler.
4310                            Kill pending work first, as schedule_delayed_work()
4311                            won't do it. */
4312                         cancel_delayed_work(&priv->dwork_beacon);
4313                         schedule_delayed_work(&priv->dwork_beacon,
4314                                               BEACON_TIMEOUT);
4315                         priv->curr_bss->rssi = buf->rssi;
4316                         priv->beacons_received++;
4317                         goto exit;
4318                 }
4319         }
4320
4321         /* look if we have this BSS already in the list */
4322         match = NULL;
4323
4324         if (!list_empty(&priv->bss_list)) {
4325                 list_for_each(lptr, &priv->bss_list) {
4326                         struct bss_info *bss_ptr =
4327                             list_entry(lptr, struct bss_info, list);
4328                         if (!compare_ether_addr(bss_ptr->bssid, mgmt->addr3)) {
4329                                 match = bss_ptr;
4330                                 break;
4331                         }
4332                 }
4333         }
4334
4335         if (!match) {
4336                 /* BSS not in the list - append it */
4337                 match = kzalloc(sizeof(struct bss_info), GFP_ATOMIC);
4338                 if (!match) {
4339                         at76_dbg(DBG_BSS_TABLE,
4340                                  "%s: cannot kmalloc new bss info (%zd byte)",
4341                                  priv->netdev->name, sizeof(struct bss_info));
4342                         goto exit;
4343                 }
4344                 new_entry = 1;
4345                 list_add_tail(&match->list, &priv->bss_list);
4346         }
4347
4348         match->capa = le16_to_cpu(bdata->capability);
4349         match->beacon_interval = le16_to_cpu(bdata->beacon_interval);
4350         match->rssi = buf->rssi;
4351         match->link_qual = buf->link_quality;
4352         match->noise_level = buf->noise_level;
4353         memcpy(match->bssid, mgmt->addr3, ETH_ALEN);
4354         at76_dbg(DBG_RX_BEACON, "%s: bssid %pM", priv->netdev->name,
4355                  match->bssid);
4356
4357         ie = bdata->info_element;
4358
4359         /* length of var length beacon parameters */
4360         varpar_len = min_t(int, le16_to_cpu(buf->wlength) -
4361                            sizeof(struct ieee80211_beacon),
4362                            BEACON_MAX_DATA_LENGTH);
4363
4364         /* This routine steps through the bdata->data array to get
4365          * some useful information about the access point.
4366          * Currently, this implementation supports receipt of: SSID,
4367          * supported transfer rates and channel, in any order, with some
4368          * tolerance for intermittent unknown codes (although this
4369          * functionality may not be necessary as the useful information will
4370          * usually arrive in consecutively, but there have been some
4371          * reports of some of the useful information fields arriving in a
4372          * different order).
4373          * It does not support any more IE types although MFIE_TYPE_TIM may
4374          * be supported (on my AP at least).
4375          * The bdata->data array is about 1500 bytes long but only ~36 of those
4376          * bytes are useful, hence the have_ssid etc optimizations. */
4377
4378         while (keep_going &&
4379                ((&ie->data[ie->len] - (u8 *)bdata->info_element) <=
4380                 varpar_len)) {
4381
4382                 switch (ie->id) {
4383
4384                 case WLAN_EID_SSID:
4385                         if (have_ssid)
4386                                 break;
4387
4388                         len = min_t(int, IW_ESSID_MAX_SIZE, ie->len);
4389
4390                         /* we copy only if this is a new entry,
4391                            or the incoming SSID is not a hidden SSID. This
4392                            will protect us from overwriting a real SSID read
4393                            in a ProbeResponse with a hidden one from a
4394                            following beacon. */
4395                         if (!new_entry && at76_is_hidden_ssid(ie->data, len)) {
4396                                 have_ssid = 1;
4397                                 break;
4398                         }
4399
4400                         match->ssid_len = len;
4401                         memcpy(match->ssid, ie->data, len);
4402                         at76_dbg(DBG_RX_BEACON, "%s: SSID - %.*s",
4403                                  priv->netdev->name, len, match->ssid);
4404                         have_ssid = 1;
4405                         break;
4406
4407                 case WLAN_EID_SUPP_RATES:
4408                         if (have_rates)
4409                                 break;
4410
4411                         match->rates_len =
4412                             min_t(int, sizeof(match->rates), ie->len);
4413                         memcpy(match->rates, ie->data, match->rates_len);
4414                         have_rates = 1;
4415                         at76_dbg(DBG_RX_BEACON, "%s: SUPPORTED RATES %s",
4416                                  priv->netdev->name,
4417                                  hex2str(ie->data, ie->len));
4418                         break;
4419
4420                 case WLAN_EID_DS_PARAMS:
4421                         if (have_channel)
4422                                 break;
4423
4424                         match->channel = ie->data[0];
4425                         have_channel = 1;
4426                         at76_dbg(DBG_RX_BEACON, "%s: CHANNEL - %d",
4427                                  priv->netdev->name, match->channel);
4428                         break;
4429
4430                 case WLAN_EID_CF_PARAMS:
4431                 case WLAN_EID_TIM:
4432                 case WLAN_EID_IBSS_PARAMS:
4433                 default:
4434                         at76_dbg(DBG_RX_BEACON, "%s: beacon IE id %d len %d %s",
4435                                  priv->netdev->name, ie->id, ie->len,
4436                                  hex2str(ie->data, ie->len));
4437                         break;
4438                 }
4439
4440                 /* advance to the next informational element */
4441                 next_ie(&ie);
4442
4443                 /* Optimization: after all, the bdata->data array is
4444                  * varpar_len bytes long, whereas we get all of the useful
4445                  * information after only ~36 bytes, this saves us a lot of
4446                  * time (and trouble as the remaining portion of the array
4447                  * could be full of junk)
4448                  * Comment this out if you want to see what other information
4449                  * comes from the AP - although little of it may be useful */
4450         }
4451
4452         at76_dbg(DBG_RX_BEACON, "%s: Finished processing beacon data",
4453                  priv->netdev->name);
4454
4455         match->last_rx = jiffies;       /* record last rx of beacon */
4456
4457 exit:
4458         spin_unlock_irqrestore(&priv->bss_list_spinlock, flags);
4459 }
4460
4461 /* Calculate the link level from a given rx_buffer */
4462 static void at76_calc_level(struct at76_priv *priv, struct at76_rx_buffer *buf,
4463                             struct iw_quality *qual)
4464 {
4465         /* just a guess for now, might be different for other chips */
4466         int max_rssi = 42;
4467
4468         qual->level = (buf->rssi * 100 / max_rssi);
4469         if (qual->level > 100)
4470                 qual->level = 100;
4471         qual->updated |= IW_QUAL_LEVEL_UPDATED;
4472 }
4473
4474 /* Calculate the link quality from a given rx_buffer */
4475 static void at76_calc_qual(struct at76_priv *priv, struct at76_rx_buffer *buf,
4476                            struct iw_quality *qual)
4477 {
4478         if (at76_is_intersil(priv->board_type))
4479                 qual->qual = buf->link_quality;
4480         else {
4481                 unsigned long elapsed;
4482
4483                 /* Update qual at most once a second */
4484                 elapsed = jiffies - priv->beacons_last_qual;
4485                 if (elapsed < 1 * HZ)
4486                         return;
4487
4488                 qual->qual = qual->level * priv->beacons_received *
4489                     msecs_to_jiffies(priv->beacon_period) / elapsed;
4490
4491                 priv->beacons_last_qual = jiffies;
4492                 priv->beacons_received = 0;
4493         }
4494         qual->qual = (qual->qual > 100) ? 100 : qual->qual;
4495         qual->updated |= IW_QUAL_QUAL_UPDATED;
4496 }
4497
4498 /* Calculate the noise quality from a given rx_buffer */
4499 static void at76_calc_noise(struct at76_priv *priv, struct at76_rx_buffer *buf,
4500                             struct iw_quality *qual)
4501 {
4502         qual->noise = 0;
4503         qual->updated |= IW_QUAL_NOISE_INVALID;
4504 }
4505
4506 static void at76_update_wstats(struct at76_priv *priv,
4507                                struct at76_rx_buffer *buf)
4508 {
4509         struct iw_quality *qual = &priv->wstats.qual;
4510
4511         if (buf->rssi && priv->mac_state == MAC_CONNECTED) {
4512                 qual->updated = 0;
4513                 at76_calc_level(priv, buf, qual);
4514                 at76_calc_qual(priv, buf, qual);
4515                 at76_calc_noise(priv, buf, qual);
4516         } else {
4517                 qual->qual = 0;
4518                 qual->level = 0;
4519                 qual->noise = 0;
4520                 qual->updated = IW_QUAL_ALL_INVALID;
4521         }
4522 }
4523
4524 static void at76_rx_mgmt(struct at76_priv *priv, struct at76_rx_buffer *buf)
4525 {
4526         struct ieee80211_hdr_3addr *mgmt =
4527             (struct ieee80211_hdr_3addr *)buf->packet;
4528         u16 framectl = le16_to_cpu(mgmt->frame_ctl);
4529
4530         /* update wstats */
4531         if (priv->mac_state != MAC_INIT && priv->mac_state != MAC_SCANNING) {
4532                 /* jal: this is a dirty hack needed by Tim in ad-hoc mode */
4533                 /* Data packets always seem to have a 0 link level, so we
4534                    only read link quality info from management packets.
4535                    Atmel driver actually averages the present, and previous
4536                    values, we just present the raw value at the moment - TJS */
4537                 if (priv->iw_mode == IW_MODE_ADHOC
4538                     || (priv->curr_bss
4539                         && !compare_ether_addr(mgmt->addr3,
4540                                                priv->curr_bss->bssid)))
4541                         at76_update_wstats(priv, buf);
4542         }
4543
4544         at76_dbg(DBG_RX_MGMT_CONTENT, "%s rx mgmt framectl 0x%x %s",
4545                  priv->netdev->name, framectl,
4546                  hex2str(mgmt, le16_to_cpu(buf->wlength)));
4547
4548         switch (framectl & IEEE80211_FCTL_STYPE) {
4549         case IEEE80211_STYPE_BEACON:
4550         case IEEE80211_STYPE_PROBE_RESP:
4551                 at76_rx_mgmt_beacon(priv, buf);
4552                 break;
4553
4554         case IEEE80211_STYPE_ASSOC_RESP:
4555                 at76_rx_mgmt_assoc(priv, buf);
4556                 break;
4557
4558         case IEEE80211_STYPE_DISASSOC:
4559                 at76_rx_mgmt_disassoc(priv, buf);
4560                 break;
4561
4562         case IEEE80211_STYPE_AUTH:
4563                 at76_rx_mgmt_auth(priv, buf);
4564                 break;
4565
4566         case IEEE80211_STYPE_DEAUTH:
4567                 at76_rx_mgmt_deauth(priv, buf);
4568                 break;
4569
4570         default:
4571                 printk(KERN_DEBUG "%s: ignoring frame with framectl 0x%04x\n",
4572                        priv->netdev->name, framectl);
4573         }
4574
4575         return;
4576 }
4577
4578 /* Convert the 802.11 header into an ethernet-style header, make skb
4579  * ready for consumption by netif_rx() */
4580 static void at76_ieee80211_to_eth(struct sk_buff *skb, int iw_mode)
4581 {
4582         struct ieee80211_hdr_3addr *i802_11_hdr;
4583         struct ethhdr *eth_hdr_p;
4584         u8 *src_addr;
4585         u8 *dest_addr;
4586
4587         i802_11_hdr = (struct ieee80211_hdr_3addr *)skb->data;
4588
4589         /* That would be the ethernet header if the hardware converted
4590          * the frame for us.  Make sure the source and the destination
4591          * match the 802.11 header.  Which hardware does it? */
4592         eth_hdr_p = (struct ethhdr *)skb_pull(skb, IEEE80211_3ADDR_LEN);
4593
4594         dest_addr = i802_11_hdr->addr1;
4595         if (iw_mode == IW_MODE_ADHOC)
4596                 src_addr = i802_11_hdr->addr2;
4597         else
4598                 src_addr = i802_11_hdr->addr3;
4599
4600         if (!compare_ether_addr(eth_hdr_p->h_source, src_addr) &&
4601             !compare_ether_addr(eth_hdr_p->h_dest, dest_addr))
4602                 /* Yes, we already have an ethernet header */
4603                 skb_reset_mac_header(skb);
4604         else {
4605                 u16 len;
4606
4607                 /* Need to build an ethernet header */
4608                 if (!memcmp(skb->data, snapsig, sizeof(snapsig))) {
4609                         /* SNAP frame - decapsulate, keep proto */
4610                         skb_push(skb, offsetof(struct ethhdr, h_proto) -
4611                                  sizeof(rfc1042sig));
4612                         len = 0;
4613                 } else {
4614                         /* 802.3 frame, proto is length */
4615                         len = skb->len;
4616                         skb_push(skb, ETH_HLEN);
4617                 }
4618
4619                 skb_reset_mac_header(skb);
4620                 eth_hdr_p = eth_hdr(skb);
4621                 /* This needs to be done in this order (eth_hdr_p->h_dest may
4622                  * overlap src_addr) */
4623                 memcpy(eth_hdr_p->h_source, src_addr, ETH_ALEN);
4624                 memcpy(eth_hdr_p->h_dest, dest_addr, ETH_ALEN);
4625                 if (len)
4626                         eth_hdr_p->h_proto = htons(len);
4627         }
4628
4629         skb->protocol = eth_type_trans(skb, skb->dev);
4630 }
4631
4632 /* Check for fragmented data in priv->rx_skb. If the packet was no fragment
4633    or it was the last of a fragment set a skb containing the whole packet
4634    is returned for further processing. Otherwise we get NULL and are
4635    done and the packet is either stored inside the fragment buffer
4636    or thrown away.  Every returned skb starts with the ieee802_11 header
4637    and contains _no_ FCS at the end */
4638 static struct sk_buff *at76_check_for_rx_frags(struct at76_priv *priv)
4639 {
4640         struct sk_buff *skb = priv->rx_skb;
4641         struct at76_rx_buffer *buf = (struct at76_rx_buffer *)skb->data;
4642         struct ieee80211_hdr_3addr *i802_11_hdr =
4643             (struct ieee80211_hdr_3addr *)buf->packet;
4644         /* seq_ctrl, fragment_number, sequence number of new packet */
4645         u16 sctl = le16_to_cpu(i802_11_hdr->seq_ctl);
4646         u16 fragnr = sctl & 0xf;
4647         u16 seqnr = sctl >> 4;
4648         u16 frame_ctl = le16_to_cpu(i802_11_hdr->frame_ctl);
4649
4650         /* Length including the IEEE802.11 header, but without the trailing
4651          * FCS and without the Atmel Rx header */
4652         int length = le16_to_cpu(buf->wlength) - IEEE80211_FCS_LEN;
4653
4654         /* where does the data payload start in skb->data ? */
4655         u8 *data = i802_11_hdr->payload;
4656
4657         /* length of payload, excl. the trailing FCS */
4658         int data_len = length - IEEE80211_3ADDR_LEN;
4659
4660         int i;
4661         struct rx_data_buf *bptr, *optr;
4662         unsigned long oldest = ~0UL;
4663
4664         at76_dbg(DBG_RX_FRAGS,
4665                  "%s: rx data frame_ctl %04x addr2 %pM seq/frag %d/%d "
4666                  "length %d data %d: %s ...", priv->netdev->name, frame_ctl,
4667                  i802_11_hdr->addr2, seqnr, fragnr, length, data_len,
4668                  hex2str(data, 32));
4669
4670         at76_dbg(DBG_RX_FRAGS_SKB, "%s: incoming skb: head %p data %p "
4671                  "tail %p end %p len %d", priv->netdev->name, skb->head,
4672                  skb->data, skb_tail_pointer(skb), skb_end_pointer(skb),
4673                  skb->len);
4674
4675         if (data_len < 0) {
4676                 /* make sure data starts in the buffer */
4677                 printk(KERN_INFO "%s: data frame too short\n",
4678                        priv->netdev->name);
4679                 return NULL;
4680         }
4681
4682         WARN_ON(length <= AT76_RX_HDRLEN);
4683         if (length <= AT76_RX_HDRLEN)
4684                 return NULL;
4685
4686         /* remove the at76_rx_buffer header - we don't need it anymore */
4687         /* we need the IEEE802.11 header (for the addresses) if this packet
4688            is the first of a chain */
4689         skb_pull(skb, AT76_RX_HDRLEN);
4690
4691         /* remove FCS at end */
4692         skb_trim(skb, length);
4693
4694         at76_dbg(DBG_RX_FRAGS_SKB, "%s: trimmed skb: head %p data %p tail %p "
4695                  "end %p len %d data %p data_len %d", priv->netdev->name,
4696                  skb->head, skb->data, skb_tail_pointer(skb),
4697                  skb_end_pointer(skb), skb->len, data, data_len);
4698
4699         if (fragnr == 0 && !(frame_ctl & IEEE80211_FCTL_MOREFRAGS)) {
4700                 /* unfragmented packet received */
4701                 /* Use a new skb for the next receive */
4702                 priv->rx_skb = NULL;
4703                 at76_dbg(DBG_RX_FRAGS, "%s: unfragmented", priv->netdev->name);
4704                 return skb;
4705         }
4706
4707         /* look if we've got a chain for the sender address.
4708            afterwards optr points to first free or the oldest entry,
4709            or, if i < NR_RX_DATA_BUF, bptr points to the entry for the
4710            sender address */
4711         /* determining the oldest entry doesn't cope with jiffies wrapping
4712            but I don't care to delete a young entry at these rare moments ... */
4713
4714         bptr = priv->rx_data;
4715         optr = NULL;
4716         for (i = 0; i < NR_RX_DATA_BUF; i++, bptr++) {
4717                 if (!bptr->skb) {
4718                         optr = bptr;
4719                         oldest = 0UL;
4720                         continue;
4721                 }
4722
4723                 if (!compare_ether_addr(i802_11_hdr->addr2, bptr->sender))
4724                         break;
4725
4726                 if (!optr) {
4727                         optr = bptr;
4728                         oldest = bptr->last_rx;
4729                 } else if (bptr->last_rx < oldest)
4730                         optr = bptr;
4731         }
4732
4733         if (i < NR_RX_DATA_BUF) {
4734
4735                 at76_dbg(DBG_RX_FRAGS, "%s: %d. cacheentry (seq/frag = %d/%d) "
4736                          "matched sender addr",
4737                          priv->netdev->name, i, bptr->seqnr, bptr->fragnr);
4738
4739                 /* bptr points to an entry for the sender address */
4740                 if (bptr->seqnr == seqnr) {
4741                         int left;
4742                         /* the fragment has the current sequence number */
4743                         if (((bptr->fragnr + 1) & 0xf) != fragnr) {
4744                                 /* wrong fragment number -> ignore it */
4745                                 /* is & 0xf necessary above ??? */
4746                                 at76_dbg(DBG_RX_FRAGS,
4747                                          "%s: frag nr mismatch: %d + 1 != %d",
4748                                          priv->netdev->name, bptr->fragnr,
4749                                          fragnr);
4750                                 return NULL;
4751                         }
4752                         bptr->last_rx = jiffies;
4753                         /* the next following fragment number ->
4754                            add the data at the end */
4755
4756                         /* for test only ??? */
4757                         left = skb_tailroom(bptr->skb);
4758                         if (left < data_len)
4759                                 printk(KERN_INFO
4760                                        "%s: only %d byte free (need %d)\n",
4761                                        priv->netdev->name, left, data_len);
4762                         else
4763                                 memcpy(skb_put(bptr->skb, data_len), data,
4764                                        data_len);
4765
4766                         bptr->fragnr = fragnr;
4767                         if (frame_ctl & IEEE80211_FCTL_MOREFRAGS)
4768                                 return NULL;
4769
4770                         /* this was the last fragment - send it */
4771                         skb = bptr->skb;
4772                         bptr->skb = NULL;       /* free the entry */
4773                         at76_dbg(DBG_RX_FRAGS, "%s: last frag of seq %d",
4774                                  priv->netdev->name, seqnr);
4775                         return skb;
4776                 }
4777
4778                 /* got another sequence number */
4779                 if (fragnr == 0) {
4780                         /* it's the start of a new chain - replace the
4781                            old one by this */
4782                         /* bptr->sender has the correct value already */
4783                         at76_dbg(DBG_RX_FRAGS,
4784                                  "%s: start of new seq %d, removing old seq %d",
4785                                  priv->netdev->name, seqnr, bptr->seqnr);
4786                         bptr->seqnr = seqnr;
4787                         bptr->fragnr = 0;
4788                         bptr->last_rx = jiffies;
4789                         /* swap bptr->skb and priv->rx_skb */
4790                         skb = bptr->skb;
4791                         bptr->skb = priv->rx_skb;
4792                         priv->rx_skb = skb;
4793                 } else {
4794                         /* it from the middle of a new chain ->
4795                            delete the old entry and skip the new one */
4796                         at76_dbg(DBG_RX_FRAGS,
4797                                  "%s: middle of new seq %d (%d) "
4798                                  "removing old seq %d",
4799                                  priv->netdev->name, seqnr, fragnr,
4800                                  bptr->seqnr);
4801                         dev_kfree_skb(bptr->skb);
4802                         bptr->skb = NULL;
4803                 }
4804                 return NULL;
4805         }
4806
4807         /* if we didn't find a chain for the sender address, optr
4808            points either to the first free or the oldest entry */
4809
4810         if (fragnr != 0) {
4811                 /* this is not the begin of a fragment chain ... */
4812                 at76_dbg(DBG_RX_FRAGS,
4813                          "%s: no chain for non-first fragment (%d)",
4814                          priv->netdev->name, fragnr);
4815                 return NULL;
4816         }
4817
4818         BUG_ON(!optr);
4819         if (optr->skb) {
4820                 /* swap the skb's */
4821                 skb = optr->skb;
4822                 optr->skb = priv->rx_skb;
4823                 priv->rx_skb = skb;
4824
4825                 at76_dbg(DBG_RX_FRAGS,
4826                          "%s: free old contents: sender %pM seq/frag %d/%d",
4827                          priv->netdev->name, optr->sender,
4828                          optr->seqnr, optr->fragnr);
4829
4830         } else {
4831                 /* take the skb from priv->rx_skb */
4832                 optr->skb = priv->rx_skb;
4833                 /* let at76_submit_rx_urb() allocate a new skb */
4834                 priv->rx_skb = NULL;
4835
4836                 at76_dbg(DBG_RX_FRAGS, "%s: use a free entry",
4837                          priv->netdev->name);
4838         }
4839         memcpy(optr->sender, i802_11_hdr->addr2, ETH_ALEN);
4840         optr->seqnr = seqnr;
4841         optr->fragnr = 0;
4842         optr->last_rx = jiffies;
4843
4844         return NULL;
4845 }
4846
4847 /* Rx interrupt: we expect the complete data buffer in priv->rx_skb */
4848 static void at76_rx_data(struct at76_priv *priv)
4849 {
4850         struct net_device *netdev = priv->netdev;
4851         struct net_device_stats *stats = &priv->stats;
4852         struct sk_buff *skb = priv->rx_skb;
4853         struct at76_rx_buffer *buf = (struct at76_rx_buffer *)skb->data;
4854         struct ieee80211_hdr_3addr *i802_11_hdr;
4855         int length = le16_to_cpu(buf->wlength);
4856
4857         at76_dbg(DBG_RX_DATA, "%s received data packet: %s", netdev->name,
4858                  hex2str(skb->data, AT76_RX_HDRLEN));
4859
4860         at76_dbg(DBG_RX_DATA_CONTENT, "rx packet: %s",
4861                  hex2str(skb->data + AT76_RX_HDRLEN, length));
4862
4863         skb = at76_check_for_rx_frags(priv);
4864         if (!skb)
4865                 return;
4866
4867         /* Atmel header and the FCS are already removed */
4868         i802_11_hdr = (struct ieee80211_hdr_3addr *)skb->data;
4869
4870         skb->dev = netdev;
4871         skb->ip_summed = CHECKSUM_NONE; /* TODO: should check CRC */
4872
4873         if (is_broadcast_ether_addr(i802_11_hdr->addr1)) {
4874                 if (!compare_ether_addr(i802_11_hdr->addr1, netdev->broadcast))
4875                         skb->pkt_type = PACKET_BROADCAST;
4876                 else
4877                         skb->pkt_type = PACKET_MULTICAST;
4878         } else if (compare_ether_addr(i802_11_hdr->addr1, netdev->dev_addr))
4879                 skb->pkt_type = PACKET_OTHERHOST;
4880
4881         at76_ieee80211_to_eth(skb, priv->iw_mode);
4882
4883         netdev->last_rx = jiffies;
4884         netif_rx(skb);
4885         stats->rx_packets++;
4886         stats->rx_bytes += length;
4887
4888         return;
4889 }
4890
4891 static void at76_rx_monitor_mode(struct at76_priv *priv)
4892 {
4893         struct at76_rx_radiotap *rt;
4894         u8 *payload;
4895         int skblen;
4896         struct net_device *netdev = priv->netdev;
4897         struct at76_rx_buffer *buf =
4898             (struct at76_rx_buffer *)priv->rx_skb->data;
4899         /* length including the IEEE802.11 header and the trailing FCS,
4900            but not at76_rx_buffer */
4901         int length = le16_to_cpu(buf->wlength);
4902         struct sk_buff *skb = priv->rx_skb;
4903         struct net_device_stats *stats = &priv->stats;
4904
4905         if (length < IEEE80211_FCS_LEN) {
4906                 /* buffer contains no data */
4907                 at76_dbg(DBG_MONITOR_MODE,
4908                          "%s: MONITOR MODE: rx skb without data",
4909                          priv->netdev->name);
4910                 return;
4911         }
4912
4913         skblen = sizeof(struct at76_rx_radiotap) + length;
4914
4915         skb = dev_alloc_skb(skblen);
4916         if (!skb) {
4917                 printk(KERN_ERR "%s: MONITOR MODE: dev_alloc_skb for radiotap "
4918                        "header returned NULL\n", priv->netdev->name);
4919                 return;
4920         }
4921
4922         skb_put(skb, skblen);
4923
4924         rt = (struct at76_rx_radiotap *)skb->data;
4925         payload = skb->data + sizeof(struct at76_rx_radiotap);
4926
4927         rt->rt_hdr.it_version = 0;
4928         rt->rt_hdr.it_pad = 0;
4929         rt->rt_hdr.it_len = cpu_to_le16(sizeof(struct at76_rx_radiotap));
4930         rt->rt_hdr.it_present = cpu_to_le32(AT76_RX_RADIOTAP_PRESENT);
4931
4932         rt->rt_tsft = cpu_to_le64(le32_to_cpu(buf->rx_time));
4933         rt->rt_rate = hw_rates[buf->rx_rate] & (~0x80);
4934         rt->rt_signal = buf->rssi;
4935         rt->rt_noise = buf->noise_level;
4936         rt->rt_flags = IEEE80211_RADIOTAP_F_FCS;
4937         if (buf->fragmentation)
4938                 rt->rt_flags |= IEEE80211_RADIOTAP_F_FRAG;
4939
4940         memcpy(payload, buf->packet, length);
4941         skb->dev = netdev;
4942         skb->ip_summed = CHECKSUM_NONE;
4943         skb_reset_mac_header(skb);
4944         skb->pkt_type = PACKET_OTHERHOST;
4945         skb->protocol = htons(ETH_P_802_2);
4946
4947         netdev->last_rx = jiffies;
4948         netif_rx(skb);
4949         stats->rx_packets++;
4950         stats->rx_bytes += length;
4951 }
4952
4953 /* Check if we spy on the sender address in buf and update stats */
4954 static void at76_iwspy_update(struct at76_priv *priv,
4955                               struct at76_rx_buffer *buf)
4956 {
4957         struct ieee80211_hdr_3addr *hdr =
4958             (struct ieee80211_hdr_3addr *)buf->packet;
4959         struct iw_quality qual;
4960
4961         /* We can only set the level here */
4962         qual.updated = IW_QUAL_QUAL_INVALID | IW_QUAL_NOISE_INVALID;
4963         qual.level = 0;
4964         qual.noise = 0;
4965         at76_calc_level(priv, buf, &qual);
4966
4967         spin_lock_bh(&priv->spy_spinlock);
4968
4969         if (priv->spy_data.spy_number > 0)
4970                 wireless_spy_update(priv->netdev, hdr->addr2, &qual);
4971
4972         spin_unlock_bh(&priv->spy_spinlock);
4973 }
4974
4975 static void at76_rx_tasklet(unsigned long param)
4976 {
4977         struct urb *urb = (struct urb *)param;
4978         struct at76_priv *priv = urb->context;
4979         struct net_device *netdev = priv->netdev;
4980         struct at76_rx_buffer *buf;
4981         struct ieee80211_hdr_3addr *i802_11_hdr;
4982         u16 frame_ctl;
4983
4984         if (priv->device_unplugged) {
4985                 at76_dbg(DBG_DEVSTART, "device unplugged");
4986                 if (urb)
4987                         at76_dbg(DBG_DEVSTART, "urb status %d", urb->status);
4988                 return;
4989         }
4990
4991         if (!priv->rx_skb || !netdev || !priv->rx_skb->data)
4992                 return;
4993
4994         buf = (struct at76_rx_buffer *)priv->rx_skb->data;
4995
4996         i802_11_hdr = (struct ieee80211_hdr_3addr *)buf->packet;
4997
4998         frame_ctl = le16_to_cpu(i802_11_hdr->frame_ctl);
4999
5000         if (urb->status != 0) {
5001                 if (urb->status != -ENOENT && urb->status != -ECONNRESET)
5002                         at76_dbg(DBG_URB,
5003                                  "%s %s: - nonzero Rx bulk status received: %d",
5004                                  __func__, netdev->name, urb->status);
5005                 return;
5006         }
5007
5008         at76_dbg(DBG_RX_ATMEL_HDR,
5009                  "%s: rx frame: rate %d rssi %d noise %d link %d %s",
5010                  priv->netdev->name, buf->rx_rate, buf->rssi, buf->noise_level,
5011                  buf->link_quality, hex2str(i802_11_hdr, 48));
5012         if (priv->iw_mode == IW_MODE_MONITOR) {
5013                 at76_rx_monitor_mode(priv);
5014                 goto exit;
5015         }
5016
5017         /* there is a new bssid around, accept it: */
5018         if (buf->newbss && priv->iw_mode == IW_MODE_ADHOC) {
5019                 at76_dbg(DBG_PROGRESS, "%s: rx newbss", netdev->name);
5020                 schedule_work(&priv->work_new_bss);
5021         }
5022
5023         switch (frame_ctl & IEEE80211_FCTL_FTYPE) {
5024         case IEEE80211_FTYPE_DATA:
5025                 at76_rx_data(priv);
5026                 break;
5027
5028         case IEEE80211_FTYPE_MGMT:
5029                 /* jal: TODO: find out if we can update iwspy also on
5030                    other frames than management (might depend on the
5031                    radio chip / firmware version !) */
5032
5033                 at76_iwspy_update(priv, buf);
5034
5035                 at76_rx_mgmt(priv, buf);
5036                 break;
5037
5038         case IEEE80211_FTYPE_CTL:
5039                 at76_dbg(DBG_RX_CTRL, "%s: ignored ctrl frame: %04x",
5040                          priv->netdev->name, frame_ctl);
5041                 break;
5042
5043         default:
5044                 printk(KERN_DEBUG "%s: ignoring frame with framectl 0x%04x\n",
5045                        priv->netdev->name, frame_ctl);
5046         }
5047 exit:
5048         at76_submit_rx_urb(priv);
5049 }
5050
5051 /* Load firmware into kernel memory and parse it */
5052 static struct fwentry *at76_load_firmware(struct usb_device *udev,
5053                                           enum board_type board_type)
5054 {
5055         int ret;
5056         char *str;
5057         struct at76_fw_header *fwh;
5058         struct fwentry *fwe = &firmwares[board_type];
5059
5060         mutex_lock(&fw_mutex);
5061
5062         if (fwe->loaded) {
5063                 at76_dbg(DBG_FW, "re-using previously loaded fw");
5064                 goto exit;
5065         }
5066
5067         at76_dbg(DBG_FW, "downloading firmware %s", fwe->fwname);
5068         ret = request_firmware(&fwe->fw, fwe->fwname, &udev->dev);
5069         if (ret < 0) {
5070                 dev_printk(KERN_ERR, &udev->dev, "firmware %s not found!\n",
5071                            fwe->fwname);
5072                 dev_printk(KERN_ERR, &udev->dev,
5073                            "you may need to download the firmware from "
5074                            "http://developer.berlios.de/projects/at76c503a/");
5075                 goto exit;
5076         }
5077
5078         at76_dbg(DBG_FW, "got it.");
5079         fwh = (struct at76_fw_header *)(fwe->fw->data);
5080
5081         if (fwe->fw->size <= sizeof(*fwh)) {
5082                 dev_printk(KERN_ERR, &udev->dev,
5083                            "firmware is too short (0x%zx)\n", fwe->fw->size);
5084                 goto exit;
5085         }
5086
5087         /* CRC currently not checked */
5088         fwe->board_type = le32_to_cpu(fwh->board_type);
5089         if (fwe->board_type != board_type) {
5090                 dev_printk(KERN_ERR, &udev->dev,
5091                            "board type mismatch, requested %u, got %u\n",
5092                            board_type, fwe->board_type);
5093                 goto exit;
5094         }
5095
5096         fwe->fw_version.major = fwh->major;
5097         fwe->fw_version.minor = fwh->minor;
5098         fwe->fw_version.patch = fwh->patch;
5099         fwe->fw_version.build = fwh->build;
5100
5101         str = (char *)fwh + le32_to_cpu(fwh->str_offset);
5102         fwe->intfw = (u8 *)fwh + le32_to_cpu(fwh->int_fw_offset);
5103         fwe->intfw_size = le32_to_cpu(fwh->int_fw_len);
5104         fwe->extfw = (u8 *)fwh + le32_to_cpu(fwh->ext_fw_offset);
5105         fwe->extfw_size = le32_to_cpu(fwh->ext_fw_len);
5106
5107         fwe->loaded = 1;
5108
5109         dev_printk(KERN_DEBUG, &udev->dev,
5110                    "using firmware %s (version %d.%d.%d-%d)\n",
5111                    fwe->fwname, fwh->major, fwh->minor, fwh->patch, fwh->build);
5112
5113         at76_dbg(DBG_DEVSTART, "board %u, int %d:%d, ext %d:%d", board_type,
5114                  le32_to_cpu(fwh->int_fw_offset), le32_to_cpu(fwh->int_fw_len),
5115                  le32_to_cpu(fwh->ext_fw_offset), le32_to_cpu(fwh->ext_fw_len));
5116         at76_dbg(DBG_DEVSTART, "firmware id %s", str);
5117
5118 exit:
5119         mutex_unlock(&fw_mutex);
5120
5121         if (fwe->loaded)
5122                 return fwe;
5123         else
5124                 return NULL;
5125 }
5126
5127 /* Allocate network device and initialize private data */
5128 static struct at76_priv *at76_alloc_new_device(struct usb_device *udev)
5129 {
5130         struct net_device *netdev;
5131         struct at76_priv *priv;
5132         int i;
5133
5134         /* allocate memory for our device state and initialize it */
5135         netdev = alloc_etherdev(sizeof(struct at76_priv));
5136         if (!netdev) {
5137                 dev_printk(KERN_ERR, &udev->dev, "out of memory\n");
5138                 return NULL;
5139         }
5140
5141         priv = netdev_priv(netdev);
5142
5143         priv->udev = udev;
5144         priv->netdev = netdev;
5145
5146         mutex_init(&priv->mtx);
5147         INIT_WORK(&priv->work_assoc_done, at76_work_assoc_done);
5148         INIT_WORK(&priv->work_join, at76_work_join);
5149         INIT_WORK(&priv->work_new_bss, at76_work_new_bss);
5150         INIT_WORK(&priv->work_start_scan, at76_work_start_scan);
5151         INIT_WORK(&priv->work_set_promisc, at76_work_set_promisc);
5152         INIT_WORK(&priv->work_submit_rx, at76_work_submit_rx);
5153         INIT_DELAYED_WORK(&priv->dwork_restart, at76_dwork_restart);
5154         INIT_DELAYED_WORK(&priv->dwork_get_scan, at76_dwork_get_scan);
5155         INIT_DELAYED_WORK(&priv->dwork_beacon, at76_dwork_beacon);
5156         INIT_DELAYED_WORK(&priv->dwork_auth, at76_dwork_auth);
5157         INIT_DELAYED_WORK(&priv->dwork_assoc, at76_dwork_assoc);
5158
5159         spin_lock_init(&priv->mgmt_spinlock);
5160         priv->next_mgmt_bulk = NULL;
5161         priv->mac_state = MAC_INIT;
5162
5163         /* initialize empty BSS list */
5164         priv->curr_bss = NULL;
5165         INIT_LIST_HEAD(&priv->bss_list);
5166         spin_lock_init(&priv->bss_list_spinlock);
5167
5168         init_timer(&priv->bss_list_timer);
5169         priv->bss_list_timer.data = (unsigned long)priv;
5170         priv->bss_list_timer.function = at76_bss_list_timeout;
5171
5172         spin_lock_init(&priv->spy_spinlock);
5173
5174         /* mark all rx data entries as unused */
5175         for (i = 0; i < NR_RX_DATA_BUF; i++)
5176                 priv->rx_data[i].skb = NULL;
5177
5178         priv->rx_tasklet.func = at76_rx_tasklet;
5179         priv->rx_tasklet.data = 0;
5180
5181         priv->pm_mode = AT76_PM_OFF;
5182         priv->pm_period = 0;
5183
5184         return priv;
5185 }
5186
5187 static int at76_alloc_urbs(struct at76_priv *priv,
5188                            struct usb_interface *interface)
5189 {
5190         struct usb_endpoint_descriptor *endpoint, *ep_in, *ep_out;
5191         int i;
5192         int buffer_size;
5193         struct usb_host_interface *iface_desc;
5194
5195         at76_dbg(DBG_PROC_ENTRY, "%s: ENTER", __func__);
5196
5197         at76_dbg(DBG_URB, "%s: NumEndpoints %d ", __func__,
5198                  interface->altsetting[0].desc.bNumEndpoints);
5199
5200         ep_in = NULL;
5201         ep_out = NULL;
5202         iface_desc = interface->cur_altsetting;
5203         for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
5204                 endpoint = &iface_desc->endpoint[i].desc;
5205
5206                 at76_dbg(DBG_URB, "%s: %d. endpoint: addr 0x%x attr 0x%x",
5207                          __func__, i, endpoint->bEndpointAddress,
5208                          endpoint->bmAttributes);
5209
5210                 if (!ep_in && usb_endpoint_is_bulk_in(endpoint))
5211                         ep_in = endpoint;
5212
5213                 if (!ep_out && usb_endpoint_is_bulk_out(endpoint))
5214                         ep_out = endpoint;
5215         }
5216
5217         if (!ep_in || !ep_out) {
5218                 dev_printk(KERN_ERR, &interface->dev,
5219                            "bulk endpoints missing\n");
5220                 return -ENXIO;
5221         }
5222
5223         priv->rx_pipe = usb_rcvbulkpipe(priv->udev, ep_in->bEndpointAddress);
5224         priv->tx_pipe = usb_sndbulkpipe(priv->udev, ep_out->bEndpointAddress);
5225
5226         priv->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
5227         priv->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
5228         if (!priv->rx_urb || !priv->tx_urb) {
5229                 dev_printk(KERN_ERR, &interface->dev, "cannot allocate URB\n");
5230                 return -ENOMEM;
5231         }
5232
5233         buffer_size = sizeof(struct at76_tx_buffer) + MAX_PADDING_SIZE;
5234         priv->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
5235         if (!priv->bulk_out_buffer) {
5236                 dev_printk(KERN_ERR, &interface->dev,
5237                            "cannot allocate output buffer\n");
5238                 return -ENOMEM;
5239         }
5240
5241         at76_dbg(DBG_PROC_ENTRY, "%s: EXIT", __func__);
5242
5243         return 0;
5244 }
5245
5246 static const struct net_device_ops at76_netdev_ops = {
5247         .ndo_open               = at76_open,
5248         .ndo_stop               = at76_stop,
5249         .ndo_get_stats          = at76_get_stats,
5250         .ndo_start_xmit         = at76_tx,
5251         .ndo_tx_timeout         = at76_tx_timeout,
5252         .ndo_set_multicast_list = at76_set_multicast,
5253         .ndo_set_mac_address    = at76_set_mac_address,
5254         .ndo_validate_addr      = eth_validate_addr,
5255         .ndo_change_mtu         = eth_change_mtu,
5256 };
5257
5258 /* Register network device and initialize the hardware */
5259 static int at76_init_new_device(struct at76_priv *priv,
5260                                 struct usb_interface *interface)
5261 {
5262         struct net_device *netdev = priv->netdev;
5263         int ret;
5264
5265         /* set up the endpoint information */
5266         /* check out the endpoints */
5267
5268         at76_dbg(DBG_DEVSTART, "USB interface: %d endpoints",
5269                  interface->cur_altsetting->desc.bNumEndpoints);
5270
5271         ret = at76_alloc_urbs(priv, interface);
5272         if (ret < 0)
5273                 goto exit;
5274
5275         /* MAC address */
5276         ret = at76_get_hw_config(priv);
5277         if (ret < 0) {
5278                 dev_printk(KERN_ERR, &interface->dev,
5279                            "cannot get MAC address\n");
5280                 goto exit;
5281         }
5282
5283         priv->domain = at76_get_reg_domain(priv->regulatory_domain);
5284         /* init. netdev->dev_addr */
5285         memcpy(netdev->dev_addr, priv->mac_addr, ETH_ALEN);
5286
5287         priv->channel = DEF_CHANNEL;
5288         priv->iw_mode = IW_MODE_INFRA;
5289         priv->rts_threshold = DEF_RTS_THRESHOLD;
5290         priv->frag_threshold = DEF_FRAG_THRESHOLD;
5291         priv->short_retry_limit = DEF_SHORT_RETRY_LIMIT;
5292         priv->txrate = TX_RATE_AUTO;
5293         priv->preamble_type = PREAMBLE_TYPE_LONG;
5294         priv->beacon_period = 100;
5295         priv->beacons_last_qual = jiffies;
5296         priv->auth_mode = WLAN_AUTH_OPEN;
5297         priv->scan_min_time = DEF_SCAN_MIN_TIME;
5298         priv->scan_max_time = DEF_SCAN_MAX_TIME;
5299         priv->scan_mode = SCAN_TYPE_ACTIVE;
5300
5301         netdev->flags &= ~IFF_MULTICAST;        /* not yet or never */
5302         netdev->netdev_ops = &at76_netdev_ops;
5303         netdev->ethtool_ops = &at76_ethtool_ops;
5304
5305         /* Add pointers to enable iwspy support. */
5306         priv->wireless_data.spy_data = &priv->spy_data;
5307 #ifdef CONFIG_WIRELESS_EXT
5308         netdev->wireless_data = &priv->wireless_data;
5309         netdev->wireless_handlers = &at76_handler_def;
5310 #endif
5311
5312         netdev->watchdog_timeo = 2 * HZ;
5313         dev_alloc_name(netdev, "wlan%d");
5314
5315         ret = register_netdev(priv->netdev);
5316         if (ret) {
5317                 dev_printk(KERN_ERR, &interface->dev,
5318                            "cannot register netdevice (status %d)!\n", ret);
5319                 goto exit;
5320         }
5321         priv->netdev_registered = 1;
5322
5323         printk(KERN_INFO "%s: USB %s, MAC %pM, firmware %d.%d.%d-%d\n",
5324                netdev->name, dev_name(&interface->dev), priv->mac_addr,
5325                priv->fw_version.major, priv->fw_version.minor,
5326                priv->fw_version.patch, priv->fw_version.build);
5327         printk(KERN_INFO "%s: regulatory domain 0x%02x: %s\n", netdev->name,
5328                priv->regulatory_domain, priv->domain->name);
5329
5330         /* we let this timer run the whole time this driver instance lives */
5331         mod_timer(&priv->bss_list_timer, jiffies + BSS_LIST_TIMEOUT);
5332
5333 exit:
5334         return ret;
5335 }
5336
5337 static void at76_delete_device(struct at76_priv *priv)
5338 {
5339         int i;
5340
5341         at76_dbg(DBG_PROC_ENTRY, "%s: ENTER", __func__);
5342
5343         /* The device is gone, don't bother turning it off */
5344         priv->device_unplugged = 1;
5345
5346         if (priv->netdev_registered)
5347                 unregister_netdev(priv->netdev);
5348
5349         /* assuming we used keventd, it must quiesce too */
5350         flush_scheduled_work();
5351
5352         kfree(priv->bulk_out_buffer);
5353
5354         if (priv->tx_urb) {
5355                 usb_kill_urb(priv->tx_urb);
5356                 usb_free_urb(priv->tx_urb);
5357         }
5358         if (priv->rx_urb) {
5359                 usb_kill_urb(priv->rx_urb);
5360                 usb_free_urb(priv->rx_urb);
5361         }
5362
5363         at76_dbg(DBG_PROC_ENTRY, "%s: unlinked urbs", __func__);
5364
5365         kfree_skb(priv->rx_skb);
5366
5367         at76_free_bss_list(priv);
5368         del_timer_sync(&priv->bss_list_timer);
5369         cancel_delayed_work(&priv->dwork_get_scan);
5370         cancel_delayed_work(&priv->dwork_beacon);
5371         cancel_delayed_work(&priv->dwork_auth);
5372         cancel_delayed_work(&priv->dwork_assoc);
5373
5374         if (priv->mac_state == MAC_CONNECTED)
5375                 at76_iwevent_bss_disconnect(priv->netdev);
5376
5377         for (i = 0; i < NR_RX_DATA_BUF; i++)
5378                 if (priv->rx_data[i].skb) {
5379                         dev_kfree_skb(priv->rx_data[i].skb);
5380                         priv->rx_data[i].skb = NULL;
5381                 }
5382         usb_put_dev(priv->udev);
5383
5384         at76_dbg(DBG_PROC_ENTRY, "%s: before freeing priv/netdev", __func__);
5385         free_netdev(priv->netdev);      /* priv is in netdev */
5386
5387         at76_dbg(DBG_PROC_ENTRY, "%s: EXIT", __func__);
5388 }
5389
5390 static int at76_probe(struct usb_interface *interface,
5391                       const struct usb_device_id *id)
5392 {
5393         int ret;
5394         struct at76_priv *priv;
5395         struct fwentry *fwe;
5396         struct usb_device *udev;
5397         int op_mode;
5398         int need_ext_fw = 0;
5399         struct mib_fw_version fwv;
5400         int board_type = (int)id->driver_info;
5401
5402         udev = usb_get_dev(interface_to_usbdev(interface));
5403
5404         /* Load firmware into kernel memory */
5405         fwe = at76_load_firmware(udev, board_type);
5406         if (!fwe) {
5407                 ret = -ENOENT;
5408                 goto error;
5409         }
5410
5411         op_mode = at76_get_op_mode(udev);
5412
5413         at76_dbg(DBG_DEVSTART, "opmode %d", op_mode);
5414
5415         /* we get OPMODE_NONE with 2.4.23, SMC2662W-AR ???
5416            we get 204 with 2.4.23, Fiberline FL-WL240u (505A+RFMD2958) ??? */
5417
5418         if (op_mode == OPMODE_HW_CONFIG_MODE) {
5419                 dev_printk(KERN_ERR, &interface->dev,
5420                            "cannot handle a device in HW_CONFIG_MODE\n");
5421                 ret = -EBUSY;
5422                 goto error;
5423         }
5424
5425         if (op_mode != OPMODE_NORMAL_NIC_WITH_FLASH
5426             && op_mode != OPMODE_NORMAL_NIC_WITHOUT_FLASH) {
5427                 /* download internal firmware part */
5428                 dev_printk(KERN_DEBUG, &interface->dev,
5429                            "downloading internal firmware\n");
5430                 ret = at76_load_internal_fw(udev, fwe);
5431                 if (ret < 0) {
5432                         dev_printk(KERN_ERR, &interface->dev,
5433                                    "error %d downloading internal firmware\n",
5434                                    ret);
5435                         goto error;
5436                 }
5437                 usb_put_dev(udev);
5438                 return ret;
5439         }
5440
5441         /* Internal firmware already inside the device.  Get firmware
5442          * version to test if external firmware is loaded.
5443          * This works only for newer firmware, e.g. the Intersil 0.90.x
5444          * says "control timeout on ep0in" and subsequent
5445          * at76_get_op_mode() fail too :-( */
5446
5447         /* if version >= 0.100.x.y or device with built-in flash we can
5448          * query the device for the fw version */
5449         if ((fwe->fw_version.major > 0 || fwe->fw_version.minor >= 100)
5450             || (op_mode == OPMODE_NORMAL_NIC_WITH_FLASH)) {
5451                 ret = at76_get_mib(udev, MIB_FW_VERSION, &fwv, sizeof(fwv));
5452                 if (ret < 0 || (fwv.major | fwv.minor) == 0)
5453                         need_ext_fw = 1;
5454         } else
5455                 /* No way to check firmware version, reload to be sure */
5456                 need_ext_fw = 1;
5457
5458         if (need_ext_fw) {
5459                 dev_printk(KERN_DEBUG, &interface->dev,
5460                            "downloading external firmware\n");
5461
5462                 ret = at76_load_external_fw(udev, fwe);
5463                 if (ret)
5464                         goto error;
5465
5466                 /* Re-check firmware version */
5467                 ret = at76_get_mib(udev, MIB_FW_VERSION, &fwv, sizeof(fwv));
5468                 if (ret < 0) {
5469                         dev_printk(KERN_ERR, &interface->dev,
5470                                    "error %d getting firmware version\n", ret);
5471                         goto error;
5472                 }
5473         }
5474
5475         priv = at76_alloc_new_device(udev);
5476         if (!priv) {
5477                 ret = -ENOMEM;
5478                 goto error;
5479         }
5480
5481         SET_NETDEV_DEV(priv->netdev, &interface->dev);
5482         usb_set_intfdata(interface, priv);
5483
5484         memcpy(&priv->fw_version, &fwv, sizeof(struct mib_fw_version));
5485         priv->board_type = board_type;
5486
5487         ret = at76_init_new_device(priv, interface);
5488         if (ret < 0)
5489                 at76_delete_device(priv);
5490
5491         return ret;
5492
5493 error:
5494         usb_put_dev(udev);
5495         return ret;
5496 }
5497
5498 static void at76_disconnect(struct usb_interface *interface)
5499 {
5500         struct at76_priv *priv;
5501
5502         priv = usb_get_intfdata(interface);
5503         usb_set_intfdata(interface, NULL);
5504
5505         /* Disconnect after loading internal firmware */
5506         if (!priv)
5507                 return;
5508
5509         printk(KERN_INFO "%s: disconnecting\n", priv->netdev->name);
5510         at76_delete_device(priv);
5511         dev_printk(KERN_INFO, &interface->dev, "disconnected\n");
5512 }
5513
5514 /* Structure for registering this driver with the USB subsystem */
5515 static struct usb_driver at76_driver = {
5516         .name = DRIVER_NAME,
5517         .probe = at76_probe,
5518         .disconnect = at76_disconnect,
5519         .id_table = dev_table,
5520 };
5521
5522 static int __init at76_mod_init(void)
5523 {
5524         int result;
5525
5526         printk(KERN_INFO DRIVER_DESC " " DRIVER_VERSION " loading\n");
5527
5528         mutex_init(&fw_mutex);
5529
5530         /* register this driver with the USB subsystem */
5531         result = usb_register(&at76_driver);
5532         if (result < 0)
5533                 printk(KERN_ERR DRIVER_NAME
5534                        ": usb_register failed (status %d)\n", result);
5535
5536         led_trigger_register_simple("at76_usb-tx", &ledtrig_tx);
5537         return result;
5538 }
5539
5540 static void __exit at76_mod_exit(void)
5541 {
5542         int i;
5543
5544         printk(KERN_INFO DRIVER_DESC " " DRIVER_VERSION " unloading\n");
5545         usb_deregister(&at76_driver);
5546         for (i = 0; i < ARRAY_SIZE(firmwares); i++) {
5547                 if (firmwares[i].fw)
5548                         release_firmware(firmwares[i].fw);
5549         }
5550         led_trigger_unregister_simple(ledtrig_tx);
5551 }
5552
5553 module_param_named(debug, at76_debug, int, 0600);
5554 MODULE_PARM_DESC(debug, "Debugging level");
5555
5556 module_init(at76_mod_init);
5557 module_exit(at76_mod_exit);
5558
5559 MODULE_AUTHOR("Oliver Kurth <oku@masqmail.cx>");
5560 MODULE_AUTHOR("Joerg Albert <joerg.albert@gmx.de>");
5561 MODULE_AUTHOR("Alex <alex@foogod.com>");
5562 MODULE_AUTHOR("Nick Jones");
5563 MODULE_AUTHOR("Balint Seeber <n0_5p4m_p13453@hotmail.com>");
5564 MODULE_AUTHOR("Pavel Roskin <proski@gnu.org>");
5565 MODULE_DESCRIPTION(DRIVER_DESC);
5566 MODULE_LICENSE("GPL");