Skip to content

PS2 games in the browser: static recompilation to WebAssembly with a native runtime

C++

iop: SIO2 with a DualShock 2, a USB host controller and dmacman

Samir Nuri414ec953d013
diff --git a/runtime/src/iop/hw.cpp b/runtime/src/iop/hw.cpp
index 62db7c9..d10fc12 100644
--- a/runtime/src/iop/hw.cpp
+++ b/runtime/src/iop/hw.cpp
@@ -2,6 +2,7 @@
#include "iop.hpp"
#include "kernel.hpp"
+#include "sio2.hpp"
#include "spu2.hpp"
#include <cstdio>
@@ -79,6 +80,7 @@ struct Dma {
std::uint32_t madr, bcr, chcr, tadr;
};
Dma g_dma[14];
+std::uint32_t g_ohci[0x18];
int dma_channel(std::uint32_t a, std::uint32_t &reg) {
if (a >= 0x1F801080u && a < 0x1F8010F0u) {
@@ -99,12 +101,17 @@ void report(const char *what, std::uint32_t a, std::uint32_t v) {
void start_dma(unsigned ch) {
Dma &d = g_dma[ch];
+ if (kernel::g_trace_modules) std::fprintf(stderr, "[iop-dma] start ch %u madr 0x%08X bcr 0x%08X chcr 0x%08X\n", ch, d.madr, d.bcr, d.chcr);
const std::uint32_t words = (d.bcr & 0xFFFFu) * ((d.bcr >> 16) ? (d.bcr >> 16) : 1u);
if (ch == 4 || ch == 7) {
spu2::dma(ch == 4 ? 0 : 1, d.madr, words, (d.chcr & 1u) != 0);
kernel::schedule(kernel::now() + 64u + words / 4u, [ch]() { dma_done(ch); });
return;
}
+ if (ch == 11 || ch == 12) {
+ sio2::arm_dma(static_cast<int>(ch), d.madr, d.bcr & 0xFFFFu, d.bcr >> 16);
+ return;
+ }
std::fprintf(stderr, "[iop-dma] channel %u start madr 0x%08X bcr 0x%08X chcr 0x%08X (not emulated)\n", ch, d.madr, d.bcr, d.chcr);
dma_done(ch);
}
@@ -118,6 +125,8 @@ void reset() {
std::memset(g_dma, 0, sizeof g_dma);
std::memset(g_scratchpad, 0, sizeof g_scratchpad);
spu2::reset();
+ sio2::reset();
+ std::memset(g_ohci, 0, sizeof g_ohci);
}
void raise_interrupt(unsigned line) {
@@ -128,12 +137,18 @@ void set_interrupt_mask(unsigned line, bool enabled) {
if (line < 32) {
if (enabled) g_imask |= 1u << line;
else g_imask &= ~(1u << line);
- } else if (line < 39) {
+ return;
+ }
+ if (enabled) {
+ g_imask |= 8u;
+ g_dicr |= 0x800000u;
+ }
+ if (line < 39) {
const std::uint32_t bit = 1u << (16 + line - 32);
if (enabled) g_dicr |= bit;
else g_dicr &= ~bit;
- } else if (line < 46) {
- const std::uint32_t bit = 1u << (16 + line - 39);
+ } else if (line >= 40 && line < 46) {
+ const std::uint32_t bit = 1u << (16 + line - 40);
if (enabled) g_dicr2 |= bit;
else g_dicr2 &= ~bit;
}
@@ -146,7 +161,7 @@ int next_pending_interrupt() {
const std::uint32_t flags = (g_dicr >> 24) & (g_dicr >> 16) & 0x7Fu;
if (flags) return 32 + __builtin_ctz(flags);
const std::uint32_t flags2 = (g_dicr2 >> 24) & (g_dicr2 >> 16) & 0x3Fu;
- if (flags2) return 39 + __builtin_ctz(flags2);
+ if (flags2) return 40 + __builtin_ctz(flags2);
g_istat &= ~8u;
}
const std::uint32_t rest = g_istat & g_imask & ~8u;
@@ -159,7 +174,7 @@ void acknowledge_interrupt(unsigned line) {
return;
}
if (line < 39) g_dicr &= ~(1u << (24 + line - 32));
- else g_dicr2 &= ~(1u << (24 + line - 39));
+ else if (line >= 40) g_dicr2 &= ~(1u << (24 + line - 40));
if (!(((g_dicr >> 24) & 0x7Fu) | ((g_dicr2 >> 24) & 0x3Fu))) g_istat &= ~8u;
}
@@ -170,8 +185,30 @@ void dma_done(unsigned ch) {
g_istat |= 8u;
}
+std::uint32_t ohci_read(std::uint32_t a) {
+ const std::uint32_t reg = (a - 0x1F801600u) >> 2;
+ switch (reg) {
+ case 0x00: return 0x110u;
+ case 0x02: return g_ohci[reg] & ~1u;
+ case 0x0E: return static_cast<std::uint32_t>(kernel::now() / 36864u) & 0xFFFFu;
+ case 0x12: return 0x00000202u;
+ default: return reg < 0x18 ? g_ohci[reg] : 0u;
+ }
+}
+
+void ohci_write(std::uint32_t a, std::uint32_t v) {
+ const std::uint32_t reg = (a - 0x1F801600u) >> 2;
+ if (reg >= 0x18) return;
+ if (reg == 0x03) g_ohci[reg] &= ~v;
+ else if (reg == 0x05) g_ohci[0x04] &= ~v;
+ else if (reg == 0x04) g_ohci[reg] |= v;
+ else g_ohci[reg] = v;
+}
+
std::uint32_t read(std::uint32_t a, unsigned size) {
if (a >= 0x1F900000u && a < 0x1F900800u) return spu2::read(a, size);
+ if (a >= 0x1F801600u && a < 0x1F801660u) return ohci_read(a);
+ if (a >= 0x1F808200u && a < 0x1F808280u) return sio2::read(a);
if (a == kIStat) return g_istat;
if (a == kIMask) return g_imask;
if (a == kICtrl) {
@@ -198,6 +235,8 @@ std::uint32_t read(std::uint32_t a, unsigned size) {
void write(std::uint32_t a, std::uint32_t v, unsigned size) {
if (a >= 0x1F900000u && a < 0x1F900800u) { spu2::write(a, v, size); return; }
+ if (a >= 0x1F801600u && a < 0x1F801660u) { ohci_write(a, v); return; }
+ if (a >= 0x1F808200u && a < 0x1F808280u) { sio2::write(a, v); return; }
if (a == kIStat) { g_istat &= v; return; }
if (a == kIMask) { g_imask = v; return; }
if (a == kICtrl) { g_ictrl = v & 1u; return; }
diff --git a/runtime/src/iop/kernel.cpp b/runtime/src/iop/kernel.cpp
index efa2e44..ec5cdcd 100644
--- a/runtime/src/iop/kernel.cpp
+++ b/runtime/src/iop/kernel.cpp
@@ -432,6 +432,7 @@ const std::map<int, Module> &modules() { return g_modules; }
void register_hle_module(const std::string &name, HleModuleStart start) { g_hle_modules[name] = std::move(start); }
void register_interrupt(unsigned line, std::uint32_t handler, std::uint32_t arg, std::uint32_t mode) {
+ if (g_trace_modules) std::fprintf(stderr, "[iop] interrupt %u -> 0x%08X (arg 0x%X)\n", line, handler, arg);
g_interrupts[line] = Interrupt{handler, arg, mode};
}
diff --git a/runtime/src/iop/libs.cpp b/runtime/src/iop/libs.cpp
index 940ba4a..4c0d1d0 100644
--- a/runtime/src/iop/libs.cpp
+++ b/runtime/src/iop/libs.cpp
@@ -885,10 +885,31 @@ void install_timrman() {
def("timrman", 16, "GetHardTimerIntrCode", [](Cpu &c) { c.r[2] = 14; });
}
+std::uint32_t dma_register(std::uint32_t ch, std::uint32_t reg) {
+ return (ch < 7 ? 0x1F801080u + ch * 0x10u : 0x1F801500u + (ch - 7) * 0x10u) + reg * 4u;
+}
+
+std::uint32_t g_dma_direction[16];
+
void install_dmacman() {
register_hle_library("dmacman", 0x0101);
- for (std::uint32_t i : {16u, 17u, 28u, 32u, 33u, 34u, 35u})
- def("dmacman", i, "dmac", [](Cpu &c) { c.r[2] = 0; });
+ def("dmacman", 16, "dmac_set_dpcr2", [](Cpu &c) { c.r[2] = 0; });
+ def("dmacman", 17, "dmac_get_dpcr2", [](Cpu &c) { c.r[2] = 0; });
+ def("dmacman", 28, "sceSetSliceDMA", [](Cpu &c) {
+ const std::uint32_t ch = arg(c, 0) & 15u;
+ write32(dma_register(ch, 0), arg(c, 1));
+ write32(dma_register(ch, 1), (arg(c, 3) << 16) | (arg(c, 2) & 0xFFFFu));
+ g_dma_direction[ch] = arg(c, 4);
+ c.r[2] = 1;
+ });
+ def("dmacman", 32, "sceStartDMA", [](Cpu &c) {
+ const std::uint32_t ch = arg(c, 0) & 15u;
+ write32(dma_register(ch, 2), 0x01000200u | (g_dma_direction[ch] & 1u));
+ c.r[2] = 1;
+ });
+ def("dmacman", 33, "sceSetDMAPriority", [](Cpu &c) { c.r[2] = 1; });
+ def("dmacman", 34, "sceEnableDMAChannel", [](Cpu &c) { c.r[2] = 1; });
+ def("dmacman", 35, "sceDisableDMAChannel", [](Cpu &c) { c.r[2] = 1; });
}
void install_heaplib() {
diff --git a/runtime/src/iop/sio2.cpp b/runtime/src/iop/sio2.cpp
new file mode 100644
index 0000000..729ab1d
--- /dev/null
+++ b/runtime/src/iop/sio2.cpp
@@ -0,0 +1,244 @@
+#include "sio2.hpp"
+
+#include "hw.hpp"
+#include "iop.hpp"
+
+#include <cstring>
+#include <deque>
+#include <vector>
+
+namespace ps2::iop::sio2 {
+
+namespace {
+
+constexpr std::uint8_t kDigital = 0x41, kAnalog = 0x73, kPressure = 0x79, kConfig = 0xF3;
+constexpr std::uint32_t kNoDevice = 0x1D100u;
+
+struct Pad {
+ bool connected = false;
+ std::uint16_t buttons = 0;
+ std::uint8_t axes[4] = {0x80, 0x80, 0x80, 0x80};
+ std::uint8_t mode = kDigital;
+ bool config = false;
+ bool locked = false;
+ std::uint8_t poll_mask[3] = {0xFF, 0xFF, 0x03};
+};
+
+struct Dma {
+ bool armed = false;
+ std::uint32_t madr = 0, block_words = 0, blocks = 0;
+};
+
+std::uint32_t g_send3[16];
+std::uint32_t g_ctrl1[4], g_ctrl2[4];
+std::uint32_t g_index = 0;
+std::uint32_t g_stat = 0;
+std::deque<std::uint8_t> g_in, g_out;
+Pad g_pads[2];
+Dma g_dma[2];
+
+void controller(int port, std::size_t at, std::uint32_t out_size) {
+ if (port > 1 || !g_pads[port].connected) {
+ g_stat = kNoDevice;
+ return;
+ }
+ Pad &p = g_pads[port];
+ const std::vector<std::uint8_t> in(g_in.begin(), g_in.end());
+ const std::uint8_t cmd = in.size() > 1 ? in[1] : 0;
+ auto put = [&](std::size_t i, std::uint8_t v) {
+ if (i < out_size) g_out[at + i] = v;
+ };
+ put(0, 0xFF);
+ put(1, p.config ? kConfig : p.mode);
+ put(2, 0x5A);
+ const std::uint16_t raw = static_cast<std::uint16_t>(~p.buttons);
+ auto data = [&]() {
+ put(3, static_cast<std::uint8_t>(raw >> 8));
+ put(4, static_cast<std::uint8_t>(raw));
+ if (p.mode != kDigital) {
+ put(5, p.axes[0]);
+ put(6, p.axes[1]);
+ put(7, p.axes[2]);
+ put(8, p.axes[3]);
+ }
+ if (p.mode == kPressure) {
+ static const int kBits[12] = {5 + 8, 7 + 8, 4 + 8, 6 + 8, 4, 5, 6, 7, 2, 3, 0, 1};
+ for (int i = 0; i < 12; ++i) put(9 + static_cast<std::size_t>(i), (p.buttons >> kBits[i]) & 1u ? 0xFF : 0x00);
+ }
+ };
+ switch (cmd) {
+ case 0x40:
+ put(3, 0); put(4, 0); put(5, 2); put(6, 0); put(7, 0); put(8, 0x5A);
+ break;
+ case 0x41:
+ if (p.mode == kDigital) for (int i = 3; i < 9; ++i) put(static_cast<std::size_t>(i), 0);
+ else { put(3, p.poll_mask[0]); put(4, p.poll_mask[1]); put(5, p.poll_mask[2]); put(6, 0); put(7, 0); put(8, 0x5A); }
+ break;
+ case 0x42:
+ data();
+ break;
+ case 0x43:
+ if (!p.config) data();
+ else for (int i = 3; i < 9; ++i) put(static_cast<std::size_t>(i), 0);
+ if (in.size() > 3) p.config = in[3] == 1;
+ break;
+ case 0x44:
+ if (in.size() > 4) {
+ p.mode = in[3] ? kAnalog : kDigital;
+ p.locked = in[4] == 3;
+ }
+ for (int i = 3; i < 9; ++i) put(static_cast<std::size_t>(i), 0);
+ break;
+ case 0x45:
+ put(3, 0x03); put(4, 0x02); put(5, p.mode == kDigital ? 0 : 1); put(6, 0x02); put(7, 0x01); put(8, 0x00);
+ break;
+ case 0x46:
+ put(3, 0);
+ if (in.size() > 3 && in[3] == 0) { put(4, 0x00); put(5, 0x01); put(6, 0x02); put(7, 0x00); put(8, 0x0A); }
+ else { put(4, 0x00); put(5, 0x01); put(6, 0x01); put(7, 0x01); put(8, 0x14); }
+ break;
+ case 0x47:
+ put(3, 0); put(4, 0x00); put(5, 0x02); put(6, 0x00); put(7, 0x01); put(8, 0x00);
+ break;
+ case 0x4C:
+ put(3, 0);
+ if (in.size() > 3 && in[3] == 0) { put(4, 0); put(5, 0); put(6, 0x04); put(7, 0); put(8, 0); }
+ else { put(4, 0); put(5, 0); put(6, 0x07); put(7, 0); put(8, 0); }
+ break;
+ case 0x4D:
+ for (int i = 3; i < 9; ++i) put(static_cast<std::size_t>(i), 0xFF);
+ break;
+ case 0x4F:
+ if (in.size() > 5) {
+ p.poll_mask[0] = in[3];
+ p.poll_mask[1] = in[4];
+ p.poll_mask[2] = in[5];
+ }
+ p.mode = kPressure;
+ put(3, 0); put(4, 0); put(5, 0); put(6, 0); put(7, 0); put(8, 0x5A);
+ break;
+ default:
+ data();
+ break;
+ }
+}
+
+void process() {
+ const std::uint32_t reg = g_send3[g_index & 15u];
+ const std::uint32_t in_size = (reg >> 8) & 0x1FFu, out_size = (reg >> 18) & 0x1FFu;
+ if (g_in.size() < in_size) return;
+ const int port = static_cast<int>(reg & 3u);
+ const std::size_t at = g_out.size();
+ for (std::uint32_t i = 0; i < out_size; ++i) g_out.push_back(0xFF);
+ g_stat = 0x1100u;
+ const std::uint32_t device = g_ctrl2[port];
+ if (device == 0x5FFFFu || device == 0x00030064u || port >= 2) g_stat = kNoDevice;
+ else controller(port, at, out_size);
+ g_in.clear();
+ ++g_index;
+}
+
+void run_transfer() {
+ Dma &in = g_dma[0], &out = g_dma[1];
+ if (in.armed) {
+ for (std::uint32_t b = 0; b < in.blocks; ++b) {
+ for (std::uint32_t i = 0; i < in.block_words * 4; ++i) g_in.push_back(read8(in.madr + b * in.block_words * 4 + i));
+ process();
+ }
+ in.armed = false;
+ hw::dma_done(11);
+ }
+ if (out.armed) {
+ for (std::uint32_t b = 0; b < out.blocks && b < 16; ++b) {
+ const std::uint32_t size = (g_send3[b] >> 18) & 0x1FFu;
+ for (std::uint32_t i = 0; i < size && !g_out.empty(); ++i) {
+ write8(out.madr + b * out.block_words * 4 + i, g_out.front());
+ g_out.pop_front();
+ }
+ }
+ out.armed = false;
+ hw::dma_done(12);
+ }
+ hw::raise_interrupt(17);
+}
+
+}
+
+void reset() {
+ std::memset(g_send3, 0, sizeof g_send3);
+ std::memset(g_ctrl1, 0, sizeof g_ctrl1);
+ std::memset(g_ctrl2, 0, sizeof g_ctrl2);
+ g_index = 0;
+ g_stat = 0;
+ g_in.clear();
+ g_out.clear();
+ g_pads[0] = Pad{};
+ g_pads[1] = Pad{};
+ g_pads[0].connected = true;
+ g_dma[0] = g_dma[1] = Dma{};
+}
+
+std::uint32_t read(std::uint32_t a) {
+ if (a >= 0x1F808200u && a < 0x1F808240u) return g_send3[(a - 0x1F808200u) / 4];
+ if (a >= 0x1F808240u && a < 0x1F808260u) {
+ const std::uint32_t port = (a - 0x1F808240u) / 8;
+ return (a & 4u) ? g_ctrl2[port] : g_ctrl1[port];
+ }
+ switch (a) {
+ case 0x1F808264u: {
+ if (g_out.empty()) return 0xFF;
+ const std::uint8_t v = g_out.front();
+ g_out.pop_front();
+ return v;
+ }
+ case 0x1F808268u: return 0;
+ case 0x1F80826Cu: return g_stat;
+ case 0x1F808270u: return 0xF;
+ case 0x1F808274u: return 0;
+ default: return 0;
+ }
+}
+
+void write(std::uint32_t a, std::uint32_t v) {
+ if (a >= 0x1F808200u && a < 0x1F808240u) { g_send3[(a - 0x1F808200u) / 4] = v; return; }
+ if (a >= 0x1F808240u && a < 0x1F808260u) {
+ const std::uint32_t port = (a - 0x1F808240u) / 8;
+ if (a & 4u) g_ctrl2[port] = v;
+ else g_ctrl1[port] = v;
+ return;
+ }
+ switch (a) {
+ case 0x1F808260u:
+ g_in.push_back(static_cast<std::uint8_t>(v));
+ process();
+ break;
+ case 0x1F808268u:
+ if ((v & 0xCu) == 0xCu) {
+ g_index = 0;
+ g_in.clear();
+ g_out.clear();
+ }
+ if (v & 1u) run_transfer();
+ break;
+ default:
+ break;
+ }
+}
+
+void arm_dma(int channel, std::uint32_t madr, std::uint32_t block_words, std::uint32_t blocks) {
+ Dma &d = g_dma[channel == 11 ? 0 : 1];
+ d.armed = true;
+ d.madr = madr;
+ d.block_words = block_words;
+ d.blocks = blocks;
+}
+
+void set_buttons(int pad, std::uint16_t pressed_mask) {
+ if (pad >= 0 && pad < 2) g_pads[pad].buttons = pressed_mask;
+}
+
+void set_axis(int pad, int axis, std::uint8_t value) {
+ if (pad >= 0 && pad < 2 && axis >= 0 && axis < 4) g_pads[pad].axes[axis] = value;
+}
+
+}
diff --git a/runtime/src/iop/sio2.hpp b/runtime/src/iop/sio2.hpp
new file mode 100644
index 0000000..f752281
--- /dev/null
+++ b/runtime/src/iop/sio2.hpp
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <cstdint>
+
+namespace ps2::iop::sio2 {
+
+void reset();
+std::uint32_t read(std::uint32_t a);
+void write(std::uint32_t a, std::uint32_t v);
+void arm_dma(int channel, std::uint32_t madr, std::uint32_t block_words, std::uint32_t blocks);
+void set_buttons(int pad, std::uint16_t pressed_mask);
+void set_axis(int pad, int axis, std::uint8_t value);
+
+}