scan.c

Go to the documentation of this file.

/* Helpers for managing scan queues
 *
 * See copyright notice in main.c
 */

#include <linux/gfp.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/ieee80211.h>
#include <net/cfg80211.h>

#include "hermes.h"
#include "orinoco.h"
#include "main.h"

#include "scan.h"

#define ZERO_DBM_OFFSET 0x95
#define MAX_SIGNAL_LEVEL 0x8A
#define MIN_SIGNAL_LEVEL 0x2F

#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)

static int symbol_build_supp_rates(u8 *buf, const __le16 *rates)
{
    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;
    }
    buf[1] = i;

    return i + 2;
}

static int prism_build_supp_rates(u8 *buf, const u8 *rates)
{
    int i;

    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;
}

static void orinoco_add_hostscan_result(struct orinoco_private *priv,
                    const union hermes_scan_info *bss)
{
    struct wiphy *wiphy = priv_to_wiphy(priv);
    struct ieee80211_channel *channel;
    struct cfg80211_bss *cbss;
    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;

    case FIRMWARE_TYPE_INTERSIL:
        ie_len += prism_build_supp_rates(ie, bss->p.rates);
        break;

    case FIRMWARE_TYPE_AGERE:
    default:
        break;
    }

    freq = ieee80211_dsss_chan_to_freq(le16_to_cpu(bss->a.channel));
    channel = ieee80211_get_channel(wiphy, freq);
    if (!channel) {
        printk(KERN_DEBUG "Invalid channel designation %04X(%04X)",
            bss->a.channel, freq);
        return; /* Then ignore it for now */
    }
    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));

    cbss = cfg80211_inform_bss(wiphy, channel, bss->a.bssid, timestamp,
                   capability, beacon_interval, ie_buf, ie_len,
                   signal, GFP_KERNEL);
    cfg80211_put_bss(cbss);
}

void orinoco_add_extscan_result(struct orinoco_private *priv,
                struct agere_ext_scan_info *bss,
                size_t len)
{
    struct wiphy *wiphy = priv_to_wiphy(priv);
    struct ieee80211_channel *channel;
    struct cfg80211_bss *cbss;
    const u8 *ie;
    u64 timestamp;
    s32 signal;
    u16 capability;
    u16 beacon_interval;
    size_t ie_len;
    int chan, freq;

    ie_len = len - sizeof(*bss);
    ie = cfg80211_find_ie(WLAN_EID_DS_PARAMS, bss->data, ie_len);
    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);

    cbss = cfg80211_inform_bss(wiphy, channel, bss->bssid, timestamp,
                   capability, beacon_interval, ie, ie_len,
                   signal, GFP_KERNEL);
    cfg80211_put_bss(cbss);
}

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.
         * We try modulo first.  If the length divides by both,
         * we check what would be the channel in the second
         * frame for a 68-byte atom.  76-byte atoms have 0 there.
         * Valid channel cannot be 0.  */
        if (len % 76)
            atom_len = 68;
        else if (len % 68)
            atom_len = 76;
        else if (len >= 1292 && buf[68] == 0)
            atom_len = 76;
        else
            atom_len = 68;
        offset = 0;
        break;

    case FIRMWARE_TYPE_INTERSIL:
        offset = 4;
        if (priv->has_hostscan) {
            atom_len = le16_to_cpup((__le16 *)buf);
            /* Sanity check for atom_len */
            if (atom_len < sizeof(struct prism2_scan_apinfo)) {
                printk(KERN_ERR "%s: Invalid atom_len in scan "
                       "data: %zu\n", priv->ndev->name,
                       atom_len);
                abort = true;
                goto scan_abort;
            }
        } else
            atom_len = offsetof(struct prism2_scan_apinfo, atim);
        break;

    default:
        abort = true;
        goto scan_abort;
    }

    /* Check that we got an whole number of atoms */
    if ((len - offset) % atom_len) {
        printk(KERN_ERR "%s: Unexpected scan data length %zu, "
               "atom_len %zu, offset %d\n", priv->ndev->name, len,
               atom_len, offset);
        abort = true;
        goto scan_abort;
    }

    /* Process the entries one by one */
    for (; offset + atom_len <= len; offset += atom_len) {
        union hermes_scan_info *atom;

        atom = (union hermes_scan_info *) (buf + offset);

        orinoco_add_hostscan_result(priv, atom);
    }

 scan_abort:
    if (priv->scan_request) {
        cfg80211_scan_done(priv->scan_request, abort);
        priv->scan_request = NULL;
    }
}

void orinoco_scan_done(struct orinoco_private *priv, bool abort)
{
    if (priv->scan_request) {
        cfg80211_scan_done(priv->scan_request, abort);
        priv->scan_request = NULL;
    }
}