board_usb_internal.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdint.h>
#include <unicorn/unicorn.h>
 
#include "board_usb.h"
#include "ra8_attributes.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* =============================================================================
 * Window geometry + model sizing.
 * =============================================================================
 */

typedef enum : uint64_t {
  k_usb_base       = 0x40250000UL, 
  k_usb_span       = 0x100UL,      
  k_usb_reg_words  = 0x100UL / 2U, 
  k_usb_dcp_mps    = 64UL,         
  k_usb_pipe_mps   = 64UL,         
  k_usb_pipe_count = 10UL,         
  k_usb_echo_cap   = 256UL,        
  k_usb_in_cap     = 512UL,        
} usb_geom_t;
 
/* =============================================================================
 * Standard USB chapter-9 request constants (USB 2.0 sec 9.3 / 9.4).
 * =============================================================================
 */

typedef enum : uint8_t {
  k_usb_req_get_descriptor = 0x06U, 
  k_usb_req_set_address    = 0x05U, 
  k_usb_req_set_config     = 0x09U, 
} usb_breq_t;

typedef enum : uint8_t {
  k_cdc_req_set_line_coding        = 0x20U, 
  k_cdc_req_set_control_line_state = 0x22U, 
} cdc_breq_t;

typedef enum : uint8_t {
  k_usb_dt_device = 0x01U, 
  k_usb_dt_config = 0x02U, 
  k_usb_dt_string = 0x03U, 
} usb_dt_t;

typedef enum : uint8_t {
  k_usb_dir_device_to_host = 0x80U, 
  k_usb_dir_host_to_device = 0x00U, 
} usb_dir_t;

typedef enum : uint16_t {
  k_usb_rhst_fs = 0x0002U, 
} usb_rhst_t;

typedef enum : uint32_t {
  k_usb_byte_bits      = 8U,    
  k_usb_byte_mask      = 0xFFU, 
  k_usb_cfifo_h        = 2U,    
  k_usb_cfifo_hh       = 3U,    
  k_usb_addr_assigned  = 7U,    
  k_usb_config_value   = 1U,    
  k_usb_desc8_len      = 8U,    
  k_usb_desc_dev_len   = 18U,   
  k_usb_cfg_probe_len  = 9U,    
  k_usb_cfg_full_cap   = 255U,  
  k_usb_str_len        = 255U,  
  k_usb_step_timeout   = 64U,   
  k_usb_reset_settle   = 4U,    
  k_usb_post_cfg_idle  = 8U,    
  k_usb_log_cap        = 48U,   
  k_usb_log_width      = 96U,   
  k_usb_trace_dump_max = 24U,   
  k_usb_bulk_in_pipe   = 1U,    
  k_usb_bulk_out_pipe  = 2U,    
  k_usb_dcp_pipe_bit   = 1U,    
} usb_const_t;
 
/* =============================================================================
 * Controller register state + FIFO staging.
 * =============================================================================
 */

typedef struct {
  uint8_t  data[k_usb_pipe_mps]; 
  uint16_t len;                  
  uint16_t rd;                   
  bool     ready;                
} usb_out_buf_t;

typedef struct {
  uint8_t  data[k_usb_in_cap]; 
  uint16_t len;                
  bool     valid;              
} usb_in_buf_t;

typedef struct {
  uint16_t      reg[k_usb_reg_words];       
  uint16_t      ctsq;                       
  uint16_t      dvsq;                       
  bool          setup_valid;                
  usb_in_buf_t  dcp_in;                     
  usb_out_buf_t dcp_out;                    
  usb_in_buf_t  pipe_in[k_usb_pipe_count];  
  usb_out_buf_t pipe_out[k_usb_pipe_count]; 
} usb_state_t;

typedef enum : uint8_t {
  k_phase_idle       = 0U, 
  k_phase_reset      = 1U, 
  k_phase_setup      = 2U, 
  k_phase_configured = 3U, 
  k_phase_done       = 4U, 
} usb_host_phase_t;

typedef enum : uint8_t {
  k_sub_deliver  = 0U, 
  k_sub_wait_in  = 1U, 
  k_sub_status   = 2U, 
  k_sub_wait_ack = 3U, 
  k_sub_next     = 4U, 
} usb_host_sub_t;

typedef enum : uint32_t {
  k_iface_class_off     = 5U,    
  k_usb_req_class_iface = 0x21U, 
  k_cdc_line_coding_len = 7U,    
  k_scsi_inquiry        = 0x12U, 
  k_inquiry_len         = 36U,   
  k_scsi_read_capacity  = 0x25U, 
  k_scsi_read10         = 0x28U, 
  k_cdb10_len           = 10U,   
  k_sector_bytes        = 512U,  
  k_usb_shift24         = 24U,   
  k_cbw_tag_off         = 4U,    
  k_cbw_dtl_off         = 8U,    
  k_cbw_flags_off       = 12U,   
  k_cbw_lun_off         = 13U,   
  k_cbw_cdblen_off      = 14U,   
  k_cbw_cdb_off         = 15U,   
} usb_lit_t;

