mirror of
https://github.com/freebsd/freebsd-src
synced 2024-09-06 17:18:32 +00:00
![Emmanuel Vadot](/assets/img/avatar_default.png)
We've removed kernel option EXT_RESOURCES almost two years ago. While it was ok to have some code under a common 'extres' subdirectory at first, we now have a lot of consumer of it and we made it mandatory so no need to have it under a cryptic name. Reviewed by: emaste, imp Sponsored by: Beckhoff Automation GmbH & Co. KG Differential Revision: https://reviews.freebsd.org/D43194
710 lines
19 KiB
C
710 lines
19 KiB
C
/*-
|
|
* Copyright 2016 Michal Meloun <mmel@FreeBSD.org>
|
|
* 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 AUTHOR 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 AUTHOR 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 <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/bus.h>
|
|
#include <sys/gpio.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/module.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/rman.h>
|
|
#include <sys/sx.h>
|
|
|
|
#include <machine/bus.h>
|
|
|
|
#include <dev/regulator/regulator.h>
|
|
#include <dev/gpio/gpiobusvar.h>
|
|
|
|
#include <dt-bindings/mfd/as3722.h>
|
|
|
|
#include "as3722.h"
|
|
|
|
MALLOC_DEFINE(M_AS3722_REG, "AS3722 regulator", "AS3722 power regulator");
|
|
|
|
#define DIV_ROUND_UP(n,d) howmany(n, d)
|
|
|
|
enum as3722_reg_id {
|
|
AS3722_REG_ID_SD0,
|
|
AS3722_REG_ID_SD1,
|
|
AS3722_REG_ID_SD2,
|
|
AS3722_REG_ID_SD3,
|
|
AS3722_REG_ID_SD4,
|
|
AS3722_REG_ID_SD5,
|
|
AS3722_REG_ID_SD6,
|
|
AS3722_REG_ID_LDO0,
|
|
AS3722_REG_ID_LDO1,
|
|
AS3722_REG_ID_LDO2,
|
|
AS3722_REG_ID_LDO3,
|
|
AS3722_REG_ID_LDO4,
|
|
AS3722_REG_ID_LDO5,
|
|
AS3722_REG_ID_LDO6,
|
|
AS3722_REG_ID_LDO7,
|
|
AS3722_REG_ID_LDO9,
|
|
AS3722_REG_ID_LDO10,
|
|
AS3722_REG_ID_LDO11,
|
|
};
|
|
|
|
/* Regulator HW definition. */
|
|
struct reg_def {
|
|
intptr_t id; /* ID */
|
|
char *name; /* Regulator name */
|
|
char *supply_name; /* Source property name */
|
|
uint8_t volt_reg;
|
|
uint8_t volt_vsel_mask;
|
|
uint8_t enable_reg;
|
|
uint8_t enable_mask;
|
|
uint8_t ext_enable_reg;
|
|
uint8_t ext_enable_mask;
|
|
struct regulator_range *ranges;
|
|
int nranges;
|
|
};
|
|
|
|
struct as3722_reg_sc {
|
|
struct regnode *regnode;
|
|
struct as3722_softc *base_sc;
|
|
struct reg_def *def;
|
|
phandle_t xref;
|
|
|
|
struct regnode_std_param *param;
|
|
int ext_control;
|
|
int enable_tracking;
|
|
|
|
int enable_usec;
|
|
};
|
|
|
|
static struct regulator_range as3722_sd016_ranges[] = {
|
|
REG_RANGE_INIT(0x00, 0x00, 0, 0),
|
|
REG_RANGE_INIT(0x01, 0x5A, 610000, 10000),
|
|
};
|
|
|
|
static struct regulator_range as3722_sd0_lv_ranges[] = {
|
|
REG_RANGE_INIT(0x00, 0x00, 0, 0),
|
|
REG_RANGE_INIT(0x01, 0x6E, 410000, 10000),
|
|
};
|
|
|
|
static struct regulator_range as3722_sd_ranges[] = {
|
|
REG_RANGE_INIT(0x00, 0x00, 0, 0),
|
|
REG_RANGE_INIT(0x01, 0x40, 612500, 12500),
|
|
REG_RANGE_INIT(0x41, 0x70, 1425000, 25000),
|
|
REG_RANGE_INIT(0x71, 0x7F, 2650000, 50000),
|
|
};
|
|
|
|
static struct regulator_range as3722_ldo3_ranges[] = {
|
|
REG_RANGE_INIT(0x00, 0x00, 0, 0),
|
|
REG_RANGE_INIT(0x01, 0x2D, 620000, 20000),
|
|
};
|
|
|
|
static struct regulator_range as3722_ldo_ranges[] = {
|
|
REG_RANGE_INIT(0x00, 0x00, 0, 0),
|
|
REG_RANGE_INIT(0x01, 0x24, 825000, 25000),
|
|
REG_RANGE_INIT(0x40, 0x7F, 1725000, 25000),
|
|
};
|
|
|
|
static struct reg_def as3722s_def[] = {
|
|
{
|
|
.id = AS3722_REG_ID_SD0,
|
|
.name = "sd0",
|
|
.volt_reg = AS3722_SD0_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_SD_VSEL_MASK,
|
|
.enable_reg = AS3722_SD_CONTROL,
|
|
.enable_mask = AS3722_SDN_CTRL(0),
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL1,
|
|
.ext_enable_mask = AS3722_SD0_EXT_ENABLE_MASK,
|
|
.ranges = as3722_sd016_ranges,
|
|
.nranges = nitems(as3722_sd016_ranges),
|
|
},
|
|
{
|
|
.id = AS3722_REG_ID_SD1,
|
|
.name = "sd1",
|
|
.volt_reg = AS3722_SD1_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_SD_VSEL_MASK,
|
|
.enable_reg = AS3722_SD_CONTROL,
|
|
.enable_mask = AS3722_SDN_CTRL(1),
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL1,
|
|
.ext_enable_mask = AS3722_SD1_EXT_ENABLE_MASK,
|
|
.ranges = as3722_sd_ranges,
|
|
.nranges = nitems(as3722_sd_ranges),
|
|
},
|
|
{
|
|
.id = AS3722_REG_ID_SD2,
|
|
.name = "sd2",
|
|
.supply_name = "vsup-sd2",
|
|
.volt_reg = AS3722_SD2_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_SD_VSEL_MASK,
|
|
.enable_reg = AS3722_SD_CONTROL,
|
|
.enable_mask = AS3722_SDN_CTRL(2),
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL1,
|
|
.ext_enable_mask = AS3722_SD2_EXT_ENABLE_MASK,
|
|
.ranges = as3722_sd_ranges,
|
|
.nranges = nitems(as3722_sd_ranges),
|
|
},
|
|
{
|
|
.id = AS3722_REG_ID_SD3,
|
|
.name = "sd3",
|
|
.supply_name = "vsup-sd3",
|
|
.volt_reg = AS3722_SD3_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_SD_VSEL_MASK,
|
|
.enable_reg = AS3722_SD_CONTROL,
|
|
.enable_mask = AS3722_SDN_CTRL(3),
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL1,
|
|
.ext_enable_mask = AS3722_SD3_EXT_ENABLE_MASK,
|
|
.ranges = as3722_sd_ranges,
|
|
.nranges = nitems(as3722_sd_ranges),
|
|
},
|
|
{
|
|
.id = AS3722_REG_ID_SD4,
|
|
.name = "sd4",
|
|
.supply_name = "vsup-sd4",
|
|
.volt_reg = AS3722_SD4_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_SD_VSEL_MASK,
|
|
.enable_reg = AS3722_SD_CONTROL,
|
|
.enable_mask = AS3722_SDN_CTRL(4),
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL2,
|
|
.ext_enable_mask = AS3722_SD4_EXT_ENABLE_MASK,
|
|
.ranges = as3722_sd_ranges,
|
|
.nranges = nitems(as3722_sd_ranges),
|
|
},
|
|
{
|
|
.id = AS3722_REG_ID_SD5,
|
|
.name = "sd5",
|
|
.supply_name = "vsup-sd5",
|
|
.volt_reg = AS3722_SD5_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_SD_VSEL_MASK,
|
|
.enable_reg = AS3722_SD_CONTROL,
|
|
.enable_mask = AS3722_SDN_CTRL(5),
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL2,
|
|
.ext_enable_mask = AS3722_SD5_EXT_ENABLE_MASK,
|
|
.ranges = as3722_sd_ranges,
|
|
.nranges = nitems(as3722_sd_ranges),
|
|
},
|
|
{
|
|
.id = AS3722_REG_ID_SD6,
|
|
.name = "sd6",
|
|
.volt_reg = AS3722_SD6_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_SD_VSEL_MASK,
|
|
.enable_reg = AS3722_SD_CONTROL,
|
|
.enable_mask = AS3722_SDN_CTRL(6),
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL2,
|
|
.ext_enable_mask = AS3722_SD6_EXT_ENABLE_MASK,
|
|
.ranges = as3722_sd016_ranges,
|
|
.nranges = nitems(as3722_sd016_ranges),
|
|
},
|
|
{
|
|
.id = AS3722_REG_ID_LDO0,
|
|
.name = "ldo0",
|
|
.supply_name = "vin-ldo0",
|
|
.volt_reg = AS3722_LDO0_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_LDO0_VSEL_MASK,
|
|
.enable_reg = AS3722_LDO_CONTROL0,
|
|
.enable_mask = AS3722_LDO0_CTRL,
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL3,
|
|
.ext_enable_mask = AS3722_LDO0_EXT_ENABLE_MASK,
|
|
.ranges = as3722_ldo_ranges,
|
|
.nranges = nitems(as3722_ldo_ranges),
|
|
},
|
|
{
|
|
.id = AS3722_REG_ID_LDO1,
|
|
.name = "ldo1",
|
|
.supply_name = "vin-ldo1-6",
|
|
.volt_reg = AS3722_LDO1_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
|
|
.enable_reg = AS3722_LDO_CONTROL0,
|
|
.enable_mask = AS3722_LDO1_CTRL,
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL3,
|
|
.ext_enable_mask = AS3722_LDO1_EXT_ENABLE_MASK,
|
|
.ranges = as3722_ldo_ranges,
|
|
.nranges = nitems(as3722_ldo_ranges),
|
|
},
|
|
{
|
|
.id = AS3722_REG_ID_LDO2,
|
|
.name = "ldo2",
|
|
.supply_name = "vin-ldo2-5-7",
|
|
.volt_reg = AS3722_LDO2_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
|
|
.enable_reg = AS3722_LDO_CONTROL0,
|
|
.enable_mask = AS3722_LDO2_CTRL,
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL3,
|
|
.ext_enable_mask = AS3722_LDO2_EXT_ENABLE_MASK,
|
|
.ranges = as3722_ldo_ranges,
|
|
.nranges = nitems(as3722_ldo_ranges),
|
|
},
|
|
{
|
|
.id = AS3722_REG_ID_LDO3,
|
|
.name = "ldo3",
|
|
.supply_name = "vin-ldo3-4",
|
|
.volt_reg = AS3722_LDO3_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_LDO3_VSEL_MASK,
|
|
.enable_reg = AS3722_LDO_CONTROL0,
|
|
.enable_mask = AS3722_LDO3_CTRL,
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL3,
|
|
.ext_enable_mask = AS3722_LDO3_EXT_ENABLE_MASK,
|
|
.ranges = as3722_ldo3_ranges,
|
|
.nranges = nitems(as3722_ldo3_ranges),
|
|
},
|
|
{
|
|
.id = AS3722_REG_ID_LDO4,
|
|
.name = "ldo4",
|
|
.supply_name = "vin-ldo3-4",
|
|
.volt_reg = AS3722_LDO4_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
|
|
.enable_reg = AS3722_LDO_CONTROL0,
|
|
.enable_mask = AS3722_LDO4_CTRL,
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL4,
|
|
.ext_enable_mask = AS3722_LDO4_EXT_ENABLE_MASK,
|
|
.ranges = as3722_ldo_ranges,
|
|
.nranges = nitems(as3722_ldo_ranges),
|
|
},
|
|
{
|
|
.id = AS3722_REG_ID_LDO5,
|
|
.name = "ldo5",
|
|
.supply_name = "vin-ldo2-5-7",
|
|
.volt_reg = AS3722_LDO5_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
|
|
.enable_reg = AS3722_LDO_CONTROL0,
|
|
.enable_mask = AS3722_LDO5_CTRL,
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL4,
|
|
.ext_enable_mask = AS3722_LDO5_EXT_ENABLE_MASK,
|
|
.ranges = as3722_ldo_ranges,
|
|
.nranges = nitems(as3722_ldo_ranges),
|
|
},
|
|
{
|
|
.id = AS3722_REG_ID_LDO6,
|
|
.name = "ldo6",
|
|
.supply_name = "vin-ldo1-6",
|
|
.volt_reg = AS3722_LDO6_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
|
|
.enable_reg = AS3722_LDO_CONTROL0,
|
|
.enable_mask = AS3722_LDO6_CTRL,
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL4,
|
|
.ext_enable_mask = AS3722_LDO6_EXT_ENABLE_MASK,
|
|
.ranges = as3722_ldo_ranges,
|
|
.nranges = nitems(as3722_ldo_ranges),
|
|
},
|
|
{
|
|
.id = AS3722_REG_ID_LDO7,
|
|
.name = "ldo7",
|
|
.supply_name = "vin-ldo2-5-7",
|
|
.volt_reg = AS3722_LDO7_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
|
|
.enable_reg = AS3722_LDO_CONTROL0,
|
|
.enable_mask = AS3722_LDO7_CTRL,
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL4,
|
|
.ext_enable_mask = AS3722_LDO7_EXT_ENABLE_MASK,
|
|
.ranges = as3722_ldo_ranges,
|
|
.nranges = nitems(as3722_ldo_ranges),
|
|
},
|
|
{
|
|
.id = AS3722_REG_ID_LDO9,
|
|
.name = "ldo9",
|
|
.supply_name = "vin-ldo9-10",
|
|
.volt_reg = AS3722_LDO9_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
|
|
.enable_reg = AS3722_LDO_CONTROL1,
|
|
.enable_mask = AS3722_LDO9_CTRL,
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL5,
|
|
.ext_enable_mask = AS3722_LDO9_EXT_ENABLE_MASK,
|
|
.ranges = as3722_ldo_ranges,
|
|
.nranges = nitems(as3722_ldo_ranges),
|
|
},
|
|
{
|
|
.id = AS3722_REG_ID_LDO10,
|
|
.name = "ldo10",
|
|
.supply_name = "vin-ldo9-10",
|
|
.volt_reg = AS3722_LDO10_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
|
|
.enable_reg = AS3722_LDO_CONTROL1,
|
|
.enable_mask = AS3722_LDO10_CTRL,
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL5,
|
|
.ext_enable_mask = AS3722_LDO10_EXT_ENABLE_MASK,
|
|
.ranges = as3722_ldo_ranges,
|
|
.nranges = nitems(as3722_ldo_ranges),
|
|
},
|
|
{
|
|
.id = AS3722_REG_ID_LDO11,
|
|
.name = "ldo11",
|
|
.supply_name = "vin-ldo11",
|
|
.volt_reg = AS3722_LDO11_VOLTAGE,
|
|
.volt_vsel_mask = AS3722_LDO_VSEL_MASK,
|
|
.enable_reg = AS3722_LDO_CONTROL1,
|
|
.enable_mask = AS3722_LDO11_CTRL,
|
|
.ext_enable_reg = AS3722_ENABLE_CTRL5,
|
|
.ext_enable_mask = AS3722_LDO11_EXT_ENABLE_MASK,
|
|
.ranges = as3722_ldo_ranges,
|
|
.nranges = nitems(as3722_ldo_ranges),
|
|
},
|
|
};
|
|
|
|
struct as3722_regnode_init_def {
|
|
struct regnode_init_def reg_init_def;
|
|
int ext_control;
|
|
int enable_tracking;
|
|
};
|
|
|
|
static int as3722_regnode_init(struct regnode *regnode);
|
|
static int as3722_regnode_enable(struct regnode *regnode, bool enable,
|
|
int *udelay);
|
|
static int as3722_regnode_set_volt(struct regnode *regnode, int min_uvolt,
|
|
int max_uvolt, int *udelay);
|
|
static int as3722_regnode_get_volt(struct regnode *regnode, int *uvolt);
|
|
static regnode_method_t as3722_regnode_methods[] = {
|
|
/* Regulator interface */
|
|
REGNODEMETHOD(regnode_init, as3722_regnode_init),
|
|
REGNODEMETHOD(regnode_enable, as3722_regnode_enable),
|
|
REGNODEMETHOD(regnode_set_voltage, as3722_regnode_set_volt),
|
|
REGNODEMETHOD(regnode_get_voltage, as3722_regnode_get_volt),
|
|
REGNODEMETHOD_END
|
|
};
|
|
DEFINE_CLASS_1(as3722_regnode, as3722_regnode_class, as3722_regnode_methods,
|
|
sizeof(struct as3722_reg_sc), regnode_class);
|
|
|
|
static int
|
|
as3722_read_sel(struct as3722_reg_sc *sc, uint8_t *sel)
|
|
{
|
|
int rv;
|
|
|
|
rv = RD1(sc->base_sc, sc->def->volt_reg, sel);
|
|
if (rv != 0)
|
|
return (rv);
|
|
*sel &= sc->def->volt_vsel_mask;
|
|
*sel >>= ffs(sc->def->volt_vsel_mask) - 1;
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
as3722_write_sel(struct as3722_reg_sc *sc, uint8_t sel)
|
|
{
|
|
int rv;
|
|
|
|
sel <<= ffs(sc->def->volt_vsel_mask) - 1;
|
|
sel &= sc->def->volt_vsel_mask;
|
|
|
|
rv = RM1(sc->base_sc, sc->def->volt_reg,
|
|
sc->def->volt_vsel_mask, sel);
|
|
if (rv != 0)
|
|
return (rv);
|
|
return (rv);
|
|
}
|
|
|
|
static bool
|
|
as3722_sd0_is_low_voltage(struct as3722_reg_sc *sc)
|
|
{
|
|
uint8_t val;
|
|
int rv;
|
|
|
|
rv = RD1(sc->base_sc, AS3722_FUSE7, &val);
|
|
if (rv != 0)
|
|
return (rv);
|
|
return (val & AS3722_FUSE7_SD0_LOW_VOLTAGE ? true : false);
|
|
}
|
|
|
|
static int
|
|
as3722_reg_extreg_setup(struct as3722_reg_sc *sc, int ext_pwr_ctrl)
|
|
{
|
|
uint8_t val;
|
|
int rv;
|
|
|
|
val = ext_pwr_ctrl << (ffs(sc->def->ext_enable_mask) - 1);
|
|
rv = RM1(sc->base_sc, sc->def->ext_enable_reg,
|
|
sc->def->ext_enable_mask, val);
|
|
return (rv);
|
|
}
|
|
|
|
static int
|
|
as3722_reg_enable(struct as3722_reg_sc *sc)
|
|
{
|
|
int rv;
|
|
|
|
rv = RM1(sc->base_sc, sc->def->enable_reg,
|
|
sc->def->enable_mask, sc->def->enable_mask);
|
|
return (rv);
|
|
}
|
|
|
|
static int
|
|
as3722_reg_disable(struct as3722_reg_sc *sc)
|
|
{
|
|
int rv;
|
|
|
|
rv = RM1(sc->base_sc, sc->def->enable_reg,
|
|
sc->def->enable_mask, 0);
|
|
return (rv);
|
|
}
|
|
|
|
static int
|
|
as3722_regnode_init(struct regnode *regnode)
|
|
{
|
|
struct as3722_reg_sc *sc;
|
|
int rv;
|
|
|
|
sc = regnode_get_softc(regnode);
|
|
|
|
sc->enable_usec = 500;
|
|
if (sc->def->id == AS3722_REG_ID_SD0) {
|
|
if (as3722_sd0_is_low_voltage(sc)) {
|
|
sc->def->ranges = as3722_sd0_lv_ranges;
|
|
sc->def->nranges = nitems(as3722_sd0_lv_ranges);
|
|
}
|
|
sc->enable_usec = 600;
|
|
} else if (sc->def->id == AS3722_REG_ID_LDO3) {
|
|
if (sc->enable_tracking) {
|
|
rv = RM1(sc->base_sc, sc->def->volt_reg,
|
|
AS3722_LDO3_MODE_MASK,
|
|
AS3722_LDO3_MODE_PMOS_TRACKING);
|
|
if (rv < 0) {
|
|
device_printf(sc->base_sc->dev,
|
|
"LDO3 tracking failed: %d\n", rv);
|
|
return (rv);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (sc->ext_control) {
|
|
rv = as3722_reg_enable(sc);
|
|
if (rv < 0) {
|
|
device_printf(sc->base_sc->dev,
|
|
"Failed to enable %s regulator: %d\n",
|
|
sc->def->name, rv);
|
|
return (rv);
|
|
}
|
|
rv = as3722_reg_extreg_setup(sc, sc->ext_control);
|
|
if (rv < 0) {
|
|
device_printf(sc->base_sc->dev,
|
|
"%s ext control failed: %d", sc->def->name, rv);
|
|
return (rv);
|
|
}
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
static void
|
|
as3722_fdt_parse(struct as3722_softc *sc, phandle_t node, struct reg_def *def,
|
|
struct as3722_regnode_init_def *init_def)
|
|
{
|
|
int rv;
|
|
phandle_t parent, supply_node;
|
|
char prop_name[64]; /* Maximum OFW property name length. */
|
|
|
|
rv = regulator_parse_ofw_stdparam(sc->dev, node,
|
|
&init_def->reg_init_def);
|
|
|
|
rv = OF_getencprop(node, "ams,ext-control", &init_def->ext_control,
|
|
sizeof(init_def->ext_control));
|
|
if (rv <= 0)
|
|
init_def->ext_control = 0;
|
|
if (init_def->ext_control > 3) {
|
|
device_printf(sc->dev,
|
|
"Invalid value for ams,ext-control property: %d\n",
|
|
init_def->ext_control);
|
|
init_def->ext_control = 0;
|
|
}
|
|
if (OF_hasprop(node, "ams,enable-tracking"))
|
|
init_def->enable_tracking = 1;
|
|
|
|
/* Get parent supply. */
|
|
if (def->supply_name == NULL)
|
|
return;
|
|
|
|
parent = OF_parent(node);
|
|
snprintf(prop_name, sizeof(prop_name), "%s-supply",
|
|
def->supply_name);
|
|
rv = OF_getencprop(parent, prop_name, &supply_node,
|
|
sizeof(supply_node));
|
|
if (rv <= 0)
|
|
return;
|
|
supply_node = OF_node_from_xref(supply_node);
|
|
rv = OF_getprop_alloc(supply_node, "regulator-name",
|
|
(void **)&init_def->reg_init_def.parent_name);
|
|
if (rv <= 0)
|
|
init_def->reg_init_def.parent_name = NULL;
|
|
}
|
|
|
|
static struct as3722_reg_sc *
|
|
as3722_attach(struct as3722_softc *sc, phandle_t node, struct reg_def *def)
|
|
{
|
|
struct as3722_reg_sc *reg_sc;
|
|
struct as3722_regnode_init_def init_def;
|
|
struct regnode *regnode;
|
|
|
|
bzero(&init_def, sizeof(init_def));
|
|
|
|
as3722_fdt_parse(sc, node, def, &init_def);
|
|
init_def.reg_init_def.id = def->id;
|
|
init_def.reg_init_def.ofw_node = node;
|
|
regnode = regnode_create(sc->dev, &as3722_regnode_class,
|
|
&init_def.reg_init_def);
|
|
if (regnode == NULL) {
|
|
device_printf(sc->dev, "Cannot create regulator.\n");
|
|
return (NULL);
|
|
}
|
|
reg_sc = regnode_get_softc(regnode);
|
|
|
|
/* Init regulator softc. */
|
|
reg_sc->regnode = regnode;
|
|
reg_sc->base_sc = sc;
|
|
reg_sc->def = def;
|
|
reg_sc->xref = OF_xref_from_node(node);
|
|
|
|
reg_sc->param = regnode_get_stdparam(regnode);
|
|
reg_sc->ext_control = init_def.ext_control;
|
|
reg_sc->enable_tracking = init_def.enable_tracking;
|
|
|
|
regnode_register(regnode);
|
|
if (bootverbose) {
|
|
int volt, rv;
|
|
regnode_topo_slock();
|
|
rv = regnode_get_voltage(regnode, &volt);
|
|
if (rv == ENODEV) {
|
|
device_printf(sc->dev,
|
|
" Regulator %s: parent doesn't exist yet.\n",
|
|
regnode_get_name(regnode));
|
|
} else if (rv != 0) {
|
|
device_printf(sc->dev,
|
|
" Regulator %s: voltage: INVALID!!!\n",
|
|
regnode_get_name(regnode));
|
|
} else {
|
|
device_printf(sc->dev,
|
|
" Regulator %s: voltage: %d uV\n",
|
|
regnode_get_name(regnode), volt);
|
|
}
|
|
regnode_topo_unlock();
|
|
}
|
|
|
|
return (reg_sc);
|
|
}
|
|
|
|
int
|
|
as3722_regulator_attach(struct as3722_softc *sc, phandle_t node)
|
|
{
|
|
struct as3722_reg_sc *reg;
|
|
phandle_t child, rnode;
|
|
int i;
|
|
|
|
rnode = ofw_bus_find_child(node, "regulators");
|
|
if (rnode <= 0) {
|
|
device_printf(sc->dev, " Cannot find regulators subnode\n");
|
|
return (ENXIO);
|
|
}
|
|
|
|
sc->nregs = nitems(as3722s_def);
|
|
sc->regs = malloc(sizeof(struct as3722_reg_sc *) * sc->nregs,
|
|
M_AS3722_REG, M_WAITOK | M_ZERO);
|
|
|
|
/* Attach all known regulators if exist in DT. */
|
|
for (i = 0; i < sc->nregs; i++) {
|
|
child = ofw_bus_find_child(rnode, as3722s_def[i].name);
|
|
if (child == 0) {
|
|
if (bootverbose)
|
|
device_printf(sc->dev,
|
|
"Regulator %s missing in DT\n",
|
|
as3722s_def[i].name);
|
|
continue;
|
|
}
|
|
reg = as3722_attach(sc, child, as3722s_def + i);
|
|
if (reg == NULL) {
|
|
device_printf(sc->dev, "Cannot attach regulator: %s\n",
|
|
as3722s_def[i].name);
|
|
return (ENXIO);
|
|
}
|
|
sc->regs[i] = reg;
|
|
}
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
as3722_regulator_map(device_t dev, phandle_t xref, int ncells,
|
|
pcell_t *cells, int *num)
|
|
{
|
|
struct as3722_softc *sc;
|
|
int i;
|
|
|
|
sc = device_get_softc(dev);
|
|
for (i = 0; i < sc->nregs; i++) {
|
|
if (sc->regs[i] == NULL)
|
|
continue;
|
|
if (sc->regs[i]->xref == xref) {
|
|
*num = sc->regs[i]->def->id;
|
|
return (0);
|
|
}
|
|
}
|
|
return (ENXIO);
|
|
}
|
|
|
|
static int
|
|
as3722_regnode_enable(struct regnode *regnode, bool val, int *udelay)
|
|
{
|
|
struct as3722_reg_sc *sc;
|
|
int rv;
|
|
|
|
sc = regnode_get_softc(regnode);
|
|
|
|
if (val)
|
|
rv = as3722_reg_enable(sc);
|
|
else
|
|
rv = as3722_reg_disable(sc);
|
|
*udelay = sc->enable_usec;
|
|
return (rv);
|
|
}
|
|
|
|
static int
|
|
as3722_regnode_set_volt(struct regnode *regnode, int min_uvolt, int max_uvolt,
|
|
int *udelay)
|
|
{
|
|
struct as3722_reg_sc *sc;
|
|
uint8_t sel;
|
|
int rv;
|
|
|
|
sc = regnode_get_softc(regnode);
|
|
|
|
*udelay = 0;
|
|
rv = regulator_range_volt_to_sel8(sc->def->ranges, sc->def->nranges,
|
|
min_uvolt, max_uvolt, &sel);
|
|
if (rv != 0)
|
|
return (rv);
|
|
rv = as3722_write_sel(sc, sel);
|
|
return (rv);
|
|
|
|
}
|
|
|
|
static int
|
|
as3722_regnode_get_volt(struct regnode *regnode, int *uvolt)
|
|
{
|
|
struct as3722_reg_sc *sc;
|
|
uint8_t sel;
|
|
int rv;
|
|
|
|
sc = regnode_get_softc(regnode);
|
|
rv = as3722_read_sel(sc, &sel);
|
|
if (rv != 0)
|
|
return (rv);
|
|
|
|
/* LDO6 have bypass. */
|
|
if (sc->def->id == AS3722_REG_ID_LDO6 && sel == AS3722_LDO6_SEL_BYPASS)
|
|
return (ENOENT);
|
|
rv = regulator_range_sel8_to_volt(sc->def->ranges, sc->def->nranges,
|
|
sel, uvolt);
|
|
return (rv);
|
|
}
|