SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/net/wireless/ipw2200.c

   1 /******************************************************************************
   2
   3   Copyright(c) 2003 - 2005 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.0.10"
  37 #define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2200/2915 Network Driver"
  38 #define DRV_COPYRIGHT   "Copyright(c) 2003-2005 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_header {
2833         u32 version;
2834         u32 mode;
2835 };
2836
2837 struct fw_chunk {
2838         u32 address;
2839         u32 length;
2840 };
2841
2842 #define IPW_FW_MAJOR_VERSION 2
2843 #define IPW_FW_MINOR_VERSION 4
2844
2845 #define IPW_FW_MINOR(x) ((x & 0xff) >> 8)
2846 #define IPW_FW_MAJOR(x) (x & 0xff)
2847
2848 #define IPW_FW_VERSION ((IPW_FW_MINOR_VERSION << 8) | IPW_FW_MAJOR_VERSION)
2849
2850 #define IPW_FW_PREFIX "ipw-" __stringify(IPW_FW_MAJOR_VERSION) \
2851 "." __stringify(IPW_FW_MINOR_VERSION) "-"
2852
2853 #if IPW_FW_MAJOR_VERSION >= 2 && IPW_FW_MINOR_VERSION > 0
2854 #define IPW_FW_NAME(x) IPW_FW_PREFIX "" x ".fw"
2855 #else
2856 #define IPW_FW_NAME(x) "ipw2200_" x ".fw"
2857 #endif
2858
2859 static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
2860 {
2861         int rc = 0, i, addr;
2862         u8 cr = 0;
2863         u16 *image;
2864
2865         image = (u16 *) data;
2866
2867         IPW_DEBUG_TRACE(">> \n");
2868
2869         rc = ipw_stop_master(priv);
2870
2871         if (rc < 0)
2872                 return rc;
2873
2874 //      spin_lock_irqsave(&priv->lock, flags);
2875
2876         for (addr = IPW_SHARED_LOWER_BOUND;
2877              addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
2878                 ipw_write32(priv, addr, 0);
2879         }
2880
2881         /* no ucode (yet) */
2882         memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
2883         /* destroy DMA queues */
2884         /* reset sequence */
2885
2886         ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_ON);
2887         ipw_arc_release(priv);
2888         ipw_write_reg32(priv, IPW_MEM_HALT_AND_RESET, IPW_BIT_HALT_RESET_OFF);
2889         mdelay(1);
2890
2891         /* reset PHY */
2892         ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, IPW_BASEBAND_POWER_DOWN);
2893         mdelay(1);
2894
2895         ipw_write_reg32(priv, IPW_INTERNAL_CMD_EVENT, 0);
2896         mdelay(1);
2897
2898         /* enable ucode store */
2899         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0x0);
2900         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_CS);
2901         mdelay(1);
2902
2903         /* write ucode */
2904         /**
2905          * @bug
2906          * Do NOT set indirect address register once and then
2907          * store data to indirect data register in the loop.
2908          * It seems very reasonable, but in this case DINO do not
2909          * accept ucode. It is essential to set address each time.
2910          */
2911         /* load new ipw uCode */
2912         for (i = 0; i < len / 2; i++)
2913                 ipw_write_reg16(priv, IPW_BASEBAND_CONTROL_STORE,
2914                                 cpu_to_le16(image[i]));
2915
2916         /* enable DINO */
2917         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2918         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, DINO_ENABLE_SYSTEM);
2919
2920         /* this is where the igx / win driver deveates from the VAP driver. */
2921
2922         /* wait for alive response */
2923         for (i = 0; i < 100; i++) {
2924                 /* poll for incoming data */
2925                 cr = ipw_read_reg8(priv, IPW_BASEBAND_CONTROL_STATUS);
2926                 if (cr & DINO_RXFIFO_DATA)
2927                         break;
2928                 mdelay(1);
2929         }
2930
2931         if (cr & DINO_RXFIFO_DATA) {
2932                 /* alive_command_responce size is NOT multiple of 4 */
2933                 u32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
2934
2935                 for (i = 0; i < ARRAY_SIZE(response_buffer); i++)
2936                         response_buffer[i] =
2937                             le32_to_cpu(ipw_read_reg32(priv,
2938                                                        IPW_BASEBAND_RX_FIFO_READ));
2939                 memcpy(&priv->dino_alive, response_buffer,
2940                        sizeof(priv->dino_alive));
2941                 if (priv->dino_alive.alive_command == 1
2942                     && priv->dino_alive.ucode_valid == 1) {
2943                         rc = 0;
2944                         IPW_DEBUG_INFO
2945                             ("Microcode OK, rev. %d (0x%x) dev. %d (0x%x) "
2946                              "of %02d/%02d/%02d %02d:%02d\n",
2947                              priv->dino_alive.software_revision,
2948                              priv->dino_alive.software_revision,
2949                              priv->dino_alive.device_identifier,
2950                              priv->dino_alive.device_identifier,
2951                              priv->dino_alive.time_stamp[0],
2952                              priv->dino_alive.time_stamp[1],
2953                              priv->dino_alive.time_stamp[2],
2954                              priv->dino_alive.time_stamp[3],
2955                              priv->dino_alive.time_stamp[4]);
2956                 } else {
2957                         IPW_DEBUG_INFO("Microcode is not alive\n");
2958                         rc = -EINVAL;
2959                 }
2960         } else {
2961                 IPW_DEBUG_INFO("No alive response from DINO\n");
2962                 rc = -ETIME;
2963         }
2964
2965         /* disable DINO, otherwise for some reason
2966            firmware have problem getting alive resp. */
2967         ipw_write_reg8(priv, IPW_BASEBAND_CONTROL_STATUS, 0);
2968
2969 //      spin_unlock_irqrestore(&priv->lock, flags);
2970
2971         return rc;
2972 }
2973
2974 static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
2975 {
2976         int rc = -1;
2977         int offset = 0;
2978         struct fw_chunk *chunk;
2979         dma_addr_t shared_phys;
2980         u8 *shared_virt;
2981
2982         IPW_DEBUG_TRACE("<< : \n");
2983         shared_virt = pci_alloc_consistent(priv->pci_dev, len, &shared_phys);
2984
2985         if (!shared_virt)
2986                 return -ENOMEM;
2987
2988         memmove(shared_virt, data, len);
2989
2990         /* Start the Dma */
2991         rc = ipw_fw_dma_enable(priv);
2992
2993         if (priv->sram_desc.last_cb_index > 0) {
2994                 /* the DMA is already ready this would be a bug. */
2995                 BUG();
2996                 goto out;
2997         }
2998
2999         do {
3000                 chunk = (struct fw_chunk *)(data + offset);
3001                 offset += sizeof(struct fw_chunk);
3002                 /* build DMA packet and queue up for sending */
3003                 /* dma to chunk->address, the chunk->length bytes from data +
3004                  * offeset*/
3005                 /* Dma loading */
3006                 rc = ipw_fw_dma_add_buffer(priv, shared_phys + offset,
3007                                            le32_to_cpu(chunk->address),
3008                                            le32_to_cpu(chunk->length));
3009                 if (rc) {
3010                         IPW_DEBUG_INFO("dmaAddBuffer Failed\n");
3011                         goto out;
3012                 }
3013
3014                 offset += le32_to_cpu(chunk->length);
3015         } while (offset < len);
3016
3017         /* Run the DMA and wait for the answer */
3018         rc = ipw_fw_dma_kick(priv);
3019         if (rc) {
3020                 IPW_ERROR("dmaKick Failed\n");
3021                 goto out;
3022         }
3023
3024         rc = ipw_fw_dma_wait(priv);
3025         if (rc) {
3026                 IPW_ERROR("dmaWaitSync Failed\n");
3027                 goto out;
3028         }
3029       out:
3030         pci_free_consistent(priv->pci_dev, len, shared_virt, shared_phys);
3031         return rc;
3032 }
3033
3034 /* stop nic */
3035 static int ipw_stop_nic(struct ipw_priv *priv)
3036 {
3037         int rc = 0;
3038
3039         /* stop */
3040         ipw_write32(priv, IPW_RESET_REG, IPW_RESET_REG_STOP_MASTER);
3041
3042         rc = ipw_poll_bit(priv, IPW_RESET_REG,
3043                           IPW_RESET_REG_MASTER_DISABLED, 500);
3044         if (rc < 0) {
3045                 IPW_ERROR("wait for reg master disabled failed after 500ms\n");
3046                 return rc;
3047         }
3048
3049         ipw_set_bit(priv, IPW_RESET_REG, CBD_RESET_REG_PRINCETON_RESET);
3050
3051         return rc;
3052 }
3053
3054 static void ipw_start_nic(struct ipw_priv *priv)
3055 {
3056         IPW_DEBUG_TRACE(">>\n");
3057
3058         /* prvHwStartNic  release ARC */
3059         ipw_clear_bit(priv, IPW_RESET_REG,
3060                       IPW_RESET_REG_MASTER_DISABLED |
3061                       IPW_RESET_REG_STOP_MASTER |
3062                       CBD_RESET_REG_PRINCETON_RESET);
3063
3064         /* enable power management */
3065         ipw_set_bit(priv, IPW_GP_CNTRL_RW,
3066                     IPW_GP_CNTRL_BIT_HOST_ALLOWS_STANDBY);
3067
3068         IPW_DEBUG_TRACE("<<\n");
3069 }
3070
3071 static int ipw_init_nic(struct ipw_priv *priv)
3072 {
3073         int rc;
3074
3075         IPW_DEBUG_TRACE(">>\n");
3076         /* reset */
3077         /*prvHwInitNic */
3078         /* set "initialization complete" bit to move adapter to D0 state */
3079         ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3080
3081         /* low-level PLL activation */
3082         ipw_write32(priv, IPW_READ_INT_REGISTER,
3083                     IPW_BIT_INT_HOST_SRAM_READ_INT_REGISTER);
3084
3085         /* wait for clock stabilization */
3086         rc = ipw_poll_bit(priv, IPW_GP_CNTRL_RW,
3087                           IPW_GP_CNTRL_BIT_CLOCK_READY, 250);
3088         if (rc < 0)
3089                 IPW_DEBUG_INFO("FAILED wait for clock stablization\n");
3090
3091         /* assert SW reset */
3092         ipw_set_bit(priv, IPW_RESET_REG, IPW_RESET_REG_SW_RESET);
3093
3094         udelay(10);
3095
3096         /* set "initialization complete" bit to move adapter to D0 state */
3097         ipw_set_bit(priv, IPW_GP_CNTRL_RW, IPW_GP_CNTRL_BIT_INIT_DONE);
3098
3099         IPW_DEBUG_TRACE(">>\n");
3100         return 0;
3101 }
3102
3103 /* Call this function from process context, it will sleep in request_firmware.
3104  * Probe is an ok place to call this from.
3105  */
3106 static int ipw_reset_nic(struct ipw_priv *priv)
3107 {
3108         int rc = 0;
3109         unsigned long flags;
3110
3111         IPW_DEBUG_TRACE(">>\n");
3112
3113         rc = ipw_init_nic(priv);
3114
3115         spin_lock_irqsave(&priv->lock, flags);
3116         /* Clear the 'host command active' bit... */
3117         priv->status &= ~STATUS_HCMD_ACTIVE;
3118         wake_up_interruptible(&priv->wait_command_queue);
3119         priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3120         wake_up_interruptible(&priv->wait_state);
3121         spin_unlock_irqrestore(&priv->lock, flags);
3122
3123         IPW_DEBUG_TRACE("<<\n");
3124         return rc;
3125 }
3126
3127 static int ipw_get_fw(struct ipw_priv *priv,
3128                       const struct firmware **fw, const char *name)
3129 {
3130         struct fw_header *header;
3131         int rc;
3132
3133         /* ask firmware_class module to get the boot firmware off disk */
3134         rc = request_firmware(fw, name, &priv->pci_dev->dev);
3135         if (rc < 0) {
3136                 IPW_ERROR("%s load failed: Reason %d\n", name, rc);
3137                 return rc;
3138         }
3139
3140         header = (struct fw_header *)(*fw)->data;
3141         if (IPW_FW_MAJOR(le32_to_cpu(header->version)) != IPW_FW_MAJOR_VERSION) {
3142                 IPW_ERROR("'%s' firmware version not compatible (%d != %d)\n",
3143                           name,
3144                           IPW_FW_MAJOR(le32_to_cpu(header->version)),
3145                           IPW_FW_MAJOR_VERSION);
3146                 return -EINVAL;
3147         }
3148
3149         IPW_DEBUG_INFO("Loading firmware '%s' file v%d.%d (%zd bytes)\n",
3150                        name,
3151                        IPW_FW_MAJOR(le32_to_cpu(header->version)),
3152                        IPW_FW_MINOR(le32_to_cpu(header->version)),
3153                        (*fw)->size - sizeof(struct fw_header));
3154         return 0;
3155 }
3156
3157 #define IPW_RX_BUF_SIZE (3000)
3158
3159 static void ipw_rx_queue_reset(struct ipw_priv *priv,
3160                                       struct ipw_rx_queue *rxq)
3161 {
3162         unsigned long flags;
3163         int i;
3164
3165         spin_lock_irqsave(&rxq->lock, flags);
3166
3167         INIT_LIST_HEAD(&rxq->rx_free);
3168         INIT_LIST_HEAD(&rxq->rx_used);
3169
3170         /* Fill the rx_used queue with _all_ of the Rx buffers */
3171         for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
3172                 /* In the reset function, these buffers may have been allocated
3173                  * to an SKB, so we need to unmap and free potential storage */
3174                 if (rxq->pool[i].skb != NULL) {
3175                         pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
3176                                          IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
3177                         dev_kfree_skb(rxq->pool[i].skb);
3178                         rxq->pool[i].skb = NULL;
3179                 }
3180                 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3181         }
3182
3183         /* Set us so that we have processed and used all buffers, but have
3184          * not restocked the Rx queue with fresh buffers */
3185         rxq->read = rxq->write = 0;
3186         rxq->processed = RX_QUEUE_SIZE - 1;
3187         rxq->free_count = 0;
3188         spin_unlock_irqrestore(&rxq->lock, flags);
3189 }
3190
3191 #ifdef CONFIG_PM
3192 static int fw_loaded = 0;
3193 static const struct firmware *bootfw = NULL;
3194 static const struct firmware *firmware = NULL;
3195 static const struct firmware *ucode = NULL;
3196
3197 static void free_firmware(void)
3198 {
3199         if (fw_loaded) {
3200                 release_firmware(bootfw);
3201                 release_firmware(ucode);
3202                 release_firmware(firmware);
3203                 bootfw = ucode = firmware = NULL;
3204                 fw_loaded = 0;
3205         }
3206 }
3207 #else
3208 #define free_firmware() do {} while (0)
3209 #endif
3210
3211 static int ipw_load(struct ipw_priv *priv)
3212 {
3213 #ifndef CONFIG_PM
3214         const struct firmware *bootfw = NULL;
3215         const struct firmware *firmware = NULL;
3216         const struct firmware *ucode = NULL;
3217 #endif
3218         char *ucode_name;
3219         char *fw_name;
3220         int rc = 0, retries = 3;
3221
3222         switch (priv->ieee->iw_mode) {
3223         case IW_MODE_ADHOC:
3224                 ucode_name = IPW_FW_NAME("ibss_ucode");
3225                 fw_name = IPW_FW_NAME("ibss");
3226                 break;
3227 #ifdef CONFIG_IPW2200_MONITOR
3228         case IW_MODE_MONITOR:
3229                 ucode_name = IPW_FW_NAME("sniffer_ucode");
3230                 fw_name = IPW_FW_NAME("sniffer");
3231                 break;
3232 #endif
3233         case IW_MODE_INFRA:
3234                 ucode_name = IPW_FW_NAME("bss_ucode");
3235                 fw_name = IPW_FW_NAME("bss");
3236                 break;
3237         default:
3238                 rc = -EINVAL;
3239         }
3240
3241         if (rc < 0)
3242                 goto error;
3243
3244         if (!priv->rxq)
3245                 priv->rxq = ipw_rx_queue_alloc(priv);
3246         else
3247                 ipw_rx_queue_reset(priv, priv->rxq);
3248         if (!priv->rxq) {
3249                 IPW_ERROR("Unable to initialize Rx queue\n");
3250                 goto error;
3251         }
3252
3253       retry:
3254         /* Ensure interrupts are disabled */
3255         ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3256         priv->status &= ~STATUS_INT_ENABLED;
3257
3258         /* ack pending interrupts */
3259         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3260
3261         ipw_stop_nic(priv);
3262
3263         rc = ipw_reset_nic(priv);
3264         if (rc < 0) {
3265                 IPW_ERROR("Unable to reset NIC\n");
3266                 goto error;
3267         }
3268
3269         ipw_zero_memory(priv, IPW_NIC_SRAM_LOWER_BOUND,
3270                         IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
3271
3272 #ifdef CONFIG_PM
3273         if (!fw_loaded) {
3274 #endif
3275                 rc = ipw_get_fw(priv, &bootfw, IPW_FW_NAME("boot"));
3276                 if (rc < 0)
3277                         goto error;
3278 #ifdef CONFIG_PM
3279         }
3280 #endif
3281         /* DMA the initial boot firmware into the device */
3282         rc = ipw_load_firmware(priv, bootfw->data + sizeof(struct fw_header),
3283                                bootfw->size - sizeof(struct fw_header));
3284         if (rc < 0) {
3285                 IPW_ERROR("Unable to load boot firmware: %d\n", rc);
3286                 goto error;
3287         }
3288
3289         /* kick start the device */
3290         ipw_start_nic(priv);
3291
3292         /* wait for the device to finish its initial startup sequence */
3293         rc = ipw_poll_bit(priv, IPW_INTA_RW,
3294                           IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3295         if (rc < 0) {
3296                 IPW_ERROR("device failed to boot initial fw image\n");
3297                 goto error;
3298         }
3299         IPW_DEBUG_INFO("initial device response after %dms\n", rc);
3300
3301         /* ack fw init done interrupt */
3302         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3303
3304 #ifdef CONFIG_PM
3305         if (!fw_loaded) {
3306 #endif
3307                 rc = ipw_get_fw(priv, &ucode, ucode_name);
3308                 if (rc < 0)
3309                         goto error;
3310 #ifdef CONFIG_PM
3311         }
3312 #endif
3313
3314         /* DMA the ucode into the device */
3315         rc = ipw_load_ucode(priv, ucode->data + sizeof(struct fw_header),
3316                             ucode->size - sizeof(struct fw_header));
3317         if (rc < 0) {
3318                 IPW_ERROR("Unable to load ucode: %d\n", rc);
3319                 goto error;
3320         }
3321
3322         /* stop nic */
3323         ipw_stop_nic(priv);
3324
3325 #ifdef CONFIG_PM
3326         if (!fw_loaded) {
3327 #endif
3328                 rc = ipw_get_fw(priv, &firmware, fw_name);
3329                 if (rc < 0)
3330                         goto error;
3331 #ifdef CONFIG_PM
3332         }
3333 #endif
3334
3335         /* DMA bss firmware into the device */
3336         rc = ipw_load_firmware(priv, firmware->data +
3337                                sizeof(struct fw_header),
3338                                firmware->size - sizeof(struct fw_header));
3339         if (rc < 0) {
3340                 IPW_ERROR("Unable to load firmware: %d\n", rc);
3341                 goto error;
3342         }
3343 #ifdef CONFIG_PM
3344         fw_loaded = 1;
3345 #endif
3346
3347         ipw_write32(priv, IPW_EEPROM_LOAD_DISABLE, 0);
3348
3349         rc = ipw_queue_reset(priv);
3350         if (rc < 0) {
3351                 IPW_ERROR("Unable to initialize queues\n");
3352                 goto error;
3353         }
3354
3355         /* Ensure interrupts are disabled */
3356         ipw_write32(priv, IPW_INTA_MASK_R, ~IPW_INTA_MASK_ALL);
3357         /* ack pending interrupts */
3358         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3359
3360         /* kick start the device */
3361         ipw_start_nic(priv);
3362
3363         if (ipw_read32(priv, IPW_INTA_RW) & IPW_INTA_BIT_PARITY_ERROR) {
3364                 if (retries > 0) {
3365                         IPW_WARNING("Parity error.  Retrying init.\n");
3366                         retries--;
3367                         goto retry;
3368                 }
3369
3370                 IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
3371                 rc = -EIO;
3372                 goto error;
3373         }
3374
3375         /* wait for the device */
3376         rc = ipw_poll_bit(priv, IPW_INTA_RW,
3377                           IPW_INTA_BIT_FW_INITIALIZATION_DONE, 500);
3378         if (rc < 0) {
3379                 IPW_ERROR("device failed to start within 500ms\n");
3380                 goto error;
3381         }
3382         IPW_DEBUG_INFO("device response after %dms\n", rc);
3383
3384         /* ack fw init done interrupt */
3385         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_BIT_FW_INITIALIZATION_DONE);
3386
3387         /* read eeprom data and initialize the eeprom region of sram */
3388         priv->eeprom_delay = 1;
3389         ipw_eeprom_init_sram(priv);
3390
3391         /* enable interrupts */
3392         ipw_enable_interrupts(priv);
3393
3394         /* Ensure our queue has valid packets */
3395         ipw_rx_queue_replenish(priv);
3396
3397         ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
3398
3399         /* ack pending interrupts */
3400         ipw_write32(priv, IPW_INTA_RW, IPW_INTA_MASK_ALL);
3401
3402 #ifndef CONFIG_PM
3403         release_firmware(bootfw);
3404         release_firmware(ucode);
3405         release_firmware(firmware);
3406 #endif
3407         return 0;
3408
3409       error:
3410         if (priv->rxq) {
3411                 ipw_rx_queue_free(priv, priv->rxq);
3412                 priv->rxq = NULL;
3413         }
3414         ipw_tx_queue_free(priv);
3415         if (bootfw)
3416                 release_firmware(bootfw);
3417         if (ucode)
3418                 release_firmware(ucode);
3419         if (firmware)
3420                 release_firmware(firmware);
3421 #ifdef CONFIG_PM
3422         fw_loaded = 0;
3423         bootfw = ucode = firmware = NULL;
3424 #endif
3425
3426         return rc;
3427 }
3428
3429 /**
3430  * DMA services
3431  *
3432  * Theory of operation
3433  *
3434  * A queue is a circular buffers with 'Read' and 'Write' pointers.
3435  * 2 empty entries always kept in the buffer to protect from overflow.
3436  *
3437  * For Tx queue, there are low mark and high mark limits. If, after queuing
3438  * the packet for Tx, free space become < low mark, Tx queue stopped. When
3439  * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
3440  * Tx queue resumed.
3441  *
3442  * The IPW operates with six queues, one receive queue in the device's
3443  * sram, one transmit queue for sending commands to the device firmware,
3444  * and four transmit queues for data.
3445  *
3446  * The four transmit queues allow for performing quality of service (qos)
3447  * transmissions as per the 802.11 protocol.  Currently Linux does not
3448  * provide a mechanism to the user for utilizing prioritized queues, so
3449  * we only utilize the first data transmit queue (queue1).
3450  */
3451
3452 /**
3453  * Driver allocates buffers of this size for Rx
3454  */
3455
3456 static inline int ipw_queue_space(const struct clx2_queue *q)
3457 {
3458         int s = q->last_used - q->first_empty;
3459         if (s <= 0)
3460                 s += q->n_bd;
3461         s -= 2;                 /* keep some reserve to not confuse empty and full situations */
3462         if (s < 0)
3463                 s = 0;
3464         return s;
3465 }
3466
3467 static inline int ipw_queue_inc_wrap(int index, int n_bd)
3468 {
3469         return (++index == n_bd) ? 0 : index;
3470 }
3471
3472 /**
3473  * Initialize common DMA queue structure
3474  *
3475  * @param q                queue to init
3476  * @param count            Number of BD's to allocate. Should be power of 2
3477  * @param read_register    Address for 'read' register
3478  *                         (not offset within BAR, full address)
3479  * @param write_register   Address for 'write' register
3480  *                         (not offset within BAR, full address)
3481  * @param base_register    Address for 'base' register
3482  *                         (not offset within BAR, full address)
3483  * @param size             Address for 'size' register
3484  *                         (not offset within BAR, full address)
3485  */
3486 static void ipw_queue_init(struct ipw_priv *priv, struct clx2_queue *q,
3487                            int count, u32 read, u32 write, u32 base, u32 size)
3488 {
3489         q->n_bd = count;
3490
3491         q->low_mark = q->n_bd / 4;
3492         if (q->low_mark < 4)
3493                 q->low_mark = 4;
3494
3495         q->high_mark = q->n_bd / 8;
3496         if (q->high_mark < 2)
3497                 q->high_mark = 2;
3498
3499         q->first_empty = q->last_used = 0;
3500         q->reg_r = read;
3501         q->reg_w = write;
3502
3503         ipw_write32(priv, base, q->dma_addr);
3504         ipw_write32(priv, size, count);
3505         ipw_write32(priv, read, 0);
3506         ipw_write32(priv, write, 0);
3507
3508         _ipw_read32(priv, 0x90);
3509 }
3510
3511 static int ipw_queue_tx_init(struct ipw_priv *priv,
3512                              struct clx2_tx_queue *q,
3513                              int count, u32 read, u32 write, u32 base, u32 size)
3514 {
3515         struct pci_dev *dev = priv->pci_dev;
3516
3517         q->txb = kmalloc(sizeof(q->txb[0]) * count, GFP_KERNEL);
3518         if (!q->txb) {
3519                 IPW_ERROR("vmalloc for auxilary BD structures failed\n");
3520                 return -ENOMEM;
3521         }
3522
3523         q->bd =
3524             pci_alloc_consistent(dev, sizeof(q->bd[0]) * count, &q->q.dma_addr);
3525         if (!q->bd) {
3526                 IPW_ERROR("pci_alloc_consistent(%zd) failed\n",
3527                           sizeof(q->bd[0]) * count);
3528                 kfree(q->txb);
3529                 q->txb = NULL;
3530                 return -ENOMEM;
3531         }
3532
3533         ipw_queue_init(priv, &q->q, count, read, write, base, size);
3534         return 0;
3535 }
3536
3537 /**
3538  * Free one TFD, those at index [txq->q.last_used].
3539  * Do NOT advance any indexes
3540  *
3541  * @param dev
3542  * @param txq
3543  */
3544 static void ipw_queue_tx_free_tfd(struct ipw_priv *priv,
3545                                   struct clx2_tx_queue *txq)
3546 {
3547         struct tfd_frame *bd = &txq->bd[txq->q.last_used];
3548         struct pci_dev *dev = priv->pci_dev;
3549         int i;
3550
3551         /* classify bd */
3552         if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
3553                 /* nothing to cleanup after for host commands */
3554                 return;
3555
3556         /* sanity check */
3557         if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3558                 IPW_ERROR("Too many chunks: %i\n",
3559                           le32_to_cpu(bd->u.data.num_chunks));
3560                 /** @todo issue fatal error, it is quite serious situation */
3561                 return;
3562         }
3563
3564         /* unmap chunks if any */
3565         for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3566                 pci_unmap_single(dev, le32_to_cpu(bd->u.data.chunk_ptr[i]),
3567                                  le16_to_cpu(bd->u.data.chunk_len[i]),
3568                                  PCI_DMA_TODEVICE);
3569                 if (txq->txb[txq->q.last_used]) {
3570                         ieee80211_txb_free(txq->txb[txq->q.last_used]);
3571                         txq->txb[txq->q.last_used] = NULL;
3572                 }
3573         }
3574 }
3575
3576 /**
3577  * Deallocate DMA queue.
3578  *
3579  * Empty queue by removing and destroying all BD's.
3580  * Free all buffers.
3581  *
3582  * @param dev
3583  * @param q
3584  */
3585 static void ipw_queue_tx_free(struct ipw_priv *priv, struct clx2_tx_queue *txq)
3586 {
3587         struct clx2_queue *q = &txq->q;
3588         struct pci_dev *dev = priv->pci_dev;
3589
3590         if (q->n_bd == 0)
3591                 return;
3592
3593         /* first, empty all BD's */
3594         for (; q->first_empty != q->last_used;
3595              q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
3596                 ipw_queue_tx_free_tfd(priv, txq);
3597         }
3598
3599         /* free buffers belonging to queue itself */
3600         pci_free_consistent(dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
3601                             q->dma_addr);
3602         kfree(txq->txb);
3603
3604         /* 0 fill whole structure */
3605         memset(txq, 0, sizeof(*txq));
3606 }
3607
3608 /**
3609  * Destroy all DMA queues and structures
3610  *
3611  * @param priv
3612  */
3613 static void ipw_tx_queue_free(struct ipw_priv *priv)
3614 {
3615         /* Tx CMD queue */
3616         ipw_queue_tx_free(priv, &priv->txq_cmd);
3617
3618         /* Tx queues */
3619         ipw_queue_tx_free(priv, &priv->txq[0]);
3620         ipw_queue_tx_free(priv, &priv->txq[1]);
3621         ipw_queue_tx_free(priv, &priv->txq[2]);
3622         ipw_queue_tx_free(priv, &priv->txq[3]);
3623 }
3624
3625 static void ipw_create_bssid(struct ipw_priv *priv, u8 * bssid)
3626 {
3627         /* First 3 bytes are manufacturer */
3628         bssid[0] = priv->mac_addr[0];
3629         bssid[1] = priv->mac_addr[1];
3630         bssid[2] = priv->mac_addr[2];
3631
3632         /* Last bytes are random */
3633         get_random_bytes(&bssid[3], ETH_ALEN - 3);
3634
3635         bssid[0] &= 0xfe;       /* clear multicast bit */
3636         bssid[0] |= 0x02;       /* set local assignment bit (IEEE802) */
3637 }
3638
3639 static u8 ipw_add_station(struct ipw_priv *priv, u8 * bssid)
3640 {
3641         struct ipw_station_entry entry;
3642         int i;
3643
3644         for (i = 0; i < priv->num_stations; i++) {
3645                 if (!memcmp(priv->stations[i], bssid, ETH_ALEN)) {
3646                         /* Another node is active in network */
3647                         priv->missed_adhoc_beacons = 0;
3648                         if (!(priv->config & CFG_STATIC_CHANNEL))
3649                                 /* when other nodes drop out, we drop out */
3650                                 priv->config &= ~CFG_ADHOC_PERSIST;
3651
3652                         return i;
3653                 }
3654         }
3655
3656         if (i == MAX_STATIONS)
3657                 return IPW_INVALID_STATION;
3658
3659         IPW_DEBUG_SCAN("Adding AdHoc station: " MAC_FMT "\n", MAC_ARG(bssid));
3660
3661         entry.reserved = 0;
3662         entry.support_mode = 0;
3663         memcpy(entry.mac_addr, bssid, ETH_ALEN);
3664         memcpy(priv->stations[i], bssid, ETH_ALEN);
3665         ipw_write_direct(priv, IPW_STATION_TABLE_LOWER + i * sizeof(entry),
3666                          &entry, sizeof(entry));
3667         priv->num_stations++;
3668
3669         return i;
3670 }
3671
3672 static u8 ipw_find_station(struct ipw_priv *priv, u8 * bssid)
3673 {
3674         int i;
3675
3676         for (i = 0; i < priv->num_stations; i++)
3677                 if (!memcmp(priv->stations[i], bssid, ETH_ALEN))
3678                         return i;
3679
3680         return IPW_INVALID_STATION;
3681 }
3682
3683 static void ipw_send_disassociate(struct ipw_priv *priv, int quiet)
3684 {
3685         int err;
3686
3687         if (priv->status & STATUS_ASSOCIATING) {
3688                 IPW_DEBUG_ASSOC("Disassociating while associating.\n");
3689                 queue_work(priv->workqueue, &priv->disassociate);
3690                 return;
3691         }
3692
3693         if (!(priv->status & STATUS_ASSOCIATED)) {
3694                 IPW_DEBUG_ASSOC("Disassociating while not associated.\n");
3695                 return;
3696         }
3697
3698         IPW_DEBUG_ASSOC("Disassocation attempt from " MAC_FMT " "
3699                         "on channel %d.\n",
3700                         MAC_ARG(priv->assoc_request.bssid),
3701                         priv->assoc_request.channel);
3702
3703         priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
3704         priv->status |= STATUS_DISASSOCIATING;
3705
3706         if (quiet)
3707                 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
3708         else
3709                 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
3710
3711         err = ipw_send_associate(priv, &priv->assoc_request);
3712         if (err) {
3713                 IPW_DEBUG_HC("Attempt to send [dis]associate command "
3714                              "failed.\n");
3715                 return;
3716         }
3717
3718 }
3719
3720 static int ipw_disassociate(void *data)
3721 {
3722         struct ipw_priv *priv = data;
3723         if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3724                 return 0;
3725         ipw_send_disassociate(data, 0);
3726         return 1;
3727 }
3728
3729 static void ipw_bg_disassociate(void *data)
3730 {
3731         struct ipw_priv *priv = data;
3732         mutex_lock(&priv->mutex);
3733         ipw_disassociate(data);
3734         mutex_unlock(&priv->mutex);
3735 }
3736
3737 static void ipw_system_config(void *data)
3738 {
3739         struct ipw_priv *priv = data;
3740         ipw_send_system_config(priv, &priv->sys_config);
3741 }
3742
3743 struct ipw_status_code {
3744         u16 status;
3745         const char *reason;
3746 };
3747
3748 static const struct ipw_status_code ipw_status_codes[] = {
3749         {0x00, "Successful"},
3750         {0x01, "Unspecified failure"},
3751         {0x0A, "Cannot support all requested capabilities in the "
3752          "Capability information field"},
3753         {0x0B, "Reassociation denied due to inability to confirm that "
3754          "association exists"},
3755         {0x0C, "Association denied due to reason outside the scope of this "
3756          "standard"},
3757         {0x0D,
3758          "Responding station does not support the specified authentication "
3759          "algorithm"},
3760         {0x0E,
3761          "Received an Authentication frame with authentication sequence "
3762          "transaction sequence number out of expected sequence"},
3763         {0x0F, "Authentication rejected because of challenge failure"},
3764         {0x10, "Authentication rejected due to timeout waiting for next "
3765          "frame in sequence"},
3766         {0x11, "Association denied because AP is unable to handle additional "
3767          "associated stations"},
3768         {0x12,
3769          "Association denied due to requesting station not supporting all "
3770          "of the datarates in the BSSBasicServiceSet Parameter"},
3771         {0x13,
3772          "Association denied due to requesting station not supporting "
3773          "short preamble operation"},
3774         {0x14,
3775          "Association denied due to requesting station not supporting "
3776          "PBCC encoding"},
3777         {0x15,
3778          "Association denied due to requesting station not supporting "
3779          "channel agility"},
3780         {0x19,
3781          "Association denied due to requesting station not supporting "
3782          "short slot operation"},
3783         {0x1A,
3784          "Association denied due to requesting station not supporting "
3785          "DSSS-OFDM operation"},
3786         {0x28, "Invalid Information Element"},
3787         {0x29, "Group Cipher is not valid"},
3788         {0x2A, "Pairwise Cipher is not valid"},
3789         {0x2B, "AKMP is not valid"},
3790         {0x2C, "Unsupported RSN IE version"},
3791         {0x2D, "Invalid RSN IE Capabilities"},
3792         {0x2E, "Cipher suite is rejected per security policy"},
3793 };
3794
3795 #ifdef CONFIG_IPW2200_DEBUG
3796 static const char *ipw_get_status_code(u16 status)
3797 {
3798         int i;
3799         for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
3800                 if (ipw_status_codes[i].status == (status & 0xff))
3801                         return ipw_status_codes[i].reason;
3802         return "Unknown status value.";
3803 }
3804 #endif
3805
3806 static void inline average_init(struct average *avg)
3807 {
3808         memset(avg, 0, sizeof(*avg));
3809 }
3810
3811 static void average_add(struct average *avg, s16 val)
3812 {
3813         avg->sum -= avg->entries[avg->pos];
3814         avg->sum += val;
3815         avg->entries[avg->pos++] = val;
3816         if (unlikely(avg->pos == AVG_ENTRIES)) {
3817                 avg->init = 1;
3818                 avg->pos = 0;
3819         }
3820 }
3821
3822 static s16 average_value(struct average *avg)
3823 {
3824         if (!unlikely(avg->init)) {
3825                 if (avg->pos)
3826                         return avg->sum / avg->pos;
3827                 return 0;
3828         }
3829
3830         return avg->sum / AVG_ENTRIES;
3831 }
3832
3833 static void ipw_reset_stats(struct ipw_priv *priv)
3834 {
3835         u32 len = sizeof(u32);
3836
3837         priv->quality = 0;
3838
3839         average_init(&priv->average_missed_beacons);
3840         average_init(&priv->average_rssi);
3841         average_init(&priv->average_noise);
3842
3843         priv->last_rate = 0;
3844         priv->last_missed_beacons = 0;
3845         priv->last_rx_packets = 0;
3846         priv->last_tx_packets = 0;
3847         priv->last_tx_failures = 0;
3848
3849         /* Firmware managed, reset only when NIC is restarted, so we have to
3850          * normalize on the current value */
3851         ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC,
3852                         &priv->last_rx_err, &len);
3853         ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE,
3854                         &priv->last_tx_failures, &len);
3855
3856         /* Driver managed, reset with each association */
3857         priv->missed_adhoc_beacons = 0;
3858         priv->missed_beacons = 0;
3859         priv->tx_packets = 0;
3860         priv->rx_packets = 0;
3861
3862 }
3863
3864 static u32 ipw_get_max_rate(struct ipw_priv *priv)
3865 {
3866         u32 i = 0x80000000;
3867         u32 mask = priv->rates_mask;
3868         /* If currently associated in B mode, restrict the maximum
3869          * rate match to B rates */
3870         if (priv->assoc_request.ieee_mode == IPW_B_MODE)
3871                 mask &= IEEE80211_CCK_RATES_MASK;
3872
3873         /* TODO: Verify that the rate is supported by the current rates
3874          * list. */
3875
3876         while (i && !(mask & i))
3877                 i >>= 1;
3878         switch (i) {
3879         case IEEE80211_CCK_RATE_1MB_MASK:
3880                 return 1000000;
3881         case IEEE80211_CCK_RATE_2MB_MASK:
3882                 return 2000000;
3883         case IEEE80211_CCK_RATE_5MB_MASK:
3884                 return 5500000;
3885         case IEEE80211_OFDM_RATE_6MB_MASK:
3886                 return 6000000;
3887         case IEEE80211_OFDM_RATE_9MB_MASK:
3888                 return 9000000;
3889         case IEEE80211_CCK_RATE_11MB_MASK:
3890                 return 11000000;
3891         case IEEE80211_OFDM_RATE_12MB_MASK:
3892                 return 12000000;
3893         case IEEE80211_OFDM_RATE_18MB_MASK:
3894                 return 18000000;
3895         case IEEE80211_OFDM_RATE_24MB_MASK:
3896                 return 24000000;
3897         case IEEE80211_OFDM_RATE_36MB_MASK:
3898                 return 36000000;
3899         case IEEE80211_OFDM_RATE_48MB_MASK:
3900                 return 48000000;
3901         case IEEE80211_OFDM_RATE_54MB_MASK:
3902                 return 54000000;
3903         }
3904
3905         if (priv->ieee->mode == IEEE_B)
3906                 return 11000000;
3907         else
3908                 return 54000000;
3909 }
3910
3911 static u32 ipw_get_current_rate(struct ipw_priv *priv)
3912 {
3913         u32 rate, len = sizeof(rate);
3914         int err;
3915
3916         if (!(priv->status & STATUS_ASSOCIATED))
3917                 return 0;
3918
3919         if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
3920                 err = ipw_get_ordinal(priv, IPW_ORD_STAT_TX_CURR_RATE, &rate,
3921                                       &len);
3922                 if (err) {
3923                         IPW_DEBUG_INFO("failed querying ordinals.\n");
3924                         return 0;
3925                 }
3926         } else
3927                 return ipw_get_max_rate(priv);
3928
3929         switch (rate) {
3930         case IPW_TX_RATE_1MB:
3931                 return 1000000;
3932         case IPW_TX_RATE_2MB:
3933                 return 2000000;
3934         case IPW_TX_RATE_5MB:
3935                 return 5500000;
3936         case IPW_TX_RATE_6MB:
3937                 return 6000000;
3938         case IPW_TX_RATE_9MB:
3939                 return 9000000;
3940         case IPW_TX_RATE_11MB:
3941                 return 11000000;
3942         case IPW_TX_RATE_12MB:
3943                 return 12000000;
3944         case IPW_TX_RATE_18MB:
3945                 return 18000000;
3946         case IPW_TX_RATE_24MB:
3947                 return 24000000;
3948         case IPW_TX_RATE_36MB:
3949                 return 36000000;
3950         case IPW_TX_RATE_48MB:
3951                 return 48000000;
3952         case IPW_TX_RATE_54MB:
3953                 return 54000000;
3954         }
3955
3956         return 0;
3957 }
3958
3959 #define IPW_STATS_INTERVAL (2 * HZ)
3960 static void ipw_gather_stats(struct ipw_priv *priv)
3961 {
3962         u32 rx_err, rx_err_delta, rx_packets_delta;
3963         u32 tx_failures, tx_failures_delta, tx_packets_delta;
3964         u32 missed_beacons_percent, missed_beacons_delta;
3965         u32 quality = 0;
3966         u32 len = sizeof(u32);
3967         s16 rssi;
3968         u32 beacon_quality, signal_quality, tx_quality, rx_quality,
3969             rate_quality;
3970         u32 max_rate;
3971
3972         if (!(priv->status & STATUS_ASSOCIATED)) {
3973                 priv->quality = 0;
3974                 return;
3975         }
3976
3977         /* Update the statistics */
3978         ipw_get_ordinal(priv, IPW_ORD_STAT_MISSED_BEACONS,
3979                         &priv->missed_beacons, &len);
3980         missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
3981         priv->last_missed_beacons = priv->missed_beacons;
3982         if (priv->assoc_request.beacon_interval) {
3983                 missed_beacons_percent = missed_beacons_delta *
3984                     (HZ * priv->assoc_request.beacon_interval) /
3985                     (IPW_STATS_INTERVAL * 10);
3986         } else {
3987                 missed_beacons_percent = 0;
3988         }
3989         average_add(&priv->average_missed_beacons, missed_beacons_percent);
3990
3991         ipw_get_ordinal(priv, IPW_ORD_STAT_RX_ERR_CRC, &rx_err, &len);
3992         rx_err_delta = rx_err - priv->last_rx_err;
3993         priv->last_rx_err = rx_err;
3994
3995         ipw_get_ordinal(priv, IPW_ORD_STAT_TX_FAILURE, &tx_failures, &len);
3996         tx_failures_delta = tx_failures - priv->last_tx_failures;
3997         priv->last_tx_failures = tx_failures;
3998
3999         rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
4000         priv->last_rx_packets = priv->rx_packets;
4001
4002         tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
4003         priv->last_tx_packets = priv->tx_packets;
4004
4005         /* Calculate quality based on the following:
4006          *
4007          * Missed beacon: 100% = 0, 0% = 70% missed
4008          * Rate: 60% = 1Mbs, 100% = Max
4009          * Rx and Tx errors represent a straight % of total Rx/Tx
4010          * RSSI: 100% = > -50,  0% = < -80
4011          * Rx errors: 100% = 0, 0% = 50% missed
4012          *
4013          * The lowest computed quality is used.
4014          *
4015          */
4016 #define BEACON_THRESHOLD 5
4017         beacon_quality = 100 - missed_beacons_percent;
4018         if (beacon_quality < BEACON_THRESHOLD)
4019                 beacon_quality = 0;
4020         else
4021                 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
4022                     (100 - BEACON_THRESHOLD);
4023         IPW_DEBUG_STATS("Missed beacon: %3d%% (%d%%)\n",
4024                         beacon_quality, missed_beacons_percent);
4025
4026         priv->last_rate = ipw_get_current_rate(priv);
4027         max_rate = ipw_get_max_rate(priv);
4028         rate_quality = priv->last_rate * 40 / max_rate + 60;
4029         IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
4030                         rate_quality, priv->last_rate / 1000000);
4031
4032         if (rx_packets_delta > 100 && rx_packets_delta + rx_err_delta)
4033                 rx_quality = 100 - (rx_err_delta * 100) /
4034                     (rx_packets_delta + rx_err_delta);
4035         else
4036                 rx_quality = 100;
4037         IPW_DEBUG_STATS("Rx quality   : %3d%% (%u errors, %u packets)\n",
4038                         rx_quality, rx_err_delta, rx_packets_delta);
4039
4040         if (tx_packets_delta > 100 && tx_packets_delta + tx_failures_delta)
4041                 tx_quality = 100 - (tx_failures_delta * 100) /
4042                     (tx_packets_delta + tx_failures_delta);
4043         else
4044                 tx_quality = 100;
4045         IPW_DEBUG_STATS("Tx quality   : %3d%% (%u errors, %u packets)\n",
4046                         tx_quality, tx_failures_delta, tx_packets_delta);
4047
4048         rssi = average_value(&priv->average_rssi);
4049         signal_quality =
4050             (100 *
4051              (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4052              (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
4053              (priv->ieee->perfect_rssi - rssi) *
4054              (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
4055               62 * (priv->ieee->perfect_rssi - rssi))) /
4056             ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4057              (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
4058         if (signal_quality > 100)
4059                 signal_quality = 100;
4060         else if (signal_quality < 1)
4061                 signal_quality = 0;
4062
4063         IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
4064                         signal_quality, rssi);
4065
4066         quality = min(beacon_quality,
4067                       min(rate_quality,
4068                           min(tx_quality, min(rx_quality, signal_quality))));
4069         if (quality == beacon_quality)
4070                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to missed beacons.\n",
4071                                 quality);
4072         if (quality == rate_quality)
4073                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to rate quality.\n",
4074                                 quality);
4075         if (quality == tx_quality)
4076                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Tx quality.\n",
4077                                 quality);
4078         if (quality == rx_quality)
4079                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to Rx quality.\n",
4080                                 quality);
4081         if (quality == signal_quality)
4082                 IPW_DEBUG_STATS("Quality (%d%%): Clamped to signal quality.\n",
4083                                 quality);
4084
4085         priv->quality = quality;
4086
4087         queue_delayed_work(priv->workqueue, &priv->gather_stats,
4088                            IPW_STATS_INTERVAL);
4089 }
4090
4091 static void ipw_bg_gather_stats(void *data)
4092 {
4093         struct ipw_priv *priv = data;
4094         mutex_lock(&priv->mutex);
4095         ipw_gather_stats(data);
4096         mutex_unlock(&priv->mutex);
4097 }
4098
4099 /* Missed beacon behavior:
4100  * 1st missed -> roaming_threshold, just wait, don't do any scan/roam.
4101  * roaming_threshold -> disassociate_threshold, scan and roam for better signal.
4102  * Above disassociate threshold, give up and stop scanning.
4103  * Roaming is disabled if disassociate_threshold <= roaming_threshold  */
4104 static void ipw_handle_missed_beacon(struct ipw_priv *priv,
4105                                             int missed_count)
4106 {
4107         priv->notif_missed_beacons = missed_count;
4108
4109         if (missed_count > priv->disassociate_threshold &&
4110             priv->status & STATUS_ASSOCIATED) {
4111                 /* If associated and we've hit the missed
4112                  * beacon threshold, disassociate, turn
4113                  * off roaming, and abort any active scans */
4114                 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4115                           IPW_DL_STATE | IPW_DL_ASSOC,
4116                           "Missed beacon: %d - disassociate\n", missed_count);
4117                 priv->status &= ~STATUS_ROAMING;
4118                 if (priv->status & STATUS_SCANNING) {
4119                         IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
4120                                   IPW_DL_STATE,
4121                                   "Aborting scan with missed beacon.\n");
4122                         queue_work(priv->workqueue, &priv->abort_scan);
4123                 }
4124
4125                 queue_work(priv->workqueue, &priv->disassociate);
4126                 return;
4127         }
4128
4129         if (priv->status & STATUS_ROAMING) {
4130                 /* If we are currently roaming, then just
4131                  * print a debug statement... */
4132                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4133                           "Missed beacon: %d - roam in progress\n",
4134                           missed_count);
4135                 return;
4136         }
4137
4138         if (roaming &&
4139             (missed_count > priv->roaming_threshold &&
4140              missed_count <= priv->disassociate_threshold)) {
4141                 /* If we are not already roaming, set the ROAM
4142                  * bit in the status and kick off a scan.
4143                  * This can happen several times before we reach
4144                  * disassociate_threshold. */
4145                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4146                           "Missed beacon: %d - initiate "
4147                           "roaming\n", missed_count);
4148                 if (!(priv->status & STATUS_ROAMING)) {
4149                         priv->status |= STATUS_ROAMING;
4150                         if (!(priv->status & STATUS_SCANNING))
4151                                 queue_work(priv->workqueue,
4152                                            &priv->request_scan);
4153                 }
4154                 return;
4155         }
4156
4157         if (priv->status & STATUS_SCANNING) {
4158                 /* Stop scan to keep fw from getting
4159                  * stuck (only if we aren't roaming --
4160                  * otherwise we'll never scan more than 2 or 3
4161                  * channels..) */
4162                 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF | IPW_DL_STATE,
4163                           "Aborting scan with missed beacon.\n");
4164                 queue_work(priv->workqueue, &priv->abort_scan);
4165         }
4166
4167         IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);
4168 }
4169
4170 /**
4171  * Handle host notification packet.
4172  * Called from interrupt routine
4173  */
4174 static void ipw_rx_notification(struct ipw_priv *priv,
4175                                        struct ipw_rx_notification *notif)
4176 {
4177         notif->size = le16_to_cpu(notif->size);
4178
4179         IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, notif->size);
4180
4181         switch (notif->subtype) {
4182         case HOST_NOTIFICATION_STATUS_ASSOCIATED:{
4183                         struct notif_association *assoc = &notif->u.assoc;
4184
4185                         switch (assoc->state) {
4186                         case CMAS_ASSOCIATED:{
4187                                         IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4188                                                   IPW_DL_ASSOC,
4189                                                   "associated: '%s' " MAC_FMT
4190                                                   " \n",
4191                                                   escape_essid(priv->essid,
4192                                                                priv->essid_len),
4193                                                   MAC_ARG(priv->bssid));
4194
4195                                         switch (priv->ieee->iw_mode) {
4196                                         case IW_MODE_INFRA:
4197                                                 memcpy(priv->ieee->bssid,
4198                                                        priv->bssid, ETH_ALEN);
4199                                                 break;
4200
4201                                         case IW_MODE_ADHOC:
4202                                                 memcpy(priv->ieee->bssid,
4203                                                        priv->bssid, ETH_ALEN);
4204
4205                                                 /* clear out the station table */
4206                                                 priv->num_stations = 0;
4207
4208                                                 IPW_DEBUG_ASSOC
4209                                                     ("queueing adhoc check\n");
4210                                                 queue_delayed_work(priv->
4211                                                                    workqueue,
4212                                                                    &priv->
4213                                                                    adhoc_check,
4214                                                                    priv->
4215                                                                    assoc_request.
4216                                                                    beacon_interval);
4217                                                 break;
4218                                         }
4219
4220                                         priv->status &= ~STATUS_ASSOCIATING;
4221                                         priv->status |= STATUS_ASSOCIATED;
4222                                         queue_work(priv->workqueue,
4223                                                    &priv->system_config);
4224
4225 #ifdef CONFIG_IPW_QOS
4226 #define IPW_GET_PACKET_STYPE(x) WLAN_FC_GET_STYPE( \
4227                          le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_ctl))
4228                                         if ((priv->status & STATUS_AUTH) &&
4229                                             (IPW_GET_PACKET_STYPE(&notif->u.raw)
4230                                              == IEEE80211_STYPE_ASSOC_RESP)) {
4231                                                 if ((sizeof
4232                                                      (struct
4233                                                       ieee80211_assoc_response)
4234                                                      <= notif->size)
4235                                                     && (notif->size <= 2314)) {
4236                                                         struct
4237                                                         ieee80211_rx_stats
4238                                                             stats = {
4239                                                                 .len =
4240                                                                     notif->
4241                                                                     size - 1,
4242                                                         };
4243
4244                                                         IPW_DEBUG_QOS
4245                                                             ("QoS Associate "
4246                                                              "size %d\n",
4247                                                              notif->size);
4248                                                         ieee80211_rx_mgt(priv->
4249                                                                          ieee,
4250                                                                          (struct
4251                                                                           ieee80211_hdr_4addr
4252                                                                           *)
4253                                                                          &notif->u.raw, &stats);
4254                                                 }
4255                                         }
4256 #endif
4257
4258                                         schedule_work(&priv->link_up);
4259
4260                                         break;
4261                                 }
4262
4263                         case CMAS_AUTHENTICATED:{
4264                                         if (priv->
4265                                             status & (STATUS_ASSOCIATED |
4266                                                       STATUS_AUTH)) {
4267 #ifdef CONFIG_IPW2200_DEBUG
4268                                                 struct notif_authenticate *auth
4269                                                     = &notif->u.auth;
4270                                                 IPW_DEBUG(IPW_DL_NOTIF |
4271                                                           IPW_DL_STATE |
4272                                                           IPW_DL_ASSOC,
4273                                                           "deauthenticated: '%s' "
4274                                                           MAC_FMT
4275                                                           ": (0x%04X) - %s \n",
4276                                                           escape_essid(priv->
4277                                                                        essid,
4278                                                                        priv->
4279                                                                        essid_len),
4280                                                           MAC_ARG(priv->bssid),
4281                                                           ntohs(auth->status),
4282                                                           ipw_get_status_code
4283                                                           (ntohs
4284                                                            (auth->status)));
4285 #endif
4286
4287                                                 priv->status &=
4288                                                     ~(STATUS_ASSOCIATING |
4289                                                       STATUS_AUTH |
4290                                                       STATUS_ASSOCIATED);
4291
4292                                                 schedule_work(&priv->link_down);
4293                                                 break;
4294                                         }
4295
4296                                         IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4297                                                   IPW_DL_ASSOC,
4298                                                   "authenticated: '%s' " MAC_FMT
4299                                                   "\n",
4300                                                   escape_essid(priv->essid,
4301                                                                priv->essid_len),
4302                                                   MAC_ARG(priv->bssid));
4303                                         break;
4304                                 }
4305
4306                         case CMAS_INIT:{
4307                                         if (priv->status & STATUS_AUTH) {
4308                                                 struct
4309                                                     ieee80211_assoc_response
4310                                                 *resp;
4311                                                 resp =
4312                                                     (struct
4313                                                      ieee80211_assoc_response
4314                                                      *)&notif->u.raw;
4315                                                 IPW_DEBUG(IPW_DL_NOTIF |
4316                                                           IPW_DL_STATE |
4317                                                           IPW_DL_ASSOC,
4318                                                           "association failed (0x%04X): %s\n",
4319                                                           ntohs(resp->status),
4320                                                           ipw_get_status_code
4321                                                           (ntohs
4322                                                            (resp->status)));
4323                                         }
4324
4325                                         IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4326                                                   IPW_DL_ASSOC,
4327                                                   "disassociated: '%s' " MAC_FMT
4328                                                   " \n",
4329                                                   escape_essid(priv->essid,
4330                                                                priv->essid_len),
4331                                                   MAC_ARG(priv->bssid));
4332
4333                                         priv->status &=
4334                                             ~(STATUS_DISASSOCIATING |
4335                                               STATUS_ASSOCIATING |
4336                                               STATUS_ASSOCIATED | STATUS_AUTH);
4337                                         if (priv->assoc_network
4338                                             && (priv->assoc_network->
4339                                                 capability &
4340                                                 WLAN_CAPABILITY_IBSS))
4341                                                 ipw_remove_current_network
4342                                                     (priv);
4343
4344                                         schedule_work(&priv->link_down);
4345
4346                                         break;
4347                                 }
4348
4349                         case CMAS_RX_ASSOC_RESP:
4350                                 break;
4351
4352                         default:
4353                                 IPW_ERROR("assoc: unknown (%d)\n",
4354                                           assoc->state);
4355                                 break;
4356                         }
4357
4358                         break;
4359                 }
4360
4361         case HOST_NOTIFICATION_STATUS_AUTHENTICATE:{
4362                         struct notif_authenticate *auth = &notif->u.auth;
4363                         switch (auth->state) {
4364                         case CMAS_AUTHENTICATED:
4365                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4366                                           "authenticated: '%s' " MAC_FMT " \n",
4367                                           escape_essid(priv->essid,
4368                                                        priv->essid_len),
4369                                           MAC_ARG(priv->bssid));
4370                                 priv->status |= STATUS_AUTH;
4371                                 break;
4372
4373                         case CMAS_INIT:
4374                                 if (priv->status & STATUS_AUTH) {
4375                                         IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4376                                                   IPW_DL_ASSOC,
4377                                                   "authentication failed (0x%04X): %s\n",
4378                                                   ntohs(auth->status),
4379                                                   ipw_get_status_code(ntohs
4380                                                                       (auth->
4381                                                                        status)));
4382                                 }
4383                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4384                                           IPW_DL_ASSOC,
4385                                           "deauthenticated: '%s' " MAC_FMT "\n",
4386                                           escape_essid(priv->essid,
4387                                                        priv->essid_len),
4388                                           MAC_ARG(priv->bssid));
4389
4390                                 priv->status &= ~(STATUS_ASSOCIATING |
4391                                                   STATUS_AUTH |
4392                                                   STATUS_ASSOCIATED);
4393
4394                                 schedule_work(&priv->link_down);
4395                                 break;
4396
4397                         case CMAS_TX_AUTH_SEQ_1:
4398                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4399                                           IPW_DL_ASSOC, "AUTH_SEQ_1\n");
4400                                 break;
4401                         case CMAS_RX_AUTH_SEQ_2:
4402                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4403                                           IPW_DL_ASSOC, "AUTH_SEQ_2\n");
4404                                 break;
4405                         case CMAS_AUTH_SEQ_1_PASS:
4406                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4407                                           IPW_DL_ASSOC, "AUTH_SEQ_1_PASS\n");
4408                                 break;
4409                         case CMAS_AUTH_SEQ_1_FAIL:
4410                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4411                                           IPW_DL_ASSOC, "AUTH_SEQ_1_FAIL\n");
4412                                 break;
4413                         case CMAS_TX_AUTH_SEQ_3:
4414                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4415                                           IPW_DL_ASSOC, "AUTH_SEQ_3\n");
4416                                 break;
4417                         case CMAS_RX_AUTH_SEQ_4:
4418                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4419                                           IPW_DL_ASSOC, "RX_AUTH_SEQ_4\n");
4420                                 break;
4421                         case CMAS_AUTH_SEQ_2_PASS:
4422                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4423                                           IPW_DL_ASSOC, "AUTH_SEQ_2_PASS\n");
4424                                 break;
4425                         case CMAS_AUTH_SEQ_2_FAIL:
4426                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4427                                           IPW_DL_ASSOC, "AUT_SEQ_2_FAIL\n");
4428                                 break;
4429                         case CMAS_TX_ASSOC:
4430                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4431                                           IPW_DL_ASSOC, "TX_ASSOC\n");
4432                                 break;
4433                         case CMAS_RX_ASSOC_RESP:
4434                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4435                                           IPW_DL_ASSOC, "RX_ASSOC_RESP\n");
4436
4437                                 break;
4438                         case CMAS_ASSOCIATED:
4439                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
4440                                           IPW_DL_ASSOC, "ASSOCIATED\n");
4441                                 break;
4442                         default:
4443                                 IPW_DEBUG_NOTIF("auth: failure - %d\n",
4444                                                 auth->state);
4445                                 break;
4446                         }
4447                         break;
4448                 }
4449
4450         case HOST_NOTIFICATION_STATUS_SCAN_CHANNEL_RESULT:{
4451                         struct notif_channel_result *x =
4452                             &notif->u.channel_result;
4453
4454                         if (notif->size == sizeof(*x)) {
4455                                 IPW_DEBUG_SCAN("Scan result for channel %d\n",
4456                                                x->channel_num);
4457                         } else {
4458                                 IPW_DEBUG_SCAN("Scan result of wrong size %d "
4459                                                "(should be %zd)\n",
4460                                                notif->size, sizeof(*x));
4461                         }
4462                         break;
4463                 }
4464
4465         case HOST_NOTIFICATION_STATUS_SCAN_COMPLETED:{
4466                         struct notif_scan_complete *x = &notif->u.scan_complete;
4467                         if (notif->size == sizeof(*x)) {
4468                                 IPW_DEBUG_SCAN
4469                                     ("Scan completed: type %d, %d channels, "
4470                                      "%d status\n", x->scan_type,
4471                                      x->num_channels, x->status);
4472                         } else {
4473                                 IPW_ERROR("Scan completed of wrong size %d "
4474                                           "(should be %zd)\n",
4475                                           notif->size, sizeof(*x));
4476                         }
4477
4478                         priv->status &=
4479                             ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
4480
4481                         wake_up_interruptible(&priv->wait_state);
4482                         cancel_delayed_work(&priv->scan_check);
4483
4484                         if (priv->status & STATUS_EXIT_PENDING)
4485                                 break;
4486
4487                         priv->ieee->scans++;
4488
4489 #ifdef CONFIG_IPW2200_MONITOR
4490                         if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
4491                                 priv->status |= STATUS_SCAN_FORCED;
4492                                 queue_work(priv->workqueue,
4493                                            &priv->request_scan);
4494                                 break;
4495                         }
4496                         priv->status &= ~STATUS_SCAN_FORCED;
4497 #endif                          /* CONFIG_IPW2200_MONITOR */
4498
4499                         if (!(priv->status & (STATUS_ASSOCIATED |
4500                                               STATUS_ASSOCIATING |
4501                                               STATUS_ROAMING |
4502                                               STATUS_DISASSOCIATING)))
4503                                 queue_work(priv->workqueue, &priv->associate);
4504                         else if (priv->status & STATUS_ROAMING) {
4505                                 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4506                                         /* If a scan completed and we are in roam mode, then
4507                                          * the scan that completed was the one requested as a
4508                                          * result of entering roam... so, schedule the
4509                                          * roam work */
4510                                         queue_work(priv->workqueue,
4511                                                    &priv->roam);
4512                                 else
4513                                         /* Don't schedule if we aborted the scan */
4514                                         priv->status &= ~STATUS_ROAMING;
4515                         } else if (priv->status & STATUS_SCAN_PENDING)
4516                                 queue_work(priv->workqueue,
4517                                            &priv->request_scan);
4518                         else if (priv->config & CFG_BACKGROUND_SCAN
4519                                  && priv->status & STATUS_ASSOCIATED)
4520                                 queue_delayed_work(priv->workqueue,
4521                                                    &priv->request_scan, HZ);
4522                         break;
4523                 }
4524
4525         case HOST_NOTIFICATION_STATUS_FRAG_LENGTH:{
4526                         struct notif_frag_length *x = &notif->u.frag_len;
4527
4528                         if (notif->size == sizeof(*x))
4529                                 IPW_ERROR("Frag length: %d\n",
4530                                           le16_to_cpu(x->frag_length));
4531                         else
4532                                 IPW_ERROR("Frag length of wrong size %d "
4533                                           "(should be %zd)\n",
4534                                           notif->size, sizeof(*x));
4535                         break;
4536                 }
4537
4538         case HOST_NOTIFICATION_STATUS_LINK_DETERIORATION:{
4539                         struct notif_link_deterioration *x =
4540                             &notif->u.link_deterioration;
4541
4542                         if (notif->size == sizeof(*x)) {
4543                                 IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
4544                                         "link deterioration: type %d, cnt %d\n",
4545                                         x->silence_notification_type,
4546                                         x->silence_count);
4547                                 memcpy(&priv->last_link_deterioration, x,
4548                                        sizeof(*x));
4549                         } else {
4550                                 IPW_ERROR("Link Deterioration of wrong size %d "
4551                                           "(should be %zd)\n",
4552                                           notif->size, sizeof(*x));
4553                         }
4554                         break;
4555                 }
4556
4557         case HOST_NOTIFICATION_DINO_CONFIG_RESPONSE:{
4558                         IPW_ERROR("Dino config\n");
4559                         if (priv->hcmd
4560                             && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
4561                                 IPW_ERROR("Unexpected DINO_CONFIG_RESPONSE\n");
4562
4563                         break;
4564                 }
4565
4566         case HOST_NOTIFICATION_STATUS_BEACON_STATE:{
4567                         struct notif_beacon_state *x = &notif->u.beacon_state;
4568                         if (notif->size != sizeof(*x)) {
4569                                 IPW_ERROR
4570                                     ("Beacon state of wrong size %d (should "
4571                                      "be %zd)\n", notif->size, sizeof(*x));
4572                                 break;
4573                         }
4574
4575                         if (le32_to_cpu(x->state) ==
4576                             HOST_NOTIFICATION_STATUS_BEACON_MISSING)
4577                                 ipw_handle_missed_beacon(priv,
4578                                                          le32_to_cpu(x->
4579                                                                      number));
4580
4581                         break;
4582                 }
4583
4584         case HOST_NOTIFICATION_STATUS_TGI_TX_KEY:{
4585                         struct notif_tgi_tx_key *x = &notif->u.tgi_tx_key;
4586                         if (notif->size == sizeof(*x)) {
4587                                 IPW_ERROR("TGi Tx Key: state 0x%02x sec type "
4588                                           "0x%02x station %d\n",
4589                                           x->key_state, x->security_type,
4590                                           x->station_index);
4591                                 break;
4592                         }
4593
4594                         IPW_ERROR
4595                             ("TGi Tx Key of wrong size %d (should be %zd)\n",
4596                              notif->size, sizeof(*x));
4597                         break;
4598                 }
4599
4600         case HOST_NOTIFICATION_CALIB_KEEP_RESULTS:{
4601                         struct notif_calibration *x = &notif->u.calibration;
4602
4603                         if (notif->size == sizeof(*x)) {
4604                                 memcpy(&priv->calib, x, sizeof(*x));
4605                                 IPW_DEBUG_INFO("TODO: Calibration\n");
4606                                 break;
4607                         }
4608
4609                         IPW_ERROR
4610                             ("Calibration of wrong size %d (should be %zd)\n",
4611                              notif->size, sizeof(*x));
4612                         break;
4613                 }
4614
4615         case HOST_NOTIFICATION_NOISE_STATS:{
4616                         if (notif->size == sizeof(u32)) {
4617                                 priv->last_noise =
4618                                     (u8) (le32_to_cpu(notif->u.noise.value) &
4619                                           0xff);
4620                                 average_add(&priv->average_noise,
4621                                             priv->last_noise);
4622                                 break;
4623                         }
4624
4625                         IPW_ERROR
4626                             ("Noise stat is wrong size %d (should be %zd)\n",
4627                              notif->size, sizeof(u32));
4628                         break;
4629                 }
4630
4631         default:
4632                 IPW_DEBUG_NOTIF("Unknown notification: "
4633                                 "subtype=%d,flags=0x%2x,size=%d\n",
4634                                 notif->subtype, notif->flags, notif->size);
4635         }
4636 }
4637
4638 /**
4639  * Destroys all DMA structures and initialise them again
4640  *
4641  * @param priv
4642  * @return error code
4643  */
4644 static int ipw_queue_reset(struct ipw_priv *priv)
4645 {
4646         int rc = 0;
4647         /** @todo customize queue sizes */
4648         int nTx = 64, nTxCmd = 8;
4649         ipw_tx_queue_free(priv);
4650         /* Tx CMD queue */
4651         rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
4652                                IPW_TX_CMD_QUEUE_READ_INDEX,
4653                                IPW_TX_CMD_QUEUE_WRITE_INDEX,
4654                                IPW_TX_CMD_QUEUE_BD_BASE,
4655                                IPW_TX_CMD_QUEUE_BD_SIZE);
4656         if (rc) {
4657                 IPW_ERROR("Tx Cmd queue init failed\n");
4658                 goto error;
4659         }
4660         /* Tx queue(s) */
4661         rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
4662                                IPW_TX_QUEUE_0_READ_INDEX,
4663                                IPW_TX_QUEUE_0_WRITE_INDEX,
4664                                IPW_TX_QUEUE_0_BD_BASE, IPW_TX_QUEUE_0_BD_SIZE);
4665         if (rc) {
4666                 IPW_ERROR("Tx 0 queue init failed\n");
4667                 goto error;
4668         }
4669         rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
4670                                IPW_TX_QUEUE_1_READ_INDEX,
4671                                IPW_TX_QUEUE_1_WRITE_INDEX,
4672                                IPW_TX_QUEUE_1_BD_BASE, IPW_TX_QUEUE_1_BD_SIZE);
4673         if (rc) {
4674                 IPW_ERROR("Tx 1 queue init failed\n");
4675                 goto error;
4676         }
4677         rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
4678                                IPW_TX_QUEUE_2_READ_INDEX,
4679                                IPW_TX_QUEUE_2_WRITE_INDEX,
4680                                IPW_TX_QUEUE_2_BD_BASE, IPW_TX_QUEUE_2_BD_SIZE);
4681         if (rc) {
4682                 IPW_ERROR("Tx 2 queue init failed\n");
4683                 goto error;
4684         }
4685         rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
4686                                IPW_TX_QUEUE_3_READ_INDEX,
4687                                IPW_TX_QUEUE_3_WRITE_INDEX,
4688                                IPW_TX_QUEUE_3_BD_BASE, IPW_TX_QUEUE_3_BD_SIZE);
4689         if (rc) {
4690                 IPW_ERROR("Tx 3 queue init failed\n");
4691                 goto error;
4692         }
4693         /* statistics */
4694         priv->rx_bufs_min = 0;
4695         priv->rx_pend_max = 0;
4696         return rc;
4697
4698       error:
4699         ipw_tx_queue_free(priv);
4700         return rc;
4701 }
4702
4703 /**
4704  * Reclaim Tx queue entries no more used by NIC.
4705  *
4706  * When FW adwances 'R' index, all entries between old and
4707  * new 'R' index need to be reclaimed. As result, some free space
4708  * forms. If there is enough free space (> low mark), wake Tx queue.
4709  *
4710  * @note Need to protect against garbage in 'R' index
4711  * @param priv
4712  * @param txq
4713  * @param qindex
4714  * @return Number of used entries remains in the queue
4715  */
4716 static int ipw_queue_tx_reclaim(struct ipw_priv *priv,
4717                                 struct clx2_tx_queue *txq, int qindex)
4718 {
4719         u32 hw_tail;
4720         int used;
4721         struct clx2_queue *q = &txq->q;
4722
4723         hw_tail = ipw_read32(priv, q->reg_r);
4724         if (hw_tail >= q->n_bd) {
4725                 IPW_ERROR
4726                     ("Read index for DMA queue (%d) is out of range [0-%d)\n",
4727                      hw_tail, q->n_bd);
4728                 goto done;
4729         }
4730         for (; q->last_used != hw_tail;
4731              q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
4732                 ipw_queue_tx_free_tfd(priv, txq);
4733                 priv->tx_packets++;
4734         }
4735       done:
4736         if ((ipw_queue_space(q) > q->low_mark) &&
4737             (qindex >= 0) &&
4738             (priv->status & STATUS_ASSOCIATED) && netif_running(priv->net_dev))
4739                 netif_wake_queue(priv->net_dev);
4740         used = q->first_empty - q->last_used;
4741         if (used < 0)
4742                 used += q->n_bd;
4743
4744         return used;
4745 }
4746
4747 static int ipw_queue_tx_hcmd(struct ipw_priv *priv, int hcmd, void *buf,
4748                              int len, int sync)
4749 {
4750         struct clx2_tx_queue *txq = &priv->txq_cmd;
4751         struct clx2_queue *q = &txq->q;
4752         struct tfd_frame *tfd;
4753
4754         if (ipw_queue_space(q) < (sync ? 1 : 2)) {
4755                 IPW_ERROR("No space for Tx\n");
4756                 return -EBUSY;
4757         }
4758
4759         tfd = &txq->bd[q->first_empty];
4760         txq->txb[q->first_empty] = NULL;
4761
4762         memset(tfd, 0, sizeof(*tfd));
4763         tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
4764         tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
4765         priv->hcmd_seq++;
4766         tfd->u.cmd.index = hcmd;
4767         tfd->u.cmd.length = len;
4768         memcpy(tfd->u.cmd.payload, buf, len);
4769         q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
4770         ipw_write32(priv, q->reg_w, q->first_empty);
4771         _ipw_read32(priv, 0x90);
4772
4773         return 0;
4774 }
4775
4776 /*
4777  * Rx theory of operation
4778  *
4779  * The host allocates 32 DMA target addresses and passes the host address
4780  * to the firmware at register IPW_RFDS_TABLE_LOWER + N * RFD_SIZE where N is
4781  * 0 to 31
4782  *
4783  * Rx Queue Indexes
4784  * The host/firmware share two index registers for managing the Rx buffers.
4785  *
4786  * The READ index maps to the first position that the firmware may be writing
4787  * to -- the driver can read up to (but not including) this position and get
4788  * good data.
4789  * The READ index is managed by the firmware once the card is enabled.
4790  *
4791  * The WRITE index maps to the last position the driver has read from -- the
4792  * position preceding WRITE is the last slot the firmware can place a packet.
4793  *
4794  * The queue is empty (no good data) if WRITE = READ - 1, and is full if
4795  * WRITE = READ.
4796  *
4797  * During initialization the host sets up the READ queue position to the first
4798  * INDEX position, and WRITE to the last (READ - 1 wrapped)
4799  *
4800  * When the firmware places a packet in a buffer it will advance the READ index
4801  * and fire the RX interrupt.  The driver can then query the READ index and
4802  * process as many packets as possible, moving the WRITE index forward as it
4803  * resets the Rx queue buffers with new memory.
4804  *
4805  * The management in the driver is as follows:
4806  * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free.  When
4807  *   ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
4808  *   to replensish the ipw->rxq->rx_free.
4809  * + In ipw_rx_queue_replenish (scheduled) if 'processed' != 'read' then the
4810  *   ipw->rxq is replenished and the READ INDEX is updated (updating the
4811  *   'processed' and 'read' driver indexes as well)
4812  * + A received packet is processed and handed to the kernel network stack,
4813  *   detached from the ipw->rxq.  The driver 'processed' index is updated.
4814  * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
4815  *   list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
4816  *   INDEX is not incremented and ipw->status(RX_STALLED) is set.  If there
4817  *   were enough free buffers and RX_STALLED is set it is cleared.
4818  *
4819  *
4820  * Driver sequence:
4821  *
4822  * ipw_rx_queue_alloc()       Allocates rx_free
4823  * ipw_rx_queue_replenish()   Replenishes rx_free list from rx_used, and calls
4824  *                            ipw_rx_queue_restock
4825  * ipw_rx_queue_restock()     Moves available buffers from rx_free into Rx
4826  *                            queue, updates firmware pointers, and updates
4827  *                            the WRITE index.  If insufficient rx_free buffers
4828  *                            are available, schedules ipw_rx_queue_replenish
4829  *
4830  * -- enable interrupts --
4831  * ISR - ipw_rx()             Detach ipw_rx_mem_buffers from pool up to the
4832  *                            READ INDEX, detaching the SKB from the pool.
4833  *                            Moves the packet buffer from queue to rx_used.
4834  *                            Calls ipw_rx_queue_restock to refill any empty
4835  *                            slots.
4836  * ...
4837  *
4838  */
4839
4840 /*
4841  * If there are slots in the RX queue that  need to be restocked,
4842  * and we have free pre-allocated buffers, fill the ranks as much
4843  * as we can pulling from rx_free.
4844  *
4845  * This moves the 'write' index forward to catch up with 'processed', and
4846  * also updates the memory address in the firmware to reference the new
4847  * target buffer.
4848  */
4849 static void ipw_rx_queue_restock(struct ipw_priv *priv)
4850 {
4851         struct ipw_rx_queue *rxq = priv->rxq;
4852         struct list_head *element;
4853         struct ipw_rx_mem_buffer *rxb;
4854         unsigned long flags;
4855         int write;
4856
4857         spin_lock_irqsave(&rxq->lock, flags);
4858         write = rxq->write;
4859         while ((rxq->write != rxq->processed) && (rxq->free_count)) {
4860                 element = rxq->rx_free.next;
4861                 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4862                 list_del(element);
4863
4864                 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
4865                             rxb->dma_addr);
4866                 rxq->queue[rxq->write] = rxb;
4867                 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
4868                 rxq->free_count--;
4869         }
4870         spin_unlock_irqrestore(&rxq->lock, flags);
4871
4872         /* If the pre-allocated buffer pool is dropping low, schedule to
4873          * refill it */
4874         if (rxq->free_count <= RX_LOW_WATERMARK)
4875                 queue_work(priv->workqueue, &priv->rx_replenish);
4876
4877         /* If we've added more space for the firmware to place data, tell it */
4878         if (write != rxq->write)
4879                 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
4880 }
4881
4882 /*
4883  * Move all used packet from rx_used to rx_free, allocating a new SKB for each.
4884  * Also restock the Rx queue via ipw_rx_queue_restock.
4885  *
4886  * This is called as a scheduled work item (except for during intialization)
4887  */
4888 static void ipw_rx_queue_replenish(void *data)
4889 {
4890         struct ipw_priv *priv = data;
4891         struct ipw_rx_queue *rxq = priv->rxq;
4892         struct list_head *element;
4893         struct ipw_rx_mem_buffer *rxb;
4894         unsigned long flags;
4895
4896         spin_lock_irqsave(&rxq->lock, flags);
4897         while (!list_empty(&rxq->rx_used)) {
4898                 element = rxq->rx_used.next;
4899                 rxb = list_entry(element, struct ipw_rx_mem_buffer, list);
4900                 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
4901                 if (!rxb->skb) {
4902                         printk(KERN_CRIT "%s: Can not allocate SKB buffers.\n",
4903                                priv->net_dev->name);
4904                         /* We don't reschedule replenish work here -- we will
4905                          * call the restock method and if it still needs
4906                          * more buffers it will schedule replenish */
4907                         break;
4908                 }
4909                 list_del(element);
4910
4911                 rxb->rxb = (struct ipw_rx_buffer *)rxb->skb->data;
4912                 rxb->dma_addr =
4913                     pci_map_single(priv->pci_dev, rxb->skb->data,
4914                                    IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4915
4916                 list_add_tail(&rxb->list, &rxq->rx_free);
4917                 rxq->free_count++;
4918         }
4919         spin_unlock_irqrestore(&rxq->lock, flags);
4920
4921         ipw_rx_queue_restock(priv);
4922 }
4923
4924 static void ipw_bg_rx_queue_replenish(void *data)
4925 {
4926         struct ipw_priv *priv = data;
4927         mutex_lock(&priv->mutex);
4928         ipw_rx_queue_replenish(data);
4929         mutex_unlock(&priv->mutex);
4930 }
4931
4932 /* Assumes that the skb field of the buffers in 'pool' is kept accurate.
4933  * If an SKB has been detached, the POOL needs to have its SKB set to NULL
4934  * This free routine walks the list of POOL entries and if SKB is set to
4935  * non NULL it is unmapped and freed
4936  */
4937 static void ipw_rx_queue_free(struct ipw_priv *priv, struct ipw_rx_queue *rxq)
4938 {
4939         int i;
4940
4941         if (!rxq)
4942                 return;
4943
4944         for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
4945                 if (rxq->pool[i].skb != NULL) {
4946                         pci_unmap_single(priv->pci_dev, rxq->pool[i].dma_addr,
4947                                          IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
4948                         dev_kfree_skb(rxq->pool[i].skb);
4949                 }
4950         }
4951
4952         kfree(rxq);
4953 }
4954
4955 static struct ipw_rx_queue *ipw_rx_queue_alloc(struct ipw_priv *priv)
4956 {
4957         struct ipw_rx_queue *rxq;
4958         int i;
4959
4960         rxq = kzalloc(sizeof(*rxq), GFP_KERNEL);
4961         if (unlikely(!rxq)) {
4962                 IPW_ERROR("memory allocation failed\n");
4963                 return NULL;
4964         }
4965         spin_lock_init(&rxq->lock);
4966         INIT_LIST_HEAD(&rxq->rx_free);
4967         INIT_LIST_HEAD(&rxq->rx_used);
4968
4969         /* Fill the rx_used queue with _all_ of the Rx buffers */
4970         for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++)
4971                 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
4972
4973         /* Set us so that we have processed and used all buffers, but have
4974          * not restocked the Rx queue with fresh buffers */
4975         rxq->read = rxq->write = 0;
4976         rxq->processed = RX_QUEUE_SIZE - 1;
4977         rxq->free_count = 0;
4978
4979         return rxq;
4980 }
4981
4982 static int ipw_is_rate_in_mask(struct ipw_priv *priv, int ieee_mode, u8 rate)
4983 {
4984         rate &= ~IEEE80211_BASIC_RATE_MASK;
4985         if (ieee_mode == IEEE_A) {
4986                 switch (rate) {
4987                 case IEEE80211_OFDM_RATE_6MB:
4988                         return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ?
4989                             1 : 0;
4990                 case IEEE80211_OFDM_RATE_9MB:
4991                         return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ?
4992                             1 : 0;
4993                 case IEEE80211_OFDM_RATE_12MB:
4994                         return priv->
4995                             rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
4996                 case IEEE80211_OFDM_RATE_18MB:
4997                         return priv->
4998                             rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
4999                 case IEEE80211_OFDM_RATE_24MB:
5000                         return priv->
5001                             rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
5002                 case IEEE80211_OFDM_RATE_36MB:
5003                         return priv->
5004                             rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
5005                 case IEEE80211_OFDM_RATE_48MB:
5006                         return priv->
5007                             rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
5008                 case IEEE80211_OFDM_RATE_54MB:
5009                         return priv->
5010                             rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5011                 default:
5012                         return 0;
5013                 }
5014         }
5015
5016         /* B and G mixed */
5017         switch (rate) {
5018         case IEEE80211_CCK_RATE_1MB:
5019                 return priv->rates_mask & IEEE80211_CCK_RATE_1MB_MASK ? 1 : 0;
5020         case IEEE80211_CCK_RATE_2MB:
5021                 return priv->rates_mask & IEEE80211_CCK_RATE_2MB_MASK ? 1 : 0;
5022         case IEEE80211_CCK_RATE_5MB:
5023                 return priv->rates_mask & IEEE80211_CCK_RATE_5MB_MASK ? 1 : 0;
5024         case IEEE80211_CCK_RATE_11MB:
5025                 return priv->rates_mask & IEEE80211_CCK_RATE_11MB_MASK ? 1 : 0;
5026         }
5027
5028         /* If we are limited to B modulations, bail at this point */
5029         if (ieee_mode == IEEE_B)
5030                 return 0;
5031
5032         /* G */
5033         switch (rate) {
5034         case IEEE80211_OFDM_RATE_6MB:
5035                 return priv->rates_mask & IEEE80211_OFDM_RATE_6MB_MASK ? 1 : 0;
5036         case IEEE80211_OFDM_RATE_9MB:
5037                 return priv->rates_mask & IEEE80211_OFDM_RATE_9MB_MASK ? 1 : 0;
5038         case IEEE80211_OFDM_RATE_12MB:
5039                 return priv->rates_mask & IEEE80211_OFDM_RATE_12MB_MASK ? 1 : 0;
5040         case IEEE80211_OFDM_RATE_18MB:
5041                 return priv->rates_mask & IEEE80211_OFDM_RATE_18MB_MASK ? 1 : 0;
5042         case IEEE80211_OFDM_RATE_24MB:
5043                 return priv->rates_mask & IEEE80211_OFDM_RATE_24MB_MASK ? 1 : 0;
5044         case IEEE80211_OFDM_RATE_36MB:
5045                 return priv->rates_mask & IEEE80211_OFDM_RATE_36MB_MASK ? 1 : 0;
5046         case IEEE80211_OFDM_RATE_48MB:
5047                 return priv->rates_mask & IEEE80211_OFDM_RATE_48MB_MASK ? 1 : 0;
5048         case IEEE80211_OFDM_RATE_54MB:
5049                 return priv->rates_mask & IEEE80211_OFDM_RATE_54MB_MASK ? 1 : 0;
5050         }
5051
5052         return 0;
5053 }
5054
5055 static int ipw_compatible_rates(struct ipw_priv *priv,
5056                                 const struct ieee80211_network *network,
5057                                 struct ipw_supported_rates *rates)
5058 {
5059         int num_rates, i;
5060
5061         memset(rates, 0, sizeof(*rates));
5062         num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
5063         rates->num_rates = 0;
5064         for (i = 0; i < num_rates; i++) {
5065                 if (!ipw_is_rate_in_mask(priv, network->mode,
5066                                          network->rates[i])) {
5067
5068                         if (network->rates[i] & IEEE80211_BASIC_RATE_MASK) {
5069                                 IPW_DEBUG_SCAN("Adding masked mandatory "
5070                                                "rate %02X\n",
5071                                                network->rates[i]);
5072                                 rates->supported_rates[rates->num_rates++] =
5073                                     network->rates[i];
5074                                 continue;
5075                         }
5076
5077                         IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5078                                        network->rates[i], priv->rates_mask);
5079                         continue;
5080                 }
5081
5082                 rates->supported_rates[rates->num_rates++] = network->rates[i];
5083         }
5084
5085         num_rates = min(network->rates_ex_len,
5086                         (u8) (IPW_MAX_RATES - num_rates));
5087         for (i = 0; i < num_rates; i++) {
5088                 if (!ipw_is_rate_in_mask(priv, network->mode,
5089                                          network->rates_ex[i])) {
5090                         if (network->rates_ex[i] & IEEE80211_BASIC_RATE_MASK) {
5091                                 IPW_DEBUG_SCAN("Adding masked mandatory "
5092                                                "rate %02X\n",
5093                                                network->rates_ex[i]);
5094                                 rates->supported_rates[rates->num_rates++] =
5095                                     network->rates[i];
5096                                 continue;
5097                         }
5098
5099                         IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
5100                                        network->rates_ex[i], priv->rates_mask);
5101                         continue;
5102                 }
5103
5104                 rates->supported_rates[rates->num_rates++] =
5105                     network->rates_ex[i];
5106         }
5107
5108         return 1;
5109 }
5110
5111 static void ipw_copy_rates(struct ipw_supported_rates *dest,
5112                                   const struct ipw_supported_rates *src)
5113 {
5114         u8 i;
5115         for (i = 0; i < src->num_rates; i++)
5116                 dest->supported_rates[i] = src->supported_rates[i];
5117         dest->num_rates = src->num_rates;
5118 }
5119
5120 /* TODO: Look at sniffed packets in the air to determine if the basic rate
5121  * mask should ever be used -- right now all callers to add the scan rates are
5122  * set with the modulation = CCK, so BASIC_RATE_MASK is never set... */
5123 static void ipw_add_cck_scan_rates(struct ipw_supported_rates *rates,
5124                                    u8 modulation, u32 rate_mask)
5125 {
5126         u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5127             IEEE80211_BASIC_RATE_MASK : 0;
5128
5129         if (rate_mask & IEEE80211_CCK_RATE_1MB_MASK)
5130                 rates->supported_rates[rates->num_rates++] =
5131                     IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_1MB;
5132
5133         if (rate_mask & IEEE80211_CCK_RATE_2MB_MASK)
5134                 rates->supported_rates[rates->num_rates++] =
5135                     IEEE80211_BASIC_RATE_MASK | IEEE80211_CCK_RATE_2MB;
5136
5137         if (rate_mask & IEEE80211_CCK_RATE_5MB_MASK)
5138                 rates->supported_rates[rates->num_rates++] = basic_mask |
5139                     IEEE80211_CCK_RATE_5MB;
5140
5141         if (rate_mask & IEEE80211_CCK_RATE_11MB_MASK)
5142                 rates->supported_rates[rates->num_rates++] = basic_mask |
5143                     IEEE80211_CCK_RATE_11MB;
5144 }
5145
5146 static void ipw_add_ofdm_scan_rates(struct ipw_supported_rates *rates,
5147                                     u8 modulation, u32 rate_mask)
5148 {
5149         u8 basic_mask = (IEEE80211_OFDM_MODULATION == modulation) ?
5150             IEEE80211_BASIC_RATE_MASK : 0;
5151
5152         if (rate_mask & IEEE80211_OFDM_RATE_6MB_MASK)
5153                 rates->supported_rates[rates->num_rates++] = basic_mask |
5154                     IEEE80211_OFDM_RATE_6MB;
5155
5156         if (rate_mask & IEEE80211_OFDM_RATE_9MB_MASK)
5157                 rates->supported_rates[rates->num_rates++] =
5158                     IEEE80211_OFDM_RATE_9MB;
5159
5160         if (rate_mask & IEEE80211_OFDM_RATE_12MB_MASK)
5161                 rates->supported_rates[rates->num_rates++] = basic_mask |
5162                     IEEE80211_OFDM_RATE_12MB;
5163
5164         if (rate_mask & IEEE80211_OFDM_RATE_18MB_MASK)
5165                 rates->supported_rates[rates->num_rates++] =
5166                     IEEE80211_OFDM_RATE_18MB;
5167
5168         if (rate_mask & IEEE80211_OFDM_RATE_24MB_MASK)
5169                 rates->supported_rates[rates->num_rates++] = basic_mask |
5170                     IEEE80211_OFDM_RATE_24MB;
5171
5172         if (rate_mask & IEEE80211_OFDM_RATE_36MB_MASK)
5173                 rates->supported_rates[rates->num_rates++] =
5174                     IEEE80211_OFDM_RATE_36MB;
5175
5176         if (rate_mask & IEEE80211_OFDM_RATE_48MB_MASK)
5177                 rates->supported_rates[rates->num_rates++] =
5178                     IEEE80211_OFDM_RATE_48MB;
5179
5180         if (rate_mask & IEEE80211_OFDM_RATE_54MB_MASK)
5181                 rates->supported_rates[rates->num_rates++] =
5182                     IEEE80211_OFDM_RATE_54MB;
5183 }
5184
5185 struct ipw_network_match {
5186         struct ieee80211_network *network;
5187         struct ipw_supported_rates rates;
5188 };
5189
5190 static int ipw_find_adhoc_network(struct ipw_priv *priv,
5191                                   struct ipw_network_match *match,
5192                                   struct ieee80211_network *network,
5193                                   int roaming)
5194 {
5195         struct ipw_supported_rates rates;
5196
5197         /* Verify that this network's capability is compatible with the
5198          * current mode (AdHoc or Infrastructure) */
5199         if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
5200              !(network->capability & WLAN_CAPABILITY_IBSS))) {
5201                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded due to "
5202                                 "capability mismatch.\n",
5203                                 escape_essid(network->ssid, network->ssid_len),
5204                                 MAC_ARG(network->bssid));
5205                 return 0;
5206         }
5207
5208         /* If we do not have an ESSID for this AP, we can not associate with
5209          * it */
5210         if (network->flags & NETWORK_EMPTY_ESSID) {
5211                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5212                                 "because of hidden ESSID.\n",
5213                                 escape_essid(network->ssid, network->ssid_len),
5214                                 MAC_ARG(network->bssid));
5215                 return 0;
5216         }
5217
5218         if (unlikely(roaming)) {
5219                 /* If we are roaming, then ensure check if this is a valid
5220                  * network to try and roam to */
5221                 if ((network->ssid_len != match->network->ssid_len) ||
5222                     memcmp(network->ssid, match->network->ssid,
5223                            network->ssid_len)) {
5224                         IPW_DEBUG_MERGE("Netowrk '%s (" MAC_FMT ")' excluded "
5225                                         "because of non-network ESSID.\n",
5226                                         escape_essid(network->ssid,
5227                                                      network->ssid_len),
5228                                         MAC_ARG(network->bssid));
5229                         return 0;
5230                 }
5231         } else {
5232                 /* If an ESSID has been configured then compare the broadcast
5233                  * ESSID to ours */
5234                 if ((priv->config & CFG_STATIC_ESSID) &&
5235                     ((network->ssid_len != priv->essid_len) ||
5236                      memcmp(network->ssid, priv->essid,
5237                             min(network->ssid_len, priv->essid_len)))) {
5238                         char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5239
5240                         strncpy(escaped,
5241                                 escape_essid(network->ssid, network->ssid_len),
5242                                 sizeof(escaped));
5243                         IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5244                                         "because of ESSID mismatch: '%s'.\n",
5245                                         escaped, MAC_ARG(network->bssid),
5246                                         escape_essid(priv->essid,
5247                                                      priv->essid_len));
5248                         return 0;
5249                 }
5250         }
5251
5252         /* If the old network rate is better than this one, don't bother
5253          * testing everything else. */
5254
5255         if (network->time_stamp[0] < match->network->time_stamp[0]) {
5256                 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5257                                 "current network.\n",
5258                                 escape_essid(match->network->ssid,
5259                                              match->network->ssid_len));
5260                 return 0;
5261         } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
5262                 IPW_DEBUG_MERGE("Network '%s excluded because newer than "
5263                                 "current network.\n",
5264                                 escape_essid(match->network->ssid,
5265                                              match->network->ssid_len));
5266                 return 0;
5267         }
5268
5269         /* Now go through and see if the requested network is valid... */
5270         if (priv->ieee->scan_age != 0 &&
5271             time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5272                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5273                                 "because of age: %ums.\n",
5274                                 escape_essid(network->ssid, network->ssid_len),
5275                                 MAC_ARG(network->bssid),
5276                                 jiffies_to_msecs(jiffies -
5277                                                  network->last_scanned));
5278                 return 0;
5279         }
5280
5281         if ((priv->config & CFG_STATIC_CHANNEL) &&
5282             (network->channel != priv->channel)) {
5283                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5284                                 "because of channel mismatch: %d != %d.\n",
5285                                 escape_essid(network->ssid, network->ssid_len),
5286                                 MAC_ARG(network->bssid),
5287                                 network->channel, priv->channel);
5288                 return 0;
5289         }
5290
5291         /* Verify privacy compatability */
5292         if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5293             ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5294                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5295                                 "because of privacy mismatch: %s != %s.\n",
5296                                 escape_essid(network->ssid, network->ssid_len),
5297                                 MAC_ARG(network->bssid),
5298                                 priv->
5299                                 capability & CAP_PRIVACY_ON ? "on" : "off",
5300                                 network->
5301                                 capability & WLAN_CAPABILITY_PRIVACY ? "on" :
5302                                 "off");
5303                 return 0;
5304         }
5305
5306         if (!memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5307                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5308                                 "because of the same BSSID match: " MAC_FMT
5309                                 ".\n", escape_essid(network->ssid,
5310                                                     network->ssid_len),
5311                                 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5312                 return 0;
5313         }
5314
5315         /* Filter out any incompatible freq / mode combinations */
5316         if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5317                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5318                                 "because of invalid frequency/mode "
5319                                 "combination.\n",
5320                                 escape_essid(network->ssid, network->ssid_len),
5321                                 MAC_ARG(network->bssid));
5322                 return 0;
5323         }
5324
5325         /* Ensure that the rates supported by the driver are compatible with
5326          * this AP, including verification of basic rates (mandatory) */
5327         if (!ipw_compatible_rates(priv, network, &rates)) {
5328                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5329                                 "because configured rate mask excludes "
5330                                 "AP mandatory rate.\n",
5331                                 escape_essid(network->ssid, network->ssid_len),
5332                                 MAC_ARG(network->bssid));
5333                 return 0;
5334         }
5335
5336         if (rates.num_rates == 0) {
5337                 IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' excluded "
5338                                 "because of no compatible rates.\n",
5339                                 escape_essid(network->ssid, network->ssid_len),
5340                                 MAC_ARG(network->bssid));
5341                 return 0;
5342         }
5343
5344         /* TODO: Perform any further minimal comparititive tests.  We do not
5345          * want to put too much policy logic here; intelligent scan selection
5346          * should occur within a generic IEEE 802.11 user space tool.  */
5347
5348         /* Set up 'new' AP to this network */
5349         ipw_copy_rates(&match->rates, &rates);
5350         match->network = network;
5351         IPW_DEBUG_MERGE("Network '%s (" MAC_FMT ")' is a viable match.\n",
5352                         escape_essid(network->ssid, network->ssid_len),
5353                         MAC_ARG(network->bssid));
5354
5355         return 1;
5356 }
5357
5358 static void ipw_merge_adhoc_network(void *data)
5359 {
5360         struct ipw_priv *priv = data;
5361         struct ieee80211_network *network = NULL;
5362         struct ipw_network_match match = {
5363                 .network = priv->assoc_network
5364         };
5365
5366         if ((priv->status & STATUS_ASSOCIATED) &&
5367             (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5368                 /* First pass through ROAM process -- look for a better
5369                  * network */
5370                 unsigned long flags;
5371
5372                 spin_lock_irqsave(&priv->ieee->lock, flags);
5373                 list_for_each_entry(network, &priv->ieee->network_list, list) {
5374                         if (network != priv->assoc_network)
5375                                 ipw_find_adhoc_network(priv, &match, network,
5376                                                        1);
5377                 }
5378                 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5379
5380                 if (match.network == priv->assoc_network) {
5381                         IPW_DEBUG_MERGE("No better ADHOC in this network to "
5382                                         "merge to.\n");
5383                         return;
5384                 }
5385
5386                 mutex_lock(&priv->mutex);
5387                 if ((priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5388                         IPW_DEBUG_MERGE("remove network %s\n",
5389                                         escape_essid(priv->essid,
5390                                                      priv->essid_len));
5391                         ipw_remove_current_network(priv);
5392                 }
5393
5394                 ipw_disassociate(priv);
5395                 priv->assoc_network = match.network;
5396                 mutex_unlock(&priv->mutex);
5397                 return;
5398         }
5399 }
5400
5401 static int ipw_best_network(struct ipw_priv *priv,
5402                             struct ipw_network_match *match,
5403                             struct ieee80211_network *network, int roaming)
5404 {
5405         struct ipw_supported_rates rates;
5406
5407         /* Verify that this network's capability is compatible with the
5408          * current mode (AdHoc or Infrastructure) */
5409         if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
5410              !(network->capability & WLAN_CAPABILITY_ESS)) ||
5411             (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5412              !(network->capability & WLAN_CAPABILITY_IBSS))) {
5413                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded due to "
5414                                 "capability mismatch.\n",
5415                                 escape_essid(network->ssid, network->ssid_len),
5416                                 MAC_ARG(network->bssid));
5417                 return 0;
5418         }
5419
5420         /* If we do not have an ESSID for this AP, we can not associate with
5421          * it */
5422         if (network->flags & NETWORK_EMPTY_ESSID) {
5423                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5424                                 "because of hidden ESSID.\n",
5425                                 escape_essid(network->ssid, network->ssid_len),
5426                                 MAC_ARG(network->bssid));
5427                 return 0;
5428         }
5429
5430         if (unlikely(roaming)) {
5431                 /* If we are roaming, then ensure check if this is a valid
5432                  * network to try and roam to */
5433                 if ((network->ssid_len != match->network->ssid_len) ||
5434                     memcmp(network->ssid, match->network->ssid,
5435                            network->ssid_len)) {
5436                         IPW_DEBUG_ASSOC("Netowrk '%s (" MAC_FMT ")' excluded "
5437                                         "because of non-network ESSID.\n",
5438                                         escape_essid(network->ssid,
5439                                                      network->ssid_len),
5440                                         MAC_ARG(network->bssid));
5441                         return 0;
5442                 }
5443         } else {
5444                 /* If an ESSID has been configured then compare the broadcast
5445                  * ESSID to ours */
5446                 if ((priv->config & CFG_STATIC_ESSID) &&
5447                     ((network->ssid_len != priv->essid_len) ||
5448                      memcmp(network->ssid, priv->essid,
5449                             min(network->ssid_len, priv->essid_len)))) {
5450                         char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5451                         strncpy(escaped,
5452                                 escape_essid(network->ssid, network->ssid_len),
5453                                 sizeof(escaped));
5454                         IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5455                                         "because of ESSID mismatch: '%s'.\n",
5456                                         escaped, MAC_ARG(network->bssid),
5457                                         escape_essid(priv->essid,
5458                                                      priv->essid_len));
5459                         return 0;
5460                 }
5461         }
5462
5463         /* If the old network rate is better than this one, don't bother
5464          * testing everything else. */
5465         if (match->network && match->network->stats.rssi > network->stats.rssi) {
5466                 char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
5467                 strncpy(escaped,
5468                         escape_essid(network->ssid, network->ssid_len),
5469                         sizeof(escaped));
5470                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded because "
5471                                 "'%s (" MAC_FMT ")' has a stronger signal.\n",
5472                                 escaped, MAC_ARG(network->bssid),
5473                                 escape_essid(match->network->ssid,
5474                                              match->network->ssid_len),
5475                                 MAC_ARG(match->network->bssid));
5476                 return 0;
5477         }
5478
5479         /* If this network has already had an association attempt within the
5480          * last 3 seconds, do not try and associate again... */
5481         if (network->last_associate &&
5482             time_after(network->last_associate + (HZ * 3UL), jiffies)) {
5483                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5484                                 "because of storming (%ums since last "
5485                                 "assoc attempt).\n",
5486                                 escape_essid(network->ssid, network->ssid_len),
5487                                 MAC_ARG(network->bssid),
5488                                 jiffies_to_msecs(jiffies -
5489                                                  network->last_associate));
5490                 return 0;
5491         }
5492
5493         /* Now go through and see if the requested network is valid... */
5494         if (priv->ieee->scan_age != 0 &&
5495             time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5496                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5497                                 "because of age: %ums.\n",
5498                                 escape_essid(network->ssid, network->ssid_len),
5499                                 MAC_ARG(network->bssid),
5500                                 jiffies_to_msecs(jiffies -
5501                                                  network->last_scanned));
5502                 return 0;
5503         }
5504
5505         if ((priv->config & CFG_STATIC_CHANNEL) &&
5506             (network->channel != priv->channel)) {
5507                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5508                                 "because of channel mismatch: %d != %d.\n",
5509                                 escape_essid(network->ssid, network->ssid_len),
5510                                 MAC_ARG(network->bssid),
5511                                 network->channel, priv->channel);
5512                 return 0;
5513         }
5514
5515         /* Verify privacy compatability */
5516         if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5517             ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5518                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5519                                 "because of privacy mismatch: %s != %s.\n",
5520                                 escape_essid(network->ssid, network->ssid_len),
5521                                 MAC_ARG(network->bssid),
5522                                 priv->capability & CAP_PRIVACY_ON ? "on" :
5523                                 "off",
5524                                 network->capability &
5525                                 WLAN_CAPABILITY_PRIVACY ? "on" : "off");
5526                 return 0;
5527         }
5528
5529         if ((priv->config & CFG_STATIC_BSSID) &&
5530             memcmp(network->bssid, priv->bssid, ETH_ALEN)) {
5531                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5532                                 "because of BSSID mismatch: " MAC_FMT ".\n",
5533                                 escape_essid(network->ssid, network->ssid_len),
5534                                 MAC_ARG(network->bssid), MAC_ARG(priv->bssid));
5535                 return 0;
5536         }
5537
5538         /* Filter out any incompatible freq / mode combinations */
5539         if (!ieee80211_is_valid_mode(priv->ieee, network->mode)) {
5540                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5541                                 "because of invalid frequency/mode "
5542                                 "combination.\n",
5543                                 escape_essid(network->ssid, network->ssid_len),
5544                                 MAC_ARG(network->bssid));
5545                 return 0;
5546         }
5547
5548         /* Filter out invalid channel in current GEO */
5549         if (!ieee80211_is_valid_channel(priv->ieee, network->channel)) {
5550                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5551                                 "because of invalid channel in current GEO\n",
5552                                 escape_essid(network->ssid, network->ssid_len),
5553                                 MAC_ARG(network->bssid));
5554                 return 0;
5555         }
5556
5557         /* Ensure that the rates supported by the driver are compatible with
5558          * this AP, including verification of basic rates (mandatory) */
5559         if (!ipw_compatible_rates(priv, network, &rates)) {
5560                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5561                                 "because configured rate mask excludes "
5562                                 "AP mandatory rate.\n",
5563                                 escape_essid(network->ssid, network->ssid_len),
5564                                 MAC_ARG(network->bssid));
5565                 return 0;
5566         }
5567
5568         if (rates.num_rates == 0) {
5569                 IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
5570                                 "because of no compatible rates.\n",
5571                                 escape_essid(network->ssid, network->ssid_len),
5572                                 MAC_ARG(network->bssid));
5573                 return 0;
5574         }
5575
5576         /* TODO: Perform any further minimal comparititive tests.  We do not
5577          * want to put too much policy logic here; intelligent scan selection
5578          * should occur within a generic IEEE 802.11 user space tool.  */
5579
5580         /* Set up 'new' AP to this network */
5581         ipw_copy_rates(&match->rates, &rates);
5582         match->network = network;
5583
5584         IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' is a viable match.\n",
5585                         escape_essid(network->ssid, network->ssid_len),
5586                         MAC_ARG(network->bssid));
5587
5588         return 1;
5589 }
5590
5591 static void ipw_adhoc_create(struct ipw_priv *priv,
5592                              struct ieee80211_network *network)
5593 {
5594         const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
5595         int i;
5596
5597         /*
5598          * For the purposes of scanning, we can set our wireless mode
5599          * to trigger scans across combinations of bands, but when it
5600          * comes to creating a new ad-hoc network, we have tell the FW
5601          * exactly which band to use.
5602          *
5603          * We also have the possibility of an invalid channel for the
5604          * chossen band.  Attempting to create a new ad-hoc network
5605          * with an invalid channel for wireless mode will trigger a
5606          * FW fatal error.
5607          *
5608          */
5609         switch (ieee80211_is_valid_channel(priv->ieee, priv->channel)) {
5610         case IEEE80211_52GHZ_BAND:
5611                 network->mode = IEEE_A;
5612                 i = ieee80211_channel_to_index(priv->ieee, priv->channel);
5613                 if (i == -1)
5614                         BUG();
5615                 if (geo->a[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5616                         IPW_WARNING("Overriding invalid channel\n");
5617                         priv->channel = geo->a[0].channel;
5618                 }
5619                 break;
5620
5621         case IEEE80211_24GHZ_BAND:
5622                 if (priv->ieee->mode & IEEE_G)
5623                         network->mode = IEEE_G;
5624                 else
5625                         network->mode = IEEE_B;
5626                 i = ieee80211_channel_to_index(priv->ieee, priv->channel);
5627                 if (i == -1)
5628                         BUG();
5629                 if (geo->bg[i].flags & IEEE80211_CH_PASSIVE_ONLY) {
5630                         IPW_WARNING("Overriding invalid channel\n");
5631                         priv->channel = geo->bg[0].channel;
5632                 }
5633                 break;
5634
5635         default:
5636                 IPW_WARNING("Overriding invalid channel\n");
5637                 if (priv->ieee->mode & IEEE_A) {
5638                         network->mode = IEEE_A;
5639                         priv->channel = geo->a[0].channel;
5640                 } else if (priv->ieee->mode & IEEE_G) {
5641                         network->mode = IEEE_G;
5642                         priv->channel = geo->bg[0].channel;
5643                 } else {
5644                         network->mode = IEEE_B;
5645                         priv->channel = geo->bg[0].channel;
5646                 }
5647                 break;
5648         }
5649
5650         network->channel = priv->channel;
5651         priv->config |= CFG_ADHOC_PERSIST;
5652         ipw_create_bssid(priv, network->bssid);
5653         network->ssid_len = priv->essid_len;
5654         memcpy(network->ssid, priv->essid, priv->essid_len);
5655         memset(&network->stats, 0, sizeof(network->stats));
5656         network->capability = WLAN_CAPABILITY_IBSS;
5657         if (!(priv->config & CFG_PREAMBLE_LONG))
5658                 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
5659         if (priv->capability & CAP_PRIVACY_ON)
5660                 network->capability |= WLAN_CAPABILITY_PRIVACY;
5661         network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
5662         memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
5663         network->rates_ex_len = priv->rates.num_rates - network->rates_len;
5664         memcpy(network->rates_ex,
5665                &priv->rates.supported_rates[network->rates_len],
5666                network->rates_ex_len);
5667         network->last_scanned = 0;
5668         network->flags = 0;
5669         network->last_associate = 0;
5670         network->time_stamp[0] = 0;
5671         network->time_stamp[1] = 0;
5672         network->beacon_interval = 100; /* Default */
5673         network->listen_interval = 10;  /* Default */
5674         network->atim_window = 0;       /* Default */
5675         network->wpa_ie_len = 0;
5676         network->rsn_ie_len = 0;
5677 }
5678
5679 static void ipw_send_tgi_tx_key(struct ipw_priv *priv, int type, int index)
5680 {
5681         struct ipw_tgi_tx_key key;
5682
5683         if (!(priv->ieee->sec.flags & (1 << index)))
5684                 return;
5685
5686         key.key_id = index;
5687         memcpy(key.key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
5688         key.security_type = type;
5689         key.station_index = 0;  /* always 0 for BSS */
5690         key.flags = 0;
5691         /* 0 for new key; previous value of counter (after fatal error) */
5692         key.tx_counter[0] = 0;
5693         key.tx_counter[1] = 0;
5694
5695         ipw_send_cmd_pdu(priv, IPW_CMD_TGI_TX_KEY, sizeof(key), &key);
5696 }
5697
5698 static void ipw_send_wep_keys(struct ipw_priv *priv, int type)
5699 {
5700         struct ipw_wep_key key;
5701         int i;
5702
5703         key.cmd_id = DINO_CMD_WEP_KEY;
5704         key.seq_num = 0;
5705
5706         /* Note: AES keys cannot be set for multiple times.
5707          * Only set it at the first time. */
5708         for (i = 0; i < 4; i++) {
5709                 key.key_index = i | type;
5710                 if (!(priv->ieee->sec.flags & (1 << i))) {
5711                         key.key_size = 0;
5712                         continue;
5713                 }
5714
5715                 key.key_size = priv->ieee->sec.key_sizes[i];
5716                 memcpy(key.key, priv->ieee->sec.keys[i], key.key_size);
5717
5718                 ipw_send_cmd_pdu(priv, IPW_CMD_WEP_KEY, sizeof(key), &key);
5719         }
5720 }
5721
5722 static void ipw_set_hw_decrypt_unicast(struct ipw_priv *priv, int level)
5723 {
5724         if (priv->ieee->host_encrypt)
5725                 return;
5726
5727         switch (level) {
5728         case SEC_LEVEL_3:
5729                 priv->sys_config.disable_unicast_decryption = 0;
5730                 priv->ieee->host_decrypt = 0;
5731                 break;
5732         case SEC_LEVEL_2:
5733                 priv->sys_config.disable_unicast_decryption = 1;
5734                 priv->ieee->host_decrypt = 1;
5735                 break;
5736         case SEC_LEVEL_1:
5737                 priv->sys_config.disable_unicast_decryption = 0;
5738                 priv->ieee->host_decrypt = 0;
5739                 break;
5740         case SEC_LEVEL_0:
5741                 priv->sys_config.disable_unicast_decryption = 1;
5742                 break;
5743         default:
5744                 break;
5745         }
5746 }
5747
5748 static void ipw_set_hw_decrypt_multicast(struct ipw_priv *priv, int level)
5749 {
5750         if (priv->ieee->host_encrypt)
5751                 return;
5752
5753         switch (level) {
5754         case SEC_LEVEL_3:
5755                 priv->sys_config.disable_multicast_decryption = 0;
5756                 break;
5757         case SEC_LEVEL_2:
5758                 priv->sys_config.disable_multicast_decryption = 1;
5759                 break;
5760         case SEC_LEVEL_1:
5761                 priv->sys_config.disable_multicast_decryption = 0;
5762                 break;
5763         case SEC_LEVEL_0:
5764                 priv->sys_config.disable_multicast_decryption = 1;
5765                 break;
5766         default:
5767                 break;
5768         }
5769 }
5770
5771 static void ipw_set_hwcrypto_keys(struct ipw_priv *priv)
5772 {
5773         switch (priv->ieee->sec.level) {
5774         case SEC_LEVEL_3:
5775                 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5776                         ipw_send_tgi_tx_key(priv,
5777                                             DCT_FLAG_EXT_SECURITY_CCM,
5778                                             priv->ieee->sec.active_key);
5779
5780                 if (!priv->ieee->host_mc_decrypt)
5781                         ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_CCM);
5782                 break;
5783         case SEC_LEVEL_2:
5784                 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5785                         ipw_send_tgi_tx_key(priv,
5786                                             DCT_FLAG_EXT_SECURITY_TKIP,
5787                                             priv->ieee->sec.active_key);
5788                 break;
5789         case SEC_LEVEL_1:
5790                 ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
5791                 ipw_set_hw_decrypt_unicast(priv, priv->ieee->sec.level);
5792                 ipw_set_hw_decrypt_multicast(priv, priv->ieee->sec.level);
5793                 break;
5794         case SEC_LEVEL_0:
5795         default:
5796                 break;
5797         }
5798 }
5799
5800 static void ipw_adhoc_check(void *data)
5801 {
5802         struct ipw_priv *priv = data;
5803
5804         if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
5805             !(priv->config & CFG_ADHOC_PERSIST)) {
5806                 IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
5807                           IPW_DL_STATE | IPW_DL_ASSOC,
5808                           "Missed beacon: %d - disassociate\n",
5809                           priv->missed_adhoc_beacons);
5810                 ipw_remove_current_network(priv);
5811                 ipw_disassociate(priv);
5812                 return;
5813         }
5814
5815         queue_delayed_work(priv->workqueue, &priv->adhoc_check,
5816                            priv->assoc_request.beacon_interval);
5817 }
5818
5819 static void ipw_bg_adhoc_check(void *data)
5820 {
5821         struct ipw_priv *priv = data;
5822         mutex_lock(&priv->mutex);
5823         ipw_adhoc_check(data);
5824         mutex_unlock(&priv->mutex);
5825 }
5826
5827 #ifdef CONFIG_IPW2200_DEBUG
5828 static void ipw_debug_config(struct ipw_priv *priv)
5829 {
5830         IPW_DEBUG_INFO("Scan completed, no valid APs matched "
5831                        "[CFG 0x%08X]\n", priv->config);
5832         if (priv->config & CFG_STATIC_CHANNEL)
5833                 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
5834         else
5835                 IPW_DEBUG_INFO("Channel unlocked.\n");
5836         if (priv->config & CFG_STATIC_ESSID)
5837                 IPW_DEBUG_INFO("ESSID locked to '%s'\n",
5838                                escape_essid(priv->essid, priv->essid_len));
5839         else
5840                 IPW_DEBUG_INFO("ESSID unlocked.\n");
5841         if (priv->config & CFG_STATIC_BSSID)
5842                 IPW_DEBUG_INFO("BSSID locked to " MAC_FMT "\n",
5843                                MAC_ARG(priv->bssid));
5844         else
5845                 IPW_DEBUG_INFO("BSSID unlocked.\n");
5846         if (priv->capability & CAP_PRIVACY_ON)
5847                 IPW_DEBUG_INFO("PRIVACY on\n");
5848         else
5849                 IPW_DEBUG_INFO("PRIVACY off\n");
5850         IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
5851 }
5852 #else
5853 #define ipw_debug_config(x) do {} while (0)
5854 #endif
5855
5856 static void ipw_set_fixed_rate(struct ipw_priv *priv, int mode)
5857 {
5858         /* TODO: Verify that this works... */
5859         struct ipw_fixed_rate fr = {
5860                 .tx_rates = priv->rates_mask
5861         };
5862         u32 reg;
5863         u16 mask = 0;
5864
5865         /* Identify 'current FW band' and match it with the fixed
5866          * Tx rates */
5867
5868         switch (priv->ieee->freq_band) {
5869         case IEEE80211_52GHZ_BAND:      /* A only */
5870                 /* IEEE_A */
5871                 if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) {
5872                         /* Invalid fixed rate mask */
5873                         IPW_DEBUG_WX
5874                             ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5875                         fr.tx_rates = 0;
5876                         break;
5877                 }
5878
5879                 fr.tx_rates >>= IEEE80211_OFDM_SHIFT_MASK_A;
5880                 break;
5881
5882         default:                /* 2.4Ghz or Mixed */
5883                 /* IEEE_B */
5884                 if (mode == IEEE_B) {
5885                         if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) {
5886                                 /* Invalid fixed rate mask */
5887                                 IPW_DEBUG_WX
5888                                     ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5889                                 fr.tx_rates = 0;
5890                         }
5891                         break;
5892                 }
5893
5894                 /* IEEE_G */
5895                 if (fr.tx_rates & ~(IEEE80211_CCK_RATES_MASK |
5896                                     IEEE80211_OFDM_RATES_MASK)) {
5897                         /* Invalid fixed rate mask */
5898                         IPW_DEBUG_WX
5899                             ("invalid fixed rate mask in ipw_set_fixed_rate\n");
5900                         fr.tx_rates = 0;
5901                         break;
5902                 }
5903
5904                 if (IEEE80211_OFDM_RATE_6MB_MASK & fr.tx_rates) {
5905                         mask |= (IEEE80211_OFDM_RATE_6MB_MASK >> 1);
5906                         fr.tx_rates &= ~IEEE80211_OFDM_RATE_6MB_MASK;
5907                 }
5908
5909                 if (IEEE80211_OFDM_RATE_9MB_MASK & fr.tx_rates) {
5910                         mask |= (IEEE80211_OFDM_RATE_9MB_MASK >> 1);
5911                         fr.tx_rates &= ~IEEE80211_OFDM_RATE_9MB_MASK;
5912                 }
5913
5914                 if (IEEE80211_OFDM_RATE_12MB_MASK & fr.tx_rates) {
5915                         mask |= (IEEE80211_OFDM_RATE_12MB_MASK >> 1);
5916                         fr.tx_rates &= ~IEEE80211_OFDM_RATE_12MB_MASK;
5917                 }
5918
5919                 fr.tx_rates |= mask;
5920                 break;
5921         }
5922
5923         reg = ipw_read32(priv, IPW_MEM_FIXED_OVERRIDE);
5924         ipw_write_reg32(priv, reg, *(u32 *) & fr);
5925 }
5926
5927 static void ipw_abort_scan(struct ipw_priv *priv)
5928 {
5929         int err;
5930
5931         if (priv->status & STATUS_SCAN_ABORTING) {
5932                 IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
5933                 return;
5934         }
5935         priv->status |= STATUS_SCAN_ABORTING;
5936
5937         err = ipw_send_scan_abort(priv);
5938         if (err)
5939                 IPW_DEBUG_HC("Request to abort scan failed.\n");
5940 }
5941
5942 static void ipw_add_scan_channels(struct ipw_priv *priv,
5943                                   struct ipw_scan_request_ext *scan,
5944                                   int scan_type)
5945 {
5946         int channel_index = 0;
5947         const struct ieee80211_geo *geo;
5948         int i;
5949
5950         geo = ieee80211_get_geo(priv->ieee);
5951
5952         if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) {
5953                 int start = channel_index;
5954                 for (i = 0; i < geo->a_channels; i++) {
5955                         if ((priv->status & STATUS_ASSOCIATED) &&
5956                             geo->a[i].channel == priv->channel)
5957                                 continue;
5958                         channel_index++;
5959                         scan->channels_list[channel_index] = geo->a[i].channel;
5960                         ipw_set_scan_type(scan, channel_index,
5961                                           geo->a[i].
5962                                           flags & IEEE80211_CH_PASSIVE_ONLY ?
5963                                           IPW_SCAN_PASSIVE_FULL_DWELL_SCAN :
5964                                           scan_type);
5965                 }
5966
5967                 if (start != channel_index) {
5968                         scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
5969                             (channel_index - start);
5970                         channel_index++;
5971                 }
5972         }
5973
5974         if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) {
5975                 int start = channel_index;
5976                 if (priv->config & CFG_SPEED_SCAN) {
5977                         int index;
5978                         u8 channels[IEEE80211_24GHZ_CHANNELS] = {
5979                                 /* nop out the list */
5980                                 [0] = 0
5981                         };
5982
5983                         u8 channel;
5984                         while (channel_index < IPW_SCAN_CHANNELS) {
5985                                 channel =
5986                                     priv->speed_scan[priv->speed_scan_pos];
5987                                 if (channel == 0) {
5988                                         priv->speed_scan_pos = 0;
5989                                         channel = priv->speed_scan[0];
5990                                 }
5991                                 if ((priv->status & STATUS_ASSOCIATED) &&
5992                                     channel == priv->channel) {
5993                                         priv->speed_scan_pos++;
5994                                         continue;
5995                                 }
5996
5997                                 /* If this channel has already been
5998                                  * added in scan, break from loop
5999                                  * and this will be the first channel
6000                                  * in the next scan.
6001                                  */
6002                                 if (channels[channel - 1] != 0)
6003                                         break;
6004
6005                                 channels[channel - 1] = 1;
6006                                 priv->speed_scan_pos++;
6007                                 channel_index++;
6008                                 scan->channels_list[channel_index] = channel;
6009                                 index =
6010                                     ieee80211_channel_to_index(priv->ieee, channel);
6011                                 ipw_set_scan_type(scan, channel_index,
6012                                                   geo->bg[index].
6013                                                   flags &
6014                                                   IEEE80211_CH_PASSIVE_ONLY ?
6015                                                   IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6016                                                   : scan_type);
6017                         }
6018                 } else {
6019                         for (i = 0; i < geo->bg_channels; i++) {
6020                                 if ((priv->status & STATUS_ASSOCIATED) &&
6021                                     geo->bg[i].channel == priv->channel)
6022                                         continue;
6023                                 channel_index++;
6024                                 scan->channels_list[channel_index] =
6025                                     geo->bg[i].channel;
6026                                 ipw_set_scan_type(scan, channel_index,
6027                                                   geo->bg[i].
6028                                                   flags &
6029                                                   IEEE80211_CH_PASSIVE_ONLY ?
6030                                                   IPW_SCAN_PASSIVE_FULL_DWELL_SCAN
6031                                                   : scan_type);
6032                         }
6033                 }
6034
6035                 if (start != channel_index) {
6036                         scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6037                             (channel_index - start);
6038                 }
6039         }
6040 }
6041
6042 static int ipw_request_scan(struct ipw_priv *priv)
6043 {
6044         struct ipw_scan_request_ext scan;
6045         int err = 0, scan_type;
6046
6047         if (!(priv->status & STATUS_INIT) ||
6048             (priv->status & STATUS_EXIT_PENDING))
6049                 return 0;
6050
6051         mutex_lock(&priv->mutex);
6052
6053         if (priv->status & STATUS_SCANNING) {
6054                 IPW_DEBUG_HC("Concurrent scan requested.  Ignoring.\n");
6055                 priv->status |= STATUS_SCAN_PENDING;
6056                 goto done;
6057         }
6058
6059         if (!(priv->status & STATUS_SCAN_FORCED) &&
6060             priv->status & STATUS_SCAN_ABORTING) {
6061                 IPW_DEBUG_HC("Scan request while abort pending.  Queuing.\n");
6062                 priv->status |= STATUS_SCAN_PENDING;
6063                 goto done;
6064         }
6065
6066         if (priv->status & STATUS_RF_KILL_MASK) {
6067                 IPW_DEBUG_HC("Aborting scan due to RF Kill activation\n");
6068                 priv->status |= STATUS_SCAN_PENDING;
6069                 goto done;
6070         }
6071
6072         memset(&scan, 0, sizeof(scan));
6073
6074         if (priv->config & CFG_SPEED_SCAN)
6075                 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6076                     cpu_to_le16(30);
6077         else
6078                 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
6079                     cpu_to_le16(20);
6080
6081         scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
6082             cpu_to_le16(20);
6083         scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
6084
6085         scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
6086
6087 #ifdef CONFIG_IPW2200_MONITOR
6088         if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
6089                 u8 channel;
6090                 u8 band = 0;
6091
6092                 switch (ieee80211_is_valid_channel(priv->ieee, priv->channel)) {
6093                 case IEEE80211_52GHZ_BAND:
6094                         band = (u8) (IPW_A_MODE << 6) | 1;
6095                         channel = priv->channel;
6096                         break;
6097
6098                 case IEEE80211_24GHZ_BAND:
6099                         band = (u8) (IPW_B_MODE << 6) | 1;
6100                         channel = priv->channel;
6101                         break;
6102
6103                 default:
6104                         band = (u8) (IPW_B_MODE << 6) | 1;
6105                         channel = 9;
6106                         break;
6107                 }
6108
6109                 scan.channels_list[0] = band;
6110                 scan.channels_list[1] = channel;
6111                 ipw_set_scan_type(&scan, 1, IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
6112
6113                 /* NOTE:  The card will sit on this channel for this time
6114                  * period.  Scan aborts are timing sensitive and frequently
6115                  * result in firmware restarts.  As such, it is best to
6116                  * set a small dwell_time here and just keep re-issuing
6117                  * scans.  Otherwise fast channel hopping will not actually
6118                  * hop channels.
6119                  *
6120                  * TODO: Move SPEED SCAN support to all modes and bands */
6121                 scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] =
6122                     cpu_to_le16(2000);
6123         } else {
6124 #endif                          /* CONFIG_IPW2200_MONITOR */
6125                 /* If we are roaming, then make this a directed scan for the
6126                  * current network.  Otherwise, ensure that every other scan
6127                  * is a fast channel hop scan */
6128                 if ((priv->status & STATUS_ROAMING)
6129                     || (!(priv->status & STATUS_ASSOCIATED)
6130                         && (priv->config & CFG_STATIC_ESSID)
6131                         && (le32_to_cpu(scan.full_scan_index) % 2))) {
6132                         err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6133                         if (err) {
6134                                 IPW_DEBUG_HC("Attempt to send SSID command "
6135                                              "failed.\n");
6136                                 goto done;
6137                         }
6138
6139                         scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
6140                 } else
6141                         scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
6142
6143                 ipw_add_scan_channels(priv, &scan, scan_type);
6144 #ifdef CONFIG_IPW2200_MONITOR
6145         }
6146 #endif
6147
6148         err = ipw_send_scan_request_ext(priv, &scan);
6149         if (err) {
6150                 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
6151                 goto done;
6152         }
6153
6154         priv->status |= STATUS_SCANNING;
6155         priv->status &= ~STATUS_SCAN_PENDING;
6156         queue_delayed_work(priv->workqueue, &priv->scan_check,
6157                            IPW_SCAN_CHECK_WATCHDOG);
6158       done:
6159         mutex_unlock(&priv->mutex);
6160         return err;
6161 }
6162
6163 static void ipw_bg_abort_scan(void *data)
6164 {
6165         struct ipw_priv *priv = data;
6166         mutex_lock(&priv->mutex);
6167         ipw_abort_scan(data);
6168         mutex_unlock(&priv->mutex);
6169 }
6170
6171 static int ipw_wpa_enable(struct ipw_priv *priv, int value)
6172 {
6173         /* This is called when wpa_supplicant loads and closes the driver
6174          * interface. */
6175         priv->ieee->wpa_enabled = value;
6176         return 0;
6177 }
6178
6179 static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
6180 {
6181         struct ieee80211_device *ieee = priv->ieee;
6182         struct ieee80211_security sec = {
6183                 .flags = SEC_AUTH_MODE,
6184         };
6185         int ret = 0;
6186
6187         if (value & IW_AUTH_ALG_SHARED_KEY) {
6188                 sec.auth_mode = WLAN_AUTH_SHARED_KEY;
6189                 ieee->open_wep = 0;
6190         } else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
6191                 sec.auth_mode = WLAN_AUTH_OPEN;
6192                 ieee->open_wep = 1;
6193         } else if (value & IW_AUTH_ALG_LEAP) {
6194                 sec.auth_mode = WLAN_AUTH_LEAP;
6195                 ieee->open_wep = 1;
6196         } else
6197                 return -EINVAL;
6198
6199         if (ieee->set_security)
6200                 ieee->set_security(ieee->dev, &sec);
6201         else
6202                 ret = -EOPNOTSUPP;
6203
6204         return ret;
6205 }
6206
6207 static void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie,
6208                                 int wpa_ie_len)
6209 {
6210         /* make sure WPA is enabled */
6211         ipw_wpa_enable(priv, 1);
6212
6213         ipw_disassociate(priv);
6214 }
6215
6216 static int ipw_set_rsn_capa(struct ipw_priv *priv,
6217                             char *capabilities, int length)
6218 {
6219         IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
6220
6221         return ipw_send_cmd_pdu(priv, IPW_CMD_RSN_CAPABILITIES, length,
6222                                 capabilities);
6223 }
6224
6225 /*
6226  * WE-18 support
6227  */
6228
6229 /* SIOCSIWGENIE */
6230 static int ipw_wx_set_genie(struct net_device *dev,
6231                             struct iw_request_info *info,
6232                             union iwreq_data *wrqu, char *extra)
6233 {
6234         struct ipw_priv *priv = ieee80211_priv(dev);
6235         struct ieee80211_device *ieee = priv->ieee;
6236         u8 *buf;
6237         int err = 0;
6238
6239         if (wrqu->data.length > MAX_WPA_IE_LEN ||
6240             (wrqu->data.length && extra == NULL))
6241                 return -EINVAL;
6242
6243         //mutex_lock(&priv->mutex);
6244
6245         //if (!ieee->wpa_enabled) {
6246         //      err = -EOPNOTSUPP;
6247         //      goto out;
6248         //}
6249
6250         if (wrqu->data.length) {
6251                 buf = kmalloc(wrqu->data.length, GFP_KERNEL);
6252                 if (buf == NULL) {
6253                         err = -ENOMEM;
6254                         goto out;
6255                 }
6256
6257                 memcpy(buf, extra, wrqu->data.length);
6258                 kfree(ieee->wpa_ie);
6259                 ieee->wpa_ie = buf;
6260                 ieee->wpa_ie_len = wrqu->data.length;
6261         } else {
6262                 kfree(ieee->wpa_ie);
6263                 ieee->wpa_ie = NULL;
6264                 ieee->wpa_ie_len = 0;
6265         }
6266
6267         ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6268       out:
6269         //mutex_unlock(&priv->mutex);
6270         return err;
6271 }
6272
6273 /* SIOCGIWGENIE */
6274 static int ipw_wx_get_genie(struct net_device *dev,
6275                             struct iw_request_info *info,
6276                             union iwreq_data *wrqu, char *extra)
6277 {
6278         struct ipw_priv *priv = ieee80211_priv(dev);
6279         struct ieee80211_device *ieee = priv->ieee;
6280         int err = 0;
6281
6282         //mutex_lock(&priv->mutex);
6283
6284         //if (!ieee->wpa_enabled) {
6285         //      err = -EOPNOTSUPP;
6286         //      goto out;
6287         //}
6288
6289         if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6290                 wrqu->data.length = 0;
6291                 goto out;
6292         }
6293
6294         if (wrqu->data.length < ieee->wpa_ie_len) {
6295                 err = -E2BIG;
6296                 goto out;
6297         }
6298
6299         wrqu->data.length = ieee->wpa_ie_len;
6300         memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6301
6302       out:
6303         //mutex_unlock(&priv->mutex);
6304         return err;
6305 }
6306
6307 static int wext_cipher2level(int cipher)
6308 {
6309         switch (cipher) {
6310         case IW_AUTH_CIPHER_NONE:
6311                 return SEC_LEVEL_0;
6312         case IW_AUTH_CIPHER_WEP40:
6313         case IW_AUTH_CIPHER_WEP104:
6314                 return SEC_LEVEL_1;
6315         case IW_AUTH_CIPHER_TKIP:
6316                 return SEC_LEVEL_2;
6317         case IW_AUTH_CIPHER_CCMP:
6318                 return SEC_LEVEL_3;
6319         default:
6320                 return -1;
6321         }
6322 }
6323
6324 /* SIOCSIWAUTH */
6325 static int ipw_wx_set_auth(struct net_device *dev,
6326                            struct iw_request_info *info,
6327                            union iwreq_data *wrqu, char *extra)
6328 {
6329         struct ipw_priv *priv = ieee80211_priv(dev);
6330         struct ieee80211_device *ieee = priv->ieee;
6331         struct iw_param *param = &wrqu->param;
6332         struct ieee80211_crypt_data *crypt;
6333         unsigned long flags;
6334         int ret = 0;
6335
6336         switch (param->flags & IW_AUTH_INDEX) {
6337         case IW_AUTH_WPA_VERSION:
6338                 break;
6339         case IW_AUTH_CIPHER_PAIRWISE:
6340                 ipw_set_hw_decrypt_unicast(priv,
6341                                            wext_cipher2level(param->value));
6342                 break;
6343         case IW_AUTH_CIPHER_GROUP:
6344                 ipw_set_hw_decrypt_multicast(priv,
6345                                              wext_cipher2level(param->value));
6346                 break;
6347         case IW_AUTH_KEY_MGMT:
6348                 /*
6349                  * ipw2200 does not use these parameters
6350                  */
6351                 break;
6352
6353         case IW_AUTH_TKIP_COUNTERMEASURES:
6354                 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6355                 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
6356                         break;
6357
6358                 flags = crypt->ops->get_flags(crypt->priv);
6359
6360                 if (param->value)
6361                         flags |= IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6362                 else
6363                         flags &= ~IEEE80211_CRYPTO_TKIP_COUNTERMEASURES;
6364
6365                 crypt->ops->set_flags(flags, crypt->priv);
6366
6367                 break;
6368
6369         case IW_AUTH_DROP_UNENCRYPTED:{
6370                         /* HACK:
6371                          *
6372                          * wpa_supplicant calls set_wpa_enabled when the driver
6373                          * is loaded and unloaded, regardless of if WPA is being
6374                          * used.  No other calls are made which can be used to
6375                          * determine if encryption will be used or not prior to
6376                          * association being expected.  If encryption is not being
6377                          * used, drop_unencrypted is set to false, else true -- we
6378                          * can use this to determine if the CAP_PRIVACY_ON bit should
6379                          * be set.
6380                          */
6381                         struct ieee80211_security sec = {
6382                                 .flags = SEC_ENABLED,
6383                                 .enabled = param->value,
6384                         };
6385                         priv->ieee->drop_unencrypted = param->value;
6386                         /* We only change SEC_LEVEL for open mode. Others
6387                          * are set by ipw_wpa_set_encryption.
6388                          */
6389                         if (!param->value) {
6390                                 sec.flags |= SEC_LEVEL;
6391                                 sec.level = SEC_LEVEL_0;
6392                         } else {
6393                                 sec.flags |= SEC_LEVEL;
6394                                 sec.level = SEC_LEVEL_1;
6395                         }
6396                         if (priv->ieee->set_security)
6397                                 priv->ieee->set_security(priv->ieee->dev, &sec);
6398                         break;
6399                 }
6400
6401         case IW_AUTH_80211_AUTH_ALG:
6402                 ret = ipw_wpa_set_auth_algs(priv, param->value);
6403                 break;
6404
6405         case IW_AUTH_WPA_ENABLED:
6406                 ret = ipw_wpa_enable(priv, param->value);
6407                 break;
6408
6409         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6410                 ieee->ieee802_1x = param->value;
6411                 break;
6412
6413                 //case IW_AUTH_ROAMING_CONTROL:
6414         case IW_AUTH_PRIVACY_INVOKED:
6415                 ieee->privacy_invoked = param->value;
6416                 break;
6417
6418         default:
6419                 return -EOPNOTSUPP;
6420         }
6421         return ret;
6422 }
6423
6424 /* SIOCGIWAUTH */
6425 static int ipw_wx_get_auth(struct net_device *dev,
6426                            struct iw_request_info *info,
6427                            union iwreq_data *wrqu, char *extra)
6428 {
6429         struct ipw_priv *priv = ieee80211_priv(dev);
6430         struct ieee80211_device *ieee = priv->ieee;
6431         struct ieee80211_crypt_data *crypt;
6432         struct iw_param *param = &wrqu->param;
6433         int ret = 0;
6434
6435         switch (param->flags & IW_AUTH_INDEX) {
6436         case IW_AUTH_WPA_VERSION:
6437         case IW_AUTH_CIPHER_PAIRWISE:
6438         case IW_AUTH_CIPHER_GROUP:
6439         case IW_AUTH_KEY_MGMT:
6440                 /*
6441                  * wpa_supplicant will control these internally
6442                  */
6443                 ret = -EOPNOTSUPP;
6444                 break;
6445
6446         case IW_AUTH_TKIP_COUNTERMEASURES:
6447                 crypt = priv->ieee->crypt[priv->ieee->tx_keyidx];
6448                 if (!crypt || !crypt->ops->get_flags)
6449                         break;
6450
6451                 param->value = (crypt->ops->get_flags(crypt->priv) &
6452                                 IEEE80211_CRYPTO_TKIP_COUNTERMEASURES) ? 1 : 0;
6453
6454                 break;
6455
6456         case IW_AUTH_DROP_UNENCRYPTED:
6457                 param->value = ieee->drop_unencrypted;
6458                 break;
6459
6460         case IW_AUTH_80211_AUTH_ALG:
6461                 param->value = ieee->sec.auth_mode;
6462                 break;
6463
6464         case IW_AUTH_WPA_ENABLED:
6465                 param->value = ieee->wpa_enabled;
6466                 break;
6467
6468         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
6469                 param->value = ieee->ieee802_1x;
6470                 break;
6471
6472         case IW_AUTH_ROAMING_CONTROL:
6473         case IW_AUTH_PRIVACY_INVOKED:
6474                 param->value = ieee->privacy_invoked;
6475                 break;
6476
6477         default:
6478                 return -EOPNOTSUPP;
6479         }
6480         return 0;
6481 }
6482
6483 /* SIOCSIWENCODEEXT */
6484 static int ipw_wx_set_encodeext(struct net_device *dev,
6485                                 struct iw_request_info *info,
6486                                 union iwreq_data *wrqu, char *extra)
6487 {
6488         struct ipw_priv *priv = ieee80211_priv(dev);
6489         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
6490
6491         if (hwcrypto) {
6492                 if (ext->alg == IW_ENCODE_ALG_TKIP) {
6493                         /* IPW HW can't build TKIP MIC,
6494                            host decryption still needed */
6495                         if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6496                                 priv->ieee->host_mc_decrypt = 1;
6497                         else {
6498                                 priv->ieee->host_encrypt = 0;
6499                                 priv->ieee->host_encrypt_msdu = 1;
6500                                 priv->ieee->host_decrypt = 1;
6501                         }
6502                 } else {
6503                         priv->ieee->host_encrypt = 0;
6504                         priv->ieee->host_encrypt_msdu = 0;
6505                         priv->ieee->host_decrypt = 0;
6506                         priv->ieee->host_mc_decrypt = 0;
6507                 }
6508         }
6509
6510         return ieee80211_wx_set_encodeext(priv->ieee, info, wrqu, extra);
6511 }
6512
6513 /* SIOCGIWENCODEEXT */
6514 static int ipw_wx_get_encodeext(struct net_device *dev,
6515                                 struct iw_request_info *info,
6516                                 union iwreq_data *wrqu, char *extra)
6517 {
6518         struct ipw_priv *priv = ieee80211_priv(dev);
6519         return ieee80211_wx_get_encodeext(priv->ieee, info, wrqu, extra);
6520 }
6521
6522 /* SIOCSIWMLME */
6523 static int ipw_wx_set_mlme(struct net_device *dev,
6524                            struct iw_request_info *info,
6525                            union iwreq_data *wrqu, char *extra)
6526 {
6527         struct ipw_priv *priv = ieee80211_priv(dev);
6528         struct iw_mlme *mlme = (struct iw_mlme *)extra;
6529         u16 reason;
6530
6531         reason = cpu_to_le16(mlme->reason_code);
6532
6533         switch (mlme->cmd) {
6534         case IW_MLME_DEAUTH:
6535                 // silently ignore
6536                 break;
6537
6538         case IW_MLME_DISASSOC:
6539                 ipw_disassociate(priv);
6540                 break;
6541
6542         default:
6543                 return -EOPNOTSUPP;
6544         }
6545         return 0;
6546 }
6547
6548 #ifdef CONFIG_IPW_QOS
6549
6550 /* QoS */
6551 /*
6552 * get the modulation type of the current network or
6553 * the card current mode
6554 */
6555 static u8 ipw_qos_current_mode(struct ipw_priv * priv)
6556 {
6557         u8 mode = 0;
6558
6559         if (priv->status & STATUS_ASSOCIATED) {
6560                 unsigned long flags;
6561
6562                 spin_lock_irqsave(&priv->ieee->lock, flags);
6563                 mode = priv->assoc_network->mode;
6564                 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6565         } else {
6566                 mode = priv->ieee->mode;
6567         }
6568         IPW_DEBUG_QOS("QoS network/card mode %d \n", mode);
6569         return mode;
6570 }
6571
6572 /*
6573 * Handle management frame beacon and probe response
6574 */
6575 static int ipw_qos_handle_probe_response(struct ipw_priv *priv,
6576                                          int active_network,
6577                                          struct ieee80211_network *network)
6578 {
6579         u32 size = sizeof(struct ieee80211_qos_parameters);
6580
6581         if (network->capability & WLAN_CAPABILITY_IBSS)
6582                 network->qos_data.active = network->qos_data.supported;
6583
6584         if (network->flags & NETWORK_HAS_QOS_MASK) {
6585                 if (active_network &&
6586                     (network->flags & NETWORK_HAS_QOS_PARAMETERS))
6587                         network->qos_data.active = network->qos_data.supported;
6588
6589                 if ((network->qos_data.active == 1) && (active_network == 1) &&
6590                     (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
6591                     (network->qos_data.old_param_count !=
6592                      network->qos_data.param_count)) {
6593                         network->qos_data.old_param_count =
6594                             network->qos_data.param_count;
6595                         schedule_work(&priv->qos_activate);
6596                         IPW_DEBUG_QOS("QoS parameters change call "
6597                                       "qos_activate\n");
6598                 }
6599         } else {
6600                 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
6601                         memcpy(&network->qos_data.parameters,
6602                                &def_parameters_CCK, size);
6603                 else
6604                         memcpy(&network->qos_data.parameters,
6605                                &def_parameters_OFDM, size);
6606
6607                 if ((network->qos_data.active == 1) && (active_network == 1)) {
6608                         IPW_DEBUG_QOS("QoS was disabled call qos_activate \n");
6609                         schedule_work(&priv->qos_activate);
6610                 }
6611
6612                 network->qos_data.active = 0;
6613                 network->qos_data.supported = 0;
6614         }
6615         if ((priv->status & STATUS_ASSOCIATED) &&
6616             (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
6617                 if (memcmp(network->bssid, priv->bssid, ETH_ALEN))
6618                         if ((network->capability & WLAN_CAPABILITY_IBSS) &&
6619                             !(network->flags & NETWORK_EMPTY_ESSID))
6620                                 if ((network->ssid_len ==
6621                                      priv->assoc_network->ssid_len) &&
6622                                     !memcmp(network->ssid,
6623                                             priv->assoc_network->ssid,
6624                                             network->ssid_len)) {
6625                                         queue_work(priv->workqueue,
6626                                                    &priv->merge_networks);
6627                                 }
6628         }
6629
6630         return 0;
6631 }
6632
6633 /*
6634 * This function set up the firmware to support QoS. It sends
6635 * IPW_CMD_QOS_PARAMETERS and IPW_CMD_WME_INFO
6636 */
6637 static int ipw_qos_activate(struct ipw_priv *priv,
6638                             struct ieee80211_qos_data *qos_network_data)
6639 {
6640         int err;
6641         struct ieee80211_qos_parameters qos_parameters[QOS_QOS_SETS];
6642         struct ieee80211_qos_parameters *active_one = NULL;
6643         u32 size = sizeof(struct ieee80211_qos_parameters);
6644         u32 burst_duration;
6645         int i;
6646         u8 type;
6647
6648         type = ipw_qos_current_mode(priv);
6649
6650         active_one = &(qos_parameters[QOS_PARAM_SET_DEF_CCK]);
6651         memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
6652         active_one = &(qos_parameters[QOS_PARAM_SET_DEF_OFDM]);
6653         memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
6654
6655         if (qos_network_data == NULL) {
6656                 if (type == IEEE_B) {
6657                         IPW_DEBUG_QOS("QoS activate network mode %d\n", type);
6658                         active_one = &def_parameters_CCK;
6659                 } else
6660                         active_one = &def_parameters_OFDM;
6661
6662                 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6663                 burst_duration = ipw_qos_get_burst_duration(priv);
6664                 for (i = 0; i < QOS_QUEUE_NUM; i++)
6665                         qos_parameters[QOS_PARAM_SET_ACTIVE].tx_op_limit[i] =
6666                             (u16) burst_duration;
6667         } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6668                 if (type == IEEE_B) {
6669                         IPW_DEBUG_QOS("QoS activate IBSS nework mode %d\n",
6670                                       type);
6671                         if (priv->qos_data.qos_enable == 0)
6672                                 active_one = &def_parameters_CCK;
6673                         else
6674                                 active_one = priv->qos_data.def_qos_parm_CCK;
6675                 } else {
6676                         if (priv->qos_data.qos_enable == 0)
6677                                 active_one = &def_parameters_OFDM;
6678                         else
6679                                 active_one = priv->qos_data.def_qos_parm_OFDM;
6680                 }
6681                 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6682         } else {
6683                 unsigned long flags;
6684                 int active;
6685
6686                 spin_lock_irqsave(&priv->ieee->lock, flags);
6687                 active_one = &(qos_network_data->parameters);
6688                 qos_network_data->old_param_count =
6689                     qos_network_data->param_count;
6690                 memcpy(&qos_parameters[QOS_PARAM_SET_ACTIVE], active_one, size);
6691                 active = qos_network_data->supported;
6692                 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6693
6694                 if (active == 0) {
6695                         burst_duration = ipw_qos_get_burst_duration(priv);
6696                         for (i = 0; i < QOS_QUEUE_NUM; i++)
6697                                 qos_parameters[QOS_PARAM_SET_ACTIVE].
6698                                     tx_op_limit[i] = (u16) burst_duration;
6699                 }
6700         }
6701
6702         IPW_DEBUG_QOS("QoS sending IPW_CMD_QOS_PARAMETERS\n");
6703         err = ipw_send_qos_params_command(priv,
6704                                           (struct ieee80211_qos_parameters *)
6705                                           &(qos_parameters[0]));
6706         if (err)
6707                 IPW_DEBUG_QOS("QoS IPW_CMD_QOS_PARAMETERS failed\n");
6708
6709         return err;
6710 }
6711
6712 /*
6713 * send IPW_CMD_WME_INFO to the firmware
6714 */
6715 static int ipw_qos_set_info_element(struct ipw_priv *priv)
6716 {
6717         int ret = 0;
6718         struct ieee80211_qos_information_element qos_info;
6719
6720         if (priv == NULL)
6721                 return -1;
6722
6723         qos_info.elementID = QOS_ELEMENT_ID;
6724         qos_info.length = sizeof(struct ieee80211_qos_information_element) - 2;
6725
6726         qos_info.version = QOS_VERSION_1;
6727         qos_info.ac_info = 0;
6728
6729         memcpy(qos_info.qui, qos_oui, QOS_OUI_LEN);
6730         qos_info.qui_type = QOS_OUI_TYPE;
6731         qos_info.qui_subtype = QOS_OUI_INFO_SUB_TYPE;
6732
6733         ret = ipw_send_qos_info_command(priv, &qos_info);
6734         if (ret != 0) {
6735                 IPW_DEBUG_QOS("QoS error calling ipw_send_qos_info_command\n");
6736         }
6737         return ret;
6738 }
6739
6740 /*
6741 * Set the QoS parameter with the association request structure
6742 */
6743 static int ipw_qos_association(struct ipw_priv *priv,
6744                                struct ieee80211_network *network)
6745 {
6746         int err = 0;
6747         struct ieee80211_qos_data *qos_data = NULL;
6748         struct ieee80211_qos_data ibss_data = {
6749                 .supported = 1,
6750                 .active = 1,
6751         };
6752
6753         switch (priv->ieee->iw_mode) {
6754         case IW_MODE_ADHOC:
6755                 if (!(network->capability & WLAN_CAPABILITY_IBSS))
6756                         BUG();
6757
6758                 qos_data = &ibss_data;
6759                 break;
6760
6761         case IW_MODE_INFRA:
6762                 qos_data = &network->qos_data;
6763                 break;
6764
6765         default:
6766                 BUG();
6767                 break;
6768         }
6769
6770         err = ipw_qos_activate(priv, qos_data);
6771         if (err) {
6772                 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
6773                 return err;
6774         }
6775
6776         if (priv->qos_data.qos_enable && qos_data->supported) {
6777                 IPW_DEBUG_QOS("QoS will be enabled for this association\n");
6778                 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
6779                 return ipw_qos_set_info_element(priv);
6780         }
6781
6782         return 0;
6783 }
6784
6785 /*
6786 * handling the beaconing responces. if we get different QoS setting
6787 * of the network from the the associated setting adjust the QoS
6788 * setting
6789 */
6790 static int ipw_qos_association_resp(struct ipw_priv *priv,
6791                                     struct ieee80211_network *network)
6792 {
6793         int ret = 0;
6794         unsigned long flags;
6795         u32 size = sizeof(struct ieee80211_qos_parameters);
6796         int set_qos_param = 0;
6797
6798         if ((priv == NULL) || (network == NULL) ||
6799             (priv->assoc_network == NULL))
6800                 return ret;
6801
6802         if (!(priv->status & STATUS_ASSOCIATED))
6803                 return ret;
6804
6805         if ((priv->ieee->iw_mode != IW_MODE_INFRA))
6806                 return ret;
6807
6808         spin_lock_irqsave(&priv->ieee->lock, flags);
6809         if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
6810                 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
6811                        sizeof(struct ieee80211_qos_data));
6812                 priv->assoc_network->qos_data.active = 1;
6813                 if ((network->qos_data.old_param_count !=
6814                      network->qos_data.param_count)) {
6815                         set_qos_param = 1;
6816                         network->qos_data.old_param_count =
6817                             network->qos_data.param_count;
6818                 }
6819
6820         } else {
6821                 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
6822                         memcpy(&priv->assoc_network->qos_data.parameters,
6823                                &def_parameters_CCK, size);
6824                 else
6825                         memcpy(&priv->assoc_network->qos_data.parameters,
6826                                &def_parameters_OFDM, size);
6827                 priv->assoc_network->qos_data.active = 0;
6828                 priv->assoc_network->qos_data.supported = 0;
6829                 set_qos_param = 1;
6830         }
6831
6832         spin_unlock_irqrestore(&priv->ieee->lock, flags);
6833
6834         if (set_qos_param == 1)
6835                 schedule_work(&priv->qos_activate);
6836
6837         return ret;
6838 }
6839
6840 static u32 ipw_qos_get_burst_duration(struct ipw_priv *priv)
6841 {
6842         u32 ret = 0;
6843
6844         if ((priv == NULL))
6845                 return 0;
6846
6847         if (!(priv->ieee->modulation & IEEE80211_OFDM_MODULATION))
6848                 ret = priv->qos_data.burst_duration_CCK;
6849         else
6850                 ret = priv->qos_data.burst_duration_OFDM;
6851
6852         return ret;
6853 }
6854
6855 /*
6856 * Initialize the setting of QoS global
6857 */
6858 static void ipw_qos_init(struct ipw_priv *priv, int enable,
6859                          int burst_enable, u32 burst_duration_CCK,
6860                          u32 burst_duration_OFDM)
6861 {
6862         priv->qos_data.qos_enable = enable;
6863
6864         if (priv->qos_data.qos_enable) {
6865                 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
6866                 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
6867                 IPW_DEBUG_QOS("QoS is enabled\n");
6868         } else {
6869                 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
6870                 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
6871                 IPW_DEBUG_QOS("QoS is not enabled\n");
6872         }
6873
6874         priv->qos_data.burst_enable = burst_enable;
6875
6876         if (burst_enable) {
6877                 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
6878                 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
6879         } else {
6880                 priv->qos_data.burst_duration_CCK = 0;
6881                 priv->qos_data.burst_duration_OFDM = 0;
6882         }
6883 }
6884
6885 /*
6886 * map the packet priority to the right TX Queue
6887 */
6888 static int ipw_get_tx_queue_number(struct ipw_priv *priv, u16 priority)
6889 {
6890         if (priority > 7 || !priv->qos_data.qos_enable)
6891                 priority = 0;
6892
6893         return from_priority_to_tx_queue[priority] - 1;
6894 }
6895
6896 /*
6897 * add QoS parameter to the TX command
6898 */
6899 static int ipw_qos_set_tx_queue_command(struct ipw_priv *priv,
6900                                         u16 priority,
6901                                         struct tfd_data *tfd, u8 unicast)
6902 {
6903         int ret = 0;
6904         int tx_queue_id = 0;
6905         struct ieee80211_qos_data *qos_data = NULL;
6906         int active, supported;
6907         unsigned long flags;
6908
6909         if (!(priv->status & STATUS_ASSOCIATED))
6910                 return 0;
6911
6912         qos_data = &priv->assoc_network->qos_data;
6913
6914         spin_lock_irqsave(&priv->ieee->lock, flags);
6915
6916         if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6917                 if (unicast == 0)
6918                         qos_data->active = 0;
6919                 else
6920                         qos_data->active = qos_data->supported;
6921         }
6922
6923         active = qos_data->active;
6924         supported = qos_data->supported;
6925
6926         spin_unlock_irqrestore(&priv->ieee->lock, flags);
6927
6928         IPW_DEBUG_QOS("QoS  %d network is QoS active %d  supported %d  "
6929                       "unicast %d\n",
6930                       priv->qos_data.qos_enable, active, supported, unicast);
6931         if (active && priv->qos_data.qos_enable) {
6932                 ret = from_priority_to_tx_queue[priority];
6933                 tx_queue_id = ret - 1;
6934                 IPW_DEBUG_QOS("QoS packet priority is %d \n", priority);
6935                 if (priority <= 7) {
6936                         tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
6937                         tfd->tfd.tfd_26.mchdr.qos_ctrl = priority;
6938                         tfd->tfd.tfd_26.mchdr.frame_ctl |=
6939                             IEEE80211_STYPE_QOS_DATA;
6940
6941                         if (priv->qos_data.qos_no_ack_mask &
6942                             (1UL << tx_queue_id)) {
6943                                 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
6944                                 tfd->tfd.tfd_26.mchdr.qos_ctrl |=
6945                                     CTRL_QOS_NO_ACK;
6946                         }
6947                 }
6948         }
6949
6950         return ret;
6951 }
6952
6953 /*
6954 * background support to run QoS activate functionality
6955 */
6956 static void ipw_bg_qos_activate(void *data)
6957 {
6958         struct ipw_priv *priv = data;
6959
6960         if (priv == NULL)
6961                 return;
6962
6963         mutex_lock(&priv->mutex);
6964
6965         if (priv->status & STATUS_ASSOCIATED)
6966                 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
6967
6968         mutex_unlock(&priv->mutex);
6969 }
6970
6971 static int ipw_handle_probe_response(struct net_device *dev,
6972                                      struct ieee80211_probe_response *resp,
6973                                      struct ieee80211_network *network)
6974 {
6975         struct ipw_priv *priv = ieee80211_priv(dev);
6976         int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6977                               (network == priv->assoc_network));
6978
6979         ipw_qos_handle_probe_response(priv, active_network, network);
6980
6981         return 0;
6982 }
6983
6984 static int ipw_handle_beacon(struct net_device *dev,
6985                              struct ieee80211_beacon *resp,
6986                              struct ieee80211_network *network)
6987 {
6988         struct ipw_priv *priv = ieee80211_priv(dev);
6989         int active_network = ((priv->status & STATUS_ASSOCIATED) &&
6990                               (network == priv->assoc_network));
6991
6992         ipw_qos_handle_probe_response(priv, active_network, network);
6993
6994         return 0;
6995 }
6996
6997 static int ipw_handle_assoc_response(struct net_device *dev,
6998                                      struct ieee80211_assoc_response *resp,
6999                                      struct ieee80211_network *network)
7000 {
7001         struct ipw_priv *priv = ieee80211_priv(dev);
7002         ipw_qos_association_resp(priv, network);
7003         return 0;
7004 }
7005
7006 static int ipw_send_qos_params_command(struct ipw_priv *priv, struct ieee80211_qos_parameters
7007                                        *qos_param)
7008 {
7009         return ipw_send_cmd_pdu(priv, IPW_CMD_QOS_PARAMETERS,
7010                                 sizeof(*qos_param) * 3, qos_param);
7011 }
7012
7013 static int ipw_send_qos_info_command(struct ipw_priv *priv, struct ieee80211_qos_information_element
7014                                      *qos_param)
7015 {
7016         return ipw_send_cmd_pdu(priv, IPW_CMD_WME_INFO, sizeof(*qos_param),
7017                                 qos_param);
7018 }
7019
7020 #endif                          /* CONFIG_IPW_QOS */
7021
7022 static int ipw_associate_network(struct ipw_priv *priv,
7023                                  struct ieee80211_network *network,
7024                                  struct ipw_supported_rates *rates, int roaming)
7025 {
7026         int err;
7027
7028         if (priv->config & CFG_FIXED_RATE)
7029                 ipw_set_fixed_rate(priv, network->mode);
7030
7031         if (!(priv->config & CFG_STATIC_ESSID)) {
7032                 priv->essid_len = min(network->ssid_len,
7033                                       (u8) IW_ESSID_MAX_SIZE);
7034                 memcpy(priv->essid, network->ssid, priv->essid_len);
7035         }
7036
7037         network->last_associate = jiffies;
7038
7039         memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7040         priv->assoc_request.channel = network->channel;
7041         priv->assoc_request.auth_key = 0;
7042
7043         if ((priv->capability & CAP_PRIVACY_ON) &&
7044             (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)) {
7045                 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
7046                 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7047
7048                 if (priv->ieee->sec.level == SEC_LEVEL_1)
7049                         ipw_send_wep_keys(priv, DCW_WEP_KEY_SEC_TYPE_WEP);
7050
7051         } else if ((priv->capability & CAP_PRIVACY_ON) &&
7052                    (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP))
7053                 priv->assoc_request.auth_type = AUTH_LEAP;
7054         else
7055                 priv->assoc_request.auth_type = AUTH_OPEN;
7056
7057         if (priv->ieee->wpa_ie_len) {
7058                 priv->assoc_request.policy_support = 0x02;      /* RSN active */
7059                 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7060                                  priv->ieee->wpa_ie_len);
7061         }
7062
7063         /*
7064          * It is valid for our ieee device to support multiple modes, but
7065          * when it comes to associating to a given network we have to choose
7066          * just one mode.
7067          */
7068         if (network->mode & priv->ieee->mode & IEEE_A)
7069                 priv->assoc_request.ieee_mode = IPW_A_MODE;
7070         else if (network->mode & priv->ieee->mode & IEEE_G)
7071                 priv->assoc_request.ieee_mode = IPW_G_MODE;
7072         else if (network->mode & priv->ieee->mode & IEEE_B)
7073                 priv->assoc_request.ieee_mode = IPW_B_MODE;
7074
7075         priv->assoc_request.capability = network->capability;
7076         if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7077             && !(priv->config & CFG_PREAMBLE_LONG)) {
7078                 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7079         } else {
7080                 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7081
7082                 /* Clear the short preamble if we won't be supporting it */
7083                 priv->assoc_request.capability &=
7084                     ~WLAN_CAPABILITY_SHORT_PREAMBLE;
7085         }
7086
7087         /* Clear capability bits that aren't used in Ad Hoc */
7088         if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7089                 priv->assoc_request.capability &=
7090                     ~WLAN_CAPABILITY_SHORT_SLOT_TIME;
7091
7092         IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
7093                         "802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
7094                         roaming ? "Rea" : "A",
7095                         escape_essid(priv->essid, priv->essid_len),
7096                         network->channel,
7097                         ipw_modes[priv->assoc_request.ieee_mode],
7098                         rates->num_rates,
7099                         (priv->assoc_request.preamble_length ==
7100                          DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
7101                         network->capability &
7102                         WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
7103                         priv->capability & CAP_PRIVACY_ON ? "on " : "off",
7104                         priv->capability & CAP_PRIVACY_ON ?
7105                         (priv->capability & CAP_SHARED_KEY ? "(shared)" :
7106                          "(open)") : "",
7107                         priv->capability & CAP_PRIVACY_ON ? " key=" : "",
7108                         priv->capability & CAP_PRIVACY_ON ?
7109                         '1' + priv->ieee->sec.active_key : '.',
7110                         priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
7111
7112         priv->assoc_request.beacon_interval = network->beacon_interval;
7113         if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
7114             (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
7115                 priv->assoc_request.assoc_type = HC_IBSS_START;
7116                 priv->assoc_request.assoc_tsf_msw = 0;
7117                 priv->assoc_request.assoc_tsf_lsw = 0;
7118         } else {
7119                 if (unlikely(roaming))
7120                         priv->assoc_request.assoc_type = HC_REASSOCIATE;
7121                 else
7122                         priv->assoc_request.assoc_type = HC_ASSOCIATE;
7123                 priv->assoc_request.assoc_tsf_msw = network->time_stamp[1];
7124                 priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0];
7125         }
7126
7127         memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
7128
7129         if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7130                 memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
7131                 priv->assoc_request.atim_window = network->atim_window;
7132         } else {
7133                 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
7134                 priv->assoc_request.atim_window = 0;
7135         }
7136
7137         priv->assoc_request.listen_interval = network->listen_interval;
7138
7139         err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7140         if (err) {
7141                 IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
7142                 return err;
7143         }
7144
7145         rates->ieee_mode = priv->assoc_request.ieee_mode;
7146         rates->purpose = IPW_RATE_CONNECT;
7147         ipw_send_supported_rates(priv, rates);
7148
7149         if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7150                 priv->sys_config.dot11g_auto_detection = 1;
7151         else
7152                 priv->sys_config.dot11g_auto_detection = 0;
7153
7154         if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7155                 priv->sys_config.answer_broadcast_ssid_probe = 1;
7156         else
7157                 priv->sys_config.answer_broadcast_ssid_probe = 0;
7158
7159         err = ipw_send_system_config(priv, &priv->sys_config);
7160         if (err) {
7161                 IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
7162                 return err;
7163         }
7164
7165         IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
7166         err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
7167         if (err) {
7168                 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7169                 return err;
7170         }
7171
7172         /*
7173          * If preemption is enabled, it is possible for the association
7174          * to complete before we return from ipw_send_associate.  Therefore
7175          * we have to be sure and update our priviate data first.
7176          */
7177         priv->channel = network->channel;
7178         memcpy(priv->bssid, network->bssid, ETH_ALEN);
7179         priv->status |= STATUS_ASSOCIATING;
7180         priv->status &= ~STATUS_SECURITY_UPDATED;
7181
7182         priv->assoc_network = network;
7183
7184 #ifdef CONFIG_IPW_QOS
7185         ipw_qos_association(priv, network);
7186 #endif
7187
7188         err = ipw_send_associate(priv, &priv->assoc_request);
7189         if (err) {
7190                 IPW_DEBUG_HC("Attempt to send associate command failed.\n");
7191                 return err;
7192         }
7193
7194         IPW_DEBUG(IPW_DL_STATE, "associating: '%s' " MAC_FMT " \n",
7195                   escape_essid(priv->essid, priv->essid_len),
7196                   MAC_ARG(priv->bssid));
7197
7198         return 0;
7199 }
7200
7201 static void ipw_roam(void *data)
7202 {
7203         struct ipw_priv *priv = data;
7204         struct ieee80211_network *network = NULL;
7205         struct ipw_network_match match = {
7206                 .network = priv->assoc_network
7207         };
7208
7209         /* The roaming process is as follows:
7210          *
7211          * 1.  Missed beacon threshold triggers the roaming process by
7212          *     setting the status ROAM bit and requesting a scan.
7213          * 2.  When the scan completes, it schedules the ROAM work
7214          * 3.  The ROAM work looks at all of the known networks for one that
7215          *     is a better network than the currently associated.  If none
7216          *     found, the ROAM process is over (ROAM bit cleared)
7217          * 4.  If a better network is found, a disassociation request is
7218          *     sent.
7219          * 5.  When the disassociation completes, the roam work is again
7220          *     scheduled.  The second time through, the driver is no longer
7221          *     associated, and the newly selected network is sent an
7222          *     association request.
7223          * 6.  At this point ,the roaming process is complete and the ROAM
7224          *     status bit is cleared.
7225          */
7226
7227         /* If we are no longer associated, and the roaming bit is no longer
7228          * set, then we are not actively roaming, so just return */
7229         if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7230                 return;
7231
7232         if (priv->status & STATUS_ASSOCIATED) {
7233                 /* First pass through ROAM process -- look for a better
7234                  * network */
7235                 unsigned long flags;
7236                 u8 rssi = priv->assoc_network->stats.rssi;
7237                 priv->assoc_network->stats.rssi = -128;
7238                 spin_lock_irqsave(&priv->ieee->lock, flags);
7239                 list_for_each_entry(network, &priv->ieee->network_list, list) {
7240                         if (network != priv->assoc_network)
7241                                 ipw_best_network(priv, &match, network, 1);
7242                 }
7243                 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7244                 priv->assoc_network->stats.rssi = rssi;
7245
7246                 if (match.network == priv->assoc_network) {
7247                         IPW_DEBUG_ASSOC("No better APs in this network to "
7248                                         "roam to.\n");
7249                         priv->status &= ~STATUS_ROAMING;
7250                         ipw_debug_config(priv);
7251                         return;
7252                 }
7253
7254                 ipw_send_disassociate(priv, 1);
7255                 priv->assoc_network = match.network;
7256
7257                 return;
7258         }
7259
7260         /* Second pass through ROAM process -- request association */
7261         ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7262         ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7263         priv->status &= ~STATUS_ROAMING;
7264 }
7265
7266 static void ipw_bg_roam(void *data)
7267 {
7268         struct ipw_priv *priv = data;
7269         mutex_lock(&priv->mutex);
7270         ipw_roam(data);
7271         mutex_unlock(&priv->mutex);
7272 }
7273
7274 static int ipw_associate(void *data)
7275 {
7276         struct ipw_priv *priv = data;
7277
7278         struct ieee80211_network *network = NULL;
7279         struct ipw_network_match match = {
7280                 .network = NULL
7281         };
7282         struct ipw_supported_rates *rates;
7283         struct list_head *element;
7284         unsigned long flags;
7285
7286         if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7287                 IPW_DEBUG_ASSOC("Not attempting association (monitor mode)\n");
7288                 return 0;
7289         }
7290
7291         if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
7292                 IPW_DEBUG_ASSOC("Not attempting association (already in "
7293                                 "progress)\n");
7294                 return 0;
7295         }
7296
7297         if (priv->status & STATUS_DISASSOCIATING) {
7298                 IPW_DEBUG_ASSOC("Not attempting association (in "
7299                                 "disassociating)\n ");
7300                 queue_work(priv->workqueue, &priv->associate);
7301                 return 0;
7302         }
7303
7304         if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
7305                 IPW_DEBUG_ASSOC("Not attempting association (scanning or not "
7306                                 "initialized)\n");
7307                 return 0;
7308         }
7309
7310         if (!(priv->config & CFG_ASSOCIATE) &&
7311             !(priv->config & (CFG_STATIC_ESSID |
7312                               CFG_STATIC_CHANNEL | CFG_STATIC_BSSID))) {
7313                 IPW_DEBUG_ASSOC("Not attempting association (associate=0)\n");
7314                 return 0;
7315         }
7316
7317         /* Protect our use of the network_list */
7318         spin_lock_irqsave(&priv->ieee->lock, flags);
7319         list_for_each_entry(network, &priv->ieee->network_list, list)
7320             ipw_best_network(priv, &match, network, 0);
7321
7322         network = match.network;
7323         rates = &match.rates;
7324
7325         if (network == NULL &&
7326             priv->ieee->iw_mode == IW_MODE_ADHOC &&
7327             priv->config & CFG_ADHOC_CREATE &&
7328             priv->config & CFG_STATIC_ESSID &&
7329             priv->config & CFG_STATIC_CHANNEL &&
7330             !list_empty(&priv->ieee->network_free_list)) {
7331                 element = priv->ieee->network_free_list.next;
7332                 network = list_entry(element, struct ieee80211_network, list);
7333                 ipw_adhoc_create(priv, network);
7334                 rates = &priv->rates;
7335                 list_del(element);
7336                 list_add_tail(&network->list, &priv->ieee->network_list);
7337         }
7338         spin_unlock_irqrestore(&priv->ieee->lock, flags);
7339
7340         /* If we reached the end of the list, then we don't have any valid
7341          * matching APs */
7342         if (!network) {
7343                 ipw_debug_config(priv);
7344
7345                 if (!(priv->status & STATUS_SCANNING)) {
7346                         if (!(priv->config & CFG_SPEED_SCAN))
7347                                 queue_delayed_work(priv->workqueue,
7348                                                    &priv->request_scan,
7349                                                    SCAN_INTERVAL);
7350                         else
7351                                 queue_work(priv->workqueue,
7352                                            &priv->request_scan);
7353                 }
7354
7355                 return 0;
7356         }
7357
7358         ipw_associate_network(priv, network, rates, 0);
7359
7360         return 1;
7361 }
7362
7363 static void ipw_bg_associate(void *data)
7364 {
7365         struct ipw_priv *priv = data;
7366         mutex_lock(&priv->mutex);
7367         ipw_associate(data);
7368         mutex_unlock(&priv->mutex);
7369 }
7370
7371 static void ipw_rebuild_decrypted_skb(struct ipw_priv *priv,
7372                                       struct sk_buff *skb)
7373 {
7374         struct ieee80211_hdr *hdr;
7375         u16 fc;
7376
7377         hdr = (struct ieee80211_hdr *)skb->data;
7378         fc = le16_to_cpu(hdr->frame_ctl);
7379         if (!(fc & IEEE80211_FCTL_PROTECTED))
7380                 return;
7381
7382         fc &= ~IEEE80211_FCTL_PROTECTED;
7383         hdr->frame_ctl = cpu_to_le16(fc);
7384         switch (priv->ieee->sec.level) {
7385         case SEC_LEVEL_3:
7386                 /* Remove CCMP HDR */
7387                 memmove(skb->data + IEEE80211_3ADDR_LEN,
7388                         skb->data + IEEE80211_3ADDR_LEN + 8,
7389                         skb->len - IEEE80211_3ADDR_LEN - 8);
7390                 skb_trim(skb, skb->len - 16);   /* CCMP_HDR_LEN + CCMP_MIC_LEN */
7391                 break;
7392         case SEC_LEVEL_2:
7393                 break;
7394         case SEC_LEVEL_1:
7395                 /* Remove IV */
7396                 memmove(skb->data + IEEE80211_3ADDR_LEN,
7397                         skb->data + IEEE80211_3ADDR_LEN + 4,
7398                         skb->len - IEEE80211_3ADDR_LEN - 4);
7399                 skb_trim(skb, skb->len - 8);    /* IV + ICV */
7400                 break;
7401         case SEC_LEVEL_0:
7402                 break;
7403         default:
7404                 printk(KERN_ERR "Unknow security level %d\n",
7405                        priv->ieee->sec.level);
7406                 break;
7407         }
7408 }
7409
7410 static void ipw_handle_data_packet(struct ipw_priv *priv,
7411                                    struct ipw_rx_mem_buffer *rxb,
7412                                    struct ieee80211_rx_stats *stats)
7413 {
7414         struct ieee80211_hdr_4addr *hdr;
7415         struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7416
7417         /* We received data from the HW, so stop the watchdog */
7418         priv->net_dev->trans_start = jiffies;
7419
7420         /* We only process data packets if the
7421          * interface is open */
7422         if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7423                      skb_tailroom(rxb->skb))) {
7424                 priv->ieee->stats.rx_errors++;
7425                 priv->wstats.discard.misc++;
7426                 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7427                 return;
7428         } else if (unlikely(!netif_running(priv->net_dev))) {
7429                 priv->ieee->stats.rx_dropped++;
7430                 priv->wstats.discard.misc++;
7431                 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7432                 return;
7433         }
7434
7435         /* Advance skb->data to the start of the actual payload */
7436         skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
7437
7438         /* Set the size of the skb to the size of the frame */
7439         skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
7440
7441         IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7442
7443         /* HW decrypt will not clear the WEP bit, MIC, PN, etc. */
7444         hdr = (struct ieee80211_hdr_4addr *)rxb->skb->data;
7445         if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
7446             (is_multicast_ether_addr(hdr->addr1) ?
7447              !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
7448                 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7449
7450         if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7451                 priv->ieee->stats.rx_errors++;
7452         else {                  /* ieee80211_rx succeeded, so it now owns the SKB */
7453                 rxb->skb = NULL;
7454                 __ipw_led_activity_on(priv);
7455         }
7456 }
7457
7458 #ifdef CONFIG_IEEE80211_RADIOTAP
7459 static void ipw_handle_data_packet_monitor(struct ipw_priv *priv,
7460                                            struct ipw_rx_mem_buffer *rxb,
7461                                            struct ieee80211_rx_stats *stats)
7462 {
7463         struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7464         struct ipw_rx_frame *frame = &pkt->u.frame;
7465
7466         /* initial pull of some data */
7467         u16 received_channel = frame->received_channel;
7468         u8 antennaAndPhy = frame->antennaAndPhy;
7469         s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM;       /* call it signed anyhow */
7470         u16 pktrate = frame->rate;
7471
7472         /* Magic struct that slots into the radiotap header -- no reason
7473          * to build this manually element by element, we can write it much
7474          * more efficiently than we can parse it. ORDER MATTERS HERE */
7475         struct ipw_rt_hdr {
7476                 struct ieee80211_radiotap_header rt_hdr;
7477                 u8 rt_flags;    /* radiotap packet flags */
7478                 u8 rt_rate;     /* rate in 500kb/s */
7479                 u16 rt_channel; /* channel in mhz */
7480                 u16 rt_chbitmask;       /* channel bitfield */
7481                 s8 rt_dbmsignal;        /* signal in dbM, kluged to signed */
7482                 u8 rt_antenna;  /* antenna number */
7483         } *ipw_rt;
7484
7485         short len = le16_to_cpu(pkt->u.frame.length);
7486
7487         /* We received data from the HW, so stop the watchdog */
7488         priv->net_dev->trans_start = jiffies;
7489
7490         /* We only process data packets if the
7491          * interface is open */
7492         if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7493                      skb_tailroom(rxb->skb))) {
7494                 priv->ieee->stats.rx_errors++;
7495                 priv->wstats.discard.misc++;
7496                 IPW_DEBUG_DROP("Corruption detected! Oh no!\n");
7497                 return;
7498         } else if (unlikely(!netif_running(priv->net_dev))) {
7499                 priv->ieee->stats.rx_dropped++;
7500                 priv->wstats.discard.misc++;
7501                 IPW_DEBUG_DROP("Dropping packet while interface is not up.\n");
7502                 return;
7503         }
7504
7505         /* Libpcap 0.9.3+ can handle variable length radiotap, so we'll use
7506          * that now */
7507         if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7508                 /* FIXME: Should alloc bigger skb instead */
7509                 priv->ieee->stats.rx_dropped++;
7510                 priv->wstats.discard.misc++;
7511                 IPW_DEBUG_DROP("Dropping too large packet in monitor\n");
7512                 return;
7513         }
7514
7515         /* copy the frame itself */
7516         memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7517                 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7518
7519         /* Zero the radiotap static buffer  ...  We only need to zero the bytes NOT
7520          * part of our real header, saves a little time.
7521          *
7522          * No longer necessary since we fill in all our data.  Purge before merging
7523          * patch officially.
7524          * memset(rxb->skb->data + sizeof(struct ipw_rt_hdr), 0,
7525          *        IEEE80211_RADIOTAP_HDRLEN - sizeof(struct ipw_rt_hdr));
7526          */
7527
7528         ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7529
7530         ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7531         ipw_rt->rt_hdr.it_pad = 0;      /* always good to zero */
7532         ipw_rt->rt_hdr.it_len = sizeof(struct ipw_rt_hdr);      /* total header+data */
7533
7534         /* Big bitfield of all the fields we provide in radiotap */
7535         ipw_rt->rt_hdr.it_present =
7536             ((1 << IEEE80211_RADIOTAP_FLAGS) |
7537              (1 << IEEE80211_RADIOTAP_RATE) |
7538              (1 << IEEE80211_RADIOTAP_CHANNEL) |
7539              (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
7540              (1 << IEEE80211_RADIOTAP_ANTENNA));
7541
7542         /* Zero the flags, we'll add to them as we go */
7543         ipw_rt->rt_flags = 0;
7544
7545         /* Convert signal to DBM */
7546         ipw_rt->rt_dbmsignal = antsignal;
7547
7548         /* Convert the channel data and set the flags */
7549         ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7550         if (received_channel > 14) {    /* 802.11a */
7551                 ipw_rt->rt_chbitmask =
7552                     cpu_to_le16((IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ));
7553         } else if (antennaAndPhy & 32) {        /* 802.11b */
7554                 ipw_rt->rt_chbitmask =
7555                     cpu_to_le16((IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ));
7556         } else {                /* 802.11g */
7557                 ipw_rt->rt_chbitmask =
7558                     (IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ);
7559         }
7560
7561         /* set the rate in multiples of 500k/s */
7562         switch (pktrate) {
7563         case IPW_TX_RATE_1MB:
7564                 ipw_rt->rt_rate = 2;
7565                 break;
7566         case IPW_TX_RATE_2MB:
7567                 ipw_rt->rt_rate = 4;
7568                 break;
7569         case IPW_TX_RATE_5MB:
7570                 ipw_rt->rt_rate = 10;
7571                 break;
7572         case IPW_TX_RATE_6MB:
7573                 ipw_rt->rt_rate = 12;
7574                 break;
7575         case IPW_TX_RATE_9MB:
7576                 ipw_rt->rt_rate = 18;
7577                 break;
7578         case IPW_TX_RATE_11MB:
7579                 ipw_rt->rt_rate = 22;
7580                 break;
7581         case IPW_TX_RATE_12MB:
7582                 ipw_rt->rt_rate = 24;
7583                 break;
7584         case IPW_TX_RATE_18MB:
7585                 ipw_rt->rt_rate = 36;
7586                 break;
7587         case IPW_TX_RATE_24MB:
7588                 ipw_rt->rt_rate = 48;
7589                 break;
7590         case IPW_TX_RATE_36MB:
7591                 ipw_rt->rt_rate = 72;
7592                 break;
7593         case IPW_TX_RATE_48MB:
7594                 ipw_rt->rt_rate = 96;
7595                 break;
7596         case IPW_TX_RATE_54MB:
7597                 ipw_rt->rt_rate = 108;
7598                 break;
7599         default:
7600                 ipw_rt->rt_rate = 0;
7601                 break;
7602         }
7603
7604         /* antenna number */
7605         ipw_rt->rt_antenna = (antennaAndPhy & 3);       /* Is this right? */
7606
7607         /* set the preamble flag if we have it */
7608         if ((antennaAndPhy & 64))
7609                 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7610
7611         /* Set the size of the skb to the size of the frame */
7612         skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
7613
7614         IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7615
7616         if (!ieee80211_rx(priv->ieee, rxb->skb, stats))
7617                 priv->ieee->stats.rx_errors++;
7618         else {                  /* ieee80211_rx succeeded, so it now owns the SKB */
7619                 rxb->skb = NULL;
7620                 /* no LED during capture */
7621         }
7622 }
7623 #endif
7624
7625 static int is_network_packet(struct ipw_priv *priv,
7626                                     struct ieee80211_hdr_4addr *header)
7627 {
7628         /* Filter incoming packets to determine if they are targetted toward
7629          * this network, discarding packets coming from ourselves */
7630         switch (priv->ieee->iw_mode) {
7631         case IW_MODE_ADHOC:     /* Header: Dest. | Source    | BSSID */
7632                 /* packets from our adapter are dropped (echo) */
7633                 if (!memcmp(header->addr2, priv->net_dev->dev_addr, ETH_ALEN))
7634                         return 0;
7635
7636                 /* {broad,multi}cast packets to our BSSID go through */
7637                 if (is_multicast_ether_addr(header->addr1))
7638                         return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
7639
7640                 /* packets to our adapter go through */
7641                 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7642                                ETH_ALEN);
7643
7644         case IW_MODE_INFRA:     /* Header: Dest. | BSSID | Source */
7645                 /* packets from our adapter are dropped (echo) */
7646                 if (!memcmp(header->addr3, priv->net_dev->dev_addr, ETH_ALEN))
7647                         return 0;
7648
7649                 /* {broad,multi}cast packets to our BSS go through */
7650                 if (is_multicast_ether_addr(header->addr1))
7651                         return !memcmp(header->addr2, priv->bssid, ETH_ALEN);
7652
7653                 /* packets to our adapter go through */
7654                 return !memcmp(header->addr1, priv->net_dev->dev_addr,
7655                                ETH_ALEN);
7656         }
7657
7658         return 1;
7659 }
7660
7661 #define IPW_PACKET_RETRY_TIME HZ
7662
7663 static  int is_duplicate_packet(struct ipw_priv *priv,
7664                                       struct ieee80211_hdr_4addr *header)
7665 {
7666         u16 sc = le16_to_cpu(header->seq_ctl);
7667         u16 seq = WLAN_GET_SEQ_SEQ(sc);
7668         u16 frag = WLAN_GET_SEQ_FRAG(sc);
7669         u16 *last_seq, *last_frag;
7670         unsigned long *last_time;
7671
7672         switch (priv->ieee->iw_mode) {
7673         case IW_MODE_ADHOC:
7674                 {
7675                         struct list_head *p;
7676                         struct ipw_ibss_seq *entry = NULL;
7677                         u8 *mac = header->addr2;
7678                         int index = mac[5] % IPW_IBSS_MAC_HASH_SIZE;
7679
7680                         __list_for_each(p, &priv->ibss_mac_hash[index]) {
7681                                 entry =
7682                                     list_entry(p, struct ipw_ibss_seq, list);
7683                                 if (!memcmp(entry->mac, mac, ETH_ALEN))
7684                                         break;
7685                         }
7686                         if (p == &priv->ibss_mac_hash[index]) {
7687                                 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
7688                                 if (!entry) {
7689                                         IPW_ERROR
7690                                             ("Cannot malloc new mac entry\n");
7691                                         return 0;
7692                                 }
7693                                 memcpy(entry->mac, mac, ETH_ALEN);
7694                                 entry->seq_num = seq;
7695                                 entry->frag_num = frag;
7696                                 entry->packet_time = jiffies;
7697                                 list_add(&entry->list,
7698                                          &priv->ibss_mac_hash[index]);
7699                                 return 0;
7700                         }
7701                         last_seq = &entry->seq_num;
7702                         last_frag = &entry->frag_num;
7703                         last_time = &entry->packet_time;
7704                         break;
7705                 }
7706         case IW_MODE_INFRA:
7707                 last_seq = &priv->last_seq_num;
7708                 last_frag = &priv->last_frag_num;
7709                 last_time = &priv->last_packet_time;
7710                 break;
7711         default:
7712                 return 0;
7713         }
7714         if ((*last_seq == seq) &&
7715             time_after(*last_time + IPW_PACKET_RETRY_TIME, jiffies)) {
7716                 if (*last_frag == frag)
7717                         goto drop;
7718                 if (*last_frag + 1 != frag)
7719                         /* out-of-order fragment */
7720                         goto drop;
7721         } else
7722                 *last_seq = seq;
7723
7724         *last_frag = frag;
7725         *last_time = jiffies;
7726         return 0;
7727
7728       drop:
7729         /* Comment this line now since we observed the card receives
7730          * duplicate packets but the FCTL_RETRY bit is not set in the
7731          * IBSS mode with fragmentation enabled.
7732          BUG_ON(!(le16_to_cpu(header->frame_ctl) & IEEE80211_FCTL_RETRY)); */
7733         return 1;
7734 }
7735
7736 static void ipw_handle_mgmt_packet(struct ipw_priv *priv,
7737                                    struct ipw_rx_mem_buffer *rxb,
7738                                    struct ieee80211_rx_stats *stats)
7739 {
7740         struct sk_buff *skb = rxb->skb;
7741         struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
7742         struct ieee80211_hdr_4addr *header = (struct ieee80211_hdr_4addr *)
7743             (skb->data + IPW_RX_FRAME_SIZE);
7744
7745         ieee80211_rx_mgt(priv->ieee, header, stats);
7746
7747         if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
7748             ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7749               IEEE80211_STYPE_PROBE_RESP) ||
7750              (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
7751               IEEE80211_STYPE_BEACON))) {
7752                 if (!memcmp(header->addr3, priv->bssid, ETH_ALEN))
7753                         ipw_add_station(priv, header->addr2);
7754         }
7755
7756         if (priv->config & CFG_NET_STATS) {
7757                 IPW_DEBUG_HC("sending stat packet\n");
7758
7759                 /* Set the size of the skb to the size of the full
7760                  * ipw header and 802.11 frame */
7761                 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
7762                         IPW_RX_FRAME_SIZE);
7763
7764                 /* Advance past the ipw packet header to the 802.11 frame */
7765                 skb_pull(skb, IPW_RX_FRAME_SIZE);
7766
7767                 /* Push the ieee80211_rx_stats before the 802.11 frame */
7768                 memcpy(skb_push(skb, sizeof(*stats)), stats, sizeof(*stats));
7769
7770                 skb->dev = priv->ieee->dev;
7771
7772                 /* Point raw at the ieee80211_stats */
7773                 skb->mac.raw = skb->data;
7774
7775                 skb->pkt_type = PACKET_OTHERHOST;
7776                 skb->protocol = __constant_htons(ETH_P_80211_STATS);
7777                 memset(skb->cb, 0, sizeof(rxb->skb->cb));
7778                 netif_rx(skb);
7779                 rxb->skb = NULL;
7780         }
7781 }
7782
7783 /*
7784  * Main entry function for recieving a packet with 80211 headers.  This
7785  * should be called when ever the FW has notified us that there is a new
7786  * skb in the recieve queue.
7787  */
7788 static void ipw_rx(struct ipw_priv *priv)
7789 {
7790         struct ipw_rx_mem_buffer *rxb;
7791         struct ipw_rx_packet *pkt;
7792         struct ieee80211_hdr_4addr *header;
7793         u32 r, w, i;
7794         u8 network_packet;
7795
7796         r = ipw_read32(priv, IPW_RX_READ_INDEX);
7797         w = ipw_read32(priv, IPW_RX_WRITE_INDEX);
7798         i = (priv->rxq->processed + 1) % RX_QUEUE_SIZE;
7799
7800         while (i != r) {
7801                 rxb = priv->rxq->queue[i];
7802                 if (unlikely(rxb == NULL)) {
7803                         printk(KERN_CRIT "Queue not allocated!\n");
7804                         break;
7805                 }
7806                 priv->rxq->queue[i] = NULL;
7807
7808                 pci_dma_sync_single_for_cpu(priv->pci_dev, rxb->dma_addr,
7809                                             IPW_RX_BUF_SIZE,
7810                                             PCI_DMA_FROMDEVICE);
7811
7812                 pkt = (struct ipw_rx_packet *)rxb->skb->data;
7813                 IPW_DEBUG_RX("Packet: type=%02X seq=%02X bits=%02X\n",
7814                              pkt->header.message_type,
7815                              pkt->header.rx_seq_num, pkt->header.control_bits);
7816
7817                 switch (pkt->header.message_type) {
7818                 case RX_FRAME_TYPE:     /* 802.11 frame */  {
7819                                 struct ieee80211_rx_stats stats = {
7820                                         .rssi =
7821                                             le16_to_cpu(pkt->u.frame.rssi_dbm) -
7822                                             IPW_RSSI_TO_DBM,
7823                                         .signal =
7824                                             le16_to_cpu(pkt->u.frame.rssi_dbm) -
7825                                             IPW_RSSI_TO_DBM + 0x100,
7826                                         .noise =
7827                                             le16_to_cpu(pkt->u.frame.noise),
7828                                         .rate = pkt->u.frame.rate,
7829                                         .mac_time = jiffies,
7830                                         .received_channel =
7831                                             pkt->u.frame.received_channel,
7832                                         .freq =
7833                                             (pkt->u.frame.
7834                                              control & (1 << 0)) ?
7835                                             IEEE80211_24GHZ_BAND :
7836                                             IEEE80211_52GHZ_BAND,
7837                                         .len = le16_to_cpu(pkt->u.frame.length),
7838                                 };
7839
7840                                 if (stats.rssi != 0)
7841                                         stats.mask |= IEEE80211_STATMASK_RSSI;
7842                                 if (stats.signal != 0)
7843                                         stats.mask |= IEEE80211_STATMASK_SIGNAL;
7844                                 if (stats.noise != 0)
7845                                         stats.mask |= IEEE80211_STATMASK_NOISE;
7846                                 if (stats.rate != 0)
7847                                         stats.mask |= IEEE80211_STATMASK_RATE;
7848
7849                                 priv->rx_packets++;
7850
7851 #ifdef CONFIG_IPW2200_MONITOR
7852                                 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7853 #ifdef CONFIG_IEEE80211_RADIOTAP
7854                                         ipw_handle_data_packet_monitor(priv,
7855                                                                        rxb,
7856                                                                        &stats);
7857 #else
7858                                         ipw_handle_data_packet(priv, rxb,
7859                                                                &stats);
7860 #endif
7861                                         break;
7862                                 }
7863 #endif
7864
7865                                 header =
7866                                     (struct ieee80211_hdr_4addr *)(rxb->skb->
7867                                                                    data +
7868                                                                    IPW_RX_FRAME_SIZE);
7869                                 /* TODO: Check Ad-Hoc dest/source and make sure
7870                                  * that we are actually parsing these packets
7871                                  * correctly -- we should probably use the
7872                                  * frame control of the packet and disregard
7873                                  * the current iw_mode */
7874
7875                                 network_packet =
7876                                     is_network_packet(priv, header);
7877                                 if (network_packet && priv->assoc_network) {
7878                                         priv->assoc_network->stats.rssi =
7879                                             stats.rssi;
7880                                         average_add(&priv->average_rssi,
7881                                                     stats.rssi);
7882                                         priv->last_rx_rssi = stats.rssi;
7883                                 }
7884
7885                                 IPW_DEBUG_RX("Frame: len=%u\n",
7886                                              le16_to_cpu(pkt->u.frame.length));
7887
7888                                 if (le16_to_cpu(pkt->u.frame.length) <
7889                                     ieee80211_get_hdrlen(le16_to_cpu(
7890                                                     header->frame_ctl))) {
7891                                         IPW_DEBUG_DROP
7892                                             ("Received packet is too small. "
7893                                              "Dropping.\n");
7894                                         priv->ieee->stats.rx_errors++;
7895                                         priv->wstats.discard.misc++;
7896                                         break;
7897                                 }
7898
7899                                 switch (WLAN_FC_GET_TYPE
7900                                         (le16_to_cpu(header->frame_ctl))) {
7901
7902                                 case IEEE80211_FTYPE_MGMT:
7903                                         ipw_handle_mgmt_packet(priv, rxb,
7904                                                                &stats);
7905                                         break;
7906
7907                                 case IEEE80211_FTYPE_CTL:
7908                                         break;
7909
7910                                 case IEEE80211_FTYPE_DATA:
7911                                         if (unlikely(!network_packet ||
7912                                                      is_duplicate_packet(priv,
7913                                                                          header)))
7914                                         {
7915                                                 IPW_DEBUG_DROP("Dropping: "
7916                                                                MAC_FMT ", "
7917                                                                MAC_FMT ", "
7918                                                                MAC_FMT "\n",
7919                                                                MAC_ARG(header->
7920                                                                        addr1),
7921                                                                MAC_ARG(header->
7922                                                                        addr2),
7923                                                                MAC_ARG(header->
7924                                                                        addr3));
7925                                                 break;
7926                                         }
7927
7928                                         ipw_handle_data_packet(priv, rxb,
7929                                                                &stats);
7930
7931                                         break;
7932                                 }
7933                                 break;
7934                         }
7935
7936                 case RX_HOST_NOTIFICATION_TYPE:{
7937                                 IPW_DEBUG_RX
7938                                     ("Notification: subtype=%02X flags=%02X size=%d\n",
7939                                      pkt->u.notification.subtype,
7940                                      pkt->u.notification.flags,
7941                                      pkt->u.notification.size);
7942                                 ipw_rx_notification(priv, &pkt->u.notification);
7943                                 break;
7944                         }
7945
7946                 default:
7947                         IPW_DEBUG_RX("Bad Rx packet of type %d\n",
7948                                      pkt->header.message_type);
7949                         break;
7950                 }
7951
7952                 /* For now we just don't re-use anything.  We can tweak this
7953                  * later to try and re-use notification packets and SKBs that
7954                  * fail to Rx correctly */
7955                 if (rxb->skb != NULL) {
7956                         dev_kfree_skb_any(rxb->skb);
7957                         rxb->skb = NULL;
7958                 }
7959
7960                 pci_unmap_single(priv->pci_dev, rxb->dma_addr,
7961                                  IPW_RX_BUF_SIZE, PCI_DMA_FROMDEVICE);
7962                 list_add_tail(&rxb->list, &priv->rxq->rx_used);
7963
7964                 i = (i + 1) % RX_QUEUE_SIZE;
7965         }
7966
7967         /* Backtrack one entry */
7968         priv->rxq->processed = (i ? i : RX_QUEUE_SIZE) - 1;
7969
7970         ipw_rx_queue_restock(priv);
7971 }
7972
7973 #define DEFAULT_RTS_THRESHOLD     2304U
7974 #define MIN_RTS_THRESHOLD         1U
7975 #define MAX_RTS_THRESHOLD         2304U
7976 #define DEFAULT_BEACON_INTERVAL   100U
7977 #define DEFAULT_SHORT_RETRY_LIMIT 7U
7978 #define DEFAULT_LONG_RETRY_LIMIT  4U
7979
7980 /**
7981  * ipw_sw_reset
7982  * @option: options to control different reset behaviour
7983  *          0 = reset everything except the 'disable' module_param
7984  *          1 = reset everything and print out driver info (for probe only)
7985  *          2 = reset everything
7986  */
7987 static int ipw_sw_reset(struct ipw_priv *priv, int option)
7988 {
7989         int band, modulation;
7990         int old_mode = priv->ieee->iw_mode;
7991
7992         /* Initialize module parameter values here */
7993         priv->config = 0;
7994
7995         /* We default to disabling the LED code as right now it causes
7996          * too many systems to lock up... */
7997         if (!led)
7998                 priv->config |= CFG_NO_LED;
7999
8000         if (associate)
8001                 priv->config |= CFG_ASSOCIATE;
8002         else
8003                 IPW_DEBUG_INFO("Auto associate disabled.\n");
8004
8005         if (auto_create)
8006                 priv->config |= CFG_ADHOC_CREATE;
8007         else
8008                 IPW_DEBUG_INFO("Auto adhoc creation disabled.\n");
8009
8010         priv->config &= ~CFG_STATIC_ESSID;
8011         priv->essid_len = 0;
8012         memset(priv->essid, 0, IW_ESSID_MAX_SIZE);
8013
8014         if (disable && option) {
8015                 priv->status |= STATUS_RF_KILL_SW;
8016                 IPW_DEBUG_INFO("Radio disabled.\n");
8017         }
8018
8019         if (channel != 0) {
8020                 priv->config |= CFG_STATIC_CHANNEL;
8021                 priv->channel = channel;
8022                 IPW_DEBUG_INFO("Bind to static channel %d\n", channel);
8023                 /* TODO: Validate that provided channel is in range */
8024         }
8025 #ifdef CONFIG_IPW_QOS
8026         ipw_qos_init(priv, qos_enable, qos_burst_enable,
8027                      burst_duration_CCK, burst_duration_OFDM);
8028 #endif                          /* CONFIG_IPW_QOS */
8029
8030         switch (mode) {
8031         case 1:
8032                 priv->ieee->iw_mode = IW_MODE_ADHOC;
8033                 priv->net_dev->type = ARPHRD_ETHER;
8034
8035                 break;
8036 #ifdef CONFIG_IPW2200_MONITOR
8037         case 2:
8038                 priv->ieee->iw_mode = IW_MODE_MONITOR;
8039 #ifdef CONFIG_IEEE80211_RADIOTAP
8040                 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8041 #else
8042                 priv->net_dev->type = ARPHRD_IEEE80211;
8043 #endif
8044                 break;
8045 #endif
8046         default:
8047         case 0:
8048                 priv->net_dev->type = ARPHRD_ETHER;
8049                 priv->ieee->iw_mode = IW_MODE_INFRA;
8050                 break;
8051         }
8052
8053         if (hwcrypto) {
8054                 priv->ieee->host_encrypt = 0;
8055                 priv->ieee->host_encrypt_msdu = 0;
8056                 priv->ieee->host_decrypt = 0;
8057                 priv->ieee->host_mc_decrypt = 0;
8058         }
8059         IPW_DEBUG_INFO("Hardware crypto [%s]\n", hwcrypto ? "on" : "off");
8060
8061         /* IPW2200/2915 is abled to do hardware fragmentation. */
8062         priv->ieee->host_open_frag = 0;
8063
8064         if ((priv->pci_dev->device == 0x4223) ||
8065             (priv->pci_dev->device == 0x4224)) {
8066                 if (option == 1)
8067                         printk(KERN_INFO DRV_NAME
8068                                ": Detected Intel PRO/Wireless 2915ABG Network "
8069                                "Connection\n");
8070                 priv->ieee->abg_true = 1;
8071                 band = IEEE80211_52GHZ_BAND | IEEE80211_24GHZ_BAND;
8072                 modulation = IEEE80211_OFDM_MODULATION |
8073                     IEEE80211_CCK_MODULATION;
8074                 priv->adapter = IPW_2915ABG;
8075                 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
8076         } else {
8077                 if (option == 1)
8078                         printk(KERN_INFO DRV_NAME
8079                                ": Detected Intel PRO/Wireless 2200BG Network "
8080                                "Connection\n");
8081
8082                 priv->ieee->abg_true = 0;
8083                 band = IEEE80211_24GHZ_BAND;
8084                 modulation = IEEE80211_OFDM_MODULATION |
8085                     IEEE80211_CCK_MODULATION;
8086                 priv->adapter = IPW_2200BG;
8087                 priv->ieee->mode = IEEE_G | IEEE_B;
8088         }
8089
8090         priv->ieee->freq_band = band;
8091         priv->ieee->modulation = modulation;
8092
8093         priv->rates_mask = IEEE80211_DEFAULT_RATES_MASK;
8094
8095         priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8096         priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
8097
8098         priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8099         priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8100         priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
8101
8102         /* If power management is turned on, default to AC mode */
8103         priv->power_mode = IPW_POWER_AC;
8104         priv->tx_power = IPW_TX_POWER_DEFAULT;
8105
8106         return old_mode == priv->ieee->iw_mode;
8107 }
8108
8109 /*
8110  * This file defines the Wireless Extension handlers.  It does not
8111  * define any methods of hardware manipulation and relies on the
8112  * functions defined in ipw_main to provide the HW interaction.
8113  *
8114  * The exception to this is the use of the ipw_get_ordinal()
8115  * function used to poll the hardware vs. making unecessary calls.
8116  *
8117  */
8118
8119 static int ipw_wx_get_name(struct net_device *dev,
8120                            struct iw_request_info *info,
8121                            union iwreq_data *wrqu, char *extra)
8122 {
8123         struct ipw_priv *priv = ieee80211_priv(dev);
8124         mutex_lock(&priv->mutex);
8125         if (priv->status & STATUS_RF_KILL_MASK)
8126                 strcpy(wrqu->name, "radio off");
8127         else if (!(priv->status & STATUS_ASSOCIATED))
8128                 strcpy(wrqu->name, "unassociated");
8129         else
8130                 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11%c",
8131                          ipw_modes[priv->assoc_request.ieee_mode]);
8132         IPW_DEBUG_WX("Name: %s\n", wrqu->name);
8133         mutex_unlock(&priv->mutex);
8134         return 0;
8135 }
8136
8137 static int ipw_set_channel(struct ipw_priv *priv, u8 channel)
8138 {
8139         if (channel == 0) {
8140                 IPW_DEBUG_INFO("Setting channel to ANY (0)\n");
8141                 priv->config &= ~CFG_STATIC_CHANNEL;
8142                 IPW_DEBUG_ASSOC("Attempting to associate with new "
8143                                 "parameters.\n");
8144                 ipw_associate(priv);
8145                 return 0;
8146         }
8147
8148         priv->config |= CFG_STATIC_CHANNEL;
8149
8150         if (priv->channel == channel) {
8151                 IPW_DEBUG_INFO("Request to set channel to current value (%d)\n",
8152                                channel);
8153                 return 0;
8154         }
8155
8156         IPW_DEBUG_INFO("Setting channel to %i\n", (int)channel);
8157         priv->channel = channel;
8158
8159 #ifdef CONFIG_IPW2200_MONITOR
8160         if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8161                 int i;
8162                 if (priv->status & STATUS_SCANNING) {
8163                         IPW_DEBUG_SCAN("Scan abort triggered due to "
8164                                        "channel change.\n");
8165                         ipw_abort_scan(priv);
8166                 }
8167
8168                 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8169                         udelay(10);
8170
8171                 if (priv->status & STATUS_SCANNING)
8172                         IPW_DEBUG_SCAN("Still scanning...\n");
8173                 else
8174                         IPW_DEBUG_SCAN("Took %dms to abort current scan\n",
8175                                        1000 - i);
8176
8177                 return 0;
8178         }
8179 #endif                          /* CONFIG_IPW2200_MONITOR */
8180
8181         /* Network configuration changed -- force [re]association */
8182         IPW_DEBUG_ASSOC("[re]association triggered due to channel change.\n");
8183         if (!ipw_disassociate(priv))
8184                 ipw_associate(priv);
8185
8186         return 0;
8187 }
8188
8189 static int ipw_wx_set_freq(struct net_device *dev,
8190                            struct iw_request_info *info,
8191                            union iwreq_data *wrqu, char *extra)
8192 {
8193         struct ipw_priv *priv = ieee80211_priv(dev);
8194         const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
8195         struct iw_freq *fwrq = &wrqu->freq;
8196         int ret = 0, i;
8197         u8 channel, flags;
8198         int band;
8199
8200         if (fwrq->m == 0) {
8201                 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
8202                 mutex_lock(&priv->mutex);
8203                 ret = ipw_set_channel(priv, 0);
8204                 mutex_unlock(&priv->mutex);
8205                 return ret;
8206         }
8207         /* if setting by freq convert to channel */
8208         if (fwrq->e == 1) {
8209                 channel = ieee80211_freq_to_channel(priv->ieee, fwrq->m);
8210                 if (channel == 0)
8211                         return -EINVAL;
8212         } else
8213                 channel = fwrq->m;
8214
8215         if (!(band = ieee80211_is_valid_channel(priv->ieee, channel)))
8216                 return -EINVAL;
8217
8218         if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
8219                 i = ieee80211_channel_to_index(priv->ieee, channel);
8220                 if (i == -1)
8221                         return -EINVAL;
8222
8223                 flags = (band == IEEE80211_24GHZ_BAND) ?
8224                     geo->bg[i].flags : geo->a[i].flags;
8225                 if (flags & IEEE80211_CH_PASSIVE_ONLY) {
8226                         IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8227                         return -EINVAL;
8228                 }
8229         }
8230
8231         IPW_DEBUG_WX("SET Freq/Channel -> %d \n", fwrq->m);
8232         mutex_lock(&priv->mutex);
8233         ret = ipw_set_channel(priv, channel);
8234         mutex_unlock(&priv->mutex);
8235         return ret;
8236 }
8237
8238 static int ipw_wx_get_freq(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
8244         wrqu->freq.e = 0;
8245
8246         /* If we are associated, trying to associate, or have a statically
8247          * configured CHANNEL then return that; otherwise return ANY */
8248         mutex_lock(&priv->mutex);
8249         if (priv->config & CFG_STATIC_CHANNEL ||
8250             priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED))
8251                 wrqu->freq.m = priv->channel;
8252         else
8253                 wrqu->freq.m = 0;
8254
8255         mutex_unlock(&priv->mutex);
8256         IPW_DEBUG_WX("GET Freq/Channel -> %d \n", priv->channel);
8257         return 0;
8258 }
8259
8260 static int ipw_wx_set_mode(struct net_device *dev,
8261                            struct iw_request_info *info,
8262                            union iwreq_data *wrqu, char *extra)
8263 {
8264         struct ipw_priv *priv = ieee80211_priv(dev);
8265         int err = 0;
8266
8267         IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8268
8269         switch (wrqu->mode) {
8270 #ifdef CONFIG_IPW2200_MONITOR
8271         case IW_MODE_MONITOR:
8272 #endif
8273         case IW_MODE_ADHOC:
8274         case IW_MODE_INFRA:
8275                 break;
8276         case IW_MODE_AUTO:
8277                 wrqu->mode = IW_MODE_INFRA;
8278                 break;
8279         default:
8280                 return -EINVAL;
8281         }
8282         if (wrqu->mode == priv->ieee->iw_mode)
8283                 return 0;
8284
8285         mutex_lock(&priv->mutex);
8286
8287         ipw_sw_reset(priv, 0);
8288
8289 #ifdef CONFIG_IPW2200_MONITOR
8290         if (priv->ieee->iw_mode == IW_MODE_MONITOR)
8291                 priv->net_dev->type = ARPHRD_ETHER;
8292
8293         if (wrqu->mode == IW_MODE_MONITOR)
8294 #ifdef CONFIG_IEEE80211_RADIOTAP
8295                 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8296 #else
8297                 priv->net_dev->type = ARPHRD_IEEE80211;
8298 #endif
8299 #endif                          /* CONFIG_IPW2200_MONITOR */
8300
8301         /* Free the existing firmware and reset the fw_loaded
8302          * flag so ipw_load() will bring in the new firmawre */
8303         free_firmware();
8304
8305         priv->ieee->iw_mode = wrqu->mode;
8306
8307         queue_work(priv->workqueue, &priv->adapter_restart);
8308         mutex_unlock(&priv->mutex);
8309         return err;
8310 }
8311
8312 static int ipw_wx_get_mode(struct net_device *dev,
8313                            struct iw_request_info *info,
8314                            union iwreq_data *wrqu, char *extra)
8315 {
8316         struct ipw_priv *priv = ieee80211_priv(dev);
8317         mutex_lock(&priv->mutex);
8318         wrqu->mode = priv->ieee->iw_mode;
8319         IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
8320         mutex_unlock(&priv->mutex);
8321         return 0;
8322 }
8323
8324 /* Values are in microsecond */
8325 static const s32 timeout_duration[] = {
8326         350000,
8327         250000,
8328         75000,
8329         37000,
8330         25000,
8331 };
8332
8333 static const s32 period_duration[] = {
8334         400000,
8335         700000,
8336         1000000,
8337         1000000,
8338         1000000
8339 };
8340
8341 static int ipw_wx_get_range(struct net_device *dev,
8342                             struct iw_request_info *info,
8343                             union iwreq_data *wrqu, char *extra)
8344 {
8345         struct ipw_priv *priv = ieee80211_priv(dev);
8346         struct iw_range *range = (struct iw_range *)extra;
8347         const struct ieee80211_geo *geo = ieee80211_get_geo(priv->ieee);
8348         int i = 0, j;
8349
8350         wrqu->data.length = sizeof(*range);
8351         memset(range, 0, sizeof(*range));
8352
8353         /* 54Mbs == ~27 Mb/s real (802.11g) */
8354         range->throughput = 27 * 1000 * 1000;
8355
8356         range->max_qual.qual = 100;
8357         /* TODO: Find real max RSSI and stick here */
8358         range->max_qual.level = 0;
8359         range->max_qual.noise = 0;
8360         range->max_qual.updated = 7;    /* Updated all three */
8361
8362         range->avg_qual.qual = 70;
8363         /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
8364         range->avg_qual.level = 0;      /* FIXME to real average level */
8365         range->avg_qual.noise = 0;
8366         range->avg_qual.updated = 7;    /* Updated all three */
8367         mutex_lock(&priv->mutex);
8368         range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
8369
8370         for (i = 0; i < range->num_bitrates; i++)
8371                 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
8372                     500000;
8373
8374         range->max_rts = DEFAULT_RTS_THRESHOLD;
8375         range->min_frag = MIN_FRAG_THRESHOLD;
8376         range->max_frag = MAX_FRAG_THRESHOLD;
8377
8378         range->encoding_size[0] = 5;
8379         range->encoding_size[1] = 13;
8380         range->num_encoding_sizes = 2;
8381         range->max_encoding_tokens = WEP_KEYS;
8382
8383         /* Set the Wireless Extension versions */
8384         range->we_version_compiled = WIRELESS_EXT;
8385         range->we_version_source = 18;
8386
8387         i = 0;
8388         if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
8389                 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES; j++) {
8390                         if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
8391                             (geo->bg[j].flags & IEEE80211_CH_PASSIVE_ONLY))
8392                                 continue;
8393
8394                         range->freq[i].i = geo->bg[j].channel;
8395                         range->freq[i].m = geo->bg[j].freq * 100000;
8396                         range->freq[i].e = 1;
8397                         i++;
8398                 }
8399         }
8400
8401         if (priv->ieee->mode & IEEE_A) {
8402                 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES; j++) {
8403                         if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
8404                             (geo->a[j].flags & IEEE80211_CH_PASSIVE_ONLY))
8405                                 continue;
8406
8407                         range->freq[i].i = geo->a[j].channel;
8408                         range->freq[i].m = geo->a[j].freq * 100000;
8409                         range->freq[i].e = 1;
8410                         i++;
8411                 }
8412         }
8413
8414         range->num_channels = i;
8415         range->num_frequency = i;
8416
8417         mutex_unlock(&priv->mutex);
8418
8419         /* Event capability (kernel + driver) */
8420         range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
8421                                 IW_EVENT_CAPA_MASK(SIOCGIWTHRSPY) |
8422                                 IW_EVENT_CAPA_MASK(SIOCGIWAP));
8423         range->event_capa[1] = IW_EVENT_CAPA_K_1;
8424
8425         range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
8426                 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
8427
8428         IPW_DEBUG_WX("GET Range\n");
8429         return 0;
8430 }
8431
8432 static int ipw_wx_set_wap(struct net_device *dev,
8433                           struct iw_request_info *info,
8434                           union iwreq_data *wrqu, char *extra)
8435 {
8436         struct ipw_priv *priv = ieee80211_priv(dev);
8437
8438         static const unsigned char any[] = {
8439                 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
8440         };
8441         static const unsigned char off[] = {
8442                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
8443         };
8444
8445         if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
8446                 return -EINVAL;
8447         mutex_lock(&priv->mutex);
8448         if (!memcmp(any, wrqu->ap_addr.sa_data, ETH_ALEN) ||
8449             !memcmp(off, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8450                 /* we disable mandatory BSSID association */
8451                 IPW_DEBUG_WX("Setting AP BSSID to ANY\n");
8452                 priv->config &= ~CFG_STATIC_BSSID;
8453                 IPW_DEBUG_ASSOC("Attempting to associate with new "
8454                                 "parameters.\n");
8455                 ipw_associate(priv);
8456                 mutex_unlock(&priv->mutex);
8457                 return 0;
8458         }
8459
8460         priv->config |= CFG_STATIC_BSSID;
8461         if (!memcmp(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN)) {
8462                 IPW_DEBUG_WX("BSSID set to current BSSID.\n");
8463                 mutex_unlock(&priv->mutex);
8464                 return 0;
8465         }
8466
8467         IPW_DEBUG_WX("Setting mandatory BSSID to " MAC_FMT "\n",
8468                      MAC_ARG(wrqu->ap_addr.sa_data));
8469
8470         memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
8471
8472         /* Network configuration changed -- force [re]association */
8473         IPW_DEBUG_ASSOC("[re]association triggered due to BSSID change.\n");
8474         if (!ipw_disassociate(priv))
8475                 ipw_associate(priv);
8476
8477         mutex_unlock(&priv->mutex);
8478         return 0;
8479 }
8480
8481 static int ipw_wx_get_wap(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         /* If we are associated, trying to associate, or have a statically
8487          * configured BSSID then return that; otherwise return ANY */
8488         mutex_lock(&priv->mutex);
8489         if (priv->config & CFG_STATIC_BSSID ||
8490             priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8491                 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
8492                 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
8493         } else
8494                 memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
8495
8496         IPW_DEBUG_WX("Getting WAP BSSID: " MAC_FMT "\n",
8497                      MAC_ARG(wrqu->ap_addr.sa_data));
8498         mutex_unlock(&priv->mutex);
8499         return 0;
8500 }
8501
8502 static int ipw_wx_set_essid(struct net_device *dev,
8503                             struct iw_request_info *info,
8504                             union iwreq_data *wrqu, char *extra)
8505 {
8506         struct ipw_priv *priv = ieee80211_priv(dev);
8507         char *essid = "";       /* ANY */
8508         int length = 0;
8509         mutex_lock(&priv->mutex);
8510         if (wrqu->essid.flags && wrqu->essid.length) {
8511                 length = wrqu->essid.length - 1;
8512                 essid = extra;
8513         }
8514         if (length == 0) {
8515                 IPW_DEBUG_WX("Setting ESSID to ANY\n");
8516                 if ((priv->config & CFG_STATIC_ESSID) &&
8517                     !(priv->status & (STATUS_ASSOCIATED |
8518                                       STATUS_ASSOCIATING))) {
8519                         IPW_DEBUG_ASSOC("Attempting to associate with new "
8520                                         "parameters.\n");
8521                         priv->config &= ~CFG_STATIC_ESSID;
8522                         ipw_associate(priv);
8523                 }
8524                 mutex_unlock(&priv->mutex);
8525                 return 0;
8526         }
8527
8528         length = min(length, IW_ESSID_MAX_SIZE);
8529
8530         priv->config |= CFG_STATIC_ESSID;
8531
8532         if (priv->essid_len == length && !memcmp(priv->essid, extra, length)) {
8533                 IPW_DEBUG_WX("ESSID set to current ESSID.\n");
8534                 mutex_unlock(&priv->mutex);
8535                 return 0;
8536         }
8537
8538         IPW_DEBUG_WX("Setting ESSID: '%s' (%d)\n", escape_essid(essid, length),
8539                      length);
8540
8541         priv->essid_len = length;
8542         memcpy(priv->essid, essid, priv->essid_len);
8543
8544         /* Network configuration changed -- force [re]association */
8545         IPW_DEBUG_ASSOC("[re]association triggered due to ESSID change.\n");
8546         if (!ipw_disassociate(priv))
8547                 ipw_associate(priv);
8548
8549         mutex_unlock(&priv->mutex);
8550         return 0;
8551 }
8552
8553 static int ipw_wx_get_essid(struct net_device *dev,
8554                             struct iw_request_info *info,
8555                             union iwreq_data *wrqu, char *extra)
8556 {
8557         struct ipw_priv *priv = ieee80211_priv(dev);
8558
8559         /* If we are associated, trying to associate, or have a statically
8560          * configured ESSID then return that; otherwise return ANY */
8561         mutex_lock(&priv->mutex);
8562         if (priv->config & CFG_STATIC_ESSID ||
8563             priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8564                 IPW_DEBUG_WX("Getting essid: '%s'\n",
8565                              escape_essid(priv->essid, priv->essid_len));
8566                 memcpy(extra, priv->essid, priv->essid_len);
8567                 wrqu->essid.length = priv->essid_len;
8568                 wrqu->essid.flags = 1;  /* active */
8569         } else {
8570                 IPW_DEBUG_WX("Getting essid: ANY\n");
8571                 wrqu->essid.length = 0;
8572                 wrqu->essid.flags = 0;  /* active */
8573         }
8574         mutex_unlock(&priv->mutex);
8575         return 0;
8576 }
8577
8578 static int ipw_wx_set_nick(struct net_device *dev,
8579                            struct iw_request_info *info,
8580                            union iwreq_data *wrqu, char *extra)
8581 {
8582         struct ipw_priv *priv = ieee80211_priv(dev);
8583
8584         IPW_DEBUG_WX("Setting nick to '%s'\n", extra);
8585         if (wrqu->data.length > IW_ESSID_MAX_SIZE)
8586                 return -E2BIG;
8587         mutex_lock(&priv->mutex);
8588         wrqu->data.length = min((size_t) wrqu->data.length, sizeof(priv->nick));
8589         memset(priv->nick, 0, sizeof(priv->nick));
8590         memcpy(priv->nick, extra, wrqu->data.length);
8591         IPW_DEBUG_TRACE("<<\n");
8592         mutex_unlock(&priv->mutex);
8593         return 0;
8594
8595 }
8596
8597 static int ipw_wx_get_nick(struct net_device *dev,
8598                            struct iw_request_info *info,
8599                            union iwreq_data *wrqu, char *extra)
8600 {
8601         struct ipw_priv *priv = ieee80211_priv(dev);
8602         IPW_DEBUG_WX("Getting nick\n");
8603         mutex_lock(&priv->mutex);
8604         wrqu->data.length = strlen(priv->nick) + 1;
8605         memcpy(extra, priv->nick, wrqu->data.length);
8606         wrqu->data.flags = 1;   /* active */
8607         mutex_unlock(&priv->mutex);
8608         return 0;
8609 }
8610
8611 static int ipw_wx_set_rate(struct net_device *dev,
8612                            struct iw_request_info *info,
8613                            union iwreq_data *wrqu, char *extra)
8614 {
8615         /* TODO: We should use semaphores or locks for access to priv */
8616         struct ipw_priv *priv = ieee80211_priv(dev);
8617         u32 target_rate = wrqu->bitrate.value;
8618         u32 fixed, mask;
8619
8620         /* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
8621         /* value = X, fixed = 1 means only rate X */
8622         /* value = X, fixed = 0 means all rates lower equal X */
8623
8624         if (target_rate == -1) {
8625                 fixed = 0;
8626                 mask = IEEE80211_DEFAULT_RATES_MASK;
8627                 /* Now we should reassociate */
8628                 goto apply;
8629         }
8630
8631         mask = 0;
8632         fixed = wrqu->bitrate.fixed;
8633
8634         if (target_rate == 1000000 || !fixed)
8635                 mask |= IEEE80211_CCK_RATE_1MB_MASK;
8636         if (target_rate == 1000000)
8637                 goto apply;
8638
8639         if (target_rate == 2000000 || !fixed)
8640                 mask |= IEEE80211_CCK_RATE_2MB_MASK;
8641         if (target_rate == 2000000)
8642                 goto apply;
8643
8644         if (target_rate == 5500000 || !fixed)
8645                 mask |= IEEE80211_CCK_RATE_5MB_MASK;
8646         if (target_rate == 5500000)
8647                 goto apply;
8648
8649         if (target_rate == 6000000 || !fixed)
8650                 mask |= IEEE80211_OFDM_RATE_6MB_MASK;
8651         if (target_rate == 6000000)
8652                 goto apply;
8653
8654         if (target_rate == 9000000 || !fixed)
8655                 mask |= IEEE80211_OFDM_RATE_9MB_MASK;
8656         if (target_rate == 9000000)
8657                 goto apply;
8658
8659         if (target_rate == 11000000 || !fixed)
8660                 mask |= IEEE80211_CCK_RATE_11MB_MASK;
8661         if (target_rate == 11000000)
8662                 goto apply;
8663
8664         if (target_rate == 12000000 || !fixed)
8665                 mask |= IEEE80211_OFDM_RATE_12MB_MASK;
8666         if (target_rate == 12000000)
8667                 goto apply;
8668
8669         if (target_rate == 18000000 || !fixed)
8670                 mask |= IEEE80211_OFDM_RATE_18MB_MASK;
8671         if (target_rate == 18000000)
8672                 goto apply;
8673
8674         if (target_rate == 24000000 || !fixed)
8675                 mask |= IEEE80211_OFDM_RATE_24MB_MASK;
8676         if (target_rate == 24000000)
8677                 goto apply;
8678
8679         if (target_rate == 36000000 || !fixed)
8680                 mask |= IEEE80211_OFDM_RATE_36MB_MASK;
8681         if (target_rate == 36000000)
8682                 goto apply;
8683
8684         if (target_rate == 48000000 || !fixed)
8685                 mask |= IEEE80211_OFDM_RATE_48MB_MASK;
8686         if (target_rate == 48000000)
8687                 goto apply;
8688
8689         if (target_rate == 54000000 || !fixed)
8690                 mask |= IEEE80211_OFDM_RATE_54MB_MASK;
8691         if (target_rate == 54000000)
8692                 goto apply;
8693
8694         IPW_DEBUG_WX("invalid rate specified, returning error\n");
8695         return -EINVAL;
8696
8697       apply:
8698         IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
8699                      mask, fixed ? "fixed" : "sub-rates");
8700         mutex_lock(&priv->mutex);
8701         if (mask == IEEE80211_DEFAULT_RATES_MASK) {
8702                 priv->config &= ~CFG_FIXED_RATE;
8703                 ipw_set_fixed_rate(priv, priv->ieee->mode);
8704         } else
8705                 priv->config |= CFG_FIXED_RATE;
8706
8707         if (priv->rates_mask == mask) {
8708                 IPW_DEBUG_WX("Mask set to current mask.\n");
8709                 mutex_unlock(&priv->mutex);
8710                 return 0;
8711         }
8712
8713         priv->rates_mask = mask;
8714
8715         /* Network configuration changed -- force [re]association */
8716         IPW_DEBUG_ASSOC("[re]association triggered due to rates change.\n");
8717         if (!ipw_disassociate(priv))
8718                 ipw_associate(priv);
8719
8720         mutex_unlock(&priv->mutex);
8721         return 0;
8722 }
8723
8724 static int ipw_wx_get_rate(struct net_device *dev,
8725                            struct iw_request_info *info,
8726                            union iwreq_data *wrqu, char *extra)
8727 {
8728         struct ipw_priv *priv = ieee80211_priv(dev);
8729         mutex_lock(&priv->mutex);
8730         wrqu->bitrate.value = priv->last_rate;
8731         mutex_unlock(&priv->mutex);
8732         IPW_DEBUG_WX("GET Rate -> %d \n", wrqu->bitrate.value);
8733         return 0;
8734 }
8735
8736 static int ipw_wx_set_rts(struct net_device *dev,
8737                           struct iw_request_info *info,
8738                           union iwreq_data *wrqu, char *extra)
8739 {
8740         struct ipw_priv *priv = ieee80211_priv(dev);
8741         mutex_lock(&priv->mutex);
8742         if (wrqu->rts.disabled)
8743                 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8744         else {
8745                 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
8746                     wrqu->rts.value > MAX_RTS_THRESHOLD) {
8747                         mutex_unlock(&priv->mutex);
8748                         return -EINVAL;
8749                 }
8750                 priv->rts_threshold = wrqu->rts.value;
8751         }
8752
8753         ipw_send_rts_threshold(priv, priv->rts_threshold);
8754         mutex_unlock(&priv->mutex);
8755         IPW_DEBUG_WX("SET RTS Threshold -> %d \n", priv->rts_threshold);
8756         return 0;
8757 }
8758
8759 static int ipw_wx_get_rts(struct net_device *dev,
8760                           struct iw_request_info *info,
8761                           union iwreq_data *wrqu, char *extra)
8762 {
8763         struct ipw_priv *priv = ieee80211_priv(dev);
8764         mutex_lock(&priv->mutex);
8765         wrqu->rts.value = priv->rts_threshold;
8766         wrqu->rts.fixed = 0;    /* no auto select */
8767         wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
8768         mutex_unlock(&priv->mutex);
8769         IPW_DEBUG_WX("GET RTS Threshold -> %d \n", wrqu->rts.value);
8770         return 0;
8771 }
8772
8773 static int ipw_wx_set_txpow(struct net_device *dev,
8774                             struct iw_request_info *info,
8775                             union iwreq_data *wrqu, char *extra)
8776 {
8777         struct ipw_priv *priv = ieee80211_priv(dev);
8778         int err = 0;
8779
8780         mutex_lock(&priv->mutex);
8781         if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
8782                 err = -EINPROGRESS;
8783                 goto out;
8784         }
8785
8786         if (!wrqu->power.fixed)
8787                 wrqu->power.value = IPW_TX_POWER_DEFAULT;
8788
8789         if (wrqu->power.flags != IW_TXPOW_DBM) {
8790                 err = -EINVAL;
8791                 goto out;
8792         }
8793
8794         if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
8795             (wrqu->power.value < IPW_TX_POWER_MIN)) {
8796                 err = -EINVAL;
8797                 goto out;
8798         }
8799
8800         priv->tx_power = wrqu->power.value;
8801         err = ipw_set_tx_power(priv);
8802       out:
8803         mutex_unlock(&priv->mutex);
8804         return err;
8805 }
8806
8807 static int ipw_wx_get_txpow(struct net_device *dev,
8808                             struct iw_request_info *info,
8809                             union iwreq_data *wrqu, char *extra)
8810 {
8811         struct ipw_priv *priv = ieee80211_priv(dev);
8812         mutex_lock(&priv->mutex);
8813         wrqu->power.value = priv->tx_power;
8814         wrqu->power.fixed = 1;
8815         wrqu->power.flags = IW_TXPOW_DBM;
8816         wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
8817         mutex_unlock(&priv->mutex);
8818
8819         IPW_DEBUG_WX("GET TX Power -> %s %d \n",
8820                      wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
8821
8822         return 0;
8823 }
8824
8825 static int ipw_wx_set_frag(struct net_device *dev,
8826                            struct iw_request_info *info,
8827                            union iwreq_data *wrqu, char *extra)
8828 {
8829         struct ipw_priv *priv = ieee80211_priv(dev);
8830         mutex_lock(&priv->mutex);
8831         if (wrqu->frag.disabled)
8832                 priv->ieee->fts = DEFAULT_FTS;
8833         else {
8834                 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
8835                     wrqu->frag.value > MAX_FRAG_THRESHOLD) {
8836                         mutex_unlock(&priv->mutex);
8837                         return -EINVAL;
8838                 }
8839
8840                 priv->ieee->fts = wrqu->frag.value & ~0x1;
8841         }
8842
8843         ipw_send_frag_threshold(priv, wrqu->frag.value);
8844         mutex_unlock(&priv->mutex);
8845         IPW_DEBUG_WX("SET Frag Threshold -> %d \n", wrqu->frag.value);
8846         return 0;
8847 }
8848
8849 static int ipw_wx_get_frag(struct net_device *dev,
8850                            struct iw_request_info *info,
8851                            union iwreq_data *wrqu, char *extra)
8852 {
8853         struct ipw_priv *priv = ieee80211_priv(dev);
8854         mutex_lock(&priv->mutex);
8855         wrqu->frag.value = priv->ieee->fts;
8856         wrqu->frag.fixed = 0;   /* no auto select */
8857         wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
8858         mutex_unlock(&priv->mutex);
8859         IPW_DEBUG_WX("GET Frag Threshold -> %d \n", wrqu->frag.value);
8860
8861         return 0;
8862 }
8863
8864 static int ipw_wx_set_retry(struct net_device *dev,
8865                             struct iw_request_info *info,
8866                             union iwreq_data *wrqu, char *extra)
8867 {
8868         struct ipw_priv *priv = ieee80211_priv(dev);
8869
8870         if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
8871                 return -EINVAL;
8872
8873         if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
8874                 return 0;
8875
8876         if (wrqu->retry.value < 0 || wrqu->retry.value > 255)
8877                 return -EINVAL;
8878
8879         mutex_lock(&priv->mutex);
8880         if (wrqu->retry.flags & IW_RETRY_MIN)
8881                 priv->short_retry_limit = (u8) wrqu->retry.value;
8882         else if (wrqu->retry.flags & IW_RETRY_MAX)
8883                 priv->long_retry_limit = (u8) wrqu->retry.value;
8884         else {
8885                 priv->short_retry_limit = (u8) wrqu->retry.value;
8886                 priv->long_retry_limit = (u8) wrqu->retry.value;
8887         }
8888
8889         ipw_send_retry_limit(priv, priv->short_retry_limit,
8890                              priv->long_retry_limit);
8891         mutex_unlock(&priv->mutex);
8892         IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
8893                      priv->short_retry_limit, priv->long_retry_limit);
8894         return 0;
8895 }
8896
8897 static int ipw_wx_get_retry(struct net_device *dev,
8898                             struct iw_request_info *info,
8899                             union iwreq_data *wrqu, char *extra)
8900 {
8901         struct ipw_priv *priv = ieee80211_priv(dev);
8902
8903         mutex_lock(&priv->mutex);
8904         wrqu->retry.disabled = 0;
8905
8906         if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
8907                 mutex_unlock(&priv->mutex);
8908                 return -EINVAL;
8909         }
8910
8911         if (wrqu->retry.flags & IW_RETRY_MAX) {
8912                 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
8913                 wrqu->retry.value = priv->long_retry_limit;
8914         } else if (wrqu->retry.flags & IW_RETRY_MIN) {
8915                 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_MIN;
8916                 wrqu->retry.value = priv->short_retry_limit;
8917         } else {
8918                 wrqu->retry.flags = IW_RETRY_LIMIT;
8919                 wrqu->retry.value = priv->short_retry_limit;
8920         }
8921         mutex_unlock(&priv->mutex);
8922
8923         IPW_DEBUG_WX("GET retry -> %d \n", wrqu->retry.value);
8924
8925         return 0;
8926 }
8927
8928 static int ipw_request_direct_scan(struct ipw_priv *priv, char *essid,
8929                                    int essid_len)
8930 {
8931         struct ipw_scan_request_ext scan;
8932         int err = 0, scan_type;
8933
8934         if (!(priv->status & STATUS_INIT) ||
8935             (priv->status & STATUS_EXIT_PENDING))
8936                 return 0;
8937
8938         mutex_lock(&priv->mutex);
8939
8940         if (priv->status & STATUS_RF_KILL_MASK) {
8941                 IPW_DEBUG_HC("Aborting scan due to RF kill activation\n");
8942                 priv->status |= STATUS_SCAN_PENDING;
8943                 goto done;
8944         }
8945
8946         IPW_DEBUG_HC("starting request direct scan!\n");
8947
8948         if (priv->status & (STATUS_SCANNING | STATUS_SCAN_ABORTING)) {
8949                 /* We should not sleep here; otherwise we will block most
8950                  * of the system (for instance, we hold rtnl_lock when we
8951                  * get here).
8952                  */
8953                 err = -EAGAIN;
8954                 goto done;
8955         }
8956         memset(&scan, 0, sizeof(scan));
8957
8958         if (priv->config & CFG_SPEED_SCAN)
8959                 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8960                     cpu_to_le16(30);
8961         else
8962                 scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] =
8963                     cpu_to_le16(20);
8964
8965         scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] =
8966             cpu_to_le16(20);
8967         scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = cpu_to_le16(120);
8968         scan.dwell_time[IPW_SCAN_ACTIVE_DIRECT_SCAN] = cpu_to_le16(20);
8969
8970         scan.full_scan_index = cpu_to_le32(ieee80211_get_scans(priv->ieee));
8971
8972         err = ipw_send_ssid(priv, essid, essid_len);
8973         if (err) {
8974                 IPW_DEBUG_HC("Attempt to send SSID command failed\n");
8975                 goto done;
8976         }
8977         scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
8978
8979         ipw_add_scan_channels(priv, &scan, scan_type);
8980
8981         err = ipw_send_scan_request_ext(priv, &scan);
8982         if (err) {
8983                 IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
8984                 goto done;
8985         }
8986
8987         priv->status |= STATUS_SCANNING;
8988
8989       done:
8990         mutex_unlock(&priv->mutex);
8991         return err;
8992 }
8993
8994 static int ipw_wx_set_scan(struct net_device *dev,
8995                            struct iw_request_info *info,
8996                            union iwreq_data *wrqu, char *extra)
8997 {
8998         struct ipw_priv *priv = ieee80211_priv(dev);
8999         struct iw_scan_req *req = NULL;
9000         if (wrqu->data.length
9001             && wrqu->data.length == sizeof(struct iw_scan_req)) {
9002                 req = (struct iw_scan_req *)extra;
9003                 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
9004                         ipw_request_direct_scan(priv, req->essid,
9005                                                 req->essid_len);
9006                         return 0;
9007                 }
9008         }
9009
9010         IPW_DEBUG_WX("Start scan\n");
9011
9012         queue_work(priv->workqueue, &priv->request_scan);
9013
9014         return 0;
9015 }
9016
9017 static int ipw_wx_get_scan(struct net_device *dev,
9018                            struct iw_request_info *info,
9019                            union iwreq_data *wrqu, char *extra)
9020 {
9021         struct ipw_priv *priv = ieee80211_priv(dev);
9022         return ieee80211_wx_get_scan(priv->ieee, info, wrqu, extra);
9023 }
9024
9025 static int ipw_wx_set_encode(struct net_device *dev,
9026                              struct iw_request_info *info,
9027                              union iwreq_data *wrqu, char *key)
9028 {
9029         struct ipw_priv *priv = ieee80211_priv(dev);
9030         int ret;
9031         u32 cap = priv->capability;
9032
9033         mutex_lock(&priv->mutex);
9034         ret = ieee80211_wx_set_encode(priv->ieee, info, wrqu, key);
9035
9036         /* In IBSS mode, we need to notify the firmware to update
9037          * the beacon info after we changed the capability. */
9038         if (cap != priv->capability &&
9039             priv->ieee->iw_mode == IW_MODE_ADHOC &&
9040             priv->status & STATUS_ASSOCIATED)
9041                 ipw_disassociate(priv);
9042
9043         mutex_unlock(&priv->mutex);
9044         return ret;
9045 }
9046
9047 static int ipw_wx_get_encode(struct net_device *dev,
9048                              struct iw_request_info *info,
9049                              union iwreq_data *wrqu, char *key)
9050 {
9051         struct ipw_priv *priv = ieee80211_priv(dev);
9052         return ieee80211_wx_get_encode(priv->ieee, info, wrqu, key);
9053 }
9054
9055 static int ipw_wx_set_power(struct net_device *dev,
9056                             struct iw_request_info *info,
9057                             union iwreq_data *wrqu, char *extra)
9058 {
9059         struct ipw_priv *priv = ieee80211_priv(dev);
9060         int err;
9061         mutex_lock(&priv->mutex);
9062         if (wrqu->power.disabled) {
9063                 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9064                 err = ipw_send_power_mode(priv, IPW_POWER_MODE_CAM);
9065                 if (err) {
9066                         IPW_DEBUG_WX("failed setting power mode.\n");
9067                         mutex_unlock(&priv->mutex);
9068                         return err;
9069                 }
9070                 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
9071                 mutex_unlock(&priv->mutex);
9072                 return 0;
9073         }
9074
9075         switch (wrqu->power.flags & IW_POWER_MODE) {
9076         case IW_POWER_ON:       /* If not specified */
9077         case IW_POWER_MODE:     /* If set all mask */
9078         case IW_POWER_ALL_R:    /* If explicitely state all */
9079                 break;
9080         default:                /* Otherwise we don't support it */
9081                 IPW_DEBUG_WX("SET PM Mode: %X not supported.\n",
9082                              wrqu->power.flags);
9083                 mutex_unlock(&priv->mutex);
9084                 return -EOPNOTSUPP;
9085         }
9086
9087         /* If the user hasn't specified a power management mode yet, default
9088          * to BATTERY */
9089         if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
9090                 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
9091         else
9092                 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9093         err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9094         if (err) {
9095                 IPW_DEBUG_WX("failed setting power mode.\n");
9096                 mutex_unlock(&priv->mutex);
9097                 return err;
9098         }
9099
9100         IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
9101         mutex_unlock(&priv->mutex);
9102         return 0;
9103 }
9104
9105 static int ipw_wx_get_power(struct net_device *dev,
9106                             struct iw_request_info *info,
9107                             union iwreq_data *wrqu, char *extra)
9108 {
9109         struct ipw_priv *priv = ieee80211_priv(dev);
9110         mutex_lock(&priv->mutex);
9111         if (!(priv->power_mode & IPW_POWER_ENABLED))
9112                 wrqu->power.disabled = 1;
9113         else
9114                 wrqu->power.disabled = 0;
9115
9116         mutex_unlock(&priv->mutex);
9117         IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
9118
9119         return 0;
9120 }
9121
9122 static int ipw_wx_set_powermode(struct net_device *dev,
9123                                 struct iw_request_info *info,
9124                                 union iwreq_data *wrqu, char *extra)
9125 {
9126         struct ipw_priv *priv = ieee80211_priv(dev);
9127         int mode = *(int *)extra;
9128         int err;
9129         mutex_lock(&priv->mutex);
9130         if ((mode < 1) || (mode > IPW_POWER_LIMIT)) {
9131                 mode = IPW_POWER_AC;
9132                 priv->power_mode = mode;
9133         } else {
9134                 priv->power_mode = IPW_POWER_ENABLED | mode;
9135         }
9136
9137         if (priv->power_mode != mode) {
9138                 err = ipw_send_power_mode(priv, mode);
9139
9140                 if (err) {
9141                         IPW_DEBUG_WX("failed setting power mode.\n");
9142                         mutex_unlock(&priv->mutex);
9143                         return err;
9144                 }
9145         }
9146         mutex_unlock(&priv->mutex);
9147         return 0;
9148 }
9149
9150 #define MAX_WX_STRING 80
9151 static int ipw_wx_get_powermode(struct net_device *dev,
9152                                 struct iw_request_info *info,
9153                                 union iwreq_data *wrqu, char *extra)
9154 {
9155         struct ipw_priv *priv = ieee80211_priv(dev);
9156         int level = IPW_POWER_LEVEL(priv->power_mode);
9157         char *p = extra;
9158
9159         p += snprintf(p, MAX_WX_STRING, "Power save level: %d ", level);
9160
9161         switch (level) {
9162         case IPW_POWER_AC:
9163                 p += snprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9164                 break;
9165         case IPW_POWER_BATTERY:
9166                 p += snprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9167                 break;
9168         default:
9169                 p += snprintf(p, MAX_WX_STRING - (p - extra),
9170                               "(Timeout %dms, Period %dms)",
9171                               timeout_duration[level - 1] / 1000,
9172                               period_duration[level - 1] / 1000);
9173         }
9174
9175         if (!(priv->power_mode & IPW_POWER_ENABLED))
9176                 p += snprintf(p, MAX_WX_STRING - (p - extra), " OFF");
9177
9178         wrqu->data.length = p - extra + 1;
9179
9180         return 0;
9181 }
9182
9183 static int ipw_wx_set_wireless_mode(struct net_device *dev,
9184                                     struct iw_request_info *info,
9185                                     union iwreq_data *wrqu, char *extra)
9186 {
9187         struct ipw_priv *priv = ieee80211_priv(dev);
9188         int mode = *(int *)extra;
9189         u8 band = 0, modulation = 0;
9190
9191         if (mode == 0 || mode & ~IEEE_MODE_MASK) {
9192                 IPW_WARNING("Attempt to set invalid wireless mode: %d\n", mode);
9193                 return -EINVAL;
9194         }
9195         mutex_lock(&priv->mutex);
9196         if (priv->adapter == IPW_2915ABG) {
9197                 priv->ieee->abg_true = 1;
9198                 if (mode & IEEE_A) {
9199                         band |= IEEE80211_52GHZ_BAND;
9200                         modulation |= IEEE80211_OFDM_MODULATION;
9201                 } else
9202                         priv->ieee->abg_true = 0;
9203         } else {
9204                 if (mode & IEEE_A) {
9205                         IPW_WARNING("Attempt to set 2200BG into "
9206                                     "802.11a mode\n");
9207                         mutex_unlock(&priv->mutex);
9208                         return -EINVAL;
9209                 }
9210
9211                 priv->ieee->abg_true = 0;
9212         }
9213
9214         if (mode & IEEE_B) {
9215                 band |= IEEE80211_24GHZ_BAND;
9216                 modulation |= IEEE80211_CCK_MODULATION;
9217         } else
9218                 priv->ieee->abg_true = 0;
9219
9220         if (mode & IEEE_G) {
9221                 band |= IEEE80211_24GHZ_BAND;
9222                 modulation |= IEEE80211_OFDM_MODULATION;
9223         } else
9224                 priv->ieee->abg_true = 0;
9225
9226         priv->ieee->mode = mode;
9227         priv->ieee->freq_band = band;
9228         priv->ieee->modulation = modulation;
9229         init_supported_rates(priv, &priv->rates);
9230
9231         /* Network configuration changed -- force [re]association */
9232         IPW_DEBUG_ASSOC("[re]association triggered due to mode change.\n");
9233         if (!ipw_disassociate(priv)) {
9234                 ipw_send_supported_rates(priv, &priv->rates);
9235                 ipw_associate(priv);
9236         }
9237
9238         /* Update the band LEDs */
9239         ipw_led_band_on(priv);
9240
9241         IPW_DEBUG_WX("PRIV SET MODE: %c%c%c\n",
9242                      mode & IEEE_A ? 'a' : '.',
9243                      mode & IEEE_B ? 'b' : '.', mode & IEEE_G ? 'g' : '.');
9244         mutex_unlock(&priv->mutex);
9245         return 0;
9246 }
9247
9248 static int ipw_wx_get_wireless_mode(struct net_device *dev,
9249                                     struct iw_request_info *info,
9250                                     union iwreq_data *wrqu, char *extra)
9251 {
9252         struct ipw_priv *priv = ieee80211_priv(dev);
9253         mutex_lock(&priv->mutex);
9254         switch (priv->ieee->mode) {
9255         case IEEE_A:
9256                 strncpy(extra, "802.11a (1)", MAX_WX_STRING);
9257                 break;
9258         case IEEE_B:
9259                 strncpy(extra, "802.11b (2)", MAX_WX_STRING);
9260                 break;
9261         case IEEE_A | IEEE_B:
9262                 strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
9263                 break;
9264         case IEEE_G:
9265                 strncpy(extra, "802.11g (4)", MAX_WX_STRING);
9266                 break;
9267         case IEEE_A | IEEE_G:
9268                 strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
9269                 break;
9270         case IEEE_B | IEEE_G:
9271                 strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
9272                 break;
9273         case IEEE_A | IEEE_B | IEEE_G:
9274                 strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
9275                 break;
9276         default:
9277                 strncpy(extra, "unknown", MAX_WX_STRING);
9278                 break;
9279         }
9280
9281         IPW_DEBUG_WX("PRIV GET MODE: %s\n", extra);
9282
9283         wrqu->data.length = strlen(extra) + 1;
9284         mutex_unlock(&priv->mutex);
9285
9286         return 0;
9287 }
9288
9289 static int ipw_wx_set_preamble(struct net_device *dev,
9290                                struct iw_request_info *info,
9291                                union iwreq_data *wrqu, char *extra)
9292 {
9293         struct ipw_priv *priv = ieee80211_priv(dev);
9294         int mode = *(int *)extra;
9295         mutex_lock(&priv->mutex);
9296         /* Switching from SHORT -> LONG requires a disassociation */
9297         if (mode == 1) {
9298                 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9299                         priv->config |= CFG_PREAMBLE_LONG;
9300
9301                         /* Network configuration changed -- force [re]association */
9302                         IPW_DEBUG_ASSOC
9303                             ("[re]association triggered due to preamble change.\n");
9304                         if (!ipw_disassociate(priv))
9305                                 ipw_associate(priv);
9306                 }
9307                 goto done;
9308         }
9309
9310         if (mode == 0) {
9311                 priv->config &= ~CFG_PREAMBLE_LONG;
9312                 goto done;
9313         }
9314         mutex_unlock(&priv->mutex);
9315         return -EINVAL;
9316
9317       done:
9318         mutex_unlock(&priv->mutex);
9319         return 0;
9320 }
9321
9322 static int ipw_wx_get_preamble(struct net_device *dev,
9323                                struct iw_request_info *info,
9324                                union iwreq_data *wrqu, char *extra)
9325 {
9326         struct ipw_priv *priv = ieee80211_priv(dev);
9327         mutex_lock(&priv->mutex);
9328         if (priv->config & CFG_PREAMBLE_LONG)
9329                 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9330         else
9331                 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
9332         mutex_unlock(&priv->mutex);
9333         return 0;
9334 }
9335
9336 #ifdef CONFIG_IPW2200_MONITOR
9337 static int ipw_wx_set_monitor(struct net_device *dev,
9338                               struct iw_request_info *info,
9339                               union iwreq_data *wrqu, char *extra)
9340 {
9341         struct ipw_priv *priv = ieee80211_priv(dev);
9342         int *parms = (int *)extra;
9343         int enable = (parms[0] > 0);
9344         mutex_lock(&priv->mutex);
9345         IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
9346         if (enable) {
9347                 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9348 #ifdef CONFIG_IEEE80211_RADIOTAP
9349                         priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9350 #else
9351                         priv->net_dev->type = ARPHRD_IEEE80211;
9352 #endif
9353                         queue_work(priv->workqueue, &priv->adapter_restart);
9354                 }
9355
9356                 ipw_set_channel(priv, parms[1]);
9357         } else {
9358                 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9359                         mutex_unlock(&priv->mutex);
9360                         return 0;
9361                 }
9362                 priv->net_dev->type = ARPHRD_ETHER;
9363                 queue_work(priv->workqueue, &priv->adapter_restart);
9364         }
9365         mutex_unlock(&priv->mutex);
9366         return 0;
9367 }
9368
9369 #endif                          // CONFIG_IPW2200_MONITOR
9370
9371 static int ipw_wx_reset(struct net_device *dev,
9372                         struct iw_request_info *info,
9373                         union iwreq_data *wrqu, char *extra)
9374 {
9375         struct ipw_priv *priv = ieee80211_priv(dev);
9376         IPW_DEBUG_WX("RESET\n");
9377         queue_work(priv->workqueue, &priv->adapter_restart);
9378         return 0;
9379 }
9380
9381 static int ipw_wx_sw_reset(struct net_device *dev,
9382                            struct iw_request_info *info,
9383                            union iwreq_data *wrqu, char *extra)
9384 {
9385         struct ipw_priv *priv = ieee80211_priv(dev);
9386         union iwreq_data wrqu_sec = {
9387                 .encoding = {
9388                              .flags = IW_ENCODE_DISABLED,
9389                              },
9390         };
9391         int ret;
9392
9393         IPW_DEBUG_WX("SW_RESET\n");
9394
9395         mutex_lock(&priv->mutex);
9396
9397         ret = ipw_sw_reset(priv, 2);
9398         if (!ret) {
9399                 free_firmware();
9400                 ipw_adapter_restart(priv);
9401         }
9402
9403         /* The SW reset bit might have been toggled on by the 'disable'
9404          * module parameter, so take appropriate action */
9405         ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9406
9407         mutex_unlock(&priv->mutex);
9408         ieee80211_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
9409         mutex_lock(&priv->mutex);
9410
9411         if (!(priv->status & STATUS_RF_KILL_MASK)) {
9412                 /* Configuration likely changed -- force [re]association */
9413                 IPW_DEBUG_ASSOC("[re]association triggered due to sw "
9414                                 "reset.\n");
9415                 if (!ipw_disassociate(priv))
9416                         ipw_associate(priv);
9417         }
9418
9419         mutex_unlock(&priv->mutex);
9420
9421         return 0;
9422 }
9423
9424 /* Rebase the WE IOCTLs to zero for the handler array */
9425 #define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
9426 static iw_handler ipw_wx_handlers[] = {
9427         IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name,
9428         IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq,
9429         IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq,
9430         IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode,
9431         IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode,
9432         IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range,
9433         IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap,
9434         IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap,
9435         IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan,
9436         IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan,
9437         IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid,
9438         IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid,
9439         IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick,
9440         IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick,
9441         IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate,
9442         IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate,
9443         IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts,
9444         IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts,
9445         IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag,
9446         IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag,
9447         IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow,
9448         IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow,
9449         IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry,
9450         IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry,
9451         IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
9452         IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
9453         IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power,
9454         IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power,
9455         IW_IOCTL(SIOCSIWSPY) = iw_handler_set_spy,
9456         IW_IOCTL(SIOCGIWSPY) = iw_handler_get_spy,
9457         IW_IOCTL(SIOCSIWTHRSPY) = iw_handler_set_thrspy,
9458         IW_IOCTL(SIOCGIWTHRSPY) = iw_handler_get_thrspy,
9459         IW_IOCTL(SIOCSIWGENIE) = ipw_wx_set_genie,
9460         IW_IOCTL(SIOCGIWGENIE) = ipw_wx_get_genie,
9461         IW_IOCTL(SIOCSIWMLME) = ipw_wx_set_mlme,
9462         IW_IOCTL(SIOCSIWAUTH) = ipw_wx_set_auth,
9463         IW_IOCTL(SIOCGIWAUTH) = ipw_wx_get_auth,
9464         IW_IOCTL(SIOCSIWENCODEEXT) = ipw_wx_set_encodeext,
9465         IW_IOCTL(SIOCGIWENCODEEXT) = ipw_wx_get_encodeext,
9466 };
9467
9468 enum {
9469         IPW_PRIV_SET_POWER = SIOCIWFIRSTPRIV,
9470         IPW_PRIV_GET_POWER,
9471         IPW_PRIV_SET_MODE,
9472         IPW_PRIV_GET_MODE,
9473         IPW_PRIV_SET_PREAMBLE,
9474         IPW_PRIV_GET_PREAMBLE,
9475         IPW_PRIV_RESET,
9476         IPW_PRIV_SW_RESET,
9477 #ifdef CONFIG_IPW2200_MONITOR
9478         IPW_PRIV_SET_MONITOR,
9479 #endif
9480 };
9481
9482 static struct iw_priv_args ipw_priv_args[] = {
9483         {
9484          .cmd = IPW_PRIV_SET_POWER,
9485          .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9486          .name = "set_power"},
9487         {
9488          .cmd = IPW_PRIV_GET_POWER,
9489          .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9490          .name = "get_power"},
9491         {
9492          .cmd = IPW_PRIV_SET_MODE,
9493          .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9494          .name = "set_mode"},
9495         {
9496          .cmd = IPW_PRIV_GET_MODE,
9497          .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
9498          .name = "get_mode"},
9499         {
9500          .cmd = IPW_PRIV_SET_PREAMBLE,
9501          .set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
9502          .name = "set_preamble"},
9503         {
9504          .cmd = IPW_PRIV_GET_PREAMBLE,
9505          .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
9506          .name = "get_preamble"},
9507         {
9508          IPW_PRIV_RESET,
9509          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
9510         {
9511          IPW_PRIV_SW_RESET,
9512          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "sw_reset"},
9513 #ifdef CONFIG_IPW2200_MONITOR
9514         {
9515          IPW_PRIV_SET_MONITOR,
9516          IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
9517 #endif                          /* CONFIG_IPW2200_MONITOR */
9518 };
9519
9520 static iw_handler ipw_priv_handler[] = {
9521         ipw_wx_set_powermode,
9522         ipw_wx_get_powermode,
9523         ipw_wx_set_wireless_mode,
9524         ipw_wx_get_wireless_mode,
9525         ipw_wx_set_preamble,
9526         ipw_wx_get_preamble,
9527         ipw_wx_reset,
9528         ipw_wx_sw_reset,
9529 #ifdef CONFIG_IPW2200_MONITOR
9530         ipw_wx_set_monitor,
9531 #endif
9532 };
9533
9534 static struct iw_handler_def ipw_wx_handler_def = {
9535         .standard = ipw_wx_handlers,
9536         .num_standard = ARRAY_SIZE(ipw_wx_handlers),
9537         .num_private = ARRAY_SIZE(ipw_priv_handler),
9538         .num_private_args = ARRAY_SIZE(ipw_priv_args),
9539         .private = ipw_priv_handler,
9540         .private_args = ipw_priv_args,
9541         .get_wireless_stats = ipw_get_wireless_stats,
9542 };
9543
9544 /*
9545  * Get wireless statistics.
9546  * Called by /proc/net/wireless
9547  * Also called by SIOCGIWSTATS
9548  */
9549 static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
9550 {
9551         struct ipw_priv *priv = ieee80211_priv(dev);
9552         struct iw_statistics *wstats;
9553
9554         wstats = &priv->wstats;
9555
9556         /* if hw is disabled, then ipw_get_ordinal() can't be called.
9557          * netdev->get_wireless_stats seems to be called before fw is
9558          * initialized.  STATUS_ASSOCIATED will only be set if the hw is up
9559          * and associated; if not associcated, the values are all meaningless
9560          * anyway, so set them all to NULL and INVALID */
9561         if (!(priv->status & STATUS_ASSOCIATED)) {
9562                 wstats->miss.beacon = 0;
9563                 wstats->discard.retries = 0;
9564                 wstats->qual.qual = 0;
9565                 wstats->qual.level = 0;
9566                 wstats->qual.noise = 0;
9567                 wstats->qual.updated = 7;
9568                 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
9569                     IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_INVALID;
9570                 return wstats;
9571         }
9572
9573         wstats->qual.qual = priv->quality;
9574         wstats->qual.level = average_value(&priv->average_rssi);
9575         wstats->qual.noise = average_value(&priv->average_noise);
9576         wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
9577             IW_QUAL_NOISE_UPDATED | IW_QUAL_DBM;
9578
9579         wstats->miss.beacon = average_value(&priv->average_missed_beacons);
9580         wstats->discard.retries = priv->last_tx_failures;
9581         wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
9582
9583 /*      if (ipw_get_ordinal(priv, IPW_ORD_STAT_TX_RETRY, &tx_retry, &len))
9584         goto fail_get_ordinal;
9585         wstats->discard.retries += tx_retry; */
9586
9587         return wstats;
9588 }
9589
9590 /* net device stuff */
9591
9592 static  void init_sys_config(struct ipw_sys_config *sys_config)
9593 {
9594         memset(sys_config, 0, sizeof(struct ipw_sys_config));
9595         sys_config->bt_coexistence = 0;
9596         sys_config->answer_broadcast_ssid_probe = 0;
9597         sys_config->accept_all_data_frames = 0;
9598         sys_config->accept_non_directed_frames = 1;
9599         sys_config->exclude_unicast_unencrypted = 0;
9600         sys_config->disable_unicast_decryption = 1;
9601         sys_config->exclude_multicast_unencrypted = 0;
9602         sys_config->disable_multicast_decryption = 1;
9603         sys_config->antenna_diversity = CFG_SYS_ANTENNA_SLOW_DIV;
9604         sys_config->pass_crc_to_host = 0;       /* TODO: See if 1 gives us FCS */
9605         sys_config->dot11g_auto_detection = 0;
9606         sys_config->enable_cts_to_self = 0;
9607         sys_config->bt_coexist_collision_thr = 0;
9608         sys_config->pass_noise_stats_to_host = 1;       //1 -- fix for 256
9609         sys_config->silence_threshold = 0x1e;
9610 }
9611
9612 static int ipw_net_open(struct net_device *dev)
9613 {
9614         struct ipw_priv *priv = ieee80211_priv(dev);
9615         IPW_DEBUG_INFO("dev->open\n");
9616         /* we should be verifying the device is ready to be opened */
9617         mutex_lock(&priv->mutex);
9618         if (!(priv->status & STATUS_RF_KILL_MASK) &&
9619             (priv->status & STATUS_ASSOCIATED))
9620                 netif_start_queue(dev);
9621         mutex_unlock(&priv->mutex);
9622         return 0;
9623 }
9624
9625 static int ipw_net_stop(struct net_device *dev)
9626 {
9627         IPW_DEBUG_INFO("dev->close\n");
9628         netif_stop_queue(dev);
9629         return 0;
9630 }
9631
9632 /*
9633 todo:
9634
9635 modify to send one tfd per fragment instead of using chunking.  otherwise
9636 we need to heavily modify the ieee80211_skb_to_txb.
9637 */
9638
9639 static int ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb,
9640                              int pri)
9641 {
9642         struct ieee80211_hdr_3addr *hdr = (struct ieee80211_hdr_3addr *)
9643             txb->fragments[0]->data;
9644         int i = 0;
9645         struct tfd_frame *tfd;
9646 #ifdef CONFIG_IPW_QOS
9647         int tx_id = ipw_get_tx_queue_number(priv, pri);
9648         struct clx2_tx_queue *txq = &priv->txq[tx_id];
9649 #else
9650         struct clx2_tx_queue *txq = &priv->txq[0];
9651 #endif
9652         struct clx2_queue *q = &txq->q;
9653         u8 id, hdr_len, unicast;
9654         u16 remaining_bytes;
9655         int fc;
9656
9657         switch (priv->ieee->iw_mode) {
9658         case IW_MODE_ADHOC:
9659                 hdr_len = IEEE80211_3ADDR_LEN;
9660                 unicast = !is_multicast_ether_addr(hdr->addr1);
9661                 id = ipw_find_station(priv, hdr->addr1);
9662                 if (id == IPW_INVALID_STATION) {
9663                         id = ipw_add_station(priv, hdr->addr1);
9664                         if (id == IPW_INVALID_STATION) {
9665                                 IPW_WARNING("Attempt to send data to "
9666                                             "invalid cell: " MAC_FMT "\n",
9667                                             MAC_ARG(hdr->addr1));
9668                                 goto drop;
9669                         }
9670                 }
9671                 break;
9672
9673         case IW_MODE_INFRA:
9674         default:
9675                 unicast = !is_multicast_ether_addr(hdr->addr3);
9676                 hdr_len = IEEE80211_3ADDR_LEN;
9677                 id = 0;
9678                 break;
9679         }
9680
9681         tfd = &txq->bd[q->first_empty];
9682         txq->txb[q->first_empty] = txb;
9683         memset(tfd, 0, sizeof(*tfd));
9684         tfd->u.data.station_number = id;
9685
9686         tfd->control_flags.message_type = TX_FRAME_TYPE;
9687         tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
9688
9689         tfd->u.data.cmd_id = DINO_CMD_TX;
9690         tfd->u.data.len = cpu_to_le16(txb->payload_size);
9691         remaining_bytes = txb->payload_size;
9692
9693         if (priv->assoc_request.ieee_mode == IPW_B_MODE)
9694                 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
9695         else
9696                 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
9697
9698         if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
9699                 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
9700
9701         fc = le16_to_cpu(hdr->frame_ctl);
9702         hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
9703
9704         memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
9705
9706         if (likely(unicast))
9707                 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9708
9709         if (txb->encrypted && !priv->ieee->host_encrypt) {
9710                 switch (priv->ieee->sec.level) {
9711                 case SEC_LEVEL_3:
9712                         tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9713                             IEEE80211_FCTL_PROTECTED;
9714                         /* XXX: ACK flag must be set for CCMP even if it
9715                          * is a multicast/broadcast packet, because CCMP
9716                          * group communication encrypted by GTK is
9717                          * actually done by the AP. */
9718                         if (!unicast)
9719                                 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
9720
9721                         tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9722                         tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
9723                         tfd->u.data.key_index = 0;
9724                         tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
9725                         break;
9726                 case SEC_LEVEL_2:
9727                         tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9728                             IEEE80211_FCTL_PROTECTED;
9729                         tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
9730                         tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
9731                         tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
9732                         break;
9733                 case SEC_LEVEL_1:
9734                         tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
9735                             IEEE80211_FCTL_PROTECTED;
9736                         tfd->u.data.key_index = priv->ieee->tx_keyidx;
9737                         if (priv->ieee->sec.key_sizes[priv->ieee->tx_keyidx] <=
9738                             40)
9739                                 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
9740                         else
9741                                 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
9742                         break;
9743                 case SEC_LEVEL_0:
9744                         break;
9745                 default:
9746                         printk(KERN_ERR "Unknow security level %d\n",
9747                                priv->ieee->sec.level);
9748                         break;
9749                 }
9750         } else
9751                 /* No hardware encryption */
9752                 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
9753
9754 #ifdef CONFIG_IPW_QOS
9755         ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data), unicast);
9756 #endif                          /* CONFIG_IPW_QOS */
9757
9758         /* payload */
9759         tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
9760                                                  txb->nr_frags));
9761         IPW_DEBUG_FRAG("%i fragments being sent as %i chunks.\n",
9762                        txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
9763         for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
9764                 IPW_DEBUG_FRAG("Adding fragment %i of %i (%d bytes).\n",
9765                                i, le32_to_cpu(tfd->u.data.num_chunks),
9766                                txb->fragments[i]->len - hdr_len);
9767                 IPW_DEBUG_TX("Dumping TX packet frag %i of %i (%d bytes):\n",
9768                              i, tfd->u.data.num_chunks,
9769                              txb->fragments[i]->len - hdr_len);
9770                 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
9771                            txb->fragments[i]->len - hdr_len);
9772
9773                 tfd->u.data.chunk_ptr[i] =
9774                     cpu_to_le32(pci_map_single
9775                                 (priv->pci_dev,
9776                                  txb->fragments[i]->data + hdr_len,
9777                                  txb->fragments[i]->len - hdr_len,
9778                                  PCI_DMA_TODEVICE));
9779                 tfd->u.data.chunk_len[i] =
9780                     cpu_to_le16(txb->fragments[i]->len - hdr_len);
9781         }
9782
9783         if (i != txb->nr_frags) {
9784                 struct sk_buff *skb;
9785                 u16 remaining_bytes = 0;
9786                 int j;
9787
9788                 for (j = i; j < txb->nr_frags; j++)
9789                         remaining_bytes += txb->fragments[j]->len - hdr_len;
9790
9791                 printk(KERN_INFO "Trying to reallocate for %d bytes\n",
9792                        remaining_bytes);
9793                 skb = alloc_skb(remaining_bytes, GFP_ATOMIC);
9794                 if (skb != NULL) {
9795                         tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
9796                         for (j = i; j < txb->nr_frags; j++) {
9797                                 int size = txb->fragments[j]->len - hdr_len;
9798
9799                                 printk(KERN_INFO "Adding frag %d %d...\n",
9800                                        j, size);
9801                                 memcpy(skb_put(skb, size),
9802                                        txb->fragments[j]->data + hdr_len, size);
9803                         }
9804                         dev_kfree_skb_any(txb->fragments[i]);
9805                         txb->fragments[i] = skb;
9806                         tfd->u.data.chunk_ptr[i] =
9807                             cpu_to_le32(pci_map_single
9808                                         (priv->pci_dev, skb->data,
9809                                          tfd->u.data.chunk_len[i],
9810                                          PCI_DMA_TODEVICE));
9811
9812                         tfd->u.data.num_chunks =
9813                             cpu_to_le32(le32_to_cpu(tfd->u.data.num_chunks) +
9814                                         1);
9815                 }
9816         }
9817
9818         /* kick DMA */
9819         q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
9820         ipw_write32(priv, q->reg_w, q->first_empty);
9821
9822         if (ipw_queue_space(q) < q->high_mark)
9823                 netif_stop_queue(priv->net_dev);
9824
9825         return NETDEV_TX_OK;
9826
9827       drop:
9828         IPW_DEBUG_DROP("Silently dropping Tx packet.\n");
9829         ieee80211_txb_free(txb);
9830         return NETDEV_TX_OK;
9831 }
9832
9833 static int ipw_net_is_queue_full(struct net_device *dev, int pri)
9834 {
9835         struct ipw_priv *priv = ieee80211_priv(dev);
9836 #ifdef CONFIG_IPW_QOS
9837         int tx_id = ipw_get_tx_queue_number(priv, pri);
9838         struct clx2_tx_queue *txq = &priv->txq[tx_id];
9839 #else
9840         struct clx2_tx_queue *txq = &priv->txq[0];
9841 #endif                          /* CONFIG_IPW_QOS */
9842
9843         if (ipw_queue_space(&txq->q) < txq->q.high_mark)
9844                 return 1;
9845
9846         return 0;
9847 }
9848
9849 static int ipw_net_hard_start_xmit(struct ieee80211_txb *txb,
9850                                    struct net_device *dev, int pri)
9851 {
9852         struct ipw_priv *priv = ieee80211_priv(dev);
9853         unsigned long flags;
9854         int ret;
9855
9856         IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
9857         spin_lock_irqsave(&priv->lock, flags);
9858
9859         if (!(priv->status & STATUS_ASSOCIATED)) {
9860                 IPW_DEBUG_INFO("Tx attempt while not associated.\n");
9861                 priv->ieee->stats.tx_carrier_errors++;
9862                 netif_stop_queue(dev);
9863                 goto fail_unlock;
9864         }
9865
9866         ret = ipw_tx_skb(priv, txb, pri);
9867         if (ret == NETDEV_TX_OK)
9868                 __ipw_led_activity_on(priv);
9869         spin_unlock_irqrestore(&priv->lock, flags);
9870
9871         return ret;
9872
9873       fail_unlock:
9874         spin_unlock_irqrestore(&priv->lock, flags);
9875         return 1;
9876 }
9877
9878 static struct net_device_stats *ipw_net_get_stats(struct net_device *dev)
9879 {
9880         struct ipw_priv *priv = ieee80211_priv(dev);
9881
9882         priv->ieee->stats.tx_packets = priv->tx_packets;
9883         priv->ieee->stats.rx_packets = priv->rx_packets;
9884         return &priv->ieee->stats;
9885 }
9886
9887 static void ipw_net_set_multicast_list(struct net_device *dev)
9888 {
9889
9890 }
9891
9892 static int ipw_net_set_mac_address(struct net_device *dev, void *p)
9893 {
9894         struct ipw_priv *priv = ieee80211_priv(dev);
9895         struct sockaddr *addr = p;
9896         if (!is_valid_ether_addr(addr->sa_data))
9897                 return -EADDRNOTAVAIL;
9898         mutex_lock(&priv->mutex);
9899         priv->config |= CFG_CUSTOM_MAC;
9900         memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
9901         printk(KERN_INFO "%s: Setting MAC to " MAC_FMT "\n",
9902                priv->net_dev->name, MAC_ARG(priv->mac_addr));
9903         queue_work(priv->workqueue, &priv->adapter_restart);
9904         mutex_unlock(&priv->mutex);
9905         return 0;
9906 }
9907
9908 static void ipw_ethtool_get_drvinfo(struct net_device *dev,
9909                                     struct ethtool_drvinfo *info)
9910 {
9911         struct ipw_priv *p = ieee80211_priv(dev);
9912         char vers[64];
9913         char date[32];
9914         u32 len;
9915
9916         strcpy(info->driver, DRV_NAME);
9917         strcpy(info->version, DRV_VERSION);
9918
9919         len = sizeof(vers);
9920         ipw_get_ordinal(p, IPW_ORD_STAT_FW_VERSION, vers, &len);
9921         len = sizeof(date);
9922         ipw_get_ordinal(p, IPW_ORD_STAT_FW_DATE, date, &len);
9923
9924         snprintf(info->fw_version, sizeof(info->fw_version), "%s (%s)",
9925                  vers, date);
9926         strcpy(info->bus_info, pci_name(p->pci_dev));
9927         info->eedump_len = IPW_EEPROM_IMAGE_SIZE;
9928 }
9929
9930 static u32 ipw_ethtool_get_link(struct net_device *dev)
9931 {
9932         struct ipw_priv *priv = ieee80211_priv(dev);
9933         return (priv->status & STATUS_ASSOCIATED) != 0;
9934 }
9935
9936 static int ipw_ethtool_get_eeprom_len(struct net_device *dev)
9937 {
9938         return IPW_EEPROM_IMAGE_SIZE;
9939 }
9940
9941 static int ipw_ethtool_get_eeprom(struct net_device *dev,
9942                                   struct ethtool_eeprom *eeprom, u8 * bytes)
9943 {
9944         struct ipw_priv *p = ieee80211_priv(dev);
9945
9946         if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
9947                 return -EINVAL;
9948         mutex_lock(&p->mutex);
9949         memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
9950         mutex_unlock(&p->mutex);
9951         return 0;
9952 }
9953
9954 static int ipw_ethtool_set_eeprom(struct net_device *dev,
9955                                   struct ethtool_eeprom *eeprom, u8 * bytes)
9956 {
9957         struct ipw_priv *p = ieee80211_priv(dev);
9958         int i;
9959
9960         if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
9961                 return -EINVAL;
9962         mutex_lock(&p->mutex);
9963         memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
9964         for (i = IPW_EEPROM_DATA;
9965              i < IPW_EEPROM_DATA + IPW_EEPROM_IMAGE_SIZE; i++)
9966                 ipw_write8(p, i, p->eeprom[i]);
9967         mutex_unlock(&p->mutex);
9968         return 0;
9969 }
9970
9971 static struct ethtool_ops ipw_ethtool_ops = {
9972         .get_link = ipw_ethtool_get_link,
9973         .get_drvinfo = ipw_ethtool_get_drvinfo,
9974         .get_eeprom_len = ipw_ethtool_get_eeprom_len,
9975         .get_eeprom = ipw_ethtool_get_eeprom,
9976         .set_eeprom = ipw_ethtool_set_eeprom,
9977 };
9978
9979 static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
9980 {
9981         struct ipw_priv *priv = data;
9982         u32 inta, inta_mask;
9983
9984         if (!priv)
9985                 return IRQ_NONE;
9986
9987         spin_lock(&priv->lock);
9988
9989         if (!(priv->status & STATUS_INT_ENABLED)) {
9990                 /* Shared IRQ */
9991                 goto none;
9992         }
9993
9994         inta = ipw_read32(priv, IPW_INTA_RW);
9995         inta_mask = ipw_read32(priv, IPW_INTA_MASK_R);
9996
9997         if (inta == 0xFFFFFFFF) {
9998                 /* Hardware disappeared */
9999                 IPW_WARNING("IRQ INTA == 0xFFFFFFFF\n");
10000                 goto none;
10001         }
10002
10003         if (!(inta & (IPW_INTA_MASK_ALL & inta_mask))) {
10004                 /* Shared interrupt */
10005                 goto none;
10006         }
10007
10008         /* tell the device to stop sending interrupts */
10009         ipw_disable_interrupts(priv);
10010
10011         /* ack current interrupts */
10012         inta &= (IPW_INTA_MASK_ALL & inta_mask);
10013         ipw_write32(priv, IPW_INTA_RW, inta);
10014
10015         /* Cache INTA value for our tasklet */
10016         priv->isr_inta = inta;
10017
10018         tasklet_schedule(&priv->irq_tasklet);
10019
10020         spin_unlock(&priv->lock);
10021
10022         return IRQ_HANDLED;
10023       none:
10024         spin_unlock(&priv->lock);
10025         return IRQ_NONE;
10026 }
10027
10028 static void ipw_rf_kill(void *adapter)
10029 {
10030         struct ipw_priv *priv = adapter;
10031         unsigned long flags;
10032
10033         spin_lock_irqsave(&priv->lock, flags);
10034
10035         if (rf_kill_active(priv)) {
10036                 IPW_DEBUG_RF_KILL("RF Kill active, rescheduling GPIO check\n");
10037                 if (priv->workqueue)
10038                         queue_delayed_work(priv->workqueue,
10039                                            &priv->rf_kill, 2 * HZ);
10040                 goto exit_unlock;
10041         }
10042
10043         /* RF Kill is now disabled, so bring the device back up */
10044
10045         if (!(priv->status & STATUS_RF_KILL_MASK)) {
10046                 IPW_DEBUG_RF_KILL("HW RF Kill no longer active, restarting "
10047                                   "device\n");
10048
10049                 /* we can not do an adapter restart while inside an irq lock */
10050                 queue_work(priv->workqueue, &priv->adapter_restart);
10051         } else
10052                 IPW_DEBUG_RF_KILL("HW RF Kill deactivated.  SW RF Kill still "
10053                                   "enabled\n");
10054
10055       exit_unlock:
10056         spin_unlock_irqrestore(&priv->lock, flags);
10057 }
10058
10059 static void ipw_bg_rf_kill(void *data)
10060 {
10061         struct ipw_priv *priv = data;
10062         mutex_lock(&priv->mutex);
10063         ipw_rf_kill(data);
10064         mutex_unlock(&priv->mutex);
10065 }
10066
10067 static void ipw_link_up(struct ipw_priv *priv)
10068 {
10069         priv->last_seq_num = -1;
10070         priv->last_frag_num = -1;
10071         priv->last_packet_time = 0;
10072
10073         netif_carrier_on(priv->net_dev);
10074         if (netif_queue_stopped(priv->net_dev)) {
10075                 IPW_DEBUG_NOTIF("waking queue\n");
10076                 netif_wake_queue(priv->net_dev);
10077         } else {
10078                 IPW_DEBUG_NOTIF("starting queue\n");
10079                 netif_start_queue(priv->net_dev);
10080         }
10081
10082         cancel_delayed_work(&priv->request_scan);
10083         ipw_reset_stats(priv);
10084         /* Ensure the rate is updated immediately */
10085         priv->last_rate = ipw_get_current_rate(priv);
10086         ipw_gather_stats(priv);
10087         ipw_led_link_up(priv);
10088         notify_wx_assoc_event(priv);
10089
10090         if (priv->config & CFG_BACKGROUND_SCAN)
10091                 queue_delayed_work(priv->workqueue, &priv->request_scan, HZ);
10092 }
10093
10094 static void ipw_bg_link_up(void *data)
10095 {
10096         struct ipw_priv *priv = data;
10097         mutex_lock(&priv->mutex);
10098         ipw_link_up(data);
10099         mutex_unlock(&priv->mutex);
10100 }
10101
10102 static void ipw_link_down(struct ipw_priv *priv)
10103 {
10104         ipw_led_link_down(priv);
10105         netif_carrier_off(priv->net_dev);
10106         netif_stop_queue(priv->net_dev);
10107         notify_wx_assoc_event(priv);
10108
10109         /* Cancel any queued work ... */
10110         cancel_delayed_work(&priv->request_scan);
10111         cancel_delayed_work(&priv->adhoc_check);
10112         cancel_delayed_work(&priv->gather_stats);
10113
10114         ipw_reset_stats(priv);
10115
10116         if (!(priv->status & STATUS_EXIT_PENDING)) {
10117                 /* Queue up another scan... */
10118                 queue_work(priv->workqueue, &priv->request_scan);
10119         }
10120 }
10121
10122 static void ipw_bg_link_down(void *data)
10123 {
10124         struct ipw_priv *priv = data;
10125         mutex_lock(&priv->mutex);
10126         ipw_link_down(data);
10127         mutex_unlock(&priv->mutex);
10128 }
10129
10130 static int ipw_setup_deferred_work(struct ipw_priv *priv)
10131 {
10132         int ret = 0;
10133
10134         priv->workqueue = create_workqueue(DRV_NAME);
10135         init_waitqueue_head(&priv->wait_command_queue);
10136         init_waitqueue_head(&priv->wait_state);
10137
10138         INIT_WORK(&priv->adhoc_check, ipw_bg_adhoc_check, priv);
10139         INIT_WORK(&priv->associate, ipw_bg_associate, priv);
10140         INIT_WORK(&priv->disassociate, ipw_bg_disassociate, priv);
10141         INIT_WORK(&priv->system_config, ipw_system_config, priv);
10142         INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish, priv);
10143         INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart, priv);
10144         INIT_WORK(&priv->rf_kill, ipw_bg_rf_kill, priv);
10145         INIT_WORK(&priv->up, (void (*)(void *))ipw_bg_up, priv);
10146         INIT_WORK(&priv->down, (void (*)(void *))ipw_bg_down, priv);
10147         INIT_WORK(&priv->request_scan,
10148                   (void (*)(void *))ipw_request_scan, priv);
10149         INIT_WORK(&priv->gather_stats,
10150                   (void (*)(void *))ipw_bg_gather_stats, priv);
10151         INIT_WORK(&priv->abort_scan, (void (*)(void *))ipw_bg_abort_scan, priv);
10152         INIT_WORK(&priv->roam, ipw_bg_roam, priv);
10153         INIT_WORK(&priv->scan_check, ipw_bg_scan_check, priv);
10154         INIT_WORK(&priv->link_up, (void (*)(void *))ipw_bg_link_up, priv);
10155         INIT_WORK(&priv->link_down, (void (*)(void *))ipw_bg_link_down, priv);
10156         INIT_WORK(&priv->led_link_on, (void (*)(void *))ipw_bg_led_link_on,
10157                   priv);
10158         INIT_WORK(&priv->led_link_off, (void (*)(void *))ipw_bg_led_link_off,
10159                   priv);
10160         INIT_WORK(&priv->led_act_off, (void (*)(void *))ipw_bg_led_activity_off,
10161                   priv);
10162         INIT_WORK(&priv->merge_networks,
10163                   (void (*)(void *))ipw_merge_adhoc_network, priv);
10164
10165 #ifdef CONFIG_IPW_QOS
10166         INIT_WORK(&priv->qos_activate, (void (*)(void *))ipw_bg_qos_activate,
10167                   priv);
10168 #endif                          /* CONFIG_IPW_QOS */
10169
10170         tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
10171                      ipw_irq_tasklet, (unsigned long)priv);
10172
10173         return ret;
10174 }
10175
10176 static void shim__set_security(struct net_device *dev,
10177                                struct ieee80211_security *sec)
10178 {
10179         struct ipw_priv *priv = ieee80211_priv(dev);
10180         int i;
10181         for (i = 0; i < 4; i++) {
10182                 if (sec->flags & (1 << i)) {
10183                         priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
10184                         priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
10185                         if (sec->key_sizes[i] == 0)
10186                                 priv->ieee->sec.flags &= ~(1 << i);
10187                         else {
10188                                 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
10189                                        sec->key_sizes[i]);
10190                                 priv->ieee->sec.flags |= (1 << i);
10191                         }
10192                         priv->status |= STATUS_SECURITY_UPDATED;
10193                 } else if (sec->level != SEC_LEVEL_1)
10194                         priv->ieee->sec.flags &= ~(1 << i);
10195         }
10196
10197         if (sec->flags & SEC_ACTIVE_KEY) {
10198                 if (sec->active_key <= 3) {
10199                         priv->ieee->sec.active_key = sec->active_key;
10200                         priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
10201                 } else
10202                         priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10203                 priv->status |= STATUS_SECURITY_UPDATED;
10204         } else
10205                 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10206
10207         if ((sec->flags & SEC_AUTH_MODE) &&
10208             (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10209                 priv->ieee->sec.auth_mode = sec->auth_mode;
10210                 priv->ieee->sec.flags |= SEC_AUTH_MODE;
10211                 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10212                         priv->capability |= CAP_SHARED_KEY;
10213                 else
10214                         priv->capability &= ~CAP_SHARED_KEY;
10215                 priv->status |= STATUS_SECURITY_UPDATED;
10216         }
10217
10218         if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10219                 priv->ieee->sec.flags |= SEC_ENABLED;
10220                 priv->ieee->sec.enabled = sec->enabled;
10221                 priv->status |= STATUS_SECURITY_UPDATED;
10222                 if (sec->enabled)
10223                         priv->capability |= CAP_PRIVACY_ON;
10224                 else
10225                         priv->capability &= ~CAP_PRIVACY_ON;
10226         }
10227
10228         if (sec->flags & SEC_ENCRYPT)
10229                 priv->ieee->sec.encrypt = sec->encrypt;
10230
10231         if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10232                 priv->ieee->sec.level = sec->level;
10233                 priv->ieee->sec.flags |= SEC_LEVEL;
10234                 priv->status |= STATUS_SECURITY_UPDATED;
10235         }
10236
10237         if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10238                 ipw_set_hwcrypto_keys(priv);
10239
10240         /* To match current functionality of ipw2100 (which works well w/
10241          * various supplicants, we don't force a disassociate if the
10242          * privacy capability changes ... */
10243 #if 0
10244         if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
10245             (((priv->assoc_request.capability &
10246                WLAN_CAPABILITY_PRIVACY) && !sec->enabled) ||
10247              (!(priv->assoc_request.capability &
10248                 WLAN_CAPABILITY_PRIVACY) && sec->enabled))) {
10249                 IPW_DEBUG_ASSOC("Disassociating due to capability "
10250                                 "change.\n");
10251                 ipw_disassociate(priv);
10252         }
10253 #endif
10254 }
10255
10256 static int init_supported_rates(struct ipw_priv *priv,
10257                                 struct ipw_supported_rates *rates)
10258 {
10259         /* TODO: Mask out rates based on priv->rates_mask */
10260
10261         memset(rates, 0, sizeof(*rates));
10262         /* configure supported rates */
10263         switch (priv->ieee->freq_band) {
10264         case IEEE80211_52GHZ_BAND:
10265                 rates->ieee_mode = IPW_A_MODE;
10266                 rates->purpose = IPW_RATE_CAPABILITIES;
10267                 ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10268                                         IEEE80211_OFDM_DEFAULT_RATES_MASK);
10269                 break;
10270
10271         default:                /* Mixed or 2.4Ghz */
10272                 rates->ieee_mode = IPW_G_MODE;
10273                 rates->purpose = IPW_RATE_CAPABILITIES;
10274                 ipw_add_cck_scan_rates(rates, IEEE80211_CCK_MODULATION,
10275                                        IEEE80211_CCK_DEFAULT_RATES_MASK);
10276                 if (priv->ieee->modulation & IEEE80211_OFDM_MODULATION) {
10277                         ipw_add_ofdm_scan_rates(rates, IEEE80211_CCK_MODULATION,
10278                                                 IEEE80211_OFDM_DEFAULT_RATES_MASK);
10279                 }
10280                 break;
10281         }
10282
10283         return 0;
10284 }
10285
10286 static int ipw_config(struct ipw_priv *priv)
10287 {
10288         /* This is only called from ipw_up, which resets/reloads the firmware
10289            so, we don't need to first disable the card before we configure
10290            it */
10291         if (ipw_set_tx_power(priv))
10292                 goto error;
10293
10294         /* initialize adapter address */
10295         if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10296                 goto error;
10297
10298         /* set basic system config settings */
10299         init_sys_config(&priv->sys_config);
10300
10301         /* Support Bluetooth if we have BT h/w on board, and user wants to.
10302          * Does not support BT priority yet (don't abort or defer our Tx) */
10303         if (bt_coexist) {
10304                 unsigned char bt_caps = priv->eeprom[EEPROM_SKU_CAPABILITY];
10305
10306                 if (bt_caps & EEPROM_SKU_CAP_BT_CHANNEL_SIG)
10307                         priv->sys_config.bt_coexistence
10308                             |= CFG_BT_COEXISTENCE_SIGNAL_CHNL;
10309                 if (bt_caps & EEPROM_SKU_CAP_BT_OOB)
10310                         priv->sys_config.bt_coexistence
10311                             |= CFG_BT_COEXISTENCE_OOB;
10312         }
10313
10314         if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10315                 priv->sys_config.answer_broadcast_ssid_probe = 1;
10316         else
10317                 priv->sys_config.answer_broadcast_ssid_probe = 0;
10318
10319         if (ipw_send_system_config(priv, &priv->sys_config))
10320                 goto error;
10321
10322         init_supported_rates(priv, &priv->rates);
10323         if (ipw_send_supported_rates(priv, &priv->rates))
10324                 goto error;
10325
10326         /* Set request-to-send threshold */
10327         if (priv->rts_threshold) {
10328                 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10329                         goto error;
10330         }
10331 #ifdef CONFIG_IPW_QOS
10332         IPW_DEBUG_QOS("QoS: call ipw_qos_activate\n");
10333         ipw_qos_activate(priv, NULL);
10334 #endif                          /* CONFIG_IPW_QOS */
10335
10336         if (ipw_set_random_seed(priv))
10337                 goto error;
10338
10339         /* final state transition to the RUN state */
10340         if (ipw_send_host_complete(priv))
10341                 goto error;
10342
10343         priv->status |= STATUS_INIT;
10344
10345         ipw_led_init(priv);
10346         ipw_led_radio_on(priv);
10347         priv->notif_missed_beacons = 0;
10348
10349         /* Set hardware WEP key if it is configured. */
10350         if ((priv->capability & CAP_PRIVACY_ON) &&
10351             (priv->ieee->sec.level == SEC_LEVEL_1) &&
10352             !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10353                 ipw_set_hwcrypto_keys(priv);
10354
10355         return 0;
10356
10357       error:
10358         return -EIO;
10359 }
10360
10361 /*
10362  * NOTE:
10363  *
10364  * These tables have been tested in conjunction with the
10365  * Intel PRO/Wireless 2200BG and 2915ABG Network Connection Adapters.
10366  *
10367  * Altering this values, using it on other hardware, or in geographies
10368  * not intended for resale of the above mentioned Intel adapters has
10369  * not been tested.
10370  *
10371  * Remember to update the table in README.ipw2200 when changing this
10372  * table.
10373  *
10374  */
10375 static const struct ieee80211_geo ipw_geos[] = {
10376         {                       /* Restricted */
10377          "---",
10378          .bg_channels = 11,
10379          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10380                 {2427, 4}, {2432, 5}, {2437, 6},
10381                 {2442, 7}, {2447, 8}, {2452, 9},
10382                 {2457, 10}, {2462, 11}},
10383          },
10384
10385         {                       /* Custom US/Canada */
10386          "ZZF",
10387          .bg_channels = 11,
10388          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10389                 {2427, 4}, {2432, 5}, {2437, 6},
10390                 {2442, 7}, {2447, 8}, {2452, 9},
10391                 {2457, 10}, {2462, 11}},
10392          .a_channels = 8,
10393          .a = {{5180, 36},
10394                {5200, 40},
10395                {5220, 44},
10396                {5240, 48},
10397                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10398                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10399                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10400                {5320, 64, IEEE80211_CH_PASSIVE_ONLY}},
10401          },
10402
10403         {                       /* Rest of World */
10404          "ZZD",
10405          .bg_channels = 13,
10406          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10407                 {2427, 4}, {2432, 5}, {2437, 6},
10408                 {2442, 7}, {2447, 8}, {2452, 9},
10409                 {2457, 10}, {2462, 11}, {2467, 12},
10410                 {2472, 13}},
10411          },
10412
10413         {                       /* Custom USA & Europe & High */
10414          "ZZA",
10415          .bg_channels = 11,
10416          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10417                 {2427, 4}, {2432, 5}, {2437, 6},
10418                 {2442, 7}, {2447, 8}, {2452, 9},
10419                 {2457, 10}, {2462, 11}},
10420          .a_channels = 13,
10421          .a = {{5180, 36},
10422                {5200, 40},
10423                {5220, 44},
10424                {5240, 48},
10425                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10426                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10427                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10428                {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10429                {5745, 149},
10430                {5765, 153},
10431                {5785, 157},
10432                {5805, 161},
10433                {5825, 165}},
10434          },
10435
10436         {                       /* Custom NA & Europe */
10437          "ZZB",
10438          .bg_channels = 11,
10439          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10440                 {2427, 4}, {2432, 5}, {2437, 6},
10441                 {2442, 7}, {2447, 8}, {2452, 9},
10442                 {2457, 10}, {2462, 11}},
10443          .a_channels = 13,
10444          .a = {{5180, 36},
10445                {5200, 40},
10446                {5220, 44},
10447                {5240, 48},
10448                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10449                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10450                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10451                {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10452                {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10453                {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10454                {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10455                {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10456                {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10457          },
10458
10459         {                       /* Custom Japan */
10460          "ZZC",
10461          .bg_channels = 11,
10462          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10463                 {2427, 4}, {2432, 5}, {2437, 6},
10464                 {2442, 7}, {2447, 8}, {2452, 9},
10465                 {2457, 10}, {2462, 11}},
10466          .a_channels = 4,
10467          .a = {{5170, 34}, {5190, 38},
10468                {5210, 42}, {5230, 46}},
10469          },
10470
10471         {                       /* Custom */
10472          "ZZM",
10473          .bg_channels = 11,
10474          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10475                 {2427, 4}, {2432, 5}, {2437, 6},
10476                 {2442, 7}, {2447, 8}, {2452, 9},
10477                 {2457, 10}, {2462, 11}},
10478          },
10479
10480         {                       /* Europe */
10481          "ZZE",
10482          .bg_channels = 13,
10483          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10484                 {2427, 4}, {2432, 5}, {2437, 6},
10485                 {2442, 7}, {2447, 8}, {2452, 9},
10486                 {2457, 10}, {2462, 11}, {2467, 12},
10487                 {2472, 13}},
10488          .a_channels = 19,
10489          .a = {{5180, 36},
10490                {5200, 40},
10491                {5220, 44},
10492                {5240, 48},
10493                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10494                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10495                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10496                {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10497                {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10498                {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10499                {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10500                {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10501                {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10502                {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10503                {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10504                {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10505                {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10506                {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10507                {5700, 140, IEEE80211_CH_PASSIVE_ONLY}},
10508          },
10509
10510         {                       /* Custom Japan */
10511          "ZZJ",
10512          .bg_channels = 14,
10513          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10514                 {2427, 4}, {2432, 5}, {2437, 6},
10515                 {2442, 7}, {2447, 8}, {2452, 9},
10516                 {2457, 10}, {2462, 11}, {2467, 12},
10517                 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY}},
10518          .a_channels = 4,
10519          .a = {{5170, 34}, {5190, 38},
10520                {5210, 42}, {5230, 46}},
10521          },
10522
10523         {                       /* Rest of World */
10524          "ZZR",
10525          .bg_channels = 14,
10526          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10527                 {2427, 4}, {2432, 5}, {2437, 6},
10528                 {2442, 7}, {2447, 8}, {2452, 9},
10529                 {2457, 10}, {2462, 11}, {2467, 12},
10530                 {2472, 13}, {2484, 14, IEEE80211_CH_B_ONLY |
10531                              IEEE80211_CH_PASSIVE_ONLY}},
10532          },
10533
10534         {                       /* High Band */
10535          "ZZH",
10536          .bg_channels = 13,
10537          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10538                 {2427, 4}, {2432, 5}, {2437, 6},
10539                 {2442, 7}, {2447, 8}, {2452, 9},
10540                 {2457, 10}, {2462, 11},
10541                 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10542                 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10543          .a_channels = 4,
10544          .a = {{5745, 149}, {5765, 153},
10545                {5785, 157}, {5805, 161}},
10546          },
10547
10548         {                       /* Custom Europe */
10549          "ZZG",
10550          .bg_channels = 13,
10551          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10552                 {2427, 4}, {2432, 5}, {2437, 6},
10553                 {2442, 7}, {2447, 8}, {2452, 9},
10554                 {2457, 10}, {2462, 11},
10555                 {2467, 12}, {2472, 13}},
10556          .a_channels = 4,
10557          .a = {{5180, 36}, {5200, 40},
10558                {5220, 44}, {5240, 48}},
10559          },
10560
10561         {                       /* Europe */
10562          "ZZK",
10563          .bg_channels = 13,
10564          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10565                 {2427, 4}, {2432, 5}, {2437, 6},
10566                 {2442, 7}, {2447, 8}, {2452, 9},
10567                 {2457, 10}, {2462, 11},
10568                 {2467, 12, IEEE80211_CH_PASSIVE_ONLY},
10569                 {2472, 13, IEEE80211_CH_PASSIVE_ONLY}},
10570          .a_channels = 24,
10571          .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10572                {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10573                {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10574                {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10575                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10576                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10577                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10578                {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10579                {5500, 100, IEEE80211_CH_PASSIVE_ONLY},
10580                {5520, 104, IEEE80211_CH_PASSIVE_ONLY},
10581                {5540, 108, IEEE80211_CH_PASSIVE_ONLY},
10582                {5560, 112, IEEE80211_CH_PASSIVE_ONLY},
10583                {5580, 116, IEEE80211_CH_PASSIVE_ONLY},
10584                {5600, 120, IEEE80211_CH_PASSIVE_ONLY},
10585                {5620, 124, IEEE80211_CH_PASSIVE_ONLY},
10586                {5640, 128, IEEE80211_CH_PASSIVE_ONLY},
10587                {5660, 132, IEEE80211_CH_PASSIVE_ONLY},
10588                {5680, 136, IEEE80211_CH_PASSIVE_ONLY},
10589                {5700, 140, IEEE80211_CH_PASSIVE_ONLY},
10590                {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10591                {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10592                {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10593                {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10594                {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10595          },
10596
10597         {                       /* Europe */
10598          "ZZL",
10599          .bg_channels = 11,
10600          .bg = {{2412, 1}, {2417, 2}, {2422, 3},
10601                 {2427, 4}, {2432, 5}, {2437, 6},
10602                 {2442, 7}, {2447, 8}, {2452, 9},
10603                 {2457, 10}, {2462, 11}},
10604          .a_channels = 13,
10605          .a = {{5180, 36, IEEE80211_CH_PASSIVE_ONLY},
10606                {5200, 40, IEEE80211_CH_PASSIVE_ONLY},
10607                {5220, 44, IEEE80211_CH_PASSIVE_ONLY},
10608                {5240, 48, IEEE80211_CH_PASSIVE_ONLY},
10609                {5260, 52, IEEE80211_CH_PASSIVE_ONLY},
10610                {5280, 56, IEEE80211_CH_PASSIVE_ONLY},
10611                {5300, 60, IEEE80211_CH_PASSIVE_ONLY},
10612                {5320, 64, IEEE80211_CH_PASSIVE_ONLY},
10613                {5745, 149, IEEE80211_CH_PASSIVE_ONLY},
10614                {5765, 153, IEEE80211_CH_PASSIVE_ONLY},
10615                {5785, 157, IEEE80211_CH_PASSIVE_ONLY},
10616                {5805, 161, IEEE80211_CH_PASSIVE_ONLY},
10617                {5825, 165, IEEE80211_CH_PASSIVE_ONLY}},
10618          }
10619 };
10620
10621 #define MAX_HW_RESTARTS 5
10622 static int ipw_up(struct ipw_priv *priv)
10623 {
10624         int rc, i, j;
10625
10626         if (priv->status & STATUS_EXIT_PENDING)
10627                 return -EIO;
10628
10629         if (cmdlog && !priv->cmdlog) {
10630                 priv->cmdlog = kmalloc(sizeof(*priv->cmdlog) * cmdlog,
10631                                        GFP_KERNEL);
10632                 if (priv->cmdlog == NULL) {
10633                         IPW_ERROR("Error allocating %d command log entries.\n",
10634                                   cmdlog);
10635                 } else {
10636                         memset(priv->cmdlog, 0, sizeof(*priv->cmdlog) * cmdlog);
10637                         priv->cmdlog_len = cmdlog;
10638                 }
10639         }
10640
10641         for (i = 0; i < MAX_HW_RESTARTS; i++) {
10642                 /* Load the microcode, firmware, and eeprom.
10643                  * Also start the clocks. */
10644                 rc = ipw_load(priv);
10645                 if (rc) {
10646                         IPW_ERROR("Unable to load firmware: %d\n", rc);
10647                         return rc;
10648                 }
10649
10650                 ipw_init_ordinals(priv);
10651                 if (!(priv->config & CFG_CUSTOM_MAC))
10652                         eeprom_parse_mac(priv, priv->mac_addr);
10653                 memcpy(priv->net_dev->dev_addr, priv->mac_addr, ETH_ALEN);
10654
10655                 for (j = 0; j < ARRAY_SIZE(ipw_geos); j++) {
10656                         if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
10657                                     ipw_geos[j].name, 3))
10658                                 break;
10659                 }
10660                 if (j == ARRAY_SIZE(ipw_geos)) {
10661                         IPW_WARNING("SKU [%c%c%c] not recognized.\n",
10662                                     priv->eeprom[EEPROM_COUNTRY_CODE + 0],
10663                                     priv->eeprom[EEPROM_COUNTRY_CODE + 1],
10664                                     priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
10665                         j = 0;
10666                 }
10667                 if (ieee80211_set_geo(priv->ieee, &ipw_geos[j])) {
10668                         IPW_WARNING("Could not set geography.");
10669                         return 0;
10670                 }
10671
10672                 if (priv->status & STATUS_RF_KILL_SW) {
10673                         IPW_WARNING("Radio disabled by module parameter.\n");
10674                         return 0;
10675                 } else if (rf_kill_active(priv)) {
10676                         IPW_WARNING("Radio Frequency Kill Switch is On:\n"
10677                                     "Kill switch must be turned off for "
10678                                     "wireless networking to work.\n");
10679                         queue_delayed_work(priv->workqueue, &priv->rf_kill,
10680                                            2 * HZ);
10681                         return 0;
10682                 }
10683
10684                 rc = ipw_config(priv);
10685                 if (!rc) {
10686                         IPW_DEBUG_INFO("Configured device on count %i\n", i);
10687
10688                         /* If configure to try and auto-associate, kick
10689                          * off a scan. */
10690                         queue_work(priv->workqueue, &priv->request_scan);
10691
10692                         return 0;
10693                 }
10694
10695                 IPW_DEBUG_INFO("Device configuration failed: 0x%08X\n", rc);
10696                 IPW_DEBUG_INFO("Failed to config device on retry %d of %d\n",
10697                                i, MAX_HW_RESTARTS);
10698
10699                 /* We had an error bringing up the hardware, so take it
10700                  * all the way back down so we can try again */
10701                 ipw_down(priv);
10702         }
10703
10704         /* tried to restart and config the device for as long as our
10705          * patience could withstand */
10706         IPW_ERROR("Unable to initialize device after %d attempts.\n", i);
10707
10708         return -EIO;
10709 }
10710
10711 static void ipw_bg_up(void *data)
10712 {
10713         struct ipw_priv *priv = data;
10714         mutex_lock(&priv->mutex);
10715         ipw_up(data);
10716         mutex_unlock(&priv->mutex);
10717 }
10718
10719 static void ipw_deinit(struct ipw_priv *priv)
10720 {
10721         int i;
10722
10723         if (priv->status & STATUS_SCANNING) {
10724                 IPW_DEBUG_INFO("Aborting scan during shutdown.\n");
10725                 ipw_abort_scan(priv);
10726         }
10727
10728         if (priv->status & STATUS_ASSOCIATED) {
10729                 IPW_DEBUG_INFO("Disassociating during shutdown.\n");
10730                 ipw_disassociate(priv);
10731         }
10732
10733         ipw_led_shutdown(priv);
10734
10735         /* Wait up to 1s for status to change to not scanning and not
10736          * associated (disassociation can take a while for a ful 802.11
10737          * exchange */
10738         for (i = 1000; i && (priv->status &
10739                              (STATUS_DISASSOCIATING |
10740                               STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
10741                 udelay(10);
10742
10743         if (priv->status & (STATUS_DISASSOCIATING |
10744                             STATUS_ASSOCIATED | STATUS_SCANNING))
10745                 IPW_DEBUG_INFO("Still associated or scanning...\n");
10746         else
10747                 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
10748
10749         /* Attempt to disable the card */
10750         ipw_send_card_disable(priv, 0);
10751
10752         priv->status &= ~STATUS_INIT;
10753 }
10754
10755 static void ipw_down(struct ipw_priv *priv)
10756 {
10757         int exit_pending = priv->status & STATUS_EXIT_PENDING;
10758
10759         priv->status |= STATUS_EXIT_PENDING;
10760
10761         if (ipw_is_init(priv))
10762                 ipw_deinit(priv);
10763
10764         /* Wipe out the EXIT_PENDING status bit if we are not actually
10765          * exiting the module */
10766         if (!exit_pending)
10767                 priv->status &= ~STATUS_EXIT_PENDING;
10768
10769         /* tell the device to stop sending interrupts */
10770         ipw_disable_interrupts(priv);
10771
10772         /* Clear all bits but the RF Kill */
10773         priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
10774         netif_carrier_off(priv->net_dev);
10775         netif_stop_queue(priv->net_dev);
10776
10777         ipw_stop_nic(priv);
10778
10779         ipw_led_radio_off(priv);
10780 }
10781
10782 static void ipw_bg_down(void *data)
10783 {
10784         struct ipw_priv *priv = data;
10785         mutex_lock(&priv->mutex);
10786         ipw_down(data);
10787         mutex_unlock(&priv->mutex);
10788 }
10789
10790 /* Called by register_netdev() */
10791 static int ipw_net_init(struct net_device *dev)
10792 {
10793         struct ipw_priv *priv = ieee80211_priv(dev);
10794         mutex_lock(&priv->mutex);
10795
10796         if (ipw_up(priv)) {
10797                 mutex_unlock(&priv->mutex);
10798                 return -EIO;
10799         }
10800
10801         mutex_unlock(&priv->mutex);
10802         return 0;
10803 }
10804
10805 /* PCI driver stuff */
10806 static struct pci_device_id card_ids[] = {
10807         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2701, 0, 0, 0},
10808         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2702, 0, 0, 0},
10809         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2711, 0, 0, 0},
10810         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2712, 0, 0, 0},
10811         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2721, 0, 0, 0},
10812         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2722, 0, 0, 0},
10813         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2731, 0, 0, 0},
10814         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2732, 0, 0, 0},
10815         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2741, 0, 0, 0},
10816         {PCI_VENDOR_ID_INTEL, 0x1043, 0x103c, 0x2741, 0, 0, 0},
10817         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2742, 0, 0, 0},
10818         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2751, 0, 0, 0},
10819         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2752, 0, 0, 0},
10820         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2753, 0, 0, 0},
10821         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2754, 0, 0, 0},
10822         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2761, 0, 0, 0},
10823         {PCI_VENDOR_ID_INTEL, 0x1043, 0x8086, 0x2762, 0, 0, 0},
10824         {PCI_VENDOR_ID_INTEL, 0x104f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
10825         {PCI_VENDOR_ID_INTEL, 0x4220, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10826         {PCI_VENDOR_ID_INTEL, 0x4221, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* BG */
10827         {PCI_VENDOR_ID_INTEL, 0x4223, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10828         {PCI_VENDOR_ID_INTEL, 0x4224, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, /* ABG */
10829
10830         /* required last entry */
10831         {0,}
10832 };
10833
10834 MODULE_DEVICE_TABLE(pci, card_ids);
10835
10836 static struct attribute *ipw_sysfs_entries[] = {
10837         &dev_attr_rf_kill.attr,
10838         &dev_attr_direct_dword.attr,
10839         &dev_attr_indirect_byte.attr,
10840         &dev_attr_indirect_dword.attr,
10841         &dev_attr_mem_gpio_reg.attr,
10842         &dev_attr_command_event_reg.attr,
10843         &dev_attr_nic_type.attr,
10844         &dev_attr_status.attr,
10845         &dev_attr_cfg.attr,
10846         &dev_attr_error.attr,
10847         &dev_attr_event_log.attr,
10848         &dev_attr_cmd_log.attr,
10849         &dev_attr_eeprom_delay.attr,
10850         &dev_attr_ucode_version.attr,
10851         &dev_attr_rtc.attr,
10852         &dev_attr_scan_age.attr,
10853         &dev_attr_led.attr,
10854         &dev_attr_speed_scan.attr,
10855         &dev_attr_net_stats.attr,
10856         NULL
10857 };
10858
10859 static struct attribute_group ipw_attribute_group = {
10860         .name = NULL,           /* put in device directory */
10861         .attrs = ipw_sysfs_entries,
10862 };
10863
10864 static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
10865 {
10866         int err = 0;
10867         struct net_device *net_dev;
10868         void __iomem *base;
10869         u32 length, val;
10870         struct ipw_priv *priv;
10871         int i;
10872
10873         net_dev = alloc_ieee80211(sizeof(struct ipw_priv));
10874         if (net_dev == NULL) {
10875                 err = -ENOMEM;
10876                 goto out;
10877         }
10878
10879         priv = ieee80211_priv(net_dev);
10880         priv->ieee = netdev_priv(net_dev);
10881
10882         priv->net_dev = net_dev;
10883         priv->pci_dev = pdev;
10884 #ifdef CONFIG_IPW2200_DEBUG
10885         ipw_debug_level = debug;
10886 #endif
10887         spin_lock_init(&priv->lock);
10888         for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++)
10889                 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
10890
10891         mutex_init(&priv->mutex);
10892         if (pci_enable_device(pdev)) {
10893                 err = -ENODEV;
10894                 goto out_free_ieee80211;
10895         }
10896
10897         pci_set_master(pdev);
10898
10899         err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
10900         if (!err)
10901                 err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
10902         if (err) {
10903                 printk(KERN_WARNING DRV_NAME ": No suitable DMA available.\n");
10904                 goto out_pci_disable_device;
10905         }
10906
10907         pci_set_drvdata(pdev, priv);
10908
10909         err = pci_request_regions(pdev, DRV_NAME);
10910         if (err)
10911                 goto out_pci_disable_device;
10912
10913         /* We disable the RETRY_TIMEOUT register (0x41) to keep
10914          * PCI Tx retries from interfering with C3 CPU state */
10915         pci_read_config_dword(pdev, 0x40, &val);
10916         if ((val & 0x0000ff00) != 0)
10917                 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
10918
10919         length = pci_resource_len(pdev, 0);
10920         priv->hw_len = length;
10921
10922         base = ioremap_nocache(pci_resource_start(pdev, 0), length);
10923         if (!base) {
10924                 err = -ENODEV;
10925                 goto out_pci_release_regions;
10926         }
10927
10928         priv->hw_base = base;
10929         IPW_DEBUG_INFO("pci_resource_len = 0x%08x\n", length);
10930         IPW_DEBUG_INFO("pci_resource_base = %p\n", base);
10931
10932         err = ipw_setup_deferred_work(priv);
10933         if (err) {
10934                 IPW_ERROR("Unable to setup deferred work\n");
10935                 goto out_iounmap;
10936         }
10937
10938         ipw_sw_reset(priv, 1);
10939
10940         err = request_irq(pdev->irq, ipw_isr, SA_SHIRQ, DRV_NAME, priv);
10941         if (err) {
10942                 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
10943                 goto out_destroy_workqueue;
10944         }
10945
10946         SET_MODULE_OWNER(net_dev);
10947         SET_NETDEV_DEV(net_dev, &pdev->dev);
10948
10949         mutex_lock(&priv->mutex);
10950
10951         priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
10952         priv->ieee->set_security = shim__set_security;
10953         priv->ieee->is_queue_full = ipw_net_is_queue_full;
10954
10955 #ifdef CONFIG_IPW_QOS
10956         priv->ieee->handle_probe_response = ipw_handle_beacon;
10957         priv->ieee->handle_beacon = ipw_handle_probe_response;
10958         priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
10959 #endif                          /* CONFIG_IPW_QOS */
10960
10961         priv->ieee->perfect_rssi = -20;
10962         priv->ieee->worst_rssi = -85;
10963
10964         net_dev->open = ipw_net_open;
10965         net_dev->stop = ipw_net_stop;
10966         net_dev->init = ipw_net_init;
10967         net_dev->get_stats = ipw_net_get_stats;
10968         net_dev->set_multicast_list = ipw_net_set_multicast_list;
10969         net_dev->set_mac_address = ipw_net_set_mac_address;
10970         priv->wireless_data.spy_data = &priv->ieee->spy_data;
10971         net_dev->wireless_data = &priv->wireless_data;
10972         net_dev->wireless_handlers = &ipw_wx_handler_def;
10973         net_dev->ethtool_ops = &ipw_ethtool_ops;
10974         net_dev->irq = pdev->irq;
10975         net_dev->base_addr = (unsigned long)priv->hw_base;
10976         net_dev->mem_start = pci_resource_start(pdev, 0);
10977         net_dev->mem_end = net_dev->mem_start + pci_resource_len(pdev, 0) - 1;
10978
10979         err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
10980         if (err) {
10981                 IPW_ERROR("failed to create sysfs device attributes\n");
10982                 mutex_unlock(&priv->mutex);
10983                 goto out_release_irq;
10984         }
10985
10986         mutex_unlock(&priv->mutex);
10987         err = register_netdev(net_dev);
10988         if (err) {
10989                 IPW_ERROR("failed to register network device\n");
10990                 goto out_remove_sysfs;
10991         }
10992
10993         printk(KERN_INFO DRV_NAME ": Detected geography %s (%d 802.11bg "
10994                "channels, %d 802.11a channels)\n",
10995                priv->ieee->geo.name, priv->ieee->geo.bg_channels,
10996                priv->ieee->geo.a_channels);
10997
10998         return 0;
10999
11000       out_remove_sysfs:
11001         sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11002       out_release_irq:
11003         free_irq(pdev->irq, priv);
11004       out_destroy_workqueue:
11005         destroy_workqueue(priv->workqueue);
11006         priv->workqueue = NULL;
11007       out_iounmap:
11008         iounmap(priv->hw_base);
11009       out_pci_release_regions:
11010         pci_release_regions(pdev);
11011       out_pci_disable_device:
11012         pci_disable_device(pdev);
11013         pci_set_drvdata(pdev, NULL);
11014       out_free_ieee80211:
11015         free_ieee80211(priv->net_dev);
11016       out:
11017         return err;
11018 }
11019
11020 static void ipw_pci_remove(struct pci_dev *pdev)
11021 {
11022         struct ipw_priv *priv = pci_get_drvdata(pdev);
11023         struct list_head *p, *q;
11024         int i;
11025
11026         if (!priv)
11027                 return;
11028
11029         mutex_lock(&priv->mutex);
11030
11031         priv->status |= STATUS_EXIT_PENDING;
11032         ipw_down(priv);
11033         sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11034
11035         mutex_unlock(&priv->mutex);
11036
11037         unregister_netdev(priv->net_dev);
11038
11039         if (priv->rxq) {
11040                 ipw_rx_queue_free(priv, priv->rxq);
11041                 priv->rxq = NULL;
11042         }
11043         ipw_tx_queue_free(priv);
11044
11045         if (priv->cmdlog) {
11046                 kfree(priv->cmdlog);
11047                 priv->cmdlog = NULL;
11048         }
11049         /* ipw_down will ensure that there is no more pending work
11050          * in the workqueue's, so we can safely remove them now. */
11051         cancel_delayed_work(&priv->adhoc_check);
11052         cancel_delayed_work(&priv->gather_stats);
11053         cancel_delayed_work(&priv->request_scan);
11054         cancel_delayed_work(&priv->rf_kill);
11055         cancel_delayed_work(&priv->scan_check);
11056         destroy_workqueue(priv->workqueue);
11057         priv->workqueue = NULL;
11058
11059         /* Free MAC hash list for ADHOC */
11060         for (i = 0; i < IPW_IBSS_MAC_HASH_SIZE; i++) {
11061                 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
11062                         list_del(p);
11063                         kfree(list_entry(p, struct ipw_ibss_seq, list));
11064                 }
11065         }
11066
11067         if (priv->error) {
11068                 ipw_free_error_log(priv->error);
11069                 priv->error = NULL;
11070         }
11071
11072         free_irq(pdev->irq, priv);
11073         iounmap(priv->hw_base);
11074         pci_release_regions(pdev);
11075         pci_disable_device(pdev);
11076         pci_set_drvdata(pdev, NULL);
11077         free_ieee80211(priv->net_dev);
11078         free_firmware();
11079 }
11080
11081 #ifdef CONFIG_PM
11082 static int ipw_pci_suspend(struct pci_dev *pdev, pm_message_t state)
11083 {
11084         struct ipw_priv *priv = pci_get_drvdata(pdev);
11085         struct net_device *dev = priv->net_dev;
11086
11087         printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11088
11089         /* Take down the device; powers it off, etc. */
11090         ipw_down(priv);
11091
11092         /* Remove the PRESENT state of the device */
11093         netif_device_detach(dev);
11094
11095         pci_save_state(pdev);
11096         pci_disable_device(pdev);
11097         pci_set_power_state(pdev, pci_choose_state(pdev, state));
11098
11099         return 0;
11100 }
11101
11102 static int ipw_pci_resume(struct pci_dev *pdev)
11103 {
11104         struct ipw_priv *priv = pci_get_drvdata(pdev);
11105         struct net_device *dev = priv->net_dev;
11106         u32 val;
11107
11108         printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11109
11110         pci_set_power_state(pdev, PCI_D0);
11111         pci_enable_device(pdev);
11112         pci_restore_state(pdev);
11113
11114         /*
11115          * Suspend/Resume resets the PCI configuration space, so we have to
11116          * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
11117          * from interfering with C3 CPU state. pci_restore_state won't help
11118          * here since it only restores the first 64 bytes pci config header.
11119          */
11120         pci_read_config_dword(pdev, 0x40, &val);
11121         if ((val & 0x0000ff00) != 0)
11122                 pci_write_config_dword(pdev, 0x40, val & 0xffff00ff);
11123
11124         /* Set the device back into the PRESENT state; this will also wake
11125          * the queue of needed */
11126         netif_device_attach(dev);
11127
11128         /* Bring the device back up */
11129         queue_work(priv->workqueue, &priv->up);
11130
11131         return 0;
11132 }
11133 #endif
11134
11135 /* driver initialization stuff */
11136 static struct pci_driver ipw_driver = {
11137         .name = DRV_NAME,
11138         .id_table = card_ids,
11139         .probe = ipw_pci_probe,
11140         .remove = __devexit_p(ipw_pci_remove),
11141 #ifdef CONFIG_PM
11142         .suspend = ipw_pci_suspend,
11143         .resume = ipw_pci_resume,
11144 #endif
11145 };
11146
11147 static int __init ipw_init(void)
11148 {
11149         int ret;
11150
11151         printk(KERN_INFO DRV_NAME ": " DRV_DESCRIPTION ", " DRV_VERSION "\n");
11152         printk(KERN_INFO DRV_NAME ": " DRV_COPYRIGHT "\n");
11153
11154         ret = pci_module_init(&ipw_driver);
11155         if (ret) {
11156                 IPW_ERROR("Unable to initialize PCI module\n");
11157                 return ret;
11158         }
11159
11160         ret = driver_create_file(&ipw_driver.driver, &driver_attr_debug_level);
11161         if (ret) {
11162                 IPW_ERROR("Unable to create driver sysfs file\n");
11163                 pci_unregister_driver(&ipw_driver);
11164                 return ret;
11165         }
11166
11167         return ret;
11168 }
11169
11170 static void __exit ipw_exit(void)
11171 {
11172         driver_remove_file(&ipw_driver.driver, &driver_attr_debug_level);
11173         pci_unregister_driver(&ipw_driver);
11174 }
11175
11176 module_param(disable, int, 0444);
11177 MODULE_PARM_DESC(disable, "manually disable the radio (default 0 [radio on])");
11178
11179 module_param(associate, int, 0444);
11180 MODULE_PARM_DESC(associate, "auto associate when scanning (default on)");
11181
11182 module_param(auto_create, int, 0444);
11183 MODULE_PARM_DESC(auto_create, "auto create adhoc network (default on)");
11184
11185 module_param(led, int, 0444);
11186 MODULE_PARM_DESC(led, "enable led control on some systems (default 0 off)\n");
11187
11188 #ifdef CONFIG_IPW2200_DEBUG
11189 module_param(debug, int, 0444);
11190 MODULE_PARM_DESC(debug, "debug output mask");
11191 #endif
11192
11193 module_param(channel, int, 0444);
11194 MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
11195
11196 #ifdef CONFIG_IPW_QOS
11197 module_param(qos_enable, int, 0444);
11198 MODULE_PARM_DESC(qos_enable, "enable all QoS functionalitis");
11199
11200 module_param(qos_burst_enable, int, 0444);
11201 MODULE_PARM_DESC(qos_burst_enable, "enable QoS burst mode");
11202
11203 module_param(qos_no_ack_mask, int, 0444);
11204 MODULE_PARM_DESC(qos_no_ack_mask, "mask Tx_Queue to no ack");
11205
11206 module_param(burst_duration_CCK, int, 0444);
11207 MODULE_PARM_DESC(burst_duration_CCK, "set CCK burst value");
11208
11209 module_param(burst_duration_OFDM, int, 0444);
11210 MODULE_PARM_DESC(burst_duration_OFDM, "set OFDM burst value");
11211 #endif                          /* CONFIG_IPW_QOS */
11212
11213 #ifdef CONFIG_IPW2200_MONITOR
11214 module_param(mode, int, 0444);
11215 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
11216 #else
11217 module_param(mode, int, 0444);
11218 MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS)");
11219 #endif
11220
11221 module_param(bt_coexist, int, 0444);
11222 MODULE_PARM_DESC(bt_coexist, "enable bluetooth coexistence (default off)");
11223
11224 module_param(hwcrypto, int, 0444);
11225 MODULE_PARM_DESC(hwcrypto, "enable hardware crypto (default off)");
11226
11227 module_param(cmdlog, int, 0444);
11228 MODULE_PARM_DESC(cmdlog,
11229                  "allocate a ring buffer for logging firmware commands");
11230
11231 module_param(roaming, int, 0444);
11232 MODULE_PARM_DESC(roaming, "enable roaming support (default on)");
11233
11234 module_exit(ipw_exit);
11235 module_init(ipw_init);