Loading...
Note: File does not exist in v3.5.6.
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Copyright (c) 2022, Microsoft Corporation. All rights reserved.
4 */
5
6#include "mana_ib.h"
7
8void mana_ib_uncfg_vport(struct mana_ib_dev *dev, struct mana_ib_pd *pd,
9 u32 port)
10{
11 struct gdma_dev *gd = &dev->gdma_dev->gdma_context->mana;
12 struct mana_port_context *mpc;
13 struct net_device *ndev;
14 struct mana_context *mc;
15
16 mc = gd->driver_data;
17 ndev = mc->ports[port];
18 mpc = netdev_priv(ndev);
19
20 mutex_lock(&pd->vport_mutex);
21
22 pd->vport_use_count--;
23 WARN_ON(pd->vport_use_count < 0);
24
25 if (!pd->vport_use_count)
26 mana_uncfg_vport(mpc);
27
28 mutex_unlock(&pd->vport_mutex);
29}
30
31int mana_ib_cfg_vport(struct mana_ib_dev *dev, u32 port, struct mana_ib_pd *pd,
32 u32 doorbell_id)
33{
34 struct gdma_dev *mdev = &dev->gdma_dev->gdma_context->mana;
35 struct mana_port_context *mpc;
36 struct mana_context *mc;
37 struct net_device *ndev;
38 int err;
39
40 mc = mdev->driver_data;
41 ndev = mc->ports[port];
42 mpc = netdev_priv(ndev);
43
44 mutex_lock(&pd->vport_mutex);
45
46 pd->vport_use_count++;
47 if (pd->vport_use_count > 1) {
48 ibdev_dbg(&dev->ib_dev,
49 "Skip as this PD is already configured vport\n");
50 mutex_unlock(&pd->vport_mutex);
51 return 0;
52 }
53
54 err = mana_cfg_vport(mpc, pd->pdn, doorbell_id);
55 if (err) {
56 pd->vport_use_count--;
57 mutex_unlock(&pd->vport_mutex);
58
59 ibdev_dbg(&dev->ib_dev, "Failed to configure vPort %d\n", err);
60 return err;
61 }
62
63 mutex_unlock(&pd->vport_mutex);
64
65 pd->tx_shortform_allowed = mpc->tx_shortform_allowed;
66 pd->tx_vp_offset = mpc->tx_vp_offset;
67
68 ibdev_dbg(&dev->ib_dev, "vport handle %llx pdid %x doorbell_id %x\n",
69 mpc->port_handle, pd->pdn, doorbell_id);
70
71 return 0;
72}
73
74int mana_ib_alloc_pd(struct ib_pd *ibpd, struct ib_udata *udata)
75{
76 struct mana_ib_pd *pd = container_of(ibpd, struct mana_ib_pd, ibpd);
77 struct ib_device *ibdev = ibpd->device;
78 struct gdma_create_pd_resp resp = {};
79 struct gdma_create_pd_req req = {};
80 enum gdma_pd_flags flags = 0;
81 struct mana_ib_dev *dev;
82 struct gdma_dev *mdev;
83 int err;
84
85 dev = container_of(ibdev, struct mana_ib_dev, ib_dev);
86 mdev = dev->gdma_dev;
87
88 mana_gd_init_req_hdr(&req.hdr, GDMA_CREATE_PD, sizeof(req),
89 sizeof(resp));
90
91 req.flags = flags;
92 err = mana_gd_send_request(mdev->gdma_context, sizeof(req), &req,
93 sizeof(resp), &resp);
94
95 if (err || resp.hdr.status) {
96 ibdev_dbg(&dev->ib_dev,
97 "Failed to get pd_id err %d status %u\n", err,
98 resp.hdr.status);
99 if (!err)
100 err = -EPROTO;
101
102 return err;
103 }
104
105 pd->pd_handle = resp.pd_handle;
106 pd->pdn = resp.pd_id;
107 ibdev_dbg(&dev->ib_dev, "pd_handle 0x%llx pd_id %d\n",
108 pd->pd_handle, pd->pdn);
109
110 mutex_init(&pd->vport_mutex);
111 pd->vport_use_count = 0;
112 return 0;
113}
114
115int mana_ib_dealloc_pd(struct ib_pd *ibpd, struct ib_udata *udata)
116{
117 struct mana_ib_pd *pd = container_of(ibpd, struct mana_ib_pd, ibpd);
118 struct ib_device *ibdev = ibpd->device;
119 struct gdma_destory_pd_resp resp = {};
120 struct gdma_destroy_pd_req req = {};
121 struct mana_ib_dev *dev;
122 struct gdma_dev *mdev;
123 int err;
124
125 dev = container_of(ibdev, struct mana_ib_dev, ib_dev);
126 mdev = dev->gdma_dev;
127
128 mana_gd_init_req_hdr(&req.hdr, GDMA_DESTROY_PD, sizeof(req),
129 sizeof(resp));
130
131 req.pd_handle = pd->pd_handle;
132 err = mana_gd_send_request(mdev->gdma_context, sizeof(req), &req,
133 sizeof(resp), &resp);
134
135 if (err || resp.hdr.status) {
136 ibdev_dbg(&dev->ib_dev,
137 "Failed to destroy pd_handle 0x%llx err %d status %u",
138 pd->pd_handle, err, resp.hdr.status);
139 if (!err)
140 err = -EPROTO;
141 }
142
143 return err;
144}
145
146static int mana_gd_destroy_doorbell_page(struct gdma_context *gc,
147 int doorbell_page)
148{
149 struct gdma_destroy_resource_range_req req = {};
150 struct gdma_resp_hdr resp = {};
151 int err;
152
153 mana_gd_init_req_hdr(&req.hdr, GDMA_DESTROY_RESOURCE_RANGE,
154 sizeof(req), sizeof(resp));
155
156 req.resource_type = GDMA_RESOURCE_DOORBELL_PAGE;
157 req.num_resources = 1;
158 req.allocated_resources = doorbell_page;
159
160 err = mana_gd_send_request(gc, sizeof(req), &req, sizeof(resp), &resp);
161 if (err || resp.status) {
162 dev_err(gc->dev,
163 "Failed to destroy doorbell page: ret %d, 0x%x\n",
164 err, resp.status);
165 return err ?: -EPROTO;
166 }
167
168 return 0;
169}
170
171static int mana_gd_allocate_doorbell_page(struct gdma_context *gc,
172 int *doorbell_page)
173{
174 struct gdma_allocate_resource_range_req req = {};
175 struct gdma_allocate_resource_range_resp resp = {};
176 int err;
177
178 mana_gd_init_req_hdr(&req.hdr, GDMA_ALLOCATE_RESOURCE_RANGE,
179 sizeof(req), sizeof(resp));
180
181 req.resource_type = GDMA_RESOURCE_DOORBELL_PAGE;
182 req.num_resources = 1;
183 req.alignment = 1;
184
185 /* Have GDMA start searching from 0 */
186 req.allocated_resources = 0;
187
188 err = mana_gd_send_request(gc, sizeof(req), &req, sizeof(resp), &resp);
189 if (err || resp.hdr.status) {
190 dev_err(gc->dev,
191 "Failed to allocate doorbell page: ret %d, 0x%x\n",
192 err, resp.hdr.status);
193 return err ?: -EPROTO;
194 }
195
196 *doorbell_page = resp.allocated_resources;
197
198 return 0;
199}
200
201int mana_ib_alloc_ucontext(struct ib_ucontext *ibcontext,
202 struct ib_udata *udata)
203{
204 struct mana_ib_ucontext *ucontext =
205 container_of(ibcontext, struct mana_ib_ucontext, ibucontext);
206 struct ib_device *ibdev = ibcontext->device;
207 struct mana_ib_dev *mdev;
208 struct gdma_context *gc;
209 struct gdma_dev *dev;
210 int doorbell_page;
211 int ret;
212
213 mdev = container_of(ibdev, struct mana_ib_dev, ib_dev);
214 dev = mdev->gdma_dev;
215 gc = dev->gdma_context;
216
217 /* Allocate a doorbell page index */
218 ret = mana_gd_allocate_doorbell_page(gc, &doorbell_page);
219 if (ret) {
220 ibdev_dbg(ibdev, "Failed to allocate doorbell page %d\n", ret);
221 return ret;
222 }
223
224 ibdev_dbg(ibdev, "Doorbell page allocated %d\n", doorbell_page);
225
226 ucontext->doorbell = doorbell_page;
227
228 return 0;
229}
230
231void mana_ib_dealloc_ucontext(struct ib_ucontext *ibcontext)
232{
233 struct mana_ib_ucontext *mana_ucontext =
234 container_of(ibcontext, struct mana_ib_ucontext, ibucontext);
235 struct ib_device *ibdev = ibcontext->device;
236 struct mana_ib_dev *mdev;
237 struct gdma_context *gc;
238 int ret;
239
240 mdev = container_of(ibdev, struct mana_ib_dev, ib_dev);
241 gc = mdev->gdma_dev->gdma_context;
242
243 ret = mana_gd_destroy_doorbell_page(gc, mana_ucontext->doorbell);
244 if (ret)
245 ibdev_dbg(ibdev, "Failed to destroy doorbell page %d\n", ret);
246}
247
248static int
249mana_ib_gd_first_dma_region(struct mana_ib_dev *dev,
250 struct gdma_context *gc,
251 struct gdma_create_dma_region_req *create_req,
252 size_t num_pages, mana_handle_t *gdma_region,
253 u32 expected_status)
254{
255 struct gdma_create_dma_region_resp create_resp = {};
256 unsigned int create_req_msg_size;
257 int err;
258
259 create_req_msg_size =
260 struct_size(create_req, page_addr_list, num_pages);
261 create_req->page_addr_list_len = num_pages;
262
263 err = mana_gd_send_request(gc, create_req_msg_size, create_req,
264 sizeof(create_resp), &create_resp);
265 if (err || create_resp.hdr.status != expected_status) {
266 ibdev_dbg(&dev->ib_dev,
267 "Failed to create DMA region: %d, 0x%x\n",
268 err, create_resp.hdr.status);
269 if (!err)
270 err = -EPROTO;
271
272 return err;
273 }
274
275 *gdma_region = create_resp.dma_region_handle;
276 ibdev_dbg(&dev->ib_dev, "Created DMA region handle 0x%llx\n",
277 *gdma_region);
278
279 return 0;
280}
281
282static int
283mana_ib_gd_add_dma_region(struct mana_ib_dev *dev, struct gdma_context *gc,
284 struct gdma_dma_region_add_pages_req *add_req,
285 unsigned int num_pages, u32 expected_status)
286{
287 unsigned int add_req_msg_size =
288 struct_size(add_req, page_addr_list, num_pages);
289 struct gdma_general_resp add_resp = {};
290 int err;
291
292 mana_gd_init_req_hdr(&add_req->hdr, GDMA_DMA_REGION_ADD_PAGES,
293 add_req_msg_size, sizeof(add_resp));
294 add_req->page_addr_list_len = num_pages;
295
296 err = mana_gd_send_request(gc, add_req_msg_size, add_req,
297 sizeof(add_resp), &add_resp);
298 if (err || add_resp.hdr.status != expected_status) {
299 ibdev_dbg(&dev->ib_dev,
300 "Failed to create DMA region: %d, 0x%x\n",
301 err, add_resp.hdr.status);
302
303 if (!err)
304 err = -EPROTO;
305
306 return err;
307 }
308
309 return 0;
310}
311
312int mana_ib_gd_create_dma_region(struct mana_ib_dev *dev, struct ib_umem *umem,
313 mana_handle_t *gdma_region)
314{
315 struct gdma_dma_region_add_pages_req *add_req = NULL;
316 size_t num_pages_processed = 0, num_pages_to_handle;
317 struct gdma_create_dma_region_req *create_req;
318 unsigned int create_req_msg_size;
319 struct hw_channel_context *hwc;
320 struct ib_block_iter biter;
321 size_t max_pgs_add_cmd = 0;
322 size_t max_pgs_create_cmd;
323 struct gdma_context *gc;
324 size_t num_pages_total;
325 struct gdma_dev *mdev;
326 unsigned long page_sz;
327 unsigned int tail = 0;
328 u64 *page_addr_list;
329 void *request_buf;
330 int err;
331
332 mdev = dev->gdma_dev;
333 gc = mdev->gdma_context;
334 hwc = gc->hwc.driver_data;
335
336 /* Hardware requires dma region to align to chosen page size */
337 page_sz = ib_umem_find_best_pgsz(umem, PAGE_SZ_BM, 0);
338 if (!page_sz) {
339 ibdev_dbg(&dev->ib_dev, "failed to find page size.\n");
340 return -ENOMEM;
341 }
342 num_pages_total = ib_umem_num_dma_blocks(umem, page_sz);
343
344 max_pgs_create_cmd =
345 (hwc->max_req_msg_size - sizeof(*create_req)) / sizeof(u64);
346 num_pages_to_handle =
347 min_t(size_t, num_pages_total, max_pgs_create_cmd);
348 create_req_msg_size =
349 struct_size(create_req, page_addr_list, num_pages_to_handle);
350
351 request_buf = kzalloc(hwc->max_req_msg_size, GFP_KERNEL);
352 if (!request_buf)
353 return -ENOMEM;
354
355 create_req = request_buf;
356 mana_gd_init_req_hdr(&create_req->hdr, GDMA_CREATE_DMA_REGION,
357 create_req_msg_size,
358 sizeof(struct gdma_create_dma_region_resp));
359
360 create_req->length = umem->length;
361 create_req->offset_in_page = umem->address & (page_sz - 1);
362 create_req->gdma_page_type = order_base_2(page_sz) - PAGE_SHIFT;
363 create_req->page_count = num_pages_total;
364
365 ibdev_dbg(&dev->ib_dev, "size_dma_region %lu num_pages_total %lu\n",
366 umem->length, num_pages_total);
367
368 ibdev_dbg(&dev->ib_dev, "page_sz %lu offset_in_page %u\n",
369 page_sz, create_req->offset_in_page);
370
371 ibdev_dbg(&dev->ib_dev, "num_pages_to_handle %lu, gdma_page_type %u",
372 num_pages_to_handle, create_req->gdma_page_type);
373
374 page_addr_list = create_req->page_addr_list;
375 rdma_umem_for_each_dma_block(umem, &biter, page_sz) {
376 u32 expected_status = 0;
377
378 page_addr_list[tail++] = rdma_block_iter_dma_address(&biter);
379 if (tail < num_pages_to_handle)
380 continue;
381
382 if (num_pages_processed + num_pages_to_handle <
383 num_pages_total)
384 expected_status = GDMA_STATUS_MORE_ENTRIES;
385
386 if (!num_pages_processed) {
387 /* First create message */
388 err = mana_ib_gd_first_dma_region(dev, gc, create_req,
389 tail, gdma_region,
390 expected_status);
391 if (err)
392 goto out;
393
394 max_pgs_add_cmd = (hwc->max_req_msg_size -
395 sizeof(*add_req)) / sizeof(u64);
396
397 add_req = request_buf;
398 add_req->dma_region_handle = *gdma_region;
399 add_req->reserved3 = 0;
400 page_addr_list = add_req->page_addr_list;
401 } else {
402 /* Subsequent create messages */
403 err = mana_ib_gd_add_dma_region(dev, gc, add_req, tail,
404 expected_status);
405 if (err)
406 break;
407 }
408
409 num_pages_processed += tail;
410 tail = 0;
411
412 /* The remaining pages to create */
413 num_pages_to_handle =
414 min_t(size_t,
415 num_pages_total - num_pages_processed,
416 max_pgs_add_cmd);
417 }
418
419 if (err)
420 mana_ib_gd_destroy_dma_region(dev, *gdma_region);
421
422out:
423 kfree(request_buf);
424 return err;
425}
426
427int mana_ib_gd_destroy_dma_region(struct mana_ib_dev *dev, u64 gdma_region)
428{
429 struct gdma_dev *mdev = dev->gdma_dev;
430 struct gdma_context *gc;
431
432 gc = mdev->gdma_context;
433 ibdev_dbg(&dev->ib_dev, "destroy dma region 0x%llx\n", gdma_region);
434
435 return mana_gd_destroy_dma_region(gc, gdma_region);
436}
437
438int mana_ib_mmap(struct ib_ucontext *ibcontext, struct vm_area_struct *vma)
439{
440 struct mana_ib_ucontext *mana_ucontext =
441 container_of(ibcontext, struct mana_ib_ucontext, ibucontext);
442 struct ib_device *ibdev = ibcontext->device;
443 struct mana_ib_dev *mdev;
444 struct gdma_context *gc;
445 phys_addr_t pfn;
446 pgprot_t prot;
447 int ret;
448
449 mdev = container_of(ibdev, struct mana_ib_dev, ib_dev);
450 gc = mdev->gdma_dev->gdma_context;
451
452 if (vma->vm_pgoff != 0) {
453 ibdev_dbg(ibdev, "Unexpected vm_pgoff %lu\n", vma->vm_pgoff);
454 return -EINVAL;
455 }
456
457 /* Map to the page indexed by ucontext->doorbell */
458 pfn = (gc->phys_db_page_base +
459 gc->db_page_size * mana_ucontext->doorbell) >>
460 PAGE_SHIFT;
461 prot = pgprot_writecombine(vma->vm_page_prot);
462
463 ret = rdma_user_mmap_io(ibcontext, vma, pfn, gc->db_page_size, prot,
464 NULL);
465 if (ret)
466 ibdev_dbg(ibdev, "can't rdma_user_mmap_io ret %d\n", ret);
467 else
468 ibdev_dbg(ibdev, "mapped I/O pfn 0x%llx page_size %u, ret %d\n",
469 pfn, gc->db_page_size, ret);
470
471 return ret;
472}
473
474int mana_ib_get_port_immutable(struct ib_device *ibdev, u32 port_num,
475 struct ib_port_immutable *immutable)
476{
477 /*
478 * This version only support RAW_PACKET
479 * other values need to be filled for other types
480 */
481 immutable->core_cap_flags = RDMA_CORE_PORT_RAW_PACKET;
482
483 return 0;
484}
485
486int mana_ib_query_device(struct ib_device *ibdev, struct ib_device_attr *props,
487 struct ib_udata *uhw)
488{
489 struct mana_ib_dev *dev = container_of(ibdev,
490 struct mana_ib_dev, ib_dev);
491
492 props->max_qp = dev->adapter_caps.max_qp_count;
493 props->max_qp_wr = dev->adapter_caps.max_qp_wr;
494 props->max_cq = dev->adapter_caps.max_cq_count;
495 props->max_cqe = dev->adapter_caps.max_qp_wr;
496 props->max_mr = dev->adapter_caps.max_mr_count;
497 props->max_mr_size = MANA_IB_MAX_MR_SIZE;
498 props->max_send_sge = dev->adapter_caps.max_send_sge_count;
499 props->max_recv_sge = dev->adapter_caps.max_recv_sge_count;
500
501 return 0;
502}
503
504int mana_ib_query_port(struct ib_device *ibdev, u32 port,
505 struct ib_port_attr *props)
506{
507 /* This version doesn't return port properties */
508 return 0;
509}
510
511int mana_ib_query_gid(struct ib_device *ibdev, u32 port, int index,
512 union ib_gid *gid)
513{
514 /* This version doesn't return GID properties */
515 return 0;
516}
517
518void mana_ib_disassociate_ucontext(struct ib_ucontext *ibcontext)
519{
520}
521
522int mana_ib_gd_query_adapter_caps(struct mana_ib_dev *dev)
523{
524 struct mana_ib_adapter_caps *caps = &dev->adapter_caps;
525 struct mana_ib_query_adapter_caps_resp resp = {};
526 struct mana_ib_query_adapter_caps_req req = {};
527 int err;
528
529 mana_gd_init_req_hdr(&req.hdr, MANA_IB_GET_ADAPTER_CAP, sizeof(req),
530 sizeof(resp));
531 req.hdr.resp.msg_version = GDMA_MESSAGE_V3;
532 req.hdr.dev_id = dev->gdma_dev->dev_id;
533
534 err = mana_gd_send_request(dev->gdma_dev->gdma_context, sizeof(req),
535 &req, sizeof(resp), &resp);
536
537 if (err) {
538 ibdev_err(&dev->ib_dev,
539 "Failed to query adapter caps err %d", err);
540 return err;
541 }
542
543 caps->max_sq_id = resp.max_sq_id;
544 caps->max_rq_id = resp.max_rq_id;
545 caps->max_cq_id = resp.max_cq_id;
546 caps->max_qp_count = resp.max_qp_count;
547 caps->max_cq_count = resp.max_cq_count;
548 caps->max_mr_count = resp.max_mr_count;
549 caps->max_pd_count = resp.max_pd_count;
550 caps->max_inbound_read_limit = resp.max_inbound_read_limit;
551 caps->max_outbound_read_limit = resp.max_outbound_read_limit;
552 caps->mw_count = resp.mw_count;
553 caps->max_srq_count = resp.max_srq_count;
554 caps->max_qp_wr = min_t(u32,
555 resp.max_requester_sq_size / GDMA_MAX_SQE_SIZE,
556 resp.max_requester_rq_size / GDMA_MAX_RQE_SIZE);
557 caps->max_inline_data_size = resp.max_inline_data_size;
558 caps->max_send_sge_count = resp.max_send_sge_count;
559 caps->max_recv_sge_count = resp.max_recv_sge_count;
560
561 return 0;
562}