[mirror_ubuntu-eoan-kernel.git] / drivers / net / wireless / wl12xx / scan.c

/*
 * This file is part of wl1271
 *
 * Copyright (C) 2009-2010 Nokia Corporation
 *
 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 */

#include <linux/ieee80211.h>

#include "wl12xx.h"
#include "cmd.h"
#include "scan.h"
#include "acx.h"
#include "ps.h"

void wl1271_scan_complete_work(struct work_struct *work)
{
	struct delayed_work *dwork;
	struct wl1271 *wl;

	dwork = container_of(work, struct delayed_work, work);
	wl = container_of(dwork, struct wl1271, scan_complete_work);

	wl1271_debug(DEBUG_SCAN, "Scanning complete");

	mutex_lock(&wl->mutex);

	if (wl->state == WL1271_STATE_OFF)
		goto out;

	if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
		goto out;

	wl->scan.state = WL1271_SCAN_STATE_IDLE;
	memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
	wl->scan.req = NULL;
	ieee80211_scan_completed(wl->hw, false);

	/* restore hardware connection monitoring template */
	if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
		if (wl1271_ps_elp_wakeup(wl) == 0) {
			wl1271_cmd_build_ap_probe_req(wl, wl->probereq);
			wl1271_ps_elp_sleep(wl);
		}
	}

	if (wl->scan.failed) {
		wl1271_info("Scan completed due to error.");
		wl12xx_queue_recovery_work(wl);
	}

out:
	mutex_unlock(&wl->mutex);

}


static int wl1271_get_scan_channels(struct wl1271 *wl,
				    struct cfg80211_scan_request *req,
				    struct basic_scan_channel_params *channels,
				    enum ieee80211_band band, bool passive)
{
	struct conf_scan_settings *c = &wl->conf.scan;
	int i, j;
	u32 flags;

	for (i = 0, j = 0;
	     i < req->n_channels && j < WL1271_SCAN_MAX_CHANNELS;
	     i++) {

		flags = req->channels[i]->flags;

		if (!test_bit(i, wl->scan.scanned_ch) &&
		    !(flags & IEEE80211_CHAN_DISABLED) &&
		    ((!!(flags & IEEE80211_CHAN_PASSIVE_SCAN)) == passive) &&
		    (req->channels[i]->band == band)) {

			wl1271_debug(DEBUG_SCAN, "band %d, center_freq %d ",
				     req->channels[i]->band,
				     req->channels[i]->center_freq);
			wl1271_debug(DEBUG_SCAN, "hw_value %d, flags %X",
				     req->channels[i]->hw_value,
				     req->channels[i]->flags);
			wl1271_debug(DEBUG_SCAN,
				     "max_antenna_gain %d, max_power %d",
				     req->channels[i]->max_antenna_gain,
				     req->channels[i]->max_power);
			wl1271_debug(DEBUG_SCAN, "beacon_found %d",
				     req->channels[i]->beacon_found);

			if (!passive) {
				channels[j].min_duration =
					cpu_to_le32(c->min_dwell_time_active);
				channels[j].max_duration =
					cpu_to_le32(c->max_dwell_time_active);
			} else {
				channels[j].min_duration =
					cpu_to_le32(c->min_dwell_time_passive);
				channels[j].max_duration =
					cpu_to_le32(c->max_dwell_time_passive);
			}
			channels[j].early_termination = 0;
			channels[j].tx_power_att = req->channels[i]->max_power;
			channels[j].channel = req->channels[i]->hw_value;

			memset(&channels[j].bssid_lsb, 0xff, 4);
			memset(&channels[j].bssid_msb, 0xff, 2);

			/* Mark the channels we already used */
			set_bit(i, wl->scan.scanned_ch);

			j++;
		}
	}

	return j;
}

#define WL1271_NOTHING_TO_SCAN 1

static int wl1271_scan_send(struct wl1271 *wl, enum ieee80211_band band,
			     bool passive, u32 basic_rate)
{
	struct wl1271_cmd_scan *cmd;
	struct wl1271_cmd_trigger_scan_to *trigger;
	int ret;
	u16 scan_options = 0;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	trigger = kzalloc(sizeof(*trigger), GFP_KERNEL);
	if (!cmd || !trigger) {
		ret = -ENOMEM;
		goto out;
	}

	/* We always use high priority scans */
	scan_options = WL1271_SCAN_OPT_PRIORITY_HIGH;

	/* No SSIDs means that we have a forced passive scan */
	if (passive || wl->scan.req->n_ssids == 0)
		scan_options |= WL1271_SCAN_OPT_PASSIVE;

	cmd->params.scan_options = cpu_to_le16(scan_options);

	cmd->params.n_ch = wl1271_get_scan_channels(wl, wl->scan.req,
						    cmd->channels,
						    band, passive);
	if (cmd->params.n_ch == 0) {
		ret = WL1271_NOTHING_TO_SCAN;
		goto out;
	}

	cmd->params.tx_rate = cpu_to_le32(basic_rate);
	cmd->params.rx_config_options = cpu_to_le32(CFG_RX_ALL_GOOD);
	cmd->params.rx_filter_options =
		cpu_to_le32(CFG_RX_PRSP_EN | CFG_RX_MGMT_EN | CFG_RX_BCN_EN);

	cmd->params.n_probe_reqs = wl->conf.scan.num_probe_reqs;
	cmd->params.tx_rate = cpu_to_le32(basic_rate);
	cmd->params.tid_trigger = 0;
	cmd->params.scan_tag = WL1271_SCAN_DEFAULT_TAG;

	if (band == IEEE80211_BAND_2GHZ)
		cmd->params.band = WL1271_SCAN_BAND_2_4_GHZ;
	else
		cmd->params.band = WL1271_SCAN_BAND_5_GHZ;

	if (wl->scan.ssid_len && wl->scan.ssid) {
		cmd->params.ssid_len = wl->scan.ssid_len;
		memcpy(cmd->params.ssid, wl->scan.ssid, wl->scan.ssid_len);
	}

	ret = wl1271_cmd_build_probe_req(wl, wl->scan.ssid, wl->scan.ssid_len,
					 wl->scan.req->ie, wl->scan.req->ie_len,
					 band);
	if (ret < 0) {
		wl1271_error("PROBE request template failed");
		goto out;
	}

	/* disable the timeout */
	trigger->timeout = 0;
	ret = wl1271_cmd_send(wl, CMD_TRIGGER_SCAN_TO, trigger,
			      sizeof(*trigger), 0);
	if (ret < 0) {
		wl1271_error("trigger scan to failed for hw scan");
		goto out;
	}

	wl1271_dump(DEBUG_SCAN, "SCAN: ", cmd, sizeof(*cmd));

	ret = wl1271_cmd_send(wl, CMD_SCAN, cmd, sizeof(*cmd), 0);
	if (ret < 0) {
		wl1271_error("SCAN failed");
		goto out;
	}

out:
	kfree(cmd);
	kfree(trigger);
	return ret;
}

