android13/u-boot/arch/arm/mach-rockchip/rk_mini_dump.c

/*
 * (C) Copyright 2023 Rockchip Electronics Co., Ltd.
 *
 * SPDX-License-Identifier:     GPL-2.0+
 */

#include <common.h>
#include <linux/types.h>
#include <asm/io.h>
#include <rk_mini_dump.h>

/* don't modify it, it is behind pstore memory space */
#ifdef CONFIG_ROCKCHIP_MINIDUMP_SMEM_BASE
#define SMEM_BASE		CONFIG_ROCKCHIP_MINIDUMP_SMEM_BASE
#else
#define SMEM_BASE		0x1f0000
#endif

#ifdef CONFIG_ROCKCHIP_MINIDUMP_MAX_ELF_SIZE
#define MAX_ELF_SIZE		CONFIG_ROCKCHIP_MINIDUMP_MAX_ELF_SIZE
#else
#define MAX_ELF_SIZE		0x2000000
#endif

#ifdef CONFIG_ROCKCHIP_MINIDUMP_MAX_ENTRIES
#define MAX_NUM_ENTRIES		(CONFIG_ROCKCHIP_MINIDUMP_MAX_ENTRIES + 1)
#else
#define MAX_NUM_ENTRIES		129
#endif

/* Bootloader has 16 byte support, 4 bytes reserved for itself */
#define MAX_REGION_NAME_LENGTH	16
#define MAX_STRTBL_SIZE		(MAX_NUM_ENTRIES * MAX_REGION_NAME_LENGTH)

/**
 * md_table : Local Minidump toc holder
 * @num_regions : Number of regions requested
 * @md_ss_toc  : HLOS toc pointer
 * @md_gbl_toc : Global toc pointer
 * @md_regions : HLOS regions base pointer
 * @entry : array of HLOS regions requested
 */
struct md_table {
	u32			revision;
	u32                     num_regions;
	struct md_ss_toc	*md_ss_toc;
	struct md_global_toc	*md_gbl_toc;
	struct md_ss_region	*md_regions;
	struct md_region	entry[MAX_NUM_ENTRIES];
};

#define MAX_NUM_OF_SS		2

/**
 * md_ss_toc: Sub system SMEM Table of content
 * @md_ss_toc_init : SS toc init status
 * @md_ss_enable_status : if set to 1, Bootloader would dump this SS regions
 * @encryption_status: Encryption status for this subsystem
 * @encryption_required : Decides to encrypt the SS regions or not
 * @ss_region_count : Number of regions added in this SS toc
 * @md_ss_smem_regions_baseptr : regions base pointer of the Subsystem
 * @elf_header : base pointer of the minidump elf header
 * @minidump_table : base pointer of the minidump_table
 */
struct md_ss_toc {
	u32			md_ss_toc_init;
	u32			md_ss_enable_status;
	u32			encryption_status;
	u32			encryption_required;
	u32			ss_region_count;
	u64			md_ss_smem_regions_baseptr;
	u64			elf_header;
	u64			elf_size;
	u64			minidump_table;
};

/**
 * md_global_toc: Global Table of Content
 * @md_toc_init : Global Minidump init status
 * @md_revision : Minidump revision
 * @md_enable_status : Minidump enable status
 * @md_ss_toc : Array of subsystems toc
 */
struct md_global_toc {
	u32			md_toc_init;
	u32			md_revision;
	u32			md_enable_status;
	struct md_ss_toc	md_ss_toc[MAX_NUM_OF_SS];
};

/* Bootloader has 16 byte support, 4 bytes reserved for itself */
#define MAX_REGION_NAME_LENGTH	16

#define MD_REGION_VALID		('V' << 24 | 'A' << 16 | 'L' << 8 | 'I' << 0)
#define MD_REGION_INVALID	('I' << 24 | 'N' << 16 | 'V' << 8 | 'A' << 0)
#define MD_REGION_INIT		('I' << 24 | 'N' << 16 | 'I' << 8 | 'T' << 0)
#define MD_REGION_NOINIT	0

