From: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Date: Thu, 7 Apr 2022 17:40:39 +0000 (+0200)
Subject: Merge branch 'wfx-move-out-of-staging' of git://git.kernel.org/pub/scm/linux/kernel... 
X-Git-Url: http://git.maquefel.me/?a=commitdiff_plain;h=f8525b9763c61f54d1abdcce2821468dc416cda1;p=linux.git

Merge branch 'wfx-move-out-of-staging' of git://git./linux/kernel/git/wireless/wireless-next into staging-next

This moves the wfx driver out of staging.

* 'wfx-move-out-of-staging' of git://git.kernel.org/pub/scm/linux/kernel/git/wireless/wireless-next:
  wfx: get out from the staging area
---

f8525b9763c61f54d1abdcce2821468dc416cda1
diff --cc drivers/net/wireless/silabs/wfx/hif_tx.c
index 0000000000000,ae3cc5919dcd5..9c653d0e90347
mode 000000,100644..100644
--- a/drivers/net/wireless/silabs/wfx/hif_tx.c
+++ b/drivers/net/wireless/silabs/wfx/hif_tx.c
@@@ -1,0 -1,490 +1,490 @@@
+ // SPDX-License-Identifier: GPL-2.0-only
+ /*
+  * Implementation of the host-to-chip commands (aka request/confirmation) of the
+  * hardware API.
+  *
+  * Copyright (c) 2017-2020, Silicon Laboratories, Inc.
+  * Copyright (c) 2010, ST-Ericsson
+  */
+ #include <linux/etherdevice.h>
+ 
+ #include "hif_tx.h"
+ #include "wfx.h"
+ #include "bh.h"
+ #include "hwio.h"
+ #include "debug.h"
+ #include "sta.h"
+ 
+ void wfx_init_hif_cmd(struct wfx_hif_cmd *hif_cmd)
+ {
+ 	init_completion(&hif_cmd->ready);
+ 	init_completion(&hif_cmd->done);
+ 	mutex_init(&hif_cmd->lock);
+ }
+ 
+ static void wfx_fill_header(struct wfx_hif_msg *hif, int if_id, unsigned int cmd, size_t size)
+ {
+ 	if (if_id == -1)
+ 		if_id = 2;
+ 
+ 	WARN(cmd > 0x3f, "invalid hardware command %#.2x", cmd);
+ 	WARN(size > 0xFFF, "requested buffer is too large: %zu bytes", size);
+ 	WARN(if_id > 0x3, "invalid interface ID %d", if_id);
+ 
+ 	hif->len = cpu_to_le16(size + 4);
+ 	hif->id = cmd;
+ 	hif->interface = if_id;
+ }
+ 
+ static void *wfx_alloc_hif(size_t body_len, struct wfx_hif_msg **hif)
+ {
+ 	*hif = kzalloc(sizeof(struct wfx_hif_msg) + body_len, GFP_KERNEL);
+ 	if (*hif)
+ 		return (*hif)->body;
+ 	else
+ 		return NULL;
+ }
+ 
+ int wfx_cmd_send(struct wfx_dev *wdev, struct wfx_hif_msg *request,
+ 		 void *reply, size_t reply_len, bool no_reply)
+ {
+ 	const char *mib_name = "";
+ 	const char *mib_sep = "";
+ 	int cmd = request->id;
+ 	int vif = request->interface;
+ 	int ret;
+ 
+ 	/* Do not wait for any reply if chip is frozen */
+ 	if (wdev->chip_frozen)
+ 		return -ETIMEDOUT;
+ 
+ 	mutex_lock(&wdev->hif_cmd.lock);
+ 	WARN(wdev->hif_cmd.buf_send, "data locking error");
+ 
+ 	/* Note: call to complete() below has an implicit memory barrier that hopefully protect
+ 	 * buf_send
+ 	 */
+ 	wdev->hif_cmd.buf_send = request;
+ 	wdev->hif_cmd.buf_recv = reply;
+ 	wdev->hif_cmd.len_recv = reply_len;
+ 	complete(&wdev->hif_cmd.ready);
+ 
+ 	wfx_bh_request_tx(wdev);
+ 
+ 	if (no_reply) {
+ 		/* Chip won't reply. Ensure the wq has send the buffer before to continue. */
+ 		flush_workqueue(system_highpri_wq);
+ 		ret = 0;
+ 		goto end;
+ 	}
+ 
+ 	if (wdev->poll_irq)
+ 		wfx_bh_poll_irq(wdev);
+ 
+ 	ret = wait_for_completion_timeout(&wdev->hif_cmd.done, 1 * HZ);
+ 	if (!ret) {
+ 		dev_err(wdev->dev, "chip is abnormally long to answer\n");
+ 		reinit_completion(&wdev->hif_cmd.ready);
+ 		ret = wait_for_completion_timeout(&wdev->hif_cmd.done, 3 * HZ);
+ 	}
+ 	if (!ret) {
+ 		dev_err(wdev->dev, "chip did not answer\n");
+ 		wfx_pending_dump_old_frames(wdev, 3000);
+ 		wdev->chip_frozen = true;
+ 		reinit_completion(&wdev->hif_cmd.done);
+ 		ret = -ETIMEDOUT;
+ 	} else {
+ 		ret = wdev->hif_cmd.ret;
+ 	}
+ 
+ end:
+ 	wdev->hif_cmd.buf_send = NULL;
+ 	mutex_unlock(&wdev->hif_cmd.lock);
+ 
+ 	if (ret &&
+ 	    (cmd == HIF_REQ_ID_READ_MIB || cmd == HIF_REQ_ID_WRITE_MIB)) {
+ 		mib_name = wfx_get_mib_name(((u16 *)request)[2]);
+ 		mib_sep = "/";
+ 	}
+ 	if (ret < 0)
+ 		dev_err(wdev->dev, "hardware request %s%s%s (%#.2x) on vif %d returned error %d\n",
+ 			wfx_get_hif_name(cmd), mib_sep, mib_name, cmd, vif, ret);
+ 	if (ret > 0)
+ 		dev_warn(wdev->dev, "hardware request %s%s%s (%#.2x) on vif %d returned status %d\n",
+ 			 wfx_get_hif_name(cmd), mib_sep, mib_name, cmd, vif, ret);
+ 
+ 	return ret;
+ }
+ 
+ /* This function is special. After HIF_REQ_ID_SHUT_DOWN, chip won't reply to any request anymore.
+  * Obviously, only call this function during device unregister.
+  */
+ int wfx_hif_shutdown(struct wfx_dev *wdev)
+ {
+ 	int ret;
+ 	struct wfx_hif_msg *hif;
+ 
+ 	wfx_alloc_hif(0, &hif);
+ 	if (!hif)
+ 		return -ENOMEM;
+ 	wfx_fill_header(hif, -1, HIF_REQ_ID_SHUT_DOWN, 0);
+ 	ret = wfx_cmd_send(wdev, hif, NULL, 0, true);
+ 	if (wdev->pdata.gpio_wakeup)
+ 		gpiod_set_value(wdev->pdata.gpio_wakeup, 0);
+ 	else
+ 		wfx_control_reg_write(wdev, 0);
+ 	kfree(hif);
+ 	return ret;
+ }
+ 
+ int wfx_hif_configuration(struct wfx_dev *wdev, const u8 *conf, size_t len)
+ {
+ 	int ret;
+ 	size_t buf_len = sizeof(struct wfx_hif_req_configuration) + len;
+ 	struct wfx_hif_msg *hif;
+ 	struct wfx_hif_req_configuration *body = wfx_alloc_hif(buf_len, &hif);
+ 
+ 	if (!hif)
+ 		return -ENOMEM;
+ 	body->length = cpu_to_le16(len);
+ 	memcpy(body->pds_data, conf, len);
+ 	wfx_fill_header(hif, -1, HIF_REQ_ID_CONFIGURATION, buf_len);
+ 	ret = wfx_cmd_send(wdev, hif, NULL, 0, false);
+ 	kfree(hif);
+ 	return ret;
+ }
+ 
+ int wfx_hif_reset(struct wfx_vif *wvif, bool reset_stat)
+ {
+ 	int ret;
+ 	struct wfx_hif_msg *hif;
+ 	struct wfx_hif_req_reset *body = wfx_alloc_hif(sizeof(*body), &hif);
+ 
+ 	if (!hif)
+ 		return -ENOMEM;
+ 	body->reset_stat = reset_stat;
+ 	wfx_fill_header(hif, wvif->id, HIF_REQ_ID_RESET, sizeof(*body));
+ 	ret = wfx_cmd_send(wvif->wdev, hif, NULL, 0, false);
+ 	kfree(hif);
+ 	return ret;
+ }
+ 
+ int wfx_hif_read_mib(struct wfx_dev *wdev, int vif_id, u16 mib_id, void *val, size_t val_len)
+ {
+ 	int ret;
+ 	struct wfx_hif_msg *hif;
+ 	int buf_len = sizeof(struct wfx_hif_cnf_read_mib) + val_len;
+ 	struct wfx_hif_req_read_mib *body = wfx_alloc_hif(sizeof(*body), &hif);
+ 	struct wfx_hif_cnf_read_mib *reply = kmalloc(buf_len, GFP_KERNEL);
+ 
+ 	if (!body || !reply) {
+ 		ret = -ENOMEM;
+ 		goto out;
+ 	}
+ 	body->mib_id = cpu_to_le16(mib_id);
+ 	wfx_fill_header(hif, vif_id, HIF_REQ_ID_READ_MIB, sizeof(*body));
+ 	ret = wfx_cmd_send(wdev, hif, reply, buf_len, false);
+ 
+ 	if (!ret && mib_id != le16_to_cpu(reply->mib_id)) {
+ 		dev_warn(wdev->dev, "%s: confirmation mismatch request\n", __func__);
+ 		ret = -EIO;
+ 	}
+ 	if (ret == -ENOMEM)
+ 		dev_err(wdev->dev, "buffer is too small to receive %s (%zu < %d)\n",
+ 			wfx_get_mib_name(mib_id), val_len, le16_to_cpu(reply->length));
+ 	if (!ret)
+ 		memcpy(val, &reply->mib_data, le16_to_cpu(reply->length));
+ 	else
+ 		memset(val, 0xFF, val_len);
+ out:
+ 	kfree(hif);
+ 	kfree(reply);
+ 	return ret;
+ }
+ 
+ int wfx_hif_write_mib(struct wfx_dev *wdev, int vif_id, u16 mib_id, void *val, size_t val_len)
+ {
+ 	int ret;
+ 	struct wfx_hif_msg *hif;
+ 	int buf_len = sizeof(struct wfx_hif_req_write_mib) + val_len;
+ 	struct wfx_hif_req_write_mib *body = wfx_alloc_hif(buf_len, &hif);
+ 
+ 	if (!hif)
+ 		return -ENOMEM;
+ 	body->mib_id = cpu_to_le16(mib_id);
+ 	body->length = cpu_to_le16(val_len);
+ 	memcpy(&body->mib_data, val, val_len);
+ 	wfx_fill_header(hif, vif_id, HIF_REQ_ID_WRITE_MIB, buf_len);
+ 	ret = wfx_cmd_send(wdev, hif, NULL, 0, false);
+ 	kfree(hif);
+ 	return ret;
+ }
+ 
+ int wfx_hif_scan(struct wfx_vif *wvif, struct cfg80211_scan_request *req,
+ 		 int chan_start_idx, int chan_num)
+ {
+ 	int ret, i;
+ 	struct wfx_hif_msg *hif;
+ 	size_t buf_len = sizeof(struct wfx_hif_req_start_scan_alt) + chan_num * sizeof(u8);
+ 	struct wfx_hif_req_start_scan_alt *body = wfx_alloc_hif(buf_len, &hif);
+ 
+ 	WARN(chan_num > HIF_API_MAX_NB_CHANNELS, "invalid params");
+ 	WARN(req->n_ssids > HIF_API_MAX_NB_SSIDS, "invalid params");
+ 
+ 	if (!hif)
+ 		return -ENOMEM;
+ 	for (i = 0; i < req->n_ssids; i++) {
+ 		memcpy(body->ssid_def[i].ssid, req->ssids[i].ssid, IEEE80211_MAX_SSID_LEN);
+ 		body->ssid_def[i].ssid_length = cpu_to_le32(req->ssids[i].ssid_len);
+ 	}
+ 	body->num_of_ssids = HIF_API_MAX_NB_SSIDS;
+ 	body->maintain_current_bss = 1;
+ 	body->disallow_ps = 1;
+ 	body->tx_power_level = cpu_to_le32(req->channels[chan_start_idx]->max_power);
+ 	body->num_of_channels = chan_num;
+ 	for (i = 0; i < chan_num; i++)
+ 		body->channel_list[i] = req->channels[i + chan_start_idx]->hw_value;
+ 	if (req->no_cck)
+ 		body->max_transmit_rate = API_RATE_INDEX_G_6MBPS;
+ 	else
+ 		body->max_transmit_rate = API_RATE_INDEX_B_1MBPS;
+ 	if (req->channels[chan_start_idx]->flags & IEEE80211_CHAN_NO_IR) {
+ 		body->min_channel_time = cpu_to_le32(50);
+ 		body->max_channel_time = cpu_to_le32(150);
+ 	} else {
+ 		body->min_channel_time = cpu_to_le32(10);
+ 		body->max_channel_time = cpu_to_le32(50);
+ 		body->num_of_probe_requests = 2;
+ 		body->probe_delay = 100;
+ 	}
+ 
+ 	wfx_fill_header(hif, wvif->id, HIF_REQ_ID_START_SCAN, buf_len);
+ 	ret = wfx_cmd_send(wvif->wdev, hif, NULL, 0, false);
+ 	kfree(hif);
+ 	return ret;
+ }
+ 
+ int wfx_hif_stop_scan(struct wfx_vif *wvif)
+ {
+ 	int ret;
+ 	struct wfx_hif_msg *hif;
+ 	/* body associated to HIF_REQ_ID_STOP_SCAN is empty */
+ 	wfx_alloc_hif(0, &hif);
+ 
+ 	if (!hif)
+ 		return -ENOMEM;
+ 	wfx_fill_header(hif, wvif->id, HIF_REQ_ID_STOP_SCAN, 0);
+ 	ret = wfx_cmd_send(wvif->wdev, hif, NULL, 0, false);
+ 	kfree(hif);
+ 	return ret;
+ }
+ 
+ int wfx_hif_join(struct wfx_vif *wvif, const struct ieee80211_bss_conf *conf,
 -		 struct ieee80211_channel *channel, const u8 *ssid, int ssidlen)
