spu.h

Go to the documentation of this file.

#ifndef __SYS_SPU_H__
#define __SYS_SPU_H__

#include <ppu-asm.h>
#include <ppu-lv2.h>
#include <lv2/spu.h>

/* MFC channel registers */
#define MFC_LSA                                 0x3004  
#define MFC_EAH                                 0x3008  
#define MFC_EAL                                 0x300C  
#define MFC_Size                                0x3010  
#define MFC_Class_CMD                           0x3014  
#define MFC_CMD_Status                          0x3014  
#define MFC_QStatus                             0x3104  
#define Prxy_QueryType                          0x3204  
#define Prxy_QueryMask                          0x321C  
#define Prxy_TagStatus                          0x322C  
#define SPU_Out_MBox                            0x4004  
#define SPU_In_MBox                             0x400C  
#define SPU_MBox_Status                         0x4014  
#define SPU_RunCtrl                             0x401C  
#define SPU_Status                              0x4024  
#define SPU_NextPC                              0x4034  
#define SPU_Sig_Notify_1                        0x1400C 
#define SPU_Sig_Notify_2                        0x1C00C 

#define SPU_THREAD_ATTR_NONE                    0x00
#define SPU_THREAD_ATTR_ASYNC_INT_ENABLE        0x01
#define SPU_THREAD_ATTR_DEC_SYNC_TB_ENABLE      0x02

#define SPU_THREAD_EVENT_USER                   0x01
#define SPU_THREAD_EVENT_DMA                    0x02

#define SPU_THREAD_EVENT_USER_KEY               0xFFFFFFFF53505501ULL
#define SPU_THREAD_EVENT_DMA_KEY                0xFFFFFFFF53505502ULL

#define SPU_SIGNAL1_OVERWRITE                   0x00
#define SPU_SIGNAL1_OR                          0x01
#define SPU_SIGNAL2_OVERWRITE                   0x00
#define SPU_SIGNAL2_OR                          0x02

#define SPU_THREAD_BASE                         0xF0000000ULL
#define SPU_THREAD_OFFSET                       0x00100000ULL
#define SPU_RAW_BASE                            0xE0000000ULL
#define SPU_RAW_OFFSET                          0x00100000ULL
#define SPU_LOCAL_OFFSET                        0x00000000ULL
#define SPU_PROBLEM_OFFSET                      0x00040000ULL

#define SPU_RAW_GET_BASE_OFFSET(spu) \
    (SPU_RAW_BASE + (SPU_RAW_OFFSET*(spu)))

#define SPU_RAW_GET_LOCAL_STORAGE(spu,reg) \
    (SPU_RAW_GET_BASE_OFFSET(spu) + SPU_LOCAL_OFFSET + (reg))

#define SPU_RAW_GET_PROBLEM_STORAGE(spu,reg) \
    (SPU_RAW_GET_BASE_OFFSET(spu) + SPU_PROBLEM_OFFSET + (reg))

#define SPU_THREAD_GET_BASE_OFFSET(spu) \
    (SPU_THREAD_BASE + (SPU_THREAD_OFFSET*(spu)))

#define SPU_THREAD_GET_LOCAL_STORAGE(spu,reg) \
    (SPU_THREAD_GET_BASE_OFFSET(spu) + SPU_LOCAL_OFFSET + (reg))

#define SPU_THREAD_GET_PROBLEM_STORAGE(spu,reg) \
    (SPU_THREAD_GET_BASE_OFFSET(spu) + SPU_PROBLEM_OFFSET + (reg))

