1 // SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause 2 /* 3 * Copyright (C) 2018, STMicroelectronics - All Rights Reserved 4 */ 5 #include <common.h> 6 #include <adc.h> 7 #include <config.h> 8 #include <clk.h> 9 #include <dm.h> 10 #include <g_dnl.h> 11 #include <generic-phy.h> 12 #include <i2c.h> 13 #include <led.h> 14 #include <misc.h> 15 #include <phy.h> 16 #include <reset.h> 17 #include <syscon.h> 18 #include <usb.h> 19 #include <asm/io.h> 20 #include <asm/gpio.h> 21 #include <asm/arch/stm32.h> 22 #include <power/regulator.h> 23 #include <usb/dwc2_udc.h> 24 25 /* SYSCFG registers */ 26 #define SYSCFG_BOOTR 0x00 27 #define SYSCFG_PMCSETR 0x04 28 #define SYSCFG_IOCTRLSETR 0x18 29 #define SYSCFG_ICNR 0x1C 30 #define SYSCFG_CMPCR 0x20 31 #define SYSCFG_CMPENSETR 0x24 32 #define SYSCFG_PMCCLRR 0x44 33 34 #define SYSCFG_BOOTR_BOOT_MASK GENMASK(2, 0) 35 #define SYSCFG_BOOTR_BOOTPD_SHIFT 4 36 37 #define SYSCFG_IOCTRLSETR_HSLVEN_TRACE BIT(0) 38 #define SYSCFG_IOCTRLSETR_HSLVEN_QUADSPI BIT(1) 39 #define SYSCFG_IOCTRLSETR_HSLVEN_ETH BIT(2) 40 #define SYSCFG_IOCTRLSETR_HSLVEN_SDMMC BIT(3) 41 #define SYSCFG_IOCTRLSETR_HSLVEN_SPI BIT(4) 42 43 #define SYSCFG_CMPCR_SW_CTRL BIT(1) 44 #define SYSCFG_CMPCR_READY BIT(8) 45 46 #define SYSCFG_CMPENSETR_MPU_EN BIT(0) 47 48 #define SYSCFG_PMCSETR_ETH_CLK_SEL BIT(16) 49 #define SYSCFG_PMCSETR_ETH_REF_CLK_SEL BIT(17) 50 51 #define SYSCFG_PMCSETR_ETH_SELMII BIT(20) 52 53 #define SYSCFG_PMCSETR_ETH_SEL_MASK GENMASK(23, 21) 54 #define SYSCFG_PMCSETR_ETH_SEL_GMII_MII (0 << 21) 55 #define SYSCFG_PMCSETR_ETH_SEL_RGMII (1 << 21) 56 #define SYSCFG_PMCSETR_ETH_SEL_RMII (4 << 21) 57 58 /* 59 * Get a global data pointer 60 */ 61 DECLARE_GLOBAL_DATA_PTR; 62 63 #define USB_WARNING_LOW_THRESHOLD_UV 660000 64 #define USB_START_LOW_THRESHOLD_UV 1230000 65 #define USB_START_HIGH_THRESHOLD_UV 2100000 66 67 int checkboard(void) 68 { 69 int ret; 70 char *mode; 71 u32 otp; 72 struct udevice *dev; 73 const char *fdt_compat; 74 int fdt_compat_len; 75 76 if (IS_ENABLED(CONFIG_STM32MP1_TRUSTED)) 77 mode = "trusted"; 78 else 79 mode = "basic"; 80 81 printf("Board: stm32mp1 in %s mode", mode); 82 fdt_compat = fdt_getprop(gd->fdt_blob, 0, "compatible", 83 &fdt_compat_len); 84 if (fdt_compat && fdt_compat_len) 85 printf(" (%s)", fdt_compat); 86 puts("\n"); 87 88 ret = uclass_get_device_by_driver(UCLASS_MISC, 89 DM_GET_DRIVER(stm32mp_bsec), 90 &dev); 91 92 if (!ret) 93 ret = misc_read(dev, STM32_BSEC_SHADOW(BSEC_OTP_BOARD), 94 &otp, sizeof(otp)); 95 if (!ret && otp) { 96 printf("Board: MB%04x Var%d Rev.%c-%02d\n", 97 otp >> 16, 98 (otp >> 12) & 0xF, 99 ((otp >> 8) & 0xF) - 1 + 'A', 100 otp & 0xF); 101 } 102 103 return 0; 104 } 105 106 static void board_key_check(void) 107 { 108 #if defined(CONFIG_FASTBOOT) || defined(CONFIG_CMD_STM32PROG) 109 ofnode node; 110 struct gpio_desc gpio; 111 enum forced_boot_mode boot_mode = BOOT_NORMAL; 112 113 node = ofnode_path("/config"); 114 if (!ofnode_valid(node)) { 115 debug("%s: no /config node?\n", __func__); 116 return; 117 } 118 #ifdef CONFIG_FASTBOOT 119 if (gpio_request_by_name_nodev(node, "st,fastboot-gpios", 0, 120 &gpio, GPIOD_IS_IN)) { 121 debug("%s: could not find a /config/st,fastboot-gpios\n", 122 __func__); 123 } else { 124 if (dm_gpio_get_value(&gpio)) { 125 puts("Fastboot key pressed, "); 126 boot_mode = BOOT_FASTBOOT; 127 } 128 129 dm_gpio_free(NULL, &gpio); 130 } 131 #endif 132 #ifdef CONFIG_CMD_STM32PROG 133 if (gpio_request_by_name_nodev(node, "st,stm32prog-gpios", 0, 134 &gpio, GPIOD_IS_IN)) { 135 debug("%s: could not find a /config/st,stm32prog-gpios\n", 136 __func__); 137 } else { 138 if (dm_gpio_get_value(&gpio)) { 139 puts("STM32Programmer key pressed, "); 140 boot_mode = BOOT_STM32PROG; 141 } 142 dm_gpio_free(NULL, &gpio); 143 } 144 #endif 145 146 if (boot_mode != BOOT_NORMAL) { 147 puts("entering download mode...\n"); 148 clrsetbits_le32(TAMP_BOOT_CONTEXT, 149 TAMP_BOOT_FORCED_MASK, 150 boot_mode); 151 } 152 #endif 153 } 154 155 #if defined(CONFIG_USB_GADGET) && defined(CONFIG_USB_GADGET_DWC2_OTG) 156 157 /* STMicroelectronics STUSB1600 Type-C controller */ 158 #define STUSB1600_CC_CONNECTION_STATUS 0x0E 159 160 /* STUSB1600_CC_CONNECTION_STATUS bitfields */ 161 #define STUSB1600_CC_ATTACH BIT(0) 162 163 static int stusb1600_init(struct udevice **dev_stusb1600) 164 { 165 ofnode node; 166 struct udevice *dev, *bus; 167 int ret; 168 u32 chip_addr; 169 170 *dev_stusb1600 = NULL; 171 172 /* if node stusb1600 is present, means DK1 or DK2 board */ 173 node = ofnode_by_compatible(ofnode_null(), "st,stusb1600"); 174 if (!ofnode_valid(node)) 175 return -ENODEV; 176 177 ret = ofnode_read_u32(node, "reg", &chip_addr); 178 if (ret) 179 return -EINVAL; 180 181 ret = uclass_get_device_by_ofnode(UCLASS_I2C, ofnode_get_parent(node), 182 &bus); 183 if (ret) { 184 printf("bus for stusb1600 not found\n"); 185 return -ENODEV; 186 } 187 188 ret = dm_i2c_probe(bus, chip_addr, 0, &dev); 189 if (!ret) 190 *dev_stusb1600 = dev; 191 192 return ret; 193 } 194 195 static int stusb1600_cable_connected(struct udevice *dev) 196 { 197 u8 status; 198 199 if (dm_i2c_read(dev, STUSB1600_CC_CONNECTION_STATUS, &status, 1)) 200 return 0; 201 202 return status & STUSB1600_CC_ATTACH; 203 } 204 205 #include <usb/dwc2_udc.h> 206 int g_dnl_board_usb_cable_connected(void) 207 { 208 struct udevice *stusb1600; 209 struct udevice *dwc2_udc_otg; 210 int ret; 211 212 if (!stusb1600_init(&stusb1600)) 213 return stusb1600_cable_connected(stusb1600); 214 215 ret = uclass_get_device_by_driver(UCLASS_USB_GADGET_GENERIC, 216 DM_GET_DRIVER(dwc2_udc_otg), 217 &dwc2_udc_otg); 218 if (!ret) 219 debug("dwc2_udc_otg init failed\n"); 220 221 return dwc2_udc_B_session_valid(dwc2_udc_otg); 222 } 223 #endif /* CONFIG_USB_GADGET */ 224 225 static int get_led(struct udevice **dev, char *led_string) 226 { 227 char *led_name; 228 int ret; 229 230 led_name = fdtdec_get_config_string(gd->fdt_blob, led_string); 231 if (!led_name) { 232 pr_debug("%s: could not find %s config string\n", 233 __func__, led_string); 234 return -ENOENT; 235 } 236 ret = led_get_by_label(led_name, dev); 237 if (ret) { 238 debug("%s: get=%d\n", __func__, ret); 239 return ret; 240 } 241 242 return 0; 243 } 244 245 static int setup_led(enum led_state_t cmd) 246 { 247 struct udevice *dev; 248 int ret; 249 250 ret = get_led(&dev, "u-boot,boot-led"); 251 if (ret) 252 return ret; 253 254 ret = led_set_state(dev, cmd); 255 return ret; 256 } 257 258 static int board_check_usb_power(void) 259 { 260 struct ofnode_phandle_args adc_args; 261 struct udevice *adc; 262 struct udevice *led; 263 ofnode node; 264 unsigned int raw; 265 int max_uV = 0; 266 int ret, uV, adc_count; 267 u8 i, nb_blink; 268 269 node = ofnode_path("/config"); 270 if (!ofnode_valid(node)) { 271 debug("%s: no /config node?\n", __func__); 272 return -ENOENT; 273 } 274 275 /* 276 * Retrieve the ADC channels devices and get measurement 277 * for each of them 278 */ 279 adc_count = ofnode_count_phandle_with_args(node, "st,adc_usb_pd", 280 "#io-channel-cells"); 281 if (adc_count < 0) { 282 if (adc_count == -ENOENT) 283 return 0; 284 285 pr_err("%s: can't find adc channel (%d)\n", __func__, 286 adc_count); 287 288 return adc_count; 289 } 290 291 for (i = 0; i < adc_count; i++) { 292 if (ofnode_parse_phandle_with_args(node, "st,adc_usb_pd", 293 "#io-channel-cells", 0, i, 294 &adc_args)) { 295 pr_debug("%s: can't find /config/st,adc_usb_pd\n", 296 __func__); 297 return 0; 298 } 299 300 ret = uclass_get_device_by_ofnode(UCLASS_ADC, adc_args.node, 301 &adc); 302 303 if (ret) { 304 pr_err("%s: Can't get adc device(%d)\n", __func__, 305 ret); 306 return ret; 307 } 308 309 ret = adc_channel_single_shot(adc->name, adc_args.args[0], 310 &raw); 311 if (ret) { 312 pr_err("%s: single shot failed for %s[%d]!\n", 313 __func__, adc->name, adc_args.args[0]); 314 return ret; 315 } 316 /* Convert to uV */ 317 if (!adc_raw_to_uV(adc, raw, &uV)) { 318 if (uV > max_uV) 319 max_uV = uV; 320 pr_debug("%s: %s[%02d] = %u, %d uV\n", __func__, 321 adc->name, adc_args.args[0], raw, uV); 322 } else { 323 pr_err("%s: Can't get uV value for %s[%d]\n", 324 __func__, adc->name, adc_args.args[0]); 325 } 326 } 327 328 /* 329 * If highest value is inside 1.23 Volts and 2.10 Volts, that means 330 * board is plugged on an USB-C 3A power supply and boot process can 331 * continue. 332 */ 333 if (max_uV > USB_START_LOW_THRESHOLD_UV && 334 max_uV < USB_START_HIGH_THRESHOLD_UV) 335 return 0; 336 337 /* Display warning message and make u-boot,error-led blinking */ 338 pr_err("\n*******************************************\n"); 339 340 if (max_uV < USB_WARNING_LOW_THRESHOLD_UV) { 341 pr_err("* WARNING 500mA power supply detected *\n"); 342 nb_blink = 2; 343 } else { 344 pr_err("* WARNING 1.5A power supply detected *\n"); 345 nb_blink = 3; 346 } 347 348 pr_err("* Current too low, use a 3A power supply! *\n"); 349 pr_err("*******************************************\n\n"); 350 351 ret = get_led(&led, "u-boot,error-led"); 352 if (ret) 353 return ret; 354 355 for (i = 0; i < nb_blink * 2; i++) { 356 led_set_state(led, LEDST_TOGGLE); 357 mdelay(125); 358 } 359 led_set_state(led, LEDST_ON); 360 361 return 0; 362 } 363 364 static void sysconf_init(void) 365 { 366 #ifndef CONFIG_STM32MP1_TRUSTED 367 u8 *syscfg; 368 #ifdef CONFIG_DM_REGULATOR 369 struct udevice *pwr_dev; 370 struct udevice *pwr_reg; 371 struct udevice *dev; 372 int ret; 373 u32 otp = 0; 374 #endif 375 u32 bootr; 376 377 syscfg = (u8 *)syscon_get_first_range(STM32MP_SYSCON_SYSCFG); 378 379 /* interconnect update : select master using the port 1 */ 380 /* LTDC = AXI_M9 */ 381 /* GPU = AXI_M8 */ 382 /* today information is hardcoded in U-Boot */ 383 writel(BIT(9), syscfg + SYSCFG_ICNR); 384 385 /* disable Pull-Down for boot pin connected to VDD */ 386 bootr = readl(syscfg + SYSCFG_BOOTR); 387 bootr &= ~(SYSCFG_BOOTR_BOOT_MASK << SYSCFG_BOOTR_BOOTPD_SHIFT); 388 bootr |= (bootr & SYSCFG_BOOTR_BOOT_MASK) << SYSCFG_BOOTR_BOOTPD_SHIFT; 389 writel(bootr, syscfg + SYSCFG_BOOTR); 390 391 #ifdef CONFIG_DM_REGULATOR 392 /* High Speed Low Voltage Pad mode Enable for SPI, SDMMC, ETH, QSPI 393 * and TRACE. Needed above ~50MHz and conditioned by AFMUX selection. 394 * The customer will have to disable this for low frequencies 395 * or if AFMUX is selected but the function not used, typically for 396 * TRACE. Otherwise, impact on power consumption. 397 * 398 * WARNING: 399 * enabling High Speed mode while VDD>2.7V 400 * with the OTP product_below_2v5 (OTP 18, BIT 13) 401 * erroneously set to 1 can damage the IC! 402 * => U-Boot set the register only if VDD < 2.7V (in DT) 403 * but this value need to be consistent with board design 404 */ 405 ret = syscon_get_by_driver_data(STM32MP_SYSCON_PWR, &pwr_dev); 406 if (!ret) { 407 ret = uclass_get_device_by_driver(UCLASS_MISC, 408 DM_GET_DRIVER(stm32mp_bsec), 409 &dev); 410 if (ret) { 411 pr_err("Can't find stm32mp_bsec driver\n"); 412 return; 413 } 414 415 ret = misc_read(dev, STM32_BSEC_SHADOW(18), &otp, 4); 416 if (!ret) 417 otp = otp & BIT(13); 418 419 /* get VDD = pwr-supply */ 420 ret = device_get_supply_regulator(pwr_dev, "pwr-supply", 421 &pwr_reg); 422 423 /* check if VDD is Low Voltage */ 424 if (!ret) { 425 if (regulator_get_value(pwr_reg) < 2700000) { 426 writel(SYSCFG_IOCTRLSETR_HSLVEN_TRACE | 427 SYSCFG_IOCTRLSETR_HSLVEN_QUADSPI | 428 SYSCFG_IOCTRLSETR_HSLVEN_ETH | 429 SYSCFG_IOCTRLSETR_HSLVEN_SDMMC | 430 SYSCFG_IOCTRLSETR_HSLVEN_SPI, 431 syscfg + SYSCFG_IOCTRLSETR); 432 433 if (!otp) 434 pr_err("product_below_2v5=0: HSLVEN protected by HW\n"); 435 } else { 436 if (otp) 437 pr_err("product_below_2v5=1: HSLVEN update is destructive, no update as VDD>2.7V\n"); 438 } 439 } else { 440 debug("VDD unknown"); 441 } 442 } 443 #endif 444 445 /* activate automatic I/O compensation 446 * warning: need to ensure CSI enabled and ready in clock driver 447 */ 448 writel(SYSCFG_CMPENSETR_MPU_EN, syscfg + SYSCFG_CMPENSETR); 449 450 while (!(readl(syscfg + SYSCFG_CMPCR) & SYSCFG_CMPCR_READY)) 451 ; 452 clrbits_le32(syscfg + SYSCFG_CMPCR, SYSCFG_CMPCR_SW_CTRL); 453 #endif 454 } 455 456 /* board dependent setup after realloc */ 457 int board_init(void) 458 { 459 struct udevice *dev; 460 461 /* address of boot parameters */ 462 gd->bd->bi_boot_params = STM32_DDR_BASE + 0x100; 463 464 /* probe all PINCTRL for hog */ 465 for (uclass_first_device(UCLASS_PINCTRL, &dev); 466 dev; 467 uclass_next_device(&dev)) { 468 pr_debug("probe pincontrol = %s\n", dev->name); 469 } 470 471 board_key_check(); 472 473 sysconf_init(); 474 475 if (IS_ENABLED(CONFIG_LED)) 476 led_default_state(); 477 478 return 0; 479 } 480 481 int board_late_init(void) 482 { 483 #ifdef CONFIG_ENV_VARS_UBOOT_RUNTIME_CONFIG 484 const void *fdt_compat; 485 int fdt_compat_len; 486 487 fdt_compat = fdt_getprop(gd->fdt_blob, 0, "compatible", 488 &fdt_compat_len); 489 if (fdt_compat && fdt_compat_len) { 490 if (strncmp(fdt_compat, "st,", 3) != 0) 491 env_set("board_name", fdt_compat); 492 else 493 env_set("board_name", fdt_compat + 3); 494 } 495 #endif 496 497 /* for DK1/DK2 boards */ 498 board_check_usb_power(); 499 500 return 0; 501 } 502 503 void board_quiesce_devices(void) 504 { 505 setup_led(LEDST_OFF); 506 } 507