axp20x.c revision 1.13 1 1.13 thorpej /* $NetBSD: axp20x.c,v 1.13 2018/06/26 06:03:57 thorpej Exp $ */
2 1.1 jmcneill
3 1.1 jmcneill /*-
4 1.6 jmcneill * Copyright (c) 2014-2017 Jared McNeill <jmcneill (at) invisible.ca>
5 1.1 jmcneill * All rights reserved.
6 1.1 jmcneill *
7 1.1 jmcneill * Redistribution and use in source and binary forms, with or without
8 1.1 jmcneill * modification, are permitted provided that the following conditions
9 1.1 jmcneill * are met:
10 1.1 jmcneill * 1. Redistributions of source code must retain the above copyright
11 1.1 jmcneill * notice, this list of conditions and the following disclaimer.
12 1.1 jmcneill * 2. Redistributions in binary form must reproduce the above copyright
13 1.1 jmcneill * notice, this list of conditions and the following disclaimer in the
14 1.1 jmcneill * documentation and/or other materials provided with the distribution.
15 1.1 jmcneill *
16 1.1 jmcneill * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17 1.1 jmcneill * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 1.1 jmcneill * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 1.1 jmcneill * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20 1.1 jmcneill * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 1.1 jmcneill * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 1.1 jmcneill * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 1.1 jmcneill * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 1.1 jmcneill * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 1.1 jmcneill * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 1.1 jmcneill * POSSIBILITY OF SUCH DAMAGE.
27 1.1 jmcneill */
28 1.1 jmcneill
29 1.6 jmcneill #include "opt_fdt.h"
30 1.6 jmcneill
31 1.1 jmcneill #include <sys/cdefs.h>
32 1.13 thorpej __KERNEL_RCSID(0, "$NetBSD: axp20x.c,v 1.13 2018/06/26 06:03:57 thorpej Exp $");
33 1.1 jmcneill
34 1.1 jmcneill #include <sys/param.h>
35 1.1 jmcneill #include <sys/systm.h>
36 1.1 jmcneill #include <sys/device.h>
37 1.1 jmcneill #include <sys/conf.h>
38 1.1 jmcneill #include <sys/bus.h>
39 1.1 jmcneill #include <sys/kmem.h>
40 1.1 jmcneill
41 1.1 jmcneill #include <dev/i2c/i2cvar.h>
42 1.3 bouyer #include <dev/i2c/axp20xvar.h>
43 1.1 jmcneill
44 1.1 jmcneill #include <dev/sysmon/sysmonvar.h>
45 1.1 jmcneill
46 1.7 jmcneill #ifdef FDT
47 1.7 jmcneill #include <dev/fdt/fdtvar.h>
48 1.7 jmcneill #endif
49 1.7 jmcneill
50 1.11 thorpej #define AXP209_I2C_ADDR 0x34
51 1.11 thorpej
52 1.3 bouyer #define AXP_INPUT_STATUS 0x00
53 1.3 bouyer #define AXP_INPUT_STATUS_AC_PRESENT __BIT(7)
54 1.3 bouyer #define AXP_INPUT_STATUS_AC_OK __BIT(6)
55 1.3 bouyer #define AXP_INPUT_STATUS_VBUS_PRESENT __BIT(5)
56 1.3 bouyer #define AXP_INPUT_STATUS_VBUS_OK __BIT(4)
57 1.3 bouyer
58 1.3 bouyer #define AXP_POWER_MODE 0x01
59 1.3 bouyer #define AXP_POWER_MODE_OVERTEMP __BIT(7)
60 1.3 bouyer #define AXP_POWER_MODE_CHARGING __BIT(6)
61 1.3 bouyer #define AXP_POWER_MODE_BATTOK __BIT(5)
62 1.3 bouyer
63 1.3 bouyer #define AXP_POWEROUT_CTRL 0x12
64 1.3 bouyer #define AXP_POWEROUT_CTRL_LDO3 __BIT(6)
65 1.3 bouyer #define AXP_POWEROUT_CTRL_DCDC2 __BIT(4)
66 1.3 bouyer #define AXP_POWEROUT_CTRL_LDO4 __BIT(3)
67 1.3 bouyer #define AXP_POWEROUT_CTRL_LDO2 __BIT(2)
68 1.3 bouyer #define AXP_POWEROUT_CTRL_DCDC3 __BIT(1)
69 1.3 bouyer #define AXP_POWEROUT_CTRL_EXTEN __BIT(0)
70 1.3 bouyer
71 1.3 bouyer #define AXP_DCDC2 0x23
72 1.3 bouyer #define AXP_DCDC2_VOLT_MASK __BITS(0,5)
73 1.3 bouyer #define AXP_DCDC2_VOLT_SHIFT 0
74 1.3 bouyer
75 1.3 bouyer #define AXP_DCDC2_LDO3_VRC 0x25
76 1.3 bouyer
77 1.3 bouyer #define AXP_DCDC3 0x27
78 1.3 bouyer #define AXP_DCDC3_VOLT_MASK __BITS(0,6)
79 1.3 bouyer #define AXP_DCDC3_VOLT_SHIFT 0
80 1.3 bouyer
81 1.3 bouyer #define AXP_LDO2_4 0x28
82 1.3 bouyer #define AXP_LDO2_VOLT_MASK __BITS(4,7)
83 1.3 bouyer #define AXP_LDO2_VOLT_SHIFT 4
84 1.3 bouyer #define AXP_LDO4_VOLT_MASK __BITS(0,3)
85 1.3 bouyer #define AXP_LDO4_VOLT_SHIFT 0
86 1.3 bouyer static int ldo4_mvV[] = {
87 1.3 bouyer 1250,
88 1.3 bouyer 1300,
89 1.3 bouyer 1400,
90 1.3 bouyer 1500,
91 1.3 bouyer 1600,
92 1.3 bouyer 1700,
93 1.3 bouyer 1800,
94 1.3 bouyer 1900,
95 1.3 bouyer 2000,
96 1.3 bouyer 2500,
97 1.3 bouyer 2700,
98 1.3 bouyer 2800,
99 1.3 bouyer 3000,
100 1.3 bouyer 3100,
101 1.3 bouyer 3200,
102 1.3 bouyer 3300
103 1.3 bouyer };
104 1.3 bouyer
105 1.3 bouyer #define AXP_LDO3 0x29
106 1.3 bouyer #define AXP_LDO3_TRACK __BIT(7)
107 1.3 bouyer #define AXP_LDO3_VOLT_MASK __BITS(0,6)
108 1.3 bouyer #define AXP_LDO3_VOLT_SHIFT 0
109 1.3 bouyer
110 1.7 jmcneill #define AXP_SHUTDOWN 0x32
111 1.7 jmcneill #define AXP_SHUTDOWN_CTRL __BIT(7)
112 1.7 jmcneill
113 1.5 tnn #define AXP_BKUP_CTRL 0x35
114 1.5 tnn #define AXP_BKUP_CTRL_ENABLE __BIT(7)
115 1.5 tnn #define AXP_BKUP_CTRL_VOLT_MASK __BITS(5,6)
116 1.5 tnn #define AXP_BKUP_CTRL_VOLT_SHIFT 5
117 1.5 tnn #define AXP_BKUP_CTRL_VOLT_3V1 0
118 1.5 tnn #define AXP_BKUP_CTRL_VOLT_3V0 1
119 1.5 tnn #define AXP_BKUP_CTRL_VOLT_3V6 2
120 1.5 tnn #define AXP_BKUP_CTRL_VOLT_2V5 3
121 1.5 tnn static int bkup_volt[] = {
122 1.5 tnn 3100,
123 1.5 tnn 3000,
124 1.5 tnn 3600,
125 1.5 tnn 2500
126 1.5 tnn };
127 1.5 tnn #define AXP_BKUP_CTRL_CURR_MASK __BITS(0,1)
128 1.5 tnn #define AXP_BKUP_CTRL_CURR_SHIFT 0
129 1.5 tnn #define AXP_BKUP_CTRL_CURR_50U 0
130 1.5 tnn #define AXP_BKUP_CTRL_CURR_100U 1
131 1.5 tnn #define AXP_BKUP_CTRL_CURR_200U 2
132 1.5 tnn #define AXP_BKUP_CTRL_CURR_400U 3
133 1.5 tnn static int bkup_curr[] = {
134 1.5 tnn 50,
135 1.5 tnn 100,
136 1.5 tnn 200,
137 1.5 tnn 400
138 1.5 tnn };
139 1.5 tnn
140 1.3 bouyer #define AXP_ACV_MON_REG 0x56 /* 2 bytes */
141 1.3 bouyer #define AXP_ACI_MON_REG 0x58 /* 2 bytes */
142 1.3 bouyer #define AXP_VBUSV_MON_REG 0x5a /* 2 bytes */
143 1.3 bouyer #define AXP_VBUSI_MON_REG 0x5c /* 2 bytes */
144 1.1 jmcneill #define AXP_TEMP_MON_REG 0x5e /* 2 bytes */
145 1.3 bouyer #define AXP_BATTV_MON_REG 0x78 /* 2 bytes */
146 1.3 bouyer #define AXP_BATTCI_MON_REG 0x7a /* 2 bytes */
147 1.3 bouyer #define AXP_BATTDI_MON_REG 0x7c /* 2 bytes */
148 1.3 bouyer #define AXP_APSV_MON_REG 0x7e /* 2 bytes */
149 1.3 bouyer
150 1.3 bouyer #define AXP_ADC_EN1 0x82
151 1.3 bouyer #define AXP_ADC_EN1_BATTV __BIT(7)
152 1.3 bouyer #define AXP_ADC_EN1_BATTI __BIT(6)
153 1.3 bouyer #define AXP_ADC_EN1_ACV __BIT(5)
154 1.3 bouyer #define AXP_ADC_EN1_ACI __BIT(4)
155 1.3 bouyer #define AXP_ADC_EN1_VBUSV __BIT(3)
156 1.3 bouyer #define AXP_ADC_EN1_VBUSI __BIT(2)
157 1.3 bouyer #define AXP_ADC_EN1_APSV __BIT(1)
158 1.3 bouyer #define AXP_ADC_EN1_TS __BIT(0)
159 1.3 bouyer #define AXP_ADC_EN2 0x83
160 1.3 bouyer #define AXP_ADC_EN2_TEMP __BIT(7)
161 1.3 bouyer
162 1.3 bouyer #define AXP_SENSOR_ACOK 0
163 1.3 bouyer #define AXP_SENSOR_ACV 1
164 1.3 bouyer #define AXP_SENSOR_ACI 2
165 1.3 bouyer #define AXP_SENSOR_VBUSOK 3
166 1.3 bouyer #define AXP_SENSOR_VBUSV 4
167 1.3 bouyer #define AXP_SENSOR_VBUSI 5
168 1.3 bouyer #define AXP_SENSOR_BATTOK 6
169 1.3 bouyer #define AXP_SENSOR_BATTV 7
170 1.3 bouyer #define AXP_SENSOR_BATTI 8
171 1.3 bouyer #define AXP_SENSOR_APSV 9
172 1.3 bouyer #define AXP_SENSOR_TEMP 10
173 1.3 bouyer #define AXP_NSENSORS (AXP_SENSOR_TEMP + 1)
174 1.3 bouyer
175 1.3 bouyer /* define per-ADC LSB to uV/uA values */
176 1.3 bouyer static int axp20x_sensors_lsb[] = {
177 1.3 bouyer 0, /* AXP_SENSOR_ACOK */
178 1.3 bouyer 1700, /* AXP_SENSOR_ACV */
179 1.3 bouyer 625, /* AXP_SENSOR_ACI */
180 1.3 bouyer 0,
181 1.3 bouyer 1700, /* AXP_SENSOR_VBUSV */
182 1.3 bouyer 375, /* AXP_SENSOR_VBUSI */
183 1.3 bouyer 0,
184 1.3 bouyer 1100, /* AXP_SENSOR_BATTV */
185 1.3 bouyer 500, /* AXP_SENSOR_BATTI */
186 1.3 bouyer 1400, /* AXP_SENSOR_APSV */
187 1.3 bouyer };
188 1.3 bouyer
189 1.1 jmcneill
190 1.1 jmcneill struct axp20x_softc {
191 1.1 jmcneill device_t sc_dev;
192 1.1 jmcneill i2c_tag_t sc_i2c;
193 1.1 jmcneill i2c_addr_t sc_addr;
194 1.6 jmcneill int sc_phandle;
195 1.1 jmcneill
196 1.3 bouyer uint8_t sc_inputstatus;
197 1.3 bouyer uint8_t sc_powermode;
198 1.3 bouyer
199 1.1 jmcneill struct sysmon_envsys *sc_sme;
200 1.3 bouyer envsys_data_t sc_sensor[AXP_NSENSORS];
201 1.1 jmcneill };
202 1.1 jmcneill
203 1.1 jmcneill static int axp20x_match(device_t, cfdata_t, void *);
204 1.1 jmcneill static void axp20x_attach(device_t, device_t, void *);
205 1.1 jmcneill
206 1.1 jmcneill static void axp20x_sensors_refresh(struct sysmon_envsys *, envsys_data_t *);
207 1.3 bouyer static int axp20x_read(struct axp20x_softc *, uint8_t, uint8_t *, size_t, int);
208 1.3 bouyer static int axp20x_write(struct axp20x_softc *, uint8_t, uint8_t *, size_t, int);
209 1.1 jmcneill
210 1.7 jmcneill #ifdef FDT
211 1.7 jmcneill static void axp20x_fdt_attach(struct axp20x_softc *);
212 1.7 jmcneill #endif
213 1.7 jmcneill
214 1.1 jmcneill CFATTACH_DECL_NEW(axp20x, sizeof(struct axp20x_softc),
215 1.1 jmcneill axp20x_match, axp20x_attach, NULL, NULL);
216 1.1 jmcneill
217 1.13 thorpej static const struct device_compatible_entry compat_data[] = {
218 1.13 thorpej { "x-powers,axp209", 0 },
219 1.13 thorpej { NULL, 0 }
220 1.12 thorpej };
221 1.12 thorpej
222 1.1 jmcneill static int
223 1.1 jmcneill axp20x_match(device_t parent, cfdata_t match, void *aux)
224 1.1 jmcneill {
225 1.6 jmcneill struct i2c_attach_args * const ia = aux;
226 1.11 thorpej int match_result;
227 1.11 thorpej
228 1.13 thorpej if (iic_use_direct_match(ia, match, compat_data, &match_result))
229 1.11 thorpej return match_result;
230 1.6 jmcneill
231 1.11 thorpej /* This device is direct-config only. */
232 1.6 jmcneill
233 1.11 thorpej return 0;
234 1.1 jmcneill }
235 1.1 jmcneill
236 1.1 jmcneill static void
237 1.1 jmcneill axp20x_attach(device_t parent, device_t self, void *aux)
238 1.1 jmcneill {
239 1.1 jmcneill struct axp20x_softc *sc = device_private(self);
240 1.1 jmcneill struct i2c_attach_args *ia = aux;
241 1.3 bouyer int first;
242 1.3 bouyer int error;
243 1.3 bouyer uint8_t value;
244 1.1 jmcneill
245 1.1 jmcneill sc->sc_dev = self;
246 1.1 jmcneill sc->sc_i2c = ia->ia_tag;
247 1.1 jmcneill sc->sc_addr = ia->ia_addr;
248 1.6 jmcneill sc->sc_phandle = ia->ia_cookie;
249 1.1 jmcneill
250 1.3 bouyer error = axp20x_read(sc, AXP_INPUT_STATUS,
251 1.3 bouyer &sc->sc_inputstatus, 1, I2C_F_POLL);
252 1.3 bouyer if (error) {
253 1.3 bouyer aprint_error(": can't read status: %d\n", error);
254 1.3 bouyer return;
255 1.3 bouyer }
256 1.3 bouyer error = axp20x_read(sc, AXP_POWER_MODE,
257 1.3 bouyer &sc->sc_powermode, 1, I2C_F_POLL);
258 1.3 bouyer if (error) {
259 1.3 bouyer aprint_error(": can't read power mode: %d\n", error);
260 1.3 bouyer return;
261 1.3 bouyer }
262 1.3 bouyer value = AXP_ADC_EN1_ACV | AXP_ADC_EN1_ACI | AXP_ADC_EN1_VBUSV | AXP_ADC_EN1_VBUSI | AXP_ADC_EN1_APSV | AXP_ADC_EN1_TS;
263 1.3 bouyer if (sc->sc_powermode & AXP_POWER_MODE_BATTOK)
264 1.3 bouyer value |= AXP_ADC_EN1_BATTV | AXP_ADC_EN1_BATTI;
265 1.3 bouyer error = axp20x_write(sc, AXP_ADC_EN1, &value, 1, I2C_F_POLL);
266 1.3 bouyer if (error) {
267 1.3 bouyer aprint_error(": can't set AXP_ADC_EN1\n");
268 1.3 bouyer return;
269 1.3 bouyer }
270 1.3 bouyer error = axp20x_read(sc, AXP_ADC_EN2, &value, 1, I2C_F_POLL);
271 1.3 bouyer if (error) {
272 1.3 bouyer aprint_error(": can't read AXP_ADC_EN2\n");
273 1.3 bouyer return;
274 1.3 bouyer }
275 1.3 bouyer value |= AXP_ADC_EN2_TEMP;
276 1.3 bouyer error = axp20x_write(sc, AXP_ADC_EN2, &value, 1, I2C_F_POLL);
277 1.3 bouyer if (error) {
278 1.3 bouyer aprint_error(": can't set AXP_ADC_EN2\n");
279 1.3 bouyer return;
280 1.3 bouyer }
281 1.3 bouyer
282 1.1 jmcneill aprint_naive("\n");
283 1.3 bouyer first = 1;
284 1.3 bouyer if (sc->sc_inputstatus & AXP_INPUT_STATUS_AC_OK) {
285 1.4 bouyer aprint_verbose(": AC used");
286 1.3 bouyer first = 0;
287 1.3 bouyer } else if (sc->sc_inputstatus & AXP_INPUT_STATUS_AC_PRESENT) {
288 1.4 bouyer aprint_verbose(": AC present (but unused)");
289 1.3 bouyer first = 0;
290 1.3 bouyer }
291 1.3 bouyer if (sc->sc_inputstatus & AXP_INPUT_STATUS_VBUS_OK) {
292 1.4 bouyer aprint_verbose("%s VBUS used", first ? ":" : ",");
293 1.3 bouyer first = 0;
294 1.3 bouyer } else if (sc->sc_inputstatus & AXP_INPUT_STATUS_VBUS_PRESENT) {
295 1.4 bouyer aprint_verbose("%s VBUS present (but unused)", first ? ":" : ",");
296 1.3 bouyer first = 0;
297 1.3 bouyer }
298 1.3 bouyer if (sc->sc_powermode & AXP_POWER_MODE_BATTOK) {
299 1.4 bouyer aprint_verbose("%s battery present", first ? ":" : ",");
300 1.3 bouyer }
301 1.1 jmcneill aprint_normal("\n");
302 1.1 jmcneill
303 1.1 jmcneill sc->sc_sme = sysmon_envsys_create();
304 1.1 jmcneill sc->sc_sme->sme_name = device_xname(self);
305 1.1 jmcneill sc->sc_sme->sme_cookie = sc;
306 1.1 jmcneill sc->sc_sme->sme_refresh = axp20x_sensors_refresh;
307 1.1 jmcneill
308 1.3 bouyer sc->sc_sensor[AXP_SENSOR_ACOK].units = ENVSYS_INDICATOR;
309 1.3 bouyer sc->sc_sensor[AXP_SENSOR_ACOK].state = ENVSYS_SVALID;
310 1.3 bouyer sc->sc_sensor[AXP_SENSOR_ACOK].value_cur =
311 1.3 bouyer (sc->sc_inputstatus & AXP_INPUT_STATUS_AC_OK) ? 1 : 0;
312 1.3 bouyer snprintf(sc->sc_sensor[AXP_SENSOR_ACOK].desc,
313 1.3 bouyer sizeof(sc->sc_sensor[AXP_SENSOR_ACOK].desc), "AC input");
314 1.3 bouyer sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[AXP_SENSOR_ACOK]);
315 1.3 bouyer sc->sc_sensor[AXP_SENSOR_ACV].units = ENVSYS_SVOLTS_DC;
316 1.3 bouyer sc->sc_sensor[AXP_SENSOR_ACV].state = ENVSYS_SINVALID;
317 1.3 bouyer sc->sc_sensor[AXP_SENSOR_ACV].flags = ENVSYS_FHAS_ENTROPY;
318 1.3 bouyer snprintf(sc->sc_sensor[AXP_SENSOR_ACV].desc,
319 1.3 bouyer sizeof(sc->sc_sensor[AXP_SENSOR_ACV].desc), "AC input voltage");
320 1.3 bouyer sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[AXP_SENSOR_ACV]);
321 1.3 bouyer sc->sc_sensor[AXP_SENSOR_ACI].units = ENVSYS_SAMPS;
322 1.3 bouyer sc->sc_sensor[AXP_SENSOR_ACI].state = ENVSYS_SINVALID;
323 1.3 bouyer sc->sc_sensor[AXP_SENSOR_ACI].flags = ENVSYS_FHAS_ENTROPY;
324 1.3 bouyer snprintf(sc->sc_sensor[AXP_SENSOR_ACI].desc,
325 1.3 bouyer sizeof(sc->sc_sensor[AXP_SENSOR_ACI].desc), "AC input current");
326 1.3 bouyer sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[AXP_SENSOR_ACI]);
327 1.3 bouyer
328 1.3 bouyer sc->sc_sensor[AXP_SENSOR_VBUSOK].units = ENVSYS_INDICATOR;
329 1.3 bouyer sc->sc_sensor[AXP_SENSOR_VBUSOK].state = ENVSYS_SVALID;
330 1.3 bouyer sc->sc_sensor[AXP_SENSOR_VBUSOK].value_cur =
331 1.3 bouyer (sc->sc_inputstatus & AXP_INPUT_STATUS_VBUS_OK) ? 1 : 0;
332 1.3 bouyer snprintf(sc->sc_sensor[AXP_SENSOR_VBUSOK].desc,
333 1.3 bouyer sizeof(sc->sc_sensor[AXP_SENSOR_VBUSOK].desc), "VBUS input");
334 1.3 bouyer sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[AXP_SENSOR_VBUSOK]);
335 1.3 bouyer sc->sc_sensor[AXP_SENSOR_VBUSV].units = ENVSYS_SVOLTS_DC;
336 1.3 bouyer sc->sc_sensor[AXP_SENSOR_VBUSV].state = ENVSYS_SINVALID;
337 1.3 bouyer sc->sc_sensor[AXP_SENSOR_VBUSV].flags = ENVSYS_FHAS_ENTROPY;
338 1.3 bouyer snprintf(sc->sc_sensor[AXP_SENSOR_VBUSV].desc,
339 1.3 bouyer sizeof(sc->sc_sensor[AXP_SENSOR_VBUSV].desc), "VBUS input voltage");
340 1.3 bouyer sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[AXP_SENSOR_VBUSV]);
341 1.3 bouyer sc->sc_sensor[AXP_SENSOR_VBUSI].units = ENVSYS_SAMPS;
342 1.3 bouyer sc->sc_sensor[AXP_SENSOR_VBUSI].state = ENVSYS_SINVALID;
343 1.3 bouyer sc->sc_sensor[AXP_SENSOR_VBUSI].flags = ENVSYS_FHAS_ENTROPY;
344 1.3 bouyer snprintf(sc->sc_sensor[AXP_SENSOR_VBUSI].desc,
345 1.3 bouyer sizeof(sc->sc_sensor[AXP_SENSOR_VBUSI].desc), "VBUS input current");
346 1.3 bouyer sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[AXP_SENSOR_VBUSI]);
347 1.3 bouyer
348 1.3 bouyer sc->sc_sensor[AXP_SENSOR_BATTOK].units = ENVSYS_INDICATOR;
349 1.3 bouyer sc->sc_sensor[AXP_SENSOR_BATTOK].state = ENVSYS_SVALID;
350 1.3 bouyer sc->sc_sensor[AXP_SENSOR_BATTOK].value_cur =
351 1.3 bouyer (sc->sc_powermode & AXP_POWER_MODE_BATTOK) ? 1 : 0;
352 1.3 bouyer snprintf(sc->sc_sensor[AXP_SENSOR_BATTOK].desc,
353 1.3 bouyer sizeof(sc->sc_sensor[AXP_SENSOR_BATTOK].desc), "battery");
354 1.3 bouyer sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[AXP_SENSOR_BATTOK]);
355 1.3 bouyer sc->sc_sensor[AXP_SENSOR_BATTV].units = ENVSYS_SVOLTS_DC;
356 1.3 bouyer sc->sc_sensor[AXP_SENSOR_BATTV].state = ENVSYS_SINVALID;
357 1.3 bouyer sc->sc_sensor[AXP_SENSOR_BATTV].flags = ENVSYS_FHAS_ENTROPY;
358 1.3 bouyer snprintf(sc->sc_sensor[AXP_SENSOR_BATTV].desc,
359 1.3 bouyer sizeof(sc->sc_sensor[AXP_SENSOR_BATTV].desc), "battery voltage");
360 1.3 bouyer sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[AXP_SENSOR_BATTV]);
361 1.3 bouyer sc->sc_sensor[AXP_SENSOR_BATTI].units = ENVSYS_SAMPS;
362 1.3 bouyer sc->sc_sensor[AXP_SENSOR_BATTI].state = ENVSYS_SINVALID;
363 1.3 bouyer sc->sc_sensor[AXP_SENSOR_BATTI].flags = ENVSYS_FHAS_ENTROPY;
364 1.3 bouyer snprintf(sc->sc_sensor[AXP_SENSOR_BATTI].desc,
365 1.3 bouyer sizeof(sc->sc_sensor[AXP_SENSOR_BATTI].desc), "battery current");
366 1.3 bouyer sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[AXP_SENSOR_BATTI]);
367 1.3 bouyer
368 1.3 bouyer sc->sc_sensor[AXP_SENSOR_APSV].units = ENVSYS_SVOLTS_DC;
369 1.3 bouyer sc->sc_sensor[AXP_SENSOR_APSV].state = ENVSYS_SINVALID;
370 1.3 bouyer sc->sc_sensor[AXP_SENSOR_APSV].flags = ENVSYS_FHAS_ENTROPY;
371 1.3 bouyer snprintf(sc->sc_sensor[AXP_SENSOR_APSV].desc,
372 1.3 bouyer sizeof(sc->sc_sensor[AXP_SENSOR_APSV].desc), "APS output voltage");
373 1.3 bouyer sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[AXP_SENSOR_APSV]);
374 1.3 bouyer sc->sc_sensor[AXP_SENSOR_TEMP].units = ENVSYS_STEMP;
375 1.3 bouyer sc->sc_sensor[AXP_SENSOR_TEMP].state = ENVSYS_SINVALID;
376 1.3 bouyer sc->sc_sensor[AXP_SENSOR_TEMP].flags = ENVSYS_FHAS_ENTROPY;
377 1.3 bouyer snprintf(sc->sc_sensor[AXP_SENSOR_TEMP].desc,
378 1.3 bouyer sizeof(sc->sc_sensor[AXP_SENSOR_TEMP].desc),
379 1.1 jmcneill "internal temperature");
380 1.3 bouyer sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[AXP_SENSOR_TEMP]);
381 1.1 jmcneill
382 1.1 jmcneill sysmon_envsys_register(sc->sc_sme);
383 1.3 bouyer
384 1.3 bouyer if (axp20x_read(sc, AXP_DCDC2, &value, 1, I2C_F_POLL) == 0) {
385 1.9 jmcneill aprint_verbose_dev(sc->sc_dev, "DCDC2 %dmV\n",
386 1.3 bouyer (int)(700 + (value & AXP_DCDC2_VOLT_MASK) * 25));
387 1.3 bouyer }
388 1.3 bouyer if (axp20x_read(sc, AXP_DCDC3, &value, 1, I2C_F_POLL) == 0) {
389 1.9 jmcneill aprint_verbose_dev(sc->sc_dev, "DCDC3 %dmV\n",
390 1.3 bouyer (int)(700 + (value & AXP_DCDC3_VOLT_MASK) * 25));
391 1.3 bouyer }
392 1.3 bouyer if (axp20x_read(sc, AXP_LDO2_4, &value, 1, I2C_F_POLL) == 0) {
393 1.9 jmcneill aprint_verbose_dev(sc->sc_dev, "LDO2 %dmV, LDO4 %dmV\n",
394 1.3 bouyer (int)(1800 +
395 1.3 bouyer ((value & AXP_LDO2_VOLT_MASK) >> AXP_LDO2_VOLT_SHIFT) * 100
396 1.3 bouyer ),
397 1.3 bouyer ldo4_mvV[(value & AXP_LDO4_VOLT_MASK) >> AXP_LDO4_VOLT_SHIFT]);
398 1.3 bouyer }
399 1.3 bouyer if (axp20x_read(sc, AXP_LDO3, &value, 1, I2C_F_POLL) == 0) {
400 1.3 bouyer if (value & AXP_LDO3_TRACK) {
401 1.9 jmcneill aprint_verbose_dev(sc->sc_dev, "LDO3: tracking\n");
402 1.3 bouyer } else {
403 1.9 jmcneill aprint_verbose_dev(sc->sc_dev, "LDO3 %dmV\n",
404 1.3 bouyer (int)(700 + (value & AXP_LDO3_VOLT_MASK) * 25));
405 1.3 bouyer }
406 1.3 bouyer }
407 1.5 tnn
408 1.5 tnn if (axp20x_read(sc, AXP_BKUP_CTRL, &value, 1, I2C_F_POLL) == 0) {
409 1.5 tnn if (value & AXP_BKUP_CTRL_ENABLE) {
410 1.5 tnn aprint_verbose_dev(sc->sc_dev,
411 1.5 tnn "RTC supercap charger enabled: %dmV at %duA\n",
412 1.5 tnn bkup_volt[(value & AXP_BKUP_CTRL_VOLT_MASK) >>
413 1.5 tnn AXP_BKUP_CTRL_VOLT_SHIFT],
414 1.5 tnn bkup_curr[(value & AXP_BKUP_CTRL_CURR_MASK) >>
415 1.5 tnn AXP_BKUP_CTRL_CURR_SHIFT]
416 1.5 tnn );
417 1.5 tnn }
418 1.5 tnn }
419 1.7 jmcneill
420 1.7 jmcneill #ifdef FDT
421 1.7 jmcneill axp20x_fdt_attach(sc);
422 1.7 jmcneill #endif
423 1.1 jmcneill }
424 1.1 jmcneill
425 1.1 jmcneill static void
426 1.3 bouyer axp20x_sensors_refresh_volt(struct axp20x_softc *sc, int reg,
427 1.3 bouyer envsys_data_t *edata)
428 1.1 jmcneill {
429 1.1 jmcneill uint8_t buf[2];
430 1.1 jmcneill int error;
431 1.1 jmcneill
432 1.3 bouyer error = axp20x_read(sc, reg, buf, sizeof(buf), 0);
433 1.3 bouyer if (error) {
434 1.3 bouyer edata->state = ENVSYS_SINVALID;
435 1.3 bouyer } else {
436 1.3 bouyer edata->value_cur = ((buf[0] << 4) | (buf[1] & 0xf)) *
437 1.3 bouyer axp20x_sensors_lsb[edata->sensor];
438 1.3 bouyer edata->state = ENVSYS_SVALID;
439 1.3 bouyer }
440 1.3 bouyer }
441 1.3 bouyer
442 1.3 bouyer static void
443 1.3 bouyer axp20x_sensors_refresh_amp(struct axp20x_softc *sc, int reg,
444 1.3 bouyer envsys_data_t *edata)
445 1.3 bouyer {
446 1.3 bouyer uint8_t buf[2];
447 1.3 bouyer int error;
448 1.1 jmcneill
449 1.3 bouyer error = axp20x_read(sc, reg, buf, sizeof(buf), 0);
450 1.1 jmcneill if (error) {
451 1.1 jmcneill edata->state = ENVSYS_SINVALID;
452 1.1 jmcneill } else {
453 1.3 bouyer edata->value_cur = ((buf[0] << 4) | (buf[1] & 0xf)) *
454 1.3 bouyer axp20x_sensors_lsb[edata->sensor];
455 1.1 jmcneill edata->state = ENVSYS_SVALID;
456 1.1 jmcneill }
457 1.1 jmcneill }
458 1.1 jmcneill
459 1.3 bouyer static void
460 1.3 bouyer axp20x_sensors_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
461 1.3 bouyer {
462 1.3 bouyer struct axp20x_softc *sc = sme->sme_cookie;
463 1.3 bouyer uint8_t buf[2];
464 1.3 bouyer int error;
465 1.3 bouyer
466 1.3 bouyer switch(edata->sensor) {
467 1.3 bouyer case AXP_SENSOR_ACOK:
468 1.3 bouyer case AXP_SENSOR_VBUSOK:
469 1.3 bouyer error = axp20x_read(sc, AXP_INPUT_STATUS,
470 1.3 bouyer &sc->sc_inputstatus, 1, 0);
471 1.3 bouyer if (error) {
472 1.3 bouyer edata->state = ENVSYS_SINVALID;
473 1.3 bouyer return;
474 1.3 bouyer }
475 1.3 bouyer if (edata->sensor == AXP_SENSOR_ACOK) {
476 1.3 bouyer edata->value_cur =
477 1.3 bouyer (sc->sc_inputstatus & AXP_INPUT_STATUS_AC_OK) ? 1 : 0;
478 1.3 bouyer } else {
479 1.3 bouyer edata->value_cur =
480 1.3 bouyer (sc->sc_inputstatus & AXP_INPUT_STATUS_VBUS_OK) ? 1 : 0;
481 1.3 bouyer }
482 1.3 bouyer edata->state = ENVSYS_SVALID;
483 1.3 bouyer return;
484 1.3 bouyer case AXP_SENSOR_BATTOK:
485 1.3 bouyer error = axp20x_read(sc, AXP_POWER_MODE,
486 1.3 bouyer &sc->sc_powermode, 1, 0);
487 1.3 bouyer if (error) {
488 1.3 bouyer edata->state = ENVSYS_SINVALID;
489 1.3 bouyer return;
490 1.3 bouyer }
491 1.3 bouyer edata->value_cur =
492 1.3 bouyer (sc->sc_powermode & AXP_POWER_MODE_BATTOK) ? 1 : 0;
493 1.3 bouyer return;
494 1.3 bouyer case AXP_SENSOR_ACV:
495 1.3 bouyer if (sc->sc_inputstatus & AXP_INPUT_STATUS_AC_OK)
496 1.3 bouyer axp20x_sensors_refresh_volt(sc, AXP_ACV_MON_REG, edata);
497 1.3 bouyer else
498 1.3 bouyer edata->state = ENVSYS_SINVALID;
499 1.3 bouyer return;
500 1.3 bouyer case AXP_SENSOR_ACI:
501 1.3 bouyer if (sc->sc_inputstatus & AXP_INPUT_STATUS_AC_OK)
502 1.3 bouyer axp20x_sensors_refresh_amp(sc, AXP_ACI_MON_REG, edata);
503 1.3 bouyer else
504 1.3 bouyer edata->state = ENVSYS_SINVALID;
505 1.3 bouyer return;
506 1.3 bouyer case AXP_SENSOR_VBUSV:
507 1.3 bouyer if (sc->sc_inputstatus & AXP_INPUT_STATUS_VBUS_OK)
508 1.3 bouyer axp20x_sensors_refresh_volt(sc, AXP_VBUSV_MON_REG, edata);
509 1.3 bouyer else
510 1.3 bouyer edata->state = ENVSYS_SINVALID;
511 1.3 bouyer return;
512 1.3 bouyer case AXP_SENSOR_VBUSI:
513 1.3 bouyer if (sc->sc_inputstatus & AXP_INPUT_STATUS_VBUS_OK)
514 1.3 bouyer axp20x_sensors_refresh_amp(sc, AXP_VBUSI_MON_REG, edata);
515 1.3 bouyer else
516 1.3 bouyer edata->state = ENVSYS_SINVALID;
517 1.3 bouyer return;
518 1.3 bouyer case AXP_SENSOR_BATTV:
519 1.3 bouyer if (sc->sc_powermode & AXP_POWER_MODE_BATTOK)
520 1.3 bouyer axp20x_sensors_refresh_volt(sc, AXP_BATTV_MON_REG, edata);
521 1.3 bouyer else
522 1.3 bouyer edata->state = ENVSYS_SINVALID;
523 1.3 bouyer return;
524 1.3 bouyer case AXP_SENSOR_BATTI:
525 1.3 bouyer if ((sc->sc_powermode & AXP_POWER_MODE_BATTOK) == 0) {
526 1.3 bouyer edata->state = ENVSYS_SINVALID;
527 1.3 bouyer return;
528 1.3 bouyer }
529 1.3 bouyer error = axp20x_read(sc, AXP_POWER_MODE,
530 1.3 bouyer &sc->sc_inputstatus, 1, 0);
531 1.3 bouyer if (error) {
532 1.3 bouyer edata->state = ENVSYS_SINVALID;
533 1.3 bouyer return;
534 1.3 bouyer }
535 1.3 bouyer if (sc->sc_inputstatus & AXP_POWER_MODE_CHARGING) {
536 1.3 bouyer axp20x_sensors_refresh_amp(sc, AXP_BATTCI_MON_REG,
537 1.3 bouyer edata);
538 1.3 bouyer edata->value_cur = -edata->value_cur;
539 1.3 bouyer } else {
540 1.3 bouyer axp20x_sensors_refresh_amp(sc, AXP_BATTDI_MON_REG,
541 1.3 bouyer edata);
542 1.3 bouyer }
543 1.3 bouyer return;
544 1.3 bouyer case AXP_SENSOR_APSV:
545 1.3 bouyer axp20x_sensors_refresh_volt(sc, AXP_APSV_MON_REG, edata);
546 1.3 bouyer return;
547 1.3 bouyer case AXP_SENSOR_TEMP:
548 1.3 bouyer error = axp20x_read(sc, AXP_TEMP_MON_REG, buf, sizeof(buf), 0);
549 1.3 bouyer if (error) {
550 1.3 bouyer edata->state = ENVSYS_SINVALID;
551 1.3 bouyer } else {
552 1.3 bouyer /* between -144.7C and 264.8C, step +0.1C */
553 1.3 bouyer edata->value_cur =
554 1.3 bouyer (((buf[0] << 4) | (buf[1] & 0xf)) - 1447)
555 1.3 bouyer * 100000 + 273150000;
556 1.3 bouyer edata->state = ENVSYS_SVALID;
557 1.3 bouyer }
558 1.3 bouyer return;
559 1.3 bouyer default:
560 1.9 jmcneill aprint_error_dev(sc->sc_dev, "invalid sensor %d\n",
561 1.3 bouyer edata->sensor);
562 1.3 bouyer }
563 1.3 bouyer }
564 1.3 bouyer
565 1.3 bouyer static int
566 1.3 bouyer axp20x_read(struct axp20x_softc *sc, uint8_t reg, uint8_t *val, size_t len,
567 1.3 bouyer int flags)
568 1.3 bouyer {
569 1.3 bouyer int ret;
570 1.3 bouyer iic_acquire_bus(sc->sc_i2c, flags);
571 1.10 jmcneill ret = iic_exec(sc->sc_i2c, I2C_OP_READ_WITH_STOP, sc->sc_addr,
572 1.10 jmcneill ®, 1, val, len, flags);
573 1.3 bouyer iic_release_bus(sc->sc_i2c, flags);
574 1.3 bouyer return ret;
575 1.3 bouyer
576 1.3 bouyer }
577 1.3 bouyer
578 1.1 jmcneill static int
579 1.3 bouyer axp20x_write(struct axp20x_softc *sc, uint8_t reg, uint8_t *val, size_t len,
580 1.3 bouyer int flags)
581 1.1 jmcneill {
582 1.3 bouyer int ret;
583 1.3 bouyer iic_acquire_bus(sc->sc_i2c, flags);
584 1.10 jmcneill ret = iic_exec(sc->sc_i2c, I2C_OP_WRITE_WITH_STOP, sc->sc_addr,
585 1.10 jmcneill ®, 1, val, len, flags);
586 1.3 bouyer iic_release_bus(sc->sc_i2c, flags);
587 1.3 bouyer return ret;
588 1.3 bouyer }
589 1.3 bouyer
590 1.3 bouyer int
591 1.3 bouyer axp20x_set_dcdc(device_t dev, int dcdc, int mvolt, bool poll)
592 1.3 bouyer {
593 1.3 bouyer struct axp20x_softc *sc = device_private(dev);
594 1.3 bouyer int ret;
595 1.3 bouyer int value;
596 1.3 bouyer uint8_t reg;
597 1.3 bouyer
598 1.3 bouyer KASSERT(sc != NULL);
599 1.3 bouyer value = (mvolt - 700) / 25;
600 1.3 bouyer switch (dcdc) {
601 1.3 bouyer case AXP20X_DCDC2:
602 1.3 bouyer value <<= AXP_DCDC2_VOLT_SHIFT;
603 1.3 bouyer if (value > AXP_DCDC2_VOLT_MASK)
604 1.3 bouyer return EINVAL;
605 1.3 bouyer reg = value & AXP_DCDC2_VOLT_MASK;
606 1.3 bouyer ret = axp20x_write(sc, AXP_DCDC2, ®, 1,
607 1.3 bouyer poll ? I2C_F_POLL : 0);
608 1.3 bouyer if (ret)
609 1.3 bouyer return ret;
610 1.3 bouyer if (axp20x_read(sc, AXP_DCDC2, ®, 1, poll ? I2C_F_POLL : 0)
611 1.3 bouyer == 0) {
612 1.9 jmcneill aprint_debug_dev(sc->sc_dev,
613 1.9 jmcneill "DCDC2 changed to %dmV\n",
614 1.3 bouyer (int)(700 + (reg & AXP_DCDC2_VOLT_MASK) * 25));
615 1.3 bouyer }
616 1.3 bouyer return 0;
617 1.3 bouyer
618 1.3 bouyer case AXP20X_DCDC3:
619 1.4 bouyer value <<= AXP_DCDC3_VOLT_SHIFT;
620 1.4 bouyer if (value > AXP_DCDC3_VOLT_MASK)
621 1.3 bouyer return EINVAL;
622 1.4 bouyer reg = value & AXP_DCDC3_VOLT_MASK;
623 1.4 bouyer ret = axp20x_write(sc, AXP_DCDC3, ®, 1,
624 1.3 bouyer poll ? I2C_F_POLL : 0);
625 1.3 bouyer if (ret)
626 1.3 bouyer return ret;
627 1.4 bouyer if (axp20x_read(sc, AXP_DCDC3, ®, 1, poll ? I2C_F_POLL : 0)
628 1.3 bouyer == 0) {
629 1.9 jmcneill aprint_debug_dev(sc->sc_dev,
630 1.9 jmcneill "DCDC3 changed to %dmV\n",
631 1.4 bouyer (int)(700 + (reg & AXP_DCDC3_VOLT_MASK) * 25));
632 1.3 bouyer }
633 1.3 bouyer return 0;
634 1.3 bouyer default:
635 1.3 bouyer aprint_error_dev(dev, "wrong DCDC %d\n", dcdc);
636 1.3 bouyer return EINVAL;
637 1.3 bouyer }
638 1.1 jmcneill }
639 1.7 jmcneill
640 1.8 jmcneill int
641 1.8 jmcneill axp20x_get_dcdc(device_t dev, int dcdc, int *pmvolt, bool poll)
642 1.8 jmcneill {
643 1.8 jmcneill struct axp20x_softc *sc = device_private(dev);
644 1.8 jmcneill uint8_t reg;
645 1.8 jmcneill int error;
646 1.8 jmcneill
647 1.8 jmcneill switch (dcdc) {
648 1.8 jmcneill case AXP20X_DCDC2:
649 1.8 jmcneill error = axp20x_read(sc, AXP_DCDC2, ®, 1, poll ? I2C_F_POLL : 0);
650 1.8 jmcneill if (error != 0)
651 1.8 jmcneill return error;
652 1.8 jmcneill *pmvolt = __SHIFTOUT(reg, AXP_DCDC2_VOLT_MASK) * 25 + 700;
653 1.8 jmcneill return 0;
654 1.8 jmcneill case AXP20X_DCDC3:
655 1.8 jmcneill error = axp20x_read(sc, AXP_DCDC3, ®, 1, poll ? I2C_F_POLL : 0);
656 1.8 jmcneill if (error != 0)
657 1.8 jmcneill return error;
658 1.8 jmcneill *pmvolt = __SHIFTOUT(reg, AXP_DCDC3_VOLT_MASK) * 25 + 700;
659 1.8 jmcneill return 0;
660 1.8 jmcneill default:
661 1.8 jmcneill return EINVAL;
662 1.8 jmcneill }
663 1.8 jmcneill }
664 1.8 jmcneill
665 1.7 jmcneill void
666 1.7 jmcneill axp20x_poweroff(device_t dev)
667 1.7 jmcneill {
668 1.7 jmcneill struct axp20x_softc * const sc = device_private(dev);
669 1.7 jmcneill uint8_t reg = AXP_SHUTDOWN_CTRL;
670 1.7 jmcneill
671 1.7 jmcneill if (axp20x_write(sc, AXP_SHUTDOWN, ®, 1, I2C_F_POLL) != 0)
672 1.7 jmcneill device_printf(dev, "WARNING: poweroff failed\n");
673 1.7 jmcneill }
674 1.7 jmcneill
675 1.7 jmcneill #ifdef FDT
676 1.8 jmcneill static const struct axp20xregdef {
677 1.8 jmcneill const char *name;
678 1.8 jmcneill int dcdc;
679 1.8 jmcneill } axp20x_regdefs[] = {
680 1.8 jmcneill { "dcdc2", AXP20X_DCDC2 },
681 1.8 jmcneill { "dcdc3", AXP20X_DCDC3 },
682 1.8 jmcneill };
683 1.8 jmcneill
684 1.8 jmcneill struct axp20xreg_softc {
685 1.8 jmcneill device_t sc_dev;
686 1.8 jmcneill int sc_phandle;
687 1.8 jmcneill const struct axp20xregdef *sc_regdef;
688 1.8 jmcneill };
689 1.8 jmcneill
690 1.8 jmcneill struct axp20xreg_attach_args {
691 1.8 jmcneill int reg_phandle;
692 1.8 jmcneill };
693 1.8 jmcneill
694 1.8 jmcneill static int
695 1.8 jmcneill axp20xreg_acquire(device_t dev)
696 1.8 jmcneill {
697 1.8 jmcneill return 0;
698 1.8 jmcneill }
699 1.8 jmcneill
700 1.8 jmcneill static void
701 1.8 jmcneill axp20xreg_release(device_t dev)
702 1.8 jmcneill {
703 1.8 jmcneill }
704 1.8 jmcneill
705 1.8 jmcneill static int
706 1.8 jmcneill axp20xreg_enable(device_t dev, bool enable)
707 1.8 jmcneill {
708 1.8 jmcneill /* TODO */
709 1.8 jmcneill return enable ? 0 : EINVAL;
710 1.8 jmcneill }
711 1.8 jmcneill
712 1.8 jmcneill static int
713 1.8 jmcneill axp20xreg_set_voltage(device_t dev, u_int min_uvol, u_int max_uvol)
714 1.8 jmcneill {
715 1.8 jmcneill struct axp20xreg_softc * const sc = device_private(dev);
716 1.8 jmcneill
717 1.8 jmcneill return axp20x_set_dcdc(device_parent(dev), sc->sc_regdef->dcdc, min_uvol / 1000, true);
718 1.8 jmcneill }
719 1.8 jmcneill
720 1.8 jmcneill static int
721 1.8 jmcneill axp20xreg_get_voltage(device_t dev, u_int *puvol)
722 1.8 jmcneill {
723 1.8 jmcneill struct axp20xreg_softc * const sc = device_private(dev);
724 1.8 jmcneill int mvol, error;
725 1.8 jmcneill
726 1.8 jmcneill error = axp20x_get_dcdc(device_parent(dev), sc->sc_regdef->dcdc, &mvol, true);
727 1.8 jmcneill if (error != 0)
728 1.8 jmcneill return error;
729 1.8 jmcneill
730 1.8 jmcneill *puvol = mvol * 1000;
731 1.8 jmcneill return 0;
732 1.8 jmcneill }
733 1.8 jmcneill
734 1.8 jmcneill static struct fdtbus_regulator_controller_func axp20xreg_funcs = {
735 1.8 jmcneill .acquire = axp20xreg_acquire,
736 1.8 jmcneill .release = axp20xreg_release,
737 1.8 jmcneill .enable = axp20xreg_enable,
738 1.8 jmcneill .set_voltage = axp20xreg_set_voltage,
739 1.8 jmcneill .get_voltage = axp20xreg_get_voltage,
740 1.8 jmcneill };
741 1.8 jmcneill
742 1.8 jmcneill static const struct axp20xregdef *
743 1.8 jmcneill axp20xreg_lookup(int phandle)
744 1.8 jmcneill {
745 1.8 jmcneill const char *name;
746 1.8 jmcneill int n;
747 1.8 jmcneill
748 1.8 jmcneill name = fdtbus_get_string(phandle, "name");
749 1.8 jmcneill if (name == NULL)
750 1.8 jmcneill return NULL;
751 1.8 jmcneill
752 1.8 jmcneill for (n = 0; n < __arraycount(axp20x_regdefs); n++)
753 1.8 jmcneill if (strcmp(name, axp20x_regdefs[n].name) == 0)
754 1.8 jmcneill return &axp20x_regdefs[n];
755 1.8 jmcneill
756 1.8 jmcneill return NULL;
757 1.8 jmcneill }
758 1.8 jmcneill
759 1.8 jmcneill static int
760 1.8 jmcneill axp20xreg_match(device_t parent, cfdata_t match, void *aux)
761 1.8 jmcneill {
762 1.8 jmcneill const struct axp20xreg_attach_args *reg = aux;
763 1.8 jmcneill
764 1.8 jmcneill return axp20xreg_lookup(reg->reg_phandle) != NULL;
765 1.8 jmcneill }
766 1.8 jmcneill
767 1.8 jmcneill static void
768 1.8 jmcneill axp20xreg_attach(device_t parent, device_t self, void *aux)
769 1.8 jmcneill {
770 1.8 jmcneill struct axp20xreg_softc * const sc = device_private(self);
771 1.8 jmcneill const struct axp20xreg_attach_args *reg = aux;
772 1.8 jmcneill const char *regulator_name;
773 1.8 jmcneill
774 1.8 jmcneill sc->sc_dev = self;
775 1.8 jmcneill sc->sc_phandle = reg->reg_phandle;
776 1.8 jmcneill sc->sc_regdef = axp20xreg_lookup(reg->reg_phandle);
777 1.8 jmcneill
778 1.8 jmcneill regulator_name = fdtbus_get_string(reg->reg_phandle, "regulator-name");
779 1.8 jmcneill
780 1.8 jmcneill aprint_naive("\n");
781 1.8 jmcneill if (regulator_name)
782 1.8 jmcneill aprint_normal(": %s (%s)\n", sc->sc_regdef->name, regulator_name);
783 1.8 jmcneill else
784 1.8 jmcneill aprint_normal(": %s\n", sc->sc_regdef->name);
785 1.8 jmcneill
786 1.8 jmcneill fdtbus_register_regulator_controller(self, sc->sc_phandle, &axp20xreg_funcs);
787 1.8 jmcneill }
788 1.8 jmcneill
789 1.8 jmcneill CFATTACH_DECL_NEW(axp20xreg, sizeof(struct axp20xreg_softc),
790 1.8 jmcneill axp20xreg_match, axp20xreg_attach, NULL, NULL);
791 1.8 jmcneill
792 1.7 jmcneill static void
793 1.7 jmcneill axp20x_fdt_poweroff(device_t dev)
794 1.7 jmcneill {
795 1.7 jmcneill delay(1000000);
796 1.7 jmcneill axp20x_poweroff(dev);
797 1.7 jmcneill }
798 1.7 jmcneill
799 1.7 jmcneill static struct fdtbus_power_controller_func axp20x_fdt_power_funcs = {
800 1.7 jmcneill .poweroff = axp20x_fdt_poweroff,
801 1.7 jmcneill };
802 1.7 jmcneill
803 1.7 jmcneill static void
804 1.7 jmcneill axp20x_fdt_attach(struct axp20x_softc *sc)
805 1.7 jmcneill {
806 1.8 jmcneill int regulators_phandle, child;
807 1.8 jmcneill
808 1.7 jmcneill fdtbus_register_power_controller(sc->sc_dev, sc->sc_phandle,
809 1.7 jmcneill &axp20x_fdt_power_funcs);
810 1.8 jmcneill
811 1.8 jmcneill regulators_phandle = of_find_firstchild_byname(sc->sc_phandle, "regulators");
812 1.8 jmcneill if (regulators_phandle == -1)
813 1.8 jmcneill return;
814 1.8 jmcneill
815 1.8 jmcneill for (child = OF_child(regulators_phandle); child; child = OF_peer(child)) {
816 1.8 jmcneill struct axp20xreg_attach_args reg = { .reg_phandle = child };
817 1.8 jmcneill config_found(sc->sc_dev, ®, NULL);
818 1.8 jmcneill }
819 1.7 jmcneill }
820 1.7 jmcneill #endif /* FDT */
821