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         /* ldr pc, [pc, #0x18] */
 112         const uint32_t ldr_pc = 0xe59ff018;
 113         /* Jumptable location is 0x0 */
 114         uint32_t *vt = (uint32_t *)0x0;
 115         int i;
 116
 117         for (i = 0; i < 8; i++) {
 118                 vt[i] = ldr_pc;
 119                 vt[i + 8] = start_addr + (4 * i);
 120         }
 121 }
 122
 123 #ifdef  CONFIG_ARCH_MISC_INIT
 124 int arch_misc_init(void)
 125 {
 126         mx28_fixup_vt(gd->relocaddr);
 127         return 0;
 128 }
 129 #endif
 130
 131 #ifdef CONFIG_ARCH_CPU_INIT
 132 int arch_cpu_init(void)
 133 {
 134         struct mxs_clkctrl_regs *clkctrl_regs =
 135                 (struct mxs_clkctrl_regs *)MXS_CLKCTRL_BASE;
 136         extern uint32_t _start;
 137
 138         mx28_fixup_vt((uint32_t)&_start);
 139
 140         /*
 141          * Enable NAND clock
 142          */
 143         /* Clear bypass bit */
 144         writel(CLKCTRL_CLKSEQ_BYPASS_GPMI,
 145                 &clkctrl_regs->hw_clkctrl_clkseq_set);
 146
 147         /* Set GPMI clock to ref_gpmi / 12 */
 148         clrsetbits_le32(&clkctrl_regs->hw_clkctrl_gpmi,
 149                 CLKCTRL_GPMI_CLKGATE | CLKCTRL_GPMI_DIV_MASK, 1);
 150
 151         udelay(1000);
 152
 153         /*
 154          * Configure GPIO unit
 155          */
 156         mxs_gpio_init();
 157
 158 #ifdef  CONFIG_APBH_DMA
 159         /* Start APBH DMA */
 160         mxs_dma_init();
 161 #endif
 162
 163         return 0;
 164 }
 165 #endif
 166
 167 #if defined(CONFIG_DISPLAY_CPUINFO)
 168 static const char *get_cpu_type(void)
 169 {
 170         struct mxs_digctl_regs *digctl_regs =
 171                 (struct mxs_digctl_regs *)MXS_DIGCTL_BASE;
 172
 173         switch (readl(&digctl_regs->hw_digctl_chipid) & HW_DIGCTL_CHIPID_MASK) {
 174         case HW_DIGCTL_CHIPID_MX23:
 175                 return "23";
 176         case HW_DIGCTL_CHIPID_MX28:
 177                 return "28";
 178         default:
 179                 return "??";
 180         }
 181 }
 182
 183 static const char *get_cpu_rev(void)
 184 {
 185         struct mxs_digctl_regs *digctl_regs =
 186                 (struct mxs_digctl_regs *)MXS_DIGCTL_BASE;
 187         uint8_t rev = readl(&digctl_regs->hw_digctl_chipid) & 0x000000FF;
 188
 189         switch (readl(&digctl_regs->hw_digctl_chipid) & HW_DIGCTL_CHIPID_MASK) {
 190         case HW_DIGCTL_CHIPID_MX23:
 191                 switch (rev) {
 192                 case 0x0:
 193                         return "1.0";
 194                 case 0x1:
 195                         return "1.1";
 196                 case 0x2:
 197                         return "1.2";
 198                 case 0x3:
 199                         return "1.3";
 200                 case 0x4:
 201                         return "1.4";
 202                 default:
 203                         return "??";
 204                 }
 205         case HW_DIGCTL_CHIPID_MX28:
 206                 switch (rev) {
 207                 case 0x1:
 208                         return "1.2";
 209                 default:
 210                         return "??";
 211                 }
 212         default:
 213                 return "??";
 214         }
 215 }
 216
 217 int print_cpuinfo(void)
 218 {
 219         struct mxs_spl_data *data = (struct mxs_spl_data *)
 220                 ((CONFIG_SYS_TEXT_BASE - sizeof(struct mxs_spl_data)) & ~0xf);
 221
 222         printf("CPU:   Freescale i.MX%s rev%s at %d MHz\n",
 223                 get_cpu_type(),
 224                 get_cpu_rev(),
 225                 mxc_get_clock(MXC_ARM_CLK) / 1000000);
 226         printf("BOOT:  %s\n", mxs_boot_modes[data->boot_mode_idx].mode);
 227         return 0;
 228 }
 229 #endif
 230
 231 #define pr_clk(n, c) {                                          \
 232         unsigned long clk = c;  \
 233         printf("%-5s  %3lu.%03lu MHz\n", #n ":", clk / 1000000, \
 234                 clk / 1000 % 1000);                             \
 235 }
 236
 237 int do_mx28_showclocks(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
 238 {
 239         pr_clk(CPU, mxc_get_clock(MXC_ARM_CLK));
 240         pr_clk(APBH, mxc_get_clock(MXC_AHB_CLK));
 241         pr_clk(APBX, mxc_get_clock(MXC_XBUS_CLK));
 242         pr_clk(IO0, mxc_get_clock(MXC_IO0_CLK) * 1000);
 243         pr_clk(IO1, mxc_get_clock(MXC_IO1_CLK) * 1000);
 244         pr_clk(EMI, mxc_get_clock(MXC_EMI_CLK) * 1000000);
 245         pr_clk(GPMI, mxc_get_clock(MXC_GPMI_CLK));
 246         return 0;
 247 }
 248
 249 /*
 250  * Initializes on-chip ethernet controllers.
 251  */
 252 #if defined(CONFIG_MX28) && defined(CONFIG_CMD_NET)
 253 int cpu_eth_init(bd_t *bis)
 254 {
 255         struct mxs_clkctrl_regs *clkctrl_regs =
 256                 (struct mxs_clkctrl_regs *)MXS_CLKCTRL_BASE;
 257
 258         /* Turn on ENET clocks */
 259         clrbits_le32(&clkctrl_regs->hw_clkctrl_enet,
 260                 CLKCTRL_ENET_SLEEP | CLKCTRL_ENET_DISABLE);
 261
 262         /* Set up ENET PLL for 50 MHz */
 263         /* Power on ENET PLL */
 264         writel(CLKCTRL_PLL2CTRL0_POWER,
 265                 &clkctrl_regs->hw_clkctrl_pll2ctrl0_set);
 266
 267         udelay(10);
 268
 269         /*
 270          * Enable pad output; must be done BEFORE enabling PLL
 271          * according to i.MX28 Ref. Manual Rev. 1, 2010 p. 883
 272          */
 273         setbits_le32(&clkctrl_regs->hw_clkctrl_enet, CLKCTRL_ENET_CLK_OUT_EN);
 274
 275         /* Gate on ENET PLL */
 276         writel(CLKCTRL_PLL2CTRL0_CLKGATE,
 277                 &clkctrl_regs->hw_clkctrl_pll2ctrl0_clr);
 278
 279         udelay(6000);
 280         return 0;
 281 }
 282 #endif
 283
 284 __weak void mx28_adjust_mac(int dev_id, unsigned char *mac)
 285 {
 286         mac[0] = 0x00;
 287         mac[1] = 0x04; /* Use FSL vendor MAC address by default */
 288
 289         if (dev_id == 1) /* Let MAC1 be MAC0 + 1 by default */
 290                 mac[5] += 1;
 291 }
 292
 293 #ifdef  CONFIG_MX28_FEC_MAC_IN_OCOTP
 294
 295 #define MXS_OCOTP_MAX_TIMEOUT   1000000
 296 void imx_get_mac_from_fuse(int dev_id, unsigned char *mac)
 297 {
 298         struct mxs_ocotp_regs *ocotp_regs =
 299                 (struct mxs_ocotp_regs *)MXS_OCOTP_BASE;
 300         uint32_t data;
 301
 302         memset(mac, 0, 6);
 303
 304         writel(OCOTP_CTRL_RD_BANK_OPEN, &ocotp_regs->hw_ocotp_ctrl_set);
 305
 306         if (mxs_wait_mask_clr(&ocotp_regs->hw_ocotp_ctrl_reg, OCOTP_CTRL_BUSY,
 307                                 MXS_OCOTP_MAX_TIMEOUT)) {
 308                 printf("MXS FEC: Can't get MAC from OCOTP\n");
 309                 return;
 310         }
 311
 312         data = readl(&ocotp_regs->hw_ocotp_cust0);
 313
 314         mac[2] = (data >> 24) & 0xff;
 315         mac[3] = (data >> 16) & 0xff;
 316         mac[4] = (data >> 8) & 0xff;
 317         mac[5] = data & 0xff;
 318         mx28_adjust_mac(dev_id, mac);
 319 }
 320 #else
 321 void imx_get_mac_from_fuse(int dev_id, unsigned char *mac)
 322 {
 323         memset(mac, 0, 6);
 324 }
 325 #endif
 326
 327 int mxs_dram_init(void)
 328 {
 329         struct mxs_spl_data *data = (struct mxs_spl_data *)
 330                 ((CONFIG_SYS_TEXT_BASE - sizeof(struct mxs_spl_data)) & ~0xf);
 331
 332         if (data->mem_dram_size == 0) {
 333                 printf("MXS:\n"
 334                         "Error, the RAM size passed up from SPL is 0!\n");
 335                 hang();
 336         }
 337
 338         gd->ram_size = data->mem_dram_size;
 339         return 0;
 340 }
 341
 342 U_BOOT_CMD(
 343         clocks, CONFIG_SYS_MAXARGS, 1, do_mx28_showclocks,
 344         "display clocks",
 345         ""
 346 );