// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
 * Author: Manivannan Sadhasivam <manivannan.sadhasivam@oss.qualcomm.com>
 */

#include <linux/device.h>
#include <linux/delay.h>
#include <linux/gpio/consumer.h>
#include <linux/list.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_graph.h>
#include <linux/of_platform.h>
#include <linux/pci.h>
#include <linux/platform_device.h>
#include <linux/pwrseq/provider.h>
#include <linux/regulator/consumer.h>
#include <linux/serdev.h>
#include <linux/slab.h>

struct pwrseq_pci_dev {
        struct serdev_device *serdev;
        struct of_changeset *ocs;
        struct pci_dev *pdev;
        struct list_head list;
};

struct pwrseq_pcie_m2_pdata {
        const struct pwrseq_target_data **targets;
};

struct pwrseq_pcie_m2_ctx {
        struct pwrseq_device *pwrseq;
        struct device_node *of_node;
        const struct pwrseq_pcie_m2_pdata *pdata;
        struct regulator_bulk_data *regs;
        size_t num_vregs;
        struct notifier_block nb;
        struct gpio_desc *w_disable1_gpio;
        struct gpio_desc *w_disable2_gpio;
        struct device *dev;
        struct list_head pci_devices;
        struct mutex list_lock;
};

static int pwrseq_pcie_m2_vregs_enable(struct pwrseq_device *pwrseq)
{
        struct pwrseq_pcie_m2_ctx *ctx = pwrseq_device_get_drvdata(pwrseq);

        return regulator_bulk_enable(ctx->num_vregs, ctx->regs);
}

static int pwrseq_pcie_m2_vregs_disable(struct pwrseq_device *pwrseq)
{
        struct pwrseq_pcie_m2_ctx *ctx = pwrseq_device_get_drvdata(pwrseq);

        return regulator_bulk_disable(ctx->num_vregs, ctx->regs);
}

static const struct pwrseq_unit_data pwrseq_pcie_m2_vregs_unit_data = {
        .name = "regulators-enable",
        .enable = pwrseq_pcie_m2_vregs_enable,
        .disable = pwrseq_pcie_m2_vregs_disable,
};

static const struct pwrseq_unit_data *pwrseq_pcie_m2_unit_deps[] = {
        &pwrseq_pcie_m2_vregs_unit_data,
        NULL
};

static int pwrseq_pci_m2_e_uart_enable(struct pwrseq_device *pwrseq)
{
        struct pwrseq_pcie_m2_ctx *ctx = pwrseq_device_get_drvdata(pwrseq);

        return gpiod_set_value_cansleep(ctx->w_disable2_gpio, 0);
}

static int pwrseq_pci_m2_e_uart_disable(struct pwrseq_device *pwrseq)
{
        struct pwrseq_pcie_m2_ctx *ctx = pwrseq_device_get_drvdata(pwrseq);

        return gpiod_set_value_cansleep(ctx->w_disable2_gpio, 1);
}

static const struct pwrseq_unit_data pwrseq_pcie_m2_e_uart_unit_data = {
        .name = "uart-enable",
        .deps = pwrseq_pcie_m2_unit_deps,
        .enable = pwrseq_pci_m2_e_uart_enable,
        .disable = pwrseq_pci_m2_e_uart_disable,
};

static int pwrseq_pci_m2_e_pcie_enable(struct pwrseq_device *pwrseq)
{
        struct pwrseq_pcie_m2_ctx *ctx = pwrseq_device_get_drvdata(pwrseq);

        return gpiod_set_value_cansleep(ctx->w_disable1_gpio, 0);
}

static int pwrseq_pci_m2_e_pcie_disable(struct pwrseq_device *pwrseq)
{
        struct pwrseq_pcie_m2_ctx *ctx = pwrseq_device_get_drvdata(pwrseq);

        return gpiod_set_value_cansleep(ctx->w_disable1_gpio, 1);
}

static const struct pwrseq_unit_data pwrseq_pcie_m2_e_pcie_unit_data = {
        .name = "pcie-enable",
        .deps = pwrseq_pcie_m2_unit_deps,
        .enable = pwrseq_pci_m2_e_pcie_enable,
        .disable = pwrseq_pci_m2_e_pcie_disable,
};

static const struct pwrseq_unit_data pwrseq_pcie_m2_m_pcie_unit_data = {
        .name = "pcie-enable",
        .deps = pwrseq_pcie_m2_unit_deps,
};

