rdpq_internal.h

Go to the documentation of this file.

 
#ifndef __LIBDRAGON_RDPQ_INTERNAL_H
#define __LIBDRAGON_RDPQ_INTERNAL_H
 
#include "pputils.h"
#include "rspq.h"
#include "../rspq/rspq_internal.h"
 
extern bool __rdpq_inited;
 
extern void rdpq_fence(void);
 
typedef struct rdpq_block_s rdpq_block_t;
typedef struct rdpq_trifmt_s rdpq_trifmt_t;
 
typedef struct {
    uint32_t autosync : 17;
    bool mode_freeze : 1;
    uint8_t cycle_type_known : 2;
    uint8_t cycle_type_frozen : 2;
} rdpq_tracking_t;
 
extern rdpq_tracking_t rdpq_tracking;
 
typedef struct rdpq_block_s {
    rdpq_block_t *next;                           
    rdpq_tracking_t tracking;                     
    uint32_t cmds[] __attribute__((aligned(8)));  
} rdpq_block_t;
 
typedef struct rdpq_block_state_s {
    volatile uint32_t *wptr;
    volatile uint32_t *wend;
    volatile uint32_t *pending_wptr;
    volatile uint32_t *pending_wend;
    rdpq_block_t *last_node;
    rdpq_block_t *first_node;
    int bufsize;
    volatile uint32_t *last_rdp_append_buffer;
    rdpq_tracking_t previous_tracking;
} rdpq_block_state_t;
 
void __rdpq_block_begin();
rdpq_block_t* __rdpq_block_end();
void __rdpq_block_free(rdpq_block_t *block);
void __rdpq_block_run(rdpq_block_t *block);
void __rdpq_block_next_buffer(void);
void __rdpq_block_update(volatile uint32_t *wptr);
void __rdpq_block_reserve(int num_rdp_commands);
 
inline void __rdpq_autosync_use(uint32_t res)
{
    rdpq_tracking.autosync |= res;
}
void __rdpq_autosync_change(uint32_t res);
 
void __rdpq_write8(uint32_t cmd_id, uint32_t arg0, uint32_t arg1);
void __rdpq_write16(uint32_t cmd_id, uint32_t arg0, uint32_t arg1, uint32_t arg2, uint32_t arg3);
 
void rdpq_triangle_cpu(const rdpq_trifmt_t *fmt, const float *v1, const float *v2, const float *v3);
void rdpq_triangle_rsp(const rdpq_trifmt_t *fmt, const float *v1, const float *v2, const float *v3);
 
 
/* Helpers for rdpq_passthrough_write / rdpq_fixup_write */
#define __rdpcmd_count_words2(rdp_cmd_id, arg0, ...)  nwords += __COUNT_VARARGS(__VA_ARGS__) + 1;
#define __rdpcmd_count_words(arg)                    __rdpcmd_count_words2 arg
 
#define __rdpcmd_write_arg(arg)                      *ptr++ = arg;
#define __rdpcmd_write2(rdp_cmd_id, arg0, ...)        \
        *ptr++ = (RDPQ_OVL_ID + ((rdp_cmd_id)<<24)) | (arg0); \
        __CALL_FOREACH_BIS(__rdpcmd_write_arg, ##__VA_ARGS__);
#define __rdpcmd_write(arg)                          __rdpcmd_write2 arg
 
#define __rspcmd_write(...)                          ({ rspq_write(RDPQ_OVL_ID, __VA_ARGS__ ); })
 
#define rdpq_passthrough_write(rdp_cmd) ({ \
    if (__builtin_expect(rspq_in_block(), 0)) { \
        extern rdpq_block_state_t rdpq_block_state; \
        int nwords = 0; __rdpcmd_count_words(rdp_cmd); \
        if (__builtin_expect(rdpq_block_state.wptr + nwords > rdpq_block_state.wend, 0)) \
            __rdpq_block_next_buffer(); \
        volatile uint32_t *ptr = rdpq_block_state.wptr; \
        __rdpcmd_write(rdp_cmd); \
        __rdpq_block_update((uint32_t*)ptr); \
    } else { \
        __rspcmd_write rdp_cmd; \
    } \
})
 
#endif