err.no Git - linux-2.6/blob - drivers/net/wireless/ipw2200.c

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