drivers/net/bnxt/hcapi/cfa/hcapi_cfa_defs.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2019-2021 Broadcom
   3  * All rights reserved.
   4  */
   5
   6 /*!
   7  *   \file
   8  *   \brief Exported functions for CFA HW programming
   9  */
  10 #ifndef _HCAPI_CFA_DEFS_H_
  11 #define _HCAPI_CFA_DEFS_H_
  12
  13 #include <stdio.h>
  14 #include <string.h>
  15 #include <stdbool.h>
  16 #include <stddef.h>
  17 #include <stdint.h>
  18
  19 #if !defined(__GNUC__)
  20 #pragma anon_unions
  21 #endif
  22
  23 #define CFA_BITS_PER_BYTE (8)
  24 #define CFA_BITS_PER_WORD (sizeof(uint32_t) * CFA_BITS_PER_BYTE)
  25 #define __CFA_ALIGN_MASK(x, mask) (((x) + (mask)) & ~(mask))
  26 #define CFA_ALIGN(x, a) __CFA_ALIGN_MASK((x), (a) - 1)
  27 #define CFA_ALIGN_256(x) CFA_ALIGN(x, 256)
  28 #define CFA_ALIGN_128(x) CFA_ALIGN(x, 128)
  29 #define CFA_ALIGN_32(x) CFA_ALIGN(x, 32)
  30
  31 #define NUM_WORDS_ALIGN_32BIT(x) (CFA_ALIGN_32(x) / CFA_BITS_PER_WORD)
  32 #define NUM_WORDS_ALIGN_128BIT(x) (CFA_ALIGN_128(x) / CFA_BITS_PER_WORD)
  33 #define NUM_WORDS_ALIGN_256BIT(x) (CFA_ALIGN_256(x) / CFA_BITS_PER_WORD)
  34
  35 /* TODO: redefine according to chip variant */
  36 #define CFA_GLOBAL_CFG_DATA_SZ (100)
  37
  38 #ifndef SUPPORT_CFA_HW_P4
  39 #define SUPPORT_CFA_HW_P4 (0)
  40 #endif
  41
  42 #ifndef SUPPORT_CFA_HW_P45
  43 #define SUPPORT_CFA_HW_P45 (0)
  44 #endif
  45
  46 #ifndef SUPPORT_CFA_HW_P58
  47 #define SUPPORT_CFA_HW_P58 (0)
  48 #endif
  49
  50 #if SUPPORT_CFA_HW_ALL
  51 #include "hcapi_cfa_p4.h"
  52 #include "hcapi_cfa_p58.h"
  53 #endif /* SUPPORT_CFA_HW_ALL */
  54
  55 /*
  56  * Hashing defines
  57  */
  58 #define HCAPI_CFA_LKUP_SEED_MEM_SIZE 512
  59
  60 /* CRC32i support for Key0 hash */
  61 #define ucrc32(ch, crc) (crc32tbl[((crc) ^ (ch)) & 0xff] ^ ((crc) >> 8))
  62 #define crc32(x, y) crc32i(~0, x, y)
  63
  64 /**
  65  * CFA HW version definition
  66  */
  67 enum hcapi_cfa_ver {
  68         HCAPI_CFA_P40 = 0, /**< CFA phase 4.0 */
  69         HCAPI_CFA_P45 = 1, /**< CFA phase 4.5 */
  70         HCAPI_CFA_P58 = 2, /**< CFA phase 5.8 */
  71         HCAPI_CFA_PMAX = 3
  72 };
  73
  74 /**
  75  * CFA direction definition
  76  */
  77 enum hcapi_cfa_dir {
  78         HCAPI_CFA_DIR_RX = 0, /**< Receive */
  79         HCAPI_CFA_DIR_TX = 1, /**< Transmit */
  80         HCAPI_CFA_DIR_MAX = 2
  81 };
  82
  83 /**
  84  * CFA HW OPCODE definition
  85  */
  86 enum hcapi_cfa_hwops {
  87         HCAPI_CFA_HWOPS_PUT,   /**< Write to HW operation */
  88         HCAPI_CFA_HWOPS_GET,   /**< Read from HW operation */
  89         HCAPI_CFA_HWOPS_ADD,   /*<
  90                                 * For operations which require more then
  91                                 * simple writes to HW, this operation is
  92                                 * used.  The distinction with this operation
  93                                 * when compared to the PUT ops is that this
  94                                 * operation is used in conjunction with
  95                                 * the HCAPI_CFA_HWOPS_DEL op to remove
  96                                 * the operations issued by the ADD OP.
  97                                 */
  98         HCAPI_CFA_HWOPS_DEL,   /*<
  99                                 *  Beside to delete from the hardware, this
 100                                 *   operation is also undo the add operation
 101                                 *   performed by the HCAPI_CFA_HWOPS_ADD op.
 102                                 */
 103         HCAPI_CFA_HWOPS_EVICT, /*< This operation is used to evict entries from
 104                                 *   CFA cache memories. This operation is only
 105                                 *   applicable to tables that use CFA caches.
 106                                 */
 107         HCAPI_CFA_HWOPS_MAX
 108 };
 109
 110 /**
 111  * CFA HW KEY CONTROL OPCODE definition
 112  */
 113 enum hcapi_cfa_key_ctrlops {
 114         HCAPI_CFA_KEY_CTRLOPS_INSERT, /**< insert control bits */
 115         HCAPI_CFA_KEY_CTRLOPS_STRIP,  /**< strip control bits */
 116         HCAPI_CFA_KEY_CTRLOPS_MAX
 117 };
 118
 119 /**
 120  * CFA HW definition
 121  */
 122 struct hcapi_cfa_hw {
 123         /** [in] HW table base address for the operation with optional device
 124          *  handle. For on-chip HW table operation, this is the either the TX
 125          *  or RX CFA HW base address. For off-chip table, this field is the
 126          *  base memory address of the off-chip table.
 127          */
 128         uint64_t base_addr;
 129         /** [in] Optional opaque device handle. It is generally used to access
 130          *  an GRC register space through PCIE BAR and passed to the BAR memory
 131          *  accessor routine.
 132          */
 133         void *handle;
 134 };
 135
 136 /**
 137  * CFA HW operation definition
 138  *
 139  */
 140 struct hcapi_cfa_hwop {
 141         /** [in] HW opcode */
 142         enum hcapi_cfa_hwops opcode;
 143         /** [in] CFA HW information used by accessor routines.
 144          */
 145         struct hcapi_cfa_hw hw;
 146 };
 147
 148 /**
 149  * CFA HW data structure definition
 150  */
 151 struct hcapi_cfa_data {
 152         /** [in] physical offset to the HW table for the data to be
 153          *  written to.  If this is an array of registers, this is the
 154          *  index into the array of registers.  For writing keys, this
 155          *  is the byte pointer into the memory where the key should be
 156          *  written.
 157          */
 158         union {
 159                 uint32_t index;
 160                 uint32_t byte_offset;
 161         };
 162         /** [in] HW data buffer pointer */
 163         uint8_t *data;
 164         /** [in] HW data mask buffer pointer.
 165          *  When the CFA data is a FKB and  data_mask pointer
 166          *  is NULL, then the default mask to enable all bit will
 167          *  be used.
 168          */
 169         uint8_t *data_mask;
 170         /** [in/out] size of the HW data buffer in bytes
 171          */
 172         uint16_t data_sz;
 173 };
 174
 175 /*********************** Truflow start ***************************/
 176 enum hcapi_cfa_pg_tbl_lvl {
 177         TF_PT_LVL_0,
 178         TF_PT_LVL_1,
 179         TF_PT_LVL_2,
 180         TF_PT_LVL_MAX
 181 };
 182
 183 enum hcapi_cfa_em_table_type {
 184         TF_KEY0_TABLE,
 185         TF_KEY1_TABLE,
 186         TF_RECORD_TABLE,
 187         TF_EFC_TABLE,
 188         TF_ACTION_TABLE,
 189         TF_EM_LKUP_TABLE,
 190         TF_MAX_TABLE
 191 };
 192
 193 struct hcapi_cfa_em_page_tbl {
 194         uint32_t pg_count;
 195         uint32_t pg_size;
 196         void **pg_va_tbl;
 197         uint64_t *pg_pa_tbl;
 198 };
 199
 200 struct hcapi_cfa_em_table {
 201         int type;
 202         uint32_t num_entries;
 203         uint16_t ctx_id;
 204         uint32_t entry_size;
 205         int num_lvl;
 206         uint32_t page_cnt[TF_PT_LVL_MAX];
 207         uint64_t num_data_pages;
 208         void *l0_addr;
 209         uint64_t l0_dma_addr;
 210         struct hcapi_cfa_em_page_tbl pg_tbl[TF_PT_LVL_MAX];
 211 };
 212
 213 struct hcapi_cfa_em_ctx_mem_info {
 214         struct hcapi_cfa_em_table em_tables[TF_MAX_TABLE];
 215 };
 216
 217 /*********************** Truflow end ****************************/
 218 /**
 219  * CFA HW key table definition
 220  *
 221  * Applicable to EEM and off-chip EM table only.
 222  */
 223 struct hcapi_cfa_key_tbl {
 224         /** [in] For EEM, this is the KEY0 base mem pointer. For off-chip EM,
 225          *  this is the base mem pointer of the key table.
 226          */
 227         uint8_t *base0;
 228         /** [in] total size of the key table in bytes. For EEM, this size is
 229          *  same for both KEY0 and KEY1 table.
 230          */
 231         uint32_t size;
 232         /** [in] number of key buckets, applicable for newer chips */
 233         uint32_t num_buckets;
 234         /** [in] For EEM, this is KEY1 base mem pointer. For off-chip EM,
 235          *  this is the key record memory base pointer within the key table,
 236          *  applicable for newer chip
 237          */
 238         uint8_t *base1;
 239         /** [in] Optional - If the table is managed by a Backing Store
 240          *  database, then this object can be use to configure the EM Key.
 241          */
 242         struct hcapi_cfa_bs_db *bs_db;
 243         /** [in] Page size for EEM tables */
 244         uint32_t page_size;
 245 };
 246
 247 /**
 248  * CFA HW key buffer definition
 249  */
 250 struct hcapi_cfa_key_obj {
 251         /** [in] pointer to the key data buffer */
 252         uint32_t *data;
 253         /** [in] buffer len in bytes */
 254         uint32_t len;
 255         /** [in] Pointer to the key layout */
 256         struct hcapi_cfa_key_layout *layout;
 257 };
 258
 259 /**
 260  * CFA HW key data definition
 261  */
 262 struct hcapi_cfa_key_data {
 263         /** [in] For on-chip key table, it is the offset in unit of smallest
 264          *  key. For off-chip key table, it is the byte offset relative
 265          *  to the key record memory base and adjusted for page and entry size.
 266          */
 267         uint32_t offset;
 268         /** [in] HW key data buffer pointer */
 269         uint8_t *data;
 270         /** [in] size of the key in bytes */
 271         uint16_t size;
 272         /** [in] optional table scope ID */
 273         uint8_t tbl_scope;
 274         /** [in] the fid owner of the key */
 275         uint64_t metadata;
 276         /** [in] stored with the bucket which can be used by
 277          *       the caller to retrieve later via the GET HW OP.
 278          */
 279 };
 280
 281 /**
 282  * CFA HW key location definition
 283  */
 284 struct hcapi_cfa_key_loc {
 285         /** [out] on-chip EM bucket offset or off-chip EM bucket mem pointer */
 286         uint64_t bucket_mem_ptr;
 287         /** [out] off-chip EM key offset mem pointer */
 288         uint64_t mem_ptr;
 289         /** [out] index within the array of the EM buckets */
 290         uint32_t bucket_mem_idx;
 291         /** [out] index within the EM bucket */
 292         uint8_t bucket_idx;
 293         /** [out] index within the EM records */
 294         uint32_t mem_idx;
 295 };
 296
 297 /**
 298  *  Action record info
 299  */
 300 struct hcapi_cfa_action_addr {
 301         /** [in] action SRAM block ID for on-chip action records or table
 302          *  scope of the action backing store
 303          */
 304         uint16_t blk_id;
 305         /** [in] ar_id or cache line aligned address offset for the action
 306          *  record
 307          */
 308         uint32_t offset;
 309 };
 310
 311 /**
 312  * Action data definition
 313  */
 314 struct hcapi_cfa_action_data {
 315         /** [in] action record addr info for on-chip action records */
 316         struct hcapi_cfa_action_addr addr;
 317         /** [in/out] pointer to the action data buffer */
 318         uint32_t *data;
 319         /** [in] action data buffer len in bytes */
 320         uint32_t len;
 321 };
 322
 323 /**
 324  * Action object definition
 325  */
 326 struct hcapi_cfa_action_obj {
 327         /** [in] pointer to the action data buffer */
 328         uint32_t *data;
 329         /** [in] buffer len in bytes */
 330         uint32_t len;
 331         /** [in] pointer to the action layout */
 332         struct hcapi_cfa_action_layout *layout;
 333 };
 334
 335 /**
 336  * This function is used to hash E/EM keys
 337  *
 338  *
 339  * @param[in] key_data
 340  *  A pointer of the key
 341  *
 342  * @param[in] bitlen
 343  *  Number of bits in the key
 344  *
 345  * @return
 346  *   CRC32 and Lookup3 hashes of the input key
 347  */
 348 uint64_t hcapi_cfa_key_hash(uint64_t *key_data,
 349                             uint16_t bitlen);
 350
 351 /**
 352  * This function is used to execute an operation
 353  *
 354  *
 355  * @param[in] op
 356  *  Operation
 357  *
 358  * @param[in] key_tbl
 359  *  Table
 360  *
 361  * @param[in] key_obj
 362  *  Key data
 363  *
 364  * @param[in] key_key_loc
 365  *
 366  * @return
 367  *   0 for SUCCESS, negative value for FAILURE
 368  */
 369 int hcapi_cfa_key_hw_op(struct hcapi_cfa_hwop *op,
 370                         struct hcapi_cfa_key_tbl *key_tbl,
 371                         struct hcapi_cfa_key_data *key_obj,
 372                         struct hcapi_cfa_key_loc *key_loc);
 373
 374 uint64_t hcapi_get_table_page(struct hcapi_cfa_em_table *mem,
 375                               uint32_t page);
 376 uint32_t hcapi_cfa_crc32i(uint32_t crc, const uint8_t *buf, size_t len);
 377 uint64_t hcapi_cfa_p4_key_hash(uint64_t *key_data,
 378                                uint16_t bitlen);
 379 uint64_t hcapi_cfa_p58_key_hash(uint64_t *key_data,
 380                                 uint16_t bitlen);
 381 #endif /* HCAPI_CFA_DEFS_H_ */