drivers/net/bnxt/tf_core/tf_rm.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2019-2020 Broadcom
   3  * All rights reserved.
   4  */
   5
   6 #ifndef TF_RM_H_
   7 #define TF_RM_H_
   8
   9 #include "tf_resources.h"
  10 #include "tf_core.h"
  11 #include "bitalloc.h"
  12
  13 struct tf;
  14 struct tf_session;
  15
  16 /* Internal macro to determine appropriate allocation pools based on
  17  * DIRECTION parm, also performs error checking for DIRECTION parm. The
  18  * SESSION_POOL and SESSION pointers are set appropriately upon
  19  * successful return (the GLOBAL_POOL is used to globally manage
  20  * resource allocation and the SESSION_POOL is used to track the
  21  * resources that have been allocated to the session)
  22  *
  23  * parameters:
  24  *   struct tfp        *tfp
  25  *   enum tf_dir        direction
  26  *   struct bitalloc  **session_pool
  27  *   string             base_pool_name - used to form pointers to the
  28  *                                       appropriate bit allocation
  29  *                                       pools, both directions of the
  30  *                                       session pools must have same
  31  *                                       base name, for example if
  32  *                                       POOL_NAME is feat_pool: - the
  33  *                                       ptr's to the session pools
  34  *                                       are feat_pool_rx feat_pool_tx
  35  *
  36  *  int                  rc - return code
  37  *                            0 - Success
  38  *                           -1 - invalid DIRECTION parm
  39  */
  40 #define TF_RM_GET_POOLS(tfs, direction, session_pool, pool_name, rc) do { \
  41                 (rc) = 0;                                               \
  42                 if ((direction) == TF_DIR_RX) {                         \
  43                         *(session_pool) = (tfs)->pool_name ## _RX;      \
  44                 } else if ((direction) == TF_DIR_TX) {                  \
  45                         *(session_pool) = (tfs)->pool_name ## _TX;      \
  46                 } else {                                                \
  47                         rc = -1;                                        \
  48                 }                                                       \
  49         } while (0)
  50
  51 #define TF_RM_GET_POOLS_RX(tfs, session_pool, pool_name)        \
  52         (*(session_pool) = (tfs)->pool_name ## _RX)
  53
  54 #define TF_RM_GET_POOLS_TX(tfs, session_pool, pool_name)        \
  55         (*(session_pool) = (tfs)->pool_name ## _TX)
  56
  57 /**
  58  * Resource query single entry
  59  */
  60 struct tf_rm_query_entry {
  61         /** Minimum guaranteed number of elements */
  62         uint16_t min;
  63         /** Maximum non-guaranteed number of elements */
  64         uint16_t max;
  65 };
  66
  67 /**
  68  * Resource single entry
  69  */
  70 struct tf_rm_entry {
  71         /** Starting index of the allocated resource */
  72         uint16_t start;
  73         /** Number of allocated elements */
  74         uint16_t stride;
  75 };
  76
  77 /**
  78  * Resource query array of HW entities
  79  */
  80 struct tf_rm_hw_query {
  81         /** array of HW resource entries */
  82         struct tf_rm_query_entry hw_query[TF_RESC_TYPE_HW_MAX];
  83 };
  84
  85 /**
  86  * Resource allocation array of HW entities
  87  */
  88 struct tf_rm_hw_alloc {
  89         /** array of HW resource entries */
  90         uint16_t hw_num[TF_RESC_TYPE_HW_MAX];
  91 };
  92
  93 /**
  94  * Resource query array of SRAM entities
  95  */
  96 struct tf_rm_sram_query {
  97         /** array of SRAM resource entries */
  98         struct tf_rm_query_entry sram_query[TF_RESC_TYPE_SRAM_MAX];
  99 };
 100
 101 /**
 102  * Resource allocation array of SRAM entities
 103  */
 104 struct tf_rm_sram_alloc {
 105         /** array of SRAM resource entries */
 106         uint16_t sram_num[TF_RESC_TYPE_SRAM_MAX];
 107 };
 108
 109 /**
 110  * Resource Manager arrays for a single direction
 111  */
 112 struct tf_rm_resc {
 113         /** array of HW resource entries */
 114         struct tf_rm_entry hw_entry[TF_RESC_TYPE_HW_MAX];
 115         /** array of SRAM resource entries */
 116         struct tf_rm_entry sram_entry[TF_RESC_TYPE_SRAM_MAX];
 117 };
 118
 119 /**
 120  * Resource Manager Database
 121  */
 122 struct tf_rm_db {
 123         struct tf_rm_resc rx;
 124         struct tf_rm_resc tx;
 125 };
 126
 127 /**
 128  * Helper function converting direction to text string
 129  */
 130 const char
 131 *tf_dir_2_str(enum tf_dir dir);
 132
 133 /**
 134  * Helper function converting identifier to text string
 135  */
 136 const char
 137 *tf_ident_2_str(enum tf_identifier_type id_type);
 138
 139 /**
 140  * Helper function converting tcam type to text string
 141  */
 142 const char
 143 *tf_tcam_tbl_2_str(enum tf_tcam_tbl_type tcam_type);
 144
 145 /**
 146  * Helper function used to convert HW HCAPI resource type to a string.
 147  */
 148 const char
 149 *tf_hcapi_hw_2_str(enum tf_resource_type_hw hw_type);
 150
 151 /**
 152  * Helper function used to convert SRAM HCAPI resource type to a string.
 153  */
 154 const char
 155 *tf_hcapi_sram_2_str(enum tf_resource_type_sram sram_type);
 156
 157 /**
 158  * Initializes the Resource Manager and the associated database
 159  * entries for HW and SRAM resources. Must be called before any other
 160  * Resource Manager functions.
 161  *
 162  * [in] tfp
 163  *   Pointer to TF handle
 164  */
 165 void tf_rm_init(struct tf *tfp);
 166
 167 /**
 168  * Allocates and validates both HW and SRAM resources per the NVM
 169  * configuration. If any allocation fails all resources for the
 170  * session is deallocated.
 171  *
 172  * [in] tfp
 173  *   Pointer to TF handle
 174  *
 175  * Returns
 176  *   - (0) if successful.
 177  *   - (-EINVAL) on failure.
 178  */
 179 int tf_rm_allocate_validate(struct tf *tfp);
 180
 181 /**
 182  * Closes the Resource Manager and frees all allocated resources per
 183  * the associated database.
 184  *
 185  * [in] tfp
 186  *   Pointer to TF handle
 187  *
 188  * Returns
 189  *   - (0) if successful.
 190  *   - (-EINVAL) on failure.
 191  *   - (-ENOTEMPTY) if resources are not cleaned up before close
 192  */
 193 int tf_rm_close(struct tf *tfp);
 194
 195 #if (TF_SHADOW == 1)
 196 /**
 197  * Initializes Shadow DB of configuration elements
 198  *
 199  * [in] tfs
 200  *   Pointer to TF Session
 201  *
 202  * Returns:
 203  *  0  - Success
 204  */
 205 int tf_rm_shadow_db_init(struct tf_session *tfs);
 206 #endif /* TF_SHADOW */
 207
 208 /**
 209  * Perform a Session Pool lookup using the Tcam table type.
 210  *
 211  * Function will print error msg if tcam type is unsupported or lookup
 212  * failed.
 213  *
 214  * [in] tfs
 215  *   Pointer to TF Session
 216  *
 217  * [in] type
 218  *   Type of the object
 219  *
 220  * [in] dir
 221  *    Receive or transmit direction
 222  *
 223  * [in/out]  session_pool
 224  *   Session pool
 225  *
 226  * Returns:
 227  *  0           - Success will set the **pool
 228  *  -EOPNOTSUPP - Type is not supported
 229  */
 230 int
 231 tf_rm_lookup_tcam_type_pool(struct tf_session *tfs,
 232                             enum tf_dir dir,
 233                             enum tf_tcam_tbl_type type,
 234                             struct bitalloc **pool);
 235
 236 /**
 237  * Perform a Session Pool lookup using the Table type.
 238  *
 239  * Function will print error msg if table type is unsupported or
 240  * lookup failed.
 241  *
 242  * [in] tfs
 243  *   Pointer to TF Session
 244  *
 245  * [in] type
 246  *   Type of the object
 247  *
 248  * [in] dir
 249  *    Receive or transmit direction
 250  *
 251  * [in/out]  session_pool
 252  *   Session pool
 253  *
 254  * Returns:
 255  *  0           - Success will set the **pool
 256  *  -EOPNOTSUPP - Type is not supported
 257  */
 258 int
 259 tf_rm_lookup_tbl_type_pool(struct tf_session *tfs,
 260                            enum tf_dir dir,
 261                            enum tf_tbl_type type,
 262                            struct bitalloc **pool);
 263
 264 /**
 265  * Converts the TF Table Type to internal HCAPI_TYPE
 266  *
 267  * [in] type
 268  *   Type to be converted
 269  *
 270  * [in/out] hcapi_type
 271  *   Converted type
 272  *
 273  * Returns:
 274  *  0           - Success will set the *hcapi_type
 275  *  -EOPNOTSUPP - Type is not supported
 276  */
 277 int
 278 tf_rm_convert_tbl_type(enum tf_tbl_type type,
 279                        uint32_t *hcapi_type);
 280
 281 /**
 282  * TF RM Convert of index methods.
 283  */
 284 enum tf_rm_convert_type {
 285         /** Adds the base of the Session Pool to the index */
 286         TF_RM_CONVERT_ADD_BASE,
 287         /** Removes the Session Pool base from the index */
 288         TF_RM_CONVERT_RM_BASE
 289 };
 290
 291 /**
 292  * Provides conversion of the Table Type index in relation to the
 293  * Session Pool base.
 294  *
 295  * [in] tfs
 296  *   Pointer to TF Session
 297  *
 298  * [in] dir
 299  *    Receive or transmit direction
 300  *
 301  * [in] type
 302  *   Type of the object
 303  *
 304  * [in] c_type
 305  *   Type of conversion to perform
 306  *
 307  * [in] index
 308  *   Index to be converted
 309  *
 310  * [in/out]  convert_index
 311  *   Pointer to the converted index
 312  */
 313 int
 314 tf_rm_convert_index(struct tf_session *tfs,
 315                     enum tf_dir dir,
 316                     enum tf_tbl_type type,
 317                     enum tf_rm_convert_type c_type,
 318                     uint32_t index,
 319                     uint32_t *convert_index);
 320
 321 #endif /* TF_RM_H_ */