Merge with /pub/scm/linux/kernel/git/torvalds/linux-2.6.git
[linux-2.6] / arch / mips / gt64120 / momenco_ocelot / setup.c
1 /*
2  * setup.c
3  *
4  * BRIEF MODULE DESCRIPTION
5  * Momentum Computer Ocelot (CP7000) - board dependent boot routines
6  *
7  * Copyright (C) 1996, 1997, 2001, 06  Ralf Baechle (ralf@linux-mips.org)
8  * Copyright (C) 2000 RidgeRun, Inc.
9  * Copyright (C) 2001 Red Hat, Inc.
10  * Copyright (C) 2002 Momentum Computer
11  *
12  * Author: RidgeRun, Inc.
13  *   glonnon@ridgerun.com, skranz@ridgerun.com, stevej@ridgerun.com
14  *
15  * Copyright 2001 MontaVista Software Inc.
16  * Author: jsun@mvista.com or jsun@junsun.net
17  *
18  *  This program is free software; you can redistribute  it and/or modify it
19  *  under  the terms of  the GNU General  Public License as published by the
20  *  Free Software Foundation;  either version 2 of the  License, or (at your
21  *  option) any later version.
22  *
23  *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
24  *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
25  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
26  *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
27  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
28  *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
29  *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
30  *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
31  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
32  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33  *
34  *  You should have received a copy of the  GNU General Public License along
35  *  with this program; if not, write  to the Free Software Foundation, Inc.,
36  *  675 Mass Ave, Cambridge, MA 02139, USA.
37  *
38  */
39 #include <linux/init.h>
40 #include <linux/kernel.h>
41 #include <linux/types.h>
42 #include <linux/mm.h>
43 #include <linux/swap.h>
44 #include <linux/ioport.h>
45 #include <linux/sched.h>
46 #include <linux/interrupt.h>
47 #include <linux/pci.h>
48 #include <linux/timex.h>
49 #include <linux/vmalloc.h>
50 #include <linux/pm.h>
51
52 #include <asm/time.h>
53 #include <asm/bootinfo.h>
54 #include <asm/page.h>
55 #include <asm/io.h>
56 #include <asm/irq.h>
57 #include <asm/pci.h>
58 #include <asm/processor.h>
59 #include <asm/ptrace.h>
60 #include <asm/reboot.h>
61 #include <asm/traps.h>
62 #include <linux/bootmem.h>
63 #include <linux/initrd.h>
64 #include <asm/gt64120.h>
65 #include "ocelot_pld.h"
66
67 unsigned long gt64120_base = KSEG1ADDR(GT_DEF_BASE);
68
69 /* These functions are used for rebooting or halting the machine*/
70 extern void momenco_ocelot_restart(char *command);
71 extern void momenco_ocelot_halt(void);
72 extern void momenco_ocelot_power_off(void);
73
74 extern void gt64120_time_init(void);
75 extern void momenco_ocelot_irq_setup(void);
76
77 static char reset_reason;
78
79 #define ENTRYLO(x) ((pte_val(pfn_pte((x) >> PAGE_SHIFT, PAGE_KERNEL_UNCACHED)) >> 6)|1)
80
81 static void __init setup_l3cache(unsigned long size);
82
83 /* setup code for a handoff from a version 1 PMON 2000 PROM */
84 void PMON_v1_setup()
85 {
86         /* A wired TLB entry for the GT64120A and the serial port. The
87            GT64120A is going to be hit on every IRQ anyway - there's
88            absolutely no point in letting it be a random TLB entry, as
89            it'll just cause needless churning of the TLB. And we use
90            the other half for the serial port, which is just a PITA
91            otherwise :)
92
93                 Device                  Physical        Virtual
94                 GT64120 Internal Regs   0x24000000      0xe0000000
95                 UARTs (CS2)             0x2d000000      0xe0001000
96         */
97         add_wired_entry(ENTRYLO(0x24000000), ENTRYLO(0x2D000000), 0xe0000000, PM_4K);
98
99         /* Also a temporary entry to let us talk to the Ocelot PLD and NVRAM
100            in the CS[012] region. We can't use ioremap() yet. The NVRAM
101            is a ST M48T37Y, which includes NVRAM, RTC, and Watchdog functions.
102
103                 Ocelot PLD (CS0)        0x2c000000      0xe0020000
104                 NVRAM                   0x2c800000      0xe0030000
105         */
106
107         add_temporary_entry(ENTRYLO(0x2C000000), ENTRYLO(0x2d000000), 0xe0020000, PM_64K);
108
109         /* Relocate the CS3/BootCS region */
110         GT_WRITE(GT_CS3BOOTLD_OFS, 0x2f000000 >> 21);
111
112         /* Relocate CS[012] */
113         GT_WRITE(GT_CS20LD_OFS, 0x2c000000 >> 21);
114
115         /* Relocate the GT64120A itself... */
116         GT_WRITE(GT_ISD_OFS, 0x24000000 >> 21);
117         mb();
118         gt64120_base = 0xe0000000;
119
120         /* ...and the PCI0 view of it. */
121         GT_WRITE(GT_PCI0_CFGADDR_OFS, 0x80000020);
122         GT_WRITE(GT_PCI0_CFGDATA_OFS, 0x24000000);
123         GT_WRITE(GT_PCI0_CFGADDR_OFS, 0x80000024);
124         GT_WRITE(GT_PCI0_CFGDATA_OFS, 0x24000001);
125 }
126
127 /* setup code for a handoff from a version 2 PMON 2000 PROM */
128 void PMON_v2_setup()
129 {
130         /* A wired TLB entry for the GT64120A and the serial port. The
131            GT64120A is going to be hit on every IRQ anyway - there's
132            absolutely no point in letting it be a random TLB entry, as
133            it'll just cause needless churning of the TLB. And we use
134            the other half for the serial port, which is just a PITA
135            otherwise :)
136
137                 Device                  Physical        Virtual
138                 GT64120 Internal Regs   0xf4000000      0xe0000000
139                 UARTs (CS2)             0xfd000000      0xe0001000
140         */
141         add_wired_entry(ENTRYLO(0xf4000000), ENTRYLO(0xfD000000), 0xe0000000, PM_4K);
142
143         /* Also a temporary entry to let us talk to the Ocelot PLD and NVRAM
144            in the CS[012] region. We can't use ioremap() yet. The NVRAM
145            is a ST M48T37Y, which includes NVRAM, RTC, and Watchdog functions.
146
147                 Ocelot PLD (CS0)        0xfc000000      0xe0020000
148                 NVRAM                   0xfc800000      0xe0030000
149         */
150         add_temporary_entry(ENTRYLO(0xfC000000), ENTRYLO(0xfd000000), 0xe0020000, PM_64K);
151
152         gt64120_base = 0xe0000000;
153 }
154
155 void __init plat_mem_setup(void)
156 {
157         void (*l3func)(unsigned long)=KSEG1ADDR(&setup_l3cache);
158         unsigned int tmpword;
159
160         board_time_init = gt64120_time_init;
161
162         _machine_restart = momenco_ocelot_restart;
163         _machine_halt = momenco_ocelot_halt;
164         pm_power_off = momenco_ocelot_power_off;
165
166         /*
167          * initrd_start = (ulong)ocelot_initrd_start;
168          * initrd_end = (ulong)ocelot_initrd_start + (ulong)ocelot_initrd_size;
169          * initrd_below_start_ok = 1;
170          */
171
172         /* do handoff reconfiguration */
173         if (gt64120_base == KSEG1ADDR(GT_DEF_BASE))
174                 PMON_v1_setup();
175         else
176                 PMON_v2_setup();
177
178         /* Turn off the Bit-Error LED */
179         OCELOT_PLD_WRITE(0x80, INTCLR);
180
181         /* Relocate all the PCI1 stuff, not that we use it */
182         GT_WRITE(GT_PCI1IOLD_OFS, 0x30000000 >> 21);
183         GT_WRITE(GT_PCI1M0LD_OFS, 0x32000000 >> 21);
184         GT_WRITE(GT_PCI1M1LD_OFS, 0x34000000 >> 21);
185
186         /* Relocate PCI0 I/O and Mem0 */
187         GT_WRITE(GT_PCI0IOLD_OFS, 0x20000000 >> 21);
188         GT_WRITE(GT_PCI0M0LD_OFS, 0x22000000 >> 21);
189
190         /* Relocate PCI0 Mem1 */
191         GT_WRITE(GT_PCI0M1LD_OFS, 0x36000000 >> 21);
192
193         /* For the initial programming, we assume 512MB configuration */
194         /* Relocate the CPU's view of the RAM... */
195         GT_WRITE(GT_SCS10LD_OFS, 0);
196         GT_WRITE(GT_SCS10HD_OFS, 0x0fe00000 >> 21);
197         GT_WRITE(GT_SCS32LD_OFS, 0x10000000 >> 21);
198         GT_WRITE(GT_SCS32HD_OFS, 0x0fe00000 >> 21);
199
200         GT_WRITE(GT_SCS1LD_OFS, 0xff);
201         GT_WRITE(GT_SCS1HD_OFS, 0x00);
202         GT_WRITE(GT_SCS0LD_OFS, 0);
203         GT_WRITE(GT_SCS0HD_OFS, 0xff);
204         GT_WRITE(GT_SCS3LD_OFS, 0xff);
205         GT_WRITE(GT_SCS3HD_OFS, 0x00);
206         GT_WRITE(GT_SCS2LD_OFS, 0);
207         GT_WRITE(GT_SCS2HD_OFS, 0xff);
208
209         /* ...and the PCI0 view of it. */
210         GT_WRITE(GT_PCI0_CFGADDR_OFS, 0x80000010);
211         GT_WRITE(GT_PCI0_CFGDATA_OFS, 0x00000000);
212         GT_WRITE(GT_PCI0_CFGADDR_OFS, 0x80000014);
213         GT_WRITE(GT_PCI0_CFGDATA_OFS, 0x10000000);
214         GT_WRITE(GT_PCI0_BS_SCS10_OFS, 0x0ffff000);
215         GT_WRITE(GT_PCI0_BS_SCS32_OFS, 0x0ffff000);
216
217         tmpword = OCELOT_PLD_READ(BOARDREV);
218         if (tmpword < 26)
219                 printk("Momenco Ocelot: Board Assembly Rev. %c\n", 'A'+tmpword);
220         else
221                 printk("Momenco Ocelot: Board Assembly Revision #0x%x\n", tmpword);
222
223         tmpword = OCELOT_PLD_READ(PLD1_ID);
224         printk("PLD 1 ID: %d.%d\n", tmpword>>4, tmpword&15);
225         tmpword = OCELOT_PLD_READ(PLD2_ID);
226         printk("PLD 2 ID: %d.%d\n", tmpword>>4, tmpword&15);
227         tmpword = OCELOT_PLD_READ(RESET_STATUS);
228         printk("Reset reason: 0x%x\n", tmpword);
229         reset_reason = tmpword;
230         OCELOT_PLD_WRITE(0xff, RESET_STATUS);
231
232         tmpword = OCELOT_PLD_READ(BOARD_STATUS);
233         printk("Board Status register: 0x%02x\n", tmpword);
234         printk("  - User jumper: %s\n", (tmpword & 0x80)?"installed":"absent");
235         printk("  - Boot flash write jumper: %s\n", (tmpword&0x40)?"installed":"absent");
236         printk("  - Tulip PHY %s connected\n", (tmpword&0x10)?"is":"not");
237         printk("  - L3 Cache size: %d MiB\n", (1<<((tmpword&12) >> 2))&~1);
238         printk("  - SDRAM size: %d MiB\n", 1<<(6+(tmpword&3)));
239
240         if (tmpword&12)
241                 l3func((1<<(((tmpword&12) >> 2)+20)));
242
243         switch(tmpword &3) {
244         case 3:
245                 /* 512MiB */
246                 /* Decoders are allready set -- just add the
247                  * appropriate region */
248                 add_memory_region( 0x40<<20,  0xC0<<20, BOOT_MEM_RAM);
249                 add_memory_region(0x100<<20, 0x100<<20, BOOT_MEM_RAM);
250                 break;
251         case 2:
252                 /* 256MiB -- two banks of 128MiB */
253                 GT_WRITE(GT_SCS10HD_OFS, 0x07e00000 >> 21);
254                 GT_WRITE(GT_SCS32LD_OFS, 0x08000000 >> 21);
255                 GT_WRITE(GT_SCS32HD_OFS, 0x0fe00000 >> 21);
256
257                 GT_WRITE(GT_SCS0HD_OFS, 0x7f);
258                 GT_WRITE(GT_SCS2LD_OFS, 0x80);
259                 GT_WRITE(GT_SCS2HD_OFS, 0xff);
260
261                 /* reconfigure the PCI0 interface view of memory */
262                 GT_WRITE(GT_PCI0_CFGADDR_OFS, 0x80000014);
263                 GT_WRITE(GT_PCI0_CFGDATA_OFS, 0x08000000);
264                 GT_WRITE(GT_PCI0_BS_SCS10_OFS, 0x0ffff000);
265                 GT_WRITE(GT_PCI0_BS_SCS32_OFS, 0x0ffff000);
266
267                 add_memory_region(0x40<<20, 0x40<<20, BOOT_MEM_RAM);
268                 add_memory_region(0x80<<20, 0x80<<20, BOOT_MEM_RAM);
269                 break;
270         case 1:
271                 /* 128MiB -- 64MiB per bank */
272                 GT_WRITE(GT_SCS10HD_OFS, 0x03e00000 >> 21);
273                 GT_WRITE(GT_SCS32LD_OFS, 0x04000000 >> 21);
274                 GT_WRITE(GT_SCS32HD_OFS, 0x07e00000 >> 21);
275
276                 GT_WRITE(GT_SCS0HD_OFS, 0x3f);
277                 GT_WRITE(GT_SCS2LD_OFS, 0x40);
278                 GT_WRITE(GT_SCS2HD_OFS, 0x7f);
279
280                 /* reconfigure the PCI0 interface view of memory */
281                 GT_WRITE(GT_PCI0_CFGADDR_OFS, 0x80000014);
282                 GT_WRITE(GT_PCI0_CFGDATA_OFS, 0x04000000);
283                 GT_WRITE(GT_PCI0_BS_SCS10_OFS, 0x03fff000);
284                 GT_WRITE(GT_PCI0_BS_SCS32_OFS, 0x03fff000);
285
286                 /* add the appropriate region */
287                 add_memory_region(0x40<<20, 0x40<<20, BOOT_MEM_RAM);
288                 break;
289         case 0:
290                 /* 64MiB */
291                 GT_WRITE(GT_SCS10HD_OFS, 0x01e00000 >> 21);
292                 GT_WRITE(GT_SCS32LD_OFS, 0x02000000 >> 21);
293                 GT_WRITE(GT_SCS32HD_OFS, 0x03e00000 >> 21);
294
295                 GT_WRITE(GT_SCS0HD_OFS, 0x1f);
296                 GT_WRITE(GT_SCS2LD_OFS, 0x20);
297                 GT_WRITE(GT_SCS2HD_OFS, 0x3f);
298
299                 /* reconfigure the PCI0 interface view of memory */
300                 GT_WRITE(GT_PCI0_CFGADDR_OFS, 0x80000014);
301                 GT_WRITE(GT_PCI0_CFGDATA_OFS, 0x04000000);
302                 GT_WRITE(GT_PCI0_BS_SCS10_OFS, 0x01fff000);
303                 GT_WRITE(GT_PCI0_BS_SCS32_OFS, 0x01fff000);
304
305                 break;
306         }
307
308         /* Fix up the DiskOnChip mapping */
309         GT_WRITE(GT_DEV_B3_OFS, 0xfef73);
310 }
311
312 extern int rm7k_tcache_enabled;
313 /*
314  * This runs in KSEG1. See the verbiage in rm7k.c::probe_scache()
315  */
316 #define Page_Invalidate_T 0x16
317 static void __init setup_l3cache(unsigned long size)
318 {
319         int register i;
320         unsigned long tmp;
321
322         printk("Enabling L3 cache...");
323
324         /* Enable the L3 cache in the GT64120A's CPU Configuration register */
325         tmp = GT_READ(GT_CPU_OFS);
326         GT_WRITE(GT_CPU_OFS, tmp | (1<<14));
327
328         /* Enable the L3 cache in the CPU */
329         set_c0_config(1<<12 /* CONF_TE */);
330
331         /* Clear the cache */
332         write_c0_taglo(0);
333         write_c0_taghi(0);
334
335         for (i=0; i < size; i+= 4096) {
336                 __asm__ __volatile__ (
337                         ".set noreorder\n\t"
338                         ".set mips3\n\t"
339                         "cache %1, (%0)\n\t"
340                         ".set mips0\n\t"
341                         ".set reorder"
342                         :
343                         : "r" (KSEG0ADDR(i)),
344                           "i" (Page_Invalidate_T));
345         }
346
347         /* Let the RM7000 MM code know that the tertiary cache is enabled */
348         rm7k_tcache_enabled = 1;
349
350         printk("Done\n");
351 }
352
353
354 /* This needs to be one of the first initcalls, because no I/O port access
355    can work before this */
356
357 static int io_base_ioremap(void)
358 {
359         void *io_remap_range = ioremap(GT_PCI_IO_BASE, GT_PCI_IO_SIZE);
360
361         if (!io_remap_range) {
362                 panic("Could not ioremap I/O port range");
363         }
364         set_io_port_base(io_remap_range - GT_PCI_IO_BASE);
365
366         return 0;
367 }
368
369 module_init(io_base_ioremap);