board_usb.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdint.h>
#include <unicorn/unicorn.h>
 
#ifdef __cplusplus
extern "C" {
#endif

typedef void (*board_usb_irq_raiser_t)(uc_engine* uc, uint16_t event);

void board_usb_init(bool trace);

void board_usb_set_irq_raiser(board_usb_irq_raiser_t raise);

uint64_t board_usb_read(uc_engine* uc, uint64_t addr, unsigned size, bool* handled);

void board_usb_write(uc_engine* uc, uint64_t addr, unsigned size, uint64_t value, bool* handled);

void board_usb_tick(uc_engine* uc);

bool board_usb_configured(void);

const char* board_usb_state_string(void);

void board_usb_feed_bulk_in(const uint8_t* data, uint32_t len);

uint32_t board_usb_echo_received(void);

void board_usb_report(void);
 
/* =============================================================================
 * Chip-internal USBHS-host <-> USBFS-device bridge.
 *
 * These entry points let the modelled on-chip USBHS host controller
 * (board_periph_usbhs_host.c, register window 0x40351000) drive THIS USBFS
 * device model directly, closing the RA8D2's chip-internal self-loop (the two
 * jacks cabled to each other on the bench). When an external real-firmware host
 * is present the built-in virtual chapter-9 host stands down (::board_usb_tick
 * returns early) so exactly one host drives the device: the real firmware, via
 * these primitives, exactly as the physical port-to-port cable does.
 * =============================================================================
 */

void board_usb_set_external_host(bool present);

bool board_usb_dev_attached(void);

void board_usb_bridge_bus_reset(uc_engine* uc);

void board_usb_bridge_deliver_setup(uc_engine* uc, const uint8_t* setup);

bool board_usb_bridge_dcp_in_ready(void);

uint16_t board_usb_bridge_dcp_in_take(uint8_t* buf, uint16_t cap);

void board_usb_bridge_ctrl_status(uc_engine* uc);

bool board_usb_bridge_dev_took_ccpl(void);

void board_usb_bridge_mark_configured(uc_engine* uc);

void board_usb_bridge_bulk_out(uc_engine* uc, uint8_t dev_pipe, const uint8_t* data, uint16_t len);

void board_usb_bridge_dcp_out(uc_engine* uc, const uint8_t* data, uint16_t len);

bool board_usb_bridge_dcp_out_consumed(void);

bool board_usb_bridge_bulk_out_consumed(uint8_t dev_pipe);

bool board_usb_bridge_bulk_in_ready(uint8_t dev_pipe);

uint16_t board_usb_bridge_bulk_in_take(uc_engine* uc, uint8_t dev_pipe, uint8_t* buf, uint16_t cap);
 
/* =============================================================================
 * Self-loop role routing (Config A vs Config B).
 *
 * The two on-chip controllers can run the self-loop in either polarity: HS
 * host + FS device ("Config A", the default) or FS host + HS device ("Config
 * B", dfu_selftest_fs_host). On silicon each controller's role is selected by
 * the firmware itself through SYSCFG: DCFM=1 declares controller (host) mode
 * (HUM Ch 36.2.1 / 37.2.1), DPRPU=1 declares the device-role D+ pull-up. The
 * models mirror that: a DCFM=1 write to the USBFS window, or a DPRPU=1 write
 * to the USBHS window, swaps the window<->model binding so the single host
 * model serves the window the firmware drives as host and the single device
 * model serves the other -- no per-app configuration, the register writes
 * decide, exactly as the silicon does.
 * =============================================================================
 */

bool board_usb_roles_swapped(void);

void board_usb_roles_swap(uc_engine* uc);

uint64_t board_usb_dev_reg_read(uc_engine* uc, uint64_t off, unsigned size);

void board_usb_dev_reg_write(uc_engine* uc, uint64_t off, unsigned size, uint64_t value);

uint64_t board_usbhs_host_reg_read(uc_engine* uc, uint64_t off, unsigned size);

void board_usbhs_host_reg_write(uc_engine* uc, uint64_t off, unsigned size, uint64_t value);

uint32_t board_usbhs_host_shadow_handoff(uint16_t* dst_words, uint32_t word_capacity);
 
/* =============================================================================
 * Loop-cable transport -- consumed by the USBHS HOST-mode model
 * (board_usb_host.c) when the firmware itself is the host on the self-loop
 * bench (USBHS J7 host cabled to USBFS J11 device). Each call is one bus
 * operation the firmware host performs against the modelled USBFS device.
 * =============================================================================
 */

void board_usb_loop_latch(void);

bool board_usb_loop_attached(void);

void board_usb_loop_bus_reset(uc_engine* uc);

bool board_usb_loop_setup(uc_engine* uc, uint16_t req, uint16_t val, uint16_t indx, uint16_t leng);

bool board_usb_loop_take_ccpl(uc_engine* uc);

uint16_t board_usb_loop_ctrl_in_avail(void);

uint16_t board_usb_loop_ctrl_in_read(uint8_t* dst, uint16_t cap);

void board_usb_loop_ctrl_in_flush(void);

void board_usb_loop_ctrl_out(uc_engine* uc, const uint8_t* data, uint16_t len);

void board_usb_loop_status_out_zlp(uc_engine* uc);

void board_usb_loop_bulk_out(uc_engine* uc, uint8_t ep, const uint8_t* data, uint16_t len);

uint16_t board_usb_loop_bulk_in_avail(uint8_t ep);

uint16_t board_usb_loop_bulk_in_read(uc_engine* uc, uint8_t ep, uint8_t* dst, uint16_t cap);

void board_usb_loop_bulk_in_flush(uint8_t ep);
 
#ifdef __cplusplus
}
#endif