Skip to content

L
linux
Commit ea2b26e0 authored by James Ketrenos's avatar James Ketrenos
Browse files
Options

Catch ipw2200 up to equivelancy with v1.0.1 

This commit contains the following fixes:

Fixed #559: iwconfig rate support (thanks to Florian Hackenberger)

Improved link signal quality calculation (thanks to Bill Moss)

Fixed a problem with sensitivity threshold during association

Added iwpriv for turning forcing long preamble support:
  % iwpriv eth1 set_preamble 1|0

Fixed #542 and #377 support for short preamble

Fixed locked BSSID reporting channel number (thanks to Pedro
Ramalhais)

Fixed type-o with scan watchdog timeout message (thanks to Pedro
Ramalhais)

Changed logic for displaying get_mode output so the code is easier to
follow (thanks to Pedro Ramalhais)

Added initial support for WPA (thanks to Yi Zhu) -- tested with
wpa_supplicant (either tip w/ ipw driver, or with -Dipw2100) with
both CCMP and TKIP

Fixed problem with CCMP not working due to uninitialized 802.11
header fields (thanks to Pedro Ramalhais)

Bug references are to defects stored on http://bughost.orgSigned-off-by: default avatarJames Ketrenos <jketreno@linux.intel.com>
parent a1e695ad
Hide whitespace changes
Inline Side-by-side
Showing with 1247 additions and 470 deletions
drivers/net/wireless/ipw2200.c
View file @ ea2b26e0
...@@ -32,7 +32,7 @@ ...@@ -32,7 +32,7 @@
#include "ipw2200.h" #include "ipw2200.h"
#define IPW2200_VERSION "1.0.0" #define IPW2200_VERSION "1.0.1"
#define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2200/2915 Network Driver" #define DRV_DESCRIPTION "Intel(R) PRO/Wireless 2200/2915 Network Driver"
#define DRV_COPYRIGHT "Copyright(c) 2003-2004 Intel Corporation" #define DRV_COPYRIGHT "Copyright(c) 2003-2004 Intel Corporation"
#define DRV_VERSION IPW2200_VERSION #define DRV_VERSION IPW2200_VERSION
...@@ -44,7 +44,6 @@ MODULE_LICENSE("GPL"); ...@@ -44,7 +44,6 @@ MODULE_LICENSE("GPL");
static int debug = 0; static int debug = 0;
static int channel = 0; static int channel = 0;
static char *ifname;
static int mode = 0; static int mode = 0;
static u32 ipw_debug_level; static u32 ipw_debug_level;
...@@ -289,32 +288,33 @@ static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf, ...@@ -289,32 +288,33 @@ static void _ipw_read_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
{ {
u32 aligned_addr = addr & CX2_INDIRECT_ADDR_MASK; u32 aligned_addr = addr & CX2_INDIRECT_ADDR_MASK;
u32 dif_len = addr - aligned_addr; u32 dif_len = addr - aligned_addr;
u32 aligned_len;
u32 i; u32 i;
IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num); IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
if (num <= 0) {
return;
}
/* Read the first nibble byte by byte */ /* Read the first nibble byte by byte */
if (unlikely(dif_len)) { if (unlikely(dif_len)) {
/* Start reading at aligned_addr + dif_len */
_ipw_write32(priv, CX2_INDIRECT_ADDR, aligned_addr); _ipw_write32(priv, CX2_INDIRECT_ADDR, aligned_addr);
for (i = dif_len; i < 4; i++, buf++) /* Start reading at aligned_addr + dif_len */
*buf = _ipw_read8(priv, CX2_INDIRECT_DATA + i); for (i = dif_len; ((i < 4) && (num > 0)); i++, num--)
num -= dif_len; *buf++ = _ipw_read8(priv, CX2_INDIRECT_DATA + i);
aligned_addr += 4; aligned_addr += 4;
} }
/* Read DWs through autoinc register */
_ipw_write32(priv, CX2_AUTOINC_ADDR, aligned_addr); _ipw_write32(priv, CX2_AUTOINC_ADDR, aligned_addr);
aligned_len = num & CX2_INDIRECT_ADDR_MASK; for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4) *(u32 *) buf = _ipw_read32(priv, CX2_AUTOINC_DATA);
*(u32 *) buf = ipw_read32(priv, CX2_AUTOINC_DATA);
/* Copy the last nibble */ /* Copy the last nibble */
dif_len = num - aligned_len; if (unlikely(num)) {
_ipw_write32(priv, CX2_INDIRECT_ADDR, aligned_addr); _ipw_write32(priv, CX2_INDIRECT_ADDR, aligned_addr);
for (i = 0; i < dif_len; i++, buf++) for (i = 0; num > 0; i++, num--)
*buf = ipw_read8(priv, CX2_INDIRECT_DATA + i); *buf++ = ipw_read8(priv, CX2_INDIRECT_DATA + i);
}
} }
static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf, static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
...@@ -322,32 +322,33 @@ static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf, ...@@ -322,32 +322,33 @@ static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * buf,
{ {
u32 aligned_addr = addr & CX2_INDIRECT_ADDR_MASK; u32 aligned_addr = addr & CX2_INDIRECT_ADDR_MASK;
u32 dif_len = addr - aligned_addr; u32 dif_len = addr - aligned_addr;
u32 aligned_len;
u32 i; u32 i;
IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num); IPW_DEBUG_IO("addr = %i, buf = %p, num = %i\n", addr, buf, num);
if (num <= 0) {
return;
}
/* Write the first nibble byte by byte */ /* Write the first nibble byte by byte */
if (unlikely(dif_len)) { if (unlikely(dif_len)) {
/* Start writing at aligned_addr + dif_len */
_ipw_write32(priv, CX2_INDIRECT_ADDR, aligned_addr); _ipw_write32(priv, CX2_INDIRECT_ADDR, aligned_addr);
for (i = dif_len; i < 4; i++, buf++) /* Start reading at aligned_addr + dif_len */
for (i = dif_len; ((i < 4) && (num > 0)); i++, num--, buf++)
_ipw_write8(priv, CX2_INDIRECT_DATA + i, *buf); _ipw_write8(priv, CX2_INDIRECT_DATA + i, *buf);
num -= dif_len;
aligned_addr += 4; aligned_addr += 4;
} }
/* Write DWs through autoinc register */
_ipw_write32(priv, CX2_AUTOINC_ADDR, aligned_addr); _ipw_write32(priv, CX2_AUTOINC_ADDR, aligned_addr);
aligned_len = num & CX2_INDIRECT_ADDR_MASK; for (; num >= 4; buf += 4, aligned_addr += 4, num -= 4)
for (i = 0; i < aligned_len; i += 4, buf += 4, aligned_addr += 4)
_ipw_write32(priv, CX2_AUTOINC_DATA, *(u32 *) buf); _ipw_write32(priv, CX2_AUTOINC_DATA, *(u32 *) buf);
/* Copy the last nibble */ /* Copy the last nibble */
dif_len = num - aligned_len; if (unlikely(num)) {
_ipw_write32(priv, CX2_INDIRECT_ADDR, aligned_addr); _ipw_write32(priv, CX2_INDIRECT_ADDR, aligned_addr);
for (i = 0; i < dif_len; i++, buf++) for (i = 0; num > 0; i++, num--, buf++)
_ipw_write8(priv, CX2_INDIRECT_DATA + i, *buf); _ipw_write8(priv, CX2_INDIRECT_DATA + i, *buf);
}
} }
static void ipw_write_direct(struct ipw_priv *priv, u32 addr, void *buf, static void ipw_write_direct(struct ipw_priv *priv, u32 addr, void *buf,
...@@ -945,7 +946,7 @@ static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr, ...@@ -945,7 +946,7 @@ static ssize_t show_rf_kill(struct device *d, struct device_attribute *attr,
static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio) static int ipw_radio_kill_sw(struct ipw_priv *priv, int disable_radio)
{ {
if ((disable_radio ? 1 : 0) == if ((disable_radio ? 1 : 0) ==
(priv->status & STATUS_RF_KILL_SW ? 1 : 0)) ((priv->status & STATUS_RF_KILL_SW) ? 1 : 0))
return 0; return 0;
IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n", IPW_DEBUG_RF_KILL("Manual SW RF Kill set to: RADIO %s\n",
...@@ -987,6 +988,17 @@ static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr, ...@@ -987,6 +988,17 @@ static ssize_t store_rf_kill(struct device *d, struct device_attribute *attr,
static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill); static DEVICE_ATTR(rf_kill, S_IWUSR | S_IRUGO, show_rf_kill, store_rf_kill);
static void notify_wx_assoc_event(struct ipw_priv *priv)
{
union iwreq_data wrqu;
wrqu.ap_addr.sa_family = ARPHRD_ETHER;
if (priv->status & STATUS_ASSOCIATED)
memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
else
memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
}
static void ipw_irq_tasklet(struct ipw_priv *priv) static void ipw_irq_tasklet(struct ipw_priv *priv)
{ {
u32 inta, inta_mask, handled = 0; u32 inta, inta_mask, handled = 0;
...@@ -1071,6 +1083,8 @@ static void ipw_irq_tasklet(struct ipw_priv *priv) ...@@ -1071,6 +1083,8 @@ static void ipw_irq_tasklet(struct ipw_priv *priv)
wake_up_interruptible(&priv->wait_command_queue); wake_up_interruptible(&priv->wait_command_queue);
netif_carrier_off(priv->net_dev); netif_carrier_off(priv->net_dev);
netif_stop_queue(priv->net_dev); netif_stop_queue(priv->net_dev);
priv->status &= ~(STATUS_ASSOCIATED | STATUS_ASSOCIATING);
notify_wx_assoc_event(priv);
cancel_delayed_work(&priv->request_scan); cancel_delayed_work(&priv->request_scan);
queue_delayed_work(priv->workqueue, &priv->rf_kill, 2 * HZ); queue_delayed_work(priv->workqueue, &priv->rf_kill, 2 * HZ);
handled |= CX2_INTA_BIT_RF_KILL_DONE; handled |= CX2_INTA_BIT_RF_KILL_DONE;
...@@ -1162,7 +1176,7 @@ static char *get_cmd_string(u8 cmd) ...@@ -1162,7 +1176,7 @@ static char *get_cmd_string(u8 cmd)
return "UNKNOWN"; return "UNKNOWN";
} }
} }
#endif /* CONFIG_IPW_DEBUG */ #endif
#define HOST_COMPLETE_TIMEOUT HZ #define HOST_COMPLETE_TIMEOUT HZ
static int ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd) static int ipw_send_cmd(struct ipw_priv *priv, struct host_cmd *cmd)
...@@ -2445,10 +2459,10 @@ static int ipw_load(struct ipw_priv *priv) ...@@ -2445,10 +2459,10 @@ static int ipw_load(struct ipw_priv *priv)
rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("ibss")); rc = ipw_get_fw(priv, &firmware, IPW_FW_NAME("ibss"));
break; break;
#ifdef CONFIG_IPW_PROMISC #ifdef CONFIG_IPW_MONITOR
case IW_MODE_MONITOR: case IW_MODE_MONITOR:
rc = ipw_get_fw(priv, &ucode, rc = ipw_get_fw(priv, &ucode,
IPW_FW_NAME("ibss_ucode")); IPW_FW_NAME("sniffer_ucode"));
if (rc) if (rc)
goto error; goto error;
...@@ -2929,17 +2943,6 @@ static void ipw_disassociate(void *data) ...@@ -2929,17 +2943,6 @@ static void ipw_disassociate(void *data)
ipw_send_disassociate(data, 0); ipw_send_disassociate(data, 0);
} }
static void notify_wx_assoc_event(struct ipw_priv *priv)
{
union iwreq_data wrqu;
wrqu.ap_addr.sa_family = ARPHRD_ETHER;
if (priv->status & STATUS_ASSOCIATED)
memcpy(wrqu.ap_addr.sa_data, priv->bssid, ETH_ALEN);
else
memset(wrqu.ap_addr.sa_data, 0, ETH_ALEN);
wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
}
struct ipw_status_code { struct ipw_status_code {
u16 status; u16 status;
const char *reason; const char *reason;
...@@ -2997,7 +3000,7 @@ static const char *ipw_get_status_code(u16 status) ...@@ -2997,7 +3000,7 @@ static const char *ipw_get_status_code(u16 status)
{ {
int i; int i;
for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++) for (i = 0; i < ARRAY_SIZE(ipw_status_codes); i++)
if (ipw_status_codes[i].status == status) if (ipw_status_codes[i].status == (status & 0xff))
return ipw_status_codes[i].reason; return ipw_status_codes[i].reason;
return "Unknown status value."; return "Unknown status value.";
} }
...@@ -3076,18 +3079,30 @@ static inline u32 ipw_get_max_rate(struct ipw_priv *priv) ...@@ -3076,18 +3079,30 @@ static inline u32 ipw_get_max_rate(struct ipw_priv *priv)
while (i && !(mask & i)) while (i && !(mask & i))
i >>= 1; i >>= 1;
switch (i) { switch (i) {
case IEEE80211_CCK_RATE_1MB_MASK: return 1000000; case IEEE80211_CCK_RATE_1MB_MASK:
case IEEE80211_CCK_RATE_2MB_MASK: return 2000000; return 1000000;
case IEEE80211_CCK_RATE_5MB_MASK: return 5500000; case IEEE80211_CCK_RATE_2MB_MASK:
case IEEE80211_OFDM_RATE_6MB_MASK: return 6000000; return 2000000;
case IEEE80211_OFDM_RATE_9MB_MASK: return 9000000; case IEEE80211_CCK_RATE_5MB_MASK:
case IEEE80211_CCK_RATE_11MB_MASK: return 11000000; return 5500000;
case IEEE80211_OFDM_RATE_12MB_MASK: return 12000000; case IEEE80211_OFDM_RATE_6MB_MASK:
case IEEE80211_OFDM_RATE_18MB_MASK: return 18000000; return 6000000;
case IEEE80211_OFDM_RATE_24MB_MASK: return 24000000; case IEEE80211_OFDM_RATE_9MB_MASK:
case IEEE80211_OFDM_RATE_36MB_MASK: return 36000000; return 9000000;
case IEEE80211_OFDM_RATE_48MB_MASK: return 48000000; case IEEE80211_CCK_RATE_11MB_MASK:
case IEEE80211_OFDM_RATE_54MB_MASK: return 54000000; return 11000000;
case IEEE80211_OFDM_RATE_12MB_MASK:
return 12000000;
case IEEE80211_OFDM_RATE_18MB_MASK:
return 18000000;
case IEEE80211_OFDM_RATE_24MB_MASK:
return 24000000;
case IEEE80211_OFDM_RATE_36MB_MASK:
return 36000000;
case IEEE80211_OFDM_RATE_48MB_MASK:
return 48000000;
case IEEE80211_OFDM_RATE_54MB_MASK:
return 54000000;
} }
if (priv->ieee->mode == IEEE_B) if (priv->ieee->mode == IEEE_B)
...@@ -3115,24 +3130,36 @@ static u32 ipw_get_current_rate(struct ipw_priv *priv) ...@@ -3115,24 +3130,36 @@ static u32 ipw_get_current_rate(struct ipw_priv *priv)
return ipw_get_max_rate(priv); return ipw_get_max_rate(priv);
switch (rate) { switch (rate) {
case IPW_TX_RATE_1MB: return 1000000; case IPW_TX_RATE_1MB:
case IPW_TX_RATE_2MB: return 2000000; return 1000000;
case IPW_TX_RATE_5MB: return 5500000; case IPW_TX_RATE_2MB:
case IPW_TX_RATE_6MB: return 6000000; return 2000000;
case IPW_TX_RATE_9MB: return 9000000; case IPW_TX_RATE_5MB:
case IPW_TX_RATE_11MB: return 11000000; return 5500000;
case IPW_TX_RATE_12MB: return 12000000; case IPW_TX_RATE_6MB:
case IPW_TX_RATE_18MB: return 18000000; return 6000000;
case IPW_TX_RATE_24MB: return 24000000; case IPW_TX_RATE_9MB:
case IPW_TX_RATE_36MB: return 36000000; return 9000000;
case IPW_TX_RATE_48MB: return 48000000; case IPW_TX_RATE_11MB:
case IPW_TX_RATE_54MB: return 54000000; return 11000000;
case IPW_TX_RATE_12MB:
return 12000000;
case IPW_TX_RATE_18MB:
return 18000000;
case IPW_TX_RATE_24MB:
return 24000000;
case IPW_TX_RATE_36MB:
return 36000000;
case IPW_TX_RATE_48MB:
return 48000000;
case IPW_TX_RATE_54MB:
return 54000000;
} }
return 0; return 0;
} }
#define PERFECT_RSSI (-50) #define PERFECT_RSSI (-20)
#define WORST_RSSI (-85) #define WORST_RSSI (-85)
#define IPW_STATS_INTERVAL (2 * HZ) #define IPW_STATS_INTERVAL (2 * HZ)
static void ipw_gather_stats(struct ipw_priv *priv) static void ipw_gather_stats(struct ipw_priv *priv)
...@@ -3145,6 +3172,7 @@ static void ipw_gather_stats(struct ipw_priv *priv) ...@@ -3145,6 +3172,7 @@ static void ipw_gather_stats(struct ipw_priv *priv)
s16 rssi; s16 rssi;
u32 beacon_quality, signal_quality, tx_quality, rx_quality, u32 beacon_quality, signal_quality, tx_quality, rx_quality,
rate_quality; rate_quality;
u32 max_rate;
if (!(priv->status & STATUS_ASSOCIATED)) { if (!(priv->status & STATUS_ASSOCIATED)) {
priv->quality = 0; priv->quality = 0;
...@@ -3201,7 +3229,8 @@ static void ipw_gather_stats(struct ipw_priv *priv) ...@@ -3201,7 +3229,8 @@ static void ipw_gather_stats(struct ipw_priv *priv)
beacon_quality, missed_beacons_percent); beacon_quality, missed_beacons_percent);
priv->last_rate = ipw_get_current_rate(priv); priv->last_rate = ipw_get_current_rate(priv);
rate_quality = priv->last_rate * 40 / priv->last_rate + 60; max_rate = ipw_get_max_rate(priv);
rate_quality = priv->last_rate * 40 / max_rate + 60;
IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n", IPW_DEBUG_STATS("Rate quality : %3d%% (%dMbs)\n",
rate_quality, priv->last_rate / 1000000); rate_quality, priv->last_rate / 1000000);
...@@ -3226,9 +3255,16 @@ static void ipw_gather_stats(struct ipw_priv *priv) ...@@ -3226,9 +3255,16 @@ static void ipw_gather_stats(struct ipw_priv *priv)
signal_quality = 100; signal_quality = 100;
else if (rssi < WORST_RSSI) else if (rssi < WORST_RSSI)
signal_quality = 0; signal_quality = 0;
else else /* qual = 100a^2 - 15ab + 62b^2 / a^2 */
signal_quality = (rssi - WORST_RSSI) * 100 / signal_quality =
(PERFECT_RSSI - WORST_RSSI); (100 *
(PERFECT_RSSI - WORST_RSSI) *
(PERFECT_RSSI - WORST_RSSI) -
(PERFECT_RSSI - rssi) *
(15 * (PERFECT_RSSI - WORST_RSSI) +
62 * (PERFECT_RSSI - rssi))) /
((PERFECT_RSSI - WORST_RSSI) * (PERFECT_RSSI - WORST_RSSI));
IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n", IPW_DEBUG_STATS("Signal level : %3d%% (%d dBm)\n",
signal_quality, rssi); signal_quality, rssi);
...@@ -3257,6 +3293,62 @@ static void ipw_gather_stats(struct ipw_priv *priv) ...@@ -3257,6 +3293,62 @@ static void ipw_gather_stats(struct ipw_priv *priv)
IPW_STATS_INTERVAL); IPW_STATS_INTERVAL);
} }
static inline void ipw_handle_missed_beacon(struct ipw_priv *priv,
int missed_count)
{
priv->notif_missed_beacons = missed_count;
if (missed_count > priv->missed_beacon_threshold &&
priv->status & STATUS_ASSOCIATED) {
/* If associated and we've hit the missed
* beacon threshold, disassociate, turn
* off roaming, and abort any active scans */
IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
IPW_DL_STATE,
"Missed beacon: %d - disassociate\n", missed_count);
priv->status &= ~STATUS_ROAMING;
if (priv->status & STATUS_SCANNING)
queue_work(priv->workqueue, &priv->abort_scan);
queue_work(priv->workqueue, &priv->disassociate);
return;
}
if (priv->status & STATUS_ROAMING) {
/* If we are currently roaming, then just
* print a debug statement... */
IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
"Missed beacon: %d - roam in progress\n",
missed_count);
return;
}
if (missed_count > priv->roaming_threshold) {
/* If we are not already roaming, set the ROAM
* bit in the status and kick off a scan */
IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
"Missed beacon: %d - initiate "
"roaming\n", missed_count);
if (!(priv->status & STATUS_ROAMING)) {
priv->status |= STATUS_ROAMING;
if (!(priv->status & STATUS_SCANNING))
queue_work(priv->workqueue,
&priv->request_scan);
}
return;
}
if (priv->status & STATUS_SCANNING) {
/* Stop scan to keep fw from getting
* stuck (only if we aren't roaming --
* otherwise we'll never scan more than 2 or 3
* channels..) */
queue_work(priv->workqueue, &priv->abort_scan);
}
IPW_DEBUG_NOTIF("Missed beacon: %d\n", missed_count);
}
/** /**
* Handle host notification packet. * Handle host notification packet.
* Called from interrupt routine * Called from interrupt routine
...@@ -3383,6 +3475,24 @@ static inline void ipw_rx_notification(struct ipw_priv *priv, ...@@ -3383,6 +3475,24 @@ static inline void ipw_rx_notification(struct ipw_priv *priv,
} }
case CMAS_INIT:{ case CMAS_INIT:{
if (priv->status & STATUS_AUTH) {
struct
ieee80211_assoc_response
*resp;
resp =
(struct
ieee80211_assoc_response
*)&notif->u.raw;
IPW_DEBUG(IPW_DL_NOTIF |
IPW_DL_STATE |
IPW_DL_ASSOC,
"association failed (0x%04X): %s\n",
ntohs(resp->status),
ipw_get_status_code
(ntohs
(resp->status)));
}
IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE | IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE |
IPW_DL_ASSOC, IPW_DL_ASSOC,
"disassociated: '%s' " MAC_FMT "disassociated: '%s' " MAC_FMT
...@@ -3629,36 +3739,8 @@ static inline void ipw_rx_notification(struct ipw_priv *priv, ...@@ -3629,36 +3739,8 @@ static inline void ipw_rx_notification(struct ipw_priv *priv,
break; break;
} }
if (x->state == HOST_NOTIFICATION_STATUS_BEACON_MISSING) { if (x->state == HOST_NOTIFICATION_STATUS_BEACON_MISSING)
if (priv->status & STATUS_SCANNING) { ipw_handle_missed_beacon(priv, x->number);
/* Stop scan to keep fw from getting
* stuck... */
queue_work(priv->workqueue,
&priv->abort_scan);
}
if (x->number > priv->missed_beacon_threshold &&
priv->status & STATUS_ASSOCIATED) {
IPW_DEBUG(IPW_DL_INFO | IPW_DL_NOTIF |
IPW_DL_STATE,
"Missed beacon: %d - disassociate\n",
x->number);
queue_work(priv->workqueue,
&priv->disassociate);
} else if (x->number > priv->roaming_threshold) {
IPW_DEBUG(IPW_DL_NOTIF | IPW_DL_STATE,
"Missed beacon: %d - initiate "
"roaming\n", x->number);
queue_work(priv->workqueue,
&priv->roam);
} else {
IPW_DEBUG_NOTIF("Missed beacon: %d\n",
x->number);
}
priv->notif_missed_beacons = x->number;
}
break; break;
} }
...@@ -4137,6 +4219,13 @@ static int ipw_compatible_rates(struct ipw_priv *priv, ...@@ -4137,6 +4219,13 @@ static int ipw_compatible_rates(struct ipw_priv *priv,
for (i = 0; i < num_rates; i++) { for (i = 0; i < num_rates; i++) {
if (!ipw_is_rate_in_mask if (!ipw_is_rate_in_mask
(priv, network->mode, network->rates[i])) { (priv, network->mode, network->rates[i])) {
if (network->rates[i] & IEEE80211_BASIC_RATE_MASK) {
IPW_DEBUG_SCAN
("Basic rate %02X masked: 0x%08X\n",
network->rates[i], priv->rates_mask);
return 0;
}
IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n", IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
network->rates[i], priv->rates_mask); network->rates[i], priv->rates_mask);
continue; continue;
...@@ -4150,6 +4239,13 @@ static int ipw_compatible_rates(struct ipw_priv *priv, ...@@ -4150,6 +4239,13 @@ static int ipw_compatible_rates(struct ipw_priv *priv,
for (i = 0; i < num_rates; i++) { for (i = 0; i < num_rates; i++) {
if (!ipw_is_rate_in_mask if (!ipw_is_rate_in_mask
(priv, network->mode, network->rates_ex[i])) { (priv, network->mode, network->rates_ex[i])) {
if (network->rates_ex[i] & IEEE80211_BASIC_RATE_MASK) {
IPW_DEBUG_SCAN
("Basic rate %02X masked: 0x%08X\n",
network->rates_ex[i], priv->rates_mask);
return 0;
}
IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n", IPW_DEBUG_SCAN("Rate %02X masked : 0x%08X\n",
network->rates_ex[i], priv->rates_mask); network->rates_ex[i], priv->rates_mask);
continue; continue;
...@@ -4159,7 +4255,7 @@ static int ipw_compatible_rates(struct ipw_priv *priv, ...@@ -4159,7 +4255,7 @@ static int ipw_compatible_rates(struct ipw_priv *priv,
network->rates_ex[i]; network->rates_ex[i];
} }
return rates->num_rates; return 1;
} }
static inline void ipw_copy_rates(struct ipw_supported_rates *dest, static inline void ipw_copy_rates(struct ipw_supported_rates *dest,
...@@ -4322,7 +4418,7 @@ static int ipw_best_network(struct ipw_priv *priv, ...@@ -4322,7 +4418,7 @@ static int ipw_best_network(struct ipw_priv *priv,
/* If this network has already had an association attempt within the /* If this network has already had an association attempt within the
* last 3 seconds, do not try and associate again... */ * last 3 seconds, do not try and associate again... */
if (network->last_associate && if (network->last_associate &&
time_after(network->last_associate + (HZ * 5UL), jiffies)) { time_after(network->last_associate + (HZ * 3UL), jiffies)) {
IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded " IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
"because of storming (%lu since last " "because of storming (%lu since last "
"assoc attempt).\n", "assoc attempt).\n",
...@@ -4334,7 +4430,7 @@ static int ipw_best_network(struct ipw_priv *priv, ...@@ -4334,7 +4430,7 @@ static int ipw_best_network(struct ipw_priv *priv,
/* Now go through and see if the requested network is valid... */ /* Now go through and see if the requested network is valid... */
if (priv->ieee->scan_age != 0 && if (priv->ieee->scan_age != 0 &&
jiffies - network->last_scanned > priv->ieee->scan_age) { time_after(jiffies, network->last_scanned + priv->ieee->scan_age)) {
IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded " IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
"because of age: %lums.\n", "because of age: %lums.\n",
escape_essid(network->ssid, network->ssid_len), escape_essid(network->ssid, network->ssid_len),
...@@ -4386,7 +4482,17 @@ static int ipw_best_network(struct ipw_priv *priv, ...@@ -4386,7 +4482,17 @@ static int ipw_best_network(struct ipw_priv *priv,
return 0; return 0;
} }
ipw_compatible_rates(priv, network, &rates); /* Ensure that the rates supported by the driver are compatible with
* this AP, including verification of basic rates (mandatory) */
if (!ipw_compatible_rates(priv, network, &rates)) {
IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
"because configured rate mask excludes "
"AP mandatory rate.\n",
escape_essid(network->ssid, network->ssid_len),
MAC_ARG(network->bssid));
return 0;
}
if (rates.num_rates == 0) { if (rates.num_rates == 0) {
IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded " IPW_DEBUG_ASSOC("Network '%s (" MAC_FMT ")' excluded "
"because of no compatible rates.\n", "because of no compatible rates.\n",
...@@ -4448,6 +4554,8 @@ static void ipw_adhoc_create(struct ipw_priv *priv, ...@@ -4448,6 +4554,8 @@ static void ipw_adhoc_create(struct ipw_priv *priv,
memcpy(network->ssid, priv->essid, priv->essid_len); memcpy(network->ssid, priv->essid, priv->essid_len);
memset(&network->stats, 0, sizeof(network->stats)); memset(&network->stats, 0, sizeof(network->stats));
network->capability = WLAN_CAPABILITY_IBSS; network->capability = WLAN_CAPABILITY_IBSS;
if (!(priv->config & CFG_PREAMBLE_LONG))
network->capability |= WLAN_CAPABILITY_SHORT_PREAMBLE;
if (priv->capability & CAP_PRIVACY_ON) if (priv->capability & CAP_PRIVACY_ON)
network->capability |= WLAN_CAPABILITY_PRIVACY; network->capability |= WLAN_CAPABILITY_PRIVACY;
network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH); network->rates_len = min(priv->rates.num_rates, MAX_RATES_LENGTH);
...@@ -4530,7 +4638,8 @@ static void ipw_debug_config(struct ipw_priv *priv) ...@@ -4530,7 +4638,8 @@ static void ipw_debug_config(struct ipw_priv *priv)
else else
IPW_DEBUG_INFO("ESSID unlocked.\n"); IPW_DEBUG_INFO("ESSID unlocked.\n");
if (priv->config & CFG_STATIC_BSSID) if (priv->config & CFG_STATIC_BSSID)
IPW_DEBUG_INFO("BSSID locked to %d\n", priv->channel); IPW_DEBUG_INFO("BSSID locked to " MAC_FMT "\n",
MAC_ARG(priv->bssid));
else else
IPW_DEBUG_INFO("BSSID unlocked.\n"); IPW_DEBUG_INFO("BSSID unlocked.\n");
if (priv->capability & CAP_PRIVACY_ON) if (priv->capability & CAP_PRIVACY_ON)
...@@ -4561,6 +4670,8 @@ static inline void ipw_set_fixed_rate(struct ipw_priv *priv, ...@@ -4561,6 +4670,8 @@ static inline void ipw_set_fixed_rate(struct ipw_priv *priv,
/* IEEE_A */ /* IEEE_A */
if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) { if (priv->rates_mask & ~IEEE80211_OFDM_RATES_MASK) {
/* Invalid fixed rate mask */ /* Invalid fixed rate mask */
IPW_DEBUG_WX
("invalid fixed rate mask in ipw_set_fixed_rate\n");
fr.tx_rates = 0; fr.tx_rates = 0;
break; break;
} }
...@@ -4573,6 +4684,8 @@ static inline void ipw_set_fixed_rate(struct ipw_priv *priv, ...@@ -4573,6 +4684,8 @@ static inline void ipw_set_fixed_rate(struct ipw_priv *priv,
if (network->mode == IEEE_B) { if (network->mode == IEEE_B) {
if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) { if (fr.tx_rates & ~IEEE80211_CCK_RATES_MASK) {
/* Invalid fixed rate mask */ /* Invalid fixed rate mask */
IPW_DEBUG_WX
("invalid fixed rate mask in ipw_set_fixed_rate\n");
fr.tx_rates = 0; fr.tx_rates = 0;
} }
break; break;
...@@ -4582,6 +4695,8 @@ static inline void ipw_set_fixed_rate(struct ipw_priv *priv, ...@@ -4582,6 +4695,8 @@ static inline void ipw_set_fixed_rate(struct ipw_priv *priv,
if (fr.tx_rates & ~(IEEE80211_CCK_RATES_MASK | if (fr.tx_rates & ~(IEEE80211_CCK_RATES_MASK |
IEEE80211_OFDM_RATES_MASK)) { IEEE80211_OFDM_RATES_MASK)) {
/* Invalid fixed rate mask */ /* Invalid fixed rate mask */
IPW_DEBUG_WX
("invalid fixed rate mask in ipw_set_fixed_rate\n");
fr.tx_rates = 0; fr.tx_rates = 0;
break; break;
} }
...@@ -4609,134 +4724,748 @@ static inline void ipw_set_fixed_rate(struct ipw_priv *priv, ...@@ -4609,134 +4724,748 @@ static inline void ipw_set_fixed_rate(struct ipw_priv *priv,
ipw_write_reg32(priv, reg, *(u32 *) & fr); ipw_write_reg32(priv, reg, *(u32 *) & fr);
} }
static int ipw_associate_network(struct ipw_priv *priv, static void ipw_abort_scan(struct ipw_priv *priv)
struct ieee80211_network *network,
struct ipw_supported_rates *rates, int roaming)
{ {
int err; int err;
if (priv->config & CFG_FIXED_RATE) if (priv->status & STATUS_SCAN_ABORTING) {
ipw_set_fixed_rate(priv, network); IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
return;
}
priv->status |= STATUS_SCAN_ABORTING;
if (!(priv->config & CFG_STATIC_ESSID)) { err = ipw_send_scan_abort(priv);
priv->essid_len = min(network->ssid_len, if (err)
(u8) IW_ESSID_MAX_SIZE); IPW_DEBUG_HC("Request to abort scan failed.\n");
memcpy(priv->essid, network->ssid, priv->essid_len); }
static int ipw_request_scan(struct ipw_priv *priv)
{
struct ipw_scan_request_ext scan;
int channel_index = 0;
int i, err, scan_type;
if (priv->status & STATUS_EXIT_PENDING) {
IPW_DEBUG_SCAN("Aborting scan due to device shutdown\n");
priv->status |= STATUS_SCAN_PENDING;
return 0;
} }
network->last_associate = jiffies; if (priv->status & STATUS_SCANNING) {
IPW_DEBUG_HC("Concurrent scan requested. Aborting first.\n");
priv->status |= STATUS_SCAN_PENDING;
ipw_abort_scan(priv);
return 0;
}
memset(&priv->assoc_request, 0, sizeof(priv->assoc_request)); if (priv->status & STATUS_SCAN_ABORTING) {
priv->assoc_request.channel = network->channel; IPW_DEBUG_HC("Scan request while abort pending. Queuing.\n");
if ((priv->capability & CAP_PRIVACY_ON) && priv->status |= STATUS_SCAN_PENDING;
(priv->capability & CAP_SHARED_KEY)) { return 0;
priv->assoc_request.auth_type = AUTH_SHARED_KEY;
priv->assoc_request.auth_key = priv->sec.active_key;
} else {
priv->assoc_request.auth_type = AUTH_OPEN;
priv->assoc_request.auth_key = 0;
} }
if (priv->capability & CAP_PRIVACY_ON) if (priv->status & STATUS_RF_KILL_MASK) {
ipw_send_wep_keys(priv); IPW_DEBUG_HC("Aborting scan due to RF Kill activation\n");
priv->status |= STATUS_SCAN_PENDING;
return 0;
}
/* memset(&scan, 0, sizeof(scan));
* It is valid for our ieee device to support multiple modes, but
* when it comes to associating to a given network we have to choose
* just one mode.
*/
if (network->mode & priv->ieee->mode & IEEE_A)
priv->assoc_request.ieee_mode = IPW_A_MODE;
else if (network->mode & priv->ieee->mode & IEEE_G)
priv->assoc_request.ieee_mode = IPW_G_MODE;
else if (network->mode & priv->ieee->mode & IEEE_B)
priv->assoc_request.ieee_mode = IPW_B_MODE;
IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, " scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] = 20;
"802.11%c [%d], enc=%s%s%s%c%c\n", scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] = 20;
roaming ? "Rea" : "A", scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = 20;
escape_essid(priv->essid, priv->essid_len),
network->channel,
ipw_modes[priv->assoc_request.ieee_mode],
rates->num_rates,
priv->capability & CAP_PRIVACY_ON ? "on " : "off",
priv->capability & CAP_PRIVACY_ON ?
(priv->capability & CAP_SHARED_KEY ? "(shared)" :
"(open)") : "",
priv->capability & CAP_PRIVACY_ON ? " key=" : "",
priv->capability & CAP_PRIVACY_ON ?
'1' + priv->sec.active_key : '.',
priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
priv->assoc_request.beacon_interval = network->beacon_interval; scan.full_scan_index = ieee80211_get_scans(priv->ieee);
if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
(network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
priv->assoc_request.assoc_type = HC_IBSS_START;
priv->assoc_request.assoc_tsf_msw = 0;
priv->assoc_request.assoc_tsf_lsw = 0;
} else {
if (unlikely(roaming))
priv->assoc_request.assoc_type = HC_REASSOCIATE;
else
priv->assoc_request.assoc_type = HC_ASSOCIATE;
priv->assoc_request.assoc_tsf_msw = network->time_stamp[1];
priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0];
}
memcpy(&priv->assoc_request.bssid, network->bssid, ETH_ALEN); #ifdef CONFIG_IPW_MONITOR
if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
u8 band = 0, channel = priv->channel;
if (priv->ieee->iw_mode == IW_MODE_ADHOC) { if (is_valid_channel(IEEE_A, channel))
memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN); band = (u8) (IPW_A_MODE << 6) | 1;
priv->assoc_request.atim_window = network->atim_window;
if (is_valid_channel(IEEE_B | IEEE_G, channel))
band = (u8) (IPW_B_MODE << 6) | 1;
if (band == 0) {
band = (u8) (IPW_B_MODE << 6) | 1;
channel = 9;
}
scan.channels_list[channel_index++] = band;
scan.channels_list[channel_index] = channel;
ipw_set_scan_type(&scan, channel_index,
IPW_SCAN_PASSIVE_FULL_DWELL_SCAN);
scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = 2000;
} else { } else {
memcpy(&priv->assoc_request.dest, network->bssid, ETH_ALEN); #endif /* CONFIG_IPW_MONITOR */
priv->assoc_request.atim_window = 0; /* If we are roaming, then make this a directed scan for the current
} * network. Otherwise, ensure that every other scan is a fast
* channel hop scan */
if ((priv->status & STATUS_ROAMING)
|| (!(priv->status & STATUS_ASSOCIATED)
&& (priv->config & CFG_STATIC_ESSID)
&& (scan.full_scan_index % 2))) {
err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
if (err) {
IPW_DEBUG_HC
("Attempt to send SSID command failed.\n");
return err;
}
priv->assoc_request.capability = network->capability; scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
priv->assoc_request.listen_interval = network->listen_interval; } else {
scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
}
err = ipw_send_ssid(priv, priv->essid, priv->essid_len); if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) {
if (err) { int start = channel_index;
IPW_DEBUG_HC("Attempt to send SSID command failed.\n"); for (i = 0; i < MAX_A_CHANNELS; i++) {
return err; if (band_a_active_channel[i] == 0)
} break;
if ((priv->status & STATUS_ASSOCIATED) &&
band_a_active_channel[i] == priv->channel)
continue;
channel_index++;
scan.channels_list[channel_index] =
band_a_active_channel[i];
ipw_set_scan_type(&scan, channel_index,
scan_type);
}
rates->ieee_mode = priv->assoc_request.ieee_mode; if (start != channel_index) {
rates->purpose = IPW_RATE_CONNECT; scan.channels_list[start] =
ipw_send_supported_rates(priv, rates); (u8) (IPW_A_MODE << 6) | (channel_index -
start);
channel_index++;
}
}
if (priv->assoc_request.ieee_mode == IPW_G_MODE) if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) {
priv->sys_config.dot11g_auto_detection = 1; int start = channel_index;
else for (i = 0; i < MAX_B_CHANNELS; i++) {
priv->sys_config.dot11g_auto_detection = 0; if (band_b_active_channel[i] == 0)
err = ipw_send_system_config(priv, &priv->sys_config); break;
if (err) { if ((priv->status & STATUS_ASSOCIATED) &&
IPW_DEBUG_HC("Attempt to send sys config command failed.\n"); band_b_active_channel[i] == priv->channel)
return err; continue;
channel_index++;
scan.channels_list[channel_index] =
band_b_active_channel[i];
ipw_set_scan_type(&scan, channel_index,
scan_type);
}
if (start != channel_index) {
scan.channels_list[start] =
(u8) (IPW_B_MODE << 6) | (channel_index -
start);
}
}
#ifdef CONFIG_IPW_MONITOR
} }
#endif
IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi); err = ipw_send_scan_request_ext(priv, &scan);
err = ipw_set_sensitivity(priv, network->stats.rssi);
if (err) { if (err) {
IPW_DEBUG_HC("Attempt to send associate command failed.\n"); IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
return err; return -EIO;
} }
/* priv->status |= STATUS_SCANNING;
* If preemption is enabled, it is possible for the association priv->status &= ~STATUS_SCAN_PENDING;
* to complete before we return from ipw_send_associate. Therefore
* we have to be sure and update our priviate data first.
*/
priv->channel = network->channel;
memcpy(priv->bssid, network->bssid, ETH_ALEN);
priv->status |= STATUS_ASSOCIATING;
priv->status &= ~STATUS_SECURITY_UPDATED;
priv->assoc_network = network; return 0;
}
err = ipw_send_associate(priv, &priv->assoc_request); /* Support for wpa_supplicant. Will be replaced with WEXT once
if (err) { * they get WPA support. */
#ifdef CONFIG_IEEE80211_WPA
/* following definitions must match definitions in driver_ipw.c */
#define IPW_IOCTL_WPA_SUPPLICANT SIOCIWFIRSTPRIV+30
#define IPW_CMD_SET_WPA_PARAM 1
#define IPW_CMD_SET_WPA_IE 2
#define IPW_CMD_SET_ENCRYPTION 3
#define IPW_CMD_MLME 4
#define IPW_PARAM_WPA_ENABLED 1
#define IPW_PARAM_TKIP_COUNTERMEASURES 2
#define IPW_PARAM_DROP_UNENCRYPTED 3
#define IPW_PARAM_PRIVACY_INVOKED 4
#define IPW_PARAM_AUTH_ALGS 5
#define IPW_PARAM_IEEE_802_1X 6
#define IPW_MLME_STA_DEAUTH 1
#define IPW_MLME_STA_DISASSOC 2
#define IPW_CRYPT_ERR_UNKNOWN_ALG 2
#define IPW_CRYPT_ERR_UNKNOWN_ADDR 3
#define IPW_CRYPT_ERR_CRYPT_INIT_FAILED 4
#define IPW_CRYPT_ERR_KEY_SET_FAILED 5
#define IPW_CRYPT_ERR_TX_KEY_SET_FAILED 6
#define IPW_CRYPT_ERR_CARD_CONF_FAILED 7
#define IPW_CRYPT_ALG_NAME_LEN 16
struct ipw_param {
u32 cmd;
u8 sta_addr[ETH_ALEN];
union {
struct {
u8 name;
u32 value;
} wpa_param;
struct {
u32 len;
u8 *data;
} wpa_ie;
struct {
int command;
int reason_code;
} mlme;
struct {
u8 alg[IPW_CRYPT_ALG_NAME_LEN];
u8 set_tx;
u32 err;
u8 idx;
u8 seq[8]; /* sequence counter (set: RX, get: TX) */
u16 key_len;
u8 key[0];
} crypt;
} u;
};
/* end of driver_ipw.c code */
static int ipw_wpa_enable(struct ipw_priv *priv, int value)
{
struct ieee80211_device *ieee = priv->ieee;
struct ieee80211_security sec = {
.flags = SEC_LEVEL | SEC_ENABLED,
};
int ret = 0;
ieee->wpa_enabled = value;
if (value) {
sec.level = SEC_LEVEL_3;
sec.enabled = 1;
} else {
sec.level = SEC_LEVEL_0;
sec.enabled = 0;
}
if (ieee->set_security)
ieee->set_security(ieee->dev, &sec);
else
ret = -EOPNOTSUPP;
return ret;
}
#define AUTH_ALG_OPEN_SYSTEM 0x1
#define AUTH_ALG_SHARED_KEY 0x2
static int ipw_wpa_set_auth_algs(struct ipw_priv *priv, int value)
{
struct ieee80211_device *ieee = priv->ieee;
struct ieee80211_security sec = {
.flags = SEC_AUTH_MODE,
};
int ret = 0;
if (value & AUTH_ALG_SHARED_KEY) {
sec.auth_mode = WLAN_AUTH_SHARED_KEY;
ieee->open_wep = 0;
} else {
sec.auth_mode = WLAN_AUTH_OPEN;
ieee->open_wep = 1;
}
if (ieee->set_security)
ieee->set_security(ieee->dev, &sec);
else
ret = -EOPNOTSUPP;
return ret;
}
static int ipw_wpa_set_param(struct net_device *dev, u8 name, u32 value)
{
struct ipw_priv *priv = ieee80211_priv(dev);
int ret = 0;
switch (name) {
case IPW_PARAM_WPA_ENABLED:
ret = ipw_wpa_enable(priv, value);
break;
case IPW_PARAM_TKIP_COUNTERMEASURES:
priv->ieee->tkip_countermeasures = value;
break;
case IPW_PARAM_DROP_UNENCRYPTED:
priv->ieee->drop_unencrypted = value;
break;
case IPW_PARAM_PRIVACY_INVOKED:
priv->ieee->privacy_invoked = value;
break;
case IPW_PARAM_AUTH_ALGS:
ret = ipw_wpa_set_auth_algs(priv, value);
break;
case IPW_PARAM_IEEE_802_1X:
priv->ieee->ieee802_1x = value;
break;
default:
IPW_ERROR("%s: Unknown WPA param: %d\n", dev->name, name);
ret = -EOPNOTSUPP;
}
return ret;
}
static int ipw_wpa_mlme(struct net_device *dev, int command, int reason)
{
struct ipw_priv *priv = ieee80211_priv(dev);
int ret = 0;
switch (command) {
case IPW_MLME_STA_DEAUTH:
// silently ignore
break;
case IPW_MLME_STA_DISASSOC:
ipw_disassociate(priv);
break;
default:
IPW_ERROR("%s: Unknown MLME request: %d\n", dev->name, command);
ret = -EOPNOTSUPP;
}
return ret;
}
static int ipw_set_rsn_capa(struct ipw_priv *priv,
char *capabilities, int length)
{
struct host_cmd cmd = {
.cmd = IPW_CMD_RSN_CAPABILITIES,
.len = length,
};
IPW_DEBUG_HC("HOST_CMD_RSN_CAPABILITIES\n");
memcpy(&cmd.param, capabilities, length);
if (ipw_send_cmd(priv, &cmd)) {
IPW_ERROR("failed to send HOST_CMD_RSN_CAPABILITIES command\n");
return -1;
}
return 0;
}
void ipw_wpa_assoc_frame(struct ipw_priv *priv, char *wpa_ie, int wpa_ie_len)
{
/* make sure WPA is enabled */
ipw_wpa_enable(priv, 1);
if (priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING))
ipw_disassociate(priv);
}
static int ipw_wpa_set_wpa_ie(struct net_device *dev,
struct ipw_param *param, int plen)
{
struct ipw_priv *priv = ieee80211_priv(dev);
struct ieee80211_device *ieee = priv->ieee;
u8 *buf;
if (!ieee->wpa_enabled)
return -EOPNOTSUPP;
if (param->u.wpa_ie.len > MAX_WPA_IE_LEN ||
(param->u.wpa_ie.len && param->u.wpa_ie.data == NULL))
return -EINVAL;
if (param->u.wpa_ie.len) {
buf = kmalloc(param->u.wpa_ie.len, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
memcpy(buf, param->u.wpa_ie.data, param->u.wpa_ie.len);
kfree(ieee->wpa_ie);
ieee->wpa_ie = buf;
ieee->wpa_ie_len = param->u.wpa_ie.len;
} else {
kfree(ieee->wpa_ie);
ieee->wpa_ie = NULL;
ieee->wpa_ie_len = 0;
}
ipw_wpa_assoc_frame(priv, ieee->wpa_ie, ieee->wpa_ie_len);
return 0;
}
/* implementation borrowed from hostap driver */
static int ipw_wpa_set_encryption(struct net_device *dev,
struct ipw_param *param, int param_len)
{
int ret = 0;
struct ipw_priv *priv = ieee80211_priv(dev);
struct ieee80211_device *ieee = priv->ieee;
struct ieee80211_crypto_ops *ops;
struct ieee80211_crypt_data **crypt;
struct ieee80211_security sec = {
.flags = 0,
};
param->u.crypt.err = 0;
param->u.crypt.alg[IPW_CRYPT_ALG_NAME_LEN - 1] = '\0';
if (param_len !=
(int)((char *)param->u.crypt.key - (char *)param) +
param->u.crypt.key_len) {
IPW_DEBUG_INFO("Len mismatch %d, %d\n", param_len,
param->u.crypt.key_len);
return -EINVAL;
}
if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
if (param->u.crypt.idx >= WEP_KEYS)
return -EINVAL;
crypt = &ieee->crypt[param->u.crypt.idx];
} else {
return -EINVAL;
}
if (strcmp(param->u.crypt.alg, "none") == 0) {
if (crypt) {
sec.enabled = 0;
sec.level = SEC_LEVEL_0;
sec.flags |= SEC_ENABLED | SEC_LEVEL;
ieee80211_crypt_delayed_deinit(ieee, crypt);
}
goto done;
}
sec.enabled = 1;
sec.flags |= SEC_ENABLED;
ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
if (ops == NULL && strcmp(param->u.crypt.alg, "WEP") == 0) {
request_module("ieee80211_crypt_wep");
ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
} else if (ops == NULL && strcmp(param->u.crypt.alg, "TKIP") == 0) {
request_module("ieee80211_crypt_tkip");
ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
} else if (ops == NULL && strcmp(param->u.crypt.alg, "CCMP") == 0) {
request_module("ieee80211_crypt_ccmp");
ops = ieee80211_get_crypto_ops(param->u.crypt.alg);
}
if (ops == NULL) {
IPW_DEBUG_INFO("%s: unknown crypto alg '%s'\n",
dev->name, param->u.crypt.alg);
param->u.crypt.err = IPW_CRYPT_ERR_UNKNOWN_ALG;
ret = -EINVAL;
goto done;
}
if (*crypt == NULL || (*crypt)->ops != ops) {
struct ieee80211_crypt_data *new_crypt;
ieee80211_crypt_delayed_deinit(ieee, crypt);
new_crypt = (struct ieee80211_crypt_data *)
kmalloc(sizeof(*new_crypt), GFP_KERNEL);
if (new_crypt == NULL) {
ret = -ENOMEM;
goto done;
}
memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data));
new_crypt->ops = ops;
if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
new_crypt->priv =
new_crypt->ops->init(param->u.crypt.idx);
if (new_crypt->priv == NULL) {
kfree(new_crypt);
param->u.crypt.err = IPW_CRYPT_ERR_CRYPT_INIT_FAILED;
ret = -EINVAL;
goto done;
}
*crypt = new_crypt;
}
if (param->u.crypt.key_len > 0 && (*crypt)->ops->set_key &&
(*crypt)->ops->set_key(param->u.crypt.key,
param->u.crypt.key_len, param->u.crypt.seq,
(*crypt)->priv) < 0) {
IPW_DEBUG_INFO("%s: key setting failed\n", dev->name);
param->u.crypt.err = IPW_CRYPT_ERR_KEY_SET_FAILED;
ret = -EINVAL;
goto done;
}
if (param->u.crypt.set_tx) {
ieee->tx_keyidx = param->u.crypt.idx;
sec.active_key = param->u.crypt.idx;
sec.flags |= SEC_ACTIVE_KEY;
}
if (ops->name != NULL) {
if (strcmp(ops->name, "WEP") == 0) {
memcpy(sec.keys[param->u.crypt.idx],
param->u.crypt.key, param->u.crypt.key_len);
sec.key_sizes[param->u.crypt.idx] =
param->u.crypt.key_len;
sec.flags |= (1 << param->u.crypt.idx);
sec.flags |= SEC_LEVEL;
sec.level = SEC_LEVEL_1;
} else if (strcmp(ops->name, "TKIP") == 0) {
sec.flags |= SEC_LEVEL;
sec.level = SEC_LEVEL_2;
} else if (strcmp(ops->name, "CCMP") == 0) {
sec.flags |= SEC_LEVEL;
sec.level = SEC_LEVEL_3;
}
}
done:
if (ieee->set_security)
ieee->set_security(ieee->dev, &sec);
/* Do not reset port if card is in Managed mode since resetting will
* generate new IEEE 802.11 authentication which may end up in looping
* with IEEE 802.1X. If your hardware requires a reset after WEP
* configuration (for example... Prism2), implement the reset_port in
* the callbacks structures used to initialize the 802.11 stack. */
if (ieee->reset_on_keychange &&
ieee->iw_mode != IW_MODE_INFRA &&
ieee->reset_port && ieee->reset_port(dev)) {
IPW_DEBUG_INFO("%s: reset_port failed\n", dev->name);
param->u.crypt.err = IPW_CRYPT_ERR_CARD_CONF_FAILED;
return -EINVAL;
}
return ret;
}
static int ipw_wpa_supplicant(struct net_device *dev, struct iw_point *p)
{
struct ipw_param *param;
int ret = 0;
IPW_DEBUG_INFO("wpa_supplicant: len=%d\n", p->length);
if (p->length < sizeof(struct ipw_param) || !p->pointer)
return -EINVAL;
param = (struct ipw_param *)kmalloc(p->length, GFP_KERNEL);
if (param == NULL)
return -ENOMEM;
if (copy_from_user(param, p->pointer, p->length)) {
kfree(param);
return -EFAULT;
}
switch (param->cmd) {
case IPW_CMD_SET_WPA_PARAM:
ret = ipw_wpa_set_param(dev, param->u.wpa_param.name,
param->u.wpa_param.value);
break;
case IPW_CMD_SET_WPA_IE:
ret = ipw_wpa_set_wpa_ie(dev, param, p->length);
break;
case IPW_CMD_SET_ENCRYPTION:
ret = ipw_wpa_set_encryption(dev, param, p->length);
break;
case IPW_CMD_MLME:
ret = ipw_wpa_mlme(dev, param->u.mlme.command,
param->u.mlme.reason_code);
break;
default:
IPW_ERROR("%s: Unknown WPA supplicant request: %d\n",
dev->name, param->cmd);
ret = -EOPNOTSUPP;
}
if (ret == 0 && copy_to_user(p->pointer, param, p->length))
ret = -EFAULT;
kfree(param);
return ret;
}
#endif /* CONFIG_IEEE80211_WPA */
static int ipw_associate_network(struct ipw_priv *priv,
struct ieee80211_network *network,
struct ipw_supported_rates *rates, int roaming)
{
int err;
if (priv->config & CFG_FIXED_RATE)
ipw_set_fixed_rate(priv, network);
if (!(priv->config & CFG_STATIC_ESSID)) {
priv->essid_len = min(network->ssid_len,
(u8) IW_ESSID_MAX_SIZE);
memcpy(priv->essid, network->ssid, priv->essid_len);
}
network->last_associate = jiffies;
memset(&priv->assoc_request, 0, sizeof(priv->assoc_request));
priv->assoc_request.channel = network->channel;
if ((priv->capability & CAP_PRIVACY_ON) &&
(priv->capability & CAP_SHARED_KEY)) {
priv->assoc_request.auth_type = AUTH_SHARED_KEY;
priv->assoc_request.auth_key = priv->sec.active_key;
} else {
priv->assoc_request.auth_type = AUTH_OPEN;
priv->assoc_request.auth_key = 0;
}
if (priv->capability & CAP_PRIVACY_ON)
ipw_send_wep_keys(priv);
#ifdef CONFIG_IEEE80211_WPA
if (priv->ieee->wpa_enabled) {
priv->assoc_request.policy_support = 0x02; /* RSN active */
ipw_set_rsn_capa(priv, priv->ieee->wpa_ie,
priv->ieee->wpa_ie_len);
}
#endif
/*
* It is valid for our ieee device to support multiple modes, but
* when it comes to associating to a given network we have to choose
* just one mode.
*/
if (network->mode & priv->ieee->mode & IEEE_A)
priv->assoc_request.ieee_mode = IPW_A_MODE;
else if (network->mode & priv->ieee->mode & IEEE_G)
priv->assoc_request.ieee_mode = IPW_G_MODE;
else if (network->mode & priv->ieee->mode & IEEE_B)
priv->assoc_request.ieee_mode = IPW_B_MODE;
priv->assoc_request.capability = network->capability;
if ((network->capability & WLAN_CAPABILITY_SHORT_PREAMBLE)
&& !(priv->config & CFG_PREAMBLE_LONG)) {
priv->assoc_request.preamble_length = DCT_FLAG_SHORT_PREAMBLE;
} else {
priv->assoc_request.preamble_length = DCT_FLAG_LONG_PREAMBLE;
/* Clear the short preamble if we won't be supporting it */
priv->assoc_request.capability &=
~WLAN_CAPABILITY_SHORT_PREAMBLE;
}
IPW_DEBUG_ASSOC("%sssocation attempt: '%s', channel %d, "
"802.11%c [%d], %s[:%s], enc=%s%s%s%c%c\n",
roaming ? "Rea" : "A",
escape_essid(priv->essid, priv->essid_len),
network->channel,
ipw_modes[priv->assoc_request.ieee_mode],
rates->num_rates,
(priv->assoc_request.preamble_length ==
DCT_FLAG_LONG_PREAMBLE) ? "long" : "short",
network->capability &
WLAN_CAPABILITY_SHORT_PREAMBLE ? "short" : "long",
priv->capability & CAP_PRIVACY_ON ? "on " : "off",
priv->capability & CAP_PRIVACY_ON ?
(priv->capability & CAP_SHARED_KEY ? "(shared)" :
"(open)") : "",
priv->capability & CAP_PRIVACY_ON ? " key=" : "",
priv->capability & CAP_PRIVACY_ON ?
'1' + priv->sec.active_key : '.',
priv->capability & CAP_PRIVACY_ON ? '.' : ' ');
priv->assoc_request.beacon_interval = network->beacon_interval;
if ((priv->ieee->iw_mode == IW_MODE_ADHOC) &&
(network->time_stamp[0] == 0) && (network->time_stamp[1] == 0)) {
priv->assoc_request.assoc_type = HC_IBSS_START;
priv->assoc_request.assoc_tsf_msw = 0;
priv->assoc_request.assoc_tsf_lsw = 0;
} else {
if (unlikely(roaming))
priv->assoc_request.assoc_type = HC_REASSOCIATE;
else
priv->assoc_request.assoc_type = HC_ASSOCIATE;
priv->assoc_request.assoc_tsf_msw = network->time_stamp[1];
priv->assoc_request.assoc_tsf_lsw = network->time_stamp[0];
}
memcpy(&priv->assoc_request.bssid, network->bssid, ETH_ALEN);
if (priv->ieee->iw_mode == IW_MODE_ADHOC) {
memset(&priv->assoc_request.dest, 0xFF, ETH_ALEN);
priv->assoc_request.atim_window = network->atim_window;
} else {
memcpy(&priv->assoc_request.dest, network->bssid, ETH_ALEN);
priv->assoc_request.atim_window = 0;
}
priv->assoc_request.listen_interval = network->listen_interval;
err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
if (err) {
IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
return err;
}
rates->ieee_mode = priv->assoc_request.ieee_mode;
rates->purpose = IPW_RATE_CONNECT;
ipw_send_supported_rates(priv, rates);
if (priv->assoc_request.ieee_mode == IPW_G_MODE)
priv->sys_config.dot11g_auto_detection = 1;
else
priv->sys_config.dot11g_auto_detection = 0;
err = ipw_send_system_config(priv, &priv->sys_config);
if (err) {
IPW_DEBUG_HC("Attempt to send sys config command failed.\n");
return err;
}
IPW_DEBUG_ASSOC("Association sensitivity: %d\n", network->stats.rssi);
err = ipw_set_sensitivity(priv, network->stats.rssi + IPW_RSSI_TO_DBM);
if (err) {
IPW_DEBUG_HC("Attempt to send associate command failed.\n");
return err;
}
/*
* If preemption is enabled, it is possible for the association
* to complete before we return from ipw_send_associate. Therefore
* we have to be sure and update our priviate data first.
*/
priv->channel = network->channel;
memcpy(priv->bssid, network->bssid, ETH_ALEN);
priv->status |= STATUS_ASSOCIATING;
priv->status &= ~STATUS_SECURITY_UPDATED;
priv->assoc_network = network;
err = ipw_send_associate(priv, &priv->assoc_request);
if (err) {
IPW_DEBUG_HC("Attempt to send associate command failed.\n"); IPW_DEBUG_HC("Attempt to send associate command failed.\n");
return err; return err;
} }
...@@ -4899,6 +5628,32 @@ static inline void ipw_handle_data_packet(struct ipw_priv *priv, ...@@ -4899,6 +5628,32 @@ static inline void ipw_handle_data_packet(struct ipw_priv *priv,
rxb->skb = NULL; rxb->skb = NULL;
} }
static inline int is_network_packet(struct ipw_priv *priv,
struct ieee80211_hdr_4addr *header)
{
/* Filter incoming packets to determine if they are targetted toward
* this network, discarding packets coming from ourselves */
switch (priv->ieee->iw_mode) {
case IW_MODE_ADHOC:
if (is_broadcast_ether_addr(header->addr1) ||
is_multicast_ether_addr(header->addr1))
return !memcmp(header->addr3, priv->bssid, ETH_ALEN);
else
return memcmp(header->addr1, priv->net_dev->dev_addr,
ETH_ALEN);
break;
case IW_MODE_INFRA:
if (is_broadcast_ether_addr(header->addr3) ||
is_multicast_ether_addr(header->addr3))
return !memcmp(header->addr1, priv->bssid, ETH_ALEN);
else
return memcmp(header->addr3, priv->net_dev->dev_addr,
ETH_ALEN);
break;
}
return 1;
}
/* /*
* Main entry function for recieving a packet with 80211 headers. This * Main entry function for recieving a packet with 80211 headers. This
* should be called when ever the FW has notified us that there is a new * should be called when ever the FW has notified us that there is a new
...@@ -4962,7 +5717,7 @@ static void ipw_rx(struct ipw_priv *priv) ...@@ -4962,7 +5717,7 @@ static void ipw_rx(struct ipw_priv *priv)
priv->rx_packets++; priv->rx_packets++;
#ifdef CONFIG_IPW_PROMISC #ifdef CONFIG_IPW_MONITOR
if (priv->ieee->iw_mode == IW_MODE_MONITOR) { if (priv->ieee->iw_mode == IW_MODE_MONITOR) {
ipw_handle_data_packet(priv, rxb, ipw_handle_data_packet(priv, rxb,
&stats); &stats);
...@@ -4979,35 +5734,9 @@ static void ipw_rx(struct ipw_priv *priv) ...@@ -4979,35 +5734,9 @@ static void ipw_rx(struct ipw_priv *priv)
* correctly -- we should probably use the * correctly -- we should probably use the
* frame control of the packet and disregard * frame control of the packet and disregard
* the current iw_mode */ * the current iw_mode */
switch (priv->ieee->iw_mode) {
case IW_MODE_ADHOC:
network_packet =
!memcmp(header->addr1,
priv->net_dev->dev_addr,
ETH_ALEN) ||
!memcmp(header->addr3,
priv->bssid, ETH_ALEN) ||
is_broadcast_ether_addr(header->
addr1)
|| is_multicast_ether_addr(header->
addr1);
break;
case IW_MODE_INFRA:
default:
network_packet =
!memcmp(header->addr3,
priv->bssid, ETH_ALEN) ||
!memcmp(header->addr1,
priv->net_dev->dev_addr,
ETH_ALEN) ||
is_broadcast_ether_addr(header->
addr1)
|| is_multicast_ether_addr(header->
addr1);
break;
}
network_packet =
is_network_packet(priv, header);
if (network_packet && priv->assoc_network) { if (network_packet && priv->assoc_network) {
priv->assoc_network->stats.rssi = priv->assoc_network->stats.rssi =
stats.rssi; stats.rssi;
...@@ -5108,130 +5837,6 @@ static void ipw_rx(struct ipw_priv *priv) ...@@ -5108,130 +5837,6 @@ static void ipw_rx(struct ipw_priv *priv)
ipw_rx_queue_restock(priv); ipw_rx_queue_restock(priv);
} }
static void ipw_abort_scan(struct ipw_priv *priv)
{
int err;
if (priv->status & STATUS_SCAN_ABORTING) {
IPW_DEBUG_HC("Ignoring concurrent scan abort request.\n");
return;
}
priv->status |= STATUS_SCAN_ABORTING;
err = ipw_send_scan_abort(priv);
if (err)
IPW_DEBUG_HC("Request to abort scan failed.\n");
}
static int ipw_request_scan(struct ipw_priv *priv)
{
struct ipw_scan_request_ext scan;
int channel_index = 0;
int i, err, scan_type;
if (priv->status & STATUS_EXIT_PENDING) {
IPW_DEBUG_SCAN("Aborting scan due to device shutdown\n");
priv->status |= STATUS_SCAN_PENDING;
return 0;
}
if (priv->status & STATUS_SCANNING) {
IPW_DEBUG_HC("Concurrent scan requested. Aborting first.\n");
priv->status |= STATUS_SCAN_PENDING;
ipw_abort_scan(priv);
return 0;
}
if (priv->status & STATUS_SCAN_ABORTING) {
IPW_DEBUG_HC("Scan request while abort pending. Queuing.\n");
priv->status |= STATUS_SCAN_PENDING;
return 0;
}
if (priv->status & STATUS_RF_KILL_MASK) {
IPW_DEBUG_HC("Aborting scan due to RF Kill activation\n");
priv->status |= STATUS_SCAN_PENDING;
return 0;
}
memset(&scan, 0, sizeof(scan));
scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_SCAN] = 20;
scan.dwell_time[IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN] = 20;
scan.dwell_time[IPW_SCAN_PASSIVE_FULL_DWELL_SCAN] = 20;
scan.full_scan_index = ieee80211_get_scans(priv->ieee);
/* If we are roaming, then make this a directed scan for the current
* network. Otherwise, ensure that every other scan is a fast
* channel hop scan */
if ((priv->status & STATUS_ROAMING)
|| (!(priv->status & STATUS_ASSOCIATED)
&& (priv->config & CFG_STATIC_ESSID)
&& (scan.full_scan_index % 2))) {
err = ipw_send_ssid(priv, priv->essid, priv->essid_len);
if (err) {
IPW_DEBUG_HC("Attempt to send SSID command failed.\n");
return err;
}
scan_type = IPW_SCAN_ACTIVE_BROADCAST_AND_DIRECT_SCAN;
} else {
scan_type = IPW_SCAN_ACTIVE_BROADCAST_SCAN;
}
if (priv->ieee->freq_band & IEEE80211_52GHZ_BAND) {
int start = channel_index;
for (i = 0; i < MAX_A_CHANNELS; i++) {
if (band_a_active_channel[i] == 0)
break;
if ((priv->status & STATUS_ASSOCIATED) &&
band_a_active_channel[i] == priv->channel)
continue;
channel_index++;
scan.channels_list[channel_index] =
band_a_active_channel[i];
ipw_set_scan_type(&scan, channel_index, scan_type);
}
if (start != channel_index) {
scan.channels_list[start] = (u8) (IPW_A_MODE << 6) |
(channel_index - start);
channel_index++;
}
}
if (priv->ieee->freq_band & IEEE80211_24GHZ_BAND) {
int start = channel_index;
for (i = 0; i < MAX_B_CHANNELS; i++) {
if (band_b_active_channel[i] == 0)
break;
if ((priv->status & STATUS_ASSOCIATED) &&
band_b_active_channel[i] == priv->channel)
continue;
channel_index++;
scan.channels_list[channel_index] =
band_b_active_channel[i];
ipw_set_scan_type(&scan, channel_index, scan_type);
}
if (start != channel_index) {
scan.channels_list[start] = (u8) (IPW_B_MODE << 6) |
(channel_index - start);
}
}
err = ipw_send_scan_request_ext(priv, &scan);
if (err) {
IPW_DEBUG_HC("Sending scan command failed: %08X\n", err);
return -EIO;
}
priv->status |= STATUS_SCANNING;
priv->status &= ~STATUS_SCAN_PENDING;
return 0;
}
/* /*
* This file defines the Wireless Extension handlers. It does not * This file defines the Wireless Extension handlers. It does not
* define any methods of hardware manipulation and relies on the * define any methods of hardware manipulation and relies on the
...@@ -5357,7 +5962,7 @@ static int ipw_wx_set_mode(struct net_device *dev, ...@@ -5357,7 +5962,7 @@ static int ipw_wx_set_mode(struct net_device *dev,
return 0; return 0;
switch (wrqu->mode) { switch (wrqu->mode) {
#ifdef CONFIG_IPW_PROMISC #ifdef CONFIG_IPW_MONITOR
case IW_MODE_MONITOR: case IW_MODE_MONITOR:
#endif #endif
case IW_MODE_ADHOC: case IW_MODE_ADHOC:
...@@ -5370,13 +5975,13 @@ static int ipw_wx_set_mode(struct net_device *dev, ...@@ -5370,13 +5975,13 @@ static int ipw_wx_set_mode(struct net_device *dev,
return -EINVAL; return -EINVAL;
} }
#ifdef CONFIG_IPW_PROMISC #ifdef CONFIG_IPW_MONITOR
if (priv->ieee->iw_mode == IW_MODE_MONITOR) if (priv->ieee->iw_mode == IW_MODE_MONITOR)
priv->net_dev->type = ARPHRD_ETHER; priv->net_dev->type = ARPHRD_ETHER;
if (wrqu->mode == IW_MODE_MONITOR) if (wrqu->mode == IW_MODE_MONITOR)
priv->net_dev->type = ARPHRD_IEEE80211; priv->net_dev->type = ARPHRD_IEEE80211;
#endif /* CONFIG_IPW_PROMISC */ #endif /* CONFIG_IPW_MONITOR */
#ifdef CONFIG_PM #ifdef CONFIG_PM
/* Free the existing firmware and reset the fw_loaded /* Free the existing firmware and reset the fw_loaded
...@@ -5680,8 +6285,111 @@ static int ipw_wx_set_rate(struct net_device *dev, ...@@ -5680,8 +6285,111 @@ static int ipw_wx_set_rate(struct net_device *dev,
struct iw_request_info *info, struct iw_request_info *info,
union iwreq_data *wrqu, char *extra) union iwreq_data *wrqu, char *extra)
{ {
IPW_DEBUG_WX("0x%p, 0x%p, 0x%p\n", dev, info, wrqu); /* TODO: We should use semaphores or locks for access to priv */
return -EOPNOTSUPP; struct ipw_priv *priv = ieee80211_priv(dev);
u32 target_rate = wrqu->bitrate.value;
u32 fixed, mask;
/* value = -1, fixed = 0 means auto only, so we should use all rates offered by AP */
/* value = X, fixed = 1 means only rate X */
/* value = X, fixed = 0 means all rates lower equal X */
if (target_rate == -1) {
fixed = 0;
mask = IEEE80211_DEFAULT_RATES_MASK;
/* Now we should reassociate */
goto apply;
}
mask = 0;
fixed = wrqu->bitrate.fixed;
if (target_rate == 1000000 || !fixed)
mask |= IEEE80211_CCK_RATE_1MB_MASK;
if (target_rate == 1000000)
goto apply;
if (target_rate == 2000000 || !fixed)
mask |= IEEE80211_CCK_RATE_2MB_MASK;
if (target_rate == 2000000)
goto apply;
if (target_rate == 5500000 || !fixed)
mask |= IEEE80211_CCK_RATE_5MB_MASK;
if (target_rate == 5500000)
goto apply;
if (target_rate == 6000000 || !fixed)
mask |= IEEE80211_OFDM_RATE_6MB_MASK;
if (target_rate == 6000000)
goto apply;
if (target_rate == 9000000 || !fixed)
mask |= IEEE80211_OFDM_RATE_9MB_MASK;
if (target_rate == 9000000)
goto apply;
if (target_rate == 11000000 || !fixed)
mask |= IEEE80211_CCK_RATE_11MB_MASK;
if (target_rate == 11000000)
goto apply;
if (target_rate == 12000000 || !fixed)
mask |= IEEE80211_OFDM_RATE_12MB_MASK;
if (target_rate == 12000000)
goto apply;
if (target_rate == 18000000 || !fixed)
mask |= IEEE80211_OFDM_RATE_18MB_MASK;
if (target_rate == 18000000)
goto apply;
if (target_rate == 24000000 || !fixed)
mask |= IEEE80211_OFDM_RATE_24MB_MASK;
if (target_rate == 24000000)
goto apply;
if (target_rate == 36000000 || !fixed)
mask |= IEEE80211_OFDM_RATE_36MB_MASK;
if (target_rate == 36000000)
goto apply;
if (target_rate == 48000000 || !fixed)
mask |= IEEE80211_OFDM_RATE_48MB_MASK;
if (target_rate == 48000000)
goto apply;
if (target_rate == 54000000 || !fixed)
mask |= IEEE80211_OFDM_RATE_54MB_MASK;
if (target_rate == 54000000)
goto apply;
IPW_DEBUG_WX("invalid rate specified, returning error\n");
return -EINVAL;
apply:
IPW_DEBUG_WX("Setting rate mask to 0x%08X [%s]\n",
mask, fixed ? "fixed" : "sub-rates");
if (mask == IEEE80211_DEFAULT_RATES_MASK)
priv->config &= ~CFG_FIXED_RATE;
else
priv->config |= CFG_FIXED_RATE;
if (priv->rates_mask != mask) {
priv->rates_mask = mask;
/* If we are already associated or are currently trying to
* associate, disassociate and try again */
if ((priv->status & (STATUS_ASSOCIATED | STATUS_ASSOCIATING))) {
IPW_DEBUG_ASSOC("Disassociating due to RATE change.\n");
ipw_disassociate(priv);
}
} else {
/* We are not yet associated, so kick one off... */
ipw_associate(priv);
}
return 0;
} }
static int ipw_wx_get_rate(struct net_device *dev, static int ipw_wx_get_rate(struct net_device *dev,
...@@ -5888,7 +6596,6 @@ static int ipw_wx_set_power(struct net_device *dev, ...@@ -5888,7 +6596,6 @@ static int ipw_wx_set_power(struct net_device *dev,
IPW_DEBUG_WX("failed setting power mode.\n"); IPW_DEBUG_WX("failed setting power mode.\n");
return err; return err;
} }
IPW_DEBUG_WX("SET Power Management Mode -> off\n"); IPW_DEBUG_WX("SET Power Management Mode -> off\n");
return 0; return 0;
...@@ -6069,37 +6776,30 @@ static int ipw_wx_get_wireless_mode(struct net_device *dev, ...@@ -6069,37 +6776,30 @@ static int ipw_wx_get_wireless_mode(struct net_device *dev,
{ {
struct ipw_priv *priv = ieee80211_priv(dev); struct ipw_priv *priv = ieee80211_priv(dev);
switch (priv->ieee->freq_band) { switch (priv->ieee->mode) {
case IEEE80211_24GHZ_BAND: case IEEE_A:
switch (priv->ieee->modulation) {
case IEEE80211_CCK_MODULATION:
strncpy(extra, "802.11b (2)", MAX_WX_STRING);
break;
case IEEE80211_OFDM_MODULATION:
strncpy(extra, "802.11g (4)", MAX_WX_STRING);
break;
default:
strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
break;
}
break;
case IEEE80211_52GHZ_BAND:
strncpy(extra, "802.11a (1)", MAX_WX_STRING); strncpy(extra, "802.11a (1)", MAX_WX_STRING);
break; break;
case IEEE_B:
default: /* Mixed Band */ strncpy(extra, "802.11b (2)", MAX_WX_STRING);
switch (priv->ieee->modulation) { break;
case IEEE80211_CCK_MODULATION: case IEEE_A | IEEE_B:
strncpy(extra, "802.11ab (3)", MAX_WX_STRING); strncpy(extra, "802.11ab (3)", MAX_WX_STRING);
break; break;
case IEEE80211_OFDM_MODULATION: case IEEE_G:
strncpy(extra, "802.11ag (5)", MAX_WX_STRING); strncpy(extra, "802.11g (4)", MAX_WX_STRING);
break; break;
default: case IEEE_A | IEEE_G:
strncpy(extra, "802.11abg (7)", MAX_WX_STRING); strncpy(extra, "802.11ag (5)", MAX_WX_STRING);
break; break;
} case IEEE_B | IEEE_G:
strncpy(extra, "802.11bg (6)", MAX_WX_STRING);
break;
case IEEE_A | IEEE_B | IEEE_G:
strncpy(extra, "802.11abg (7)", MAX_WX_STRING);
break;
default:
strncpy(extra, "unknown", MAX_WX_STRING);
break; break;
} }
...@@ -6110,8 +6810,55 @@ static int ipw_wx_get_wireless_mode(struct net_device *dev, ...@@ -6110,8 +6810,55 @@ static int ipw_wx_get_wireless_mode(struct net_device *dev,
return 0; return 0;
} }
#ifdef CONFIG_IPW_PROMISC static int ipw_wx_set_preamble(struct net_device *dev,
static int ipw_wx_set_promisc(struct net_device *dev, struct iw_request_info *info,
union iwreq_data *wrqu, char *extra)
{
struct ipw_priv *priv = ieee80211_priv(dev);
int mode = *(int *)extra;
/* Switching from SHORT -> LONG requires a disassociation */
if (mode == 1) {
if (!(priv->config & CFG_PREAMBLE_LONG)) {
priv->config |= CFG_PREAMBLE_LONG;
if (priv->status &
(STATUS_ASSOCIATED | STATUS_ASSOCIATING)) {
IPW_DEBUG_ASSOC
("Disassociating due to preamble "
"change.\n");
ipw_disassociate(priv);
}
}
goto done;
}
if (mode == 0) {
priv->config &= ~CFG_PREAMBLE_LONG;
goto done;
}
return -EINVAL;
done:
return 0;
}
static int ipw_wx_get_preamble(struct net_device *dev,
struct iw_request_info *info,
union iwreq_data *wrqu, char *extra)
{
struct ipw_priv *priv = ieee80211_priv(dev);
if (priv->config & CFG_PREAMBLE_LONG)
snprintf(wrqu->name, IFNAMSIZ, "long (1)");
else
snprintf(wrqu->name, IFNAMSIZ, "auto (0)");
return 0;
}
#ifdef CONFIG_IPW_MONITOR
static int ipw_wx_set_monitor(struct net_device *dev,
struct iw_request_info *info, struct iw_request_info *info,
union iwreq_data *wrqu, char *extra) union iwreq_data *wrqu, char *extra)
{ {
...@@ -6119,7 +6866,7 @@ static int ipw_wx_set_promisc(struct net_device *dev, ...@@ -6119,7 +6866,7 @@ static int ipw_wx_set_promisc(struct net_device *dev,
int *parms = (int *)extra; int *parms = (int *)extra;
int enable = (parms[0] > 0); int enable = (parms[0] > 0);
IPW_DEBUG_WX("SET PROMISC: %d %d\n", enable, parms[1]); IPW_DEBUG_WX("SET MONITOR: %d %d\n", enable, parms[1]);
if (enable) { if (enable) {
if (priv->ieee->iw_mode != IW_MODE_MONITOR) { if (priv->ieee->iw_mode != IW_MODE_MONITOR) {
priv->net_dev->type = ARPHRD_IEEE80211; priv->net_dev->type = ARPHRD_IEEE80211;
...@@ -6145,47 +6892,49 @@ static int ipw_wx_reset(struct net_device *dev, ...@@ -6145,47 +6892,49 @@ static int ipw_wx_reset(struct net_device *dev,
ipw_adapter_restart(priv); ipw_adapter_restart(priv);
return 0; return 0;
} }
#endif // CONFIG_IPW_PROMISC #endif // CONFIG_IPW_MONITOR
/* Rebase the WE IOCTLs to zero for the handler array */ /* Rebase the WE IOCTLs to zero for the handler array */
#define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT] #define IW_IOCTL(x) [(x)-SIOCSIWCOMMIT]
static iw_handler ipw_wx_handlers[] = { static iw_handler ipw_wx_handlers[] = {
IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name, IW_IOCTL(SIOCGIWNAME) = ipw_wx_get_name,
IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq, IW_IOCTL(SIOCSIWFREQ) = ipw_wx_set_freq,
IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq, IW_IOCTL(SIOCGIWFREQ) = ipw_wx_get_freq,
IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode, IW_IOCTL(SIOCSIWMODE) = ipw_wx_set_mode,
IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode, IW_IOCTL(SIOCGIWMODE) = ipw_wx_get_mode,
IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range, IW_IOCTL(SIOCGIWRANGE) = ipw_wx_get_range,
IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap, IW_IOCTL(SIOCSIWAP) = ipw_wx_set_wap,
IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap, IW_IOCTL(SIOCGIWAP) = ipw_wx_get_wap,
IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan, IW_IOCTL(SIOCSIWSCAN) = ipw_wx_set_scan,
IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan, IW_IOCTL(SIOCGIWSCAN) = ipw_wx_get_scan,
IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid, IW_IOCTL(SIOCSIWESSID) = ipw_wx_set_essid,
IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid, IW_IOCTL(SIOCGIWESSID) = ipw_wx_get_essid,
IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick, IW_IOCTL(SIOCSIWNICKN) = ipw_wx_set_nick,
IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick, IW_IOCTL(SIOCGIWNICKN) = ipw_wx_get_nick,
IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate, IW_IOCTL(SIOCSIWRATE) = ipw_wx_set_rate,
IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate, IW_IOCTL(SIOCGIWRATE) = ipw_wx_get_rate,
IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts, IW_IOCTL(SIOCSIWRTS) = ipw_wx_set_rts,
IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts, IW_IOCTL(SIOCGIWRTS) = ipw_wx_get_rts,
IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag, IW_IOCTL(SIOCSIWFRAG) = ipw_wx_set_frag,
IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag, IW_IOCTL(SIOCGIWFRAG) = ipw_wx_get_frag,
IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow, IW_IOCTL(SIOCSIWTXPOW) = ipw_wx_set_txpow,
IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow, IW_IOCTL(SIOCGIWTXPOW) = ipw_wx_get_txpow,
IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry, IW_IOCTL(SIOCSIWRETRY) = ipw_wx_set_retry,
IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry, IW_IOCTL(SIOCGIWRETRY) = ipw_wx_get_retry,
IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode, IW_IOCTL(SIOCSIWENCODE) = ipw_wx_set_encode,
IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode, IW_IOCTL(SIOCGIWENCODE) = ipw_wx_get_encode,
IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power, IW_IOCTL(SIOCSIWPOWER) = ipw_wx_set_power,
IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power, IW_IOCTL(SIOCGIWPOWER) = ipw_wx_get_power,
}; };
#define IPW_PRIV_SET_POWER SIOCIWFIRSTPRIV #define IPW_PRIV_SET_POWER SIOCIWFIRSTPRIV
#define IPW_PRIV_GET_POWER SIOCIWFIRSTPRIV+1 #define IPW_PRIV_GET_POWER SIOCIWFIRSTPRIV+1
#define IPW_PRIV_SET_MODE SIOCIWFIRSTPRIV+2 #define IPW_PRIV_SET_MODE SIOCIWFIRSTPRIV+2
#define IPW_PRIV_GET_MODE SIOCIWFIRSTPRIV+3 #define IPW_PRIV_GET_MODE SIOCIWFIRSTPRIV+3
#define IPW_PRIV_SET_PROMISC SIOCIWFIRSTPRIV+4 #define IPW_PRIV_SET_PREAMBLE SIOCIWFIRSTPRIV+4
#define IPW_PRIV_RESET SIOCIWFIRSTPRIV+5 #define IPW_PRIV_GET_PREAMBLE SIOCIWFIRSTPRIV+5
#define IPW_PRIV_SET_MONITOR SIOCIWFIRSTPRIV+6
#define IPW_PRIV_RESET SIOCIWFIRSTPRIV+7
static struct iw_priv_args ipw_priv_args[] = { static struct iw_priv_args ipw_priv_args[] = {
{ {
...@@ -6204,14 +6953,22 @@ static struct iw_priv_args ipw_priv_args[] = { ...@@ -6204,14 +6953,22 @@ static struct iw_priv_args ipw_priv_args[] = {
.cmd = IPW_PRIV_GET_MODE, .cmd = IPW_PRIV_GET_MODE,
.get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING, .get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | MAX_WX_STRING,
.name = "get_mode"}, .name = "get_mode"},
#ifdef CONFIG_IPW_PROMISC
{ {
IPW_PRIV_SET_PROMISC, .cmd = IPW_PRIV_SET_PREAMBLE,
.set_args = IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
.name = "set_preamble"},
{
.cmd = IPW_PRIV_GET_PREAMBLE,
.get_args = IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_FIXED | IFNAMSIZ,
.name = "get_preamble"},
#ifdef CONFIG_IPW_MONITOR
{
IPW_PRIV_SET_MONITOR,
IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"}, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "monitor"},
{ {
IPW_PRIV_RESET, IPW_PRIV_RESET,
IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"}, IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 0, 0, "reset"},
#endif /* CONFIG_IPW_PROMISC */ #endif /* CONFIG_IPW_MONITOR */
}; };
static iw_handler ipw_priv_handler[] = { static iw_handler ipw_priv_handler[] = {
...@@ -6219,19 +6976,21 @@ static iw_handler ipw_priv_handler[] = { ...@@ -6219,19 +6976,21 @@ static iw_handler ipw_priv_handler[] = {
ipw_wx_get_powermode, ipw_wx_get_powermode,
ipw_wx_set_wireless_mode, ipw_wx_set_wireless_mode,
ipw_wx_get_wireless_mode, ipw_wx_get_wireless_mode,
#ifdef CONFIG_IPW_PROMISC ipw_wx_set_preamble,
ipw_wx_set_promisc, ipw_wx_get_preamble,
#ifdef CONFIG_IPW_MONITOR
ipw_wx_set_monitor,
ipw_wx_reset, ipw_wx_reset,
#endif #endif
}; };
static struct iw_handler_def ipw_wx_handler_def = { static struct iw_handler_def ipw_wx_handler_def = {
.standard = ipw_wx_handlers, .standard = ipw_wx_handlers,
.num_standard = ARRAY_SIZE(ipw_wx_handlers), .num_standard = ARRAY_SIZE(ipw_wx_handlers),
.num_private = ARRAY_SIZE(ipw_priv_handler), .num_private = ARRAY_SIZE(ipw_priv_handler),
.num_private_args = ARRAY_SIZE(ipw_priv_args), .num_private_args = ARRAY_SIZE(ipw_priv_args),
.private = ipw_priv_handler, .private = ipw_priv_handler,
.private_args = ipw_priv_args, .private_args = ipw_priv_args,
}; };
/* /*
...@@ -6246,7 +7005,7 @@ static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev) ...@@ -6246,7 +7005,7 @@ static struct iw_statistics *ipw_get_wireless_stats(struct net_device *dev)
wstats = &priv->wstats; wstats = &priv->wstats;
/* if hw is disabled, then ipw2100_get_ordinal() can't be called. /* if hw is disabled, then ipw_get_ordinal() can't be called.
* ipw2100_wx_wireless_stats seems to be called before fw is * ipw2100_wx_wireless_stats seems to be called before fw is
* initialized. STATUS_ASSOCIATED will only be set if the hw is up * initialized. STATUS_ASSOCIATED will only be set if the hw is up
* and associated; if not associcated, the values are all meaningless * and associated; if not associcated, the values are all meaningless
...@@ -6384,8 +7143,8 @@ static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb) ...@@ -6384,8 +7143,8 @@ static inline void ipw_tx_skb(struct ipw_priv *priv, struct ieee80211_txb *txb)
else else
tfd->u.data.tx_flags_ext = DCT_FLAG_EXT_MODE_OFDM; tfd->u.data.tx_flags_ext = DCT_FLAG_EXT_MODE_OFDM;
if (priv->config & CFG_PREAMBLE) if (priv->assoc_request.preamble_length == DCT_FLAG_SHORT_PREAMBLE)
tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREMBL; tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len); memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
...@@ -6568,11 +7327,11 @@ static int ipw_ethtool_set_eeprom(struct net_device *dev, ...@@ -6568,11 +7327,11 @@ static int ipw_ethtool_set_eeprom(struct net_device *dev,
} }
static struct ethtool_ops ipw_ethtool_ops = { static struct ethtool_ops ipw_ethtool_ops = {
.get_link = ipw_ethtool_get_link, .get_link = ipw_ethtool_get_link,
.get_drvinfo = ipw_ethtool_get_drvinfo, .get_drvinfo = ipw_ethtool_get_drvinfo,
.get_eeprom_len = ipw_ethtool_get_eeprom_len, .get_eeprom_len = ipw_ethtool_get_eeprom_len,
.get_eeprom = ipw_ethtool_get_eeprom, .get_eeprom = ipw_ethtool_get_eeprom,
.set_eeprom = ipw_ethtool_set_eeprom, .set_eeprom = ipw_ethtool_set_eeprom,
}; };
static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs) static irqreturn_t ipw_isr(int irq, void *data, struct pt_regs *regs)
...@@ -6918,6 +7677,25 @@ static void ipw_down(struct ipw_priv *priv) ...@@ -6918,6 +7677,25 @@ static void ipw_down(struct ipw_priv *priv)
ipw_stop_nic(priv); ipw_stop_nic(priv);
} }
static int ipw_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
#ifdef CONFIG_IEEE80211_WPA
struct iwreq *wrq = (struct iwreq *)rq;
int ret = -1;
switch (cmd) {
case IPW_IOCTL_WPA_SUPPLICANT:
ret = ipw_wpa_supplicant(dev, &wrq->u.data);
return ret;
default:
return -EOPNOTSUPP;
}
#endif /* CONFIG_IEEE80211_WPA */
return -EOPNOTSUPP;
}
/* Called by register_netdev() */ /* Called by register_netdev() */
static int ipw_net_init(struct net_device *dev) static int ipw_net_init(struct net_device *dev)
{ {
...@@ -7065,9 +7843,6 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) ...@@ -7065,9 +7843,6 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
} }
/* Initialize module parameter values here */ /* Initialize module parameter values here */
if (ifname)
strncpy(net_dev->name, ifname, IFNAMSIZ);
if (associate) if (associate)
priv->config |= CFG_ASSOCIATE; priv->config |= CFG_ASSOCIATE;
else else
...@@ -7095,7 +7870,7 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) ...@@ -7095,7 +7870,7 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
case 1: case 1:
priv->ieee->iw_mode = IW_MODE_ADHOC; priv->ieee->iw_mode = IW_MODE_ADHOC;
break; break;
#ifdef CONFIG_IPW_PROMISC #ifdef CONFIG_IPW_MONITOR
case 2: case 2:
priv->ieee->iw_mode = IW_MODE_MONITOR; priv->ieee->iw_mode = IW_MODE_MONITOR;
break; break;
...@@ -7164,6 +7939,7 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent) ...@@ -7164,6 +7939,7 @@ static int ipw_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
net_dev->open = ipw_net_open; net_dev->open = ipw_net_open;
net_dev->stop = ipw_net_stop; net_dev->stop = ipw_net_stop;
net_dev->init = ipw_net_init; net_dev->init = ipw_net_init;
net_dev->do_ioctl = ipw_ioctl;
net_dev->get_stats = ipw_net_get_stats; net_dev->get_stats = ipw_net_get_stats;
net_dev->set_multicast_list = ipw_net_set_multicast_list; net_dev->set_multicast_list = ipw_net_set_multicast_list;
net_dev->set_mac_address = ipw_net_set_mac_address; net_dev->set_mac_address = ipw_net_set_mac_address;
...@@ -7287,13 +8063,10 @@ static int ipw_pci_resume(struct pci_dev *pdev) ...@@ -7287,13 +8063,10 @@ static int ipw_pci_resume(struct pci_dev *pdev)
printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name); printk(KERN_INFO "%s: Coming out of suspend...\n", dev->name);
pci_set_power_state(pdev, 0); pci_set_power_state(pdev, PCI_D0);
pci_enable_device(pdev); pci_enable_device(pdev);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,10)
pci_restore_state(pdev, priv->pm_state);
#else
pci_restore_state(pdev); pci_restore_state(pdev);
#endif
/* /*
* Suspend/Resume resets the PCI configuration space, so we have to * Suspend/Resume resets the PCI configuration space, so we have to
* re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries * re-disable the RETRY_TIMEOUT register (0x41) to keep PCI Tx retries
...@@ -7371,10 +8144,7 @@ MODULE_PARM_DESC(debug, "debug output mask"); ...@@ -7371,10 +8144,7 @@ MODULE_PARM_DESC(debug, "debug output mask");
module_param(channel, int, 0444); module_param(channel, int, 0444);
MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])"); MODULE_PARM_DESC(channel, "channel to limit associate to (default 0 [ANY])");
module_param(ifname, charp, 0444); #ifdef CONFIG_IPW_MONITOR
MODULE_PARM_DESC(ifname, "network device name (default eth%d)");
#ifdef CONFIG_IPW_PROMISC
module_param(mode, int, 0444); module_param(mode, int, 0444);
MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)"); MODULE_PARM_DESC(mode, "network mode (0=BSS,1=IBSS,2=Monitor)");
#else #else
......
drivers/net/wireless/ipw2200.h
View file @ ea2b26e0
...@@ -168,7 +168,8 @@ enum connection_manager_assoc_states { ...@@ -168,7 +168,8 @@ enum connection_manager_assoc_states {
#define DCT_FLAG_CTS_REQUIRED 0x02 #define DCT_FLAG_CTS_REQUIRED 0x02
/* use short preamble */ /* use short preamble */
#define DCT_FLAG_SHORT_PREMBL 0x04 #define DCT_FLAG_LONG_PREAMBLE 0x00
#define DCT_FLAG_SHORT_PREAMBLE 0x04
/* RTS/CTS first */ /* RTS/CTS first */
#define DCT_FLAG_RTS_REQD 0x08 #define DCT_FLAG_RTS_REQD 0x08
...@@ -899,7 +900,7 @@ struct ipw_cmd { ...@@ -899,7 +900,7 @@ struct ipw_cmd {
#define CFG_STATIC_ESSID (1<<1) /* Restrict assoc. to single SSID */ #define CFG_STATIC_ESSID (1<<1) /* Restrict assoc. to single SSID */
#define CFG_STATIC_BSSID (1<<2) /* Restrict assoc. to single BSSID */ #define CFG_STATIC_BSSID (1<<2) /* Restrict assoc. to single BSSID */
#define CFG_CUSTOM_MAC (1<<3) #define CFG_CUSTOM_MAC (1<<3)
#define CFG_PREAMBLE (1<<4) #define CFG_PREAMBLE_LONG (1<<4)
#define CFG_ADHOC_PERSIST (1<<5) #define CFG_ADHOC_PERSIST (1<<5)
#define CFG_ASSOCIATE (1<<6) #define CFG_ASSOCIATE (1<<6)
#define CFG_FIXED_RATE (1<<7) #define CFG_FIXED_RATE (1<<7)
...@@ -1206,12 +1207,18 @@ do { if (ipw_debug_level & (level)) \ ...@@ -1206,12 +1207,18 @@ do { if (ipw_debug_level & (level)) \
/* /*
* RESET Register Bit Indexes * RESET Register Bit Indexes
*/ */
#define CBD_RESET_REG_PRINCETON_RESET 0x00000001 /* Bit 0 (LSB) */ #define CBD_RESET_REG_PRINCETON_RESET (1<<0)
#define CX2_RESET_REG_SW_RESET 0x00000080 /* Bit 7 */ #define CX2_START_STANDBY (1<<2)
#define CX2_RESET_REG_MASTER_DISABLED 0x00000100 /* Bit 8 */ #define CX2_ACTIVITY_LED (1<<4)
#define CX2_RESET_REG_STOP_MASTER 0x00000200 /* Bit 9 */ #define CX2_ASSOCIATED_LED (1<<5)
#define CX2_ARC_KESHET_CONFIG 0x08000000 /* Bit 27 */ #define CX2_OFDM_LED (1<<6)
#define CX2_START_STANDBY 0x00000004 /* Bit 2 */ #define CX2_RESET_REG_SW_RESET (1<<7)
#define CX2_RESET_REG_MASTER_DISABLED (1<<8)
#define CX2_RESET_REG_STOP_MASTER (1<<9)
#define CX2_GATE_ODMA (1<<25)
#define CX2_GATE_IDMA (1<<26)
#define CX2_ARC_KESHET_CONFIG (1<<27)
#define CX2_GATE_ADMA (1<<29)
#define CX2_CSR_CIS_UPPER_BOUND 0x00000200 #define CX2_CSR_CIS_UPPER_BOUND 0x00000200
#define CX2_DOMAIN_0_END 0x1000 #define CX2_DOMAIN_0_END 0x1000
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7