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