1 /*
2 * Copyright (C) 2017 Google, Inc
3 * Written by Simon Glass <sjg@chromium.org>
4 *
5 * Placeholder regulator driver for as3722.
6 *
7 * SPDX-License-Identifier: GPL-2.0+
8 */
9
10 #include <common.h>
11 #include <dm.h>
12 #include <errno.h>
13 #include <power/as3722.h>
14 #include <power/pmic.h>
15 #include <power/regulator.h>
16
stepdown_get_value(struct udevice * dev)17 static int stepdown_get_value(struct udevice *dev)
18 {
19 return -ENOSYS;
20 }
21
stepdown_set_value(struct udevice * dev,int uvolt)22 static int stepdown_set_value(struct udevice *dev, int uvolt)
23 {
24 return -ENOSYS;
25 }
26
stepdown_set_enable(struct udevice * dev,bool enable)27 static int stepdown_set_enable(struct udevice *dev, bool enable)
28 {
29 struct udevice *pmic = dev_get_parent(dev);
30 int sd = dev->driver_data;
31 int ret;
32
33 ret = pmic_clrsetbits(pmic, AS3722_SD_CONTROL, 0, 1 << sd);
34 if (ret < 0) {
35 debug("%s: failed to write SD control register: %d", __func__,
36 ret);
37 return ret;
38 }
39
40 return 0;
41 }
42
stepdown_get_enable(struct udevice * dev)43 static int stepdown_get_enable(struct udevice *dev)
44 {
45 struct udevice *pmic = dev_get_parent(dev);
46 int sd = dev->driver_data;
47 int ret;
48
49 ret = pmic_reg_read(pmic, AS3722_SD_CONTROL);
50 if (ret < 0) {
51 debug("%s: failed to read SD control register: %d", __func__,
52 ret);
53 return ret;
54 }
55
56 return ret & (1 << sd) ? true : false;
57 }
58
ldo_get_value(struct udevice * dev)59 static int ldo_get_value(struct udevice *dev)
60 {
61 return -ENOSYS;
62 }
63
ldo_set_value(struct udevice * dev,int uvolt)64 static int ldo_set_value(struct udevice *dev, int uvolt)
65 {
66 return -ENOSYS;
67 }
68
ldo_set_enable(struct udevice * dev,bool enable)69 static int ldo_set_enable(struct udevice *dev, bool enable)
70 {
71 struct udevice *pmic = dev_get_parent(dev);
72 int ldo = dev->driver_data;
73 int ret;
74
75 ret = pmic_clrsetbits(pmic, AS3722_LDO_CONTROL, 0, 1 << ldo);
76 if (ret < 0) {
77 debug("%s: failed to write LDO control register: %d", __func__,
78 ret);
79 return ret;
80 }
81
82 return 0;
83 }
84
ldo_get_enable(struct udevice * dev)85 static int ldo_get_enable(struct udevice *dev)
86 {
87 struct udevice *pmic = dev_get_parent(dev);
88 int ldo = dev->driver_data;
89 int ret;
90
91 ret = pmic_reg_read(pmic, AS3722_LDO_CONTROL);
92 if (ret < 0) {
93 debug("%s: failed to read SD control register: %d", __func__,
94 ret);
95 return ret;
96 }
97
98 return ret & (1 << ldo) ? true : false;
99 }
100
as3722_stepdown_probe(struct udevice * dev)101 static int as3722_stepdown_probe(struct udevice *dev)
102 {
103 struct dm_regulator_uclass_platdata *uc_pdata;
104
105 uc_pdata = dev_get_uclass_platdata(dev);
106
107 uc_pdata->type = REGULATOR_TYPE_BUCK;
108
109 return 0;
110 }
111
as3722_ldo_probe(struct udevice * dev)112 static int as3722_ldo_probe(struct udevice *dev)
113 {
114 struct dm_regulator_uclass_platdata *uc_pdata;
115
116 uc_pdata = dev_get_uclass_platdata(dev);
117
118 uc_pdata->type = REGULATOR_TYPE_LDO;
119
120 return 0;
121 }
122
123 static const struct dm_regulator_ops as3722_stepdown_ops = {
124 .get_value = stepdown_get_value,
125 .set_value = stepdown_set_value,
126 .get_enable = stepdown_get_enable,
127 .set_enable = stepdown_set_enable,
128 };
129
130 static const struct dm_regulator_ops as3722_ldo_ops = {
131 .get_value = ldo_get_value,
132 .set_value = ldo_set_value,
133 .get_enable = ldo_get_enable,
134 .set_enable = ldo_set_enable,
135 };
136
137 U_BOOT_DRIVER(as3722_stepdown) = {
138 .name = "as3722_stepdown",
139 .id = UCLASS_REGULATOR,
140 .ops = &as3722_stepdown_ops,
141 .probe = as3722_stepdown_probe,
142 };
143
144 U_BOOT_DRIVER(as3722_ldo) = {
145 .name = "as3722_ldo",
146 .id = UCLASS_REGULATOR,
147 .ops = &as3722_ldo_ops,
148 .probe = as3722_ldo_probe,
149 };
150