1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
// SPDX-License-Identifier: GPL-2.0+
/*
* (C) Copyright 2016 Texas Instruments Incorporated, <www.ti.com>
* Keerthy <j-keerthy@ti.com>
*/
#include <common.h>
#include <fdtdec.h>
#include <errno.h>
#include <dm.h>
#include <log.h>
#include <asm/gpio.h>
#include <power/pmic.h>
#include <power/regulator.h>
#include "regulator_common.h"
#define GPIO_REGULATOR_MAX_STATES 2
struct gpio_regulator_plat {
struct regulator_common_plat common;
struct gpio_desc gpio; /* GPIO for regulator voltage control */
int states[GPIO_REGULATOR_MAX_STATES];
int voltages[GPIO_REGULATOR_MAX_STATES];
};
static int gpio_regulator_of_to_plat(struct udevice *dev)
{
struct dm_regulator_uclass_plat *uc_pdata;
struct gpio_regulator_plat *plat;
struct gpio_desc *gpio;
int ret, count, i, j;
u32 states_array[GPIO_REGULATOR_MAX_STATES * 2];
plat = dev_get_plat(dev);
uc_pdata = dev_get_uclass_plat(dev);
if (!uc_pdata)
return -ENXIO;
/* Set type to gpio */
uc_pdata->type = REGULATOR_TYPE_GPIO;
/*
* Get gpio regulator gpio desc
* Assuming one GPIO per regulator.
* Can be extended later to multiple GPIOs
* per gpio-regulator. As of now no instance with multiple
* gpios is presnt
*/
gpio = &plat->gpio;
ret = gpio_request_by_name(dev, "gpios", 0, gpio, GPIOD_IS_OUT);
if (ret)
debug("regulator gpio - not found! Error: %d", ret);
ret = dev_read_size(dev, "states");
if (ret < 0)
return ret;
count = ret / sizeof(states_array[0]);
if (count > ARRAY_SIZE(states_array)) {
debug("regulator gpio - to many states (%d > %d)",
count / 2, GPIO_REGULATOR_MAX_STATES);
count = ARRAY_SIZE(states_array);
}
ret = dev_read_u32_array(dev, "states", states_array, count);
if (ret < 0)
return ret;
for (i = 0, j = 0; i < count; i += 2) {
plat->voltages[j] = states_array[i];
plat->states[j] = states_array[i + 1];
j++;
}
return regulator_common_of_to_plat(dev, &plat->common, "enable-gpios");
}
static int gpio_regulator_get_value(struct udevice *dev)
{
struct dm_regulator_uclass_plat *uc_pdata;
struct gpio_regulator_plat *plat = dev_get_plat(dev);
int enable;
if (!plat->gpio.dev)
return -ENOSYS;
uc_pdata = dev_get_uclass_plat(dev);
if (uc_pdata->min_uV > uc_pdata->max_uV) {
debug("Invalid constraints for: %s\n", uc_pdata->name);
return -EINVAL;
}
enable = dm_gpio_get_value(&plat->gpio);
if (enable == plat->states[0])
return plat->voltages[0];
else
return plat->voltages[1];
}
static int gpio_regulator_set_value(struct udevice *dev, int uV)
{
struct gpio_regulator_plat *plat = dev_get_plat(dev);
int ret;
bool enable;
if (!plat->gpio.dev)
return -ENOSYS;
if (uV == plat->voltages[0])
enable = plat->states[0];
else if (uV == plat->voltages[1])
enable = plat->states[1];
else
return -EINVAL;
ret = dm_gpio_set_value(&plat->gpio, enable);
if (ret) {
pr_err("Can't set regulator : %s gpio to: %d\n", dev->name,
enable);
return ret;
}
return 0;
}
static int gpio_regulator_get_enable(struct udevice *dev)
{
struct gpio_regulator_plat *plat = dev_get_plat(dev);
return regulator_common_get_enable(dev, &plat->common);
}
static int gpio_regulator_set_enable(struct udevice *dev, bool enable)
{
struct gpio_regulator_plat *plat = dev_get_plat(dev);
return regulator_common_set_enable(dev, &plat->common, enable);
}
static const struct dm_regulator_ops gpio_regulator_ops = {
.get_value = gpio_regulator_get_value,
.set_value = gpio_regulator_set_value,
.get_enable = gpio_regulator_get_enable,
.set_enable = gpio_regulator_set_enable,
};
static const struct udevice_id gpio_regulator_ids[] = {
{ .compatible = "regulator-gpio" },
{ },
};
U_BOOT_DRIVER(gpio_regulator) = {
.name = "gpio regulator",
.id = UCLASS_REGULATOR,
.ops = &gpio_regulator_ops,
.of_match = gpio_regulator_ids,
.of_to_plat = gpio_regulator_of_to_plat,
.plat_auto = sizeof(struct gpio_regulator_plat),
};
|