1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2018 Emmanuel Vadot <manu@FreeBSD.org>
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28 #include <sys/cdefs.h>
29 #include <sys/param.h>
30 #include <sys/bus.h>
31 #include <sys/clock.h>
32 #include <sys/eventhandler.h>
33 #include <sys/kernel.h>
34 #include <sys/module.h>
35 #include <sys/reboot.h>
36 #include <sys/mutex.h>
37 #include <sys/rman.h>
38 #include <machine/bus.h>
39
40 #include <dev/iicbus/iiconf.h>
41 #include <dev/iicbus/iicbus.h>
42
43 #include <dev/ofw/ofw_bus.h>
44 #include <dev/ofw/ofw_bus_subr.h>
45
46 #include <dev/extres/regulator/regulator.h>
47
48 #include <arm64/rockchip/rk805reg.h>
49
50 #include "clock_if.h"
51 #include "regdev_if.h"
52
53 MALLOC_DEFINE(M_RK805_REG, "RK805 regulator", "RK805 power regulator");
54
55 /* #define dprintf(sc, format, arg...) device_printf(sc->base_dev, "%s: " format, __func__, arg) */
56 #define dprintf(sc, format, arg...)
57
58 enum rk_pmic_type {
59 RK805 = 1,
60 RK808,
61 };
62
63 static struct ofw_compat_data compat_data[] = {
64 {"rockchip,rk805", RK805},
65 {"rockchip,rk808", RK808},
66 {NULL, 0}
67 };
68
69 struct rk805_regdef {
70 intptr_t id;
71 char *name;
72 uint8_t enable_reg;
73 uint8_t enable_mask;
74 uint8_t voltage_reg;
75 uint8_t voltage_mask;
76 int voltage_min;
77 int voltage_max;
78 int voltage_step;
79 int voltage_nstep;
80 };
81
82 struct rk805_reg_sc {
83 struct regnode *regnode;
84 device_t base_dev;
85 struct rk805_regdef *def;
86 phandle_t xref;
87 struct regnode_std_param *param;
88 };
89
90 struct reg_list {
91 TAILQ_ENTRY(reg_list) next;
92 struct rk805_reg_sc *reg;
93 };
94
95 struct rk805_softc {
96 device_t dev;
97 struct mtx mtx;
98 struct resource * res[1];
99 void * intrcookie;
100 struct intr_config_hook intr_hook;
101 enum rk_pmic_type type;
102
103 TAILQ_HEAD(, reg_list) regs;
104 int nregs;
105 };
106
107 static int rk805_regnode_status(struct regnode *regnode, int *status);
108 static int rk805_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
109 int max_uvolt, int *udelay);
110 static int rk805_regnode_get_voltage(struct regnode *regnode, int *uvolt);
111
112 static struct rk805_regdef rk805_regdefs[] = {
113 {
114 .id = RK805_DCDC1,
115 .name = "DCDC_REG1",
116 .enable_reg = RK805_DCDC_EN,
117 .enable_mask = 0x11,
118 .voltage_reg = RK805_DCDC1_ON_VSEL,
119 .voltage_mask = 0x3F,
120 .voltage_min = 712500,
121 .voltage_max = 1450000,
122 .voltage_step = 12500,
123 .voltage_nstep = 64,
124 },
125 {
126 .id = RK805_DCDC2,
127 .name = "DCDC_REG2",
128 .enable_reg = RK805_DCDC_EN,
129 .enable_mask = 0x22,
130 .voltage_reg = RK805_DCDC2_ON_VSEL,
131 .voltage_mask = 0x3F,
132 .voltage_min = 712500,
133 .voltage_max = 1450000,
134 .voltage_step = 12500,
135 .voltage_nstep = 64,
136 },
137 {
138 .id = RK805_DCDC3,
139 .name = "DCDC_REG3",
140 .enable_reg = RK805_DCDC_EN,
141 .enable_mask = 0x44,
142 },
143 {
144 .id = RK805_DCDC4,
145 .name = "DCDC_REG4",
146 .enable_reg = RK805_DCDC_EN,
147 .enable_mask = 0x88,
148 .voltage_reg = RK805_DCDC4_ON_VSEL,
149 .voltage_mask = 0x3F,
150 .voltage_min = 800000,
151 .voltage_max = 3500000,
152 .voltage_step = 100000,
153 .voltage_nstep = 28,
154 },
155 {
156 .id = RK805_LDO1,
157 .name = "LDO_REG1",
158 .enable_reg = RK805_LDO_EN,
159 .enable_mask = 0x11,
160 .voltage_reg = RK805_LDO1_ON_VSEL,
161 .voltage_mask = 0x1F,
162 .voltage_min = 800000,
163 .voltage_max = 3400000,
164 .voltage_step = 100000,
165 .voltage_nstep = 27,
166 },
167 {
168 .id = RK805_LDO2,
169 .name = "LDO_REG2",
170 .enable_reg = RK805_LDO_EN,
171 .enable_mask = 0x22,
172 .voltage_reg = RK805_LDO2_ON_VSEL,
173 .voltage_mask = 0x1F,
174 .voltage_min = 800000,
175 .voltage_max = 3400000,
176 .voltage_step = 100000,
177 .voltage_nstep = 27,
178 },
179 {
180 .id = RK805_LDO3,
181 .name = "LDO_REG3",
182 .enable_reg = RK805_LDO_EN,
183 .enable_mask = 0x44,
184 .voltage_reg = RK805_LDO3_ON_VSEL,
185 .voltage_mask = 0x1F,
186 .voltage_min = 800000,
187 .voltage_max = 3400000,
188 .voltage_step = 100000,
189 .voltage_nstep = 27,
190 },
191 };
192
193 static struct rk805_regdef rk808_regdefs[] = {
194 {
195 .id = RK805_DCDC1,
196 .name = "DCDC_REG1",
197 .enable_reg = RK805_DCDC_EN,
198 .enable_mask = 0x1,
199 .voltage_reg = RK805_DCDC1_ON_VSEL,
200 .voltage_mask = 0x3F,
201 .voltage_min = 712500,
202 .voltage_max = 1500000,
203 .voltage_step = 12500,
204 .voltage_nstep = 64,
205 },
206 {
207 .id = RK805_DCDC2,
208 .name = "DCDC_REG2",
209 .enable_reg = RK805_DCDC_EN,
210 .enable_mask = 0x2,
211 .voltage_reg = RK805_DCDC2_ON_VSEL,
212 .voltage_mask = 0x3F,
213 .voltage_min = 712500,
214 .voltage_max = 1500000,
215 .voltage_step = 12500,
216 .voltage_nstep = 64,
217 },
218 {
219 /* BUCK3 voltage is calculated based on external resistor */
220 .id = RK805_DCDC3,
221 .name = "DCDC_REG3",
222 .enable_reg = RK805_DCDC_EN,
223 .enable_mask = 0x4,
224 },
225 {
226 .id = RK805_DCDC4,
227 .name = "DCDC_REG4",
228 .enable_reg = RK805_DCDC_EN,
229 .enable_mask = 0x8,
230 .voltage_reg = RK805_DCDC4_ON_VSEL,
231 .voltage_mask = 0xF,
232 .voltage_min = 1800000,
233 .voltage_max = 3300000,
234 .voltage_step = 100000,
235 .voltage_nstep = 16,
236 },
237 {
238 .id = RK808_LDO1,
239 .name = "LDO_REG1",
240 .enable_reg = RK808_LDO_EN,
241 .enable_mask = 0x1,
242 .voltage_reg = RK805_LDO1_ON_VSEL,
243 .voltage_mask = 0x1F,
244 .voltage_min = 1800000,
245 .voltage_max = 3400000,
246 .voltage_step = 100000,
247 .voltage_nstep = 17,
248 },
249 {
250 .id = RK808_LDO2,
251 .name = "LDO_REG2",
252 .enable_reg = RK808_LDO_EN,
253 .enable_mask = 0x2,
254 .voltage_reg = RK805_LDO2_ON_VSEL,
255 .voltage_mask = 0x1F,
256 .voltage_min = 1800000,
257 .voltage_max = 3400000,
258 .voltage_step = 100000,
259 .voltage_nstep = 17,
260 },
261 {
262 .id = RK808_LDO3,
263 .name = "LDO_REG3",
264 .enable_reg = RK808_LDO_EN,
265 .enable_mask = 0x4,
266 .voltage_reg = RK805_LDO3_ON_VSEL,
267 .voltage_mask = 0xF,
268 .voltage_min = 800000,
269 .voltage_max = 2500000,
270 .voltage_step = 100000,
271 .voltage_nstep = 18,
272 },
273 {
274 .id = RK808_LDO4,
275 .name = "LDO_REG4",
276 .enable_reg = RK808_LDO_EN,
277 .enable_mask = 0x8,
278 .voltage_reg = RK808_LDO4_ON_VSEL,
279 .voltage_mask = 0x1F,
280 .voltage_min = 1800000,
281 .voltage_max = 3400000,
282 .voltage_step = 100000,
283 .voltage_nstep = 17,
284 },
285 {
286 .id = RK808_LDO5,
287 .name = "LDO_REG5",
288 .enable_reg = RK808_LDO_EN,
289 .enable_mask = 0x10,
290 .voltage_reg = RK808_LDO5_ON_VSEL,
291 .voltage_mask = 0x1F,
292 .voltage_min = 1800000,
293 .voltage_max = 3400000,
294 .voltage_step = 100000,
295 .voltage_nstep = 17,
296 },
297 {
298 .id = RK808_LDO6,
299 .name = "LDO_REG6",
300 .enable_reg = RK808_LDO_EN,
301 .enable_mask = 0x20,
302 .voltage_reg = RK808_LDO6_ON_VSEL,
303 .voltage_mask = 0x1F,
304 .voltage_min = 800000,
305 .voltage_max = 2500000,
306 .voltage_step = 100000,
307 .voltage_nstep = 18,
308 },
309 {
310 .id = RK808_LDO7,
311 .name = "LDO_REG7",
312 .enable_reg = RK808_LDO_EN,
313 .enable_mask = 0x40,
314 .voltage_reg = RK808_LDO7_ON_VSEL,
315 .voltage_mask = 0x1F,
316 .voltage_min = 800000,
317 .voltage_max = 2500000,
318 .voltage_step = 100000,
319 .voltage_nstep = 18,
320 },
321 {
322 .id = RK808_LDO8,
323 .name = "LDO_REG8",
324 .enable_reg = RK808_LDO_EN,
325 .enable_mask = 0x80,
326 .voltage_reg = RK808_LDO8_ON_VSEL,
327 .voltage_mask = 0x1F,
328 .voltage_min = 1800000,
329 .voltage_max = 3400000,
330 .voltage_step = 100000,
331 .voltage_nstep = 17,
332 },
333 {
334 .id = RK808_SWITCH1,
335 .name = "SWITCH_REG1",
336 .enable_reg = RK805_DCDC_EN,
337 .enable_mask = 0x20,
338 .voltage_min = 3000000,
339 .voltage_max = 3000000,
340 },
341 {
342 .id = RK808_SWITCH2,
343 .name = "SWITCH_REG2",
344 .enable_reg = RK805_DCDC_EN,
345 .enable_mask = 0x40,
346 .voltage_min = 3000000,
347 .voltage_max = 3000000,
348 },
349 };
350
351 static int
rk805_read(device_t dev,uint8_t reg,uint8_t * data,uint8_t size)352 rk805_read(device_t dev, uint8_t reg, uint8_t *data, uint8_t size)
353 {
354 int err;
355
356 err = iicdev_readfrom(dev, reg, data, size, IIC_INTRWAIT);
357 return (err);
358 }
359
360 static int
rk805_write(device_t dev,uint8_t reg,uint8_t * data,uint8_t size)361 rk805_write(device_t dev, uint8_t reg, uint8_t *data, uint8_t size)
362 {
363
364 return (iicdev_writeto(dev, reg, data, size, IIC_INTRWAIT));
365 }
366
367 static int
rk805_regnode_init(struct regnode * regnode)368 rk805_regnode_init(struct regnode *regnode)
369 {
370 struct rk805_reg_sc *sc;
371 struct regnode_std_param *param;
372 int rv, udelay, uvolt, status;
373
374 sc = regnode_get_softc(regnode);
375 dprintf(sc, "Regulator %s init called\n", sc->def->name);
376 param = regnode_get_stdparam(regnode);
377 if (param->min_uvolt == 0)
378 return (0);
379
380 /* Check that the regulator is preset to the correct voltage */
381 rv = rk805_regnode_get_voltage(regnode, &uvolt);
382 if (rv != 0)
383 return(rv);
384
385 if (uvolt >= param->min_uvolt && uvolt <= param->max_uvolt)
386 return(0);
387 /*
388 * Set the regulator at the correct voltage if it is not enabled.
389 * Do not enable it, this is will be done either by a
390 * consumer or by regnode_set_constraint if boot_on is true
391 */
392 rv = rk805_regnode_status(regnode, &status);
393 if (rv != 0 || status == REGULATOR_STATUS_ENABLED)
394 return (rv);
395
396 rv = rk805_regnode_set_voltage(regnode, param->min_uvolt,
397 param->max_uvolt, &udelay);
398 if (udelay != 0)
399 DELAY(udelay);
400
401 return (rv);
402 }
403
404 static int
rk805_regnode_enable(struct regnode * regnode,bool enable,int * udelay)405 rk805_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
406 {
407 struct rk805_reg_sc *sc;
408 uint8_t val;
409
410 sc = regnode_get_softc(regnode);
411
412 dprintf(sc, "%sabling regulator %s\n",
413 enable ? "En" : "Dis",
414 sc->def->name);
415 rk805_read(sc->base_dev, sc->def->enable_reg, &val, 1);
416 if (enable)
417 val |= sc->def->enable_mask;
418 else
419 val &= ~sc->def->enable_mask;
420 rk805_write(sc->base_dev, sc->def->enable_reg, &val, 1);
421
422 *udelay = 0;
423
424 return (0);
425 }
426
427 static void
rk805_regnode_reg_to_voltage(struct rk805_reg_sc * sc,uint8_t val,int * uv)428 rk805_regnode_reg_to_voltage(struct rk805_reg_sc *sc, uint8_t val, int *uv)
429 {
430 if (val < sc->def->voltage_nstep)
431 *uv = sc->def->voltage_min + val * sc->def->voltage_step;
432 else
433 *uv = sc->def->voltage_min +
434 (sc->def->voltage_nstep * sc->def->voltage_step);
435 }
436
437 static int
rk805_regnode_voltage_to_reg(struct rk805_reg_sc * sc,int min_uvolt,int max_uvolt,uint8_t * val)438 rk805_regnode_voltage_to_reg(struct rk805_reg_sc *sc, int min_uvolt,
439 int max_uvolt, uint8_t *val)
440 {
441 uint8_t nval;
442 int nstep, uvolt;
443
444 nval = 0;
445 uvolt = sc->def->voltage_min;
446
447 for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
448 nstep++) {
449 ++nval;
450 uvolt += sc->def->voltage_step;
451 }
452 if (uvolt > max_uvolt)
453 return (EINVAL);
454
455 *val = nval;
456 return (0);
457 }
458
459 static int
rk805_regnode_status(struct regnode * regnode,int * status)460 rk805_regnode_status(struct regnode *regnode, int *status)
461 {
462 struct rk805_reg_sc *sc;
463 uint8_t val;
464
465 sc = regnode_get_softc(regnode);
466
467 *status = 0;
468 rk805_read(sc->base_dev, sc->def->enable_reg, &val, 1);
469 if (val & sc->def->enable_mask)
470 *status = REGULATOR_STATUS_ENABLED;
471
472 return (0);
473 }
474
475 static int
rk805_regnode_set_voltage(struct regnode * regnode,int min_uvolt,int max_uvolt,int * udelay)476 rk805_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
477 int max_uvolt, int *udelay)
478 {
479 struct rk805_reg_sc *sc;
480 uint8_t val;
481 int uvolt;
482
483 sc = regnode_get_softc(regnode);
484
485 if (!sc->def->voltage_step)
486 return (ENXIO);
487
488 dprintf(sc, "Setting %s to %d<->%d uvolts\n",
489 sc->def->name,
490 min_uvolt,
491 max_uvolt);
492 rk805_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
493 if (rk805_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0)
494 return (ERANGE);
495
496 rk805_write(sc->base_dev, sc->def->voltage_reg, &val, 1);
497
498 rk805_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
499
500 *udelay = 0;
501
502 rk805_regnode_reg_to_voltage(sc, val, &uvolt);
503 dprintf(sc, "Regulator %s set to %d uvolt\n",
504 sc->def->name,
505 uvolt);
506
507 return (0);
508 }
509
510 static int
rk805_regnode_get_voltage(struct regnode * regnode,int * uvolt)511 rk805_regnode_get_voltage(struct regnode *regnode, int *uvolt)
512 {
513 struct rk805_reg_sc *sc;
514 uint8_t val;
515
516 sc = regnode_get_softc(regnode);
517
518 if (sc->def->voltage_min == sc->def->voltage_max) {
519 *uvolt = sc->def->voltage_min;
520 return (0);
521 }
522
523 if (!sc->def->voltage_step)
524 return (ENXIO);
525
526 rk805_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
527 rk805_regnode_reg_to_voltage(sc, val & sc->def->voltage_mask, uvolt);
528
529 dprintf(sc, "Regulator %s is at %d uvolt\n",
530 sc->def->name,
531 *uvolt);
532
533 return (0);
534 }
535
536 static regnode_method_t rk805_regnode_methods[] = {
537 /* Regulator interface */
538 REGNODEMETHOD(regnode_init, rk805_regnode_init),
539 REGNODEMETHOD(regnode_enable, rk805_regnode_enable),
540 REGNODEMETHOD(regnode_status, rk805_regnode_status),
541 REGNODEMETHOD(regnode_set_voltage, rk805_regnode_set_voltage),
542 REGNODEMETHOD(regnode_get_voltage, rk805_regnode_get_voltage),
543 REGNODEMETHOD(regnode_check_voltage, regnode_method_check_voltage),
544 REGNODEMETHOD_END
545 };
546 DEFINE_CLASS_1(rk805_regnode, rk805_regnode_class, rk805_regnode_methods,
547 sizeof(struct rk805_reg_sc), regnode_class);
548
549 static struct rk805_reg_sc *
rk805_reg_attach(device_t dev,phandle_t node,struct rk805_regdef * def)550 rk805_reg_attach(device_t dev, phandle_t node,
551 struct rk805_regdef *def)
552 {
553 struct rk805_reg_sc *reg_sc;
554 struct regnode_init_def initdef;
555 struct regnode *regnode;
556
557 memset(&initdef, 0, sizeof(initdef));
558 if (regulator_parse_ofw_stdparam(dev, node, &initdef) != 0) {
559 device_printf(dev, "cannot create regulator\n");
560 return (NULL);
561 }
562 if (initdef.std_param.min_uvolt == 0)
563 initdef.std_param.min_uvolt = def->voltage_min;
564 if (initdef.std_param.max_uvolt == 0)
565 initdef.std_param.max_uvolt = def->voltage_max;
566 initdef.id = def->id;
567 initdef.ofw_node = node;
568
569 regnode = regnode_create(dev, &rk805_regnode_class, &initdef);
570 if (regnode == NULL) {
571 device_printf(dev, "cannot create regulator\n");
572 return (NULL);
573 }
574
575 reg_sc = regnode_get_softc(regnode);
576 reg_sc->regnode = regnode;
577 reg_sc->base_dev = dev;
578 reg_sc->def = def;
579 reg_sc->xref = OF_xref_from_node(node);
580 reg_sc->param = regnode_get_stdparam(regnode);
581
582 regnode_register(regnode);
583
584 return (reg_sc);
585 }
586
587 static int
rk805_probe(device_t dev)588 rk805_probe(device_t dev)
589 {
590 if (!ofw_bus_status_okay(dev))
591 return (ENXIO);
592
593 if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
594 return (ENXIO);
595
596 device_set_desc(dev, "RockChip RK805 PMIC");
597 return (BUS_PROBE_DEFAULT);
598 }
599
600 static void
rk805_start(void * pdev)601 rk805_start(void *pdev)
602 {
603 struct rk805_softc *sc;
604 device_t dev;
605 uint8_t data[2];
606 int err;
607
608 dev = pdev;
609 sc = device_get_softc(dev);
610 sc->dev = dev;
611
612 /* No version register in RK808 */
613 if (bootverbose && sc->type == RK805) {
614 err = rk805_read(dev, RK805_CHIP_NAME, data, 1);
615 if (err != 0) {
616 device_printf(dev, "Cannot read chip name reg\n");
617 return;
618 }
619 err = rk805_read(dev, RK805_CHIP_VER, data + 1, 1);
620 if (err != 0) {
621 device_printf(dev, "Cannot read chip version reg\n");
622 return;
623 }
624 device_printf(dev, "Chip Name: %x\n",
625 data[0] << 4 | ((data[1] >> 4) & 0xf));
626 device_printf(dev, "Chip Version: %x\n", data[1] & 0xf);
627 }
628
629 /* Register this as a 1Hz clock */
630 clock_register(dev, 1000000);
631
632 config_intrhook_disestablish(&sc->intr_hook);
633 }
634
635 static int
rk805_gettime(device_t dev,struct timespec * ts)636 rk805_gettime(device_t dev, struct timespec *ts)
637 {
638 struct bcd_clocktime bct;
639 uint8_t data[7];
640 uint8_t ctrl;
641 int error;
642
643 /* Latch the RTC value into the shadow registers and set 24hr mode */
644 error = rk805_read(dev, RK805_RTC_CTRL, &ctrl, 1);
645 if (error != 0)
646 return (error);
647
648 ctrl |= RK805_RTC_READSEL;
649 ctrl &= ~(RK805_RTC_AMPM_MODE | RK805_RTC_GET_TIME);
650 error = rk805_write(dev, RK805_RTC_CTRL, &ctrl, 1);
651 if (error != 0)
652 return (error);
653 ctrl |= RK805_RTC_GET_TIME;
654 error = rk805_write(dev, RK805_RTC_CTRL, &ctrl, 1);
655 if (error != 0)
656 return (error);
657 ctrl &= ~RK805_RTC_GET_TIME;
658 error = rk805_write(dev, RK805_RTC_CTRL, &ctrl, 1);
659 if (error != 0)
660 return (error);
661
662 /* This works as long as RK805_RTC_SECS = 0 */
663 error = rk805_read(dev, RK805_RTC_SECS, data, 7);
664 if (error != 0)
665 return (error);
666
667 /*
668 * If the reported year is earlier than 2019, assume the clock is unset.
669 * This is both later than the reset value for the RK805 and RK808 as
670 * well as being prior to the current time.
671 */
672 if (data[RK805_RTC_YEARS] < 0x19)
673 return (EINVAL);
674
675 memset(&bct, 0, sizeof(bct));
676 bct.year = data[RK805_RTC_YEARS];
677 bct.mon = data[RK805_RTC_MONTHS] & RK805_RTC_MONTHS_MASK;
678 bct.day = data[RK805_RTC_DAYS] & RK805_RTC_DAYS_MASK;
679 bct.hour = data[RK805_RTC_HOURS] & RK805_RTC_HOURS_MASK;
680 bct.min = data[RK805_RTC_MINUTES] & RK805_RTC_MINUTES_MASK;
681 bct.sec = data[RK805_RTC_SECS] & RK805_RTC_SECS_MASK;
682 bct.dow = data[RK805_RTC_WEEKS] & RK805_RTC_WEEKS_MASK;
683 /* The day of week is reported as 1-7 with 1 = Monday */
684 if (bct.dow == 7)
685 bct.dow = 0;
686 bct.ispm = 0;
687
688 if (bootverbose)
689 device_printf(dev, "Read RTC: %02x-%02x-%02x %02x:%02x:%02x\n",
690 bct.year, bct.mon, bct.day, bct.hour, bct.min, bct.sec);
691
692 return (clock_bcd_to_ts(&bct, ts, false));
693 }
694
695 static int
rk805_settime(device_t dev,struct timespec * ts)696 rk805_settime(device_t dev, struct timespec *ts)
697 {
698 struct bcd_clocktime bct;
699 uint8_t data[7];
700 int error;
701 uint8_t ctrl;
702
703 clock_ts_to_bcd(ts, &bct, false);
704
705 /* This works as long as RK805_RTC_SECS = 0 */
706 data[RK805_RTC_YEARS] = bct.year;
707 data[RK805_RTC_MONTHS] = bct.mon;
708 data[RK805_RTC_DAYS] = bct.day;
709 data[RK805_RTC_HOURS] = bct.hour;
710 data[RK805_RTC_MINUTES] = bct.min;
711 data[RK805_RTC_SECS] = bct.sec;
712 data[RK805_RTC_WEEKS] = bct.dow;
713 /* The day of week is reported as 1-7 with 1 = Monday */
714 if (data[RK805_RTC_WEEKS] == 0)
715 data[RK805_RTC_WEEKS] = 7;
716
717 error = rk805_read(dev, RK805_RTC_CTRL, &ctrl, 1);
718 if (error != 0)
719 return (error);
720
721 ctrl |= RK805_RTC_CTRL_STOP;
722 ctrl &= ~RK805_RTC_AMPM_MODE;
723 error = rk805_write(dev, RK805_RTC_CTRL, &ctrl, 1);
724 if (error != 0)
725 return (error);
726
727 error = rk805_write(dev, RK805_RTC_SECS, data, 7);
728 ctrl &= ~RK805_RTC_CTRL_STOP;
729 rk805_write(dev, RK805_RTC_CTRL, &ctrl, 1);
730
731 if (bootverbose)
732 device_printf(dev,
733 "Set RTC at %04x-%02x-%02x %02x:%02x:%02x[.%09ld]\n",
734 bct.year, bct.mon, bct.day, bct.hour, bct.min, bct.sec,
735 bct.nsec);
736
737 return (error);
738 }
739
740 static void
rk805_poweroff(void * arg,int howto)741 rk805_poweroff(void *arg, int howto)
742 {
743 device_t dev = arg;
744 int error;
745 uint8_t val;
746
747 if ((howto & RB_POWEROFF) == 0)
748 return;
749
750 device_printf(dev, "Powering off...\n");
751 error = rk805_read(dev, RK805_DEV_CTRL, &val, 1);
752 if (error == 0) {
753 val |= RK805_DEV_CTRL_OFF;
754 error = rk805_write(dev, RK805_DEV_CTRL, &val, 1);
755
756 /* Wait a bit for the command to take effect. */
757 if (error == 0)
758 DELAY(100);
759 }
760 device_printf(dev, "Power off failed\n");
761 }
762
763 static int
rk805_attach(device_t dev)764 rk805_attach(device_t dev)
765 {
766 struct rk805_softc *sc;
767 struct rk805_reg_sc *reg;
768 struct rk805_regdef *regdefs;
769 struct reg_list *regp;
770 phandle_t rnode, child;
771 int i;
772
773 sc = device_get_softc(dev);
774
775 sc->intr_hook.ich_func = rk805_start;
776 sc->intr_hook.ich_arg = dev;
777
778 if (config_intrhook_establish(&sc->intr_hook) != 0)
779 return (ENOMEM);
780
781 sc->type = ofw_bus_search_compatible(dev, compat_data)->ocd_data;
782 switch (sc->type) {
783 case RK805:
784 regdefs = rk805_regdefs;
785 sc->nregs = nitems(rk805_regdefs);
786 break;
787 case RK808:
788 regdefs = rk808_regdefs;
789 sc->nregs = nitems(rk808_regdefs);
790 break;
791 default:
792 device_printf(dev, "Unknown type %d\n", sc->type);
793 return (ENXIO);
794 }
795
796 TAILQ_INIT(&sc->regs);
797
798 rnode = ofw_bus_find_child(ofw_bus_get_node(dev), "regulators");
799 if (rnode > 0) {
800 for (i = 0; i < sc->nregs; i++) {
801 child = ofw_bus_find_child(rnode,
802 regdefs[i].name);
803 if (child == 0)
804 continue;
805 if (OF_hasprop(child, "regulator-name") != 1)
806 continue;
807 reg = rk805_reg_attach(dev, child, ®defs[i]);
808 if (reg == NULL) {
809 device_printf(dev,
810 "cannot attach regulator %s\n",
811 regdefs[i].name);
812 continue;
813 }
814 regp = malloc(sizeof(*regp), M_DEVBUF, M_WAITOK | M_ZERO);
815 regp->reg = reg;
816 TAILQ_INSERT_TAIL(&sc->regs, regp, next);
817 if (bootverbose)
818 device_printf(dev, "Regulator %s attached\n",
819 regdefs[i].name);
820 }
821 }
822
823 if (OF_hasprop(ofw_bus_get_node(dev),
824 "rockchip,system-power-controller")) {
825 /*
826 * The priority is chosen to override PSCI and EFI shutdown
827 * methods as those two just hang without powering off on Rock64
828 * at least.
829 */
830 EVENTHANDLER_REGISTER(shutdown_final, rk805_poweroff, dev,
831 SHUTDOWN_PRI_LAST - 2);
832 }
833
834 return (0);
835 }
836
837 static int
rk805_detach(device_t dev)838 rk805_detach(device_t dev)
839 {
840
841 /* We cannot detach regulators */
842 return (EBUSY);
843 }
844
845 static int
rk805_map(device_t dev,phandle_t xref,int ncells,pcell_t * cells,intptr_t * id)846 rk805_map(device_t dev, phandle_t xref, int ncells,
847 pcell_t *cells, intptr_t *id)
848 {
849 struct rk805_softc *sc;
850 struct reg_list *regp;
851
852 sc = device_get_softc(dev);
853
854 TAILQ_FOREACH(regp, &sc->regs, next) {
855 if (regp->reg->xref == xref) {
856 *id = regp->reg->def->id;
857 return (0);
858 }
859 }
860
861 return (ERANGE);
862 }
863
864 static device_method_t rk805_methods[] = {
865 DEVMETHOD(device_probe, rk805_probe),
866 DEVMETHOD(device_attach, rk805_attach),
867 DEVMETHOD(device_detach, rk805_detach),
868
869 /* regdev interface */
870 DEVMETHOD(regdev_map, rk805_map),
871
872 /* Clock interface */
873 DEVMETHOD(clock_gettime, rk805_gettime),
874 DEVMETHOD(clock_settime, rk805_settime),
875
876 DEVMETHOD_END
877 };
878
879 static driver_t rk805_driver = {
880 "rk805_pmu",
881 rk805_methods,
882 sizeof(struct rk805_softc),
883 };
884
885 static devclass_t rk805_devclass;
886
887 EARLY_DRIVER_MODULE(rk805, iicbus, rk805_driver, rk805_devclass, 0, 0,
888 BUS_PASS_INTERRUPT + BUS_PASS_ORDER_LAST);
889 MODULE_DEPEND(rk805, iicbus, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER);
890 MODULE_VERSION(rk805, 1);
891