#include <linux/module.h>
#include <linux/bitmap.h>
#include <linux/cdx/cdx_bus.h>
#include <linux/msi.h>
#include <linux/xarray.h>
#include <net/mana/mana.h>
#define MANA_CDX_GDMA_REGS_SIZE (GDMA_REG_SHM_OFFSET + sizeof(u64))
static int mana_cdx_msix_virq(struct gdma_context *gc, int msi)
{
unsigned int virq = msi_get_virq(gc->dev, msi);
return virq ? virq : -EINVAL;
}
static int mana_cdx_dev_reset(struct gdma_context *gc)
{
return cdx_dev_reset(gc->dev);
}
static int mana_cdx_setup_hwc_irqs(struct gdma_context *gc)
{
struct cdx_device *cdx_dev = to_cdx_device(gc->dev);
struct gdma_irq_context *gic;
unsigned int max_irqs;
int nvec;
int err, i = 0, j;
max_irqs = cdx_dev->num_msi;
if (max_irqs < 2) {
dev_err(&cdx_dev->dev, "Not enough MSI vectors: %u\n",
max_irqs);
return -ENOSPC;
}
err = dma_set_mask_and_coherent(gc->dev, DMA_BIT_MASK(32));
if (err) {
dev_err(&cdx_dev->dev, "Failed to set 32-bit DMA mask\n");
return err;
}
err = cdx_enable_msi(cdx_dev);
if (err) {
dev_err(&cdx_dev->dev, "Failed to enable MSI\n");
return err;
}
err = msi_domain_alloc_irqs(gc->dev, MSI_DEFAULT_DOMAIN, max_irqs);
if (err) {
dev_err(&cdx_dev->dev, "Failed to alloc MSI IRQs\n");
cdx_disable_msi(cdx_dev);
return err;
}
nvec = max_irqs;
xa_init(&gc->irq_contexts);
for (i = 0; i < nvec; i++) {
int msi = i;
gic = mana_gd_get_gic(gc, false, &msi);
if (IS_ERR(gic)) {
err = PTR_ERR(gic);
goto free_irq;
}
}
gc->max_num_msix = nvec;
gc->num_msix_usable = nvec;
gc->msi_sharing = false;
gc->msi_bitmap = bitmap_zalloc(nvec, GFP_KERNEL);
if (!gc->msi_bitmap) {
err = -ENOMEM;
goto free_irq;
}
set_bit(0, gc->msi_bitmap);
return 0;
free_irq:
for (j = i - 1; j >= 0; j--)
mana_gd_put_gic(gc, false, j);
xa_destroy(&gc->irq_contexts);
msi_domain_free_irqs_all(gc->dev, MSI_DEFAULT_DOMAIN);
cdx_disable_msi(cdx_dev);
return err;
}
static void mana_cdx_remove_irqs(struct gdma_context *gc)
{
struct cdx_device *cdx_dev = to_cdx_device(gc->dev);
int i;
if (gc->max_num_msix < 1)
return;
for (i = 0; i < gc->max_num_msix; i++) {
if (!xa_load(&gc->irq_contexts, i))
continue;
mana_gd_put_gic(gc, false, i);
}
WARN_ON(!xa_empty(&gc->irq_contexts));
xa_destroy(&gc->irq_contexts);
msi_domain_free_irqs_all(gc->dev, MSI_DEFAULT_DOMAIN);
cdx_disable_msi(cdx_dev);
bitmap_free(gc->msi_bitmap);
gc->msi_bitmap = NULL;
gc->max_num_msix = 0;
gc->num_msix_usable = 0;
}
static int mana_cdx_setup_remaining_irqs(struct gdma_context *gc)
{
unsigned int max_queues_vport;
gc->msi_sharing = false;
max_queues_vport = (gc->num_msix_usable - 1) / gc->num_ports;
if (!max_queues_vport) {
dev_err(gc->dev, "%u MSI vectors cannot serve %u vPorts\n",
gc->num_msix_usable, gc->num_ports);
return -ENOSPC;
}
gc->max_num_queues_vport = min(gc->max_num_queues, max_queues_vport);
dev_dbg(gc->dev, "%u MSI vectors, %u vPorts, %u queues, no MSI sharing\n",
gc->num_msix_usable, gc->num_ports, gc->max_num_queues_vport);
return 0;
}
static const struct gdma_bus_ops mana_cdx_bus_ops = {
.bus_name = "cdx",
.adev_prefix = "mana_cdx",
.msix_virq = mana_cdx_msix_virq,
.setup_hwc_irqs = mana_cdx_setup_hwc_irqs,
.setup_remaining_irqs = mana_cdx_setup_remaining_irqs,
.remove_irqs = mana_cdx_remove_irqs,
.dev_reset = mana_cdx_dev_reset,
};
static int mana_cdx_gd_probe(struct cdx_device *cdx_dev)
{
struct gdma_context *gc;
void __iomem *bar0_va;
int err;
BUILD_BUG_ON(2 * MAX_PORTS_IN_MANA_DEV * GDMA_EQE_SIZE > EQ_SIZE);
err = cdx_dev_reset(&cdx_dev->dev);
if (err)
return err;
err = cdx_set_master(cdx_dev);
if (err)
return err;
gc = vzalloc(sizeof(*gc));
if (!gc) {
err = -ENOMEM;
goto clear_master;
}
mutex_init(&gc->eq_test_event_mutex);
mutex_init(&gc->gic_mutex);
dev_set_drvdata(&cdx_dev->dev, gc);
gc->bar0_pa = cdx_resource_start(cdx_dev, 0);
gc->bar0_size = cdx_resource_len(cdx_dev, 0);
if (gc->bar0_size < MANA_CDX_GDMA_REGS_SIZE) {
dev_err(&cdx_dev->dev, "BAR0 size %#llx is too small\n",
(u64)gc->bar0_size);
err = -EINVAL;
goto free_gc;
}
bar0_va = ioremap(gc->bar0_pa, gc->bar0_size);
if (!bar0_va) {
err = -ENOMEM;
goto free_gc;
}
gc->numa_node = dev_to_node(&cdx_dev->dev);
gc->bar0_va = bar0_va;
gc->dev = &cdx_dev->dev;
gc->bus_ops = &mana_cdx_bus_ops;
err = mana_gd_setup(gc);
if (err)
goto unmap_bar;
err = mana_probe(&gc->mana, false);
if (err)
goto cleanup_gd;
err = mana_rdma_probe(&gc->mana_ib);
if (err)
goto remove_mana;
if (test_and_set_bit(GC_PROBE_SUCCEEDED, &gc->flags)) {
err = -EPROTO;
goto remove_rdma;
}
return 0;
remove_rdma:
mana_rdma_remove(&gc->mana_ib);
remove_mana:
mana_remove(&gc->mana, false);
cleanup_gd:
mana_gd_cleanup(gc);
unmap_bar:
iounmap(bar0_va);
free_gc:
dev_set_drvdata(&cdx_dev->dev, NULL);
vfree(gc);
clear_master:
cdx_clear_master(cdx_dev);
return err;
}
static int mana_cdx_gd_remove(struct cdx_device *cdx_dev)
{
struct gdma_context *gc = dev_get_drvdata(&cdx_dev->dev);
mana_rdma_remove(&gc->mana_ib);
mana_remove(&gc->mana, false);
mana_gd_cleanup(gc);
cdx_clear_master(cdx_dev);
iounmap(gc->bar0_va);
dev_set_drvdata(&cdx_dev->dev, NULL);
vfree(gc);
return 0;
}
static void mana_cdx_gd_shutdown(struct cdx_device *cdx_dev)
{
struct gdma_context *gc = dev_get_drvdata(&cdx_dev->dev);
mana_rdma_remove(&gc->mana_ib);
mana_remove(&gc->mana, true);
mana_gd_cleanup(gc);
cdx_clear_master(cdx_dev);
}
#define CDX_VENDOR_ID_MICROSOFT 0x1414
static const struct cdx_device_id mana_cdx_table[] = {
{ CDX_DEVICE(CDX_VENDOR_ID_MICROSOFT, MANA_CDX_DEVICE_ID) },
{}
};
MODULE_DEVICE_TABLE(cdx, mana_cdx_table);
static struct cdx_driver gdma_cdx_driver = {
.match_id_table = mana_cdx_table,
.probe = mana_cdx_gd_probe,
.remove = mana_cdx_gd_remove,
.shutdown = mana_cdx_gd_shutdown,
.driver = {
.name = "mana_cdx",
},
};
module_driver(gdma_cdx_driver, cdx_driver_register, cdx_driver_unregister);
MODULE_LICENSE("Dual BSD/GPL");
MODULE_DESCRIPTION("Microsoft Azure Network Adapter driver for the CDX bus");
MODULE_IMPORT_NS("CDX_BUS");
MODULE_IMPORT_NS("NET_MANA"