sys/dev/mlx5/mlx5_core/mlx5_transobj.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 <dev/mlx5/driver.h>
  29
  30 #include "mlx5_core.h"
  31 #include "transobj.h"
  32
  33 int mlx5_alloc_transport_domain(struct mlx5_core_dev *dev, u32 *tdn)
  34 {
  35         u32 in[MLX5_ST_SZ_DW(alloc_transport_domain_in)];
  36         u32 out[MLX5_ST_SZ_DW(alloc_transport_domain_out)];
  37         int err;
  38
  39         memset(in, 0, sizeof(in));
  40         memset(out, 0, sizeof(out));
  41
  42         MLX5_SET(alloc_transport_domain_in, in, opcode,
  43                  MLX5_CMD_OP_ALLOC_TRANSPORT_DOMAIN);
  44
  45         err = mlx5_cmd_exec_check_status(dev, in, sizeof(in), out, sizeof(out));
  46         if (!err)
  47                 *tdn = MLX5_GET(alloc_transport_domain_out, out,
  48                                 transport_domain);
  49
  50         return err;
  51 }
  52
  53 void mlx5_dealloc_transport_domain(struct mlx5_core_dev *dev, u32 tdn)
  54 {
  55         u32 in[MLX5_ST_SZ_DW(dealloc_transport_domain_in)];
  56         u32 out[MLX5_ST_SZ_DW(dealloc_transport_domain_out)];
  57
  58         memset(in, 0, sizeof(in));
  59         memset(out, 0, sizeof(out));
  60
  61         MLX5_SET(dealloc_transport_domain_in, in, opcode,
  62                  MLX5_CMD_OP_DEALLOC_TRANSPORT_DOMAIN);
  63         MLX5_SET(dealloc_transport_domain_in, in, transport_domain, tdn);
  64
  65         mlx5_cmd_exec_check_status(dev, in, sizeof(in), out, sizeof(out));
  66 }
  67
  68 int mlx5_core_create_rq(struct mlx5_core_dev *dev, u32 *in, int inlen, u32 *rqn)
  69 {
  70         u32 out[MLX5_ST_SZ_DW(create_rq_out)];
  71         int err;
  72
  73         MLX5_SET(create_rq_in, in, opcode, MLX5_CMD_OP_CREATE_RQ);
  74
  75         memset(out, 0, sizeof(out));
  76         err = mlx5_cmd_exec_check_status(dev, in, inlen, out, sizeof(out));
  77         if (!err)
  78                 *rqn = MLX5_GET(create_rq_out, out, rqn);
  79
  80         return err;
  81 }
  82
  83 int mlx5_core_modify_rq(struct mlx5_core_dev *dev, u32 *in, int inlen)
  84 {
  85         u32 out[MLX5_ST_SZ_DW(modify_rq_out)];
  86
  87         MLX5_SET(modify_rq_in, in, opcode, MLX5_CMD_OP_MODIFY_RQ);
  88
  89         memset(out, 0, sizeof(out));
  90         return mlx5_cmd_exec_check_status(dev, in, inlen, out, sizeof(out));
  91 }
  92
  93 void mlx5_core_destroy_rq(struct mlx5_core_dev *dev, u32 rqn)
  94 {
  95         u32 in[MLX5_ST_SZ_DW(destroy_rq_in)];
  96         u32 out[MLX5_ST_SZ_DW(destroy_rq_out)];
  97
  98         memset(in, 0, sizeof(in));
  99
 100         MLX5_SET(destroy_rq_in, in, opcode, MLX5_CMD_OP_DESTROY_RQ);
 101         MLX5_SET(destroy_rq_in, in, rqn, rqn);
 102
 103         mlx5_cmd_exec_check_status(dev, in, sizeof(in), out, sizeof(out));
 104 }
 105
 106 int mlx5_core_query_rq(struct mlx5_core_dev *dev, u32 rqn, u32 *out)
 107 {
 108         u32 in[MLX5_ST_SZ_DW(query_rq_in)];
 109         int outlen = MLX5_ST_SZ_BYTES(query_rq_out);
 110
 111         memset(in, 0, sizeof(in));
 112         MLX5_SET(query_rq_in, in, opcode, MLX5_CMD_OP_QUERY_RQ);
 113         MLX5_SET(query_rq_in, in, rqn, rqn);
 114
 115         return mlx5_cmd_exec_check_status(dev, in, sizeof(in), out, outlen);
 116 }
 117
 118 int mlx5_core_create_sq(struct mlx5_core_dev *dev, u32 *in, int inlen, u32 *sqn)
 119 {
 120         u32 out[MLX5_ST_SZ_DW(create_sq_out)];
 121         int err;
 122
 123         MLX5_SET(create_sq_in, in, opcode, MLX5_CMD_OP_CREATE_SQ);
 124
 125         memset(out, 0, sizeof(out));
 126         err = mlx5_cmd_exec_check_status(dev, in, inlen, out, sizeof(out));
 127         if (!err)
 128                 *sqn = MLX5_GET(create_sq_out, out, sqn);
 129
 130         return err;
 131 }
 132
 133 int mlx5_core_modify_sq(struct mlx5_core_dev *dev, u32 *in, int inlen)
 134 {
 135         u32 out[MLX5_ST_SZ_DW(modify_sq_out)];
 136
 137         MLX5_SET(modify_sq_in, in, opcode, MLX5_CMD_OP_MODIFY_SQ);
 138
 139         memset(out, 0, sizeof(out));
 140         return mlx5_cmd_exec_check_status(dev, in, inlen, out, sizeof(out));
 141 }
 142
 143 void mlx5_core_destroy_sq(struct mlx5_core_dev *dev, u32 sqn)
 144 {
 145         u32 in[MLX5_ST_SZ_DW(destroy_sq_in)];
 146         u32 out[MLX5_ST_SZ_DW(destroy_sq_out)];
 147
 148         memset(in, 0, sizeof(in));
 149
 150         MLX5_SET(destroy_sq_in, in, opcode, MLX5_CMD_OP_DESTROY_SQ);
 151         MLX5_SET(destroy_sq_in, in, sqn, sqn);
 152
 153         mlx5_cmd_exec_check_status(dev, in, sizeof(in), out, sizeof(out));
 154 }
 155
 156 int mlx5_core_query_sq(struct mlx5_core_dev *dev, u32 sqn, u32 *out)
 157 {
 158         u32 in[MLX5_ST_SZ_DW(query_sq_in)];
 159         int outlen = MLX5_ST_SZ_BYTES(query_sq_out);
 160
 161         memset(in, 0, sizeof(in));
 162         MLX5_SET(query_sq_in, in, opcode, MLX5_CMD_OP_QUERY_SQ);
 163         MLX5_SET(query_sq_in, in, sqn, sqn);
 164
 165         return mlx5_cmd_exec_check_status(dev, in, sizeof(in), out, outlen);
 166 }
 167
 168 int mlx5_core_create_tir(struct mlx5_core_dev *dev, u32 *in, int inlen,
 169                          u32 *tirn)
 170 {
 171         u32 out[MLX5_ST_SZ_DW(create_tir_out)];
 172         int err;
 173
 174         MLX5_SET(create_tir_in, in, opcode, MLX5_CMD_OP_CREATE_TIR);
 175
 176         memset(out, 0, sizeof(out));
 177         err = mlx5_cmd_exec_check_status(dev, in, inlen, out, sizeof(out));
 178         if (!err)
 179                 *tirn = MLX5_GET(create_tir_out, out, tirn);
 180
 181         return err;
 182 }
 183
 184 void mlx5_core_destroy_tir(struct mlx5_core_dev *dev, u32 tirn)
 185 {
 186         u32 in[MLX5_ST_SZ_DW(destroy_tir_in)];
 187         u32 out[MLX5_ST_SZ_DW(destroy_tir_out)];
 188
 189         memset(in, 0, sizeof(in));
 190
 191         MLX5_SET(destroy_tir_in, in, opcode, MLX5_CMD_OP_DESTROY_TIR);
 192         MLX5_SET(destroy_tir_in, in, tirn, tirn);
 193
 194         mlx5_cmd_exec_check_status(dev, in, sizeof(in), out, sizeof(out));
 195 }
 196
 197 int mlx5_core_create_tis(struct mlx5_core_dev *dev, u32 *in, int inlen,
 198                          u32 *tisn)
 199 {
 200         u32 out[MLX5_ST_SZ_DW(create_tis_out)];
 201         int err;
 202
 203         MLX5_SET(create_tis_in, in, opcode, MLX5_CMD_OP_CREATE_TIS);
 204
 205         memset(out, 0, sizeof(out));
 206         err = mlx5_cmd_exec_check_status(dev, in, inlen, out, sizeof(out));
 207         if (!err)
 208                 *tisn = MLX5_GET(create_tis_out, out, tisn);
 209
 210         return err;
 211 }
 212
 213 void mlx5_core_destroy_tis(struct mlx5_core_dev *dev, u32 tisn)
 214 {
 215         u32 in[MLX5_ST_SZ_DW(destroy_tis_in)];
 216         u32 out[MLX5_ST_SZ_DW(destroy_tis_out)];
 217
 218         memset(in, 0, sizeof(in));
 219
 220         MLX5_SET(destroy_tis_in, in, opcode, MLX5_CMD_OP_DESTROY_TIS);
 221         MLX5_SET(destroy_tis_in, in, tisn, tisn);
 222
 223         mlx5_cmd_exec_check_status(dev, in, sizeof(in), out, sizeof(out));
 224 }
 225
 226 int mlx5_core_create_rmp(struct mlx5_core_dev *dev, u32 *in, int inlen, u32 *rmpn)
 227 {
 228         u32 out[MLX5_ST_SZ_DW(create_rmp_out)];
 229         int err;
 230
 231         MLX5_SET(create_rmp_in, in, opcode, MLX5_CMD_OP_CREATE_RMP);
 232
 233         memset(out, 0, sizeof(out));
 234         err = mlx5_cmd_exec_check_status(dev, in, inlen, out, sizeof(out));
 235         if (!err)
 236                 *rmpn = MLX5_GET(create_rmp_out, out, rmpn);
 237
 238         return err;
 239 }
 240
 241 int mlx5_core_modify_rmp(struct mlx5_core_dev *dev, u32 *in, int inlen)
 242 {
 243         u32 out[MLX5_ST_SZ_DW(modify_rmp_out)];
 244
 245         MLX5_SET(modify_rmp_in, in, opcode, MLX5_CMD_OP_MODIFY_RMP);
 246
 247         memset(out, 0, sizeof(out));
 248         return mlx5_cmd_exec_check_status(dev, in, inlen, out, sizeof(out));
 249 }
 250
 251 int mlx5_core_destroy_rmp(struct mlx5_core_dev *dev, u32 rmpn)
 252 {
 253         u32 in[MLX5_ST_SZ_DW(destroy_rmp_in)];
 254         u32 out[MLX5_ST_SZ_DW(destroy_rmp_out)];
 255
 256         memset(in, 0, sizeof(in));
 257
 258         MLX5_SET(destroy_rmp_in, in, opcode, MLX5_CMD_OP_DESTROY_RMP);
 259         MLX5_SET(destroy_rmp_in, in, rmpn, rmpn);
 260
 261         return mlx5_cmd_exec_check_status(dev, in, sizeof(in), out, sizeof(out));
 262 }
 263
 264 int mlx5_core_query_rmp(struct mlx5_core_dev *dev, u32 rmpn, u32 *out)
 265 {
 266         u32 in[MLX5_ST_SZ_DW(query_rmp_in)];
 267         int outlen = MLX5_ST_SZ_BYTES(query_rmp_out);
 268
 269         memset(in, 0, sizeof(in));
 270         MLX5_SET(query_rmp_in, in, opcode, MLX5_CMD_OP_QUERY_RMP);
 271         MLX5_SET(query_rmp_in, in, rmpn,   rmpn);
 272
 273         return mlx5_cmd_exec_check_status(dev, in, sizeof(in), out, outlen);
 274 }
 275
 276 int mlx5_core_arm_rmp(struct mlx5_core_dev *dev, u32 rmpn, u16 lwm)
 277 {
 278         void *in;
 279         void *rmpc;
 280         void *wq;
 281         void *bitmask;
 282         int  err;
 283
 284         in = mlx5_vzalloc(MLX5_ST_SZ_BYTES(modify_rmp_in));
 285         if (!in)
 286                 return -ENOMEM;
 287
 288         rmpc    = MLX5_ADDR_OF(modify_rmp_in,   in,   ctx);
 289         bitmask = MLX5_ADDR_OF(modify_rmp_in,   in,   bitmask);
 290         wq      = MLX5_ADDR_OF(rmpc,            rmpc, wq);
 291
 292         MLX5_SET(modify_rmp_in, in,      rmp_state, MLX5_RMPC_STATE_RDY);
 293         MLX5_SET(modify_rmp_in, in,      rmpn,      rmpn);
 294         MLX5_SET(wq,            wq,      lwm,       lwm);
 295         MLX5_SET(rmp_bitmask,   bitmask, lwm,       1);
 296         MLX5_SET(rmpc,          rmpc,    state,     MLX5_RMPC_STATE_RDY);
 297
 298         err =  mlx5_core_modify_rmp(dev, in, MLX5_ST_SZ_BYTES(modify_rmp_in));
 299
 300         kvfree(in);
 301
 302         return err;
 303 }
 304
 305 int mlx5_core_create_xsrq(struct mlx5_core_dev *dev, u32 *in, int inlen, u32 *xsrqn)
 306 {
 307         u32 out[MLX5_ST_SZ_DW(create_xrc_srq_out)];
 308         int err;
 309
 310         MLX5_SET(create_xrc_srq_in, in, opcode,     MLX5_CMD_OP_CREATE_XRC_SRQ);
 311
 312         memset(out, 0, sizeof(out));
 313         err = mlx5_cmd_exec_check_status(dev, in, inlen, out, sizeof(out));
 314         if (!err)
 315                 *xsrqn = MLX5_GET(create_xrc_srq_out, out, xrc_srqn);
 316
 317         return err;
 318 }
 319
 320 int mlx5_core_destroy_xsrq(struct mlx5_core_dev *dev, u32 xsrqn)
 321 {
 322         u32 in[MLX5_ST_SZ_DW(destroy_xrc_srq_in)];
 323         u32 out[MLX5_ST_SZ_DW(destroy_xrc_srq_out)];
 324
 325         memset(in, 0, sizeof(in));
 326         memset(out, 0, sizeof(out));
 327
 328         MLX5_SET(destroy_xrc_srq_in, in, opcode,   MLX5_CMD_OP_DESTROY_XRC_SRQ);
 329         MLX5_SET(destroy_xrc_srq_in, in, xrc_srqn, xsrqn);
 330
 331         return mlx5_cmd_exec_check_status(dev, in, sizeof(in), out,
 332                                           sizeof(out));
 333 }
 334
 335 int mlx5_core_query_xsrq(struct mlx5_core_dev *dev, u32 xsrqn, u32 *out)
 336 {
 337         u32 in[MLX5_ST_SZ_DW(query_xrc_srq_in)];
 338         void *srqc;
 339         void *xrc_srqc;
 340         int err;
 341
 342         memset(in, 0, sizeof(in));
 343         MLX5_SET(query_xrc_srq_in, in, opcode,   MLX5_CMD_OP_QUERY_XRC_SRQ);
 344         MLX5_SET(query_xrc_srq_in, in, xrc_srqn, xsrqn);
 345
 346         err =  mlx5_cmd_exec_check_status(dev, in, sizeof(in),
 347                                           out,
 348                                           MLX5_ST_SZ_BYTES(query_xrc_srq_out));
 349         if (!err) {
 350                 xrc_srqc = MLX5_ADDR_OF(query_xrc_srq_out, out,
 351                                         xrc_srq_context_entry);
 352                 srqc = MLX5_ADDR_OF(query_srq_out, out, srq_context_entry);
 353                 memcpy(srqc, xrc_srqc, MLX5_ST_SZ_BYTES(srqc));
 354         }
 355
 356         return err;
 357 }
 358
 359 int mlx5_core_arm_xsrq(struct mlx5_core_dev *dev, u32 xsrqn, u16 lwm)
 360 {
 361         u32 in[MLX5_ST_SZ_DW(arm_xrc_srq_in)];
 362         u32 out[MLX5_ST_SZ_DW(arm_xrc_srq_out)];
 363
 364         memset(in, 0, sizeof(in));
 365         memset(out, 0, sizeof(out));
 366
 367         MLX5_SET(arm_xrc_srq_in, in, opcode,   MLX5_CMD_OP_ARM_XRC_SRQ);
 368         MLX5_SET(arm_xrc_srq_in, in, xrc_srqn, xsrqn);
 369         MLX5_SET(arm_xrc_srq_in, in, lwm,      lwm);
 370         MLX5_SET(arm_xrc_srq_in, in, op_mod,
 371                  MLX5_ARM_XRC_SRQ_IN_OP_MOD_XRC_SRQ);
 372
 373         return  mlx5_cmd_exec_check_status(dev, in, sizeof(in), out,
 374                                            sizeof(out));
 375
 376 }
 377
 378 int mlx5_core_create_rqt(struct mlx5_core_dev *dev, u32 *in, int inlen,
 379                          u32 *rqtn)
 380 {
 381         u32 out[MLX5_ST_SZ_DW(create_rqt_out)];
 382         int err;
 383
 384         MLX5_SET(create_rqt_in, in, opcode, MLX5_CMD_OP_CREATE_RQT);
 385
 386         memset(out, 0, sizeof(out));
 387         err = mlx5_cmd_exec_check_status(dev, in, inlen, out, sizeof(out));
 388         if (!err)
 389                 *rqtn = MLX5_GET(create_rqt_out, out, rqtn);
 390
 391         return err;
 392 }
 393
 394 int mlx5_core_modify_rqt(struct mlx5_core_dev *dev, u32 rqtn, u32 *in,
 395                          int inlen)
 396 {
 397         u32 out[MLX5_ST_SZ_DW(modify_rqt_out)];
 398
 399         MLX5_SET(modify_rqt_in, in, rqtn, rqtn);
 400         MLX5_SET(modify_rqt_in, in, opcode, MLX5_CMD_OP_MODIFY_RQT);
 401
 402         memset(out, 0, sizeof(out));
 403         return mlx5_cmd_exec_check_status(dev, in, inlen, out, sizeof(out));
 404 }
 405
 406 void mlx5_core_destroy_rqt(struct mlx5_core_dev *dev, u32 rqtn)
 407 {
 408         u32 in[MLX5_ST_SZ_DW(destroy_rqt_in)];
 409         u32 out[MLX5_ST_SZ_DW(destroy_rqt_out)];
 410
 411         memset(in, 0, sizeof(in));
 412
 413         MLX5_SET(destroy_rqt_in, in, opcode, MLX5_CMD_OP_DESTROY_RQT);
 414         MLX5_SET(destroy_rqt_in, in, rqtn, rqtn);
 415
 416         mlx5_cmd_exec_check_status(dev, in, sizeof(in), out, sizeof(out));
 417 }