// SPDX-License-Identifier: GPL-2.0
/*
 * AMD Promontory 21 xHCI host controller PCI Bus Glue.
 *
 * This does not add any PROM21-specific USB or xHCI operation. It exists only
 * to publish an auxiliary device for integrated temperature sensor support.
 *
 * Copyright (C) 2026 Jihong Min <hurryman2212@gmail.com>
 */

#include <linux/auxiliary_bus.h>
#include <linux/device/devres.h>
#include <linux/errno.h>
#include <linux/idr.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/platform_data/usb-xhci-prom21.h>
#include <linux/usb.h>
#include <linux/usb/hcd.h>

#include "xhci-pci.h"

struct prom21_xhci_auxdev {
        struct auxiliary_device *auxdev;
        struct prom21_xhci_pdata pdata;
        int id;
};

static DEFINE_IDA(prom21_xhci_auxdev_ida);

static void prom21_xhci_auxdev_release(struct device *dev, void *res)
{
        struct prom21_xhci_auxdev *prom21_auxdev = res;

        auxiliary_device_destroy(prom21_auxdev->auxdev);
        ida_free(&prom21_xhci_auxdev_ida, prom21_auxdev->id);
}

static int prom21_xhci_create_auxdev(struct pci_dev *pdev)
{
        struct prom21_xhci_auxdev *prom21_auxdev;
        struct usb_hcd *hcd = pci_get_drvdata(pdev);
        int ret;

        prom21_auxdev = devres_alloc(prom21_xhci_auxdev_release,
                                     sizeof(*prom21_auxdev), GFP_KERNEL);
        if (!prom21_auxdev)
                return -ENOMEM;

        prom21_auxdev->pdata.pdev = pdev;
        prom21_auxdev->pdata.regs = hcd->regs;
        prom21_auxdev->pdata.rsrc_len = hcd->rsrc_len;

        prom21_auxdev->id = ida_alloc(&prom21_xhci_auxdev_ida, GFP_KERNEL);
        if (prom21_auxdev->id < 0) {
                ret = prom21_auxdev->id;
                goto err_free_devres;
        }

        prom21_auxdev->auxdev = auxiliary_device_create(&pdev->dev,
                                                        KBUILD_MODNAME, "hwmon",
                                                        &prom21_auxdev->pdata,
                                                        prom21_auxdev->id);
        if (!prom21_auxdev->auxdev) {
                ret = -ENOMEM;
                goto err_free_ida;
        }

        devres_add(&pdev->dev, prom21_auxdev);
        return 0;

err_free_ida:
        ida_free(&prom21_xhci_auxdev_ida, prom21_auxdev->id);
err_free_devres:
        devres_free(prom21_auxdev);
        return ret;
}

static void prom21_xhci_destroy_auxdev(struct pci_dev *pdev)
{
        devres_release(&pdev->dev, prom21_xhci_auxdev_release, NULL, NULL);
}

static int prom21_xhci_probe(struct pci_dev *dev,
                             const struct pci_device_id *id)
{
        int retval;

        retval = xhci_pci_common_probe(dev, id);
        if (retval)
                return retval;

        retval = prom21_xhci_create_auxdev(dev);
        if (retval) {
                /*
                 * The auxiliary device only provides optional temperature sensor
                 * support. Keep the xHCI controller usable if it fails.
                 */
                dev_err(&dev->dev,
                        "failed to create PROM21 hwmon auxiliary device: %d\n",
                        retval);
        }

        return 0;
}

static void prom21_xhci_remove(struct pci_dev *dev)
{
        prom21_xhci_destroy_auxdev(dev);
        xhci_pci_remove(dev);
}

static const struct pci_device_id pci_ids[] = {
        { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_PROM21_XHCI_43FC) },
        { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_PROM21_XHCI_43FD) },
        { /* end: all zeroes */ }
};
MODULE_DEVICE_TABLE(pci, pci_ids);

static struct pci_driver prom21_xhci_driver = {
        .name = "xhci-pci-prom21",
        .id_table = pci_ids,

        .probe = prom21_xhci_probe,
        .remove = prom21_xhci_remove,

        .shutdown = usb_hcd_pci_shutdown,
        .driver = {
                .pm = pm_ptr(&usb_hcd_pci_pm_ops),
        },
};
module_pci_driver(prom21_xhci_driver);

MODULE_AUTHOR("Jihong Min <hurryman2212@gmail.com>");
MODULE_DESCRIPTION("AMD Promontory 21 xHCI PCI Host Controller Driver");
MODULE_IMPORT_NS("xhci");
MODULE_LICENSE("GPL");