Skip to content

Commit 6ba0ad0

Browse files
DHrpcs3DHrpcs3
committed
[rpcsx-os] implement fw simulation
implement impi messages
1 parent 2278a29 commit 6ba0ad0

File tree

8 files changed

+516
-153
lines changed

8 files changed

+516
-153
lines changed

‎hw/amdgpu/bridge/include/amdgpu/bridge/bridge.hpp

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,14 @@
11
#pragma once
22

3-
#include "orbis/utils/SharedMutex.hpp"
43
#include <atomic>
54
#include <cstdint>
65
#include <cstring>
76
#include <initializer_list>
87
#include <orbis/utils/SharedCV.hpp>
98

109
namespace amdgpu::bridge {
10+
extern std::uint32_t expGpuPid;
11+
1112
struct PadState {
1213
std::uint64_t timestamp;
1314
std::uint32_t unk;
@@ -149,21 +150,21 @@ struct BridgePusher {
149150

150151
void sendMemoryProtect(std::uint32_t pid, std::uint64_t address,
151152
std::uint64_t size, std::uint32_t prot) {
152-
if (pid == 50001) {
153+
if (pid == expGpuPid) {
153154
sendCommand(CommandId::ProtectMemory, {pid, address, size, prot});
154155
}
155156
}
156157

157158
void sendCommandBuffer(std::uint32_t pid, std::uint64_t queue,
158159
std::uint64_t address, std::uint64_t size) {
159-
if (pid == 50001) {
160+
if (pid == expGpuPid) {
160161
sendCommand(CommandId::CommandBuffer, {pid, queue, address, size});
161162
}
162163
}
163164

164165
void sendFlip(std::uint32_t pid, std::uint32_t bufferIndex,
165166
std::uint64_t arg) {
166-
if (pid == 50001) {
167+
if (pid == expGpuPid) {
167168
sendCommand(CommandId::Flip, {pid, bufferIndex, arg});
168169
}
169170
}

‎hw/amdgpu/bridge/src/bridge.cpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,8 @@
88
static int gShmFd = -1;
99
static constexpr std::size_t kShmSize = sizeof(amdgpu::bridge::BridgeHeader) +
1010
(sizeof(std::uint64_t) * (1024 * 1024));
11+
std::uint32_t amdgpu::bridge::expGpuPid = 0;
12+
1113
amdgpu::bridge::BridgeHeader *
1214
amdgpu::bridge::createShmCommandBuffer(const char *name) {
1315
if (gShmFd != -1) {

‎orbis-kernel/include/orbis/ipmi.hpp

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -58,6 +58,8 @@ struct IpmiClient : RcBase {
5858
shared_mutex mutex;
5959
shared_cv sessionCv;
6060
sint pid;
61+
kdeque<kvector<std::byte>> messages;
62+
shared_cv messageCv;
6163

6264
explicit IpmiClient(kstring name) : name(std::move(name)) {}
6365
};
@@ -150,6 +152,8 @@ SysResult sysIpmiSendConnectResult(Thread *thread, ptr<uint> result, uint kid,
150152
ptr<void> params, uint64_t paramsSz);
151153
SysResult sysIpmiSessionRespondSync(Thread *thread, ptr<uint> result, uint kid,
152154
ptr<void> params, uint64_t paramsSz);
155+
SysResult sysIpmiClientTryGetMessage(Thread *thread, ptr<uint> result, uint kid,
156+
ptr<void> params, uint64_t paramsSz);
153157
SysResult sysIpmiSessionGetClientPid(Thread *thread, ptr<uint> result, uint kid,
154158
ptr<void> params, uint64_t paramsSz);
155159
SysResult sysIpmiClientInvokeSyncMethod(Thread *thread, ptr<uint> result,
@@ -161,9 +165,8 @@ SysResult sysIpmiSessionGetUserData(Thread *thread, ptr<uint> result, uint kid,
161165
ptr<void> params, uint64_t paramsSz);
162166
SysResult sysIpmiServerGetName(Thread *thread, ptr<uint> result, uint kid,
163167
ptr<void> params, uint64_t paramsSz);
164-
SysResult sysIpmiClientPollEventFlag(Thread *thread, ptr<uint> result,
165-
uint kid, ptr<void> params,
166-
uint64_t paramsSz);
168+
SysResult sysIpmiClientPollEventFlag(Thread *thread, ptr<uint> result, uint kid,
169+
ptr<void> params, uint64_t paramsSz);
167170
SysResult sysIpmiSessionWaitEventFlag(Thread *thread, ptr<uint> result,
168171
uint kid, ptr<void> params,
169172
uint64_t paramsSz);

‎orbis-kernel/src/ipmi.cpp

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -341,6 +341,54 @@ orbis::SysResult orbis::sysIpmiSessionRespondSync(Thread *thread,
341341
return uwrite(result, 0u);
342342
}
343343

344+
orbis::SysResult orbis::sysIpmiClientTryGetMessage(Thread *thread,
345+
ptr<uint> result, uint kid,
346+
ptr<void> params,
347+
uint64_t paramsSz) {
348+
struct SceIpmiClientTryGetArgs {
349+
uint32_t unk; // 0
350+
uint32_t padding;
351+
ptr<std::byte> message;
352+
ptr<uint64_t> pSize;
353+
uint64_t maxSize;
354+
};
355+
356+
static_assert(sizeof(SceIpmiClientTryGetArgs) == 0x20);
357+
358+
if (paramsSz != sizeof(SceIpmiClientTryGetArgs)) {
359+
return ErrorCode::INVAL;
360+
}
361+
362+
auto client = thread->tproc->ipmiMap.get(kid).cast<IpmiClient>();
363+
364+
if (client == nullptr) {
365+
return ErrorCode::INVAL;
366+
}
367+
368+
SceIpmiClientTryGetArgs _params;
369+
ORBIS_RET_ON_ERROR(uread(_params, ptr<SceIpmiClientTryGetArgs>(params)));
370+
371+
std::lock_guard lock(client->mutex);
372+
if (client->messages.empty()) {
373+
return uwrite<uint>(result,
374+
0x80020000 + static_cast<int>(ErrorCode::AGAIN));
375+
}
376+
377+
auto &message = client->messages.front();
378+
379+
if (_params.maxSize < message.size()) {
380+
ORBIS_LOG_ERROR(__FUNCTION__, "too small buffer");
381+
return uwrite<uint>(result,
382+
0x80020000 + static_cast<int>(ErrorCode::INVAL));
383+
}
384+
385+
ORBIS_RET_ON_ERROR(uwrite(_params.pSize, message.size()));
386+
ORBIS_RET_ON_ERROR(
387+
uwriteRaw(_params.message, message.data(), message.size()));
388+
client->messages.pop_front();
389+
return uwrite<uint>(result, 0);
390+
}
391+
344392
orbis::SysResult orbis::sysIpmiSessionGetClientPid(Thread *thread,
345393
ptr<uint> result, uint kid,
346394
ptr<void> params,

‎orbis-kernel/src/sys/sys_sce.cpp

Lines changed: 25 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -950,25 +950,26 @@ orbis::SysResult orbis::sys_get_self_auth_info(Thread *thread,
950950
ORBIS_LOG_ERROR(__FUNCTION__, path, result);
951951
thread->where();
952952

953-
return uwrite(
954-
result, {
955-
.unk0 = 0x3100000000000001,
956-
.caps =
957-
{
958-
~0ull, ~0ull, ~0ull, ~0ull,
959-
// 0x2000038000000000,
960-
// 0x000000000000FF00,
961-
// 0x0000000000000000,
962-
// 0x0000000000000000,
963-
},
964-
.attrs =
965-
{
966-
0x4000400040000000,
967-
0x4000000000000000,
968-
0x0080000000000004, // lower byte is application type
969-
0xF0000000FFFF4000,
970-
},
971-
});
953+
char _path[512];
954+
ORBIS_RET_ON_ERROR(ureadString(_path, sizeof(_path), path));
955+
956+
struct Result {
957+
std::uint64_t authorityId;
958+
std::uint64_t programType;
959+
std::uint64_t programVersion;
960+
std::uint64_t systemVersion;
961+
char contentId[32];
962+
char hash[32];
963+
};
964+
965+
Result _result{};
966+
_result.authorityId = 0x1000;
967+
_result.programType = 1;
968+
_result.programVersion = 1;
969+
_result.systemVersion = 1;
970+
_result.contentId[24] = 4;
971+
972+
return uwrite((ptr<Result>)result, _result);
972973

973974
return {};
974975
}
@@ -1095,8 +1096,7 @@ orbis::SysResult orbis::sys_ipmimgr_call(Thread *thread, uint op, uint kid,
10951096
case 0x232:
10961097
return sysIpmiSessionRespondSync(thread, result, kid, params, paramsSz);
10971098
case 0x252:
1098-
// TODO: try get message
1099-
return uwrite<uint>(result, 0x80020023);
1099+
return sysIpmiClientTryGetMessage(thread, result, kid, params, paramsSz);
11001100
case 0x302:
11011101
return sysIpmiSessionGetClientPid(thread, result, kid, params, paramsSz);
11021102
case 0x320:
@@ -1225,8 +1225,8 @@ orbis::SysResult
12251225
orbis::sys_get_kernel_mem_statistics(Thread *thread /* TODO */) {
12261226
return ErrorCode::NOSYS;
12271227
}
1228-
orbis::SysResult
1229-
orbis::sys_get_sdk_compiled_version(Thread *thread, ptr<const char> path) {
1228+
orbis::SysResult orbis::sys_get_sdk_compiled_version(Thread *thread,
1229+
ptr<const char> path) {
12301230
ORBIS_LOG_ERROR(__FUNCTION__, path);
12311231
thread->retval[0] = g_context.sdkVersion;
12321232
return {};
@@ -1244,8 +1244,8 @@ orbis::SysResult orbis::sys_dynlib_get_obj_member(Thread *thread,
12441244

12451245
return ErrorCode::NOSYS;
12461246
}
1247-
orbis::SysResult
1248-
orbis::sys_budget_get_ptype_of_budget(Thread *thread, sint budgetId) {
1247+
orbis::SysResult orbis::sys_budget_get_ptype_of_budget(Thread *thread,
1248+
sint budgetId) {
12491249
ORBIS_LOG_WARNING(__FUNCTION__, budgetId);
12501250
thread->retval[0] = budgetId;
12511251
return {};

‎rpcsx-gpu/main.cpp

Lines changed: 1 addition & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -92,7 +92,7 @@ int main(int argc, const char *argv[]) {
9292
}
9393

9494
const char *cmdBridgeName = "/rpcsx-gpu-cmds";
95-
const char *shmName = "/rpcsx-os-memory-50001";
95+
const char *shmName = "/rpcsx-os-memory";
9696
unsigned long gpuIndex = 0;
9797
auto presenter = PresenterMode::Window;
9898
bool enableValidation = false;
@@ -945,25 +945,15 @@ int main(int argc, const char *argv[]) {
945945
for (auto cmd : std::span(commandsBuffer, pulledCount)) {
946946
switch (cmd.id) {
947947
case amdgpu::bridge::CommandId::ProtectMemory:
948-
if (cmd.memoryProt.pid != 50001) {
949-
continue;
950-
}
951948
device.handleProtectMemory(cmd.memoryProt.address,
952949
cmd.memoryProt.size, cmd.memoryProt.prot);
953950
break;
954951
case amdgpu::bridge::CommandId::CommandBuffer:
955-
if (cmd.memoryProt.pid != 50001) {
956-
continue;
957-
}
958952
device.handleCommandBuffer(cmd.commandBuffer.queue,
959953
cmd.commandBuffer.address,
960954
cmd.commandBuffer.size);
961955
break;
962956
case amdgpu::bridge::CommandId::Flip: {
963-
if (cmd.memoryProt.pid != 50001) {
964-
continue;
965-
}
966-
967957
if (!isImageAcquired) {
968958
Verify() << vkAcquireNextImageKHR(vkDevice, swapchain, UINT64_MAX,
969959
presentCompleteSemaphore, nullptr,

0 commit comments

Comments
 (0)