1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#if 0
25#define DEBUG
26#endif
27
28#include <common.h>
29#include <pci.h>
30#include <ppc4xx.h>
31#include <asm/processor.h>
32#include <asm-ppc/io.h>
33
34#if (defined(CONFIG_440SPE) || defined(CONFIG_405EX) || \
35 defined(CONFIG_460EX) || defined(CONFIG_460GT)) && \
36 defined(CONFIG_PCI) && !defined(CONFIG_PCI_DISABLE_PCIE)
37
38#include <asm/4xx_pcie.h>
39
40enum {
41 PTYPE_ENDPOINT = 0x0,
42 PTYPE_LEGACY_ENDPOINT = 0x1,
43 PTYPE_ROOT_PORT = 0x4,
44
45 LNKW_X1 = 0x1,
46 LNKW_X4 = 0x4,
47 LNKW_X8 = 0x8
48};
49
50static int validate_endpoint(struct pci_controller *hose)
51{
52 if (hose->cfg_data == (u8 *)CONFIG_SYS_PCIE0_CFGBASE)
53 return (is_end_point(0));
54 else if (hose->cfg_data == (u8 *)CONFIG_SYS_PCIE1_CFGBASE)
55 return (is_end_point(1));
56#if CONFIG_SYS_PCIE_NR_PORTS > 2
57 else if (hose->cfg_data == (u8 *)CONFIG_SYS_PCIE2_CFGBASE)
58 return (is_end_point(2));
59#endif
60
61 return 0;
62}
63
64static u8* pcie_get_base(struct pci_controller *hose, unsigned int devfn)
65{
66 u8 *base = (u8*)hose->cfg_data;
67
68
69 if (PCI_BUS(devfn) == 0) {
70 if (hose->cfg_data == (u8*)CONFIG_SYS_PCIE0_CFGBASE)
71 base = (u8*)CONFIG_SYS_PCIE0_XCFGBASE;
72 if (hose->cfg_data == (u8*)CONFIG_SYS_PCIE1_CFGBASE)
73 base = (u8*)CONFIG_SYS_PCIE1_XCFGBASE;
74#if CONFIG_SYS_PCIE_NR_PORTS > 2
75 if (hose->cfg_data == (u8*)CONFIG_SYS_PCIE2_CFGBASE)
76 base = (u8*)CONFIG_SYS_PCIE2_XCFGBASE;
77#endif
78 }
79
80 return base;
81}
82
83static void pcie_dmer_disable(void)
84{
85 mtdcr (DCRN_PEGPL_CFG(DCRN_PCIE0_BASE),
86 mfdcr (DCRN_PEGPL_CFG(DCRN_PCIE0_BASE)) | GPL_DMER_MASK_DISA);
87 mtdcr (DCRN_PEGPL_CFG(DCRN_PCIE1_BASE),
88 mfdcr (DCRN_PEGPL_CFG(DCRN_PCIE1_BASE)) | GPL_DMER_MASK_DISA);
89#if CONFIG_SYS_PCIE_NR_PORTS > 2
90 mtdcr (DCRN_PEGPL_CFG(DCRN_PCIE2_BASE),
91 mfdcr (DCRN_PEGPL_CFG(DCRN_PCIE2_BASE)) | GPL_DMER_MASK_DISA);
92#endif
93}
94
95static void pcie_dmer_enable(void)
96{
97 mtdcr (DCRN_PEGPL_CFG (DCRN_PCIE0_BASE),
98 mfdcr (DCRN_PEGPL_CFG(DCRN_PCIE0_BASE)) & ~GPL_DMER_MASK_DISA);
99 mtdcr (DCRN_PEGPL_CFG (DCRN_PCIE1_BASE),
100 mfdcr (DCRN_PEGPL_CFG(DCRN_PCIE1_BASE)) & ~GPL_DMER_MASK_DISA);
101#if CONFIG_SYS_PCIE_NR_PORTS > 2
102 mtdcr (DCRN_PEGPL_CFG (DCRN_PCIE2_BASE),
103 mfdcr (DCRN_PEGPL_CFG(DCRN_PCIE2_BASE)) & ~GPL_DMER_MASK_DISA);
104#endif
105}
106
107static int pcie_read_config(struct pci_controller *hose, unsigned int devfn,
108 int offset, int len, u32 *val) {
109
110 u8 *address;
111 *val = 0;
112
113 if (validate_endpoint(hose))
114 return 0;
115
116
117
118
119 devfn -= PCI_BDF(hose->first_busno, 0, 0);
120
121
122
123
124
125
126
127 if (PCI_BUS(devfn) >= 16)
128 return 0;
129
130
131
132
133
134 if ((!((PCI_FUNC(devfn) == 0) && (PCI_DEV(devfn) == 0))) &&
135 ((PCI_BUS(devfn) == 0) || (PCI_BUS(devfn) == 1)))
136 return 0;
137
138 address = pcie_get_base(hose, devfn);
139 offset += devfn << 4;
140
141
142
143
144
145
146 pcie_dmer_disable ();
147
148 debug("%s: cfg_data=%08x offset=%08x\n", __func__, hose->cfg_data, offset);
149 switch (len) {
150 case 1:
151 *val = in_8(hose->cfg_data + offset);
152 break;
153 case 2:
154 *val = in_le16((u16 *)(hose->cfg_data + offset));
155 break;
156 default:
157 *val = in_le32((u32*)(hose->cfg_data + offset));
158 break;
159 }
160
161 pcie_dmer_enable ();
162
163 return 0;
164}
165
166static int pcie_write_config(struct pci_controller *hose, unsigned int devfn,
167 int offset, int len, u32 val) {
168
169 u8 *address;
170
171 if (validate_endpoint(hose))
172 return 0;
173
174
175
176
177 devfn -= PCI_BDF(hose->first_busno, 0, 0);
178
179
180
181
182 if (PCI_BUS(devfn) >= 16)
183 return 0;
184
185 if ((!((PCI_FUNC(devfn) == 0) && (PCI_DEV(devfn) == 0))) &&
186 ((PCI_BUS(devfn) == 0) || (PCI_BUS(devfn) == 1)))
187 return 0;
188
189 address = pcie_get_base(hose, devfn);
190 offset += devfn << 4;
191
192
193
194
195 pcie_dmer_disable ();
196
197 switch (len) {
198 case 1:
199 out_8(hose->cfg_data + offset, val);
200 break;
201 case 2:
202 out_le16((u16 *)(hose->cfg_data + offset), val);
203 break;
204 default:
205 out_le32((u32 *)(hose->cfg_data + offset), val);
206 break;
207 }
208
209 pcie_dmer_enable ();
210
211 return 0;
212}
213
214int pcie_read_config_byte(struct pci_controller *hose,pci_dev_t dev,int offset,u8 *val)
215{
216 u32 v;
217 int rv;
218
219 rv = pcie_read_config(hose, dev, offset, 1, &v);
220 *val = (u8)v;
221 return rv;
222}
223
224int pcie_read_config_word(struct pci_controller *hose,pci_dev_t dev,int offset,u16 *val)
225{
226 u32 v;
227 int rv;
228
229 rv = pcie_read_config(hose, dev, offset, 2, &v);
230 *val = (u16)v;
231 return rv;
232}
233
234int pcie_read_config_dword(struct pci_controller *hose,pci_dev_t dev,int offset,u32 *val)
235{
236 u32 v;
237 int rv;
238
239 rv = pcie_read_config(hose, dev, offset, 3, &v);
240 *val = (u32)v;
241 return rv;
242}
243
244int pcie_write_config_byte(struct pci_controller *hose,pci_dev_t dev,int offset,u8 val)
245{
246 return pcie_write_config(hose,(u32)dev,offset,1,val);
247}
248
249int pcie_write_config_word(struct pci_controller *hose,pci_dev_t dev,int offset,u16 val)
250{
251 return pcie_write_config(hose,(u32)dev,offset,2,(u32 )val);
252}
253
254int pcie_write_config_dword(struct pci_controller *hose,pci_dev_t dev,int offset,u32 val)
255{
256 return pcie_write_config(hose,(u32)dev,offset,3,(u32 )val);
257}
258
259#if defined(CONFIG_440SPE)
260static void ppc4xx_setup_utl(u32 port) {
261
262 volatile void *utl_base = NULL;
263
264
265
266
267 switch (port) {
268 case 0:
269 mtdcr(DCRN_PEGPL_REGBAH(PCIE0), 0x0000000c);
270 mtdcr(DCRN_PEGPL_REGBAL(PCIE0), 0x20000000);
271 mtdcr(DCRN_PEGPL_REGMSK(PCIE0), 0x00007001);
272 mtdcr(DCRN_PEGPL_SPECIAL(PCIE0), 0x68782800);
273 break;
274
275 case 1:
276 mtdcr(DCRN_PEGPL_REGBAH(PCIE1), 0x0000000c);
277 mtdcr(DCRN_PEGPL_REGBAL(PCIE1), 0x20001000);
278 mtdcr(DCRN_PEGPL_REGMSK(PCIE1), 0x00007001);
279 mtdcr(DCRN_PEGPL_SPECIAL(PCIE1), 0x68782800);
280 break;
281
282 case 2:
283 mtdcr(DCRN_PEGPL_REGBAH(PCIE2), 0x0000000c);
284 mtdcr(DCRN_PEGPL_REGBAL(PCIE2), 0x20002000);
285 mtdcr(DCRN_PEGPL_REGMSK(PCIE2), 0x00007001);
286 mtdcr(DCRN_PEGPL_SPECIAL(PCIE2), 0x68782800);
287 break;
288 }
289 utl_base = (unsigned int *)(CONFIG_SYS_PCIE_BASE + 0x1000 * port);
290
291
292
293
294 out_be32(utl_base + PEUTL_OUTTR, 0x08000000);
295 out_be32(utl_base + PEUTL_INTR, 0x02000000);
296 out_be32(utl_base + PEUTL_OPDBSZ, 0x10000000);
297 out_be32(utl_base + PEUTL_PBBSZ, 0x53000000);
298 out_be32(utl_base + PEUTL_IPHBSZ, 0x08000000);
299 out_be32(utl_base + PEUTL_IPDBSZ, 0x10000000);
300 out_be32(utl_base + PEUTL_RCIRQEN, 0x00f00000);
301 out_be32(utl_base + PEUTL_PCTL, 0x80800066);
302}
303
304static int check_error(void)
305{
306 u32 valPE0, valPE1, valPE2;
307 int err = 0;
308
309
310 if (!(valPE0 = SDR_READ(PESDR0_PLLLCT1) & 0x01000000))
311 printf("PCIE: SDR0_PEGPLLLCT1 reset error 0x%x\n", valPE0);
312
313 valPE0 = SDR_READ(PESDR0_RCSSET);
314 valPE1 = SDR_READ(PESDR1_RCSSET);
315 valPE2 = SDR_READ(PESDR2_RCSSET);
316
317
318 if (!(valPE0 & 0x01000000) ||
319 !(valPE1 & 0x01000000) ||
320 !(valPE2 & 0x01000000)) {
321 printf("PCIE: SDR0_PExRCSSET rstgu error\n");
322 err = -1;
323 }
324
325
326 if (!(valPE0 & 0x00010000) ||
327 !(valPE1 & 0x00010000) ||
328 !(valPE2 & 0x00010000)) {
329 printf("PCIE: SDR0_PExRCSSET rstdl error\n");
330 err = -1;
331 }
332
333
334 if ((valPE0 & 0x00001000) ||
335 (valPE1 & 0x00001000) ||
336 (valPE2 & 0x00001000)) {
337 printf("PCIE: SDR0_PExRCSSET rstpyn error\n");
338 err = -1;
339 }
340
341
342 if ((valPE0 & 0x10000000) ||
343 (valPE1 & 0x10000000) ||
344 (valPE2 & 0x10000000)) {
345 printf("PCIE: SDR0_PExRCSSET hldplb error\n");
346 err = -1;
347 }
348
349
350 if ((valPE0 & 0x00100000) ||
351 (valPE1 & 0x00100000) ||
352 (valPE2 & 0x00100000)) {
353 printf("PCIE: SDR0_PExRCSSET rdy error\n");
354 err = -1;
355 }
356
357
358 if ((valPE0 & 0x00000100) ||
359 (valPE1 & 0x00000100) ||
360 (valPE2 & 0x00000100)) {
361 printf("PCIE: SDR0_PExRCSSET shutdown error\n");
362 err = -1;
363 }
364 return err;
365}
366
367
368
369
370int ppc4xx_init_pcie(void)
371{
372 int time_out = 20;
373
374
375 SDR_WRITE(PESDR0_PLLLCT1, SDR_READ(PESDR0_PLLLCT1) | 1 << 28);
376
377 if (check_error())
378 return -1;
379
380 if (!(SDR_READ(PESDR0_PLLLCT2) & 0x10000))
381 {
382 printf("PCIE: PESDR_PLLCT2 resistance calibration failed (0x%08x)\n",
383 SDR_READ(PESDR0_PLLLCT2));
384 return -1;
385 }
386
387 SDR_WRITE(PESDR0_PLLLCT1, SDR_READ(PESDR0_PLLLCT1) & ~(1 << 24));
388 udelay(3);
389
390 while (time_out) {
391 if (!(SDR_READ(PESDR0_PLLLCT3) & 0x10000000)) {
392 time_out--;
393 udelay(1);
394 } else
395 break;
396 }
397 if (!time_out) {
398 printf("PCIE: VCO output not locked\n");
399 return -1;
400 }
401 return 0;
402}
403#endif
404
405#if defined(CONFIG_460EX) || defined(CONFIG_460GT)
406static void ppc4xx_setup_utl(u32 port)
407{
408 volatile void *utl_base = NULL;
409
410
411
412
413 switch (port) {
414 case 0:
415 mtdcr(DCRN_PEGPL_REGBAH(PCIE0), U64_TO_U32_HIGH(CONFIG_SYS_PCIE0_UTLBASE));
416 mtdcr(DCRN_PEGPL_REGBAL(PCIE0), U64_TO_U32_LOW(CONFIG_SYS_PCIE0_UTLBASE));
417 mtdcr(DCRN_PEGPL_REGMSK(PCIE0), 0x00007001);
418 mtdcr(DCRN_PEGPL_SPECIAL(PCIE0), 0);
419 break;
420
421 case 1:
422 mtdcr(DCRN_PEGPL_REGBAH(PCIE1), U64_TO_U32_HIGH(CONFIG_SYS_PCIE0_UTLBASE));
423 mtdcr(DCRN_PEGPL_REGBAL(PCIE1), U64_TO_U32_LOW(CONFIG_SYS_PCIE0_UTLBASE)
424 + 0x1000);
425 mtdcr(DCRN_PEGPL_REGMSK(PCIE1), 0x00007001);
426 mtdcr(DCRN_PEGPL_SPECIAL(PCIE1), 0);
427 break;
428 }
429 utl_base = (unsigned int *)(CONFIG_SYS_PCIE_BASE + 0x1000 * port);
430
431
432
433
434 out_be32(utl_base + PEUTL_PBCTL, 0x0800000c);
435 out_be32(utl_base + PEUTL_OUTTR, 0x08000000);
436 out_be32(utl_base + PEUTL_INTR, 0x02000000);
437 out_be32(utl_base + PEUTL_OPDBSZ, 0x04000000);
438 out_be32(utl_base + PEUTL_PBBSZ, 0x00000000);
439 out_be32(utl_base + PEUTL_IPHBSZ, 0x02000000);
440 out_be32(utl_base + PEUTL_IPDBSZ, 0x04000000);
441 out_be32(utl_base + PEUTL_RCIRQEN, 0x00f00000);
442 out_be32(utl_base + PEUTL_PCTL, 0x80800066);
443}
444
445
446
447
448
449
450static int check_error(void)
451{
452 u32 valPE0, valPE1;
453 int err = 0;
454
455 valPE0 = SDR_READ(SDRN_PESDR_RCSSET(0));
456 valPE1 = SDR_READ(SDRN_PESDR_RCSSET(1));
457
458
459 if (!(valPE0 & PESDRx_RCSSET_RSTGU) || !(valPE1 & PESDRx_RCSSET_RSTGU)) {
460 printf("PCIE: SDR0_PExRCSSET rstgu error\n");
461 err = -1;
462 }
463
464
465 if (!(valPE0 & PESDRx_RCSSET_RSTDL) || !(valPE1 & PESDRx_RCSSET_RSTDL)) {
466 printf("PCIE: SDR0_PExRCSSET rstdl error\n");
467 err = -1;
468 }
469
470
471 if ((valPE0 & PESDRx_RCSSET_RSTPYN) || (valPE1 & PESDRx_RCSSET_RSTPYN)) {
472 printf("PCIE: SDR0_PExRCSSET rstpyn error\n");
473 err = -1;
474 }
475
476
477 if ((valPE0 & PESDRx_RCSSET_HLDPLB) || (valPE1 & PESDRx_RCSSET_HLDPLB)) {
478 printf("PCIE: SDR0_PExRCSSET hldplb error\n");
479 err = -1;
480 }
481
482
483 if ((valPE0 & PESDRx_RCSSET_RDY) || (valPE1 & PESDRx_RCSSET_RDY)) {
484 printf("PCIE: SDR0_PExRCSSET rdy error\n");
485 err = -1;
486 }
487
488 return err;
489}
490
491
492
493
494
495int ppc4xx_init_pcie(void)
496{
497 if (check_error())
498 return -1;
499
500 return 0;
501}
502#endif
503
504#if defined(CONFIG_405EX)
505static void ppc4xx_setup_utl(u32 port)
506{
507 u32 utl_base;
508
509
510
511
512 switch (port) {
513 case 0:
514 mtdcr(DCRN_PEGPL_REGBAH(PCIE0), 0x00000000);
515 mtdcr(DCRN_PEGPL_REGBAL(PCIE0), CONFIG_SYS_PCIE0_UTLBASE);
516 mtdcr(DCRN_PEGPL_REGMSK(PCIE0), 0x00007001);
517 mtdcr(DCRN_PEGPL_SPECIAL(PCIE0), 0);
518 break;
519
520 case 1:
521 mtdcr(DCRN_PEGPL_REGBAH(PCIE1), 0x00000000);
522 mtdcr(DCRN_PEGPL_REGBAL(PCIE1), CONFIG_SYS_PCIE1_UTLBASE);
523 mtdcr(DCRN_PEGPL_REGMSK(PCIE1), 0x00007001);
524 mtdcr(DCRN_PEGPL_SPECIAL(PCIE1), 0);
525
526 break;
527 }
528 utl_base = (port==0) ? CONFIG_SYS_PCIE0_UTLBASE : CONFIG_SYS_PCIE1_UTLBASE;
529
530
531
532
533 out_be32((u32 *)(utl_base + PEUTL_OUTTR), 0x02000000);
534 out_be32((u32 *)(utl_base + PEUTL_INTR), 0x02000000);
535 out_be32((u32 *)(utl_base + PEUTL_OPDBSZ), 0x04000000);
536 out_be32((u32 *)(utl_base + PEUTL_PBBSZ), 0x21000000);
537 out_be32((u32 *)(utl_base + PEUTL_IPHBSZ), 0x02000000);
538 out_be32((u32 *)(utl_base + PEUTL_IPDBSZ), 0x04000000);
539 out_be32((u32 *)(utl_base + PEUTL_RCIRQEN), 0x00f00000);
540 out_be32((u32 *)(utl_base + PEUTL_PCTL), 0x80800066);
541
542 out_be32((u32 *)(utl_base + PEUTL_PBCTL), 0x0800000c);
543 out_be32((u32 *)(utl_base + PEUTL_RCSTA),
544 in_be32((u32 *)(utl_base + PEUTL_RCSTA)) | 0x000040000);
545}
546
547int ppc4xx_init_pcie(void)
548{
549
550
551
552 return 0;
553}
554#endif
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575#if defined(CONFIG_440SPE)
576int __ppc4xx_init_pcie_port_hw(int port, int rootport)
577{
578 u32 val = 1 << 24;
579 u32 utlset1;
580
581 if (rootport) {
582 val = PTYPE_ROOT_PORT << 20;
583 utlset1 = 0x21222222;
584 } else {
585 val = PTYPE_LEGACY_ENDPOINT << 20;
586 utlset1 = 0x20222222;
587 }
588
589 if (port == 0)
590 val |= LNKW_X8 << 12;
591 else
592 val |= LNKW_X4 << 12;
593
594 SDR_WRITE(SDRN_PESDR_DLPSET(port), val);
595 SDR_WRITE(SDRN_PESDR_UTLSET1(port), utlset1);
596 if (!ppc440spe_revB())
597 SDR_WRITE(SDRN_PESDR_UTLSET2(port), 0x11000000);
598 SDR_WRITE(SDRN_PESDR_HSSL0SET1(port), 0x35000000);
599 SDR_WRITE(SDRN_PESDR_HSSL1SET1(port), 0x35000000);
600 SDR_WRITE(SDRN_PESDR_HSSL2SET1(port), 0x35000000);
601 SDR_WRITE(SDRN_PESDR_HSSL3SET1(port), 0x35000000);
602 if (port == 0) {
603 SDR_WRITE(PESDR0_HSSL4SET1, 0x35000000);
604 SDR_WRITE(PESDR0_HSSL5SET1, 0x35000000);
605 SDR_WRITE(PESDR0_HSSL6SET1, 0x35000000);
606 SDR_WRITE(PESDR0_HSSL7SET1, 0x35000000);
607 }
608 SDR_WRITE(SDRN_PESDR_RCSSET(port), (SDR_READ(SDRN_PESDR_RCSSET(port)) &
609 ~(1 << 24 | 1 << 16)) | 1 << 12);
610
611 return 0;
612}
613#endif
614
615#if defined(CONFIG_460EX) || defined(CONFIG_460GT)
616int __ppc4xx_init_pcie_port_hw(int port, int rootport)
617{
618 u32 val;
619 u32 utlset1;
620
621 if (rootport)
622 val = PTYPE_ROOT_PORT << 20;
623 else
624 val = PTYPE_LEGACY_ENDPOINT << 20;
625
626 if (port == 0) {
627 val |= LNKW_X1 << 12;
628 utlset1 = 0x20000000;
629 } else {
630 val |= LNKW_X4 << 12;
631 utlset1 = 0x20101101;
632 }
633
634 SDR_WRITE(SDRN_PESDR_DLPSET(port), val);
635 SDR_WRITE(SDRN_PESDR_UTLSET1(port), utlset1);
636 SDR_WRITE(SDRN_PESDR_UTLSET2(port), 0x01210000);
637
638 switch (port) {
639 case 0:
640 SDR_WRITE(PESDR0_L0CDRCTL, 0x00003230);
641 SDR_WRITE(PESDR0_L0DRV, 0x00000130);
642 SDR_WRITE(PESDR0_L0CLK, 0x00000006);
643
644 SDR_WRITE(PESDR0_PHY_CTL_RST,0x10000000);
645 break;
646
647 case 1:
648 SDR_WRITE(PESDR1_L0CDRCTL, 0x00003230);
649 SDR_WRITE(PESDR1_L1CDRCTL, 0x00003230);
650 SDR_WRITE(PESDR1_L2CDRCTL, 0x00003230);
651 SDR_WRITE(PESDR1_L3CDRCTL, 0x00003230);
652 SDR_WRITE(PESDR1_L0DRV, 0x00000130);
653 SDR_WRITE(PESDR1_L1DRV, 0x00000130);
654 SDR_WRITE(PESDR1_L2DRV, 0x00000130);
655 SDR_WRITE(PESDR1_L3DRV, 0x00000130);
656 SDR_WRITE(PESDR1_L0CLK, 0x00000006);
657 SDR_WRITE(PESDR1_L1CLK, 0x00000006);
658 SDR_WRITE(PESDR1_L2CLK, 0x00000006);
659 SDR_WRITE(PESDR1_L3CLK, 0x00000006);
660
661 SDR_WRITE(PESDR1_PHY_CTL_RST,0x10000000);
662 break;
663 }
664
665 SDR_WRITE(SDRN_PESDR_RCSSET(port), SDR_READ(SDRN_PESDR_RCSSET(port)) |
666 (PESDRx_RCSSET_RSTGU | PESDRx_RCSSET_RSTPYN));
667
668
669 switch (port) {
670 case 0:
671 while (!(SDR_READ(PESDR0_RSTSTA) & 0x1))
672 udelay(10);
673 break;
674 case 1:
675 while (!(SDR_READ(PESDR1_RSTSTA) & 0x1))
676 udelay(10);
677 break;
678 }
679
680 SDR_WRITE(SDRN_PESDR_RCSSET(port),
681 (SDR_READ(SDRN_PESDR_RCSSET(port)) &
682 ~(PESDRx_RCSSET_RSTGU | PESDRx_RCSSET_RSTDL)) |
683 PESDRx_RCSSET_RSTPYN);
684
685 return 0;
686}
687#endif
688
689#if defined(CONFIG_405EX)
690int __ppc4xx_init_pcie_port_hw(int port, int rootport)
691{
692 u32 val;
693
694 if (rootport)
695 val = 0x00401000;
696 else
697 val = 0x00101000;
698
699 SDR_WRITE(SDRN_PESDR_DLPSET(port), val);
700 SDR_WRITE(SDRN_PESDR_UTLSET1(port), 0x00000000);
701 SDR_WRITE(SDRN_PESDR_UTLSET2(port), 0x01010000);
702 SDR_WRITE(SDRN_PESDR_PHYSET1(port), 0x720F0000);
703 SDR_WRITE(SDRN_PESDR_PHYSET2(port), 0x70600003);
704
705
706 SDR_WRITE(SDRN_PESDR_RCSSET(port), 0x01010000);
707 udelay(1000);
708
709
710 if (is_end_point(port))
711 SDR_WRITE(SDRN_PESDR_RCSSET(port), 0x01111000);
712 else
713 SDR_WRITE(SDRN_PESDR_RCSSET(port), 0x01101000);
714
715
716 while (!(SDR_READ(SDRN_PESDR_PHYSTA(port)) & 0x00001000))
717 ;
718
719
720 SDR_WRITE(SDRN_PESDR_RCSSET(port), 0x00101000);
721
722 if (port == 0)
723 mtdcr(DCRN_PEGPL_CFG(PCIE0), 0x10000000);
724 else
725 mtdcr(DCRN_PEGPL_CFG(PCIE1), 0x10000000);
726
727 return 0;
728}
729#endif
730
731int ppc4xx_init_pcie_port_hw(int port, int rootport)
732__attribute__((weak, alias("__ppc4xx_init_pcie_port_hw")));
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760static inline u64 ppc4xx_get_cfgaddr(int port)
761{
762#if defined(CONFIG_405EX)
763 if (port == 0)
764 return (u64)CONFIG_SYS_PCIE0_CFGBASE;
765 else
766 return (u64)CONFIG_SYS_PCIE1_CFGBASE;
767#endif
768#if defined(CONFIG_440SPE)
769 if (ppc440spe_revB()) {
770 switch (port) {
771 default:
772 case 0:
773 return 0x0000000d00000000ULL;
774 case 1:
775 return 0x0000000d20000000ULL;
776 case 2:
777 return 0x0000000d40000000ULL;
778 }
779 } else {
780 switch (port) {
781 default:
782 case 0:
783 return 0x0000000c40000000ULL;
784 case 1:
785 return 0x0000000c80000000ULL;
786 case 2:
787 return 0x0000000cc0000000ULL;
788 }
789 }
790#endif
791#if defined(CONFIG_460EX) || defined(CONFIG_460GT)
792 if (port == 0)
793 return 0x0000000d00000000ULL;
794 else
795 return 0x0000000d20000000ULL;
796#endif
797}
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833int ppc4xx_init_pcie_port(int port, int rootport)
834{
835 static int core_init;
836 volatile u32 val = 0;
837 int attempts;
838 u64 addr;
839 u32 low, high;
840
841 if (!core_init) {
842 if (ppc4xx_init_pcie())
843 return -1;
844 ++core_init;
845 }
846
847
848
849
850 ppc4xx_init_pcie_port_hw(port, rootport);
851
852
853
854
855
856 mdelay(100);
857
858 val = SDR_READ(SDRN_PESDR_RCSSTS(port));
859 if (val & (1 << 20)) {
860 printf("PCIE%d: PGRST failed %08x\n", port, val);
861 return -1;
862 }
863
864
865
866
867 val = SDR_READ(SDRN_PESDR_LOOP(port));
868 if (!(val & 0x00001000)) {
869 printf("PCIE%d: link is not up.\n", port);
870 return -1;
871 }
872
873
874
875
876
877 if (!ppc440spe_revB())
878 ppc4xx_setup_utl(port);
879
880
881
882
883 addr = ppc4xx_get_cfgaddr(port);
884 low = U64_TO_U32_LOW(addr);
885 high = U64_TO_U32_HIGH(addr);
886
887 switch (port) {
888 case 0:
889 mtdcr(DCRN_PEGPL_CFGBAH(PCIE0), high);
890 mtdcr(DCRN_PEGPL_CFGBAL(PCIE0), low);
891 mtdcr(DCRN_PEGPL_CFGMSK(PCIE0), 0xe0000001);
892 break;
893 case 1:
894 mtdcr(DCRN_PEGPL_CFGBAH(PCIE1), high);
895 mtdcr(DCRN_PEGPL_CFGBAL(PCIE1), low);
896 mtdcr(DCRN_PEGPL_CFGMSK(PCIE1), 0xe0000001);
897 break;
898#if CONFIG_SYS_PCIE_NR_PORTS > 2
899 case 2:
900 mtdcr(DCRN_PEGPL_CFGBAH(PCIE2), high);
901 mtdcr(DCRN_PEGPL_CFGBAL(PCIE2), low);
902 mtdcr(DCRN_PEGPL_CFGMSK(PCIE2), 0xe0000001);
903 break;
904#endif
905 }
906
907
908
909
910 attempts = 10;
911 while(!(SDR_READ(SDRN_PESDR_RCSSTS(port)) & (1 << 16))) {
912 if (!(attempts--)) {
913 printf("PCIE%d: VC0 not active\n", port);
914 return -1;
915 }
916 mdelay(1000);
917 }
918 SDR_WRITE(SDRN_PESDR_RCSSET(port),
919 SDR_READ(SDRN_PESDR_RCSSET(port)) | 1 << 20);
920 mdelay(100);
921
922 return 0;
923}
924
925int ppc4xx_init_pcie_rootport(int port)
926{
927 return ppc4xx_init_pcie_port(port, 1);
928}
929
930int ppc4xx_init_pcie_endport(int port)
931{
932 return ppc4xx_init_pcie_port(port, 0);
933}
934
935void ppc4xx_setup_pcie_rootpoint(struct pci_controller *hose, int port)
936{
937 volatile void *mbase = NULL;
938 volatile void *rmbase = NULL;
939
940 pci_set_ops(hose,
941 pcie_read_config_byte,
942 pcie_read_config_word,
943 pcie_read_config_dword,
944 pcie_write_config_byte,
945 pcie_write_config_word,
946 pcie_write_config_dword);
947
948 switch (port) {
949 case 0:
950 mbase = (u32 *)CONFIG_SYS_PCIE0_XCFGBASE;
951 rmbase = (u32 *)CONFIG_SYS_PCIE0_CFGBASE;
952 hose->cfg_data = (u8 *)CONFIG_SYS_PCIE0_CFGBASE;
953 break;
954 case 1:
955 mbase = (u32 *)CONFIG_SYS_PCIE1_XCFGBASE;
956 rmbase = (u32 *)CONFIG_SYS_PCIE1_CFGBASE;
957 hose->cfg_data = (u8 *)CONFIG_SYS_PCIE1_CFGBASE;
958 break;
959#if CONFIG_SYS_PCIE_NR_PORTS > 2
960 case 2:
961 mbase = (u32 *)CONFIG_SYS_PCIE2_XCFGBASE;
962 rmbase = (u32 *)CONFIG_SYS_PCIE2_CFGBASE;
963 hose->cfg_data = (u8 *)CONFIG_SYS_PCIE2_CFGBASE;
964 break;
965#endif
966 }
967
968
969
970
971 out_8((u8 *)mbase + PCI_PRIMARY_BUS, 0);
972 out_8((u8 *)mbase + PCI_SECONDARY_BUS, 1);
973 out_8((u8 *)mbase + PCI_SUBORDINATE_BUS, 1);
974
975
976
977
978
979
980
981 out_le32(mbase + PECFG_POM0LAH, 0x00000000);
982 out_le32(mbase + PECFG_POM0LAL, CONFIG_SYS_PCIE_MEMBASE +
983 port * CONFIG_SYS_PCIE_MEMSIZE);
984 debug("PECFG_POM0LA=%08x.%08x\n", in_le32(mbase + PECFG_POM0LAH),
985 in_le32(mbase + PECFG_POM0LAL));
986
987 switch (port) {
988 case 0:
989 mtdcr(DCRN_PEGPL_OMR1BAH(PCIE0), CONFIG_SYS_PCIE_ADDR_HIGH);
990 mtdcr(DCRN_PEGPL_OMR1BAL(PCIE0), CONFIG_SYS_PCIE_MEMBASE +
991 port * CONFIG_SYS_PCIE_MEMSIZE);
992 mtdcr(DCRN_PEGPL_OMR1MSKH(PCIE0), 0x7fffffff);
993 mtdcr(DCRN_PEGPL_OMR1MSKL(PCIE0),
994 ~(CONFIG_SYS_PCIE_MEMSIZE - 1) | 3);
995 debug("0:PEGPL_OMR1BA=%08x.%08x MSK=%08x.%08x\n",
996 mfdcr(DCRN_PEGPL_OMR1BAH(PCIE0)),
997 mfdcr(DCRN_PEGPL_OMR1BAL(PCIE0)),
998 mfdcr(DCRN_PEGPL_OMR1MSKH(PCIE0)),
999 mfdcr(DCRN_PEGPL_OMR1MSKL(PCIE0)));
1000 break;
1001 case 1:
1002 mtdcr(DCRN_PEGPL_OMR1BAH(PCIE1), CONFIG_SYS_PCIE_ADDR_HIGH);
1003 mtdcr(DCRN_PEGPL_OMR1BAL(PCIE1), CONFIG_SYS_PCIE_MEMBASE +
1004 port * CONFIG_SYS_PCIE_MEMSIZE);
1005 mtdcr(DCRN_PEGPL_OMR1MSKH(PCIE1), 0x7fffffff);
1006 mtdcr(DCRN_PEGPL_OMR1MSKL(PCIE1),
1007 ~(CONFIG_SYS_PCIE_MEMSIZE - 1) | 3);
1008 debug("1:PEGPL_OMR1BA=%08x.%08x MSK=%08x.%08x\n",
1009 mfdcr(DCRN_PEGPL_OMR1BAH(PCIE1)),
1010 mfdcr(DCRN_PEGPL_OMR1BAL(PCIE1)),
1011 mfdcr(DCRN_PEGPL_OMR1MSKH(PCIE1)),
1012 mfdcr(DCRN_PEGPL_OMR1MSKL(PCIE1)));
1013 break;
1014#if CONFIG_SYS_PCIE_NR_PORTS > 2
1015 case 2:
1016 mtdcr(DCRN_PEGPL_OMR1BAH(PCIE2), CONFIG_SYS_PCIE_ADDR_HIGH);
1017 mtdcr(DCRN_PEGPL_OMR1BAL(PCIE2), CONFIG_SYS_PCIE_MEMBASE +
1018 port * CONFIG_SYS_PCIE_MEMSIZE);
1019 mtdcr(DCRN_PEGPL_OMR1MSKH(PCIE2), 0x7fffffff);
1020 mtdcr(DCRN_PEGPL_OMR1MSKL(PCIE2),
1021 ~(CONFIG_SYS_PCIE_MEMSIZE - 1) | 3);
1022 debug("2:PEGPL_OMR1BA=%08x.%08x MSK=%08x.%08x\n",
1023 mfdcr(DCRN_PEGPL_OMR1BAH(PCIE2)),
1024 mfdcr(DCRN_PEGPL_OMR1BAL(PCIE2)),
1025 mfdcr(DCRN_PEGPL_OMR1MSKH(PCIE2)),
1026 mfdcr(DCRN_PEGPL_OMR1MSKL(PCIE2)));
1027 break;
1028#endif
1029 }
1030
1031
1032 out_le32(mbase + PCI_BASE_ADDRESS_0, 0);
1033 out_le32(mbase + PCI_BASE_ADDRESS_1, 0);
1034 out_le32(mbase + PECFG_BAR0HMPA, 0x7ffffff);
1035 out_le32(mbase + PECFG_BAR0LMPA, 0);
1036
1037 out_le32(mbase + PECFG_PIM01SAH, 0xffff0000);
1038 out_le32(mbase + PECFG_PIM01SAL, 0x00000000);
1039 out_le32(mbase + PECFG_PIM0LAL, 0);
1040 out_le32(mbase + PECFG_PIM0LAH, 0);
1041 out_le32(mbase + PECFG_PIM1LAL, 0x00000000);
1042 out_le32(mbase + PECFG_PIM1LAH, 0x00000004);
1043 out_le32(mbase + PECFG_PIMEN, 0x1);
1044
1045
1046 out_le16((u16 *)(mbase + PCI_COMMAND),
1047 in_le16((u16 *)(mbase + PCI_COMMAND)) |
1048 PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER);
1049
1050
1051 out_le16(mbase + 0x200, 0xaaa0 + port);
1052 out_le16(mbase + 0x202, 0xbed0 + port);
1053
1054
1055 out_le32(mbase + 0x208, 0x06040001);
1056
1057 printf("PCIE%d: successfully set as root-complex\n", port);
1058}
1059
1060int ppc4xx_setup_pcie_endpoint(struct pci_controller *hose, int port)
1061{
1062 volatile void *mbase = NULL;
1063 int attempts = 0;
1064
1065 pci_set_ops(hose,
1066 pcie_read_config_byte,
1067 pcie_read_config_word,
1068 pcie_read_config_dword,
1069 pcie_write_config_byte,
1070 pcie_write_config_word,
1071 pcie_write_config_dword);
1072
1073 switch (port) {
1074 case 0:
1075 mbase = (u32 *)CONFIG_SYS_PCIE0_XCFGBASE;
1076 hose->cfg_data = (u8 *)CONFIG_SYS_PCIE0_CFGBASE;
1077 break;
1078 case 1:
1079 mbase = (u32 *)CONFIG_SYS_PCIE1_XCFGBASE;
1080 hose->cfg_data = (u8 *)CONFIG_SYS_PCIE1_CFGBASE;
1081 break;
1082#if defined(CONFIG_SYS_PCIE2_CFGBASE)
1083 case 2:
1084 mbase = (u32 *)CONFIG_SYS_PCIE2_XCFGBASE;
1085 hose->cfg_data = (u8 *)CONFIG_SYS_PCIE2_CFGBASE;
1086 break;
1087#endif
1088 }
1089
1090
1091
1092
1093
1094
1095
1096 out_le32(mbase + PECFG_POM0LAH, 0x00001ff8);
1097 out_le32(mbase + PECFG_POM0LAL, 0x00001000);
1098
1099 switch (port) {
1100 case 0:
1101 mtdcr(DCRN_PEGPL_OMR1BAH(PCIE0), CONFIG_SYS_PCIE_ADDR_HIGH);
1102 mtdcr(DCRN_PEGPL_OMR1BAL(PCIE0), CONFIG_SYS_PCIE_MEMBASE +
1103 port * CONFIG_SYS_PCIE_MEMSIZE);
1104 mtdcr(DCRN_PEGPL_OMR1MSKH(PCIE0), 0x7fffffff);
1105 mtdcr(DCRN_PEGPL_OMR1MSKL(PCIE0),
1106 ~(CONFIG_SYS_PCIE_MEMSIZE - 1) | 3);
1107 break;
1108 case 1:
1109 mtdcr(DCRN_PEGPL_OMR1BAH(PCIE1), CONFIG_SYS_PCIE_ADDR_HIGH);
1110 mtdcr(DCRN_PEGPL_OMR1BAL(PCIE1), CONFIG_SYS_PCIE_MEMBASE +
1111 port * CONFIG_SYS_PCIE_MEMSIZE);
1112 mtdcr(DCRN_PEGPL_OMR1MSKH(PCIE1), 0x7fffffff);
1113 mtdcr(DCRN_PEGPL_OMR1MSKL(PCIE1),
1114 ~(CONFIG_SYS_PCIE_MEMSIZE - 1) | 3);
1115 break;
1116#if CONFIG_SYS_PCIE_NR_PORTS > 2
1117 case 2:
1118 mtdcr(DCRN_PEGPL_OMR1BAH(PCIE2), CONFIG_SYS_PCIE_ADDR_HIGH);
1119 mtdcr(DCRN_PEGPL_OMR1BAL(PCIE2), CONFIG_SYS_PCIE_MEMBASE +
1120 port * CONFIG_SYS_PCIE_MEMSIZE);
1121 mtdcr(DCRN_PEGPL_OMR1MSKH(PCIE2), 0x7fffffff);
1122 mtdcr(DCRN_PEGPL_OMR1MSKL(PCIE2),
1123 ~(CONFIG_SYS_PCIE_MEMSIZE - 1) | 3);
1124 break;
1125#endif
1126 }
1127
1128
1129 out_le32(mbase + PCI_BASE_ADDRESS_0, 0);
1130 out_le32(mbase + PCI_BASE_ADDRESS_1, 0);
1131
1132 out_le32(mbase + PECFG_PIM01SAH, 0xffffffff);
1133 out_le32(mbase + PECFG_PIM01SAL, 0xfc000000);
1134
1135
1136 out_le32(mbase + PECFG_BAR0HMPA, 0x7fffffff);
1137 out_le32(mbase + PECFG_BAR0LMPA, 0xfc000000 | PCI_BASE_ADDRESS_MEM_TYPE_64);
1138
1139
1140 out_le32(mbase + PECFG_BAR1MPA, 0);
1141 out_le32(mbase + PECFG_BAR2HMPA, 0);
1142 out_le32(mbase + PECFG_BAR2LMPA, 0);
1143
1144 out_le32(mbase + PECFG_PIM0LAL, U64_TO_U32_LOW(CONFIG_SYS_PCIE_INBOUND_BASE));
1145 out_le32(mbase + PECFG_PIM0LAH, U64_TO_U32_HIGH(CONFIG_SYS_PCIE_INBOUND_BASE));
1146 out_le32(mbase + PECFG_PIMEN, 0x1);
1147
1148
1149 out_le16((u16 *)(mbase + PCI_COMMAND),
1150 in_le16((u16 *)(mbase + PCI_COMMAND)) |
1151 PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER);
1152 out_le16(mbase + 0x200, 0xcaad);
1153 out_le16(mbase + 0x202, 0xfeed);
1154
1155
1156 out_le32(mbase + 0x208, 0x0b200001);
1157
1158 attempts = 10;
1159 while(!(SDR_READ(SDRN_PESDR_RCSSTS(port)) & (1 << 8))) {
1160 if (!(attempts--)) {
1161 printf("PCIE%d: BME not active\n", port);
1162 return -1;
1163 }
1164 mdelay(1000);
1165 }
1166
1167 printf("PCIE%d: successfully set as endpoint\n", port);
1168
1169 return 0;
1170}
1171#endif
1172