rspq.h

Go to the documentation of this file.

 
#ifndef __LIBDRAGON_RSPQ_H
#define __LIBDRAGON_RSPQ_H
 
#include <stdint.h>
#include <rsp.h>
#include <debug.h>
#include <n64sys.h>
#include <pputils.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define RSPQ_MAX_COMMAND_SIZE          62
 
#define RSPQ_MAX_SHORT_COMMAND_SIZE    16
 
typedef struct rspq_block_s rspq_block_t;
 
typedef int rspq_syncpoint_t;
 
void rspq_init(void);
 
void rspq_close(void);
 
 
uint32_t rspq_overlay_register(rsp_ucode_t *overlay_ucode);
 
void rspq_overlay_register_static(rsp_ucode_t *overlay_ucode, uint32_t overlay_id);
 
void rspq_overlay_unregister(uint32_t overlay_id);
 
void* rspq_overlay_get_state(rsp_ucode_t *overlay_ucode);
 
#define rspq_write(ovl_id, cmd_id, ...) \
    __PPCAT(_rspq_write, __HAS_VARARGS(__VA_ARGS__)) (ovl_id, cmd_id, ##__VA_ARGS__)
 
 
// Helpers used to implement rspq_write
#define _rspq_write_prolog() \
    extern volatile uint32_t *rspq_cur_pointer, *rspq_cur_sentinel; \
    extern void rspq_next_buffer(void); \
    volatile uint32_t *ptr = rspq_cur_pointer+1; \
    (void)ptr;
 
#define _rspq_write_epilog() ({ \
    if (__builtin_expect(rspq_cur_pointer > rspq_cur_sentinel, 0)) \
        rspq_next_buffer(); \
})
 
#define _rspq_write_arg(arg) \
    *ptr++ = (arg);
 
#define _rspq_write0(ovl_id, cmd_id) ({ \
    _rspq_write_prolog(); \
    rspq_cur_pointer[0] = (ovl_id) + ((cmd_id)<<24); \
    rspq_cur_pointer += 1; \
    _rspq_write_epilog(); \
})
 
#define _rspq_write1(ovl_id, cmd_id, arg0, ...) ({ \
    _Static_assert(__COUNT_VARARGS(__VA_ARGS__) <= RSPQ_MAX_SHORT_COMMAND_SIZE, "too many arguments to rspq_write, please use rspq_write_begin/arg/end instead"); \
    _rspq_write_prolog(); \
    __CALL_FOREACH(_rspq_write_arg, ##__VA_ARGS__); \
    rspq_cur_pointer[0] = ((ovl_id) + ((cmd_id)<<24)) | (arg0); \
    rspq_cur_pointer += 1 + __COUNT_VARARGS(__VA_ARGS__); \
    _rspq_write_epilog(); \
})
 
 
typedef struct {
    uint32_t first_word;                  
    volatile uint32_t *pointer;           
    volatile uint32_t *first;             
    bool is_first;                        
} rspq_write_t;
 
inline rspq_write_t rspq_write_begin(uint32_t ovl_id, uint32_t cmd_id, int size) {
    extern volatile uint32_t *rspq_cur_pointer, *rspq_cur_sentinel;
    extern void rspq_next_buffer(void);
 
    assertf(size <= RSPQ_MAX_COMMAND_SIZE, "The maximum command size is %d!", RSPQ_MAX_COMMAND_SIZE);
 
    if (__builtin_expect(rspq_cur_pointer > rspq_cur_sentinel - size, 0))
        rspq_next_buffer();
 
    volatile uint32_t *cur = rspq_cur_pointer;
    rspq_cur_pointer += size;
 
    return (rspq_write_t){
        .first_word = ovl_id + (cmd_id<<24),
        .pointer = cur + 1,
        .first = cur,
        .is_first = 1
    };
}
 
inline void rspq_write_arg(rspq_write_t *w, uint32_t value) {
    if (w->is_first) {
        w->first_word |= value;
        w->is_first = 0;
    } else {
        *w->pointer++ = value;
    }
}
 
inline void rspq_write_end(rspq_write_t *w) {
    *w->first = w->first_word;
    w->first = 0;
    w->pointer = 0;
}
 
void rspq_flush(void);
 
void rspq_wait(void);
 
rspq_syncpoint_t rspq_syncpoint_new(void);
 
bool rspq_syncpoint_check(rspq_syncpoint_t sync_id);
 
void rspq_syncpoint_wait(rspq_syncpoint_t sync_id);
 
 
void rspq_block_begin(void);
 
rspq_block_t* rspq_block_end(void);
 
void rspq_block_run(rspq_block_t *block);
 
void rspq_block_free(rspq_block_t *block);
 
void rspq_highpri_begin(void);
 
void rspq_highpri_end(void);
 
void rspq_highpri_sync(void);
 
void rspq_noop(void);
 
void rspq_dma_to_rdram(void *rdram_addr, uint32_t dmem_addr, uint32_t len, bool is_async);
 
void rspq_dma_to_dmem(uint32_t dmem_addr, void *rdram_addr, uint32_t len, bool is_async);
 
__attribute__((deprecated("may not work anymore. use rspq_syncpoint_new/rspq_syncpoint_check instead")))
void rspq_signal(uint32_t signal);
#ifdef __cplusplus
}
#endif
 
#endif