void wl1271_scan_stm(struct wl1271 *wl)
{
	int ret = 0;

	switch (wl->scan.state) {
	case WL1271_SCAN_STATE_IDLE:
		break;

	case WL1271_SCAN_STATE_2GHZ_ACTIVE:
		ret = wl1271_scan_send(wl, IEEE80211_BAND_2GHZ, false,
				       wl->conf.tx.basic_rate);
		if (ret == WL1271_NOTHING_TO_SCAN) {
			wl->scan.state = WL1271_SCAN_STATE_2GHZ_PASSIVE;
			wl1271_scan_stm(wl);
		}

		break;

	case WL1271_SCAN_STATE_2GHZ_PASSIVE:
		ret = wl1271_scan_send(wl, IEEE80211_BAND_2GHZ, true,
				       wl->conf.tx.basic_rate);
		if (ret == WL1271_NOTHING_TO_SCAN) {
			if (wl->enable_11a)
				wl->scan.state = WL1271_SCAN_STATE_5GHZ_ACTIVE;
			else
				wl->scan.state = WL1271_SCAN_STATE_DONE;
			wl1271_scan_stm(wl);
		}

		break;

	case WL1271_SCAN_STATE_5GHZ_ACTIVE:
		ret = wl1271_scan_send(wl, IEEE80211_BAND_5GHZ, false,
				       wl->conf.tx.basic_rate_5);
		if (ret == WL1271_NOTHING_TO_SCAN) {
			wl->scan.state = WL1271_SCAN_STATE_5GHZ_PASSIVE;
			wl1271_scan_stm(wl);
		}

		break;

	case WL1271_SCAN_STATE_5GHZ_PASSIVE:
		ret = wl1271_scan_send(wl, IEEE80211_BAND_5GHZ, true,
				       wl->conf.tx.basic_rate_5);
		if (ret == WL1271_NOTHING_TO_SCAN) {
			wl->scan.state = WL1271_SCAN_STATE_DONE;
			wl1271_scan_stm(wl);
		}

		break;

	case WL1271_SCAN_STATE_DONE:
		wl->scan.failed = false;
		cancel_delayed_work(&wl->scan_complete_work);
		ieee80211_queue_delayed_work(wl->hw, &wl->scan_complete_work,
					     msecs_to_jiffies(0));
		break;

	default:
		wl1271_error("invalid scan state");
		break;
	}

	if (ret < 0) {
		cancel_delayed_work(&wl->scan_complete_work);
		ieee80211_queue_delayed_work(wl->hw, &wl->scan_complete_work,
					     msecs_to_jiffies(0));
	}
}

int wl1271_scan(struct wl1271 *wl, const u8 *ssid, size_t ssid_len,
		struct cfg80211_scan_request *req)
{
	/*
	 * cfg80211 should guarantee that we don't get more channels
	 * than what we have registered.
	 */
	BUG_ON(req->n_channels > WL1271_MAX_CHANNELS);

	if (wl->scan.state != WL1271_SCAN_STATE_IDLE)
		return -EBUSY;

	wl->scan.state = WL1271_SCAN_STATE_2GHZ_ACTIVE;

	if (ssid_len && ssid) {
		wl->scan.ssid_len = ssid_len;
		memcpy(wl->scan.ssid, ssid, ssid_len);
	} else {
		wl->scan.ssid_len = 0;
	}

	wl->scan.req = req;
	memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));

	/* we assume failure so that timeout scenarios are handled correctly */
	wl->scan.failed = true;
	ieee80211_queue_delayed_work(wl->hw, &wl->scan_complete_work,
				     msecs_to_jiffies(WL1271_SCAN_TIMEOUT));

	wl1271_scan_stm(wl);

	return 0;
}