static int pwrseq_pcie_m2_e_pwup_delay(struct pwrseq_device *pwrseq)
{
        /*
         * FIXME: This delay is only required for some Qcom WLAN/BT cards like
         * WCN7850 and not for all devices. But currently, there is no way to
         * identify the device model before enumeration.
         */
        msleep(50);

        return 0;
}

static const struct pwrseq_target_data pwrseq_pcie_m2_e_uart_target_data = {
        .name = "uart",
        .unit = &pwrseq_pcie_m2_e_uart_unit_data,
        .post_enable = pwrseq_pcie_m2_e_pwup_delay,
};

static const struct pwrseq_target_data pwrseq_pcie_m2_e_pcie_target_data = {
        .name = "pcie",
        .unit = &pwrseq_pcie_m2_e_pcie_unit_data,
        .post_enable = pwrseq_pcie_m2_e_pwup_delay,
};

static const struct pwrseq_target_data pwrseq_pcie_m2_m_pcie_target_data = {
        .name = "pcie",
        .unit = &pwrseq_pcie_m2_m_pcie_unit_data,
};

static const struct pwrseq_target_data *pwrseq_pcie_m2_e_targets[] = {
        &pwrseq_pcie_m2_e_pcie_target_data,
        &pwrseq_pcie_m2_e_uart_target_data,
        NULL
};

static const struct pwrseq_target_data *pwrseq_pcie_m2_m_targets[] = {
        &pwrseq_pcie_m2_m_pcie_target_data,
        NULL
};

static const struct pwrseq_pcie_m2_pdata pwrseq_pcie_m2_e_of_data = {
        .targets = pwrseq_pcie_m2_e_targets,
};

static const struct pwrseq_pcie_m2_pdata pwrseq_pcie_m2_m_of_data = {
        .targets = pwrseq_pcie_m2_m_targets,
};

static int pwrseq_pcie_m2_match(struct pwrseq_device *pwrseq,
                                 struct device *dev)
{
        struct pwrseq_pcie_m2_ctx *ctx = pwrseq_device_get_drvdata(pwrseq);
        struct device_node *endpoint __free(device_node) = NULL;

        /*
         * Traverse the 'remote-endpoint' nodes and check if the remote node's
         * parent matches the OF node of 'dev'.
         */
        for_each_endpoint_of_node(ctx->of_node, endpoint) {
                struct device_node *remote __free(device_node) =
                                of_graph_get_remote_port_parent(endpoint);
                if (remote && (remote == dev_of_node(dev)))
                        return PWRSEQ_MATCH_OK;
        }

        return PWRSEQ_NO_MATCH;
}

static const struct pci_device_id pwrseq_m2_pci_ids[] = {
        { PCI_DEVICE(PCI_VENDOR_ID_QCOM, 0x1103),
          .driver_data = (kernel_ulong_t)"qcom,wcn6855-bt" },
        { PCI_DEVICE(PCI_VENDOR_ID_QCOM, 0x1107),
          .driver_data = (kernel_ulong_t)"qcom,wcn7850-bt" },
        { } /* Sentinel */
};

static int pwrseq_pcie_m2_create_bt_node(struct pwrseq_pcie_m2_ctx *ctx,
                                        struct pwrseq_pci_dev *pci_dev,
                                        struct device_node *parent,
                                        struct pci_dev *pdev)
{
        const struct pci_device_id *id;
        struct device *dev = ctx->dev;
        const char *compatible;
        struct device_node *np;
        int ret;

        id = pci_match_id(pwrseq_m2_pci_ids, pdev);
        if (WARN_ON_ONCE(!id)) /* Shouldn't happen */
                return -ENODEV;

        compatible = (const char *)id->driver_data;

        pci_dev->ocs = kzalloc_obj(*pci_dev->ocs);
        if (!pci_dev->ocs)
                return -ENOMEM;

        of_changeset_init(pci_dev->ocs);

        np = of_changeset_create_node(pci_dev->ocs, parent, "bluetooth");
        if (!np) {
                dev_err(dev, "Failed to create bluetooth node\n");
                ret = -ENODEV;
                goto err_destroy_changeset;
        }

        ret = of_changeset_add_prop_string(pci_dev->ocs, np, "compatible", compatible);
        if (ret) {
                dev_err(dev, "Failed to add bluetooth compatible: %d\n", ret);
                goto err_destroy_changeset;
        }

