drivers/net/cxgbe/cxgbevf_ethdev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Chelsio Communications.
   3  * All rights reserved.
   4  */
   5
   6 #include <rte_ethdev_driver.h>
   7 #include <rte_ethdev_pci.h>
   8
   9 #include "cxgbe.h"
  10 #include "cxgbe_pfvf.h"
  11
  12 /*
  13  * Macros needed to support the PCI Device ID Table ...
  14  */
  15 #define CH_PCI_DEVICE_ID_TABLE_DEFINE_BEGIN \
  16         static const struct rte_pci_id cxgb4vf_pci_tbl[] = {
  17 #define CH_PCI_DEVICE_ID_FUNCTION 0x8
  18
  19 #define PCI_VENDOR_ID_CHELSIO 0x1425
  20
  21 #define CH_PCI_ID_TABLE_ENTRY(devid) \
  22                 { RTE_PCI_DEVICE(PCI_VENDOR_ID_CHELSIO, (devid)) }
  23
  24 #define CH_PCI_DEVICE_ID_TABLE_DEFINE_END \
  25                 { .vendor_id = 0, } \
  26         }
  27
  28 /*
  29  *... and the PCI ID Table itself ...
  30  */
  31 #include "t4_pci_id_tbl.h"
  32
  33 static const struct eth_dev_ops cxgbevf_eth_dev_ops = {
  34         .dev_start              = cxgbe_dev_start,
  35         .dev_stop               = cxgbe_dev_stop,
  36         .dev_close              = cxgbe_dev_close,
  37         .promiscuous_enable     = cxgbe_dev_promiscuous_enable,
  38         .promiscuous_disable    = cxgbe_dev_promiscuous_disable,
  39         .allmulticast_enable    = cxgbe_dev_allmulticast_enable,
  40         .allmulticast_disable   = cxgbe_dev_allmulticast_disable,
  41         .dev_configure          = cxgbe_dev_configure,
  42         .dev_infos_get          = cxgbe_dev_info_get,
  43         .dev_supported_ptypes_get = cxgbe_dev_supported_ptypes_get,
  44         .link_update            = cxgbe_dev_link_update,
  45         .mtu_set                = cxgbe_dev_mtu_set,
  46         .tx_queue_setup         = cxgbe_dev_tx_queue_setup,
  47         .tx_queue_start         = cxgbe_dev_tx_queue_start,
  48         .tx_queue_stop          = cxgbe_dev_tx_queue_stop,
  49         .tx_queue_release       = cxgbe_dev_tx_queue_release,
  50         .rx_queue_setup         = cxgbe_dev_rx_queue_setup,
  51         .rx_queue_start         = cxgbe_dev_rx_queue_start,
  52         .rx_queue_stop          = cxgbe_dev_rx_queue_stop,
  53         .rx_queue_release       = cxgbe_dev_rx_queue_release,
  54 };
  55
  56 /*
  57  * Initialize driver
  58  * It returns 0 on success.
  59  */
  60 static int eth_cxgbevf_dev_init(struct rte_eth_dev *eth_dev)
  61 {
  62         struct port_info *pi = (struct port_info *)(eth_dev->data->dev_private);
  63         struct rte_pci_device *pci_dev;
  64         char name[RTE_ETH_NAME_MAX_LEN];
  65         struct adapter *adapter = NULL;
  66         int err = 0;
  67
  68         CXGBE_FUNC_TRACE();
  69
  70         eth_dev->dev_ops = &cxgbevf_eth_dev_ops;
  71         eth_dev->rx_pkt_burst = &cxgbe_recv_pkts;
  72         eth_dev->tx_pkt_burst = &cxgbe_xmit_pkts;
  73         pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
  74
  75         /* for secondary processes, we attach to ethdevs allocated by primary
  76          * and do minimal initialization.
  77          */
  78         if (rte_eal_process_type() != RTE_PROC_PRIMARY) {
  79                 int i;
  80
  81                 for (i = 1; i < MAX_NPORTS; i++) {
  82                         struct rte_eth_dev *rest_eth_dev;
  83                         char namei[RTE_ETH_NAME_MAX_LEN];
  84
  85                         snprintf(namei, sizeof(namei), "%s_%d",
  86                                  pci_dev->device.name, i);
  87                         rest_eth_dev = rte_eth_dev_attach_secondary(namei);
  88                         if (rest_eth_dev) {
  89                                 rest_eth_dev->device = &pci_dev->device;
  90                                 rest_eth_dev->dev_ops =
  91                                         eth_dev->dev_ops;
  92                                 rest_eth_dev->rx_pkt_burst =
  93                                         eth_dev->rx_pkt_burst;
  94                                 rest_eth_dev->tx_pkt_burst =
  95                                         eth_dev->tx_pkt_burst;
  96                         }
  97                 }
  98                 return 0;
  99         }
 100
 101         snprintf(name, sizeof(name), "cxgbevfadapter%d",
 102                  eth_dev->data->port_id);
 103         adapter = rte_zmalloc(name, sizeof(*adapter), 0);
 104         if (!adapter)
 105                 return -1;
 106
 107         adapter->use_unpacked_mode = 1;
 108         adapter->regs = (void *)pci_dev->mem_resource[0].addr;
 109         if (!adapter->regs) {
 110                 dev_err(adapter, "%s: cannot map device registers\n", __func__);
 111                 err = -ENOMEM;
 112                 goto out_free_adapter;
 113         }
 114         adapter->pdev = pci_dev;
 115         adapter->eth_dev = eth_dev;
 116         pi->adapter = adapter;
 117         err = cxgbevf_probe(adapter);
 118         if (err) {
 119                 dev_err(adapter, "%s: cxgbevf probe failed with err %d\n",
 120                         __func__, err);
 121                 goto out_free_adapter;
 122         }
 123
 124         return 0;
 125
 126 out_free_adapter:
 127         rte_free(adapter);
 128         return err;
 129 }
 130
 131 static int eth_cxgbevf_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
 132                                  struct rte_pci_device *pci_dev)
 133 {
 134         return rte_eth_dev_pci_generic_probe(pci_dev, sizeof(struct port_info),
 135                                              eth_cxgbevf_dev_init);
 136 }
 137
 138 static int eth_cxgbevf_pci_remove(struct rte_pci_device *pci_dev)
 139 {
 140         return rte_eth_dev_pci_generic_remove(pci_dev, NULL);
 141 }
 142
 143 static struct rte_pci_driver rte_cxgbevf_pmd = {
 144         .id_table = cxgb4vf_pci_tbl,
 145         .drv_flags = RTE_PCI_DRV_NEED_MAPPING,
 146         .probe = eth_cxgbevf_pci_probe,
 147         .remove = eth_cxgbevf_pci_remove,
 148 };
 149
 150 RTE_PMD_REGISTER_PCI(net_cxgbevf, rte_cxgbevf_pmd);
 151 RTE_PMD_REGISTER_PCI_TABLE(net_cxgbevf, cxgb4vf_pci_tbl);
 152 RTE_PMD_REGISTER_KMOD_DEP(net_cxgbevf, "* igb_uio | vfio-pci");