static int
wl1271_scan_get_sched_scan_channels(struct wl1271 *wl,
				    struct cfg80211_sched_scan_request *req,
				    struct conn_scan_ch_params *channels,
				    u32 band, bool radar, bool passive,
				    int start, int max_channels)
{
	struct conf_sched_scan_settings *c = &wl->conf.sched_scan;
	int i, j;
	u32 flags;
	bool force_passive = !req->n_ssids;

	for (i = 0, j = start;
	     i < req->n_channels && j < max_channels;
	     i++) {
		flags = req->channels[i]->flags;

		if (force_passive)
			flags |= IEEE80211_CHAN_PASSIVE_SCAN;

		if ((req->channels[i]->band == band) &&
		    !(flags & IEEE80211_CHAN_DISABLED) &&
		    (!!(flags & IEEE80211_CHAN_RADAR) == radar) &&
		    /* if radar is set, we ignore the passive flag */
		    (radar ||
		     !!(flags & IEEE80211_CHAN_PASSIVE_SCAN) == passive)) {
			wl1271_debug(DEBUG_SCAN, "band %d, center_freq %d ",
				     req->channels[i]->band,
				     req->channels[i]->center_freq);
			wl1271_debug(DEBUG_SCAN, "hw_value %d, flags %X",
				     req->channels[i]->hw_value,
				     req->channels[i]->flags);
			wl1271_debug(DEBUG_SCAN, "max_power %d",
				     req->channels[i]->max_power);

			if (flags & IEEE80211_CHAN_RADAR) {
				channels[j].flags |= SCAN_CHANNEL_FLAGS_DFS;
				channels[j].passive_duration =
					cpu_to_le16(c->dwell_time_dfs);
			}
			else if (flags & IEEE80211_CHAN_PASSIVE_SCAN) {
				channels[j].passive_duration =
					cpu_to_le16(c->dwell_time_passive);
			} else {
				channels[j].min_duration =
					cpu_to_le16(c->min_dwell_time_active);
				channels[j].max_duration =
					cpu_to_le16(c->max_dwell_time_active);
			}
			channels[j].tx_power_att = req->channels[i]->max_power;
			channels[j].channel = req->channels[i]->hw_value;

			j++;
		}
	}

	return j - start;
}

static bool
wl1271_scan_sched_scan_channels(struct wl1271 *wl,
				struct cfg80211_sched_scan_request *req,
				struct wl1271_cmd_sched_scan_config *cfg)
{
	cfg->passive[0] =
		wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels_2,
						    IEEE80211_BAND_2GHZ,
						    false, true, 0,
						    MAX_CHANNELS_2GHZ);
	cfg->active[0] =
		wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels_2,
						    IEEE80211_BAND_2GHZ,
						    false, false,
						    cfg->passive[0],
						    MAX_CHANNELS_2GHZ);
	cfg->passive[1] =
		wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels_5,
						    IEEE80211_BAND_5GHZ,
						    false, true, 0,
						    MAX_CHANNELS_5GHZ);
	cfg->dfs =
		wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels_5,
						    IEEE80211_BAND_5GHZ,
						    true, true,
						    cfg->passive[1],
						    MAX_CHANNELS_5GHZ);
	cfg->active[1] =
		wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels_5,
						    IEEE80211_BAND_5GHZ,
						    false, false,
						    cfg->passive[1] + cfg->dfs,
						    MAX_CHANNELS_5GHZ);
	/* 802.11j channels are not supported yet */
	cfg->passive[2] = 0;
	cfg->active[2] = 0;

	wl1271_debug(DEBUG_SCAN, "    2.4GHz: active %d passive %d",
		     cfg->active[0], cfg->passive[0]);
	wl1271_debug(DEBUG_SCAN, "    5GHz: active %d passive %d",
		     cfg->active[1], cfg->passive[1]);
	wl1271_debug(DEBUG_SCAN, "    DFS: %d", cfg->dfs);

	return  cfg->passive[0] || cfg->active[0] ||
		cfg->passive[1] || cfg->active[1] || cfg->dfs ||
		cfg->passive[2] || cfg->active[2];
}

int wl1271_scan_sched_scan_config(struct wl1271 *wl,
				  struct cfg80211_sched_scan_request *req,
				  struct ieee80211_sched_scan_ies *ies)
{
	struct wl1271_cmd_sched_scan_config *cfg = NULL;
	struct conf_sched_scan_settings *c = &wl->conf.sched_scan;
	int i, ret;
	bool force_passive = !req->n_ssids;

	wl1271_debug(DEBUG_CMD, "cmd sched_scan scan config");

	cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
	if (!cfg)
		return -ENOMEM;

	cfg->rssi_threshold = c->rssi_threshold;
	cfg->snr_threshold  = c->snr_threshold;
	cfg->n_probe_reqs = c->num_probe_reqs;
	/* cycles set to 0 it means infinite (until manually stopped) */
	cfg->cycles = 0;
	/* report APs when at least 1 is found */
	cfg->report_after = 1;
	/* don't stop scanning automatically when something is found */
	cfg->terminate = 0;
	cfg->tag = WL1271_SCAN_DEFAULT_TAG;
	/* don't filter on BSS type */
	cfg->bss_type = SCAN_BSS_TYPE_ANY;
	/* currently NL80211 supports only a single interval */
	for (i = 0; i < SCAN_MAX_CYCLE_INTERVALS; i++)
		cfg->intervals[i] = cpu_to_le32(req->interval);

	if (!force_passive && req->ssids[0].ssid_len && req->ssids[0].ssid) {
		cfg->filter_type = SCAN_SSID_FILTER_SPECIFIC;
		cfg->ssid_len = req->ssids[0].ssid_len;
		memcpy(cfg->ssid, req->ssids[0].ssid,
		       req->ssids[0].ssid_len);
	} else {
		cfg->filter_type = SCAN_SSID_FILTER_ANY;
		cfg->ssid_len = 0;
	}

	if (!wl1271_scan_sched_scan_channels(wl, req, cfg)) {
		wl1271_error("scan channel list is empty");
		ret = -EINVAL;
		goto out;
	}

	if (!force_passive && cfg->active[0]) {
		ret = wl1271_cmd_build_probe_req(wl, req->ssids[0].ssid,
						 req->ssids[0].ssid_len,
						 ies->ie[IEEE80211_BAND_2GHZ],
						 ies->len[IEEE80211_BAND_2GHZ],
						 IEEE80211_BAND_2GHZ);
		if (ret < 0) {
			wl1271_error("2.4GHz PROBE request template failed");
			goto out;
		}
	}

