drivers/net/bnxt/tf_core/tf_msg.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2019-2020 Broadcom
   3  * All rights reserved.
   4  */
   5
   6 #include <inttypes.h>
   7 #include <stdbool.h>
   8 #include <stdlib.h>
   9
  10 #include "bnxt.h"
  11 #include "tf_core.h"
  12 #include "tf_session.h"
  13 #include "tfp.h"
  14
  15 #include "tf_msg_common.h"
  16 #include "tf_msg.h"
  17 #include "hsi_struct_def_dpdk.h"
  18 #include "hwrm_tf.h"
  19
  20 /**
  21  * Endian converts min and max values from the HW response to the query
  22  */
  23 #define TF_HW_RESP_TO_QUERY(query, index, response, element) do {            \
  24         (query)->hw_query[index].min =                                       \
  25                 tfp_le_to_cpu_16(response. element ## _min);                 \
  26         (query)->hw_query[index].max =                                       \
  27                 tfp_le_to_cpu_16(response. element ## _max);                 \
  28 } while (0)
  29
  30 /**
  31  * Endian converts the number of entries from the alloc to the request
  32  */
  33 #define TF_HW_ALLOC_TO_REQ(alloc, index, request, element)                   \
  34         (request. num_ ## element = tfp_cpu_to_le_16((alloc)->hw_num[index]))
  35
  36 /**
  37  * Endian converts the start and stride value from the free to the request
  38  */
  39 #define TF_HW_FREE_TO_REQ(hw_entry, index, request, element) do {            \
  40         request.element ## _start =                                          \
  41                 tfp_cpu_to_le_16(hw_entry[index].start);                     \
  42         request.element ## _stride =                                         \
  43                 tfp_cpu_to_le_16(hw_entry[index].stride);                    \
  44 } while (0)
  45
  46 /**
  47  * Endian converts the start and stride from the HW response to the
  48  * alloc
  49  */
  50 #define TF_HW_RESP_TO_ALLOC(hw_entry, index, response, element) do {         \
  51         hw_entry[index].start =                                              \
  52                 tfp_le_to_cpu_16(response.element ## _start);                \
  53         hw_entry[index].stride =                                             \
  54                 tfp_le_to_cpu_16(response.element ## _stride);               \
  55 } while (0)
  56
  57 /**
  58  * Endian converts min and max values from the SRAM response to the
  59  * query
  60  */
  61 #define TF_SRAM_RESP_TO_QUERY(query, index, response, element) do {          \
  62         (query)->sram_query[index].min =                                     \
  63                 tfp_le_to_cpu_16(response.element ## _min);                  \
  64         (query)->sram_query[index].max =                                     \
  65                 tfp_le_to_cpu_16(response.element ## _max);                  \
  66 } while (0)
  67
  68 /**
  69  * Endian converts the number of entries from the action (alloc) to
  70  * the request
  71  */
  72 #define TF_SRAM_ALLOC_TO_REQ(action, index, request, element)                \
  73         (request. num_ ## element = tfp_cpu_to_le_16((action)->sram_num[index]))
  74
  75 /**
  76  * Endian converts the start and stride value from the free to the request
  77  */
  78 #define TF_SRAM_FREE_TO_REQ(sram_entry, index, request, element) do {        \
  79         request.element ## _start =                                          \
  80                 tfp_cpu_to_le_16(sram_entry[index].start);                   \
  81         request.element ## _stride =                                         \
  82                 tfp_cpu_to_le_16(sram_entry[index].stride);                  \
  83 } while (0)
  84
  85 /**
  86  * Endian converts the start and stride from the HW response to the
  87  * alloc
  88  */
  89 #define TF_SRAM_RESP_TO_ALLOC(sram_entry, index, response, element) do {     \
  90         sram_entry[index].start =                                            \
  91                 tfp_le_to_cpu_16(response.element ## _start);                \
  92         sram_entry[index].stride =                                           \
  93                 tfp_le_to_cpu_16(response.element ## _stride);               \
  94 } while (0)
  95
  96 /**
  97  * Sends session open request to TF Firmware
  98  */
  99 int
 100 tf_msg_session_open(struct tf *tfp,
 101                     char *ctrl_chan_name,
 102                     uint8_t *fw_session_id)
 103 {
 104         int rc;
 105         struct hwrm_tf_session_open_input req = { 0 };
 106         struct hwrm_tf_session_open_output resp = { 0 };
 107         struct tfp_send_msg_parms parms = { 0 };
 108
 109         /* Populate the request */
 110         memcpy(&req.session_name, ctrl_chan_name, TF_SESSION_NAME_MAX);
 111
 112         parms.tf_type = HWRM_TF_SESSION_OPEN;
 113         parms.req_data = (uint32_t *)&req;
 114         parms.req_size = sizeof(req);
 115         parms.resp_data = (uint32_t *)&resp;
 116         parms.resp_size = sizeof(resp);
 117         parms.mailbox = TF_KONG_MB;
 118
 119         rc = tfp_send_msg_direct(tfp,
 120                                  &parms);
 121         if (rc)
 122                 return rc;
 123
 124         *fw_session_id = resp.fw_session_id;
 125
 126         return rc;
 127 }
 128
 129 /**
 130  * Sends session attach request to TF Firmware
 131  */
 132 int
 133 tf_msg_session_attach(struct tf *tfp __rte_unused,
 134                       char *ctrl_chan_name __rte_unused,
 135                       uint8_t tf_fw_session_id __rte_unused)
 136 {
 137         return -1;
 138 }
 139
 140 /**
 141  * Sends session close request to TF Firmware
 142  */
 143 int
 144 tf_msg_session_close(struct tf *tfp)
 145 {
 146         int rc;
 147         struct hwrm_tf_session_close_input req = { 0 };
 148         struct hwrm_tf_session_close_output resp = { 0 };
 149         struct tf_session *tfs = (struct tf_session *)(tfp->session->core_data);
 150         struct tfp_send_msg_parms parms = { 0 };
 151
 152         /* Populate the request */
 153         req.fw_session_id =
 154                 tfp_cpu_to_le_32(tfs->session_id.internal.fw_session_id);
 155
 156         parms.tf_type = HWRM_TF_SESSION_CLOSE;
 157         parms.req_data = (uint32_t *)&req;
 158         parms.req_size = sizeof(req);
 159         parms.resp_data = (uint32_t *)&resp;
 160         parms.resp_size = sizeof(resp);
 161         parms.mailbox = TF_KONG_MB;
 162
 163         rc = tfp_send_msg_direct(tfp,
 164                                  &parms);
 165         return rc;
 166 }
 167
 168 /**
 169  * Sends session query config request to TF Firmware
 170  */
 171 int
 172 tf_msg_session_qcfg(struct tf *tfp)
 173 {
 174         int rc;
 175         struct hwrm_tf_session_qcfg_input  req = { 0 };
 176         struct hwrm_tf_session_qcfg_output resp = { 0 };
 177         struct tf_session *tfs = (struct tf_session *)(tfp->session->core_data);
 178         struct tfp_send_msg_parms parms = { 0 };
 179
 180         /* Populate the request */
 181         req.fw_session_id =
 182                 tfp_cpu_to_le_32(tfs->session_id.internal.fw_session_id);
 183
 184         parms.tf_type = HWRM_TF_SESSION_QCFG,
 185         parms.req_data = (uint32_t *)&req;
 186         parms.req_size = sizeof(req);
 187         parms.resp_data = (uint32_t *)&resp;
 188         parms.resp_size = sizeof(resp);
 189         parms.mailbox = TF_KONG_MB;
 190
 191         rc = tfp_send_msg_direct(tfp,
 192                                  &parms);
 193         return rc;
 194 }
 195
 196 /**
 197  * Sends session HW resource query capability request to TF Firmware
 198  */
 199 int
 200 tf_msg_session_hw_resc_qcaps(struct tf *tfp,
 201                              enum tf_dir dir,
 202                              struct tf_rm_hw_query *query)
 203 {
 204         int rc;
 205         struct tfp_send_msg_parms parms = { 0 };
 206         struct tf_session_hw_resc_qcaps_input req = { 0 };
 207         struct tf_session_hw_resc_qcaps_output resp = { 0 };
 208         struct tf_session *tfs = (struct tf_session *)(tfp->session->core_data);
 209
 210         memset(query, 0, sizeof(*query));
 211
 212         /* Populate the request */
 213         req.fw_session_id =
 214                 tfp_cpu_to_le_32(tfs->session_id.internal.fw_session_id);
 215         req.flags = tfp_cpu_to_le_16(dir);
 216
 217         MSG_PREP(parms,
 218                  TF_KONG_MB,
 219                  HWRM_TF,
 220                  HWRM_TFT_SESSION_HW_RESC_QCAPS,
 221                  req,
 222                  resp);
 223
 224         rc = tfp_send_msg_tunneled(tfp, &parms);
 225         if (rc)
 226                 return rc;
 227
 228         /* Process the response */
 229         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_L2_CTXT_TCAM, resp,
 230                             l2_ctx_tcam_entries);
 231         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_PROF_FUNC, resp,
 232                             prof_func);
 233         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_PROF_TCAM, resp,
 234                             prof_tcam_entries);
 235         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_EM_PROF_ID, resp,
 236                             em_prof_id);
 237         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_EM_REC, resp,
 238                             em_record_entries);
 239         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_WC_TCAM_PROF_ID, resp,
 240                             wc_tcam_prof_id);
 241         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_WC_TCAM, resp,
 242                             wc_tcam_entries);
 243         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_METER_PROF, resp,
 244                             meter_profiles);
 245         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_METER_INST,
 246                             resp, meter_inst);
 247         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_MIRROR, resp,
 248                             mirrors);
 249         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_UPAR, resp,
 250                             upar);
 251         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_SP_TCAM, resp,
 252                             sp_tcam_entries);
 253         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_L2_FUNC, resp,
 254                             l2_func);
 255         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_FKB, resp,
 256                             flex_key_templ);
 257         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_TBL_SCOPE, resp,
 258                             tbl_scope);
 259         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_EPOCH0, resp,
 260                             epoch0_entries);
 261         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_EPOCH1, resp,
 262                             epoch1_entries);
 263         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_METADATA, resp,
 264                             metadata);
 265         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_CT_STATE, resp,
 266                             ct_state);
 267         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_RANGE_PROF, resp,
 268                             range_prof);
 269         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_RANGE_ENTRY, resp,
 270                             range_entries);
 271         TF_HW_RESP_TO_QUERY(query, TF_RESC_TYPE_HW_LAG_ENTRY, resp,
 272                             lag_tbl_entries);
 273
 274         return tfp_le_to_cpu_32(parms.tf_resp_code);
 275 }
 276
 277 /**
 278  * Sends session HW resource allocation request to TF Firmware
 279  */
 280 int
 281 tf_msg_session_hw_resc_alloc(struct tf *tfp __rte_unused,
 282                              enum tf_dir dir,
 283                              struct tf_rm_hw_alloc *hw_alloc __rte_unused,
 284                              struct tf_rm_entry *hw_entry __rte_unused)
 285 {
 286         int rc;
 287         struct tfp_send_msg_parms parms = { 0 };
 288         struct tf_session_hw_resc_alloc_input req = { 0 };
 289         struct tf_session_hw_resc_alloc_output resp = { 0 };
 290         struct tf_session *tfs = (struct tf_session *)(tfp->session->core_data);
 291
 292         memset(hw_entry, 0, sizeof(*hw_entry));
 293
 294         /* Populate the request */
 295         req.fw_session_id =
 296                 tfp_cpu_to_le_32(tfs->session_id.internal.fw_session_id);
 297         req.flags = tfp_cpu_to_le_16(dir);
 298
 299         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_L2_CTXT_TCAM, req,
 300                            l2_ctx_tcam_entries);
 301         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_PROF_FUNC, req,
 302                            prof_func_entries);
 303         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_PROF_TCAM, req,
 304                            prof_tcam_entries);
 305         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_EM_PROF_ID, req,
 306                            em_prof_id);
 307         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_EM_REC, req,
 308                            em_record_entries);
 309         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_WC_TCAM_PROF_ID, req,
 310                            wc_tcam_prof_id);
 311         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_WC_TCAM, req,
 312                            wc_tcam_entries);
 313         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_METER_PROF, req,
 314                            meter_profiles);
 315         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_METER_INST, req,
 316                            meter_inst);
 317         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_MIRROR, req,
 318                            mirrors);
 319         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_UPAR, req,
 320                            upar);
 321         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_SP_TCAM, req,
 322                            sp_tcam_entries);
 323         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_L2_FUNC, req,
 324                            l2_func);
 325         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_FKB, req,
 326                            flex_key_templ);
 327         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_TBL_SCOPE, req,
 328                            tbl_scope);
 329         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_EPOCH0, req,
 330                            epoch0_entries);
 331         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_EPOCH1, req,
 332                            epoch1_entries);
 333         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_METADATA, req,
 334                            metadata);
 335         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_CT_STATE, req,
 336                            ct_state);
 337         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_RANGE_PROF, req,
 338                            range_prof);
 339         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_RANGE_ENTRY, req,
 340                            range_entries);
 341         TF_HW_ALLOC_TO_REQ(hw_alloc, TF_RESC_TYPE_HW_LAG_ENTRY, req,
 342                            lag_tbl_entries);
 343
 344         MSG_PREP(parms,
 345                  TF_KONG_MB,
 346                  HWRM_TF,
 347                  HWRM_TFT_SESSION_HW_RESC_ALLOC,
 348                  req,
 349                  resp);
 350
 351         rc = tfp_send_msg_tunneled(tfp, &parms);
 352         if (rc)
 353                 return rc;
 354
 355         /* Process the response */
 356         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_L2_CTXT_TCAM, resp,
 357                             l2_ctx_tcam_entries);
 358         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_PROF_FUNC, resp,
 359                             prof_func);
 360         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_PROF_TCAM, resp,
 361                             prof_tcam_entries);
 362         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_EM_PROF_ID, resp,
 363                             em_prof_id);
 364         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_EM_REC, resp,
 365                             em_record_entries);
 366         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_WC_TCAM_PROF_ID, resp,
 367                             wc_tcam_prof_id);
 368         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_WC_TCAM, resp,
 369                             wc_tcam_entries);
 370         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_METER_PROF, resp,
 371                             meter_profiles);
 372         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_METER_INST, resp,
 373                             meter_inst);
 374         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_MIRROR, resp,
 375                             mirrors);
 376         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_UPAR, resp,
 377                             upar);
 378         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_SP_TCAM, resp,
 379                             sp_tcam_entries);
 380         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_L2_FUNC, resp,
 381                             l2_func);
 382         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_FKB, resp,
 383                             flex_key_templ);
 384         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_TBL_SCOPE, resp,
 385                             tbl_scope);
 386         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_EPOCH0, resp,
 387                             epoch0_entries);
 388         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_EPOCH1, resp,
 389                             epoch1_entries);
 390         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_METADATA, resp,
 391                             metadata);
 392         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_CT_STATE, resp,
 393                             ct_state);
 394         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_RANGE_PROF, resp,
 395                             range_prof);
 396         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_RANGE_ENTRY, resp,
 397                             range_entries);
 398         TF_HW_RESP_TO_ALLOC(hw_entry, TF_RESC_TYPE_HW_LAG_ENTRY, resp,
 399                             lag_tbl_entries);
 400
 401         return tfp_le_to_cpu_32(parms.tf_resp_code);
 402 }
 403
 404 /**
 405  * Sends session HW resource free request to TF Firmware
 406  */
 407 int
 408 tf_msg_session_hw_resc_free(struct tf *tfp,
 409                             enum tf_dir dir,
 410                             struct tf_rm_entry *hw_entry)
 411 {
 412         int rc;
 413         struct tfp_send_msg_parms parms = { 0 };
 414         struct tf_session_hw_resc_free_input req = { 0 };
 415         struct tf_session *tfs = (struct tf_session *)(tfp->session->core_data);
 416
 417         memset(hw_entry, 0, sizeof(*hw_entry));
 418
 419         /* Populate the request */
 420         req.fw_session_id =
 421                 tfp_cpu_to_le_32(tfs->session_id.internal.fw_session_id);
 422         req.flags = tfp_cpu_to_le_16(dir);
 423
 424         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_L2_CTXT_TCAM, req,
 425                           l2_ctx_tcam_entries);
 426         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_PROF_FUNC, req,
 427                           prof_func);
 428         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_PROF_TCAM, req,
 429                           prof_tcam_entries);
 430         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_EM_PROF_ID, req,
 431                           em_prof_id);
 432         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_EM_REC, req,
 433                           em_record_entries);
 434         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_WC_TCAM_PROF_ID, req,
 435                           wc_tcam_prof_id);
 436         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_WC_TCAM, req,
 437                           wc_tcam_entries);
 438         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_METER_PROF, req,
 439                           meter_profiles);
 440         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_METER_INST, req,
 441                           meter_inst);
 442         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_MIRROR, req,
 443                           mirrors);
 444         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_UPAR, req,
 445                           upar);
 446         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_SP_TCAM, req,
 447                           sp_tcam_entries);
 448         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_L2_FUNC, req,
 449                           l2_func);
 450         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_FKB, req,
 451                           flex_key_templ);
 452         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_TBL_SCOPE, req,
 453                           tbl_scope);
 454         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_EPOCH0, req,
 455                           epoch0_entries);
 456         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_EPOCH1, req,
 457                           epoch1_entries);
 458         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_METADATA, req,
 459                           metadata);
 460         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_CT_STATE, req,
 461                           ct_state);
 462         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_RANGE_PROF, req,
 463                           range_prof);
 464         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_RANGE_ENTRY, req,
 465                           range_entries);
 466         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_LAG_ENTRY, req,
 467                           lag_tbl_entries);
 468
 469         MSG_PREP_NO_RESP(parms,
 470                          TF_KONG_MB,
 471                          HWRM_TF,
 472                          HWRM_TFT_SESSION_HW_RESC_FREE,
 473                          req);
 474
 475         rc = tfp_send_msg_tunneled(tfp, &parms);
 476         if (rc)
 477                 return rc;
 478
 479         return tfp_le_to_cpu_32(parms.tf_resp_code);
 480 }
 481
 482 /**
 483  * Sends session HW resource flush request to TF Firmware
 484  */
 485 int
 486 tf_msg_session_hw_resc_flush(struct tf *tfp,
 487                              enum tf_dir dir,
 488                              struct tf_rm_entry *hw_entry)
 489 {
 490         int rc;
 491         struct tfp_send_msg_parms parms = { 0 };
 492         struct tf_session_hw_resc_free_input req = { 0 };
 493         struct tf_session *tfs = (struct tf_session *)(tfp->session->core_data);
 494
 495         /* Populate the request */
 496         req.fw_session_id =
 497                 tfp_cpu_to_le_32(tfs->session_id.internal.fw_session_id);
 498         req.flags = tfp_cpu_to_le_16(dir);
 499
 500         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_L2_CTXT_TCAM, req,
 501                           l2_ctx_tcam_entries);
 502         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_PROF_FUNC, req,
 503                           prof_func);
 504         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_PROF_TCAM, req,
 505                           prof_tcam_entries);
 506         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_EM_PROF_ID, req,
 507                           em_prof_id);
 508         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_EM_REC, req,
 509                           em_record_entries);
 510         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_WC_TCAM_PROF_ID, req,
 511                           wc_tcam_prof_id);
 512         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_WC_TCAM, req,
 513                           wc_tcam_entries);
 514         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_METER_PROF, req,
 515                           meter_profiles);
 516         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_METER_INST, req,
 517                           meter_inst);
 518         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_MIRROR, req,
 519                           mirrors);
 520         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_UPAR, req,
 521                           upar);
 522         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_SP_TCAM, req,
 523                           sp_tcam_entries);
 524         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_L2_FUNC, req,
 525                           l2_func);
 526         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_FKB, req,
 527                           flex_key_templ);
 528         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_TBL_SCOPE, req,
 529                           tbl_scope);
 530         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_EPOCH0, req,
 531                           epoch0_entries);
 532         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_EPOCH1, req,
 533                           epoch1_entries);
 534         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_METADATA, req,
 535                           metadata);
 536         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_CT_STATE, req,
 537                           ct_state);
 538         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_RANGE_PROF, req,
 539                           range_prof);
 540         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_RANGE_ENTRY, req,
 541                           range_entries);
 542         TF_HW_FREE_TO_REQ(hw_entry, TF_RESC_TYPE_HW_LAG_ENTRY, req,
 543                           lag_tbl_entries);
 544
 545         MSG_PREP_NO_RESP(parms,
 546                          TF_KONG_MB,
 547                          TF_TYPE_TRUFLOW,
 548                          HWRM_TFT_SESSION_HW_RESC_FLUSH,
 549                          req);
 550
 551         rc = tfp_send_msg_tunneled(tfp, &parms);
 552         if (rc)
 553                 return rc;
 554
 555         return tfp_le_to_cpu_32(parms.tf_resp_code);
 556 }
 557
 558 /**
 559  * Sends session SRAM resource query capability request to TF Firmware
 560  */
 561 int
 562 tf_msg_session_sram_resc_qcaps(struct tf *tfp __rte_unused,
 563                                enum tf_dir dir,
 564                                struct tf_rm_sram_query *query __rte_unused)
 565 {
 566         int rc;
 567         struct tfp_send_msg_parms parms = { 0 };
 568         struct tf_session_sram_resc_qcaps_input req = { 0 };
 569         struct tf_session_sram_resc_qcaps_output resp = { 0 };
 570         struct tf_session *tfs = (struct tf_session *)(tfp->session->core_data);
 571
 572         /* Populate the request */
 573         req.fw_session_id =
 574                 tfp_cpu_to_le_32(tfs->session_id.internal.fw_session_id);
 575         req.flags = tfp_cpu_to_le_16(dir);
 576
 577         MSG_PREP(parms,
 578                  TF_KONG_MB,
 579                  HWRM_TF,
 580                  HWRM_TFT_SESSION_SRAM_RESC_QCAPS,
 581                  req,
 582                  resp);
 583
 584         rc = tfp_send_msg_tunneled(tfp, &parms);
 585         if (rc)
 586                 return rc;
 587
 588         /* Process the response */
 589         TF_SRAM_RESP_TO_QUERY(query, TF_RESC_TYPE_SRAM_FULL_ACTION, resp,
 590                               full_action);
 591         TF_SRAM_RESP_TO_QUERY(query, TF_RESC_TYPE_SRAM_MCG, resp,
 592                               mcg);
 593         TF_SRAM_RESP_TO_QUERY(query, TF_RESC_TYPE_SRAM_ENCAP_8B, resp,
 594                               encap_8b);
 595         TF_SRAM_RESP_TO_QUERY(query, TF_RESC_TYPE_SRAM_ENCAP_16B, resp,
 596                               encap_16b);
 597         TF_SRAM_RESP_TO_QUERY(query, TF_RESC_TYPE_SRAM_ENCAP_64B, resp,
 598                               encap_64b);
 599         TF_SRAM_RESP_TO_QUERY(query, TF_RESC_TYPE_SRAM_SP_SMAC, resp,
 600                               sp_smac);
 601         TF_SRAM_RESP_TO_QUERY(query, TF_RESC_TYPE_SRAM_SP_SMAC_IPV4, resp,
 602                               sp_smac_ipv4);
 603         TF_SRAM_RESP_TO_QUERY(query, TF_RESC_TYPE_SRAM_SP_SMAC_IPV6, resp,
 604                               sp_smac_ipv6);
 605         TF_SRAM_RESP_TO_QUERY(query, TF_RESC_TYPE_SRAM_COUNTER_64B, resp,
 606                               counter_64b);
 607         TF_SRAM_RESP_TO_QUERY(query, TF_RESC_TYPE_SRAM_NAT_SPORT, resp,
 608                               nat_sport);
 609         TF_SRAM_RESP_TO_QUERY(query, TF_RESC_TYPE_SRAM_NAT_DPORT, resp,
 610                               nat_dport);
 611         TF_SRAM_RESP_TO_QUERY(query, TF_RESC_TYPE_SRAM_NAT_S_IPV4, resp,
 612                               nat_s_ipv4);
 613         TF_SRAM_RESP_TO_QUERY(query, TF_RESC_TYPE_SRAM_NAT_D_IPV4, resp,
 614                               nat_d_ipv4);
 615
 616         return tfp_le_to_cpu_32(parms.tf_resp_code);
 617 }
 618
 619 /**
 620  * Sends session SRAM resource allocation request to TF Firmware
 621  */
 622 int
 623 tf_msg_session_sram_resc_alloc(struct tf *tfp __rte_unused,
 624                                enum tf_dir dir,
 625                                struct tf_rm_sram_alloc *sram_alloc __rte_unused,
 626                                struct tf_rm_entry *sram_entry __rte_unused)
 627 {
 628         int rc;
 629         struct tfp_send_msg_parms parms = { 0 };
 630         struct tf_session_sram_resc_alloc_input req = { 0 };
 631         struct tf_session_sram_resc_alloc_output resp;
 632         struct tf_session *tfs = (struct tf_session *)(tfp->session->core_data);
 633
 634         memset(&resp, 0, sizeof(resp));
 635
 636         /* Populate the request */
 637         req.fw_session_id =
 638                 tfp_cpu_to_le_32(tfs->session_id.internal.fw_session_id);
 639         req.flags = tfp_cpu_to_le_16(dir);
 640
 641         TF_SRAM_ALLOC_TO_REQ(sram_alloc, TF_RESC_TYPE_SRAM_FULL_ACTION, req,
 642                              full_action);
 643         TF_SRAM_ALLOC_TO_REQ(sram_alloc, TF_RESC_TYPE_SRAM_MCG, req,
 644                              mcg);
 645         TF_SRAM_ALLOC_TO_REQ(sram_alloc, TF_RESC_TYPE_SRAM_ENCAP_8B, req,
 646                              encap_8b);
 647         TF_SRAM_ALLOC_TO_REQ(sram_alloc, TF_RESC_TYPE_SRAM_ENCAP_16B, req,
 648                              encap_16b);
 649         TF_SRAM_ALLOC_TO_REQ(sram_alloc, TF_RESC_TYPE_SRAM_ENCAP_64B, req,
 650                              encap_64b);
 651         TF_SRAM_ALLOC_TO_REQ(sram_alloc, TF_RESC_TYPE_SRAM_SP_SMAC, req,
 652                              sp_smac);
 653         TF_SRAM_ALLOC_TO_REQ(sram_alloc, TF_RESC_TYPE_SRAM_SP_SMAC_IPV4,
 654                              req, sp_smac_ipv4);
 655         TF_SRAM_ALLOC_TO_REQ(sram_alloc, TF_RESC_TYPE_SRAM_SP_SMAC_IPV6,
 656                              req, sp_smac_ipv6);
 657         TF_SRAM_ALLOC_TO_REQ(sram_alloc, TF_RESC_TYPE_SRAM_COUNTER_64B,
 658                              req, counter_64b);
 659         TF_SRAM_ALLOC_TO_REQ(sram_alloc, TF_RESC_TYPE_SRAM_NAT_SPORT, req,
 660                              nat_sport);
 661         TF_SRAM_ALLOC_TO_REQ(sram_alloc, TF_RESC_TYPE_SRAM_NAT_DPORT, req,
 662                              nat_dport);
 663         TF_SRAM_ALLOC_TO_REQ(sram_alloc, TF_RESC_TYPE_SRAM_NAT_S_IPV4, req,
 664                              nat_s_ipv4);
 665         TF_SRAM_ALLOC_TO_REQ(sram_alloc, TF_RESC_TYPE_SRAM_NAT_D_IPV4, req,
 666                              nat_d_ipv4);
 667
 668         MSG_PREP(parms,
 669                  TF_KONG_MB,
 670                  HWRM_TF,
 671                  HWRM_TFT_SESSION_SRAM_RESC_ALLOC,
 672                  req,
 673                  resp);
 674
 675         rc = tfp_send_msg_tunneled(tfp, &parms);
 676         if (rc)
 677                 return rc;
 678
 679         /* Process the response */
 680         TF_SRAM_RESP_TO_ALLOC(sram_entry, TF_RESC_TYPE_SRAM_FULL_ACTION,
 681                               resp, full_action);
 682         TF_SRAM_RESP_TO_ALLOC(sram_entry, TF_RESC_TYPE_SRAM_MCG, resp,
 683                               mcg);
 684         TF_SRAM_RESP_TO_ALLOC(sram_entry, TF_RESC_TYPE_SRAM_ENCAP_8B, resp,
 685                               encap_8b);
 686         TF_SRAM_RESP_TO_ALLOC(sram_entry, TF_RESC_TYPE_SRAM_ENCAP_16B, resp,
 687                               encap_16b);
 688         TF_SRAM_RESP_TO_ALLOC(sram_entry, TF_RESC_TYPE_SRAM_ENCAP_64B, resp,
 689                               encap_64b);
 690         TF_SRAM_RESP_TO_ALLOC(sram_entry, TF_RESC_TYPE_SRAM_SP_SMAC, resp,
 691                               sp_smac);
 692         TF_SRAM_RESP_TO_ALLOC(sram_entry, TF_RESC_TYPE_SRAM_SP_SMAC_IPV4,
 693                               resp, sp_smac_ipv4);
 694         TF_SRAM_RESP_TO_ALLOC(sram_entry, TF_RESC_TYPE_SRAM_SP_SMAC_IPV6,
 695                               resp, sp_smac_ipv6);
 696         TF_SRAM_RESP_TO_ALLOC(sram_entry, TF_RESC_TYPE_SRAM_COUNTER_64B, resp,
 697                               counter_64b);
 698         TF_SRAM_RESP_TO_ALLOC(sram_entry, TF_RESC_TYPE_SRAM_NAT_SPORT, resp,
 699                               nat_sport);
 700         TF_SRAM_RESP_TO_ALLOC(sram_entry, TF_RESC_TYPE_SRAM_NAT_DPORT, resp,
 701                               nat_dport);
 702         TF_SRAM_RESP_TO_ALLOC(sram_entry, TF_RESC_TYPE_SRAM_NAT_S_IPV4, resp,
 703                               nat_s_ipv4);
 704         TF_SRAM_RESP_TO_ALLOC(sram_entry, TF_RESC_TYPE_SRAM_NAT_D_IPV4, resp,
 705                               nat_d_ipv4);
 706
 707         return tfp_le_to_cpu_32(parms.tf_resp_code);
 708 }
 709
 710 /**
 711  * Sends session SRAM resource free request to TF Firmware
 712  */
 713 int
 714 tf_msg_session_sram_resc_free(struct tf *tfp __rte_unused,
 715                               enum tf_dir dir,
 716                               struct tf_rm_entry *sram_entry __rte_unused)
 717 {
 718         int rc;
 719         struct tfp_send_msg_parms parms = { 0 };
 720         struct tf_session_sram_resc_free_input req = { 0 };
 721         struct tf_session *tfs = (struct tf_session *)(tfp->session->core_data);
 722
 723         /* Populate the request */
 724         req.fw_session_id =
 725                 tfp_cpu_to_le_32(tfs->session_id.internal.fw_session_id);
 726         req.flags = tfp_cpu_to_le_16(dir);
 727
 728         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_FULL_ACTION, req,
 729                             full_action);
 730         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_MCG, req,
 731                             mcg);
 732         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_ENCAP_8B, req,
 733                             encap_8b);
 734         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_ENCAP_16B, req,
 735                             encap_16b);
 736         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_ENCAP_64B, req,
 737                             encap_64b);
 738         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_SP_SMAC, req,
 739                             sp_smac);
 740         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_SP_SMAC_IPV4, req,
 741                             sp_smac_ipv4);
 742         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_SP_SMAC_IPV6, req,
 743                             sp_smac_ipv6);
 744         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_COUNTER_64B, req,
 745                             counter_64b);
 746         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_NAT_SPORT, req,
 747                             nat_sport);
 748         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_NAT_DPORT, req,
 749                             nat_dport);
 750         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_NAT_S_IPV4, req,
 751                             nat_s_ipv4);
 752         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_NAT_D_IPV4, req,
 753                             nat_d_ipv4);
 754
 755         MSG_PREP_NO_RESP(parms,
 756                          TF_KONG_MB,
 757                          HWRM_TF,
 758                          HWRM_TFT_SESSION_SRAM_RESC_FREE,
 759                          req);
 760
 761         rc = tfp_send_msg_tunneled(tfp, &parms);
 762         if (rc)
 763                 return rc;
 764
 765         return tfp_le_to_cpu_32(parms.tf_resp_code);
 766 }
 767
 768 /**
 769  * Sends session SRAM resource flush request to TF Firmware
 770  */
 771 int
 772 tf_msg_session_sram_resc_flush(struct tf *tfp,
 773                                enum tf_dir dir,
 774                                struct tf_rm_entry *sram_entry)
 775 {
 776         int rc;
 777         struct tfp_send_msg_parms parms = { 0 };
 778         struct tf_session_sram_resc_free_input req = { 0 };
 779         struct tf_session *tfs = (struct tf_session *)(tfp->session->core_data);
 780
 781         /* Populate the request */
 782         req.fw_session_id =
 783                 tfp_cpu_to_le_32(tfs->session_id.internal.fw_session_id);
 784         req.flags = tfp_cpu_to_le_16(dir);
 785
 786         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_FULL_ACTION, req,
 787                             full_action);
 788         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_MCG, req,
 789                             mcg);
 790         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_ENCAP_8B, req,
 791                             encap_8b);
 792         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_ENCAP_16B, req,
 793                             encap_16b);
 794         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_ENCAP_64B, req,
 795                             encap_64b);
 796         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_SP_SMAC, req,
 797                             sp_smac);
 798         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_SP_SMAC_IPV4, req,
 799                             sp_smac_ipv4);
 800         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_SP_SMAC_IPV6, req,
 801                             sp_smac_ipv6);
 802         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_COUNTER_64B, req,
 803                             counter_64b);
 804         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_NAT_SPORT, req,
 805                             nat_sport);
 806         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_NAT_DPORT, req,
 807                             nat_dport);
 808         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_NAT_S_IPV4, req,
 809                             nat_s_ipv4);
 810         TF_SRAM_FREE_TO_REQ(sram_entry, TF_RESC_TYPE_SRAM_NAT_D_IPV4, req,
 811                             nat_d_ipv4);
 812
 813         MSG_PREP_NO_RESP(parms,
 814                          TF_KONG_MB,
 815                          TF_TYPE_TRUFLOW,
 816                          HWRM_TFT_SESSION_SRAM_RESC_FLUSH,
 817                          req);
 818
 819         rc = tfp_send_msg_tunneled(tfp, &parms);
 820         if (rc)
 821                 return rc;
 822
 823         return tfp_le_to_cpu_32(parms.tf_resp_code);
 824 }