scan.c 5.88 KB
Newer Older
1 2 3 4 5
/* Helpers for managing scan queues
 *
 * See copyright notice in main.c
 */

6
#include <linux/gfp.h>
7 8
#include <linux/kernel.h>
#include <linux/string.h>
9 10
#include <linux/ieee80211.h>
#include <net/cfg80211.h>
11 12 13

#include "hermes.h"
#include "orinoco.h"
14
#include "main.h"
15 16 17

#include "scan.h"

18 19 20
#define ZERO_DBM_OFFSET 0x95
#define MAX_SIGNAL_LEVEL 0x8A
#define MIN_SIGNAL_LEVEL 0x2F
21

22 23 24 25
#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)
26

27
static int symbol_build_supp_rates(u8 *buf, const __le16 *rates)
28
{
29 30 31 32 33 34 35 36 37 38
	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;
39
	}
40
	buf[1] = i;
41

42
	return i + 2;
43 44
}

45
static int prism_build_supp_rates(u8 *buf, const u8 *rates)
46 47 48
{
	int i;

49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
	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];
67
		}
68
		buf[11] = i - 8;
69
	}
70 71

	return (i < 8) ? i + 2 : i + 4;
72 73
}

74 75
static void orinoco_add_hostscan_result(struct orinoco_private *priv,
					const union hermes_scan_info *bss)
76
{
77 78
	struct wiphy *wiphy = priv_to_wiphy(priv);
	struct ieee80211_channel *channel;
79
	struct cfg80211_bss *cbss;
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
	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);
102 103
		break;

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

108 109 110
	case FIRMWARE_TYPE_AGERE:
	default:
		break;
111 112
	}

113
	freq = ieee80211_channel_to_frequency(
114
		le16_to_cpu(bss->a.channel), NL80211_BAND_2GHZ);
115
	channel = ieee80211_get_channel(wiphy, freq);
116 117 118 119 120
	if (!channel) {
		printk(KERN_DEBUG "Invalid channel designation %04X(%04X)",
			bss->a.channel, freq);
		return;	/* Then ignore it for now */
	}
121 122 123 124 125
	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));

126 127 128 129
	cbss = cfg80211_inform_bss(wiphy, channel, CFG80211_BSS_FTYPE_UNKNOWN,
				   bss->a.bssid, timestamp, capability,
				   beacon_interval, ie_buf, ie_len, signal,
				   GFP_KERNEL);
130
	cfg80211_put_bss(wiphy, cbss);
131 132
}

133 134 135
void orinoco_add_extscan_result(struct orinoco_private *priv,
				struct agere_ext_scan_info *bss,
				size_t len)
136
{
137 138
	struct wiphy *wiphy = priv_to_wiphy(priv);
	struct ieee80211_channel *channel;
139
	struct cfg80211_bss *cbss;
David Kilroy's avatar
David Kilroy committed
140
	const u8 *ie;
141 142 143 144 145 146 147 148
	u64 timestamp;
	s32 signal;
	u16 capability;
	u16 beacon_interval;
	size_t ie_len;
	int chan, freq;

	ie_len = len - sizeof(*bss);
David Kilroy's avatar
David Kilroy committed
149
	ie = cfg80211_find_ie(WLAN_EID_DS_PARAMS, bss->data, ie_len);
150
	chan = ie ? ie[2] : 0;
151
	freq = ieee80211_channel_to_frequency(chan, NL80211_BAND_2GHZ);
152 153 154 155 156 157 158 159
	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);

160 161 162 163
	cbss = cfg80211_inform_bss(wiphy, channel, CFG80211_BSS_FTYPE_UNKNOWN,
				   bss->bssid, timestamp, capability,
				   beacon_interval, ie, ie_len, signal,
				   GFP_KERNEL);
164
	cfg80211_put_bss(wiphy, cbss);
165 166 167 168 169 170 171 172 173
}

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;
174 175 176 177 178 179

	switch (priv->firmware_type) {
	case FIRMWARE_TYPE_AGERE:
		atom_len = sizeof(struct agere_scan_apinfo);
		offset = 0;
		break;
180

181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
	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;
198

199 200 201 202 203 204 205
	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 "
206
				       "data: %zu\n", priv->ndev->name,
207
				       atom_len);
208 209
				abort = true;
				goto scan_abort;
210 211 212 213
			}
		} else
			atom_len = offsetof(struct prism2_scan_apinfo, atim);
		break;
214

215
	default:
216 217
		abort = true;
		goto scan_abort;
218 219 220 221
	}

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

229
	/* Process the entries one by one */
230
	for (; offset + atom_len <= len; offset += atom_len) {
231
		union hermes_scan_info *atom;
232 233 234

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

235
		orinoco_add_hostscan_result(priv, atom);
236 237
	}

238 239 240 241 242
 scan_abort:
	if (priv->scan_request) {
		cfg80211_scan_done(priv->scan_request, abort);
		priv->scan_request = NULL;
	}
243
}
244 245 246 247 248 249 250 251

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