	if (!force_passive && cfg->active[1]) {
		ret = wl1271_cmd_build_probe_req(wl,  req->ssids[0].ssid,
						 req->ssids[0].ssid_len,
						 ies->ie[IEEE80211_BAND_5GHZ],
						 ies->len[IEEE80211_BAND_5GHZ],
						 IEEE80211_BAND_5GHZ);
		if (ret < 0) {
			wl1271_error("5GHz PROBE request template failed");
			goto out;
		}
	}

	wl1271_dump(DEBUG_SCAN, "SCAN_CFG: ", cfg, sizeof(*cfg));

	ret = wl1271_cmd_send(wl, CMD_CONNECTION_SCAN_CFG, cfg,
			      sizeof(*cfg), 0);
	if (ret < 0) {
		wl1271_error("SCAN configuration failed");
		goto out;
	}
out:
	kfree(cfg);
	return ret;
}

int wl1271_scan_sched_scan_start(struct wl1271 *wl)
{
	struct wl1271_cmd_sched_scan_start *start;
	int ret = 0;

	wl1271_debug(DEBUG_CMD, "cmd periodic scan start");

	if (wl->bss_type != BSS_TYPE_STA_BSS)
		return -EOPNOTSUPP;

	if (!test_bit(WL1271_FLAG_IDLE, &wl->flags))
		return -EBUSY;

	start = kzalloc(sizeof(*start), GFP_KERNEL);
	if (!start)
		return -ENOMEM;

	start->tag = WL1271_SCAN_DEFAULT_TAG;

	ret = wl1271_cmd_send(wl, CMD_START_PERIODIC_SCAN, start,
			      sizeof(*start), 0);
	if (ret < 0) {
		wl1271_error("failed to send scan start command");
		goto out_free;
	}

out_free:
	kfree(start);
	return ret;
}

void wl1271_scan_sched_scan_results(struct wl1271 *wl)
{
	wl1271_debug(DEBUG_SCAN, "got periodic scan results");

	ieee80211_sched_scan_results(wl->hw);
}

void wl1271_scan_sched_scan_stop(struct wl1271 *wl)
{
	struct wl1271_cmd_sched_scan_stop *stop;
	int ret = 0;

	wl1271_debug(DEBUG_CMD, "cmd periodic scan stop");

	/* FIXME: what to do if alloc'ing to stop fails? */
	stop = kzalloc(sizeof(*stop), GFP_KERNEL);
	if (!stop) {
		wl1271_error("failed to alloc memory to send sched scan stop");
		return;
	}

	stop->tag = WL1271_SCAN_DEFAULT_TAG;

	ret = wl1271_cmd_send(wl, CMD_STOP_PERIODIC_SCAN, stop,
			      sizeof(*stop), 0);
	if (ret < 0) {
		wl1271_error("failed to send sched scan stop command");
		goto out_free;
	}
	wl->sched_scanning = false;

out_free:
	kfree(stop);
}
Commit	Line	Data
34dd2aaa LC	1	/*
	2	* This file is part of wl1271
	3	*
	4	* Copyright (C) 2009-2010 Nokia Corporation
	5	*
	6	* Contact: Luciano Coelho <luciano.coelho@nokia.com>
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License
	10	* version 2 as published by the Free Software Foundation.
	11	*
	12	* This program is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
	20	* 02110-1301 USA
	21	*
	22	*/
	23
	24	#include <linux/ieee80211.h>
	25
00d20100 SL	26	#include "wl12xx.h"
	27	#include "cmd.h"
	28	#include "scan.h"
	29	#include "acx.h"
24225b37	30	#include "ps.h"
34dd2aaa	31
c454f1d9 JO	32	void wl1271_scan_complete_work(struct work_struct *work)
c454f1d9 JO	33	{
78abd320 JO	34	struct delayed_work *dwork;
	35	struct wl1271 *wl;
	36
	37	dwork = container_of(work, struct delayed_work, work);
	38	wl = container_of(dwork, struct wl1271, scan_complete_work);
c454f1d9 JO	39
	40	wl1271_debug(DEBUG_SCAN, "Scanning complete");
	41
	42	mutex_lock(&wl->mutex);
52a2a375	43
24225b37 AN	44	if (wl->state == WL1271_STATE_OFF)
	45	goto out;
	46
	47	if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
	48	goto out;
52a2a375	49
c454f1d9	50	wl->scan.state = WL1271_SCAN_STATE_IDLE;
4a31c11c	51	memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
b739a42c	52	wl->scan.req = NULL;
c454f1d9	53	ieee80211_scan_completed(wl->hw, false);
78abd320	54
2f6724b2	55	/* restore hardware connection monitoring template */
24225b37 AN	56	if (test_bit(WL1271_FLAG_STA_ASSOCIATED, &wl->flags)) {
	57	if (wl1271_ps_elp_wakeup(wl) == 0) {
	58	wl1271_cmd_build_ap_probe_req(wl, wl->probereq);
	59	wl1271_ps_elp_sleep(wl);
	60	}
	61	}
2f6724b2	62
78abd320 JO	63	if (wl->scan.failed) {
78abd320 JO	64	wl1271_info("Scan completed due to error.");
baacb9ae	65	wl12xx_queue_recovery_work(wl);
78abd320	66	}
24225b37 AN	67
24225b37 AN	68	out:
b739a42c JO	69	mutex_unlock(&wl->mutex);
b739a42c JO	70
c454f1d9 JO	71	}
	72
	73
08688d6b LC	74	static int wl1271_get_scan_channels(struct wl1271 *wl,
	75	struct cfg80211_scan_request *req,
	76	struct basic_scan_channel_params *channels,
	77	enum ieee80211_band band, bool passive)
