Mirrors/u-boot
2
0
Fork 0
mirror of https://github.com/AsahiLinux/u-boot synced 2024-11-28 15:41:40 +00:00
Code Issues Projects Releases Packages Wiki Activity

dm: power: Convert as3722 to driver model

Browse source 
Convert this PMIC driver to driver model and fix up other users. The
regulator and GPIO functions are now handled by separate drivers.

Update nyan-big to work correct. Three boards will need to be updated by
the maintainers: apalis-tk1, cei-tk1-som. Also the TODO in the code re
as3722_sd_set_voltage() needs to be completed.

Signed-off-by: Simon Glass <sjg@chromium.org>
Reviewed-by: Lukasz Majewski <lukma@denx.de>
Tested-by: Marcel Ziswiler <marcel.ziswiler@toradex.com>
Tested-on: Jetson-TK1
Tested-by: Stephen Warren <swarren@nvidia.com>
This commit is contained in:
Simon Glass 2017-07-25 08:30:12 -06:00
parent c2012cb47c
commit e3f44f5c89
12 changed files with 178 additions and 252 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
arch/arm/mach-tegra/board2.c
View file

@ -29,7 +29,6 @@
#ifdef CONFIG_TEGRA_CLOCK_SCALING
#include <asm/arch/emc.h>
#endif
#include <power/as3722.h>
#include "emc.h"
DECLARE_GLOBAL_DATA_PTR;
@ -142,11 +141,6 @@ int board_init(void)
debug("Memory controller init failed: %d\n", err);
# endif
# endif /* CONFIG_TEGRA_PMU */
#ifdef CONFIG_PMIC_AS3722
err = as3722_init(NULL);
if (err && err != -ENODEV)
return err;
#endif
#endif /* CONFIG_SYS_I2C_TEGRA */
#ifdef CONFIG_USB_EHCI_TEGRA

2
board/cei/cei-tk1-som/cei-tk1-som.c
View file

@ -39,6 +39,7 @@ void pinmux_init(void)
#ifdef CONFIG_PCI_TEGRA
int tegra_pcie_board_init(void)
{
/* TODO: Convert to driver model
struct udevice *pmic;
int err;
@ -59,6 +60,7 @@ int tegra_pcie_board_init(void)
error("failed to set SD4 voltage: %d\n", err);
return err;
}
*/
return 0;
}

52
board/nvidia/jetson-tk1/jetson-tk1.c
View file

@ -6,7 +6,9 @@
*/
#include <common.h>
#include <dm.h>
#include <power/as3722.h>
#include <power/pmic.h>
#include <asm/arch/gpio.h>
#include <asm/arch/pinmux.h>
@ -37,29 +39,47 @@ void pinmux_init(void)
}
#ifdef CONFIG_PCI_TEGRA
int tegra_pcie_board_init(void)
/* TODO: Convert to driver model */
static int as3722_sd_enable(struct udevice *pmic, unsigned int sd)
{
struct udevice *pmic;
int err;
err = as3722_init(&pmic);
if (sd > 6)
return -EINVAL;
err = pmic_clrsetbits(pmic, AS3722_SD_CONTROL, 0, 1 << sd);
if (err) {
error("failed to initialize AS3722 PMIC: %d\n", err);
return err;
}
err = as3722_sd_enable(pmic, 4);
if (err < 0) {
error("failed to enable SD4: %d\n", err);
return err;
}
err = as3722_sd_set_voltage(pmic, 4, 0x24);
if (err < 0) {
error("failed to set SD4 voltage: %d\n", err);
error("failed to update SD control register: %d", err);
return err;
}
return 0;
}
int tegra_pcie_board_init(void)
{
struct udevice *dev;
int ret;
ret = uclass_get_device_by_driver(UCLASS_PMIC,
DM_GET_DRIVER(pmic_as3722), &dev);
if (ret) {
debug("%s: Failed to find PMIC\n", __func__);
return ret;
}
ret = as3722_sd_enable(dev, 4);
if (ret < 0) {
error("failed to enable SD4: %d\n", ret);
return ret;
}
ret = as3722_sd_set_voltage(dev, 4, 0x24);
if (ret < 0) {
error("failed to set SD4 voltage: %d\n", ret);
return ret;
}
return 0;
}
#endif /* PCI */

22
board/nvidia/nyan-big/nyan-big.c
View file

