]>
Commit | Line | Data |
---|---|---|
11fdf7f2 TL |
1 | /* SPDX-License-Identifier: BSD-3-Clause |
2 | * Copyright(c) 2017 Intel Corporation | |
3 | */ | |
4 | ||
5 | #ifndef _RTE_BBDEV_OP_H_ | |
6 | #define _RTE_BBDEV_OP_H_ | |
7 | ||
8 | /** | |
9 | * @file rte_bbdev_op.h | |
10 | * | |
11 | * Defines wireless base band layer 1 operations and capabilities | |
12 | * | |
13 | * @warning | |
14 | * @b EXPERIMENTAL: this API may change without prior notice | |
15 | */ | |
16 | ||
17 | #ifdef __cplusplus | |
18 | extern "C" { | |
19 | #endif | |
20 | ||
21 | #include <stdint.h> | |
22 | ||
23 | #include <rte_common.h> | |
24 | #include <rte_mbuf.h> | |
25 | #include <rte_memory.h> | |
26 | #include <rte_mempool.h> | |
27 | ||
28 | /* Number of columns in sub-block interleaver (36.212, section 5.1.4.1.1) */ | |
29 | #define RTE_BBDEV_C_SUBBLOCK (32) | |
30 | /* Maximum size of Transport Block (36.213, Table, Table 7.1.7.2.5-1) */ | |
31 | #define RTE_BBDEV_MAX_TB_SIZE (391656) | |
32 | /* Maximum size of Code Block (36.212, Table 5.1.3-3) */ | |
33 | #define RTE_BBDEV_MAX_CB_SIZE (6144) | |
34 | /* Minimum size of Code Block (36.212, Table 5.1.3-3) */ | |
35 | #define RTE_BBDEV_MIN_CB_SIZE (40) | |
36 | /* Maximum size of circular buffer */ | |
37 | #define RTE_BBDEV_MAX_KW (18528) | |
38 | /* | |
39 | * Maximum number of Code Blocks in Transport Block. It is calculated based on | |
40 | * maximum size of one Code Block and one Transport Block (considering CRC24A | |
41 | * and CRC24B): | |
42 | * (391656 + 24) / (6144 - 24) = 64 | |
43 | */ | |
44 | #define RTE_BBDEV_MAX_CODE_BLOCKS (64) | |
45 | ||
46 | /** Flags for turbo decoder operation and capability structure */ | |
47 | enum rte_bbdev_op_td_flag_bitmasks { | |
48 | /**< If sub block de-interleaving is to be performed. */ | |
49 | RTE_BBDEV_TURBO_SUBBLOCK_DEINTERLEAVE = (1ULL << 0), | |
50 | /**< To use CRC Type 24B (otherwise use CRC Type 24A). */ | |
51 | RTE_BBDEV_TURBO_CRC_TYPE_24B = (1ULL << 1), | |
52 | /**< If turbo equalization is to be performed. */ | |
53 | RTE_BBDEV_TURBO_EQUALIZER = (1ULL << 2), | |
54 | /**< If set, saturate soft output to +/-127 */ | |
55 | RTE_BBDEV_TURBO_SOFT_OUT_SATURATE = (1ULL << 3), | |
56 | /**< Set to 1 to start iteration from even, else odd; one iteration = | |
57 | * max_iteration + 0.5 | |
58 | */ | |
59 | RTE_BBDEV_TURBO_HALF_ITERATION_EVEN = (1ULL << 4), | |
60 | /**< If 0, TD stops after CRC matches; else if 1, runs to end of next | |
61 | * odd iteration after CRC matches | |
62 | */ | |
63 | RTE_BBDEV_TURBO_CONTINUE_CRC_MATCH = (1ULL << 5), | |
64 | /**< Set if soft output is required to be output */ | |
65 | RTE_BBDEV_TURBO_SOFT_OUTPUT = (1ULL << 6), | |
66 | /**< Set to enable early termination mode */ | |
67 | RTE_BBDEV_TURBO_EARLY_TERMINATION = (1ULL << 7), | |
68 | /**< Set if a device supports decoder dequeue interrupts */ | |
69 | RTE_BBDEV_TURBO_DEC_INTERRUPTS = (1ULL << 9), | |
70 | /**< Set if positive LLR encoded input is supported. Positive LLR value | |
71 | * represents the level of confidence for bit '1', and vice versa for | |
72 | * bit '0'. | |
73 | * This is mutually exclusive with RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN | |
74 | * when used to formalize the input data format. | |
75 | */ | |
76 | RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN = (1ULL << 10), | |
77 | /**< Set if negative LLR encoded input is supported. Negative LLR value | |
78 | * represents the level of confidence for bit '1', and vice versa for | |
79 | * bit '0'. | |
80 | * This is mutually exclusive with RTE_BBDEV_TURBO_POS_LLR_1_BIT_IN | |
81 | * when used to formalize the input data format. | |
82 | */ | |
83 | RTE_BBDEV_TURBO_NEG_LLR_1_BIT_IN = (1ULL << 11), | |
84 | /**< Set if positive LLR soft output is supported. Positive LLR value | |
85 | * represents the level of confidence for bit '1', and vice versa for | |
86 | * bit '0'. | |
87 | * This is mutually exclusive with | |
88 | * RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT when used to formalize | |
89 | * the input data format. | |
90 | */ | |
91 | RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT = (1ULL << 12), | |
92 | /**< Set if negative LLR soft output is supported. Negative LLR value | |
93 | * represents the level of confidence for bit '1', and vice versa for | |
94 | * bit '0'. | |
95 | * This is mutually exclusive with | |
96 | * RTE_BBDEV_TURBO_POS_LLR_1_BIT_SOFT_OUT when used to formalize the | |
97 | * input data format. | |
98 | */ | |
99 | RTE_BBDEV_TURBO_NEG_LLR_1_BIT_SOFT_OUT = (1ULL << 13), | |
100 | /**< Set if driver supports flexible parallel MAP engine decoding. If | |
101 | * not supported, num_maps (number of MAP engines) argument is unusable. | |
102 | */ | |
103 | RTE_BBDEV_TURBO_MAP_DEC = (1ULL << 14), | |
104 | /**< Set if a device supports scatter-gather functionality */ | |
105 | RTE_BBDEV_TURBO_DEC_SCATTER_GATHER = (1ULL << 15), | |
106 | /**< Set to keep CRC24B bits appended while decoding. Only usable when | |
107 | * decoding Transport Blocks (code_block_mode = 0). | |
108 | */ | |
109 | RTE_BBDEV_TURBO_DEC_TB_CRC_24B_KEEP = (1ULL << 16) | |
110 | }; | |
111 | ||
112 | /** Flags for turbo encoder operation and capability structure */ | |
113 | enum rte_bbdev_op_te_flag_bitmasks { | |
114 | /**< Ignore rv_index and set K0 = 0 */ | |
115 | RTE_BBDEV_TURBO_RV_INDEX_BYPASS = (1ULL << 0), | |
116 | /**< If rate matching is to be performed */ | |
117 | RTE_BBDEV_TURBO_RATE_MATCH = (1ULL << 1), | |
118 | /**< This bit must be set to enable CRC-24B generation */ | |
119 | RTE_BBDEV_TURBO_CRC_24B_ATTACH = (1ULL << 2), | |
120 | /**< This bit must be set to enable CRC-24A generation */ | |
121 | RTE_BBDEV_TURBO_CRC_24A_ATTACH = (1ULL << 3), | |
122 | /**< Set if a device supports encoder dequeue interrupts */ | |
123 | RTE_BBDEV_TURBO_ENC_INTERRUPTS = (1ULL << 4), | |
124 | /**< Set if a device supports scatter-gather functionality */ | |
125 | RTE_BBDEV_TURBO_ENC_SCATTER_GATHER = (1ULL << 5) | |
126 | }; | |
127 | ||
128 | /**< Data input and output buffer for BBDEV operations */ | |
129 | struct rte_bbdev_op_data { | |
130 | /**< The mbuf data structure representing the data for BBDEV operation. | |
131 | * | |
132 | * This mbuf pointer can point to one Code Block (CB) data buffer or | |
133 | * multiple CBs contiguously located next to each other. | |
134 | * A Transport Block (TB) represents a whole piece of data that is | |
135 | * divided into one or more CBs. Maximum number of CBs can be contained | |
136 | * in one TB is defined by RTE_BBDEV_MAX_CODE_BLOCKS. | |
137 | * | |
138 | * An mbuf data structure cannot represent more than one TB. The | |
139 | * smallest piece of data that can be contained in one mbuf is one CB. | |
140 | * An mbuf can include one contiguous CB, subset of contiguous CBs that | |
141 | * are belonging to one TB, or all contiguous CBs that are belonging to | |
142 | * one TB. | |
143 | * | |
144 | * If a BBDEV PMD supports the extended capability "Scatter-Gather", | |
145 | * then it is capable of collecting (gathering) non-contiguous | |
146 | * (scattered) data from multiple locations in the memory. | |
147 | * This capability is reported by the capability flags: | |
148 | * - RTE_BBDEV_TURBO_ENC_SCATTER_GATHER and | |
149 | * - RTE_BBDEV_TURBO_DEC_SCATTER_GATHER. | |
150 | * Only if a BBDEV PMD supports this feature, chained mbuf data | |
151 | * structures are accepted. A chained mbuf can represent one | |
152 | * non-contiguous CB or multiple non-contiguous CBs. | |
153 | * If BBDEV PMD does not support this feature, it will assume inbound | |
154 | * mbuf data contains one segment. | |
155 | * | |
156 | * The output mbuf data though is always one segment, even if the input | |
157 | * was a chained mbuf. | |
158 | */ | |
159 | struct rte_mbuf *data; | |
160 | /**< The starting point of the BBDEV (encode/decode) operation, | |
161 | * in bytes. | |
162 | * | |
163 | * BBDEV starts to read data past this offset. | |
164 | * In case of chained mbuf, this offset applies only to the first mbuf | |
165 | * segment. | |
166 | */ | |
167 | uint32_t offset; | |
168 | /**< The total data length to be processed in one operation, in bytes. | |
169 | * | |
170 | * In case the mbuf data is representing one CB, this is the length of | |
171 | * the CB undergoing the operation. | |
172 | * If it's for multiple CBs, this is the total length of those CBs | |
173 | * undergoing the operation. | |
174 | * If it's for one TB, this is the total length of the TB under | |
175 | * operation. | |
176 | * | |
177 | * In case of chained mbuf, this data length includes the lengths of the | |
178 | * "scattered" data segments undergoing the operation. | |
179 | */ | |
180 | uint32_t length; | |
181 | }; | |
182 | ||
183 | struct rte_bbdev_op_dec_cb_params { | |
184 | /**< The K size of the input CB, in bits [40:6144], as specified in | |
185 | * 3GPP TS 36.212. | |
186 | * This size is inclusive of CRC bits, regardless whether it was | |
187 | * pre-calculated by the application or not. | |
188 | */ | |
189 | uint16_t k; | |
190 | /**< The E length of the CB rate matched LLR output, in bytes, as in | |
191 | * 3GPP TS 36.212. | |
192 | */ | |
193 | uint32_t e; | |
194 | }; | |
195 | ||
196 | struct rte_bbdev_op_dec_tb_params { | |
197 | /**< The K- size of the input CB, in bits [40:6144], that is in the | |
198 | * Turbo operation when r < C-, as in 3GPP TS 36.212. | |
199 | */ | |
200 | uint16_t k_neg; | |
201 | /**< The K+ size of the input CB, in bits [40:6144], that is in the | |
202 | * Turbo operation when r >= C-, as in 3GPP TS 36.212. | |
203 | */ | |
204 | uint16_t k_pos; | |
205 | /**< The number of CBs that have K- size, [0:63] */ | |
206 | uint8_t c_neg; | |
207 | /**< The total number of CBs in the TB, [1:RTE_BBDEV_MAX_CODE_BLOCKS] */ | |
208 | uint8_t c; | |
209 | /**< The number of CBs that uses Ea before switching to Eb, [0:63] */ | |
210 | uint8_t cab; | |
211 | /**< The E size of the CB rate matched output to use in the Turbo | |
212 | * operation when r < cab | |
213 | */ | |
214 | uint32_t ea; | |
215 | /**< The E size of the CB rate matched output to use in the Turbo | |
216 | * operation when r >= cab | |
217 | */ | |
218 | uint32_t eb; | |
9f95a23c TL |
219 | /**< The index of the first CB in the inbound mbuf data, default is 0 */ |
220 | uint8_t r; | |
11fdf7f2 TL |
221 | }; |
222 | ||
223 | /**< Operation structure for Turbo decode. | |
224 | * An operation can perform on one CB at a time "CB-mode". | |
225 | * An operation can perform on one or multiple CBs that are logically belonging | |
226 | * to one TB "TB-mode". | |
227 | * The provided K size parameter of the CB is its size out coming from the | |
228 | * decode operation. | |
229 | * CRC24A/B check is requested by the application by setting the flag | |
230 | * RTE_BBDEV_TURBO_CRC_TYPE_24B for CRC24B check or CRC24A otherwise. | |
231 | * In TB-mode, BBDEV concatenates the decoded CBs one next to the other with | |
232 | * relevant CRC24B in between. | |
233 | * | |
234 | * The input encoded CB data is the Virtual Circular Buffer data stream, wk, | |
235 | * with the null padding included as described in 3GPP TS 36.212 | |
236 | * section 5.1.4.1.2 and shown in 3GPP TS 36.212 section 5.1.4.1 Figure 5.1.4-1. | |
237 | * The size of the virtual circular buffer is 3*Kpi, where Kpi is the 32 byte | |
238 | * aligned value of K, as specified in 3GPP TS 36.212 section 5.1.4.1.1. | |
239 | * | |
240 | * Each byte in the input circular buffer is the LLR value of each bit of the | |
241 | * original CB. | |
242 | * | |
243 | * Hard output is a mandatory capability that all BBDEV PMDs support. This is | |
244 | * the decoded CBs of K sizes (CRC24A/B is the last 24-bit in each decoded CB). | |
245 | * Soft output is an optional capability for BBDEV PMDs. If supported, an LLR | |
246 | * rate matched output is computed in the soft_output buffer structure. | |
247 | * | |
248 | * The output mbuf data structure is expected to be allocated by the | |
249 | * application with enough room for the output data. | |
250 | */ | |
251 | struct rte_bbdev_op_turbo_dec { | |
252 | /**< The Virtual Circular Buffer, wk, size 3*Kpi for each CB */ | |
253 | struct rte_bbdev_op_data input; | |
254 | /**< The hard decisions buffer for the decoded output, | |
255 | * size K for each CB | |
256 | */ | |
257 | struct rte_bbdev_op_data hard_output; | |
258 | /**< The soft LLR output buffer - optional */ | |
259 | struct rte_bbdev_op_data soft_output; | |
260 | ||
261 | uint32_t op_flags; /**< Flags from rte_bbdev_op_td_flag_bitmasks */ | |
262 | uint8_t rv_index; /**< Rv index for rate matching [0:3] */ | |
263 | /**< The minimum number of iterations to perform in decoding all CBs in | |
264 | * this operation - input | |
265 | */ | |
266 | uint8_t iter_min:4; | |
267 | /**< The maximum number of iterations to perform in decoding all CBs in | |
268 | * this operation - input | |
269 | */ | |
270 | uint8_t iter_max:4; | |
271 | /**< The maximum number of iterations that were perform in decoding all | |
272 | * CBs in this decode operation - output | |
273 | */ | |
274 | uint8_t iter_count; | |
275 | /**< 5 bit extrinsic scale (scale factor on extrinsic info) */ | |
276 | uint8_t ext_scale; | |
277 | /**< Number of MAP engines to use in decode, | |
278 | * must be power of 2 (or 0 to auto-select) | |
279 | */ | |
280 | uint8_t num_maps; | |
281 | ||
282 | uint8_t code_block_mode; /**< [0 - TB : 1 - CB] */ | |
283 | union { | |
284 | /**< Struct which stores Code Block specific parameters */ | |
285 | struct rte_bbdev_op_dec_cb_params cb_params; | |
286 | /**< Struct which stores Transport Block specific parameters */ | |
287 | struct rte_bbdev_op_dec_tb_params tb_params; | |
288 | }; | |
289 | }; | |
290 | ||
291 | struct rte_bbdev_op_enc_cb_params { | |
292 | /**< The K size of the input CB, in bits [40:6144], as specified in | |
293 | * 3GPP TS 36.212. | |
294 | * This size is inclusive of CRC24A, regardless whether it was | |
295 | * pre-calculated by the application or not. | |
296 | */ | |
297 | uint16_t k; | |
298 | /**< The E length of the CB rate matched output, in bits, as in | |
299 | * 3GPP TS 36.212. | |
300 | */ | |
301 | uint32_t e; | |
302 | /**< The Ncb soft buffer size of the CB rate matched output [K:3*Kpi], | |
303 | * in bits, as specified in 3GPP TS 36.212. | |
304 | */ | |
305 | uint16_t ncb; | |
306 | }; | |
307 | ||
308 | struct rte_bbdev_op_enc_tb_params { | |
309 | /**< The K- size of the input CB, in bits [40:6144], that is in the | |
310 | * Turbo operation when r < C-, as in 3GPP TS 36.212. | |
311 | * This size is inclusive of CRC24B, regardless whether it was | |
312 | * pre-calculated and appended by the application or not. | |
313 | */ | |
314 | uint16_t k_neg; | |
315 | /**< The K+ size of the input CB, in bits [40:6144], that is in the | |
316 | * Turbo operation when r >= C-, as in 3GPP TS 36.212. | |
317 | * This size is inclusive of CRC24B, regardless whether it was | |
318 | * pre-calculated and appended by the application or not. | |
319 | */ | |
320 | uint16_t k_pos; | |
321 | /**< The number of CBs that have K- size, [0:63] */ | |
322 | uint8_t c_neg; | |
323 | /**< The total number of CBs in the TB, [1:RTE_BBDEV_MAX_CODE_BLOCKS] */ | |
324 | uint8_t c; | |
325 | /**< The number of CBs that uses Ea before switching to Eb, [0:63] */ | |
326 | uint8_t cab; | |
327 | /**< The E size of the CB rate matched output to use in the Turbo | |
328 | * operation when r < cab | |
329 | */ | |
330 | uint32_t ea; | |
331 | /**< The E size of the CB rate matched output to use in the Turbo | |
332 | * operation when r >= cab | |
333 | */ | |
334 | uint32_t eb; | |
335 | /**< The Ncb soft buffer size for the rate matched CB that is used in | |
336 | * the Turbo operation when r < C-, [K:3*Kpi] | |
337 | */ | |
338 | uint16_t ncb_neg; | |
339 | /**< The Ncb soft buffer size for the rate matched CB that is used in | |
340 | * the Turbo operation when r >= C-, [K:3*Kpi] | |
341 | */ | |
342 | uint16_t ncb_pos; | |
343 | /**< The index of the first CB in the inbound mbuf data, default is 0 */ | |
344 | uint8_t r; | |
345 | }; | |
346 | ||
347 | /**< Operation structure for Turbo encode. | |
348 | * An operation can perform on one CB at a time "CB-mode". | |
349 | * An operation can perform on one or multiple CBs that are logically | |
350 | * belonging to one TB "TB-mode". | |
351 | * | |
352 | * In CB-mode, CRC24A/B is an optional operation. K size parameter is not | |
353 | * affected by CRC24A/B inclusion, this only affects the inbound mbuf data | |
354 | * length. Not all BBDEV PMDs are capable of CRC24A/B calculation. Flags | |
355 | * RTE_BBDEV_TURBO_CRC_24A_ATTACH and RTE_BBDEV_TURBO_CRC_24B_ATTACH informs | |
356 | * the application with relevant capability. These flags can be set in the | |
357 | * op_flags parameter to indicate BBDEV to calculate and append CRC24A to CB | |
358 | * before going forward with Turbo encoding. | |
359 | * | |
360 | * In TB-mode, CRC24A is assumed to be pre-calculated and appended to the | |
361 | * inbound TB mbuf data buffer. | |
362 | * | |
363 | * The output mbuf data structure is expected to be allocated by the | |
364 | * application with enough room for the output data. | |
365 | */ | |
366 | struct rte_bbdev_op_turbo_enc { | |
367 | /**< The input CB or TB data */ | |
368 | struct rte_bbdev_op_data input; | |
369 | /**< The rate matched CB or TB output buffer */ | |
370 | struct rte_bbdev_op_data output; | |
371 | ||
372 | uint32_t op_flags; /**< Flags from rte_bbdev_op_te_flag_bitmasks */ | |
373 | uint8_t rv_index; /**< Rv index for rate matching [0:3] */ | |
374 | ||
375 | uint8_t code_block_mode; /**< [0 - TB : 1 - CB] */ | |
376 | union { | |
377 | /**< Struct which stores Code Block specific parameters */ | |
378 | struct rte_bbdev_op_enc_cb_params cb_params; | |
379 | /**< Struct which stores Transport Block specific parameters */ | |
380 | struct rte_bbdev_op_enc_tb_params tb_params; | |
381 | }; | |
382 | }; | |
383 | ||
384 | /**< List of the capabilities for the Turbo Decoder */ | |
385 | struct rte_bbdev_op_cap_turbo_dec { | |
386 | /**< Flags from rte_bbdev_op_td_flag_bitmasks */ | |
387 | uint32_t capability_flags; | |
388 | /** Maximal LLR absolute value. Acceptable LLR values lie in range | |
389 | * [-max_llr_modulus, max_llr_modulus]. | |
390 | */ | |
391 | int8_t max_llr_modulus; | |
392 | uint8_t num_buffers_src; /**< Num input code block buffers */ | |
393 | /**< Num hard output code block buffers */ | |
394 | uint8_t num_buffers_hard_out; | |
395 | /**< Num soft output code block buffers if supported by the driver */ | |
396 | uint8_t num_buffers_soft_out; | |
397 | }; | |
398 | ||
399 | /**< List of the capabilities for the Turbo Encoder */ | |
400 | struct rte_bbdev_op_cap_turbo_enc { | |
401 | /**< Flags from rte_bbdev_op_te_flag_bitmasks */ | |
402 | uint32_t capability_flags; | |
403 | uint8_t num_buffers_src; /**< Num input code block buffers */ | |
404 | uint8_t num_buffers_dst; /**< Num output code block buffers */ | |
405 | }; | |
406 | ||
407 | /** Different operation types supported by the device */ | |
408 | enum rte_bbdev_op_type { | |
409 | RTE_BBDEV_OP_NONE, /**< Dummy operation that does nothing */ | |
410 | RTE_BBDEV_OP_TURBO_DEC, /**< Turbo decode */ | |
411 | RTE_BBDEV_OP_TURBO_ENC, /**< Turbo encode */ | |
412 | RTE_BBDEV_OP_TYPE_COUNT, /**< Count of different op types */ | |
413 | }; | |
414 | ||
415 | /**< Bit indexes of possible errors reported through status field */ | |
416 | enum { | |
417 | RTE_BBDEV_DRV_ERROR, | |
418 | RTE_BBDEV_DATA_ERROR, | |
419 | RTE_BBDEV_CRC_ERROR, | |
420 | }; | |
421 | ||
422 | /**< Structure specifying a single encode operation */ | |
423 | struct rte_bbdev_enc_op { | |
424 | int status; /**< Status of operation that was performed */ | |
425 | struct rte_mempool *mempool; /**< Mempool which op instance is in */ | |
426 | void *opaque_data; /**< Opaque pointer for user data */ | |
427 | /**< Contains encoder specific parameters */ | |
428 | struct rte_bbdev_op_turbo_enc turbo_enc; | |
429 | }; | |
430 | ||
431 | /**< Structure specifying a single decode operation */ | |
432 | struct rte_bbdev_dec_op { | |
433 | int status; /**< Status of operation that was performed */ | |
434 | struct rte_mempool *mempool; /**< Mempool which op instance is in */ | |
435 | void *opaque_data; /**< Opaque pointer for user data */ | |
436 | /**< Contains decoder specific parameters */ | |
437 | struct rte_bbdev_op_turbo_dec turbo_dec; | |
438 | }; | |
439 | ||
440 | /**< Operation capabilities supported by a device */ | |
441 | struct rte_bbdev_op_cap { | |
442 | enum rte_bbdev_op_type type; /**< Type of operation */ | |
443 | union { | |
444 | struct rte_bbdev_op_cap_turbo_dec turbo_dec; | |
445 | struct rte_bbdev_op_cap_turbo_enc turbo_enc; | |
446 | } cap; /**< Operation-type specific capabilities */ | |
447 | }; | |
448 | ||
449 | /**< @internal Private data structure stored with operation pool. */ | |
450 | struct rte_bbdev_op_pool_private { | |
451 | enum rte_bbdev_op_type type; /**< Type of operations in a pool */ | |
452 | }; | |
453 | ||
454 | /** | |
455 | * Converts queue operation type from enum to string | |
456 | * | |
457 | * @param op_type | |
458 | * Operation type as enum | |
459 | * | |
460 | * @returns | |
461 | * Operation type as string or NULL if op_type is invalid | |
462 | * | |
463 | */ | |
9f95a23c | 464 | const char* __rte_experimental |
11fdf7f2 TL |
465 | rte_bbdev_op_type_str(enum rte_bbdev_op_type op_type); |
466 | ||
467 | /** | |
468 | * Creates a bbdev operation mempool | |
469 | * | |
470 | * @param name | |
471 | * Pool name. | |
472 | * @param type | |
473 | * Operation type, use RTE_BBDEV_OP_NONE for a pool which supports all | |
474 | * operation types. | |
475 | * @param num_elements | |
476 | * Number of elements in the pool. | |
477 | * @param cache_size | |
478 | * Number of elements to cache on an lcore, see rte_mempool_create() for | |
479 | * further details about cache size. | |
480 | * @param socket_id | |
481 | * Socket to allocate memory on. | |
482 | * | |
483 | * @return | |
484 | * - Pointer to a mempool on success, | |
485 | * - NULL pointer on failure. | |
486 | */ | |
9f95a23c | 487 | struct rte_mempool * __rte_experimental |
11fdf7f2 TL |
488 | rte_bbdev_op_pool_create(const char *name, enum rte_bbdev_op_type type, |
489 | unsigned int num_elements, unsigned int cache_size, | |
490 | int socket_id); | |
491 | ||
492 | /** | |
493 | * Bulk allocate encode operations from a mempool with parameter defaults reset. | |
494 | * | |
495 | * @param mempool | |
496 | * Operation mempool, created by rte_bbdev_op_pool_create(). | |
497 | * @param ops | |
498 | * Output array to place allocated operations | |
499 | * @param num_ops | |
500 | * Number of operations to allocate | |
501 | * | |
502 | * @returns | |
503 | * - 0 on success | |
504 | * - EINVAL if invalid mempool is provided | |
505 | */ | |
9f95a23c | 506 | static inline int __rte_experimental |
11fdf7f2 TL |
507 | rte_bbdev_enc_op_alloc_bulk(struct rte_mempool *mempool, |
508 | struct rte_bbdev_enc_op **ops, uint16_t num_ops) | |
509 | { | |
510 | struct rte_bbdev_op_pool_private *priv; | |
511 | int ret; | |
512 | ||
513 | /* Check type */ | |
514 | priv = (struct rte_bbdev_op_pool_private *) | |
515 | rte_mempool_get_priv(mempool); | |
516 | if (unlikely(priv->type != RTE_BBDEV_OP_TURBO_ENC)) | |
517 | return -EINVAL; | |
518 | ||
519 | /* Get elements */ | |
520 | ret = rte_mempool_get_bulk(mempool, (void **)ops, num_ops); | |
521 | if (unlikely(ret < 0)) | |
522 | return ret; | |
523 | ||
524 | return 0; | |
525 | } | |
526 | ||
527 | /** | |
528 | * Bulk allocate decode operations from a mempool with parameter defaults reset. | |
529 | * | |
530 | * @param mempool | |
531 | * Operation mempool, created by rte_bbdev_op_pool_create(). | |
532 | * @param ops | |
533 | * Output array to place allocated operations | |
534 | * @param num_ops | |
535 | * Number of operations to allocate | |
536 | * | |
537 | * @returns | |
538 | * - 0 on success | |
539 | * - EINVAL if invalid mempool is provided | |
540 | */ | |
9f95a23c | 541 | static inline int __rte_experimental |
11fdf7f2 TL |
542 | rte_bbdev_dec_op_alloc_bulk(struct rte_mempool *mempool, |
543 | struct rte_bbdev_dec_op **ops, uint16_t num_ops) | |
544 | { | |
545 | struct rte_bbdev_op_pool_private *priv; | |
546 | int ret; | |
547 | ||
548 | /* Check type */ | |
549 | priv = (struct rte_bbdev_op_pool_private *) | |
550 | rte_mempool_get_priv(mempool); | |
551 | if (unlikely(priv->type != RTE_BBDEV_OP_TURBO_DEC)) | |
552 | return -EINVAL; | |
553 | ||
554 | /* Get elements */ | |
555 | ret = rte_mempool_get_bulk(mempool, (void **)ops, num_ops); | |
556 | if (unlikely(ret < 0)) | |
557 | return ret; | |
558 | ||
559 | return 0; | |
560 | } | |
561 | ||
562 | /** | |
563 | * Free decode operation structures that were allocated by | |
564 | * rte_bbdev_dec_op_alloc_bulk(). | |
565 | * All structures must belong to the same mempool. | |
566 | * | |
567 | * @param ops | |
568 | * Operation structures | |
569 | * @param num_ops | |
570 | * Number of structures | |
571 | */ | |
9f95a23c | 572 | static inline void __rte_experimental |
11fdf7f2 TL |
573 | rte_bbdev_dec_op_free_bulk(struct rte_bbdev_dec_op **ops, unsigned int num_ops) |
574 | { | |
575 | if (num_ops > 0) | |
576 | rte_mempool_put_bulk(ops[0]->mempool, (void **)ops, num_ops); | |
577 | } | |
578 | ||
579 | /** | |
580 | * Free encode operation structures that were allocated by | |
581 | * rte_bbdev_enc_op_alloc_bulk(). | |
582 | * All structures must belong to the same mempool. | |
583 | * | |
584 | * @param ops | |
585 | * Operation structures | |
586 | * @param num_ops | |
587 | * Number of structures | |
588 | */ | |
9f95a23c | 589 | static inline void __rte_experimental |
11fdf7f2 TL |
590 | rte_bbdev_enc_op_free_bulk(struct rte_bbdev_enc_op **ops, unsigned int num_ops) |
591 | { | |
592 | if (num_ops > 0) | |
593 | rte_mempool_put_bulk(ops[0]->mempool, (void **)ops, num_ops); | |
594 | } | |
595 | ||
596 | #ifdef __cplusplus | |
597 | } | |
598 | #endif | |
599 | ||
600 | #endif /* _RTE_BBDEV_OP_H_ */ |