1
2
3
4
5
6#define LOG_CATEGORY LOGC_ARCH
7
8#include <common.h>
9#include <clk.h>
10#include <cpu_func.h>
11#include <debug_uart.h>
12#include <env.h>
13#include <init.h>
14#include <log.h>
15#include <lmb.h>
16#include <misc.h>
17#include <net.h>
18#include <asm/io.h>
19#include <asm/arch/bsec.h>
20#include <asm/arch/stm32.h>
21#include <asm/arch/sys_proto.h>
22#include <asm/global_data.h>
23#include <dm/device.h>
24#include <dm/uclass.h>
25#include <linux/bitops.h>
26
27
28#define RCC_TZCR (STM32_RCC_BASE + 0x00)
29#define RCC_DBGCFGR (STM32_RCC_BASE + 0x080C)
30#define RCC_BDCR (STM32_RCC_BASE + 0x0140)
31#define RCC_MP_APB5ENSETR (STM32_RCC_BASE + 0x0208)
32#define RCC_MP_AHB5ENSETR (STM32_RCC_BASE + 0x0210)
33#define RCC_BDCR_VSWRST BIT(31)
34#define RCC_BDCR_RTCSRC GENMASK(17, 16)
35#define RCC_DBGCFGR_DBGCKEN BIT(8)
36
37
38#define ETZPC_TZMA1_SIZE (STM32_ETZPC_BASE + 0x04)
39#define ETZPC_DECPROT0 (STM32_ETZPC_BASE + 0x10)
40
41#define TZC_GATE_KEEPER (STM32_TZC_BASE + 0x008)
42#define TZC_REGION_ATTRIBUTE0 (STM32_TZC_BASE + 0x110)
43#define TZC_REGION_ID_ACCESS0 (STM32_TZC_BASE + 0x114)
44
45#define TAMP_CR1 (STM32_TAMP_BASE + 0x00)
46
47#define PWR_CR1 (STM32_PWR_BASE + 0x00)
48#define PWR_MCUCR (STM32_PWR_BASE + 0x14)
49#define PWR_CR1_DBP BIT(8)
50#define PWR_MCUCR_SBF BIT(6)
51
52
53#define DBGMCU_IDC (STM32_DBGMCU_BASE + 0x00)
54#define DBGMCU_APB4FZ1 (STM32_DBGMCU_BASE + 0x2C)
55#define DBGMCU_APB4FZ1_IWDG2 BIT(2)
56#define DBGMCU_IDC_DEV_ID_MASK GENMASK(11, 0)
57#define DBGMCU_IDC_DEV_ID_SHIFT 0
58#define DBGMCU_IDC_REV_ID_MASK GENMASK(31, 16)
59#define DBGMCU_IDC_REV_ID_SHIFT 16
60
61
62#define GPIOZ_SECCFGR 0x54004030
63
64
65
66
67
68#define BOOTROM_PARAM_ADDR 0x2FFC0078
69#define BOOTROM_MODE_MASK GENMASK(15, 0)
70#define BOOTROM_MODE_SHIFT 0
71#define BOOTROM_INSTANCE_MASK GENMASK(31, 16)
72#define BOOTROM_INSTANCE_SHIFT 16
73
74
75#define RPN_SHIFT 0
76#define RPN_MASK GENMASK(7, 0)
77
78
79
80
81
82
83
84
85#define PKG_SHIFT 27
86#define PKG_MASK GENMASK(2, 0)
87
88
89
90
91
92u8 early_tlb[PGTABLE_SIZE] __section(".data") __aligned(0x4000);
93
94struct lmb lmb;
95
96static void security_init(void)
97{
98
99
100
101 setbits_le32(PWR_CR1, PWR_CR1_DBP);
102
103 while (!(readl(PWR_CR1) & PWR_CR1_DBP))
104 ;
105
106
107
108
109 if (!(readl(RCC_BDCR) & RCC_BDCR_RTCSRC)) {
110 setbits_le32(RCC_BDCR, RCC_BDCR_VSWRST);
111 while (!(readl(RCC_BDCR) & RCC_BDCR_VSWRST))
112 ;
113 clrbits_le32(RCC_BDCR, RCC_BDCR_VSWRST);
114 }
115
116
117 writel(GENMASK(25, 0), ETZPC_DECPROT0);
118
119
120 writel(0x0, ETZPC_TZMA1_SIZE);
121
122
123 writel(BIT(11) | BIT(12), RCC_MP_APB5ENSETR);
124
125
126
127
128
129
130
131 writel(0xFFFFFFFF, TZC_REGION_ID_ACCESS0);
132
133
134 writel(BIT(0) | BIT(1) | BIT(30) | BIT(31), TZC_REGION_ATTRIBUTE0);
135
136
137 setbits_le32(TZC_GATE_KEEPER, BIT(0) | BIT(1));
138
139
140 writel(0x0, RCC_TZCR);
141
142
143
144
145
146
147
148
149 writel(0x0, TAMP_CR1);
150
151
152 writel(BIT(0), RCC_MP_AHB5ENSETR);
153 writel(0x0, GPIOZ_SECCFGR);
154}
155
156
157
158
159static void dbgmcu_init(void)
160{
161
162
163
164
165
166 if (bsec_dbgswenable()) {
167 setbits_le32(RCC_DBGCFGR, RCC_DBGCFGR_DBGCKEN);
168 setbits_le32(DBGMCU_APB4FZ1, DBGMCU_APB4FZ1_IWDG2);
169 }
170}
171
172void spl_board_init(void)
173{
174 struct udevice *dev;
175 int ret;
176
177 dbgmcu_init();
178
179
180 ret = uclass_get_device_by_driver(UCLASS_MISC, DM_DRIVER_GET(stm32mp_bsec), &dev);
181 if (ret)
182 log_warning("BSEC probe failed: %d\n", ret);
183}
184
185
186static void update_bootmode(void)
187{
188 u32 boot_mode;
189 u32 bootrom_itf = readl(BOOTROM_PARAM_ADDR);
190 u32 bootrom_device, bootrom_instance;
191
192
193 writel(BIT(8), RCC_MP_APB5ENSETR);
194
195
196 bootrom_device =
197 (bootrom_itf & BOOTROM_MODE_MASK) >> BOOTROM_MODE_SHIFT;
198 bootrom_instance =
199 (bootrom_itf & BOOTROM_INSTANCE_MASK) >> BOOTROM_INSTANCE_SHIFT;
200 boot_mode =
201 ((bootrom_device << BOOT_TYPE_SHIFT) & BOOT_TYPE_MASK) |
202 ((bootrom_instance << BOOT_INSTANCE_SHIFT) &
203 BOOT_INSTANCE_MASK);
204
205
206 clrsetbits_le32(TAMP_BOOT_CONTEXT,
207 TAMP_BOOT_MODE_MASK,
208 boot_mode << TAMP_BOOT_MODE_SHIFT);
209}
210
211u32 get_bootmode(void)
212{
213
214 return (readl(TAMP_BOOT_CONTEXT) & TAMP_BOOT_MODE_MASK) >>
215 TAMP_BOOT_MODE_SHIFT;
216}
217
218
219
220
221
222void dram_bank_mmu_setup(int bank)
223{
224 struct bd_info *bd = gd->bd;
225 int i;
226 phys_addr_t start;
227 phys_size_t size;
228 bool use_lmb = false;
229 enum dcache_option option;
230
231 if (IS_ENABLED(CONFIG_SPL_BUILD)) {
232 start = ALIGN_DOWN(STM32_SYSRAM_BASE, MMU_SECTION_SIZE);
233 size = ALIGN(STM32_SYSRAM_SIZE, MMU_SECTION_SIZE);
234 } else if (gd->flags & GD_FLG_RELOC) {
235
236 start = bd->bi_dram[bank].start;
237 size = bd->bi_dram[bank].size;
238 use_lmb = true;
239 } else {
240
241 start = STM32_DDR_BASE;
242 size = CONFIG_DDR_CACHEABLE_SIZE;
243 }
244
245 for (i = start >> MMU_SECTION_SHIFT;
246 i < (start >> MMU_SECTION_SHIFT) + (size >> MMU_SECTION_SHIFT);
247 i++) {
248 option = DCACHE_DEFAULT_OPTION;
249 if (use_lmb && lmb_is_reserved_flags(&lmb, i << MMU_SECTION_SHIFT, LMB_NOMAP))
250 option = 0;
251 set_section_dcache(i, option);
252 }
253}
254
255
256
257
258
259static void early_enable_caches(void)
260{
261
262
263 if (CONFIG_IS_ENABLED(SYS_DCACHE_OFF))
264 return;
265
266 if (!(CONFIG_IS_ENABLED(SYS_ICACHE_OFF) && CONFIG_IS_ENABLED(SYS_DCACHE_OFF))) {
267 gd->arch.tlb_size = PGTABLE_SIZE;
268 gd->arch.tlb_addr = (unsigned long)&early_tlb;
269 }
270
271
272 dcache_enable();
273}
274
275
276
277
278int arch_cpu_init(void)
279{
280 u32 boot_mode;
281
282 early_enable_caches();
283
284
285 timer_init();
286
287 if (IS_ENABLED(CONFIG_SPL_BUILD)) {
288 security_init();
289 update_bootmode();
290 }
291
292 if (!IS_ENABLED(CONFIG_SPL) || IS_ENABLED(CONFIG_SPL_BUILD)) {
293
294 if (!(readl(PWR_MCUCR) & PWR_MCUCR_SBF)) {
295 writel(TAMP_COPRO_STATE_OFF, TAMP_COPRO_STATE);
296 writel(0, TAMP_COPRO_RSC_TBL_ADDRESS);
297 }
298 }
299
300 boot_mode = get_bootmode();
301
302 if (IS_ENABLED(CONFIG_CMD_STM32PROG_SERIAL) &&
303 (boot_mode & TAMP_BOOT_DEVICE_MASK) == BOOT_SERIAL_UART)
304 gd->flags |= GD_FLG_SILENT | GD_FLG_DISABLE_CONSOLE;
305 else if (IS_ENABLED(CONFIG_DEBUG_UART) && IS_ENABLED(CONFIG_SPL_BUILD))
306 debug_uart_init();
307
308 return 0;
309}
310
311void enable_caches(void)
312{
313
314 lmb_init_and_reserve(&lmb, gd->bd, (void *)gd->fdt_blob);
315
316
317
318
319 dcache_disable();
320
321
322
323
324 dcache_enable();
325}
326
327static u32 read_idc(void)
328{
329
330 if (bsec_dbgswenable()) {
331 setbits_le32(RCC_DBGCFGR, RCC_DBGCFGR_DBGCKEN);
332
333 return readl(DBGMCU_IDC);
334 }
335
336 if (CONFIG_IS_ENABLED(STM32MP15x))
337 return CPU_DEV_STM32MP15;
338 else
339 return 0x0;
340}
341
342u32 get_cpu_dev(void)
343{
344 return (read_idc() & DBGMCU_IDC_DEV_ID_MASK) >> DBGMCU_IDC_DEV_ID_SHIFT;
345}
346
347u32 get_cpu_rev(void)
348{
349 return (read_idc() & DBGMCU_IDC_REV_ID_MASK) >> DBGMCU_IDC_REV_ID_SHIFT;
350}
351
352static u32 get_otp(int index, int shift, int mask)
353{
354 int ret;
355 struct udevice *dev;
356 u32 otp = 0;
357
358 ret = uclass_get_device_by_driver(UCLASS_MISC,
359 DM_DRIVER_GET(stm32mp_bsec),
360 &dev);
361
362 if (!ret)
363 ret = misc_read(dev, STM32_BSEC_SHADOW(index),
364 &otp, sizeof(otp));
365
366 return (otp >> shift) & mask;
367}
368
369
370static u32 get_cpu_rpn(void)
371{
372 return get_otp(BSEC_OTP_RPN, RPN_SHIFT, RPN_MASK);
373}
374
375u32 get_cpu_type(void)
376{
377 return (get_cpu_dev() << 16) | get_cpu_rpn();
378}
379
380
381u32 get_cpu_package(void)
382{
383 return get_otp(BSEC_OTP_PKG, PKG_SHIFT, PKG_MASK);
384}
385
386static const char * const soc_type[] = {
387 "????",
388 "151C", "151A", "151F", "151D",
389 "153C", "153A", "153F", "153D",
390 "157C", "157A", "157F", "157D"
391};
392
393static const char * const soc_pkg[] = { "??", "AD", "AC", "AB", "AA" };
394static const char * const soc_rev[] = { "?", "A", "B", "Z" };
395
396static void get_cpu_string_offsets(unsigned int *type, unsigned int *pkg,
397 unsigned int *rev)
398{
399 u32 cpu_type = get_cpu_type();
400 u32 ct = cpu_type & ~(BIT(7) | BIT(0));
401 u32 cm = ((cpu_type & BIT(7)) >> 6) | (cpu_type & BIT(0));
402 u32 cp = get_cpu_package();
403
404
405 switch (ct) {
406 case CPU_STM32MP151Cxx:
407 *type = cm + 1;
408 break;
409 case CPU_STM32MP153Cxx:
410 *type = cm + 5;
411 break;
412 case CPU_STM32MP157Cxx:
413 *type = cm + 9;
414 break;
415 default:
416 *type = 0;
417 break;
418 }
419
420
421 switch (cp) {
422 case PKG_AA_LBGA448:
423 case PKG_AB_LBGA354:
424 case PKG_AC_TFBGA361:
425 case PKG_AD_TFBGA257:
426 *pkg = cp;
427 break;
428 default:
429 *pkg = 0;
430 break;
431 }
432
433
434 switch (get_cpu_rev()) {
435 case CPU_REVA:
436 *rev = 1;
437 break;
438 case CPU_REVB:
439 *rev = 2;
440 break;
441 case CPU_REVZ:
442 *rev = 3;
443 break;
444 default:
445 *rev = 0;
446 break;
447 }
448}
449
450void get_soc_name(char name[SOC_NAME_SIZE])
451{
452 unsigned int type, pkg, rev;
453
454 get_cpu_string_offsets(&type, &pkg, &rev);
455
456 snprintf(name, SOC_NAME_SIZE, "STM32MP%s%s Rev.%s",
457 soc_type[type], soc_pkg[pkg], soc_rev[rev]);
458}
459
460
461int print_cpuinfo(void)
462{
463 char name[SOC_NAME_SIZE];
464
465 get_soc_name(name);
466 printf("CPU: %s\n", name);
467
468 return 0;
469}
470
471static void setup_boot_mode(void)
472{
473 const u32 serial_addr[] = {
474 STM32_USART1_BASE,
475 STM32_USART2_BASE,
476 STM32_USART3_BASE,
477 STM32_UART4_BASE,
478 STM32_UART5_BASE,
479 STM32_USART6_BASE,
480 STM32_UART7_BASE,
481 STM32_UART8_BASE
482 };
483 const u32 sdmmc_addr[] = {
484 STM32_SDMMC1_BASE,
485 STM32_SDMMC2_BASE,
486 STM32_SDMMC3_BASE
487 };
488 char cmd[60];
489 u32 boot_ctx = readl(TAMP_BOOT_CONTEXT);
490 u32 boot_mode =
491 (boot_ctx & TAMP_BOOT_MODE_MASK) >> TAMP_BOOT_MODE_SHIFT;
492 unsigned int instance = (boot_mode & TAMP_BOOT_INSTANCE_MASK) - 1;
493 u32 forced_mode = (boot_ctx & TAMP_BOOT_FORCED_MASK);
494 struct udevice *dev;
495
496 log_debug("%s: boot_ctx=0x%x => boot_mode=%x, instance=%d forced=%x\n",
497 __func__, boot_ctx, boot_mode, instance, forced_mode);
498 switch (boot_mode & TAMP_BOOT_DEVICE_MASK) {
499 case BOOT_SERIAL_UART:
500 if (instance > ARRAY_SIZE(serial_addr))
501 break;
502
503 sprintf(cmd, "serial@%x", serial_addr[instance]);
504 if (uclass_get_device_by_name(UCLASS_SERIAL, cmd, &dev)) {
505
506 if (IS_ENABLED(CONFIG_CMD_STM32PROG_SERIAL))
507 gd->flags &= ~(GD_FLG_SILENT |
508 GD_FLG_DISABLE_CONSOLE);
509 log_err("uart%d = %s not found in device tree!\n",
510 instance + 1, cmd);
511 break;
512 }
513 sprintf(cmd, "%d", dev_seq(dev));
514 env_set("boot_device", "serial");
515 env_set("boot_instance", cmd);
516
517
518 if (IS_ENABLED(CONFIG_CMD_STM32PROG_SERIAL) && gd->cur_serial_dev != dev) {
519 gd->flags &= ~(GD_FLG_SILENT |
520 GD_FLG_DISABLE_CONSOLE);
521 log_info("serial boot with console enabled!\n");
522 }
523 break;
524 case BOOT_SERIAL_USB:
525 env_set("boot_device", "usb");
526 env_set("boot_instance", "0");
527 break;
528 case BOOT_FLASH_SD:
529 case BOOT_FLASH_EMMC:
530 if (instance > ARRAY_SIZE(sdmmc_addr))
531 break;
532
533 sprintf(cmd, "mmc@%x", sdmmc_addr[instance]);
534 if (uclass_get_device_by_name(UCLASS_MMC, cmd, &dev)) {
535 printf("mmc%d = %s not found in device tree!\n",
536 instance, cmd);
537 break;
538 }
539 sprintf(cmd, "%d", dev_seq(dev));
540 env_set("boot_device", "mmc");
541 env_set("boot_instance", cmd);
542 break;
543 case BOOT_FLASH_NAND:
544 env_set("boot_device", "nand");
545 env_set("boot_instance", "0");
546 break;
547 case BOOT_FLASH_SPINAND:
548 env_set("boot_device", "spi-nand");
549 env_set("boot_instance", "0");
550 break;
551 case BOOT_FLASH_NOR:
552 env_set("boot_device", "nor");
553 env_set("boot_instance", "0");
554 break;
555 default:
556 env_set("boot_device", "invalid");
557 env_set("boot_instance", "");
558 log_err("unexpected boot mode = %x\n", boot_mode);
559 break;
560 }
561
562 switch (forced_mode) {
563 case BOOT_FASTBOOT:
564 log_info("Enter fastboot!\n");
565 env_set("preboot", "env set preboot; fastboot 0");
566 break;
567 case BOOT_STM32PROG:
568 env_set("boot_device", "usb");
569 env_set("boot_instance", "0");
570 break;
571 case BOOT_UMS_MMC0:
572 case BOOT_UMS_MMC1:
573 case BOOT_UMS_MMC2:
574 log_info("Enter UMS!\n");
575 instance = forced_mode - BOOT_UMS_MMC0;
576 sprintf(cmd, "env set preboot; ums 0 mmc %d", instance);
577 env_set("preboot", cmd);
578 break;
579 case BOOT_RECOVERY:
580 env_set("preboot", "env set preboot; run altbootcmd");
581 break;
582 case BOOT_NORMAL:
583 break;
584 default:
585 log_debug("unexpected forced boot mode = %x\n", forced_mode);
586 break;
587 }
588
589
590 clrsetbits_le32(TAMP_BOOT_CONTEXT, TAMP_BOOT_FORCED_MASK, BOOT_NORMAL);
591}
592
593
594
595
596
597__weak int setup_mac_address(void)
598{
599 int ret;
600 int i;
601 u32 otp[2];
602 uchar enetaddr[6];
603 struct udevice *dev;
604
605 if (!IS_ENABLED(CONFIG_NET))
606 return 0;
607
608
609 if (eth_env_get_enetaddr("ethaddr", enetaddr))
610 return 0;
611
612 ret = uclass_get_device_by_driver(UCLASS_MISC,
613 DM_DRIVER_GET(stm32mp_bsec),
614 &dev);
615 if (ret)
616 return ret;
617
618 ret = misc_read(dev, STM32_BSEC_SHADOW(BSEC_OTP_MAC),
619 otp, sizeof(otp));
620 if (ret < 0)
621 return ret;
622
623 for (i = 0; i < 6; i++)
624 enetaddr[i] = ((uint8_t *)&otp)[i];
625
626 if (!is_valid_ethaddr(enetaddr)) {
627 log_err("invalid MAC address in OTP %pM\n", enetaddr);
628 return -EINVAL;
629 }
630 log_debug("OTP MAC address = %pM\n", enetaddr);
631 ret = eth_env_set_enetaddr("ethaddr", enetaddr);
632 if (ret)
633 log_err("Failed to set mac address %pM from OTP: %d\n", enetaddr, ret);
634
635 return 0;
636}
637
638static int setup_serial_number(void)
639{
640 char serial_string[25];
641 u32 otp[3] = {0, 0, 0 };
642 struct udevice *dev;
643 int ret;
644
645 if (env_get("serial#"))
646 return 0;
647
648 ret = uclass_get_device_by_driver(UCLASS_MISC,
649 DM_DRIVER_GET(stm32mp_bsec),
650 &dev);
651 if (ret)
652 return ret;
653
654 ret = misc_read(dev, STM32_BSEC_SHADOW(BSEC_OTP_SERIAL),
655 otp, sizeof(otp));
656 if (ret < 0)
657 return ret;
658
659 sprintf(serial_string, "%08X%08X%08X", otp[0], otp[1], otp[2]);
660 env_set("serial#", serial_string);
661
662 return 0;
663}
664
665static void setup_soc_type_pkg_rev(void)
666{
667 unsigned int type, pkg, rev;
668
669 get_cpu_string_offsets(&type, &pkg, &rev);
670
671 env_set("soc_type", soc_type[type]);
672 env_set("soc_pkg", soc_pkg[pkg]);
673 env_set("soc_rev", soc_rev[rev]);
674}
675
676int arch_misc_init(void)
677{
678 setup_boot_mode();
679 setup_mac_address();
680 setup_serial_number();
681 setup_soc_type_pkg_rev();
682
683 return 0;
684}
685