typedef enum : uint8_t {
  k_le_lane_b0 = 0U, 
  k_le_lane_b1 = 1U, 
  k_le_lane_b2 = 2U, 
  k_le_lane_b3 = 3U, 
} usb_le_lane_t;

typedef enum : uint8_t {
  k_cap10_last_lba_off = 0U, 
  k_cap10_blocklen_off = 4U, 
} scsi_cap10_off_t;

typedef enum : uint8_t {
  k_be_lane_b3 = 0U, 
  k_be_lane_b2 = 1U, 
  k_be_lane_b1 = 2U, 
  k_be_lane_b0 = 3U, 
} usb_be_lane_t;

typedef enum : uint8_t {
  k_usb_class_unknown = 0U, 
  k_usb_class_cdc     = 1U, 
  k_usb_class_hid     = 2U, 
  k_usb_class_msc     = 3U, 
  k_usb_class_printer = 4U, 
  k_usb_class_vendor  = 5U, 
} usb_dev_class_t;

typedef enum : uint8_t {
  k_usb_iclass_cdc_comm = 0x02U, 
  k_usb_iclass_hid      = 0x03U, 
  k_usb_iclass_printer  = 0x07U, 
  k_usb_iclass_msc      = 0x08U, 
  k_usb_iclass_cdc_data = 0x0AU, 
  k_usb_iclass_vendor   = 0xFFU, 
  k_usb_dt_interface    = 0x04U, 
} usb_iclass_t;

typedef struct {
  uint8_t     bm_request_type; 
  uint8_t     b_request;       
  uint16_t    w_value;         
  uint16_t    w_index;         
  uint16_t    w_length;        
  const char* name;            
} usb_setup_step_t;

RA8_INTERNAL static inline uint32_t internal_usb_word(uint64_t off)
{
  return (uint32_t)((off & ~(uint64_t)1U) / 2U);
}
 
/* Shared model state -- one logical module across the board_usb_* TUs; the
 * defining TU is noted per declaration. */
extern usb_state_t            s_usb;                      
extern bool                   s_trace;                    
extern board_usb_irq_raiser_t s_raise;                    
extern bool                   s_external_host;            
extern bool                   s_roles_swapped;            
extern uint16_t               g_dev_irq_event;            
extern uint8_t                s_dcp_hold[k_usb_in_cap];   
extern uint16_t               s_dcp_hold_len;             
extern bool                   s_dcp_hold_pending;         
extern uint8_t                s_host_phase;               
extern uint8_t                s_host_step;                
extern uint8_t                s_host_substate;            
extern uint32_t               s_host_wait;                
extern bool                   s_configured;               
extern uint32_t               s_usb_irqs;                 
extern uint8_t                s_echo_out[k_usb_echo_cap]; 
extern uint32_t               s_echo_out_len;             
extern uint32_t               s_echo_out_sent;            
extern uint32_t               s_echo_in_got;              
extern uint8_t                s_dev_class;                
extern uint32_t               s_hid_reports;              
extern int32_t                s_hid_cx;                   
extern int32_t                s_hid_cy;                   
extern uint8_t                s_hid_buttons;              
extern uint32_t               s_msc_blocks;               
extern uint32_t               s_msc_block_len;            
extern uint32_t               s_msc_read_ok;              
extern bool                   s_msc_inquiry_ok;           
extern bool                   s_loop_latched;             
extern uint32_t               s_loop_setups;              
extern uint32_t               s_loop_bulk_out_pkts;       
extern uint32_t               s_loop_bulk_in_pkts;        

RA8_PRIV void priv_usb_log_line(const char* msg);

RA8_PRIV void priv_usb_log_count(const char* label, unsigned n);

RA8_PRIV uint16_t priv_usb_intsts0(void);

RA8_PRIV void priv_usb_intsts0_set(uint8_t bit);

RA8_PRIV void priv_usb_raise_irq(uc_engine* uc);

RA8_PRIV uint32_t priv_usb_reg_read(uint64_t off, unsigned size);

RA8_PRIV void priv_usb_reg_write(uint64_t off, uint32_t value, unsigned size);

RA8_PRIV void priv_usb_detect_class(const uint8_t* d, uint16_t len);

RA8_PRIV const char* priv_usb_class_active_str(void);

RA8_PRIV void priv_host_run_idle_phase(uc_engine* uc);

RA8_PRIV void priv_host_run_reset_phase(uc_engine* uc);

RA8_PRIV void priv_host_run_setup_phase(uc_engine* uc);

RA8_PRIV void priv_host_run_configured_phase(uc_engine* uc);

RA8_PRIV void priv_host_echo_read_in(uc_engine* uc);

RA8_PRIV void priv_bridge_pump_device(uc_engine* uc);

RA8_PRIV bool priv_host_device_attached(void);

RA8_PRIV void priv_host_deliver_setup(uc_engine* uc, const usb_setup_step_t* s);

RA8_PRIV void priv_host_apply_no_data(uc_engine* uc, const usb_setup_step_t* s);

RA8_PRIV bool priv_host_dcp_pid_buf(void);

RA8_PRIV bool priv_host_take_ccpl(void);

RA8_PRIV void priv_host_mark_configured(uc_engine* uc);
 
#ifdef __cplusplus
}
#endif