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