drivers/net/ethernet/mellanox/mlx5/core/srq.c

   1 /*
   2  * Copyright (c) 2013-2015, Mellanox Technologies. All rights reserved.
   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/kernel.h>
  34 #include <linux/module.h>
  35 #include <linux/mlx5/driver.h>
  36 #include <linux/mlx5/cmd.h>
  37 #include <linux/mlx5/srq.h>
  38 #include <rdma/ib_verbs.h>
  39 #include "mlx5_core.h"
  40 #include <linux/mlx5/transobj.h>
  41
  42 void mlx5_srq_event(struct mlx5_core_dev *dev, u32 srqn, int event_type)
  43 {
  44         struct mlx5_srq_table *table = &dev->priv.srq_table;
  45         struct mlx5_core_srq *srq;
  46
  47         spin_lock(&table->lock);
  48
  49         srq = radix_tree_lookup(&table->tree, srqn);
  50         if (srq)
  51                 atomic_inc(&srq->refcount);
  52
  53         spin_unlock(&table->lock);
  54
  55         if (!srq) {
  56                 mlx5_core_warn(dev, "Async event for bogus SRQ 0x%08x\n", srqn);
  57                 return;
  58         }
  59
  60         srq->event(srq, event_type);
  61
  62         if (atomic_dec_and_test(&srq->refcount))
  63                 complete(&srq->free);
  64 }
  65
  66 static int get_pas_size(void *srqc)
  67 {
  68         u32 log_page_size = MLX5_GET(srqc, srqc, log_page_size) + 12;
  69         u32 log_srq_size  = MLX5_GET(srqc, srqc, log_srq_size);
  70         u32 log_rq_stride = MLX5_GET(srqc, srqc, log_rq_stride);
  71         u32 page_offset   = MLX5_GET(srqc, srqc, page_offset);
  72         u32 po_quanta     = 1 << (log_page_size - 6);
  73         u32 rq_sz         = 1 << (log_srq_size + 4 + log_rq_stride);
  74         u32 page_size     = 1 << log_page_size;
  75         u32 rq_sz_po      = rq_sz + (page_offset * po_quanta);
  76         u32 rq_num_pas    = (rq_sz_po + page_size - 1) / page_size;
  77
  78         return rq_num_pas * sizeof(u64);
  79 }
  80
  81 static void rmpc_srqc_reformat(void *srqc, void *rmpc, bool srqc_to_rmpc)
  82 {
  83         void *wq = MLX5_ADDR_OF(rmpc, rmpc, wq);
  84
  85         if (srqc_to_rmpc) {
  86                 switch (MLX5_GET(srqc, srqc, state)) {
  87                 case MLX5_SRQC_STATE_GOOD:
  88                         MLX5_SET(rmpc, rmpc, state, MLX5_RMPC_STATE_RDY);
  89                         break;
  90                 case MLX5_SRQC_STATE_ERROR:
  91                         MLX5_SET(rmpc, rmpc, state, MLX5_RMPC_STATE_ERR);
  92                         break;
  93                 default:
  94                         pr_warn("%s: %d: Unknown srq state = 0x%x\n", __func__,
  95                                 __LINE__, MLX5_GET(srqc, srqc, state));
  96                         MLX5_SET(rmpc, rmpc, state, MLX5_GET(srqc, srqc, state));
  97                 }
  98
  99                 MLX5_SET(wq,   wq, wq_signature,  MLX5_GET(srqc,  srqc, wq_signature));
 100                 MLX5_SET(wq,   wq, log_wq_pg_sz,  MLX5_GET(srqc,  srqc, log_page_size));
 101                 MLX5_SET(wq,   wq, log_wq_stride, MLX5_GET(srqc,  srqc, log_rq_stride) + 4);
 102                 MLX5_SET(wq,   wq, log_wq_sz,     MLX5_GET(srqc,  srqc, log_srq_size));
 103                 MLX5_SET(wq,   wq, page_offset,   MLX5_GET(srqc,  srqc, page_offset));
 104                 MLX5_SET(wq,   wq, lwm,           MLX5_GET(srqc,  srqc, lwm));
 105                 MLX5_SET(wq,   wq, pd,            MLX5_GET(srqc,  srqc, pd));
 106                 MLX5_SET64(wq, wq, dbr_addr, MLX5_GET64(srqc,     srqc, dbr_addr));
 107         } else {
 108                 switch (MLX5_GET(rmpc, rmpc, state)) {
 109                 case MLX5_RMPC_STATE_RDY:
 110                         MLX5_SET(srqc, srqc, state, MLX5_SRQC_STATE_GOOD);
 111                         break;
 112                 case MLX5_RMPC_STATE_ERR:
 113                         MLX5_SET(srqc, srqc, state, MLX5_SRQC_STATE_ERROR);
 114                         break;
 115                 default:
 116                         pr_warn("%s: %d: Unknown rmp state = 0x%x\n",
 117                                 __func__, __LINE__,
 118                                 MLX5_GET(rmpc, rmpc, state));
 119                         MLX5_SET(srqc, srqc, state,
 120                                  MLX5_GET(rmpc, rmpc, state));
 121                 }
 122
 123                 MLX5_SET(srqc,   srqc, wq_signature,   MLX5_GET(wq,   wq, wq_signature));
 124                 MLX5_SET(srqc,   srqc, log_page_size,  MLX5_GET(wq,   wq, log_wq_pg_sz));
 125                 MLX5_SET(srqc,   srqc, log_rq_stride,  MLX5_GET(wq,   wq, log_wq_stride) - 4);
 126                 MLX5_SET(srqc,   srqc, log_srq_size,   MLX5_GET(wq,   wq, log_wq_sz));
 127                 MLX5_SET(srqc,   srqc, page_offset,    MLX5_GET(wq,   wq, page_offset));
 128                 MLX5_SET(srqc,   srqc, lwm,            MLX5_GET(wq,   wq, lwm));
 129                 MLX5_SET(srqc,   srqc, pd,             MLX5_GET(wq,   wq, pd));
 130                 MLX5_SET64(srqc, srqc, dbr_addr,       MLX5_GET64(wq, wq, dbr_addr));
 131         }
 132 }
 133
 134 struct mlx5_core_srq *mlx5_core_get_srq(struct mlx5_core_dev *dev, u32 srqn)
 135 {
 136         struct mlx5_srq_table *table = &dev->priv.srq_table;
 137         struct mlx5_core_srq *srq;
 138
 139         spin_lock(&table->lock);
 140
 141         srq = radix_tree_lookup(&table->tree, srqn);
 142         if (srq)
 143                 atomic_inc(&srq->refcount);
 144
 145         spin_unlock(&table->lock);
 146
 147         return srq;
 148 }
 149 EXPORT_SYMBOL(mlx5_core_get_srq);
 150
 151 static int create_srq_cmd(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 152                           struct mlx5_create_srq_mbox_in *in, int inlen)
 153 {
 154         struct mlx5_create_srq_mbox_out out;
 155         int err;
 156
 157         memset(&out, 0, sizeof(out));
 158
 159         in->hdr.opcode = cpu_to_be16(MLX5_CMD_OP_CREATE_SRQ);
 160
 161         err = mlx5_cmd_exec_check_status(dev, (u32 *)in, inlen, (u32 *)(&out),
 162                                          sizeof(out));
 163
 164         srq->srqn = be32_to_cpu(out.srqn) & 0xffffff;
 165
 166         return err;
 167 }
 168
 169 static int destroy_srq_cmd(struct mlx5_core_dev *dev,
 170                            struct mlx5_core_srq *srq)
 171 {
 172         struct mlx5_destroy_srq_mbox_in in;
 173         struct mlx5_destroy_srq_mbox_out out;
 174
 175         memset(&in, 0, sizeof(in));
 176         memset(&out, 0, sizeof(out));
 177         in.hdr.opcode = cpu_to_be16(MLX5_CMD_OP_DESTROY_SRQ);
 178         in.srqn = cpu_to_be32(srq->srqn);
 179
 180         return mlx5_cmd_exec_check_status(dev, (u32 *)(&in), sizeof(in),
 181                                           (u32 *)(&out), sizeof(out));
 182 }
 183
 184 static int arm_srq_cmd(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 185                        u16 lwm, int is_srq)
 186 {
 187         struct mlx5_arm_srq_mbox_in     in;
 188         struct mlx5_arm_srq_mbox_out    out;
 189
 190         memset(&in, 0, sizeof(in));
 191         memset(&out, 0, sizeof(out));
 192
 193         in.hdr.opcode = cpu_to_be16(MLX5_CMD_OP_ARM_RQ);
 194         in.hdr.opmod = cpu_to_be16(!!is_srq);
 195         in.srqn = cpu_to_be32(srq->srqn);
 196         in.lwm = cpu_to_be16(lwm);
 197
 198         return mlx5_cmd_exec_check_status(dev, (u32 *)(&in),
 199                                           sizeof(in), (u32 *)(&out),
 200                                           sizeof(out));
 201 }
 202
 203 static int query_srq_cmd(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 204                          struct mlx5_query_srq_mbox_out *out)
 205 {
 206         struct mlx5_query_srq_mbox_in in;
 207
 208         memset(&in, 0, sizeof(in));
 209
 210         in.hdr.opcode = cpu_to_be16(MLX5_CMD_OP_QUERY_SRQ);
 211         in.srqn = cpu_to_be32(srq->srqn);
 212
 213         return mlx5_cmd_exec_check_status(dev, (u32 *)(&in), sizeof(in),
 214                                           (u32 *)out, sizeof(*out));
 215 }
 216
 217 static int create_xrc_srq_cmd(struct mlx5_core_dev *dev,
 218                               struct mlx5_core_srq *srq,
 219                               struct mlx5_create_srq_mbox_in *in,
 220                               int srq_inlen)
 221 {
 222         u32 create_out[MLX5_ST_SZ_DW(create_xrc_srq_out)];
 223         void *create_in;
 224         void *srqc;
 225         void *xrc_srqc;
 226         void *pas;
 227         int pas_size;
 228         int inlen;
 229         int err;
 230
 231         srqc      = MLX5_ADDR_OF(create_srq_in, in, srq_context_entry);
 232         pas_size  = get_pas_size(srqc);
 233         inlen     = MLX5_ST_SZ_BYTES(create_xrc_srq_in) + pas_size;
 234         create_in = mlx5_vzalloc(inlen);
 235         if (!create_in)
 236                 return -ENOMEM;
 237
 238         xrc_srqc = MLX5_ADDR_OF(create_xrc_srq_in, create_in,
 239                                 xrc_srq_context_entry);
 240         pas      = MLX5_ADDR_OF(create_xrc_srq_in, create_in, pas);
 241
 242         memcpy(xrc_srqc, srqc, MLX5_ST_SZ_BYTES(srqc));
 243         memcpy(pas, in->pas, pas_size);
 244         MLX5_SET(create_xrc_srq_in, create_in, opcode,
 245                  MLX5_CMD_OP_CREATE_XRC_SRQ);
 246
 247         memset(create_out, 0, sizeof(create_out));
 248         err = mlx5_cmd_exec_check_status(dev, create_in, inlen, create_out,
 249                                          sizeof(create_out));
 250         if (err)
 251                 goto out;
 252
 253         srq->srqn = MLX5_GET(create_xrc_srq_out, create_out, xrc_srqn);
 254 out:
 255         kvfree(create_in);
 256         return err;
 257 }
 258
 259 static int destroy_xrc_srq_cmd(struct mlx5_core_dev *dev,
 260                                struct mlx5_core_srq *srq)
 261 {
 262         u32 xrcsrq_in[MLX5_ST_SZ_DW(destroy_xrc_srq_in)];
 263         u32 xrcsrq_out[MLX5_ST_SZ_DW(destroy_xrc_srq_out)];
 264
 265         memset(xrcsrq_in, 0, sizeof(xrcsrq_in));
 266         memset(xrcsrq_out, 0, sizeof(xrcsrq_out));
 267
 268         MLX5_SET(destroy_xrc_srq_in, xrcsrq_in, opcode,
 269                  MLX5_CMD_OP_DESTROY_XRC_SRQ);
 270         MLX5_SET(destroy_xrc_srq_in, xrcsrq_in, xrc_srqn, srq->srqn);
 271
 272         return mlx5_cmd_exec_check_status(dev, xrcsrq_in, sizeof(xrcsrq_in),
 273                                           xrcsrq_out, sizeof(xrcsrq_out));
 274 }
 275
 276 static int arm_xrc_srq_cmd(struct mlx5_core_dev *dev,
 277                            struct mlx5_core_srq *srq, u16 lwm)
 278 {
 279         u32 xrcsrq_in[MLX5_ST_SZ_DW(arm_xrc_srq_in)];
 280         u32 xrcsrq_out[MLX5_ST_SZ_DW(arm_xrc_srq_out)];
 281
 282         memset(xrcsrq_in, 0, sizeof(xrcsrq_in));
 283         memset(xrcsrq_out, 0, sizeof(xrcsrq_out));
 284
 285         MLX5_SET(arm_xrc_srq_in, xrcsrq_in, opcode,   MLX5_CMD_OP_ARM_XRC_SRQ);
 286         MLX5_SET(arm_xrc_srq_in, xrcsrq_in, op_mod,   MLX5_ARM_XRC_SRQ_IN_OP_MOD_XRC_SRQ);
 287         MLX5_SET(arm_xrc_srq_in, xrcsrq_in, xrc_srqn, srq->srqn);
 288         MLX5_SET(arm_xrc_srq_in, xrcsrq_in, lwm,      lwm);
 289
 290         return  mlx5_cmd_exec_check_status(dev, xrcsrq_in, sizeof(xrcsrq_in),
 291                                            xrcsrq_out, sizeof(xrcsrq_out));
 292 }
 293
 294 static int query_xrc_srq_cmd(struct mlx5_core_dev *dev,
 295                              struct mlx5_core_srq *srq,
 296                              struct mlx5_query_srq_mbox_out *out)
 297 {
 298         u32 xrcsrq_in[MLX5_ST_SZ_DW(query_xrc_srq_in)];
 299         u32 *xrcsrq_out;
 300         void *srqc;
 301         void *xrc_srqc;
 302         int err;
 303
 304         xrcsrq_out = mlx5_vzalloc(MLX5_ST_SZ_BYTES(query_xrc_srq_out));
 305         if (!xrcsrq_out)
 306                 return -ENOMEM;
 307         memset(xrcsrq_in, 0, sizeof(xrcsrq_in));
 308
 309         MLX5_SET(query_xrc_srq_in, xrcsrq_in, opcode,
 310                  MLX5_CMD_OP_QUERY_XRC_SRQ);
 311         MLX5_SET(query_xrc_srq_in, xrcsrq_in, xrc_srqn, srq->srqn);
 312         err =  mlx5_cmd_exec_check_status(dev, xrcsrq_in, sizeof(xrcsrq_in),
 313                                           xrcsrq_out,
 314                                           MLX5_ST_SZ_BYTES(query_xrc_srq_out));
 315         if (err)
 316                 goto out;
 317
 318         xrc_srqc = MLX5_ADDR_OF(query_xrc_srq_out, xrcsrq_out,
 319                                 xrc_srq_context_entry);
 320         srqc = MLX5_ADDR_OF(query_srq_out, out, srq_context_entry);
 321         memcpy(srqc, xrc_srqc, MLX5_ST_SZ_BYTES(srqc));
 322
 323 out:
 324         kvfree(xrcsrq_out);
 325         return err;
 326 }
 327
 328 static int create_rmp_cmd(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 329                           struct mlx5_create_srq_mbox_in *in, int srq_inlen)
 330 {
 331         void *create_in;
 332         void *rmpc;
 333         void *srqc;
 334         int pas_size;
 335         int inlen;
 336         int err;
 337
 338         srqc = MLX5_ADDR_OF(create_srq_in, in, srq_context_entry);
 339         pas_size = get_pas_size(srqc);
 340         inlen = MLX5_ST_SZ_BYTES(create_rmp_in) + pas_size;
 341         create_in = mlx5_vzalloc(inlen);
 342         if (!create_in)
 343                 return -ENOMEM;
 344
 345         rmpc = MLX5_ADDR_OF(create_rmp_in, create_in, ctx);
 346
 347         memcpy(MLX5_ADDR_OF(rmpc, rmpc, wq.pas), in->pas, pas_size);
 348         rmpc_srqc_reformat(srqc, rmpc, true);
 349
 350         err = mlx5_core_create_rmp(dev, create_in, inlen, &srq->srqn);
 351
 352         kvfree(create_in);
 353         return err;
 354 }
 355
 356 static int destroy_rmp_cmd(struct mlx5_core_dev *dev,
 357                            struct mlx5_core_srq *srq)
 358 {
 359         return mlx5_core_destroy_rmp(dev, srq->srqn);
 360 }
 361
 362 static int arm_rmp_cmd(struct mlx5_core_dev *dev,
 363                        struct mlx5_core_srq *srq,
 364                        u16 lwm)
 365 {
 366         void *in;
 367         void *rmpc;
 368         void *wq;
 369         void *bitmask;
 370         int err;
 371
 372         in = mlx5_vzalloc(MLX5_ST_SZ_BYTES(modify_rmp_in));
 373         if (!in)
 374                 return -ENOMEM;
 375
 376         rmpc =    MLX5_ADDR_OF(modify_rmp_in,   in,   ctx);
 377         bitmask = MLX5_ADDR_OF(modify_rmp_in,   in,   bitmask);
 378         wq   =    MLX5_ADDR_OF(rmpc,            rmpc, wq);
 379
 380         MLX5_SET(modify_rmp_in, in,      rmp_state, MLX5_RMPC_STATE_RDY);
 381         MLX5_SET(modify_rmp_in, in,      rmpn,      srq->srqn);
 382         MLX5_SET(wq,            wq,      lwm,       lwm);
 383         MLX5_SET(rmp_bitmask,   bitmask, lwm,       1);
 384         MLX5_SET(rmpc, rmpc, state, MLX5_RMPC_STATE_RDY);
 385
 386         err = mlx5_core_modify_rmp(dev, in, MLX5_ST_SZ_BYTES(modify_rmp_in));
 387
 388         kvfree(in);
 389         return err;
 390 }
 391
 392 static int query_rmp_cmd(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 393                          struct mlx5_query_srq_mbox_out *out)
 394 {
 395         u32 *rmp_out;
 396         void *rmpc;
 397         void *srqc;
 398         int err;
 399
 400         rmp_out =  mlx5_vzalloc(MLX5_ST_SZ_BYTES(query_rmp_out));
 401         if (!rmp_out)
 402                 return -ENOMEM;
 403
 404         err = mlx5_core_query_rmp(dev, srq->srqn, rmp_out);
 405         if (err)
 406                 goto out;
 407
 408         srqc = MLX5_ADDR_OF(query_srq_out, out,     srq_context_entry);
 409         rmpc = MLX5_ADDR_OF(query_rmp_out, rmp_out, rmp_context);
 410         rmpc_srqc_reformat(srqc, rmpc, false);
 411
 412 out:
 413         kvfree(rmp_out);
 414         return err;
 415 }
 416
 417 static int create_srq_split(struct mlx5_core_dev *dev,
 418                             struct mlx5_core_srq *srq,
 419                             struct mlx5_create_srq_mbox_in *in,
 420                             int inlen, int is_xrc)
 421 {
 422         if (!dev->issi)
 423                 return create_srq_cmd(dev, srq, in, inlen);
 424         else if (srq->common.res == MLX5_RES_XSRQ)
 425                 return create_xrc_srq_cmd(dev, srq, in, inlen);
 426         else
 427                 return create_rmp_cmd(dev, srq, in, inlen);
 428 }
 429
 430 static int destroy_srq_split(struct mlx5_core_dev *dev,
 431                              struct mlx5_core_srq *srq)
 432 {
 433         if (!dev->issi)
 434                 return destroy_srq_cmd(dev, srq);
 435         else if (srq->common.res == MLX5_RES_XSRQ)
 436                 return destroy_xrc_srq_cmd(dev, srq);
 437         else
 438                 return destroy_rmp_cmd(dev, srq);
 439 }
 440
 441 int mlx5_core_create_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 442                          struct mlx5_create_srq_mbox_in *in, int inlen,
 443                          int is_xrc)
 444 {
 445         int err;
 446         struct mlx5_srq_table *table = &dev->priv.srq_table;
 447
 448         srq->common.res = is_xrc ? MLX5_RES_XSRQ : MLX5_RES_SRQ;
 449
 450         err = create_srq_split(dev, srq, in, inlen, is_xrc);
 451         if (err)
 452                 return err;
 453
 454         atomic_set(&srq->refcount, 1);
 455         init_completion(&srq->free);
 456
 457         spin_lock_irq(&table->lock);
 458         err = radix_tree_insert(&table->tree, srq->srqn, srq);
 459         spin_unlock_irq(&table->lock);
 460         if (err) {
 461                 mlx5_core_warn(dev, "err %d, srqn 0x%x\n", err, srq->srqn);
 462                 goto err_destroy_srq_split;
 463         }
 464
 465         return 0;
 466
 467 err_destroy_srq_split:
 468         destroy_srq_split(dev, srq);
 469
 470         return err;
 471 }
 472 EXPORT_SYMBOL(mlx5_core_create_srq);
 473
 474 int mlx5_core_destroy_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq)
 475 {
 476         struct mlx5_srq_table *table = &dev->priv.srq_table;
 477         struct mlx5_core_srq *tmp;
 478         int err;
 479
 480         spin_lock_irq(&table->lock);
 481         tmp = radix_tree_delete(&table->tree, srq->srqn);
 482         spin_unlock_irq(&table->lock);
 483         if (!tmp) {
 484                 mlx5_core_warn(dev, "srq 0x%x not found in tree\n", srq->srqn);
 485                 return -EINVAL;
 486         }
 487         if (tmp != srq) {
 488                 mlx5_core_warn(dev, "corruption on srqn 0x%x\n", srq->srqn);
 489                 return -EINVAL;
 490         }
 491
 492         err = destroy_srq_split(dev, srq);
 493         if (err)
 494                 return err;
 495
 496         if (atomic_dec_and_test(&srq->refcount))
 497                 complete(&srq->free);
 498         wait_for_completion(&srq->free);
 499
 500         return 0;
 501 }
 502 EXPORT_SYMBOL(mlx5_core_destroy_srq);
 503
 504 int mlx5_core_query_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 505                         struct mlx5_query_srq_mbox_out *out)
 506 {
 507         if (!dev->issi)
 508                 return query_srq_cmd(dev, srq, out);
 509         else if (srq->common.res == MLX5_RES_XSRQ)
 510                 return query_xrc_srq_cmd(dev, srq, out);
 511         else
 512                 return query_rmp_cmd(dev, srq, out);
 513 }
 514 EXPORT_SYMBOL(mlx5_core_query_srq);
 515
 516 int mlx5_core_arm_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 517                       u16 lwm, int is_srq)
 518 {
 519         if (!dev->issi)
 520                 return arm_srq_cmd(dev, srq, lwm, is_srq);
 521         else if (srq->common.res == MLX5_RES_XSRQ)
 522                 return arm_xrc_srq_cmd(dev, srq, lwm);
 523         else
 524                 return arm_rmp_cmd(dev, srq, lwm);
 525 }
 526 EXPORT_SYMBOL(mlx5_core_arm_srq);
 527
 528 void mlx5_init_srq_table(struct mlx5_core_dev *dev)
 529 {
 530         struct mlx5_srq_table *table = &dev->priv.srq_table;
 531
 532         memset(table, 0, sizeof(*table));
 533         spin_lock_init(&table->lock);
 534         INIT_RADIX_TREE(&table->tree, GFP_ATOMIC);
 535 }
 536
 537 void mlx5_cleanup_srq_table(struct mlx5_core_dev *dev)
 538 {
 539         /* nothing */
 540 }