[linux-2.6-block.git] / drivers / thermal / k3_j72xx_bandgap.c

// SPDX-License-Identifier: GPL-2.0
/*
 * TI Bandgap temperature sensor driver for J72XX SoC Family
 *
 * Copyright (C) 2021 Texas Instruments Incorporated - http://www.ti.com/
 */

#include <linux/math.h>
#include <linux/math64.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/pm_runtime.h>
#include <linux/err.h>
#include <linux/types.h>
#include <linux/of_platform.h>
#include <linux/io.h>
#include <linux/thermal.h>
#include <linux/of.h>
#include <linux/delay.h>
#include <linux/slab.h>

#define K3_VTM_DEVINFO_PWR0_OFFSET		0x4
#define K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK	0xf0
#define K3_VTM_TMPSENS0_CTRL_OFFSET		0x300
#define K3_VTM_MISC_CTRL_OFFSET			0xc
#define K3_VTM_TMPSENS_STAT_OFFSET		0x8
#define K3_VTM_ANYMAXT_OUTRG_ALERT_EN		0x1
#define K3_VTM_MISC_CTRL2_OFFSET		0x10
#define K3_VTM_TS_STAT_DTEMP_MASK		0x3ff
#define K3_VTM_MAX_NUM_TS			8
#define K3_VTM_TMPSENS_CTRL_SOC			BIT(5)
#define K3_VTM_TMPSENS_CTRL_CLRZ		BIT(6)
#define K3_VTM_TMPSENS_CTRL_CLKON_REQ		BIT(7)
#define K3_VTM_TMPSENS_CTRL_MAXT_OUTRG_EN	BIT(11)

#define K3_VTM_CORRECTION_TEMP_CNT		3

#define MINUS40CREF				5
#define PLUS30CREF				253
#define PLUS125CREF				730
#define PLUS150CREF				940

#define TABLE_SIZE				1024
#define MAX_TEMP				123000
#define COOL_DOWN_TEMP				105000

#define FACTORS_REDUCTION			13
static int *derived_table;

static int compute_value(int index, const s64 *factors, int nr_factors,
			 int reduction)
{
	s64 value = 0;
	int i;

	for (i = 0; i < nr_factors; i++)
		value += factors[i] * int_pow(index, i);

	return (int)div64_s64(value, int_pow(10, reduction));
}

static void init_table(int factors_size, int *table, const s64 *factors)
{
	int i;

	for (i = 0; i < TABLE_SIZE; i++)
		table[i] = compute_value(i, factors, factors_size,
					 FACTORS_REDUCTION);
}

/**
 * struct err_values - structure containing error/reference values
 * @refs: reference error values for -40C, 30C, 125C & 150C
 * @errs: Actual error values for -40C, 30C, 125C & 150C read from the efuse
 */
struct err_values {
	int refs[4];
	int errs[4];
};

static void create_table_segments(struct err_values *err_vals, int seg,
				  int *ref_table)
{
	int m = 0, c, num, den, i, err, idx1, idx2, err1, err2, ref1, ref2;

	if (seg == 0)
		idx1 = 0;
	else
		idx1 = err_vals->refs[seg];

	idx2 = err_vals->refs[seg + 1];
	err1 = err_vals->errs[seg];
	err2 = err_vals->errs[seg + 1];
	ref1 = err_vals->refs[seg];
	ref2 = err_vals->refs[seg + 1];

	/*
	 * Calculate the slope with adc values read from the register
	 * as the y-axis param and err in adc value as x-axis param
	 */
	num = ref2 - ref1;
	den = err2 - err1;
	if (den)
		m = num / den;
	c = ref2 - m * err2;

	/*
	 * Take care of divide by zero error if error values are same
	 * Or when the slope is 0
	 */
	if (den != 0 && m != 0) {
		for (i = idx1; i <= idx2; i++) {
			err = (i - c) / m;
			if (((i + err) < 0) || ((i + err) >= TABLE_SIZE))
				continue;
			derived_table[i] = ref_table[i + err];
		}
	} else { /* Constant error take care of divide by zero */
		for (i = idx1; i <= idx2; i++) {
			if (((i + err1) < 0) || ((i + err1) >= TABLE_SIZE))
				continue;
			derived_table[i] = ref_table[i + err1];
		}
	}
}

static int prep_lookup_table(struct err_values *err_vals, int *ref_table)
{
	int inc, i, seg;

	/*
	 * Fill up the lookup table under 3 segments
	 * region -40C to +30C
	 * region +30C to +125C
	 * region +125C to +150C
	 */
	for (seg = 0; seg < 3; seg++)
		create_table_segments(err_vals, seg, ref_table);

	/* Get to the first valid temperature */
	i = 0;
	while (!derived_table[i])
		i++;

	/*
	 * Get to the last zero index and back fill the temperature for
	 * sake of continuity
	 */
	if (i) {
		/* 300 milli celsius steps */
		while (i--)
			derived_table[i] = derived_table[i + 1] - 300;
	}

	/*
	 * Fill the last trailing 0s which are unfilled with increments of
	 * 100 milli celsius till 1023 code
	 */
	i = TABLE_SIZE - 1;
	while (!derived_table[i])
		i--;

	i++;
	inc = 1;
	while (i < TABLE_SIZE) {
		derived_table[i] = derived_table[i - 1] + inc * 100;
		i++;
	}

	return 0;
}

