1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * ST Thermal Sensor Driver core routines
4 * Author: Ajit Pal Singh <ajitpal.singh@st.com>
5 *
6 * Copyright (C) 2003-2014 STMicroelectronics (R&D) Limited
7 */
8
9#include <linux/clk.h>
10#include <linux/module.h>
11#include <linux/of.h>
12#include <linux/of_device.h>
13
14#include "st_thermal.h"
15
16/* The Thermal Framework expects millidegrees */
17#define mcelsius(temp)			((temp) * 1000)
18
19/*
20 * Function to allocate regfields which are common
21 * between syscfg and memory mapped based sensors
22 */
23static int st_thermal_alloc_regfields(struct st_thermal_sensor *sensor)
24{
25	struct device *dev = sensor->dev;
26	struct regmap *regmap = sensor->regmap;
27	const struct reg_field *reg_fields = sensor->cdata->reg_fields;
28
29	sensor->dcorrect = devm_regmap_field_alloc(dev, regmap,
30						   reg_fields[DCORRECT]);
31
32	sensor->overflow = devm_regmap_field_alloc(dev, regmap,
33						   reg_fields[OVERFLOW]);
34
35	sensor->temp_data = devm_regmap_field_alloc(dev, regmap,
36						    reg_fields[DATA]);
37
38	if (IS_ERR(sensor->dcorrect) ||
39	    IS_ERR(sensor->overflow) ||
40	    IS_ERR(sensor->temp_data)) {
41		dev_err(dev, "failed to allocate common regfields\n");
42		return -EINVAL;
43	}
44
45	return sensor->ops->alloc_regfields(sensor);
46}
47
48static int st_thermal_sensor_on(struct st_thermal_sensor *sensor)
49{
50	int ret;
51	struct device *dev = sensor->dev;
52
53	ret = clk_prepare_enable(sensor->clk);
54	if (ret) {
55		dev_err(dev, "failed to enable clk\n");
56		return ret;
57	}
58
59	ret = sensor->ops->power_ctrl(sensor, POWER_ON);
60	if (ret) {
61		dev_err(dev, "failed to power on sensor\n");
62		clk_disable_unprepare(sensor->clk);
63	}
64
65	return ret;
66}
67
68static int st_thermal_sensor_off(struct st_thermal_sensor *sensor)
69{
70	int ret;
71
72	ret = sensor->ops->power_ctrl(sensor, POWER_OFF);
73	if (ret)
74		return ret;
75
76	clk_disable_unprepare(sensor->clk);
77
78	return 0;
79}
80
81static int st_thermal_calibration(struct st_thermal_sensor *sensor)
82{
83	int ret;
84	unsigned int val;
85	struct device *dev = sensor->dev;
86
87	/* Check if sensor calibration data is already written */
88	ret = regmap_field_read(sensor->dcorrect, &val);
89	if (ret) {
90		dev_err(dev, "failed to read calibration data\n");
91		return ret;
92	}
93
94	if (!val) {
95		/*
96		 * Sensor calibration value not set by bootloader,
97		 * default calibration data to be used
98		 */
99		ret = regmap_field_write(sensor->dcorrect,
100					 sensor->cdata->calibration_val);
101		if (ret)
102			dev_err(dev, "failed to set calibration data\n");
103	}
104
105	return ret;
106}
107
108/* Callback to get temperature from HW*/
109static int st_thermal_get_temp(struct thermal_zone_device *th, int *temperature)
110{
111	struct st_thermal_sensor *sensor = thermal_zone_device_priv(th);
112	unsigned int temp;
113	unsigned int overflow;
114	int ret;
115
116	ret = regmap_field_read(sensor->overflow, &overflow);
117	if (ret)
118		return ret;
119	if (overflow)
120		return -EIO;
121
122	ret = regmap_field_read(sensor->temp_data, &temp);
123	if (ret)
124		return ret;
125
126	temp += sensor->cdata->temp_adjust_val;
127	temp = mcelsius(temp);
128
129	*temperature = temp;
130
131	return 0;
132}
133
134static struct thermal_zone_device_ops st_tz_ops = {
135	.get_temp	= st_thermal_get_temp,
136};
137
138static struct thermal_trip trip;
139
140int st_thermal_register(struct platform_device *pdev,
141			const struct of_device_id *st_thermal_of_match)
142{
143	struct st_thermal_sensor *sensor;
144	struct device *dev = &pdev->dev;
145	struct device_node *np = dev->of_node;
146	const struct of_device_id *match;
147
148	int polling_delay;
149	int ret;
150
151	if (!np) {
152		dev_err(dev, "device tree node not found\n");
153		return -EINVAL;
154	}
155
156	sensor = devm_kzalloc(dev, sizeof(*sensor), GFP_KERNEL);
157	if (!sensor)
158		return -ENOMEM;
159
160	sensor->dev = dev;
161
162	match = of_match_device(st_thermal_of_match, dev);
163	if (!(match && match->data))
164		return -EINVAL;
165
166	sensor->cdata = match->data;
167	if (!sensor->cdata->ops)
168		return -EINVAL;
169
170	sensor->ops = sensor->cdata->ops;
171
172	ret = (sensor->ops->regmap_init)(sensor);
173	if (ret)
174		return ret;
175
176	ret = st_thermal_alloc_regfields(sensor);
177	if (ret)
178		return ret;
179
180	sensor->clk = devm_clk_get(dev, "thermal");
181	if (IS_ERR(sensor->clk)) {
182		dev_err(dev, "failed to fetch clock\n");
183		return PTR_ERR(sensor->clk);
184	}
185
186	if (sensor->ops->register_enable_irq) {
187		ret = sensor->ops->register_enable_irq(sensor);
188		if (ret)
189			return ret;
190	}
191
192	ret = st_thermal_sensor_on(sensor);
193	if (ret)
194		return ret;
195
196	ret = st_thermal_calibration(sensor);
197	if (ret)
198		goto sensor_off;
199
200	polling_delay = sensor->ops->register_enable_irq ? 0 : 1000;
201
202	trip.temperature = sensor->cdata->crit_temp;
203	trip.type = THERMAL_TRIP_CRITICAL;
204
205	sensor->thermal_dev =
206		thermal_zone_device_register_with_trips(dev_name(dev), &trip, 1, 0, sensor,
207							&st_tz_ops, NULL, 0, polling_delay);
208	if (IS_ERR(sensor->thermal_dev)) {
209		dev_err(dev, "failed to register thermal zone device\n");
210		ret = PTR_ERR(sensor->thermal_dev);
211		goto sensor_off;
212	}
213	ret = thermal_zone_device_enable(sensor->thermal_dev);
214	if (ret)
215		goto tzd_unregister;
216
217	platform_set_drvdata(pdev, sensor);
218
219	return 0;
220
221tzd_unregister:
222	thermal_zone_device_unregister(sensor->thermal_dev);
223sensor_off:
224	st_thermal_sensor_off(sensor);
225
226	return ret;
227}
228EXPORT_SYMBOL_GPL(st_thermal_register);
229
230void st_thermal_unregister(struct platform_device *pdev)
231{
232	struct st_thermal_sensor *sensor = platform_get_drvdata(pdev);
233
234	st_thermal_sensor_off(sensor);
235	thermal_zone_device_unregister(sensor->thermal_dev);
236}
237EXPORT_SYMBOL_GPL(st_thermal_unregister);
238
239#ifdef CONFIG_PM_SLEEP
240static int st_thermal_suspend(struct device *dev)
241{
242	struct st_thermal_sensor *sensor = dev_get_drvdata(dev);
243
244	return st_thermal_sensor_off(sensor);
245}
246
247static int st_thermal_resume(struct device *dev)
248{
249	int ret;
250	struct st_thermal_sensor *sensor = dev_get_drvdata(dev);
251
252	ret = st_thermal_sensor_on(sensor);
253	if (ret)
254		return ret;
255
256	ret = st_thermal_calibration(sensor);
257	if (ret)
258		return ret;
259
260	if (sensor->ops->enable_irq) {
261		ret = sensor->ops->enable_irq(sensor);
262		if (ret)
263			return ret;
264	}
265
266	return 0;
267}
268#endif
269
270SIMPLE_DEV_PM_OPS(st_thermal_pm_ops, st_thermal_suspend, st_thermal_resume);
271EXPORT_SYMBOL_GPL(st_thermal_pm_ops);
272
273MODULE_AUTHOR("STMicroelectronics (R&D) Limited <ajitpal.singh@st.com>");
274MODULE_DESCRIPTION("STMicroelectronics STi SoC Thermal Sensor Driver");
275MODULE_LICENSE("GPL v2");
276