1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2014-2021 Broadcom
10 #include "ulp_template_db_enum.h"
12 #define ULP_BUFFER_ALIGN_8_BYTE 8
13 #define ULP_BUFFER_ALIGN_16_BYTE 16
14 #define ULP_BUFFER_ALIGN_64_BYTE 64
15 #define ULP_64B_IN_BYTES 8
17 * Macros for bitmap sets and gets
18 * These macros can be used if the val are power of 2.
20 #define ULP_BITMAP_SET(bitmap, val) ((bitmap) |= (val))
21 #define ULP_BITMAP_RESET(bitmap, val) ((bitmap) &= ~(val))
22 #define ULP_BITMAP_ISSET(bitmap, val) ((bitmap) & (val))
23 #define ULP_BITMAP_CMP(b1, b2) memcmp(&(b1)->bits, \
24 &(b2)->bits, sizeof((b1)->bits))
26 * Macros for bitmap sets and gets
27 * These macros can be used if the val are not power of 2 and
28 * are simple index values.
30 #define ULP_INDEX_BITMAP_SIZE (sizeof(uint64_t) * 8)
31 #define ULP_INDEX_BITMAP_CSET(i) (1UL << \
32 ((ULP_INDEX_BITMAP_SIZE - 1) - \
33 ((i) % ULP_INDEX_BITMAP_SIZE)))
35 #define ULP_INDEX_BITMAP_SET(b, i) ((b) |= \
36 (1UL << ((ULP_INDEX_BITMAP_SIZE - 1) - \
37 ((i) % ULP_INDEX_BITMAP_SIZE))))
39 #define ULP_INDEX_BITMAP_RESET(b, i) ((b) &= \
40 (~(1UL << ((ULP_INDEX_BITMAP_SIZE - 1) - \
41 ((i) % ULP_INDEX_BITMAP_SIZE)))))
43 #define ULP_INDEX_BITMAP_GET(b, i) (((b) >> \
44 ((ULP_INDEX_BITMAP_SIZE - 1) - \
45 ((i) % ULP_INDEX_BITMAP_SIZE))) & 1)
47 #define ULP_DEVICE_PARAMS_INDEX(tid, dev_id) \
48 (((tid) << BNXT_ULP_LOG2_MAX_NUM_DEV) | (dev_id))
50 /* Macro to convert bytes to bits */
51 #define ULP_BYTE_2_BITS(byte_x) ((byte_x) * 8)
52 /* Macro to convert bits to bytes */
53 #define ULP_BITS_2_BYTE(bits_x) (((bits_x) + 7) / 8)
54 /* Macro to convert bits to bytes with no round off*/
55 #define ULP_BITS_2_BYTE_NR(bits_x) ((bits_x) / 8)
57 /* Macro to round off to next multiple of 8*/
58 #define ULP_BYTE_ROUND_OFF_8(x) (((x) + 7) & ~7)
60 /* Macro to check bits are byte aligned */
61 #define ULP_BITS_IS_BYTE_NOT_ALIGNED(x) ((x) % 8)
63 /* Macros to read the computed fields */
64 #define ULP_COMP_FLD_IDX_RD(params, idx) \
65 rte_be_to_cpu_32((params)->comp_fld[(idx)])
67 #define ULP_COMP_FLD_IDX_WR(params, idx, val) \
68 ((params)->comp_fld[(idx)] = rte_cpu_to_be_32((val)))
70 * Making the blob statically sized to 128 bytes for now.
71 * The blob must be initialized with ulp_blob_init prior to using.
73 #define BNXT_ULP_FLMP_BLOB_SIZE (128)
74 #define BNXT_ULP_FLMP_BLOB_SIZE_IN_BITS ULP_BYTE_2_BITS(BNXT_ULP_FLMP_BLOB_SIZE)
76 enum bnxt_ulp_byte_order byte_order;
79 uint8_t data[BNXT_ULP_FLMP_BLOB_SIZE];
80 uint16_t encap_swap_idx;
84 * The data can likely be only 32 bits for now. Just size check
85 * the data when being written.
87 #define ULP_REGFILE_ENTRY_SIZE (sizeof(uint32_t))
88 struct ulp_regfile_entry {
94 struct ulp_regfile_entry entry[BNXT_ULP_REGFILE_INDEX_LAST];
98 * Initialize the regfile structure for writing
100 * regfile [in] Ptr to a regfile instance
102 * returns 0 on error or 1 on success
105 ulp_regfile_init(struct ulp_regfile *regfile);
108 * Read a value from the regfile
110 * regfile [in] The regfile instance. Must be initialized prior to being used
112 * field [in] The field to be read within the regfile.
114 * returns the byte array
117 ulp_regfile_read(struct ulp_regfile *regfile,
118 enum bnxt_ulp_regfile_index field,
122 * Write a value to the regfile
124 * regfile [in] The regfile instance. Must be initialized prior to being used
126 * field [in] The field to be written within the regfile.
128 * data [in] The value is written into this variable. It is going to be in the
129 * same byte order as it was written.
131 * returns zero on error
134 ulp_regfile_write(struct ulp_regfile *regfile,
135 enum bnxt_ulp_regfile_index field,
139 * Initializes the blob structure for creating binary blob
141 * blob [in] The blob to be initialized
143 * bitlen [in] The bit length of the blob
145 * order [in] The byte order for the blob. Currently only supporting
146 * big endian. All fields are packed with this order.
148 * returns 0 on error or 1 on success
151 ulp_blob_init(struct ulp_blob *blob,
153 enum bnxt_ulp_byte_order order);
156 * Add data to the binary blob at the current offset.
158 * blob [in] The blob that data is added to. The blob must
159 * be initialized prior to pushing data.
161 * data [in] A pointer to bytes to be added to the blob.
163 * datalen [in] The number of bits to be added to the blob.
165 * The offset of the data is updated after each push of data.
166 * NULL returned on error.
169 ulp_blob_push(struct ulp_blob *blob,
174 * Insert data into the binary blob at the given offset.
176 * blob [in] The blob that data is added to. The blob must
177 * be initialized prior to pushing data.
179 * offset [in] The offset where the data needs to be inserted.
181 * data [in/out] A pointer to bytes to be added to the blob.
183 * datalen [in] The number of bits to be added to the blob.
185 * The offset of the data is updated after each push of data.
186 * NULL returned on error.
189 ulp_blob_insert(struct ulp_blob *blob, uint32_t offset,
190 uint8_t *data, uint32_t datalen);
193 * Add data to the binary blob at the current offset.
195 * blob [in] The blob that data is added to. The blob must
196 * be initialized prior to pushing data.
198 * data [in] 64-bit value to be added to the blob.
200 * datalen [in] The number of bits to be added to the blob.
202 * The offset of the data is updated after each push of data.
203 * NULL returned on error, ptr to pushed data otherwise
206 ulp_blob_push_64(struct ulp_blob *blob,
211 * Add data to the binary blob at the current offset.
213 * blob [in] The blob that data is added to. The blob must
214 * be initialized prior to pushing data.
216 * data [in] 32-bit value to be added to the blob.
218 * datalen [in] The number of bits to be added ot the blob.
220 * The offset of the data is updated after each push of data.
221 * NULL returned on error, pointer pushed value otherwise.
224 ulp_blob_push_32(struct ulp_blob *blob,
229 * Add encap data to the binary blob at the current offset.
231 * blob [in] The blob that data is added to. The blob must
232 * be initialized prior to pushing data.
234 * data [in] value to be added to the blob.
236 * datalen [in] The number of bits to be added to the blob.
238 * The offset of the data is updated after each push of data.
239 * NULL returned on error, pointer pushed value otherwise.
242 ulp_blob_push_encap(struct ulp_blob *blob,
247 * Get the data portion of the binary blob.
249 * blob [in] The blob's data to be retrieved. The blob must be
250 * initialized prior to pushing data.
252 * datalen [out] The number of bits to that are filled.
254 * returns a byte array of the blob data. Returns NULL on error.
257 ulp_blob_data_get(struct ulp_blob *blob,
261 * Extract data from the binary blob using given offset.
263 * blob [in] The blob that data is extracted from. The blob must
264 * be initialized prior to pulling data.
266 * data [in] A pointer to put the data.
267 * data_size [in] size of the data buffer in bytes.
268 *offset [in] - Offset in the blob to extract the data in bits format.
269 * len [in] The number of bits to be pulled from the blob.
271 * Output: zero on success, -1 on failure
274 ulp_blob_pull(struct ulp_blob *blob, uint8_t *data, uint32_t data_size,
275 uint16_t offset, uint16_t len);
278 * Adds pad to an initialized blob at the current offset
280 * blob [in] The blob that data is added to. The blob must
281 * be initialized prior to pushing data.
283 * datalen [in] The number of bits of pad to add
285 * returns the number of pad bits added, -1 on failure
288 ulp_blob_pad_push(struct ulp_blob *blob,
292 * Set the 64 bit swap start index of the binary blob.
294 * blob [in] The blob's data to be retrieved. The blob must be
295 * initialized prior to pushing data.
300 ulp_blob_encap_swap_idx_set(struct ulp_blob *blob);
303 * Perform the encap buffer swap to 64 bit reversal.
305 * blob [in] The blob's data to be used for swap.
310 ulp_blob_perform_encap_swap(struct ulp_blob *blob);
313 * Perform the blob buffer reversal byte wise.
314 * This api makes the first byte the last and
317 * blob [in] The blob's data to be used for swap.
322 ulp_blob_perform_byte_reverse(struct ulp_blob *blob);
325 * Perform the blob buffer 64 bit word swap.
326 * This api makes the first 4 bytes the last in
327 * a given 64 bit value and vice-versa.
329 * blob [in] The blob's data to be used for swap.
334 ulp_blob_perform_64B_word_swap(struct ulp_blob *blob);
337 * Perform the blob buffer 64 bit byte swap.
338 * This api makes the first byte the last in
339 * a given 64 bit value and vice-versa.
341 * blob [in] The blob's data to be used for swap.
346 ulp_blob_perform_64B_byte_swap(struct ulp_blob *blob);
349 * Read data from the operand
351 * operand [in] A pointer to a 16 Byte operand
353 * val [in/out] The variable to copy the operand to
355 * bitlen [in] The number of bits to read into val
357 * returns number of bits read, zero on error
360 ulp_operand_read(uint8_t *operand,
365 * copy the buffer in the encap format which is 2 bytes.
366 * The MSB of the src is placed at the LSB of dst.
368 * dst [out] The destination buffer
369 * src [in] The source buffer dst
370 * size[in] size of the buffer.
371 * align[in] The alignment is either 8 or 16.
374 ulp_encap_buffer_copy(uint8_t *dst,
380 * Check the buffer is empty
382 * buf [in] The buffer
383 * size [in] The size of the buffer
385 int32_t ulp_buffer_is_empty(const uint8_t *buf, uint32_t size);
387 /* Function to check if bitmap is zero.Return 1 on success */
388 uint32_t ulp_bitmap_is_zero(uint8_t *bitmap, int32_t size);
390 /* Function to check if bitmap is ones. Return 1 on success */
391 uint32_t ulp_bitmap_is_ones(uint8_t *bitmap, int32_t size);
393 /* Function to check if bitmap is not zero. Return 1 on success */
394 uint32_t ulp_bitmap_notzero(uint8_t *bitmap, int32_t size);
396 #endif /* _ULP_UTILS_H_ */