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 #define CMD_TOKEN_MASK 0x1f 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; 49 int ret; 50 51 mutex_lock(&cmd->hcr_mutex); 52 ret = hr_dev->hw->post_mbox(hr_dev, in_param, out_param, in_modifier, 53 op_modifier, op, token, event); 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 { 65 struct device *dev = hr_dev->dev; 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"); 73 return ret; 74 } 75 76 return hr_dev->hw->chk_mbox(hr_dev, timeout); 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 EXPORT_SYMBOL_GPL(hns_roce_cmd_event); 107 108 /* this should be called with "use_events" */ 109 static int __hns_roce_cmd_mbox_wait(struct hns_roce_dev *hr_dev, u64 in_param, 110 u64 out_param, unsigned long in_modifier, 111 u8 op_modifier, u16 op, 112 unsigned long timeout) 113 { 114 struct hns_roce_cmdq *cmd = &hr_dev->cmd; 115 struct hns_roce_cmd_context *context; 116 struct device *dev = hr_dev->dev; 117 int ret; 118 119 spin_lock(&cmd->context_lock); 120 WARN_ON(cmd->free_head < 0); 121 context = &cmd->context[cmd->free_head]; 122 context->token += cmd->token_mask + 1; 123 cmd->free_head = context->next; 124 spin_unlock(&cmd->context_lock); 125 126 init_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 goto out; 133 134 /* 135 * It is timeout when wait_for_completion_timeout return 0 136 * The return value is the time limit set in advance 137 * how many seconds showing 138 */ 139 if (!wait_for_completion_timeout(&context->done, 140 msecs_to_jiffies(timeout))) { 141 dev_err(dev, "[cmd]wait_for_completion_timeout timeout\n"); 142 ret = -EBUSY; 143 goto out; 144 } 145 146 ret = context->result; 147 if (ret) { 148 dev_err(dev, "[cmd]event mod cmd process error!err=%d\n", ret); 149 goto out; 150 } 151 152 out: 153 spin_lock(&cmd->context_lock); 154 context->next = cmd->free_head; 155 cmd->free_head = context - cmd->context; 156 spin_unlock(&cmd->context_lock); 157 158 return ret; 159 } 160 161 static int hns_roce_cmd_mbox_wait(struct hns_roce_dev *hr_dev, u64 in_param, 162 u64 out_param, unsigned long in_modifier, 163 u8 op_modifier, u16 op, unsigned long timeout) 164 { 165 int ret = 0; 166 167 down(&hr_dev->cmd.event_sem); 168 ret = __hns_roce_cmd_mbox_wait(hr_dev, in_param, out_param, 169 in_modifier, op_modifier, op, timeout); 170 up(&hr_dev->cmd.event_sem); 171 172 return ret; 173 } 174 175 int hns_roce_cmd_mbox(struct hns_roce_dev *hr_dev, u64 in_param, u64 out_param, 176 unsigned long in_modifier, u8 op_modifier, u16 op, 177 unsigned long timeout) 178 { 179 int ret; 180 181 if (hr_dev->hw->rst_prc_mbox) { 182 ret = hr_dev->hw->rst_prc_mbox(hr_dev); 183 if (ret == CMD_RST_PRC_SUCCESS) 184 return 0; 185 else if (ret == CMD_RST_PRC_EBUSY) 186 return -EBUSY; 187 } 188 189 if (hr_dev->cmd.use_events) 190 ret = hns_roce_cmd_mbox_wait(hr_dev, in_param, out_param, 191 in_modifier, op_modifier, op, 192 timeout); 193 else 194 ret = hns_roce_cmd_mbox_poll(hr_dev, in_param, out_param, 195 in_modifier, op_modifier, op, 196 timeout); 197 198 if (ret == CMD_RST_PRC_EBUSY) 199 return -EBUSY; 200 201 if (ret && (hr_dev->hw->rst_prc_mbox && 202 hr_dev->hw->rst_prc_mbox(hr_dev) == CMD_RST_PRC_SUCCESS)) 203 return 0; 204 205 return ret; 206 } 207 EXPORT_SYMBOL_GPL(hns_roce_cmd_mbox); 208 209 int hns_roce_cmd_init(struct hns_roce_dev *hr_dev) 210 { 211 struct device *dev = hr_dev->dev; 212 213 mutex_init(&hr_dev->cmd.hcr_mutex); 214 sema_init(&hr_dev->cmd.poll_sem, 1); 215 hr_dev->cmd.use_events = 0; 216 hr_dev->cmd.toggle = 1; 217 hr_dev->cmd.max_cmds = CMD_MAX_NUM; 218 hr_dev->cmd.pool = dma_pool_create("hns_roce_cmd", dev, 219 HNS_ROCE_MAILBOX_SIZE, 220 HNS_ROCE_MAILBOX_SIZE, 0); 221 if (!hr_dev->cmd.pool) 222 return -ENOMEM; 223 224 return 0; 225 } 226 227 void hns_roce_cmd_cleanup(struct hns_roce_dev *hr_dev) 228 { 229 dma_pool_destroy(hr_dev->cmd.pool); 230 } 231 232 int hns_roce_cmd_use_events(struct hns_roce_dev *hr_dev) 233 { 234 struct hns_roce_cmdq *hr_cmd = &hr_dev->cmd; 235 int i; 236 237 hr_cmd->context = kmalloc_array(hr_cmd->max_cmds, 238 sizeof(*hr_cmd->context), 239 GFP_KERNEL); 240 if (!hr_cmd->context) 241 return -ENOMEM; 242 243 for (i = 0; i < hr_cmd->max_cmds; ++i) { 244 hr_cmd->context[i].token = i; 245 hr_cmd->context[i].next = i + 1; 246 } 247 248 hr_cmd->context[hr_cmd->max_cmds - 1].next = -1; 249 hr_cmd->free_head = 0; 250 251 sema_init(&hr_cmd->event_sem, hr_cmd->max_cmds); 252 spin_lock_init(&hr_cmd->context_lock); 253 254 hr_cmd->token_mask = CMD_TOKEN_MASK; 255 hr_cmd->use_events = 1; 256 257 down(&hr_cmd->poll_sem); 258 259 return 0; 260 } 261 262 void hns_roce_cmd_use_polling(struct hns_roce_dev *hr_dev) 263 { 264 struct hns_roce_cmdq *hr_cmd = &hr_dev->cmd; 265 int i; 266 267 hr_cmd->use_events = 0; 268 269 for (i = 0; i < hr_cmd->max_cmds; ++i) 270 down(&hr_cmd->event_sem); 271 272 kfree(hr_cmd->context); 273 up(&hr_cmd->poll_sem); 274 } 275 276 struct hns_roce_cmd_mailbox 277 *hns_roce_alloc_cmd_mailbox(struct hns_roce_dev *hr_dev) 278 { 279 struct hns_roce_cmd_mailbox *mailbox; 280 281 mailbox = kmalloc(sizeof(*mailbox), GFP_KERNEL); 282 if (!mailbox) 283 return ERR_PTR(-ENOMEM); 284 285 mailbox->buf = dma_pool_alloc(hr_dev->cmd.pool, GFP_KERNEL, 286 &mailbox->dma); 287 if (!mailbox->buf) { 288 kfree(mailbox); 289 return ERR_PTR(-ENOMEM); 290 } 291 292 return mailbox; 293 } 294 EXPORT_SYMBOL_GPL(hns_roce_alloc_cmd_mailbox); 295 296 void hns_roce_free_cmd_mailbox(struct hns_roce_dev *hr_dev, 297 struct hns_roce_cmd_mailbox *mailbox) 298 { 299 if (!mailbox) 300 return; 301 302 dma_pool_free(hr_dev->cmd.pool, mailbox->buf, mailbox->dma); 303 kfree(mailbox); 304 } 305 EXPORT_SYMBOL_GPL(hns_roce_free_cmd_mailbox); 306