mirrors/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-04-20 03:25:16 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Compilation fix + CellSpursAttribute

Browse source
This commit is contained in:
Nekotekina 2014-09-15 22:17:30 +04:00
parent 201f0f3a9f
commit c9132a4bdb
5 changed files with 149 additions and 128 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
Utilities/BEType.h
View file

@ -530,6 +530,24 @@ template<typename T, typename T1, T1 value> struct _se<be_t<T>, T1, value> : pub
#define se32(x) _se<u32, decltype(x), x>::value
#define se64(x) _se<u64, decltype(x), x>::value
// template that helps to define be_t arrays in unions
template<typename T, size_t size>
class be_array_t
{
be_t<T> data[size];
public:
__forceinline be_t<T>& operator [] (size_t index)
{
return data[index];
}
__forceinline const be_t<T>& operator [] (size_t index) const
{
return data[index];
}
};
template<typename T> __forceinline static u8 Read8(T& f)
{
u8 ret;

35
rpcs3/Emu/Cell/SPURSManager.cpp
View file

@ -3,37 +3,6 @@
#include "SPURSManager.h"
SPURSManagerAttribute::SPURSManagerAttribute(int nSpus, int spuPriority, int ppuPriority, bool exitIfNoWork)
{
this->nSpus = nSpus;
this->spuThreadGroupPriority = spuPriority;
this->ppuThreadPriority = ppuPriority;
this->exitIfNoWork = exitIfNoWork;
memset(this->namePrefix, 0, CELL_SPURS_NAME_MAX_LENGTH + 1);
this->threadGroupType = 0;
this->container = 0;
}
int SPURSManagerAttribute::_setNamePrefix(const char *name, u32 size)
{
strncpy(this->namePrefix, name, size);
this->namePrefix[0] = 0;
return 0;
}
int SPURSManagerAttribute::_setSpuThreadGroupType(int type)
{
this->threadGroupType = type;
return 0;
}
int SPURSManagerAttribute::_setMemoryContainerForSpuThread(u32 container)
{
this->container = container;
return 0;
}
SPURSManagerEventFlag::SPURSManagerEventFlag(u32 flagClearMode, u32 flagDirection)
{
this->flagClearMode = flagClearMode;
@ -46,14 +15,12 @@ SPURSManagerTasksetAttribute::SPURSManagerTasksetAttribute(u64 args, vm::ptr<con
this->maxContention = maxContention;
}
SPURSManager::SPURSManager(SPURSManagerAttribute *attr)
SPURSManager::SPURSManager()
{
this->attr = attr;
}
void SPURSManager::Finalize()
{
delete this->attr;
}
void SPURSManager::AttachLv2EventQueue(u32 queue, vm::ptr<u8> port, int isDynamic)

27
rpcs3/Emu/Cell/SPURSManager.h
View file

@ -2,28 +2,6 @@
#include "Emu/SysCalls/Modules/cellSpurs.h"
// Internal class to shape a SPURS attribute.
class SPURSManagerAttribute
{
public:
SPURSManagerAttribute(int nSpus, int spuPriority, int ppuPriority, bool exitIfNoWork);
int _setNamePrefix(const char *name, u32 size);
int _setSpuThreadGroupType(int type);
int _setMemoryContainerForSpuThread(u32 container);
protected:
be_t<int> nSpus;
be_t<int> spuThreadGroupPriority;
be_t<int> ppuThreadPriority;
bool exitIfNoWork;
char namePrefix[CELL_SPURS_NAME_MAX_LENGTH+1];
be_t<int> threadGroupType;
be_t<u32> container;
};
class SPURSManagerEventFlag
{
public:
@ -68,12 +46,9 @@ protected:
class SPURSManager
{
public:
SPURSManager(SPURSManagerAttribute *attr);
SPURSManager();
void Finalize();
void AttachLv2EventQueue(u32 queue, vm::ptr<u8> port, int isDynamic);
void DetachLv2EventQueue(u8 port);
protected:
SPURSManagerAttribute *attr;
};

171
rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
View file

@ -15,23 +15,23 @@ extern u32 libsre_rtoc;
s64 spursInit(
vm::ptr<CellSpurs2> spurs,
u32 arg2,
u64 arg3,
u32 revision,
u32 sdkVersion,
s32 nSpus,
s32 spuPriority,
s32 ppuPriority,
u32 flags,
u32 arg8,
u32 arg9,
u32 arg10,
const char prefix[],
u32 prefixSize,
u32 container,
u32 arg11,
u32 arg12,
u32 arg13)
{
// internal function
#ifdef PRX_DEBUG
return cb_caller<s32,vm::ptr<CellSpurs2>, u32, u64, s32, s32, s32, u32, u32, u32, u32, u32, u32, u32>::call(GetCurrentPPUThread(), libsre + 0x74E4, libsre_rtoc,
spurs, arg2, arg3, nSpus, spuPriority, ppuPriority, flags, arg8, arg9, arg10, arg11, arg12, arg13);
return cb_caller<s32,vm::ptr<CellSpurs2>, u32, u32, s32, s32, s32, u32, u32, u32, u32, u32, u32, u32>::call(GetCurrentPPUThread(), libsre + 0x74E4, libsre_rtoc,
spurs, revision, sdkVersion, nSpus, spuPriority, ppuPriority, flags, Memory.RealToVirtualAddr(prefix), prefixSize, container, arg11, arg12, arg13);
#else
//spurs->spurs = new SPURSManager(attr);
return CELL_OK;
@ -54,7 +54,7 @@ s64 cellSpursInitialize(vm::ptr<CellSpurs> spurs, s32 nSpus, s32 spuPriority, s3
spuPriority,
ppuPriority,
exitIfNoWork ? 1 : 0,
0,
nullptr,
0,
0,
0,
@ -78,25 +78,25 @@ s64 cellSpursInitializeWithAttribute(vm::ptr<CellSpurs> spurs, vm::ptr<const Cel
{
return CELL_SPURS_CORE_ERROR_ALIGN;
}
if (attr->m.arg1 > 2)
if (attr->m.revision > 2)
{
return CELL_SPURS_CORE_ERROR_INVAL;
}
return spursInit(
vm::ptr<CellSpurs2>::make(spurs.addr()),
attr->m.arg1,
attr->m.arg2,
attr->m.revision,
attr->m.sdkVersion,
attr->m.nSpus,
attr->m.spuPriority,
attr->m.ppuPriority,
(u32)attr->_u32.raw[10] | (u32)attr->_u8[20],
attr.addr() + 0x15,
attr->_u32.raw[9],
attr->_u32.raw[11],
(u32)attr->m.flags | (attr->m.exitIfNoWork ? 1 : 0),
attr->m.prefix,
attr->m.prefixSize,
attr->m.container,
attr.addr() + 0x38,
attr->_u32.raw[16],
attr->_u32.raw[17]);
attr->_u32[16],
attr->_u32[17]);
#endif
}
@ -115,83 +115,106 @@ s64 cellSpursInitializeWithAttribute2(vm::ptr<CellSpurs2> spurs, vm::ptr<const C
{
return CELL_SPURS_CORE_ERROR_ALIGN;
}
if (attr->m.arg1 > 2)
if (attr->m.revision > 2)
{
return CELL_SPURS_CORE_ERROR_INVAL;
}
return spursInit(
spurs,
attr->m.arg1,
attr->m.arg2,
attr->m.revision,
attr->m.sdkVersion,
attr->m.nSpus,
attr->m.spuPriority,
attr->m.ppuPriority,
(u32)attr->_u32.raw[10] | (u32)attr->_u8[20] | 4,
attr.addr() + 0x15,
attr->_u32.raw[9],
attr->_u32.raw[11],
(u32)attr->m.flags | (attr->m.exitIfNoWork ? 1 : 0) | 4,
attr->m.prefix,
attr->m.prefixSize,
attr->m.container,
attr.addr() + 0x38,
attr->_u32.raw[16],
attr->_u32.raw[17]);
attr->_u32[16],
attr->_u32[17]);
#endif
}
s64 cellSpursFinalize(vm::ptr<CellSpurs> spurs)
s64 _cellSpursAttributeInitialize(vm::ptr<CellSpursAttribute> attr, u32 revision, u32 sdkVersion, u32 nSpus, s32 spuPriority, s32 ppuPriority, bool exitIfNoWork)
{
cellSpurs->Warning("cellSpursFinalize(spurs_addr=0x%x)", spurs.addr());
cellSpurs->Warning("_cellSpursAttributeInitialize(attr_addr=0x%x, revision=%d, sdkVersion=0x%x, nSpus=%d, spuPriority=%d, ppuPriority=%d, exitIfNoWork=%d)",
attr.addr(), revision, sdkVersion, nSpus, spuPriority, ppuPriority, exitIfNoWork ? 1 : 0);
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libsre + 0x8568, libsre_rtoc);
#else
spurs->spurs->Finalize();
return CELL_OK;
#endif
}
s64 _cellSpursAttributeInitialize(vm::ptr<CellSpursAttribute> attr, s32 nSpus, s32 spuPriority, s32 ppuPriority, bool exitIfNoWork)
{
cellSpurs->Warning("_cellSpursAttributeInitialize(attr_addr=0x%x, nSpus=%d, spuPriority=%d, ppuPriority=%d, exitIfNoWork=%d)",
attr.addr(), nSpus, spuPriority, ppuPriority, exitIfNoWork);
#ifdef PRX_DEBUG
#ifdef PRX_DEBUG_XXX
return GetCurrentPPUThread().FastCall2(libsre + 0x72CC, libsre_rtoc);
#else
attr->attr = new SPURSManagerAttribute(nSpus, spuPriority, ppuPriority, exitIfNoWork);
if (!attr)
{
return CELL_SPURS_CORE_ERROR_NULL_POINTER;
}
if (attr.addr() % 8)
{
return CELL_SPURS_CORE_ERROR_ALIGN;
}
memset(attr.get_ptr(), 0, attr->size);
attr->m.revision = revision;
attr->m.sdkVersion = sdkVersion;
attr->m.nSpus = nSpus;
attr->m.spuPriority = spuPriority;
attr->m.ppuPriority = ppuPriority;
attr->m.exitIfNoWork = exitIfNoWork;
return CELL_OK;
#endif
}
s64 cellSpursAttributeSetMemoryContainerForSpuThread(vm::ptr<CellSpursAttribute> attr, u32 container)
{
cellSpurs->Warning("cellSpursAttributeSetMemoryContainerForSpuThread(attr_addr=0x%x, container=0x%x)", attr.addr(), container);
cellSpurs->Warning("cellSpursAttributeSetMemoryContainerForSpuThread(attr_addr=0x%x, container=%d)", attr.addr(), container);
#ifdef PRX_DEBUG
#ifdef PRX_DEBUG_XXX
return GetCurrentPPUThread().FastCall2(libsre + 0x6FF8, libsre_rtoc);
#else
attr->attr->_setMemoryContainerForSpuThread(container);
if (!attr)
{
return CELL_SPURS_CORE_ERROR_NULL_POINTER;
}
if (attr.addr() % 8)
{
return CELL_SPURS_CORE_ERROR_ALIGN;
}
CellSpursAttribute a = *attr;
if ((u32)a.m.flags & 0x20000000) // check unknown flag
{
return CELL_SPURS_CORE_ERROR_STAT;
}
attr->_u32[11] = container;
attr->m.flags |= 0x40000000; // set unknown flag
return CELL_OK;
#endif
}
s64 cellSpursAttributeSetNamePrefix(vm::ptr<CellSpursAttribute> attr, vm::ptr<const char> prefix, u32 size)
{
cellSpurs->Warning("cellSpursAttributeSetNamePrefix(attr_addr=0x%x, prefix_addr=0x%x, size=0x%x)", attr.addr(), prefix.addr(), size);
cellSpurs->Warning("cellSpursAttributeSetNamePrefix(attr_addr=0x%x, prefix_addr=0x%x, size=%d)", attr.addr(), prefix.addr(), size);
#ifdef PRX_DEBUG
#ifdef PRX_DEBUG_XXX
return GetCurrentPPUThread().FastCall2(libsre + 0x7234, libsre_rtoc);
#else
if (!attr || !prefix)
{
return CELL_SPURS_CORE_ERROR_NULL_POINTER;
}
if (attr.addr() % 8)
{
return CELL_SPURS_CORE_ERROR_ALIGN;
}
if (size > CELL_SPURS_NAME_MAX_LENGTH)
{
cellSpurs->Error("cellSpursAttributeSetNamePrefix : CELL_SPURS_CORE_ERROR_INVAL");
return CELL_SPURS_CORE_ERROR_INVAL;
}
attr->attr->_setNamePrefix(prefix.get_ptr(), size);
memcpy(attr->m.prefix, prefix.get_ptr(), size);
attr->m.prefixSize = size;
return CELL_OK;
#endif
}
@ -211,12 +234,37 @@ s64 cellSpursAttributeSetSpuThreadGroupType(vm::ptr<CellSpursAttribute> attr, s3
{
cellSpurs->Warning("cellSpursAttributeSetSpuThreadGroupType(attr_addr=0x%x, type=%d)", attr.addr(), type);
#ifdef PRX_DEBUG
#ifdef PRX_DEBUG_XXX
return GetCurrentPPUThread().FastCall2(libsre + 0x70C8, libsre_rtoc);
#else
attr->attr->_setSpuThreadGroupType(type);
if (!attr)
{
return CELL_SPURS_CORE_ERROR_NULL_POINTER;
}
if (attr.addr() % 8)
{
return CELL_SPURS_CORE_ERROR_ALIGN;
}
return CELL_OK;
if (type == 0x18)
{
if (attr->m.flags & 0x40000000) // check unknown flag
{
return CELL_SPURS_CORE_ERROR_STAT;
}
attr->m.flags |= 0x20000000; // set unknown flag
return CELL_OK;
}
else if (type)
{
return CELL_SPURS_CORE_ERROR_INVAL;
}
else // if type == 0
{
attr->m.flags &= ~0x20000000; // clear unknown flag
return CELL_OK;
}
#endif
}
@ -240,6 +288,19 @@ s64 cellSpursAttributeEnableSystemWorkload(vm::ptr<CellSpursAttribute> attr, vm:
#endif
}
s64 cellSpursFinalize(vm::ptr<CellSpurs> spurs)
{
cellSpurs->Warning("cellSpursFinalize(spurs_addr=0x%x)", spurs.addr());
#ifdef PRX_DEBUG
return GetCurrentPPUThread().FastCall2(libsre + 0x8568, libsre_rtoc);
#else
spurs->spurs->Finalize();
return CELL_OK;
#endif
}
s64 cellSpursGetSpuThreadGroupId(vm::ptr<CellSpurs> spurs, vm::ptr<be_t<u32>> group)
{
#ifdef PRX_DEBUG

26
rpcs3/Emu/SysCalls/Modules/cellSpurs.h
View file

@ -77,7 +77,6 @@ enum TaskConstants
};
class SPURSManager;
class SPURSManagerAttribute;
class SPURSManagerEventFlag;
class SPURSManagerTaskset;
@ -100,27 +99,28 @@ struct CellSpursAttribute
union
{
// raw data
u8 _u8[size / sizeof(u8)];
struct
{
be_t<u32> raw[size / sizeof(u32)];
} _u32;
u8 _u8[size];
be_array_t<u32, size / sizeof(u32)> _u32;
// real structure
struct
{
be_t<u32> arg1;
be_t<u32> arg2;
be_t<u32> nSpus;
be_t<s32> spuPriority;
be_t<s32> ppuPriority;
be_t<u32> revision; // 0x0
be_t<u32> sdkVersion; // 0x4
be_t<u32> nSpus; // 0x8
be_t<s32> spuPriority; // 0xC
be_t<s32> ppuPriority; // 0x10
bool exitIfNoWork; // 0x14
char prefix[15]; // 0x15 (not a NTS)
be_t<u32> prefixSize; // 0x24
be_t<u32> flags; // 0x28
be_t<u32> container; // 0x2C
// ...
} m;
// alternative implementation
struct
{
SPURSManagerAttribute *attr;
} c;
};
};