imx28: Fix issue with GCC 5.x
[karo-tx-uboot.git] / 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 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 );