++		 struct ieee80211_channel *channel, const u8 *ssid, int ssid_len)
+ {
+ 	int ret;
+ 	struct wfx_hif_msg *hif;
+ 	struct wfx_hif_req_join *body = wfx_alloc_hif(sizeof(*body), &hif);
+ 
+ 	WARN_ON(!conf->beacon_int);
+ 	WARN_ON(!conf->basic_rates);
 -	WARN_ON(sizeof(body->ssid) < ssidlen);
 -	WARN(!conf->ibss_joined && !ssidlen, "joining an unknown BSS");
++	WARN_ON(sizeof(body->ssid) < ssid_len);
++	WARN(!conf->ibss_joined && !ssid_len, "joining an unknown BSS");
+ 	if (!hif)
+ 		return -ENOMEM;
+ 	body->infrastructure_bss_mode = !conf->ibss_joined;
+ 	body->short_preamble = conf->use_short_preamble;
+ 	body->probe_for_join = !(channel->flags & IEEE80211_CHAN_NO_IR);
+ 	body->channel_number = channel->hw_value;
+ 	body->beacon_interval = cpu_to_le32(conf->beacon_int);
+ 	body->basic_rate_set = cpu_to_le32(wfx_rate_mask_to_hw(wvif->wdev, conf->basic_rates));
+ 	memcpy(body->bssid, conf->bssid, sizeof(body->bssid));
+ 	if (ssid) {
 -		body->ssid_length = cpu_to_le32(ssidlen);
 -		memcpy(body->ssid, ssid, ssidlen);
++		body->ssid_length = cpu_to_le32(ssid_len);
++		memcpy(body->ssid, ssid, ssid_len);
+ 	}
+ 	wfx_fill_header(hif, wvif->id, HIF_REQ_ID_JOIN, sizeof(*body));
+ 	ret = wfx_cmd_send(wvif->wdev, hif, NULL, 0, false);
+ 	kfree(hif);
+ 	return ret;
+ }
+ 
+ int wfx_hif_set_bss_params(struct wfx_vif *wvif, int aid, int beacon_lost_count)
+ {
+ 	int ret;
+ 	struct wfx_hif_msg *hif;
+ 	struct wfx_hif_req_set_bss_params *body = wfx_alloc_hif(sizeof(*body), &hif);
+ 
+ 	if (!hif)
+ 		return -ENOMEM;
+ 	body->aid = cpu_to_le16(aid);
+ 	body->beacon_lost_count = beacon_lost_count;
+ 	wfx_fill_header(hif, wvif->id, HIF_REQ_ID_SET_BSS_PARAMS, sizeof(*body));
+ 	ret = wfx_cmd_send(wvif->wdev, hif, NULL, 0, false);
+ 	kfree(hif);
+ 	return ret;
+ }
+ 
+ int wfx_hif_add_key(struct wfx_dev *wdev, const struct wfx_hif_req_add_key *arg)
+ {
+ 	int ret;
+ 	struct wfx_hif_msg *hif;
+ 	/* FIXME: only send necessary bits */
+ 	struct wfx_hif_req_add_key *body = wfx_alloc_hif(sizeof(*body), &hif);
+ 
+ 	if (!hif)
+ 		return -ENOMEM;
+ 	/* FIXME: swap bytes as necessary in body */
+ 	memcpy(body, arg, sizeof(*body));
+ 	if (wfx_api_older_than(wdev, 1, 5))
+ 		/* Legacy firmwares expect that add_key to be sent on right interface. */
+ 		wfx_fill_header(hif, arg->int_id, HIF_REQ_ID_ADD_KEY, sizeof(*body));
+ 	else
+ 		wfx_fill_header(hif, -1, HIF_REQ_ID_ADD_KEY, sizeof(*body));
+ 	ret = wfx_cmd_send(wdev, hif, NULL, 0, false);
+ 	kfree(hif);
+ 	return ret;
+ }
+ 
+ int wfx_hif_remove_key(struct wfx_dev *wdev, int idx)
+ {
+ 	int ret;
+ 	struct wfx_hif_msg *hif;
+ 	struct wfx_hif_req_remove_key *body = wfx_alloc_hif(sizeof(*body), &hif);
+ 
+ 	if (!hif)
+ 		return -ENOMEM;
+ 	body->entry_index = idx;
+ 	wfx_fill_header(hif, -1, HIF_REQ_ID_REMOVE_KEY, sizeof(*body));
+ 	ret = wfx_cmd_send(wdev, hif, NULL, 0, false);
+ 	kfree(hif);
+ 	return ret;
+ }
+ 
+ int wfx_hif_set_edca_queue_params(struct wfx_vif *wvif, u16 queue,
+ 				  const struct ieee80211_tx_queue_params *arg)
+ {
+ 	int ret;
+ 	struct wfx_hif_msg *hif;
+ 	struct wfx_hif_req_edca_queue_params *body = wfx_alloc_hif(sizeof(*body), &hif);
+ 
+ 	if (!body)
+ 		return -ENOMEM;
+ 
+ 	WARN_ON(arg->aifs > 255);
+ 	if (!hif)
+ 		return -ENOMEM;
+ 	body->aifsn = arg->aifs;
+ 	body->cw_min = cpu_to_le16(arg->cw_min);
+ 	body->cw_max = cpu_to_le16(arg->cw_max);
+ 	body->tx_op_limit = cpu_to_le16(arg->txop * USEC_PER_TXOP);
+ 	body->queue_id = 3 - queue;
+ 	/* API 2.0 has changed queue IDs values */
+ 	if (wfx_api_older_than(wvif->wdev, 2, 0) && queue == IEEE80211_AC_BE)
+ 		body->queue_id = HIF_QUEUE_ID_BACKGROUND;
+ 	if (wfx_api_older_than(wvif->wdev, 2, 0) && queue == IEEE80211_AC_BK)
+ 		body->queue_id = HIF_QUEUE_ID_BESTEFFORT;
+ 	wfx_fill_header(hif, wvif->id, HIF_REQ_ID_EDCA_QUEUE_PARAMS, sizeof(*body));
+ 	ret = wfx_cmd_send(wvif->wdev, hif, NULL, 0, false);
+ 	kfree(hif);
+ 	return ret;
+ }
+ 
+ int wfx_hif_set_pm(struct wfx_vif *wvif, bool ps, int dynamic_ps_timeout)
+ {
+ 	int ret;
+ 	struct wfx_hif_msg *hif;
+ 	struct wfx_hif_req_set_pm_mode *body = wfx_alloc_hif(sizeof(*body), &hif);
+ 
+ 	if (!body)
+ 		return -ENOMEM;
+ 
+ 	if (!hif)
+ 		return -ENOMEM;
+ 	if (ps) {
+ 		body->enter_psm = 1;
+ 		/* Firmware does not support more than 128ms */
+ 		body->fast_psm_idle_period = min(dynamic_ps_timeout * 2, 255);
+ 		if (body->fast_psm_idle_period)
+ 			body->fast_psm = 1;
+ 	}
+ 	wfx_fill_header(hif, wvif->id, HIF_REQ_ID_SET_PM_MODE, sizeof(*body));
+ 	ret = wfx_cmd_send(wvif->wdev, hif, NULL, 0, false);
+ 	kfree(hif);
+ 	return ret;
+ }
+ 
+ int wfx_hif_start(struct wfx_vif *wvif, const struct ieee80211_bss_conf *conf,
+ 		  const struct ieee80211_channel *channel)
+ {
+ 	int ret;
+ 	struct wfx_hif_msg *hif;
+ 	struct wfx_hif_req_start *body = wfx_alloc_hif(sizeof(*body), &hif);
+ 
+ 	WARN_ON(!conf->beacon_int);
+ 	if (!hif)
+ 		return -ENOMEM;
+ 	body->dtim_period = conf->dtim_period;
+ 	body->short_preamble = conf->use_short_preamble;
+ 	body->channel_number = channel->hw_value;
+ 	body->beacon_interval = cpu_to_le32(conf->beacon_int);
+ 	body->basic_rate_set = cpu_to_le32(wfx_rate_mask_to_hw(wvif->wdev, conf->basic_rates));
+ 	body->ssid_length = conf->ssid_len;
+ 	memcpy(body->ssid, conf->ssid, conf->ssid_len);
+ 	wfx_fill_header(hif, wvif->id, HIF_REQ_ID_START, sizeof(*body));
+ 	ret = wfx_cmd_send(wvif->wdev, hif, NULL, 0, false);
+ 	kfree(hif);
+ 	return ret;
+ }
+ 
+ int wfx_hif_beacon_transmit(struct wfx_vif *wvif, bool enable)
+ {
+ 	int ret;
+ 	struct wfx_hif_msg *hif;
+ 	struct wfx_hif_req_beacon_transmit *body = wfx_alloc_hif(sizeof(*body), &hif);
+ 
+ 	if (!hif)
+ 		return -ENOMEM;
+ 	body->enable_beaconing = enable ? 1 : 0;
+ 	wfx_fill_header(hif, wvif->id, HIF_REQ_ID_BEACON_TRANSMIT, sizeof(*body));
+ 	ret = wfx_cmd_send(wvif->wdev, hif, NULL, 0, false);
+ 	kfree(hif);
+ 	return ret;
+ }
+ 
+ int wfx_hif_map_link(struct wfx_vif *wvif, bool unmap, u8 *mac_addr, int sta_id, bool mfp)
+ {
+ 	int ret;
+ 	struct wfx_hif_msg *hif;
+ 	struct wfx_hif_req_map_link *body = wfx_alloc_hif(sizeof(*body), &hif);
+ 
+ 	if (!hif)
+ 		return -ENOMEM;
+ 	if (mac_addr)
+ 		ether_addr_copy(body->mac_addr, mac_addr);
+ 	body->mfpc = mfp ? 1 : 0;
+ 	body->unmap = unmap ? 1 : 0;
+ 	body->peer_sta_id = sta_id;
+ 	wfx_fill_header(hif, wvif->id, HIF_REQ_ID_MAP_LINK, sizeof(*body));
+ 	ret = wfx_cmd_send(wvif->wdev, hif, NULL, 0, false);
+ 	kfree(hif);
+ 	return ret;
+ }
+ 
+ int wfx_hif_update_ie_beacon(struct wfx_vif *wvif, const u8 *ies, size_t ies_len)
+ {
+ 	int ret;
+ 	struct wfx_hif_msg *hif;
+ 	int buf_len = sizeof(struct wfx_hif_req_update_ie) + ies_len;
+ 	struct wfx_hif_req_update_ie *body = wfx_alloc_hif(buf_len, &hif);
+ 
+ 	if (!hif)
+ 		return -ENOMEM;
+ 	body->beacon = 1;
+ 	body->num_ies = cpu_to_le16(1);
+ 	memcpy(body->ie, ies, ies_len);
+ 	wfx_fill_header(hif, wvif->id, HIF_REQ_ID_UPDATE_IE, buf_len);
+ 	ret = wfx_cmd_send(wvif->wdev, hif, NULL, 0, false);
+ 	kfree(hif);
+ 	return ret;
+ }
diff --cc drivers/net/wireless/silabs/wfx/main.c
index 0000000000000,b93b16b900c84..e575a81ca2cab
mode 000000,100644..100644
--- a/drivers/net/wireless/silabs/wfx/main.c
+++ b/drivers/net/wireless/silabs/wfx/main.c
@@@ -1,0 -1,491 +1,491 @@@
+ // SPDX-License-Identifier: GPL-2.0-only
+ /*
+  * Device probe and register.
+  *
+  * Copyright (c) 2017-2020, Silicon Laboratories, Inc.
+  * Copyright (c) 2010, ST-Ericsson
+  * Copyright (c) 2008, Johannes Berg <johannes@sipsolutions.net>
+  * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
+  * Copyright (c) 2007-2009, Christian Lamparter <chunkeey@web.de>
+  * Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
+  * Copyright (c) 2004-2006 Jean-Baptiste Note <jbnote@gmail.com>, et al.
+  */
+ #include <linux/module.h>
+ #include <linux/of.h>
+ #include <linux/of_net.h>
+ #include <linux/gpio/consumer.h>
+ #include <linux/mmc/sdio_func.h>
+ #include <linux/spi/spi.h>
+ #include <linux/etherdevice.h>
+ #include <linux/firmware.h>
+ 
+ #include "main.h"
+ #include "wfx.h"
+ #include "fwio.h"
+ #include "hwio.h"
+ #include "bus.h"
+ #include "bh.h"
+ #include "sta.h"
+ #include "key.h"
+ #include "scan.h"
+ #include "debug.h"
+ #include "data_tx.h"
+ #include "hif_tx_mib.h"
+ #include "hif_api_cmd.h"
+ 
+ #define WFX_PDS_TLV_TYPE 0x4450 // "PD" (Platform Data) in ascii little-endian
+ #define WFX_PDS_MAX_CHUNK_SIZE 1500
+ 
+ MODULE_DESCRIPTION("Silicon Labs 802.11 Wireless LAN driver for WF200");
+ MODULE_AUTHOR("Jérôme Pouiller <jerome.pouiller@silabs.com>");
+ MODULE_LICENSE("GPL");
+ 
+ #define RATETAB_ENT(_rate, _rateid, _flags) { \
+ 	.bitrate  = (_rate),   \
+ 	.hw_value = (_rateid), \
+ 	.flags    = (_flags),  \
+ }
+ 
+ static struct ieee80211_rate wfx_rates[] = {
+ 	RATETAB_ENT(10,  0,  0),
+ 	RATETAB_ENT(20,  1,  IEEE80211_RATE_SHORT_PREAMBLE),
+ 	RATETAB_ENT(55,  2,  IEEE80211_RATE_SHORT_PREAMBLE),
+ 	RATETAB_ENT(110, 3,  IEEE80211_RATE_SHORT_PREAMBLE),
+ 	RATETAB_ENT(60,  6,  0),
+ 	RATETAB_ENT(90,  7,  0),
+ 	RATETAB_ENT(120, 8,  0),
+ 	RATETAB_ENT(180, 9,  0),
+ 	RATETAB_ENT(240, 10, 0),
+ 	RATETAB_ENT(360, 11, 0),
+ 	RATETAB_ENT(480, 12, 0),
+ 	RATETAB_ENT(540, 13, 0),
+ };
+ 
+ #define CHAN2G(_channel, _freq, _flags) { \
+ 	.band = NL80211_BAND_2GHZ, \
+ 	.center_freq = (_freq),    \
+ 	.hw_value = (_channel),    \
+ 	.flags = (_flags),         \
+ 	.max_antenna_gain = 0,     \
+ 	.max_power = 30,           \
+ }
+ 
+ static struct ieee80211_channel wfx_2ghz_chantable[] = {
+ 	CHAN2G(1,  2412, 0),
+ 	CHAN2G(2,  2417, 0),
+ 	CHAN2G(3,  2422, 0),
+ 	CHAN2G(4,  2427, 0),
+ 	CHAN2G(5,  2432, 0),
+ 	CHAN2G(6,  2437, 0),
+ 	CHAN2G(7,  2442, 0),
+ 	CHAN2G(8,  2447, 0),
+ 	CHAN2G(9,  2452, 0),
+ 	CHAN2G(10, 2457, 0),
+ 	CHAN2G(11, 2462, 0),
+ 	CHAN2G(12, 2467, 0),
+ 	CHAN2G(13, 2472, 0),
+ 	CHAN2G(14, 2484, 0),
+ };
+ 
+ static const struct ieee80211_supported_band wfx_band_2ghz = {
+ 	.channels = wfx_2ghz_chantable,
+ 	.n_channels = ARRAY_SIZE(wfx_2ghz_chantable),
+ 	.bitrates = wfx_rates,
+ 	.n_bitrates = ARRAY_SIZE(wfx_rates),
+ 	.ht_cap = {
+ 		/* Receive caps */
+ 		.cap = IEEE80211_HT_CAP_GRN_FLD | IEEE80211_HT_CAP_SGI_20 |
+ 		       IEEE80211_HT_CAP_MAX_AMSDU | (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT),
+ 		.ht_supported = 1,
+ 		.ampdu_factor = IEEE80211_HT_MAX_AMPDU_16K,
+ 		.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE,
+ 		.mcs = {
+ 			.rx_mask = { 0xFF }, /* MCS0 to MCS7 */
+ 			.rx_highest = cpu_to_le16(72),
+ 			.tx_params = IEEE80211_HT_MCS_TX_DEFINED,
+ 		},
+ 	},
+ };
+ 
+ static const struct ieee80211_iface_limit wdev_iface_limits[] = {
+ 	{ .max = 1, .types = BIT(NL80211_IFTYPE_STATION) },
+ 	{ .max = 1, .types = BIT(NL80211_IFTYPE_AP) },
+ };
+ 
+ static const struct ieee80211_iface_combination wfx_iface_combinations[] = {
+ 	{
+ 		.num_different_channels = 2,
+ 		.max_interfaces = 2,
+ 		.limits = wdev_iface_limits,
+ 		.n_limits = ARRAY_SIZE(wdev_iface_limits),
+ 	}
+ };
+ 
+ static const struct ieee80211_ops wfx_ops = {
+ 	.start                   = wfx_start,
+ 	.stop                    = wfx_stop,
+ 	.add_interface           = wfx_add_interface,
+ 	.remove_interface        = wfx_remove_interface,
+ 	.config                  = wfx_config,
+ 	.tx                      = wfx_tx,
+ 	.join_ibss               = wfx_join_ibss,
+ 	.leave_ibss              = wfx_leave_ibss,
+ 	.conf_tx                 = wfx_conf_tx,
+ 	.hw_scan                 = wfx_hw_scan,
+ 	.cancel_hw_scan          = wfx_cancel_hw_scan,
+ 	.start_ap                = wfx_start_ap,
+ 	.stop_ap                 = wfx_stop_ap,
+ 	.sta_add                 = wfx_sta_add,
+ 	.sta_remove              = wfx_sta_remove,
+ 	.set_tim                 = wfx_set_tim,
+ 	.set_key                 = wfx_set_key,
+ 	.set_rts_threshold       = wfx_set_rts_threshold,
+ 	.set_default_unicast_key = wfx_set_default_unicast_key,
+ 	.bss_info_changed        = wfx_bss_info_changed,
+ 	.configure_filter        = wfx_configure_filter,
+ 	.ampdu_action            = wfx_ampdu_action,
+ 	.flush                   = wfx_flush,
+ 	.add_chanctx             = wfx_add_chanctx,
+ 	.remove_chanctx          = wfx_remove_chanctx,
+ 	.change_chanctx          = wfx_change_chanctx,
+ 	.assign_vif_chanctx      = wfx_assign_vif_chanctx,
+ 	.unassign_vif_chanctx    = wfx_unassign_vif_chanctx,
+ };
+ 
+ bool wfx_api_older_than(struct wfx_dev *wdev, int major, int minor)
+ {
+ 	if (wdev->hw_caps.api_version_major < major)
+ 		return true;
+ 	if (wdev->hw_caps.api_version_major > major)
+ 		return false;
+ 	if (wdev->hw_caps.api_version_minor < minor)
+ 		return true;
+ 	return false;
+ }
+ 
+ /* The device needs data about the antenna configuration. This information in provided by PDS
+  * (Platform Data Set, this is the wording used in WF200 documentation) files. For hardware
+  * integrators, the full process to create PDS files is described here:
+  *   https://github.com/SiliconLabs/wfx-firmware/blob/master/PDS/README.md
+  *
+  * The PDS file is an array of Time-Length-Value structs.
+  */
 - int wfx_send_pds(struct wfx_dev *wdev, u8 *buf, size_t len)
