blob: 5770bf7d66b661f6e5260df4ca1acf11c6defed8 [file] [log] [blame]
johpow019d134022021-06-16 17:57:28 -05001/*
2 * Copyright (c) 2021, Arm Limited. All rights reserved.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7#ifndef GPT_RME_PRIVATE_H
8#define GPT_RME_PRIVATE_H
9
10#include <arch.h>
11#include <lib/gpt_rme/gpt_rme.h>
12#include <lib/utils_def.h>
13
14/******************************************************************************/
15/* GPT descriptor definitions */
16/******************************************************************************/
17
18/* GPT level 0 descriptor bit definitions. */
19#define GPT_L0_TYPE_MASK UL(0xF)
20#define GPT_L0_TYPE_SHIFT U(0)
21
22/* For now, we don't support contiguous descriptors, only table and block. */
23#define GPT_L0_TYPE_TBL_DESC UL(0x3)
24#define GPT_L0_TYPE_BLK_DESC UL(0x1)
25
26#define GPT_L0_TBL_DESC_L1ADDR_MASK UL(0xFFFFFFFFFF)
27#define GPT_L0_TBL_DESC_L1ADDR_SHIFT U(12)
28
29#define GPT_L0_BLK_DESC_GPI_MASK UL(0xF)
30#define GPT_L0_BLK_DESC_GPI_SHIFT U(4)
31
32/* GPT level 1 descriptor bit definitions */
33#define GPT_L1_GRAN_DESC_GPI_MASK UL(0xF)
34
35/*
36 * This macro fills out every GPI entry in a granules descriptor to the same
37 * value.
38 */
39#define GPT_BUILD_L1_DESC(_gpi) (((uint64_t)(_gpi) << 4*0) | \
40 ((uint64_t)(_gpi) << 4*1) | \
41 ((uint64_t)(_gpi) << 4*2) | \
42 ((uint64_t)(_gpi) << 4*3) | \
43 ((uint64_t)(_gpi) << 4*4) | \
44 ((uint64_t)(_gpi) << 4*5) | \
45 ((uint64_t)(_gpi) << 4*6) | \
46 ((uint64_t)(_gpi) << 4*7) | \
47 ((uint64_t)(_gpi) << 4*8) | \
48 ((uint64_t)(_gpi) << 4*9) | \
49 ((uint64_t)(_gpi) << 4*10) | \
50 ((uint64_t)(_gpi) << 4*11) | \
51 ((uint64_t)(_gpi) << 4*12) | \
52 ((uint64_t)(_gpi) << 4*13) | \
53 ((uint64_t)(_gpi) << 4*14) | \
54 ((uint64_t)(_gpi) << 4*15))
55
56/******************************************************************************/
57/* GPT platform configuration */
58/******************************************************************************/
59
60/* This value comes from GPCCR_EL3 so no externally supplied definition. */
61#define GPT_L0GPTSZ ((unsigned int)((read_gpccr_el3() >> \
62 GPCCR_L0GPTSZ_SHIFT) & GPCCR_L0GPTSZ_MASK))
63
64/* The "S" value is directly related to L0GPTSZ */
65#define GPT_S_VAL (GPT_L0GPTSZ + 30U)
66
67/*
68 * Map PPS values to T values.
69 *
70 * PPS Size T
71 * 0b000 4GB 32
72 * 0b001 64GB 36
73 * 0b010 1TB 40
74 * 0b011 4TB 42
75 * 0b100 16TB 44
76 * 0b101 256TB 48
77 * 0b110 4PB 52
78 *
79 * See section 15.1.27 of the RME specification.
80 */
81typedef enum {
82 PPS_4GB_T = 32U,
83 PPS_64GB_T = 36U,
84 PPS_1TB_T = 40U,
85 PPS_4TB_T = 42U,
86 PPS_16TB_T = 44U,
87 PPS_256TB_T = 48U,
88 PPS_4PB_T = 52U
89} gpt_t_val_e;
90
91/*
92 * Map PGS values to P values.
93 *
94 * PGS Size P
95 * 0b00 4KB 12
96 * 0b10 16KB 14
97 * 0b01 64KB 16
98 *
99 * Note that pgs=0b10 is 16KB and pgs=0b01 is 64KB, this is not a typo.
100 *
101 * See section 15.1.27 of the RME specification.
102 */
103typedef enum {
104 PGS_4KB_P = 12U,
105 PGS_16KB_P = 14U,
106 PGS_64KB_P = 16U
107} gpt_p_val_e;
108
109/* Max valid value for PGS. */
110#define GPT_PGS_MAX (2U)
111
112/* Max valid value for PPS. */
113#define GPT_PPS_MAX (6U)
114
115/******************************************************************************/
116/* L0 address attribute macros */
117/******************************************************************************/
118
119/*
120 * If S is greater than or equal to T then there is a single L0 region covering
121 * the entire protected space so there is no L0 index, so the width (and the
122 * derivative mask value) are both zero. If we don't specifically handle this
123 * special case we'll get a negative width value which does not make sense and
124 * could cause a lot of problems.
125 */
126#define GPT_L0_IDX_WIDTH(_t) (((_t) > GPT_S_VAL) ? \
127 ((_t) - GPT_S_VAL) : (0U))
128
129/* Bit shift for the L0 index field in a PA. */
130#define GPT_L0_IDX_SHIFT (GPT_S_VAL)
131
132/* Mask for the L0 index field, must be shifted. */
133#define GPT_L0_IDX_MASK(_t) (0xFFFFFFFFFFFFFFFFUL >> \
134 (64U - (GPT_L0_IDX_WIDTH(_t))))
135
136/* Total number of L0 regions. */
137#define GPT_L0_REGION_COUNT(_t) ((GPT_L0_IDX_MASK(_t)) + 1U)
138
139/* Total size of each GPT L0 region in bytes. */
140#define GPT_L0_REGION_SIZE (1UL << (GPT_L0_IDX_SHIFT))
141
142/* Total size in bytes of the whole L0 table. */
143#define GPT_L0_TABLE_SIZE(_t) ((GPT_L0_REGION_COUNT(_t)) << 3U)
144
145/******************************************************************************/
146/* L1 address attribute macros */
147/******************************************************************************/
148
149/* Width of the L1 index field. */
150#define GPT_L1_IDX_WIDTH(_p) ((GPT_S_VAL - 1U) - ((_p) + 3U))
151
152/* Bit shift for the L1 index field. */
153#define GPT_L1_IDX_SHIFT(_p) ((_p) + 4U)
154
155/* Mask for the L1 index field, must be shifted. */
156#define GPT_L1_IDX_MASK(_p) (0xFFFFFFFFFFFFFFFFUL >> \
157 (64U - (GPT_L1_IDX_WIDTH(_p))))
158
159/* Bit shift for the index of the L1 GPI in a PA. */
160#define GPT_L1_GPI_IDX_SHIFT(_p) (_p)
161
162/* Mask for the index of the L1 GPI in a PA. */
163#define GPT_L1_GPI_IDX_MASK (0xF)
164
165/* Total number of entries in each L1 table. */
166#define GPT_L1_ENTRY_COUNT(_p) ((GPT_L1_IDX_MASK(_p)) + 1U)
167
168/* Total size in bytes of each L1 table. */
169#define GPT_L1_TABLE_SIZE(_p) ((GPT_L1_ENTRY_COUNT(_p)) << 3U)
170
171/******************************************************************************/
172/* General helper macros */
173/******************************************************************************/
174
175/* Protected space actual size in bytes. */
176#define GPT_PPS_ACTUAL_SIZE(_t) (1UL << (_t))
177
178/* Granule actual size in bytes. */
179#define GPT_PGS_ACTUAL_SIZE(_p) (1UL << (_p))
180
181/* L0 GPT region size in bytes. */
182#define GPT_L0GPTSZ_ACTUAL_SIZE (1UL << GPT_S_VAL)
183
184/* Get the index of the L0 entry from a physical address. */
185#define GPT_L0_IDX(_pa) ((_pa) >> GPT_L0_IDX_SHIFT)
186
187/*
188 * This definition is used to determine if a physical address lies on an L0
189 * region boundary.
190 */
191#define GPT_IS_L0_ALIGNED(_pa) (((_pa) & (GPT_L0_REGION_SIZE - U(1))) == U(0))
192
193/* Get the type field from an L0 descriptor. */
194#define GPT_L0_TYPE(_desc) (((_desc) >> GPT_L0_TYPE_SHIFT) & \
195 GPT_L0_TYPE_MASK)
196
197/* Create an L0 block descriptor. */
198#define GPT_L0_BLK_DESC(_gpi) (GPT_L0_TYPE_BLK_DESC | \
199 (((_gpi) & GPT_L0_BLK_DESC_GPI_MASK) << \
200 GPT_L0_BLK_DESC_GPI_SHIFT))
201
202/* Create an L0 table descriptor with an L1 table address. */
203#define GPT_L0_TBL_DESC(_pa) (GPT_L0_TYPE_TBL_DESC | ((uint64_t)(_pa) & \
204 (GPT_L0_TBL_DESC_L1ADDR_MASK << \
205 GPT_L0_TBL_DESC_L1ADDR_SHIFT)))
206
207/* Get the GPI from an L0 block descriptor. */
208#define GPT_L0_BLKD_GPI(_desc) (((_desc) >> GPT_L0_BLK_DESC_GPI_SHIFT) & \
209 GPT_L0_BLK_DESC_GPI_MASK)
210
211/* Get the L1 address from an L0 table descriptor. */
212#define GPT_L0_TBLD_ADDR(_desc) ((uint64_t *)(((_desc) & \
213 (GPT_L0_TBL_DESC_L1ADDR_MASK << \
214 GPT_L0_TBL_DESC_L1ADDR_SHIFT))))
215
216/* Get the index into the L1 table from a physical address. */
217#define GPT_L1_IDX(_p, _pa) (((_pa) >> GPT_L1_IDX_SHIFT(_p)) & \
218 GPT_L1_IDX_MASK(_p))
219
220/* Get the index of the GPI within an L1 table entry from a physical address. */
221#define GPT_L1_GPI_IDX(_p, _pa) (((_pa) >> GPT_L1_GPI_IDX_SHIFT(_p)) & \
222 GPT_L1_GPI_IDX_MASK)
223
224/* Determine if an address is granule-aligned. */
225#define GPT_IS_L1_ALIGNED(_p, _pa) (((_pa) & (GPT_PGS_ACTUAL_SIZE(_p) - U(1))) \
226 == U(0))
227
228#endif /* GPT_RME_PRIVATE_H */