1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB 2 /* 3 * Copyright (c) 2013-2018, Mellanox Technologies inc. All rights reserved. 4 */ 5 6 #include <linux/kernel.h> 7 #include <linux/mlx5/driver.h> 8 #include <linux/mlx5/cmd.h> 9 #include "mlx5_ib.h" 10 #include "srq.h" 11 12 static int get_pas_size(struct mlx5_srq_attr *in) 13 { 14 u32 log_page_size = in->log_page_size + 12; 15 u32 log_srq_size = in->log_size; 16 u32 log_rq_stride = in->wqe_shift; 17 u32 page_offset = in->page_offset; 18 u32 po_quanta = 1 << (log_page_size - 6); 19 u32 rq_sz = 1 << (log_srq_size + 4 + log_rq_stride); 20 u32 page_size = 1 << log_page_size; 21 u32 rq_sz_po = rq_sz + (page_offset * po_quanta); 22 u32 rq_num_pas = DIV_ROUND_UP(rq_sz_po, page_size); 23 24 return rq_num_pas * sizeof(u64); 25 } 26 27 static void set_wq(void *wq, struct mlx5_srq_attr *in) 28 { 29 MLX5_SET(wq, wq, wq_signature, !!(in->flags 30 & MLX5_SRQ_FLAG_WQ_SIG)); 31 MLX5_SET(wq, wq, log_wq_pg_sz, in->log_page_size); 32 MLX5_SET(wq, wq, log_wq_stride, in->wqe_shift + 4); 33 MLX5_SET(wq, wq, log_wq_sz, in->log_size); 34 MLX5_SET(wq, wq, page_offset, in->page_offset); 35 MLX5_SET(wq, wq, lwm, in->lwm); 36 MLX5_SET(wq, wq, pd, in->pd); 37 MLX5_SET64(wq, wq, dbr_addr, in->db_record); 38 } 39 40 static void set_srqc(void *srqc, struct mlx5_srq_attr *in) 41 { 42 MLX5_SET(srqc, srqc, wq_signature, !!(in->flags 43 & MLX5_SRQ_FLAG_WQ_SIG)); 44 MLX5_SET(srqc, srqc, log_page_size, in->log_page_size); 45 MLX5_SET(srqc, srqc, log_rq_stride, in->wqe_shift); 46 MLX5_SET(srqc, srqc, log_srq_size, in->log_size); 47 MLX5_SET(srqc, srqc, page_offset, in->page_offset); 48 MLX5_SET(srqc, srqc, lwm, in->lwm); 49 MLX5_SET(srqc, srqc, pd, in->pd); 50 MLX5_SET64(srqc, srqc, dbr_addr, in->db_record); 51 MLX5_SET(srqc, srqc, xrcd, in->xrcd); 52 MLX5_SET(srqc, srqc, cqn, in->cqn); 53 } 54 55 static void get_wq(void *wq, struct mlx5_srq_attr *in) 56 { 57 if (MLX5_GET(wq, wq, wq_signature)) 58 in->flags &= MLX5_SRQ_FLAG_WQ_SIG; 59 in->log_page_size = MLX5_GET(wq, wq, log_wq_pg_sz); 60 in->wqe_shift = MLX5_GET(wq, wq, log_wq_stride) - 4; 61 in->log_size = MLX5_GET(wq, wq, log_wq_sz); 62 in->page_offset = MLX5_GET(wq, wq, page_offset); 63 in->lwm = MLX5_GET(wq, wq, lwm); 64 in->pd = MLX5_GET(wq, wq, pd); 65 in->db_record = MLX5_GET64(wq, wq, dbr_addr); 66 } 67 68 static void get_srqc(void *srqc, struct mlx5_srq_attr *in) 69 { 70 if (MLX5_GET(srqc, srqc, wq_signature)) 71 in->flags &= MLX5_SRQ_FLAG_WQ_SIG; 72 in->log_page_size = MLX5_GET(srqc, srqc, log_page_size); 73 in->wqe_shift = MLX5_GET(srqc, srqc, log_rq_stride); 74 in->log_size = MLX5_GET(srqc, srqc, log_srq_size); 75 in->page_offset = MLX5_GET(srqc, srqc, page_offset); 76 in->lwm = MLX5_GET(srqc, srqc, lwm); 77 in->pd = MLX5_GET(srqc, srqc, pd); 78 in->db_record = MLX5_GET64(srqc, srqc, dbr_addr); 79 } 80 81 struct mlx5_core_srq *mlx5_cmd_get_srq(struct mlx5_ib_dev *dev, u32 srqn) 82 { 83 struct mlx5_srq_table *table = &dev->srq_table; 84 struct mlx5_core_srq *srq; 85 86 xa_lock(&table->array); 87 srq = xa_load(&table->array, srqn); 88 if (srq) 89 refcount_inc(&srq->common.refcount); 90 xa_unlock(&table->array); 91 92 return srq; 93 } 94 95 static int create_srq_cmd(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq, 96 struct mlx5_srq_attr *in) 97 { 98 u32 create_out[MLX5_ST_SZ_DW(create_srq_out)] = {0}; 99 void *create_in; 100 void *srqc; 101 void *pas; 102 int pas_size; 103 int inlen; 104 int err; 105 106 pas_size = get_pas_size(in); 107 inlen = MLX5_ST_SZ_BYTES(create_srq_in) + pas_size; 108 create_in = kvzalloc(inlen, GFP_KERNEL); 109 if (!create_in) 110 return -ENOMEM; 111 112 MLX5_SET(create_srq_in, create_in, uid, in->uid); 113 srqc = MLX5_ADDR_OF(create_srq_in, create_in, srq_context_entry); 114 pas = MLX5_ADDR_OF(create_srq_in, create_in, pas); 115 116 set_srqc(srqc, in); 117 memcpy(pas, in->pas, pas_size); 118 119 MLX5_SET(create_srq_in, create_in, opcode, 120 MLX5_CMD_OP_CREATE_SRQ); 121 122 err = mlx5_cmd_exec(dev->mdev, create_in, inlen, create_out, 123 sizeof(create_out)); 124 kvfree(create_in); 125 if (!err) { 126 srq->srqn = MLX5_GET(create_srq_out, create_out, srqn); 127 srq->uid = in->uid; 128 } 129 130 return err; 131 } 132 133 static int destroy_srq_cmd(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq) 134 { 135 u32 srq_in[MLX5_ST_SZ_DW(destroy_srq_in)] = {0}; 136 u32 srq_out[MLX5_ST_SZ_DW(destroy_srq_out)] = {0}; 137 138 MLX5_SET(destroy_srq_in, srq_in, opcode, 139 MLX5_CMD_OP_DESTROY_SRQ); 140 MLX5_SET(destroy_srq_in, srq_in, srqn, srq->srqn); 141 MLX5_SET(destroy_srq_in, srq_in, uid, srq->uid); 142 143 return mlx5_cmd_exec(dev->mdev, srq_in, sizeof(srq_in), srq_out, 144 sizeof(srq_out)); 145 } 146 147 static int arm_srq_cmd(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq, 148 u16 lwm, int is_srq) 149 { 150 u32 srq_in[MLX5_ST_SZ_DW(arm_rq_in)] = {0}; 151 u32 srq_out[MLX5_ST_SZ_DW(arm_rq_out)] = {0}; 152 153 MLX5_SET(arm_rq_in, srq_in, opcode, MLX5_CMD_OP_ARM_RQ); 154 MLX5_SET(arm_rq_in, srq_in, op_mod, MLX5_ARM_RQ_IN_OP_MOD_SRQ); 155 MLX5_SET(arm_rq_in, srq_in, srq_number, srq->srqn); 156 MLX5_SET(arm_rq_in, srq_in, lwm, lwm); 157 MLX5_SET(arm_rq_in, srq_in, uid, srq->uid); 158 159 return mlx5_cmd_exec(dev->mdev, srq_in, sizeof(srq_in), srq_out, 160 sizeof(srq_out)); 161 } 162 163 static int query_srq_cmd(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq, 164 struct mlx5_srq_attr *out) 165 { 166 u32 srq_in[MLX5_ST_SZ_DW(query_srq_in)] = {0}; 167 u32 *srq_out; 168 void *srqc; 169 int err; 170 171 srq_out = kvzalloc(MLX5_ST_SZ_BYTES(query_srq_out), GFP_KERNEL); 172 if (!srq_out) 173 return -ENOMEM; 174 175 MLX5_SET(query_srq_in, srq_in, opcode, 176 MLX5_CMD_OP_QUERY_SRQ); 177 MLX5_SET(query_srq_in, srq_in, srqn, srq->srqn); 178 err = mlx5_cmd_exec(dev->mdev, srq_in, sizeof(srq_in), srq_out, 179 MLX5_ST_SZ_BYTES(query_srq_out)); 180 if (err) 181 goto out; 182 183 srqc = MLX5_ADDR_OF(query_srq_out, srq_out, srq_context_entry); 184 get_srqc(srqc, out); 185 if (MLX5_GET(srqc, srqc, state) != MLX5_SRQC_STATE_GOOD) 186 out->flags |= MLX5_SRQ_FLAG_ERR; 187 out: 188 kvfree(srq_out); 189 return err; 190 } 191 192 static int create_xrc_srq_cmd(struct mlx5_ib_dev *dev, 193 struct mlx5_core_srq *srq, 194 struct mlx5_srq_attr *in) 195 { 196 u32 create_out[MLX5_ST_SZ_DW(create_xrc_srq_out)]; 197 void *create_in; 198 void *xrc_srqc; 199 void *pas; 200 int pas_size; 201 int inlen; 202 int err; 203 204 pas_size = get_pas_size(in); 205 inlen = MLX5_ST_SZ_BYTES(create_xrc_srq_in) + pas_size; 206 create_in = kvzalloc(inlen, GFP_KERNEL); 207 if (!create_in) 208 return -ENOMEM; 209 210 MLX5_SET(create_xrc_srq_in, create_in, uid, in->uid); 211 xrc_srqc = MLX5_ADDR_OF(create_xrc_srq_in, create_in, 212 xrc_srq_context_entry); 213 pas = MLX5_ADDR_OF(create_xrc_srq_in, create_in, pas); 214 215 set_srqc(xrc_srqc, in); 216 MLX5_SET(xrc_srqc, xrc_srqc, user_index, in->user_index); 217 memcpy(pas, in->pas, pas_size); 218 MLX5_SET(create_xrc_srq_in, create_in, opcode, 219 MLX5_CMD_OP_CREATE_XRC_SRQ); 220 221 memset(create_out, 0, sizeof(create_out)); 222 err = mlx5_cmd_exec(dev->mdev, create_in, inlen, create_out, 223 sizeof(create_out)); 224 if (err) 225 goto out; 226 227 srq->srqn = MLX5_GET(create_xrc_srq_out, create_out, xrc_srqn); 228 srq->uid = in->uid; 229 out: 230 kvfree(create_in); 231 return err; 232 } 233 234 static int destroy_xrc_srq_cmd(struct mlx5_ib_dev *dev, 235 struct mlx5_core_srq *srq) 236 { 237 u32 xrcsrq_in[MLX5_ST_SZ_DW(destroy_xrc_srq_in)] = {0}; 238 u32 xrcsrq_out[MLX5_ST_SZ_DW(destroy_xrc_srq_out)] = {0}; 239 240 MLX5_SET(destroy_xrc_srq_in, xrcsrq_in, opcode, 241 MLX5_CMD_OP_DESTROY_XRC_SRQ); 242 MLX5_SET(destroy_xrc_srq_in, xrcsrq_in, xrc_srqn, srq->srqn); 243 MLX5_SET(destroy_xrc_srq_in, xrcsrq_in, uid, srq->uid); 244 245 return mlx5_cmd_exec(dev->mdev, xrcsrq_in, sizeof(xrcsrq_in), 246 xrcsrq_out, sizeof(xrcsrq_out)); 247 } 248 249 static int arm_xrc_srq_cmd(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq, 250 u16 lwm) 251 { 252 u32 xrcsrq_in[MLX5_ST_SZ_DW(arm_xrc_srq_in)] = {0}; 253 u32 xrcsrq_out[MLX5_ST_SZ_DW(arm_xrc_srq_out)] = {0}; 254 255 MLX5_SET(arm_xrc_srq_in, xrcsrq_in, opcode, MLX5_CMD_OP_ARM_XRC_SRQ); 256 MLX5_SET(arm_xrc_srq_in, xrcsrq_in, op_mod, MLX5_ARM_XRC_SRQ_IN_OP_MOD_XRC_SRQ); 257 MLX5_SET(arm_xrc_srq_in, xrcsrq_in, xrc_srqn, srq->srqn); 258 MLX5_SET(arm_xrc_srq_in, xrcsrq_in, lwm, lwm); 259 MLX5_SET(arm_xrc_srq_in, xrcsrq_in, uid, srq->uid); 260 261 return mlx5_cmd_exec(dev->mdev, xrcsrq_in, sizeof(xrcsrq_in), 262 xrcsrq_out, sizeof(xrcsrq_out)); 263 } 264 265 static int query_xrc_srq_cmd(struct mlx5_ib_dev *dev, 266 struct mlx5_core_srq *srq, 267 struct mlx5_srq_attr *out) 268 { 269 u32 xrcsrq_in[MLX5_ST_SZ_DW(query_xrc_srq_in)]; 270 u32 *xrcsrq_out; 271 void *xrc_srqc; 272 int err; 273 274 xrcsrq_out = kvzalloc(MLX5_ST_SZ_BYTES(query_xrc_srq_out), GFP_KERNEL); 275 if (!xrcsrq_out) 276 return -ENOMEM; 277 memset(xrcsrq_in, 0, sizeof(xrcsrq_in)); 278 279 MLX5_SET(query_xrc_srq_in, xrcsrq_in, opcode, 280 MLX5_CMD_OP_QUERY_XRC_SRQ); 281 MLX5_SET(query_xrc_srq_in, xrcsrq_in, xrc_srqn, srq->srqn); 282 283 err = mlx5_cmd_exec(dev->mdev, xrcsrq_in, sizeof(xrcsrq_in), 284 xrcsrq_out, MLX5_ST_SZ_BYTES(query_xrc_srq_out)); 285 if (err) 286 goto out; 287 288 xrc_srqc = MLX5_ADDR_OF(query_xrc_srq_out, xrcsrq_out, 289 xrc_srq_context_entry); 290 get_srqc(xrc_srqc, out); 291 if (MLX5_GET(xrc_srqc, xrc_srqc, state) != MLX5_XRC_SRQC_STATE_GOOD) 292 out->flags |= MLX5_SRQ_FLAG_ERR; 293 294 out: 295 kvfree(xrcsrq_out); 296 return err; 297 } 298 299 static int create_rmp_cmd(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq, 300 struct mlx5_srq_attr *in) 301 { 302 void *create_out = NULL; 303 void *create_in = NULL; 304 void *rmpc; 305 void *wq; 306 int pas_size; 307 int outlen; 308 int inlen; 309 int err; 310 311 pas_size = get_pas_size(in); 312 inlen = MLX5_ST_SZ_BYTES(create_rmp_in) + pas_size; 313 outlen = MLX5_ST_SZ_BYTES(create_rmp_out); 314 create_in = kvzalloc(inlen, GFP_KERNEL); 315 create_out = kvzalloc(outlen, GFP_KERNEL); 316 if (!create_in || !create_out) { 317 err = -ENOMEM; 318 goto out; 319 } 320 321 rmpc = MLX5_ADDR_OF(create_rmp_in, create_in, ctx); 322 wq = MLX5_ADDR_OF(rmpc, rmpc, wq); 323 324 MLX5_SET(rmpc, rmpc, state, MLX5_RMPC_STATE_RDY); 325 MLX5_SET(create_rmp_in, create_in, uid, in->uid); 326 set_wq(wq, in); 327 memcpy(MLX5_ADDR_OF(rmpc, rmpc, wq.pas), in->pas, pas_size); 328 329 MLX5_SET(create_rmp_in, create_in, opcode, MLX5_CMD_OP_CREATE_RMP); 330 err = mlx5_cmd_exec(dev->mdev, create_in, inlen, create_out, outlen); 331 if (!err) { 332 srq->srqn = MLX5_GET(create_rmp_out, create_out, rmpn); 333 srq->uid = in->uid; 334 } 335 336 out: 337 kvfree(create_in); 338 kvfree(create_out); 339 return err; 340 } 341 342 static int destroy_rmp_cmd(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq) 343 { 344 u32 in[MLX5_ST_SZ_DW(destroy_rmp_in)] = {}; 345 u32 out[MLX5_ST_SZ_DW(destroy_rmp_out)] = {}; 346 347 MLX5_SET(destroy_rmp_in, in, opcode, MLX5_CMD_OP_DESTROY_RMP); 348 MLX5_SET(destroy_rmp_in, in, rmpn, srq->srqn); 349 MLX5_SET(destroy_rmp_in, in, uid, srq->uid); 350 return mlx5_cmd_exec(dev->mdev, in, sizeof(in), out, sizeof(out)); 351 } 352 353 static int arm_rmp_cmd(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq, 354 u16 lwm) 355 { 356 void *out = NULL; 357 void *in = NULL; 358 void *rmpc; 359 void *wq; 360 void *bitmask; 361 int outlen; 362 int inlen; 363 int err; 364 365 inlen = MLX5_ST_SZ_BYTES(modify_rmp_in); 366 outlen = MLX5_ST_SZ_BYTES(modify_rmp_out); 367 368 in = kvzalloc(inlen, GFP_KERNEL); 369 out = kvzalloc(outlen, GFP_KERNEL); 370 if (!in || !out) { 371 err = -ENOMEM; 372 goto out; 373 } 374 375 rmpc = MLX5_ADDR_OF(modify_rmp_in, in, ctx); 376 bitmask = MLX5_ADDR_OF(modify_rmp_in, in, bitmask); 377 wq = MLX5_ADDR_OF(rmpc, rmpc, wq); 378 379 MLX5_SET(modify_rmp_in, in, rmp_state, MLX5_RMPC_STATE_RDY); 380 MLX5_SET(modify_rmp_in, in, rmpn, srq->srqn); 381 MLX5_SET(modify_rmp_in, in, uid, srq->uid); 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 MLX5_SET(modify_rmp_in, in, opcode, MLX5_CMD_OP_MODIFY_RMP); 386 387 err = mlx5_cmd_exec(dev->mdev, in, inlen, out, outlen); 388 389 out: 390 kvfree(in); 391 kvfree(out); 392 return err; 393 } 394 395 static int query_rmp_cmd(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq, 396 struct mlx5_srq_attr *out) 397 { 398 u32 *rmp_out = NULL; 399 u32 *rmp_in = NULL; 400 void *rmpc; 401 int outlen; 402 int inlen; 403 int err; 404 405 outlen = MLX5_ST_SZ_BYTES(query_rmp_out); 406 inlen = MLX5_ST_SZ_BYTES(query_rmp_in); 407 408 rmp_out = kvzalloc(outlen, GFP_KERNEL); 409 rmp_in = kvzalloc(inlen, GFP_KERNEL); 410 if (!rmp_out || !rmp_in) { 411 err = -ENOMEM; 412 goto out; 413 } 414 415 MLX5_SET(query_rmp_in, rmp_in, opcode, MLX5_CMD_OP_QUERY_RMP); 416 MLX5_SET(query_rmp_in, rmp_in, rmpn, srq->srqn); 417 err = mlx5_cmd_exec(dev->mdev, rmp_in, inlen, rmp_out, outlen); 418 if (err) 419 goto out; 420 421 rmpc = MLX5_ADDR_OF(query_rmp_out, rmp_out, rmp_context); 422 get_wq(MLX5_ADDR_OF(rmpc, rmpc, wq), out); 423 if (MLX5_GET(rmpc, rmpc, state) != MLX5_RMPC_STATE_RDY) 424 out->flags |= MLX5_SRQ_FLAG_ERR; 425 426 out: 427 kvfree(rmp_out); 428 kvfree(rmp_in); 429 return err; 430 } 431 432 static int create_xrq_cmd(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq, 433 struct mlx5_srq_attr *in) 434 { 435 u32 create_out[MLX5_ST_SZ_DW(create_xrq_out)] = {0}; 436 void *create_in; 437 void *xrqc; 438 void *wq; 439 int pas_size; 440 int inlen; 441 int err; 442 443 pas_size = get_pas_size(in); 444 inlen = MLX5_ST_SZ_BYTES(create_xrq_in) + pas_size; 445 create_in = kvzalloc(inlen, GFP_KERNEL); 446 if (!create_in) 447 return -ENOMEM; 448 449 xrqc = MLX5_ADDR_OF(create_xrq_in, create_in, xrq_context); 450 wq = MLX5_ADDR_OF(xrqc, xrqc, wq); 451 452 set_wq(wq, in); 453 memcpy(MLX5_ADDR_OF(xrqc, xrqc, wq.pas), in->pas, pas_size); 454 455 if (in->type == IB_SRQT_TM) { 456 MLX5_SET(xrqc, xrqc, topology, MLX5_XRQC_TOPOLOGY_TAG_MATCHING); 457 if (in->flags & MLX5_SRQ_FLAG_RNDV) 458 MLX5_SET(xrqc, xrqc, offload, MLX5_XRQC_OFFLOAD_RNDV); 459 MLX5_SET(xrqc, xrqc, 460 tag_matching_topology_context.log_matching_list_sz, 461 in->tm_log_list_size); 462 } 463 MLX5_SET(xrqc, xrqc, user_index, in->user_index); 464 MLX5_SET(xrqc, xrqc, cqn, in->cqn); 465 MLX5_SET(create_xrq_in, create_in, opcode, MLX5_CMD_OP_CREATE_XRQ); 466 MLX5_SET(create_xrq_in, create_in, uid, in->uid); 467 err = mlx5_cmd_exec(dev->mdev, create_in, inlen, create_out, 468 sizeof(create_out)); 469 kvfree(create_in); 470 if (!err) { 471 srq->srqn = MLX5_GET(create_xrq_out, create_out, xrqn); 472 srq->uid = in->uid; 473 } 474 475 return err; 476 } 477 478 static int destroy_xrq_cmd(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq) 479 { 480 u32 in[MLX5_ST_SZ_DW(destroy_xrq_in)] = {0}; 481 u32 out[MLX5_ST_SZ_DW(destroy_xrq_out)] = {0}; 482 483 MLX5_SET(destroy_xrq_in, in, opcode, MLX5_CMD_OP_DESTROY_XRQ); 484 MLX5_SET(destroy_xrq_in, in, xrqn, srq->srqn); 485 MLX5_SET(destroy_xrq_in, in, uid, srq->uid); 486 487 return mlx5_cmd_exec(dev->mdev, in, sizeof(in), out, sizeof(out)); 488 } 489 490 static int arm_xrq_cmd(struct mlx5_ib_dev *dev, 491 struct mlx5_core_srq *srq, 492 u16 lwm) 493 { 494 u32 out[MLX5_ST_SZ_DW(arm_rq_out)] = {0}; 495 u32 in[MLX5_ST_SZ_DW(arm_rq_in)] = {0}; 496 497 MLX5_SET(arm_rq_in, in, opcode, MLX5_CMD_OP_ARM_RQ); 498 MLX5_SET(arm_rq_in, in, op_mod, MLX5_ARM_RQ_IN_OP_MOD_XRQ); 499 MLX5_SET(arm_rq_in, in, srq_number, srq->srqn); 500 MLX5_SET(arm_rq_in, in, lwm, lwm); 501 MLX5_SET(arm_rq_in, in, uid, srq->uid); 502 503 return mlx5_cmd_exec(dev->mdev, in, sizeof(in), out, sizeof(out)); 504 } 505 506 static int query_xrq_cmd(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq, 507 struct mlx5_srq_attr *out) 508 { 509 u32 in[MLX5_ST_SZ_DW(query_xrq_in)] = {0}; 510 u32 *xrq_out; 511 int outlen = MLX5_ST_SZ_BYTES(query_xrq_out); 512 void *xrqc; 513 int err; 514 515 xrq_out = kvzalloc(outlen, GFP_KERNEL); 516 if (!xrq_out) 517 return -ENOMEM; 518 519 MLX5_SET(query_xrq_in, in, opcode, MLX5_CMD_OP_QUERY_XRQ); 520 MLX5_SET(query_xrq_in, in, xrqn, srq->srqn); 521 522 err = mlx5_cmd_exec(dev->mdev, in, sizeof(in), xrq_out, outlen); 523 if (err) 524 goto out; 525 526 xrqc = MLX5_ADDR_OF(query_xrq_out, xrq_out, xrq_context); 527 get_wq(MLX5_ADDR_OF(xrqc, xrqc, wq), out); 528 if (MLX5_GET(xrqc, xrqc, state) != MLX5_XRQC_STATE_GOOD) 529 out->flags |= MLX5_SRQ_FLAG_ERR; 530 out->tm_next_tag = 531 MLX5_GET(xrqc, xrqc, 532 tag_matching_topology_context.append_next_index); 533 out->tm_hw_phase_cnt = 534 MLX5_GET(xrqc, xrqc, 535 tag_matching_topology_context.hw_phase_cnt); 536 out->tm_sw_phase_cnt = 537 MLX5_GET(xrqc, xrqc, 538 tag_matching_topology_context.sw_phase_cnt); 539 540 out: 541 kvfree(xrq_out); 542 return err; 543 } 544 545 static int create_srq_split(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq, 546 struct mlx5_srq_attr *in) 547 { 548 if (!dev->mdev->issi) 549 return create_srq_cmd(dev, srq, in); 550 switch (srq->common.res) { 551 case MLX5_RES_XSRQ: 552 return create_xrc_srq_cmd(dev, srq, in); 553 case MLX5_RES_XRQ: 554 return create_xrq_cmd(dev, srq, in); 555 default: 556 return create_rmp_cmd(dev, srq, in); 557 } 558 } 559 560 static int destroy_srq_split(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq) 561 { 562 if (!dev->mdev->issi) 563 return destroy_srq_cmd(dev, srq); 564 switch (srq->common.res) { 565 case MLX5_RES_XSRQ: 566 return destroy_xrc_srq_cmd(dev, srq); 567 case MLX5_RES_XRQ: 568 return destroy_xrq_cmd(dev, srq); 569 default: 570 return destroy_rmp_cmd(dev, srq); 571 } 572 } 573 574 int mlx5_cmd_create_srq(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq, 575 struct mlx5_srq_attr *in) 576 { 577 struct mlx5_srq_table *table = &dev->srq_table; 578 int err; 579 580 switch (in->type) { 581 case IB_SRQT_XRC: 582 srq->common.res = MLX5_RES_XSRQ; 583 break; 584 case IB_SRQT_TM: 585 srq->common.res = MLX5_RES_XRQ; 586 break; 587 default: 588 srq->common.res = MLX5_RES_SRQ; 589 } 590 591 err = create_srq_split(dev, srq, in); 592 if (err) 593 return err; 594 595 refcount_set(&srq->common.refcount, 1); 596 init_completion(&srq->common.free); 597 598 err = xa_err(xa_store_irq(&table->array, srq->srqn, srq, GFP_KERNEL)); 599 if (err) 600 goto err_destroy_srq_split; 601 602 return 0; 603 604 err_destroy_srq_split: 605 destroy_srq_split(dev, srq); 606 607 return err; 608 } 609 610 void mlx5_cmd_destroy_srq(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq) 611 { 612 struct mlx5_srq_table *table = &dev->srq_table; 613 struct mlx5_core_srq *tmp; 614 int err; 615 616 tmp = xa_erase_irq(&table->array, srq->srqn); 617 if (!tmp || tmp != srq) 618 return; 619 620 err = destroy_srq_split(dev, srq); 621 if (err) 622 return; 623 624 mlx5_core_res_put(&srq->common); 625 wait_for_completion(&srq->common.free); 626 } 627 628 int mlx5_cmd_query_srq(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq, 629 struct mlx5_srq_attr *out) 630 { 631 if (!dev->mdev->issi) 632 return query_srq_cmd(dev, srq, out); 633 switch (srq->common.res) { 634 case MLX5_RES_XSRQ: 635 return query_xrc_srq_cmd(dev, srq, out); 636 case MLX5_RES_XRQ: 637 return query_xrq_cmd(dev, srq, out); 638 default: 639 return query_rmp_cmd(dev, srq, out); 640 } 641 } 642 643 int mlx5_cmd_arm_srq(struct mlx5_ib_dev *dev, struct mlx5_core_srq *srq, 644 u16 lwm, int is_srq) 645 { 646 if (!dev->mdev->issi) 647 return arm_srq_cmd(dev, srq, lwm, is_srq); 648 switch (srq->common.res) { 649 case MLX5_RES_XSRQ: 650 return arm_xrc_srq_cmd(dev, srq, lwm); 651 case MLX5_RES_XRQ: 652 return arm_xrq_cmd(dev, srq, lwm); 653 default: 654 return arm_rmp_cmd(dev, srq, lwm); 655 } 656 } 657 658 static int srq_event_notifier(struct notifier_block *nb, 659 unsigned long type, void *data) 660 { 661 struct mlx5_srq_table *table; 662 struct mlx5_core_srq *srq; 663 struct mlx5_eqe *eqe; 664 u32 srqn; 665 666 if (type != MLX5_EVENT_TYPE_SRQ_CATAS_ERROR && 667 type != MLX5_EVENT_TYPE_SRQ_RQ_LIMIT) 668 return NOTIFY_DONE; 669 670 table = container_of(nb, struct mlx5_srq_table, nb); 671 672 eqe = data; 673 srqn = be32_to_cpu(eqe->data.qp_srq.qp_srq_n) & 0xffffff; 674 675 xa_lock(&table->array); 676 srq = xa_load(&table->array, srqn); 677 if (srq) 678 refcount_inc(&srq->common.refcount); 679 xa_unlock(&table->array); 680 681 if (!srq) 682 return NOTIFY_OK; 683 684 srq->event(srq, eqe->type); 685 686 mlx5_core_res_put(&srq->common); 687 688 return NOTIFY_OK; 689 } 690 691 int mlx5_init_srq_table(struct mlx5_ib_dev *dev) 692 { 693 struct mlx5_srq_table *table = &dev->srq_table; 694 695 memset(table, 0, sizeof(*table)); 696 xa_init_flags(&table->array, XA_FLAGS_LOCK_IRQ); 697 698 table->nb.notifier_call = srq_event_notifier; 699 mlx5_notifier_register(dev->mdev, &table->nb); 700 701 return 0; 702 } 703 704 void mlx5_cleanup_srq_table(struct mlx5_ib_dev *dev) 705 { 706 struct mlx5_srq_table *table = &dev->srq_table; 707 708 mlx5_notifier_unregister(dev->mdev, &table->nb); 709 } 710