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