Tom Rini | 10e4779 | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
Heiko Schocher | f853c6c | 2014-07-18 06:07:22 +0200 | [diff] [blame] | 2 | /* |
| 3 | * (C) Copyright 2014 |
| 4 | * Heiko Schocher, DENX Software Engineering, hs@denx.de. |
| 5 | * |
| 6 | * Based on: |
| 7 | * Copyright (C) 2012 Freescale Semiconductor, Inc. |
| 8 | * |
| 9 | * Author: Fabio Estevam <fabio.estevam@freescale.com> |
Heiko Schocher | f853c6c | 2014-07-18 06:07:22 +0200 | [diff] [blame] | 10 | */ |
| 11 | |
Tom Rini | abb9a04 | 2024-05-18 20:20:43 -0600 | [diff] [blame] | 12 | #include <common.h> |
Simon Glass | bcb87b6 | 2022-10-18 07:10:26 -0600 | [diff] [blame] | 13 | #include <bmp_layout.h> |
Simon Glass | ed38aef | 2020-05-10 11:40:03 -0600 | [diff] [blame] | 14 | #include <command.h> |
Simon Glass | 2dc9c34 | 2020-05-10 11:40:01 -0600 | [diff] [blame] | 15 | #include <image.h> |
Simon Glass | 9758973 | 2020-05-10 11:40:02 -0600 | [diff] [blame] | 16 | #include <init.h> |
Heiko Schocher | f853c6c | 2014-07-18 06:07:22 +0200 | [diff] [blame] | 17 | #include <asm/arch/clock.h> |
| 18 | #include <asm/arch/imx-regs.h> |
| 19 | #include <asm/arch/iomux.h> |
| 20 | #include <asm/arch/mx6-pins.h> |
Simon Glass | 3ba929a | 2020-10-30 21:38:53 -0600 | [diff] [blame] | 21 | #include <asm/global_data.h> |
Masahiro Yamada | 56a931c | 2016-09-21 11:28:55 +0900 | [diff] [blame] | 22 | #include <linux/errno.h> |
Heiko Schocher | f853c6c | 2014-07-18 06:07:22 +0200 | [diff] [blame] | 23 | #include <asm/gpio.h> |
Stefano Babic | 33731bc | 2017-06-29 10:16:06 +0200 | [diff] [blame] | 24 | #include <asm/mach-imx/iomux-v3.h> |
| 25 | #include <asm/mach-imx/boot_mode.h> |
Stefano Babic | 33731bc | 2017-06-29 10:16:06 +0200 | [diff] [blame] | 26 | #include <asm/mach-imx/video.h> |
Heiko Schocher | f853c6c | 2014-07-18 06:07:22 +0200 | [diff] [blame] | 27 | #include <asm/arch/crm_regs.h> |
Heiko Schocher | f853c6c | 2014-07-18 06:07:22 +0200 | [diff] [blame] | 28 | #include <asm/io.h> |
| 29 | #include <asm/arch/sys_proto.h> |
Shiji Yang | bb11234 | 2023-08-03 09:47:16 +0800 | [diff] [blame] | 30 | #include <asm/sections.h> |
Heiko Schocher | 8f4a1b9 | 2019-12-01 11:23:19 +0100 | [diff] [blame] | 31 | #include <bmp_logo.h> |
Heiko Schocher | 5433379 | 2019-12-01 11:23:12 +0100 | [diff] [blame] | 32 | #include <dm/root.h> |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 33 | #include <env.h> |
Heiko Schocher | c672968 | 2019-12-01 11:23:23 +0100 | [diff] [blame] | 34 | #include <i2c_eeprom.h> |
| 35 | #include <i2c.h> |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 36 | #include <micrel.h> |
Heiko Schocher | 441b054 | 2019-12-01 11:23:18 +0100 | [diff] [blame] | 37 | #include <miiphy.h> |
Heiko Schocher | 495956b | 2019-12-01 11:23:15 +0100 | [diff] [blame] | 38 | #include <led.h> |
Heiko Schocher | f5210a9 | 2020-03-02 09:44:03 +0100 | [diff] [blame] | 39 | #include <power/pmic.h> |
| 40 | #include <power/regulator.h> |
| 41 | #include <power/da9063_pmic.h> |
Heiko Schocher | 8f4a1b9 | 2019-12-01 11:23:19 +0100 | [diff] [blame] | 42 | #include <splash.h> |
Simon Glass | bcb87b6 | 2022-10-18 07:10:26 -0600 | [diff] [blame] | 43 | #include <video.h> |
Heiko Schocher | f853c6c | 2014-07-18 06:07:22 +0200 | [diff] [blame] | 44 | |
| 45 | DECLARE_GLOBAL_DATA_PTR; |
| 46 | |
Heiko Schocher | 5433379 | 2019-12-01 11:23:12 +0100 | [diff] [blame] | 47 | enum { |
| 48 | BOARD_TYPE_4 = 4, |
| 49 | BOARD_TYPE_7 = 7, |
| 50 | }; |
| 51 | |
| 52 | #define ARI_BT_4 "aristainetos2_4@2" |
| 53 | #define ARI_BT_7 "aristainetos2_7@1" |
| 54 | |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 55 | int board_phy_config(struct phy_device *phydev) |
| 56 | { |
| 57 | /* control data pad skew - devaddr = 0x02, register = 0x04 */ |
| 58 | ksz9031_phy_extended_write(phydev, 0x02, |
| 59 | MII_KSZ9031_EXT_RGMII_CTRL_SIG_SKEW, |
| 60 | MII_KSZ9031_MOD_DATA_NO_POST_INC, 0x0000); |
| 61 | /* rx data pad skew - devaddr = 0x02, register = 0x05 */ |
| 62 | ksz9031_phy_extended_write(phydev, 0x02, |
| 63 | MII_KSZ9031_EXT_RGMII_RX_DATA_SKEW, |
| 64 | MII_KSZ9031_MOD_DATA_NO_POST_INC, 0x0000); |
| 65 | /* tx data pad skew - devaddr = 0x02, register = 0x06 */ |
| 66 | ksz9031_phy_extended_write(phydev, 0x02, |
| 67 | MII_KSZ9031_EXT_RGMII_TX_DATA_SKEW, |
| 68 | MII_KSZ9031_MOD_DATA_NO_POST_INC, 0x0000); |
| 69 | /* gtx and rx clock pad skew - devaddr = 0x02, register = 0x08 */ |
| 70 | ksz9031_phy_extended_write(phydev, 0x02, |
| 71 | MII_KSZ9031_EXT_RGMII_CLOCK_SKEW, |
| 72 | MII_KSZ9031_MOD_DATA_NO_POST_INC, 0x03FF); |
| 73 | |
| 74 | if (phydev->drv->config) |
| 75 | phydev->drv->config(phydev); |
| 76 | |
| 77 | return 0; |
| 78 | } |
| 79 | |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 80 | static int rotate_logo_one(unsigned char *out, unsigned char *in) |
| 81 | { |
| 82 | int i, j; |
| 83 | |
| 84 | for (i = 0; i < BMP_LOGO_WIDTH; i++) |
| 85 | for (j = 0; j < BMP_LOGO_HEIGHT; j++) |
| 86 | out[j * BMP_LOGO_WIDTH + BMP_LOGO_HEIGHT - 1 - i] = |
| 87 | in[i * BMP_LOGO_WIDTH + j]; |
| 88 | return 0; |
| 89 | } |
| 90 | |
| 91 | /* |
| 92 | * Rotate the BMP_LOGO (only) |
| 93 | * Will only work, if the logo is square, as |
| 94 | * BMP_LOGO_HEIGHT and BMP_LOGO_WIDTH are defines, not variables |
| 95 | */ |
| 96 | void rotate_logo(int rotations) |
| 97 | { |
| 98 | unsigned char out_logo[BMP_LOGO_WIDTH * BMP_LOGO_HEIGHT]; |
Heiko Schocher | 8f4a1b9 | 2019-12-01 11:23:19 +0100 | [diff] [blame] | 99 | struct bmp_header *header; |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 100 | unsigned char *in_logo; |
| 101 | int i, j; |
| 102 | |
| 103 | if (BMP_LOGO_WIDTH != BMP_LOGO_HEIGHT) |
| 104 | return; |
| 105 | |
Heiko Schocher | 8f4a1b9 | 2019-12-01 11:23:19 +0100 | [diff] [blame] | 106 | header = (struct bmp_header *)bmp_logo_bitmap; |
| 107 | in_logo = bmp_logo_bitmap + header->data_offset; |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 108 | |
| 109 | /* one 90 degree rotation */ |
| 110 | if (rotations == 1 || rotations == 2 || rotations == 3) |
| 111 | rotate_logo_one(out_logo, in_logo); |
| 112 | |
| 113 | /* second 90 degree rotation */ |
| 114 | if (rotations == 2 || rotations == 3) |
| 115 | rotate_logo_one(in_logo, out_logo); |
| 116 | |
| 117 | /* third 90 degree rotation */ |
| 118 | if (rotations == 3) |
| 119 | rotate_logo_one(out_logo, in_logo); |
| 120 | |
| 121 | /* copy result back to original array */ |
| 122 | if (rotations == 1 || rotations == 3) |
| 123 | for (i = 0; i < BMP_LOGO_WIDTH; i++) |
| 124 | for (j = 0; j < BMP_LOGO_HEIGHT; j++) |
| 125 | in_logo[i * BMP_LOGO_WIDTH + j] = |
| 126 | out_logo[i * BMP_LOGO_WIDTH + j]; |
| 127 | } |
| 128 | |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 129 | static void enable_lvds(struct display_info_t const *dev) |
| 130 | { |
| 131 | struct iomuxc *iomux = (struct iomuxc *)IOMUXC_BASE_ADDR; |
| 132 | struct mxc_ccm_reg *ccm = (struct mxc_ccm_reg *)CCM_BASE_ADDR; |
| 133 | int reg; |
| 134 | s32 timeout = 100000; |
| 135 | |
| 136 | /* set PLL5 clock */ |
| 137 | reg = readl(&ccm->analog_pll_video); |
| 138 | reg |= BM_ANADIG_PLL_VIDEO_POWERDOWN; |
| 139 | writel(reg, &ccm->analog_pll_video); |
| 140 | |
| 141 | /* set PLL5 to 232720000Hz */ |
| 142 | reg &= ~BM_ANADIG_PLL_VIDEO_DIV_SELECT; |
| 143 | reg |= BF_ANADIG_PLL_VIDEO_DIV_SELECT(0x26); |
| 144 | reg &= ~BM_ANADIG_PLL_VIDEO_POST_DIV_SELECT; |
| 145 | reg |= BF_ANADIG_PLL_VIDEO_POST_DIV_SELECT(0); |
| 146 | writel(reg, &ccm->analog_pll_video); |
| 147 | |
| 148 | writel(BF_ANADIG_PLL_VIDEO_NUM_A(0xC0238), |
| 149 | &ccm->analog_pll_video_num); |
| 150 | writel(BF_ANADIG_PLL_VIDEO_DENOM_B(0xF4240), |
| 151 | &ccm->analog_pll_video_denom); |
| 152 | |
| 153 | reg &= ~BM_ANADIG_PLL_VIDEO_POWERDOWN; |
| 154 | writel(reg, &ccm->analog_pll_video); |
| 155 | |
| 156 | while (timeout--) |
| 157 | if (readl(&ccm->analog_pll_video) & BM_ANADIG_PLL_VIDEO_LOCK) |
| 158 | break; |
| 159 | if (timeout < 0) |
| 160 | printf("Warning: video pll lock timeout!\n"); |
| 161 | |
| 162 | reg = readl(&ccm->analog_pll_video); |
| 163 | reg |= BM_ANADIG_PLL_VIDEO_ENABLE; |
| 164 | reg &= ~BM_ANADIG_PLL_VIDEO_BYPASS; |
| 165 | writel(reg, &ccm->analog_pll_video); |
| 166 | |
| 167 | /* set LDB0, LDB1 clk select to 000/000 (PLL5 clock) */ |
| 168 | reg = readl(&ccm->cs2cdr); |
| 169 | reg &= ~(MXC_CCM_CS2CDR_LDB_DI0_CLK_SEL_MASK |
| 170 | | MXC_CCM_CS2CDR_LDB_DI1_CLK_SEL_MASK); |
| 171 | reg |= (0 << MXC_CCM_CS2CDR_LDB_DI0_CLK_SEL_OFFSET) |
| 172 | | (0 << MXC_CCM_CS2CDR_LDB_DI1_CLK_SEL_OFFSET); |
| 173 | writel(reg, &ccm->cs2cdr); |
| 174 | |
| 175 | reg = readl(&ccm->cscmr2); |
| 176 | reg |= MXC_CCM_CSCMR2_LDB_DI0_IPU_DIV; |
| 177 | writel(reg, &ccm->cscmr2); |
| 178 | |
| 179 | reg = readl(&ccm->chsccdr); |
| 180 | reg |= (CHSCCDR_CLK_SEL_LDB_DI0 |
| 181 | << MXC_CCM_CHSCCDR_IPU1_DI0_CLK_SEL_OFFSET); |
| 182 | writel(reg, &ccm->chsccdr); |
| 183 | |
| 184 | reg = IOMUXC_GPR2_BGREF_RRMODE_EXTERNAL_RES |
| 185 | | IOMUXC_GPR2_DI1_VS_POLARITY_ACTIVE_HIGH |
| 186 | | IOMUXC_GPR2_DI0_VS_POLARITY_ACTIVE_HIGH |
| 187 | | IOMUXC_GPR2_BIT_MAPPING_CH0_SPWG |
| 188 | | IOMUXC_GPR2_DATA_WIDTH_CH0_24BIT |
| 189 | | IOMUXC_GPR2_LVDS_CH1_MODE_DISABLED |
| 190 | | IOMUXC_GPR2_LVDS_CH0_MODE_ENABLED_DI0; |
| 191 | writel(reg, &iomux->gpr[2]); |
| 192 | |
| 193 | reg = readl(&iomux->gpr[3]); |
| 194 | reg = (reg & ~IOMUXC_GPR3_LVDS0_MUX_CTL_MASK) |
| 195 | | (IOMUXC_GPR3_MUX_SRC_IPU1_DI0 |
| 196 | << IOMUXC_GPR3_LVDS0_MUX_CTL_OFFSET); |
| 197 | writel(reg, &iomux->gpr[3]); |
| 198 | } |
| 199 | |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 200 | static void setup_display(void) |
| 201 | { |
| 202 | enable_ipu_clock(); |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 203 | } |
| 204 | |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 205 | static void set_gpr_register(void) |
| 206 | { |
| 207 | struct iomuxc *iomuxc_regs = (struct iomuxc *)IOMUXC_BASE_ADDR; |
| 208 | |
| 209 | writel(IOMUXC_GPR1_APP_CLK_REQ_N | IOMUXC_GPR1_PCIE_RDY_L23 | |
| 210 | IOMUXC_GPR1_EXC_MON_SLVE | |
| 211 | (2 << IOMUXC_GPR1_ADDRS0_OFFSET) | |
| 212 | IOMUXC_GPR1_ACT_CS0, |
| 213 | &iomuxc_regs->gpr[1]); |
| 214 | writel(0x0, &iomuxc_regs->gpr[8]); |
| 215 | writel(IOMUXC_GPR12_ARMP_IPG_CLK_EN | IOMUXC_GPR12_ARMP_AHB_CLK_EN | |
| 216 | IOMUXC_GPR12_ARMP_ATB_CLK_EN | IOMUXC_GPR12_ARMP_APB_CLK_EN, |
| 217 | &iomuxc_regs->gpr[12]); |
| 218 | } |
| 219 | |
| 220 | int board_early_init_f(void) |
| 221 | { |
Heiko Schocher | 8f4a1b9 | 2019-12-01 11:23:19 +0100 | [diff] [blame] | 222 | select_ldb_di_clock_source(MXC_PLL5_CLK); |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 223 | set_gpr_register(); |
Heiko Schocher | 5433379 | 2019-12-01 11:23:12 +0100 | [diff] [blame] | 224 | |
| 225 | /* |
| 226 | * clear bss here, so we can use spi driver |
| 227 | * before relocation and read Environment |
| 228 | * from spi flash. |
| 229 | */ |
| 230 | memset(__bss_start, 0x00, __bss_end - __bss_start); |
| 231 | |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 232 | return 0; |
| 233 | } |
| 234 | |
Heiko Schocher | 495956b | 2019-12-01 11:23:15 +0100 | [diff] [blame] | 235 | static void setup_one_led(char *label, int state) |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 236 | { |
Heiko Schocher | 495956b | 2019-12-01 11:23:15 +0100 | [diff] [blame] | 237 | struct udevice *dev; |
| 238 | int ret; |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 239 | |
Heiko Schocher | 495956b | 2019-12-01 11:23:15 +0100 | [diff] [blame] | 240 | ret = led_get_by_label(label, &dev); |
| 241 | if (ret == 0) |
| 242 | led_set_state(dev, state); |
| 243 | } |
| 244 | |
| 245 | static void setup_board_gpio(void) |
| 246 | { |
| 247 | setup_one_led("led_ena", LEDST_ON); |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 248 | /* switch off Status LEDs */ |
Heiko Schocher | 495956b | 2019-12-01 11:23:15 +0100 | [diff] [blame] | 249 | setup_one_led("led_yellow", LEDST_OFF); |
| 250 | setup_one_led("led_red", LEDST_OFF); |
| 251 | setup_one_led("led_green", LEDST_OFF); |
| 252 | setup_one_led("led_blue", LEDST_OFF); |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 253 | } |
| 254 | |
Heiko Schocher | c672968 | 2019-12-01 11:23:23 +0100 | [diff] [blame] | 255 | static void aristainetos_run_rescue_command(int reason) |
| 256 | { |
Heiko Schocher | 5a0baf4 | 2020-11-30 20:46:02 +0100 | [diff] [blame] | 257 | char rescue_reason_command[20]; |
Heiko Schocher | c672968 | 2019-12-01 11:23:23 +0100 | [diff] [blame] | 258 | |
Heiko Schocher | 5a0baf4 | 2020-11-30 20:46:02 +0100 | [diff] [blame] | 259 | sprintf(rescue_reason_command, "setenv rreason %d", reason); |
Heiko Schocher | c672968 | 2019-12-01 11:23:23 +0100 | [diff] [blame] | 260 | run_command(rescue_reason_command, 0); |
| 261 | } |
| 262 | |
Heiko Schocher | 5a0baf4 | 2020-11-30 20:46:02 +0100 | [diff] [blame] | 263 | static int aristainetos_bootmode_settings(void) |
Heiko Schocher | c672968 | 2019-12-01 11:23:23 +0100 | [diff] [blame] | 264 | { |
Heiko Schocher | 5a0baf4 | 2020-11-30 20:46:02 +0100 | [diff] [blame] | 265 | struct gpio_desc *desc; |
| 266 | struct src *psrc = (struct src *)SRC_BASE_ADDR; |
| 267 | unsigned int sbmr1 = readl(&psrc->sbmr1); |
| 268 | char *my_bootdelay; |
| 269 | char bootmode = 0; |
| 270 | int ret; |
Heiko Schocher | c672968 | 2019-12-01 11:23:23 +0100 | [diff] [blame] | 271 | struct udevice *dev; |
| 272 | int off; |
Heiko Schocher | c672968 | 2019-12-01 11:23:23 +0100 | [diff] [blame] | 273 | u8 data[0x10]; |
| 274 | u8 rescue_reason; |
| 275 | |
Heiko Schocher | 5a0baf4 | 2020-11-30 20:46:02 +0100 | [diff] [blame] | 276 | /* jumper controlled reset of the environment */ |
| 277 | ret = gpio_hog_lookup_name("env_reset", &desc); |
| 278 | if (!ret) { |
| 279 | if (dm_gpio_get_value(desc)) { |
| 280 | printf("\nReset u-boot environment (jumper)\n"); |
| 281 | run_command("run default_env; saveenv; saveenv", 0); |
| 282 | } |
| 283 | } |
| 284 | |
Heiko Schocher | c672968 | 2019-12-01 11:23:23 +0100 | [diff] [blame] | 285 | off = fdt_path_offset(gd->fdt_blob, "eeprom0"); |
| 286 | if (off < 0) { |
| 287 | printf("%s: No eeprom0 path offset\n", __func__); |
| 288 | return off; |
| 289 | } |
| 290 | |
| 291 | ret = uclass_get_device_by_of_offset(UCLASS_I2C_EEPROM, off, &dev); |
| 292 | if (ret) { |
| 293 | printf("%s: Could not find EEPROM\n", __func__); |
| 294 | return ret; |
| 295 | } |
| 296 | |
| 297 | ret = i2c_set_chip_offset_len(dev, 2); |
| 298 | if (ret) |
| 299 | return ret; |
| 300 | |
Heiko Schocher | 5a0baf4 | 2020-11-30 20:46:02 +0100 | [diff] [blame] | 301 | ret = i2c_eeprom_read(dev, 0x1ff0, (uint8_t *)data, sizeof(data)); |
Heiko Schocher | c672968 | 2019-12-01 11:23:23 +0100 | [diff] [blame] | 302 | if (ret) { |
| 303 | printf("%s: Could not read EEPROM\n", __func__); |
| 304 | return ret; |
| 305 | } |
| 306 | |
Heiko Schocher | 5a0baf4 | 2020-11-30 20:46:02 +0100 | [diff] [blame] | 307 | /* software controlled reset of the environment (EEPROM magic) */ |
| 308 | if (strncmp((char *)data, "DeF", 3) == 0) { |
Heiko Schocher | c672968 | 2019-12-01 11:23:23 +0100 | [diff] [blame] | 309 | memset(data, 0xff, 3); |
| 310 | i2c_eeprom_write(dev, 0x1ff0, (uint8_t *)data, 3); |
Heiko Schocher | 5a0baf4 | 2020-11-30 20:46:02 +0100 | [diff] [blame] | 311 | printf("\nReset u-boot environment (EEPROM)\n"); |
Heiko Schocher | c672968 | 2019-12-01 11:23:23 +0100 | [diff] [blame] | 312 | run_command("run default_env; saveenv; saveenv", 0); |
| 313 | } |
| 314 | |
Heiko Schocher | 5a0baf4 | 2020-11-30 20:46:02 +0100 | [diff] [blame] | 315 | if (sbmr1 & 0x40) { |
| 316 | env_set("bootmode", "1"); |
| 317 | printf("SD bootmode jumper set!\n"); |
| 318 | } else { |
| 319 | env_set("bootmode", "0"); |
| 320 | } |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 321 | |
| 322 | /* |
| 323 | * Check the boot-source. If booting from NOR Flash, |
| 324 | * disable bootdelay |
| 325 | */ |
Heiko Schocher | e3379da | 2019-12-01 11:23:26 +0100 | [diff] [blame] | 326 | ret = gpio_hog_lookup_name("bootsel0", &desc); |
| 327 | if (!ret) |
Heiko Schocher | 495956b | 2019-12-01 11:23:15 +0100 | [diff] [blame] | 328 | bootmode |= (dm_gpio_get_value(desc) ? 1 : 0) << 0; |
Heiko Schocher | e3379da | 2019-12-01 11:23:26 +0100 | [diff] [blame] | 329 | ret = gpio_hog_lookup_name("bootsel1", &desc); |
| 330 | if (!ret) |
Heiko Schocher | 495956b | 2019-12-01 11:23:15 +0100 | [diff] [blame] | 331 | bootmode |= (dm_gpio_get_value(desc) ? 1 : 0) << 1; |
Heiko Schocher | e3379da | 2019-12-01 11:23:26 +0100 | [diff] [blame] | 332 | ret = gpio_hog_lookup_name("bootsel2", &desc); |
| 333 | if (!ret) |
Heiko Schocher | 495956b | 2019-12-01 11:23:15 +0100 | [diff] [blame] | 334 | bootmode |= (dm_gpio_get_value(desc) ? 1 : 0) << 2; |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 335 | |
| 336 | if (bootmode == 7) { |
| 337 | my_bootdelay = env_get("nor_bootdelay"); |
Heiko Schocher | e3379da | 2019-12-01 11:23:26 +0100 | [diff] [blame] | 338 | if (my_bootdelay) |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 339 | env_set("bootdelay", my_bootdelay); |
| 340 | else |
| 341 | env_set("bootdelay", "-2"); |
| 342 | } |
| 343 | |
Heiko Schocher | 5a0baf4 | 2020-11-30 20:46:02 +0100 | [diff] [blame] | 344 | /* jumper controlled boot of the rescue system */ |
Heiko Schocher | 495956b | 2019-12-01 11:23:15 +0100 | [diff] [blame] | 345 | ret = gpio_hog_lookup_name("boot_rescue", &desc); |
| 346 | if (!ret) { |
| 347 | if (dm_gpio_get_value(desc)) { |
Heiko Schocher | 5a0baf4 | 2020-11-30 20:46:02 +0100 | [diff] [blame] | 348 | printf("\nBooting into Rescue System (jumper)\n"); |
Heiko Schocher | 495956b | 2019-12-01 11:23:15 +0100 | [diff] [blame] | 349 | aristainetos_run_rescue_command(16); |
| 350 | run_command("run rescue_xload_boot", 0); |
| 351 | } |
| 352 | } |
Heiko Schocher | 5a0baf4 | 2020-11-30 20:46:02 +0100 | [diff] [blame] | 353 | |
| 354 | /* software controlled boot of the rescue system (EEPROM magic) */ |
| 355 | if (strncmp((char *)&data[3], "ReScUe", 6) == 0) { |
| 356 | rescue_reason = *(uint8_t *)&data[9]; |
| 357 | memset(&data[3], 0xff, 7); |
| 358 | i2c_eeprom_write(dev, 0x1ff0, (uint8_t *)&data[3], 7); |
| 359 | printf("\nBooting into Rescue System (EEPROM)\n"); |
| 360 | aristainetos_run_rescue_command(rescue_reason); |
| 361 | run_command("run rescue_xload_boot", 0); |
| 362 | } |
| 363 | |
| 364 | return 0; |
Heiko Schocher | e3379da | 2019-12-01 11:23:26 +0100 | [diff] [blame] | 365 | } |
| 366 | |
Heiko Schocher | f5210a9 | 2020-03-02 09:44:03 +0100 | [diff] [blame] | 367 | #if defined(CONFIG_DM_PMIC_DA9063) |
| 368 | /* |
| 369 | * On the aristainetos2c boards the PMIC needs to be initialized, |
| 370 | * because the Ethernet PHY uses a different regulator that is not |
| 371 | * setup per hardware default. This does not influence the other versions |
| 372 | * as this regulator isn't used there at all. |
| 373 | * |
| 374 | * Unfortunately we have not yet a interface to setup all |
| 375 | * values we need. |
| 376 | */ |
| 377 | static int setup_pmic_voltages(void) |
| 378 | { |
| 379 | struct udevice *dev; |
| 380 | int off; |
| 381 | int ret; |
| 382 | |
| 383 | off = fdt_path_offset(gd->fdt_blob, "pmic0"); |
| 384 | if (off < 0) { |
| 385 | printf("%s: No pmic path offset\n", __func__); |
| 386 | return off; |
| 387 | } |
| 388 | |
| 389 | ret = uclass_get_device_by_of_offset(UCLASS_PMIC, off, &dev); |
| 390 | if (ret) { |
| 391 | printf("%s: Could not find PMIC\n", __func__); |
| 392 | return ret; |
| 393 | } |
| 394 | |
| 395 | pmic_reg_write(dev, DA9063_REG_PAGE_CON, 0x01); |
| 396 | pmic_reg_write(dev, DA9063_REG_BPRO_CFG, 0xc1); |
| 397 | ret = pmic_reg_read(dev, DA9063_REG_BUCK_ILIM_B); |
| 398 | if (ret < 0) { |
| 399 | printf("%s: error %d get register\n", __func__, ret); |
| 400 | return ret; |
| 401 | } |
| 402 | ret &= 0xf0; |
| 403 | ret |= 0x09; |
| 404 | pmic_reg_write(dev, DA9063_REG_BUCK_ILIM_B, ret); |
| 405 | pmic_reg_write(dev, DA9063_REG_VBPRO_A, 0x43); |
| 406 | pmic_reg_write(dev, DA9063_REG_VBPRO_B, 0xc3); |
| 407 | |
| 408 | return 0; |
| 409 | } |
| 410 | #else |
| 411 | static int setup_pmic_voltages(void) |
| 412 | { |
| 413 | return 0; |
| 414 | } |
| 415 | #endif |
| 416 | |
Heiko Schocher | e3379da | 2019-12-01 11:23:26 +0100 | [diff] [blame] | 417 | int board_late_init(void) |
| 418 | { |
| 419 | int x, y; |
Heiko Schocher | 5a0baf4 | 2020-11-30 20:46:02 +0100 | [diff] [blame] | 420 | int ret; |
Heiko Schocher | e3379da | 2019-12-01 11:23:26 +0100 | [diff] [blame] | 421 | |
Heiko Schocher | e3379da | 2019-12-01 11:23:26 +0100 | [diff] [blame] | 422 | splash_get_pos(&x, &y); |
| 423 | bmp_display((ulong)&bmp_logo_bitmap[0], x, y); |
| 424 | |
Heiko Schocher | 5a0baf4 | 2020-11-30 20:46:02 +0100 | [diff] [blame] | 425 | ret = aristainetos_bootmode_settings(); |
| 426 | if (ret) |
| 427 | return ret; |
Heiko Schocher | c672968 | 2019-12-01 11:23:23 +0100 | [diff] [blame] | 428 | |
Heiko Schocher | 5433379 | 2019-12-01 11:23:12 +0100 | [diff] [blame] | 429 | /* set board_type */ |
| 430 | if (gd->board_type == BOARD_TYPE_4) |
| 431 | env_set("board_type", ARI_BT_4); |
| 432 | else |
| 433 | env_set("board_type", ARI_BT_7); |
Heiko Schocher | e3379da | 2019-12-01 11:23:26 +0100 | [diff] [blame] | 434 | |
Heiko Schocher | f5210a9 | 2020-03-02 09:44:03 +0100 | [diff] [blame] | 435 | if (setup_pmic_voltages()) |
| 436 | printf("Error setup PMIC\n"); |
| 437 | |
Heiko Schocher | a051ee9 | 2019-12-01 11:23:11 +0100 | [diff] [blame] | 438 | return 0; |
| 439 | } |
Heiko Schocher | 0572982 | 2015-05-18 13:32:31 +0200 | [diff] [blame] | 440 | |
Heiko Schocher | 0572982 | 2015-05-18 13:32:31 +0200 | [diff] [blame] | 441 | int dram_init(void) |
Heiko Schocher | f853c6c | 2014-07-18 06:07:22 +0200 | [diff] [blame] | 442 | { |
Fabio Estevam | 1b23fe5 | 2016-07-23 13:23:39 -0300 | [diff] [blame] | 443 | gd->ram_size = imx_ddr_size(); |
Heiko Schocher | f853c6c | 2014-07-18 06:07:22 +0200 | [diff] [blame] | 444 | |
Heiko Schocher | 0572982 | 2015-05-18 13:32:31 +0200 | [diff] [blame] | 445 | return 0; |
Heiko Schocher | f853c6c | 2014-07-18 06:07:22 +0200 | [diff] [blame] | 446 | } |
| 447 | |
Heiko Schocher | f853c6c | 2014-07-18 06:07:22 +0200 | [diff] [blame] | 448 | struct display_info_t const displays[] = { |
| 449 | { |
| 450 | .bus = -1, |
| 451 | .addr = 0, |
| 452 | .pixfmt = IPU_PIX_FMT_RGB24, |
| 453 | .detect = NULL, |
| 454 | .enable = enable_lvds, |
| 455 | .mode = { |
| 456 | .name = "lb07wv8", |
| 457 | .refresh = 60, |
| 458 | .xres = 800, |
| 459 | .yres = 480, |
Heiko Schocher | 2781329 | 2015-08-11 08:09:44 +0200 | [diff] [blame] | 460 | .pixclock = 30066, |
Heiko Schocher | f853c6c | 2014-07-18 06:07:22 +0200 | [diff] [blame] | 461 | .left_margin = 88, |
| 462 | .right_margin = 88, |
Heiko Schocher | 2781329 | 2015-08-11 08:09:44 +0200 | [diff] [blame] | 463 | .upper_margin = 20, |
| 464 | .lower_margin = 20, |
Heiko Schocher | 69f0e44 | 2015-01-20 10:06:18 +0100 | [diff] [blame] | 465 | .hsync_len = 80, |
Heiko Schocher | 2781329 | 2015-08-11 08:09:44 +0200 | [diff] [blame] | 466 | .vsync_len = 5, |
| 467 | .sync = FB_SYNC_EXT, |
Heiko Schocher | f853c6c | 2014-07-18 06:07:22 +0200 | [diff] [blame] | 468 | .vmode = FB_VMODE_NONINTERLACED |
| 469 | } |
| 470 | } |
| 471 | }; |
| 472 | size_t display_count = ARRAY_SIZE(displays); |
| 473 | |
Heiko Schocher | f853c6c | 2014-07-18 06:07:22 +0200 | [diff] [blame] | 474 | int board_init(void) |
| 475 | { |
| 476 | struct iomuxc *iomux = (struct iomuxc *)IOMUXC_BASE_ADDR; |
| 477 | |
| 478 | /* address of boot parameters */ |
| 479 | gd->bd->bi_boot_params = PHYS_SDRAM + 0x100; |
| 480 | |
Heiko Schocher | 0572982 | 2015-05-18 13:32:31 +0200 | [diff] [blame] | 481 | setup_board_gpio(); |
Heiko Schocher | 8f4a1b9 | 2019-12-01 11:23:19 +0100 | [diff] [blame] | 482 | setup_display(); |
Heiko Schocher | f853c6c | 2014-07-18 06:07:22 +0200 | [diff] [blame] | 483 | |
| 484 | /* GPIO_1 for USB_OTG_ID */ |
Heiko Schocher | 0572982 | 2015-05-18 13:32:31 +0200 | [diff] [blame] | 485 | clrsetbits_le32(&iomux->gpr[1], IOMUXC_GPR1_USB_OTG_ID_SEL_MASK, 0); |
Heiko Schocher | f853c6c | 2014-07-18 06:07:22 +0200 | [diff] [blame] | 486 | return 0; |
| 487 | } |
| 488 | |
Heiko Schocher | 5433379 | 2019-12-01 11:23:12 +0100 | [diff] [blame] | 489 | int board_fit_config_name_match(const char *name) |
| 490 | { |
| 491 | if (gd->board_type == BOARD_TYPE_4 && |
| 492 | strchr(name, 0x34)) |
| 493 | return 0; |
| 494 | |
| 495 | if (gd->board_type == BOARD_TYPE_7 && |
| 496 | strchr(name, 0x37)) |
| 497 | return 0; |
| 498 | |
| 499 | return -1; |
| 500 | } |
| 501 | |
| 502 | static void do_board_detect(void) |
| 503 | { |
| 504 | int ret; |
| 505 | char s[30]; |
| 506 | |
| 507 | /* default use board type 7 */ |
| 508 | gd->board_type = BOARD_TYPE_7; |
| 509 | if (env_init()) |
| 510 | return; |
| 511 | |
| 512 | ret = env_get_f("panel", s, sizeof(s)); |
| 513 | if (ret < 0) |
| 514 | return; |
| 515 | |
| 516 | if (!strncmp("lg4573", s, 6)) |
| 517 | gd->board_type = BOARD_TYPE_4; |
| 518 | } |
| 519 | |
| 520 | #ifdef CONFIG_DTB_RESELECT |
| 521 | int embedded_dtb_select(void) |
| 522 | { |
| 523 | int rescan; |
| 524 | |
| 525 | do_board_detect(); |
| 526 | fdtdec_resetup(&rescan); |
| 527 | |
Heiko Schocher | f853c6c | 2014-07-18 06:07:22 +0200 | [diff] [blame] | 528 | return 0; |
| 529 | } |
| 530 | #endif |