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 int *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 = 1172499100UL, 228 .coef_m = 2000096UL, 229 .coef_div = 4201, 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