/* $NetBSD: as3722.c,v 1.27 2025/09/17 13:49:13 thorpej Exp $ */ /*- * Copyright (c) 2015 Jared D. McNeill * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include "opt_fdt.h" #include __KERNEL_RCSID(0, "$NetBSD: as3722.c,v 1.27 2025/09/17 13:49:13 thorpej Exp $"); #include #include #include #include #include #include #include #include #include #include #include #include #ifdef FDT #include #endif #define AS3722_I2C_ADDR 0x40 #define AS3722_START_YEAR 2000 #define AS3722_SD0_VOLTAGE_REG 0x00 #define AS3722_SD4_VOLTAGE_REG 0x04 #define AS3722_GPIO0_CTRL_REG 0x08 #define AS3722_GPIO0_CTRL_INVERT __BIT(7) #define AS3722_GPIO0_CTRL_IOSF __BITS(6,3) #define AS3722_GPIO0_CTRL_IOSF_GPIO 0 #define AS3722_GPIO0_CTRL_IOSF_WATCHDOG 9 #define AS3722_GPIO0_CTRL_MODE __BITS(2,0) #define AS3722_GPIO0_CTRL_MODE_PULLDOWN 5 #define AS3722_LDO6_VOLTAGE_REG 0x16 #define AS3722_RESET_CTRL_REG 0x36 #define AS3722_RESET_CTRL_POWER_OFF __BIT(1) #define AS3722_RESET_CTRL_FORCE_RESET __BIT(0) #define AS3722_WATCHDOG_CTRL_REG 0x38 #define AS3722_WATCHDOG_CTRL_MODE __BITS(2,1) #define AS3722_WATCHDOG_CTRL_ON __BIT(0) #define AS3722_WATCHDOG_TIMER_REG 0x46 #define AS3722_WATCHDOG_TIMER_TIMER __BITS(6,0) #define AS3722_WATCHDOG_SIGNAL_REG 0x48 #define AS3722_WATCHDOG_SIGNAL_PWM_DIV __BITS(7,6) #define AS3722_WATCHDOG_SIGNAL_SW_SIG __BIT(0) #define AS3722_SDCONTROL_REG 0x4d #define AS3722_SDCONTROL_SD4_ENABLE __BIT(4) #define AS3722_LDOCONTROL0_REG 0x4e #define AS3722_RTC_CONTROL_REG 0x60 #define AS3722_RTC_CONTROL_RTC_ON __BIT(2) #define AS3722_RTC_SECOND_REG 0x61 #define AS3722_RTC_MINUTE_REG 0x62 #define AS3722_RTC_HOUR_REG 0x63 #define AS3722_RTC_DAY_REG 0x64 #define AS3722_RTC_MONTH_REG 0x65 #define AS3722_RTC_YEAR_REG 0x66 #define AS3722_RTC_ACCESS_REG 0x6f #define AS3722_ASIC_ID1_REG 0x90 #define AS3722_ASIC_ID2_REG 0x91 #define AS3722_FUSE7_REG 0xa7 #define AS3722_FUSE7_SD0_V_MINUS_200MV __BIT(4) struct as3722_softc { device_t sc_dev; i2c_tag_t sc_i2c; i2c_addr_t sc_addr; #ifdef FDT int sc_phandle; #endif int sc_flags; #define AS3722_FLAG_SD0_V_MINUS_200MV 0x01 struct sysmon_wdog sc_smw; struct todr_chip_handle sc_todr; }; #ifdef FDT static int as3722reg_set_voltage_sd0(device_t, u_int, u_int); static int as3722reg_get_voltage_sd0(device_t, u_int *); static int as3722reg_set_voltage_sd4(device_t, u_int, u_int); static int as3722reg_get_voltage_sd4(device_t, u_int *); static int as3722reg_set_voltage_ldo(device_t, u_int, u_int); static int as3722reg_get_voltage_ldo(device_t, u_int *); static const struct as3722regdef { const char *name; u_int vsel_reg; u_int vsel_mask; u_int enable_reg; u_int enable_mask; int (*set)(device_t, u_int, u_int); int (*get)(device_t, u_int *); } as3722regdefs[] = { { .name = "sd0", .vsel_reg = AS3722_SD0_VOLTAGE_REG, .vsel_mask = 0x7f, .set = as3722reg_set_voltage_sd0, .get = as3722reg_get_voltage_sd0 }, { .name = "sd4", .vsel_reg = AS3722_SD4_VOLTAGE_REG, .vsel_mask = 0x7f, .enable_reg = AS3722_SDCONTROL_REG, .enable_mask = AS3722_SDCONTROL_SD4_ENABLE, .set = as3722reg_set_voltage_sd4, .get = as3722reg_get_voltage_sd4 }, { .name = "ldo6", .vsel_reg = AS3722_LDO6_VOLTAGE_REG, .vsel_mask = 0x7f, .enable_reg = AS3722_LDOCONTROL0_REG, .enable_mask = 0x40, .set = as3722reg_set_voltage_ldo, .get = as3722reg_get_voltage_ldo }, }; struct as3722reg_softc { device_t sc_dev; int sc_phandle; const struct as3722regdef *sc_regdef; }; struct as3722reg_attach_args { const struct as3722regdef *reg_def; int reg_phandle; }; #endif #define AS3722_WATCHDOG_DEFAULT_PERIOD 10 static int as3722_match(device_t, cfdata_t, void *); static void as3722_attach(device_t, device_t, void *); static void as3722_wdt_attach(struct as3722_softc *); static int as3722_wdt_setmode(struct sysmon_wdog *); static int as3722_wdt_tickle(struct sysmon_wdog *); static void as3722_rtc_attach(struct as3722_softc *); static int as3722_rtc_gettime(todr_chip_handle_t, struct clock_ymdhms *); static int as3722_rtc_settime(todr_chip_handle_t, struct clock_ymdhms *); #ifdef FDT static void as3722_regulator_attach(struct as3722_softc *); static int as3722reg_match(device_t, cfdata_t, void *); static void as3722reg_attach(device_t, device_t, void *); static int as3722reg_acquire(device_t); static void as3722reg_release(device_t); static int as3722reg_enable(device_t, bool); static int as3722reg_set_voltage(device_t, u_int, u_int); static int as3722reg_get_voltage(device_t, u_int *); static struct fdtbus_regulator_controller_func as3722reg_funcs = { .acquire = as3722reg_acquire, .release = as3722reg_release, .enable = as3722reg_enable, .set_voltage = as3722reg_set_voltage, .get_voltage = as3722reg_get_voltage, }; static void as3722_power_reset(device_t); static void as3722_power_poweroff(device_t); static struct fdtbus_power_controller_func as3722power_funcs = { .reset = as3722_power_reset, .poweroff = as3722_power_poweroff, }; #endif static int as3722_read(struct as3722_softc *, uint8_t, uint8_t *, int); static int as3722_write(struct as3722_softc *, uint8_t, uint8_t, int); static int as3722_set_clear(struct as3722_softc *, uint8_t, uint8_t, uint8_t, int); CFATTACH_DECL_NEW(as3722pmic, sizeof(struct as3722_softc), as3722_match, as3722_attach, NULL, NULL); #ifdef FDT CFATTACH_DECL_NEW(as3722reg, sizeof(struct as3722reg_softc), as3722reg_match, as3722reg_attach, NULL, NULL); #endif static const struct device_compatible_entry compat_data[] = { { .compat = "ams,as3722" }, DEVICE_COMPAT_EOL }; static int as3722_match(device_t parent, cfdata_t match, void *aux) { struct i2c_attach_args *ia = aux; uint8_t reg, id1; int error, match_result; if (iic_use_direct_match(ia, match, compat_data, &match_result)) return match_result; if (ia->ia_addr != AS3722_I2C_ADDR) return 0; iic_acquire_bus(ia->ia_tag, 0); reg = AS3722_ASIC_ID1_REG; error = iic_exec(ia->ia_tag, I2C_OP_READ_WITH_STOP, ia->ia_addr, ®, 1, &id1, 1, 0); iic_release_bus(ia->ia_tag, 0); if (error == 0 && id1 == 0x0c) return I2C_MATCH_ADDRESS_AND_PROBE; return 0; } static void as3722_attach(device_t parent, device_t self, void *aux) { struct as3722_softc * const sc = device_private(self); struct i2c_attach_args *ia = aux; sc->sc_dev = self; sc->sc_i2c = ia->ia_tag; sc->sc_addr = ia->ia_addr; #ifdef FDT if (devhandle_type(device_handle(self)) == DEVHANDLE_TYPE_OF) { sc->sc_phandle = devhandle_to_of(device_handle(self)); } #endif aprint_naive("\n"); aprint_normal(": AMS AS3722\n"); as3722_wdt_attach(sc); as3722_rtc_attach(sc); #ifdef FDT as3722_regulator_attach(sc); fdtbus_register_power_controller(self, sc->sc_phandle, &as3722power_funcs); #endif } static void as3722_wdt_attach(struct as3722_softc *sc) { int error; iic_acquire_bus(sc->sc_i2c, 0); error = as3722_write(sc, AS3722_GPIO0_CTRL_REG, __SHIFTIN(AS3722_GPIO0_CTRL_IOSF_GPIO, AS3722_GPIO0_CTRL_IOSF) | __SHIFTIN(AS3722_GPIO0_CTRL_MODE_PULLDOWN, AS3722_GPIO0_CTRL_MODE), 0); error += as3722_set_clear(sc, AS3722_WATCHDOG_CTRL_REG, __SHIFTIN(1, AS3722_WATCHDOG_CTRL_MODE), 0, 0); iic_release_bus(sc->sc_i2c, 0); if (error) { aprint_error_dev(sc->sc_dev, "couldn't setup watchdog\n"); return; } sc->sc_smw.smw_name = device_xname(sc->sc_dev); sc->sc_smw.smw_cookie = sc; sc->sc_smw.smw_setmode = as3722_wdt_setmode; sc->sc_smw.smw_tickle = as3722_wdt_tickle; sc->sc_smw.smw_period = AS3722_WATCHDOG_DEFAULT_PERIOD; aprint_normal_dev(sc->sc_dev, "default watchdog period is %u seconds\n", sc->sc_smw.smw_period); if (sysmon_wdog_register(&sc->sc_smw) != 0) aprint_error_dev(sc->sc_dev, "couldn't register with sysmon\n"); } static void as3722_rtc_attach(struct as3722_softc *sc) { int error; iic_acquire_bus(sc->sc_i2c, 0); error = as3722_set_clear(sc, AS3722_RTC_CONTROL_REG, AS3722_RTC_CONTROL_RTC_ON, 0, 0); iic_release_bus(sc->sc_i2c, 0); if (error) { aprint_error_dev(sc->sc_dev, "couldn't setup RTC\n"); return; } sc->sc_todr.todr_gettime_ymdhms = as3722_rtc_gettime; sc->sc_todr.todr_settime_ymdhms = as3722_rtc_settime; sc->sc_todr.todr_dev = sc->sc_dev; todr_attach(&sc->sc_todr); } static int as3722_read(struct as3722_softc *sc, uint8_t reg, uint8_t *val, int flags) { return iic_exec(sc->sc_i2c, I2C_OP_READ_WITH_STOP, sc->sc_addr, ®, 1, val, 1, flags); } static int as3722_write(struct as3722_softc *sc, uint8_t reg, uint8_t val, int flags) { uint8_t buf[2] = { reg, val }; return iic_exec(sc->sc_i2c, I2C_OP_WRITE_WITH_STOP, sc->sc_addr, NULL, 0, buf, 2, flags); } static int as3722_set_clear(struct as3722_softc *sc, uint8_t reg, uint8_t set, uint8_t clr, int flags) { uint8_t old, new; int error; error = as3722_read(sc, reg, &old, flags); if (error) { return error; } new = set | (old & ~clr); return as3722_write(sc, reg, new, flags); } static int as3722_wdt_setmode(struct sysmon_wdog *smw) { struct as3722_softc * const sc = smw->smw_cookie; int error; const int flags = 0; if ((smw->smw_mode & WDOG_MODE_MASK) == WDOG_MODE_DISARMED) { iic_acquire_bus(sc->sc_i2c, flags); error = as3722_set_clear(sc, AS3722_WATCHDOG_CTRL_REG, 0, AS3722_WATCHDOG_CTRL_ON, flags); iic_release_bus(sc->sc_i2c, flags); return error; } if (smw->smw_period == WDOG_PERIOD_DEFAULT) { smw->smw_period = AS3722_WATCHDOG_DEFAULT_PERIOD; } if (smw->smw_period < 1 || smw->smw_period > 128) { return EINVAL; } sc->sc_smw.smw_period = smw->smw_period; iic_acquire_bus(sc->sc_i2c, flags); error = as3722_set_clear(sc, AS3722_WATCHDOG_TIMER_REG, __SHIFTIN(sc->sc_smw.smw_period - 1, AS3722_WATCHDOG_TIMER_TIMER), AS3722_WATCHDOG_TIMER_TIMER, flags); if (error == 0) { error = as3722_set_clear(sc, AS3722_WATCHDOG_CTRL_REG, AS3722_WATCHDOG_CTRL_ON, 0, flags); } iic_release_bus(sc->sc_i2c, flags); return error; } static int as3722_wdt_tickle(struct sysmon_wdog *smw) { struct as3722_softc * const sc = smw->smw_cookie; int error; const int flags = 0; iic_acquire_bus(sc->sc_i2c, flags); error = as3722_set_clear(sc, AS3722_WATCHDOG_SIGNAL_REG, AS3722_WATCHDOG_SIGNAL_SW_SIG, 0, flags); iic_release_bus(sc->sc_i2c, flags); return error; } static int as3722_rtc_gettime(todr_chip_handle_t tch, struct clock_ymdhms *dt) { struct as3722_softc * const sc = device_private(tch->todr_dev); uint8_t buf[6]; int error = 0; const int flags = 0; iic_acquire_bus(sc->sc_i2c, flags); error += as3722_read(sc, AS3722_RTC_SECOND_REG, &buf[0], flags); error += as3722_read(sc, AS3722_RTC_MINUTE_REG, &buf[1], flags); error += as3722_read(sc, AS3722_RTC_HOUR_REG, &buf[2], flags); error += as3722_read(sc, AS3722_RTC_DAY_REG, &buf[3], flags); error += as3722_read(sc, AS3722_RTC_MONTH_REG, &buf[4], flags); error += as3722_read(sc, AS3722_RTC_YEAR_REG, &buf[5], flags); iic_release_bus(sc->sc_i2c, flags); if (error) return error; dt->dt_sec = bcdtobin(buf[0] & 0x7f); dt->dt_min = bcdtobin(buf[1] & 0x7f); dt->dt_hour = bcdtobin(buf[2] & 0x3f); dt->dt_day = bcdtobin(buf[3] & 0x3f); dt->dt_mon = bcdtobin(buf[4] & 0x1f) - 1; dt->dt_year = AS3722_START_YEAR + bcdtobin(buf[5] & 0x7f); dt->dt_wday = 0; return 0; } static int as3722_rtc_settime(todr_chip_handle_t tch, struct clock_ymdhms *dt) { struct as3722_softc * const sc = device_private(tch->todr_dev); uint8_t buf[6]; int error = 0; if (dt->dt_year < AS3722_START_YEAR) return EINVAL; buf[0] = bintobcd(dt->dt_sec) & 0x7f; buf[1] = bintobcd(dt->dt_min) & 0x7f; buf[2] = bintobcd(dt->dt_hour) & 0x3f; buf[3] = bintobcd(dt->dt_day) & 0x3f; buf[4] = bintobcd(dt->dt_mon + 1) & 0x1f; buf[5] = bintobcd(dt->dt_year - AS3722_START_YEAR) & 0x7f; const int flags = 0; iic_acquire_bus(sc->sc_i2c, flags); error += as3722_write(sc, AS3722_RTC_SECOND_REG, buf[0], flags); error += as3722_write(sc, AS3722_RTC_MINUTE_REG, buf[1], flags); error += as3722_write(sc, AS3722_RTC_HOUR_REG, buf[2], flags); error += as3722_write(sc, AS3722_RTC_DAY_REG, buf[3], flags); error += as3722_write(sc, AS3722_RTC_MONTH_REG, buf[4], flags); error += as3722_write(sc, AS3722_RTC_YEAR_REG, buf[5], flags); iic_release_bus(sc->sc_i2c, flags); return error; } #ifdef FDT static void as3722_regulator_attach(struct as3722_softc *sc) { struct as3722reg_attach_args raa; int phandle, child; int error; const int flags = 0; uint8_t tmp; iic_acquire_bus(sc->sc_i2c, flags); error = as3722_read(sc, AS3722_FUSE7_REG, &tmp, flags); iic_release_bus(sc->sc_i2c, flags); if (error != 0) { aprint_error_dev(sc->sc_dev, "failed to read Fuse7: %d\n", error); return; } if (tmp & AS3722_FUSE7_SD0_V_MINUS_200MV) sc->sc_flags |= AS3722_FLAG_SD0_V_MINUS_200MV; phandle = of_find_firstchild_byname(sc->sc_phandle, "regulators"); if (phandle <= 0) return; for (int i = 0; i < __arraycount(as3722regdefs); i++) { const struct as3722regdef *regdef = &as3722regdefs[i]; child = of_find_firstchild_byname(phandle, regdef->name); if (child <= 0) continue; raa.reg_def = regdef; raa.reg_phandle = child; config_found(sc->sc_dev, &raa, NULL, CFARGS_NONE); } } static int as3722reg_match(device_t parent, cfdata_t match, void *aux) { return 1; } static void as3722reg_attach(device_t parent, device_t self, void *aux) { struct as3722reg_softc *sc = device_private(self); struct as3722reg_attach_args *raa = aux; char *name = NULL; int len; sc->sc_dev = self; sc->sc_phandle = raa->reg_phandle; sc->sc_regdef = raa->reg_def; fdtbus_register_regulator_controller(self, sc->sc_phandle, &as3722reg_funcs); len = OF_getproplen(sc->sc_phandle, "regulator-name"); if (len > 0) { name = kmem_zalloc(len, KM_SLEEP); OF_getprop(sc->sc_phandle, "regulator-name", name, len); } aprint_naive("\n"); if (name) aprint_normal(": %s\n", name); else aprint_normal("\n"); if (name) kmem_free(name, len); } static int as3722reg_acquire(device_t dev) { return 0; } static void as3722reg_release(device_t dev) { } static int as3722reg_enable(device_t dev, bool enable) { struct as3722reg_softc *sc = device_private(dev); struct as3722_softc *asc = device_private(device_parent(dev)); const struct as3722regdef *regdef = sc->sc_regdef; const int flags = 0; int error; if (!regdef->enable_mask) return enable ? 0 : EINVAL; iic_acquire_bus(asc->sc_i2c, flags); if (enable) error = as3722_set_clear(asc, regdef->enable_reg, regdef->enable_mask, 0, flags); else error = as3722_set_clear(asc, regdef->enable_reg, 0, regdef->enable_mask, flags); iic_release_bus(asc->sc_i2c, flags); return error; } static int as3722reg_set_voltage_ldo(device_t dev, u_int min_uvol, u_int max_uvol) { struct as3722reg_softc *sc = device_private(dev); struct as3722_softc *asc = device_private(device_parent(dev)); const struct as3722regdef *regdef = sc->sc_regdef; const int flags = 0; uint8_t set_v = 0x00; u_int uvol; int error; for (uint8_t v = 0x01; v <= 0x24; v++) { uvol = 800000 + (v * 25000); if (uvol >= min_uvol && uvol <= max_uvol) { set_v = v; goto done; } } for (uint8_t v = 0x40; v <= 0x7f; v++) { uvol = 1725000 + ((v - 0x40) * 25000); if (uvol >= min_uvol && uvol <= max_uvol) { set_v = v; goto done; } } if (set_v == 0) return ERANGE; done: iic_acquire_bus(asc->sc_i2c, flags); error = as3722_set_clear(asc, regdef->vsel_reg, set_v, regdef->vsel_mask, flags); iic_release_bus(asc->sc_i2c, flags); return error; } static int as3722reg_get_voltage_ldo(device_t dev, u_int *puvol) { struct as3722reg_softc *sc = device_private(dev); struct as3722_softc *asc = device_private(device_parent(dev)); const struct as3722regdef *regdef = sc->sc_regdef; const int flags = 0; uint8_t v; int error; iic_acquire_bus(asc->sc_i2c, flags); error = as3722_read(asc, regdef->vsel_reg, &v, flags); iic_release_bus(asc->sc_i2c, flags); if (error != 0) return error; v &= regdef->vsel_mask; if (v == 0) *puvol = 0; /* LDO off */ else if (v >= 0x01 && v <= 0x24) *puvol = 800000 + (v * 25000); else if (v >= 0x40 && v <= 0x7f) *puvol = 1725000 + ((v - 0x40) * 25000); else return EINVAL; return 0; } static int as3722reg_set_voltage_sd0(device_t dev, u_int min_uvol, u_int max_uvol) { struct as3722reg_softc *sc = device_private(dev); struct as3722_softc *asc = device_private(device_parent(dev)); const struct as3722regdef *regdef = sc->sc_regdef; const int flags = 0; uint8_t set_v = 0x00; u_int uvol; int error; if (asc->sc_flags & AS3722_FLAG_SD0_V_MINUS_200MV) { for (uint8_t v = 0x01; v <= 0x6e; v++) { uvol = 400000 + (v * 10000); if (uvol >= min_uvol && uvol <= max_uvol) { set_v = v; goto done; } } } else { for (uint8_t v = 0x01; v <= 0x5a; v++) { uvol = 600000 + (v * 10000); if (uvol >= min_uvol && uvol <= max_uvol) { set_v = v; goto done; } } } if (set_v == 0) return ERANGE; done: iic_acquire_bus(asc->sc_i2c, flags); error = as3722_set_clear(asc, regdef->vsel_reg, set_v, regdef->vsel_mask, flags); iic_release_bus(asc->sc_i2c, flags); return error; } static int as3722reg_get_voltage_sd0(device_t dev, u_int *puvol) { struct as3722reg_softc *sc = device_private(dev); struct as3722_softc *asc = device_private(device_parent(dev)); const struct as3722regdef *regdef = sc->sc_regdef; const int flags = 0; uint8_t v; int error; iic_acquire_bus(asc->sc_i2c, flags); error = as3722_read(asc, regdef->vsel_reg, &v, flags); iic_release_bus(asc->sc_i2c, flags); if (error != 0) return error; v &= regdef->vsel_mask; if (v == 0) { *puvol = 0; /* DC/DC powered down */ return 0; } if (asc->sc_flags & AS3722_FLAG_SD0_V_MINUS_200MV) { if (v >= 0x01 && v <= 0x6e) { *puvol = 400000 + (v * 10000); return 0; } } else { if (v >= 0x01 && v <= 0x5a) { *puvol = 600000 + (v * 10000); return 0; } } return EINVAL; } static int as3722reg_set_voltage_sd4(device_t dev, u_int min_uvol, u_int max_uvol) { struct as3722reg_softc *sc = device_private(dev); struct as3722_softc *asc = device_private(device_parent(dev)); const struct as3722regdef *regdef = sc->sc_regdef; const int flags = 0; uint8_t set_v = 0x00; u_int uvol; int error; for (uint8_t v = 0x01; v <= 0x40; v++) { uvol = 600000 + (v * 12500); if (uvol >= min_uvol && uvol <= max_uvol) { set_v = v; goto done; } } for (uint8_t v = 0x41; v <= 0x70; v++) { uvol = 1400000 + ((v - 0x40) * 25000); if (uvol >= min_uvol && uvol <= max_uvol) { set_v = v; goto done; } } for (uint8_t v = 0x71; v <= 0x7f; v++) { uvol = 2600000 + ((v - 0x70) * 50000); if (uvol >= min_uvol && uvol <= max_uvol) { set_v = v; goto done; } } if (set_v == 0) return ERANGE; done: iic_acquire_bus(asc->sc_i2c, flags); error = as3722_set_clear(asc, regdef->vsel_reg, set_v, regdef->vsel_mask, flags); iic_release_bus(asc->sc_i2c, flags); return error; } static int as3722reg_get_voltage_sd4(device_t dev, u_int *puvol) { struct as3722reg_softc *sc = device_private(dev); struct as3722_softc *asc = device_private(device_parent(dev)); const struct as3722regdef *regdef = sc->sc_regdef; const int flags = 0; uint8_t v; int error; iic_acquire_bus(asc->sc_i2c, flags); error = as3722_read(asc, regdef->vsel_reg, &v, flags); iic_release_bus(asc->sc_i2c, flags); if (error != 0) return error; v &= regdef->vsel_mask; if (v == 0) *puvol = 0; /* DC/DC powered down */ else if (v >= 0x01 && v <= 0x40) *puvol = 600000 + (v * 12500); else if (v >= 0x41 && v <= 0x70) *puvol = 1400000 + (v - 0x40) * 25000; else if (v >= 0x71 && v <= 0x7f) *puvol = 2600000 + (v - 0x70) * 50000; else return EINVAL; return 0; } static int as3722reg_set_voltage(device_t dev, u_int min_uvol, u_int max_uvol) { struct as3722reg_softc *sc = device_private(dev); const struct as3722regdef *regdef = sc->sc_regdef; return regdef->set(dev, min_uvol, max_uvol); } static int as3722reg_get_voltage(device_t dev, u_int *puvol) { struct as3722reg_softc *sc = device_private(dev); const struct as3722regdef *regdef = sc->sc_regdef; return regdef->get(dev, puvol); } static void as3722_power_reset(device_t dev) { delay(1000000); as3722_reboot(dev); } static void as3722_power_poweroff(device_t dev) { delay(1000000); as3722_poweroff(dev); } #endif int as3722_poweroff(device_t dev) { struct as3722_softc * const sc = device_private(dev); int error; error = iic_acquire_bus(sc->sc_i2c, 0); if (error == 0) { error = as3722_write(sc, AS3722_RESET_CTRL_REG, AS3722_RESET_CTRL_POWER_OFF, 0); iic_release_bus(sc->sc_i2c, 0); } if (error) { device_printf(dev, "WARNING: unable to power off, error %d\n", error); } return error; } int as3722_reboot(device_t dev) { struct as3722_softc * const sc = device_private(dev); int error; error = iic_acquire_bus(sc->sc_i2c, 0); if (error == 0) { error = as3722_write(sc, AS3722_RESET_CTRL_REG, AS3722_RESET_CTRL_FORCE_RESET, 0); iic_release_bus(sc->sc_i2c, 0); } if (error) { device_printf(dev, "WARNING: unable to reboot, error %d\n", error); } return error; }