]> git.sur5r.net Git - u-boot/blob - drivers/power/as3722.c
include/configs: Numerous typo fixes: "controler" -> "controller".
[u-boot] / drivers / power / as3722.c
1 /*
2  * Copyright (C) 2014 NVIDIA Corporation
3  *
4  * SPDX-License-Identifier: GPL-2.0+
5  */
6
7 #define pr_fmt(fmt) "as3722: " fmt
8
9 #include <common.h>
10 #include <dm.h>
11 #include <errno.h>
12 #include <fdtdec.h>
13 #include <i2c.h>
14
15 #include <power/as3722.h>
16
17 #define AS3722_SD_VOLTAGE(n) (0x00 + (n))
18 #define AS3722_GPIO_CONTROL(n) (0x08 + (n))
19 #define  AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDH (1 << 0)
20 #define  AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDL (7 << 0)
21 #define  AS3722_GPIO_CONTROL_INVERT (1 << 7)
22 #define AS3722_LDO_VOLTAGE(n) (0x10 + (n))
23 #define AS3722_GPIO_SIGNAL_OUT 0x20
24 #define AS3722_SD_CONTROL 0x4d
25 #define AS3722_LDO_CONTROL 0x4e
26 #define AS3722_ASIC_ID1 0x90
27 #define  AS3722_DEVICE_ID 0x0c
28 #define AS3722_ASIC_ID2 0x91
29
30 int as3722_read(struct udevice *pmic, u8 reg, u8 *value)
31 {
32         int err;
33
34         err = dm_i2c_read(pmic, reg, value, 1);
35         if (err < 0)
36                 return err;
37
38         return 0;
39 }
40
41 int as3722_write(struct udevice *pmic, u8 reg, u8 value)
42 {
43         int err;
44
45         err = dm_i2c_write(pmic, reg, &value, 1);
46         if (err < 0)
47                 return err;
48
49         return 0;
50 }
51
52 static int as3722_read_id(struct udevice *pmic, u8 *id, u8 *revision)
53 {
54         int err;
55
56         err = as3722_read(pmic, AS3722_ASIC_ID1, id);
57         if (err) {
58                 error("failed to read ID1 register: %d", err);
59                 return err;
60         }
61
62         err = as3722_read(pmic, AS3722_ASIC_ID2, revision);
63         if (err) {
64                 error("failed to read ID2 register: %d", err);
65                 return err;
66         }
67
68         return 0;
69 }
70
71 int as3722_sd_enable(struct udevice *pmic, unsigned int sd)
72 {
73         u8 value;
74         int err;
75
76         if (sd > 6)
77                 return -EINVAL;
78
79         err = as3722_read(pmic, AS3722_SD_CONTROL, &value);
80         if (err) {
81                 error("failed to read SD control register: %d", err);
82                 return err;
83         }
84
85         value |= 1 << sd;
86
87         err = as3722_write(pmic, AS3722_SD_CONTROL, value);
88         if (err < 0) {
89                 error("failed to write SD control register: %d", err);
90                 return err;
91         }
92
93         return 0;
94 }
95
96 int as3722_sd_set_voltage(struct udevice *pmic, unsigned int sd, u8 value)
97 {
98         int err;
99
100         if (sd > 6)
101                 return -EINVAL;
102
103         err = as3722_write(pmic, AS3722_SD_VOLTAGE(sd), value);
104         if (err < 0) {
105                 error("failed to write SD%u voltage register: %d", sd, err);
106                 return err;
107         }
108
109         return 0;
110 }
111
112 int as3722_ldo_enable(struct udevice *pmic, unsigned int ldo)
113 {
114         u8 value;
115         int err;
116
117         if (ldo > 11)
118                 return -EINVAL;
119
120         err = as3722_read(pmic, AS3722_LDO_CONTROL, &value);
121         if (err) {
122                 error("failed to read LDO control register: %d", err);
123                 return err;
124         }
125
126         value |= 1 << ldo;
127
128         err = as3722_write(pmic, AS3722_LDO_CONTROL, value);
129         if (err < 0) {
130                 error("failed to write LDO control register: %d", err);
131                 return err;
132         }
133
134         return 0;
135 }
136
137 int as3722_ldo_set_voltage(struct udevice *pmic, unsigned int ldo, u8 value)
138 {
139         int err;
140
141         if (ldo > 11)
142                 return -EINVAL;
143
144         err = as3722_write(pmic, AS3722_LDO_VOLTAGE(ldo), value);
145         if (err < 0) {
146                 error("failed to write LDO%u voltage register: %d", ldo,
147                       err);
148                 return err;
149         }
150
151         return 0;
152 }
153
154 int as3722_gpio_configure(struct udevice *pmic, unsigned int gpio,
155                           unsigned long flags)
156 {
157         u8 value = 0;
158         int err;
159
160         if (flags & AS3722_GPIO_OUTPUT_VDDH)
161                 value |= AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDH;
162
163         if (flags & AS3722_GPIO_INVERT)
164                 value |= AS3722_GPIO_CONTROL_INVERT;
165
166         err = as3722_write(pmic, AS3722_GPIO_CONTROL(gpio), value);
167         if (err) {
168                 error("failed to configure GPIO#%u: %d", gpio, err);
169                 return err;
170         }
171
172         return 0;
173 }
174
175 static int as3722_gpio_set(struct udevice *pmic, unsigned int gpio,
176                            unsigned int level)
177 {
178         const char *l;
179         u8 value;
180         int err;
181
182         if (gpio > 7)
183                 return -EINVAL;
184
185         err = as3722_read(pmic, AS3722_GPIO_SIGNAL_OUT, &value);
186         if (err < 0) {
187                 error("failed to read GPIO signal out register: %d", err);
188                 return err;
189         }
190
191         if (level == 0) {
192                 value &= ~(1 << gpio);
193                 l = "low";
194         } else {
195                 value |= 1 << gpio;
196                 l = "high";
197         }
198
199         err = as3722_write(pmic, AS3722_GPIO_SIGNAL_OUT, value);
200         if (err) {
201                 error("failed to set GPIO#%u %s: %d", gpio, l, err);
202                 return err;
203         }
204
205         return 0;
206 }
207
208 int as3722_gpio_direction_output(struct udevice *pmic, unsigned int gpio,
209                                  unsigned int level)
210 {
211         u8 value;
212         int err;
213
214         if (gpio > 7)
215                 return -EINVAL;
216
217         if (level == 0)
218                 value = AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDL;
219         else
220                 value = AS3722_GPIO_CONTROL_MODE_OUTPUT_VDDH;
221
222         err = as3722_write(pmic, AS3722_GPIO_CONTROL(gpio), value);
223         if (err) {
224                 error("failed to configure GPIO#%u as output: %d", gpio, err);
225                 return err;
226         }
227
228         err = as3722_gpio_set(pmic, gpio, level);
229         if (err < 0) {
230                 error("failed to set GPIO#%u high: %d", gpio, err);
231                 return err;
232         }
233
234         return 0;
235 }
236
237 /* Temporary function until we get the pmic framework */
238 int as3722_get(struct udevice **devp)
239 {
240         int bus = 0;
241         int address = 0x40;
242
243         return i2c_get_chip_for_busnum(bus, address, 1, devp);
244 }
245
246 int as3722_init(struct udevice **devp)
247 {
248         struct udevice *pmic;
249         u8 id, revision;
250         const unsigned int bus = 0;
251         const unsigned int address = 0x40;
252         int err;
253
254         err = i2c_get_chip_for_busnum(bus, address, 1, &pmic);
255         if (err)
256                 return err;
257         err = as3722_read_id(pmic, &id, &revision);
258         if (err < 0) {
259                 error("failed to read ID: %d", err);
260                 return err;
261         }
262
263         if (id != AS3722_DEVICE_ID) {
264                 error("unknown device");
265                 return -ENOENT;
266         }
267
268         debug("AS3722 revision %#x found on I2C bus %u, address %#x\n",
269               revision, bus, address);
270         if (devp)
271                 *devp = pmic;
272
273         return 0;
274 }