/*
 * Copyright 2022 Haiku, Inc. All rights reserved.
 * Released under the terms of the MIT License.
 */

#include "generic_mmu.h"

#include <algorithm>
#include <boot/stage2.h>


void
build_physical_memory_list(size_t memoryMapSize, efi_memory_descriptor* memoryMap,
	size_t descriptorSize, uint32_t descriptorVersion,
	uint64_t physicalMemoryLow, uint64_t physicalMemoryHigh)
{
	addr_t addr = (addr_t)memoryMap;

	gKernelArgs.num_physical_memory_ranges = 0;

	// First scan: Add all usable ranges
	for (size_t i = 0; i < memoryMapSize / descriptorSize; ++i) {
		efi_memory_descriptor* entry = (efi_memory_descriptor *)(addr + i * descriptorSize);
		switch (entry->Type) {
			case EfiLoaderCode:
			case EfiLoaderData:
			case EfiBootServicesCode:
			case EfiBootServicesData:
			case EfiConventionalMemory: {
				uint64_t base = entry->PhysicalStart;
				uint64_t end = entry->PhysicalStart + entry->NumberOfPages * B_PAGE_SIZE;
				uint64_t originalSize = end - base;
				base = std::max(base, physicalMemoryLow);
				end = std::min(end, physicalMemoryHigh);

				gKernelArgs.ignored_physical_memory
					+= originalSize - (max_c(end, base) - base);

				if (base >= end)
					break;
				uint64_t size = end - base;

				insert_physical_memory_range(base, size);
				break;
			}
			default:
				break;
		}
	}

	uint64_t initialPhysicalMemory = total_physical_memory();

	// Second scan: Remove everything reserved that may overlap
	for (size_t i = 0; i < memoryMapSize / descriptorSize; ++i) {
		efi_memory_descriptor* entry = (efi_memory_descriptor *)(addr + i * descriptorSize);
		switch (entry->Type) {
			case EfiLoaderCode:
			case EfiLoaderData:
			case EfiBootServicesCode:
			case EfiBootServicesData:
			case EfiConventionalMemory:
				break;
			default:
				uint64_t base = entry->PhysicalStart;
				uint64_t size = entry->NumberOfPages * B_PAGE_SIZE;
				remove_physical_memory_range(base, size);
		}
	}

	gKernelArgs.ignored_physical_memory
		+= initialPhysicalMemory - total_physical_memory();

	sort_address_ranges(gKernelArgs.physical_memory_range,
		gKernelArgs.num_physical_memory_ranges);
}


void
build_physical_allocated_list(size_t memoryMapSize, efi_memory_descriptor* memoryMap,
	size_t descriptorSize, uint32_t descriptorVersion)
{
	gKernelArgs.num_physical_allocated_ranges = 0;

	addr_t addr = (addr_t)memoryMap;
	for (size_t i = 0; i < memoryMapSize / descriptorSize; ++i) {
		efi_memory_descriptor* entry = (efi_memory_descriptor *)(addr + i * descriptorSize);
		switch (entry->Type) {
			case EfiLoaderData: {
				uint64_t base = entry->PhysicalStart;
				uint64_t size = entry->NumberOfPages * B_PAGE_SIZE;
				insert_physical_allocated_range(base, size);
				break;
			}
			default:
				;
		}
	}

	sort_address_ranges(gKernelArgs.physical_allocated_range,
		gKernelArgs.num_physical_allocated_ranges);
}


const char*
memory_region_type_str(int type)
{
	switch (type)	{
		case EfiReservedMemoryType:
			return "EfiReservedMemoryType";
		case EfiLoaderCode:
			return "EfiLoaderCode";
		case EfiLoaderData:
			return "EfiLoaderData";
		case EfiBootServicesCode:
			return "EfiBootServicesCode";
		case EfiBootServicesData:
			return "EfiBootServicesData";
		case EfiRuntimeServicesCode:
			return "EfiRuntimeServicesCode";
		case EfiRuntimeServicesData:
			return "EfiRuntimeServicesData";
		case EfiConventionalMemory:
			return "EfiConventionalMemory";
		case EfiUnusableMemory:
			return "EfiUnusableMemory";
		case EfiACPIReclaimMemory:
			return "EfiACPIReclaimMemory";
		case EfiACPIMemoryNVS:
			return "EfiACPIMemoryNVS";
		case EfiMemoryMappedIO:
			return "EfiMemoryMappedIO";
		case EfiMemoryMappedIOPortSpace:
			return "EfiMemoryMappedIOPortSpace";
		case EfiPalCode:
			return "EfiPalCode";
		case EfiPersistentMemory:
			return "EfiPersistentMemory";
		default:
			return "unknown";
	}
}