Commit c63cdbe8 authored by David Kilroy's avatar David Kilroy Committed by John W. Linville

orinoco: convert scanning to cfg80211

This removes the custom scan cache used by orinoco.

We also have to avoid calling cfg80211_scan_done from the hard
interrupt, so we offload the entirety of scan processing to a workqueue.

This may behave strangely if you start scanning just prior to
suspending...
Signed-off-by: default avatarDavid Kilroy <kilroyd@googlemail.com>
Signed-off-by: default avatarJohn W. Linville <linville@tuxdriver.com>
parent 5217c571
......@@ -137,6 +137,26 @@ static int orinoco_change_vif(struct wiphy *wiphy, struct net_device *dev,
return err;
}
static int orinoco_scan(struct wiphy *wiphy, struct net_device *dev,
struct cfg80211_scan_request *request)
{
struct orinoco_private *priv = wiphy_priv(wiphy);
int err;
if (!request)
return -EINVAL;
if (priv->scan_request && priv->scan_request != request)
return -EBUSY;
priv->scan_request = request;
err = orinoco_hw_trigger_scan(priv, request->ssids);
return err;
}
const struct cfg80211_ops orinoco_cfg_ops = {
.change_virtual_intf = orinoco_change_vif,
.scan = orinoco_scan,
};
......@@ -342,7 +342,7 @@ struct agere_ext_scan_info {
__le64 timestamp;
__le16 beacon_interval;
__le16 capabilities;
u8 data[316];
u8 data[0];
} __attribute__ ((packed));
#define HERMES_LINKSTATUS_NOT_CONNECTED (0x0000)
......
......@@ -1157,3 +1157,88 @@ int orinoco_hw_get_bitratelist(struct orinoco_private *priv,
return 0;
}
int orinoco_hw_trigger_scan(struct orinoco_private *priv,
const struct cfg80211_ssid *ssid)
{
struct net_device *dev = priv->ndev;
hermes_t *hw = &priv->hw;
unsigned long flags;
int err = 0;
if (orinoco_lock(priv, &flags) != 0)
return -EBUSY;
/* Scanning with port 0 disabled would fail */
if (!netif_running(dev)) {
err = -ENETDOWN;
goto out;
}
/* In monitor mode, the scan results are always empty.
* Probe responses are passed to the driver as received
* frames and could be processed in software. */
if (priv->iw_mode == NL80211_IFTYPE_MONITOR) {
err = -EOPNOTSUPP;
goto out;
}
if (priv->has_hostscan) {
switch (priv->firmware_type) {
case FIRMWARE_TYPE_SYMBOL:
err = hermes_write_wordrec(hw, USER_BAP,
HERMES_RID_CNFHOSTSCAN_SYMBOL,
HERMES_HOSTSCAN_SYMBOL_ONCE |
HERMES_HOSTSCAN_SYMBOL_BCAST);
break;
case FIRMWARE_TYPE_INTERSIL: {
__le16 req[3];
req[0] = cpu_to_le16(0x3fff); /* All channels */
req[1] = cpu_to_le16(0x0001); /* rate 1 Mbps */
req[2] = 0; /* Any ESSID */
err = HERMES_WRITE_RECORD(hw, USER_BAP,
HERMES_RID_CNFHOSTSCAN, &req);
break;
}
case FIRMWARE_TYPE_AGERE:
if (ssid->ssid_len > 0) {
struct hermes_idstring idbuf;
size_t len = ssid->ssid_len;
idbuf.len = cpu_to_le16(len);
memcpy(idbuf.val, ssid->ssid, len);
err = hermes_write_ltv(hw, USER_BAP,
HERMES_RID_CNFSCANSSID_AGERE,
HERMES_BYTES_TO_RECLEN(len + 2),
&idbuf);
} else
err = hermes_write_wordrec(hw, USER_BAP,
HERMES_RID_CNFSCANSSID_AGERE,
0); /* Any ESSID */
if (err)
break;
if (priv->has_ext_scan) {
err = hermes_write_wordrec(hw, USER_BAP,
HERMES_RID_CNFSCANCHANNELS2GHZ,
0x7FFF);
if (err)
goto out;
err = hermes_inquire(hw,
HERMES_INQ_CHANNELINFO);
} else
err = hermes_inquire(hw, HERMES_INQ_SCAN);
break;
}
} else
err = hermes_inquire(hw, HERMES_INQ_SCAN);
out:
orinoco_unlock(priv, &flags);
return err;
}
......@@ -7,6 +7,7 @@
#include <linux/types.h>
#include <linux/wireless.h>
#include <net/cfg80211.h>
/* Hardware BAPs */
#define USER_BAP 0
......@@ -47,5 +48,7 @@ int orinoco_hw_get_essid(struct orinoco_private *priv, int *active,
int orinoco_hw_get_freq(struct orinoco_private *priv);
int orinoco_hw_get_bitratelist(struct orinoco_private *priv,
int *numrates, s32 *rates, int max);
int orinoco_hw_trigger_scan(struct orinoco_private *priv,
const struct cfg80211_ssid *ssid);
#endif /* _ORINOCO_HW_H_ */
......@@ -206,6 +206,13 @@ struct orinoco_rx_data {
struct list_head list;
};
struct orinoco_scan_data {
void *buf;
size_t len;
int type;
struct list_head list;
};
/********************************************************************/
/* Function prototypes */
/********************************************************************/
......@@ -1265,6 +1272,78 @@ static void orinoco_send_wevents(struct work_struct *work)
orinoco_unlock(priv, &flags);
}
static void qbuf_scan(struct orinoco_private *priv, void *buf,
int len, int type)
{
struct orinoco_scan_data *sd;
unsigned long flags;
sd = kmalloc(sizeof(*sd), GFP_ATOMIC);
sd->buf = buf;
sd->len = len;
sd->type = type;
spin_lock_irqsave(&priv->scan_lock, flags);
list_add_tail(&sd->list, &priv->scan_list);
spin_unlock_irqrestore(&priv->scan_lock, flags);
schedule_work(&priv->process_scan);
}
static void qabort_scan(struct orinoco_private *priv)
{
struct orinoco_scan_data *sd;
unsigned long flags;
sd = kmalloc(sizeof(*sd), GFP_ATOMIC);
sd->len = -1; /* Abort */
spin_lock_irqsave(&priv->scan_lock, flags);
list_add_tail(&sd->list, &priv->scan_list);
spin_unlock_irqrestore(&priv->scan_lock, flags);
schedule_work(&priv->process_scan);
}
static void orinoco_process_scan_results(struct work_struct *work)
{
struct orinoco_private *priv =
container_of(work, struct orinoco_private, process_scan);
struct orinoco_scan_data *sd, *temp;
unsigned long flags;
void *buf;
int len;
int type;
spin_lock_irqsave(&priv->scan_lock, flags);
list_for_each_entry_safe(sd, temp, &priv->scan_list, list) {
spin_unlock_irqrestore(&priv->scan_lock, flags);
buf = sd->buf;
len = sd->len;
type = sd->type;
list_del(&sd->list);
kfree(sd);
if (len > 0) {
if (type == HERMES_INQ_CHANNELINFO)
orinoco_add_extscan_result(priv, buf, len);
else
orinoco_add_hostscan_results(priv, buf, len);
kfree(buf);
} else if (priv->scan_request) {
/* Either abort or complete the scan */
cfg80211_scan_done(priv->scan_request, (len < 0));
priv->scan_request = NULL;
}
spin_lock_irqsave(&priv->scan_lock, flags);
}
spin_unlock_irqrestore(&priv->scan_lock, flags);
}
static void __orinoco_ev_info(struct net_device *dev, hermes_t *hw)
{
struct orinoco_private *priv = ndev_priv(dev);
......@@ -1351,7 +1430,7 @@ static void __orinoco_ev_info(struct net_device *dev, hermes_t *hw)
* the hostscan frame can be requested. */
if (newstatus == HERMES_LINKSTATUS_AP_OUT_OF_RANGE &&
priv->firmware_type == FIRMWARE_TYPE_SYMBOL &&
priv->has_hostscan && priv->scan_inprogress) {
priv->has_hostscan && priv->scan_request) {
hermes_inquire(hw, HERMES_INQ_HOSTSCAN_SYMBOL);
break;
}
......@@ -1377,7 +1456,7 @@ static void __orinoco_ev_info(struct net_device *dev, hermes_t *hw)
}
break;
case HERMES_INQ_SCAN:
if (!priv->scan_inprogress && priv->bssid_fixed &&
if (!priv->scan_request && priv->bssid_fixed &&
priv->firmware_type == FIRMWARE_TYPE_INTERSIL) {
schedule_work(&priv->join_work);
break;
......@@ -1387,30 +1466,30 @@ static void __orinoco_ev_info(struct net_device *dev, hermes_t *hw)
case HERMES_INQ_HOSTSCAN_SYMBOL: {
/* Result of a scanning. Contains information about
* cells in the vicinity - Jean II */
union iwreq_data wrqu;
unsigned char *buf;
/* Scan is no longer in progress */
priv->scan_inprogress = 0;
/* Sanity check */
if (len > 4096) {
printk(KERN_WARNING "%s: Scan results too large (%d bytes)\n",
dev->name, len);
qabort_scan(priv);
break;
}
/* Allocate buffer for results */
buf = kmalloc(len, GFP_ATOMIC);
if (buf == NULL)
if (buf == NULL) {
/* No memory, so can't printk()... */
qabort_scan(priv);
break;
}
/* Read scan data */
err = hermes_bap_pread(hw, IRQ_BAP, (void *) buf, len,
infofid, sizeof(info));
if (err) {
kfree(buf);
qabort_scan(priv);
break;
}
......@@ -1424,24 +1503,14 @@ static void __orinoco_ev_info(struct net_device *dev, hermes_t *hw)
}
#endif /* ORINOCO_DEBUG */
if (orinoco_process_scan_results(priv, buf, len) == 0) {
/* Send an empty event to user space.
* We don't send the received data on the event because
* it would require us to do complex transcoding, and
* we want to minimise the work done in the irq handler
* Use a request to extract the data - Jean II */
wrqu.data.length = 0;
wrqu.data.flags = 0;
wireless_send_event(dev, SIOCGIWSCAN, &wrqu, NULL);
}
kfree(buf);
qbuf_scan(priv, buf, len, type);
}
break;
case HERMES_INQ_CHANNELINFO:
{
struct agere_ext_scan_info *bss;
if (!priv->scan_inprogress) {
if (!priv->scan_request) {
printk(KERN_DEBUG "%s: Got chaninfo without scan, "
"len=%d\n", dev->name, len);
break;
......@@ -1449,25 +1518,12 @@ static void __orinoco_ev_info(struct net_device *dev, hermes_t *hw)
/* An empty result indicates that the scan is complete */
if (len == 0) {
union iwreq_data wrqu;
/* Scan is no longer in progress */
priv->scan_inprogress = 0;
wrqu.data.length = 0;
wrqu.data.flags = 0;
wireless_send_event(dev, SIOCGIWSCAN, &wrqu, NULL);
qbuf_scan(priv, NULL, len, type);
break;
}
/* Sanity check */
else if (len > sizeof(*bss)) {
printk(KERN_WARNING
"%s: Ext scan results too large (%d bytes). "
"Truncating results to %zd bytes.\n",
dev->name, len, sizeof(*bss));
len = sizeof(*bss);
} else if (len < (offsetof(struct agere_ext_scan_info,
else if (len < (offsetof(struct agere_ext_scan_info,
data) + 2)) {
/* Drop this result now so we don't have to
* keep checking later */
......@@ -1477,21 +1533,18 @@ static void __orinoco_ev_info(struct net_device *dev, hermes_t *hw)
break;
}
bss = kmalloc(sizeof(*bss), GFP_ATOMIC);
bss = kmalloc(len, GFP_ATOMIC);
if (bss == NULL)
break;
/* Read scan data */
err = hermes_bap_pread(hw, IRQ_BAP, (void *) bss, len,
infofid, sizeof(info));
if (err) {
if (err)
kfree(bss);
break;
}
orinoco_add_ext_scan_result(priv, bss);
else
qbuf_scan(priv, bss, len, type);
kfree(bss);
break;
}
case HERMES_INQ_SEC_STAT_AGERE:
......@@ -1506,6 +1559,8 @@ static void __orinoco_ev_info(struct net_device *dev, hermes_t *hw)
/* We don't actually do anything about it */
break;
}
return;
}
static void __orinoco_ev_infdrop(struct net_device *dev, hermes_t *hw)
......@@ -1649,9 +1704,11 @@ void orinoco_reset(struct work_struct *work)
orinoco_unlock(priv, &flags);
/* Scanning support: Cleanup of driver struct */
orinoco_clear_scan_results(priv, 0);
priv->scan_inprogress = 0;
/* Scanning support: Notify scan cancellation */
if (priv->scan_request) {
cfg80211_scan_done(priv->scan_request, 1);
priv->scan_request = NULL;
}
if (priv->hard_reset) {
err = (*priv->hard_reset)(priv);
......@@ -1965,12 +2022,6 @@ int orinoco_init(struct orinoco_private *priv)
}
}
/* Now we have the firmware capabilities, allocate appropiate
* sized scan buffers */
if (orinoco_bss_data_allocate(priv))
goto out;
orinoco_bss_data_init(priv);
err = orinoco_hw_read_card_settings(priv, wiphy->perm_addr);
if (err)
goto out;
......@@ -2100,6 +2151,10 @@ struct orinoco_private
tasklet_init(&priv->rx_tasklet, orinoco_rx_isr_tasklet,
(unsigned long) priv);
spin_lock_init(&priv->scan_lock);
INIT_LIST_HEAD(&priv->scan_list);
INIT_WORK(&priv->process_scan, orinoco_process_scan_results);
priv->last_linkstatus = 0xffff;
#if defined(CONFIG_HERMES_CACHE_FW_ON_INIT) || defined(CONFIG_PM_SLEEP)
......@@ -2192,6 +2247,7 @@ void free_orinocodev(struct orinoco_private *priv)
{
struct wiphy *wiphy = priv_to_wiphy(priv);
struct orinoco_rx_data *rx_data, *temp;
struct orinoco_scan_data *sd, *sdtemp;
wiphy_unregister(wiphy);
......@@ -2209,13 +2265,22 @@ void free_orinocodev(struct orinoco_private *priv)
kfree(rx_data);
}
cancel_work_sync(&priv->process_scan);
/* Explicitly drain priv->scan_list */
list_for_each_entry_safe(sd, sdtemp, &priv->scan_list, list) {
list_del(&sd->list);
if ((sd->len > 0) && sd->buf)
kfree(sd->buf);
kfree(sd);
}
orinoco_unregister_pm_notifier(priv);
orinoco_uncache_fw(priv);
priv->wpa_ie_len = 0;
kfree(priv->wpa_ie);
orinoco_mic_free(priv);
orinoco_bss_data_free(priv);
wiphy_free(wiphy);
}
EXPORT_SYMBOL(free_orinocodev);
......
......@@ -48,18 +48,6 @@ typedef enum {
FIRMWARE_TYPE_SYMBOL
} fwtype_t;
struct bss_element {
union hermes_scan_info bss;
unsigned long last_scanned;
struct list_head list;
};
struct xbss_element {
struct agere_ext_scan_info bss;
unsigned long last_scanned;
struct list_head list;
};
struct firmware;
struct orinoco_private {
......@@ -145,12 +133,10 @@ struct orinoco_private {
int promiscuous, mc_count;
/* Scanning support */
struct list_head bss_list;
struct list_head bss_free_list;
void *bss_xbss_data;
int scan_inprogress; /* Scan pending... */
u32 scan_mode; /* Type of scan done */
struct cfg80211_scan_request *scan_request;
struct work_struct process_scan;
struct list_head scan_list;
spinlock_t scan_lock; /* protects the scan list */
/* WPA support */
u8 *wpa_ie;
......
......@@ -5,147 +5,166 @@
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/etherdevice.h>
#include <linux/ieee80211.h>
#include <net/cfg80211.h>
#include "hermes.h"
#include "orinoco.h"
#include "main.h"
#include "scan.h"
#define ORINOCO_MAX_BSS_COUNT 64
#define ZERO_DBM_OFFSET 0x95
#define MAX_SIGNAL_LEVEL 0x8A
#define MIN_SIGNAL_LEVEL 0x2F
#define PRIV_BSS ((struct bss_element *)priv->bss_xbss_data)
#define PRIV_XBSS ((struct xbss_element *)priv->bss_xbss_data)
#define SIGNAL_TO_DBM(x) \
(clamp_t(s32, (x), MIN_SIGNAL_LEVEL, MAX_SIGNAL_LEVEL) \
- ZERO_DBM_OFFSET)
#define SIGNAL_TO_MBM(x) (SIGNAL_TO_DBM(x) * 100)
int orinoco_bss_data_allocate(struct orinoco_private *priv)
static int symbol_build_supp_rates(u8 *buf, const __le16 *rates)
{
if (priv->bss_xbss_data)
return 0;
if (priv->has_ext_scan)
priv->bss_xbss_data = kzalloc(ORINOCO_MAX_BSS_COUNT *
sizeof(struct xbss_element),
GFP_KERNEL);
else
priv->bss_xbss_data = kzalloc(ORINOCO_MAX_BSS_COUNT *
sizeof(struct bss_element),
GFP_KERNEL);
if (!priv->bss_xbss_data) {
printk(KERN_WARNING "Out of memory allocating beacons");
return -ENOMEM;
int i;
u8 rate;
buf[0] = WLAN_EID_SUPP_RATES;
for (i = 0; i < 5; i++) {
rate = le16_to_cpu(rates[i]);
/* NULL terminated */
if (rate == 0x0)
break;
buf[i + 2] = rate;
}
return 0;
}
buf[1] = i;
void orinoco_bss_data_free(struct orinoco_private *priv)
{
kfree(priv->bss_xbss_data);
priv->bss_xbss_data = NULL;
return i + 2;
}
void orinoco_bss_data_init(struct orinoco_private *priv)
static int prism_build_supp_rates(u8 *buf, const u8 *rates)
{
int i;
INIT_LIST_HEAD(&priv->bss_free_list);
INIT_LIST_HEAD(&priv->bss_list);
if (priv->has_ext_scan)
for (i = 0; i < ORINOCO_MAX_BSS_COUNT; i++)
list_add_tail(&(PRIV_XBSS[i].list),
&priv->bss_free_list);
else
for (i = 0; i < ORINOCO_MAX_BSS_COUNT; i++)
list_add_tail(&(PRIV_BSS[i].list),
&priv->bss_free_list);
}
void orinoco_clear_scan_results(struct orinoco_private *priv,
unsigned long scan_age)
{
if (priv->has_ext_scan) {
struct xbss_element *bss;
struct xbss_element *tmp_bss;
/* Blow away current list of scan results */
list_for_each_entry_safe(bss, tmp_bss, &priv->bss_list, list) {
if (!scan_age ||
time_after(jiffies, bss->last_scanned + scan_age)) {
list_move_tail(&bss->list,
&priv->bss_free_list);
/* Don't blow away ->list, just BSS data */
memset(&bss->bss, 0, sizeof(bss->bss));
bss->last_scanned = 0;
}
}
} else {
struct bss_element *bss;
struct bss_element *tmp_bss;
/* Blow away current list of scan results */
list_for_each_entry_safe(bss, tmp_bss, &priv->bss_list, list) {
if (!scan_age ||
time_after(jiffies, bss->last_scanned + scan_age)) {
list_move_tail(&bss->list,
&priv->bss_free_list);
/* Don't blow away ->list, just BSS data */
memset(&bss->bss, 0, sizeof(bss->bss));
bss->last_scanned = 0;
}
buf[0] = WLAN_EID_SUPP_RATES;
for (i = 0; i < 8; i++) {
/* NULL terminated */
if (rates[i] == 0x0)
break;
buf[i + 2] = rates[i];
}
buf[1] = i;
/* We might still have another 2 rates, which need to go in
* extended supported rates */
if (i == 8 && rates[i] > 0) {
buf[10] = WLAN_EID_EXT_SUPP_RATES;
for (; i < 10; i++) {
/* NULL terminated */
if (rates[i] == 0x0)
break;
buf[i + 2] = rates[i];
}
buf[11] = i - 8;
}
return (i < 8) ? i + 2 : i + 4;
}
void orinoco_add_ext_scan_result(struct orinoco_private *priv,
struct agere_ext_scan_info *atom)
static void orinoco_add_hostscan_result(struct orinoco_private *priv,
const union hermes_scan_info *bss)
{
struct xbss_element *bss = NULL;
int found = 0;
/* Try to update an existing bss first */
list_for_each_entry(bss, &priv->bss_list, list) {
if (compare_ether_addr(bss->bss.bssid, atom->bssid))
continue;
/* ESSID lengths */
if (bss->bss.data[1] != atom->data[1])
continue;
if (memcmp(&bss->bss.data[2], &atom->data[2],
atom->data[1]))
continue;
found = 1;
struct wiphy *wiphy = priv_to_wiphy(priv);
struct ieee80211_channel *channel;
u8 *ie;
u8 ie_buf[46];
u64 timestamp;
s32 signal;
u16 capability;
u16 beacon_interval;
int ie_len;
int freq;
int len;
len = le16_to_cpu(bss->a.essid_len);
/* Reconstruct SSID and bitrate IEs to pass up */
ie_buf[0] = WLAN_EID_SSID;
ie_buf[1] = len;
memcpy(&ie_buf[2], bss->a.essid, len);
ie = ie_buf + len + 2;
ie_len = ie_buf[1] + 2;
switch (priv->firmware_type) {
case FIRMWARE_TYPE_SYMBOL:
ie_len += symbol_build_supp_rates(ie, bss->s.rates);
break;
}
/* Grab a bss off the free list */
if (!found && !list_empty(&priv->bss_free_list)) {
bss = list_entry(priv->bss_free_list.next,
struct xbss_element, list);
list_del(priv->bss_free_list.next);
case FIRMWARE_TYPE_INTERSIL:
ie_len += prism_build_supp_rates(ie, bss->p.rates);
break;
list_add_tail(&bss->list, &priv->bss_list);
case FIRMWARE_TYPE_AGERE:
default:
break;
}
if (bss) {
/* Always update the BSS to get latest beacon info */
memcpy(&bss->bss, atom, sizeof(bss->bss));
bss->last_scanned = jiffies;
}
freq = ieee80211_dsss_chan_to_freq(le16_to_cpu(bss->a.channel));
channel = ieee80211_get_channel(wiphy, freq);
timestamp = 0;
capability = le16_to_cpu(bss->a.capabilities);
beacon_interval = le16_to_cpu(bss->a.beacon_interv);
signal = SIGNAL_TO_MBM(le16_to_cpu(bss->a.level));
cfg80211_inform_bss(wiphy, channel, bss->a.bssid, timestamp,
capability, beacon_interval, ie_buf, ie_len,
signal, GFP_KERNEL);
}
int orinoco_process_scan_results(struct orinoco_private *priv,
unsigned char *buf,
int len)
void orinoco_add_extscan_result(struct orinoco_private *priv,
struct agere_ext_scan_info *bss,
size_t len)
{
int offset; /* In the scan data */
union hermes_scan_info *atom;
int atom_len;
struct wiphy *wiphy = priv_to_wiphy(priv);
struct ieee80211_channel *channel;
u8 *ie;
u64 timestamp;
s32 signal;
u16 capability;
u16 beacon_interval;
size_t ie_len;
int chan, freq;
ie_len = len - sizeof(*bss);
ie = orinoco_get_ie(bss->data, ie_len, WLAN_EID_DS_PARAMS);
chan = ie ? ie[2] : 0;
freq = ieee80211_dsss_chan_to_freq(chan);
channel = ieee80211_get_channel(wiphy, freq);
timestamp = le64_to_cpu(bss->timestamp);
capability = le16_to_cpu(bss->capabilities);
beacon_interval = le16_to_cpu(bss->beacon_interval);
ie = bss->data;
signal = SIGNAL_TO_MBM(bss->level);
cfg80211_inform_bss(wiphy, channel, bss->bssid, timestamp,
capability, beacon_interval, ie, ie_len,
signal, GFP_KERNEL);
}
void orinoco_add_hostscan_results(struct orinoco_private *priv,
unsigned char *buf,
size_t len)
{
int offset; /* In the scan data */
size_t atom_len;
bool abort = false;
switch (priv->firmware_type) {
case FIRMWARE_TYPE_AGERE:
atom_len = sizeof(struct agere_scan_apinfo);
offset = 0;
break;
case FIRMWARE_TYPE_SYMBOL:
/* Lack of documentation necessitates this hack.
* Different firmwares have 68 or 76 byte long atoms.
......@@ -163,6 +182,7 @@ int orinoco_process_scan_results(struct orinoco_private *priv,
atom_len = 68;
offset = 0;
break;
case FIRMWARE_TYPE_INTERSIL:
offset = 4;
if (priv->has_hostscan) {
......@@ -172,13 +192,16 @@ int orinoco_process_scan_results(struct orinoco_private *priv,
printk(KERN_ERR "%s: Invalid atom_len in scan "
"data: %d\n", priv->ndev->name,
atom_len);
return -EIO;
abort = true;
goto scan_abort;
}
} else
atom_len = offsetof(struct prism2_scan_apinfo, atim);
break;
default:
return -EOPNOTSUPP;
abort = true;
goto scan_abort;
}
/* Check that we got an whole number of atoms */
......@@ -186,48 +209,22 @@ int orinoco_process_scan_results(struct orinoco_private *priv,
printk(KERN_ERR "%s: Unexpected scan data length %d, "
"atom_len %d, offset %d\n", priv->ndev->name, len,
atom_len, offset);
return -EIO;
abort = true;
goto scan_abort;
}
orinoco_clear_scan_results(priv, msecs_to_jiffies(15000));
/* Read the entries one by one */
/* Process the entries one by one */
for (; offset + atom_len <= len; offset += atom_len) {
int found = 0;
struct bss_element *bss = NULL;
union hermes_scan_info *atom;
/* Get next atom */
atom = (union hermes_scan_info *) (buf + offset);
/* Try to update an existing bss first */
list_for_each_entry(bss, &priv->bss_list, list) {
if (compare_ether_addr(bss->bss.a.bssid, atom->a.bssid))
continue;
if (le16_to_cpu(bss->bss.a.essid_len) !=
le16_to_cpu(atom->a.essid_len))
continue;
if (memcmp(bss->bss.a.essid, atom->a.essid,
le16_to_cpu(atom->a.essid_len)))
continue;
found = 1;
break;
}
/* Grab a bss off the free list */
if (!found && !list_empty(&priv->bss_free_list)) {
bss = list_entry(priv->bss_free_list.next,
struct bss_element, list);
list_del(priv->bss_free_list.next);
list_add_tail(&bss->list, &priv->bss_list);
}
if (bss) {
/* Always update the BSS to get latest beacon info */
memcpy(&bss->bss, atom, sizeof(bss->bss));
bss->last_scanned = jiffies;
}
orinoco_add_hostscan_result(priv, atom);
}
return 0;
scan_abort:
if (priv->scan_request) {
cfg80211_scan_done(priv->scan_request, abort);
priv->scan_request = NULL;
}
}
......@@ -9,21 +9,12 @@
struct orinoco_private;
struct agere_ext_scan_info;
/* Setup and free memory for scan results */
int orinoco_bss_data_allocate(struct orinoco_private *priv);
void orinoco_bss_data_free(struct orinoco_private *priv);
void orinoco_bss_data_init(struct orinoco_private *priv);
/* Add scan results */
void orinoco_add_ext_scan_result(struct orinoco_private *priv,
struct agere_ext_scan_info *atom);
int orinoco_process_scan_results(struct orinoco_private *dev,
unsigned char *buf,
int len);
/* Clear scan results */
void orinoco_clear_scan_results(struct orinoco_private *priv,
unsigned long scan_age);
void orinoco_add_extscan_result(struct orinoco_private *priv,
struct agere_ext_scan_info *atom,
size_t len);
void orinoco_add_hostscan_results(struct orinoco_private *dev,
unsigned char *buf,
size_t len);
#endif /* _ORINOCO_SCAN_H_ */
This diff is collapsed.
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