Commit b0712199 authored by Bob Beckett's avatar Bob Beckett
Browse files

Merge branch 'upstream-v3-p7-pmic-da9063' into upstream-v3-integration

parents a6f2bd10 8cf2206b
......@@ -95,7 +95,7 @@ static int do_dump(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
for (reg = 0; reg < pmic_reg_count(dev); reg++) {
ret = pmic_reg_read(dev, reg);
if (ret < 0) {
if (ret < 0 && ret != -ENODATA) {
printf("Can't read register: %d\n", reg);
return failure(ret);
}
......@@ -103,7 +103,15 @@ static int do_dump(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
if (!(reg % 16))
printf("\n0x%02x: ", reg);
printf(fmt, ret);
if (ret == -ENODATA) {
int i;
for (i = 0; i < priv->trans_len; i++)
puts("--");
puts(" ");
} else {
printf(fmt, ret);
}
}
printf("\n");
......
......@@ -40,6 +40,20 @@ config PMIC_ACT8846
functions. It uses an I2C interface and is designed for use with
tablets and smartphones.
config DM_PMIC_DA9063
bool "Enable Driver Model for the Dialog DA9063 PMIC"
depends on DM_PMIC
help
This config enables implementation of driver-model pmic uclass features
for PMIC DA9063. The driver implements read/write operations.
config SPL_DM_PMIC_DA9063
bool "Enable Driver Model for the Dialog DA9063 PMIC in SPL"
depends on DM_PMIC && SPL
help
This config enables implementation of driver-model pmic uclass features
for PMIC DA9063. The driver implements read/write operations.
config PMIC_AS3722
bool "Enable support for the Austria Micro Systems (AMS) AS7322 PMIC"
help
......
......@@ -5,6 +5,7 @@
obj-$(CONFIG_DM_PMIC) += pmic-uclass.o
obj-$(CONFIG_DM_PMIC_FAN53555) += fan53555.o
obj-$(CONFIG_$(SPL_)DM_PMIC_DA9063) += da9063.o
obj-$(CONFIG_DM_PMIC_MAX77686) += max77686.o
obj-$(CONFIG_DM_PMIC_MAX8998) += max8998.o
obj-$(CONFIG_DM_PMIC_MC34708) += mc34708.o
......
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (C) 2018 Flowbird
* Martin Fuzzey <martin.fuzzey@flowbird.group>
*/
#include <common.h>
#include <fdtdec.h>
#include <errno.h>
#include <dm.h>
#include <i2c.h>
#include <power/pmic.h>
#include <power/regulator.h>
#include <power/da9063_pmic.h>
static const struct pmic_child_info pmic_children_info[] = {
{ .prefix = "ldo", .driver = DA9063_LDO_DRIVER },
{ .prefix = "b", .driver = DA9063_BUCK_DRIVER },
{ },
};
/*
* The register map is non contiguous and attempts to read in the holes fail.
* But "pmic dump" tries to dump the full register map.
* So define the holes here so we can fix that.
*/
struct da9063_reg_hole {
u16 first;
u16 last;
};
static const struct da9063_reg_hole da9063_reg_holes[] = {
DA9063_REG_HOLE_1,
DA9063_REG_HOLE_2,
DA9063_REG_HOLE_3,
/* These aren't readable. I can't see why from the datasheet but
* attempts to read fail and the kernel marks them unreadable too,
*/
{DA9063_REG_OTP_COUNT, DA9063_REG_OTP_DATA},
};
static int da9063_reg_count(struct udevice *dev)
{
return DA9063_NUM_OF_REGS;
}
static bool da9063_reg_valid(uint reg)
{
int i;
for (i = 0; i < ARRAY_SIZE(da9063_reg_holes); i++) {
const struct da9063_reg_hole *hole = &da9063_reg_holes[i];
if (reg >= hole->first && reg <= hole->last)
return false;
}
return true;
}
static int da9063_write(struct udevice *dev, uint reg, const uint8_t *buff,
int len)
{
if (dm_i2c_write(dev, reg, buff, len)) {
pr_err("write error to device: %p register: %#x!", dev, reg);
return -EIO;
}
return 0;
}
static int da9063_read(struct udevice *dev, uint reg, uint8_t *buff, int len)
{
if (!da9063_reg_valid(reg))
return -ENODATA;
if (dm_i2c_read(dev, reg, buff, len)) {
pr_err("read error from device: %p register: %#x!", dev, reg);
return -EIO;
}
return 0;
}
static int da9063_bind(struct udevice *dev)
{
ofnode regulators_node;
int children;
regulators_node = dev_read_subnode(dev, "regulators");
if (!ofnode_valid(regulators_node)) {
debug("%s: %s regulators subnode not found!", __func__,
dev->name);
return -ENXIO;
}
debug("%s: '%s' - found regulators subnode\n", __func__, dev->name);
children = pmic_bind_children(dev, regulators_node, pmic_children_info);
if (!children)
debug("%s: %s - no child found\n", __func__, dev->name);
/* Always return success for this device */
return 0;
}
static int da9063_probe(struct udevice *dev)
{
return i2c_set_chip_addr_offset_mask(dev, 0x1);
}
static struct dm_pmic_ops da9063_ops = {
.reg_count = da9063_reg_count,
.read = da9063_read,
.write = da9063_write,
};
static const struct udevice_id da9063_ids[] = {
{ .compatible = "dlg,da9063" },
{ }
};
U_BOOT_DRIVER(pmic_da9063) = {
.name = "da9063_pmic",
.id = UCLASS_PMIC,
.of_match = da9063_ids,
.bind = da9063_bind,
.probe = da9063_probe,
.ops = &da9063_ops,
};
......@@ -60,6 +60,26 @@ config SPL_DM_REGULATOR_BD71837
This config enables implementation of driver-model regulator uclass
features for regulators on ROHM BD71837 and BD71847 in SPL.
config DM_REGULATOR_DA9063
bool "Enable Driver Model for REGULATOR DA9063"
depends on DM_REGULATOR && DM_PMIC_DA9063
help
This config enables implementation of driver-model regulator uclass
features for REGULATOR DA9063.
The driver implements get/set api for value, enable and mode for all
regulators. It also implements the get/set api for current for the
buck regulators.
config SPL_DM_REGULATOR_DA9063
bool "Enable Driver Model for REGULATOR DA9063 in SPL"
depends on DM_REGULATOR && DM_PMIC_DA9063 && SPL
help
This config enables implementation of driver-model regulator uclass
features for REGULATOR DA9063.
The driver implements get/set api for value, enable and mode for all
regulators. It also implements the get/set api for current for the
buck regulators.
config DM_REGULATOR_PFUZE100
bool "Enable Driver Model for REGULATOR PFUZE100"
depends on DM_REGULATOR && DM_PMIC_PFUZE100
......
......@@ -7,6 +7,7 @@
obj-$(CONFIG_$(SPL_)DM_REGULATOR) += regulator-uclass.o
obj-$(CONFIG_REGULATOR_ACT8846) += act8846.o
obj-$(CONFIG_REGULATOR_AS3722) += as3722_regulator.o
obj-$(CONFIG_$(SPL_)DM_REGULATOR_DA9063) += da9063.o
obj-$(CONFIG_DM_REGULATOR_MAX77686) += max77686.o
obj-$(CONFIG_$(SPL_)DM_PMIC_PFUZE100) += pfuze100.o
obj-$(CONFIG_$(SPL_)DM_REGULATOR_BD71837) += bd71837.o
......
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (C) 2018 Flowbird
* Martin Fuzzey <martin.fuzzey@flowbird.group>
*/
#include <common.h>
#include <dm.h>
#include <power/da9063_pmic.h>
#include <power/pmic.h>
#include <power/regulator.h>
#define DA9063_BUCK_EN 0x01
#define DA9063_LDO_EN 0x01
#define DA9063_VBUCK_MASK 0x7F
#define DA9063_BUCK_SL 0x80
#define DA9063_LDO_SL 0x80
#define DA9063_VLDO1_MASK 0x3F
#define DA9063_VLDO2_MASK 0x3F
#define DA9063_VLDO3_MASK 0x7F
#define DA9063_VLDO4_MASK 0x7F
#define DA9063_VLDO5_MASK 0x3F
#define DA9063_VLDO6_MASK 0x3F
#define DA9063_VLDO7_MASK 0x3F
#define DA9063_VLDO8_MASK 0x3F
#define DA9063_VLDO9_MASK 0x3F
#define DA9063_VLDO10_MASK 0x3F
#define DA9063_VLDO11_MASK 0x3F
#define DA9063_BUCK_MODE_MASK 0xC0
#define DA9063_BUCK_MODE_MANUAL 0x00
#define DA9063_BUCK_MODE_SLEEP 0x40
#define DA9063_BUCK_MODE_SYNC 0x80
#define DA9063_BUCK_MODE_AUTO 0xC0
#define DA9063_BIO_ILIM_MASK 0x0F
#define DA9063_BMEM_ILIM_MASK 0xF0
#define DA9063_BPRO_ILIM_MASK 0x0F
#define DA9063_BPERI_ILIM_MASK 0xF0
#define DA9063_BCORE1_ILIM_MASK 0x0F
#define DA9063_BCORE2_ILIM_MASK 0xF0
struct da9063_reg_info {
uint min_uV;
uint step_uV;
uint max_uV;
uint min_uA;
uint step_uA;
uint max_uA;
uint en_reg;
uint vsel_reg;
uint mode_reg;
uint ilim_reg;
u8 en_mask;
u8 vsel_mask;
u8 ilim_mask;
const char *dt_node_name;
const int *current_limits;
};
struct da9063_priv {
const struct da9063_reg_info *reg_info;
};
static struct dm_regulator_mode da9063_ldo_modes[] = {
{ .id = DA9063_LDOMODE_SLEEP,
.register_value = DA9063_LDO_SL, .name = "SLEEP" },
{ .id = DA9063_LDOMODE_NORMAL,
.register_value = 0, .name = "NORMAL" },
};
#define DA9063_LDO(regl_name, min_mV, step_mV, max_mV) \
.min_uV = (min_mV) * 1000, \
.step_uV = (step_mV) * 1000, \
.max_uV = (max_mV) * 1000, \
.en_reg = DA9063_REG_##regl_name##_CONT, \
.en_mask = DA9063_LDO_EN, \
.vsel_reg = DA9063_REG_V##regl_name##_A, \
.vsel_mask = DA9063_V##regl_name##_MASK, \
.mode_reg = DA9063_REG_V##regl_name##_A \
/* This array is directly indexed so must stay in numerical order */
static const struct da9063_reg_info da9063_ldo_info[] = {
{ DA9063_LDO(LDO1, 600, 20, 1860) },
{ DA9063_LDO(LDO2, 600, 20, 1860) },
{ DA9063_LDO(LDO3, 900, 20, 3440) },
{ DA9063_LDO(LDO4, 900, 20, 3440) },
{ DA9063_LDO(LDO5, 900, 50, 3600) },
{ DA9063_LDO(LDO6, 900, 50, 3600) },
{ DA9063_LDO(LDO7, 900, 50, 3600) },
{ DA9063_LDO(LDO8, 900, 50, 3600) },
{ DA9063_LDO(LDO9, 950, 50, 3600) },
{ DA9063_LDO(LDO10, 900, 50, 3600) },
{ DA9063_LDO(LDO11, 900, 50, 3600) },
};
static struct dm_regulator_mode da9063_buck_modes[] = {
{ .id = DA9063_BUCKMODE_SLEEP,
.register_value = DA9063_BUCK_MODE_SLEEP, .name = "SLEEP" },
{ .id = DA9063_BUCKMODE_SYNC,
.register_value = DA9063_BUCK_MODE_SYNC, .name = "SYNC" },
{ .id = DA9063_BUCKMODE_AUTO,
.register_value = DA9063_BUCK_MODE_AUTO, .name = "AUTO" },
};
#define DA9063_BUCK(regl_name, dt_name, \
min_mV, step_mV, max_mV, \
min_mA, step_mA, max_mA, _ilim_reg) \
.dt_node_name = dt_name, \
.min_uV = (min_mV) * 1000, \
.step_uV = (step_mV) * 1000, \
.max_uV = (max_mV) * 1000, \
.min_uA = (min_mA) * 1000, \
.step_uA = (step_mA) * 1000, \
.max_uA = (max_mA) * 1000, \
.en_reg = DA9063_REG_##regl_name##_CONT, \
.en_mask = DA9063_BUCK_EN, \
.vsel_reg = DA9063_REG_V##regl_name##_A, \
.vsel_mask = DA9063_VBUCK_MASK, \
.mode_reg = DA9063_REG_##regl_name##_CFG, \
.ilim_reg = DA9063_REG_BUCK_ILIM_##_ilim_reg, \
.ilim_mask = DA9063_##regl_name##_ILIM_MASK
static const struct da9063_reg_info da9063_buck_info[] = {
/* mV mA */
{ DA9063_BUCK(BCORE1, "bcore1", 300, 10, 1570, 500, 100, 2000, C) },
{ DA9063_BUCK(BCORE2, "bcore2", 300, 10, 1570, 500, 100, 2000, C) },
{ DA9063_BUCK(BPRO, "bpro", 530, 10, 1800, 500, 100, 2000, B) },
{ DA9063_BUCK(BMEM, "bmem", 800, 20, 3340, 1500, 100, 3000, A) },
{ DA9063_BUCK(BIO, "bio", 800, 20, 3340, 1500, 100, 3000, A) },
{ DA9063_BUCK(BPERI, "bperi", 800, 20, 3340, 1500, 100, 3000, B) },
};
static int da9063_get_enable(struct udevice *dev)
{
const struct da9063_priv *priv = dev->priv;
const struct da9063_reg_info *info = priv->reg_info;
int ret;
ret = pmic_reg_read(dev->parent, info->en_reg);
if (ret < 0)
return ret;
return ret & info->en_mask ? true : false;
}
static int da9063_set_enable(struct udevice *dev, bool enable)
{
const struct da9063_priv *priv = dev->priv;
const struct da9063_reg_info *info = priv->reg_info;
return pmic_clrsetbits(dev->parent, info->en_reg,
info->en_mask, enable ? info->en_mask : 0);
}
static int da9063_get_voltage(struct udevice *dev)
{
const struct da9063_priv *priv = dev->priv;
const struct da9063_reg_info *info = priv->reg_info;
int ret;
ret = pmic_reg_read(dev->parent, info->vsel_reg);
if (ret < 0)
return ret;
return info->min_uV + (ret & info->vsel_mask) * info->step_uV;
}
static int da9063_set_voltage(struct udevice *dev, int uV)
{
const struct da9063_priv *priv = dev->priv;
const struct da9063_reg_info *info = priv->reg_info;
uint sel;
if (uV < info->min_uV || uV > info->max_uV)
return -EINVAL;
sel = (uV - info->min_uV) / info->step_uV;
return pmic_clrsetbits(dev->parent, info->vsel_reg,
info->vsel_mask, sel);
}
static const struct dm_regulator_mode
*da9063_find_mode_by_id(int id,
const struct dm_regulator_mode *modes,
uint mode_count)
{
for (; mode_count; mode_count--) {
if (modes->id == id)
return modes;
modes++;
}
return NULL;
}
static int ldo_get_mode(struct udevice *dev)
{
const struct da9063_priv *priv = dev->priv;
const struct da9063_reg_info *info = priv->reg_info;
int val;
val = pmic_reg_read(dev->parent, info->mode_reg);
if (val < 0)
return val;
if (val & DA9063_LDO_SL)
return DA9063_LDOMODE_SLEEP;
else
return DA9063_LDOMODE_NORMAL;
}
static int ldo_set_mode(struct udevice *dev, int mode_id)
{
const struct da9063_priv *priv = dev->priv;
const struct da9063_reg_info *info = priv->reg_info;
const struct dm_regulator_mode *mode;
mode = da9063_find_mode_by_id(mode_id,
da9063_ldo_modes,
ARRAY_SIZE(da9063_ldo_modes));
if (!mode)
return -EINVAL;
return pmic_clrsetbits(dev->parent, info->mode_reg,
DA9063_LDO_SL, mode->register_value);
}
static int buck_get_mode(struct udevice *dev)
{
const struct da9063_priv *priv = dev->priv;
const struct da9063_reg_info *info = priv->reg_info;
int i;
int val;
val = pmic_reg_read(dev->parent, info->mode_reg);
if (val < 0)
return val;
val &= DA9063_BUCK_MODE_MASK;
if (val == DA9063_BUCK_MODE_MANUAL) {
val = pmic_reg_read(dev->parent, info->vsel_reg);
if (val < 0)
return val;
if (val & DA9063_BUCK_SL)
return DA9063_BUCKMODE_SLEEP;
else
return DA9063_BUCKMODE_SYNC;
}
for (i = 0; i < ARRAY_SIZE(da9063_buck_modes); i++) {
if (da9063_buck_modes[i].register_value == val)
return da9063_buck_modes[i].id;
}
return -EINVAL;
}
static int buck_set_mode(struct udevice *dev, int mode_id)
{
const struct da9063_priv *priv = dev->priv;
const struct da9063_reg_info *info = priv->reg_info;
const struct dm_regulator_mode *mode;
mode = da9063_find_mode_by_id(mode_id,
da9063_buck_modes,
ARRAY_SIZE(da9063_buck_modes));
if (!mode)
return -EINVAL;
return pmic_clrsetbits(dev->parent, info->mode_reg,
DA9063_BUCK_MODE_MASK, mode->register_value);
}
static int buck_get_current_limit(struct udevice *dev)
{
const struct da9063_priv *priv = dev->priv;
const struct da9063_reg_info *info = priv->reg_info;
int val;
val = pmic_reg_read(dev->parent, info->ilim_reg);
if (val < 0)
return val;
val &= info->ilim_mask;
val >>= (ffs(info->ilim_mask) - 1);
return info->min_uA + val * info->step_uA;
}
static int buck_set_current_limit(struct udevice *dev, int uA)
{
const struct da9063_priv *priv = dev->priv;
const struct da9063_reg_info *info = priv->reg_info;
int val;
if (uA < info->min_uA || uA > info->max_uA)
return -EINVAL;
val = (uA - info->min_uA) / info->step_uA;
val <<= (ffs(info->ilim_mask) - 1);
return pmic_clrsetbits(dev->parent, info->ilim_reg,
info->ilim_mask, val);
}
static int da9063_ldo_probe(struct udevice *dev)
{
struct dm_regulator_uclass_platdata *uc_pdata;
struct da9063_priv *priv = dev->priv;
/* LDOs are named numerically in DT so can directly index */
if (dev->driver_data < 1 ||
dev->driver_data > ARRAY_SIZE(da9063_ldo_info))
return -EINVAL;
priv->reg_info = &da9063_ldo_info[dev->driver_data - 1];
uc_pdata = dev_get_uclass_platdata(dev);
uc_pdata->type = REGULATOR_TYPE_LDO;
uc_pdata->mode = da9063_ldo_modes;
uc_pdata->mode_count = ARRAY_SIZE(da9063_ldo_modes);
return 0;
}
static int da9063_buck_probe(struct udevice *dev)
{
struct dm_regulator_uclass_platdata *uc_pdata;
struct da9063_priv *priv = dev->priv;
int i;
/* Bucks have names rather than numbers so need to match with DT */
for (i = 0; i < ARRAY_SIZE(da9063_buck_info); i++) {
const struct da9063_reg_info *info = &da9063_buck_info[i];
if (!strcmp(info->dt_node_name, dev->name)) {
priv->reg_info = info;
break;
}
}
if (!priv->reg_info)
return -ENODEV;
uc_pdata = dev_get_uclass_platdata(dev);
uc_pdata->type = REGULATOR_TYPE_BUCK;
uc_pdata->mode = da9063_buck_modes;
uc_pdata->mode_count = ARRAY_SIZE(da9063_buck_modes);
return 0;
}
static const struct dm_regulator_ops da9063_ldo_ops = {
.get_value = da9063_get_voltage,
.set_value = da9063_set_voltage,
.get_enable = da9063_get_enable,
.set_enable = da9063_set_enable,
.get_mode = ldo_get_mode,
.set_mode = ldo_set_mode,
};
U_BOOT_DRIVER(da9063_ldo) = {
.name = DA9063_LDO_DRIVER,
.id = UCLASS_REGULATOR,
.ops = &da9063_ldo_ops,
.probe = da9063_ldo_probe,
.priv_auto_alloc_size = sizeof(struct da9063_priv),
};
static const struct dm_regulator_ops da9063_buck_ops = {
.get_value = da9063_get_voltage,
.set_value = da9063_set_voltage,
.get_enable = da9063_get_enable,
.set_enable = da9063_set_enable,
.get_mode = buck_get_mode,
.set_mode = buck_set_mode,
.get_current = buck_get_current_limit,
.set_current = buck_set_current_limit,
};
U_BOOT_DRIVER(da9063_buck) = {
.name = DA9063_BUCK_DRIVER,
.id = UCLASS_REGULATOR,
.ops = &da9063_buck_ops,
.probe = da9063_buck_probe,
.priv_auto_alloc_size = sizeof(struct da9063_priv),
};
/* SPDX-License-Identifier: GPL-2.0+ */
/*
* Copyright (C) 2018 Flowbird
* Martin Fuzzey <martin.fuzzey@flowbird.group>
*/
#ifndef __DA9063_PMIC_H_
#define __DA9063_PMIC_H_