blob: e4065c1c99bb318aa64818b2b0ee3cd9013a9089 [file] [log] [blame]
Yann Gautieree8f5422019-02-14 11:13:25 +01001/*
Yann Gautiera0a6ff62021-05-10 16:05:18 +02002 * Copyright (c) 2015-2021, ARM Limited and Contributors. All rights reserved.
Yann Gautieree8f5422019-02-14 11:13:25 +01003 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
Yann Gautiere3bf9132019-05-07 18:52:17 +02007#include <assert.h>
8
Yann Gautier35dc0772019-05-13 18:34:48 +02009#include <libfdt.h>
10
Yann Gautieree8f5422019-02-14 11:13:25 +010011#include <platform_def.h>
12
Yann Gautier091eab52019-06-04 18:06:34 +020013#include <drivers/st/stm32_iwdg.h>
Yann Gautieree8f5422019-02-14 11:13:25 +010014#include <lib/xlat_tables/xlat_tables_v2.h>
15
Yann Gautier35dc0772019-05-13 18:34:48 +020016/* Internal layout of the 32bit OTP word board_id */
17#define BOARD_ID_BOARD_NB_MASK GENMASK(31, 16)
18#define BOARD_ID_BOARD_NB_SHIFT 16
Patrick Delaunay7704f162020-01-08 10:05:14 +010019#define BOARD_ID_VARCPN_MASK GENMASK(15, 12)
20#define BOARD_ID_VARCPN_SHIFT 12
Yann Gautier35dc0772019-05-13 18:34:48 +020021#define BOARD_ID_REVISION_MASK GENMASK(11, 8)
22#define BOARD_ID_REVISION_SHIFT 8
Patrick Delaunay7704f162020-01-08 10:05:14 +010023#define BOARD_ID_VARFG_MASK GENMASK(7, 4)
24#define BOARD_ID_VARFG_SHIFT 4
Yann Gautier35dc0772019-05-13 18:34:48 +020025#define BOARD_ID_BOM_MASK GENMASK(3, 0)
26
27#define BOARD_ID2NB(_id) (((_id) & BOARD_ID_BOARD_NB_MASK) >> \
28 BOARD_ID_BOARD_NB_SHIFT)
Patrick Delaunay7704f162020-01-08 10:05:14 +010029#define BOARD_ID2VARCPN(_id) (((_id) & BOARD_ID_VARCPN_MASK) >> \
30 BOARD_ID_VARCPN_SHIFT)
Yann Gautier35dc0772019-05-13 18:34:48 +020031#define BOARD_ID2REV(_id) (((_id) & BOARD_ID_REVISION_MASK) >> \
32 BOARD_ID_REVISION_SHIFT)
Patrick Delaunay7704f162020-01-08 10:05:14 +010033#define BOARD_ID2VARFG(_id) (((_id) & BOARD_ID_VARFG_MASK) >> \
34 BOARD_ID_VARFG_SHIFT)
Yann Gautier35dc0772019-05-13 18:34:48 +020035#define BOARD_ID2BOM(_id) ((_id) & BOARD_ID_BOM_MASK)
36
Etienne Carriere72369b12019-12-08 08:17:56 +010037#if defined(IMAGE_BL2)
38#define MAP_SEC_SYSRAM MAP_REGION_FLAT(STM32MP_SYSRAM_BASE, \
Yann Gautiera2e2a302019-02-14 11:13:39 +010039 STM32MP_SYSRAM_SIZE, \
Yann Gautieree8f5422019-02-14 11:13:25 +010040 MT_MEMORY | \
41 MT_RW | \
42 MT_SECURE | \
43 MT_EXECUTE_NEVER)
Etienne Carriere72369b12019-12-08 08:17:56 +010044#elif defined(IMAGE_BL32)
45#define MAP_SEC_SYSRAM MAP_REGION_FLAT(STM32MP_SEC_SYSRAM_BASE, \
46 STM32MP_SEC_SYSRAM_SIZE, \
47 MT_MEMORY | \
48 MT_RW | \
49 MT_SECURE | \
50 MT_EXECUTE_NEVER)
Yann Gautieree8f5422019-02-14 11:13:25 +010051
Etienne Carriere72369b12019-12-08 08:17:56 +010052/* Non-secure SYSRAM is used a uncached memory for SCMI message transfer */
53#define MAP_NS_SYSRAM MAP_REGION_FLAT(STM32MP_NS_SYSRAM_BASE, \
54 STM32MP_NS_SYSRAM_SIZE, \
55 MT_DEVICE | \
56 MT_RW | \
57 MT_NS | \
58 MT_EXECUTE_NEVER)
59#endif
60
Yann Gautieree8f5422019-02-14 11:13:25 +010061#define MAP_DEVICE1 MAP_REGION_FLAT(STM32MP1_DEVICE1_BASE, \
62 STM32MP1_DEVICE1_SIZE, \
63 MT_DEVICE | \
64 MT_RW | \
65 MT_SECURE | \
66 MT_EXECUTE_NEVER)
67
68#define MAP_DEVICE2 MAP_REGION_FLAT(STM32MP1_DEVICE2_BASE, \
69 STM32MP1_DEVICE2_SIZE, \
70 MT_DEVICE | \
71 MT_RW | \
72 MT_SECURE | \
73 MT_EXECUTE_NEVER)
74
75#if defined(IMAGE_BL2)
76static const mmap_region_t stm32mp1_mmap[] = {
Etienne Carriere72369b12019-12-08 08:17:56 +010077 MAP_SEC_SYSRAM,
Yann Gautieree8f5422019-02-14 11:13:25 +010078 MAP_DEVICE1,
79 MAP_DEVICE2,
80 {0}
81};
82#endif
83#if defined(IMAGE_BL32)
84static const mmap_region_t stm32mp1_mmap[] = {
Etienne Carriere72369b12019-12-08 08:17:56 +010085 MAP_SEC_SYSRAM,
86 MAP_NS_SYSRAM,
Yann Gautieree8f5422019-02-14 11:13:25 +010087 MAP_DEVICE1,
88 MAP_DEVICE2,
89 {0}
90};
91#endif
92
93void configure_mmu(void)
94{
95 mmap_add(stm32mp1_mmap);
96 init_xlat_tables();
97
98 enable_mmu_svc_mon(0);
99}
Yann Gautiere3bf9132019-05-07 18:52:17 +0200100
Etienne Carriere66b04522019-12-02 10:05:02 +0100101uintptr_t stm32_get_gpio_bank_base(unsigned int bank)
102{
103 if (bank == GPIO_BANK_Z) {
104 return GPIOZ_BASE;
105 }
106
107 assert(GPIO_BANK_A == 0 && bank <= GPIO_BANK_K);
108
109 return GPIOA_BASE + (bank * GPIO_BANK_OFFSET);
110}
111
112uint32_t stm32_get_gpio_bank_offset(unsigned int bank)
113{
114 if (bank == GPIO_BANK_Z) {
115 return 0;
116 }
117
118 assert(GPIO_BANK_A == 0 && bank <= GPIO_BANK_K);
119
120 return bank * GPIO_BANK_OFFSET;
121}
122
Yann Gautiere3bf9132019-05-07 18:52:17 +0200123unsigned long stm32_get_gpio_bank_clock(unsigned int bank)
124{
125 if (bank == GPIO_BANK_Z) {
126 return GPIOZ;
127 }
128
129 assert(GPIO_BANK_A == 0 && bank <= GPIO_BANK_K);
130
131 return GPIOA + (bank - GPIO_BANK_A);
132}
Yann Gautier091eab52019-06-04 18:06:34 +0200133
Etienne Carriered81dadf2020-04-25 11:14:45 +0200134int stm32_get_gpio_bank_pinctrl_node(void *fdt, unsigned int bank)
135{
136 switch (bank) {
137 case GPIO_BANK_A:
138 case GPIO_BANK_B:
139 case GPIO_BANK_C:
140 case GPIO_BANK_D:
141 case GPIO_BANK_E:
142 case GPIO_BANK_F:
143 case GPIO_BANK_G:
144 case GPIO_BANK_H:
145 case GPIO_BANK_I:
146 case GPIO_BANK_J:
147 case GPIO_BANK_K:
148 return fdt_path_offset(fdt, "/soc/pin-controller");
149 case GPIO_BANK_Z:
150 return fdt_path_offset(fdt, "/soc/pin-controller-z");
151 default:
152 panic();
153 }
154}
155
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200156uint32_t stm32mp_get_chip_version(void)
Yann Gautierc7374052019-06-04 18:02:37 +0200157{
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200158 uint32_t version = 0U;
159
160 if (stm32mp1_dbgmcu_get_chip_version(&version) < 0) {
161 INFO("Cannot get CPU version, debug disabled\n");
162 return 0U;
163 }
164
165 return version;
166}
Yann Gautierc7374052019-06-04 18:02:37 +0200167
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200168uint32_t stm32mp_get_chip_dev_id(void)
169{
170 uint32_t dev_id;
Nicolas Le Bayon98f4ea02019-09-23 11:18:32 +0200171
Yann Gautierc7374052019-06-04 18:02:37 +0200172 if (stm32mp1_dbgmcu_get_chip_dev_id(&dev_id) < 0) {
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200173 INFO("Use default chip ID, debug disabled\n");
174 dev_id = STM32MP1_CHIP_ID;
Yann Gautierc7374052019-06-04 18:02:37 +0200175 }
176
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200177 return dev_id;
178}
179
180static uint32_t get_part_number(void)
181{
182 static uint32_t part_number;
183
184 if (part_number != 0U) {
185 return part_number;
186 }
187
Yann Gautierc7374052019-06-04 18:02:37 +0200188 if (bsec_shadow_read_otp(&part_number, PART_NUMBER_OTP) != BSEC_OK) {
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200189 panic();
Yann Gautierc7374052019-06-04 18:02:37 +0200190 }
191
192 part_number = (part_number & PART_NUMBER_OTP_PART_MASK) >>
193 PART_NUMBER_OTP_PART_SHIFT;
194
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200195 part_number |= stm32mp_get_chip_dev_id() << 16;
Yann Gautierc7374052019-06-04 18:02:37 +0200196
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200197 return part_number;
Yann Gautierc7374052019-06-04 18:02:37 +0200198}
199
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200200static uint32_t get_cpu_package(void)
Yann Gautierc7374052019-06-04 18:02:37 +0200201{
202 uint32_t package;
203
204 if (bsec_shadow_read_otp(&package, PACKAGE_OTP) != BSEC_OK) {
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200205 panic();
Yann Gautierc7374052019-06-04 18:02:37 +0200206 }
207
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200208 package = (package & PACKAGE_OTP_PKG_MASK) >>
Yann Gautierc7374052019-06-04 18:02:37 +0200209 PACKAGE_OTP_PKG_SHIFT;
210
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200211 return package;
Yann Gautierc7374052019-06-04 18:02:37 +0200212}
213
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200214void stm32mp_get_soc_name(char name[STM32_SOC_NAME_SIZE])
Yann Gautierc7374052019-06-04 18:02:37 +0200215{
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200216 char *cpu_s, *cpu_r, *pkg;
Yann Gautierc7374052019-06-04 18:02:37 +0200217
218 /* MPUs Part Numbers */
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200219 switch (get_part_number()) {
Yann Gautierc7374052019-06-04 18:02:37 +0200220 case STM32MP157C_PART_NB:
221 cpu_s = "157C";
222 break;
223 case STM32MP157A_PART_NB:
224 cpu_s = "157A";
225 break;
226 case STM32MP153C_PART_NB:
227 cpu_s = "153C";
228 break;
229 case STM32MP153A_PART_NB:
230 cpu_s = "153A";
231 break;
232 case STM32MP151C_PART_NB:
233 cpu_s = "151C";
234 break;
235 case STM32MP151A_PART_NB:
236 cpu_s = "151A";
237 break;
Lionel Debieve7b64e3e2019-05-17 16:01:18 +0200238 case STM32MP157F_PART_NB:
239 cpu_s = "157F";
240 break;
241 case STM32MP157D_PART_NB:
242 cpu_s = "157D";
243 break;
244 case STM32MP153F_PART_NB:
245 cpu_s = "153F";
246 break;
247 case STM32MP153D_PART_NB:
248 cpu_s = "153D";
249 break;
250 case STM32MP151F_PART_NB:
251 cpu_s = "151F";
252 break;
253 case STM32MP151D_PART_NB:
254 cpu_s = "151D";
255 break;
Yann Gautierc7374052019-06-04 18:02:37 +0200256 default:
257 cpu_s = "????";
258 break;
259 }
260
261 /* Package */
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200262 switch (get_cpu_package()) {
Yann Gautierc7374052019-06-04 18:02:37 +0200263 case PKG_AA_LFBGA448:
264 pkg = "AA";
265 break;
266 case PKG_AB_LFBGA354:
267 pkg = "AB";
268 break;
269 case PKG_AC_TFBGA361:
270 pkg = "AC";
271 break;
272 case PKG_AD_TFBGA257:
273 pkg = "AD";
274 break;
275 default:
276 pkg = "??";
277 break;
278 }
279
280 /* REVISION */
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200281 switch (stm32mp_get_chip_version()) {
Yann Gautierc7374052019-06-04 18:02:37 +0200282 case STM32MP1_REV_B:
283 cpu_r = "B";
284 break;
Lionel Debieve2d64b532019-06-25 10:40:37 +0200285 case STM32MP1_REV_Z:
286 cpu_r = "Z";
287 break;
Yann Gautierc7374052019-06-04 18:02:37 +0200288 default:
289 cpu_r = "?";
290 break;
291 }
292
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200293 snprintf(name, STM32_SOC_NAME_SIZE,
294 "STM32MP%s%s Rev.%s", cpu_s, pkg, cpu_r);
295}
296
297void stm32mp_print_cpuinfo(void)
298{
299 char name[STM32_SOC_NAME_SIZE];
300
301 stm32mp_get_soc_name(name);
302 NOTICE("CPU: %s\n", name);
Yann Gautierc7374052019-06-04 18:02:37 +0200303}
304
Yann Gautier35dc0772019-05-13 18:34:48 +0200305void stm32mp_print_boardinfo(void)
306{
307 uint32_t board_id;
308 uint32_t board_otp;
309 int bsec_node, bsec_board_id_node;
310 void *fdt;
311 const fdt32_t *cuint;
312
313 if (fdt_get_address(&fdt) == 0) {
314 panic();
315 }
316
317 bsec_node = fdt_node_offset_by_compatible(fdt, -1, DT_BSEC_COMPAT);
318 if (bsec_node < 0) {
319 return;
320 }
321
322 bsec_board_id_node = fdt_subnode_offset(fdt, bsec_node, "board_id");
323 if (bsec_board_id_node <= 0) {
324 return;
325 }
326
327 cuint = fdt_getprop(fdt, bsec_board_id_node, "reg", NULL);
328 if (cuint == NULL) {
329 panic();
330 }
331
332 board_otp = fdt32_to_cpu(*cuint) / sizeof(uint32_t);
333
334 if (bsec_shadow_read_otp(&board_id, board_otp) != BSEC_OK) {
335 ERROR("BSEC: PART_NUMBER_OTP Error\n");
336 return;
337 }
338
339 if (board_id != 0U) {
340 char rev[2];
341
342 rev[0] = BOARD_ID2REV(board_id) - 1 + 'A';
343 rev[1] = '\0';
Yann Gautier36e9d382020-10-13 18:03:31 +0200344 NOTICE("Board: MB%04x Var%u.%u Rev.%s-%02u\n",
Yann Gautier35dc0772019-05-13 18:34:48 +0200345 BOARD_ID2NB(board_id),
Patrick Delaunay7704f162020-01-08 10:05:14 +0100346 BOARD_ID2VARCPN(board_id),
347 BOARD_ID2VARFG(board_id),
Yann Gautier35dc0772019-05-13 18:34:48 +0200348 rev,
349 BOARD_ID2BOM(board_id));
350 }
351}
352
Yann Gautieraf19ff92019-06-04 18:23:10 +0200353/* Return true when SoC provides a single Cortex-A7 core, and false otherwise */
354bool stm32mp_is_single_core(void)
355{
Yann Gautiera0a6ff62021-05-10 16:05:18 +0200356 switch (get_part_number()) {
Yann Gautieraf19ff92019-06-04 18:23:10 +0200357 case STM32MP151A_PART_NB:
358 case STM32MP151C_PART_NB:
Lionel Debieve7b64e3e2019-05-17 16:01:18 +0200359 case STM32MP151D_PART_NB:
360 case STM32MP151F_PART_NB:
361 return true;
Yann Gautieraf19ff92019-06-04 18:23:10 +0200362 default:
Lionel Debieve7b64e3e2019-05-17 16:01:18 +0200363 return false;
Yann Gautieraf19ff92019-06-04 18:23:10 +0200364 }
Yann Gautieraf19ff92019-06-04 18:23:10 +0200365}
366
Lionel Debieve0e73d732019-09-16 12:17:09 +0200367/* Return true when device is in closed state */
368bool stm32mp_is_closed_device(void)
369{
370 uint32_t value;
371
372 if ((bsec_shadow_register(DATA0_OTP) != BSEC_OK) ||
373 (bsec_read_otp(&value, DATA0_OTP) != BSEC_OK)) {
374 return true;
375 }
376
377 return (value & DATA0_OTP_SECURED) == DATA0_OTP_SECURED;
378}
379
Yann Gautier091eab52019-06-04 18:06:34 +0200380uint32_t stm32_iwdg_get_instance(uintptr_t base)
381{
382 switch (base) {
383 case IWDG1_BASE:
384 return IWDG1_INST;
385 case IWDG2_BASE:
386 return IWDG2_INST;
387 default:
388 panic();
389 }
390}
391
392uint32_t stm32_iwdg_get_otp_config(uint32_t iwdg_inst)
393{
394 uint32_t iwdg_cfg = 0U;
395 uint32_t otp_value;
396
397#if defined(IMAGE_BL2)
398 if (bsec_shadow_register(HW2_OTP) != BSEC_OK) {
399 panic();
400 }
401#endif
402
403 if (bsec_read_otp(&otp_value, HW2_OTP) != BSEC_OK) {
404 panic();
405 }
406
407 if ((otp_value & BIT(iwdg_inst + HW2_OTP_IWDG_HW_POS)) != 0U) {
408 iwdg_cfg |= IWDG_HW_ENABLED;
409 }
410
411 if ((otp_value & BIT(iwdg_inst + HW2_OTP_IWDG_FZ_STOP_POS)) != 0U) {
412 iwdg_cfg |= IWDG_DISABLE_ON_STOP;
413 }
414
415 if ((otp_value & BIT(iwdg_inst + HW2_OTP_IWDG_FZ_STANDBY_POS)) != 0U) {
416 iwdg_cfg |= IWDG_DISABLE_ON_STANDBY;
417 }
418
419 return iwdg_cfg;
420}
421
422#if defined(IMAGE_BL2)
423uint32_t stm32_iwdg_shadow_update(uint32_t iwdg_inst, uint32_t flags)
424{
425 uint32_t otp;
426 uint32_t result;
427
428 if (bsec_shadow_read_otp(&otp, HW2_OTP) != BSEC_OK) {
429 panic();
430 }
431
432 if ((flags & IWDG_DISABLE_ON_STOP) != 0U) {
433 otp |= BIT(iwdg_inst + HW2_OTP_IWDG_FZ_STOP_POS);
434 }
435
436 if ((flags & IWDG_DISABLE_ON_STANDBY) != 0U) {
437 otp |= BIT(iwdg_inst + HW2_OTP_IWDG_FZ_STANDBY_POS);
438 }
439
440 result = bsec_write_otp(otp, HW2_OTP);
441 if (result != BSEC_OK) {
442 return result;
443 }
444
445 /* Sticky lock OTP_IWDG (read and write) */
446 if (!bsec_write_sr_lock(HW2_OTP, 1U) ||
447 !bsec_write_sw_lock(HW2_OTP, 1U)) {
448 return BSEC_LOCK_FAIL;
449 }
450
451 return BSEC_OK;
452}
453#endif
Yann Gautier8f268c82020-02-26 13:39:44 +0100454
Lionel Debieve1dc5e2e2020-09-27 21:13:53 +0200455#if STM32MP_USE_STM32IMAGE
Yann Gautier8f268c82020-02-26 13:39:44 +0100456/* Get the non-secure DDR size */
457uint32_t stm32mp_get_ddr_ns_size(void)
458{
459 static uint32_t ddr_ns_size;
460 uint32_t ddr_size;
461
462 if (ddr_ns_size != 0U) {
463 return ddr_ns_size;
464 }
465
466 ddr_size = dt_get_ddr_size();
467 if ((ddr_size <= (STM32MP_DDR_S_SIZE + STM32MP_DDR_SHMEM_SIZE)) ||
468 (ddr_size > STM32MP_DDR_MAX_SIZE)) {
469 panic();
470 }
471
472 ddr_ns_size = ddr_size - (STM32MP_DDR_S_SIZE + STM32MP_DDR_SHMEM_SIZE);
473
474 return ddr_ns_size;
475}
Lionel Debieve1dc5e2e2020-09-27 21:13:53 +0200476#endif /* STM32MP_USE_STM32IMAGE */