#define MD_SS_ENCR_REQ		(0 << 24 | 'Y' << 16 | 'E' << 8 | 'S' << 0)
#define MD_SS_ENCR_NOTREQ	(0 << 24 | 0 << 16 | 'N' << 8 | 'R' << 0)
#define MD_SS_ENCR_NONE		('N' << 24 | 'O' << 16 | 'N' << 8 | 'E' << 0)
#define MD_SS_ENCR_DONE		('D' << 24 | 'O' << 16 | 'N' << 8 | 'E' << 0)
#define MD_SS_ENCR_START	('S' << 24 | 'T' << 16 | 'R' << 8 | 'T' << 0)
#define MD_SS_ENABLED		('E' << 24 | 'N' << 16 | 'B' << 8 | 'L' << 0)
#define MD_SS_DISABLED		('D' << 24 | 'S' << 16 | 'B' << 8 | 'L' << 0)

#define EM_AARCH64	183	/* ARM 64 bit */

/**
 * md_ss_region - Minidump region
 * @name		: Name of the region to be dumped
 * @seq_num:		: Use to differentiate regions with same name.
 * @md_valid		: This entry to be dumped (if set to 1)
 * @region_base_address	: Physical address of region to be dumped
 * @region_size		: Size of the region
 */
struct md_ss_region {
	char	name[MAX_REGION_NAME_LENGTH];
	u32	seq_num;
	u32	md_valid;
	u64	region_base_address;
	u64	region_size;
};

#define NO_FAULT_TAG 0x55aa55aa
static u32 no_fault;
static struct md_table *minidump_table;

u32 md_no_fault_handler(struct pt_regs *pt_regs, unsigned int esr)
{
	if (no_fault == NO_FAULT_TAG) {
		no_fault = 0;
		return 1;
	}
	return 0;
}

#if defined(CONFIG_ROCKCHIP_RK3588)
static u32 md_is_ddr_addr(void *addr)
{
	/* peripheral address space */
	if (addr >= (void *)0xf0000000 && addr <= (void *)0x100000000)
		return 0;
	/* pcie address space */
	if (addr > (void *)0x800000000)
		return 0;
	return 1;
}
#else
static u32 md_is_ddr_addr(void *addr)
{
	return 1;
}
#endif

static u32 md_is_uboot_addr(void *addr)
{
	volatile u32 *p_no_fault = &no_fault;

	if(!md_is_ddr_addr(addr))
		return 0;

	*p_no_fault = NO_FAULT_TAG;
	readb(addr);
	return *p_no_fault;
}

struct md_region *md_get_region(char *name)
{
	struct md_region *mdr;
	int i, regno;

	if (!md_is_uboot_addr((void *)minidump_table))
		return NULL;

	regno = minidump_table->num_regions;
	for (i = 0; i < regno; i++) {
		mdr = &minidump_table->entry[i];
		if (!strcmp(mdr->name, name))
			return mdr;
	}
	return NULL;
}

