aboutsummaryrefslogtreecommitdiff
path: root/plat/common/plat_spm_sp.c
blob: 7b7fbd987e4c3008f46f39d069c549976139eab1 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
/*
 * Copyright (c) 2018, Arm Limited. All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

#include <assert.h>
#include <debug.h>
#include <platform_def.h>
#include <sptool.h>

static unsigned int sp_next;

/*******************************************************************************
 * Platform handler get the address of a Secure Partition and its resource
 * description blob. It iterates through all SPs detected by the platform. If
 * there is information for another SP, it returns 0. If there are no more SPs,
 * it returns -1.
 ******************************************************************************/
int plat_spm_sp_get_next_address(void **sp_base, size_t *sp_size,
				 void **rd_base, size_t *rd_size)
{
	assert((sp_base != NULL) && (sp_size != NULL));
	assert((rd_base != NULL) && (rd_base != NULL));

	const uint64_t *pkg_base = (uint64_t *)PLAT_SP_PACKAGE_BASE;

	struct sp_pkg_header *pkg_header = (struct sp_pkg_header *)pkg_base;

	if (sp_next == 0) {
		if (pkg_header->version != 0x1) {
			ERROR("SP package has an unsupported version 0x%llx\n",
			      pkg_header->version);
			panic();
		}
	}

	if (sp_next >= pkg_header->number_of_sp) {
		/* No more partitions in the package */
		return -1;
	}

	const struct sp_pkg_entry *entry_list =
		(const struct sp_pkg_entry *)((uintptr_t)pkg_base
					       + sizeof(struct sp_pkg_header));

	const struct sp_pkg_entry *entry = &(entry_list[sp_next]);

	uint64_t sp_offset = entry->sp_offset;
	uint64_t rd_offset = entry->rd_offset;

	uintptr_t pkg_sp_base = ((uintptr_t)PLAT_SP_PACKAGE_BASE + sp_offset);
	uintptr_t pkg_rd_base = ((uintptr_t)PLAT_SP_PACKAGE_BASE + rd_offset);

	uint64_t pkg_sp_size = entry->sp_size;
	uint64_t pkg_rd_size = entry->rd_size;

	uintptr_t pkg_end = (uintptr_t)PLAT_SP_PACKAGE_BASE
			  + (uintptr_t)PLAT_SP_PACKAGE_SIZE - 1U;

	/*
	 * Check for overflows. The package header isn't trusted, so assert()
	 * can't be used here.
	 */

	uintptr_t pkg_sp_end = pkg_sp_base + pkg_sp_size - 1U;
	uintptr_t pkg_rd_end = pkg_rd_base + pkg_rd_size - 1U;

	if ((pkg_sp_end > pkg_end) || (pkg_sp_end < pkg_sp_base)) {
		ERROR("Invalid Secure Partition size (0x%llx)\n", pkg_sp_size);
		panic();
	}

	if ((pkg_rd_end > pkg_end) || (pkg_rd_end < pkg_rd_base)) {
		ERROR("Invalid Resource Description blob size (0x%llx)\n",
		      pkg_rd_size);
		panic();
	}

	/* Return location of the binaries. */

	*sp_base = (void *)pkg_sp_base;
	*sp_size = pkg_sp_size;
	*rd_base = (void *)pkg_rd_base;
	*rd_size = pkg_rd_size;

	sp_next++;

	return 0;
}