// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Thermal device driver for DA9062 and DA9061
 * Copyright (C) 2017  Dialog Semiconductor
 */

/* When over-temperature is reached, an interrupt from the device will be
 * triggered. Following this event the interrupt will be disabled and
 * periodic transmission of uevents (HOT trip point) should define the
 * first level of temperature supervision. It is expected that any final
 * implementation of the thermal driver will include a .notify() function
 * to implement these uevents to userspace.
 *
 * These uevents are intended to indicate non-invasive temperature control
 * of the system, where the necessary measures for cooling are the
 * responsibility of the host software. Once the temperature falls again,
 * the IRQ is re-enabled so the start of a new over-temperature event can
 * be detected without constant software monitoring.
 */

#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/thermal.h>
#include <linux/workqueue.h>

#include <linux/mfd/da9062/core.h>
#include <linux/mfd/da9062/registers.h>

/* Minimum, maximum and default polling millisecond periods are provided
 * here as an example. It is expected that any final implementation to also
 * include a modification of these settings to match the required
 * application.
 */
#define DA9062_DEFAULT_POLLING_MS_PERIOD        3000
#define DA9062_MAX_POLLING_MS_PERIOD            10000
#define DA9062_MIN_POLLING_MS_PERIOD            1000

#define DA9062_MILLI_CELSIUS(t)                 ((t) * 1000)

static unsigned int pp_tmp = DA9062_DEFAULT_POLLING_MS_PERIOD;

struct da9062_thermal_config {
        const char *name;
};

struct da9062_thermal {
        struct da9062 *hw;
        struct delayed_work work;
        struct thermal_zone_device *zone;
        struct mutex lock; /* protection for da9062_thermal temperature */
        int temperature;
        int irq;
        const struct da9062_thermal_config *config;
        struct device *dev;
};

static void da9062_thermal_poll_on(struct work_struct *work)
{
        struct da9062_thermal *thermal = container_of(work,
                                                struct da9062_thermal,
                                                work.work);
        unsigned long delay;
        unsigned int val;
        int ret;

        /* clear E_TEMP */
        ret = regmap_write(thermal->hw->regmap,
                           DA9062AA_EVENT_B,
                           DA9062AA_E_TEMP_MASK);
        if (ret < 0) {
                dev_err(thermal->dev,
                        "Cannot clear the TJUNC temperature status\n");
                goto err_enable_irq;
        }

        /* Now read E_TEMP again: it is acting like a status bit.
         * If over-temperature, then this status will be true.
         * If not over-temperature, this status will be false.
         */
        ret = regmap_read(thermal->hw->regmap,
                          DA9062AA_EVENT_B,
                          &val);
        if (ret < 0) {
                dev_err(thermal->dev,
                        "Cannot check the TJUNC temperature status\n");
                goto err_enable_irq;
        }

        if (val & DA9062AA_E_TEMP_MASK) {
                mutex_lock(&thermal->lock);
                thermal->temperature = DA9062_MILLI_CELSIUS(125);
                mutex_unlock(&thermal->lock);
                thermal_zone_device_update(thermal->zone,
                                           THERMAL_EVENT_UNSPECIFIED);

                /*
                 * pp_tmp is between 1s and 10s, so we can round the jiffies
                 */
                delay = round_jiffies(msecs_to_jiffies(pp_tmp));
                queue_delayed_work(system_freezable_wq, &thermal->work, delay);
                return;
        }

        mutex_lock(&thermal->lock);
        thermal->temperature = DA9062_MILLI_CELSIUS(0);
        mutex_unlock(&thermal->lock);
        thermal_zone_device_update(thermal->zone,
                                   THERMAL_EVENT_UNSPECIFIED);

err_enable_irq:
        enable_irq(thermal->irq);
}

static irqreturn_t da9062_thermal_irq_handler(int irq, void *data)
{
        struct da9062_thermal *thermal = data;

        disable_irq_nosync(thermal->irq);
        queue_delayed_work(system_freezable_wq, &thermal->work, 0);

        return IRQ_HANDLED;
}

static int da9062_thermal_get_temp(struct thermal_zone_device *z,
                                   int *temp)
{
        struct da9062_thermal *thermal = thermal_zone_device_priv(z);

        mutex_lock(&thermal->lock);
        *temp = thermal->temperature;
        mutex_unlock(&thermal->lock);

        return 0;
}

