Version:  2.0.40 2.2.26 2.4.37 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19

Linux/drivers/thermal/armada_thermal.c

  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_UNIT_CONTROL_SHIFT         27
 39 #define A375_UNIT_CONTROL_MASK          0x7
 40 #define A375_READOUT_INVERT             BIT(15)
 41 #define A375_HW_RESETn                  BIT(8)
 42 #define A380_HW_RESET                   BIT(8)
 43 
 44 struct armada_thermal_data;
 45 
 46 /* Marvell EBU Thermal Sensor Dev Structure */
 47 struct armada_thermal_priv {
 48         void __iomem *sensor;
 49         void __iomem *control;
 50         struct armada_thermal_data *data;
 51 };
 52 
 53 struct armada_thermal_data {
 54         /* Initialize the sensor */
 55         void (*init_sensor)(struct platform_device *pdev,
 56                             struct armada_thermal_priv *);
 57 
 58         /* Test for a valid sensor value (optional) */
 59         bool (*is_valid)(struct armada_thermal_priv *);
 60 
 61         /* Formula coeficients: temp = (b + m * reg) / div */
 62         unsigned long coef_b;
 63         unsigned long coef_m;
 64         unsigned long coef_div;
 65         bool inverted;
 66 
 67         /* Register shift and mask to access the sensor temperature */
 68         unsigned int temp_shift;
 69         unsigned int temp_mask;
 70         unsigned int is_valid_shift;
 71 };
 72 
 73 static void armadaxp_init_sensor(struct platform_device *pdev,
 74                                  struct armada_thermal_priv *priv)
 75 {
 76         unsigned long reg;
 77 
 78         reg = readl_relaxed(priv->control);
 79         reg |= PMU_TDC0_OTF_CAL_MASK;
 80         writel(reg, priv->control);
 81 
 82         /* Reference calibration value */
 83         reg &= ~PMU_TDC0_REF_CAL_CNT_MASK;
 84         reg |= (0xf1 << PMU_TDC0_REF_CAL_CNT_OFFS);
 85         writel(reg, priv->control);
 86 
 87         /* Reset the sensor */
 88         reg = readl_relaxed(priv->control);
 89         writel((reg | PMU_TDC0_SW_RST_MASK), priv->control);
 90 
 91         writel(reg, priv->control);
 92 
 93         /* Enable the sensor */
 94         reg = readl_relaxed(priv->sensor);
 95         reg &= ~PMU_TM_DISABLE_MASK;
 96         writel(reg, priv->sensor);
 97 }
 98 
 99 static void armada370_init_sensor(struct platform_device *pdev,
100                                   struct armada_thermal_priv *priv)
101 {
102         unsigned long reg;
103 
104         reg = readl_relaxed(priv->control);
105         reg |= PMU_TDC0_OTF_CAL_MASK;
106         writel(reg, priv->control);
107 
108         /* Reference calibration value */
109         reg &= ~PMU_TDC0_REF_CAL_CNT_MASK;
110         reg |= (0xf1 << PMU_TDC0_REF_CAL_CNT_OFFS);
111         writel(reg, priv->control);
112 
113         reg &= ~PMU_TDC0_START_CAL_MASK;
114         writel(reg, priv->control);
115 
116         mdelay(10);
117 }
118 
119 static void armada375_init_sensor(struct platform_device *pdev,
120                                   struct armada_thermal_priv *priv)
121 {
122         unsigned long reg;
123 
124         reg = readl(priv->control + 4);
125         reg &= ~(A375_UNIT_CONTROL_MASK << A375_UNIT_CONTROL_SHIFT);
126         reg &= ~A375_READOUT_INVERT;
127         reg &= ~A375_HW_RESETn;
128 
129         writel(reg, priv->control + 4);
130         mdelay(20);
131 
132         reg |= A375_HW_RESETn;
133         writel(reg, priv->control + 4);
134         mdelay(50);
135 }
136 
137 static void armada380_init_sensor(struct platform_device *pdev,
138                                   struct armada_thermal_priv *priv)
139 {
140         unsigned long reg = readl_relaxed(priv->control);
141 
142         /* Reset hardware once */
143         if (!(reg & A380_HW_RESET)) {
144                 reg |= A380_HW_RESET;
145                 writel(reg, priv->control);
146                 mdelay(10);
147         }
148 }
149 
150 static bool armada_is_valid(struct armada_thermal_priv *priv)
151 {
152         unsigned long reg = readl_relaxed(priv->sensor);
153 
154         return (reg >> priv->data->is_valid_shift) & THERMAL_VALID_MASK;
155 }
156 
157 static int armada_get_temp(struct thermal_zone_device *thermal,
158                           unsigned long *temp)
159 {
160         struct armada_thermal_priv *priv = thermal->devdata;
161         unsigned long reg;
162         unsigned long m, b, div;
163 
164         /* Valid check */
165         if (priv->data->is_valid && !priv->data->is_valid(priv)) {
166                 dev_err(&thermal->device,
167                         "Temperature sensor reading not valid\n");
168                 return -EIO;
169         }
170 
171         reg = readl_relaxed(priv->sensor);
172         reg = (reg >> priv->data->temp_shift) & priv->data->temp_mask;
173 
174         /* Get formula coeficients */
175         b = priv->data->coef_b;
176         m = priv->data->coef_m;
177         div = priv->data->coef_div;
178 
179         if (priv->data->inverted)
180                 *temp = ((m * reg) - b) / div;
181         else
182                 *temp = (b - (m * reg)) / div;
183         return 0;
184 }
185 
186 static struct thermal_zone_device_ops ops = {
187         .get_temp = armada_get_temp,
188 };
189 
190 static const struct armada_thermal_data armadaxp_data = {
191         .init_sensor = armadaxp_init_sensor,
192         .temp_shift = 10,
193         .temp_mask = 0x1ff,
194         .coef_b = 3153000000UL,
195         .coef_m = 10000000UL,
196         .coef_div = 13825,
197 };
198 
199 static const struct armada_thermal_data armada370_data = {
200         .is_valid = armada_is_valid,
201         .init_sensor = armada370_init_sensor,
202         .is_valid_shift = 9,
203         .temp_shift = 10,
204         .temp_mask = 0x1ff,
205         .coef_b = 3153000000UL,
206         .coef_m = 10000000UL,
207         .coef_div = 13825,
208 };
209 
210 static const struct armada_thermal_data armada375_data = {
211         .is_valid = armada_is_valid,
212         .init_sensor = armada375_init_sensor,
213         .is_valid_shift = 10,
214         .temp_shift = 0,
215         .temp_mask = 0x1ff,
216         .coef_b = 3171900000UL,
217         .coef_m = 10000000UL,
218         .coef_div = 13616,
219 };
220 
221 static const struct armada_thermal_data armada380_data = {
222         .is_valid = armada_is_valid,
223         .init_sensor = armada380_init_sensor,
224         .is_valid_shift = 10,
225         .temp_shift = 0,
226         .temp_mask = 0x3ff,
227         .coef_b = 1169498786UL,
228         .coef_m = 2000000UL,
229         .coef_div = 4289,
230         .inverted = true,
231 };
232 
233 static const struct of_device_id armada_thermal_id_table[] = {
234         {
235                 .compatible = "marvell,armadaxp-thermal",
236                 .data       = &armadaxp_data,
237         },
238         {
239                 .compatible = "marvell,armada370-thermal",
240                 .data       = &armada370_data,
241         },
242         {
243                 .compatible = "marvell,armada375-thermal",
244                 .data       = &armada375_data,
245         },
246         {
247                 .compatible = "marvell,armada380-thermal",
248                 .data       = &armada380_data,
249         },
250         {
251                 /* sentinel */
252         },
253 };
254 MODULE_DEVICE_TABLE(of, armada_thermal_id_table);
255 
256 static int armada_thermal_probe(struct platform_device *pdev)
257 {
258         struct thermal_zone_device *thermal;
259         const struct of_device_id *match;
260         struct armada_thermal_priv *priv;
261         struct resource *res;
262 
263         match = of_match_device(armada_thermal_id_table, &pdev->dev);
264         if (!match)
265                 return -ENODEV;
266 
267         priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
268         if (!priv)
269                 return -ENOMEM;
270 
271         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
272         priv->sensor = devm_ioremap_resource(&pdev->dev, res);
273         if (IS_ERR(priv->sensor))
274                 return PTR_ERR(priv->sensor);
275 
276         res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
277         priv->control = devm_ioremap_resource(&pdev->dev, res);
278         if (IS_ERR(priv->control))
279                 return PTR_ERR(priv->control);
280 
281         priv->data = (struct armada_thermal_data *)match->data;
282         priv->data->init_sensor(pdev, priv);
283 
284         thermal = thermal_zone_device_register("armada_thermal", 0, 0,
285                                                priv, &ops, NULL, 0, 0);
286         if (IS_ERR(thermal)) {
287                 dev_err(&pdev->dev,
288                         "Failed to register thermal zone device\n");
289                 return PTR_ERR(thermal);
290         }
291 
292         platform_set_drvdata(pdev, thermal);
293 
294         return 0;
295 }
296 
297 static int armada_thermal_exit(struct platform_device *pdev)
298 {
299         struct thermal_zone_device *armada_thermal =
300                 platform_get_drvdata(pdev);
301 
302         thermal_zone_device_unregister(armada_thermal);
303 
304         return 0;
305 }
306 
307 static struct platform_driver armada_thermal_driver = {
308         .probe = armada_thermal_probe,
309         .remove = armada_thermal_exit,
310         .driver = {
311                 .name = "armada_thermal",
312                 .of_match_table = armada_thermal_id_table,
313         },
314 };
315 
316 module_platform_driver(armada_thermal_driver);
317 
318 MODULE_AUTHOR("Ezequiel Garcia <ezequiel.garcia@free-electrons.com>");
319 MODULE_DESCRIPTION("Armada 370/XP thermal driver");
320 MODULE_LICENSE("GPL v2");
321 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us