Lines Matching +full:4 +full:ghz +full:- +full:coexistence
1 // SPDX-License-Identifier: GPL-2.0-only
4 Copyright(c) 2003 - 2006 Intel Corporation. All rights reserved.
6 802.11 status code portion of this file from ethereal-0.10.6:
8 Ethereal - Network traffic analyzer
15 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
21 #include <net/cfg80211-wext.h>
64 #define DRV_COPYRIGHT "Copyright(c) 2003-2006 Intel Corporation"
73 MODULE_FIRMWARE("ipw2200-ibss.fw");
75 MODULE_FIRMWARE("ipw2200-sniffer.fw");
77 MODULE_FIRMWARE("ipw2200-bss.fw");
98 static int rtap_iface = 0; /* def: 0 -- do not create rtap interface */
116 #define ipw2200_a_rates (ipw2200_rates + 4)
229 out += scnprintf(buf + out, count - out, " ");
231 out += scnprintf(buf + out, count - out, "%02X ",
234 out += scnprintf(buf + out, count - out, " ");
237 out += scnprintf(buf + out, count - out, " ");
239 out += scnprintf(buf + out, count - out, " ");
245 out += scnprintf(buf + out, count - out, "%c", c);
249 out += scnprintf(buf + out, count - out, " ");
267 len -= min(len, 16U);
283 size -= out;
284 len -= min_t(size_t, len, 16U);
290 /* alias for 32-bit indirect read (for SRAM/reg above 4K), with debug wrapper */
294 /* alias for 8-bit indirect read (for SRAM/reg above 4K), with debug wrapper */
298 /* 8-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
307 /* 16-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
316 /* 32-bit indirect write (for SRAM/reg above 4K), with debug wrapper */
325 /* 8-bit direct write (low 4K) */
329 writeb(val, ipw->hw_base + ofs);
332 /* 8-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
339 /* 16-bit direct write (low 4K) */
343 writew(val, ipw->hw_base + ofs);
346 /* 16-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
353 /* 32-bit direct write (low 4K) */
357 writel(val, ipw->hw_base + ofs);
360 /* 32-bit direct write (for low 4K of SRAM/regs), with debug wrapper */
367 /* 8-bit direct read (low 4K) */
370 return readb(ipw->hw_base + ofs);
373 /* alias to 8-bit direct read (low 4K of SRAM/regs), with debug wrapper */
380 /* 32-bit direct read (low 4K) */
383 return readl(ipw->hw_base + ofs);
386 /* alias to 32-bit direct read (low 4K of SRAM/regs), with debug wrapper */
394 /* alias to multi-byte read (SRAM/regs above 4K), with debug wrapper */
401 /* alias to multi-byte read (SRAM/regs above 4K), with debug wrapper */
410 /* 32-bit indirect write (above 4K) */
418 /* 8-bit indirect write (above 4K) */
422 u32 dif_len = reg - aligned_addr;
429 /* 16-bit indirect write (above 4K) */
433 u32 dif_len = (reg - aligned_addr) & (~0x1ul);
440 /* 8-bit indirect read (above 4K) */
450 /* 32-bit indirect read (above 4K) */
459 IPW_DEBUG_IO(" reg = 0x%4X : value = 0x%4x\n", reg, value);
463 /* General purpose, no alignment requirement, iterative (multi-byte) read, */
464 /* for area above 1st 4K of SRAM/reg space */
469 u32 dif_len = addr - aligned_addr;
482 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--)
484 aligned_addr += 4;
487 /* Read all of the middle dwords as dwords, with auto-increment */
489 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
495 for (i = 0; num > 0; i++, num--)
500 /* General purpose, no alignment requirement, iterative (multi-byte) write, */
501 /* for area above 1st 4K of SRAM/reg space */
506 u32 dif_len = addr - aligned_addr;
519 for (i = dif_len; ((i < 4) && (num > 0)); i++, num--, buf++)
521 aligned_addr += 4;
524 /* Write all of the middle dwords as dwords, with auto-increment */
526 for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
532 for (i = 0; num > 0; i++, num--, buf++)
537 /* General purpose, no alignment requirement, iterative (multi-byte) write, */
538 /* for 1st 4K of SRAM/regs space */
542 memcpy_toio((priv->hw_base + addr), buf, num);
545 /* Set bit(s) in low 4K of SRAM/regs */
551 /* Clear bit(s) in low 4K of SRAM/regs */
559 if (priv->status & STATUS_INT_ENABLED)
561 priv->status |= STATUS_INT_ENABLED;
567 if (!(priv->status & STATUS_INT_ENABLED))
569 priv->status &= ~STATUS_INT_ENABLED;
577 spin_lock_irqsave(&priv->irq_lock, flags);
579 spin_unlock_irqrestore(&priv->irq_lock, flags);
586 spin_lock_irqsave(&priv->irq_lock, flags);
588 spin_unlock_irqrestore(&priv->irq_lock, flags);
642 error->status, error->config);
644 for (i = 0; i < error->elem_len; i++)
646 ipw_error_desc(error->elem[i].desc),
647 error->elem[i].time,
648 error->elem[i].blink1,
649 error->elem[i].blink2,
650 error->elem[i].link1,
651 error->elem[i].link2, error->elem[i].data);
652 for (i = 0; i < error->log_len; i++)
654 error->log[i].time,
655 error->log[i].data, error->log[i].event);
660 return (priv->status & STATUS_INIT) ? 1 : 0;
671 return -EINVAL;
675 if (!priv->table0_addr || !priv->table1_addr || !priv->table2_addr) {
677 return -EINVAL;
693 if (ord > priv->table0_len) {
695 "max (%i)\n", ord, priv->table0_len);
696 return -EINVAL;
703 return -EINVAL;
707 ord, priv->table0_addr + (ord << 2));
711 *((u32 *) val) = ipw_read32(priv, priv->table0_addr + ord);
727 if (ord > priv->table1_len) {
729 return -EINVAL;
736 return -EINVAL;
740 ipw_read_reg32(priv, (priv->table1_addr + (ord << 2)));
749 * - dword containing the starting offset of the data
750 * - dword containing the lengh in the first 16bits
758 if (ord > priv->table2_len) {
760 return -EINVAL;
764 addr = ipw_read_reg32(priv, priv->table2_addr + (ord << 3));
767 * two 16-bit words - first is length, second is count */
770 priv->table2_addr + (ord << 3) +
783 return -EINVAL;
798 return -EINVAL;
807 priv->table0_addr = IPW_ORDINALS_TABLE_LOWER;
808 priv->table0_len = ipw_read32(priv, priv->table0_addr);
811 priv->table0_addr, priv->table0_len);
813 priv->table1_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_1);
814 priv->table1_len = ipw_read_reg32(priv, priv->table1_addr);
817 priv->table1_addr, priv->table1_len);
819 priv->table2_addr = ipw_read32(priv, IPW_ORDINALS_TABLE_2);
820 priv->table2_len = ipw_read_reg32(priv, priv->table2_addr);
821 priv->table2_len &= 0x0000ffff; /* use first two bytes */
824 priv->table2_addr, priv->table2_len);
842 * - On radio ON, turn on any LEDs that require to be on during start
843 * - On initialization, start unassociated blink
844 * - On association, disable unassociated blink
845 * - On disassociation, start unassociated blink
846 * - On radio OFF, turn off any LEDs started during radio on
860 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
863 spin_lock_irqsave(&priv->lock, flags);
865 if (!(priv->status & STATUS_RF_KILL_MASK) &&
866 !(priv->status & STATUS_LED_LINK_ON)) {
869 led |= priv->led_association_on;
876 priv->status |= STATUS_LED_LINK_ON;
879 if (!(priv->status & STATUS_ASSOCIATED))
880 schedule_delayed_work(&priv->led_link_off,
884 spin_unlock_irqrestore(&priv->lock, flags);
891 mutex_lock(&priv->mutex);
893 mutex_unlock(&priv->mutex);
903 if (priv->config & CFG_NO_LED || priv->nic_type == EEPROM_NIC_TYPE_1)
906 spin_lock_irqsave(&priv->lock, flags);
908 if (priv->status & STATUS_LED_LINK_ON) {
910 led &= priv->led_association_off;
918 priv->status &= ~STATUS_LED_LINK_ON;
922 if (!(priv->status & STATUS_RF_KILL_MASK) &&
923 !(priv->status & STATUS_ASSOCIATED))
924 schedule_delayed_work(&priv->led_link_on,
929 spin_unlock_irqrestore(&priv->lock, flags);
936 mutex_lock(&priv->mutex);
938 mutex_unlock(&priv->mutex);
945 if (priv->config & CFG_NO_LED)
948 if (priv->status & STATUS_RF_KILL_MASK)
951 if (!(priv->status & STATUS_LED_ACT_ON)) {
953 led |= priv->led_activity_on;
962 priv->status |= STATUS_LED_ACT_ON;
964 cancel_delayed_work(&priv->led_act_off);
965 schedule_delayed_work(&priv->led_act_off, LD_TIME_ACT_ON);
968 cancel_delayed_work(&priv->led_act_off);
969 schedule_delayed_work(&priv->led_act_off, LD_TIME_ACT_ON);
977 spin_lock_irqsave(&priv->lock, flags);
979 spin_unlock_irqrestore(&priv->lock, flags);
988 if (priv->config & CFG_NO_LED)
991 spin_lock_irqsave(&priv->lock, flags);
993 if (priv->status & STATUS_LED_ACT_ON) {
995 led &= priv->led_activity_off;
1004 priv->status &= ~STATUS_LED_ACT_ON;
1007 spin_unlock_irqrestore(&priv->lock, flags);
1014 mutex_lock(&priv->mutex);
1016 mutex_unlock(&priv->mutex);
1025 if (priv->config & CFG_NO_LED ||
1026 priv->nic_type != EEPROM_NIC_TYPE_1 || !priv->assoc_network)
1029 spin_lock_irqsave(&priv->lock, flags);
1032 if (priv->assoc_network->mode == IEEE_A) {
1033 led |= priv->led_ofdm_on;
1034 led &= priv->led_association_off;
1036 } else if (priv->assoc_network->mode == IEEE_G) {
1037 led |= priv->led_ofdm_on;
1038 led |= priv->led_association_on;
1041 led &= priv->led_ofdm_off;
1042 led |= priv->led_association_on;
1051 spin_unlock_irqrestore(&priv->lock, flags);
1060 if (priv->config & CFG_NO_LED || priv->nic_type != EEPROM_NIC_TYPE_1)
1063 spin_lock_irqsave(&priv->lock, flags);
1066 led &= priv->led_ofdm_off;
1067 led &= priv->led_association_off;
1074 spin_unlock_irqrestore(&priv->lock, flags);
1099 if (priv->status & STATUS_RF_KILL_MASK)
1105 priv->nic_type = priv->eeprom[EEPROM_NIC_TYPE];
1108 priv->led_activity_on = IPW_ACTIVITY_LED;
1109 priv->led_activity_off = ~(IPW_ACTIVITY_LED);
1111 priv->led_association_on = IPW_ASSOCIATED_LED;
1112 priv->led_association_off = ~(IPW_ASSOCIATED_LED);
1115 priv->led_ofdm_on = IPW_OFDM_LED;
1116 priv->led_ofdm_off = ~(IPW_OFDM_LED);
1118 switch (priv->nic_type) {
1121 priv->led_activity_on = IPW_ASSOCIATED_LED;
1122 priv->led_activity_off = ~(IPW_ASSOCIATED_LED);
1123 priv->led_association_on = IPW_ACTIVITY_LED;
1124 priv->led_association_off = ~(IPW_ACTIVITY_LED);
1126 if (!(priv->config & CFG_NO_LED))
1141 priv->nic_type);
1142 priv->nic_type = EEPROM_NIC_TYPE_0;
1146 if (!(priv->config & CFG_NO_LED)) {
1147 if (priv->status & STATUS_ASSOCIATED)
1159 cancel_delayed_work(&priv->led_link_on);
1160 cancel_delayed_work(&priv->led_link_off);
1161 cancel_delayed_work(&priv->led_act_off);
1183 if (result == -EINVAL)
1186 else if (result == -ERANGE)
1222 array_size(sizeof(*error->log), log_len)),
1229 error->jiffies = jiffies;
1230 error->status = priv->status;
1231 error->config = priv->config;
1232 error->elem_len = elem_len;
1233 error->log_len = log_len;
1234 error->log = (struct ipw_event *)(error->elem + elem_len);
1236 ipw_capture_event_log(priv, log_len, error->log);
1239 ipw_read_indirect(priv, base + sizeof(base), (u8 *) error->elem,
1240 sizeof(*error->elem) * elem_len);
1265 len += scnprintf(buf + len, PAGE_SIZE - len, "%08X", log_len);
1267 len += scnprintf(buf + len, PAGE_SIZE - len,
1270 len += scnprintf(buf + len, PAGE_SIZE - len, "\n");
1282 if (!priv->error)
1284 len += scnprintf(buf + len, PAGE_SIZE - len,
1286 priv->error->jiffies,
1287 priv->error->status,
1288 priv->error->config, priv->error->elem_len);
1289 for (i = 0; i < priv->error->elem_len; i++)
1290 len += scnprintf(buf + len, PAGE_SIZE - len,
1292 priv->error->elem[i].time,
1293 priv->error->elem[i].desc,
1294 priv->error->elem[i].blink1,
1295 priv->error->elem[i].blink2,
1296 priv->error->elem[i].link1,
1297 priv->error->elem[i].link2,
1298 priv->error->elem[i].data);
1300 len += scnprintf(buf + len, PAGE_SIZE - len,
1301 "\n%08X", priv->error->log_len);
1302 for (i = 0; i < priv->error->log_len; i++)
1303 len += scnprintf(buf + len, PAGE_SIZE - len,
1305 priv->error->log[i].time,
1306 priv->error->log[i].event,
1307 priv->error->log[i].data);
1308 len += scnprintf(buf + len, PAGE_SIZE - len, "\n");
1318 kfree(priv->error);
1319 priv->error = NULL;
1330 if (!priv->cmdlog)
1332 for (i = (priv->cmdlog_pos + 1) % priv->cmdlog_len;
1333 (i != priv->cmdlog_pos) && (len < PAGE_SIZE);
1334 i = (i + 1) % priv->cmdlog_len) {
1336 scnprintf(buf + len, PAGE_SIZE - len,
1337 "\n%08lX%08X%08X%08X\n", priv->cmdlog[i].jiffies,
1338 priv->cmdlog[i].retcode, priv->cmdlog[i].cmd.cmd,
1339 priv->cmdlog[i].cmd.len);
1341 snprintk_buf(buf + len, PAGE_SIZE - len,
1342 (u8 *) priv->cmdlog[i].cmd.param,
1343 priv->cmdlog[i].cmd.len);
1344 len += scnprintf(buf + len, PAGE_SIZE - len, "\n");
1346 len += scnprintf(buf + len, PAGE_SIZE - len, "\n");
1363 return -EINVAL;
1370 if (netif_running(priv->prom_net_dev)) {
1389 return -EINVAL;
1406 return sprintf(buf, "%s", priv->prom_net_dev->name);
1408 buf[0] = '-';
1423 if (!priv->prom_priv) {
1426 return -EPERM;
1429 priv->prom_priv->filter = simple_strtol(buf, NULL, 0);
1432 BIT_ARG16(priv->prom_priv->filter));
1443 priv->prom_priv ? priv->prom_priv->filter : 0);
1453 return sprintf(buf, "%d\n", priv->ieee->scan_age);
1460 struct net_device *dev = priv->net_dev;
1467 if (result == -EINVAL || result == -ERANGE) {
1468 IPW_DEBUG_INFO("%s: user supplied invalid value.\n", dev->name);
1470 priv->ieee->scan_age = val;
1471 IPW_DEBUG_INFO("set scan_age = %u\n", priv->ieee->scan_age);
1484 return sprintf(buf, "%d\n", (priv->config & CFG_NO_LED) ? 0 : 1);
1499 priv->config |= CFG_NO_LED;
1503 priv->config &= ~CFG_NO_LED;
1517 return sprintf(buf, "0x%08x\n", (int)p->status);
1526 return sprintf(buf, "0x%08x\n", (int)p->config);
1535 return sprintf(buf, "TYPE: %d\n", priv->nic_type);
1576 int n = p->eeprom_delay;
1584 sscanf(buf, "%i", &p->eeprom_delay);
1642 if (priv->status & STATUS_INDIRECT_DWORD)
1643 reg = ipw_read_reg32(priv, priv->indirect_dword);
1655 sscanf(buf, "%x", &priv->indirect_dword);
1656 priv->status |= STATUS_INDIRECT_DWORD;
1668 if (priv->status & STATUS_INDIRECT_BYTE)
1669 reg = ipw_read_reg8(priv, priv->indirect_byte);
1681 sscanf(buf, "%x", &priv->indirect_byte);
1682 priv->status |= STATUS_INDIRECT_BYTE;
1694 if (priv->status & STATUS_DIRECT_DWORD)
1695 reg = ipw_read32(priv, priv->direct_dword);
1707 sscanf(buf, "%x", &priv->direct_dword);
1708 priv->status |= STATUS_DIRECT_DWORD;
1717 priv->status |= STATUS_RF_KILL_HW;
1718 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
1720 priv->status &= ~STATUS_RF_KILL_HW;
1721 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, false);
1724 return (priv->status & STATUS_RF_KILL_HW) ? 1 : 0;
1730 /* 0 - RF kill not enabled
1731 1 - SW based RF kill active (sysfs)
1732 2 - HW based RF kill active
1733 3 - Both HW and SW baed RF kill active */
1735 int val = ((priv->status & STATUS_RF_KILL_SW) ? 0x1 : 0x0) |
1743 ((priv->status & STATUS_RF_KILL_SW) ? 1 : 0))
1750 priv->status |= STATUS_RF_KILL_SW;
1752 cancel_delayed_work(&priv->request_scan);
1753 cancel_delayed_work(&priv->request_direct_scan);
1754 cancel_delayed_work(&priv->request_passive_scan);
1755 cancel_delayed_work(&priv->scan_event);
1756 schedule_work(&priv->down);
1758 priv->status &= ~STATUS_RF_KILL_SW;
1760 IPW_DEBUG_RF_KILL("Can not turn radio back on - "
1763 cancel_delayed_work(&priv->rf_kill);
1764 schedule_delayed_work(&priv->rf_kill,
1767 schedule_work(&priv->up);
1790 if (priv->config & CFG_SPEED_SCAN) {
1791 while (priv->speed_scan[pos] != 0)
1793 priv->speed_scan[pos++]);
1809 if (pos == MAX_SPEED_SCAN - 1) {
1810 priv->speed_scan[pos] = 0;
1814 if (libipw_is_valid_channel(priv->ieee, channel))
1815 priv->speed_scan[pos++] = channel;
1827 priv->config &= ~CFG_SPEED_SCAN;
1829 priv->speed_scan_pos = 0;
1830 priv->config |= CFG_SPEED_SCAN;
1842 return sprintf(buf, "%c\n", (priv->config & CFG_NET_STATS) ? '1' : '0');
1850 priv->config |= CFG_NET_STATS;
1852 priv->config &= ~CFG_NET_STATS;
1864 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
1868 "Displaying %d channels in 2.4Ghz band "
1869 "(802.11bg):\n", geo->bg_channels);
1871 for (i = 0; i < geo->bg_channels; i++) {
1873 geo->bg[i].channel,
1874 geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT ?
1876 ((geo->bg[i].flags & LIBIPW_CH_NO_IBSS) ||
1877 (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT))
1879 geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY ?
1881 geo->bg[i].flags & LIBIPW_CH_B_ONLY ?
1886 "Displaying %d channels in 5.2Ghz band "
1887 "(802.11a):\n", geo->a_channels);
1888 for (i = 0; i < geo->a_channels; i++) {
1890 geo->a[i].channel,
1891 geo->a[i].flags & LIBIPW_CH_RADAR_DETECT ?
1893 ((geo->a[i].flags & LIBIPW_CH_NO_IBSS) ||
1894 (geo->a[i].flags & LIBIPW_CH_RADAR_DETECT))
1896 geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY ?
1909 if (priv->status & STATUS_ASSOCIATED)
1910 memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
1913 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
1922 spin_lock_irqsave(&priv->irq_lock, flags);
1936 inta |= priv->isr_inta;
1938 spin_unlock_irqrestore(&priv->irq_lock, flags);
1940 spin_lock_irqsave(&priv->lock, flags);
1950 ipw_queue_tx_reclaim(priv, &priv->txq_cmd, -1);
1951 priv->status &= ~STATUS_HCMD_ACTIVE;
1952 wake_up_interruptible(&priv->wait_command_queue);
1958 ipw_queue_tx_reclaim(priv, &priv->txq[0], 0);
1964 ipw_queue_tx_reclaim(priv, &priv->txq[1], 1);
1970 ipw_queue_tx_reclaim(priv, &priv->txq[2], 2);
1976 ipw_queue_tx_reclaim(priv, &priv->txq[3], 3);
2007 priv->status |= STATUS_RF_KILL_HW;
2008 wiphy_rfkill_set_hw_state(priv->ieee->wdev.wiphy, true);
2009 wake_up_interruptible(&priv->wait_command_queue);
2010 priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
2011 cancel_delayed_work(&priv->request_scan);
2012 cancel_delayed_work(&priv->request_direct_scan);
2013 cancel_delayed_work(&priv->request_passive_scan);
2014 cancel_delayed_work(&priv->scan_event);
2015 schedule_work(&priv->link_down);
2016 schedule_delayed_work(&priv->rf_kill, 2 * HZ);
2022 if (priv->error) {
2031 priv->error = ipw_alloc_error_log(priv);
2032 if (priv->error)
2038 ipw_dump_error_log(priv, priv->error);
2043 if (priv->ieee->sec.encrypt) {
2044 priv->status &= ~STATUS_ASSOCIATED;
2050 priv->status &= ~STATUS_INIT;
2053 priv->status &= ~STATUS_HCMD_ACTIVE;
2054 wake_up_interruptible(&priv->wait_command_queue);
2056 schedule_work(&priv->adapter_restart);
2069 spin_unlock_irqrestore(&priv->lock, flags);
2142 spin_lock_irqsave(&priv->lock, flags);
2143 if (priv->status & STATUS_HCMD_ACTIVE) {
2145 get_cmd_string(cmd->cmd));
2146 spin_unlock_irqrestore(&priv->lock, flags);
2147 return -EAGAIN;
2150 priv->status |= STATUS_HCMD_ACTIVE;
2152 if (priv->cmdlog) {
2153 priv->cmdlog[priv->cmdlog_pos].jiffies = jiffies;
2154 priv->cmdlog[priv->cmdlog_pos].cmd.cmd = cmd->cmd;
2155 priv->cmdlog[priv->cmdlog_pos].cmd.len = cmd->len;
2156 memcpy(priv->cmdlog[priv->cmdlog_pos].cmd.param, cmd->param,
2157 cmd->len);
2158 priv->cmdlog[priv->cmdlog_pos].retcode = -1;
2162 get_cmd_string(cmd->cmd), cmd->cmd, cmd->len,
2163 priv->status);
2166 if (cmd->cmd == IPW_CMD_WEP_KEY)
2170 printk_buf(IPW_DL_HOST_COMMAND, (u8 *) cmd->param, cmd->len);
2172 rc = ipw_queue_tx_hcmd(priv, cmd->cmd, cmd->param, cmd->len, 0);
2174 priv->status &= ~STATUS_HCMD_ACTIVE;
2176 get_cmd_string(cmd->cmd), rc);
2177 spin_unlock_irqrestore(&priv->lock, flags);
2180 spin_unlock_irqrestore(&priv->lock, flags);
2185 rc = wait_event_interruptible_timeout(priv->wait_command_queue,
2186 !(priv->
2188 end - now);
2197 spin_lock_irqsave(&priv->lock, flags);
2198 if (priv->status & STATUS_HCMD_ACTIVE) {
2200 get_cmd_string(cmd->cmd));
2201 priv->status &= ~STATUS_HCMD_ACTIVE;
2202 spin_unlock_irqrestore(&priv->lock, flags);
2203 rc = -EIO;
2206 spin_unlock_irqrestore(&priv->lock, flags);
2210 if (priv->status & STATUS_RF_KILL_HW) {
2212 get_cmd_string(cmd->cmd));
2213 rc = -EIO;
2218 if (priv->cmdlog) {
2219 priv->cmdlog[priv->cmdlog_pos++].retcode = rc;
2220 priv->cmdlog_pos %= priv->cmdlog_len;
2250 return -1;
2259 sizeof(priv->sys_config),
2260 &priv->sys_config);
2267 return -1;
2278 return -1;
2282 priv->net_dev->name, mac);
2291 if (priv->status & STATUS_RF_KILL_MASK)
2296 if (priv->assoc_network &&
2297 (priv->assoc_network->capability & WLAN_CAPABILITY_IBSS))
2310 mutex_lock(&priv->mutex);
2312 mutex_unlock(&priv->mutex);
2323 if (priv->status & STATUS_SCAN_ABORTING) {
2327 schedule_work(&priv->adapter_restart);
2328 } else if (priv->status & STATUS_SCANNING) {
2333 schedule_delayed_work(&priv->scan_check, HZ);
2341 mutex_lock(&priv->mutex);
2343 mutex_unlock(&priv->mutex);
2357 return -1;
2378 return -1;
2390 return -1;
2403 return -1;
2416 return -1;
2426 return -1;
2434 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
2443 tx_power.num_channels = geo->bg_channels;
2444 for (i = 0; i < geo->bg_channels; i++) {
2445 max_power = geo->bg[i].max_power;
2447 geo->bg[i].channel;
2449 min(max_power, priv->tx_power) : priv->tx_power;
2452 return -EIO;
2457 return -EIO;
2460 if (priv->ieee->abg_true) {
2462 tx_power.num_channels = geo->a_channels;
2464 max_power = geo->a[i].max_power;
2466 geo->a[i].channel;
2468 min(max_power, priv->tx_power) : priv->tx_power;
2471 return -EIO;
2484 return -1;
2499 return -1;
2512 return -1;
2542 return -1;
2572 udelay(p->eeprom_delay);
2609 for (i = 7; i >= 0; i--) {
2646 memcpy(mac, &priv->eeprom[EEPROM_MAC_ADDRESS], ETH_ALEN);
2652 __le16 *eeprom = (__le16 *) priv->eeprom;
2669 * bit needs region of shared SRAM needs to be non-zero.
2682 if (priv->eeprom[EEPROM_VERSION] != 0) {
2687 ipw_write8(priv, IPW_EEPROM_DATA + i, priv->eeprom[i]);
2707 while (count--)
2742 priv->sram_desc.last_cb_index = 0;
2770 for (index = 0; index < priv->sram_desc.last_cb_index; index++)
2772 &priv->sram_desc.cb_list[index]);
2830 current_cb_index = (current_cb_address - IPW_SHARED_SRAM_DMA_CONTROL) /
2857 if (priv->sram_desc.last_cb_index >= CB_NUMBER_OF_ELEMENTS_SMALL)
2858 return -1;
2860 last_cb_element = priv->sram_desc.last_cb_index;
2861 cb = &priv->sram_desc.cb_list[last_cb_element];
2862 priv->sram_desc.last_cb_index++;
2874 cb->status = control ^ src_address ^ dest_address;
2877 cb->dest_addr = dest_address;
2878 cb->source_addr = src_address;
2881 cb->control = control;
2897 size = min_t(u32, len - i * CB_MAX_LENGTH, CB_MAX_LENGTH);
2904 return -1;
2922 (int)priv->sram_desc.last_cb_index);
2924 while (current_index < priv->sram_desc.last_cb_index) {
2937 return -1;
2957 spin_lock_irqsave(&priv->ieee->lock, flags);
2958 list_for_each_safe(element, safe, &priv->ieee->network_list) {
2960 if (ether_addr_equal(network->bssid, priv->bssid)) {
2962 list_add_tail(&network->list,
2963 &priv->ieee->network_free_list);
2966 spin_unlock_irqrestore(&priv->ieee->lock, flags);
2969 /* timeout in msec, attempted in 10-msec quanta */
2982 return -ETIME;
2995 /* stop master. typical delay - 0 */
2998 /* timeout is in msec, polled in 10-msec quanta */
3003 return -1;
3043 addr < IPW_REGISTER_DOMAIN1_END; addr += 4) {
3048 memset(&priv->dino_alive, 0, sizeof(priv->dino_alive));
3098 /* alive_command_responce size is NOT multiple of 4 */
3099 __le32 response_buffer[(sizeof(priv->dino_alive) + 3) / 4];
3105 memcpy(&priv->dino_alive, response_buffer,
3106 sizeof(priv->dino_alive));
3107 if (priv->dino_alive.alive_command == 1
3108 && priv->dino_alive.ucode_valid == 1) {
3113 priv->dino_alive.software_revision,
3114 priv->dino_alive.software_revision,
3115 priv->dino_alive.device_identifier,
3116 priv->dino_alive.device_identifier,
3117 priv->dino_alive.time_stamp[0],
3118 priv->dino_alive.time_stamp[1],
3119 priv->dino_alive.time_stamp[2],
3120 priv->dino_alive.time_stamp[3],
3121 priv->dino_alive.time_stamp[4]);
3124 rc = -EINVAL;
3128 rc = -ETIME;
3140 int ret = -1;
3154 return -ENOMEM;
3160 return -ENOMEM;
3162 pool = dma_pool_create("ipw2200", &priv->pci_dev->dev, CB_MAX_LENGTH, 0,
3168 return -ENOMEM;
3175 BUG_ON(priv->sram_desc.last_cb_index > 0);
3185 chunk_len = le32_to_cpu(chunk->length);
3188 nr = (chunk_len + CB_MAX_LENGTH - 1) / CB_MAX_LENGTH;
3193 ret = -ENOMEM;
3196 size = min_t(u32, chunk_len - i * CB_MAX_LENGTH,
3206 /* dma to chunk->address, the chunk->length bytes from data +
3209 ret = ipw_fw_dma_add_buffer(priv, &phys[total_nr - nr],
3210 nr, le32_to_cpu(chunk->address),
3290 /* low-level PLL activation */
3324 spin_lock_irqsave(&priv->lock, flags);
3326 priv->status &= ~STATUS_HCMD_ACTIVE;
3327 wake_up_interruptible(&priv->wait_command_queue);
3328 priv->status &= ~(STATUS_SCANNING | STATUS_SCAN_ABORTING);
3329 wake_up_interruptible(&priv->wait_state);
3330 spin_unlock_irqrestore(&priv->lock, flags);
3352 rc = request_firmware(raw, name, &priv->pci_dev->dev);
3358 if ((*raw)->size < sizeof(*fw)) {
3359 IPW_ERROR("%s is too small (%zd)\n", name, (*raw)->size);
3360 return -EINVAL;
3363 fw = (void *)(*raw)->data;
3365 if ((*raw)->size < sizeof(*fw) + le32_to_cpu(fw->boot_size) +
3366 le32_to_cpu(fw->ucode_size) + le32_to_cpu(fw->fw_size)) {
3368 name, (*raw)->size);
3369 return -EINVAL;
3374 le32_to_cpu(fw->ver) >> 16,
3375 le32_to_cpu(fw->ver) & 0xff,
3376 (*raw)->size - sizeof(*fw));
3388 spin_lock_irqsave(&rxq->lock, flags);
3390 INIT_LIST_HEAD(&rxq->rx_free);
3391 INIT_LIST_HEAD(&rxq->rx_used);
3397 if (rxq->pool[i].skb != NULL) {
3398 dma_unmap_single(&priv->pci_dev->dev,
3399 rxq->pool[i].dma_addr,
3401 dev_kfree_skb_irq(rxq->pool[i].skb);
3402 rxq->pool[i].skb = NULL;
3404 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
3409 rxq->read = rxq->write = 0;
3410 rxq->free_count = 0;
3411 spin_unlock_irqrestore(&rxq->lock, flags);
3440 switch (priv->ieee->iw_mode) {
3442 name = "ipw2200-ibss.fw";
3446 name = "ipw2200-sniffer.fw";
3450 name = "ipw2200-bss.fw";
3455 rc = -EINVAL;
3469 fw = (void *)raw->data;
3470 boot_img = &fw->data[0];
3471 ucode_img = &fw->data[le32_to_cpu(fw->boot_size)];
3472 fw_img = &fw->data[le32_to_cpu(fw->boot_size) +
3473 le32_to_cpu(fw->ucode_size)];
3475 if (!priv->rxq)
3476 priv->rxq = ipw_rx_queue_alloc(priv);
3478 ipw_rx_queue_reset(priv, priv->rxq);
3479 if (!priv->rxq) {
3481 rc = -ENOMEM;
3488 priv->status &= ~STATUS_INT_ENABLED;
3502 IPW_NIC_SRAM_UPPER_BOUND - IPW_NIC_SRAM_LOWER_BOUND);
3505 rc = ipw_load_firmware(priv, boot_img, le32_to_cpu(fw->boot_size));
3527 rc = ipw_load_ucode(priv, ucode_img, le32_to_cpu(fw->ucode_size));
3537 rc = ipw_load_firmware(priv, fw_img, le32_to_cpu(fw->fw_size));
3565 retries--;
3569 IPW_ERROR("TODO: Handle parity error -- schedule restart?\n");
3570 rc = -EIO;
3587 priv->eeprom_delay = 1;
3598 ipw_write32(priv, IPW_RX_READ_INDEX, priv->rxq->read);
3609 if (priv->rxq) {
3610 ipw_rx_queue_free(priv, priv->rxq);
3611 priv->rxq = NULL;
3651 * ipw_rx_queue_space - Return number of free slots available in queue.
3655 int s = q->read - q->write;
3659 s -= 2;
3667 int s = q->last_used - q->first_empty;
3669 s += q->n_bd;
3670 s -= 2; /* keep some reserve to not confuse empty and full situations */
3698 q->n_bd = count;
3700 q->low_mark = q->n_bd / 4;
3701 if (q->low_mark < 4)
3702 q->low_mark = 4;
3704 q->high_mark = q->n_bd / 8;
3705 if (q->high_mark < 2)
3706 q->high_mark = 2;
3708 q->first_empty = q->last_used = 0;
3709 q->reg_r = read;
3710 q->reg_w = write;
3712 ipw_write32(priv, base, q->dma_addr);
3724 struct pci_dev *dev = priv->pci_dev;
3726 q->txb = kmalloc_array(count, sizeof(q->txb[0]), GFP_KERNEL);
3727 if (!q->txb)
3728 return -ENOMEM;
3730 q->bd =
3731 dma_alloc_coherent(&dev->dev, sizeof(q->bd[0]) * count,
3732 &q->q.dma_addr, GFP_KERNEL);
3733 if (!q->bd) {
3735 sizeof(q->bd[0]) * count);
3736 kfree(q->txb);
3737 q->txb = NULL;
3738 return -ENOMEM;
3741 ipw_queue_init(priv, &q->q, count, read, write, base, size);
3746 * Free one TFD, those at index [txq->q.last_used].
3755 struct tfd_frame *bd = &txq->bd[txq->q.last_used];
3756 struct pci_dev *dev = priv->pci_dev;
3760 if (bd->control_flags.message_type == TX_HOST_COMMAND_TYPE)
3765 if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3767 le32_to_cpu(bd->u.data.num_chunks));
3773 for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3774 dma_unmap_single(&dev->dev,
3775 le32_to_cpu(bd->u.data.chunk_ptr[i]),
3776 le16_to_cpu(bd->u.data.chunk_len[i]),
3778 if (txq->txb[txq->q.last_used]) {
3779 libipw_txb_free(txq->txb[txq->q.last_used]);
3780 txq->txb[txq->q.last_used] = NULL;
3796 struct clx2_queue *q = &txq->q;
3797 struct pci_dev *dev = priv->pci_dev;
3799 if (q->n_bd == 0)
3803 for (; q->first_empty != q->last_used;
3804 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
3809 dma_free_coherent(&dev->dev, sizeof(txq->bd[0]) * q->n_bd, txq->bd,
3810 q->dma_addr);
3811 kfree(txq->txb);
3825 ipw_queue_tx_free(priv, &priv->txq_cmd);
3828 ipw_queue_tx_free(priv, &priv->txq[0]);
3829 ipw_queue_tx_free(priv, &priv->txq[1]);
3830 ipw_queue_tx_free(priv, &priv->txq[2]);
3831 ipw_queue_tx_free(priv, &priv->txq[3]);
3837 bssid[0] = priv->mac_addr[0];
3838 bssid[1] = priv->mac_addr[1];
3839 bssid[2] = priv->mac_addr[2];
3842 get_random_bytes(&bssid[3], ETH_ALEN - 3);
3853 for (i = 0; i < priv->num_stations; i++) {
3854 if (ether_addr_equal(priv->stations[i], bssid)) {
3856 priv->missed_adhoc_beacons = 0;
3857 if (!(priv->config & CFG_STATIC_CHANNEL))
3859 priv->config &= ~CFG_ADHOC_PERSIST;
3873 memcpy(priv->stations[i], bssid, ETH_ALEN);
3876 priv->num_stations++;
3885 for (i = 0; i < priv->num_stations; i++)
3886 if (ether_addr_equal(priv->stations[i], bssid))
3896 if (priv->status & STATUS_ASSOCIATING) {
3898 schedule_work(&priv->disassociate);
3902 if (!(priv->status & STATUS_ASSOCIATED)) {
3909 priv->assoc_request.bssid,
3910 priv->assoc_request.channel);
3912 priv->status &= ~(STATUS_ASSOCIATING | STATUS_ASSOCIATED);
3913 priv->status |= STATUS_DISASSOCIATING;
3916 priv->assoc_request.assoc_type = HC_DISASSOC_QUIET;
3918 priv->assoc_request.assoc_type = HC_DISASSOCIATE;
3920 err = ipw_send_associate(priv, &priv->assoc_request);
3932 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)))
3935 netif_carrier_off(priv->net_dev);
3943 mutex_lock(&priv->mutex);
3945 mutex_unlock(&priv->mutex);
3954 if (priv->prom_net_dev && netif_running(priv->prom_net_dev)) {
3955 priv->sys_config.accept_all_data_frames = 1;
3956 priv->sys_config.accept_non_directed_frames = 1;
3957 priv->sys_config.accept_all_mgmt_bcpr = 1;
3958 priv->sys_config.accept_all_mgmt_frames = 1;
4007 "DSSS-OFDM operation"},
4035 return ((depth-1)*prev_avg + val)/depth;
4040 avg->sum -= avg->entries[avg->pos];
4041 avg->sum += val;
4042 avg->entries[avg->pos++] = val;
4043 if (unlikely(avg->pos == AVG_ENTRIES)) {
4044 avg->init = 1;
4045 avg->pos = 0;
4051 if (!unlikely(avg->init)) {
4052 if (avg->pos)
4053 return avg->sum / avg->pos;
4057 return avg->sum / AVG_ENTRIES;
4064 priv->quality = 0;
4066 average_init(&priv->average_missed_beacons);
4067 priv->exp_avg_rssi = -60;
4068 priv->exp_avg_noise = -85 + 0x100;
4070 priv->last_rate = 0;
4071 priv->last_missed_beacons = 0;
4072 priv->last_rx_packets = 0;
4073 priv->last_tx_packets = 0;
4074 priv->last_tx_failures = 0;
4079 &priv->last_rx_err, &len);
4081 &priv->last_tx_failures, &len);
4084 priv->missed_adhoc_beacons = 0;
4085 priv->missed_beacons = 0;
4086 priv->tx_packets = 0;
4087 priv->rx_packets = 0;
4094 u32 mask = priv->rates_mask;
4097 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
4132 if (priv->ieee->mode == IEEE_B)
4143 if (!(priv->status & STATUS_ASSOCIATED))
4146 if (priv->tx_packets > IPW_REAL_RATE_RX_PACKET_THRESHOLD) {
4199 if (!(priv->status & STATUS_ASSOCIATED)) {
4200 priv->quality = 0;
4206 &priv->missed_beacons, &len);
4207 missed_beacons_delta = priv->missed_beacons - priv->last_missed_beacons;
4208 priv->last_missed_beacons = priv->missed_beacons;
4209 if (priv->assoc_request.beacon_interval) {
4211 (HZ * le16_to_cpu(priv->assoc_request.beacon_interval)) /
4216 average_add(&priv->average_missed_beacons, missed_beacons_percent);
4219 rx_err_delta = rx_err - priv->last_rx_err;
4220 priv->last_rx_err = rx_err;
4223 tx_failures_delta = tx_failures - priv->last_tx_failures;
4224 priv->last_tx_failures = tx_failures;
4226 rx_packets_delta = priv->rx_packets - priv->last_rx_packets;
4227 priv->last_rx_packets = priv->rx_packets;
4229 tx_packets_delta = priv->tx_packets - priv->last_tx_packets;
4230 priv->last_tx_packets = priv->tx_packets;
4237 * RSSI: 100% = > -50, 0% = < -80
4244 beacon_quality = 100 - missed_beacons_percent;
4248 beacon_quality = (beacon_quality - BEACON_THRESHOLD) * 100 /
4249 (100 - BEACON_THRESHOLD);
4253 priv->last_rate = ipw_get_current_rate(priv);
4255 rate_quality = priv->last_rate * 40 / max_rate + 60;
4257 rate_quality, priv->last_rate / 1000000);
4260 rx_quality = 100 - (rx_err_delta * 100) /
4268 tx_quality = 100 - (tx_failures_delta * 100) /
4275 rssi = priv->exp_avg_rssi;
4278 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4279 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) -
4280 (priv->ieee->perfect_rssi - rssi) *
4281 (15 * (priv->ieee->perfect_rssi - priv->ieee->worst_rssi) +
4282 62 * (priv->ieee->perfect_rssi - rssi))) /
4283 ((priv->ieee->perfect_rssi - priv->ieee->worst_rssi) *
4284 (priv->ieee->perfect_rssi - priv->ieee->worst_rssi));
4313 priv->quality = quality;
4315 schedule_delayed_work(&priv->gather_stats, IPW_STATS_INTERVAL);
4322 mutex_lock(&priv->mutex);
4324 mutex_unlock(&priv->mutex);
4328 * 1st missed -> roaming_threshold, just wait, don't do any scan/roam.
4329 * roaming_threshold -> disassociate_threshold, scan and roam for better signal.
4335 priv->notif_missed_beacons = missed_count;
4337 if (missed_count > priv->disassociate_threshold &&
4338 priv->status & STATUS_ASSOCIATED) {
4344 "Missed beacon: %d - disassociate\n", missed_count);
4345 priv->status &= ~STATUS_ROAMING;
4346 if (priv->status & STATUS_SCANNING) {
4350 schedule_work(&priv->abort_scan);
4353 schedule_work(&priv->disassociate);
4357 if (priv->status & STATUS_ROAMING) {
4361 "Missed beacon: %d - roam in progress\n",
4367 (missed_count > priv->roaming_threshold &&
4368 missed_count <= priv->disassociate_threshold)) {
4374 "Missed beacon: %d - initiate "
4376 if (!(priv->status & STATUS_ROAMING)) {
4377 priv->status |= STATUS_ROAMING;
4378 if (!(priv->status & STATUS_SCANNING))
4379 schedule_delayed_work(&priv->request_scan, 0);
4384 if (priv->status & STATUS_SCANNING &&
4387 * stuck (only if we aren't roaming --
4392 schedule_work(&priv->abort_scan);
4407 wireless_send_event(priv->net_dev, SIOCGIWSCAN, &wrqu, NULL);
4412 /* Only userspace-requested scan completion events go out immediately */
4413 if (!priv->user_requested_scan) {
4414 schedule_delayed_work(&priv->scan_event,
4417 priv->user_requested_scan = 0;
4418 mod_delayed_work(system_percpu_wq, &priv->scan_event, 0);
4429 u16 size = le16_to_cpu(notif->size);
4431 IPW_DEBUG_NOTIF("type = %i (%d bytes)\n", notif->subtype, size);
4433 switch (notif->subtype) {
4435 struct notif_association *assoc = ¬if->u.assoc;
4437 switch (assoc->state) {
4442 priv->essid_len, priv->essid,
4443 priv->bssid);
4445 switch (priv->ieee->iw_mode) {
4447 memcpy(priv->ieee->bssid,
4448 priv->bssid, ETH_ALEN);
4452 memcpy(priv->ieee->bssid,
4453 priv->bssid, ETH_ALEN);
4456 priv->num_stations = 0;
4461 &priv->adhoc_check,
4462 le16_to_cpu(priv->
4468 priv->status &= ~STATUS_ASSOCIATING;
4469 priv->status |= STATUS_ASSOCIATED;
4470 schedule_work(&priv->system_config);
4474 le16_to_cpu(((struct ieee80211_hdr *)(x))->frame_control))
4475 if ((priv->status & STATUS_AUTH) &&
4476 (IPW_GET_PACKET_STYPE(¬if->u.raw)
4486 .len = size - 1,
4492 libipw_rx_mgt(priv->
4497 ¬if->u.raw, &stats);
4502 schedule_work(&priv->link_up);
4508 if (priv->
4512 = ¬if->u.auth;
4516 "deauthenticated: '%*pE' %pM: (0x%04X) - %s\n",
4517 priv->essid_len,
4518 priv->essid,
4519 priv->bssid,
4520 le16_to_cpu(auth->status),
4523 (auth->status)));
4525 priv->status &=
4530 schedule_work(&priv->link_down);
4537 priv->essid_len, priv->essid,
4538 priv->bssid);
4543 if (priv->status & STATUS_AUTH) {
4550 *)¬if->u.raw;
4555 le16_to_cpu(resp->status),
4558 (resp->status)));
4564 priv->essid_len, priv->essid,
4565 priv->bssid);
4567 priv->status &=
4571 if (priv->assoc_network
4572 && (priv->assoc_network->
4578 schedule_work(&priv->link_down);
4588 assoc->state);
4596 struct notif_authenticate *auth = ¬if->u.auth;
4597 switch (auth->state) {
4601 priv->essid_len, priv->essid,
4602 priv->bssid);
4603 priv->status |= STATUS_AUTH;
4607 if (priv->status & STATUS_AUTH) {
4611 le16_to_cpu(auth->status),
4613 (auth->
4619 priv->essid_len, priv->essid,
4620 priv->bssid);
4622 priv->status &= ~(STATUS_ASSOCIATING |
4626 schedule_work(&priv->link_down);
4675 IPW_DEBUG_NOTIF("auth: failure - %d\n",
4676 auth->state);
4684 ¬if->u.channel_result;
4688 x->channel_num);
4698 struct notif_scan_complete *x = ¬if->u.scan_complete;
4702 "%d status\n", x->scan_type,
4703 x->num_channels, x->status);
4710 priv->status &=
4713 wake_up_interruptible(&priv->wait_state);
4714 cancel_delayed_work(&priv->scan_check);
4716 if (priv->status & STATUS_EXIT_PENDING)
4719 priv->ieee->scans++;
4722 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
4723 priv->status |= STATUS_SCAN_FORCED;
4724 schedule_delayed_work(&priv->request_scan, 0);
4727 priv->status &= ~STATUS_SCAN_FORCED;
4731 if (priv->status & STATUS_DIRECT_SCAN_PENDING)
4732 schedule_delayed_work(&priv->request_direct_scan, 0);
4734 if (!(priv->status & (STATUS_ASSOCIATED |
4738 schedule_work(&priv->associate);
4739 else if (priv->status & STATUS_ROAMING) {
4740 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4745 schedule_work(&priv->roam);
4748 priv->status &= ~STATUS_ROAMING;
4749 } else if (priv->status & STATUS_SCAN_PENDING)
4750 schedule_delayed_work(&priv->request_scan, 0);
4751 else if (priv->config & CFG_BACKGROUND_SCAN
4752 && priv->status & STATUS_ASSOCIATED)
4753 schedule_delayed_work(&priv->request_scan,
4765 if (x->status == SCAN_COMPLETED_STATUS_COMPLETE)
4771 struct notif_frag_length *x = ¬if->u.frag_len;
4775 le16_to_cpu(x->frag_length));
4785 ¬if->u.link_deterioration;
4790 x->silence_notification_type,
4791 x->silence_count);
4792 memcpy(&priv->last_link_deterioration, x,
4804 if (priv->hcmd
4805 && priv->hcmd->cmd != HOST_CMD_DINO_CONFIG)
4812 struct notif_beacon_state *x = ¬if->u.beacon_state;
4820 if (le32_to_cpu(x->state) ==
4823 le32_to_cpu(x->
4830 struct notif_tgi_tx_key *x = ¬if->u.tgi_tx_key;
4834 x->key_state, x->security_type,
4835 x->station_index);
4846 struct notif_calibration *x = ¬if->u.calibration;
4849 memcpy(&priv->calib, x, sizeof(*x));
4862 priv->exp_avg_noise =
4863 exponential_average(priv->exp_avg_noise,
4864 (u8) (le32_to_cpu(notif->u.noise.value) & 0xff),
4878 notif->subtype, notif->flags, size);
4895 rc = ipw_queue_tx_init(priv, &priv->txq_cmd, nTxCmd,
4905 rc = ipw_queue_tx_init(priv, &priv->txq[0], nTx,
4913 rc = ipw_queue_tx_init(priv, &priv->txq[1], nTx,
4921 rc = ipw_queue_tx_init(priv, &priv->txq[2], nTx,
4929 rc = ipw_queue_tx_init(priv, &priv->txq[3], nTx,
4938 priv->rx_bufs_min = 0;
4939 priv->rx_pend_max = 0;
4965 struct clx2_queue *q = &txq->q;
4967 hw_tail = ipw_read32(priv, q->reg_r);
4968 if (hw_tail >= q->n_bd) {
4970 ("Read index for DMA queue (%d) is out of range [0-%d)\n",
4971 hw_tail, q->n_bd);
4974 for (; q->last_used != hw_tail;
4975 q->last_used = ipw_queue_inc_wrap(q->last_used, q->n_bd)) {
4977 priv->tx_packets++;
4980 if ((ipw_tx_queue_space(q) > q->low_mark) &&
4982 netif_wake_queue(priv->net_dev);
4983 used = q->first_empty - q->last_used;
4985 used += q->n_bd;
4993 struct clx2_tx_queue *txq = &priv->txq_cmd;
4994 struct clx2_queue *q = &txq->q;
4999 return -EBUSY;
5002 tfd = &txq->bd[q->first_empty];
5003 txq->txb[q->first_empty] = NULL;
5006 tfd->control_flags.message_type = TX_HOST_COMMAND_TYPE;
5007 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
5008 priv->hcmd_seq++;
5009 tfd->u.cmd.index = hcmd;
5010 tfd->u.cmd.length = len;
5011 memcpy(tfd->u.cmd.payload, buf, len);
5012 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
5013 ipw_write32(priv, q->reg_w, q->first_empty);
5030 * to -- the driver can read up to (but not including) this position and get
5034 * The WRITE index maps to the last position the driver has read from -- the
5037 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
5041 * INDEX position, and WRITE to the last (READ - 1 wrapped)
5049 * + A list of pre-allocated SKBs is stored in ipw->rxq->rx_free. When
5050 * ipw->rxq->free_count drops to or below RX_LOW_WATERMARK, work is scheduled
5051 * to replensish the ipw->rxq->rx_free.
5053 * ipw->rxq is replenished and the READ INDEX is updated (updating the
5056 * detached from the ipw->rxq. The driver 'processed' index is updated.
5057 * + The Host/Firmware ipw->rxq is replenished at tasklet time from the rx_free
5058 * list. If there are no allocated buffers in ipw->rxq->rx_free, the READ
5059 * INDEX is not incremented and ipw->status(RX_STALLED) is set. If there
5073 * -- enable interrupts --
5074 * ISR - ipw_rx() Detach ipw_rx_mem_buffers from pool up to the
5085 * and we have free pre-allocated buffers, fill the ranks as much
5094 struct ipw_rx_queue *rxq = priv->rxq;
5100 spin_lock_irqsave(&rxq->lock, flags);
5101 write = rxq->write;
5102 while ((ipw_rx_queue_space(rxq) > 0) && (rxq->free_count)) {
5103 element = rxq->rx_free.next;
5107 ipw_write32(priv, IPW_RFDS_TABLE_LOWER + rxq->write * RFD_SIZE,
5108 rxb->dma_addr);
5109 rxq->queue[rxq->write] = rxb;
5110 rxq->write = (rxq->write + 1) % RX_QUEUE_SIZE;
5111 rxq->free_count--;
5113 spin_unlock_irqrestore(&rxq->lock, flags);
5115 /* If the pre-allocated buffer pool is dropping low, schedule to
5117 if (rxq->free_count <= RX_LOW_WATERMARK)
5118 schedule_work(&priv->rx_replenish);
5121 if (write != rxq->write)
5122 ipw_write32(priv, IPW_RX_WRITE_INDEX, rxq->write);
5134 struct ipw_rx_queue *rxq = priv->rxq;
5139 spin_lock_irqsave(&rxq->lock, flags);
5140 while (!list_empty(&rxq->rx_used)) {
5141 element = rxq->rx_used.next;
5143 rxb->skb = alloc_skb(IPW_RX_BUF_SIZE, GFP_ATOMIC);
5144 if (!rxb->skb) {
5146 priv->net_dev->name);
5147 /* We don't reschedule replenish work here -- we will
5154 rxb->dma_addr =
5155 dma_map_single(&priv->pci_dev->dev, rxb->skb->data,
5158 list_add_tail(&rxb->list, &rxq->rx_free);
5159 rxq->free_count++;
5161 spin_unlock_irqrestore(&rxq->lock, flags);
5170 mutex_lock(&priv->mutex);
5172 mutex_unlock(&priv->mutex);
5188 if (rxq->pool[i].skb != NULL) {
5189 dma_unmap_single(&priv->pci_dev->dev,
5190 rxq->pool[i].dma_addr,
5192 dev_kfree_skb(rxq->pool[i].skb);
5209 spin_lock_init(&rxq->lock);
5210 INIT_LIST_HEAD(&rxq->rx_free);
5211 INIT_LIST_HEAD(&rxq->rx_used);
5215 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
5219 rxq->read = rxq->write = 0;
5220 rxq->free_count = 0;
5231 return priv->rates_mask & LIBIPW_OFDM_RATE_6MB_MASK ?
5234 return priv->rates_mask & LIBIPW_OFDM_RATE_9MB_MASK ?
5237 return priv->
5240 return priv->
5243 return priv->
5246 return priv->
5249 return priv->
5252 return priv->
5262 return priv->rates_mask & LIBIPW_CCK_RATE_1MB_MASK ? 1 : 0;
5264 return priv->rates_mask & LIBIPW_CCK_RATE_2MB_MASK ? 1 : 0;
5266 return priv->rates_mask & LIBIPW_CCK_RATE_5MB_MASK ? 1 : 0;
5268 return priv->rates_mask & LIBIPW_CCK_RATE_11MB_MASK ? 1 : 0;
5278 return priv->rates_mask & LIBIPW_OFDM_RATE_6MB_MASK ? 1 : 0;
5280 return priv->rates_mask & LIBIPW_OFDM_RATE_9MB_MASK ? 1 : 0;
5282 return priv->rates_mask & LIBIPW_OFDM_RATE_12MB_MASK ? 1 : 0;
5284 return priv->rates_mask & LIBIPW_OFDM_RATE_18MB_MASK ? 1 : 0;
5286 return priv->rates_mask & LIBIPW_OFDM_RATE_24MB_MASK ? 1 : 0;
5288 return priv->rates_mask & LIBIPW_OFDM_RATE_36MB_MASK ? 1 : 0;
5290 return priv->rates_mask & LIBIPW_OFDM_RATE_48MB_MASK ? 1 : 0;
5292 return priv->rates_mask & LIBIPW_OFDM_RATE_54MB_MASK ? 1 : 0;
5305 num_rates = min(network->rates_len, (u8) IPW_MAX_RATES);
5306 rates->num_rates = 0;
5308 if (!ipw_is_rate_in_mask(priv, network->mode,
5309 network->rates[i])) {
5311 if (network->rates[i] & LIBIPW_BASIC_RATE_MASK) {
5314 network->rates[i]);
5315 rates->supported_rates[rates->num_rates++] =
5316 network->rates[i];
5321 network->rates[i], priv->rates_mask);
5325 rates->supported_rates[rates->num_rates++] = network->rates[i];
5328 num_rates = min(network->rates_ex_len,
5329 (u8) (IPW_MAX_RATES - num_rates));
5331 if (!ipw_is_rate_in_mask(priv, network->mode,
5332 network->rates_ex[i])) {
5333 if (network->rates_ex[i] & LIBIPW_BASIC_RATE_MASK) {
5336 network->rates_ex[i]);
5337 rates->supported_rates[rates->num_rates++] =
5338 network->rates[i];
5343 network->rates_ex[i], priv->rates_mask);
5347 rates->supported_rates[rates->num_rates++] =
5348 network->rates_ex[i];
5358 for (i = 0; i < src->num_rates; i++)
5359 dest->supported_rates[i] = src->supported_rates[i];
5360 dest->num_rates = src->num_rates;
5364 * mask should ever be used -- right now all callers to add the scan rates are
5373 rates->supported_rates[rates->num_rates++] =
5377 rates->supported_rates[rates->num_rates++] =
5381 rates->supported_rates[rates->num_rates++] = basic_mask |
5385 rates->supported_rates[rates->num_rates++] = basic_mask |
5396 rates->supported_rates[rates->num_rates++] = basic_mask |
5400 rates->supported_rates[rates->num_rates++] =
5404 rates->supported_rates[rates->num_rates++] = basic_mask |
5408 rates->supported_rates[rates->num_rates++] =
5412 rates->supported_rates[rates->num_rates++] = basic_mask |
5416 rates->supported_rates[rates->num_rates++] =
5420 rates->supported_rates[rates->num_rates++] =
5424 rates->supported_rates[rates->num_rates++] =
5442 if ((priv->ieee->iw_mode == IW_MODE_ADHOC &&
5443 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5445 network->ssid_len, network->ssid,
5446 network->bssid);
5453 if ((network->ssid_len != match->network->ssid_len) ||
5454 memcmp(network->ssid, match->network->ssid,
5455 network->ssid_len)) {
5456 IPW_DEBUG_MERGE("Network '%*pE (%pM)' excluded because of non-network ESSID.\n",
5457 network->ssid_len, network->ssid,
5458 network->bssid);
5464 if ((priv->config & CFG_STATIC_ESSID) &&
5465 ((network->ssid_len != priv->essid_len) ||
5466 memcmp(network->ssid, priv->essid,
5467 min(network->ssid_len, priv->essid_len)))) {
5469 network->ssid_len, network->ssid,
5470 network->bssid, priv->essid_len,
5471 priv->essid);
5479 if (network->time_stamp[0] < match->network->time_stamp[0]) {
5481 match->network->ssid_len, match->network->ssid);
5483 } else if (network->time_stamp[1] < match->network->time_stamp[1]) {
5485 match->network->ssid_len, match->network->ssid);
5490 if (priv->ieee->scan_age != 0 &&
5491 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5493 network->ssid_len, network->ssid,
5494 network->bssid,
5495 jiffies_to_msecs(jiffies -
5496 network->last_scanned));
5500 if ((priv->config & CFG_STATIC_CHANNEL) &&
5501 (network->channel != priv->channel)) {
5503 network->ssid_len, network->ssid,
5504 network->bssid,
5505 network->channel, priv->channel);
5510 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5511 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5513 network->ssid_len, network->ssid,
5514 network->bssid,
5515 priv->
5517 network->
5523 if (ether_addr_equal(network->bssid, priv->bssid)) {
5525 network->ssid_len, network->ssid,
5526 network->bssid, priv->bssid);
5531 if (!libipw_is_valid_mode(priv->ieee, network->mode)) {
5533 network->ssid_len, network->ssid,
5534 network->bssid);
5542 network->ssid_len, network->ssid,
5543 network->bssid);
5549 network->ssid_len, network->ssid,
5550 network->bssid);
5559 ipw_copy_rates(&match->rates, &rates);
5560 match->network = network;
5562 network->ssid_len, network->ssid, network->bssid);
5573 .network = priv->assoc_network
5576 if ((priv->status & STATUS_ASSOCIATED) &&
5577 (priv->ieee->iw_mode == IW_MODE_ADHOC)) {
5578 /* First pass through ROAM process -- look for a better
5582 spin_lock_irqsave(&priv->ieee->lock, flags);
5583 list_for_each_entry(network, &priv->ieee->network_list, list) {
5584 if (network != priv->assoc_network)
5588 spin_unlock_irqrestore(&priv->ieee->lock, flags);
5590 if (match.network == priv->assoc_network) {
5596 mutex_lock(&priv->mutex);
5597 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
5599 priv->essid_len, priv->essid);
5604 priv->assoc_network = match.network;
5605 mutex_unlock(&priv->mutex);
5618 if ((priv->ieee->iw_mode == IW_MODE_INFRA &&
5619 !(network->capability & WLAN_CAPABILITY_ESS)) ||
5620 (priv->ieee->iw_mode == IW_MODE_ADHOC &&
5621 !(network->capability & WLAN_CAPABILITY_IBSS))) {
5623 network->ssid_len, network->ssid,
5624 network->bssid);
5631 if ((network->ssid_len != match->network->ssid_len) ||
5632 memcmp(network->ssid, match->network->ssid,
5633 network->ssid_len)) {
5634 IPW_DEBUG_ASSOC("Network '%*pE (%pM)' excluded because of non-network ESSID.\n",
5635 network->ssid_len, network->ssid,
5636 network->bssid);
5642 if ((priv->config & CFG_STATIC_ESSID) &&
5643 ((network->ssid_len != priv->essid_len) ||
5644 memcmp(network->ssid, priv->essid,
5645 min(network->ssid_len, priv->essid_len)))) {
5647 network->ssid_len, network->ssid,
5648 network->bssid, priv->essid_len,
5649 priv->essid);
5656 if (match->network && match->network->stats.rssi > network->stats.rssi) {
5658 network->ssid_len, network->ssid,
5659 network->bssid, match->network->ssid_len,
5660 match->network->ssid, match->network->bssid);
5666 if (network->last_associate &&
5667 time_after(network->last_associate + (HZ * 3UL), jiffies)) {
5669 network->ssid_len, network->ssid,
5670 network->bssid,
5671 jiffies_to_msecs(jiffies -
5672 network->last_associate));
5677 if (priv->ieee->scan_age != 0 &&
5678 time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
5680 network->ssid_len, network->ssid,
5681 network->bssid,
5682 jiffies_to_msecs(jiffies -
5683 network->last_scanned));
5687 if ((priv->config & CFG_STATIC_CHANNEL) &&
5688 (network->channel != priv->channel)) {
5690 network->ssid_len, network->ssid,
5691 network->bssid,
5692 network->channel, priv->channel);
5697 if (((priv->capability & CAP_PRIVACY_ON) ? 1 : 0) !=
5698 ((network->capability & WLAN_CAPABILITY_PRIVACY) ? 1 : 0)) {
5700 network->ssid_len, network->ssid,
5701 network->bssid,
5702 priv->capability & CAP_PRIVACY_ON ? "on" :
5704 network->capability &
5709 if ((priv->config & CFG_STATIC_BSSID) &&
5710 !ether_addr_equal(network->bssid, priv->bssid)) {
5712 network->ssid_len, network->ssid,
5713 network->bssid, priv->bssid);
5718 if (!libipw_is_valid_mode(priv->ieee, network->mode)) {
5720 network->ssid_len, network->ssid,
5721 network->bssid);
5726 if (!libipw_is_valid_channel(priv->ieee, network->channel)) {
5728 network->ssid_len, network->ssid,
5729 network->bssid);
5737 network->ssid_len, network->ssid,
5738 network->bssid);
5744 network->ssid_len, network->ssid,
5745 network->bssid);
5754 ipw_copy_rates(&match->rates, &rates);
5755 match->network = network;
5758 network->ssid_len, network->ssid, network->bssid);
5766 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
5772 * comes to creating a new ad-hoc network, we have tell the FW
5776 * chossen band. Attempting to create a new ad-hoc network
5781 switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
5783 network->mode = IEEE_A;
5784 i = libipw_channel_to_index(priv->ieee, priv->channel);
5785 BUG_ON(i == -1);
5786 if (geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY) {
5788 priv->channel = geo->a[0].channel;
5793 if (priv->ieee->mode & IEEE_G)
5794 network->mode = IEEE_G;
5796 network->mode = IEEE_B;
5797 i = libipw_channel_to_index(priv->ieee, priv->channel);
5798 BUG_ON(i == -1);
5799 if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY) {
5801 priv->channel = geo->bg[0].channel;
5807 if (priv->ieee->mode & IEEE_A) {
5808 network->mode = IEEE_A;
5809 priv->channel = geo->a[0].channel;
5810 } else if (priv->ieee->mode & IEEE_G) {
5811 network->mode = IEEE_G;
5812 priv->channel = geo->bg[0].channel;
5814 network->mode = IEEE_B;
5815 priv->channel = geo->bg[0].channel;
5820 network->channel = priv->channel;
5821 priv->config |= CFG_ADHOC_PERSIST;
5822 ipw_create_bssid(priv, network->bssid);
5823 network->ssid_len = priv->essid_len;
5824 memcpy(network->ssid, priv->essid, priv->essid_len);
5825 memset(&network->stats, 0, sizeof(network->stats));
5826 network->capability = WLAN_CAPABILITY_IBSS;
5827 if (!(priv->config & CFG_PREAMBLE_LONG))
5828 network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
5829 if (priv->capability & CAP_PRIVACY_ON)
5830 network->capability |= WLAN_CAPABILITY_PRIVACY;
5831 network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
5832 memcpy(network->rates, priv->rates.supported_rates, network->rates_len);
5833 network->rates_ex_len = priv->rates.num_rates - network->rates_len;
5834 memcpy(network->rates_ex,
5835 &priv->rates.supported_rates[network->rates_len],
5836 network->rates_ex_len);
5837 network->last_scanned = 0;
5838 network->flags = 0;
5839 network->last_associate = 0;
5840 network->time_stamp[0] = 0;
5841 network->time_stamp[1] = 0;
5842 network->beacon_interval = 100; /* Default */
5843 network->listen_interval = 10; /* Default */
5844 network->atim_window = 0; /* Default */
5845 network->wpa_ie_len = 0;
5846 network->rsn_ie_len = 0;
5853 if (!(priv->ieee->sec.flags & (1 << index)))
5857 memcpy(key.key, priv->ieee->sec.keys[index], SCM_TEMPORAL_KEY_LENGTH);
5878 for (i = 0; i < 4; i++) {
5880 if (!(priv->ieee->sec.flags & (1 << i))) {
5885 key.key_size = priv->ieee->sec.key_sizes[i];
5886 memcpy(key.key, priv->ieee->sec.keys[i], key.key_size);
5894 if (priv->ieee->host_encrypt)
5899 priv->sys_config.disable_unicast_decryption = 0;
5900 priv->ieee->host_decrypt = 0;
5903 priv->sys_config.disable_unicast_decryption = 1;
5904 priv->ieee->host_decrypt = 1;
5907 priv->sys_config.disable_unicast_decryption = 0;
5908 priv->ieee->host_decrypt = 0;
5911 priv->sys_config.disable_unicast_decryption = 1;
5920 if (priv->ieee->host_encrypt)
5925 priv->sys_config.disable_multicast_decryption = 0;
5928 priv->sys_config.disable_multicast_decryption = 1;
5931 priv->sys_config.disable_multicast_decryption = 0;
5934 priv->sys_config.disable_multicast_decryption = 1;
5943 switch (priv->ieee->sec.level) {
5945 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5948 priv->ieee->sec.active_key);
5950 if (!priv->ieee->host_mc_decrypt)
5954 if (priv->ieee->sec.flags & SEC_ACTIVE_KEY)
5957 priv->ieee->sec.active_key);
5961 ipw_set_hw_decrypt_unicast(priv, priv->ieee->sec.level);
5962 ipw_set_hw_decrypt_multicast(priv, priv->ieee->sec.level);
5974 if (priv->missed_adhoc_beacons++ > priv->disassociate_threshold &&
5975 !(priv->config & CFG_ADHOC_PERSIST)) {
5978 "Missed beacon: %d - disassociate\n",
5979 priv->missed_adhoc_beacons);
5985 schedule_delayed_work(&priv->adhoc_check,
5986 le16_to_cpu(priv->assoc_request.beacon_interval));
5993 mutex_lock(&priv->mutex);
5995 mutex_unlock(&priv->mutex);
6001 "[CFG 0x%08X]\n", priv->config);
6002 if (priv->config & CFG_STATIC_CHANNEL)
6003 IPW_DEBUG_INFO("Channel locked to %d\n", priv->channel);
6006 if (priv->config & CFG_STATIC_ESSID)
6008 priv->essid_len, priv->essid);
6011 if (priv->config & CFG_STATIC_BSSID)
6012 IPW_DEBUG_INFO("BSSID locked to %pM\n", priv->bssid);
6015 if (priv->capability & CAP_PRIVACY_ON)
6019 IPW_DEBUG_INFO("RATE MASK: 0x%08X\n", priv->rates_mask);
6028 u16 new_tx_rates = priv->rates_mask;
6033 switch (priv->ieee->freq_band) {
6036 if (priv->rates_mask & ~LIBIPW_OFDM_RATES_MASK) {
6047 default: /* 2.4Ghz or Mixed */
6098 if (priv->status & STATUS_SCAN_ABORTING) {
6102 priv->status |= STATUS_SCAN_ABORTING;
6117 geo = libipw_get_geo(priv->ieee);
6119 if (priv->ieee->freq_band & LIBIPW_52GHZ_BAND) {
6121 for (i = 0; i < geo->a_channels; i++) {
6122 if ((priv->status & STATUS_ASSOCIATED) &&
6123 geo->a[i].channel == priv->channel)
6126 scan->channels_list[channel_index] = geo->a[i].channel;
6128 geo->a[i].
6135 scan->channels_list[start] = (u8) (IPW_A_MODE << 6) |
6136 (channel_index - start);
6141 if (priv->ieee->freq_band & LIBIPW_24GHZ_BAND) {
6143 if (priv->config & CFG_SPEED_SCAN) {
6151 while (channel_index < IPW_SCAN_CHANNELS - 1) {
6153 priv->speed_scan[priv->speed_scan_pos];
6155 priv->speed_scan_pos = 0;
6156 channel = priv->speed_scan[0];
6158 if ((priv->status & STATUS_ASSOCIATED) &&
6159 channel == priv->channel) {
6160 priv->speed_scan_pos++;
6169 if (channels[channel - 1] != 0)
6172 channels[channel - 1] = 1;
6173 priv->speed_scan_pos++;
6175 scan->channels_list[channel_index] = channel;
6177 libipw_channel_to_index(priv->ieee, channel);
6179 geo->bg[index].
6186 for (i = 0; i < geo->bg_channels; i++) {
6187 if ((priv->status & STATUS_ASSOCIATED) &&
6188 geo->bg[i].channel == priv->channel)
6191 scan->channels_list[channel_index] =
6192 geo->bg[i].channel;
6194 geo->bg[i].
6203 scan->channels_list[start] = (u8) (IPW_B_MODE << 6) |
6204 (channel_index - start);
6216 if (priv->status & STATUS_ASSOCIATED
6217 && priv->assoc_network->beacon_interval > 10)
6218 return priv->assoc_network->beacon_interval - 10;
6228 if (!(priv->status & STATUS_INIT) ||
6229 (priv->status & STATUS_EXIT_PENDING))
6232 mutex_lock(&priv->mutex);
6234 if (direct && (priv->direct_scan_ssid_len == 0)) {
6236 priv->status &= ~STATUS_DIRECT_SCAN_PENDING;
6240 if (priv->status & STATUS_SCANNING) {
6242 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6247 if (!(priv->status & STATUS_SCAN_FORCED) &&
6248 priv->status & STATUS_SCAN_ABORTING) {
6250 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6255 if (priv->status & STATUS_RF_KILL_MASK) {
6257 priv->status |= direct ? STATUS_DIRECT_SCAN_PENDING :
6263 scan.full_scan_index = cpu_to_le32(libipw_get_scans(priv->ieee));
6275 if (priv->config & CFG_SPEED_SCAN)
6290 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
6294 switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
6297 channel = priv->channel;
6302 channel = priv->channel;
6318 * set a small dwell_time here and just keep re-issuing
6331 err = ipw_send_ssid(priv, priv->direct_scan_ssid,
6332 priv->direct_scan_ssid_len);
6340 } else if ((priv->status & STATUS_ROAMING)
6341 || (!(priv->status & STATUS_ASSOCIATED)
6342 && (priv->config & CFG_STATIC_ESSID)
6344 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
6367 priv->status |= STATUS_SCANNING;
6369 priv->status &= ~STATUS_DIRECT_SCAN_PENDING;
6370 priv->direct_scan_ssid_len = 0;
6372 priv->status &= ~STATUS_SCAN_PENDING;
6374 schedule_delayed_work(&priv->scan_check, IPW_SCAN_CHECK_WATCHDOG);
6376 mutex_unlock(&priv->mutex);
6405 mutex_lock(&priv->mutex);
6407 mutex_unlock(&priv->mutex);
6414 priv->ieee->wpa_enabled = value;
6420 struct libipw_device *ieee = priv->ieee;
6428 ieee->open_wep = 0;
6431 ieee->open_wep = 1;
6434 ieee->open_wep = 1;
6436 return -EINVAL;
6438 if (ieee->set_security)
6439 ieee->set_security(ieee->dev, &sec);
6441 ret = -EOPNOTSUPP;
6463 * WE-18 support
6470 strcpy(wrqu->name, "IEEE 802.11");
6480 struct libipw_device *ieee = priv->ieee;
6484 if (wrqu->data.length > MAX_WPA_IE_LEN ||
6485 (wrqu->data.length && extra == NULL))
6486 return -EINVAL;
6488 if (wrqu->data.length) {
6489 buf = kmemdup(extra, wrqu->data.length, GFP_KERNEL);
6491 err = -ENOMEM;
6495 kfree(ieee->wpa_ie);
6496 ieee->wpa_ie = buf;
6497 ieee->wpa_ie_len = wrqu->data.length;
6499 kfree(ieee->wpa_ie);
6500 ieee->wpa_ie = NULL;
6501 ieee->wpa_ie_len = 0;
6504 ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
6515 struct libipw_device *ieee = priv->ieee;
6518 if (ieee->wpa_ie_len == 0 || ieee->wpa_ie == NULL) {
6519 wrqu->data.length = 0;
6523 if (wrqu->data.length < ieee->wpa_ie_len) {
6524 err = -E2BIG;
6528 wrqu->data.length = ieee->wpa_ie_len;
6529 memcpy(extra, ieee->wpa_ie, ieee->wpa_ie_len);
6548 return -1;
6558 struct libipw_device *ieee = priv->ieee;
6559 struct iw_param *param = &wrqu->param;
6564 switch (param->flags & IW_AUTH_INDEX) {
6569 wext_cipher2level(param->value));
6573 wext_cipher2level(param->value));
6582 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
6583 if (!crypt || !crypt->ops->set_flags || !crypt->ops->get_flags)
6586 flags = crypt->ops->get_flags(crypt->priv);
6588 if (param->value)
6593 crypt->ops->set_flags(flags, crypt->priv);
6605 * used, drop_unencrypted is set to false, else true -- we
6611 .enabled = param->value,
6613 priv->ieee->drop_unencrypted = param->value;
6617 if (!param->value) {
6624 if (priv->ieee->set_security)
6625 priv->ieee->set_security(priv->ieee->dev, &sec);
6630 ret = ipw_wpa_set_auth_algs(priv, param->value);
6634 ret = ipw_wpa_enable(priv, param->value);
6639 ieee->ieee802_1x = param->value;
6643 ieee->privacy_invoked = param->value;
6647 return -EOPNOTSUPP;
6658 struct libipw_device *ieee = priv->ieee;
6660 struct iw_param *param = &wrqu->param;
6662 switch (param->flags & IW_AUTH_INDEX) {
6670 return -EOPNOTSUPP;
6673 crypt = priv->ieee->crypt_info.crypt[priv->ieee->crypt_info.tx_keyidx];
6674 if (!crypt || !crypt->ops->get_flags)
6677 param->value = (crypt->ops->get_flags(crypt->priv) &
6683 param->value = ieee->drop_unencrypted;
6687 param->value = ieee->sec.auth_mode;
6691 param->value = ieee->wpa_enabled;
6695 param->value = ieee->ieee802_1x;
6700 param->value = ieee->privacy_invoked;
6704 return -EOPNOTSUPP;
6718 if (ext->alg == IW_ENCODE_ALG_TKIP) {
6721 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
6722 priv->ieee->host_mc_decrypt = 1;
6724 priv->ieee->host_encrypt = 0;
6725 priv->ieee->host_encrypt_msdu = 1;
6726 priv->ieee->host_decrypt = 1;
6729 priv->ieee->host_encrypt = 0;
6730 priv->ieee->host_encrypt_msdu = 0;
6731 priv->ieee->host_decrypt = 0;
6732 priv->ieee->host_mc_decrypt = 0;
6736 return libipw_wx_set_encodeext(priv->ieee, info, wrqu, extra);
6745 return libipw_wx_get_encodeext(priv->ieee, info, wrqu, extra);
6756 switch (mlme->cmd) {
6766 return -EOPNOTSUPP;
6782 if (priv->status & STATUS_ASSOCIATED) {
6785 spin_lock_irqsave(&priv->ieee->lock, flags);
6786 mode = priv->assoc_network->mode;
6787 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6789 mode = priv->ieee->mode;
6804 if (network->capability & WLAN_CAPABILITY_IBSS)
6805 network->qos_data.active = network->qos_data.supported;
6807 if (network->flags & NETWORK_HAS_QOS_MASK) {
6809 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
6810 network->qos_data.active = network->qos_data.supported;
6812 if ((network->qos_data.active == 1) && (active_network == 1) &&
6813 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
6814 (network->qos_data.old_param_count !=
6815 network->qos_data.param_count)) {
6816 network->qos_data.old_param_count =
6817 network->qos_data.param_count;
6818 schedule_work(&priv->qos_activate);
6823 if ((priv->ieee->mode == IEEE_B) || (network->mode == IEEE_B))
6824 memcpy(&network->qos_data.parameters,
6827 memcpy(&network->qos_data.parameters,
6830 if ((network->qos_data.active == 1) && (active_network == 1)) {
6832 schedule_work(&priv->qos_activate);
6835 network->qos_data.active = 0;
6836 network->qos_data.supported = 0;
6838 if ((priv->status & STATUS_ASSOCIATED) &&
6839 (priv->ieee->iw_mode == IW_MODE_ADHOC) && (active_network == 0)) {
6840 if (!ether_addr_equal(network->bssid, priv->bssid))
6841 if (network->capability & WLAN_CAPABILITY_IBSS)
6842 if ((network->ssid_len ==
6843 priv->assoc_network->ssid_len) &&
6844 !memcmp(network->ssid,
6845 priv->assoc_network->ssid,
6846 network->ssid_len)) {
6847 schedule_work(&priv->merge_networks);
6872 memcpy(active_one, priv->qos_data.def_qos_parm_CCK, size);
6874 memcpy(active_one, priv->qos_data.def_qos_parm_OFDM, size);
6888 } else if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
6892 if (priv->qos_data.qos_enable == 0)
6895 active_one = priv->qos_data.def_qos_parm_CCK;
6897 if (priv->qos_data.qos_enable == 0)
6900 active_one = priv->qos_data.def_qos_parm_OFDM;
6907 spin_lock_irqsave(&priv->ieee->lock, flags);
6908 active_one = &(qos_network_data->parameters);
6909 qos_network_data->old_param_count =
6910 qos_network_data->param_count;
6912 active = qos_network_data->supported;
6913 spin_unlock_irqrestore(&priv->ieee->lock, flags);
6940 return -1;
6943 qos_info.length = sizeof(struct libipw_qos_information_element) - 2;
6972 switch (priv->ieee->iw_mode) {
6974 BUG_ON(!(network->capability & WLAN_CAPABILITY_IBSS));
6980 qos_data = &network->qos_data;
6990 priv->assoc_request.policy_support &= ~HC_QOS_SUPPORT_ASSOC;
6994 if (priv->qos_data.qos_enable && qos_data->supported) {
6996 priv->assoc_request.policy_support |= HC_QOS_SUPPORT_ASSOC;
7016 (priv->assoc_network == NULL))
7019 if (!(priv->status & STATUS_ASSOCIATED))
7022 if ((priv->ieee->iw_mode != IW_MODE_INFRA))
7025 spin_lock_irqsave(&priv->ieee->lock, flags);
7026 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
7027 memcpy(&priv->assoc_network->qos_data, &network->qos_data,
7029 priv->assoc_network->qos_data.active = 1;
7030 if ((network->qos_data.old_param_count !=
7031 network->qos_data.param_count)) {
7033 network->qos_data.old_param_count =
7034 network->qos_data.param_count;
7038 if ((network->mode == IEEE_B) || (priv->ieee->mode == IEEE_B))
7039 memcpy(&priv->assoc_network->qos_data.parameters,
7042 memcpy(&priv->assoc_network->qos_data.parameters,
7044 priv->assoc_network->qos_data.active = 0;
7045 priv->assoc_network->qos_data.supported = 0;
7049 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7052 schedule_work(&priv->qos_activate);
7062 if (!(priv->ieee->modulation & LIBIPW_OFDM_MODULATION))
7063 ret = priv->qos_data.burst_duration_CCK;
7065 ret = priv->qos_data.burst_duration_OFDM;
7077 priv->qos_data.qos_enable = enable;
7079 if (priv->qos_data.qos_enable) {
7080 priv->qos_data.def_qos_parm_CCK = &def_qos_parameters_CCK;
7081 priv->qos_data.def_qos_parm_OFDM = &def_qos_parameters_OFDM;
7084 priv->qos_data.def_qos_parm_CCK = &def_parameters_CCK;
7085 priv->qos_data.def_qos_parm_OFDM = &def_parameters_OFDM;
7089 priv->qos_data.burst_enable = burst_enable;
7092 priv->qos_data.burst_duration_CCK = burst_duration_CCK;
7093 priv->qos_data.burst_duration_OFDM = burst_duration_OFDM;
7095 priv->qos_data.burst_duration_CCK = 0;
7096 priv->qos_data.burst_duration_OFDM = 0;
7105 if (priority > 7 || !priv->qos_data.qos_enable)
7108 return from_priority_to_tx_queue[priority] - 1;
7117 u8 *daddr = skb->data + ETH_ALEN;
7120 if (!(priv->status & STATUS_ASSOCIATED))
7123 qos_data = &priv->assoc_network->qos_data;
7125 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7127 qos_data->active = 0;
7129 qos_data->active = qos_data->supported;
7131 active = qos_data->active;
7132 supported = qos_data->supported;
7135 priv->qos_data.qos_enable, active, supported, unicast);
7136 if (active && priv->qos_data.qos_enable)
7152 tx_queue_id = from_priority_to_tx_queue[priority] - 1;
7153 tfd->tx_flags_ext |= DCT_FLAG_EXT_QOS_ENABLED;
7155 if (priv->qos_data.qos_no_ack_mask & (1UL << tx_queue_id)) {
7156 tfd->tx_flags &= ~DCT_FLAG_ACK_REQD;
7157 tfd->tfd.tfd_26.mchdr.qos_ctrl |= cpu_to_le16(CTRL_QOS_NO_ACK);
7170 mutex_lock(&priv->mutex);
7172 if (priv->status & STATUS_ASSOCIATED)
7173 ipw_qos_activate(priv, &(priv->assoc_network->qos_data));
7175 mutex_unlock(&priv->mutex);
7183 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7184 (network == priv->assoc_network));
7196 int active_network = ((priv->status & STATUS_ASSOCIATED) &&
7197 (network == priv->assoc_network));
7235 if (priv->config & CFG_FIXED_RATE)
7236 ipw_set_fixed_rate(priv, network->mode);
7238 if (!(priv->config & CFG_STATIC_ESSID)) {
7239 priv->essid_len = min(network->ssid_len,
7241 memcpy(priv->essid, network->ssid, priv->essid_len);
7244 network->last_associate = jiffies;
7246 memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
7247 priv->assoc_request.channel = network->channel;
7248 priv->assoc_request.auth_key = 0;
7250 if ((priv->capability & CAP_PRIVACY_ON) &&
7251 (priv->ieee->sec.auth_mode == WLAN_AUTH_SHARED_KEY)) {
7252 priv->assoc_request.auth_type = AUTH_SHARED_KEY;
7253 priv->assoc_request.auth_key = priv->ieee->sec.active_key;
7255 if (priv->ieee->sec.level == SEC_LEVEL_1)
7258 } else if ((priv->capability & CAP_PRIVACY_ON) &&
7259 (priv->ieee->sec.auth_mode == WLAN_AUTH_LEAP))
7260 priv->assoc_request.auth_type = AUTH_LEAP;
7262 priv->assoc_request.auth_type = AUTH_OPEN;
7264 if (priv->ieee->wpa_ie_len) {
7265 priv->assoc_request.policy_support = cpu_to_le16(0x02); /* RSN active */
7266 ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
7267 priv->ieee->wpa_ie_len);
7275 if (network->mode & priv->ieee->mode & IEEE_A)
7276 priv->assoc_request.ieee_mode = IPW_A_MODE;
7277 else if (network->mode & priv->ieee->mode & IEEE_G)
7278 priv->assoc_request.ieee_mode = IPW_G_MODE;
7279 else if (network->mode & priv->ieee->mode & IEEE_B)
7280 priv->assoc_request.ieee_mode = IPW_B_MODE;
7282 priv->assoc_request.capability = cpu_to_le16(network->capability);
7283 if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
7284 && !(priv->config & CFG_PREAMBLE_LONG)) {
7285 priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
7287 priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
7290 priv->assoc_request.capability &=
7295 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7296 priv->assoc_request.capability &=
7301 priv->essid_len, priv->essid,
7302 network->channel,
7303 ipw_modes[priv->assoc_request.ieee_mode],
7304 rates->num_rates,
7305 (priv->assoc_request.preamble_length ==
7307 network->capability &
7309 priv->capability & CAP_PRIVACY_ON ? "on " : "off",
7310 priv->capability & CAP_PRIVACY_ON ?
7311 (priv->capability & CAP_SHARED_KEY ? "(shared)" :
7313 priv->capability & CAP_PRIVACY_ON ? " key=" : "",
7314 priv->capability & CAP_PRIVACY_ON ?
7315 '1' + priv->ieee->sec.active_key : '.',
7316 priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
7318 priv->assoc_request.beacon_interval = cpu_to_le16(network->beacon_interval);
7319 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
7320 (network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
7321 priv->assoc_request.assoc_type = HC_IBSS_START;
7322 priv->assoc_request.assoc_tsf_msw = 0;
7323 priv->assoc_request.assoc_tsf_lsw = 0;
7326 priv->assoc_request.assoc_type = HC_REASSOCIATE;
7328 priv->assoc_request.assoc_type = HC_ASSOCIATE;
7329 priv->assoc_request.assoc_tsf_msw = cpu_to_le32(network->time_stamp[1]);
7330 priv->assoc_request.assoc_tsf_lsw = cpu_to_le32(network->time_stamp[0]);
7333 memcpy(priv->assoc_request.bssid, network->bssid, ETH_ALEN);
7335 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
7336 eth_broadcast_addr(priv->assoc_request.dest);
7337 priv->assoc_request.atim_window = cpu_to_le16(network->atim_window);
7339 memcpy(priv->assoc_request.dest, network->bssid, ETH_ALEN);
7340 priv->assoc_request.atim_window = 0;
7343 priv->assoc_request.listen_interval = cpu_to_le16(network->listen_interval);
7345 err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
7351 rates->ieee_mode = priv->assoc_request.ieee_mode;
7352 rates->purpose = IPW_RATE_CONNECT;
7355 if (priv->assoc_request.ieee_mode == IPW_G_MODE)
7356 priv->sys_config.dot11g_auto_detection = 1;
7358 priv->sys_config.dot11g_auto_detection = 0;
7360 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
7361 priv->sys_config.answer_broadcast_ssid_probe = 1;
7363 priv->sys_config.answer_broadcast_ssid_probe = 0;
7371 IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
7372 err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
7383 priv->channel = network->channel;
7384 memcpy(priv->bssid, network->bssid, ETH_ALEN);
7385 priv->status |= STATUS_ASSOCIATING;
7386 priv->status &= ~STATUS_SECURITY_UPDATED;
7388 priv->assoc_network = network;
7394 err = ipw_send_associate(priv, &priv->assoc_request);
7401 priv->essid_len, priv->essid, priv->bssid);
7411 .network = priv->assoc_network
7422 * 4. If a better network is found, a disassociation request is
7434 if (!(priv->status & (STATUS_ASSOCIATED | STATUS_ROAMING)))
7437 if (priv->status & STATUS_ASSOCIATED) {
7438 /* First pass through ROAM process -- look for a better
7441 u8 rssi = priv->assoc_network->stats.rssi;
7442 priv->assoc_network->stats.rssi = -128;
7443 spin_lock_irqsave(&priv->ieee->lock, flags);
7444 list_for_each_entry(network, &priv->ieee->network_list, list) {
7445 if (network != priv->assoc_network)
7448 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7449 priv->assoc_network->stats.rssi = rssi;
7451 if (match.network == priv->assoc_network) {
7454 priv->status &= ~STATUS_ROAMING;
7460 priv->assoc_network = match.network;
7465 /* Second pass through ROAM process -- request association */
7466 ipw_compatible_rates(priv, priv->assoc_network, &match.rates);
7467 ipw_associate_network(priv, priv->assoc_network, &match.rates, 1);
7468 priv->status &= ~STATUS_ROAMING;
7475 mutex_lock(&priv->mutex);
7477 mutex_unlock(&priv->mutex);
7492 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
7497 if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
7503 if (priv->status & STATUS_DISASSOCIATING) {
7505 schedule_work(&priv->associate);
7509 if (!ipw_is_init(priv) || (priv->status & STATUS_SCANNING)) {
7515 if (!(priv->config & CFG_ASSOCIATE) &&
7516 !(priv->config & (CFG_STATIC_ESSID | CFG_STATIC_BSSID))) {
7522 spin_lock_irqsave(&priv->ieee->lock, flags);
7523 list_for_each_entry(network, &priv->ieee->network_list, list)
7530 priv->ieee->iw_mode == IW_MODE_ADHOC &&
7531 priv->config & CFG_ADHOC_CREATE &&
7532 priv->config & CFG_STATIC_ESSID &&
7533 priv->config & CFG_STATIC_CHANNEL) {
7535 if (list_empty(&priv->ieee->network_free_list)) {
7539 list_for_each_entry(target, &priv->ieee->network_list, list) {
7541 (target->last_scanned < oldest->last_scanned))
7546 list_del(&oldest->list);
7549 target->ssid_len, target->ssid,
7550 target->bssid);
7551 list_add_tail(&target->list,
7552 &priv->ieee->network_free_list);
7555 element = priv->ieee->network_free_list.next;
7558 rates = &priv->rates;
7560 list_add_tail(&network->list, &priv->ieee->network_list);
7562 spin_unlock_irqrestore(&priv->ieee->lock, flags);
7569 if (!(priv->status & STATUS_SCANNING)) {
7570 if (!(priv->config & CFG_SPEED_SCAN))
7571 schedule_delayed_work(&priv->request_scan,
7574 schedule_delayed_work(&priv->request_scan, 0);
7589 mutex_lock(&priv->mutex);
7591 mutex_unlock(&priv->mutex);
7600 hdr = (struct ieee80211_hdr *)skb->data;
7601 fc = le16_to_cpu(hdr->frame_control);
7606 hdr->frame_control = cpu_to_le16(fc);
7607 switch (priv->ieee->sec.level) {
7610 memmove(skb->data + LIBIPW_3ADDR_LEN,
7611 skb->data + LIBIPW_3ADDR_LEN + 8,
7612 skb->len - LIBIPW_3ADDR_LEN - 8);
7613 skb_trim(skb, skb->len - 16); /* CCMP_HDR_LEN + CCMP_MIC_LEN */
7619 memmove(skb->data + LIBIPW_3ADDR_LEN,
7620 skb->data + LIBIPW_3ADDR_LEN + 4,
7621 skb->len - LIBIPW_3ADDR_LEN - 4);
7622 skb_trim(skb, skb->len - 8); /* IV + ICV */
7628 priv->ieee->sec.level);
7637 struct net_device *dev = priv->net_dev;
7639 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7646 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7647 skb_tailroom(rxb->skb))) {
7648 dev->stats.rx_errors++;
7649 priv->wstats.discard.misc++;
7652 } else if (unlikely(!netif_running(priv->net_dev))) {
7653 dev->stats.rx_dropped++;
7654 priv->wstats.discard.misc++;
7659 /* Advance skb->data to the start of the actual payload */
7660 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
7663 skb_put(rxb->skb, le16_to_cpu(pkt->u.frame.length));
7665 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7668 hdr = (struct libipw_hdr_4addr *)rxb->skb->data;
7669 if (priv->ieee->iw_mode != IW_MODE_MONITOR &&
7670 (is_multicast_ether_addr(hdr->addr1) ?
7671 !priv->ieee->host_mc_decrypt : !priv->ieee->host_decrypt))
7672 ipw_rebuild_decrypted_skb(priv, rxb->skb);
7674 if (!libipw_rx(priv->ieee, rxb->skb, stats))
7675 dev->stats.rx_errors++;
7677 rxb->skb = NULL;
7687 struct net_device *dev = priv->net_dev;
7688 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7689 struct ipw_rx_frame *frame = &pkt->u.frame;
7692 u16 received_channel = frame->received_channel;
7693 u8 antennaAndPhy = frame->antennaAndPhy;
7694 s8 antsignal = frame->rssi_dbm - IPW_RSSI_TO_DBM; /* call it signed anyhow */
7695 u16 pktrate = frame->rate;
7697 /* Magic struct that slots into the radiotap header -- no reason
7702 unsigned short len = le16_to_cpu(pkt->u.frame.length);
7709 if (unlikely((le16_to_cpu(pkt->u.frame.length) + IPW_RX_FRAME_SIZE) >
7710 skb_tailroom(rxb->skb))) {
7711 dev->stats.rx_errors++;
7712 priv->wstats.discard.misc++;
7715 } else if (unlikely(!netif_running(priv->net_dev))) {
7716 dev->stats.rx_dropped++;
7717 priv->wstats.discard.misc++;
7724 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7726 dev->stats.rx_dropped++;
7727 priv->wstats.discard.misc++;
7733 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7734 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7736 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7738 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7739 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
7740 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(struct ipw_rt_hdr)); /* total header+data */
7743 ipw_rt->rt_hdr.it_present = cpu_to_le32(
7753 ipw_rt->rt_flags = 0;
7754 ipw_rt->rt_tsf = (u64)(frame->parent_tsf[3] << 24 |
7755 frame->parent_tsf[2] << 16 |
7756 frame->parent_tsf[1] << 8 |
7757 frame->parent_tsf[0]);
7760 ipw_rt->rt_dbmsignal = antsignal;
7761 ipw_rt->rt_dbmnoise = (s8) le16_to_cpu(frame->noise);
7764 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(received_channel));
7766 ipw_rt->rt_chbitmask =
7769 ipw_rt->rt_chbitmask =
7772 ipw_rt->rt_chbitmask =
7779 ipw_rt->rt_rate = 2;
7782 ipw_rt->rt_rate = 4;
7785 ipw_rt->rt_rate = 10;
7788 ipw_rt->rt_rate = 12;
7791 ipw_rt->rt_rate = 18;
7794 ipw_rt->rt_rate = 22;
7797 ipw_rt->rt_rate = 24;
7800 ipw_rt->rt_rate = 36;
7803 ipw_rt->rt_rate = 48;
7806 ipw_rt->rt_rate = 72;
7809 ipw_rt->rt_rate = 96;
7812 ipw_rt->rt_rate = 108;
7815 ipw_rt->rt_rate = 0;
7820 ipw_rt->rt_antenna = (antennaAndPhy & 3); /* Is this right? */
7824 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
7827 skb_put(rxb->skb, len + sizeof(struct ipw_rt_hdr));
7829 IPW_DEBUG_RX("Rx packet of %d bytes.\n", rxb->skb->len);
7831 if (!libipw_rx(priv->ieee, rxb->skb, stats))
7832 dev->stats.rx_errors++;
7834 rxb->skb = NULL;
7864 struct net_device *dev = priv->prom_net_dev;
7865 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7866 struct ipw_rx_frame *frame = &pkt->u.frame;
7872 u16 channel = frame->received_channel;
7873 u8 phy_flags = frame->antennaAndPhy;
7874 s8 signal = frame->rssi_dbm - IPW_RSSI_TO_DBM;
7875 s8 noise = (s8) le16_to_cpu(frame->noise);
7876 u8 rate = frame->rate;
7877 unsigned short len = le16_to_cpu(pkt->u.frame.length);
7880 u16 filter = priv->prom_priv->filter;
7889 if (unlikely((len + IPW_RX_FRAME_SIZE) > skb_tailroom(rxb->skb))) {
7890 dev->stats.rx_errors++;
7897 dev->stats.rx_dropped++;
7904 if (len > IPW_RX_BUF_SIZE - sizeof(struct ipw_rt_hdr)) {
7906 dev->stats.rx_dropped++;
7911 hdr = (void *)rxb->skb->data + IPW_RX_FRAME_SIZE;
7912 if (libipw_is_management(le16_to_cpu(hdr->frame_control))) {
7917 } else if (libipw_is_control(le16_to_cpu(hdr->frame_control))) {
7922 } else if (libipw_is_data(le16_to_cpu(hdr->frame_control))) {
7930 skb = skb_copy(rxb->skb, GFP_ATOMIC);
7937 ipw_rt = (void *)skb->data;
7940 len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_control));
7942 memcpy(ipw_rt->payload, hdr, len);
7944 ipw_rt->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
7945 ipw_rt->rt_hdr.it_pad = 0; /* always good to zero */
7946 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(*ipw_rt)); /* total header+data */
7952 ipw_rt->rt_hdr.it_present = cpu_to_le32(
7962 ipw_rt->rt_flags = 0;
7963 ipw_rt->rt_tsf = (u64)(frame->parent_tsf[3] << 24 |
7964 frame->parent_tsf[2] << 16 |
7965 frame->parent_tsf[1] << 8 |
7966 frame->parent_tsf[0]);
7969 ipw_rt->rt_dbmsignal = signal;
7970 ipw_rt->rt_dbmnoise = noise;
7973 ipw_rt->rt_channel = cpu_to_le16(ieee80211chan2mhz(channel));
7975 ipw_rt->rt_chbitmask =
7978 ipw_rt->rt_chbitmask =
7981 ipw_rt->rt_chbitmask =
7988 ipw_rt->rt_rate = 2;
7991 ipw_rt->rt_rate = 4;
7994 ipw_rt->rt_rate = 10;
7997 ipw_rt->rt_rate = 12;
8000 ipw_rt->rt_rate = 18;
8003 ipw_rt->rt_rate = 22;
8006 ipw_rt->rt_rate = 24;
8009 ipw_rt->rt_rate = 36;
8012 ipw_rt->rt_rate = 48;
8015 ipw_rt->rt_rate = 72;
8018 ipw_rt->rt_rate = 96;
8021 ipw_rt->rt_rate = 108;
8024 ipw_rt->rt_rate = 0;
8029 ipw_rt->rt_antenna = (phy_flags & 3);
8033 ipw_rt->rt_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
8035 IPW_DEBUG_RX("Rx packet of %d bytes.\n", skb->len);
8037 if (!libipw_rx(priv->prom_priv->ieee, skb, stats)) {
8038 dev->stats.rx_errors++;
8049 switch (priv->ieee->iw_mode) {
8052 if (ether_addr_equal(header->addr2, priv->net_dev->dev_addr))
8056 if (is_multicast_ether_addr(header->addr1))
8057 return ether_addr_equal(header->addr3, priv->bssid);
8060 return ether_addr_equal(header->addr1,
8061 priv->net_dev->dev_addr);
8065 if (ether_addr_equal(header->addr3, priv->net_dev->dev_addr))
8069 if (is_multicast_ether_addr(header->addr1))
8070 return ether_addr_equal(header->addr2, priv->bssid);
8073 return ether_addr_equal(header->addr1,
8074 priv->net_dev->dev_addr);
8085 u16 sc = le16_to_cpu(header->seq_ctl);
8091 switch (priv->ieee->iw_mode) {
8096 u8 *mac = header->addr2;
8099 list_for_each(p, &priv->ibss_mac_hash[index]) {
8102 if (ether_addr_equal(entry->mac, mac))
8105 if (p == &priv->ibss_mac_hash[index]) {
8112 memcpy(entry->mac, mac, ETH_ALEN);
8113 entry->seq_num = seq;
8114 entry->frag_num = frag;
8115 entry->packet_time = jiffies;
8116 list_add(&entry->list,
8117 &priv->ibss_mac_hash[index]);
8120 last_seq = &entry->seq_num;
8121 last_frag = &entry->frag_num;
8122 last_time = &entry->packet_time;
8126 last_seq = &priv->last_seq_num;
8127 last_frag = &priv->last_frag_num;
8128 last_time = &priv->last_packet_time;
8138 /* out-of-order fragment */
8151 BUG_ON(!(le16_to_cpu(header->frame_control) & IEEE80211_FCTL_RETRY)); */
8159 struct sk_buff *skb = rxb->skb;
8160 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
8162 (skb->data + IPW_RX_FRAME_SIZE);
8164 libipw_rx_mgt(priv->ieee, header, stats);
8166 if (priv->ieee->iw_mode == IW_MODE_ADHOC &&
8167 ((WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8169 (WLAN_FC_GET_STYPE(le16_to_cpu(header->frame_ctl)) ==
8171 if (ether_addr_equal(header->addr3, priv->bssid))
8172 ipw_add_station(priv, header->addr2);
8175 if (priv->config & CFG_NET_STATS) {
8180 skb_put(skb, le16_to_cpu(pkt->u.frame.length) +
8189 skb->dev = priv->ieee->dev;
8194 skb->pkt_type = PACKET_OTHERHOST;
8195 skb->protocol = cpu_to_be16(ETH_P_80211_STATS);
8196 memset(skb->cb, 0, sizeof(rxb->skb->cb));
8198 rxb->skb = NULL;
8218 i = priv->rxq->read;
8220 if (ipw_rx_queue_space (priv->rxq) > (RX_QUEUE_SIZE / 2))
8224 rxb = priv->rxq->queue[i];
8229 priv->rxq->queue[i] = NULL;
8231 dma_sync_single_for_cpu(&priv->pci_dev->dev, rxb->dma_addr,
8234 pkt = (struct ipw_rx_packet *)rxb->skb->data;
8236 pkt->header.message_type,
8237 pkt->header.rx_seq_num, pkt->header.control_bits);
8239 switch (pkt->header.message_type) {
8242 .rssi = pkt->u.frame.rssi_dbm -
8245 pkt->u.frame.rssi_dbm -
8248 le16_to_cpu(pkt->u.frame.noise),
8249 .rate = pkt->u.frame.rate,
8252 pkt->u.frame.received_channel,
8254 (pkt->u.frame.
8258 .len = le16_to_cpu(pkt->u.frame.length),
8270 priv->rx_packets++;
8273 if (priv->prom_net_dev && netif_running(priv->prom_net_dev))
8278 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8293 (struct libipw_hdr_4addr *)(rxb->skb->
8296 /* TODO: Check Ad-Hoc dest/source and make sure
8298 * correctly -- we should probably use the
8304 if (network_packet && priv->assoc_network) {
8305 priv->assoc_network->stats.rssi =
8307 priv->exp_avg_rssi =
8308 exponential_average(priv->exp_avg_rssi,
8313 le16_to_cpu(pkt->u.frame.length));
8315 if (le16_to_cpu(pkt->u.frame.length) <
8317 header->frame_ctl))) {
8321 priv->net_dev->stats.rx_errors++;
8322 priv->wstats.discard.misc++;
8327 (le16_to_cpu(header->frame_ctl))) {
8346 header->addr1,
8347 header->addr2,
8348 header->addr3);
8363 pkt->u.notification.subtype,
8364 pkt->u.notification.flags,
8365 le16_to_cpu(pkt->u.notification.size));
8366 ipw_rx_notification(priv, &pkt->u.notification);
8372 pkt->header.message_type);
8376 /* For now we just don't re-use anything. We can tweak this
8377 * later to try and re-use notification packets and SKBs that
8379 if (rxb->skb != NULL) {
8380 dev_kfree_skb_any(rxb->skb);
8381 rxb->skb = NULL;
8384 dma_unmap_single(&priv->pci_dev->dev, rxb->dma_addr,
8386 list_add_tail(&rxb->list, &priv->rxq->rx_used);
8393 priv->rxq->read = i;
8399 priv->rxq->read = i;
8408 #define DEFAULT_LONG_RETRY_LIMIT 4U
8420 int old_mode = priv->ieee->iw_mode;
8423 priv->config = 0;
8428 priv->config |= CFG_NO_LED;
8431 priv->config |= CFG_ASSOCIATE;
8436 priv->config |= CFG_ADHOC_CREATE;
8440 priv->config &= ~CFG_STATIC_ESSID;
8441 priv->essid_len = 0;
8442 memset(priv->essid, 0, IW_ESSID_MAX_SIZE);
8445 priv->status |= STATUS_RF_KILL_SW;
8450 priv->config |= CFG_STATIC_CHANNEL;
8451 priv->channel = default_channel;
8462 priv->ieee->iw_mode = IW_MODE_ADHOC;
8463 priv->net_dev->type = ARPHRD_ETHER;
8468 priv->ieee->iw_mode = IW_MODE_MONITOR;
8470 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8472 priv->net_dev->type = ARPHRD_IEEE80211;
8478 priv->net_dev->type = ARPHRD_ETHER;
8479 priv->ieee->iw_mode = IW_MODE_INFRA;
8484 priv->ieee->host_encrypt = 0;
8485 priv->ieee->host_encrypt_msdu = 0;
8486 priv->ieee->host_decrypt = 0;
8487 priv->ieee->host_mc_decrypt = 0;
8492 priv->ieee->host_open_frag = 0;
8494 if ((priv->pci_dev->device == 0x4223) ||
8495 (priv->pci_dev->device == 0x4224)) {
8500 priv->ieee->abg_true = 1;
8504 priv->adapter = IPW_2915ABG;
8505 priv->ieee->mode = IEEE_A | IEEE_G | IEEE_B;
8512 priv->ieee->abg_true = 0;
8516 priv->adapter = IPW_2200BG;
8517 priv->ieee->mode = IEEE_G | IEEE_B;
8520 priv->ieee->freq_band = band;
8521 priv->ieee->modulation = modulation;
8523 priv->rates_mask = LIBIPW_DEFAULT_RATES_MASK;
8525 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
8526 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
8528 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
8529 priv->short_retry_limit = DEFAULT_SHORT_RETRY_LIMIT;
8530 priv->long_retry_limit = DEFAULT_LONG_RETRY_LIMIT;
8533 priv->power_mode = IPW_POWER_AC;
8534 priv->tx_power = IPW_TX_POWER_DEFAULT;
8536 return old_mode == priv->ieee->iw_mode;
8553 priv->config &= ~CFG_STATIC_CHANNEL;
8560 priv->config |= CFG_STATIC_CHANNEL;
8562 if (priv->channel == channel) {
8569 priv->channel = channel;
8572 if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
8574 if (priv->status & STATUS_SCANNING) {
8580 for (i = 1000; i && (priv->status & STATUS_SCANNING); i--)
8583 if (priv->status & STATUS_SCANNING)
8587 1000 - i);
8593 /* Network configuration changed -- force [re]association */
8606 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
8607 struct iw_freq *fwrq = &wrqu->freq;
8612 if (fwrq->m == 0) {
8613 IPW_DEBUG_WX("SET Freq/Channel -> any\n");
8614 mutex_lock(&priv->mutex);
8616 mutex_unlock(&priv->mutex);
8620 if (fwrq->e == 1) {
8621 channel = libipw_freq_to_channel(priv->ieee, fwrq->m);
8623 return -EINVAL;
8625 channel = fwrq->m;
8627 if (!(band = libipw_is_valid_channel(priv->ieee, channel)))
8628 return -EINVAL;
8630 if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
8631 i = libipw_channel_to_index(priv->ieee, channel);
8632 if (i == -1)
8633 return -EINVAL;
8636 geo->bg[i].flags : geo->a[i].flags;
8638 IPW_DEBUG_WX("Invalid Ad-Hoc channel for 802.11a\n");
8639 return -EINVAL;
8643 IPW_DEBUG_WX("SET Freq/Channel -> %d\n", fwrq->m);
8644 mutex_lock(&priv->mutex);
8646 mutex_unlock(&priv->mutex);
8656 wrqu->freq.e = 0;
8660 mutex_lock(&priv->mutex);
8661 if (priv->config & CFG_STATIC_CHANNEL ||
8662 priv->status & (STATUS_ASSOCIATING | STATUS_ASSOCIATED)) {
8665 i = libipw_channel_to_index(priv->ieee, priv->channel);
8666 BUG_ON(i == -1);
8667 wrqu->freq.e = 1;
8669 switch (libipw_is_valid_channel(priv->ieee, priv->channel)) {
8671 wrqu->freq.m = priv->ieee->geo.a[i].freq * 100000;
8675 wrqu->freq.m = priv->ieee->geo.bg[i].freq * 100000;
8682 wrqu->freq.m = 0;
8684 mutex_unlock(&priv->mutex);
8685 IPW_DEBUG_WX("GET Freq/Channel -> %d\n", priv->channel);
8696 IPW_DEBUG_WX("Set MODE: %d\n", wrqu->mode);
8698 switch (wrqu->mode) {
8706 wrqu->mode = IW_MODE_INFRA;
8709 return -EINVAL;
8711 if (wrqu->mode == priv->ieee->iw_mode)
8714 mutex_lock(&priv->mutex);
8719 if (priv->ieee->iw_mode == IW_MODE_MONITOR)
8720 priv->net_dev->type = ARPHRD_ETHER;
8722 if (wrqu->mode == IW_MODE_MONITOR)
8724 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
8726 priv->net_dev->type = ARPHRD_IEEE80211;
8734 priv->ieee->iw_mode = wrqu->mode;
8736 schedule_work(&priv->adapter_restart);
8737 mutex_unlock(&priv->mutex);
8746 mutex_lock(&priv->mutex);
8747 wrqu->mode = priv->ieee->iw_mode;
8748 IPW_DEBUG_WX("Get MODE -> %d\n", wrqu->mode);
8749 mutex_unlock(&priv->mutex);
8776 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
8779 wrqu->data.length = sizeof(*range);
8783 range->throughput = 27 * 1000 * 1000;
8785 range->max_qual.qual = 100;
8787 range->max_qual.level = 0;
8788 range->max_qual.noise = 0;
8789 range->max_qual.updated = 7; /* Updated all three */
8791 range->avg_qual.qual = 70;
8793 range->avg_qual.level = 0; /* FIXME to real average level */
8794 range->avg_qual.noise = 0;
8795 range->avg_qual.updated = 7; /* Updated all three */
8796 mutex_lock(&priv->mutex);
8797 range->num_bitrates = min(priv->rates.num_rates, (u8) IW_MAX_BITRATES);
8799 for (i = 0; i < range->num_bitrates; i++)
8800 range->bitrate[i] = (priv->rates.supported_rates[i] & 0x7F) *
8803 range->max_rts = DEFAULT_RTS_THRESHOLD;
8804 range->min_frag = MIN_FRAG_THRESHOLD;
8805 range->max_frag = MAX_FRAG_THRESHOLD;
8807 range->encoding_size[0] = 5;
8808 range->encoding_size[1] = 13;
8809 range->num_encoding_sizes = 2;
8810 range->max_encoding_tokens = WEP_KEYS;
8813 range->we_version_compiled = WIRELESS_EXT;
8814 range->we_version_source = 18;
8817 if (priv->ieee->mode & (IEEE_B | IEEE_G)) {
8818 for (j = 0; j < geo->bg_channels && i < IW_MAX_FREQUENCIES; j++) {
8819 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
8820 (geo->bg[j].flags & LIBIPW_CH_PASSIVE_ONLY))
8823 range->freq[i].i = geo->bg[j].channel;
8824 range->freq[i].m = geo->bg[j].freq * 100000;
8825 range->freq[i].e = 1;
8830 if (priv->ieee->mode & IEEE_A) {
8831 for (j = 0; j < geo->a_channels && i < IW_MAX_FREQUENCIES; j++) {
8832 if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
8833 (geo->a[j].flags & LIBIPW_CH_PASSIVE_ONLY))
8836 range->freq[i].i = geo->a[j].channel;
8837 range->freq[i].m = geo->a[j].freq * 100000;
8838 range->freq[i].e = 1;
8843 range->num_channels = i;
8844 range->num_frequency = i;
8846 mutex_unlock(&priv->mutex);
8849 range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
8853 range->event_capa[1] = IW_EVENT_CAPA_K_1;
8855 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
8858 range->scan_capa = IW_SCAN_CAPA_ESSID | IW_SCAN_CAPA_TYPE;
8870 if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
8871 return -EINVAL;
8872 mutex_lock(&priv->mutex);
8873 if (is_broadcast_ether_addr(wrqu->ap_addr.sa_data) ||
8874 is_zero_ether_addr(wrqu->ap_addr.sa_data)) {
8877 priv->config &= ~CFG_STATIC_BSSID;
8881 mutex_unlock(&priv->mutex);
8885 priv->config |= CFG_STATIC_BSSID;
8886 if (ether_addr_equal(priv->bssid, wrqu->ap_addr.sa_data)) {
8888 mutex_unlock(&priv->mutex);
8893 wrqu->ap_addr.sa_data);
8895 memcpy(priv->bssid, wrqu->ap_addr.sa_data, ETH_ALEN);
8897 /* Network configuration changed -- force [re]association */
8902 mutex_unlock(&priv->mutex);
8914 mutex_lock(&priv->mutex);
8915 if (priv->config & CFG_STATIC_BSSID ||
8916 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8917 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
8918 memcpy(wrqu->ap_addr.sa_data, priv->bssid, ETH_ALEN);
8920 eth_zero_addr(wrqu->ap_addr.sa_data);
8923 wrqu->ap_addr.sa_data);
8924 mutex_unlock(&priv->mutex);
8935 mutex_lock(&priv->mutex);
8937 if (!wrqu->essid.flags)
8941 priv->config &= ~CFG_STATIC_ESSID;
8943 mutex_unlock(&priv->mutex);
8947 length = min((int)wrqu->essid.length, IW_ESSID_MAX_SIZE);
8949 priv->config |= CFG_STATIC_ESSID;
8951 if (priv->essid_len == length && !memcmp(priv->essid, extra, length)
8952 && (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING))) {
8954 mutex_unlock(&priv->mutex);
8960 priv->essid_len = length;
8961 memcpy(priv->essid, extra, priv->essid_len);
8963 /* Network configuration changed -- force [re]association */
8968 mutex_unlock(&priv->mutex);
8980 mutex_lock(&priv->mutex);
8981 if (priv->config & CFG_STATIC_ESSID ||
8982 priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
8984 priv->essid_len, priv->essid);
8985 memcpy(extra, priv->essid, priv->essid_len);
8986 wrqu->essid.length = priv->essid_len;
8987 wrqu->essid.flags = 1; /* active */
8990 wrqu->essid.length = 0;
8991 wrqu->essid.flags = 0; /* active */
8993 mutex_unlock(&priv->mutex);
9004 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
9005 return -E2BIG;
9006 mutex_lock(&priv->mutex);
9007 wrqu->data.length = min_t(size_t, wrqu->data.length, sizeof(priv->nick));
9008 memset(priv->nick, 0, sizeof(priv->nick));
9009 memcpy(priv->nick, extra, wrqu->data.length);
9011 mutex_unlock(&priv->mutex);
9022 mutex_lock(&priv->mutex);
9023 wrqu->data.length = strlen(priv->nick);
9024 memcpy(extra, priv->nick, wrqu->data.length);
9025 wrqu->data.flags = 1; /* active */
9026 mutex_unlock(&priv->mutex);
9037 IPW_DEBUG_WX("Setting roaming threshold to %d\n", wrqu->sens.value);
9038 IPW_DEBUG_WX("Setting disassociate threshold to %d\n", 3*wrqu->sens.value);
9039 mutex_lock(&priv->mutex);
9041 if (wrqu->sens.fixed == 0)
9043 priv->roaming_threshold = IPW_MB_ROAMING_THRESHOLD_DEFAULT;
9044 priv->disassociate_threshold = IPW_MB_DISASSOCIATE_THRESHOLD_DEFAULT;
9047 if ((wrqu->sens.value > IPW_MB_ROAMING_THRESHOLD_MAX) ||
9048 (wrqu->sens.value < IPW_MB_ROAMING_THRESHOLD_MIN)) {
9049 err = -EINVAL;
9053 priv->roaming_threshold = wrqu->sens.value;
9054 priv->disassociate_threshold = 3*wrqu->sens.value;
9056 mutex_unlock(&priv->mutex);
9065 mutex_lock(&priv->mutex);
9066 wrqu->sens.fixed = 1;
9067 wrqu->sens.value = priv->roaming_threshold;
9068 mutex_unlock(&priv->mutex);
9070 IPW_DEBUG_WX("GET roaming threshold -> %s %d\n",
9071 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
9082 u32 target_rate = wrqu->bitrate.value;
9085 /* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
9089 if (target_rate == -1) {
9097 fixed = wrqu->bitrate.fixed;
9160 return -EINVAL;
9164 mask, fixed ? "fixed" : "sub-rates");
9165 mutex_lock(&priv->mutex);
9167 priv->config &= ~CFG_FIXED_RATE;
9168 ipw_set_fixed_rate(priv, priv->ieee->mode);
9170 priv->config |= CFG_FIXED_RATE;
9172 if (priv->rates_mask == mask) {
9174 mutex_unlock(&priv->mutex);
9178 priv->rates_mask = mask;
9180 /* Network configuration changed -- force [re]association */
9185 mutex_unlock(&priv->mutex);
9194 mutex_lock(&priv->mutex);
9195 wrqu->bitrate.value = priv->last_rate;
9196 wrqu->bitrate.fixed = (priv->config & CFG_FIXED_RATE) ? 1 : 0;
9197 mutex_unlock(&priv->mutex);
9198 IPW_DEBUG_WX("GET Rate -> %d\n", wrqu->bitrate.value);
9207 mutex_lock(&priv->mutex);
9208 if (wrqu->rts.disabled || !wrqu->rts.fixed)
9209 priv->rts_threshold = DEFAULT_RTS_THRESHOLD;
9211 if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
9212 wrqu->rts.value > MAX_RTS_THRESHOLD) {
9213 mutex_unlock(&priv->mutex);
9214 return -EINVAL;
9216 priv->rts_threshold = wrqu->rts.value;
9219 ipw_send_rts_threshold(priv, priv->rts_threshold);
9220 mutex_unlock(&priv->mutex);
9221 IPW_DEBUG_WX("SET RTS Threshold -> %d\n", priv->rts_threshold);
9230 mutex_lock(&priv->mutex);
9231 wrqu->rts.value = priv->rts_threshold;
9232 wrqu->rts.fixed = 0; /* no auto select */
9233 wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
9234 mutex_unlock(&priv->mutex);
9235 IPW_DEBUG_WX("GET RTS Threshold -> %d\n", wrqu->rts.value);
9246 mutex_lock(&priv->mutex);
9247 if (ipw_radio_kill_sw(priv, wrqu->power.disabled)) {
9248 err = -EINPROGRESS;
9252 if (!wrqu->power.fixed)
9253 wrqu->power.value = IPW_TX_POWER_DEFAULT;
9255 if (wrqu->power.flags != IW_TXPOW_DBM) {
9256 err = -EINVAL;
9260 if ((wrqu->power.value > IPW_TX_POWER_MAX) ||
9261 (wrqu->power.value < IPW_TX_POWER_MIN)) {
9262 err = -EINVAL;
9266 priv->tx_power = wrqu->power.value;
9269 mutex_unlock(&priv->mutex);
9278 mutex_lock(&priv->mutex);
9279 wrqu->power.value = priv->tx_power;
9280 wrqu->power.fixed = 1;
9281 wrqu->power.flags = IW_TXPOW_DBM;
9282 wrqu->power.disabled = (priv->status & STATUS_RF_KILL_MASK) ? 1 : 0;
9283 mutex_unlock(&priv->mutex);
9285 IPW_DEBUG_WX("GET TX Power -> %s %d\n",
9286 wrqu->power.disabled ? "OFF" : "ON", wrqu->power.value);
9296 mutex_lock(&priv->mutex);
9297 if (wrqu->frag.disabled || !wrqu->frag.fixed)
9298 priv->ieee->fts = DEFAULT_FTS;
9300 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
9301 wrqu->frag.value > MAX_FRAG_THRESHOLD) {
9302 mutex_unlock(&priv->mutex);
9303 return -EINVAL;
9306 priv->ieee->fts = wrqu->frag.value & ~0x1;
9309 ipw_send_frag_threshold(priv, wrqu->frag.value);
9310 mutex_unlock(&priv->mutex);
9311 IPW_DEBUG_WX("SET Frag Threshold -> %d\n", wrqu->frag.value);
9320 mutex_lock(&priv->mutex);
9321 wrqu->frag.value = priv->ieee->fts;
9322 wrqu->frag.fixed = 0; /* no auto select */
9323 wrqu->frag.disabled = (wrqu->frag.value == DEFAULT_FTS);
9324 mutex_unlock(&priv->mutex);
9325 IPW_DEBUG_WX("GET Frag Threshold -> %d\n", wrqu->frag.value);
9336 if (wrqu->retry.flags & IW_RETRY_LIFETIME || wrqu->retry.disabled)
9337 return -EINVAL;
9339 if (!(wrqu->retry.flags & IW_RETRY_LIMIT))
9342 if (wrqu->retry.value < 0 || wrqu->retry.value >= 255)
9343 return -EINVAL;
9345 mutex_lock(&priv->mutex);
9346 if (wrqu->retry.flags & IW_RETRY_SHORT)
9347 priv->short_retry_limit = (u8) wrqu->retry.value;
9348 else if (wrqu->retry.flags & IW_RETRY_LONG)
9349 priv->long_retry_limit = (u8) wrqu->retry.value;
9351 priv->short_retry_limit = (u8) wrqu->retry.value;
9352 priv->long_retry_limit = (u8) wrqu->retry.value;
9355 ipw_send_retry_limit(priv, priv->short_retry_limit,
9356 priv->long_retry_limit);
9357 mutex_unlock(&priv->mutex);
9358 IPW_DEBUG_WX("SET retry limit -> short:%d long:%d\n",
9359 priv->short_retry_limit, priv->long_retry_limit);
9369 mutex_lock(&priv->mutex);
9370 wrqu->retry.disabled = 0;
9372 if ((wrqu->retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
9373 mutex_unlock(&priv->mutex);
9374 return -EINVAL;
9377 if (wrqu->retry.flags & IW_RETRY_LONG) {
9378 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
9379 wrqu->retry.value = priv->long_retry_limit;
9380 } else if (wrqu->retry.flags & IW_RETRY_SHORT) {
9381 wrqu->retry.flags = IW_RETRY_LIMIT | IW_RETRY_SHORT;
9382 wrqu->retry.value = priv->short_retry_limit;
9384 wrqu->retry.flags = IW_RETRY_LIMIT;
9385 wrqu->retry.value = priv->short_retry_limit;
9387 mutex_unlock(&priv->mutex);
9389 IPW_DEBUG_WX("GET retry -> %d\n", wrqu->retry.value);
9402 mutex_lock(&priv->mutex);
9404 priv->user_requested_scan = 1;
9406 if (wrqu->data.length == sizeof(struct iw_scan_req)) {
9407 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
9408 int len = min((int)req->essid_len,
9409 (int)sizeof(priv->direct_scan_ssid));
9410 memcpy(priv->direct_scan_ssid, req->essid, len);
9411 priv->direct_scan_ssid_len = len;
9412 work = &priv->request_direct_scan;
9413 } else if (req->scan_type == IW_SCAN_TYPE_PASSIVE) {
9414 work = &priv->request_passive_scan;
9418 work = &priv->request_scan;
9421 mutex_unlock(&priv->mutex);
9435 return libipw_wx_get_scan(priv->ieee, info, wrqu, extra);
9444 u32 cap = priv->capability;
9446 mutex_lock(&priv->mutex);
9447 ret = libipw_wx_set_encode(priv->ieee, info, wrqu, key);
9451 if (cap != priv->capability &&
9452 priv->ieee->iw_mode == IW_MODE_ADHOC &&
9453 priv->status & STATUS_ASSOCIATED)
9456 mutex_unlock(&priv->mutex);
9465 return libipw_wx_get_encode(priv->ieee, info, wrqu, key);
9474 mutex_lock(&priv->mutex);
9475 if (wrqu->power.disabled) {
9476 priv->power_mode = IPW_POWER_LEVEL(priv->power_mode);
9480 mutex_unlock(&priv->mutex);
9483 IPW_DEBUG_WX("SET Power Management Mode -> off\n");
9484 mutex_unlock(&priv->mutex);
9488 switch (wrqu->power.flags & IW_POWER_MODE) {
9495 wrqu->power.flags);
9496 mutex_unlock(&priv->mutex);
9497 return -EOPNOTSUPP;
9502 if (IPW_POWER_LEVEL(priv->power_mode) == IPW_POWER_AC)
9503 priv->power_mode = IPW_POWER_ENABLED | IPW_POWER_BATTERY;
9505 priv->power_mode = IPW_POWER_ENABLED | priv->power_mode;
9507 err = ipw_send_power_mode(priv, IPW_POWER_LEVEL(priv->power_mode));
9510 mutex_unlock(&priv->mutex);
9514 IPW_DEBUG_WX("SET Power Management Mode -> 0x%02X\n", priv->power_mode);
9515 mutex_unlock(&priv->mutex);
9524 mutex_lock(&priv->mutex);
9525 if (!(priv->power_mode & IPW_POWER_ENABLED))
9526 wrqu->power.disabled = 1;
9528 wrqu->power.disabled = 0;
9530 mutex_unlock(&priv->mutex);
9531 IPW_DEBUG_WX("GET Power Management Mode -> %02X\n", priv->power_mode);
9544 mutex_lock(&priv->mutex);
9548 if (IPW_POWER_LEVEL(priv->power_mode) != mode) {
9552 mutex_unlock(&priv->mutex);
9555 priv->power_mode = IPW_POWER_ENABLED | mode;
9557 mutex_unlock(&priv->mutex);
9567 int level = IPW_POWER_LEVEL(priv->power_mode);
9574 p += scnprintf(p, MAX_WX_STRING - (p - extra), "(AC)");
9577 p += scnprintf(p, MAX_WX_STRING - (p - extra), "(BATTERY)");
9580 p += scnprintf(p, MAX_WX_STRING - (p - extra),
9582 timeout_duration[level - 1] / 1000,
9583 period_duration[level - 1] / 1000);
9586 if (!(priv->power_mode & IPW_POWER_ENABLED))
9587 p += scnprintf(p, MAX_WX_STRING - (p - extra), " OFF");
9589 wrqu->data.length = p - extra + 1;
9604 return -EINVAL;
9606 mutex_lock(&priv->mutex);
9607 if (priv->adapter == IPW_2915ABG) {
9608 priv->ieee->abg_true = 1;
9613 priv->ieee->abg_true = 0;
9618 mutex_unlock(&priv->mutex);
9619 return -EINVAL;
9622 priv->ieee->abg_true = 0;
9629 priv->ieee->abg_true = 0;
9635 priv->ieee->abg_true = 0;
9637 priv->ieee->mode = mode;
9638 priv->ieee->freq_band = band;
9639 priv->ieee->modulation = modulation;
9640 init_supported_rates(priv, &priv->rates);
9642 /* Network configuration changed -- force [re]association */
9645 ipw_send_supported_rates(priv, &priv->rates);
9655 mutex_unlock(&priv->mutex);
9664 mutex_lock(&priv->mutex);
9665 switch (priv->ieee->mode) {
9676 strscpy_pad(extra, "802.11g (4)", MAX_WX_STRING);
9694 wrqu->data.length = strlen(extra) + 1;
9695 mutex_unlock(&priv->mutex);
9706 mutex_lock(&priv->mutex);
9707 /* Switching from SHORT -> LONG requires a disassociation */
9709 if (!(priv->config & CFG_PREAMBLE_LONG)) {
9710 priv->config |= CFG_PREAMBLE_LONG;
9712 /* Network configuration changed -- force [re]association */
9722 priv->config &= ~CFG_PREAMBLE_LONG;
9725 mutex_unlock(&priv->mutex);
9726 return -EINVAL;
9729 mutex_unlock(&priv->mutex);
9738 mutex_lock(&priv->mutex);
9739 if (priv->config & CFG_PREAMBLE_LONG)
9740 snprintf(wrqu->name, IFNAMSIZ, "long (1)");
9742 snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
9743 mutex_unlock(&priv->mutex);
9755 mutex_lock(&priv->mutex);
9758 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9760 priv->net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
9762 priv->net_dev->type = ARPHRD_IEEE80211;
9764 schedule_work(&priv->adapter_restart);
9769 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
9770 mutex_unlock(&priv->mutex);
9773 priv->net_dev->type = ARPHRD_ETHER;
9774 schedule_work(&priv->adapter_restart);
9776 mutex_unlock(&priv->mutex);
9788 schedule_work(&priv->adapter_restart);
9806 mutex_lock(&priv->mutex);
9816 ipw_radio_kill_sw(priv, priv->status & STATUS_RF_KILL_SW);
9818 mutex_unlock(&priv->mutex);
9819 libipw_wx_set_encode(priv->ieee, info, &wrqu_sec, NULL);
9820 mutex_lock(&priv->mutex);
9822 if (!(priv->status & STATUS_RF_KILL_MASK)) {
9823 /* Configuration likely changed -- force [re]association */
9830 mutex_unlock(&priv->mutex);
9966 wstats = &priv->wstats;
9969 * netdev->get_wireless_stats seems to be called before fw is
9973 if (!(priv->status & STATUS_ASSOCIATED)) {
9974 wstats->miss.beacon = 0;
9975 wstats->discard.retries = 0;
9976 wstats->qual.qual = 0;
9977 wstats->qual.level = 0;
9978 wstats->qual.noise = 0;
9979 wstats->qual.updated = 7;
9980 wstats->qual.updated |= IW_QUAL_NOISE_INVALID |
9985 wstats->qual.qual = priv->quality;
9986 wstats->qual.level = priv->exp_avg_rssi;
9987 wstats->qual.noise = priv->exp_avg_noise;
9988 wstats->qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
9991 wstats->miss.beacon = average_value(&priv->average_missed_beacons);
9992 wstats->discard.retries = priv->last_tx_failures;
9993 wstats->discard.code = priv->ieee->ieee_stats.rx_discards_undecryptable;
9997 wstats->discard.retries += tx_retry; */
10007 sys_config->bt_coexistence = 0;
10008 sys_config->answer_broadcast_ssid_probe = 0;
10009 sys_config->accept_all_data_frames = 0;
10010 sys_config->accept_non_directed_frames = 1;
10011 sys_config->exclude_unicast_unencrypted = 0;
10012 sys_config->disable_unicast_decryption = 1;
10013 sys_config->exclude_multicast_unencrypted = 0;
10014 sys_config->disable_multicast_decryption = 1;
10017 sys_config->antenna_diversity = antenna;
10018 sys_config->pass_crc_to_host = 0; /* TODO: See if 1 gives us FCS */
10019 sys_config->dot11g_auto_detection = 0;
10020 sys_config->enable_cts_to_self = 0;
10021 sys_config->bt_coexist_collision_thr = 0;
10022 sys_config->pass_noise_stats_to_host = 1; /* 1 -- fix for 256 */
10023 sys_config->silence_threshold = 0x1e;
10028 IPW_DEBUG_INFO("dev->open\n");
10035 IPW_DEBUG_INFO("dev->close\n");
10051 txb->fragments[0]->data;
10056 struct clx2_tx_queue *txq = &priv->txq[tx_id];
10058 struct clx2_tx_queue *txq = &priv->txq[0];
10060 struct clx2_queue *q = &txq->q;
10064 if (!(priv->status & STATUS_ASSOCIATED))
10067 hdr_len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_ctl));
10068 switch (priv->ieee->iw_mode) {
10070 unicast = !is_multicast_ether_addr(hdr->addr1);
10071 id = ipw_find_station(priv, hdr->addr1);
10073 id = ipw_add_station(priv, hdr->addr1);
10077 hdr->addr1);
10085 unicast = !is_multicast_ether_addr(hdr->addr3);
10090 tfd = &txq->bd[q->first_empty];
10091 txq->txb[q->first_empty] = txb;
10093 tfd->u.data.station_number = id;
10095 tfd->control_flags.message_type = TX_FRAME_TYPE;
10096 tfd->control_flags.control_bits = TFD_NEED_IRQ_MASK;
10098 tfd->u.data.cmd_id = DINO_CMD_TX;
10099 tfd->u.data.len = cpu_to_le16(txb->payload_size);
10101 if (priv->assoc_request.ieee_mode == IPW_B_MODE)
10102 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
10104 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
10106 if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
10107 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
10109 fc = le16_to_cpu(hdr->frame_ctl);
10110 hdr->frame_ctl = cpu_to_le16(fc & ~IEEE80211_FCTL_MOREFRAGS);
10112 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
10115 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10117 if (txb->encrypted && !priv->ieee->host_encrypt) {
10118 switch (priv->ieee->sec.level) {
10120 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10127 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10129 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10130 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
10131 tfd->u.data.key_index = 0;
10132 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
10135 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10137 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10138 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
10139 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
10142 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10144 tfd->u.data.key_index = priv->ieee->crypt_info.tx_keyidx;
10145 if (priv->ieee->sec.key_sizes[priv->ieee->crypt_info.tx_keyidx] <=
10147 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
10149 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
10155 priv->ieee->sec.level);
10160 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
10164 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data));
10168 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
10169 txb->nr_frags));
10171 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
10172 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
10174 i, le32_to_cpu(tfd->u.data.num_chunks),
10175 txb->fragments[i]->len - hdr_len);
10177 i, tfd->u.data.num_chunks,
10178 txb->fragments[i]->len - hdr_len);
10179 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
10180 txb->fragments[i]->len - hdr_len);
10182 tfd->u.data.chunk_ptr[i] =
10183 cpu_to_le32(dma_map_single(&priv->pci_dev->dev,
10184 txb->fragments[i]->data + hdr_len,
10185 txb->fragments[i]->len - hdr_len,
10187 tfd->u.data.chunk_len[i] =
10188 cpu_to_le16(txb->fragments[i]->len - hdr_len);
10191 if (i != txb->nr_frags) {
10196 for (j = i; j < txb->nr_frags; j++)
10197 remaining_bytes += txb->fragments[j]->len - hdr_len;
10203 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
10204 for (j = i; j < txb->nr_frags; j++) {
10205 int size = txb->fragments[j]->len - hdr_len;
10210 txb->fragments[j]->data + hdr_len,
10213 dev_kfree_skb_any(txb->fragments[i]);
10214 txb->fragments[i] = skb;
10215 tfd->u.data.chunk_ptr[i] =
10216 cpu_to_le32(dma_map_single(&priv->pci_dev->dev,
10217 skb->data,
10221 le32_add_cpu(&tfd->u.data.num_chunks, 1);
10226 q->first_empty = ipw_queue_inc_wrap(q->first_empty, q->n_bd);
10227 ipw_write32(priv, q->reg_w, q->first_empty);
10229 if (ipw_tx_queue_space(q) < q->high_mark)
10230 netif_stop_queue(priv->net_dev);
10245 struct clx2_tx_queue *txq = &priv->txq[tx_id];
10247 struct clx2_tx_queue *txq = &priv->txq[0];
10250 if (ipw_tx_queue_space(&txq->q) < txq->q.high_mark)
10263 u16 filter = priv->prom_priv->filter;
10272 hdr = (void *)txb->fragments[0]->data;
10273 if (libipw_is_management(le16_to_cpu(hdr->frame_control))) {
10278 } else if (libipw_is_control(le16_to_cpu(hdr->frame_control))) {
10283 } else if (libipw_is_data(le16_to_cpu(hdr->frame_control))) {
10290 for(n=0; n<txb->nr_frags; ++n) {
10291 struct sk_buff *src = txb->fragments[n];
10297 hdr = (void *)src->data;
10298 len = libipw_get_hdrlen(le16_to_cpu(hdr->frame_control));
10300 len = src->len;
10308 rt_hdr->it_version = PKTHDR_RADIOTAP_VERSION;
10309 rt_hdr->it_pad = 0;
10310 rt_hdr->it_present = 0; /* after all, it's just an idea */
10311 rt_hdr->it_present |= cpu_to_le32(1 << IEEE80211_RADIOTAP_CHANNEL);
10314 ieee80211chan2mhz(priv->channel));
10315 if (priv->channel > 14) /* 802.11a */
10319 else if (priv->ieee->mode == IEEE_B) /* 802.11b */
10328 rt_hdr->it_len = cpu_to_le16(dst->len);
10332 if (!libipw_rx(priv->prom_priv->ieee, dst, &dummystats))
10345 IPW_DEBUG_TX("dev->xmit(%d bytes)\n", txb->payload_size);
10346 spin_lock_irqsave(&priv->lock, flags);
10349 if (rtap_iface && netif_running(priv->prom_net_dev))
10356 spin_unlock_irqrestore(&priv->lock, flags);
10371 if (!is_valid_ether_addr(addr->sa_data))
10372 return -EADDRNOTAVAIL;
10373 mutex_lock(&priv->mutex);
10374 priv->config |= CFG_CUSTOM_MAC;
10375 memcpy(priv->mac_addr, addr->sa_data, ETH_ALEN);
10377 priv->net_dev->name, priv->mac_addr);
10378 schedule_work(&priv->adapter_restart);
10379 mutex_unlock(&priv->mutex);
10390 strscpy(info->driver, DRV_NAME, sizeof(info->driver));
10391 strscpy(info->version, DRV_VERSION, sizeof(info->version));
10396 strscpy(info->fw_version, vers, sizeof(info->fw_version));
10397 strscpy(info->bus_info, pci_name(p->pci_dev),
10398 sizeof(info->bus_info));
10404 return (priv->status & STATUS_ASSOCIATED) != 0;
10417 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
10418 return -EINVAL;
10419 mutex_lock(&p->mutex);
10420 memcpy(bytes, &p->eeprom[eeprom->offset], eeprom->len);
10421 mutex_unlock(&p->mutex);
10431 if (eeprom->offset + eeprom->len > IPW_EEPROM_IMAGE_SIZE)
10432 return -EINVAL;
10433 mutex_lock(&p->mutex);
10434 memcpy(&p->eeprom[eeprom->offset], bytes, eeprom->len);
10436 ipw_write8(p, i + IPW_EEPROM_DATA, p->eeprom[i]);
10437 mutex_unlock(&p->mutex);
10457 spin_lock(&priv->irq_lock);
10459 if (!(priv->status & STATUS_INT_ENABLED)) {
10486 priv->isr_inta = inta;
10488 tasklet_schedule(&priv->irq_tasklet);
10490 spin_unlock(&priv->irq_lock);
10494 spin_unlock(&priv->irq_lock);
10503 spin_lock_irqsave(&priv->lock, flags);
10507 schedule_delayed_work(&priv->rf_kill, 2 * HZ);
10513 if (!(priv->status & STATUS_RF_KILL_MASK)) {
10518 schedule_work(&priv->adapter_restart);
10524 spin_unlock_irqrestore(&priv->lock, flags);
10531 mutex_lock(&priv->mutex);
10533 mutex_unlock(&priv->mutex);
10538 priv->last_seq_num = -1;
10539 priv->last_frag_num = -1;
10540 priv->last_packet_time = 0;
10542 netif_carrier_on(priv->net_dev);
10544 cancel_delayed_work(&priv->request_scan);
10545 cancel_delayed_work(&priv->request_direct_scan);
10546 cancel_delayed_work(&priv->request_passive_scan);
10547 cancel_delayed_work(&priv->scan_event);
10550 priv->last_rate = ipw_get_current_rate(priv);
10555 if (priv->config & CFG_BACKGROUND_SCAN)
10556 schedule_delayed_work(&priv->request_scan, HZ);
10563 mutex_lock(&priv->mutex);
10565 mutex_unlock(&priv->mutex);
10571 netif_carrier_off(priv->net_dev);
10575 cancel_delayed_work(&priv->request_scan);
10576 cancel_delayed_work(&priv->request_direct_scan);
10577 cancel_delayed_work(&priv->request_passive_scan);
10578 cancel_delayed_work(&priv->adhoc_check);
10579 cancel_delayed_work(&priv->gather_stats);
10583 if (!(priv->status & STATUS_EXIT_PENDING)) {
10585 schedule_delayed_work(&priv->request_scan, 0);
10587 cancel_delayed_work(&priv->scan_event);
10594 mutex_lock(&priv->mutex);
10596 mutex_unlock(&priv->mutex);
10601 init_waitqueue_head(&priv->wait_command_queue);
10602 init_waitqueue_head(&priv->wait_state);
10604 INIT_DELAYED_WORK(&priv->adhoc_check, ipw_bg_adhoc_check);
10605 INIT_WORK(&priv->associate, ipw_bg_associate);
10606 INIT_WORK(&priv->disassociate, ipw_bg_disassociate);
10607 INIT_WORK(&priv->system_config, ipw_system_config);
10608 INIT_WORK(&priv->rx_replenish, ipw_bg_rx_queue_replenish);
10609 INIT_WORK(&priv->adapter_restart, ipw_bg_adapter_restart);
10610 INIT_DELAYED_WORK(&priv->rf_kill, ipw_bg_rf_kill);
10611 INIT_WORK(&priv->up, ipw_bg_up);
10612 INIT_WORK(&priv->down, ipw_bg_down);
10613 INIT_DELAYED_WORK(&priv->request_scan, ipw_request_scan);
10614 INIT_DELAYED_WORK(&priv->request_direct_scan, ipw_request_direct_scan);
10615 INIT_DELAYED_WORK(&priv->request_passive_scan, ipw_request_passive_scan);
10616 INIT_DELAYED_WORK(&priv->scan_event, ipw_scan_event);
10617 INIT_DELAYED_WORK(&priv->gather_stats, ipw_bg_gather_stats);
10618 INIT_WORK(&priv->abort_scan, ipw_bg_abort_scan);
10619 INIT_WORK(&priv->roam, ipw_bg_roam);
10620 INIT_DELAYED_WORK(&priv->scan_check, ipw_bg_scan_check);
10621 INIT_WORK(&priv->link_up, ipw_bg_link_up);
10622 INIT_WORK(&priv->link_down, ipw_bg_link_down);
10623 INIT_DELAYED_WORK(&priv->led_link_on, ipw_bg_led_link_on);
10624 INIT_DELAYED_WORK(&priv->led_link_off, ipw_bg_led_link_off);
10625 INIT_DELAYED_WORK(&priv->led_act_off, ipw_bg_led_activity_off);
10626 INIT_WORK(&priv->merge_networks, ipw_merge_adhoc_network);
10629 INIT_WORK(&priv->qos_activate, ipw_bg_qos_activate);
10632 tasklet_setup(&priv->irq_tasklet, ipw_irq_tasklet);
10640 for (i = 0; i < 4; i++) {
10641 if (sec->flags & (1 << i)) {
10642 priv->ieee->sec.encode_alg[i] = sec->encode_alg[i];
10643 priv->ieee->sec.key_sizes[i] = sec->key_sizes[i];
10644 if (sec->key_sizes[i] == 0)
10645 priv->ieee->sec.flags &= ~(1 << i);
10647 memcpy(priv->ieee->sec.keys[i], sec->keys[i],
10648 sec->key_sizes[i]);
10649 priv->ieee->sec.flags |= (1 << i);
10651 priv->status |= STATUS_SECURITY_UPDATED;
10652 } else if (sec->level != SEC_LEVEL_1)
10653 priv->ieee->sec.flags &= ~(1 << i);
10656 if (sec->flags & SEC_ACTIVE_KEY) {
10657 priv->ieee->sec.active_key = sec->active_key;
10658 priv->ieee->sec.flags |= SEC_ACTIVE_KEY;
10659 priv->status |= STATUS_SECURITY_UPDATED;
10661 priv->ieee->sec.flags &= ~SEC_ACTIVE_KEY;
10663 if ((sec->flags & SEC_AUTH_MODE) &&
10664 (priv->ieee->sec.auth_mode != sec->auth_mode)) {
10665 priv->ieee->sec.auth_mode = sec->auth_mode;
10666 priv->ieee->sec.flags |= SEC_AUTH_MODE;
10667 if (sec->auth_mode == WLAN_AUTH_SHARED_KEY)
10668 priv->capability |= CAP_SHARED_KEY;
10670 priv->capability &= ~CAP_SHARED_KEY;
10671 priv->status |= STATUS_SECURITY_UPDATED;
10674 if (sec->flags & SEC_ENABLED && priv->ieee->sec.enabled != sec->enabled) {
10675 priv->ieee->sec.flags |= SEC_ENABLED;
10676 priv->ieee->sec.enabled = sec->enabled;
10677 priv->status |= STATUS_SECURITY_UPDATED;
10678 if (sec->enabled)
10679 priv->capability |= CAP_PRIVACY_ON;
10681 priv->capability &= ~CAP_PRIVACY_ON;
10684 if (sec->flags & SEC_ENCRYPT)
10685 priv->ieee->sec.encrypt = sec->encrypt;
10687 if (sec->flags & SEC_LEVEL && priv->ieee->sec.level != sec->level) {
10688 priv->ieee->sec.level = sec->level;
10689 priv->ieee->sec.flags |= SEC_LEVEL;
10690 priv->status |= STATUS_SECURITY_UPDATED;
10693 if (!priv->ieee->host_encrypt && (sec->flags & SEC_ENCRYPT))
10700 if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING)) &&
10701 (((priv->assoc_request.capability &
10702 cpu_to_le16(WLAN_CAPABILITY_PRIVACY)) && !sec->enabled) ||
10703 (!(priv->assoc_request.capability &
10704 cpu_to_le16(WLAN_CAPABILITY_PRIVACY)) && sec->enabled))) {
10715 /* TODO: Mask out rates based on priv->rates_mask */
10719 switch (priv->ieee->freq_band) {
10721 rates->ieee_mode = IPW_A_MODE;
10722 rates->purpose = IPW_RATE_CAPABILITIES;
10727 default: /* Mixed or 2.4Ghz */
10728 rates->ieee_mode = IPW_G_MODE;
10729 rates->purpose = IPW_RATE_CAPABILITIES;
10732 if (priv->ieee->modulation & LIBIPW_OFDM_MODULATION) {
10751 if (ipw_send_adapter_address(priv, priv->net_dev->dev_addr))
10755 init_sys_config(&priv->sys_config);
10760 unsigned char bt_caps = priv->eeprom[EEPROM_SKU_CAPABILITY];
10763 priv->sys_config.bt_coexistence
10766 priv->sys_config.bt_coexistence
10771 if (priv->prom_net_dev && netif_running(priv->prom_net_dev)) {
10772 priv->sys_config.accept_all_data_frames = 1;
10773 priv->sys_config.accept_non_directed_frames = 1;
10774 priv->sys_config.accept_all_mgmt_bcpr = 1;
10775 priv->sys_config.accept_all_mgmt_frames = 1;
10779 if (priv->ieee->iw_mode == IW_MODE_ADHOC)
10780 priv->sys_config.answer_broadcast_ssid_probe = 1;
10782 priv->sys_config.answer_broadcast_ssid_probe = 0;
10787 init_supported_rates(priv, &priv->rates);
10788 if (ipw_send_supported_rates(priv, &priv->rates))
10791 /* Set request-to-send threshold */
10792 if (priv->rts_threshold) {
10793 if (ipw_send_rts_threshold(priv, priv->rts_threshold))
10808 priv->status |= STATUS_INIT;
10812 priv->notif_missed_beacons = 0;
10815 if ((priv->capability & CAP_PRIVACY_ON) &&
10816 (priv->ieee->sec.level == SEC_LEVEL_1) &&
10817 !(priv->ieee->host_encrypt || priv->ieee->host_decrypt))
10823 return -EIO;
10842 "---",
10845 {2427, 4}, {2432, 5}, {2437, 6},
10854 {2427, 4}, {2432, 5}, {2437, 6},
10872 {2427, 4}, {2432, 5}, {2437, 6},
10882 {2427, 4}, {2432, 5}, {2437, 6},
10905 {2427, 4}, {2432, 5}, {2437, 6},
10928 {2427, 4}, {2432, 5}, {2437, 6},
10931 .a_channels = 4,
10940 {2427, 4}, {2432, 5}, {2437, 6},
10949 {2427, 4}, {2432, 5}, {2437, 6},
10979 {2427, 4}, {2432, 5}, {2437, 6},
10983 .a_channels = 4,
10992 {2427, 4}, {2432, 5}, {2437, 6},
11003 {2427, 4}, {2432, 5}, {2437, 6},
11008 .a_channels = 4,
11017 {2427, 4}, {2432, 5}, {2437, 6},
11021 .a_channels = 4,
11030 {2427, 4}, {2432, 5}, {2437, 6},
11066 {2427, 4}, {2432, 5}, {2437, 6},
11091 if (!memcmp(&priv->eeprom[EEPROM_COUNTRY_CODE],
11098 priv->eeprom[EEPROM_COUNTRY_CODE + 0],
11099 priv->eeprom[EEPROM_COUNTRY_CODE + 1],
11100 priv->eeprom[EEPROM_COUNTRY_CODE + 2]);
11104 libipw_set_geo(priv->ieee, &ipw_geos[j]);
11113 if (priv->suspend_time) {
11114 libipw_networks_age(priv->ieee, priv->suspend_time);
11115 priv->suspend_time = 0;
11118 if (priv->status & STATUS_EXIT_PENDING)
11119 return -EIO;
11121 if (cmdlog && !priv->cmdlog) {
11122 priv->cmdlog = kcalloc(cmdlog, sizeof(*priv->cmdlog),
11124 if (priv->cmdlog == NULL) {
11127 return -ENOMEM;
11129 priv->cmdlog_len = cmdlog;
11143 if (!(priv->config & CFG_CUSTOM_MAC))
11144 eeprom_parse_mac(priv, priv->mac_addr);
11145 eth_hw_addr_set(priv->net_dev, priv->mac_addr);
11149 if (priv->status & STATUS_RF_KILL_SW) {
11156 schedule_delayed_work(&priv->rf_kill, 2 * HZ);
11164 /* If configure to try and auto-associate, kick
11166 schedule_delayed_work(&priv->request_scan, 0);
11184 return -EIO;
11191 mutex_lock(&priv->mutex);
11193 mutex_unlock(&priv->mutex);
11200 if (priv->status & STATUS_SCANNING) {
11205 if (priv->status & STATUS_ASSOCIATED) {
11215 for (i = 1000; i && (priv->status &
11217 STATUS_ASSOCIATED | STATUS_SCANNING)); i--)
11220 if (priv->status & (STATUS_DISASSOCIATING |
11224 IPW_DEBUG_INFO("Took %dms to de-init\n", 1000 - i);
11229 priv->status &= ~STATUS_INIT;
11234 int exit_pending = priv->status & STATUS_EXIT_PENDING;
11236 priv->status |= STATUS_EXIT_PENDING;
11244 priv->status &= ~STATUS_EXIT_PENDING;
11250 priv->status &= STATUS_RF_KILL_MASK | STATUS_EXIT_PENDING;
11251 netif_carrier_off(priv->net_dev);
11262 mutex_lock(&priv->mutex);
11264 mutex_unlock(&priv->mutex);
11271 const struct libipw_geo *geo = libipw_get_geo(priv->ieee);
11272 struct wireless_dev *wdev = &priv->ieee->wdev;
11274 memcpy(wdev->wiphy->perm_addr, priv->mac_addr, ETH_ALEN);
11276 /* fill-out priv->ieee->bg_band */
11277 if (geo->bg_channels) {
11278 struct ieee80211_supported_band *bg_band = &priv->ieee->bg_band;
11280 bg_band->band = NL80211_BAND_2GHZ;
11281 bg_band->n_channels = geo->bg_channels;
11282 bg_band->channels = kcalloc(geo->bg_channels,
11285 if (!bg_band->channels) {
11286 rc = -ENOMEM;
11289 /* translate geo->bg to bg_band.channels */
11290 for (i = 0; i < geo->bg_channels; i++) {
11291 bg_band->channels[i].band = NL80211_BAND_2GHZ;
11292 bg_band->channels[i].center_freq = geo->bg[i].freq;
11293 bg_band->channels[i].hw_value = geo->bg[i].channel;
11294 bg_band->channels[i].max_power = geo->bg[i].max_power;
11295 if (geo->bg[i].flags & LIBIPW_CH_PASSIVE_ONLY)
11296 bg_band->channels[i].flags |=
11298 if (geo->bg[i].flags & LIBIPW_CH_NO_IBSS)
11299 bg_band->channels[i].flags |=
11301 if (geo->bg[i].flags & LIBIPW_CH_RADAR_DETECT)
11302 bg_band->channels[i].flags |=
11309 bg_band->bitrates = ipw2200_bg_rates;
11310 bg_band->n_bitrates = ipw2200_num_bg_rates;
11312 wdev->wiphy->bands[NL80211_BAND_2GHZ] = bg_band;
11315 /* fill-out priv->ieee->a_band */
11316 if (geo->a_channels) {
11317 struct ieee80211_supported_band *a_band = &priv->ieee->a_band;
11319 a_band->band = NL80211_BAND_5GHZ;
11320 a_band->n_channels = geo->a_channels;
11321 a_band->channels = kcalloc(geo->a_channels,
11324 if (!a_band->channels) {
11325 rc = -ENOMEM;
11328 /* translate geo->a to a_band.channels */
11329 for (i = 0; i < geo->a_channels; i++) {
11330 a_band->channels[i].band = NL80211_BAND_5GHZ;
11331 a_band->channels[i].center_freq = geo->a[i].freq;
11332 a_band->channels[i].hw_value = geo->a[i].channel;
11333 a_band->channels[i].max_power = geo->a[i].max_power;
11334 if (geo->a[i].flags & LIBIPW_CH_PASSIVE_ONLY)
11335 a_band->channels[i].flags |=
11337 if (geo->a[i].flags & LIBIPW_CH_NO_IBSS)
11338 a_band->channels[i].flags |=
11340 if (geo->a[i].flags & LIBIPW_CH_RADAR_DETECT)
11341 a_band->channels[i].flags |=
11348 a_band->bitrates = ipw2200_a_rates;
11349 a_band->n_bitrates = ipw2200_num_a_rates;
11351 wdev->wiphy->bands[NL80211_BAND_5GHZ] = a_band;
11354 wdev->wiphy->cipher_suites = ipw_cipher_suites;
11355 wdev->wiphy->n_cipher_suites = ARRAY_SIZE(ipw_cipher_suites);
11357 set_wiphy_dev(wdev->wiphy, &priv->pci_dev->dev);
11360 rc = wiphy_register(wdev->wiphy);
11366 kfree(priv->ieee->a_band.channels);
11367 kfree(priv->ieee->bg_band.channels);
11439 struct ipw_priv *priv = prom_priv->priv;
11441 IPW_DEBUG_INFO("prom dev->open\n");
11444 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
11445 priv->sys_config.accept_all_data_frames = 1;
11446 priv->sys_config.accept_non_directed_frames = 1;
11447 priv->sys_config.accept_all_mgmt_bcpr = 1;
11448 priv->sys_config.accept_all_mgmt_frames = 1;
11459 struct ipw_priv *priv = prom_priv->priv;
11461 IPW_DEBUG_INFO("prom dev->stop\n");
11463 if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
11464 priv->sys_config.accept_all_data_frames = 0;
11465 priv->sys_config.accept_non_directed_frames = 0;
11466 priv->sys_config.accept_all_mgmt_bcpr = 0;
11467 priv->sys_config.accept_all_mgmt_frames = 0;
11478 IPW_DEBUG_INFO("prom dev->xmit\n");
11495 if (priv->prom_net_dev)
11496 return -EPERM;
11498 priv->prom_net_dev = alloc_libipw(sizeof(struct ipw_prom_priv), 1);
11499 if (priv->prom_net_dev == NULL)
11500 return -ENOMEM;
11502 priv->prom_priv = libipw_priv(priv->prom_net_dev);
11503 priv->prom_priv->ieee = netdev_priv(priv->prom_net_dev);
11504 priv->prom_priv->priv = priv;
11506 strcpy(priv->prom_net_dev->name, "rtap%d");
11507 eth_hw_addr_set(priv->prom_net_dev, priv->mac_addr);
11509 priv->prom_net_dev->type = ARPHRD_IEEE80211_RADIOTAP;
11510 priv->prom_net_dev->netdev_ops = &ipw_prom_netdev_ops;
11512 priv->prom_net_dev->min_mtu = 68;
11513 priv->prom_net_dev->max_mtu = LIBIPW_DATA_LEN;
11515 priv->prom_priv->ieee->iw_mode = IW_MODE_MONITOR;
11516 SET_NETDEV_DEV(priv->prom_net_dev, &priv->pci_dev->dev);
11518 rc = register_netdev(priv->prom_net_dev);
11520 free_libipw(priv->prom_net_dev, 1);
11521 priv->prom_net_dev = NULL;
11530 if (!priv->prom_net_dev)
11533 unregister_netdev(priv->prom_net_dev);
11534 free_libipw(priv->prom_net_dev, 1);
11536 priv->prom_net_dev = NULL;
11562 err = -ENOMEM;
11567 priv->ieee = netdev_priv(net_dev);
11569 priv->net_dev = net_dev;
11570 priv->pci_dev = pdev;
11572 spin_lock_init(&priv->irq_lock);
11573 spin_lock_init(&priv->lock);
11575 INIT_LIST_HEAD(&priv->ibss_mac_hash[i]);
11577 mutex_init(&priv->mutex);
11579 err = -ENODEV;
11585 err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
11587 err = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
11606 priv->hw_len = length;
11610 err = -ENODEV;
11614 priv->hw_base = base;
11622 err = request_irq(pdev->irq, ipw_isr, IRQF_SHARED, DRV_NAME, priv);
11624 IPW_ERROR("Error allocating IRQ %d\n", pdev->irq);
11628 SET_NETDEV_DEV(net_dev, &pdev->dev);
11630 mutex_lock(&priv->mutex);
11632 priv->ieee->hard_start_xmit = ipw_net_hard_start_xmit;
11633 priv->ieee->set_security = shim__set_security;
11634 priv->ieee->is_queue_full = ipw_net_is_queue_full;
11637 priv->ieee->is_qos_active = ipw_is_qos_active;
11638 priv->ieee->handle_probe_response = ipw_handle_beacon;
11639 priv->ieee->handle_beacon = ipw_handle_probe_response;
11640 priv->ieee->handle_assoc_response = ipw_handle_assoc_response;
11643 priv->ieee->perfect_rssi = -20;
11644 priv->ieee->worst_rssi = -85;
11646 net_dev->netdev_ops = &ipw_netdev_ops;
11647 priv->ieee->spy_enabled = true;
11648 net_dev->wireless_handlers = &ipw_wx_handler_def;
11649 net_dev->ethtool_ops = &ipw_ethtool_ops;
11651 net_dev->min_mtu = 68;
11652 net_dev->max_mtu = LIBIPW_DATA_LEN;
11654 err = sysfs_create_group(&pdev->dev.kobj, &ipw_attribute_group);
11657 mutex_unlock(&priv->mutex);
11662 mutex_unlock(&priv->mutex);
11663 err = -EIO;
11667 mutex_unlock(&priv->mutex);
11687 unregister_netdev(priv->net_dev);
11695 priv->ieee->geo.name, priv->ieee->geo.bg_channels,
11696 priv->ieee->geo.a_channels);
11701 wiphy_unregister(priv->ieee->wdev.wiphy);
11702 kfree(priv->ieee->a_band.channels);
11703 kfree(priv->ieee->bg_band.channels);
11705 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11707 free_irq(pdev->irq, priv);
11709 iounmap(priv->hw_base);
11715 free_libipw(priv->net_dev, 0);
11729 mutex_lock(&priv->mutex);
11731 priv->status |= STATUS_EXIT_PENDING;
11733 sysfs_remove_group(&pdev->dev.kobj, &ipw_attribute_group);
11735 mutex_unlock(&priv->mutex);
11737 unregister_netdev(priv->net_dev);
11739 if (priv->rxq) {
11740 ipw_rx_queue_free(priv, priv->rxq);
11741 priv->rxq = NULL;
11745 if (priv->cmdlog) {
11746 kfree(priv->cmdlog);
11747 priv->cmdlog = NULL;
11751 cancel_delayed_work_sync(&priv->adhoc_check);
11752 cancel_work_sync(&priv->associate);
11753 cancel_work_sync(&priv->disassociate);
11754 cancel_work_sync(&priv->system_config);
11755 cancel_work_sync(&priv->rx_replenish);
11756 cancel_work_sync(&priv->adapter_restart);
11757 cancel_delayed_work_sync(&priv->rf_kill);
11758 cancel_work_sync(&priv->up);
11759 cancel_work_sync(&priv->down);
11760 cancel_delayed_work_sync(&priv->request_scan);
11761 cancel_delayed_work_sync(&priv->request_direct_scan);
11762 cancel_delayed_work_sync(&priv->request_passive_scan);
11763 cancel_delayed_work_sync(&priv->scan_event);
11764 cancel_delayed_work_sync(&priv->gather_stats);
11765 cancel_work_sync(&priv->abort_scan);
11766 cancel_work_sync(&priv->roam);
11767 cancel_delayed_work_sync(&priv->scan_check);
11768 cancel_work_sync(&priv->link_up);
11769 cancel_work_sync(&priv->link_down);
11770 cancel_delayed_work_sync(&priv->led_link_on);
11771 cancel_delayed_work_sync(&priv->led_link_off);
11772 cancel_delayed_work_sync(&priv->led_act_off);
11773 cancel_work_sync(&priv->merge_networks);
11777 list_for_each_safe(p, q, &priv->ibss_mac_hash[i]) {
11783 kfree(priv->error);
11784 priv->error = NULL;
11790 free_irq(pdev->irq, priv);
11791 iounmap(priv->hw_base);
11795 wiphy_unregister(priv->ieee->wdev.wiphy);
11796 kfree(priv->ieee->a_band.channels);
11797 kfree(priv->ieee->bg_band.channels);
11798 free_libipw(priv->net_dev, 0);
11805 struct net_device *dev = priv->net_dev;
11807 printk(KERN_INFO "%s: Going into suspend...\n", dev->name);
11815 priv->suspend_at = ktime_get_boottime_seconds();
11824 struct net_device *dev = priv->net_dev;
11827 printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
11831 * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
11843 priv->suspend_time = ktime_get_boottime_seconds() - priv->suspend_at;
11846 schedule_work(&priv->up);
11922 MODULE_PARM_DESC(rtap_iface, "create the rtap interface (1 - create, default 0)");
11951 MODULE_PARM_DESC(bt_coexist, "enable bluetooth coexistence (default off)");