Whitebox
/
u-boot
1
0
Fork 0
Code Issues Pull Requests Releases 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>
master
Simon Glass 7 years ago
parent c2012cb47c
commit e3f44f5c89
12 changed files with 164 additions and 238 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 6
      arch/arm/mach-tegra/board2.c
  2. 2
      board/cei/cei-tk1-som/cei-tk1-som.c
  3. 44
      board/nvidia/jetson-tk1/jetson-tk1.c
  4. 22
      board/nvidia/nyan-big/nyan-big.c
  5. 6
      board/toradex/apalis-tk1/apalis-tk1.c
  6. 3
      configs/apalis-tk1_defconfig
  7. 3
      configs/cei-tk1-som_defconfig
  8. 3
      configs/jetson-tk1_defconfig
  9. 1
      configs/nyan-big_defconfig
  10. 2
      drivers/power/pmic/Makefile
  11. 292
      drivers/power/pmic/as3722.c
  12. 18
      include/power/as3722.h

6
arch/arm/mach-tegra/board2.c
Unescape View File

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

2
board/cei/cei-tk1-som/cei-tk1-som.c
Unescape View File

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

44
board/nvidia/jetson-tk1/jetson-tk1.c
Unescape View File

@ -6,7 +6,9 @@
*/ */
#include <common.h> #include <common.h>
#include <dm.h>
#include <power/as3722.h> #include <power/as3722.h>
#include <power/pmic.h>
#include <asm/arch/gpio.h> #include <asm/arch/gpio.h>
#include <asm/arch/pinmux.h> #include <asm/arch/pinmux.h>
@ -37,27 +39,45 @@ void pinmux_init(void)
} }
#ifdef CONFIG_PCI_TEGRA #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; int err;
err = as3722_init(&pmic); if (sd > 6)
return -EINVAL;
err = pmic_clrsetbits(pmic, AS3722_SD_CONTROL, 0, 1 << sd);
if (err) { if (err) {
error("failed to initialize AS3722 PMIC: %d\n", err); error("failed to update SD control register: %d", err);
return err; return err;
} }
err = as3722_sd_enable(pmic, 4); return 0;
if (err < 0) { }
error("failed to enable SD4: %d\n", err);
return err; 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;
} }
err = as3722_sd_set_voltage(pmic, 4, 0x24); ret = as3722_sd_enable(dev, 4);
if (err < 0) { if (ret < 0) {
error("failed to set SD4 voltage: %d\n", err); error("failed to enable SD4: %d\n", ret);
return err; 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; return 0;

22
board/nvidia/nyan-big/nyan-big.c
Unescape View File

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

6
board/toradex/apalis-tk1/apalis-tk1.c
Unescape View File

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

3
configs/apalis-tk1_defconfig
Unescape View File

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

3
configs/cei-tk1-som_defconfig
Unescape View File

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

3
configs/jetson-tk1_defconfig
Unescape View File

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

1
configs/nyan-big_defconfig
Unescape View File

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

2
drivers/power/pmic/Makefile
Unescape View File

@ -12,7 +12,7 @@ obj-$(CONFIG_DM_PMIC_PFUZE100) += pfuze100.o
obj-$(CONFIG_PMIC_S2MPS11) += s2mps11.o obj-$(CONFIG_PMIC_S2MPS11) += s2mps11.o
obj-$(CONFIG_DM_PMIC_SANDBOX) += sandbox.o i2c_pmic_emul.o obj-$(CONFIG_DM_PMIC_SANDBOX) += sandbox.o i2c_pmic_emul.o
obj-$(CONFIG_PMIC_ACT8846) += act8846.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_MAX8997) += max8997.o
obj-$(CONFIG_PMIC_PM8916) += pm8916.o obj-$(CONFIG_PMIC_PM8916) += pm8916.o
obj-$(CONFIG_PMIC_RK8XX) += rk8xx.o obj-$(CONFIG_PMIC_RK8XX) += rk8xx.o

292
drivers/power/pmic/as3722.c
Unescape View File

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

18
include/power/as3722.h
Unescape View File

@ -7,8 +7,6 @@
#ifndef __POWER_AS3722_H__ #ifndef __POWER_AS3722_H__
#define __POWER_AS3722_H__ #define __POWER_AS3722_H__
#include <asm/types.h>
#define AS3722_GPIO_OUTPUT_VDDH (1 << 0) #define AS3722_GPIO_OUTPUT_VDDH (1 << 0)
#define AS3722_GPIO_INVERT (1 << 1) #define AS3722_GPIO_INVERT (1 << 1)
@ -21,23 +19,11 @@
#define AS3722_ASIC_ID2 0x91 #define AS3722_ASIC_ID2 0x91
#define AS3722_GPIO_CONTROL(n) (0x08 + (n)) #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_VDDH (1 << 0)
#define AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDL (7 << 0) #define AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDL (7 << 0)
#define AS3722_GPIO_CONTROL_INVERT (1 << 7) #define AS3722_GPIO_CONTROL_INVERT (1 << 7)
struct udevice; int as3722_sd_set_voltage(struct udevice *dev, unsigned int sd, u8 value);
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);
#endif /* __POWER_AS3722_H__ */ #endif /* __POWER_AS3722_H__ */

Write Preview
Loading…
Cancel
Save