Ian Campbell | 6efe369 | 2014-05-05 11:52:26 +0100 | [diff] [blame] | 1 | /* |
| 2 | * (C) Copyright 2012 Henrik Nordstrom <henrik@henriknordstrom.net> |
| 3 | * |
| 4 | * (C) Copyright 2007-2011 |
| 5 | * Allwinner Technology Co., Ltd. <www.allwinnertech.com> |
| 6 | * Tom Cubie <tangliang@allwinnertech.com> |
| 7 | * |
| 8 | * Some init for sunxi platform. |
| 9 | * |
| 10 | * SPDX-License-Identifier: GPL-2.0+ |
| 11 | */ |
| 12 | |
| 13 | #include <common.h> |
Daniel Kochmański | e8b97e2 | 2015-05-29 16:55:42 +0200 | [diff] [blame] | 14 | #include <mmc.h> |
Hans de Goede | 3352b22 | 2014-06-13 22:55:49 +0200 | [diff] [blame] | 15 | #include <i2c.h> |
Ian Campbell | 6efe369 | 2014-05-05 11:52:26 +0100 | [diff] [blame] | 16 | #include <serial.h> |
| 17 | #ifdef CONFIG_SPL_BUILD |
| 18 | #include <spl.h> |
| 19 | #endif |
| 20 | #include <asm/gpio.h> |
| 21 | #include <asm/io.h> |
| 22 | #include <asm/arch/clock.h> |
| 23 | #include <asm/arch/gpio.h> |
Bernhard Nortmann | ead498a | 2015-09-17 18:52:52 +0200 | [diff] [blame] | 24 | #include <asm/arch/spl.h> |
Ian Campbell | 6efe369 | 2014-05-05 11:52:26 +0100 | [diff] [blame] | 25 | #include <asm/arch/sys_proto.h> |
| 26 | #include <asm/arch/timer.h> |
Chen-Yu Tsai | fcc7b70 | 2015-08-25 10:49:19 +0800 | [diff] [blame] | 27 | #include <asm/arch/tzpc.h> |
Daniel Kochmański | e8b97e2 | 2015-05-29 16:55:42 +0200 | [diff] [blame] | 28 | #include <asm/arch/mmc.h> |
Ian Campbell | 6efe369 | 2014-05-05 11:52:26 +0100 | [diff] [blame] | 29 | |
Ian Campbell | d41e2f67 | 2014-07-06 20:03:20 +0100 | [diff] [blame] | 30 | #include <linux/compiler.h> |
| 31 | |
Simon Glass | 5debe1f | 2015-02-07 10:47:30 -0700 | [diff] [blame] | 32 | struct fel_stash { |
| 33 | uint32_t sp; |
| 34 | uint32_t lr; |
Siarhei Siamashka | 7ef91f0 | 2015-02-16 10:23:59 +0200 | [diff] [blame] | 35 | uint32_t cpsr; |
| 36 | uint32_t sctlr; |
| 37 | uint32_t vbar; |
| 38 | uint32_t cr; |
Simon Glass | 5debe1f | 2015-02-07 10:47:30 -0700 | [diff] [blame] | 39 | }; |
| 40 | |
| 41 | struct fel_stash fel_stash __attribute__((section(".data"))); |
| 42 | |
Andre Przywara | 3a63c23 | 2017-02-16 01:20:24 +0000 | [diff] [blame] | 43 | #ifdef CONFIG_ARM64 |
Siarhei Siamashka | 26c50fb | 2016-03-29 17:29:10 +0200 | [diff] [blame] | 44 | #include <asm/armv8/mmu.h> |
| 45 | |
| 46 | static struct mm_region sunxi_mem_map[] = { |
| 47 | { |
| 48 | /* SRAM, MMIO regions */ |
York Sun | c7104e5 | 2016-06-24 16:46:22 -0700 | [diff] [blame] | 49 | .virt = 0x0UL, |
| 50 | .phys = 0x0UL, |
Siarhei Siamashka | 26c50fb | 2016-03-29 17:29:10 +0200 | [diff] [blame] | 51 | .size = 0x40000000UL, |
| 52 | .attrs = PTE_BLOCK_MEMTYPE(MT_DEVICE_NGNRNE) | |
| 53 | PTE_BLOCK_NON_SHARE |
| 54 | }, { |
| 55 | /* RAM */ |
York Sun | c7104e5 | 2016-06-24 16:46:22 -0700 | [diff] [blame] | 56 | .virt = 0x40000000UL, |
| 57 | .phys = 0x40000000UL, |
Siarhei Siamashka | 26c50fb | 2016-03-29 17:29:10 +0200 | [diff] [blame] | 58 | .size = 0x80000000UL, |
| 59 | .attrs = PTE_BLOCK_MEMTYPE(MT_NORMAL) | |
| 60 | PTE_BLOCK_INNER_SHARE |
| 61 | }, { |
| 62 | /* List terminator */ |
| 63 | 0, |
| 64 | } |
| 65 | }; |
| 66 | struct mm_region *mem_map = sunxi_mem_map; |
| 67 | #endif |
| 68 | |
Simon Glass | 8735682 | 2014-12-23 12:04:52 -0700 | [diff] [blame] | 69 | static int gpio_init(void) |
Ian Campbell | 6efe369 | 2014-05-05 11:52:26 +0100 | [diff] [blame] | 70 | { |
Chen-Yu Tsai | d4ea92b | 2014-10-22 16:47:42 +0800 | [diff] [blame] | 71 | #if CONFIG_CONS_INDEX == 1 && defined(CONFIG_UART0_PORT_F) |
Chen-Yu Tsai | cc2605e | 2016-11-30 14:57:32 +0800 | [diff] [blame] | 72 | #if defined(CONFIG_MACH_SUN4I) || \ |
| 73 | defined(CONFIG_MACH_SUN7I) || \ |
| 74 | defined(CONFIG_MACH_SUN8I_R40) |
Chen-Yu Tsai | d4ea92b | 2014-10-22 16:47:42 +0800 | [diff] [blame] | 75 | /* disable GPB22,23 as uart0 tx,rx to avoid conflict */ |
| 76 | sunxi_gpio_set_cfgpin(SUNXI_GPB(22), SUNXI_GPIO_INPUT); |
| 77 | sunxi_gpio_set_cfgpin(SUNXI_GPB(23), SUNXI_GPIO_INPUT); |
| 78 | #endif |
Chen-Yu Tsai | cc2605e | 2016-11-30 14:57:32 +0800 | [diff] [blame] | 79 | #if defined(CONFIG_MACH_SUN8I) && !defined(CONFIG_MACH_SUN8I_R40) |
Chen-Yu Tsai | da2f333 | 2015-06-23 19:57:23 +0800 | [diff] [blame] | 80 | sunxi_gpio_set_cfgpin(SUNXI_GPF(2), SUN8I_GPF_UART0); |
| 81 | sunxi_gpio_set_cfgpin(SUNXI_GPF(4), SUN8I_GPF_UART0); |
Paul Kocialkowski | ae358a4 | 2015-03-22 18:12:22 +0100 | [diff] [blame] | 82 | #else |
Chen-Yu Tsai | da2f333 | 2015-06-23 19:57:23 +0800 | [diff] [blame] | 83 | sunxi_gpio_set_cfgpin(SUNXI_GPF(2), SUNXI_GPF_UART0); |
| 84 | sunxi_gpio_set_cfgpin(SUNXI_GPF(4), SUNXI_GPF_UART0); |
Paul Kocialkowski | ae358a4 | 2015-03-22 18:12:22 +0100 | [diff] [blame] | 85 | #endif |
Chen-Yu Tsai | d4ea92b | 2014-10-22 16:47:42 +0800 | [diff] [blame] | 86 | sunxi_gpio_set_pull(SUNXI_GPF(4), 1); |
Chen-Yu Tsai | cc2605e | 2016-11-30 14:57:32 +0800 | [diff] [blame] | 87 | #elif CONFIG_CONS_INDEX == 1 && (defined(CONFIG_MACH_SUN4I) || \ |
| 88 | defined(CONFIG_MACH_SUN7I) || \ |
| 89 | defined(CONFIG_MACH_SUN8I_R40)) |
Paul Kocialkowski | ae358a4 | 2015-03-22 18:12:22 +0100 | [diff] [blame] | 90 | sunxi_gpio_set_cfgpin(SUNXI_GPB(22), SUN4I_GPB_UART0); |
| 91 | sunxi_gpio_set_cfgpin(SUNXI_GPB(23), SUN4I_GPB_UART0); |
Chen-Yu Tsai | 4e526e2 | 2014-10-03 20:16:21 +0800 | [diff] [blame] | 92 | sunxi_gpio_set_pull(SUNXI_GPB(23), SUNXI_GPIO_PULL_UP); |
Ian Campbell | 8f32aaa | 2014-10-24 21:20:47 +0100 | [diff] [blame] | 93 | #elif CONFIG_CONS_INDEX == 1 && defined(CONFIG_MACH_SUN5I) |
Paul Kocialkowski | ae358a4 | 2015-03-22 18:12:22 +0100 | [diff] [blame] | 94 | sunxi_gpio_set_cfgpin(SUNXI_GPB(19), SUN5I_GPB_UART0); |
| 95 | sunxi_gpio_set_cfgpin(SUNXI_GPB(20), SUN5I_GPB_UART0); |
Chen-Yu Tsai | 4e526e2 | 2014-10-03 20:16:21 +0800 | [diff] [blame] | 96 | sunxi_gpio_set_pull(SUNXI_GPB(20), SUNXI_GPIO_PULL_UP); |
Ian Campbell | 8f32aaa | 2014-10-24 21:20:47 +0100 | [diff] [blame] | 97 | #elif CONFIG_CONS_INDEX == 1 && defined(CONFIG_MACH_SUN6I) |
Paul Kocialkowski | ae358a4 | 2015-03-22 18:12:22 +0100 | [diff] [blame] | 98 | sunxi_gpio_set_cfgpin(SUNXI_GPH(20), SUN6I_GPH_UART0); |
| 99 | sunxi_gpio_set_cfgpin(SUNXI_GPH(21), SUN6I_GPH_UART0); |
Maxime Ripard | f139f1e | 2014-10-03 20:16:28 +0800 | [diff] [blame] | 100 | sunxi_gpio_set_pull(SUNXI_GPH(21), SUNXI_GPIO_PULL_UP); |
Chen-Yu Tsai | 28b7192 | 2015-06-23 19:57:25 +0800 | [diff] [blame] | 101 | #elif CONFIG_CONS_INDEX == 1 && defined(CONFIG_MACH_SUN8I_A33) |
| 102 | sunxi_gpio_set_cfgpin(SUNXI_GPB(0), SUN8I_A33_GPB_UART0); |
| 103 | sunxi_gpio_set_cfgpin(SUNXI_GPB(1), SUN8I_A33_GPB_UART0); |
| 104 | sunxi_gpio_set_pull(SUNXI_GPB(1), SUNXI_GPIO_PULL_UP); |
Andre Przywara | 5fb9743 | 2017-02-16 01:20:27 +0000 | [diff] [blame] | 105 | #elif CONFIG_CONS_INDEX == 1 && defined(CONFIG_MACH_SUNXI_H3_H5) |
Jens Kuske | f977072 | 2015-11-17 15:12:58 +0100 | [diff] [blame] | 106 | sunxi_gpio_set_cfgpin(SUNXI_GPA(4), SUN8I_H3_GPA_UART0); |
| 107 | sunxi_gpio_set_cfgpin(SUNXI_GPA(5), SUN8I_H3_GPA_UART0); |
| 108 | sunxi_gpio_set_pull(SUNXI_GPA(5), SUNXI_GPIO_PULL_UP); |
Siarhei Siamashka | 26c50fb | 2016-03-29 17:29:10 +0200 | [diff] [blame] | 109 | #elif CONFIG_CONS_INDEX == 1 && defined(CONFIG_MACH_SUN50I) |
| 110 | sunxi_gpio_set_cfgpin(SUNXI_GPB(8), SUN50I_GPB_UART0); |
| 111 | sunxi_gpio_set_cfgpin(SUNXI_GPB(9), SUN50I_GPB_UART0); |
| 112 | sunxi_gpio_set_pull(SUNXI_GPB(9), SUNXI_GPIO_PULL_UP); |
vishnupatekar | 133bfbe | 2015-11-29 01:07:20 +0800 | [diff] [blame] | 113 | #elif CONFIG_CONS_INDEX == 1 && defined(CONFIG_MACH_SUN8I_A83T) |
| 114 | sunxi_gpio_set_cfgpin(SUNXI_GPB(9), SUN8I_A83T_GPB_UART0); |
| 115 | sunxi_gpio_set_cfgpin(SUNXI_GPB(10), SUN8I_A83T_GPB_UART0); |
| 116 | sunxi_gpio_set_pull(SUNXI_GPB(10), SUNXI_GPIO_PULL_UP); |
Icenowy Zheng | 52e6188 | 2017-04-08 15:30:12 +0800 | [diff] [blame] | 117 | #elif CONFIG_CONS_INDEX == 1 && defined(CONFIG_MACH_SUN8I_V3S) |
| 118 | sunxi_gpio_set_cfgpin(SUNXI_GPB(8), SUN8I_V3S_GPB_UART0); |
| 119 | sunxi_gpio_set_cfgpin(SUNXI_GPB(9), SUN8I_V3S_GPB_UART0); |
| 120 | sunxi_gpio_set_pull(SUNXI_GPB(9), SUNXI_GPIO_PULL_UP); |
Hans de Goede | 7bfe2bb | 2015-01-13 19:25:06 +0100 | [diff] [blame] | 121 | #elif CONFIG_CONS_INDEX == 1 && defined(CONFIG_MACH_SUN9I) |
| 122 | sunxi_gpio_set_cfgpin(SUNXI_GPH(12), SUN9I_GPH_UART0); |
| 123 | sunxi_gpio_set_cfgpin(SUNXI_GPH(13), SUN9I_GPH_UART0); |
| 124 | sunxi_gpio_set_pull(SUNXI_GPH(13), SUNXI_GPIO_PULL_UP); |
Ian Campbell | 8f32aaa | 2014-10-24 21:20:47 +0100 | [diff] [blame] | 125 | #elif CONFIG_CONS_INDEX == 2 && defined(CONFIG_MACH_SUN5I) |
Paul Kocialkowski | ae358a4 | 2015-03-22 18:12:22 +0100 | [diff] [blame] | 126 | sunxi_gpio_set_cfgpin(SUNXI_GPG(3), SUN5I_GPG_UART1); |
| 127 | sunxi_gpio_set_cfgpin(SUNXI_GPG(4), SUN5I_GPG_UART1); |
Chen-Yu Tsai | 4e526e2 | 2014-10-03 20:16:21 +0800 | [diff] [blame] | 128 | sunxi_gpio_set_pull(SUNXI_GPG(4), SUNXI_GPIO_PULL_UP); |
Laurent Itti | 20dfe00 | 2015-05-05 17:02:00 -0700 | [diff] [blame] | 129 | #elif CONFIG_CONS_INDEX == 3 && defined(CONFIG_MACH_SUN8I) |
| 130 | sunxi_gpio_set_cfgpin(SUNXI_GPB(0), SUN8I_GPB_UART2); |
| 131 | sunxi_gpio_set_cfgpin(SUNXI_GPB(1), SUN8I_GPB_UART2); |
| 132 | sunxi_gpio_set_pull(SUNXI_GPB(1), SUNXI_GPIO_PULL_UP); |
Ian Campbell | 8f32aaa | 2014-10-24 21:20:47 +0100 | [diff] [blame] | 133 | #elif CONFIG_CONS_INDEX == 5 && defined(CONFIG_MACH_SUN8I) |
Paul Kocialkowski | ae358a4 | 2015-03-22 18:12:22 +0100 | [diff] [blame] | 134 | sunxi_gpio_set_cfgpin(SUNXI_GPL(2), SUN8I_GPL_R_UART); |
| 135 | sunxi_gpio_set_cfgpin(SUNXI_GPL(3), SUN8I_GPL_R_UART); |
Chen-Yu Tsai | 6ee6388 | 2014-10-22 16:47:47 +0800 | [diff] [blame] | 136 | sunxi_gpio_set_pull(SUNXI_GPL(3), SUNXI_GPIO_PULL_UP); |
Hans de Goede | 8c1c782 | 2014-06-09 11:36:58 +0200 | [diff] [blame] | 137 | #else |
| 138 | #error Unsupported console port number. Please fix pin mux settings in board.c |
| 139 | #endif |
Ian Campbell | 6efe369 | 2014-05-05 11:52:26 +0100 | [diff] [blame] | 140 | |
| 141 | return 0; |
| 142 | } |
Simon Glass | 8735682 | 2014-12-23 12:04:52 -0700 | [diff] [blame] | 143 | |
Andre Przywara | a563adc | 2017-01-02 11:48:45 +0000 | [diff] [blame] | 144 | #if defined(CONFIG_SPL_BOARD_LOAD_IMAGE) && defined(CONFIG_SPL_BUILD) |
Simon Glass | ee30679 | 2016-09-24 18:20:13 -0600 | [diff] [blame] | 145 | static int spl_board_load_image(struct spl_image_info *spl_image, |
| 146 | struct spl_boot_device *bootdev) |
Simon Glass | 5debe1f | 2015-02-07 10:47:30 -0700 | [diff] [blame] | 147 | { |
| 148 | debug("Returning to FEL sp=%x, lr=%x\n", fel_stash.sp, fel_stash.lr); |
| 149 | return_to_fel(fel_stash.sp, fel_stash.lr); |
Nikita Kiryanov | 33eefe4 | 2015-11-08 17:11:49 +0200 | [diff] [blame] | 150 | |
| 151 | return 0; |
Simon Glass | 5debe1f | 2015-02-07 10:47:30 -0700 | [diff] [blame] | 152 | } |
Simon Glass | 4fc1f25 | 2016-11-30 15:30:50 -0700 | [diff] [blame] | 153 | SPL_LOAD_IMAGE_METHOD("FEL", 0, BOOT_DEVICE_BOARD, spl_board_load_image); |
Simon Glass | a499648 | 2016-09-24 18:20:12 -0600 | [diff] [blame] | 154 | #endif |
Simon Glass | 5debe1f | 2015-02-07 10:47:30 -0700 | [diff] [blame] | 155 | |
Hans de Goede | b42b04d | 2015-01-21 16:24:05 +0100 | [diff] [blame] | 156 | void s_init(void) |
Simon Glass | 8735682 | 2014-12-23 12:04:52 -0700 | [diff] [blame] | 157 | { |
Hans de Goede | b88d0ab | 2016-03-04 10:57:34 +0100 | [diff] [blame] | 158 | /* |
| 159 | * Undocumented magic taken from boot0, without this DRAM |
| 160 | * access gets messed up (seems cache related). |
| 161 | * The boot0 sources describe this as: "config ema for cache sram" |
| 162 | */ |
| 163 | #if defined CONFIG_MACH_SUN6I |
Simon Glass | 8735682 | 2014-12-23 12:04:52 -0700 | [diff] [blame] | 164 | setbits_le32(SUNXI_SRAMC_BASE + 0x44, 0x1800); |
Hans de Goede | c62f8da | 2016-03-24 22:37:08 +0100 | [diff] [blame] | 165 | #elif defined CONFIG_MACH_SUN8I |
| 166 | __maybe_unused uint version; |
Hans de Goede | b88d0ab | 2016-03-04 10:57:34 +0100 | [diff] [blame] | 167 | |
| 168 | /* Unlock sram version info reg, read it, relock */ |
| 169 | setbits_le32(SUNXI_SRAMC_BASE + 0x24, (1 << 15)); |
Hans de Goede | c62f8da | 2016-03-24 22:37:08 +0100 | [diff] [blame] | 170 | version = readl(SUNXI_SRAMC_BASE + 0x24) >> 16; |
Hans de Goede | b88d0ab | 2016-03-04 10:57:34 +0100 | [diff] [blame] | 171 | clrbits_le32(SUNXI_SRAMC_BASE + 0x24, (1 << 15)); |
| 172 | |
Hans de Goede | c62f8da | 2016-03-24 22:37:08 +0100 | [diff] [blame] | 173 | /* |
| 174 | * Ideally this would be a switch case, but we do not know exactly |
| 175 | * which versions there are and which version needs which settings, |
| 176 | * so reproduce the per SoC code from the BSP. |
| 177 | */ |
| 178 | #if defined CONFIG_MACH_SUN8I_A23 |
| 179 | if (version == 0x1650) |
Hans de Goede | b88d0ab | 2016-03-04 10:57:34 +0100 | [diff] [blame] | 180 | setbits_le32(SUNXI_SRAMC_BASE + 0x44, 0x1800); |
| 181 | else /* 0x1661 ? */ |
| 182 | setbits_le32(SUNXI_SRAMC_BASE + 0x44, 0xc0); |
Hans de Goede | c62f8da | 2016-03-24 22:37:08 +0100 | [diff] [blame] | 183 | #elif defined CONFIG_MACH_SUN8I_A33 |
| 184 | if (version != 0x1667) |
| 185 | setbits_le32(SUNXI_SRAMC_BASE + 0x44, 0xc0); |
| 186 | #endif |
| 187 | /* A83T BSP never modifies SUNXI_SRAMC_BASE + 0x44 */ |
| 188 | /* No H3 BSP, boot0 seems to not modify SUNXI_SRAMC_BASE + 0x44 */ |
Simon Glass | 8735682 | 2014-12-23 12:04:52 -0700 | [diff] [blame] | 189 | #endif |
Hans de Goede | b88d0ab | 2016-03-04 10:57:34 +0100 | [diff] [blame] | 190 | |
Andre Przywara | 4330eb9 | 2017-02-16 01:20:21 +0000 | [diff] [blame] | 191 | #if !defined(CONFIG_ARM_CORTEX_CPU_IS_UP) && !defined(CONFIG_ARM64) |
Simon Glass | 8735682 | 2014-12-23 12:04:52 -0700 | [diff] [blame] | 192 | /* Enable SMP mode for CPU0, by setting bit 6 of Auxiliary Ctl reg */ |
| 193 | asm volatile( |
| 194 | "mrc p15, 0, r0, c1, c0, 1\n" |
| 195 | "orr r0, r0, #1 << 6\n" |
Andre Przywara | cd975a4 | 2017-02-16 01:20:18 +0000 | [diff] [blame] | 196 | "mcr p15, 0, r0, c1, c0, 1\n" |
| 197 | ::: "r0"); |
Simon Glass | 8735682 | 2014-12-23 12:04:52 -0700 | [diff] [blame] | 198 | #endif |
Chen-Yu Tsai | 0932b63 | 2016-01-06 15:13:06 +0800 | [diff] [blame] | 199 | #if defined CONFIG_MACH_SUN6I || defined CONFIG_MACH_SUN8I_H3 |
| 200 | /* Enable non-secure access to some peripherals */ |
Chen-Yu Tsai | fcc7b70 | 2015-08-25 10:49:19 +0800 | [diff] [blame] | 201 | tzpc_init(); |
| 202 | #endif |
Simon Glass | 8735682 | 2014-12-23 12:04:52 -0700 | [diff] [blame] | 203 | |
| 204 | clock_init(); |
| 205 | timer_init(); |
| 206 | gpio_init(); |
| 207 | i2c_init_board(); |
Hans de Goede | 42cbbe3 | 2016-03-17 13:53:03 +0100 | [diff] [blame] | 208 | eth_init_board(); |
Hans de Goede | b42b04d | 2015-01-21 16:24:05 +0100 | [diff] [blame] | 209 | } |
Simon Glass | 8735682 | 2014-12-23 12:04:52 -0700 | [diff] [blame] | 210 | |
Hans de Goede | b42b04d | 2015-01-21 16:24:05 +0100 | [diff] [blame] | 211 | #ifdef CONFIG_SPL_BUILD |
Daniel Kochmański | e8b97e2 | 2015-05-29 16:55:42 +0200 | [diff] [blame] | 212 | DECLARE_GLOBAL_DATA_PTR; |
| 213 | |
Hans de Goede | b42b04d | 2015-01-21 16:24:05 +0100 | [diff] [blame] | 214 | /* The sunxi internal brom will try to loader external bootloader |
| 215 | * from mmc0, nand flash, mmc2. |
Hans de Goede | b42b04d | 2015-01-21 16:24:05 +0100 | [diff] [blame] | 216 | */ |
| 217 | u32 spl_boot_device(void) |
| 218 | { |
Hans de Goede | 6527fa2 | 2016-07-09 15:31:47 +0200 | [diff] [blame] | 219 | int boot_source; |
| 220 | |
Siarhei Siamashka | 7ef91f0 | 2015-02-16 10:23:59 +0200 | [diff] [blame] | 221 | /* |
Daniel Kochmański | e8b97e2 | 2015-05-29 16:55:42 +0200 | [diff] [blame] | 222 | * When booting from the SD card or NAND memory, the "eGON.BT0" |
| 223 | * signature is expected to be found in memory at the address 0x0004 |
| 224 | * (see the "mksunxiboot" tool, which generates this header). |
Siarhei Siamashka | 7ef91f0 | 2015-02-16 10:23:59 +0200 | [diff] [blame] | 225 | * |
| 226 | * When booting in the FEL mode over USB, this signature is patched in |
| 227 | * memory and replaced with something else by the 'fel' tool. This other |
| 228 | * signature is selected in such a way, that it can't be present in a |
| 229 | * valid bootable SD card image (because the BROM would refuse to |
| 230 | * execute the SPL in this case). |
| 231 | * |
Daniel Kochmański | e8b97e2 | 2015-05-29 16:55:42 +0200 | [diff] [blame] | 232 | * This checks for the signature and if it is not found returns to |
| 233 | * the FEL code in the BROM to wait and receive the main u-boot |
| 234 | * binary over USB. If it is found, it determines where SPL was |
| 235 | * read from. |
Siarhei Siamashka | 7ef91f0 | 2015-02-16 10:23:59 +0200 | [diff] [blame] | 236 | */ |
Bernhard Nortmann | ead498a | 2015-09-17 18:52:52 +0200 | [diff] [blame] | 237 | if (!is_boot0_magic(SPL_ADDR + 4)) /* eGON.BT0 */ |
Simon Glass | 5debe1f | 2015-02-07 10:47:30 -0700 | [diff] [blame] | 238 | return BOOT_DEVICE_BOARD; |
Daniel Kochmański | e8b97e2 | 2015-05-29 16:55:42 +0200 | [diff] [blame] | 239 | |
Hans de Goede | 6527fa2 | 2016-07-09 15:31:47 +0200 | [diff] [blame] | 240 | boot_source = readb(SPL_ADDR + 0x28); |
| 241 | switch (boot_source) { |
| 242 | case SUNXI_BOOTED_FROM_MMC0: |
Daniel Kochmański | e8b97e2 | 2015-05-29 16:55:42 +0200 | [diff] [blame] | 243 | return BOOT_DEVICE_MMC1; |
Hans de Goede | 6527fa2 | 2016-07-09 15:31:47 +0200 | [diff] [blame] | 244 | case SUNXI_BOOTED_FROM_NAND: |
Daniel Kochmański | e8b97e2 | 2015-05-29 16:55:42 +0200 | [diff] [blame] | 245 | return BOOT_DEVICE_NAND; |
Hans de Goede | 6527fa2 | 2016-07-09 15:31:47 +0200 | [diff] [blame] | 246 | case SUNXI_BOOTED_FROM_MMC2: |
| 247 | return BOOT_DEVICE_MMC2; |
| 248 | case SUNXI_BOOTED_FROM_SPI: |
| 249 | return BOOT_DEVICE_SPI; |
Daniel Kochmański | e8b97e2 | 2015-05-29 16:55:42 +0200 | [diff] [blame] | 250 | } |
| 251 | |
Hans de Goede | 6527fa2 | 2016-07-09 15:31:47 +0200 | [diff] [blame] | 252 | panic("Unknown boot source %d\n", boot_source); |
Daniel Kochmański | e8b97e2 | 2015-05-29 16:55:42 +0200 | [diff] [blame] | 253 | return -1; /* Never reached */ |
Hans de Goede | b42b04d | 2015-01-21 16:24:05 +0100 | [diff] [blame] | 254 | } |
| 255 | |
| 256 | /* No confirmation data available in SPL yet. Hardcode bootmode */ |
Marek Vasut | 64d64bb | 2016-05-14 23:42:07 +0200 | [diff] [blame] | 257 | u32 spl_boot_mode(const u32 boot_device) |
Hans de Goede | b42b04d | 2015-01-21 16:24:05 +0100 | [diff] [blame] | 258 | { |
| 259 | return MMCSD_MODE_RAW; |
| 260 | } |
| 261 | |
| 262 | void board_init_f(ulong dummy) |
| 263 | { |
Hans de Goede | 76fa0b2 | 2015-09-13 12:31:24 +0200 | [diff] [blame] | 264 | spl_init(); |
Simon Glass | 8735682 | 2014-12-23 12:04:52 -0700 | [diff] [blame] | 265 | preloader_console_init(); |
| 266 | |
| 267 | #ifdef CONFIG_SPL_I2C_SUPPORT |
| 268 | /* Needed early by sunxi_board_init if PMU is enabled */ |
| 269 | i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE); |
| 270 | #endif |
| 271 | sunxi_board_init(); |
Simon Glass | 8735682 | 2014-12-23 12:04:52 -0700 | [diff] [blame] | 272 | } |
| 273 | #endif |
Ian Campbell | 6efe369 | 2014-05-05 11:52:26 +0100 | [diff] [blame] | 274 | |
| 275 | void reset_cpu(ulong addr) |
| 276 | { |
Chen-Yu Tsai | 84f3bb4 | 2016-11-30 16:27:14 +0800 | [diff] [blame] | 277 | #if defined(CONFIG_SUNXI_GEN_SUN4I) || defined(CONFIG_MACH_SUN8I_R40) |
Hans de Goede | 1374e89 | 2014-06-09 11:36:56 +0200 | [diff] [blame] | 278 | static const struct sunxi_wdog *wdog = |
| 279 | &((struct sunxi_timer_reg *)SUNXI_TIMER_BASE)->wdog; |
| 280 | |
| 281 | /* Set the watchdog for its shortest interval (.5s) and wait */ |
| 282 | writel(WDT_MODE_RESET_EN | WDT_MODE_EN, &wdog->mode); |
| 283 | writel(WDT_CTRL_KEY | WDT_CTRL_RESTART, &wdog->ctl); |
Hans de Goede | fa43a6e | 2014-06-13 22:55:52 +0200 | [diff] [blame] | 284 | |
| 285 | while (1) { |
| 286 | /* sun5i sometimes gets stuck without this */ |
| 287 | writel(WDT_MODE_RESET_EN | WDT_MODE_EN, &wdog->mode); |
| 288 | } |
Chen-Yu Tsai | 84f3bb4 | 2016-11-30 16:27:14 +0800 | [diff] [blame] | 289 | #elif defined(CONFIG_SUNXI_GEN_SUN6I) |
Chen-Yu Tsai | 1275c48 | 2014-10-04 20:37:28 +0800 | [diff] [blame] | 290 | static const struct sunxi_wdog *wdog = |
| 291 | ((struct sunxi_timer_reg *)SUNXI_TIMER_BASE)->wdog; |
| 292 | |
| 293 | /* Set the watchdog for its shortest interval (.5s) and wait */ |
| 294 | writel(WDT_CFG_RESET, &wdog->cfg); |
| 295 | writel(WDT_MODE_EN, &wdog->mode); |
| 296 | writel(WDT_CTRL_KEY | WDT_CTRL_RESTART, &wdog->ctl); |
Hans de Goede | b25d3c9 | 2015-06-14 16:53:15 +0200 | [diff] [blame] | 297 | while (1) { } |
Chen-Yu Tsai | 1275c48 | 2014-10-04 20:37:28 +0800 | [diff] [blame] | 298 | #endif |
Ian Campbell | 6efe369 | 2014-05-05 11:52:26 +0100 | [diff] [blame] | 299 | } |
| 300 | |
Siarhei Siamashka | 26c50fb | 2016-03-29 17:29:10 +0200 | [diff] [blame] | 301 | #if !defined(CONFIG_SYS_DCACHE_OFF) && !defined(CONFIG_ARM64) |
Ian Campbell | 6efe369 | 2014-05-05 11:52:26 +0100 | [diff] [blame] | 302 | void enable_caches(void) |
| 303 | { |
| 304 | /* Enable D-cache. I-cache is already enabled in start.S */ |
| 305 | dcache_enable(); |
| 306 | } |
| 307 | #endif |