Tom Rini | 83d290c | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 2 | /* |
Dipen Dudhat | beba93e | 2011-01-19 12:46:27 +0530 | [diff] [blame] | 3 | * Copyright 2004,2007-2011 Freescale Semiconductor, Inc. |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 4 | * (C) Copyright 2002, 2003 Motorola Inc. |
| 5 | * Xianghua Xiao (X.Xiao@motorola.com) |
| 6 | * |
| 7 | * (C) Copyright 2000 |
| 8 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 9 | */ |
| 10 | |
Andy Fleming | 75b9d4a | 2008-08-31 16:33:26 -0500 | [diff] [blame] | 11 | #include <config.h> |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 12 | #include <common.h> |
Simon Glass | 62f9b65 | 2019-11-14 12:57:09 -0700 | [diff] [blame] | 13 | #include <cpu_func.h> |
Tom Rini | efb5dab7 | 2021-08-21 13:50:17 -0400 | [diff] [blame] | 14 | #include <clock_legacy.h> |
Simon Glass | 691d719 | 2020-05-10 11:40:02 -0600 | [diff] [blame] | 15 | #include <init.h> |
Simon Glass | 36bf446 | 2019-11-14 12:57:42 -0700 | [diff] [blame] | 16 | #include <irq_func.h> |
Simon Glass | f7ae49f | 2020-05-10 11:40:05 -0600 | [diff] [blame] | 17 | #include <log.h> |
Simon Glass | 049f8d6 | 2019-12-28 10:44:59 -0700 | [diff] [blame] | 18 | #include <time.h> |
Simon Glass | 2189d5f | 2019-11-14 12:57:20 -0700 | [diff] [blame] | 19 | #include <vsprintf.h> |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 20 | #include <watchdog.h> |
| 21 | #include <command.h> |
Andy Fleming | 80522dc | 2008-10-30 16:51:33 -0500 | [diff] [blame] | 22 | #include <fsl_esdhc.h> |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 23 | #include <asm/cache.h> |
Simon Glass | 401d1c4 | 2020-10-30 21:38:53 -0600 | [diff] [blame] | 24 | #include <asm/global_data.h> |
Sergei Poselenov | 740280e | 2008-06-06 15:42:40 +0200 | [diff] [blame] | 25 | #include <asm/io.h> |
Becky Bruce | 199e262 | 2010-06-17 11:37:25 -0500 | [diff] [blame] | 26 | #include <asm/mmu.h> |
York Sun | 0b66513 | 2013-10-22 12:39:02 -0700 | [diff] [blame] | 27 | #include <fsl_ifc.h> |
Becky Bruce | 199e262 | 2010-06-17 11:37:25 -0500 | [diff] [blame] | 28 | #include <asm/fsl_law.h> |
Becky Bruce | 38dba0c | 2010-12-17 17:17:56 -0600 | [diff] [blame] | 29 | #include <asm/fsl_lbc.h> |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 30 | #include <post.h> |
| 31 | #include <asm/processor.h> |
York Sun | 5614e71 | 2013-09-30 09:22:09 -0700 | [diff] [blame] | 32 | #include <fsl_ddr_sdram.h> |
Christophe Leroy | f3603b4 | 2017-07-13 15:09:54 +0200 | [diff] [blame] | 33 | #include <asm/ppc.h> |
Simon Glass | c05ed00 | 2020-05-10 11:40:11 -0600 | [diff] [blame] | 34 | #include <linux/delay.h> |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 35 | |
James Yang | 591933c | 2008-02-08 16:44:53 -0600 | [diff] [blame] | 36 | DECLARE_GLOBAL_DATA_PTR; |
| 37 | |
Ira W. Snyder | c18de0d | 2011-11-21 13:20:32 -0800 | [diff] [blame] | 38 | /* |
| 39 | * Default board reset function |
| 40 | */ |
| 41 | static void |
| 42 | __board_reset(void) |
| 43 | { |
| 44 | /* Do nothing */ |
| 45 | } |
| 46 | void board_reset(void) __attribute__((weak, alias("__board_reset"))); |
| 47 | |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 48 | int checkcpu (void) |
| 49 | { |
wdenk | 97d80fc | 2004-06-09 00:34:46 +0000 | [diff] [blame] | 50 | sys_info_t sysinfo; |
wdenk | 97d80fc | 2004-06-09 00:34:46 +0000 | [diff] [blame] | 51 | uint pvr, svr; |
| 52 | uint ver; |
| 53 | uint major, minor; |
Kumar Gala | 4dbdb76 | 2008-06-10 16:53:46 -0500 | [diff] [blame] | 54 | struct cpu_type *cpu; |
Wolfgang Denk | 08ef89e | 2008-10-19 02:35:49 +0200 | [diff] [blame] | 55 | char buf1[32], buf2[32]; |
Tom Rini | efb5dab7 | 2021-08-21 13:50:17 -0400 | [diff] [blame] | 56 | #if defined(CONFIG_DYNAMIC_DDR_CLK_FREQ) || \ |
| 57 | defined(CONFIG_STATIC_DDR_CLK_FREQ) || defined(CONFIG_FSL_CORENET) |
York Sun | f165bc3 | 2013-06-25 11:37:43 -0700 | [diff] [blame] | 58 | ccsr_gur_t __iomem *gur = |
| 59 | (void __iomem *)(CONFIG_SYS_MPC85xx_GUTS_ADDR); |
| 60 | #endif |
York Sun | 98ffa19 | 2012-10-08 07:44:31 +0000 | [diff] [blame] | 61 | |
| 62 | /* |
| 63 | * Cornet platforms use ddr sync bit in RCW to indicate sync vs async |
| 64 | * mode. Previous platform use ddr ratio to do the same. This |
| 65 | * information is only for display here. |
| 66 | */ |
| 67 | #ifdef CONFIG_FSL_CORENET |
| 68 | #ifdef CONFIG_SYS_FSL_QORIQ_CHASSIS2 |
| 69 | u32 ddr_sync = 0; /* only async mode is supported */ |
| 70 | #else |
| 71 | u32 ddr_sync = ((gur->rcwsr[5]) & FSL_CORENET_RCWSR5_DDR_SYNC) |
| 72 | >> FSL_CORENET_RCWSR5_DDR_SYNC_SHIFT; |
| 73 | #endif /* CONFIG_SYS_FSL_QORIQ_CHASSIS2 */ |
| 74 | #else /* CONFIG_FSL_CORENET */ |
Tom Rini | efb5dab7 | 2021-08-21 13:50:17 -0400 | [diff] [blame] | 75 | #if defined(CONFIG_DYNAMIC_DDR_CLK_FREQ) || defined(CONFIG_STATIC_DDR_CLK_FREQ) |
Srikanth Srinivasan | ab48ca1 | 2010-02-10 17:32:43 +0800 | [diff] [blame] | 76 | u32 ddr_ratio = ((gur->porpllsr) & MPC85xx_PORPLLSR_DDR_RATIO) |
| 77 | >> MPC85xx_PORPLLSR_DDR_RATIO_SHIFT; |
| 78 | #else |
Kumar Gala | ee1e35b | 2008-05-29 01:21:24 -0500 | [diff] [blame] | 79 | u32 ddr_ratio = 0; |
Tom Rini | efb5dab7 | 2021-08-21 13:50:17 -0400 | [diff] [blame] | 80 | #endif /* CONFIG_DYNAMIC_DDR_CLK_FREQ || CONFIG_STATIC_DDR_CLK_FREQ */ |
York Sun | 98ffa19 | 2012-10-08 07:44:31 +0000 | [diff] [blame] | 81 | #endif /* CONFIG_FSL_CORENET */ |
| 82 | |
Timur Tabi | fbb9ecf | 2011-08-05 16:15:24 -0500 | [diff] [blame] | 83 | unsigned int i, core, nr_cores = cpu_numcores(); |
| 84 | u32 mask = cpu_mask(); |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 85 | |
Shaveta Leekha | b8bf0ad | 2015-01-19 12:46:54 +0530 | [diff] [blame] | 86 | #ifdef CONFIG_HETROGENOUS_CLUSTERS |
| 87 | unsigned int j, dsp_core, dsp_numcores = cpu_num_dspcores(); |
| 88 | u32 dsp_mask = cpu_dsp_mask(); |
| 89 | #endif |
| 90 | |
wdenk | 97d80fc | 2004-06-09 00:34:46 +0000 | [diff] [blame] | 91 | svr = get_svr(); |
wdenk | 97d80fc | 2004-06-09 00:34:46 +0000 | [diff] [blame] | 92 | major = SVR_MAJ(svr); |
| 93 | minor = SVR_MIN(svr); |
| 94 | |
Shengzhou Liu | 5122dfa | 2014-04-25 16:31:22 +0800 | [diff] [blame] | 95 | #if defined(CONFIG_SYS_FSL_QORIQ_CHASSIS2) && defined(CONFIG_E6500) |
| 96 | if (SVR_SOC_VER(svr) == SVR_T4080) { |
| 97 | ccsr_rcpm_t *rcpm = |
| 98 | (void __iomem *)(CONFIG_SYS_FSL_CORENET_RCPM_ADDR); |
| 99 | |
| 100 | setbits_be32(&gur->devdisr2, FSL_CORENET_DEVDISR2_DTSEC1_6 || |
| 101 | FSL_CORENET_DEVDISR2_DTSEC1_9); |
| 102 | setbits_be32(&gur->devdisr3, FSL_CORENET_DEVDISR3_PCIE3); |
| 103 | setbits_be32(&gur->devdisr5, FSL_CORENET_DEVDISR5_DDR3); |
| 104 | |
| 105 | /* It needs SW to disable core4~7 as HW design sake on T4080 */ |
| 106 | for (i = 4; i < 8; i++) |
| 107 | cpu_disable(i); |
| 108 | |
| 109 | /* request core4~7 into PH20 state, prior to entering PCL10 |
| 110 | * state, all cores in cluster should be placed in PH20 state. |
| 111 | */ |
| 112 | setbits_be32(&rcpm->pcph20setr, 0xf0); |
| 113 | |
| 114 | /* put the 2nd cluster into PCL10 state */ |
| 115 | setbits_be32(&rcpm->clpcl10setr, 1 << 1); |
| 116 | } |
| 117 | #endif |
| 118 | |
Poonam Aggrwal | 0e87098 | 2009-07-31 12:08:14 +0530 | [diff] [blame] | 119 | if (cpu_numcores() > 1) { |
Poonam Aggrwal | 21170c8 | 2009-09-03 19:42:40 +0530 | [diff] [blame] | 120 | #ifndef CONFIG_MP |
| 121 | puts("Unicore software on multiprocessor system!!\n" |
| 122 | "To enable mutlticore build define CONFIG_MP\n"); |
| 123 | #endif |
Kim Phillips | 680c613 | 2010-08-09 18:39:57 -0500 | [diff] [blame] | 124 | volatile ccsr_pic_t *pic = (void *)(CONFIG_SYS_MPC8xxx_PIC_ADDR); |
Poonam Aggrwal | 0e87098 | 2009-07-31 12:08:14 +0530 | [diff] [blame] | 125 | printf("CPU%d: ", pic->whoami); |
| 126 | } else { |
| 127 | puts("CPU: "); |
| 128 | } |
Andy Fleming | 1ced121 | 2008-02-06 01:19:40 -0600 | [diff] [blame] | 129 | |
Simon Glass | 67ac13b | 2012-12-13 20:48:48 +0000 | [diff] [blame] | 130 | cpu = gd->arch.cpu; |
Poonam Aggrwal | 0e87098 | 2009-07-31 12:08:14 +0530 | [diff] [blame] | 131 | |
Poonam Aggrwal | 58442dc | 2009-09-02 13:35:21 +0530 | [diff] [blame] | 132 | puts(cpu->name); |
| 133 | if (IS_E_PROCESSOR(svr)) |
| 134 | puts("E"); |
Andy Fleming | 1ced121 | 2008-02-06 01:19:40 -0600 | [diff] [blame] | 135 | |
wdenk | 97d80fc | 2004-06-09 00:34:46 +0000 | [diff] [blame] | 136 | printf(", Version: %d.%d, (0x%08x)\n", major, minor, svr); |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 137 | |
wdenk | 6c9e789 | 2005-03-15 22:56:53 +0000 | [diff] [blame] | 138 | pvr = get_pvr(); |
| 139 | ver = PVR_VER(pvr); |
| 140 | major = PVR_MAJ(pvr); |
| 141 | minor = PVR_MIN(pvr); |
| 142 | |
| 143 | printf("Core: "); |
Kumar Gala | 8992738 | 2011-07-25 09:28:39 -0500 | [diff] [blame] | 144 | switch(ver) { |
| 145 | case PVR_VER_E500_V1: |
Pali Rohár | efd9914 | 2022-04-03 00:05:10 +0200 | [diff] [blame] | 146 | puts("e500v1"); |
| 147 | break; |
Kumar Gala | 8992738 | 2011-07-25 09:28:39 -0500 | [diff] [blame] | 148 | case PVR_VER_E500_V2: |
Pali Rohár | efd9914 | 2022-04-03 00:05:10 +0200 | [diff] [blame] | 149 | puts("e500v2"); |
Kumar Gala | 8992738 | 2011-07-25 09:28:39 -0500 | [diff] [blame] | 150 | break; |
| 151 | case PVR_VER_E500MC: |
Fabio Estevam | 6770c5e | 2013-04-21 13:11:02 -0300 | [diff] [blame] | 152 | puts("e500mc"); |
Kumar Gala | 8992738 | 2011-07-25 09:28:39 -0500 | [diff] [blame] | 153 | break; |
| 154 | case PVR_VER_E5500: |
Fabio Estevam | 6770c5e | 2013-04-21 13:11:02 -0300 | [diff] [blame] | 155 | puts("e5500"); |
Kumar Gala | 8992738 | 2011-07-25 09:28:39 -0500 | [diff] [blame] | 156 | break; |
Kumar Gala | 5b6b85a | 2012-08-17 08:20:23 +0000 | [diff] [blame] | 157 | case PVR_VER_E6500: |
Fabio Estevam | 6770c5e | 2013-04-21 13:11:02 -0300 | [diff] [blame] | 158 | puts("e6500"); |
Kumar Gala | 5b6b85a | 2012-08-17 08:20:23 +0000 | [diff] [blame] | 159 | break; |
Kumar Gala | 8992738 | 2011-07-25 09:28:39 -0500 | [diff] [blame] | 160 | default: |
Kumar Gala | 2a3a96c | 2009-10-21 13:23:54 -0500 | [diff] [blame] | 161 | puts("Unknown"); |
Kumar Gala | 8992738 | 2011-07-25 09:28:39 -0500 | [diff] [blame] | 162 | break; |
wdenk | 6c9e789 | 2005-03-15 22:56:53 +0000 | [diff] [blame] | 163 | } |
Kumar Gala | 0f060c3 | 2008-10-23 01:47:38 -0500 | [diff] [blame] | 164 | |
wdenk | 6c9e789 | 2005-03-15 22:56:53 +0000 | [diff] [blame] | 165 | printf(", Version: %d.%d, (0x%08x)\n", major, minor, pvr); |
| 166 | |
York Sun | 2f1712b | 2012-10-08 07:44:10 +0000 | [diff] [blame] | 167 | if (nr_cores > CONFIG_MAX_CPUS) { |
| 168 | panic("\nUnexpected number of cores: %d, max is %d\n", |
| 169 | nr_cores, CONFIG_MAX_CPUS); |
| 170 | } |
| 171 | |
wdenk | 97d80fc | 2004-06-09 00:34:46 +0000 | [diff] [blame] | 172 | get_sys_info(&sysinfo); |
| 173 | |
vijay rai | 0c12a15 | 2014-04-15 11:34:12 +0530 | [diff] [blame] | 174 | #ifdef CONFIG_SYS_FSL_SINGLE_SOURCE_CLK |
| 175 | if (sysinfo.diff_sysclk == 1) |
| 176 | puts("Single Source Clock Configuration\n"); |
| 177 | #endif |
| 178 | |
Kumar Gala | b29dee3 | 2009-02-04 09:35:57 -0600 | [diff] [blame] | 179 | puts("Clock Configuration:"); |
Timur Tabi | fbb9ecf | 2011-08-05 16:15:24 -0500 | [diff] [blame] | 180 | for_each_cpu(i, core, nr_cores, mask) { |
Wolfgang Denk | 1bba30e | 2009-02-19 00:41:08 +0100 | [diff] [blame] | 181 | if (!(i & 3)) |
| 182 | printf ("\n "); |
Timur Tabi | fbb9ecf | 2011-08-05 16:15:24 -0500 | [diff] [blame] | 183 | printf("CPU%d:%-4s MHz, ", core, |
Prabhakar Kushwaha | 997399f | 2013-08-16 14:52:26 +0530 | [diff] [blame] | 184 | strmhz(buf1, sysinfo.freq_processor[core])); |
Kumar Gala | b29dee3 | 2009-02-04 09:35:57 -0600 | [diff] [blame] | 185 | } |
Shaveta Leekha | b8bf0ad | 2015-01-19 12:46:54 +0530 | [diff] [blame] | 186 | |
| 187 | #ifdef CONFIG_HETROGENOUS_CLUSTERS |
| 188 | for_each_cpu(j, dsp_core, dsp_numcores, dsp_mask) { |
| 189 | if (!(j & 3)) |
| 190 | printf("\n "); |
| 191 | printf("DSP CPU%d:%-4s MHz, ", j, |
| 192 | strmhz(buf1, sysinfo.freq_processor_dsp[dsp_core])); |
| 193 | } |
| 194 | #endif |
| 195 | |
Prabhakar Kushwaha | 997399f | 2013-08-16 14:52:26 +0530 | [diff] [blame] | 196 | printf("\n CCB:%-4s MHz,", strmhz(buf1, sysinfo.freq_systembus)); |
| 197 | printf("\n"); |
Kumar Gala | ee1e35b | 2008-05-29 01:21:24 -0500 | [diff] [blame] | 198 | |
Kumar Gala | 39aaca1 | 2009-03-19 02:46:19 -0500 | [diff] [blame] | 199 | #ifdef CONFIG_FSL_CORENET |
| 200 | if (ddr_sync == 1) { |
| 201 | printf(" DDR:%-4s MHz (%s MT/s data rate) " |
| 202 | "(Synchronous), ", |
Prabhakar Kushwaha | 997399f | 2013-08-16 14:52:26 +0530 | [diff] [blame] | 203 | strmhz(buf1, sysinfo.freq_ddrbus/2), |
| 204 | strmhz(buf2, sysinfo.freq_ddrbus)); |
Kumar Gala | 39aaca1 | 2009-03-19 02:46:19 -0500 | [diff] [blame] | 205 | } else { |
| 206 | printf(" DDR:%-4s MHz (%s MT/s data rate) " |
| 207 | "(Asynchronous), ", |
Prabhakar Kushwaha | 997399f | 2013-08-16 14:52:26 +0530 | [diff] [blame] | 208 | strmhz(buf1, sysinfo.freq_ddrbus/2), |
| 209 | strmhz(buf2, sysinfo.freq_ddrbus)); |
Kumar Gala | 39aaca1 | 2009-03-19 02:46:19 -0500 | [diff] [blame] | 210 | } |
| 211 | #else |
Kumar Gala | d435793 | 2007-12-07 04:59:26 -0600 | [diff] [blame] | 212 | switch (ddr_ratio) { |
| 213 | case 0x0: |
Wolfgang Denk | 08ef89e | 2008-10-19 02:35:49 +0200 | [diff] [blame] | 214 | printf(" DDR:%-4s MHz (%s MT/s data rate), ", |
Prabhakar Kushwaha | 997399f | 2013-08-16 14:52:26 +0530 | [diff] [blame] | 215 | strmhz(buf1, sysinfo.freq_ddrbus/2), |
| 216 | strmhz(buf2, sysinfo.freq_ddrbus)); |
Kumar Gala | d435793 | 2007-12-07 04:59:26 -0600 | [diff] [blame] | 217 | break; |
| 218 | case 0x7: |
Kumar Gala | 39aaca1 | 2009-03-19 02:46:19 -0500 | [diff] [blame] | 219 | printf(" DDR:%-4s MHz (%s MT/s data rate) " |
| 220 | "(Synchronous), ", |
Prabhakar Kushwaha | 997399f | 2013-08-16 14:52:26 +0530 | [diff] [blame] | 221 | strmhz(buf1, sysinfo.freq_ddrbus/2), |
| 222 | strmhz(buf2, sysinfo.freq_ddrbus)); |
Kumar Gala | d435793 | 2007-12-07 04:59:26 -0600 | [diff] [blame] | 223 | break; |
| 224 | default: |
Kumar Gala | 39aaca1 | 2009-03-19 02:46:19 -0500 | [diff] [blame] | 225 | printf(" DDR:%-4s MHz (%s MT/s data rate) " |
| 226 | "(Asynchronous), ", |
Prabhakar Kushwaha | 997399f | 2013-08-16 14:52:26 +0530 | [diff] [blame] | 227 | strmhz(buf1, sysinfo.freq_ddrbus/2), |
| 228 | strmhz(buf2, sysinfo.freq_ddrbus)); |
Kumar Gala | d435793 | 2007-12-07 04:59:26 -0600 | [diff] [blame] | 229 | break; |
| 230 | } |
Kumar Gala | 39aaca1 | 2009-03-19 02:46:19 -0500 | [diff] [blame] | 231 | #endif |
wdenk | 97d80fc | 2004-06-09 00:34:46 +0000 | [diff] [blame] | 232 | |
Dipen Dudhat | beba93e | 2011-01-19 12:46:27 +0530 | [diff] [blame] | 233 | #if defined(CONFIG_FSL_LBC) |
Prabhakar Kushwaha | 997399f | 2013-08-16 14:52:26 +0530 | [diff] [blame] | 234 | if (sysinfo.freq_localbus > LCRR_CLKDIV) { |
| 235 | printf("LBC:%-4s MHz\n", strmhz(buf1, sysinfo.freq_localbus)); |
Kumar Gala | 39aaca1 | 2009-03-19 02:46:19 -0500 | [diff] [blame] | 236 | } else { |
Trent Piepho | ada591d | 2008-12-03 15:16:37 -0800 | [diff] [blame] | 237 | printf("LBC: unknown (LCRR[CLKDIV] = 0x%02lx)\n", |
Prabhakar Kushwaha | 997399f | 2013-08-16 14:52:26 +0530 | [diff] [blame] | 238 | sysinfo.freq_localbus); |
Kumar Gala | 39aaca1 | 2009-03-19 02:46:19 -0500 | [diff] [blame] | 239 | } |
Dipen Dudhat | beba93e | 2011-01-19 12:46:27 +0530 | [diff] [blame] | 240 | #endif |
wdenk | 97d80fc | 2004-06-09 00:34:46 +0000 | [diff] [blame] | 241 | |
Kumar Gala | 800c73c | 2012-10-08 07:44:06 +0000 | [diff] [blame] | 242 | #if defined(CONFIG_FSL_IFC) |
Prabhakar Kushwaha | 997399f | 2013-08-16 14:52:26 +0530 | [diff] [blame] | 243 | printf("IFC:%-4s MHz\n", strmhz(buf1, sysinfo.freq_localbus)); |
Kumar Gala | 800c73c | 2012-10-08 07:44:06 +0000 | [diff] [blame] | 244 | #endif |
| 245 | |
Haiying Wang | b3d7f20 | 2009-05-20 12:30:29 -0400 | [diff] [blame] | 246 | #ifdef CONFIG_QE |
Prabhakar Kushwaha | 997399f | 2013-08-16 14:52:26 +0530 | [diff] [blame] | 247 | printf(" QE:%-4s MHz\n", strmhz(buf1, sysinfo.freq_qe)); |
Haiying Wang | b3d7f20 | 2009-05-20 12:30:29 -0400 | [diff] [blame] | 248 | #endif |
| 249 | |
Shaveta Leekha | b8bf0ad | 2015-01-19 12:46:54 +0530 | [diff] [blame] | 250 | #if defined(CONFIG_SYS_CPRI) |
| 251 | printf(" "); |
| 252 | printf("CPRI:%-4s MHz", strmhz(buf1, sysinfo.freq_cpri)); |
| 253 | #endif |
| 254 | |
| 255 | #if defined(CONFIG_SYS_MAPLE) |
| 256 | printf("\n "); |
| 257 | printf("MAPLE:%-4s MHz, ", strmhz(buf1, sysinfo.freq_maple)); |
| 258 | printf("MAPLE-ULB:%-4s MHz, ", strmhz(buf1, sysinfo.freq_maple_ulb)); |
| 259 | printf("MAPLE-eTVPE:%-4s MHz\n", |
| 260 | strmhz(buf1, sysinfo.freq_maple_etvpe)); |
| 261 | #endif |
| 262 | |
Kumar Gala | 39aaca1 | 2009-03-19 02:46:19 -0500 | [diff] [blame] | 263 | #ifdef CONFIG_SYS_DPAA_FMAN |
| 264 | for (i = 0; i < CONFIG_SYS_NUM_FMAN; i++) { |
Emil Medve | 7eda1f8 | 2010-06-17 00:08:29 -0500 | [diff] [blame] | 265 | printf(" FMAN%d: %s MHz\n", i + 1, |
Prabhakar Kushwaha | 997399f | 2013-08-16 14:52:26 +0530 | [diff] [blame] | 266 | strmhz(buf1, sysinfo.freq_fman[i])); |
Kumar Gala | 39aaca1 | 2009-03-19 02:46:19 -0500 | [diff] [blame] | 267 | } |
| 268 | #endif |
| 269 | |
Haiying Wang | 990e1a8 | 2012-10-11 07:13:39 +0000 | [diff] [blame] | 270 | #ifdef CONFIG_SYS_DPAA_QBMAN |
Prabhakar Kushwaha | 997399f | 2013-08-16 14:52:26 +0530 | [diff] [blame] | 271 | printf(" QMAN: %s MHz\n", strmhz(buf1, sysinfo.freq_qman)); |
Haiying Wang | 990e1a8 | 2012-10-11 07:13:39 +0000 | [diff] [blame] | 272 | #endif |
| 273 | |
Kumar Gala | 39aaca1 | 2009-03-19 02:46:19 -0500 | [diff] [blame] | 274 | #ifdef CONFIG_SYS_DPAA_PME |
Prabhakar Kushwaha | 997399f | 2013-08-16 14:52:26 +0530 | [diff] [blame] | 275 | printf(" PME: %s MHz\n", strmhz(buf1, sysinfo.freq_pme)); |
Kumar Gala | 39aaca1 | 2009-03-19 02:46:19 -0500 | [diff] [blame] | 276 | #endif |
| 277 | |
Shruti Kanetkar | 6b44d9e | 2013-08-15 11:25:38 -0500 | [diff] [blame] | 278 | puts("L1: D-cache 32 KiB enabled\n I-cache 32 KiB enabled\n"); |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 279 | |
York Sun | f165bc3 | 2013-06-25 11:37:43 -0700 | [diff] [blame] | 280 | #ifdef CONFIG_FSL_CORENET |
| 281 | /* Display the RCW, so that no one gets confused as to what RCW |
| 282 | * we're actually using for this boot. |
| 283 | */ |
| 284 | puts("Reset Configuration Word (RCW):"); |
| 285 | for (i = 0; i < ARRAY_SIZE(gur->rcwsr); i++) { |
| 286 | u32 rcw = in_be32(&gur->rcwsr[i]); |
| 287 | |
| 288 | if ((i % 4) == 0) |
| 289 | printf("\n %08x:", i * 4); |
| 290 | printf(" %08x", rcw); |
| 291 | } |
| 292 | puts("\n"); |
| 293 | #endif |
| 294 | |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 295 | return 0; |
| 296 | } |
| 297 | |
| 298 | |
| 299 | /* ------------------------------------------------------------------------- */ |
| 300 | |
Simon Glass | 0914011 | 2020-05-10 11:40:03 -0600 | [diff] [blame] | 301 | int do_reset(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 302 | { |
Kumar Gala | c348322 | 2009-09-08 13:46:46 -0500 | [diff] [blame] | 303 | /* Everything after the first generation of PQ3 parts has RSTCR */ |
Tom Rini | 9889860 | 2021-05-14 21:34:21 -0400 | [diff] [blame] | 304 | #if defined(CONFIG_ARCH_MPC8540) || defined(CONFIG_ARCH_MPC8560) |
Sergei Poselenov | 793670c | 2008-05-08 14:17:08 +0200 | [diff] [blame] | 305 | unsigned long val, msr; |
| 306 | |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 307 | /* |
| 308 | * Initiate hard reset in debug control register DBCR0 |
Kumar Gala | c348322 | 2009-09-08 13:46:46 -0500 | [diff] [blame] | 309 | * Make sure MSR[DE] = 1. This only resets the core. |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 310 | */ |
Sergei Poselenov | 793670c | 2008-05-08 14:17:08 +0200 | [diff] [blame] | 311 | msr = mfmsr (); |
| 312 | msr |= MSR_DE; |
| 313 | mtmsr (msr); |
urwithsughosh@gmail.com | df90968 | 2007-09-24 13:32:13 -0400 | [diff] [blame] | 314 | |
Sergei Poselenov | 793670c | 2008-05-08 14:17:08 +0200 | [diff] [blame] | 315 | val = mfspr(DBCR0); |
| 316 | val |= 0x70000000; |
| 317 | mtspr(DBCR0,val); |
Kumar Gala | c348322 | 2009-09-08 13:46:46 -0500 | [diff] [blame] | 318 | #else |
| 319 | volatile ccsr_gur_t *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR); |
Ira W. Snyder | c18de0d | 2011-11-21 13:20:32 -0800 | [diff] [blame] | 320 | |
| 321 | /* Attempt board-specific reset */ |
| 322 | board_reset(); |
| 323 | |
| 324 | /* Next try asserting HRESET_REQ */ |
| 325 | out_be32(&gur->rstcr, 0x2); |
Kumar Gala | c348322 | 2009-09-08 13:46:46 -0500 | [diff] [blame] | 326 | udelay(100); |
| 327 | #endif |
Sergei Poselenov | 793670c | 2008-05-08 14:17:08 +0200 | [diff] [blame] | 328 | |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 329 | return 1; |
| 330 | } |
| 331 | |
| 332 | |
| 333 | /* |
| 334 | * Get timebase clock frequency |
| 335 | */ |
Kumar Gala | 66412c6 | 2011-02-18 05:40:54 -0600 | [diff] [blame] | 336 | #ifndef CONFIG_SYS_FSL_TBCLK_DIV |
| 337 | #define CONFIG_SYS_FSL_TBCLK_DIV 8 |
| 338 | #endif |
Simon Glass | 049f8d6 | 2019-12-28 10:44:59 -0700 | [diff] [blame] | 339 | __weak unsigned long get_tbclk(void) |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 340 | { |
Kumar Gala | 66412c6 | 2011-02-18 05:40:54 -0600 | [diff] [blame] | 341 | unsigned long tbclk_div = CONFIG_SYS_FSL_TBCLK_DIV; |
| 342 | |
| 343 | return (gd->bus_clk + (tbclk_div >> 1)) / tbclk_div; |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 344 | } |
| 345 | |
| 346 | |
Pali Rohár | 549bb6b | 2022-04-28 13:31:43 +0200 | [diff] [blame^] | 347 | #ifndef CONFIG_WDT |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 348 | #if defined(CONFIG_WATCHDOG) |
Boschung, Rainer | 0f8062b | 2014-06-03 09:05:14 +0200 | [diff] [blame] | 349 | #define WATCHDOG_MASK (TCR_WP(63) | TCR_WRC(3) | TCR_WIE) |
| 350 | void |
| 351 | init_85xx_watchdog(void) |
| 352 | { |
| 353 | mtspr(SPRN_TCR, (mfspr(SPRN_TCR) & ~WATCHDOG_MASK) | |
| 354 | TCR_WP(CONFIG_WATCHDOG_PRESC) | TCR_WRC(CONFIG_WATCHDOG_RC)); |
| 355 | } |
| 356 | |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 357 | void |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 358 | reset_85xx_watchdog(void) |
| 359 | { |
| 360 | /* |
| 361 | * Clear TSR(WIS) bit by writing 1 |
| 362 | */ |
Mark Marshall | 320d53d | 2012-09-09 23:06:03 +0000 | [diff] [blame] | 363 | mtspr(SPRN_TSR, TSR_WIS); |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 364 | } |
Horst Kronstorfer | df616ca | 2013-03-13 10:14:05 +0000 | [diff] [blame] | 365 | |
| 366 | void |
| 367 | watchdog_reset(void) |
| 368 | { |
| 369 | int re_enable = disable_interrupts(); |
| 370 | |
| 371 | reset_85xx_watchdog(); |
| 372 | if (re_enable) |
| 373 | enable_interrupts(); |
| 374 | } |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 375 | #endif /* CONFIG_WATCHDOG */ |
Pali Rohár | 549bb6b | 2022-04-28 13:31:43 +0200 | [diff] [blame^] | 376 | #endif |
wdenk | 42d1f03 | 2003-10-15 23:53:47 +0000 | [diff] [blame] | 377 | |
Sergei Poselenov | 740280e | 2008-06-06 15:42:40 +0200 | [diff] [blame] | 378 | /* |
Andy Fleming | 80522dc | 2008-10-30 16:51:33 -0500 | [diff] [blame] | 379 | * Initializes on-chip MMC controllers. |
| 380 | * to override, implement board_mmc_init() |
| 381 | */ |
Masahiro Yamada | b75d8dc | 2020-06-26 15:13:33 +0900 | [diff] [blame] | 382 | int cpu_mmc_init(struct bd_info *bis) |
Andy Fleming | 80522dc | 2008-10-30 16:51:33 -0500 | [diff] [blame] | 383 | { |
| 384 | #ifdef CONFIG_FSL_ESDHC |
| 385 | return fsl_esdhc_mmc_init(bis); |
| 386 | #else |
| 387 | return 0; |
| 388 | #endif |
| 389 | } |
Becky Bruce | 199e262 | 2010-06-17 11:37:25 -0500 | [diff] [blame] | 390 | |
| 391 | /* |
| 392 | * Print out the state of various machine registers. |
Dipen Dudhat | d789b5f | 2011-01-20 16:29:35 +0530 | [diff] [blame] | 393 | * Currently prints out LAWs, BR0/OR0 for LBC, CSPR/CSOR/Timing |
| 394 | * parameters for IFC and TLBs |
Becky Bruce | 199e262 | 2010-06-17 11:37:25 -0500 | [diff] [blame] | 395 | */ |
Christophe Leroy | f3603b4 | 2017-07-13 15:09:54 +0200 | [diff] [blame] | 396 | void print_reginfo(void) |
Becky Bruce | 199e262 | 2010-06-17 11:37:25 -0500 | [diff] [blame] | 397 | { |
| 398 | print_tlbcam(); |
Bin Meng | 907568e | 2021-02-25 17:22:27 +0800 | [diff] [blame] | 399 | #ifdef CONFIG_FSL_LAW |
Becky Bruce | 199e262 | 2010-06-17 11:37:25 -0500 | [diff] [blame] | 400 | print_laws(); |
Bin Meng | 907568e | 2021-02-25 17:22:27 +0800 | [diff] [blame] | 401 | #endif |
Dipen Dudhat | beba93e | 2011-01-19 12:46:27 +0530 | [diff] [blame] | 402 | #if defined(CONFIG_FSL_LBC) |
Becky Bruce | 199e262 | 2010-06-17 11:37:25 -0500 | [diff] [blame] | 403 | print_lbc_regs(); |
Dipen Dudhat | beba93e | 2011-01-19 12:46:27 +0530 | [diff] [blame] | 404 | #endif |
Dipen Dudhat | d789b5f | 2011-01-20 16:29:35 +0530 | [diff] [blame] | 405 | #ifdef CONFIG_FSL_IFC |
| 406 | print_ifc_regs(); |
| 407 | #endif |
Dipen Dudhat | beba93e | 2011-01-19 12:46:27 +0530 | [diff] [blame] | 408 | |
Becky Bruce | 199e262 | 2010-06-17 11:37:25 -0500 | [diff] [blame] | 409 | } |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 410 | |
Becky Bruce | 38dba0c | 2010-12-17 17:17:56 -0600 | [diff] [blame] | 411 | /* Common ddr init for non-corenet fsl 85xx platforms */ |
| 412 | #ifndef CONFIG_FSL_CORENET |
Scott Wood | c97cd1b | 2012-09-20 19:02:18 -0500 | [diff] [blame] | 413 | #if (defined(CONFIG_SYS_RAMBOOT) || defined(CONFIG_SPL)) && \ |
| 414 | !defined(CONFIG_SYS_INIT_L2_ADDR) |
Simon Glass | f1683aa | 2017-04-06 12:47:05 -0600 | [diff] [blame] | 415 | int dram_init(void) |
Zhao Chenhui | c1fc2d4 | 2011-01-28 17:58:37 +0800 | [diff] [blame] | 416 | { |
Alexander Graf | fa08d39 | 2014-04-11 17:09:45 +0200 | [diff] [blame] | 417 | #if defined(CONFIG_SPD_EEPROM) || defined(CONFIG_DDR_SPD) || \ |
York Sun | 1034340 | 2016-11-18 12:29:51 -0800 | [diff] [blame] | 418 | defined(CONFIG_ARCH_QEMU_E500) |
Simon Glass | 088454c | 2017-03-31 08:40:25 -0600 | [diff] [blame] | 419 | gd->ram_size = fsl_ddr_sdram_size(); |
Zhao Chenhui | c1fc2d4 | 2011-01-28 17:58:37 +0800 | [diff] [blame] | 420 | #else |
Simon Glass | 088454c | 2017-03-31 08:40:25 -0600 | [diff] [blame] | 421 | gd->ram_size = (phys_size_t)CONFIG_SYS_SDRAM_SIZE * 1024 * 1024; |
Zhao Chenhui | c1fc2d4 | 2011-01-28 17:58:37 +0800 | [diff] [blame] | 422 | #endif |
Simon Glass | 088454c | 2017-03-31 08:40:25 -0600 | [diff] [blame] | 423 | |
| 424 | return 0; |
Zhao Chenhui | c1fc2d4 | 2011-01-28 17:58:37 +0800 | [diff] [blame] | 425 | } |
| 426 | #else /* CONFIG_SYS_RAMBOOT */ |
Simon Glass | f1683aa | 2017-04-06 12:47:05 -0600 | [diff] [blame] | 427 | int dram_init(void) |
Becky Bruce | 38dba0c | 2010-12-17 17:17:56 -0600 | [diff] [blame] | 428 | { |
| 429 | phys_size_t dram_size = 0; |
| 430 | |
Becky Bruce | 810c442 | 2010-12-17 17:17:58 -0600 | [diff] [blame] | 431 | #if defined(CONFIG_SYS_FSL_ERRATUM_DDR_MSYNC_IN) |
Becky Bruce | 38dba0c | 2010-12-17 17:17:56 -0600 | [diff] [blame] | 432 | { |
| 433 | ccsr_gur_t *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR); |
| 434 | unsigned int x = 10; |
| 435 | unsigned int i; |
| 436 | |
| 437 | /* |
| 438 | * Work around to stabilize DDR DLL |
| 439 | */ |
| 440 | out_be32(&gur->ddrdllcr, 0x81000000); |
| 441 | asm("sync;isync;msync"); |
| 442 | udelay(200); |
| 443 | while (in_be32(&gur->ddrdllcr) != 0x81000100) { |
| 444 | setbits_be32(&gur->devdisr, 0x00010000); |
| 445 | for (i = 0; i < x; i++) |
| 446 | ; |
| 447 | clrbits_be32(&gur->devdisr, 0x00010000); |
| 448 | x++; |
| 449 | } |
| 450 | } |
| 451 | #endif |
| 452 | |
York Sun | 1b3e3c4 | 2011-06-07 09:42:16 +0800 | [diff] [blame] | 453 | #if defined(CONFIG_SPD_EEPROM) || \ |
| 454 | defined(CONFIG_DDR_SPD) || \ |
| 455 | defined(CONFIG_SYS_DDR_RAW_TIMING) |
Becky Bruce | 38dba0c | 2010-12-17 17:17:56 -0600 | [diff] [blame] | 456 | dram_size = fsl_ddr_sdram(); |
| 457 | #else |
| 458 | dram_size = fixed_sdram(); |
| 459 | #endif |
| 460 | dram_size = setup_ddr_tlbs(dram_size / 0x100000); |
| 461 | dram_size *= 0x100000; |
| 462 | |
| 463 | #if defined(CONFIG_DDR_ECC) && !defined(CONFIG_ECC_INIT_VIA_DDRCONTROLLER) |
| 464 | /* |
| 465 | * Initialize and enable DDR ECC. |
| 466 | */ |
| 467 | ddr_enable_ecc(dram_size); |
| 468 | #endif |
| 469 | |
Dipen Dudhat | beba93e | 2011-01-19 12:46:27 +0530 | [diff] [blame] | 470 | #if defined(CONFIG_FSL_LBC) |
Becky Bruce | 38dba0c | 2010-12-17 17:17:56 -0600 | [diff] [blame] | 471 | /* Some boards also have sdram on the lbc */ |
Becky Bruce | 70961ba | 2010-12-17 17:17:57 -0600 | [diff] [blame] | 472 | lbc_sdram_init(); |
Dipen Dudhat | beba93e | 2011-01-19 12:46:27 +0530 | [diff] [blame] | 473 | #endif |
Becky Bruce | 38dba0c | 2010-12-17 17:17:56 -0600 | [diff] [blame] | 474 | |
Wolfgang Denk | 21cd581 | 2011-07-25 10:13:53 +0200 | [diff] [blame] | 475 | debug("DDR: "); |
Simon Glass | 088454c | 2017-03-31 08:40:25 -0600 | [diff] [blame] | 476 | gd->ram_size = dram_size; |
| 477 | |
| 478 | return 0; |
Becky Bruce | 38dba0c | 2010-12-17 17:17:56 -0600 | [diff] [blame] | 479 | } |
Zhao Chenhui | c1fc2d4 | 2011-01-28 17:58:37 +0800 | [diff] [blame] | 480 | #endif /* CONFIG_SYS_RAMBOOT */ |
Becky Bruce | 38dba0c | 2010-12-17 17:17:56 -0600 | [diff] [blame] | 481 | #endif |
| 482 | |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 483 | #if CONFIG_POST & CONFIG_SYS_POST_MEMORY |
| 484 | |
| 485 | /* Board-specific functions defined in each board's ddr.c */ |
| 486 | void fsl_ddr_get_spd(generic_spd_eeprom_t *ctrl_dimms_spd, |
York Sun | 1d71efb | 2014-08-01 15:51:00 -0700 | [diff] [blame] | 487 | unsigned int ctrl_num, unsigned int dimm_slots_per_ctrl); |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 488 | void read_tlbcam_entry(int idx, u32 *valid, u32 *tsize, unsigned long *epn, |
| 489 | phys_addr_t *rpn); |
| 490 | unsigned int |
| 491 | setup_ddr_tlbs_phys(phys_addr_t p_addr, unsigned int memsize_in_meg); |
| 492 | |
Becky Bruce | 9cdfe28 | 2011-07-18 18:49:15 -0500 | [diff] [blame] | 493 | void clear_ddr_tlbs_phys(phys_addr_t p_addr, unsigned int memsize_in_meg); |
| 494 | |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 495 | static void dump_spd_ddr_reg(void) |
| 496 | { |
| 497 | int i, j, k, m; |
| 498 | u8 *p_8; |
| 499 | u32 *p_32; |
York Sun | 51370d5 | 2016-12-28 08:43:45 -0800 | [diff] [blame] | 500 | struct ccsr_ddr __iomem *ddr[CONFIG_SYS_NUM_DDR_CTLRS]; |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 501 | generic_spd_eeprom_t |
York Sun | 51370d5 | 2016-12-28 08:43:45 -0800 | [diff] [blame] | 502 | spd[CONFIG_SYS_NUM_DDR_CTLRS][CONFIG_DIMM_SLOTS_PER_CTLR]; |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 503 | |
York Sun | 51370d5 | 2016-12-28 08:43:45 -0800 | [diff] [blame] | 504 | for (i = 0; i < CONFIG_SYS_NUM_DDR_CTLRS; i++) |
York Sun | 1d71efb | 2014-08-01 15:51:00 -0700 | [diff] [blame] | 505 | fsl_ddr_get_spd(spd[i], i, CONFIG_DIMM_SLOTS_PER_CTLR); |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 506 | |
Robert P. J. Day | fc0b594 | 2016-09-07 14:27:59 -0400 | [diff] [blame] | 507 | puts("SPD data of all dimms (zero value is omitted)...\n"); |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 508 | puts("Byte (hex) "); |
| 509 | k = 1; |
York Sun | 51370d5 | 2016-12-28 08:43:45 -0800 | [diff] [blame] | 510 | for (i = 0; i < CONFIG_SYS_NUM_DDR_CTLRS; i++) { |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 511 | for (j = 0; j < CONFIG_DIMM_SLOTS_PER_CTLR; j++) |
| 512 | printf("Dimm%d ", k++); |
| 513 | } |
| 514 | puts("\n"); |
| 515 | for (k = 0; k < sizeof(generic_spd_eeprom_t); k++) { |
| 516 | m = 0; |
| 517 | printf("%3d (0x%02x) ", k, k); |
York Sun | 51370d5 | 2016-12-28 08:43:45 -0800 | [diff] [blame] | 518 | for (i = 0; i < CONFIG_SYS_NUM_DDR_CTLRS; i++) { |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 519 | for (j = 0; j < CONFIG_DIMM_SLOTS_PER_CTLR; j++) { |
| 520 | p_8 = (u8 *) &spd[i][j]; |
| 521 | if (p_8[k]) { |
| 522 | printf("0x%02x ", p_8[k]); |
| 523 | m++; |
| 524 | } else |
| 525 | puts(" "); |
| 526 | } |
| 527 | } |
| 528 | if (m) |
| 529 | puts("\n"); |
| 530 | else |
| 531 | puts("\r"); |
| 532 | } |
| 533 | |
York Sun | 51370d5 | 2016-12-28 08:43:45 -0800 | [diff] [blame] | 534 | for (i = 0; i < CONFIG_SYS_NUM_DDR_CTLRS; i++) { |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 535 | switch (i) { |
| 536 | case 0: |
York Sun | 5614e71 | 2013-09-30 09:22:09 -0700 | [diff] [blame] | 537 | ddr[i] = (void *)CONFIG_SYS_FSL_DDR_ADDR; |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 538 | break; |
York Sun | 51370d5 | 2016-12-28 08:43:45 -0800 | [diff] [blame] | 539 | #if defined(CONFIG_SYS_FSL_DDR2_ADDR) && (CONFIG_SYS_NUM_DDR_CTLRS > 1) |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 540 | case 1: |
York Sun | 5614e71 | 2013-09-30 09:22:09 -0700 | [diff] [blame] | 541 | ddr[i] = (void *)CONFIG_SYS_FSL_DDR2_ADDR; |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 542 | break; |
| 543 | #endif |
York Sun | 51370d5 | 2016-12-28 08:43:45 -0800 | [diff] [blame] | 544 | #if defined(CONFIG_SYS_FSL_DDR3_ADDR) && (CONFIG_SYS_NUM_DDR_CTLRS > 2) |
York Sun | a4c6650 | 2012-08-17 08:22:39 +0000 | [diff] [blame] | 545 | case 2: |
York Sun | 5614e71 | 2013-09-30 09:22:09 -0700 | [diff] [blame] | 546 | ddr[i] = (void *)CONFIG_SYS_FSL_DDR3_ADDR; |
York Sun | a4c6650 | 2012-08-17 08:22:39 +0000 | [diff] [blame] | 547 | break; |
| 548 | #endif |
York Sun | 51370d5 | 2016-12-28 08:43:45 -0800 | [diff] [blame] | 549 | #if defined(CONFIG_SYS_FSL_DDR4_ADDR) && (CONFIG_SYS_NUM_DDR_CTLRS > 3) |
York Sun | a4c6650 | 2012-08-17 08:22:39 +0000 | [diff] [blame] | 550 | case 3: |
York Sun | 5614e71 | 2013-09-30 09:22:09 -0700 | [diff] [blame] | 551 | ddr[i] = (void *)CONFIG_SYS_FSL_DDR4_ADDR; |
York Sun | a4c6650 | 2012-08-17 08:22:39 +0000 | [diff] [blame] | 552 | break; |
| 553 | #endif |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 554 | default: |
| 555 | printf("%s unexpected controller number = %u\n", |
| 556 | __func__, i); |
| 557 | return; |
| 558 | } |
| 559 | } |
| 560 | printf("DDR registers dump for all controllers " |
Robert P. J. Day | fc0b594 | 2016-09-07 14:27:59 -0400 | [diff] [blame] | 561 | "(zero value is omitted)...\n"); |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 562 | puts("Offset (hex) "); |
York Sun | 51370d5 | 2016-12-28 08:43:45 -0800 | [diff] [blame] | 563 | for (i = 0; i < CONFIG_SYS_NUM_DDR_CTLRS; i++) |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 564 | printf(" Base + 0x%04x", (u32)ddr[i] & 0xFFFF); |
| 565 | puts("\n"); |
York Sun | 9a17eb5 | 2013-11-18 10:29:32 -0800 | [diff] [blame] | 566 | for (k = 0; k < sizeof(struct ccsr_ddr)/4; k++) { |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 567 | m = 0; |
| 568 | printf("%6d (0x%04x)", k * 4, k * 4); |
York Sun | 51370d5 | 2016-12-28 08:43:45 -0800 | [diff] [blame] | 569 | for (i = 0; i < CONFIG_SYS_NUM_DDR_CTLRS; i++) { |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 570 | p_32 = (u32 *) ddr[i]; |
| 571 | if (p_32[k]) { |
| 572 | printf(" 0x%08x", p_32[k]); |
| 573 | m++; |
| 574 | } else |
| 575 | puts(" "); |
| 576 | } |
| 577 | if (m) |
| 578 | puts("\n"); |
| 579 | else |
| 580 | puts("\r"); |
| 581 | } |
| 582 | puts("\n"); |
| 583 | } |
| 584 | |
| 585 | /* invalid the TLBs for DDR and setup new ones to cover p_addr */ |
| 586 | static int reset_tlb(phys_addr_t p_addr, u32 size, phys_addr_t *phys_offset) |
| 587 | { |
| 588 | u32 vstart = CONFIG_SYS_DDR_SDRAM_BASE; |
| 589 | unsigned long epn; |
| 590 | u32 tsize, valid, ptr; |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 591 | int ddr_esel; |
| 592 | |
Becky Bruce | 9cdfe28 | 2011-07-18 18:49:15 -0500 | [diff] [blame] | 593 | clear_ddr_tlbs_phys(p_addr, size>>20); |
York Sun | ebbe11d | 2010-09-28 15:20:33 -0700 | [diff] [blame] | 594 | |
| 595 | /* Setup new tlb to cover the physical address */ |
| 596 | setup_ddr_tlbs_phys(p_addr, size>>20); |
| 597 | |
| 598 | ptr = vstart; |
| 599 | ddr_esel = find_tlb_idx((void *)ptr, 1); |
| 600 | if (ddr_esel != -1) { |
| 601 | read_tlbcam_entry(ddr_esel, &valid, &tsize, &epn, phys_offset); |
| 602 | } else { |
| 603 | printf("TLB error in function %s\n", __func__); |
| 604 | return -1; |
| 605 | } |
| 606 | |
| 607 | return 0; |
| 608 | } |
| 609 | |
| 610 | /* |
| 611 | * slide the testing window up to test another area |
| 612 | * for 32_bit system, the maximum testable memory is limited to |
| 613 | * CONFIG_MAX_MEM_MAPPED |
| 614 | */ |
| 615 | int arch_memory_test_advance(u32 *vstart, u32 *size, phys_addr_t *phys_offset) |
| 616 | { |
| 617 | phys_addr_t test_cap, p_addr; |
| 618 | phys_size_t p_size = min(gd->ram_size, CONFIG_MAX_MEM_MAPPED); |
| 619 | |
| 620 | #if !defined(CONFIG_PHYS_64BIT) || \ |
| 621 | !defined(CONFIG_SYS_INIT_RAM_ADDR_PHYS) || \ |
| 622 | (CONFIG_SYS_INIT_RAM_ADDR_PHYS < 0x100000000ull) |
| 623 | test_cap = p_size; |
| 624 | #else |
| 625 | test_cap = gd->ram_size; |
| 626 | #endif |
| 627 | p_addr = (*vstart) + (*size) + (*phys_offset); |
| 628 | if (p_addr < test_cap - 1) { |
| 629 | p_size = min(test_cap - p_addr, CONFIG_MAX_MEM_MAPPED); |
| 630 | if (reset_tlb(p_addr, p_size, phys_offset) == -1) |
| 631 | return -1; |
| 632 | *vstart = CONFIG_SYS_DDR_SDRAM_BASE; |
| 633 | *size = (u32) p_size; |
| 634 | printf("Testing 0x%08llx - 0x%08llx\n", |
| 635 | (u64)(*vstart) + (*phys_offset), |
| 636 | (u64)(*vstart) + (*phys_offset) + (*size) - 1); |
| 637 | } else |
| 638 | return 1; |
| 639 | |
| 640 | return 0; |
| 641 | } |
| 642 | |
| 643 | /* initialization for testing area */ |
| 644 | int arch_memory_test_prepare(u32 *vstart, u32 *size, phys_addr_t *phys_offset) |
| 645 | { |
| 646 | phys_size_t p_size = min(gd->ram_size, CONFIG_MAX_MEM_MAPPED); |
| 647 | |
| 648 | *vstart = CONFIG_SYS_DDR_SDRAM_BASE; |
| 649 | *size = (u32) p_size; /* CONFIG_MAX_MEM_MAPPED < 4G */ |
| 650 | *phys_offset = 0; |
| 651 | |
| 652 | #if !defined(CONFIG_PHYS_64BIT) || \ |
| 653 | !defined(CONFIG_SYS_INIT_RAM_ADDR_PHYS) || \ |
| 654 | (CONFIG_SYS_INIT_RAM_ADDR_PHYS < 0x100000000ull) |
| 655 | if (gd->ram_size > CONFIG_MAX_MEM_MAPPED) { |
| 656 | puts("Cannot test more than "); |
| 657 | print_size(CONFIG_MAX_MEM_MAPPED, |
| 658 | " without proper 36BIT support.\n"); |
| 659 | } |
| 660 | #endif |
| 661 | printf("Testing 0x%08llx - 0x%08llx\n", |
| 662 | (u64)(*vstart) + (*phys_offset), |
| 663 | (u64)(*vstart) + (*phys_offset) + (*size) - 1); |
| 664 | |
| 665 | return 0; |
| 666 | } |
| 667 | |
| 668 | /* invalid TLBs for DDR and remap as normal after testing */ |
| 669 | int arch_memory_test_cleanup(u32 *vstart, u32 *size, phys_addr_t *phys_offset) |
| 670 | { |
| 671 | unsigned long epn; |
| 672 | u32 tsize, valid, ptr; |
| 673 | phys_addr_t rpn = 0; |
| 674 | int ddr_esel; |
| 675 | |
| 676 | /* disable the TLBs for this testing */ |
| 677 | ptr = *vstart; |
| 678 | |
| 679 | while (ptr < (*vstart) + (*size)) { |
| 680 | ddr_esel = find_tlb_idx((void *)ptr, 1); |
| 681 | if (ddr_esel != -1) { |
| 682 | read_tlbcam_entry(ddr_esel, &valid, &tsize, &epn, &rpn); |
| 683 | disable_tlb(ddr_esel); |
| 684 | } |
| 685 | ptr += TSIZE_TO_BYTES(tsize); |
| 686 | } |
| 687 | |
| 688 | puts("Remap DDR "); |
| 689 | setup_ddr_tlbs(gd->ram_size>>20); |
| 690 | puts("\n"); |
| 691 | |
| 692 | return 0; |
| 693 | } |
| 694 | |
| 695 | void arch_memory_failure_handle(void) |
| 696 | { |
| 697 | dump_spd_ddr_reg(); |
| 698 | } |
| 699 | #endif |