drivers/infiniband/hw/hns/hns_roce_cmd.c

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