[linux-block.git] / drivers / infiniband / hw / hns / hns_roce_cmd.c

/*
 * Copyright (c) 2016 Hisilicon Limited.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <linux/dmapool.h>
#include <linux/platform_device.h>
#include "hns_roce_common.h"
#include "hns_roce_device.h"
#include "hns_roce_cmd.h"

#define CMD_POLL_TOKEN		0xffff
#define CMD_MAX_NUM		32
#define CMD_TOKEN_MASK		0x1f

static int hns_roce_cmd_mbox_post_hw(struct hns_roce_dev *hr_dev, u64 in_param,
				     u64 out_param, u32 in_modifier,
				     u8 op_modifier, u16 op, u16 token,
				     int event)
{
	struct hns_roce_cmdq *cmd = &hr_dev->cmd;
	int ret;

	mutex_lock(&cmd->hcr_mutex);
	ret = hr_dev->hw->post_mbox(hr_dev, in_param, out_param, in_modifier,
				    op_modifier, op, token, event);
	mutex_unlock(&cmd->hcr_mutex);

	return ret;
}

/* this should be called with "poll_sem" */
static int __hns_roce_cmd_mbox_poll(struct hns_roce_dev *hr_dev, u64 in_param,
				    u64 out_param, unsigned long in_modifier,
				    u8 op_modifier, u16 op,
				    unsigned long timeout)
{
	struct device *dev = hr_dev->dev;
	int ret;

	ret = hns_roce_cmd_mbox_post_hw(hr_dev, in_param, out_param,
					in_modifier, op_modifier, op,
					CMD_POLL_TOKEN, 0);
	if (ret) {
		dev_err(dev, "[cmd_poll]hns_roce_cmd_mbox_post_hw failed\n");
		return ret;
	}

	return hr_dev->hw->chk_mbox(hr_dev, timeout);
}

static int hns_roce_cmd_mbox_poll(struct hns_roce_dev *hr_dev, u64 in_param,
				  u64 out_param, unsigned long in_modifier,
				  u8 op_modifier, u16 op, unsigned long timeout)
{
	int ret;

	down(&hr_dev->cmd.poll_sem);
	ret = __hns_roce_cmd_mbox_poll(hr_dev, in_param, out_param, in_modifier,
				       op_modifier, op, timeout);
	up(&hr_dev->cmd.poll_sem);

	return ret;
}

void hns_roce_cmd_event(struct hns_roce_dev *hr_dev, u16 token, u8 status,
			u64 out_param)
{
	struct hns_roce_cmd_context
		*context = &hr_dev->cmd.context[token & hr_dev->cmd.token_mask];

	if (token != context->token)
		return;

	context->result = (status == HNS_ROCE_CMD_SUCCESS) ? 0 : (-EIO);
	context->out_param = out_param;
	complete(&context->done);
}

/* this should be called with "use_events" */
static int __hns_roce_cmd_mbox_wait(struct hns_roce_dev *hr_dev, u64 in_param,
				    u64 out_param, unsigned long in_modifier,
				    u8 op_modifier, u16 op,
				    unsigned long timeout)
{
	struct hns_roce_cmdq *cmd = &hr_dev->cmd;
	struct hns_roce_cmd_context *context;
	struct device *dev = hr_dev->dev;
	int ret;

	spin_lock(&cmd->context_lock);
	WARN_ON(cmd->free_head < 0);
	context = &cmd->context[cmd->free_head];
	context->token += cmd->token_mask + 1;
	cmd->free_head = context->next;
	spin_unlock(&cmd->context_lock);

	init_completion(&context->done);

	ret = hns_roce_cmd_mbox_post_hw(hr_dev, in_param, out_param,
					in_modifier, op_modifier, op,
					context->token, 1);
	if (ret)
		goto out;

	/*
	 * It is timeout when wait_for_completion_timeout return 0
	 * The return value is the time limit set in advance
	 * how many seconds showing
	 */
	if (!wait_for_completion_timeout(&context->done,
					 msecs_to_jiffies(timeout))) {
		dev_err(dev, "[cmd]wait_for_completion_timeout timeout\n");
		ret = -EBUSY;
		goto out;
	}

	ret = context->result;
	if (ret) {
		dev_err(dev, "[cmd]event mod cmd process error!err=%d\n", ret);
		goto out;
	}

out:
	spin_lock(&cmd->context_lock);
	context->next = cmd->free_head;
	cmd->free_head = context - cmd->context;
	spin_unlock(&cmd->context_lock);

	return ret;
}

