@samitouri / QOSamiQemu
Code Commits Issues Pulls Sessions CI/CD
master
master
c 422 lines 13.1 KB
Raw
1 /*
2 * Nuvoton NPCM7xx General Purpose Input / Output (GPIO)
3 *
4 * Copyright 2020 Google LLC
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * version 2 as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 */
15
16 #include "qemu/osdep.h"
17
18 #include "hw/gpio/npcm7xx_gpio.h"
19 #include "hw/core/irq.h"
20 #include "hw/core/qdev-properties.h"
21 #include "migration/vmstate.h"
22 #include "qapi/error.h"
23 #include "qemu/log.h"
24 #include "qemu/module.h"
25 #include "qemu/units.h"
26 #include "trace.h"
27
28 /* 32-bit register indices. */
29 enum NPCM7xxGPIORegister {
30 NPCM7XX_GPIO_TLOCK1,
31 NPCM7XX_GPIO_DIN,
32 NPCM7XX_GPIO_POL,
33 NPCM7XX_GPIO_DOUT,
34 NPCM7XX_GPIO_OE,
35 NPCM7XX_GPIO_OTYP,
36 NPCM7XX_GPIO_MP,
37 NPCM7XX_GPIO_PU,
38 NPCM7XX_GPIO_PD,
39 NPCM7XX_GPIO_DBNC,
40 NPCM7XX_GPIO_EVTYP,
41 NPCM7XX_GPIO_EVBE,
42 NPCM7XX_GPIO_OBL0,
43 NPCM7XX_GPIO_OBL1,
44 NPCM7XX_GPIO_OBL2,
45 NPCM7XX_GPIO_OBL3,
46 NPCM7XX_GPIO_EVEN,
47 NPCM7XX_GPIO_EVENS,
48 NPCM7XX_GPIO_EVENC,
49 NPCM7XX_GPIO_EVST,
50 NPCM7XX_GPIO_SPLCK,
51 NPCM7XX_GPIO_MPLCK,
52 NPCM7XX_GPIO_IEM,
53 NPCM7XX_GPIO_OSRC,
54 NPCM7XX_GPIO_ODSC,
55 NPCM7XX_GPIO_DOS = 0x68 / sizeof(uint32_t),
56 NPCM7XX_GPIO_DOC,
57 NPCM7XX_GPIO_OES,
58 NPCM7XX_GPIO_OEC,
59 NPCM7XX_GPIO_TLOCK2 = 0x7c / sizeof(uint32_t),
60 NPCM7XX_GPIO_REGS_END,
61 };
62
63 #define NPCM7XX_GPIO_REGS_SIZE (4 * KiB)
64
65 #define NPCM7XX_GPIO_LOCK_MAGIC1 (0xc0defa73)
66 #define NPCM7XX_GPIO_LOCK_MAGIC2 (0xc0de1248)
67
68 static void npcm7xx_gpio_update_events(NPCM7xxGPIOState *s, uint32_t din_diff)
69 {
70 uint32_t din_new = s->regs[NPCM7XX_GPIO_DIN];
71
72 /* Trigger on high level */
73 s->regs[NPCM7XX_GPIO_EVST] |= din_new & ~s->regs[NPCM7XX_GPIO_EVTYP];
74 /* Trigger on both edges */
75 s->regs[NPCM7XX_GPIO_EVST] |= (din_diff & s->regs[NPCM7XX_GPIO_EVTYP]
76 & s->regs[NPCM7XX_GPIO_EVBE]);
77 /* Trigger on rising edge */
78 s->regs[NPCM7XX_GPIO_EVST] |= (din_diff & din_new
79 & s->regs[NPCM7XX_GPIO_EVTYP]);
80
81 trace_npcm7xx_gpio_update_events(DEVICE(s)->canonical_path,
82 s->regs[NPCM7XX_GPIO_EVST],
83 s->regs[NPCM7XX_GPIO_EVEN]);
84 qemu_set_irq(s->irq, !!(s->regs[NPCM7XX_GPIO_EVST]
85 & s->regs[NPCM7XX_GPIO_EVEN]));
86 }
87
88 static void npcm7xx_gpio_update_pins(NPCM7xxGPIOState *s, uint32_t diff)
89 {
90 uint32_t drive_en;
91 uint32_t drive_lvl;
92 uint32_t not_driven;
93 uint32_t undefined;
94 uint32_t pin_diff;
95 uint32_t din_old;
96
97 /* Calculate level of each pin driven by GPIO controller. */
98 drive_lvl = s->regs[NPCM7XX_GPIO_DOUT] ^ s->regs[NPCM7XX_GPIO_POL];
99 /* If OTYP=1, only drive low (open drain) */
100 drive_en = s->regs[NPCM7XX_GPIO_OE] & ~(s->regs[NPCM7XX_GPIO_OTYP]
101 & drive_lvl);
102 /*
103 * If a pin is driven to opposite levels by the GPIO controller and the
104 * external driver, the result is undefined.
105 */
106 undefined = drive_en & s->ext_driven & (drive_lvl ^ s->ext_level);
107 if (undefined) {
108 qemu_log_mask(LOG_GUEST_ERROR,
109 "%s: pins have multiple drivers: 0x%" PRIx32 "\n",
110 DEVICE(s)->canonical_path, undefined);
111 }
112
113 not_driven = ~(drive_en | s->ext_driven);
114 pin_diff = s->pin_level;
115
116 /* Set pins to externally driven level. */
117 s->pin_level = s->ext_level & s->ext_driven;
118 /* Set internally driven pins, ignoring any conflicts. */
119 s->pin_level |= drive_lvl & drive_en;
120 /* Pull up undriven pins with internal pull-up enabled. */
121 s->pin_level |= not_driven & s->regs[NPCM7XX_GPIO_PU];
122 /* Pins not driven, pulled up or pulled down are undefined */
123 undefined |= not_driven & ~(s->regs[NPCM7XX_GPIO_PU]
124 | s->regs[NPCM7XX_GPIO_PD]);
125
126 /* If any pins changed state, update the outgoing GPIOs. */
127 pin_diff ^= s->pin_level;
128 pin_diff |= undefined & diff;
129 if (pin_diff) {
130 int i;
131
132 for (i = 0; i < NPCM7XX_GPIO_NR_PINS; i++) {
133 uint32_t mask = BIT(i);
134 if (pin_diff & mask) {
135 int level = (undefined & mask) ? -1 : !!(s->pin_level & mask);
136 trace_npcm7xx_gpio_set_output(DEVICE(s)->canonical_path,
137 i, level);
138 qemu_set_irq(s->output[i], level);
139 }
140 }
141 }
142
143 /* Calculate new value of DIN after masking and polarity setting. */
144 din_old = s->regs[NPCM7XX_GPIO_DIN];
145 s->regs[NPCM7XX_GPIO_DIN] = ((s->pin_level & s->regs[NPCM7XX_GPIO_IEM])
146 ^ s->regs[NPCM7XX_GPIO_POL]);
147
148 /* See if any new events triggered because of all this. */
149 npcm7xx_gpio_update_events(s, din_old ^ s->regs[NPCM7XX_GPIO_DIN]);
150 }
151
152 static bool npcm7xx_gpio_is_locked(NPCM7xxGPIOState *s)
153 {
154 return s->regs[NPCM7XX_GPIO_TLOCK1] == 1;
155 }
156
157 static uint64_t npcm7xx_gpio_regs_read(void *opaque, hwaddr addr,
158 unsigned int size)
159 {
160 hwaddr reg = addr / sizeof(uint32_t);
161 NPCM7xxGPIOState *s = opaque;
162 uint64_t value = 0;
163
164 switch (reg) {
165 case NPCM7XX_GPIO_TLOCK1 ... NPCM7XX_GPIO_EVEN:
166 case NPCM7XX_GPIO_EVST ... NPCM7XX_GPIO_ODSC:
167 value = s->regs[reg];
168 break;
169
170 case NPCM7XX_GPIO_EVENS ... NPCM7XX_GPIO_EVENC:
171 case NPCM7XX_GPIO_DOS ... NPCM7XX_GPIO_TLOCK2:
172 qemu_log_mask(LOG_GUEST_ERROR,
173 "%s: read from write-only register 0x%" HWADDR_PRIx "\n",
174 DEVICE(s)->canonical_path, addr);
175 break;
176
177 default:
178 qemu_log_mask(LOG_GUEST_ERROR,
179 "%s: read from invalid offset 0x%" HWADDR_PRIx "\n",
180 DEVICE(s)->canonical_path, addr);
181 break;
182 }
183
184 trace_npcm7xx_gpio_read(DEVICE(s)->canonical_path, addr, value);
185
186 return value;
187 }
188
189 static void npcm7xx_gpio_regs_write(void *opaque, hwaddr addr, uint64_t v,
190 unsigned int size)
191 {
192 hwaddr reg = addr / sizeof(uint32_t);
193 NPCM7xxGPIOState *s = opaque;
194 uint32_t value = v;
195 uint32_t diff;
196
197 trace_npcm7xx_gpio_write(DEVICE(s)->canonical_path, addr, v);
198
199 if (npcm7xx_gpio_is_locked(s)) {
200 switch (reg) {
201 case NPCM7XX_GPIO_TLOCK1:
202 if (s->regs[NPCM7XX_GPIO_TLOCK2] == NPCM7XX_GPIO_LOCK_MAGIC2 &&
203 value == NPCM7XX_GPIO_LOCK_MAGIC1) {
204 s->regs[NPCM7XX_GPIO_TLOCK1] = 0;
205 s->regs[NPCM7XX_GPIO_TLOCK2] = 0;
206 }
207 break;
208
209 case NPCM7XX_GPIO_TLOCK2:
210 s->regs[reg] = value;
211 break;
212
213 default:
214 qemu_log_mask(LOG_GUEST_ERROR,
215 "%s: write to locked register @ 0x%" HWADDR_PRIx "\n",
216 DEVICE(s)->canonical_path, addr);
217 break;
218 }
219
220 return;
221 }
222
223 switch (reg) {
224 case NPCM7XX_GPIO_TLOCK1:
225 case NPCM7XX_GPIO_TLOCK2:
226 s->regs[NPCM7XX_GPIO_TLOCK1] = 1;
227 s->regs[NPCM7XX_GPIO_TLOCK2] = 0;
228 break;
229
230 case NPCM7XX_GPIO_DIN:
231 qemu_log_mask(LOG_GUEST_ERROR,
232 "%s: write to read-only register @ 0x%" HWADDR_PRIx "\n",
233 DEVICE(s)->canonical_path, addr);
234 break;
235
236 case NPCM7XX_GPIO_POL:
237 case NPCM7XX_GPIO_DOUT:
238 case NPCM7XX_GPIO_OE:
239 case NPCM7XX_GPIO_OTYP:
240 case NPCM7XX_GPIO_PU:
241 case NPCM7XX_GPIO_PD:
242 case NPCM7XX_GPIO_IEM:
243 diff = s->regs[reg] ^ value;
244 s->regs[reg] = value;
245 npcm7xx_gpio_update_pins(s, diff);
246 break;
247
248 case NPCM7XX_GPIO_DOS:
249 s->regs[NPCM7XX_GPIO_DOUT] |= value;
250 npcm7xx_gpio_update_pins(s, value);
251 break;
252 case NPCM7XX_GPIO_DOC:
253 s->regs[NPCM7XX_GPIO_DOUT] &= ~value;
254 npcm7xx_gpio_update_pins(s, value);
255 break;
256 case NPCM7XX_GPIO_OES:
257 s->regs[NPCM7XX_GPIO_OE] |= value;
258 npcm7xx_gpio_update_pins(s, value);
259 break;
260 case NPCM7XX_GPIO_OEC:
261 s->regs[NPCM7XX_GPIO_OE] &= ~value;
262 npcm7xx_gpio_update_pins(s, value);
263 break;
264
265 case NPCM7XX_GPIO_EVTYP:
266 case NPCM7XX_GPIO_EVBE:
267 case NPCM7XX_GPIO_EVEN:
268 s->regs[reg] = value;
269 npcm7xx_gpio_update_events(s, 0);
270 break;
271
272 case NPCM7XX_GPIO_EVENS:
273 s->regs[NPCM7XX_GPIO_EVEN] |= value;
274 npcm7xx_gpio_update_events(s, 0);
275 break;
276 case NPCM7XX_GPIO_EVENC:
277 s->regs[NPCM7XX_GPIO_EVEN] &= ~value;
278 npcm7xx_gpio_update_events(s, 0);
279 break;
280
281 case NPCM7XX_GPIO_EVST:
282 s->regs[reg] &= ~value;
283 npcm7xx_gpio_update_events(s, 0);
284 break;
285
286 case NPCM7XX_GPIO_MP:
287 case NPCM7XX_GPIO_DBNC:
288 case NPCM7XX_GPIO_OSRC:
289 case NPCM7XX_GPIO_ODSC:
290 /* Nothing to do; just store the value. */
291 s->regs[reg] = value;
292 break;
293
294 case NPCM7XX_GPIO_OBL0:
295 case NPCM7XX_GPIO_OBL1:
296 case NPCM7XX_GPIO_OBL2:
297 case NPCM7XX_GPIO_OBL3:
298 s->regs[reg] = value;
299 qemu_log_mask(LOG_UNIMP, "%s: Blinking is not implemented\n",
300 __func__);
301 break;
302
303 case NPCM7XX_GPIO_SPLCK:
304 case NPCM7XX_GPIO_MPLCK:
305 qemu_log_mask(LOG_UNIMP, "%s: Per-pin lock is not implemented\n",
306 __func__);
307 break;
308
309 default:
310 qemu_log_mask(LOG_GUEST_ERROR,
311 "%s: write to invalid offset 0x%" HWADDR_PRIx "\n",
312 DEVICE(s)->canonical_path, addr);
313 break;
314 }
315 }
316
317 static const MemoryRegionOps npcm7xx_gpio_regs_ops = {
318 .read = npcm7xx_gpio_regs_read,
319 .write = npcm7xx_gpio_regs_write,
320 .endianness = DEVICE_NATIVE_ENDIAN,
321 .valid = {
322 .min_access_size = 4,
323 .max_access_size = 4,
324 .unaligned = false,
325 },
326 };
327
328 static void npcm7xx_gpio_set_input(void *opaque, int line, int level)
329 {
330 NPCM7xxGPIOState *s = opaque;
331
332 trace_npcm7xx_gpio_set_input(DEVICE(s)->canonical_path, line, level);
333
334 g_assert(line >= 0 && line < NPCM7XX_GPIO_NR_PINS);
335
336 s->ext_driven = deposit32(s->ext_driven, line, 1, level >= 0);
337 s->ext_level = deposit32(s->ext_level, line, 1, level > 0);
338
339 npcm7xx_gpio_update_pins(s, BIT(line));
340 }
341
342 static void npcm7xx_gpio_enter_reset(Object *obj, ResetType type)
343 {
344 NPCM7xxGPIOState *s = NPCM7XX_GPIO(obj);
345
346 memset(s->regs, 0, sizeof(s->regs));
347
348 s->regs[NPCM7XX_GPIO_PU] = s->reset_pu;
349 s->regs[NPCM7XX_GPIO_PD] = s->reset_pd;
350 s->regs[NPCM7XX_GPIO_OSRC] = s->reset_osrc;
351 s->regs[NPCM7XX_GPIO_ODSC] = s->reset_odsc;
352 }
353
354 static void npcm7xx_gpio_hold_reset(Object *obj, ResetType type)
355 {
356 NPCM7xxGPIOState *s = NPCM7XX_GPIO(obj);
357
358 npcm7xx_gpio_update_pins(s, -1);
359 }
360
361 static void npcm7xx_gpio_init(Object *obj)
362 {
363 NPCM7xxGPIOState *s = NPCM7XX_GPIO(obj);
364 DeviceState *dev = DEVICE(obj);
365
366 memory_region_init_io(&s->mmio, obj, &npcm7xx_gpio_regs_ops, s,
367 "regs", NPCM7XX_GPIO_REGS_SIZE);
368 sysbus_init_mmio(SYS_BUS_DEVICE(obj), &s->mmio);
369 sysbus_init_irq(SYS_BUS_DEVICE(obj), &s->irq);
370
371 qdev_init_gpio_in(dev, npcm7xx_gpio_set_input, NPCM7XX_GPIO_NR_PINS);
372 qdev_init_gpio_out(dev, s->output, NPCM7XX_GPIO_NR_PINS);
373 }
374
375 static const VMStateDescription vmstate_npcm7xx_gpio = {
376 .name = "npcm7xx-gpio",
377 .version_id = 0,
378 .minimum_version_id = 0,
379 .fields = (const VMStateField[]) {
380 VMSTATE_UINT32(pin_level, NPCM7xxGPIOState),
381 VMSTATE_UINT32(ext_level, NPCM7xxGPIOState),
382 VMSTATE_UINT32(ext_driven, NPCM7xxGPIOState),
383 VMSTATE_UINT32_ARRAY(regs, NPCM7xxGPIOState, NPCM7XX_GPIO_NR_REGS),
384 VMSTATE_END_OF_LIST(),
385 },
386 };
387
388 static const Property npcm7xx_gpio_properties[] = {
389 /* Bit n set => pin n has pullup enabled by default. */
390 DEFINE_PROP_UINT32("reset-pullup", NPCM7xxGPIOState, reset_pu, 0),
391 /* Bit n set => pin n has pulldown enabled by default. */
392 DEFINE_PROP_UINT32("reset-pulldown", NPCM7xxGPIOState, reset_pd, 0),
393 /* Bit n set => pin n has high slew rate by default. */
394 DEFINE_PROP_UINT32("reset-osrc", NPCM7xxGPIOState, reset_osrc, 0),
395 /* Bit n set => pin n has high drive strength by default. */
396 DEFINE_PROP_UINT32("reset-odsc", NPCM7xxGPIOState, reset_odsc, 0),
397 };
398
399 static void npcm7xx_gpio_class_init(ObjectClass *klass, const void *data)
400 {
401 ResettableClass *reset = RESETTABLE_CLASS(klass);
402 DeviceClass *dc = DEVICE_CLASS(klass);
403
404 QEMU_BUILD_BUG_ON(NPCM7XX_GPIO_REGS_END > NPCM7XX_GPIO_NR_REGS);
405
406 dc->desc = "NPCM7xx GPIO Controller";
407 dc->vmsd = &vmstate_npcm7xx_gpio;
408 reset->phases.enter = npcm7xx_gpio_enter_reset;
409 reset->phases.hold = npcm7xx_gpio_hold_reset;
410 device_class_set_props(dc, npcm7xx_gpio_properties);
411 }
412
413 static const TypeInfo npcm7xx_gpio_types[] = {
414 {
415 .name = TYPE_NPCM7XX_GPIO,
416 .parent = TYPE_SYS_BUS_DEVICE,
417 .instance_size = sizeof(NPCM7xxGPIOState),
418 .class_init = npcm7xx_gpio_class_init,
419 .instance_init = npcm7xx_gpio_init,
420 },
421 };
422 DEFINE_TYPES(npcm7xx_gpio_types);