34dd2aaa	78	{
bea39d6a	79	struct conf_scan_settings *c = &wl->conf.scan;
08688d6b LC	80	int i, j;
08688d6b LC	81	u32 flags;
34dd2aaa	82
08688d6b LC	83	for (i = 0, j = 0;
	84	i < req->n_channels && j < WL1271_SCAN_MAX_CHANNELS;
	85	i++) {
34dd2aaa	86
08688d6b	87	flags = req->channels[i]->flags;
34dd2aaa	88
4a31c11c	89	if (!test_bit(i, wl->scan.scanned_ch) &&
08688d6b LC	90	!(flags & IEEE80211_CHAN_DISABLED) &&
	91	((!!(flags & IEEE80211_CHAN_PASSIVE_SCAN)) == passive) &&
	92	(req->channels[i]->band == band)) {
34dd2aaa	93
08688d6b LC	94	wl1271_debug(DEBUG_SCAN, "band %d, center_freq %d ",
	95	req->channels[i]->band,
	96	req->channels[i]->center_freq);
	97	wl1271_debug(DEBUG_SCAN, "hw_value %d, flags %X",
	98	req->channels[i]->hw_value,
	99	req->channels[i]->flags);
	100	wl1271_debug(DEBUG_SCAN,
	101	"max_antenna_gain %d, max_power %d",
	102	req->channels[i]->max_antenna_gain,
	103	req->channels[i]->max_power);
	104	wl1271_debug(DEBUG_SCAN, "beacon_found %d",
	105	req->channels[i]->beacon_found);
34dd2aaa	106
bea39d6a JO	107	if (!passive) {
	108	channels[j].min_duration =
	109	cpu_to_le32(c->min_dwell_time_active);
	110	channels[j].max_duration =
	111	cpu_to_le32(c->max_dwell_time_active);
	112	} else {
	113	channels[j].min_duration =
	114	cpu_to_le32(c->min_dwell_time_passive);
	115	channels[j].max_duration =
	116	cpu_to_le32(c->max_dwell_time_passive);
	117	}
08688d6b	118	channels[j].early_termination = 0;
3cc7b544	119	channels[j].tx_power_att = req->channels[i]->max_power;
08688d6b LC	120	channels[j].channel = req->channels[i]->hw_value;
	121
	122	memset(&channels[j].bssid_lsb, 0xff, 4);
	123	memset(&channels[j].bssid_msb, 0xff, 2);
	124
	125	/* Mark the channels we already used */
4a31c11c	126	set_bit(i, wl->scan.scanned_ch);
08688d6b	127
34dd2aaa LC	128	j++;
	129	}
	130	}
	131
08688d6b LC	132	return j;
08688d6b LC	133	}
34dd2aaa	134
08688d6b LC	135	#define WL1271_NOTHING_TO_SCAN 1
	136
	137	static int wl1271_scan_send(struct wl1271 *wl, enum ieee80211_band band,
	138	bool passive, u32 basic_rate)
	139	{
	140	struct wl1271_cmd_scan *cmd;
	141	struct wl1271_cmd_trigger_scan_to *trigger;
	142	int ret;
	143	u16 scan_options = 0;
	144
	145	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	146	trigger = kzalloc(sizeof(*trigger), GFP_KERNEL);
	147	if (!cmd \|\| !trigger) {
	148	ret = -ENOMEM;
	149	goto out;
34dd2aaa LC	150	}
34dd2aaa LC	151
08688d6b LC	152	/* We always use high priority scans */
08688d6b LC	153	scan_options = WL1271_SCAN_OPT_PRIORITY_HIGH;
4f35c025 LC	154
	155	/* No SSIDs means that we have a forced passive scan */
	156	if (passive \|\| wl->scan.req->n_ssids == 0)
08688d6b	157	scan_options \|= WL1271_SCAN_OPT_PASSIVE;
4f35c025	158
08688d6b LC	159	cmd->params.scan_options = cpu_to_le16(scan_options);
	160
	161	cmd->params.n_ch = wl1271_get_scan_channels(wl, wl->scan.req,
	162	cmd->channels,
	163	band, passive);
	164	if (cmd->params.n_ch == 0) {
	165	ret = WL1271_NOTHING_TO_SCAN;
34dd2aaa LC	166	goto out;
	167	}
	168
08688d6b LC	169	cmd->params.tx_rate = cpu_to_le32(basic_rate);
	170	cmd->params.rx_config_options = cpu_to_le32(CFG_RX_ALL_GOOD);
	171	cmd->params.rx_filter_options =
	172	cpu_to_le32(CFG_RX_PRSP_EN \| CFG_RX_MGMT_EN \| CFG_RX_BCN_EN);
	173
bea39d6a	174	cmd->params.n_probe_reqs = wl->conf.scan.num_probe_reqs;
08688d6b LC	175	cmd->params.tx_rate = cpu_to_le32(basic_rate);
	176	cmd->params.tid_trigger = 0;
	177	cmd->params.scan_tag = WL1271_SCAN_DEFAULT_TAG;
	178
	179	if (band == IEEE80211_BAND_2GHZ)
	180	cmd->params.band = WL1271_SCAN_BAND_2_4_GHZ;
	181	else
	182	cmd->params.band = WL1271_SCAN_BAND_5_GHZ;
	183
	184	if (wl->scan.ssid_len && wl->scan.ssid) {
	185	cmd->params.ssid_len = wl->scan.ssid_len;
	186	memcpy(cmd->params.ssid, wl->scan.ssid, wl->scan.ssid_len);
	187	}
	188
	189	ret = wl1271_cmd_build_probe_req(wl, wl->scan.ssid, wl->scan.ssid_len,
	190	wl->scan.req->ie, wl->scan.req->ie_len,
	191	band);
	192	if (ret < 0) {
	193	wl1271_error("PROBE request template failed");
34dd2aaa LC	194	goto out;
	195	}
	196
	197	/* disable the timeout */
	198	trigger->timeout = 0;
34dd2aaa LC	199	ret = wl1271_cmd_send(wl, CMD_TRIGGER_SCAN_TO, trigger,
	200	sizeof(*trigger), 0);
	201	if (ret < 0) {
	202	wl1271_error("trigger scan to failed for hw scan");
	203	goto out;
	204	}
	205
08688d6b	206	wl1271_dump(DEBUG_SCAN, "SCAN: ", cmd, sizeof(*cmd));
34dd2aaa	207
08688d6b	208	ret = wl1271_cmd_send(wl, CMD_SCAN, cmd, sizeof(*cmd), 0);
34dd2aaa LC	209	if (ret < 0) {
34dd2aaa LC	210	wl1271_error("SCAN failed");
34dd2aaa LC	211	goto out;
	212	}
	213
	214	out:
08688d6b	215	kfree(cmd);
34dd2aaa LC	216	kfree(trigger);
	217	return ret;
	218	}
	219
