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   _ (0xa0f8, RVU_VF, "Marvell Octeon Resource Virtualization Unit VF"),
  55   _ (0xa0f7, SDP_VF, "Marvell Octeon System DPI Packet Interface Unit VF"),
  56   _ (0xa0f3, CPT_VF, "Marvell Octeon Cryptographic Accelerator Unit VF"),
  57 #undef _
  58 };
  59
  60 static u8 *
  61 oct_probe (vlib_main_t *vm, vnet_dev_bus_index_t bus_index, void *dev_info)
  62 {
  63   vnet_dev_bus_pci_device_info_t *di = dev_info;
  64
  65   if (di->vendor_id != 0x177d) /* Cavium */
  66     return 0;
  67
  68   FOREACH_ARRAY_ELT (dt, oct_dev_types)
  69     {
  70       if (dt->device_id == di->device_id)
  71         return format (0, "%s", dt->description);
  72     }
  73
  74   return 0;
  75 }
  76
  77 vnet_dev_rv_t
  78 cnx_return_roc_err (vnet_dev_t *dev, int rrv, char *fmt, ...)
  79 {
  80   va_list va;
  81   va_start (va, fmt);
  82   u8 *s = va_format (0, fmt, &va);
  83   va_end (va);
  84
  85   log_err (dev, "%v: %s [%d]", s, roc_error_msg_get (rrv), rrv);
  86   vec_free (s);
  87
  88   return VNET_DEV_ERR_UNSUPPORTED_DEVICE;
  89 }
  90
  91 static vnet_dev_rv_t
  92 oct_alloc (vlib_main_t *vm, vnet_dev_t *dev)
  93 {
  94   oct_device_t *cd = vnet_dev_get_data (dev);
  95   cd->nix =
  96     clib_mem_alloc_aligned (sizeof (struct roc_nix), CLIB_CACHE_LINE_BYTES);
  97   return VNET_DEV_OK;
  98 }
  99
 100 static vnet_dev_rv_t
 101 oct_init_nix (vlib_main_t *vm, vnet_dev_t *dev)
 102 {
 103   oct_device_t *cd = vnet_dev_get_data (dev);
 104   u8 mac_addr[6];
 105   int rrv;
 106   oct_port_t oct_port = {};
 107
 108   *cd->nix = (struct roc_nix){
 109     .reta_sz = ROC_NIX_RSS_RETA_SZ_256,
 110     .max_sqb_count = 512,
 111     .pci_dev = &cd->plt_pci_dev,
 112   };
 113
 114   if ((rrv = roc_nix_dev_init (cd->nix)))
 115     return cnx_return_roc_err (dev, rrv, "roc_nix_dev_init");
 116
 117   if ((rrv = roc_nix_npc_mac_addr_get (cd->nix, mac_addr)))
 118     return cnx_return_roc_err (dev, rrv, "roc_nix_npc_mac_addr_get");
 119
 120   vnet_dev_port_add_args_t port_add_args = {
 121     .port = {
 122       .attr = {
 123         .type = VNET_DEV_PORT_TYPE_ETHERNET,
 124         .max_rx_queues = 64,
 125         .max_tx_queues = 64,
 126         .max_supported_rx_frame_size = roc_nix_max_pkt_len (cd->nix),
 127         .caps = {
 128           .rss = 1,
 129         },
 130         .rx_offloads = {
 131           .ip4_cksum = 1,
 132         },
 133       },
 134       .ops = {
 135         .init = oct_port_init,
 136         .deinit = oct_port_deinit,
 137         .start = oct_port_start,
 138         .stop = oct_port_stop,
 139         .config_change = oct_port_cfg_change,
 140         .config_change_validate = oct_port_cfg_change_validate,
 141         .format_status = format_oct_port_status,
 142         .format_flow = format_oct_port_flow,
 143       },
 144       .data_size = sizeof (oct_port_t),
 145       .initial_data = &oct_port,
 146     },
 147     .rx_node = &oct_rx_node,
 148     .tx_node = &oct_tx_node,
 149     .rx_queue = {
 150       .config = {
 151         .data_size = sizeof (oct_rxq_t),
 152         .default_size = 1024,
 153         .multiplier = 32,
 154         .min_size = 256,
 155         .max_size = 16384,
 156       },
 157       .ops = {
 158         .alloc = oct_rx_queue_alloc,
 159         .free = oct_rx_queue_free,
 160         .format_info = format_oct_rxq_info,
 161       },
 162     },
 163     .tx_queue = {
 164       .config = {
 165         .data_size = sizeof (oct_txq_t),
 166         .default_size = 1024,
 167         .multiplier = 32,
 168         .min_size = 256,
 169         .max_size = 16384,
 170       },
 171       .ops = {
 172         .alloc = oct_tx_queue_alloc,
 173         .free = oct_tx_queue_free,
 174         .format_info = format_oct_txq_info,
 175       },
 176     },
 177   };
 178
 179   vnet_dev_set_hw_addr_eth_mac (&port_add_args.port.attr.hw_addr, mac_addr);
 180
 181   log_info (dev, "MAC address is %U", format_ethernet_address, mac_addr);
 182
 183   return vnet_dev_port_add (vm, dev, 0, &port_add_args);
 184 }
 185
 186 static vnet_dev_rv_t
 187 oct_init_cpt (vlib_main_t *vm, vnet_dev_t *dev)
 188 {
 189   oct_device_t *cd = vnet_dev_get_data (dev);
 190   int rrv;
 191   struct roc_cpt cpt = {
 192     .pci_dev = &cd->plt_pci_dev,
 193   };
 194
 195   if ((rrv = roc_cpt_dev_init (&cpt)))
 196     return cnx_return_roc_err (dev, rrv, "roc_cpt_dev_init");
 197   return VNET_DEV_OK;
 198 }
 199
 200 static vnet_dev_rv_t
 201 oct_init (vlib_main_t *vm, vnet_dev_t *dev)
 202 {
 203   oct_device_t *cd = vnet_dev_get_data (dev);
 204   vlib_pci_config_hdr_t pci_hdr;
 205   vnet_dev_rv_t rv;
 206
 207   rv = vnet_dev_pci_read_config_header (vm, dev, &pci_hdr);
 208   if (rv != VNET_DEV_OK)
 209     return rv;
 210
 211   if (pci_hdr.vendor_id != 0x177d)
 212     return VNET_DEV_ERR_UNSUPPORTED_DEVICE;
 213
 214   FOREACH_ARRAY_ELT (dt, oct_dev_types)
 215     {
 216       if (dt->device_id == pci_hdr.device_id)
 217         cd->type = dt->type;
 218     }
 219
 220   if (cd->type == OCT_DEVICE_TYPE_UNKNOWN)
 221     return rv;
 222
 223   rv = VNET_DEV_ERR_UNSUPPORTED_DEVICE;
 224
 225   cd->plt_pci_dev = (struct plt_pci_device){
 226     .id.vendor_id = pci_hdr.vendor_id,
 227     .id.device_id = pci_hdr.device_id,
 228     .id.class_id = pci_hdr.class << 16 | pci_hdr.subclass,
 229     .pci_handle = vnet_dev_get_pci_handle (dev),
 230   };
 231
 232   foreach_int (i, 2, 4)
 233     {
 234       rv = vnet_dev_pci_map_region (vm, dev, i,
 235                                     &cd->plt_pci_dev.mem_resource[i].addr);
 236       if (rv != VNET_DEV_OK)
 237         return rv;
 238     }
 239
 240   strncpy ((char *) cd->plt_pci_dev.name, dev->device_id,
 241            sizeof (cd->plt_pci_dev.name) - 1);
 242
 243   switch (cd->type)
 244     {
 245     case OCT_DEVICE_TYPE_RVU_PF:
 246     case OCT_DEVICE_TYPE_RVU_VF:
 247     case OCT_DEVICE_TYPE_SDP_VF:
 248       return oct_init_nix (vm, dev);
 249
 250     case OCT_DEVICE_TYPE_CPT_VF:
 251       return oct_init_cpt (vm, dev);
 252
 253     default:
 254       return VNET_DEV_ERR_UNSUPPORTED_DEVICE;
 255     }
 256
 257   return 0;
 258 }
 259
 260 static void
 261 oct_deinit (vlib_main_t *vm, vnet_dev_t *dev)
 262 {
 263   oct_device_t *cd = vnet_dev_get_data (dev);
 264
 265   if (cd->nix_initialized)
 266     roc_nix_dev_fini (cd->nix);
 267 }
 268
 269 static void
 270 oct_free (vlib_main_t *vm, vnet_dev_t *dev)
 271 {
 272   oct_device_t *cd = vnet_dev_get_data (dev);
 273
 274   if (cd->nix_initialized)
 275     roc_nix_dev_fini (cd->nix);
 276 }
 277
 278 VNET_DEV_REGISTER_DRIVER (octeon) = {
 279   .name = "octeon",
 280   .bus = "pci",
 281   .device_data_sz = sizeof (oct_device_t),
 282   .ops = {
 283     .alloc = oct_alloc,
 284     .init = oct_init,
 285     .deinit = oct_deinit,
 286     .free = oct_free,
 287     .probe = oct_probe,
 288   },
 289 };
 290
 291 static clib_error_t *
 292 oct_plugin_init (vlib_main_t *vm)
 293 {
 294   int rv;
 295   extern oct_plt_init_param_t oct_plt_init_param;
 296
 297   rv = oct_plt_init (&oct_plt_init_param);
 298   if (rv)
 299     return clib_error_return (0, "oct_plt_init failed");
 300
 301   rv = roc_model_init (&oct_model);
 302   if (rv)
 303     return clib_error_return (0, "roc_model_init failed");
 304   return 0;
 305 }
 306
 307 VLIB_INIT_FUNCTION (oct_plugin_init);
 308
 309 VLIB_PLUGIN_REGISTER () = {
 310   .version = VPP_BUILD_VER,
 311   .description = "dev_octeon",
 312 };