[pcsx_rearmed.git] / libpcsxcore / lightrec / mem_wiiu.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (C) 2022 Ash Logan <ash@heyquark.com>
 */

#include <coreinit/memorymap.h>
#include <malloc.h>
#include <stdbool.h>

#include "../memmap.h"
#include "../psxhw.h"
#include "../psxmem.h"
#include "../r3000a.h"

#include "mem.h"

void wiiu_clear_cache(void *start, void *end);

static void* wiiu_mmap(uint32_t requested_va, size_t length, void* backing_mem) {
	if (length < OS_PAGE_SIZE) length = OS_PAGE_SIZE;

	uint32_t va = OSAllocVirtAddr(requested_va, length, 0);
	if (!va) return MAP_FAILED;

	BOOL mapped = OSMapMemory(va, OSEffectiveToPhysical((uint32_t)backing_mem),
	                          length, OS_MAP_MEMORY_READ_WRITE);
	if (!mapped) {
		OSFreeVirtAddr(va, length);
		return MAP_FAILED;
	}

	return (void*)va;
}

static void wiiu_unmap(void* va, size_t length) {
	if (va == MAP_FAILED) return;
	OSUnmapMemory((uint32_t)va, length);
	OSFreeVirtAddr((uint32_t)va, length);
}

static void* psx_mem;
static void* psx_parallel;
static void* psx_scratch;
static void* psx_bios;

int lightrec_init_mmap(void) {
	psx_mem      = memalign(OS_PAGE_SIZE, 0x200000);
	psx_parallel = memalign(OS_PAGE_SIZE, 0x10000);
	psx_scratch  = memalign(OS_PAGE_SIZE, 0x10000);
	psx_bios     = memalign(OS_PAGE_SIZE, 0x80000);
	if (!psx_mem || !psx_parallel || !psx_scratch || !psx_bios)
		goto cleanup_allocations;

	uint32_t avail_va;
	uint32_t avail_va_size;
	OSGetMapVirtAddrRange(&avail_va, &avail_va_size);
	if (!avail_va || avail_va_size < 0x20000000)
		goto cleanup_allocations;

	// Map 4x ram mirrors
	int i;
	for (i = 0; i < 4; i++) {
		void* ret = wiiu_mmap(avail_va + 0x200000 * i, 0x200000, psx_mem);
		if (ret == MAP_FAILED) break;
	}
	if (i != 4) {
		for (int i = 0; i < 4; i++)
			wiiu_unmap(avail_va + 0x200000 * i, 0x200000);
		goto cleanup_allocations;
	}
	psxM = (void*)avail_va;

	psxP = wiiu_mmap(avail_va + 0x1f000000, 0x10000, psx_parallel);
	psxH = wiiu_mmap(avail_va + 0x1f800000, 0x10000, psx_scratch);
	psxR = wiiu_mmap(avail_va + 0x1fc00000, 0x80000, psx_bios);

	if (psxP == MAP_FAILED || psxH == MAP_FAILED || psxR == MAP_FAILED) {
		for (int i = 0; i < 4; i++)
			wiiu_unmap(psxM + 0x200000 * i, 0x200000);
		wiiu_unmap(psxP, 0x10000);
		wiiu_unmap(psxH, 0x10000);
		wiiu_unmap(psxR, 0x80000);
		goto cleanup_allocations;
	}

	code_buffer = WUP_RWX_MEM_BASE;

	return 0;

cleanup_allocations:
	free(psx_mem);
	free(psx_parallel);
	free(psx_scratch);
	free(psx_bios);
	return -1;
}

void lightrec_free_mmap(void) {
	for (int i = 0; i < 4; i++)
		wiiu_unmap(psxM + 0x200000 * i, 0x200000);
	wiiu_unmap(psxP, 0x10000);
	wiiu_unmap(psxH, 0x10000);
	wiiu_unmap(psxR, 0x80000);
	free(psx_mem);
	free(psx_parallel);
	free(psx_scratch);
	free(psx_bios);
}

