drivers/net/wireless/ipw2200.c

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