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