This source file includes following definitions.
- mlx5_get_rsc
- mlx5_core_put_rsc
- qp_allowed_event_types
- rq_allowed_event_types
- sq_allowed_event_types
- dct_allowed_event_types
- is_event_type_allowed
- rsc_event_notifier
- create_resource_common
- destroy_resource_common
- _mlx5_core_destroy_dct
- mlx5_core_create_dct
- mlx5_core_create_qp
- mlx5_core_drain_dct
- mlx5_core_destroy_dct
- mlx5_core_destroy_qp
- mlx5_core_set_delay_drop
- mbox_alloc
- mbox_free
- modify_qp_mbox_alloc
- mlx5_core_qp_modify
- mlx5_init_qp_table
- mlx5_cleanup_qp_table
- mlx5_core_qp_query
- mlx5_core_dct_query
- mlx5_core_xrcd_alloc
- mlx5_core_xrcd_dealloc
- destroy_rq_tracked
- mlx5_core_create_rq_tracked
- mlx5_core_destroy_rq_tracked
- destroy_sq_tracked
- mlx5_core_create_sq_tracked
- mlx5_core_destroy_sq_tracked
- mlx5_core_alloc_q_counter
- mlx5_core_dealloc_q_counter
- mlx5_core_query_q_counter
- mlx5_core_res_hold
- mlx5_core_res_put
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33 #include <linux/gfp.h>
34 #include <linux/export.h>
35 #include <linux/mlx5/cmd.h>
36 #include <linux/mlx5/qp.h>
37 #include <linux/mlx5/driver.h>
38 #include <linux/mlx5/transobj.h>
39
40 #include "mlx5_core.h"
41 #include "lib/eq.h"
42
43 static int mlx5_core_drain_dct(struct mlx5_core_dev *dev,
44 struct mlx5_core_dct *dct);
45
46 static struct mlx5_core_rsc_common *
47 mlx5_get_rsc(struct mlx5_qp_table *table, u32 rsn)
48 {
49 struct mlx5_core_rsc_common *common;
50 unsigned long flags;
51
52 spin_lock_irqsave(&table->lock, flags);
53
54 common = radix_tree_lookup(&table->tree, rsn);
55 if (common)
56 refcount_inc(&common->refcount);
57
58 spin_unlock_irqrestore(&table->lock, flags);
59
60 return common;
61 }
62
63 void mlx5_core_put_rsc(struct mlx5_core_rsc_common *common)
64 {
65 if (refcount_dec_and_test(&common->refcount))
66 complete(&common->free);
67 }
68
69 static u64 qp_allowed_event_types(void)
70 {
71 u64 mask;
72
73 mask = BIT(MLX5_EVENT_TYPE_PATH_MIG) |
74 BIT(MLX5_EVENT_TYPE_COMM_EST) |
75 BIT(MLX5_EVENT_TYPE_SQ_DRAINED) |
76 BIT(MLX5_EVENT_TYPE_SRQ_LAST_WQE) |
77 BIT(MLX5_EVENT_TYPE_WQ_CATAS_ERROR) |
78 BIT(MLX5_EVENT_TYPE_PATH_MIG_FAILED) |
79 BIT(MLX5_EVENT_TYPE_WQ_INVAL_REQ_ERROR) |
80 BIT(MLX5_EVENT_TYPE_WQ_ACCESS_ERROR);
81
82 return mask;
83 }
84
85 static u64 rq_allowed_event_types(void)
86 {
87 u64 mask;
88
89 mask = BIT(MLX5_EVENT_TYPE_SRQ_LAST_WQE) |
90 BIT(MLX5_EVENT_TYPE_WQ_CATAS_ERROR);
91
92 return mask;
93 }
94
95 static u64 sq_allowed_event_types(void)
96 {
97 return BIT(MLX5_EVENT_TYPE_WQ_CATAS_ERROR);
98 }
99
100 static u64 dct_allowed_event_types(void)
101 {
102 return BIT(MLX5_EVENT_TYPE_DCT_DRAINED);
103 }
104
105 static bool is_event_type_allowed(int rsc_type, int event_type)
106 {
107 switch (rsc_type) {
108 case MLX5_EVENT_QUEUE_TYPE_QP:
109 return BIT(event_type) & qp_allowed_event_types();
110 case MLX5_EVENT_QUEUE_TYPE_RQ:
111 return BIT(event_type) & rq_allowed_event_types();
112 case MLX5_EVENT_QUEUE_TYPE_SQ:
113 return BIT(event_type) & sq_allowed_event_types();
114 case MLX5_EVENT_QUEUE_TYPE_DCT:
115 return BIT(event_type) & dct_allowed_event_types();
116 default:
117 WARN(1, "Event arrived for unknown resource type");
118 return false;
119 }
120 }
121
122 static int rsc_event_notifier(struct notifier_block *nb,
123 unsigned long type, void *data)
124 {
125 struct mlx5_core_rsc_common *common;
126 struct mlx5_qp_table *table;
127 struct mlx5_core_dev *dev;
128 struct mlx5_core_dct *dct;
129 u8 event_type = (u8)type;
130 struct mlx5_core_qp *qp;
131 struct mlx5_priv *priv;
132 struct mlx5_eqe *eqe;
133 u32 rsn;
134
135 switch (event_type) {
136 case MLX5_EVENT_TYPE_DCT_DRAINED:
137 eqe = data;
138 rsn = be32_to_cpu(eqe->data.dct.dctn) & 0xffffff;
139 rsn |= (MLX5_RES_DCT << MLX5_USER_INDEX_LEN);
140 break;
141 case MLX5_EVENT_TYPE_PATH_MIG:
142 case MLX5_EVENT_TYPE_COMM_EST:
143 case MLX5_EVENT_TYPE_SQ_DRAINED:
144 case MLX5_EVENT_TYPE_SRQ_LAST_WQE:
145 case MLX5_EVENT_TYPE_WQ_CATAS_ERROR:
146 case MLX5_EVENT_TYPE_PATH_MIG_FAILED:
147 case MLX5_EVENT_TYPE_WQ_INVAL_REQ_ERROR:
148 case MLX5_EVENT_TYPE_WQ_ACCESS_ERROR:
149 eqe = data;
150 rsn = be32_to_cpu(eqe->data.qp_srq.qp_srq_n) & 0xffffff;
151 rsn |= (eqe->data.qp_srq.type << MLX5_USER_INDEX_LEN);
152 break;
153 default:
154 return NOTIFY_DONE;
155 }
156
157 table = container_of(nb, struct mlx5_qp_table, nb);
158 priv = container_of(table, struct mlx5_priv, qp_table);
159 dev = container_of(priv, struct mlx5_core_dev, priv);
160
161 mlx5_core_dbg(dev, "event (%d) arrived on resource 0x%x\n", eqe->type, rsn);
162
163 common = mlx5_get_rsc(table, rsn);
164 if (!common) {
165 mlx5_core_dbg(dev, "Async event for unknown resource 0x%x\n", rsn);
166 return NOTIFY_OK;
167 }
168
169 if (!is_event_type_allowed((rsn >> MLX5_USER_INDEX_LEN), event_type)) {
170 mlx5_core_warn(dev, "event 0x%.2x is not allowed on resource 0x%.8x\n",
171 event_type, rsn);
172 goto out;
173 }
174
175 switch (common->res) {
176 case MLX5_RES_QP:
177 case MLX5_RES_RQ:
178 case MLX5_RES_SQ:
179 qp = (struct mlx5_core_qp *)common;
180 qp->event(qp, event_type);
181 break;
182 case MLX5_RES_DCT:
183 dct = (struct mlx5_core_dct *)common;
184 if (event_type == MLX5_EVENT_TYPE_DCT_DRAINED)
185 complete(&dct->drained);
186 break;
187 default:
188 mlx5_core_warn(dev, "invalid resource type for 0x%x\n", rsn);
189 }
190 out:
191 mlx5_core_put_rsc(common);
192
193 return NOTIFY_OK;
194 }
195
196 static int create_resource_common(struct mlx5_core_dev *dev,
197 struct mlx5_core_qp *qp,
198 int rsc_type)
199 {
200 struct mlx5_qp_table *table = &dev->priv.qp_table;
201 int err;
202
203 qp->common.res = rsc_type;
204 spin_lock_irq(&table->lock);
205 err = radix_tree_insert(&table->tree,
206 qp->qpn | (rsc_type << MLX5_USER_INDEX_LEN),
207 qp);
208 spin_unlock_irq(&table->lock);
209 if (err)
210 return err;
211
212 refcount_set(&qp->common.refcount, 1);
213 init_completion(&qp->common.free);
214 qp->pid = current->pid;
215
216 return 0;
217 }
218
219 static void destroy_resource_common(struct mlx5_core_dev *dev,
220 struct mlx5_core_qp *qp)
221 {
222 struct mlx5_qp_table *table = &dev->priv.qp_table;
223 unsigned long flags;
224
225 spin_lock_irqsave(&table->lock, flags);
226 radix_tree_delete(&table->tree,
227 qp->qpn | (qp->common.res << MLX5_USER_INDEX_LEN));
228 spin_unlock_irqrestore(&table->lock, flags);
229 mlx5_core_put_rsc((struct mlx5_core_rsc_common *)qp);
230 wait_for_completion(&qp->common.free);
231 }
232
233 static int _mlx5_core_destroy_dct(struct mlx5_core_dev *dev,
234 struct mlx5_core_dct *dct, bool need_cleanup)
235 {
236 u32 out[MLX5_ST_SZ_DW(destroy_dct_out)] = {0};
237 u32 in[MLX5_ST_SZ_DW(destroy_dct_in)] = {0};
238 struct mlx5_core_qp *qp = &dct->mqp;
239 int err;
240
241 err = mlx5_core_drain_dct(dev, dct);
242 if (err) {
243 if (dev->state == MLX5_DEVICE_STATE_INTERNAL_ERROR) {
244 goto destroy;
245 } else {
246 mlx5_core_warn(
247 dev, "failed drain DCT 0x%x with error 0x%x\n",
248 qp->qpn, err);
249 return err;
250 }
251 }
252 wait_for_completion(&dct->drained);
253 destroy:
254 if (need_cleanup)
255 destroy_resource_common(dev, &dct->mqp);
256 MLX5_SET(destroy_dct_in, in, opcode, MLX5_CMD_OP_DESTROY_DCT);
257 MLX5_SET(destroy_dct_in, in, dctn, qp->qpn);
258 MLX5_SET(destroy_dct_in, in, uid, qp->uid);
259 err = mlx5_cmd_exec(dev, (void *)&in, sizeof(in),
260 (void *)&out, sizeof(out));
261 return err;
262 }
263
264 int mlx5_core_create_dct(struct mlx5_core_dev *dev,
265 struct mlx5_core_dct *dct,
266 u32 *in, int inlen,
267 u32 *out, int outlen)
268 {
269 struct mlx5_core_qp *qp = &dct->mqp;
270 int err;
271
272 init_completion(&dct->drained);
273 MLX5_SET(create_dct_in, in, opcode, MLX5_CMD_OP_CREATE_DCT);
274
275 err = mlx5_cmd_exec(dev, in, inlen, out, outlen);
276 if (err) {
277 mlx5_core_warn(dev, "create DCT failed, ret %d\n", err);
278 return err;
279 }
280
281 qp->qpn = MLX5_GET(create_dct_out, out, dctn);
282 qp->uid = MLX5_GET(create_dct_in, in, uid);
283 err = create_resource_common(dev, qp, MLX5_RES_DCT);
284 if (err)
285 goto err_cmd;
286
287 return 0;
288 err_cmd:
289 _mlx5_core_destroy_dct(dev, dct, false);
290 return err;
291 }
292 EXPORT_SYMBOL_GPL(mlx5_core_create_dct);
293
294 int mlx5_core_create_qp(struct mlx5_core_dev *dev,
295 struct mlx5_core_qp *qp,
296 u32 *in, int inlen)
297 {
298 u32 out[MLX5_ST_SZ_DW(create_qp_out)] = {0};
299 u32 dout[MLX5_ST_SZ_DW(destroy_qp_out)];
300 u32 din[MLX5_ST_SZ_DW(destroy_qp_in)];
301 int err;
302
303 MLX5_SET(create_qp_in, in, opcode, MLX5_CMD_OP_CREATE_QP);
304
305 err = mlx5_cmd_exec(dev, in, inlen, out, sizeof(out));
306 if (err)
307 return err;
308
309 qp->uid = MLX5_GET(create_qp_in, in, uid);
310 qp->qpn = MLX5_GET(create_qp_out, out, qpn);
311 mlx5_core_dbg(dev, "qpn = 0x%x\n", qp->qpn);
312
313 err = create_resource_common(dev, qp, MLX5_RES_QP);
314 if (err)
315 goto err_cmd;
316
317 err = mlx5_debug_qp_add(dev, qp);
318 if (err)
319 mlx5_core_dbg(dev, "failed adding QP 0x%x to debug file system\n",
320 qp->qpn);
321
322 atomic_inc(&dev->num_qps);
323
324 return 0;
325
326 err_cmd:
327 memset(din, 0, sizeof(din));
328 memset(dout, 0, sizeof(dout));
329 MLX5_SET(destroy_qp_in, din, opcode, MLX5_CMD_OP_DESTROY_QP);
330 MLX5_SET(destroy_qp_in, din, qpn, qp->qpn);
331 MLX5_SET(destroy_qp_in, din, uid, qp->uid);
332 mlx5_cmd_exec(dev, din, sizeof(din), dout, sizeof(dout));
333 return err;
334 }
335 EXPORT_SYMBOL_GPL(mlx5_core_create_qp);
336
337 static int mlx5_core_drain_dct(struct mlx5_core_dev *dev,
338 struct mlx5_core_dct *dct)
339 {
340 u32 out[MLX5_ST_SZ_DW(drain_dct_out)] = {0};
341 u32 in[MLX5_ST_SZ_DW(drain_dct_in)] = {0};
342 struct mlx5_core_qp *qp = &dct->mqp;
343
344 MLX5_SET(drain_dct_in, in, opcode, MLX5_CMD_OP_DRAIN_DCT);
345 MLX5_SET(drain_dct_in, in, dctn, qp->qpn);
346 MLX5_SET(drain_dct_in, in, uid, qp->uid);
347 return mlx5_cmd_exec(dev, (void *)&in, sizeof(in),
348 (void *)&out, sizeof(out));
349 }
350
351 int mlx5_core_destroy_dct(struct mlx5_core_dev *dev,
352 struct mlx5_core_dct *dct)
353 {
354 return _mlx5_core_destroy_dct(dev, dct, true);
355 }
356 EXPORT_SYMBOL_GPL(mlx5_core_destroy_dct);
357
358 int mlx5_core_destroy_qp(struct mlx5_core_dev *dev,
359 struct mlx5_core_qp *qp)
360 {
361 u32 out[MLX5_ST_SZ_DW(destroy_qp_out)] = {0};
362 u32 in[MLX5_ST_SZ_DW(destroy_qp_in)] = {0};
363 int err;
364
365 mlx5_debug_qp_remove(dev, qp);
366
367 destroy_resource_common(dev, qp);
368
369 MLX5_SET(destroy_qp_in, in, opcode, MLX5_CMD_OP_DESTROY_QP);
370 MLX5_SET(destroy_qp_in, in, qpn, qp->qpn);
371 MLX5_SET(destroy_qp_in, in, uid, qp->uid);
372 err = mlx5_cmd_exec(dev, in, sizeof(in), out, sizeof(out));
373 if (err)
374 return err;
375
376 atomic_dec(&dev->num_qps);
377 return 0;
378 }
379 EXPORT_SYMBOL_GPL(mlx5_core_destroy_qp);
380
381 int mlx5_core_set_delay_drop(struct mlx5_core_dev *dev,
382 u32 timeout_usec)
383 {
384 u32 out[MLX5_ST_SZ_DW(set_delay_drop_params_out)] = {0};
385 u32 in[MLX5_ST_SZ_DW(set_delay_drop_params_in)] = {0};
386
387 MLX5_SET(set_delay_drop_params_in, in, opcode,
388 MLX5_CMD_OP_SET_DELAY_DROP_PARAMS);
389 MLX5_SET(set_delay_drop_params_in, in, delay_drop_timeout,
390 timeout_usec / 100);
391 return mlx5_cmd_exec(dev, in, sizeof(in), out, sizeof(out));
392 }
393 EXPORT_SYMBOL_GPL(mlx5_core_set_delay_drop);
394
395 struct mbox_info {
396 u32 *in;
397 u32 *out;
398 int inlen;
399 int outlen;
400 };
401
402 static int mbox_alloc(struct mbox_info *mbox, int inlen, int outlen)
403 {
404 mbox->inlen = inlen;
405 mbox->outlen = outlen;
406 mbox->in = kzalloc(mbox->inlen, GFP_KERNEL);
407 mbox->out = kzalloc(mbox->outlen, GFP_KERNEL);
408 if (!mbox->in || !mbox->out) {
409 kfree(mbox->in);
410 kfree(mbox->out);
411 return -ENOMEM;
412 }
413
414 return 0;
415 }
416
417 static void mbox_free(struct mbox_info *mbox)
418 {
419 kfree(mbox->in);
420 kfree(mbox->out);
421 }
422
423 static int modify_qp_mbox_alloc(struct mlx5_core_dev *dev, u16 opcode, int qpn,
424 u32 opt_param_mask, void *qpc,
425 struct mbox_info *mbox, u16 uid)
426 {
427 mbox->out = NULL;
428 mbox->in = NULL;
429
430 #define MBOX_ALLOC(mbox, typ) \
431 mbox_alloc(mbox, MLX5_ST_SZ_BYTES(typ##_in), MLX5_ST_SZ_BYTES(typ##_out))
432
433 #define MOD_QP_IN_SET(typ, in, _opcode, _qpn, _uid) \
434 do { \
435 MLX5_SET(typ##_in, in, opcode, _opcode); \
436 MLX5_SET(typ##_in, in, qpn, _qpn); \
437 MLX5_SET(typ##_in, in, uid, _uid); \
438 } while (0)
439
440 #define MOD_QP_IN_SET_QPC(typ, in, _opcode, _qpn, _opt_p, _qpc, _uid) \
441 do { \
442 MOD_QP_IN_SET(typ, in, _opcode, _qpn, _uid); \
443 MLX5_SET(typ##_in, in, opt_param_mask, _opt_p); \
444 memcpy(MLX5_ADDR_OF(typ##_in, in, qpc), _qpc, \
445 MLX5_ST_SZ_BYTES(qpc)); \
446 } while (0)
447
448 switch (opcode) {
449
450 case MLX5_CMD_OP_2RST_QP:
451 if (MBOX_ALLOC(mbox, qp_2rst))
452 return -ENOMEM;
453 MOD_QP_IN_SET(qp_2rst, mbox->in, opcode, qpn, uid);
454 break;
455 case MLX5_CMD_OP_2ERR_QP:
456 if (MBOX_ALLOC(mbox, qp_2err))
457 return -ENOMEM;
458 MOD_QP_IN_SET(qp_2err, mbox->in, opcode, qpn, uid);
459 break;
460
461
462 case MLX5_CMD_OP_RST2INIT_QP:
463 if (MBOX_ALLOC(mbox, rst2init_qp))
464 return -ENOMEM;
465 MOD_QP_IN_SET_QPC(rst2init_qp, mbox->in, opcode, qpn,
466 opt_param_mask, qpc, uid);
467 break;
468 case MLX5_CMD_OP_INIT2RTR_QP:
469 if (MBOX_ALLOC(mbox, init2rtr_qp))
470 return -ENOMEM;
471 MOD_QP_IN_SET_QPC(init2rtr_qp, mbox->in, opcode, qpn,
472 opt_param_mask, qpc, uid);
473 break;
474 case MLX5_CMD_OP_RTR2RTS_QP:
475 if (MBOX_ALLOC(mbox, rtr2rts_qp))
476 return -ENOMEM;
477 MOD_QP_IN_SET_QPC(rtr2rts_qp, mbox->in, opcode, qpn,
478 opt_param_mask, qpc, uid);
479 break;
480 case MLX5_CMD_OP_RTS2RTS_QP:
481 if (MBOX_ALLOC(mbox, rts2rts_qp))
482 return -ENOMEM;
483 MOD_QP_IN_SET_QPC(rts2rts_qp, mbox->in, opcode, qpn,
484 opt_param_mask, qpc, uid);
485 break;
486 case MLX5_CMD_OP_SQERR2RTS_QP:
487 if (MBOX_ALLOC(mbox, sqerr2rts_qp))
488 return -ENOMEM;
489 MOD_QP_IN_SET_QPC(sqerr2rts_qp, mbox->in, opcode, qpn,
490 opt_param_mask, qpc, uid);
491 break;
492 case MLX5_CMD_OP_INIT2INIT_QP:
493 if (MBOX_ALLOC(mbox, init2init_qp))
494 return -ENOMEM;
495 MOD_QP_IN_SET_QPC(init2init_qp, mbox->in, opcode, qpn,
496 opt_param_mask, qpc, uid);
497 break;
498 default:
499 mlx5_core_err(dev, "Unknown transition for modify QP: OP(0x%x) QPN(0x%x)\n",
500 opcode, qpn);
501 return -EINVAL;
502 }
503 return 0;
504 }
505
506 int mlx5_core_qp_modify(struct mlx5_core_dev *dev, u16 opcode,
507 u32 opt_param_mask, void *qpc,
508 struct mlx5_core_qp *qp)
509 {
510 struct mbox_info mbox;
511 int err;
512
513 err = modify_qp_mbox_alloc(dev, opcode, qp->qpn,
514 opt_param_mask, qpc, &mbox, qp->uid);
515 if (err)
516 return err;
517
518 err = mlx5_cmd_exec(dev, mbox.in, mbox.inlen, mbox.out, mbox.outlen);
519 mbox_free(&mbox);
520 return err;
521 }
522 EXPORT_SYMBOL_GPL(mlx5_core_qp_modify);
523
524 void mlx5_init_qp_table(struct mlx5_core_dev *dev)
525 {
526 struct mlx5_qp_table *table = &dev->priv.qp_table;
527
528 memset(table, 0, sizeof(*table));
529 spin_lock_init(&table->lock);
530 INIT_RADIX_TREE(&table->tree, GFP_ATOMIC);
531 mlx5_qp_debugfs_init(dev);
532
533 table->nb.notifier_call = rsc_event_notifier;
534 mlx5_notifier_register(dev, &table->nb);
535 }
536
537 void mlx5_cleanup_qp_table(struct mlx5_core_dev *dev)
538 {
539 struct mlx5_qp_table *table = &dev->priv.qp_table;
540
541 mlx5_notifier_unregister(dev, &table->nb);
542 mlx5_qp_debugfs_cleanup(dev);
543 }
544
545 int mlx5_core_qp_query(struct mlx5_core_dev *dev, struct mlx5_core_qp *qp,
546 u32 *out, int outlen)
547 {
548 u32 in[MLX5_ST_SZ_DW(query_qp_in)] = {0};
549
550 MLX5_SET(query_qp_in, in, opcode, MLX5_CMD_OP_QUERY_QP);
551 MLX5_SET(query_qp_in, in, qpn, qp->qpn);
552 return mlx5_cmd_exec(dev, in, sizeof(in), out, outlen);
553 }
554 EXPORT_SYMBOL_GPL(mlx5_core_qp_query);
555
556 int mlx5_core_dct_query(struct mlx5_core_dev *dev, struct mlx5_core_dct *dct,
557 u32 *out, int outlen)
558 {
559 u32 in[MLX5_ST_SZ_DW(query_dct_in)] = {0};
560 struct mlx5_core_qp *qp = &dct->mqp;
561
562 MLX5_SET(query_dct_in, in, opcode, MLX5_CMD_OP_QUERY_DCT);
563 MLX5_SET(query_dct_in, in, dctn, qp->qpn);
564
565 return mlx5_cmd_exec(dev, (void *)&in, sizeof(in),
566 (void *)out, outlen);
567 }
568 EXPORT_SYMBOL_GPL(mlx5_core_dct_query);
569
570 int mlx5_core_xrcd_alloc(struct mlx5_core_dev *dev, u32 *xrcdn)
571 {
572 u32 out[MLX5_ST_SZ_DW(alloc_xrcd_out)] = {0};
573 u32 in[MLX5_ST_SZ_DW(alloc_xrcd_in)] = {0};
574 int err;
575
576 MLX5_SET(alloc_xrcd_in, in, opcode, MLX5_CMD_OP_ALLOC_XRCD);
577 err = mlx5_cmd_exec(dev, in, sizeof(in), out, sizeof(out));
578 if (!err)
579 *xrcdn = MLX5_GET(alloc_xrcd_out, out, xrcd);
580 return err;
581 }
582 EXPORT_SYMBOL_GPL(mlx5_core_xrcd_alloc);
583
584 int mlx5_core_xrcd_dealloc(struct mlx5_core_dev *dev, u32 xrcdn)
585 {
586 u32 out[MLX5_ST_SZ_DW(dealloc_xrcd_out)] = {0};
587 u32 in[MLX5_ST_SZ_DW(dealloc_xrcd_in)] = {0};
588
589 MLX5_SET(dealloc_xrcd_in, in, opcode, MLX5_CMD_OP_DEALLOC_XRCD);
590 MLX5_SET(dealloc_xrcd_in, in, xrcd, xrcdn);
591 return mlx5_cmd_exec(dev, in, sizeof(in), out, sizeof(out));
592 }
593 EXPORT_SYMBOL_GPL(mlx5_core_xrcd_dealloc);
594
595 static void destroy_rq_tracked(struct mlx5_core_dev *dev, u32 rqn, u16 uid)
596 {
597 u32 in[MLX5_ST_SZ_DW(destroy_rq_in)] = {};
598 u32 out[MLX5_ST_SZ_DW(destroy_rq_out)] = {};
599
600 MLX5_SET(destroy_rq_in, in, opcode, MLX5_CMD_OP_DESTROY_RQ);
601 MLX5_SET(destroy_rq_in, in, rqn, rqn);
602 MLX5_SET(destroy_rq_in, in, uid, uid);
603 mlx5_cmd_exec(dev, in, sizeof(in), out, sizeof(out));
604 }
605
606 int mlx5_core_create_rq_tracked(struct mlx5_core_dev *dev, u32 *in, int inlen,
607 struct mlx5_core_qp *rq)
608 {
609 int err;
610 u32 rqn;
611
612 err = mlx5_core_create_rq(dev, in, inlen, &rqn);
613 if (err)
614 return err;
615
616 rq->uid = MLX5_GET(create_rq_in, in, uid);
617 rq->qpn = rqn;
618 err = create_resource_common(dev, rq, MLX5_RES_RQ);
619 if (err)
620 goto err_destroy_rq;
621
622 return 0;
623
624 err_destroy_rq:
625 destroy_rq_tracked(dev, rq->qpn, rq->uid);
626
627 return err;
628 }
629 EXPORT_SYMBOL(mlx5_core_create_rq_tracked);
630
631 void mlx5_core_destroy_rq_tracked(struct mlx5_core_dev *dev,
632 struct mlx5_core_qp *rq)
633 {
634 destroy_resource_common(dev, rq);
635 destroy_rq_tracked(dev, rq->qpn, rq->uid);
636 }
637 EXPORT_SYMBOL(mlx5_core_destroy_rq_tracked);
638
639 static void destroy_sq_tracked(struct mlx5_core_dev *dev, u32 sqn, u16 uid)
640 {
641 u32 in[MLX5_ST_SZ_DW(destroy_sq_in)] = {};
642 u32 out[MLX5_ST_SZ_DW(destroy_sq_out)] = {};
643
644 MLX5_SET(destroy_sq_in, in, opcode, MLX5_CMD_OP_DESTROY_SQ);
645 MLX5_SET(destroy_sq_in, in, sqn, sqn);
646 MLX5_SET(destroy_sq_in, in, uid, uid);
647 mlx5_cmd_exec(dev, in, sizeof(in), out, sizeof(out));
648 }
649
650 int mlx5_core_create_sq_tracked(struct mlx5_core_dev *dev, u32 *in, int inlen,
651 struct mlx5_core_qp *sq)
652 {
653 int err;
654 u32 sqn;
655
656 err = mlx5_core_create_sq(dev, in, inlen, &sqn);
657 if (err)
658 return err;
659
660 sq->uid = MLX5_GET(create_sq_in, in, uid);
661 sq->qpn = sqn;
662 err = create_resource_common(dev, sq, MLX5_RES_SQ);
663 if (err)
664 goto err_destroy_sq;
665
666 return 0;
667
668 err_destroy_sq:
669 destroy_sq_tracked(dev, sq->qpn, sq->uid);
670
671 return err;
672 }
673 EXPORT_SYMBOL(mlx5_core_create_sq_tracked);
674
675 void mlx5_core_destroy_sq_tracked(struct mlx5_core_dev *dev,
676 struct mlx5_core_qp *sq)
677 {
678 destroy_resource_common(dev, sq);
679 destroy_sq_tracked(dev, sq->qpn, sq->uid);
680 }
681 EXPORT_SYMBOL(mlx5_core_destroy_sq_tracked);
682
683 int mlx5_core_alloc_q_counter(struct mlx5_core_dev *dev, u16 *counter_id)
684 {
685 u32 in[MLX5_ST_SZ_DW(alloc_q_counter_in)] = {0};
686 u32 out[MLX5_ST_SZ_DW(alloc_q_counter_out)] = {0};
687 int err;
688
689 MLX5_SET(alloc_q_counter_in, in, opcode, MLX5_CMD_OP_ALLOC_Q_COUNTER);
690 err = mlx5_cmd_exec(dev, in, sizeof(in), out, sizeof(out));
691 if (!err)
692 *counter_id = MLX5_GET(alloc_q_counter_out, out,
693 counter_set_id);
694 return err;
695 }
696 EXPORT_SYMBOL_GPL(mlx5_core_alloc_q_counter);
697
698 int mlx5_core_dealloc_q_counter(struct mlx5_core_dev *dev, u16 counter_id)
699 {
700 u32 in[MLX5_ST_SZ_DW(dealloc_q_counter_in)] = {0};
701 u32 out[MLX5_ST_SZ_DW(dealloc_q_counter_out)] = {0};
702
703 MLX5_SET(dealloc_q_counter_in, in, opcode,
704 MLX5_CMD_OP_DEALLOC_Q_COUNTER);
705 MLX5_SET(dealloc_q_counter_in, in, counter_set_id, counter_id);
706 return mlx5_cmd_exec(dev, in, sizeof(in), out, sizeof(out));
707 }
708 EXPORT_SYMBOL_GPL(mlx5_core_dealloc_q_counter);
709
710 int mlx5_core_query_q_counter(struct mlx5_core_dev *dev, u16 counter_id,
711 int reset, void *out, int out_size)
712 {
713 u32 in[MLX5_ST_SZ_DW(query_q_counter_in)] = {0};
714
715 MLX5_SET(query_q_counter_in, in, opcode, MLX5_CMD_OP_QUERY_Q_COUNTER);
716 MLX5_SET(query_q_counter_in, in, clear, reset);
717 MLX5_SET(query_q_counter_in, in, counter_set_id, counter_id);
718 return mlx5_cmd_exec(dev, in, sizeof(in), out, out_size);
719 }
720 EXPORT_SYMBOL_GPL(mlx5_core_query_q_counter);
721
722 struct mlx5_core_rsc_common *mlx5_core_res_hold(struct mlx5_core_dev *dev,
723 int res_num,
724 enum mlx5_res_type res_type)
725 {
726 u32 rsn = res_num | (res_type << MLX5_USER_INDEX_LEN);
727 struct mlx5_qp_table *table = &dev->priv.qp_table;
728
729 return mlx5_get_rsc(table, rsn);
730 }
731 EXPORT_SYMBOL_GPL(mlx5_core_res_hold);
732
733 void mlx5_core_res_put(struct mlx5_core_rsc_common *res)
734 {
735 mlx5_core_put_rsc(res);
736 }
737 EXPORT_SYMBOL_GPL(mlx5_core_res_put);