]>
Commit | Line | Data |
---|---|---|
f67539c2 TL |
1 | /* SPDX-License-Identifier: BSD-3-Clause |
2 | * Copyright(c) 2019-2020 Broadcom | |
3 | * All rights reserved. | |
4 | */ | |
5 | ||
6 | #ifndef TF_RM_H_ | |
7 | #define TF_RM_H_ | |
8 | ||
9 | #include "tf_resources.h" | |
10 | #include "tf_core.h" | |
11 | #include "bitalloc.h" | |
12 | ||
13 | struct tf; | |
14 | struct tf_session; | |
15 | ||
16 | /* Internal macro to determine appropriate allocation pools based on | |
17 | * DIRECTION parm, also performs error checking for DIRECTION parm. The | |
18 | * SESSION_POOL and SESSION pointers are set appropriately upon | |
19 | * successful return (the GLOBAL_POOL is used to globally manage | |
20 | * resource allocation and the SESSION_POOL is used to track the | |
21 | * resources that have been allocated to the session) | |
22 | * | |
23 | * parameters: | |
24 | * struct tfp *tfp | |
25 | * enum tf_dir direction | |
26 | * struct bitalloc **session_pool | |
27 | * string base_pool_name - used to form pointers to the | |
28 | * appropriate bit allocation | |
29 | * pools, both directions of the | |
30 | * session pools must have same | |
31 | * base name, for example if | |
32 | * POOL_NAME is feat_pool: - the | |
33 | * ptr's to the session pools | |
34 | * are feat_pool_rx feat_pool_tx | |
35 | * | |
36 | * int rc - return code | |
37 | * 0 - Success | |
38 | * -1 - invalid DIRECTION parm | |
39 | */ | |
40 | #define TF_RM_GET_POOLS(tfs, direction, session_pool, pool_name, rc) do { \ | |
41 | (rc) = 0; \ | |
42 | if ((direction) == TF_DIR_RX) { \ | |
43 | *(session_pool) = (tfs)->pool_name ## _RX; \ | |
44 | } else if ((direction) == TF_DIR_TX) { \ | |
45 | *(session_pool) = (tfs)->pool_name ## _TX; \ | |
46 | } else { \ | |
47 | rc = -1; \ | |
48 | } \ | |
49 | } while (0) | |
50 | ||
51 | #define TF_RM_GET_POOLS_RX(tfs, session_pool, pool_name) \ | |
52 | (*(session_pool) = (tfs)->pool_name ## _RX) | |
53 | ||
54 | #define TF_RM_GET_POOLS_TX(tfs, session_pool, pool_name) \ | |
55 | (*(session_pool) = (tfs)->pool_name ## _TX) | |
56 | ||
57 | /** | |
58 | * Resource query single entry | |
59 | */ | |
60 | struct tf_rm_query_entry { | |
61 | /** Minimum guaranteed number of elements */ | |
62 | uint16_t min; | |
63 | /** Maximum non-guaranteed number of elements */ | |
64 | uint16_t max; | |
65 | }; | |
66 | ||
67 | /** | |
68 | * Resource single entry | |
69 | */ | |
70 | struct tf_rm_entry { | |
71 | /** Starting index of the allocated resource */ | |
72 | uint16_t start; | |
73 | /** Number of allocated elements */ | |
74 | uint16_t stride; | |
75 | }; | |
76 | ||
77 | /** | |
78 | * Resource query array of HW entities | |
79 | */ | |
80 | struct tf_rm_hw_query { | |
81 | /** array of HW resource entries */ | |
82 | struct tf_rm_query_entry hw_query[TF_RESC_TYPE_HW_MAX]; | |
83 | }; | |
84 | ||
85 | /** | |
86 | * Resource allocation array of HW entities | |
87 | */ | |
88 | struct tf_rm_hw_alloc { | |
89 | /** array of HW resource entries */ | |
90 | uint16_t hw_num[TF_RESC_TYPE_HW_MAX]; | |
91 | }; | |
92 | ||
93 | /** | |
94 | * Resource query array of SRAM entities | |
95 | */ | |
96 | struct tf_rm_sram_query { | |
97 | /** array of SRAM resource entries */ | |
98 | struct tf_rm_query_entry sram_query[TF_RESC_TYPE_SRAM_MAX]; | |
99 | }; | |
100 | ||
101 | /** | |
102 | * Resource allocation array of SRAM entities | |
103 | */ | |
104 | struct tf_rm_sram_alloc { | |
105 | /** array of SRAM resource entries */ | |
106 | uint16_t sram_num[TF_RESC_TYPE_SRAM_MAX]; | |
107 | }; | |
108 | ||
109 | /** | |
110 | * Resource Manager arrays for a single direction | |
111 | */ | |
112 | struct tf_rm_resc { | |
113 | /** array of HW resource entries */ | |
114 | struct tf_rm_entry hw_entry[TF_RESC_TYPE_HW_MAX]; | |
115 | /** array of SRAM resource entries */ | |
116 | struct tf_rm_entry sram_entry[TF_RESC_TYPE_SRAM_MAX]; | |
117 | }; | |
118 | ||
119 | /** | |
120 | * Resource Manager Database | |
121 | */ | |
122 | struct tf_rm_db { | |
123 | struct tf_rm_resc rx; | |
124 | struct tf_rm_resc tx; | |
125 | }; | |
126 | ||
127 | /** | |
128 | * Helper function converting direction to text string | |
129 | */ | |
130 | const char | |
131 | *tf_dir_2_str(enum tf_dir dir); | |
132 | ||
133 | /** | |
134 | * Helper function converting identifier to text string | |
135 | */ | |
136 | const char | |
137 | *tf_ident_2_str(enum tf_identifier_type id_type); | |
138 | ||
139 | /** | |
140 | * Helper function converting tcam type to text string | |
141 | */ | |
142 | const char | |
143 | *tf_tcam_tbl_2_str(enum tf_tcam_tbl_type tcam_type); | |
144 | ||
145 | /** | |
146 | * Helper function used to convert HW HCAPI resource type to a string. | |
147 | */ | |
148 | const char | |
149 | *tf_hcapi_hw_2_str(enum tf_resource_type_hw hw_type); | |
150 | ||
151 | /** | |
152 | * Helper function used to convert SRAM HCAPI resource type to a string. | |
153 | */ | |
154 | const char | |
155 | *tf_hcapi_sram_2_str(enum tf_resource_type_sram sram_type); | |
156 | ||
157 | /** | |
158 | * Initializes the Resource Manager and the associated database | |
159 | * entries for HW and SRAM resources. Must be called before any other | |
160 | * Resource Manager functions. | |
161 | * | |
162 | * [in] tfp | |
163 | * Pointer to TF handle | |
164 | */ | |
165 | void tf_rm_init(struct tf *tfp); | |
166 | ||
167 | /** | |
168 | * Allocates and validates both HW and SRAM resources per the NVM | |
169 | * configuration. If any allocation fails all resources for the | |
170 | * session is deallocated. | |
171 | * | |
172 | * [in] tfp | |
173 | * Pointer to TF handle | |
174 | * | |
175 | * Returns | |
176 | * - (0) if successful. | |
177 | * - (-EINVAL) on failure. | |
178 | */ | |
179 | int tf_rm_allocate_validate(struct tf *tfp); | |
180 | ||
181 | /** | |
182 | * Closes the Resource Manager and frees all allocated resources per | |
183 | * the associated database. | |
184 | * | |
185 | * [in] tfp | |
186 | * Pointer to TF handle | |
187 | * | |
188 | * Returns | |
189 | * - (0) if successful. | |
190 | * - (-EINVAL) on failure. | |
191 | * - (-ENOTEMPTY) if resources are not cleaned up before close | |
192 | */ | |
193 | int tf_rm_close(struct tf *tfp); | |
194 | ||
195 | #if (TF_SHADOW == 1) | |
196 | /** | |
197 | * Initializes Shadow DB of configuration elements | |
198 | * | |
199 | * [in] tfs | |
200 | * Pointer to TF Session | |
201 | * | |
202 | * Returns: | |
203 | * 0 - Success | |
204 | */ | |
205 | int tf_rm_shadow_db_init(struct tf_session *tfs); | |
206 | #endif /* TF_SHADOW */ | |
207 | ||
208 | /** | |
209 | * Perform a Session Pool lookup using the Tcam table type. | |
210 | * | |
211 | * Function will print error msg if tcam type is unsupported or lookup | |
212 | * failed. | |
213 | * | |
214 | * [in] tfs | |
215 | * Pointer to TF Session | |
216 | * | |
217 | * [in] type | |
218 | * Type of the object | |
219 | * | |
220 | * [in] dir | |
221 | * Receive or transmit direction | |
222 | * | |
223 | * [in/out] session_pool | |
224 | * Session pool | |
225 | * | |
226 | * Returns: | |
227 | * 0 - Success will set the **pool | |
228 | * -EOPNOTSUPP - Type is not supported | |
229 | */ | |
230 | int | |
231 | tf_rm_lookup_tcam_type_pool(struct tf_session *tfs, | |
232 | enum tf_dir dir, | |
233 | enum tf_tcam_tbl_type type, | |
234 | struct bitalloc **pool); | |
235 | ||
236 | /** | |
237 | * Perform a Session Pool lookup using the Table type. | |
238 | * | |
239 | * Function will print error msg if table type is unsupported or | |
240 | * lookup failed. | |
241 | * | |
242 | * [in] tfs | |
243 | * Pointer to TF Session | |
244 | * | |
245 | * [in] type | |
246 | * Type of the object | |
247 | * | |
248 | * [in] dir | |
249 | * Receive or transmit direction | |
250 | * | |
251 | * [in/out] session_pool | |
252 | * Session pool | |
253 | * | |
254 | * Returns: | |
255 | * 0 - Success will set the **pool | |
256 | * -EOPNOTSUPP - Type is not supported | |
257 | */ | |
258 | int | |
259 | tf_rm_lookup_tbl_type_pool(struct tf_session *tfs, | |
260 | enum tf_dir dir, | |
261 | enum tf_tbl_type type, | |
262 | struct bitalloc **pool); | |
263 | ||
264 | /** | |
265 | * Converts the TF Table Type to internal HCAPI_TYPE | |
266 | * | |
267 | * [in] type | |
268 | * Type to be converted | |
269 | * | |
270 | * [in/out] hcapi_type | |
271 | * Converted type | |
272 | * | |
273 | * Returns: | |
274 | * 0 - Success will set the *hcapi_type | |
275 | * -EOPNOTSUPP - Type is not supported | |
276 | */ | |
277 | int | |
278 | tf_rm_convert_tbl_type(enum tf_tbl_type type, | |
279 | uint32_t *hcapi_type); | |
280 | ||
281 | /** | |
282 | * TF RM Convert of index methods. | |
283 | */ | |
284 | enum tf_rm_convert_type { | |
285 | /** Adds the base of the Session Pool to the index */ | |
286 | TF_RM_CONVERT_ADD_BASE, | |
287 | /** Removes the Session Pool base from the index */ | |
288 | TF_RM_CONVERT_RM_BASE | |
289 | }; | |
290 | ||
291 | /** | |
292 | * Provides conversion of the Table Type index in relation to the | |
293 | * Session Pool base. | |
294 | * | |
295 | * [in] tfs | |
296 | * Pointer to TF Session | |
297 | * | |
298 | * [in] dir | |
299 | * Receive or transmit direction | |
300 | * | |
301 | * [in] type | |
302 | * Type of the object | |
303 | * | |
304 | * [in] c_type | |
305 | * Type of conversion to perform | |
306 | * | |
307 | * [in] index | |
308 | * Index to be converted | |
309 | * | |
310 | * [in/out] convert_index | |
311 | * Pointer to the converted index | |
312 | */ | |
313 | int | |
314 | tf_rm_convert_index(struct tf_session *tfs, | |
315 | enum tf_dir dir, | |
316 | enum tf_tbl_type type, | |
317 | enum tf_rm_convert_type c_type, | |
318 | uint32_t index, | |
319 | uint32_t *convert_index); | |
320 | ||
321 | #endif /* TF_RM_H_ */ |