Commit 4f8b7fab authored by Jérôme Pouiller's avatar Jérôme Pouiller Committed by Greg Kroah-Hartman
Browse files

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: default avatarJérôme Pouiller <jerome.pouiller@silabs.com>
Link: https://lore.kernel.org/r/20190919142527.31797-12-Jerome.Pouiller@silabs.com


Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent e16e7f07

drivers/staging/wfx/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -7,6 +7,7 @@ wfx-y := \ 
	bh.o \

	hwio.o \

	fwio.o \

	hif_tx.o \

	hif_rx.o \

	main.o \

	sta.o \

drivers/staging/wfx/bh.c

+4 −1
Original line number Diff line number Diff line
@@ -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;

drivers/staging/wfx/debug.c

+130 −0
Original line number Diff line number Diff line
@@ -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;

}

drivers/staging/wfx/debug.h

+4 −0
Original line number Diff line number Diff line
@@ -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 */

drivers/staging/wfx/hif_rx.c

+45 −0
Original line number Diff line number Diff line
@@ -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)

CRA Git | Maintained and supported by SUSTech CRA and CCSE