src/plugins/dev_octeon/init.c

   1 /* SPDX-License-Identifier: Apache-2.0
   2  * Copyright (c) 2023 Cisco Systems, Inc.
   3  */
   4
   5 #include <vnet/vnet.h>
   6 #include <vnet/dev/dev.h>
   7 #include <vnet/dev/pci.h>
   8 #include <vnet/dev/counters.h>
   9 #include <vnet/ethernet/ethernet.h>
  10 #include <vnet/plugin/plugin.h>
  11 #include <vpp/app/version.h>
  12 #include <dev_octeon/octeon.h>
  13
  14 #include <base/roc_api.h>
  15 #include <common.h>
  16
  17 struct roc_model oct_model;
  18
  19 VLIB_REGISTER_LOG_CLASS (oct_log, static) = {
  20   .class_name = "octeon",
  21   .subclass_name = "init",
  22 };
  23
  24 #define _(f, n, s, d)                                                         \
  25   { .name = #n, .desc = d, .severity = VL_COUNTER_SEVERITY_##s },
  26
  27 vlib_error_desc_t oct_tx_node_counters[] = { foreach_oct_tx_node_counter };
  28 #undef _
  29
  30 vnet_dev_node_t oct_rx_node = {
  31   .format_trace = format_oct_rx_trace,
  32 };
  33
  34 vnet_dev_node_t oct_tx_node = {
  35   .format_trace = format_oct_tx_trace,
  36   .error_counters = oct_tx_node_counters,
  37   .n_error_counters = ARRAY_LEN (oct_tx_node_counters),
  38 };
  39
  40 static struct
  41 {
  42   u16 device_id;
  43   oct_device_type_t type;
  44   char *description;
  45 } oct_dev_types[] = {
  46
  47 #define _(id, device_type, desc)                                              \
  48   {                                                                           \
  49     .device_id = (id), .type = OCT_DEVICE_TYPE_##device_type,                 \
  50     .description = (desc)                                                     \
  51   }
  52
  53   _ (0xa063, RVU_PF, "Marvell Octeon Resource Virtualization Unit PF"),
  54   _ (0xa0f3, CPT_VF, "Marvell Octeon Cryptographic Accelerator Unit VF"),
  55 #undef _
  56 };
  57
  58 static u8 *
  59 oct_probe (vlib_main_t *vm, vnet_dev_bus_index_t bus_index, void *dev_info)
  60 {
  61   vnet_dev_bus_pci_device_info_t *di = dev_info;
  62
  63   if (di->vendor_id != 0x177d) /* Cavium */
  64     return 0;
  65
  66   FOREACH_ARRAY_ELT (dt, oct_dev_types)
  67     {
  68       if (dt->device_id == di->device_id)
  69         return format (0, "%s", dt->description);
  70     }
  71
  72   return 0;
  73 }
  74
  75 vnet_dev_rv_t
  76 cnx_return_roc_err (vnet_dev_t *dev, int rrv, char *fmt, ...)
  77 {
  78   va_list va;
  79   va_start (va, fmt);
  80   u8 *s = va_format (0, fmt, &va);
  81   va_end (va);
  82
  83   log_err (dev, "%v: %s [%d]", s, roc_error_msg_get (rrv), rrv);
  84   vec_free (s);
  85
  86   return VNET_DEV_ERR_UNSUPPORTED_DEVICE;
  87 }
  88
  89 static vnet_dev_rv_t
  90 oct_alloc (vlib_main_t *vm, vnet_dev_t *dev)
  91 {
  92   oct_device_t *cd = vnet_dev_get_data (dev);
  93   cd->nix =
  94     clib_mem_alloc_aligned (sizeof (struct roc_nix), CLIB_CACHE_LINE_BYTES);
  95   return VNET_DEV_OK;
  96 }
  97
  98 static vnet_dev_rv_t
  99 oct_init_nix (vlib_main_t *vm, vnet_dev_t *dev)
 100 {
 101   oct_device_t *cd = vnet_dev_get_data (dev);
 102   u8 mac_addr[6];
 103   int rrv;
 104   oct_port_t oct_port = {};
 105
 106   *cd->nix = (struct roc_nix){
 107     .reta_sz = ROC_NIX_RSS_RETA_SZ_256,
 108     .max_sqb_count = 512,
 109     .pci_dev = &cd->plt_pci_dev,
 110   };
 111
 112   if ((rrv = roc_nix_dev_init (cd->nix)))
 113     return cnx_return_roc_err (dev, rrv, "roc_nix_dev_init");
 114
 115   if (roc_nix_npc_mac_addr_get (cd->nix, mac_addr))
 116     return cnx_return_roc_err (dev, rrv, "roc_nix_npc_mac_addr_get");
 117
 118   vnet_dev_port_add_args_t port_add_args = {
 119     .port = {
 120       .attr = {
 121         .type = VNET_DEV_PORT_TYPE_ETHERNET,
 122         .max_rx_queues = 64,
 123         .max_tx_queues = 64,
 124         .max_supported_rx_frame_size = roc_nix_max_pkt_len (cd->nix),
 125         .caps = {
 126           .rss = 1,
 127         },
 128         .rx_offloads = {
 129           .ip4_cksum = 1,
 130         },
 131       },
 132       .ops = {
 133         .init = oct_port_init,
 134         .deinit = oct_port_deinit,
 135         .start = oct_port_start,
 136         .stop = oct_port_stop,
 137         .config_change = oct_port_cfg_change,
 138         .format_status = format_oct_port_status,
 139       },
 140       .data_size = sizeof (oct_port_t),
 141       .initial_data = &oct_port,
 142     },
 143     .rx_node = &oct_rx_node,
 144     .tx_node = &oct_tx_node,
 145     .rx_queue = {
 146       .config = {
 147         .data_size = sizeof (oct_rxq_t),
 148         .default_size = 1024,
 149         .multiplier = 32,
 150         .min_size = 256,
 151         .max_size = 16384,
 152       },
 153       .ops = {
 154         .alloc = oct_rx_queue_alloc,
 155         .free = oct_rx_queue_free,
 156         .format_info = format_oct_rxq_info,
 157       },
 158     },
 159     .tx_queue = {
 160       .config = {
 161         .data_size = sizeof (oct_txq_t),
 162         .default_size = 1024,
 163         .multiplier = 32,
 164         .min_size = 256,
 165         .max_size = 16384,
 166       },
 167       .ops = {
 168         .alloc = oct_tx_queue_alloc,
 169         .free = oct_tx_queue_free,
 170         .format_info = format_oct_txq_info,
 171       },
 172     },
 173   };
 174
 175   vnet_dev_set_hw_addr_eth_mac (&port_add_args.port.attr.hw_addr, mac_addr);
 176
 177   log_info (dev, "MAC address is %U", format_ethernet_address, mac_addr);
 178
 179   return vnet_dev_port_add (vm, dev, 0, &port_add_args);
 180 }
 181
 182 static vnet_dev_rv_t
 183 oct_init_cpt (vlib_main_t *vm, vnet_dev_t *dev)
 184 {
 185   oct_device_t *cd = vnet_dev_get_data (dev);
 186   int rrv;
 187   struct roc_cpt cpt = {
 188     .pci_dev = &cd->plt_pci_dev,
 189   };
 190
 191   if ((rrv = roc_cpt_dev_init (&cpt)))
 192     return cnx_return_roc_err (dev, rrv, "roc_cpt_dev_init");
 193   return VNET_DEV_OK;
 194 }
 195
 196 static vnet_dev_rv_t
 197 oct_init (vlib_main_t *vm, vnet_dev_t *dev)
 198 {
 199   oct_device_t *cd = vnet_dev_get_data (dev);
 200   vlib_pci_config_hdr_t pci_hdr;
 201   vnet_dev_rv_t rv;
 202
 203   rv = vnet_dev_pci_read_config_header (vm, dev, &pci_hdr);
 204   if (rv != VNET_DEV_OK)
 205     return rv;
 206
 207   if (pci_hdr.vendor_id != 0x177d)
 208     return VNET_DEV_ERR_UNSUPPORTED_DEVICE;
 209
 210   FOREACH_ARRAY_ELT (dt, oct_dev_types)
 211     {
 212       if (dt->device_id == pci_hdr.device_id)
 213         cd->type = dt->type;
 214     }
 215
 216   if (cd->type == OCT_DEVICE_TYPE_UNKNOWN)
 217     return rv;
 218
 219   rv = VNET_DEV_ERR_UNSUPPORTED_DEVICE;
 220
 221   cd->plt_pci_dev = (struct plt_pci_device){
 222     .id.vendor_id = pci_hdr.vendor_id,
 223     .id.device_id = pci_hdr.device_id,
 224     .id.class_id = pci_hdr.class << 16 | pci_hdr.subclass,
 225     .pci_handle = vnet_dev_get_pci_handle (dev),
 226   };
 227
 228   foreach_int (i, 2, 4)
 229     {
 230       rv = vnet_dev_pci_map_region (vm, dev, i,
 231                                     &cd->plt_pci_dev.mem_resource[i].addr);
 232       if (rv != VNET_DEV_OK)
 233         return rv;
 234     }
 235
 236   strncpy ((char *) cd->plt_pci_dev.name, dev->device_id,
 237            sizeof (cd->plt_pci_dev.name) - 1);
 238
 239   if (cd->type == OCT_DEVICE_TYPE_RVU_PF)
 240     return oct_init_nix (vm, dev);
 241   else if (cd->type == OCT_DEVICE_TYPE_CPT_VF)
 242     return oct_init_cpt (vm, dev);
 243   else
 244     return VNET_DEV_ERR_UNSUPPORTED_DEVICE;
 245
 246   return 0;
 247 }
 248
 249 static void
 250 oct_deinit (vlib_main_t *vm, vnet_dev_t *dev)
 251 {
 252   oct_device_t *cd = vnet_dev_get_data (dev);
 253
 254   if (cd->nix_initialized)
 255     roc_nix_dev_fini (cd->nix);
 256 }
 257
 258 static void
 259 oct_free (vlib_main_t *vm, vnet_dev_t *dev)
 260 {
 261   oct_device_t *cd = vnet_dev_get_data (dev);
 262
 263   if (cd->nix_initialized)
 264     roc_nix_dev_fini (cd->nix);
 265 }
 266
 267 VNET_DEV_REGISTER_DRIVER (octeon) = {
 268   .name = "octeon",
 269   .bus = "pci",
 270   .device_data_sz = sizeof (oct_device_t),
 271   .ops = {
 272     .alloc = oct_alloc,
 273     .init = oct_init,
 274     .deinit = oct_deinit,
 275     .free = oct_free,
 276     .probe = oct_probe,
 277   },
 278 };
 279
 280 static clib_error_t *
 281 oct_plugin_init (vlib_main_t *vm)
 282 {
 283   int rv;
 284   extern oct_plt_init_param_t oct_plt_init_param;
 285
 286   rv = oct_plt_init (&oct_plt_init_param);
 287   if (rv)
 288     return clib_error_return (0, "oct_plt_init failed");
 289
 290   rv = roc_model_init (&oct_model);
 291   if (rv)
 292     return clib_error_return (0, "roc_model_init failed");
 293   return 0;
 294 }
 295
 296 VLIB_INIT_FUNCTION (oct_plugin_init);
 297
 298 VLIB_PLUGIN_REGISTER () = {
 299   .version = VPP_BUILD_VER,
 300   .description = "dev_octeon",
 301 };