// SPDX-License-Identifier: GPL-2.0
// Copyright (C) 2020 Spreadtrum Communications Inc.

#include <linux/clk.h>
#include <linux/io.h>
#include <linux/iopoll.h>
#include <linux/module.h>
#include <linux/nvmem-consumer.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/thermal.h>

#define SPRD_THM_CTL                    0x0
#define SPRD_THM_INT_EN                 0x4
#define SPRD_THM_INT_STS                0x8
#define SPRD_THM_INT_RAW_STS            0xc
#define SPRD_THM_DET_PERIOD             0x10
#define SPRD_THM_INT_CLR                0x14
#define SPRD_THM_INT_CLR_ST             0x18
#define SPRD_THM_MON_PERIOD             0x4c
#define SPRD_THM_MON_CTL                0x50
#define SPRD_THM_INTERNAL_STS1          0x54
#define SPRD_THM_RAW_READ_MSK           0x3ff

#define SPRD_THM_OFFSET(id)             ((id) * 0x4)
#define SPRD_THM_TEMP(id)               (SPRD_THM_OFFSET(id) + 0x5c)
#define SPRD_THM_THRES(id)              (SPRD_THM_OFFSET(id) + 0x2c)

#define SPRD_THM_SEN(id)                BIT((id) + 2)
#define SPRD_THM_SEN_OVERHEAT_EN(id)    BIT((id) + 8)
#define SPRD_THM_SEN_OVERHEAT_ALARM_EN(id)      BIT((id) + 0)

/* bits definitions for register THM_CTL */
#define SPRD_THM_SET_RDY_ST             BIT(13)
#define SPRD_THM_SET_RDY                BIT(12)
#define SPRD_THM_MON_EN                 BIT(1)
#define SPRD_THM_EN                     BIT(0)

/* bits definitions for register THM_INT_CTL */
#define SPRD_THM_BIT_INT_EN             BIT(26)
#define SPRD_THM_OVERHEAT_EN            BIT(25)
#define SPRD_THM_OTP_TRIP_SHIFT         10

/* bits definitions for register SPRD_THM_INTERNAL_STS1 */
#define SPRD_THM_TEMPER_RDY             BIT(0)

#define SPRD_THM_DET_PERIOD_DATA        0x800
#define SPRD_THM_DET_PERIOD_MASK        GENMASK(19, 0)
#define SPRD_THM_MON_MODE               0x7
#define SPRD_THM_MON_MODE_MASK          GENMASK(3, 0)
#define SPRD_THM_MON_PERIOD_DATA        0x10
#define SPRD_THM_MON_PERIOD_MASK        GENMASK(15, 0)
#define SPRD_THM_THRES_MASK             GENMASK(19, 0)
#define SPRD_THM_INT_CLR_MASK           GENMASK(24, 0)

/* thermal sensor calibration parameters */
#define SPRD_THM_TEMP_LOW               -40000
#define SPRD_THM_TEMP_HIGH              120000
#define SPRD_THM_OTP_TEMP               120000
#define SPRD_THM_HOT_TEMP               75000
#define SPRD_THM_RAW_DATA_LOW           0
#define SPRD_THM_RAW_DATA_HIGH          1000
#define SPRD_THM_SEN_NUM                8
#define SPRD_THM_DT_OFFSET              24
#define SPRD_THM_RATION_OFFSET          17
#define SPRD_THM_RATION_SIGN            16

#define SPRD_THM_RDYST_POLLING_TIME     10
#define SPRD_THM_RDYST_TIMEOUT          700
#define SPRD_THM_TEMP_READY_POLL_TIME   10000
#define SPRD_THM_TEMP_READY_TIMEOUT     600000
#define SPRD_THM_MAX_SENSOR             8

struct sprd_thermal_sensor {
        struct thermal_zone_device *tzd;
        struct sprd_thermal_data *data;
        struct device *dev;
        int cal_slope;
        int cal_offset;
        int id;
};

