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_GROUP_TYPE_NORMAL                        0x0
#define SPU_THREAD_GROUP_TYPE_SEQUENTIAL                    0x1
#define SPU_THREAD_GROUP_TYPE_SYSTEM                        0x2
#define SPU_THREAD_GROUP_TYPE_MEMORY_FROM_CONTAINER         0x4
 
#define SPU_THREAD_GROUP_JOIN_GROUP_EXIT                    0x0001
#define SPU_THREAD_GROUP_JOIN_ALL_THREADS_EXIT              0x0002
#define SPU_THREAD_GROUP_JOIN_TERMINATED                    0x0004
 
#define SPU_THREAD_GROUP_EVENT_RUN                          0x1
#define SPU_THREAD_GROUP_EVENT_RUN_KEY                      0xFFFFFFFF53505500ULL
#define SPU_THREAD_GROUP_EVENT_EXCEPTION                    0x2
#define SPU_THREAD_GROUP_EVENT_EXCEPTION_KEY                0xFFFFFFFF53505503ULL
 
#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
 
/* exception causes */
#define SPU_EXCEPTION_DMA_ALIGNMENT                         0x0001U
#define SPU_EXCEPTION_DMA_COMMAND                           0x0002U
#define SPU_EXCEPTION_SPU_ERROR                             0x0004U
#define SPU_EXCEPTION_MFC_FIR                               0x0008U
#define SPU_EXCEPTION_MFC_SEGMENT                           0x0010U
#define SPU_EXCEPTION_MFC_STORAGE                           0x0020U
#define SPU_EXCEPTION_STOP_CALL                             0x0100U
#define SPU_EXCEPTION_STOP_BREAK                            0x0200U
#define SPU_EXCEPTION_HALT                                  0x0400U
#define SPU_EXCEPTION_UNKNOWN_SIGNAL                        0x0800U
#define SPU_EXCEPTION_NO_VALUE                              0x0U
 
#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
{
    const char *name ATTRIBUTE_PRXPTR;  
    u32 nsize;                          
    u32 option;                         
} sysSpuThreadAttribute;
 
typedef struct _sys_spu_thread_group_attr
{
    u32 nsize;                          
    const char *name ATTRIBUTE_PRXPTR;  
    u32 type;                           
    union {
        sys_mem_container_t ct;         
    } option;
} sysSpuThreadGroupAttribute;
 
#define sysSpuThreadAttributeInitialize(x)      \
    do {                                        \
        x.name = NULL;                          \
        x.nsize = 0;                            \
        x.option = SPU_THREAD_ATTR_NONE;        \
    } while(0)
    
#define sysSpuThreadAttributeName(x, s)             \
    do {                                            \
        x.name = s;                                 \
        if(s == NULL) {                             \
            x.nsize = 0;                            \
        } else {                                    \
            int n = 0;                              \
            for(; (n<127) && (s[n] != '\0'); n++)   \
                ;                                   \
            x.nsize = n + 1;                        \
        }                                           \
    } while(0)
 
#define sysSpuThreadAttributeOption(x, f)       \
    do {                                        \
        x.option = f;                           \
    } while(0)
    
#define sysSpuThreadArgumentInitialize(x)       \
    do {                                        \
        x.arg0 = x.arg1 = x.arg2 = x.arg3 = 0;  \
    } while(0)
    
#define sysSpuThreadGroupAttributeInitialize(x) \
    do {                                        \
        x.name = NULL;                          \
        x.nsize = 0;                            \
        x.type = SPU_THREAD_GROUP_TYPE_NORMAL;  \
    } while(0)
    
#define sysSpuThreadGroupAttributeName(x, s)        \
    do {                                            \
        x.name = s;                                 \
        if(s == NULL) {                             \
            x.nsize = 0;                            \
        } else {                                    \
            int n = 0;                              \
            for(; (n<127) && (s[n] != '\0'); n++)   \
                ;                                   \
            x.nsize = n + 1;                        \
        }                                           \
    } while(0)
    
#define sysSpuThreadGroupAttributeType(x, t)        \
    do {                                            \
        x.type = t;                                 \
    } while(0)
 
#define sysSpuThreadGroupAttributeMemoryContainer(x, ct)        \
    do {                                                        \
        x.type |= SPU_THREAD_GROUP_TYPE_MEMORY_FROM_CONTAINER;  \
        x.option.ct = ct;                                       \
    } while(0)
    
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