08688d6b	220	void wl1271_scan_stm(struct wl1271 *wl)
34dd2aaa	221	{
78abd320	222	int ret = 0;
08688d6b LC	223
	224	switch (wl->scan.state) {
	225	case WL1271_SCAN_STATE_IDLE:
	226	break;
	227
	228	case WL1271_SCAN_STATE_2GHZ_ACTIVE:
	229	ret = wl1271_scan_send(wl, IEEE80211_BAND_2GHZ, false,
	230	wl->conf.tx.basic_rate);
	231	if (ret == WL1271_NOTHING_TO_SCAN) {
	232	wl->scan.state = WL1271_SCAN_STATE_2GHZ_PASSIVE;
	233	wl1271_scan_stm(wl);
	234	}
	235
	236	break;
	237
	238	case WL1271_SCAN_STATE_2GHZ_PASSIVE:
	239	ret = wl1271_scan_send(wl, IEEE80211_BAND_2GHZ, true,
	240	wl->conf.tx.basic_rate);
	241	if (ret == WL1271_NOTHING_TO_SCAN) {
02fabb0e	242	if (wl->enable_11a)
08688d6b LC	243	wl->scan.state = WL1271_SCAN_STATE_5GHZ_ACTIVE;
	244	else
	245	wl->scan.state = WL1271_SCAN_STATE_DONE;
	246	wl1271_scan_stm(wl);
34dd2aaa	247	}
08688d6b LC	248
	249	break;
	250
	251	case WL1271_SCAN_STATE_5GHZ_ACTIVE:
	252	ret = wl1271_scan_send(wl, IEEE80211_BAND_5GHZ, false,
	253	wl->conf.tx.basic_rate_5);
	254	if (ret == WL1271_NOTHING_TO_SCAN) {
	255	wl->scan.state = WL1271_SCAN_STATE_5GHZ_PASSIVE;
	256	wl1271_scan_stm(wl);
	257	}
	258
	259	break;
	260
	261	case WL1271_SCAN_STATE_5GHZ_PASSIVE:
	262	ret = wl1271_scan_send(wl, IEEE80211_BAND_5GHZ, true,
	263	wl->conf.tx.basic_rate_5);
	264	if (ret == WL1271_NOTHING_TO_SCAN) {
	265	wl->scan.state = WL1271_SCAN_STATE_DONE;
	266	wl1271_scan_stm(wl);
	267	}
	268
	269	break;
	270
	271	case WL1271_SCAN_STATE_DONE:
78abd320 JO	272	wl->scan.failed = false;
	273	cancel_delayed_work(&wl->scan_complete_work);
	274	ieee80211_queue_delayed_work(wl->hw, &wl->scan_complete_work,
	275	msecs_to_jiffies(0));
08688d6b LC	276	break;
	277
	278	default:
	279	wl1271_error("invalid scan state");
	280	break;
34dd2aaa	281	}
78abd320 JO	282
	283	if (ret < 0) {
	284	cancel_delayed_work(&wl->scan_complete_work);
	285	ieee80211_queue_delayed_work(wl->hw, &wl->scan_complete_work,
	286	msecs_to_jiffies(0));
	287	}
08688d6b LC	288	}
	289
	290	int wl1271_scan(struct wl1271 wl, const u8 ssid, size_t ssid_len,
	291	struct cfg80211_scan_request *req)
	292	{
4a31c11c LC	293	/*
	294	* cfg80211 should guarantee that we don't get more channels
	295	* than what we have registered.
	296	*/
	297	BUG_ON(req->n_channels > WL1271_MAX_CHANNELS);
	298
08688d6b LC	299	if (wl->scan.state != WL1271_SCAN_STATE_IDLE)
	300	return -EBUSY;
	301
	302	wl->scan.state = WL1271_SCAN_STATE_2GHZ_ACTIVE;
	303
	304	if (ssid_len && ssid) {
	305	wl->scan.ssid_len = ssid_len;
	306	memcpy(wl->scan.ssid, ssid, ssid_len);
	307	} else {
	308	wl->scan.ssid_len = 0;
	309	}
	310
	311	wl->scan.req = req;
4a31c11c	312	memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
08688d6b	313
78abd320 JO	314	/* we assume failure so that timeout scenarios are handled correctly */
	315	wl->scan.failed = true;
	316	ieee80211_queue_delayed_work(wl->hw, &wl->scan_complete_work,
	317	msecs_to_jiffies(WL1271_SCAN_TIMEOUT));
	318
08688d6b LC	319	wl1271_scan_stm(wl);
08688d6b LC	320
34dd2aaa LC	321	return 0;
34dd2aaa LC	322	}
95feadca LC	323
	324	static int
	325	wl1271_scan_get_sched_scan_channels(struct wl1271 *wl,
	326	struct cfg80211_sched_scan_request *req,
	327	struct conn_scan_ch_params *channels,
	328	u32 band, bool radar, bool passive,
d2c2bb9f	329	int start, int max_channels)
95feadca LC	330	{
	331	struct conf_sched_scan_settings *c = &wl->conf.sched_scan;
	332	int i, j;
	333	u32 flags;
66870b1c	334	bool force_passive = !req->n_ssids;
95feadca LC	335
95feadca LC	336	for (i = 0, j = start;
d2c2bb9f	337	i < req->n_channels && j < max_channels;
95feadca LC	338	i++) {
	339	flags = req->channels[i]->flags;
	340
66870b1c LC	341	if (force_passive)
	342	flags \|= IEEE80211_CHAN_PASSIVE_SCAN;
	343
2497a246 LC	344	if ((req->channels[i]->band == band) &&
2497a246 LC	345	!(flags & IEEE80211_CHAN_DISABLED) &&
dd086821	346	(!!(flags & IEEE80211_CHAN_RADAR) == radar) &&
2497a246 LC	347	/* if radar is set, we ignore the passive flag */
	348	(radar \|\|
	349	!!(flags & IEEE80211_CHAN_PASSIVE_SCAN) == passive)) {
95feadca LC	350	wl1271_debug(DEBUG_SCAN, "band %d, center_freq %d ",
	351	req->channels[i]->band,
	352	req->channels[i]->center_freq);
	353	wl1271_debug(DEBUG_SCAN, "hw_value %d, flags %X",
	354	req->channels[i]->hw_value,
	355	req->channels[i]->flags);
	356	wl1271_debug(DEBUG_SCAN, "max_power %d",
	357	req->channels[i]->max_power);
	358
50a66d7f	359	if (flags & IEEE80211_CHAN_RADAR) {
2497a246	360	channels[j].flags \|= SCAN_CHANNEL_FLAGS_DFS;
50a66d7f LC	361	channels[j].passive_duration =
	362	cpu_to_le16(c->dwell_time_dfs);
	363	}
	364	else if (flags & IEEE80211_CHAN_PASSIVE_SCAN) {
95feadca LC	365	channels[j].passive_duration =
	366	cpu_to_le16(c->dwell_time_passive);
	367	} else {
	368	channels[j].min_duration =
	369	cpu_to_le16(c->min_dwell_time_active);
	370	channels[j].max_duration =
	371	cpu_to_le16(c->max_dwell_time_active);
	372	}
2497a246	373	channels[j].tx_power_att = req->channels[i]->max_power;
95feadca LC	374	channels[j].channel = req->channels[i]->hw_value;
	375
	376	j++;
	377	}
	378	}
	379
	380	return j - start;
	381	}
	382
