1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2014-2021 Broadcom 3 * All rights reserved. 4 */ 5 6 #ifndef _ULP_UTILS_H_ 7 #define _ULP_UTILS_H_ 8 9 #include "bnxt.h" 10 #include "ulp_template_db_enum.h" 11 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 16 /* 17 * Macros for bitmap sets and gets 18 * These macros can be used if the val are power of 2. 19 */ 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)) 25 /* 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. 29 */ 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))) 34 35 #define ULP_INDEX_BITMAP_SET(b, i) ((b) |= \ 36 (1UL << ((ULP_INDEX_BITMAP_SIZE - 1) - \ 37 ((i) % ULP_INDEX_BITMAP_SIZE)))) 38 39 #define ULP_INDEX_BITMAP_RESET(b, i) ((b) &= \ 40 (~(1UL << ((ULP_INDEX_BITMAP_SIZE - 1) - \ 41 ((i) % ULP_INDEX_BITMAP_SIZE))))) 42 43 #define ULP_INDEX_BITMAP_GET(b, i) (((b) >> \ 44 ((ULP_INDEX_BITMAP_SIZE - 1) - \ 45 ((i) % ULP_INDEX_BITMAP_SIZE))) & 1) 46 47 #define ULP_DEVICE_PARAMS_INDEX(tid, dev_id) \ 48 (((tid) << BNXT_ULP_LOG2_MAX_NUM_DEV) | (dev_id)) 49 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) 56 57 /* Macro to round off to next multiple of 8*/ 58 #define ULP_BYTE_ROUND_OFF_8(x) (((x) + 7) & ~7) 59 60 /* Macro to check bits are byte aligned */ 61 #define ULP_BITS_IS_BYTE_NOT_ALIGNED(x) ((x) % 8) 62 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)]) 66 67 #define ULP_COMP_FLD_IDX_WR(params, idx, val) \ 68 ((params)->comp_fld[(idx)] = rte_cpu_to_be_32((val))) 69 /* 70 * Making the blob statically sized to 128 bytes for now. 71 * The blob must be initialized with ulp_blob_init prior to using. 72 */ 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) 75 struct ulp_blob { 76 enum bnxt_ulp_byte_order byte_order; 77 uint16_t write_idx; 78 uint16_t bitlen; 79 uint8_t data[BNXT_ULP_FLMP_BLOB_SIZE]; 80 uint16_t encap_swap_idx; 81 }; 82 83 /* 84 * The data can likely be only 32 bits for now. Just size check 85 * the data when being written. 86 */ 87 #define ULP_REGFILE_ENTRY_SIZE (sizeof(uint32_t)) 88 struct ulp_regfile_entry { 89 uint64_t data; 90 uint32_t size; 91 }; 92 93 struct ulp_regfile { 94 struct ulp_regfile_entry entry[BNXT_ULP_REGFILE_INDEX_LAST]; 95 }; 96 97 /* 98 * Initialize the regfile structure for writing 99 * 100 * regfile [in] Ptr to a regfile instance 101 * 102 * returns 0 on error or 1 on success 103 */ 104 uint32_t 105 ulp_regfile_init(struct ulp_regfile *regfile); 106 107 /* 108 * Read a value from the regfile 109 * 110 * regfile [in] The regfile instance. Must be initialized prior to being used 111 * 112 * field [in] The field to be read within the regfile. 113 * 114 * returns the byte array 115 */ 116 uint32_t 117 ulp_regfile_read(struct ulp_regfile *regfile, 118 enum bnxt_ulp_regfile_index field, 119 uint64_t *data); 120 121 /* 122 * Write a value to the regfile 123 * 124 * regfile [in] The regfile instance. Must be initialized prior to being used 125 * 126 * field [in] The field to be written within the regfile. 127 * 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. 130 * 131 * returns zero on error 132 */ 133 uint32_t 134 ulp_regfile_write(struct ulp_regfile *regfile, 135 enum bnxt_ulp_regfile_index field, 136 uint64_t data); 137 138 /* 139 * Initializes the blob structure for creating binary blob 140 * 141 * blob [in] The blob to be initialized 142 * 143 * bitlen [in] The bit length of the blob 144 * 145 * order [in] The byte order for the blob. Currently only supporting 146 * big endian. All fields are packed with this order. 147 * 148 * returns 0 on error or 1 on success 149 */ 150 uint32_t 151 ulp_blob_init(struct ulp_blob *blob, 152 uint16_t bitlen, 153 enum bnxt_ulp_byte_order order); 154 155 /* 156 * Add data to the binary blob at the current offset. 157 * 158 * blob [in] The blob that data is added to. The blob must 159 * be initialized prior to pushing data. 160 * 161 * data [in] A pointer to bytes to be added to the blob. 162 * 163 * datalen [in] The number of bits to be added to the blob. 164 * 165 * The offset of the data is updated after each push of data. 166 * NULL returned on error. 167 */ 168 uint32_t 169 ulp_blob_push(struct ulp_blob *blob, 170 uint8_t *data, 171 uint32_t datalen); 172 173 /* 174 * Insert data into the binary blob at the given offset. 175 * 176 * blob [in] The blob that data is added to. The blob must 177 * be initialized prior to pushing data. 178 * 179 * offset [in] The offset where the data needs to be inserted. 180 * 181 * data [in/out] A pointer to bytes to be added to the blob. 182 * 183 * datalen [in] The number of bits to be added to the blob. 184 * 185 * The offset of the data is updated after each push of data. 186 * NULL returned on error. 187 */ 188 uint32_t 189 ulp_blob_insert(struct ulp_blob *blob, uint32_t offset, 190 uint8_t *data, uint32_t datalen); 191 192 /* 193 * Add data to the binary blob at the current offset. 194 * 195 * blob [in] The blob that data is added to. The blob must 196 * be initialized prior to pushing data. 197 * 198 * data [in] 64-bit value to be added to the blob. 199 * 200 * datalen [in] The number of bits to be added to the blob. 201 * 202 * The offset of the data is updated after each push of data. 203 * NULL returned on error, ptr to pushed data otherwise 204 */ 205 uint8_t * 206 ulp_blob_push_64(struct ulp_blob *blob, 207 uint64_t *data, 208 uint32_t datalen); 209 210 /* 211 * Add data to the binary blob at the current offset. 212 * 213 * blob [in] The blob that data is added to. The blob must 214 * be initialized prior to pushing data. 215 * 216 * data [in] 32-bit value to be added to the blob. 217 * 218 * datalen [in] The number of bits to be added ot the blob. 219 * 220 * The offset of the data is updated after each push of data. 221 * NULL returned on error, pointer pushed value otherwise. 222 */ 223 uint8_t * 224 ulp_blob_push_32(struct ulp_blob *blob, 225 uint32_t *data, 226 uint32_t datalen); 227 228 /* 229 * Add encap data to the binary blob at the current offset. 230 * 231 * blob [in] The blob that data is added to. The blob must 232 * be initialized prior to pushing data. 233 * 234 * data [in] value to be added to the blob. 235 * 236 * datalen [in] The number of bits to be added to the blob. 237 * 238 * The offset of the data is updated after each push of data. 239 * NULL returned on error, pointer pushed value otherwise. 240 */ 241 uint32_t 242 ulp_blob_push_encap(struct ulp_blob *blob, 243 uint8_t *data, 244 uint32_t datalen); 245 246 /* 247 * Get the data portion of the binary blob. 248 * 249 * blob [in] The blob's data to be retrieved. The blob must be 250 * initialized prior to pushing data. 251 * 252 * datalen [out] The number of bits to that are filled. 253 * 254 * returns a byte array of the blob data. Returns NULL on error. 255 */ 256 uint8_t * 257 ulp_blob_data_get(struct ulp_blob *blob, 258 uint16_t *datalen); 259 260 /* 261 * Extract data from the binary blob using given offset. 262 * 263 * blob [in] The blob that data is extracted from. The blob must 264 * be initialized prior to pulling data. 265 * 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. 270 * 271 * Output: zero on success, -1 on failure 272 */ 273 int32_t 274 ulp_blob_pull(struct ulp_blob *blob, uint8_t *data, uint32_t data_size, 275 uint16_t offset, uint16_t len); 276 277 /* 278 * Adds pad to an initialized blob at the current offset 279 * 280 * blob [in] The blob that data is added to. The blob must 281 * be initialized prior to pushing data. 282 * 283 * datalen [in] The number of bits of pad to add 284 * 285 * returns the number of pad bits added, -1 on failure 286 */ 287 int32_t 288 ulp_blob_pad_push(struct ulp_blob *blob, 289 uint32_t datalen); 290 291 /* 292 * Set the 64 bit swap start index of the binary blob. 293 * 294 * blob [in] The blob's data to be retrieved. The blob must be 295 * initialized prior to pushing data. 296 * 297 * returns void. 298 */ 299 void 300 ulp_blob_encap_swap_idx_set(struct ulp_blob *blob); 301 302 /* 303 * Perform the encap buffer swap to 64 bit reversal. 304 * 305 * blob [in] The blob's data to be used for swap. 306 * 307 * returns void. 308 */ 309 void 310 ulp_blob_perform_encap_swap(struct ulp_blob *blob); 311 312 /* 313 * Perform the blob buffer reversal byte wise. 314 * This api makes the first byte the last and 315 * vice-versa. 316 * 317 * blob [in] The blob's data to be used for swap. 318 * 319 * returns void. 320 */ 321 void 322 ulp_blob_perform_byte_reverse(struct ulp_blob *blob); 323 324 /* 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. 328 * 329 * blob [in] The blob's data to be used for swap. 330 * 331 * returns void. 332 */ 333 void 334 ulp_blob_perform_64B_word_swap(struct ulp_blob *blob); 335 336 /* 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. 340 * 341 * blob [in] The blob's data to be used for swap. 342 * 343 * returns void. 344 */ 345 void 346 ulp_blob_perform_64B_byte_swap(struct ulp_blob *blob); 347 348 /* 349 * Read data from the operand 350 * 351 * operand [in] A pointer to a 16 Byte operand 352 * 353 * val [in/out] The variable to copy the operand to 354 * 355 * bitlen [in] The number of bits to read into val 356 * 357 * returns number of bits read, zero on error 358 */ 359 uint16_t 360 ulp_operand_read(uint8_t *operand, 361 uint8_t *val, 362 uint16_t bitlen); 363 364 /* 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. 367 * 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. 372 */ 373 void 374 ulp_encap_buffer_copy(uint8_t *dst, 375 const uint8_t *src, 376 uint16_t size, 377 uint16_t align); 378 379 /* 380 * Check the buffer is empty 381 * 382 * buf [in] The buffer 383 * size [in] The size of the buffer 384 */ 385 int32_t ulp_buffer_is_empty(const uint8_t *buf, uint32_t size); 386 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); 389 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); 392 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); 395 396 #endif /* _ULP_UTILS_H_ */ 397