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