arch/arm/cpu/arm926ejs/mxs/mxs.c

   1 /*
   2  * Freescale i.MX23/i.MX28 common code
   3  *
   4  * Copyright (C) 2011 Marek Vasut <marek.vasut@gmail.com>
   5  * on behalf of DENX Software Engineering GmbH
   6  *
   7  * Based on code from LTIB:
   8  * Copyright (C) 2010 Freescale Semiconductor, Inc.
   9  *
  10  * SPDX-License-Identifier:     GPL-2.0+
  11  */
  12
  13 #include <common.h>
  14 #include <asm/errno.h>
  15 #include <asm/io.h>
  16 #include <asm/arch/clock.h>
  17 #include <asm/imx-common/dma.h>
  18 #include <asm/arch/gpio.h>
  19 #include <asm/arch/iomux.h>
  20 #include <asm/arch/imx-regs.h>
  21 #include <asm/arch/sys_proto.h>
  22 #include <linux/compiler.h>
  23
  24 DECLARE_GLOBAL_DATA_PTR;
  25
  26 /* Lowlevel init isn't used on i.MX28, so just have a dummy here */
  27 inline void lowlevel_init(void) {}
  28
  29 #define BOOT_CAUSE_MASK         (RTC_PERSISTENT0_EXTERNAL_RESET |       \
  30                                 RTC_PERSISTENT0_ALARM_WAKE |            \
  31                                 RTC_PERSISTENT0_THERMAL_RESET)
  32
  33 static int wait_rtc_stat(u32 mask)
  34 {
  35         int timeout = 5000;
  36         u32 val;
  37         struct mxs_rtc_regs *rtc_regs = (void *)MXS_RTC_BASE;
  38         u32 old_val = readl(&rtc_regs->hw_rtc_stat);
  39
  40         debug("stat=%x\n", old_val);
  41
  42         while ((val = readl(&rtc_regs->hw_rtc_stat)) & mask) {
  43                 if (val != old_val) {
  44                         old_val = val;
  45                         debug("stat: %x -> %x\n", old_val, val);
  46                 }
  47                 udelay(1);
  48                 if (timeout-- < 0)
  49                         break;
  50         }
  51         return !!(readl(&rtc_regs->hw_rtc_stat) & mask);
  52 }
  53
  54 void reset_cpu(ulong ignored) __attribute__((noreturn));
  55
  56 void reset_cpu(ulong ignored)
  57 {
  58         struct mxs_rtc_regs *rtc_regs =
  59                 (struct mxs_rtc_regs *)MXS_RTC_BASE;
  60         struct mxs_lcdif_regs *lcdif_regs =
  61                 (struct mxs_lcdif_regs *)MXS_LCDIF_BASE;
  62         u32 reg;
  63
  64         /*
  65          * Shut down the LCD controller as it interferes with BootROM boot mode
  66          * pads sampling.
  67          */
  68         writel(LCDIF_CTRL_RUN, &lcdif_regs->hw_lcdif_ctrl_clr);
  69
  70         reg = readl(&rtc_regs->hw_rtc_persistent0);
  71         if (reg & BOOT_CAUSE_MASK) {
  72                 writel(reg & ~BOOT_CAUSE_MASK, &rtc_regs->hw_rtc_persistent0);
  73                 wait_rtc_stat(RTC_STAT_NEW_REGS_PERSISTENT0);
  74         }
  75
  76         /* Wait 1 mS before doing the actual watchdog reset */
  77         writel(1, &rtc_regs->hw_rtc_watchdog);
  78         writel(RTC_CTRL_WATCHDOGEN, &rtc_regs->hw_rtc_ctrl_set);
  79
  80         /* Endless loop, reset will exit from here */
  81         for (;;)
  82                 ;
  83 }
  84
  85 void enable_caches(void)
  86 {
  87 #ifndef CONFIG_SYS_ICACHE_OFF
  88         icache_enable();
  89 #endif
  90 #ifndef CONFIG_SYS_DCACHE_OFF
  91         dcache_enable();
  92 #endif
  93 }
  94
  95 /*
  96  * This function will craft a jumptable at 0x0 which will redirect interrupt
  97  * vectoring to proper location of U-Boot in RAM.
  98  *
  99  * The structure of the jumptable will be as follows:
 100  *  ldr pc, [pc, #0x18] ..... for each vector, thus repeated 8 times
 101  *  <destination address> ... for each previous ldr, thus also repeated 8 times
 102  *
 103  * The "ldr pc, [pc, #0x18]" instruction above loads address from memory at
 104  * offset 0x18 from current value of PC register. Note that PC is already
 105  * incremented by 4 when computing the offset, so the effective offset is
 106  * actually 0x20, this the associated <destination address>. Loading the PC
 107  * register with an address performs a jump to that address.
 108  */
 109 void mx28_fixup_vt(uint32_t start_addr)
 110 {
 111         /* Jumptable location is 0x0 */
 112         uint32_t *vt = (uint32_t *)0x20;
 113         uint32_t cr = get_cr();
 114
 115         /* cppcheck-suppress nullPointer */
 116         memcpy(vt, (void *)start_addr + 0x20, 32);
 117         set_cr(cr & ~CR_V);
 118 }
 119
 120 #ifdef  CONFIG_ARCH_MISC_INIT
 121 int arch_misc_init(void)
 122 {
 123         mx28_fixup_vt(gd->relocaddr);
 124         return 0;
 125 }
 126 #endif
 127
 128 #ifdef CONFIG_ARCH_CPU_INIT
 129 int arch_cpu_init(void)
 130 {
 131         struct mxs_clkctrl_regs *clkctrl_regs =
 132                 (struct mxs_clkctrl_regs *)MXS_CLKCTRL_BASE;
 133         extern uint32_t _start;
 134
 135         mx28_fixup_vt((uint32_t)&_start);
 136
 137         /*
 138          * Enable NAND clock
 139          */
 140         /* Clear bypass bit */
 141         writel(CLKCTRL_CLKSEQ_BYPASS_GPMI,
 142                 &clkctrl_regs->hw_clkctrl_clkseq_set);
 143
 144         /* Set GPMI clock to ref_gpmi / 12 */
 145         clrsetbits_le32(&clkctrl_regs->hw_clkctrl_gpmi,
 146                 CLKCTRL_GPMI_CLKGATE | CLKCTRL_GPMI_DIV_MASK, 1);
 147
 148         udelay(1000);
 149
 150         /*
 151          * Configure GPIO unit
 152          */
 153         mxs_gpio_init();
 154
 155 #ifdef  CONFIG_APBH_DMA
 156         /* Start APBH DMA */
 157         mxs_dma_init();
 158 #endif
 159
 160         return 0;
 161 }
 162 #endif
 163
 164 #if defined(CONFIG_DISPLAY_CPUINFO)
 165 static const char *get_cpu_type(void)
 166 {
 167         struct mxs_digctl_regs *digctl_regs =
 168                 (struct mxs_digctl_regs *)MXS_DIGCTL_BASE;
 169
 170         switch (readl(&digctl_regs->hw_digctl_chipid) & HW_DIGCTL_CHIPID_MASK) {
 171         case HW_DIGCTL_CHIPID_MX23:
 172                 return "23";
 173         case HW_DIGCTL_CHIPID_MX28:
 174                 return "28";
 175         default:
 176                 return "??";
 177         }
 178 }
 179
 180 static const char *get_cpu_rev(void)
 181 {
 182         struct mxs_digctl_regs *digctl_regs =
 183                 (struct mxs_digctl_regs *)MXS_DIGCTL_BASE;
 184         uint8_t rev = readl(&digctl_regs->hw_digctl_chipid) & 0x000000FF;
 185
 186         switch (readl(&digctl_regs->hw_digctl_chipid) & HW_DIGCTL_CHIPID_MASK) {
 187         case HW_DIGCTL_CHIPID_MX23:
 188                 switch (rev) {
 189                 case 0x0:
 190                         return "1.0";
 191                 case 0x1:
 192                         return "1.1";
 193                 case 0x2:
 194                         return "1.2";
 195                 case 0x3:
 196                         return "1.3";
 197                 case 0x4:
 198                         return "1.4";
 199                 default:
 200                         return "??";
 201                 }
 202         case HW_DIGCTL_CHIPID_MX28:
 203                 switch (rev) {
 204                 case 0x1:
 205                         return "1.2";
 206                 default:
 207                         return "??";
 208                 }
 209         default:
 210                 return "??";
 211         }
 212 }
 213
 214 int print_cpuinfo(void)
 215 {
 216         struct mxs_spl_data *data = (struct mxs_spl_data *)
 217                 ((CONFIG_SYS_TEXT_BASE - sizeof(struct mxs_spl_data)) & ~0xf);
 218
 219         printf("CPU:   Freescale i.MX%s rev%s at %d MHz\n",
 220                 get_cpu_type(),
 221                 get_cpu_rev(),
 222                 mxc_get_clock(MXC_ARM_CLK) / 1000000);
 223         printf("BOOT:  %s\n", mxs_boot_modes[data->boot_mode_idx].mode);
 224         return 0;
 225 }
 226 #endif
 227
 228 #define pr_clk(n, c) {                                          \
 229         unsigned long clk = c;  \
 230         printf("%-5s  %3lu.%03lu MHz\n", #n ":", clk / 1000000, \
 231                 clk / 1000 % 1000);                             \
 232 }
 233
 234 int do_mx28_showclocks(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 235 {
 236         pr_clk(CPU, mxc_get_clock(MXC_ARM_CLK));
 237         pr_clk(APBH, mxc_get_clock(MXC_AHB_CLK));
 238         pr_clk(APBX, mxc_get_clock(MXC_XBUS_CLK));
 239         pr_clk(IO0, mxc_get_clock(MXC_IO0_CLK) * 1000);
 240         pr_clk(IO1, mxc_get_clock(MXC_IO1_CLK) * 1000);
 241         pr_clk(EMI, mxc_get_clock(MXC_EMI_CLK) * 1000000);
 242         pr_clk(GPMI, mxc_get_clock(MXC_GPMI_CLK));
 243         return 0;
 244 }
 245
 246 /*
 247  * Initializes on-chip ethernet controllers.
 248  */
 249 #if defined(CONFIG_SOC_MX28) && defined(CONFIG_CMD_NET)
 250 int cpu_eth_init(bd_t *bis)
 251 {
 252         struct mxs_clkctrl_regs *clkctrl_regs =
 253                 (struct mxs_clkctrl_regs *)MXS_CLKCTRL_BASE;
 254
 255         /* Turn on ENET clocks */
 256         clrbits_le32(&clkctrl_regs->hw_clkctrl_enet,
 257                 CLKCTRL_ENET_SLEEP | CLKCTRL_ENET_DISABLE);
 258
 259         /* Set up ENET PLL for 50 MHz */
 260         /* Power on ENET PLL */
 261         writel(CLKCTRL_PLL2CTRL0_POWER,
 262                 &clkctrl_regs->hw_clkctrl_pll2ctrl0_set);
 263
 264         udelay(10);
 265
 266         /*
 267          * Enable pad output; must be done BEFORE enabling PLL
 268          * according to i.MX28 Ref. Manual Rev. 1, 2010 p. 883
 269          */
 270         setbits_le32(&clkctrl_regs->hw_clkctrl_enet, CLKCTRL_ENET_CLK_OUT_EN);
 271
 272         /* Gate on ENET PLL */
 273         writel(CLKCTRL_PLL2CTRL0_CLKGATE,
 274                 &clkctrl_regs->hw_clkctrl_pll2ctrl0_clr);
 275
 276         udelay(6000);
 277         return 0;
 278 }
 279 #endif
 280
 281 __weak void mx28_adjust_mac(int dev_id, unsigned char *mac)
 282 {
 283         mac[0] = 0x00;
 284         mac[1] = 0x04; /* Use FSL vendor MAC address by default */
 285
 286         if (dev_id == 1) /* Let MAC1 be MAC0 + 1 by default */
 287                 mac[5] += 1;
 288 }
 289
 290 #ifdef  CONFIG_MX28_FEC_MAC_IN_OCOTP
 291
 292 #define MXS_OCOTP_MAX_TIMEOUT   1000000
 293 void imx_get_mac_from_fuse(int dev_id, unsigned char *mac)
 294 {
 295         struct mxs_ocotp_regs *ocotp_regs =
 296                 (struct mxs_ocotp_regs *)MXS_OCOTP_BASE;
 297         uint32_t data;
 298
 299         memset(mac, 0, 6);
 300
 301         writel(OCOTP_CTRL_RD_BANK_OPEN, &ocotp_regs->hw_ocotp_ctrl_set);
 302
 303         if (mxs_wait_mask_clr(&ocotp_regs->hw_ocotp_ctrl_reg, OCOTP_CTRL_BUSY,
 304                                 MXS_OCOTP_MAX_TIMEOUT)) {
 305                 printf("MXS FEC: Can't get MAC from OCOTP\n");
 306                 return;
 307         }
 308
 309         data = readl(&ocotp_regs->hw_ocotp_cust0);
 310
 311         mac[2] = (data >> 24) & 0xff;
 312         mac[3] = (data >> 16) & 0xff;
 313         mac[4] = (data >> 8) & 0xff;
 314         mac[5] = data & 0xff;
 315         mx28_adjust_mac(dev_id, mac);
 316 }
 317 #else
 318 void imx_get_mac_from_fuse(int dev_id, unsigned char *mac)
 319 {
 320         memset(mac, 0, 6);
 321 }
 322 #endif
 323
 324 int mxs_dram_init(void)
 325 {
 326         struct mxs_spl_data *data = (struct mxs_spl_data *)
 327                 ((CONFIG_SYS_TEXT_BASE - sizeof(struct mxs_spl_data)) & ~0xf);
 328
 329         if (data->mem_dram_size == 0) {
 330                 printf("MXS:\n"
 331                         "Error, the RAM size passed up from SPL is 0!\n");
 332                 hang();
 333         }
 334
 335         gd->ram_size = data->mem_dram_size;
 336         return 0;
 337 }
 338
 339 U_BOOT_CMD(
 340         clocks, CONFIG_SYS_MAXARGS, 1, do_mx28_showclocks,
 341         "display clocks",
 342         ""
 343 );