#ifdef CONFIG_ARM64
static Elf64_Xword rk_dump_elf64_image_phdr(void *ram_image,
					    Elf64_Addr ehaddr, Elf64_Xword ehsize)
{
	Elf64_Ehdr *ehdr = (Elf64_Ehdr *)ehaddr;
	Elf64_Phdr *phdr = NULL, *phdr_next = NULL;
	Elf64_Shdr *shdr = NULL, *shdr_next = NULL;
	unsigned int i = 0, error = 0, phdr_off = 0, strtbl_off = 0;
	unsigned int size = 0, elf_size = ehsize;

	if (!md_is_uboot_addr((void *)ehdr))
		return 0;

	if (!md_is_uboot_addr((void *)ram_image) ||
	    !md_is_uboot_addr((void *)ram_image + MAX_ELF_SIZE - 4))
		return 0;

	memcpy(ehdr->e_ident, ELFMAG, SELFMAG);
	ehdr->e_ident[EI_CLASS] = ELFCLASS64;
	ehdr->e_ident[EI_DATA] = ELFDATA2LSB;
	ehdr->e_ident[EI_VERSION] = EV_CURRENT;
	ehdr->e_ident[EI_OSABI] = ELFOSABI_NONE;

	if (ehdr->e_type != ET_CORE) {
		error++;
		ehdr->e_type = ET_CORE;
	}
	if (ehdr->e_machine != EM_AARCH64) {
		error++;
		ehdr->e_machine = EM_AARCH64;
	}
	if (ehdr->e_version != EV_CURRENT) {
		error++;
		ehdr->e_version = EV_CURRENT;
	}
	if (ehdr->e_ehsize != sizeof(*ehdr)) {
		error++;
		ehdr->e_ehsize = sizeof(*ehdr);
	}
	if (ehdr->e_phentsize != sizeof(*phdr)) {
		error++;
		ehdr->e_phentsize = sizeof(*phdr);
	}
	if (ehdr->e_shentsize != sizeof(*shdr)) {
		error++;
		ehdr->e_shentsize = sizeof(*shdr);
	}
	if (ehdr->e_shoff != sizeof(*ehdr)) {
		error++;
		ehdr->e_shoff = sizeof(*ehdr);
	}

	phdr_off = sizeof(*ehdr) + (sizeof(*shdr) * MAX_NUM_ENTRIES);

	if (ehdr->e_phoff != phdr_off) {
		error++;
		ehdr->e_phoff = phdr_off;
	}

	printf("Minidump header error:0x%x\n", error);
	/* If there are much error, maybe ehdr address is wrong */
	if (error > 6)
		return 0;

	ehdr->e_shstrndx = 1;
	phdr = (Elf64_Phdr *)(ehaddr + ehdr->e_phoff);
	shdr = (Elf64_Shdr *)(ehaddr + ehdr->e_shoff);

	shdr->sh_name = 0;
	shdr->sh_type = 0;
	shdr->sh_flags = 0;
	shdr->sh_addr = 0;
	shdr->sh_offset = 0;
	shdr->sh_size = 0;
	shdr->sh_link = 0;
	shdr->sh_info = 0;
	shdr->sh_addralign = 0;
	shdr->sh_entsize = 0;

	shdr++;
	if (shdr->sh_name >= MAX_STRTBL_SIZE)
		shdr->sh_name = 0;
	shdr->sh_type = SHT_STRTAB;
	shdr->sh_flags = 0;
	shdr->sh_addr = 0;
	shdr->sh_offset = phdr_off + (sizeof(*phdr) * MAX_NUM_ENTRIES);
	shdr->sh_size = MAX_STRTBL_SIZE;
	shdr->sh_link = 0;
	shdr->sh_info = 0;
	shdr->sh_addralign = 0;
	shdr->sh_entsize = 0;

	shdr++;
	/* 3rd section is for minidump_table VA, used by parsers */
	if (shdr->sh_name >= MAX_STRTBL_SIZE)
		shdr->sh_name = 0;
	shdr->sh_type = SHT_PROGBITS;
	shdr->sh_flags = 0;
	shdr->sh_offset = 0;
	shdr->sh_size = 0;
	shdr->sh_link = 0;
	shdr->sh_info = 0;
	shdr->sh_addralign = 0;
	shdr->sh_entsize = 0;

	shdr++;
	shdr->sh_flags = 0;
	shdr->sh_link = 0;
	shdr->sh_info = 0;
	shdr->sh_addralign = 0;
	shdr->sh_entsize = 0;

	strtbl_off = phdr_off + (sizeof(*phdr) * MAX_NUM_ENTRIES);
	strtbl_off += MAX_STRTBL_SIZE;

	if (phdr->p_offset != strtbl_off)
		phdr->p_offset = strtbl_off;
	if (shdr->sh_offset != strtbl_off)
		shdr->sh_offset = strtbl_off;

	phdr->p_filesz &= GENMASK(23, 0);	/* 16MB */
	phdr->p_memsz &= GENMASK(23, 0);	/* 16MB */
	shdr->sh_size &= GENMASK(23, 0);	/* 16MB */

	if (phdr->p_filesz == phdr->p_memsz) {
		size = phdr->p_filesz;
		shdr->sh_size = size;
	} else if (phdr->p_filesz == shdr->sh_size) {
		size = phdr->p_filesz;
		phdr->p_memsz = size;
	} else if (phdr->p_memsz == shdr->sh_size) {
		size = phdr->p_memsz;
		phdr->p_filesz = size;
	} else {
		printf("Minidump error first phdr p_filesz:0x%llx p_memsz:0x%llx sh_size:0x%llx\n",
		       phdr->p_filesz, phdr->p_memsz, shdr->sh_size);
		return 0;
	}

	phdr++;
	shdr++;
	phdr_next = phdr + 1;
	shdr_next = shdr + 1;

	memset(ram_image, 0x0, 0x18000);

	phdr->p_offset &= MAX_ELF_SIZE - 1;
	shdr->sh_offset &= MAX_ELF_SIZE - 1;
	elf_size &= MAX_ELF_SIZE - 1;
	if (phdr->p_offset == shdr->sh_offset) {
		elf_size = phdr->p_offset;
	} else if (phdr->p_offset == elf_size) {
		shdr->sh_offset = phdr->p_offset;
	} else if (elf_size == shdr->sh_offset) {
		phdr->p_offset = shdr->sh_offset;
	} else {
		printf("Minidump error phdr[1] p_offset:0x%llx sh_offset:0x%llx elf_size:0x%x\n",
		       phdr->p_offset, shdr->sh_offset, elf_size);
		return 0;
	}

	/* save phdr space */
	for (i = 1; i < MAX_NUM_ENTRIES; i++) {
		void *src = NULL;
		void *dst = NULL;

		if (phdr->p_vaddr == 0 || shdr->sh_addr == 0)
			break;

		phdr->p_offset &= MAX_ELF_SIZE - 1;
		shdr->sh_offset &= MAX_ELF_SIZE - 1;

		if (phdr->p_offset != elf_size)
			phdr->p_offset = elf_size;

		if (shdr->sh_offset != elf_size)
			shdr->sh_offset = elf_size;

		phdr->p_paddr &= GENMASK(34, 0);	/* 32GB */
		phdr->p_align &= GENMASK(34, 0);	/* 32GB */
		shdr->sh_info &= GENMASK(34, 0);	/* 32GB */

		if (phdr->p_paddr != phdr->p_align && phdr->p_align == shdr->sh_entsize)
			phdr->p_paddr = phdr->p_align;

		phdr->p_type &= 0xf;
		phdr->p_flags &= 0xf;
		phdr->p_filesz &= GENMASK(23, 0);	/* 16MB */
		phdr->p_memsz &= GENMASK(23, 0);	/* 16MB */
		phdr->p_align = 0;

		if (phdr->p_vaddr != shdr->sh_addr) {
			if (shdr->sh_addr == shdr->sh_addralign)
				phdr->p_vaddr = shdr->sh_addr;
			else if (phdr->p_vaddr == shdr->sh_addralign)
				shdr->sh_addr = phdr->p_vaddr;
			else
				printf("Minidump error phdr[%d] p_vaddr:0x%llx sh_addr:0x%llx sh_addralign:0x%llx\n",
				       i, phdr->p_vaddr, shdr->sh_addr, shdr->sh_addralign);
		}

		if (shdr->sh_name >= MAX_STRTBL_SIZE)
			shdr->sh_name = 0;
		shdr->sh_type = SHT_PROGBITS;
		shdr->sh_flags = SHF_WRITE;
		shdr->sh_size &= GENMASK(23, 0);	/* 16MB */
		shdr->sh_link = 0;
		shdr->sh_info = 0;
		shdr->sh_addralign = 0;
		shdr->sh_entsize = 0;

		if (phdr->p_filesz == phdr->p_memsz) {
			size = phdr->p_filesz;
			shdr->sh_size = size;
		} else if (phdr->p_filesz == shdr->sh_size) {
			size = phdr->p_filesz;
			phdr->p_memsz = size;
		} else if (phdr->p_memsz == shdr->sh_size) {
			size = phdr->p_memsz;
			phdr->p_filesz = size;
		} else {
			if ((phdr_next->p_offset == shdr_next->sh_offset) &&
			    (phdr_next->p_offset != 0)) {
				size = phdr_next->p_offset - phdr->p_offset;
				phdr->p_filesz = size;
				phdr->p_memsz = size;
				shdr->sh_size = size;
			} else {
				printf("Minidump error phdr[%d] p_filesz:0x%llx p_memsz:0x%llx sh_size:0x%llx",
				       i, phdr->p_filesz, phdr->p_memsz, shdr->sh_size);
				printf("p_offset:0x%llx sh_offset:0x%llx\n", phdr_next->p_offset,
				       shdr_next->sh_offset);
				return 0;
			}
		}

		elf_size += size;
		src = (void *)(Elf64_Addr)phdr->p_paddr;
		dst = ram_image + phdr->p_offset;

		if (size > MAX_ELF_SIZE / 2)
			goto donot_cpy;

		if (!md_is_uboot_addr(src) || !md_is_uboot_addr(src + size - 1)) {
			printf("Minidump error src 0x%p-0x%p\n", src, src + size - 1);
			goto donot_cpy;
		}
		if (!md_is_uboot_addr(dst) || !md_is_uboot_addr(dst + size - 1)) {
			printf("Minidump error dst 0x%p-0x%p\n", dst, dst + size - 1);
			goto donot_cpy;
		}
		if (size)
			memcpy(dst, src, size);
donot_cpy:
		phdr++;
		shdr++;
		phdr_next++;
		shdr_next++;
	}

	if (ehdr->e_phnum != i)
		ehdr->e_phnum = i;
	if ((ehdr->e_phnum + 3) != ehdr->e_shnum)
		ehdr->e_shnum = ehdr->e_phnum + 3;

	/* copy ehdr to ram image */
	memcpy(ram_image, (void *)ehdr, ehsize);
	flush_cache((unsigned long)ram_image, elf_size);
	printf("Minidump.elf 0x%x@0x%p\n", elf_size, ram_image);
	return elf_size;
}
#else
static Elf32_Word rk_dump_elf32_image_phdr(void *ram_image, Elf32_Addr ehaddr,
					   Elf32_Word ehsize)
{
	Elf32_Ehdr *ehdr = (Elf32_Ehdr *)ehaddr;
	Elf32_Phdr *phdr = (Elf32_Phdr *)(ehaddr + ehdr->e_phoff);
	Elf32_Word ram_image_size = 0;
	int i;

	/* copy ehdr to ram image */
	memcpy(ram_image, (void *)ehdr, ehsize);

	/* save phdr space */
	for (i = 0; i < ehdr->e_phnum; ++i) {
		void *src = (void *)(Elf32_Addr)phdr->p_paddr;
		void *dst = ram_image + phdr->p_offset;

		if (phdr->p_filesz)
			memcpy(dst, src, phdr->p_filesz);
		if (phdr->p_filesz != phdr->p_memsz)
			memset(dst + phdr->p_filesz, 0x00,
			       phdr->p_memsz - phdr->p_filesz);
		++phdr;
	}

	phdr--;
	ram_image_size = phdr->p_memsz + phdr->p_offset;
	printf("Minidump.elf 0x%llx@0x%p\n", ram_image_size, ram_image);
	return ram_image_size;
}
#endif

