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 
8 #include "sw/device/lib/dif/autogen/dif_gpio_autogen.h"
9 
10 #include <stdint.h>
11 
12 #include "sw/device/lib/dif/dif_base.h"
13 
14 #include "gpio_regs.h" // Generated.
15 
16 OT_WARN_UNUSED_RESULT
17 dif_result_t dif_gpio_init(mmio_region_t base_addr, dif_gpio_t *gpio) {
18  if (gpio == NULL) {
19  return kDifBadArg;
20  }
21 
22  gpio->base_addr = base_addr;
23 
24  return kDifOk;
25 }
26 
27 dif_result_t dif_gpio_alert_force(const dif_gpio_t *gpio,
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) {
35  case kDifGpioAlertFatalFault:
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[] = {
159  kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent,
160  kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent,
161  kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent,
162  kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent,
163  kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent,
164  kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent,
165  kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent,
166  kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent, kDifIrqTypeEvent,
167 };
168 
169 OT_WARN_UNUSED_RESULT
170 dif_result_t dif_gpio_irq_get_type(const dif_gpio_t *gpio, dif_gpio_irq_t irq,
171  dif_irq_type_t *type) {
172  if (gpio == NULL || type == NULL || irq == kDifGpioIrqGpio31 + 1) {
173  return kDifBadArg;
174  }
175 
176  *type = irq_types[irq];
177 
178  return kDifOk;
179 }
180 
181 OT_WARN_UNUSED_RESULT
182 dif_result_t dif_gpio_irq_get_state(const dif_gpio_t *gpio,
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 
194 OT_WARN_UNUSED_RESULT
195 dif_result_t dif_gpio_irq_acknowledge_state(
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 
207 OT_WARN_UNUSED_RESULT
208 dif_result_t dif_gpio_irq_is_pending(const dif_gpio_t *gpio, dif_gpio_irq_t irq,
209  bool *is_pending) {
210  if (gpio == NULL || is_pending == NULL) {
211  return kDifBadArg;
212  }
213 
214  bitfield_bit32_index_t index;
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 
227 OT_WARN_UNUSED_RESULT
228 dif_result_t dif_gpio_irq_acknowledge_all(const dif_gpio_t *gpio) {
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 
240 OT_WARN_UNUSED_RESULT
241 dif_result_t dif_gpio_irq_acknowledge(const dif_gpio_t *gpio,
242  dif_gpio_irq_t irq) {
243  if (gpio == NULL) {
244  return kDifBadArg;
245  }
246 
247  bitfield_bit32_index_t index;
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 
260 OT_WARN_UNUSED_RESULT
261 dif_result_t dif_gpio_irq_force(const dif_gpio_t *gpio, dif_gpio_irq_t irq,
262  const bool val) {
263  if (gpio == NULL) {
264  return kDifBadArg;
265  }
266 
267  bitfield_bit32_index_t index;
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 
279 OT_WARN_UNUSED_RESULT
280 dif_result_t dif_gpio_irq_get_enabled(const dif_gpio_t *gpio,
281  dif_gpio_irq_t irq, dif_toggle_t *state) {
282  if (gpio == NULL || state == NULL) {
283  return kDifBadArg;
284  }
285 
286  bitfield_bit32_index_t index;
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 
300 OT_WARN_UNUSED_RESULT
301 dif_result_t dif_gpio_irq_set_enabled(const dif_gpio_t *gpio,
302  dif_gpio_irq_t irq, dif_toggle_t state) {
303  if (gpio == NULL) {
304  return kDifBadArg;
305  }
306 
307  bitfield_bit32_index_t index;
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 
323 OT_WARN_UNUSED_RESULT
324 dif_result_t dif_gpio_irq_disable_all(
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 
343 OT_WARN_UNUSED_RESULT
344 dif_result_t dif_gpio_irq_restore_all(
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 }
Return to OpenTitan Documentation