Skip to content

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

C++
7.1 KB
Raw Blame
#include "kernel.hpp"
#include "sif.hpp"

#include "ps2/disc.hpp"
#include "ps2/memory.hpp"

#include "ps2/state.hpp"

#include <cstdio>
#include <ctime>
#include <vector>

namespace ps2::iop::kernel {

namespace {

std::uint32_t ee32(std::uint32_t a) { return load<std::uint32_t>(ps2::g_ram + (a & (ps2::kRamSize - 1))); }
void set_ee32(std::uint32_t a, std::uint32_t v) { store<std::uint32_t>(ps2::g_ram + (a & (ps2::kRamSize - 1)), v); }

std::uint8_t bcd(int v) { return static_cast<std::uint8_t>(((v / 10) << 4) | (v % 10)); }

bool g_streaming = false;
std::uint32_t g_stream_pos = 0;

std::uint64_t delay(std::uint32_t sectors) { return usec_to_cycles(400) + static_cast<std::uint64_t>(sectors) * usec_to_cycles(200); }

void read_to_ee(std::uint32_t sector, std::uint32_t count, std::uint32_t dst) {
    std::vector<std::uint8_t> data(static_cast<std::size_t>(count) * disc::kSector);
    disc::read(sector, count, data.data());
    const std::uint32_t at = dst & (ps2::kRamSize - 1);
    std::memcpy(ps2::g_ram + at, data.data(), std::min<std::size_t>(data.size(), ps2::kRamSize - at));
    ps2::watch_span(at, static_cast<std::uint32_t>(std::min<std::size_t>(data.size(), ps2::kRamSize - at)), "cdvd:read");
}

}

void install_cdvdfsv() {
    g_streaming = false;
    g_stream_pos = 0;
    register_job(kJobFsvRead, [](const Job &j) {
        if (g_trace_hle) std::fprintf(stderr, "[cdvdfsv] stream write lsn %u count %u to 0x%08X\n", j.a, j.b, j.c);
        if (!disc::ready(j.a, j.b)) {
            schedule(now() + usec_to_cycles(1000), j);
            return;
        }
        read_to_ee(j.a, j.b, j.c);
        sif::complete_call(0x80000595u);
    });
    register_job(kJobFsvComplete, [](const Job &) { sif::complete_call(0x80000595u); });
    register_job(kJobFsvIopRead, [](const Job &j) {
        if (!disc::ready(j.a, j.b)) {
            schedule(now() + usec_to_cycles(1000), j);
            return;
        }
        std::vector<std::uint8_t> data(static_cast<std::size_t>(j.b) * disc::kSector);
        disc::read(j.a, j.b, data.data());
        for (std::size_t i = 0; i < data.size(); ++i) write8(j.c + static_cast<std::uint32_t>(i), data[i]);
        sif::complete_call(0x80000595u);
    });
    sif::register_hle_server(0x80000592u, [](std::uint32_t, std::uint32_t, std::uint32_t, std::uint32_t ret, std::uint32_t ret_size) {
        if (ret_size >= 16) set_ee32(ret + 12, 0xFF);
        return true;
    });
    sif::register_hle_server(0x80000593u, [](std::uint32_t method, std::uint32_t args, std::uint32_t, std::uint32_t ret, std::uint32_t ret_size) {
        switch (method) {
        case 0x01: {
            const std::time_t t = std::time(nullptr);
            const std::tm *tm = std::gmtime(&t);
            set_ee32(ret, 1);
            std::uint8_t *clock = ps2::g_ram + ret + 4;
            clock[0] = 0;
            clock[1] = bcd(tm->tm_sec);
            clock[2] = bcd(tm->tm_min);
            clock[3] = bcd((tm->tm_hour + 9) % 24);
            clock[4] = 0;
            clock[5] = bcd(tm->tm_mday);
            clock[6] = bcd(tm->tm_mon + 1);
            clock[7] = bcd(tm->tm_year % 100);
            break;
        }
        case 0x03: set_ee32(ret, 0x14); break;
        case 0x04: set_ee32(ret, 0); break;
        case 0x05: set_ee32(ret, 1); set_ee32(ret + 4, 0); break;
        case 0x0C: set_ee32(ret, g_streaming ? 0x12u : 0x0Au); break;
        case 0x16: set_ee32(ret, 1); break;
        case 0x22: set_ee32(ret, 1); break;
        case 0x27:
            set_ee32(ret, 1);
            set_ee32(ret + 4, disc::layer1_start() ? 1u : 0u);
            if (ret_size >= 12) set_ee32(ret + 8, disc::layer1_start());
            break;
        default:
            std::fprintf(stderr, "[cdvdfsv] S command 0x%X\n", method);
            set_ee32(ret, 1);
            break;
        }
        (void)args;
        return true;
    });
    sif::register_hle_server(0x80000595u, [](std::uint32_t method, std::uint32_t args, std::uint32_t, std::uint32_t ret, std::uint32_t ret_size) {
        const std::uint32_t sector = ee32(args), count = ee32(args + 4), dst = ee32(args + 8);
        if (g_trace_hle) std::fprintf(stderr, "[cdvdfsv] N 0x%X sector %u count %u to 0x%08X\n", method, sector, count, dst);
        switch (method) {
        case 0x01:
            if (ret_size >= 4) set_ee32(ret, 0);
            disc::ready(sector, count);
            schedule(now() + delay(count), Job{kJobFsvRead, sector, count, dst});
            return false;
        case 0x04: set_ee32(ret, 1); return true;
        case 0x05: return true;
        case 0x08:
            schedule(now() + delay(0), Job{kJobFsvComplete});
            return false;
        case 0x09: {
            const std::uint32_t cmd = ee32(args + 12);
            if (g_trace_hle) std::fprintf(stderr, "[cdvdfsv] stream cmd %u (pos %u)\n", cmd, g_stream_pos);
            switch (cmd) {
            case 1: g_stream_pos = sector; g_streaming = true; set_ee32(ret, 1); return true;
            case 2: {
                const std::uint32_t pos = g_stream_pos;
                g_stream_pos += count;
                set_ee32(ret, count);
                disc::ready(pos, count);
                schedule(now() + delay(count), Job{kJobFsvRead, pos, count, dst});
                return false;
            }
            case 3: g_streaming = false; set_ee32(ret, 1); return true;
            case 4: case 9: g_stream_pos = sector; set_ee32(ret, 1); return true;
            case 5: set_ee32(ret, 1); return true;
            case 6: set_ee32(ret, sector); return true;
            default: set_ee32(ret, 1); return true;
            }
        }
        case 0x0D:
            if (ret_size >= 4) set_ee32(ret, 0);
            disc::ready(sector, count);
            schedule(now() + delay(count), Job{kJobFsvIopRead, sector, count, dst});
            return false;
        case 0x0E: set_ee32(ret, 2); return true;
        default:
            std::fprintf(stderr, "[cdvdfsv] N command 0x%X\n", method);
            set_ee32(ret, 1);
            return true;
        }
    });
    sif::register_hle_server(0x80000596u, [](std::uint32_t method, std::uint32_t, std::uint32_t, std::uint32_t, std::uint32_t) {
        return method != 0x01;
    });
    sif::register_hle_server(0x80000597u, [](std::uint32_t, std::uint32_t args, std::uint32_t size, std::uint32_t ret, std::uint32_t) {
        const std::uint32_t offset = size == 0x124 ? 0x20u : 0x24u;
        const std::string path(reinterpret_cast<const char *>(ps2::g_ram + (args & (ps2::kRamSize - 1)) + offset));
        const auto entry = disc::find(path);
        if (entry) {
            set_ee32(args, entry->sector);
            set_ee32(args + 4, entry->size);
        }
        std::fprintf(stderr, "[cdvdfsv] search %s -> %s\n", path.c_str(), entry ? "found" : "missing");
        set_ee32(ret, entry ? 1u : 0u);
        return true;
    });
    const auto ready = [](std::uint32_t, std::uint32_t, std::uint32_t, std::uint32_t ret, std::uint32_t) {
        set_ee32(ret, 2);
        return true;
    };
    sif::register_hle_server(0x8000059Au, ready);
    sif::register_hle_server(0x8000059Cu, ready);
}

}

namespace ps2::iop::kernel {

void cdvdfsv_state(ps2::state::Stream &s) {
    s.tag("cdvdfsv");
    s.pod(g_streaming);
    s.pod(g_stream_pos);
}

}