struct sprd_thermal_data {
        const struct sprd_thm_variant_data *var_data;
        struct sprd_thermal_sensor *sensor[SPRD_THM_MAX_SENSOR];
        struct clk *clk;
        void __iomem *base;
        u32 ratio_off;
        int ratio_sign;
        int nr_sensors;
};

/*
 * The conversion between ADC and temperature is based on linear relationship,
 * and use idea_k to specify the slope and ideal_b to specify the offset.
 *
 * Since different Spreadtrum SoCs have different ideal_k and ideal_b,
 * we should save ideal_k and ideal_b in the device data structure.
 */
struct sprd_thm_variant_data {
        u32 ideal_k;
        u32 ideal_b;
};

static const struct sprd_thm_variant_data ums512_data = {
        .ideal_k = 262,
        .ideal_b = 66400,
};

static inline void sprd_thm_update_bits(void __iomem *reg, u32 mask, u32 val)
{
        u32 tmp, orig;

        orig = readl(reg);
        tmp = orig & ~mask;
        tmp |= val & mask;
        writel(tmp, reg);
}

static int sprd_thm_cal_read(struct device_node *np, const char *cell_id,
                             u32 *val)
{
        struct nvmem_cell *cell;
        void *buf;
        size_t len;

        cell = of_nvmem_cell_get(np, cell_id);
        if (IS_ERR(cell))
                return PTR_ERR(cell);

        buf = nvmem_cell_read(cell, &len);
        nvmem_cell_put(cell);
        if (IS_ERR(buf))
                return PTR_ERR(buf);

        if (len > sizeof(u32)) {
                kfree(buf);
                return -EINVAL;
        }

        memcpy(val, buf, len);

        kfree(buf);
        return 0;
}

static int sprd_thm_sensor_calibration(struct device_node *np,
                                       struct sprd_thermal_data *thm,
                                       struct sprd_thermal_sensor *sen)
{
        int ret;
        /*
         * According to thermal datasheet, the default calibration offset is 64,
         * and the default ratio is 1000.
         */
        int dt_offset = 64, ratio = 1000;

        ret = sprd_thm_cal_read(np, "sen_delta_cal", &dt_offset);
        if (ret)
                return ret;

        ratio += thm->ratio_sign * thm->ratio_off;

        /*
         * According to the ideal slope K and ideal offset B, combined with
         * calibration value of thermal from efuse, then calibrate the real
         * slope k and offset b:
         * k_cal = (k * ratio) / 1000.
         * b_cal = b + (dt_offset - 64) * 500.
         */
        sen->cal_slope = (thm->var_data->ideal_k * ratio) / 1000;
        sen->cal_offset = thm->var_data->ideal_b + (dt_offset - 128) * 250;

        return 0;
}

static int sprd_thm_rawdata_to_temp(struct sprd_thermal_sensor *sen,
                                    u32 rawdata)
{
        clamp(rawdata, (u32)SPRD_THM_RAW_DATA_LOW, (u32)SPRD_THM_RAW_DATA_HIGH);

        /*
         * According to the thermal datasheet, the formula of converting
         * adc value to the temperature value should be:
         * T_final = k_cal * x - b_cal.
         */
        return sen->cal_slope * rawdata - sen->cal_offset;
}

static int sprd_thm_temp_to_rawdata(int temp, struct sprd_thermal_sensor *sen)
{
        u32 val;

        clamp(temp, (int)SPRD_THM_TEMP_LOW, (int)SPRD_THM_TEMP_HIGH);

        /*
         * According to the thermal datasheet, the formula of converting
         * adc value to the temperature value should be:
         * T_final = k_cal * x - b_cal.
         */
        val = (temp + sen->cal_offset) / sen->cal_slope;

        return clamp(val, val, (u32)(SPRD_THM_RAW_DATA_HIGH - 1));
}

static int sprd_thm_read_temp(struct thermal_zone_device *tz, int *temp)
{
        struct sprd_thermal_sensor *sen = thermal_zone_device_priv(tz);
        u32 data;

        data = readl(sen->data->base + SPRD_THM_TEMP(sen->id)) &
                SPRD_THM_RAW_READ_MSK;

        *temp = sprd_thm_rawdata_to_temp(sen, data);

        return 0;
}