static int hns_roce_cmd_mbox_wait(struct hns_roce_dev *hr_dev, u64 in_param,
				  u64 out_param, unsigned long in_modifier,
				  u8 op_modifier, u16 op, unsigned long timeout)
{
	int ret;

	down(&hr_dev->cmd.event_sem);
	ret = __hns_roce_cmd_mbox_wait(hr_dev, in_param, out_param,
				       in_modifier, op_modifier, op, timeout);
	up(&hr_dev->cmd.event_sem);

	return ret;
}

int hns_roce_cmd_mbox(struct hns_roce_dev *hr_dev, u64 in_param, u64 out_param,
		      unsigned long in_modifier, u8 op_modifier, u16 op,
		      unsigned long timeout)
{
	int ret;

	if (hr_dev->hw->rst_prc_mbox) {
		ret = hr_dev->hw->rst_prc_mbox(hr_dev);
		if (ret == CMD_RST_PRC_SUCCESS)
			return 0;
		else if (ret == CMD_RST_PRC_EBUSY)
			return -EBUSY;
	}

	if (hr_dev->cmd.use_events)
		ret = hns_roce_cmd_mbox_wait(hr_dev, in_param, out_param,
					     in_modifier, op_modifier, op,
					     timeout);
	else
		ret = hns_roce_cmd_mbox_poll(hr_dev, in_param, out_param,
					     in_modifier, op_modifier, op,
					     timeout);

	if (ret == CMD_RST_PRC_EBUSY)
		return -EBUSY;

	if (ret && (hr_dev->hw->rst_prc_mbox &&
		    hr_dev->hw->rst_prc_mbox(hr_dev) == CMD_RST_PRC_SUCCESS))
		return 0;

	return ret;
}

int hns_roce_cmd_init(struct hns_roce_dev *hr_dev)
{
	struct device *dev = hr_dev->dev;

	mutex_init(&hr_dev->cmd.hcr_mutex);
	sema_init(&hr_dev->cmd.poll_sem, 1);
	hr_dev->cmd.use_events = 0;
	hr_dev->cmd.max_cmds = CMD_MAX_NUM;
	hr_dev->cmd.pool = dma_pool_create("hns_roce_cmd", dev,
					   HNS_ROCE_MAILBOX_SIZE,
					   HNS_ROCE_MAILBOX_SIZE, 0);
	if (!hr_dev->cmd.pool)
		return -ENOMEM;

	return 0;
}

void hns_roce_cmd_cleanup(struct hns_roce_dev *hr_dev)
{
	dma_pool_destroy(hr_dev->cmd.pool);
}

int hns_roce_cmd_use_events(struct hns_roce_dev *hr_dev)
{
	struct hns_roce_cmdq *hr_cmd = &hr_dev->cmd;
	int i;

	hr_cmd->context = kmalloc_array(hr_cmd->max_cmds,
					sizeof(*hr_cmd->context),
					GFP_KERNEL);
	if (!hr_cmd->context)
		return -ENOMEM;

	for (i = 0; i < hr_cmd->max_cmds; ++i) {
		hr_cmd->context[i].token = i;
		hr_cmd->context[i].next = i + 1;
	}

	hr_cmd->context[hr_cmd->max_cmds - 1].next = -1;
	hr_cmd->free_head = 0;

	sema_init(&hr_cmd->event_sem, hr_cmd->max_cmds);
	spin_lock_init(&hr_cmd->context_lock);

	hr_cmd->token_mask = CMD_TOKEN_MASK;
	hr_cmd->use_events = 1;

	return 0;
}

void hns_roce_cmd_use_polling(struct hns_roce_dev *hr_dev)
{
	struct hns_roce_cmdq *hr_cmd = &hr_dev->cmd;

	kfree(hr_cmd->context);
	hr_cmd->use_events = 0;
}

