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 static 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, int *temperature) 115 { 116 struct st_thermal_sensor *sensor = th->devdata; 117 struct device *dev = sensor->dev; 118 unsigned int temp; 119 unsigned int overflow; 120 int ret; 121 122 ret = regmap_field_read(sensor->overflow, &overflow); 123 if (ret) 124 return ret; 125 if (overflow) 126 return -EIO; 127 128 ret = regmap_field_read(sensor->temp_data, &temp); 129 if (ret) 130 return ret; 131 132 temp += sensor->cdata->temp_adjust_val; 133 temp = mcelsius(temp); 134 135 dev_dbg(dev, "temperature: %d\n", temp); 136 137 *temperature = temp; 138 139 return 0; 140 } 141 142 static int st_thermal_get_trip_type(struct thermal_zone_device *th, 143 int trip, enum thermal_trip_type *type) 144 { 145 struct st_thermal_sensor *sensor = th->devdata; 146 struct device *dev = sensor->dev; 147 148 switch (trip) { 149 case 0: 150 *type = THERMAL_TRIP_CRITICAL; 151 break; 152 default: 153 dev_err(dev, "invalid trip point\n"); 154 return -EINVAL; 155 } 156 157 return 0; 158 } 159 160 static int st_thermal_get_trip_temp(struct thermal_zone_device *th, 161 int trip, int *temp) 162 { 163 struct st_thermal_sensor *sensor = th->devdata; 164 struct device *dev = sensor->dev; 165 166 switch (trip) { 167 case 0: 168 *temp = mcelsius(sensor->cdata->crit_temp); 169 break; 170 default: 171 dev_err(dev, "Invalid trip point\n"); 172 return -EINVAL; 173 } 174 175 return 0; 176 } 177 178 static struct thermal_zone_device_ops st_tz_ops = { 179 .get_temp = st_thermal_get_temp, 180 .get_trip_type = st_thermal_get_trip_type, 181 .get_trip_temp = st_thermal_get_trip_temp, 182 }; 183 184 int st_thermal_register(struct platform_device *pdev, 185 const struct of_device_id *st_thermal_of_match) 186 { 187 struct st_thermal_sensor *sensor; 188 struct device *dev = &pdev->dev; 189 struct device_node *np = dev->of_node; 190 const struct of_device_id *match; 191 192 int polling_delay; 193 int ret; 194 195 if (!np) { 196 dev_err(dev, "device tree node not found\n"); 197 return -EINVAL; 198 } 199 200 sensor = devm_kzalloc(dev, sizeof(*sensor), GFP_KERNEL); 201 if (!sensor) 202 return -ENOMEM; 203 204 sensor->dev = dev; 205 206 match = of_match_device(st_thermal_of_match, dev); 207 if (!(match && match->data)) 208 return -EINVAL; 209 210 sensor->cdata = match->data; 211 if (!sensor->cdata->ops) 212 return -EINVAL; 213 214 sensor->ops = sensor->cdata->ops; 215 216 ret = (sensor->ops->regmap_init)(sensor); 217 if (ret) 218 return ret; 219 220 ret = st_thermal_alloc_regfields(sensor); 221 if (ret) 222 return ret; 223 224 sensor->clk = devm_clk_get(dev, "thermal"); 225 if (IS_ERR(sensor->clk)) { 226 dev_err(dev, "failed to fetch clock\n"); 227 return PTR_ERR(sensor->clk); 228 } 229 230 if (sensor->ops->register_enable_irq) { 231 ret = sensor->ops->register_enable_irq(sensor); 232 if (ret) 233 return ret; 234 } 235 236 ret = st_thermal_sensor_on(sensor); 237 if (ret) 238 return ret; 239 240 ret = st_thermal_calibration(sensor); 241 if (ret) 242 goto sensor_off; 243 244 polling_delay = sensor->ops->register_enable_irq ? 0 : 1000; 245 246 sensor->thermal_dev = 247 thermal_zone_device_register(dev_name(dev), 1, 0, sensor, 248 &st_tz_ops, NULL, 0, polling_delay); 249 if (IS_ERR(sensor->thermal_dev)) { 250 dev_err(dev, "failed to register thermal zone device\n"); 251 ret = PTR_ERR(sensor->thermal_dev); 252 goto sensor_off; 253 } 254 255 platform_set_drvdata(pdev, sensor); 256 257 return 0; 258 259 sensor_off: 260 st_thermal_sensor_off(sensor); 261 262 return ret; 263 } 264 EXPORT_SYMBOL_GPL(st_thermal_register); 265 266 int st_thermal_unregister(struct platform_device *pdev) 267 { 268 struct st_thermal_sensor *sensor = platform_get_drvdata(pdev); 269 270 st_thermal_sensor_off(sensor); 271 thermal_zone_device_unregister(sensor->thermal_dev); 272 273 return 0; 274 } 275 EXPORT_SYMBOL_GPL(st_thermal_unregister); 276 277 #ifdef CONFIG_PM_SLEEP 278 static int st_thermal_suspend(struct device *dev) 279 { 280 struct platform_device *pdev = to_platform_device(dev); 281 struct st_thermal_sensor *sensor = platform_get_drvdata(pdev); 282 283 return st_thermal_sensor_off(sensor); 284 } 285 286 static int st_thermal_resume(struct device *dev) 287 { 288 int ret; 289 struct platform_device *pdev = to_platform_device(dev); 290 struct st_thermal_sensor *sensor = platform_get_drvdata(pdev); 291 292 ret = st_thermal_sensor_on(sensor); 293 if (ret) 294 return ret; 295 296 ret = st_thermal_calibration(sensor); 297 if (ret) 298 return ret; 299 300 if (sensor->ops->enable_irq) { 301 ret = sensor->ops->enable_irq(sensor); 302 if (ret) 303 return ret; 304 } 305 306 return 0; 307 } 308 #endif 309 310 SIMPLE_DEV_PM_OPS(st_thermal_pm_ops, st_thermal_suspend, st_thermal_resume); 311 EXPORT_SYMBOL_GPL(st_thermal_pm_ops); 312 313 MODULE_AUTHOR("STMicroelectronics (R&D) Limited <ajitpal.singh@st.com>"); 314 MODULE_DESCRIPTION("STMicroelectronics STi SoC Thermal Sensor Driver"); 315 MODULE_LICENSE("GPL v2"); 316