struct k3_thermal_data;

struct k3_j72xx_bandgap {
	struct device *dev;
	void __iomem *base;
	void __iomem *cfg2_base;
	void __iomem *fuse_base;
	struct k3_thermal_data *ts_data[K3_VTM_MAX_NUM_TS];
};

/* common data structures */
struct k3_thermal_data {
	struct k3_j72xx_bandgap *bgp;
	u32 ctrl_offset;
	u32 stat_offset;
};

static int two_cmp(int tmp, int mask)
{
	tmp = ~(tmp);
	tmp &= mask;
	tmp += 1;

	/* Return negative value */
	return (0 - tmp);
}

static unsigned int vtm_get_best_value(unsigned int s0, unsigned int s1,
				       unsigned int s2)
{
	int d01 = abs(s0 - s1);
	int d02 = abs(s0 - s2);
	int d12 = abs(s1 - s2);

	if (d01 <= d02 && d01 <= d12)
		return (s0 + s1) / 2;

	if (d02 <= d01 && d02 <= d12)
		return (s0 + s2) / 2;

	return (s1 + s2) / 2;
}

static inline int k3_bgp_read_temp(struct k3_thermal_data *devdata,
				   int *temp)
{
	struct k3_j72xx_bandgap *bgp;
	unsigned int dtemp, s0, s1, s2;

	bgp = devdata->bgp;
	/*
	 * Errata is applicable for am654 pg 1.0 silicon/J7ES. There
	 * is a variation of the order for certain degree centigrade on AM654.
	 * Work around that by getting the average of two closest
	 * readings out of three readings everytime we want to
	 * report temperatures.
	 *
	 * Errata workaround.
	 */
	s0 = readl(bgp->base + devdata->stat_offset) &
		K3_VTM_TS_STAT_DTEMP_MASK;
	s1 = readl(bgp->base + devdata->stat_offset) &
		K3_VTM_TS_STAT_DTEMP_MASK;
	s2 = readl(bgp->base + devdata->stat_offset) &
		K3_VTM_TS_STAT_DTEMP_MASK;
	dtemp = vtm_get_best_value(s0, s1, s2);

	if (dtemp < 0 || dtemp >= TABLE_SIZE)
		return -EINVAL;

	*temp = derived_table[dtemp];

	return 0;
}

/* Get temperature callback function for thermal zone */
static int k3_thermal_get_temp(void *devdata, int *temp)
{
	struct k3_thermal_data *data = devdata;
	int ret = 0;

	ret = k3_bgp_read_temp(data, temp);
	if (ret)
		return ret;

	return ret;
}

static const struct thermal_zone_of_device_ops k3_of_thermal_ops = {
	.get_temp = k3_thermal_get_temp,
};

static int k3_j72xx_bandgap_temp_to_adc_code(int temp)
{
	int low = 0, high = TABLE_SIZE - 1, mid;

	if (temp > 160000 || temp < -50000)
		return -EINVAL;

	/* Binary search to find the adc code */
	while (low < (high - 1)) {
		mid = (low + high) / 2;
		if (temp <= derived_table[mid])
			high = mid;
		else
			low = mid;
	}

	return mid;
}

static void get_efuse_values(int id, struct k3_thermal_data *data, int *err,
			     struct k3_j72xx_bandgap *bgp)
{
	int i, tmp, pow;
	int ct_offsets[5][K3_VTM_CORRECTION_TEMP_CNT] = {
		{ 0x0, 0x8, 0x4 },
		{ 0x0, 0x8, 0x4 },
		{ 0x0, -1,  0x4 },
		{ 0x0, 0xC, -1 },
		{ 0x0, 0xc, 0x8 }
	};
	int ct_bm[5][K3_VTM_CORRECTION_TEMP_CNT] = {
		{ 0x3f, 0x1fe000, 0x1ff },
		{ 0xfc0, 0x1fe000, 0x3fe00 },
		{ 0x3f000, 0x7f800000, 0x7fc0000 },
		{ 0xfc0000, 0x1fe0, 0x1f800000 },
		{ 0x3f000000, 0x1fe000, 0x1ff0 }
	};

	for (i = 0; i < 3; i++) {
		/* Extract the offset value using bit-mask */
		if (ct_offsets[id][i] == -1 && i == 1) {
			/* 25C offset Case of Sensor 2 split between 2 regs */
			tmp = (readl(bgp->fuse_base + 0x8) & 0xE0000000) >> (29);
			tmp |= ((readl(bgp->fuse_base + 0xC) & 0x1F) << 3);
			pow = tmp & 0x80;
		} else if (ct_offsets[id][i] == -1 && i == 2) {
			/* 125C Case of Sensor 3 split between 2 regs */
			tmp = (readl(bgp->fuse_base + 0x4) & 0xF8000000) >> (27);
			tmp |= ((readl(bgp->fuse_base + 0x8) & 0xF) << 5);
			pow = tmp & 0x100;
		} else {
			tmp = readl(bgp->fuse_base + ct_offsets[id][i]);
			tmp &= ct_bm[id][i];
			tmp = tmp >> __ffs(ct_bm[id][i]);

			/* Obtain the sign bit pow*/
			pow = ct_bm[id][i] >> __ffs(ct_bm[id][i]);
			pow += 1;
			pow /= 2;
		}

		/* Check for negative value */
		if (tmp & pow) {
			/* 2's complement value */
			tmp = two_cmp(tmp, ct_bm[id][i] >> __ffs(ct_bm[id][i]));
		}
		err[i] = tmp;
	}