static const struct thermal_zone_device_ops sprd_thm_ops = {
        .get_temp = sprd_thm_read_temp,
};

static int sprd_thm_poll_ready_status(struct sprd_thermal_data *thm)
{
        u32 val;
        int ret;

        /*
         * Wait for thermal ready status before configuring thermal parameters.
         */
        ret = readl_poll_timeout(thm->base + SPRD_THM_CTL, val,
                                 !(val & SPRD_THM_SET_RDY_ST),
                                 SPRD_THM_RDYST_POLLING_TIME,
                                 SPRD_THM_RDYST_TIMEOUT);
        if (ret)
                return ret;

        sprd_thm_update_bits(thm->base + SPRD_THM_CTL, SPRD_THM_MON_EN,
                             SPRD_THM_MON_EN);
        sprd_thm_update_bits(thm->base + SPRD_THM_CTL, SPRD_THM_SET_RDY,
                             SPRD_THM_SET_RDY);
        return 0;
}

static int sprd_thm_wait_temp_ready(struct sprd_thermal_data *thm)
{
        u32 val;

        /* Wait for first temperature data ready before reading temperature */
        return readl_poll_timeout(thm->base + SPRD_THM_INTERNAL_STS1, val,
                                  !(val & SPRD_THM_TEMPER_RDY),
                                  SPRD_THM_TEMP_READY_POLL_TIME,
                                  SPRD_THM_TEMP_READY_TIMEOUT);
}

static int sprd_thm_set_ready(struct sprd_thermal_data *thm)
{
        int ret;

        ret = sprd_thm_poll_ready_status(thm);
        if (ret)
                return ret;

        /*
         * Clear interrupt status, enable thermal interrupt and enable thermal.
         *
         * The SPRD thermal controller integrates a hardware interrupt signal,
         * which means if the temperature is overheat, it will generate an
         * interrupt and notify the event to PMIC automatically to shutdown the
         * system. So here we should enable the interrupt bits, though we have
         * not registered an irq handler.
         */
        writel(SPRD_THM_INT_CLR_MASK, thm->base + SPRD_THM_INT_CLR);
        sprd_thm_update_bits(thm->base + SPRD_THM_INT_EN,
                             SPRD_THM_BIT_INT_EN, SPRD_THM_BIT_INT_EN);
        sprd_thm_update_bits(thm->base + SPRD_THM_CTL,
                             SPRD_THM_EN, SPRD_THM_EN);
        return 0;
}

static void sprd_thm_sensor_init(struct sprd_thermal_data *thm,
                                 struct sprd_thermal_sensor *sen)
{
        u32 otp_rawdata, hot_rawdata;

        otp_rawdata = sprd_thm_temp_to_rawdata(SPRD_THM_OTP_TEMP, sen);
        hot_rawdata = sprd_thm_temp_to_rawdata(SPRD_THM_HOT_TEMP, sen);

        /* Enable the sensor' overheat temperature protection interrupt */
        sprd_thm_update_bits(thm->base + SPRD_THM_INT_EN,
                             SPRD_THM_SEN_OVERHEAT_ALARM_EN(sen->id),
                             SPRD_THM_SEN_OVERHEAT_ALARM_EN(sen->id));

        /* Set the sensor' overheat and hot threshold temperature */
        sprd_thm_update_bits(thm->base + SPRD_THM_THRES(sen->id),
                             SPRD_THM_THRES_MASK,
                             (otp_rawdata << SPRD_THM_OTP_TRIP_SHIFT) |
                             hot_rawdata);

        /* Enable the corresponding sensor */
        sprd_thm_update_bits(thm->base + SPRD_THM_CTL, SPRD_THM_SEN(sen->id),
                             SPRD_THM_SEN(sen->id));
}