        ret = of_changeset_apply(pci_dev->ocs);
        if (ret) {
                dev_err(dev, "Failed to apply changeset: %d\n", ret);
                goto err_destroy_changeset;
        }

        ret = device_add_of_node(&pci_dev->serdev->dev, np);
        if (ret) {
                dev_err(dev, "Failed to add OF node: %d\n", ret);
                goto err_revert_changeset;
        }

        return 0;

err_revert_changeset:
        of_changeset_revert(pci_dev->ocs);
err_destroy_changeset:
        of_changeset_destroy(pci_dev->ocs);
        kfree(pci_dev->ocs);
        pci_dev->ocs = NULL;

        return ret;
}

static int pwrseq_pcie_m2_create_serdev_one(struct pwrseq_pcie_m2_ctx *ctx,
                                        struct pci_dev *pdev)
{
        struct serdev_controller *serdev_ctrl;
        struct device *dev = ctx->dev;
        struct pwrseq_pci_dev *pci_dev;
        int ret;

        struct device_node *serdev_parent __free(device_node) =
                of_graph_get_remote_node(dev_of_node(ctx->dev), 3, 0);
        if (!serdev_parent)
                return 0;

        serdev_ctrl = of_find_serdev_controller_by_node(serdev_parent);
        if (!serdev_ctrl)
                return 0;

        /* Bail out if the device was already attached to this controller */
        if (serdev_ctrl->serdev) {
                serdev_controller_put(serdev_ctrl);
                return 0;
        }

        /* Bail out if the serdev device was already created for the PCI dev */
        scoped_guard(mutex, &ctx->list_lock) {
                list_for_each_entry(pci_dev, &ctx->pci_devices, list) {
                        if (pci_dev->pdev == pdev)
                                return 0;
                }
        }

        pci_dev = kzalloc(sizeof(*pci_dev), GFP_KERNEL);
        if (!pci_dev) {
                ret = -ENOMEM;
                goto err_put_ctrl;
        }

        pci_dev->serdev = serdev_device_alloc(serdev_ctrl);
        if (!pci_dev->serdev) {
                ret = -ENOMEM;
                goto err_free_pci_dev;
        }

        ret = pwrseq_pcie_m2_create_bt_node(ctx, pci_dev, serdev_parent, pdev);
        if (ret)
                goto err_free_serdev;

        ret = serdev_device_add(pci_dev->serdev);
        if (ret) {
                dev_err(dev, "Failed to add serdev for PCI device (%s): %d\n",
                        pci_name(pdev), ret);
                goto err_free_dt_node;
        }

        serdev_controller_put(serdev_ctrl);

        pci_dev->pdev = pci_dev_get(pdev);

        mutex_lock(&ctx->list_lock);
        list_add_tail(&pci_dev->list, &ctx->pci_devices);
        mutex_unlock(&ctx->list_lock);

        return 0;

err_free_dt_node:
        device_remove_of_node(&pci_dev->serdev->dev);
        of_changeset_revert(pci_dev->ocs);
        of_changeset_destroy(pci_dev->ocs);
        kfree(pci_dev->ocs);
        pci_dev->ocs = NULL;
err_free_serdev:
        serdev_device_put(pci_dev->serdev);
        pci_dev->serdev = NULL;
err_free_pci_dev:
        kfree(pci_dev);
err_put_ctrl:
        serdev_controller_put(serdev_ctrl);

        return ret;
}

static void __pwrseq_pcie_m2_remove_serdev(struct pwrseq_pcie_m2_ctx *ctx,
                                           struct pwrseq_pci_dev *pci_dev)
{
        if (pci_dev->serdev) {
                device_remove_of_node(&pci_dev->serdev->dev);
                serdev_device_remove(pci_dev->serdev);
        }

        if (pci_dev->ocs) {
                of_changeset_revert(pci_dev->ocs);
                of_changeset_destroy(pci_dev->ocs);
                kfree(pci_dev->ocs);
        }

        pci_dev_put(pci_dev->pdev);
        list_del(&pci_dev->list);
        kfree(pci_dev);
}

static void pwrseq_pcie_m2_remove_serdev(struct pwrseq_pcie_m2_ctx *ctx,
                                         struct pci_dev *pdev)
{
        struct pwrseq_pci_dev *pci_dev, *tmp;

        mutex_lock(&ctx->list_lock);
        list_for_each_entry_safe(pci_dev, tmp, &ctx->pci_devices, list) {
                if (!pdev || pci_dev->pdev == pdev) {
                        __pwrseq_pcie_m2_remove_serdev(ctx, pci_dev);
                        if (pdev)
                                break;
                }
        }
        mutex_unlock(&ctx->list_lock);
}