d2c2bb9f	383	static bool
95feadca LC	384	wl1271_scan_sched_scan_channels(struct wl1271 *wl,
	385	struct cfg80211_sched_scan_request *req,
	386	struct wl1271_cmd_sched_scan_config *cfg)
	387	{
95feadca	388	cfg->passive[0] =
d2c2bb9f	389	wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels_2,
95feadca	390	IEEE80211_BAND_2GHZ,
d2c2bb9f LC	391	false, true, 0,
d2c2bb9f LC	392	MAX_CHANNELS_2GHZ);
95feadca	393	cfg->active[0] =
d2c2bb9f	394	wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels_2,
95feadca	395	IEEE80211_BAND_2GHZ,
d2c2bb9f LC	396	false, false,
	397	cfg->passive[0],
	398	MAX_CHANNELS_2GHZ);
95feadca	399	cfg->passive[1] =
d2c2bb9f	400	wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels_5,
95feadca	401	IEEE80211_BAND_5GHZ,
d2c2bb9f LC	402	false, true, 0,
d2c2bb9f LC	403	MAX_CHANNELS_5GHZ);
2497a246	404	cfg->dfs =
d2c2bb9f	405	wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels_5,
95feadca	406	IEEE80211_BAND_5GHZ,
d2c2bb9f LC	407	true, true,
	408	cfg->passive[1],
	409	MAX_CHANNELS_5GHZ);
2497a246	410	cfg->active[1] =
d2c2bb9f	411	wl1271_scan_get_sched_scan_channels(wl, req, cfg->channels_5,
95feadca	412	IEEE80211_BAND_5GHZ,
d2c2bb9f LC	413	false, false,
	414	cfg->passive[1] + cfg->dfs,
	415	MAX_CHANNELS_5GHZ);
	416	/* 802.11j channels are not supported yet */
	417	cfg->passive[2] = 0;
	418	cfg->active[2] = 0;
95feadca LC	419
	420	wl1271_debug(DEBUG_SCAN, " 2.4GHz: active %d passive %d",
	421	cfg->active[0], cfg->passive[0]);
	422	wl1271_debug(DEBUG_SCAN, " 5GHz: active %d passive %d",
	423	cfg->active[1], cfg->passive[1]);
2497a246	424	wl1271_debug(DEBUG_SCAN, " DFS: %d", cfg->dfs);
95feadca	425
d2c2bb9f LC	426	return cfg->passive[0] \|\| cfg->active[0] \|\|
	427	cfg->passive[1] \|\| cfg->active[1] \|\| cfg->dfs \|\|
	428	cfg->passive[2] \|\| cfg->active[2];