static void sprd_thm_para_config(struct sprd_thermal_data *thm)
{
        /* Set the period of two valid temperature detection action */
        sprd_thm_update_bits(thm->base + SPRD_THM_DET_PERIOD,
                             SPRD_THM_DET_PERIOD_MASK, SPRD_THM_DET_PERIOD);

        /* Set the sensors' monitor mode */
        sprd_thm_update_bits(thm->base + SPRD_THM_MON_CTL,
                             SPRD_THM_MON_MODE_MASK, SPRD_THM_MON_MODE);

        /* Set the sensors' monitor period */
        sprd_thm_update_bits(thm->base + SPRD_THM_MON_PERIOD,
                             SPRD_THM_MON_PERIOD_MASK, SPRD_THM_MON_PERIOD);
}

static void sprd_thm_toggle_sensor(struct sprd_thermal_sensor *sen, bool on)
{
        struct thermal_zone_device *tzd = sen->tzd;

        if (on)
                thermal_zone_device_enable(tzd);
        else
                thermal_zone_device_disable(tzd);
}

static int sprd_thm_probe(struct platform_device *pdev)
{
        struct device_node *np = pdev->dev.of_node;
        struct device_node *sen_child;
        struct sprd_thermal_data *thm;
        struct sprd_thermal_sensor *sen;
        const struct sprd_thm_variant_data *pdata;
        int ret, i;
        u32 val;

        pdata = of_device_get_match_data(&pdev->dev);
        if (!pdata) {
                dev_err(&pdev->dev, "No matching driver data found\n");
                return -EINVAL;
        }

        thm = devm_kzalloc(&pdev->dev, sizeof(*thm), GFP_KERNEL);
        if (!thm)
                return -ENOMEM;

        thm->var_data = pdata;
        thm->base = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(thm->base))
                return PTR_ERR(thm->base);

        thm->nr_sensors = of_get_child_count(np);
        if (thm->nr_sensors == 0 || thm->nr_sensors > SPRD_THM_MAX_SENSOR) {
                dev_err(&pdev->dev, "incorrect sensor count\n");
                return -EINVAL;
        }

        thm->clk = devm_clk_get_enabled(&pdev->dev, "enable");
        if (IS_ERR(thm->clk)) {
                dev_err(&pdev->dev, "failed to get enable clock\n");
                return PTR_ERR(thm->clk);
        }

        sprd_thm_para_config(thm);

        ret = sprd_thm_cal_read(np, "thm_sign_cal", &val);
        if (ret)
                return ret;

        if (val > 0)
                thm->ratio_sign = -1;
        else
                thm->ratio_sign = 1;

        ret = sprd_thm_cal_read(np, "thm_ratio_cal", &thm->ratio_off);
        if (ret)
                return ret;

        for_each_child_of_node(np, sen_child) {
                sen = devm_kzalloc(&pdev->dev, sizeof(*sen), GFP_KERNEL);
                if (!sen) {
                        ret = -ENOMEM;
                        goto of_put;
                }

                sen->data = thm;
                sen->dev = &pdev->dev;

                ret = of_property_read_u32(sen_child, "reg", &sen->id);
                if (ret) {
                        dev_err(&pdev->dev, "get sensor reg failed");
                        goto of_put;
                }

                ret = sprd_thm_sensor_calibration(sen_child, thm, sen);
                if (ret) {
                        dev_err(&pdev->dev, "efuse cal analysis failed");
                        goto of_put;
                }

                sprd_thm_sensor_init(thm, sen);

                sen->tzd = devm_thermal_of_zone_register(sen->dev,
                                                         sen->id,
                                                         sen,
                                                         &sprd_thm_ops);
                if (IS_ERR(sen->tzd)) {
                        dev_err(&pdev->dev, "register thermal zone failed %d\n",
                                sen->id);
                        ret = PTR_ERR(sen->tzd);
                        goto of_put;
                }

                thm->sensor[sen->id] = sen;
        }
        /* sen_child set to NULL at this point */

        ret = sprd_thm_set_ready(thm);
        if (ret)
                goto of_put;

        ret = sprd_thm_wait_temp_ready(thm);
        if (ret)
                goto of_put;

        for (i = 0; i < thm->nr_sensors; i++)
                sprd_thm_toggle_sensor(thm->sensor[i], true);

        platform_set_drvdata(pdev, thm);
        return 0;

