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