struct hns_roce_cmd_mailbox
	*hns_roce_alloc_cmd_mailbox(struct hns_roce_dev *hr_dev)
{
	struct hns_roce_cmd_mailbox *mailbox;

	mailbox = kmalloc(sizeof(*mailbox), GFP_KERNEL);
	if (!mailbox)
		return ERR_PTR(-ENOMEM);

	mailbox->buf = dma_pool_alloc(hr_dev->cmd.pool, GFP_KERNEL,
				      &mailbox->dma);
	if (!mailbox->buf) {
		kfree(mailbox);
		return ERR_PTR(-ENOMEM);
	}

	return mailbox;
}

void hns_roce_free_cmd_mailbox(struct hns_roce_dev *hr_dev,
			       struct hns_roce_cmd_mailbox *mailbox)
{
	if (!mailbox)
		return;

	dma_pool_free(hr_dev->cmd.pool, mailbox->buf, mailbox->dma);
	kfree(mailbox);
}
Commit	Line	Data
9a443537	1	/*
	2	* Copyright (c) 2016 Hisilicon Limited.
	3	*
	4	* This software is available to you under a choice of one of two
	5	* licenses. You may choose to be licensed under the terms of the GNU
	6	* General Public License (GPL) Version 2, available from the file
	7	* COPYING in the main directory of this source tree, or the
	8	* OpenIB.org BSD license below:
	9	*
	10	* Redistribution and use in source and binary forms, with or
	11	* without modification, are permitted provided that the following
	12	* conditions are met:
	13	*
	14	* - Redistributions of source code must retain the above
	15	* copyright notice, this list of conditions and the following
	16	* disclaimer.
	17	*
	18	* - Redistributions in binary form must reproduce the above
	19	* copyright notice, this list of conditions and the following
	20	* disclaimer in the documentation and/or other materials
	21	* provided with the distribution.
	22	*
	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	25	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	26	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	27	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	28	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	29	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	30	* SOFTWARE.
	31	*/
	32
	33	#include <linux/dmapool.h>
	34	#include <linux/platform_device.h>
	35	#include "hns_roce_common.h"
	36	#include "hns_roce_device.h"
	37	#include "hns_roce_cmd.h"
	38
	39	#define CMD_POLL_TOKEN 0xffff
	40	#define CMD_MAX_NUM 32