	/* Err value for 150C is set to 0 */
	err[i] = 0;
}

static void print_look_up_table(struct device *dev, int *ref_table)
{
	int i;

	dev_dbg(dev, "The contents of derived array\n");
	dev_dbg(dev, "Code   Temperature\n");
	for (i = 0; i < TABLE_SIZE; i++)
		dev_dbg(dev, "%d       %d %d\n", i, derived_table[i], ref_table[i]);
}

struct k3_j72xx_bandgap_data {
	unsigned int has_errata_i2128;
};

static int k3_j72xx_bandgap_probe(struct platform_device *pdev)
{
	int ret = 0, cnt, val, id;
	int high_max, low_temp;
	struct resource *res;
	struct device *dev = &pdev->dev;
	struct k3_j72xx_bandgap *bgp;
	struct k3_thermal_data *data;
	int workaround_needed = 0;
	const struct k3_j72xx_bandgap_data *driver_data;
	struct thermal_zone_device *ti_thermal;
	int *ref_table;
	struct err_values err_vals;

	const s64 golden_factors[] = {
		-490019999999999936,
		3251200000000000,
		-1705800000000,
		603730000,
		-92627,
	};

	const s64 pvt_wa_factors[] = {
		-415230000000000000,
		3126600000000000,
		-1157800000000,
	};

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

	bgp->dev = dev;
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	bgp->base = devm_ioremap_resource(dev, res);
	if (IS_ERR(bgp->base))
		return PTR_ERR(bgp->base);

	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	bgp->cfg2_base = devm_ioremap_resource(dev, res);
	if (IS_ERR(bgp->cfg2_base))
		return PTR_ERR(bgp->cfg2_base);

	res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
	bgp->fuse_base = devm_ioremap_resource(dev, res);
	if (IS_ERR(bgp->fuse_base))
		return PTR_ERR(bgp->fuse_base);

	driver_data = of_device_get_match_data(dev);
	if (driver_data)
		workaround_needed = driver_data->has_errata_i2128;

	pm_runtime_enable(dev);
	ret = pm_runtime_get_sync(dev);
	if (ret < 0) {
		pm_runtime_put_noidle(dev);
		pm_runtime_disable(dev);
		return ret;
	}

	/* Get the sensor count in the VTM */
	val = readl(bgp->base + K3_VTM_DEVINFO_PWR0_OFFSET);
	cnt = val & K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK;
	cnt >>= __ffs(K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK);

	data = devm_kcalloc(bgp->dev, cnt, sizeof(*data), GFP_KERNEL);
	if (!data) {
		ret = -ENOMEM;
		goto err_alloc;
	}

	ref_table = kzalloc(sizeof(*ref_table) * TABLE_SIZE, GFP_KERNEL);
	if (!ref_table) {
		ret = -ENOMEM;
		goto err_alloc;
	}

	derived_table = devm_kzalloc(bgp->dev, sizeof(*derived_table) * TABLE_SIZE,
				     GFP_KERNEL);
	if (!derived_table) {
		ret = -ENOMEM;
		goto err_free_ref_table;
	}

	/* Workaround not needed if bit30/bit31 is set even for J721e */
	if (workaround_needed && (readl(bgp->fuse_base + 0x0) & 0xc0000000) == 0xc0000000)
		workaround_needed = false;

	dev_dbg(bgp->dev, "Work around %sneeded\n",
		workaround_needed ? "not " : "");

	if (!workaround_needed)
		init_table(5, ref_table, golden_factors);
	else
		init_table(3, ref_table, pvt_wa_factors);

	/* Register the thermal sensors */
	for (id = 0; id < cnt; id++) {
		data[id].bgp = bgp;
		data[id].ctrl_offset = K3_VTM_TMPSENS0_CTRL_OFFSET + id * 0x20;
		data[id].stat_offset = data[id].ctrl_offset +
					K3_VTM_TMPSENS_STAT_OFFSET;

		if (workaround_needed) {
			/* ref adc values for -40C, 30C & 125C respectively */
			err_vals.refs[0] = MINUS40CREF;
			err_vals.refs[1] = PLUS30CREF;
			err_vals.refs[2] = PLUS125CREF;
			err_vals.refs[3] = PLUS150CREF;
			get_efuse_values(id, &data[id], err_vals.errs, bgp);
		}

		if (id == 0 && workaround_needed)
			prep_lookup_table(&err_vals, ref_table);
		else if (id == 0 && !workaround_needed)
			memcpy(derived_table, ref_table, TABLE_SIZE * 4);

		val = readl(data[id].bgp->cfg2_base + data[id].ctrl_offset);
		val |= (K3_VTM_TMPSENS_CTRL_MAXT_OUTRG_EN |
			K3_VTM_TMPSENS_CTRL_SOC |
			K3_VTM_TMPSENS_CTRL_CLRZ | BIT(4));
		writel(val, data[id].bgp->cfg2_base + data[id].ctrl_offset);

		bgp->ts_data[id] = &data[id];
		ti_thermal =
		devm_thermal_zone_of_sensor_register(bgp->dev, id,
						     &data[id],
						     &k3_of_thermal_ops);
		if (IS_ERR(ti_thermal)) {
			dev_err(bgp->dev, "thermal zone device is NULL\n");
			ret = PTR_ERR(ti_thermal);
			goto err_free_ref_table;
		}
	}

	/*
	 * Program TSHUT thresholds
	 * Step 1: set the thresholds to ~123C and 105C WKUP_VTM_MISC_CTRL2
	 * Step 2: WKUP_VTM_TMPSENS_CTRL_j set the MAXT_OUTRG_EN  bit
	 *         This is already taken care as per of init
	 * Step 3: WKUP_VTM_MISC_CTRL set the ANYMAXT_OUTRG_ALERT_EN  bit
	 */
	high_max = k3_j72xx_bandgap_temp_to_adc_code(MAX_TEMP);
	low_temp = k3_j72xx_bandgap_temp_to_adc_code(COOL_DOWN_TEMP);

	writel((low_temp << 16) | high_max, data[0].bgp->cfg2_base +
	       K3_VTM_MISC_CTRL2_OFFSET);
	mdelay(100);
	writel(K3_VTM_ANYMAXT_OUTRG_ALERT_EN, data[0].bgp->cfg2_base +
	       K3_VTM_MISC_CTRL_OFFSET);

	platform_set_drvdata(pdev, bgp);

	print_look_up_table(dev, ref_table);
	/*
	 * Now that the derived_table has the appropriate look up values
	 * Free up the ref_table
	 */
	kfree(ref_table);

	return 0;

err_free_ref_table:
	kfree(ref_table);

err_alloc:
	pm_runtime_put_sync(&pdev->dev);
	pm_runtime_disable(&pdev->dev);

	return ret;
}