++int wfx_send_pds(struct wfx_dev *wdev, u8 *buf, size_t len)
+ {
+ 	int ret, chunk_type, chunk_len, chunk_num = 0;
+ 
+ 	if (*buf == '{') {
+ 		dev_err(wdev->dev, "PDS: malformed file (legacy format?)\n");
+ 		return -EINVAL;
+ 	}
+ 	while (len > 0) {
+ 		chunk_type = get_unaligned_le16(buf + 0);
+ 		chunk_len = get_unaligned_le16(buf + 2);
+ 		if (chunk_len > len) {
+ 			dev_err(wdev->dev, "PDS:%d: corrupted file\n", chunk_num);
+ 			return -EINVAL;
+ 		}
+ 		if (chunk_type != WFX_PDS_TLV_TYPE) {
+ 			dev_info(wdev->dev, "PDS:%d: skip unknown data\n", chunk_num);
+ 			goto next;
+ 		}
+ 		if (chunk_len > WFX_PDS_MAX_CHUNK_SIZE)
+ 			dev_warn(wdev->dev, "PDS:%d: unexpectedly large chunk\n", chunk_num);
+ 		if (buf[4] != '{' || buf[chunk_len - 1] != '}')
+ 			dev_warn(wdev->dev, "PDS:%d: unexpected content\n", chunk_num);
+ 
+ 		ret = wfx_hif_configuration(wdev, buf + 4, chunk_len - 4);
+ 		if (ret > 0) {
+ 			dev_err(wdev->dev, "PDS:%d: invalid data (unsupported options?)\n", chunk_num);
+ 			return -EINVAL;
+ 		}
+ 		if (ret == -ETIMEDOUT) {
+ 			dev_err(wdev->dev, "PDS:%d: chip didn't reply (corrupted file?)\n", chunk_num);
+ 			return ret;
+ 		}
+ 		if (ret) {
+ 			dev_err(wdev->dev, "PDS:%d: chip returned an unknown error\n", chunk_num);
+ 			return -EIO;
+ 		}
+ next:
+ 		chunk_num++;
+ 		len -= chunk_len;
+ 		buf += chunk_len;
+ 	}
+ 	return 0;
+ }
+ 
+ static int wfx_send_pdata_pds(struct wfx_dev *wdev)
+ {
+ 	int ret = 0;
+ 	const struct firmware *pds;
+ 	u8 *tmp_buf;
+ 
+ 	ret = request_firmware(&pds, wdev->pdata.file_pds, wdev->dev);
+ 	if (ret) {
+ 		dev_err(wdev->dev, "can't load antenna parameters (PDS file %s). The device may be unstable.\n",
+ 			wdev->pdata.file_pds);
+ 		return ret;
+ 	}
+ 	tmp_buf = kmemdup(pds->data, pds->size, GFP_KERNEL);
+ 	if (!tmp_buf) {
+ 		ret = -ENOMEM;
+ 		goto release_fw;
+ 	}
+ 	ret = wfx_send_pds(wdev, tmp_buf, pds->size);
+ 	kfree(tmp_buf);
+ release_fw:
+ 	release_firmware(pds);
+ 	return ret;
+ }
+ 
+ static void wfx_free_common(void *data)
+ {
+ 	struct wfx_dev *wdev = data;
+ 
+ 	mutex_destroy(&wdev->tx_power_loop_info_lock);
+ 	mutex_destroy(&wdev->rx_stats_lock);
+ 	mutex_destroy(&wdev->conf_mutex);
+ 	ieee80211_free_hw(wdev->hw);
+ }
+ 
+ struct wfx_dev *wfx_init_common(struct device *dev, const struct wfx_platform_data *pdata,
+ 				const struct wfx_hwbus_ops *hwbus_ops, void *hwbus_priv)
+ {
+ 	struct ieee80211_hw *hw;
+ 	struct wfx_dev *wdev;
+ 
+ 	hw = ieee80211_alloc_hw(sizeof(struct wfx_dev), &wfx_ops);
+ 	if (!hw)
+ 		return NULL;
+ 
+ 	SET_IEEE80211_DEV(hw, dev);
+ 
+ 	ieee80211_hw_set(hw, TX_AMPDU_SETUP_IN_HW);
+ 	ieee80211_hw_set(hw, AMPDU_AGGREGATION);
+ 	ieee80211_hw_set(hw, CONNECTION_MONITOR);
+ 	ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);
+ 	ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);
+ 	ieee80211_hw_set(hw, SIGNAL_DBM);
+ 	ieee80211_hw_set(hw, SUPPORTS_PS);
+ 	ieee80211_hw_set(hw, MFP_CAPABLE);
+ 
+ 	hw->vif_data_size = sizeof(struct wfx_vif);
+ 	hw->sta_data_size = sizeof(struct wfx_sta_priv);
+ 	hw->queues = 4;
+ 	hw->max_rates = 8;
+ 	hw->max_rate_tries = 8;
+ 	hw->extra_tx_headroom = sizeof(struct wfx_hif_msg) + sizeof(struct wfx_hif_req_tx) +
+ 				4 /* alignment */ + 8 /* TKIP IV */;
+ 	hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
+ 				     BIT(NL80211_IFTYPE_ADHOC) |
+ 				     BIT(NL80211_IFTYPE_AP);
+ 	hw->wiphy->probe_resp_offload = NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
+ 					NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
+ 					NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P |
+ 					NL80211_PROBE_RESP_OFFLOAD_SUPPORT_80211U;
+ 	hw->wiphy->features |= NL80211_FEATURE_AP_SCAN;
+ 	hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
+ 	hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
+ 	hw->wiphy->max_ap_assoc_sta = HIF_LINK_ID_MAX;
+ 	hw->wiphy->max_scan_ssids = 2;
+ 	hw->wiphy->max_scan_ie_len = IEEE80211_MAX_DATA_LEN;
+ 	hw->wiphy->n_iface_combinations = ARRAY_SIZE(wfx_iface_combinations);
+ 	hw->wiphy->iface_combinations = wfx_iface_combinations;
+ 	hw->wiphy->bands[NL80211_BAND_2GHZ] = devm_kmalloc(dev, sizeof(wfx_band_2ghz), GFP_KERNEL);
+ 	if (!hw->wiphy->bands[NL80211_BAND_2GHZ])
+ 		goto err;
+ 
+ 	/* FIXME: also copy wfx_rates and wfx_2ghz_chantable */
+ 	memcpy(hw->wiphy->bands[NL80211_BAND_2GHZ], &wfx_band_2ghz, sizeof(wfx_band_2ghz));
+ 
+ 	wdev = hw->priv;
+ 	wdev->hw = hw;
+ 	wdev->dev = dev;
+ 	wdev->hwbus_ops = hwbus_ops;
+ 	wdev->hwbus_priv = hwbus_priv;
+ 	memcpy(&wdev->pdata, pdata, sizeof(*pdata));
+ 	of_property_read_string(dev->of_node, "silabs,antenna-config-file", &wdev->pdata.file_pds);
+ 	wdev->pdata.gpio_wakeup = devm_gpiod_get_optional(dev, "wakeup", GPIOD_OUT_LOW);
+ 	if (IS_ERR(wdev->pdata.gpio_wakeup))
+ 		goto err;
+ 
+ 	if (wdev->pdata.gpio_wakeup)
+ 		gpiod_set_consumer_name(wdev->pdata.gpio_wakeup, "wfx wakeup");
+ 
+ 	mutex_init(&wdev->conf_mutex);
+ 	mutex_init(&wdev->rx_stats_lock);
+ 	mutex_init(&wdev->tx_power_loop_info_lock);
+ 	init_completion(&wdev->firmware_ready);
+ 	INIT_DELAYED_WORK(&wdev->cooling_timeout_work, wfx_cooling_timeout_work);
+ 	skb_queue_head_init(&wdev->tx_pending);
+ 	init_waitqueue_head(&wdev->tx_dequeue);
+ 	wfx_init_hif_cmd(&wdev->hif_cmd);
+ 
+ 	if (devm_add_action_or_reset(dev, wfx_free_common, wdev))
+ 		return NULL;
+ 
+ 	return wdev;
+ 
+ err:
+ 	ieee80211_free_hw(hw);
+ 	return NULL;
+ }
+ 
+ int wfx_probe(struct wfx_dev *wdev)
+ {
+ 	int i;
+ 	int err;
+ 	struct gpio_desc *gpio_saved;
+ 
+ 	/* During first part of boot, gpio_wakeup cannot yet been used. So prevent bh() to touch
+ 	 * it.
+ 	 */
+ 	gpio_saved = wdev->pdata.gpio_wakeup;
+ 	wdev->pdata.gpio_wakeup = NULL;
+ 	wdev->poll_irq = true;
+ 
+ 	wfx_bh_register(wdev);
+ 
+ 	err = wfx_init_device(wdev);
+ 	if (err)
+ 		goto bh_unregister;
+ 
+ 	wfx_bh_poll_irq(wdev);
+ 	err = wait_for_completion_timeout(&wdev->firmware_ready, 1 * HZ);
+ 	if (err <= 0) {
+ 		if (err == 0) {
+ 			dev_err(wdev->dev, "timeout while waiting for startup indication\n");
+ 			err = -ETIMEDOUT;
+ 		} else if (err == -ERESTARTSYS) {
+ 			dev_info(wdev->dev, "probe interrupted by user\n");
+ 		}
+ 		goto bh_unregister;
+ 	}
+ 
+ 	/* FIXME: fill wiphy::hw_version */
+ 	dev_info(wdev->dev, "started firmware %d.%d.%d \"%s\" (API: %d.%d, keyset: %02X, caps: 0x%.8X)\n",
+ 		 wdev->hw_caps.firmware_major, wdev->hw_caps.firmware_minor,
+ 		 wdev->hw_caps.firmware_build, wdev->hw_caps.firmware_label,
+ 		 wdev->hw_caps.api_version_major, wdev->hw_caps.api_version_minor,
+ 		 wdev->keyset, wdev->hw_caps.link_mode);
+ 	snprintf(wdev->hw->wiphy->fw_version,
+ 		 sizeof(wdev->hw->wiphy->fw_version),
+ 		 "%d.%d.%d",
+ 		 wdev->hw_caps.firmware_major,
+ 		 wdev->hw_caps.firmware_minor,
+ 		 wdev->hw_caps.firmware_build);
+ 
+ 	if (wfx_api_older_than(wdev, 1, 0)) {
+ 		dev_err(wdev->dev, "unsupported firmware API version (expect 1 while firmware returns %d)\n",
+ 			wdev->hw_caps.api_version_major);
+ 		err = -EOPNOTSUPP;
+ 		goto bh_unregister;
+ 	}
+ 
+ 	if (wdev->hw_caps.link_mode == SEC_LINK_ENFORCED) {
+ 		dev_err(wdev->dev, "chip require secure_link, but can't negotiate it\n");
+ 		goto bh_unregister;
+ 	}
+ 
+ 	if (wdev->hw_caps.region_sel_mode) {
+ 		wdev->hw->wiphy->regulatory_flags |= REGULATORY_DISABLE_BEACON_HINTS;
+ 		wdev->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels[11].flags |=
+ 			IEEE80211_CHAN_NO_IR;
+ 		wdev->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels[12].flags |=
+ 			IEEE80211_CHAN_NO_IR;
+ 		wdev->hw->wiphy->bands[NL80211_BAND_2GHZ]->channels[13].flags |=
+ 			IEEE80211_CHAN_DISABLED;
+ 	}
+ 
+ 	dev_dbg(wdev->dev, "sending configuration file %s\n", wdev->pdata.file_pds);
+ 	err = wfx_send_pdata_pds(wdev);
+ 	if (err < 0 && err != -ENOENT)
+ 		goto bh_unregister;
+ 
+ 	wdev->poll_irq = false;
+ 	err = wdev->hwbus_ops->irq_subscribe(wdev->hwbus_priv);
+ 	if (err)
+ 		goto bh_unregister;
+ 
+ 	err = wfx_hif_use_multi_tx_conf(wdev, true);
+ 	if (err)
+ 		dev_err(wdev->dev, "misconfigured IRQ?\n");
+ 
+ 	wdev->pdata.gpio_wakeup = gpio_saved;
+ 	if (wdev->pdata.gpio_wakeup) {
+ 		dev_dbg(wdev->dev, "enable 'quiescent' power mode with wakeup GPIO and PDS file %s\n",
+ 			wdev->pdata.file_pds);
+ 		gpiod_set_value_cansleep(wdev->pdata.gpio_wakeup, 1);
+ 		wfx_control_reg_write(wdev, 0);
+ 		wfx_hif_set_operational_mode(wdev, HIF_OP_POWER_MODE_QUIESCENT);
+ 	} else {
+ 		wfx_hif_set_operational_mode(wdev, HIF_OP_POWER_MODE_DOZE);
+ 	}
+ 
+ 	for (i = 0; i < ARRAY_SIZE(wdev->addresses); i++) {
+ 		eth_zero_addr(wdev->addresses[i].addr);
+ 		err = of_get_mac_address(wdev->dev->of_node, wdev->addresses[i].addr);
+ 		if (!err)
+ 			wdev->addresses[i].addr[ETH_ALEN - 1] += i;
+ 		else
+ 			ether_addr_copy(wdev->addresses[i].addr, wdev->hw_caps.mac_addr[i]);
+ 		if (!is_valid_ether_addr(wdev->addresses[i].addr)) {
+ 			dev_warn(wdev->dev, "using random MAC address\n");
+ 			eth_random_addr(wdev->addresses[i].addr);
+ 		}
+ 		dev_info(wdev->dev, "MAC address %d: %pM\n", i, wdev->addresses[i].addr);
+ 	}
+ 	wdev->hw->wiphy->n_addresses = ARRAY_SIZE(wdev->addresses);
+ 	wdev->hw->wiphy->addresses = wdev->addresses;
+ 
+ 	if (!wfx_api_older_than(wdev, 3, 8))
+ 		wdev->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
+ 
+ 	err = ieee80211_register_hw(wdev->hw);
+ 	if (err)
+ 		goto irq_unsubscribe;
+ 
+ 	err = wfx_debug_init(wdev);
+ 	if (err)
+ 		goto ieee80211_unregister;
+ 
+ 	return 0;
+ 
+ ieee80211_unregister:
+ 	ieee80211_unregister_hw(wdev->hw);
+ irq_unsubscribe:
+ 	wdev->hwbus_ops->irq_unsubscribe(wdev->hwbus_priv);
+ bh_unregister:
+ 	wfx_bh_unregister(wdev);
+ 	return err;
+ }
+ 
+ void wfx_release(struct wfx_dev *wdev)
+ {
+ 	ieee80211_unregister_hw(wdev->hw);
+ 	wfx_hif_shutdown(wdev);
+ 	wdev->hwbus_ops->irq_unsubscribe(wdev->hwbus_priv);
+ 	wfx_bh_unregister(wdev);
+ }
+ 
+ static int __init wfx_core_init(void)
+ {
+ 	int ret = 0;
+ 
+ 	if (IS_ENABLED(CONFIG_SPI))
+ 		ret = spi_register_driver(&wfx_spi_driver);
+ 	if (IS_ENABLED(CONFIG_MMC) && !ret)
+ 		ret = sdio_register_driver(&wfx_sdio_driver);
+ 	return ret;
+ }
+ module_init(wfx_core_init);
+ 
+ static void __exit wfx_core_exit(void)
+ {
+ 	if (IS_ENABLED(CONFIG_MMC))
+ 		sdio_unregister_driver(&wfx_sdio_driver);
+ 	if (IS_ENABLED(CONFIG_SPI))
+ 		spi_unregister_driver(&wfx_spi_driver);
+ }
+ module_exit(wfx_core_exit);
diff --cc drivers/net/wireless/silabs/wfx/sta.c
index 0000000000000,b1e9fb14d2b41..03025ef7f1beb
mode 000000,100644..100644
--- a/drivers/net/wireless/silabs/wfx/sta.c
+++ b/drivers/net/wireless/silabs/wfx/sta.c
@@@ -1,0 -1,794 +1,794 @@@
+ // SPDX-License-Identifier: GPL-2.0-only
+ /*
+  * Implementation of mac80211 API.
+  *
+  * Copyright (c) 2017-2020, Silicon Laboratories, Inc.
+  * Copyright (c) 2010, ST-Ericsson
+  */
+ #include <linux/etherdevice.h>
+ #include <net/mac80211.h>
+ 
+ #include "sta.h"
+ #include "wfx.h"
+ #include "fwio.h"
+ #include "bh.h"
+ #include "key.h"
+ #include "scan.h"
+ #include "debug.h"
+ #include "hif_tx.h"
+ #include "hif_tx_mib.h"
+ 
+ #define HIF_MAX_ARP_IP_ADDRTABLE_ENTRIES 2
+ 
+ u32 wfx_rate_mask_to_hw(struct wfx_dev *wdev, u32 rates)
+ {
+ 	int i;
+ 	u32 ret = 0;
+ 	/* The device only supports 2GHz */
+ 	struct ieee80211_supported_band *sband = wdev->hw->wiphy->bands[NL80211_BAND_2GHZ];
+ 
+ 	for (i = 0; i < sband->n_bitrates; i++) {
+ 		if (rates & BIT(i)) {
+ 			if (i >= sband->n_bitrates)
+ 				dev_warn(wdev->dev, "unsupported basic rate\n");
+ 			else
+ 				ret |= BIT(sband->bitrates[i].hw_value);
+ 		}
+ 	}
+ 	return ret;
+ }
+ 
+ void wfx_cooling_timeout_work(struct work_struct *work)
+ {
+ 	struct wfx_dev *wdev = container_of(to_delayed_work(work), struct wfx_dev,
+ 					    cooling_timeout_work);
+ 
+ 	wdev->chip_frozen = true;
+ 	wfx_tx_unlock(wdev);
+ }
+ 
+ void wfx_suspend_hot_dev(struct wfx_dev *wdev, enum sta_notify_cmd cmd)
+ {
+ 	if (cmd == STA_NOTIFY_AWAKE) {
+ 		/* Device recover normal temperature */
+ 		if (cancel_delayed_work(&wdev->cooling_timeout_work))
+ 			wfx_tx_unlock(wdev);
+ 	} else {
+ 		/* Device is too hot */
+ 		schedule_delayed_work(&wdev->cooling_timeout_work, 10 * HZ);
+ 		wfx_tx_lock(wdev);
+ 	}
+ }
+ 
+ static void wfx_filter_beacon(struct wfx_vif *wvif, bool filter_beacon)
+ {
+ 	static const struct wfx_hif_ie_table_entry filter_ies[] = {
+ 		{
+ 			.ie_id        = WLAN_EID_VENDOR_SPECIFIC,
+ 			.has_changed  = 1,
+ 			.no_longer    = 1,
+ 			.has_appeared = 1,
+ 			.oui          = { 0x50, 0x6F, 0x9A },
+ 		}, {
+ 			.ie_id        = WLAN_EID_HT_OPERATION,
+ 			.has_changed  = 1,
+ 			.no_longer    = 1,
+ 			.has_appeared = 1,
+ 		}, {
+ 			.ie_id        = WLAN_EID_ERP_INFO,
+ 			.has_changed  = 1,
+ 			.no_longer    = 1,
+ 			.has_appeared = 1,
+ 		}, {
+ 			.ie_id        = WLAN_EID_CHANNEL_SWITCH,
+ 			.has_changed  = 1,
+ 			.no_longer    = 1,
+ 			.has_appeared = 1,
+ 		}
+ 	};
+ 
+ 	if (!filter_beacon) {
+ 		wfx_hif_beacon_filter_control(wvif, 0, 1);
+ 	} else {
+ 		wfx_hif_set_beacon_filter_table(wvif, ARRAY_SIZE(filter_ies), filter_ies);
+ 		wfx_hif_beacon_filter_control(wvif, HIF_BEACON_FILTER_ENABLE, 0);
+ 	}
+ }
+ 
+ void wfx_configure_filter(struct ieee80211_hw *hw, unsigned int changed_flags,
+ 			  unsigned int *total_flags, u64 unused)
+ {
+ 	struct wfx_vif *wvif = NULL;
+ 	struct wfx_dev *wdev = hw->priv;
+ 	bool filter_bssid, filter_prbreq, filter_beacon;
+ 
+ 	/* Notes:
+ 	 *   - Probe responses (FIF_BCN_PRBRESP_PROMISC) are never filtered
+ 	 *   - PS-Poll (FIF_PSPOLL) are never filtered
+ 	 *   - RTS, CTS and Ack (FIF_CONTROL) are always filtered
+ 	 *   - Broken frames (FIF_FCSFAIL and FIF_PLCPFAIL) are always filtered
+ 	 *   - Firmware does (yet) allow to forward unicast traffic sent to other stations (aka.
+ 	 *     promiscuous mode)
+ 	 */
+ 	*total_flags &= FIF_BCN_PRBRESP_PROMISC | FIF_ALLMULTI | FIF_OTHER_BSS |
+ 			FIF_PROBE_REQ | FIF_PSPOLL;
+ 
+ 	mutex_lock(&wdev->conf_mutex);
+ 	while ((wvif = wvif_iterate(wdev, wvif)) != NULL) {
+ 		mutex_lock(&wvif->scan_lock);
+ 
+ 		/* Note: FIF_BCN_PRBRESP_PROMISC covers probe response and
+ 		 * beacons from other BSS
+ 		 */
+ 		if (*total_flags & FIF_BCN_PRBRESP_PROMISC)
+ 			filter_beacon = false;
+ 		else
+ 			filter_beacon = true;
+ 		wfx_filter_beacon(wvif, filter_beacon);
+ 
+ 		if (*total_flags & FIF_OTHER_BSS)
+ 			filter_bssid = false;
+ 		else
+ 			filter_bssid = true;
+ 
+ 		/* In AP mode, chip can reply to probe request itself */
+ 		if (*total_flags & FIF_PROBE_REQ && wvif->vif->type == NL80211_IFTYPE_AP) {
+ 			dev_dbg(wdev->dev, "do not forward probe request in AP mode\n");
+ 			*total_flags &= ~FIF_PROBE_REQ;
+ 		}
+ 
+ 		if (*total_flags & FIF_PROBE_REQ)
+ 			filter_prbreq = false;
+ 		else
+ 			filter_prbreq = true;
+ 		wfx_hif_set_rx_filter(wvif, filter_bssid, filter_prbreq);
+ 
+ 		mutex_unlock(&wvif->scan_lock);
+ 	}
+ 	mutex_unlock(&wdev->conf_mutex);
+ }
+ 
+ static int wfx_get_ps_timeout(struct wfx_vif *wvif, bool *enable_ps)
+ {
+ 	struct ieee80211_channel *chan0 = NULL, *chan1 = NULL;
+ 	struct ieee80211_conf *conf = &wvif->wdev->hw->conf;
+ 
+ 	WARN(!wvif->vif->bss_conf.assoc && enable_ps,
+ 	     "enable_ps is reliable only if associated");
+ 	if (wdev_to_wvif(wvif->wdev, 0))
+ 		chan0 = wdev_to_wvif(wvif->wdev, 0)->vif->bss_conf.chandef.chan;
+ 	if (wdev_to_wvif(wvif->wdev, 1))
+ 		chan1 = wdev_to_wvif(wvif->wdev, 1)->vif->bss_conf.chandef.chan;
+ 	if (chan0 && chan1 && wvif->vif->type != NL80211_IFTYPE_AP) {
+ 		if (chan0->hw_value == chan1->hw_value) {
+ 			/* It is useless to enable PS if channels are the same. */
+ 			if (enable_ps)
+ 				*enable_ps = false;
+ 			if (wvif->vif->bss_conf.assoc && wvif->vif->bss_conf.ps)
+ 				dev_info(wvif->wdev->dev, "ignoring requested PS mode");
+ 			return -1;
+ 		}
+ 		/* It is necessary to enable PS if channels are different. */
+ 		if (enable_ps)
+ 			*enable_ps = true;
+ 		if (wfx_api_older_than(wvif->wdev, 3, 2))
+ 			return 0;
+ 		else
+ 			return 30;
+ 	}
+ 	if (enable_ps)
+ 		*enable_ps = wvif->vif->bss_conf.ps;
+ 	if (wvif->vif->bss_conf.assoc && wvif->vif->bss_conf.ps)
+ 		return conf->dynamic_ps_timeout;
+ 	else
+ 		return -1;
+ }
+ 
+ int wfx_update_pm(struct wfx_vif *wvif)
+ {
+ 	int ps_timeout;
+ 	bool ps;
+ 
+ 	if (!wvif->vif->bss_conf.assoc)
+ 		return 0;
+ 	ps_timeout = wfx_get_ps_timeout(wvif, &ps);
+ 	if (!ps)
+ 		ps_timeout = 0;
+ 	WARN_ON(ps_timeout < 0);
+ 	if (wvif->uapsd_mask)
+ 		ps_timeout = 0;
+ 
+ 	if (!wait_for_completion_timeout(&wvif->set_pm_mode_complete, TU_TO_JIFFIES(512)))
+ 		dev_warn(wvif->wdev->dev, "timeout while waiting of set_pm_mode_complete\n");
+ 	return wfx_hif_set_pm(wvif, ps, ps_timeout);
+ }
+ 
+ int wfx_conf_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+ 		u16 queue, const struct ieee80211_tx_queue_params *params)
+ {
+ 	struct wfx_dev *wdev = hw->priv;
+ 	struct wfx_vif *wvif = (struct wfx_vif *)vif->drv_priv;
+ 	int old_uapsd = wvif->uapsd_mask;
+ 
+ 	WARN_ON(queue >= hw->queues);
+ 
+ 	mutex_lock(&wdev->conf_mutex);
+ 	assign_bit(queue, &wvif->uapsd_mask, params->uapsd);
+ 	wfx_hif_set_edca_queue_params(wvif, queue, params);
+ 	if (wvif->vif->type == NL80211_IFTYPE_STATION && old_uapsd != wvif->uapsd_mask) {
+ 		wfx_hif_set_uapsd_info(wvif, wvif->uapsd_mask);
+ 		wfx_update_pm(wvif);
+ 	}
+ 	mutex_unlock(&wdev->conf_mutex);
+ 	return 0;
+ }
+ 
+ int wfx_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
+ {
+ 	struct wfx_dev *wdev = hw->priv;
+ 	struct wfx_vif *wvif = NULL;
+ 
+ 	while ((wvif = wvif_iterate(wdev, wvif)) != NULL)
+ 		wfx_hif_rts_threshold(wvif, value);
+ 	return 0;
+ }
+ 
+ void wfx_event_report_rssi(struct wfx_vif *wvif, u8 raw_rcpi_rssi)
+ {
+ 	/* RSSI: signed Q8.0, RCPI: unsigned Q7.1
+ 	 * RSSI = RCPI / 2 - 110
+ 	 */
+ 	int rcpi_rssi;
+ 	int cqm_evt;
+ 
+ 	rcpi_rssi = raw_rcpi_rssi / 2 - 110;
+ 	if (rcpi_rssi <= wvif->vif->bss_conf.cqm_rssi_thold)
+ 		cqm_evt = NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW;
+ 	else
+ 		cqm_evt = NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH;
+ 	ieee80211_cqm_rssi_notify(wvif->vif, cqm_evt, rcpi_rssi, GFP_KERNEL);
+ }
+ 
+ static void wfx_beacon_loss_work(struct work_struct *work)
+ {
+ 	struct wfx_vif *wvif = container_of(to_delayed_work(work), struct wfx_vif,
+ 					    beacon_loss_work);
+ 	struct ieee80211_bss_conf *bss_conf = &wvif->vif->bss_conf;
+ 
+ 	ieee80211_beacon_loss(wvif->vif);
+ 	schedule_delayed_work(to_delayed_work(work), msecs_to_jiffies(bss_conf->beacon_int));
+ }
+ 
+ void wfx_set_default_unicast_key(struct ieee80211_hw *hw, struct ieee80211_vif *vif, int idx)
+ {
+ 	struct wfx_vif *wvif = (struct wfx_vif *)vif->drv_priv;
+ 
+ 	wfx_hif_wep_default_key_id(wvif, idx);
+ }
+ 
+ void wfx_reset(struct wfx_vif *wvif)
+ {
+ 	struct wfx_dev *wdev = wvif->wdev;
+ 
+ 	wfx_tx_lock_flush(wdev);
+ 	wfx_hif_reset(wvif, false);
+ 	wfx_tx_policy_init(wvif);
+ 	if (wvif_count(wdev) <= 1)
+ 		wfx_hif_set_block_ack_policy(wvif, 0xFF, 0xFF);
+ 	wfx_tx_unlock(wdev);
+ 	wvif->join_in_progress = false;
+ 	cancel_delayed_work_sync(&wvif->beacon_loss_work);
+ 	wvif =  NULL;
+ 	while ((wvif = wvif_iterate(wdev, wvif)) != NULL)
+ 		wfx_update_pm(wvif);
+ }
+ 
+ int wfx_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif, struct ieee80211_sta *sta)
+ {
+ 	struct wfx_vif *wvif = (struct wfx_vif *)vif->drv_priv;
+ 	struct wfx_sta_priv *sta_priv = (struct wfx_sta_priv *)&sta->drv_priv;
+ 
+ 	sta_priv->vif_id = wvif->id;
+ 
+ 	if (vif->type == NL80211_IFTYPE_STATION)
+ 		wfx_hif_set_mfp(wvif, sta->mfp, sta->mfp);
+ 
+ 	/* In station mode, the firmware interprets new link-id as a TDLS peer */
+ 	if (vif->type == NL80211_IFTYPE_STATION && !sta->tdls)
+ 		return 0;
+ 	sta_priv->link_id = ffz(wvif->link_id_map);
+ 	wvif->link_id_map |= BIT(sta_priv->link_id);
+ 	WARN_ON(!sta_priv->link_id);
+ 	WARN_ON(sta_priv->link_id >= HIF_LINK_ID_MAX);
+ 	wfx_hif_map_link(wvif, false, sta->addr, sta_priv->link_id, sta->mfp);
+ 
+ 	return 0;
+ }
+ 
+ int wfx_sta_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif, struct ieee80211_sta *sta)
+ {
+ 	struct wfx_vif *wvif = (struct wfx_vif *)vif->drv_priv;
+ 	struct wfx_sta_priv *sta_priv = (struct wfx_sta_priv *)&sta->drv_priv;
+ 
+ 	/* See note in wfx_sta_add() */
+ 	if (!sta_priv->link_id)
+ 		return 0;
+ 	/* FIXME add a mutex? */
+ 	wfx_hif_map_link(wvif, true, sta->addr, sta_priv->link_id, false);
+ 	wvif->link_id_map &= ~BIT(sta_priv->link_id);
+ 	return 0;
+ }
+ 
+ static int wfx_upload_ap_templates(struct wfx_vif *wvif)
+ {
+ 	struct sk_buff *skb;
+ 
+ 	skb = ieee80211_beacon_get(wvif->wdev->hw, wvif->vif);
+ 	if (!skb)
+ 		return -ENOMEM;
+ 	wfx_hif_set_template_frame(wvif, skb, HIF_TMPLT_BCN, API_RATE_INDEX_B_1MBPS);
+ 	dev_kfree_skb(skb);
+ 
+ 	skb = ieee80211_proberesp_get(wvif->wdev->hw, wvif->vif);
+ 	if (!skb)
+ 		return -ENOMEM;
+ 	wfx_hif_set_template_frame(wvif, skb, HIF_TMPLT_PRBRES, API_RATE_INDEX_B_1MBPS);
+ 	dev_kfree_skb(skb);
+ 	return 0;
+ }
+ 
+ static void wfx_set_mfp_ap(struct wfx_vif *wvif)
+ {
+ 	struct sk_buff *skb = ieee80211_beacon_get(wvif->wdev->hw, wvif->vif);
+ 	const int ieoffset = offsetof(struct ieee80211_mgmt, u.beacon.variable);
+ 	const u16 *ptr = (u16 *)cfg80211_find_ie(WLAN_EID_RSN, skb->data + ieoffset,
+ 						 skb->len - ieoffset);
+ 	const int pairwise_cipher_suite_count_offset = 8 / sizeof(u16);
+ 	const int pairwise_cipher_suite_size = 4 / sizeof(u16);
+ 	const int akm_suite_size = 4 / sizeof(u16);
+ 
+ 	if (ptr) {
+ 		ptr += pairwise_cipher_suite_count_offset;
+ 		if (WARN_ON(ptr > (u16 *)skb_tail_pointer(skb)))
+ 			return;
+ 		ptr += 1 + pairwise_cipher_suite_size * *ptr;
+ 		if (WARN_ON(ptr > (u16 *)skb_tail_pointer(skb)))
+ 			return;
+ 		ptr += 1 + akm_suite_size * *ptr;
+ 		if (WARN_ON(ptr > (u16 *)skb_tail_pointer(skb)))
+ 			return;
+ 		wfx_hif_set_mfp(wvif, *ptr & BIT(7), *ptr & BIT(6));
+ 	}
+ }
+ 
+ int wfx_start_ap(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
+ {
+ 	struct wfx_vif *wvif = (struct wfx_vif *)vif->drv_priv;
+ 	struct wfx_dev *wdev = wvif->wdev;
+ 	int ret;
+ 
+ 	wvif =  NULL;
+ 	while ((wvif = wvif_iterate(wdev, wvif)) != NULL)
+ 		wfx_update_pm(wvif);
+ 	wvif = (struct wfx_vif *)vif->drv_priv;
+ 	wfx_upload_ap_templates(wvif);
+ 	ret = wfx_hif_start(wvif, &vif->bss_conf, wvif->channel);
+ 	if (ret > 0)
+ 		return -EIO;
+ 	wfx_set_mfp_ap(wvif);
+ 	return ret;
+ }
+ 
+ void wfx_stop_ap(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
+ {
+ 	struct wfx_vif *wvif = (struct wfx_vif *)vif->drv_priv;
+ 
+ 	wfx_reset(wvif);
+ }
+ 
+ static void wfx_join(struct wfx_vif *wvif)
+ {
+ 	int ret;
+ 	struct ieee80211_bss_conf *conf = &wvif->vif->bss_conf;
+ 	struct cfg80211_bss *bss = NULL;
+ 	u8 ssid[IEEE80211_MAX_SSID_LEN];
 -	const u8 *ssidie = NULL;
 -	int ssidlen = 0;
++	const u8 *ssid_ie = NULL;
++	int ssid_len = 0;
+ 
+ 	wfx_tx_lock_flush(wvif->wdev);
+ 
+ 	bss = cfg80211_get_bss(wvif->wdev->hw->wiphy, wvif->channel, conf->bssid, NULL, 0,
+ 			       IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY);
+ 	if (!bss && !conf->ibss_joined) {
+ 		wfx_tx_unlock(wvif->wdev);
+ 		return;
+ 	}
+ 
 -	rcu_read_lock(); /* protect ssidie */
++	rcu_read_lock(); /* protect ssid_ie */
+ 	if (bss)
 -		ssidie = ieee80211_bss_get_ie(bss, WLAN_EID_SSID);
 -	if (ssidie) {
 -		ssidlen = ssidie[1];
 -		if (ssidlen > IEEE80211_MAX_SSID_LEN)
 -			ssidlen = IEEE80211_MAX_SSID_LEN;
 -		memcpy(ssid, &ssidie[2], ssidlen);
++		ssid_ie = ieee80211_bss_get_ie(bss, WLAN_EID_SSID);
++	if (ssid_ie) {
++		ssid_len = ssid_ie[1];
++		if (ssid_len > IEEE80211_MAX_SSID_LEN)
++			ssid_len = IEEE80211_MAX_SSID_LEN;
++		memcpy(ssid, &ssid_ie[2], ssid_len);
+ 	}
+ 	rcu_read_unlock();
+ 
+ 	cfg80211_put_bss(wvif->wdev->hw->wiphy, bss);
+ 
+ 	wvif->join_in_progress = true;
 -	ret = wfx_hif_join(wvif, conf, wvif->channel, ssid, ssidlen);
++	ret = wfx_hif_join(wvif, conf, wvif->channel, ssid, ssid_len);
+ 	if (ret) {
+ 		ieee80211_connection_loss(wvif->vif);
+ 		wfx_reset(wvif);
+ 	} else {
+ 		/* Due to beacon filtering it is possible that the AP's beacon is not known for the
+ 		 * mac80211 stack.  Disable filtering temporary to make sure the stack receives at
+ 		 * least one
+ 		 */
+ 		wfx_filter_beacon(wvif, false);
+ 	}
+ 	wfx_tx_unlock(wvif->wdev);
+ }
+ 
+ static void wfx_join_finalize(struct wfx_vif *wvif, struct ieee80211_bss_conf *info)
+ {
+ 	struct ieee80211_sta *sta = NULL;
+ 	int ampdu_density = 0;
+ 	bool greenfield = false;
+ 
+ 	rcu_read_lock(); /* protect sta */
+ 	if (info->bssid && !info->ibss_joined)
+ 		sta = ieee80211_find_sta(wvif->vif, info->bssid);
+ 	if (sta && sta->ht_cap.ht_supported)
+ 		ampdu_density = sta->ht_cap.ampdu_density;
+ 	if (sta && sta->ht_cap.ht_supported &&
+ 	    !(info->ht_operation_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT))
+ 		greenfield = !!(sta->ht_cap.cap & IEEE80211_HT_CAP_GRN_FLD);
+ 	rcu_read_unlock();
+ 
+ 	wvif->join_in_progress = false;
+ 	wfx_hif_set_association_mode(wvif, ampdu_density, greenfield, info->use_short_preamble);
+ 	wfx_hif_keep_alive_period(wvif, 0);
+ 	/* beacon_loss_count is defined to 7 in net/mac80211/mlme.c. Let's use the same value. */
+ 	wfx_hif_set_bss_params(wvif, info->aid, 7);
+ 	wfx_hif_set_beacon_wakeup_period(wvif, 1, 1);
+ 	wfx_update_pm(wvif);
+ }
+ 
+ int wfx_join_ibss(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
+ {
+ 	struct wfx_vif *wvif = (struct wfx_vif *)vif->drv_priv;
+ 
+ 	wfx_upload_ap_templates(wvif);
+ 	wfx_join(wvif);
+ 	return 0;
+ }
+ 
+ void wfx_leave_ibss(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
+ {
+ 	struct wfx_vif *wvif = (struct wfx_vif *)vif->drv_priv;
+ 
+ 	wfx_reset(wvif);
+ }
+ 
+ static void wfx_enable_beacon(struct wfx_vif *wvif, bool enable)
+ {
+ 	/* Driver has Content After DTIM Beacon in queue. Driver is waiting for a signal from the
+ 	 * firmware. Since we are going to stop to send beacons, this signal will never happens. See
+ 	 * also wfx_suspend_resume_mc()
+ 	 */
+ 	if (!enable && wfx_tx_queues_has_cab(wvif)) {
+ 		wvif->after_dtim_tx_allowed = true;
+ 		wfx_bh_request_tx(wvif->wdev);
+ 	}
+ 	wfx_hif_beacon_transmit(wvif, enable);
+ }
+ 
+ void wfx_bss_info_changed(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+ 			  struct ieee80211_bss_conf *info, u32 changed)
+ {
+ 	struct wfx_dev *wdev = hw->priv;
+ 	struct wfx_vif *wvif = (struct wfx_vif *)vif->drv_priv;
+ 	int i;
+ 
+ 	mutex_lock(&wdev->conf_mutex);
+ 
+ 	if (changed & BSS_CHANGED_BASIC_RATES ||
+ 	    changed & BSS_CHANGED_BEACON_INT ||
+ 	    changed & BSS_CHANGED_BSSID) {
+ 		if (vif->type == NL80211_IFTYPE_STATION)
+ 			wfx_join(wvif);
+ 	}
+ 
+ 	if (changed & BSS_CHANGED_ASSOC) {
+ 		if (info->assoc || info->ibss_joined)
+ 			wfx_join_finalize(wvif, info);
+ 		else if (!info->assoc && vif->type == NL80211_IFTYPE_STATION)
+ 			wfx_reset(wvif);
+ 		else
+ 			dev_warn(wdev->dev, "misunderstood change: ASSOC\n");
+ 	}
+ 
+ 	if (changed & BSS_CHANGED_BEACON_INFO) {
+ 		if (vif->type != NL80211_IFTYPE_STATION)
+ 			dev_warn(wdev->dev, "misunderstood change: BEACON_INFO\n");
+ 		wfx_hif_set_beacon_wakeup_period(wvif, info->dtim_period, info->dtim_period);
+ 		/* We temporary forwarded beacon for join process. It is now no more necessary. */
+ 		wfx_filter_beacon(wvif, true);
+ 	}
+ 
+ 	if (changed & BSS_CHANGED_ARP_FILTER) {
+ 		for (i = 0; i < HIF_MAX_ARP_IP_ADDRTABLE_ENTRIES; i++) {
+ 			__be32 *arp_addr = &info->arp_addr_list[i];
+ 
+ 			if (info->arp_addr_cnt > HIF_MAX_ARP_IP_ADDRTABLE_ENTRIES)
+ 				arp_addr = NULL;
+ 			if (i >= info->arp_addr_cnt)
+ 				arp_addr = NULL;
+ 			wfx_hif_set_arp_ipv4_filter(wvif, i, arp_addr);
+ 		}
+ 	}
+ 
+ 	if (changed & BSS_CHANGED_AP_PROBE_RESP || changed & BSS_CHANGED_BEACON)
+ 		wfx_upload_ap_templates(wvif);
+ 
+ 	if (changed & BSS_CHANGED_BEACON_ENABLED)
+ 		wfx_enable_beacon(wvif, info->enable_beacon);
+ 
+ 	if (changed & BSS_CHANGED_KEEP_ALIVE)
+ 		wfx_hif_keep_alive_period(wvif,
+ 					  info->max_idle_period * USEC_PER_TU / USEC_PER_MSEC);
+ 
+ 	if (changed & BSS_CHANGED_ERP_CTS_PROT)
+ 		wfx_hif_erp_use_protection(wvif, info->use_cts_prot);
+ 
+ 	if (changed & BSS_CHANGED_ERP_SLOT)
+ 		wfx_hif_slot_time(wvif, info->use_short_slot ? 9 : 20);
+ 
+ 	if (changed & BSS_CHANGED_CQM)
+ 		wfx_hif_set_rcpi_rssi_threshold(wvif, info->cqm_rssi_thold, info->cqm_rssi_hyst);
+ 
+ 	if (changed & BSS_CHANGED_TXPOWER)
+ 		wfx_hif_set_output_power(wvif, info->txpower);
+ 
+ 	if (changed & BSS_CHANGED_PS)
+ 		wfx_update_pm(wvif);
+ 
+ 	mutex_unlock(&wdev->conf_mutex);
+ }
+ 
+ static int wfx_update_tim(struct wfx_vif *wvif)
+ {
+ 	struct sk_buff *skb;
+ 	u16 tim_offset, tim_length;
+ 	u8 *tim_ptr;
+ 
+ 	skb = ieee80211_beacon_get_tim(wvif->wdev->hw, wvif->vif, &tim_offset, &tim_length);
+ 	if (!skb)
+ 		return -ENOENT;
+ 	tim_ptr = skb->data + tim_offset;
+ 
+ 	if (tim_offset && tim_length >= 6) {
+ 		/* Firmware handles DTIM counter internally */
+ 		tim_ptr[2] = 0;
+ 
+ 		/* Set/reset aid0 bit */
+ 		if (wfx_tx_queues_has_cab(wvif))
+ 			tim_ptr[4] |= 1;
+ 		else
+ 			tim_ptr[4] &= ~1;
+ 	}
+ 
+ 	wfx_hif_update_ie_beacon(wvif, tim_ptr, tim_length);
+ 	dev_kfree_skb(skb);
+ 
+ 	return 0;
+ }
+ 
+ static void wfx_update_tim_work(struct work_struct *work)
+ {
+ 	struct wfx_vif *wvif = container_of(work, struct wfx_vif, update_tim_work);
+ 
+ 	wfx_update_tim(wvif);
+ }
+ 
+ int wfx_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta, bool set)
+ {
+ 	struct wfx_dev *wdev = hw->priv;
+ 	struct wfx_sta_priv *sta_dev = (struct wfx_sta_priv *)&sta->drv_priv;
+ 	struct wfx_vif *wvif = wdev_to_wvif(wdev, sta_dev->vif_id);
+ 
+ 	if (!wvif) {
+ 		dev_warn(wdev->dev, "%s: received event for non-existent vif\n", __func__);
+ 		return -EIO;
+ 	}
+ 	schedule_work(&wvif->update_tim_work);
+ 	return 0;
+ }
+ 
+ void wfx_suspend_resume_mc(struct wfx_vif *wvif, enum sta_notify_cmd notify_cmd)
+ {
+ 	struct wfx_vif *wvif_it;
+ 
+ 	if (notify_cmd != STA_NOTIFY_AWAKE)
+ 		return;
+ 
+ 	/* Device won't be able to honor CAB if a scan is in progress on any interface. Prefer to
+ 	 * skip this DTIM and wait for the next one.
+ 	 */
+ 	wvif_it = NULL;
+ 	while ((wvif_it = wvif_iterate(wvif->wdev, wvif_it)) != NULL)
+ 		if (mutex_is_locked(&wvif_it->scan_lock))
+ 			return;
+ 
+ 	if (!wfx_tx_queues_has_cab(wvif) || wvif->after_dtim_tx_allowed)
+ 		dev_warn(wvif->wdev->dev, "incorrect sequence (%d CAB in queue)",
+ 			 wfx_tx_queues_has_cab(wvif));
+ 	wvif->after_dtim_tx_allowed = true;
+ 	wfx_bh_request_tx(wvif->wdev);
+ }
+ 
+ int wfx_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+ 		     struct ieee80211_ampdu_params *params)
+ {
+ 	/* Aggregation is implemented fully in firmware */
+ 	switch (params->action) {
+ 	case IEEE80211_AMPDU_RX_START:
+ 	case IEEE80211_AMPDU_RX_STOP:
+ 		/* Just acknowledge it to enable frame re-ordering */
+ 		return 0;
+ 	default:
+ 		/* Leave the firmware doing its business for tx aggregation */
+ 		return -EOPNOTSUPP;
+ 	}
+ }
+ 
+ int wfx_add_chanctx(struct ieee80211_hw *hw, struct ieee80211_chanctx_conf *conf)
+ {
+ 	return 0;
+ }
+ 
+ void wfx_remove_chanctx(struct ieee80211_hw *hw, struct ieee80211_chanctx_conf *conf)
+ {
+ }
+ 
+ void wfx_change_chanctx(struct ieee80211_hw *hw, struct ieee80211_chanctx_conf *conf, u32 changed)
+ {
+ }
+ 
+ int wfx_assign_vif_chanctx(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+ 			   struct ieee80211_chanctx_conf *conf)
+ {
+ 	struct wfx_vif *wvif = (struct wfx_vif *)vif->drv_priv;
+ 	struct ieee80211_channel *ch = conf->def.chan;
+ 
+ 	WARN(wvif->channel, "channel overwrite");
+ 	wvif->channel = ch;
+ 
+ 	return 0;
+ }
+ 
+ void wfx_unassign_vif_chanctx(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+ 			      struct ieee80211_chanctx_conf *conf)
+ {
+ 	struct wfx_vif *wvif = (struct wfx_vif *)vif->drv_priv;
+ 	struct ieee80211_channel *ch = conf->def.chan;
+ 
+ 	WARN(wvif->channel != ch, "channel mismatch");
+ 	wvif->channel = NULL;
+ }
+ 
+ int wfx_config(struct ieee80211_hw *hw, u32 changed)
+ {
+ 	return 0;
+ }
+ 
+ int wfx_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
+ {
+ 	int i;
+ 	struct wfx_dev *wdev = hw->priv;
+ 	struct wfx_vif *wvif = (struct wfx_vif *)vif->drv_priv;
+ 
+ 	vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER |
+ 			     IEEE80211_VIF_SUPPORTS_UAPSD |
+ 			     IEEE80211_VIF_SUPPORTS_CQM_RSSI;
+ 
+ 	mutex_lock(&wdev->conf_mutex);
+ 
+ 	switch (vif->type) {
+ 	case NL80211_IFTYPE_STATION:
+ 	case NL80211_IFTYPE_ADHOC:
+ 	case NL80211_IFTYPE_AP:
+ 		break;
+ 	default:
+ 		mutex_unlock(&wdev->conf_mutex);
+ 		return -EOPNOTSUPP;
+ 	}
+ 
+ 	/* FIXME: prefer use of container_of() to get vif */
+ 	wvif->vif = vif;
+ 	wvif->wdev = wdev;
+ 
+ 	wvif->link_id_map = 1; /* link-id 0 is reserved for multicast */
+ 	INIT_WORK(&wvif->update_tim_work, wfx_update_tim_work);
+ 	INIT_DELAYED_WORK(&wvif->beacon_loss_work, wfx_beacon_loss_work);
+ 
+ 	init_completion(&wvif->set_pm_mode_complete);
+ 	complete(&wvif->set_pm_mode_complete);
+ 	INIT_WORK(&wvif->tx_policy_upload_work, wfx_tx_policy_upload_work);
+ 
+ 	mutex_init(&wvif->scan_lock);
+ 	init_completion(&wvif->scan_complete);
+ 	INIT_WORK(&wvif->scan_work, wfx_hw_scan_work);
+ 
+ 	wfx_tx_queues_init(wvif);
+ 	wfx_tx_policy_init(wvif);
+ 
+ 	for (i = 0; i < ARRAY_SIZE(wdev->vif); i++) {
+ 		if (!wdev->vif[i]) {
+ 			wdev->vif[i] = vif;
+ 			wvif->id = i;
+ 			break;
+ 		}
+ 	}
+ 	WARN(i == ARRAY_SIZE(wdev->vif), "try to instantiate more vif than supported");
+ 
+ 	wfx_hif_set_macaddr(wvif, vif->addr);
+ 
+ 	mutex_unlock(&wdev->conf_mutex);
+ 
+ 	wvif = NULL;
+ 	while ((wvif = wvif_iterate(wdev, wvif)) != NULL) {
+ 		/* Combo mode does not support Block Acks. We can re-enable them */
+ 		if (wvif_count(wdev) == 1)
+ 			wfx_hif_set_block_ack_policy(wvif, 0xFF, 0xFF);
+ 		else
+ 			wfx_hif_set_block_ack_policy(wvif, 0x00, 0x00);
+ 	}
+ 	return 0;
+ }
+ 
+ void wfx_remove_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
+ {
+ 	struct wfx_dev *wdev = hw->priv;
+ 	struct wfx_vif *wvif = (struct wfx_vif *)vif->drv_priv;
+ 
+ 	wait_for_completion_timeout(&wvif->set_pm_mode_complete, msecs_to_jiffies(300));
+ 	wfx_tx_queues_check_empty(wvif);
+ 
+ 	mutex_lock(&wdev->conf_mutex);
+ 	WARN(wvif->link_id_map != 1, "corrupted state");
+ 
+ 	wfx_hif_reset(wvif, false);
+ 	wfx_hif_set_macaddr(wvif, NULL);
+ 	wfx_tx_policy_init(wvif);
+ 
+ 	cancel_delayed_work_sync(&wvif->beacon_loss_work);
+ 	wdev->vif[wvif->id] = NULL;
+ 	wvif->vif = NULL;
+ 
+ 	mutex_unlock(&wdev->conf_mutex);
+ 
+ 	wvif = NULL;
+ 	while ((wvif = wvif_iterate(wdev, wvif)) != NULL) {
+ 		/* Combo mode does not support Block Acks. We can re-enable them */
+ 		if (wvif_count(wdev) == 1)
+ 			wfx_hif_set_block_ack_policy(wvif, 0xFF, 0xFF);
+ 		else
+ 			wfx_hif_set_block_ack_policy(wvif, 0x00, 0x00);
+ 	}
+ }
+ 
+ int wfx_start(struct ieee80211_hw *hw)
+ {
+ 	return 0;
+ }
+ 
+ void wfx_stop(struct ieee80211_hw *hw)
+ {
+ 	struct wfx_dev *wdev = hw->priv;
+ 
+ 	WARN_ON(!skb_queue_empty_lockless(&wdev->tx_pending));
+ }