#ifdef __cplusplus
extern "C" {
#endif

typedef struct _sys_spu_thread_arg
{
    u64 arg0;   
    u64 arg1;   
    u64 arg2;   
    u64 arg3;   
} sysSpuThreadArgument;

typedef struct _sys_spu_thread_attr
{
    u32 nameAddress;    
    u32 nameSize;       
    u32 attribute;      
} sysSpuThreadAttribute;

typedef struct _sys_spu_thread_group_attr
{
    u32 nameSize;       
    u32 nameAddress;    
    u32 groupType;      
    u32 memContainer;   
} sysSpuThreadGroupAttribute;

LV2_SYSCALL sysSpuInitialize(u32 spus,u32 rawspus) 
{ 
    lv2syscall2(169,spus,rawspus); 
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuRawCreate(sys_raw_spu_t *spu,u32 *attributes)
{
    lv2syscall2(160,(u64)spu,(u64)attributes);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuRawDestroy(sys_raw_spu_t spu)
{
    lv2syscall1(161,spu);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuRawCreateInterrupTag(sys_raw_spu_t spu,u32 classid,u32 hardwarethread,u32 *tag)
{
    lv2syscall4(150,spu,classid,hardwarethread,(u64)tag);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuRawSetIntMask(sys_raw_spu_t spu,u32 classid,u64 mask)
{
    lv2syscall3(151,spu,classid,mask);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuRawGetIntMask(sys_raw_spu_t spu,u32 classid,u64 *mask)
{
    lv2syscall3(152,spu,classid,(u64)mask);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuRawSetIntStat(sys_raw_spu_t spu, u32 classid, u64 stat)
{ 
    lv2syscall3(153, spu, classid, stat);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuRawGetIntStat(sys_raw_spu_t spu, u32 classid, u64* stat)
{
    lv2syscall3(154, spu, classid, (u64)stat);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuRawReadPuintMb(sys_raw_spu_t spu, u32* value)
{
    lv2syscall2(163, spu, (u64)value);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuRawSetConfiguration(sys_raw_spu_t spu, u32 value)
{
    lv2syscall2(196, spu, value);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuRawGetConfirugation(sys_raw_spu_t spu, u32* value)
{
    lv2syscall2(197, spu, (u64)value);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuRawRecoverPageFault(sys_raw_spu_t spu)
{
    lv2syscall1(199, spu);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuImageOpen(sysSpuImage* image, const char* path)
{ 
    lv2syscall2(156, (u64)image, (u64)path);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuImageOpenFd(sysSpuImage* image, s32 fd, u64 offset)
{ 
    lv2syscall3(260, (u64)image, fd, offset);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadInitialize(sys_spu_thread_t* thread, sys_spu_group_t group, u32 spu, sysSpuImage* image, sysSpuThreadAttribute* attributes, sysSpuThreadArgument* arguments)
{
    lv2syscall6(172, (u64)thread, group, spu, (u64)image, (u64)attributes, (u64)arguments);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadSetArguments(sys_spu_thread_t thread, sysSpuThreadArgument* arguments)
{ 
    lv2syscall2(166, thread, (u64)arguments);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadGetExitStatus(sys_spu_thread_t thread, s32* status)
{
    lv2syscall2(165, thread, (u64)status);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadConnectEvent(sys_spu_thread_t thread, sys_event_queue_t queue, u32 type, u8 spup)
{
    lv2syscall4(191, thread, queue, type, spup);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadDisconnectEvent(sys_spu_thread_t thread, u32 type, u8 spup) 
{ 
    lv2syscall3(192, thread, type, spup); 
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadBindQueue(sys_spu_thread_t thread, sys_event_queue_t queue, u32 spuq_num) 
{ 
    lv2syscall3(193, thread, queue, spuq_num); 
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadUnbindQueue(sys_spu_thread_t thread, u32 spuq_num) 
{ 
    lv2syscall2(194, thread, spuq_num); 
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadWriteLocalStorage(sys_spu_thread_t thread, u32 address, u64 value, u32 type) 
{ 
    lv2syscall4(181, thread, address, value, type); 
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadReadLocalStorage(sys_spu_thread_t thread, u32 address, u64* value, u32 type) 
{ 
    lv2syscall4(182, thread, address, (u64)value, type); 
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadWriteSignal(sys_spu_thread_t thread,u32 signal,u32 value)
{
    lv2syscall3(184,thread,signal,value);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadSetConfiguration(sys_spu_thread_t thread, u64 value) 
{ 
    lv2syscall2(187, thread, value); 
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadGetConfiguration(sys_spu_thread_t thread, u64* value) 
{ 
    lv2syscall2(188, thread, (u64)value); 
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadWriteMb(sys_spu_thread_t thread, u32 value) 
{ 
    lv2syscall2(190, thread, value); 
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadRecoverPageFault(sys_spu_thread_t thread) 
{ 
    lv2syscall1(198, thread); 
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadGroupCreate(sys_spu_group_t *group,u32 num,u32 prio,sysSpuThreadGroupAttribute *attr)
{
    lv2syscall4(170,(u64)group,num,prio,(u64)attr);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadGroupDestroy(sys_spu_group_t group)
{
    lv2syscall1(171,group);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadGroupStart(sys_spu_group_t group)
{
    lv2syscall1(173,group);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadGroupSuspend(sys_spu_group_t group)
{
    lv2syscall1(174,group);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadGroupResume(sys_spu_group_t group)
{
    lv2syscall1(175,group);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadGroupYield(sys_spu_group_t group)
{
    lv2syscall1(176,group);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadGroupTerminate(sys_spu_group_t group,u32 value)
{
    lv2syscall2(177,group,value);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadGroupJoin(sys_spu_group_t group,u32 *cause,u32 *status)
{
    lv2syscall3(178,group,(u64)cause,(u64)status);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadGroupSetPriority(sys_spu_group_t group,u32 prio)
{
    lv2syscall2(179,group,prio);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadGroupGetPriority(sys_spu_group_t group,u32 *prio)
{
    lv2syscall2(180,group,(u64)prio);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadGroupConnectEvent(sys_spu_group_t group,sys_event_queue_t eventQ,u32 eventType)
{
    lv2syscall3(185,group,eventQ,eventType);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadGroupDisconnectEvent(sys_spu_group_t group,u32 eventType)
{
    lv2syscall2(186,group,eventType);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadGroupConnectEventAllThreads(sys_spu_group_t group,sys_event_queue_t eventQ,u64 req,u8 *spup)
{
    lv2syscall4(251,group,eventQ,req,(u64)spup);
    return_to_user_prog(s32);
}

LV2_SYSCALL sysSpuThreadGroupDisonnectEventAllThreads(sys_spu_group_t group,u8 spup)
{
    lv2syscall2(252,group,spup);
    return_to_user_prog(s32);
}

static inline void sysSpuRawWriteProblemStorage(sys_raw_spu_t spu,u32 reg,u32 value)
{
    __write32(SPU_RAW_GET_PROBLEM_STORAGE(spu,reg),value);
}

static inline u32 sysSpuRawReadProblemStorage(sys_raw_spu_t spu,u32 reg)
{
    return __read32(SPU_RAW_GET_PROBLEM_STORAGE(spu,reg));
}

static inline void sysSpuRawWriteLocalStorage(sys_raw_spu_t spu,u32 reg,u32 value)
{
    __write32(SPU_RAW_GET_LOCAL_STORAGE(spu,reg),value);
}

static inline u32 sysSpuRawReadLocalStorage(sys_raw_spu_t spu,u32 reg)
{
    return __read32(SPU_RAW_GET_LOCAL_STORAGE(spu,reg));
}

static inline void sysSpuThreadWriteProblemStorage(sys_raw_spu_t spu,u32 reg,u32 value)
{
    __write32(SPU_THREAD_GET_PROBLEM_STORAGE(spu,reg),value);
}

static inline u32 sysSpuThreadReadProblemStorage(sys_raw_spu_t spu,u32 reg)
{
    return __read32(SPU_THREAD_GET_PROBLEM_STORAGE(spu,reg));
}

#ifdef __cplusplus
    }
#endif

#endif