static int k3_j72xx_bandgap_remove(struct platform_device *pdev)
{
	pm_runtime_put_sync(&pdev->dev);
	pm_runtime_disable(&pdev->dev);

	return 0;
}

static const struct k3_j72xx_bandgap_data k3_j72xx_bandgap_j721e_data = {
	.has_errata_i2128 = 1,
};

static const struct k3_j72xx_bandgap_data k3_j72xx_bandgap_j7200_data = {
	.has_errata_i2128 = 0,
};

static const struct of_device_id of_k3_j72xx_bandgap_match[] = {
	{
		.compatible = "ti,j721e-vtm",
		.data = &k3_j72xx_bandgap_j721e_data,
	},
	{
		.compatible = "ti,j7200-vtm",
		.data = &k3_j72xx_bandgap_j7200_data,
	},
	{ /* sentinel */ },
};
MODULE_DEVICE_TABLE(of, of_k3_j72xx_bandgap_match);

static struct platform_driver k3_j72xx_bandgap_sensor_driver = {
	.probe = k3_j72xx_bandgap_probe,
	.remove = k3_j72xx_bandgap_remove,
	.driver = {
		.name = "k3-j72xx-soc-thermal",
		.of_match_table	= of_k3_j72xx_bandgap_match,
	},
};

module_platform_driver(k3_j72xx_bandgap_sensor_driver);

