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