drivers/net/bnxt/tf_ulp/ulp_port_db.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2014-2020 Broadcom
   3  * All rights reserved.
   4  */
   5
   6 #include <rte_malloc.h>
   7 #include "bnxt.h"
   8 #include "bnxt_vnic.h"
   9 #include "bnxt_tf_common.h"
  10 #include "ulp_port_db.h"
  11
  12 static uint32_t
  13 ulp_port_db_allocate_ifindex(struct bnxt_ulp_port_db *port_db)
  14 {
  15         uint32_t idx = 1;
  16
  17         while (idx < port_db->ulp_intf_list_size &&
  18                port_db->ulp_intf_list[idx].type != BNXT_ULP_INTF_TYPE_INVALID)
  19                 idx++;
  20
  21         if (idx >= port_db->ulp_intf_list_size) {
  22                 BNXT_TF_DBG(ERR, "Port DB interface list is full\n");
  23                 return 0;
  24         }
  25         return idx;
  26 }
  27
  28 /*
  29  * Initialize the port database. Memory is allocated in this
  30  * call and assigned to the port database.
  31  *
  32  * ulp_ctxt [in] Ptr to ulp context
  33  *
  34  * Returns 0 on success or negative number on failure.
  35  */
  36 int32_t ulp_port_db_init(struct bnxt_ulp_context *ulp_ctxt)
  37 {
  38         struct bnxt_ulp_port_db *port_db;
  39
  40         port_db = rte_zmalloc("bnxt_ulp_port_db",
  41                               sizeof(struct bnxt_ulp_port_db), 0);
  42         if (!port_db) {
  43                 BNXT_TF_DBG(ERR,
  44                             "Failed to allocate memory for port db\n");
  45                 return -ENOMEM;
  46         }
  47
  48         /* Attach the port database to the ulp context. */
  49         bnxt_ulp_cntxt_ptr2_port_db_set(ulp_ctxt, port_db);
  50
  51         /* index 0 is not being used hence add 1 to size */
  52         port_db->ulp_intf_list_size = BNXT_PORT_DB_MAX_INTF_LIST + 1;
  53         /* Allocate the port tables */
  54         port_db->ulp_intf_list = rte_zmalloc("bnxt_ulp_port_db_intf_list",
  55                                              port_db->ulp_intf_list_size *
  56                                              sizeof(struct ulp_interface_info),
  57                                              0);
  58         if (!port_db->ulp_intf_list) {
  59                 BNXT_TF_DBG(ERR,
  60                             "Failed to allocate mem for port interface list\n");
  61                 goto error_free;
  62         }
  63         return 0;
  64
  65 error_free:
  66         ulp_port_db_deinit(ulp_ctxt);
  67         return -ENOMEM;
  68 }
  69
  70 /*
  71  * Deinitialize the port database. Memory is deallocated in
  72  * this call.
  73  *
  74  * ulp_ctxt [in] Ptr to ulp context
  75  *
  76  * Returns 0 on success.
  77  */
  78 int32_t ulp_port_db_deinit(struct bnxt_ulp_context *ulp_ctxt)
  79 {
  80         struct bnxt_ulp_port_db *port_db;
  81
  82         port_db = bnxt_ulp_cntxt_ptr2_port_db_get(ulp_ctxt);
  83         if (!port_db) {
  84                 BNXT_TF_DBG(ERR, "Invalid Arguments\n");
  85                 return -EINVAL;
  86         }
  87
  88         /* Detach the flow database from the ulp context. */
  89         bnxt_ulp_cntxt_ptr2_port_db_set(ulp_ctxt, NULL);
  90
  91         /* Free up all the memory. */
  92         rte_free(port_db->ulp_intf_list);
  93         rte_free(port_db);
  94         return 0;
  95 }
  96
  97 /*
  98  * Update the port database.This api is called when the port
  99  * details are available during the startup.
 100  *
 101  * ulp_ctxt [in] Ptr to ulp context
 102  * bp [in]. ptr to the device function.
 103  *
 104  * Returns 0 on success or negative number on failure.
 105  */
 106 int32_t ulp_port_db_dev_port_intf_update(struct bnxt_ulp_context *ulp_ctxt,
 107                                          struct bnxt *bp)
 108 {
 109         struct bnxt_ulp_port_db *port_db;
 110         uint32_t port_id = bp->eth_dev->data->port_id;
 111         uint32_t ifindex;
 112         struct ulp_interface_info *intf;
 113         int32_t rc;
 114         struct bnxt_vnic_info *vnic;
 115
 116         port_db = bnxt_ulp_cntxt_ptr2_port_db_get(ulp_ctxt);
 117         if (!port_db) {
 118                 BNXT_TF_DBG(ERR, "Invalid Arguments\n");
 119                 return -EINVAL;
 120         }
 121
 122         rc = ulp_port_db_dev_port_to_ulp_index(ulp_ctxt, port_id, &ifindex);
 123         if (rc == -ENOENT) {
 124                 /* port not found, allocate one */
 125                 ifindex = ulp_port_db_allocate_ifindex(port_db);
 126                 if (!ifindex)
 127                         return -ENOMEM;
 128                 port_db->dev_port_list[port_id] = ifindex;
 129         } else if (rc == -EINVAL) {
 130                 return -EINVAL;
 131         }
 132
 133         /* update the interface details */
 134         intf = &port_db->ulp_intf_list[ifindex];
 135         if (BNXT_PF(bp) || BNXT_VF(bp)) {
 136                 if (BNXT_PF(bp)) {
 137                         intf->type = BNXT_ULP_INTF_TYPE_PF;
 138                         intf->port_svif = bp->port_svif;
 139                 } else {
 140                         intf->type = BNXT_ULP_INTF_TYPE_VF;
 141                 }
 142                 intf->func_id = bp->fw_fid;
 143                 intf->func_svif = bp->func_svif;
 144                 vnic = BNXT_GET_DEFAULT_VNIC(bp);
 145                 if (vnic)
 146                         intf->default_vnic = vnic->fw_vnic_id;
 147                 intf->bp = bp;
 148                 memcpy(intf->mac_addr, bp->mac_addr, sizeof(intf->mac_addr));
 149         } else {
 150                 BNXT_TF_DBG(ERR, "Invalid interface type\n");
 151         }
 152
 153         return 0;
 154 }
 155
 156 /*
 157  * Api to get the ulp ifindex for a given device port.
 158  *
 159  * ulp_ctxt [in] Ptr to ulp context
 160  * port_id [in].device port id
 161  * ifindex [out] ulp ifindex
 162  *
 163  * Returns 0 on success or negative number on failure.
 164  */
 165 int32_t
 166 ulp_port_db_dev_port_to_ulp_index(struct bnxt_ulp_context *ulp_ctxt,
 167                                   uint32_t port_id,
 168                                   uint32_t *ifindex)
 169 {
 170         struct bnxt_ulp_port_db *port_db;
 171
 172         *ifindex = 0;
 173         port_db = bnxt_ulp_cntxt_ptr2_port_db_get(ulp_ctxt);
 174         if (!port_db || port_id >= RTE_MAX_ETHPORTS) {
 175                 BNXT_TF_DBG(ERR, "Invalid Arguments\n");
 176                 return -EINVAL;
 177         }
 178         if (!port_db->dev_port_list[port_id])
 179                 return -ENOENT;
 180
 181         *ifindex = port_db->dev_port_list[port_id];
 182         return 0;
 183 }
 184
 185 /*
 186  * Api to get the function id for a given ulp ifindex.
 187  *
 188  * ulp_ctxt [in] Ptr to ulp context
 189  * ifindex [in] ulp ifindex
 190  * func_id [out] the function id of the given ifindex.
 191  *
 192  * Returns 0 on success or negative number on failure.
 193  */
 194 int32_t
 195 ulp_port_db_function_id_get(struct bnxt_ulp_context *ulp_ctxt,
 196                             uint32_t ifindex,
 197                             uint16_t *func_id)
 198 {
 199         struct bnxt_ulp_port_db *port_db;
 200
 201         port_db = bnxt_ulp_cntxt_ptr2_port_db_get(ulp_ctxt);
 202         if (!port_db || ifindex >= port_db->ulp_intf_list_size || !ifindex) {
 203                 BNXT_TF_DBG(ERR, "Invalid Arguments\n");
 204                 return -EINVAL;
 205         }
 206         *func_id =  port_db->ulp_intf_list[ifindex].func_id;
 207         return 0;
 208 }
 209
 210 /*
 211  * Api to get the svid for a given ulp ifindex.
 212  *
 213  * ulp_ctxt [in] Ptr to ulp context
 214  * ifindex [in] ulp ifindex
 215  * dir [in] the direction for the flow.
 216  * svif [out] the svif of the given ifindex.
 217  *
 218  * Returns 0 on success or negative number on failure.
 219  */
 220 int32_t
 221 ulp_port_db_svif_get(struct bnxt_ulp_context *ulp_ctxt,
 222                      uint32_t ifindex,
 223                      uint32_t dir,
 224                      uint16_t *svif)
 225 {
 226         struct bnxt_ulp_port_db *port_db;
 227
 228         port_db = bnxt_ulp_cntxt_ptr2_port_db_get(ulp_ctxt);
 229         if (!port_db || ifindex >= port_db->ulp_intf_list_size || !ifindex) {
 230                 BNXT_TF_DBG(ERR, "Invalid Arguments\n");
 231                 return -EINVAL;
 232         }
 233         if (dir == ULP_DIR_EGRESS)
 234                 *svif = port_db->ulp_intf_list[ifindex].func_svif;
 235         else
 236                 *svif = port_db->ulp_intf_list[ifindex].port_svif;
 237         return 0;
 238 }
 239
 240 /*
 241  * Api to get the vnic id for a given ulp ifindex.
 242  *
 243  * ulp_ctxt [in] Ptr to ulp context
 244  * ifindex [in] ulp ifindex
 245  * vnic [out] the vnic of the given ifindex.
 246  *
 247  * Returns 0 on success or negative number on failure.
 248  */
 249 int32_t
 250 ulp_port_db_default_vnic_get(struct bnxt_ulp_context *ulp_ctxt,
 251                              uint32_t ifindex,
 252                              uint16_t *vnic)
 253 {
 254         struct bnxt_ulp_port_db *port_db;
 255
 256         port_db = bnxt_ulp_cntxt_ptr2_port_db_get(ulp_ctxt);
 257         if (!port_db || ifindex >= port_db->ulp_intf_list_size || !ifindex) {
 258                 BNXT_TF_DBG(ERR, "Invalid Arguments\n");
 259                 return -EINVAL;
 260         }
 261         *vnic = port_db->ulp_intf_list[ifindex].default_vnic;
 262         return 0;
 263 }