Commit cb082cf9061ccc24a4f374fd9b5c442b52ac05af
Committed by
Priyanka Jain
1 parent
8793c3d8af
Exists in
smarc_8mq_lf_v2020.04
and in
4 other branches
board: fsl: ls2088ardb: Program GIC LPI configuration table
Program GIC LPI configuration table: 1. Redistributor PROCBASER configuration table (which is common for all redistributors) 2. Redistributor pending table (PENDBASER), for all the available redistributors. 3.Reserve DDR memory region used for GIC LPI configuration table. Signed-off-by: Nikhil Gupta <nikhil.gupta@nxp.com>
Showing 1 changed file with 26 additions and 1 deletions Inline Diff
board/freescale/ls2080ardb/ls2080ardb.c
1 | // SPDX-License-Identifier: GPL-2.0+ | 1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* | 2 | /* |
3 | * Copyright 2015 Freescale Semiconductor | 3 | * Copyright 2015 Freescale Semiconductor |
4 | * Copyright 2017 NXP | 4 | * Copyright 2017-2020 NXP |
5 | */ | 5 | */ |
6 | #include <common.h> | 6 | #include <common.h> |
7 | #include <env.h> | 7 | #include <env.h> |
8 | #include <malloc.h> | 8 | #include <malloc.h> |
9 | #include <errno.h> | 9 | #include <errno.h> |
10 | #include <netdev.h> | 10 | #include <netdev.h> |
11 | #include <fsl_ifc.h> | 11 | #include <fsl_ifc.h> |
12 | #include <fsl_ddr.h> | 12 | #include <fsl_ddr.h> |
13 | #include <asm/io.h> | 13 | #include <asm/io.h> |
14 | #include <hwconfig.h> | 14 | #include <hwconfig.h> |
15 | #include <fdt_support.h> | 15 | #include <fdt_support.h> |
16 | #include <linux/libfdt.h> | 16 | #include <linux/libfdt.h> |
17 | #include <fsl-mc/fsl_mc.h> | 17 | #include <fsl-mc/fsl_mc.h> |
18 | #include <env_internal.h> | 18 | #include <env_internal.h> |
19 | #include <efi_loader.h> | 19 | #include <efi_loader.h> |
20 | #include <i2c.h> | 20 | #include <i2c.h> |
21 | #include <asm/arch/mmu.h> | 21 | #include <asm/arch/mmu.h> |
22 | #include <asm/arch/soc.h> | 22 | #include <asm/arch/soc.h> |
23 | #include <asm/arch/ppa.h> | 23 | #include <asm/arch/ppa.h> |
24 | #include <fsl_sec.h> | 24 | #include <fsl_sec.h> |
25 | #include <asm/arch-fsl-layerscape/fsl_icid.h> | 25 | #include <asm/arch-fsl-layerscape/fsl_icid.h> |
26 | #include <asm/gic-v3.h> | ||
27 | #include <cpu_func.h> | ||
26 | 28 | ||
29 | #define GIC_LPI_SIZE 0x200000 | ||
27 | #ifdef CONFIG_FSL_QIXIS | 30 | #ifdef CONFIG_FSL_QIXIS |
28 | #include "../common/qixis.h" | 31 | #include "../common/qixis.h" |
29 | #include "ls2080ardb_qixis.h" | 32 | #include "ls2080ardb_qixis.h" |
30 | #endif | 33 | #endif |
31 | #include "../common/vid.h" | 34 | #include "../common/vid.h" |
32 | 35 | ||
33 | #define PIN_MUX_SEL_SDHC 0x00 | 36 | #define PIN_MUX_SEL_SDHC 0x00 |
34 | #define PIN_MUX_SEL_DSPI 0x0a | 37 | #define PIN_MUX_SEL_DSPI 0x0a |
35 | 38 | ||
36 | #define SET_SDHC_MUX_SEL(reg, value) ((reg & 0xf0) | value) | 39 | #define SET_SDHC_MUX_SEL(reg, value) ((reg & 0xf0) | value) |
37 | DECLARE_GLOBAL_DATA_PTR; | 40 | DECLARE_GLOBAL_DATA_PTR; |
38 | 41 | ||
39 | enum { | 42 | enum { |
40 | MUX_TYPE_SDHC, | 43 | MUX_TYPE_SDHC, |
41 | MUX_TYPE_DSPI, | 44 | MUX_TYPE_DSPI, |
42 | }; | 45 | }; |
43 | 46 | ||
44 | unsigned long long get_qixis_addr(void) | 47 | unsigned long long get_qixis_addr(void) |
45 | { | 48 | { |
46 | unsigned long long addr; | 49 | unsigned long long addr; |
47 | 50 | ||
48 | if (gd->flags & GD_FLG_RELOC) | 51 | if (gd->flags & GD_FLG_RELOC) |
49 | addr = QIXIS_BASE_PHYS; | 52 | addr = QIXIS_BASE_PHYS; |
50 | else | 53 | else |
51 | addr = QIXIS_BASE_PHYS_EARLY; | 54 | addr = QIXIS_BASE_PHYS_EARLY; |
52 | 55 | ||
53 | /* | 56 | /* |
54 | * IFC address under 256MB is mapped to 0x30000000, any address above | 57 | * IFC address under 256MB is mapped to 0x30000000, any address above |
55 | * is mapped to 0x5_10000000 up to 4GB. | 58 | * is mapped to 0x5_10000000 up to 4GB. |
56 | */ | 59 | */ |
57 | addr = addr > 0x10000000 ? addr + 0x500000000ULL : addr + 0x30000000; | 60 | addr = addr > 0x10000000 ? addr + 0x500000000ULL : addr + 0x30000000; |
58 | 61 | ||
59 | return addr; | 62 | return addr; |
60 | } | 63 | } |
61 | 64 | ||
62 | int checkboard(void) | 65 | int checkboard(void) |
63 | { | 66 | { |
64 | #ifdef CONFIG_FSL_QIXIS | 67 | #ifdef CONFIG_FSL_QIXIS |
65 | u8 sw; | 68 | u8 sw; |
66 | #endif | 69 | #endif |
67 | char buf[15]; | 70 | char buf[15]; |
68 | 71 | ||
69 | cpu_name(buf); | 72 | cpu_name(buf); |
70 | printf("Board: %s-RDB, ", buf); | 73 | printf("Board: %s-RDB, ", buf); |
71 | 74 | ||
72 | #ifdef CONFIG_TARGET_LS2081ARDB | 75 | #ifdef CONFIG_TARGET_LS2081ARDB |
73 | #ifdef CONFIG_FSL_QIXIS | 76 | #ifdef CONFIG_FSL_QIXIS |
74 | sw = QIXIS_READ(arch); | 77 | sw = QIXIS_READ(arch); |
75 | printf("Board version: %c, ", (sw & 0xf) + 'A'); | 78 | printf("Board version: %c, ", (sw & 0xf) + 'A'); |
76 | 79 | ||
77 | sw = QIXIS_READ(brdcfg[0]); | 80 | sw = QIXIS_READ(brdcfg[0]); |
78 | sw = (sw >> QIXIS_QMAP_SHIFT) & QIXIS_QMAP_MASK; | 81 | sw = (sw >> QIXIS_QMAP_SHIFT) & QIXIS_QMAP_MASK; |
79 | switch (sw) { | 82 | switch (sw) { |
80 | case 0: | 83 | case 0: |
81 | puts("boot from QSPI DEV#0\n"); | 84 | puts("boot from QSPI DEV#0\n"); |
82 | puts("QSPI_CSA_1 mapped to QSPI DEV#1\n"); | 85 | puts("QSPI_CSA_1 mapped to QSPI DEV#1\n"); |
83 | break; | 86 | break; |
84 | case 1: | 87 | case 1: |
85 | puts("boot from QSPI DEV#1\n"); | 88 | puts("boot from QSPI DEV#1\n"); |
86 | puts("QSPI_CSA_1 mapped to QSPI DEV#0\n"); | 89 | puts("QSPI_CSA_1 mapped to QSPI DEV#0\n"); |
87 | break; | 90 | break; |
88 | case 2: | 91 | case 2: |
89 | puts("boot from QSPI EMU\n"); | 92 | puts("boot from QSPI EMU\n"); |
90 | puts("QSPI_CSA_1 mapped to QSPI DEV#0\n"); | 93 | puts("QSPI_CSA_1 mapped to QSPI DEV#0\n"); |
91 | break; | 94 | break; |
92 | case 3: | 95 | case 3: |
93 | puts("boot from QSPI EMU\n"); | 96 | puts("boot from QSPI EMU\n"); |
94 | puts("QSPI_CSA_1 mapped to QSPI DEV#1\n"); | 97 | puts("QSPI_CSA_1 mapped to QSPI DEV#1\n"); |
95 | break; | 98 | break; |
96 | case 4: | 99 | case 4: |
97 | puts("boot from QSPI DEV#0\n"); | 100 | puts("boot from QSPI DEV#0\n"); |
98 | puts("QSPI_CSA_1 mapped to QSPI EMU\n"); | 101 | puts("QSPI_CSA_1 mapped to QSPI EMU\n"); |
99 | break; | 102 | break; |
100 | default: | 103 | default: |
101 | printf("invalid setting of SW%u\n", sw); | 104 | printf("invalid setting of SW%u\n", sw); |
102 | break; | 105 | break; |
103 | } | 106 | } |
104 | printf("FPGA: v%d.%d\n", QIXIS_READ(scver), QIXIS_READ(tagdata)); | 107 | printf("FPGA: v%d.%d\n", QIXIS_READ(scver), QIXIS_READ(tagdata)); |
105 | #endif | 108 | #endif |
106 | puts("SERDES1 Reference : "); | 109 | puts("SERDES1 Reference : "); |
107 | printf("Clock1 = 100MHz "); | 110 | printf("Clock1 = 100MHz "); |
108 | printf("Clock2 = 161.13MHz"); | 111 | printf("Clock2 = 161.13MHz"); |
109 | #else | 112 | #else |
110 | #ifdef CONFIG_FSL_QIXIS | 113 | #ifdef CONFIG_FSL_QIXIS |
111 | sw = QIXIS_READ(arch); | 114 | sw = QIXIS_READ(arch); |
112 | printf("Board Arch: V%d, ", sw >> 4); | 115 | printf("Board Arch: V%d, ", sw >> 4); |
113 | printf("Board version: %c, boot from ", (sw & 0xf) + 'A'); | 116 | printf("Board version: %c, boot from ", (sw & 0xf) + 'A'); |
114 | 117 | ||
115 | sw = QIXIS_READ(brdcfg[0]); | 118 | sw = QIXIS_READ(brdcfg[0]); |
116 | sw = (sw & QIXIS_LBMAP_MASK) >> QIXIS_LBMAP_SHIFT; | 119 | sw = (sw & QIXIS_LBMAP_MASK) >> QIXIS_LBMAP_SHIFT; |
117 | 120 | ||
118 | if (sw < 0x8) | 121 | if (sw < 0x8) |
119 | printf("vBank: %d\n", sw); | 122 | printf("vBank: %d\n", sw); |
120 | else if (sw == 0x9) | 123 | else if (sw == 0x9) |
121 | puts("NAND\n"); | 124 | puts("NAND\n"); |
122 | else | 125 | else |
123 | printf("invalid setting of SW%u\n", QIXIS_LBMAP_SWITCH); | 126 | printf("invalid setting of SW%u\n", QIXIS_LBMAP_SWITCH); |
124 | 127 | ||
125 | printf("FPGA: v%d.%d\n", QIXIS_READ(scver), QIXIS_READ(tagdata)); | 128 | printf("FPGA: v%d.%d\n", QIXIS_READ(scver), QIXIS_READ(tagdata)); |
126 | #endif | 129 | #endif |
127 | puts("SERDES1 Reference : "); | 130 | puts("SERDES1 Reference : "); |
128 | printf("Clock1 = 156.25MHz "); | 131 | printf("Clock1 = 156.25MHz "); |
129 | printf("Clock2 = 156.25MHz"); | 132 | printf("Clock2 = 156.25MHz"); |
130 | #endif | 133 | #endif |
131 | 134 | ||
132 | puts("\nSERDES2 Reference : "); | 135 | puts("\nSERDES2 Reference : "); |
133 | printf("Clock1 = 100MHz "); | 136 | printf("Clock1 = 100MHz "); |
134 | printf("Clock2 = 100MHz\n"); | 137 | printf("Clock2 = 100MHz\n"); |
135 | 138 | ||
136 | return 0; | 139 | return 0; |
137 | } | 140 | } |
138 | 141 | ||
139 | unsigned long get_board_sys_clk(void) | 142 | unsigned long get_board_sys_clk(void) |
140 | { | 143 | { |
141 | #ifdef CONFIG_FSL_QIXIS | 144 | #ifdef CONFIG_FSL_QIXIS |
142 | u8 sysclk_conf = QIXIS_READ(brdcfg[1]); | 145 | u8 sysclk_conf = QIXIS_READ(brdcfg[1]); |
143 | 146 | ||
144 | switch (sysclk_conf & 0x0F) { | 147 | switch (sysclk_conf & 0x0F) { |
145 | case QIXIS_SYSCLK_83: | 148 | case QIXIS_SYSCLK_83: |
146 | return 83333333; | 149 | return 83333333; |
147 | case QIXIS_SYSCLK_100: | 150 | case QIXIS_SYSCLK_100: |
148 | return 100000000; | 151 | return 100000000; |
149 | case QIXIS_SYSCLK_125: | 152 | case QIXIS_SYSCLK_125: |
150 | return 125000000; | 153 | return 125000000; |
151 | case QIXIS_SYSCLK_133: | 154 | case QIXIS_SYSCLK_133: |
152 | return 133333333; | 155 | return 133333333; |
153 | case QIXIS_SYSCLK_150: | 156 | case QIXIS_SYSCLK_150: |
154 | return 150000000; | 157 | return 150000000; |
155 | case QIXIS_SYSCLK_160: | 158 | case QIXIS_SYSCLK_160: |
156 | return 160000000; | 159 | return 160000000; |
157 | case QIXIS_SYSCLK_166: | 160 | case QIXIS_SYSCLK_166: |
158 | return 166666666; | 161 | return 166666666; |
159 | } | 162 | } |
160 | #endif | 163 | #endif |
161 | return 100000000; | 164 | return 100000000; |
162 | } | 165 | } |
163 | 166 | ||
164 | int select_i2c_ch_pca9547(u8 ch) | 167 | int select_i2c_ch_pca9547(u8 ch) |
165 | { | 168 | { |
166 | int ret; | 169 | int ret; |
167 | 170 | ||
168 | #ifndef CONFIG_DM_I2C | 171 | #ifndef CONFIG_DM_I2C |
169 | ret = i2c_write(I2C_MUX_PCA_ADDR_PRI, 0, 1, &ch, 1); | 172 | ret = i2c_write(I2C_MUX_PCA_ADDR_PRI, 0, 1, &ch, 1); |
170 | #else | 173 | #else |
171 | struct udevice *dev; | 174 | struct udevice *dev; |
172 | 175 | ||
173 | ret = i2c_get_chip_for_busnum(0, I2C_MUX_PCA_ADDR_PRI, 1, &dev); | 176 | ret = i2c_get_chip_for_busnum(0, I2C_MUX_PCA_ADDR_PRI, 1, &dev); |
174 | if (!ret) | 177 | if (!ret) |
175 | ret = dm_i2c_write(dev, 0, &ch, 1); | 178 | ret = dm_i2c_write(dev, 0, &ch, 1); |
176 | #endif | 179 | #endif |
177 | 180 | ||
178 | if (ret) { | 181 | if (ret) { |
179 | puts("PCA: failed to select proper channel\n"); | 182 | puts("PCA: failed to select proper channel\n"); |
180 | return ret; | 183 | return ret; |
181 | } | 184 | } |
182 | 185 | ||
183 | return 0; | 186 | return 0; |
184 | } | 187 | } |
185 | 188 | ||
186 | int i2c_multiplexer_select_vid_channel(u8 channel) | 189 | int i2c_multiplexer_select_vid_channel(u8 channel) |
187 | { | 190 | { |
188 | return select_i2c_ch_pca9547(channel); | 191 | return select_i2c_ch_pca9547(channel); |
189 | } | 192 | } |
190 | 193 | ||
191 | int config_board_mux(int ctrl_type) | 194 | int config_board_mux(int ctrl_type) |
192 | { | 195 | { |
193 | #ifdef CONFIG_FSL_QIXIS | 196 | #ifdef CONFIG_FSL_QIXIS |
194 | u8 reg5; | 197 | u8 reg5; |
195 | 198 | ||
196 | reg5 = QIXIS_READ(brdcfg[5]); | 199 | reg5 = QIXIS_READ(brdcfg[5]); |
197 | 200 | ||
198 | switch (ctrl_type) { | 201 | switch (ctrl_type) { |
199 | case MUX_TYPE_SDHC: | 202 | case MUX_TYPE_SDHC: |
200 | reg5 = SET_SDHC_MUX_SEL(reg5, PIN_MUX_SEL_SDHC); | 203 | reg5 = SET_SDHC_MUX_SEL(reg5, PIN_MUX_SEL_SDHC); |
201 | break; | 204 | break; |
202 | case MUX_TYPE_DSPI: | 205 | case MUX_TYPE_DSPI: |
203 | reg5 = SET_SDHC_MUX_SEL(reg5, PIN_MUX_SEL_DSPI); | 206 | reg5 = SET_SDHC_MUX_SEL(reg5, PIN_MUX_SEL_DSPI); |
204 | break; | 207 | break; |
205 | default: | 208 | default: |
206 | printf("Wrong mux interface type\n"); | 209 | printf("Wrong mux interface type\n"); |
207 | return -1; | 210 | return -1; |
208 | } | 211 | } |
209 | 212 | ||
210 | QIXIS_WRITE(brdcfg[5], reg5); | 213 | QIXIS_WRITE(brdcfg[5], reg5); |
211 | #endif | 214 | #endif |
212 | return 0; | 215 | return 0; |
213 | } | 216 | } |
214 | 217 | ||
215 | int board_init(void) | 218 | int board_init(void) |
216 | { | 219 | { |
217 | #ifdef CONFIG_FSL_MC_ENET | 220 | #ifdef CONFIG_FSL_MC_ENET |
218 | u32 __iomem *irq_ccsr = (u32 __iomem *)ISC_BASE; | 221 | u32 __iomem *irq_ccsr = (u32 __iomem *)ISC_BASE; |
219 | #endif | 222 | #endif |
220 | 223 | ||
221 | init_final_memctl_regs(); | 224 | init_final_memctl_regs(); |
222 | 225 | ||
223 | #ifdef CONFIG_ENV_IS_NOWHERE | 226 | #ifdef CONFIG_ENV_IS_NOWHERE |
224 | gd->env_addr = (ulong)&default_environment[0]; | 227 | gd->env_addr = (ulong)&default_environment[0]; |
225 | #endif | 228 | #endif |
226 | select_i2c_ch_pca9547(I2C_MUX_CH_DEFAULT); | 229 | select_i2c_ch_pca9547(I2C_MUX_CH_DEFAULT); |
227 | 230 | ||
228 | #ifdef CONFIG_FSL_QIXIS | 231 | #ifdef CONFIG_FSL_QIXIS |
229 | QIXIS_WRITE(rst_ctl, QIXIS_RST_CTL_RESET_EN); | 232 | QIXIS_WRITE(rst_ctl, QIXIS_RST_CTL_RESET_EN); |
230 | #endif | 233 | #endif |
231 | 234 | ||
232 | #ifdef CONFIG_FSL_CAAM | 235 | #ifdef CONFIG_FSL_CAAM |
233 | sec_init(); | 236 | sec_init(); |
234 | #endif | 237 | #endif |
235 | #ifdef CONFIG_FSL_LS_PPA | 238 | #ifdef CONFIG_FSL_LS_PPA |
236 | ppa_init(); | 239 | ppa_init(); |
237 | #endif | 240 | #endif |
238 | 241 | ||
239 | #ifdef CONFIG_FSL_MC_ENET | 242 | #ifdef CONFIG_FSL_MC_ENET |
240 | /* invert AQR405 IRQ pins polarity */ | 243 | /* invert AQR405 IRQ pins polarity */ |
241 | out_le32(irq_ccsr + IRQCR_OFFSET / 4, AQR405_IRQ_MASK); | 244 | out_le32(irq_ccsr + IRQCR_OFFSET / 4, AQR405_IRQ_MASK); |
242 | #endif | 245 | #endif |
243 | #ifdef CONFIG_FSL_CAAM | 246 | #ifdef CONFIG_FSL_CAAM |
244 | sec_init(); | 247 | sec_init(); |
245 | #endif | 248 | #endif |
246 | 249 | ||
247 | return 0; | 250 | return 0; |
248 | } | 251 | } |
249 | 252 | ||
250 | int board_early_init_f(void) | 253 | int board_early_init_f(void) |
251 | { | 254 | { |
252 | #ifdef CONFIG_SYS_I2C_EARLY_INIT | 255 | #ifdef CONFIG_SYS_I2C_EARLY_INIT |
253 | i2c_early_init_f(); | 256 | i2c_early_init_f(); |
254 | #endif | 257 | #endif |
255 | fsl_lsch3_early_init_f(); | 258 | fsl_lsch3_early_init_f(); |
256 | return 0; | 259 | return 0; |
257 | } | 260 | } |
258 | 261 | ||
259 | int misc_init_r(void) | 262 | int misc_init_r(void) |
260 | { | 263 | { |
261 | char *env_hwconfig; | 264 | char *env_hwconfig; |
262 | u32 __iomem *dcfg_ccsr = (u32 __iomem *)DCFG_BASE; | 265 | u32 __iomem *dcfg_ccsr = (u32 __iomem *)DCFG_BASE; |
263 | u32 val; | 266 | u32 val; |
264 | struct ccsr_gur __iomem *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR); | 267 | struct ccsr_gur __iomem *gur = (void *)(CONFIG_SYS_FSL_GUTS_ADDR); |
265 | u32 svr = gur_in32(&gur->svr); | 268 | u32 svr = gur_in32(&gur->svr); |
266 | 269 | ||
267 | val = in_le32(dcfg_ccsr + DCFG_RCWSR13 / 4); | 270 | val = in_le32(dcfg_ccsr + DCFG_RCWSR13 / 4); |
268 | 271 | ||
269 | env_hwconfig = env_get("hwconfig"); | 272 | env_hwconfig = env_get("hwconfig"); |
270 | 273 | ||
271 | if (hwconfig_f("dspi", env_hwconfig) && | 274 | if (hwconfig_f("dspi", env_hwconfig) && |
272 | DCFG_RCWSR13_DSPI == (val & (u32)(0xf << 8))) | 275 | DCFG_RCWSR13_DSPI == (val & (u32)(0xf << 8))) |
273 | config_board_mux(MUX_TYPE_DSPI); | 276 | config_board_mux(MUX_TYPE_DSPI); |
274 | else | 277 | else |
275 | config_board_mux(MUX_TYPE_SDHC); | 278 | config_board_mux(MUX_TYPE_SDHC); |
276 | 279 | ||
277 | /* | 280 | /* |
278 | * LS2081ARDB RevF board has smart voltage translator | 281 | * LS2081ARDB RevF board has smart voltage translator |
279 | * which needs to be programmed to enable high speed SD interface | 282 | * which needs to be programmed to enable high speed SD interface |
280 | * by setting GPIO4_10 output to zero | 283 | * by setting GPIO4_10 output to zero |
281 | */ | 284 | */ |
282 | #ifdef CONFIG_TARGET_LS2081ARDB | 285 | #ifdef CONFIG_TARGET_LS2081ARDB |
283 | out_le32(GPIO4_GPDIR_ADDR, (1 << 21 | | 286 | out_le32(GPIO4_GPDIR_ADDR, (1 << 21 | |
284 | in_le32(GPIO4_GPDIR_ADDR))); | 287 | in_le32(GPIO4_GPDIR_ADDR))); |
285 | out_le32(GPIO4_GPDAT_ADDR, (~(1 << 21) & | 288 | out_le32(GPIO4_GPDAT_ADDR, (~(1 << 21) & |
286 | in_le32(GPIO4_GPDAT_ADDR))); | 289 | in_le32(GPIO4_GPDAT_ADDR))); |
287 | #endif | 290 | #endif |
288 | if (hwconfig("sdhc")) | 291 | if (hwconfig("sdhc")) |
289 | config_board_mux(MUX_TYPE_SDHC); | 292 | config_board_mux(MUX_TYPE_SDHC); |
290 | 293 | ||
291 | if (adjust_vdd(0)) | 294 | if (adjust_vdd(0)) |
292 | printf("Warning: Adjusting core voltage failed.\n"); | 295 | printf("Warning: Adjusting core voltage failed.\n"); |
293 | /* | 296 | /* |
294 | * Default value of board env is based on filename which is | 297 | * Default value of board env is based on filename which is |
295 | * ls2080ardb. Modify board env for other supported SoCs | 298 | * ls2080ardb. Modify board env for other supported SoCs |
296 | */ | 299 | */ |
297 | if ((SVR_SOC_VER(svr) == SVR_LS2088A) || | 300 | if ((SVR_SOC_VER(svr) == SVR_LS2088A) || |
298 | (SVR_SOC_VER(svr) == SVR_LS2048A)) | 301 | (SVR_SOC_VER(svr) == SVR_LS2048A)) |
299 | env_set("board", "ls2088ardb"); | 302 | env_set("board", "ls2088ardb"); |
300 | else if ((SVR_SOC_VER(svr) == SVR_LS2081A) || | 303 | else if ((SVR_SOC_VER(svr) == SVR_LS2081A) || |
301 | (SVR_SOC_VER(svr) == SVR_LS2041A)) | 304 | (SVR_SOC_VER(svr) == SVR_LS2041A)) |
302 | env_set("board", "ls2081ardb"); | 305 | env_set("board", "ls2081ardb"); |
303 | 306 | ||
304 | return 0; | 307 | return 0; |
305 | } | 308 | } |
306 | 309 | ||
307 | void detail_board_ddr_info(void) | 310 | void detail_board_ddr_info(void) |
308 | { | 311 | { |
309 | puts("\nDDR "); | 312 | puts("\nDDR "); |
310 | print_size(gd->bd->bi_dram[0].size + gd->bd->bi_dram[1].size, ""); | 313 | print_size(gd->bd->bi_dram[0].size + gd->bd->bi_dram[1].size, ""); |
311 | print_ddr_info(0); | 314 | print_ddr_info(0); |
312 | #ifdef CONFIG_SYS_FSL_HAS_DP_DDR | 315 | #ifdef CONFIG_SYS_FSL_HAS_DP_DDR |
313 | if (soc_has_dp_ddr() && gd->bd->bi_dram[2].size) { | 316 | if (soc_has_dp_ddr() && gd->bd->bi_dram[2].size) { |
314 | puts("\nDP-DDR "); | 317 | puts("\nDP-DDR "); |
315 | print_size(gd->bd->bi_dram[2].size, ""); | 318 | print_size(gd->bd->bi_dram[2].size, ""); |
316 | print_ddr_info(CONFIG_DP_DDR_CTRL); | 319 | print_ddr_info(CONFIG_DP_DDR_CTRL); |
317 | } | 320 | } |
318 | #endif | 321 | #endif |
319 | } | 322 | } |
320 | 323 | ||
321 | #ifdef CONFIG_FSL_MC_ENET | 324 | #ifdef CONFIG_FSL_MC_ENET |
322 | void fdt_fixup_board_enet(void *fdt) | 325 | void fdt_fixup_board_enet(void *fdt) |
323 | { | 326 | { |
324 | int offset; | 327 | int offset; |
325 | 328 | ||
326 | offset = fdt_path_offset(fdt, "/soc/fsl-mc"); | 329 | offset = fdt_path_offset(fdt, "/soc/fsl-mc"); |
327 | 330 | ||
328 | if (offset < 0) | 331 | if (offset < 0) |
329 | offset = fdt_path_offset(fdt, "/fsl-mc"); | 332 | offset = fdt_path_offset(fdt, "/fsl-mc"); |
330 | 333 | ||
331 | if (offset < 0) { | 334 | if (offset < 0) { |
332 | printf("%s: ERROR: fsl-mc node not found in device tree (error %d)\n", | 335 | printf("%s: ERROR: fsl-mc node not found in device tree (error %d)\n", |
333 | __func__, offset); | 336 | __func__, offset); |
334 | return; | 337 | return; |
335 | } | 338 | } |
336 | 339 | ||
337 | if (get_mc_boot_status() == 0 && | 340 | if (get_mc_boot_status() == 0 && |
338 | (is_lazy_dpl_addr_valid() || get_dpl_apply_status() == 0)) | 341 | (is_lazy_dpl_addr_valid() || get_dpl_apply_status() == 0)) |
339 | fdt_status_okay(fdt, offset); | 342 | fdt_status_okay(fdt, offset); |
340 | else | 343 | else |
341 | fdt_status_fail(fdt, offset); | 344 | fdt_status_fail(fdt, offset); |
342 | } | 345 | } |
343 | 346 | ||
344 | void board_quiesce_devices(void) | 347 | void board_quiesce_devices(void) |
345 | { | 348 | { |
346 | fsl_mc_ldpaa_exit(gd->bd); | 349 | fsl_mc_ldpaa_exit(gd->bd); |
347 | } | 350 | } |
348 | #endif | 351 | #endif |
349 | 352 | ||
353 | #ifdef CONFIG_GIC_V3_ITS | ||
354 | void fdt_fixup_gic_lpi_memory(void *blob, u64 gic_lpi_base) | ||
355 | { | ||
356 | u32 phandle; | ||
357 | int err; | ||
358 | struct fdt_memory gic_lpi; | ||
359 | |||
360 | gic_lpi.start = gic_lpi_base; | ||
361 | gic_lpi.end = gic_lpi_base + GIC_LPI_SIZE - 1; | ||
362 | err = fdtdec_add_reserved_memory(blob, "gic-lpi", &gic_lpi, &phandle); | ||
363 | if (err < 0) | ||
364 | debug("failed to add reserved memory: %d\n", err); | ||
365 | } | ||
366 | #endif | ||
367 | |||
350 | #ifdef CONFIG_OF_BOARD_SETUP | 368 | #ifdef CONFIG_OF_BOARD_SETUP |
351 | void fsl_fdt_fixup_flash(void *fdt) | 369 | void fsl_fdt_fixup_flash(void *fdt) |
352 | { | 370 | { |
353 | int offset; | 371 | int offset; |
354 | #ifdef CONFIG_TFABOOT | 372 | #ifdef CONFIG_TFABOOT |
355 | u32 __iomem *dcfg_ccsr = (u32 __iomem *)DCFG_BASE; | 373 | u32 __iomem *dcfg_ccsr = (u32 __iomem *)DCFG_BASE; |
356 | u32 val; | 374 | u32 val; |
357 | #endif | 375 | #endif |
358 | 376 | ||
359 | /* | 377 | /* |
360 | * IFC and QSPI are muxed on board. | 378 | * IFC and QSPI are muxed on board. |
361 | * So disable IFC node in dts if QSPI is enabled or | 379 | * So disable IFC node in dts if QSPI is enabled or |
362 | * disable QSPI node in dts in case QSPI is not enabled. | 380 | * disable QSPI node in dts in case QSPI is not enabled. |
363 | */ | 381 | */ |
364 | #ifdef CONFIG_TFABOOT | 382 | #ifdef CONFIG_TFABOOT |
365 | enum boot_src src = get_boot_src(); | 383 | enum boot_src src = get_boot_src(); |
366 | bool disable_ifc = false; | 384 | bool disable_ifc = false; |
367 | 385 | ||
368 | switch (src) { | 386 | switch (src) { |
369 | case BOOT_SOURCE_IFC_NOR: | 387 | case BOOT_SOURCE_IFC_NOR: |
370 | disable_ifc = false; | 388 | disable_ifc = false; |
371 | break; | 389 | break; |
372 | case BOOT_SOURCE_QSPI_NOR: | 390 | case BOOT_SOURCE_QSPI_NOR: |
373 | disable_ifc = true; | 391 | disable_ifc = true; |
374 | break; | 392 | break; |
375 | default: | 393 | default: |
376 | val = in_le32(dcfg_ccsr + DCFG_RCWSR15 / 4); | 394 | val = in_le32(dcfg_ccsr + DCFG_RCWSR15 / 4); |
377 | if (DCFG_RCWSR15_IFCGRPABASE_QSPI == (val & (u32)0x3)) | 395 | if (DCFG_RCWSR15_IFCGRPABASE_QSPI == (val & (u32)0x3)) |
378 | disable_ifc = true; | 396 | disable_ifc = true; |
379 | break; | 397 | break; |
380 | } | 398 | } |
381 | 399 | ||
382 | if (disable_ifc) { | 400 | if (disable_ifc) { |
383 | offset = fdt_path_offset(fdt, "/soc/ifc"); | 401 | offset = fdt_path_offset(fdt, "/soc/ifc"); |
384 | 402 | ||
385 | if (offset < 0) | 403 | if (offset < 0) |
386 | offset = fdt_path_offset(fdt, "/ifc"); | 404 | offset = fdt_path_offset(fdt, "/ifc"); |
387 | } else { | 405 | } else { |
388 | offset = fdt_path_offset(fdt, "/soc/quadspi"); | 406 | offset = fdt_path_offset(fdt, "/soc/quadspi"); |
389 | 407 | ||
390 | if (offset < 0) | 408 | if (offset < 0) |
391 | offset = fdt_path_offset(fdt, "/quadspi"); | 409 | offset = fdt_path_offset(fdt, "/quadspi"); |
392 | } | 410 | } |
393 | 411 | ||
394 | #else | 412 | #else |
395 | #ifdef CONFIG_FSL_QSPI | 413 | #ifdef CONFIG_FSL_QSPI |
396 | offset = fdt_path_offset(fdt, "/soc/ifc"); | 414 | offset = fdt_path_offset(fdt, "/soc/ifc"); |
397 | 415 | ||
398 | if (offset < 0) | 416 | if (offset < 0) |
399 | offset = fdt_path_offset(fdt, "/ifc"); | 417 | offset = fdt_path_offset(fdt, "/ifc"); |
400 | #else | 418 | #else |
401 | offset = fdt_path_offset(fdt, "/soc/quadspi"); | 419 | offset = fdt_path_offset(fdt, "/soc/quadspi"); |
402 | 420 | ||
403 | if (offset < 0) | 421 | if (offset < 0) |
404 | offset = fdt_path_offset(fdt, "/quadspi"); | 422 | offset = fdt_path_offset(fdt, "/quadspi"); |
405 | #endif | 423 | #endif |
406 | #endif | 424 | #endif |
407 | 425 | ||
408 | if (offset < 0) | 426 | if (offset < 0) |
409 | return; | 427 | return; |
410 | 428 | ||
411 | fdt_status_disabled(fdt, offset); | 429 | fdt_status_disabled(fdt, offset); |
412 | } | 430 | } |
413 | 431 | ||
414 | int ft_board_setup(void *blob, bd_t *bd) | 432 | int ft_board_setup(void *blob, bd_t *bd) |
415 | { | 433 | { |
416 | int i; | 434 | int i; |
417 | u16 mc_memory_bank = 0; | 435 | u16 mc_memory_bank = 0; |
418 | 436 | ||
419 | u64 *base; | 437 | u64 *base; |
420 | u64 *size; | 438 | u64 *size; |
421 | u64 mc_memory_base = 0; | 439 | u64 mc_memory_base = 0; |
422 | u64 mc_memory_size = 0; | 440 | u64 mc_memory_size = 0; |
423 | u16 total_memory_banks; | 441 | u16 total_memory_banks; |
442 | u64 gic_lpi_base; | ||
424 | 443 | ||
425 | ft_cpu_setup(blob, bd); | 444 | ft_cpu_setup(blob, bd); |
426 | 445 | ||
427 | fdt_fixup_mc_ddr(&mc_memory_base, &mc_memory_size); | 446 | fdt_fixup_mc_ddr(&mc_memory_base, &mc_memory_size); |
428 | 447 | ||
429 | if (mc_memory_base != 0) | 448 | if (mc_memory_base != 0) |
430 | mc_memory_bank++; | 449 | mc_memory_bank++; |
431 | 450 | ||
432 | total_memory_banks = CONFIG_NR_DRAM_BANKS + mc_memory_bank; | 451 | total_memory_banks = CONFIG_NR_DRAM_BANKS + mc_memory_bank; |
433 | 452 | ||
434 | base = calloc(total_memory_banks, sizeof(u64)); | 453 | base = calloc(total_memory_banks, sizeof(u64)); |
435 | size = calloc(total_memory_banks, sizeof(u64)); | 454 | size = calloc(total_memory_banks, sizeof(u64)); |
436 | 455 | ||
437 | /* fixup DT for the two GPP DDR banks */ | 456 | /* fixup DT for the two GPP DDR banks */ |
438 | base[0] = gd->bd->bi_dram[0].start; | 457 | base[0] = gd->bd->bi_dram[0].start; |
439 | size[0] = gd->bd->bi_dram[0].size; | 458 | size[0] = gd->bd->bi_dram[0].size; |
440 | base[1] = gd->bd->bi_dram[1].start; | 459 | base[1] = gd->bd->bi_dram[1].start; |
441 | size[1] = gd->bd->bi_dram[1].size; | 460 | size[1] = gd->bd->bi_dram[1].size; |
461 | |||
462 | #ifdef CONFIG_GIC_V3_ITS | ||
463 | gic_lpi_base = gd->arch.resv_ram - GIC_LPI_SIZE; | ||
464 | gic_lpi_tables_init(gic_lpi_base, cpu_numcores()); | ||
465 | fdt_fixup_gic_lpi_memory(blob, gic_lpi_base); | ||
466 | #endif | ||
442 | 467 | ||
443 | #ifdef CONFIG_RESV_RAM | 468 | #ifdef CONFIG_RESV_RAM |
444 | /* reduce size if reserved memory is within this bank */ | 469 | /* reduce size if reserved memory is within this bank */ |
445 | if (gd->arch.resv_ram >= base[0] && | 470 | if (gd->arch.resv_ram >= base[0] && |
446 | gd->arch.resv_ram < base[0] + size[0]) | 471 | gd->arch.resv_ram < base[0] + size[0]) |
447 | size[0] = gd->arch.resv_ram - base[0]; | 472 | size[0] = gd->arch.resv_ram - base[0]; |
448 | else if (gd->arch.resv_ram >= base[1] && | 473 | else if (gd->arch.resv_ram >= base[1] && |
449 | gd->arch.resv_ram < base[1] + size[1]) | 474 | gd->arch.resv_ram < base[1] + size[1]) |
450 | size[1] = gd->arch.resv_ram - base[1]; | 475 | size[1] = gd->arch.resv_ram - base[1]; |
451 | #endif | 476 | #endif |
452 | 477 | ||
453 | if (mc_memory_base != 0) { | 478 | if (mc_memory_base != 0) { |
454 | for (i = 0; i <= total_memory_banks; i++) { | 479 | for (i = 0; i <= total_memory_banks; i++) { |
455 | if (base[i] == 0 && size[i] == 0) { | 480 | if (base[i] == 0 && size[i] == 0) { |
456 | base[i] = mc_memory_base; | 481 | base[i] = mc_memory_base; |
457 | size[i] = mc_memory_size; | 482 | size[i] = mc_memory_size; |
458 | break; | 483 | break; |
459 | } | 484 | } |
460 | } | 485 | } |
461 | } | 486 | } |
462 | 487 | ||
463 | fdt_fixup_memory_banks(blob, base, size, total_memory_banks); | 488 | fdt_fixup_memory_banks(blob, base, size, total_memory_banks); |
464 | 489 | ||
465 | fdt_fsl_mc_fixup_iommu_map_entry(blob); | 490 | fdt_fsl_mc_fixup_iommu_map_entry(blob); |
466 | 491 | ||
467 | fsl_fdt_fixup_dr_usb(blob, bd); | 492 | fsl_fdt_fixup_dr_usb(blob, bd); |
468 | 493 | ||
469 | fsl_fdt_fixup_flash(blob); | 494 | fsl_fdt_fixup_flash(blob); |
470 | 495 | ||
471 | #ifdef CONFIG_FSL_MC_ENET | 496 | #ifdef CONFIG_FSL_MC_ENET |
472 | fdt_fixup_board_enet(blob); | 497 | fdt_fixup_board_enet(blob); |
473 | #endif | 498 | #endif |
474 | 499 | ||
475 | fdt_fixup_icid(blob); | 500 | fdt_fixup_icid(blob); |
476 | 501 | ||
477 | return 0; | 502 | return 0; |
478 | } | 503 | } |
479 | #endif | 504 | #endif |
480 | 505 | ||
481 | void qixis_dump_switch(void) | 506 | void qixis_dump_switch(void) |
482 | { | 507 | { |
483 | #ifdef CONFIG_FSL_QIXIS | 508 | #ifdef CONFIG_FSL_QIXIS |
484 | int i, nr_of_cfgsw; | 509 | int i, nr_of_cfgsw; |
485 | 510 | ||
486 | QIXIS_WRITE(cms[0], 0x00); | 511 | QIXIS_WRITE(cms[0], 0x00); |
487 | nr_of_cfgsw = QIXIS_READ(cms[1]); | 512 | nr_of_cfgsw = QIXIS_READ(cms[1]); |
488 | 513 | ||
489 | puts("DIP switch settings dump:\n"); | 514 | puts("DIP switch settings dump:\n"); |
490 | for (i = 1; i <= nr_of_cfgsw; i++) { | 515 | for (i = 1; i <= nr_of_cfgsw; i++) { |
491 | QIXIS_WRITE(cms[0], i); | 516 | QIXIS_WRITE(cms[0], i); |
492 | printf("SW%d = (0x%02x)\n", i, QIXIS_READ(cms[1])); | 517 | printf("SW%d = (0x%02x)\n", i, QIXIS_READ(cms[1])); |
493 | } | 518 | } |
494 | #endif | 519 | #endif |
495 | } | 520 | } |
496 | 521 | ||
497 | /* | 522 | /* |
498 | * Board rev C and earlier has duplicated I2C addresses for 2nd controller. | 523 | * Board rev C and earlier has duplicated I2C addresses for 2nd controller. |
499 | * Both slots has 0x54, resulting 2nd slot unusable. | 524 | * Both slots has 0x54, resulting 2nd slot unusable. |
500 | */ | 525 | */ |
501 | void update_spd_address(unsigned int ctrl_num, | 526 | void update_spd_address(unsigned int ctrl_num, |
502 | unsigned int slot, | 527 | unsigned int slot, |
503 | unsigned int *addr) | 528 | unsigned int *addr) |
504 | { | 529 | { |
505 | #ifndef CONFIG_TARGET_LS2081ARDB | 530 | #ifndef CONFIG_TARGET_LS2081ARDB |
506 | #ifdef CONFIG_FSL_QIXIS | 531 | #ifdef CONFIG_FSL_QIXIS |
507 | u8 sw; | 532 | u8 sw; |
508 | 533 | ||
509 | sw = QIXIS_READ(arch); | 534 | sw = QIXIS_READ(arch); |
510 | if ((sw & 0xf) < 0x3) { | 535 | if ((sw & 0xf) < 0x3) { |
511 | if (ctrl_num == 1 && slot == 0) | 536 | if (ctrl_num == 1 && slot == 0) |
512 | *addr = SPD_EEPROM_ADDRESS4; | 537 | *addr = SPD_EEPROM_ADDRESS4; |
513 | else if (ctrl_num == 1 && slot == 1) | 538 | else if (ctrl_num == 1 && slot == 1) |
514 | *addr = SPD_EEPROM_ADDRESS3; | 539 | *addr = SPD_EEPROM_ADDRESS3; |
515 | } | 540 | } |
516 | #endif | 541 | #endif |
517 | #endif | 542 | #endif |
518 | } | 543 | } |
519 | 544 |