@ -6,6 +6,7 @@
*/
#include <common.h>
#include <dm.h>
#include <errno.h>
#include <asm/gpio.h>
#include <asm/io.h>
@ -46,20 +47,23 @@ int tegra_board_id(void)
int tegra_lcd_pmic_init(int board_id)
{
struct udevice *pmic;
struct udevice *dev;
int ret;
ret = as3722_get(&pmic);
if (ret)
return -ENOENT;
ret = uclass_get_device_by_driver(UCLASS_PMIC,
DM_GET_DRIVER(pmic_as3722), &dev);
if (ret) {
debug("%s: Failed to find PMIC\n", __func__);
return ret;
}
if (board_id == 0)
as3722_write(pmic, 0x00, 0x3c);
pmic_reg_write(dev, 0x00, 0x3c);
else
as3722_write(pmic, 0x00, 0x50);
as3722_write(pmic, 0x12, 0x10);
as3722_write(pmic, 0x0c, 0x07);
as3722_write(pmic, 0x20, 0x10);
pmic_reg_write(dev, 0x00, 0x50);
pmic_reg_write(dev, 0x12, 0x10);
pmic_reg_write(dev, 0x0c, 0x07);
pmic_reg_write(dev, 0x20, 0x10);
return 0;
}

6
board/toradex/apalis-tk1/apalis-tk1.c
View file

