drivers/net/bnxt/tf_ulp/ulp_utils.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2014-2019 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_ */