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

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