1 /*
2  * Marvell Armada 370/XP thermal sensor driver
3  *
4  * Copyright (C) 2013 Marvell
5  *
6  * This software is licensed under the terms of the GNU General Public
7  * License version 2, as published by the Free Software Foundation, and
8  * may be copied, distributed, and modified under those terms.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  */
16 #include <linux/device.h>
17 #include <linux/err.h>
18 #include <linux/io.h>
19 #include <linux/kernel.h>
20 #include <linux/of.h>
21 #include <linux/module.h>
22 #include <linux/delay.h>
23 #include <linux/platform_device.h>
24 #include <linux/of_device.h>
25 #include <linux/thermal.h>
26 
27 #define THERMAL_VALID_MASK		0x1
28 
29 /* Thermal Manager Control and Status Register */
30 #define PMU_TDC0_SW_RST_MASK		(0x1 << 1)
31 #define PMU_TM_DISABLE_OFFS		0
32 #define PMU_TM_DISABLE_MASK		(0x1 << PMU_TM_DISABLE_OFFS)
33 #define PMU_TDC0_REF_CAL_CNT_OFFS	11
34 #define PMU_TDC0_REF_CAL_CNT_MASK	(0x1ff << PMU_TDC0_REF_CAL_CNT_OFFS)
35 #define PMU_TDC0_OTF_CAL_MASK		(0x1 << 30)
36 #define PMU_TDC0_START_CAL_MASK		(0x1 << 25)
37 
38 #define A375_Z1_CAL_RESET_LSB		0x8011e214
39 #define A375_Z1_CAL_RESET_MSB		0x30a88019
40 #define A375_Z1_WORKAROUND_BIT		BIT(9)
41 
42 #define A375_UNIT_CONTROL_SHIFT		27
43 #define A375_UNIT_CONTROL_MASK		0x7
44 #define A375_READOUT_INVERT		BIT(15)
45 #define A375_HW_RESETn			BIT(8)
46 #define A380_HW_RESET			BIT(8)
47 
48 struct armada_thermal_data;
49 
50 /* Marvell EBU Thermal Sensor Dev Structure */
51 struct armada_thermal_priv {
52 	void __iomem *sensor;
53 	void __iomem *control;
54 	struct armada_thermal_data *data;
55 };
56 
57 struct armada_thermal_data {
58 	/* Initialize the sensor */
59 	void (*init_sensor)(struct platform_device *pdev,
60 			    struct armada_thermal_priv *);
61 
62 	/* Test for a valid sensor value (optional) */
63 	bool (*is_valid)(struct armada_thermal_priv *);
64 
65 	/* Formula coeficients: temp = (b + m * reg) / div */
66 	unsigned long coef_b;
67 	unsigned long coef_m;
68 	unsigned long coef_div;
69 	bool inverted;
70 
71 	/* Register shift and mask to access the sensor temperature */
72 	unsigned int temp_shift;
73 	unsigned int temp_mask;
74 	unsigned int is_valid_shift;
75 };
76 
77 static void armadaxp_init_sensor(struct platform_device *pdev,
78 				 struct armada_thermal_priv *priv)
79 {
80 	unsigned long reg;
81 
82 	reg = readl_relaxed(priv->control);
83 	reg |= PMU_TDC0_OTF_CAL_MASK;
84 	writel(reg, priv->control);
85 
86 	/* Reference calibration value */
87 	reg &= ~PMU_TDC0_REF_CAL_CNT_MASK;
88 	reg |= (0xf1 << PMU_TDC0_REF_CAL_CNT_OFFS);
89 	writel(reg, priv->control);
90 
91 	/* Reset the sensor */
92 	reg = readl_relaxed(priv->control);
93 	writel((reg | PMU_TDC0_SW_RST_MASK), priv->control);
94 
95 	writel(reg, priv->control);
96 
97 	/* Enable the sensor */
98 	reg = readl_relaxed(priv->sensor);
99 	reg &= ~PMU_TM_DISABLE_MASK;
100 	writel(reg, priv->sensor);
101 }
102 
103 static void armada370_init_sensor(struct platform_device *pdev,
104 				  struct armada_thermal_priv *priv)
105 {
106 	unsigned long reg;
107 
108 	reg = readl_relaxed(priv->control);
109 	reg |= PMU_TDC0_OTF_CAL_MASK;
110 	writel(reg, priv->control);
111 
112 	/* Reference calibration value */
113 	reg &= ~PMU_TDC0_REF_CAL_CNT_MASK;
114 	reg |= (0xf1 << PMU_TDC0_REF_CAL_CNT_OFFS);
115 	writel(reg, priv->control);
116 
117 	reg &= ~PMU_TDC0_START_CAL_MASK;
118 	writel(reg, priv->control);
119 
120 	mdelay(10);
121 }
122 
123 static void armada375_init_sensor(struct platform_device *pdev,
124 				  struct armada_thermal_priv *priv)
125 {
126 	unsigned long reg;
127 	bool quirk_needed =
128 		!!of_device_is_compatible(pdev->dev.of_node,
129 					  "marvell,armada375-z1-thermal");
130 
131 	if (quirk_needed) {
132 		/* Ensure these registers have the default (reset) values */
133 		writel(A375_Z1_CAL_RESET_LSB, priv->control);
134 		writel(A375_Z1_CAL_RESET_MSB, priv->control + 0x4);
135 	}
136 
137 	reg = readl(priv->control + 4);
138 	reg &= ~(A375_UNIT_CONTROL_MASK << A375_UNIT_CONTROL_SHIFT);
139 	reg &= ~A375_READOUT_INVERT;
140 	reg &= ~A375_HW_RESETn;
141 
142 	if (quirk_needed)
143 		reg |= A375_Z1_WORKAROUND_BIT;
144 
145 	writel(reg, priv->control + 4);
146 	mdelay(20);
147 
148 	reg |= A375_HW_RESETn;
149 	writel(reg, priv->control + 4);
150 	mdelay(50);
151 }
152 
153 static void armada380_init_sensor(struct platform_device *pdev,
154 				  struct armada_thermal_priv *priv)
155 {
156 	unsigned long reg = readl_relaxed(priv->control);
157 
158 	/* Reset hardware once */
159 	if (!(reg & A380_HW_RESET)) {
160 		reg |= A380_HW_RESET;
161 		writel(reg, priv->control);
162 		mdelay(10);
163 	}
164 }
165 
166 static bool armada_is_valid(struct armada_thermal_priv *priv)
167 {
168 	unsigned long reg = readl_relaxed(priv->sensor);
169 
170 	return (reg >> priv->data->is_valid_shift) & THERMAL_VALID_MASK;
171 }
172 
173 static int armada_get_temp(struct thermal_zone_device *thermal,
174 			  unsigned long *temp)
175 {
176 	struct armada_thermal_priv *priv = thermal->devdata;
177 	unsigned long reg;
178 	unsigned long m, b, div;
179 
180 	/* Valid check */
181 	if (priv->data->is_valid && !priv->data->is_valid(priv)) {
182 		dev_err(&thermal->device,
183 			"Temperature sensor reading not valid\n");
184 		return -EIO;
185 	}
186 
187 	reg = readl_relaxed(priv->sensor);
188 	reg = (reg >> priv->data->temp_shift) & priv->data->temp_mask;
189 
190 	/* Get formula coeficients */
191 	b = priv->data->coef_b;
192 	m = priv->data->coef_m;
193 	div = priv->data->coef_div;
194 
195 	if (priv->data->inverted)
196 		*temp = ((m * reg) - b) / div;
197 	else
198 		*temp = (b - (m * reg)) / div;
199 	return 0;
200 }
201 
202 static struct thermal_zone_device_ops ops = {
203 	.get_temp = armada_get_temp,
204 };
205 
206 static const struct armada_thermal_data armadaxp_data = {
207 	.init_sensor = armadaxp_init_sensor,
208 	.temp_shift = 10,
209 	.temp_mask = 0x1ff,
210 	.coef_b = 3153000000UL,
211 	.coef_m = 10000000UL,
212 	.coef_div = 13825,
213 };
214 
215 static const struct armada_thermal_data armada370_data = {
216 	.is_valid = armada_is_valid,
217 	.init_sensor = armada370_init_sensor,
218 	.is_valid_shift = 9,
219 	.temp_shift = 10,
220 	.temp_mask = 0x1ff,
221 	.coef_b = 3153000000UL,
222 	.coef_m = 10000000UL,
223 	.coef_div = 13825,
224 };
225 
226 static const struct armada_thermal_data armada375_data = {
227 	.is_valid = armada_is_valid,
228 	.init_sensor = armada375_init_sensor,
229 	.is_valid_shift = 10,
230 	.temp_shift = 0,
231 	.temp_mask = 0x1ff,
232 	.coef_b = 3171900000UL,
233 	.coef_m = 10000000UL,
234 	.coef_div = 13616,
235 };
236 
237 static const struct armada_thermal_data armada380_data = {
238 	.is_valid = armada_is_valid,
239 	.init_sensor = armada380_init_sensor,
240 	.is_valid_shift = 10,
241 	.temp_shift = 0,
242 	.temp_mask = 0x3ff,
243 	.coef_b = 1169498786UL,
244 	.coef_m = 2000000UL,
245 	.coef_div = 4289,
246 	.inverted = true,
247 };
248 
249 static const struct of_device_id armada_thermal_id_table[] = {
250 	{
251 		.compatible = "marvell,armadaxp-thermal",
252 		.data       = &armadaxp_data,
253 	},
254 	{
255 		.compatible = "marvell,armada370-thermal",
256 		.data       = &armada370_data,
257 	},
258 	{
259 		.compatible = "marvell,armada375-thermal",
260 		.data       = &armada375_data,
261 	},
262 	{
263 		.compatible = "marvell,armada375-z1-thermal",
264 		.data       = &armada375_data,
265 	},
266 	{
267 		.compatible = "marvell,armada380-thermal",
268 		.data       = &armada380_data,
269 	},
270 	{
271 		/* sentinel */
272 	},
273 };
274 MODULE_DEVICE_TABLE(of, armada_thermal_id_table);
275 
276 static int armada_thermal_probe(struct platform_device *pdev)
277 {
278 	struct thermal_zone_device *thermal;
279 	const struct of_device_id *match;
280 	struct armada_thermal_priv *priv;
281 	struct resource *res;
282 
283 	match = of_match_device(armada_thermal_id_table, &pdev->dev);
284 	if (!match)
285 		return -ENODEV;
286 
287 	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
288 	if (!priv)
289 		return -ENOMEM;
290 
291 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
292 	priv->sensor = devm_ioremap_resource(&pdev->dev, res);
293 	if (IS_ERR(priv->sensor))
294 		return PTR_ERR(priv->sensor);
295 
296 	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
297 	priv->control = devm_ioremap_resource(&pdev->dev, res);
298 	if (IS_ERR(priv->control))
299 		return PTR_ERR(priv->control);
300 
301 	priv->data = (struct armada_thermal_data *)match->data;
302 	priv->data->init_sensor(pdev, priv);
303 
304 	thermal = thermal_zone_device_register("armada_thermal", 0, 0,
305 					       priv, &ops, NULL, 0, 0);
306 	if (IS_ERR(thermal)) {
307 		dev_err(&pdev->dev,
308 			"Failed to register thermal zone device\n");
309 		return PTR_ERR(thermal);
310 	}
311 
312 	platform_set_drvdata(pdev, thermal);
313 
314 	return 0;
315 }
316 
317 static int armada_thermal_exit(struct platform_device *pdev)
318 {
319 	struct thermal_zone_device *armada_thermal =
320 		platform_get_drvdata(pdev);
321 
322 	thermal_zone_device_unregister(armada_thermal);
323 
324 	return 0;
325 }
326 
327 static struct platform_driver armada_thermal_driver = {
328 	.probe = armada_thermal_probe,
329 	.remove = armada_thermal_exit,
330 	.driver = {
331 		.name = "armada_thermal",
332 		.owner = THIS_MODULE,
333 		.of_match_table = armada_thermal_id_table,
334 	},
335 };
336 
337 module_platform_driver(armada_thermal_driver);
338 
339 MODULE_AUTHOR("Ezequiel Garcia <ezequiel.garcia@free-electrons.com>");
340 MODULE_DESCRIPTION("Armada 370/XP thermal driver");
341 MODULE_LICENSE("GPL v2");
342