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 "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         /* 0xffffff means we ask to work with cqe version 0 */
 245         MLX5_SET(xrc_srqc,          xrc_srqc,  user_index, 0xffffff);
 246         MLX5_SET(create_xrc_srq_in, create_in, opcode,
 247                  MLX5_CMD_OP_CREATE_XRC_SRQ);
 248
 249         memset(create_out, 0, sizeof(create_out));
 250         err = mlx5_cmd_exec_check_status(dev, create_in, inlen, create_out,
 251                                          sizeof(create_out));
 252         if (err)
 253                 goto out;
 254
 255         srq->srqn = MLX5_GET(create_xrc_srq_out, create_out, xrc_srqn);
 256 out:
 257         kvfree(create_in);
 258         return err;
 259 }
 260
 261 static int destroy_xrc_srq_cmd(struct mlx5_core_dev *dev,
 262                                struct mlx5_core_srq *srq)
 263 {
 264         u32 xrcsrq_in[MLX5_ST_SZ_DW(destroy_xrc_srq_in)];
 265         u32 xrcsrq_out[MLX5_ST_SZ_DW(destroy_xrc_srq_out)];
 266
 267         memset(xrcsrq_in, 0, sizeof(xrcsrq_in));
 268         memset(xrcsrq_out, 0, sizeof(xrcsrq_out));
 269
 270         MLX5_SET(destroy_xrc_srq_in, xrcsrq_in, opcode,
 271                  MLX5_CMD_OP_DESTROY_XRC_SRQ);
 272         MLX5_SET(destroy_xrc_srq_in, xrcsrq_in, xrc_srqn, srq->srqn);
 273
 274         return mlx5_cmd_exec_check_status(dev, xrcsrq_in, sizeof(xrcsrq_in),
 275                                           xrcsrq_out, sizeof(xrcsrq_out));
 276 }
 277
 278 static int arm_xrc_srq_cmd(struct mlx5_core_dev *dev,
 279                            struct mlx5_core_srq *srq, u16 lwm)
 280 {
 281         u32 xrcsrq_in[MLX5_ST_SZ_DW(arm_xrc_srq_in)];
 282         u32 xrcsrq_out[MLX5_ST_SZ_DW(arm_xrc_srq_out)];
 283
 284         memset(xrcsrq_in, 0, sizeof(xrcsrq_in));
 285         memset(xrcsrq_out, 0, sizeof(xrcsrq_out));
 286
 287         MLX5_SET(arm_xrc_srq_in, xrcsrq_in, opcode,   MLX5_CMD_OP_ARM_XRC_SRQ);
 288         MLX5_SET(arm_xrc_srq_in, xrcsrq_in, op_mod,   MLX5_ARM_XRC_SRQ_IN_OP_MOD_XRC_SRQ);
 289         MLX5_SET(arm_xrc_srq_in, xrcsrq_in, xrc_srqn, srq->srqn);
 290         MLX5_SET(arm_xrc_srq_in, xrcsrq_in, lwm,      lwm);
 291
 292         return  mlx5_cmd_exec_check_status(dev, xrcsrq_in, sizeof(xrcsrq_in),
 293                                            xrcsrq_out, sizeof(xrcsrq_out));
 294 }
 295
 296 static int query_xrc_srq_cmd(struct mlx5_core_dev *dev,
 297                              struct mlx5_core_srq *srq,
 298                              struct mlx5_query_srq_mbox_out *out)
 299 {
 300         u32 xrcsrq_in[MLX5_ST_SZ_DW(query_xrc_srq_in)];
 301         u32 *xrcsrq_out;
 302         void *srqc;
 303         void *xrc_srqc;
 304         int err;
 305
 306         xrcsrq_out = mlx5_vzalloc(MLX5_ST_SZ_BYTES(query_xrc_srq_out));
 307         if (!xrcsrq_out)
 308                 return -ENOMEM;
 309         memset(xrcsrq_in, 0, sizeof(xrcsrq_in));
 310
 311         MLX5_SET(query_xrc_srq_in, xrcsrq_in, opcode,
 312                  MLX5_CMD_OP_QUERY_XRC_SRQ);
 313         MLX5_SET(query_xrc_srq_in, xrcsrq_in, xrc_srqn, srq->srqn);
 314         err =  mlx5_cmd_exec_check_status(dev, xrcsrq_in, sizeof(xrcsrq_in),
 315                                           xrcsrq_out,
 316                                           MLX5_ST_SZ_BYTES(query_xrc_srq_out));
 317         if (err)
 318                 goto out;
 319
 320         xrc_srqc = MLX5_ADDR_OF(query_xrc_srq_out, xrcsrq_out,
 321                                 xrc_srq_context_entry);
 322         srqc = MLX5_ADDR_OF(query_srq_out, out, srq_context_entry);
 323         memcpy(srqc, xrc_srqc, MLX5_ST_SZ_BYTES(srqc));
 324
 325 out:
 326         kvfree(xrcsrq_out);
 327         return err;
 328 }
 329
 330 static int create_rmp_cmd(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 331                           struct mlx5_create_srq_mbox_in *in, int srq_inlen)
 332 {
 333         void *create_in;
 334         void *rmpc;
 335         void *srqc;
 336         int pas_size;
 337         int inlen;
 338         int err;
 339
 340         srqc = MLX5_ADDR_OF(create_srq_in, in, srq_context_entry);
 341         pas_size = get_pas_size(srqc);
 342         inlen = MLX5_ST_SZ_BYTES(create_rmp_in) + pas_size;
 343         create_in = mlx5_vzalloc(inlen);
 344         if (!create_in)
 345                 return -ENOMEM;
 346
 347         rmpc = MLX5_ADDR_OF(create_rmp_in, create_in, ctx);
 348
 349         memcpy(MLX5_ADDR_OF(rmpc, rmpc, wq.pas), in->pas, pas_size);
 350         rmpc_srqc_reformat(srqc, rmpc, true);
 351
 352         err = mlx5_core_create_rmp(dev, create_in, inlen, &srq->srqn);
 353
 354         kvfree(create_in);
 355         return err;
 356 }
 357
 358 static int destroy_rmp_cmd(struct mlx5_core_dev *dev,
 359                            struct mlx5_core_srq *srq)
 360 {
 361         return mlx5_core_destroy_rmp(dev, srq->srqn);
 362 }
 363
 364 static int arm_rmp_cmd(struct mlx5_core_dev *dev,
 365                        struct mlx5_core_srq *srq,
 366                        u16 lwm)
 367 {
 368         void *in;
 369         void *rmpc;
 370         void *wq;
 371         void *bitmask;
 372         int err;
 373
 374         in = mlx5_vzalloc(MLX5_ST_SZ_BYTES(modify_rmp_in));
 375         if (!in)
 376                 return -ENOMEM;
 377
 378         rmpc =    MLX5_ADDR_OF(modify_rmp_in,   in,   ctx);
 379         bitmask = MLX5_ADDR_OF(modify_rmp_in,   in,   bitmask);
 380         wq   =    MLX5_ADDR_OF(rmpc,            rmpc, wq);
 381
 382         MLX5_SET(modify_rmp_in, in,      rmp_state, MLX5_RMPC_STATE_RDY);
 383         MLX5_SET(modify_rmp_in, in,      rmpn,      srq->srqn);
 384         MLX5_SET(wq,            wq,      lwm,       lwm);
 385         MLX5_SET(rmp_bitmask,   bitmask, lwm,       1);
 386         MLX5_SET(rmpc, rmpc, state, MLX5_RMPC_STATE_RDY);
 387
 388         err = mlx5_core_modify_rmp(dev, in, MLX5_ST_SZ_BYTES(modify_rmp_in));
 389
 390         kvfree(in);
 391         return err;
 392 }
 393
 394 static int query_rmp_cmd(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 395                          struct mlx5_query_srq_mbox_out *out)
 396 {
 397         u32 *rmp_out;
 398         void *rmpc;
 399         void *srqc;
 400         int err;
 401
 402         rmp_out =  mlx5_vzalloc(MLX5_ST_SZ_BYTES(query_rmp_out));
 403         if (!rmp_out)
 404                 return -ENOMEM;
 405
 406         err = mlx5_core_query_rmp(dev, srq->srqn, rmp_out);
 407         if (err)
 408                 goto out;
 409
 410         srqc = MLX5_ADDR_OF(query_srq_out, out,     srq_context_entry);
 411         rmpc = MLX5_ADDR_OF(query_rmp_out, rmp_out, rmp_context);
 412         rmpc_srqc_reformat(srqc, rmpc, false);
 413
 414 out:
 415         kvfree(rmp_out);
 416         return err;
 417 }
 418
 419 static int create_srq_split(struct mlx5_core_dev *dev,
 420                             struct mlx5_core_srq *srq,
 421                             struct mlx5_create_srq_mbox_in *in,
 422                             int inlen, int is_xrc)
 423 {
 424         if (!dev->issi)
 425                 return create_srq_cmd(dev, srq, in, inlen);
 426         else if (srq->common.res == MLX5_RES_XSRQ)
 427                 return create_xrc_srq_cmd(dev, srq, in, inlen);
 428         else
 429                 return create_rmp_cmd(dev, srq, in, inlen);
 430 }
 431
 432 static int destroy_srq_split(struct mlx5_core_dev *dev,
 433                              struct mlx5_core_srq *srq)
 434 {
 435         if (!dev->issi)
 436                 return destroy_srq_cmd(dev, srq);
 437         else if (srq->common.res == MLX5_RES_XSRQ)
 438                 return destroy_xrc_srq_cmd(dev, srq);
 439         else
 440                 return destroy_rmp_cmd(dev, srq);
 441 }
 442
 443 int mlx5_core_create_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 444                          struct mlx5_create_srq_mbox_in *in, int inlen,
 445                          int is_xrc)
 446 {
 447         int err;
 448         struct mlx5_srq_table *table = &dev->priv.srq_table;
 449
 450         srq->common.res = is_xrc ? MLX5_RES_XSRQ : MLX5_RES_SRQ;
 451
 452         err = create_srq_split(dev, srq, in, inlen, is_xrc);
 453         if (err)
 454                 return err;
 455
 456         atomic_set(&srq->refcount, 1);
 457         init_completion(&srq->free);
 458
 459         spin_lock_irq(&table->lock);
 460         err = radix_tree_insert(&table->tree, srq->srqn, srq);
 461         spin_unlock_irq(&table->lock);
 462         if (err) {
 463                 mlx5_core_warn(dev, "err %d, srqn 0x%x\n", err, srq->srqn);
 464                 goto err_destroy_srq_split;
 465         }
 466
 467         return 0;
 468
 469 err_destroy_srq_split:
 470         destroy_srq_split(dev, srq);
 471
 472         return err;
 473 }
 474 EXPORT_SYMBOL(mlx5_core_create_srq);
 475
 476 int mlx5_core_destroy_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq)
 477 {
 478         struct mlx5_srq_table *table = &dev->priv.srq_table;
 479         struct mlx5_core_srq *tmp;
 480         int err;
 481
 482         spin_lock_irq(&table->lock);
 483         tmp = radix_tree_delete(&table->tree, srq->srqn);
 484         spin_unlock_irq(&table->lock);
 485         if (!tmp) {
 486                 mlx5_core_warn(dev, "srq 0x%x not found in tree\n", srq->srqn);
 487                 return -EINVAL;
 488         }
 489         if (tmp != srq) {
 490                 mlx5_core_warn(dev, "corruption on srqn 0x%x\n", srq->srqn);
 491                 return -EINVAL;
 492         }
 493
 494         err = destroy_srq_split(dev, srq);
 495         if (err)
 496                 return err;
 497
 498         if (atomic_dec_and_test(&srq->refcount))
 499                 complete(&srq->free);
 500         wait_for_completion(&srq->free);
 501
 502         return 0;
 503 }
 504 EXPORT_SYMBOL(mlx5_core_destroy_srq);
 505
 506 int mlx5_core_query_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 507                         struct mlx5_query_srq_mbox_out *out)
 508 {
 509         if (!dev->issi)
 510                 return query_srq_cmd(dev, srq, out);
 511         else if (srq->common.res == MLX5_RES_XSRQ)
 512                 return query_xrc_srq_cmd(dev, srq, out);
 513         else
 514                 return query_rmp_cmd(dev, srq, out);
 515 }
 516 EXPORT_SYMBOL(mlx5_core_query_srq);
 517
 518 int mlx5_core_arm_srq(struct mlx5_core_dev *dev, struct mlx5_core_srq *srq,
 519                       u16 lwm, int is_srq)
 520 {
 521         if (!dev->issi)
 522                 return arm_srq_cmd(dev, srq, lwm, is_srq);
 523         else if (srq->common.res == MLX5_RES_XSRQ)
 524                 return arm_xrc_srq_cmd(dev, srq, lwm);
 525         else
 526                 return arm_rmp_cmd(dev, srq, lwm);
 527 }
 528 EXPORT_SYMBOL(mlx5_core_arm_srq);
 529
 530 void mlx5_init_srq_table(struct mlx5_core_dev *dev)
 531 {
 532         struct mlx5_srq_table *table = &dev->priv.srq_table;
 533
 534         memset(table, 0, sizeof(*table));
 535         spin_lock_init(&table->lock);
 536         INIT_RADIX_TREE(&table->tree, GFP_ATOMIC);
 537 }
 538
 539 void mlx5_cleanup_srq_table(struct mlx5_core_dev *dev)
 540 {
 541         /* nothing */
 542 }