4fcba5d556
Some devices share a regulator supply, when the first one will request regulator disable, the second device will have it's supply cut off before graciously shutting down. Hence there will be timeouts and other failed operations. Implement a reference counter mechanism similar with what is done in Linux, to keep track of enable and disable requests, and only disable the regulator when the last of the consumers has requested shutdown. Signed-off-by: Eugen Hristev <eugen.hristev@collabora.com> Reviewed-by: Simon Glass <sjg@chromium.org> Reviewed-by: Patrice Chotard <patrice.chotard@foss.st.com>
114 lines
2.7 KiB
C
114 lines
2.7 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Copyright (C) 2019 Disruptive Technologies Research AS
|
|
* Sven Schwermer <sven.svenschwermer@disruptive-technologies.com>
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <dm.h>
|
|
#include <log.h>
|
|
#include <linux/delay.h>
|
|
#include <power/regulator.h>
|
|
|
|
#include "regulator_common.h"
|
|
|
|
int regulator_common_of_to_plat(struct udevice *dev,
|
|
struct regulator_common_plat *dev_pdata,
|
|
const char *enable_gpio_name)
|
|
{
|
|
struct gpio_desc *gpio;
|
|
int flags = GPIOD_IS_OUT;
|
|
int ret;
|
|
|
|
if (!dev_read_bool(dev, "enable-active-high"))
|
|
flags |= GPIOD_ACTIVE_LOW;
|
|
if (dev_read_bool(dev, "regulator-boot-on"))
|
|
flags |= GPIOD_IS_OUT_ACTIVE;
|
|
|
|
/* Get optional enable GPIO desc */
|
|
gpio = &dev_pdata->gpio;
|
|
ret = gpio_request_by_name(dev, enable_gpio_name, 0, gpio, flags);
|
|
if (ret) {
|
|
debug("Regulator '%s' optional enable GPIO - not found! Error: %d\n",
|
|
dev->name, ret);
|
|
if (ret != -ENOENT)
|
|
return ret;
|
|
}
|
|
|
|
/* Get optional ramp up delay */
|
|
dev_pdata->startup_delay_us = dev_read_u32_default(dev,
|
|
"startup-delay-us", 0);
|
|
dev_pdata->off_on_delay_us =
|
|
dev_read_u32_default(dev, "off-on-delay-us", 0);
|
|
if (!dev_pdata->off_on_delay_us) {
|
|
dev_pdata->off_on_delay_us =
|
|
dev_read_u32_default(dev, "u-boot,off-on-delay-us", 0);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int regulator_common_get_enable(const struct udevice *dev,
|
|
struct regulator_common_plat *dev_pdata)
|
|
{
|
|
/* Enable GPIO is optional */
|
|
if (!dev_pdata->gpio.dev)
|
|
return true;
|
|
|
|
return dm_gpio_get_value(&dev_pdata->gpio);
|
|
}
|
|
|
|
int regulator_common_set_enable(const struct udevice *dev,
|
|
struct regulator_common_plat *dev_pdata, bool enable)
|
|
{
|
|
int ret;
|
|
|
|
debug("%s: dev='%s', enable=%d, delay=%d, has_gpio=%d\n", __func__,
|
|
dev->name, enable, dev_pdata->startup_delay_us,
|
|
dm_gpio_is_valid(&dev_pdata->gpio));
|
|
/* Enable GPIO is optional */
|
|
if (!dm_gpio_is_valid(&dev_pdata->gpio)) {
|
|
if (!enable)
|
|
return -ENOSYS;
|
|
return 0;
|
|
}
|
|
|
|
/* If previously enabled, increase count */
|
|
if (enable && dev_pdata->enable_count > 0) {
|
|
dev_pdata->enable_count++;
|
|
return -EALREADY;
|
|
}
|
|
|
|
if (!enable) {
|
|
if (dev_pdata->enable_count > 1) {
|
|
/* If enabled multiple times, decrease count */
|
|
dev_pdata->enable_count--;
|
|
return -EBUSY;
|
|
} else if (!dev_pdata->enable_count) {
|
|
/* If already disabled, do nothing */
|
|
return -EALREADY;
|
|
}
|
|
}
|
|
|
|
ret = dm_gpio_set_value(&dev_pdata->gpio, enable);
|
|
if (ret) {
|
|
pr_err("Can't set regulator : %s gpio to: %d\n", dev->name,
|
|
enable);
|
|
return ret;
|
|
}
|
|
|
|
if (enable && dev_pdata->startup_delay_us)
|
|
udelay(dev_pdata->startup_delay_us);
|
|
debug("%s: done\n", __func__);
|
|
|
|
if (!enable && dev_pdata->off_on_delay_us)
|
|
udelay(dev_pdata->off_on_delay_us);
|
|
|
|
if (enable)
|
|
dev_pdata->enable_count++;
|
|
else
|
|
dev_pdata->enable_count--;
|
|
|
|
return 0;
|
|
}
|