#include <linux/dma-mapping.h>
#include <linux/err.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/pci.h>
#include <linux/slab.h>
#include <linux/types.h>
#include "mpnic.h"
#include "mpnic_netdev.h"
#include "mpnic_txrx.h"
#define PCI_DEVICE_ID_META_MPNIC 0x0014
static void mpnic_mmio_err(struct mpnic_dev *mpd, u32 reg)
{
WRITE_ONCE(mpd->uc_addr0, NULL);
dev_err(mpd->dev,
"Failed read (idx 0x%x AKA addr 0x%x), disabled CSR access, awaiting reset\n",
reg, reg << 2);
if (mpd->netdev)
netif_device_detach(mpd->netdev);
}
u64 mpnic_rd64(struct mpnic_dev *mpd, u32 reg)
{
u32 __iomem *csr = READ_ONCE(mpd->uc_addr0);
u64 value;
if (!csr)
return ~0ULL;
value = readq(csr + reg);
if (~value)
return value;
if (reg != MPNIC_BDQ_SPARE && ~readq(csr + MPNIC_BDQ_SPARE))
return value;
mpnic_mmio_err(mpd, reg);
return ~0ULL;
}
static void mpnic_service_task(struct work_struct *work)
{
struct mpnic_dev *mpd = container_of(to_delayed_work(work),
struct mpnic_dev, service_task);
struct net_device *netdev = mpd->netdev;
netdev_lock(netdev);
if (netif_carrier_ok(netdev))
mpnic_napi_depletion_check(netdev_priv(netdev));
if (netif_running(netdev))
schedule_delayed_work(&mpd->service_task, HZ);
netdev_unlock(netdev);
}
static struct mpnic_dev *mpnic_alloc(struct pci_dev *pdev)
{
struct mpnic_dev *mpd;
mpd = kzalloc_obj(*mpd);
if (!mpd)
return NULL;
pci_set_drvdata(pdev, mpd);
mpd->dev = &pdev->dev;
mpd->dsn = pci_get_dsn(pdev);
mpd->mps = pcie_get_mps(pdev);
mpd->readrq = pcie_get_readrq(pdev);
mpd->relaxed_ord = pcie_relaxed_ordering_enabled(pdev);
INIT_DELAYED_WORK(&mpd->service_task, mpnic_service_task);
return mpd;
}
static int mpnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
{
struct net_device *netdev;
void __iomem *uc_addr0;
struct mpnic_dev *mpd;
int err;
if (pdev->error_state != pci_channel_io_normal) {
dev_err(&pdev->dev,
"PCI device still in an error state. Unable to load...\n");
return -EIO;
}
err = pcim_enable_device(pdev);
if (err) {
dev_err(&pdev->dev, "PCI enable device failed: %d\n", err);
return err;
}
err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(46));
if (err) {
dev_err(&pdev->dev, "DMA configuration failed: %d\n", err);
return err;
}
mpd = mpnic_alloc(pdev);
if (!mpd)
return -ENOMEM;
uc_addr0 = pcim_iomap_region(pdev, 0, MPNIC_DRV_NAME);
if (IS_ERR(uc_addr0)) {
err = PTR_ERR(uc_addr0);
dev_err(&pdev->dev, "Mapping the register file failed: %d\n",
err);
goto err_free_mpd;
}
mpd->uc_addr0 = uc_addr0;
pci_set_master(pdev);
pci_save_state(pdev);
err = mpnic_alloc_irqs(mpd);
if (err)
goto err_free_mpd;
err = mpnic_dev_init(mpd);
if (err)
goto err_free_irqs;
netdev = mpnic_netdev_alloc(mpd);
if (!netdev) {
dev_err(&pdev->dev, "Netdev allocation failed\n");
err = -ENOMEM;
goto err_free_irqs;
}
err = mpnic_netdev_register(netdev);
if (err) {
dev_err(&pdev->dev, "Netdev registration failed: %d\n", err);
goto err_free_netdev;
}
return 0;
err_free_netdev:
mpnic_netdev_free(mpd);
err_free_irqs:
mpnic_free_irqs(mpd);
err_free_mpd:
kfree(mpd);
return err;
}
static void mpnic_remove(struct pci_dev *pdev)
{
struct mpnic_dev *mpd = pci_get_drvdata(pdev);
unregister_netdev(mpd->netdev);
cancel_delayed_work_sync(&mpd->service_task);
mpnic_netdev_free(mpd);
mpnic_free_irqs(mpd);
kfree(mpd);
}
static const struct pci_device_id mpnic_pci_tbl[] = {
{ PCI_VDEVICE(META, PCI_DEVICE_ID_META_MPNIC) },
{}
};
MODULE_DEVICE_TABLE(pci, mpnic_pci_tbl);
static struct pci_driver mpnic_driver = {
.name = MPNIC_DRV_NAME,
.id_table = mpnic_pci_tbl,
.probe = mpnic_probe,
.remove = mpnic_remove,
};
module_pci_driver(mpnic_driver);
MODULE_DESCRIPTION("Meta Platforms Network Interface Controller");
MODULE_LICENSE("GPL"