packet2_vif.h

/*
# _____     ___ ____     ___ ____
#  ____|   |    ____|   |        | |____|
# |     ___|   |____ ___|    ____| |    \    PS2DEV Open Source Project.
#-----------------------------------------------------------------------
# (c) 2020 h4570 Sandro Sobczyński <sandro.sobczynski@gmail.com>
# Licenced under Academic Free License version 2.0
# Review ps2sdk README & LICENSE files for further details.
*/
 
#ifndef __PACKET2_VIF_H__
#define __PACKET2_VIF_H__
 
#include <packet2.h>
#include <packet2_types.h>
#include <assert.h>
 
#define MAKE_VIF_CODE(_immediate, _num, _cmd, _irq) ((u32)(_immediate) | ((u32)(_num) << 16) | ((u32)(_cmd) << 24) | ((u32)(_irq) << 31))
 
#ifdef __cplusplus
extern "C"
{
#endif
 
    static inline void packet2_vif_open_unpack(packet2_t *packet2, enum UnpackMode mode, u32 vuAddr, u8 dblBuffered, u8 masked, u8 usigned, u8 irq)
    {
        assert(packet2->vif_code_opened_at == NULL); // All previous UNPACK/DIRECT are closed.
        packet2->vif_code_opened_at = (vif_code_t *)packet2->next;
        packet2_add_u32(packet2,
                        MAKE_VIF_CODE(vuAddr | ((u32)usigned << 14) | ((u32)dblBuffered << 15),
                                      0,
                                      mode | ((u32)masked << 4) | 0x60, irq));
    }
 
    static inline void packet2_vif_close_unpack_manual(packet2_t *packet2, u32 unpack_num)
    {
        assert(packet2->vif_code_opened_at != NULL);               // There is open UNPACK/DIRECT.
        assert(((u32)packet2->next & 0x3) == 0);                   // Make sure we're u32 aligned
        assert((packet2->vif_code_opened_at->cmd & 0x60) == 0x60); // It was UNPACK
        assert(unpack_num <= 256);
        packet2->vif_code_opened_at->num = (unpack_num == 256) ? 0 : unpack_num;
        packet2->vif_code_opened_at = (vif_code_t *)NULL;
    }
 
    u32 packet2_vif_close_unpack_auto(packet2_t *packet2, u32 wl, u32 cl);
 
    static inline void packet2_vif_open_direct(packet2_t *packet2, u8 irq)
    {
        assert(packet2->vif_code_opened_at == NULL); // All previous UNPACK/DIRECT are closed.
        packet2->vif_code_opened_at = (vif_code_t *)packet2->next;
        packet2_add_u32(packet2, MAKE_VIF_CODE(0, 0, P2_VIF_DIRECT, irq));
    }
 
    static inline void packet2_vif_close_direct_manual(packet2_t *packet2, u32 qwords)
    {
        assert(packet2->vif_code_opened_at != NULL); // There is open UNPACK/DIRECT.
        assert((((u32)packet2->next - ((u32)packet2->vif_code_opened_at + 4)) & 0xF) == 0);
        packet2->vif_code_opened_at->immediate = qwords;
        packet2->vif_code_opened_at = (vif_code_t *)NULL;
    }
 
    static inline void packet2_vif_close_direct_auto(packet2_t *packet2)
    {
        return packet2_vif_close_direct_manual(packet2, ((u32)packet2->next - ((u32)packet2->vif_code_opened_at + 4)) >> 4);
    }
 
    static inline void packet2_vif_nop(packet2_t *packet2, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(0, 0, P2_VIF_NOP, irq));
    }
 
    static inline void packet2_vif_pad96(packet2_t *packet2)
    {
        packet2_pad96(packet2, MAKE_VIF_CODE(0, 0, P2_VIF_NOP, 0));
    }
 
    static inline void packet2_vif_pad128(packet2_t *packet2)
    {
        packet2_pad128(packet2, MAKE_VIF_CODE(0, 0, P2_VIF_NOP, 0));
    }
 
    static inline void packet2_vif_mpg(packet2_t *packet2, u32 num, u32 addr, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(addr, num, P2_VIF_MPG, irq));
    }
 
    static inline void packet2_vif_stcycl(packet2_t *packet2, u32 wl, u32 cl, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(cl | (wl << 8), 0, P2_VIF_STCYCL, irq));
    }
 
    static inline void packet2_vif_offset(packet2_t *packet2, u32 offset, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(offset, 0, P2_VIF_OFFSET, irq));
    }
 
    static inline void packet2_vif_base(packet2_t *packet2, u32 base, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(base, 0, P2_VIF_BASE, irq));
    }
 
    static inline void packet2_vif_flush(packet2_t *packet2, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(0, 0, P2_VIF_FLUSH, irq));
    }
 
    static inline void packet2_vif_mscal(packet2_t *packet2, u32 addr, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(addr, 0, P2_VIF_MSCAL, irq));
    }
 
    static inline void packet2_vif_mscnt(packet2_t *packet2, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(0, 0, P2_VIF_MSCNT, irq));
    }
 
    static inline void packet2_vif_itop(packet2_t *packet2, u32 itops, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(itops, 0, P2_VIF_ITOP, irq));
    }
 
    static inline void packet2_vif_stmod(packet2_t *packet2, u32 mode, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(mode, 0, P2_VIF_STMOD, irq));
    }
 
    static inline void packet2_vif_mskpath3(packet2_t *packet2, u32 mask, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(mask, 0, P2_VIF_MSKPATH3, irq));
    }
 
    static inline void packet2_vif_mark(packet2_t *packet2, u32 value, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(value, 0, P2_VIF_MARK, irq));
    }
 
    static inline void packet2_vif_flushe(packet2_t *packet2, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(0, 0, P2_VIF_FLUSHE, irq));
    }
 
    static inline void packet2_vif_flusha(packet2_t *packet2, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(0, 0, P2_VIF_FLUSHA, irq));
    }
 
    static inline void packet2_vif_mscalf(packet2_t *packet2, u32 addr, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(addr, 0, P2_VIF_MSCALF, irq));
    }
 
    static inline void packet2_vif_stmask(packet2_t *packet2, Mask mask, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(0, 0, P2_VIF_STMASK, irq));
        packet2_add_u32(packet2, mask.m);
    }
 
    static inline void packet2_vif_strow(packet2_t *packet2, const u32 *row_arr, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(0, 0, P2_VIF_STROW, irq));
        packet2_add_u32(packet2, row_arr[0]);
        packet2_add_u32(packet2, row_arr[1]);
        packet2_add_u32(packet2, row_arr[2]);
        packet2_add_u32(packet2, row_arr[3]);
    }
 
    static inline void packet2_vif_stcol(packet2_t *packet2, const u32 *col_arr, u8 irq)
    {
        packet2_add_u32(packet2, MAKE_VIF_CODE(0, 0, P2_VIF_STCOL, irq));
        packet2_add_u32(packet2, col_arr[0]);
        packet2_add_u32(packet2, col_arr[1]);
        packet2_add_u32(packet2, col_arr[2]);
        packet2_add_u32(packet2, col_arr[3]);
    }
 
    void packet2_vif_add_micro_program(packet2_t *packet2, u32 dest, u32 *start, u32 *end);
 
#ifdef __cplusplus
}
#endif
 
#endif /* __PACKET2_VIF_H__ */