1// SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause 2/* 3 * Copyright (C) 2018, STMicroelectronics - All Rights Reserved 4 */ 5 6#define LOG_CATEGORY LOGC_BOARD 7 8#include <common.h> 9#include <adc.h> 10#include <bootm.h> 11#include <button.h> 12#include <clk.h> 13#include <config.h> 14#include <dm.h> 15#include <efi_loader.h> 16#include <env.h> 17#include <env_internal.h> 18#include <fdt_simplefb.h> 19#include <fdt_support.h> 20#include <g_dnl.h> 21#include <generic-phy.h> 22#include <hang.h> 23#include <i2c.h> 24#include <init.h> 25#include <led.h> 26#include <log.h> 27#include <malloc.h> 28#include <misc.h> 29#include <net.h> 30#include <netdev.h> 31#include <phy.h> 32#include <remoteproc.h> 33#include <reset.h> 34#include <syscon.h> 35#include <usb.h> 36#include <watchdog.h> 37#include <asm/global_data.h> 38#include <asm/io.h> 39#include <asm/gpio.h> 40#include <asm/arch/stm32.h> 41#include <asm/arch/sys_proto.h> 42#include <dm/device-internal.h> 43#include <dm/ofnode.h> 44#include <jffs2/load_kernel.h> 45#include <linux/bitops.h> 46#include <linux/delay.h> 47#include <linux/err.h> 48#include <linux/iopoll.h> 49#include <linux/printk.h> 50#include <power/regulator.h> 51#include <usb/dwc2_udc.h> 52 53#include "../../st/common/stusb160x.h" 54 55/* SYSCFG registers */ 56#define SYSCFG_BOOTR 0x00 57#define SYSCFG_IOCTRLSETR 0x18 58#define SYSCFG_ICNR 0x1C 59#define SYSCFG_CMPCR 0x20 60#define SYSCFG_CMPENSETR 0x24 61 62#define SYSCFG_BOOTR_BOOT_MASK GENMASK(2, 0) 63#define SYSCFG_BOOTR_BOOTPD_SHIFT 4 64 65#define SYSCFG_IOCTRLSETR_HSLVEN_TRACE BIT(0) 66#define SYSCFG_IOCTRLSETR_HSLVEN_QUADSPI BIT(1) 67#define SYSCFG_IOCTRLSETR_HSLVEN_ETH BIT(2) 68#define SYSCFG_IOCTRLSETR_HSLVEN_SDMMC BIT(3) 69#define SYSCFG_IOCTRLSETR_HSLVEN_SPI BIT(4) 70 71#define SYSCFG_CMPCR_SW_CTRL BIT(1) 72#define SYSCFG_CMPCR_READY BIT(8) 73 74#define SYSCFG_CMPENSETR_MPU_EN BIT(0) 75 76#define USB_LOW_THRESHOLD_UV 200000 77#define USB_WARNING_LOW_THRESHOLD_UV 660000 78#define USB_START_LOW_THRESHOLD_UV 1230000 79#define USB_START_HIGH_THRESHOLD_UV 2150000 80 81#if IS_ENABLED(CONFIG_EFI_HAVE_CAPSULE_SUPPORT) 82struct efi_fw_image fw_images[1]; 83 84struct efi_capsule_update_info update_info = { 85 .num_images = ARRAY_SIZE(fw_images), 86 .images = fw_images, 87}; 88 89#endif /* EFI_HAVE_CAPSULE_SUPPORT */ 90 91int board_early_init_f(void) 92{ 93 /* nothing to do, only used in SPL */ 94 return 0; 95} 96 97int checkboard(void) 98{ 99 int ret; 100 char *mode; 101 u32 otp; 102 struct udevice *dev; 103 const char *fdt_compat; 104 int fdt_compat_len; 105 106 if (IS_ENABLED(CONFIG_TFABOOT)) { 107 if (IS_ENABLED(CONFIG_STM32MP15X_STM32IMAGE)) 108 mode = "trusted - stm32image"; 109 else 110 mode = "trusted"; 111 } else { 112 mode = "basic"; 113 } 114 115 fdt_compat = ofnode_get_property(ofnode_root(), "compatible", 116 &fdt_compat_len); 117 118 log_info("Board: stm32mp1 in %s mode (%s)\n", mode, 119 fdt_compat && fdt_compat_len ? fdt_compat : ""); 120 121 /* display the STMicroelectronics board identification */ 122 if (IS_ENABLED(CONFIG_CMD_STBOARD)) { 123 ret = uclass_get_device_by_driver(UCLASS_MISC, 124 DM_DRIVER_GET(stm32mp_bsec), 125 &dev); 126 if (!ret) 127 ret = misc_read(dev, STM32_BSEC_SHADOW(BSEC_OTP_BOARD), 128 &otp, sizeof(otp)); 129 if (ret > 0 && otp) 130 log_info("Board: MB%04x Var%d.%d Rev.%c-%02d\n", 131 otp >> 16, 132 (otp >> 12) & 0xF, 133 (otp >> 4) & 0xF, 134 ((otp >> 8) & 0xF) - 1 + 'A', 135 otp & 0xF); 136 } 137 138 return 0; 139} 140 141static void board_key_check(void) 142{ 143 struct udevice *button1 = NULL, *button2 = NULL; 144 enum forced_boot_mode boot_mode = BOOT_NORMAL; 145 int ret; 146 147 if (!IS_ENABLED(CONFIG_BUTTON)) 148 return; 149 150 if (!IS_ENABLED(CONFIG_FASTBOOT) && !IS_ENABLED(CONFIG_CMD_STM32PROG)) 151 return; 152 153 if (IS_ENABLED(CONFIG_CMD_STM32PROG)) 154 button_get_by_label("User-1", &button1); 155 156 if (IS_ENABLED(CONFIG_FASTBOOT)) 157 button_get_by_label("User-2", &button2); 158 159 if (!button1 && !button2) 160 return; 161 162 if (button2) { 163 if (button_get_state(button2) == BUTTON_ON) { 164 log_notice("Fastboot key pressed, "); 165 boot_mode = BOOT_FASTBOOT; 166 } 167 /* 168 * On some boards, same gpio is shared betwwen gpio-keys and 169 * leds, remove the button device to free the gpio for led 170 * usage 171 */ 172 ret = device_remove(button2, DM_REMOVE_NORMAL); 173 if (ret) 174 log_err("Can't remove button2 (%d)\n", ret); 175 } 176 177 if (button1) { 178 if (button_get_state(button1) == BUTTON_ON) { 179 log_notice("STM32Programmer key pressed, "); 180 boot_mode = BOOT_STM32PROG; 181 } 182 /* 183 * On some boards, same gpio is shared betwwen gpio-keys and 184 * leds, remove the button device to free the gpio for led 185 * usage 186 */ 187 ret = device_remove(button1, DM_REMOVE_NORMAL); 188 if (ret) 189 log_err("Can't remove button1 (%d)\n", ret); 190 } 191 192 if (boot_mode != BOOT_NORMAL) { 193 log_notice("entering download mode...\n"); 194 clrsetbits_le32(TAMP_BOOT_CONTEXT, 195 TAMP_BOOT_FORCED_MASK, 196 boot_mode); 197 } 198} 199 200int g_dnl_board_usb_cable_connected(void) 201{ 202 struct udevice *dwc2_udc_otg; 203 int ret; 204 205 if (!IS_ENABLED(CONFIG_USB_GADGET_DWC2_OTG)) 206 return -ENODEV; 207 208 /* 209 * In case of USB boot device is detected, consider USB cable is 210 * connected 211 */ 212 if ((get_bootmode() & TAMP_BOOT_DEVICE_MASK) == BOOT_SERIAL_USB) 213 return true; 214 215 /* if typec stusb160x is present, means DK1 or DK2 board */ 216 ret = stusb160x_cable_connected(); 217 if (ret >= 0) 218 return ret; 219 220 ret = uclass_get_device_by_driver(UCLASS_USB_GADGET_GENERIC, 221 DM_DRIVER_GET(dwc2_udc_otg), 222 &dwc2_udc_otg); 223 if (ret) { 224 log_debug("dwc2_udc_otg init failed\n"); 225 return ret; 226 } 227 228 return dwc2_udc_B_session_valid(dwc2_udc_otg); 229} 230 231#ifdef CONFIG_USB_GADGET_DOWNLOAD 232#define STM32MP1_G_DNL_DFU_PRODUCT_NUM 0xdf11 233#define STM32MP1_G_DNL_FASTBOOT_PRODUCT_NUM 0x0afb 234 235int g_dnl_bind_fixup(struct usb_device_descriptor *dev, const char *name) 236{ 237 if (IS_ENABLED(CONFIG_DFU_OVER_USB) && 238 !strcmp(name, "usb_dnl_dfu")) 239 put_unaligned(STM32MP1_G_DNL_DFU_PRODUCT_NUM, &dev->idProduct); 240 else if (IS_ENABLED(CONFIG_FASTBOOT) && 241 !strcmp(name, "usb_dnl_fastboot")) 242 put_unaligned(STM32MP1_G_DNL_FASTBOOT_PRODUCT_NUM, 243 &dev->idProduct); 244 else 245 put_unaligned(CONFIG_USB_GADGET_PRODUCT_NUM, &dev->idProduct); 246 247 return 0; 248} 249#endif /* CONFIG_USB_GADGET_DOWNLOAD */ 250 251static int get_led(struct udevice **dev, char *led_string) 252{ 253 const char *led_name; 254 int ret; 255 256 led_name = ofnode_conf_read_str(led_string); 257 if (!led_name) { 258 log_debug("could not find %s config string\n", led_string); 259 return -ENOENT; 260 } 261 ret = led_get_by_label(led_name, dev); 262 if (ret) { 263 log_debug("get=%d\n", ret); 264 return ret; 265 } 266 267 return 0; 268} 269 270static int setup_led(enum led_state_t cmd) 271{ 272 struct udevice *dev; 273 int ret; 274 275 if (!CONFIG_IS_ENABLED(LED)) 276 return 0; 277 278 ret = get_led(&dev, "u-boot,boot-led"); 279 if (ret) 280 return ret; 281 282 ret = led_set_state(dev, cmd); 283 return ret; 284} 285 286static void __maybe_unused led_error_blink(u32 nb_blink) 287{ 288 int ret; 289 struct udevice *led; 290 u32 i; 291 292 if (!nb_blink) 293 return; 294 295 if (CONFIG_IS_ENABLED(LED)) { 296 ret = get_led(&led, "u-boot,error-led"); 297 if (!ret) { 298 /* make u-boot,error-led blinking */ 299 /* if U32_MAX and 125ms interval, for 17.02 years */ 300 for (i = 0; i < 2 * nb_blink; i++) { 301 led_set_state(led, LEDST_TOGGLE); 302 mdelay(125); 303 schedule(); 304 } 305 led_set_state(led, LEDST_ON); 306 } 307 } 308 309 /* infinite: the boot process must be stopped */ 310 if (nb_blink == U32_MAX) 311 hang(); 312} 313 314static int adc_measurement(ofnode node, int adc_count, int *min_uV, int *max_uV) 315{ 316 struct ofnode_phandle_args adc_args; 317 struct udevice *adc; 318 unsigned int raw; 319 int ret, uV; 320 int i; 321 322 for (i = 0; i < adc_count; i++) { 323 if (ofnode_parse_phandle_with_args(node, "st,adc_usb_pd", 324 "#io-channel-cells", 0, i, 325 &adc_args)) { 326 log_debug("can't find /config/st,adc_usb_pd\n"); 327 return 0; 328 } 329 330 ret = uclass_get_device_by_ofnode(UCLASS_ADC, adc_args.node, 331 &adc); 332 333 if (ret) { 334 log_err("Can't get adc device(%d)\n", ret); 335 return ret; 336 } 337 338 ret = adc_channel_single_shot(adc->name, adc_args.args[0], 339 &raw); 340 if (ret) { 341 log_err("single shot failed for %s[%d]!\n", 342 adc->name, adc_args.args[0]); 343 return ret; 344 } 345 /* Convert to uV */ 346 if (!adc_raw_to_uV(adc, raw, &uV)) { 347 if (uV > *max_uV) 348 *max_uV = uV; 349 if (uV < *min_uV) 350 *min_uV = uV; 351 log_debug("%s[%02d] = %u, %d uV\n", 352 adc->name, adc_args.args[0], raw, uV); 353 } else { 354 log_err("Can't get uV value for %s[%d]\n", 355 adc->name, adc_args.args[0]); 356 } 357 } 358 359 return 0; 360} 361 362static int board_check_usb_power(void) 363{ 364 ofnode node; 365 int max_uV = 0; 366 int min_uV = USB_START_HIGH_THRESHOLD_UV; 367 int adc_count, ret; 368 u32 nb_blink; 369 u8 i; 370 371 if (!IS_ENABLED(CONFIG_ADC)) 372 return -ENODEV; 373 374 node = ofnode_path("/config"); 375 if (!ofnode_valid(node)) { 376 log_debug("no /config node?\n"); 377 return -ENOENT; 378 } 379 380 /* 381 * Retrieve the ADC channels devices and get measurement 382 * for each of them 383 */ 384 adc_count = ofnode_count_phandle_with_args(node, "st,adc_usb_pd", 385 "#io-channel-cells", 0); 386 if (adc_count < 0) { 387 if (adc_count == -ENOENT) 388 return 0; 389 390 log_err("Can't find adc channel (%d)\n", adc_count); 391 392 return adc_count; 393 } 394 395 /* perform maximum of 2 ADC measurements to detect power supply current */ 396 for (i = 0; i < 2; i++) { 397 ret = adc_measurement(node, adc_count, &min_uV, &max_uV); 398 if (ret) 399 return ret; 400 401 /* 402 * If highest value is inside 1.23 Volts and 2.10 Volts, that means 403 * board is plugged on an USB-C 3A power supply and boot process can 404 * continue. 405 */ 406 if (max_uV > USB_START_LOW_THRESHOLD_UV && 407 max_uV <= USB_START_HIGH_THRESHOLD_UV && 408 min_uV <= USB_LOW_THRESHOLD_UV) 409 return 0; 410 411 if (i == 0) { 412 log_err("Previous ADC measurements was not the one expected, retry in 20ms\n"); 413 mdelay(20); /* equal to max tPDDebounce duration (min 10ms - max 20ms) */ 414 } 415 } 416 417 log_notice("****************************************************\n"); 418 /* 419 * If highest and lowest value are either both below 420 * USB_LOW_THRESHOLD_UV or both above USB_LOW_THRESHOLD_UV, that 421 * means USB TYPE-C is in unattached mode, this is an issue, make 422 * u-boot,error-led blinking and stop boot process. 423 */ 424 if ((max_uV > USB_LOW_THRESHOLD_UV && 425 min_uV > USB_LOW_THRESHOLD_UV) || 426 (max_uV <= USB_LOW_THRESHOLD_UV && 427 min_uV <= USB_LOW_THRESHOLD_UV)) { 428 log_notice("* ERROR USB TYPE-C connection in unattached mode *\n"); 429 log_notice("* Check that USB TYPE-C cable is correctly plugged *\n"); 430 /* with 125ms interval, led will blink for 17.02 years ....*/ 431 nb_blink = U32_MAX; 432 } 433 434 if (max_uV > USB_LOW_THRESHOLD_UV && 435 max_uV <= USB_WARNING_LOW_THRESHOLD_UV && 436 min_uV <= USB_LOW_THRESHOLD_UV) { 437 log_notice("* WARNING 500mA power supply detected *\n"); 438 nb_blink = 2; 439 } 440 441 if (max_uV > USB_WARNING_LOW_THRESHOLD_UV && 442 max_uV <= USB_START_LOW_THRESHOLD_UV && 443 min_uV <= USB_LOW_THRESHOLD_UV) { 444 log_notice("* WARNING 1.5A power supply detected *\n"); 445 nb_blink = 3; 446 } 447 448 /* 449 * If highest value is above 2.15 Volts that means that the USB TypeC 450 * supplies more than 3 Amp, this is not compliant with TypeC specification 451 */ 452 if (max_uV > USB_START_HIGH_THRESHOLD_UV) { 453 log_notice("* USB TYPE-C charger not compliant with *\n"); 454 log_notice("* specification *\n"); 455 log_notice("****************************************************\n\n"); 456 /* with 125ms interval, led will blink for 17.02 years ....*/ 457 nb_blink = U32_MAX; 458 } else { 459 log_notice("* Current too low, use a 3A power supply! *\n"); 460 log_notice("****************************************************\n\n"); 461 } 462 463 led_error_blink(nb_blink); 464 465 return 0; 466} 467 468static void sysconf_init(void) 469{ 470 u8 *syscfg; 471 struct udevice *pwr_dev; 472 struct udevice *pwr_reg; 473 struct udevice *dev; 474 u32 otp = 0; 475 int ret; 476 u32 bootr, val; 477 478 syscfg = (u8 *)syscon_get_first_range(STM32MP_SYSCON_SYSCFG); 479 480 /* interconnect update : select master using the port 1 */ 481 /* LTDC = AXI_M9 */ 482 /* GPU = AXI_M8 */ 483 /* today information is hardcoded in U-Boot */ 484 writel(BIT(9), syscfg + SYSCFG_ICNR); 485 486 /* disable Pull-Down for boot pin connected to VDD */ 487 bootr = readl(syscfg + SYSCFG_BOOTR); 488 bootr &= ~(SYSCFG_BOOTR_BOOT_MASK << SYSCFG_BOOTR_BOOTPD_SHIFT); 489 bootr |= (bootr & SYSCFG_BOOTR_BOOT_MASK) << SYSCFG_BOOTR_BOOTPD_SHIFT; 490 writel(bootr, syscfg + SYSCFG_BOOTR); 491 492 /* High Speed Low Voltage Pad mode Enable for SPI, SDMMC, ETH, QSPI 493 * and TRACE. Needed above ~50MHz and conditioned by AFMUX selection. 494 * The customer will have to disable this for low frequencies 495 * or if AFMUX is selected but the function not used, typically for 496 * TRACE. Otherwise, impact on power consumption. 497 * 498 * WARNING: 499 * enabling High Speed mode while VDD>2.7V 500 * with the OTP product_below_2v5 (OTP 18, BIT 13) 501 * erroneously set to 1 can damage the IC! 502 * => U-Boot set the register only if VDD < 2.7V (in DT) 503 * but this value need to be consistent with board design 504 */ 505 ret = uclass_get_device_by_driver(UCLASS_PMIC, 506 DM_DRIVER_GET(stm32mp_pwr_pmic), 507 &pwr_dev); 508 if (!ret) { 509 ret = uclass_get_device_by_driver(UCLASS_MISC, 510 DM_DRIVER_GET(stm32mp_bsec), 511 &dev); 512 if (ret) { 513 log_err("Can't find stm32mp_bsec driver\n"); 514 return; 515 } 516 517 ret = misc_read(dev, STM32_BSEC_SHADOW(18), &otp, 4); 518 if (ret > 0) 519 otp = otp & BIT(13); 520 521 /* get VDD = vdd-supply */ 522 ret = device_get_supply_regulator(pwr_dev, "vdd-supply", 523 &pwr_reg); 524 525 /* check if VDD is Low Voltage */ 526 if (!ret) { 527 if (regulator_get_value(pwr_reg) < 2700000) { 528 writel(SYSCFG_IOCTRLSETR_HSLVEN_TRACE | 529 SYSCFG_IOCTRLSETR_HSLVEN_QUADSPI | 530 SYSCFG_IOCTRLSETR_HSLVEN_ETH | 531 SYSCFG_IOCTRLSETR_HSLVEN_SDMMC | 532 SYSCFG_IOCTRLSETR_HSLVEN_SPI, 533 syscfg + SYSCFG_IOCTRLSETR); 534 535 if (!otp) 536 log_err("product_below_2v5=0: HSLVEN protected by HW\n"); 537 } else { 538 if (otp) 539 log_err("product_below_2v5=1: HSLVEN update is destructive, no update as VDD>2.7V\n"); 540 } 541 } else { 542 log_debug("VDD unknown"); 543 } 544 } 545 546 /* activate automatic I/O compensation 547 * warning: need to ensure CSI enabled and ready in clock driver 548 */ 549 writel(SYSCFG_CMPENSETR_MPU_EN, syscfg + SYSCFG_CMPENSETR); 550 551 /* poll until ready (1s timeout) */ 552 ret = readl_poll_timeout(syscfg + SYSCFG_CMPCR, val, 553 val & SYSCFG_CMPCR_READY, 554 1000000); 555 if (ret) { 556 log_err("SYSCFG: I/O compensation failed, timeout.\n"); 557 led_error_blink(10); 558 } 559 560 clrbits_le32(syscfg + SYSCFG_CMPCR, SYSCFG_CMPCR_SW_CTRL); 561} 562 563static int board_stm32mp15x_dk2_init(void) 564{ 565 ofnode node; 566 struct gpio_desc hdmi, audio; 567 int ret = 0; 568 569 /* Fix to make I2C1 usable on DK2 for touchscreen usage in kernel */ 570 node = ofnode_path("/soc/i2c@40012000/hdmi-transmitter@39"); 571 if (!ofnode_valid(node)) { 572 log_debug("no hdmi-transmitter@39 ?\n"); 573 return -ENOENT; 574 } 575 576 if (gpio_request_by_name_nodev(node, "reset-gpios", 0, 577 &hdmi, GPIOD_IS_OUT)) { 578 log_debug("could not find reset-gpios\n"); 579 return -ENOENT; 580 } 581 582 node = ofnode_path("/soc/i2c@40012000/cs42l51@4a"); 583 if (!ofnode_valid(node)) { 584 log_debug("no cs42l51@4a ?\n"); 585 return -ENOENT; 586 } 587 588 if (gpio_request_by_name_nodev(node, "reset-gpios", 0, 589 &audio, GPIOD_IS_OUT)) { 590 log_debug("could not find reset-gpios\n"); 591 return -ENOENT; 592 } 593 594 /* before power up, insure that HDMI and AUDIO IC is under reset */ 595 ret = dm_gpio_set_value(&hdmi, 1); 596 if (ret) { 597 log_err("can't set_value for hdmi_nrst gpio"); 598 goto error; 599 } 600 ret = dm_gpio_set_value(&audio, 1); 601 if (ret) { 602 log_err("can't set_value for audio_nrst gpio"); 603 goto error; 604 } 605 606 /* power-up audio IC */ 607 regulator_autoset_by_name("v1v8_audio", NULL); 608 609 /* power-up HDMI IC */ 610 regulator_autoset_by_name("v1v2_hdmi", NULL); 611 regulator_autoset_by_name("v3v3_hdmi", NULL); 612 613error: 614 return ret; 615} 616 617static bool board_is_stm32mp15x_dk2(void) 618{ 619 if (CONFIG_IS_ENABLED(TARGET_ST_STM32MP15X) && 620 of_machine_is_compatible("st,stm32mp157c-dk2")) 621 return true; 622 623 return false; 624} 625 626static bool board_is_stm32mp15x_ev1(void) 627{ 628 if (CONFIG_IS_ENABLED(TARGET_ST_STM32MP15X) && 629 (of_machine_is_compatible("st,stm32mp157a-ev1") || 630 of_machine_is_compatible("st,stm32mp157c-ev1") || 631 of_machine_is_compatible("st,stm32mp157d-ev1") || 632 of_machine_is_compatible("st,stm32mp157f-ev1"))) 633 return true; 634 635 return false; 636} 637 638/* touchscreen driver: only used for pincontrol configuration */ 639static const struct udevice_id goodix_ids[] = { 640 { .compatible = "goodix,gt9147", }, 641 { } 642}; 643 644U_BOOT_DRIVER(goodix) = { 645 .name = "goodix", 646 .id = UCLASS_NOP, 647 .of_match = goodix_ids, 648}; 649 650static void board_stm32mp15x_ev1_init(void) 651{ 652 struct udevice *dev; 653 654 /* configure IRQ line on EV1 for touchscreen before LCD reset */ 655 uclass_get_device_by_driver(UCLASS_NOP, DM_DRIVER_GET(goodix), &dev); 656} 657 658/* board dependent setup after realloc */ 659int board_init(void) 660{ 661 board_key_check(); 662 663 if (board_is_stm32mp15x_ev1()) 664 board_stm32mp15x_ev1_init(); 665 666 if (board_is_stm32mp15x_dk2()) 667 board_stm32mp15x_dk2_init(); 668 669 regulators_enable_boot_on(_DEBUG); 670 671 /* 672 * sysconf initialisation done only when U-Boot is running in secure 673 * done in TF-A for TFABOOT. 674 */ 675 if (IS_ENABLED(CONFIG_ARMV7_NONSEC)) 676 sysconf_init(); 677 678 setup_led(LEDST_ON); 679 680#if IS_ENABLED(CONFIG_EFI_HAVE_CAPSULE_SUPPORT) 681 efi_guid_t image_type_guid = STM32MP_FIP_IMAGE_GUID; 682 683 guidcpy(&fw_images[0].image_type_id, &image_type_guid); 684 fw_images[0].fw_name = u"STM32MP-FIP"; 685 fw_images[0].image_index = 1; 686#endif 687 return 0; 688} 689 690int board_late_init(void) 691{ 692 const void *fdt_compat; 693 int fdt_compat_len; 694 int ret; 695 u32 otp; 696 struct udevice *dev; 697 char buf[10]; 698 char dtb_name[256]; 699 int buf_len; 700 701 if (IS_ENABLED(CONFIG_ENV_VARS_UBOOT_RUNTIME_CONFIG)) { 702 fdt_compat = ofnode_get_property(ofnode_root(), "compatible", 703 &fdt_compat_len); 704 if (fdt_compat && fdt_compat_len) { 705 if (strncmp(fdt_compat, "st,", 3) != 0) { 706 env_set("board_name", fdt_compat); 707 } else { 708 env_set("board_name", fdt_compat + 3); 709 710 buf_len = sizeof(dtb_name); 711 strncpy(dtb_name, fdt_compat + 3, buf_len); 712 buf_len -= strlen(fdt_compat + 3); 713 strncat(dtb_name, ".dtb", buf_len); 714 env_set("fdtfile", dtb_name); 715 } 716 } 717 ret = uclass_get_device_by_driver(UCLASS_MISC, 718 DM_DRIVER_GET(stm32mp_bsec), 719 &dev); 720 721 if (!ret) 722 ret = misc_read(dev, STM32_BSEC_SHADOW(BSEC_OTP_BOARD), 723 &otp, sizeof(otp)); 724 if (ret > 0 && otp) { 725 snprintf(buf, sizeof(buf), "0x%04x", otp >> 16); 726 env_set("board_id", buf); 727 728 snprintf(buf, sizeof(buf), "0x%04x", 729 ((otp >> 8) & 0xF) - 1 + 0xA); 730 env_set("board_rev", buf); 731 } 732 } 733 734 /* for DK1/DK2 boards */ 735 board_check_usb_power(); 736 737 return 0; 738} 739 740void board_quiesce_devices(void) 741{ 742 setup_led(LEDST_OFF); 743} 744 745enum env_location env_get_location(enum env_operation op, int prio) 746{ 747 u32 bootmode = get_bootmode(); 748 749 if (prio) 750 return ENVL_UNKNOWN; 751 752 switch (bootmode & TAMP_BOOT_DEVICE_MASK) { 753 case BOOT_FLASH_SD: 754 case BOOT_FLASH_EMMC: 755 if (CONFIG_IS_ENABLED(ENV_IS_IN_MMC)) 756 return ENVL_MMC; 757 else if (CONFIG_IS_ENABLED(ENV_IS_IN_EXT4)) 758 return ENVL_EXT4; 759 else 760 return ENVL_NOWHERE; 761 762 case BOOT_FLASH_NAND: 763 case BOOT_FLASH_SPINAND: 764 if (IS_ENABLED(CONFIG_ENV_IS_IN_UBI)) 765 return ENVL_UBI; 766 else 767 return ENVL_NOWHERE; 768 769 case BOOT_FLASH_NOR: 770 if (CONFIG_IS_ENABLED(ENV_IS_IN_SPI_FLASH)) 771 return ENVL_SPI_FLASH; 772 else 773 return ENVL_NOWHERE; 774 775 default: 776 return ENVL_NOWHERE; 777 } 778} 779 780const char *env_ext4_get_intf(void) 781{ 782 u32 bootmode = get_bootmode(); 783 784 switch (bootmode & TAMP_BOOT_DEVICE_MASK) { 785 case BOOT_FLASH_SD: 786 case BOOT_FLASH_EMMC: 787 return "mmc"; 788 default: 789 return ""; 790 } 791} 792 793int mmc_get_boot(void) 794{ 795 struct udevice *dev; 796 u32 boot_mode = get_bootmode(); 797 unsigned int instance = (boot_mode & TAMP_BOOT_INSTANCE_MASK) - 1; 798 char cmd[20]; 799 const u32 sdmmc_addr[] = { 800 STM32_SDMMC1_BASE, 801 STM32_SDMMC2_BASE, 802 STM32_SDMMC3_BASE 803 }; 804 805 if (instance >= ARRAY_SIZE(sdmmc_addr)) 806 return 0; 807 808 /* search associated sdmmc node in devicetree */ 809 snprintf(cmd, sizeof(cmd), "mmc@%x", sdmmc_addr[instance]); 810 if (uclass_get_device_by_name(UCLASS_MMC, cmd, &dev)) { 811 log_err("mmc%d = %s not found in device tree!\n", instance, cmd); 812 return 0; 813 } 814 815 return dev_seq(dev); 816}; 817 818const char *env_ext4_get_dev_part(void) 819{ 820 static char *const env_dev_part = 821#ifdef CONFIG_ENV_EXT4_DEVICE_AND_PART 822 CONFIG_ENV_EXT4_DEVICE_AND_PART; 823#else 824 ""; 825#endif 826 static char *const dev_part[] = {"0:auto", "1:auto", "2:auto"}; 827 828 if (strlen(env_dev_part) > 0) 829 return env_dev_part; 830 831 return dev_part[mmc_get_boot()]; 832} 833 834int mmc_get_env_dev(void) 835{ 836 const int mmc_env_dev = CONFIG_IS_ENABLED(ENV_IS_IN_MMC, (CONFIG_SYS_MMC_ENV_DEV), (-1)); 837 838 if (mmc_env_dev >= 0) 839 return mmc_env_dev; 840 841 /* use boot instance to select the correct mmc device identifier */ 842 return mmc_get_boot(); 843} 844 845#if defined(CONFIG_OF_BOARD_SETUP) 846int ft_board_setup(void *blob, struct bd_info *bd) 847{ 848 fdt_copy_fixed_partitions(blob); 849 850 if (IS_ENABLED(CONFIG_FDT_SIMPLEFB)) 851 fdt_simplefb_enable_and_mem_rsv(blob); 852 853 return 0; 854} 855#endif 856 857static void board_copro_image_process(ulong fw_image, size_t fw_size) 858{ 859 int ret, id = 0; /* Copro id fixed to 0 as only one coproc on mp1 */ 860 861 if (!rproc_is_initialized()) 862 if (rproc_init()) { 863 log_err("Remote Processor %d initialization failed\n", 864 id); 865 return; 866 } 867 868 ret = rproc_load(id, fw_image, fw_size); 869 log_err("Load Remote Processor %d with data@addr=0x%08lx %u bytes:%s\n", 870 id, fw_image, fw_size, ret ? " Failed!" : " Success!"); 871 872 if (!ret) 873 rproc_start(id); 874} 875 876U_BOOT_FIT_LOADABLE_HANDLER(IH_TYPE_COPRO, board_copro_image_process); 877 878#if defined(CONFIG_FWU_MULTI_BANK_UPDATE) 879 880#include <fwu.h> 881 882/** 883 * fwu_plat_get_bootidx() - Get the value of the boot index 884 * @boot_idx: Boot index value 885 * 886 * Get the value of the bank(partition) from which the platform 887 * has booted. This value is passed to U-Boot from the earlier 888 * stage bootloader which loads and boots all the relevant 889 * firmware images 890 * 891 */ 892void fwu_plat_get_bootidx(uint *boot_idx) 893{ 894 *boot_idx = (readl(TAMP_FWU_BOOT_INFO_REG) >> 895 TAMP_FWU_BOOT_IDX_OFFSET) & TAMP_FWU_BOOT_IDX_MASK; 896} 897#endif /* CONFIG_FWU_MULTI_BANK_UPDATE */ 898