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
|
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (C) 2015 Samsung Electronics
*
* Przemyslaw Marczak <p.marczak@samsung.com>
*/
#include <common.h>
#include <clk.h>
#include <errno.h>
#include <dm.h>
#include <linux/delay.h>
#include <log.h>
#include <power/pmic.h>
#include <power/regulator.h>
#include "regulator_common.h"
struct fixed_clock_regulator_plat {
struct clk *enable_clock;
unsigned int clk_enable_counter;
};
static int fixed_regulator_of_to_plat(struct udevice *dev)
{
struct dm_regulator_uclass_plat *uc_pdata;
struct regulator_common_plat *dev_pdata;
dev_pdata = dev_get_plat(dev);
uc_pdata = dev_get_uclass_plat(dev);
if (!uc_pdata)
return -ENXIO;
uc_pdata->type = REGULATOR_TYPE_FIXED;
return regulator_common_of_to_plat(dev, dev_pdata, "gpio");
}
static int fixed_regulator_get_value(struct udevice *dev)
{
struct dm_regulator_uclass_plat *uc_pdata;
uc_pdata = dev_get_uclass_plat(dev);
if (!uc_pdata)
return -ENXIO;
if (uc_pdata->min_uV != uc_pdata->max_uV) {
debug("Invalid constraints for: %s\n", uc_pdata->name);
return -EINVAL;
}
return uc_pdata->min_uV;
}
static int fixed_regulator_get_current(struct udevice *dev)
{
struct dm_regulator_uclass_plat *uc_pdata;
uc_pdata = dev_get_uclass_plat(dev);
if (!uc_pdata)
return -ENXIO;
if (uc_pdata->min_uA != uc_pdata->max_uA) {
debug("Invalid constraints for: %s\n", uc_pdata->name);
return -EINVAL;
}
return uc_pdata->min_uA;
}
static int fixed_regulator_get_enable(struct udevice *dev)
{
return regulator_common_get_enable(dev, dev_get_plat(dev));
}
static int fixed_regulator_set_enable(struct udevice *dev, bool enable)
{
return regulator_common_set_enable(dev, dev_get_plat(dev), enable);
}
static int fixed_clock_regulator_get_enable(struct udevice *dev)
{
struct fixed_clock_regulator_plat *priv = dev_get_priv(dev);
return priv->clk_enable_counter > 0;
}
static int fixed_clock_regulator_set_enable(struct udevice *dev, bool enable)
{
struct fixed_clock_regulator_plat *priv = dev_get_priv(dev);
struct regulator_common_plat *dev_pdata = dev_get_plat(dev);
int ret = 0;
if (enable) {
ret = clk_enable(priv->enable_clock);
priv->clk_enable_counter++;
} else {
ret = clk_disable(priv->enable_clock);
priv->clk_enable_counter--;
}
if (ret)
return ret;
if (enable && dev_pdata->startup_delay_us)
udelay(dev_pdata->startup_delay_us);
if (!enable && dev_pdata->off_on_delay_us)
udelay(dev_pdata->off_on_delay_us);
return ret;
}
static const struct dm_regulator_ops fixed_regulator_ops = {
.get_value = fixed_regulator_get_value,
.get_current = fixed_regulator_get_current,
.get_enable = fixed_regulator_get_enable,
.set_enable = fixed_regulator_set_enable,
};
static const struct dm_regulator_ops fixed_clock_regulator_ops = {
.get_enable = fixed_clock_regulator_get_enable,
.set_enable = fixed_clock_regulator_set_enable,
};
static const struct udevice_id fixed_regulator_ids[] = {
{ .compatible = "regulator-fixed" },
{ },
};
static const struct udevice_id fixed_clock_regulator_ids[] = {
{ .compatible = "regulator-fixed-clock" },
{ },
};
U_BOOT_DRIVER(regulator_fixed) = {
.name = "regulator_fixed",
.id = UCLASS_REGULATOR,
.ops = &fixed_regulator_ops,
.of_match = fixed_regulator_ids,
.of_to_plat = fixed_regulator_of_to_plat,
.plat_auto = sizeof(struct regulator_common_plat),
};
U_BOOT_DRIVER(regulator_fixed_clock) = {
.name = "regulator_fixed_clk",
.id = UCLASS_REGULATOR,
.ops = &fixed_clock_regulator_ops,
.of_match = fixed_clock_regulator_ids,
.of_to_plat = fixed_regulator_of_to_plat,
.plat_auto = sizeof(struct fixed_clock_regulator_plat),
};
|