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