board/st/stm32mp1/stm32mp1.c

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