85xx: Use common LSDMR defines from asm/fsl_lbc.h
[oweals/u-boot.git] / board / sbc8548 / sbc8548.c
1 /*
2  * Copyright 2007 Wind River Systemes, Inc. <www.windriver.com>
3  * Copyright 2007 Embedded Specialties, Inc.
4  *
5  * Copyright 2004, 2007 Freescale Semiconductor.
6  *
7  * (C) Copyright 2002 Scott McNutt <smcnutt@artesyncp.com>
8  *
9  * See file CREDITS for list of people who contributed to this
10  * project.
11  *
12  * This program is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License as
14  * published by the Free Software Foundation; either version 2 of
15  * the License, or (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
25  * MA 02111-1307 USA
26  */
27
28 #include <common.h>
29 #include <pci.h>
30 #include <asm/processor.h>
31 #include <asm/immap_85xx.h>
32 #include <asm/immap_fsl_pci.h>
33 #include <asm/fsl_ddr_sdram.h>
34 #include <spd_sdram.h>
35 #include <miiphy.h>
36 #include <libfdt.h>
37 #include <fdt_support.h>
38
39 DECLARE_GLOBAL_DATA_PTR;
40
41 void local_bus_init(void);
42 void sdram_init(void);
43 long int fixed_sdram (void);
44
45 int board_early_init_f (void)
46 {
47         return 0;
48 }
49
50 int checkboard (void)
51 {
52         volatile ccsr_gur_t *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
53         volatile ccsr_local_ecm_t *ecm = (void *)(CONFIG_SYS_MPC85xx_ECM_ADDR);
54         volatile u_char *rev= (void *)CONFIG_SYS_BD_REV;
55
56         printf ("Board: Wind River SBC8548 Rev. 0x%01x\n",
57                         (*rev) >> 4);
58
59         /*
60          * Initialize local bus.
61          */
62         local_bus_init ();
63
64         /*
65          * Hack TSEC 3 and 4 IO voltages.
66          */
67         gur->tsec34ioovcr = 0xe7e0;     /*  1110 0111 1110 0xxx */
68
69         ecm->eedr = 0xffffffff;         /* clear ecm errors */
70         ecm->eeer = 0xffffffff;         /* enable ecm errors */
71         return 0;
72 }
73
74 phys_size_t
75 initdram(int board_type)
76 {
77         long dram_size = 0;
78
79         puts("Initializing\n");
80
81 #if defined(CONFIG_DDR_DLL)
82         {
83                 /*
84                  * Work around to stabilize DDR DLL MSYNC_IN.
85                  * Errata DDR9 seems to have been fixed.
86                  * This is now the workaround for Errata DDR11:
87                  *    Override DLL = 1, Course Adj = 1, Tap Select = 0
88                  */
89
90                 volatile ccsr_gur_t *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
91
92                 gur->ddrdllcr = 0x81000000;
93                 asm("sync;isync;msync");
94                 udelay(200);
95         }
96 #endif
97
98 #if defined(CONFIG_SPD_EEPROM)
99         dram_size = fsl_ddr_sdram();
100         dram_size = setup_ddr_tlbs(dram_size / 0x100000);
101         dram_size *= 0x100000;
102 #else
103         dram_size = fixed_sdram ();
104 #endif
105
106         /*
107          * SDRAM Initialization
108          */
109         sdram_init();
110
111         puts("    DDR: ");
112         return dram_size;
113 }
114
115 /*
116  * Initialize Local Bus
117  */
118 void
119 local_bus_init(void)
120 {
121         volatile ccsr_gur_t *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
122         volatile ccsr_lbc_t *lbc = (void *)(CONFIG_SYS_MPC85xx_LBC_ADDR);
123
124         uint clkdiv;
125         uint lbc_hz;
126         sys_info_t sysinfo;
127
128         get_sys_info(&sysinfo);
129         clkdiv = (lbc->lcrr & LCRR_CLKDIV) * 2;
130         lbc_hz = sysinfo.freqSystemBus / 1000000 / clkdiv;
131
132         gur->lbiuiplldcr1 = 0x00078080;
133         if (clkdiv == 16) {
134                 gur->lbiuiplldcr0 = 0x7c0f1bf0;
135         } else if (clkdiv == 8) {
136                 gur->lbiuiplldcr0 = 0x6c0f1bf0;
137         } else if (clkdiv == 4) {
138                 gur->lbiuiplldcr0 = 0x5c0f1bf0;
139         }
140
141         lbc->lcrr |= 0x00030000;
142
143         asm("sync;isync;msync");
144
145         lbc->ltesr = 0xffffffff;        /* Clear LBC error interrupts */
146         lbc->lteir = 0xffffffff;        /* Enable LBC error interrupts */
147 }
148
149 /*
150  * Initialize SDRAM memory on the Local Bus.
151  */
152 void
153 sdram_init(void)
154 {
155 #if defined(CONFIG_SYS_OR3_PRELIM) && defined(CONFIG_SYS_BR3_PRELIM)
156
157         uint idx;
158         volatile ccsr_lbc_t *lbc = (void *)(CONFIG_SYS_MPC85xx_LBC_ADDR);
159         uint *sdram_addr = (uint *)CONFIG_SYS_LBC_SDRAM_BASE;
160         uint lsdmr_common;
161
162         puts("    SDRAM: ");
163
164         print_size (CONFIG_SYS_LBC_SDRAM_SIZE * 1024 * 1024, "\n");
165
166         /*
167          * Setup SDRAM Base and Option Registers
168          */
169         lbc->or3 = CONFIG_SYS_OR3_PRELIM;
170         asm("msync");
171
172         lbc->br3 = CONFIG_SYS_BR3_PRELIM;
173         asm("msync");
174
175         lbc->lbcr = CONFIG_SYS_LBC_LBCR;
176         asm("msync");
177
178
179         lbc->lsrt = CONFIG_SYS_LBC_LSRT;
180         lbc->mrtpr = CONFIG_SYS_LBC_MRTPR;
181         asm("msync");
182
183         /*
184          * MPC8548 uses "new" 15-16 style addressing.
185          */
186         lsdmr_common = CONFIG_SYS_LBC_LSDMR_COMMON;
187         lsdmr_common |= LSDMR_BSMA1516;
188
189         /*
190          * Issue PRECHARGE ALL command.
191          */
192         lbc->lsdmr = lsdmr_common | LSDMR_OP_PCHALL;
193         asm("sync;msync");
194         *sdram_addr = 0xff;
195         ppcDcbf((unsigned long) sdram_addr);
196         udelay(100);
197
198         /*
199          * Issue 8 AUTO REFRESH commands.
200          */
201         for (idx = 0; idx < 8; idx++) {
202                 lbc->lsdmr = lsdmr_common | LSDMR_OP_ARFRSH;
203                 asm("sync;msync");
204                 *sdram_addr = 0xff;
205                 ppcDcbf((unsigned long) sdram_addr);
206                 udelay(100);
207         }
208
209         /*
210          * Issue 8 MODE-set command.
211          */
212         lbc->lsdmr = lsdmr_common | LSDMR_OP_MRW;
213         asm("sync;msync");
214         *sdram_addr = 0xff;
215         ppcDcbf((unsigned long) sdram_addr);
216         udelay(100);
217
218         /*
219          * Issue NORMAL OP command.
220          */
221         lbc->lsdmr = lsdmr_common | LSDMR_OP_NORMAL;
222         asm("sync;msync");
223         *sdram_addr = 0xff;
224         ppcDcbf((unsigned long) sdram_addr);
225         udelay(200);    /* Overkill. Must wait > 200 bus cycles */
226
227 #endif  /* enable SDRAM init */
228 }
229
230 #if defined(CONFIG_SYS_DRAM_TEST)
231 int
232 testdram(void)
233 {
234         uint *pstart = (uint *) CONFIG_SYS_MEMTEST_START;
235         uint *pend = (uint *) CONFIG_SYS_MEMTEST_END;
236         uint *p;
237
238         printf("Testing DRAM from 0x%08x to 0x%08x\n",
239                CONFIG_SYS_MEMTEST_START,
240                CONFIG_SYS_MEMTEST_END);
241
242         printf("DRAM test phase 1:\n");
243         for (p = pstart; p < pend; p++)
244                 *p = 0xaaaaaaaa;
245
246         for (p = pstart; p < pend; p++) {
247                 if (*p != 0xaaaaaaaa) {
248                         printf ("DRAM test fails at: %08x\n", (uint) p);
249                         return 1;
250                 }
251         }
252
253         printf("DRAM test phase 2:\n");
254         for (p = pstart; p < pend; p++)
255                 *p = 0x55555555;
256
257         for (p = pstart; p < pend; p++) {
258                 if (*p != 0x55555555) {
259                         printf ("DRAM test fails at: %08x\n", (uint) p);
260                         return 1;
261                 }
262         }
263
264         printf("DRAM test passed.\n");
265         return 0;
266 }
267 #endif
268
269 #if     !defined(CONFIG_SPD_EEPROM)
270 /*************************************************************************
271  *  fixed_sdram init -- doesn't use serial presence detect.
272  *  assumes 256MB DDR2 SDRAM SODIMM, without ECC, running at DDR400 speed.
273  ************************************************************************/
274 long int fixed_sdram (void)
275 {
276     #define CONFIG_SYS_DDR_CONTROL 0xc300c000
277
278         volatile ccsr_ddr_t *ddr = (void *)(CONFIG_SYS_MPC85xx_DDR_ADDR);
279
280         ddr->cs0_bnds           = 0x0000007f;
281         ddr->cs1_bnds           = 0x008000ff;
282         ddr->cs2_bnds           = 0x00000000;
283         ddr->cs3_bnds           = 0x00000000;
284         ddr->cs0_config         = 0x80010101;
285         ddr->cs1_config         = 0x80010101;
286         ddr->cs2_config         = 0x00000000;
287         ddr->cs3_config         = 0x00000000;
288         ddr->timing_cfg_3               = 0x00000000;
289         ddr->timing_cfg_0       = 0x00220802;
290         ddr->timing_cfg_1       = 0x38377322;
291         ddr->timing_cfg_2       = 0x0fa044C7;
292         ddr->sdram_cfg          = 0x4300C000;
293         ddr->sdram_cfg_2        = 0x24401000;
294         ddr->sdram_mode         = 0x23C00542;
295         ddr->sdram_mode_2       = 0x00000000;
296         ddr->sdram_interval     = 0x05080100;
297         ddr->sdram_md_cntl      = 0x00000000;
298         ddr->sdram_data_init    = 0x00000000;
299         ddr->sdram_clk_cntl     = 0x03800000;
300         asm("sync;isync;msync");
301         udelay(500);
302
303         #if defined (CONFIG_DDR_ECC)
304           /* Enable ECC checking */
305           ddr->sdram_cfg = (CONFIG_SYS_DDR_CONTROL | 0x20000000);
306         #else
307           ddr->sdram_cfg = CONFIG_SYS_DDR_CONTROL;
308         #endif
309
310         return CONFIG_SYS_SDRAM_SIZE * 1024 * 1024;
311 }
312 #endif
313
314 #if defined(CONFIG_PCI) || defined(CONFIG_PCI1)
315 /* For some reason the Tundra PCI bridge shows up on itself as a
316  * different device.  Work around that by refusing to configure it.
317  */
318 void dummy_func(struct pci_controller* hose, pci_dev_t dev, struct pci_config_table *tab) { }
319
320 static struct pci_config_table pci_sbc8548_config_table[] = {
321         {0x10e3, 0x0513, PCI_ANY_ID, 1, 3, PCI_ANY_ID, dummy_func, {0,0,0}},
322         {0x1106, 0x0686, PCI_ANY_ID, 1, VIA_ID, 0, mpc85xx_config_via, {0,0,0}},
323         {0x1106, 0x0571, PCI_ANY_ID, 1, VIA_ID, 1,
324                 mpc85xx_config_via_usbide, {0,0,0}},
325         {0x1105, 0x3038, PCI_ANY_ID, 1, VIA_ID, 2,
326                 mpc85xx_config_via_usb, {0,0,0}},
327         {0x1106, 0x3038, PCI_ANY_ID, 1, VIA_ID, 3,
328                 mpc85xx_config_via_usb2, {0,0,0}},
329         {0x1106, 0x3058, PCI_ANY_ID, 1, VIA_ID, 5,
330                 mpc85xx_config_via_power, {0,0,0}},
331         {0x1106, 0x3068, PCI_ANY_ID, 1, VIA_ID, 6,
332                 mpc85xx_config_via_ac97, {0,0,0}},
333         {},
334 };
335
336 static struct pci_controller pci1_hose = {
337         config_table: pci_sbc8548_config_table};
338 #endif  /* CONFIG_PCI */
339
340 #ifdef CONFIG_PCI2
341 static struct pci_controller pci2_hose;
342 #endif  /* CONFIG_PCI2 */
343
344 #ifdef CONFIG_PCIE1
345 static struct pci_controller pcie1_hose;
346 #endif  /* CONFIG_PCIE1 */
347
348 int first_free_busno=0;
349
350 extern int fsl_pci_setup_inbound_windows(struct pci_region *r);
351 extern void fsl_pci_init(struct pci_controller *hose);
352
353 void
354 pci_init_board(void)
355 {
356         volatile ccsr_gur_t *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
357
358 #ifdef CONFIG_PCI1
359 {
360         volatile ccsr_fsl_pci_t *pci = (ccsr_fsl_pci_t *) CONFIG_SYS_PCI1_ADDR;
361         struct pci_controller *hose = &pci1_hose;
362         struct pci_config_table *table;
363         struct pci_region *r = hose->regions;
364
365         uint pci_32 = gur->pordevsr & MPC85xx_PORDEVSR_PCI1_PCI32;      /* PORDEVSR[15] */
366         uint pci_arb = gur->pordevsr & MPC85xx_PORDEVSR_PCI1_ARB;       /* PORDEVSR[14] */
367         uint pci_clk_sel = gur->porpllsr & MPC85xx_PORDEVSR_PCI1_SPD;   /* PORPLLSR[16] */
368
369         uint pci_agent = (host_agent == 3) || (host_agent == 4 ) || (host_agent == 6);
370
371         uint pci_speed = get_clock_freq ();     /* PCI PSPEED in [4:5] */
372
373         if (!(gur->devdisr & MPC85xx_DEVDISR_PCI1)) {
374                 printf ("    PCI: %d bit, %s MHz, %s, %s, %s\n",
375                         (pci_32) ? 32 : 64,
376                         (pci_speed == 33333000) ? "33" :
377                         (pci_speed == 66666000) ? "66" : "unknown",
378                         pci_clk_sel ? "sync" : "async",
379                         pci_agent ? "agent" : "host",
380                         pci_arb ? "arbiter" : "external-arbiter"
381                         );
382
383
384                 /* inbound */
385                 r += fsl_pci_setup_inbound_windows(r);
386
387                 /* outbound memory */
388                 pci_set_region(r++,
389                                CONFIG_SYS_PCI1_MEM_BASE,
390                                CONFIG_SYS_PCI1_MEM_PHYS,
391                                CONFIG_SYS_PCI1_MEM_SIZE,
392                                PCI_REGION_MEM);
393
394                 /* outbound io */
395                 pci_set_region(r++,
396                                CONFIG_SYS_PCI1_IO_BASE,
397                                CONFIG_SYS_PCI1_IO_PHYS,
398                                CONFIG_SYS_PCI1_IO_SIZE,
399                                PCI_REGION_IO);
400                 hose->region_count = r - hose->regions;
401
402                 /* relocate config table pointers */
403                 hose->config_table = \
404                         (struct pci_config_table *)((uint)hose->config_table + gd->reloc_off);
405                 for (table = hose->config_table; table && table->vendor; table++)
406                         table->config_device += gd->reloc_off;
407
408                 hose->first_busno=first_free_busno;
409                 pci_setup_indirect(hose, (int) &pci->cfg_addr, (int) &pci->cfg_data);
410
411                 fsl_pci_init(hose);
412                 first_free_busno=hose->last_busno+1;
413                 printf ("PCI on bus %02x - %02x\n",hose->first_busno,hose->last_busno);
414 #ifdef CONFIG_PCIX_CHECK
415                 if (!(gur->pordevsr & MPC85xx_PORDEVSR_PCI1)) {
416                         /* PCI-X init */
417                         if (CONFIG_SYS_CLK_FREQ < 66000000)
418                                 printf("PCI-X will only work at 66 MHz\n");
419
420                         reg16 = PCI_X_CMD_MAX_SPLIT | PCI_X_CMD_MAX_READ
421                                 | PCI_X_CMD_ERO | PCI_X_CMD_DPERR_E;
422                         pci_hose_write_config_word(hose, bus, PCIX_COMMAND, reg16);
423                 }
424 #endif
425         } else {
426                 printf ("    PCI: disabled\n");
427         }
428 }
429 #else
430         gur->devdisr |= MPC85xx_DEVDISR_PCI1; /* disable */
431 #endif
432
433 #ifdef CONFIG_PCI2
434 {
435         uint pci2_clk_sel = gur->porpllsr & 0x4000;     /* PORPLLSR[17] */
436         uint pci_dual = get_pci_dual ();        /* PCI DUAL in CM_PCI[3] */
437         if (pci_dual) {
438                 printf ("    PCI2: 32 bit, 66 MHz, %s\n",
439                         pci2_clk_sel ? "sync" : "async");
440         } else {
441                 printf ("    PCI2: disabled\n");
442         }
443 }
444 #else
445         gur->devdisr |= MPC85xx_DEVDISR_PCI2; /* disable */
446 #endif /* CONFIG_PCI2 */
447
448 #ifdef CONFIG_PCIE1
449 {
450         volatile ccsr_fsl_pci_t *pci = (ccsr_fsl_pci_t *) CONFIG_SYS_PCIE1_ADDR;
451         struct pci_controller *hose = &pcie1_hose;
452         int pcie_ep =  (host_agent == 0) || (host_agent == 2 ) || (host_agent == 3);
453         struct pci_region *r = hose->regions;
454
455         int pcie_configured  = io_sel >= 1;
456
457         if (pcie_configured && !(gur->devdisr & MPC85xx_DEVDISR_PCIE)){
458                 printf ("\n    PCIE connected to slot as %s (base address %x)",
459                         pcie_ep ? "End Point" : "Root Complex",
460                         (uint)pci);
461
462                 if (pci->pme_msg_det) {
463                         pci->pme_msg_det = 0xffffffff;
464                         debug (" with errors.  Clearing.  Now 0x%08x",pci->pme_msg_det);
465                 }
466                 printf ("\n");
467
468                 /* inbound */
469                 pci_set_region(r++,
470                                CONFIG_SYS_PCI_MEMORY_BUS,
471                                CONFIG_SYS_PCI_MEMORY_PHYS,
472                                CONFIG_SYS_PCI_MEMORY_SIZE,
473                                PCI_REGION_MEM | PCI_REGION_SYS_MEMORY);
474
475                 /* outbound memory */
476                 pci_set_region(r++,
477                                CONFIG_SYS_PCIE1_MEM_BASE,
478                                CONFIG_SYS_PCIE1_MEM_PHYS,
479                                CONFIG_SYS_PCIE1_MEM_SIZE,
480                                PCI_REGION_MEM);
481
482                 /* outbound io */
483                 pci_set_region(r++,
484                                CONFIG_SYS_PCIE1_IO_BASE,
485                                CONFIG_SYS_PCIE1_IO_PHYS,
486                                CONFIG_SYS_PCIE1_IO_SIZE,
487                                PCI_REGION_IO);
488
489                 hose->region_count = r - hose->regions;
490
491                 hose->first_busno=first_free_busno;
492                 pci_setup_indirect(hose, (int) &pci->cfg_addr, (int) &pci->cfg_data);
493
494                 fsl_pci_init(hose);
495                 printf ("PCIE on bus %d - %d\n",hose->first_busno,hose->last_busno);
496
497                 first_free_busno=hose->last_busno+1;
498
499         } else {
500                 printf ("    PCIE: disabled\n");
501         }
502  }
503 #else
504         gur->devdisr |= MPC85xx_DEVDISR_PCIE; /* disable */
505 #endif
506
507 }
508
509 int last_stage_init(void)
510 {
511         return 0;
512 }
513
514 #if defined(CONFIG_OF_BOARD_SETUP)
515 extern void ft_fsl_pci_setup(void *blob, const char *pci_alias,
516                         struct pci_controller *hose);
517
518 void ft_board_setup(void *blob, bd_t *bd)
519 {
520         ft_cpu_setup(blob, bd);
521 #ifdef CONFIG_PCI1
522         ft_fsl_pci_setup(blob, "pci0", &pci1_hose);
523 #endif
524 #ifdef CONFIG_PCIE1
525         ft_fsl_pci_setup(blob, "pci1", &pcie1_hose);
526 #endif
527 }
528 #endif