staging: wfx: allow to send commands to chip
Chip has multiple input buffers and can handle multiple 802.11 frames in parallel. However, other HIF command must be sent sequentially. wsm_send_cmd() handles these requests. This commit also add send_hif_cmd in debugfs. This file allows to send arbitrary commands to chip. It can be used for debug and testing. Signed-off-by: Jérôme Pouiller <jerome.pouiller@silabs.com> Link: https://lore.kernel.org/r/20190919142527.31797-12-Jerome.Pouiller@silabs.com Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Родитель
e16e7f0716
Коммит
4f8b7fabb1
|
@ -7,6 +7,7 @@ wfx-y := \
|
|||
bh.o \
|
||||
hwio.o \
|
||||
fwio.o \
|
||||
hif_tx.o \
|
||||
hif_rx.o \
|
||||
main.o \
|
||||
sta.o \
|
||||
|
|
|
@ -190,7 +190,10 @@ static int bh_work_tx(struct wfx_dev *wdev, int max_msg)
|
|||
for (i = 0; i < max_msg; i++) {
|
||||
hif = NULL;
|
||||
if (wdev->hif.tx_buffers_used < wdev->hw_caps.num_inp_ch_bufs) {
|
||||
/* FIXME: get queued data */
|
||||
if (try_wait_for_completion(&wdev->hif_cmd.ready)) {
|
||||
WARN(!mutex_is_locked(&wdev->hif_cmd.lock), "data locking error");
|
||||
hif = wdev->hif_cmd.buf_send;
|
||||
}
|
||||
}
|
||||
if (!hif)
|
||||
return i;
|
||||
|
|
|
@ -7,16 +7,146 @@
|
|||
*/
|
||||
#include <linux/debugfs.h>
|
||||
|
||||
#include "debug.h"
|
||||
#include "wfx.h"
|
||||
|
||||
#define CREATE_TRACE_POINTS
|
||||
#include "traces.h"
|
||||
|
||||
static const struct trace_print_flags hif_msg_print_map[] = {
|
||||
hif_msg_list,
|
||||
};
|
||||
|
||||
static const struct trace_print_flags hif_mib_print_map[] = {
|
||||
hif_mib_list,
|
||||
};
|
||||
|
||||
static const struct trace_print_flags wfx_reg_print_map[] = {
|
||||
wfx_reg_list,
|
||||
};
|
||||
|
||||
static const char *get_symbol(unsigned long val,
|
||||
const struct trace_print_flags *symbol_array)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; symbol_array[i].mask != -1; i++) {
|
||||
if (val == symbol_array[i].mask)
|
||||
return symbol_array[i].name;
|
||||
}
|
||||
|
||||
return "unknown";
|
||||
}
|
||||
|
||||
const char *get_hif_name(unsigned long id)
|
||||
{
|
||||
return get_symbol(id, hif_msg_print_map);
|
||||
}
|
||||
|
||||
const char *get_mib_name(unsigned long id)
|
||||
{
|
||||
return get_symbol(id, hif_mib_print_map);
|
||||
}
|
||||
|
||||
const char *get_reg_name(unsigned long id)
|
||||
{
|
||||
return get_symbol(id, wfx_reg_print_map);
|
||||
}
|
||||
|
||||
struct dbgfs_hif_msg {
|
||||
struct wfx_dev *wdev;
|
||||
struct completion complete;
|
||||
u8 reply[1024];
|
||||
int ret;
|
||||
};
|
||||
|
||||
static ssize_t wfx_send_hif_msg_write(struct file *file, const char __user *user_buf,
|
||||
size_t count, loff_t *ppos)
|
||||
{
|
||||
struct dbgfs_hif_msg *context = file->private_data;
|
||||
struct wfx_dev *wdev = context->wdev;
|
||||
struct hif_msg *request;
|
||||
|
||||
if (completion_done(&context->complete)) {
|
||||
dev_dbg(wdev->dev, "read previous result before start a new one\n");
|
||||
return -EBUSY;
|
||||
}
|
||||
if (count < sizeof(struct hif_msg))
|
||||
return -EINVAL;
|
||||
|
||||
// wfx_cmd_send() chekc that reply buffer is wide enough, but do not
|
||||
// return precise length read. User have to know how many bytes should
|
||||
// be read. Filling reply buffer with a memory pattern may help user.
|
||||
memset(context->reply, sizeof(context->reply), 0xFF);
|
||||
request = memdup_user(user_buf, count);
|
||||
if (IS_ERR(request))
|
||||
return PTR_ERR(request);
|
||||
if (request->len != count) {
|
||||
kfree(request);
|
||||
return -EINVAL;
|
||||
}
|
||||
context->ret = wfx_cmd_send(wdev, request, context->reply, sizeof(context->reply), false);
|
||||
|
||||
kfree(request);
|
||||
complete(&context->complete);
|
||||
return count;
|
||||
}
|
||||
|
||||
static ssize_t wfx_send_hif_msg_read(struct file *file, char __user *user_buf,
|
||||
size_t count, loff_t *ppos)
|
||||
{
|
||||
struct dbgfs_hif_msg *context = file->private_data;
|
||||
int ret;
|
||||
|
||||
if (count > sizeof(context->reply))
|
||||
return -EINVAL;
|
||||
ret = wait_for_completion_interruptible(&context->complete);
|
||||
if (ret)
|
||||
return ret;
|
||||
if (context->ret < 0)
|
||||
return context->ret;
|
||||
// Be carefull, write() is waiting for a full message while read()
|
||||
// only return a payload
|
||||
ret = copy_to_user(user_buf, context->reply, count);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
static int wfx_send_hif_msg_open(struct inode *inode, struct file *file)
|
||||
{
|
||||
struct dbgfs_hif_msg *context = kzalloc(sizeof(*context), GFP_KERNEL);
|
||||
|
||||
if (!context)
|
||||
return -ENOMEM;
|
||||
context->wdev = inode->i_private;
|
||||
init_completion(&context->complete);
|
||||
file->private_data = context;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int wfx_send_hif_msg_release(struct inode *inode, struct file *file)
|
||||
{
|
||||
struct dbgfs_hif_msg *context = file->private_data;
|
||||
|
||||
kfree(context);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct file_operations wfx_send_hif_msg_fops = {
|
||||
.open = wfx_send_hif_msg_open,
|
||||
.release = wfx_send_hif_msg_release,
|
||||
.write = wfx_send_hif_msg_write,
|
||||
.read = wfx_send_hif_msg_read,
|
||||
};
|
||||
|
||||
int wfx_debug_init(struct wfx_dev *wdev)
|
||||
{
|
||||
struct dentry *d;
|
||||
|
||||
d = debugfs_create_dir("wfx", wdev->hw->wiphy->debugfsdir);
|
||||
debugfs_create_file("send_hif_msg", 0600, d, wdev, &wfx_send_hif_msg_fops);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -12,4 +12,8 @@ struct wfx_dev;
|
|||
|
||||
int wfx_debug_init(struct wfx_dev *wdev);
|
||||
|
||||
const char *get_hif_name(unsigned long id);
|
||||
const char *get_mib_name(unsigned long id);
|
||||
const char *get_reg_name(unsigned long id);
|
||||
|
||||
#endif /* WFX_DEBUG_H */
|
||||
|
|
|
@ -13,6 +13,43 @@
|
|||
#include "wfx.h"
|
||||
#include "hif_api_cmd.h"
|
||||
|
||||
static int hif_generic_confirm(struct wfx_dev *wdev, struct hif_msg *hif, void *buf)
|
||||
{
|
||||
// All confirm messages start with status
|
||||
int status = le32_to_cpu(*((__le32 *) buf));
|
||||
int cmd = hif->id;
|
||||
int len = hif->len - 4; // drop header
|
||||
|
||||
WARN(!mutex_is_locked(&wdev->hif_cmd.lock), "data locking error");
|
||||
|
||||
if (!wdev->hif_cmd.buf_send) {
|
||||
dev_warn(wdev->dev, "unexpected confirmation: 0x%.2x\n", cmd);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (cmd != wdev->hif_cmd.buf_send->id) {
|
||||
dev_warn(wdev->dev, "chip response mismatch request: 0x%.2x vs 0x%.2x\n",
|
||||
cmd, wdev->hif_cmd.buf_send->id);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (wdev->hif_cmd.buf_recv) {
|
||||
if (wdev->hif_cmd.len_recv >= len)
|
||||
memcpy(wdev->hif_cmd.buf_recv, buf, len);
|
||||
else
|
||||
status = -ENOMEM;
|
||||
}
|
||||
wdev->hif_cmd.ret = status;
|
||||
|
||||
if (!wdev->hif_cmd.async) {
|
||||
complete(&wdev->hif_cmd.done);
|
||||
} else {
|
||||
wdev->hif_cmd.buf_send = NULL;
|
||||
mutex_unlock(&wdev->hif_cmd.lock);
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
static int hif_startup_indication(struct wfx_dev *wdev, struct hif_msg *hif, void *buf)
|
||||
{
|
||||
struct hif_ind_startup *body = buf;
|
||||
|
@ -44,6 +81,14 @@ void wfx_handle_rx(struct wfx_dev *wdev, struct sk_buff *skb)
|
|||
struct hif_msg *hif = (struct hif_msg *) skb->data;
|
||||
int hif_id = hif->id;
|
||||
|
||||
// Note: mutex_is_lock cause an implicit memory barrier that protect
|
||||
// buf_send
|
||||
if (mutex_is_locked(&wdev->hif_cmd.lock)
|
||||
&& wdev->hif_cmd.buf_send
|
||||
&& wdev->hif_cmd.buf_send->id == hif_id) {
|
||||
hif_generic_confirm(wdev, hif, hif->body);
|
||||
goto free;
|
||||
}
|
||||
for (i = 0; i < ARRAY_SIZE(hif_handlers); i++) {
|
||||
if (hif_handlers[i].msg_id == hif_id) {
|
||||
if (hif_handlers[i].handler)
|
||||
|
|
|
@ -0,0 +1,87 @@
|
|||
// SPDX-License-Identifier: GPL-2.0-only
|
||||
/*
|
||||
* Implementation of host-to-chip commands (aka request/confirmation) of WFxxx
|
||||
* Split Mac (WSM) API.
|
||||
*
|
||||
* Copyright (c) 2017-2019, Silicon Laboratories, Inc.
|
||||
* Copyright (c) 2010, ST-Ericsson
|
||||
*/
|
||||
#include <linux/skbuff.h>
|
||||
#include <linux/etherdevice.h>
|
||||
|
||||
#include "hif_tx.h"
|
||||
#include "wfx.h"
|
||||
#include "bh.h"
|
||||
#include "debug.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);
|
||||
}
|
||||
|
||||
int wfx_cmd_send(struct wfx_dev *wdev, struct hif_msg *request, void *reply, size_t reply_len, bool async)
|
||||
{
|
||||
const char *mib_name = "";
|
||||
const char *mib_sep = "";
|
||||
int cmd = request->id;
|
||||
int vif = request->interface;
|
||||
int ret;
|
||||
|
||||
WARN(wdev->hif_cmd.buf_recv && wdev->hif_cmd.async, "API usage error");
|
||||
|
||||
// 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;
|
||||
wdev->hif_cmd.async = async;
|
||||
complete(&wdev->hif_cmd.ready);
|
||||
|
||||
wfx_bh_request_tx(wdev);
|
||||
|
||||
// NOTE: no timeout is catched async is enabled
|
||||
if (async)
|
||||
return 0;
|
||||
|
||||
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");
|
||||
wdev->chip_frozen = 1;
|
||||
reinit_completion(&wdev->hif_cmd.done);
|
||||
ret = -ETIMEDOUT;
|
||||
} else {
|
||||
ret = wdev->hif_cmd.ret;
|
||||
}
|
||||
|
||||
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 = get_mib_name(((u16 *) request)[2]);
|
||||
mib_sep = "/";
|
||||
}
|
||||
if (ret < 0)
|
||||
dev_err(wdev->dev,
|
||||
"WSM request %s%s%s (%#.2x) on vif %d returned error %d\n",
|
||||
get_hif_name(cmd), mib_sep, mib_name, cmd, vif, ret);
|
||||
if (ret > 0)
|
||||
dev_warn(wdev->dev,
|
||||
"WSM request %s%s%s (%#.2x) on vif %d returned status %d\n",
|
||||
get_hif_name(cmd), mib_sep, mib_name, cmd, vif, ret);
|
||||
|
||||
return ret;
|
||||
}
|
|
@ -0,0 +1,33 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0-only */
|
||||
/*
|
||||
* Implementation of host-to-chip commands (aka request/confirmation) of WFxxx
|
||||
* Split Mac (WSM) API.
|
||||
*
|
||||
* Copyright (c) 2017-2019, Silicon Laboratories, Inc.
|
||||
* Copyright (c) 2010, ST-Ericsson
|
||||
* Copyright (C) 2010, ST-Ericsson SA
|
||||
*/
|
||||
#ifndef WFX_HIF_TX_H
|
||||
#define WFX_HIF_TX_H
|
||||
|
||||
#include "hif_api_cmd.h"
|
||||
|
||||
struct wfx_dev;
|
||||
struct wfx_vif;
|
||||
|
||||
struct wfx_hif_cmd {
|
||||
struct mutex lock;
|
||||
struct completion ready;
|
||||
struct completion done;
|
||||
bool async;
|
||||
struct hif_msg *buf_send;
|
||||
void *buf_recv;
|
||||
size_t len_recv;
|
||||
int ret;
|
||||
};
|
||||
|
||||
void wfx_init_hif_cmd(struct wfx_hif_cmd *wfx_hif_cmd);
|
||||
int wfx_cmd_send(struct wfx_dev *wdev, struct hif_msg *request,
|
||||
void *reply, size_t reply_len, bool async);
|
||||
|
||||
#endif
|
|
@ -115,6 +115,7 @@ struct wfx_dev *wfx_init_common(struct device *dev,
|
|||
memcpy(&wdev->pdata, pdata, sizeof(*pdata));
|
||||
|
||||
init_completion(&wdev->firmware_ready);
|
||||
wfx_init_hif_cmd(&wdev->hif_cmd);
|
||||
|
||||
return wdev;
|
||||
}
|
||||
|
|
|
@ -15,6 +15,7 @@
|
|||
|
||||
#include "bh.h"
|
||||
#include "main.h"
|
||||
#include "hif_tx.h"
|
||||
#include "hif_api_general.h"
|
||||
|
||||
struct hwbus_ops;
|
||||
|
@ -32,6 +33,9 @@ struct wfx_dev {
|
|||
struct completion firmware_ready;
|
||||
struct hif_ind_startup hw_caps;
|
||||
struct wfx_hif hif;
|
||||
int chip_frozen;
|
||||
|
||||
struct wfx_hif_cmd hif_cmd;
|
||||
};
|
||||
|
||||
struct wfx_vif {
|
||||
|
|
Загрузка…
Ссылка в новой задаче