MODULE_DESCRIPTION("K3 bandgap temperature sensor driver");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("J Keerthy <j-keerthy@ti.com>");
Commit	Line	Data
ffcb2fc8 K	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* TI Bandgap temperature sensor driver for J72XX SoC Family
	4	*
	5	* Copyright (C) 2021 Texas Instruments Incorporated - http://www.ti.com/
	6	*/
	7
	8	#include <linux/math.h>
	9	#include <linux/math64.h>
	10	#include <linux/module.h>
	11	#include <linux/init.h>
	12	#include <linux/kernel.h>
	13	#include <linux/pm_runtime.h>
	14	#include <linux/err.h>
	15	#include <linux/types.h>
	16	#include <linux/of_platform.h>
	17	#include <linux/io.h>
	18	#include <linux/thermal.h>
	19	#include <linux/of.h>
	20	#include <linux/delay.h>
	21	#include <linux/slab.h>
	22
	23	#define K3_VTM_DEVINFO_PWR0_OFFSET 0x4
	24	#define K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK 0xf0
	25	#define K3_VTM_TMPSENS0_CTRL_OFFSET 0x300
	26	#define K3_VTM_MISC_CTRL_OFFSET 0xc
	27	#define K3_VTM_TMPSENS_STAT_OFFSET 0x8
	28	#define K3_VTM_ANYMAXT_OUTRG_ALERT_EN 0x1
	29	#define K3_VTM_MISC_CTRL2_OFFSET 0x10
	30	#define K3_VTM_TS_STAT_DTEMP_MASK 0x3ff
	31	#define K3_VTM_MAX_NUM_TS 8
	32	#define K3_VTM_TMPSENS_CTRL_SOC BIT(5)
	33	#define K3_VTM_TMPSENS_CTRL_CLRZ BIT(6)
	34	#define K3_VTM_TMPSENS_CTRL_CLKON_REQ BIT(7)
	35	#define K3_VTM_TMPSENS_CTRL_MAXT_OUTRG_EN BIT(11)
	36
	37	#define K3_VTM_CORRECTION_TEMP_CNT 3
	38
	39	#define MINUS40CREF 5
	40	#define PLUS30CREF 253
	41	#define PLUS125CREF 730
	42	#define PLUS150CREF 940
	43
	44	#define TABLE_SIZE 1024
	45	#define MAX_TEMP 123000
	46	#define COOL_DOWN_TEMP 105000
	47
	48	#define FACTORS_REDUCTION 13
	49	static int *derived_table;
	50
	51	static int compute_value(int index, const s64 *factors, int nr_factors,
	52	int reduction)
	53	{
	54	s64 value = 0;
	55	int i;
	56
	57	for (i = 0; i < nr_factors; i++)
	58	value += factors[i] * int_pow(index, i);
	59
	60	return (int)div64_s64(value, int_pow(10, reduction));
	61	}
	62
	63	static void init_table(int factors_size, int table, const s64 factors)
	64	{
65	int i;
66
67	for (i = 0; i < TABLE_SIZE; i++)
68	table[i] = compute_value(i, factors, factors_size,
69	FACTORS_REDUCTION);
70	}
71
72	/**
73	* struct err_values - structure containing error/reference values
74	* @refs: reference error values for -40C, 30C, 125C & 150C
75	* @errs: Actual error values for -40C, 30C, 125C & 150C read from the efuse
76	*/
77	struct err_values {
78	int refs[4];
79	int errs[4];
80	};
81
82	static void create_table_segments(struct err_values *err_vals, int seg,
83	int *ref_table)
84	{
85	int m = 0, c, num, den, i, err, idx1, idx2, err1, err2, ref1, ref2;
86
87	if (seg == 0)
88	idx1 = 0;
89	else
90	idx1 = err_vals->refs[seg];
91
92	idx2 = err_vals->refs[seg + 1];
93	err1 = err_vals->errs[seg];
94	err2 = err_vals->errs[seg + 1];
95	ref1 = err_vals->refs[seg];
96	ref2 = err_vals->refs[seg + 1];
97
98	/*
99	* Calculate the slope with adc values read from the register
100	* as the y-axis param and err in adc value as x-axis param
101	*/
102	num = ref2 - ref1;
103	den = err2 - err1;
104	if (den)
105	m = num / den;
106	c = ref2 - m * err2;
107
108	/*
109	* Take care of divide by zero error if error values are same
110	* Or when the slope is 0
111	*/
112	if (den != 0 && m != 0) {
113	for (i = idx1; i <= idx2; i++) {
114	err = (i - c) / m;
115	if (((i + err) < 0) \|\| ((i + err) >= TABLE_SIZE))
116	continue;
117	derived_table[i] = ref_table[i + err];
118	}
119	} else { /* Constant error take care of divide by zero */
120	for (i = idx1; i <= idx2; i++) {
121	if (((i + err1) < 0) \|\| ((i + err1) >= TABLE_SIZE))
122	continue;
123	derived_table[i] = ref_table[i + err1];
124	}
125	}
126	}
127
128	static int prep_lookup_table(struct err_values err_vals, int ref_table)
129	{
130	int inc, i, seg;
131
132	/*
133	* Fill up the lookup table under 3 segments
134	* region -40C to +30C
135	* region +30C to +125C
136	* region +125C to +150C
137	*/
138	for (seg = 0; seg < 3; seg++)
139	create_table_segments(err_vals, seg, ref_table);
140
141	/* Get to the first valid temperature */
142	i = 0;
143	while (!derived_table[i])
144	i++;
145
146	/*
147	* Get to the last zero index and back fill the temperature for
148	* sake of continuity
149	*/
150	if (i) {
151	/* 300 milli celsius steps */
152	while (i--)
153	derived_table[i] = derived_table[i + 1] - 300;
ffcb2fc8 K	154	}
	155
	156	/*
	157	* Fill the last trailing 0s which are unfilled with increments of
	158	* 100 milli celsius till 1023 code
	159	*/
	160	i = TABLE_SIZE - 1;
	161	while (!derived_table[i])
	162	i--;
	163
	164	i++;
	165	inc = 1;
	166	while (i < TABLE_SIZE) {
	167	derived_table[i] = derived_table[i - 1] + inc * 100;
	168	i++;
	169	}
	170
	171	return 0;
	172	}
	173
	174	struct k3_thermal_data;
	175
	176	struct k3_j72xx_bandgap {
	177	struct device *dev;
	178	void __iomem *base;
	179	void __iomem *cfg2_base;
	180	void __iomem *fuse_base;
	181	struct k3_thermal_data *ts_data[K3_VTM_MAX_NUM_TS];
	182	};
	183
	184	/* common data structures */
	185	struct k3_thermal_data {
	186	struct k3_j72xx_bandgap *bgp;
	187	u32 ctrl_offset;
	188	u32 stat_offset;
	189	};
	190
	191	static int two_cmp(int tmp, int mask)
	192	{
	193	tmp = ~(tmp);
	194	tmp &= mask;
	195	tmp += 1;
	196
	197	/* Return negative value */
	198	return (0 - tmp);
	199	}
	200
	201	static unsigned int vtm_get_best_value(unsigned int s0, unsigned int s1,
	202	unsigned int s2)
	203	{
	204	int d01 = abs(s0 - s1);
	205	int d02 = abs(s0 - s2);
	206	int d12 = abs(s1 - s2);
	207
	208	if (d01 <= d02 && d01 <= d12)
	209	return (s0 + s1) / 2;
	210
	211	if (d02 <= d01 && d02 <= d12)
	212	return (s0 + s2) / 2;
	213
	214	return (s1 + s2) / 2;
	215	}
	216
	217	static inline int k3_bgp_read_temp(struct k3_thermal_data *devdata,
218	int *temp)
219	{
220	struct k3_j72xx_bandgap *bgp;
221	unsigned int dtemp, s0, s1, s2;
222
223	bgp = devdata->bgp;
224	/*
225	* Errata is applicable for am654 pg 1.0 silicon/J7ES. There
226	* is a variation of the order for certain degree centigrade on AM654.
227	* Work around that by getting the average of two closest
228	* readings out of three readings everytime we want to
229	* report temperatures.
230	*
231	* Errata workaround.
232	*/
233	s0 = readl(bgp->base + devdata->stat_offset) &
234	K3_VTM_TS_STAT_DTEMP_MASK;
235	s1 = readl(bgp->base + devdata->stat_offset) &
236	K3_VTM_TS_STAT_DTEMP_MASK;
237	s2 = readl(bgp->base + devdata->stat_offset) &
238	K3_VTM_TS_STAT_DTEMP_MASK;
239	dtemp = vtm_get_best_value(s0, s1, s2);
240
241	if (dtemp < 0 \|\| dtemp >= TABLE_SIZE)
242	return -EINVAL;
243
244	*temp = derived_table[dtemp];
245
246	return 0;
247	}
248
249	/* Get temperature callback function for thermal zone */
250	static int k3_thermal_get_temp(void devdata, int temp)
251	{
252	struct k3_thermal_data *data = devdata;
253	int ret = 0;
254
255	ret = k3_bgp_read_temp(data, temp);
256	if (ret)
257	return ret;
258
259	return ret;
260	}
261
262	static const struct thermal_zone_of_device_ops k3_of_thermal_ops = {
263	.get_temp = k3_thermal_get_temp,
264	};
265
266	static int k3_j72xx_bandgap_temp_to_adc_code(int temp)
267	{
268	int low = 0, high = TABLE_SIZE - 1, mid;
269
270	if (temp > 160000 \|\| temp < -50000)
271	return -EINVAL;
272
273	/* Binary search to find the adc code */
274	while (low < (high - 1)) {
275	mid = (low + high) / 2;
276	if (temp <= derived_table[mid])
277	high = mid;
278	else
279	low = mid;
280	}
281
282	return mid;
283	}
284
285	static void get_efuse_values(int id, struct k3_thermal_data data, int err,
286	struct k3_j72xx_bandgap *bgp)
287	{
288	int i, tmp, pow;
289	int ct_offsets[5][K3_VTM_CORRECTION_TEMP_CNT] = {
290	{ 0x0, 0x8, 0x4 },
291	{ 0x0, 0x8, 0x4 },
292	{ 0x0, -1, 0x4 },
293	{ 0x0, 0xC, -1 },
294	{ 0x0, 0xc, 0x8 }
295	};
296	int ct_bm[5][K3_VTM_CORRECTION_TEMP_CNT] = {
297	{ 0x3f, 0x1fe000, 0x1ff },
298	{ 0xfc0, 0x1fe000, 0x3fe00 },
299	{ 0x3f000, 0x7f800000, 0x7fc0000 },
300	{ 0xfc0000, 0x1fe0, 0x1f800000 },
301	{ 0x3f000000, 0x1fe000, 0x1ff0 }
302	};
303
304	for (i = 0; i < 3; i++) {
305	/* Extract the offset value using bit-mask */
306	if (ct_offsets[id][i] == -1 && i == 1) {
307	/* 25C offset Case of Sensor 2 split between 2 regs */
308	tmp = (readl(bgp->fuse_base + 0x8) & 0xE0000000) >> (29);
309	tmp \|= ((readl(bgp->fuse_base + 0xC) & 0x1F) << 3);
310	pow = tmp & 0x80;
311	} else if (ct_offsets[id][i] == -1 && i == 2) {
312	/* 125C Case of Sensor 3 split between 2 regs */
313	tmp = (readl(bgp->fuse_base + 0x4) & 0xF8000000) >> (27);
314	tmp \|= ((readl(bgp->fuse_base + 0x8) & 0xF) << 5);
315	pow = tmp & 0x100;
316	} else {
317	tmp = readl(bgp->fuse_base + ct_offsets[id][i]);
318	tmp &= ct_bm[id][i];
319	tmp = tmp >> __ffs(ct_bm[id][i]);
320
321	/* Obtain the sign bit pow*/
322	pow = ct_bm[id][i] >> __ffs(ct_bm[id][i]);
323	pow += 1;
324	pow /= 2;
325	}
326
327	/* Check for negative value */
328	if (tmp & pow) {
329	/* 2's complement value */
330	tmp = two_cmp(tmp, ct_bm[id][i] >> __ffs(ct_bm[id][i]));
331	}
332	err[i] = tmp;
333	}
334
335	/* Err value for 150C is set to 0 */
336	err[i] = 0;
337	}
338
339	static void print_look_up_table(struct device dev, int ref_table)
340	{
341	int i;
342
343	dev_dbg(dev, "The contents of derived array\n");
344	dev_dbg(dev, "Code Temperature\n");
345	for (i = 0; i < TABLE_SIZE; i++)
346	dev_dbg(dev, "%d %d %d\n", i, derived_table[i], ref_table[i]);
347	}
348
349	struct k3_j72xx_bandgap_data {
350	unsigned int has_errata_i2128;
351	};
352
353	static int k3_j72xx_bandgap_probe(struct platform_device *pdev)
354	{
355	int ret = 0, cnt, val, id;
356	int high_max, low_temp;
357	struct resource *res;
358	struct device *dev = &pdev->dev;
359	struct k3_j72xx_bandgap *bgp;
360	struct k3_thermal_data *data;
361	int workaround_needed = 0;
362	const struct k3_j72xx_bandgap_data *driver_data;
363	struct thermal_zone_device *ti_thermal;
364	int *ref_table;
365	struct err_values err_vals;
366
367	const s64 golden_factors[] = {
368	-490019999999999936,
369	3251200000000000,
370	-1705800000000,
371	603730000,
372	-92627,
373	};
374
375	const s64 pvt_wa_factors[] = {
376	-415230000000000000,
377	3126600000000000,
378	-1157800000000,
379	};
380
381	bgp = devm_kzalloc(&pdev->dev, sizeof(*bgp), GFP_KERNEL);
382	if (!bgp)
383	return -ENOMEM;
384
385	bgp->dev = dev;
386	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
387	bgp->base = devm_ioremap_resource(dev, res);
388	if (IS_ERR(bgp->base))
389	return PTR_ERR(bgp->base);
390
391	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
392	bgp->cfg2_base = devm_ioremap_resource(dev, res);
393	if (IS_ERR(bgp->cfg2_base))
394	return PTR_ERR(bgp->cfg2_base);
395
396	res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
397	bgp->fuse_base = devm_ioremap_resource(dev, res);
398	if (IS_ERR(bgp->fuse_base))
399	return PTR_ERR(bgp->fuse_base);
400
401	driver_data = of_device_get_match_data(dev);
402	if (driver_data)
403	workaround_needed = driver_data->has_errata_i2128;
404
405	pm_runtime_enable(dev);
406	ret = pm_runtime_get_sync(dev);
407	if (ret < 0) {
408	pm_runtime_put_noidle(dev);
409	pm_runtime_disable(dev);
410	return ret;
411	}
412
413	/* Get the sensor count in the VTM */
414	val = readl(bgp->base + K3_VTM_DEVINFO_PWR0_OFFSET);
415	cnt = val & K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK;
416	cnt >>= __ffs(K3_VTM_DEVINFO_PWR0_TEMPSENS_CT_MASK);
417
418	data = devm_kcalloc(bgp->dev, cnt, sizeof(*data), GFP_KERNEL);
419	if (!data) {
420	ret = -ENOMEM;
421	goto err_alloc;
422	}
423
424	ref_table = kzalloc(sizeof(ref_table) TABLE_SIZE, GFP_KERNEL);
425	if (!ref_table) {
426	ret = -ENOMEM;
427	goto err_alloc;
428	}
429
430	derived_table = devm_kzalloc(bgp->dev, sizeof(derived_table) TABLE_SIZE,
431	GFP_KERNEL);
432	if (!derived_table) {
433	ret = -ENOMEM;
99a049aa	434	goto err_free_ref_table;
ffcb2fc8 K	435	}
	436
	437	/* Workaround not needed if bit30/bit31 is set even for J721e */
	438	if (workaround_needed && (readl(bgp->fuse_base + 0x0) & 0xc0000000) == 0xc0000000)
	439	workaround_needed = false;
	440
	441	dev_dbg(bgp->dev, "Work around %sneeded\n",
	442	workaround_needed ? "not " : "");
	443
	444	if (!workaround_needed)
	445	init_table(5, ref_table, golden_factors);
	446	else
	447	init_table(3, ref_table, pvt_wa_factors);
	448
	449	/* Register the thermal sensors */
	450	for (id = 0; id < cnt; id++) {
	451	data[id].bgp = bgp;
	452	data[id].ctrl_offset = K3_VTM_TMPSENS0_CTRL_OFFSET + id * 0x20;
	453	data[id].stat_offset = data[id].ctrl_offset +
	454	K3_VTM_TMPSENS_STAT_OFFSET;
	455
	456	if (workaround_needed) {
	457	/* ref adc values for -40C, 30C & 125C respectively */
	458	err_vals.refs[0] = MINUS40CREF;
	459	err_vals.refs[1] = PLUS30CREF;
	460	err_vals.refs[2] = PLUS125CREF;
	461	err_vals.refs[3] = PLUS150CREF;
	462	get_efuse_values(id, &data[id], err_vals.errs, bgp);
	463	}
	464
	465	if (id == 0 && workaround_needed)
	466	prep_lookup_table(&err_vals, ref_table);
	467	else if (id == 0 && !workaround_needed)
	468	memcpy(derived_table, ref_table, TABLE_SIZE * 4);
	469
	470	val = readl(data[id].bgp->cfg2_base + data[id].ctrl_offset);
	471	val \|= (K3_VTM_TMPSENS_CTRL_MAXT_OUTRG_EN \|
	472	K3_VTM_TMPSENS_CTRL_SOC \|
	473	K3_VTM_TMPSENS_CTRL_CLRZ \| BIT(4));
	474	writel(val, data[id].bgp->cfg2_base + data[id].ctrl_offset);
	475
	476	bgp->ts_data[id] = &data[id];
	477	ti_thermal =
	478	devm_thermal_zone_of_sensor_register(bgp->dev, id,
	479	&data[id],
	480	&k3_of_thermal_ops);
	481	if (IS_ERR(ti_thermal)) {
	482	dev_err(bgp->dev, "thermal zone device is NULL\n");
	483	ret = PTR_ERR(ti_thermal);
99a049aa	484	goto err_free_ref_table;
ffcb2fc8 K	485	}
	486	}
	487
	488	/*
	489	* Program TSHUT thresholds
	490	* Step 1: set the thresholds to ~123C and 105C WKUP_VTM_MISC_CTRL2
	491	* Step 2: WKUP_VTM_TMPSENS_CTRL_j set the MAXT_OUTRG_EN bit
	492	* This is already taken care as per of init
	493	* Step 3: WKUP_VTM_MISC_CTRL set the ANYMAXT_OUTRG_ALERT_EN bit
	494	*/
	495	high_max = k3_j72xx_bandgap_temp_to_adc_code(MAX_TEMP);
	496	low_temp = k3_j72xx_bandgap_temp_to_adc_code(COOL_DOWN_TEMP);
	497
	498	writel((low_temp << 16) \| high_max, data[0].bgp->cfg2_base +
	499	K3_VTM_MISC_CTRL2_OFFSET);
	500	mdelay(100);
	501	writel(K3_VTM_ANYMAXT_OUTRG_ALERT_EN, data[0].bgp->cfg2_base +
	502	K3_VTM_MISC_CTRL_OFFSET);
	503
	504	platform_set_drvdata(pdev, bgp);
	505
	506	print_look_up_table(dev, ref_table);
	507	/*
	508	* Now that the derived_table has the appropriate look up values
	509	* Free up the ref_table
	510	*/
	511	kfree(ref_table);
	512
	513	return 0;
	514
99a049aa BB	515	err_free_ref_table:
	516	kfree(ref_table);
	517
ffcb2fc8 K	518	err_alloc:
	519	pm_runtime_put_sync(&pdev->dev);
	520	pm_runtime_disable(&pdev->dev);
	521
	522	return ret;
	523	}
	524
	525	static int k3_j72xx_bandgap_remove(struct platform_device *pdev)
	526	{
	527	pm_runtime_put_sync(&pdev->dev);
	528	pm_runtime_disable(&pdev->dev);
	529
	530	return 0;
	531	}
	532
