arch/arm/mach-tegra/board2.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *  (C) Copyright 2010,2011
   4  *  NVIDIA Corporation <www.nvidia.com>
   5  */
   6
   7 #include <common.h>
   8 #include <dm.h>
   9 #include <env.h>
  10 #include <errno.h>
  11 #include <init.h>
  12 #include <log.h>
  13 #include <ns16550.h>
  14 #include <usb.h>
  15 #include <asm/global_data.h>
  16 #include <asm/io.h>
  17 #include <asm/arch-tegra/ap.h>
  18 #include <asm/arch-tegra/board.h>
  19 #include <asm/arch-tegra/cboot.h>
  20 #include <asm/arch-tegra/clk_rst.h>
  21 #include <asm/arch-tegra/pmc.h>
  22 #include <asm/arch-tegra/pmu.h>
  23 #include <asm/arch-tegra/sys_proto.h>
  24 #include <asm/arch-tegra/uart.h>
  25 #include <asm/arch-tegra/warmboot.h>
  26 #include <asm/arch-tegra/gpu.h>
  27 #include <asm/arch-tegra/usb.h>
  28 #include <asm/arch-tegra/xusb-padctl.h>
  29 #if IS_ENABLED(CONFIG_TEGRA_CLKRST)
  30 #include <asm/arch/clock.h>
  31 #endif
  32 #if IS_ENABLED(CONFIG_TEGRA_PINCTRL)
  33 #include <asm/arch/funcmux.h>
  34 #include <asm/arch/pinmux.h>
  35 #endif
  36 #include <asm/arch/tegra.h>
  37 #ifdef CONFIG_TEGRA_CLOCK_SCALING
  38 #include <asm/arch/emc.h>
  39 #endif
  40 #include "emc.h"
  41
  42 DECLARE_GLOBAL_DATA_PTR;
  43
  44 #ifdef CONFIG_SPL_BUILD
  45 /* TODO([email protected]): Remove once SPL supports device tree */
  46 U_BOOT_DRVINFO(tegra_gpios) = {
  47         "gpio_tegra"
  48 };
  49 #endif
  50
  51 __weak void pinmux_init(void) {}
  52 __weak void pin_mux_usb(void) {}
  53 __weak void pin_mux_spi(void) {}
  54 __weak void pin_mux_mmc(void) {}
  55 __weak void gpio_early_init_uart(void) {}
  56 __weak void pin_mux_display(void) {}
  57 __weak void start_cpu_fan(void) {}
  58 __weak void cboot_late_init(void) {}
  59 __weak void nvidia_board_late_init(void) {}
  60
  61 #if defined(CONFIG_TEGRA_NAND)
  62 __weak void pin_mux_nand(void)
  63 {
  64         funcmux_select(PERIPH_ID_NDFLASH, FUNCMUX_DEFAULT);
  65 }
  66 #endif
  67
  68 /*
  69  * Routine: power_det_init
  70  * Description: turn off power detects
  71  */
  72 static void power_det_init(void)
  73 {
  74 #if defined(CONFIG_TEGRA20)
  75         struct pmc_ctlr *const pmc = (struct pmc_ctlr *)NV_PA_PMC_BASE;
  76
  77         /* turn off power detects */
  78         writel(0, &pmc->pmc_pwr_det_latch);
  79         writel(0, &pmc->pmc_pwr_det);
  80 #endif
  81 }
  82
  83 __weak int tegra_board_id(void)
  84 {
  85         return -1;
  86 }
  87
  88 #ifdef CONFIG_DISPLAY_BOARDINFO
  89 int checkboard(void)
  90 {
  91         int board_id = tegra_board_id();
  92
  93         printf("Board: %s", CFG_TEGRA_BOARD_STRING);
  94         if (board_id != -1)
  95                 printf(", ID: %d\n", board_id);
  96         printf("\n");
  97
  98         return 0;
  99 }
 100 #endif  /* CONFIG_DISPLAY_BOARDINFO */
 101
 102 __weak int tegra_lcd_pmic_init(int board_it)
 103 {
 104         return 0;
 105 }
 106
 107 __weak int nvidia_board_init(void)
 108 {
 109         return 0;
 110 }
 111
 112 /*
 113  * Routine: board_init
 114  * Description: Early hardware init.
 115  */
 116 int board_init(void)
 117 {
 118         __maybe_unused int err;
 119         __maybe_unused int board_id;
 120
 121         /* Do clocks and UART first so that printf() works */
 122 #if IS_ENABLED(CONFIG_TEGRA_CLKRST)
 123         clock_init();
 124         clock_verify();
 125 #endif
 126
 127         tegra_gpu_config();
 128
 129 #ifdef CONFIG_TEGRA_SPI
 130         pin_mux_spi();
 131 #endif
 132
 133 #ifdef CONFIG_MMC_SDHCI_TEGRA
 134         pin_mux_mmc();
 135 #endif
 136
 137         /* Init is handled automatically in the driver-model case */
 138 #if defined(CONFIG_VIDEO)
 139         pin_mux_display();
 140 #endif
 141         /* boot param addr */
 142         gd->bd->bi_boot_params = (NV_PA_SDRAM_BASE + 0x100);
 143
 144         power_det_init();
 145
 146 #ifdef CONFIG_SYS_I2C_TEGRA
 147 # ifdef CONFIG_TEGRA_PMU
 148         if (pmu_set_nominal())
 149                 debug("Failed to select nominal voltages\n");
 150 #  ifdef CONFIG_TEGRA_CLOCK_SCALING
 151         err = board_emc_init();
 152         if (err)
 153                 debug("Memory controller init failed: %d\n", err);
 154 #  endif
 155 # endif /* CONFIG_TEGRA_PMU */
 156 #endif /* CONFIG_SYS_I2C_TEGRA */
 157
 158 #ifdef CONFIG_USB_EHCI_TEGRA
 159         pin_mux_usb();
 160 #endif
 161
 162 #if defined(CONFIG_VIDEO)
 163         board_id = tegra_board_id();
 164         err = tegra_lcd_pmic_init(board_id);
 165         if (err) {
 166                 debug("Failed to set up LCD PMIC\n");
 167                 return err;
 168         }
 169 #endif
 170
 171 #ifdef CONFIG_TEGRA_NAND
 172         pin_mux_nand();
 173 #endif
 174
 175         tegra_xusb_padctl_init();
 176
 177 #ifdef CONFIG_TEGRA_LP0
 178         /* save Sdram params to PMC 2, 4, and 24 for WB0 */
 179         warmboot_save_sdram_params();
 180
 181         /* prepare the WB code to LP0 location */
 182         warmboot_prepare_code(TEGRA_LP0_ADDR, TEGRA_LP0_SIZE);
 183 #endif
 184         return nvidia_board_init();
 185 }
 186
 187 void board_cleanup_before_linux(void)
 188 {
 189         /* power down UPHY PLL */
 190         tegra_xusb_padctl_exit();
 191 }
 192
 193 #ifdef CONFIG_BOARD_EARLY_INIT_F
 194 static void __gpio_early_init(void)
 195 {
 196 }
 197
 198 void gpio_early_init(void) __attribute__((weak, alias("__gpio_early_init")));
 199
 200 int board_early_init_f(void)
 201 {
 202 #if IS_ENABLED(CONFIG_TEGRA_CLKRST)
 203         if (!clock_early_init_done())
 204                 clock_early_init();
 205 #endif
 206
 207 #if defined(CONFIG_TEGRA_DISCONNECT_UDC_ON_BOOT)
 208 #define USBCMD_FS2 (1 << 15)
 209         {
 210                 struct usb_ctlr *usbctlr = (struct usb_ctlr *)0x7d000000;
 211                 writel(USBCMD_FS2, &usbctlr->usb_cmd);
 212         }
 213 #endif
 214
 215         /* Do any special system timer/TSC setup */
 216 #if IS_ENABLED(CONFIG_TEGRA_CLKRST)
 217 #  if defined(CONFIG_TEGRA_SUPPORT_NON_SECURE)
 218         if (!tegra_cpu_is_non_secure())
 219 #  endif
 220                 arch_timer_init();
 221 #endif
 222
 223 #if defined(CONFIG_DISABLE_SDMMC1_EARLY)
 224         /*
 225          * Turn off (reset/disable) SDMMC1 on Nano here, before GPIO INIT.
 226          * We do this because earlier bootloaders have enabled power to
 227          * SDMMC1 on Nano, and toggling power-gpio (PZ3) in pinmux_init()
 228          * results in power being back-driven into the SD-card and SDMMC1
 229          * HW, which is 'bad' as per the HW team.
 230          *
 231          * From the HW team: "LDO2 from the PMIC has already been set to 3.3v in
 232          * nvtboot/CBoot on Nano (for SD-card boot). So when U-Boot's GPIO_INIT
 233          * table sets PZ3 to OUT0 as per the pinmux spreadsheet, it turns off
 234          * the loadswitch. When PZ3 is 0 and not driving, essentially the SDCard
 235          * voltage turns off. Since the SDCard voltage is no longer there, the
 236          * SDMMC CLK/DAT lines are backdriving into what essentially is a
 237          * powered-off SDCard, that's why the voltage drops from 3.3V to ~1.6V"
 238          *
 239          * Note that this can probably be removed when we change over to storing
 240          * all BL components on QSPI on Nano, and U-Boot then becomes the first
 241          * one to turn on SDMMC1 power. Another fix would be to have CBoot
 242          * disable power/gate SDMMC1 off before handing off to U-Boot/kernel.
 243          */
 244         reset_set_enable(PERIPH_ID_SDMMC1, 1);
 245         clock_set_enable(PERIPH_ID_SDMMC1, 0);
 246 #endif  /* CONFIG_DISABLE_SDMMC1_EARLY */
 247
 248         pinmux_init();
 249         board_init_uart_f();
 250
 251         /* Initialize periph GPIOs */
 252         gpio_early_init();
 253         gpio_early_init_uart();
 254
 255         return 0;
 256 }
 257 #endif  /* EARLY_INIT */
 258
 259 int board_late_init(void)
 260 {
 261 #if defined(CONFIG_TEGRA_SUPPORT_NON_SECURE)
 262         if (tegra_cpu_is_non_secure()) {
 263                 printf("CPU is in NS mode\n");
 264                 env_set("cpu_ns_mode", "1");
 265         } else {
 266                 env_set("cpu_ns_mode", "");
 267         }
 268 #endif
 269         start_cpu_fan();
 270         cboot_late_init();
 271         nvidia_board_late_init();
 272
 273         return 0;
 274 }
 275
 276 /*
 277  * In some SW environments, a memory carve-out exists to house a secure
 278  * monitor, a trusted OS, and/or various statically allocated media buffers.
 279  *
 280  * This carveout exists at the highest possible address that is within a
 281  * 32-bit physical address space.
 282  *
 283  * This function returns the total size of this carve-out. At present, the
 284  * returned value is hard-coded for simplicity. In the future, it may be
 285  * possible to determine the carve-out size:
 286  * - By querying some run-time information source, such as:
 287  *   - A structure passed to U-Boot by earlier boot software.
 288  *   - SoC registers.
 289  *   - A call into the secure monitor.
 290  * - In the per-board U-Boot configuration header, based on knowledge of the
 291  *   SW environment that U-Boot is being built for.
 292  *
 293  * For now, we support two configurations in U-Boot:
 294  * - 32-bit ports without any form of carve-out.
 295  * - 64 bit ports which are assumed to use a carve-out of a conservatively
 296  *   hard-coded size.
 297  */
 298 static ulong carveout_size(void)
 299 {
 300 #ifdef CONFIG_ARM64
 301         return SZ_512M;
 302 #elif defined(CONFIG_ARMV7_SECURE_RESERVE_SIZE)
 303         // BASE+SIZE might not == 4GB. If so, we want the carveout to cover
 304         // from BASE to 4GB, not BASE to BASE+SIZE.
 305         return (0 - CONFIG_ARMV7_SECURE_BASE) & ~(SZ_2M - 1);
 306 #else
 307         return 0;
 308 #endif
 309 }
 310
 311 /*
 312  * Determine the amount of usable RAM below 4GiB, taking into account any
 313  * carve-out that may be assigned.
 314  */
 315 static ulong usable_ram_size_below_4g(void)
 316 {
 317         ulong total_size_below_4g;
 318         ulong usable_size_below_4g;
 319
 320         /*
 321          * The total size of RAM below 4GiB is the lesser address of:
 322          * (a) 2GiB itself (RAM starts at 2GiB, and 4GiB - 2GiB == 2GiB).
 323          * (b) The size RAM physically present in the system.
 324          */
 325         if (gd->ram_size < SZ_2G)
 326                 total_size_below_4g = gd->ram_size;
 327         else
 328                 total_size_below_4g = SZ_2G;
 329
 330         /* Calculate usable RAM by subtracting out any carve-out size */
 331         usable_size_below_4g = total_size_below_4g - carveout_size();
 332
 333         return usable_size_below_4g;
 334 }
 335
 336 /*
 337  * Represent all available RAM in either one or two banks.
 338  *
 339  * The first bank describes any usable RAM below 4GiB.
 340  * The second bank describes any RAM above 4GiB.
 341  *
 342  * This split is driven by the following requirements:
 343  * - The NVIDIA L4T kernel requires separate entries in the DT /memory/reg
 344  *   property for memory below and above the 4GiB boundary. The layout of that
 345  *   DT property is directly driven by the entries in the U-Boot bank array.
 346  * - The potential existence of a carve-out at the end of RAM below 4GiB can
 347  *   only be represented using multiple banks.
 348  *
 349  * Explicitly removing the carve-out RAM from the bank entries makes the RAM
 350  * layout a bit more obvious, e.g. when running "bdinfo" at the U-Boot
 351  * command-line.
 352  *
 353  * This does mean that the DT U-Boot passes to the Linux kernel will not
 354  * include this RAM in /memory/reg at all. An alternative would be to include
 355  * all RAM in the U-Boot banks (and hence DT), and add a /memreserve/ node
 356  * into DT to stop the kernel from using the RAM. IIUC, I don't /think/ the
 357  * Linux kernel will ever need to access any RAM in* the carve-out via a CPU
 358  * mapping, so either way is acceptable.
 359  *
 360  * On 32-bit systems, we never define a bank for RAM above 4GiB, since the
 361  * start address of that bank cannot be represented in the 32-bit .size
 362  * field.
 363  */
 364 int dram_init_banksize(void)
 365 {
 366         int err;
 367
 368         /* try to compute DRAM bank size based on cboot DTB first */
 369         err = cboot_dram_init_banksize();
 370         if (err == 0)
 371                 return err;
 372
 373         /* fall back to default DRAM bank size computation */
 374
 375         gd->bd->bi_dram[0].start = CFG_SYS_SDRAM_BASE;
 376         gd->bd->bi_dram[0].size = usable_ram_size_below_4g();
 377
 378 #ifdef CONFIG_PCI
 379         gd->pci_ram_top = gd->bd->bi_dram[0].start + gd->bd->bi_dram[0].size;
 380 #endif
 381
 382 #ifdef CONFIG_PHYS_64BIT
 383         if (gd->ram_size > SZ_2G) {
 384                 gd->bd->bi_dram[1].start = 0x100000000;
 385                 gd->bd->bi_dram[1].size = gd->ram_size - SZ_2G;
 386         } else
 387 #endif
 388         {
 389                 gd->bd->bi_dram[1].start = 0;
 390                 gd->bd->bi_dram[1].size = 0;
 391         }
 392
 393         return 0;
 394 }
 395
 396 /*
 397  * Most hardware on 64-bit Tegra is still restricted to DMA to the lower
 398  * 32-bits of the physical address space. Cap the maximum usable RAM area
 399  * at 4 GiB to avoid DMA buffers from being allocated beyond the 32-bit
 400  * boundary that most devices can address. Also, don't let U-Boot use any
 401  * carve-out, as mentioned above.
 402  *
 403  * This function is called before dram_init_banksize(), so we can't simply
 404  * return gd->bd->bi_dram[1].start + gd->bd->bi_dram[1].size.
 405  */
 406 phys_size_t board_get_usable_ram_top(phys_size_t total_size)
 407 {
 408         ulong ram_top;
 409
 410         /* try to get top of usable RAM based on cboot DTB first */
 411         ram_top = cboot_get_usable_ram_top(total_size);
 412         if (ram_top > 0)
 413                 return ram_top;
 414
 415         /* fall back to default usable RAM computation */
 416
 417         return CFG_SYS_SDRAM_BASE + usable_ram_size_below_4g();
 418 }