]>
Commit | Line | Data |
---|---|---|
8d30fcd9 SG |
1 | /* |
2 | * Copyright (c) 2011 The Chromium OS Authors. | |
1a459660 | 3 | * SPDX-License-Identifier: GPL-2.0+ |
8d30fcd9 SG |
4 | */ |
5 | ||
6 | #include <common.h> | |
e2d8a714 SG |
7 | #include <dm.h> |
8 | #include <fdtdec.h> | |
9 | #include <malloc.h> | |
8d30fcd9 SG |
10 | #include <asm/gpio.h> |
11 | ||
e2d8a714 SG |
12 | DECLARE_GLOBAL_DATA_PTR; |
13 | ||
8d30fcd9 SG |
14 | /* Flags for each GPIO */ |
15 | #define GPIOF_OUTPUT (1 << 0) /* Currently set as an output */ | |
16 | #define GPIOF_HIGH (1 << 1) /* Currently set high */ | |
17 | #define GPIOF_RESERVED (1 << 2) /* Is in use / requested */ | |
18 | ||
19 | struct gpio_state { | |
20 | const char *label; /* label given by requester */ | |
21 | u8 flags; /* flags (GPIOF_...) */ | |
22 | }; | |
23 | ||
8d30fcd9 | 24 | /* Access routines for GPIO state */ |
54c5d08a | 25 | static u8 *get_gpio_flags(struct udevice *dev, unsigned offset) |
8d30fcd9 | 26 | { |
e2d8a714 SG |
27 | struct gpio_dev_priv *uc_priv = dev->uclass_priv; |
28 | struct gpio_state *state = dev_get_priv(dev); | |
29 | ||
30 | if (offset >= uc_priv->gpio_count) { | |
8d30fcd9 | 31 | static u8 invalid_flags; |
e2d8a714 | 32 | printf("sandbox_gpio: error: invalid gpio %u\n", offset); |
8d30fcd9 SG |
33 | return &invalid_flags; |
34 | } | |
35 | ||
e2d8a714 | 36 | return &state[offset].flags; |
8d30fcd9 SG |
37 | } |
38 | ||
54c5d08a | 39 | static int get_gpio_flag(struct udevice *dev, unsigned offset, int flag) |
8d30fcd9 | 40 | { |
e2d8a714 | 41 | return (*get_gpio_flags(dev, offset) & flag) != 0; |
8d30fcd9 SG |
42 | } |
43 | ||
54c5d08a | 44 | static int set_gpio_flag(struct udevice *dev, unsigned offset, int flag, |
e2d8a714 | 45 | int value) |
8d30fcd9 | 46 | { |
e2d8a714 | 47 | u8 *gpio = get_gpio_flags(dev, offset); |
8d30fcd9 SG |
48 | |
49 | if (value) | |
50 | *gpio |= flag; | |
51 | else | |
52 | *gpio &= ~flag; | |
53 | ||
54 | return 0; | |
55 | } | |
56 | ||
54c5d08a | 57 | static int check_reserved(struct udevice *dev, unsigned offset, |
e2d8a714 | 58 | const char *func) |
8d30fcd9 | 59 | { |
e2d8a714 SG |
60 | if (!get_gpio_flag(dev, offset, GPIOF_RESERVED)) { |
61 | printf("sandbox_gpio: %s: error: offset %u not reserved\n", | |
62 | func, offset); | |
8d30fcd9 SG |
63 | return -1; |
64 | } | |
65 | ||
66 | return 0; | |
67 | } | |
68 | ||
69 | /* | |
70 | * Back-channel sandbox-internal-only access to GPIO state | |
71 | */ | |
72 | ||
54c5d08a | 73 | int sandbox_gpio_get_value(struct udevice *dev, unsigned offset) |
8d30fcd9 | 74 | { |
e2d8a714 SG |
75 | if (get_gpio_flag(dev, offset, GPIOF_OUTPUT)) |
76 | debug("sandbox_gpio: get_value on output gpio %u\n", offset); | |
77 | return get_gpio_flag(dev, offset, GPIOF_HIGH); | |
8d30fcd9 SG |
78 | } |
79 | ||
54c5d08a | 80 | int sandbox_gpio_set_value(struct udevice *dev, unsigned offset, int value) |
8d30fcd9 | 81 | { |
e2d8a714 | 82 | return set_gpio_flag(dev, offset, GPIOF_HIGH, value); |
8d30fcd9 SG |
83 | } |
84 | ||
54c5d08a | 85 | int sandbox_gpio_get_direction(struct udevice *dev, unsigned offset) |
8d30fcd9 | 86 | { |
e2d8a714 | 87 | return get_gpio_flag(dev, offset, GPIOF_OUTPUT); |
8d30fcd9 SG |
88 | } |
89 | ||
54c5d08a | 90 | int sandbox_gpio_set_direction(struct udevice *dev, unsigned offset, int output) |
8d30fcd9 | 91 | { |
e2d8a714 | 92 | return set_gpio_flag(dev, offset, GPIOF_OUTPUT, output); |
8d30fcd9 SG |
93 | } |
94 | ||
95 | /* | |
96 | * These functions implement the public interface within U-Boot | |
97 | */ | |
98 | ||
e2d8a714 | 99 | /* set GPIO port 'offset' as an input */ |
54c5d08a | 100 | static int sb_gpio_direction_input(struct udevice *dev, unsigned offset) |
8d30fcd9 | 101 | { |
e2d8a714 | 102 | debug("%s: offset:%u\n", __func__, offset); |
8d30fcd9 | 103 | |
e2d8a714 | 104 | if (check_reserved(dev, offset, __func__)) |
8d30fcd9 SG |
105 | return -1; |
106 | ||
e2d8a714 | 107 | return sandbox_gpio_set_direction(dev, offset, 0); |
8d30fcd9 SG |
108 | } |
109 | ||
e2d8a714 | 110 | /* set GPIO port 'offset' as an output, with polarity 'value' */ |
54c5d08a | 111 | static int sb_gpio_direction_output(struct udevice *dev, unsigned offset, |
e2d8a714 | 112 | int value) |
8d30fcd9 | 113 | { |
e2d8a714 | 114 | debug("%s: offset:%u, value = %d\n", __func__, offset, value); |
8d30fcd9 | 115 | |
e2d8a714 | 116 | if (check_reserved(dev, offset, __func__)) |
8d30fcd9 SG |
117 | return -1; |
118 | ||
e2d8a714 SG |
119 | return sandbox_gpio_set_direction(dev, offset, 1) | |
120 | sandbox_gpio_set_value(dev, offset, value); | |
8d30fcd9 SG |
121 | } |
122 | ||
e2d8a714 | 123 | /* read GPIO IN value of port 'offset' */ |
54c5d08a | 124 | static int sb_gpio_get_value(struct udevice *dev, unsigned offset) |
8d30fcd9 | 125 | { |
e2d8a714 | 126 | debug("%s: offset:%u\n", __func__, offset); |
8d30fcd9 | 127 | |
e2d8a714 | 128 | if (check_reserved(dev, offset, __func__)) |
8d30fcd9 SG |
129 | return -1; |
130 | ||
e2d8a714 | 131 | return sandbox_gpio_get_value(dev, offset); |
8d30fcd9 SG |
132 | } |
133 | ||
e2d8a714 | 134 | /* write GPIO OUT value to port 'offset' */ |
54c5d08a | 135 | static int sb_gpio_set_value(struct udevice *dev, unsigned offset, int value) |
8d30fcd9 | 136 | { |
e2d8a714 | 137 | debug("%s: offset:%u, value = %d\n", __func__, offset, value); |
8d30fcd9 | 138 | |
e2d8a714 | 139 | if (check_reserved(dev, offset, __func__)) |
8d30fcd9 SG |
140 | return -1; |
141 | ||
e2d8a714 SG |
142 | if (!sandbox_gpio_get_direction(dev, offset)) { |
143 | printf("sandbox_gpio: error: set_value on input gpio %u\n", | |
144 | offset); | |
8d30fcd9 SG |
145 | return -1; |
146 | } | |
147 | ||
e2d8a714 | 148 | return sandbox_gpio_set_value(dev, offset, value); |
8d30fcd9 SG |
149 | } |
150 | ||
54c5d08a | 151 | static int sb_gpio_request(struct udevice *dev, unsigned offset, |
e2d8a714 | 152 | const char *label) |
8d30fcd9 | 153 | { |
e2d8a714 SG |
154 | struct gpio_dev_priv *uc_priv = dev->uclass_priv; |
155 | struct gpio_state *state = dev_get_priv(dev); | |
156 | ||
157 | debug("%s: offset:%u, label:%s\n", __func__, offset, label); | |
8d30fcd9 | 158 | |
e2d8a714 SG |
159 | if (offset >= uc_priv->gpio_count) { |
160 | printf("sandbox_gpio: error: invalid gpio %u\n", offset); | |
8d30fcd9 SG |
161 | return -1; |
162 | } | |
163 | ||
e2d8a714 SG |
164 | if (get_gpio_flag(dev, offset, GPIOF_RESERVED)) { |
165 | printf("sandbox_gpio: error: gpio %u already reserved\n", | |
166 | offset); | |
8d30fcd9 SG |
167 | return -1; |
168 | } | |
169 | ||
e2d8a714 SG |
170 | state[offset].label = label; |
171 | return set_gpio_flag(dev, offset, GPIOF_RESERVED, 1); | |
8d30fcd9 SG |
172 | } |
173 | ||
54c5d08a | 174 | static int sb_gpio_free(struct udevice *dev, unsigned offset) |
8d30fcd9 | 175 | { |
e2d8a714 SG |
176 | struct gpio_state *state = dev_get_priv(dev); |
177 | ||
178 | debug("%s: offset:%u\n", __func__, offset); | |
8d30fcd9 | 179 | |
e2d8a714 | 180 | if (check_reserved(dev, offset, __func__)) |
8d30fcd9 SG |
181 | return -1; |
182 | ||
e2d8a714 SG |
183 | state[offset].label = NULL; |
184 | return set_gpio_flag(dev, offset, GPIOF_RESERVED, 0); | |
8d30fcd9 SG |
185 | } |
186 | ||
54c5d08a | 187 | static int sb_gpio_get_state(struct udevice *dev, unsigned int offset, |
e2d8a714 | 188 | char *buf, int bufsize) |
8d30fcd9 | 189 | { |
e2d8a714 SG |
190 | struct gpio_dev_priv *uc_priv = dev->uclass_priv; |
191 | struct gpio_state *state = dev_get_priv(dev); | |
192 | const char *label; | |
193 | ||
194 | label = state[offset].label; | |
195 | snprintf(buf, bufsize, "%s%d: %s: %d [%c]%s%s", | |
196 | uc_priv->bank_name ? uc_priv->bank_name : "", offset, | |
197 | sandbox_gpio_get_direction(dev, offset) ? "out" : " in", | |
198 | sandbox_gpio_get_value(dev, offset), | |
199 | get_gpio_flag(dev, offset, GPIOF_RESERVED) ? 'x' : ' ', | |
200 | label ? " " : "", | |
201 | label ? label : ""); | |
8d30fcd9 | 202 | |
e2d8a714 SG |
203 | return 0; |
204 | } | |
205 | ||
206 | static const struct dm_gpio_ops gpio_sandbox_ops = { | |
207 | .request = sb_gpio_request, | |
208 | .free = sb_gpio_free, | |
209 | .direction_input = sb_gpio_direction_input, | |
210 | .direction_output = sb_gpio_direction_output, | |
211 | .get_value = sb_gpio_get_value, | |
212 | .set_value = sb_gpio_set_value, | |
213 | .get_state = sb_gpio_get_state, | |
214 | }; | |
215 | ||
54c5d08a | 216 | static int sandbox_gpio_ofdata_to_platdata(struct udevice *dev) |
e2d8a714 SG |
217 | { |
218 | struct gpio_dev_priv *uc_priv = dev->uclass_priv; | |
8d30fcd9 | 219 | |
e2d8a714 SG |
220 | uc_priv->gpio_count = fdtdec_get_int(gd->fdt_blob, dev->of_offset, |
221 | "num-gpios", 0); | |
222 | uc_priv->bank_name = fdt_getprop(gd->fdt_blob, dev->of_offset, | |
223 | "gpio-bank-name", NULL); | |
8d30fcd9 | 224 | |
e2d8a714 SG |
225 | return 0; |
226 | } | |
227 | ||
54c5d08a | 228 | static int gpio_sandbox_probe(struct udevice *dev) |
e2d8a714 SG |
229 | { |
230 | struct gpio_dev_priv *uc_priv = dev->uclass_priv; | |
231 | ||
232 | if (dev->of_offset == -1) { | |
233 | /* Tell the uclass how many GPIOs we have */ | |
234 | uc_priv->gpio_count = CONFIG_SANDBOX_GPIO_COUNT; | |
8d30fcd9 | 235 | } |
e2d8a714 SG |
236 | |
237 | dev->priv = calloc(sizeof(struct gpio_state), uc_priv->gpio_count); | |
238 | ||
239 | return 0; | |
8d30fcd9 | 240 | } |
e2d8a714 | 241 | |
ae7f4513 | 242 | static const struct udevice_id sandbox_gpio_ids[] = { |
e2d8a714 SG |
243 | { .compatible = "sandbox,gpio" }, |
244 | { } | |
245 | }; | |
246 | ||
247 | U_BOOT_DRIVER(gpio_sandbox) = { | |
248 | .name = "gpio_sandbox", | |
249 | .id = UCLASS_GPIO, | |
250 | .of_match = sandbox_gpio_ids, | |
251 | .ofdata_to_platdata = sandbox_gpio_ofdata_to_platdata, | |
252 | .probe = gpio_sandbox_probe, | |
253 | .ops = &gpio_sandbox_ops, | |
254 | }; |