1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Voltage regulators coupler for NVIDIA Tegra20
4 * Copyright (C) 2019 GRATE-DRIVER project
5 *
6 * Voltage constraints borrowed from downstream kernel sources
7 * Copyright (C) 2010-2011 NVIDIA Corporation
8 */
9
10 #define pr_fmt(fmt) "tegra voltage-coupler: " fmt
11
12 #include <linux/init.h>
13 #include <linux/kernel.h>
14 #include <linux/of.h>
15 #include <linux/reboot.h>
16 #include <linux/regulator/coupler.h>
17 #include <linux/regulator/driver.h>
18 #include <linux/regulator/machine.h>
19
20 #include <soc/tegra/pmc.h>
21
22 struct tegra_regulator_coupler {
23 struct regulator_coupler coupler;
24 struct regulator_dev *core_rdev;
25 struct regulator_dev *cpu_rdev;
26 struct regulator_dev *rtc_rdev;
27 struct notifier_block reboot_notifier;
28 int core_min_uV, cpu_min_uV;
29 bool sys_reboot_mode_req;
30 bool sys_reboot_mode;
31 };
32
33 static inline struct tegra_regulator_coupler *
to_tegra_coupler(struct regulator_coupler * coupler)34 to_tegra_coupler(struct regulator_coupler *coupler)
35 {
36 return container_of(coupler, struct tegra_regulator_coupler, coupler);
37 }
38
tegra20_core_limit(struct tegra_regulator_coupler * tegra,struct regulator_dev * core_rdev)39 static int tegra20_core_limit(struct tegra_regulator_coupler *tegra,
40 struct regulator_dev *core_rdev)
41 {
42 int core_min_uV = 0;
43 int core_max_uV;
44 int core_cur_uV;
45 int err;
46
47 /*
48 * Tegra20 SoC has critical DVFS-capable devices that are
49 * permanently-active or active at a boot time, like EMC
50 * (DRAM controller) or Display controller for example.
51 *
52 * The voltage of a CORE SoC power domain shall not be dropped below
53 * a minimum level, which is determined by device's clock rate.
54 * This means that we can't fully allow CORE voltage scaling until
55 * the state of all DVFS-critical CORE devices is synced.
56 */
57 if (tegra_pmc_core_domain_state_synced() && !tegra->sys_reboot_mode) {
58 pr_info_once("voltage state synced\n");
59 return 0;
60 }
61
62 if (tegra->core_min_uV > 0)
63 return tegra->core_min_uV;
64
65 core_cur_uV = regulator_get_voltage_rdev(core_rdev);
66 if (core_cur_uV < 0)
67 return core_cur_uV;
68
69 core_max_uV = max(core_cur_uV, 1200000);
70
71 err = regulator_check_voltage(core_rdev, &core_min_uV, &core_max_uV);
72 if (err)
73 return err;
74
75 /*
76 * Limit minimum CORE voltage to a value left from bootloader or,
77 * if it's unreasonably low value, to the most common 1.2v or to
78 * whatever maximum value defined via board's device-tree.
79 */
80 tegra->core_min_uV = core_max_uV;
81
82 pr_info("core voltage initialized to %duV\n", tegra->core_min_uV);
83
84 return tegra->core_min_uV;
85 }
86
tegra20_core_rtc_max_spread(struct regulator_dev * core_rdev,struct regulator_dev * rtc_rdev)87 static int tegra20_core_rtc_max_spread(struct regulator_dev *core_rdev,
88 struct regulator_dev *rtc_rdev)
89 {
90 struct coupling_desc *c_desc = &core_rdev->coupling_desc;
91 struct regulator_dev *rdev;
92 int max_spread;
93 unsigned int i;
94
95 for (i = 1; i < c_desc->n_coupled; i++) {
96 max_spread = core_rdev->constraints->max_spread[i - 1];
97 rdev = c_desc->coupled_rdevs[i];
98
99 if (rdev == rtc_rdev && max_spread)
100 return max_spread;
101 }
102
103 pr_err_once("rtc-core max-spread is undefined in device-tree\n");
104
105 return 150000;
106 }
107
tegra20_core_rtc_update(struct tegra_regulator_coupler * tegra,struct regulator_dev * core_rdev,struct regulator_dev * rtc_rdev,int cpu_uV,int cpu_min_uV)108 static int tegra20_core_rtc_update(struct tegra_regulator_coupler *tegra,
109 struct regulator_dev *core_rdev,
110 struct regulator_dev *rtc_rdev,
111 int cpu_uV, int cpu_min_uV)
112 {
113 int core_min_uV, core_max_uV = INT_MAX;
114 int rtc_min_uV, rtc_max_uV = INT_MAX;
115 int core_target_uV;
116 int rtc_target_uV;
117 int max_spread;
118 int core_uV;
119 int rtc_uV;
120 int err;
121
122 /*
123 * RTC and CORE voltages should be no more than 170mV from each other,
124 * CPU should be below RTC and CORE by at least 120mV. This applies
125 * to all Tegra20 SoC's.
126 */
127 max_spread = tegra20_core_rtc_max_spread(core_rdev, rtc_rdev);
128
129 /*
130 * The core voltage scaling is currently not hooked up in drivers,
131 * hence we will limit the minimum core voltage to a reasonable value.
132 * This should be good enough for the time being.
133 */
134 core_min_uV = tegra20_core_limit(tegra, core_rdev);
135 if (core_min_uV < 0)
136 return core_min_uV;
137
138 err = regulator_check_voltage(core_rdev, &core_min_uV, &core_max_uV);
139 if (err)
140 return err;
141
142 err = regulator_check_consumers(core_rdev, &core_min_uV, &core_max_uV,
143 PM_SUSPEND_ON);
144 if (err)
145 return err;
146
147 core_uV = regulator_get_voltage_rdev(core_rdev);
148 if (core_uV < 0)
149 return core_uV;
150
151 core_min_uV = max(cpu_min_uV + 125000, core_min_uV);
152 if (core_min_uV > core_max_uV)
153 return -EINVAL;
154
155 if (cpu_uV + 120000 > core_uV)
156 pr_err("core-cpu voltage constraint violated: %d %d\n",
157 core_uV, cpu_uV + 120000);
158
159 rtc_uV = regulator_get_voltage_rdev(rtc_rdev);
160 if (rtc_uV < 0)
161 return rtc_uV;
162
163 if (cpu_uV + 120000 > rtc_uV)
164 pr_err("rtc-cpu voltage constraint violated: %d %d\n",
165 rtc_uV, cpu_uV + 120000);
166
167 if (abs(core_uV - rtc_uV) > 170000)
168 pr_err("core-rtc voltage constraint violated: %d %d\n",
169 core_uV, rtc_uV);
170
171 rtc_min_uV = max(cpu_min_uV + 125000, core_min_uV - max_spread);
172
173 err = regulator_check_voltage(rtc_rdev, &rtc_min_uV, &rtc_max_uV);
174 if (err)
175 return err;
176
177 while (core_uV != core_min_uV || rtc_uV != rtc_min_uV) {
178 if (core_uV < core_min_uV) {
179 core_target_uV = min(core_uV + max_spread, core_min_uV);
180 core_target_uV = min(rtc_uV + max_spread, core_target_uV);
181 } else {
182 core_target_uV = max(core_uV - max_spread, core_min_uV);
183 core_target_uV = max(rtc_uV - max_spread, core_target_uV);
184 }
185
186 if (core_uV == core_target_uV)
187 goto update_rtc;
188
189 err = regulator_set_voltage_rdev(core_rdev,
190 core_target_uV,
191 core_max_uV,
192 PM_SUSPEND_ON);
193 if (err)
194 return err;
195
196 core_uV = core_target_uV;
197 update_rtc:
198 if (rtc_uV < rtc_min_uV) {
199 rtc_target_uV = min(rtc_uV + max_spread, rtc_min_uV);
200 rtc_target_uV = min(core_uV + max_spread, rtc_target_uV);
201 } else {
202 rtc_target_uV = max(rtc_uV - max_spread, rtc_min_uV);
203 rtc_target_uV = max(core_uV - max_spread, rtc_target_uV);
204 }
205
206 if (rtc_uV == rtc_target_uV)
207 continue;
208
209 err = regulator_set_voltage_rdev(rtc_rdev,
210 rtc_target_uV,
211 rtc_max_uV,
212 PM_SUSPEND_ON);
213 if (err)
214 return err;
215
216 rtc_uV = rtc_target_uV;
217 }
218
219 return 0;
220 }
221
tegra20_core_voltage_update(struct tegra_regulator_coupler * tegra,struct regulator_dev * cpu_rdev,struct regulator_dev * core_rdev,struct regulator_dev * rtc_rdev)222 static int tegra20_core_voltage_update(struct tegra_regulator_coupler *tegra,
223 struct regulator_dev *cpu_rdev,
224 struct regulator_dev *core_rdev,
225 struct regulator_dev *rtc_rdev)
226 {
227 int cpu_uV;
228
229 cpu_uV = regulator_get_voltage_rdev(cpu_rdev);
230 if (cpu_uV < 0)
231 return cpu_uV;
232
233 return tegra20_core_rtc_update(tegra, core_rdev, rtc_rdev,
234 cpu_uV, cpu_uV);
235 }
236
tegra20_cpu_voltage_update(struct tegra_regulator_coupler * tegra,struct regulator_dev * cpu_rdev,struct regulator_dev * core_rdev,struct regulator_dev * rtc_rdev)237 static int tegra20_cpu_voltage_update(struct tegra_regulator_coupler *tegra,
238 struct regulator_dev *cpu_rdev,
239 struct regulator_dev *core_rdev,
240 struct regulator_dev *rtc_rdev)
241 {
242 int cpu_min_uV_consumers = 0;
243 int cpu_max_uV = INT_MAX;
244 int cpu_min_uV = 0;
245 int cpu_uV;
246 int err;
247
248 err = regulator_check_voltage(cpu_rdev, &cpu_min_uV, &cpu_max_uV);
249 if (err)
250 return err;
251
252 err = regulator_check_consumers(cpu_rdev, &cpu_min_uV, &cpu_max_uV,
253 PM_SUSPEND_ON);
254 if (err)
255 return err;
256
257 err = regulator_check_consumers(cpu_rdev, &cpu_min_uV_consumers,
258 &cpu_max_uV, PM_SUSPEND_ON);
259 if (err)
260 return err;
261
262 cpu_uV = regulator_get_voltage_rdev(cpu_rdev);
263 if (cpu_uV < 0)
264 return cpu_uV;
265
266 /* store boot voltage level */
267 if (!tegra->cpu_min_uV)
268 tegra->cpu_min_uV = cpu_uV;
269
270 /*
271 * CPU's regulator may not have any consumers, hence the voltage
272 * must not be changed in that case because CPU simply won't
273 * survive the voltage drop if it's running on a higher frequency.
274 */
275 if (!cpu_min_uV_consumers)
276 cpu_min_uV = cpu_uV;
277
278 /* restore boot voltage level */
279 if (tegra->sys_reboot_mode)
280 cpu_min_uV = max(cpu_min_uV, tegra->cpu_min_uV);
281
282 if (cpu_min_uV > cpu_uV) {
283 err = tegra20_core_rtc_update(tegra, core_rdev, rtc_rdev,
284 cpu_uV, cpu_min_uV);
285 if (err)
286 return err;
287
288 err = regulator_set_voltage_rdev(cpu_rdev, cpu_min_uV,
289 cpu_max_uV, PM_SUSPEND_ON);
290 if (err)
291 return err;
292 } else if (cpu_min_uV < cpu_uV) {
293 err = regulator_set_voltage_rdev(cpu_rdev, cpu_min_uV,
294 cpu_max_uV, PM_SUSPEND_ON);
295 if (err)
296 return err;
297
298 err = tegra20_core_rtc_update(tegra, core_rdev, rtc_rdev,
299 cpu_uV, cpu_min_uV);
300 if (err)
301 return err;
302 }
303
304 return 0;
305 }
306
tegra20_regulator_balance_voltage(struct regulator_coupler * coupler,struct regulator_dev * rdev,suspend_state_t state)307 static int tegra20_regulator_balance_voltage(struct regulator_coupler *coupler,
308 struct regulator_dev *rdev,
309 suspend_state_t state)
310 {
311 struct tegra_regulator_coupler *tegra = to_tegra_coupler(coupler);
312 struct regulator_dev *core_rdev = tegra->core_rdev;
313 struct regulator_dev *cpu_rdev = tegra->cpu_rdev;
314 struct regulator_dev *rtc_rdev = tegra->rtc_rdev;
315
316 if ((core_rdev != rdev && cpu_rdev != rdev && rtc_rdev != rdev) ||
317 state != PM_SUSPEND_ON) {
318 pr_err("regulators are not coupled properly\n");
319 return -EINVAL;
320 }
321
322 tegra->sys_reboot_mode = READ_ONCE(tegra->sys_reboot_mode_req);
323
324 if (rdev == cpu_rdev)
325 return tegra20_cpu_voltage_update(tegra, cpu_rdev,
326 core_rdev, rtc_rdev);
327
328 if (rdev == core_rdev)
329 return tegra20_core_voltage_update(tegra, cpu_rdev,
330 core_rdev, rtc_rdev);
331
332 pr_err("changing %s voltage not permitted\n", rdev_get_name(rtc_rdev));
333
334 return -EPERM;
335 }
336
tegra20_regulator_prepare_reboot(struct tegra_regulator_coupler * tegra,bool sys_reboot_mode)337 static int tegra20_regulator_prepare_reboot(struct tegra_regulator_coupler *tegra,
338 bool sys_reboot_mode)
339 {
340 int err;
341
342 if (!tegra->core_rdev || !tegra->rtc_rdev || !tegra->cpu_rdev)
343 return 0;
344
345 WRITE_ONCE(tegra->sys_reboot_mode_req, true);
346
347 /*
348 * Some devices use CPU soft-reboot method and in this case we
349 * should ensure that voltages are sane for the reboot by restoring
350 * the minimum boot levels.
351 */
352 err = regulator_sync_voltage_rdev(tegra->cpu_rdev);
353 if (err)
354 return err;
355
356 err = regulator_sync_voltage_rdev(tegra->core_rdev);
357 if (err)
358 return err;
359
360 WRITE_ONCE(tegra->sys_reboot_mode_req, sys_reboot_mode);
361
362 return 0;
363 }
364
tegra20_regulator_reboot(struct notifier_block * notifier,unsigned long event,void * cmd)365 static int tegra20_regulator_reboot(struct notifier_block *notifier,
366 unsigned long event, void *cmd)
367 {
368 struct tegra_regulator_coupler *tegra;
369 int ret;
370
371 if (event != SYS_RESTART)
372 return NOTIFY_DONE;
373
374 tegra = container_of(notifier, struct tegra_regulator_coupler,
375 reboot_notifier);
376
377 ret = tegra20_regulator_prepare_reboot(tegra, true);
378
379 return notifier_from_errno(ret);
380 }
381
tegra20_regulator_attach(struct regulator_coupler * coupler,struct regulator_dev * rdev)382 static int tegra20_regulator_attach(struct regulator_coupler *coupler,
383 struct regulator_dev *rdev)
384 {
385 struct tegra_regulator_coupler *tegra = to_tegra_coupler(coupler);
386 struct device_node *np = rdev->dev.of_node;
387
388 if (of_property_read_bool(np, "nvidia,tegra-core-regulator") &&
389 !tegra->core_rdev) {
390 tegra->core_rdev = rdev;
391 return 0;
392 }
393
394 if (of_property_read_bool(np, "nvidia,tegra-rtc-regulator") &&
395 !tegra->rtc_rdev) {
396 tegra->rtc_rdev = rdev;
397 return 0;
398 }
399
400 if (of_property_read_bool(np, "nvidia,tegra-cpu-regulator") &&
401 !tegra->cpu_rdev) {
402 tegra->cpu_rdev = rdev;
403 return 0;
404 }
405
406 return -EINVAL;
407 }
408
tegra20_regulator_detach(struct regulator_coupler * coupler,struct regulator_dev * rdev)409 static int tegra20_regulator_detach(struct regulator_coupler *coupler,
410 struct regulator_dev *rdev)
411 {
412 struct tegra_regulator_coupler *tegra = to_tegra_coupler(coupler);
413
414 /*
415 * We don't expect regulators to be decoupled during reboot,
416 * this may race with the reboot handler and shouldn't ever
417 * happen in practice.
418 */
419 if (WARN_ON_ONCE(system_state > SYSTEM_RUNNING))
420 return -EPERM;
421
422 if (tegra->core_rdev == rdev) {
423 tegra->core_rdev = NULL;
424 return 0;
425 }
426
427 if (tegra->rtc_rdev == rdev) {
428 tegra->rtc_rdev = NULL;
429 return 0;
430 }
431
432 if (tegra->cpu_rdev == rdev) {
433 tegra->cpu_rdev = NULL;
434 return 0;
435 }
436
437 return -EINVAL;
438 }
439
440 static struct tegra_regulator_coupler tegra20_coupler = {
441 .coupler = {
442 .attach_regulator = tegra20_regulator_attach,
443 .detach_regulator = tegra20_regulator_detach,
444 .balance_voltage = tegra20_regulator_balance_voltage,
445 },
446 .reboot_notifier.notifier_call = tegra20_regulator_reboot,
447 };
448
tegra_regulator_coupler_init(void)449 static int __init tegra_regulator_coupler_init(void)
450 {
451 int err;
452
453 if (!of_machine_is_compatible("nvidia,tegra20"))
454 return 0;
455
456 err = register_reboot_notifier(&tegra20_coupler.reboot_notifier);
457 WARN_ON(err);
458
459 return regulator_coupler_register(&tegra20_coupler.coupler);
460 }
461 arch_initcall(tegra_regulator_coupler_init);
462