void rk_minidump_init(void)
{
	struct md_global_toc *mdg_toc = (struct md_global_toc *)SMEM_BASE;
	struct md_ss_toc *md_ss_toc = &mdg_toc->md_ss_toc[0];
	struct md_ss_region *mdreg;

	printf("Minidump: init...\n");
	mdg_toc->md_toc_init = 1;
	mdg_toc->md_revision = 1;
	mdg_toc->md_enable_status = 0;

	if (md_ss_toc->md_ss_enable_status == MD_SS_ENABLED) {
		/* linux would set it 1, so we set it 0 here */
		md_ss_toc->md_ss_enable_status = 0;
		flush_cache((unsigned long)md_ss_toc, 8);
		mdreg = (struct md_ss_region *)md_ss_toc->md_ss_smem_regions_baseptr;
		minidump_table = (struct md_table *)md_ss_toc->minidump_table;
#ifdef CONFIG_ARM64
		md_ss_toc->elf_size = rk_dump_elf64_image_phdr((void *)md_ss_toc->elf_header,
					 (Elf64_Addr)mdreg->region_base_address,
					 (Elf64_Xword)mdreg->region_size);
#else
		md_ss_toc->elf_size = rk_dump_elf32_image_phdr((void *)md_ss_toc->elf_header,
					 (Elf32_Addr)mdreg->region_base_address,
					 (Elf32_Word)mdreg->region_size);
#endif
	}
}

#ifdef CONFIG_ARM64
void rk_minidump_get_el64(void **ram_image_addr, Elf64_Xword *ram_image_size)
{
	struct md_global_toc *mdg_toc = (struct md_global_toc *)SMEM_BASE;
	struct md_ss_toc *md_ss_toc = &mdg_toc->md_ss_toc[0];

	*ram_image_addr = (void *)md_ss_toc->elf_header;
	*ram_image_size = md_ss_toc->elf_size;
}
#else
void rk_minidump_get_el32(void **ram_image_addr, Elf32_Word *ram_image_size)
{
	struct md_global_toc *mdg_toc = (struct md_global_toc *)SMEM_BASE;
	struct md_ss_toc *md_ss_toc = &mdg_toc->md_ss_toc[0];

	*ram_image_addr = (void *)md_ss_toc->elf_header;
	*ram_image_size = md_ss_toc->elf_size;
}
#endif