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