Software APIs
dif_usbdev_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
6
7
8
9
10
11// THIS FILE HAS BEEN GENERATED, DO NOT EDIT MANUALLY. COMMAND:
12// util/autogen_dif.py -i hw/ip/usbdev/data/usbdev.hjson -o
13// bazel-out/k8-fastbuild/bin/sw/device/lib/dif/autogen
14
15
16#include <stdint.h>
17
18#include "sw/device/lib/dif/dif_base.h"
19#include "sw/device/lib/dif/autogen/dif_usbdev_autogen.h"
20
21#include "hw/top/usbdev_regs.h" // Generated.
22
23
24OT_WARN_UNUSED_RESULT
25dif_result_t dif_usbdev_init(
26 mmio_region_t base_addr,
27 dif_usbdev_t *usbdev) {
28 if (usbdev == NULL) {
29 return kDifBadArg;
30 }
31
32 usbdev->dt = kDtUsbdevCount;
33 usbdev->base_addr = base_addr;
34
35 return kDifOk;
36}
37
38OT_WARN_UNUSED_RESULT
39dif_result_t dif_usbdev_init_from_dt(
40 dt_usbdev_t dt,
41 dif_usbdev_t *usbdev) {
42 if (usbdev == NULL) {
43 return kDifBadArg;
44 }
45
46 usbdev->dt = dt;
47 usbdev->base_addr = mmio_region_from_addr(dt_usbdev_primary_reg_block(dt));
48
49 return kDifOk;
50}
51
52dif_result_t dif_usbdev_get_dt(
53 const dif_usbdev_t *usbdev,
54 dt_usbdev_t *dt) {
55 if ((int)usbdev->dt == kDtUsbdevCount || dt == NULL) {
56 return kDifBadArg;
57 }
58 *dt = usbdev->dt;
59 return kDifOk;
60}
61
62 dif_result_t dif_usbdev_alert_force(
63 const dif_usbdev_t *usbdev,
64 dif_usbdev_alert_t alert) {
65 if (usbdev == NULL) {
66 return kDifBadArg;
67 }
68
69 bitfield_bit32_index_t alert_idx;
70 switch (alert) {
71 case kDifUsbdevAlertFatalFault:
72 alert_idx = USBDEV_ALERT_TEST_FATAL_FAULT_BIT;
73 break;
74 default:
75 return kDifBadArg;
76 }
77
78 uint32_t alert_test_reg = bitfield_bit32_write(0, alert_idx, true);
79 mmio_region_write32(
80 usbdev->base_addr,
81 (ptrdiff_t)USBDEV_ALERT_TEST_REG_OFFSET,
82 alert_test_reg);
83
84
85 return kDifOk;
86}
87
88
89 /**
90 * Get the corresponding interrupt register bit offset of the IRQ.
91 */
92 static bool usbdev_get_irq_bit_index(
93 dif_usbdev_irq_t irq,
94 bitfield_bit32_index_t *index_out) {
95
96 switch (irq) {
97 case kDtUsbdevIrqPktReceived:
98 *index_out = USBDEV_INTR_COMMON_PKT_RECEIVED_BIT;
99 break;
100 case kDtUsbdevIrqPktSent:
101 *index_out = USBDEV_INTR_COMMON_PKT_SENT_BIT;
102 break;
103 case kDtUsbdevIrqDisconnected:
104 *index_out = USBDEV_INTR_COMMON_DISCONNECTED_BIT;
105 break;
106 case kDtUsbdevIrqHostLost:
107 *index_out = USBDEV_INTR_COMMON_HOST_LOST_BIT;
108 break;
109 case kDtUsbdevIrqLinkReset:
110 *index_out = USBDEV_INTR_COMMON_LINK_RESET_BIT;
111 break;
112 case kDtUsbdevIrqLinkSuspend:
113 *index_out = USBDEV_INTR_COMMON_LINK_SUSPEND_BIT;
114 break;
115 case kDtUsbdevIrqLinkResume:
116 *index_out = USBDEV_INTR_COMMON_LINK_RESUME_BIT;
117 break;
118 case kDtUsbdevIrqAvOutEmpty:
119 *index_out = USBDEV_INTR_COMMON_AV_OUT_EMPTY_BIT;
120 break;
121 case kDtUsbdevIrqRxFull:
122 *index_out = USBDEV_INTR_COMMON_RX_FULL_BIT;
123 break;
124 case kDtUsbdevIrqAvOverflow:
125 *index_out = USBDEV_INTR_COMMON_AV_OVERFLOW_BIT;
126 break;
127 case kDtUsbdevIrqLinkInErr:
128 *index_out = USBDEV_INTR_COMMON_LINK_IN_ERR_BIT;
129 break;
130 case kDtUsbdevIrqRxCrcErr:
131 *index_out = USBDEV_INTR_COMMON_RX_CRC_ERR_BIT;
132 break;
133 case kDtUsbdevIrqRxPidErr:
134 *index_out = USBDEV_INTR_COMMON_RX_PID_ERR_BIT;
135 break;
136 case kDtUsbdevIrqRxBitstuffErr:
137 *index_out = USBDEV_INTR_COMMON_RX_BITSTUFF_ERR_BIT;
138 break;
139 case kDtUsbdevIrqFrame:
140 *index_out = USBDEV_INTR_COMMON_FRAME_BIT;
141 break;
142 case kDtUsbdevIrqPowered:
143 *index_out = USBDEV_INTR_COMMON_POWERED_BIT;
144 break;
145 case kDtUsbdevIrqLinkOutErr:
146 *index_out = USBDEV_INTR_COMMON_LINK_OUT_ERR_BIT;
147 break;
148 case kDtUsbdevIrqAvSetupEmpty:
149 *index_out = USBDEV_INTR_COMMON_AV_SETUP_EMPTY_BIT;
150 break;
151 default:
152 return false;
153 }
154
155 return true;
156 }
157
158 static dif_irq_type_t irq_types[] = {
159 kDifIrqTypeStatus,
160 kDifIrqTypeStatus,
161 kDifIrqTypeEvent,
162 kDifIrqTypeEvent,
163 kDifIrqTypeEvent,
164 kDifIrqTypeEvent,
165 kDifIrqTypeEvent,
166 kDifIrqTypeStatus,
167 kDifIrqTypeStatus,
168 kDifIrqTypeEvent,
169 kDifIrqTypeEvent,
170 kDifIrqTypeEvent,
171 kDifIrqTypeEvent,
172 kDifIrqTypeEvent,
173 kDifIrqTypeEvent,
174 kDifIrqTypeEvent,
175 kDifIrqTypeEvent,
176 kDifIrqTypeStatus,
177 };
178
179 OT_WARN_UNUSED_RESULT
180 dif_result_t dif_usbdev_irq_get_type(
181 const dif_usbdev_t *usbdev,
182 dif_usbdev_irq_t irq,
183 dif_irq_type_t *type) {
184
185
186 if (usbdev == NULL ||
187 type == NULL ||
188 irq < kDifUsbdevIrqPktReceived ||
189 irq > kDifUsbdevIrqAvSetupEmpty) {
190 return kDifBadArg;
191 }
192
193 *type = irq_types[irq];
194
195 return kDifOk;
196 }
197
198 OT_WARN_UNUSED_RESULT
199 dif_result_t dif_usbdev_irq_get_state(
200 const dif_usbdev_t *usbdev,
201 dif_usbdev_irq_state_snapshot_t *snapshot) {
202
203 if (usbdev == NULL || snapshot == NULL) {
204 return kDifBadArg;
205 }
206
207 *snapshot = mmio_region_read32(
208 usbdev->base_addr,
209 (ptrdiff_t)USBDEV_INTR_STATE_REG_OFFSET);
210
211
212 return kDifOk;
213 }
214
215 OT_WARN_UNUSED_RESULT
216 dif_result_t dif_usbdev_irq_acknowledge_state(
217 const dif_usbdev_t *usbdev,
218 dif_usbdev_irq_state_snapshot_t snapshot) {
219 if (usbdev == NULL) {
220 return kDifBadArg;
221 }
222
223 mmio_region_write32(
224 usbdev->base_addr,
225 (ptrdiff_t)USBDEV_INTR_STATE_REG_OFFSET,
226 snapshot);
227
228
229 return kDifOk;
230 }
231
232 OT_WARN_UNUSED_RESULT
233 dif_result_t dif_usbdev_irq_is_pending(
234 const dif_usbdev_t *usbdev,
235 dif_usbdev_irq_t irq,
236 bool *is_pending) {
237
238 if (usbdev == NULL || is_pending == NULL) {
239 return kDifBadArg;
240 }
241
242 bitfield_bit32_index_t index;
243 if (!usbdev_get_irq_bit_index(irq, &index)) {
244 return kDifBadArg;
245 }
246
247 uint32_t intr_state_reg = mmio_region_read32(
248 usbdev->base_addr,
249 (ptrdiff_t)USBDEV_INTR_STATE_REG_OFFSET);
250
251
252 *is_pending = bitfield_bit32_read(intr_state_reg, index);
253
254 return kDifOk;
255 }
256
257 OT_WARN_UNUSED_RESULT
258 dif_result_t dif_usbdev_irq_acknowledge_all(
259 const dif_usbdev_t *usbdev
260 ) {
261
262 if (usbdev == NULL) {
263 return kDifBadArg;
264 }
265
266 // Writing to the register clears the corresponding bits (Write-one clear).
267 mmio_region_write32(
268 usbdev->base_addr,
269 (ptrdiff_t)USBDEV_INTR_STATE_REG_OFFSET,
270 UINT32_MAX);
271
272
273 return kDifOk;
274 }
275
276 OT_WARN_UNUSED_RESULT
277 dif_result_t dif_usbdev_irq_acknowledge(
278 const dif_usbdev_t *usbdev,
279 dif_usbdev_irq_t irq) {
280
281 if (usbdev == NULL) {
282 return kDifBadArg;
283 }
284
285 bitfield_bit32_index_t index;
286 if (!usbdev_get_irq_bit_index(irq, &index)) {
287 return kDifBadArg;
288 }
289
290 // Writing to the register clears the corresponding bits (Write-one clear).
291 uint32_t intr_state_reg = bitfield_bit32_write(0, index, true);
292 mmio_region_write32(
293 usbdev->base_addr,
294 (ptrdiff_t)USBDEV_INTR_STATE_REG_OFFSET,
295 intr_state_reg);
296
297
298 return kDifOk;
299 }
300
301 OT_WARN_UNUSED_RESULT
302 dif_result_t dif_usbdev_irq_force(
303 const dif_usbdev_t *usbdev,
304 dif_usbdev_irq_t irq,
305 const bool val) {
306
307 if (usbdev == NULL) {
308 return kDifBadArg;
309 }
310
311 bitfield_bit32_index_t index;
312 if (!usbdev_get_irq_bit_index(irq, &index)) {
313 return kDifBadArg;
314 }
315
316 uint32_t intr_test_reg = bitfield_bit32_write(0, index, val);
317 mmio_region_write32(
318 usbdev->base_addr,
319 (ptrdiff_t)USBDEV_INTR_TEST_REG_OFFSET,
320 intr_test_reg);
321
322
323 return kDifOk;
324 }
325
326 OT_WARN_UNUSED_RESULT
327 dif_result_t dif_usbdev_irq_get_enabled(
328 const dif_usbdev_t *usbdev,
329 dif_usbdev_irq_t irq,
330 dif_toggle_t *state) {
331
332 if (usbdev == NULL || state == NULL) {
333 return kDifBadArg;
334 }
335
336 bitfield_bit32_index_t index;
337 if (!usbdev_get_irq_bit_index(irq, &index)) {
338 return kDifBadArg;
339 }
340
341 uint32_t intr_enable_reg = mmio_region_read32(
342 usbdev->base_addr,
343 (ptrdiff_t)USBDEV_INTR_ENABLE_REG_OFFSET);
344
345
346 bool is_enabled = bitfield_bit32_read(intr_enable_reg, index);
347 *state = is_enabled ?
348 kDifToggleEnabled : kDifToggleDisabled;
349
350 return kDifOk;
351 }
352
353 OT_WARN_UNUSED_RESULT
354 dif_result_t dif_usbdev_irq_set_enabled(
355 const dif_usbdev_t *usbdev,
356 dif_usbdev_irq_t irq,
357 dif_toggle_t state) {
358
359 if (usbdev == NULL) {
360 return kDifBadArg;
361 }
362
363 bitfield_bit32_index_t index;
364 if (!usbdev_get_irq_bit_index(irq, &index)) {
365 return kDifBadArg;
366 }
367
368 uint32_t intr_enable_reg = mmio_region_read32(
369 usbdev->base_addr,
370 (ptrdiff_t)USBDEV_INTR_ENABLE_REG_OFFSET);
371
372
373 bool enable_bit = (state == kDifToggleEnabled) ? true : false;
374 intr_enable_reg = bitfield_bit32_write(intr_enable_reg, index, enable_bit);
375 mmio_region_write32(
376 usbdev->base_addr,
377 (ptrdiff_t)USBDEV_INTR_ENABLE_REG_OFFSET,
378 intr_enable_reg);
379
380
381 return kDifOk;
382 }
383
384 OT_WARN_UNUSED_RESULT
385 dif_result_t dif_usbdev_irq_disable_all(
386 const dif_usbdev_t *usbdev,
387 dif_usbdev_irq_enable_snapshot_t *snapshot) {
388
389 if (usbdev == NULL) {
390 return kDifBadArg;
391 }
392
393 // Pass the current interrupt state to the caller, if requested.
394 if (snapshot != NULL) {
395 *snapshot = mmio_region_read32(
396 usbdev->base_addr,
397 (ptrdiff_t)USBDEV_INTR_ENABLE_REG_OFFSET);
398
399 }
400
401 // Disable all interrupts.
402 mmio_region_write32(
403 usbdev->base_addr,
404 (ptrdiff_t)USBDEV_INTR_ENABLE_REG_OFFSET,
405 0u);
406
407
408 return kDifOk;
409 }
410
411 OT_WARN_UNUSED_RESULT
412 dif_result_t dif_usbdev_irq_restore_all(
413 const dif_usbdev_t *usbdev,
414 const dif_usbdev_irq_enable_snapshot_t *snapshot) {
415
416 if (usbdev == NULL || snapshot == NULL) {
417 return kDifBadArg;
418 }
419
420 mmio_region_write32(
421 usbdev->base_addr,
422 (ptrdiff_t)USBDEV_INTR_ENABLE_REG_OFFSET,
423 *snapshot);
424
425
426 return kDifOk;
427 }
428