4aaec53b	533	static const struct k3_j72xx_bandgap_data k3_j72xx_bandgap_j721e_data = {
ffcb2fc8 K	534	.has_errata_i2128 = 1,
	535	};
	536
4aaec53b	537	static const struct k3_j72xx_bandgap_data k3_j72xx_bandgap_j7200_data = {
ffcb2fc8 K	538	.has_errata_i2128 = 0,
	539	};
	540
	541	static const struct of_device_id of_k3_j72xx_bandgap_match[] = {
	542	{
	543	.compatible = "ti,j721e-vtm",
	544	.data = &k3_j72xx_bandgap_j721e_data,
	545	},
	546	{
	547	.compatible = "ti,j7200-vtm",
	548	.data = &k3_j72xx_bandgap_j7200_data,
	549	},
	550	{ /* sentinel */ },
	551	};
	552	MODULE_DEVICE_TABLE(of, of_k3_j72xx_bandgap_match);
	553
	554	static struct platform_driver k3_j72xx_bandgap_sensor_driver = {
	555	.probe = k3_j72xx_bandgap_probe,
	556	.remove = k3_j72xx_bandgap_remove,
	557	.driver = {
	558	.name = "k3-j72xx-soc-thermal",
	559	.of_match_table = of_k3_j72xx_bandgap_match,
	560	},
	561	};
	562
	563	module_platform_driver(k3_j72xx_bandgap_sensor_driver);
	564
	565	MODULE_DESCRIPTION("K3 bandgap temperature sensor driver");
	566	MODULE_LICENSE("GPL");
	567	MODULE_AUTHOR("J Keerthy <j-keerthy@ti.com>");