static int pwrseq_pcie_m2_notify(struct notifier_block *nb, unsigned long action,
                              void *data)
{
        struct pwrseq_pcie_m2_ctx *ctx = container_of(nb, struct pwrseq_pcie_m2_ctx, nb);
        struct pci_dev *pdev = to_pci_dev(data);
        int ret;

        /*
         * Check whether the PCI device is associated with this M.2 connector or
         * not, by comparing the OF node of the PCI device parent and the Port 0
         * (PCIe) remote node parent OF node.
         */
        struct device_node *pci_parent __free(device_node) =
                        of_graph_get_remote_node(dev_of_node(ctx->dev), 0, 0);
        if (!pci_parent || (pci_parent != pdev->dev.parent->of_node))
                return NOTIFY_DONE;

        switch (action) {
        case BUS_NOTIFY_ADD_DEVICE:
                if (pci_match_id(pwrseq_m2_pci_ids, pdev)) {
                        ret = pwrseq_pcie_m2_create_serdev_one(ctx, pdev);
                        if (ret)
                                return notifier_from_errno(ret);
                }
                break;
        case BUS_NOTIFY_REMOVED_DEVICE:
                if (pci_match_id(pwrseq_m2_pci_ids, pdev))
                        pwrseq_pcie_m2_remove_serdev(ctx, pdev);

                break;
        }

        return NOTIFY_OK;
}

static bool pwrseq_pcie_m2_check_remote_node(struct device *dev, u8 port, u8 endpoint,
                                             const char *node)
{
        struct device_node *remote __free(device_node) =
                        of_graph_get_remote_node(dev_of_node(dev), port, endpoint);

        if (remote && of_node_name_eq(remote, node))
                return true;

        return false;
}

/*
 * If the connector exposes a non-discoverable bus like UART, the respective
 * protocol device needs to be created manually with the help of the notifier
 * of the discoverable bus like PCIe.
 */
static int pwrseq_pcie_m2_register_notifier(struct pwrseq_pcie_m2_ctx *ctx)
{
        int ret;

        /*
         * Register a PCI notifier for Key E connector that has PCIe as Port
         * 0/Endpoint 0 interface and Serial as Port 3/Endpoint 0 interface.
         */
        if (!pwrseq_pcie_m2_check_remote_node(ctx->dev, 3, 0, "serial") ||
            !pwrseq_pcie_m2_check_remote_node(ctx->dev, 0, 0, "pcie"))
                return 0;

        ctx->nb.notifier_call = pwrseq_pcie_m2_notify;
        ret = bus_register_notifier(&pci_bus_type, &ctx->nb);
        if (ret)
                return dev_err_probe(ctx->dev, ret,
                                     "Failed to register notifier for serdev\n");
        return 0;
}

static int pwrseq_pcie_m2_create_serdev(struct pwrseq_pcie_m2_ctx *ctx)
{
        struct pci_dev *pdev = NULL;
        int ret;

        if (!pwrseq_pcie_m2_check_remote_node(ctx->dev, 3, 0, "serial") ||
            !pwrseq_pcie_m2_check_remote_node(ctx->dev, 0, 0, "pcie"))
                return 0;

        struct device_node *pci_parent __free(device_node) =
                                of_graph_get_remote_node(dev_of_node(ctx->dev), 0, 0);
        if (!pci_parent)
                return 0;

        /* Create serdev for existing PCI devices if required */
        for_each_pci_dev(pdev) {
                if (!pdev->dev.parent || pci_parent != pdev->dev.parent->of_node)
                        continue;

                if (!pci_match_id(pwrseq_m2_pci_ids, pdev))
                        continue;

                ret = pwrseq_pcie_m2_create_serdev_one(ctx, pdev);
                if (ret) {
                        dev_err_probe(ctx->dev, ret,
                                      "Failed to create serdev for PCI device (%s)\n",
                                      pci_name(pdev));
                        pci_dev_put(pdev);
                        goto err_remove_serdev;
                }
        }

        return 0;

err_remove_serdev:
        pwrseq_pcie_m2_remove_serdev(ctx, NULL);

        return ret;
}

