// SPDX-License-Identifier: GPL-2.0
/*
 * AMD AE4DMA driver
 *
 * Copyright (c) 2024, Advanced Micro Devices, Inc.
 * All Rights Reserved.
 *
 * Author: Basavaraj Natikar <Basavaraj.Natikar@amd.com>
 */

#include "ae4dma.h"

static int ae4_get_irqs(struct ae4_device *ae4)
{
        struct ae4_msix *ae4_msix = ae4->ae4_msix;
        struct pt_device *pt = &ae4->pt;
        struct device *dev = pt->dev;
        struct pci_dev *pdev;
        int i, v, ret;

        pdev = to_pci_dev(dev);

        for (v = 0; v < ARRAY_SIZE(ae4_msix->msix_entry); v++)
                ae4_msix->msix_entry[v].entry = v;

        ret = pci_alloc_irq_vectors(pdev, v, v, PCI_IRQ_MSIX);
        if (ret != v) {
                if (ret > 0)
                        pci_free_irq_vectors(pdev);

                dev_err(dev, "could not enable MSI-X (%d), trying MSI\n", ret);
                ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_MSI);
                if (ret < 0) {
                        dev_err(dev, "could not enable MSI (%d)\n", ret);
                        return ret;
                }

                ret = pci_irq_vector(pdev, 0);
                if (ret < 0) {
                        pci_free_irq_vectors(pdev);
                        return ret;
                }

                for (i = 0; i < MAX_AE4_HW_QUEUES; i++)
                        ae4->ae4_irq[i] = ret;

        } else {
                ae4_msix->msix_count = ret;
                for (i = 0; i < ae4_msix->msix_count; i++)
                        ae4->ae4_irq[i] = pci_irq_vector(pdev, i);
        }

        return ret;
}

static void ae4_free_irqs(struct ae4_device *ae4)
{
        struct ae4_msix *ae4_msix = ae4->ae4_msix;
        struct pt_device *pt = &ae4->pt;
        struct device *dev = pt->dev;
        struct pci_dev *pdev;

        pdev = to_pci_dev(dev);

        if (ae4_msix && (ae4_msix->msix_count || ae4->ae4_irq[MAX_AE4_HW_QUEUES - 1]))
                pci_free_irq_vectors(pdev);
}

static void ae4_deinit(struct ae4_device *ae4)
{
        ae4_free_irqs(ae4);
}

static int ae4_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
{
        struct device *dev = &pdev->dev;
        struct ae4_device *ae4;
        struct pt_device *pt;
        int bar_mask;
        int ret = 0;

        ae4 = devm_kzalloc(dev, sizeof(*ae4), GFP_KERNEL);
        if (!ae4)
                return -ENOMEM;

        ae4->ae4_msix = devm_kzalloc(dev, sizeof(struct ae4_msix), GFP_KERNEL);
        if (!ae4->ae4_msix)
                return -ENOMEM;

        ret = pcim_enable_device(pdev);
        if (ret)
                goto ae4_error;

        bar_mask = pci_select_bars(pdev, IORESOURCE_MEM);
        ret = pcim_iomap_regions(pdev, bar_mask, "ae4dma");
        if (ret)
                goto ae4_error;

        pt = &ae4->pt;
        pt->dev = dev;
        pt->ver = AE4_DMA_VERSION;

        pt->io_regs = pcim_iomap_table(pdev)[0];
        if (!pt->io_regs) {
                ret = -ENOMEM;
                goto ae4_error;
        }

        ret = ae4_get_irqs(ae4);
        if (ret < 0)
                goto ae4_error;

        pci_set_master(pdev);

        dma_set_mask_and_coherent(dev, DMA_BIT_MASK(48));

        dev_set_drvdata(dev, ae4);

        ret = ae4_core_init(ae4);
        if (ret)
                goto ae4_error;

        return 0;

ae4_error:
        ae4_deinit(ae4);

        return ret;
}

static void ae4_pci_remove(struct pci_dev *pdev)
{
        struct ae4_device *ae4 = dev_get_drvdata(&pdev->dev);

        ae4_destroy_work(ae4);
        ae4_deinit(ae4);
}

static const struct pci_device_id ae4_pci_table[] = {
        { PCI_VDEVICE(AMD, 0x149B), },
        /* Last entry must be zero */
        { 0, }
};
MODULE_DEVICE_TABLE(pci, ae4_pci_table);

static struct pci_driver ae4_pci_driver = {
        .name = "ae4dma",
        .id_table = ae4_pci_table,
        .probe = ae4_pci_probe,
        .remove = ae4_pci_remove,
};

module_pci_driver(ae4_pci_driver);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("AMD AE4DMA driver");