9a443537	41	#define CMD_TOKEN_MASK 0x1f
9a443537	42
	43	static int hns_roce_cmd_mbox_post_hw(struct hns_roce_dev *hr_dev, u64 in_param,
	44	u64 out_param, u32 in_modifier,
	45	u8 op_modifier, u16 op, u16 token,
	46	int event)
	47	{
	48	struct hns_roce_cmdq *cmd = &hr_dev->cmd;
a680f2f3	49	int ret;
9a443537	50
9a443537	51	mutex_lock(&cmd->hcr_mutex);
a680f2f3 WHX	52	ret = hr_dev->hw->post_mbox(hr_dev, in_param, out_param, in_modifier,
a680f2f3 WHX	53	op_modifier, op, token, event);
9a443537	54	mutex_unlock(&cmd->hcr_mutex);
	55
	56	return ret;
	57	}
	58
	59	/* this should be called with "poll_sem" */
	60	static int __hns_roce_cmd_mbox_poll(struct hns_roce_dev *hr_dev, u64 in_param,
	61	u64 out_param, unsigned long in_modifier,
	62	u8 op_modifier, u16 op,
	63	unsigned long timeout)
	64	{
13ca970e	65	struct device *dev = hr_dev->dev;
9a443537	66	int ret;
	67
	68	ret = hns_roce_cmd_mbox_post_hw(hr_dev, in_param, out_param,
	69	in_modifier, op_modifier, op,
	70	CMD_POLL_TOKEN, 0);
	71	if (ret) {
	72	dev_err(dev, "[cmd_poll]hns_roce_cmd_mbox_post_hw failed\n");
a680f2f3	73	return ret;
9a443537	74	}
9a443537	75
a680f2f3	76	return hr_dev->hw->chk_mbox(hr_dev, timeout);
9a443537	77	}
	78
	79	static int hns_roce_cmd_mbox_poll(struct hns_roce_dev *hr_dev, u64 in_param,
	80	u64 out_param, unsigned long in_modifier,
	81	u8 op_modifier, u16 op, unsigned long timeout)
	82	{
	83	int ret;
	84
	85	down(&hr_dev->cmd.poll_sem);
	86	ret = __hns_roce_cmd_mbox_poll(hr_dev, in_param, out_param, in_modifier,
	87	op_modifier, op, timeout);
	88	up(&hr_dev->cmd.poll_sem);
	89
	90	return ret;
	91	}
	92
	93	void hns_roce_cmd_event(struct hns_roce_dev *hr_dev, u16 token, u8 status,
	94	u64 out_param)
	95	{
	96	struct hns_roce_cmd_context
	97	*context = &hr_dev->cmd.context[token & hr_dev->cmd.token_mask];
	98
	99	if (token != context->token)
	100	return;
	101
	102	context->result = (status == HNS_ROCE_CMD_SUCCESS) ? 0 : (-EIO);
	103	context->out_param = out_param;
	104	complete(&context->done);
	105	}
	106
	107	/* this should be called with "use_events" */
	108	static int __hns_roce_cmd_mbox_wait(struct hns_roce_dev *hr_dev, u64 in_param,
	109	u64 out_param, unsigned long in_modifier,
	110	u8 op_modifier, u16 op,
	111	unsigned long timeout)
	112	{
	113	struct hns_roce_cmdq *cmd = &hr_dev->cmd;
9a443537	114	struct hns_roce_cmd_context *context;
13ca970e	115	struct device *dev = hr_dev->dev;
a680f2f3	116	int ret;
9a443537	117
	118	spin_lock(&cmd->context_lock);
	119	WARN_ON(cmd->free_head < 0);
	120	context = &cmd->context[cmd->free_head];
	121	context->token += cmd->token_mask + 1;
	122	cmd->free_head = context->next;
	123	spin_unlock(&cmd->context_lock);
	124
	125	init_completion(&context->done);
	126
	127	ret = hns_roce_cmd_mbox_post_hw(hr_dev, in_param, out_param,
	128	in_modifier, op_modifier, op,
	129	context->token, 1);
	130	if (ret)
	131	goto out;
	132
	133	/*
e84e40be S	134	* It is timeout when wait_for_completion_timeout return 0
	135	* The return value is the time limit set in advance
	136	* how many seconds showing
	137	*/
9a443537	138	if (!wait_for_completion_timeout(&context->done,
	139	msecs_to_jiffies(timeout))) {
	140	dev_err(dev, "[cmd]wait_for_completion_timeout timeout\n");
	141	ret = -EBUSY;
	142	goto out;
	143	}
	144
	145	ret = context->result;
	146	if (ret) {
	147	dev_err(dev, "[cmd]event mod cmd process error!err=%d\n", ret);
	148	goto out;
	149	}
	150
	151	out:
	152	spin_lock(&cmd->context_lock);
	153	context->next = cmd->free_head;
	154	cmd->free_head = context - cmd->context;
	155	spin_unlock(&cmd->context_lock);
	156
	157	return ret;
	158	}
	159
	160	static int hns_roce_cmd_mbox_wait(struct hns_roce_dev *hr_dev, u64 in_param,
	161	u64 out_param, unsigned long in_modifier,
	162	u8 op_modifier, u16 op, unsigned long timeout)
	163	{
617cf24f	164	int ret;
9a443537	165
	166	down(&hr_dev->cmd.event_sem);
	167	ret = __hns_roce_cmd_mbox_wait(hr_dev, in_param, out_param,
	168	in_modifier, op_modifier, op, timeout);
	169	up(&hr_dev->cmd.event_sem);
	170
	171	return ret;
	172	}
	173
	174	int hns_roce_cmd_mbox(struct hns_roce_dev *hr_dev, u64 in_param, u64 out_param,
	175	unsigned long in_modifier, u8 op_modifier, u16 op,
	176	unsigned long timeout)
	177	{
6a04aed6 WHX	178	int ret;
	179
	180	if (hr_dev->hw->rst_prc_mbox) {
	181	ret = hr_dev->hw->rst_prc_mbox(hr_dev);
	182	if (ret == CMD_RST_PRC_SUCCESS)
	183	return 0;
	184	else if (ret == CMD_RST_PRC_EBUSY)
	185	return -EBUSY;
	186	}
cb7a94c9	187
9a443537	188	if (hr_dev->cmd.use_events)
6a04aed6 WHX	189	ret = hns_roce_cmd_mbox_wait(hr_dev, in_param, out_param,
	190	in_modifier, op_modifier, op,
	191	timeout);
9a443537	192	else
6a04aed6 WHX	193	ret = hns_roce_cmd_mbox_poll(hr_dev, in_param, out_param,
	194	in_modifier, op_modifier, op,
	195	timeout);
	196
	197	if (ret == CMD_RST_PRC_EBUSY)
	198	return -EBUSY;
	199
	200	if (ret && (hr_dev->hw->rst_prc_mbox &&
	201	hr_dev->hw->rst_prc_mbox(hr_dev) == CMD_RST_PRC_SUCCESS))
	202	return 0;
	203
	204	return ret;
9a443537	205	}
	206
	207	int hns_roce_cmd_init(struct hns_roce_dev *hr_dev)
	208	{
13ca970e	209	struct device *dev = hr_dev->dev;
9a443537	210
	211	mutex_init(&hr_dev->cmd.hcr_mutex);
	212	sema_init(&hr_dev->cmd.poll_sem, 1);
	213	hr_dev->cmd.use_events = 0;
9a443537	214	hr_dev->cmd.max_cmds = CMD_MAX_NUM;
9a443537	215	hr_dev->cmd.pool = dma_pool_create("hns_roce_cmd", dev,
	216	HNS_ROCE_MAILBOX_SIZE,
	217	HNS_ROCE_MAILBOX_SIZE, 0);
	218	if (!hr_dev->cmd.pool)
	219	return -ENOMEM;
	220
	221	return 0;
	222	}
	223
	224	void hns_roce_cmd_cleanup(struct hns_roce_dev *hr_dev)
	225	{
	226	dma_pool_destroy(hr_dev->cmd.pool);
	227	}
	228
	229	int hns_roce_cmd_use_events(struct hns_roce_dev *hr_dev)
	230	{
	231	struct hns_roce_cmdq *hr_cmd = &hr_dev->cmd;
	232	int i;
	233
e1d717de ME	234	hr_cmd->context = kmalloc_array(hr_cmd->max_cmds,
	235	sizeof(*hr_cmd->context),
	236	GFP_KERNEL);
9a443537	237	if (!hr_cmd->context)
	238	return -ENOMEM;
	239
	240	for (i = 0; i < hr_cmd->max_cmds; ++i) {
	241	hr_cmd->context[i].token = i;
	242	hr_cmd->context[i].next = i + 1;
	243	}
	244
	245	hr_cmd->context[hr_cmd->max_cmds - 1].next = -1;
	246	hr_cmd->free_head = 0;
	247
	248	sema_init(&hr_cmd->event_sem, hr_cmd->max_cmds);
	249	spin_lock_init(&hr_cmd->context_lock);
	250
	251	hr_cmd->token_mask = CMD_TOKEN_MASK;
	252	hr_cmd->use_events = 1;
	253
9a443537	254	return 0;
	255	}
	256
	257	void hns_roce_cmd_use_polling(struct hns_roce_dev *hr_dev)
	258	{
	259	struct hns_roce_cmdq *hr_cmd = &hr_dev->cmd;
9a443537	260
9a443537	261	kfree(hr_cmd->context);
3d50503b	262	hr_cmd->use_events = 0;
9a443537	263	}
	264
	265	struct hns_roce_cmd_mailbox
	266	hns_roce_alloc_cmd_mailbox(struct hns_roce_dev hr_dev)
	267	{
	268	struct hns_roce_cmd_mailbox *mailbox;
	269
	270	mailbox = kmalloc(sizeof(*mailbox), GFP_KERNEL);
	271	if (!mailbox)
	272	return ERR_PTR(-ENOMEM);
	273
	274	mailbox->buf = dma_pool_alloc(hr_dev->cmd.pool, GFP_KERNEL,
	275	&mailbox->dma);
	276	if (!mailbox->buf) {
	277	kfree(mailbox);
	278	return ERR_PTR(-ENOMEM);
	279	}
	280
	281	return mailbox;
	282	}
	283
	284	void hns_roce_free_cmd_mailbox(struct hns_roce_dev *hr_dev,
	285	struct hns_roce_cmd_mailbox *mailbox)
	286	{
	287	if (!mailbox)
	288	return;
	289
	290	dma_pool_free(hr_dev->cmd.pool, mailbox->buf, mailbox->dma);
	291	kfree(mailbox);
	292	}