static int pwrseq_pcie_m2_probe(struct platform_device *pdev)
{
        struct device *dev = &pdev->dev;
        struct pwrseq_pcie_m2_ctx *ctx;
        struct pwrseq_config config = {};
        int ret;

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

        platform_set_drvdata(pdev, ctx);
        ctx->of_node = dev_of_node(dev);
        ctx->pdata = device_get_match_data(dev);
        if (!ctx->pdata)
                return dev_err_probe(dev, -ENODEV,
                                     "Failed to obtain platform data\n");

        /*
         * Currently, of_regulator_bulk_get_all() is the only regulator API that
         * allows to get all supplies in the devicetree node without manually
         * specifying them.
         */
        ret = of_regulator_bulk_get_all(dev, dev_of_node(dev), &ctx->regs);
        if (ret < 0)
                return dev_err_probe(dev, ret,
                                     "Failed to get all regulators\n");

        ctx->num_vregs = ret;

        ctx->w_disable1_gpio = devm_gpiod_get_optional(dev, "w-disable1", GPIOD_OUT_HIGH);
        if (IS_ERR(ctx->w_disable1_gpio)) {
                ret = dev_err_probe(dev, PTR_ERR(ctx->w_disable1_gpio),
                                     "Failed to get the W_DISABLE_1# GPIO\n");
                goto err_free_regulators;
        }

        ctx->w_disable2_gpio = devm_gpiod_get_optional(dev, "w-disable2", GPIOD_OUT_HIGH);
        if (IS_ERR(ctx->w_disable2_gpio)) {
                ret = dev_err_probe(dev, PTR_ERR(ctx->w_disable2_gpio),
                                     "Failed to get the W_DISABLE_2# GPIO\n");
                goto err_free_regulators;
        }

        config.parent = dev;
        config.owner = THIS_MODULE;
        config.drvdata = ctx;
        config.match = pwrseq_pcie_m2_match;
        config.targets = ctx->pdata->targets;

        ctx->pwrseq = devm_pwrseq_device_register(dev, &config);
        if (IS_ERR(ctx->pwrseq)) {
                ret = dev_err_probe(dev, PTR_ERR(ctx->pwrseq),
                                     "Failed to register the power sequencer\n");
                goto err_free_regulators;
        }

        mutex_init(&ctx->list_lock);
        INIT_LIST_HEAD(&ctx->pci_devices);
        ctx->dev = dev;

        /* Create serdev for available PCI devices (if required) */
        ret = pwrseq_pcie_m2_create_serdev(ctx);
        if (ret)
                goto err_destroy_mutex;

        /*
         * Register a notifier for creating protocol devices for
         * non-discoverable busses like UART.
         */
        ret = pwrseq_pcie_m2_register_notifier(ctx);
        if (ret)
                goto err_remove_serdev;

        return 0;

err_remove_serdev:
        pwrseq_pcie_m2_remove_serdev(ctx, NULL);
err_destroy_mutex:
        mutex_destroy(&ctx->list_lock);
err_free_regulators:
        regulator_bulk_free(ctx->num_vregs, ctx->regs);

        return ret;
}

static void pwrseq_pcie_m2_remove(struct platform_device *pdev)
{
        struct pwrseq_pcie_m2_ctx *ctx = platform_get_drvdata(pdev);

        bus_unregister_notifier(&pci_bus_type, &ctx->nb);
        pwrseq_pcie_m2_remove_serdev(ctx, NULL);
        mutex_destroy(&ctx->list_lock);

        regulator_bulk_free(ctx->num_vregs, ctx->regs);
}

static const struct of_device_id pwrseq_pcie_m2_of_match[] = {
        {
                .compatible = "pcie-m2-m-connector",
                .data = &pwrseq_pcie_m2_m_of_data,
        },
        {
                .compatible = "pcie-m2-e-connector",
                .data = &pwrseq_pcie_m2_e_of_data,
        },
        { }
};
MODULE_DEVICE_TABLE(of, pwrseq_pcie_m2_of_match);

static struct platform_driver pwrseq_pcie_m2_driver = {
        .driver = {
                .name = "pwrseq-pcie-m2",
                .of_match_table = pwrseq_pcie_m2_of_match,
        },
        .probe = pwrseq_pcie_m2_probe,
        .remove = pwrseq_pcie_m2_remove,
};
module_platform_driver(pwrseq_pcie_m2_driver);

MODULE_AUTHOR("Manivannan Sadhasivam <manivannan.sadhasivam@oss.qualcomm.com>");
MODULE_DESCRIPTION("Power Sequencing driver for PCIe M.2 connector");
MODULE_LICENSE("GPL");