Software APIs
dif_gpio_autogen.c
1 // Copyright lowRISC contributors (OpenTitan project).
2 // Licensed under the Apache License, Version 2.0, see LICENSE for details.
3 // SPDX-License-Identifier: Apache-2.0
4 
5 // THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND:
6 // util/make_new_dif.py --mode=regen --only=autogen
7 
9 
10 #include <stdint.h>
11 
13 
14 #include "gpio_regs.h" // Generated.
15 
18  if (gpio == NULL) {
19  return kDifBadArg;
20  }
21 
22  gpio->base_addr = base_addr;
23 
24  return kDifOk;
25 }
26 
28  dif_gpio_alert_t alert) {
29  if (gpio == NULL) {
30  return kDifBadArg;
31  }
32 
33  bitfield_bit32_index_t alert_idx;
34  switch (alert) {
36  alert_idx = GPIO_ALERT_TEST_FATAL_FAULT_BIT;
37  break;
38  default:
39  return kDifBadArg;
40  }
41 
42  uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true);
43  mmio_region_write32(gpio->base_addr, (ptrdiff_t)GPIO_ALERT_TEST_REG_OFFSET,
44  alert_test_reg);
45 
46  return kDifOk;
47 }
48 
49 /**
50  * Get the corresponding interrupt register bit offset of the IRQ.
51  */
52 static bool gpio_get_irq_bit_index(dif_gpio_irq_t irq,
53  bitfield_bit32_index_t *index_out) {
54  switch (irq) {
55  case kDifGpioIrqGpio0:
56  *index_out = 0;
57  break;
58  case kDifGpioIrqGpio1:
59  *index_out = 1;
60  break;
61  case kDifGpioIrqGpio2:
62  *index_out = 2;
63  break;
64  case kDifGpioIrqGpio3:
65  *index_out = 3;
66  break;
67  case kDifGpioIrqGpio4:
68  *index_out = 4;
69  break;
70  case kDifGpioIrqGpio5:
71  *index_out = 5;
72  break;
73  case kDifGpioIrqGpio6:
74  *index_out = 6;
75  break;
76  case kDifGpioIrqGpio7:
77  *index_out = 7;
78  break;
79  case kDifGpioIrqGpio8:
80  *index_out = 8;
81  break;
82  case kDifGpioIrqGpio9:
83  *index_out = 9;
84  break;
85  case kDifGpioIrqGpio10:
86  *index_out = 10;
87  break;
88  case kDifGpioIrqGpio11:
89  *index_out = 11;
90  break;
91  case kDifGpioIrqGpio12:
92  *index_out = 12;
93  break;
94  case kDifGpioIrqGpio13:
95  *index_out = 13;
96  break;
97  case kDifGpioIrqGpio14:
98  *index_out = 14;
99  break;
100  case kDifGpioIrqGpio15:
101  *index_out = 15;
102  break;
103  case kDifGpioIrqGpio16:
104  *index_out = 16;
105  break;
106  case kDifGpioIrqGpio17:
107  *index_out = 17;
108  break;
109  case kDifGpioIrqGpio18:
110  *index_out = 18;
111  break;
112  case kDifGpioIrqGpio19:
113  *index_out = 19;
114  break;
115  case kDifGpioIrqGpio20:
116  *index_out = 20;
117  break;
118  case kDifGpioIrqGpio21:
119  *index_out = 21;
120  break;
121  case kDifGpioIrqGpio22:
122  *index_out = 22;
123  break;
124  case kDifGpioIrqGpio23:
125  *index_out = 23;
126  break;
127  case kDifGpioIrqGpio24:
128  *index_out = 24;
129  break;
130  case kDifGpioIrqGpio25:
131  *index_out = 25;
132  break;
133  case kDifGpioIrqGpio26:
134  *index_out = 26;
135  break;
136  case kDifGpioIrqGpio27:
137  *index_out = 27;
138  break;
139  case kDifGpioIrqGpio28:
140  *index_out = 28;
141  break;
142  case kDifGpioIrqGpio29:
143  *index_out = 29;
144  break;
145  case kDifGpioIrqGpio30:
146  *index_out = 30;
147  break;
148  case kDifGpioIrqGpio31:
149  *index_out = 31;
150  break;
151  default:
152  return false;
153  }
154 
155  return true;
156 }
157 
158 static dif_irq_type_t irq_types[] = {
167 };
168 
171  dif_irq_type_t *type) {
172  if (gpio == NULL || type == NULL || irq < 0 || irq > kDifGpioIrqGpio31) {
173  return kDifBadArg;
174  }
175 
176  *type = irq_types[irq];
177 
178  return kDifOk;
179 }
180 
183  dif_gpio_irq_state_snapshot_t *snapshot) {
184  if (gpio == NULL || snapshot == NULL) {
185  return kDifBadArg;
186  }
187 
188  *snapshot = mmio_region_read32(gpio->base_addr,
189  (ptrdiff_t)GPIO_INTR_STATE_REG_OFFSET);
190 
191  return kDifOk;
192 }
193 
196  const dif_gpio_t *gpio, dif_gpio_irq_state_snapshot_t snapshot) {
197  if (gpio == NULL) {
198  return kDifBadArg;
199  }
200 
201  mmio_region_write32(gpio->base_addr, (ptrdiff_t)GPIO_INTR_STATE_REG_OFFSET,
202  snapshot);
203 
204  return kDifOk;
205 }
206 
209  bool *is_pending) {
210  if (gpio == NULL || is_pending == NULL) {
211  return kDifBadArg;
212  }
213 
215  if (!gpio_get_irq_bit_index(irq, &index)) {
216  return kDifBadArg;
217  }
218 
219  uint32_t intr_state_reg = mmio_region_read32(
220  gpio->base_addr, (ptrdiff_t)GPIO_INTR_STATE_REG_OFFSET);
221 
222  *is_pending = bitfield_bit32_read(intr_state_reg, index);
223 
224  return kDifOk;
225 }
226 
229  if (gpio == NULL) {
230  return kDifBadArg;
231  }
232 
233  // Writing to the register clears the corresponding bits (Write-one clear).
234  mmio_region_write32(gpio->base_addr, (ptrdiff_t)GPIO_INTR_STATE_REG_OFFSET,
235  UINT32_MAX);
236 
237  return kDifOk;
238 }
239 
242  dif_gpio_irq_t irq) {
243  if (gpio == NULL) {
244  return kDifBadArg;
245  }
246 
248  if (!gpio_get_irq_bit_index(irq, &index)) {
249  return kDifBadArg;
250  }
251 
252  // Writing to the register clears the corresponding bits (Write-one clear).
253  uint32_t intr_state_reg = bitfield_bit32_write(0, index, true);
254  mmio_region_write32(gpio->base_addr, (ptrdiff_t)GPIO_INTR_STATE_REG_OFFSET,
255  intr_state_reg);
256 
257  return kDifOk;
258 }
259 
262  const bool val) {
263  if (gpio == NULL) {
264  return kDifBadArg;
265  }
266 
268  if (!gpio_get_irq_bit_index(irq, &index)) {
269  return kDifBadArg;
270  }
271 
272  uint32_t intr_test_reg = bitfield_bit32_write(0, index, val);
273  mmio_region_write32(gpio->base_addr, (ptrdiff_t)GPIO_INTR_TEST_REG_OFFSET,
274  intr_test_reg);
275 
276  return kDifOk;
277 }
278 
281  dif_gpio_irq_t irq, dif_toggle_t *state) {
282  if (gpio == NULL || state == NULL) {
283  return kDifBadArg;
284  }
285 
287  if (!gpio_get_irq_bit_index(irq, &index)) {
288  return kDifBadArg;
289  }
290 
291  uint32_t intr_enable_reg = mmio_region_read32(
292  gpio->base_addr, (ptrdiff_t)GPIO_INTR_ENABLE_REG_OFFSET);
293 
294  bool is_enabled = bitfield_bit32_read(intr_enable_reg, index);
295  *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled;
296 
297  return kDifOk;
298 }
299 
302  dif_gpio_irq_t irq, dif_toggle_t state) {
303  if (gpio == NULL) {
304  return kDifBadArg;
305  }
306 
308  if (!gpio_get_irq_bit_index(irq, &index)) {
309  return kDifBadArg;
310  }
311 
312  uint32_t intr_enable_reg = mmio_region_read32(
313  gpio->base_addr, (ptrdiff_t)GPIO_INTR_ENABLE_REG_OFFSET);
314 
315  bool enable_bit = (state == kDifToggleEnabled) ? true : false;
316  intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit);
317  mmio_region_write32(gpio->base_addr, (ptrdiff_t)GPIO_INTR_ENABLE_REG_OFFSET,
318  intr_enable_reg);
319 
320  return kDifOk;
321 }
322 
325  const dif_gpio_t *gpio, dif_gpio_irq_enable_snapshot_t *snapshot) {
326  if (gpio == NULL) {
327  return kDifBadArg;
328  }
329 
330  // Pass the current interrupt state to the caller, if requested.
331  if (snapshot != NULL) {
332  *snapshot = mmio_region_read32(gpio->base_addr,
333  (ptrdiff_t)GPIO_INTR_ENABLE_REG_OFFSET);
334  }
335 
336  // Disable all interrupts.
337  mmio_region_write32(gpio->base_addr, (ptrdiff_t)GPIO_INTR_ENABLE_REG_OFFSET,
338  0u);
339 
340  return kDifOk;
341 }
342 
345  const dif_gpio_t *gpio, const dif_gpio_irq_enable_snapshot_t *snapshot) {
346  if (gpio == NULL || snapshot == NULL) {
347  return kDifBadArg;
348  }
349 
350  mmio_region_write32(gpio->base_addr, (ptrdiff_t)GPIO_INTR_ENABLE_REG_OFFSET,
351  *snapshot);
352 
353  return kDifOk;
354 }