1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2019-2021 Broadcom
3 * All rights reserved.
4 */
5
6 /* Truflow Table APIs and supporting code */
7
8 #include <rte_common.h>
9
10 #include "tf_tbl.h"
11 #include "tf_tbl_sram.h"
12 #include "tf_sram_mgr.h"
13 #include "tf_common.h"
14 #include "tf_rm.h"
15 #include "tf_util.h"
16 #include "tf_msg.h"
17 #include "tfp.h"
18 #include "tf_session.h"
19 #include "tf_device.h"
20 #include "cfa_resource_types.h"
21
22 #define DBG_SRAM 0
23
24 #define TF_TBL_PTR_TO_RM(new_idx, idx, base, shift) { \
25 *(new_idx) = (((idx) >> (shift)) - (base)); \
26 }
27
28 /**
29 * tf_sram_tbl_get_info_parms parameter definition
30 */
31 struct tf_tbl_sram_get_info_parms {
32 /**
33 * [in] table RM database
34 */
35 void *rm_db;
36 /**
37 * [in] Receive or transmit direction
38 */
39 enum tf_dir dir;
40 /**
41 * [in] table_type
42 *
43 * the TF index table type
44 */
45 enum tf_tbl_type tbl_type;
46 /**
47 * [out] bank
48 *
49 * The SRAM bank associated with the type
50 */
51 enum tf_sram_bank_id bank_id;
52 /**
53 * [out] slice_size
54 *
55 * the slice size for the indicated table type
56 */
57 enum tf_sram_slice_size slice_size;
58 };
59
60 /**
61 * Translate HCAPI type to SRAM Manager bank
62 */
63 const uint16_t tf_tbl_sram_hcapi_2_bank[CFA_RESOURCE_TYPE_P58_LAST] = {
64 [CFA_RESOURCE_TYPE_P58_SRAM_BANK_0] = TF_SRAM_BANK_ID_0,
65 [CFA_RESOURCE_TYPE_P58_SRAM_BANK_1] = TF_SRAM_BANK_ID_1,
66 [CFA_RESOURCE_TYPE_P58_SRAM_BANK_2] = TF_SRAM_BANK_ID_2,
67 [CFA_RESOURCE_TYPE_P58_SRAM_BANK_3] = TF_SRAM_BANK_ID_3
68 };
69
70 #define TF_TBL_SRAM_SLICES_MAX \
71 (TF_SRAM_MGR_BLOCK_SZ_BYTES / TF_SRAM_MGR_MIN_SLICE_BYTES)
72 /**
73 * Translate HCAPI type to SRAM Manager bank
74 */
75 const uint8_t tf_tbl_sram_slices_2_size[TF_TBL_SRAM_SLICES_MAX + 1] = {
76 [0] = TF_SRAM_SLICE_SIZE_64B, /* if 0 slices assume 1 64B block */
77 [1] = TF_SRAM_SLICE_SIZE_64B, /* 1 slice per 64B block */
78 [2] = TF_SRAM_SLICE_SIZE_32B, /* 2 slices per 64B block */
79 [4] = TF_SRAM_SLICE_SIZE_16B, /* 4 slices per 64B block */
80 [8] = TF_SRAM_SLICE_SIZE_8B /* 8 slices per 64B block */
81 };
82
83 /**
84 * Get SRAM Table Information for a given index table type
85 *
86 *
87 * [in] sram_handle
88 * Pointer to SRAM handle
89 *
90 * [in] parms
91 * Pointer to the SRAM get info parameters
92 *
93 * Returns
94 * - (0) if successful
95 * - (-EINVAL) on failure
96 *
97 */
tf_tbl_sram_get_info(struct tf_tbl_sram_get_info_parms * parms)98 static int tf_tbl_sram_get_info(struct tf_tbl_sram_get_info_parms *parms)
99 {
100 int rc = 0;
101 uint16_t hcapi_type;
102 uint16_t slices;
103 struct tf_rm_get_hcapi_parms hparms;
104 struct tf_rm_get_slices_parms sparms;
105
106 hparms.rm_db = parms->rm_db;
107 hparms.subtype = parms->tbl_type;
108 hparms.hcapi_type = &hcapi_type;
109
110 rc = tf_rm_get_hcapi_type(&hparms);
111 if (rc) {
112 TFP_DRV_LOG(ERR,
113 "%s: Failed to get hcapi_type %s, rc:%s\n",
114 tf_dir_2_str(parms->dir),
115 tf_tbl_type_2_str(parms->tbl_type),
116 strerror(-rc));
117 return rc;
118 }
119 parms->bank_id = tf_tbl_sram_hcapi_2_bank[hcapi_type];
120
121 sparms.rm_db = parms->rm_db;
122 sparms.subtype = parms->tbl_type;
123 sparms.slices = &slices;
124
125 rc = tf_rm_get_slices(&sparms);
126 if (rc) {
127 TFP_DRV_LOG(ERR,
128 "%s: Failed to get slice cnt %s, rc:%s\n",
129 tf_dir_2_str(parms->dir),
130 tf_tbl_type_2_str(parms->tbl_type),
131 strerror(-rc));
132 return rc;
133 }
134 if (slices)
135 parms->slice_size = tf_tbl_sram_slices_2_size[slices];
136
137 return rc;
138 }
139
140 int
tf_tbl_sram_bind(struct tf * tfp __rte_unused)141 tf_tbl_sram_bind(struct tf *tfp __rte_unused)
142 {
143 int rc = 0;
144 void *sram_handle = NULL;
145
146 TF_CHECK_PARMS1(tfp);
147
148 rc = tf_sram_mgr_bind(&sram_handle);
149
150 tf_session_set_sram_db(tfp, sram_handle);
151
152 TFP_DRV_LOG(INFO,
153 "SRAM Table - initialized\n");
154
155 return rc;
156 }
157
158 int
tf_tbl_sram_unbind(struct tf * tfp __rte_unused)159 tf_tbl_sram_unbind(struct tf *tfp __rte_unused)
160 {
161 int rc = 0;
162 void *sram_handle = NULL;
163
164 TF_CHECK_PARMS1(tfp);
165
166 rc = tf_session_get_sram_db(tfp, &sram_handle);
167 if (rc) {
168 TFP_DRV_LOG(ERR,
169 "Failed to get sram_handle from session, rc:%s\n",
170 strerror(-rc));
171 return rc;
172 }
173 if (sram_handle)
174 rc = tf_sram_mgr_unbind(sram_handle);
175
176 TFP_DRV_LOG(INFO,
177 "SRAM Table - deinitialized\n");
178 return rc;
179 }
180
181 int
tf_tbl_sram_alloc(struct tf * tfp,struct tf_tbl_alloc_parms * parms)182 tf_tbl_sram_alloc(struct tf *tfp,
183 struct tf_tbl_alloc_parms *parms)
184 {
185 int rc;
186 uint16_t idx;
187 struct tf_session *tfs;
188 struct tf_dev_info *dev;
189 struct tf_tbl_sram_get_info_parms iparms = { 0 };
190 struct tf_sram_mgr_alloc_parms aparms = { 0 };
191 struct tbl_rm_db *tbl_db;
192 void *tbl_db_ptr = NULL;
193 void *sram_handle = NULL;
194
195 TF_CHECK_PARMS2(tfp, parms);
196
197 /* Retrieve the session information */
198 rc = tf_session_get(tfp, &tfs, &dev);
199 if (rc)
200 return rc;
201
202 rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TABLE, &tbl_db_ptr);
203 if (rc) {
204 TFP_DRV_LOG(ERR,
205 "Failed to get tbl_db from session, rc:%s\n",
206 strerror(-rc));
207 return rc;
208 }
209
210 tbl_db = (struct tbl_rm_db *)tbl_db_ptr;
211
212 rc = tf_session_get_sram_db(tfp, &sram_handle);
213 if (rc) {
214 TFP_DRV_LOG(ERR,
215 "Failed to get sram_handle from session, rc:%s\n",
216 strerror(-rc));
217 return rc;
218 }
219
220 iparms.rm_db = tbl_db->tbl_db[parms->dir];
221 iparms.dir = parms->dir;
222 iparms.tbl_type = parms->type;
223
224 rc = tf_tbl_sram_get_info(&iparms);
225
226 if (rc) {
227 TFP_DRV_LOG(ERR,
228 "%s: Failed to get SRAM info %s\n",
229 tf_dir_2_str(parms->dir),
230 tf_tbl_type_2_str(parms->type));
231 return rc;
232 }
233
234 aparms.dir = parms->dir;
235 aparms.bank_id = iparms.bank_id;
236 aparms.slice_size = iparms.slice_size;
237 aparms.sram_offset = &idx;
238 aparms.tbl_type = parms->type;
239 aparms.rm_db = tbl_db->tbl_db[parms->dir];
240
241 rc = tf_sram_mgr_alloc(sram_handle, &aparms);
242 if (rc) {
243 TFP_DRV_LOG(ERR,
244 "%s: Failed to allocate SRAM table:%s\n",
245 tf_dir_2_str(parms->dir),
246 tf_tbl_type_2_str(parms->type));
247 return rc;
248 }
249 *parms->idx = idx;
250
251 #if (DBG_SRAM == 1)
252 {
253 struct tf_sram_mgr_dump_parms dparms;
254
255 dparms.dir = parms->dir;
256 dparms.bank_id = iparms.bank_id;
257 dparms.slice_size = iparms.slice_size;
258
259 rc = tf_sram_mgr_dump(sram_handle, &dparms);
260 }
261 #endif
262
263 return rc;
264 }
265
266 int
tf_tbl_sram_free(struct tf * tfp __rte_unused,struct tf_tbl_free_parms * parms)267 tf_tbl_sram_free(struct tf *tfp __rte_unused,
268 struct tf_tbl_free_parms *parms)
269 {
270 int rc;
271 struct tf_session *tfs;
272 struct tf_dev_info *dev;
273 struct tbl_rm_db *tbl_db;
274 void *tbl_db_ptr = NULL;
275 struct tf_tbl_sram_get_info_parms iparms = { 0 };
276 struct tf_sram_mgr_free_parms fparms = { 0 };
277 struct tf_sram_mgr_is_allocated_parms aparms = { 0 };
278 bool allocated = false;
279 void *sram_handle = NULL;
280
281 TF_CHECK_PARMS2(tfp, parms);
282
283 /* Retrieve the session information */
284 rc = tf_session_get(tfp, &tfs, &dev);
285 if (rc)
286 return rc;
287
288 rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TABLE, &tbl_db_ptr);
289 if (rc) {
290 TFP_DRV_LOG(ERR,
291 "Failed to get em_ext_db from session, rc:%s\n",
292 strerror(-rc));
293 return rc;
294 }
295 tbl_db = (struct tbl_rm_db *)tbl_db_ptr;
296
297 rc = tf_session_get_sram_db(tfp, &sram_handle);
298 if (rc) {
299 TFP_DRV_LOG(ERR,
300 "Failed to get sram_handle from session, rc:%s\n",
301 strerror(-rc));
302 return rc;
303 }
304
305 iparms.rm_db = tbl_db->tbl_db[parms->dir];
306 iparms.dir = parms->dir;
307 iparms.tbl_type = parms->type;
308
309 rc = tf_tbl_sram_get_info(&iparms);
310 if (rc) {
311 TFP_DRV_LOG(ERR,
312 "%s: Failed to get table info:%s\n",
313 tf_dir_2_str(parms->dir),
314 tf_tbl_type_2_str(parms->type));
315 return rc;
316 }
317
318 #if (DBG_SRAM == 1)
319 {
320 struct tf_sram_mgr_dump_parms dparms;
321
322 printf("%s: %s: %s\n", tf_dir_2_str(parms->dir),
323 tf_sram_slice_2_str(iparms.slice_size),
324 tf_sram_bank_2_str(iparms.bank_id));
325
326 dparms.dir = parms->dir;
327 dparms.bank_id = iparms.bank_id;
328 dparms.slice_size = iparms.slice_size;
329
330 rc = tf_sram_mgr_dump(sram_handle, &dparms);
331 }
332 #endif
333
334 aparms.sram_offset = parms->idx;
335 aparms.slice_size = iparms.slice_size;
336 aparms.bank_id = iparms.bank_id;
337 aparms.dir = parms->dir;
338 aparms.is_allocated = &allocated;
339
340 rc = tf_sram_mgr_is_allocated(sram_handle, &aparms);
341 if (rc || !allocated) {
342 TFP_DRV_LOG(ERR,
343 "%s: Free of invalid entry:%s idx(%d):(%s)\n",
344 tf_dir_2_str(parms->dir),
345 tf_tbl_type_2_str(parms->type),
346 parms->idx,
347 strerror(-rc));
348 rc = -ENOMEM;
349 return rc;
350 }
351
352 fparms.rm_db = tbl_db->tbl_db[parms->dir];
353 fparms.tbl_type = parms->type;
354 fparms.sram_offset = parms->idx;
355 fparms.slice_size = iparms.slice_size;
356 fparms.bank_id = iparms.bank_id;
357 fparms.dir = parms->dir;
358 #if (STATS_CLEAR_ON_READ_SUPPORT == 0)
359 fparms.tfp = tfp;
360 #endif
361 rc = tf_sram_mgr_free(sram_handle, &fparms);
362 if (rc) {
363 TFP_DRV_LOG(ERR,
364 "%s: Failed to free entry:%s idx(%d)\n",
365 tf_dir_2_str(parms->dir),
366 tf_tbl_type_2_str(parms->type),
367 parms->idx);
368 return rc;
369 }
370
371 #if (DBG_SRAM == 1)
372 {
373 struct tf_sram_mgr_dump_parms dparms;
374
375 printf("%s: %s: %s\n", tf_dir_2_str(parms->dir),
376 tf_sram_slice_2_str(iparms.slice_size),
377 tf_sram_bank_2_str(iparms.bank_id));
378
379 dparms.dir = parms->dir;
380 dparms.bank_id = iparms.bank_id;
381 dparms.slice_size = iparms.slice_size;
382
383 rc = tf_sram_mgr_dump(sram_handle, &dparms);
384 }
385 #endif
386 return rc;
387 }
388
389 int
tf_tbl_sram_set(struct tf * tfp,struct tf_tbl_set_parms * parms)390 tf_tbl_sram_set(struct tf *tfp,
391 struct tf_tbl_set_parms *parms)
392 {
393 int rc;
394 bool allocated = 0;
395 int rallocated = 0;
396 uint16_t hcapi_type;
397 struct tf_rm_get_hcapi_parms hparms = { 0 };
398 struct tf_session *tfs;
399 struct tf_dev_info *dev;
400 struct tbl_rm_db *tbl_db;
401 void *tbl_db_ptr = NULL;
402 struct tf_tbl_sram_get_info_parms iparms = { 0 };
403 struct tf_sram_mgr_is_allocated_parms aparms = { 0 };
404 struct tf_rm_is_allocated_parms raparms = { 0 };
405 void *sram_handle = NULL;
406 uint16_t base = 0, shift = 0;
407
408 TF_CHECK_PARMS3(tfp, parms, parms->data);
409
410 /* Retrieve the session information */
411 rc = tf_session_get(tfp, &tfs, &dev);
412 if (rc)
413 return rc;
414
415 rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TABLE, &tbl_db_ptr);
416 if (rc) {
417 TFP_DRV_LOG(ERR,
418 "Failed to get em_ext_db from session, rc:%s\n",
419 strerror(-rc));
420 return rc;
421 }
422 tbl_db = (struct tbl_rm_db *)tbl_db_ptr;
423
424 rc = tf_session_get_sram_db(tfp, &sram_handle);
425 if (rc) {
426 TFP_DRV_LOG(ERR,
427 "Failed to get sram_handle from session, rc:%s\n",
428 strerror(-rc));
429 return rc;
430 }
431
432 iparms.rm_db = tbl_db->tbl_db[parms->dir];
433 iparms.dir = parms->dir;
434 iparms.tbl_type = parms->type;
435
436 rc = tf_tbl_sram_get_info(&iparms);
437 if (rc) {
438 TFP_DRV_LOG(ERR,
439 "%s: Failed to get table info:%s\n",
440 tf_dir_2_str(parms->dir),
441 tf_tbl_type_2_str(parms->type));
442 return rc;
443 }
444
445 if (tf_session_is_shared_session(tfs)) {
446 /* Only get table info if required for the device */
447 if (dev->ops->tf_dev_get_tbl_info) {
448 rc = dev->ops->tf_dev_get_tbl_info(tfp,
449 tbl_db->tbl_db[parms->dir],
450 parms->type,
451 &base,
452 &shift);
453 if (rc) {
454 TFP_DRV_LOG(ERR,
455 "%s: Failed to get table info:%d\n",
456 tf_dir_2_str(parms->dir),
457 parms->type);
458 return rc;
459 }
460 }
461 TF_TBL_PTR_TO_RM(&raparms.index, parms->idx, base, shift);
462
463 raparms.rm_db = tbl_db->tbl_db[parms->dir];
464 raparms.subtype = parms->type;
465 raparms.allocated = &rallocated;
466 rc = tf_rm_is_allocated(&raparms);
467 if (rc)
468 return rc;
469
470 if (rallocated != TF_RM_ALLOCATED_ENTRY_IN_USE) {
471 TFP_DRV_LOG(ERR,
472 "%s, Invalid or not allocated index, type:%s, idx:%d\n",
473 tf_dir_2_str(parms->dir),
474 tf_tbl_type_2_str(parms->type),
475 parms->idx);
476 return -EINVAL;
477 }
478 } else {
479 aparms.sram_offset = parms->idx;
480 aparms.slice_size = iparms.slice_size;
481 aparms.bank_id = iparms.bank_id;
482 aparms.dir = parms->dir;
483 aparms.is_allocated = &allocated;
484 rc = tf_sram_mgr_is_allocated(sram_handle, &aparms);
485 if (rc || !allocated) {
486 TFP_DRV_LOG(ERR,
487 "%s: Entry not allocated:%s idx(%d):(%s)\n",
488 tf_dir_2_str(parms->dir),
489 tf_tbl_type_2_str(parms->type),
490 parms->idx,
491 strerror(-rc));
492 rc = -ENOMEM;
493 return rc;
494 }
495 }
496 /* Set the entry */
497 hparms.rm_db = tbl_db->tbl_db[parms->dir];
498 hparms.subtype = parms->type;
499 hparms.hcapi_type = &hcapi_type;
500 rc = tf_rm_get_hcapi_type(&hparms);
501 if (rc) {
502 TFP_DRV_LOG(ERR,
503 "%s, Failed type lookup, type:%s, rc:%s\n",
504 tf_dir_2_str(parms->dir),
505 tf_tbl_type_2_str(parms->type),
506 strerror(-rc));
507 return rc;
508 }
509
510 rc = tf_msg_set_tbl_entry(tfp,
511 parms->dir,
512 hcapi_type,
513 parms->data_sz_in_bytes,
514 parms->data,
515 parms->idx);
516 if (rc) {
517 TFP_DRV_LOG(ERR,
518 "%s, Set failed, type:%s, rc:%s\n",
519 tf_dir_2_str(parms->dir),
520 tf_tbl_type_2_str(parms->type),
521 strerror(-rc));
522 return rc;
523 }
524 return rc;
525 }
526
527 int
tf_tbl_sram_get(struct tf * tfp,struct tf_tbl_get_parms * parms)528 tf_tbl_sram_get(struct tf *tfp,
529 struct tf_tbl_get_parms *parms)
530 {
531 int rc;
532 uint16_t hcapi_type;
533 bool allocated = 0;
534 struct tf_rm_get_hcapi_parms hparms = { 0 };
535 struct tf_session *tfs;
536 struct tf_dev_info *dev;
537 struct tbl_rm_db *tbl_db;
538 void *tbl_db_ptr = NULL;
539 struct tf_tbl_sram_get_info_parms iparms = { 0 };
540 struct tf_sram_mgr_is_allocated_parms aparms = { 0 };
541 void *sram_handle = NULL;
542 bool clear_on_read = false;
543
544 TF_CHECK_PARMS3(tfp, parms, parms->data);
545
546 /* Retrieve the session information */
547 rc = tf_session_get(tfp, &tfs, &dev);
548 if (rc)
549 return rc;
550
551 rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TABLE, &tbl_db_ptr);
552 if (rc) {
553 TFP_DRV_LOG(ERR,
554 "Failed to get em_ext_db from session, rc:%s\n",
555 strerror(-rc));
556 return rc;
557 }
558 tbl_db = (struct tbl_rm_db *)tbl_db_ptr;
559
560 rc = tf_session_get_sram_db(tfp, &sram_handle);
561 if (rc) {
562 TFP_DRV_LOG(ERR,
563 "Failed to get sram_handle from session, rc:%s\n",
564 strerror(-rc));
565 return rc;
566 }
567
568 iparms.rm_db = tbl_db->tbl_db[parms->dir];
569 iparms.dir = parms->dir;
570 iparms.tbl_type = parms->type;
571
572 rc = tf_tbl_sram_get_info(&iparms);
573 if (rc) {
574 TFP_DRV_LOG(ERR,
575 "%s: Failed to get table info:%s\n",
576 tf_dir_2_str(parms->dir),
577 tf_tbl_type_2_str(parms->type));
578 return rc;
579 }
580
581 aparms.sram_offset = parms->idx;
582 aparms.slice_size = iparms.slice_size;
583 aparms.bank_id = iparms.bank_id;
584 aparms.dir = parms->dir;
585 aparms.is_allocated = &allocated;
586
587 rc = tf_sram_mgr_is_allocated(sram_handle, &aparms);
588 if (rc || !allocated) {
589 TFP_DRV_LOG(ERR,
590 "%s: Entry not allocated:%s idx(%d):(%s)\n",
591 tf_dir_2_str(parms->dir),
592 tf_tbl_type_2_str(parms->type),
593 parms->idx,
594 strerror(-rc));
595 rc = -ENOMEM;
596 return rc;
597 }
598
599 /* Get the entry */
600 hparms.rm_db = tbl_db->tbl_db[parms->dir];
601 hparms.subtype = parms->type;
602 hparms.hcapi_type = &hcapi_type;
603 rc = tf_rm_get_hcapi_type(&hparms);
604 if (rc) {
605 TFP_DRV_LOG(ERR,
606 "%s, Failed type lookup, type:%s, rc:%s\n",
607 tf_dir_2_str(parms->dir),
608 tf_tbl_type_2_str(parms->type),
609 strerror(-rc));
610 return rc;
611 }
612 if (parms->type == TF_TBL_TYPE_ACT_STATS_64)
613 clear_on_read = true;
614
615 /* Get the entry */
616 rc = tf_msg_get_tbl_entry(tfp,
617 parms->dir,
618 hcapi_type,
619 parms->data_sz_in_bytes,
620 parms->data,
621 parms->idx,
622 clear_on_read);
623 if (rc) {
624 TFP_DRV_LOG(ERR,
625 "%s, Get failed, type:%s, rc:%s\n",
626 tf_dir_2_str(parms->dir),
627 tf_tbl_type_2_str(parms->type),
628 strerror(-rc));
629 return rc;
630 }
631 return rc;
632 }
633
634 int
tf_tbl_sram_bulk_get(struct tf * tfp,struct tf_tbl_get_bulk_parms * parms)635 tf_tbl_sram_bulk_get(struct tf *tfp,
636 struct tf_tbl_get_bulk_parms *parms)
637 {
638 int rc;
639 uint16_t hcapi_type;
640 struct tf_rm_get_hcapi_parms hparms = { 0 };
641 struct tf_tbl_sram_get_info_parms iparms = { 0 };
642 struct tf_session *tfs;
643 struct tf_dev_info *dev;
644 struct tbl_rm_db *tbl_db;
645 void *tbl_db_ptr = NULL;
646 uint16_t idx;
647 struct tf_sram_mgr_is_allocated_parms aparms = { 0 };
648 bool allocated = false;
649 void *sram_handle = NULL;
650 bool clear_on_read = false;
651
652 TF_CHECK_PARMS2(tfp, parms);
653
654 /* Retrieve the session information */
655 rc = tf_session_get(tfp, &tfs, &dev);
656 if (rc)
657 return rc;
658
659 rc = tf_session_get_db(tfp, TF_MODULE_TYPE_TABLE, &tbl_db_ptr);
660 if (rc) {
661 TFP_DRV_LOG(ERR,
662 "Failed to get em_ext_db from session, rc:%s\n",
663 strerror(-rc));
664 return rc;
665 }
666 tbl_db = (struct tbl_rm_db *)tbl_db_ptr;
667
668 rc = tf_session_get_sram_db(tfp, &sram_handle);
669 if (rc) {
670 TFP_DRV_LOG(ERR,
671 "Failed to get sram_handle from session, rc:%s\n",
672 strerror(-rc));
673 return rc;
674 }
675
676 iparms.rm_db = tbl_db->tbl_db[parms->dir];
677 iparms.dir = parms->dir;
678 iparms.tbl_type = parms->type;
679
680 rc = tf_tbl_sram_get_info(&iparms);
681 if (rc) {
682 TFP_DRV_LOG(ERR,
683 "%s: Failed to get table info:%s\n",
684 tf_dir_2_str(parms->dir),
685 tf_tbl_type_2_str(parms->type));
686 return rc;
687 }
688
689 /* Validate the start offset and the end offset is allocated
690 * This API is only used for statistics. 8 Byte entry allocation
691 * is used to verify
692 */
693 aparms.sram_offset = parms->starting_idx;
694 aparms.slice_size = iparms.slice_size;
695 aparms.bank_id = iparms.bank_id;
696 aparms.dir = parms->dir;
697 aparms.is_allocated = &allocated;
698 rc = tf_sram_mgr_is_allocated(sram_handle, &aparms);
699 if (rc || !allocated) {
700 TFP_DRV_LOG(ERR,
701 "%s: Entry not allocated:%s starting_idx(%d):(%s)\n",
702 tf_dir_2_str(parms->dir),
703 tf_tbl_type_2_str(parms->type),
704 parms->starting_idx,
705 strerror(-rc));
706 rc = -ENOMEM;
707 return rc;
708 }
709 idx = parms->starting_idx + parms->num_entries - 1;
710 aparms.sram_offset = idx;
711 rc = tf_sram_mgr_is_allocated(sram_handle, &aparms);
712 if (rc || !allocated) {
713 TFP_DRV_LOG(ERR,
714 "%s: Entry not allocated:%s last_idx(%d):(%s)\n",
715 tf_dir_2_str(parms->dir),
716 tf_tbl_type_2_str(parms->type),
717 idx,
718 strerror(-rc));
719 rc = -ENOMEM;
720 return rc;
721 }
722
723 hparms.rm_db = tbl_db->tbl_db[parms->dir];
724 hparms.subtype = parms->type;
725 hparms.hcapi_type = &hcapi_type;
726 rc = tf_rm_get_hcapi_type(&hparms);
727 if (rc) {
728 TFP_DRV_LOG(ERR,
729 "%s, Failed type lookup, type:%s, rc:%s\n",
730 tf_dir_2_str(parms->dir),
731 tf_tbl_type_2_str(parms->type),
732 strerror(-rc));
733 return rc;
734 }
735
736 if (parms->type == TF_TBL_TYPE_ACT_STATS_64)
737 clear_on_read = true;
738
739 /* Get the entries */
740 rc = tf_msg_bulk_get_tbl_entry(tfp,
741 parms->dir,
742 hcapi_type,
743 parms->starting_idx,
744 parms->num_entries,
745 parms->entry_sz_in_bytes,
746 parms->physical_mem_addr,
747 clear_on_read);
748 if (rc) {
749 TFP_DRV_LOG(ERR,
750 "%s, Bulk get failed, type:%s, rc:%s\n",
751 tf_dir_2_str(parms->dir),
752 tf_tbl_type_2_str(parms->type),
753 strerror(-rc));
754 }
755 return rc;
756 }
757