rsp.h

Go to the documentation of this file.

 
#ifndef __LIBDRAGON_RSP_H
#define __LIBDRAGON_RSP_H
 
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define SP_DMEM       ((volatile uint32_t*)0xA4000000)
 
#define SP_IMEM       ((volatile uint32_t*)0xA4001000)
 
#define SP_PC         ((volatile uint32_t*)0xA4080000)
 
#define SP_STATUS     ((volatile uint32_t*)0xA4040010)
 
#define SP_DMA_FULL   ((volatile uint32_t*)0xA4040014)
 
#define SP_DMA_BUSY   ((volatile uint32_t*)0xA4040018)
 
#define SP_SEMAPHORE  ((volatile uint32_t*)0xA404001C)
 
#define SP_STATUS_HALTED                (1 << 0)
#define SP_STATUS_BROKE                 (1 << 1)
#define SP_STATUS_DMA_BUSY              (1 << 2)
#define SP_STATUS_DMA_FULL              (1 << 3)
#define SP_STATUS_IO_BUSY               (1 << 4)
#define SP_STATUS_SSTEP                 (1 << 5)
#define SP_STATUS_INTERRUPT_ON_BREAK    (1 << 6)
#define SP_STATUS_SIG0                  (1 << 7)
#define SP_STATUS_SIG1                  (1 << 8)
#define SP_STATUS_SIG2                  (1 << 9)
#define SP_STATUS_SIG3                  (1 << 10)
#define SP_STATUS_SIG4                  (1 << 11)
#define SP_STATUS_SIG5                  (1 << 12)
#define SP_STATUS_SIG6                  (1 << 13)
#define SP_STATUS_SIG7                  (1 << 14)
 
#define SP_WSTATUS_CLEAR_HALT        0x00001   
#define SP_WSTATUS_SET_HALT          0x00002   
#define SP_WSTATUS_CLEAR_BROKE       0x00004   
#define SP_WSTATUS_CLEAR_INTR        0x00008   
#define SP_WSTATUS_SET_INTR          0x00010   
#define SP_WSTATUS_CLEAR_SSTEP       0x00020   
#define SP_WSTATUS_SET_SSTEP         0x00040   
#define SP_WSTATUS_CLEAR_INTR_BREAK  0x00080   
#define SP_WSTATUS_SET_INTR_BREAK    0x00100   
#define SP_WSTATUS_CLEAR_SIG0        0x00200   
#define SP_WSTATUS_SET_SIG0          0x00400   
#define SP_WSTATUS_CLEAR_SIG1        0x00800   
#define SP_WSTATUS_SET_SIG1          0x01000   
#define SP_WSTATUS_CLEAR_SIG2        0x02000   
#define SP_WSTATUS_SET_SIG2          0x04000   
#define SP_WSTATUS_CLEAR_SIG3        0x08000   
#define SP_WSTATUS_SET_SIG3          0x10000   
#define SP_WSTATUS_CLEAR_SIG4        0x20000   
#define SP_WSTATUS_SET_SIG4          0x40000   
#define SP_WSTATUS_CLEAR_SIG5        0x80000   
#define SP_WSTATUS_SET_SIG5          0x100000  
#define SP_WSTATUS_CLEAR_SIG6        0x200000  
#define SP_WSTATUS_SET_SIG6          0x400000  
#define SP_WSTATUS_CLEAR_SIG7        0x800000  
#define SP_WSTATUS_SET_SIG7          0x1000000 
 
typedef struct {
    uint32_t gpr[32];           
    uint16_t vpr[32][8];        
    uint16_t vaccum[3][8];      
    uint32_t cop0[16];          
    uint32_t cop2[3];           
    uint32_t pc;                
    uint8_t dmem[4096] __attribute__((aligned(8)));  
    uint8_t imem[4096] __attribute__((aligned(8)));  
} rsp_snapshot_t;
 
