1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * db8500_thermal.c - DB8500 Thermal Management Implementation 4 * 5 * Copyright (C) 2012 ST-Ericsson 6 * Copyright (C) 2012-2019 Linaro Ltd. 7 * 8 * Authors: Hongbo Zhang, Linus Walleij 9 */ 10 11 #include <linux/cpu_cooling.h> 12 #include <linux/interrupt.h> 13 #include <linux/mfd/dbx500-prcmu.h> 14 #include <linux/module.h> 15 #include <linux/of.h> 16 #include <linux/platform_device.h> 17 #include <linux/slab.h> 18 #include <linux/thermal.h> 19 20 #define PRCMU_DEFAULT_MEASURE_TIME 0xFFF 21 #define PRCMU_DEFAULT_LOW_TEMP 0 22 23 /** 24 * db8500_thermal_points - the interpolation points that trigger 25 * interrupts 26 */ 27 static const unsigned long db8500_thermal_points[] = { 28 15000, 29 20000, 30 25000, 31 30000, 32 35000, 33 40000, 34 45000, 35 50000, 36 55000, 37 60000, 38 65000, 39 70000, 40 75000, 41 80000, 42 /* 43 * This is where things start to get really bad for the 44 * SoC and the thermal zones should be set up to trigger 45 * critical temperature at 85000 mC so we don't get above 46 * this point. 47 */ 48 85000, 49 90000, 50 95000, 51 100000, 52 }; 53 54 struct db8500_thermal_zone { 55 struct thermal_zone_device *tz; 56 enum thermal_trend trend; 57 unsigned long interpolated_temp; 58 unsigned int cur_index; 59 }; 60 61 /* Callback to get current temperature */ 62 static int db8500_thermal_get_temp(void *data, int *temp) 63 { 64 struct db8500_thermal_zone *th = data; 65 66 /* 67 * TODO: There is no PRCMU interface to get temperature data currently, 68 * so a pseudo temperature is returned , it works for thermal framework 69 * and this will be fixed when the PRCMU interface is available. 70 */ 71 *temp = th->interpolated_temp; 72 73 return 0; 74 } 75 76 /* Callback to get temperature changing trend */ 77 static int db8500_thermal_get_trend(void *data, int trip, enum thermal_trend *trend) 78 { 79 struct db8500_thermal_zone *th = data; 80 81 *trend = th->trend; 82 83 return 0; 84 } 85 86 static struct thermal_zone_of_device_ops thdev_ops = { 87 .get_temp = db8500_thermal_get_temp, 88 .get_trend = db8500_thermal_get_trend, 89 }; 90 91 static void db8500_thermal_update_config(struct db8500_thermal_zone *th, 92 unsigned int idx, 93 enum thermal_trend trend, 94 unsigned long next_low, 95 unsigned long next_high) 96 { 97 prcmu_stop_temp_sense(); 98 99 th->cur_index = idx; 100 th->interpolated_temp = (next_low + next_high)/2; 101 th->trend = trend; 102 103 /* 104 * The PRCMU accept absolute temperatures in celsius so divide 105 * down the millicelsius with 1000 106 */ 107 prcmu_config_hotmon((u8)(next_low/1000), (u8)(next_high/1000)); 108 prcmu_start_temp_sense(PRCMU_DEFAULT_MEASURE_TIME); 109 } 110 111 static irqreturn_t prcmu_low_irq_handler(int irq, void *irq_data) 112 { 113 struct db8500_thermal_zone *th = irq_data; 114 unsigned int idx = th->cur_index; 115 unsigned long next_low, next_high; 116 117 if (idx == 0) 118 /* Meaningless for thermal management, ignoring it */ 119 return IRQ_HANDLED; 120 121 if (idx == 1) { 122 next_high = db8500_thermal_points[0]; 123 next_low = PRCMU_DEFAULT_LOW_TEMP; 124 } else { 125 next_high = db8500_thermal_points[idx - 1]; 126 next_low = db8500_thermal_points[idx - 2]; 127 } 128 idx -= 1; 129 130 db8500_thermal_update_config(th, idx, THERMAL_TREND_DROPPING, 131 next_low, next_high); 132 dev_dbg(&th->tz->device, 133 "PRCMU set max %ld, min %ld\n", next_high, next_low); 134 135 thermal_zone_device_update(th->tz, THERMAL_EVENT_UNSPECIFIED); 136 137 return IRQ_HANDLED; 138 } 139 140 static irqreturn_t prcmu_high_irq_handler(int irq, void *irq_data) 141 { 142 struct db8500_thermal_zone *th = irq_data; 143 unsigned int idx = th->cur_index; 144 unsigned long next_low, next_high; 145 int num_points = ARRAY_SIZE(db8500_thermal_points); 146 147 if (idx < num_points - 1) { 148 next_high = db8500_thermal_points[idx+1]; 149 next_low = db8500_thermal_points[idx]; 150 idx += 1; 151 152 db8500_thermal_update_config(th, idx, THERMAL_TREND_RAISING, 153 next_low, next_high); 154 155 dev_info(&th->tz->device, 156 "PRCMU set max %ld, min %ld\n", next_high, next_low); 157 } else if (idx == num_points - 1) 158 /* So we roof out 1 degree over the max point */ 159 th->interpolated_temp = db8500_thermal_points[idx] + 1; 160 161 thermal_zone_device_update(th->tz, THERMAL_EVENT_UNSPECIFIED); 162 163 return IRQ_HANDLED; 164 } 165 166 static int db8500_thermal_probe(struct platform_device *pdev) 167 { 168 struct db8500_thermal_zone *th = NULL; 169 struct device *dev = &pdev->dev; 170 int low_irq, high_irq, ret = 0; 171 172 th = devm_kzalloc(dev, sizeof(*th), GFP_KERNEL); 173 if (!th) 174 return -ENOMEM; 175 176 low_irq = platform_get_irq_byname(pdev, "IRQ_HOTMON_LOW"); 177 if (low_irq < 0) { 178 dev_err(dev, "Get IRQ_HOTMON_LOW failed\n"); 179 return low_irq; 180 } 181 182 ret = devm_request_threaded_irq(dev, low_irq, NULL, 183 prcmu_low_irq_handler, IRQF_NO_SUSPEND | IRQF_ONESHOT, 184 "dbx500_temp_low", th); 185 if (ret < 0) { 186 dev_err(dev, "failed to allocate temp low irq\n"); 187 return ret; 188 } 189 190 high_irq = platform_get_irq_byname(pdev, "IRQ_HOTMON_HIGH"); 191 if (high_irq < 0) { 192 dev_err(dev, "Get IRQ_HOTMON_HIGH failed\n"); 193 return high_irq; 194 } 195 196 ret = devm_request_threaded_irq(dev, high_irq, NULL, 197 prcmu_high_irq_handler, IRQF_NO_SUSPEND | IRQF_ONESHOT, 198 "dbx500_temp_high", th); 199 if (ret < 0) { 200 dev_err(dev, "failed to allocate temp high irq\n"); 201 return ret; 202 } 203 204 /* register of thermal sensor and get info from DT */ 205 th->tz = devm_thermal_zone_of_sensor_register(dev, 0, th, &thdev_ops); 206 if (IS_ERR(th->tz)) { 207 dev_err(dev, "register thermal zone sensor failed\n"); 208 return PTR_ERR(th->tz); 209 } 210 dev_info(dev, "thermal zone sensor registered\n"); 211 212 /* Start measuring at the lowest point */ 213 db8500_thermal_update_config(th, 0, THERMAL_TREND_STABLE, 214 PRCMU_DEFAULT_LOW_TEMP, 215 db8500_thermal_points[0]); 216 217 platform_set_drvdata(pdev, th); 218 219 return 0; 220 } 221 222 static int db8500_thermal_suspend(struct platform_device *pdev, 223 pm_message_t state) 224 { 225 prcmu_stop_temp_sense(); 226 227 return 0; 228 } 229 230 static int db8500_thermal_resume(struct platform_device *pdev) 231 { 232 struct db8500_thermal_zone *th = platform_get_drvdata(pdev); 233 234 /* Resume and start measuring at the lowest point */ 235 db8500_thermal_update_config(th, 0, THERMAL_TREND_STABLE, 236 PRCMU_DEFAULT_LOW_TEMP, 237 db8500_thermal_points[0]); 238 239 return 0; 240 } 241 242 static const struct of_device_id db8500_thermal_match[] = { 243 { .compatible = "stericsson,db8500-thermal" }, 244 {}, 245 }; 246 MODULE_DEVICE_TABLE(of, db8500_thermal_match); 247 248 static struct platform_driver db8500_thermal_driver = { 249 .driver = { 250 .name = "db8500-thermal", 251 .of_match_table = of_match_ptr(db8500_thermal_match), 252 }, 253 .probe = db8500_thermal_probe, 254 .suspend = db8500_thermal_suspend, 255 .resume = db8500_thermal_resume, 256 }; 257 258 module_platform_driver(db8500_thermal_driver); 259 260 MODULE_AUTHOR("Hongbo Zhang <hongbo.zhang@stericsson.com>"); 261 MODULE_DESCRIPTION("DB8500 thermal driver"); 262 MODULE_LICENSE("GPL"); 263