1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2019-2021 Broadcom
10 #include "tf_session.h"
14 #include "tf_global_cfg.h"
20 #include "tf_common.h"
21 #include "tf_ext_flow_handle.h"
24 tf_open_session(struct tf *tfp,
25 struct tf_open_session_parms *parms)
28 unsigned int domain, bus, slot, device;
29 struct tf_session_open_session_parms oparms;
31 TF_CHECK_PARMS2(tfp, parms);
33 /* Filter out any non-supported device types on the Core
34 * side. It is assumed that the Firmware will be supported if
35 * firmware open session succeeds.
37 if (parms->device_type != TF_DEVICE_TYPE_WH &&
38 parms->device_type != TF_DEVICE_TYPE_THOR &&
39 parms->device_type != TF_DEVICE_TYPE_SR) {
41 "Unsupported device type %d\n",
46 /* Verify control channel and build the beginning of session_id */
47 rc = sscanf(parms->ctrl_chan_name,
54 /* PCI Domain not provided (optional in DPDK), thus we
55 * force domain to 0 and recheck.
59 /* Check parsing of bus/slot/device */
60 rc = sscanf(parms->ctrl_chan_name,
67 "Failed to scan device ctrl_chan_name\n");
72 parms->session_id.internal.domain = domain;
73 parms->session_id.internal.bus = bus;
74 parms->session_id.internal.device = device;
75 oparms.open_cfg = parms;
77 /* Session vs session client is decided in
78 * tf_session_open_session()
80 rc = tf_session_open_session(tfp, &oparms);
81 /* Logging handled by tf_session_open_session */
86 "domain:%d, bus:%d, device:%u\n",
87 parms->session_id.internal.domain,
88 parms->session_id.internal.bus,
89 parms->session_id.internal.device);
95 tf_attach_session(struct tf *tfp,
96 struct tf_attach_session_parms *parms)
99 unsigned int domain, bus, slot, device;
100 struct tf_session_attach_session_parms aparms;
102 TF_CHECK_PARMS2(tfp, parms);
104 /* Verify control channel */
105 rc = sscanf(parms->ctrl_chan_name,
113 "Failed to scan device ctrl_chan_name\n");
117 /* Verify 'attach' channel */
118 rc = sscanf(parms->attach_chan_name,
126 "Failed to scan device attach_chan_name\n");
130 /* Prepare return value of session_id, using ctrl_chan_name
131 * device values as it becomes the session id.
133 parms->session_id.internal.domain = domain;
134 parms->session_id.internal.bus = bus;
135 parms->session_id.internal.device = device;
136 aparms.attach_cfg = parms;
137 rc = tf_session_attach_session(tfp,
139 /* Logging handled by dev_bind */
144 "Attached to session, session_id:%d\n",
145 parms->session_id.id);
148 "domain:%d, bus:%d, device:%d, fw_session_id:%d\n",
149 parms->session_id.internal.domain,
150 parms->session_id.internal.bus,
151 parms->session_id.internal.device,
152 parms->session_id.internal.fw_session_id);
158 tf_close_session(struct tf *tfp)
161 struct tf_session_close_session_parms cparms = { 0 };
162 union tf_session_id session_id = { 0 };
165 TF_CHECK_PARMS1(tfp);
167 cparms.ref_count = &ref_count;
168 cparms.session_id = &session_id;
169 /* Session vs session client is decided in
170 * tf_session_close_session()
172 rc = tf_session_close_session(tfp,
174 /* Logging handled by tf_session_close_session */
179 "domain:%d, bus:%d, device:%d\n",
180 cparms.session_id->internal.domain,
181 cparms.session_id->internal.bus,
182 cparms.session_id->internal.device);
187 /** insert EM hash entry API
193 int tf_insert_em_entry(struct tf *tfp,
194 struct tf_insert_em_entry_parms *parms)
196 struct tf_session *tfs;
197 struct tf_dev_info *dev;
200 TF_CHECK_PARMS2(tfp, parms);
202 /* Retrieve the session information */
203 rc = tf_session_get_session(tfp, &tfs);
206 "%s: Failed to lookup session, rc:%s\n",
207 tf_dir_2_str(parms->dir),
212 /* Retrieve the device information */
213 rc = tf_session_get_device(tfs, &dev);
216 "%s: Failed to lookup device, rc:%s\n",
217 tf_dir_2_str(parms->dir),
222 if (parms->mem == TF_MEM_EXTERNAL &&
223 dev->ops->tf_dev_insert_ext_em_entry != NULL)
224 rc = dev->ops->tf_dev_insert_ext_em_entry(tfp, parms);
225 else if (parms->mem == TF_MEM_INTERNAL &&
226 dev->ops->tf_dev_insert_int_em_entry != NULL)
227 rc = dev->ops->tf_dev_insert_int_em_entry(tfp, parms);
233 "%s: EM insert failed, rc:%s\n",
234 tf_dir_2_str(parms->dir),
242 /** Delete EM hash entry API
248 int tf_delete_em_entry(struct tf *tfp,
249 struct tf_delete_em_entry_parms *parms)
251 struct tf_session *tfs;
252 struct tf_dev_info *dev;
254 unsigned int flag = 0;
256 TF_CHECK_PARMS2(tfp, parms);
258 /* Retrieve the session information */
259 rc = tf_session_get_session(tfp, &tfs);
262 "%s: Failed to lookup session, rc:%s\n",
263 tf_dir_2_str(parms->dir),
268 /* Retrieve the device information */
269 rc = tf_session_get_device(tfs, &dev);
272 "%s: Failed to lookup device, rc:%s\n",
273 tf_dir_2_str(parms->dir),
278 TF_GET_FLAG_FROM_FLOW_HANDLE(parms->flow_handle, flag);
279 if ((flag & TF_FLAGS_FLOW_HANDLE_INTERNAL))
280 rc = dev->ops->tf_dev_delete_int_em_entry(tfp, parms);
282 rc = dev->ops->tf_dev_delete_ext_em_entry(tfp, parms);
286 "%s: EM delete failed, rc:%s\n",
287 tf_dir_2_str(parms->dir),
295 /** Get global configuration API
301 int tf_get_global_cfg(struct tf *tfp,
302 struct tf_global_cfg_parms *parms)
305 struct tf_session *tfs;
306 struct tf_dev_info *dev;
308 TF_CHECK_PARMS2(tfp, parms);
310 /* Retrieve the session information */
311 rc = tf_session_get_session(tfp, &tfs);
314 "%s: Failed to lookup session, rc:%s\n",
315 tf_dir_2_str(parms->dir),
320 /* Retrieve the device information */
321 rc = tf_session_get_device(tfs, &dev);
324 "%s: Failed to lookup device, rc:%s\n",
325 tf_dir_2_str(parms->dir),
330 if (parms->config == NULL ||
331 parms->config_sz_in_bytes == 0) {
332 TFP_DRV_LOG(ERR, "Invalid Argument(s)\n");
336 if (dev->ops->tf_dev_get_global_cfg == NULL) {
339 "%s: Operation not supported, rc:%s\n",
340 tf_dir_2_str(parms->dir),
345 rc = dev->ops->tf_dev_get_global_cfg(tfp, parms);
348 "%s: Global Cfg get failed, rc:%s\n",
349 tf_dir_2_str(parms->dir),
357 /** Set global configuration API
363 int tf_set_global_cfg(struct tf *tfp,
364 struct tf_global_cfg_parms *parms)
367 struct tf_session *tfs;
368 struct tf_dev_info *dev;
370 TF_CHECK_PARMS2(tfp, parms);
372 /* Retrieve the session information */
373 rc = tf_session_get_session(tfp, &tfs);
376 "%s: Failed to lookup session, rc:%s\n",
377 tf_dir_2_str(parms->dir),
382 /* Retrieve the device information */
383 rc = tf_session_get_device(tfs, &dev);
386 "%s: Failed to lookup device, rc:%s\n",
387 tf_dir_2_str(parms->dir),
392 if (parms->config == NULL ||
393 parms->config_sz_in_bytes == 0) {
394 TFP_DRV_LOG(ERR, "Invalid Argument(s)\n");
398 if (dev->ops->tf_dev_set_global_cfg == NULL) {
401 "%s: Operation not supported, rc:%s\n",
402 tf_dir_2_str(parms->dir),
407 rc = dev->ops->tf_dev_set_global_cfg(tfp, parms);
410 "%s: Global Cfg set failed, rc:%s\n",
411 tf_dir_2_str(parms->dir),
420 tf_alloc_identifier(struct tf *tfp,
421 struct tf_alloc_identifier_parms *parms)
424 struct tf_session *tfs;
425 struct tf_dev_info *dev;
426 struct tf_ident_alloc_parms aparms;
429 TF_CHECK_PARMS2(tfp, parms);
431 /* Can't do static initialization due to UT enum check */
432 memset(&aparms, 0, sizeof(struct tf_ident_alloc_parms));
434 /* Retrieve the session information */
435 rc = tf_session_get_session(tfp, &tfs);
438 "%s: Failed to lookup session, rc:%s\n",
439 tf_dir_2_str(parms->dir),
444 /* Retrieve the device information */
445 rc = tf_session_get_device(tfs, &dev);
448 "%s: Failed to lookup device, rc:%s\n",
449 tf_dir_2_str(parms->dir),
454 if (dev->ops->tf_dev_alloc_ident == NULL) {
457 "%s: Operation not supported, rc:%s\n",
458 tf_dir_2_str(parms->dir),
463 aparms.dir = parms->dir;
464 aparms.type = parms->ident_type;
466 rc = dev->ops->tf_dev_alloc_ident(tfp, &aparms);
469 "%s: Identifier allocation failed, rc:%s\n",
470 tf_dir_2_str(parms->dir),
481 tf_free_identifier(struct tf *tfp,
482 struct tf_free_identifier_parms *parms)
485 struct tf_session *tfs;
486 struct tf_dev_info *dev;
487 struct tf_ident_free_parms fparms;
489 TF_CHECK_PARMS2(tfp, parms);
491 /* Can't do static initialization due to UT enum check */
492 memset(&fparms, 0, sizeof(struct tf_ident_free_parms));
494 /* Retrieve the session information */
495 rc = tf_session_get_session(tfp, &tfs);
498 "%s: Failed to lookup session, rc:%s\n",
499 tf_dir_2_str(parms->dir),
504 /* Retrieve the device information */
505 rc = tf_session_get_device(tfs, &dev);
508 "%s: Failed to lookup device, rc:%s\n",
509 tf_dir_2_str(parms->dir),
514 if (dev->ops->tf_dev_free_ident == NULL) {
517 "%s: Operation not supported, rc:%s\n",
518 tf_dir_2_str(parms->dir),
523 fparms.dir = parms->dir;
524 fparms.type = parms->ident_type;
525 fparms.id = parms->id;
526 fparms.ref_cnt = &parms->ref_cnt;
527 rc = dev->ops->tf_dev_free_ident(tfp, &fparms);
530 "%s: Identifier free failed, rc:%s\n",
531 tf_dir_2_str(parms->dir),
540 tf_search_identifier(struct tf *tfp,
541 struct tf_search_identifier_parms *parms)
544 struct tf_session *tfs;
545 struct tf_dev_info *dev;
546 struct tf_ident_search_parms sparms;
548 TF_CHECK_PARMS2(tfp, parms);
550 /* Can't do static initialization due to UT enum check */
551 memset(&sparms, 0, sizeof(struct tf_ident_search_parms));
553 /* Retrieve the session information */
554 rc = tf_session_get_session(tfp, &tfs);
557 "%s: Failed to lookup session, rc:%s\n",
558 tf_dir_2_str(parms->dir),
563 /* Retrieve the device information */
564 rc = tf_session_get_device(tfs, &dev);
567 "%s: Failed to lookup device, rc:%s\n",
568 tf_dir_2_str(parms->dir),
573 if (dev->ops->tf_dev_search_ident == NULL) {
576 "%s: Operation not supported, rc:%s\n",
577 tf_dir_2_str(parms->dir),
582 sparms.dir = parms->dir;
583 sparms.type = parms->ident_type;
584 sparms.search_id = parms->search_id;
585 sparms.hit = &parms->hit;
586 sparms.ref_cnt = &parms->ref_cnt;
587 rc = dev->ops->tf_dev_search_ident(tfp, &sparms);
590 "%s: Identifier search failed, rc:%s\n",
591 tf_dir_2_str(parms->dir),
600 tf_search_tcam_entry(struct tf *tfp,
601 struct tf_search_tcam_entry_parms *parms)
604 struct tf_session *tfs;
605 struct tf_dev_info *dev;
606 struct tf_tcam_alloc_search_parms sparms;
608 TF_CHECK_PARMS2(tfp, parms);
610 memset(&sparms, 0, sizeof(struct tf_tcam_alloc_search_parms));
612 /* Retrieve the session information */
613 rc = tf_session_get_session(tfp, &tfs);
616 "%s: Failed to lookup session, rc:%s\n",
617 tf_dir_2_str(parms->dir),
622 /* Retrieve the device information */
623 rc = tf_session_get_device(tfs, &dev);
626 "%s: Failed to lookup device, rc:%s\n",
627 tf_dir_2_str(parms->dir),
632 if (dev->ops->tf_dev_alloc_search_tcam == NULL) {
635 "%s: Operation not supported, rc:%s\n",
636 tf_dir_2_str(parms->dir),
641 sparms.dir = parms->dir;
642 sparms.type = parms->tcam_tbl_type;
643 sparms.key = parms->key;
644 sparms.key_size = TF_BITS2BYTES_WORD_ALIGN(parms->key_sz_in_bits);
645 sparms.mask = parms->mask;
646 sparms.priority = parms->priority;
647 sparms.alloc = parms->alloc;
649 /* Result is an in/out and so no need to copy during outputs */
650 sparms.result = parms->result;
652 TF_BITS2BYTES_WORD_ALIGN(parms->result_sz_in_bits);
654 rc = dev->ops->tf_dev_alloc_search_tcam(tfp, &sparms);
657 "%s: TCAM allocation failed, rc:%s\n",
658 tf_dir_2_str(parms->dir),
663 /* Copy the outputs */
664 parms->hit = sparms.hit;
665 parms->search_status = sparms.search_status;
666 parms->ref_cnt = sparms.ref_cnt;
667 parms->idx = sparms.idx;
673 tf_alloc_tcam_entry(struct tf *tfp,
674 struct tf_alloc_tcam_entry_parms *parms)
677 struct tf_session *tfs;
678 struct tf_dev_info *dev;
679 struct tf_tcam_alloc_parms aparms;
681 TF_CHECK_PARMS2(tfp, parms);
683 memset(&aparms, 0, sizeof(struct tf_tcam_alloc_parms));
685 /* Retrieve the session information */
686 rc = tf_session_get_session(tfp, &tfs);
689 "%s: Failed to lookup session, rc:%s\n",
690 tf_dir_2_str(parms->dir),
695 /* Retrieve the device information */
696 rc = tf_session_get_device(tfs, &dev);
699 "%s: Failed to lookup device, rc:%s\n",
700 tf_dir_2_str(parms->dir),
705 if (dev->ops->tf_dev_alloc_tcam == NULL) {
708 "%s: Operation not supported, rc:%s\n",
709 tf_dir_2_str(parms->dir),
714 aparms.dir = parms->dir;
715 aparms.type = parms->tcam_tbl_type;
716 aparms.key_size = TF_BITS2BYTES_WORD_ALIGN(parms->key_sz_in_bits);
717 aparms.priority = parms->priority;
718 rc = dev->ops->tf_dev_alloc_tcam(tfp, &aparms);
721 "%s: TCAM allocation failed, rc:%s\n",
722 tf_dir_2_str(parms->dir),
727 parms->idx = aparms.idx;
733 tf_set_tcam_entry(struct tf *tfp,
734 struct tf_set_tcam_entry_parms *parms)
737 struct tf_session *tfs;
738 struct tf_dev_info *dev;
739 struct tf_tcam_set_parms sparms;
741 TF_CHECK_PARMS2(tfp, parms);
743 memset(&sparms, 0, sizeof(struct tf_tcam_set_parms));
746 /* Retrieve the session information */
747 rc = tf_session_get_session(tfp, &tfs);
750 "%s: Failed to lookup session, rc:%s\n",
751 tf_dir_2_str(parms->dir),
756 /* Retrieve the device information */
757 rc = tf_session_get_device(tfs, &dev);
760 "%s: Failed to lookup device, rc:%s\n",
761 tf_dir_2_str(parms->dir),
766 if (dev->ops->tf_dev_set_tcam == NULL ||
767 dev->ops->tf_dev_word_align == NULL) {
770 "%s: Operation not supported, rc:%s\n",
771 tf_dir_2_str(parms->dir),
776 sparms.dir = parms->dir;
777 sparms.type = parms->tcam_tbl_type;
778 sparms.idx = parms->idx;
779 sparms.key = parms->key;
780 sparms.mask = parms->mask;
781 sparms.key_size = dev->ops->tf_dev_word_align(parms->key_sz_in_bits);
782 sparms.result = parms->result;
783 sparms.result_size = TF_BITS2BYTES_WORD_ALIGN(parms->result_sz_in_bits);
785 rc = dev->ops->tf_dev_set_tcam(tfp, &sparms);
788 "%s: TCAM set failed, rc:%s\n",
789 tf_dir_2_str(parms->dir),
798 tf_get_tcam_entry(struct tf *tfp __rte_unused,
799 struct tf_get_tcam_entry_parms *parms)
802 struct tf_session *tfs;
803 struct tf_dev_info *dev;
804 struct tf_tcam_get_parms gparms;
806 TF_CHECK_PARMS2(tfp, parms);
808 memset(&gparms, 0, sizeof(struct tf_tcam_get_parms));
811 /* Retrieve the session information */
812 rc = tf_session_get_session(tfp, &tfs);
815 "%s: Failed to lookup session, rc:%s\n",
816 tf_dir_2_str(parms->dir),
821 /* Retrieve the device information */
822 rc = tf_session_get_device(tfs, &dev);
825 "%s: Failed to lookup device, rc:%s\n",
826 tf_dir_2_str(parms->dir),
831 if (dev->ops->tf_dev_get_tcam == NULL) {
834 "%s: Operation not supported, rc:%s\n",
835 tf_dir_2_str(parms->dir),
840 gparms.dir = parms->dir;
841 gparms.type = parms->tcam_tbl_type;
842 gparms.idx = parms->idx;
843 gparms.key = parms->key;
844 gparms.key_size = dev->ops->tf_dev_word_align(parms->key_sz_in_bits);
845 gparms.mask = parms->mask;
846 gparms.result = parms->result;
847 gparms.result_size = TF_BITS2BYTES_WORD_ALIGN(parms->result_sz_in_bits);
849 rc = dev->ops->tf_dev_get_tcam(tfp, &gparms);
852 "%s: TCAM get failed, rc:%s\n",
853 tf_dir_2_str(parms->dir),
857 parms->key_sz_in_bits = gparms.key_size * 8;
858 parms->result_sz_in_bits = gparms.result_size * 8;
864 tf_free_tcam_entry(struct tf *tfp,
865 struct tf_free_tcam_entry_parms *parms)
868 struct tf_session *tfs;
869 struct tf_dev_info *dev;
870 struct tf_tcam_free_parms fparms;
872 TF_CHECK_PARMS2(tfp, parms);
874 memset(&fparms, 0, sizeof(struct tf_tcam_free_parms));
876 /* Retrieve the session information */
877 rc = tf_session_get_session(tfp, &tfs);
880 "%s: Failed to lookup session, rc:%s\n",
881 tf_dir_2_str(parms->dir),
886 /* Retrieve the device information */
887 rc = tf_session_get_device(tfs, &dev);
890 "%s: Failed to lookup device, rc:%s\n",
891 tf_dir_2_str(parms->dir),
896 if (dev->ops->tf_dev_free_tcam == NULL) {
899 "%s: Operation not supported, rc:%s\n",
900 tf_dir_2_str(parms->dir),
905 fparms.dir = parms->dir;
906 fparms.type = parms->tcam_tbl_type;
907 fparms.idx = parms->idx;
908 rc = dev->ops->tf_dev_free_tcam(tfp, &fparms);
911 "%s: TCAM free failed, rc:%s\n",
912 tf_dir_2_str(parms->dir),
920 #ifdef TF_TCAM_SHARED
922 tf_move_tcam_shared_entries(struct tf *tfp,
923 struct tf_move_tcam_shared_entries_parms *parms)
926 struct tf_session *tfs;
927 struct tf_dev_info *dev;
929 TF_CHECK_PARMS2(tfp, parms);
931 /* Retrieve the session information */
932 rc = tf_session_get_session(tfp, &tfs);
935 "%s: Failed to lookup session, rc:%s\n",
936 tf_dir_2_str(parms->dir),
941 /* Retrieve the device information */
942 rc = tf_session_get_device(tfs, &dev);
945 "%s: Failed to lookup device, rc:%s\n",
946 tf_dir_2_str(parms->dir),
951 if (dev->ops->tf_dev_move_tcam == NULL) {
954 "%s: Operation not supported, rc:%s\n",
955 tf_dir_2_str(parms->dir),
960 rc = dev->ops->tf_dev_move_tcam(tfp, parms);
963 "%s: TCAM shared entries move failed, rc:%s\n",
964 tf_dir_2_str(parms->dir),
973 tf_clear_tcam_shared_entries(struct tf *tfp,
974 struct tf_clear_tcam_shared_entries_parms *parms)
977 struct tf_session *tfs;
978 struct tf_dev_info *dev;
980 TF_CHECK_PARMS2(tfp, parms);
982 /* Retrieve the session information */
983 rc = tf_session_get_session(tfp, &tfs);
986 "%s: Failed to lookup session, rc:%s\n",
987 tf_dir_2_str(parms->dir),
992 /* Retrieve the device information */
993 rc = tf_session_get_device(tfs, &dev);
996 "%s: Failed to lookup device, rc:%s\n",
997 tf_dir_2_str(parms->dir),
1002 if (dev->ops->tf_dev_clear_tcam == NULL) {
1005 "%s: Operation not supported, rc:%s\n",
1006 tf_dir_2_str(parms->dir),
1011 rc = dev->ops->tf_dev_clear_tcam(tfp, parms);
1014 "%s: TCAM shared entries clear failed, rc:%s\n",
1015 tf_dir_2_str(parms->dir),
1022 #endif /* TF_TCAM_SHARED */
1025 tf_alloc_tbl_entry(struct tf *tfp,
1026 struct tf_alloc_tbl_entry_parms *parms)
1029 struct tf_session *tfs;
1030 struct tf_dev_info *dev;
1031 struct tf_tbl_alloc_parms aparms;
1034 TF_CHECK_PARMS2(tfp, parms);
1036 /* Can't do static initialization due to UT enum check */
1037 memset(&aparms, 0, sizeof(struct tf_tbl_alloc_parms));
1039 /* Retrieve the session information */
1040 rc = tf_session_get_session(tfp, &tfs);
1043 "%s: Failed to lookup session, rc:%s\n",
1044 tf_dir_2_str(parms->dir),
1049 /* Retrieve the device information */
1050 rc = tf_session_get_device(tfs, &dev);
1053 "%s: Failed to lookup device, rc:%s\n",
1054 tf_dir_2_str(parms->dir),
1059 aparms.dir = parms->dir;
1060 aparms.type = parms->type;
1062 aparms.tbl_scope_id = parms->tbl_scope_id;
1064 if (parms->type == TF_TBL_TYPE_EXT) {
1065 if (dev->ops->tf_dev_alloc_ext_tbl == NULL) {
1068 "%s: Operation not supported, rc:%s\n",
1069 tf_dir_2_str(parms->dir),
1074 rc = dev->ops->tf_dev_alloc_ext_tbl(tfp, &aparms);
1077 "%s: External table allocation failed, rc:%s\n",
1078 tf_dir_2_str(parms->dir),
1082 } else if (dev->ops->tf_dev_is_sram_managed(tfp, parms->type)) {
1083 rc = dev->ops->tf_dev_alloc_sram_tbl(tfp, &aparms);
1086 "%s: SRAM table allocation failed, rc:%s\n",
1087 tf_dir_2_str(parms->dir),
1092 rc = dev->ops->tf_dev_alloc_tbl(tfp, &aparms);
1095 "%s: Table allocation failed, rc:%s\n",
1096 tf_dir_2_str(parms->dir),
1108 tf_free_tbl_entry(struct tf *tfp,
1109 struct tf_free_tbl_entry_parms *parms)
1112 struct tf_session *tfs;
1113 struct tf_dev_info *dev;
1114 struct tf_tbl_free_parms fparms;
1116 TF_CHECK_PARMS2(tfp, parms);
1118 /* Can't do static initialization due to UT enum check */
1119 memset(&fparms, 0, sizeof(struct tf_tbl_free_parms));
1121 /* Retrieve the session information */
1122 rc = tf_session_get_session(tfp, &tfs);
1125 "%s: Failed to lookup session, rc:%s\n",
1126 tf_dir_2_str(parms->dir),
1131 /* Retrieve the device information */
1132 rc = tf_session_get_device(tfs, &dev);
1135 "%s: Failed to lookup device, rc:%s\n",
1136 tf_dir_2_str(parms->dir),
1141 fparms.dir = parms->dir;
1142 fparms.type = parms->type;
1143 fparms.idx = parms->idx;
1144 fparms.tbl_scope_id = parms->tbl_scope_id;
1146 if (parms->type == TF_TBL_TYPE_EXT) {
1147 if (dev->ops->tf_dev_free_ext_tbl == NULL) {
1150 "%s: Operation not supported, rc:%s\n",
1151 tf_dir_2_str(parms->dir),
1156 rc = dev->ops->tf_dev_free_ext_tbl(tfp, &fparms);
1159 "%s: Table free failed, rc:%s\n",
1160 tf_dir_2_str(parms->dir),
1164 } else if (dev->ops->tf_dev_is_sram_managed(tfp, parms->type)) {
1165 rc = dev->ops->tf_dev_free_sram_tbl(tfp, &fparms);
1168 "%s: SRAM table free failed, rc:%s\n",
1169 tf_dir_2_str(parms->dir),
1175 rc = dev->ops->tf_dev_free_tbl(tfp, &fparms);
1178 "%s: Table free failed, rc:%s\n",
1179 tf_dir_2_str(parms->dir),
1188 tf_set_tbl_entry(struct tf *tfp,
1189 struct tf_set_tbl_entry_parms *parms)
1192 struct tf_session *tfs;
1193 struct tf_dev_info *dev;
1194 struct tf_tbl_set_parms sparms;
1196 TF_CHECK_PARMS3(tfp, parms, parms->data);
1198 /* Can't do static initialization due to UT enum check */
1199 memset(&sparms, 0, sizeof(struct tf_tbl_set_parms));
1201 /* Retrieve the session information */
1202 rc = tf_session_get_session(tfp, &tfs);
1205 "%s: Failed to lookup session, rc:%s\n",
1206 tf_dir_2_str(parms->dir),
1211 /* Retrieve the device information */
1212 rc = tf_session_get_device(tfs, &dev);
1215 "%s: Failed to lookup device, rc:%s\n",
1216 tf_dir_2_str(parms->dir),
1221 sparms.dir = parms->dir;
1222 sparms.type = parms->type;
1223 sparms.data = parms->data;
1224 sparms.data_sz_in_bytes = parms->data_sz_in_bytes;
1225 sparms.idx = parms->idx;
1226 sparms.tbl_scope_id = parms->tbl_scope_id;
1228 if (parms->type == TF_TBL_TYPE_EXT) {
1229 if (dev->ops->tf_dev_set_ext_tbl == NULL) {
1232 "%s: Operation not supported, rc:%s\n",
1233 tf_dir_2_str(parms->dir),
1238 rc = dev->ops->tf_dev_set_ext_tbl(tfp, &sparms);
1241 "%s: Table set failed, rc:%s\n",
1242 tf_dir_2_str(parms->dir),
1246 } else if (dev->ops->tf_dev_is_sram_managed(tfp, parms->type)) {
1247 rc = dev->ops->tf_dev_set_sram_tbl(tfp, &sparms);
1250 "%s: SRAM table set failed, rc:%s\n",
1251 tf_dir_2_str(parms->dir),
1256 if (dev->ops->tf_dev_set_tbl == NULL) {
1259 "%s: Operation not supported, rc:%s\n",
1260 tf_dir_2_str(parms->dir),
1265 rc = dev->ops->tf_dev_set_tbl(tfp, &sparms);
1268 "%s: Table set failed, rc:%s\n",
1269 tf_dir_2_str(parms->dir),
1279 tf_get_tbl_entry(struct tf *tfp,
1280 struct tf_get_tbl_entry_parms *parms)
1283 struct tf_session *tfs;
1284 struct tf_dev_info *dev;
1285 struct tf_tbl_get_parms gparms;
1287 TF_CHECK_PARMS3(tfp, parms, parms->data);
1289 /* Can't do static initialization due to UT enum check */
1290 memset(&gparms, 0, sizeof(struct tf_tbl_get_parms));
1292 /* Retrieve the session information */
1293 rc = tf_session_get_session(tfp, &tfs);
1296 "%s: Failed to lookup session, rc:%s\n",
1297 tf_dir_2_str(parms->dir),
1302 /* Retrieve the device information */
1303 rc = tf_session_get_device(tfs, &dev);
1306 "%s: Failed to lookup device, rc:%s\n",
1307 tf_dir_2_str(parms->dir),
1311 gparms.dir = parms->dir;
1312 gparms.type = parms->type;
1313 gparms.data = parms->data;
1314 gparms.data_sz_in_bytes = parms->data_sz_in_bytes;
1315 gparms.idx = parms->idx;
1317 if (dev->ops->tf_dev_is_sram_managed(tfp, parms->type)) {
1318 rc = dev->ops->tf_dev_get_sram_tbl(tfp, &gparms);
1321 "%s: SRAM table get failed, rc:%s\n",
1322 tf_dir_2_str(parms->dir),
1327 if (dev->ops->tf_dev_get_tbl == NULL) {
1330 "%s: Operation not supported, rc:%s\n",
1331 tf_dir_2_str(parms->dir),
1336 rc = dev->ops->tf_dev_get_tbl(tfp, &gparms);
1339 "%s: Table get failed, rc:%s\n",
1340 tf_dir_2_str(parms->dir),
1350 tf_bulk_get_tbl_entry(struct tf *tfp,
1351 struct tf_bulk_get_tbl_entry_parms *parms)
1354 struct tf_session *tfs;
1355 struct tf_dev_info *dev;
1356 struct tf_tbl_get_bulk_parms bparms;
1358 TF_CHECK_PARMS2(tfp, parms);
1360 /* Can't do static initialization due to UT enum check */
1361 memset(&bparms, 0, sizeof(struct tf_tbl_get_bulk_parms));
1363 /* Retrieve the session information */
1364 rc = tf_session_get_session(tfp, &tfs);
1367 "%s: Failed to lookup session, rc:%s\n",
1368 tf_dir_2_str(parms->dir),
1373 /* Retrieve the device information */
1374 rc = tf_session_get_device(tfs, &dev);
1377 "%s: Failed to lookup device, rc:%s\n",
1378 tf_dir_2_str(parms->dir),
1383 bparms.dir = parms->dir;
1384 bparms.type = parms->type;
1385 bparms.starting_idx = parms->starting_idx;
1386 bparms.num_entries = parms->num_entries;
1387 bparms.entry_sz_in_bytes = parms->entry_sz_in_bytes;
1388 bparms.physical_mem_addr = parms->physical_mem_addr;
1390 if (parms->type == TF_TBL_TYPE_EXT) {
1391 /* Not supported, yet */
1394 "%s, External table type not supported, rc:%s\n",
1395 tf_dir_2_str(parms->dir),
1399 } else if (dev->ops->tf_dev_is_sram_managed(tfp, parms->type)) {
1400 rc = dev->ops->tf_dev_get_bulk_sram_tbl(tfp, &bparms);
1403 "%s: SRAM table bulk get failed, rc:%s\n",
1404 tf_dir_2_str(parms->dir),
1410 if (dev->ops->tf_dev_get_bulk_tbl == NULL) {
1413 "%s: Operation not supported, rc:%s\n",
1414 tf_dir_2_str(parms->dir),
1419 rc = dev->ops->tf_dev_get_bulk_tbl(tfp, &bparms);
1422 "%s: Table get bulk failed, rc:%s\n",
1423 tf_dir_2_str(parms->dir),
1430 int tf_get_shared_tbl_increment(struct tf *tfp,
1431 struct tf_get_shared_tbl_increment_parms *parms)
1434 struct tf_session *tfs;
1435 struct tf_dev_info *dev;
1437 TF_CHECK_PARMS2(tfp, parms);
1439 /* Retrieve the session information */
1440 rc = tf_session_get_session(tfp, &tfs);
1443 "%s: Failed to lookup session, rc:%s\n",
1444 tf_dir_2_str(parms->dir),
1449 /* Retrieve the device information */
1450 rc = tf_session_get_device(tfs, &dev);
1453 "%s: Failed to lookup device, rc:%s\n",
1454 tf_dir_2_str(parms->dir),
1459 /* Internal table type processing */
1461 if (dev->ops->tf_dev_get_shared_tbl_increment == NULL) {
1464 "%s: Operation not supported, rc:%s\n",
1465 tf_dir_2_str(parms->dir),
1470 rc = dev->ops->tf_dev_get_shared_tbl_increment(tfp, parms);
1473 "%s: Get table increment not supported, rc:%s\n",
1474 tf_dir_2_str(parms->dir),
1483 tf_alloc_tbl_scope(struct tf *tfp,
1484 struct tf_alloc_tbl_scope_parms *parms)
1486 struct tf_session *tfs;
1487 struct tf_dev_info *dev;
1490 TF_CHECK_PARMS2(tfp, parms);
1492 /* Retrieve the session information */
1493 rc = tf_session_get_session(tfp, &tfs);
1496 "Failed to lookup session, rc:%s\n",
1501 /* Retrieve the device information */
1502 rc = tf_session_get_device(tfs, &dev);
1505 "Failed to lookup device, rc:%s\n",
1510 if (dev->ops->tf_dev_alloc_tbl_scope != NULL) {
1511 rc = dev->ops->tf_dev_alloc_tbl_scope(tfp, parms);
1514 "Alloc table scope not supported by device\n");
1521 tf_map_tbl_scope(struct tf *tfp,
1522 struct tf_map_tbl_scope_parms *parms)
1524 struct tf_session *tfs;
1525 struct tf_dev_info *dev;
1528 TF_CHECK_PARMS2(tfp, parms);
1530 /* Retrieve the session information */
1531 rc = tf_session_get_session(tfp, &tfs);
1534 "Failed to lookup session, rc:%s\n",
1539 /* Retrieve the device information */
1540 rc = tf_session_get_device(tfs, &dev);
1543 "Failed to lookup device, rc:%s\n",
1548 if (dev->ops->tf_dev_map_tbl_scope != NULL) {
1549 rc = dev->ops->tf_dev_map_tbl_scope(tfp, parms);
1552 "Map table scope not supported by device\n");
1560 tf_free_tbl_scope(struct tf *tfp,
1561 struct tf_free_tbl_scope_parms *parms)
1563 struct tf_session *tfs;
1564 struct tf_dev_info *dev;
1567 TF_CHECK_PARMS2(tfp, parms);
1569 /* Retrieve the session information */
1570 rc = tf_session_get_session(tfp, &tfs);
1573 "Failed to lookup session, rc:%s\n",
1578 /* Retrieve the device information */
1579 rc = tf_session_get_device(tfs, &dev);
1582 "Failed to lookup device, rc:%s\n",
1587 if (dev->ops->tf_dev_free_tbl_scope) {
1588 rc = dev->ops->tf_dev_free_tbl_scope(tfp, parms);
1591 "Free table scope not supported by device\n");
1599 tf_set_if_tbl_entry(struct tf *tfp,
1600 struct tf_set_if_tbl_entry_parms *parms)
1603 struct tf_session *tfs;
1604 struct tf_dev_info *dev;
1605 struct tf_if_tbl_set_parms sparms = { 0 };
1607 TF_CHECK_PARMS2(tfp, parms);
1609 /* Retrieve the session information */
1610 rc = tf_session_get_session(tfp, &tfs);
1613 "%s: Failed to lookup session, rc:%s\n",
1614 tf_dir_2_str(parms->dir),
1619 /* Retrieve the device information */
1620 rc = tf_session_get_device(tfs, &dev);
1623 "%s: Failed to lookup device, rc:%s\n",
1624 tf_dir_2_str(parms->dir),
1629 if (dev->ops->tf_dev_set_if_tbl == NULL) {
1632 "%s: Operation not supported, rc:%s\n",
1633 tf_dir_2_str(parms->dir),
1638 sparms.dir = parms->dir;
1639 sparms.type = parms->type;
1640 sparms.idx = parms->idx;
1641 sparms.data_sz_in_bytes = parms->data_sz_in_bytes;
1642 sparms.data = parms->data;
1644 rc = dev->ops->tf_dev_set_if_tbl(tfp, &sparms);
1647 "%s: If_tbl set failed, rc:%s\n",
1648 tf_dir_2_str(parms->dir),
1657 tf_get_if_tbl_entry(struct tf *tfp,
1658 struct tf_get_if_tbl_entry_parms *parms)
1661 struct tf_session *tfs;
1662 struct tf_dev_info *dev;
1663 struct tf_if_tbl_get_parms gparms = { 0 };
1665 TF_CHECK_PARMS2(tfp, parms);
1667 /* Retrieve the session information */
1668 rc = tf_session_get_session(tfp, &tfs);
1671 "%s: Failed to lookup session, rc:%s\n",
1672 tf_dir_2_str(parms->dir),
1677 /* Retrieve the device information */
1678 rc = tf_session_get_device(tfs, &dev);
1681 "%s: Failed to lookup device, rc:%s\n",
1682 tf_dir_2_str(parms->dir),
1687 if (dev->ops->tf_dev_get_if_tbl == NULL) {
1690 "%s: Operation not supported, rc:%s\n",
1691 tf_dir_2_str(parms->dir),
1696 gparms.dir = parms->dir;
1697 gparms.type = parms->type;
1698 gparms.idx = parms->idx;
1699 gparms.data_sz_in_bytes = parms->data_sz_in_bytes;
1700 gparms.data = parms->data;
1702 rc = dev->ops->tf_dev_get_if_tbl(tfp, &gparms);
1705 "%s: If_tbl get failed, rc:%s\n",
1706 tf_dir_2_str(parms->dir),
1714 int tf_get_session_info(struct tf *tfp,
1715 struct tf_get_session_info_parms *parms)
1718 struct tf_session *tfs;
1719 struct tf_dev_info *dev;
1721 TF_CHECK_PARMS2(tfp, parms);
1723 /* Retrieve the session information */
1724 rc = tf_session_get_session(tfp, &tfs);
1727 "Failed to lookup session, rc:%s\n",
1732 /* Retrieve the device information */
1733 rc = tf_session_get_device(tfs, &dev);
1736 "Failed to lookup device, rc:%s\n",
1741 TF_CHECK_PARMS2(tfp, parms);
1743 if (dev->ops->tf_dev_get_ident_resc_info == NULL) {
1746 "Operation not supported, rc:%s\n",
1751 rc = dev->ops->tf_dev_get_ident_resc_info(tfp, parms->session_info.ident);
1754 "Ident get resc info failed, rc:%s\n",
1758 if (dev->ops->tf_dev_get_tbl_resc_info == NULL) {
1761 "Operation not supported, rc:%s\n",
1766 rc = dev->ops->tf_dev_get_tbl_resc_info(tfp, parms->session_info.tbl);
1769 "Tbl get resc info failed, rc:%s\n",
1773 if (dev->ops->tf_dev_get_tcam_resc_info == NULL) {
1776 "Operation not supported, rc:%s\n",
1781 rc = dev->ops->tf_dev_get_tcam_resc_info(tfp, parms->session_info.tcam);
1784 "TCAM get resc info failed, rc:%s\n",
1788 if (dev->ops->tf_dev_get_em_resc_info == NULL) {
1791 "Operation not supported, rc:%s\n",
1796 rc = dev->ops->tf_dev_get_em_resc_info(tfp, parms->session_info.em);
1799 "EM get resc info failed, rc:%s\n",
1806 int tf_get_version(struct tf *tfp,
1807 struct tf_get_version_parms *parms)
1810 struct tf_dev_info dev;
1812 TF_CHECK_PARMS2(tfp, parms);
1814 /* This function can be called before open session, filter
1815 * out any non-supported device types on the Core side.
1817 if (parms->device_type != TF_DEVICE_TYPE_WH &&
1818 parms->device_type != TF_DEVICE_TYPE_THOR &&
1819 parms->device_type != TF_DEVICE_TYPE_SR) {
1821 "Unsupported device type %d\n",
1822 parms->device_type);
1826 tf_dev_bind_ops(parms->device_type, &dev);
1828 rc = tf_msg_get_version(parms->bp, &dev, parms);
1835 int tf_query_sram_resources(struct tf *tfp,
1836 struct tf_query_sram_resources_parms *parms)
1839 struct tf_dev_info dev;
1841 struct tfp_calloc_parms cparms;
1842 struct tf_rm_resc_req_entry *query;
1843 enum tf_rm_resc_resv_strategy resv_strategy;
1845 TF_CHECK_PARMS2(tfp, parms);
1847 /* This function can be called before open session, filter
1848 * out any non-supported device types on the Core side.
1850 if (parms->device_type != TF_DEVICE_TYPE_THOR) {
1852 "Unsupported device type %d\n",
1853 parms->device_type);
1857 tf_dev_bind_ops(parms->device_type, &dev);
1859 if (dev.ops->tf_dev_get_max_types == NULL) {
1862 "%s: Operation not supported, rc:%s\n",
1863 tf_dir_2_str(parms->dir),
1868 /* Need device max number of elements for the RM QCAPS */
1869 rc = dev.ops->tf_dev_get_max_types(tfp, &max_types);
1872 "Get SRAM resc info failed, rc:%s\n",
1877 /* Allocate memory for RM QCAPS request */
1878 cparms.nitems = max_types;
1879 cparms.size = sizeof(struct tf_rm_resc_req_entry);
1880 cparms.alignment = 0;
1881 rc = tfp_calloc(&cparms);
1885 query = (struct tf_rm_resc_req_entry *)cparms.mem_va;
1886 tfp->bp = parms->bp;
1888 /* Get Firmware Capabilities */
1889 rc = tf_msg_session_resc_qcaps(tfp,
1895 &parms->sram_profile);
1899 if (dev.ops->tf_dev_get_sram_resources == NULL) {
1902 "%s: Operation not supported, rc:%s\n",
1903 tf_dir_2_str(parms->dir),
1908 rc = dev.ops->tf_dev_get_sram_resources((void *)query,
1909 parms->bank_resc_count,
1910 &parms->dynamic_sram_capable);
1913 "Get SRAM resc info failed, rc:%s\n",
1921 int tf_set_sram_policy(struct tf *tfp,
1922 struct tf_set_sram_policy_parms *parms)
1925 struct tf_dev_info dev;
1927 TF_CHECK_PARMS2(tfp, parms);
1929 /* This function can be called before open session, filter
1930 * out any non-supported device types on the Core side.
1932 if (parms->device_type != TF_DEVICE_TYPE_THOR) {
1934 "Unsupported device type %d\n",
1935 parms->device_type);
1939 tf_dev_bind_ops(parms->device_type, &dev);
1941 if (dev.ops->tf_dev_set_sram_policy == NULL) {
1944 "%s: Operation not supported, rc:%s\n",
1945 tf_dir_2_str(parms->dir),
1950 rc = dev.ops->tf_dev_set_sram_policy(parms->dir, parms->bank_id);
1953 "%s: SRAM policy set failed, rc:%s\n",
1954 tf_dir_2_str(parms->dir),
1962 int tf_get_sram_policy(struct tf *tfp,
1963 struct tf_get_sram_policy_parms *parms)
1966 struct tf_dev_info dev;
1968 TF_CHECK_PARMS2(tfp, parms);
1970 /* This function can be called before open session, filter
1971 * out any non-supported device types on the Core side.
1973 if (parms->device_type != TF_DEVICE_TYPE_THOR) {
1975 "Unsupported device type %d\n",
1976 parms->device_type);
1980 tf_dev_bind_ops(parms->device_type, &dev);
1982 if (dev.ops->tf_dev_get_sram_policy == NULL) {
1985 "%s: Operation not supported, rc:%s\n",
1986 tf_dir_2_str(parms->dir),
1991 rc = dev.ops->tf_dev_get_sram_policy(parms->dir, parms->bank_id);
1994 "%s: SRAM policy get failed, rc:%s\n",
1995 tf_dir_2_str(parms->dir),