typedef struct {
    uint8_t *code;         
    void    *code_end;     
    uint8_t *data;         
    void    *data_end;     
 
    const char *name;      
    uint32_t start_pc;     
 
    void (*crash_handler)(rsp_snapshot_t *state);
 
    void (*assert_handler)(rsp_snapshot_t *state, uint16_t assert_code);
} rsp_ucode_t;
 
#define DEFINE_RSP_UCODE(ucode_name, ...) \
    extern uint8_t ucode_name ## _text_start[]; \
    extern uint8_t ucode_name ## _data_start[]; \
    extern uint8_t ucode_name ## _text_end[0]; \
    extern uint8_t ucode_name ## _data_end[0]; \
    rsp_ucode_t ucode_name = (rsp_ucode_t){ \
        .code = ucode_name ## _text_start, \
        .data = ucode_name ## _data_start, \
        .code_end = ucode_name ## _text_end, \
        .data_end = ucode_name ## _data_end, \
        .name = #ucode_name, .start_pc = 0, \
        .crash_handler = 0, .assert_handler = 0, \
        __VA_ARGS__ \
    }
 
void rsp_init(void);
 
void rsp_load(rsp_ucode_t *ucode);
 
void rsp_run(void);
 
inline void rsp_run_async(void)
{
    extern void __rsp_run_async(uint32_t status_flags);
    __rsp_run_async(SP_WSTATUS_SET_INTR_BREAK);
}
 
void rsp_wait(void);
 
void rsp_load_code(void* code, unsigned long size, unsigned int imem_offset);
 
void rsp_load_data(void* data, unsigned long size, unsigned int dmem_offset);
 
 
void rsp_read_code(void* code, unsigned long size, unsigned int imem_offset);
 
void rsp_read_data(void* data, unsigned long size, unsigned int dmem_offset);
 
#ifndef NDEBUG
#define rsp_crash()  ({ \
    __rsp_crash(__FILE__, __LINE__, __func__, NULL); \
})
#else
#define rsp_crash() abort()
#endif
 
#ifndef NDEBUG
#define rsp_crashf(msg, ...) ({ \
    __rsp_crash(__FILE__, __LINE__, __func__, msg, ##__VA_ARGS__); \
})
#else
#define rsp_crashf(msg, ...) abort()
#endif
 
#define RSP_WAIT_LOOP(timeout_ms) \
    for (uint32_t __t = TICKS_READ() + TICKS_FROM_MS(timeout_ms); \
         TICKS_BEFORE(TICKS_READ(), __t) || (rsp_crashf("wait loop timed out (%d ms)", timeout_ms), false); \
         __rsp_check_assert(__FILE__, __LINE__, __func__))
 
static inline __attribute__((deprecated("use rsp_load_code instead")))
void load_ucode(void * start, unsigned long size) {
    rsp_load_code(start, size, 0);
}
 
static inline __attribute__((deprecated("use rsp_read_code instead")))
void read_ucode(void * start, unsigned long size) {    
    rsp_read_code(start, size, 0);
}
 
static inline __attribute__((deprecated("use rsp_load_data instead"))) 
void load_data(void * start, unsigned long size) {
    rsp_load_data(start, size, 0);
}
 
static inline __attribute__((deprecated("use rsp_read_data instead"))) 
void read_data(void * start, unsigned long size) {
    rsp_read_data(start, size, 0);
}
 
static inline __attribute__((deprecated("use rsp_run_async instead"))) 
void run_ucode(void) {
    rsp_run_async();
}
 
// Internal function used by rsp_crash and rsp_crashf. These are not part
// of the public API of rsp.h. Do not call them directly.
#ifndef NDEBUG
void __rsp_crash(const char *file, int line, const char *func, const char *msg, ...)
   __attribute__((noreturn, format(printf, 4, 5)));
void __rsp_check_assert(const char *file, int line, const char *func);
#else
static inline void __rsp_check_assert(const char *file, int line, const char *func) {}
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif