]>
Commit | Line | Data |
---|---|---|
d72fc9dc CD |
1 | /* |
2 | * Raspberry Pi (BCM2835) GPIO Controller | |
3 | * | |
4 | * Copyright (c) 2017 Antfield SAS | |
5 | * | |
6 | * Authors: | |
7 | * Clement Deschamps <clement.deschamps@antfield.fr> | |
8 | * Luc Michel <luc.michel@antfield.fr> | |
9 | * | |
10 | * This work is licensed under the terms of the GNU GPL, version 2 or later. | |
11 | * See the COPYING file in the top-level directory. | |
12 | */ | |
13 | ||
14 | #include "qemu/osdep.h" | |
15 | #include "qemu/log.h" | |
0b8fa32f | 16 | #include "qemu/module.h" |
d72fc9dc CD |
17 | #include "qemu/timer.h" |
18 | #include "qapi/error.h" | |
19 | #include "hw/sysbus.h" | |
20 | #include "hw/sd/sd.h" | |
21 | #include "hw/gpio/bcm2835_gpio.h" | |
22 | ||
23 | #define GPFSEL0 0x00 | |
24 | #define GPFSEL1 0x04 | |
25 | #define GPFSEL2 0x08 | |
26 | #define GPFSEL3 0x0C | |
27 | #define GPFSEL4 0x10 | |
28 | #define GPFSEL5 0x14 | |
29 | #define GPSET0 0x1C | |
30 | #define GPSET1 0x20 | |
31 | #define GPCLR0 0x28 | |
32 | #define GPCLR1 0x2C | |
33 | #define GPLEV0 0x34 | |
34 | #define GPLEV1 0x38 | |
35 | #define GPEDS0 0x40 | |
36 | #define GPEDS1 0x44 | |
37 | #define GPREN0 0x4C | |
38 | #define GPREN1 0x50 | |
39 | #define GPFEN0 0x58 | |
40 | #define GPFEN1 0x5C | |
41 | #define GPHEN0 0x64 | |
42 | #define GPHEN1 0x68 | |
43 | #define GPLEN0 0x70 | |
44 | #define GPLEN1 0x74 | |
45 | #define GPAREN0 0x7C | |
46 | #define GPAREN1 0x80 | |
47 | #define GPAFEN0 0x88 | |
48 | #define GPAFEN1 0x8C | |
49 | #define GPPUD 0x94 | |
50 | #define GPPUDCLK0 0x98 | |
51 | #define GPPUDCLK1 0x9C | |
52 | ||
53 | static uint32_t gpfsel_get(BCM2835GpioState *s, uint8_t reg) | |
54 | { | |
55 | int i; | |
56 | uint32_t value = 0; | |
57 | for (i = 0; i < 10; i++) { | |
58 | uint32_t index = 10 * reg + i; | |
59 | if (index < sizeof(s->fsel)) { | |
60 | value |= (s->fsel[index] & 0x7) << (3 * i); | |
61 | } | |
62 | } | |
63 | return value; | |
64 | } | |
65 | ||
66 | static void gpfsel_set(BCM2835GpioState *s, uint8_t reg, uint32_t value) | |
67 | { | |
68 | int i; | |
69 | for (i = 0; i < 10; i++) { | |
70 | uint32_t index = 10 * reg + i; | |
71 | if (index < sizeof(s->fsel)) { | |
72 | int fsel = (value >> (3 * i)) & 0x7; | |
73 | s->fsel[index] = fsel; | |
74 | } | |
75 | } | |
76 | ||
77 | /* SD controller selection (48-53) */ | |
78 | if (s->sd_fsel != 0 | |
79 | && (s->fsel[48] == 0) /* SD_CLK_R */ | |
80 | && (s->fsel[49] == 0) /* SD_CMD_R */ | |
81 | && (s->fsel[50] == 0) /* SD_DATA0_R */ | |
82 | && (s->fsel[51] == 0) /* SD_DATA1_R */ | |
83 | && (s->fsel[52] == 0) /* SD_DATA2_R */ | |
84 | && (s->fsel[53] == 0) /* SD_DATA3_R */ | |
85 | ) { | |
86 | /* SDHCI controller selected */ | |
87 | sdbus_reparent_card(s->sdbus_sdhost, s->sdbus_sdhci); | |
88 | s->sd_fsel = 0; | |
89 | } else if (s->sd_fsel != 4 | |
90 | && (s->fsel[48] == 4) /* SD_CLK_R */ | |
91 | && (s->fsel[49] == 4) /* SD_CMD_R */ | |
92 | && (s->fsel[50] == 4) /* SD_DATA0_R */ | |
93 | && (s->fsel[51] == 4) /* SD_DATA1_R */ | |
94 | && (s->fsel[52] == 4) /* SD_DATA2_R */ | |
95 | && (s->fsel[53] == 4) /* SD_DATA3_R */ | |
96 | ) { | |
97 | /* SDHost controller selected */ | |
98 | sdbus_reparent_card(s->sdbus_sdhci, s->sdbus_sdhost); | |
99 | s->sd_fsel = 4; | |
100 | } | |
101 | } | |
102 | ||
103 | static int gpfsel_is_out(BCM2835GpioState *s, int index) | |
104 | { | |
105 | if (index >= 0 && index < 54) { | |
106 | return s->fsel[index] == 1; | |
107 | } | |
108 | return 0; | |
109 | } | |
110 | ||
111 | static void gpset(BCM2835GpioState *s, | |
112 | uint32_t val, uint8_t start, uint8_t count, uint32_t *lev) | |
113 | { | |
114 | uint32_t changes = val & ~*lev; | |
115 | uint32_t cur = 1; | |
116 | ||
117 | int i; | |
118 | for (i = 0; i < count; i++) { | |
119 | if ((changes & cur) && (gpfsel_is_out(s, start + i))) { | |
120 | qemu_set_irq(s->out[start + i], 1); | |
121 | } | |
122 | cur <<= 1; | |
123 | } | |
124 | ||
125 | *lev |= val; | |
126 | } | |
127 | ||
128 | static void gpclr(BCM2835GpioState *s, | |
129 | uint32_t val, uint8_t start, uint8_t count, uint32_t *lev) | |
130 | { | |
131 | uint32_t changes = val & *lev; | |
132 | uint32_t cur = 1; | |
133 | ||
134 | int i; | |
135 | for (i = 0; i < count; i++) { | |
136 | if ((changes & cur) && (gpfsel_is_out(s, start + i))) { | |
137 | qemu_set_irq(s->out[start + i], 0); | |
138 | } | |
139 | cur <<= 1; | |
140 | } | |
141 | ||
142 | *lev &= ~val; | |
143 | } | |
144 | ||
145 | static uint64_t bcm2835_gpio_read(void *opaque, hwaddr offset, | |
146 | unsigned size) | |
147 | { | |
148 | BCM2835GpioState *s = (BCM2835GpioState *)opaque; | |
149 | ||
150 | switch (offset) { | |
151 | case GPFSEL0: | |
152 | case GPFSEL1: | |
153 | case GPFSEL2: | |
154 | case GPFSEL3: | |
155 | case GPFSEL4: | |
156 | case GPFSEL5: | |
157 | return gpfsel_get(s, offset / 4); | |
158 | case GPSET0: | |
159 | case GPSET1: | |
160 | /* Write Only */ | |
161 | return 0; | |
162 | case GPCLR0: | |
163 | case GPCLR1: | |
164 | /* Write Only */ | |
165 | return 0; | |
166 | case GPLEV0: | |
167 | return s->lev0; | |
168 | case GPLEV1: | |
169 | return s->lev1; | |
170 | case GPEDS0: | |
171 | case GPEDS1: | |
172 | case GPREN0: | |
173 | case GPREN1: | |
174 | case GPFEN0: | |
175 | case GPFEN1: | |
176 | case GPHEN0: | |
177 | case GPHEN1: | |
178 | case GPLEN0: | |
179 | case GPLEN1: | |
180 | case GPAREN0: | |
181 | case GPAREN1: | |
182 | case GPAFEN0: | |
183 | case GPAFEN1: | |
184 | case GPPUD: | |
185 | case GPPUDCLK0: | |
186 | case GPPUDCLK1: | |
187 | /* Not implemented */ | |
188 | return 0; | |
189 | default: | |
190 | qemu_log_mask(LOG_GUEST_ERROR, "%s: Bad offset %"HWADDR_PRIx"\n", | |
191 | __func__, offset); | |
192 | break; | |
193 | } | |
194 | ||
195 | return 0; | |
196 | } | |
197 | ||
198 | static void bcm2835_gpio_write(void *opaque, hwaddr offset, | |
199 | uint64_t value, unsigned size) | |
200 | { | |
201 | BCM2835GpioState *s = (BCM2835GpioState *)opaque; | |
202 | ||
203 | switch (offset) { | |
204 | case GPFSEL0: | |
205 | case GPFSEL1: | |
206 | case GPFSEL2: | |
207 | case GPFSEL3: | |
208 | case GPFSEL4: | |
209 | case GPFSEL5: | |
210 | gpfsel_set(s, offset / 4, value); | |
211 | break; | |
212 | case GPSET0: | |
213 | gpset(s, value, 0, 32, &s->lev0); | |
214 | break; | |
215 | case GPSET1: | |
216 | gpset(s, value, 32, 22, &s->lev1); | |
217 | break; | |
218 | case GPCLR0: | |
219 | gpclr(s, value, 0, 32, &s->lev0); | |
220 | break; | |
221 | case GPCLR1: | |
222 | gpclr(s, value, 32, 22, &s->lev1); | |
223 | break; | |
224 | case GPLEV0: | |
225 | case GPLEV1: | |
226 | /* Read Only */ | |
227 | break; | |
228 | case GPEDS0: | |
229 | case GPEDS1: | |
230 | case GPREN0: | |
231 | case GPREN1: | |
232 | case GPFEN0: | |
233 | case GPFEN1: | |
234 | case GPHEN0: | |
235 | case GPHEN1: | |
236 | case GPLEN0: | |
237 | case GPLEN1: | |
238 | case GPAREN0: | |
239 | case GPAREN1: | |
240 | case GPAFEN0: | |
241 | case GPAFEN1: | |
242 | case GPPUD: | |
243 | case GPPUDCLK0: | |
244 | case GPPUDCLK1: | |
245 | /* Not implemented */ | |
246 | break; | |
247 | default: | |
248 | goto err_out; | |
249 | } | |
250 | return; | |
251 | ||
252 | err_out: | |
253 | qemu_log_mask(LOG_GUEST_ERROR, "%s: Bad offset %"HWADDR_PRIx"\n", | |
254 | __func__, offset); | |
255 | } | |
256 | ||
257 | static void bcm2835_gpio_reset(DeviceState *dev) | |
258 | { | |
259 | BCM2835GpioState *s = BCM2835_GPIO(dev); | |
260 | ||
261 | int i; | |
262 | for (i = 0; i < 6; i++) { | |
263 | gpfsel_set(s, i, 0); | |
264 | } | |
265 | ||
266 | s->sd_fsel = 0; | |
267 | ||
268 | /* SDHCI is selected by default */ | |
269 | sdbus_reparent_card(&s->sdbus, s->sdbus_sdhci); | |
270 | ||
271 | s->lev0 = 0; | |
272 | s->lev1 = 0; | |
273 | } | |
274 | ||
275 | static const MemoryRegionOps bcm2835_gpio_ops = { | |
276 | .read = bcm2835_gpio_read, | |
277 | .write = bcm2835_gpio_write, | |
278 | .endianness = DEVICE_NATIVE_ENDIAN, | |
279 | }; | |
280 | ||
281 | static const VMStateDescription vmstate_bcm2835_gpio = { | |
282 | .name = "bcm2835_gpio", | |
283 | .version_id = 1, | |
284 | .minimum_version_id = 1, | |
285 | .fields = (VMStateField[]) { | |
286 | VMSTATE_UINT8_ARRAY(fsel, BCM2835GpioState, 54), | |
287 | VMSTATE_UINT32(lev0, BCM2835GpioState), | |
288 | VMSTATE_UINT32(lev1, BCM2835GpioState), | |
289 | VMSTATE_UINT8(sd_fsel, BCM2835GpioState), | |
290 | VMSTATE_END_OF_LIST() | |
291 | } | |
292 | }; | |
293 | ||
294 | static void bcm2835_gpio_init(Object *obj) | |
295 | { | |
296 | BCM2835GpioState *s = BCM2835_GPIO(obj); | |
297 | DeviceState *dev = DEVICE(obj); | |
298 | SysBusDevice *sbd = SYS_BUS_DEVICE(obj); | |
299 | ||
300 | qbus_create_inplace(&s->sdbus, sizeof(s->sdbus), | |
301 | TYPE_SD_BUS, DEVICE(s), "sd-bus"); | |
302 | ||
303 | memory_region_init_io(&s->iomem, obj, | |
304 | &bcm2835_gpio_ops, s, "bcm2835_gpio", 0x1000); | |
305 | sysbus_init_mmio(sbd, &s->iomem); | |
306 | qdev_init_gpio_out(dev, s->out, 54); | |
307 | } | |
308 | ||
309 | static void bcm2835_gpio_realize(DeviceState *dev, Error **errp) | |
310 | { | |
311 | BCM2835GpioState *s = BCM2835_GPIO(dev); | |
312 | Object *obj; | |
313 | Error *err = NULL; | |
314 | ||
315 | obj = object_property_get_link(OBJECT(dev), "sdbus-sdhci", &err); | |
316 | if (obj == NULL) { | |
317 | error_setg(errp, "%s: required sdhci link not found: %s", | |
318 | __func__, error_get_pretty(err)); | |
319 | return; | |
320 | } | |
321 | s->sdbus_sdhci = SD_BUS(obj); | |
322 | ||
323 | obj = object_property_get_link(OBJECT(dev), "sdbus-sdhost", &err); | |
324 | if (obj == NULL) { | |
325 | error_setg(errp, "%s: required sdhost link not found: %s", | |
326 | __func__, error_get_pretty(err)); | |
327 | return; | |
328 | } | |
329 | s->sdbus_sdhost = SD_BUS(obj); | |
330 | } | |
331 | ||
332 | static void bcm2835_gpio_class_init(ObjectClass *klass, void *data) | |
333 | { | |
334 | DeviceClass *dc = DEVICE_CLASS(klass); | |
335 | ||
336 | dc->vmsd = &vmstate_bcm2835_gpio; | |
337 | dc->realize = &bcm2835_gpio_realize; | |
338 | dc->reset = &bcm2835_gpio_reset; | |
339 | } | |
340 | ||
341 | static const TypeInfo bcm2835_gpio_info = { | |
342 | .name = TYPE_BCM2835_GPIO, | |
343 | .parent = TYPE_SYS_BUS_DEVICE, | |
344 | .instance_size = sizeof(BCM2835GpioState), | |
345 | .instance_init = bcm2835_gpio_init, | |
346 | .class_init = bcm2835_gpio_class_init, | |
347 | }; | |
348 | ||
349 | static void bcm2835_gpio_register_types(void) | |
350 | { | |
351 | type_register_static(&bcm2835_gpio_info); | |
352 | } | |
353 | ||
354 | type_init(bcm2835_gpio_register_types) |