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