drivers/net/txgbe/txgbe_ethdev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2015-2020
   3  */
   4
   5 #include <stdio.h>
   6 #include <errno.h>
   7 #include <stdint.h>
   8 #include <string.h>
   9 #include <rte_common.h>
  10 #include <rte_ethdev_pci.h>
  11 #include <rte_pci.h>
  12 #include <rte_memory.h>
  13
  14 #include "txgbe_logs.h"
  15 #include "base/txgbe.h"
  16 #include "txgbe_ethdev.h"
  17
  18 static int txgbe_dev_close(struct rte_eth_dev *dev);
  19
  20 /*
  21  * The set of PCI devices this driver supports
  22  */
  23 static const struct rte_pci_id pci_id_txgbe_map[] = {
  24         { RTE_PCI_DEVICE(PCI_VENDOR_ID_WANGXUN, TXGBE_DEV_ID_RAPTOR_SFP) },
  25         { RTE_PCI_DEVICE(PCI_VENDOR_ID_WANGXUN, TXGBE_DEV_ID_WX1820_SFP) },
  26         { .vendor_id = 0, /* sentinel */ },
  27 };
  28
  29 static const struct eth_dev_ops txgbe_eth_dev_ops;
  30
  31 static inline int
  32 txgbe_is_sfp(struct txgbe_hw *hw)
  33 {
  34         switch (hw->phy.type) {
  35         case txgbe_phy_sfp_avago:
  36         case txgbe_phy_sfp_ftl:
  37         case txgbe_phy_sfp_intel:
  38         case txgbe_phy_sfp_unknown:
  39         case txgbe_phy_sfp_tyco_passive:
  40         case txgbe_phy_sfp_unknown_passive:
  41                 return 1;
  42         default:
  43                 return 0;
  44         }
  45 }
  46
  47 static int
  48 eth_txgbe_dev_init(struct rte_eth_dev *eth_dev, void *init_params __rte_unused)
  49 {
  50         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
  51         struct txgbe_hw *hw = TXGBE_DEV_HW(eth_dev);
  52         struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
  53         const struct rte_memzone *mz;
  54         uint16_t csum;
  55         int err;
  56
  57         PMD_INIT_FUNC_TRACE();
  58
  59         eth_dev->dev_ops = &txgbe_eth_dev_ops;
  60
  61         rte_eth_copy_pci_info(eth_dev, pci_dev);
  62
  63         /* Vendor and Device ID need to be set before init of shared code */
  64         hw->device_id = pci_dev->id.device_id;
  65         hw->vendor_id = pci_dev->id.vendor_id;
  66         hw->hw_addr = (void *)pci_dev->mem_resource[0].addr;
  67         hw->allow_unsupported_sfp = 1;
  68
  69         /* Reserve memory for interrupt status block */
  70         mz = rte_eth_dma_zone_reserve(eth_dev, "txgbe_driver", -1,
  71                 16, TXGBE_ALIGN, SOCKET_ID_ANY);
  72         if (mz == NULL)
  73                 return -ENOMEM;
  74
  75         hw->isb_dma = TMZ_PADDR(mz);
  76         hw->isb_mem = TMZ_VADDR(mz);
  77
  78         /* Initialize the shared code (base driver) */
  79         err = txgbe_init_shared_code(hw);
  80         if (err != 0) {
  81                 PMD_INIT_LOG(ERR, "Shared code init failed: %d", err);
  82                 return -EIO;
  83         }
  84
  85         err = hw->rom.init_params(hw);
  86         if (err != 0) {
  87                 PMD_INIT_LOG(ERR, "The EEPROM init failed: %d", err);
  88                 return -EIO;
  89         }
  90
  91         /* Make sure we have a good EEPROM before we read from it */
  92         err = hw->rom.validate_checksum(hw, &csum);
  93         if (err != 0) {
  94                 PMD_INIT_LOG(ERR, "The EEPROM checksum is not valid: %d", err);
  95                 return -EIO;
  96         }
  97
  98         /* Allocate memory for storing MAC addresses */
  99         eth_dev->data->mac_addrs = rte_zmalloc("txgbe", RTE_ETHER_ADDR_LEN *
 100                                                hw->mac.num_rar_entries, 0);
 101         if (eth_dev->data->mac_addrs == NULL) {
 102                 PMD_INIT_LOG(ERR,
 103                              "Failed to allocate %u bytes needed to store "
 104                              "MAC addresses",
 105                              RTE_ETHER_ADDR_LEN * hw->mac.num_rar_entries);
 106                 return -ENOMEM;
 107         }
 108
 109         /* Copy the permanent MAC address */
 110         rte_ether_addr_copy((struct rte_ether_addr *)hw->mac.perm_addr,
 111                         &eth_dev->data->mac_addrs[0]);
 112
 113         /* Allocate memory for storing hash filter MAC addresses */
 114         eth_dev->data->hash_mac_addrs = rte_zmalloc("txgbe",
 115                         RTE_ETHER_ADDR_LEN * TXGBE_VMDQ_NUM_UC_MAC, 0);
 116         if (eth_dev->data->hash_mac_addrs == NULL) {
 117                 PMD_INIT_LOG(ERR,
 118                              "Failed to allocate %d bytes needed to store MAC addresses",
 119                              RTE_ETHER_ADDR_LEN * TXGBE_VMDQ_NUM_UC_MAC);
 120                 return -ENOMEM;
 121         }
 122
 123         if (txgbe_is_sfp(hw) && hw->phy.sfp_type != txgbe_sfp_type_not_present)
 124                 PMD_INIT_LOG(DEBUG, "MAC: %d, PHY: %d, SFP+: %d",
 125                              (int)hw->mac.type, (int)hw->phy.type,
 126                              (int)hw->phy.sfp_type);
 127         else
 128                 PMD_INIT_LOG(DEBUG, "MAC: %d, PHY: %d",
 129                              (int)hw->mac.type, (int)hw->phy.type);
 130
 131         PMD_INIT_LOG(DEBUG, "port %d vendorID=0x%x deviceID=0x%x",
 132                      eth_dev->data->port_id, pci_dev->id.vendor_id,
 133                      pci_dev->id.device_id);
 134
 135         /* enable uio/vfio intr/eventfd mapping */
 136         rte_intr_enable(intr_handle);
 137
 138         return 0;
 139 }
 140
 141 static int
 142 eth_txgbe_dev_uninit(struct rte_eth_dev *eth_dev)
 143 {
 144         PMD_INIT_FUNC_TRACE();
 145
 146         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
 147                 return 0;
 148
 149         txgbe_dev_close(eth_dev);
 150
 151         return 0;
 152 }
 153
 154 static int
 155 eth_txgbe_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
 156                 struct rte_pci_device *pci_dev)
 157 {
 158         struct rte_eth_dev *pf_ethdev;
 159         struct rte_eth_devargs eth_da;
 160         int retval;
 161
 162         if (pci_dev->device.devargs) {
 163                 retval = rte_eth_devargs_parse(pci_dev->device.devargs->args,
 164                                 &eth_da);
 165                 if (retval)
 166                         return retval;
 167         } else {
 168                 memset(&eth_da, 0, sizeof(eth_da));
 169         }
 170
 171         retval = rte_eth_dev_create(&pci_dev->device, pci_dev->device.name,
 172                         sizeof(struct txgbe_adapter),
 173                         eth_dev_pci_specific_init, pci_dev,
 174                         eth_txgbe_dev_init, NULL);
 175
 176         if (retval || eth_da.nb_representor_ports < 1)
 177                 return retval;
 178
 179         pf_ethdev = rte_eth_dev_allocated(pci_dev->device.name);
 180         if (pf_ethdev == NULL)
 181                 return -ENODEV;
 182
 183         return 0;
 184 }
 185
 186 static int eth_txgbe_pci_remove(struct rte_pci_device *pci_dev)
 187 {
 188         struct rte_eth_dev *ethdev;
 189
 190         ethdev = rte_eth_dev_allocated(pci_dev->device.name);
 191         if (!ethdev)
 192                 return -ENODEV;
 193
 194         return rte_eth_dev_destroy(ethdev, eth_txgbe_dev_uninit);
 195 }
 196
 197 static struct rte_pci_driver rte_txgbe_pmd = {
 198         .id_table = pci_id_txgbe_map,
 199         .drv_flags = RTE_PCI_DRV_NEED_MAPPING |
 200                      RTE_PCI_DRV_INTR_LSC,
 201         .probe = eth_txgbe_pci_probe,
 202         .remove = eth_txgbe_pci_remove,
 203 };
 204
 205 /*
 206  * Reset and stop device.
 207  */
 208 static int
 209 txgbe_dev_close(struct rte_eth_dev *dev)
 210 {
 211         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
 212         struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
 213
 214         PMD_INIT_FUNC_TRACE();
 215
 216         /* disable uio intr before callback unregister */
 217         rte_intr_disable(intr_handle);
 218
 219         rte_free(dev->data->mac_addrs);
 220         dev->data->mac_addrs = NULL;
 221
 222         rte_free(dev->data->hash_mac_addrs);
 223         dev->data->hash_mac_addrs = NULL;
 224
 225         return 0;
 226 }
 227
 228 static const struct eth_dev_ops txgbe_eth_dev_ops = {
 229 };
 230
 231 RTE_PMD_REGISTER_PCI(net_txgbe, rte_txgbe_pmd);
 232 RTE_PMD_REGISTER_PCI_TABLE(net_txgbe, pci_id_txgbe_map);
 233 RTE_PMD_REGISTER_KMOD_DEP(net_txgbe, "* igb_uio | uio_pci_generic | vfio-pci");
 234
 235 RTE_LOG_REGISTER(txgbe_logtype_init, pmd.net.txgbe.init, NOTICE);
 236 RTE_LOG_REGISTER(txgbe_logtype_driver, pmd.net.txgbe.driver, NOTICE);
 237
 238 #ifdef RTE_LIBRTE_TXGBE_DEBUG_RX
 239         RTE_LOG_REGISTER(txgbe_logtype_rx, pmd.net.txgbe.rx, DEBUG);
 240 #endif
 241 #ifdef RTE_LIBRTE_TXGBE_DEBUG_TX
 242         RTE_LOG_REGISTER(txgbe_logtype_tx, pmd.net.txgbe.tx, DEBUG);
 243 #endif
 244
 245 #ifdef RTE_LIBRTE_TXGBE_DEBUG_TX_FREE
 246         RTE_LOG_REGISTER(txgbe_logtype_tx_free, pmd.net.txgbe.tx_free, DEBUG);
 247 #endif