@ -61,6 +61,7 @@ void pinmux_init(void)
#ifdef CONFIG_PCI_TEGRA
int tegra_pcie_board_init(void)
{
/* TODO: Convert to driver model
struct udevice *pmic;
int err;
@ -94,6 +95,7 @@ int tegra_pcie_board_init(void)
error("failed to set GPIO#2 high: %d\n", err);
return err;
}
*/
/* Reset I210 Gigabit Ethernet Controller */
gpio_request(LAN_RESET_N, "LAN_RESET_N");
@ -110,6 +112,7 @@ int tegra_pcie_board_init(void)
gpio_direction_output(TEGRA_GPIO(O, 6), 0);
/* Make sure LDO9 and LDO10 are initially enabled @ 0V */
/* TODO: Convert to driver model
err = as3722_ldo_enable(pmic, 9);
if (err < 0) {
error("failed to enable LDO9: %d\n", err);
@ -130,6 +133,7 @@ int tegra_pcie_board_init(void)
error("failed to set LDO10 voltage: %d\n", err);
return err;
}
*/
mdelay(100);
@ -137,6 +141,7 @@ int tegra_pcie_board_init(void)
gpio_set_value(TEGRA_GPIO(O, 6), 1);
/* Enable LDO9 and LDO10 for +V3.3_ETH on patched prototypes */
/* TODO: Convert to driver model
err = as3722_ldo_set_voltage(pmic, 9, 0xff);
if (err < 0) {
error("failed to set LDO9 voltage: %d\n", err);
@ -147,6 +152,7 @@ int tegra_pcie_board_init(void)
error("failed to set LDO10 voltage: %d\n", err);
return err;
}
*/
mdelay(100);
gpio_set_value(LAN_RESET_N, 1);

3
configs/apalis-tk1_defconfig
View file

@ -32,7 +32,10 @@ CONFIG_PCI=y
CONFIG_DM_PCI=y
CONFIG_DM_PCI_COMPAT=y
CONFIG_PCI_TEGRA=y
CONFIG_DM_PMIC=y
CONFIG_PMIC_AS3722=y
CONFIG_DM_REGULATOR=y
CONFIG_REGULATOR_AS3722=y
CONFIG_SYS_NS16550=y
CONFIG_USB=y
CONFIG_DM_USB=y

3
configs/cei-tk1-som_defconfig
View file

@ -36,7 +36,10 @@ CONFIG_PCI=y
CONFIG_DM_PCI=y
CONFIG_DM_PCI_COMPAT=y
CONFIG_PCI_TEGRA=y
CONFIG_DM_PMIC=y
CONFIG_PMIC_AS3722=y
CONFIG_DM_REGULATOR=y
CONFIG_REGULATOR_AS3722=y
CONFIG_SYS_NS16550=y
CONFIG_TEGRA114_SPI=y
CONFIG_USB=y

3
configs/jetson-tk1_defconfig
View file

@ -36,7 +36,10 @@ CONFIG_PCI=y
CONFIG_DM_PCI=y
CONFIG_DM_PCI_COMPAT=y
CONFIG_PCI_TEGRA=y
CONFIG_DM_PMIC=y
CONFIG_PMIC_AS3722=y
CONFIG_DM_REGULATOR=y
CONFIG_REGULATOR_AS3722=y
CONFIG_SYS_NS16550=y
CONFIG_TEGRA114_SPI=y
CONFIG_USB=y

1
configs/nyan-big_defconfig
View file

@ -50,6 +50,7 @@ CONFIG_SPI_FLASH_WINBOND=y
CONFIG_DM_PMIC=y
CONFIG_PMIC_AS3722=y
CONFIG_DM_REGULATOR=y
CONFIG_REGULATOR_AS3722=y
CONFIG_DM_REGULATOR_FIXED=y
CONFIG_PWM_TEGRA=y
CONFIG_DEBUG_UART_BASE=0x70006000

2
drivers/power/pmic/Makefile
View file

@ -12,7 +12,7 @@ obj-$(CONFIG_DM_PMIC_PFUZE100) += pfuze100.o
obj-$(CONFIG_PMIC_S2MPS11) += s2mps11.o
obj-$(CONFIG_DM_PMIC_SANDBOX) += sandbox.o i2c_pmic_emul.o
obj-$(CONFIG_PMIC_ACT8846) += act8846.o
obj-$(CONFIG_PMIC_AS3722) += as3722.o
obj-$(CONFIG_PMIC_AS3722) += as3722.o as3722_gpio.o
obj-$(CONFIG_PMIC_MAX8997) += max8997.o
obj-$(CONFIG_PMIC_PM8916) += pm8916.o
obj-$(CONFIG_PMIC_RK8XX) += rk8xx.o

312
drivers/power/pmic/as3722.c
View file

@ -11,253 +11,99 @@
#include <errno.h>
#include <fdtdec.h>
#include <i2c.h>
#include <dm/lists.h>
#include <power/as3722.h>
#include <power/pmic.h>
#define AS3722_SD_VOLTAGE(n) (0x00 + (n))
#define AS3722_GPIO_CONTROL(n) (0x08 + (n))
#define AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDH (1 << 0)
#define AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDL (7 << 0)
#define AS3722_GPIO_CONTROL_INVERT (1 << 7)
#define AS3722_LDO_VOLTAGE(n) (0x10 + (n))
#define AS3722_GPIO_SIGNAL_OUT 0x20
#define AS3722_SD_CONTROL 0x4d
#define AS3722_LDO_CONTROL 0x4e
#define AS3722_ASIC_ID1 0x90
#define AS3722_DEVICE_ID 0x0c
#define AS3722_ASIC_ID2 0x91
#define AS3722_NUM_OF_REGS 0x92
int as3722_read(struct udevice *pmic, u8 reg, u8 *value)
static int as3722_read(struct udevice *dev, uint reg, uint8_t *buff, int len)
{
int err;
int ret;
err = dm_i2c_read(pmic, reg, value, 1);
if (err < 0)
return err;
ret = dm_i2c_read(dev, reg, buff, len);
if (ret < 0)
return ret;
return 0;
}
int as3722_write(struct udevice *pmic, u8 reg, u8 value)
static int as3722_write(struct udevice *dev, uint reg, const uint8_t *buff,
int len)
{
int err;
int ret;
err = dm_i2c_write(pmic, reg, &value, 1);
if (err < 0)
return err;
ret = dm_i2c_write(dev, reg, buff, len);
if (ret < 0)
return ret;
return 0;
}
static int as3722_read_id(struct udevice *pmic, u8 *id, u8 *revision)
static int as3722_read_id(struct udevice *dev, uint *idp, uint *revisionp)
{
int err;
int ret;
err = as3722_read(pmic, AS3722_ASIC_ID1, id);
if (err) {
error("failed to read ID1 register: %d", err);
return err;
ret = pmic_reg_read(dev, AS3722_ASIC_ID1);
if (ret < 0) {
error("failed to read ID1 register: %d", ret);
return ret;
}
*idp = ret;
err = as3722_read(pmic, AS3722_ASIC_ID2, revision);
if (err) {
error("failed to read ID2 register: %d", err);
return err;
ret = pmic_reg_read(dev, AS3722_ASIC_ID2);
if (ret < 0) {
error("failed to read ID2 register: %d", ret);
return ret;
}
*revisionp = ret;
return 0;
}
int as3722_sd_enable(struct udevice *pmic, unsigned int sd)
/* TODO(treding@nvidia.com): Add proper regulator support to avoid this */
int as3722_sd_set_voltage(struct udevice *dev, unsigned int sd, u8 value)
{
u8 value;
int err;
int ret;
if (sd > 6)
return -EINVAL;
err = as3722_read(pmic, AS3722_SD_CONTROL, &value);
if (err) {
error("failed to read SD control register: %d", err);
return err;
}
value |= 1 << sd;
err = as3722_write(pmic, AS3722_SD_CONTROL, value);
if (err < 0) {
error("failed to write SD control register: %d", err);
return err;
ret = pmic_reg_write(dev, AS3722_SD_VOLTAGE(sd), value);
if (ret < 0) {
error("failed to write SD%u voltage register: %d", sd, ret);
return ret;
}
return 0;
}
int as3722_sd_set_voltage(struct udevice *pmic, unsigned int sd, u8 value)
int as3722_ldo_set_voltage(struct udevice *dev, unsigned int ldo, u8 value)
{
int err;
if (sd > 6)
return -EINVAL;
err = as3722_write(pmic, AS3722_SD_VOLTAGE(sd), value);
if (err < 0) {
error("failed to write SD%u voltage register: %d", sd, err);
return err;
}
return 0;
}
int as3722_ldo_enable(struct udevice *pmic, unsigned int ldo)
{
u8 value;
int err;
int ret;
if (ldo > 11)
return -EINVAL;
err = as3722_read(pmic, AS3722_LDO_CONTROL, &value);
if (err) {
error("failed to read LDO control register: %d", err);
return err;
}
value |= 1 << ldo;
err = as3722_write(pmic, AS3722_LDO_CONTROL, value);
if (err < 0) {
error("failed to write LDO control register: %d", err);
return err;
}
return 0;
}
int as3722_ldo_set_voltage(struct udevice *pmic, unsigned int ldo, u8 value)
{
int err;
if (ldo > 11)
return -EINVAL;
err = as3722_write(pmic, AS3722_LDO_VOLTAGE(ldo), value);
if (err < 0) {
ret = pmic_reg_write(dev, AS3722_LDO_VOLTAGE(ldo), value);
if (ret < 0) {
error("failed to write LDO%u voltage register: %d", ldo,
err);
return err;
ret);
return ret;
}
return 0;
}
int as3722_gpio_configure(struct udevice *pmic, unsigned int gpio,
unsigned long flags)
static int as3722_probe(struct udevice *dev)
{
u8 value = 0;
int err;
uint id, revision;
int ret;
if (flags & AS3722_GPIO_OUTPUT_VDDH)
value |= AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDH;
if (flags & AS3722_GPIO_INVERT)
value |= AS3722_GPIO_CONTROL_INVERT;
err = as3722_write(pmic, AS3722_GPIO_CONTROL(gpio), value);
if (err) {
error("failed to configure GPIO#%u: %d", gpio, err);
return err;
}
return 0;
}
static int as3722_gpio_set(struct udevice *pmic, unsigned int gpio,
unsigned int level)
{
const char *l;
u8 value;
int err;
if (gpio > 7)
return -EINVAL;
err = as3722_read(pmic, AS3722_GPIO_SIGNAL_OUT, &value);
if (err < 0) {
error("failed to read GPIO signal out register: %d", err);
return err;
}
if (level == 0) {
value &= ~(1 << gpio);
l = "low";
} else {
value |= 1 << gpio;
l = "high";
}
err = as3722_write(pmic, AS3722_GPIO_SIGNAL_OUT, value);
if (err) {
error("failed to set GPIO#%u %s: %d", gpio, l, err);
return err;
}
return 0;
}
int as3722_gpio_direction_output(struct udevice *pmic, unsigned int gpio,
unsigned int level)
{
u8 value;
int err;
if (gpio > 7)
return -EINVAL;
if (level == 0)
value = AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDL;
else
value = AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDH;
err = as3722_write(pmic, AS3722_GPIO_CONTROL(gpio), value);
if (err) {
error("failed to configure GPIO#%u as output: %d", gpio, err);
return err;
}
err = as3722_gpio_set(pmic, gpio, level);
if (err < 0) {
error("failed to set GPIO#%u high: %d", gpio, err);
return err;
}
return 0;
}
/* Temporary function until we get the pmic framework */
int as3722_get(struct udevice **devp)
{
int bus = 0;
int address = 0x40;
return i2c_get_chip_for_busnum(bus, address, 1, devp);
}
int as3722_init(struct udevice **devp)
{
struct udevice *pmic;
u8 id, revision;
const unsigned int bus = 0;
const unsigned int address = 0x40;
int err;
err = i2c_get_chip_for_busnum(bus, address, 1, &pmic);
if (err)
return err;
err = as3722_read_id(pmic, &id, &revision);
if (err < 0) {
error("failed to read ID: %d", err);
return err;
ret = as3722_read_id(dev, &id, &revision);
if (ret < 0) {
error("failed to read ID: %d", ret);
return ret;
}
if (id != AS3722_DEVICE_ID) {
@ -265,10 +111,68 @@ int as3722_init(struct udevice **devp)
return -ENOENT;
}
debug("AS3722 revision %#x found on I2C bus %u, address %#x\n",
revision, bus, address);
if (devp)
*devp = pmic;
debug("AS3722 revision %#x found on I2C bus %s\n", revision, dev->name);
return 0;
}
#if CONFIG_IS_ENABLED(PMIC_CHILDREN)
static const struct pmic_child_info pmic_children_info[] = {
{ .prefix = "sd", .driver = "as3722_stepdown"},
{ .prefix = "ldo", .driver = "as3722_ldo"},
{ },
};
static int as3722_bind(struct udevice *dev)
{
struct udevice *gpio_dev;
ofnode regulators_node;
int children;
int ret;
regulators_node = dev_read_subnode(dev, "regulators");
if (!ofnode_valid(regulators_node)) {
debug("%s: %s regulators subnode not found\n", __func__,
dev->name);
return -ENXIO;
}
children = pmic_bind_children(dev, regulators_node, pmic_children_info);
if (!children)
debug("%s: %s - no child found\n", __func__, dev->name);
ret = device_bind_driver(dev, "gpio_as3722", "gpio_as3722", &gpio_dev);
if (ret) {
debug("%s: Cannot bind GPIOs (ret=%d)\n", __func__, ret);
return ret;
}
return 0;
}
#endif
static int as3722_reg_count(struct udevice *dev)
{
return AS3722_NUM_OF_REGS;
}
static struct dm_pmic_ops as3722_ops = {
.reg_count = as3722_reg_count,
.read = as3722_read,
.write = as3722_write,
};
static const struct udevice_id as3722_ids[] = {
{ .compatible = "ams,as3722" },
{ }
};
U_BOOT_DRIVER(pmic_as3722) = {
.name = "as3722_pmic",
.id = UCLASS_PMIC,
.of_match = as3722_ids,
#if CONFIG_IS_ENABLED(PMIC_CHILDREN)
.bind = as3722_bind,
#endif
.probe = as3722_probe,
.ops = &as3722_ops,
};

18
include/power/as3722.h
View file

@ -7,8 +7,6 @@
#ifndef __POWER_AS3722_H__
#define __POWER_AS3722_H__
#include <asm/types.h>
#define AS3722_GPIO_OUTPUT_VDDH (1 << 0)
#define AS3722_GPIO_INVERT (1 << 1)
@ -21,23 +19,11 @@
#define AS3722_ASIC_ID2 0x91
#define AS3722_GPIO_CONTROL(n) (0x08 + (n))
#define AS3722_GPIO_SIGNAL_OUT 0x20
#define AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDH (1 << 0)
#define AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDL (7 << 0)
#define AS3722_GPIO_CONTROL_INVERT (1 << 7)
struct udevice;
int as3722_init(struct udevice **devp);
int as3722_sd_enable(struct udevice *pmic, unsigned int sd);
int as3722_sd_set_voltage(struct udevice *pmic, unsigned int sd, u8 value);
int as3722_ldo_enable(struct udevice *pmic, unsigned int ldo);
int as3722_ldo_set_voltage(struct udevice *pmic, unsigned int ldo, u8 value);
int as3722_gpio_configure(struct udevice *pmic, unsigned int gpio,
unsigned long flags);
int as3722_gpio_direction_output(struct udevice *pmic, unsigned int gpio,
unsigned int level);
int as3722_read(struct udevice *pmic, u8 reg, u8 *value);
int as3722_write(struct udevice *pmic, u8 reg, u8 value);
int as3722_get(struct udevice **devp);
int as3722_sd_set_voltage(struct udevice *dev, unsigned int sd, u8 value);
#endif /* __POWER_AS3722_H__ */