staging: wfx: allow to scan networks (1a61af0f) · Commits · 戴 / test

drivers/staging/wfx/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -12,6 +12,7 @@ wfx-y := \
		queue.o \
		data_tx.o \
		data_rx.o \
		scan.o \
		sta.o \
		main.o \
		sta.o \

drivers/staging/wfx/bh.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -268,7 +268,7 @@ static void bh_work(struct work_struct *work)

		if (last_op_is_rx)
		ack_sdio_data(wdev);
		if (!wdev->hif.tx_buffers_used && !work_pending(work)) {
		if (!wdev->hif.tx_buffers_used && !work_pending(work) && !atomic_read(&wdev->scan_in_progress)) {
		device_release(wdev);
		release_chip = true;
		}

drivers/staging/wfx/hif_rx.c

+13 −0

Original line number	Diff line number	Diff line
		@@ -11,6 +11,7 @@

		#include "hif_rx.h"
		#include "wfx.h"
		#include "scan.h"
		#include "data_rx.h"
		#include "secure_link.h"
		#include "hif_api_cmd.h"
		@@ -143,6 +144,17 @@ static int hif_receive_indication(struct wfx_dev wdev, struct hif_msg hif, voi
		return 0;
		}

		static int hif_scan_complete_indication(struct wfx_dev wdev, struct hif_msg hif, void *buf)
		{
		struct wfx_vif *wvif = wdev_to_wvif(wdev, hif->interface);
		struct hif_ind_scan_cmpl *body = buf;

		WARN_ON(!wvif);
		wfx_scan_complete_cb(wvif, body);

		return 0;
		}

		static int hif_join_complete_indication(struct wfx_dev wdev, struct hif_msg hif, void *buf)
		{
		struct wfx_vif *wvif = wdev_to_wvif(wdev, hif->interface);
		@@ -230,6 +242,7 @@ static const struct {
		{ HIF_IND_ID_STARTUP, hif_startup_indication },
		{ HIF_IND_ID_WAKEUP, hif_wakeup_indication },
		{ HIF_IND_ID_JOIN_COMPLETE, hif_join_complete_indication },
		{ HIF_IND_ID_SCAN_CMPL, hif_scan_complete_indication },
		{ HIF_IND_ID_SL_EXCHANGE_PUB_KEYS, hif_keys_indication },
		{ HIF_IND_ID_GENERIC, hif_generic_indication },
		{ HIF_IND_ID_ERROR, hif_error_indication },

drivers/staging/wfx/main.c

+5 −0

Original line number	Diff line number	Diff line
		@@ -55,6 +55,7 @@ static const struct ieee80211_ops wfx_ops = {
		.add_interface = wfx_add_interface,
		.remove_interface = wfx_remove_interface,
		.tx = wfx_tx,
		.hw_scan = wfx_hw_scan,
		};

		bool wfx_api_older_than(struct wfx_dev *wdev, int major, int minor)
		@@ -203,6 +204,8 @@ struct wfx_dev wfx_init_common(struct device dev,
		hw->extra_tx_headroom = sizeof(struct hif_sl_msg_hdr) + sizeof(struct hif_msg)
		+ sizeof(struct hif_req_tx)
		+ 4 /* alignment / + 8 / TKIP IV */;
		hw->wiphy->max_scan_ssids = 2;
		hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;

		wdev = hw->priv;
		wdev->hw = hw;
		@@ -214,6 +217,7 @@ struct wfx_dev wfx_init_common(struct device dev,
		wdev->pdata.gpio_wakeup = wfx_get_gpio(dev, gpio_wakeup, "wakeup");
		wfx_fill_sl_key(dev, &wdev->pdata);

		mutex_init(&wdev->conf_mutex);
		mutex_init(&wdev->rx_stats_lock);
		init_completion(&wdev->firmware_ready);
		wfx_init_hif_cmd(&wdev->hif_cmd);
		@@ -225,6 +229,7 @@ struct wfx_dev wfx_init_common(struct device dev,
		void wfx_free_common(struct wfx_dev *wdev)
		{
		mutex_destroy(&wdev->rx_stats_lock);
		mutex_destroy(&wdev->conf_mutex);
		wfx_tx_queues_deinit(wdev);
		ieee80211_free_hw(wdev->hw);
		}

drivers/staging/wfx/scan.c

0 → 100644

+249 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-only
		/*
		* Scan related functions.
		*
		* Copyright (c) 2017-2019, Silicon Laboratories, Inc.
		* Copyright (c) 2010, ST-Ericsson
		*/
		#include <net/mac80211.h>

		#include "scan.h"
		#include "wfx.h"
		#include "sta.h"
		#include "hif_tx_mib.h"

		static void __ieee80211_scan_completed_compat(struct ieee80211_hw *hw, bool aborted)
		{
		struct cfg80211_scan_info info = {
		.aborted = aborted ? 1 : 0,
		};

		ieee80211_scan_completed(hw, &info);
		}

		static int wfx_scan_start(struct wfx_vif wvif, struct wfx_scan_params scan)
		{
		int ret;
		int tmo = 500;

		tmo += scan->scan_req.num_of_channels *
		((20 * (scan->scan_req.max_channel_time)) + 10);
		atomic_set(&wvif->scan.in_progress, 1);
		atomic_set(&wvif->wdev->scan_in_progress, 1);

		schedule_delayed_work(&wvif->scan.timeout, msecs_to_jiffies(tmo));
		ret = hif_scan(wvif, scan);
		if (ret) {
		wfx_scan_failed_cb(wvif);
		atomic_set(&wvif->scan.in_progress, 0);
		atomic_set(&wvif->wdev->scan_in_progress, 0);
		cancel_delayed_work_sync(&wvif->scan.timeout);
		}
		return ret;
		}

		int wfx_hw_scan(struct ieee80211_hw *hw,
		struct ieee80211_vif *vif,
		struct ieee80211_scan_request *hw_req)
		{
		struct wfx_dev *wdev = hw->priv;
		struct wfx_vif wvif = (struct wfx_vif ) vif->drv_priv;
		struct cfg80211_scan_request *req = &hw_req->req;
		struct sk_buff *skb;
		int i, ret;
		struct hif_mib_template_frame *p;

		if (!wvif)
		return -EINVAL;

		if (req->n_ssids == 1 && !req->ssids[0].ssid_len)
		req->n_ssids = 0;

		if (req->n_ssids > HIF_API_MAX_NB_SSIDS)
		return -EINVAL;

		skb = ieee80211_probereq_get(hw, wvif->vif->addr, NULL, 0, req->ie_len);
		if (!skb)
		return -ENOMEM;

		if (req->ie_len)
		memcpy(skb_put(skb, req->ie_len), req->ie, req->ie_len);

		mutex_lock(&wdev->conf_mutex);

		p = (struct hif_mib_template_frame *)skb_push(skb, 4);
		p->frame_type = HIF_TMPLT_PRBREQ;
		p->frame_length = cpu_to_le16(skb->len - 4);
		ret = hif_set_template_frame(wvif, p);
		skb_pull(skb, 4);

		if (!ret)
		/* Host want to be the probe responder. */
		ret = wfx_fwd_probe_req(wvif, true);
		if (ret) {
		mutex_unlock(&wdev->conf_mutex);
		dev_kfree_skb(skb);
		return ret;
		}

		wfx_tx_lock_flush(wdev);

		BUG_ON(wvif->scan.req);
		wvif->scan.req = req;
		wvif->scan.n_ssids = 0;
		wvif->scan.status = 0;
		wvif->scan.begin = &req->channels[0];
		wvif->scan.curr = wvif->scan.begin;
		wvif->scan.end = &req->channels[req->n_channels];
		wvif->scan.output_power = wdev->output_power;

		for (i = 0; i < req->n_ssids; ++i) {
		struct hif_ssid_def *dst = &wvif->scan.ssids[wvif->scan.n_ssids];

		memcpy(&dst->ssid[0], req->ssids[i].ssid, sizeof(dst->ssid));
		dst->ssid_length = req->ssids[i].ssid_len;
		++wvif->scan.n_ssids;
		}

		mutex_unlock(&wdev->conf_mutex);

		if (skb)
		dev_kfree_skb(skb);
		schedule_work(&wvif->scan.work);
		return 0;
		}

		void wfx_scan_work(struct work_struct *work)
		{
		struct wfx_vif *wvif = container_of(work, struct wfx_vif, scan.work);
		struct ieee80211_channel **it;
		struct wfx_scan_params scan = {
		.scan_req.scan_type.type = 0, /* Foreground */
		};
		struct ieee80211_channel *first;
		int i;

		down(&wvif->scan.lock);
		mutex_lock(&wvif->wdev->conf_mutex);

		if (!wvif->scan.req \|\| wvif->scan.curr == wvif->scan.end) {
		if (wvif->scan.output_power != wvif->wdev->output_power)
		hif_set_output_power(wvif, wvif->wdev->output_power * 10);

		if (wvif->scan.status < 0)
		dev_warn(wvif->wdev->dev, "scan failed\n");
		else if (wvif->scan.req)
		dev_dbg(wvif->wdev->dev, "scan completed\n");
		else
		dev_dbg(wvif->wdev->dev, "scan canceled\n");

		wvif->scan.req = NULL;
		wfx_tx_unlock(wvif->wdev);
		mutex_unlock(&wvif->wdev->conf_mutex);
		__ieee80211_scan_completed_compat(wvif->wdev->hw, wvif->scan.status ? 1 : 0);
		up(&wvif->scan.lock);
		return;
		}
		first = *wvif->scan.curr;

		for (it = wvif->scan.curr + 1, i = 1;
		it != wvif->scan.end && i < HIF_API_MAX_NB_CHANNELS;
		++it, ++i) {
		if ((*it)->band != first->band)
		break;
		if (((*it)->flags ^ first->flags) &
		IEEE80211_CHAN_NO_IR)
		break;
		if (!(first->flags & IEEE80211_CHAN_NO_IR) &&
		(*it)->max_power != first->max_power)
		break;
		}
		scan.scan_req.band = first->band;

		if (wvif->scan.req->no_cck)
		scan.scan_req.max_transmit_rate = API_RATE_INDEX_G_6MBPS;
		else
		scan.scan_req.max_transmit_rate = API_RATE_INDEX_B_1MBPS;
		scan.scan_req.num_of_probe_requests =
		(first->flags & IEEE80211_CHAN_NO_IR) ? 0 : 2;
		scan.scan_req.num_of_ssi_ds = wvif->scan.n_ssids;
		scan.ssids = &wvif->scan.ssids[0];
		scan.scan_req.num_of_channels = it - wvif->scan.curr;
		scan.scan_req.probe_delay = 100;

		scan.ch = kcalloc(scan.scan_req.num_of_channels, sizeof(u8), GFP_KERNEL);

		if (!scan.ch) {
		wvif->scan.status = -ENOMEM;
		goto fail;
		}
		for (i = 0; i < scan.scan_req.num_of_channels; ++i)
		scan.ch[i] = wvif->scan.curr[i]->hw_value;

		if (wvif->scan.curr[0]->flags & IEEE80211_CHAN_NO_IR) {
		scan.scan_req.min_channel_time = 50;
		scan.scan_req.max_channel_time = 150;
		} else {
		scan.scan_req.min_channel_time = 10;
		scan.scan_req.max_channel_time = 50;
		}
		if (!(first->flags & IEEE80211_CHAN_NO_IR) &&
		wvif->scan.output_power != first->max_power) {
		wvif->scan.output_power = first->max_power;
		hif_set_output_power(wvif, wvif->scan.output_power * 10);
		}
		wvif->scan.status = wfx_scan_start(wvif, &scan);
		kfree(scan.ch);
		if (wvif->scan.status)
		goto fail;
		wvif->scan.curr = it;
		mutex_unlock(&wvif->wdev->conf_mutex);
		return;

		fail:
		wvif->scan.curr = wvif->scan.end;
		mutex_unlock(&wvif->wdev->conf_mutex);
		up(&wvif->scan.lock);
		schedule_work(&wvif->scan.work);
		}

		static void wfx_scan_complete(struct wfx_vif *wvif)
		{
		up(&wvif->scan.lock);
		atomic_set(&wvif->wdev->scan_in_progress, 0);

		wfx_scan_work(&wvif->scan.work);
		}

		void wfx_scan_failed_cb(struct wfx_vif *wvif)
		{
		if (cancel_delayed_work_sync(&wvif->scan.timeout) > 0) {
		wvif->scan.status = -EIO;
		schedule_work(&wvif->scan.timeout.work);
		}
		}

		void wfx_scan_complete_cb(struct wfx_vif wvif, struct hif_ind_scan_cmpl arg)
		{
		if (cancel_delayed_work_sync(&wvif->scan.timeout) > 0) {
		wvif->scan.status = 1;
		schedule_work(&wvif->scan.timeout.work);
		}
		}

		void wfx_scan_timeout(struct work_struct *work)
		{
		struct wfx_vif *wvif = container_of(work, struct wfx_vif, scan.timeout.work);

		if (atomic_xchg(&wvif->scan.in_progress, 0)) {
		if (wvif->scan.status > 0) {
		wvif->scan.status = 0;
		} else if (!wvif->scan.status) {
		dev_warn(wvif->wdev->dev, "timeout waiting for scan complete notification\n");
		wvif->scan.status = -ETIMEDOUT;
		wvif->scan.curr = wvif->scan.end;
		hif_stop_scan(wvif);
		}
		wfx_scan_complete(wvif);
		}
		}

Admin message