of_put:
        of_node_put(sen_child);
        return ret;
}

#ifdef CONFIG_PM_SLEEP
static void sprd_thm_hw_suspend(struct sprd_thermal_data *thm)
{
        int i;

        for (i = 0; i < thm->nr_sensors; i++) {
                sprd_thm_update_bits(thm->base + SPRD_THM_CTL,
                                     SPRD_THM_SEN(thm->sensor[i]->id), 0);
        }

        sprd_thm_update_bits(thm->base + SPRD_THM_CTL,
                             SPRD_THM_EN, 0x0);
}

static int sprd_thm_suspend(struct device *dev)
{
        struct sprd_thermal_data *thm = dev_get_drvdata(dev);
        int i;

        for (i = 0; i < thm->nr_sensors; i++)
                sprd_thm_toggle_sensor(thm->sensor[i], false);

        sprd_thm_hw_suspend(thm);
        clk_disable_unprepare(thm->clk);

        return 0;
}

static int sprd_thm_hw_resume(struct sprd_thermal_data *thm)
{
        int ret, i;

        for (i = 0; i < thm->nr_sensors; i++) {
                sprd_thm_update_bits(thm->base + SPRD_THM_CTL,
                                     SPRD_THM_SEN(thm->sensor[i]->id),
                                     SPRD_THM_SEN(thm->sensor[i]->id));
        }

        ret = sprd_thm_poll_ready_status(thm);
        if (ret)
                return ret;

        writel(SPRD_THM_INT_CLR_MASK, thm->base + SPRD_THM_INT_CLR);
        sprd_thm_update_bits(thm->base + SPRD_THM_CTL,
                             SPRD_THM_EN, SPRD_THM_EN);
        return sprd_thm_wait_temp_ready(thm);
}

static int sprd_thm_resume(struct device *dev)
{
        struct sprd_thermal_data *thm = dev_get_drvdata(dev);
        int ret, i;

        ret = clk_prepare_enable(thm->clk);
        if (ret)
                return ret;

        ret = sprd_thm_hw_resume(thm);
        if (ret)
                goto disable_clk;

        for (i = 0; i < thm->nr_sensors; i++)
                sprd_thm_toggle_sensor(thm->sensor[i], true);

        return 0;

disable_clk:
        clk_disable_unprepare(thm->clk);
        return ret;
}
#endif

static void sprd_thm_remove(struct platform_device *pdev)
{
        struct sprd_thermal_data *thm = platform_get_drvdata(pdev);
        int i;

        for (i = 0; i < thm->nr_sensors; i++) {
                sprd_thm_toggle_sensor(thm->sensor[i], false);
                devm_thermal_of_zone_unregister(&pdev->dev,
                                                thm->sensor[i]->tzd);
        }
}

static const struct of_device_id sprd_thermal_of_match[] = {
        { .compatible = "sprd,ums512-thermal", .data = &ums512_data },
        { },
};
MODULE_DEVICE_TABLE(of, sprd_thermal_of_match);

static const struct dev_pm_ops sprd_thermal_pm_ops = {
        SET_SYSTEM_SLEEP_PM_OPS(sprd_thm_suspend, sprd_thm_resume)
};

static struct platform_driver sprd_thermal_driver = {
        .probe = sprd_thm_probe,
        .remove = sprd_thm_remove,
        .driver = {
                .name = "sprd-thermal",
                .pm = &sprd_thermal_pm_ops,
                .of_match_table = sprd_thermal_of_match,
        },
};

module_platform_driver(sprd_thermal_driver);

MODULE_AUTHOR("Freeman Liu <freeman.liu@unisoc.com>");
MODULE_DESCRIPTION("Spreadtrum thermal driver");
MODULE_LICENSE("GPL v2");