input: Add generic keyboard input handler
[oweals/u-boot.git] / board / eXalion / eXalion.c
1 /*
2  * (C) Copyright 2000-2004
3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4  *
5  * (C) Copyright 2002
6  * Torsten Demke, FORCE Computers GmbH. torsten.demke@fci.com
7  *
8  * See file CREDITS for list of people who contributed to this
9  * project.
10  *
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License as
13  * published by the Free Software Foundation; either version 2 of
14  * the License, or (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
24  * MA 02111-1307 USA
25  */
26
27 #include <common.h>
28 #include <mpc824x.h>
29 #include <asm/processor.h>
30 #include <asm/io.h>
31 #include <pci.h>
32 #include <ide.h>
33 #include <netdev.h>
34 #include <timestamp.h>
35 #include "piix_pci.h"
36 #include "eXalion.h"
37
38 int checkboard (void)
39 {
40         ulong busfreq = get_bus_freq (0);
41         char buf[32];
42
43         printf ("Board: eXalion MPC824x - CHRP (MAP B)\n");
44         printf ("Built: %s at %s\n", U_BOOT_DATE, U_BOOT_TIME);
45         printf ("Local Bus:  %s MHz\n", strmhz (buf, busfreq));
46
47         return 0;
48 }
49
50 int checkflash (void)
51 {
52         printf ("checkflash\n");
53         flash_init ();
54         return (0);
55 }
56
57 phys_size_t initdram (int board_type)
58 {
59         int i, cnt;
60         volatile uchar *base = CONFIG_SYS_SDRAM_BASE;
61         volatile ulong *addr;
62         ulong save[32];
63         ulong val, ret = 0;
64
65         for (i = 0, cnt = (CONFIG_SYS_MAX_RAM_SIZE / sizeof (long)) >> 1; cnt > 0;
66              cnt >>= 1) {
67                 addr = (volatile ulong *) base + cnt;
68                 save[i++] = *addr;
69                 *addr = ~cnt;
70         }
71
72         addr = (volatile ulong *) base;
73         save[i] = *addr;
74         *addr = 0;
75
76         if (*addr != 0) {
77                 *addr = save[i];
78                 goto Done;
79         }
80
81         for (cnt = 1; cnt <= CONFIG_SYS_MAX_RAM_SIZE / sizeof (long); cnt <<= 1) {
82                 addr = (volatile ulong *) base + cnt;
83                 val = *addr;
84                 *addr = save[--i];
85                 if (val != ~cnt) {
86                         ulong new_bank0_end = cnt * sizeof (long) - 1;
87                         ulong mear1 = mpc824x_mpc107_getreg (MEAR1);
88                         ulong emear1 = mpc824x_mpc107_getreg (EMEAR1);
89
90                         mear1 = (mear1 & 0xFFFFFF00) |
91                                 ((new_bank0_end & MICR_ADDR_MASK) >>
92                                  MICR_ADDR_SHIFT);
93                         emear1 = (emear1 & 0xFFFFFF00) |
94                                 ((new_bank0_end & MICR_ADDR_MASK) >>
95                                  MICR_EADDR_SHIFT);
96                         mpc824x_mpc107_setreg (MEAR1, mear1);
97                         mpc824x_mpc107_setreg (EMEAR1, emear1);
98
99                         ret = cnt * sizeof (long);
100                         goto Done;
101                 }
102         }
103
104         ret = CONFIG_SYS_MAX_RAM_SIZE;
105       Done:
106         return ret;
107 }
108
109 int misc_init_r (void)
110 {
111         pci_dev_t bdf;
112         u32 val32;
113         u8 val8;
114
115         puts ("ISA:   ");
116         bdf = pci_find_device (PIIX4_VENDOR_ID, PIIX4_ISA_DEV_ID, 0);
117         if (bdf == -1) {
118                 puts ("Unable to find PIIX4 ISA bridge !\n");
119                 hang ();
120         }
121
122         /* set device for normal ISA instead EIO */
123         pci_read_config_dword (bdf, PCI_CFG_PIIX4_GENCFG, &val32);
124         val32 |= 0x00000001;
125         pci_write_config_dword (bdf, PCI_CFG_PIIX4_GENCFG, val32);
126         printf ("PIIX4 ISA bridge (%d,%d,%d)\n", PCI_BUS (bdf),
127                 PCI_DEV (bdf), PCI_FUNC (bdf));
128
129         puts ("ISA:   ");
130         bdf = pci_find_device (PIIX4_VENDOR_ID, PIIX4_IDE_DEV_ID, 0);
131         if (bdf == -1) {
132                 puts ("Unable to find PIIX4 IDE controller !\n");
133                 hang ();
134         }
135
136         /* Init BMIBA register  */
137         /* pci_read_config_dword(bdf, PCI_CFG_PIIX4_BMIBA, &val32); */
138         /* val32 |= 0x1000; */
139         /* pci_write_config_dword(bdf, PCI_CFG_PIIX4_BMIBA, val32); */
140
141         /* Enable BUS master and IO access  */
142         val32 = PCI_COMMAND_MASTER | PCI_COMMAND_IO;
143         pci_write_config_dword (bdf, PCI_COMMAND, val32);
144
145         /* Set latency  */
146         pci_read_config_byte (bdf, PCI_LATENCY_TIMER, &val8);
147         val8 = 0x40;
148         pci_write_config_byte (bdf, PCI_LATENCY_TIMER, val8);
149
150         /* Enable Primary ATA/IDE  */
151         pci_read_config_dword (bdf, PCI_CFG_PIIX4_IDETIM, &val32);
152         /* val32 = 0xa307a307; */
153         val32 = 0x00008000;
154         pci_write_config_dword (bdf, PCI_CFG_PIIX4_IDETIM, val32);
155
156
157         printf ("PIIX4 IDE controller (%d,%d,%d)\n", PCI_BUS (bdf),
158                 PCI_DEV (bdf), PCI_FUNC (bdf));
159
160         /* Try to get FAT working... */
161         /* fat_register_read(ide_read); */
162
163
164         return (0);
165 }
166
167 /*
168  * Show/Init PCI devices on the specified bus number.
169  */
170
171 void pci_eXalion_fixup_irq (struct pci_controller *hose, pci_dev_t dev)
172 {
173         unsigned char line;
174
175         switch (PCI_DEV (dev)) {
176         case 16:
177                 line = PCI_INT_A;
178                 break;
179         case 17:
180                 line = PCI_INT_B;
181                 break;
182         case 18:
183                 line = PCI_INT_C;
184                 break;
185         case 19:
186                 line = PCI_INT_D;
187                 break;
188 #if defined (CONFIG_MPC8245)
189         case 20:
190                 line = PCI_INT_A;
191                 break;
192         case 21:
193                 line = PCI_INT_B;
194                 break;
195         case 22:
196                 line = PCI_INT_NA;
197                 break;
198 #endif
199         default:
200                 line = PCI_INT_A;
201                 break;
202         }
203         pci_hose_write_config_byte (hose, dev, PCI_INTERRUPT_LINE, line);
204 }
205
206
207 /*
208  * Initialize PCI Devices, report devices found.
209  */
210 #ifndef CONFIG_PCI_PNP
211 #if defined (CONFIG_MPC8240)
212 static struct pci_config_table pci_eXalion_config_table[] = {
213         {
214          /* Intel 82559ER ethernet controller */
215          PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, 0x00, 18, 0x00,
216          pci_cfgfunc_config_device, {PCI_ENET0_IOADDR,
217                                      PCI_ENET0_MEMADDR,
218                                      PCI_COMMAND_MEMORY |
219                                      PCI_COMMAND_MASTER}},
220         {
221          /* Intel 82371AB PIIX4 PCI to ISA bridge */
222          PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, 0x00, 20, 0x00,
223          pci_cfgfunc_config_device, {0,
224                                      0,
225                                      PCI_COMMAND_IO | PCI_COMMAND_MASTER}},
226         {
227          /* Intel 82371AB PIIX4 IDE controller */
228          PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, 0x00, 20, 0x01,
229          pci_cfgfunc_config_device, {0,
230                                      0,
231                                      PCI_COMMAND_IO | PCI_COMMAND_MASTER}},
232         {}
233 };
234 #elif defined (CONFIG_MPC8245)
235 static struct pci_config_table pci_eXalion_config_table[] = {
236         {
237          /* Intel 82559ER ethernet controller */
238          PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, 0x00, 17, 0x00,
239          pci_cfgfunc_config_device, {PCI_ENET0_IOADDR,
240                                      PCI_ENET0_MEMADDR,
241                                      PCI_COMMAND_MEMORY |
242                                      PCI_COMMAND_MASTER}},
243         {
244          /* Intel 82559ER ethernet controller */
245          PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, 0x00, 18, 0x00,
246          pci_cfgfunc_config_device, {PCI_ENET1_IOADDR,
247                                      PCI_ENET1_MEMADDR,
248                                      PCI_COMMAND_MEMORY |
249                                      PCI_COMMAND_MASTER}},
250         {
251          /* Broadcom BCM5690 Gigabit switch */
252          PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, 0x00, 20, 0x00,
253          pci_cfgfunc_config_device, {PCI_ENET2_IOADDR,
254                                      PCI_ENET2_MEMADDR,
255                                      PCI_COMMAND_MEMORY |
256                                      PCI_COMMAND_MASTER}},
257         {
258          /* Broadcom BCM5690 Gigabit switch */
259          PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, 0x00, 21, 0x00,
260          pci_cfgfunc_config_device, {PCI_ENET3_IOADDR,
261                                      PCI_ENET3_MEMADDR,
262                                      PCI_COMMAND_MEMORY |
263                                      PCI_COMMAND_MASTER}},
264         {
265          /* Intel 82371AB PIIX4 PCI to ISA bridge */
266          PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, 0x00, 22, 0x00,
267          pci_cfgfunc_config_device, {0,
268                                      0,
269                                      PCI_COMMAND_IO | PCI_COMMAND_MASTER}},
270         {
271          /* Intel 82371AB PIIX4 IDE controller */
272          PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, 0x00, 22, 0x01,
273          pci_cfgfunc_config_device, {0,
274                                      0,
275                                      PCI_COMMAND_IO | PCI_COMMAND_MASTER}},
276         {}
277 };
278 #else
279 #error Specific type of MPC824x must be defined (i.e. CONFIG_MPC8240)
280 #endif
281
282 #endif /* #ifndef CONFIG_PCI_PNP */
283
284 struct pci_controller hose = {
285 #ifndef CONFIG_PCI_PNP
286         config_table:pci_eXalion_config_table,
287         fixup_irq:pci_eXalion_fixup_irq,
288 #endif
289 };
290
291 void pci_init_board (void)
292 {
293         pci_mpc824x_init (&hose);
294 }
295
296 int board_eth_init(bd_t *bis)
297 {
298         return pci_eth_init(bis);
299 }