Software APIs
dif_mbx_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_mbx_autogen.h"
9 
10 #include <stdint.h>
11 
12 #include "sw/device/lib/dif/dif_base.h"
13 
14 #include "mbx_regs.h" // Generated.
15 
16 OT_WARN_UNUSED_RESULT
17 dif_result_t dif_mbx_init(mmio_region_t base_addr, dif_mbx_t *mbx) {
18  if (mbx == NULL) {
19  return kDifBadArg;
20  }
21 
22  mbx->base_addr = base_addr;
23 
24  return kDifOk;
25 }
26 
27 dif_result_t dif_mbx_alert_force(const dif_mbx_t *mbx, dif_mbx_alert_t alert) {
28  if (mbx == NULL) {
29  return kDifBadArg;
30  }
31 
32  bitfield_bit32_index_t alert_idx;
33  switch (alert) {
34  case kDifMbxAlertFatalFault:
35  alert_idx = MBX_ALERT_TEST_FATAL_FAULT_BIT;
36  break;
37  case kDifMbxAlertRecovFault:
38  alert_idx = MBX_ALERT_TEST_RECOV_FAULT_BIT;
39  break;
40  default:
41  return kDifBadArg;
42  }
43 
44  uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true);
45  mmio_region_write32(mbx->base_addr, (ptrdiff_t)MBX_ALERT_TEST_REG_OFFSET,
46  alert_test_reg);
47 
48  return kDifOk;
49 }
50 
51 /**
52  * Get the corresponding interrupt register bit offset of the IRQ.
53  */
54 static bool mbx_get_irq_bit_index(dif_mbx_irq_t irq,
55  bitfield_bit32_index_t *index_out) {
56  switch (irq) {
57  case kDifMbxIrqMbxReady:
58  *index_out = MBX_INTR_COMMON_MBX_READY_BIT;
59  break;
60  case kDifMbxIrqMbxAbort:
61  *index_out = MBX_INTR_COMMON_MBX_ABORT_BIT;
62  break;
63  case kDifMbxIrqMbxError:
64  *index_out = MBX_INTR_COMMON_MBX_ERROR_BIT;
65  break;
66  default:
67  return false;
68  }
69 
70  return true;
71 }
72 
73 static dif_irq_type_t irq_types[] = {
74  kDifIrqTypeEvent,
75  kDifIrqTypeEvent,
76  kDifIrqTypeEvent,
77 };
78 
79 OT_WARN_UNUSED_RESULT
80 dif_result_t dif_mbx_irq_get_type(const dif_mbx_t *mbx, dif_mbx_irq_t irq,
81  dif_irq_type_t *type) {
82  if (mbx == NULL || type == NULL || irq < 0 || irq > kDifMbxIrqMbxError) {
83  return kDifBadArg;
84  }
85 
86  *type = irq_types[irq];
87 
88  return kDifOk;
89 }
90 
91 OT_WARN_UNUSED_RESULT
92 dif_result_t dif_mbx_irq_get_state(const dif_mbx_t *mbx,
93  dif_mbx_irq_state_snapshot_t *snapshot) {
94  if (mbx == NULL || snapshot == NULL) {
95  return kDifBadArg;
96  }
97 
98  *snapshot =
99  mmio_region_read32(mbx->base_addr, (ptrdiff_t)MBX_INTR_STATE_REG_OFFSET);
100 
101  return kDifOk;
102 }
103 
104 OT_WARN_UNUSED_RESULT
105 dif_result_t dif_mbx_irq_acknowledge_state(
106  const dif_mbx_t *mbx, dif_mbx_irq_state_snapshot_t snapshot) {
107  if (mbx == NULL) {
108  return kDifBadArg;
109  }
110 
111  mmio_region_write32(mbx->base_addr, (ptrdiff_t)MBX_INTR_STATE_REG_OFFSET,
112  snapshot);
113 
114  return kDifOk;
115 }
116 
117 OT_WARN_UNUSED_RESULT
118 dif_result_t dif_mbx_irq_is_pending(const dif_mbx_t *mbx, dif_mbx_irq_t irq,
119  bool *is_pending) {
120  if (mbx == NULL || is_pending == NULL) {
121  return kDifBadArg;
122  }
123 
124  bitfield_bit32_index_t index;
125  if (!mbx_get_irq_bit_index(irq, &index)) {
126  return kDifBadArg;
127  }
128 
129  uint32_t intr_state_reg =
130  mmio_region_read32(mbx->base_addr, (ptrdiff_t)MBX_INTR_STATE_REG_OFFSET);
131 
132  *is_pending = bitfield_bit32_read(intr_state_reg, index);
133 
134  return kDifOk;
135 }
136 
137 OT_WARN_UNUSED_RESULT
138 dif_result_t dif_mbx_irq_acknowledge_all(const dif_mbx_t *mbx) {
139  if (mbx == NULL) {
140  return kDifBadArg;
141  }
142 
143  // Writing to the register clears the corresponding bits (Write-one clear).
144  mmio_region_write32(mbx->base_addr, (ptrdiff_t)MBX_INTR_STATE_REG_OFFSET,
145  UINT32_MAX);
146 
147  return kDifOk;
148 }
149 
150 OT_WARN_UNUSED_RESULT
151 dif_result_t dif_mbx_irq_acknowledge(const dif_mbx_t *mbx, dif_mbx_irq_t irq) {
152  if (mbx == NULL) {
153  return kDifBadArg;
154  }
155 
156  bitfield_bit32_index_t index;
157  if (!mbx_get_irq_bit_index(irq, &index)) {
158  return kDifBadArg;
159  }
160 
161  // Writing to the register clears the corresponding bits (Write-one clear).
162  uint32_t intr_state_reg = bitfield_bit32_write(0, index, true);
163  mmio_region_write32(mbx->base_addr, (ptrdiff_t)MBX_INTR_STATE_REG_OFFSET,
164  intr_state_reg);
165 
166  return kDifOk;
167 }
168 
169 OT_WARN_UNUSED_RESULT
170 dif_result_t dif_mbx_irq_force(const dif_mbx_t *mbx, dif_mbx_irq_t irq,
171  const bool val) {
172  if (mbx == NULL) {
173  return kDifBadArg;
174  }
175 
176  bitfield_bit32_index_t index;
177  if (!mbx_get_irq_bit_index(irq, &index)) {
178  return kDifBadArg;
179  }
180 
181  uint32_t intr_test_reg = bitfield_bit32_write(0, index, val);
182  mmio_region_write32(mbx->base_addr, (ptrdiff_t)MBX_INTR_TEST_REG_OFFSET,
183  intr_test_reg);
184 
185  return kDifOk;
186 }
187 
188 OT_WARN_UNUSED_RESULT
189 dif_result_t dif_mbx_irq_get_enabled(const dif_mbx_t *mbx, dif_mbx_irq_t irq,
190  dif_toggle_t *state) {
191  if (mbx == NULL || state == NULL) {
192  return kDifBadArg;
193  }
194 
195  bitfield_bit32_index_t index;
196  if (!mbx_get_irq_bit_index(irq, &index)) {
197  return kDifBadArg;
198  }
199 
200  uint32_t intr_enable_reg =
201  mmio_region_read32(mbx->base_addr, (ptrdiff_t)MBX_INTR_ENABLE_REG_OFFSET);
202 
203  bool is_enabled = bitfield_bit32_read(intr_enable_reg, index);
204  *state = is_enabled ? kDifToggleEnabled : kDifToggleDisabled;
205 
206  return kDifOk;
207 }
208 
209 OT_WARN_UNUSED_RESULT
210 dif_result_t dif_mbx_irq_set_enabled(const dif_mbx_t *mbx, dif_mbx_irq_t irq,
211  dif_toggle_t state) {
212  if (mbx == NULL) {
213  return kDifBadArg;
214  }
215 
216  bitfield_bit32_index_t index;
217  if (!mbx_get_irq_bit_index(irq, &index)) {
218  return kDifBadArg;
219  }
220 
221  uint32_t intr_enable_reg =
222  mmio_region_read32(mbx->base_addr, (ptrdiff_t)MBX_INTR_ENABLE_REG_OFFSET);
223 
224  bool enable_bit = (state == kDifToggleEnabled) ? true : false;
225  intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit);
226  mmio_region_write32(mbx->base_addr, (ptrdiff_t)MBX_INTR_ENABLE_REG_OFFSET,
227  intr_enable_reg);
228 
229  return kDifOk;
230 }
231 
232 OT_WARN_UNUSED_RESULT
233 dif_result_t dif_mbx_irq_disable_all(const dif_mbx_t *mbx,
234  dif_mbx_irq_enable_snapshot_t *snapshot) {
235  if (mbx == NULL) {
236  return kDifBadArg;
237  }
238 
239  // Pass the current interrupt state to the caller, if requested.
240  if (snapshot != NULL) {
241  *snapshot = mmio_region_read32(mbx->base_addr,
242  (ptrdiff_t)MBX_INTR_ENABLE_REG_OFFSET);
243  }
244 
245  // Disable all interrupts.
246  mmio_region_write32(mbx->base_addr, (ptrdiff_t)MBX_INTR_ENABLE_REG_OFFSET,
247  0u);
248 
249  return kDifOk;
250 }
251 
252 OT_WARN_UNUSED_RESULT
253 dif_result_t dif_mbx_irq_restore_all(
254  const dif_mbx_t *mbx, const dif_mbx_irq_enable_snapshot_t *snapshot) {
255  if (mbx == NULL || snapshot == NULL) {
256  return kDifBadArg;
257  }
258 
259  mmio_region_write32(mbx->base_addr, (ptrdiff_t)MBX_INTR_ENABLE_REG_OFFSET,
260  *snapshot);
261 
262  return kDifOk;
263 }
Return to OpenTitan Documentation