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
41 
42 static int hns_roce_cmd_mbox_post_hw(struct hns_roce_dev *hr_dev, u64 in_param,
43 				     u64 out_param, u32 in_modifier,
44 				     u8 op_modifier, u16 op, u16 token,
45 				     int event)
46 {
47 	return hr_dev->hw->post_mbox(hr_dev, in_param, out_param, in_modifier,
48 				     op_modifier, op, token, event);
49 }
50 
51 /* this should be called with "poll_sem" */
52 static int __hns_roce_cmd_mbox_poll(struct hns_roce_dev *hr_dev, u64 in_param,
53 				    u64 out_param, unsigned long in_modifier,
54 				    u8 op_modifier, u16 op,
55 				    unsigned int timeout)
56 {
57 	int ret;
58 
59 	ret = hns_roce_cmd_mbox_post_hw(hr_dev, in_param, out_param,
60 					in_modifier, op_modifier, op,
61 					CMD_POLL_TOKEN, 0);
62 	if (ret) {
63 		dev_err_ratelimited(hr_dev->dev,
64 				    "failed to post mailbox %x in poll mode, ret = %d.\n",
65 				    op, ret);
66 		return ret;
67 	}
68 
69 	return hr_dev->hw->poll_mbox_done(hr_dev, timeout);
70 }
71 
72 static int hns_roce_cmd_mbox_poll(struct hns_roce_dev *hr_dev, u64 in_param,
73 				  u64 out_param, unsigned long in_modifier,
74 				  u8 op_modifier, u16 op, unsigned int timeout)
75 {
76 	int ret;
77 
78 	down(&hr_dev->cmd.poll_sem);
79 	ret = __hns_roce_cmd_mbox_poll(hr_dev, in_param, out_param, in_modifier,
80 				       op_modifier, op, timeout);
81 	up(&hr_dev->cmd.poll_sem);
82 
83 	return ret;
84 }
85 
86 void hns_roce_cmd_event(struct hns_roce_dev *hr_dev, u16 token, u8 status,
87 			u64 out_param)
88 {
89 	struct hns_roce_cmd_context *context =
90 		&hr_dev->cmd.context[token % hr_dev->cmd.max_cmds];
91 
92 	if (unlikely(token != context->token)) {
93 		dev_err_ratelimited(hr_dev->dev,
94 				    "[cmd] invalid ae token %x,context token is %x!\n",
95 				    token, context->token);
96 		return;
97 	}
98 
99 	context->result = (status == HNS_ROCE_CMD_SUCCESS) ? 0 : (-EIO);
100 	context->out_param = out_param;
101 	complete(&context->done);
102 }
103 
104 static int __hns_roce_cmd_mbox_wait(struct hns_roce_dev *hr_dev, u64 in_param,
105 				    u64 out_param, unsigned long in_modifier,
106 				    u8 op_modifier, u16 op,
107 				    unsigned int timeout)
108 {
109 	struct hns_roce_cmdq *cmd = &hr_dev->cmd;
110 	struct hns_roce_cmd_context *context;
111 	struct device *dev = hr_dev->dev;
112 	int ret;
113 
114 	spin_lock(&cmd->context_lock);
115 
116 	do {
117 		context = &cmd->context[cmd->free_head];
118 		cmd->free_head = context->next;
119 	} while (context->busy);
120 
121 	context->busy = 1;
122 	context->token += cmd->max_cmds;
123 
124 	spin_unlock(&cmd->context_lock);
125 
126 	reinit_completion(&context->done);
127 
128 	ret = hns_roce_cmd_mbox_post_hw(hr_dev, in_param, out_param,
129 					in_modifier, op_modifier, op,
130 					context->token, 1);
131 	if (ret) {
132 		dev_err_ratelimited(dev,
133 				    "failed to post mailbox %x in event mode, ret = %d.\n",
134 				    op, ret);
135 		goto out;
136 	}
137 
138 	if (!wait_for_completion_timeout(&context->done,
139 					 msecs_to_jiffies(timeout))) {
140 		dev_err_ratelimited(dev, "[cmd] token %x mailbox %x timeout.\n",
141 				    context->token, op);
142 		ret = -EBUSY;
143 		goto out;
144 	}
145 
146 	ret = context->result;
147 	if (ret)
148 		dev_err_ratelimited(dev, "[cmd] token %x mailbox %x error %d\n",
149 				    context->token, op, ret);
150 
151 out:
152 	context->busy = 0;
153 	return ret;
154 }
155 
156 static int hns_roce_cmd_mbox_wait(struct hns_roce_dev *hr_dev, u64 in_param,
157 				  u64 out_param, unsigned long in_modifier,
158 				  u8 op_modifier, u16 op, unsigned int timeout)
159 {
160 	int ret;
161 
162 	down(&hr_dev->cmd.event_sem);
163 	ret = __hns_roce_cmd_mbox_wait(hr_dev, in_param, out_param, in_modifier,
164 				       op_modifier, op, timeout);
165 	up(&hr_dev->cmd.event_sem);
166 
167 	return ret;
168 }
169 
170 int hns_roce_cmd_mbox(struct hns_roce_dev *hr_dev, u64 in_param, u64 out_param,
171 		      unsigned long in_modifier, u8 op_modifier, u16 op,
172 		      unsigned int timeout)
173 {
174 	bool is_busy;
175 
176 	if (hr_dev->hw->chk_mbox_avail)
177 		if (!hr_dev->hw->chk_mbox_avail(hr_dev, &is_busy))
178 			return is_busy ? -EBUSY : 0;
179 
180 	if (hr_dev->cmd.use_events)
181 		return hns_roce_cmd_mbox_wait(hr_dev, in_param, out_param,
182 					      in_modifier, op_modifier, op,
183 					      timeout);
184 	else
185 		return hns_roce_cmd_mbox_poll(hr_dev, in_param, out_param,
186 					      in_modifier, op_modifier, op,
187 					      timeout);
188 }
189 
190 int hns_roce_cmd_init(struct hns_roce_dev *hr_dev)
191 {
192 	sema_init(&hr_dev->cmd.poll_sem, 1);
193 	hr_dev->cmd.use_events = 0;
194 	hr_dev->cmd.max_cmds = CMD_MAX_NUM;
195 	hr_dev->cmd.pool = dma_pool_create("hns_roce_cmd", hr_dev->dev,
196 					   HNS_ROCE_MAILBOX_SIZE,
197 					   HNS_ROCE_MAILBOX_SIZE, 0);
198 	if (!hr_dev->cmd.pool)
199 		return -ENOMEM;
200 
201 	return 0;
202 }
203 
204 void hns_roce_cmd_cleanup(struct hns_roce_dev *hr_dev)
205 {
206 	dma_pool_destroy(hr_dev->cmd.pool);
207 }
208 
209 int hns_roce_cmd_use_events(struct hns_roce_dev *hr_dev)
210 {
211 	struct hns_roce_cmdq *hr_cmd = &hr_dev->cmd;
212 	int i;
213 
214 	hr_cmd->context =
215 		kcalloc(hr_cmd->max_cmds, sizeof(*hr_cmd->context), GFP_KERNEL);
216 	if (!hr_cmd->context)
217 		return -ENOMEM;
218 
219 	for (i = 0; i < hr_cmd->max_cmds; ++i) {
220 		hr_cmd->context[i].token = i;
221 		hr_cmd->context[i].next = i + 1;
222 		init_completion(&hr_cmd->context[i].done);
223 	}
224 	hr_cmd->context[hr_cmd->max_cmds - 1].next = 0;
225 	hr_cmd->free_head = 0;
226 
227 	sema_init(&hr_cmd->event_sem, hr_cmd->max_cmds);
228 	spin_lock_init(&hr_cmd->context_lock);
229 
230 	hr_cmd->use_events = 1;
231 	down(&hr_cmd->poll_sem);
232 
233 	return 0;
234 }
235 
236 void hns_roce_cmd_use_polling(struct hns_roce_dev *hr_dev)
237 {
238 	struct hns_roce_cmdq *hr_cmd = &hr_dev->cmd;
239 
240 	kfree(hr_cmd->context);
241 	hr_cmd->use_events = 0;
242 
243 	up(&hr_cmd->poll_sem);
244 }
245 
246 struct hns_roce_cmd_mailbox *
247 hns_roce_alloc_cmd_mailbox(struct hns_roce_dev *hr_dev)
248 {
249 	struct hns_roce_cmd_mailbox *mailbox;
250 
251 	mailbox = kmalloc(sizeof(*mailbox), GFP_KERNEL);
252 	if (!mailbox)
253 		return ERR_PTR(-ENOMEM);
254 
255 	mailbox->buf =
256 		dma_pool_alloc(hr_dev->cmd.pool, GFP_KERNEL, &mailbox->dma);
257 	if (!mailbox->buf) {
258 		kfree(mailbox);
259 		return ERR_PTR(-ENOMEM);
260 	}
261 
262 	return mailbox;
263 }
264 
265 void hns_roce_free_cmd_mailbox(struct hns_roce_dev *hr_dev,
266 			       struct hns_roce_cmd_mailbox *mailbox)
267 {
268 	if (!mailbox)
269 		return;
270 
271 	dma_pool_free(hr_dev->cmd.pool, mailbox->buf, mailbox->dma);
272 	kfree(mailbox);
273 }
274