drivers/net/wireless/intel/ipw2x00/ipw2200.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /******************************************************************************
   3
   4   Copyright(c) 2003 - 2006 Intel Corporation. All rights reserved.
   5
   6   802.11 status code portion of this file from ethereal-0.10.6:
   7     Copyright 2000, Axis Communications AB
   8     Ethereal - Network traffic analyzer
   9     By Gerald Combs <[email protected]>
  10     Copyright 1998 Gerald Combs
  11
  12
  13   Contact Information:
  14   Intel Linux Wireless <[email protected]>
  15   Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  16
  17 ******************************************************************************/
  18
  19 #include <linux/sched.h>
  20 #include <linux/slab.h>
  21 #include <net/cfg80211-wext.h>
  22 #include "ipw2200.h"
  23 #include "ipw.h"
  24
  25
  26 #ifndef KBUILD_EXTMOD
  27 #define VK "k"
  28 #else
  29 #define VK
  30 #endif
  31
  32 #ifdef CONFIG_IPW2200_DEBUG
  33 #define VD "d"
  34 #else
  35 #define VD
  36 #endif
  37
  38 #ifdef CONFIG_IPW2200_MONITOR
  39 #define VM "m"
  40 #else
  41 #define VM
  42 #endif
  43
  44 #ifdef CONFIG_IPW2200_PROMISCUOUS
  45 #define VP "p"
  46 #else
  47 #define VP
  48 #endif
  49
  50 #ifdef CONFIG_IPW2200_RADIOTAP
  51 #define VR "r"
  52 #else
  53 #define VR
  54 #endif
  55
  56 #ifdef CONFIG_IPW2200_QOS
  57 #define VQ "q"
  58 #else
  59 #define VQ
  60 #endif
  61
  62 #define IPW2200_VERSION "1.2.2" VK VD VM VP VR VQ
  63 #define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2200/2915 Network Driver"
  64 #define DRV_COPYRIGHT   "Copyright(c) 2003-2006 Intel Corporation"
  65 #define DRV_VERSION     IPW2200_VERSION
  66
  67 #define ETH_P_80211_STATS (ETH_P_80211_RAW + 1)
  68
  69 MODULE_DESCRIPTION(DRV_DESCRIPTION);
  70 MODULE_VERSION(DRV_VERSION);
  71 MODULE_AUTHOR(DRV_COPYRIGHT);
  72 MODULE_LICENSE("GPL");
  73 MODULE_FIRMWARE("ipw2200-ibss.fw");
  74 #ifdef CONFIG_IPW2200_MONITOR
  75 MODULE_FIRMWARE("ipw2200-sniffer.fw");
  76 #endif
  77 MODULE_FIRMWARE("ipw2200-bss.fw");
  78
  79 static int cmdlog = 0;
  80 static int debug = 0;
  81 static int default_channel = 0;
  82 static int network_mode = 0;
  83
  84 static u32 ipw_debug_level;
  85 static int associate;
  86 static int auto_create = 1;
  87 static int led_support = 1;
  88 static int disable = 0;
  89 static int bt_coexist = 0;
  90 static int hwcrypto = 0;
  91 static int roaming = 1;
  92 static const char ipw_modes[] = {
  93         'a', 'b', 'g', '?'
  94 };
  95 static int antenna = CFG_SYS_ANTENNA_BOTH;
  96
  97 #ifdef CONFIG_IPW2200_PROMISCUOUS
  98 static int rtap_iface = 0;     /* def: 0 -- do not create rtap interface */
  99 #endif
 100
 101 static struct ieee80211_rate ipw2200_rates[] = {
 102         { .bitrate = 10 },
 103         { .bitrate = 20, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 104         { .bitrate = 55, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 105         { .bitrate = 110, .flags = IEEE80211_RATE_SHORT_PREAMBLE },
 106         { .bitrate = 60 },
 107         { .bitrate = 90 },
 108         { .bitrate = 120 },
 109         { .bitrate = 180 },
 110         { .bitrate = 240 },
 111         { .bitrate = 360 },
 112         { .bitrate = 480 },
 113         { .bitrate = 540 }
 114 };
 115
 116 #define ipw2200_a_rates         (ipw2200_rates + 4)
 117 #define ipw2200_num_a_rates     8
 118 #define ipw2200_bg_rates        (ipw2200_rates + 0)
 119 #define ipw2200_num_bg_rates    12
 120
 121 /* Ugly macro to convert literal channel numbers into their mhz equivalents
 122  * There are certianly some conditions that will break this (like feeding it '30')
 123  * but they shouldn't arise since nothing talks on channel 30. */
 124 #define ieee80211chan2mhz(x) \
 125         (((x) <= 14) ? \
 126         (((x) == 14) ? 2484 : ((x) * 5) + 2407) : \
 127         ((x) + 1000) * 5)
 128
 129 #ifdef CONFIG_IPW2200_QOS
 130 static int qos_enable = 0;
 131 static int qos_burst_enable = 0;
 132 static int qos_no_ack_mask = 0;
 133 static int burst_duration_CCK = 0;
 134 static int burst_duration_OFDM = 0;
 135
 136 static struct libipw_qos_parameters def_qos_parameters_OFDM = {
 137         {QOS_TX0_CW_MIN_OFDM, QOS_TX1_CW_MIN_OFDM, QOS_TX2_CW_MIN_OFDM,
 138          QOS_TX3_CW_MIN_OFDM},
 139         {QOS_TX0_CW_MAX_OFDM, QOS_TX1_CW_MAX_OFDM, QOS_TX2_CW_MAX_OFDM,
 140          QOS_TX3_CW_MAX_OFDM},
 141         {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
 142         {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
 143         {QOS_TX0_TXOP_LIMIT_OFDM, QOS_TX1_TXOP_LIMIT_OFDM,
 144          QOS_TX2_TXOP_LIMIT_OFDM, QOS_TX3_TXOP_LIMIT_OFDM}
 145 };
 146
 147 static struct libipw_qos_parameters def_qos_parameters_CCK = {
 148         {QOS_TX0_CW_MIN_CCK, QOS_TX1_CW_MIN_CCK, QOS_TX2_CW_MIN_CCK,
 149          QOS_TX3_CW_MIN_CCK},
 150         {QOS_TX0_CW_MAX_CCK, QOS_TX1_CW_MAX_CCK, QOS_TX2_CW_MAX_CCK,
 151          QOS_TX3_CW_MAX_CCK},
 152         {QOS_TX0_AIFS, QOS_TX1_AIFS, QOS_TX2_AIFS, QOS_TX3_AIFS},
 153         {QOS_TX0_ACM, QOS_TX1_ACM, QOS_TX2_ACM, QOS_TX3_ACM},
 154         {QOS_TX0_TXOP_LIMIT_CCK, QOS_TX1_TXOP_LIMIT_CCK, QOS_TX2_TXOP_LIMIT_CCK,
 155          QOS_TX3_TXOP_LIMIT_CCK}
 156 };
 157
 158 static struct libipw_qos_parameters def_parameters_OFDM = {
 159         {DEF_TX0_CW_MIN_OFDM, DEF_TX1_CW_MIN_OFDM, DEF_TX2_CW_MIN_OFDM,
 160          DEF_TX3_CW_MIN_OFDM},
 161         {DEF_TX0_CW_MAX_OFDM, DEF_TX1_CW_MAX_OFDM, DEF_TX2_CW_MAX_OFDM,
 162          DEF_TX3_CW_MAX_OFDM},
 163         {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
 164         {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
 165         {DEF_TX0_TXOP_LIMIT_OFDM, DEF_TX1_TXOP_LIMIT_OFDM,
 166          DEF_TX2_TXOP_LIMIT_OFDM, DEF_TX3_TXOP_LIMIT_OFDM}
 167 };
 168
 169 static struct libipw_qos_parameters def_parameters_CCK = {
 170         {DEF_TX0_CW_MIN_CCK, DEF_TX1_CW_MIN_CCK, DEF_TX2_CW_MIN_CCK,
 171          DEF_TX3_CW_MIN_CCK},
 172         {DEF_TX0_CW_MAX_CCK, DEF_TX1_CW_MAX_CCK, DEF_TX2_CW_MAX_CCK,
 173          DEF_TX3_CW_MAX_CCK},
 174         {DEF_TX0_AIFS, DEF_TX1_AIFS, DEF_TX2_AIFS, DEF_TX3_AIFS},
 175         {DEF_TX0_ACM, DEF_TX1_ACM, DEF_TX2_ACM, DEF_TX3_ACM},
 176         {DEF_TX0_TXOP_LIMIT_CCK, DEF_TX1_TXOP_LIMIT_CCK, DEF_TX2_TXOP_LIMIT_CCK,
 177          DEF_TX3_TXOP_LIMIT_CCK}
 178 };
 179
 180 static u8 qos_oui[QOS_OUI_LEN] = { 0x00, 0x50, 0xF2 };
 181
 182 static int from_priority_to_tx_queue[] = {
 183         IPW_TX_QUEUE_1, IPW_TX_QUEUE_2, IPW_TX_QUEUE_2, IPW_TX_QUEUE_1,
 184         IPW_TX_QUEUE_3, IPW_TX_QUEUE_3, IPW_TX_QUEUE_4, IPW_TX_QUEUE_4
 185 };
 186
 187 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv);
 188
 189 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct libipw_qos_parameters
 190                                        *qos_param);
 191 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct libipw_qos_information_element
 192                                      *qos_param);
 193 #endif                          /* CONFIG_IPW2200_QOS */
 194
 195 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev);
 196 static void ipw_remove_current_network(struct ipw_priv *priv);
 197 static void ipw_rx(struct ipw_priv *priv);
 198 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
 199                                 struct clx2_tx_queue *txq, int qindex);
 200 static int ipw_queue_reset(struct ipw_priv *priv);
 201
 202 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, const void *buf,
 203                              int len, int sync);
 204
 205 static void ipw_tx_queue_free(struct ipw_priv *);
 206
 207 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *);
 208 static void ipw_rx_queue_free(struct ipw_priv *, struct ipw_rx_queue *);
 209 static void ipw_rx_queue_replenish(void *);
 210 static int ipw_up(struct ipw_priv *);
 211 static void ipw_bg_up(struct work_struct *work);
 212 static void ipw_down(struct ipw_priv *);
 213 static void ipw_bg_down(struct work_struct *work);
 214 static int ipw_config(struct ipw_priv *);
 215 static int init_supported_rates(struct ipw_priv *priv,
 216                                 struct ipw_supported_rates *prates);
 217 static void ipw_set_hwcrypto_keys(struct ipw_priv *);
 218 static void ipw_send_wep_keys(struct ipw_priv *, int);
 219
 220 static int snprint_line(char *buf, size_t count,
 221                         const u8 * data, u32 len, u32 ofs)
 222 {
 223         int out, i, j, l;
 224         char c;
 225
 226         out = scnprintf(buf, count, "%08X", ofs);
 227
 228         for (l = 0, i = 0; i < 2; i++) {
 229                 out += scnprintf(buf + out, count - out, " ");
 230                 for (j = 0; j < 8 && l < len; j++, l++)
 231                         out += scnprintf(buf + out, count - out, "%02X ",
 232                                         data[(i * 8 + j)]);
 233                 for (; j < 8; j++)
 234                         out += scnprintf(buf + out, count - out, "   ");
 235         }
 236
 237         out += scnprintf(buf + out, count - out, " ");
 238         for (l = 0, i = 0; i < 2; i++) {
 239                 out += scnprintf(buf + out, count - out, " ");
 240                 for (j = 0; j < 8 && l < len; j++, l++) {
 241                         c = data[(i * 8 + j)];
 242                         if (!isascii(c) || !isprint(c))
 243                                 c = '.';
 244
 245                         out += scnprintf(buf + out, count - out, "%c", c);
 246                 }
 247
 248                 for (; j < 8; j++)
 249                         out += scnprintf(buf + out, count - out, " ");
 250         }
 251
 252         return out;
 253 }
 254
 255 static void printk_buf(int level, const u8 * data, u32 len)
 256 {
 257         char line[81];
 258         u32 ofs = 0;
 259         if (!(ipw_debug_level & level))
 260                 return;
 261
 262         while (len) {
 263                 snprint_line(line, sizeof(line), &data[ofs],
 264                              min(len, 16U), ofs);
 265                 printk(KERN_DEBUG "%s\n", line);
 266                 ofs += 16;
 267                 len -= min(len, 16U);
 268         }
 269 }
 270
 271 static int snprintk_buf(u8 * output, size_t size, const u8 * data, size_t len)
 272 {
 273         size_t out = size;
 274         u32 ofs = 0;
 275         int total = 0;
 276
 277         while (size && len) {
 278                 out = snprint_line(output, size, &data[ofs],
 279                                    min_t(size_t, len, 16U), ofs);
 280
 281                 ofs += 16;
 282                 output += out;
 283                 size -= out;
 284                 len -= min_t(size_t, len, 16U);
 285                 total += out;
 286         }
 287         return total;
 288 }
 289
 290 /* alias for 32-bit indirect read (for SRAM/reg above 4K), with debug wrapper */
 291 static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg);
 292 #define ipw_read_reg32(a, b) _ipw_read_reg32(a, b)
 293
 294 /* alias for 8-bit indirect read (for SRAM/reg above 4K), with debug wrapper */
 295 static u8 _ipw_read_reg8(struct ipw_priv *ipw, u32 reg);
 296 #define ipw_read_reg8(a, b) _ipw_read_reg8(a, b)
 297
 298 /* 8-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
 299 static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value);
 300 static inline void ipw_write_reg8(struct ipw_priv *a, u32 b, u8 c)
 301 {
 302         IPW_DEBUG_IO("%s %d: write_indirect8(0x%08X, 0x%08X)\n", __FILE__,
 303                      __LINE__, (u32) (b), (u32) (c));
 304         _ipw_write_reg8(a, b, c);
 305 }
 306
 307 /* 16-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
 308 static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value);
 309 static inline void ipw_write_reg16(struct ipw_priv *a, u32 b, u16 c)
 310 {
 311         IPW_DEBUG_IO("%s %d: write_indirect16(0x%08X, 0x%08X)\n", __FILE__,
 312                      __LINE__, (u32) (b), (u32) (c));
 313         _ipw_write_reg16(a, b, c);
 314 }
 315
 316 /* 32-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
 317 static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value);
 318 static inline void ipw_write_reg32(struct ipw_priv *a, u32 b, u32 c)
 319 {
 320         IPW_DEBUG_IO("%s %d: write_indirect32(0x%08X, 0x%08X)\n", __FILE__,
 321                      __LINE__, (u32) (b), (u32) (c));
 322         _ipw_write_reg32(a, b, c);
 323 }
 324
 325 /* 8-bit direct write (low 4K) */
 326 static inline void _ipw_write8(struct ipw_priv *ipw, unsigned long ofs,
 327                 u8 val)
 328 {
 329         writeb(val, ipw->hw_base + ofs);
 330 }
 331
 332 /* 8-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
 333 #define ipw_write8(ipw, ofs, val) do { \
 334         IPW_DEBUG_IO("%s %d: write_direct8(0x%08X, 0x%08X)\n", __FILE__, \
 335                         __LINE__, (u32)(ofs), (u32)(val)); \
 336         _ipw_write8(ipw, ofs, val); \
 337 } while (0)
 338
 339 /* 16-bit direct write (low 4K) */
 340 static inline void _ipw_write16(struct ipw_priv *ipw, unsigned long ofs,
 341                 u16 val)
 342 {
 343         writew(val, ipw->hw_base + ofs);
 344 }
 345
 346 /* 16-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
 347 #define ipw_write16(ipw, ofs, val) do { \
 348         IPW_DEBUG_IO("%s %d: write_direct16(0x%08X, 0x%08X)\n", __FILE__, \
 349                         __LINE__, (u32)(ofs), (u32)(val)); \
 350         _ipw_write16(ipw, ofs, val); \
 351 } while (0)
 352
 353 /* 32-bit direct write (low 4K) */
 354 static inline void _ipw_write32(struct ipw_priv *ipw, unsigned long ofs,
 355                 u32 val)
 356 {
 357         writel(val, ipw->hw_base + ofs);
 358 }
 359
 360 /* 32-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
 361 #define ipw_write32(ipw, ofs, val) do { \
 362         IPW_DEBUG_IO("%s %d: write_direct32(0x%08X, 0x%08X)\n", __FILE__, \
 363                         __LINE__, (u32)(ofs), (u32)(val)); \
 364         _ipw_write32(ipw, ofs, val); \
 365 } while (0)
 366
 367 /* 8-bit direct read (low 4K) */
 368 static inline u8 _ipw_read8(struct ipw_priv *ipw, unsigned long ofs)
 369 {
 370         return readb(ipw->hw_base + ofs);
 371 }
 372
 373 /* alias to 8-bit direct read (low 4K of SRAM/regs), with debug wrapper */
 374 #define ipw_read8(ipw, ofs) ({ \
 375         IPW_DEBUG_IO("%s %d: read_direct8(0x%08X)\n", __FILE__, __LINE__, \
 376                         (u32)(ofs)); \
 377         _ipw_read8(ipw, ofs); \
 378 })
 379
 380 /* 32-bit direct read (low 4K) */
 381 static inline u32 _ipw_read32(struct ipw_priv *ipw, unsigned long ofs)
 382 {
 383         return readl(ipw->hw_base + ofs);
 384 }
 385
 386 /* alias to 32-bit direct read (low 4K of SRAM/regs), with debug wrapper */
 387 #define ipw_read32(ipw, ofs) ({ \
 388         IPW_DEBUG_IO("%s %d: read_direct32(0x%08X)\n", __FILE__, __LINE__, \
 389                         (u32)(ofs)); \
 390         _ipw_read32(ipw, ofs); \
 391 })
 392
 393 static void _ipw_read_indirect(struct ipw_priv *, u32, u8 *, int);
 394 /* alias to multi-byte read (SRAM/regs above 4K), with debug wrapper */
 395 #define ipw_read_indirect(a, b, c, d) ({ \
 396         IPW_DEBUG_IO("%s %d: read_indirect(0x%08X) %u bytes\n", __FILE__, \
 397                         __LINE__, (u32)(b), (u32)(d)); \
 398         _ipw_read_indirect(a, b, c, d); \
 399 })
 400
 401 /* alias to multi-byte read (SRAM/regs above 4K), with debug wrapper */
 402 static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data,
 403                                 int num);
 404 #define ipw_write_indirect(a, b, c, d) do { \
 405         IPW_DEBUG_IO("%s %d: write_indirect(0x%08X) %u bytes\n", __FILE__, \
 406                         __LINE__, (u32)(b), (u32)(d)); \
 407         _ipw_write_indirect(a, b, c, d); \
 408 } while (0)
 409
 410 /* 32-bit indirect write (above 4K) */
 411 static void _ipw_write_reg32(struct ipw_priv *priv, u32 reg, u32 value)
 412 {
 413         IPW_DEBUG_IO(" %p : reg = 0x%8X : value = 0x%8X\n", priv, reg, value);
 414         _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
 415         _ipw_write32(priv, IPW_INDIRECT_DATA, value);
 416 }
 417
 418 /* 8-bit indirect write (above 4K) */
 419 static void _ipw_write_reg8(struct ipw_priv *priv, u32 reg, u8 value)
 420 {
 421         u32 aligned_addr = reg & IPW_INDIRECT_ADDR_MASK;        /* dword align */
 422         u32 dif_len = reg - aligned_addr;
 423
 424         IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
 425         _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
 426         _ipw_write8(priv, IPW_INDIRECT_DATA + dif_len, value);
 427 }
 428
 429 /* 16-bit indirect write (above 4K) */
 430 static void _ipw_write_reg16(struct ipw_priv *priv, u32 reg, u16 value)
 431 {
 432         u32 aligned_addr = reg & IPW_INDIRECT_ADDR_MASK;        /* dword align */
 433         u32 dif_len = (reg - aligned_addr) & (~0x1ul);
 434
 435         IPW_DEBUG_IO(" reg = 0x%8X : value = 0x%8X\n", reg, value);
 436         _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
 437         _ipw_write16(priv, IPW_INDIRECT_DATA + dif_len, value);
 438 }
 439
 440 /* 8-bit indirect read (above 4K) */
 441 static u8 _ipw_read_reg8(struct ipw_priv *priv, u32 reg)
 442 {
 443         u32 word;
 444         _ipw_write32(priv, IPW_INDIRECT_ADDR, reg & IPW_INDIRECT_ADDR_MASK);
 445         IPW_DEBUG_IO(" reg = 0x%8X :\n", reg);
 446         word = _ipw_read32(priv, IPW_INDIRECT_DATA);
 447         return (word >> ((reg & 0x3) * 8)) & 0xff;
 448 }
 449
 450 /* 32-bit indirect read (above 4K) */
 451 static u32 _ipw_read_reg32(struct ipw_priv *priv, u32 reg)
 452 {
 453         u32 value;
 454
 455         IPW_DEBUG_IO("%p : reg = 0x%08x\n", priv, reg);
 456
 457         _ipw_write32(priv, IPW_INDIRECT_ADDR, reg);
 458         value = _ipw_read32(priv, IPW_INDIRECT_DATA);
 459         IPW_DEBUG_IO(" reg = 0x%4X : value = 0x%4x\n", reg, value);
 460         return value;
 461 }
 462
 463 /* General purpose, no alignment requirement, iterative (multi-byte) read, */
 464 /*    for area above 1st 4K of SRAM/reg space */
 465 static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
 466                                int num)
 467 {
 468         u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;       /* dword align */
 469         u32 dif_len = addr - aligned_addr;
 470         u32 i;
 471
 472         IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
 473
 474         if (num <= 0) {
 475                 return;
 476         }
 477
 478         /* Read the first dword (or portion) byte by byte */
 479         if (unlikely(dif_len)) {
 480                 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
 481                 /* Start reading at aligned_addr + dif_len */
 482                 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--)
 483                         *buf++ = _ipw_read8(priv, IPW_INDIRECT_DATA + i);
 484                 aligned_addr += 4;
 485         }
 486
 487         /* Read all of the middle dwords as dwords, with auto-increment */
 488         _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
 489         for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
 490                 *(u32 *) buf = _ipw_read32(priv, IPW_AUTOINC_DATA);
 491
 492         /* Read the last dword (or portion) byte by byte */
 493         if (unlikely(num)) {
 494                 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
 495                 for (i = 0; num > 0; i++, num--)
 496                         *buf++ = ipw_read8(priv, IPW_INDIRECT_DATA + i);
 497         }
 498 }
 499
 500 /* General purpose, no alignment requirement, iterative (multi-byte) write, */
 501 /*    for area above 1st 4K of SRAM/reg space */
 502 static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
 503                                 int num)
 504 {
 505         u32 aligned_addr = addr & IPW_INDIRECT_ADDR_MASK;       /* dword align */
 506         u32 dif_len = addr - aligned_addr;
 507         u32 i;
 508
 509         IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
 510
 511         if (num <= 0) {
 512                 return;
 513         }
 514
 515         /* Write the first dword (or portion) byte by byte */
 516         if (unlikely(dif_len)) {
 517                 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
 518                 /* Start writing at aligned_addr + dif_len */
 519                 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--, buf++)
 520                         _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
 521                 aligned_addr += 4;
 522         }
 523
 524         /* Write all of the middle dwords as dwords, with auto-increment */
 525         _ipw_write32(priv, IPW_AUTOINC_ADDR, aligned_addr);
 526         for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
 527                 _ipw_write32(priv, IPW_AUTOINC_DATA, *(u32 *) buf);
 528
 529         /* Write the last dword (or portion) byte by byte */
 530         if (unlikely(num)) {
 531                 _ipw_write32(priv, IPW_INDIRECT_ADDR, aligned_addr);
 532                 for (i = 0; num > 0; i++, num--, buf++)
 533                         _ipw_write8(priv, IPW_INDIRECT_DATA + i, *buf);
 534         }
 535 }
 536
 537 /* General purpose, no alignment requirement, iterative (multi-byte) write, */
 538 /*    for 1st 4K of SRAM/regs space */
 539 static void ipw_write_direct(struct ipw_priv *priv, u32 addr, void *buf,
 540                              int num)
 541 {
 542         memcpy_toio((priv->hw_base + addr), buf, num);
 543 }
 544
 545 /* Set bit(s) in low 4K of SRAM/regs */
 546 static inline void ipw_set_bit(struct ipw_priv *priv, u32 reg, u32 mask)
 547 {
 548         ipw_write32(priv, reg, ipw_read32(priv, reg) | mask);
 549 }
 550
 551 /* Clear bit(s) in low 4K of SRAM/regs */
 552 static inline void ipw_clear_bit(struct ipw_priv *priv, u32 reg, u32 mask)
 553 {
 554         ipw_write32(priv, reg, ipw_read32(priv, reg) & ~mask);
 555 }
 556
 557 static inline void __ipw_enable_interrupts(struct ipw_priv *priv)
 558 {
 559         if (priv->status & STATUS_INT_ENABLED)
 560                 return;
 561         priv->status |= STATUS_INT_ENABLED;
 562         ipw_write32(priv, IPW_INTA_MASK_R, IPW_INTA_MASK_ALL);
 563 }
 564
 565 static inline void __ipw_disable_interrupts(struct ipw_priv *priv)
 566 {
 567         if (!(priv->status & STATUS_INT_ENABLED))
 568                 return;
 569         priv->status &= ~STATUS_INT_ENABLED;
 570         ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
 571 }
 572
 573 static inline void ipw_enable_interrupts(struct ipw_priv *priv)
 574 {
 575         unsigned long flags;
 576
 577         spin_lock_irqsave(&priv->irq_lock, flags);
 578         __ipw_enable_interrupts(priv);
 579         spin_unlock_irqrestore(&priv->irq_lock, flags);
 580 }
 581
 582 static inline void ipw_disable_interrupts(struct ipw_priv *priv)
 583 {
 584         unsigned long flags;
 585
 586         spin_lock_irqsave(&priv->irq_lock, flags);
 587         __ipw_disable_interrupts(priv);
 588         spin_unlock_irqrestore(&priv->irq_lock, flags);
 589 }
 590
 591 static char *ipw_error_desc(u32 val)
 592 {
 593         switch (val) {
 594         case IPW_FW_ERROR_OK:
 595                 return "ERROR_OK";
 596         case IPW_FW_ERROR_FAIL:
 597                 return "ERROR_FAIL";
 598         case IPW_FW_ERROR_MEMORY_UNDERFLOW:
 599                 return "MEMORY_UNDERFLOW";
 600         case IPW_FW_ERROR_MEMORY_OVERFLOW:
 601                 return "MEMORY_OVERFLOW";
 602         case IPW_FW_ERROR_BAD_PARAM:
 603                 return "BAD_PARAM";
 604         case IPW_FW_ERROR_BAD_CHECKSUM:
 605                 return "BAD_CHECKSUM";
 606         case IPW_FW_ERROR_NMI_INTERRUPT:
 607                 return "NMI_INTERRUPT";
 608         case IPW_FW_ERROR_BAD_DATABASE:
 609                 return "BAD_DATABASE";
 610         case IPW_FW_ERROR_ALLOC_FAIL:
 611                 return "ALLOC_FAIL";
 612         case IPW_FW_ERROR_DMA_UNDERRUN:
 613                 return "DMA_UNDERRUN";
 614         case IPW_FW_ERROR_DMA_STATUS:
 615                 return "DMA_STATUS";
 616         case IPW_FW_ERROR_DINO_ERROR:
 617                 return "DINO_ERROR";
 618         case IPW_FW_ERROR_EEPROM_ERROR:
 619                 return "EEPROM_ERROR";
 620         case IPW_FW_ERROR_SYSASSERT:
 621                 return "SYSASSERT";
 622         case IPW_FW_ERROR_FATAL_ERROR:
 623                 return "FATAL_ERROR";
 624         default:
 625                 return "UNKNOWN_ERROR";
 626         }
 627 }
 628
 629 static void ipw_dump_error_log(struct ipw_priv *priv,
 630                                struct ipw_fw_error *error)
 631 {
 632         u32 i;
 633
 634         if (!error) {
 635                 IPW_ERROR("Error allocating and capturing error log.  "
 636                           "Nothing to dump.\n");
 637                 return;
 638         }
 639
 640         IPW_ERROR("Start IPW Error Log Dump:\n");
 641         IPW_ERROR("Status: 0x%08X, Config: %08X\n",
 642                   error->status, error->config);
 643
 644         for (i = 0; i < error->elem_len; i++)
 645                 IPW_ERROR("%s %i 0x%08x  0x%08x  0x%08x  0x%08x  0x%08x\n",
 646                           ipw_error_desc(error->elem[i].desc),
 647                           error->elem[i].time,
 648                           error->elem[i].blink1,
 649                           error->elem[i].blink2,
 650                           error->elem[i].link1,
 651                           error->elem[i].link2, error->elem[i].data);
 652         for (i = 0; i < error->log_len; i++)
 653                 IPW_ERROR("%i\t0x%08x\t%i\n",
 654                           error->log[i].time,
 655                           error->log[i].data, error->log[i].event);
 656 }
 657
 658 static inline int ipw_is_init(struct ipw_priv *priv)
 659 {
 660         return (priv->status & STATUS_INIT) ? 1 : 0;
 661 }
 662
 663 static int ipw_get_ordinal(struct ipw_priv *priv, u32 ord, void *val, u32 * len)
 664 {
 665         u32 addr, field_info, field_len, field_count, total_len;
 666
 667         IPW_DEBUG_ORD("ordinal = %i\n", ord);
 668
 669         if (!priv || !val || !len) {
 670                 IPW_DEBUG_ORD("Invalid argument\n");
 671                 return -EINVAL;
 672         }
 673
 674         /* verify device ordinal tables have been initialized */
 675         if (!priv->table0_addr || !priv->table1_addr || !priv->table2_addr) {
 676                 IPW_DEBUG_ORD("Access ordinals before initialization\n");
 677                 return -EINVAL;
 678         }
 679
 680         switch (IPW_ORD_TABLE_ID_MASK & ord) {
 681         case IPW_ORD_TABLE_0_MASK:
 682                 /*
 683                  * TABLE 0: Direct access to a table of 32 bit values
 684                  *
 685                  * This is a very simple table with the data directly
 686                  * read from the table
 687                  */
 688
 689                 /* remove the table id from the ordinal */
 690                 ord &= IPW_ORD_TABLE_VALUE_MASK;
 691
 692                 /* boundary check */
 693                 if (ord > priv->table0_len) {
 694                         IPW_DEBUG_ORD("ordinal value (%i) longer then "
 695                                       "max (%i)\n", ord, priv->table0_len);
 696                         return -EINVAL;
 697                 }
 698
 699                 /* verify we have enough room to store the value */
 700                 if (*len < sizeof(u32)) {
 701                         IPW_DEBUG_ORD("ordinal buffer length too small, "
 702                                       "need %zd\n", sizeof(u32));
 703                         return -EINVAL;
 704                 }
 705
 706                 IPW_DEBUG_ORD("Reading TABLE0[%i] from offset 0x%08x\n",
 707                               ord, priv->table0_addr + (ord << 2));
 708
 709                 *len = sizeof(u32);
 710                 ord <<= 2;
 711                 *((u32 *) val) = ipw_read32(priv, priv->table0_addr + ord);
 712                 break;
 713
 714         case IPW_ORD_TABLE_1_MASK:
 715                 /*
 716                  * TABLE 1: Indirect access to a table of 32 bit values
 717                  *
 718                  * This is a fairly large table of u32 values each
 719                  * representing starting addr for the data (which is
 720                  * also a u32)
 721                  */
 722
 723                 /* remove the table id from the ordinal */
 724                 ord &= IPW_ORD_TABLE_VALUE_MASK;
 725
 726                 /* boundary check */
 727                 if (ord > priv->table1_len) {
 728                         IPW_DEBUG_ORD("ordinal value too long\n");
 729                         return -EINVAL;
 730                 }
 731
 732                 /* verify we have enough room to store the value */
 733                 if (*len < sizeof(u32)) {
 734                         IPW_DEBUG_ORD("ordinal buffer length too small, "
 735                                       "need %zd\n", sizeof(u32));
 736                         return -EINVAL;
 737                 }
 738
 739                 *((u32 *) val) =
 740                     ipw_read_reg32(priv, (priv->table1_addr + (ord << 2)));
 741                 *len = sizeof(u32);
 742                 break;
 743
 744         case IPW_ORD_TABLE_2_MASK:
 745                 /*
 746                  * TABLE 2: Indirect access to a table of variable sized values
 747                  *
 748                  * This table consist of six values, each containing
 749                  *     - dword containing the starting offset of the data
 750                  *     - dword containing the lengh in the first 16bits
 751                  *       and the count in the second 16bits
 752                  */
 753
 754                 /* remove the table id from the ordinal */
 755                 ord &= IPW_ORD_TABLE_VALUE_MASK;
 756
 757                 /* boundary check */
 758                 if (ord > priv->table2_len) {
 759                         IPW_DEBUG_ORD("ordinal value too long\n");
 760                         return -EINVAL;
 761                 }
 762
 763                 /* get the address of statistic */
 764                 addr = ipw_read_reg32(priv, priv->table2_addr + (ord << 3));
 765
 766                 /* get the second DW of statistics ;
 767                  * two 16-bit words - first is length, second is count */
 768                 field_info =
 769                     ipw_read_reg32(priv,
 770                                    priv->table2_addr + (ord << 3) +
 771                                    sizeof(u32));
 772
 773                 /* get each entry length */
 774                 field_len = *((u16 *) & field_info);
 775
 776                 /* get number of entries */
 777                 field_count = *(((u16 *) & field_info) + 1);
 778
 779                 /* abort if not enough memory */
 780                 total_len = field_len * field_count;
 781                 if (total_len > *len) {
 782                         *len = total_len;
 783                         return -EINVAL;
 784                 }
 785
 786                 *len = total_len;
 787                 if (!total_len)
 788                         return 0;
 789
 790                 IPW_DEBUG_ORD("addr = 0x%08x, total_len = %i, "
 791                               "field_info = 0x%08x\n",
 792                               addr, total_len, field_info);
 793                 ipw_read_indirect(priv, addr, val, total_len);
 794                 break;
 795
 796         default:
 797                 IPW_DEBUG_ORD("Invalid ordinal!\n");
 798                 return -EINVAL;
 799
 800         }
 801
 802         return 0;
 803 }
 804
 805 static void ipw_init_ordinals(struct ipw_priv *priv)
 806 {
 807         priv->table0_addr = IPW_ORDINALS_TABLE_LOWER;
 808         priv->table0_len = ipw_read32(priv, priv->table0_addr);
 809
 810         IPW_DEBUG_ORD("table 0 offset at 0x%08x, len = %i\n",
 811                       priv->table0_addr, priv->table0_len);
 812
 813         priv->table1_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_1);
 814         priv->table1_len = ipw_read_reg32(priv, priv->table1_addr);
 815
 816         IPW_DEBUG_ORD("table 1 offset at 0x%08x, len = %i\n",
 817                       priv->table1_addr, priv->table1_len);
 818
 819         priv->table2_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_2);
 820         priv->table2_len = ipw_read_reg32(priv, priv->table2_addr);
 821         priv->table2_len &= 0x0000ffff; /* use first two bytes */
 822
 823         IPW_DEBUG_ORD("table 2 offset at 0x%08x, len = %i\n",
 824                       priv->table2_addr, priv->table2_len);
 825
 826 }
 827
 828 static u32 ipw_register_toggle(u32 reg)
 829 {
 830         reg &= ~IPW_START_STANDBY;
 831         if (reg & IPW_GATE_ODMA)
 832                 reg &= ~IPW_GATE_ODMA;
 833         if (reg & IPW_GATE_IDMA)
 834                 reg &= ~IPW_GATE_IDMA;
 835         if (reg & IPW_GATE_ADMA)
 836                 reg &= ~IPW_GATE_ADMA;
 837         return reg;
 838 }
 839
 840 /*
 841  * LED behavior:
 842  * - On radio ON, turn on any LEDs that require to be on during start
 843  * - On initialization, start unassociated blink
 844  * - On association, disable unassociated blink
 845  * - On disassociation, start unassociated blink
 846  * - On radio OFF, turn off any LEDs started during radio on
 847  *
 848  */
 849 #define LD_TIME_LINK_ON msecs_to_jiffies(300)
 850 #define LD_TIME_LINK_OFF msecs_to_jiffies(2700)
 851 #define LD_TIME_ACT_ON msecs_to_jiffies(250)
 852
 853 static void ipw_led_link_on(struct ipw_priv *priv)
 854 {
 855         unsigned long flags;
 856         u32 led;
 857
 858         /* If configured to not use LEDs, or nic_type is 1,
 859          * then we don't toggle a LINK led */
 860         if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
 861                 return;
 862
 863         spin_lock_irqsave(&priv->lock, flags);
 864
 865         if (!(priv->status & STATUS_RF_KILL_MASK) &&
 866             !(priv->status & STATUS_LED_LINK_ON)) {
 867                 IPW_DEBUG_LED("Link LED On\n");
 868                 led = ipw_read_reg32(priv, IPW_EVENT_REG);
 869                 led |= priv->led_association_on;
 870
 871                 led = ipw_register_toggle(led);
 872
 873                 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
 874                 ipw_write_reg32(priv, IPW_EVENT_REG, led);
 875
 876                 priv->status |= STATUS_LED_LINK_ON;
 877
 878                 /* If we aren't associated, schedule turning the LED off */
 879                 if (!(priv->status & STATUS_ASSOCIATED))
 880                         schedule_delayed_work(&priv->led_link_off,
 881                                               LD_TIME_LINK_ON);
 882         }
 883
 884         spin_unlock_irqrestore(&priv->lock, flags);
 885 }
 886
 887 static void ipw_bg_led_link_on(struct work_struct *work)
 888 {
 889         struct ipw_priv *priv =
 890                 container_of(work, struct ipw_priv, led_link_on.work);
 891         mutex_lock(&priv->mutex);
 892         ipw_led_link_on(priv);
 893         mutex_unlock(&priv->mutex);
 894 }
 895
 896 static void ipw_led_link_off(struct ipw_priv *priv)
 897 {
 898         unsigned long flags;
 899         u32 led;
 900
 901         /* If configured not to use LEDs, or nic type is 1,
 902          * then we don't goggle the LINK led. */
 903         if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
 904                 return;
 905
 906         spin_lock_irqsave(&priv->lock, flags);
 907
 908         if (priv->status & STATUS_LED_LINK_ON) {
 909                 led = ipw_read_reg32(priv, IPW_EVENT_REG);
 910                 led &= priv->led_association_off;
 911                 led = ipw_register_toggle(led);
 912
 913                 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
 914                 ipw_write_reg32(priv, IPW_EVENT_REG, led);
 915
 916                 IPW_DEBUG_LED("Link LED Off\n");
 917
 918                 priv->status &= ~STATUS_LED_LINK_ON;
 919
 920                 /* If we aren't associated and the radio is on, schedule
 921                  * turning the LED on (blink while unassociated) */
 922                 if (!(priv->status & STATUS_RF_KILL_MASK) &&
 923                     !(priv->status & STATUS_ASSOCIATED))
 924                         schedule_delayed_work(&priv->led_link_on,
 925                                               LD_TIME_LINK_OFF);
 926
 927         }
 928
 929         spin_unlock_irqrestore(&priv->lock, flags);
 930 }
 931
 932 static void ipw_bg_led_link_off(struct work_struct *work)
 933 {
 934         struct ipw_priv *priv =
 935                 container_of(work, struct ipw_priv, led_link_off.work);
 936         mutex_lock(&priv->mutex);
 937         ipw_led_link_off(priv);
 938         mutex_unlock(&priv->mutex);
 939 }
 940
 941 static void __ipw_led_activity_on(struct ipw_priv *priv)
 942 {
 943         u32 led;
 944
 945         if (priv->config & CFG_NO_LED)
 946                 return;
 947
 948         if (priv->status & STATUS_RF_KILL_MASK)
 949                 return;
 950
 951         if (!(priv->status & STATUS_LED_ACT_ON)) {
 952                 led = ipw_read_reg32(priv, IPW_EVENT_REG);
 953                 led |= priv->led_activity_on;
 954
 955                 led = ipw_register_toggle(led);
 956
 957                 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
 958                 ipw_write_reg32(priv, IPW_EVENT_REG, led);
 959
 960                 IPW_DEBUG_LED("Activity LED On\n");
 961
 962                 priv->status |= STATUS_LED_ACT_ON;
 963
 964                 cancel_delayed_work(&priv->led_act_off);
 965                 schedule_delayed_work(&priv->led_act_off, LD_TIME_ACT_ON);
 966         } else {
 967                 /* Reschedule LED off for full time period */
 968                 cancel_delayed_work(&priv->led_act_off);
 969                 schedule_delayed_work(&priv->led_act_off, LD_TIME_ACT_ON);
 970         }
 971 }
 972
 973 #if 0
 974 void ipw_led_activity_on(struct ipw_priv *priv)
 975 {
 976         unsigned long flags;
 977         spin_lock_irqsave(&priv->lock, flags);
 978         __ipw_led_activity_on(priv);
 979         spin_unlock_irqrestore(&priv->lock, flags);
 980 }
 981 #endif  /*  0  */
 982
 983 static void ipw_led_activity_off(struct ipw_priv *priv)
 984 {
 985         unsigned long flags;
 986         u32 led;
 987
 988         if (priv->config & CFG_NO_LED)
 989                 return;
 990
 991         spin_lock_irqsave(&priv->lock, flags);
 992
 993         if (priv->status & STATUS_LED_ACT_ON) {
 994                 led = ipw_read_reg32(priv, IPW_EVENT_REG);
 995                 led &= priv->led_activity_off;
 996
 997                 led = ipw_register_toggle(led);
 998
 999                 IPW_DEBUG_LED("Reg: 0x%08X\n", led);
1000                 ipw_write_reg32(priv, IPW_EVENT_REG, led);
1001
1002                 IPW_DEBUG_LED("Activity LED Off\n");
1003
1004                 priv->status &= ~STATUS_LED_ACT_ON;
1005         }
1006
1007         spin_unlock_irqrestore(&priv->lock, flags);
1008 }
1009
1010 static void ipw_bg_led_activity_off(struct work_struct *work)
1011 {
1012         struct ipw_priv *priv =
1013                 container_of(work, struct ipw_priv, led_act_off.work);
1014         mutex_lock(&priv->mutex);
1015         ipw_led_activity_off(priv);
1016         mutex_unlock(&priv->mutex);
1017 }
1018
1019 static void ipw_led_band_on(struct ipw_priv *priv)
1020 {
1021         unsigned long flags;
1022         u32 led;
1023
1024         /* Only nic type 1 supports mode LEDs */
1025         if (priv->config & CFG_NO_LED ||
1026             priv->nic_type != EEPROM_NIC_TYPE_1 || !priv->assoc_network)
1027                 return;
1028
1029         spin_lock_irqsave(&priv->lock, flags);
1030
1031         led = ipw_read_reg32(priv, IPW_EVENT_REG);
1032         if (priv->assoc_network->mode == IEEE_A) {
1033                 led |= priv->led_ofdm_on;
1034                 led &= priv->led_association_off;
1035                 IPW_DEBUG_LED("Mode LED On: 802.11a\n");
1036         } else if (priv->assoc_network->mode == IEEE_G) {
1037                 led |= priv->led_ofdm_on;
1038                 led |= priv->led_association_on;
1039                 IPW_DEBUG_LED("Mode LED On: 802.11g\n");
1040         } else {
1041                 led &= priv->led_ofdm_off;
1042                 led |= priv->led_association_on;
1043                 IPW_DEBUG_LED("Mode LED On: 802.11b\n");
1044         }
1045
1046         led = ipw_register_toggle(led);
1047
1048         IPW_DEBUG_LED("Reg: 0x%08X\n", led);
1049         ipw_write_reg32(priv, IPW_EVENT_REG, led);
1050
1051         spin_unlock_irqrestore(&priv->lock, flags);
1052 }
1053
1054 static void ipw_led_band_off(struct ipw_priv *priv)
1055 {
1056         unsigned long flags;
1057         u32 led;
1058
1059         /* Only nic type 1 supports mode LEDs */
1060         if (priv->config & CFG_NO_LED || priv->nic_type != EEPROM_NIC_TYPE_1)
1061                 return;
1062
1063         spin_lock_irqsave(&priv->lock, flags);
1064
1065         led = ipw_read_reg32(priv, IPW_EVENT_REG);
1066         led &= priv->led_ofdm_off;
1067         led &= priv->led_association_off;
1068
1069         led = ipw_register_toggle(led);
1070
1071         IPW_DEBUG_LED("Reg: 0x%08X\n", led);
1072         ipw_write_reg32(priv, IPW_EVENT_REG, led);
1073
1074         spin_unlock_irqrestore(&priv->lock, flags);
1075 }
1076
1077 static void ipw_led_radio_on(struct ipw_priv *priv)
1078 {
1079         ipw_led_link_on(priv);
1080 }
1081
1082 static void ipw_led_radio_off(struct ipw_priv *priv)
1083 {
1084         ipw_led_activity_off(priv);
1085         ipw_led_link_off(priv);
1086 }
1087
1088 static void ipw_led_link_up(struct ipw_priv *priv)
1089 {
1090         /* Set the Link Led on for all nic types */
1091         ipw_led_link_on(priv);
1092 }
1093
1094 static void ipw_led_link_down(struct ipw_priv *priv)
1095 {
1096         ipw_led_activity_off(priv);
1097         ipw_led_link_off(priv);
1098
1099         if (priv->status & STATUS_RF_KILL_MASK)
1100                 ipw_led_radio_off(priv);
1101 }
1102
1103 static void ipw_led_init(struct ipw_priv *priv)
1104 {
1105         priv->nic_type = priv->eeprom[EEPROM_NIC_TYPE];
1106
1107         /* Set the default PINs for the link and activity leds */
1108         priv->led_activity_on = IPW_ACTIVITY_LED;
1109         priv->led_activity_off = ~(IPW_ACTIVITY_LED);
1110
1111         priv->led_association_on = IPW_ASSOCIATED_LED;
1112         priv->led_association_off = ~(IPW_ASSOCIATED_LED);
1113
1114         /* Set the default PINs for the OFDM leds */
1115         priv->led_ofdm_on = IPW_OFDM_LED;
1116         priv->led_ofdm_off = ~(IPW_OFDM_LED);
1117
1118         switch (priv->nic_type) {
1119         case EEPROM_NIC_TYPE_1:
1120                 /* In this NIC type, the LEDs are reversed.... */
1121                 priv->led_activity_on = IPW_ASSOCIATED_LED;
1122                 priv->led_activity_off = ~(IPW_ASSOCIATED_LED);
1123                 priv->led_association_on = IPW_ACTIVITY_LED;
1124                 priv->led_association_off = ~(IPW_ACTIVITY_LED);
1125
1126                 if (!(priv->config & CFG_NO_LED))
1127                         ipw_led_band_on(priv);
1128
1129                 /* And we don't blink link LEDs for this nic, so
1130                  * just return here */
1131                 return;
1132
1133         case EEPROM_NIC_TYPE_3:
1134         case EEPROM_NIC_TYPE_2:
1135         case EEPROM_NIC_TYPE_4:
1136         case EEPROM_NIC_TYPE_0:
1137                 break;
1138
1139         default:
1140                 IPW_DEBUG_INFO("Unknown NIC type from EEPROM: %d\n",
1141                                priv->nic_type);
1142                 priv->nic_type = EEPROM_NIC_TYPE_0;
1143                 break;
1144         }
1145
1146         if (!(priv->config & CFG_NO_LED)) {
1147                 if (priv->status & STATUS_ASSOCIATED)
1148                         ipw_led_link_on(priv);
1149                 else
1150                         ipw_led_link_off(priv);
1151         }
1152 }
1153
1154 static void ipw_led_shutdown(struct ipw_priv *priv)
1155 {
1156         ipw_led_activity_off(priv);
1157         ipw_led_link_off(priv);
1158         ipw_led_band_off(priv);
1159         cancel_delayed_work(&priv->led_link_on);
1160         cancel_delayed_work(&priv->led_link_off);
1161         cancel_delayed_work(&priv->led_act_off);
1162 }
1163
1164 /*
1165  * The following adds a new attribute to the sysfs representation
1166  * of this device driver (i.e. a new file in /sys/bus/pci/drivers/ipw/)
1167  * used for controlling the debug level.
1168  *
1169  * See the level definitions in ipw for details.
1170  */
1171 static ssize_t debug_level_show(struct device_driver *d, char *buf)
1172 {
1173         return sprintf(buf, "0x%08X\n", ipw_debug_level);
1174 }
1175
1176 static ssize_t debug_level_store(struct device_driver *d, const char *buf,
1177                                  size_t count)
1178 {
1179         unsigned long val;
1180
1181         int result = kstrtoul(buf, 0, &val);
1182
1183         if (result == -EINVAL)
1184                 printk(KERN_INFO DRV_NAME
1185                        ": %s is not in hex or decimal form.\n", buf);
1186         else if (result == -ERANGE)
1187                 printk(KERN_INFO DRV_NAME
1188                          ": %s has overflowed.\n", buf);
1189         else
1190                 ipw_debug_level = val;
1191
1192         return count;
1193 }
1194 static DRIVER_ATTR_RW(debug_level);
1195
1196 static inline u32 ipw_get_event_log_len(struct ipw_priv *priv)
1197 {
1198         /* length = 1st dword in log */
1199         return ipw_read_reg32(priv, ipw_read32(priv, IPW_EVENT_LOG));
1200 }
1201
1202 static void ipw_capture_event_log(struct ipw_priv *priv,
1203                                   u32 log_len, struct ipw_event *log)
1204 {
1205         u32 base;
1206
1207         if (log_len) {
1208                 base = ipw_read32(priv, IPW_EVENT_LOG);
1209                 ipw_read_indirect(priv, base + sizeof(base) + sizeof(u32),
1210                                   (u8 *) log, sizeof(*log) * log_len);
1211         }
1212 }
1213
1214 static struct ipw_fw_error *ipw_alloc_error_log(struct ipw_priv *priv)
1215 {
1216         struct ipw_fw_error *error;
1217         u32 log_len = ipw_get_event_log_len(priv);
1218         u32 base = ipw_read32(priv, IPW_ERROR_LOG);
1219         u32 elem_len = ipw_read_reg32(priv, base);
1220
1221         error = kmalloc(size_add(struct_size(error, elem, elem_len),
1222                                  array_size(sizeof(*error->log), log_len)),
1223                         GFP_ATOMIC);
1224         if (!error) {
1225                 IPW_ERROR("Memory allocation for firmware error log "
1226                           "failed.\n");
1227                 return NULL;
1228         }
1229         error->jiffies = jiffies;
1230         error->status = priv->status;
1231         error->config = priv->config;
1232         error->elem_len = elem_len;
1233         error->log_len = log_len;
1234         error->log = (struct ipw_event *)(error->elem + elem_len);
1235
1236         ipw_capture_event_log(priv, log_len, error->log);
1237
1238         if (elem_len)
1239                 ipw_read_indirect(priv, base + sizeof(base), (u8 *) error->elem,
1240                                   sizeof(*error->elem) * elem_len);
1241
1242         return error;
1243 }
1244
1245 static ssize_t event_log_show(struct device *d,
1246                               struct device_attribute *attr, char *buf)
1247 {
1248         struct ipw_priv *priv = dev_get_drvdata(d);
1249         u32 log_len = ipw_get_event_log_len(priv);
1250         u32 log_size;
1251         struct ipw_event *log;
1252         u32 len = 0, i;
1253
1254         /* not using min() because of its strict type checking */
1255         log_size = PAGE_SIZE / sizeof(*log) > log_len ?
1256                         sizeof(*log) * log_len : PAGE_SIZE;
1257         log = kzalloc(log_size, GFP_KERNEL);
1258         if (!log) {
1259                 IPW_ERROR("Unable to allocate memory for log\n");
1260                 return 0;
1261         }
1262         log_len = log_size / sizeof(*log);
1263         ipw_capture_event_log(priv, log_len, log);
1264
1265         len += scnprintf(buf + len, PAGE_SIZE - len, "%08X", log_len);
1266         for (i = 0; i < log_len; i++)
1267                 len += scnprintf(buf + len, PAGE_SIZE - len,
1268                                 "\n%08X%08X%08X",
1269                                 log[i].time, log[i].event, log[i].data);
1270         len += scnprintf(buf + len, PAGE_SIZE - len, "\n");
1271         kfree(log);
1272         return len;
1273 }
1274
1275 static DEVICE_ATTR_RO(event_log);
1276
1277 static ssize_t error_show(struct device *d,
1278                           struct device_attribute *attr, char *buf)
1279 {
1280         struct ipw_priv *priv = dev_get_drvdata(d);
1281         u32 len = 0, i;
1282         if (!priv->error)
1283                 return 0;
1284         len += scnprintf(buf + len, PAGE_SIZE - len,
1285                         "%08lX%08X%08X%08X",
1286                         priv->error->jiffies,
1287                         priv->error->status,
1288                         priv->error->config, priv->error->elem_len);
1289         for (i = 0; i < priv->error->elem_len; i++)
1290                 len += scnprintf(buf + len, PAGE_SIZE - len,
1291                                 "\n%08X%08X%08X%08X%08X%08X%08X",
1292                                 priv->error->elem[i].time,
1293                                 priv->error->elem[i].desc,
1294                                 priv->error->elem[i].blink1,
1295                                 priv->error->elem[i].blink2,
1296                                 priv->error->elem[i].link1,
1297                                 priv->error->elem[i].link2,
1298                                 priv->error->elem[i].data);
1299
1300         len += scnprintf(buf + len, PAGE_SIZE - len,
1301                         "\n%08X", priv->error->log_len);
1302         for (i = 0; i < priv->error->log_len; i++)
1303                 len += scnprintf(buf + len, PAGE_SIZE - len,
1304                                 "\n%08X%08X%08X",
1305                                 priv->error->log[i].time,
1306                                 priv->error->log[i].event,
1307                                 priv->error->log[i].data);
1308         len += scnprintf(buf + len, PAGE_SIZE - len, "\n");
1309         return len;
1310 }
1311
1312 static ssize_t error_store(struct device *d,
1313                            struct device_attribute *attr,
1314                            const char *buf, size_t count)
1315 {
1316         struct ipw_priv *priv = dev_get_drvdata(d);
1317
1318         kfree(priv->error);
1319         priv->error = NULL;
1320         return count;
1321 }
1322
1323 static DEVICE_ATTR_RW(error);
1324
1325 static ssize_t cmd_log_show(struct device *d,
1326                             struct device_attribute *attr, char *buf)
1327 {
1328         struct ipw_priv *priv = dev_get_drvdata(d);
1329         u32 len = 0, i;
1330         if (!priv->cmdlog)
1331                 return 0;
1332         for (i = (priv->cmdlog_pos + 1) % priv->cmdlog_len;
1333              (i != priv->cmdlog_pos) && (len < PAGE_SIZE);
1334              i = (i + 1) % priv->cmdlog_len) {
1335                 len +=
1336                     scnprintf(buf + len, PAGE_SIZE - len,
1337                              "\n%08lX%08X%08X%08X\n", priv->cmdlog[i].jiffies,
1338                              priv->cmdlog[i].retcode, priv->cmdlog[i].cmd.cmd,
1339                              priv->cmdlog[i].cmd.len);
1340                 len +=
1341                     snprintk_buf(buf + len, PAGE_SIZE - len,
1342                                  (u8 *) priv->cmdlog[i].cmd.param,
1343                                  priv->cmdlog[i].cmd.len);
1344                 len += scnprintf(buf + len, PAGE_SIZE - len, "\n");
1345         }
1346         len += scnprintf(buf + len, PAGE_SIZE - len, "\n");
1347         return len;
1348 }
1349
1350 static DEVICE_ATTR_RO(cmd_log);
1351
1352 #ifdef CONFIG_IPW2200_PROMISCUOUS
1353 static void ipw_prom_free(struct ipw_priv *priv);
1354 static int ipw_prom_alloc(struct ipw_priv *priv);
1355 static ssize_t rtap_iface_store(struct device *d,
1356                          struct device_attribute *attr,
1357                          const char *buf, size_t count)
1358 {
1359         struct ipw_priv *priv = dev_get_drvdata(d);
1360         int rc = 0;
1361
1362         if (count < 1)
1363                 return -EINVAL;
1364
1365         switch (buf[0]) {
1366         case '0':
1367                 if (!rtap_iface)
1368                         return count;
1369
1370                 if (netif_running(priv->prom_net_dev)) {
1371                         IPW_WARNING("Interface is up.  Cannot unregister.\n");
1372                         return count;
1373                 }
1374
1375                 ipw_prom_free(priv);
1376                 rtap_iface = 0;
1377                 break;
1378
1379         case '1':
1380                 if (rtap_iface)
1381                         return count;
1382
1383                 rc = ipw_prom_alloc(priv);
1384                 if (!rc)
1385                         rtap_iface = 1;
1386                 break;
1387
1388         default:
1389                 return -EINVAL;
1390         }
1391
1392         if (rc) {
1393                 IPW_ERROR("Failed to register promiscuous network "
1394                           "device (error %d).\n", rc);
1395         }
1396
1397         return count;
1398 }
1399
1400 static ssize_t rtap_iface_show(struct device *d,
1401                         struct device_attribute *attr,
1402                         char *buf)
1403 {
1404         struct ipw_priv *priv = dev_get_drvdata(d);
1405         if (rtap_iface)
1406                 return sprintf(buf, "%s", priv->prom_net_dev->name);
1407         else {
1408                 buf[0] = '-';
1409                 buf[1] = '1';
1410                 buf[2] = '\0';
1411                 return 3;
1412         }
1413 }
1414
1415 static DEVICE_ATTR_ADMIN_RW(rtap_iface);
1416
1417 static ssize_t rtap_filter_store(struct device *d,
1418                          struct device_attribute *attr,
1419                          const char *buf, size_t count)
1420 {
1421         struct ipw_priv *priv = dev_get_drvdata(d);
1422
1423         if (!priv->prom_priv) {
1424                 IPW_ERROR("Attempting to set filter without "
1425                           "rtap_iface enabled.\n");
1426                 return -EPERM;
1427         }
1428
1429         priv->prom_priv->filter = simple_strtol(buf, NULL, 0);
1430
1431         IPW_DEBUG_INFO("Setting rtap filter to " BIT_FMT16 "\n",
1432                        BIT_ARG16(priv->prom_priv->filter));
1433
1434         return count;
1435 }
1436
1437 static ssize_t rtap_filter_show(struct device *d,
1438                         struct device_attribute *attr,
1439                         char *buf)
1440 {
1441         struct ipw_priv *priv = dev_get_drvdata(d);
1442         return sprintf(buf, "0x%04X",
1443                        priv->prom_priv ? priv->prom_priv->filter : 0);
1444 }
1445
1446 static DEVICE_ATTR_ADMIN_RW(rtap_filter);
1447 #endif
1448
1449 static ssize_t scan_age_show(struct device *d, struct device_attribute *attr,
1450                              char *buf)
1451 {
1452         struct ipw_priv *priv = dev_get_drvdata(d);
1453         return sprintf(buf, "%d\n", priv->ieee->scan_age);
1454 }
1455
1456 static ssize_t scan_age_store(struct device *d, struct device_attribute *attr,
1457                               const char *buf, size_t count)
1458 {
1459         struct ipw_priv *priv = dev_get_drvdata(d);
1460         struct net_device *dev = priv->net_dev;
1461
1462         IPW_DEBUG_INFO("enter\n");
1463
1464         unsigned long val;
1465         int result = kstrtoul(buf, 0, &val);
1466
1467         if (result == -EINVAL || result == -ERANGE) {
1468                 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
1469         } else {
1470                 priv->ieee->scan_age = val;
1471                 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
1472         }
1473
1474         IPW_DEBUG_INFO("exit\n");
1475         return count;
1476 }
1477
1478 static DEVICE_ATTR_RW(scan_age);
1479
1480 static ssize_t led_show(struct device *d, struct device_attribute *attr,
1481                         char *buf)
1482 {
1483         struct ipw_priv *priv = dev_get_drvdata(d);
1484         return sprintf(buf, "%d\n", (priv->config & CFG_NO_LED) ? 0 : 1);
1485 }
1486
1487 static ssize_t led_store(struct device *d, struct device_attribute *attr,
1488                          const char *buf, size_t count)
1489 {
1490         struct ipw_priv *priv = dev_get_drvdata(d);
1491
1492         IPW_DEBUG_INFO("enter\n");
1493
1494         if (count == 0)
1495                 return 0;
1496
1497         if (*buf == 0) {
1498                 IPW_DEBUG_LED("Disabling LED control.\n");
1499                 priv->config |= CFG_NO_LED;
1500                 ipw_led_shutdown(priv);
1501         } else {
1502                 IPW_DEBUG_LED("Enabling LED control.\n");
1503                 priv->config &= ~CFG_NO_LED;
1504                 ipw_led_init(priv);
1505         }
1506
1507         IPW_DEBUG_INFO("exit\n");
1508         return count;
1509 }
1510
1511 static DEVICE_ATTR_RW(led);
1512
1513 static ssize_t status_show(struct device *d,
1514                            struct device_attribute *attr, char *buf)
1515 {
1516         struct ipw_priv *p = dev_get_drvdata(d);
1517         return sprintf(buf, "0x%08x\n", (int)p->status);
1518 }
1519
1520 static DEVICE_ATTR_RO(status);
1521
1522 static ssize_t cfg_show(struct device *d, struct device_attribute *attr,
1523                         char *buf)
1524 {
1525         struct ipw_priv *p = dev_get_drvdata(d);
1526         return sprintf(buf, "0x%08x\n", (int)p->config);
1527 }
1528
1529 static DEVICE_ATTR_RO(cfg);
1530
1531 static ssize_t nic_type_show(struct device *d,
1532                              struct device_attribute *attr, char *buf)
1533 {
1534         struct ipw_priv *priv = dev_get_drvdata(d);
1535         return sprintf(buf, "TYPE: %d\n", priv->nic_type);
1536 }
1537
1538 static DEVICE_ATTR_RO(nic_type);
1539
1540 static ssize_t ucode_version_show(struct device *d,
1541                                   struct device_attribute *attr, char *buf)
1542 {
1543         u32 len = sizeof(u32), tmp = 0;
1544         struct ipw_priv *p = dev_get_drvdata(d);
1545
1546         if (ipw_get_ordinal(p, IPW_ORD_STAT_UCODE_VERSION, &tmp, &len))
1547                 return 0;
1548
1549         return sprintf(buf, "0x%08x\n", tmp);
1550 }
1551
1552 static DEVICE_ATTR_RO(ucode_version);
1553
1554 static ssize_t rtc_show(struct device *d, struct device_attribute *attr,
1555                         char *buf)
1556 {
1557         u32 len = sizeof(u32), tmp = 0;
1558         struct ipw_priv *p = dev_get_drvdata(d);
1559
1560         if (ipw_get_ordinal(p, IPW_ORD_STAT_RTC, &tmp, &len))
1561                 return 0;
1562
1563         return sprintf(buf, "0x%08x\n", tmp);
1564 }
1565
1566 static DEVICE_ATTR_RO(rtc);
1567
1568 /*
1569  * Add a device attribute to view/control the delay between eeprom
1570  * operations.
1571  */
1572 static ssize_t eeprom_delay_show(struct device *d,
1573                                  struct device_attribute *attr, char *buf)
1574 {
1575         struct ipw_priv *p = dev_get_drvdata(d);
1576         int n = p->eeprom_delay;
1577         return sprintf(buf, "%i\n", n);
1578 }
1579 static ssize_t eeprom_delay_store(struct device *d,
1580                                   struct device_attribute *attr,
1581                                   const char *buf, size_t count)
1582 {
1583         struct ipw_priv *p = dev_get_drvdata(d);
1584         sscanf(buf, "%i", &p->eeprom_delay);
1585         return strnlen(buf, count);
1586 }
1587
1588 static DEVICE_ATTR_RW(eeprom_delay);
1589
1590 static ssize_t command_event_reg_show(struct device *d,
1591                                       struct device_attribute *attr, char *buf)
1592 {
1593         u32 reg = 0;
1594         struct ipw_priv *p = dev_get_drvdata(d);
1595
1596         reg = ipw_read_reg32(p, IPW_INTERNAL_CMD_EVENT);
1597         return sprintf(buf, "0x%08x\n", reg);
1598 }
1599 static ssize_t command_event_reg_store(struct device *d,
1600                                        struct device_attribute *attr,
1601                                        const char *buf, size_t count)
1602 {
1603         u32 reg;
1604         struct ipw_priv *p = dev_get_drvdata(d);
1605
1606         sscanf(buf, "%x", &reg);
1607         ipw_write_reg32(p, IPW_INTERNAL_CMD_EVENT, reg);
1608         return strnlen(buf, count);
1609 }
1610
1611 static DEVICE_ATTR_RW(command_event_reg);
1612
1613 static ssize_t mem_gpio_reg_show(struct device *d,
1614                                  struct device_attribute *attr, char *buf)
1615 {
1616         u32 reg = 0;
1617         struct ipw_priv *p = dev_get_drvdata(d);
1618
1619         reg = ipw_read_reg32(p, 0x301100);
1620         return sprintf(buf, "0x%08x\n", reg);
1621 }
1622 static ssize_t mem_gpio_reg_store(struct device *d,
1623                                   struct device_attribute *attr,
1624                                   const char *buf, size_t count)
1625 {
1626         u32 reg;
1627         struct ipw_priv *p = dev_get_drvdata(d);
1628
1629         sscanf(buf, "%x", &reg);
1630         ipw_write_reg32(p, 0x301100, reg);
1631         return strnlen(buf, count);
1632 }
1633
1634 static DEVICE_ATTR_RW(mem_gpio_reg);
1635
1636 static ssize_t indirect_dword_show(struct device *d,
1637                                    struct device_attribute *attr, char *buf)
1638 {
1639         u32 reg = 0;
1640         struct ipw_priv *priv = dev_get_drvdata(d);
1641
1642         if (priv->status & STATUS_INDIRECT_DWORD)
1643                 reg = ipw_read_reg32(priv, priv->indirect_dword);
1644         else
1645                 reg = 0;
1646
1647         return sprintf(buf, "0x%08x\n", reg);
1648 }
1649 static ssize_t indirect_dword_store(struct device *d,
1650                                     struct device_attribute *attr,
1651                                     const char *buf, size_t count)
1652 {
1653         struct ipw_priv *priv = dev_get_drvdata(d);
1654
1655         sscanf(buf, "%x", &priv->indirect_dword);
1656         priv->status |= STATUS_INDIRECT_DWORD;
1657         return strnlen(buf, count);
1658 }
1659
1660 static DEVICE_ATTR_RW(indirect_dword);
1661
1662 static ssize_t indirect_byte_show(struct device *d,
1663                                   struct device_attribute *attr, char *buf)
1664 {
1665         u8 reg = 0;
1666         struct ipw_priv *priv = dev_get_drvdata(d);
1667
1668         if (priv->status & STATUS_INDIRECT_BYTE)
1669                 reg = ipw_read_reg8(priv, priv->indirect_byte);
1670         else
1671                 reg = 0;
1672
1673         return sprintf(buf, "0x%02x\n", reg);
1674 }
1675 static ssize_t indirect_byte_store(struct device *d,
1676                                    struct device_attribute *attr,
1677                                    const char *buf, size_t count)
1678 {
1679         struct ipw_priv *priv = dev_get_drvdata(d);
1680
1681         sscanf(buf, "%x", &priv->indirect_byte);
1682         priv->status |= STATUS_INDIRECT_BYTE;
1683         return strnlen(buf, count);
1684 }
1685
1686 static DEVICE_ATTR_RW(indirect_byte);
1687
1688 static ssize_t direct_dword_show(struct device *d,
1689                                  struct device_attribute *attr, char *buf)
1690 {
1691         u32 reg = 0;
1692         struct ipw_priv *priv = dev_get_drvdata(d);
1693
1694         if (priv->status & STATUS_DIRECT_DWORD)
1695                 reg = ipw_read32(priv, priv->direct_dword);
1696         else
1697                 reg = 0;
1698
1699         return sprintf(buf, "0x%08x\n", reg);
1700 }
1701 static ssize_t direct_dword_store(struct device *d,
1702                                   struct device_attribute *attr,
1703                                   const char *buf, size_t count)
1704 {
1705         struct ipw_priv *priv = dev_get_drvdata(d);
1706
1707         sscanf(buf, "%x", &priv->direct_dword);
1708         priv->status |= STATUS_DIRECT_DWORD;
1709         return strnlen(buf, count);
1710 }
1711
1712 static DEVICE_ATTR_RW(direct_dword);
1713
1714 static int rf_kill_active(struct ipw_priv *priv)
1715 {
1716         if (0 == (ipw_read32(priv, 0x30) & 0x10000)) {
1717                 priv->status |= STATUS_RF_KILL_HW;
1718                 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
1719         } else {
1720                 priv->status &= ~STATUS_RF_KILL_HW;
1721                 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, false);
1722         }
1723
1724         return (priv->status & STATUS_RF_KILL_HW) ? 1 : 0;
1725 }
1726
1727 static ssize_t rf_kill_show(struct device *d, struct device_attribute *attr,
1728                             char *buf)
1729 {
1730         /* 0 - RF kill not enabled
1731            1 - SW based RF kill active (sysfs)
1732            2 - HW based RF kill active
1733            3 - Both HW and SW baed RF kill active */
1734         struct ipw_priv *priv = dev_get_drvdata(d);
1735         int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
1736             (rf_kill_active(priv) ? 0x2 : 0x0);
1737         return sprintf(buf, "%i\n", val);
1738 }
1739
1740 static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
1741 {
1742         if ((disable_radio ? 1 : 0) ==
1743             ((priv->status & STATUS_RF_KILL_SW) ? 1 : 0))
1744                 return 0;
1745
1746         IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO  %s\n",
1747                           disable_radio ? "OFF" : "ON");
1748
1749         if (disable_radio) {
1750                 priv->status |= STATUS_RF_KILL_SW;
1751
1752                 cancel_delayed_work(&priv->request_scan);
1753                 cancel_delayed_work(&priv->request_direct_scan);
1754                 cancel_delayed_work(&priv->request_passive_scan);
1755                 cancel_delayed_work(&priv->scan_event);
1756                 schedule_work(&priv->down);
1757         } else {
1758                 priv->status &= ~STATUS_RF_KILL_SW;
1759                 if (rf_kill_active(priv)) {
1760                         IPW_DEBUG_RF_KILL("Can not turn radio back on - "
1761                                           "disabled by HW switch\n");
1762                         /* Make sure the RF_KILL check timer is running */
1763                         cancel_delayed_work(&priv->rf_kill);
1764                         schedule_delayed_work(&priv->rf_kill,
1765                                               round_jiffies_relative(2 * HZ));
1766                 } else
1767                         schedule_work(&priv->up);
1768         }
1769
1770         return 1;
1771 }
1772
1773 static ssize_t rf_kill_store(struct device *d, struct device_attribute *attr,
1774                              const char *buf, size_t count)
1775 {
1776         struct ipw_priv *priv = dev_get_drvdata(d);
1777
1778         ipw_radio_kill_sw(priv, buf[0] == '1');
1779
1780         return count;
1781 }
1782
1783 static DEVICE_ATTR_RW(rf_kill);
1784
1785 static ssize_t speed_scan_show(struct device *d, struct device_attribute *attr,
1786                                char *buf)
1787 {
1788         struct ipw_priv *priv = dev_get_drvdata(d);
1789         int pos = 0, len = 0;
1790         if (priv->config & CFG_SPEED_SCAN) {
1791                 while (priv->speed_scan[pos] != 0)
1792                         len += sprintf(&buf[len], "%d ",
1793                                        priv->speed_scan[pos++]);
1794                 return len + sprintf(&buf[len], "\n");
1795         }
1796
1797         return sprintf(buf, "0\n");
1798 }
1799
1800 static ssize_t speed_scan_store(struct device *d, struct device_attribute *attr,
1801                                 const char *buf, size_t count)
1802 {
1803         struct ipw_priv *priv = dev_get_drvdata(d);
1804         int channel, pos = 0;
1805         const char *p = buf;
1806
1807         /* list of space separated channels to scan, optionally ending with 0 */
1808         while ((channel = simple_strtol(p, NULL, 0))) {
1809                 if (pos == MAX_SPEED_SCAN - 1) {
1810                         priv->speed_scan[pos] = 0;
1811                         break;
1812                 }
1813
1814                 if (libipw_is_valid_channel(priv->ieee, channel))
1815                         priv->speed_scan[pos++] = channel;
1816                 else
1817                         IPW_WARNING("Skipping invalid channel request: %d\n",
1818                                     channel);
1819                 p = strchr(p, ' ');
1820                 if (!p)
1821                         break;
1822                 while (*p == ' ' || *p == '\t')
1823                         p++;
1824         }
1825
1826         if (pos == 0)
1827                 priv->config &= ~CFG_SPEED_SCAN;
1828         else {
1829                 priv->speed_scan_pos = 0;
1830                 priv->config |= CFG_SPEED_SCAN;
1831         }
1832
1833         return count;
1834 }
1835
1836 static DEVICE_ATTR_RW(speed_scan);
1837
1838 static ssize_t net_stats_show(struct device *d, struct device_attribute *attr,
1839                               char *buf)
1840 {
1841         struct ipw_priv *priv = dev_get_drvdata(d);
1842         return sprintf(buf, "%c\n", (priv->config & CFG_NET_STATS) ? '1' : '0');
1843 }
1844
1845 static ssize_t net_stats_store(struct device *d, struct device_attribute *attr,
1846                                const char *buf, size_t count)
1847 {
1848         struct ipw_priv *priv = dev_get_drvdata(d);
1849         if (buf[0] == '1')
1850                 priv->config |= CFG_NET_STATS;
1851         else
1852                 priv->config &= ~CFG_NET_STATS;
1853
1854         return count;
1855 }
1856
1857 static DEVICE_ATTR_RW(net_stats);
1858
1859 static ssize_t channels_show(struct device *d,
1860                              struct device_attribute *attr,
1861                              char *buf)
1862 {
1863         struct ipw_priv *priv = dev_get_drvdata(d);
1864         const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
1865         int len = 0, i;
1866
1867         len = sprintf(&buf[len],
1868                       "Displaying %d channels in 2.4Ghz band "
1869                       "(802.11bg):\n", geo->bg_channels);
1870
1871         for (i = 0; i < geo->bg_channels; i++) {
1872                 len += sprintf(&buf[len], "%d: BSS%s%s, %s, Band %s.\n",
1873                                geo->bg[i].channel,
1874                                geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT ?
1875                                " (radar spectrum)" : "",
1876                                ((geo->bg[i].flags & LIBIPW_CH_NO_IBSS) ||
1877                                 (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT))
1878                                ? "" : ", IBSS",
1879                                geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY ?
1880                                "passive only" : "active/passive",
1881                                geo->bg[i].flags & LIBIPW_CH_B_ONLY ?
1882                                "B" : "B/G");
1883         }
1884
1885         len += sprintf(&buf[len],
1886                        "Displaying %d channels in 5.2Ghz band "
1887                        "(802.11a):\n", geo->a_channels);
1888         for (i = 0; i < geo->a_channels; i++) {
1889                 len += sprintf(&buf[len], "%d: BSS%s%s, %s.\n",
1890                                geo->a[i].channel,
1891                                geo->a[i].flags & LIBIPW_CH_RADAR_DETECT ?
1892                                " (radar spectrum)" : "",
1893                                ((geo->a[i].flags & LIBIPW_CH_NO_IBSS) ||
1894                                 (geo->a[i].flags & LIBIPW_CH_RADAR_DETECT))
1895                                ? "" : ", IBSS",
1896                                geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY ?
1897                                "passive only" : "active/passive");
1898         }
1899
1900         return len;
1901 }
1902
1903 static DEVICE_ATTR_ADMIN_RO(channels);
1904
1905 static void notify_wx_assoc_event(struct ipw_priv *priv)
1906 {
1907         union iwreq_data wrqu;
1908         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1909         if (priv->status & STATUS_ASSOCIATED)
1910                 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
1911         else
1912                 eth_zero_addr(wrqu.ap_addr.sa_data);
1913         wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1914 }
1915
1916 static void ipw_irq_tasklet(struct tasklet_struct *t)
1917 {
1918         struct ipw_priv *priv = from_tasklet(priv, t, irq_tasklet);
1919         u32 inta, inta_mask, handled = 0;
1920         unsigned long flags;
1921
1922         spin_lock_irqsave(&priv->irq_lock, flags);
1923
1924         inta = ipw_read32(priv, IPW_INTA_RW);
1925         inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
1926
1927         if (inta == 0xFFFFFFFF) {
1928                 /* Hardware disappeared */
1929                 IPW_WARNING("TASKLET INTA == 0xFFFFFFFF\n");
1930                 /* Only handle the cached INTA values */
1931                 inta = 0;
1932         }
1933         inta &= (IPW_INTA_MASK_ALL & inta_mask);
1934
1935         /* Add any cached INTA values that need to be handled */
1936         inta |= priv->isr_inta;
1937
1938         spin_unlock_irqrestore(&priv->irq_lock, flags);
1939
1940         spin_lock_irqsave(&priv->lock, flags);
1941
1942         /* handle all the justifications for the interrupt */
1943         if (inta & IPW_INTA_BIT_RX_TRANSFER) {
1944                 ipw_rx(priv);
1945                 handled |= IPW_INTA_BIT_RX_TRANSFER;
1946         }
1947
1948         if (inta & IPW_INTA_BIT_TX_CMD_QUEUE) {
1949                 IPW_DEBUG_HC("Command completed.\n");
1950                 ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1);
1951                 priv->status &= ~STATUS_HCMD_ACTIVE;
1952                 wake_up_interruptible(&priv->wait_command_queue);
1953                 handled |= IPW_INTA_BIT_TX_CMD_QUEUE;
1954         }
1955
1956         if (inta & IPW_INTA_BIT_TX_QUEUE_1) {
1957                 IPW_DEBUG_TX("TX_QUEUE_1\n");
1958                 ipw_queue_tx_reclaim(priv, &priv->txq[0], 0);
1959                 handled |= IPW_INTA_BIT_TX_QUEUE_1;
1960         }
1961
1962         if (inta & IPW_INTA_BIT_TX_QUEUE_2) {
1963                 IPW_DEBUG_TX("TX_QUEUE_2\n");
1964                 ipw_queue_tx_reclaim(priv, &priv->txq[1], 1);
1965                 handled |= IPW_INTA_BIT_TX_QUEUE_2;
1966         }
1967
1968         if (inta & IPW_INTA_BIT_TX_QUEUE_3) {
1969                 IPW_DEBUG_TX("TX_QUEUE_3\n");
1970                 ipw_queue_tx_reclaim(priv, &priv->txq[2], 2);
1971                 handled |= IPW_INTA_BIT_TX_QUEUE_3;
1972         }
1973
1974         if (inta & IPW_INTA_BIT_TX_QUEUE_4) {
1975                 IPW_DEBUG_TX("TX_QUEUE_4\n");
1976                 ipw_queue_tx_reclaim(priv, &priv->txq[3], 3);
1977                 handled |= IPW_INTA_BIT_TX_QUEUE_4;
1978         }
1979
1980         if (inta & IPW_INTA_BIT_STATUS_CHANGE) {
1981                 IPW_WARNING("STATUS_CHANGE\n");
1982                 handled |= IPW_INTA_BIT_STATUS_CHANGE;
1983         }
1984
1985         if (inta & IPW_INTA_BIT_BEACON_PERIOD_EXPIRED) {
1986                 IPW_WARNING("TX_PERIOD_EXPIRED\n");
1987                 handled |= IPW_INTA_BIT_BEACON_PERIOD_EXPIRED;
1988         }
1989
1990         if (inta & IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE) {
1991                 IPW_WARNING("HOST_CMD_DONE\n");
1992                 handled |= IPW_INTA_BIT_SLAVE_MODE_HOST_CMD_DONE;
1993         }
1994
1995         if (inta & IPW_INTA_BIT_FW_INITIALIZATION_DONE) {
1996                 IPW_WARNING("FW_INITIALIZATION_DONE\n");
1997                 handled |= IPW_INTA_BIT_FW_INITIALIZATION_DONE;
1998         }
1999
2000         if (inta & IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE) {
2001                 IPW_WARNING("PHY_OFF_DONE\n");
2002                 handled |= IPW_INTA_BIT_FW_CARD_DISABLE_PHY_OFF_DONE;
2003         }
2004
2005         if (inta & IPW_INTA_BIT_RF_KILL_DONE) {
2006                 IPW_DEBUG_RF_KILL("RF_KILL_DONE\n");
2007                 priv->status |= STATUS_RF_KILL_HW;
2008                 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
2009                 wake_up_interruptible(&priv->wait_command_queue);
2010                 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
2011                 cancel_delayed_work(&priv->request_scan);
2012                 cancel_delayed_work(&priv->request_direct_scan);
2013                 cancel_delayed_work(&priv->request_passive_scan);
2014                 cancel_delayed_work(&priv->scan_event);
2015                 schedule_work(&priv->link_down);
2016                 schedule_delayed_work(&priv->rf_kill, 2 * HZ);
2017                 handled |= IPW_INTA_BIT_RF_KILL_DONE;
2018         }
2019
2020         if (inta & IPW_INTA_BIT_FATAL_ERROR) {
2021                 IPW_WARNING("Firmware error detected.  Restarting.\n");
2022                 if (priv->error) {
2023                         IPW_DEBUG_FW("Sysfs 'error' log already exists.\n");
2024                         if (ipw_debug_level & IPW_DL_FW_ERRORS) {
2025                                 struct ipw_fw_error *error =
2026                                     ipw_alloc_error_log(priv);
2027                                 ipw_dump_error_log(priv, error);
2028                                 kfree(error);
2029                         }
2030                 } else {
2031                         priv->error = ipw_alloc_error_log(priv);
2032                         if (priv->error)
2033                                 IPW_DEBUG_FW("Sysfs 'error' log captured.\n");
2034                         else
2035                                 IPW_DEBUG_FW("Error allocating sysfs 'error' "
2036                                              "log.\n");
2037                         if (ipw_debug_level & IPW_DL_FW_ERRORS)
2038                                 ipw_dump_error_log(priv, priv->error);
2039                 }
2040
2041                 /* XXX: If hardware encryption is for WPA/WPA2,
2042                  * we have to notify the supplicant. */
2043                 if (priv->ieee->sec.encrypt) {
2044                         priv->status &= ~STATUS_ASSOCIATED;
2045                         notify_wx_assoc_event(priv);
2046                 }
2047
2048                 /* Keep the restart process from trying to send host
2049                  * commands by clearing the INIT status bit */
2050                 priv->status &= ~STATUS_INIT;
2051
2052                 /* Cancel currently queued command. */
2053                 priv->status &= ~STATUS_HCMD_ACTIVE;
2054                 wake_up_interruptible(&priv->wait_command_queue);
2055
2056                 schedule_work(&priv->adapter_restart);
2057                 handled |= IPW_INTA_BIT_FATAL_ERROR;
2058         }
2059
2060         if (inta & IPW_INTA_BIT_PARITY_ERROR) {
2061                 IPW_ERROR("Parity error\n");
2062                 handled |= IPW_INTA_BIT_PARITY_ERROR;
2063         }
2064
2065         if (handled != inta) {
2066                 IPW_ERROR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
2067         }
2068
2069         spin_unlock_irqrestore(&priv->lock, flags);
2070
2071         /* enable all interrupts */
2072         ipw_enable_interrupts(priv);
2073 }
2074
2075 #define IPW_CMD(x) case IPW_CMD_ ## x : return #x
2076 static char *get_cmd_string(u8 cmd)
2077 {
2078         switch (cmd) {
2079                 IPW_CMD(HOST_COMPLETE);
2080                 IPW_CMD(POWER_DOWN);
2081                 IPW_CMD(SYSTEM_CONFIG);
2082                 IPW_CMD(MULTICAST_ADDRESS);
2083                 IPW_CMD(SSID);
2084                 IPW_CMD(ADAPTER_ADDRESS);
2085                 IPW_CMD(PORT_TYPE);
2086                 IPW_CMD(RTS_THRESHOLD);
2087                 IPW_CMD(FRAG_THRESHOLD);
2088                 IPW_CMD(POWER_MODE);
2089                 IPW_CMD(WEP_KEY);
2090                 IPW_CMD(TGI_TX_KEY);
2091                 IPW_CMD(SCAN_REQUEST);
2092                 IPW_CMD(SCAN_REQUEST_EXT);
2093                 IPW_CMD(ASSOCIATE);
2094                 IPW_CMD(SUPPORTED_RATES);
2095                 IPW_CMD(SCAN_ABORT);
2096                 IPW_CMD(TX_FLUSH);
2097                 IPW_CMD(QOS_PARAMETERS);
2098                 IPW_CMD(DINO_CONFIG);
2099                 IPW_CMD(RSN_CAPABILITIES);
2100                 IPW_CMD(RX_KEY);
2101                 IPW_CMD(CARD_DISABLE);
2102                 IPW_CMD(SEED_NUMBER);
2103                 IPW_CMD(TX_POWER);
2104                 IPW_CMD(COUNTRY_INFO);
2105                 IPW_CMD(AIRONET_INFO);
2106                 IPW_CMD(AP_TX_POWER);
2107                 IPW_CMD(CCKM_INFO);
2108                 IPW_CMD(CCX_VER_INFO);
2109                 IPW_CMD(SET_CALIBRATION);
2110                 IPW_CMD(SENSITIVITY_CALIB);
2111                 IPW_CMD(RETRY_LIMIT);
2112                 IPW_CMD(IPW_PRE_POWER_DOWN);
2113                 IPW_CMD(VAP_BEACON_TEMPLATE);
2114                 IPW_CMD(VAP_DTIM_PERIOD);
2115                 IPW_CMD(EXT_SUPPORTED_RATES);
2116                 IPW_CMD(VAP_LOCAL_TX_PWR_CONSTRAINT);
2117                 IPW_CMD(VAP_QUIET_INTERVALS);
2118                 IPW_CMD(VAP_CHANNEL_SWITCH);
2119                 IPW_CMD(VAP_MANDATORY_CHANNELS);
2120                 IPW_CMD(VAP_CELL_PWR_LIMIT);
2121                 IPW_CMD(VAP_CF_PARAM_SET);
2122                 IPW_CMD(VAP_SET_BEACONING_STATE);
2123                 IPW_CMD(MEASUREMENT);
2124                 IPW_CMD(POWER_CAPABILITY);
2125                 IPW_CMD(SUPPORTED_CHANNELS);
2126                 IPW_CMD(TPC_REPORT);
2127                 IPW_CMD(WME_INFO);
2128                 IPW_CMD(PRODUCTION_COMMAND);
2129         default:
2130                 return "UNKNOWN";
2131         }
2132 }
2133
2134 #define HOST_COMPLETE_TIMEOUT HZ
2135
2136 static int __ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
2137 {
2138         int rc = 0;
2139         unsigned long flags;
2140         unsigned long now, end;
2141
2142         spin_lock_irqsave(&priv->lock, flags);
2143         if (priv->status & STATUS_HCMD_ACTIVE) {
2144                 IPW_ERROR("Failed to send %s: Already sending a command.\n",
2145                           get_cmd_string(cmd->cmd));
2146                 spin_unlock_irqrestore(&priv->lock, flags);
2147                 return -EAGAIN;
2148         }
2149
2150         priv->status |= STATUS_HCMD_ACTIVE;
2151
2152         if (priv->cmdlog) {
2153                 priv->cmdlog[priv->cmdlog_pos].jiffies = jiffies;
2154                 priv->cmdlog[priv->cmdlog_pos].cmd.cmd = cmd->cmd;
2155                 priv->cmdlog[priv->cmdlog_pos].cmd.len = cmd->len;
2156                 memcpy(priv->cmdlog[priv->cmdlog_pos].cmd.param, cmd->param,
2157                        cmd->len);
2158                 priv->cmdlog[priv->cmdlog_pos].retcode = -1;
2159         }
2160
2161         IPW_DEBUG_HC("%s command (#%d) %d bytes: 0x%08X\n",
2162                      get_cmd_string(cmd->cmd), cmd->cmd, cmd->len,
2163                      priv->status);
2164
2165 #ifndef DEBUG_CMD_WEP_KEY
2166         if (cmd->cmd == IPW_CMD_WEP_KEY)
2167                 IPW_DEBUG_HC("WEP_KEY command masked out for secure.\n");
2168         else
2169 #endif
2170                 printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
2171
2172         rc = ipw_queue_tx_hcmd(priv, cmd->cmd, cmd->param, cmd->len, 0);
2173         if (rc) {
2174                 priv->status &= ~STATUS_HCMD_ACTIVE;
2175                 IPW_ERROR("Failed to send %s: Reason %d\n",
2176                           get_cmd_string(cmd->cmd), rc);
2177                 spin_unlock_irqrestore(&priv->lock, flags);
2178                 goto exit;
2179         }
2180         spin_unlock_irqrestore(&priv->lock, flags);
2181
2182         now = jiffies;
2183         end = now + HOST_COMPLETE_TIMEOUT;
2184 again:
2185         rc = wait_event_interruptible_timeout(priv->wait_command_queue,
2186                                               !(priv->
2187                                                 status & STATUS_HCMD_ACTIVE),
2188                                               end - now);
2189         if (rc < 0) {
2190                 now = jiffies;
2191                 if (time_before(now, end))
2192                         goto again;
2193                 rc = 0;
2194         }
2195
2196         if (rc == 0) {
2197                 spin_lock_irqsave(&priv->lock, flags);
2198                 if (priv->status & STATUS_HCMD_ACTIVE) {
2199                         IPW_ERROR("Failed to send %s: Command timed out.\n",
2200                                   get_cmd_string(cmd->cmd));
2201                         priv->status &= ~STATUS_HCMD_ACTIVE;
2202                         spin_unlock_irqrestore(&priv->lock, flags);
2203                         rc = -EIO;
2204                         goto exit;
2205                 }
2206                 spin_unlock_irqrestore(&priv->lock, flags);
2207         } else
2208                 rc = 0;
2209
2210         if (priv->status & STATUS_RF_KILL_HW) {
2211                 IPW_ERROR("Failed to send %s: Aborted due to RF kill switch.\n",
2212                           get_cmd_string(cmd->cmd));
2213                 rc = -EIO;
2214                 goto exit;
2215         }
2216
2217       exit:
2218         if (priv->cmdlog) {
2219                 priv->cmdlog[priv->cmdlog_pos++].retcode = rc;
2220                 priv->cmdlog_pos %= priv->cmdlog_len;
2221         }
2222         return rc;
2223 }
2224
2225 static int ipw_send_cmd_simple(struct ipw_priv *priv, u8 command)
2226 {
2227         struct host_cmd cmd = {
2228                 .cmd = command,
2229         };
2230
2231         return __ipw_send_cmd(priv, &cmd);
2232 }
2233
2234 static int ipw_send_cmd_pdu(struct ipw_priv *priv, u8 command, u8 len,
2235                             const void *data)
2236 {
2237         struct host_cmd cmd = {
2238                 .cmd = command,
2239                 .len = len,
2240                 .param = data,
2241         };
2242
2243         return __ipw_send_cmd(priv, &cmd);
2244 }
2245
2246 static int ipw_send_host_complete(struct ipw_priv *priv)
2247 {
2248         if (!priv) {
2249                 IPW_ERROR("Invalid args\n");
2250                 return -1;
2251         }
2252
2253         return ipw_send_cmd_simple(priv, IPW_CMD_HOST_COMPLETE);
2254 }
2255
2256 static int ipw_send_system_config(struct ipw_priv *priv)
2257 {
2258         return ipw_send_cmd_pdu(priv, IPW_CMD_SYSTEM_CONFIG,
2259                                 sizeof(priv->sys_config),
2260                                 &priv->sys_config);
2261 }
2262
2263 static int ipw_send_ssid(struct ipw_priv *priv, u8 * ssid, int len)
2264 {
2265         if (!priv || !ssid) {
2266                 IPW_ERROR("Invalid args\n");
2267                 return -1;
2268         }
2269
2270         return ipw_send_cmd_pdu(priv, IPW_CMD_SSID, min(len, IW_ESSID_MAX_SIZE),
2271                                 ssid);
2272 }
2273
2274 static int ipw_send_adapter_address(struct ipw_priv *priv, const u8 * mac)
2275 {
2276         if (!priv || !mac) {
2277                 IPW_ERROR("Invalid args\n");
2278                 return -1;
2279         }
2280
2281         IPW_DEBUG_INFO("%s: Setting MAC to %pM\n",
2282                        priv->net_dev->name, mac);
2283
2284         return ipw_send_cmd_pdu(priv, IPW_CMD_ADAPTER_ADDRESS, ETH_ALEN, mac);
2285 }
2286
2287 static void ipw_adapter_restart(void *adapter)
2288 {
2289         struct ipw_priv *priv = adapter;
2290
2291         if (priv->status & STATUS_RF_KILL_MASK)
2292                 return;
2293
2294         ipw_down(priv);
2295
2296         if (priv->assoc_network &&
2297             (priv->assoc_network->capability & WLAN_CAPABILITY_IBSS))
2298                 ipw_remove_current_network(priv);
2299
2300         if (ipw_up(priv)) {
2301                 IPW_ERROR("Failed to up device\n");
2302                 return;
2303         }
2304 }
2305
2306 static void ipw_bg_adapter_restart(struct work_struct *work)
2307 {
2308         struct ipw_priv *priv =
2309                 container_of(work, struct ipw_priv, adapter_restart);
2310         mutex_lock(&priv->mutex);
2311         ipw_adapter_restart(priv);
2312         mutex_unlock(&priv->mutex);
2313 }
2314
2315 static void ipw_abort_scan(struct ipw_priv *priv);
2316
2317 #define IPW_SCAN_CHECK_WATCHDOG (5 * HZ)
2318
2319 static void ipw_scan_check(void *data)
2320 {
2321         struct ipw_priv *priv = data;
2322
2323         if (priv->status & STATUS_SCAN_ABORTING) {
2324                 IPW_DEBUG_SCAN("Scan completion watchdog resetting "
2325                                "adapter after (%dms).\n",
2326                                jiffies_to_msecs(IPW_SCAN_CHECK_WATCHDOG));
2327                 schedule_work(&priv->adapter_restart);
2328         } else if (priv->status & STATUS_SCANNING) {
2329                 IPW_DEBUG_SCAN("Scan completion watchdog aborting scan "
2330                                "after (%dms).\n",
2331                                jiffies_to_msecs(IPW_SCAN_CHECK_WATCHDOG));
2332                 ipw_abort_scan(priv);
2333                 schedule_delayed_work(&priv->scan_check, HZ);
2334         }
2335 }
2336
2337 static void ipw_bg_scan_check(struct work_struct *work)
2338 {
2339         struct ipw_priv *priv =
2340                 container_of(work, struct ipw_priv, scan_check.work);
2341         mutex_lock(&priv->mutex);
2342         ipw_scan_check(priv);
2343         mutex_unlock(&priv->mutex);
2344 }
2345
2346 static int ipw_send_scan_request_ext(struct ipw_priv *priv,
2347                                      struct ipw_scan_request_ext *request)
2348 {
2349         return ipw_send_cmd_pdu(priv, IPW_CMD_SCAN_REQUEST_EXT,
2350                                 sizeof(*request), request);
2351 }
2352
2353 static int ipw_send_scan_abort(struct ipw_priv *priv)
2354 {
2355         if (!priv) {
2356                 IPW_ERROR("Invalid args\n");
2357                 return -1;
2358         }
2359
2360         return ipw_send_cmd_simple(priv, IPW_CMD_SCAN_ABORT);
2361 }
2362
2363 static int ipw_set_sensitivity(struct ipw_priv *priv, u16 sens)
2364 {
2365         struct ipw_sensitivity_calib calib = {
2366                 .beacon_rssi_raw = cpu_to_le16(sens),
2367         };
2368
2369         return ipw_send_cmd_pdu(priv, IPW_CMD_SENSITIVITY_CALIB, sizeof(calib),
2370                                 &calib);
2371 }
2372
2373 static int ipw_send_associate(struct ipw_priv *priv,
2374                               struct ipw_associate *associate)
2375 {
2376         if (!priv || !associate) {
2377                 IPW_ERROR("Invalid args\n");
2378                 return -1;
2379         }
2380
2381         return ipw_send_cmd_pdu(priv, IPW_CMD_ASSOCIATE, sizeof(*associate),
2382                                 associate);
2383 }
2384
2385 static int ipw_send_supported_rates(struct ipw_priv *priv,
2386                                     struct ipw_supported_rates *rates)
2387 {
2388         if (!priv || !rates) {
2389                 IPW_ERROR("Invalid args\n");
2390                 return -1;
2391         }
2392
2393         return ipw_send_cmd_pdu(priv, IPW_CMD_SUPPORTED_RATES, sizeof(*rates),
2394                                 rates);
2395 }
2396
2397 static int ipw_set_random_seed(struct ipw_priv *priv)
2398 {
2399         u32 val;
2400
2401         if (!priv) {
2402                 IPW_ERROR("Invalid args\n");
2403                 return -1;
2404         }
2405
2406         get_random_bytes(&val, sizeof(val));
2407
2408         return ipw_send_cmd_pdu(priv, IPW_CMD_SEED_NUMBER, sizeof(val), &val);
2409 }
2410
2411 static int ipw_send_card_disable(struct ipw_priv *priv, u32 phy_off)
2412 {
2413         __le32 v = cpu_to_le32(phy_off);
2414         if (!priv) {
2415                 IPW_ERROR("Invalid args\n");
2416                 return -1;
2417         }
2418
2419         return ipw_send_cmd_pdu(priv, IPW_CMD_CARD_DISABLE, sizeof(v), &v);
2420 }
2421
2422 static int ipw_send_tx_power(struct ipw_priv *priv, struct ipw_tx_power *power)
2423 {
2424         if (!priv || !power) {
2425                 IPW_ERROR("Invalid args\n");
2426                 return -1;
2427         }
2428
2429         return ipw_send_cmd_pdu(priv, IPW_CMD_TX_POWER, sizeof(*power), power);
2430 }
2431
2432 static int ipw_set_tx_power(struct ipw_priv *priv)
2433 {
2434         const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
2435         struct ipw_tx_power tx_power;
2436         s8 max_power;
2437         int i;
2438
2439         memset(&tx_power, 0, sizeof(tx_power));
2440
2441         /* configure device for 'G' band */
2442         tx_power.ieee_mode = IPW_G_MODE;
2443         tx_power.num_channels = geo->bg_channels;
2444         for (i = 0; i < geo->bg_channels; i++) {
2445                 max_power = geo->bg[i].max_power;
2446                 tx_power.channels_tx_power[i].channel_number =
2447                     geo->bg[i].channel;
2448                 tx_power.channels_tx_power[i].tx_power = max_power ?
2449                     min(max_power, priv->tx_power) : priv->tx_power;
2450         }
2451         if (ipw_send_tx_power(priv, &tx_power))
2452                 return -EIO;
2453
2454         /* configure device to also handle 'B' band */
2455         tx_power.ieee_mode = IPW_B_MODE;
2456         if (ipw_send_tx_power(priv, &tx_power))
2457                 return -EIO;
2458
2459         /* configure device to also handle 'A' band */
2460         if (priv->ieee->abg_true) {
2461                 tx_power.ieee_mode = IPW_A_MODE;
2462                 tx_power.num_channels = geo->a_channels;
2463                 for (i = 0; i < tx_power.num_channels; i++) {
2464                         max_power = geo->a[i].max_power;
2465                         tx_power.channels_tx_power[i].channel_number =
2466                             geo->a[i].channel;
2467                         tx_power.channels_tx_power[i].tx_power = max_power ?
2468                             min(max_power, priv->tx_power) : priv->tx_power;
2469                 }
2470                 if (ipw_send_tx_power(priv, &tx_power))
2471                         return -EIO;
2472         }
2473         return 0;
2474 }
2475
2476 static int ipw_send_rts_threshold(struct ipw_priv *priv, u16 rts)
2477 {
2478         struct ipw_rts_threshold rts_threshold = {
2479                 .rts_threshold = cpu_to_le16(rts),
2480         };
2481
2482         if (!priv) {
2483                 IPW_ERROR("Invalid args\n");
2484                 return -1;
2485         }
2486
2487         return ipw_send_cmd_pdu(priv, IPW_CMD_RTS_THRESHOLD,
2488                                 sizeof(rts_threshold), &rts_threshold);
2489 }
2490
2491 static int ipw_send_frag_threshold(struct ipw_priv *priv, u16 frag)
2492 {
2493         struct ipw_frag_threshold frag_threshold = {
2494                 .frag_threshold = cpu_to_le16(frag),
2495         };
2496
2497         if (!priv) {
2498                 IPW_ERROR("Invalid args\n");
2499                 return -1;
2500         }
2501
2502         return ipw_send_cmd_pdu(priv, IPW_CMD_FRAG_THRESHOLD,
2503                                 sizeof(frag_threshold), &frag_threshold);
2504 }
2505
2506 static int ipw_send_power_mode(struct ipw_priv *priv, u32 mode)
2507 {
2508         __le32 param;
2509
2510         if (!priv) {
2511                 IPW_ERROR("Invalid args\n");
2512                 return -1;
2513         }
2514
2515         /* If on battery, set to 3, if AC set to CAM, else user
2516          * level */
2517         switch (mode) {
2518         case IPW_POWER_BATTERY:
2519                 param = cpu_to_le32(IPW_POWER_INDEX_3);
2520                 break;
2521         case IPW_POWER_AC:
2522                 param = cpu_to_le32(IPW_POWER_MODE_CAM);
2523                 break;
2524         default:
2525                 param = cpu_to_le32(mode);
2526                 break;
2527         }
2528
2529         return ipw_send_cmd_pdu(priv, IPW_CMD_POWER_MODE, sizeof(param),
2530                                 &param);
2531 }
2532
2533 static int ipw_send_retry_limit(struct ipw_priv *priv, u8 slimit, u8 llimit)
2534 {
2535         struct ipw_retry_limit retry_limit = {
2536                 .short_retry_limit = slimit,
2537                 .long_retry_limit = llimit
2538         };
2539
2540         if (!priv) {
2541                 IPW_ERROR("Invalid args\n");
2542                 return -1;
2543         }
2544
2545         return ipw_send_cmd_pdu(priv, IPW_CMD_RETRY_LIMIT, sizeof(retry_limit),
2546                                 &retry_limit);
2547 }
2548
2549 /*
2550  * The IPW device contains a Microwire compatible EEPROM that stores
2551  * various data like the MAC address.  Usually the firmware has exclusive
2552  * access to the eeprom, but during device initialization (before the
2553  * device driver has sent the HostComplete command to the firmware) the
2554  * device driver has read access to the EEPROM by way of indirect addressing
2555  * through a couple of memory mapped registers.
2556  *
2557  * The following is a simplified implementation for pulling data out of the
2558  * eeprom, along with some helper functions to find information in
2559  * the per device private data's copy of the eeprom.
2560  *
2561  * NOTE: To better understand how these functions work (i.e what is a chip
2562  *       select and why do have to keep driving the eeprom clock?), read
2563  *       just about any data sheet for a Microwire compatible EEPROM.
2564  */
2565
2566 /* write a 32 bit value into the indirect accessor register */
2567 static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
2568 {
2569         ipw_write_reg32(p, FW_MEM_REG_EEPROM_ACCESS, data);
2570
2571         /* the eeprom requires some time to complete the operation */
2572         udelay(p->eeprom_delay);
2573 }
2574
2575 /* perform a chip select operation */
2576 static void eeprom_cs(struct ipw_priv *priv)
2577 {
2578         eeprom_write_reg(priv, 0);
2579         eeprom_write_reg(priv, EEPROM_BIT_CS);
2580         eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2581         eeprom_write_reg(priv, EEPROM_BIT_CS);
2582 }
2583
2584 /* perform a chip select operation */
2585 static void eeprom_disable_cs(struct ipw_priv *priv)
2586 {
2587         eeprom_write_reg(priv, EEPROM_BIT_CS);
2588         eeprom_write_reg(priv, 0);
2589         eeprom_write_reg(priv, EEPROM_BIT_SK);
2590 }
2591
2592 /* push a single bit down to the eeprom */
2593 static inline void eeprom_write_bit(struct ipw_priv *p, u8 bit)
2594 {
2595         int d = (bit ? EEPROM_BIT_DI : 0);
2596         eeprom_write_reg(p, EEPROM_BIT_CS | d);
2597         eeprom_write_reg(p, EEPROM_BIT_CS | d | EEPROM_BIT_SK);
2598 }
2599
2600 /* push an opcode followed by an address down to the eeprom */
2601 static void eeprom_op(struct ipw_priv *priv, u8 op, u8 addr)
2602 {
2603         int i;
2604
2605         eeprom_cs(priv);
2606         eeprom_write_bit(priv, 1);
2607         eeprom_write_bit(priv, op & 2);
2608         eeprom_write_bit(priv, op & 1);
2609         for (i = 7; i >= 0; i--) {
2610                 eeprom_write_bit(priv, addr & (1 << i));
2611         }
2612 }
2613
2614 /* pull 16 bits off the eeprom, one bit at a time */
2615 static u16 eeprom_read_u16(struct ipw_priv *priv, u8 addr)
2616 {
2617         int i;
2618         u16 r = 0;
2619
2620         /* Send READ Opcode */
2621         eeprom_op(priv, EEPROM_CMD_READ, addr);
2622
2623         /* Send dummy bit */
2624         eeprom_write_reg(priv, EEPROM_BIT_CS);
2625
2626         /* Read the byte off the eeprom one bit at a time */
2627         for (i = 0; i < 16; i++) {
2628                 u32 data = 0;
2629                 eeprom_write_reg(priv, EEPROM_BIT_CS | EEPROM_BIT_SK);
2630                 eeprom_write_reg(priv, EEPROM_BIT_CS);
2631                 data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
2632                 r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
2633         }
2634
2635         /* Send another dummy bit */
2636         eeprom_write_reg(priv, 0);
2637         eeprom_disable_cs(priv);
2638
2639         return r;
2640 }
2641
2642 /* helper function for pulling the mac address out of the private */
2643 /* data's copy of the eeprom data                                 */
2644 static void eeprom_parse_mac(struct ipw_priv *priv, u8 * mac)
2645 {
2646         memcpy(mac, &priv->eeprom[EEPROM_MAC_ADDRESS], ETH_ALEN);
2647 }
2648
2649 static void ipw_read_eeprom(struct ipw_priv *priv)
2650 {
2651         int i;
2652         __le16 *eeprom = (__le16 *) priv->eeprom;
2653
2654         IPW_DEBUG_TRACE(">>\n");
2655
2656         /* read entire contents of eeprom into private buffer */
2657         for (i = 0; i < 128; i++)
2658                 eeprom[i] = cpu_to_le16(eeprom_read_u16(priv, (u8) i));
2659
2660         IPW_DEBUG_TRACE("<<\n");
2661 }
2662
2663 /*
2664  * Either the device driver (i.e. the host) or the firmware can
2665  * load eeprom data into the designated region in SRAM.  If neither
2666  * happens then the FW will shutdown with a fatal error.
2667  *
2668  * In order to signal the FW to load the EEPROM, the EEPROM_LOAD_DISABLE
2669  * bit needs region of shared SRAM needs to be non-zero.
2670  */
2671 static void ipw_eeprom_init_sram(struct ipw_priv *priv)
2672 {
2673         int i;
2674
2675         IPW_DEBUG_TRACE(">>\n");
2676
2677         /*
2678            If the data looks correct, then copy it to our private
2679            copy.  Otherwise let the firmware know to perform the operation
2680            on its own.
2681          */
2682         if (priv->eeprom[EEPROM_VERSION] != 0) {
2683                 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
2684
2685                 /* write the eeprom data to sram */
2686                 for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
2687                         ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
2688
2689                 /* Do not load eeprom data on fatal error or suspend */
2690                 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
2691         } else {
2692                 IPW_DEBUG_INFO("Enabling FW initialization of SRAM\n");
2693
2694                 /* Load eeprom data on fatal error or suspend */
2695                 ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 1);
2696         }
2697
2698         IPW_DEBUG_TRACE("<<\n");
2699 }
2700
2701 static void ipw_zero_memory(struct ipw_priv *priv, u32 start, u32 count)
2702 {
2703         count >>= 2;
2704         if (!count)
2705                 return;
2706         _ipw_write32(priv, IPW_AUTOINC_ADDR, start);
2707         while (count--)
2708                 _ipw_write32(priv, IPW_AUTOINC_DATA, 0);
2709 }
2710
2711 static inline void ipw_fw_dma_reset_command_blocks(struct ipw_priv *priv)
2712 {
2713         ipw_zero_memory(priv, IPW_SHARED_SRAM_DMA_CONTROL,
2714                         CB_NUMBER_OF_ELEMENTS_SMALL *
2715                         sizeof(struct command_block));
2716 }
2717
2718 static int ipw_fw_dma_enable(struct ipw_priv *priv)
2719 {                               /* start dma engine but no transfers yet */
2720
2721         IPW_DEBUG_FW(">> :\n");
2722
2723         /* Start the dma */
2724         ipw_fw_dma_reset_command_blocks(priv);
2725
2726         /* Write CB base address */
2727         ipw_write_reg32(priv, IPW_DMA_I_CB_BASE, IPW_SHARED_SRAM_DMA_CONTROL);
2728
2729         IPW_DEBUG_FW("<< :\n");
2730         return 0;
2731 }
2732
2733 static void ipw_fw_dma_abort(struct ipw_priv *priv)
2734 {
2735         u32 control = 0;
2736
2737         IPW_DEBUG_FW(">> :\n");
2738
2739         /* set the Stop and Abort bit */
2740         control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_STOP_AND_ABORT;
2741         ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2742         priv->sram_desc.last_cb_index = 0;
2743
2744         IPW_DEBUG_FW("<<\n");
2745 }
2746
2747 static int ipw_fw_dma_write_command_block(struct ipw_priv *priv, int index,
2748                                           struct command_block *cb)
2749 {
2750         u32 address =
2751             IPW_SHARED_SRAM_DMA_CONTROL +
2752             (sizeof(struct command_block) * index);
2753         IPW_DEBUG_FW(">> :\n");
2754
2755         ipw_write_indirect(priv, address, (u8 *) cb,
2756                            (int)sizeof(struct command_block));
2757
2758         IPW_DEBUG_FW("<< :\n");
2759         return 0;
2760
2761 }
2762
2763 static int ipw_fw_dma_kick(struct ipw_priv *priv)
2764 {
2765         u32 control = 0;
2766         u32 index = 0;
2767
2768         IPW_DEBUG_FW(">> :\n");
2769
2770         for (index = 0; index < priv->sram_desc.last_cb_index; index++)
2771                 ipw_fw_dma_write_command_block(priv, index,
2772                                                &priv->sram_desc.cb_list[index]);
2773
2774         /* Enable the DMA in the CSR register */
2775         ipw_clear_bit(priv, IPW_RESET_REG,
2776                       IPW_RESET_REG_MASTER_DISABLED |
2777                       IPW_RESET_REG_STOP_MASTER);
2778
2779         /* Set the Start bit. */
2780         control = DMA_CONTROL_SMALL_CB_CONST_VALUE | DMA_CB_START;
2781         ipw_write_reg32(priv, IPW_DMA_I_DMA_CONTROL, control);
2782
2783         IPW_DEBUG_FW("<< :\n");
2784         return 0;
2785 }
2786
2787 static void ipw_fw_dma_dump_command_block(struct ipw_priv *priv)
2788 {
2789         u32 address;
2790         u32 register_value = 0;
2791         u32 cb_fields_address = 0;
2792
2793         IPW_DEBUG_FW(">> :\n");
2794         address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2795         IPW_DEBUG_FW_INFO("Current CB is 0x%x\n", address);
2796
2797         /* Read the DMA Controlor register */
2798         register_value = ipw_read_reg32(priv, IPW_DMA_I_DMA_CONTROL);
2799         IPW_DEBUG_FW_INFO("IPW_DMA_I_DMA_CONTROL is 0x%x\n", register_value);
2800
2801         /* Print the CB values */
2802         cb_fields_address = address;
2803         register_value = ipw_read_reg32(priv, cb_fields_address);
2804         IPW_DEBUG_FW_INFO("Current CB Control Field is 0x%x\n", register_value);
2805
2806         cb_fields_address += sizeof(u32);
2807         register_value = ipw_read_reg32(priv, cb_fields_address);
2808         IPW_DEBUG_FW_INFO("Current CB Source Field is 0x%x\n", register_value);
2809
2810         cb_fields_address += sizeof(u32);
2811         register_value = ipw_read_reg32(priv, cb_fields_address);
2812         IPW_DEBUG_FW_INFO("Current CB Destination Field is 0x%x\n",
2813                           register_value);
2814
2815         cb_fields_address += sizeof(u32);
2816         register_value = ipw_read_reg32(priv, cb_fields_address);
2817         IPW_DEBUG_FW_INFO("Current CB Status Field is 0x%x\n", register_value);
2818
2819         IPW_DEBUG_FW(">> :\n");
2820 }
2821
2822 static int ipw_fw_dma_command_block_index(struct ipw_priv *priv)
2823 {
2824         u32 current_cb_address = 0;
2825         u32 current_cb_index = 0;
2826
2827         IPW_DEBUG_FW("<< :\n");
2828         current_cb_address = ipw_read_reg32(priv, IPW_DMA_I_CURRENT_CB);
2829
2830         current_cb_index = (current_cb_address - IPW_SHARED_SRAM_DMA_CONTROL) /
2831             sizeof(struct command_block);
2832
2833         IPW_DEBUG_FW_INFO("Current CB index 0x%x address = 0x%X\n",
2834                           current_cb_index, current_cb_address);
2835
2836         IPW_DEBUG_FW(">> :\n");
2837         return current_cb_index;
2838
2839 }
2840
2841 static int ipw_fw_dma_add_command_block(struct ipw_priv *priv,
2842                                         u32 src_address,
2843                                         u32 dest_address,
2844                                         u32 length,
2845                                         int interrupt_enabled, int is_last)
2846 {
2847
2848         u32 control = CB_VALID | CB_SRC_LE | CB_DEST_LE | CB_SRC_AUTOINC |
2849             CB_SRC_IO_GATED | CB_DEST_AUTOINC | CB_SRC_SIZE_LONG |
2850             CB_DEST_SIZE_LONG;
2851         struct command_block *cb;
2852         u32 last_cb_element = 0;
2853
2854         IPW_DEBUG_FW_INFO("src_address=0x%x dest_address=0x%x length=0x%x\n",
2855                           src_address, dest_address, length);
2856
2857         if (priv->sram_desc.last_cb_index >= CB_NUMBER_OF_ELEMENTS_SMALL)
2858                 return -1;
2859
2860         last_cb_element = priv->sram_desc.last_cb_index;
2861         cb = &priv->sram_desc.cb_list[last_cb_element];
2862         priv->sram_desc.last_cb_index++;
2863
2864         /* Calculate the new CB control word */
2865         if (interrupt_enabled)
2866                 control |= CB_INT_ENABLED;
2867
2868         if (is_last)
2869                 control |= CB_LAST_VALID;
2870
2871         control |= length;
2872
2873         /* Calculate the CB Element's checksum value */
2874         cb->status = control ^ src_address ^ dest_address;
2875
2876         /* Copy the Source and Destination addresses */
2877         cb->dest_addr = dest_address;
2878         cb->source_addr = src_address;
2879
2880         /* Copy the Control Word last */
2881         cb->control = control;
2882
2883         return 0;
2884 }
2885
2886 static int ipw_fw_dma_add_buffer(struct ipw_priv *priv, dma_addr_t *src_address,
2887                                  int nr, u32 dest_address, u32 len)
2888 {
2889         int ret, i;
2890         u32 size;
2891
2892         IPW_DEBUG_FW(">>\n");
2893         IPW_DEBUG_FW_INFO("nr=%d dest_address=0x%x len=0x%x\n",
2894                           nr, dest_address, len);
2895
2896         for (i = 0; i < nr; i++) {
2897                 size = min_t(u32, len - i * CB_MAX_LENGTH, CB_MAX_LENGTH);
2898                 ret = ipw_fw_dma_add_command_block(priv, src_address[i],
2899                                                    dest_address +
2900                                                    i * CB_MAX_LENGTH, size,
2901                                                    0, 0);
2902                 if (ret) {
2903                         IPW_DEBUG_FW_INFO(": Failed\n");
2904                         return -1;
2905                 } else
2906                         IPW_DEBUG_FW_INFO(": Added new cb\n");
2907         }
2908
2909         IPW_DEBUG_FW("<<\n");
2910         return 0;
2911 }
2912
2913 static int ipw_fw_dma_wait(struct ipw_priv *priv)
2914 {
2915         u32 current_index = 0, previous_index;
2916         u32 watchdog = 0;
2917
2918         IPW_DEBUG_FW(">> :\n");
2919
2920         current_index = ipw_fw_dma_command_block_index(priv);
2921         IPW_DEBUG_FW_INFO("sram_desc.last_cb_index:0x%08X\n",
2922                           (int)priv->sram_desc.last_cb_index);
2923
2924         while (current_index < priv->sram_desc.last_cb_index) {
2925                 udelay(50);
2926                 previous_index = current_index;
2927                 current_index = ipw_fw_dma_command_block_index(priv);
2928
2929                 if (previous_index < current_index) {
2930                         watchdog = 0;
2931                         continue;
2932                 }
2933                 if (++watchdog > 400) {
2934                         IPW_DEBUG_FW_INFO("Timeout\n");
2935                         ipw_fw_dma_dump_command_block(priv);
2936                         ipw_fw_dma_abort(priv);
2937                         return -1;
2938                 }
2939         }
2940
2941         ipw_fw_dma_abort(priv);
2942
2943         /*Disable the DMA in the CSR register */
2944         ipw_set_bit(priv, IPW_RESET_REG,
2945                     IPW_RESET_REG_MASTER_DISABLED | IPW_RESET_REG_STOP_MASTER);
2946
2947         IPW_DEBUG_FW("<< dmaWaitSync\n");
2948         return 0;
2949 }
2950
2951 static void ipw_remove_current_network(struct ipw_priv *priv)
2952 {
2953         struct list_head *element, *safe;
2954         struct libipw_network *network = NULL;
2955         unsigned long flags;
2956
2957         spin_lock_irqsave(&priv->ieee->lock, flags);
2958         list_for_each_safe(element, safe, &priv->ieee->network_list) {
2959                 network = list_entry(element, struct libipw_network, list);
2960                 if (ether_addr_equal(network->bssid, priv->bssid)) {
2961                         list_del(element);
2962                         list_add_tail(&network->list,
2963                                       &priv->ieee->network_free_list);
2964                 }
2965         }
2966         spin_unlock_irqrestore(&priv->ieee->lock, flags);
2967 }
2968
2969 /* timeout in msec, attempted in 10-msec quanta */
2970 static int ipw_poll_bit(struct ipw_priv *priv, u32 addr, u32 mask,
2971                                int timeout)
2972 {
2973         int i = 0;
2974
2975         do {
2976                 if ((ipw_read32(priv, addr) & mask) == mask)
2977                         return i;
2978                 mdelay(10);
2979                 i += 10;
2980         } while (i < timeout);
2981
2982         return -ETIME;
2983 }
2984
2985 /* These functions load the firmware and micro code for the operation of
2986  * the ipw hardware.  It assumes the buffer has all the bits for the
2987  * image and the caller is handling the memory allocation and clean up.
2988  */
2989
2990 static int ipw_stop_master(struct ipw_priv *priv)
2991 {
2992         int rc;
2993
2994         IPW_DEBUG_TRACE(">>\n");
2995         /* stop master. typical delay - 0 */
2996         ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
2997
2998         /* timeout is in msec, polled in 10-msec quanta */
2999         rc = ipw_poll_bit(priv, IPW_RESET_REG,
3000                           IPW_RESET_REG_MASTER_DISABLED, 100);
3001         if (rc < 0) {
3002                 IPW_ERROR("wait for stop master failed after 100ms\n");
3003                 return -1;
3004         }
3005
3006         IPW_DEBUG_INFO("stop master %dms\n", rc);
3007
3008         return rc;
3009 }
3010
3011 static void ipw_arc_release(struct ipw_priv *priv)
3012 {
3013         IPW_DEBUG_TRACE(">>\n");
3014         mdelay(5);
3015
3016         ipw_clear_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
3017
3018         /* no one knows timing, for safety add some delay */
3019         mdelay(5);
3020 }
3021
3022 struct fw_chunk {
3023         __le32 address;
3024         __le32 length;
3025 };
3026
3027 static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
3028 {
3029         int rc = 0, i, addr;
3030         u8 cr = 0;
3031         __le16 *image;
3032
3033         image = (__le16 *) data;
3034
3035         IPW_DEBUG_TRACE(">>\n");
3036
3037         rc = ipw_stop_master(priv);
3038
3039         if (rc < 0)
3040                 return rc;
3041
3042         for (addr = IPW_SHARED_LOWER_BOUND;
3043              addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
3044                 ipw_write32(priv, addr, 0);
3045         }
3046
3047         /* no ucode (yet) */
3048         memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
3049         /* destroy DMA queues */
3050         /* reset sequence */
3051
3052         ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
3053         ipw_arc_release(priv);
3054         ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
3055         mdelay(1);
3056
3057         /* reset PHY */
3058         ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
3059         mdelay(1);
3060
3061         ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
3062         mdelay(1);
3063
3064         /* enable ucode store */
3065         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0x0);
3066         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_CS);
3067         mdelay(1);
3068
3069         /* write ucode */
3070         /*
3071          * @bug
3072          * Do NOT set indirect address register once and then
3073          * store data to indirect data register in the loop.
3074          * It seems very reasonable, but in this case DINO do not
3075          * accept ucode. It is essential to set address each time.
3076          */
3077         /* load new ipw uCode */
3078         for (i = 0; i < len / 2; i++)
3079                 ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
3080                                 le16_to_cpu(image[i]));
3081
3082         /* enable DINO */
3083         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
3084         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
3085
3086         /* this is where the igx / win driver deveates from the VAP driver. */
3087
3088         /* wait for alive response */
3089         for (i = 0; i < 100; i++) {
3090                 /* poll for incoming data */
3091                 cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
3092                 if (cr & DINO_RXFIFO_DATA)
3093                         break;
3094                 mdelay(1);
3095         }
3096
3097         if (cr & DINO_RXFIFO_DATA) {
3098                 /* alive_command_responce size is NOT multiple of 4 */
3099                 __le32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
3100
3101                 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
3102                         response_buffer[i] =
3103                             cpu_to_le32(ipw_read_reg32(priv,
3104                                                        IPW_BASEBAND_RX_FIFO_READ));
3105                 memcpy(&priv->dino_alive, response_buffer,
3106                        sizeof(priv->dino_alive));
3107                 if (priv->dino_alive.alive_command == 1
3108                     && priv->dino_alive.ucode_valid == 1) {
3109                         rc = 0;
3110                         IPW_DEBUG_INFO
3111                             ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
3112                              "of %02d/%02d/%02d %02d:%02d\n",
3113                              priv->dino_alive.software_revision,
3114                              priv->dino_alive.software_revision,
3115                              priv->dino_alive.device_identifier,
3116                              priv->dino_alive.device_identifier,
3117                              priv->dino_alive.time_stamp[0],
3118                              priv->dino_alive.time_stamp[1],
3119                              priv->dino_alive.time_stamp[2],
3120                              priv->dino_alive.time_stamp[3],
3121                              priv->dino_alive.time_stamp[4]);
3122                 } else {
3123                         IPW_DEBUG_INFO("Microcode is not alive\n");
3124                         rc = -EINVAL;
3125                 }
3126         } else {
3127                 IPW_DEBUG_INFO("No alive response from DINO\n");
3128                 rc = -ETIME;
3129         }
3130
3131         /* disable DINO, otherwise for some reason
3132            firmware have problem getting alive resp. */
3133         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
3134
3135         return rc;
3136 }
3137
3138 static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
3139 {
3140         int ret = -1;
3141         int offset = 0;
3142         struct fw_chunk *chunk;
3143         int total_nr = 0;
3144         int i;
3145         struct dma_pool *pool;
3146         void **virts;
3147         dma_addr_t *phys;
3148
3149         IPW_DEBUG_TRACE("<< :\n");
3150
3151         virts = kmalloc_array(CB_NUMBER_OF_ELEMENTS_SMALL, sizeof(void *),
3152                               GFP_KERNEL);
3153         if (!virts)
3154                 return -ENOMEM;
3155
3156         phys = kmalloc_array(CB_NUMBER_OF_ELEMENTS_SMALL, sizeof(dma_addr_t),
3157                              GFP_KERNEL);
3158         if (!phys) {
3159                 kfree(virts);
3160                 return -ENOMEM;
3161         }
3162         pool = dma_pool_create("ipw2200", &priv->pci_dev->dev, CB_MAX_LENGTH, 0,
3163                                0);
3164         if (!pool) {
3165                 IPW_ERROR("dma_pool_create failed\n");
3166                 kfree(phys);
3167                 kfree(virts);
3168                 return -ENOMEM;
3169         }
3170
3171         /* Start the Dma */
3172         ret = ipw_fw_dma_enable(priv);
3173
3174         /* the DMA is already ready this would be a bug. */
3175         BUG_ON(priv->sram_desc.last_cb_index > 0);
3176
3177         do {
3178                 u32 chunk_len;
3179                 u8 *start;
3180                 int size;
3181                 int nr = 0;
3182
3183                 chunk = (struct fw_chunk *)(data + offset);
3184                 offset += sizeof(struct fw_chunk);
3185                 chunk_len = le32_to_cpu(chunk->length);
3186                 start = data + offset;
3187
3188                 nr = (chunk_len + CB_MAX_LENGTH - 1) / CB_MAX_LENGTH;
3189                 for (i = 0; i < nr; i++) {
3190                         virts[total_nr] = dma_pool_alloc(pool, GFP_KERNEL,
3191                                                          &phys[total_nr]);
3192                         if (!virts[total_nr]) {
3193                                 ret = -ENOMEM;
3194                                 goto out;
3195                         }
3196                         size = min_t(u32, chunk_len - i * CB_MAX_LENGTH,
3197                                      CB_MAX_LENGTH);
3198                         memcpy(virts[total_nr], start, size);
3199                         start += size;
3200                         total_nr++;
3201                         /* We don't support fw chunk larger than 64*8K */
3202                         BUG_ON(total_nr > CB_NUMBER_OF_ELEMENTS_SMALL);
3203                 }
3204
3205                 /* build DMA packet and queue up for sending */
3206                 /* dma to chunk->address, the chunk->length bytes from data +
3207                  * offeset*/
3208                 /* Dma loading */
3209                 ret = ipw_fw_dma_add_buffer(priv, &phys[total_nr - nr],
3210                                             nr, le32_to_cpu(chunk->address),
3211                                             chunk_len);
3212                 if (ret) {
3213                         IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
3214                         goto out;
3215                 }
3216
3217                 offset += chunk_len;
3218         } while (offset < len);
3219
3220         /* Run the DMA and wait for the answer */
3221         ret = ipw_fw_dma_kick(priv);
3222         if (ret) {
3223                 IPW_ERROR("dmaKick Failed\n");
3224                 goto out;
3225         }
3226
3227         ret = ipw_fw_dma_wait(priv);
3228         if (ret) {
3229                 IPW_ERROR("dmaWaitSync Failed\n");
3230                 goto out;
3231         }
3232  out:
3233         for (i = 0; i < total_nr; i++)
3234                 dma_pool_free(pool, virts[i], phys[i]);
3235
3236         dma_pool_destroy(pool);
3237         kfree(phys);
3238         kfree(virts);
3239
3240         return ret;
3241 }
3242
3243 /* stop nic */
3244 static int ipw_stop_nic(struct ipw_priv *priv)
3245 {
3246         int rc = 0;
3247
3248         /* stop */
3249         ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
3250
3251         rc = ipw_poll_bit(priv, IPW_RESET_REG,
3252                           IPW_RESET_REG_MASTER_DISABLED, 500);
3253         if (rc < 0) {
3254                 IPW_ERROR("wait for reg master disabled failed after 500ms\n");
3255                 return rc;
3256         }
3257
3258         ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
3259
3260         return rc;
3261 }
3262
3263 static void ipw_start_nic(struct ipw_priv *priv)
3264 {
3265         IPW_DEBUG_TRACE(">>\n");
3266
3267         /* prvHwStartNic  release ARC */
3268         ipw_clear_bit(priv, IPW_RESET_REG,
3269                       IPW_RESET_REG_MASTER_DISABLED |
3270                       IPW_RESET_REG_STOP_MASTER |
3271                       CBD_RESET_REG_PRINCETON_RESET);
3272
3273         /* enable power management */
3274         ipw_set_bit(priv, IPW_GP_CNTRL_RW,
3275                     IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
3276
3277         IPW_DEBUG_TRACE("<<\n");
3278 }
3279
3280 static int ipw_init_nic(struct ipw_priv *priv)
3281 {
3282         int rc;
3283
3284         IPW_DEBUG_TRACE(">>\n");
3285         /* reset */
3286         /*prvHwInitNic */
3287         /* set "initialization complete" bit to move adapter to D0 state */
3288         ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3289
3290         /* low-level PLL activation */
3291         ipw_write32(priv, IPW_READ_INT_REGISTER,
3292                     IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
3293
3294         /* wait for clock stabilization */
3295         rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
3296                           IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
3297         if (rc < 0)
3298                 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
3299
3300         /* assert SW reset */
3301         ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
3302
3303         udelay(10);
3304
3305         /* set "initialization complete" bit to move adapter to D0 state */
3306         ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3307
3308         IPW_DEBUG_TRACE(">>\n");
3309         return 0;
3310 }
3311
3312 /* Call this function from process context, it will sleep in request_firmware.
3313  * Probe is an ok place to call this from.
3314  */
3315 static int ipw_reset_nic(struct ipw_priv *priv)
3316 {
3317         int rc = 0;
3318         unsigned long flags;
3319
3320         IPW_DEBUG_TRACE(">>\n");
3321
3322         rc = ipw_init_nic(priv);
3323
3324         spin_lock_irqsave(&priv->lock, flags);
3325         /* Clear the 'host command active' bit... */
3326         priv->status &= ~STATUS_HCMD_ACTIVE;
3327         wake_up_interruptible(&priv->wait_command_queue);
3328         priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3329         wake_up_interruptible(&priv->wait_state);
3330         spin_unlock_irqrestore(&priv->lock, flags);
3331
3332         IPW_DEBUG_TRACE("<<\n");
3333         return rc;
3334 }
3335
3336
3337 struct ipw_fw {
3338         __le32 ver;
3339         __le32 boot_size;
3340         __le32 ucode_size;
3341         __le32 fw_size;
3342         u8 data[];
3343 };
3344
3345 static int ipw_get_fw(struct ipw_priv *priv,
3346                       const struct firmware **raw, const char *name)
3347 {
3348         struct ipw_fw *fw;
3349         int rc;
3350
3351         /* ask firmware_class module to get the boot firmware off disk */
3352         rc = request_firmware(raw, name, &priv->pci_dev->dev);
3353         if (rc < 0) {
3354                 IPW_ERROR("%s request_firmware failed: Reason %d\n", name, rc);
3355                 return rc;
3356         }
3357
3358         if ((*raw)->size < sizeof(*fw)) {
3359                 IPW_ERROR("%s is too small (%zd)\n", name, (*raw)->size);
3360                 return -EINVAL;
3361         }
3362
3363         fw = (void *)(*raw)->data;
3364
3365         if ((*raw)->size < sizeof(*fw) + le32_to_cpu(fw->boot_size) +
3366             le32_to_cpu(fw->ucode_size) + le32_to_cpu(fw->fw_size)) {
3367                 IPW_ERROR("%s is too small or corrupt (%zd)\n",
3368                           name, (*raw)->size);
3369                 return -EINVAL;
3370         }
3371
3372         IPW_DEBUG_INFO("Read firmware '%s' image v%d.%d (%zd bytes)\n",
3373                        name,
3374                        le32_to_cpu(fw->ver) >> 16,
3375                        le32_to_cpu(fw->ver) & 0xff,
3376                        (*raw)->size - sizeof(*fw));
3377         return 0;
3378 }
3379
3380 #define IPW_RX_BUF_SIZE (3000)
3381
3382 static void ipw_rx_queue_reset(struct ipw_priv *priv,
3383                                       struct ipw_rx_queue *rxq)
3384 {
3385         unsigned long flags;
3386         int i;
3387
3388         spin_lock_irqsave(&rxq->lock, flags);
3389
3390         INIT_LIST_HEAD(&rxq->rx_free);
3391         INIT_LIST_HEAD(&rxq->rx_used);
3392
3393         /* Fill the rx_used queue with _all_ of the Rx buffers */
3394         for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
3395                 /* In the reset function, these buffers may have been allocated
3396                  * to an SKB, so we need to unmap and free potential storage */
3397                 if (rxq->pool[i].skb != NULL) {
3398                         dma_unmap_single(&priv->pci_dev->dev,
3399                                          rxq->pool[i].dma_addr,
3400                                          IPW_RX_BUF_SIZE, DMA_FROM_DEVICE);
3401                         dev_kfree_skb_irq(rxq->pool[i].skb);
3402                         rxq->pool[i].skb = NULL;
3403                 }
3404                 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3405         }
3406
3407         /* Set us so that we have processed and used all buffers, but have
3408          * not restocked the Rx queue with fresh buffers */
3409         rxq->read = rxq->write = 0;
3410         rxq->free_count = 0;
3411         spin_unlock_irqrestore(&rxq->lock, flags);
3412 }
3413
3414 #ifdef CONFIG_PM
3415 static int fw_loaded = 0;
3416 static const struct firmware *raw = NULL;
3417
3418 static void free_firmware(void)
3419 {
3420         if (fw_loaded) {
3421                 release_firmware(raw);
3422                 raw = NULL;
3423                 fw_loaded = 0;
3424         }
3425 }
3426 #else
3427 #define free_firmware() do {} while (0)
3428 #endif
3429
3430 static int ipw_load(struct ipw_priv *priv)
3431 {
3432 #ifndef CONFIG_PM
3433         const struct firmware *raw = NULL;
3434 #endif
3435         struct ipw_fw *fw;
3436         u8 *boot_img, *ucode_img, *fw_img;
3437         u8 *name = NULL;
3438         int rc = 0, retries = 3;
3439
3440         switch (priv->ieee->iw_mode) {
3441         case IW_MODE_ADHOC:
3442                 name = "ipw2200-ibss.fw";
3443                 break;
3444 #ifdef CONFIG_IPW2200_MONITOR
3445         case IW_MODE_MONITOR:
3446                 name = "ipw2200-sniffer.fw";
3447                 break;
3448 #endif
3449         case IW_MODE_INFRA:
3450                 name = "ipw2200-bss.fw";
3451                 break;
3452         }
3453
3454         if (!name) {
3455                 rc = -EINVAL;
3456                 goto error;
3457         }
3458
3459 #ifdef CONFIG_PM
3460         if (!fw_loaded) {
3461 #endif
3462                 rc = ipw_get_fw(priv, &raw, name);
3463                 if (rc < 0)
3464                         goto error;
3465 #ifdef CONFIG_PM
3466         }
3467 #endif
3468
3469         fw = (void *)raw->data;
3470         boot_img = &fw->data[0];
3471         ucode_img = &fw->data[le32_to_cpu(fw->boot_size)];
3472         fw_img = &fw->data[le32_to_cpu(fw->boot_size) +
3473                            le32_to_cpu(fw->ucode_size)];
3474
3475         if (!priv->rxq)
3476                 priv->rxq = ipw_rx_queue_alloc(priv);
3477         else
3478                 ipw_rx_queue_reset(priv, priv->rxq);
3479         if (!priv->rxq) {
3480                 IPW_ERROR("Unable to initialize Rx queue\n");
3481                 rc = -ENOMEM;
3482                 goto error;
3483         }
3484
3485       retry:
3486         /* Ensure interrupts are disabled */
3487         ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3488         priv->status &= ~STATUS_INT_ENABLED;
3489
3490         /* ack pending interrupts */
3491         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3492
3493         ipw_stop_nic(priv);
3494
3495         rc = ipw_reset_nic(priv);
3496         if (rc < 0) {
3497                 IPW_ERROR("Unable to reset NIC\n");
3498                 goto error;
3499         }
3500
3501         ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
3502                         IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
3503
3504         /* DMA the initial boot firmware into the device */
3505         rc = ipw_load_firmware(priv, boot_img, le32_to_cpu(fw->boot_size));
3506         if (rc < 0) {
3507                 IPW_ERROR("Unable to load boot firmware: %d\n", rc);
3508                 goto error;
3509         }
3510
3511         /* kick start the device */
3512         ipw_start_nic(priv);
3513
3514         /* wait for the device to finish its initial startup sequence */
3515         rc = ipw_poll_bit(priv, IPW_INTA_RW,
3516                           IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3517         if (rc < 0) {
3518                 IPW_ERROR("device failed to boot initial fw image\n");
3519                 goto error;
3520         }
3521         IPW_DEBUG_INFO("initial device response after %dms\n", rc);
3522
3523         /* ack fw init done interrupt */
3524         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3525
3526         /* DMA the ucode into the device */
3527         rc = ipw_load_ucode(priv, ucode_img, le32_to_cpu(fw->ucode_size));
3528         if (rc < 0) {
3529                 IPW_ERROR("Unable to load ucode: %d\n", rc);
3530                 goto error;
3531         }
3532
3533         /* stop nic */
3534         ipw_stop_nic(priv);
3535
3536         /* DMA bss firmware into the device */
3537         rc = ipw_load_firmware(priv, fw_img, le32_to_cpu(fw->fw_size));
3538         if (rc < 0) {
3539                 IPW_ERROR("Unable to load firmware: %d\n", rc);
3540                 goto error;
3541         }
3542 #ifdef CONFIG_PM
3543         fw_loaded = 1;
3544 #endif
3545
3546         ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
3547
3548         rc = ipw_queue_reset(priv);
3549         if (rc < 0) {
3550                 IPW_ERROR("Unable to initialize queues\n");
3551                 goto error;
3552         }
3553
3554         /* Ensure interrupts are disabled */
3555         ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3556         /* ack pending interrupts */
3557         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3558
3559         /* kick start the device */
3560         ipw_start_nic(priv);
3561
3562         if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
3563                 if (retries > 0) {
3564                         IPW_WARNING("Parity error.  Retrying init.\n");
3565                         retries--;
3566                         goto retry;
3567                 }
3568
3569                 IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
3570                 rc = -EIO;
3571                 goto error;
3572         }
3573
3574         /* wait for the device */
3575         rc = ipw_poll_bit(priv, IPW_INTA_RW,
3576                           IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3577         if (rc < 0) {
3578                 IPW_ERROR("device failed to start within 500ms\n");
3579                 goto error;
3580         }
3581         IPW_DEBUG_INFO("device response after %dms\n", rc);
3582
3583         /* ack fw init done interrupt */
3584         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3585
3586         /* read eeprom data */
3587         priv->eeprom_delay = 1;
3588         ipw_read_eeprom(priv);
3589         /* initialize the eeprom region of sram */
3590         ipw_eeprom_init_sram(priv);
3591
3592         /* enable interrupts */
3593         ipw_enable_interrupts(priv);
3594
3595         /* Ensure our queue has valid packets */
3596         ipw_rx_queue_replenish(priv);
3597
3598         ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
3599
3600         /* ack pending interrupts */
3601         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3602
3603 #ifndef CONFIG_PM
3604         release_firmware(raw);
3605 #endif
3606         return 0;
3607
3608       error:
3609         if (priv->rxq) {
3610                 ipw_rx_queue_free(priv, priv->rxq);
3611                 priv->rxq = NULL;
3612         }
3613         ipw_tx_queue_free(priv);
3614         release_firmware(raw);
3615 #ifdef CONFIG_PM
3616         fw_loaded = 0;
3617         raw = NULL;
3618 #endif
3619
3620         return rc;
3621 }
3622
3623 /*
3624  * DMA services
3625  *
3626  * Theory of operation
3627  *
3628  * A queue is a circular buffers with 'Read' and 'Write' pointers.
3629  * 2 empty entries always kept in the buffer to protect from overflow.
3630  *
3631  * For Tx queue, there are low mark and high mark limits. If, after queuing
3632  * the packet for Tx, free space become < low mark, Tx queue stopped. When
3633  * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
3634  * Tx queue resumed.
3635  *
3636  * The IPW operates with six queues, one receive queue in the device's
3637  * sram, one transmit queue for sending commands to the device firmware,
3638  * and four transmit queues for data.
3639  *
3640  * The four transmit queues allow for performing quality of service (qos)
3641  * transmissions as per the 802.11 protocol.  Currently Linux does not
3642  * provide a mechanism to the user for utilizing prioritized queues, so
3643  * we only utilize the first data transmit queue (queue1).
3644  */
3645
3646 /*
3647  * Driver allocates buffers of this size for Rx
3648  */
3649
3650 /*
3651  * ipw_rx_queue_space - Return number of free slots available in queue.
3652  */
3653 static int ipw_rx_queue_space(const struct ipw_rx_queue *q)
3654 {
3655         int s = q->read - q->write;
3656         if (s <= 0)
3657                 s += RX_QUEUE_SIZE;
3658         /* keep some buffer to not confuse full and empty queue */
3659         s -= 2;
3660         if (s < 0)
3661                 s = 0;
3662         return s;
3663 }
3664
3665 static inline int ipw_tx_queue_space(const struct clx2_queue *q)
3666 {
3667         int s = q->last_used - q->first_empty;
3668         if (s <= 0)
3669                 s += q->n_bd;
3670         s -= 2;                 /* keep some reserve to not confuse empty and full situations */
3671         if (s < 0)
3672                 s = 0;
3673         return s;
3674 }
3675
3676 static inline int ipw_queue_inc_wrap(int index, int n_bd)
3677 {
3678         return (++index == n_bd) ? 0 : index;
3679 }
3680
3681 /*
3682  * Initialize common DMA queue structure
3683  *
3684  * @param q                queue to init
3685  * @param count            Number of BD's to allocate. Should be power of 2
3686  * @param read_register    Address for 'read' register
3687  *                         (not offset within BAR, full address)
3688  * @param write_register   Address for 'write' register
3689  *                         (not offset within BAR, full address)
3690  * @param base_register    Address for 'base' register
3691  *                         (not offset within BAR, full address)
3692  * @param size             Address for 'size' register
3693  *                         (not offset within BAR, full address)
3694  */
3695 static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
3696                            int count, u32 read, u32 write, u32 base, u32 size)
3697 {
3698         q->n_bd = count;
3699
3700         q->low_mark = q->n_bd / 4;
3701         if (q->low_mark < 4)
3702                 q->low_mark = 4;
3703
3704         q->high_mark = q->n_bd / 8;
3705         if (q->high_mark < 2)
3706                 q->high_mark = 2;
3707
3708         q->first_empty = q->last_used = 0;
3709         q->reg_r = read;
3710         q->reg_w = write;
3711
3712         ipw_write32(priv, base, q->dma_addr);
3713         ipw_write32(priv, size, count);
3714         ipw_write32(priv, read, 0);
3715         ipw_write32(priv, write, 0);
3716
3717         _ipw_read32(priv, 0x90);
3718 }
3719
3720 static int ipw_queue_tx_init(struct ipw_priv *priv,
3721                              struct clx2_tx_queue *q,
3722                              int count, u32 read, u32 write, u32 base, u32 size)
3723 {
3724         struct pci_dev *dev = priv->pci_dev;
3725
3726         q->txb = kmalloc_array(count, sizeof(q->txb[0]), GFP_KERNEL);
3727         if (!q->txb)
3728                 return -ENOMEM;
3729
3730         q->bd =
3731             dma_alloc_coherent(&dev->dev, sizeof(q->bd[0]) * count,
3732                                &q->q.dma_addr, GFP_KERNEL);
3733         if (!q->bd) {
3734                 IPW_ERROR("dma_alloc_coherent(%zd) failed\n",
3735                           sizeof(q->bd[0]) * count);
3736                 kfree(q->txb);
3737                 q->txb = NULL;
3738                 return -ENOMEM;
3739         }
3740
3741         ipw_queue_init(priv, &q->q, count, read, write, base, size);
3742         return 0;
3743 }
3744
3745 /*
3746  * Free one TFD, those at index [txq->q.last_used].
3747  * Do NOT advance any indexes
3748  *
3749  * @param dev
3750  * @param txq
3751  */
3752 static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
3753                                   struct clx2_tx_queue *txq)
3754 {
3755         struct tfd_frame *bd = &txq->bd[txq->q.last_used];
3756         struct pci_dev *dev = priv->pci_dev;
3757         int i;
3758
3759         /* classify bd */
3760         if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
3761                 /* nothing to cleanup after for host commands */
3762                 return;
3763
3764         /* sanity check */
3765         if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3766                 IPW_ERROR("Too many chunks: %i\n",
3767                           le32_to_cpu(bd->u.data.num_chunks));
3768                 /* @todo issue fatal error, it is quite serious situation */
3769                 return;
3770         }
3771
3772         /* unmap chunks if any */
3773         for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3774                 dma_unmap_single(&dev->dev,
3775                                  le32_to_cpu(bd->u.data.chunk_ptr[i]),
3776                                  le16_to_cpu(bd->u.data.chunk_len[i]),
3777                                  DMA_TO_DEVICE);
3778                 if (txq->txb[txq->q.last_used]) {
3779                         libipw_txb_free(txq->txb[txq->q.last_used]);
3780                         txq->txb[txq->q.last_used] = NULL;
3781                 }
3782         }
3783 }
3784
3785 /*
3786  * Deallocate DMA queue.
3787  *
3788  * Empty queue by removing and destroying all BD's.
3789  * Free all buffers.
3790  *
3791  * @param dev
3792  * @param q
3793  */
3794 static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
3795 {
3796         struct clx2_queue *q = &txq->q;
3797         struct pci_dev *dev = priv->pci_dev;
3798
3799         if (q->n_bd == 0)
3800                 return;
3801
3802         /* first, empty all BD's */
3803         for (; q->first_empty != q->last_used;
3804              q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
3805                 ipw_queue_tx_free_tfd(priv, txq);
3806         }
3807
3808         /* free buffers belonging to queue itself */
3809         dma_free_coherent(&dev->dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
3810                           q->dma_addr);
3811         kfree(txq->txb);
3812
3813         /* 0 fill whole structure */
3814         memset(txq, 0, sizeof(*txq));
3815 }
3816
3817 /*
3818  * Destroy all DMA queues and structures
3819  *
3820  * @param priv
3821  */
3822 static void ipw_tx_queue_free(struct ipw_priv *priv)
3823 {
3824         /* Tx CMD queue */
3825         ipw_queue_tx_free(priv, &priv->txq_cmd);
3826
3827         /* Tx queues */
3828         ipw_queue_tx_free(priv, &priv->txq[0]);
3829         ipw_queue_tx_free(priv, &priv->txq[1]);
3830         ipw_queue_tx_free(priv, &priv->txq[2]);
3831         ipw_queue_tx_free(priv, &priv->txq[3]);
3832 }
3833
3834 static void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
3835 {
3836         /* First 3 bytes are manufacturer */
3837         bssid[0] = priv->mac_addr[0];
3838         bssid[1] = priv->mac_addr[1];
3839         bssid[2] = priv->mac_addr[2];
3840
3841         /* Last bytes are random */
3842         get_random_bytes(&bssid[3], ETH_ALEN - 3);
3843
3844         bssid[0] &= 0xfe;       /* clear multicast bit */
3845         bssid[0] |= 0x02;       /* set local assignment bit (IEEE802) */
3846 }
3847
3848 static u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
3849 {
3850         struct ipw_station_entry entry;
3851         int i;
3852
3853         for (i = 0; i < priv->num_stations; i++) {
3854                 if (ether_addr_equal(priv->stations[i], bssid)) {
3855                         /* Another node is active in network */
3856                         priv->missed_adhoc_beacons = 0;
3857                         if (!(priv->config & CFG_STATIC_CHANNEL))
3858                                 /* when other nodes drop out, we drop out */
3859                                 priv->config &= ~CFG_ADHOC_PERSIST;
3860
3861                         return i;
3862                 }
3863         }
3864
3865         if (i == MAX_STATIONS)
3866                 return IPW_INVALID_STATION;
3867
3868         IPW_DEBUG_SCAN("Adding AdHoc station: %pM\n", bssid);
3869
3870         entry.reserved = 0;
3871         entry.support_mode = 0;
3872         memcpy(entry.mac_addr, bssid, ETH_ALEN);
3873         memcpy(priv->stations[i], bssid, ETH_ALEN);
3874         ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
3875                          &entry, sizeof(entry));
3876         priv->num_stations++;
3877
3878         return i;
3879 }
3880
3881 static u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
3882 {
3883         int i;
3884
3885         for (i = 0; i < priv->num_stations; i++)
3886                 if (ether_addr_equal(priv->stations[i], bssid))
3887                         return i;
3888
3889         return IPW_INVALID_STATION;
3890 }
3891
3892 static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
3893 {
3894         int err;
3895
3896         if (priv->status & STATUS_ASSOCIATING) {
3897                 IPW_DEBUG_ASSOC("Disassociating while associating.\n");
3898                 schedule_work(&priv->disassociate);
3899                 return;
3900         }
3901
3902         if (!(priv->status & STATUS_ASSOCIATED)) {
3903                 IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
3904                 return;
3905         }
3906
3907         IPW_DEBUG_ASSOC("Disassociation attempt from %pM "
3908                         "on channel %d.\n",
3909                         priv->assoc_request.bssid,
3910                         priv->assoc_request.channel);
3911
3912         priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
3913         priv->status |= STATUS_DISASSOCIATING;
3914
3915         if (quiet)
3916                 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
3917         else
3918                 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
3919
3920         err = ipw_send_associate(priv, &priv->assoc_request);
3921         if (err) {
3922                 IPW_DEBUG_HC("Attempt to send [dis]associate command "
3923                              "failed.\n");
3924                 return;
3925         }
3926
3927 }
3928
3929 static int ipw_disassociate(void *data)
3930 {
3931         struct ipw_priv *priv = data;
3932         if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3933                 return 0;
3934         ipw_send_disassociate(data, 0);
3935         netif_carrier_off(priv->net_dev);
3936         return 1;
3937 }
3938
3939 static void ipw_bg_disassociate(struct work_struct *work)
3940 {
3941         struct ipw_priv *priv =
3942                 container_of(work, struct ipw_priv, disassociate);
3943         mutex_lock(&priv->mutex);
3944         ipw_disassociate(priv);
3945         mutex_unlock(&priv->mutex);
3946 }
3947
3948 static void ipw_system_config(struct work_struct *work)
3949 {
3950         struct ipw_priv *priv =
3951                 container_of(work, struct ipw_priv, system_config);
3952
3953 #ifdef CONFIG_IPW2200_PROMISCUOUS
3954         if (priv->prom_net_dev && netif_running(priv->prom_net_dev)) {
3955                 priv->sys_config.accept_all_data_frames = 1;
3956                 priv->sys_config.accept_non_directed_frames = 1;
3957                 priv->sys_config.accept_all_mgmt_bcpr = 1;
3958                 priv->sys_config.accept_all_mgmt_frames = 1;
3959         }
3960 #endif
3961
3962         ipw_send_system_config(priv);
3963 }
3964
3965 struct ipw_status_code {
3966         u16 status;
3967         const char *reason;
3968 };
3969
3970 static const struct ipw_status_code ipw_status_codes[] = {
3971         {0x00, "Successful"},
3972         {0x01, "Unspecified failure"},
3973         {0x0A, "Cannot support all requested capabilities in the "
3974          "Capability information field"},
3975         {0x0B, "Reassociation denied due to inability to confirm that "
3976          "association exists"},
3977         {0x0C, "Association denied due to reason outside the scope of this "
3978          "standard"},
3979         {0x0D,
3980          "Responding station does not support the specified authentication "
3981          "algorithm"},
3982         {0x0E,
3983          "Received an Authentication frame with authentication sequence "
3984          "transaction sequence number out of expected sequence"},
3985         {0x0F, "Authentication rejected because of challenge failure"},
3986         {0x10, "Authentication rejected due to timeout waiting for next "
3987          "frame in sequence"},
3988         {0x11, "Association denied because AP is unable to handle additional "
3989          "associated stations"},
3990         {0x12,
3991          "Association denied due to requesting station not supporting all "
3992          "of the datarates in the BSSBasicServiceSet Parameter"},
3993         {0x13,
3994          "Association denied due to requesting station not supporting "
3995          "short preamble operation"},
3996         {0x14,
3997          "Association denied due to requesting station not supporting "
3998          "PBCC encoding"},
3999         {0x15,
4000          "Association denied due to requesting station not supporting "
4001          "channel agility"},
4002         {0x19,
4003          "Association denied due to requesting station not supporting "
4004          "short slot operation"},
4005         {0x1A,
4006          "Association denied due to requesting station not supporting "
4007          "DSSS-OFDM operation"},
4008         {0x28, "Invalid Information Element"},
4009         {0x29, "Group Cipher is not valid"},
4010         {0x2A, "Pairwise Cipher is not valid"},
4011         {0x2B, "AKMP is not valid"},
4012         {0x2C, "Unsupported RSN IE version"},
4013         {0x2D, "Invalid RSN IE Capabilities"},
4014         {0x2E, "Cipher suite is rejected per security policy"},
4015 };
4016
4017 static const char *ipw_get_status_code(u16 status)
4018 {
4019         int i;
4020         for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
4021                 if (ipw_status_codes[i].status == (status & 0xff))
4022                         return ipw_status_codes[i].reason;
4023         return "Unknown status value.";
4024 }
4025
4026 static inline void average_init(struct average *avg)
4027 {
4028         memset(avg, 0, sizeof(*avg));
4029 }
4030
4031 #define DEPTH_RSSI 8
4032 #define DEPTH_NOISE 16
4033 static s16 exponential_average(s16 prev_avg, s16 val, u8 depth)
4034 {
4035         return ((depth-1)*prev_avg +  val)/depth;
4036 }
4037
4038 static void average_add(struct average *avg, s16 val)
4039 {
4040         avg->sum -= avg->entries[avg->pos];
4041         avg->sum += val;
4042         avg->entries[avg->pos++] = val;
4043         if (unlikely(avg->pos == AVG_ENTRIES)) {
4044                 avg->init = 1;
4045                 avg->pos = 0;
4046         }
4047 }
4048
4049 static s16 average_value(struct average *avg)
4050 {
4051         if (!unlikely(avg->init)) {
4052                 if (avg->pos)
4053                         return avg->sum / avg->pos;
4054                 return 0;
4055         }
4056
4057         return avg->sum / AVG_ENTRIES;
4058 }
4059
4060 static void ipw_reset_stats(struct ipw_priv *priv)
4061 {
4062         u32 len = sizeof(u32);
4063
4064         priv->quality = 0;
4065
4066         average_init(&priv->average_missed_beacons);
4067         priv->exp_avg_rssi = -60;
4068         priv->exp_avg_noise = -85 + 0x100;
4069
4070         priv->last_rate = 0;
4071         priv->last_missed_beacons = 0;
4072         priv->last_rx_packets = 0;
4073         priv->last_tx_packets = 0;
4074         priv->last_tx_failures = 0;
4075
4076         /* Firmware managed, reset only when NIC is restarted, so we have to
4077          * normalize on the current value */
4078         ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC,
4079                         &priv->last_rx_err, &len);
4080         ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE,
4081                         &priv->last_tx_failures, &len);
4082
4083         /* Driver managed, reset with each association */
4084         priv->missed_adhoc_beacons = 0;
4085         priv->missed_beacons = 0;
4086         priv->tx_packets = 0;
4087         priv->rx_packets = 0;
4088
4089 }
4090
4091 static u32 ipw_get_max_rate(struct ipw_priv *priv)
4092 {
4093         u32 i = 0x80000000;
4094         u32 mask = priv->rates_mask;
4095         /* If currently associated in B mode, restrict the maximum
4096          * rate match to B rates */
4097         if (priv->assoc_request.ieee_mode == IPW_B_MODE)
4098                 mask &= LIBIPW_CCK_RATES_MASK;
4099
4100         /* TODO: Verify that the rate is supported by the current rates
4101          * list. */
4102
4103         while (i && !(mask & i))
4104                 i >>= 1;
4105         switch (i) {
4106         case LIBIPW_CCK_RATE_1MB_MASK:
4107                 return 1000000;
4108         case LIBIPW_CCK_RATE_2MB_MASK:
4109                 return 2000000;
4110         case LIBIPW_CCK_RATE_5MB_MASK:
4111                 return 5500000;
4112         case LIBIPW_OFDM_RATE_6MB_MASK:
4113                 return 6000000;
4114         case LIBIPW_OFDM_RATE_9MB_MASK:
4115                 return 9000000;
4116         case LIBIPW_CCK_RATE_11MB_MASK:
4117                 return 11000000;
4118         case LIBIPW_OFDM_RATE_12MB_MASK:
4119                 return 12000000;
4120         case LIBIPW_OFDM_RATE_18MB_MASK:
4121                 return 18000000;
4122         case LIBIPW_OFDM_RATE_24MB_MASK:
4123                 return 24000000;
4124         case LIBIPW_OFDM_RATE_36MB_MASK:
4125                 return 36000000;
4126         case LIBIPW_OFDM_RATE_48MB_MASK:
4127                 return 48000000;
4128         case LIBIPW_OFDM_RATE_54MB_MASK:
4129                 return 54000000;
4130         }
4131
4132         if (priv->ieee->mode == IEEE_B)
4133                 return 11000000;
4134         else
4135                 return 54000000;
4136 }
4137
4138 static u32 ipw_get_current_rate(struct ipw_priv *priv)
4139 {
4140         u32 rate, len = sizeof(rate);
4141         int err;
4142
4143         if (!(priv->status & STATUS_ASSOCIATED))
4144                 return 0;
4145
4146         if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
4147                 err = ipw_get_ordinal(priv, IPW_ORD_STAT_TX_CURR_RATE, &rate,
4148                                       &len);
4149                 if (err) {
4150                         IPW_DEBUG_INFO("failed querying ordinals.\n");
4151                         return 0;
4152                 }
4153         } else
4154                 return ipw_get_max_rate(priv);
4155
4156         switch (rate) {
4157         case IPW_TX_RATE_1MB:
4158                 return 1000000;
4159         case IPW_TX_RATE_2MB:
4160                 return 2000000;
4161         case IPW_TX_RATE_5MB:
4162                 return 5500000;
4163         case IPW_TX_RATE_6MB:
4164                 return 6000000;
4165         case IPW_TX_RATE_9MB:
4166                 return 9000000;
4167         case IPW_TX_RATE_11MB:
4168                 return 11000000;
4169         case IPW_TX_RATE_12MB:
4170                 return 12000000;
4171         case IPW_TX_RATE_18MB:
4172                 return 18000000;
4173         case IPW_TX_RATE_24MB:
4174                 return 24000000;
4175         case IPW_TX_RATE_36MB:
4176                 return 36000000;
4177         case IPW_TX_RATE_48MB:
4178                 return 48000000;
4179         case IPW_TX_RATE_54MB:
4180                 return 54000000;
4181         }
4182
4183         return 0;
4184 }
4185
4186 #define IPW_STATS_INTERVAL (2 * HZ)
4187 static void ipw_gather_stats(struct ipw_priv *priv)
4188 {
4189         u32 rx_err, rx_err_delta, rx_packets_delta;
4190         u32 tx_failures, tx_failures_delta, tx_packets_delta;
4191         u32 missed_beacons_percent, missed_beacons_delta;
4192         u32 quality = 0;
4193         u32 len = sizeof(u32);
4194         s16 rssi;
4195         u32 beacon_quality, signal_quality, tx_quality, rx_quality,
4196             rate_quality;
4197         u32 max_rate;
4198
4199         if (!(priv->status & STATUS_ASSOCIATED)) {
4200                 priv->quality = 0;
4201                 return;
4202         }
4203
4204         /* Update the statistics */
4205         ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
4206                         &priv->missed_beacons, &len);
4207         missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
4208         priv->last_missed_beacons = priv->missed_beacons;
4209         if (priv->assoc_request.beacon_interval) {
4210                 missed_beacons_percent = missed_beacons_delta *
4211                     (HZ * le16_to_cpu(priv->assoc_request.beacon_interval)) /
4212                     (IPW_STATS_INTERVAL * 10);
4213         } else {
4214                 missed_beacons_percent = 0;
4215         }
4216         average_add(&priv->average_missed_beacons, missed_beacons_percent);
4217
4218         ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC, &rx_err, &len);
4219         rx_err_delta = rx_err - priv->last_rx_err;
4220         priv->last_rx_err = rx_err;
4221
4222         ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE, &tx_failures, &len);
4223         tx_failures_delta = tx_failures - priv->last_tx_failures;
4224         priv->last_tx_failures = tx_failures;
4225
4226         rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
4227         priv->last_rx_packets = priv->rx_packets;
4228
4229         tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
4230         priv->last_tx_packets = priv->tx_packets;
4231
4232         /* Calculate quality based on the following:
4233          *
4234          * Missed beacon: 100% = 0, 0% = 70% missed
4235          * Rate: 60% = 1Mbs, 100% = Max
4236          * Rx and Tx errors represent a straight % of total Rx/Tx
4237          * RSSI: 100% = > -50,  0% = < -80
4238          * Rx errors: 100% = 0, 0% = 50% missed
4239          *
4240          * The lowest computed quality is used.
4241          *
4242          */
4243 #define BEACON_THRESHOLD 5
4244         beacon_quality = 100 - missed_beacons_percent;
4245         if (beacon_quality < BEACON_THRESHOLD)
4246                 beacon_quality = 0;
4247         else
4248                 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
4249                     (100 - BEACON_THRESHOLD);
4250         IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
4251                         beacon_quality, missed_beacons_percent);
4252
4253         priv->last_rate = ipw_get_current_rate(priv);
4254         max_rate = ipw_get_max_rate(priv);
4255         rate_quality = priv->last_rate * 40 / max_rate + 60;
4256         IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
4257                         rate_quality, priv->last_rate / 1000000);
4258
4259         if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
4260                 rx_quality = 100 - (rx_err_delta * 100) /
4261                     (rx_packets_delta + rx_err_delta);
4262         else
4263                 rx_quality = 100;
4264         IPW_DEBUG_STATS("Rx quality   : %3d%% (%u errors, %u packets)\n",
4265                         rx_quality, rx_err_delta, rx_packets_delta);
4266
4267         if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
4268                 tx_quality = 100 - (tx_failures_delta * 100) /
4269                     (tx_packets_delta + tx_failures_delta);
4270         else
4271                 tx_quality = 100;
4272         IPW_DEBUG_STATS("Tx quality   : %3d%% (%u errors, %u packets)\n",
4273                         tx_quality, tx_failures_delta, tx_packets_delta);
4274
4275         rssi = priv->exp_avg_rssi;
4276         signal_quality =
4277             (100 *
4278              (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4279              (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
4280              (priv->ieee->perfect_rssi - rssi) *
4281              (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
4282               62 * (priv->ieee->perfect_rssi - rssi))) /
4283             ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4284              (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
4285         if (signal_quality > 100)
4286                 signal_quality = 100;
4287         else if (signal_quality < 1)
4288                 signal_quality = 0;
4289
4290         IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
4291                         signal_quality, rssi);
4292
4293         quality = min(rx_quality, signal_quality);
4294         quality = min(tx_quality, quality);
4295         quality = min(rate_quality, quality);
4296         quality = min(beacon_quality, quality);
4297         if (quality == beacon_quality)
4298                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
4299                                 quality);
4300         if (quality == rate_quality)
4301                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
4302                                 quality);
4303         if (quality == tx_quality)
4304                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
4305                                 quality);
4306         if (quality == rx_quality)
4307                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
4308                                 quality);
4309         if (quality == signal_quality)
4310                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
4311                                 quality);
4312
4313         priv->quality = quality;
4314
4315         schedule_delayed_work(&priv->gather_stats, IPW_STATS_INTERVAL);
4316 }
4317
4318 static void ipw_bg_gather_stats(struct work_struct *work)
4319 {
4320         struct ipw_priv *priv =
4321                 container_of(work, struct ipw_priv, gather_stats.work);
4322         mutex_lock(&priv->mutex);
4323         ipw_gather_stats(priv);
4324         mutex_unlock(&priv->mutex);
4325 }
4326
4327 /* Missed beacon behavior:
4328  * 1st missed -> roaming_threshold, just wait, don't do any scan/roam.
4329  * roaming_threshold -> disassociate_threshold, scan and roam for better signal.
4330  * Above disassociate threshold, give up and stop scanning.
4331  * Roaming is disabled if disassociate_threshold <= roaming_threshold  */
4332 static void ipw_handle_missed_beacon(struct ipw_priv *priv,
4333                                             int missed_count)
4334 {
4335         priv->notif_missed_beacons = missed_count;
4336
4337         if (missed_count > priv->disassociate_threshold &&
4338             priv->status & STATUS_ASSOCIATED) {
4339                 /* If associated and we've hit the missed
4340                  * beacon threshold, disassociate, turn
4341                  * off roaming, and abort any active scans */
4342                 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4343                           IPW_DL_STATE | IPW_DL_ASSOC,
4344                           "Missed beacon: %d - disassociate\n", missed_count);
4345                 priv->status &= ~STATUS_ROAMING;
4346                 if (priv->status & STATUS_SCANNING) {
4347                         IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4348                                   IPW_DL_STATE,
4349                                   "Aborting scan with missed beacon.\n");
4350                         schedule_work(&priv->abort_scan);
4351                 }
4352
4353                 schedule_work(&priv->disassociate);
4354                 return;
4355         }
4356
4357         if (priv->status & STATUS_ROAMING) {
4358                 /* If we are currently roaming, then just
4359                  * print a debug statement... */
4360                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4361                           "Missed beacon: %d - roam in progress\n",
4362                           missed_count);
4363                 return;
4364         }
4365
4366         if (roaming &&
4367             (missed_count > priv->roaming_threshold &&
4368              missed_count <= priv->disassociate_threshold)) {
4369                 /* If we are not already roaming, set the ROAM
4370                  * bit in the status and kick off a scan.
4371                  * This can happen several times before we reach
4372                  * disassociate_threshold. */
4373                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4374                           "Missed beacon: %d - initiate "
4375                           "roaming\n", missed_count);
4376                 if (!(priv->status & STATUS_ROAMING)) {
4377                         priv->status |= STATUS_ROAMING;
4378                         if (!(priv->status & STATUS_SCANNING))
4379                                 schedule_delayed_work(&priv->request_scan, 0);
4380                 }
4381                 return;
4382         }
4383
4384         if (priv->status & STATUS_SCANNING &&
4385             missed_count > IPW_MB_SCAN_CANCEL_THRESHOLD) {
4386                 /* Stop scan to keep fw from getting
4387                  * stuck (only if we aren't roaming --
4388                  * otherwise we'll never scan more than 2 or 3
4389                  * channels..) */
4390                 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF | IPW_DL_STATE,
4391                           "Aborting scan with missed beacon.\n");
4392                 schedule_work(&priv->abort_scan);
4393         }
4394
4395         IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);
4396 }
4397
4398 static void ipw_scan_event(struct work_struct *work)
4399 {
4400         union iwreq_data wrqu;
4401
4402         struct ipw_priv *priv =
4403                 container_of(work, struct ipw_priv, scan_event.work);
4404
4405         wrqu.data.length = 0;
4406         wrqu.data.flags = 0;
4407         wireless_send_event(priv->net_dev, SIOCGIWSCAN, &wrqu, NULL);
4408 }
4409
4410 static void handle_scan_event(struct ipw_priv *priv)
4411 {
4412         /* Only userspace-requested scan completion events go out immediately */
4413         if (!priv->user_requested_scan) {
4414                 schedule_delayed_work(&priv->scan_event,
4415                                       round_jiffies_relative(msecs_to_jiffies(4000)));
4416         } else {
4417                 priv->user_requested_scan = 0;
4418                 mod_delayed_work(system_wq, &priv->scan_event, 0);
4419         }
4420 }
4421
4422 /*
4423  * Handle host notification packet.
4424  * Called from interrupt routine
4425  */
4426 static void ipw_rx_notification(struct ipw_priv *priv,
4427                                        struct ipw_rx_notification *notif)
4428 {
4429         u16 size = le16_to_cpu(notif->size);
4430
4431         IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, size);
4432
4433         switch (notif->subtype) {
4434         case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
4435                         struct notif_association *assoc = &notif->u.assoc;
4436
4437                         switch (assoc->state) {
4438                         case CMAS_ASSOCIATED:{
4439                                         IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4440                                                   IPW_DL_ASSOC,
4441                                                   "associated: '%*pE' %pM\n",
4442                                                   priv->essid_len, priv->essid,
4443                                                   priv->bssid);
4444
4445                                         switch (priv->ieee->iw_mode) {
4446                                         case IW_MODE_INFRA:
4447                                                 memcpy(priv->ieee->bssid,
4448                                                        priv->bssid, ETH_ALEN);
4449                                                 break;
4450
4451                                         case IW_MODE_ADHOC:
4452                                                 memcpy(priv->ieee->bssid,
4453                                                        priv->bssid, ETH_ALEN);
4454
4455                                                 /* clear out the station table */
4456                                                 priv->num_stations = 0;
4457
4458                                                 IPW_DEBUG_ASSOC
4459                                                     ("queueing adhoc check\n");
4460                                                 schedule_delayed_work(
4461                                                         &priv->adhoc_check,
4462                                                         le16_to_cpu(priv->
4463                                                         assoc_request.
4464                                                         beacon_interval));
4465                                                 break;
4466                                         }
4467
4468                                         priv->status &= ~STATUS_ASSOCIATING;
4469                                         priv->status |= STATUS_ASSOCIATED;
4470                                         schedule_work(&priv->system_config);
4471
4472 #ifdef CONFIG_IPW2200_QOS
4473 #define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
4474                          le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_control))
4475                                         if ((priv->status & STATUS_AUTH) &&
4476                                             (IPW_GET_PACKET_STYPE(&notif->u.raw)
4477                                              == IEEE80211_STYPE_ASSOC_RESP)) {
4478                                                 if ((sizeof
4479                                                      (struct
4480                                                       libipw_assoc_response)
4481                                                      <= size)
4482                                                     && (size <= 2314)) {
4483                                                         struct
4484                                                         libipw_rx_stats
4485                                                             stats = {
4486                                                                 .len = size - 1,
4487                                                         };
4488
4489                                                         IPW_DEBUG_QOS
4490                                                             ("QoS Associate "
4491                                                              "size %d\n", size);
4492                                                         libipw_rx_mgt(priv->
4493                                                                          ieee,
4494                                                                          (struct
4495                                                                           libipw_hdr_4addr
4496                                                                           *)
4497                                                                          &notif->u.raw, &stats);
4498                                                 }
4499                                         }
4500 #endif
4501
4502                                         schedule_work(&priv->link_up);
4503
4504                                         break;
4505                                 }
4506
4507                         case CMAS_AUTHENTICATED:{
4508                                         if (priv->
4509                                             status & (STATUS_ASSOCIATED |
4510                                                       STATUS_AUTH)) {
4511                                                 struct notif_authenticate *auth
4512                                                     = &notif->u.auth;
4513                                                 IPW_DEBUG(IPW_DL_NOTIF |
4514                                                           IPW_DL_STATE |
4515                                                           IPW_DL_ASSOC,
4516                                                           "deauthenticated: '%*pE' %pM: (0x%04X) - %s\n",
4517                                                           priv->essid_len,
4518                                                           priv->essid,
4519                                                           priv->bssid,
4520                                                           le16_to_cpu(auth->status),
4521                                                           ipw_get_status_code
4522                                                           (le16_to_cpu
4523                                                            (auth->status)));
4524
4525                                                 priv->status &=
4526                                                     ~(STATUS_ASSOCIATING |
4527                                                       STATUS_AUTH |
4528                                                       STATUS_ASSOCIATED);
4529
4530                                                 schedule_work(&priv->link_down);
4531                                                 break;
4532                                         }
4533
4534                                         IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4535                                                   IPW_DL_ASSOC,
4536                                                   "authenticated: '%*pE' %pM\n",
4537                                                   priv->essid_len, priv->essid,
4538                                                   priv->bssid);
4539                                         break;
4540                                 }
4541
4542                         case CMAS_INIT:{
4543                                         if (priv->status & STATUS_AUTH) {
4544                                                 struct
4545                                                     libipw_assoc_response
4546                                                 *resp;
4547                                                 resp =
4548                                                     (struct
4549                                                      libipw_assoc_response
4550                                                      *)&notif->u.raw;
4551                                                 IPW_DEBUG(IPW_DL_NOTIF |
4552                                                           IPW_DL_STATE |
4553                                                           IPW_DL_ASSOC,
4554                                                           "association failed (0x%04X): %s\n",
4555                                                           le16_to_cpu(resp->status),
4556                                                           ipw_get_status_code
4557                                                           (le16_to_cpu
4558                                                            (resp->status)));
4559                                         }
4560
4561                                         IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4562                                                   IPW_DL_ASSOC,
4563                                                   "disassociated: '%*pE' %pM\n",
4564                                                   priv->essid_len, priv->essid,
4565                                                   priv->bssid);
4566
4567                                         priv->status &=
4568                                             ~(STATUS_DISASSOCIATING |
4569                                               STATUS_ASSOCIATING |
4570                                               STATUS_ASSOCIATED | STATUS_AUTH);
4571                                         if (priv->assoc_network
4572                                             && (priv->assoc_network->
4573                                                 capability &
4574                                                 WLAN_CAPABILITY_IBSS))
4575                                                 ipw_remove_current_network
4576                                                     (priv);
4577
4578                                         schedule_work(&priv->link_down);
4579
4580                                         break;
4581                                 }
4582
4583                         case CMAS_RX_ASSOC_RESP:
4584                                 break;
4585
4586                         default:
4587                                 IPW_ERROR("assoc: unknown (%d)\n",
4588                                           assoc->state);
4589                                 break;
4590                         }
4591
4592                         break;
4593                 }
4594
4595         case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
4596                         struct notif_authenticate *auth = &notif->u.auth;
4597                         switch (auth->state) {
4598                         case CMAS_AUTHENTICATED:
4599                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4600                                           "authenticated: '%*pE' %pM\n",
4601                                           priv->essid_len, priv->essid,
4602                                           priv->bssid);
4603                                 priv->status |= STATUS_AUTH;
4604                                 break;
4605
4606                         case CMAS_INIT:
4607                                 if (priv->status & STATUS_AUTH) {
4608                                         IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4609                                                   IPW_DL_ASSOC,
4610                                                   "authentication failed (0x%04X): %s\n",
4611                                                   le16_to_cpu(auth->status),
4612                                                   ipw_get_status_code(le16_to_cpu
4613                                                                       (auth->
4614                                                                        status)));
4615                                 }
4616                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4617                                           IPW_DL_ASSOC,
4618                                           "deauthenticated: '%*pE' %pM\n",
4619                                           priv->essid_len, priv->essid,
4620                                           priv->bssid);
4621
4622                                 priv->status &= ~(STATUS_ASSOCIATING |
4623                                                   STATUS_AUTH |
4624                                                   STATUS_ASSOCIATED);
4625
4626                                 schedule_work(&priv->link_down);
4627                                 break;
4628
4629                         case CMAS_TX_AUTH_SEQ_1:
4630                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4631                                           IPW_DL_ASSOC, "AUTH_SEQ_1\n");
4632                                 break;
4633                         case CMAS_RX_AUTH_SEQ_2:
4634                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4635                                           IPW_DL_ASSOC, "AUTH_SEQ_2\n");
4636                                 break;
4637                         case CMAS_AUTH_SEQ_1_PASS:
4638                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4639                                           IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
4640                                 break;
4641                         case CMAS_AUTH_SEQ_1_FAIL:
4642                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4643                                           IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
4644                                 break;
4645                         case CMAS_TX_AUTH_SEQ_3:
4646                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4647                                           IPW_DL_ASSOC, "AUTH_SEQ_3\n");
4648                                 break;
4649                         case CMAS_RX_AUTH_SEQ_4:
4650                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4651                                           IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
4652                                 break;
4653                         case CMAS_AUTH_SEQ_2_PASS:
4654                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4655                                           IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
4656                                 break;
4657                         case CMAS_AUTH_SEQ_2_FAIL:
4658                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4659                                           IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
4660                                 break;
4661                         case CMAS_TX_ASSOC:
4662                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4663                                           IPW_DL_ASSOC, "TX_ASSOC\n");
4664                                 break;
4665                         case CMAS_RX_ASSOC_RESP:
4666                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4667                                           IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
4668
4669                                 break;
4670                         case CMAS_ASSOCIATED:
4671                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4672                                           IPW_DL_ASSOC, "ASSOCIATED\n");
4673                                 break;
4674                         default:
4675                                 IPW_DEBUG_NOTIF("auth: failure - %d\n",
4676                                                 auth->state);
4677                                 break;
4678                         }
4679                         break;
4680                 }
4681
4682         case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
4683                         struct notif_channel_result *x =
4684                             &notif->u.channel_result;
4685
4686                         if (size == sizeof(*x)) {
4687                                 IPW_DEBUG_SCAN("Scan result for channel %d\n",
4688                                                x->channel_num);
4689                         } else {
4690                                 IPW_DEBUG_SCAN("Scan result of wrong size %d "
4691                                                "(should be %zd)\n",
4692                                                size, sizeof(*x));
4693                         }
4694                         break;
4695                 }
4696
4697         case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
4698                         struct notif_scan_complete *x = &notif->u.scan_complete;
4699                         if (size == sizeof(*x)) {
4700                                 IPW_DEBUG_SCAN
4701                                     ("Scan completed: type %d, %d channels, "
4702                                      "%d status\n", x->scan_type,
4703                                      x->num_channels, x->status);
4704                         } else {
4705                                 IPW_ERROR("Scan completed of wrong size %d "
4706                                           "(should be %zd)\n",
4707                                           size, sizeof(*x));
4708                         }
4709
4710                         priv->status &=
4711                             ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
4712
4713                         wake_up_interruptible(&priv->wait_state);
4714                         cancel_delayed_work(&priv->scan_check);
4715
4716                         if (priv->status & STATUS_EXIT_PENDING)
4717                                 break;
4718
4719                         priv->ieee->scans++;
4720
4721 #ifdef CONFIG_IPW2200_MONITOR
4722                         if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
4723                                 priv->status |= STATUS_SCAN_FORCED;
4724                                 schedule_delayed_work(&priv->request_scan, 0);
4725                                 break;
4726                         }
4727                         priv->status &= ~STATUS_SCAN_FORCED;
4728 #endif                          /* CONFIG_IPW2200_MONITOR */
4729
4730                         /* Do queued direct scans first */
4731                         if (priv->status & STATUS_DIRECT_SCAN_PENDING)
4732                                 schedule_delayed_work(&priv->request_direct_scan, 0);
4733
4734                         if (!(priv->status & (STATUS_ASSOCIATED |
4735                                               STATUS_ASSOCIATING |
4736                                               STATUS_ROAMING |
4737                                               STATUS_DISASSOCIATING)))
4738                                 schedule_work(&priv->associate);
4739                         else if (priv->status & STATUS_ROAMING) {
4740                                 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4741                                         /* If a scan completed and we are in roam mode, then
4742                                          * the scan that completed was the one requested as a
4743                                          * result of entering roam... so, schedule the
4744                                          * roam work */
4745                                         schedule_work(&priv->roam);
4746                                 else
4747                                         /* Don't schedule if we aborted the scan */
4748                                         priv->status &= ~STATUS_ROAMING;
4749                         } else if (priv->status & STATUS_SCAN_PENDING)
4750                                 schedule_delayed_work(&priv->request_scan, 0);
4751                         else if (priv->config & CFG_BACKGROUND_SCAN
4752                                  && priv->status & STATUS_ASSOCIATED)
4753                                 schedule_delayed_work(&priv->request_scan,
4754                                                       round_jiffies_relative(HZ));
4755
4756                         /* Send an empty event to user space.
4757                          * We don't send the received data on the event because
4758                          * it would require us to do complex transcoding, and
4759                          * we want to minimise the work done in the irq handler
4760                          * Use a request to extract the data.
4761                          * Also, we generate this even for any scan, regardless
4762                          * on how the scan was initiated. User space can just
4763                          * sync on periodic scan to get fresh data...
4764                          * Jean II */
4765                         if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4766                                 handle_scan_event(priv);
4767                         break;
4768                 }
4769
4770         case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
4771                         struct notif_frag_length *x = &notif->u.frag_len;
4772
4773                         if (size == sizeof(*x))
4774                                 IPW_ERROR("Frag length: %d\n",
4775                                           le16_to_cpu(x->frag_length));
4776                         else
4777                                 IPW_ERROR("Frag length of wrong size %d "
4778                                           "(should be %zd)\n",
4779                                           size, sizeof(*x));
4780                         break;
4781                 }
4782
4783         case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
4784                         struct notif_link_deterioration *x =
4785                             &notif->u.link_deterioration;
4786
4787                         if (size == sizeof(*x)) {
4788                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4789                                         "link deterioration: type %d, cnt %d\n",
4790                                         x->silence_notification_type,
4791                                         x->silence_count);
4792                                 memcpy(&priv->last_link_deterioration, x,
4793                                        sizeof(*x));
4794                         } else {
4795                                 IPW_ERROR("Link Deterioration of wrong size %d "
4796                                           "(should be %zd)\n",
4797                                           size, sizeof(*x));
4798                         }
4799                         break;
4800                 }
4801
4802         case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
4803                         IPW_ERROR("Dino config\n");
4804                         if (priv->hcmd
4805                             && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
4806                                 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
4807
4808                         break;
4809                 }
4810
4811         case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
4812                         struct notif_beacon_state *x = &notif->u.beacon_state;
4813                         if (size != sizeof(*x)) {
4814                                 IPW_ERROR
4815                                     ("Beacon state of wrong size %d (should "
4816                                      "be %zd)\n", size, sizeof(*x));
4817                                 break;
4818                         }
4819
4820                         if (le32_to_cpu(x->state) ==
4821                             HOST_NOTIFICATION_STATUS_BEACON_MISSING)
4822                                 ipw_handle_missed_beacon(priv,
4823                                                          le32_to_cpu(x->
4824                                                                      number));
4825
4826                         break;
4827                 }
4828
4829         case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
4830                         struct notif_tgi_tx_key *x = &notif->u.tgi_tx_key;
4831                         if (size == sizeof(*x)) {
4832                                 IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
4833                                           "0x%02x station %d\n",
4834                                           x->key_state, x->security_type,
4835                                           x->station_index);
4836                                 break;
4837                         }
4838
4839                         IPW_ERROR
4840                             ("TGi Tx Key of wrong size %d (should be %zd)\n",
4841                              size, sizeof(*x));
4842                         break;
4843                 }
4844
4845         case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
4846                         struct notif_calibration *x = &notif->u.calibration;
4847
4848                         if (size == sizeof(*x)) {
4849                                 memcpy(&priv->calib, x, sizeof(*x));
4850                                 IPW_DEBUG_INFO("TODO: Calibration\n");
4851                                 break;
4852                         }
4853
4854                         IPW_ERROR
4855                             ("Calibration of wrong size %d (should be %zd)\n",
4856                              size, sizeof(*x));
4857                         break;
4858                 }
4859
4860         case HOST_NOTIFICATION_NOISE_STATS:{
4861                         if (size == sizeof(u32)) {
4862                                 priv->exp_avg_noise =
4863                                     exponential_average(priv->exp_avg_noise,
4864                                     (u8) (le32_to_cpu(notif->u.noise.value) & 0xff),
4865                                     DEPTH_NOISE);
4866                                 break;
4867                         }
4868
4869                         IPW_ERROR
4870                             ("Noise stat is wrong size %d (should be %zd)\n",
4871                              size, sizeof(u32));
4872                         break;
4873                 }
4874
4875         default:
4876                 IPW_DEBUG_NOTIF("Unknown notification: "
4877                                 "subtype=%d,flags=0x%2x,size=%d\n",
4878                                 notif->subtype, notif->flags, size);
4879         }
4880 }
4881
4882 /*
4883  * Destroys all DMA structures and initialise them again
4884  *
4885  * @param priv
4886  * @return error code
4887  */
4888 static int ipw_queue_reset(struct ipw_priv *priv)
4889 {
4890         int rc = 0;
4891         /* @todo customize queue sizes */
4892         int nTx = 64, nTxCmd = 8;
4893         ipw_tx_queue_free(priv);
4894         /* Tx CMD queue */
4895         rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
4896                                IPW_TX_CMD_QUEUE_READ_INDEX,
4897                                IPW_TX_CMD_QUEUE_WRITE_INDEX,
4898                                IPW_TX_CMD_QUEUE_BD_BASE,
4899                                IPW_TX_CMD_QUEUE_BD_SIZE);
4900         if (rc) {
4901                 IPW_ERROR("Tx Cmd queue init failed\n");
4902                 goto error;
4903         }
4904         /* Tx queue(s) */
4905         rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
4906                                IPW_TX_QUEUE_0_READ_INDEX,
4907                                IPW_TX_QUEUE_0_WRITE_INDEX,
4908                                IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
4909         if (rc) {
4910                 IPW_ERROR("Tx 0 queue init failed\n");
4911                 goto error;
4912         }
4913         rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
4914                                IPW_TX_QUEUE_1_READ_INDEX,
4915                                IPW_TX_QUEUE_1_WRITE_INDEX,
4916                                IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
4917         if (rc) {
4918                 IPW_ERROR("Tx 1 queue init failed\n");
4919                 goto error;
4920         }
4921         rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
4922                                IPW_TX_QUEUE_2_READ_INDEX,
4923                                IPW_TX_QUEUE_2_WRITE_INDEX,
4924                                IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
4925         if (rc) {
4926                 IPW_ERROR("Tx 2 queue init failed\n");
4927                 goto error;
4928         }
4929         rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
4930                                IPW_TX_QUEUE_3_READ_INDEX,
4931                                IPW_TX_QUEUE_3_WRITE_INDEX,
4932                                IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
4933         if (rc) {
4934                 IPW_ERROR("Tx 3 queue init failed\n");
4935                 goto error;
4936         }
4937         /* statistics */
4938         priv->rx_bufs_min = 0;
4939         priv->rx_pend_max = 0;
4940         return rc;
4941
4942       error:
4943         ipw_tx_queue_free(priv);
4944         return rc;
4945 }
4946
4947 /*
4948  * Reclaim Tx queue entries no more used by NIC.
4949  *
4950  * When FW advances 'R' index, all entries between old and
4951  * new 'R' index need to be reclaimed. As result, some free space
4952  * forms. If there is enough free space (> low mark), wake Tx queue.
4953  *
4954  * @note Need to protect against garbage in 'R' index
4955  * @param priv
4956  * @param txq
4957  * @param qindex
4958  * @return Number of used entries remains in the queue
4959  */
4960 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
4961                                 struct clx2_tx_queue *txq, int qindex)
4962 {
4963         u32 hw_tail;
4964         int used;
4965         struct clx2_queue *q = &txq->q;
4966
4967         hw_tail = ipw_read32(priv, q->reg_r);
4968         if (hw_tail >= q->n_bd) {
4969                 IPW_ERROR
4970                     ("Read index for DMA queue (%d) is out of range [0-%d)\n",
4971                      hw_tail, q->n_bd);
4972                 goto done;
4973         }
4974         for (; q->last_used != hw_tail;
4975              q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
4976                 ipw_queue_tx_free_tfd(priv, txq);
4977                 priv->tx_packets++;
4978         }
4979       done:
4980         if ((ipw_tx_queue_space(q) > q->low_mark) &&
4981             (qindex >= 0))
4982                 netif_wake_queue(priv->net_dev);
4983         used = q->first_empty - q->last_used;
4984         if (used < 0)
4985                 used += q->n_bd;
4986
4987         return used;
4988 }
4989
4990 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, const void *buf,
4991                              int len, int sync)
4992 {
4993         struct clx2_tx_queue *txq = &priv->txq_cmd;
4994         struct clx2_queue *q = &txq->q;
4995         struct tfd_frame *tfd;
4996
4997         if (ipw_tx_queue_space(q) < (sync ? 1 : 2)) {
4998                 IPW_ERROR("No space for Tx\n");
4999                 return -EBUSY;
5000         }
5001
5002         tfd = &txq->bd[q->first_empty];
5003         txq->txb[q->first_empty] = NULL;
5004
5005         memset(tfd, 0, sizeof(*tfd));
5006         tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
5007         tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
5008         priv->hcmd_seq++;
5009         tfd->u.cmd.index = hcmd;
5010         tfd->u.cmd.length = len;
5011         memcpy(tfd->u.cmd.payload, buf, len);
5012         q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
5013         ipw_write32(priv, q->reg_w, q->first_empty);
5014         _ipw_read32(priv, 0x90);
5015
5016         return 0;
5017 }
5018
5019 /*
5020  * Rx theory of operation
5021  *
5022  * The host allocates 32 DMA target addresses and passes the host address
5023  * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
5024  * 0 to 31
5025  *
5026  * Rx Queue Indexes
5027  * The host/firmware share two index registers for managing the Rx buffers.
5028  *
5029  * The READ index maps to the first position that the firmware may be writing
5030  * to -- the driver can read up to (but not including) this position and get
5031  * good data.
5032  * The READ index is managed by the firmware once the card is enabled.
5033  *
5034  * The WRITE index maps to the last position the driver has read from -- the
5035  * position preceding WRITE is the last slot the firmware can place a packet.
5036  *
5037  * The queue is empty (no good data) if WRITE = READ - 1, and is full if
5038  * WRITE = READ.
5039  *
5040  * During initialization the host sets up the READ queue position to the first
5041  * INDEX position, and WRITE to the last (READ - 1 wrapped)
5042  *
5043  * When the firmware places a packet in a buffer it will advance the READ index
5044  * and fire the RX interrupt.  The driver can then query the READ index and
5045  * process as many packets as possible, moving the WRITE index forward as it
5046  * resets the Rx queue buffers with new memory.
5047  *
5048  * The management in the driver is as follows:
5049  * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free.  When
5050  *   ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
5051  *   to replensish the ipw->rxq->rx_free.
5052  * + In ipw_rx_queue_replenish (scheduled) if 'processed' != 'read' then the
5053  *   ipw->rxq is replenished and the READ INDEX is updated (updating the
5054  *   'processed' and 'read' driver indexes as well)
5055  * + A received packet is processed and handed to the kernel network stack,
5056  *   detached from the ipw->rxq.  The driver 'processed' index is updated.
5057  * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
5058  *   list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
5059  *   INDEX is not incremented and ipw->status(RX_STALLED) is set.  If there
5060  *   were enough free buffers and RX_STALLED is set it is cleared.
5061  *
5062  *
5063  * Driver sequence:
5064  *
5065  * ipw_rx_queue_alloc()       Allocates rx_free
5066  * ipw_rx_queue_replenish()   Replenishes rx_free list from rx_used, and calls
5067  *                            ipw_rx_queue_restock
5068  * ipw_rx_queue_restock()     Moves available buffers from rx_free into Rx
5069  *                            queue, updates firmware pointers, and updates
5070  *                            the WRITE index.  If insufficient rx_free buffers
5071  *                            are available, schedules ipw_rx_queue_replenish
5072  *
5073  * -- enable interrupts --
5074  * ISR - ipw_rx()             Detach ipw_rx_mem_buffers from pool up to the
5075  *                            READ INDEX, detaching the SKB from the pool.
5076  *                            Moves the packet buffer from queue to rx_used.
5077  *                            Calls ipw_rx_queue_restock to refill any empty
5078  *                            slots.
5079  * ...
5080  *
5081  */
5082
5083 /*
5084  * If there are slots in the RX queue that  need to be restocked,
5085  * and we have free pre-allocated buffers, fill the ranks as much
5086  * as we can pulling from rx_free.
5087  *
5088  * This moves the 'write' index forward to catch up with 'processed', and
5089  * also updates the memory address in the firmware to reference the new
5090  * target buffer.
5091  */
5092 static void ipw_rx_queue_restock(struct ipw_priv *priv)
5093 {
5094         struct ipw_rx_queue *rxq = priv->rxq;
5095         struct list_head *element;
5096         struct ipw_rx_mem_buffer *rxb;
5097         unsigned long flags;
5098         int write;
5099
5100         spin_lock_irqsave(&rxq->lock, flags);
5101         write = rxq->write;
5102         while ((ipw_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
5103                 element = rxq->rx_free.next;
5104                 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
5105                 list_del(element);
5106
5107                 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
5108                             rxb->dma_addr);
5109                 rxq->queue[rxq->write] = rxb;
5110                 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
5111                 rxq->free_count--;
5112         }
5113         spin_unlock_irqrestore(&rxq->lock, flags);
5114
5115         /* If the pre-allocated buffer pool is dropping low, schedule to
5116          * refill it */
5117         if (rxq->free_count <= RX_LOW_WATERMARK)
5118                 schedule_work(&priv->rx_replenish);
5119
5120         /* If we've added more space for the firmware to place data, tell it */
5121         if (write != rxq->write)
5122                 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
5123 }
5124
5125 /*
5126  * Move all used packet from rx_used to rx_free, allocating a new SKB for each.
5127  * Also restock the Rx queue via ipw_rx_queue_restock.
5128  *
5129  * This is called as a scheduled work item (except for during initialization)
5130  */
5131 static void ipw_rx_queue_replenish(void *data)
5132 {
5133         struct ipw_priv *priv = data;
5134         struct ipw_rx_queue *rxq = priv->rxq;
5135         struct list_head *element;
5136         struct ipw_rx_mem_buffer *rxb;
5137         unsigned long flags;
5138
5139         spin_lock_irqsave(&rxq->lock, flags);
5140         while (!list_empty(&rxq->rx_used)) {
5141                 element = rxq->rx_used.next;
5142                 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
5143                 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
5144                 if (!rxb->skb) {
5145                         printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
5146                                priv->net_dev->name);
5147                         /* We don't reschedule replenish work here -- we will
5148                          * call the restock method and if it still needs
5149                          * more buffers it will schedule replenish */
5150                         break;
5151                 }
5152                 list_del(element);
5153
5154                 rxb->dma_addr =
5155                     dma_map_single(&priv->pci_dev->dev, rxb->skb->data,
5156                                    IPW_RX_BUF_SIZE, DMA_FROM_DEVICE);
5157
5158                 list_add_tail(&rxb->list, &rxq->rx_free);
5159                 rxq->free_count++;
5160         }
5161         spin_unlock_irqrestore(&rxq->lock, flags);
5162
5163         ipw_rx_queue_restock(priv);
5164 }
5165
5166 static void ipw_bg_rx_queue_replenish(struct work_struct *work)
5167 {
5168         struct ipw_priv *priv =
5169                 container_of(work, struct ipw_priv, rx_replenish);
5170         mutex_lock(&priv->mutex);
5171         ipw_rx_queue_replenish(priv);
5172         mutex_unlock(&priv->mutex);
5173 }
5174
5175 /* Assumes that the skb field of the buffers in 'pool' is kept accurate.
5176  * If an SKB has been detached, the POOL needs to have its SKB set to NULL
5177  * This free routine walks the list of POOL entries and if SKB is set to
5178  * non NULL it is unmapped and freed
5179  */
5180 static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
5181 {
5182         int i;
5183
5184         if (!rxq)
5185                 return;
5186
5187         for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
5188                 if (rxq->pool[i].skb != NULL) {
5189                         dma_unmap_single(&priv->pci_dev->dev,
5190                                          rxq->pool[i].dma_addr,
5191                                          IPW_RX_BUF_SIZE, DMA_FROM_DEVICE);
5192                         dev_kfree_skb(rxq->pool[i].skb);
5193                 }
5194         }
5195
5196         kfree(rxq);
5197 }
5198
5199 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
5200 {
5201         struct ipw_rx_queue *rxq;
5202         int i;
5203
5204         rxq = kzalloc(sizeof(*rxq), GFP_KERNEL);
5205         if (unlikely(!rxq)) {
5206                 IPW_ERROR("memory allocation failed\n");
5207                 return NULL;
5208         }
5209         spin_lock_init(&rxq->lock);
5210         INIT_LIST_HEAD(&rxq->rx_free);
5211         INIT_LIST_HEAD(&rxq->rx_used);
5212
5213         /* Fill the rx_used queue with _all_ of the Rx buffers */
5214         for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
5215                 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
5216
5217         /* Set us so that we have processed and used all buffers, but have
5218          * not restocked the Rx queue with fresh buffers */
5219         rxq->read = rxq->write = 0;
5220         rxq->free_count = 0;
5221
5222         return rxq;
5223 }
5224
5225 static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
5226 {
5227         rate &= ~LIBIPW_BASIC_RATE_MASK;
5228         if (ieee_mode == IEEE_A) {
5229                 switch (rate) {
5230                 case LIBIPW_OFDM_RATE_6MB:
5231                         return priv->rates_mask & LIBIPW_OFDM_RATE_6MB_MASK ?
5232                             1 : 0;
5233                 case LIBIPW_OFDM_RATE_9MB:
5234                         return priv->rates_mask & LIBIPW_OFDM_RATE_9MB_MASK ?
5235                             1 : 0;
5236                 case LIBIPW_OFDM_RATE_12MB:
5237                         return priv->
5238                             rates_mask & LIBIPW_OFDM_RATE_12MB_MASK ? 1 : 0;
5239                 case LIBIPW_OFDM_RATE_18MB:
5240                         return priv->
5241                             rates_mask & LIBIPW_OFDM_RATE_18MB_MASK ? 1 : 0;
5242                 case LIBIPW_OFDM_RATE_24MB:
5243                         return priv->
5244                             rates_mask & LIBIPW_OFDM_RATE_24MB_MASK ? 1 : 0;
5245                 case LIBIPW_OFDM_RATE_36MB:
5246                         return priv->
5247                             rates_mask & LIBIPW_OFDM_RATE_36MB_MASK ? 1 : 0;
5248                 case LIBIPW_OFDM_RATE_48MB:
5249                         return priv->
5250                             rates_mask & LIBIPW_OFDM_RATE_48MB_MASK ? 1 : 0;
5251                 case LIBIPW_OFDM_RATE_54MB:
5252                         return priv->
5253                             rates_mask & LIBIPW_OFDM_RATE_54MB_MASK ? 1 : 0;
5254                 default:
5255                         return 0;
5256                 }
5257         }
5258
5259         /* B and G mixed */
5260         switch (rate) {
5261         case LIBIPW_CCK_RATE_1MB:
5262                 return priv->rates_mask & LIBIPW_CCK_RATE_1MB_MASK ? 1 : 0;
5263         case LIBIPW_CCK_RATE_2MB:
5264                 return priv->rates_mask & LIBIPW_CCK_RATE_2MB_MASK ? 1 : 0;
5265         case LIBIPW_CCK_RATE_5MB:
5266                 return priv->rates_mask & LIBIPW_CCK_RATE_5MB_MASK ? 1 : 0;
5267         case LIBIPW_CCK_RATE_11MB:
5268                 return priv->rates_mask & LIBIPW_CCK_RATE_11MB_MASK ? 1 : 0;
5269         }
5270
5271         /* If we are limited to B modulations, bail at this point */
5272         if (ieee_mode == IEEE_B)
5273                 return 0;
5274
5275         /* G */
5276         switch (rate) {
5277         case LIBIPW_OFDM_RATE_6MB:
5278                 return priv->rates_mask & LIBIPW_OFDM_RATE_6MB_MASK ? 1 : 0;
5279         case LIBIPW_OFDM_RATE_9MB:
5280                 return priv->rates_mask & LIBIPW_OFDM_RATE_9MB_MASK ? 1 : 0;
5281         case LIBIPW_OFDM_RATE_12MB:
5282                 return priv->rates_mask & LIBIPW_OFDM_RATE_12MB_MASK ? 1 : 0;
5283         case LIBIPW_OFDM_RATE_18MB:
5284                 return priv->rates_mask & LIBIPW_OFDM_RATE_18MB_MASK ? 1 : 0;
5285         case LIBIPW_OFDM_RATE_24MB:
5286                 return priv->rates_mask & LIBIPW_OFDM_RATE_24MB_MASK ? 1 : 0;
5287         case LIBIPW_OFDM_RATE_36MB:
5288                 return priv->rates_mask & LIBIPW_OFDM_RATE_36MB_MASK ? 1 : 0;
5289         case LIBIPW_OFDM_RATE_48MB:
5290                 return priv->rates_mask & LIBIPW_OFDM_RATE_48MB_MASK ? 1 : 0;
5291         case LIBIPW_OFDM_RATE_54MB:
5292                 return priv->rates_mask & LIBIPW_OFDM_RATE_54MB_MASK ? 1 : 0;
5293         }
5294
5295         return 0;
5296 }
5297
5298 static int ipw_compatible_rates(struct ipw_priv *priv,
5299                                 const struct libipw_network *network,
5300                                 struct ipw_supported_rates *rates)
5301 {
5302         int num_rates, i;
5303
5304         memset(rates, 0, sizeof(*rates));
5305         num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
5306         rates->num_rates = 0;
5307         for (i = 0; i < num_rates; i++) {
5308                 if (!ipw_is_rate_in_mask(priv, network->mode,
5309                                          network->rates[i])) {
5310
5311                         if (network->rates[i] & LIBIPW_BASIC_RATE_MASK) {
5312                                 IPW_DEBUG_SCAN("Adding masked mandatory "
5313                                                "rate %02X\n",
5314                                                network->rates[i]);
5315                                 rates->supported_rates[rates->num_rates++] =
5316                                     network->rates[i];
5317                                 continue;
5318                         }
5319
5320                         IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5321                                        network->rates[i], priv->rates_mask);
5322                         continue;
5323                 }
5324
5325                 rates->supported_rates[rates->num_rates++] = network->rates[i];
5326         }
5327
5328         num_rates = min(network->rates_ex_len,
5329                         (u8) (IPW_MAX_RATES - num_rates));
5330         for (i = 0; i < num_rates; i++) {
5331                 if (!ipw_is_rate_in_mask(priv, network->mode,
5332                                          network->rates_ex[i])) {
5333                         if (network->rates_ex[i] & LIBIPW_BASIC_RATE_MASK) {
5334                                 IPW_DEBUG_SCAN("Adding masked mandatory "
5335                                                "rate %02X\n",
5336                                                network->rates_ex[i]);
5337                                 rates->supported_rates[rates->num_rates++] =
5338                                     network->rates[i];
5339                                 continue;
5340                         }
5341
5342                         IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5343                                        network->rates_ex[i], priv->rates_mask);
5344                         continue;
5345                 }
5346
5347                 rates->supported_rates[rates->num_rates++] =
5348                     network->rates_ex[i];
5349         }
5350
5351         return 1;
5352 }
5353
5354 static void ipw_copy_rates(struct ipw_supported_rates *dest,
5355                                   const struct ipw_supported_rates *src)
5356 {
5357         u8 i;
5358         for (i = 0; i < src->num_rates; i++)
5359                 dest->supported_rates[i] = src->supported_rates[i];
5360         dest->num_rates = src->num_rates;
5361 }
5362
5363 /* TODO: Look at sniffed packets in the air to determine if the basic rate
5364  * mask should ever be used -- right now all callers to add the scan rates are
5365  * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
5366 static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
5367                                    u8 modulation, u32 rate_mask)
5368 {
5369         u8 basic_mask = (LIBIPW_OFDM_MODULATION == modulation) ?
5370             LIBIPW_BASIC_RATE_MASK : 0;
5371
5372         if (rate_mask & LIBIPW_CCK_RATE_1MB_MASK)
5373                 rates->supported_rates[rates->num_rates++] =
5374                     LIBIPW_BASIC_RATE_MASK | LIBIPW_CCK_RATE_1MB;
5375
5376         if (rate_mask & LIBIPW_CCK_RATE_2MB_MASK)
5377                 rates->supported_rates[rates->num_rates++] =
5378                     LIBIPW_BASIC_RATE_MASK | LIBIPW_CCK_RATE_2MB;
5379
5380         if (rate_mask & LIBIPW_CCK_RATE_5MB_MASK)
5381                 rates->supported_rates[rates->num_rates++] = basic_mask |
5382                     LIBIPW_CCK_RATE_5MB;
5383
5384         if (rate_mask & LIBIPW_CCK_RATE_11MB_MASK)
5385                 rates->supported_rates[rates->num_rates++] = basic_mask |
5386                     LIBIPW_CCK_RATE_11MB;
5387 }
5388
5389 static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
5390                                     u8 modulation, u32 rate_mask)
5391 {
5392         u8 basic_mask = (LIBIPW_OFDM_MODULATION == modulation) ?
5393             LIBIPW_BASIC_RATE_MASK : 0;
5394
5395         if (rate_mask & LIBIPW_OFDM_RATE_6MB_MASK)
5396                 rates->supported_rates[rates->num_rates++] = basic_mask |
5397                     LIBIPW_OFDM_RATE_6MB;
5398
5399         if (rate_mask & LIBIPW_OFDM_RATE_9MB_MASK)
5400                 rates->supported_rates[rates->num_rates++] =
5401                     LIBIPW_OFDM_RATE_9MB;
5402
5403         if (rate_mask & LIBIPW_OFDM_RATE_12MB_MASK)
5404                 rates->supported_rates[rates->num_rates++] = basic_mask |
5405                     LIBIPW_OFDM_RATE_12MB;
5406
5407         if (rate_mask & LIBIPW_OFDM_RATE_18MB_MASK)
5408                 rates->supported_rates[rates->num_rates++] =
5409                     LIBIPW_OFDM_RATE_18MB;
5410
5411         if (rate_mask & LIBIPW_OFDM_RATE_24MB_MASK)
5412                 rates->supported_rates[rates->num_rates++] = basic_mask |
5413                     LIBIPW_OFDM_RATE_24MB;
5414
5415         if (rate_mask & LIBIPW_OFDM_RATE_36MB_MASK)
5416                 rates->supported_rates[rates->num_rates++] =
5417                     LIBIPW_OFDM_RATE_36MB;
5418
5419         if (rate_mask & LIBIPW_OFDM_RATE_48MB_MASK)
5420                 rates->supported_rates[rates->num_rates++] =
5421                     LIBIPW_OFDM_RATE_48MB;
5422
5423         if (rate_mask & LIBIPW_OFDM_RATE_54MB_MASK)
5424                 rates->supported_rates[rates->num_rates++] =
5425                     LIBIPW_OFDM_RATE_54MB;
5426 }
5427
5428 struct ipw_network_match {
5429         struct libipw_network *network;
5430         struct ipw_supported_rates rates;
5431 };
5432
5433 static int ipw_find_adhoc_network(struct ipw_priv *priv,
5434                                   struct ipw_network_match *match,
5435                                   struct libipw_network *network,
5436                                   int roaming)
5437 {
5438         struct ipw_supported_rates rates;
5439
5440         /* Verify that this network's capability is compatible with the
5441          * current mode (AdHoc or Infrastructure) */
5442         if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
5443              !(network->capability & WLAN_CAPABILITY_IBSS))) {
5444                 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded due to capability mismatch.\n",
5445                                 network->ssid_len, network->ssid,
5446                                 network->bssid);
5447                 return 0;
5448         }
5449
5450         if (unlikely(roaming)) {
5451                 /* If we are roaming, then ensure check if this is a valid
5452                  * network to try and roam to */
5453                 if ((network->ssid_len != match->network->ssid_len) ||
5454                     memcmp(network->ssid, match->network->ssid,
5455                            network->ssid_len)) {
5456                         IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because of non-network ESSID.\n",
5457                                         network->ssid_len, network->ssid,
5458                                         network->bssid);
5459                         return 0;
5460                 }
5461         } else {
5462                 /* If an ESSID has been configured then compare the broadcast
5463                  * ESSID to ours */
5464                 if ((priv->config & CFG_STATIC_ESSID) &&
5465                     ((network->ssid_len != priv->essid_len) ||
5466                      memcmp(network->ssid, priv->essid,
5467                             min(network->ssid_len, priv->essid_len)))) {
5468                         IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because of ESSID mismatch: '%*pE'.\n",
5469                                         network->ssid_len, network->ssid,
5470                                         network->bssid, priv->essid_len,
5471                                         priv->essid);
5472                         return 0;
5473                 }
5474         }
5475
5476         /* If the old network rate is better than this one, don't bother
5477          * testing everything else. */
5478
5479         if (network->time_stamp[0] < match->network->time_stamp[0]) {
5480                 IPW_DEBUG_MERGE("Network '%*pE excluded because newer than current network.\n",
5481                                 match->network->ssid_len, match->network->ssid);
5482                 return 0;
5483         } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
5484                 IPW_DEBUG_MERGE("Network '%*pE excluded because newer than current network.\n",
5485                                 match->network->ssid_len, match->network->ssid);
5486                 return 0;
5487         }
5488
5489         /* Now go through and see if the requested network is valid... */
5490         if (priv->ieee->scan_age != 0 &&
5491             time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5492                 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because of age: %ums.\n",
5493                                 network->ssid_len, network->ssid,
5494                                 network->bssid,
5495                                 jiffies_to_msecs(jiffies -
5496                                                  network->last_scanned));
5497                 return 0;
5498         }
5499
5500         if ((priv->config & CFG_STATIC_CHANNEL) &&
5501             (network->channel != priv->channel)) {
5502                 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because of channel mismatch: %d != %d.\n",
5503                                 network->ssid_len, network->ssid,
5504                                 network->bssid,
5505                                 network->channel, priv->channel);
5506                 return 0;
5507         }
5508
5509         /* Verify privacy compatibility */
5510         if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5511             ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5512                 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because of privacy mismatch: %s != %s.\n",
5513                                 network->ssid_len, network->ssid,
5514                                 network->bssid,
5515                                 priv->
5516                                 capability & CAP_PRIVACY_ON ? "on" : "off",
5517                                 network->
5518                                 capability & WLAN_CAPABILITY_PRIVACY ? "on" :
5519                                 "off");
5520                 return 0;
5521         }
5522
5523         if (ether_addr_equal(network->bssid, priv->bssid)) {
5524                 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because of the same BSSID match: %pM.\n",
5525                                 network->ssid_len, network->ssid,
5526                                 network->bssid, priv->bssid);
5527                 return 0;
5528         }
5529
5530         /* Filter out any incompatible freq / mode combinations */
5531         if (!libipw_is_valid_mode(priv->ieee, network->mode)) {
5532                 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because of invalid frequency/mode combination.\n",
5533                                 network->ssid_len, network->ssid,
5534                                 network->bssid);
5535                 return 0;
5536         }
5537
5538         /* Ensure that the rates supported by the driver are compatible with
5539          * this AP, including verification of basic rates (mandatory) */
5540         if (!ipw_compatible_rates(priv, network, &rates)) {
5541                 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because configured rate mask excludes AP mandatory rate.\n",
5542                                 network->ssid_len, network->ssid,
5543                                 network->bssid);
5544                 return 0;
5545         }
5546
5547         if (rates.num_rates == 0) {
5548                 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because of no compatible rates.\n",
5549                                 network->ssid_len, network->ssid,
5550                                 network->bssid);
5551                 return 0;
5552         }
5553
5554         /* TODO: Perform any further minimal comparititive tests.  We do not
5555          * want to put too much policy logic here; intelligent scan selection
5556          * should occur within a generic IEEE 802.11 user space tool.  */
5557
5558         /* Set up 'new' AP to this network */
5559         ipw_copy_rates(&match->rates, &rates);
5560         match->network = network;
5561         IPW_DEBUG_MERGE("Network '%*pE (%pM)' is a viable match.\n",
5562                         network->ssid_len, network->ssid, network->bssid);
5563
5564         return 1;
5565 }
5566
5567 static void ipw_merge_adhoc_network(struct work_struct *work)
5568 {
5569         struct ipw_priv *priv =
5570                 container_of(work, struct ipw_priv, merge_networks);
5571         struct libipw_network *network = NULL;
5572         struct ipw_network_match match = {
5573                 .network = priv->assoc_network
5574         };
5575
5576         if ((priv->status & STATUS_ASSOCIATED) &&
5577             (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5578                 /* First pass through ROAM process -- look for a better
5579                  * network */
5580                 unsigned long flags;
5581
5582                 spin_lock_irqsave(&priv->ieee->lock, flags);
5583                 list_for_each_entry(network, &priv->ieee->network_list, list) {
5584                         if (network != priv->assoc_network)
5585                                 ipw_find_adhoc_network(priv, &match, network,
5586                                                        1);
5587                 }
5588                 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5589
5590                 if (match.network == priv->assoc_network) {
5591                         IPW_DEBUG_MERGE("No better ADHOC in this network to "
5592                                         "merge to.\n");
5593                         return;
5594                 }
5595
5596                 mutex_lock(&priv->mutex);
5597                 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
5598                         IPW_DEBUG_MERGE("remove network %*pE\n",
5599                                         priv->essid_len, priv->essid);
5600                         ipw_remove_current_network(priv);
5601                 }
5602
5603                 ipw_disassociate(priv);
5604                 priv->assoc_network = match.network;
5605                 mutex_unlock(&priv->mutex);
5606                 return;
5607         }
5608 }
5609
5610 static int ipw_best_network(struct ipw_priv *priv,
5611                             struct ipw_network_match *match,
5612                             struct libipw_network *network, int roaming)
5613 {
5614         struct ipw_supported_rates rates;
5615
5616         /* Verify that this network's capability is compatible with the
5617          * current mode (AdHoc or Infrastructure) */
5618         if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
5619              !(network->capability & WLAN_CAPABILITY_ESS)) ||
5620             (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5621              !(network->capability & WLAN_CAPABILITY_IBSS))) {
5622                 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded due to capability mismatch.\n",
5623                                 network->ssid_len, network->ssid,
5624                                 network->bssid);
5625                 return 0;
5626         }
5627
5628         if (unlikely(roaming)) {
5629                 /* If we are roaming, then ensure check if this is a valid
5630                  * network to try and roam to */
5631                 if ((network->ssid_len != match->network->ssid_len) ||
5632                     memcmp(network->ssid, match->network->ssid,
5633                            network->ssid_len)) {
5634                         IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of non-network ESSID.\n",
5635                                         network->ssid_len, network->ssid,
5636                                         network->bssid);
5637                         return 0;
5638                 }
5639         } else {
5640                 /* If an ESSID has been configured then compare the broadcast
5641                  * ESSID to ours */
5642                 if ((priv->config & CFG_STATIC_ESSID) &&
5643                     ((network->ssid_len != priv->essid_len) ||
5644                      memcmp(network->ssid, priv->essid,
5645                             min(network->ssid_len, priv->essid_len)))) {
5646                         IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of ESSID mismatch: '%*pE'.\n",
5647                                         network->ssid_len, network->ssid,
5648                                         network->bssid, priv->essid_len,
5649                                         priv->essid);
5650                         return 0;
5651                 }
5652         }
5653
5654         /* If the old network rate is better than this one, don't bother
5655          * testing everything else. */
5656         if (match->network && match->network->stats.rssi > network->stats.rssi) {
5657                 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because '%*pE (%pM)' has a stronger signal.\n",
5658                                 network->ssid_len, network->ssid,
5659                                 network->bssid, match->network->ssid_len,
5660                                 match->network->ssid, match->network->bssid);
5661                 return 0;
5662         }
5663
5664         /* If this network has already had an association attempt within the
5665          * last 3 seconds, do not try and associate again... */
5666         if (network->last_associate &&
5667             time_after(network->last_associate + (HZ * 3UL), jiffies)) {
5668                 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of storming (%ums since last assoc attempt).\n",
5669                                 network->ssid_len, network->ssid,
5670                                 network->bssid,
5671                                 jiffies_to_msecs(jiffies -
5672                                                  network->last_associate));
5673                 return 0;
5674         }
5675
5676         /* Now go through and see if the requested network is valid... */
5677         if (priv->ieee->scan_age != 0 &&
5678             time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5679                 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of age: %ums.\n",
5680                                 network->ssid_len, network->ssid,
5681                                 network->bssid,
5682                                 jiffies_to_msecs(jiffies -
5683                                                  network->last_scanned));
5684                 return 0;
5685         }
5686
5687         if ((priv->config & CFG_STATIC_CHANNEL) &&
5688             (network->channel != priv->channel)) {
5689                 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of channel mismatch: %d != %d.\n",
5690                                 network->ssid_len, network->ssid,
5691                                 network->bssid,
5692                                 network->channel, priv->channel);
5693                 return 0;
5694         }
5695
5696         /* Verify privacy compatibility */
5697         if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5698             ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5699                 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of privacy mismatch: %s != %s.\n",
5700                                 network->ssid_len, network->ssid,
5701                                 network->bssid,
5702                                 priv->capability & CAP_PRIVACY_ON ? "on" :
5703                                 "off",
5704                                 network->capability &
5705                                 WLAN_CAPABILITY_PRIVACY ? "on" : "off");
5706                 return 0;
5707         }
5708
5709         if ((priv->config & CFG_STATIC_BSSID) &&
5710             !ether_addr_equal(network->bssid, priv->bssid)) {
5711                 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of BSSID mismatch: %pM.\n",
5712                                 network->ssid_len, network->ssid,
5713                                 network->bssid, priv->bssid);
5714                 return 0;
5715         }
5716
5717         /* Filter out any incompatible freq / mode combinations */
5718         if (!libipw_is_valid_mode(priv->ieee, network->mode)) {
5719                 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of invalid frequency/mode combination.\n",
5720                                 network->ssid_len, network->ssid,
5721                                 network->bssid);
5722                 return 0;
5723         }
5724
5725         /* Filter out invalid channel in current GEO */
5726         if (!libipw_is_valid_channel(priv->ieee, network->channel)) {
5727                 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of invalid channel in current GEO\n",
5728                                 network->ssid_len, network->ssid,
5729                                 network->bssid);
5730                 return 0;
5731         }
5732
5733         /* Ensure that the rates supported by the driver are compatible with
5734          * this AP, including verification of basic rates (mandatory) */
5735         if (!ipw_compatible_rates(priv, network, &rates)) {
5736                 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because configured rate mask excludes AP mandatory rate.\n",
5737                                 network->ssid_len, network->ssid,
5738                                 network->bssid);
5739                 return 0;
5740         }
5741
5742         if (rates.num_rates == 0) {
5743                 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of no compatible rates.\n",
5744                                 network->ssid_len, network->ssid,
5745                                 network->bssid);
5746                 return 0;
5747         }
5748
5749         /* TODO: Perform any further minimal comparititive tests.  We do not
5750          * want to put too much policy logic here; intelligent scan selection
5751          * should occur within a generic IEEE 802.11 user space tool.  */
5752
5753         /* Set up 'new' AP to this network */
5754         ipw_copy_rates(&match->rates, &rates);
5755         match->network = network;
5756
5757         IPW_DEBUG_ASSOC("Network '%*pE (%pM)' is a viable match.\n",
5758                         network->ssid_len, network->ssid, network->bssid);
5759
5760         return 1;
5761 }
5762
5763 static void ipw_adhoc_create(struct ipw_priv *priv,
5764                              struct libipw_network *network)
5765 {
5766         const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
5767         int i;
5768
5769         /*
5770          * For the purposes of scanning, we can set our wireless mode
5771          * to trigger scans across combinations of bands, but when it
5772          * comes to creating a new ad-hoc network, we have tell the FW
5773          * exactly which band to use.
5774          *
5775          * We also have the possibility of an invalid channel for the
5776          * chossen band.  Attempting to create a new ad-hoc network
5777          * with an invalid channel for wireless mode will trigger a
5778          * FW fatal error.
5779          *
5780          */
5781         switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
5782         case LIBIPW_52GHZ_BAND:
5783                 network->mode = IEEE_A;
5784                 i = libipw_channel_to_index(priv->ieee, priv->channel);
5785                 BUG_ON(i == -1);
5786                 if (geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY) {
5787                         IPW_WARNING("Overriding invalid channel\n");
5788                         priv->channel = geo->a[0].channel;
5789                 }
5790                 break;
5791
5792         case LIBIPW_24GHZ_BAND:
5793                 if (priv->ieee->mode & IEEE_G)
5794                         network->mode = IEEE_G;
5795                 else
5796                         network->mode = IEEE_B;
5797                 i = libipw_channel_to_index(priv->ieee, priv->channel);
5798                 BUG_ON(i == -1);
5799                 if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY) {
5800                         IPW_WARNING("Overriding invalid channel\n");
5801                         priv->channel = geo->bg[0].channel;
5802                 }
5803                 break;
5804
5805         default:
5806                 IPW_WARNING("Overriding invalid channel\n");
5807                 if (priv->ieee->mode & IEEE_A) {
5808                         network->mode = IEEE_A;
5809                         priv->channel = geo->a[0].channel;
5810                 } else if (priv->ieee->mode & IEEE_G) {
5811                         network->mode = IEEE_G;
5812                         priv->channel = geo->bg[0].channel;
5813                 } else {
5814                         network->mode = IEEE_B;
5815                         priv->channel = geo->bg[0].channel;
5816                 }
5817                 break;
5818         }
5819
5820         network->channel = priv->channel;
5821         priv->config |= CFG_ADHOC_PERSIST;
5822         ipw_create_bssid(priv, network->bssid);
5823         network->ssid_len = priv->essid_len;
5824         memcpy(network->ssid, priv->essid, priv->essid_len);
5825         memset(&network->stats, 0, sizeof(network->stats));
5826         network->capability = WLAN_CAPABILITY_IBSS;
5827         if (!(priv->config & CFG_PREAMBLE_LONG))
5828                 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
5829         if (priv->capability & CAP_PRIVACY_ON)
5830                 network->capability |= WLAN_CAPABILITY_PRIVACY;
5831         network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
5832         memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
5833         network->rates_ex_len = priv->rates.num_rates - network->rates_len;
5834         memcpy(network->rates_ex,
5835                &priv->rates.supported_rates[network->rates_len],
5836                network->rates_ex_len);
5837         network->last_scanned = 0;
5838         network->flags = 0;
5839         network->last_associate = 0;
5840         network->time_stamp[0] = 0;
5841         network->time_stamp[1] = 0;
5842         network->beacon_interval = 100; /* Default */
5843         network->listen_interval = 10;  /* Default */
5844         network->atim_window = 0;       /* Default */
5845         network->wpa_ie_len = 0;
5846         network->rsn_ie_len = 0;
5847 }
5848
5849 static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
5850 {
5851         struct ipw_tgi_tx_key key;
5852
5853         if (!(priv->ieee->sec.flags & (1 << index)))
5854                 return;
5855
5856         key.key_id = index;
5857         memcpy(key.key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
5858         key.security_type = type;
5859         key.station_index = 0;  /* always 0 for BSS */
5860         key.flags = 0;
5861         /* 0 for new key; previous value of counter (after fatal error) */
5862         key.tx_counter[0] = cpu_to_le32(0);
5863         key.tx_counter[1] = cpu_to_le32(0);
5864
5865         ipw_send_cmd_pdu(priv, IPW_CMD_TGI_TX_KEY, sizeof(key), &key);
5866 }
5867
5868 static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
5869 {
5870         struct ipw_wep_key key;
5871         int i;
5872
5873         key.cmd_id = DINO_CMD_WEP_KEY;
5874         key.seq_num = 0;
5875
5876         /* Note: AES keys cannot be set for multiple times.
5877          * Only set it at the first time. */
5878         for (i = 0; i < 4; i++) {
5879                 key.key_index = i | type;
5880                 if (!(priv->ieee->sec.flags & (1 << i))) {
5881                         key.key_size = 0;
5882                         continue;
5883                 }
5884
5885                 key.key_size = priv->ieee->sec.key_sizes[i];
5886                 memcpy(key.key, priv->ieee->sec.keys[i], key.key_size);
5887
5888                 ipw_send_cmd_pdu(priv, IPW_CMD_WEP_KEY, sizeof(key), &key);
5889         }
5890 }
5891
5892 static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
5893 {
5894         if (priv->ieee->host_encrypt)
5895                 return;
5896
5897         switch (level) {
5898         case SEC_LEVEL_3:
5899                 priv->sys_config.disable_unicast_decryption = 0;
5900                 priv->ieee->host_decrypt = 0;
5901                 break;
5902         case SEC_LEVEL_2:
5903                 priv->sys_config.disable_unicast_decryption = 1;
5904                 priv->ieee->host_decrypt = 1;
5905                 break;
5906         case SEC_LEVEL_1:
5907                 priv->sys_config.disable_unicast_decryption = 0;
5908                 priv->ieee->host_decrypt = 0;
5909                 break;
5910         case SEC_LEVEL_0:
5911                 priv->sys_config.disable_unicast_decryption = 1;
5912                 break;
5913         default:
5914                 break;
5915         }
5916 }
5917
5918 static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
5919 {
5920         if (priv->ieee->host_encrypt)
5921                 return;
5922
5923         switch (level) {
5924         case SEC_LEVEL_3:
5925                 priv->sys_config.disable_multicast_decryption = 0;
5926                 break;
5927         case SEC_LEVEL_2:
5928                 priv->sys_config.disable_multicast_decryption = 1;
5929                 break;
5930         case SEC_LEVEL_1:
5931                 priv->sys_config.disable_multicast_decryption = 0;
5932                 break;
5933         case SEC_LEVEL_0:
5934                 priv->sys_config.disable_multicast_decryption = 1;
5935                 break;
5936         default:
5937                 break;
5938         }
5939 }
5940
5941 static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
5942 {
5943         switch (priv->ieee->sec.level) {
5944         case SEC_LEVEL_3:
5945                 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5946                         ipw_send_tgi_tx_key(priv,
5947                                             DCT_FLAG_EXT_SECURITY_CCM,
5948                                             priv->ieee->sec.active_key);
5949
5950                 if (!priv->ieee->host_mc_decrypt)
5951                         ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
5952                 break;
5953         case SEC_LEVEL_2:
5954                 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5955                         ipw_send_tgi_tx_key(priv,
5956                                             DCT_FLAG_EXT_SECURITY_TKIP,
5957                                             priv->ieee->sec.active_key);
5958                 break;
5959         case SEC_LEVEL_1:
5960                 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
5961                 ipw_set_hw_decrypt_unicast(priv, priv->ieee->sec.level);
5962                 ipw_set_hw_decrypt_multicast(priv, priv->ieee->sec.level);
5963                 break;
5964         case SEC_LEVEL_0:
5965         default:
5966                 break;
5967         }
5968 }
5969
5970 static void ipw_adhoc_check(void *data)
5971 {
5972         struct ipw_priv *priv = data;
5973
5974         if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
5975             !(priv->config & CFG_ADHOC_PERSIST)) {
5976                 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
5977                           IPW_DL_STATE | IPW_DL_ASSOC,
5978                           "Missed beacon: %d - disassociate\n",
5979                           priv->missed_adhoc_beacons);
5980                 ipw_remove_current_network(priv);
5981                 ipw_disassociate(priv);
5982                 return;
5983         }
5984
5985         schedule_delayed_work(&priv->adhoc_check,
5986                               le16_to_cpu(priv->assoc_request.beacon_interval));
5987 }
5988
5989 static void ipw_bg_adhoc_check(struct work_struct *work)
5990 {
5991         struct ipw_priv *priv =
5992                 container_of(work, struct ipw_priv, adhoc_check.work);
5993         mutex_lock(&priv->mutex);
5994         ipw_adhoc_check(priv);
5995         mutex_unlock(&priv->mutex);
5996 }
5997
5998 static void ipw_debug_config(struct ipw_priv *priv)
5999 {
6000         IPW_DEBUG_INFO("Scan completed, no valid APs matched "
6001                        "[CFG 0x%08X]\n", priv->config);
6002         if (priv->config & CFG_STATIC_CHANNEL)
6003                 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
6004         else
6005                 IPW_DEBUG_INFO("Channel unlocked.\n");
6006         if (priv->config & CFG_STATIC_ESSID)
6007                 IPW_DEBUG_INFO("ESSID locked to '%*pE'\n",
6008                                priv->essid_len, priv->essid);
6009         else
6010                 IPW_DEBUG_INFO("ESSID unlocked.\n");
6011         if (priv->config & CFG_STATIC_BSSID)
6012                 IPW_DEBUG_INFO("BSSID locked to %pM\n", priv->bssid);
6013         else
6014                 IPW_DEBUG_INFO("BSSID unlocked.\n");
6015         if (priv->capability & CAP_PRIVACY_ON)
6016                 IPW_DEBUG_INFO("PRIVACY on\n");
6017         else
6018                 IPW_DEBUG_INFO("PRIVACY off\n");
6019         IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
6020 }
6021
6022 static void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
6023 {
6024         /* TODO: Verify that this works... */
6025         struct ipw_fixed_rate fr;
6026         u32 reg;
6027         u16 mask = 0;
6028         u16 new_tx_rates = priv->rates_mask;
6029
6030         /* Identify 'current FW band' and match it with the fixed
6031          * Tx rates */
6032
6033         switch (priv->ieee->freq_band) {
6034         case LIBIPW_52GHZ_BAND: /* A only */
6035                 /* IEEE_A */
6036                 if (priv->rates_mask & ~LIBIPW_OFDM_RATES_MASK) {
6037                         /* Invalid fixed rate mask */
6038                         IPW_DEBUG_WX
6039                             ("invalid fixed rate mask in ipw_set_fixed_rate\n");
6040                         new_tx_rates = 0;
6041                         break;
6042                 }
6043
6044                 new_tx_rates >>= LIBIPW_OFDM_SHIFT_MASK_A;
6045                 break;
6046
6047         default:                /* 2.4Ghz or Mixed */
6048                 /* IEEE_B */
6049                 if (mode == IEEE_B) {
6050                         if (new_tx_rates & ~LIBIPW_CCK_RATES_MASK) {
6051                                 /* Invalid fixed rate mask */
6052                                 IPW_DEBUG_WX
6053                                     ("invalid fixed rate mask in ipw_set_fixed_rate\n");
6054                                 new_tx_rates = 0;
6055                         }
6056                         break;
6057                 }
6058
6059                 /* IEEE_G */
6060                 if (new_tx_rates & ~(LIBIPW_CCK_RATES_MASK |
6061                                     LIBIPW_OFDM_RATES_MASK)) {
6062                         /* Invalid fixed rate mask */
6063                         IPW_DEBUG_WX
6064                             ("invalid fixed rate mask in ipw_set_fixed_rate\n");
6065                         new_tx_rates = 0;
6066                         break;
6067                 }
6068
6069                 if (LIBIPW_OFDM_RATE_6MB_MASK & new_tx_rates) {
6070                         mask |= (LIBIPW_OFDM_RATE_6MB_MASK >> 1);
6071                         new_tx_rates &= ~LIBIPW_OFDM_RATE_6MB_MASK;
6072                 }
6073
6074                 if (LIBIPW_OFDM_RATE_9MB_MASK & new_tx_rates) {
6075                         mask |= (LIBIPW_OFDM_RATE_9MB_MASK >> 1);
6076                         new_tx_rates &= ~LIBIPW_OFDM_RATE_9MB_MASK;
6077                 }
6078
6079                 if (LIBIPW_OFDM_RATE_12MB_MASK & new_tx_rates) {
6080                         mask |= (LIBIPW_OFDM_RATE_12MB_MASK >> 1);
6081                         new_tx_rates &= ~LIBIPW_OFDM_RATE_12MB_MASK;
6082                 }
6083
6084                 new_tx_rates |= mask;
6085                 break;
6086         }
6087
6088         fr.tx_rates = cpu_to_le16(new_tx_rates);
6089
6090         reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
6091         ipw_write_reg32(priv, reg, *(u32 *) & fr);
6092 }
6093
6094 static void ipw_abort_scan(struct ipw_priv *priv)
6095 {
6096         int err;
6097
6098         if (priv->status & STATUS_SCAN_ABORTING) {
6099                 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
6100                 return;
6101         }
6102         priv->status |= STATUS_SCAN_ABORTING;
6103
6104         err = ipw_send_scan_abort(priv);
6105         if (err)
6106                 IPW_DEBUG_HC("Request to abort scan failed.\n");
6107 }
6108
6109 static void ipw_add_scan_channels(struct ipw_priv *priv,
6110                                   struct ipw_scan_request_ext *scan,
6111                                   int scan_type)
6112 {
6113         int channel_index = 0;
6114         const struct libipw_geo *geo;
6115         int i;
6116
6117         geo = libipw_get_geo(priv->ieee);
6118
6119         if (priv->ieee->freq_band & LIBIPW_52GHZ_BAND) {
6120                 int start = channel_index;
6121                 for (i = 0; i < geo->a_channels; i++) {
6122                         if ((priv->status & STATUS_ASSOCIATED) &&
6123                             geo->a[i].channel == priv->channel)
6124                                 continue;
6125                         channel_index++;
6126                         scan->channels_list[channel_index] = geo->a[i].channel;
6127                         ipw_set_scan_type(scan, channel_index,
6128                                           geo->a[i].
6129                                           flags & LIBIPW_CH_PASSIVE_ONLY ?
6130                                           IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
6131                                           scan_type);
6132                 }
6133
6134                 if (start != channel_index) {
6135                         scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
6136                             (channel_index - start);
6137                         channel_index++;
6138                 }
6139         }
6140
6141         if (priv->ieee->freq_band & LIBIPW_24GHZ_BAND) {
6142                 int start = channel_index;
6143                 if (priv->config & CFG_SPEED_SCAN) {
6144                         int index;
6145                         u8 channels[LIBIPW_24GHZ_CHANNELS] = {
6146                                 /* nop out the list */
6147                                 [0] = 0
6148                         };
6149
6150                         u8 channel;
6151                         while (channel_index < IPW_SCAN_CHANNELS - 1) {
6152                                 channel =
6153                                     priv->speed_scan[priv->speed_scan_pos];
6154                                 if (channel == 0) {
6155                                         priv->speed_scan_pos = 0;
6156                                         channel = priv->speed_scan[0];
6157                                 }
6158                                 if ((priv->status & STATUS_ASSOCIATED) &&
6159                                     channel == priv->channel) {
6160                                         priv->speed_scan_pos++;
6161                                         continue;
6162                                 }
6163
6164                                 /* If this channel has already been
6165                                  * added in scan, break from loop
6166                                  * and this will be the first channel
6167                                  * in the next scan.
6168                                  */
6169                                 if (channels[channel - 1] != 0)
6170                                         break;
6171
6172                                 channels[channel - 1] = 1;
6173                                 priv->speed_scan_pos++;
6174                                 channel_index++;
6175                                 scan->channels_list[channel_index] = channel;
6176                                 index =
6177                                     libipw_channel_to_index(priv->ieee, channel);
6178                                 ipw_set_scan_type(scan, channel_index,
6179                                                   geo->bg[index].
6180                                                   flags &
6181                                                   LIBIPW_CH_PASSIVE_ONLY ?
6182                                                   IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6183                                                   : scan_type);
6184                         }
6185                 } else {
6186                         for (i = 0; i < geo->bg_channels; i++) {
6187                                 if ((priv->status & STATUS_ASSOCIATED) &&
6188                                     geo->bg[i].channel == priv->channel)
6189                                         continue;
6190                                 channel_index++;
6191                                 scan->channels_list[channel_index] =
6192                                     geo->bg[i].channel;
6193                                 ipw_set_scan_type(scan, channel_index,
6194                                                   geo->bg[i].
6195                                                   flags &
6196                                                   LIBIPW_CH_PASSIVE_ONLY ?
6197                                                   IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6198                                                   : scan_type);
6199                         }
6200                 }
6201
6202                 if (start != channel_index) {
6203                         scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6204                             (channel_index - start);
6205                 }
6206         }
6207 }
6208
6209 static int ipw_passive_dwell_time(struct ipw_priv *priv)
6210 {
6211         /* staying on passive channels longer than the DTIM interval during a
6212          * scan, while associated, causes the firmware to cancel the scan
6213          * without notification. Hence, don't stay on passive channels longer
6214          * than the beacon interval.
6215          */
6216         if (priv->status & STATUS_ASSOCIATED
6217             && priv->assoc_network->beacon_interval > 10)
6218                 return priv->assoc_network->beacon_interval - 10;
6219         else
6220                 return 120;
6221 }
6222
6223 static int ipw_request_scan_helper(struct ipw_priv *priv, int type, int direct)
6224 {
6225         struct ipw_scan_request_ext scan;
6226         int err = 0, scan_type;
6227
6228         if (!(priv->status & STATUS_INIT) ||
6229             (priv->status & STATUS_EXIT_PENDING))
6230                 return 0;
6231
6232         mutex_lock(&priv->mutex);
6233
6234         if (direct && (priv->direct_scan_ssid_len == 0)) {
6235                 IPW_DEBUG_HC("Direct scan requested but no SSID to scan for\n");
6236                 priv->status &= ~STATUS_DIRECT_SCAN_PENDING;
6237                 goto done;
6238         }
6239
6240         if (priv->status & STATUS_SCANNING) {
6241                 IPW_DEBUG_HC("Concurrent scan requested.  Queuing.\n");
6242                 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6243                                         STATUS_SCAN_PENDING;
6244                 goto done;
6245         }
6246
6247         if (!(priv->status & STATUS_SCAN_FORCED) &&
6248             priv->status & STATUS_SCAN_ABORTING) {
6249                 IPW_DEBUG_HC("Scan request while abort pending.  Queuing.\n");
6250                 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6251                                         STATUS_SCAN_PENDING;
6252                 goto done;
6253         }
6254
6255         if (priv->status & STATUS_RF_KILL_MASK) {
6256                 IPW_DEBUG_HC("Queuing scan due to RF Kill activation\n");
6257                 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6258                                         STATUS_SCAN_PENDING;
6259                 goto done;
6260         }
6261
6262         memset(&scan, 0, sizeof(scan));
6263         scan.full_scan_index = cpu_to_le32(libipw_get_scans(priv->ieee));
6264
6265         if (type == IW_SCAN_TYPE_PASSIVE) {
6266                 IPW_DEBUG_WX("use passive scanning\n");
6267                 scan_type = IPW_SCAN_PASSIVE_FULL_DWELL_SCAN;
6268                 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6269                         cpu_to_le16(ipw_passive_dwell_time(priv));
6270                 ipw_add_scan_channels(priv, &scan, scan_type);
6271                 goto send_request;
6272         }
6273
6274         /* Use active scan by default. */
6275         if (priv->config & CFG_SPEED_SCAN)
6276                 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6277                         cpu_to_le16(30);
6278         else
6279                 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6280                         cpu_to_le16(20);
6281
6282         scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
6283                 cpu_to_le16(20);
6284
6285         scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6286                 cpu_to_le16(ipw_passive_dwell_time(priv));
6287         scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
6288
6289 #ifdef CONFIG_IPW2200_MONITOR
6290         if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
6291                 u8 channel;
6292                 u8 band = 0;
6293
6294                 switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
6295                 case LIBIPW_52GHZ_BAND:
6296                         band = (u8) (IPW_A_MODE << 6) | 1;
6297                         channel = priv->channel;
6298                         break;
6299
6300                 case LIBIPW_24GHZ_BAND:
6301                         band = (u8) (IPW_B_MODE << 6) | 1;
6302                         channel = priv->channel;
6303                         break;
6304
6305                 default:
6306                         band = (u8) (IPW_B_MODE << 6) | 1;
6307                         channel = 9;
6308                         break;
6309                 }
6310
6311                 scan.channels_list[0] = band;
6312                 scan.channels_list[1] = channel;
6313                 ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
6314
6315                 /* NOTE:  The card will sit on this channel for this time
6316                  * period.  Scan aborts are timing sensitive and frequently
6317                  * result in firmware restarts.  As such, it is best to
6318                  * set a small dwell_time here and just keep re-issuing
6319                  * scans.  Otherwise fast channel hopping will not actually
6320                  * hop channels.
6321                  *
6322                  * TODO: Move SPEED SCAN support to all modes and bands */
6323                 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6324                         cpu_to_le16(2000);
6325         } else {
6326 #endif                          /* CONFIG_IPW2200_MONITOR */
6327                 /* Honor direct scans first, otherwise if we are roaming make
6328                  * this a direct scan for the current network.  Finally,
6329                  * ensure that every other scan is a fast channel hop scan */
6330                 if (direct) {
6331                         err = ipw_send_ssid(priv, priv->direct_scan_ssid,
6332                                             priv->direct_scan_ssid_len);
6333                         if (err) {
6334                                 IPW_DEBUG_HC("Attempt to send SSID command  "
6335                                              "failed\n");
6336                                 goto done;
6337                         }
6338
6339                         scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6340                 } else if ((priv->status & STATUS_ROAMING)
6341                            || (!(priv->status & STATUS_ASSOCIATED)
6342                                && (priv->config & CFG_STATIC_ESSID)
6343                                && (le32_to_cpu(scan.full_scan_index) % 2))) {
6344                         err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6345                         if (err) {
6346                                 IPW_DEBUG_HC("Attempt to send SSID command "
6347                                              "failed.\n");
6348                                 goto done;
6349                         }
6350
6351                         scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6352                 } else
6353                         scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
6354
6355                 ipw_add_scan_channels(priv, &scan, scan_type);
6356 #ifdef CONFIG_IPW2200_MONITOR
6357         }
6358 #endif
6359
6360 send_request:
6361         err = ipw_send_scan_request_ext(priv, &scan);
6362         if (err) {
6363                 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
6364                 goto done;
6365         }
6366
6367         priv->status |= STATUS_SCANNING;
6368         if (direct) {
6369                 priv->status &= ~STATUS_DIRECT_SCAN_PENDING;
6370                 priv->direct_scan_ssid_len = 0;
6371         } else
6372                 priv->status &= ~STATUS_SCAN_PENDING;
6373
6374         schedule_delayed_work(&priv->scan_check, IPW_SCAN_CHECK_WATCHDOG);
6375 done:
6376         mutex_unlock(&priv->mutex);
6377         return err;
6378 }
6379
6380 static void ipw_request_passive_scan(struct work_struct *work)
6381 {
6382         struct ipw_priv *priv =
6383                 container_of(work, struct ipw_priv, request_passive_scan.work);
6384         ipw_request_scan_helper(priv, IW_SCAN_TYPE_PASSIVE, 0);
6385 }
6386
6387 static void ipw_request_scan(struct work_struct *work)
6388 {
6389         struct ipw_priv *priv =
6390                 container_of(work, struct ipw_priv, request_scan.work);
6391         ipw_request_scan_helper(priv, IW_SCAN_TYPE_ACTIVE, 0);
6392 }
6393
6394 static void ipw_request_direct_scan(struct work_struct *work)
6395 {
6396         struct ipw_priv *priv =
6397                 container_of(work, struct ipw_priv, request_direct_scan.work);
6398         ipw_request_scan_helper(priv, IW_SCAN_TYPE_ACTIVE, 1);
6399 }
6400
6401 static void ipw_bg_abort_scan(struct work_struct *work)
6402 {
6403         struct ipw_priv *priv =
6404                 container_of(work, struct ipw_priv, abort_scan);
6405         mutex_lock(&priv->mutex);
6406         ipw_abort_scan(priv);
6407         mutex_unlock(&priv->mutex);
6408 }
6409
6410 static int ipw_wpa_enable(struct ipw_priv *priv, int value)
6411 {
6412         /* This is called when wpa_supplicant loads and closes the driver
6413          * interface. */
6414         priv->ieee->wpa_enabled = value;
6415         return 0;
6416 }
6417
6418 static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
6419 {
6420         struct libipw_device *ieee = priv->ieee;
6421         struct libipw_security sec = {
6422                 .flags = SEC_AUTH_MODE,
6423         };
6424         int ret = 0;
6425
6426         if (value & IW_AUTH_ALG_SHARED_KEY) {
6427                 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
6428                 ieee->open_wep = 0;
6429         } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
6430                 sec.auth_mode = WLAN_AUTH_OPEN;
6431                 ieee->open_wep = 1;
6432         } else if (value & IW_AUTH_ALG_LEAP) {
6433                 sec.auth_mode = WLAN_AUTH_LEAP;
6434                 ieee->open_wep = 1;
6435         } else
6436                 return -EINVAL;
6437
6438         if (ieee->set_security)
6439                 ieee->set_security(ieee->dev, &sec);
6440         else
6441                 ret = -EOPNOTSUPP;
6442
6443         return ret;
6444 }
6445
6446 static void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie,
6447                                 int wpa_ie_len)
6448 {
6449         /* make sure WPA is enabled */
6450         ipw_wpa_enable(priv, 1);
6451 }
6452
6453 static int ipw_set_rsn_capa(struct ipw_priv *priv,
6454                             char *capabilities, int length)
6455 {
6456         IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
6457
6458         return ipw_send_cmd_pdu(priv, IPW_CMD_RSN_CAPABILITIES, length,
6459                                 capabilities);
6460 }
6461
6462 /*
6463  * WE-18 support
6464  */
6465
6466 static int ipw_wx_get_name(struct net_device *dev,
6467                            struct iw_request_info *info,
6468                            union iwreq_data *wrqu, char *extra)
6469 {
6470         strcpy(wrqu->name, "IEEE 802.11");
6471         return 0;
6472 }
6473
6474 /* SIOCSIWGENIE */
6475 static int ipw_wx_set_genie(struct net_device *dev,
6476                             struct iw_request_info *info,
6477                             union iwreq_data *wrqu, char *extra)
6478 {
6479         struct ipw_priv *priv = libipw_priv(dev);
6480         struct libipw_device *ieee = priv->ieee;
6481         u8 *buf;
6482         int err = 0;
6483
6484         if (wrqu->data.length > MAX_WPA_IE_LEN ||
6485             (wrqu->data.length && extra == NULL))
6486                 return -EINVAL;
6487
6488         if (wrqu->data.length) {
6489                 buf = kmemdup(extra, wrqu->data.length, GFP_KERNEL);
6490                 if (buf == NULL) {
6491                         err = -ENOMEM;
6492                         goto out;
6493                 }
6494
6495                 kfree(ieee->wpa_ie);
6496                 ieee->wpa_ie = buf;
6497                 ieee->wpa_ie_len = wrqu->data.length;
6498         } else {
6499                 kfree(ieee->wpa_ie);
6500                 ieee->wpa_ie = NULL;
6501                 ieee->wpa_ie_len = 0;
6502         }
6503
6504         ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6505       out:
6506         return err;
6507 }
6508
6509 /* SIOCGIWGENIE */
6510 static int ipw_wx_get_genie(struct net_device *dev,
6511                             struct iw_request_info *info,
6512                             union iwreq_data *wrqu, char *extra)
6513 {
6514         struct ipw_priv *priv = libipw_priv(dev);
6515         struct libipw_device *ieee = priv->ieee;
6516         int err = 0;
6517
6518         if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6519                 wrqu->data.length = 0;
6520                 goto out;
6521         }
6522
6523         if (wrqu->data.length < ieee->wpa_ie_len) {
6524                 err = -E2BIG;
6525                 goto out;
6526         }
6527
6528         wrqu->data.length = ieee->wpa_ie_len;
6529         memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6530
6531       out:
6532         return err;
6533 }
6534
6535 static int wext_cipher2level(int cipher)
6536 {
6537         switch (cipher) {
6538         case IW_AUTH_CIPHER_NONE:
6539                 return SEC_LEVEL_0;
6540         case IW_AUTH_CIPHER_WEP40:
6541         case IW_AUTH_CIPHER_WEP104:
6542                 return SEC_LEVEL_1;
6543         case IW_AUTH_CIPHER_TKIP:
6544                 return SEC_LEVEL_2;
6545         case IW_AUTH_CIPHER_CCMP:
6546                 return SEC_LEVEL_3;
6547         default:
6548                 return -1;
6549         }
6550 }
6551
6552 /* SIOCSIWAUTH */
6553 static int ipw_wx_set_auth(struct net_device *dev,
6554                            struct iw_request_info *info,
6555                            union iwreq_data *wrqu, char *extra)
6556 {
6557         struct ipw_priv *priv = libipw_priv(dev);
6558         struct libipw_device *ieee = priv->ieee;
6559         struct iw_param *param = &wrqu->param;
6560         struct libipw_crypt_data *crypt;
6561         unsigned long flags;
6562         int ret = 0;
6563
6564         switch (param->flags & IW_AUTH_INDEX) {
6565         case IW_AUTH_WPA_VERSION:
6566                 break;
6567         case IW_AUTH_CIPHER_PAIRWISE:
6568                 ipw_set_hw_decrypt_unicast(priv,
6569                                            wext_cipher2level(param->value));
6570                 break;
6571         case IW_AUTH_CIPHER_GROUP:
6572                 ipw_set_hw_decrypt_multicast(priv,
6573                                              wext_cipher2level(param->value));
6574                 break;
6575         case IW_AUTH_KEY_MGMT:
6576                 /*
6577                  * ipw2200 does not use these parameters
6578                  */
6579                 break;
6580
6581         case IW_AUTH_TKIP_COUNTERMEASURES:
6582                 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
6583                 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
6584                         break;
6585
6586                 flags = crypt->ops->get_flags(crypt->priv);
6587
6588                 if (param->value)
6589                         flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6590                 else
6591                         flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6592
6593                 crypt->ops->set_flags(flags, crypt->priv);
6594
6595                 break;
6596
6597         case IW_AUTH_DROP_UNENCRYPTED:{
6598                         /* HACK:
6599                          *
6600                          * wpa_supplicant calls set_wpa_enabled when the driver
6601                          * is loaded and unloaded, regardless of if WPA is being
6602                          * used.  No other calls are made which can be used to
6603                          * determine if encryption will be used or not prior to
6604                          * association being expected.  If encryption is not being
6605                          * used, drop_unencrypted is set to false, else true -- we
6606                          * can use this to determine if the CAP_PRIVACY_ON bit should
6607                          * be set.
6608                          */
6609                         struct libipw_security sec = {
6610                                 .flags = SEC_ENABLED,
6611                                 .enabled = param->value,
6612                         };
6613                         priv->ieee->drop_unencrypted = param->value;
6614                         /* We only change SEC_LEVEL for open mode. Others
6615                          * are set by ipw_wpa_set_encryption.
6616                          */
6617                         if (!param->value) {
6618                                 sec.flags |= SEC_LEVEL;
6619                                 sec.level = SEC_LEVEL_0;
6620                         } else {
6621                                 sec.flags |= SEC_LEVEL;
6622                                 sec.level = SEC_LEVEL_1;
6623                         }
6624                         if (priv->ieee->set_security)
6625                                 priv->ieee->set_security(priv->ieee->dev, &sec);
6626                         break;
6627                 }
6628
6629         case IW_AUTH_80211_AUTH_ALG:
6630                 ret = ipw_wpa_set_auth_algs(priv, param->value);
6631                 break;
6632
6633         case IW_AUTH_WPA_ENABLED:
6634                 ret = ipw_wpa_enable(priv, param->value);
6635                 ipw_disassociate(priv);
6636                 break;
6637
6638         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6639                 ieee->ieee802_1x = param->value;
6640                 break;
6641
6642         case IW_AUTH_PRIVACY_INVOKED:
6643                 ieee->privacy_invoked = param->value;
6644                 break;
6645
6646         default:
6647                 return -EOPNOTSUPP;
6648         }
6649         return ret;
6650 }
6651
6652 /* SIOCGIWAUTH */
6653 static int ipw_wx_get_auth(struct net_device *dev,
6654                            struct iw_request_info *info,
6655                            union iwreq_data *wrqu, char *extra)
6656 {
6657         struct ipw_priv *priv = libipw_priv(dev);
6658         struct libipw_device *ieee = priv->ieee;
6659         struct libipw_crypt_data *crypt;
6660         struct iw_param *param = &wrqu->param;
6661
6662         switch (param->flags & IW_AUTH_INDEX) {
6663         case IW_AUTH_WPA_VERSION:
6664         case IW_AUTH_CIPHER_PAIRWISE:
6665         case IW_AUTH_CIPHER_GROUP:
6666         case IW_AUTH_KEY_MGMT:
6667                 /*
6668                  * wpa_supplicant will control these internally
6669                  */
6670                 return -EOPNOTSUPP;
6671
6672         case IW_AUTH_TKIP_COUNTERMEASURES:
6673                 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
6674                 if (!crypt || !crypt->ops->get_flags)
6675                         break;
6676
6677                 param->value = (crypt->ops->get_flags(crypt->priv) &
6678                                 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6679
6680                 break;
6681
6682         case IW_AUTH_DROP_UNENCRYPTED:
6683                 param->value = ieee->drop_unencrypted;
6684                 break;
6685
6686         case IW_AUTH_80211_AUTH_ALG:
6687                 param->value = ieee->sec.auth_mode;
6688                 break;
6689
6690         case IW_AUTH_WPA_ENABLED:
6691                 param->value = ieee->wpa_enabled;
6692                 break;
6693
6694         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6695                 param->value = ieee->ieee802_1x;
6696                 break;
6697
6698         case IW_AUTH_ROAMING_CONTROL:
6699         case IW_AUTH_PRIVACY_INVOKED:
6700                 param->value = ieee->privacy_invoked;
6701                 break;
6702
6703         default:
6704                 return -EOPNOTSUPP;
6705         }
6706         return 0;
6707 }
6708
6709 /* SIOCSIWENCODEEXT */
6710 static int ipw_wx_set_encodeext(struct net_device *dev,
6711                                 struct iw_request_info *info,
6712                                 union iwreq_data *wrqu, char *extra)
6713 {
6714         struct ipw_priv *priv = libipw_priv(dev);
6715         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6716
6717         if (hwcrypto) {
6718                 if (ext->alg == IW_ENCODE_ALG_TKIP) {
6719                         /* IPW HW can't build TKIP MIC,
6720                            host decryption still needed */
6721                         if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6722                                 priv->ieee->host_mc_decrypt = 1;
6723                         else {
6724                                 priv->ieee->host_encrypt = 0;
6725                                 priv->ieee->host_encrypt_msdu = 1;
6726                                 priv->ieee->host_decrypt = 1;
6727                         }
6728                 } else {
6729                         priv->ieee->host_encrypt = 0;
6730                         priv->ieee->host_encrypt_msdu = 0;
6731                         priv->ieee->host_decrypt = 0;
6732                         priv->ieee->host_mc_decrypt = 0;
6733                 }
6734         }
6735
6736         return libipw_wx_set_encodeext(priv->ieee, info, wrqu, extra);
6737 }
6738
6739 /* SIOCGIWENCODEEXT */
6740 static int ipw_wx_get_encodeext(struct net_device *dev,
6741                                 struct iw_request_info *info,
6742                                 union iwreq_data *wrqu, char *extra)
6743 {
6744         struct ipw_priv *priv = libipw_priv(dev);
6745         return libipw_wx_get_encodeext(priv->ieee, info, wrqu, extra);
6746 }
6747
6748 /* SIOCSIWMLME */
6749 static int ipw_wx_set_mlme(struct net_device *dev,
6750                            struct iw_request_info *info,
6751                            union iwreq_data *wrqu, char *extra)
6752 {
6753         struct ipw_priv *priv = libipw_priv(dev);
6754         struct iw_mlme *mlme = (struct iw_mlme *)extra;
6755
6756         switch (mlme->cmd) {
6757         case IW_MLME_DEAUTH:
6758                 /* silently ignore */
6759                 break;
6760
6761         case IW_MLME_DISASSOC:
6762                 ipw_disassociate(priv);
6763                 break;
6764
6765         default:
6766                 return -EOPNOTSUPP;
6767         }
6768         return 0;
6769 }
6770
6771 #ifdef CONFIG_IPW2200_QOS
6772
6773 /* QoS */
6774 /*
6775 * get the modulation type of the current network or
6776 * the card current mode
6777 */
6778 static u8 ipw_qos_current_mode(struct ipw_priv * priv)
6779 {
6780         u8 mode = 0;
6781
6782         if (priv->status & STATUS_ASSOCIATED) {
6783                 unsigned long flags;
6784
6785                 spin_lock_irqsave(&priv->ieee->lock, flags);
6786                 mode = priv->assoc_network->mode;
6787                 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6788         } else {
6789                 mode = priv->ieee->mode;
6790         }
6791         IPW_DEBUG_QOS("QoS network/card mode %d\n", mode);
6792         return mode;
6793 }
6794
6795 /*
6796 * Handle management frame beacon and probe response
6797 */
6798 static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
6799                                          int active_network,
6800                                          struct libipw_network *network)
6801 {
6802         u32 size = sizeof(struct libipw_qos_parameters);
6803
6804         if (network->capability & WLAN_CAPABILITY_IBSS)
6805                 network->qos_data.active = network->qos_data.supported;
6806
6807         if (network->flags & NETWORK_HAS_QOS_MASK) {
6808                 if (active_network &&
6809                     (network->flags & NETWORK_HAS_QOS_PARAMETERS))
6810                         network->qos_data.active = network->qos_data.supported;
6811
6812                 if ((network->qos_data.active == 1) && (active_network == 1) &&
6813                     (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
6814                     (network->qos_data.old_param_count !=
6815                      network->qos_data.param_count)) {
6816                         network->qos_data.old_param_count =
6817                             network->qos_data.param_count;
6818                         schedule_work(&priv->qos_activate);
6819                         IPW_DEBUG_QOS("QoS parameters change call "
6820                                       "qos_activate\n");
6821                 }
6822         } else {
6823                 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
6824                         memcpy(&network->qos_data.parameters,
6825                                &def_parameters_CCK, size);
6826                 else
6827                         memcpy(&network->qos_data.parameters,
6828                                &def_parameters_OFDM, size);
6829
6830                 if ((network->qos_data.active == 1) && (active_network == 1)) {
6831                         IPW_DEBUG_QOS("QoS was disabled call qos_activate\n");
6832                         schedule_work(&priv->qos_activate);
6833                 }
6834
6835                 network->qos_data.active = 0;
6836                 network->qos_data.supported = 0;
6837         }
6838         if ((priv->status & STATUS_ASSOCIATED) &&
6839             (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
6840                 if (!ether_addr_equal(network->bssid, priv->bssid))
6841                         if (network->capability & WLAN_CAPABILITY_IBSS)
6842                                 if ((network->ssid_len ==
6843                                      priv->assoc_network->ssid_len) &&
6844                                     !memcmp(network->ssid,
6845                                             priv->assoc_network->ssid,
6846                                             network->ssid_len)) {
6847                                         schedule_work(&priv->merge_networks);
6848                                 }
6849         }
6850
6851         return 0;
6852 }
6853
6854 /*
6855 * This function set up the firmware to support QoS. It sends
6856 * IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
6857 */
6858 static int ipw_qos_activate(struct ipw_priv *priv,
6859                             struct libipw_qos_data *qos_network_data)
6860 {
6861         int err;
6862         struct libipw_qos_parameters qos_parameters[QOS_QOS_SETS];
6863         struct libipw_qos_parameters *active_one = NULL;
6864         u32 size = sizeof(struct libipw_qos_parameters);
6865         u32 burst_duration;
6866         int i;
6867         u8 type;
6868
6869         type = ipw_qos_current_mode(priv);
6870
6871         active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
6872         memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
6873         active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
6874         memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
6875
6876         if (qos_network_data == NULL) {
6877                 if (type == IEEE_B) {
6878                         IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
6879                         active_one = &def_parameters_CCK;
6880                 } else
6881                         active_one = &def_parameters_OFDM;
6882
6883                 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6884                 burst_duration = ipw_qos_get_burst_duration(priv);
6885                 for (i = 0; i < QOS_QUEUE_NUM; i++)
6886                         qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
6887                             cpu_to_le16(burst_duration);
6888         } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6889                 if (type == IEEE_B) {
6890                         IPW_DEBUG_QOS("QoS activate IBSS network mode %d\n",
6891                                       type);
6892                         if (priv->qos_data.qos_enable == 0)
6893                                 active_one = &def_parameters_CCK;
6894                         else
6895                                 active_one = priv->qos_data.def_qos_parm_CCK;
6896                 } else {
6897                         if (priv->qos_data.qos_enable == 0)
6898                                 active_one = &def_parameters_OFDM;
6899                         else
6900                                 active_one = priv->qos_data.def_qos_parm_OFDM;
6901                 }
6902                 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6903         } else {
6904                 unsigned long flags;
6905                 int active;
6906
6907                 spin_lock_irqsave(&priv->ieee->lock, flags);
6908                 active_one = &(qos_network_data->parameters);
6909                 qos_network_data->old_param_count =
6910                     qos_network_data->param_count;
6911                 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6912                 active = qos_network_data->supported;
6913                 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6914
6915                 if (active == 0) {
6916                         burst_duration = ipw_qos_get_burst_duration(priv);
6917                         for (i = 0; i < QOS_QUEUE_NUM; i++)
6918                                 qos_parameters[QOS_PARAM_SET_ACTIVE].
6919                                     tx_op_limit[i] = cpu_to_le16(burst_duration);
6920                 }
6921         }
6922
6923         IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
6924         err = ipw_send_qos_params_command(priv, &qos_parameters[0]);
6925         if (err)
6926                 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
6927
6928         return err;
6929 }
6930
6931 /*
6932 * send IPW_CMD_WME_INFO to the firmware
6933 */
6934 static int ipw_qos_set_info_element(struct ipw_priv *priv)
6935 {
6936         int ret = 0;
6937         struct libipw_qos_information_element qos_info;
6938
6939         if (priv == NULL)
6940                 return -1;
6941
6942         qos_info.elementID = QOS_ELEMENT_ID;
6943         qos_info.length = sizeof(struct libipw_qos_information_element) - 2;
6944
6945         qos_info.version = QOS_VERSION_1;
6946         qos_info.ac_info = 0;
6947
6948         memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
6949         qos_info.qui_type = QOS_OUI_TYPE;
6950         qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
6951
6952         ret = ipw_send_qos_info_command(priv, &qos_info);
6953         if (ret != 0) {
6954                 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
6955         }
6956         return ret;
6957 }
6958
6959 /*
6960 * Set the QoS parameter with the association request structure
6961 */
6962 static int ipw_qos_association(struct ipw_priv *priv,
6963                                struct libipw_network *network)
6964 {
6965         int err = 0;
6966         struct libipw_qos_data *qos_data = NULL;
6967         struct libipw_qos_data ibss_data = {
6968                 .supported = 1,
6969                 .active = 1,
6970         };
6971
6972         switch (priv->ieee->iw_mode) {
6973         case IW_MODE_ADHOC:
6974                 BUG_ON(!(network->capability & WLAN_CAPABILITY_IBSS));
6975
6976                 qos_data = &ibss_data;
6977                 break;
6978
6979         case IW_MODE_INFRA:
6980                 qos_data = &network->qos_data;
6981                 break;
6982
6983         default:
6984                 BUG();
6985                 break;
6986         }
6987
6988         err = ipw_qos_activate(priv, qos_data);
6989         if (err) {
6990                 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
6991                 return err;
6992         }
6993
6994         if (priv->qos_data.qos_enable && qos_data->supported) {
6995                 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
6996                 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
6997                 return ipw_qos_set_info_element(priv);
6998         }
6999
7000         return 0;
7001 }
7002
7003 /*
7004 * handling the beaconing responses. if we get different QoS setting
7005 * off the network from the associated setting, adjust the QoS
7006 * setting
7007 */
7008 static void ipw_qos_association_resp(struct ipw_priv *priv,
7009                                     struct libipw_network *network)
7010 {
7011         unsigned long flags;
7012         u32 size = sizeof(struct libipw_qos_parameters);
7013         int set_qos_param = 0;
7014
7015         if ((priv == NULL) || (network == NULL) ||
7016             (priv->assoc_network == NULL))
7017                 return;
7018
7019         if (!(priv->status & STATUS_ASSOCIATED))
7020                 return;
7021
7022         if ((priv->ieee->iw_mode != IW_MODE_INFRA))
7023                 return;
7024
7025         spin_lock_irqsave(&priv->ieee->lock, flags);
7026         if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
7027                 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
7028                        sizeof(struct libipw_qos_data));
7029                 priv->assoc_network->qos_data.active = 1;
7030                 if ((network->qos_data.old_param_count !=
7031                      network->qos_data.param_count)) {
7032                         set_qos_param = 1;
7033                         network->qos_data.old_param_count =
7034                             network->qos_data.param_count;
7035                 }
7036
7037         } else {
7038                 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
7039                         memcpy(&priv->assoc_network->qos_data.parameters,
7040                                &def_parameters_CCK, size);
7041                 else
7042                         memcpy(&priv->assoc_network->qos_data.parameters,
7043                                &def_parameters_OFDM, size);
7044                 priv->assoc_network->qos_data.active = 0;
7045                 priv->assoc_network->qos_data.supported = 0;
7046                 set_qos_param = 1;
7047         }
7048
7049         spin_unlock_irqrestore(&priv->ieee->lock, flags);
7050
7051         if (set_qos_param == 1)
7052                 schedule_work(&priv->qos_activate);
7053 }
7054
7055 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
7056 {
7057         u32 ret = 0;
7058
7059         if (!priv)
7060                 return 0;
7061
7062         if (!(priv->ieee->modulation & LIBIPW_OFDM_MODULATION))
7063                 ret = priv->qos_data.burst_duration_CCK;
7064         else
7065                 ret = priv->qos_data.burst_duration_OFDM;
7066
7067         return ret;
7068 }
7069
7070 /*
7071 * Initialize the setting of QoS global
7072 */
7073 static void ipw_qos_init(struct ipw_priv *priv, int enable,
7074                          int burst_enable, u32 burst_duration_CCK,
7075                          u32 burst_duration_OFDM)
7076 {
7077         priv->qos_data.qos_enable = enable;
7078
7079         if (priv->qos_data.qos_enable) {
7080                 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
7081                 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
7082                 IPW_DEBUG_QOS("QoS is enabled\n");
7083         } else {
7084                 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
7085                 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
7086                 IPW_DEBUG_QOS("QoS is not enabled\n");
7087         }
7088
7089         priv->qos_data.burst_enable = burst_enable;
7090
7091         if (burst_enable) {
7092                 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
7093                 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
7094         } else {
7095                 priv->qos_data.burst_duration_CCK = 0;
7096                 priv->qos_data.burst_duration_OFDM = 0;
7097         }
7098 }
7099
7100 /*
7101 * map the packet priority to the right TX Queue
7102 */
7103 static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
7104 {
7105         if (priority > 7 || !priv->qos_data.qos_enable)
7106                 priority = 0;
7107
7108         return from_priority_to_tx_queue[priority] - 1;
7109 }
7110
7111 static int ipw_is_qos_active(struct net_device *dev,
7112                              struct sk_buff *skb)
7113 {
7114         struct ipw_priv *priv = libipw_priv(dev);
7115         struct libipw_qos_data *qos_data = NULL;
7116         int active, supported;
7117         u8 *daddr = skb->data + ETH_ALEN;
7118         int unicast = !is_multicast_ether_addr(daddr);
7119
7120         if (!(priv->status & STATUS_ASSOCIATED))
7121                 return 0;
7122
7123         qos_data = &priv->assoc_network->qos_data;
7124
7125         if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7126                 if (unicast == 0)
7127                         qos_data->active = 0;
7128                 else
7129                         qos_data->active = qos_data->supported;
7130         }
7131         active = qos_data->active;
7132         supported = qos_data->supported;
7133         IPW_DEBUG_QOS("QoS  %d network is QoS active %d  supported %d  "
7134                       "unicast %d\n",
7135                       priv->qos_data.qos_enable, active, supported, unicast);
7136         if (active && priv->qos_data.qos_enable)
7137                 return 1;
7138
7139         return 0;
7140
7141 }
7142 /*
7143 * add QoS parameter to the TX command
7144 */
7145 static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
7146                                         u16 priority,
7147                                         struct tfd_data *tfd)
7148 {
7149         int tx_queue_id = 0;
7150
7151
7152         tx_queue_id = from_priority_to_tx_queue[priority] - 1;
7153         tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
7154
7155         if (priv->qos_data.qos_no_ack_mask & (1UL << tx_queue_id)) {
7156                 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
7157                 tfd->tfd.tfd_26.mchdr.qos_ctrl |= cpu_to_le16(CTRL_QOS_NO_ACK);
7158         }
7159         return 0;
7160 }
7161
7162 /*
7163 * background support to run QoS activate functionality
7164 */
7165 static void ipw_bg_qos_activate(struct work_struct *work)
7166 {
7167         struct ipw_priv *priv =
7168                 container_of(work, struct ipw_priv, qos_activate);
7169
7170         mutex_lock(&priv->mutex);
7171
7172         if (priv->status & STATUS_ASSOCIATED)
7173                 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
7174
7175         mutex_unlock(&priv->mutex);
7176 }
7177
7178 static int ipw_handle_probe_response(struct net_device *dev,
7179                                      struct libipw_probe_response *resp,
7180                                      struct libipw_network *network)
7181 {
7182         struct ipw_priv *priv = libipw_priv(dev);
7183         int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7184                               (network == priv->assoc_network));
7185
7186         ipw_qos_handle_probe_response(priv, active_network, network);
7187
7188         return 0;
7189 }
7190
7191 static int ipw_handle_beacon(struct net_device *dev,
7192                              struct libipw_beacon *resp,
7193                              struct libipw_network *network)
7194 {
7195         struct ipw_priv *priv = libipw_priv(dev);
7196         int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7197                               (network == priv->assoc_network));
7198
7199         ipw_qos_handle_probe_response(priv, active_network, network);
7200
7201         return 0;
7202 }
7203
7204 static int ipw_handle_assoc_response(struct net_device *dev,
7205                                      struct libipw_assoc_response *resp,
7206                                      struct libipw_network *network)
7207 {
7208         struct ipw_priv *priv = libipw_priv(dev);
7209         ipw_qos_association_resp(priv, network);
7210         return 0;
7211 }
7212
7213 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct libipw_qos_parameters
7214                                        *qos_param)
7215 {
7216         return ipw_send_cmd_pdu(priv, IPW_CMD_QOS_PARAMETERS,
7217                                 sizeof(*qos_param) * 3, qos_param);
7218 }
7219
7220 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct libipw_qos_information_element
7221                                      *qos_param)
7222 {
7223         return ipw_send_cmd_pdu(priv, IPW_CMD_WME_INFO, sizeof(*qos_param),
7224                                 qos_param);
7225 }
7226
7227 #endif                          /* CONFIG_IPW2200_QOS */
7228
7229 static int ipw_associate_network(struct ipw_priv *priv,
7230                                  struct libipw_network *network,
7231                                  struct ipw_supported_rates *rates, int roaming)
7232 {
7233         int err;
7234
7235         if (priv->config & CFG_FIXED_RATE)
7236                 ipw_set_fixed_rate(priv, network->mode);
7237
7238         if (!(priv->config & CFG_STATIC_ESSID)) {
7239                 priv->essid_len = min(network->ssid_len,
7240                                       (u8) IW_ESSID_MAX_SIZE);
7241                 memcpy(priv->essid, network->ssid, priv->essid_len);
7242         }
7243
7244         network->last_associate = jiffies;
7245
7246         memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7247         priv->assoc_request.channel = network->channel;
7248         priv->assoc_request.auth_key = 0;
7249
7250         if ((priv->capability & CAP_PRIVACY_ON) &&
7251             (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)) {
7252                 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
7253                 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7254
7255                 if (priv->ieee->sec.level == SEC_LEVEL_1)
7256                         ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
7257
7258         } else if ((priv->capability & CAP_PRIVACY_ON) &&
7259                    (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP))
7260                 priv->assoc_request.auth_type = AUTH_LEAP;
7261         else
7262                 priv->assoc_request.auth_type = AUTH_OPEN;
7263
7264         if (priv->ieee->wpa_ie_len) {
7265                 priv->assoc_request.policy_support = cpu_to_le16(0x02); /* RSN active */
7266                 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7267                                  priv->ieee->wpa_ie_len);
7268         }
7269
7270         /*
7271          * It is valid for our ieee device to support multiple modes, but
7272          * when it comes to associating to a given network we have to choose
7273          * just one mode.
7274          */
7275         if (network->mode & priv->ieee->mode & IEEE_A)
7276                 priv->assoc_request.ieee_mode = IPW_A_MODE;
7277         else if (network->mode & priv->ieee->mode & IEEE_G)
7278                 priv->assoc_request.ieee_mode = IPW_G_MODE;
7279         else if (network->mode & priv->ieee->mode & IEEE_B)
7280                 priv->assoc_request.ieee_mode = IPW_B_MODE;
7281
7282         priv->assoc_request.capability = cpu_to_le16(network->capability);
7283         if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7284             && !(priv->config & CFG_PREAMBLE_LONG)) {
7285                 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7286         } else {
7287                 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7288
7289                 /* Clear the short preamble if we won't be supporting it */
7290                 priv->assoc_request.capability &=
7291                     ~cpu_to_le16(WLAN_CAPABILITY_SHORT_PREAMBLE);
7292         }
7293
7294         /* Clear capability bits that aren't used in Ad Hoc */
7295         if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7296                 priv->assoc_request.capability &=
7297                     ~cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT_TIME);
7298
7299         IPW_DEBUG_ASSOC("%ssociation attempt: '%*pE', channel %d, 802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
7300                         roaming ? "Rea" : "A",
7301                         priv->essid_len, priv->essid,
7302                         network->channel,
7303                         ipw_modes[priv->assoc_request.ieee_mode],
7304                         rates->num_rates,
7305                         (priv->assoc_request.preamble_length ==
7306                          DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7307                         network->capability &
7308                         WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
7309                         priv->capability & CAP_PRIVACY_ON ? "on " : "off",
7310                         priv->capability & CAP_PRIVACY_ON ?
7311                         (priv->capability & CAP_SHARED_KEY ? "(shared)" :
7312                          "(open)") : "",
7313                         priv->capability & CAP_PRIVACY_ON ? " key=" : "",
7314                         priv->capability & CAP_PRIVACY_ON ?
7315                         '1' + priv->ieee->sec.active_key : '.',
7316                         priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
7317
7318         priv->assoc_request.beacon_interval = cpu_to_le16(network->beacon_interval);
7319         if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
7320             (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
7321                 priv->assoc_request.assoc_type = HC_IBSS_START;
7322                 priv->assoc_request.assoc_tsf_msw = 0;
7323                 priv->assoc_request.assoc_tsf_lsw = 0;
7324         } else {
7325                 if (unlikely(roaming))
7326                         priv->assoc_request.assoc_type = HC_REASSOCIATE;
7327                 else
7328                         priv->assoc_request.assoc_type = HC_ASSOCIATE;
7329                 priv->assoc_request.assoc_tsf_msw = cpu_to_le32(network->time_stamp[1]);
7330                 priv->assoc_request.assoc_tsf_lsw = cpu_to_le32(network->time_stamp[0]);
7331         }
7332
7333         memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
7334
7335         if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7336                 eth_broadcast_addr(priv->assoc_request.dest);
7337                 priv->assoc_request.atim_window = cpu_to_le16(network->atim_window);
7338         } else {
7339                 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
7340                 priv->assoc_request.atim_window = 0;
7341         }
7342
7343         priv->assoc_request.listen_interval = cpu_to_le16(network->listen_interval);
7344
7345         err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7346         if (err) {
7347                 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7348                 return err;
7349         }
7350
7351         rates->ieee_mode = priv->assoc_request.ieee_mode;
7352         rates->purpose = IPW_RATE_CONNECT;
7353         ipw_send_supported_rates(priv, rates);
7354
7355         if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7356                 priv->sys_config.dot11g_auto_detection = 1;
7357         else
7358                 priv->sys_config.dot11g_auto_detection = 0;
7359
7360         if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7361                 priv->sys_config.answer_broadcast_ssid_probe = 1;
7362         else
7363                 priv->sys_config.answer_broadcast_ssid_probe = 0;
7364
7365         err = ipw_send_system_config(priv);
7366         if (err) {
7367                 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7368                 return err;
7369         }
7370
7371         IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
7372         err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
7373         if (err) {
7374                 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7375                 return err;
7376         }
7377
7378         /*
7379          * If preemption is enabled, it is possible for the association
7380          * to complete before we return from ipw_send_associate.  Therefore
7381          * we have to be sure and update our priviate data first.
7382          */
7383         priv->channel = network->channel;
7384         memcpy(priv->bssid, network->bssid, ETH_ALEN);
7385         priv->status |= STATUS_ASSOCIATING;
7386         priv->status &= ~STATUS_SECURITY_UPDATED;
7387
7388         priv->assoc_network = network;
7389
7390 #ifdef CONFIG_IPW2200_QOS
7391         ipw_qos_association(priv, network);
7392 #endif
7393
7394         err = ipw_send_associate(priv, &priv->assoc_request);
7395         if (err) {
7396                 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7397                 return err;
7398         }
7399
7400         IPW_DEBUG(IPW_DL_STATE, "associating: '%*pE' %pM\n",
7401                   priv->essid_len, priv->essid, priv->bssid);
7402
7403         return 0;
7404 }
7405
7406 static void ipw_roam(void *data)
7407 {
7408         struct ipw_priv *priv = data;
7409         struct libipw_network *network = NULL;
7410         struct ipw_network_match match = {
7411                 .network = priv->assoc_network
7412         };
7413
7414         /* The roaming process is as follows:
7415          *
7416          * 1.  Missed beacon threshold triggers the roaming process by
7417          *     setting the status ROAM bit and requesting a scan.
7418          * 2.  When the scan completes, it schedules the ROAM work
7419          * 3.  The ROAM work looks at all of the known networks for one that
7420          *     is a better network than the currently associated.  If none
7421          *     found, the ROAM process is over (ROAM bit cleared)
7422          * 4.  If a better network is found, a disassociation request is
7423          *     sent.
7424          * 5.  When the disassociation completes, the roam work is again
7425          *     scheduled.  The second time through, the driver is no longer
7426          *     associated, and the newly selected network is sent an
7427          *     association request.
7428          * 6.  At this point ,the roaming process is complete and the ROAM
7429          *     status bit is cleared.
7430          */
7431
7432         /* If we are no longer associated, and the roaming bit is no longer
7433          * set, then we are not actively roaming, so just return */
7434         if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7435                 return;
7436
7437         if (priv->status & STATUS_ASSOCIATED) {
7438                 /* First pass through ROAM process -- look for a better
7439                  * network */
7440                 unsigned long flags;
7441                 u8 rssi = priv->assoc_network->stats.rssi;
7442                 priv->assoc_network->stats.rssi = -128;
7443                 spin_lock_irqsave(&priv->ieee->lock, flags);
7444                 list_for_each_entry(network, &priv->ieee->network_list, list) {
7445                         if (network != priv->assoc_network)
7446                                 ipw_best_network(priv, &match, network, 1);
7447                 }
7448                 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7449                 priv->assoc_network->stats.rssi = rssi;
7450
7451                 if (match.network == priv->assoc_network) {
7452                         IPW_DEBUG_ASSOC("No better APs in this network to "
7453                                         "roam to.\n");
7454                         priv->status &= ~STATUS_ROAMING;
7455                         ipw_debug_config(priv);
7456                         return;
7457                 }
7458
7459                 ipw_send_disassociate(priv, 1);
7460                 priv->assoc_network = match.network;
7461
7462                 return;
7463         }
7464
7465         /* Second pass through ROAM process -- request association */
7466         ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7467         ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7468         priv->status &= ~STATUS_ROAMING;
7469 }
7470
7471 static void ipw_bg_roam(struct work_struct *work)
7472 {
7473         struct ipw_priv *priv =
7474                 container_of(work, struct ipw_priv, roam);
7475         mutex_lock(&priv->mutex);
7476         ipw_roam(priv);
7477         mutex_unlock(&priv->mutex);
7478 }
7479
7480 static int ipw_associate(void *data)
7481 {
7482         struct ipw_priv *priv = data;
7483
7484         struct libipw_network *network = NULL;
7485         struct ipw_network_match match = {
7486                 .network = NULL
7487         };
7488         struct ipw_supported_rates *rates;
7489         struct list_head *element;
7490         unsigned long flags;
7491
7492         if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7493                 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7494                 return 0;
7495         }
7496
7497         if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
7498                 IPW_DEBUG_ASSOC("Not attempting association (already in "
7499                                 "progress)\n");
7500                 return 0;
7501         }
7502
7503         if (priv->status & STATUS_DISASSOCIATING) {
7504                 IPW_DEBUG_ASSOC("Not attempting association (in disassociating)\n");
7505                 schedule_work(&priv->associate);
7506                 return 0;
7507         }
7508
7509         if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
7510                 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7511                                 "initialized)\n");
7512                 return 0;
7513         }
7514
7515         if (!(priv->config & CFG_ASSOCIATE) &&
7516             !(priv->config & (CFG_STATIC_ESSID | CFG_STATIC_BSSID))) {
7517                 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
7518                 return 0;
7519         }
7520
7521         /* Protect our use of the network_list */
7522         spin_lock_irqsave(&priv->ieee->lock, flags);
7523         list_for_each_entry(network, &priv->ieee->network_list, list)
7524             ipw_best_network(priv, &match, network, 0);
7525
7526         network = match.network;
7527         rates = &match.rates;
7528
7529         if (network == NULL &&
7530             priv->ieee->iw_mode == IW_MODE_ADHOC &&
7531             priv->config & CFG_ADHOC_CREATE &&
7532             priv->config & CFG_STATIC_ESSID &&
7533             priv->config & CFG_STATIC_CHANNEL) {
7534                 /* Use oldest network if the free list is empty */
7535                 if (list_empty(&priv->ieee->network_free_list)) {
7536                         struct libipw_network *oldest = NULL;
7537                         struct libipw_network *target;
7538
7539                         list_for_each_entry(target, &priv->ieee->network_list, list) {
7540                                 if ((oldest == NULL) ||
7541                                     (target->last_scanned < oldest->last_scanned))
7542                                         oldest = target;
7543                         }
7544
7545                         /* If there are no more slots, expire the oldest */
7546                         list_del(&oldest->list);
7547                         target = oldest;
7548                         IPW_DEBUG_ASSOC("Expired '%*pE' (%pM) from network list.\n",
7549                                         target->ssid_len, target->ssid,
7550                                         target->bssid);
7551                         list_add_tail(&target->list,
7552                                       &priv->ieee->network_free_list);
7553                 }
7554
7555                 element = priv->ieee->network_free_list.next;
7556                 network = list_entry(element, struct libipw_network, list);
7557                 ipw_adhoc_create(priv, network);
7558                 rates = &priv->rates;
7559                 list_del(element);
7560                 list_add_tail(&network->list, &priv->ieee->network_list);
7561         }
7562         spin_unlock_irqrestore(&priv->ieee->lock, flags);
7563
7564         /* If we reached the end of the list, then we don't have any valid
7565          * matching APs */
7566         if (!network) {
7567                 ipw_debug_config(priv);
7568
7569                 if (!(priv->status & STATUS_SCANNING)) {
7570                         if (!(priv->config & CFG_SPEED_SCAN))
7571                                 schedule_delayed_work(&priv->request_scan,
7572                                                       SCAN_INTERVAL);
7573                         else
7574                                 schedule_delayed_work(&priv->request_scan, 0);
7575                 }
7576
7577                 return 0;
7578         }
7579
7580         ipw_associate_network(priv, network, rates, 0);
7581
7582         return 1;
7583 }
7584
7585 static void ipw_bg_associate(struct work_struct *work)
7586 {
7587         struct ipw_priv *priv =
7588                 container_of(work, struct ipw_priv, associate);
7589         mutex_lock(&priv->mutex);
7590         ipw_associate(priv);
7591         mutex_unlock(&priv->mutex);
7592 }
7593
7594 static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7595                                       struct sk_buff *skb)
7596 {
7597         struct ieee80211_hdr *hdr;
7598         u16 fc;
7599
7600         hdr = (struct ieee80211_hdr *)skb->data;
7601         fc = le16_to_cpu(hdr->frame_control);
7602         if (!(fc & IEEE80211_FCTL_PROTECTED))
7603                 return;
7604
7605         fc &= ~IEEE80211_FCTL_PROTECTED;
7606         hdr->frame_control = cpu_to_le16(fc);
7607         switch (priv->ieee->sec.level) {
7608         case SEC_LEVEL_3:
7609                 /* Remove CCMP HDR */
7610                 memmove(skb->data + LIBIPW_3ADDR_LEN,
7611                         skb->data + LIBIPW_3ADDR_LEN + 8,
7612                         skb->len - LIBIPW_3ADDR_LEN - 8);
7613                 skb_trim(skb, skb->len - 16);   /* CCMP_HDR_LEN + CCMP_MIC_LEN */
7614                 break;
7615         case SEC_LEVEL_2:
7616                 break;
7617         case SEC_LEVEL_1:
7618                 /* Remove IV */
7619                 memmove(skb->data + LIBIPW_3ADDR_LEN,
7620                         skb->data + LIBIPW_3ADDR_LEN + 4,
7621                         skb->len - LIBIPW_3ADDR_LEN - 4);
7622                 skb_trim(skb, skb->len - 8);    /* IV + ICV */
7623                 break;
7624         case SEC_LEVEL_0:
7625                 break;
7626         default:
7627                 printk(KERN_ERR "Unknown security level %d\n",
7628                        priv->ieee->sec.level);
7629                 break;
7630         }
7631 }
7632
7633 static void ipw_handle_data_packet(struct ipw_priv *priv,
7634                                    struct ipw_rx_mem_buffer *rxb,
7635                                    struct libipw_rx_stats *stats)
7636 {
7637         struct net_device *dev = priv->net_dev;
7638         struct libipw_hdr_4addr *hdr;
7639         struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7640
7641         /* We received data from the HW, so stop the watchdog */
7642         netif_trans_update(dev);
7643
7644         /* We only process data packets if the
7645          * interface is open */
7646         if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7647                      skb_tailroom(rxb->skb))) {
7648                 dev->stats.rx_errors++;
7649                 priv->wstats.discard.misc++;
7650                 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7651                 return;
7652         } else if (unlikely(!netif_running(priv->net_dev))) {
7653                 dev->stats.rx_dropped++;
7654                 priv->wstats.discard.misc++;
7655                 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7656                 return;
7657         }
7658
7659         /* Advance skb->data to the start of the actual payload */
7660         skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
7661
7662         /* Set the size of the skb to the size of the frame */
7663         skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
7664
7665         IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7666
7667         /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
7668         hdr = (struct libipw_hdr_4addr *)rxb->skb->data;
7669         if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
7670             (is_multicast_ether_addr(hdr->addr1) ?
7671              !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
7672                 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7673
7674         if (!libipw_rx(priv->ieee, rxb->skb, stats))
7675                 dev->stats.rx_errors++;
7676         else {                  /* libipw_rx succeeded, so it now owns the SKB */
7677                 rxb->skb = NULL;
7678                 __ipw_led_activity_on(priv);
7679         }
7680 }
7681
7682 #ifdef CONFIG_IPW2200_RADIOTAP
7683 static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7684                                            struct ipw_rx_mem_buffer *rxb,
7685                                            struct libipw_rx_stats *stats)
7686 {
7687         struct net_device *dev = priv->net_dev;
7688         struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7689         struct ipw_rx_frame *frame = &pkt->u.frame;
7690
7691         /* initial pull of some data */
7692         u16 received_channel = frame->received_channel;
7693         u8 antennaAndPhy = frame->antennaAndPhy;
7694         s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM;       /* call it signed anyhow */
7695         u16 pktrate = frame->rate;
7696
7697         /* Magic struct that slots into the radiotap header -- no reason
7698          * to build this manually element by element, we can write it much
7699          * more efficiently than we can parse it. ORDER MATTERS HERE */
7700         struct ipw_rt_hdr *ipw_rt;
7701
7702         unsigned short len = le16_to_cpu(pkt->u.frame.length);
7703
7704         /* We received data from the HW, so stop the watchdog */
7705         netif_trans_update(dev);
7706
7707         /* We only process data packets if the
7708          * interface is open */
7709         if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7710                      skb_tailroom(rxb->skb))) {
7711                 dev->stats.rx_errors++;
7712                 priv->wstats.discard.misc++;
7713                 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7714                 return;
7715         } else if (unlikely(!netif_running(priv->net_dev))) {
7716                 dev->stats.rx_dropped++;
7717                 priv->wstats.discard.misc++;
7718                 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7719                 return;
7720         }
7721
7722         /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7723          * that now */
7724         if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7725                 /* FIXME: Should alloc bigger skb instead */
7726                 dev->stats.rx_dropped++;
7727                 priv->wstats.discard.misc++;
7728                 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7729                 return;
7730         }
7731
7732         /* copy the frame itself */
7733         memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7734                 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7735
7736         ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7737
7738         ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7739         ipw_rt->rt_hdr.it_pad = 0;      /* always good to zero */
7740         ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(struct ipw_rt_hdr)); /* total header+data */
7741
7742         /* Big bitfield of all the fields we provide in radiotap */
7743         ipw_rt->rt_hdr.it_present = cpu_to_le32(
7744              (1 << IEEE80211_RADIOTAP_TSFT) |
7745              (1 << IEEE80211_RADIOTAP_FLAGS) |
7746              (1 << IEEE80211_RADIOTAP_RATE) |
7747              (1 << IEEE80211_RADIOTAP_CHANNEL) |
7748              (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
7749              (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |
7750              (1 << IEEE80211_RADIOTAP_ANTENNA));
7751
7752         /* Zero the flags, we'll add to them as we go */
7753         ipw_rt->rt_flags = 0;
7754         ipw_rt->rt_tsf = (u64)(frame->parent_tsf[3] << 24 |
7755                                frame->parent_tsf[2] << 16 |
7756                                frame->parent_tsf[1] << 8  |
7757                                frame->parent_tsf[0]);
7758
7759         /* Convert signal to DBM */
7760         ipw_rt->rt_dbmsignal = antsignal;
7761         ipw_rt->rt_dbmnoise = (s8) le16_to_cpu(frame->noise);
7762
7763         /* Convert the channel data and set the flags */
7764         ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7765         if (received_channel > 14) {    /* 802.11a */
7766                 ipw_rt->rt_chbitmask =
7767                     cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7768         } else if (antennaAndPhy & 32) {        /* 802.11b */
7769                 ipw_rt->rt_chbitmask =
7770                     cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7771         } else {                /* 802.11g */
7772                 ipw_rt->rt_chbitmask =
7773                     cpu_to_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
7774         }
7775
7776         /* set the rate in multiples of 500k/s */
7777         switch (pktrate) {
7778         case IPW_TX_RATE_1MB:
7779                 ipw_rt->rt_rate = 2;
7780                 break;
7781         case IPW_TX_RATE_2MB:
7782                 ipw_rt->rt_rate = 4;
7783                 break;
7784         case IPW_TX_RATE_5MB:
7785                 ipw_rt->rt_rate = 10;
7786                 break;
7787         case IPW_TX_RATE_6MB:
7788                 ipw_rt->rt_rate = 12;
7789                 break;
7790         case IPW_TX_RATE_9MB:
7791                 ipw_rt->rt_rate = 18;
7792                 break;
7793         case IPW_TX_RATE_11MB:
7794                 ipw_rt->rt_rate = 22;
7795                 break;
7796         case IPW_TX_RATE_12MB:
7797                 ipw_rt->rt_rate = 24;
7798                 break;
7799         case IPW_TX_RATE_18MB:
7800                 ipw_rt->rt_rate = 36;
7801                 break;
7802         case IPW_TX_RATE_24MB:
7803                 ipw_rt->rt_rate = 48;
7804                 break;
7805         case IPW_TX_RATE_36MB:
7806                 ipw_rt->rt_rate = 72;
7807                 break;
7808         case IPW_TX_RATE_48MB:
7809                 ipw_rt->rt_rate = 96;
7810                 break;
7811         case IPW_TX_RATE_54MB:
7812                 ipw_rt->rt_rate = 108;
7813                 break;
7814         default:
7815                 ipw_rt->rt_rate = 0;
7816                 break;
7817         }
7818
7819         /* antenna number */
7820         ipw_rt->rt_antenna = (antennaAndPhy & 3);       /* Is this right? */
7821
7822         /* set the preamble flag if we have it */
7823         if ((antennaAndPhy & 64))
7824                 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7825
7826         /* Set the size of the skb to the size of the frame */
7827         skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
7828
7829         IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7830
7831         if (!libipw_rx(priv->ieee, rxb->skb, stats))
7832                 dev->stats.rx_errors++;
7833         else {                  /* libipw_rx succeeded, so it now owns the SKB */
7834                 rxb->skb = NULL;
7835                 /* no LED during capture */
7836         }
7837 }
7838 #endif
7839
7840 #ifdef CONFIG_IPW2200_PROMISCUOUS
7841 #define libipw_is_probe_response(fc) \
7842    ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT && \
7843     (fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_PROBE_RESP )
7844
7845 #define libipw_is_management(fc) \
7846    ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_MGMT)
7847
7848 #define libipw_is_control(fc) \
7849    ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_CTL)
7850
7851 #define libipw_is_data(fc) \
7852    ((fc & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA)
7853
7854 #define libipw_is_assoc_request(fc) \
7855    ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_ASSOC_REQ)
7856
7857 #define libipw_is_reassoc_request(fc) \
7858    ((fc & IEEE80211_FCTL_STYPE) == IEEE80211_STYPE_REASSOC_REQ)
7859
7860 static void ipw_handle_promiscuous_rx(struct ipw_priv *priv,
7861                                       struct ipw_rx_mem_buffer *rxb,
7862                                       struct libipw_rx_stats *stats)
7863 {
7864         struct net_device *dev = priv->prom_net_dev;
7865         struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7866         struct ipw_rx_frame *frame = &pkt->u.frame;
7867         struct ipw_rt_hdr *ipw_rt;
7868
7869         /* First cache any information we need before we overwrite
7870          * the information provided in the skb from the hardware */
7871         struct ieee80211_hdr *hdr;
7872         u16 channel = frame->received_channel;
7873         u8 phy_flags = frame->antennaAndPhy;
7874         s8 signal = frame->rssi_dbm - IPW_RSSI_TO_DBM;
7875         s8 noise = (s8) le16_to_cpu(frame->noise);
7876         u8 rate = frame->rate;
7877         unsigned short len = le16_to_cpu(pkt->u.frame.length);
7878         struct sk_buff *skb;
7879         int hdr_only = 0;
7880         u16 filter = priv->prom_priv->filter;
7881
7882         /* If the filter is set to not include Rx frames then return */
7883         if (filter & IPW_PROM_NO_RX)
7884                 return;
7885
7886         /* We received data from the HW, so stop the watchdog */
7887         netif_trans_update(dev);
7888
7889         if (unlikely((len + IPW_RX_FRAME_SIZE) > skb_tailroom(rxb->skb))) {
7890                 dev->stats.rx_errors++;
7891                 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7892                 return;
7893         }
7894
7895         /* We only process data packets if the interface is open */
7896         if (unlikely(!netif_running(dev))) {
7897                 dev->stats.rx_dropped++;
7898                 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7899                 return;
7900         }
7901
7902         /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7903          * that now */
7904         if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7905                 /* FIXME: Should alloc bigger skb instead */
7906                 dev->stats.rx_dropped++;
7907                 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7908                 return;
7909         }
7910
7911         hdr = (void *)rxb->skb->data + IPW_RX_FRAME_SIZE;
7912         if (libipw_is_management(le16_to_cpu(hdr->frame_control))) {
7913                 if (filter & IPW_PROM_NO_MGMT)
7914                         return;
7915                 if (filter & IPW_PROM_MGMT_HEADER_ONLY)
7916                         hdr_only = 1;
7917         } else if (libipw_is_control(le16_to_cpu(hdr->frame_control))) {
7918                 if (filter & IPW_PROM_NO_CTL)
7919                         return;
7920                 if (filter & IPW_PROM_CTL_HEADER_ONLY)
7921                         hdr_only = 1;
7922         } else if (libipw_is_data(le16_to_cpu(hdr->frame_control))) {
7923                 if (filter & IPW_PROM_NO_DATA)
7924                         return;
7925                 if (filter & IPW_PROM_DATA_HEADER_ONLY)
7926                         hdr_only = 1;
7927         }
7928
7929         /* Copy the SKB since this is for the promiscuous side */
7930         skb = skb_copy(rxb->skb, GFP_ATOMIC);
7931         if (skb == NULL) {
7932                 IPW_ERROR("skb_clone failed for promiscuous copy.\n");
7933                 return;
7934         }
7935
7936         /* copy the frame data to write after where the radiotap header goes */
7937         ipw_rt = (void *)skb->data;
7938
7939         if (hdr_only)
7940                 len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_control));
7941
7942         memcpy(ipw_rt->payload, hdr, len);
7943
7944         ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7945         ipw_rt->rt_hdr.it_pad = 0;      /* always good to zero */
7946         ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(*ipw_rt));   /* total header+data */
7947
7948         /* Set the size of the skb to the size of the frame */
7949         skb_put(skb, sizeof(*ipw_rt) + len);
7950
7951         /* Big bitfield of all the fields we provide in radiotap */
7952         ipw_rt->rt_hdr.it_present = cpu_to_le32(
7953              (1 << IEEE80211_RADIOTAP_TSFT) |
7954              (1 << IEEE80211_RADIOTAP_FLAGS) |
7955              (1 << IEEE80211_RADIOTAP_RATE) |
7956              (1 << IEEE80211_RADIOTAP_CHANNEL) |
7957              (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
7958              (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |
7959              (1 << IEEE80211_RADIOTAP_ANTENNA));
7960
7961         /* Zero the flags, we'll add to them as we go */
7962         ipw_rt->rt_flags = 0;
7963         ipw_rt->rt_tsf = (u64)(frame->parent_tsf[3] << 24 |
7964                                frame->parent_tsf[2] << 16 |
7965                                frame->parent_tsf[1] << 8  |
7966                                frame->parent_tsf[0]);
7967
7968         /* Convert to DBM */
7969         ipw_rt->rt_dbmsignal = signal;
7970         ipw_rt->rt_dbmnoise = noise;
7971
7972         /* Convert the channel data and set the flags */
7973         ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(channel));
7974         if (channel > 14) {     /* 802.11a */
7975                 ipw_rt->rt_chbitmask =
7976                     cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7977         } else if (phy_flags & (1 << 5)) {      /* 802.11b */
7978                 ipw_rt->rt_chbitmask =
7979                     cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7980         } else {                /* 802.11g */
7981                 ipw_rt->rt_chbitmask =
7982                     cpu_to_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
7983         }
7984
7985         /* set the rate in multiples of 500k/s */
7986         switch (rate) {
7987         case IPW_TX_RATE_1MB:
7988                 ipw_rt->rt_rate = 2;
7989                 break;
7990         case IPW_TX_RATE_2MB:
7991                 ipw_rt->rt_rate = 4;
7992                 break;
7993         case IPW_TX_RATE_5MB:
7994                 ipw_rt->rt_rate = 10;
7995                 break;
7996         case IPW_TX_RATE_6MB:
7997                 ipw_rt->rt_rate = 12;
7998                 break;
7999         case IPW_TX_RATE_9MB:
8000                 ipw_rt->rt_rate = 18;
8001                 break;
8002         case IPW_TX_RATE_11MB:
8003                 ipw_rt->rt_rate = 22;
8004                 break;
8005         case IPW_TX_RATE_12MB:
8006                 ipw_rt->rt_rate = 24;
8007                 break;
8008         case IPW_TX_RATE_18MB:
8009                 ipw_rt->rt_rate = 36;
8010                 break;
8011         case IPW_TX_RATE_24MB:
8012                 ipw_rt->rt_rate = 48;
8013                 break;
8014         case IPW_TX_RATE_36MB:
8015                 ipw_rt->rt_rate = 72;
8016                 break;
8017         case IPW_TX_RATE_48MB:
8018                 ipw_rt->rt_rate = 96;
8019                 break;
8020         case IPW_TX_RATE_54MB:
8021                 ipw_rt->rt_rate = 108;
8022                 break;
8023         default:
8024                 ipw_rt->rt_rate = 0;
8025                 break;
8026         }
8027
8028         /* antenna number */
8029         ipw_rt->rt_antenna = (phy_flags & 3);
8030
8031         /* set the preamble flag if we have it */
8032         if (phy_flags & (1 << 6))
8033                 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
8034
8035         IPW_DEBUG_RX("Rx packet of %d bytes.\n", skb->len);
8036
8037         if (!libipw_rx(priv->prom_priv->ieee, skb, stats)) {
8038                 dev->stats.rx_errors++;
8039                 dev_kfree_skb_any(skb);
8040         }
8041 }
8042 #endif
8043
8044 static int is_network_packet(struct ipw_priv *priv,
8045                                     struct libipw_hdr_4addr *header)
8046 {
8047         /* Filter incoming packets to determine if they are targeted toward
8048          * this network, discarding packets coming from ourselves */
8049         switch (priv->ieee->iw_mode) {
8050         case IW_MODE_ADHOC:     /* Header: Dest. | Source    | BSSID */
8051                 /* packets from our adapter are dropped (echo) */
8052                 if (ether_addr_equal(header->addr2, priv->net_dev->dev_addr))
8053                         return 0;
8054
8055                 /* {broad,multi}cast packets to our BSSID go through */
8056                 if (is_multicast_ether_addr(header->addr1))
8057                         return ether_addr_equal(header->addr3, priv->bssid);
8058
8059                 /* packets to our adapter go through */
8060                 return ether_addr_equal(header->addr1,
8061                                         priv->net_dev->dev_addr);
8062
8063         case IW_MODE_INFRA:     /* Header: Dest. | BSSID | Source */
8064                 /* packets from our adapter are dropped (echo) */
8065                 if (ether_addr_equal(header->addr3, priv->net_dev->dev_addr))
8066                         return 0;
8067
8068                 /* {broad,multi}cast packets to our BSS go through */
8069                 if (is_multicast_ether_addr(header->addr1))
8070                         return ether_addr_equal(header->addr2, priv->bssid);
8071
8072                 /* packets to our adapter go through */
8073                 return ether_addr_equal(header->addr1,
8074                                         priv->net_dev->dev_addr);
8075         }
8076
8077         return 1;
8078 }
8079
8080 #define IPW_PACKET_RETRY_TIME HZ
8081
8082 static  int is_duplicate_packet(struct ipw_priv *priv,
8083                                       struct libipw_hdr_4addr *header)
8084 {
8085         u16 sc = le16_to_cpu(header->seq_ctl);
8086         u16 seq = WLAN_GET_SEQ_SEQ(sc);
8087         u16 frag = WLAN_GET_SEQ_FRAG(sc);
8088         u16 *last_seq, *last_frag;
8089         unsigned long *last_time;
8090
8091         switch (priv->ieee->iw_mode) {
8092         case IW_MODE_ADHOC:
8093                 {
8094                         struct list_head *p;
8095                         struct ipw_ibss_seq *entry = NULL;
8096                         u8 *mac = header->addr2;
8097                         int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
8098
8099                         list_for_each(p, &priv->ibss_mac_hash[index]) {
8100                                 entry =
8101                                     list_entry(p, struct ipw_ibss_seq, list);
8102                                 if (ether_addr_equal(entry->mac, mac))
8103                                         break;
8104                         }
8105                         if (p == &priv->ibss_mac_hash[index]) {
8106                                 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
8107                                 if (!entry) {
8108                                         IPW_ERROR
8109                                             ("Cannot malloc new mac entry\n");
8110                                         return 0;
8111                                 }
8112                                 memcpy(entry->mac, mac, ETH_ALEN);
8113                                 entry->seq_num = seq;
8114                                 entry->frag_num = frag;
8115                                 entry->packet_time = jiffies;
8116                                 list_add(&entry->list,
8117                                          &priv->ibss_mac_hash[index]);
8118                                 return 0;
8119                         }
8120                         last_seq = &entry->seq_num;
8121                         last_frag = &entry->frag_num;
8122                         last_time = &entry->packet_time;
8123                         break;
8124                 }
8125         case IW_MODE_INFRA:
8126                 last_seq = &priv->last_seq_num;
8127                 last_frag = &priv->last_frag_num;
8128                 last_time = &priv->last_packet_time;
8129                 break;
8130         default:
8131                 return 0;
8132         }
8133         if ((*last_seq == seq) &&
8134             time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
8135                 if (*last_frag == frag)
8136                         goto drop;
8137                 if (*last_frag + 1 != frag)
8138                         /* out-of-order fragment */
8139                         goto drop;
8140         } else
8141                 *last_seq = seq;
8142
8143         *last_frag = frag;
8144         *last_time = jiffies;
8145         return 0;
8146
8147       drop:
8148         /* Comment this line now since we observed the card receives
8149          * duplicate packets but the FCTL_RETRY bit is not set in the
8150          * IBSS mode with fragmentation enabled.
8151          BUG_ON(!(le16_to_cpu(header->frame_control) & IEEE80211_FCTL_RETRY)); */
8152         return 1;
8153 }
8154
8155 static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
8156                                    struct ipw_rx_mem_buffer *rxb,
8157                                    struct libipw_rx_stats *stats)
8158 {
8159         struct sk_buff *skb = rxb->skb;
8160         struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
8161         struct libipw_hdr_4addr *header = (struct libipw_hdr_4addr *)
8162             (skb->data + IPW_RX_FRAME_SIZE);
8163
8164         libipw_rx_mgt(priv->ieee, header, stats);
8165
8166         if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
8167             ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8168               IEEE80211_STYPE_PROBE_RESP) ||
8169              (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8170               IEEE80211_STYPE_BEACON))) {
8171                 if (ether_addr_equal(header->addr3, priv->bssid))
8172                         ipw_add_station(priv, header->addr2);
8173         }
8174
8175         if (priv->config & CFG_NET_STATS) {
8176                 IPW_DEBUG_HC("sending stat packet\n");
8177
8178                 /* Set the size of the skb to the size of the full
8179                  * ipw header and 802.11 frame */
8180                 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
8181                         IPW_RX_FRAME_SIZE);
8182
8183                 /* Advance past the ipw packet header to the 802.11 frame */
8184                 skb_pull(skb, IPW_RX_FRAME_SIZE);
8185
8186                 /* Push the libipw_rx_stats before the 802.11 frame */
8187                 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
8188
8189                 skb->dev = priv->ieee->dev;
8190
8191                 /* Point raw at the libipw_stats */
8192                 skb_reset_mac_header(skb);
8193
8194                 skb->pkt_type = PACKET_OTHERHOST;
8195                 skb->protocol = cpu_to_be16(ETH_P_80211_STATS);
8196                 memset(skb->cb, 0, sizeof(rxb->skb->cb));
8197                 netif_rx(skb);
8198                 rxb->skb = NULL;
8199         }
8200 }
8201
8202 /*
8203  * Main entry function for receiving a packet with 80211 headers.  This
8204  * should be called when ever the FW has notified us that there is a new
8205  * skb in the receive queue.
8206  */
8207 static void ipw_rx(struct ipw_priv *priv)
8208 {
8209         struct ipw_rx_mem_buffer *rxb;
8210         struct ipw_rx_packet *pkt;
8211         struct libipw_hdr_4addr *header;
8212         u32 r, i;
8213         u8 network_packet;
8214         u8 fill_rx = 0;
8215
8216         r = ipw_read32(priv, IPW_RX_READ_INDEX);
8217         ipw_read32(priv, IPW_RX_WRITE_INDEX);
8218         i = priv->rxq->read;
8219
8220         if (ipw_rx_queue_space (priv->rxq) > (RX_QUEUE_SIZE / 2))
8221                 fill_rx = 1;
8222
8223         while (i != r) {
8224                 rxb = priv->rxq->queue[i];
8225                 if (unlikely(rxb == NULL)) {
8226                         printk(KERN_CRIT "Queue not allocated!\n");
8227                         break;
8228                 }
8229                 priv->rxq->queue[i] = NULL;
8230
8231                 dma_sync_single_for_cpu(&priv->pci_dev->dev, rxb->dma_addr,
8232                                         IPW_RX_BUF_SIZE, DMA_FROM_DEVICE);
8233
8234                 pkt = (struct ipw_rx_packet *)rxb->skb->data;
8235                 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
8236                              pkt->header.message_type,
8237                              pkt->header.rx_seq_num, pkt->header.control_bits);
8238
8239                 switch (pkt->header.message_type) {
8240                 case RX_FRAME_TYPE:     /* 802.11 frame */  {
8241                                 struct libipw_rx_stats stats = {
8242                                         .rssi = pkt->u.frame.rssi_dbm -
8243                                             IPW_RSSI_TO_DBM,
8244                                         .signal =
8245                                             pkt->u.frame.rssi_dbm -
8246                                             IPW_RSSI_TO_DBM + 0x100,
8247                                         .noise =
8248                                             le16_to_cpu(pkt->u.frame.noise),
8249                                         .rate = pkt->u.frame.rate,
8250                                         .mac_time = jiffies,
8251                                         .received_channel =
8252                                             pkt->u.frame.received_channel,
8253                                         .freq =
8254                                             (pkt->u.frame.
8255                                              control & (1 << 0)) ?
8256                                             LIBIPW_24GHZ_BAND :
8257                                             LIBIPW_52GHZ_BAND,
8258                                         .len = le16_to_cpu(pkt->u.frame.length),
8259                                 };
8260
8261                                 if (stats.rssi != 0)
8262                                         stats.mask |= LIBIPW_STATMASK_RSSI;
8263                                 if (stats.signal != 0)
8264                                         stats.mask |= LIBIPW_STATMASK_SIGNAL;
8265                                 if (stats.noise != 0)
8266                                         stats.mask |= LIBIPW_STATMASK_NOISE;
8267                                 if (stats.rate != 0)
8268                                         stats.mask |= LIBIPW_STATMASK_RATE;
8269
8270                                 priv->rx_packets++;
8271
8272 #ifdef CONFIG_IPW2200_PROMISCUOUS
8273         if (priv->prom_net_dev && netif_running(priv->prom_net_dev))
8274                 ipw_handle_promiscuous_rx(priv, rxb, &stats);
8275 #endif
8276
8277 #ifdef CONFIG_IPW2200_MONITOR
8278                                 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8279 #ifdef CONFIG_IPW2200_RADIOTAP
8280
8281                 ipw_handle_data_packet_monitor(priv,
8282                                                rxb,
8283                                                &stats);
8284 #else
8285                 ipw_handle_data_packet(priv, rxb,
8286                                        &stats);
8287 #endif
8288                                         break;
8289                                 }
8290 #endif
8291
8292                                 header =
8293                                     (struct libipw_hdr_4addr *)(rxb->skb->
8294                                                                    data +
8295                                                                    IPW_RX_FRAME_SIZE);
8296                                 /* TODO: Check Ad-Hoc dest/source and make sure
8297                                  * that we are actually parsing these packets
8298                                  * correctly -- we should probably use the
8299                                  * frame control of the packet and disregard
8300                                  * the current iw_mode */
8301
8302                                 network_packet =
8303                                     is_network_packet(priv, header);
8304                                 if (network_packet && priv->assoc_network) {
8305                                         priv->assoc_network->stats.rssi =
8306                                             stats.rssi;
8307                                         priv->exp_avg_rssi =
8308                                             exponential_average(priv->exp_avg_rssi,
8309                                             stats.rssi, DEPTH_RSSI);
8310                                 }
8311
8312                                 IPW_DEBUG_RX("Frame: len=%u\n",
8313                                              le16_to_cpu(pkt->u.frame.length));
8314
8315                                 if (le16_to_cpu(pkt->u.frame.length) <
8316                                     libipw_get_hdrlen(le16_to_cpu(
8317                                                     header->frame_ctl))) {
8318                                         IPW_DEBUG_DROP
8319                                             ("Received packet is too small. "
8320                                              "Dropping.\n");
8321                                         priv->net_dev->stats.rx_errors++;
8322                                         priv->wstats.discard.misc++;
8323                                         break;
8324                                 }
8325
8326                                 switch (WLAN_FC_GET_TYPE
8327                                         (le16_to_cpu(header->frame_ctl))) {
8328
8329                                 case IEEE80211_FTYPE_MGMT:
8330                                         ipw_handle_mgmt_packet(priv, rxb,
8331                                                                &stats);
8332                                         break;
8333
8334                                 case IEEE80211_FTYPE_CTL:
8335                                         break;
8336
8337                                 case IEEE80211_FTYPE_DATA:
8338                                         if (unlikely(!network_packet ||
8339                                                      is_duplicate_packet(priv,
8340                                                                          header)))
8341                                         {
8342                                                 IPW_DEBUG_DROP("Dropping: "
8343                                                                "%pM, "
8344                                                                "%pM, "
8345                                                                "%pM\n",
8346                                                                header->addr1,
8347                                                                header->addr2,
8348                                                                header->addr3);
8349                                                 break;
8350                                         }
8351
8352                                         ipw_handle_data_packet(priv, rxb,
8353                                                                &stats);
8354
8355                                         break;
8356                                 }
8357                                 break;
8358                         }
8359
8360                 case RX_HOST_NOTIFICATION_TYPE:{
8361                                 IPW_DEBUG_RX
8362                                     ("Notification: subtype=%02X flags=%02X size=%d\n",
8363                                      pkt->u.notification.subtype,
8364                                      pkt->u.notification.flags,
8365                                      le16_to_cpu(pkt->u.notification.size));
8366                                 ipw_rx_notification(priv, &pkt->u.notification);
8367                                 break;
8368                         }
8369
8370                 default:
8371                         IPW_DEBUG_RX("Bad Rx packet of type %d\n",
8372                                      pkt->header.message_type);
8373                         break;
8374                 }
8375
8376                 /* For now we just don't re-use anything.  We can tweak this
8377                  * later to try and re-use notification packets and SKBs that
8378                  * fail to Rx correctly */
8379                 if (rxb->skb != NULL) {
8380                         dev_kfree_skb_any(rxb->skb);
8381                         rxb->skb = NULL;
8382                 }
8383
8384                 dma_unmap_single(&priv->pci_dev->dev, rxb->dma_addr,
8385                                  IPW_RX_BUF_SIZE, DMA_FROM_DEVICE);
8386                 list_add_tail(&rxb->list, &priv->rxq->rx_used);
8387
8388                 i = (i + 1) % RX_QUEUE_SIZE;
8389
8390                 /* If there are a lot of unsued frames, restock the Rx queue
8391                  * so the ucode won't assert */
8392                 if (fill_rx) {
8393                         priv->rxq->read = i;
8394                         ipw_rx_queue_replenish(priv);
8395                 }
8396         }
8397
8398         /* Backtrack one entry */
8399         priv->rxq->read = i;
8400         ipw_rx_queue_restock(priv);
8401 }
8402
8403 #define DEFAULT_RTS_THRESHOLD     2304U
8404 #define MIN_RTS_THRESHOLD         1U
8405 #define MAX_RTS_THRESHOLD         2304U
8406 #define DEFAULT_BEACON_INTERVAL   100U
8407 #define DEFAULT_SHORT_RETRY_LIMIT 7U
8408 #define DEFAULT_LONG_RETRY_LIMIT  4U
8409
8410 /*
8411  * ipw_sw_reset
8412  * @option: options to control different reset behaviour
8413  *          0 = reset everything except the 'disable' module_param
8414  *          1 = reset everything and print out driver info (for probe only)
8415  *          2 = reset everything
8416  */
8417 static int ipw_sw_reset(struct ipw_priv *priv, int option)
8418 {
8419         int band, modulation;
8420         int old_mode = priv->ieee->iw_mode;
8421
8422         /* Initialize module parameter values here */
8423         priv->config = 0;
8424
8425         /* We default to disabling the LED code as right now it causes
8426          * too many systems to lock up... */
8427         if (!led_support)
8428                 priv->config |= CFG_NO_LED;
8429
8430         if (associate)
8431                 priv->config |= CFG_ASSOCIATE;
8432         else
8433                 IPW_DEBUG_INFO("Auto associate disabled.\n");
8434
8435         if (auto_create)
8436                 priv->config |= CFG_ADHOC_CREATE;
8437         else
8438                 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
8439
8440         priv->config &= ~CFG_STATIC_ESSID;
8441         priv->essid_len = 0;
8442         memset(priv->essid, 0, IW_ESSID_MAX_SIZE);
8443
8444         if (disable && option) {
8445                 priv->status |= STATUS_RF_KILL_SW;
8446                 IPW_DEBUG_INFO("Radio disabled.\n");
8447         }
8448
8449         if (default_channel != 0) {
8450                 priv->config |= CFG_STATIC_CHANNEL;
8451                 priv->channel = default_channel;
8452                 IPW_DEBUG_INFO("Bind to static channel %d\n", default_channel);
8453                 /* TODO: Validate that provided channel is in range */
8454         }
8455 #ifdef CONFIG_IPW2200_QOS
8456         ipw_qos_init(priv, qos_enable, qos_burst_enable,
8457                      burst_duration_CCK, burst_duration_OFDM);
8458 #endif                          /* CONFIG_IPW2200_QOS */
8459
8460         switch (network_mode) {
8461         case 1:
8462                 priv->ieee->iw_mode = IW_MODE_ADHOC;
8463                 priv->net_dev->type = ARPHRD_ETHER;
8464
8465                 break;
8466 #ifdef CONFIG_IPW2200_MONITOR
8467         case 2:
8468                 priv->ieee->iw_mode = IW_MODE_MONITOR;
8469 #ifdef CONFIG_IPW2200_RADIOTAP
8470                 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8471 #else
8472                 priv->net_dev->type = ARPHRD_IEEE80211;
8473 #endif
8474                 break;
8475 #endif
8476         default:
8477         case 0:
8478                 priv->net_dev->type = ARPHRD_ETHER;
8479                 priv->ieee->iw_mode = IW_MODE_INFRA;
8480                 break;
8481         }
8482
8483         if (hwcrypto) {
8484                 priv->ieee->host_encrypt = 0;
8485                 priv->ieee->host_encrypt_msdu = 0;
8486                 priv->ieee->host_decrypt = 0;
8487                 priv->ieee->host_mc_decrypt = 0;
8488         }
8489         IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
8490
8491         /* IPW2200/2915 is abled to do hardware fragmentation. */
8492         priv->ieee->host_open_frag = 0;
8493
8494         if ((priv->pci_dev->device == 0x4223) ||
8495             (priv->pci_dev->device == 0x4224)) {
8496                 if (option == 1)
8497                         printk(KERN_INFO DRV_NAME
8498                                ": Detected Intel PRO/Wireless 2915ABG Network "
8499                                "Connection\n");
8500                 priv->ieee->abg_true = 1;
8501                 band = LIBIPW_52GHZ_BAND | LIBIPW_24GHZ_BAND;
8502                 modulation = LIBIPW_OFDM_MODULATION |
8503                     LIBIPW_CCK_MODULATION;
8504                 priv->adapter = IPW_2915ABG;
8505                 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
8506         } else {
8507                 if (option == 1)
8508                         printk(KERN_INFO DRV_NAME
8509                                ": Detected Intel PRO/Wireless 2200BG Network "
8510                                "Connection\n");
8511
8512                 priv->ieee->abg_true = 0;
8513                 band = LIBIPW_24GHZ_BAND;
8514                 modulation = LIBIPW_OFDM_MODULATION |
8515                     LIBIPW_CCK_MODULATION;
8516                 priv->adapter = IPW_2200BG;
8517                 priv->ieee->mode = IEEE_G | IEEE_B;
8518         }
8519
8520         priv->ieee->freq_band = band;
8521         priv->ieee->modulation = modulation;
8522
8523         priv->rates_mask = LIBIPW_DEFAULT_RATES_MASK;
8524
8525         priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8526         priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
8527
8528         priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8529         priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8530         priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
8531
8532         /* If power management is turned on, default to AC mode */
8533         priv->power_mode = IPW_POWER_AC;
8534         priv->tx_power = IPW_TX_POWER_DEFAULT;
8535
8536         return old_mode == priv->ieee->iw_mode;
8537 }
8538
8539 /*
8540  * This file defines the Wireless Extension handlers.  It does not
8541  * define any methods of hardware manipulation and relies on the
8542  * functions defined in ipw_main to provide the HW interaction.
8543  *
8544  * The exception to this is the use of the ipw_get_ordinal()
8545  * function used to poll the hardware vs. making unnecessary calls.
8546  *
8547  */
8548
8549 static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8550 {
8551         if (channel == 0) {
8552                 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8553                 priv->config &= ~CFG_STATIC_CHANNEL;
8554                 IPW_DEBUG_ASSOC("Attempting to associate with new "
8555                                 "parameters.\n");
8556                 ipw_associate(priv);
8557                 return 0;
8558         }
8559
8560         priv->config |= CFG_STATIC_CHANNEL;
8561
8562         if (priv->channel == channel) {
8563                 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8564                                channel);
8565                 return 0;
8566         }
8567
8568         IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8569         priv->channel = channel;
8570
8571 #ifdef CONFIG_IPW2200_MONITOR
8572         if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8573                 int i;
8574                 if (priv->status & STATUS_SCANNING) {
8575                         IPW_DEBUG_SCAN("Scan abort triggered due to "
8576                                        "channel change.\n");
8577                         ipw_abort_scan(priv);
8578                 }
8579
8580                 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8581                         udelay(10);
8582
8583                 if (priv->status & STATUS_SCANNING)
8584                         IPW_DEBUG_SCAN("Still scanning...\n");
8585                 else
8586                         IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8587                                        1000 - i);
8588
8589                 return 0;
8590         }
8591 #endif                          /* CONFIG_IPW2200_MONITOR */
8592
8593         /* Network configuration changed -- force [re]association */
8594         IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8595         if (!ipw_disassociate(priv))
8596                 ipw_associate(priv);
8597
8598         return 0;
8599 }
8600
8601 static int ipw_wx_set_freq(struct net_device *dev,
8602                            struct iw_request_info *info,
8603                            union iwreq_data *wrqu, char *extra)
8604 {
8605         struct ipw_priv *priv = libipw_priv(dev);
8606         const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
8607         struct iw_freq *fwrq = &wrqu->freq;
8608         int ret = 0, i;
8609         u8 channel, flags;
8610         int band;
8611
8612         if (fwrq->m == 0) {
8613                 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
8614                 mutex_lock(&priv->mutex);
8615                 ret = ipw_set_channel(priv, 0);
8616                 mutex_unlock(&priv->mutex);
8617                 return ret;
8618         }
8619         /* if setting by freq convert to channel */
8620         if (fwrq->e == 1) {
8621                 channel = libipw_freq_to_channel(priv->ieee, fwrq->m);
8622                 if (channel == 0)
8623                         return -EINVAL;
8624         } else
8625                 channel = fwrq->m;
8626
8627         if (!(band = libipw_is_valid_channel(priv->ieee, channel)))
8628                 return -EINVAL;
8629
8630         if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
8631                 i = libipw_channel_to_index(priv->ieee, channel);
8632                 if (i == -1)
8633                         return -EINVAL;
8634
8635                 flags = (band == LIBIPW_24GHZ_BAND) ?
8636                     geo->bg[i].flags : geo->a[i].flags;
8637                 if (flags & LIBIPW_CH_PASSIVE_ONLY) {
8638                         IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8639                         return -EINVAL;
8640                 }
8641         }
8642
8643         IPW_DEBUG_WX("SET Freq/Channel -> %d\n", fwrq->m);
8644         mutex_lock(&priv->mutex);
8645         ret = ipw_set_channel(priv, channel);
8646         mutex_unlock(&priv->mutex);
8647         return ret;
8648 }
8649
8650 static int ipw_wx_get_freq(struct net_device *dev,
8651                            struct iw_request_info *info,
8652                            union iwreq_data *wrqu, char *extra)
8653 {
8654         struct ipw_priv *priv = libipw_priv(dev);
8655
8656         wrqu->freq.e = 0;
8657
8658         /* If we are associated, trying to associate, or have a statically
8659          * configured CHANNEL then return that; otherwise return ANY */
8660         mutex_lock(&priv->mutex);
8661         if (priv->config & CFG_STATIC_CHANNEL ||
8662             priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED)) {
8663                 int i;
8664
8665                 i = libipw_channel_to_index(priv->ieee, priv->channel);
8666                 BUG_ON(i == -1);
8667                 wrqu->freq.e = 1;
8668
8669                 switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
8670                 case LIBIPW_52GHZ_BAND:
8671                         wrqu->freq.m = priv->ieee->geo.a[i].freq * 100000;
8672                         break;
8673
8674                 case LIBIPW_24GHZ_BAND:
8675                         wrqu->freq.m = priv->ieee->geo.bg[i].freq * 100000;
8676                         break;
8677
8678                 default:
8679                         BUG();
8680                 }
8681         } else
8682                 wrqu->freq.m = 0;
8683
8684         mutex_unlock(&priv->mutex);
8685         IPW_DEBUG_WX("GET Freq/Channel -> %d\n", priv->channel);
8686         return 0;
8687 }
8688
8689 static int ipw_wx_set_mode(struct net_device *dev,
8690                            struct iw_request_info *info,
8691                            union iwreq_data *wrqu, char *extra)
8692 {
8693         struct ipw_priv *priv = libipw_priv(dev);
8694         int err = 0;
8695
8696         IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8697
8698         switch (wrqu->mode) {
8699 #ifdef CONFIG_IPW2200_MONITOR
8700         case IW_MODE_MONITOR:
8701 #endif
8702         case IW_MODE_ADHOC:
8703         case IW_MODE_INFRA:
8704                 break;
8705         case IW_MODE_AUTO:
8706                 wrqu->mode = IW_MODE_INFRA;
8707                 break;
8708         default:
8709                 return -EINVAL;
8710         }
8711         if (wrqu->mode == priv->ieee->iw_mode)
8712                 return 0;
8713
8714         mutex_lock(&priv->mutex);
8715
8716         ipw_sw_reset(priv, 0);
8717
8718 #ifdef CONFIG_IPW2200_MONITOR
8719         if (priv->ieee->iw_mode == IW_MODE_MONITOR)
8720                 priv->net_dev->type = ARPHRD_ETHER;
8721
8722         if (wrqu->mode == IW_MODE_MONITOR)
8723 #ifdef CONFIG_IPW2200_RADIOTAP
8724                 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8725 #else
8726                 priv->net_dev->type = ARPHRD_IEEE80211;
8727 #endif
8728 #endif                          /* CONFIG_IPW2200_MONITOR */
8729
8730         /* Free the existing firmware and reset the fw_loaded
8731          * flag so ipw_load() will bring in the new firmware */
8732         free_firmware();
8733
8734         priv->ieee->iw_mode = wrqu->mode;
8735
8736         schedule_work(&priv->adapter_restart);
8737         mutex_unlock(&priv->mutex);
8738         return err;
8739 }
8740
8741 static int ipw_wx_get_mode(struct net_device *dev,
8742                            struct iw_request_info *info,
8743                            union iwreq_data *wrqu, char *extra)
8744 {
8745         struct ipw_priv *priv = libipw_priv(dev);
8746         mutex_lock(&priv->mutex);
8747         wrqu->mode = priv->ieee->iw_mode;
8748         IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
8749         mutex_unlock(&priv->mutex);
8750         return 0;
8751 }
8752
8753 /* Values are in microsecond */
8754 static const s32 timeout_duration[] = {
8755         350000,
8756         250000,
8757         75000,
8758         37000,
8759         25000,
8760 };
8761
8762 static const s32 period_duration[] = {
8763         400000,
8764         700000,
8765         1000000,
8766         1000000,
8767         1000000
8768 };
8769
8770 static int ipw_wx_get_range(struct net_device *dev,
8771                             struct iw_request_info *info,
8772                             union iwreq_data *wrqu, char *extra)
8773 {
8774         struct ipw_priv *priv = libipw_priv(dev);
8775         struct iw_range *range = (struct iw_range *)extra;
8776         const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
8777         int i = 0, j;
8778
8779         wrqu->data.length = sizeof(*range);
8780         memset(range, 0, sizeof(*range));
8781
8782         /* 54Mbs == ~27 Mb/s real (802.11g) */
8783         range->throughput = 27 * 1000 * 1000;
8784
8785         range->max_qual.qual = 100;
8786         /* TODO: Find real max RSSI and stick here */
8787         range->max_qual.level = 0;
8788         range->max_qual.noise = 0;
8789         range->max_qual.updated = 7;    /* Updated all three */
8790
8791         range->avg_qual.qual = 70;
8792         /* TODO: Find real 'good' to 'bad' threshold value for RSSI */
8793         range->avg_qual.level = 0;      /* FIXME to real average level */
8794         range->avg_qual.noise = 0;
8795         range->avg_qual.updated = 7;    /* Updated all three */
8796         mutex_lock(&priv->mutex);
8797         range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
8798
8799         for (i = 0; i < range->num_bitrates; i++)
8800                 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
8801                     500000;
8802
8803         range->max_rts = DEFAULT_RTS_THRESHOLD;
8804         range->min_frag = MIN_FRAG_THRESHOLD;
8805         range->max_frag = MAX_FRAG_THRESHOLD;
8806
8807         range->encoding_size[0] = 5;
8808         range->encoding_size[1] = 13;
8809         range->num_encoding_sizes = 2;
8810         range->max_encoding_tokens = WEP_KEYS;
8811
8812         /* Set the Wireless Extension versions */
8813         range->we_version_compiled = WIRELESS_EXT;
8814         range->we_version_source = 18;
8815
8816         i = 0;
8817         if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
8818                 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES; j++) {
8819                         if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
8820                             (geo->bg[j].flags & LIBIPW_CH_PASSIVE_ONLY))
8821                                 continue;
8822
8823                         range->freq[i].i = geo->bg[j].channel;
8824                         range->freq[i].m = geo->bg[j].freq * 100000;
8825                         range->freq[i].e = 1;
8826                         i++;
8827                 }
8828         }
8829
8830         if (priv->ieee->mode & IEEE_A) {
8831                 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES; j++) {
8832                         if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
8833                             (geo->a[j].flags & LIBIPW_CH_PASSIVE_ONLY))
8834                                 continue;
8835
8836                         range->freq[i].i = geo->a[j].channel;
8837                         range->freq[i].m = geo->a[j].freq * 100000;
8838                         range->freq[i].e = 1;
8839                         i++;
8840                 }
8841         }
8842
8843         range->num_channels = i;
8844         range->num_frequency = i;
8845
8846         mutex_unlock(&priv->mutex);
8847
8848         /* Event capability (kernel + driver) */
8849         range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
8850                                 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
8851                                 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
8852                                 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
8853         range->event_capa[1] = IW_EVENT_CAPA_K_1;
8854
8855         range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
8856                 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
8857
8858         range->scan_capa = IW_SCAN_CAPA_ESSID | IW_SCAN_CAPA_TYPE;
8859
8860         IPW_DEBUG_WX("GET Range\n");
8861         return 0;
8862 }
8863
8864 static int ipw_wx_set_wap(struct net_device *dev,
8865                           struct iw_request_info *info,
8866                           union iwreq_data *wrqu, char *extra)
8867 {
8868         struct ipw_priv *priv = libipw_priv(dev);
8869
8870         if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
8871                 return -EINVAL;
8872         mutex_lock(&priv->mutex);
8873         if (is_broadcast_ether_addr(wrqu->ap_addr.sa_data) ||
8874             is_zero_ether_addr(wrqu->ap_addr.sa_data)) {
8875                 /* we disable mandatory BSSID association */
8876                 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
8877                 priv->config &= ~CFG_STATIC_BSSID;
8878                 IPW_DEBUG_ASSOC("Attempting to associate with new "
8879                                 "parameters.\n");
8880                 ipw_associate(priv);
8881                 mutex_unlock(&priv->mutex);
8882                 return 0;
8883         }
8884
8885         priv->config |= CFG_STATIC_BSSID;
8886         if (ether_addr_equal(priv->bssid, wrqu->ap_addr.sa_data)) {
8887                 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
8888                 mutex_unlock(&priv->mutex);
8889                 return 0;
8890         }
8891
8892         IPW_DEBUG_WX("Setting mandatory BSSID to %pM\n",
8893                      wrqu->ap_addr.sa_data);
8894
8895         memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
8896
8897         /* Network configuration changed -- force [re]association */
8898         IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
8899         if (!ipw_disassociate(priv))
8900                 ipw_associate(priv);
8901
8902         mutex_unlock(&priv->mutex);
8903         return 0;
8904 }
8905
8906 static int ipw_wx_get_wap(struct net_device *dev,
8907                           struct iw_request_info *info,
8908                           union iwreq_data *wrqu, char *extra)
8909 {
8910         struct ipw_priv *priv = libipw_priv(dev);
8911
8912         /* If we are associated, trying to associate, or have a statically
8913          * configured BSSID then return that; otherwise return ANY */
8914         mutex_lock(&priv->mutex);
8915         if (priv->config & CFG_STATIC_BSSID ||
8916             priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8917                 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
8918                 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
8919         } else
8920                 eth_zero_addr(wrqu->ap_addr.sa_data);
8921
8922         IPW_DEBUG_WX("Getting WAP BSSID: %pM\n",
8923                      wrqu->ap_addr.sa_data);
8924         mutex_unlock(&priv->mutex);
8925         return 0;
8926 }
8927
8928 static int ipw_wx_set_essid(struct net_device *dev,
8929                             struct iw_request_info *info,
8930                             union iwreq_data *wrqu, char *extra)
8931 {
8932         struct ipw_priv *priv = libipw_priv(dev);
8933         int length;
8934
8935         mutex_lock(&priv->mutex);
8936
8937         if (!wrqu->essid.flags)
8938         {
8939                 IPW_DEBUG_WX("Setting ESSID to ANY\n");
8940                 ipw_disassociate(priv);
8941                 priv->config &= ~CFG_STATIC_ESSID;
8942                 ipw_associate(priv);
8943                 mutex_unlock(&priv->mutex);
8944                 return 0;
8945         }
8946
8947         length = min((int)wrqu->essid.length, IW_ESSID_MAX_SIZE);
8948
8949         priv->config |= CFG_STATIC_ESSID;
8950
8951         if (priv->essid_len == length && !memcmp(priv->essid, extra, length)
8952             && (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING))) {
8953                 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
8954                 mutex_unlock(&priv->mutex);
8955                 return 0;
8956         }
8957
8958         IPW_DEBUG_WX("Setting ESSID: '%*pE' (%d)\n", length, extra, length);
8959
8960         priv->essid_len = length;
8961         memcpy(priv->essid, extra, priv->essid_len);
8962
8963         /* Network configuration changed -- force [re]association */
8964         IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
8965         if (!ipw_disassociate(priv))
8966                 ipw_associate(priv);
8967
8968         mutex_unlock(&priv->mutex);
8969         return 0;
8970 }
8971
8972 static int ipw_wx_get_essid(struct net_device *dev,
8973                             struct iw_request_info *info,
8974                             union iwreq_data *wrqu, char *extra)
8975 {
8976         struct ipw_priv *priv = libipw_priv(dev);
8977
8978         /* If we are associated, trying to associate, or have a statically
8979          * configured ESSID then return that; otherwise return ANY */
8980         mutex_lock(&priv->mutex);
8981         if (priv->config & CFG_STATIC_ESSID ||
8982             priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8983                 IPW_DEBUG_WX("Getting essid: '%*pE'\n",
8984                              priv->essid_len, priv->essid);
8985                 memcpy(extra, priv->essid, priv->essid_len);
8986                 wrqu->essid.length = priv->essid_len;
8987                 wrqu->essid.flags = 1;  /* active */
8988         } else {
8989                 IPW_DEBUG_WX("Getting essid: ANY\n");
8990                 wrqu->essid.length = 0;
8991                 wrqu->essid.flags = 0;  /* active */
8992         }
8993         mutex_unlock(&priv->mutex);
8994         return 0;
8995 }
8996
8997 static int ipw_wx_set_nick(struct net_device *dev,
8998                            struct iw_request_info *info,
8999                            union iwreq_data *wrqu, char *extra)
9000 {
9001         struct ipw_priv *priv = libipw_priv(dev);
9002
9003         IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
9004         if (wrqu->data.length > IW_ESSID_MAX_SIZE)
9005                 return -E2BIG;
9006         mutex_lock(&priv->mutex);
9007         wrqu->data.length = min_t(size_t, wrqu->data.length, sizeof(priv->nick));
9008         memset(priv->nick, 0, sizeof(priv->nick));
9009         memcpy(priv->nick, extra, wrqu->data.length);
9010         IPW_DEBUG_TRACE("<<\n");
9011         mutex_unlock(&priv->mutex);
9012         return 0;
9013
9014 }
9015
9016 static int ipw_wx_get_nick(struct net_device *dev,
9017                            struct iw_request_info *info,
9018                            union iwreq_data *wrqu, char *extra)
9019 {
9020         struct ipw_priv *priv = libipw_priv(dev);
9021         IPW_DEBUG_WX("Getting nick\n");
9022         mutex_lock(&priv->mutex);
9023         wrqu->data.length = strlen(priv->nick);
9024         memcpy(extra, priv->nick, wrqu->data.length);
9025         wrqu->data.flags = 1;   /* active */
9026         mutex_unlock(&priv->mutex);
9027         return 0;
9028 }
9029
9030 static int ipw_wx_set_sens(struct net_device *dev,
9031                             struct iw_request_info *info,
9032                             union iwreq_data *wrqu, char *extra)
9033 {
9034         struct ipw_priv *priv = libipw_priv(dev);
9035         int err = 0;
9036
9037         IPW_DEBUG_WX("Setting roaming threshold to %d\n", wrqu->sens.value);
9038         IPW_DEBUG_WX("Setting disassociate threshold to %d\n", 3*wrqu->sens.value);
9039         mutex_lock(&priv->mutex);
9040
9041         if (wrqu->sens.fixed == 0)
9042         {
9043                 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
9044                 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
9045                 goto out;
9046         }
9047         if ((wrqu->sens.value > IPW_MB_ROAMING_THRESHOLD_MAX) ||
9048             (wrqu->sens.value < IPW_MB_ROAMING_THRESHOLD_MIN)) {
9049                 err = -EINVAL;
9050                 goto out;
9051         }
9052
9053         priv->roaming_threshold = wrqu->sens.value;
9054         priv->disassociate_threshold = 3*wrqu->sens.value;
9055       out:
9056         mutex_unlock(&priv->mutex);
9057         return err;
9058 }
9059
9060 static int ipw_wx_get_sens(struct net_device *dev,
9061                             struct iw_request_info *info,
9062                             union iwreq_data *wrqu, char *extra)
9063 {
9064         struct ipw_priv *priv = libipw_priv(dev);
9065         mutex_lock(&priv->mutex);
9066         wrqu->sens.fixed = 1;
9067         wrqu->sens.value = priv->roaming_threshold;
9068         mutex_unlock(&priv->mutex);
9069
9070         IPW_DEBUG_WX("GET roaming threshold -> %s %d\n",
9071                      wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
9072
9073         return 0;
9074 }
9075
9076 static int ipw_wx_set_rate(struct net_device *dev,
9077                            struct iw_request_info *info,
9078                            union iwreq_data *wrqu, char *extra)
9079 {
9080         /* TODO: We should use semaphores or locks for access to priv */
9081         struct ipw_priv *priv = libipw_priv(dev);
9082         u32 target_rate = wrqu->bitrate.value;
9083         u32 fixed, mask;
9084
9085         /* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
9086         /* value = X, fixed = 1 means only rate X */
9087         /* value = X, fixed = 0 means all rates lower equal X */
9088
9089         if (target_rate == -1) {
9090                 fixed = 0;
9091                 mask = LIBIPW_DEFAULT_RATES_MASK;
9092                 /* Now we should reassociate */
9093                 goto apply;
9094         }
9095
9096         mask = 0;
9097         fixed = wrqu->bitrate.fixed;
9098
9099         if (target_rate == 1000000 || !fixed)
9100                 mask |= LIBIPW_CCK_RATE_1MB_MASK;
9101         if (target_rate == 1000000)
9102                 goto apply;
9103
9104         if (target_rate == 2000000 || !fixed)
9105                 mask |= LIBIPW_CCK_RATE_2MB_MASK;
9106         if (target_rate == 2000000)
9107                 goto apply;
9108
9109         if (target_rate == 5500000 || !fixed)
9110                 mask |= LIBIPW_CCK_RATE_5MB_MASK;
9111         if (target_rate == 5500000)
9112                 goto apply;
9113
9114         if (target_rate == 6000000 || !fixed)
9115                 mask |= LIBIPW_OFDM_RATE_6MB_MASK;
9116         if (target_rate == 6000000)
9117                 goto apply;
9118
9119         if (target_rate == 9000000 || !fixed)
9120                 mask |= LIBIPW_OFDM_RATE_9MB_MASK;
9121         if (target_rate == 9000000)
9122                 goto apply;
9123
9124         if (target_rate == 11000000 || !fixed)
9125                 mask |= LIBIPW_CCK_RATE_11MB_MASK;
9126         if (target_rate == 11000000)
9127                 goto apply;
9128
9129         if (target_rate == 12000000 || !fixed)
9130                 mask |= LIBIPW_OFDM_RATE_12MB_MASK;
9131         if (target_rate == 12000000)
9132                 goto apply;
9133
9134         if (target_rate == 18000000 || !fixed)
9135                 mask |= LIBIPW_OFDM_RATE_18MB_MASK;
9136         if (target_rate == 18000000)
9137                 goto apply;
9138
9139         if (target_rate == 24000000 || !fixed)
9140                 mask |= LIBIPW_OFDM_RATE_24MB_MASK;
9141         if (target_rate == 24000000)
9142                 goto apply;
9143
9144         if (target_rate == 36000000 || !fixed)
9145                 mask |= LIBIPW_OFDM_RATE_36MB_MASK;
9146         if (target_rate == 36000000)
9147                 goto apply;
9148
9149         if (target_rate == 48000000 || !fixed)
9150                 mask |= LIBIPW_OFDM_RATE_48MB_MASK;
9151         if (target_rate == 48000000)
9152                 goto apply;
9153
9154         if (target_rate == 54000000 || !fixed)
9155                 mask |= LIBIPW_OFDM_RATE_54MB_MASK;
9156         if (target_rate == 54000000)
9157                 goto apply;
9158
9159         IPW_DEBUG_WX("invalid rate specified, returning error\n");
9160         return -EINVAL;
9161
9162       apply:
9163         IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
9164                      mask, fixed ? "fixed" : "sub-rates");
9165         mutex_lock(&priv->mutex);
9166         if (mask == LIBIPW_DEFAULT_RATES_MASK) {
9167                 priv->config &= ~CFG_FIXED_RATE;
9168                 ipw_set_fixed_rate(priv, priv->ieee->mode);
9169         } else
9170                 priv->config |= CFG_FIXED_RATE;
9171
9172         if (priv->rates_mask == mask) {
9173                 IPW_DEBUG_WX("Mask set to current mask.\n");
9174                 mutex_unlock(&priv->mutex);
9175                 return 0;
9176         }
9177
9178         priv->rates_mask = mask;
9179
9180         /* Network configuration changed -- force [re]association */
9181         IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
9182         if (!ipw_disassociate(priv))
9183                 ipw_associate(priv);
9184
9185         mutex_unlock(&priv->mutex);
9186         return 0;
9187 }
9188
9189 static int ipw_wx_get_rate(struct net_device *dev,
9190                            struct iw_request_info *info,
9191                            union iwreq_data *wrqu, char *extra)
9192 {
9193         struct ipw_priv *priv = libipw_priv(dev);
9194         mutex_lock(&priv->mutex);
9195         wrqu->bitrate.value = priv->last_rate;
9196         wrqu->bitrate.fixed = (priv->config & CFG_FIXED_RATE) ? 1 : 0;
9197         mutex_unlock(&priv->mutex);
9198         IPW_DEBUG_WX("GET Rate -> %d\n", wrqu->bitrate.value);
9199         return 0;
9200 }
9201
9202 static int ipw_wx_set_rts(struct net_device *dev,
9203                           struct iw_request_info *info,
9204                           union iwreq_data *wrqu, char *extra)
9205 {
9206         struct ipw_priv *priv = libipw_priv(dev);
9207         mutex_lock(&priv->mutex);
9208         if (wrqu->rts.disabled || !wrqu->rts.fixed)
9209                 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
9210         else {
9211                 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
9212                     wrqu->rts.value > MAX_RTS_THRESHOLD) {
9213                         mutex_unlock(&priv->mutex);
9214                         return -EINVAL;
9215                 }
9216                 priv->rts_threshold = wrqu->rts.value;
9217         }
9218
9219         ipw_send_rts_threshold(priv, priv->rts_threshold);
9220         mutex_unlock(&priv->mutex);
9221         IPW_DEBUG_WX("SET RTS Threshold -> %d\n", priv->rts_threshold);
9222         return 0;
9223 }
9224
9225 static int ipw_wx_get_rts(struct net_device *dev,
9226                           struct iw_request_info *info,
9227                           union iwreq_data *wrqu, char *extra)
9228 {
9229         struct ipw_priv *priv = libipw_priv(dev);
9230         mutex_lock(&priv->mutex);
9231         wrqu->rts.value = priv->rts_threshold;
9232         wrqu->rts.fixed = 0;    /* no auto select */
9233         wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
9234         mutex_unlock(&priv->mutex);
9235         IPW_DEBUG_WX("GET RTS Threshold -> %d\n", wrqu->rts.value);
9236         return 0;
9237 }
9238
9239 static int ipw_wx_set_txpow(struct net_device *dev,
9240                             struct iw_request_info *info,
9241                             union iwreq_data *wrqu, char *extra)
9242 {
9243         struct ipw_priv *priv = libipw_priv(dev);
9244         int err = 0;
9245
9246         mutex_lock(&priv->mutex);
9247         if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
9248                 err = -EINPROGRESS;
9249                 goto out;
9250         }
9251
9252         if (!wrqu->power.fixed)
9253                 wrqu->power.value = IPW_TX_POWER_DEFAULT;
9254
9255         if (wrqu->power.flags != IW_TXPOW_DBM) {
9256                 err = -EINVAL;
9257                 goto out;
9258         }
9259
9260         if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
9261             (wrqu->power.value < IPW_TX_POWER_MIN)) {
9262                 err = -EINVAL;
9263                 goto out;
9264         }
9265
9266         priv->tx_power = wrqu->power.value;
9267         err = ipw_set_tx_power(priv);
9268       out:
9269         mutex_unlock(&priv->mutex);
9270         return err;
9271 }
9272
9273 static int ipw_wx_get_txpow(struct net_device *dev,
9274                             struct iw_request_info *info,
9275                             union iwreq_data *wrqu, char *extra)
9276 {
9277         struct ipw_priv *priv = libipw_priv(dev);
9278         mutex_lock(&priv->mutex);
9279         wrqu->power.value = priv->tx_power;
9280         wrqu->power.fixed = 1;
9281         wrqu->power.flags = IW_TXPOW_DBM;
9282         wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
9283         mutex_unlock(&priv->mutex);
9284
9285         IPW_DEBUG_WX("GET TX Power -> %s %d\n",
9286                      wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
9287
9288         return 0;
9289 }
9290
9291 static int ipw_wx_set_frag(struct net_device *dev,
9292                            struct iw_request_info *info,
9293                            union iwreq_data *wrqu, char *extra)
9294 {
9295         struct ipw_priv *priv = libipw_priv(dev);
9296         mutex_lock(&priv->mutex);
9297         if (wrqu->frag.disabled || !wrqu->frag.fixed)
9298                 priv->ieee->fts = DEFAULT_FTS;
9299         else {
9300                 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
9301                     wrqu->frag.value > MAX_FRAG_THRESHOLD) {
9302                         mutex_unlock(&priv->mutex);
9303                         return -EINVAL;
9304                 }
9305
9306                 priv->ieee->fts = wrqu->frag.value & ~0x1;
9307         }
9308
9309         ipw_send_frag_threshold(priv, wrqu->frag.value);
9310         mutex_unlock(&priv->mutex);
9311         IPW_DEBUG_WX("SET Frag Threshold -> %d\n", wrqu->frag.value);
9312         return 0;
9313 }
9314
9315 static int ipw_wx_get_frag(struct net_device *dev,
9316                            struct iw_request_info *info,
9317                            union iwreq_data *wrqu, char *extra)
9318 {
9319         struct ipw_priv *priv = libipw_priv(dev);
9320         mutex_lock(&priv->mutex);
9321         wrqu->frag.value = priv->ieee->fts;
9322         wrqu->frag.fixed = 0;   /* no auto select */
9323         wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
9324         mutex_unlock(&priv->mutex);
9325         IPW_DEBUG_WX("GET Frag Threshold -> %d\n", wrqu->frag.value);
9326
9327         return 0;
9328 }
9329
9330 static int ipw_wx_set_retry(struct net_device *dev,
9331                             struct iw_request_info *info,
9332                             union iwreq_data *wrqu, char *extra)
9333 {
9334         struct ipw_priv *priv = libipw_priv(dev);
9335
9336         if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
9337                 return -EINVAL;
9338
9339         if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
9340                 return 0;
9341
9342         if (wrqu->retry.value < 0 || wrqu->retry.value >= 255)
9343                 return -EINVAL;
9344
9345         mutex_lock(&priv->mutex);
9346         if (wrqu->retry.flags & IW_RETRY_SHORT)
9347                 priv->short_retry_limit = (u8) wrqu->retry.value;
9348         else if (wrqu->retry.flags & IW_RETRY_LONG)
9349                 priv->long_retry_limit = (u8) wrqu->retry.value;
9350         else {
9351                 priv->short_retry_limit = (u8) wrqu->retry.value;
9352                 priv->long_retry_limit = (u8) wrqu->retry.value;
9353         }
9354
9355         ipw_send_retry_limit(priv, priv->short_retry_limit,
9356                              priv->long_retry_limit);
9357         mutex_unlock(&priv->mutex);
9358         IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
9359                      priv->short_retry_limit, priv->long_retry_limit);
9360         return 0;
9361 }
9362
9363 static int ipw_wx_get_retry(struct net_device *dev,
9364                             struct iw_request_info *info,
9365                             union iwreq_data *wrqu, char *extra)
9366 {
9367         struct ipw_priv *priv = libipw_priv(dev);
9368
9369         mutex_lock(&priv->mutex);
9370         wrqu->retry.disabled = 0;
9371
9372         if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
9373                 mutex_unlock(&priv->mutex);
9374                 return -EINVAL;
9375         }
9376
9377         if (wrqu->retry.flags & IW_RETRY_LONG) {
9378                 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
9379                 wrqu->retry.value = priv->long_retry_limit;
9380         } else if (wrqu->retry.flags & IW_RETRY_SHORT) {
9381                 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_SHORT;
9382                 wrqu->retry.value = priv->short_retry_limit;
9383         } else {
9384                 wrqu->retry.flags = IW_RETRY_LIMIT;
9385                 wrqu->retry.value = priv->short_retry_limit;
9386         }
9387         mutex_unlock(&priv->mutex);
9388
9389         IPW_DEBUG_WX("GET retry -> %d\n", wrqu->retry.value);
9390
9391         return 0;
9392 }
9393
9394 static int ipw_wx_set_scan(struct net_device *dev,
9395                            struct iw_request_info *info,
9396                            union iwreq_data *wrqu, char *extra)
9397 {
9398         struct ipw_priv *priv = libipw_priv(dev);
9399         struct iw_scan_req *req = (struct iw_scan_req *)extra;
9400         struct delayed_work *work = NULL;
9401
9402         mutex_lock(&priv->mutex);
9403
9404         priv->user_requested_scan = 1;
9405
9406         if (wrqu->data.length == sizeof(struct iw_scan_req)) {
9407                 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
9408                         int len = min((int)req->essid_len,
9409                                       (int)sizeof(priv->direct_scan_ssid));
9410                         memcpy(priv->direct_scan_ssid, req->essid, len);
9411                         priv->direct_scan_ssid_len = len;
9412                         work = &priv->request_direct_scan;
9413                 } else if (req->scan_type == IW_SCAN_TYPE_PASSIVE) {
9414                         work = &priv->request_passive_scan;
9415                 }
9416         } else {
9417                 /* Normal active broadcast scan */
9418                 work = &priv->request_scan;
9419         }
9420
9421         mutex_unlock(&priv->mutex);
9422
9423         IPW_DEBUG_WX("Start scan\n");
9424
9425         schedule_delayed_work(work, 0);
9426
9427         return 0;
9428 }
9429
9430 static int ipw_wx_get_scan(struct net_device *dev,
9431                            struct iw_request_info *info,
9432                            union iwreq_data *wrqu, char *extra)
9433 {
9434         struct ipw_priv *priv = libipw_priv(dev);
9435         return libipw_wx_get_scan(priv->ieee, info, wrqu, extra);
9436 }
9437
9438 static int ipw_wx_set_encode(struct net_device *dev,
9439                              struct iw_request_info *info,
9440                              union iwreq_data *wrqu, char *key)
9441 {
9442         struct ipw_priv *priv = libipw_priv(dev);
9443         int ret;
9444         u32 cap = priv->capability;
9445
9446         mutex_lock(&priv->mutex);
9447         ret = libipw_wx_set_encode(priv->ieee, info, wrqu, key);
9448
9449         /* In IBSS mode, we need to notify the firmware to update
9450          * the beacon info after we changed the capability. */
9451         if (cap != priv->capability &&
9452             priv->ieee->iw_mode == IW_MODE_ADHOC &&
9453             priv->status & STATUS_ASSOCIATED)
9454                 ipw_disassociate(priv);
9455
9456         mutex_unlock(&priv->mutex);
9457         return ret;
9458 }
9459
9460 static int ipw_wx_get_encode(struct net_device *dev,
9461                              struct iw_request_info *info,
9462                              union iwreq_data *wrqu, char *key)
9463 {
9464         struct ipw_priv *priv = libipw_priv(dev);
9465         return libipw_wx_get_encode(priv->ieee, info, wrqu, key);
9466 }
9467
9468 static int ipw_wx_set_power(struct net_device *dev,
9469                             struct iw_request_info *info,
9470                             union iwreq_data *wrqu, char *extra)
9471 {
9472         struct ipw_priv *priv = libipw_priv(dev);
9473         int err;
9474         mutex_lock(&priv->mutex);
9475         if (wrqu->power.disabled) {
9476                 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9477                 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9478                 if (err) {
9479                         IPW_DEBUG_WX("failed setting power mode.\n");
9480                         mutex_unlock(&priv->mutex);
9481                         return err;
9482                 }
9483                 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
9484                 mutex_unlock(&priv->mutex);
9485                 return 0;
9486         }
9487
9488         switch (wrqu->power.flags & IW_POWER_MODE) {
9489         case IW_POWER_ON:       /* If not specified */
9490         case IW_POWER_MODE:     /* If set all mask */
9491         case IW_POWER_ALL_R:    /* If explicitly state all */
9492                 break;
9493         default:                /* Otherwise we don't support it */
9494                 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9495                              wrqu->power.flags);
9496                 mutex_unlock(&priv->mutex);
9497                 return -EOPNOTSUPP;
9498         }
9499
9500         /* If the user hasn't specified a power management mode yet, default
9501          * to BATTERY */
9502         if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
9503                 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
9504         else
9505                 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9506
9507         err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9508         if (err) {
9509                 IPW_DEBUG_WX("failed setting power mode.\n");
9510                 mutex_unlock(&priv->mutex);
9511                 return err;
9512         }
9513
9514         IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
9515         mutex_unlock(&priv->mutex);
9516         return 0;
9517 }
9518
9519 static int ipw_wx_get_power(struct net_device *dev,
9520                             struct iw_request_info *info,
9521                             union iwreq_data *wrqu, char *extra)
9522 {
9523         struct ipw_priv *priv = libipw_priv(dev);
9524         mutex_lock(&priv->mutex);
9525         if (!(priv->power_mode & IPW_POWER_ENABLED))
9526                 wrqu->power.disabled = 1;
9527         else
9528                 wrqu->power.disabled = 0;
9529
9530         mutex_unlock(&priv->mutex);
9531         IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
9532
9533         return 0;
9534 }
9535
9536 static int ipw_wx_set_powermode(struct net_device *dev,
9537                                 struct iw_request_info *info,
9538                                 union iwreq_data *wrqu, char *extra)
9539 {
9540         struct ipw_priv *priv = libipw_priv(dev);
9541         int mode = *(int *)extra;
9542         int err;
9543
9544         mutex_lock(&priv->mutex);
9545         if ((mode < 1) || (mode > IPW_POWER_LIMIT))
9546                 mode = IPW_POWER_AC;
9547
9548         if (IPW_POWER_LEVEL(priv->power_mode) != mode) {
9549                 err = ipw_send_power_mode(priv, mode);
9550                 if (err) {
9551                         IPW_DEBUG_WX("failed setting power mode.\n");
9552                         mutex_unlock(&priv->mutex);
9553                         return err;
9554                 }
9555                 priv->power_mode = IPW_POWER_ENABLED | mode;
9556         }
9557         mutex_unlock(&priv->mutex);
9558         return 0;
9559 }
9560
9561 #define MAX_WX_STRING 80
9562 static int ipw_wx_get_powermode(struct net_device *dev,
9563                                 struct iw_request_info *info,
9564                                 union iwreq_data *wrqu, char *extra)
9565 {
9566         struct ipw_priv *priv = libipw_priv(dev);
9567         int level = IPW_POWER_LEVEL(priv->power_mode);
9568         char *p = extra;
9569
9570         p += scnprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9571
9572         switch (level) {
9573         case IPW_POWER_AC:
9574                 p += scnprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9575                 break;
9576         case IPW_POWER_BATTERY:
9577                 p += scnprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9578                 break;
9579         default:
9580                 p += scnprintf(p, MAX_WX_STRING - (p - extra),
9581                               "(Timeout %dms, Period %dms)",
9582                               timeout_duration[level - 1] / 1000,
9583                               period_duration[level - 1] / 1000);
9584         }
9585
9586         if (!(priv->power_mode & IPW_POWER_ENABLED))
9587                 p += scnprintf(p, MAX_WX_STRING - (p - extra), " OFF");
9588
9589         wrqu->data.length = p - extra + 1;
9590
9591         return 0;
9592 }
9593
9594 static int ipw_wx_set_wireless_mode(struct net_device *dev,
9595                                     struct iw_request_info *info,
9596                                     union iwreq_data *wrqu, char *extra)
9597 {
9598         struct ipw_priv *priv = libipw_priv(dev);
9599         int mode = *(int *)extra;
9600         u8 band = 0, modulation = 0;
9601
9602         if (mode == 0 || mode & ~IEEE_MODE_MASK) {
9603                 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
9604                 return -EINVAL;
9605         }
9606         mutex_lock(&priv->mutex);
9607         if (priv->adapter == IPW_2915ABG) {
9608                 priv->ieee->abg_true = 1;
9609                 if (mode & IEEE_A) {
9610                         band |= LIBIPW_52GHZ_BAND;
9611                         modulation |= LIBIPW_OFDM_MODULATION;
9612                 } else
9613                         priv->ieee->abg_true = 0;
9614         } else {
9615                 if (mode & IEEE_A) {
9616                         IPW_WARNING("Attempt to set 2200BG into "
9617                                     "802.11a mode\n");
9618                         mutex_unlock(&priv->mutex);
9619                         return -EINVAL;
9620                 }
9621
9622                 priv->ieee->abg_true = 0;
9623         }
9624
9625         if (mode & IEEE_B) {
9626                 band |= LIBIPW_24GHZ_BAND;
9627                 modulation |= LIBIPW_CCK_MODULATION;
9628         } else
9629                 priv->ieee->abg_true = 0;
9630
9631         if (mode & IEEE_G) {
9632                 band |= LIBIPW_24GHZ_BAND;
9633                 modulation |= LIBIPW_OFDM_MODULATION;
9634         } else
9635                 priv->ieee->abg_true = 0;
9636
9637         priv->ieee->mode = mode;
9638         priv->ieee->freq_band = band;
9639         priv->ieee->modulation = modulation;
9640         init_supported_rates(priv, &priv->rates);
9641
9642         /* Network configuration changed -- force [re]association */
9643         IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9644         if (!ipw_disassociate(priv)) {
9645                 ipw_send_supported_rates(priv, &priv->rates);
9646                 ipw_associate(priv);
9647         }
9648
9649         /* Update the band LEDs */
9650         ipw_led_band_on(priv);
9651
9652         IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
9653                      mode & IEEE_A ? 'a' : '.',
9654                      mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
9655         mutex_unlock(&priv->mutex);
9656         return 0;
9657 }
9658
9659 static int ipw_wx_get_wireless_mode(struct net_device *dev,
9660                                     struct iw_request_info *info,
9661                                     union iwreq_data *wrqu, char *extra)
9662 {
9663         struct ipw_priv *priv = libipw_priv(dev);
9664         mutex_lock(&priv->mutex);
9665         switch (priv->ieee->mode) {
9666         case IEEE_A:
9667                 strscpy_pad(extra, "802.11a (1)", MAX_WX_STRING);
9668                 break;
9669         case IEEE_B:
9670                 strscpy_pad(extra, "802.11b (2)", MAX_WX_STRING);
9671                 break;
9672         case IEEE_A | IEEE_B:
9673                 strscpy_pad(extra, "802.11ab (3)", MAX_WX_STRING);
9674                 break;
9675         case IEEE_G:
9676                 strscpy_pad(extra, "802.11g (4)", MAX_WX_STRING);
9677                 break;
9678         case IEEE_A | IEEE_G:
9679                 strscpy_pad(extra, "802.11ag (5)", MAX_WX_STRING);
9680                 break;
9681         case IEEE_B | IEEE_G:
9682                 strscpy_pad(extra, "802.11bg (6)", MAX_WX_STRING);
9683                 break;
9684         case IEEE_A | IEEE_B | IEEE_G:
9685                 strscpy_pad(extra, "802.11abg (7)", MAX_WX_STRING);
9686                 break;
9687         default:
9688                 strscpy_pad(extra, "unknown", MAX_WX_STRING);
9689                 break;
9690         }
9691
9692         IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9693
9694         wrqu->data.length = strlen(extra) + 1;
9695         mutex_unlock(&priv->mutex);
9696
9697         return 0;
9698 }
9699
9700 static int ipw_wx_set_preamble(struct net_device *dev,
9701                                struct iw_request_info *info,
9702                                union iwreq_data *wrqu, char *extra)
9703 {
9704         struct ipw_priv *priv = libipw_priv(dev);
9705         int mode = *(int *)extra;
9706         mutex_lock(&priv->mutex);
9707         /* Switching from SHORT -> LONG requires a disassociation */
9708         if (mode == 1) {
9709                 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9710                         priv->config |= CFG_PREAMBLE_LONG;
9711
9712                         /* Network configuration changed -- force [re]association */
9713                         IPW_DEBUG_ASSOC
9714                             ("[re]association triggered due to preamble change.\n");
9715                         if (!ipw_disassociate(priv))
9716                                 ipw_associate(priv);
9717                 }
9718                 goto done;
9719         }
9720
9721         if (mode == 0) {
9722                 priv->config &= ~CFG_PREAMBLE_LONG;
9723                 goto done;
9724         }
9725         mutex_unlock(&priv->mutex);
9726         return -EINVAL;
9727
9728       done:
9729         mutex_unlock(&priv->mutex);
9730         return 0;
9731 }
9732
9733 static int ipw_wx_get_preamble(struct net_device *dev,
9734                                struct iw_request_info *info,
9735                                union iwreq_data *wrqu, char *extra)
9736 {
9737         struct ipw_priv *priv = libipw_priv(dev);
9738         mutex_lock(&priv->mutex);
9739         if (priv->config & CFG_PREAMBLE_LONG)
9740                 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9741         else
9742                 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
9743         mutex_unlock(&priv->mutex);
9744         return 0;
9745 }
9746
9747 #ifdef CONFIG_IPW2200_MONITOR
9748 static int ipw_wx_set_monitor(struct net_device *dev,
9749                               struct iw_request_info *info,
9750                               union iwreq_data *wrqu, char *extra)
9751 {
9752         struct ipw_priv *priv = libipw_priv(dev);
9753         int *parms = (int *)extra;
9754         int enable = (parms[0] > 0);
9755         mutex_lock(&priv->mutex);
9756         IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
9757         if (enable) {
9758                 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9759 #ifdef CONFIG_IPW2200_RADIOTAP
9760                         priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9761 #else
9762                         priv->net_dev->type = ARPHRD_IEEE80211;
9763 #endif
9764                         schedule_work(&priv->adapter_restart);
9765                 }
9766
9767                 ipw_set_channel(priv, parms[1]);
9768         } else {
9769                 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9770                         mutex_unlock(&priv->mutex);
9771                         return 0;
9772                 }
9773                 priv->net_dev->type = ARPHRD_ETHER;
9774                 schedule_work(&priv->adapter_restart);
9775         }
9776         mutex_unlock(&priv->mutex);
9777         return 0;
9778 }
9779
9780 #endif                          /* CONFIG_IPW2200_MONITOR */
9781
9782 static int ipw_wx_reset(struct net_device *dev,
9783                         struct iw_request_info *info,
9784                         union iwreq_data *wrqu, char *extra)
9785 {
9786         struct ipw_priv *priv = libipw_priv(dev);
9787         IPW_DEBUG_WX("RESET\n");
9788         schedule_work(&priv->adapter_restart);
9789         return 0;
9790 }
9791
9792 static int ipw_wx_sw_reset(struct net_device *dev,
9793                            struct iw_request_info *info,
9794                            union iwreq_data *wrqu, char *extra)
9795 {
9796         struct ipw_priv *priv = libipw_priv(dev);
9797         union iwreq_data wrqu_sec = {
9798                 .encoding = {
9799                              .flags = IW_ENCODE_DISABLED,
9800                              },
9801         };
9802         int ret;
9803
9804         IPW_DEBUG_WX("SW_RESET\n");
9805
9806         mutex_lock(&priv->mutex);
9807
9808         ret = ipw_sw_reset(priv, 2);
9809         if (!ret) {
9810                 free_firmware();
9811                 ipw_adapter_restart(priv);
9812         }
9813
9814         /* The SW reset bit might have been toggled on by the 'disable'
9815          * module parameter, so take appropriate action */
9816         ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9817
9818         mutex_unlock(&priv->mutex);
9819         libipw_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
9820         mutex_lock(&priv->mutex);
9821
9822         if (!(priv->status & STATUS_RF_KILL_MASK)) {
9823                 /* Configuration likely changed -- force [re]association */
9824                 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9825                                 "reset.\n");
9826                 if (!ipw_disassociate(priv))
9827                         ipw_associate(priv);
9828         }
9829
9830         mutex_unlock(&priv->mutex);
9831
9832         return 0;
9833 }
9834
9835 /* Rebase the WE IOCTLs to zero for the handler array */
9836 static iw_handler ipw_wx_handlers[] = {
9837         IW_HANDLER(SIOCGIWNAME, ipw_wx_get_name),
9838         IW_HANDLER(SIOCSIWFREQ, ipw_wx_set_freq),
9839         IW_HANDLER(SIOCGIWFREQ, ipw_wx_get_freq),
9840         IW_HANDLER(SIOCSIWMODE, ipw_wx_set_mode),
9841         IW_HANDLER(SIOCGIWMODE, ipw_wx_get_mode),
9842         IW_HANDLER(SIOCSIWSENS, ipw_wx_set_sens),
9843         IW_HANDLER(SIOCGIWSENS, ipw_wx_get_sens),
9844         IW_HANDLER(SIOCGIWRANGE, ipw_wx_get_range),
9845         IW_HANDLER(SIOCSIWAP, ipw_wx_set_wap),
9846         IW_HANDLER(SIOCGIWAP, ipw_wx_get_wap),
9847         IW_HANDLER(SIOCSIWSCAN, ipw_wx_set_scan),
9848         IW_HANDLER(SIOCGIWSCAN, ipw_wx_get_scan),
9849         IW_HANDLER(SIOCSIWESSID, ipw_wx_set_essid),
9850         IW_HANDLER(SIOCGIWESSID, ipw_wx_get_essid),
9851         IW_HANDLER(SIOCSIWNICKN, ipw_wx_set_nick),
9852         IW_HANDLER(SIOCGIWNICKN, ipw_wx_get_nick),
9853         IW_HANDLER(SIOCSIWRATE, ipw_wx_set_rate),
9854         IW_HANDLER(SIOCGIWRATE, ipw_wx_get_rate),
9855         IW_HANDLER(SIOCSIWRTS, ipw_wx_set_rts),
9856         IW_HANDLER(SIOCGIWRTS, ipw_wx_get_rts),
9857         IW_HANDLER(SIOCSIWFRAG, ipw_wx_set_frag),
9858         IW_HANDLER(SIOCGIWFRAG, ipw_wx_get_frag),
9859         IW_HANDLER(SIOCSIWTXPOW, ipw_wx_set_txpow),
9860         IW_HANDLER(SIOCGIWTXPOW, ipw_wx_get_txpow),
9861         IW_HANDLER(SIOCSIWRETRY, ipw_wx_set_retry),
9862         IW_HANDLER(SIOCGIWRETRY, ipw_wx_get_retry),
9863         IW_HANDLER(SIOCSIWENCODE, ipw_wx_set_encode),
9864         IW_HANDLER(SIOCGIWENCODE, ipw_wx_get_encode),
9865         IW_HANDLER(SIOCSIWPOWER, ipw_wx_set_power),
9866         IW_HANDLER(SIOCGIWPOWER, ipw_wx_get_power),
9867         IW_HANDLER(SIOCSIWSPY, ipw_wx_set_spy),
9868         IW_HANDLER(SIOCGIWSPY, ipw_wx_get_spy),
9869         IW_HANDLER(SIOCSIWTHRSPY, ipw_wx_set_thrspy),
9870         IW_HANDLER(SIOCGIWTHRSPY, ipw_wx_get_thrspy),
9871         IW_HANDLER(SIOCSIWGENIE, ipw_wx_set_genie),
9872         IW_HANDLER(SIOCGIWGENIE, ipw_wx_get_genie),
9873         IW_HANDLER(SIOCSIWMLME, ipw_wx_set_mlme),
9874         IW_HANDLER(SIOCSIWAUTH, ipw_wx_set_auth),
9875         IW_HANDLER(SIOCGIWAUTH, ipw_wx_get_auth),
9876         IW_HANDLER(SIOCSIWENCODEEXT, ipw_wx_set_encodeext),
9877         IW_HANDLER(SIOCGIWENCODEEXT, ipw_wx_get_encodeext),
9878 };
9879
9880 enum {
9881         IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
9882         IPW_PRIV_GET_POWER,
9883         IPW_PRIV_SET_MODE,
9884         IPW_PRIV_GET_MODE,
9885         IPW_PRIV_SET_PREAMBLE,
9886         IPW_PRIV_GET_PREAMBLE,
9887         IPW_PRIV_RESET,
9888         IPW_PRIV_SW_RESET,
9889 #ifdef CONFIG_IPW2200_MONITOR
9890         IPW_PRIV_SET_MONITOR,
9891 #endif
9892 };
9893
9894 static struct iw_priv_args ipw_priv_args[] = {
9895         {
9896          .cmd = IPW_PRIV_SET_POWER,
9897          .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9898          .name = "set_power"},
9899         {
9900          .cmd = IPW_PRIV_GET_POWER,
9901          .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9902          .name = "get_power"},
9903         {
9904          .cmd = IPW_PRIV_SET_MODE,
9905          .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9906          .name = "set_mode"},
9907         {
9908          .cmd = IPW_PRIV_GET_MODE,
9909          .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9910          .name = "get_mode"},
9911         {
9912          .cmd = IPW_PRIV_SET_PREAMBLE,
9913          .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9914          .name = "set_preamble"},
9915         {
9916          .cmd = IPW_PRIV_GET_PREAMBLE,
9917          .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
9918          .name = "get_preamble"},
9919         {
9920          IPW_PRIV_RESET,
9921          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
9922         {
9923          IPW_PRIV_SW_RESET,
9924          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
9925 #ifdef CONFIG_IPW2200_MONITOR
9926         {
9927          IPW_PRIV_SET_MONITOR,
9928          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
9929 #endif                          /* CONFIG_IPW2200_MONITOR */
9930 };
9931
9932 static iw_handler ipw_priv_handler[] = {
9933         ipw_wx_set_powermode,
9934         ipw_wx_get_powermode,
9935         ipw_wx_set_wireless_mode,
9936         ipw_wx_get_wireless_mode,
9937         ipw_wx_set_preamble,
9938         ipw_wx_get_preamble,
9939         ipw_wx_reset,
9940         ipw_wx_sw_reset,
9941 #ifdef CONFIG_IPW2200_MONITOR
9942         ipw_wx_set_monitor,
9943 #endif
9944 };
9945
9946 static const struct iw_handler_def ipw_wx_handler_def = {
9947         .standard = ipw_wx_handlers,
9948         .num_standard = ARRAY_SIZE(ipw_wx_handlers),
9949         .num_private = ARRAY_SIZE(ipw_priv_handler),
9950         .num_private_args = ARRAY_SIZE(ipw_priv_args),
9951         .private = ipw_priv_handler,
9952         .private_args = ipw_priv_args,
9953         .get_wireless_stats = ipw_get_wireless_stats,
9954 };
9955
9956 /*
9957  * Get wireless statistics.
9958  * Called by /proc/net/wireless
9959  * Also called by SIOCGIWSTATS
9960  */
9961 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
9962 {
9963         struct ipw_priv *priv = libipw_priv(dev);
9964         struct iw_statistics *wstats;
9965
9966         wstats = &priv->wstats;
9967
9968         /* if hw is disabled, then ipw_get_ordinal() can't be called.
9969          * netdev->get_wireless_stats seems to be called before fw is
9970          * initialized.  STATUS_ASSOCIATED will only be set if the hw is up
9971          * and associated; if not associcated, the values are all meaningless
9972          * anyway, so set them all to NULL and INVALID */
9973         if (!(priv->status & STATUS_ASSOCIATED)) {
9974                 wstats->miss.beacon = 0;
9975                 wstats->discard.retries = 0;
9976                 wstats->qual.qual = 0;
9977                 wstats->qual.level = 0;
9978                 wstats->qual.noise = 0;
9979                 wstats->qual.updated = 7;
9980                 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
9981                     IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
9982                 return wstats;
9983         }
9984
9985         wstats->qual.qual = priv->quality;
9986         wstats->qual.level = priv->exp_avg_rssi;
9987         wstats->qual.noise = priv->exp_avg_noise;
9988         wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
9989             IW_QUAL_NOISE_UPDATED | IW_QUAL_DBM;
9990
9991         wstats->miss.beacon = average_value(&priv->average_missed_beacons);
9992         wstats->discard.retries = priv->last_tx_failures;
9993         wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
9994
9995 /*      if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
9996         goto fail_get_ordinal;
9997         wstats->discard.retries += tx_retry; */
9998
9999         return wstats;
10000 }
10001
10002 /* net device stuff */
10003
10004 static  void init_sys_config(struct ipw_sys_config *sys_config)
10005 {
10006         memset(sys_config, 0, sizeof(struct ipw_sys_config));
10007         sys_config->bt_coexistence = 0;
10008         sys_config->answer_broadcast_ssid_probe = 0;
10009         sys_config->accept_all_data_frames = 0;
10010         sys_config->accept_non_directed_frames = 1;
10011         sys_config->exclude_unicast_unencrypted = 0;
10012         sys_config->disable_unicast_decryption = 1;
10013         sys_config->exclude_multicast_unencrypted = 0;
10014         sys_config->disable_multicast_decryption = 1;
10015         if (antenna < CFG_SYS_ANTENNA_BOTH || antenna > CFG_SYS_ANTENNA_B)
10016                 antenna = CFG_SYS_ANTENNA_BOTH;
10017         sys_config->antenna_diversity = antenna;
10018         sys_config->pass_crc_to_host = 0;       /* TODO: See if 1 gives us FCS */
10019         sys_config->dot11g_auto_detection = 0;
10020         sys_config->enable_cts_to_self = 0;
10021         sys_config->bt_coexist_collision_thr = 0;
10022         sys_config->pass_noise_stats_to_host = 1;       /* 1 -- fix for 256 */
10023         sys_config->silence_threshold = 0x1e;
10024 }
10025
10026 static int ipw_net_open(struct net_device *dev)
10027 {
10028         IPW_DEBUG_INFO("dev->open\n");
10029         netif_start_queue(dev);
10030         return 0;
10031 }
10032
10033 static int ipw_net_stop(struct net_device *dev)
10034 {
10035         IPW_DEBUG_INFO("dev->close\n");
10036         netif_stop_queue(dev);
10037         return 0;
10038 }
10039
10040 /*
10041 todo:
10042
10043 modify to send one tfd per fragment instead of using chunking.  otherwise
10044 we need to heavily modify the libipw_skb_to_txb.
10045 */
10046
10047 static int ipw_tx_skb(struct ipw_priv *priv, struct libipw_txb *txb,
10048                              int pri)
10049 {
10050         struct libipw_hdr_3addrqos *hdr = (struct libipw_hdr_3addrqos *)
10051             txb->fragments[0]->data;
10052         int i = 0;
10053         struct tfd_frame *tfd;
10054 #ifdef CONFIG_IPW2200_QOS
10055         int tx_id = ipw_get_tx_queue_number(priv, pri);
10056         struct clx2_tx_queue *txq = &priv->txq[tx_id];
10057 #else
10058         struct clx2_tx_queue *txq = &priv->txq[0];
10059 #endif
10060         struct clx2_queue *q = &txq->q;
10061         u8 id, hdr_len, unicast;
10062         int fc;
10063
10064         if (!(priv->status & STATUS_ASSOCIATED))
10065                 goto drop;
10066
10067         hdr_len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_ctl));
10068         switch (priv->ieee->iw_mode) {
10069         case IW_MODE_ADHOC:
10070                 unicast = !is_multicast_ether_addr(hdr->addr1);
10071                 id = ipw_find_station(priv, hdr->addr1);
10072                 if (id == IPW_INVALID_STATION) {
10073                         id = ipw_add_station(priv, hdr->addr1);
10074                         if (id == IPW_INVALID_STATION) {
10075                                 IPW_WARNING("Attempt to send data to "
10076                                             "invalid cell: %pM\n",
10077                                             hdr->addr1);
10078                                 goto drop;
10079                         }
10080                 }
10081                 break;
10082
10083         case IW_MODE_INFRA:
10084         default:
10085                 unicast = !is_multicast_ether_addr(hdr->addr3);
10086                 id = 0;
10087                 break;
10088         }
10089
10090         tfd = &txq->bd[q->first_empty];
10091         txq->txb[q->first_empty] = txb;
10092         memset(tfd, 0, sizeof(*tfd));
10093         tfd->u.data.station_number = id;
10094
10095         tfd->control_flags.message_type = TX_FRAME_TYPE;
10096         tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
10097
10098         tfd->u.data.cmd_id = DINO_CMD_TX;
10099         tfd->u.data.len = cpu_to_le16(txb->payload_size);
10100
10101         if (priv->assoc_request.ieee_mode == IPW_B_MODE)
10102                 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
10103         else
10104                 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
10105
10106         if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
10107                 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
10108
10109         fc = le16_to_cpu(hdr->frame_ctl);
10110         hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
10111
10112         memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
10113
10114         if (likely(unicast))
10115                 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10116
10117         if (txb->encrypted && !priv->ieee->host_encrypt) {
10118                 switch (priv->ieee->sec.level) {
10119                 case SEC_LEVEL_3:
10120                         tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10121                             cpu_to_le16(IEEE80211_FCTL_PROTECTED);
10122                         /* XXX: ACK flag must be set for CCMP even if it
10123                          * is a multicast/broadcast packet, because CCMP
10124                          * group communication encrypted by GTK is
10125                          * actually done by the AP. */
10126                         if (!unicast)
10127                                 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10128
10129                         tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10130                         tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
10131                         tfd->u.data.key_index = 0;
10132                         tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
10133                         break;
10134                 case SEC_LEVEL_2:
10135                         tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10136                             cpu_to_le16(IEEE80211_FCTL_PROTECTED);
10137                         tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10138                         tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
10139                         tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
10140                         break;
10141                 case SEC_LEVEL_1:
10142                         tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10143                             cpu_to_le16(IEEE80211_FCTL_PROTECTED);
10144                         tfd->u.data.key_index = priv->ieee->crypt_info.tx_keyidx;
10145                         if (priv->ieee->sec.key_sizes[priv->ieee->crypt_info.tx_keyidx] <=
10146                             40)
10147                                 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
10148                         else
10149                                 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
10150                         break;
10151                 case SEC_LEVEL_0:
10152                         break;
10153                 default:
10154                         printk(KERN_ERR "Unknown security level %d\n",
10155                                priv->ieee->sec.level);
10156                         break;
10157                 }
10158         } else
10159                 /* No hardware encryption */
10160                 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
10161
10162 #ifdef CONFIG_IPW2200_QOS
10163         if (fc & IEEE80211_STYPE_QOS_DATA)
10164                 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data));
10165 #endif                          /* CONFIG_IPW2200_QOS */
10166
10167         /* payload */
10168         tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
10169                                                  txb->nr_frags));
10170         IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
10171                        txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
10172         for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
10173                 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
10174                                i, le32_to_cpu(tfd->u.data.num_chunks),
10175                                txb->fragments[i]->len - hdr_len);
10176                 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
10177                              i, tfd->u.data.num_chunks,
10178                              txb->fragments[i]->len - hdr_len);
10179                 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
10180                            txb->fragments[i]->len - hdr_len);
10181
10182                 tfd->u.data.chunk_ptr[i] =
10183                     cpu_to_le32(dma_map_single(&priv->pci_dev->dev,
10184                                                txb->fragments[i]->data + hdr_len,
10185                                                txb->fragments[i]->len - hdr_len,
10186                                                DMA_TO_DEVICE));
10187                 tfd->u.data.chunk_len[i] =
10188                     cpu_to_le16(txb->fragments[i]->len - hdr_len);
10189         }
10190
10191         if (i != txb->nr_frags) {
10192                 struct sk_buff *skb;
10193                 u16 remaining_bytes = 0;
10194                 int j;
10195
10196                 for (j = i; j < txb->nr_frags; j++)
10197                         remaining_bytes += txb->fragments[j]->len - hdr_len;
10198
10199                 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
10200                        remaining_bytes);
10201                 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
10202                 if (skb != NULL) {
10203                         tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
10204                         for (j = i; j < txb->nr_frags; j++) {
10205                                 int size = txb->fragments[j]->len - hdr_len;
10206
10207                                 printk(KERN_INFO "Adding frag %d %d...\n",
10208                                        j, size);
10209                                 skb_put_data(skb,
10210                                              txb->fragments[j]->data + hdr_len,
10211                                              size);
10212                         }
10213                         dev_kfree_skb_any(txb->fragments[i]);
10214                         txb->fragments[i] = skb;
10215                         tfd->u.data.chunk_ptr[i] =
10216                             cpu_to_le32(dma_map_single(&priv->pci_dev->dev,
10217                                                        skb->data,
10218                                                        remaining_bytes,
10219                                                        DMA_TO_DEVICE));
10220
10221                         le32_add_cpu(&tfd->u.data.num_chunks, 1);
10222                 }
10223         }
10224
10225         /* kick DMA */
10226         q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
10227         ipw_write32(priv, q->reg_w, q->first_empty);
10228
10229         if (ipw_tx_queue_space(q) < q->high_mark)
10230                 netif_stop_queue(priv->net_dev);
10231
10232         return NETDEV_TX_OK;
10233
10234       drop:
10235         IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
10236         libipw_txb_free(txb);
10237         return NETDEV_TX_OK;
10238 }
10239
10240 static int ipw_net_is_queue_full(struct net_device *dev, int pri)
10241 {
10242         struct ipw_priv *priv = libipw_priv(dev);
10243 #ifdef CONFIG_IPW2200_QOS
10244         int tx_id = ipw_get_tx_queue_number(priv, pri);
10245         struct clx2_tx_queue *txq = &priv->txq[tx_id];
10246 #else
10247         struct clx2_tx_queue *txq = &priv->txq[0];
10248 #endif                          /* CONFIG_IPW2200_QOS */
10249
10250         if (ipw_tx_queue_space(&txq->q) < txq->q.high_mark)
10251                 return 1;
10252
10253         return 0;
10254 }
10255
10256 #ifdef CONFIG_IPW2200_PROMISCUOUS
10257 static void ipw_handle_promiscuous_tx(struct ipw_priv *priv,
10258                                       struct libipw_txb *txb)
10259 {
10260         struct libipw_rx_stats dummystats;
10261         struct ieee80211_hdr *hdr;
10262         u8 n;
10263         u16 filter = priv->prom_priv->filter;
10264         int hdr_only = 0;
10265
10266         if (filter & IPW_PROM_NO_TX)
10267                 return;
10268
10269         memset(&dummystats, 0, sizeof(dummystats));
10270
10271         /* Filtering of fragment chains is done against the first fragment */
10272         hdr = (void *)txb->fragments[0]->data;
10273         if (libipw_is_management(le16_to_cpu(hdr->frame_control))) {
10274                 if (filter & IPW_PROM_NO_MGMT)
10275                         return;
10276                 if (filter & IPW_PROM_MGMT_HEADER_ONLY)
10277                         hdr_only = 1;
10278         } else if (libipw_is_control(le16_to_cpu(hdr->frame_control))) {
10279                 if (filter & IPW_PROM_NO_CTL)
10280                         return;
10281                 if (filter & IPW_PROM_CTL_HEADER_ONLY)
10282                         hdr_only = 1;
10283         } else if (libipw_is_data(le16_to_cpu(hdr->frame_control))) {
10284                 if (filter & IPW_PROM_NO_DATA)
10285                         return;
10286                 if (filter & IPW_PROM_DATA_HEADER_ONLY)
10287                         hdr_only = 1;
10288         }
10289
10290         for(n=0; n<txb->nr_frags; ++n) {
10291                 struct sk_buff *src = txb->fragments[n];
10292                 struct sk_buff *dst;
10293                 struct ieee80211_radiotap_header *rt_hdr;
10294                 int len;
10295
10296                 if (hdr_only) {
10297                         hdr = (void *)src->data;
10298                         len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_control));
10299                 } else
10300                         len = src->len;
10301
10302                 dst = alloc_skb(len + sizeof(*rt_hdr) + sizeof(u16)*2, GFP_ATOMIC);
10303                 if (!dst)
10304                         continue;
10305
10306                 rt_hdr = skb_put(dst, sizeof(*rt_hdr));
10307
10308                 rt_hdr->it_version = PKTHDR_RADIOTAP_VERSION;
10309                 rt_hdr->it_pad = 0;
10310                 rt_hdr->it_present = 0; /* after all, it's just an idea */
10311                 rt_hdr->it_present |=  cpu_to_le32(1 << IEEE80211_RADIOTAP_CHANNEL);
10312
10313                 *(__le16*)skb_put(dst, sizeof(u16)) = cpu_to_le16(
10314                         ieee80211chan2mhz(priv->channel));
10315                 if (priv->channel > 14)         /* 802.11a */
10316                         *(__le16*)skb_put(dst, sizeof(u16)) =
10317                                 cpu_to_le16(IEEE80211_CHAN_OFDM |
10318                                              IEEE80211_CHAN_5GHZ);
10319                 else if (priv->ieee->mode == IEEE_B) /* 802.11b */
10320                         *(__le16*)skb_put(dst, sizeof(u16)) =
10321                                 cpu_to_le16(IEEE80211_CHAN_CCK |
10322                                              IEEE80211_CHAN_2GHZ);
10323                 else            /* 802.11g */
10324                         *(__le16*)skb_put(dst, sizeof(u16)) =
10325                                 cpu_to_le16(IEEE80211_CHAN_OFDM |
10326                                  IEEE80211_CHAN_2GHZ);
10327
10328                 rt_hdr->it_len = cpu_to_le16(dst->len);
10329
10330                 skb_copy_from_linear_data(src, skb_put(dst, len), len);
10331
10332                 if (!libipw_rx(priv->prom_priv->ieee, dst, &dummystats))
10333                         dev_kfree_skb_any(dst);
10334         }
10335 }
10336 #endif
10337
10338 static netdev_tx_t ipw_net_hard_start_xmit(struct libipw_txb *txb,
10339                                            struct net_device *dev, int pri)
10340 {
10341         struct ipw_priv *priv = libipw_priv(dev);
10342         unsigned long flags;
10343         netdev_tx_t ret;
10344
10345         IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
10346         spin_lock_irqsave(&priv->lock, flags);
10347
10348 #ifdef CONFIG_IPW2200_PROMISCUOUS
10349         if (rtap_iface && netif_running(priv->prom_net_dev))
10350                 ipw_handle_promiscuous_tx(priv, txb);
10351 #endif
10352
10353         ret = ipw_tx_skb(priv, txb, pri);
10354         if (ret == NETDEV_TX_OK)
10355                 __ipw_led_activity_on(priv);
10356         spin_unlock_irqrestore(&priv->lock, flags);
10357
10358         return ret;
10359 }
10360
10361 static void ipw_net_set_multicast_list(struct net_device *dev)
10362 {
10363
10364 }
10365
10366 static int ipw_net_set_mac_address(struct net_device *dev, void *p)
10367 {
10368         struct ipw_priv *priv = libipw_priv(dev);
10369         struct sockaddr *addr = p;
10370
10371         if (!is_valid_ether_addr(addr->sa_data))
10372                 return -EADDRNOTAVAIL;
10373         mutex_lock(&priv->mutex);
10374         priv->config |= CFG_CUSTOM_MAC;
10375         memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
10376         printk(KERN_INFO "%s: Setting MAC to %pM\n",
10377                priv->net_dev->name, priv->mac_addr);
10378         schedule_work(&priv->adapter_restart);
10379         mutex_unlock(&priv->mutex);
10380         return 0;
10381 }
10382
10383 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
10384                                     struct ethtool_drvinfo *info)
10385 {
10386         struct ipw_priv *p = libipw_priv(dev);
10387         char vers[64];
10388         u32 len;
10389
10390         strscpy(info->driver, DRV_NAME, sizeof(info->driver));
10391         strscpy(info->version, DRV_VERSION, sizeof(info->version));
10392
10393         len = sizeof(vers);
10394         ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
10395
10396         strscpy(info->fw_version, vers, sizeof(info->fw_version));
10397         strscpy(info->bus_info, pci_name(p->pci_dev),
10398                 sizeof(info->bus_info));
10399 }
10400
10401 static u32 ipw_ethtool_get_link(struct net_device *dev)
10402 {
10403         struct ipw_priv *priv = libipw_priv(dev);
10404         return (priv->status & STATUS_ASSOCIATED) != 0;
10405 }
10406
10407 static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
10408 {
10409         return IPW_EEPROM_IMAGE_SIZE;
10410 }
10411
10412 static int ipw_ethtool_get_eeprom(struct net_device *dev,
10413                                   struct ethtool_eeprom *eeprom, u8 * bytes)
10414 {
10415         struct ipw_priv *p = libipw_priv(dev);
10416
10417         if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
10418                 return -EINVAL;
10419         mutex_lock(&p->mutex);
10420         memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
10421         mutex_unlock(&p->mutex);
10422         return 0;
10423 }
10424
10425 static int ipw_ethtool_set_eeprom(struct net_device *dev,
10426                                   struct ethtool_eeprom *eeprom, u8 * bytes)
10427 {
10428         struct ipw_priv *p = libipw_priv(dev);
10429         int i;
10430
10431         if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
10432                 return -EINVAL;
10433         mutex_lock(&p->mutex);
10434         memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
10435         for (i = 0; i < IPW_EEPROM_IMAGE_SIZE; i++)
10436                 ipw_write8(p, i + IPW_EEPROM_DATA, p->eeprom[i]);
10437         mutex_unlock(&p->mutex);
10438         return 0;
10439 }
10440
10441 static const struct ethtool_ops ipw_ethtool_ops = {
10442         .get_link = ipw_ethtool_get_link,
10443         .get_drvinfo = ipw_ethtool_get_drvinfo,
10444         .get_eeprom_len = ipw_ethtool_get_eeprom_len,
10445         .get_eeprom = ipw_ethtool_get_eeprom,
10446         .set_eeprom = ipw_ethtool_set_eeprom,
10447 };
10448
10449 static irqreturn_t ipw_isr(int irq, void *data)
10450 {
10451         struct ipw_priv *priv = data;
10452         u32 inta, inta_mask;
10453
10454         if (!priv)
10455                 return IRQ_NONE;
10456
10457         spin_lock(&priv->irq_lock);
10458
10459         if (!(priv->status & STATUS_INT_ENABLED)) {
10460                 /* IRQ is disabled */
10461                 goto none;
10462         }
10463
10464         inta = ipw_read32(priv, IPW_INTA_RW);
10465         inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
10466
10467         if (inta == 0xFFFFFFFF) {
10468                 /* Hardware disappeared */
10469                 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
10470                 goto none;
10471         }
10472
10473         if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
10474                 /* Shared interrupt */
10475                 goto none;
10476         }
10477
10478         /* tell the device to stop sending interrupts */
10479         __ipw_disable_interrupts(priv);
10480
10481         /* ack current interrupts */
10482         inta &= (IPW_INTA_MASK_ALL & inta_mask);
10483         ipw_write32(priv, IPW_INTA_RW, inta);
10484
10485         /* Cache INTA value for our tasklet */
10486         priv->isr_inta = inta;
10487
10488         tasklet_schedule(&priv->irq_tasklet);
10489
10490         spin_unlock(&priv->irq_lock);
10491
10492         return IRQ_HANDLED;
10493       none:
10494         spin_unlock(&priv->irq_lock);
10495         return IRQ_NONE;
10496 }
10497
10498 static void ipw_rf_kill(void *adapter)
10499 {
10500         struct ipw_priv *priv = adapter;
10501         unsigned long flags;
10502
10503         spin_lock_irqsave(&priv->lock, flags);
10504
10505         if (rf_kill_active(priv)) {
10506                 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10507                 schedule_delayed_work(&priv->rf_kill, 2 * HZ);
10508                 goto exit_unlock;
10509         }
10510
10511         /* RF Kill is now disabled, so bring the device back up */
10512
10513         if (!(priv->status & STATUS_RF_KILL_MASK)) {
10514                 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10515                                   "device\n");
10516
10517                 /* we can not do an adapter restart while inside an irq lock */
10518                 schedule_work(&priv->adapter_restart);
10519         } else
10520                 IPW_DEBUG_RF_KILL("HW RF Kill deactivated.  SW RF Kill still "
10521                                   "enabled\n");
10522
10523       exit_unlock:
10524         spin_unlock_irqrestore(&priv->lock, flags);
10525 }
10526
10527 static void ipw_bg_rf_kill(struct work_struct *work)
10528 {
10529         struct ipw_priv *priv =
10530                 container_of(work, struct ipw_priv, rf_kill.work);
10531         mutex_lock(&priv->mutex);
10532         ipw_rf_kill(priv);
10533         mutex_unlock(&priv->mutex);
10534 }
10535
10536 static void ipw_link_up(struct ipw_priv *priv)
10537 {
10538         priv->last_seq_num = -1;
10539         priv->last_frag_num = -1;
10540         priv->last_packet_time = 0;
10541
10542         netif_carrier_on(priv->net_dev);
10543
10544         cancel_delayed_work(&priv->request_scan);
10545         cancel_delayed_work(&priv->request_direct_scan);
10546         cancel_delayed_work(&priv->request_passive_scan);
10547         cancel_delayed_work(&priv->scan_event);
10548         ipw_reset_stats(priv);
10549         /* Ensure the rate is updated immediately */
10550         priv->last_rate = ipw_get_current_rate(priv);
10551         ipw_gather_stats(priv);
10552         ipw_led_link_up(priv);
10553         notify_wx_assoc_event(priv);
10554
10555         if (priv->config & CFG_BACKGROUND_SCAN)
10556                 schedule_delayed_work(&priv->request_scan, HZ);
10557 }
10558
10559 static void ipw_bg_link_up(struct work_struct *work)
10560 {
10561         struct ipw_priv *priv =
10562                 container_of(work, struct ipw_priv, link_up);
10563         mutex_lock(&priv->mutex);
10564         ipw_link_up(priv);
10565         mutex_unlock(&priv->mutex);
10566 }
10567
10568 static void ipw_link_down(struct ipw_priv *priv)
10569 {
10570         ipw_led_link_down(priv);
10571         netif_carrier_off(priv->net_dev);
10572         notify_wx_assoc_event(priv);
10573
10574         /* Cancel any queued work ... */
10575         cancel_delayed_work(&priv->request_scan);
10576         cancel_delayed_work(&priv->request_direct_scan);
10577         cancel_delayed_work(&priv->request_passive_scan);
10578         cancel_delayed_work(&priv->adhoc_check);
10579         cancel_delayed_work(&priv->gather_stats);
10580
10581         ipw_reset_stats(priv);
10582
10583         if (!(priv->status & STATUS_EXIT_PENDING)) {
10584                 /* Queue up another scan... */
10585                 schedule_delayed_work(&priv->request_scan, 0);
10586         } else
10587                 cancel_delayed_work(&priv->scan_event);
10588 }
10589
10590 static void ipw_bg_link_down(struct work_struct *work)
10591 {
10592         struct ipw_priv *priv =
10593                 container_of(work, struct ipw_priv, link_down);
10594         mutex_lock(&priv->mutex);
10595         ipw_link_down(priv);
10596         mutex_unlock(&priv->mutex);
10597 }
10598
10599 static void ipw_setup_deferred_work(struct ipw_priv *priv)
10600 {
10601         init_waitqueue_head(&priv->wait_command_queue);
10602         init_waitqueue_head(&priv->wait_state);
10603
10604         INIT_DELAYED_WORK(&priv->adhoc_check, ipw_bg_adhoc_check);
10605         INIT_WORK(&priv->associate, ipw_bg_associate);
10606         INIT_WORK(&priv->disassociate, ipw_bg_disassociate);
10607         INIT_WORK(&priv->system_config, ipw_system_config);
10608         INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish);
10609         INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart);
10610         INIT_DELAYED_WORK(&priv->rf_kill, ipw_bg_rf_kill);
10611         INIT_WORK(&priv->up, ipw_bg_up);
10612         INIT_WORK(&priv->down, ipw_bg_down);
10613         INIT_DELAYED_WORK(&priv->request_scan, ipw_request_scan);
10614         INIT_DELAYED_WORK(&priv->request_direct_scan, ipw_request_direct_scan);
10615         INIT_DELAYED_WORK(&priv->request_passive_scan, ipw_request_passive_scan);
10616         INIT_DELAYED_WORK(&priv->scan_event, ipw_scan_event);
10617         INIT_DELAYED_WORK(&priv->gather_stats, ipw_bg_gather_stats);
10618         INIT_WORK(&priv->abort_scan, ipw_bg_abort_scan);
10619         INIT_WORK(&priv->roam, ipw_bg_roam);
10620         INIT_DELAYED_WORK(&priv->scan_check, ipw_bg_scan_check);
10621         INIT_WORK(&priv->link_up, ipw_bg_link_up);
10622         INIT_WORK(&priv->link_down, ipw_bg_link_down);
10623         INIT_DELAYED_WORK(&priv->led_link_on, ipw_bg_led_link_on);
10624         INIT_DELAYED_WORK(&priv->led_link_off, ipw_bg_led_link_off);
10625         INIT_DELAYED_WORK(&priv->led_act_off, ipw_bg_led_activity_off);
10626         INIT_WORK(&priv->merge_networks, ipw_merge_adhoc_network);
10627
10628 #ifdef CONFIG_IPW2200_QOS
10629         INIT_WORK(&priv->qos_activate, ipw_bg_qos_activate);
10630 #endif                          /* CONFIG_IPW2200_QOS */
10631
10632         tasklet_setup(&priv->irq_tasklet, ipw_irq_tasklet);
10633 }
10634
10635 static void shim__set_security(struct net_device *dev,
10636                                struct libipw_security *sec)
10637 {
10638         struct ipw_priv *priv = libipw_priv(dev);
10639         int i;
10640         for (i = 0; i < 4; i++) {
10641                 if (sec->flags & (1 << i)) {
10642                         priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
10643                         priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
10644                         if (sec->key_sizes[i] == 0)
10645                                 priv->ieee->sec.flags &= ~(1 << i);
10646                         else {
10647                                 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
10648                                        sec->key_sizes[i]);
10649                                 priv->ieee->sec.flags |= (1 << i);
10650                         }
10651                         priv->status |= STATUS_SECURITY_UPDATED;
10652                 } else if (sec->level != SEC_LEVEL_1)
10653                         priv->ieee->sec.flags &= ~(1 << i);
10654         }
10655
10656         if (sec->flags & SEC_ACTIVE_KEY) {
10657                 priv->ieee->sec.active_key = sec->active_key;
10658                 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
10659                 priv->status |= STATUS_SECURITY_UPDATED;
10660         } else
10661                 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10662
10663         if ((sec->flags & SEC_AUTH_MODE) &&
10664             (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10665                 priv->ieee->sec.auth_mode = sec->auth_mode;
10666                 priv->ieee->sec.flags |= SEC_AUTH_MODE;
10667                 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10668                         priv->capability |= CAP_SHARED_KEY;
10669                 else
10670                         priv->capability &= ~CAP_SHARED_KEY;
10671                 priv->status |= STATUS_SECURITY_UPDATED;
10672         }
10673
10674         if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10675                 priv->ieee->sec.flags |= SEC_ENABLED;
10676                 priv->ieee->sec.enabled = sec->enabled;
10677                 priv->status |= STATUS_SECURITY_UPDATED;
10678                 if (sec->enabled)
10679                         priv->capability |= CAP_PRIVACY_ON;
10680                 else
10681                         priv->capability &= ~CAP_PRIVACY_ON;
10682         }
10683
10684         if (sec->flags & SEC_ENCRYPT)
10685                 priv->ieee->sec.encrypt = sec->encrypt;
10686
10687         if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10688                 priv->ieee->sec.level = sec->level;
10689                 priv->ieee->sec.flags |= SEC_LEVEL;
10690                 priv->status |= STATUS_SECURITY_UPDATED;
10691         }
10692
10693         if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10694                 ipw_set_hwcrypto_keys(priv);
10695
10696         /* To match current functionality of ipw2100 (which works well w/
10697          * various supplicants, we don't force a disassociate if the
10698          * privacy capability changes ... */
10699 #if 0
10700         if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
10701             (((priv->assoc_request.capability &
10702                cpu_to_le16(WLAN_CAPABILITY_PRIVACY)) && !sec->enabled) ||
10703              (!(priv->assoc_request.capability &
10704                 cpu_to_le16(WLAN_CAPABILITY_PRIVACY)) && sec->enabled))) {
10705                 IPW_DEBUG_ASSOC("Disassociating due to capability "
10706                                 "change.\n");
10707                 ipw_disassociate(priv);
10708         }
10709 #endif
10710 }
10711
10712 static int init_supported_rates(struct ipw_priv *priv,
10713                                 struct ipw_supported_rates *rates)
10714 {
10715         /* TODO: Mask out rates based on priv->rates_mask */
10716
10717         memset(rates, 0, sizeof(*rates));
10718         /* configure supported rates */
10719         switch (priv->ieee->freq_band) {
10720         case LIBIPW_52GHZ_BAND:
10721                 rates->ieee_mode = IPW_A_MODE;
10722                 rates->purpose = IPW_RATE_CAPABILITIES;
10723                 ipw_add_ofdm_scan_rates(rates, LIBIPW_CCK_MODULATION,
10724                                         LIBIPW_OFDM_DEFAULT_RATES_MASK);
10725                 break;
10726
10727         default:                /* Mixed or 2.4Ghz */
10728                 rates->ieee_mode = IPW_G_MODE;
10729                 rates->purpose = IPW_RATE_CAPABILITIES;
10730                 ipw_add_cck_scan_rates(rates, LIBIPW_CCK_MODULATION,
10731                                        LIBIPW_CCK_DEFAULT_RATES_MASK);
10732                 if (priv->ieee->modulation & LIBIPW_OFDM_MODULATION) {
10733                         ipw_add_ofdm_scan_rates(rates, LIBIPW_CCK_MODULATION,
10734                                                 LIBIPW_OFDM_DEFAULT_RATES_MASK);
10735                 }
10736                 break;
10737         }
10738
10739         return 0;
10740 }
10741
10742 static int ipw_config(struct ipw_priv *priv)
10743 {
10744         /* This is only called from ipw_up, which resets/reloads the firmware
10745            so, we don't need to first disable the card before we configure
10746            it */
10747         if (ipw_set_tx_power(priv))
10748                 goto error;
10749
10750         /* initialize adapter address */
10751         if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10752                 goto error;
10753
10754         /* set basic system config settings */
10755         init_sys_config(&priv->sys_config);
10756
10757         /* Support Bluetooth if we have BT h/w on board, and user wants to.
10758          * Does not support BT priority yet (don't abort or defer our Tx) */
10759         if (bt_coexist) {
10760                 unsigned char bt_caps = priv->eeprom[EEPROM_SKU_CAPABILITY];
10761
10762                 if (bt_caps & EEPROM_SKU_CAP_BT_CHANNEL_SIG)
10763                         priv->sys_config.bt_coexistence
10764                             |= CFG_BT_COEXISTENCE_SIGNAL_CHNL;
10765                 if (bt_caps & EEPROM_SKU_CAP_BT_OOB)
10766                         priv->sys_config.bt_coexistence
10767                             |= CFG_BT_COEXISTENCE_OOB;
10768         }
10769
10770 #ifdef CONFIG_IPW2200_PROMISCUOUS
10771         if (priv->prom_net_dev && netif_running(priv->prom_net_dev)) {
10772                 priv->sys_config.accept_all_data_frames = 1;
10773                 priv->sys_config.accept_non_directed_frames = 1;
10774                 priv->sys_config.accept_all_mgmt_bcpr = 1;
10775                 priv->sys_config.accept_all_mgmt_frames = 1;
10776         }
10777 #endif
10778
10779         if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10780                 priv->sys_config.answer_broadcast_ssid_probe = 1;
10781         else
10782                 priv->sys_config.answer_broadcast_ssid_probe = 0;
10783
10784         if (ipw_send_system_config(priv))
10785                 goto error;
10786
10787         init_supported_rates(priv, &priv->rates);
10788         if (ipw_send_supported_rates(priv, &priv->rates))
10789                 goto error;
10790
10791         /* Set request-to-send threshold */
10792         if (priv->rts_threshold) {
10793                 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10794                         goto error;
10795         }
10796 #ifdef CONFIG_IPW2200_QOS
10797         IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10798         ipw_qos_activate(priv, NULL);
10799 #endif                          /* CONFIG_IPW2200_QOS */
10800
10801         if (ipw_set_random_seed(priv))
10802                 goto error;
10803
10804         /* final state transition to the RUN state */
10805         if (ipw_send_host_complete(priv))
10806                 goto error;
10807
10808         priv->status |= STATUS_INIT;
10809
10810         ipw_led_init(priv);
10811         ipw_led_radio_on(priv);
10812         priv->notif_missed_beacons = 0;
10813
10814         /* Set hardware WEP key if it is configured. */
10815         if ((priv->capability & CAP_PRIVACY_ON) &&
10816             (priv->ieee->sec.level == SEC_LEVEL_1) &&
10817             !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10818                 ipw_set_hwcrypto_keys(priv);
10819
10820         return 0;
10821
10822       error:
10823         return -EIO;
10824 }
10825
10826 /*
10827  * NOTE:
10828  *
10829  * These tables have been tested in conjunction with the
10830  * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
10831  *
10832  * Altering this values, using it on other hardware, or in geographies
10833  * not intended for resale of the above mentioned Intel adapters has
10834  * not been tested.
10835  *
10836  * Remember to update the table in README.ipw2200 when changing this
10837  * table.
10838  *
10839  */
10840 static const struct libipw_geo ipw_geos[] = {
10841         {                       /* Restricted */
10842          "---",
10843          .bg_channels = 11,
10844          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10845                 {2427, 4}, {2432, 5}, {2437, 6},
10846                 {2442, 7}, {2447, 8}, {2452, 9},
10847                 {2457, 10}, {2462, 11}},
10848          },
10849
10850         {                       /* Custom US/Canada */
10851          "ZZF",
10852          .bg_channels = 11,
10853          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10854                 {2427, 4}, {2432, 5}, {2437, 6},
10855                 {2442, 7}, {2447, 8}, {2452, 9},
10856                 {2457, 10}, {2462, 11}},
10857          .a_channels = 8,
10858          .a = {{5180, 36},
10859                {5200, 40},
10860                {5220, 44},
10861                {5240, 48},
10862                {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
10863                {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
10864                {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
10865                {5320, 64, LIBIPW_CH_PASSIVE_ONLY}},
10866          },
10867
10868         {                       /* Rest of World */
10869          "ZZD",
10870          .bg_channels = 13,
10871          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10872                 {2427, 4}, {2432, 5}, {2437, 6},
10873                 {2442, 7}, {2447, 8}, {2452, 9},
10874                 {2457, 10}, {2462, 11}, {2467, 12},
10875                 {2472, 13}},
10876          },
10877
10878         {                       /* Custom USA & Europe & High */
10879          "ZZA",
10880          .bg_channels = 11,
10881          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10882                 {2427, 4}, {2432, 5}, {2437, 6},
10883                 {2442, 7}, {2447, 8}, {2452, 9},
10884                 {2457, 10}, {2462, 11}},
10885          .a_channels = 13,
10886          .a = {{5180, 36},
10887                {5200, 40},
10888                {5220, 44},
10889                {5240, 48},
10890                {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
10891                {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
10892                {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
10893                {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
10894                {5745, 149},
10895                {5765, 153},
10896                {5785, 157},
10897                {5805, 161},
10898                {5825, 165}},
10899          },
10900
10901         {                       /* Custom NA & Europe */
10902          "ZZB",
10903          .bg_channels = 11,
10904          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10905                 {2427, 4}, {2432, 5}, {2437, 6},
10906                 {2442, 7}, {2447, 8}, {2452, 9},
10907                 {2457, 10}, {2462, 11}},
10908          .a_channels = 13,
10909          .a = {{5180, 36},
10910                {5200, 40},
10911                {5220, 44},
10912                {5240, 48},
10913                {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
10914                {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
10915                {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
10916                {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
10917                {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
10918                {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
10919                {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
10920                {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
10921                {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
10922          },
10923
10924         {                       /* Custom Japan */
10925          "ZZC",
10926          .bg_channels = 11,
10927          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10928                 {2427, 4}, {2432, 5}, {2437, 6},
10929                 {2442, 7}, {2447, 8}, {2452, 9},
10930                 {2457, 10}, {2462, 11}},
10931          .a_channels = 4,
10932          .a = {{5170, 34}, {5190, 38},
10933                {5210, 42}, {5230, 46}},
10934          },
10935
10936         {                       /* Custom */
10937          "ZZM",
10938          .bg_channels = 11,
10939          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10940                 {2427, 4}, {2432, 5}, {2437, 6},
10941                 {2442, 7}, {2447, 8}, {2452, 9},
10942                 {2457, 10}, {2462, 11}},
10943          },
10944
10945         {                       /* Europe */
10946          "ZZE",
10947          .bg_channels = 13,
10948          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10949                 {2427, 4}, {2432, 5}, {2437, 6},
10950                 {2442, 7}, {2447, 8}, {2452, 9},
10951                 {2457, 10}, {2462, 11}, {2467, 12},
10952                 {2472, 13}},
10953          .a_channels = 19,
10954          .a = {{5180, 36},
10955                {5200, 40},
10956                {5220, 44},
10957                {5240, 48},
10958                {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
10959                {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
10960                {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
10961                {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
10962                {5500, 100, LIBIPW_CH_PASSIVE_ONLY},
10963                {5520, 104, LIBIPW_CH_PASSIVE_ONLY},
10964                {5540, 108, LIBIPW_CH_PASSIVE_ONLY},
10965                {5560, 112, LIBIPW_CH_PASSIVE_ONLY},
10966                {5580, 116, LIBIPW_CH_PASSIVE_ONLY},
10967                {5600, 120, LIBIPW_CH_PASSIVE_ONLY},
10968                {5620, 124, LIBIPW_CH_PASSIVE_ONLY},
10969                {5640, 128, LIBIPW_CH_PASSIVE_ONLY},
10970                {5660, 132, LIBIPW_CH_PASSIVE_ONLY},
10971                {5680, 136, LIBIPW_CH_PASSIVE_ONLY},
10972                {5700, 140, LIBIPW_CH_PASSIVE_ONLY}},
10973          },
10974
10975         {                       /* Custom Japan */
10976          "ZZJ",
10977          .bg_channels = 14,
10978          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10979                 {2427, 4}, {2432, 5}, {2437, 6},
10980                 {2442, 7}, {2447, 8}, {2452, 9},
10981                 {2457, 10}, {2462, 11}, {2467, 12},
10982                 {2472, 13}, {2484, 14, LIBIPW_CH_B_ONLY}},
10983          .a_channels = 4,
10984          .a = {{5170, 34}, {5190, 38},
10985                {5210, 42}, {5230, 46}},
10986          },
10987
10988         {                       /* Rest of World */
10989          "ZZR",
10990          .bg_channels = 14,
10991          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10992                 {2427, 4}, {2432, 5}, {2437, 6},
10993                 {2442, 7}, {2447, 8}, {2452, 9},
10994                 {2457, 10}, {2462, 11}, {2467, 12},
10995                 {2472, 13}, {2484, 14, LIBIPW_CH_B_ONLY |
10996                              LIBIPW_CH_PASSIVE_ONLY}},
10997          },
10998
10999         {                       /* High Band */
11000          "ZZH",
11001          .bg_channels = 13,
11002          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11003                 {2427, 4}, {2432, 5}, {2437, 6},
11004                 {2442, 7}, {2447, 8}, {2452, 9},
11005                 {2457, 10}, {2462, 11},
11006                 {2467, 12, LIBIPW_CH_PASSIVE_ONLY},
11007                 {2472, 13, LIBIPW_CH_PASSIVE_ONLY}},
11008          .a_channels = 4,
11009          .a = {{5745, 149}, {5765, 153},
11010                {5785, 157}, {5805, 161}},
11011          },
11012
11013         {                       /* Custom Europe */
11014          "ZZG",
11015          .bg_channels = 13,
11016          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11017                 {2427, 4}, {2432, 5}, {2437, 6},
11018                 {2442, 7}, {2447, 8}, {2452, 9},
11019                 {2457, 10}, {2462, 11},
11020                 {2467, 12}, {2472, 13}},
11021          .a_channels = 4,
11022          .a = {{5180, 36}, {5200, 40},
11023                {5220, 44}, {5240, 48}},
11024          },
11025
11026         {                       /* Europe */
11027          "ZZK",
11028          .bg_channels = 13,
11029          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11030                 {2427, 4}, {2432, 5}, {2437, 6},
11031                 {2442, 7}, {2447, 8}, {2452, 9},
11032                 {2457, 10}, {2462, 11},
11033                 {2467, 12, LIBIPW_CH_PASSIVE_ONLY},
11034                 {2472, 13, LIBIPW_CH_PASSIVE_ONLY}},
11035          .a_channels = 24,
11036          .a = {{5180, 36, LIBIPW_CH_PASSIVE_ONLY},
11037                {5200, 40, LIBIPW_CH_PASSIVE_ONLY},
11038                {5220, 44, LIBIPW_CH_PASSIVE_ONLY},
11039                {5240, 48, LIBIPW_CH_PASSIVE_ONLY},
11040                {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11041                {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11042                {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11043                {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11044                {5500, 100, LIBIPW_CH_PASSIVE_ONLY},
11045                {5520, 104, LIBIPW_CH_PASSIVE_ONLY},
11046                {5540, 108, LIBIPW_CH_PASSIVE_ONLY},
11047                {5560, 112, LIBIPW_CH_PASSIVE_ONLY},
11048                {5580, 116, LIBIPW_CH_PASSIVE_ONLY},
11049                {5600, 120, LIBIPW_CH_PASSIVE_ONLY},
11050                {5620, 124, LIBIPW_CH_PASSIVE_ONLY},
11051                {5640, 128, LIBIPW_CH_PASSIVE_ONLY},
11052                {5660, 132, LIBIPW_CH_PASSIVE_ONLY},
11053                {5680, 136, LIBIPW_CH_PASSIVE_ONLY},
11054                {5700, 140, LIBIPW_CH_PASSIVE_ONLY},
11055                {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
11056                {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
11057                {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
11058                {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
11059                {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
11060          },
11061
11062         {                       /* Europe */
11063          "ZZL",
11064          .bg_channels = 11,
11065          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
11066                 {2427, 4}, {2432, 5}, {2437, 6},
11067                 {2442, 7}, {2447, 8}, {2452, 9},
11068                 {2457, 10}, {2462, 11}},
11069          .a_channels = 13,
11070          .a = {{5180, 36, LIBIPW_CH_PASSIVE_ONLY},
11071                {5200, 40, LIBIPW_CH_PASSIVE_ONLY},
11072                {5220, 44, LIBIPW_CH_PASSIVE_ONLY},
11073                {5240, 48, LIBIPW_CH_PASSIVE_ONLY},
11074                {5260, 52, LIBIPW_CH_PASSIVE_ONLY},
11075                {5280, 56, LIBIPW_CH_PASSIVE_ONLY},
11076                {5300, 60, LIBIPW_CH_PASSIVE_ONLY},
11077                {5320, 64, LIBIPW_CH_PASSIVE_ONLY},
11078                {5745, 149, LIBIPW_CH_PASSIVE_ONLY},
11079                {5765, 153, LIBIPW_CH_PASSIVE_ONLY},
11080                {5785, 157, LIBIPW_CH_PASSIVE_ONLY},
11081                {5805, 161, LIBIPW_CH_PASSIVE_ONLY},
11082                {5825, 165, LIBIPW_CH_PASSIVE_ONLY}},
11083          }
11084 };
11085
11086 static void ipw_set_geo(struct ipw_priv *priv)
11087 {
11088         int j;
11089
11090         for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
11091                 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
11092                             ipw_geos[j].name, 3))
11093                         break;
11094         }
11095
11096         if (j == ARRAY_SIZE(ipw_geos)) {
11097                 IPW_WARNING("SKU [%c%c%c] not recognized.\n",
11098                             priv->eeprom[EEPROM_COUNTRY_CODE + 0],
11099                             priv->eeprom[EEPROM_COUNTRY_CODE + 1],
11100                             priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
11101                 j = 0;
11102         }
11103
11104         libipw_set_geo(priv->ieee, &ipw_geos[j]);
11105 }
11106
11107 #define MAX_HW_RESTARTS 5
11108 static int ipw_up(struct ipw_priv *priv)
11109 {
11110         int rc, i;
11111
11112         /* Age scan list entries found before suspend */
11113         if (priv->suspend_time) {
11114                 libipw_networks_age(priv->ieee, priv->suspend_time);
11115                 priv->suspend_time = 0;
11116         }
11117
11118         if (priv->status & STATUS_EXIT_PENDING)
11119                 return -EIO;
11120
11121         if (cmdlog && !priv->cmdlog) {
11122                 priv->cmdlog = kcalloc(cmdlog, sizeof(*priv->cmdlog),
11123                                        GFP_KERNEL);
11124                 if (priv->cmdlog == NULL) {
11125                         IPW_ERROR("Error allocating %d command log entries.\n",
11126                                   cmdlog);
11127                         return -ENOMEM;
11128                 } else {
11129                         priv->cmdlog_len = cmdlog;
11130                 }
11131         }
11132
11133         for (i = 0; i < MAX_HW_RESTARTS; i++) {
11134                 /* Load the microcode, firmware, and eeprom.
11135                  * Also start the clocks. */
11136                 rc = ipw_load(priv);
11137                 if (rc) {
11138                         IPW_ERROR("Unable to load firmware: %d\n", rc);
11139                         return rc;
11140                 }
11141
11142                 ipw_init_ordinals(priv);
11143                 if (!(priv->config & CFG_CUSTOM_MAC))
11144                         eeprom_parse_mac(priv, priv->mac_addr);
11145                 eth_hw_addr_set(priv->net_dev, priv->mac_addr);
11146
11147                 ipw_set_geo(priv);
11148
11149                 if (priv->status & STATUS_RF_KILL_SW) {
11150                         IPW_WARNING("Radio disabled by module parameter.\n");
11151                         return 0;
11152                 } else if (rf_kill_active(priv)) {
11153                         IPW_WARNING("Radio Frequency Kill Switch is On:\n"
11154                                     "Kill switch must be turned off for "
11155                                     "wireless networking to work.\n");
11156                         schedule_delayed_work(&priv->rf_kill, 2 * HZ);
11157                         return 0;
11158                 }
11159
11160                 rc = ipw_config(priv);
11161                 if (!rc) {
11162                         IPW_DEBUG_INFO("Configured device on count %i\n", i);
11163
11164                         /* If configure to try and auto-associate, kick
11165                          * off a scan. */
11166                         schedule_delayed_work(&priv->request_scan, 0);
11167
11168                         return 0;
11169                 }
11170
11171                 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
11172                 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
11173                                i, MAX_HW_RESTARTS);
11174
11175                 /* We had an error bringing up the hardware, so take it
11176                  * all the way back down so we can try again */
11177                 ipw_down(priv);
11178         }
11179
11180         /* tried to restart and config the device for as long as our
11181          * patience could withstand */
11182         IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
11183
11184         return -EIO;
11185 }
11186
11187 static void ipw_bg_up(struct work_struct *work)
11188 {
11189         struct ipw_priv *priv =
11190                 container_of(work, struct ipw_priv, up);
11191         mutex_lock(&priv->mutex);
11192         ipw_up(priv);
11193         mutex_unlock(&priv->mutex);
11194 }
11195
11196 static void ipw_deinit(struct ipw_priv *priv)
11197 {
11198         int i;
11199
11200         if (priv->status & STATUS_SCANNING) {
11201                 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
11202                 ipw_abort_scan(priv);
11203         }
11204
11205         if (priv->status & STATUS_ASSOCIATED) {
11206                 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
11207                 ipw_disassociate(priv);
11208         }
11209
11210         ipw_led_shutdown(priv);
11211
11212         /* Wait up to 1s for status to change to not scanning and not
11213          * associated (disassociation can take a while for a ful 802.11
11214          * exchange */
11215         for (i = 1000; i && (priv->status &
11216                              (STATUS_DISASSOCIATING |
11217                               STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
11218                 udelay(10);
11219
11220         if (priv->status & (STATUS_DISASSOCIATING |
11221                             STATUS_ASSOCIATED | STATUS_SCANNING))
11222                 IPW_DEBUG_INFO("Still associated or scanning...\n");
11223         else
11224                 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
11225
11226         /* Attempt to disable the card */
11227         ipw_send_card_disable(priv, 0);
11228
11229         priv->status &= ~STATUS_INIT;
11230 }
11231
11232 static void ipw_down(struct ipw_priv *priv)
11233 {
11234         int exit_pending = priv->status & STATUS_EXIT_PENDING;
11235
11236         priv->status |= STATUS_EXIT_PENDING;
11237
11238         if (ipw_is_init(priv))
11239                 ipw_deinit(priv);
11240
11241         /* Wipe out the EXIT_PENDING status bit if we are not actually
11242          * exiting the module */
11243         if (!exit_pending)
11244                 priv->status &= ~STATUS_EXIT_PENDING;
11245
11246         /* tell the device to stop sending interrupts */
11247         ipw_disable_interrupts(priv);
11248
11249         /* Clear all bits but the RF Kill */
11250         priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
11251         netif_carrier_off(priv->net_dev);
11252
11253         ipw_stop_nic(priv);
11254
11255         ipw_led_radio_off(priv);
11256 }
11257
11258 static void ipw_bg_down(struct work_struct *work)
11259 {
11260         struct ipw_priv *priv =
11261                 container_of(work, struct ipw_priv, down);
11262         mutex_lock(&priv->mutex);
11263         ipw_down(priv);
11264         mutex_unlock(&priv->mutex);
11265 }
11266
11267 static int ipw_wdev_init(struct net_device *dev)
11268 {
11269         int i, rc = 0;
11270         struct ipw_priv *priv = libipw_priv(dev);
11271         const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
11272         struct wireless_dev *wdev = &priv->ieee->wdev;
11273
11274         memcpy(wdev->wiphy->perm_addr, priv->mac_addr, ETH_ALEN);
11275
11276         /* fill-out priv->ieee->bg_band */
11277         if (geo->bg_channels) {
11278                 struct ieee80211_supported_band *bg_band = &priv->ieee->bg_band;
11279
11280                 bg_band->band = NL80211_BAND_2GHZ;
11281                 bg_band->n_channels = geo->bg_channels;
11282                 bg_band->channels = kcalloc(geo->bg_channels,
11283                                             sizeof(struct ieee80211_channel),
11284                                             GFP_KERNEL);
11285                 if (!bg_band->channels) {
11286                         rc = -ENOMEM;
11287                         goto out;
11288                 }
11289                 /* translate geo->bg to bg_band.channels */
11290                 for (i = 0; i < geo->bg_channels; i++) {
11291                         bg_band->channels[i].band = NL80211_BAND_2GHZ;
11292                         bg_band->channels[i].center_freq = geo->bg[i].freq;
11293                         bg_band->channels[i].hw_value = geo->bg[i].channel;
11294                         bg_band->channels[i].max_power = geo->bg[i].max_power;
11295                         if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY)
11296                                 bg_band->channels[i].flags |=
11297                                         IEEE80211_CHAN_NO_IR;
11298                         if (geo->bg[i].flags & LIBIPW_CH_NO_IBSS)
11299                                 bg_band->channels[i].flags |=
11300                                         IEEE80211_CHAN_NO_IR;
11301                         if (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT)
11302                                 bg_band->channels[i].flags |=
11303                                         IEEE80211_CHAN_RADAR;
11304                         /* No equivalent for LIBIPW_CH_80211H_RULES,
11305                            LIBIPW_CH_UNIFORM_SPREADING, or
11306                            LIBIPW_CH_B_ONLY... */
11307                 }
11308                 /* point at bitrate info */
11309                 bg_band->bitrates = ipw2200_bg_rates;
11310                 bg_band->n_bitrates = ipw2200_num_bg_rates;
11311
11312                 wdev->wiphy->bands[NL80211_BAND_2GHZ] = bg_band;
11313         }
11314
11315         /* fill-out priv->ieee->a_band */
11316         if (geo->a_channels) {
11317                 struct ieee80211_supported_band *a_band = &priv->ieee->a_band;
11318
11319                 a_band->band = NL80211_BAND_5GHZ;
11320                 a_band->n_channels = geo->a_channels;
11321                 a_band->channels = kcalloc(geo->a_channels,
11322                                            sizeof(struct ieee80211_channel),
11323                                            GFP_KERNEL);
11324                 if (!a_band->channels) {
11325                         rc = -ENOMEM;
11326                         goto out;
11327                 }
11328                 /* translate geo->a to a_band.channels */
11329                 for (i = 0; i < geo->a_channels; i++) {
11330                         a_band->channels[i].band = NL80211_BAND_5GHZ;
11331                         a_band->channels[i].center_freq = geo->a[i].freq;
11332                         a_band->channels[i].hw_value = geo->a[i].channel;
11333                         a_band->channels[i].max_power = geo->a[i].max_power;
11334                         if (geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY)
11335                                 a_band->channels[i].flags |=
11336                                         IEEE80211_CHAN_NO_IR;
11337                         if (geo->a[i].flags & LIBIPW_CH_NO_IBSS)
11338                                 a_band->channels[i].flags |=
11339                                         IEEE80211_CHAN_NO_IR;
11340                         if (geo->a[i].flags & LIBIPW_CH_RADAR_DETECT)
11341                                 a_band->channels[i].flags |=
11342                                         IEEE80211_CHAN_RADAR;
11343                         /* No equivalent for LIBIPW_CH_80211H_RULES,
11344                            LIBIPW_CH_UNIFORM_SPREADING, or
11345                            LIBIPW_CH_B_ONLY... */
11346                 }
11347                 /* point at bitrate info */
11348                 a_band->bitrates = ipw2200_a_rates;
11349                 a_band->n_bitrates = ipw2200_num_a_rates;
11350
11351                 wdev->wiphy->bands[NL80211_BAND_5GHZ] = a_band;
11352         }
11353
11354         wdev->wiphy->cipher_suites = ipw_cipher_suites;
11355         wdev->wiphy->n_cipher_suites = ARRAY_SIZE(ipw_cipher_suites);
11356
11357         set_wiphy_dev(wdev->wiphy, &priv->pci_dev->dev);
11358
11359         /* With that information in place, we can now register the wiphy... */
11360         rc = wiphy_register(wdev->wiphy);
11361         if (rc)
11362                 goto out;
11363
11364         return 0;
11365 out:
11366         kfree(priv->ieee->a_band.channels);
11367         kfree(priv->ieee->bg_band.channels);
11368         return rc;
11369 }
11370
11371 /* PCI driver stuff */
11372 static const struct pci_device_id card_ids[] = {
11373         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
11374         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
11375         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
11376         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
11377         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
11378         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
11379         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
11380         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
11381         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
11382         {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
11383         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
11384         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
11385         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
11386         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
11387         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
11388         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
11389         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
11390         {PCI_VDEVICE(INTEL, 0x104f), 0},
11391         {PCI_VDEVICE(INTEL, 0x4220), 0},        /* BG */
11392         {PCI_VDEVICE(INTEL, 0x4221), 0},        /* BG */
11393         {PCI_VDEVICE(INTEL, 0x4223), 0},        /* ABG */
11394         {PCI_VDEVICE(INTEL, 0x4224), 0},        /* ABG */
11395
11396         /* required last entry */
11397         {0,}
11398 };
11399
11400 MODULE_DEVICE_TABLE(pci, card_ids);
11401
11402 static struct attribute *ipw_sysfs_entries[] = {
11403         &dev_attr_rf_kill.attr,
11404         &dev_attr_direct_dword.attr,
11405         &dev_attr_indirect_byte.attr,
11406         &dev_attr_indirect_dword.attr,
11407         &dev_attr_mem_gpio_reg.attr,
11408         &dev_attr_command_event_reg.attr,
11409         &dev_attr_nic_type.attr,
11410         &dev_attr_status.attr,
11411         &dev_attr_cfg.attr,
11412         &dev_attr_error.attr,
11413         &dev_attr_event_log.attr,
11414         &dev_attr_cmd_log.attr,
11415         &dev_attr_eeprom_delay.attr,
11416         &dev_attr_ucode_version.attr,
11417         &dev_attr_rtc.attr,
11418         &dev_attr_scan_age.attr,
11419         &dev_attr_led.attr,
11420         &dev_attr_speed_scan.attr,
11421         &dev_attr_net_stats.attr,
11422         &dev_attr_channels.attr,
11423 #ifdef CONFIG_IPW2200_PROMISCUOUS
11424         &dev_attr_rtap_iface.attr,
11425         &dev_attr_rtap_filter.attr,
11426 #endif
11427         NULL
11428 };
11429
11430 static const struct attribute_group ipw_attribute_group = {
11431         .name = NULL,           /* put in device directory */
11432         .attrs = ipw_sysfs_entries,
11433 };
11434
11435 #ifdef CONFIG_IPW2200_PROMISCUOUS
11436 static int ipw_prom_open(struct net_device *dev)
11437 {
11438         struct ipw_prom_priv *prom_priv = libipw_priv(dev);
11439         struct ipw_priv *priv = prom_priv->priv;
11440
11441         IPW_DEBUG_INFO("prom dev->open\n");
11442         netif_carrier_off(dev);
11443
11444         if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
11445                 priv->sys_config.accept_all_data_frames = 1;
11446                 priv->sys_config.accept_non_directed_frames = 1;
11447                 priv->sys_config.accept_all_mgmt_bcpr = 1;
11448                 priv->sys_config.accept_all_mgmt_frames = 1;
11449
11450                 ipw_send_system_config(priv);
11451         }
11452
11453         return 0;
11454 }
11455
11456 static int ipw_prom_stop(struct net_device *dev)
11457 {
11458         struct ipw_prom_priv *prom_priv = libipw_priv(dev);
11459         struct ipw_priv *priv = prom_priv->priv;
11460
11461         IPW_DEBUG_INFO("prom dev->stop\n");
11462
11463         if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
11464                 priv->sys_config.accept_all_data_frames = 0;
11465                 priv->sys_config.accept_non_directed_frames = 0;
11466                 priv->sys_config.accept_all_mgmt_bcpr = 0;
11467                 priv->sys_config.accept_all_mgmt_frames = 0;
11468
11469                 ipw_send_system_config(priv);
11470         }
11471
11472         return 0;
11473 }
11474
11475 static netdev_tx_t ipw_prom_hard_start_xmit(struct sk_buff *skb,
11476                                             struct net_device *dev)
11477 {
11478         IPW_DEBUG_INFO("prom dev->xmit\n");
11479         dev_kfree_skb(skb);
11480         return NETDEV_TX_OK;
11481 }
11482
11483 static const struct net_device_ops ipw_prom_netdev_ops = {
11484         .ndo_open               = ipw_prom_open,
11485         .ndo_stop               = ipw_prom_stop,
11486         .ndo_start_xmit         = ipw_prom_hard_start_xmit,
11487         .ndo_set_mac_address    = eth_mac_addr,
11488         .ndo_validate_addr      = eth_validate_addr,
11489 };
11490
11491 static int ipw_prom_alloc(struct ipw_priv *priv)
11492 {
11493         int rc = 0;
11494
11495         if (priv->prom_net_dev)
11496                 return -EPERM;
11497
11498         priv->prom_net_dev = alloc_libipw(sizeof(struct ipw_prom_priv), 1);
11499         if (priv->prom_net_dev == NULL)
11500                 return -ENOMEM;
11501
11502         priv->prom_priv = libipw_priv(priv->prom_net_dev);
11503         priv->prom_priv->ieee = netdev_priv(priv->prom_net_dev);
11504         priv->prom_priv->priv = priv;
11505
11506         strcpy(priv->prom_net_dev->name, "rtap%d");
11507         eth_hw_addr_set(priv->prom_net_dev, priv->mac_addr);
11508
11509         priv->prom_net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
11510         priv->prom_net_dev->netdev_ops = &ipw_prom_netdev_ops;
11511
11512         priv->prom_net_dev->min_mtu = 68;
11513         priv->prom_net_dev->max_mtu = LIBIPW_DATA_LEN;
11514
11515         priv->prom_priv->ieee->iw_mode = IW_MODE_MONITOR;
11516         SET_NETDEV_DEV(priv->prom_net_dev, &priv->pci_dev->dev);
11517
11518         rc = register_netdev(priv->prom_net_dev);
11519         if (rc) {
11520                 free_libipw(priv->prom_net_dev, 1);
11521                 priv->prom_net_dev = NULL;
11522                 return rc;
11523         }
11524
11525         return 0;
11526 }
11527
11528 static void ipw_prom_free(struct ipw_priv *priv)
11529 {
11530         if (!priv->prom_net_dev)
11531                 return;
11532
11533         unregister_netdev(priv->prom_net_dev);
11534         free_libipw(priv->prom_net_dev, 1);
11535
11536         priv->prom_net_dev = NULL;
11537 }
11538
11539 #endif
11540
11541 static const struct net_device_ops ipw_netdev_ops = {
11542         .ndo_open               = ipw_net_open,
11543         .ndo_stop               = ipw_net_stop,
11544         .ndo_set_rx_mode        = ipw_net_set_multicast_list,
11545         .ndo_set_mac_address    = ipw_net_set_mac_address,
11546         .ndo_start_xmit         = libipw_xmit,
11547         .ndo_validate_addr      = eth_validate_addr,
11548 };
11549
11550 static int ipw_pci_probe(struct pci_dev *pdev,
11551                                    const struct pci_device_id *ent)
11552 {
11553         int err = 0;
11554         struct net_device *net_dev;
11555         void __iomem *base;
11556         u32 length, val;
11557         struct ipw_priv *priv;
11558         int i;
11559
11560         net_dev = alloc_libipw(sizeof(struct ipw_priv), 0);
11561         if (net_dev == NULL) {
11562                 err = -ENOMEM;
11563                 goto out;
11564         }
11565
11566         priv = libipw_priv(net_dev);
11567         priv->ieee = netdev_priv(net_dev);
11568
11569         priv->net_dev = net_dev;
11570         priv->pci_dev = pdev;
11571         ipw_debug_level = debug;
11572         spin_lock_init(&priv->irq_lock);
11573         spin_lock_init(&priv->lock);
11574         for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
11575                 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
11576
11577         mutex_init(&priv->mutex);
11578         if (pci_enable_device(pdev)) {
11579                 err = -ENODEV;
11580                 goto out_free_libipw;
11581         }
11582
11583         pci_set_master(pdev);
11584
11585         err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
11586         if (!err)
11587                 err = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
11588         if (err) {
11589                 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
11590                 goto out_pci_disable_device;
11591         }
11592
11593         pci_set_drvdata(pdev, priv);
11594
11595         err = pci_request_regions(pdev, DRV_NAME);
11596         if (err)
11597                 goto out_pci_disable_device;
11598
11599         /* We disable the RETRY_TIMEOUT register (0x41) to keep
11600          * PCI Tx retries from interfering with C3 CPU state */
11601         pci_read_config_dword(pdev, 0x40, &val);
11602         if ((val & 0x0000ff00) != 0)
11603                 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11604
11605         length = pci_resource_len(pdev, 0);
11606         priv->hw_len = length;
11607
11608         base = pci_ioremap_bar(pdev, 0);
11609         if (!base) {
11610                 err = -ENODEV;
11611                 goto out_pci_release_regions;
11612         }
11613
11614         priv->hw_base = base;
11615         IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
11616         IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
11617
11618         ipw_setup_deferred_work(priv);
11619
11620         ipw_sw_reset(priv, 1);
11621
11622         err = request_irq(pdev->irq, ipw_isr, IRQF_SHARED, DRV_NAME, priv);
11623         if (err) {
11624                 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
11625                 goto out_iounmap;
11626         }
11627
11628         SET_NETDEV_DEV(net_dev, &pdev->dev);
11629
11630         mutex_lock(&priv->mutex);
11631
11632         priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
11633         priv->ieee->set_security = shim__set_security;
11634         priv->ieee->is_queue_full = ipw_net_is_queue_full;
11635
11636 #ifdef CONFIG_IPW2200_QOS
11637         priv->ieee->is_qos_active = ipw_is_qos_active;
11638         priv->ieee->handle_probe_response = ipw_handle_beacon;
11639         priv->ieee->handle_beacon = ipw_handle_probe_response;
11640         priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
11641 #endif                          /* CONFIG_IPW2200_QOS */
11642
11643         priv->ieee->perfect_rssi = -20;
11644         priv->ieee->worst_rssi = -85;
11645
11646         net_dev->netdev_ops = &ipw_netdev_ops;
11647         priv->ieee->spy_enabled = true;
11648         net_dev->wireless_handlers = &ipw_wx_handler_def;
11649         net_dev->ethtool_ops = &ipw_ethtool_ops;
11650
11651         net_dev->min_mtu = 68;
11652         net_dev->max_mtu = LIBIPW_DATA_LEN;
11653
11654         err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
11655         if (err) {
11656                 IPW_ERROR("failed to create sysfs device attributes\n");
11657                 mutex_unlock(&priv->mutex);
11658                 goto out_release_irq;
11659         }
11660
11661         if (ipw_up(priv)) {
11662                 mutex_unlock(&priv->mutex);
11663                 err = -EIO;
11664                 goto out_remove_sysfs;
11665         }
11666
11667         mutex_unlock(&priv->mutex);
11668
11669         err = ipw_wdev_init(net_dev);
11670         if (err) {
11671                 IPW_ERROR("failed to register wireless device\n");
11672                 goto out_remove_sysfs;
11673         }
11674
11675         err = register_netdev(net_dev);
11676         if (err) {
11677                 IPW_ERROR("failed to register network device\n");
11678                 goto out_unregister_wiphy;
11679         }
11680
11681 #ifdef CONFIG_IPW2200_PROMISCUOUS
11682         if (rtap_iface) {
11683                 err = ipw_prom_alloc(priv);
11684                 if (err) {
11685                         IPW_ERROR("Failed to register promiscuous network "
11686                                   "device (error %d).\n", err);
11687                         unregister_netdev(priv->net_dev);
11688                         goto out_unregister_wiphy;
11689                 }
11690         }
11691 #endif
11692
11693         printk(KERN_INFO DRV_NAME ": Detected geography %s (%d 802.11bg "
11694                "channels, %d 802.11a channels)\n",
11695                priv->ieee->geo.name, priv->ieee->geo.bg_channels,
11696                priv->ieee->geo.a_channels);
11697
11698         return 0;
11699
11700       out_unregister_wiphy:
11701         wiphy_unregister(priv->ieee->wdev.wiphy);
11702         kfree(priv->ieee->a_band.channels);
11703         kfree(priv->ieee->bg_band.channels);
11704       out_remove_sysfs:
11705         sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11706       out_release_irq:
11707         free_irq(pdev->irq, priv);
11708       out_iounmap:
11709         iounmap(priv->hw_base);
11710       out_pci_release_regions:
11711         pci_release_regions(pdev);
11712       out_pci_disable_device:
11713         pci_disable_device(pdev);
11714       out_free_libipw:
11715         free_libipw(priv->net_dev, 0);
11716       out:
11717         return err;
11718 }
11719
11720 static void ipw_pci_remove(struct pci_dev *pdev)
11721 {
11722         struct ipw_priv *priv = pci_get_drvdata(pdev);
11723         struct list_head *p, *q;
11724         int i;
11725
11726         if (!priv)
11727                 return;
11728
11729         mutex_lock(&priv->mutex);
11730
11731         priv->status |= STATUS_EXIT_PENDING;
11732         ipw_down(priv);
11733         sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11734
11735         mutex_unlock(&priv->mutex);
11736
11737         unregister_netdev(priv->net_dev);
11738
11739         if (priv->rxq) {
11740                 ipw_rx_queue_free(priv, priv->rxq);
11741                 priv->rxq = NULL;
11742         }
11743         ipw_tx_queue_free(priv);
11744
11745         if (priv->cmdlog) {
11746                 kfree(priv->cmdlog);
11747                 priv->cmdlog = NULL;
11748         }
11749
11750         /* make sure all works are inactive */
11751         cancel_delayed_work_sync(&priv->adhoc_check);
11752         cancel_work_sync(&priv->associate);
11753         cancel_work_sync(&priv->disassociate);
11754         cancel_work_sync(&priv->system_config);
11755         cancel_work_sync(&priv->rx_replenish);
11756         cancel_work_sync(&priv->adapter_restart);
11757         cancel_delayed_work_sync(&priv->rf_kill);
11758         cancel_work_sync(&priv->up);
11759         cancel_work_sync(&priv->down);
11760         cancel_delayed_work_sync(&priv->request_scan);
11761         cancel_delayed_work_sync(&priv->request_direct_scan);
11762         cancel_delayed_work_sync(&priv->request_passive_scan);
11763         cancel_delayed_work_sync(&priv->scan_event);
11764         cancel_delayed_work_sync(&priv->gather_stats);
11765         cancel_work_sync(&priv->abort_scan);
11766         cancel_work_sync(&priv->roam);
11767         cancel_delayed_work_sync(&priv->scan_check);
11768         cancel_work_sync(&priv->link_up);
11769         cancel_work_sync(&priv->link_down);
11770         cancel_delayed_work_sync(&priv->led_link_on);
11771         cancel_delayed_work_sync(&priv->led_link_off);
11772         cancel_delayed_work_sync(&priv->led_act_off);
11773         cancel_work_sync(&priv->merge_networks);
11774
11775         /* Free MAC hash list for ADHOC */
11776         for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11777                 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
11778                         list_del(p);
11779                         kfree(list_entry(p, struct ipw_ibss_seq, list));
11780                 }
11781         }
11782
11783         kfree(priv->error);
11784         priv->error = NULL;
11785
11786 #ifdef CONFIG_IPW2200_PROMISCUOUS
11787         ipw_prom_free(priv);
11788 #endif
11789
11790         free_irq(pdev->irq, priv);
11791         iounmap(priv->hw_base);
11792         pci_release_regions(pdev);
11793         pci_disable_device(pdev);
11794         /* wiphy_unregister needs to be here, before free_libipw */
11795         wiphy_unregister(priv->ieee->wdev.wiphy);
11796         kfree(priv->ieee->a_band.channels);
11797         kfree(priv->ieee->bg_band.channels);
11798         free_libipw(priv->net_dev, 0);
11799         free_firmware();
11800 }
11801
11802 static int __maybe_unused ipw_pci_suspend(struct device *dev_d)
11803 {
11804         struct ipw_priv *priv = dev_get_drvdata(dev_d);
11805         struct net_device *dev = priv->net_dev;
11806
11807         printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11808
11809         /* Take down the device; powers it off, etc. */
11810         ipw_down(priv);
11811
11812         /* Remove the PRESENT state of the device */
11813         netif_device_detach(dev);
11814
11815         priv->suspend_at = ktime_get_boottime_seconds();
11816
11817         return 0;
11818 }
11819
11820 static int __maybe_unused ipw_pci_resume(struct device *dev_d)
11821 {
11822         struct pci_dev *pdev = to_pci_dev(dev_d);
11823         struct ipw_priv *priv = pci_get_drvdata(pdev);
11824         struct net_device *dev = priv->net_dev;
11825         u32 val;
11826
11827         printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11828
11829         /*
11830          * Suspend/Resume resets the PCI configuration space, so we have to
11831          * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
11832          * from interfering with C3 CPU state. pci_restore_state won't help
11833          * here since it only restores the first 64 bytes pci config header.
11834          */
11835         pci_read_config_dword(pdev, 0x40, &val);
11836         if ((val & 0x0000ff00) != 0)
11837                 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11838
11839         /* Set the device back into the PRESENT state; this will also wake
11840          * the queue of needed */
11841         netif_device_attach(dev);
11842
11843         priv->suspend_time = ktime_get_boottime_seconds() - priv->suspend_at;
11844
11845         /* Bring the device back up */
11846         schedule_work(&priv->up);
11847
11848         return 0;
11849 }
11850
11851 static void ipw_pci_shutdown(struct pci_dev *pdev)
11852 {
11853         struct ipw_priv *priv = pci_get_drvdata(pdev);
11854
11855         /* Take down the device; powers it off, etc. */
11856         ipw_down(priv);
11857
11858         pci_disable_device(pdev);
11859 }
11860
11861 static SIMPLE_DEV_PM_OPS(ipw_pci_pm_ops, ipw_pci_suspend, ipw_pci_resume);
11862
11863 /* driver initialization stuff */
11864 static struct pci_driver ipw_driver = {
11865         .name = DRV_NAME,
11866         .id_table = card_ids,
11867         .probe = ipw_pci_probe,
11868         .remove = ipw_pci_remove,
11869         .driver.pm = &ipw_pci_pm_ops,
11870         .shutdown = ipw_pci_shutdown,
11871 };
11872
11873 static int __init ipw_init(void)
11874 {
11875         int ret;
11876
11877         printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
11878         printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
11879
11880         ret = pci_register_driver(&ipw_driver);
11881         if (ret) {
11882                 IPW_ERROR("Unable to initialize PCI module\n");
11883                 return ret;
11884         }
11885
11886         ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
11887         if (ret) {
11888                 IPW_ERROR("Unable to create driver sysfs file\n");
11889                 pci_unregister_driver(&ipw_driver);
11890                 return ret;
11891         }
11892
11893         return ret;
11894 }
11895
11896 static void __exit ipw_exit(void)
11897 {
11898         driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
11899         pci_unregister_driver(&ipw_driver);
11900 }
11901
11902 module_param(disable, int, 0444);
11903 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
11904
11905 module_param(associate, int, 0444);
11906 MODULE_PARM_DESC(associate, "auto associate when scanning (default off)");
11907
11908 module_param(auto_create, int, 0444);
11909 MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
11910
11911 module_param_named(led, led_support, int, 0444);
11912 MODULE_PARM_DESC(led, "enable led control on some systems (default 1 on)");
11913
11914 module_param(debug, int, 0444);
11915 MODULE_PARM_DESC(debug, "debug output mask");
11916
11917 module_param_named(channel, default_channel, int, 0444);
11918 MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
11919
11920 #ifdef CONFIG_IPW2200_PROMISCUOUS
11921 module_param(rtap_iface, int, 0444);
11922 MODULE_PARM_DESC(rtap_iface, "create the rtap interface (1 - create, default 0)");
11923 #endif
11924
11925 #ifdef CONFIG_IPW2200_QOS
11926 module_param(qos_enable, int, 0444);
11927 MODULE_PARM_DESC(qos_enable, "enable all QoS functionalities");
11928
11929 module_param(qos_burst_enable, int, 0444);
11930 MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
11931
11932 module_param(qos_no_ack_mask, int, 0444);
11933 MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
11934
11935 module_param(burst_duration_CCK, int, 0444);
11936 MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
11937
11938 module_param(burst_duration_OFDM, int, 0444);
11939 MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
11940 #endif                          /* CONFIG_IPW2200_QOS */
11941
11942 #ifdef CONFIG_IPW2200_MONITOR
11943 module_param_named(mode, network_mode, int, 0444);
11944 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
11945 #else
11946 module_param_named(mode, network_mode, int, 0444);
11947 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
11948 #endif
11949
11950 module_param(bt_coexist, int, 0444);
11951 MODULE_PARM_DESC(bt_coexist, "enable bluetooth coexistence (default off)");
11952
11953 module_param(hwcrypto, int, 0444);
11954 MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default off)");
11955
11956 module_param(cmdlog, int, 0444);
11957 MODULE_PARM_DESC(cmdlog,
11958                  "allocate a ring buffer for logging firmware commands");
11959
11960 module_param(roaming, int, 0444);
11961 MODULE_PARM_DESC(roaming, "enable roaming support (default on)");
11962
11963 module_param(antenna, int, 0444);
11964 MODULE_PARM_DESC(antenna, "select antenna 1=Main, 3=Aux, default 0 [both], 2=slow_diversity (choose the one with lower background noise)");
11965
11966 module_exit(ipw_exit);
11967 module_init(ipw_init);