k3_j72xx_bandgap.c

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