static const struct thermal_zone_device_ops da9062_thermal_ops = {
        .get_temp       = da9062_thermal_get_temp,
};

static struct thermal_trip trips[] = {
        { .temperature = DA9062_MILLI_CELSIUS(125), .type = THERMAL_TRIP_HOT },
};

static const struct da9062_thermal_config da9062_config = {
        .name = "da9062-thermal",
};

static const struct of_device_id da9062_compatible_reg_id_table[] = {
        { .compatible = "dlg,da9062-thermal", .data = &da9062_config },
        { },
};

MODULE_DEVICE_TABLE(of, da9062_compatible_reg_id_table);

static int da9062_thermal_probe(struct platform_device *pdev)
{
        struct da9062 *chip = dev_get_drvdata(pdev->dev.parent);
        struct da9062_thermal *thermal;
        const struct of_device_id *match;
        int ret = 0;

        match = of_match_node(da9062_compatible_reg_id_table,
                              pdev->dev.of_node);
        if (!match)
                return -ENXIO;

        if (pdev->dev.of_node) {
                if (!of_property_read_u32(pdev->dev.of_node,
                                          "polling-delay-passive",
                                          &pp_tmp)) {
                        if (pp_tmp < DA9062_MIN_POLLING_MS_PERIOD ||
                            pp_tmp > DA9062_MAX_POLLING_MS_PERIOD) {
                                dev_warn(&pdev->dev,
                                         "Out-of-range polling period %d ms\n",
                                         pp_tmp);
                                pp_tmp = DA9062_DEFAULT_POLLING_MS_PERIOD;
                        }
                }
        }

        thermal = devm_kzalloc(&pdev->dev, sizeof(struct da9062_thermal),
                               GFP_KERNEL);
        if (!thermal) {
                ret = -ENOMEM;
                goto err;
        }

        thermal->config = match->data;
        thermal->hw = chip;
        thermal->dev = &pdev->dev;

        INIT_DELAYED_WORK(&thermal->work, da9062_thermal_poll_on);
        mutex_init(&thermal->lock);

        thermal->zone = thermal_zone_device_register_with_trips(thermal->config->name,
                                                                trips, ARRAY_SIZE(trips), thermal,
                                                                &da9062_thermal_ops, NULL, pp_tmp,
                                                                0);
        if (IS_ERR(thermal->zone)) {
                dev_err(&pdev->dev, "Cannot register thermal zone device\n");
                ret = PTR_ERR(thermal->zone);
                goto err;
        }
        ret = thermal_zone_device_enable(thermal->zone);
        if (ret) {
                dev_err(&pdev->dev, "Cannot enable thermal zone device\n");
                goto err_zone;
        }

        dev_dbg(&pdev->dev,
                "TJUNC temperature polling period set at %d ms\n", pp_tmp);

        ret = platform_get_irq_byname(pdev, "THERMAL");
        if (ret < 0)
                goto err_zone;

        thermal->irq = ret;

        ret = request_threaded_irq(thermal->irq, NULL,
                                   da9062_thermal_irq_handler,
                                   IRQF_TRIGGER_LOW | IRQF_ONESHOT,
                                   "THERMAL", thermal);
        if (ret) {
                dev_err(&pdev->dev,
                        "Failed to request thermal device IRQ.\n");
                goto err_zone;
        }

        platform_set_drvdata(pdev, thermal);
        return 0;

err_zone:
        thermal_zone_device_unregister(thermal->zone);
err:
        return ret;
}

static void da9062_thermal_remove(struct platform_device *pdev)
{
        struct  da9062_thermal *thermal = platform_get_drvdata(pdev);

        free_irq(thermal->irq, thermal);
        cancel_delayed_work_sync(&thermal->work);
        thermal_zone_device_unregister(thermal->zone);
}

static struct platform_driver da9062_thermal_driver = {
        .probe  = da9062_thermal_probe,
        .remove = da9062_thermal_remove,
        .driver = {
                .name           = "da9062-thermal",
                .of_match_table = da9062_compatible_reg_id_table,
        },
};

module_platform_driver(da9062_thermal_driver);

MODULE_AUTHOR("Steve Twiss");
MODULE_DESCRIPTION("Thermal TJUNC device driver for Dialog DA9062 and DA9061");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:da9062-thermal");