]>
Commit | Line | Data |
---|---|---|
63cec581 | 1 | /* |
505f3e6f | 2 | * Copyright 2007-2012 Freescale Semiconductor, Inc. |
63cec581 | 3 | * |
1a459660 | 4 | * SPDX-License-Identifier: GPL-2.0+ |
63cec581 | 5 | */ |
2e4d94f1 | 6 | |
63cec581 | 7 | #include <common.h> |
a4aafcc9 KG |
8 | #include <malloc.h> |
9 | #include <asm/fsl_serdes.h> | |
63cec581 | 10 | |
b9a1fa97 KG |
11 | DECLARE_GLOBAL_DATA_PTR; |
12 | ||
63cec581 ES |
13 | /* |
14 | * PCI/PCIE Controller initialization for mpc85xx/mpc86xx soc's | |
15 | * | |
16 | * Initialize controller and call the common driver/pci pci_hose_scan to | |
17 | * scan for bridges and devices. | |
18 | * | |
19 | * Hose fields which need to be pre-initialized by board specific code: | |
20 | * regions[] | |
21 | * first_busno | |
22 | * | |
23 | * Fields updated: | |
24 | * last_busno | |
25 | */ | |
26 | ||
27 | #include <pci.h> | |
ad19e7a5 | 28 | #include <asm/io.h> |
c8514622 | 29 | #include <asm/fsl_pci.h> |
63cec581 | 30 | |
b9a1fa97 KG |
31 | #ifndef CONFIG_SYS_PCI_MEMORY_BUS |
32 | #define CONFIG_SYS_PCI_MEMORY_BUS 0 | |
33 | #endif | |
34 | ||
35 | #ifndef CONFIG_SYS_PCI_MEMORY_PHYS | |
36 | #define CONFIG_SYS_PCI_MEMORY_PHYS 0 | |
37 | #endif | |
38 | ||
39 | #if defined(CONFIG_SYS_PCI_64BIT) && !defined(CONFIG_SYS_PCI64_MEMORY_BUS) | |
40 | #define CONFIG_SYS_PCI64_MEMORY_BUS (64ull*1024*1024*1024) | |
41 | #endif | |
42 | ||
ad19e7a5 KG |
43 | /* Setup one inbound ATMU window. |
44 | * | |
45 | * We let the caller decide what the window size should be | |
46 | */ | |
47 | static void set_inbound_window(volatile pit_t *pi, | |
48 | struct pci_region *r, | |
49 | u64 size) | |
b9a1fa97 | 50 | { |
ad19e7a5 | 51 | u32 sz = (__ilog2_u64(size) - 1); |
f1a96ec1 CL |
52 | #ifdef CONFIG_SYS_FSL_ERRATUM_A005434 |
53 | u32 flag = 0; | |
54 | #else | |
55 | u32 flag = PIWAR_LOCAL; | |
56 | #endif | |
57 | ||
58 | flag |= PIWAR_EN | PIWAR_READ_SNOOP | PIWAR_WRITE_SNOOP; | |
ad19e7a5 KG |
59 | |
60 | out_be32(&pi->pitar, r->phys_start >> 12); | |
61 | out_be32(&pi->piwbar, r->bus_start >> 12); | |
62 | #ifdef CONFIG_SYS_PCI_64BIT | |
63 | out_be32(&pi->piwbear, r->bus_start >> 44); | |
64 | #else | |
65 | out_be32(&pi->piwbear, 0); | |
66 | #endif | |
67 | if (r->flags & PCI_REGION_PREFETCH) | |
68 | flag |= PIWAR_PF; | |
69 | out_be32(&pi->piwar, flag | sz); | |
70 | } | |
71 | ||
ee53650d KG |
72 | int fsl_setup_hose(struct pci_controller *hose, unsigned long addr) |
73 | { | |
74 | volatile ccsr_fsl_pci_t *pci = (ccsr_fsl_pci_t *) addr; | |
75 | ||
96d61603 JS |
76 | /* Reset hose to make sure its in a clean state */ |
77 | memset(hose, 0, sizeof(struct pci_controller)); | |
78 | ||
ee53650d KG |
79 | pci_setup_indirect(hose, (u32)&pci->cfg_addr, (u32)&pci->cfg_data); |
80 | ||
81 | return fsl_is_pci_agent(hose); | |
82 | } | |
83 | ||
ad19e7a5 KG |
84 | static int fsl_pci_setup_inbound_windows(struct pci_controller *hose, |
85 | u64 out_lo, u8 pcie_cap, | |
86 | volatile pit_t *pi) | |
87 | { | |
88 | struct pci_region *r = hose->regions + hose->region_count; | |
89 | u64 sz = min((u64)gd->ram_size, (1ull << 32)); | |
b9a1fa97 KG |
90 | |
91 | phys_addr_t phys_start = CONFIG_SYS_PCI_MEMORY_PHYS; | |
92 | pci_addr_t bus_start = CONFIG_SYS_PCI_MEMORY_BUS; | |
ad19e7a5 | 93 | pci_size_t pci_sz; |
b9a1fa97 | 94 | |
ad19e7a5 KG |
95 | /* we have no space available for inbound memory mapping */ |
96 | if (bus_start > out_lo) { | |
97 | printf ("no space for inbound mapping of memory\n"); | |
98 | return 0; | |
99 | } | |
b9a1fa97 | 100 | |
ad19e7a5 KG |
101 | /* limit size */ |
102 | if ((bus_start + sz) > out_lo) { | |
103 | sz = out_lo - bus_start; | |
104 | debug ("limiting size to %llx\n", sz); | |
105 | } | |
b9a1fa97 KG |
106 | |
107 | pci_sz = 1ull << __ilog2_u64(sz); | |
ad19e7a5 KG |
108 | /* |
109 | * we can overlap inbound/outbound windows on PCI-E since RX & TX | |
110 | * links a separate | |
111 | */ | |
112 | if ((pcie_cap == PCI_CAP_ID_EXP) && (pci_sz < sz)) { | |
113 | debug ("R0 bus_start: %llx phys_start: %llx size: %llx\n", | |
114 | (u64)bus_start, (u64)phys_start, (u64)sz); | |
115 | pci_set_region(r, bus_start, phys_start, sz, | |
116 | PCI_REGION_MEM | PCI_REGION_SYS_MEMORY | | |
117 | PCI_REGION_PREFETCH); | |
118 | ||
119 | /* if we aren't an exact power of two match, pci_sz is smaller | |
120 | * round it up to the next power of two. We report the actual | |
121 | * size to pci region tracking. | |
122 | */ | |
123 | if (pci_sz != sz) | |
124 | sz = 2ull << __ilog2_u64(sz); | |
125 | ||
126 | set_inbound_window(pi--, r++, sz); | |
127 | sz = 0; /* make sure we dont set the R2 window */ | |
128 | } else { | |
129 | debug ("R0 bus_start: %llx phys_start: %llx size: %llx\n", | |
b9a1fa97 | 130 | (u64)bus_start, (u64)phys_start, (u64)pci_sz); |
ad19e7a5 | 131 | pci_set_region(r, bus_start, phys_start, pci_sz, |
ff4e66e9 | 132 | PCI_REGION_MEM | PCI_REGION_SYS_MEMORY | |
b9a1fa97 | 133 | PCI_REGION_PREFETCH); |
ad19e7a5 KG |
134 | set_inbound_window(pi--, r++, pci_sz); |
135 | ||
b9a1fa97 KG |
136 | sz -= pci_sz; |
137 | bus_start += pci_sz; | |
138 | phys_start += pci_sz; | |
ad19e7a5 KG |
139 | |
140 | pci_sz = 1ull << __ilog2_u64(sz); | |
141 | if (sz) { | |
142 | debug ("R1 bus_start: %llx phys_start: %llx size: %llx\n", | |
143 | (u64)bus_start, (u64)phys_start, (u64)pci_sz); | |
144 | pci_set_region(r, bus_start, phys_start, pci_sz, | |
145 | PCI_REGION_MEM | PCI_REGION_SYS_MEMORY | | |
146 | PCI_REGION_PREFETCH); | |
147 | set_inbound_window(pi--, r++, pci_sz); | |
148 | sz -= pci_sz; | |
149 | bus_start += pci_sz; | |
150 | phys_start += pci_sz; | |
151 | } | |
b9a1fa97 KG |
152 | } |
153 | ||
154 | #if defined(CONFIG_PHYS_64BIT) && defined(CONFIG_SYS_PCI_64BIT) | |
cd425162 BB |
155 | /* |
156 | * On 64-bit capable systems, set up a mapping for all of DRAM | |
157 | * in high pci address space. | |
158 | */ | |
b9a1fa97 KG |
159 | pci_sz = 1ull << __ilog2_u64(gd->ram_size); |
160 | /* round up to the next largest power of two */ | |
161 | if (gd->ram_size > pci_sz) | |
cd425162 | 162 | pci_sz = 1ull << (__ilog2_u64(gd->ram_size) + 1); |
b9a1fa97 | 163 | debug ("R64 bus_start: %llx phys_start: %llx size: %llx\n", |
cd425162 | 164 | (u64)CONFIG_SYS_PCI64_MEMORY_BUS, |
b9a1fa97 KG |
165 | (u64)CONFIG_SYS_PCI_MEMORY_PHYS, |
166 | (u64)pci_sz); | |
ad19e7a5 | 167 | pci_set_region(r, |
cd425162 | 168 | CONFIG_SYS_PCI64_MEMORY_BUS, |
b9a1fa97 KG |
169 | CONFIG_SYS_PCI_MEMORY_PHYS, |
170 | pci_sz, | |
ff4e66e9 | 171 | PCI_REGION_MEM | PCI_REGION_SYS_MEMORY | |
b9a1fa97 | 172 | PCI_REGION_PREFETCH); |
ad19e7a5 | 173 | set_inbound_window(pi--, r++, pci_sz); |
b9a1fa97 KG |
174 | #else |
175 | pci_sz = 1ull << __ilog2_u64(sz); | |
176 | if (sz) { | |
177 | debug ("R2 bus_start: %llx phys_start: %llx size: %llx\n", | |
178 | (u64)bus_start, (u64)phys_start, (u64)pci_sz); | |
ad19e7a5 | 179 | pci_set_region(r, bus_start, phys_start, pci_sz, |
ff4e66e9 | 180 | PCI_REGION_MEM | PCI_REGION_SYS_MEMORY | |
b9a1fa97 KG |
181 | PCI_REGION_PREFETCH); |
182 | sz -= pci_sz; | |
183 | bus_start += pci_sz; | |
184 | phys_start += pci_sz; | |
ad19e7a5 | 185 | set_inbound_window(pi--, r++, pci_sz); |
b9a1fa97 KG |
186 | } |
187 | #endif | |
188 | ||
4c253fdb | 189 | #ifdef CONFIG_PHYS_64BIT |
b9a1fa97 KG |
190 | if (sz && (((u64)gd->ram_size) < (1ull << 32))) |
191 | printf("Was not able to map all of memory via " | |
192 | "inbound windows -- %lld remaining\n", sz); | |
4c253fdb | 193 | #endif |
b9a1fa97 | 194 | |
ad19e7a5 KG |
195 | hose->region_count = r - hose->regions; |
196 | ||
197 | return 1; | |
b9a1fa97 KG |
198 | } |
199 | ||
c8b28152 | 200 | #ifdef CONFIG_SRIO_PCIE_BOOT_MASTER |
b5f7c873 LG |
201 | static void fsl_pcie_boot_master(pit_t *pi) |
202 | { | |
203 | /* configure inbound window for slave's u-boot image */ | |
204 | debug("PCIEBOOT - MASTER: Inbound window for slave's image; " | |
205 | "Local = 0x%llx, Bus = 0x%llx, Size = 0x%x\n", | |
206 | (u64)CONFIG_SRIO_PCIE_BOOT_IMAGE_MEM_PHYS, | |
207 | (u64)CONFIG_SRIO_PCIE_BOOT_IMAGE_MEM_BUS1, | |
208 | CONFIG_SRIO_PCIE_BOOT_IMAGE_SIZE); | |
209 | struct pci_region r_inbound; | |
210 | u32 sz_inbound = __ilog2_u64(CONFIG_SRIO_PCIE_BOOT_IMAGE_SIZE) | |
211 | - 1; | |
212 | pci_set_region(&r_inbound, | |
213 | CONFIG_SRIO_PCIE_BOOT_IMAGE_MEM_BUS1, | |
214 | CONFIG_SRIO_PCIE_BOOT_IMAGE_MEM_PHYS, | |
215 | sz_inbound, | |
216 | PCI_REGION_MEM | PCI_REGION_SYS_MEMORY); | |
217 | ||
218 | set_inbound_window(pi--, &r_inbound, | |
219 | CONFIG_SRIO_PCIE_BOOT_IMAGE_SIZE); | |
220 | ||
221 | /* configure inbound window for slave's u-boot image */ | |
222 | debug("PCIEBOOT - MASTER: Inbound window for slave's image; " | |
223 | "Local = 0x%llx, Bus = 0x%llx, Size = 0x%x\n", | |
224 | (u64)CONFIG_SRIO_PCIE_BOOT_IMAGE_MEM_PHYS, | |
225 | (u64)CONFIG_SRIO_PCIE_BOOT_IMAGE_MEM_BUS2, | |
226 | CONFIG_SRIO_PCIE_BOOT_IMAGE_SIZE); | |
227 | pci_set_region(&r_inbound, | |
228 | CONFIG_SRIO_PCIE_BOOT_IMAGE_MEM_BUS2, | |
229 | CONFIG_SRIO_PCIE_BOOT_IMAGE_MEM_PHYS, | |
230 | sz_inbound, | |
231 | PCI_REGION_MEM | PCI_REGION_SYS_MEMORY); | |
232 | ||
233 | set_inbound_window(pi--, &r_inbound, | |
234 | CONFIG_SRIO_PCIE_BOOT_IMAGE_SIZE); | |
235 | ||
236 | /* configure inbound window for slave's ucode and ENV */ | |
237 | debug("PCIEBOOT - MASTER: Inbound window for slave's " | |
238 | "ucode and ENV; " | |
239 | "Local = 0x%llx, Bus = 0x%llx, Size = 0x%x\n", | |
240 | (u64)CONFIG_SRIO_PCIE_BOOT_UCODE_ENV_MEM_PHYS, | |
241 | (u64)CONFIG_SRIO_PCIE_BOOT_UCODE_ENV_MEM_BUS, | |
242 | CONFIG_SRIO_PCIE_BOOT_UCODE_ENV_SIZE); | |
243 | sz_inbound = __ilog2_u64(CONFIG_SRIO_PCIE_BOOT_UCODE_ENV_SIZE) | |
244 | - 1; | |
245 | pci_set_region(&r_inbound, | |
246 | CONFIG_SRIO_PCIE_BOOT_UCODE_ENV_MEM_BUS, | |
247 | CONFIG_SRIO_PCIE_BOOT_UCODE_ENV_MEM_PHYS, | |
248 | sz_inbound, | |
249 | PCI_REGION_MEM | PCI_REGION_SYS_MEMORY); | |
250 | ||
251 | set_inbound_window(pi--, &r_inbound, | |
252 | CONFIG_SRIO_PCIE_BOOT_UCODE_ENV_SIZE); | |
253 | } | |
254 | ||
255 | static void fsl_pcie_boot_master_release_slave(int port) | |
256 | { | |
257 | unsigned long release_addr; | |
258 | ||
259 | /* now release slave's core 0 */ | |
260 | switch (port) { | |
261 | case 1: | |
262 | release_addr = CONFIG_SYS_PCIE1_MEM_VIRT | |
263 | + CONFIG_SRIO_PCIE_BOOT_BRR_OFFSET; | |
264 | break; | |
a1e4318c | 265 | #ifdef CONFIG_SYS_PCIE2_MEM_VIRT |
b5f7c873 LG |
266 | case 2: |
267 | release_addr = CONFIG_SYS_PCIE2_MEM_VIRT | |
268 | + CONFIG_SRIO_PCIE_BOOT_BRR_OFFSET; | |
269 | break; | |
a1e4318c YS |
270 | #endif |
271 | #ifdef CONFIG_SYS_PCIE3_MEM_VIRT | |
b5f7c873 LG |
272 | case 3: |
273 | release_addr = CONFIG_SYS_PCIE3_MEM_VIRT | |
274 | + CONFIG_SRIO_PCIE_BOOT_BRR_OFFSET; | |
275 | break; | |
a1e4318c | 276 | #endif |
b5f7c873 LG |
277 | default: |
278 | release_addr = 0; | |
279 | break; | |
280 | } | |
281 | if (release_addr != 0) { | |
282 | out_be32((void *)release_addr, | |
283 | CONFIG_SRIO_PCIE_BOOT_RELEASE_MASK); | |
284 | debug("PCIEBOOT - MASTER: " | |
285 | "Release slave successfully! Now the slave should start up!\n"); | |
286 | } else { | |
287 | debug("PCIEBOOT - MASTER: " | |
288 | "Release slave failed!\n"); | |
289 | } | |
290 | } | |
291 | #endif | |
292 | ||
213ac73e | 293 | void fsl_pci_init(struct pci_controller *hose, struct fsl_pci_info *pci_info) |
63cec581 | 294 | { |
213ac73e PT |
295 | u32 cfg_addr = (u32)&((ccsr_fsl_pci_t *)pci_info->regs)->cfg_addr; |
296 | u32 cfg_data = (u32)&((ccsr_fsl_pci_t *)pci_info->regs)->cfg_data; | |
63cec581 ES |
297 | u16 temp16; |
298 | u32 temp32; | |
b6ccd2c9 | 299 | u32 block_rev; |
8295b944 | 300 | int enabled, r, inbound = 0; |
63cec581 | 301 | u16 ltssm; |
8295b944 | 302 | u8 temp8, pcie_cap; |
287df01e ZQ |
303 | int pcie_cap_pos; |
304 | int pci_dcr; | |
305 | int pci_dsr; | |
306 | int pci_lsr; | |
307 | ||
308 | #if defined(CONFIG_FSL_PCIE_DISABLE_ASPM) | |
309 | int pci_lcr; | |
310 | #endif | |
311 | ||
fb3143b3 | 312 | volatile ccsr_fsl_pci_t *pci = (ccsr_fsl_pci_t *)cfg_addr; |
cb151aa2 | 313 | struct pci_region *reg = hose->regions + hose->region_count; |
8295b944 | 314 | pci_dev_t dev = PCI_BDF(hose->first_busno, 0, 0); |
63cec581 ES |
315 | |
316 | /* Initialize ATMU registers based on hose regions and flags */ | |
d0ff51ba | 317 | volatile pot_t *po = &pci->pot[1]; /* skip 0 */ |
b6ccd2c9 | 318 | volatile pit_t *pi; |
ad19e7a5 KG |
319 | |
320 | u64 out_hi = 0, out_lo = -1ULL; | |
321 | u32 pcicsrbar, pcicsrbar_sz; | |
63cec581 | 322 | |
fb3143b3 KG |
323 | pci_setup_indirect(hose, cfg_addr, cfg_data); |
324 | ||
b6ccd2c9 PK |
325 | block_rev = in_be32(&pci->block_rev1); |
326 | if (PEX_IP_BLK_REV_2_2 <= block_rev) { | |
327 | pi = &pci->pit[2]; /* 0xDC0 */ | |
328 | } else { | |
329 | pi = &pci->pit[3]; /* 0xDE0 */ | |
330 | } | |
331 | ||
ad19e7a5 KG |
332 | /* Handle setup of outbound windows first */ |
333 | for (r = 0; r < hose->region_count; r++) { | |
334 | unsigned long flags = hose->regions[r].flags; | |
335 | u32 sz = (__ilog2_u64((u64)hose->regions[r].size) - 1); | |
cb151aa2 | 336 | |
ad19e7a5 KG |
337 | flags &= PCI_REGION_SYS_MEMORY|PCI_REGION_TYPE; |
338 | if (flags != PCI_REGION_SYS_MEMORY) { | |
339 | u64 start = hose->regions[r].bus_start; | |
340 | u64 end = start + hose->regions[r].size; | |
cb151aa2 | 341 | |
ad19e7a5 KG |
342 | out_be32(&po->powbar, hose->regions[r].phys_start >> 12); |
343 | out_be32(&po->potar, start >> 12); | |
612ea010 | 344 | #ifdef CONFIG_SYS_PCI_64BIT |
ad19e7a5 | 345 | out_be32(&po->potear, start >> 44); |
612ea010 | 346 | #else |
ad19e7a5 | 347 | out_be32(&po->potear, 0); |
612ea010 | 348 | #endif |
ad19e7a5 KG |
349 | if (hose->regions[r].flags & PCI_REGION_IO) { |
350 | out_be32(&po->powar, POWAR_EN | sz | | |
351 | POWAR_IO_READ | POWAR_IO_WRITE); | |
352 | } else { | |
353 | out_be32(&po->powar, POWAR_EN | sz | | |
354 | POWAR_MEM_READ | POWAR_MEM_WRITE); | |
355 | out_lo = min(start, out_lo); | |
356 | out_hi = max(end, out_hi); | |
357 | } | |
63cec581 ES |
358 | po++; |
359 | } | |
360 | } | |
ad19e7a5 KG |
361 | debug("Outbound memory range: %llx:%llx\n", out_lo, out_hi); |
362 | ||
363 | /* setup PCSRBAR/PEXCSRBAR */ | |
364 | pci_hose_write_config_dword(hose, dev, PCI_BASE_ADDRESS_0, 0xffffffff); | |
365 | pci_hose_read_config_dword (hose, dev, PCI_BASE_ADDRESS_0, &pcicsrbar_sz); | |
366 | pcicsrbar_sz = ~pcicsrbar_sz + 1; | |
367 | ||
368 | if (out_hi < (0x100000000ull - pcicsrbar_sz) || | |
369 | (out_lo > 0x100000000ull)) | |
370 | pcicsrbar = 0x100000000ull - pcicsrbar_sz; | |
371 | else | |
372 | pcicsrbar = (out_lo - pcicsrbar_sz) & -pcicsrbar_sz; | |
373 | pci_hose_write_config_dword(hose, dev, PCI_BASE_ADDRESS_0, pcicsrbar); | |
374 | ||
375 | out_lo = min(out_lo, (u64)pcicsrbar); | |
376 | ||
377 | debug("PCICSRBAR @ 0x%x\n", pcicsrbar); | |
378 | ||
379 | pci_set_region(reg++, pcicsrbar, CONFIG_SYS_CCSRBAR_PHYS, | |
380 | pcicsrbar_sz, PCI_REGION_SYS_MEMORY); | |
381 | hose->region_count++; | |
63cec581 | 382 | |
8295b944 | 383 | /* see if we are a PCIe or PCI controller */ |
287df01e ZQ |
384 | pcie_cap_pos = pci_hose_find_capability(hose, dev, PCI_CAP_ID_EXP); |
385 | pci_dcr = pcie_cap_pos + 0x08; | |
386 | pci_dsr = pcie_cap_pos + 0x0a; | |
387 | pci_lsr = pcie_cap_pos + 0x12; | |
388 | ||
389 | pci_hose_read_config_byte(hose, dev, pcie_cap_pos, &pcie_cap); | |
8295b944 | 390 | |
c8b28152 | 391 | #ifdef CONFIG_SRIO_PCIE_BOOT_MASTER |
b5f7c873 | 392 | /* boot from PCIE --master */ |
00caae6d | 393 | char *s = env_get("bootmaster"); |
b5f7c873 LG |
394 | char pcie[6]; |
395 | sprintf(pcie, "PCIE%d", pci_info->pci_num); | |
396 | ||
397 | if (s && (strcmp(s, pcie) == 0)) { | |
398 | debug("PCIEBOOT - MASTER: Master port [ %d ] for pcie boot.\n", | |
399 | pci_info->pci_num); | |
400 | fsl_pcie_boot_master((pit_t *)pi); | |
401 | } else { | |
402 | /* inbound */ | |
403 | inbound = fsl_pci_setup_inbound_windows(hose, | |
404 | out_lo, pcie_cap, pi); | |
405 | } | |
406 | #else | |
ad19e7a5 KG |
407 | /* inbound */ |
408 | inbound = fsl_pci_setup_inbound_windows(hose, out_lo, pcie_cap, pi); | |
b5f7c873 | 409 | #endif |
ad19e7a5 KG |
410 | |
411 | for (r = 0; r < hose->region_count; r++) | |
d015df8f | 412 | debug("PCI reg:%d %016llx:%016llx %016llx %08lx\n", r, |
ad19e7a5 | 413 | (u64)hose->regions[r].phys_start, |
d015df8f MV |
414 | (u64)hose->regions[r].bus_start, |
415 | (u64)hose->regions[r].size, | |
ad19e7a5 KG |
416 | hose->regions[r].flags); |
417 | ||
63cec581 ES |
418 | pci_register_hose(hose); |
419 | pciauto_config_init(hose); /* grab pci_{mem,prefetch,io} */ | |
420 | hose->current_busno = hose->first_busno; | |
421 | ||
ad19e7a5 | 422 | out_be32(&pci->pedr, 0xffffffff); /* Clear any errors */ |
16263087 | 423 | out_be32(&pci->peer, ~0x20140); /* Enable All Error Interrupts except |
2e4d94f1 ES |
424 | * - Master abort (pci) |
425 | * - Master PERR (pci) | |
426 | * - ICCA (PCIe) | |
427 | */ | |
287df01e | 428 | pci_hose_read_config_dword(hose, dev, pci_dcr, &temp32); |
63cec581 | 429 | temp32 |= 0xf000e; /* set URR, FER, NFER (but not CER) */ |
287df01e | 430 | pci_hose_write_config_dword(hose, dev, pci_dcr, temp32); |
63cec581 | 431 | |
b03a466d | 432 | #if defined(CONFIG_FSL_PCIE_DISABLE_ASPM) |
287df01e | 433 | pci_lcr = pcie_cap_pos + 0x10; |
b03a466d | 434 | temp32 = 0; |
287df01e | 435 | pci_hose_read_config_dword(hose, dev, pci_lcr, &temp32); |
b03a466d | 436 | temp32 &= ~0x03; /* Disable ASPM */ |
287df01e | 437 | pci_hose_write_config_dword(hose, dev, pci_lcr, temp32); |
b03a466d PK |
438 | udelay(1); |
439 | #endif | |
8295b944 | 440 | if (pcie_cap == PCI_CAP_ID_EXP) { |
7b4e5844 ZRR |
441 | if (block_rev >= PEX_IP_BLK_REV_3_0) { |
442 | #define PEX_CSR0_LTSSM_MASK 0xFC | |
443 | #define PEX_CSR0_LTSSM_SHIFT 2 | |
444 | ltssm = (in_be32(&pci->pex_csr0) | |
445 | & PEX_CSR0_LTSSM_MASK) >> PEX_CSR0_LTSSM_SHIFT; | |
446 | enabled = (ltssm == 0x11) ? 1 : 0; | |
5066e628 ZQ |
447 | #ifdef CONFIG_FSL_PCIE_RESET |
448 | int i; | |
449 | /* assert PCIe reset */ | |
450 | setbits_be32(&pci->pdb_stat, 0x08000000); | |
451 | (void) in_be32(&pci->pdb_stat); | |
452 | udelay(1000); | |
453 | /* clear PCIe reset */ | |
454 | clrbits_be32(&pci->pdb_stat, 0x08000000); | |
455 | asm("sync;isync"); | |
456 | for (i = 0; i < 100 && ltssm < PCI_LTSSM_L0; i++) { | |
457 | pci_hose_read_config_word(hose, dev, PCI_LTSSM, | |
458 | <ssm); | |
459 | udelay(1000); | |
460 | } | |
461 | #endif | |
7b4e5844 ZRR |
462 | } else { |
463 | /* pci_hose_read_config_word(hose, dev, PCI_LTSSM, <ssm); */ | |
464 | /* enabled = ltssm >= PCI_LTSSM_L0; */ | |
63cec581 ES |
465 | pci_hose_read_config_word(hose, dev, PCI_LTSSM, <ssm); |
466 | enabled = ltssm >= PCI_LTSSM_L0; | |
467 | ||
8ff3de61 KG |
468 | #ifdef CONFIG_FSL_PCIE_RESET |
469 | if (ltssm == 1) { | |
470 | int i; | |
ad19e7a5 KG |
471 | debug("....PCIe link error. " "LTSSM=0x%02x.", ltssm); |
472 | /* assert PCIe reset */ | |
473 | setbits_be32(&pci->pdb_stat, 0x08000000); | |
474 | (void) in_be32(&pci->pdb_stat); | |
8ff3de61 | 475 | udelay(100); |
d015df8f | 476 | debug(" Asserting PCIe reset @%p = %x\n", |
ad19e7a5 KG |
477 | &pci->pdb_stat, in_be32(&pci->pdb_stat)); |
478 | /* clear PCIe reset */ | |
479 | clrbits_be32(&pci->pdb_stat, 0x08000000); | |
8ff3de61 KG |
480 | asm("sync;isync"); |
481 | for (i=0; i<100 && ltssm < PCI_LTSSM_L0; i++) { | |
482 | pci_hose_read_config_word(hose, dev, PCI_LTSSM, | |
483 | <ssm); | |
484 | udelay(1000); | |
485 | debug("....PCIe link error. " | |
486 | "LTSSM=0x%02x.\n", ltssm); | |
487 | } | |
488 | enabled = ltssm >= PCI_LTSSM_L0; | |
ad19e7a5 KG |
489 | |
490 | /* we need to re-write the bar0 since a reset will | |
491 | * clear it | |
492 | */ | |
493 | pci_hose_write_config_dword(hose, dev, | |
494 | PCI_BASE_ADDRESS_0, pcicsrbar); | |
8ff3de61 KG |
495 | } |
496 | #endif | |
7b4e5844 | 497 | } |
8ff3de61 | 498 | |
c0a4e6b8 YC |
499 | #ifdef CONFIG_SYS_P4080_ERRATUM_PCIE_A003 |
500 | if (enabled == 0) { | |
501 | serdes_corenet_t *srds_regs = (void *)CONFIG_SYS_FSL_CORENET_SERDES_ADDR; | |
502 | temp32 = in_be32(&srds_regs->srdspccr0); | |
503 | ||
504 | if ((temp32 >> 28) == 3) { | |
505 | int i; | |
506 | ||
507 | out_be32(&srds_regs->srdspccr0, 2 << 28); | |
508 | setbits_be32(&pci->pdb_stat, 0x08000000); | |
509 | in_be32(&pci->pdb_stat); | |
510 | udelay(100); | |
511 | clrbits_be32(&pci->pdb_stat, 0x08000000); | |
512 | asm("sync;isync"); | |
513 | for (i=0; i < 100 && ltssm < PCI_LTSSM_L0; i++) { | |
514 | pci_hose_read_config_word(hose, dev, PCI_LTSSM, <ssm); | |
515 | udelay(1000); | |
516 | } | |
517 | enabled = ltssm >= PCI_LTSSM_L0; | |
518 | } | |
519 | } | |
520 | #endif | |
63cec581 | 521 | if (!enabled) { |
32514d25 ZRR |
522 | /* Let the user know there's no PCIe link for root |
523 | * complex. for endpoint, the link may not setup, so | |
524 | * print undetermined. | |
525 | */ | |
526 | if (fsl_is_pci_agent(hose)) | |
527 | printf("undetermined, regs @ 0x%lx\n", pci_info->regs); | |
528 | else | |
529 | printf("no link, regs @ 0x%lx\n", pci_info->regs); | |
63cec581 ES |
530 | hose->last_busno = hose->first_busno; |
531 | return; | |
532 | } | |
533 | ||
ad19e7a5 KG |
534 | out_be32(&pci->pme_msg_det, 0xffffffff); |
535 | out_be32(&pci->pme_msg_int_en, 0xffffffff); | |
213ac73e PT |
536 | |
537 | /* Print the negotiated PCIe link width */ | |
287df01e | 538 | pci_hose_read_config_word(hose, dev, pci_lsr, &temp16); |
aceea941 PK |
539 | printf("x%d gen%d, regs @ 0x%lx\n", (temp16 & 0x3f0) >> 4, |
540 | (temp16 & 0xf), pci_info->regs); | |
213ac73e | 541 | |
63cec581 ES |
542 | hose->current_busno++; /* Start scan with secondary */ |
543 | pciauto_prescan_setup_bridge(hose, dev, hose->current_busno); | |
63cec581 ES |
544 | } |
545 | ||
09bfd962 TB |
546 | #ifdef CONFIG_SYS_FSL_ERRATUM_A007815 |
547 | /* The Read-Only Write Enable bit defaults to 1 instead of 0. | |
548 | * Set to 0 to protect the read-only registers. | |
549 | */ | |
550 | clrbits_be32(&pci->dbi_ro_wr_en, 0x01); | |
551 | #endif | |
552 | ||
16e23c3f ES |
553 | /* Use generic setup_device to initialize standard pci regs, |
554 | * but do not allocate any windows since any BAR found (such | |
555 | * as PCSRBAR) is not in this cpu's memory space. | |
556 | */ | |
16e23c3f | 557 | pciauto_setup_device(hose, dev, 0, hose->pci_mem, |
63cec581 | 558 | hose->pci_prefetch, hose->pci_io); |
16e23c3f | 559 | |
cb8250fe ES |
560 | if (inbound) { |
561 | pci_hose_read_config_word(hose, dev, PCI_COMMAND, &temp16); | |
562 | pci_hose_write_config_word(hose, dev, PCI_COMMAND, | |
563 | temp16 | PCI_COMMAND_MEMORY); | |
564 | } | |
565 | ||
2e4d94f1 | 566 | #ifndef CONFIG_PCI_NOSCAN |
505f3e6f | 567 | if (!fsl_is_pci_agent(hose)) { |
37d03fce | 568 | debug(" Scanning PCI bus %02x\n", |
6df0efd5 ES |
569 | hose->current_busno); |
570 | hose->last_busno = pci_hose_scan_bus(hose, hose->current_busno); | |
571 | } else { | |
8ca78f2c | 572 | debug(" Not scanning PCI bus %02x. PI=%x\n", |
6df0efd5 ES |
573 | hose->current_busno, temp8); |
574 | hose->last_busno = hose->current_busno; | |
575 | } | |
63cec581 | 576 | |
8295b944 KG |
577 | /* if we are PCIe - update limit regs and subordinate busno |
578 | * for the virtual P2P bridge | |
579 | */ | |
580 | if (pcie_cap == PCI_CAP_ID_EXP) { | |
63cec581 ES |
581 | pciauto_postscan_setup_bridge(hose, dev, hose->last_busno); |
582 | } | |
2e4d94f1 ES |
583 | #else |
584 | hose->last_busno = hose->current_busno; | |
585 | #endif | |
63cec581 ES |
586 | |
587 | /* Clear all error indications */ | |
8295b944 | 588 | if (pcie_cap == PCI_CAP_ID_EXP) |
ad19e7a5 KG |
589 | out_be32(&pci->pme_msg_det, 0xffffffff); |
590 | out_be32(&pci->pedr, 0xffffffff); | |
63cec581 | 591 | |
287df01e | 592 | pci_hose_read_config_word(hose, dev, pci_dsr, &temp16); |
63cec581 | 593 | if (temp16) { |
287df01e | 594 | pci_hose_write_config_word(hose, dev, pci_dsr, 0xffff); |
63cec581 ES |
595 | } |
596 | ||
597 | pci_hose_read_config_word (hose, dev, PCI_SEC_STATUS, &temp16); | |
598 | if (temp16) { | |
63cec581 ES |
599 | pci_hose_write_config_word(hose, dev, PCI_SEC_STATUS, 0xffff); |
600 | } | |
601 | } | |
a2aab460 | 602 | |
715d8f76 ES |
603 | int fsl_is_pci_agent(struct pci_controller *hose) |
604 | { | |
287df01e | 605 | int pcie_cap_pos; |
505f3e6f | 606 | u8 pcie_cap; |
715d8f76 ES |
607 | pci_dev_t dev = PCI_BDF(hose->first_busno, 0, 0); |
608 | ||
287df01e ZQ |
609 | pcie_cap_pos = pci_hose_find_capability(hose, dev, PCI_CAP_ID_EXP); |
610 | pci_hose_read_config_byte(hose, dev, pcie_cap_pos, &pcie_cap); | |
505f3e6f ML |
611 | if (pcie_cap == PCI_CAP_ID_EXP) { |
612 | u8 header_type; | |
613 | ||
614 | pci_hose_read_config_byte(hose, dev, PCI_HEADER_TYPE, | |
615 | &header_type); | |
616 | return (header_type & 0x7f) == PCI_HEADER_TYPE_NORMAL; | |
617 | } else { | |
618 | u8 prog_if; | |
715d8f76 | 619 | |
505f3e6f | 620 | pci_hose_read_config_byte(hose, dev, PCI_CLASS_PROG, &prog_if); |
7b4e5844 ZRR |
621 | /* Programming Interface (PCI_CLASS_PROG) |
622 | * 0 == pci host or pcie root-complex, | |
623 | * 1 == pci agent or pcie end-point | |
624 | */ | |
505f3e6f ML |
625 | return (prog_if == FSL_PROG_IF_AGENT); |
626 | } | |
715d8f76 ES |
627 | } |
628 | ||
0d3d68b2 | 629 | int fsl_pci_init_port(struct fsl_pci_info *pci_info, |
01471d53 | 630 | struct pci_controller *hose, int busno) |
0d3d68b2 PA |
631 | { |
632 | volatile ccsr_fsl_pci_t *pci; | |
633 | struct pci_region *r; | |
a72dbae2 | 634 | pci_dev_t dev = PCI_BDF(busno,0,0); |
287df01e | 635 | int pcie_cap_pos; |
a72dbae2 | 636 | u8 pcie_cap; |
0d3d68b2 PA |
637 | |
638 | pci = (ccsr_fsl_pci_t *) pci_info->regs; | |
639 | ||
640 | /* on non-PCIe controllers we don't have pme_msg_det so this code | |
641 | * should do nothing since the read will return 0 | |
642 | */ | |
643 | if (in_be32(&pci->pme_msg_det)) { | |
644 | out_be32(&pci->pme_msg_det, 0xffffffff); | |
645 | debug (" with errors. Clearing. Now 0x%08x", | |
646 | pci->pme_msg_det); | |
647 | } | |
648 | ||
649 | r = hose->regions + hose->region_count; | |
650 | ||
651 | /* outbound memory */ | |
652 | pci_set_region(r++, | |
653 | pci_info->mem_bus, | |
654 | pci_info->mem_phys, | |
655 | pci_info->mem_size, | |
656 | PCI_REGION_MEM); | |
657 | ||
658 | /* outbound io */ | |
659 | pci_set_region(r++, | |
660 | pci_info->io_bus, | |
661 | pci_info->io_phys, | |
662 | pci_info->io_size, | |
663 | PCI_REGION_IO); | |
664 | ||
665 | hose->region_count = r - hose->regions; | |
666 | hose->first_busno = busno; | |
667 | ||
213ac73e | 668 | fsl_pci_init(hose, pci_info); |
0d3d68b2 | 669 | |
715d8f76 ES |
670 | if (fsl_is_pci_agent(hose)) { |
671 | fsl_pci_config_unlock(hose); | |
672 | hose->last_busno = hose->first_busno; | |
c8b28152 | 673 | #ifdef CONFIG_SRIO_PCIE_BOOT_MASTER |
b5f7c873 LG |
674 | } else { |
675 | /* boot from PCIE --master releases slave's core 0 */ | |
00caae6d | 676 | char *s = env_get("bootmaster"); |
b5f7c873 LG |
677 | char pcie[6]; |
678 | sprintf(pcie, "PCIE%d", pci_info->pci_num); | |
679 | ||
680 | if (s && (strcmp(s, pcie) == 0)) | |
681 | fsl_pcie_boot_master_release_slave(pci_info->pci_num); | |
682 | #endif | |
715d8f76 ES |
683 | } |
684 | ||
287df01e ZQ |
685 | pcie_cap_pos = pci_hose_find_capability(hose, dev, PCI_CAP_ID_EXP); |
686 | pci_hose_read_config_byte(hose, dev, pcie_cap_pos, &pcie_cap); | |
8ca78f2c | 687 | printf("PCI%s%x: Bus %02x - %02x\n", pcie_cap == PCI_CAP_ID_EXP ? |
213ac73e | 688 | "e" : "", pci_info->pci_num, |
8ca78f2c | 689 | hose->first_busno, hose->last_busno); |
0d3d68b2 PA |
690 | return(hose->last_busno + 1); |
691 | } | |
692 | ||
7a897959 PT |
693 | /* Enable inbound PCI config cycles for agent/endpoint interface */ |
694 | void fsl_pci_config_unlock(struct pci_controller *hose) | |
695 | { | |
696 | pci_dev_t dev = PCI_BDF(hose->first_busno,0,0); | |
287df01e | 697 | int pcie_cap_pos; |
7a897959 PT |
698 | u8 pcie_cap; |
699 | u16 pbfr; | |
700 | ||
505f3e6f | 701 | if (!fsl_is_pci_agent(hose)) |
7a897959 PT |
702 | return; |
703 | ||
287df01e ZQ |
704 | pcie_cap_pos = pci_hose_find_capability(hose, dev, PCI_CAP_ID_EXP); |
705 | pci_hose_read_config_byte(hose, dev, pcie_cap_pos, &pcie_cap); | |
7a897959 | 706 | if (pcie_cap != 0x0) { |
1d0b59a9 ML |
707 | ccsr_fsl_pci_t *pci = (ccsr_fsl_pci_t *)hose->cfg_addr; |
708 | u32 block_rev = in_be32(&pci->block_rev1); | |
7a897959 | 709 | /* PCIe - set CFG_READY bit of Configuration Ready Register */ |
1d0b59a9 ML |
710 | if (block_rev >= PEX_IP_BLK_REV_3_0) |
711 | setbits_be32(&pci->config, FSL_PCIE_V3_CFG_RDY); | |
712 | else | |
713 | pci_hose_write_config_byte(hose, dev, | |
714 | FSL_PCIE_CFG_RDY, 0x1); | |
7a897959 PT |
715 | } else { |
716 | /* PCI - clear ACL bit of PBFR */ | |
717 | pci_hose_read_config_word(hose, dev, FSL_PCI_PBFR, &pbfr); | |
718 | pbfr &= ~0x20; | |
719 | pci_hose_write_config_word(hose, dev, FSL_PCI_PBFR, pbfr); | |
720 | } | |
721 | } | |
722 | ||
a4aafcc9 | 723 | #if defined(CONFIG_PCIE1) || defined(CONFIG_PCIE2) || \ |
d1a24f06 | 724 | defined(CONFIG_PCIE3) || defined(CONFIG_PCIE4) |
a4aafcc9 KG |
725 | int fsl_configure_pcie(struct fsl_pci_info *info, |
726 | struct pci_controller *hose, | |
727 | const char *connected, int busno) | |
728 | { | |
729 | int is_endpoint; | |
730 | ||
731 | set_next_law(info->mem_phys, law_size_bits(info->mem_size), info->law); | |
732 | set_next_law(info->io_phys, law_size_bits(info->io_size), info->law); | |
213ac73e | 733 | |
a4aafcc9 | 734 | is_endpoint = fsl_setup_hose(hose, info->regs); |
213ac73e PT |
735 | printf("PCIe%u: %s", info->pci_num, |
736 | is_endpoint ? "Endpoint" : "Root Complex"); | |
737 | if (connected) | |
738 | printf(" of %s", connected); | |
739 | puts(", "); | |
740 | ||
a4aafcc9 KG |
741 | return fsl_pci_init_port(info, hose, busno); |
742 | } | |
743 | ||
744 | #if defined(CONFIG_FSL_CORENET) | |
9e758758 YS |
745 | #ifdef CONFIG_SYS_FSL_QORIQ_CHASSIS2 |
746 | #define _DEVDISR_PCIE1 FSL_CORENET_DEVDISR3_PCIE1 | |
747 | #define _DEVDISR_PCIE2 FSL_CORENET_DEVDISR3_PCIE2 | |
748 | #define _DEVDISR_PCIE3 FSL_CORENET_DEVDISR3_PCIE3 | |
749 | #define _DEVDISR_PCIE4 FSL_CORENET_DEVDISR3_PCIE4 | |
750 | #else | |
a4aafcc9 KG |
751 | #define _DEVDISR_PCIE1 FSL_CORENET_DEVDISR_PCIE1 |
752 | #define _DEVDISR_PCIE2 FSL_CORENET_DEVDISR_PCIE2 | |
753 | #define _DEVDISR_PCIE3 FSL_CORENET_DEVDISR_PCIE3 | |
754 | #define _DEVDISR_PCIE4 FSL_CORENET_DEVDISR_PCIE4 | |
9e758758 | 755 | #endif |
a4aafcc9 KG |
756 | #define CONFIG_SYS_MPC8xxx_GUTS_ADDR CONFIG_SYS_MPC85xx_GUTS_ADDR |
757 | #elif defined(CONFIG_MPC85xx) | |
758 | #define _DEVDISR_PCIE1 MPC85xx_DEVDISR_PCIE | |
759 | #define _DEVDISR_PCIE2 MPC85xx_DEVDISR_PCIE2 | |
760 | #define _DEVDISR_PCIE3 MPC85xx_DEVDISR_PCIE3 | |
761 | #define _DEVDISR_PCIE4 0 | |
762 | #define CONFIG_SYS_MPC8xxx_GUTS_ADDR CONFIG_SYS_MPC85xx_GUTS_ADDR | |
763 | #elif defined(CONFIG_MPC86xx) | |
764 | #define _DEVDISR_PCIE1 MPC86xx_DEVDISR_PCIE1 | |
765 | #define _DEVDISR_PCIE2 MPC86xx_DEVDISR_PCIE2 | |
766 | #define _DEVDISR_PCIE3 0 | |
767 | #define _DEVDISR_PCIE4 0 | |
768 | #define CONFIG_SYS_MPC8xxx_GUTS_ADDR \ | |
769 | (&((immap_t *)CONFIG_SYS_IMMR)->im_gur) | |
770 | #else | |
771 | #error "No defines for DEVDISR_PCIE" | |
772 | #endif | |
773 | ||
774 | /* Implement a dummy function for those platforms w/o SERDES */ | |
775 | static const char *__board_serdes_name(enum srds_prtcl device) | |
776 | { | |
777 | switch (device) { | |
778 | #ifdef CONFIG_SYS_PCIE1_NAME | |
779 | case PCIE1: | |
780 | return CONFIG_SYS_PCIE1_NAME; | |
781 | #endif | |
782 | #ifdef CONFIG_SYS_PCIE2_NAME | |
783 | case PCIE2: | |
784 | return CONFIG_SYS_PCIE2_NAME; | |
785 | #endif | |
786 | #ifdef CONFIG_SYS_PCIE3_NAME | |
787 | case PCIE3: | |
788 | return CONFIG_SYS_PCIE3_NAME; | |
789 | #endif | |
790 | #ifdef CONFIG_SYS_PCIE4_NAME | |
791 | case PCIE4: | |
792 | return CONFIG_SYS_PCIE4_NAME; | |
793 | #endif | |
794 | default: | |
795 | return NULL; | |
796 | } | |
797 | ||
798 | return NULL; | |
799 | } | |
800 | ||
801 | __attribute__((weak, alias("__board_serdes_name"))) const char * | |
802 | board_serdes_name(enum srds_prtcl device); | |
803 | ||
804 | static u32 devdisr_mask[] = { | |
805 | _DEVDISR_PCIE1, | |
806 | _DEVDISR_PCIE2, | |
807 | _DEVDISR_PCIE3, | |
808 | _DEVDISR_PCIE4, | |
809 | }; | |
810 | ||
811 | int fsl_pcie_init_ctrl(int busno, u32 devdisr, enum srds_prtcl dev, | |
812 | struct fsl_pci_info *pci_info) | |
813 | { | |
814 | struct pci_controller *hose; | |
815 | int num = dev - PCIE1; | |
816 | ||
817 | hose = calloc(1, sizeof(struct pci_controller)); | |
818 | if (!hose) | |
819 | return busno; | |
820 | ||
821 | if (is_serdes_configured(dev) && !(devdisr & devdisr_mask[num])) { | |
822 | busno = fsl_configure_pcie(pci_info, hose, | |
823 | board_serdes_name(dev), busno); | |
824 | } else { | |
213ac73e | 825 | printf("PCIe%d: disabled\n", num + 1); |
a4aafcc9 KG |
826 | } |
827 | ||
828 | return busno; | |
829 | } | |
830 | ||
831 | int fsl_pcie_init_board(int busno) | |
832 | { | |
833 | struct fsl_pci_info pci_info; | |
834 | ccsr_gur_t *gur = (void *)CONFIG_SYS_MPC8xxx_GUTS_ADDR; | |
9e758758 YS |
835 | u32 devdisr; |
836 | u32 *addr; | |
837 | ||
838 | #ifdef CONFIG_SYS_FSL_QORIQ_CHASSIS2 | |
839 | addr = &gur->devdisr3; | |
840 | #else | |
841 | addr = &gur->devdisr; | |
842 | #endif | |
843 | devdisr = in_be32(addr); | |
a4aafcc9 KG |
844 | |
845 | #ifdef CONFIG_PCIE1 | |
846 | SET_STD_PCIE_INFO(pci_info, 1); | |
847 | busno = fsl_pcie_init_ctrl(busno, devdisr, PCIE1, &pci_info); | |
848 | #else | |
9e758758 | 849 | setbits_be32(addr, _DEVDISR_PCIE1); /* disable */ |
a4aafcc9 KG |
850 | #endif |
851 | ||
852 | #ifdef CONFIG_PCIE2 | |
853 | SET_STD_PCIE_INFO(pci_info, 2); | |
854 | busno = fsl_pcie_init_ctrl(busno, devdisr, PCIE2, &pci_info); | |
855 | #else | |
9e758758 | 856 | setbits_be32(addr, _DEVDISR_PCIE2); /* disable */ |
a4aafcc9 KG |
857 | #endif |
858 | ||
859 | #ifdef CONFIG_PCIE3 | |
860 | SET_STD_PCIE_INFO(pci_info, 3); | |
861 | busno = fsl_pcie_init_ctrl(busno, devdisr, PCIE3, &pci_info); | |
862 | #else | |
9e758758 | 863 | setbits_be32(addr, _DEVDISR_PCIE3); /* disable */ |
a4aafcc9 KG |
864 | #endif |
865 | ||
866 | #ifdef CONFIG_PCIE4 | |
867 | SET_STD_PCIE_INFO(pci_info, 4); | |
868 | busno = fsl_pcie_init_ctrl(busno, devdisr, PCIE4, &pci_info); | |
869 | #else | |
9e758758 | 870 | setbits_be32(addr, _DEVDISR_PCIE4); /* disable */ |
a4aafcc9 KG |
871 | #endif |
872 | ||
873 | return busno; | |
874 | } | |
875 | #else | |
876 | int fsl_pcie_init_ctrl(int busno, u32 devdisr, enum srds_prtcl dev, | |
877 | struct fsl_pci_info *pci_info) | |
878 | { | |
879 | return busno; | |
880 | } | |
881 | ||
882 | int fsl_pcie_init_board(int busno) | |
883 | { | |
884 | return busno; | |
885 | } | |
886 | #endif | |
887 | ||
a2aab460 KG |
888 | #ifdef CONFIG_OF_BOARD_SETUP |
889 | #include <libfdt.h> | |
890 | #include <fdt_support.h> | |
891 | ||
6525d51f | 892 | void ft_fsl_pci_setup(void *blob, const char *pci_compat, |
3a0e3c27 | 893 | unsigned long ctrl_addr) |
a2aab460 | 894 | { |
6525d51f | 895 | int off; |
5a85a309 | 896 | u32 bus_range[2]; |
6525d51f | 897 | phys_addr_t p_ctrl_addr = (phys_addr_t)ctrl_addr; |
3a0e3c27 KG |
898 | struct pci_controller *hose; |
899 | ||
900 | hose = find_hose_by_cfg_addr((void *)(ctrl_addr)); | |
6525d51f KG |
901 | |
902 | /* convert ctrl_addr to true physical address */ | |
903 | p_ctrl_addr = (phys_addr_t)ctrl_addr - CONFIG_SYS_CCSRBAR; | |
904 | p_ctrl_addr += CONFIG_SYS_CCSRBAR_PHYS; | |
905 | ||
906 | off = fdt_node_offset_by_compat_reg(blob, pci_compat, p_ctrl_addr); | |
a2aab460 | 907 | |
5a85a309 KG |
908 | if (off < 0) |
909 | return; | |
a2aab460 | 910 | |
5a85a309 KG |
911 | /* We assume a cfg_addr not being set means we didn't setup the controller */ |
912 | if ((hose == NULL) || (hose->cfg_addr == NULL)) { | |
6525d51f | 913 | fdt_del_node(blob, off); |
5a85a309 | 914 | } else { |
a2aab460 KG |
915 | bus_range[0] = 0; |
916 | bus_range[1] = hose->last_busno - hose->first_busno; | |
917 | fdt_setprop(blob, off, "bus-range", &bus_range[0], 2*4); | |
918 | fdt_pci_dma_ranges(blob, off, hose); | |
919 | } | |
920 | } | |
921 | #endif |