Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(C) 2021 Marvell.
3 : : */
4 : :
5 : : #include "roc_api.h"
6 : : #include "roc_priv.h"
7 : :
8 : : #define REE0_PF 19
9 : : #define REE1_PF 20
10 : :
11 : : static int
12 : 0 : roc_ree_available_queues_get(struct roc_ree_vf *vf, uint16_t *nb_queues)
13 : : {
14 : : struct free_rsrcs_rsp *rsp;
15 : 0 : struct dev *dev = vf->dev;
16 : : int ret;
17 : :
18 : 0 : mbox_alloc_msg_free_rsrc_cnt(dev->mbox);
19 : :
20 : 0 : ret = mbox_process_msg(dev->mbox, (void *)&rsp);
21 [ # # ]: 0 : if (ret)
22 : : return -EIO;
23 : :
24 [ # # ]: 0 : if (vf->block_address == RVU_BLOCK_ADDR_REE0)
25 : 0 : *nb_queues = rsp->ree0;
26 : : else
27 : 0 : *nb_queues = rsp->ree1;
28 : : return 0;
29 : : }
30 : :
31 : : static int
32 : : roc_ree_max_matches_get(struct roc_ree_vf *vf, uint8_t *max_matches)
33 : : {
34 : : uint64_t val;
35 : : int ret;
36 : :
37 : 0 : ret = roc_ree_af_reg_read(vf, REE_AF_REEXM_MAX_MATCH, &val);
38 [ # # ]: 0 : if (ret)
39 : : return ret;
40 : :
41 : 0 : *max_matches = val;
42 : : return 0;
43 : : }
44 : :
45 : : int
46 : 0 : roc_ree_queues_attach(struct roc_ree_vf *vf, uint8_t nb_queues)
47 : : {
48 : : struct rsrc_attach_req *req;
49 : : struct mbox *mbox;
50 : :
51 : 0 : mbox = vf->dev->mbox;
52 : : /* Ask AF to attach required LFs */
53 : 0 : req = mbox_alloc_msg_attach_resources(mbox);
54 [ # # ]: 0 : if (req == NULL) {
55 : 0 : plt_err("Could not allocate mailbox message");
56 : 0 : return -EFAULT;
57 : : }
58 : :
59 : : /* 1 LF = 1 queue */
60 : 0 : req->reelfs = nb_queues;
61 : 0 : req->ree_blkaddr = vf->block_address;
62 : :
63 [ # # ]: 0 : if (mbox_process(mbox) < 0)
64 : : return -EIO;
65 : :
66 : : /* Update number of attached queues */
67 : 0 : vf->nb_queues = nb_queues;
68 : :
69 : 0 : return 0;
70 : : }
71 : :
72 : : int
73 : 0 : roc_ree_queues_detach(struct roc_ree_vf *vf)
74 : : {
75 : : struct rsrc_detach_req *req;
76 : : struct mbox *mbox;
77 : :
78 : 0 : mbox = vf->dev->mbox;
79 : 0 : req = mbox_alloc_msg_detach_resources(mbox);
80 [ # # ]: 0 : if (req == NULL) {
81 : 0 : plt_err("Could not allocate mailbox message");
82 : 0 : return -EFAULT;
83 : : }
84 : 0 : req->reelfs = true;
85 : 0 : req->partial = true;
86 [ # # ]: 0 : if (mbox_process(mbox) < 0)
87 : : return -EIO;
88 : :
89 : : /* Queues have been detached */
90 : 0 : vf->nb_queues = 0;
91 : :
92 : 0 : return 0;
93 : : }
94 : :
95 : : int
96 : 0 : roc_ree_msix_offsets_get(struct roc_ree_vf *vf)
97 : : {
98 : : struct msix_offset_rsp *rsp;
99 : : struct mbox *mbox;
100 : : uint32_t i, ret;
101 : :
102 : : /* Get REE MSI-X vector offsets */
103 : 0 : mbox = vf->dev->mbox;
104 : 0 : mbox_alloc_msg_msix_offset(mbox);
105 : :
106 : : ret = mbox_process_msg(mbox, (void *)&rsp);
107 [ # # ]: 0 : if (ret)
108 : : return ret;
109 : :
110 [ # # ]: 0 : for (i = 0; i < vf->nb_queues; i++) {
111 [ # # ]: 0 : if (vf->block_address == RVU_BLOCK_ADDR_REE0)
112 : 0 : vf->lf_msixoff[i] = rsp->ree0_lf_msixoff[i];
113 : : else
114 : 0 : vf->lf_msixoff[i] = rsp->ree1_lf_msixoff[i];
115 : 0 : plt_ree_dbg("lf_msixoff[%d] 0x%x", i, vf->lf_msixoff[i]);
116 : : }
117 : :
118 : : return 0;
119 : : }
120 : :
121 : : static int
122 : 0 : ree_send_mbox_msg(struct roc_ree_vf *vf)
123 : : {
124 : 0 : struct mbox *mbox = vf->dev->mbox;
125 : : int ret;
126 : :
127 : 0 : mbox_msg_send(mbox, 0);
128 : :
129 : 0 : ret = mbox_wait_for_rsp(mbox, 0);
130 [ # # ]: 0 : if (ret < 0) {
131 : 0 : plt_err("Could not get mailbox response");
132 : 0 : return ret;
133 : : }
134 : :
135 : : return 0;
136 : : }
137 : :
138 : : int
139 : 0 : roc_ree_config_lf(struct roc_ree_vf *vf, uint8_t lf, uint8_t pri, uint32_t size)
140 : : {
141 : : struct ree_lf_req_msg *req;
142 : : struct mbox *mbox;
143 : : int ret;
144 : :
145 : 0 : mbox = vf->dev->mbox;
146 : 0 : req = mbox_alloc_msg_ree_config_lf(mbox);
147 [ # # ]: 0 : if (req == NULL) {
148 : 0 : plt_err("Could not allocate mailbox message");
149 : 0 : return -EFAULT;
150 : : }
151 : :
152 : 0 : req->lf = lf;
153 : 0 : req->pri = pri ? 1 : 0;
154 : 0 : req->size = size;
155 : 0 : req->blkaddr = vf->block_address;
156 : :
157 : 0 : ret = mbox_process(mbox);
158 [ # # ]: 0 : if (ret < 0) {
159 : 0 : plt_err("Could not get mailbox response");
160 : 0 : return ret;
161 : : }
162 : : return 0;
163 : : }
164 : :
165 : : int
166 : 0 : roc_ree_af_reg_read(struct roc_ree_vf *vf, uint64_t reg, uint64_t *val)
167 : : {
168 : : struct ree_rd_wr_reg_msg *msg;
169 : : struct mbox_dev *mdev;
170 : : struct mbox *mbox;
171 : : int ret, off;
172 : :
173 : 0 : mbox = vf->dev->mbox;
174 : 0 : mdev = &mbox->dev[0];
175 : 0 : msg = (struct ree_rd_wr_reg_msg *)mbox_alloc_msg_rsp(
176 : : mbox, 0, sizeof(*msg), sizeof(*msg));
177 [ # # ]: 0 : if (msg == NULL) {
178 : 0 : plt_err("Could not allocate mailbox message");
179 : 0 : return -EFAULT;
180 : : }
181 : :
182 : 0 : msg->hdr.id = MBOX_MSG_REE_RD_WR_REGISTER;
183 : 0 : msg->hdr.sig = MBOX_REQ_SIG;
184 : 0 : msg->hdr.pcifunc = vf->dev->pf_func;
185 : 0 : msg->is_write = 0;
186 : 0 : msg->reg_offset = reg;
187 : 0 : msg->ret_val = val;
188 : 0 : msg->blkaddr = vf->block_address;
189 : :
190 : 0 : ret = ree_send_mbox_msg(vf);
191 [ # # ]: 0 : if (ret < 0)
192 : : return ret;
193 : :
194 : 0 : off = mbox->rx_start +
195 : : RTE_ALIGN(sizeof(struct mbox_hdr), MBOX_MSG_ALIGN);
196 : 0 : msg = (struct ree_rd_wr_reg_msg *)((uintptr_t)mdev->mbase + off);
197 : :
198 : 0 : *val = msg->val;
199 : :
200 : 0 : return 0;
201 : : }
202 : :
203 : : int
204 : 0 : roc_ree_af_reg_write(struct roc_ree_vf *vf, uint64_t reg, uint64_t val)
205 : : {
206 : : struct ree_rd_wr_reg_msg *msg;
207 : : struct mbox *mbox;
208 : :
209 : 0 : mbox = vf->dev->mbox;
210 : 0 : msg = (struct ree_rd_wr_reg_msg *)mbox_alloc_msg_rsp(
211 : : mbox, 0, sizeof(*msg), sizeof(*msg));
212 [ # # ]: 0 : if (msg == NULL) {
213 : 0 : plt_err("Could not allocate mailbox message");
214 : 0 : return -EFAULT;
215 : : }
216 : :
217 : 0 : msg->hdr.id = MBOX_MSG_REE_RD_WR_REGISTER;
218 : 0 : msg->hdr.sig = MBOX_REQ_SIG;
219 : 0 : msg->hdr.pcifunc = vf->dev->pf_func;
220 : 0 : msg->is_write = 1;
221 : 0 : msg->reg_offset = reg;
222 : 0 : msg->val = val;
223 : 0 : msg->blkaddr = vf->block_address;
224 : :
225 : 0 : return ree_send_mbox_msg(vf);
226 : : }
227 : :
228 : : int
229 : 0 : roc_ree_rule_db_get(struct roc_ree_vf *vf, char *rule_db, uint32_t rule_db_len,
230 : : char *rule_dbi, uint32_t rule_dbi_len)
231 : : {
232 : : struct ree_rule_db_get_req_msg *req;
233 : : struct ree_rule_db_get_rsp_msg *rsp;
234 : : char *rule_db_ptr = (char *)rule_db;
235 : : struct mbox *mbox;
236 : : int ret, last = 0;
237 : : uint32_t len = 0;
238 : :
239 : 0 : mbox = vf->dev->mbox;
240 [ # # ]: 0 : if (!rule_db) {
241 : 0 : plt_err("Couldn't return rule db due to NULL pointer");
242 : 0 : return -EFAULT;
243 : : }
244 : :
245 [ # # ]: 0 : while (!last) {
246 : 0 : req = (struct ree_rule_db_get_req_msg *)mbox_alloc_msg_rsp(
247 : : mbox, 0, sizeof(*req), sizeof(*rsp));
248 [ # # ]: 0 : if (!req) {
249 : 0 : plt_err("Could not allocate mailbox message");
250 : 0 : return -EFAULT;
251 : : }
252 : :
253 : 0 : req->hdr.id = MBOX_MSG_REE_RULE_DB_GET;
254 : 0 : req->hdr.sig = MBOX_REQ_SIG;
255 : 0 : req->hdr.pcifunc = vf->dev->pf_func;
256 : 0 : req->blkaddr = vf->block_address;
257 : 0 : req->is_dbi = 0;
258 : 0 : req->offset = len;
259 : : ret = mbox_process_msg(mbox, (void *)&rsp);
260 [ # # ]: 0 : if (ret)
261 : 0 : return ret;
262 [ # # ]: 0 : if (rule_db_len < len + rsp->len) {
263 : 0 : plt_err("Rule db size is too small");
264 : 0 : return -EFAULT;
265 : : }
266 [ # # ]: 0 : mbox_memcpy(rule_db_ptr, rsp->rule_db, rsp->len);
267 : 0 : len += rsp->len;
268 : 0 : rule_db_ptr = rule_db_ptr + rsp->len;
269 : 0 : last = rsp->is_last;
270 : : }
271 : :
272 [ # # ]: 0 : if (rule_dbi) {
273 : 0 : req = (struct ree_rule_db_get_req_msg *)mbox_alloc_msg_rsp(
274 : : mbox, 0, sizeof(*req), sizeof(*rsp));
275 [ # # ]: 0 : if (!req) {
276 : 0 : plt_err("Could not allocate mailbox message");
277 : 0 : return -EFAULT;
278 : : }
279 : :
280 : 0 : req->hdr.id = MBOX_MSG_REE_RULE_DB_GET;
281 : 0 : req->hdr.sig = MBOX_REQ_SIG;
282 : 0 : req->hdr.pcifunc = vf->dev->pf_func;
283 : 0 : req->blkaddr = vf->block_address;
284 : 0 : req->is_dbi = 1;
285 : 0 : req->offset = 0;
286 : :
287 : : ret = mbox_process_msg(mbox, (void *)&rsp);
288 [ # # ]: 0 : if (ret)
289 : : return ret;
290 [ # # ]: 0 : if (rule_dbi_len < rsp->len) {
291 : 0 : plt_err("Rule dbi size is too small");
292 : 0 : return -EFAULT;
293 : : }
294 : 0 : mbox_memcpy(rule_dbi, rsp->rule_db, rsp->len);
295 : : }
296 : : return 0;
297 : : }
298 : :
299 : : int
300 : 0 : roc_ree_rule_db_len_get(struct roc_ree_vf *vf, uint32_t *rule_db_len,
301 : : uint32_t *rule_dbi_len)
302 : : {
303 : : struct ree_rule_db_len_rsp_msg *rsp;
304 : : struct ree_req_msg *req;
305 : : struct mbox *mbox;
306 : : int ret;
307 : :
308 : 0 : mbox = vf->dev->mbox;
309 : 0 : req = (struct ree_req_msg *)mbox_alloc_msg_rsp(mbox, 0, sizeof(*req),
310 : : sizeof(*rsp));
311 [ # # ]: 0 : if (!req) {
312 : 0 : plt_err("Could not allocate mailbox message");
313 : 0 : return -EFAULT;
314 : : }
315 : :
316 : 0 : req->hdr.id = MBOX_MSG_REE_RULE_DB_LEN_GET;
317 : 0 : req->hdr.sig = MBOX_REQ_SIG;
318 : 0 : req->hdr.pcifunc = vf->dev->pf_func;
319 : 0 : req->blkaddr = vf->block_address;
320 : : ret = mbox_process_msg(mbox, (void *)&rsp);
321 [ # # ]: 0 : if (ret)
322 : : return ret;
323 [ # # ]: 0 : if (rule_db_len != NULL)
324 : 0 : *rule_db_len = rsp->len;
325 [ # # ]: 0 : if (rule_dbi_len != NULL)
326 : 0 : *rule_dbi_len = rsp->inc_len;
327 : :
328 : : return 0;
329 : : }
330 : :
331 : : static int
332 : 0 : ree_db_msg(struct roc_ree_vf *vf, const char *db, uint32_t db_len, int inc,
333 : : int dbi)
334 : : {
335 : : uint32_t len_left = db_len, offset = 0;
336 : : struct ree_rule_db_prog_req_msg *req;
337 : : const char *rule_db_ptr = db;
338 : : struct mbox *mbox;
339 : : struct msg_rsp *rsp;
340 : : int ret;
341 : :
342 : 0 : mbox = vf->dev->mbox;
343 [ # # ]: 0 : while (len_left) {
344 : 0 : req = (struct ree_rule_db_prog_req_msg *)mbox_alloc_msg_rsp(
345 : : mbox, 0, sizeof(*req), sizeof(*rsp));
346 [ # # ]: 0 : if (!req) {
347 : 0 : plt_err("Could not allocate mailbox message");
348 : 0 : return -EFAULT;
349 : : }
350 : 0 : req->hdr.id = MBOX_MSG_REE_RULE_DB_PROG;
351 : 0 : req->hdr.sig = MBOX_REQ_SIG;
352 : 0 : req->hdr.pcifunc = vf->dev->pf_func;
353 : 0 : req->offset = offset;
354 : 0 : req->total_len = db_len;
355 : 0 : req->len = REE_RULE_DB_REQ_BLOCK_SIZE;
356 : 0 : req->is_incremental = inc;
357 : 0 : req->is_dbi = dbi;
358 : 0 : req->blkaddr = vf->block_address;
359 : :
360 [ # # ]: 0 : if (len_left < REE_RULE_DB_REQ_BLOCK_SIZE) {
361 : 0 : req->is_last = true;
362 : 0 : req->len = len_left;
363 : : }
364 [ # # ]: 0 : mbox_memcpy(req->rule_db, rule_db_ptr, req->len);
365 : : ret = mbox_process_msg(mbox, (void *)&rsp);
366 [ # # ]: 0 : if (ret) {
367 : 0 : plt_err("Programming mailbox processing failed");
368 : 0 : return ret;
369 : : }
370 : 0 : len_left -= req->len;
371 : 0 : offset += req->len;
372 : 0 : rule_db_ptr = rule_db_ptr + req->len;
373 : : }
374 : : return 0;
375 : : }
376 : :
377 : : int
378 : 0 : roc_ree_rule_db_prog(struct roc_ree_vf *vf, const char *rule_db,
379 : : uint32_t rule_db_len, const char *rule_dbi,
380 : : uint32_t rule_dbi_len)
381 : : {
382 : : int inc, ret;
383 : :
384 [ # # ]: 0 : if (rule_db_len == 0) {
385 : 0 : plt_err("Couldn't program empty rule db");
386 : 0 : return -EFAULT;
387 : : }
388 : 0 : inc = (rule_dbi_len != 0);
389 [ # # # # ]: 0 : if ((rule_db == NULL) || (inc && (rule_dbi == NULL))) {
390 : 0 : plt_err("Couldn't program NULL rule db");
391 : 0 : return -EFAULT;
392 : : }
393 [ # # ]: 0 : if (inc) {
394 : 0 : ret = ree_db_msg(vf, rule_dbi, rule_dbi_len, inc, 1);
395 [ # # ]: 0 : if (ret)
396 : : return ret;
397 : : }
398 : 0 : return ree_db_msg(vf, rule_db, rule_db_len, inc, 0);
399 : : }
400 : :
401 : : static int
402 : : ree_get_blkaddr(struct dev *dev)
403 : : {
404 : : int pf;
405 : :
406 [ # # ]: 0 : pf = dev_get_pf(dev->pf_func);
407 [ # # ]: 0 : if (pf == REE0_PF)
408 : : return RVU_BLOCK_ADDR_REE0;
409 [ # # ]: 0 : else if (pf == REE1_PF)
410 : : return RVU_BLOCK_ADDR_REE1;
411 : : else
412 : 0 : return 0;
413 : : }
414 : :
415 : : uintptr_t
416 : 0 : roc_ree_qp_get_base(struct roc_ree_vf *vf, uint16_t qp_id)
417 : : {
418 : 0 : return REE_LF_BAR2(vf, qp_id);
419 : : }
420 : :
421 : : static void
422 : 0 : roc_ree_lf_err_intr_handler(void *param)
423 : : {
424 : 0 : uintptr_t base = (uintptr_t)param;
425 : : uint8_t lf_id;
426 : : uint64_t intr;
427 : :
428 : 0 : lf_id = (base >> 12) & 0xFF;
429 : :
430 [ # # ]: 0 : intr = plt_read64(base + REE_LF_MISC_INT);
431 [ # # ]: 0 : if (intr == 0)
432 : : return;
433 : :
434 : 0 : plt_ree_dbg("LF %d MISC_INT: 0x%" PRIx64 "", lf_id, intr);
435 : :
436 : : /* Clear interrupt */
437 : : plt_write64(intr, base + REE_LF_MISC_INT);
438 : : }
439 : :
440 : : static void
441 : : roc_ree_lf_err_intr_unregister(struct roc_ree_vf *vf, uint16_t msix_off,
442 : : uintptr_t base)
443 : : {
444 : 0 : struct plt_pci_device *pci_dev = vf->pci_dev;
445 : :
446 : : /* Disable error interrupts */
447 : 0 : plt_write64(~0ull, base + REE_LF_MISC_INT_ENA_W1C);
448 : :
449 : 0 : dev_irq_unregister(pci_dev->intr_handle,
450 : : roc_ree_lf_err_intr_handler, (void *)base, msix_off);
451 : : }
452 : :
453 : : void
454 : 0 : roc_ree_err_intr_unregister(struct roc_ree_vf *vf)
455 : : {
456 : : uintptr_t base;
457 : : uint32_t i;
458 : :
459 [ # # ]: 0 : for (i = 0; i < vf->nb_queues; i++) {
460 : 0 : base = REE_LF_BAR2(vf, i);
461 : 0 : roc_ree_lf_err_intr_unregister(vf, vf->lf_msixoff[i], base);
462 : : }
463 : :
464 : 0 : vf->err_intr_registered = 0;
465 : 0 : }
466 : :
467 : : static int
468 : 0 : roc_ree_lf_err_intr_register(struct roc_ree_vf *vf, uint16_t msix_off,
469 : : uintptr_t base)
470 : : {
471 : 0 : struct plt_pci_device *pci_dev = vf->pci_dev;
472 : : int ret;
473 : :
474 : : /* Disable error interrupts */
475 : 0 : plt_write64(~0ull, base + REE_LF_MISC_INT_ENA_W1C);
476 : :
477 : : /* Register error interrupt handler */
478 : 0 : ret = dev_irq_register(pci_dev->intr_handle,
479 : : roc_ree_lf_err_intr_handler, (void *)base,
480 : : msix_off);
481 [ # # ]: 0 : if (ret)
482 : : return ret;
483 : :
484 : : /* Enable error interrupts */
485 : 0 : plt_write64(~0ull, base + REE_LF_MISC_INT_ENA_W1S);
486 : :
487 : 0 : return 0;
488 : : }
489 : :
490 : : int
491 : 0 : roc_ree_err_intr_register(struct roc_ree_vf *vf)
492 : : {
493 : : uint32_t i, j, ret;
494 : : uintptr_t base;
495 : :
496 [ # # ]: 0 : for (i = 0; i < vf->nb_queues; i++) {
497 [ # # ]: 0 : if (vf->lf_msixoff[i] == MSIX_VECTOR_INVALID) {
498 : 0 : plt_err("Invalid REE LF MSI-X offset: 0x%x",
499 : : vf->lf_msixoff[i]);
500 : 0 : return -EINVAL;
501 : : }
502 : : }
503 : :
504 [ # # ]: 0 : for (i = 0; i < vf->nb_queues; i++) {
505 : 0 : base = REE_LF_BAR2(vf, i);
506 : 0 : ret = roc_ree_lf_err_intr_register(vf, vf->lf_msixoff[i], base);
507 [ # # ]: 0 : if (ret)
508 : 0 : goto intr_unregister;
509 : : }
510 : :
511 : 0 : vf->err_intr_registered = 1;
512 : 0 : return 0;
513 : :
514 : : intr_unregister:
515 : : /* Unregister the ones already registered */
516 [ # # ]: 0 : for (j = 0; j < i; j++) {
517 : 0 : base = REE_LF_BAR2(vf, j);
518 : 0 : roc_ree_lf_err_intr_unregister(vf, vf->lf_msixoff[j], base);
519 : : }
520 : : return ret;
521 : : }
522 : :
523 : : int
524 : 0 : roc_ree_iq_enable(struct roc_ree_vf *vf, const struct roc_ree_qp *qp,
525 : : uint8_t pri, uint32_t size_div2)
526 : : {
527 : : uint64_t val;
528 : :
529 : : /* Set instruction queue size and priority */
530 : 0 : roc_ree_config_lf(vf, qp->id, pri, size_div2);
531 : :
532 : : /* Set instruction queue base address */
533 : : /* Should be written after SBUF_CTL and before LF_ENA */
534 : :
535 : 0 : val = plt_read64(qp->base + REE_LF_SBUF_ADDR);
536 : 0 : val &= ~REE_LF_SBUF_ADDR_PTR_MASK;
537 : 0 : val |= FIELD_PREP(REE_LF_SBUF_ADDR_PTR_MASK, qp->iq_dma_addr >> 7);
538 : : plt_write64(val, qp->base + REE_LF_SBUF_ADDR);
539 : :
540 : : /* Enable instruction queue */
541 : :
542 : 0 : val = plt_read64(qp->base + REE_LF_ENA);
543 : 0 : val &= ~REE_LF_ENA_ENA_MASK;
544 : 0 : val |= FIELD_PREP(REE_LF_ENA_ENA_MASK, 1);
545 : : plt_write64(val, qp->base + REE_LF_ENA);
546 : :
547 : 0 : return 0;
548 : : }
549 : :
550 : : void
551 : 0 : roc_ree_iq_disable(struct roc_ree_qp *qp)
552 : : {
553 : : uint64_t val;
554 : :
555 : : /* Stop instruction execution */
556 : 0 : val = plt_read64(qp->base + REE_LF_ENA);
557 : 0 : val &= ~REE_LF_ENA_ENA_MASK;
558 : : val |= FIELD_PREP(REE_LF_ENA_ENA_MASK, 0);
559 : : plt_write64(val, qp->base + REE_LF_ENA);
560 : 0 : }
561 : :
562 : : int
563 : 0 : roc_ree_dev_init(struct roc_ree_vf *vf)
564 : : {
565 : : struct plt_pci_device *pci_dev;
566 : : struct ree *ree;
567 : : struct dev *dev;
568 : : uint8_t max_matches = 0;
569 : 0 : uint16_t nb_queues = 0;
570 : : int rc;
571 : :
572 [ # # # # ]: 0 : if (vf == NULL || vf->pci_dev == NULL)
573 : : return -EINVAL;
574 : :
575 : : PLT_STATIC_ASSERT(sizeof(struct ree) <= ROC_REE_MEM_SZ);
576 : :
577 : : ree = roc_ree_to_ree_priv(vf);
578 : : memset(ree, 0, sizeof(*ree));
579 : 0 : vf->dev = &ree->dev;
580 : :
581 : : pci_dev = vf->pci_dev;
582 : : dev = vf->dev;
583 : :
584 : : /* Initialize device */
585 : 0 : rc = dev_init(dev, pci_dev);
586 [ # # ]: 0 : if (rc) {
587 : 0 : plt_err("Failed to init roc device");
588 : 0 : goto fail;
589 : : }
590 : :
591 : : /* Get REE block address */
592 : 0 : vf->block_address = ree_get_blkaddr(dev);
593 [ # # ]: 0 : if (!vf->block_address) {
594 : 0 : plt_err("Could not determine block PF number");
595 : 0 : goto fail;
596 : : }
597 : :
598 : : /* Get number of queues available on the device */
599 : 0 : rc = roc_ree_available_queues_get(vf, &nb_queues);
600 [ # # ]: 0 : if (rc) {
601 : 0 : plt_err("Could not determine the number of queues available");
602 : 0 : goto fail;
603 : : }
604 : :
605 : : /* Don't exceed the limits set per VF */
606 : 0 : nb_queues = RTE_MIN(nb_queues, REE_MAX_QUEUES_PER_VF);
607 : :
608 [ # # ]: 0 : if (nb_queues == 0) {
609 : 0 : plt_err("No free queues available on the device");
610 : 0 : goto fail;
611 : : }
612 : :
613 : 0 : vf->max_queues = nb_queues;
614 : :
615 : 0 : plt_ree_dbg("Max queues supported by device: %d", vf->max_queues);
616 : :
617 : : /* Get number of maximum matches supported on the device */
618 : : rc = roc_ree_max_matches_get(vf, &max_matches);
619 : : if (rc) {
620 : 0 : plt_err("Could not determine the maximum matches supported");
621 : 0 : goto fail;
622 : : }
623 : : /* Don't exceed the limits set per VF */
624 : 0 : max_matches = RTE_MIN(max_matches, REE_MAX_MATCHES_PER_VF);
625 [ # # ]: 0 : if (max_matches == 0) {
626 : 0 : plt_err("Could not determine the maximum matches supported");
627 : 0 : goto fail;
628 : : }
629 : :
630 : 0 : vf->max_matches = max_matches;
631 : :
632 : 0 : plt_ree_dbg("Max matches supported by device: %d", vf->max_matches);
633 : : fail:
634 : : return rc;
635 : : }
636 : :
637 : : int
638 : 0 : roc_ree_dev_fini(struct roc_ree_vf *vf)
639 : : {
640 [ # # ]: 0 : if (vf == NULL)
641 : : return -EINVAL;
642 : :
643 : 0 : vf->max_matches = 0;
644 : 0 : vf->max_queues = 0;
645 : :
646 : 0 : return dev_fini(vf->dev, vf->pci_dev);
647 : : }
|
