12#include "usbdev_regs.h"
19 "Mismatch in number of endpoints");
24#define USBDEV_BUFFER_ENTRY_SIZE_BYTES USBDEV_MAX_PACKET_SIZE
29#define BUFFER_POOL_FULL (USBDEV_NUM_BUFFERS - 1)
30#define BUFFER_POOL_EMPTY -1
36 uint32_t config_in_reg_offset;
46#define ENDPOINT_HW_INFO_ENTRY(N) \
47 [N] = {.config_in_reg_offset = USBDEV_CONFIGIN_##N##_REG_OFFSET, \
48 .bit_index = USBDEV_IN_SENT_SENT_##N##_BIT}
51 ENDPOINT_HW_INFO_ENTRY(0), ENDPOINT_HW_INFO_ENTRY(1),
52 ENDPOINT_HW_INFO_ENTRY(2), ENDPOINT_HW_INFO_ENTRY(3),
53 ENDPOINT_HW_INFO_ENTRY(4), ENDPOINT_HW_INFO_ENTRY(5),
54 ENDPOINT_HW_INFO_ENTRY(6), ENDPOINT_HW_INFO_ENTRY(7),
55 ENDPOINT_HW_INFO_ENTRY(8), ENDPOINT_HW_INFO_ENTRY(9),
56 ENDPOINT_HW_INFO_ENTRY(10), ENDPOINT_HW_INFO_ENTRY(11),
59#undef ENDPOINT_HW_INFO_ENTRY
75 return pool->top == BUFFER_POOL_FULL;
86 return pool->top == BUFFER_POOL_EMPTY;
98static bool buffer_pool_is_valid_buffer_id(uint8_t buffer_id) {
99 return buffer_id < USBDEV_NUM_BUFFERS;
111 if (buffer_pool_is_full(pool) || !buffer_pool_is_valid_buffer_id(buffer_id)) {
116 pool->buffers[pool->top] = buffer_id;
130 uint8_t *buffer_id) {
131 if (buffer_pool_is_empty(pool) || buffer_id == NULL) {
135 *buffer_id = pool->buffers[pool->top];
156 for (uint8_t i = 0; i < USBDEV_NUM_BUFFERS; ++i) {
157 if (!buffer_pool_add(pool, i)) {
173static bool is_valid_endpoint(uint8_t endpoint_number) {
186 if (usbdev == NULL || !is_valid_endpoint(endpoint) ||
187 !dif_is_valid_toggle(new_state)) {
192 mmio_region_read32(usbdev->
base_addr, (ptrdiff_t)reg_offset);
193 reg_val = bitfield_bit32_write(reg_val, kEndpointHwInfos[endpoint].bit_index,
194 dif_toggle_to_bool(new_state));
195 mmio_region_write32(usbdev->
base_addr, (ptrdiff_t)reg_offset, reg_val);
204static uint32_t get_buffer_addr(uint8_t buffer_id,
size_t offset) {
205 return USBDEV_BUFFER_REG_OFFSET +
206 (buffer_id * USBDEV_BUFFER_ENTRY_SIZE_BYTES) + offset;
216 if (usbdev == NULL || buffer_pool == NULL) {
221 if (!buffer_pool_init(buffer_pool)) {
228 !dif_is_valid_toggle(config.single_bit_eop) ||
229 !dif_is_valid_toggle(config.
pin_flip) ||
235 uint32_t phy_config_val = 0;
236 phy_config_val = bitfield_bit32_write(
237 phy_config_val, USBDEV_PHY_CONFIG_USE_DIFF_RCVR_BIT,
240 bitfield_bit32_write(phy_config_val, USBDEV_PHY_CONFIG_TX_USE_D_SE0_BIT,
243 bitfield_bit32_write(phy_config_val, USBDEV_PHY_CONFIG_EOP_SINGLE_BIT_BIT,
244 dif_toggle_to_bool(config.single_bit_eop));
246 bitfield_bit32_write(phy_config_val, USBDEV_PHY_CONFIG_PINFLIP_BIT,
247 dif_toggle_to_bool(config.
pin_flip));
248 phy_config_val = bitfield_bit32_write(
249 phy_config_val, USBDEV_PHY_CONFIG_USB_REF_DISABLE_BIT,
253 mmio_region_write32(usbdev->
base_addr, USBDEV_PHY_CONFIG_REG_OFFSET,
261 if (usbdev == NULL || buffer_pool == NULL) {
266 while (!buffer_pool_is_empty(buffer_pool)) {
268 mmio_region_read32(usbdev->
base_addr, USBDEV_USBSTAT_REG_OFFSET);
270 uint32_t av_setup_depth =
271 bitfield_field32_read(
status, USBDEV_USBSTAT_AV_SETUP_DEPTH_FIELD);
272 if (av_setup_depth >= 2) {
275 bitfield_bit32_read(
status, USBDEV_USBSTAT_AV_OUT_FULL_BIT);
281 if (!buffer_pool_remove(buffer_pool, &buffer_id)) {
284 if (av_setup_depth >= 2) {
287 bitfield_field32_write(0, USBDEV_AVOUTBUFFER_BUFFER_FIELD, buffer_id);
288 mmio_region_write32(usbdev->
base_addr, USBDEV_AVOUTBUFFER_REG_OFFSET,
292 uint32_t reg_val = bitfield_field32_write(
293 0, USBDEV_AVSETUPBUFFER_BUFFER_FIELD, buffer_id);
294 mmio_region_write32(usbdev->
base_addr, USBDEV_AVSETUPBUFFER_REG_OFFSET,
305 return endpoint_functionality_enable(usbdev, USBDEV_RXENABLE_SETUP_REG_OFFSET,
306 endpoint, new_state);
312 if (usbdev == NULL || !is_valid_endpoint(endpoint) ||
313 !dif_is_valid_toggle(new_state)) {
320 mmio_region_read32(usbdev->
base_addr, USBDEV_RXENABLE_OUT_REG_OFFSET);
322 reg_val = bitfield_bit32_write(reg_val, kEndpointHwInfos[endpoint].bit_index,
323 dif_toggle_to_bool(new_state));
331 .mask = USBDEV_RXENABLE_OUT_PRESERVE_MASK,
332 .index = USBDEV_RXENABLE_OUT_PRESERVE_OFFSET};
334 uint32_t preserved_endpoints = USBDEV_RXENABLE_OUT_PRESERVE_MASK &
335 ~(1u << kEndpointHwInfos[endpoint].bit_index);
338 bitfield_field32_write(reg_val, preserve_field, preserved_endpoints);
339 mmio_region_write32(usbdev->
base_addr, USBDEV_RXENABLE_OUT_REG_OFFSET,
347 return endpoint_functionality_enable(usbdev, USBDEV_SET_NAK_OUT_REG_OFFSET,
348 endpoint, new_state);
352 dif_usbdev_endpoint_id_t endpoint,
354 if (endpoint.
direction == USBDEV_ENDPOINT_DIR_IN) {
355 return endpoint_functionality_enable(usbdev, USBDEV_IN_STALL_REG_OFFSET,
356 endpoint.
number, new_state);
358 return endpoint_functionality_enable(usbdev, USBDEV_OUT_STALL_REG_OFFSET,
359 endpoint.
number, new_state);
364 dif_usbdev_endpoint_id_t endpoint,
366 if (usbdev == NULL || state == NULL || !is_valid_endpoint(endpoint.
number)) {
370 ptrdiff_t reg_offset = endpoint.
direction == USBDEV_ENDPOINT_DIR_IN
371 ? USBDEV_IN_STALL_REG_OFFSET
372 : USBDEV_OUT_STALL_REG_OFFSET;
373 uint32_t reg_val = mmio_region_read32(usbdev->
base_addr, reg_offset);
375 bitfield_bit32_read(reg_val, kEndpointHwInfos[endpoint.
number].bit_index);
381 dif_usbdev_endpoint_id_t endpoint,
383 if (endpoint.
direction == USBDEV_ENDPOINT_DIR_IN) {
384 return endpoint_functionality_enable(usbdev, USBDEV_IN_ISO_REG_OFFSET,
385 endpoint.
number, new_state);
387 return endpoint_functionality_enable(usbdev, USBDEV_OUT_ISO_REG_OFFSET,
388 endpoint.
number, new_state);
393 dif_usbdev_endpoint_id_t endpoint,
395 if (endpoint.
direction == USBDEV_ENDPOINT_DIR_IN) {
396 return endpoint_functionality_enable(usbdev, USBDEV_EP_IN_ENABLE_REG_OFFSET,
397 endpoint.
number, new_state);
399 return endpoint_functionality_enable(
400 usbdev, USBDEV_EP_OUT_ENABLE_REG_OFFSET, endpoint.
number, new_state);
407 if (usbdev == NULL || !dif_is_valid_toggle(new_state)) {
412 mmio_region_read32(usbdev->
base_addr, USBDEV_USBCTRL_REG_OFFSET);
413 reg_val = bitfield_bit32_write(reg_val, USBDEV_USBCTRL_ENABLE_BIT,
414 dif_toggle_to_bool(new_state));
415 mmio_region_write32(usbdev->
base_addr, USBDEV_USBCTRL_REG_OFFSET, reg_val);
423 if (usbdev == NULL || info == NULL || buffer == NULL) {
428 uint32_t fifo_status =
429 mmio_region_read32(usbdev->
base_addr, USBDEV_USBSTAT_REG_OFFSET);
430 if (bitfield_bit32_read(fifo_status, USBDEV_USBSTAT_RX_EMPTY_BIT)) {
435 const uint32_t fifo_entry =
436 mmio_region_read32(usbdev->
base_addr, USBDEV_RXFIFO_REG_OFFSET);
440 (uint8_t)bitfield_field32_read(fifo_entry, USBDEV_RXFIFO_EP_FIELD),
441 .is_setup = bitfield_bit32_read(fifo_entry, USBDEV_RXFIFO_SETUP_BIT),
443 (uint8_t)bitfield_field32_read(fifo_entry, USBDEV_RXFIFO_SIZE_FIELD),
447 .id = (uint8_t)bitfield_field32_read(fifo_entry,
448 USBDEV_RXFIFO_BUFFER_FIELD),
450 .remaining_bytes = info->
length,
460 if (usbdev == NULL || buffer_pool == NULL || buffer == NULL) {
464 if (buffer_pool_is_empty(buffer_pool)) {
469 if (!buffer_pool_remove(buffer_pool, &buffer_id)) {
476 .remaining_bytes = USBDEV_BUFFER_ENTRY_SIZE_BYTES,
486 if (usbdev == NULL || buffer_pool == NULL || buffer == NULL) {
490 switch (buffer->
type) {
494 if (!buffer_pool_add(buffer_pool, buffer->
id)) {
508 size_t dst_len,
size_t *bytes_written) {
509 if (usbdev == NULL || buffer_pool == NULL || buffer == NULL ||
516 if (bytes_to_copy > dst_len) {
517 bytes_to_copy = dst_len;
520 const uint32_t buffer_addr = get_buffer_addr(buffer->
id, buffer->
offset);
521 mmio_region_memcpy_from_mmio32(usbdev->
base_addr, buffer_addr, dst,
524 buffer->
offset += bytes_to_copy;
527 if (bytes_written != NULL) {
528 *bytes_written = bytes_to_copy;
537 if (!buffer_pool_add(buffer_pool, buffer->
id)) {
548 const uint8_t *src,
size_t src_len,
549 size_t *bytes_written) {
550 if (usbdev == NULL || buffer == NULL ||
557 if (bytes_to_copy > src_len) {
558 bytes_to_copy = src_len;
562 uint32_t buffer_addr = get_buffer_addr(buffer->
id, buffer->
offset);
563 mmio_region_memcpy_to_mmio32(usbdev->
base_addr, buffer_addr, src,
566 buffer->
offset += bytes_to_copy;
570 *bytes_written = bytes_to_copy;
582 if (usbdev == NULL || !is_valid_endpoint(endpoint) || buffer == NULL ||
588 const uint32_t config_in_reg_offset =
589 kEndpointHwInfos[endpoint].config_in_reg_offset;
595 uint32_t config_in_val = 0;
596 config_in_val = bitfield_field32_write(
597 config_in_val, USBDEV_CONFIGIN_0_BUFFER_0_FIELD, buffer->
id);
598 config_in_val = bitfield_field32_write(
599 config_in_val, USBDEV_CONFIGIN_0_SIZE_0_FIELD, buffer->
offset);
600 mmio_region_write32(usbdev->
base_addr, (ptrdiff_t)config_in_reg_offset,
605 bitfield_bit32_write(config_in_val, USBDEV_CONFIGIN_0_RDY_0_BIT,
true);
606 mmio_region_write32(usbdev->
base_addr, (ptrdiff_t)config_in_reg_offset,
618 if (usbdev == NULL || sent == NULL) {
621 *sent = (uint16_t)mmio_region_read32(usbdev->
base_addr,
622 USBDEV_IN_SENT_REG_OFFSET);
629 if (usbdev == NULL || buffer_pool == NULL || !is_valid_endpoint(endpoint)) {
633 uint32_t config_in_reg_offset =
634 kEndpointHwInfos[endpoint].config_in_reg_offset;
635 uint32_t config_in_reg_val =
636 mmio_region_read32(usbdev->
base_addr, (ptrdiff_t)config_in_reg_offset);
637 uint8_t buffer = (uint8_t)bitfield_field32_read(
638 config_in_reg_val, USBDEV_CONFIGIN_0_BUFFER_0_FIELD);
640 mmio_region_write32(usbdev->
base_addr, (ptrdiff_t)config_in_reg_offset,
641 1u << USBDEV_CONFIGIN_0_PEND_0_BIT);
643 mmio_region_write32(usbdev->
base_addr, USBDEV_IN_SENT_REG_OFFSET,
646 if (!buffer_pool_add(buffer_pool, buffer)) {
655 if (usbdev == NULL ||
status == NULL || !is_valid_endpoint(endpoint)) {
660 uint32_t config_in_reg_offset =
661 kEndpointHwInfos[endpoint].config_in_reg_offset;
662 uint8_t endpoint_bit_index = kEndpointHwInfos[endpoint].bit_index;
665 uint32_t config_in_val =
666 mmio_region_read32(usbdev->
base_addr, (ptrdiff_t)config_in_reg_offset);
669 if (bitfield_bit32_read(config_in_val, USBDEV_CONFIGIN_0_RDY_0_BIT)) {
672 }
else if (bitfield_bit32_read(mmio_region_read32(usbdev->
base_addr,
673 USBDEV_IN_SENT_REG_OFFSET),
674 endpoint_bit_index)) {
677 }
else if (bitfield_bit32_read(config_in_val, USBDEV_CONFIGIN_0_PEND_0_BIT)) {
689 if (usbdev == NULL) {
694 mmio_region_read32(usbdev->
base_addr, USBDEV_USBCTRL_REG_OFFSET);
695 reg_val = bitfield_field32_write(reg_val, USBDEV_USBCTRL_DEVICE_ADDRESS_FIELD,
697 mmio_region_write32(usbdev->
base_addr, USBDEV_USBCTRL_REG_OFFSET, reg_val);
703 if (usbdev == NULL || addr == NULL) {
708 mmio_region_read32(usbdev->
base_addr, USBDEV_USBCTRL_REG_OFFSET);
710 *addr = (uint8_t)bitfield_field32_read(reg_val,
711 USBDEV_USBCTRL_DEVICE_ADDRESS_FIELD);
718 if (usbdev == NULL || toggles == NULL) {
723 mmio_region_read32(usbdev->
base_addr, USBDEV_OUT_DATA_TOGGLE_REG_OFFSET);
725 *toggles = (uint16_t)reg_val;
732 if (usbdev == NULL || toggles == NULL) {
737 mmio_region_read32(usbdev->
base_addr, USBDEV_IN_DATA_TOGGLE_REG_OFFSET);
739 *toggles = (uint16_t)reg_val;
745 uint16_t mask, uint16_t state) {
746 if (usbdev == NULL) {
751 mmio_region_write32(usbdev->
base_addr, USBDEV_OUT_DATA_TOGGLE_REG_OFFSET,
752 ((uint32_t)mask << 16) | state);
758 uint16_t mask, uint16_t state) {
759 if (usbdev == NULL) {
764 mmio_region_write32(usbdev->
base_addr, USBDEV_IN_DATA_TOGGLE_REG_OFFSET,
765 ((uint32_t)mask << 16) | state);
772 if (usbdev == NULL) {
776 uint32_t reg_val = (uint32_t)1u << (endpoint + 16u);
777 mmio_region_write32(usbdev->
base_addr, USBDEV_OUT_DATA_TOGGLE_REG_OFFSET,
779 mmio_region_write32(usbdev->
base_addr, USBDEV_IN_DATA_TOGGLE_REG_OFFSET,
786 uint16_t *frame_index) {
787 if (usbdev == NULL || frame_index == NULL) {
792 mmio_region_read32(usbdev->
base_addr, USBDEV_USBSTAT_REG_OFFSET);
795 (uint8_t)bitfield_field32_read(reg_val, USBDEV_USBSTAT_FRAME_FIELD);
802 if (usbdev == NULL || host_lost == NULL) {
807 mmio_region_get_bit32(usbdev->
base_addr, USBDEV_USBSTAT_REG_OFFSET,
808 USBDEV_USBSTAT_HOST_LOST_BIT);
815 if (usbdev == NULL || link_state == NULL) {
820 mmio_region_read32(usbdev->
base_addr, USBDEV_USBSTAT_REG_OFFSET);
821 val = bitfield_field32_read(val, USBDEV_USBSTAT_LINK_STATE_FIELD);
824 case USBDEV_USBSTAT_LINK_STATE_VALUE_DISCONNECTED:
825 *link_state = kDifUsbdevLinkStateDisconnected;
827 case USBDEV_USBSTAT_LINK_STATE_VALUE_POWERED:
828 *link_state = kDifUsbdevLinkStatePowered;
830 case USBDEV_USBSTAT_LINK_STATE_VALUE_POWERED_SUSPENDED:
831 *link_state = kDifUsbdevLinkStatePoweredSuspended;
833 case USBDEV_USBSTAT_LINK_STATE_VALUE_ACTIVE:
834 *link_state = kDifUsbdevLinkStateActive;
836 case USBDEV_USBSTAT_LINK_STATE_VALUE_SUSPENDED:
837 *link_state = kDifUsbdevLinkStateSuspended;
839 case USBDEV_USBSTAT_LINK_STATE_VALUE_ACTIVE_NOSOF:
840 *link_state = kDifUsbdevLinkStateActiveNoSof;
842 case USBDEV_USBSTAT_LINK_STATE_VALUE_RESUMING:
843 *link_state = kDifUsbdevLinkStateResuming;
854 if (usbdev == NULL || sense == NULL) {
858 *sense = mmio_region_get_bit32(usbdev->
base_addr, USBDEV_USBSTAT_REG_OFFSET,
859 USBDEV_USBSTAT_SENSE_BIT);
865 const dif_usbdev_t *usbdev, uint8_t *setup_depth, uint8_t *out_depth) {
866 if (usbdev == NULL || setup_depth == NULL || out_depth == NULL) {
871 mmio_region_read32(usbdev->
base_addr, USBDEV_USBSTAT_REG_OFFSET);
873 *setup_depth = (uint8_t)bitfield_field32_read(
874 reg_val, USBDEV_USBSTAT_AV_SETUP_DEPTH_FIELD);
876 *out_depth = (uint8_t)bitfield_field32_read(
877 reg_val, USBDEV_USBSTAT_AV_OUT_DEPTH_FIELD);
883 const dif_usbdev_t *usbdev,
bool *setup_is_full,
bool *out_is_full) {
884 if (usbdev == NULL || setup_is_full == NULL || out_is_full == NULL) {
889 mmio_region_read32(usbdev->
base_addr, USBDEV_USBSTAT_REG_OFFSET);
891 bitfield_bit32_read(reg_val, USBDEV_USBSTAT_AV_SETUP_FULL_BIT);
892 *out_is_full = bitfield_bit32_read(reg_val, USBDEV_USBSTAT_AV_OUT_FULL_BIT);
899 if (usbdev == NULL || depth == NULL) {
904 mmio_region_read32(usbdev->
base_addr, USBDEV_USBSTAT_REG_OFFSET);
907 (uint8_t)bitfield_field32_read(reg_val, USBDEV_USBSTAT_RX_DEPTH_FIELD);
914 if (usbdev == NULL || is_empty == NULL) {
919 mmio_region_read32(usbdev->
base_addr, USBDEV_USBSTAT_REG_OFFSET);
920 *is_empty = bitfield_bit32_read(reg_val, USBDEV_USBSTAT_RX_EMPTY_BIT);
927 if (usbdev == NULL || !dif_is_valid_toggle(enable)) {
930 bool set_tx_osc_mode = dif_toggle_to_bool(enable);
932 mmio_region_read32(usbdev->
base_addr, USBDEV_PHY_CONFIG_REG_OFFSET);
933 reg_val = bitfield_bit32_write(
934 reg_val, USBDEV_PHY_CONFIG_TX_OSC_TEST_MODE_BIT, set_tx_osc_mode);
935 mmio_region_write32(usbdev->
base_addr, USBDEV_PHY_CONFIG_REG_OFFSET, reg_val);
941 if (usbdev == NULL || !dif_is_valid_toggle(enable)) {
945 if (dif_toggle_to_bool(enable)) {
947 bitfield_bit32_write(0, USBDEV_WAKE_CONTROL_SUSPEND_REQ_BIT,
true);
949 reg_val = bitfield_bit32_write(0, USBDEV_WAKE_CONTROL_WAKE_ACK_BIT,
true);
951 mmio_region_write32(usbdev->
base_addr, USBDEV_WAKE_CONTROL_REG_OFFSET,
957 dif_usbdev_wake_status_t *
status) {
958 if (usbdev == NULL ||
status == NULL) {
962 mmio_region_read32(usbdev->
base_addr, USBDEV_WAKE_EVENTS_REG_OFFSET);
964 bitfield_bit32_read(reg_val, USBDEV_WAKE_EVENTS_MODULE_ACTIVE_BIT);
966 bitfield_bit32_read(reg_val, USBDEV_WAKE_EVENTS_DISCONNECTED_BIT);
968 bitfield_bit32_read(reg_val, USBDEV_WAKE_EVENTS_BUS_RESET_BIT);
970 bitfield_bit32_read(reg_val, USBDEV_WAKE_EVENTS_BUS_NOT_IDLE_BIT);
975 if (usbdev == NULL) {
979 mmio_region_read32(usbdev->
base_addr, USBDEV_USBCTRL_REG_OFFSET);
980 reg_val = bitfield_bit32_write(reg_val, USBDEV_USBCTRL_RESUME_LINK_ACTIVE_BIT,
982 mmio_region_write32(usbdev->
base_addr, USBDEV_USBCTRL_REG_OFFSET, reg_val);
988 if (usbdev == NULL ||
status == NULL) {
992 mmio_region_read32(usbdev->
base_addr, USBDEV_PHY_PINS_SENSE_REG_OFFSET);
994 bitfield_bit32_read(reg_val, USBDEV_PHY_PINS_SENSE_RX_DP_I_BIT);
996 bitfield_bit32_read(reg_val, USBDEV_PHY_PINS_SENSE_RX_DN_I_BIT);
997 status->rx_d = bitfield_bit32_read(reg_val, USBDEV_PHY_PINS_SENSE_RX_D_I_BIT);
999 bitfield_bit32_read(reg_val, USBDEV_PHY_PINS_SENSE_TX_DP_O_BIT);
1001 bitfield_bit32_read(reg_val, USBDEV_PHY_PINS_SENSE_TX_DN_O_BIT);
1002 status->tx_d = bitfield_bit32_read(reg_val, USBDEV_PHY_PINS_SENSE_TX_D_O_BIT);
1004 bitfield_bit32_read(reg_val, USBDEV_PHY_PINS_SENSE_TX_SE0_O_BIT);
1006 bitfield_bit32_read(reg_val, USBDEV_PHY_PINS_SENSE_TX_OE_O_BIT);
1008 bitfield_bit32_read(reg_val, USBDEV_PHY_PINS_SENSE_PWR_SENSE_BIT);
1014 dif_usbdev_phy_pins_drive_t overrides) {
1015 if (usbdev == NULL || !dif_is_valid_toggle(override_enable)) {
1018 bool drive_en = dif_toggle_to_bool(override_enable);
1020 bitfield_bit32_write(0, USBDEV_PHY_PINS_DRIVE_EN_BIT, drive_en);
1022 reg_val = bitfield_bit32_write(reg_val, USBDEV_PHY_PINS_DRIVE_DP_O_BIT,
1024 reg_val = bitfield_bit32_write(reg_val, USBDEV_PHY_PINS_DRIVE_DN_O_BIT,
1026 reg_val = bitfield_bit32_write(reg_val, USBDEV_PHY_PINS_DRIVE_D_O_BIT,
1028 reg_val = bitfield_bit32_write(reg_val, USBDEV_PHY_PINS_DRIVE_SE0_O_BIT,
1030 reg_val = bitfield_bit32_write(reg_val, USBDEV_PHY_PINS_DRIVE_OE_O_BIT,
1033 bitfield_bit32_write(reg_val, USBDEV_PHY_PINS_DRIVE_RX_ENABLE_O_BIT,
1036 bitfield_bit32_write(reg_val, USBDEV_PHY_PINS_DRIVE_DP_PULLUP_EN_O_BIT,
1039 bitfield_bit32_write(reg_val, USBDEV_PHY_PINS_DRIVE_DN_PULLUP_EN_O_BIT,
1042 mmio_region_write32(usbdev->
base_addr, USBDEV_PHY_PINS_DRIVE_REG_OFFSET,
1048 const uint8_t *src,
size_t src_len) {
1049 if (usbdev == NULL || src == NULL || misalignment32_of((uintptr_t)src) ||
1050 src_len > USBDEV_BUFFER_ENTRY_SIZE_BYTES) {
1055 ptrdiff_t buffer_offset = (ptrdiff_t)get_buffer_addr(
id, 0U);
1056 const uint32_t *restrict ews = (uint32_t *)(src + (src_len & ~15u));
1057 const uint32_t *restrict ws = (uint32_t *)src;
1064 mmio_region_write32(usbdev->
base_addr, buffer_offset, ws[0]);
1065 mmio_region_write32(usbdev->
base_addr, buffer_offset + 4, ws[1]);
1066 mmio_region_write32(usbdev->
base_addr, buffer_offset + 8, ws[2]);
1067 mmio_region_write32(usbdev->
base_addr, buffer_offset + 12, ws[3]);
1068 buffer_offset += 16;
1075 ews = ws + (src_len >> 2);
1077 mmio_region_write32(usbdev->
base_addr, buffer_offset, *ws++);
1083 const uint8_t *restrict bs = (uint8_t *)ws;
1086 d |= ((uint32_t)bs[1] << 8);
1088 d |= ((uint32_t)bs[2] << 16);
1094 mmio_region_write32(usbdev->
base_addr, buffer_offset, d);
1102 uint8_t *dst,
size_t dst_len) {
1103 if (usbdev == NULL || dst == NULL || misalignment32_of((uintptr_t)dst) ||
1104 dst_len > USBDEV_BUFFER_ENTRY_SIZE_BYTES) {
1109 ptrdiff_t buffer_offset = (ptrdiff_t)get_buffer_addr(
id, 0U);
1110 const uint32_t *restrict ewd = (uint32_t *)(dst + (dst_len & ~15u));
1111 uint32_t *restrict wd = (uint32_t *)dst;
1118 wd[0] = mmio_region_read32(usbdev->
base_addr, buffer_offset);
1119 wd[1] = mmio_region_read32(usbdev->
base_addr, buffer_offset + 4);
1120 wd[2] = mmio_region_read32(usbdev->
base_addr, buffer_offset + 8);
1121 wd[3] = mmio_region_read32(usbdev->
base_addr, buffer_offset + 12);
1122 buffer_offset += 16;
1129 ewd = wd + (dst_len >> 2);
1131 *wd++ = mmio_region_read32(usbdev->
base_addr, buffer_offset);
1138 uint8_t *restrict bd = (uint8_t *)wd;
1139 uint32_t d = mmio_region_read32(usbdev->
base_addr, buffer_offset);
1142 bd[1] = (uint8_t)(d >> 8);
1144 bd[2] = (uint8_t)(d >> 16);