95feadca LC	429	}
	430
	431	int wl1271_scan_sched_scan_config(struct wl1271 *wl,
	432	struct cfg80211_sched_scan_request *req,
	433	struct ieee80211_sched_scan_ies *ies)
	434	{
	435	struct wl1271_cmd_sched_scan_config *cfg = NULL;
	436	struct conf_sched_scan_settings *c = &wl->conf.sched_scan;
d2c2bb9f	437	int i, ret;
66870b1c	438	bool force_passive = !req->n_ssids;
95feadca LC	439
	440	wl1271_debug(DEBUG_CMD, "cmd sched_scan scan config");
	441
	442	cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
	443	if (!cfg)
	444	return -ENOMEM;
	445
	446	cfg->rssi_threshold = c->rssi_threshold;
	447	cfg->snr_threshold = c->snr_threshold;
	448	cfg->n_probe_reqs = c->num_probe_reqs;
	449	/* cycles set to 0 it means infinite (until manually stopped) */
	450	cfg->cycles = 0;
	451	/* report APs when at least 1 is found */
	452	cfg->report_after = 1;
	453	/* don't stop scanning automatically when something is found */
	454	cfg->terminate = 0;
	455	cfg->tag = WL1271_SCAN_DEFAULT_TAG;
	456	/* don't filter on BSS type */
	457	cfg->bss_type = SCAN_BSS_TYPE_ANY;
	458	/* currently NL80211 supports only a single interval */
	459	for (i = 0; i < SCAN_MAX_CYCLE_INTERVALS; i++)
	460	cfg->intervals[i] = cpu_to_le32(req->interval);
	461
66870b1c	462	if (!force_passive && req->ssids[0].ssid_len && req->ssids[0].ssid) {
95feadca LC	463	cfg->filter_type = SCAN_SSID_FILTER_SPECIFIC;
	464	cfg->ssid_len = req->ssids[0].ssid_len;
	465	memcpy(cfg->ssid, req->ssids[0].ssid,
	466	req->ssids[0].ssid_len);
	467	} else {
	468	cfg->filter_type = SCAN_SSID_FILTER_ANY;
	469	cfg->ssid_len = 0;
	470	}
	471
d2c2bb9f	472	if (!wl1271_scan_sched_scan_channels(wl, req, cfg)) {
95feadca LC	473	wl1271_error("scan channel list is empty");
	474	ret = -EINVAL;
	475	goto out;
	476	}
	477
66870b1c	478	if (!force_passive && cfg->active[0]) {
95feadca LC	479	ret = wl1271_cmd_build_probe_req(wl, req->ssids[0].ssid,
	480	req->ssids[0].ssid_len,
	481	ies->ie[IEEE80211_BAND_2GHZ],
	482	ies->len[IEEE80211_BAND_2GHZ],
	483	IEEE80211_BAND_2GHZ);
	484	if (ret < 0) {
	485	wl1271_error("2.4GHz PROBE request template failed");
	486	goto out;
	487	}
	488	}
	489
66870b1c	490	if (!force_passive && cfg->active[1]) {
95feadca LC	491	ret = wl1271_cmd_build_probe_req(wl, req->ssids[0].ssid,
	492	req->ssids[0].ssid_len,
	493	ies->ie[IEEE80211_BAND_5GHZ],
	494	ies->len[IEEE80211_BAND_5GHZ],
	495	IEEE80211_BAND_5GHZ);
	496	if (ret < 0) {
	497	wl1271_error("5GHz PROBE request template failed");
	498	goto out;
	499	}
	500	}
	501
	502	wl1271_dump(DEBUG_SCAN, "SCAN_CFG: ", cfg, sizeof(*cfg));
	503
	504	ret = wl1271_cmd_send(wl, CMD_CONNECTION_SCAN_CFG, cfg,
	505	sizeof(*cfg), 0);
	506	if (ret < 0) {
	507	wl1271_error("SCAN configuration failed");
	508	goto out;
	509	}
	510	out:
	511	kfree(cfg);
	512	return ret;
	513	}
	514
	515	int wl1271_scan_sched_scan_start(struct wl1271 *wl)
	516	{
	517	struct wl1271_cmd_sched_scan_start *start;
	518	int ret = 0;
	519
	520	wl1271_debug(DEBUG_CMD, "cmd periodic scan start");
	521
683c0024 LC	522	if (wl->bss_type != BSS_TYPE_STA_BSS)
	523	return -EOPNOTSUPP;
	524
	525	if (!test_bit(WL1271_FLAG_IDLE, &wl->flags))
	526	return -EBUSY;
	527
95feadca LC	528	start = kzalloc(sizeof(*start), GFP_KERNEL);
	529	if (!start)
	530	return -ENOMEM;
	531
	532	start->tag = WL1271_SCAN_DEFAULT_TAG;
	533
	534	ret = wl1271_cmd_send(wl, CMD_START_PERIODIC_SCAN, start,
	535	sizeof(*start), 0);
	536	if (ret < 0) {
	537	wl1271_error("failed to send scan start command");
	538	goto out_free;
	539	}
	540
	541	out_free:
	542	kfree(start);
	543	return ret;
	544	}
	545
	546	void wl1271_scan_sched_scan_results(struct wl1271 *wl)
	547	{
	548	wl1271_debug(DEBUG_SCAN, "got periodic scan results");
	549
	550	ieee80211_sched_scan_results(wl->hw);
	551	}
	552
	553	void wl1271_scan_sched_scan_stop(struct wl1271 *wl)
	554	{
	555	struct wl1271_cmd_sched_scan_stop *stop;
	556	int ret = 0;
	557
	558	wl1271_debug(DEBUG_CMD, "cmd periodic scan stop");
	559
	560	/* FIXME: what to do if alloc'ing to stop fails? */
	561	stop = kzalloc(sizeof(*stop), GFP_KERNEL);
	562	if (!stop) {
	563	wl1271_error("failed to alloc memory to send sched scan stop");
	564	return;
	565	}
	566
	567	stop->tag = WL1271_SCAN_DEFAULT_TAG;
	568
	569	ret = wl1271_cmd_send(wl, CMD_STOP_PERIODIC_SCAN, stop,
	570	sizeof(*stop), 0);
33c2c06c	571	if (ret < 0) {
95feadca	572	wl1271_error("failed to send sched scan stop command");
33c2c06c LC	573	goto out_free;
	574	}
	575	wl->sched_scanning = false;
95feadca	576
33c2c06c	577	out_free:
95feadca LC	578	kfree(stop);
95feadca LC	579	}