iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

staging: wfx: simplify hif_scan() usage

Browse Source 
The structures hif_req_start_scan and hif_ssid_def come from hardware
API. It is not intended to be manipulated in upper layers of the driver.

So, this patch relocate handling of theses structures to hif_scan()
(the low level function). This change also allows to drop struct
wfx_scan_params.

Signed-off-by: Jérôme Pouiller <jerome.pouiller@silabs.com>
Link: https://lore.kernel.org/r/20191217161318.31402-48-Jerome.Pouiller@silabs.com
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Jérôme Pouiller 2019-12-17 16:15:32 +00:00 committed by Greg Kroah-Hartman
parent 1a53df5534
commit 945ce30aa5
4 changed files with 57 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
drivers/staging/wfx/hif_tx.c
View File

@ -220,41 +220,59 @@ int hif_write_mib(struct wfx_dev *wdev, int vif_id, u16 mib_id, void *val,
return ret;
}
int hif_scan(struct wfx_vif *wvif, const struct wfx_scan_params *arg)
int hif_scan(struct wfx_vif *wvif, struct cfg80211_scan_request *req,
int chan_start_idx, int chan_num)
{
int ret, i;
struct hif_msg *hif;
struct hif_ssid_def *ssids;
size_t buf_len = sizeof(struct hif_req_start_scan) +
arg->scan_req.num_of_channels * sizeof(u8) +
arg->scan_req.num_of_ssids * sizeof(struct hif_ssid_def);
struct hif_req_start_scan *body = wfx_alloc_hif(buf_len, &hif);
u8 *ptr = (u8 *) body + sizeof(*body);
size_t buf_len =
sizeof(struct hif_req_start_scan_alt) + chan_num * sizeof(u8);
struct hif_req_start_scan_alt *body = wfx_alloc_hif(buf_len, &hif);
int tmo_chan_fg, tmo_chan_bg, tmo;
WARN(arg->scan_req.num_of_channels > HIF_API_MAX_NB_CHANNELS, "invalid params");
WARN(arg->scan_req.num_of_ssids > 2, "invalid params");
WARN(arg->scan_req.band > 1, "invalid params");
WARN(chan_num > HIF_API_MAX_NB_CHANNELS, "invalid params");
WARN(req->n_ssids > HIF_API_MAX_NB_SSIDS, "invalid params");
compiletime_assert(IEEE80211_MAX_SSID_LEN == HIF_API_SSID_SIZE,
"API inconsistency");
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;
// Background scan is always a good idea
body->scan_type.type = 1;
body->scan_flags.fbg = 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;
}
tmo_chan_bg = le32_to_cpu(body->max_channel_time) * USEC_PER_TU;
tmo_chan_fg = 512 * USEC_PER_TU + body->probe_delay;
tmo_chan_fg *= body->num_of_probe_requests;
tmo = chan_num * max(tmo_chan_bg, tmo_chan_fg);
// FIXME: This API is unnecessary complex, fixing NumOfChannels and
// adding a member SsidDef at end of struct hif_req_start_scan would
// simplify that a lot.
memcpy(body, &arg->scan_req, sizeof(*body));
cpu_to_le32s(&body->min_channel_time);
cpu_to_le32s(&body->max_channel_time);
cpu_to_le32s(&body->tx_power_level);
memcpy(ptr, arg->ssids,
arg->scan_req.num_of_ssids * sizeof(struct hif_ssid_def));
ssids = (struct hif_ssid_def *) ptr;
for (i = 0; i < body->num_of_ssids; ++i)
cpu_to_le32s(&ssids[i].ssid_length);
ptr += arg->scan_req.num_of_ssids * sizeof(struct hif_ssid_def);
memcpy(ptr, arg->ch, arg->scan_req.num_of_channels * sizeof(u8));
ptr += arg->scan_req.num_of_channels * sizeof(u8);
WARN(buf_len != ptr - (u8 *) body, "allocation size mismatch");
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;
return ret ? ret : usecs_to_jiffies(tmo);
}
int hif_stop_scan(struct wfx_vif *wvif)

10
drivers/staging/wfx/hif_tx.h
View File

@ -13,15 +13,10 @@
#include "hif_api_cmd.h"
struct ieee80211_tx_queue_params;
struct cfg80211_scan_request;
struct wfx_dev;
struct wfx_vif;
struct wfx_scan_params {
struct hif_req_start_scan scan_req;
struct hif_ssid_def *ssids;
u8 *ch;
};
struct wfx_hif_cmd {
struct mutex lock;
struct mutex key_renew_lock;
@ -45,7 +40,8 @@ int hif_read_mib(struct wfx_dev *wdev, int vif_id, u16 mib_id,
void *buf, size_t buf_size);
int hif_write_mib(struct wfx_dev *wdev, int vif_id, u16 mib_id,
void *buf, size_t buf_size);
int hif_scan(struct wfx_vif *wvif, const struct wfx_scan_params *arg);
int hif_scan(struct wfx_vif *wvif, struct cfg80211_scan_request *req80211,
int chan_start, int chan_num);
int hif_stop_scan(struct wfx_vif *wvif);
int hif_join(struct wfx_vif *wvif, const struct hif_req_join *arg);
int hif_set_pm(struct wfx_vif *wvif, bool ps, int dynamic_ps_timeout);

54
drivers/staging/wfx/scan.c
View File

@ -34,19 +34,18 @@ static void wfx_scan_restart_delayed(struct wfx_vif *wvif)
}
}
static int wfx_scan_start(struct wfx_vif *wvif, struct wfx_scan_params *scan)
static int wfx_scan_start(struct wfx_vif *wvif,
int chan_start_idx, int chan_num)
{
int tmo = 500;
int tmo;
if (wvif->state == WFX_STATE_PRE_STA)
return -EBUSY;
tmo += scan->scan_req.num_of_channels *
((20 * (scan->scan_req.max_channel_time)) + 10);
atomic_set(&wvif->scan.in_progress, 1);
schedule_delayed_work(&wvif->scan.timeout, msecs_to_jiffies(tmo));
hif_scan(wvif, scan);
tmo = hif_scan(wvif, wvif->scan.req, chan_start_idx, chan_num);
schedule_delayed_work(&wvif->scan.timeout, tmo);
return 0;
}
@ -128,9 +127,6 @@ 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;
@ -173,48 +169,14 @@ void wfx_scan_work(struct work_struct *work)
(*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_ssids = 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;
// FIXME: Check if FW can do active scan while joined.
if (wvif->state == WFX_STATE_STA) {
scan.scan_req.scan_type.type = 1;
scan.scan_req.scan_flags.fbg = 1;
}
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);
wvif->scan.status = wfx_scan_start(wvif,
wvif->scan.curr - wvif->scan.begin,
it - wvif->scan.curr);
if (wvif->scan.status)
goto fail;
wvif->scan.curr = it;

1
drivers/staging/wfx/wfx.h
View File

@ -27,6 +27,7 @@
#include "hif_api_general.h"
#define USEC_PER_TXOP 32 // see struct ieee80211_tx_queue_params
#define USEC_PER_TU 1024
struct hwbus_ops;