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 */
db8500_thermal_get_temp(void * data,int * temp)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 */
db8500_thermal_get_trend(void * data,int trip,enum thermal_trend * 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
db8500_thermal_update_config(struct db8500_thermal_zone * th,unsigned int idx,enum thermal_trend trend,unsigned long next_low,unsigned long next_high)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
prcmu_low_irq_handler(int irq,void * irq_data)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
prcmu_high_irq_handler(int irq,void * irq_data)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
db8500_thermal_probe(struct platform_device * pdev)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
db8500_thermal_suspend(struct platform_device * pdev,pm_message_t state)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
db8500_thermal_resume(struct platform_device * pdev)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