net/mlx5: FPGA, Properly initialize dma direction on fpga conn send
[sfrench/cifs-2.6.git] / drivers / net / ethernet / mellanox / mlx5 / core / fpga / conn.c
1 /*
2  * Copyright (c) 2017 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
34 #include <net/addrconf.h>
35 #include <linux/etherdevice.h>
36 #include <linux/mlx5/vport.h>
37
38 #include "mlx5_core.h"
39 #include "lib/mlx5.h"
40 #include "fpga/conn.h"
41
42 #define MLX5_FPGA_PKEY 0xFFFF
43 #define MLX5_FPGA_PKEY_INDEX 0 /* RoCE PKEY 0xFFFF is always at index 0 */
44 #define MLX5_FPGA_RECV_SIZE 2048
45 #define MLX5_FPGA_PORT_NUM 1
46 #define MLX5_FPGA_CQ_BUDGET 64
47
48 static int mlx5_fpga_conn_map_buf(struct mlx5_fpga_conn *conn,
49                                   struct mlx5_fpga_dma_buf *buf)
50 {
51         struct device *dma_device;
52         int err = 0;
53
54         if (unlikely(!buf->sg[0].data))
55                 goto out;
56
57         dma_device = &conn->fdev->mdev->pdev->dev;
58         buf->sg[0].dma_addr = dma_map_single(dma_device, buf->sg[0].data,
59                                              buf->sg[0].size, buf->dma_dir);
60         err = dma_mapping_error(dma_device, buf->sg[0].dma_addr);
61         if (unlikely(err)) {
62                 mlx5_fpga_warn(conn->fdev, "DMA error on sg 0: %d\n", err);
63                 err = -ENOMEM;
64                 goto out;
65         }
66
67         if (!buf->sg[1].data)
68                 goto out;
69
70         buf->sg[1].dma_addr = dma_map_single(dma_device, buf->sg[1].data,
71                                              buf->sg[1].size, buf->dma_dir);
72         err = dma_mapping_error(dma_device, buf->sg[1].dma_addr);
73         if (unlikely(err)) {
74                 mlx5_fpga_warn(conn->fdev, "DMA error on sg 1: %d\n", err);
75                 dma_unmap_single(dma_device, buf->sg[0].dma_addr,
76                                  buf->sg[0].size, buf->dma_dir);
77                 err = -ENOMEM;
78         }
79
80 out:
81         return err;
82 }
83
84 static void mlx5_fpga_conn_unmap_buf(struct mlx5_fpga_conn *conn,
85                                      struct mlx5_fpga_dma_buf *buf)
86 {
87         struct device *dma_device;
88
89         dma_device = &conn->fdev->mdev->pdev->dev;
90         if (buf->sg[1].data)
91                 dma_unmap_single(dma_device, buf->sg[1].dma_addr,
92                                  buf->sg[1].size, buf->dma_dir);
93
94         if (likely(buf->sg[0].data))
95                 dma_unmap_single(dma_device, buf->sg[0].dma_addr,
96                                  buf->sg[0].size, buf->dma_dir);
97 }
98
99 static int mlx5_fpga_conn_post_recv(struct mlx5_fpga_conn *conn,
100                                     struct mlx5_fpga_dma_buf *buf)
101 {
102         struct mlx5_wqe_data_seg *data;
103         unsigned int ix;
104         int err = 0;
105
106         err = mlx5_fpga_conn_map_buf(conn, buf);
107         if (unlikely(err))
108                 goto out;
109
110         if (unlikely(conn->qp.rq.pc - conn->qp.rq.cc >= conn->qp.rq.size)) {
111                 mlx5_fpga_conn_unmap_buf(conn, buf);
112                 return -EBUSY;
113         }
114
115         ix = conn->qp.rq.pc & (conn->qp.rq.size - 1);
116         data = mlx5_wq_cyc_get_wqe(&conn->qp.wq.rq, ix);
117         data->byte_count = cpu_to_be32(buf->sg[0].size);
118         data->lkey = cpu_to_be32(conn->fdev->conn_res.mkey.key);
119         data->addr = cpu_to_be64(buf->sg[0].dma_addr);
120
121         conn->qp.rq.pc++;
122         conn->qp.rq.bufs[ix] = buf;
123
124         /* Make sure that descriptors are written before doorbell record. */
125         dma_wmb();
126         *conn->qp.wq.rq.db = cpu_to_be32(conn->qp.rq.pc & 0xffff);
127 out:
128         return err;
129 }
130
131 static void mlx5_fpga_conn_notify_hw(struct mlx5_fpga_conn *conn, void *wqe)
132 {
133         /* ensure wqe is visible to device before updating doorbell record */
134         dma_wmb();
135         *conn->qp.wq.sq.db = cpu_to_be32(conn->qp.sq.pc);
136         /* Make sure that doorbell record is visible before ringing */
137         wmb();
138         mlx5_write64(wqe, conn->fdev->conn_res.uar->map + MLX5_BF_OFFSET, NULL);
139 }
140
141 static void mlx5_fpga_conn_post_send(struct mlx5_fpga_conn *conn,
142                                      struct mlx5_fpga_dma_buf *buf)
143 {
144         struct mlx5_wqe_ctrl_seg *ctrl;
145         struct mlx5_wqe_data_seg *data;
146         unsigned int ix, sgi;
147         int size = 1;
148
149         ix = conn->qp.sq.pc & (conn->qp.sq.size - 1);
150
151         ctrl = mlx5_wq_cyc_get_wqe(&conn->qp.wq.sq, ix);
152         data = (void *)(ctrl + 1);
153
154         for (sgi = 0; sgi < ARRAY_SIZE(buf->sg); sgi++) {
155                 if (!buf->sg[sgi].data)
156                         break;
157                 data->byte_count = cpu_to_be32(buf->sg[sgi].size);
158                 data->lkey = cpu_to_be32(conn->fdev->conn_res.mkey.key);
159                 data->addr = cpu_to_be64(buf->sg[sgi].dma_addr);
160                 data++;
161                 size++;
162         }
163
164         ctrl->imm = 0;
165         ctrl->fm_ce_se = MLX5_WQE_CTRL_CQ_UPDATE;
166         ctrl->opmod_idx_opcode = cpu_to_be32(((conn->qp.sq.pc & 0xffff) << 8) |
167                                              MLX5_OPCODE_SEND);
168         ctrl->qpn_ds = cpu_to_be32(size | (conn->qp.mqp.qpn << 8));
169
170         conn->qp.sq.pc++;
171         conn->qp.sq.bufs[ix] = buf;
172         mlx5_fpga_conn_notify_hw(conn, ctrl);
173 }
174
175 int mlx5_fpga_conn_send(struct mlx5_fpga_conn *conn,
176                         struct mlx5_fpga_dma_buf *buf)
177 {
178         unsigned long flags;
179         int err;
180
181         if (!conn->qp.active)
182                 return -ENOTCONN;
183
184         buf->dma_dir = DMA_TO_DEVICE;
185         err = mlx5_fpga_conn_map_buf(conn, buf);
186         if (err)
187                 return err;
188
189         spin_lock_irqsave(&conn->qp.sq.lock, flags);
190
191         if (conn->qp.sq.pc - conn->qp.sq.cc >= conn->qp.sq.size) {
192                 list_add_tail(&buf->list, &conn->qp.sq.backlog);
193                 goto out_unlock;
194         }
195
196         mlx5_fpga_conn_post_send(conn, buf);
197
198 out_unlock:
199         spin_unlock_irqrestore(&conn->qp.sq.lock, flags);
200         return err;
201 }
202
203 static int mlx5_fpga_conn_post_recv_buf(struct mlx5_fpga_conn *conn)
204 {
205         struct mlx5_fpga_dma_buf *buf;
206         int err;
207
208         buf = kzalloc(sizeof(*buf) + MLX5_FPGA_RECV_SIZE, 0);
209         if (!buf)
210                 return -ENOMEM;
211
212         buf->sg[0].data = (void *)(buf + 1);
213         buf->sg[0].size = MLX5_FPGA_RECV_SIZE;
214         buf->dma_dir = DMA_FROM_DEVICE;
215
216         err = mlx5_fpga_conn_post_recv(conn, buf);
217         if (err)
218                 kfree(buf);
219
220         return err;
221 }
222
223 static int mlx5_fpga_conn_create_mkey(struct mlx5_core_dev *mdev, u32 pdn,
224                                       struct mlx5_core_mkey *mkey)
225 {
226         int inlen = MLX5_ST_SZ_BYTES(create_mkey_in);
227         void *mkc;
228         u32 *in;
229         int err;
230
231         in = kvzalloc(inlen, GFP_KERNEL);
232         if (!in)
233                 return -ENOMEM;
234
235         mkc = MLX5_ADDR_OF(create_mkey_in, in, memory_key_mkey_entry);
236         MLX5_SET(mkc, mkc, access_mode_1_0, MLX5_MKC_ACCESS_MODE_PA);
237         MLX5_SET(mkc, mkc, lw, 1);
238         MLX5_SET(mkc, mkc, lr, 1);
239
240         MLX5_SET(mkc, mkc, pd, pdn);
241         MLX5_SET(mkc, mkc, length64, 1);
242         MLX5_SET(mkc, mkc, qpn, 0xffffff);
243
244         err = mlx5_core_create_mkey(mdev, mkey, in, inlen);
245
246         kvfree(in);
247         return err;
248 }
249
250 static void mlx5_fpga_conn_rq_cqe(struct mlx5_fpga_conn *conn,
251                                   struct mlx5_cqe64 *cqe, u8 status)
252 {
253         struct mlx5_fpga_dma_buf *buf;
254         int ix, err;
255
256         ix = be16_to_cpu(cqe->wqe_counter) & (conn->qp.rq.size - 1);
257         buf = conn->qp.rq.bufs[ix];
258         conn->qp.rq.bufs[ix] = NULL;
259         if (!status)
260                 buf->sg[0].size = be32_to_cpu(cqe->byte_cnt);
261         conn->qp.rq.cc++;
262
263         if (unlikely(status && (status != MLX5_CQE_SYNDROME_WR_FLUSH_ERR)))
264                 mlx5_fpga_warn(conn->fdev, "RQ buf %p on FPGA QP %u completion status %d\n",
265                                buf, conn->fpga_qpn, status);
266         else
267                 mlx5_fpga_dbg(conn->fdev, "RQ buf %p on FPGA QP %u completion status %d\n",
268                               buf, conn->fpga_qpn, status);
269
270         mlx5_fpga_conn_unmap_buf(conn, buf);
271
272         if (unlikely(status || !conn->qp.active)) {
273                 conn->qp.active = false;
274                 kfree(buf);
275                 return;
276         }
277
278         mlx5_fpga_dbg(conn->fdev, "Message with %u bytes received successfully\n",
279                       buf->sg[0].size);
280         conn->recv_cb(conn->cb_arg, buf);
281
282         buf->sg[0].size = MLX5_FPGA_RECV_SIZE;
283         err = mlx5_fpga_conn_post_recv(conn, buf);
284         if (unlikely(err)) {
285                 mlx5_fpga_warn(conn->fdev,
286                                "Failed to re-post recv buf: %d\n", err);
287                 kfree(buf);
288         }
289 }
290
291 static void mlx5_fpga_conn_sq_cqe(struct mlx5_fpga_conn *conn,
292                                   struct mlx5_cqe64 *cqe, u8 status)
293 {
294         struct mlx5_fpga_dma_buf *buf, *nextbuf;
295         unsigned long flags;
296         int ix;
297
298         spin_lock_irqsave(&conn->qp.sq.lock, flags);
299
300         ix = be16_to_cpu(cqe->wqe_counter) & (conn->qp.sq.size - 1);
301         buf = conn->qp.sq.bufs[ix];
302         conn->qp.sq.bufs[ix] = NULL;
303         conn->qp.sq.cc++;
304
305         /* Handle backlog still under the spinlock to ensure message post order */
306         if (unlikely(!list_empty(&conn->qp.sq.backlog))) {
307                 if (likely(conn->qp.active)) {
308                         nextbuf = list_first_entry(&conn->qp.sq.backlog,
309                                                    struct mlx5_fpga_dma_buf, list);
310                         list_del(&nextbuf->list);
311                         mlx5_fpga_conn_post_send(conn, nextbuf);
312                 }
313         }
314
315         spin_unlock_irqrestore(&conn->qp.sq.lock, flags);
316
317         if (unlikely(status && (status != MLX5_CQE_SYNDROME_WR_FLUSH_ERR)))
318                 mlx5_fpga_warn(conn->fdev, "SQ buf %p on FPGA QP %u completion status %d\n",
319                                buf, conn->fpga_qpn, status);
320         else
321                 mlx5_fpga_dbg(conn->fdev, "SQ buf %p on FPGA QP %u completion status %d\n",
322                               buf, conn->fpga_qpn, status);
323
324         mlx5_fpga_conn_unmap_buf(conn, buf);
325
326         if (likely(buf->complete))
327                 buf->complete(conn, conn->fdev, buf, status);
328
329         if (unlikely(status))
330                 conn->qp.active = false;
331 }
332
333 static void mlx5_fpga_conn_handle_cqe(struct mlx5_fpga_conn *conn,
334                                       struct mlx5_cqe64 *cqe)
335 {
336         u8 opcode, status = 0;
337
338         opcode = cqe->op_own >> 4;
339
340         switch (opcode) {
341         case MLX5_CQE_REQ_ERR:
342                 status = ((struct mlx5_err_cqe *)cqe)->syndrome;
343                 /* Fall through */
344         case MLX5_CQE_REQ:
345                 mlx5_fpga_conn_sq_cqe(conn, cqe, status);
346                 break;
347
348         case MLX5_CQE_RESP_ERR:
349                 status = ((struct mlx5_err_cqe *)cqe)->syndrome;
350                 /* Fall through */
351         case MLX5_CQE_RESP_SEND:
352                 mlx5_fpga_conn_rq_cqe(conn, cqe, status);
353                 break;
354         default:
355                 mlx5_fpga_warn(conn->fdev, "Unexpected cqe opcode %u\n",
356                                opcode);
357         }
358 }
359
360 static void mlx5_fpga_conn_arm_cq(struct mlx5_fpga_conn *conn)
361 {
362         mlx5_cq_arm(&conn->cq.mcq, MLX5_CQ_DB_REQ_NOT,
363                     conn->fdev->conn_res.uar->map, conn->cq.wq.cc);
364 }
365
366 static void mlx5_fpga_conn_cq_event(struct mlx5_core_cq *mcq,
367                                     enum mlx5_event event)
368 {
369         struct mlx5_fpga_conn *conn;
370
371         conn = container_of(mcq, struct mlx5_fpga_conn, cq.mcq);
372         mlx5_fpga_warn(conn->fdev, "CQ event %u on CQ #%u\n", event, mcq->cqn);
373 }
374
375 static void mlx5_fpga_conn_event(struct mlx5_core_qp *mqp, int event)
376 {
377         struct mlx5_fpga_conn *conn;
378
379         conn = container_of(mqp, struct mlx5_fpga_conn, qp.mqp);
380         mlx5_fpga_warn(conn->fdev, "QP event %u on QP #%u\n", event, mqp->qpn);
381 }
382
383 static inline void mlx5_fpga_conn_cqes(struct mlx5_fpga_conn *conn,
384                                        unsigned int budget)
385 {
386         struct mlx5_cqe64 *cqe;
387
388         while (budget) {
389                 cqe = mlx5_cqwq_get_cqe(&conn->cq.wq);
390                 if (!cqe)
391                         break;
392
393                 budget--;
394                 mlx5_cqwq_pop(&conn->cq.wq);
395                 mlx5_fpga_conn_handle_cqe(conn, cqe);
396                 mlx5_cqwq_update_db_record(&conn->cq.wq);
397         }
398         if (!budget) {
399                 tasklet_schedule(&conn->cq.tasklet);
400                 return;
401         }
402
403         mlx5_fpga_dbg(conn->fdev, "Re-arming CQ with cc# %u\n", conn->cq.wq.cc);
404         /* ensure cq space is freed before enabling more cqes */
405         wmb();
406         mlx5_fpga_conn_arm_cq(conn);
407 }
408
409 static void mlx5_fpga_conn_cq_tasklet(unsigned long data)
410 {
411         struct mlx5_fpga_conn *conn = (void *)data;
412
413         if (unlikely(!conn->qp.active))
414                 return;
415         mlx5_fpga_conn_cqes(conn, MLX5_FPGA_CQ_BUDGET);
416 }
417
418 static void mlx5_fpga_conn_cq_complete(struct mlx5_core_cq *mcq)
419 {
420         struct mlx5_fpga_conn *conn;
421
422         conn = container_of(mcq, struct mlx5_fpga_conn, cq.mcq);
423         if (unlikely(!conn->qp.active))
424                 return;
425         mlx5_fpga_conn_cqes(conn, MLX5_FPGA_CQ_BUDGET);
426 }
427
428 static int mlx5_fpga_conn_create_cq(struct mlx5_fpga_conn *conn, int cq_size)
429 {
430         struct mlx5_fpga_device *fdev = conn->fdev;
431         struct mlx5_core_dev *mdev = fdev->mdev;
432         u32 temp_cqc[MLX5_ST_SZ_DW(cqc)] = {0};
433         struct mlx5_wq_param wqp;
434         struct mlx5_cqe64 *cqe;
435         int inlen, err, eqn;
436         unsigned int irqn;
437         void *cqc, *in;
438         __be64 *pas;
439         u32 i;
440
441         cq_size = roundup_pow_of_two(cq_size);
442         MLX5_SET(cqc, temp_cqc, log_cq_size, ilog2(cq_size));
443
444         wqp.buf_numa_node = mdev->priv.numa_node;
445         wqp.db_numa_node  = mdev->priv.numa_node;
446
447         err = mlx5_cqwq_create(mdev, &wqp, temp_cqc, &conn->cq.wq,
448                                &conn->cq.wq_ctrl);
449         if (err)
450                 return err;
451
452         for (i = 0; i < mlx5_cqwq_get_size(&conn->cq.wq); i++) {
453                 cqe = mlx5_cqwq_get_wqe(&conn->cq.wq, i);
454                 cqe->op_own = MLX5_CQE_INVALID << 4 | MLX5_CQE_OWNER_MASK;
455         }
456
457         inlen = MLX5_ST_SZ_BYTES(create_cq_in) +
458                 sizeof(u64) * conn->cq.wq_ctrl.buf.npages;
459         in = kvzalloc(inlen, GFP_KERNEL);
460         if (!in) {
461                 err = -ENOMEM;
462                 goto err_cqwq;
463         }
464
465         err = mlx5_vector2eqn(mdev, smp_processor_id(), &eqn, &irqn);
466         if (err)
467                 goto err_cqwq;
468
469         cqc = MLX5_ADDR_OF(create_cq_in, in, cq_context);
470         MLX5_SET(cqc, cqc, log_cq_size, ilog2(cq_size));
471         MLX5_SET(cqc, cqc, c_eqn, eqn);
472         MLX5_SET(cqc, cqc, uar_page, fdev->conn_res.uar->index);
473         MLX5_SET(cqc, cqc, log_page_size, conn->cq.wq_ctrl.buf.page_shift -
474                            MLX5_ADAPTER_PAGE_SHIFT);
475         MLX5_SET64(cqc, cqc, dbr_addr, conn->cq.wq_ctrl.db.dma);
476
477         pas = (__be64 *)MLX5_ADDR_OF(create_cq_in, in, pas);
478         mlx5_fill_page_frag_array(&conn->cq.wq_ctrl.buf, pas);
479
480         err = mlx5_core_create_cq(mdev, &conn->cq.mcq, in, inlen);
481         kvfree(in);
482
483         if (err)
484                 goto err_cqwq;
485
486         conn->cq.mcq.cqe_sz     = 64;
487         conn->cq.mcq.set_ci_db  = conn->cq.wq_ctrl.db.db;
488         conn->cq.mcq.arm_db     = conn->cq.wq_ctrl.db.db + 1;
489         *conn->cq.mcq.set_ci_db = 0;
490         *conn->cq.mcq.arm_db    = 0;
491         conn->cq.mcq.vector     = 0;
492         conn->cq.mcq.comp       = mlx5_fpga_conn_cq_complete;
493         conn->cq.mcq.event      = mlx5_fpga_conn_cq_event;
494         conn->cq.mcq.irqn       = irqn;
495         conn->cq.mcq.uar        = fdev->conn_res.uar;
496         tasklet_init(&conn->cq.tasklet, mlx5_fpga_conn_cq_tasklet,
497                      (unsigned long)conn);
498
499         mlx5_fpga_dbg(fdev, "Created CQ #0x%x\n", conn->cq.mcq.cqn);
500
501         goto out;
502
503 err_cqwq:
504         mlx5_wq_destroy(&conn->cq.wq_ctrl);
505 out:
506         return err;
507 }
508
509 static void mlx5_fpga_conn_destroy_cq(struct mlx5_fpga_conn *conn)
510 {
511         tasklet_disable(&conn->cq.tasklet);
512         tasklet_kill(&conn->cq.tasklet);
513         mlx5_core_destroy_cq(conn->fdev->mdev, &conn->cq.mcq);
514         mlx5_wq_destroy(&conn->cq.wq_ctrl);
515 }
516
517 static int mlx5_fpga_conn_create_wq(struct mlx5_fpga_conn *conn, void *qpc)
518 {
519         struct mlx5_fpga_device *fdev = conn->fdev;
520         struct mlx5_core_dev *mdev = fdev->mdev;
521         struct mlx5_wq_param wqp;
522
523         wqp.buf_numa_node = mdev->priv.numa_node;
524         wqp.db_numa_node  = mdev->priv.numa_node;
525
526         return mlx5_wq_qp_create(mdev, &wqp, qpc, &conn->qp.wq,
527                                  &conn->qp.wq_ctrl);
528 }
529
530 static int mlx5_fpga_conn_create_qp(struct mlx5_fpga_conn *conn,
531                                     unsigned int tx_size, unsigned int rx_size)
532 {
533         struct mlx5_fpga_device *fdev = conn->fdev;
534         struct mlx5_core_dev *mdev = fdev->mdev;
535         u32 temp_qpc[MLX5_ST_SZ_DW(qpc)] = {0};
536         void *in = NULL, *qpc;
537         int err, inlen;
538
539         conn->qp.rq.pc = 0;
540         conn->qp.rq.cc = 0;
541         conn->qp.rq.size = roundup_pow_of_two(rx_size);
542         conn->qp.sq.pc = 0;
543         conn->qp.sq.cc = 0;
544         conn->qp.sq.size = roundup_pow_of_two(tx_size);
545
546         MLX5_SET(qpc, temp_qpc, log_rq_stride, ilog2(MLX5_SEND_WQE_DS) - 4);
547         MLX5_SET(qpc, temp_qpc, log_rq_size, ilog2(conn->qp.rq.size));
548         MLX5_SET(qpc, temp_qpc, log_sq_size, ilog2(conn->qp.sq.size));
549         err = mlx5_fpga_conn_create_wq(conn, temp_qpc);
550         if (err)
551                 goto out;
552
553         conn->qp.rq.bufs = kvzalloc(sizeof(conn->qp.rq.bufs[0]) *
554                                     conn->qp.rq.size, GFP_KERNEL);
555         if (!conn->qp.rq.bufs) {
556                 err = -ENOMEM;
557                 goto err_wq;
558         }
559
560         conn->qp.sq.bufs = kvzalloc(sizeof(conn->qp.sq.bufs[0]) *
561                                     conn->qp.sq.size, GFP_KERNEL);
562         if (!conn->qp.sq.bufs) {
563                 err = -ENOMEM;
564                 goto err_rq_bufs;
565         }
566
567         inlen = MLX5_ST_SZ_BYTES(create_qp_in) +
568                 MLX5_FLD_SZ_BYTES(create_qp_in, pas[0]) *
569                 conn->qp.wq_ctrl.buf.npages;
570         in = kvzalloc(inlen, GFP_KERNEL);
571         if (!in) {
572                 err = -ENOMEM;
573                 goto err_sq_bufs;
574         }
575
576         qpc = MLX5_ADDR_OF(create_qp_in, in, qpc);
577         MLX5_SET(qpc, qpc, uar_page, fdev->conn_res.uar->index);
578         MLX5_SET(qpc, qpc, log_page_size,
579                  conn->qp.wq_ctrl.buf.page_shift - MLX5_ADAPTER_PAGE_SHIFT);
580         MLX5_SET(qpc, qpc, fre, 1);
581         MLX5_SET(qpc, qpc, rlky, 1);
582         MLX5_SET(qpc, qpc, st, MLX5_QP_ST_RC);
583         MLX5_SET(qpc, qpc, pm_state, MLX5_QP_PM_MIGRATED);
584         MLX5_SET(qpc, qpc, pd, fdev->conn_res.pdn);
585         MLX5_SET(qpc, qpc, log_rq_stride, ilog2(MLX5_SEND_WQE_DS) - 4);
586         MLX5_SET(qpc, qpc, log_rq_size, ilog2(conn->qp.rq.size));
587         MLX5_SET(qpc, qpc, rq_type, MLX5_NON_ZERO_RQ);
588         MLX5_SET(qpc, qpc, log_sq_size, ilog2(conn->qp.sq.size));
589         MLX5_SET(qpc, qpc, cqn_snd, conn->cq.mcq.cqn);
590         MLX5_SET(qpc, qpc, cqn_rcv, conn->cq.mcq.cqn);
591         MLX5_SET64(qpc, qpc, dbr_addr, conn->qp.wq_ctrl.db.dma);
592         if (MLX5_CAP_GEN(mdev, cqe_version) == 1)
593                 MLX5_SET(qpc, qpc, user_index, 0xFFFFFF);
594
595         mlx5_fill_page_frag_array(&conn->qp.wq_ctrl.buf,
596                                   (__be64 *)MLX5_ADDR_OF(create_qp_in, in, pas));
597
598         err = mlx5_core_create_qp(mdev, &conn->qp.mqp, in, inlen);
599         if (err)
600                 goto err_sq_bufs;
601
602         conn->qp.mqp.event = mlx5_fpga_conn_event;
603         mlx5_fpga_dbg(fdev, "Created QP #0x%x\n", conn->qp.mqp.qpn);
604
605         goto out;
606
607 err_sq_bufs:
608         kvfree(conn->qp.sq.bufs);
609 err_rq_bufs:
610         kvfree(conn->qp.rq.bufs);
611 err_wq:
612         mlx5_wq_destroy(&conn->qp.wq_ctrl);
613 out:
614         kvfree(in);
615         return err;
616 }
617
618 static void mlx5_fpga_conn_free_recv_bufs(struct mlx5_fpga_conn *conn)
619 {
620         int ix;
621
622         for (ix = 0; ix < conn->qp.rq.size; ix++) {
623                 if (!conn->qp.rq.bufs[ix])
624                         continue;
625                 mlx5_fpga_conn_unmap_buf(conn, conn->qp.rq.bufs[ix]);
626                 kfree(conn->qp.rq.bufs[ix]);
627                 conn->qp.rq.bufs[ix] = NULL;
628         }
629 }
630
631 static void mlx5_fpga_conn_flush_send_bufs(struct mlx5_fpga_conn *conn)
632 {
633         struct mlx5_fpga_dma_buf *buf, *temp;
634         int ix;
635
636         for (ix = 0; ix < conn->qp.sq.size; ix++) {
637                 buf = conn->qp.sq.bufs[ix];
638                 if (!buf)
639                         continue;
640                 conn->qp.sq.bufs[ix] = NULL;
641                 mlx5_fpga_conn_unmap_buf(conn, buf);
642                 if (!buf->complete)
643                         continue;
644                 buf->complete(conn, conn->fdev, buf, MLX5_CQE_SYNDROME_WR_FLUSH_ERR);
645         }
646         list_for_each_entry_safe(buf, temp, &conn->qp.sq.backlog, list) {
647                 mlx5_fpga_conn_unmap_buf(conn, buf);
648                 if (!buf->complete)
649                         continue;
650                 buf->complete(conn, conn->fdev, buf, MLX5_CQE_SYNDROME_WR_FLUSH_ERR);
651         }
652 }
653
654 static void mlx5_fpga_conn_destroy_qp(struct mlx5_fpga_conn *conn)
655 {
656         mlx5_core_destroy_qp(conn->fdev->mdev, &conn->qp.mqp);
657         mlx5_fpga_conn_free_recv_bufs(conn);
658         mlx5_fpga_conn_flush_send_bufs(conn);
659         kvfree(conn->qp.sq.bufs);
660         kvfree(conn->qp.rq.bufs);
661         mlx5_wq_destroy(&conn->qp.wq_ctrl);
662 }
663
664 static inline int mlx5_fpga_conn_reset_qp(struct mlx5_fpga_conn *conn)
665 {
666         struct mlx5_core_dev *mdev = conn->fdev->mdev;
667
668         mlx5_fpga_dbg(conn->fdev, "Modifying QP %u to RST\n", conn->qp.mqp.qpn);
669
670         return mlx5_core_qp_modify(mdev, MLX5_CMD_OP_2RST_QP, 0, NULL,
671                                    &conn->qp.mqp);
672 }
673
674 static inline int mlx5_fpga_conn_init_qp(struct mlx5_fpga_conn *conn)
675 {
676         struct mlx5_fpga_device *fdev = conn->fdev;
677         struct mlx5_core_dev *mdev = fdev->mdev;
678         u32 *qpc = NULL;
679         int err;
680
681         mlx5_fpga_dbg(conn->fdev, "Modifying QP %u to INIT\n", conn->qp.mqp.qpn);
682
683         qpc = kzalloc(MLX5_ST_SZ_BYTES(qpc), GFP_KERNEL);
684         if (!qpc) {
685                 err = -ENOMEM;
686                 goto out;
687         }
688
689         MLX5_SET(qpc, qpc, st, MLX5_QP_ST_RC);
690         MLX5_SET(qpc, qpc, pm_state, MLX5_QP_PM_MIGRATED);
691         MLX5_SET(qpc, qpc, primary_address_path.pkey_index, MLX5_FPGA_PKEY_INDEX);
692         MLX5_SET(qpc, qpc, primary_address_path.vhca_port_num, MLX5_FPGA_PORT_NUM);
693         MLX5_SET(qpc, qpc, pd, conn->fdev->conn_res.pdn);
694         MLX5_SET(qpc, qpc, cqn_snd, conn->cq.mcq.cqn);
695         MLX5_SET(qpc, qpc, cqn_rcv, conn->cq.mcq.cqn);
696         MLX5_SET64(qpc, qpc, dbr_addr, conn->qp.wq_ctrl.db.dma);
697
698         err = mlx5_core_qp_modify(mdev, MLX5_CMD_OP_RST2INIT_QP, 0, qpc,
699                                   &conn->qp.mqp);
700         if (err) {
701                 mlx5_fpga_warn(fdev, "qp_modify RST2INIT failed: %d\n", err);
702                 goto out;
703         }
704
705 out:
706         kfree(qpc);
707         return err;
708 }
709
710 static inline int mlx5_fpga_conn_rtr_qp(struct mlx5_fpga_conn *conn)
711 {
712         struct mlx5_fpga_device *fdev = conn->fdev;
713         struct mlx5_core_dev *mdev = fdev->mdev;
714         u32 *qpc = NULL;
715         int err;
716
717         mlx5_fpga_dbg(conn->fdev, "QP RTR\n");
718
719         qpc = kzalloc(MLX5_ST_SZ_BYTES(qpc), GFP_KERNEL);
720         if (!qpc) {
721                 err = -ENOMEM;
722                 goto out;
723         }
724
725         MLX5_SET(qpc, qpc, mtu, MLX5_QPC_MTU_1K_BYTES);
726         MLX5_SET(qpc, qpc, log_msg_max, (u8)MLX5_CAP_GEN(mdev, log_max_msg));
727         MLX5_SET(qpc, qpc, remote_qpn, conn->fpga_qpn);
728         MLX5_SET(qpc, qpc, next_rcv_psn,
729                  MLX5_GET(fpga_qpc, conn->fpga_qpc, next_send_psn));
730         MLX5_SET(qpc, qpc, primary_address_path.pkey_index, MLX5_FPGA_PKEY_INDEX);
731         MLX5_SET(qpc, qpc, primary_address_path.vhca_port_num, MLX5_FPGA_PORT_NUM);
732         ether_addr_copy(MLX5_ADDR_OF(qpc, qpc, primary_address_path.rmac_47_32),
733                         MLX5_ADDR_OF(fpga_qpc, conn->fpga_qpc, fpga_mac_47_32));
734         MLX5_SET(qpc, qpc, primary_address_path.udp_sport,
735                  MLX5_CAP_ROCE(mdev, r_roce_min_src_udp_port));
736         MLX5_SET(qpc, qpc, primary_address_path.src_addr_index,
737                  conn->qp.sgid_index);
738         MLX5_SET(qpc, qpc, primary_address_path.hop_limit, 0);
739         memcpy(MLX5_ADDR_OF(qpc, qpc, primary_address_path.rgid_rip),
740                MLX5_ADDR_OF(fpga_qpc, conn->fpga_qpc, fpga_ip),
741                MLX5_FLD_SZ_BYTES(qpc, primary_address_path.rgid_rip));
742
743         err = mlx5_core_qp_modify(mdev, MLX5_CMD_OP_INIT2RTR_QP, 0, qpc,
744                                   &conn->qp.mqp);
745         if (err) {
746                 mlx5_fpga_warn(fdev, "qp_modify RST2INIT failed: %d\n", err);
747                 goto out;
748         }
749
750 out:
751         kfree(qpc);
752         return err;
753 }
754
755 static inline int mlx5_fpga_conn_rts_qp(struct mlx5_fpga_conn *conn)
756 {
757         struct mlx5_fpga_device *fdev = conn->fdev;
758         struct mlx5_core_dev *mdev = fdev->mdev;
759         u32 *qpc = NULL;
760         u32 opt_mask;
761         int err;
762
763         mlx5_fpga_dbg(conn->fdev, "QP RTS\n");
764
765         qpc = kzalloc(MLX5_ST_SZ_BYTES(qpc), GFP_KERNEL);
766         if (!qpc) {
767                 err = -ENOMEM;
768                 goto out;
769         }
770
771         MLX5_SET(qpc, qpc, log_ack_req_freq, 8);
772         MLX5_SET(qpc, qpc, min_rnr_nak, 0x12);
773         MLX5_SET(qpc, qpc, primary_address_path.ack_timeout, 0x12); /* ~1.07s */
774         MLX5_SET(qpc, qpc, next_send_psn,
775                  MLX5_GET(fpga_qpc, conn->fpga_qpc, next_rcv_psn));
776         MLX5_SET(qpc, qpc, retry_count, 7);
777         MLX5_SET(qpc, qpc, rnr_retry, 7); /* Infinite retry if RNR NACK */
778
779         opt_mask = MLX5_QP_OPTPAR_RNR_TIMEOUT;
780         err = mlx5_core_qp_modify(mdev, MLX5_CMD_OP_RTR2RTS_QP, opt_mask, qpc,
781                                   &conn->qp.mqp);
782         if (err) {
783                 mlx5_fpga_warn(fdev, "qp_modify RST2INIT failed: %d\n", err);
784                 goto out;
785         }
786
787 out:
788         kfree(qpc);
789         return err;
790 }
791
792 static int mlx5_fpga_conn_connect(struct mlx5_fpga_conn *conn)
793 {
794         struct mlx5_fpga_device *fdev = conn->fdev;
795         int err;
796
797         MLX5_SET(fpga_qpc, conn->fpga_qpc, state, MLX5_FPGA_QPC_STATE_ACTIVE);
798         err = mlx5_fpga_modify_qp(conn->fdev->mdev, conn->fpga_qpn,
799                                   MLX5_FPGA_QPC_STATE, &conn->fpga_qpc);
800         if (err) {
801                 mlx5_fpga_err(fdev, "Failed to activate FPGA RC QP: %d\n", err);
802                 goto out;
803         }
804
805         err = mlx5_fpga_conn_reset_qp(conn);
806         if (err) {
807                 mlx5_fpga_err(fdev, "Failed to change QP state to reset\n");
808                 goto err_fpga_qp;
809         }
810
811         err = mlx5_fpga_conn_init_qp(conn);
812         if (err) {
813                 mlx5_fpga_err(fdev, "Failed to modify QP from RESET to INIT\n");
814                 goto err_fpga_qp;
815         }
816         conn->qp.active = true;
817
818         while (!mlx5_fpga_conn_post_recv_buf(conn))
819                 ;
820
821         err = mlx5_fpga_conn_rtr_qp(conn);
822         if (err) {
823                 mlx5_fpga_err(fdev, "Failed to change QP state from INIT to RTR\n");
824                 goto err_recv_bufs;
825         }
826
827         err = mlx5_fpga_conn_rts_qp(conn);
828         if (err) {
829                 mlx5_fpga_err(fdev, "Failed to change QP state from RTR to RTS\n");
830                 goto err_recv_bufs;
831         }
832         goto out;
833
834 err_recv_bufs:
835         mlx5_fpga_conn_free_recv_bufs(conn);
836 err_fpga_qp:
837         MLX5_SET(fpga_qpc, conn->fpga_qpc, state, MLX5_FPGA_QPC_STATE_INIT);
838         if (mlx5_fpga_modify_qp(conn->fdev->mdev, conn->fpga_qpn,
839                                 MLX5_FPGA_QPC_STATE, &conn->fpga_qpc))
840                 mlx5_fpga_err(fdev, "Failed to revert FPGA QP to INIT\n");
841 out:
842         return err;
843 }
844
845 struct mlx5_fpga_conn *mlx5_fpga_conn_create(struct mlx5_fpga_device *fdev,
846                                              struct mlx5_fpga_conn_attr *attr,
847                                              enum mlx5_ifc_fpga_qp_type qp_type)
848 {
849         struct mlx5_fpga_conn *ret, *conn;
850         u8 *remote_mac, *remote_ip;
851         int err;
852
853         if (!attr->recv_cb)
854                 return ERR_PTR(-EINVAL);
855
856         conn = kzalloc(sizeof(*conn), GFP_KERNEL);
857         if (!conn)
858                 return ERR_PTR(-ENOMEM);
859
860         conn->fdev = fdev;
861         INIT_LIST_HEAD(&conn->qp.sq.backlog);
862
863         spin_lock_init(&conn->qp.sq.lock);
864
865         conn->recv_cb = attr->recv_cb;
866         conn->cb_arg = attr->cb_arg;
867
868         remote_mac = MLX5_ADDR_OF(fpga_qpc, conn->fpga_qpc, remote_mac_47_32);
869         err = mlx5_query_nic_vport_mac_address(fdev->mdev, 0, remote_mac);
870         if (err) {
871                 mlx5_fpga_err(fdev, "Failed to query local MAC: %d\n", err);
872                 ret = ERR_PTR(err);
873                 goto err;
874         }
875
876         /* Build Modified EUI-64 IPv6 address from the MAC address */
877         remote_ip = MLX5_ADDR_OF(fpga_qpc, conn->fpga_qpc, remote_ip);
878         remote_ip[0] = 0xfe;
879         remote_ip[1] = 0x80;
880         addrconf_addr_eui48(&remote_ip[8], remote_mac);
881
882         err = mlx5_core_reserved_gid_alloc(fdev->mdev, &conn->qp.sgid_index);
883         if (err) {
884                 mlx5_fpga_err(fdev, "Failed to allocate SGID: %d\n", err);
885                 ret = ERR_PTR(err);
886                 goto err;
887         }
888
889         err = mlx5_core_roce_gid_set(fdev->mdev, conn->qp.sgid_index,
890                                      MLX5_ROCE_VERSION_2,
891                                      MLX5_ROCE_L3_TYPE_IPV6,
892                                      remote_ip, remote_mac, true, 0,
893                                      MLX5_FPGA_PORT_NUM);
894         if (err) {
895                 mlx5_fpga_err(fdev, "Failed to set SGID: %d\n", err);
896                 ret = ERR_PTR(err);
897                 goto err_rsvd_gid;
898         }
899         mlx5_fpga_dbg(fdev, "Reserved SGID index %u\n", conn->qp.sgid_index);
900
901         /* Allow for one cqe per rx/tx wqe, plus one cqe for the next wqe,
902          * created during processing of the cqe
903          */
904         err = mlx5_fpga_conn_create_cq(conn,
905                                        (attr->tx_size + attr->rx_size) * 2);
906         if (err) {
907                 mlx5_fpga_err(fdev, "Failed to create CQ: %d\n", err);
908                 ret = ERR_PTR(err);
909                 goto err_gid;
910         }
911
912         mlx5_fpga_conn_arm_cq(conn);
913
914         err = mlx5_fpga_conn_create_qp(conn, attr->tx_size, attr->rx_size);
915         if (err) {
916                 mlx5_fpga_err(fdev, "Failed to create QP: %d\n", err);
917                 ret = ERR_PTR(err);
918                 goto err_cq;
919         }
920
921         MLX5_SET(fpga_qpc, conn->fpga_qpc, state, MLX5_FPGA_QPC_STATE_INIT);
922         MLX5_SET(fpga_qpc, conn->fpga_qpc, qp_type, qp_type);
923         MLX5_SET(fpga_qpc, conn->fpga_qpc, st, MLX5_FPGA_QPC_ST_RC);
924         MLX5_SET(fpga_qpc, conn->fpga_qpc, ether_type, ETH_P_8021Q);
925         MLX5_SET(fpga_qpc, conn->fpga_qpc, vid, 0);
926         MLX5_SET(fpga_qpc, conn->fpga_qpc, next_rcv_psn, 1);
927         MLX5_SET(fpga_qpc, conn->fpga_qpc, next_send_psn, 0);
928         MLX5_SET(fpga_qpc, conn->fpga_qpc, pkey, MLX5_FPGA_PKEY);
929         MLX5_SET(fpga_qpc, conn->fpga_qpc, remote_qpn, conn->qp.mqp.qpn);
930         MLX5_SET(fpga_qpc, conn->fpga_qpc, rnr_retry, 7);
931         MLX5_SET(fpga_qpc, conn->fpga_qpc, retry_count, 7);
932
933         err = mlx5_fpga_create_qp(fdev->mdev, &conn->fpga_qpc,
934                                   &conn->fpga_qpn);
935         if (err) {
936                 mlx5_fpga_err(fdev, "Failed to create FPGA RC QP: %d\n", err);
937                 ret = ERR_PTR(err);
938                 goto err_qp;
939         }
940
941         err = mlx5_fpga_conn_connect(conn);
942         if (err) {
943                 ret = ERR_PTR(err);
944                 goto err_conn;
945         }
946
947         mlx5_fpga_dbg(fdev, "FPGA QPN is %u\n", conn->fpga_qpn);
948         ret = conn;
949         goto out;
950
951 err_conn:
952         mlx5_fpga_destroy_qp(conn->fdev->mdev, conn->fpga_qpn);
953 err_qp:
954         mlx5_fpga_conn_destroy_qp(conn);
955 err_cq:
956         mlx5_fpga_conn_destroy_cq(conn);
957 err_gid:
958         mlx5_core_roce_gid_set(fdev->mdev, conn->qp.sgid_index, 0, 0, NULL,
959                                NULL, false, 0, MLX5_FPGA_PORT_NUM);
960 err_rsvd_gid:
961         mlx5_core_reserved_gid_free(fdev->mdev, conn->qp.sgid_index);
962 err:
963         kfree(conn);
964 out:
965         return ret;
966 }
967
968 void mlx5_fpga_conn_destroy(struct mlx5_fpga_conn *conn)
969 {
970         struct mlx5_fpga_device *fdev = conn->fdev;
971         struct mlx5_core_dev *mdev = fdev->mdev;
972         int err = 0;
973
974         conn->qp.active = false;
975         tasklet_disable(&conn->cq.tasklet);
976         synchronize_irq(conn->cq.mcq.irqn);
977
978         mlx5_fpga_destroy_qp(conn->fdev->mdev, conn->fpga_qpn);
979         err = mlx5_core_qp_modify(mdev, MLX5_CMD_OP_2ERR_QP, 0, NULL,
980                                   &conn->qp.mqp);
981         if (err)
982                 mlx5_fpga_warn(fdev, "qp_modify 2ERR failed: %d\n", err);
983         mlx5_fpga_conn_destroy_qp(conn);
984         mlx5_fpga_conn_destroy_cq(conn);
985
986         mlx5_core_roce_gid_set(conn->fdev->mdev, conn->qp.sgid_index, 0, 0,
987                                NULL, NULL, false, 0, MLX5_FPGA_PORT_NUM);
988         mlx5_core_reserved_gid_free(conn->fdev->mdev, conn->qp.sgid_index);
989         kfree(conn);
990 }
991
992 int mlx5_fpga_conn_device_init(struct mlx5_fpga_device *fdev)
993 {
994         int err;
995
996         err = mlx5_nic_vport_enable_roce(fdev->mdev);
997         if (err) {
998                 mlx5_fpga_err(fdev, "Failed to enable RoCE: %d\n", err);
999                 goto out;
1000         }
1001
1002         fdev->conn_res.uar = mlx5_get_uars_page(fdev->mdev);
1003         if (IS_ERR(fdev->conn_res.uar)) {
1004                 err = PTR_ERR(fdev->conn_res.uar);
1005                 mlx5_fpga_err(fdev, "get_uars_page failed, %d\n", err);
1006                 goto err_roce;
1007         }
1008         mlx5_fpga_dbg(fdev, "Allocated UAR index %u\n",
1009                       fdev->conn_res.uar->index);
1010
1011         err = mlx5_core_alloc_pd(fdev->mdev, &fdev->conn_res.pdn);
1012         if (err) {
1013                 mlx5_fpga_err(fdev, "alloc pd failed, %d\n", err);
1014                 goto err_uar;
1015         }
1016         mlx5_fpga_dbg(fdev, "Allocated PD %u\n", fdev->conn_res.pdn);
1017
1018         err = mlx5_fpga_conn_create_mkey(fdev->mdev, fdev->conn_res.pdn,
1019                                          &fdev->conn_res.mkey);
1020         if (err) {
1021                 mlx5_fpga_err(fdev, "create mkey failed, %d\n", err);
1022                 goto err_dealloc_pd;
1023         }
1024         mlx5_fpga_dbg(fdev, "Created mkey 0x%x\n", fdev->conn_res.mkey.key);
1025
1026         return 0;
1027
1028 err_dealloc_pd:
1029         mlx5_core_dealloc_pd(fdev->mdev, fdev->conn_res.pdn);
1030 err_uar:
1031         mlx5_put_uars_page(fdev->mdev, fdev->conn_res.uar);
1032 err_roce:
1033         mlx5_nic_vport_disable_roce(fdev->mdev);
1034 out:
1035         return err;
1036 }
1037
1038 void mlx5_fpga_conn_device_cleanup(struct mlx5_fpga_device *fdev)
1039 {
1040         mlx5_core_destroy_mkey(fdev->mdev, &fdev->conn_res.mkey);
1041         mlx5_core_dealloc_pd(fdev->mdev, fdev->conn_res.pdn);
1042         mlx5_put_uars_page(fdev->mdev, fdev->conn_res.uar);
1043         mlx5_nic_vport_disable_roce(fdev->mdev);
1044 }