1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) STMicroelectronics 2018 - All Rights Reserved
4  * Author: David Hernandez Sanchez <david.hernandezsanchez@st.com> for
5  * STMicroelectronics.
6  */
7 
8 #include <linux/clk.h>
9 #include <linux/clk-provider.h>
10 #include <linux/delay.h>
11 #include <linux/err.h>
12 #include <linux/interrupt.h>
13 #include <linux/io.h>
14 #include <linux/iopoll.h>
15 #include <linux/module.h>
16 #include <linux/of.h>
17 #include <linux/of_address.h>
18 #include <linux/of_device.h>
19 #include <linux/platform_device.h>
20 #include <linux/thermal.h>
21 
22 #include "../thermal_core.h"
23 #include "../thermal_hwmon.h"
24 
25 /* DTS register offsets */
26 #define DTS_CFGR1_OFFSET	0x0
27 #define DTS_T0VALR1_OFFSET	0x8
28 #define DTS_RAMPVALR_OFFSET	0X10
29 #define DTS_ITR1_OFFSET		0x14
30 #define DTS_DR_OFFSET		0x1C
31 #define DTS_SR_OFFSET		0x20
32 #define DTS_ITENR_OFFSET	0x24
33 #define DTS_ICIFR_OFFSET	0x28
34 
35 /* DTS_CFGR1 register mask definitions */
36 #define HSREF_CLK_DIV_MASK	GENMASK(30, 24)
37 #define TS1_SMP_TIME_MASK	GENMASK(19, 16)
38 #define TS1_INTRIG_SEL_MASK	GENMASK(11, 8)
39 
40 /* DTS_T0VALR1 register mask definitions */
41 #define TS1_T0_MASK		GENMASK(17, 16)
42 #define TS1_FMT0_MASK		GENMASK(15, 0)
43 
44 /* DTS_RAMPVALR register mask definitions */
45 #define TS1_RAMP_COEFF_MASK	GENMASK(15, 0)
46 
47 /* DTS_ITR1 register mask definitions */
48 #define TS1_HITTHD_MASK		GENMASK(31, 16)
49 #define TS1_LITTHD_MASK		GENMASK(15, 0)
50 
51 /* DTS_DR register mask definitions */
52 #define TS1_MFREQ_MASK		GENMASK(15, 0)
53 
54 /* DTS_ITENR register mask definitions */
55 #define ITENR_MASK		(GENMASK(2, 0) | GENMASK(6, 4))
56 
57 /* DTS_ICIFR register mask definitions */
58 #define ICIFR_MASK		(GENMASK(2, 0) | GENMASK(6, 4))
59 
60 /* Less significant bit position definitions */
61 #define TS1_T0_POS		16
62 #define TS1_HITTHD_POS		16
63 #define TS1_LITTHD_POS		0
64 #define HSREF_CLK_DIV_POS	24
65 
66 /* DTS_CFGR1 bit definitions */
67 #define TS1_EN			BIT(0)
68 #define TS1_START		BIT(4)
69 #define REFCLK_SEL		BIT(20)
70 #define REFCLK_LSE		REFCLK_SEL
71 #define Q_MEAS_OPT		BIT(21)
72 #define CALIBRATION_CONTROL	Q_MEAS_OPT
73 
74 /* DTS_SR bit definitions */
75 #define TS_RDY			BIT(15)
76 /* Bit definitions below are common for DTS_SR, DTS_ITENR and DTS_CIFR */
77 #define HIGH_THRESHOLD		BIT(2)
78 #define LOW_THRESHOLD		BIT(1)
79 
80 /* Constants */
81 #define ADJUST			100
82 #define ONE_MHZ			1000000
83 #define POLL_TIMEOUT		5000
84 #define STARTUP_TIME		40
85 #define TS1_T0_VAL0		30000  /* 30 celsius */
86 #define TS1_T0_VAL1		130000 /* 130 celsius */
87 #define NO_HW_TRIG		0
88 #define SAMPLING_TIME		15
89 
90 struct stm_thermal_sensor {
91 	struct device *dev;
92 	struct thermal_zone_device *th_dev;
93 	enum thermal_device_mode mode;
94 	struct clk *clk;
95 	unsigned int low_temp_enabled;
96 	unsigned int high_temp_enabled;
97 	int irq;
98 	void __iomem *base;
99 	int t0, fmt0, ramp_coeff;
100 };
101 
stm_enable_irq(struct stm_thermal_sensor * sensor)102 static int stm_enable_irq(struct stm_thermal_sensor *sensor)
103 {
104 	u32 value;
105 
106 	dev_dbg(sensor->dev, "low:%d high:%d\n", sensor->low_temp_enabled,
107 		sensor->high_temp_enabled);
108 
109 	/* Disable IT generation for low and high thresholds */
110 	value = readl_relaxed(sensor->base + DTS_ITENR_OFFSET);
111 	value &= ~(LOW_THRESHOLD | HIGH_THRESHOLD);
112 
113 	if (sensor->low_temp_enabled)
114 		value |= HIGH_THRESHOLD;
115 
116 	if (sensor->high_temp_enabled)
117 		value |= LOW_THRESHOLD;
118 
119 	/* Enable interrupts */
120 	writel_relaxed(value, sensor->base + DTS_ITENR_OFFSET);
121 
122 	return 0;
123 }
124 
stm_thermal_irq_handler(int irq,void * sdata)125 static irqreturn_t stm_thermal_irq_handler(int irq, void *sdata)
126 {
127 	struct stm_thermal_sensor *sensor = sdata;
128 
129 	dev_dbg(sensor->dev, "sr:%d\n",
130 		readl_relaxed(sensor->base + DTS_SR_OFFSET));
131 
132 	thermal_zone_device_update(sensor->th_dev, THERMAL_EVENT_UNSPECIFIED);
133 
134 	stm_enable_irq(sensor);
135 
136 	/* Acknoledge all DTS irqs */
137 	writel_relaxed(ICIFR_MASK, sensor->base + DTS_ICIFR_OFFSET);
138 
139 	return IRQ_HANDLED;
140 }
141 
stm_sensor_power_on(struct stm_thermal_sensor * sensor)142 static int stm_sensor_power_on(struct stm_thermal_sensor *sensor)
143 {
144 	int ret;
145 	u32 value;
146 
147 	/* Enable sensor */
148 	value = readl_relaxed(sensor->base + DTS_CFGR1_OFFSET);
149 	value |= TS1_EN;
150 	writel_relaxed(value, sensor->base + DTS_CFGR1_OFFSET);
151 
152 	/*
153 	 * The DTS block can be enabled by setting TSx_EN bit in
154 	 * DTS_CFGRx register. It requires a startup time of
155 	 * 40μs. Use 5 ms as arbitrary timeout.
156 	 */
157 	ret = readl_poll_timeout(sensor->base + DTS_SR_OFFSET,
158 				 value, (value & TS_RDY),
159 				 STARTUP_TIME, POLL_TIMEOUT);
160 	if (ret)
161 		return ret;
162 
163 	/* Start continuous measuring */
164 	value = readl_relaxed(sensor->base +
165 			      DTS_CFGR1_OFFSET);
166 	value |= TS1_START;
167 	writel_relaxed(value, sensor->base +
168 		       DTS_CFGR1_OFFSET);
169 
170 	sensor->mode = THERMAL_DEVICE_ENABLED;
171 
172 	return 0;
173 }
174 
stm_sensor_power_off(struct stm_thermal_sensor * sensor)175 static int stm_sensor_power_off(struct stm_thermal_sensor *sensor)
176 {
177 	u32 value;
178 
179 	sensor->mode = THERMAL_DEVICE_DISABLED;
180 
181 	/* Stop measuring */
182 	value = readl_relaxed(sensor->base + DTS_CFGR1_OFFSET);
183 	value &= ~TS1_START;
184 	writel_relaxed(value, sensor->base + DTS_CFGR1_OFFSET);
185 
186 	/* Ensure stop is taken into account */
187 	usleep_range(STARTUP_TIME, POLL_TIMEOUT);
188 
189 	/* Disable sensor */
190 	value = readl_relaxed(sensor->base + DTS_CFGR1_OFFSET);
191 	value &= ~TS1_EN;
192 	writel_relaxed(value, sensor->base + DTS_CFGR1_OFFSET);
193 
194 	/* Ensure disable is taken into account */
195 	return readl_poll_timeout(sensor->base + DTS_SR_OFFSET, value,
196 				  !(value & TS_RDY),
197 				  STARTUP_TIME, POLL_TIMEOUT);
198 }
199 
stm_thermal_calibration(struct stm_thermal_sensor * sensor)200 static int stm_thermal_calibration(struct stm_thermal_sensor *sensor)
201 {
202 	u32 value, clk_freq;
203 	u32 prescaler;
204 
205 	/* Figure out prescaler value for PCLK during calibration */
206 	clk_freq = clk_get_rate(sensor->clk);
207 	if (!clk_freq)
208 		return -EINVAL;
209 
210 	prescaler = 0;
211 	clk_freq /= ONE_MHZ;
212 	if (clk_freq) {
213 		while (prescaler <= clk_freq)
214 			prescaler++;
215 	}
216 
217 	value = readl_relaxed(sensor->base + DTS_CFGR1_OFFSET);
218 
219 	/* Clear prescaler */
220 	value &= ~HSREF_CLK_DIV_MASK;
221 
222 	/* Set prescaler. pclk_freq/prescaler < 1MHz */
223 	value |= (prescaler << HSREF_CLK_DIV_POS);
224 
225 	/* Select PCLK as reference clock */
226 	value &= ~REFCLK_SEL;
227 
228 	/* Set maximal sampling time for better precision */
229 	value |= TS1_SMP_TIME_MASK;
230 
231 	/* Measure with calibration */
232 	value &= ~CALIBRATION_CONTROL;
233 
234 	/* select trigger */
235 	value &= ~TS1_INTRIG_SEL_MASK;
236 	value |= NO_HW_TRIG;
237 
238 	writel_relaxed(value, sensor->base + DTS_CFGR1_OFFSET);
239 
240 	return 0;
241 }
242 
243 /* Fill in DTS structure with factory sensor values */
stm_thermal_read_factory_settings(struct stm_thermal_sensor * sensor)244 static int stm_thermal_read_factory_settings(struct stm_thermal_sensor *sensor)
245 {
246 	/* Retrieve engineering calibration temperature */
247 	sensor->t0 = readl_relaxed(sensor->base + DTS_T0VALR1_OFFSET) &
248 					TS1_T0_MASK;
249 	if (!sensor->t0)
250 		sensor->t0 = TS1_T0_VAL0;
251 	else
252 		sensor->t0 = TS1_T0_VAL1;
253 
254 	/* Retrieve fmt0 and put it on Hz */
255 	sensor->fmt0 = ADJUST * (readl_relaxed(sensor->base +
256 				 DTS_T0VALR1_OFFSET) & TS1_FMT0_MASK);
257 
258 	/* Retrieve ramp coefficient */
259 	sensor->ramp_coeff = readl_relaxed(sensor->base + DTS_RAMPVALR_OFFSET) &
260 					   TS1_RAMP_COEFF_MASK;
261 
262 	if (!sensor->fmt0 || !sensor->ramp_coeff) {
263 		dev_err(sensor->dev, "%s: wrong setting\n", __func__);
264 		return -EINVAL;
265 	}
266 
267 	dev_dbg(sensor->dev, "%s: T0 = %doC, FMT0 = %dHz, RAMP_COEFF = %dHz/oC",
268 		__func__, sensor->t0, sensor->fmt0, sensor->ramp_coeff);
269 
270 	return 0;
271 }
272 
stm_thermal_calculate_threshold(struct stm_thermal_sensor * sensor,int temp,u32 * th)273 static int stm_thermal_calculate_threshold(struct stm_thermal_sensor *sensor,
274 					   int temp, u32 *th)
275 {
276 	int freqM;
277 
278 	/* Figure out the CLK_PTAT frequency for a given temperature */
279 	freqM = ((temp - sensor->t0) * sensor->ramp_coeff) / 1000 +
280 		sensor->fmt0;
281 
282 	/* Figure out the threshold sample number */
283 	*th = clk_get_rate(sensor->clk) * SAMPLING_TIME / freqM;
284 	if (!*th)
285 		return -EINVAL;
286 
287 	dev_dbg(sensor->dev, "freqM=%d Hz, threshold=0x%x", freqM, *th);
288 
289 	return 0;
290 }
291 
292 /* Disable temperature interrupt */
stm_disable_irq(struct stm_thermal_sensor * sensor)293 static int stm_disable_irq(struct stm_thermal_sensor *sensor)
294 {
295 	u32 value;
296 
297 	/* Disable IT generation */
298 	value = readl_relaxed(sensor->base + DTS_ITENR_OFFSET);
299 	value &= ~ITENR_MASK;
300 	writel_relaxed(value, sensor->base + DTS_ITENR_OFFSET);
301 
302 	return 0;
303 }
304 
stm_thermal_set_trips(void * data,int low,int high)305 static int stm_thermal_set_trips(void *data, int low, int high)
306 {
307 	struct stm_thermal_sensor *sensor = data;
308 	u32 itr1, th;
309 	int ret;
310 
311 	dev_dbg(sensor->dev, "set trips %d <--> %d\n", low, high);
312 
313 	/* Erase threshold content */
314 	itr1 = readl_relaxed(sensor->base + DTS_ITR1_OFFSET);
315 	itr1 &= ~(TS1_LITTHD_MASK | TS1_HITTHD_MASK);
316 
317 	/*
318 	 * Disable low-temp if "low" is too small. As per thermal framework
319 	 * API, we use -INT_MAX rather than INT_MIN.
320 	 */
321 
322 	if (low > -INT_MAX) {
323 		sensor->low_temp_enabled = 1;
324 		/* add 0.5 of hysteresis due to measurement error */
325 		ret = stm_thermal_calculate_threshold(sensor, low - 500, &th);
326 		if (ret)
327 			return ret;
328 
329 		itr1 |= (TS1_HITTHD_MASK  & (th << TS1_HITTHD_POS));
330 	} else {
331 		sensor->low_temp_enabled = 0;
332 	}
333 
334 	/* Disable high-temp if "high" is too big. */
335 	if (high < INT_MAX) {
336 		sensor->high_temp_enabled = 1;
337 		ret = stm_thermal_calculate_threshold(sensor, high, &th);
338 		if (ret)
339 			return ret;
340 
341 		itr1 |= (TS1_LITTHD_MASK  & (th << TS1_LITTHD_POS));
342 	} else {
343 		sensor->high_temp_enabled = 0;
344 	}
345 
346 	/* Write new threshod values*/
347 	writel_relaxed(itr1, sensor->base + DTS_ITR1_OFFSET);
348 
349 	return 0;
350 }
351 
352 /* Callback to get temperature from HW */
stm_thermal_get_temp(void * data,int * temp)353 static int stm_thermal_get_temp(void *data, int *temp)
354 {
355 	struct stm_thermal_sensor *sensor = data;
356 	u32 periods;
357 	int freqM, ret;
358 
359 	if (sensor->mode != THERMAL_DEVICE_ENABLED)
360 		return -EAGAIN;
361 
362 	/* Retrieve the number of periods sampled */
363 	ret = readl_relaxed_poll_timeout(sensor->base + DTS_DR_OFFSET, periods,
364 					 (periods & TS1_MFREQ_MASK),
365 					 STARTUP_TIME, POLL_TIMEOUT);
366 	if (ret)
367 		return ret;
368 
369 	/* Figure out the CLK_PTAT frequency */
370 	freqM = (clk_get_rate(sensor->clk) * SAMPLING_TIME) / periods;
371 	if (!freqM)
372 		return -EINVAL;
373 
374 	/* Figure out the temperature in mili celsius */
375 	*temp = (freqM - sensor->fmt0) * 1000 / sensor->ramp_coeff + sensor->t0;
376 
377 	return 0;
378 }
379 
380 /* Registers DTS irq to be visible by GIC */
stm_register_irq(struct stm_thermal_sensor * sensor)381 static int stm_register_irq(struct stm_thermal_sensor *sensor)
382 {
383 	struct device *dev = sensor->dev;
384 	struct platform_device *pdev = to_platform_device(dev);
385 	int ret;
386 
387 	sensor->irq = platform_get_irq(pdev, 0);
388 	if (sensor->irq < 0)
389 		return sensor->irq;
390 
391 	ret = devm_request_threaded_irq(dev, sensor->irq,
392 					NULL,
393 					stm_thermal_irq_handler,
394 					IRQF_ONESHOT,
395 					dev->driver->name, sensor);
396 	if (ret) {
397 		dev_err(dev, "%s: Failed to register IRQ %d\n", __func__,
398 			sensor->irq);
399 		return ret;
400 	}
401 
402 	dev_dbg(dev, "%s: thermal IRQ registered", __func__);
403 
404 	return 0;
405 }
406 
stm_thermal_sensor_off(struct stm_thermal_sensor * sensor)407 static int stm_thermal_sensor_off(struct stm_thermal_sensor *sensor)
408 {
409 	int ret;
410 
411 	stm_disable_irq(sensor);
412 
413 	ret = stm_sensor_power_off(sensor);
414 	if (ret)
415 		return ret;
416 
417 	clk_disable_unprepare(sensor->clk);
418 
419 	return 0;
420 }
421 
stm_thermal_prepare(struct stm_thermal_sensor * sensor)422 static int stm_thermal_prepare(struct stm_thermal_sensor *sensor)
423 {
424 	int ret;
425 
426 	ret = clk_prepare_enable(sensor->clk);
427 	if (ret)
428 		return ret;
429 
430 	ret = stm_thermal_read_factory_settings(sensor);
431 	if (ret)
432 		goto thermal_unprepare;
433 
434 	ret = stm_thermal_calibration(sensor);
435 	if (ret)
436 		goto thermal_unprepare;
437 
438 	return 0;
439 
440 thermal_unprepare:
441 	clk_disable_unprepare(sensor->clk);
442 
443 	return ret;
444 }
445 
446 #ifdef CONFIG_PM_SLEEP
stm_thermal_suspend(struct device * dev)447 static int stm_thermal_suspend(struct device *dev)
448 {
449 	struct stm_thermal_sensor *sensor = dev_get_drvdata(dev);
450 
451 	return stm_thermal_sensor_off(sensor);
452 }
453 
stm_thermal_resume(struct device * dev)454 static int stm_thermal_resume(struct device *dev)
455 {
456 	int ret;
457 	struct stm_thermal_sensor *sensor = dev_get_drvdata(dev);
458 
459 	ret = stm_thermal_prepare(sensor);
460 	if (ret)
461 		return ret;
462 
463 	ret = stm_sensor_power_on(sensor);
464 	if (ret)
465 		return ret;
466 
467 	thermal_zone_device_update(sensor->th_dev, THERMAL_EVENT_UNSPECIFIED);
468 	stm_enable_irq(sensor);
469 
470 	return 0;
471 }
472 #endif /* CONFIG_PM_SLEEP */
473 
474 static SIMPLE_DEV_PM_OPS(stm_thermal_pm_ops,
475 			 stm_thermal_suspend, stm_thermal_resume);
476 
477 static const struct thermal_zone_of_device_ops stm_tz_ops = {
478 	.get_temp	= stm_thermal_get_temp,
479 	.set_trips	= stm_thermal_set_trips,
480 };
481 
482 static const struct of_device_id stm_thermal_of_match[] = {
483 		{ .compatible = "st,stm32-thermal"},
484 	{ /* sentinel */ }
485 };
486 MODULE_DEVICE_TABLE(of, stm_thermal_of_match);
487 
stm_thermal_probe(struct platform_device * pdev)488 static int stm_thermal_probe(struct platform_device *pdev)
489 {
490 	struct stm_thermal_sensor *sensor;
491 	struct resource *res;
492 	void __iomem *base;
493 	int ret;
494 
495 	if (!pdev->dev.of_node) {
496 		dev_err(&pdev->dev, "%s: device tree node not found\n",
497 			__func__);
498 		return -EINVAL;
499 	}
500 
501 	sensor = devm_kzalloc(&pdev->dev, sizeof(*sensor), GFP_KERNEL);
502 	if (!sensor)
503 		return -ENOMEM;
504 
505 	platform_set_drvdata(pdev, sensor);
506 
507 	sensor->dev = &pdev->dev;
508 
509 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
510 	base = devm_ioremap_resource(&pdev->dev, res);
511 	if (IS_ERR(base))
512 		return PTR_ERR(base);
513 
514 	/* Populate sensor */
515 	sensor->base = base;
516 
517 	sensor->clk = devm_clk_get(&pdev->dev, "pclk");
518 	if (IS_ERR(sensor->clk)) {
519 		dev_err(&pdev->dev, "%s: failed to fetch PCLK clock\n",
520 			__func__);
521 		return PTR_ERR(sensor->clk);
522 	}
523 
524 	stm_disable_irq(sensor);
525 
526 	/* Clear irq flags */
527 	writel_relaxed(ICIFR_MASK, sensor->base + DTS_ICIFR_OFFSET);
528 
529 	/* Configure and enable HW sensor */
530 	ret = stm_thermal_prepare(sensor);
531 	if (ret) {
532 		dev_err(&pdev->dev, "Error prepare sensor: %d\n", ret);
533 		return ret;
534 	}
535 
536 	ret = stm_sensor_power_on(sensor);
537 	if (ret) {
538 		dev_err(&pdev->dev, "Error power on sensor: %d\n", ret);
539 		return ret;
540 	}
541 
542 	sensor->th_dev = devm_thermal_zone_of_sensor_register(&pdev->dev, 0,
543 							      sensor,
544 							      &stm_tz_ops);
545 
546 	if (IS_ERR(sensor->th_dev)) {
547 		dev_err(&pdev->dev, "%s: thermal zone sensor registering KO\n",
548 			__func__);
549 		ret = PTR_ERR(sensor->th_dev);
550 		return ret;
551 	}
552 
553 	/* Register IRQ into GIC */
554 	ret = stm_register_irq(sensor);
555 	if (ret)
556 		goto err_tz;
557 
558 	stm_enable_irq(sensor);
559 
560 	/*
561 	 * Thermal_zone doesn't enable hwmon as default,
562 	 * enable it here
563 	 */
564 	sensor->th_dev->tzp->no_hwmon = false;
565 	ret = thermal_add_hwmon_sysfs(sensor->th_dev);
566 	if (ret)
567 		goto err_tz;
568 
569 	dev_info(&pdev->dev, "%s: Driver initialized successfully\n",
570 		 __func__);
571 
572 	return 0;
573 
574 err_tz:
575 	thermal_zone_of_sensor_unregister(&pdev->dev, sensor->th_dev);
576 	return ret;
577 }
578 
stm_thermal_remove(struct platform_device * pdev)579 static int stm_thermal_remove(struct platform_device *pdev)
580 {
581 	struct stm_thermal_sensor *sensor = platform_get_drvdata(pdev);
582 
583 	stm_thermal_sensor_off(sensor);
584 	thermal_remove_hwmon_sysfs(sensor->th_dev);
585 	thermal_zone_of_sensor_unregister(&pdev->dev, sensor->th_dev);
586 
587 	return 0;
588 }
589 
590 static struct platform_driver stm_thermal_driver = {
591 	.driver = {
592 		.name	= "stm_thermal",
593 		.pm     = &stm_thermal_pm_ops,
594 		.of_match_table = stm_thermal_of_match,
595 	},
596 	.probe		= stm_thermal_probe,
597 	.remove		= stm_thermal_remove,
598 };
599 module_platform_driver(stm_thermal_driver);
600 
601 MODULE_DESCRIPTION("STMicroelectronics STM32 Thermal Sensor Driver");
602 MODULE_AUTHOR("David Hernandez Sanchez <david.hernandezsanchez@st.com>");
603 MODULE_LICENSE("GPL v2");
604 MODULE_ALIAS("platform:stm_thermal");
605