void lightrec_code_inv(void *ptr, uint32_t len)
{
	wiiu_clear_cache(ptr, (void *)((uintptr_t)ptr + len));
}
Commit	Line	Data
	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*
	3	* Copyright (C) 2022 Ash Logan <ash@heyquark.com>
	4	*/
	5
	6	#include <coreinit/memorymap.h>
	7	#include <malloc.h>
	8	#include <stdbool.h>
	9
	10	#include "../memmap.h"
	11	#include "../psxhw.h"
	12	#include "../psxmem.h"
	13	#include "../r3000a.h"
	14
	15	#include "mem.h"
	16
	17	void wiiu_clear_cache(void start, void end);
	18
	19	static void* wiiu_mmap(uint32_t requested_va, size_t length, void* backing_mem) {
	20	if (length < OS_PAGE_SIZE) length = OS_PAGE_SIZE;
	21
	22	uint32_t va = OSAllocVirtAddr(requested_va, length, 0);
	23	if (!va) return MAP_FAILED;
	24
	25	BOOL mapped = OSMapMemory(va, OSEffectiveToPhysical((uint32_t)backing_mem),
	26	length, OS_MAP_MEMORY_READ_WRITE);
	27	if (!mapped) {
	28	OSFreeVirtAddr(va, length);
	29	return MAP_FAILED;
	30	}
	31
	32	return (void*)va;
	33	}
	34
	35	static void wiiu_unmap(void* va, size_t length) {
	36	if (va == MAP_FAILED) return;
	37	OSUnmapMemory((uint32_t)va, length);
	38	OSFreeVirtAddr((uint32_t)va, length);
	39	}
	40
	41	static void* psx_mem;
	42	static void* psx_parallel;
	43	static void* psx_scratch;
	44	static void* psx_bios;
	45
	46	int lightrec_init_mmap(void) {
	47	psx_mem = memalign(OS_PAGE_SIZE, 0x200000);
	48	psx_parallel = memalign(OS_PAGE_SIZE, 0x10000);
	49	psx_scratch = memalign(OS_PAGE_SIZE, 0x10000);
	50	psx_bios = memalign(OS_PAGE_SIZE, 0x80000);
	51	if (!psx_mem \|\| !psx_parallel \|\| !psx_scratch \|\| !psx_bios)
	52	goto cleanup_allocations;
	53
	54	uint32_t avail_va;
	55	uint32_t avail_va_size;
	56	OSGetMapVirtAddrRange(&avail_va, &avail_va_size);
	57	if (!avail_va \|\| avail_va_size < 0x20000000)
	58	goto cleanup_allocations;
	59
	60	// Map 4x ram mirrors
	61	int i;
	62	for (i = 0; i < 4; i++) {
	63	void* ret = wiiu_mmap(avail_va + 0x200000 * i, 0x200000, psx_mem);
	64	if (ret == MAP_FAILED) break;
	65	}
	66	if (i != 4) {
	67	for (int i = 0; i < 4; i++)
	68	wiiu_unmap(avail_va + 0x200000 * i, 0x200000);
	69	goto cleanup_allocations;
	70	}
	71	psxM = (void*)avail_va;
	72
	73	psxP = wiiu_mmap(avail_va + 0x1f000000, 0x10000, psx_parallel);
	74	psxH = wiiu_mmap(avail_va + 0x1f800000, 0x10000, psx_scratch);
	75	psxR = wiiu_mmap(avail_va + 0x1fc00000, 0x80000, psx_bios);
	76
	77	if (psxP == MAP_FAILED \|\| psxH == MAP_FAILED \|\| psxR == MAP_FAILED) {
	78	for (int i = 0; i < 4; i++)
	79	wiiu_unmap(psxM + 0x200000 * i, 0x200000);
	80	wiiu_unmap(psxP, 0x10000);
	81	wiiu_unmap(psxH, 0x10000);
	82	wiiu_unmap(psxR, 0x80000);
	83	goto cleanup_allocations;
	84	}
	85
	86	code_buffer = WUP_RWX_MEM_BASE;
	87
	88	return 0;
	89
	90	cleanup_allocations:
	91	free(psx_mem);
	92	free(psx_parallel);
	93	free(psx_scratch);
	94	free(psx_bios);
	95	return -1;
	96	}
	97
	98	void lightrec_free_mmap(void) {
	99	for (int i = 0; i < 4; i++)
	100	wiiu_unmap(psxM + 0x200000 * i, 0x200000);
	101	wiiu_unmap(psxP, 0x10000);
	102	wiiu_unmap(psxH, 0x10000);
	103	wiiu_unmap(psxR, 0x80000);
	104	free(psx_mem);
	105	free(psx_parallel);
	106	free(psx_scratch);
	107	free(psx_bios);
	108	}
	109
	110	void lightrec_code_inv(void *ptr, uint32_t len)
	111	{
	112	wiiu_clear_cache(ptr, (void *)((uintptr_t)ptr + len));
	113	}