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