sys/dev/mlx5/mlx5_core/mlx5_srq.c

   1 /*-
   2  * Copyright (c) 2013-2015, Mellanox Technologies, Ltd.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS `AS IS' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  *
  25  * $FreeBSD$
  26  */
  27
  28 #include <linux/kernel.h>
  29 #include <linux/module.h>
  30 #include <dev/mlx5/driver.h>
  31 #include <dev/mlx5/srq.h>
  32 #include <rdma/ib_verbs.h>
  33 #include "mlx5_core.h"
  34 #include "transobj.h"
  35
  36 void mlx5_srq_event(struct mlx5_core_dev *dev, u32 srqn, int event_type)
  37 {
  38         struct mlx5_srq_table *table = &dev->priv.srq_table;
  39         struct mlx5_core_srq *srq;
  40
  41         spin_lock(&table->lock);
  42
  43         srq = radix_tree_lookup(&table->tree, srqn);
  44         if (srq)
  45                 atomic_inc(&srq->refcount);
  46
  47         spin_unlock(&table->lock);
  48
  49         if (!srq) {
  50                 mlx5_core_warn(dev, "Async event for bogus SRQ 0x%08x\n", srqn);
  51                 return;
  52         }
  53
  54         srq->event(srq, event_type);
  55
  56         if (atomic_dec_and_test(&srq->refcount))
  57                 complete(&srq->free);
  58 }
  59
  60 static void set_wq(void *wq, struct mlx5_srq_attr *in)
  61 {
  62         MLX5_SET(wq,   wq, wq_signature,  !!(in->flags & MLX5_SRQ_FLAG_WQ_SIG));
  63         MLX5_SET(wq,   wq, log_wq_pg_sz,  in->log_page_size);
  64         MLX5_SET(wq,   wq, log_wq_stride, in->wqe_shift + 4);
  65         MLX5_SET(wq,   wq, log_wq_sz,     in->log_size);
  66         MLX5_SET(wq,   wq, page_offset,   in->page_offset);
  67         MLX5_SET(wq,   wq, lwm,           in->lwm);
  68         MLX5_SET(wq,   wq, pd,            in->pd);
  69         MLX5_SET64(wq, wq, dbr_addr,      in->db_record);
  70 }
  71
  72 static void set_srqc(void *srqc, struct mlx5_srq_attr *in)
  73 {
  74         MLX5_SET(srqc,   srqc, wq_signature,  !!(in->flags & MLX5_SRQ_FLAG_WQ_SIG));
  75         MLX5_SET(srqc,   srqc, log_page_size, in->log_page_size);
  76         MLX5_SET(srqc,   srqc, log_rq_stride, in->wqe_shift);
  77         MLX5_SET(srqc,   srqc, log_srq_size,  in->log_size);
  78         MLX5_SET(srqc,   srqc, page_offset,   in->page_offset);
  79         MLX5_SET(srqc,   srqc, lwm,           in->lwm);
  80         MLX5_SET(srqc,   srqc, pd,            in->pd);
  81         MLX5_SET64(srqc, srqc, dbr_addr,      in->db_record);
  82         MLX5_SET(srqc,   srqc, xrcd,          in->xrcd);
  83         MLX5_SET(srqc,   srqc, cqn,           in->cqn);
  84 }
  85
  86 static void get_wq(void *wq, struct mlx5_srq_attr *in)
  87 {
  88         if (MLX5_GET(wq, wq, wq_signature))
  89                 in->flags &= MLX5_SRQ_FLAG_WQ_SIG;
  90         in->log_page_size = MLX5_GET(wq,   wq, log_wq_pg_sz);
  91         in->wqe_shift     = MLX5_GET(wq,   wq, log_wq_stride) - 4;
  92         in->log_size      = MLX5_GET(wq,   wq, log_wq_sz);
  93         in->page_offset   = MLX5_GET(wq,   wq, page_offset);
  94         in->lwm           = MLX5_GET(wq,   wq, lwm);
  95         in->pd            = MLX5_GET(wq,   wq, pd);
  96         in->db_record     = MLX5_GET64(wq, wq, dbr_addr);
  97 }
  98
  99 static void get_srqc(void *srqc, struct mlx5_srq_attr *in)
 100 {
 101         if (MLX5_GET(srqc, srqc, wq_signature))
 102                 in->flags &= MLX5_SRQ_FLAG_WQ_SIG;
 103         in->log_page_size = MLX5_GET(srqc,   srqc, log_page_size);
 104         in->wqe_shift     = MLX5_GET(srqc,   srqc, log_rq_stride);
 105         in->log_size      = MLX5_GET(srqc,   srqc, log_srq_size);
 106         in->page_offset   = MLX5_GET(srqc,   srqc, page_offset);
 107         in->lwm           = MLX5_GET(srqc,   srqc, lwm);
 108         in->pd            = MLX5_GET(srqc,   srqc, pd);
 109         in->db_record     = MLX5_GET64(srqc, srqc, dbr_addr);
 110 }
 111
 112 struct mlx5_core_srq *mlx5_core_get_srq(struct mlx5_core_dev *dev, u32 srqn)
 113 {
 114         struct mlx5_srq_table *table = &dev->priv.srq_table;
 115         struct mlx5_core_srq *srq;
 116
 117         spin_lock(&table->lock);
 118
 119         srq = radix_tree_lookup(&table->tree, srqn);
 120         if (srq)
 121                 atomic_inc(&srq->refcount);
 122
 123         spin_unlock(&table->lock);
 124
 125         return srq;
 126 }
 127 EXPORT_SYMBOL(mlx5_core_get_srq);
 128
 129 static int get_pas_size(struct mlx5_srq_attr *in)
 130 {
 131         u32 log_page_size = in->log_page_size + 12;
 132         u32 log_srq_size  = in->log_size;
 133         u32 log_rq_stride = in->wqe_shift;
 134         u32 page_offset   = in->page_offset;
 135         u32 po_quanta     = 1 << (log_page_size - 6);
 136         u32 rq_sz         = 1 << (log_srq_size + 4 + log_rq_stride);
 137         u32 page_size     = 1 << log_page_size;
 138         u32 rq_sz_po      = rq_sz + (page_offset * po_quanta);
 139         u32 rq_num_pas    = (rq_sz_po + page_size - 1) / page_size;
 140
 141         return rq_num_pas * sizeof(u64);
 142
 143 }
 144
 145 static int create_rmp_cmd(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 146                           struct mlx5_srq_attr *in)
 147 {
 148         void *create_in;
 149         void *rmpc;
 150         void *wq;
 151         int pas_size;
 152         int inlen;
 153         int err;
 154
 155         pas_size = get_pas_size(in);
 156         inlen = MLX5_ST_SZ_BYTES(create_rmp_in) + pas_size;
 157         create_in = mlx5_vzalloc(inlen);
 158         if (!create_in)
 159                 return -ENOMEM;
 160
 161         rmpc = MLX5_ADDR_OF(create_rmp_in, create_in, ctx);
 162         wq = MLX5_ADDR_OF(rmpc, rmpc, wq);
 163
 164         MLX5_SET(rmpc, rmpc, state, MLX5_RMPC_STATE_RDY);
 165         set_wq(wq, in);
 166         memcpy(MLX5_ADDR_OF(rmpc, rmpc, wq.pas), in->pas, pas_size);
 167
 168         err = mlx5_core_create_rmp(dev, create_in, inlen, &srq->srqn);
 169
 170         kvfree(create_in);
 171         return err;
 172 }
 173
 174 static int destroy_rmp_cmd(struct mlx5_core_dev *dev,
 175                             struct mlx5_core_srq *srq)
 176 {
 177         return mlx5_core_destroy_rmp(dev, srq->srqn);
 178 }
 179
 180 static int query_rmp_cmd(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 181                          struct mlx5_srq_attr *out)
 182 {
 183         u32 *rmp_out;
 184         void *rmpc;
 185         int err;
 186
 187         rmp_out =  mlx5_vzalloc(MLX5_ST_SZ_BYTES(query_rmp_out));
 188         if (!rmp_out)
 189                 return -ENOMEM;
 190
 191         err = mlx5_core_query_rmp(dev, srq->srqn, rmp_out);
 192         if (err)
 193                 goto out;
 194
 195         rmpc = MLX5_ADDR_OF(query_rmp_out, rmp_out, rmp_context);
 196         get_wq(MLX5_ADDR_OF(rmpc, rmpc, wq), out);
 197         if (MLX5_GET(rmpc, rmpc, state) != MLX5_RMPC_STATE_RDY)
 198                 out->flags |= MLX5_SRQ_FLAG_ERR;
 199
 200 out:
 201         kvfree(rmp_out);
 202         return 0;
 203 }
 204
 205 static int arm_rmp_cmd(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq, u16 lwm)
 206 {
 207         return mlx5_core_arm_rmp(dev, srq->srqn, lwm);
 208 }
 209
 210 static int create_xrc_srq_cmd(struct mlx5_core_dev *dev,
 211                               struct mlx5_core_srq *srq,
 212                               struct mlx5_srq_attr *in)
 213 {
 214         void *create_in;
 215         void *xrc_srqc;
 216         void *pas;
 217         int pas_size;
 218         int inlen;
 219         int err;
 220
 221         pas_size  = get_pas_size(in);
 222         inlen     = MLX5_ST_SZ_BYTES(create_xrc_srq_in) + pas_size;
 223         create_in = mlx5_vzalloc(inlen);
 224         if (!create_in)
 225                 return -ENOMEM;
 226
 227         xrc_srqc = MLX5_ADDR_OF(create_xrc_srq_in, create_in, xrc_srq_context_entry);
 228         pas      = MLX5_ADDR_OF(create_xrc_srq_in, create_in, pas);
 229
 230         set_srqc(xrc_srqc, in);
 231         MLX5_SET(xrc_srqc, xrc_srqc, user_index, in->user_index);
 232         memcpy(pas, in->pas, pas_size);
 233
 234         err = mlx5_core_create_xsrq(dev, create_in, inlen, &srq->srqn);
 235         if (err)
 236                 goto out;
 237
 238 out:
 239         kvfree(create_in);
 240         return err;
 241 }
 242
 243 static int destroy_xrc_srq_cmd(struct mlx5_core_dev *dev,
 244                                struct mlx5_core_srq *srq)
 245 {
 246         return mlx5_core_destroy_xsrq(dev, srq->srqn);
 247 }
 248
 249 static int query_xrc_srq_cmd(struct mlx5_core_dev *dev,
 250                              struct mlx5_core_srq *srq,
 251                              struct mlx5_srq_attr *out)
 252 {
 253         u32 *xrcsrq_out;
 254         void *xrc_srqc;
 255         int err;
 256
 257         xrcsrq_out = mlx5_vzalloc(MLX5_ST_SZ_BYTES(query_xrc_srq_out));
 258         if (!xrcsrq_out)
 259                 return -ENOMEM;
 260
 261         err = mlx5_core_query_xsrq(dev, srq->srqn, xrcsrq_out);
 262         if (err)
 263                 goto out;
 264
 265         xrc_srqc = MLX5_ADDR_OF(query_xrc_srq_out, xrcsrq_out,
 266                                 xrc_srq_context_entry);
 267         get_srqc(xrc_srqc, out);
 268         if (MLX5_GET(xrc_srqc, xrc_srqc, state) != MLX5_XRC_SRQC_STATE_GOOD)
 269                 out->flags |= MLX5_SRQ_FLAG_ERR;
 270
 271 out:
 272         kvfree(xrcsrq_out);
 273         return err;
 274 }
 275
 276 static int arm_xrc_srq_cmd(struct mlx5_core_dev *dev,
 277                            struct mlx5_core_srq *srq, u16 lwm)
 278 {
 279         return mlx5_core_arm_xsrq(dev, srq->srqn, lwm);
 280 }
 281
 282 static int create_srq_cmd(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 283                           struct mlx5_srq_attr *in)
 284 {
 285         u32 create_out[MLX5_ST_SZ_DW(create_srq_out)] = {0};
 286         void *create_in;
 287         void *srqc;
 288         void *pas;
 289         int pas_size;
 290         int inlen;
 291         int err;
 292
 293         pas_size  = get_pas_size(in);
 294         inlen     = MLX5_ST_SZ_BYTES(create_srq_in) + pas_size;
 295         create_in = mlx5_vzalloc(inlen);
 296         if (!create_in)
 297                 return -ENOMEM;
 298
 299         srqc = MLX5_ADDR_OF(create_srq_in, create_in, srq_context_entry);
 300         pas = MLX5_ADDR_OF(create_srq_in, create_in, pas);
 301
 302         set_srqc(srqc, in);
 303         memcpy(pas, in->pas, pas_size);
 304
 305         MLX5_SET(create_srq_in, create_in, opcode, MLX5_CMD_OP_CREATE_SRQ);
 306         err = mlx5_cmd_exec(dev, create_in, inlen, create_out, sizeof(create_out));
 307         kvfree(create_in);
 308         if (!err)
 309                 srq->srqn = MLX5_GET(create_srq_out, create_out, srqn);
 310
 311         return err;
 312 }
 313
 314 static int destroy_srq_cmd(struct mlx5_core_dev *dev,
 315                            struct mlx5_core_srq *srq)
 316 {
 317         u32 srq_out[MLX5_ST_SZ_DW(destroy_srq_out)] = {0};
 318         u32 srq_in[MLX5_ST_SZ_DW(destroy_srq_in)] = {0};
 319
 320         MLX5_SET(destroy_srq_in, srq_in, opcode, MLX5_CMD_OP_DESTROY_SRQ);
 321         MLX5_SET(destroy_srq_in, srq_in, srqn, srq->srqn);
 322
 323         return mlx5_cmd_exec(dev, srq_in, sizeof(srq_in), srq_out, sizeof(srq_out));
 324 }
 325
 326 static int query_srq_cmd(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 327                          struct mlx5_srq_attr *out)
 328 {
 329         u32 srq_in[MLX5_ST_SZ_DW(query_srq_in)] = {0};
 330         u32 *srq_out;
 331         void *srqc;
 332         int outlen = MLX5_ST_SZ_BYTES(query_srq_out);
 333         int err;
 334
 335         srq_out = mlx5_vzalloc(MLX5_ST_SZ_BYTES(query_srq_out));
 336         if (!srq_out)
 337                 return -ENOMEM;
 338
 339         MLX5_SET(query_srq_in, srq_in, opcode, MLX5_CMD_OP_QUERY_SRQ);
 340         MLX5_SET(query_srq_in, srq_in, srqn, srq->srqn);
 341         err =  mlx5_cmd_exec(dev, srq_in, sizeof(srq_in), srq_out, outlen);
 342         if (err)
 343                 goto out;
 344
 345         srqc = MLX5_ADDR_OF(query_srq_out, srq_out, srq_context_entry);
 346         get_srqc(srqc, out);
 347         if (MLX5_GET(srqc, srqc, state) != MLX5_SRQC_STATE_GOOD)
 348                 out->flags |= MLX5_SRQ_FLAG_ERR;
 349 out:
 350         kvfree(srq_out);
 351         return err;
 352 }
 353
 354 static int arm_srq_cmd(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 355                        u16 lwm, int is_srq)
 356 {
 357         /* arm_srq structs missing using identical xrc ones */
 358         u32 srq_in[MLX5_ST_SZ_DW(arm_xrc_srq_in)] = {0};
 359         u32 srq_out[MLX5_ST_SZ_DW(arm_xrc_srq_out)] = {0};
 360
 361         MLX5_SET(arm_xrc_srq_in, srq_in, opcode,   MLX5_CMD_OP_ARM_XRC_SRQ);
 362         MLX5_SET(arm_xrc_srq_in, srq_in, xrc_srqn, srq->srqn);
 363         MLX5_SET(arm_xrc_srq_in, srq_in, lwm,      lwm);
 364
 365         return  mlx5_cmd_exec(dev, srq_in, sizeof(srq_in), srq_out, sizeof(srq_out));
 366 }
 367
 368 static int create_srq_split(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 369                             struct mlx5_srq_attr *in)
 370 {
 371         if (!dev->issi)
 372                 return create_srq_cmd(dev, srq, in);
 373         else if (srq->common.res == MLX5_RES_XSRQ)
 374                 return create_xrc_srq_cmd(dev, srq, in);
 375         else
 376                 return create_rmp_cmd(dev, srq, in);
 377 }
 378
 379 static int destroy_srq_split(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq)
 380 {
 381         if (!dev->issi)
 382                 return destroy_srq_cmd(dev, srq);
 383         else if (srq->common.res == MLX5_RES_XSRQ)
 384                 return destroy_xrc_srq_cmd(dev, srq);
 385         else
 386                 return destroy_rmp_cmd(dev, srq);
 387 }
 388
 389 int mlx5_core_create_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 390                          struct mlx5_srq_attr *in)
 391 {
 392         int err;
 393         struct mlx5_srq_table *table = &dev->priv.srq_table;
 394
 395         if (in->type == IB_SRQT_XRC)
 396                 srq->common.res = MLX5_RES_XSRQ;
 397         else
 398                 srq->common.res = MLX5_RES_SRQ;
 399
 400         err = create_srq_split(dev, srq, in);
 401         if (err)
 402                 return err;
 403
 404         atomic_set(&srq->refcount, 1);
 405         init_completion(&srq->free);
 406
 407         spin_lock_irq(&table->lock);
 408         err = radix_tree_insert(&table->tree, srq->srqn, srq);
 409         spin_unlock_irq(&table->lock);
 410         if (err) {
 411                 mlx5_core_warn(dev, "err %d, srqn 0x%x\n", err, srq->srqn);
 412                 goto err_destroy_srq_split;
 413         }
 414
 415         return 0;
 416
 417 err_destroy_srq_split:
 418         destroy_srq_split(dev, srq);
 419
 420         return err;
 421 }
 422 EXPORT_SYMBOL(mlx5_core_create_srq);
 423
 424 int mlx5_core_destroy_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq)
 425 {
 426         struct mlx5_srq_table *table = &dev->priv.srq_table;
 427         struct mlx5_core_srq *tmp;
 428         int err;
 429
 430         spin_lock_irq(&table->lock);
 431         tmp = radix_tree_delete(&table->tree, srq->srqn);
 432         spin_unlock_irq(&table->lock);
 433         if (!tmp) {
 434                 mlx5_core_warn(dev, "srq 0x%x not found in tree\n", srq->srqn);
 435                 return -EINVAL;
 436         }
 437         if (tmp != srq) {
 438                 mlx5_core_warn(dev, "corruption on srqn 0x%x\n", srq->srqn);
 439                 return -EINVAL;
 440         }
 441
 442         err = destroy_srq_split(dev, srq);
 443         if (err)
 444                 return err;
 445
 446         if (atomic_dec_and_test(&srq->refcount))
 447                 complete(&srq->free);
 448         wait_for_completion(&srq->free);
 449
 450         return 0;
 451 }
 452 EXPORT_SYMBOL(mlx5_core_destroy_srq);
 453
 454 int mlx5_core_query_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 455                         struct mlx5_srq_attr *out)
 456 {
 457         if (!dev->issi)
 458                 return query_srq_cmd(dev, srq, out);
 459         else if (srq->common.res == MLX5_RES_XSRQ)
 460                 return query_xrc_srq_cmd(dev, srq, out);
 461         else
 462                 return query_rmp_cmd(dev, srq, out);
 463 }
 464 EXPORT_SYMBOL(mlx5_core_query_srq);
 465
 466 int mlx5_core_arm_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 467                       u16 lwm, int is_srq)
 468 {
 469         if (!dev->issi)
 470                 return arm_srq_cmd(dev, srq, lwm, is_srq);
 471         else if (srq->common.res == MLX5_RES_XSRQ)
 472                 return arm_xrc_srq_cmd(dev, srq, lwm);
 473         else
 474                 return arm_rmp_cmd(dev, srq, lwm);
 475 }
 476 EXPORT_SYMBOL(mlx5_core_arm_srq);
 477
 478 void mlx5_init_srq_table(struct mlx5_core_dev *dev)
 479 {
 480         struct mlx5_srq_table *table = &dev->priv.srq_table;
 481
 482         memset(table, 0, sizeof(*table));
 483         spin_lock_init(&table->lock);
 484         INIT_RADIX_TREE(&table->tree, GFP_ATOMIC);
 485 }
 486
 487 void mlx5_cleanup_srq_table(struct mlx5_core_dev *dev)
 488 {
 489         /* nothing */
 490 }