diff options
43 files changed, 4 insertions, 2892 deletions
diff --git a/arch/sh/Kconfig b/arch/sh/Kconfig index c7e3596dcde1..ddf2cc56868c 100644 --- a/arch/sh/Kconfig +++ b/arch/sh/Kconfig | |||
@@ -89,12 +89,6 @@ config SH_7751_SYSTEMH | |||
89 | Select SystemH if you are configuring for a Renesas SystemH | 89 | Select SystemH if you are configuring for a Renesas SystemH |
90 | 7751R evaluation board. | 90 | 7751R evaluation board. |
91 | 91 | ||
92 | config SH_STB1_HARP | ||
93 | bool "STB1_Harp" | ||
94 | |||
95 | config SH_STB1_OVERDRIVE | ||
96 | bool "STB1_Overdrive" | ||
97 | |||
98 | config SH_HP6XX | 92 | config SH_HP6XX |
99 | bool "HP6XX" | 93 | bool "HP6XX" |
100 | help | 94 | help |
@@ -102,19 +96,6 @@ config SH_HP6XX | |||
102 | More information (hardware only) at | 96 | More information (hardware only) at |
103 | <http://www.hp.com/jornada/>. | 97 | <http://www.hp.com/jornada/>. |
104 | 98 | ||
105 | config SH_CQREEK | ||
106 | bool "CqREEK" | ||
107 | help | ||
108 | Select CqREEK if configuring for a CqREEK SH7708 or SH7750. | ||
109 | More information at | ||
110 | <http://sources.redhat.com/ecos/hardware.html#SuperH>. | ||
111 | |||
112 | config SH_DMIDA | ||
113 | bool "DMIDA" | ||
114 | help | ||
115 | Select DMIDA if configuring for a DataMyte 4000 Industrial | ||
116 | Digital Assistant. More information at <http://www.dmida.com/>. | ||
117 | |||
118 | config SH_EC3104 | 99 | config SH_EC3104 |
119 | bool "EC3104" | 100 | bool "EC3104" |
120 | help | 101 | help |
@@ -136,25 +117,9 @@ config SH_DREAMCAST | |||
136 | <http://www.m17n.org/linux-sh/dreamcast/>. There is a | 117 | <http://www.m17n.org/linux-sh/dreamcast/>. There is a |
137 | Dreamcast project is at <http://linuxdc.sourceforge.net/>. | 118 | Dreamcast project is at <http://linuxdc.sourceforge.net/>. |
138 | 119 | ||
139 | config SH_CAT68701 | ||
140 | bool "CAT68701" | ||
141 | |||
142 | config SH_BIGSUR | 120 | config SH_BIGSUR |
143 | bool "BigSur" | 121 | bool "BigSur" |
144 | 122 | ||
145 | config SH_SH2000 | ||
146 | bool "SH2000" | ||
147 | select CPU_SUBTYPE_SH7709 | ||
148 | help | ||
149 | SH-2000 is a single-board computer based around SH7709A chip | ||
150 | intended for embedded applications. | ||
151 | It has an Ethernet interface (CS8900A), direct connected | ||
152 | Compact Flash socket, three serial ports and PC-104 bus. | ||
153 | More information at <http://sh2000.sh-linux.org>. | ||
154 | |||
155 | config SH_ADX | ||
156 | bool "ADX" | ||
157 | |||
158 | config SH_MPC1211 | 123 | config SH_MPC1211 |
159 | bool "Interface MPC1211" | 124 | bool "Interface MPC1211" |
160 | help | 125 | help |
@@ -246,7 +211,7 @@ source "arch/sh/mm/Kconfig" | |||
246 | 211 | ||
247 | config CF_ENABLER | 212 | config CF_ENABLER |
248 | bool "Compact Flash Enabler support" | 213 | bool "Compact Flash Enabler support" |
249 | depends on SH_ADX || SH_SOLUTION_ENGINE || SH_UNKNOWN || SH_CAT68701 || SH_SH03 | 214 | depends on SH_SOLUTION_ENGINE || SH_UNKNOWN || SH_SH03 |
250 | ---help--- | 215 | ---help--- |
251 | Compact Flash is a small, removable mass storage device introduced | 216 | Compact Flash is a small, removable mass storage device introduced |
252 | in 1994 originally as a PCMCIA device. If you say `Y' here, you | 217 | in 1994 originally as a PCMCIA device. If you say `Y' here, you |
@@ -274,7 +239,7 @@ config CF_AREA5 | |||
274 | - "Area5" if CompactFlash is connected to Area 5 (0x14000000) | 239 | - "Area5" if CompactFlash is connected to Area 5 (0x14000000) |
275 | - "Area6" if it is connected to Area 6 (0x18000000) | 240 | - "Area6" if it is connected to Area 6 (0x18000000) |
276 | 241 | ||
277 | "Area6" will work for most boards. For ADX, select "Area5". | 242 | "Area6" will work for most boards. |
278 | 243 | ||
279 | config CF_AREA6 | 244 | config CF_AREA6 |
280 | bool "Area6" | 245 | bool "Area6" |
@@ -418,8 +383,8 @@ source "arch/sh/cchips/Kconfig" | |||
418 | 383 | ||
419 | config HEARTBEAT | 384 | config HEARTBEAT |
420 | bool "Heartbeat LED" | 385 | bool "Heartbeat LED" |
421 | depends on SH_MPC1211 || SH_SH03 || SH_CAT68701 || \ | 386 | depends on SH_MPC1211 || SH_SH03 || \ |
422 | SH_STB1_HARP || SH_STB1_OVERDRIVE || SH_BIGSUR || \ | 387 | SH_BIGSUR || \ |
423 | SH_7751_SOLUTION_ENGINE || SH_7300_SOLUTION_ENGINE || \ | 388 | SH_7751_SOLUTION_ENGINE || SH_7300_SOLUTION_ENGINE || \ |
424 | SH_73180_SOLUTION_ENGINE || SH_SOLUTION_ENGINE || \ | 389 | SH_73180_SOLUTION_ENGINE || SH_SOLUTION_ENGINE || \ |
425 | SH_RTS7751R2D || SH_SH4202_MICRODEV || SH_LANDISK | 390 | SH_RTS7751R2D || SH_SH4202_MICRODEV || SH_LANDISK |
diff --git a/arch/sh/Makefile b/arch/sh/Makefile index 8ad0a286ff8f..d0168844c3c7 100644 --- a/arch/sh/Makefile +++ b/arch/sh/Makefile | |||
@@ -90,18 +90,11 @@ machdir-$(CONFIG_SH_SOLUTION_ENGINE) := se/770x | |||
90 | machdir-$(CONFIG_SH_7751_SOLUTION_ENGINE) := se/7751 | 90 | machdir-$(CONFIG_SH_7751_SOLUTION_ENGINE) := se/7751 |
91 | machdir-$(CONFIG_SH_7300_SOLUTION_ENGINE) := se/7300 | 91 | machdir-$(CONFIG_SH_7300_SOLUTION_ENGINE) := se/7300 |
92 | machdir-$(CONFIG_SH_73180_SOLUTION_ENGINE) := se/73180 | 92 | machdir-$(CONFIG_SH_73180_SOLUTION_ENGINE) := se/73180 |
93 | machdir-$(CONFIG_SH_STB1_HARP) := harp | ||
94 | machdir-$(CONFIG_SH_STB1_OVERDRIVE) := overdrive | ||
95 | machdir-$(CONFIG_SH_HP6XX) := hp6xx | 93 | machdir-$(CONFIG_SH_HP6XX) := hp6xx |
96 | machdir-$(CONFIG_SH_CQREEK) := cqreek | ||
97 | machdir-$(CONFIG_SH_DMIDA) := dmida | ||
98 | machdir-$(CONFIG_SH_EC3104) := ec3104 | 94 | machdir-$(CONFIG_SH_EC3104) := ec3104 |
99 | machdir-$(CONFIG_SH_SATURN) := saturn | 95 | machdir-$(CONFIG_SH_SATURN) := saturn |
100 | machdir-$(CONFIG_SH_DREAMCAST) := dreamcast | 96 | machdir-$(CONFIG_SH_DREAMCAST) := dreamcast |
101 | machdir-$(CONFIG_SH_CAT68701) := cat68701 | ||
102 | machdir-$(CONFIG_SH_BIGSUR) := bigsur | 97 | machdir-$(CONFIG_SH_BIGSUR) := bigsur |
103 | machdir-$(CONFIG_SH_SH2000) := sh2000 | ||
104 | machdir-$(CONFIG_SH_ADX) := adx | ||
105 | machdir-$(CONFIG_SH_MPC1211) := mpc1211 | 98 | machdir-$(CONFIG_SH_MPC1211) := mpc1211 |
106 | machdir-$(CONFIG_SH_SH03) := sh03 | 99 | machdir-$(CONFIG_SH_SH03) := sh03 |
107 | machdir-$(CONFIG_SH_SECUREEDGE5410) := snapgear | 100 | machdir-$(CONFIG_SH_SECUREEDGE5410) := snapgear |
diff --git a/arch/sh/boards/adx/Makefile b/arch/sh/boards/adx/Makefile deleted file mode 100644 index 5b1c531b3991..000000000000 --- a/arch/sh/boards/adx/Makefile +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | # | ||
2 | # Makefile for ADX boards | ||
3 | # | ||
4 | |||
5 | obj-y := setup.o irq.o irq_maskreq.o | ||
6 | |||
diff --git a/arch/sh/boards/adx/irq.c b/arch/sh/boards/adx/irq.c deleted file mode 100644 index c6ca409dff98..000000000000 --- a/arch/sh/boards/adx/irq.c +++ /dev/null | |||
@@ -1,31 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/boards/adx/irq.c | ||
3 | * | ||
4 | * Copyright (C) 2001 A&D Co., Ltd. | ||
5 | * | ||
6 | * I/O routine and setup routines for A&D ADX Board | ||
7 | * | ||
8 | * This file is subject to the terms and conditions of the GNU General Public | ||
9 | * License. See the file "COPYING" in the main directory of this archive | ||
10 | * for more details. | ||
11 | * | ||
12 | */ | ||
13 | |||
14 | #include <asm/irq.h> | ||
15 | |||
16 | void init_adx_IRQ(void) | ||
17 | { | ||
18 | int i; | ||
19 | |||
20 | /* printk("init_adx_IRQ()\n");*/ | ||
21 | /* setup irq_mask_register */ | ||
22 | irq_mask_register = (unsigned short *)0xa6000008; | ||
23 | |||
24 | /* cover all external interrupt area by maskreg_irq_type | ||
25 | * (Actually, irq15 doesn't exist) | ||
26 | */ | ||
27 | for (i = 0; i < 16; i++) { | ||
28 | make_maskreg_irq(i); | ||
29 | disable_irq(i); | ||
30 | } | ||
31 | } | ||
diff --git a/arch/sh/boards/adx/irq_maskreg.c b/arch/sh/boards/adx/irq_maskreg.c deleted file mode 100644 index 4b2abe5eb165..000000000000 --- a/arch/sh/boards/adx/irq_maskreg.c +++ /dev/null | |||
@@ -1,106 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/kernel/irq_maskreg.c | ||
3 | * | ||
4 | * Copyright (C) 2001 A&D Co., Ltd. <http://www.aandd.co.jp> | ||
5 | * | ||
6 | * This file may be copied or modified under the terms of the GNU | ||
7 | * General Public License. See linux/COPYING for more information. | ||
8 | * | ||
9 | * Interrupt handling for Simple external interrupt mask register | ||
10 | * | ||
11 | * This is for the machine which have single 16 bit register | ||
12 | * for masking external IRQ individually. | ||
13 | * Each bit of the register is for masking each interrupt. | ||
14 | */ | ||
15 | |||
16 | #include <linux/kernel.h> | ||
17 | #include <linux/init.h> | ||
18 | #include <linux/irq.h> | ||
19 | |||
20 | #include <asm/system.h> | ||
21 | #include <asm/io.h> | ||
22 | #include <asm/machvec.h> | ||
23 | |||
24 | /* address of external interrupt mask register | ||
25 | * address must be set prior to use these (maybe in init_XXX_irq()) | ||
26 | * XXX : is it better to use .config than specifying it in code? */ | ||
27 | unsigned short *irq_mask_register = 0; | ||
28 | |||
29 | /* forward declaration */ | ||
30 | static unsigned int startup_maskreg_irq(unsigned int irq); | ||
31 | static void shutdown_maskreg_irq(unsigned int irq); | ||
32 | static void enable_maskreg_irq(unsigned int irq); | ||
33 | static void disable_maskreg_irq(unsigned int irq); | ||
34 | static void mask_and_ack_maskreg(unsigned int); | ||
35 | static void end_maskreg_irq(unsigned int irq); | ||
36 | |||
37 | /* hw_interrupt_type */ | ||
38 | static struct hw_interrupt_type maskreg_irq_type = { | ||
39 | .typename = " Mask Register", | ||
40 | .startup = startup_maskreg_irq, | ||
41 | .shutdown = shutdown_maskreg_irq, | ||
42 | .enable = enable_maskreg_irq, | ||
43 | .disable = disable_maskreg_irq, | ||
44 | .ack = mask_and_ack_maskreg, | ||
45 | .end = end_maskreg_irq | ||
46 | }; | ||
47 | |||
48 | /* actual implementatin */ | ||
49 | static unsigned int startup_maskreg_irq(unsigned int irq) | ||
50 | { | ||
51 | enable_maskreg_irq(irq); | ||
52 | return 0; /* never anything pending */ | ||
53 | } | ||
54 | |||
55 | static void shutdown_maskreg_irq(unsigned int irq) | ||
56 | { | ||
57 | disable_maskreg_irq(irq); | ||
58 | } | ||
59 | |||
60 | static void disable_maskreg_irq(unsigned int irq) | ||
61 | { | ||
62 | if (irq_mask_register) { | ||
63 | unsigned long flags; | ||
64 | unsigned short val, mask = 0x01 << irq; | ||
65 | |||
66 | /* Set "irq"th bit */ | ||
67 | local_irq_save(flags); | ||
68 | val = ctrl_inw((unsigned long)irq_mask_register); | ||
69 | val |= mask; | ||
70 | ctrl_outw(val, (unsigned long)irq_mask_register); | ||
71 | local_irq_restore(flags); | ||
72 | } | ||
73 | } | ||
74 | |||
75 | static void enable_maskreg_irq(unsigned int irq) | ||
76 | { | ||
77 | if (irq_mask_register) { | ||
78 | unsigned long flags; | ||
79 | unsigned short val, mask = ~(0x01 << irq); | ||
80 | |||
81 | /* Clear "irq"th bit */ | ||
82 | local_irq_save(flags); | ||
83 | val = ctrl_inw((unsigned long)irq_mask_register); | ||
84 | val &= mask; | ||
85 | ctrl_outw(val, (unsigned long)irq_mask_register); | ||
86 | local_irq_restore(flags); | ||
87 | } | ||
88 | } | ||
89 | |||
90 | static void mask_and_ack_maskreg(unsigned int irq) | ||
91 | { | ||
92 | disable_maskreg_irq(irq); | ||
93 | } | ||
94 | |||
95 | static void end_maskreg_irq(unsigned int irq) | ||
96 | { | ||
97 | if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS))) | ||
98 | enable_maskreg_irq(irq); | ||
99 | } | ||
100 | |||
101 | void make_maskreg_irq(unsigned int irq) | ||
102 | { | ||
103 | disable_irq_nosync(irq); | ||
104 | irq_desc[irq].chip = &maskreg_irq_type; | ||
105 | disable_maskreg_irq(irq); | ||
106 | } | ||
diff --git a/arch/sh/boards/adx/setup.c b/arch/sh/boards/adx/setup.c deleted file mode 100644 index 4938d9592343..000000000000 --- a/arch/sh/boards/adx/setup.c +++ /dev/null | |||
@@ -1,56 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/board/adx/setup.c | ||
3 | * | ||
4 | * Copyright (C) 2001 A&D Co., Ltd. | ||
5 | * | ||
6 | * I/O routine and setup routines for A&D ADX Board | ||
7 | * | ||
8 | * This file is subject to the terms and conditions of the GNU General Public | ||
9 | * License. See the file "COPYING" in the main directory of this archive | ||
10 | * for more details. | ||
11 | * | ||
12 | */ | ||
13 | |||
14 | #include <asm/machvec.h> | ||
15 | #include <linux/module.h> | ||
16 | |||
17 | extern void init_adx_IRQ(void); | ||
18 | extern void *cf_io_base; | ||
19 | |||
20 | const char *get_system_type(void) | ||
21 | { | ||
22 | return "A&D ADX"; | ||
23 | } | ||
24 | |||
25 | unsigned long adx_isa_port2addr(unsigned long offset) | ||
26 | { | ||
27 | /* CompactFlash (IDE) */ | ||
28 | if (((offset >= 0x1f0) && (offset <= 0x1f7)) || (offset == 0x3f6)) { | ||
29 | return (unsigned long)cf_io_base + offset; | ||
30 | } | ||
31 | |||
32 | /* eth0 */ | ||
33 | if ((offset >= 0x300) && (offset <= 0x30f)) { | ||
34 | return 0xa5000000 + offset; /* COMM BOARD (AREA1) */ | ||
35 | } | ||
36 | |||
37 | return offset + 0xb0000000; /* IOBUS (AREA 4)*/ | ||
38 | } | ||
39 | |||
40 | /* | ||
41 | * The Machine Vector | ||
42 | */ | ||
43 | |||
44 | struct sh_machine_vector mv_adx __initmv = { | ||
45 | .mv_nr_irqs = 48, | ||
46 | .mv_isa_port2addr = adx_isa_port2addr, | ||
47 | .mv_init_irq = init_adx_IRQ, | ||
48 | }; | ||
49 | ALIAS_MV(adx) | ||
50 | |||
51 | int __init platform_setup(void) | ||
52 | { | ||
53 | /* Nothing to see here .. */ | ||
54 | return 0; | ||
55 | } | ||
56 | |||
diff --git a/arch/sh/boards/cat68701/Makefile b/arch/sh/boards/cat68701/Makefile deleted file mode 100644 index 52c1de0a6dfd..000000000000 --- a/arch/sh/boards/cat68701/Makefile +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | # | ||
2 | # Makefile for the CAT-68701 specific parts of the kernel | ||
3 | # | ||
4 | |||
5 | obj-y := setup.o irq.o | ||
6 | |||
diff --git a/arch/sh/boards/cat68701/irq.c b/arch/sh/boards/cat68701/irq.c deleted file mode 100644 index f9a6d185fb8b..000000000000 --- a/arch/sh/boards/cat68701/irq.c +++ /dev/null | |||
@@ -1,28 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/boards/cat68701/irq.c | ||
3 | * | ||
4 | * Copyright (C) 2000 Niibe Yutaka | ||
5 | * 2001 Yutaro Ebihara | ||
6 | * | ||
7 | * Setup routines for A-ONE Corp CAT-68701 SH7708 Board | ||
8 | * | ||
9 | * This file is subject to the terms and conditions of the GNU General Public | ||
10 | * License. See the file "COPYING" in the main directory of this archive | ||
11 | * for more details. | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | #include <asm/irq.h> | ||
16 | |||
17 | int cat68701_irq_demux(int irq) | ||
18 | { | ||
19 | if(irq==13) return 14; | ||
20 | if(irq==7) return 10; | ||
21 | return irq; | ||
22 | } | ||
23 | |||
24 | void init_cat68701_IRQ() | ||
25 | { | ||
26 | make_imask_irq(10); | ||
27 | make_imask_irq(14); | ||
28 | } | ||
diff --git a/arch/sh/boards/cat68701/setup.c b/arch/sh/boards/cat68701/setup.c deleted file mode 100644 index 90e5175df227..000000000000 --- a/arch/sh/boards/cat68701/setup.c +++ /dev/null | |||
@@ -1,85 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/boards/cat68701/setup.c | ||
3 | * | ||
4 | * Copyright (C) 2000 Niibe Yutaka | ||
5 | * 2001 Yutaro Ebihara | ||
6 | * | ||
7 | * Setup routines for A-ONE Corp CAT-68701 SH7708 Board | ||
8 | * | ||
9 | * This file is subject to the terms and conditions of the GNU General Public | ||
10 | * License. See the file "COPYING" in the main directory of this archive | ||
11 | * for more details. | ||
12 | * | ||
13 | */ | ||
14 | |||
15 | #include <asm/io.h> | ||
16 | #include <asm/machvec.h> | ||
17 | #include <asm/mach/io.h> | ||
18 | #include <linux/module.h> | ||
19 | #include <linux/init.h> | ||
20 | #include <linux/sched.h> | ||
21 | |||
22 | const char *get_system_type(void) | ||
23 | { | ||
24 | return "CAT-68701"; | ||
25 | } | ||
26 | |||
27 | #ifdef CONFIG_HEARTBEAT | ||
28 | void heartbeat_cat68701() | ||
29 | { | ||
30 | static unsigned int cnt = 0, period = 0 , bit = 0; | ||
31 | cnt += 1; | ||
32 | if (cnt < period) { | ||
33 | return; | ||
34 | } | ||
35 | cnt = 0; | ||
36 | |||
37 | /* Go through the points (roughly!): | ||
38 | * f(0)=10, f(1)=16, f(2)=20, f(5)=35,f(inf)->110 | ||
39 | */ | ||
40 | period = 110 - ( (300<<FSHIFT)/ | ||
41 | ((avenrun[0]/5) + (3<<FSHIFT)) ); | ||
42 | |||
43 | if(bit){ bit=0; }else{ bit=1; } | ||
44 | outw(bit<<15,0x3fe); | ||
45 | } | ||
46 | #endif /* CONFIG_HEARTBEAT */ | ||
47 | |||
48 | unsigned long cat68701_isa_port2addr(unsigned long offset) | ||
49 | { | ||
50 | /* CompactFlash (IDE) */ | ||
51 | if (((offset >= 0x1f0) && (offset <= 0x1f7)) || (offset==0x3f6)) | ||
52 | return 0xba000000 + offset; | ||
53 | |||
54 | /* INPUT PORT */ | ||
55 | if ((offset >= 0x3fc) && (offset <= 0x3fd)) | ||
56 | return 0xb4007000 + offset; | ||
57 | |||
58 | /* OUTPUT PORT */ | ||
59 | if ((offset >= 0x3fe) && (offset <= 0x3ff)) | ||
60 | return 0xb4007400 + offset; | ||
61 | |||
62 | return offset + 0xb4000000; /* other I/O (EREA 5)*/ | ||
63 | } | ||
64 | |||
65 | /* | ||
66 | * The Machine Vector | ||
67 | */ | ||
68 | |||
69 | struct sh_machine_vector mv_cat68701 __initmv = { | ||
70 | .mv_nr_irqs = 32, | ||
71 | .mv_isa_port2addr = cat68701_isa_port2addr, | ||
72 | .mv_irq_demux = cat68701_irq_demux, | ||
73 | |||
74 | .mv_init_irq = init_cat68701_IRQ, | ||
75 | #ifdef CONFIG_HEARTBEAT | ||
76 | .mv_heartbeat = heartbeat_cat68701, | ||
77 | #endif | ||
78 | }; | ||
79 | ALIAS_MV(cat68701) | ||
80 | |||
81 | int __init platform_setup(void) | ||
82 | { | ||
83 | /* dummy read erea5 (CS8900A) */ | ||
84 | } | ||
85 | |||
diff --git a/arch/sh/boards/cqreek/Makefile b/arch/sh/boards/cqreek/Makefile deleted file mode 100644 index 1a788a85eba3..000000000000 --- a/arch/sh/boards/cqreek/Makefile +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | # | ||
2 | # Makefile for the CqREEK specific parts of the kernel | ||
3 | # | ||
4 | |||
5 | obj-y := setup.o irq.o | ||
6 | |||
diff --git a/arch/sh/boards/cqreek/irq.c b/arch/sh/boards/cqreek/irq.c deleted file mode 100644 index 2955adc52310..000000000000 --- a/arch/sh/boards/cqreek/irq.c +++ /dev/null | |||
@@ -1,128 +0,0 @@ | |||
1 | /* $Id: irq.c,v 1.1.2.4 2002/11/04 20:33:56 lethal Exp $ | ||
2 | * | ||
3 | * arch/sh/boards/cqreek/irq.c | ||
4 | * | ||
5 | * Copyright (C) 2000 Niibe Yutaka | ||
6 | * | ||
7 | * CqREEK IDE/ISA Bridge Support. | ||
8 | * | ||
9 | */ | ||
10 | |||
11 | #include <linux/irq.h> | ||
12 | #include <linux/init.h> | ||
13 | |||
14 | #include <asm/cqreek/cqreek.h> | ||
15 | #include <asm/io.h> | ||
16 | #include <asm/io_generic.h> | ||
17 | #include <asm/irq.h> | ||
18 | #include <asm/machvec.h> | ||
19 | #include <asm/machvec_init.h> | ||
20 | #include <asm/rtc.h> | ||
21 | |||
22 | struct cqreek_irq_data { | ||
23 | unsigned short mask_port; /* Port of Interrupt Mask Register */ | ||
24 | unsigned short stat_port; /* Port of Interrupt Status Register */ | ||
25 | unsigned short bit; /* Value of the bit */ | ||
26 | }; | ||
27 | static struct cqreek_irq_data cqreek_irq_data[NR_IRQS]; | ||
28 | |||
29 | static void disable_cqreek_irq(unsigned int irq) | ||
30 | { | ||
31 | unsigned long flags; | ||
32 | unsigned short mask; | ||
33 | unsigned short mask_port = cqreek_irq_data[irq].mask_port; | ||
34 | unsigned short bit = cqreek_irq_data[irq].bit; | ||
35 | |||
36 | local_irq_save(flags); | ||
37 | /* Disable IRQ */ | ||
38 | mask = inw(mask_port) & ~bit; | ||
39 | outw_p(mask, mask_port); | ||
40 | local_irq_restore(flags); | ||
41 | } | ||
42 | |||
43 | static void enable_cqreek_irq(unsigned int irq) | ||
44 | { | ||
45 | unsigned long flags; | ||
46 | unsigned short mask; | ||
47 | unsigned short mask_port = cqreek_irq_data[irq].mask_port; | ||
48 | unsigned short bit = cqreek_irq_data[irq].bit; | ||
49 | |||
50 | local_irq_save(flags); | ||
51 | /* Enable IRQ */ | ||
52 | mask = inw(mask_port) | bit; | ||
53 | outw_p(mask, mask_port); | ||
54 | local_irq_restore(flags); | ||
55 | } | ||
56 | |||
57 | static void mask_and_ack_cqreek(unsigned int irq) | ||
58 | { | ||
59 | unsigned short stat_port = cqreek_irq_data[irq].stat_port; | ||
60 | unsigned short bit = cqreek_irq_data[irq].bit; | ||
61 | |||
62 | disable_cqreek_irq(irq); | ||
63 | /* Clear IRQ (it might be edge IRQ) */ | ||
64 | inw(stat_port); | ||
65 | outw_p(bit, stat_port); | ||
66 | } | ||
67 | |||
68 | static void end_cqreek_irq(unsigned int irq) | ||
69 | { | ||
70 | if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS))) | ||
71 | enable_cqreek_irq(irq); | ||
72 | } | ||
73 | |||
74 | static unsigned int startup_cqreek_irq(unsigned int irq) | ||
75 | { | ||
76 | enable_cqreek_irq(irq); | ||
77 | return 0; | ||
78 | } | ||
79 | |||
80 | static void shutdown_cqreek_irq(unsigned int irq) | ||
81 | { | ||
82 | disable_cqreek_irq(irq); | ||
83 | } | ||
84 | |||
85 | static struct hw_interrupt_type cqreek_irq_type = { | ||
86 | .typename = "CqREEK-IRQ", | ||
87 | .startup = startup_cqreek_irq, | ||
88 | .shutdown = shutdown_cqreek_irq, | ||
89 | .enable = enable_cqreek_irq, | ||
90 | .disable = disable_cqreek_irq, | ||
91 | .ack = mask_and_ack_cqreek, | ||
92 | .end = end_cqreek_irq | ||
93 | }; | ||
94 | |||
95 | int cqreek_has_ide, cqreek_has_isa; | ||
96 | |||
97 | /* XXX: This is just for test for my NE2000 ISA board | ||
98 | What we really need is virtualized IRQ and demultiplexer like HP600 port */ | ||
99 | void __init init_cqreek_IRQ(void) | ||
100 | { | ||
101 | if (cqreek_has_ide) { | ||
102 | cqreek_irq_data[14].mask_port = BRIDGE_IDE_INTR_MASK; | ||
103 | cqreek_irq_data[14].stat_port = BRIDGE_IDE_INTR_STAT; | ||
104 | cqreek_irq_data[14].bit = 1; | ||
105 | |||
106 | irq_desc[14].chip = &cqreek_irq_type; | ||
107 | irq_desc[14].status = IRQ_DISABLED; | ||
108 | irq_desc[14].action = 0; | ||
109 | irq_desc[14].depth = 1; | ||
110 | |||
111 | disable_cqreek_irq(14); | ||
112 | } | ||
113 | |||
114 | if (cqreek_has_isa) { | ||
115 | cqreek_irq_data[10].mask_port = BRIDGE_ISA_INTR_MASK; | ||
116 | cqreek_irq_data[10].stat_port = BRIDGE_ISA_INTR_STAT; | ||
117 | cqreek_irq_data[10].bit = (1 << 10); | ||
118 | |||
119 | /* XXX: Err... we may need demultiplexer for ISA irq... */ | ||
120 | irq_desc[10].chip = &cqreek_irq_type; | ||
121 | irq_desc[10].status = IRQ_DISABLED; | ||
122 | irq_desc[10].action = 0; | ||
123 | irq_desc[10].depth = 1; | ||
124 | |||
125 | disable_cqreek_irq(10); | ||
126 | } | ||
127 | } | ||
128 | |||
diff --git a/arch/sh/boards/cqreek/setup.c b/arch/sh/boards/cqreek/setup.c deleted file mode 100644 index eff4ed93599f..000000000000 --- a/arch/sh/boards/cqreek/setup.c +++ /dev/null | |||
@@ -1,100 +0,0 @@ | |||
1 | /* $Id: setup.c,v 1.5 2003/08/04 01:51:58 lethal Exp $ | ||
2 | * | ||
3 | * arch/sh/kernel/setup_cqreek.c | ||
4 | * | ||
5 | * Copyright (C) 2000 Niibe Yutaka | ||
6 | * | ||
7 | * CqREEK IDE/ISA Bridge Support. | ||
8 | * | ||
9 | */ | ||
10 | |||
11 | #include <linux/kernel.h> | ||
12 | #include <linux/init.h> | ||
13 | #include <linux/irq.h> | ||
14 | |||
15 | #include <asm/mach/cqreek.h> | ||
16 | #include <asm/machvec.h> | ||
17 | #include <asm/io.h> | ||
18 | #include <asm/io_generic.h> | ||
19 | #include <asm/irq.h> | ||
20 | #include <asm/rtc.h> | ||
21 | |||
22 | #define IDE_OFFSET 0xA4000000UL | ||
23 | #define ISA_OFFSET 0xA4A00000UL | ||
24 | |||
25 | const char *get_system_type(void) | ||
26 | { | ||
27 | return "CqREEK"; | ||
28 | } | ||
29 | |||
30 | static unsigned long cqreek_port2addr(unsigned long port) | ||
31 | { | ||
32 | if (0x0000<=port && port<=0x0040) | ||
33 | return IDE_OFFSET + port; | ||
34 | if ((0x01f0<=port && port<=0x01f7) || port == 0x03f6) | ||
35 | return IDE_OFFSET + port; | ||
36 | |||
37 | return ISA_OFFSET + port; | ||
38 | } | ||
39 | |||
40 | /* | ||
41 | * The Machine Vector | ||
42 | */ | ||
43 | struct sh_machine_vector mv_cqreek __initmv = { | ||
44 | #if defined(CONFIG_CPU_SH4) | ||
45 | .mv_nr_irqs = 48, | ||
46 | #elif defined(CONFIG_CPU_SUBTYPE_SH7708) | ||
47 | .mv_nr_irqs = 32, | ||
48 | #elif defined(CONFIG_CPU_SUBTYPE_SH7709) | ||
49 | .mv_nr_irqs = 61, | ||
50 | #endif | ||
51 | |||
52 | .mv_init_irq = init_cqreek_IRQ, | ||
53 | |||
54 | .mv_isa_port2addr = cqreek_port2addr, | ||
55 | }; | ||
56 | ALIAS_MV(cqreek) | ||
57 | |||
58 | /* | ||
59 | * Initialize the board | ||
60 | */ | ||
61 | void __init platform_setup(void) | ||
62 | { | ||
63 | int i; | ||
64 | /* udelay is not available at setup time yet... */ | ||
65 | #define DELAY() do {for (i=0; i<10000; i++) ctrl_inw(0xa0000000);} while(0) | ||
66 | |||
67 | if ((inw (BRIDGE_FEATURE) & 1)) { /* We have IDE interface */ | ||
68 | outw_p(0, BRIDGE_IDE_INTR_LVL); | ||
69 | outw_p(0, BRIDGE_IDE_INTR_MASK); | ||
70 | |||
71 | outw_p(0, BRIDGE_IDE_CTRL); | ||
72 | DELAY(); | ||
73 | |||
74 | outw_p(0x8000, BRIDGE_IDE_CTRL); | ||
75 | DELAY(); | ||
76 | |||
77 | outw_p(0xffff, BRIDGE_IDE_INTR_STAT); /* Clear interrupt status */ | ||
78 | outw_p(0x0f-14, BRIDGE_IDE_INTR_LVL); /* Use 14 IPR */ | ||
79 | outw_p(1, BRIDGE_IDE_INTR_MASK); /* Enable interrupt */ | ||
80 | cqreek_has_ide=1; | ||
81 | } | ||
82 | |||
83 | if ((inw (BRIDGE_FEATURE) & 2)) { /* We have ISA interface */ | ||
84 | outw_p(0, BRIDGE_ISA_INTR_LVL); | ||
85 | outw_p(0, BRIDGE_ISA_INTR_MASK); | ||
86 | |||
87 | outw_p(0, BRIDGE_ISA_CTRL); | ||
88 | DELAY(); | ||
89 | outw_p(0x8000, BRIDGE_ISA_CTRL); | ||
90 | DELAY(); | ||
91 | |||
92 | outw_p(0xffff, BRIDGE_ISA_INTR_STAT); /* Clear interrupt status */ | ||
93 | outw_p(0x0f-10, BRIDGE_ISA_INTR_LVL); /* Use 10 IPR */ | ||
94 | outw_p(0xfff8, BRIDGE_ISA_INTR_MASK); /* Enable interrupt */ | ||
95 | cqreek_has_isa=1; | ||
96 | } | ||
97 | |||
98 | printk(KERN_INFO "CqREEK Setup (IDE=%d, ISA=%d)...done\n", cqreek_has_ide, cqreek_has_isa); | ||
99 | } | ||
100 | |||
diff --git a/arch/sh/boards/dmida/Makefile b/arch/sh/boards/dmida/Makefile deleted file mode 100644 index 75999aa0a2d9..000000000000 --- a/arch/sh/boards/dmida/Makefile +++ /dev/null | |||
@@ -1,7 +0,0 @@ | |||
1 | # | ||
2 | # Makefile for the DataMyte Industrial Digital Assistant(tm) specific parts | ||
3 | # of the kernel | ||
4 | # | ||
5 | |||
6 | obj-y := mach.o | ||
7 | |||
diff --git a/arch/sh/boards/dmida/mach.c b/arch/sh/boards/dmida/mach.c deleted file mode 100644 index d03a25f989c2..000000000000 --- a/arch/sh/boards/dmida/mach.c +++ /dev/null | |||
@@ -1,59 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/boards/dmida/mach.c | ||
3 | * | ||
4 | * by Greg Banks <gbanks@pocketpenguins.com> | ||
5 | * (c) 2000 PocketPenguins Inc | ||
6 | * | ||
7 | * Derived from mach_hp600.c, which bore the message: | ||
8 | * Copyright (C) 2000 Stuart Menefy (stuart.menefy@st.com) | ||
9 | * | ||
10 | * May be copied or modified under the terms of the GNU General Public | ||
11 | * License. See linux/COPYING for more information. | ||
12 | * | ||
13 | * Machine vector for the DataMyte Industrial Digital Assistant(tm). | ||
14 | * See http://www.dmida.com | ||
15 | * | ||
16 | */ | ||
17 | |||
18 | #include <linux/init.h> | ||
19 | |||
20 | #include <asm/machvec.h> | ||
21 | #include <asm/rtc.h> | ||
22 | #include <asm/machvec_init.h> | ||
23 | |||
24 | #include <asm/io.h> | ||
25 | #include <asm/hd64465/hd64465.h> | ||
26 | #include <asm/irq.h> | ||
27 | |||
28 | /* | ||
29 | * The Machine Vector | ||
30 | */ | ||
31 | |||
32 | struct sh_machine_vector mv_dmida __initmv = { | ||
33 | .mv_nr_irqs = HD64465_IRQ_BASE+HD64465_IRQ_NUM, | ||
34 | |||
35 | .mv_inb = hd64465_inb, | ||
36 | .mv_inw = hd64465_inw, | ||
37 | .mv_inl = hd64465_inl, | ||
38 | .mv_outb = hd64465_outb, | ||
39 | .mv_outw = hd64465_outw, | ||
40 | .mv_outl = hd64465_outl, | ||
41 | |||
42 | .mv_inb_p = hd64465_inb_p, | ||
43 | .mv_inw_p = hd64465_inw, | ||
44 | .mv_inl_p = hd64465_inl, | ||
45 | .mv_outb_p = hd64465_outb_p, | ||
46 | .mv_outw_p = hd64465_outw, | ||
47 | .mv_outl_p = hd64465_outl, | ||
48 | |||
49 | .mv_insb = hd64465_insb, | ||
50 | .mv_insw = hd64465_insw, | ||
51 | .mv_insl = hd64465_insl, | ||
52 | .mv_outsb = hd64465_outsb, | ||
53 | .mv_outsw = hd64465_outsw, | ||
54 | .mv_outsl = hd64465_outsl, | ||
55 | |||
56 | .mv_irq_demux = hd64465_irq_demux, | ||
57 | }; | ||
58 | ALIAS_MV(dmida) | ||
59 | |||
diff --git a/arch/sh/boards/harp/Makefile b/arch/sh/boards/harp/Makefile deleted file mode 100644 index eb753d31812e..000000000000 --- a/arch/sh/boards/harp/Makefile +++ /dev/null | |||
@@ -1,8 +0,0 @@ | |||
1 | # | ||
2 | # Makefile for STMicroelectronics board specific parts of the kernel | ||
3 | # | ||
4 | |||
5 | obj-y := irq.o setup.o mach.o led.o | ||
6 | |||
7 | obj-$(CONFIG_PCI) += pcidma.o | ||
8 | |||
diff --git a/arch/sh/boards/harp/irq.c b/arch/sh/boards/harp/irq.c deleted file mode 100644 index 96bb41c9fc55..000000000000 --- a/arch/sh/boards/harp/irq.c +++ /dev/null | |||
@@ -1,147 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2000 David J. Mckay (david.mckay@st.com) | ||
3 | * | ||
4 | * May be copied or modified under the terms of the GNU General Public | ||
5 | * License. See linux/COPYING for more information. | ||
6 | * | ||
7 | * Looks after interrupts on the HARP board. | ||
8 | * | ||
9 | * Bases on the IPR irq system | ||
10 | */ | ||
11 | |||
12 | #include <linux/init.h> | ||
13 | #include <linux/irq.h> | ||
14 | |||
15 | #include <asm/system.h> | ||
16 | #include <asm/io.h> | ||
17 | #include <asm/harp/harp.h> | ||
18 | |||
19 | |||
20 | #define NUM_EXTERNAL_IRQS 16 | ||
21 | |||
22 | // Early versions of the STB1 Overdrive required this nasty frig | ||
23 | //#define INVERT_INTMASK_WRITES | ||
24 | |||
25 | static void enable_harp_irq(unsigned int irq); | ||
26 | static void disable_harp_irq(unsigned int irq); | ||
27 | |||
28 | /* shutdown is same as "disable" */ | ||
29 | #define shutdown_harp_irq disable_harp_irq | ||
30 | |||
31 | static void mask_and_ack_harp(unsigned int); | ||
32 | static void end_harp_irq(unsigned int irq); | ||
33 | |||
34 | static unsigned int startup_harp_irq(unsigned int irq) | ||
35 | { | ||
36 | enable_harp_irq(irq); | ||
37 | return 0; /* never anything pending */ | ||
38 | } | ||
39 | |||
40 | static struct hw_interrupt_type harp_irq_type = { | ||
41 | .typename = "Harp-IRQ", | ||
42 | .startup = startup_harp_irq, | ||
43 | .shutdown = shutdown_harp_irq, | ||
44 | .enable = enable_harp_irq, | ||
45 | .disable = disable_harp_irq, | ||
46 | .ack = mask_and_ack_harp, | ||
47 | .end = end_harp_irq | ||
48 | }; | ||
49 | |||
50 | static void disable_harp_irq(unsigned int irq) | ||
51 | { | ||
52 | unsigned val, flags; | ||
53 | unsigned maskReg; | ||
54 | unsigned mask; | ||
55 | int pri; | ||
56 | |||
57 | if (irq < 0 || irq >= NUM_EXTERNAL_IRQS) | ||
58 | return; | ||
59 | |||
60 | pri = 15 - irq; | ||
61 | |||
62 | if (pri < 8) { | ||
63 | maskReg = EPLD_INTMASK0; | ||
64 | } else { | ||
65 | maskReg = EPLD_INTMASK1; | ||
66 | pri -= 8; | ||
67 | } | ||
68 | |||
69 | local_irq_save(flags); | ||
70 | mask = ctrl_inl(maskReg); | ||
71 | mask &= (~(1 << pri)); | ||
72 | #if defined(INVERT_INTMASK_WRITES) | ||
73 | mask ^= 0xff; | ||
74 | #endif | ||
75 | ctrl_outl(mask, maskReg); | ||
76 | local_irq_restore(flags); | ||
77 | } | ||
78 | |||
79 | static void enable_harp_irq(unsigned int irq) | ||
80 | { | ||
81 | unsigned flags; | ||
82 | unsigned maskReg; | ||
83 | unsigned mask; | ||
84 | int pri; | ||
85 | |||
86 | if (irq < 0 || irq >= NUM_EXTERNAL_IRQS) | ||
87 | return; | ||
88 | |||
89 | pri = 15 - irq; | ||
90 | |||
91 | if (pri < 8) { | ||
92 | maskReg = EPLD_INTMASK0; | ||
93 | } else { | ||
94 | maskReg = EPLD_INTMASK1; | ||
95 | pri -= 8; | ||
96 | } | ||
97 | |||
98 | local_irq_save(flags); | ||
99 | mask = ctrl_inl(maskReg); | ||
100 | |||
101 | |||
102 | mask |= (1 << pri); | ||
103 | |||
104 | #if defined(INVERT_INTMASK_WRITES) | ||
105 | mask ^= 0xff; | ||
106 | #endif | ||
107 | ctrl_outl(mask, maskReg); | ||
108 | |||
109 | local_irq_restore(flags); | ||
110 | } | ||
111 | |||
112 | /* This functions sets the desired irq handler to be an overdrive type */ | ||
113 | static void __init make_harp_irq(unsigned int irq) | ||
114 | { | ||
115 | disable_irq_nosync(irq); | ||
116 | irq_desc[irq].chip = &harp_irq_type; | ||
117 | disable_harp_irq(irq); | ||
118 | } | ||
119 | |||
120 | static void mask_and_ack_harp(unsigned int irq) | ||
121 | { | ||
122 | disable_harp_irq(irq); | ||
123 | } | ||
124 | |||
125 | static void end_harp_irq(unsigned int irq) | ||
126 | { | ||
127 | enable_harp_irq(irq); | ||
128 | } | ||
129 | |||
130 | void __init init_harp_irq(void) | ||
131 | { | ||
132 | int i; | ||
133 | |||
134 | #if !defined(INVERT_INTMASK_WRITES) | ||
135 | // On the harp these are set to enable an interrupt | ||
136 | ctrl_outl(0x00, EPLD_INTMASK0); | ||
137 | ctrl_outl(0x00, EPLD_INTMASK1); | ||
138 | #else | ||
139 | // On the Overdrive the data is inverted before being stored in the reg | ||
140 | ctrl_outl(0xff, EPLD_INTMASK0); | ||
141 | ctrl_outl(0xff, EPLD_INTMASK1); | ||
142 | #endif | ||
143 | |||
144 | for (i = 0; i < NUM_EXTERNAL_IRQS; i++) { | ||
145 | make_harp_irq(i); | ||
146 | } | ||
147 | } | ||
diff --git a/arch/sh/boards/harp/led.c b/arch/sh/boards/harp/led.c deleted file mode 100644 index aeb7b392b190..000000000000 --- a/arch/sh/boards/harp/led.c +++ /dev/null | |||
@@ -1,51 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/stboards/led.c | ||
3 | * | ||
4 | * Copyright (C) 2000 Stuart Menefy <stuart.menefy@st.com> | ||
5 | * | ||
6 | * May be copied or modified under the terms of the GNU General Public | ||
7 | * License. See linux/COPYING for more information. | ||
8 | * | ||
9 | * This file contains ST40STB1 HARP and compatible code. | ||
10 | */ | ||
11 | |||
12 | #include <asm/io.h> | ||
13 | #include <asm/harp/harp.h> | ||
14 | |||
15 | /* Harp: Flash LD10 (front pannel) connected to EPLD (IC8) */ | ||
16 | /* Overdrive: Flash LD1 (front panel) connected to EPLD (IC4) */ | ||
17 | /* Works for HARP and overdrive */ | ||
18 | static void mach_led(int position, int value) | ||
19 | { | ||
20 | if (value) { | ||
21 | ctrl_outl(EPLD_LED_ON, EPLD_LED); | ||
22 | } else { | ||
23 | ctrl_outl(EPLD_LED_OFF, EPLD_LED); | ||
24 | } | ||
25 | } | ||
26 | |||
27 | #ifdef CONFIG_HEARTBEAT | ||
28 | |||
29 | #include <linux/sched.h> | ||
30 | |||
31 | /* acts like an actual heart beat -- ie thump-thump-pause... */ | ||
32 | void heartbeat_harp(void) | ||
33 | { | ||
34 | static unsigned cnt = 0, period = 0, dist = 0; | ||
35 | |||
36 | if (cnt == 0 || cnt == dist) | ||
37 | mach_led( -1, 1); | ||
38 | else if (cnt == 7 || cnt == dist+7) | ||
39 | mach_led( -1, 0); | ||
40 | |||
41 | if (++cnt > period) { | ||
42 | cnt = 0; | ||
43 | /* The hyperbolic function below modifies the heartbeat period | ||
44 | * length in dependency of the current (5min) load. It goes | ||
45 | * through the points f(0)=126, f(1)=86, f(5)=51, | ||
46 | * f(inf)->30. */ | ||
47 | period = ((672<<FSHIFT)/(5*avenrun[0]+(7<<FSHIFT))) + 30; | ||
48 | dist = period / 4; | ||
49 | } | ||
50 | } | ||
51 | #endif | ||
diff --git a/arch/sh/boards/harp/mach.c b/arch/sh/boards/harp/mach.c deleted file mode 100644 index a946dd1674ca..000000000000 --- a/arch/sh/boards/harp/mach.c +++ /dev/null | |||
@@ -1,62 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/boards/harp/mach.c | ||
3 | * | ||
4 | * Copyright (C) 2000 Stuart Menefy (stuart.menefy@st.com) | ||
5 | * | ||
6 | * May be copied or modified under the terms of the GNU General Public | ||
7 | * License. See linux/COPYING for more information. | ||
8 | * | ||
9 | * Machine vector for the STMicroelectronics STB1 HARP and compatible boards | ||
10 | */ | ||
11 | |||
12 | #include <linux/init.h> | ||
13 | |||
14 | #include <asm/machvec.h> | ||
15 | #include <asm/rtc.h> | ||
16 | #include <asm/machvec_init.h> | ||
17 | #include <asm/hd64465/io.h> | ||
18 | #include <asm/hd64465/hd64465.h> | ||
19 | |||
20 | void setup_harp(void); | ||
21 | void init_harp_irq(void); | ||
22 | void heartbeat_harp(void); | ||
23 | |||
24 | /* | ||
25 | * The Machine Vector | ||
26 | */ | ||
27 | |||
28 | struct sh_machine_vector mv_harp __initmv = { | ||
29 | .mv_nr_irqs = 89 + HD64465_IRQ_NUM, | ||
30 | |||
31 | .mv_inb = hd64465_inb, | ||
32 | .mv_inw = hd64465_inw, | ||
33 | .mv_inl = hd64465_inl, | ||
34 | .mv_outb = hd64465_outb, | ||
35 | .mv_outw = hd64465_outw, | ||
36 | .mv_outl = hd64465_outl, | ||
37 | |||
38 | .mv_inb_p = hd64465_inb_p, | ||
39 | .mv_inw_p = hd64465_inw, | ||
40 | .mv_inl_p = hd64465_inl, | ||
41 | .mv_outb_p = hd64465_outb_p, | ||
42 | .mv_outw_p = hd64465_outw, | ||
43 | .mv_outl_p = hd64465_outl, | ||
44 | |||
45 | .mv_insb = hd64465_insb, | ||
46 | .mv_insw = hd64465_insw, | ||
47 | .mv_insl = hd64465_insl, | ||
48 | .mv_outsb = hd64465_outsb, | ||
49 | .mv_outsw = hd64465_outsw, | ||
50 | .mv_outsl = hd64465_outsl, | ||
51 | |||
52 | .mv_isa_port2addr = hd64465_isa_port2addr, | ||
53 | |||
54 | #ifdef CONFIG_PCI | ||
55 | .mv_init_irq = init_harp_irq, | ||
56 | #endif | ||
57 | #ifdef CONFIG_HEARTBEAT | ||
58 | .mv_heartbeat = heartbeat_harp, | ||
59 | #endif | ||
60 | }; | ||
61 | |||
62 | ALIAS_MV(harp) | ||
diff --git a/arch/sh/boards/harp/pcidma.c b/arch/sh/boards/harp/pcidma.c deleted file mode 100644 index 475311390fd6..000000000000 --- a/arch/sh/boards/harp/pcidma.c +++ /dev/null | |||
@@ -1,42 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2001 David J. Mckay (david.mckay@st.com) | ||
3 | * | ||
4 | * May be copied or modified under the terms of the GNU General Public | ||
5 | * License. See linux/COPYING for more information. | ||
6 | * | ||
7 | * Dynamic DMA mapping support. | ||
8 | */ | ||
9 | |||
10 | #include <linux/types.h> | ||
11 | #include <linux/mm.h> | ||
12 | #include <linux/string.h> | ||
13 | #include <linux/pci.h> | ||
14 | #include <asm/io.h> | ||
15 | #include <asm/addrspace.h> | ||
16 | |||
17 | |||
18 | void *pci_alloc_consistent(struct pci_dev *hwdev, size_t size, | ||
19 | dma_addr_t * dma_handle) | ||
20 | { | ||
21 | void *ret; | ||
22 | int gfp = GFP_ATOMIC; | ||
23 | |||
24 | ret = (void *) __get_free_pages(gfp, get_order(size)); | ||
25 | |||
26 | if (ret != NULL) { | ||
27 | /* Is it neccessary to do the memset? */ | ||
28 | memset(ret, 0, size); | ||
29 | *dma_handle = virt_to_bus(ret); | ||
30 | } | ||
31 | /* We must flush the cache before we pass it on to the device */ | ||
32 | flush_cache_all(); | ||
33 | return P2SEGADDR(ret); | ||
34 | } | ||
35 | |||
36 | void pci_free_consistent(struct pci_dev *hwdev, size_t size, | ||
37 | void *vaddr, dma_addr_t dma_handle) | ||
38 | { | ||
39 | unsigned long p1addr=P1SEGADDR((unsigned long)vaddr); | ||
40 | |||
41 | free_pages(p1addr, get_order(size)); | ||
42 | } | ||
diff --git a/arch/sh/boards/harp/setup.c b/arch/sh/boards/harp/setup.c deleted file mode 100644 index 886e450ab63e..000000000000 --- a/arch/sh/boards/harp/setup.c +++ /dev/null | |||
@@ -1,90 +0,0 @@ | |||
1 | /* | ||
2 | * arch/sh/stboard/setup.c | ||
3 | * | ||
4 | * Copyright (C) 2001 Stuart Menefy (stuart.menefy@st.com) | ||
5 | * | ||
6 | * May be copied or modified under the terms of the GNU General Public | ||
7 | * License. See linux/COPYING for more information. | ||
8 | * | ||
9 | * STMicroelectronics ST40STB1 HARP and compatible support. | ||
10 | */ | ||
11 | |||
12 | #include <linux/kernel.h> | ||
13 | #include <linux/init.h> | ||
14 | #include <asm/io.h> | ||
15 | #include <asm/harp/harp.h> | ||
16 | |||
17 | const char *get_system_type(void) | ||
18 | { | ||
19 | return "STB1 Harp"; | ||
20 | } | ||
21 | |||
22 | /* | ||
23 | * Initialize the board | ||
24 | */ | ||
25 | int __init platform_setup(void) | ||
26 | { | ||
27 | #ifdef CONFIG_SH_STB1_HARP | ||
28 | unsigned long ic8_version, ic36_version; | ||
29 | |||
30 | ic8_version = ctrl_inl(EPLD_REVID2); | ||
31 | ic36_version = ctrl_inl(EPLD_REVID1); | ||
32 | |||
33 | printk("STMicroelectronics STB1 HARP initialisaton\n"); | ||
34 | printk("EPLD versions: IC8: %d.%02d, IC36: %d.%02d\n", | ||
35 | (ic8_version >> 4) & 0xf, ic8_version & 0xf, | ||
36 | (ic36_version >> 4) & 0xf, ic36_version & 0xf); | ||
37 | #elif defined(CONFIG_SH_STB1_OVERDRIVE) | ||
38 | unsigned long version; | ||
39 | |||
40 | version = ctrl_inl(EPLD_REVID); | ||
41 | |||
42 | printk("STMicroelectronics STB1 Overdrive initialisaton\n"); | ||
43 | printk("EPLD version: %d.%02d\n", | ||
44 | (version >> 4) & 0xf, version & 0xf); | ||
45 | #else | ||
46 | #error Undefined machine | ||
47 | #endif | ||
48 | |||
49 | /* Currently all STB1 chips have problems with the sleep instruction, | ||
50 | * so disable it here. | ||
51 | */ | ||
52 | disable_hlt(); | ||
53 | |||
54 | return 0; | ||
55 | } | ||
56 | |||
57 | /* | ||
58 | * pcibios_map_platform_irq | ||
59 | * | ||
60 | * This is board specific and returns the IRQ for a given PCI device. | ||
61 | * It is used by the PCI code (arch/sh/kernel/st40_pci*) | ||
62 | * | ||
63 | */ | ||
64 | |||
65 | #define HARP_PCI_IRQ 1 | ||
66 | #define HARP_BRIDGE_IRQ 2 | ||
67 | #define OVERDRIVE_SLOT0_IRQ 0 | ||
68 | |||
69 | |||
70 | int __init pcibios_map_platform_irq(struct pci_dev *dev, u8 slot, u8 pin) | ||
71 | { | ||
72 | switch (slot) { | ||
73 | #ifdef CONFIG_SH_STB1_HARP | ||
74 | case 2: /*This is the PCI slot on the */ | ||
75 | return HARP_PCI_IRQ; | ||
76 | case 1: /* this is the bridge */ | ||
77 | return HARP_BRIDGE_IRQ; | ||
78 | #elif defined(CONFIG_SH_STB1_OVERDRIVE) | ||
79 | case 1: | ||
80 | case 2: | ||
81 | case 3: | ||
82 | return slot - 1; | ||
83 | #else | ||
84 | #error Unknown board | ||
85 | #endif | ||
86 | default: | ||
87 | return -1; | ||
88 | } | ||
89 | } | ||
90 | |||
diff --git a/arch/sh/boards/overdrive/Makefile b/arch/sh/boards/overdrive/Makefile deleted file mode 100644 index 245f03baf762..000000000000 --- a/arch/sh/boards/overdrive/Makefile +++ /dev/null | |||
@@ -1,8 +0,0 @@ | |||
1 | # | ||
2 | # Makefile for the STMicroelectronics Overdrive specific parts of the kernel | ||
3 | # | ||
4 | |||
5 | obj-y := mach.o setup.o io.o irq.o led.o | ||
6 | |||
7 | obj-$(CONFIG_PCI) += fpga.o galileo.o pcidma.o | ||
8 | |||
diff --git a/arch/sh/boards/overdrive/fpga.c b/arch/sh/boards/overdrive/fpga.c deleted file mode 100644 index 956c23901228..000000000000 --- a/arch/sh/boards/overdrive/fpga.c +++ /dev/null | |||
@@ -1,133 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2000 David J. Mckay (david.mckay@st.com) | ||
3 | * | ||
4 | * May be copied or modified under the terms of the GNU General Public | ||
5 | * License. See linux/COPYING for more information. | ||
6 | * | ||
7 | * This file handles programming up the Altera Flex10K that interfaces to | ||
8 | * the Galileo, and does the PS/2 keyboard and mouse | ||
9 | * | ||
10 | */ | ||
11 | |||
12 | |||
13 | #include <linux/kernel.h> | ||
14 | #include <linux/smp.h> | ||
15 | #include <linux/smp_lock.h> | ||
16 | #include <linux/init.h> | ||
17 | #include <linux/errno.h> | ||
18 | #include <linux/pci.h> | ||
19 | #include <linux/delay.h> | ||
20 | |||
21 | |||
22 | #include <asm/overdriver/gt64111.h> | ||
23 | #include <asm/overdrive/overdrive.h> | ||
24 | #include <asm/overdrive/fpga.h> | ||
25 | |||
26 | #define FPGA_NotConfigHigh() (*FPGA_ControlReg) = (*FPGA_ControlReg) | ENABLE_FPGA_BIT | ||
27 | #define FPGA_NotConfigLow() (*FPGA_ControlReg) = (*FPGA_ControlReg) & RESET_FPGA_MASK | ||
28 | |||
29 | /* I need to find out what (if any) the real delay factor here is */ | ||
30 | /* The delay is definately not critical */ | ||
31 | #define long_delay() {int i;for(i=0;i<10000;i++);} | ||
32 | #define short_delay() {int i;for(i=0;i<100;i++);} | ||
33 | |||
34 | static void __init program_overdrive_fpga(const unsigned char *fpgacode, | ||
35 | int size) | ||
36 | { | ||
37 | int timeout = 0; | ||
38 | int i, j; | ||
39 | unsigned char b; | ||
40 | static volatile unsigned char *FPGA_ControlReg = | ||
41 | (volatile unsigned char *) (OVERDRIVE_CTRL); | ||
42 | static volatile unsigned char *FPGA_ProgramReg = | ||
43 | (volatile unsigned char *) (FPGA_DCLK_ADDRESS); | ||
44 | |||
45 | printk("FPGA: Commencing FPGA Programming\n"); | ||
46 | |||
47 | /* The PCI reset but MUST be low when programming the FPGA !!! */ | ||
48 | b = (*FPGA_ControlReg) & RESET_PCI_MASK; | ||
49 | |||
50 | (*FPGA_ControlReg) = b; | ||
51 | |||
52 | /* Prepare FPGA to program */ | ||
53 | |||
54 | FPGA_NotConfigHigh(); | ||
55 | long_delay(); | ||
56 | |||
57 | FPGA_NotConfigLow(); | ||
58 | short_delay(); | ||
59 | |||
60 | while ((*FPGA_ProgramReg & FPGA_NOT_STATUS) != 0) { | ||
61 | printk("FPGA: Waiting for NotStatus to go Low ... \n"); | ||
62 | } | ||
63 | |||
64 | FPGA_NotConfigHigh(); | ||
65 | |||
66 | /* Wait for FPGA "ready to be programmed" signal */ | ||
67 | printk("FPGA: Waiting for NotStatus to go high (FPGA ready)... \n"); | ||
68 | |||
69 | for (timeout = 0; | ||
70 | (((*FPGA_ProgramReg & FPGA_NOT_STATUS) == 0) | ||
71 | && (timeout < FPGA_TIMEOUT)); timeout++); | ||
72 | |||
73 | /* Check if timeout condition occured - i.e. an error */ | ||
74 | |||
75 | if (timeout == FPGA_TIMEOUT) { | ||
76 | printk | ||
77 | ("FPGA: Failed to program - Timeout waiting for notSTATUS to go high\n"); | ||
78 | return; | ||
79 | } | ||
80 | |||
81 | printk("FPGA: Copying data to FPGA ... %d bytes\n", size); | ||
82 | |||
83 | /* Copy array to FPGA - bit at a time */ | ||
84 | |||
85 | for (i = 0; i < size; i++) { | ||
86 | volatile unsigned w = 0; | ||
87 | |||
88 | for (j = 0; j < 8; j++) { | ||
89 | *FPGA_ProgramReg = (fpgacode[i] >> j) & 0x01; | ||
90 | short_delay(); | ||
91 | } | ||
92 | if ((i & 0x3ff) == 0) { | ||
93 | printk("."); | ||
94 | } | ||
95 | } | ||
96 | |||
97 | /* Waiting for CONFDONE to go high - means the program is complete */ | ||
98 | |||
99 | for (timeout = 0; | ||
100 | (((*FPGA_ProgramReg & FPGA_CONFDONE) == 0) | ||
101 | && (timeout < FPGA_TIMEOUT)); timeout++) { | ||
102 | |||
103 | *FPGA_ProgramReg = 0x0; | ||
104 | long_delay(); | ||
105 | } | ||
106 | |||
107 | if (timeout == FPGA_TIMEOUT) { | ||
108 | printk | ||
109 | ("FPGA: Failed to program - Timeout waiting for CONFDONE to go high\n"); | ||
110 | return; | ||
111 | } else { /* Clock another 10 times - gets the device into a working state */ | ||
112 | for (i = 0; i < 10; i++) { | ||
113 | *FPGA_ProgramReg = 0x0; | ||
114 | short_delay(); | ||
115 | } | ||
116 | } | ||
117 | |||
118 | printk("FPGA: Programming complete\n"); | ||
119 | } | ||
120 | |||
121 | |||
122 | static const unsigned char __init fpgacode[] = { | ||
123 | #include "./overdrive.ttf" /* Code from maxplus2 compiler */ | ||
124 | , 0, 0 | ||
125 | }; | ||
126 | |||
127 | |||
128 | int __init init_overdrive_fpga(void) | ||
129 | { | ||
130 | program_overdrive_fpga(fpgacode, sizeof(fpgacode)); | ||
131 | |||
132 | return 0; | ||
133 | } | ||
diff --git a/arch/sh/boards/overdrive/galileo.c b/arch/sh/boards/overdrive/galileo.c deleted file mode 100644 index 29e48971bba0..000000000000 --- a/arch/sh/boards/overdrive/galileo.c +++ /dev/null | |||
@@ -1,587 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2000 David J. Mckay (david.mckay@st.com) | ||
3 | * | ||
4 | * May be copied or modified under the terms of the GNU General Public | ||
5 | * License. See linux/COPYING for more information. | ||
6 | * | ||
7 | * This file contains the PCI routines required for the Galileo GT6411 | ||
8 | * PCI bridge as used on the Orion and Overdrive boards. | ||
9 | * | ||
10 | */ | ||
11 | |||
12 | #include <linux/kernel.h> | ||
13 | #include <linux/smp.h> | ||
14 | #include <linux/smp_lock.h> | ||
15 | #include <linux/init.h> | ||
16 | #include <linux/errno.h> | ||
17 | #include <linux/pci.h> | ||
18 | #include <linux/delay.h> | ||
19 | #include <linux/types.h> | ||
20 | #include <linux/ioport.h> | ||
21 | |||
22 | #include <asm/overdrive/overdrive.h> | ||
23 | #include <asm/overdrive/gt64111.h> | ||
24 | |||
25 | |||
26 | /* After boot, we shift the Galileo registers so that they appear | ||
27 | * in BANK6, along with IO space. This means we can have one contingous | ||
28 | * lump of PCI address space without these registers appearing in the | ||
29 | * middle of them | ||
30 | */ | ||
31 | |||
32 | #define GT64111_BASE_ADDRESS 0xbb000000 | ||
33 | #define GT64111_IO_BASE_ADDRESS 0x1000 | ||
34 | /* The GT64111 registers appear at this address to the SH4 after reset */ | ||
35 | #define RESET_GT64111_BASE_ADDRESS 0xb4000000 | ||
36 | |||
37 | /* Macros used to access the Galileo registers */ | ||
38 | #define RESET_GT64111_REG(x) (RESET_GT64111_BASE_ADDRESS+x) | ||
39 | #define GT64111_REG(x) (GT64111_BASE_ADDRESS+x) | ||
40 | |||
41 | #define RESET_GT_WRITE(x,v) writel((v),RESET_GT64111_REG(x)) | ||
42 | |||
43 | #define RESET_GT_READ(x) readl(RESET_GT64111_REG(x)) | ||
44 | |||
45 | #define GT_WRITE(x,v) writel((v),GT64111_REG(x)) | ||
46 | #define GT_WRITE_BYTE(x,v) writeb((v),GT64111_REG(x)) | ||
47 | #define GT_WRITE_SHORT(x,v) writew((v),GT64111_REG(x)) | ||
48 | |||
49 | #define GT_READ(x) readl(GT64111_REG(x)) | ||
50 | #define GT_READ_BYTE(x) readb(GT64111_REG(x)) | ||
51 | #define GT_READ_SHORT(x) readw(GT64111_REG(x)) | ||
52 | |||
53 | |||
54 | /* Where the various SH banks start at */ | ||
55 | #define SH_BANK4_ADR 0xb0000000 | ||
56 | #define SH_BANK5_ADR 0xb4000000 | ||
57 | #define SH_BANK6_ADR 0xb8000000 | ||
58 | |||
59 | /* Masks out everything but lines 28,27,26 */ | ||
60 | #define BANK_SELECT_MASK 0x1c000000 | ||
61 | |||
62 | #define SH4_TO_BANK(x) ( (x) & BANK_SELECT_MASK) | ||
63 | |||
64 | /* | ||
65 | * Masks used for address conversaion. Bank 6 is used for IO and | ||
66 | * has all the address bits zeroed by the FPGA. Special case this | ||
67 | */ | ||
68 | #define MEMORY_BANK_MASK 0x1fffffff | ||
69 | #define IO_BANK_MASK 0x03ffffff | ||
70 | |||
71 | /* Mark bank 6 as the bank used for IO. You can change this in the FPGA code | ||
72 | * if you want | ||
73 | */ | ||
74 | #define IO_BANK_ADR PCI_GTIO_BASE | ||
75 | |||
76 | /* Will select the correct mask to apply depending on the SH$ address */ | ||
77 | #define SELECT_BANK_MASK(x) \ | ||
78 | ( (SH4_TO_BANK(x)==SH4_TO_BANK(IO_BANK_ADR)) ? IO_BANK_MASK : MEMORY_BANK_MASK) | ||
79 | |||
80 | /* Converts between PCI space and P2 region */ | ||
81 | #define SH4_TO_PCI(x) ((x)&SELECT_BANK_MASK(x)) | ||
82 | |||
83 | /* Various macros for figuring out what to stick in the Galileo registers. | ||
84 | * You *really* don't want to figure this stuff out by hand, you always get | ||
85 | * it wrong | ||
86 | */ | ||
87 | #define GT_MEM_LO_ADR(x) ((((unsigned)((x)&SELECT_BANK_MASK(x)))>>21)&0x7ff) | ||
88 | #define GT_MEM_HI_ADR(x) ((((unsigned)((x)&SELECT_BANK_MASK(x)))>>21)&0x7f) | ||
89 | #define GT_MEM_SUB_ADR(x) ((((unsigned)((x)&SELECT_BANK_MASK(x)))>>20)&0xff) | ||
90 | |||
91 | #define PROGRAM_HI_LO(block,a,s) \ | ||
92 | GT_WRITE(block##_LO_DEC_ADR,GT_MEM_LO_ADR(a));\ | ||
93 | GT_WRITE(block##_HI_DEC_ADR,GT_MEM_HI_ADR(a+s-1)) | ||
94 | |||
95 | #define PROGRAM_SUB_HI_LO(block,a,s) \ | ||
96 | GT_WRITE(block##_LO_DEC_ADR,GT_MEM_SUB_ADR(a));\ | ||
97 | GT_WRITE(block##_HI_DEC_ADR,GT_MEM_SUB_ADR(a+s-1)) | ||
98 | |||
99 | /* We need to set the size, and the offset register */ | ||
100 | |||
101 | #define GT_BAR_MASK(x) ((x)&~0xfff) | ||
102 | |||
103 | /* Macro to set up the BAR in the Galileo. Essentially used for the DRAM */ | ||
104 | #define PROGRAM_GT_BAR(block,a,s) \ | ||
105 | GT_WRITE(PCI_##block##_BANK_SIZE,GT_BAR_MASK((s-1)));\ | ||
106 | write_config_to_galileo(PCI_CONFIG_##block##_BASE_ADR,\ | ||
107 | GT_BAR_MASK(a)) | ||
108 | |||
109 | #define DISABLE_GT_BAR(block) \ | ||
110 | GT_WRITE(PCI_##block##_BANK_SIZE,0),\ | ||
111 | GT_CONFIG_WRITE(PCI_CONFIG_##block##_BASE_ADR,\ | ||
112 | 0x80000000) | ||
113 | |||
114 | /* Macros to disable things we are not going to use */ | ||
115 | #define DISABLE_DECODE(x) GT_WRITE(x##_LO_DEC_ADR,0x7ff);\ | ||
116 | GT_WRITE(x##_HI_DEC_ADR,0x00) | ||
117 | |||
118 | #define DISABLE_SUB_DECODE(x) GT_WRITE(x##_LO_DEC_ADR,0xff);\ | ||
119 | GT_WRITE(x##_HI_DEC_ADR,0x00) | ||
120 | |||
121 | static void __init reset_pci(void) | ||
122 | { | ||
123 | /* Set RESET_PCI bit high */ | ||
124 | writeb(readb(OVERDRIVE_CTRL) | ENABLE_PCI_BIT, OVERDRIVE_CTRL); | ||
125 | udelay(250); | ||
126 | |||
127 | /* Set RESET_PCI bit low */ | ||
128 | writeb(readb(OVERDRIVE_CTRL) & RESET_PCI_MASK, OVERDRIVE_CTRL); | ||
129 | udelay(250); | ||
130 | |||
131 | writeb(readb(OVERDRIVE_CTRL) | ENABLE_PCI_BIT, OVERDRIVE_CTRL); | ||
132 | udelay(250); | ||
133 | } | ||
134 | |||
135 | static int write_config_to_galileo(int where, u32 val); | ||
136 | #define GT_CONFIG_WRITE(where,val) write_config_to_galileo(where,val) | ||
137 | |||
138 | #define ENABLE_PCI_DRAM | ||
139 | |||
140 | |||
141 | #ifdef TEST_DRAM | ||
142 | /* Test function to check out if the PCI DRAM is working OK */ | ||
143 | static int /* __init */ test_dram(unsigned *base, unsigned size) | ||
144 | { | ||
145 | unsigned *p = base; | ||
146 | unsigned *end = (unsigned *) (((unsigned) base) + size); | ||
147 | unsigned w; | ||
148 | |||
149 | for (p = base; p < end; p++) { | ||
150 | *p = 0xffffffff; | ||
151 | if (*p != 0xffffffff) { | ||
152 | printk("AAARGH -write failed!!! at %p is %x\n", p, | ||
153 | *p); | ||
154 | return 0; | ||
155 | } | ||
156 | *p = 0x0; | ||
157 | if (*p != 0x0) { | ||
158 | printk("AAARGH -write failed!!!\n"); | ||
159 | return 0; | ||
160 | } | ||
161 | } | ||
162 | |||
163 | for (p = base; p < end; p++) { | ||
164 | *p = (unsigned) p; | ||
165 | if (*p != (unsigned) p) { | ||
166 | printk("Failed at 0x%p, actually is 0x%x\n", p, | ||
167 | *p); | ||
168 | return 0; | ||
169 | } | ||
170 | } | ||
171 | |||
172 | for (p = base; p < end; p++) { | ||
173 | w = ((unsigned) p & 0xffff0000); | ||
174 | *p = w | (w >> 16); | ||
175 | } | ||
176 | |||
177 | for (p = base; p < end; p++) { | ||
178 | w = ((unsigned) p & 0xffff0000); | ||
179 | w |= (w >> 16); | ||
180 | if (*p != w) { | ||
181 | printk | ||
182 | ("Failed at 0x%p, should be 0x%x actually is 0x%x\n", | ||
183 | p, w, *p); | ||
184 | return 0; | ||
185 | } | ||
186 | } | ||
187 | |||
188 | return 1; | ||
189 | } | ||
190 | #endif | ||
191 | |||
192 | |||
193 | /* Function to set up and initialise the galileo. This sets up the BARS, | ||
194 | * maps the DRAM into the address space etc,etc | ||
195 | */ | ||
196 | int __init galileo_init(void) | ||
197 | { | ||
198 | reset_pci(); | ||
199 | |||
200 | /* Now shift the galileo regs into this block */ | ||
201 | RESET_GT_WRITE(INTERNAL_SPACE_DEC, | ||
202 | GT_MEM_LO_ADR(GT64111_BASE_ADDRESS)); | ||
203 | |||
204 | /* Should have a sanity check here, that you can read back at the new | ||
205 | * address what you just wrote | ||
206 | */ | ||
207 | |||
208 | /* Disable decode for all regions */ | ||
209 | DISABLE_DECODE(RAS10); | ||
210 | DISABLE_DECODE(RAS32); | ||
211 | DISABLE_DECODE(CS20); | ||
212 | DISABLE_DECODE(CS3); | ||
213 | DISABLE_DECODE(PCI_IO); | ||
214 | DISABLE_DECODE(PCI_MEM0); | ||
215 | DISABLE_DECODE(PCI_MEM1); | ||
216 | |||
217 | /* Disable all BARS */ | ||
218 | GT_WRITE(BAR_ENABLE_ADR, 0x1ff); | ||
219 | DISABLE_GT_BAR(RAS10); | ||
220 | DISABLE_GT_BAR(RAS32); | ||
221 | DISABLE_GT_BAR(CS20); | ||
222 | DISABLE_GT_BAR(CS3); | ||
223 | |||
224 | /* Tell the BAR where the IO registers now are */ | ||
225 | GT_CONFIG_WRITE(PCI_CONFIG_INT_REG_IO_ADR,GT_BAR_MASK( | ||
226 | (GT64111_IO_BASE_ADDRESS & | ||
227 | IO_BANK_MASK))); | ||
228 | /* set up a 112 Mb decode */ | ||
229 | PROGRAM_HI_LO(PCI_MEM0, SH_BANK4_ADR, 112 * 1024 * 1024); | ||
230 | |||
231 | /* Set up a 32 MB io space decode */ | ||
232 | PROGRAM_HI_LO(PCI_IO, IO_BANK_ADR, 32 * 1024 * 1024); | ||
233 | |||
234 | #ifdef ENABLE_PCI_DRAM | ||
235 | /* Program up the DRAM configuration - there is DRAM only in bank 0 */ | ||
236 | /* Now set up the DRAM decode */ | ||
237 | PROGRAM_HI_LO(RAS10, PCI_DRAM_BASE, PCI_DRAM_SIZE); | ||
238 | /* And the sub decode */ | ||
239 | PROGRAM_SUB_HI_LO(RAS0, PCI_DRAM_BASE, PCI_DRAM_SIZE); | ||
240 | |||
241 | DISABLE_SUB_DECODE(RAS1); | ||
242 | |||
243 | /* Set refresh rate */ | ||
244 | GT_WRITE(DRAM_BANK0_PARMS, 0x3f); | ||
245 | GT_WRITE(DRAM_CFG, 0x100); | ||
246 | |||
247 | /* we have to lob off the top bits rememeber!! */ | ||
248 | PROGRAM_GT_BAR(RAS10, SH4_TO_PCI(PCI_DRAM_BASE), PCI_DRAM_SIZE); | ||
249 | |||
250 | #endif | ||
251 | |||
252 | /* We are only interested in decoding RAS10 and the Galileo's internal | ||
253 | * registers (as IO) on the PCI bus | ||
254 | */ | ||
255 | #ifdef ENABLE_PCI_DRAM | ||
256 | GT_WRITE(BAR_ENABLE_ADR, (~((1 << 8) | (1 << 3))) & 0x1ff); | ||
257 | #else | ||
258 | GT_WRITE(BAR_ENABLE_ADR, (~(1 << 3)) & 0x1ff); | ||
259 | #endif | ||
260 | |||
261 | /* Change the class code to host bridge, it actually powers up | ||
262 | * as a memory controller | ||
263 | */ | ||
264 | GT_CONFIG_WRITE(8, 0x06000011); | ||
265 | |||
266 | /* Allow the galileo to master the PCI bus */ | ||
267 | GT_CONFIG_WRITE(PCI_COMMAND, | ||
268 | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER | | ||
269 | PCI_COMMAND_IO); | ||
270 | |||
271 | |||
272 | #if 0 | ||
273 | printk("Testing PCI DRAM - "); | ||
274 | if(test_dram(PCI_DRAM_BASE,PCI_DRAM_SIZE)) { | ||
275 | printk("Passed\n"); | ||
276 | }else { | ||
277 | printk("FAILED\n"); | ||
278 | } | ||
279 | #endif | ||
280 | return 0; | ||
281 | |||
282 | } | ||
283 | |||
284 | |||
285 | #define SET_CONFIG_BITS(bus,devfn,where)\ | ||
286 | ((1<<31) | ((bus) << 16) | ((devfn) << 8) | ((where) & ~3)) | ||
287 | |||
288 | #define CONFIG_CMD(dev, where) SET_CONFIG_BITS((dev)->bus->number,(dev)->devfn,where) | ||
289 | |||
290 | /* This write to the galileo config registers, unlike the functions below, can | ||
291 | * be used before the PCI subsystem has started up | ||
292 | */ | ||
293 | static int __init write_config_to_galileo(int where, u32 val) | ||
294 | { | ||
295 | GT_WRITE(PCI_CFG_ADR, SET_CONFIG_BITS(0, 0, where)); | ||
296 | |||
297 | GT_WRITE(PCI_CFG_DATA, val); | ||
298 | return 0; | ||
299 | } | ||
300 | |||
301 | /* We exclude the galileo and slot 31, the galileo because I don't know how to stop | ||
302 | * the setup code shagging up the setup I have done on it, and 31 because the whole | ||
303 | * thing locks up if you try to access that slot (which doesn't exist of course anyway | ||
304 | */ | ||
305 | |||
306 | #define EXCLUDED_DEV(dev) ((dev->bus->number==0) && ((PCI_SLOT(dev->devfn)==0) || (PCI_SLOT(dev->devfn) == 31))) | ||
307 | |||
308 | static int galileo_read_config_byte(struct pci_dev *dev, int where, | ||
309 | u8 * val) | ||
310 | { | ||
311 | |||
312 | |||
313 | /* I suspect this doesn't work because this drives a special cycle ? */ | ||
314 | if (EXCLUDED_DEV(dev)) { | ||
315 | *val = 0xff; | ||
316 | return PCIBIOS_SUCCESSFUL; | ||
317 | } | ||
318 | /* Start the config cycle */ | ||
319 | GT_WRITE(PCI_CFG_ADR, CONFIG_CMD(dev, where)); | ||
320 | /* Read back the result */ | ||
321 | *val = GT_READ_BYTE(PCI_CFG_DATA + (where & 3)); | ||
322 | |||
323 | return PCIBIOS_SUCCESSFUL; | ||
324 | } | ||
325 | |||
326 | |||
327 | static int galileo_read_config_word(struct pci_dev *dev, int where, | ||
328 | u16 * val) | ||
329 | { | ||
330 | |||
331 | if (EXCLUDED_DEV(dev)) { | ||
332 | *val = 0xffff; | ||
333 | return PCIBIOS_SUCCESSFUL; | ||
334 | } | ||
335 | |||
336 | GT_WRITE(PCI_CFG_ADR, CONFIG_CMD(dev, where)); | ||
337 | *val = GT_READ_SHORT(PCI_CFG_DATA + (where & 2)); | ||
338 | |||
339 | return PCIBIOS_SUCCESSFUL; | ||
340 | } | ||
341 | |||
342 | |||
343 | static int galileo_read_config_dword(struct pci_dev *dev, int where, | ||
344 | u32 * val) | ||
345 | { | ||
346 | if (EXCLUDED_DEV(dev)) { | ||
347 | *val = 0xffffffff; | ||
348 | return PCIBIOS_SUCCESSFUL; | ||
349 | } | ||
350 | |||
351 | GT_WRITE(PCI_CFG_ADR, CONFIG_CMD(dev, where)); | ||
352 | *val = GT_READ(PCI_CFG_DATA); | ||
353 | |||
354 | return PCIBIOS_SUCCESSFUL; | ||
355 | } | ||
356 | |||
357 | static int galileo_write_config_byte(struct pci_dev *dev, int where, | ||
358 | u8 val) | ||
359 | { | ||
360 | GT_WRITE(PCI_CFG_ADR, CONFIG_CMD(dev, where)); | ||
361 | |||
362 | GT_WRITE_BYTE(PCI_CFG_DATA + (where & 3), val); | ||
363 | |||
364 | return PCIBIOS_SUCCESSFUL; | ||
365 | } | ||
366 | |||
367 | |||
368 | static int galileo_write_config_word(struct pci_dev *dev, int where, | ||
369 | u16 val) | ||
370 | { | ||
371 | GT_WRITE(PCI_CFG_ADR, CONFIG_CMD(dev, where)); | ||
372 | |||
373 | GT_WRITE_SHORT(PCI_CFG_DATA + (where & 2), val); | ||
374 | |||
375 | return PCIBIOS_SUCCESSFUL; | ||
376 | } | ||
377 | |||
378 | static int galileo_write_config_dword(struct pci_dev *dev, int where, | ||
379 | u32 val) | ||
380 | { | ||
381 | GT_WRITE(PCI_CFG_ADR, CONFIG_CMD(dev, where)); | ||
382 | |||
383 | GT_WRITE(PCI_CFG_DATA, val); | ||
384 | |||
385 | return PCIBIOS_SUCCESSFUL; | ||
386 | } | ||
387 | |||
388 | static struct pci_ops pci_config_ops = { | ||
389 | galileo_read_config_byte, | ||
390 | galileo_read_config_word, | ||
391 | galileo_read_config_dword, | ||
392 | galileo_write_config_byte, | ||
393 | galileo_write_config_word, | ||
394 | galileo_write_config_dword | ||
395 | }; | ||
396 | |||
397 | |||
398 | /* Everything hangs off this */ | ||
399 | static struct pci_bus *pci_root_bus; | ||
400 | |||
401 | |||
402 | static u8 __init no_swizzle(struct pci_dev *dev, u8 * pin) | ||
403 | { | ||
404 | return PCI_SLOT(dev->devfn); | ||
405 | } | ||
406 | |||
407 | static int __init map_od_irq(struct pci_dev *dev, u8 slot, u8 pin) | ||
408 | { | ||
409 | /* Slot 1: Galileo | ||
410 | * Slot 2: PCI Slot 1 | ||
411 | * Slot 3: PCI Slot 2 | ||
412 | * Slot 4: ESS | ||
413 | */ | ||
414 | switch (slot) { | ||
415 | case 2: | ||
416 | return OVERDRIVE_PCI_IRQ1; | ||
417 | case 3: | ||
418 | /* Note this assumes you have a hacked card in slot 2 */ | ||
419 | return OVERDRIVE_PCI_IRQ2; | ||
420 | case 4: | ||
421 | return OVERDRIVE_ESS_IRQ; | ||
422 | default: | ||
423 | /* printk("PCI: Unexpected IRQ mapping request for slot %d\n", slot); */ | ||
424 | return -1; | ||
425 | } | ||
426 | } | ||
427 | |||
428 | |||
429 | |||
430 | void __init | ||
431 | pcibios_fixup_pbus_ranges(struct pci_bus *bus, struct pbus_set_ranges_data *ranges) | ||
432 | { | ||
433 | ranges->io_start -= bus->resource[0]->start; | ||
434 | ranges->io_end -= bus->resource[0]->start; | ||
435 | ranges->mem_start -= bus->resource[1]->start; | ||
436 | ranges->mem_end -= bus->resource[1]->start; | ||
437 | } | ||
438 | |||
439 | static void __init pci_fixup_ide_bases(struct pci_dev *d) | ||
440 | { | ||
441 | int i; | ||
442 | |||
443 | /* | ||
444 | * PCI IDE controllers use non-standard I/O port decoding, respect it. | ||
445 | */ | ||
446 | if ((d->class >> 8) != PCI_CLASS_STORAGE_IDE) | ||
447 | return; | ||
448 | printk("PCI: IDE base address fixup for %s\n", pci_name(d)); | ||
449 | for(i=0; i<4; i++) { | ||
450 | struct resource *r = &d->resource[i]; | ||
451 | if ((r->start & ~0x80) == 0x374) { | ||
452 | r->start |= 2; | ||
453 | r->end = r->start; | ||
454 | } | ||
455 | } | ||
456 | } | ||
457 | DECLARE_PCI_FIXUP_HEADER(PCI_ANY_ID, PCI_ANY_ID, pci_fixup_ide_bases); | ||
458 | |||
459 | void __init pcibios_init(void) | ||
460 | { | ||
461 | static struct resource galio,galmem; | ||
462 | |||
463 | /* Allocate the registers used by the Galileo */ | ||
464 | galio.flags = IORESOURCE_IO; | ||
465 | galio.name = "Galileo GT64011"; | ||
466 | galmem.flags = IORESOURCE_MEM|IORESOURCE_PREFETCH; | ||
467 | galmem.name = "Galileo GT64011 DRAM"; | ||
468 | |||
469 | allocate_resource(&ioport_resource, &galio, 256, | ||
470 | GT64111_IO_BASE_ADDRESS,GT64111_IO_BASE_ADDRESS+256, 256, NULL, NULL); | ||
471 | allocate_resource(&iomem_resource, &galmem,PCI_DRAM_SIZE, | ||
472 | PHYSADDR(PCI_DRAM_BASE), PHYSADDR(PCI_DRAM_BASE)+PCI_DRAM_SIZE, | ||
473 | PCI_DRAM_SIZE, NULL, NULL); | ||
474 | |||
475 | /* ok, do the scan man */ | ||
476 | pci_root_bus = pci_scan_bus(0, &pci_config_ops, NULL); | ||
477 | |||
478 | pci_assign_unassigned_resources(); | ||
479 | pci_fixup_irqs(no_swizzle, map_od_irq); | ||
480 | |||
481 | #ifdef TEST_DRAM | ||
482 | printk("Testing PCI DRAM - "); | ||
483 | if(test_dram(PCI_DRAM_BASE,PCI_DRAM_SIZE)) { | ||
484 | printk("Passed\n"); | ||
485 | }else { | ||
486 | printk("FAILED\n"); | ||
487 | } | ||
488 | #endif | ||
489 | |||
490 | } | ||
491 | |||
492 | char * __init pcibios_setup(char *str) | ||
493 | { | ||
494 | return str; | ||
495 | } | ||
496 | |||
497 | |||
498 | |||
499 | int pcibios_enable_device(struct pci_dev *dev) | ||
500 | { | ||
501 | |||
502 | u16 cmd, old_cmd; | ||
503 | int idx; | ||
504 | struct resource *r; | ||
505 | |||
506 | pci_read_config_word(dev, PCI_COMMAND, &cmd); | ||
507 | old_cmd = cmd; | ||
508 | for (idx = 0; idx < 6; idx++) { | ||
509 | r = dev->resource + idx; | ||
510 | if (!r->start && r->end) { | ||
511 | printk(KERN_ERR | ||
512 | "PCI: Device %s not available because" | ||
513 | " of resource collisions\n", | ||
514 | pci_name(dev)); | ||
515 | return -EINVAL; | ||
516 | } | ||
517 | if (r->flags & IORESOURCE_IO) | ||
518 | cmd |= PCI_COMMAND_IO; | ||
519 | if (r->flags & IORESOURCE_MEM) | ||
520 | cmd |= PCI_COMMAND_MEMORY; | ||
521 | } | ||
522 | if (cmd != old_cmd) { | ||
523 | printk("PCI: enabling device %s (%04x -> %04x)\n", | ||
524 | pci_name(dev), old_cmd, cmd); | ||
525 | pci_write_config_word(dev, PCI_COMMAND, cmd); | ||
526 | } | ||
527 | return 0; | ||
528 | |||
529 | } | ||
530 | |||
531 | /* We should do some optimisation work here I think. Ok for now though */ | ||
532 | void __init pcibios_fixup_bus(struct pci_bus *bus) | ||
533 | { | ||
534 | |||
535 | } | ||
536 | |||
537 | void pcibios_align_resource(void *data, struct resource *res, | ||
538 | resource_size_t size) | ||
539 | { | ||
540 | } | ||
541 | |||
542 | void __init pcibios_update_resource(struct pci_dev *dev, struct resource *root, | ||
543 | struct resource *res, int resource) | ||
544 | { | ||
545 | |||
546 | unsigned long where, size; | ||
547 | u32 reg; | ||
548 | |||
549 | |||
550 | printk("PCI: Assigning %3s %08lx to %s\n", | ||
551 | res->flags & IORESOURCE_IO ? "IO" : "MEM", | ||
552 | res->start, dev->name); | ||
553 | |||
554 | where = PCI_BASE_ADDRESS_0 + resource * 4; | ||
555 | size = res->end - res->start; | ||
556 | |||
557 | pci_read_config_dword(dev, where, ®); | ||
558 | reg = (reg & size) | (((u32) (res->start - root->start)) & ~size); | ||
559 | pci_write_config_dword(dev, where, reg); | ||
560 | } | ||
561 | |||
562 | |||
563 | void __init pcibios_update_irq(struct pci_dev *dev, int irq) | ||
564 | { | ||
565 | printk("PCI: Assigning IRQ %02d to %s\n", irq, dev->name); | ||
566 | pci_write_config_byte(dev, PCI_INTERRUPT_LINE, irq); | ||
567 | } | ||
568 | |||
569 | /* | ||
570 | * If we set up a device for bus mastering, we need to check the latency | ||
571 | * timer as certain crappy BIOSes forget to set it properly. | ||
572 | */ | ||
573 | unsigned int pcibios_max_latency = 255; | ||
574 | |||
575 | void pcibios_set_master(struct pci_dev *dev) | ||
576 | { | ||
577 | u8 lat; | ||
578 | pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat); | ||
579 | if (lat < 16) | ||
580 | lat = (64 <= pcibios_max_latency) ? 64 : pcibios_max_latency; | ||
581 | else if (lat > pcibios_max_latency) | ||
582 | lat = pcibios_max_latency; | ||
583 | else | ||
584 | return; | ||
585 | printk("PCI: Setting latency timer of device %s to %d\n", pci_name(dev), lat); | ||
586 | pci_write_config_byte(dev, PCI_LATENCY_TIMER, lat); | ||
587 | } | ||
diff --git a/arch/sh/boards/overdrive/io.c b/arch/sh/boards/overdrive/io.c deleted file mode 100644 index 4671b6b047bb..000000000000 --- a/arch/sh/boards/overdrive/io.c +++ /dev/null | |||
@@ -1,172 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2000 David J. Mckay (david.mckay@st.com) | ||
3 | * | ||
4 | * May be copied or modified under the terms of the GNU General Public | ||
5 | * License. See linux/COPYING for more information. | ||
6 | * | ||
7 | * This file contains the I/O routines for use on the overdrive board | ||
8 | * | ||
9 | */ | ||
10 | |||
11 | #include <linux/types.h> | ||
12 | #include <linux/delay.h> | ||
13 | #include <asm/processor.h> | ||
14 | #include <asm/io.h> | ||
15 | #include <asm/addrspace.h> | ||
16 | |||
17 | #include <asm/overdrive/overdrive.h> | ||
18 | |||
19 | /* | ||
20 | * readX/writeX() are used to access memory mapped devices. On some | ||
21 | * architectures the memory mapped IO stuff needs to be accessed | ||
22 | * differently. On the SuperH architecture, we just read/write the | ||
23 | * memory location directly. | ||
24 | */ | ||
25 | |||
26 | #define dprintk(x...) | ||
27 | |||
28 | /* Translates an IO address to where it is mapped in memory */ | ||
29 | |||
30 | #define io_addr(x) (((unsigned)(x))|PCI_GTIO_BASE) | ||
31 | |||
32 | unsigned char od_inb(unsigned long port) | ||
33 | { | ||
34 | dprintk("od_inb(%x)\n", port); | ||
35 | return readb(io_addr(port)) & 0xff; | ||
36 | } | ||
37 | |||
38 | |||
39 | unsigned short od_inw(unsigned long port) | ||
40 | { | ||
41 | dprintk("od_inw(%x)\n", port); | ||
42 | return readw(io_addr(port)) & 0xffff; | ||
43 | } | ||
44 | |||
45 | unsigned int od_inl(unsigned long port) | ||
46 | { | ||
47 | dprintk("od_inl(%x)\n", port); | ||
48 | return readl(io_addr(port)); | ||
49 | } | ||
50 | |||
51 | void od_outb(unsigned char value, unsigned long port) | ||
52 | { | ||
53 | dprintk("od_outb(%x, %x)\n", value, port); | ||
54 | writeb(value, io_addr(port)); | ||
55 | } | ||
56 | |||
57 | void od_outw(unsigned short value, unsigned long port) | ||
58 | { | ||
59 | dprintk("od_outw(%x, %x)\n", value, port); | ||
60 | writew(value, io_addr(port)); | ||
61 | } | ||
62 | |||
63 | void od_outl(unsigned int value, unsigned long port) | ||
64 | { | ||
65 | dprintk("od_outl(%x, %x)\n", value, port); | ||
66 | writel(value, io_addr(port)); | ||
67 | } | ||
68 | |||
69 | /* This is horrible at the moment - needs more work to do something sensible */ | ||
70 | #define IO_DELAY() udelay(10) | ||
71 | |||
72 | #define OUT_DELAY(x,type) \ | ||
73 | void od_out##x##_p(unsigned type value,unsigned long port){out##x(value,port);IO_DELAY();} | ||
74 | |||
75 | #define IN_DELAY(x,type) \ | ||
76 | unsigned type od_in##x##_p(unsigned long port) {unsigned type tmp=in##x(port);IO_DELAY();return tmp;} | ||
77 | |||
78 | |||
79 | OUT_DELAY(b,char) | ||
80 | OUT_DELAY(w,short) | ||
81 | OUT_DELAY(l,int) | ||
82 | |||
83 | IN_DELAY(b,char) | ||
84 | IN_DELAY(w,short) | ||
85 | IN_DELAY(l,int) | ||
86 | |||
87 | |||
88 | /* Now for the string version of these functions */ | ||
89 | void od_outsb(unsigned long port, const void *addr, unsigned long count) | ||
90 | { | ||
91 | int i; | ||
92 | unsigned char *p = (unsigned char *) addr; | ||
93 | |||
94 | for (i = 0; i < count; i++, p++) { | ||
95 | outb(*p, port); | ||
96 | } | ||
97 | } | ||
98 | |||
99 | |||
100 | void od_insb(unsigned long port, void *addr, unsigned long count) | ||
101 | { | ||
102 | int i; | ||
103 | unsigned char *p = (unsigned char *) addr; | ||
104 | |||
105 | for (i = 0; i < count; i++, p++) { | ||
106 | *p = inb(port); | ||
107 | } | ||
108 | } | ||
109 | |||
110 | /* For the 16 and 32 bit string functions, we have to worry about alignment. | ||
111 | * The SH does not do unaligned accesses, so we have to read as bytes and | ||
112 | * then write as a word or dword. | ||
113 | * This can be optimised a lot more, especially in the case where the data | ||
114 | * is aligned | ||
115 | */ | ||
116 | |||
117 | void od_outsw(unsigned long port, const void *addr, unsigned long count) | ||
118 | { | ||
119 | int i; | ||
120 | unsigned short tmp; | ||
121 | unsigned char *p = (unsigned char *) addr; | ||
122 | |||
123 | for (i = 0; i < count; i++, p += 2) { | ||
124 | tmp = (*p) | ((*(p + 1)) << 8); | ||
125 | outw(tmp, port); | ||
126 | } | ||
127 | } | ||
128 | |||
129 | |||
130 | void od_insw(unsigned long port, void *addr, unsigned long count) | ||
131 | { | ||
132 | int i; | ||
133 | unsigned short tmp; | ||
134 | unsigned char *p = (unsigned char *) addr; | ||
135 | |||
136 | for (i = 0; i < count; i++, p += 2) { | ||
137 | tmp = inw(port); | ||
138 | p[0] = tmp & 0xff; | ||
139 | p[1] = (tmp >> 8) & 0xff; | ||
140 | } | ||
141 | } | ||
142 | |||
143 | |||
144 | void od_outsl(unsigned long port, const void *addr, unsigned long count) | ||
145 | { | ||
146 | int i; | ||
147 | unsigned tmp; | ||
148 | unsigned char *p = (unsigned char *) addr; | ||
149 | |||
150 | for (i = 0; i < count; i++, p += 4) { | ||
151 | tmp = (*p) | ((*(p + 1)) << 8) | ((*(p + 2)) << 16) | | ||
152 | ((*(p + 3)) << 24); | ||
153 | outl(tmp, port); | ||
154 | } | ||
155 | } | ||
156 | |||
157 | |||
158 | void od_insl(unsigned long port, void *addr, unsigned long count) | ||
159 | { | ||
160 | int i; | ||
161 | unsigned tmp; | ||
162 | unsigned char *p = (unsigned char *) addr; | ||
163 | |||
164 | for (i = 0; i < count; i++, p += 4) { | ||
165 | tmp = inl(port); | ||
166 | p[0] = tmp & 0xff; | ||
167 | p[1] = (tmp >> 8) & 0xff; | ||
168 | p[2] = (tmp >> 16) & 0xff; | ||
169 | p[3] = (tmp >> 24) & 0xff; | ||
170 | |||
171 | } | ||
172 | } | ||
diff --git a/arch/sh/boards/overdrive/irq.c b/arch/sh/boards/overdrive/irq.c deleted file mode 100644 index 5d730c70389e..000000000000 --- a/arch/sh/boards/overdrive/irq.c +++ /dev/null | |||
@@ -1,191 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2000 David J. Mckay (david.mckay@st.com) | ||
3 | * | ||
4 | * May be copied or modified under the terms of the GNU General Public | ||
5 | * License. See linux/COPYING for more information. | ||
6 | * | ||
7 | * Looks after interrupts on the overdrive board. | ||
8 | * | ||
9 | * Bases on the IPR irq system | ||
10 | */ | ||
11 | |||
12 | #include <linux/init.h> | ||
13 | #include <linux/irq.h> | ||
14 | |||
15 | #include <asm/system.h> | ||
16 | #include <asm/io.h> | ||
17 | |||
18 | #include <asm/overdrive/overdrive.h> | ||
19 | |||
20 | struct od_data { | ||
21 | int overdrive_irq; | ||
22 | int irq_mask; | ||
23 | }; | ||
24 | |||
25 | #define NUM_EXTERNAL_IRQS 16 | ||
26 | #define EXTERNAL_IRQ_NOT_IN_USE (-1) | ||
27 | #define EXTERNAL_IRQ_NOT_ASSIGNED (-1) | ||
28 | |||
29 | /* | ||
30 | * This table is used to determine what to program into the FPGA's CT register | ||
31 | * for the specified Linux IRQ. | ||
32 | * | ||
33 | * The irq_mask gives the interrupt number from the PCI board (PCI_Int(6:0)) | ||
34 | * but is one greater than that because the because the FPGA treats 0 | ||
35 | * as disabled, a value of 1 asserts PCI_Int0, and so on. | ||
36 | * | ||
37 | * The overdrive_irq specifies which of the eight interrupt sources generates | ||
38 | * that interrupt, and but is multiplied by four to give the bit offset into | ||
39 | * the CT register. | ||
40 | * | ||
41 | * The seven interrupts levels (SH4 IRL's) we have available here is hardwired | ||
42 | * by the EPLD. The assignments here of which PCI interrupt generates each | ||
43 | * level is arbitary. | ||
44 | */ | ||
45 | static struct od_data od_data_table[NUM_EXTERNAL_IRQS] = { | ||
46 | /* overdrive_irq , irq_mask */ | ||
47 | {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE}, /* 0 */ | ||
48 | {EXTERNAL_IRQ_NOT_ASSIGNED, 7}, /* 1 */ | ||
49 | {EXTERNAL_IRQ_NOT_ASSIGNED, 6}, /* 2 */ | ||
50 | {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE}, /* 3 */ | ||
51 | {EXTERNAL_IRQ_NOT_ASSIGNED, 5}, /* 4 */ | ||
52 | {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE}, /* 5 */ | ||
53 | {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE}, /* 6 */ | ||
54 | {EXTERNAL_IRQ_NOT_ASSIGNED, 4}, /* 7 */ | ||
55 | {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE}, /* 8 */ | ||
56 | {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE}, /* 9 */ | ||
57 | {EXTERNAL_IRQ_NOT_ASSIGNED, 3}, /* 10 */ | ||
58 | {EXTERNAL_IRQ_NOT_ASSIGNED, 2}, /* 11 */ | ||
59 | {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE}, /* 12 */ | ||
60 | {EXTERNAL_IRQ_NOT_ASSIGNED, 1}, /* 13 */ | ||
61 | {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE}, /* 14 */ | ||
62 | {EXTERNAL_IRQ_NOT_ASSIGNED, EXTERNAL_IRQ_NOT_IN_USE} /* 15 */ | ||
63 | }; | ||
64 | |||
65 | static void set_od_data(int overdrive_irq, int irq) | ||
66 | { | ||
67 | if (irq >= NUM_EXTERNAL_IRQS || irq < 0) | ||
68 | return; | ||
69 | od_data_table[irq].overdrive_irq = overdrive_irq << 2; | ||
70 | } | ||
71 | |||
72 | static void enable_od_irq(unsigned int irq); | ||
73 | void disable_od_irq(unsigned int irq); | ||
74 | |||
75 | /* shutdown is same as "disable" */ | ||
76 | #define shutdown_od_irq disable_od_irq | ||
77 | |||
78 | static void mask_and_ack_od(unsigned int); | ||
79 | static void end_od_irq(unsigned int irq); | ||
80 | |||
81 | static unsigned int startup_od_irq(unsigned int irq) | ||
82 | { | ||
83 | enable_od_irq(irq); | ||
84 | return 0; /* never anything pending */ | ||
85 | } | ||
86 | |||
87 | static struct hw_interrupt_type od_irq_type = { | ||
88 | .typename = "Overdrive-IRQ", | ||
89 | .startup = startup_od_irq, | ||
90 | .shutdown = shutdown_od_irq, | ||
91 | .enable = enable_od_irq, | ||
92 | .disable = disable_od_irq, | ||
93 | .ack = mask_and_ack_od, | ||
94 | .end = end_od_irq | ||
95 | }; | ||
96 | |||
97 | static void disable_od_irq(unsigned int irq) | ||
98 | { | ||
99 | unsigned val, flags; | ||
100 | int overdrive_irq; | ||
101 | unsigned mask; | ||
102 | |||
103 | /* Not a valid interrupt */ | ||
104 | if (irq < 0 || irq >= NUM_EXTERNAL_IRQS) | ||
105 | return; | ||
106 | |||
107 | /* Is is necessary to use a cli here? Would a spinlock not be | ||
108 | * mroe efficient? | ||
109 | */ | ||
110 | local_irq_save(flags); | ||
111 | overdrive_irq = od_data_table[irq].overdrive_irq; | ||
112 | if (overdrive_irq != EXTERNAL_IRQ_NOT_ASSIGNED) { | ||
113 | mask = ~(0x7 << overdrive_irq); | ||
114 | val = ctrl_inl(OVERDRIVE_INT_CT); | ||
115 | val &= mask; | ||
116 | ctrl_outl(val, OVERDRIVE_INT_CT); | ||
117 | } | ||
118 | local_irq_restore(flags); | ||
119 | } | ||
120 | |||
121 | static void enable_od_irq(unsigned int irq) | ||
122 | { | ||
123 | unsigned val, flags; | ||
124 | int overdrive_irq; | ||
125 | unsigned mask; | ||
126 | |||
127 | /* Not a valid interrupt */ | ||
128 | if (irq < 0 || irq >= NUM_EXTERNAL_IRQS) | ||
129 | return; | ||
130 | |||
131 | /* Set priority in OD back to original value */ | ||
132 | local_irq_save(flags); | ||
133 | /* This one is not in use currently */ | ||
134 | overdrive_irq = od_data_table[irq].overdrive_irq; | ||
135 | if (overdrive_irq != EXTERNAL_IRQ_NOT_ASSIGNED) { | ||
136 | val = ctrl_inl(OVERDRIVE_INT_CT); | ||
137 | mask = ~(0x7 << overdrive_irq); | ||
138 | val &= mask; | ||
139 | mask = od_data_table[irq].irq_mask << overdrive_irq; | ||
140 | val |= mask; | ||
141 | ctrl_outl(val, OVERDRIVE_INT_CT); | ||
142 | } | ||
143 | local_irq_restore(flags); | ||
144 | } | ||
145 | |||
146 | |||
147 | |||
148 | /* this functions sets the desired irq handler to be an overdrive type */ | ||
149 | static void __init make_od_irq(unsigned int irq) | ||
150 | { | ||
151 | disable_irq_nosync(irq); | ||
152 | irq_desc[irq].chip = &od_irq_type; | ||
153 | disable_od_irq(irq); | ||
154 | } | ||
155 | |||
156 | |||
157 | static void mask_and_ack_od(unsigned int irq) | ||
158 | { | ||
159 | disable_od_irq(irq); | ||
160 | } | ||
161 | |||
162 | static void end_od_irq(unsigned int irq) | ||
163 | { | ||
164 | enable_od_irq(irq); | ||
165 | } | ||
166 | |||
167 | void __init init_overdrive_irq(void) | ||
168 | { | ||
169 | int i; | ||
170 | |||
171 | /* Disable all interrupts */ | ||
172 | ctrl_outl(0, OVERDRIVE_INT_CT); | ||
173 | |||
174 | /* Update interrupt pin mode to use encoded interrupts */ | ||
175 | i = ctrl_inw(INTC_ICR); | ||
176 | i &= ~INTC_ICR_IRLM; | ||
177 | ctrl_outw(i, INTC_ICR); | ||
178 | |||
179 | for (i = 0; i < NUM_EXTERNAL_IRQS; i++) { | ||
180 | if (od_data_table[i].irq_mask != EXTERNAL_IRQ_NOT_IN_USE) { | ||
181 | make_od_irq(i); | ||
182 | } else if (i != 15) { // Cannot use imask on level 15 | ||
183 | make_imask_irq(i); | ||
184 | } | ||
185 | } | ||
186 | |||
187 | /* Set up the interrupts */ | ||
188 | set_od_data(OVERDRIVE_PCI_INTA, OVERDRIVE_PCI_IRQ1); | ||
189 | set_od_data(OVERDRIVE_PCI_INTB, OVERDRIVE_PCI_IRQ2); | ||
190 | set_od_data(OVERDRIVE_AUDIO_INT, OVERDRIVE_ESS_IRQ); | ||
191 | } | ||
diff --git a/arch/sh/boards/overdrive/led.c b/arch/sh/boards/overdrive/led.c deleted file mode 100644 index 860d7f204a4e..000000000000 --- a/arch/sh/boards/overdrive/led.c +++ /dev/null | |||
@@ -1,58 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/overdrive/led.c | ||
3 | * | ||
4 | * Copyright (C) 1999 Stuart Menefy <stuart.menefy@st.com> | ||
5 | * | ||
6 | * May be copied or modified under the terms of the GNU General Public | ||
7 | * License. See linux/COPYING for more information. | ||
8 | * | ||
9 | * This file contains an Overdrive specific LED feature. | ||
10 | */ | ||
11 | |||
12 | #include <asm/system.h> | ||
13 | #include <asm/io.h> | ||
14 | #include <asm/overdrive/overdrive.h> | ||
15 | |||
16 | static void mach_led(int position, int value) | ||
17 | { | ||
18 | unsigned long flags; | ||
19 | unsigned long reg; | ||
20 | |||
21 | local_irq_save(flags); | ||
22 | |||
23 | reg = readl(OVERDRIVE_CTRL); | ||
24 | if (value) { | ||
25 | reg |= (1<<3); | ||
26 | } else { | ||
27 | reg &= ~(1<<3); | ||
28 | } | ||
29 | writel(reg, OVERDRIVE_CTRL); | ||
30 | |||
31 | local_irq_restore(flags); | ||
32 | } | ||
33 | |||
34 | #ifdef CONFIG_HEARTBEAT | ||
35 | |||
36 | #include <linux/sched.h> | ||
37 | |||
38 | /* acts like an actual heart beat -- ie thump-thump-pause... */ | ||
39 | void heartbeat_od(void) | ||
40 | { | ||
41 | static unsigned cnt = 0, period = 0, dist = 0; | ||
42 | |||
43 | if (cnt == 0 || cnt == dist) | ||
44 | mach_led( -1, 1); | ||
45 | else if (cnt == 7 || cnt == dist+7) | ||
46 | mach_led( -1, 0); | ||
47 | |||
48 | if (++cnt > period) { | ||
49 | cnt = 0; | ||
50 | /* The hyperbolic function below modifies the heartbeat period | ||
51 | * length in dependency of the current (5min) load. It goes | ||
52 | * through the points f(0)=126, f(1)=86, f(5)=51, | ||
53 | * f(inf)->30. */ | ||
54 | period = ((672<<FSHIFT)/(5*avenrun[0]+(7<<FSHIFT))) + 30; | ||
55 | dist = period / 4; | ||
56 | } | ||
57 | } | ||
58 | #endif /* CONFIG_HEARTBEAT */ | ||
diff --git a/arch/sh/boards/overdrive/mach.c b/arch/sh/boards/overdrive/mach.c deleted file mode 100644 index 2834a03ae477..000000000000 --- a/arch/sh/boards/overdrive/mach.c +++ /dev/null | |||
@@ -1,62 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/overdrive/mach.c | ||
3 | * | ||
4 | * Copyright (C) 2000 Stuart Menefy (stuart.menefy@st.com) | ||
5 | * | ||
6 | * May be copied or modified under the terms of the GNU General Public | ||
7 | * License. See linux/COPYING for more information. | ||
8 | * | ||
9 | * Machine vector for the STMicroelectronics Overdrive | ||
10 | */ | ||
11 | |||
12 | #include <linux/init.h> | ||
13 | |||
14 | #include <asm/machvec.h> | ||
15 | #include <asm/rtc.h> | ||
16 | #include <asm/machvec_init.h> | ||
17 | |||
18 | #include <asm/io_unknown.h> | ||
19 | #include <asm/io_generic.h> | ||
20 | #include <asm/overdrive/io.h> | ||
21 | |||
22 | void heartbeat_od(void); | ||
23 | void init_overdrive_irq(void); | ||
24 | void galileo_pcibios_init(void); | ||
25 | |||
26 | /* | ||
27 | * The Machine Vector | ||
28 | */ | ||
29 | |||
30 | struct sh_machine_vector mv_od __initmv = { | ||
31 | .mv_nr_irqs = 48, | ||
32 | |||
33 | .mv_inb = od_inb, | ||
34 | .mv_inw = od_inw, | ||
35 | .mv_inl = od_inl, | ||
36 | .mv_outb = od_outb, | ||
37 | .mv_outw = od_outw, | ||
38 | .mv_outl = od_outl, | ||
39 | |||
40 | .mv_inb_p = od_inb_p, | ||
41 | .mv_inw_p = od_inw_p, | ||
42 | .mv_inl_p = od_inl_p, | ||
43 | .mv_outb_p = od_outb_p, | ||
44 | .mv_outw_p = od_outw_p, | ||
45 | .mv_outl_p = od_outl_p, | ||
46 | |||
47 | .mv_insb = od_insb, | ||
48 | .mv_insw = od_insw, | ||
49 | .mv_insl = od_insl, | ||
50 | .mv_outsb = od_outsb, | ||
51 | .mv_outsw = od_outsw, | ||
52 | .mv_outsl = od_outsl, | ||
53 | |||
54 | #ifdef CONFIG_PCI | ||
55 | .mv_init_irq = init_overdrive_irq, | ||
56 | #endif | ||
57 | #ifdef CONFIG_HEARTBEAT | ||
58 | .mv_heartbeat = heartbeat_od, | ||
59 | #endif | ||
60 | }; | ||
61 | |||
62 | ALIAS_MV(od) | ||
diff --git a/arch/sh/boards/overdrive/pcidma.c b/arch/sh/boards/overdrive/pcidma.c deleted file mode 100644 index 1c9bfeda00b7..000000000000 --- a/arch/sh/boards/overdrive/pcidma.c +++ /dev/null | |||
@@ -1,46 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2000 David J. Mckay (david.mckay@st.com) | ||
3 | * | ||
4 | * May be copied or modified under the terms of the GNU General Public | ||
5 | * License. See linux/COPYING for more information. | ||
6 | * | ||
7 | * Dynamic DMA mapping support. | ||
8 | * | ||
9 | * On the overdrive, we can only DMA from memory behind the PCI bus! | ||
10 | * this means that all DMA'able memory must come from there. | ||
11 | * this restriction will not apply to later boards. | ||
12 | */ | ||
13 | |||
14 | #include <linux/types.h> | ||
15 | #include <linux/mm.h> | ||
16 | #include <linux/string.h> | ||
17 | #include <linux/pci.h> | ||
18 | #include <asm/io.h> | ||
19 | |||
20 | void *pci_alloc_consistent(struct pci_dev *hwdev, size_t size, | ||
21 | dma_addr_t * dma_handle) | ||
22 | { | ||
23 | void *ret; | ||
24 | int gfp = GFP_ATOMIC; | ||
25 | |||
26 | printk("BUG: pci_alloc_consistent() called - not yet supported\n"); | ||
27 | /* We ALWAYS need DMA memory on the overdrive hardware, | ||
28 | * due to it's extreme weirdness | ||
29 | * Need to flush the cache here as well, since the memory | ||
30 | * can still be seen through the cache! | ||
31 | */ | ||
32 | gfp |= GFP_DMA; | ||
33 | ret = (void *) __get_free_pages(gfp, get_order(size)); | ||
34 | |||
35 | if (ret != NULL) { | ||
36 | memset(ret, 0, size); | ||
37 | *dma_handle = virt_to_bus(ret); | ||
38 | } | ||
39 | return ret; | ||
40 | } | ||
41 | |||
42 | void pci_free_consistent(struct pci_dev *hwdev, size_t size, | ||
43 | void *vaddr, dma_addr_t dma_handle) | ||
44 | { | ||
45 | free_pages((unsigned long) vaddr, get_order(size)); | ||
46 | } | ||
diff --git a/arch/sh/boards/overdrive/setup.c b/arch/sh/boards/overdrive/setup.c deleted file mode 100644 index a3a7744c2047..000000000000 --- a/arch/sh/boards/overdrive/setup.c +++ /dev/null | |||
@@ -1,36 +0,0 @@ | |||
1 | /* | ||
2 | * arch/sh/overdrive/setup.c | ||
3 | * | ||
4 | * Copyright (C) 2000 Stuart Menefy (stuart.menefy@st.com) | ||
5 | * | ||
6 | * May be copied or modified under the terms of the GNU General Public | ||
7 | * License. See linux/COPYING for more information. | ||
8 | * | ||
9 | * STMicroelectronics Overdrive Support. | ||
10 | */ | ||
11 | |||
12 | #include <linux/kernel.h> | ||
13 | #include <linux/init.h> | ||
14 | #include <asm/io.h> | ||
15 | |||
16 | #include <asm/overdrive/overdrive.h> | ||
17 | #include <asm/overdrive/fpga.h> | ||
18 | |||
19 | const char *get_system_type(void) | ||
20 | { | ||
21 | return "SH7750 Overdrive"; | ||
22 | } | ||
23 | |||
24 | /* | ||
25 | * Initialize the board | ||
26 | */ | ||
27 | int __init platform_setup(void) | ||
28 | { | ||
29 | #ifdef CONFIG_PCI | ||
30 | init_overdrive_fpga(); | ||
31 | galileo_init(); | ||
32 | #endif | ||
33 | |||
34 | /* Enable RS232 receive buffers */ | ||
35 | writel(0x1e, OVERDRIVE_CTRL); | ||
36 | } | ||
diff --git a/arch/sh/boards/sh2000/Makefile b/arch/sh/boards/sh2000/Makefile deleted file mode 100644 index 05d390c3599c..000000000000 --- a/arch/sh/boards/sh2000/Makefile +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | # | ||
2 | # Makefile for the SH2000 specific parts of the kernel | ||
3 | # | ||
4 | |||
5 | obj-y := setup.o | ||
6 | |||
diff --git a/arch/sh/boards/sh2000/setup.c b/arch/sh/boards/sh2000/setup.c deleted file mode 100644 index 2fe6a11765e9..000000000000 --- a/arch/sh/boards/sh2000/setup.c +++ /dev/null | |||
@@ -1,70 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/kernel/setup_sh2000.c | ||
3 | * | ||
4 | * Copyright (C) 2001 SUGIOKA Tochinobu | ||
5 | * | ||
6 | * SH-2000 Support. | ||
7 | * | ||
8 | */ | ||
9 | |||
10 | #include <linux/init.h> | ||
11 | #include <linux/irq.h> | ||
12 | |||
13 | #include <asm/io.h> | ||
14 | #include <asm/machvec.h> | ||
15 | #include <asm/mach/sh2000.h> | ||
16 | |||
17 | #define CF_CIS_BASE 0xb4200000 | ||
18 | |||
19 | #define PORT_PECR 0xa4000108 | ||
20 | #define PORT_PHCR 0xa400010E | ||
21 | #define PORT_ICR1 0xa4000010 | ||
22 | #define PORT_IRR0 0xa4000004 | ||
23 | |||
24 | #define IDE_OFFSET 0xb6200000 | ||
25 | #define NIC_OFFSET 0xb6000000 | ||
26 | #define EXTBUS_OFFSET 0xba000000 | ||
27 | |||
28 | |||
29 | const char *get_system_type(void) | ||
30 | { | ||
31 | return "sh2000"; | ||
32 | } | ||
33 | |||
34 | static unsigned long sh2000_isa_port2addr(unsigned long offset) | ||
35 | { | ||
36 | if((offset & ~7) == 0x1f0 || offset == 0x3f6) | ||
37 | return IDE_OFFSET + offset; | ||
38 | else if((offset & ~0x1f) == 0x300) | ||
39 | return NIC_OFFSET + offset; | ||
40 | return EXTBUS_OFFSET + offset; | ||
41 | } | ||
42 | |||
43 | /* | ||
44 | * The Machine Vector | ||
45 | */ | ||
46 | struct sh_machine_vector mv_sh2000 __initmv = { | ||
47 | .mv_nr_irqs = 80, | ||
48 | .mv_isa_port2addr = sh2000_isa_port2addr, | ||
49 | }; | ||
50 | ALIAS_MV(sh2000) | ||
51 | |||
52 | /* | ||
53 | * Initialize the board | ||
54 | */ | ||
55 | int __init platform_setup(void) | ||
56 | { | ||
57 | /* XXX: RTC setting comes here */ | ||
58 | |||
59 | /* These should be done by BIOS/IPL ... */ | ||
60 | /* Enable nCE2A, nCE2B output */ | ||
61 | ctrl_outw(ctrl_inw(PORT_PECR) & ~0xf00, PORT_PECR); | ||
62 | /* Enable the Compact Flash card, and set the level interrupt */ | ||
63 | ctrl_outw(0x0042, CF_CIS_BASE+0x0200); | ||
64 | /* Enable interrupt */ | ||
65 | ctrl_outw(ctrl_inw(PORT_PHCR) & ~0x03f3, PORT_PHCR); | ||
66 | ctrl_outw(1, PORT_ICR1); | ||
67 | ctrl_outw(ctrl_inw(PORT_IRR0) & ~0xff3f, PORT_IRR0); | ||
68 | printk(KERN_INFO "SH-2000 Setup...done\n"); | ||
69 | return 0; | ||
70 | } | ||
diff --git a/arch/sh/tools/mach-types b/arch/sh/tools/mach-types index ffd218083876..b30e784b3a31 100644 --- a/arch/sh/tools/mach-types +++ b/arch/sh/tools/mach-types | |||
@@ -13,11 +13,9 @@ SE SH_SOLUTION_ENGINE | |||
13 | HP6XX SH_HP6XX | 13 | HP6XX SH_HP6XX |
14 | HD64461 HD64461 | 14 | HD64461 HD64461 |
15 | HD64465 HD64465 | 15 | HD64465 HD64465 |
16 | SH2000 SH_SH2000 | ||
17 | SATURN SH_SATURN | 16 | SATURN SH_SATURN |
18 | DREAMCAST SH_DREAMCAST | 17 | DREAMCAST SH_DREAMCAST |
19 | BIGSUR SH_BIGSUR | 18 | BIGSUR SH_BIGSUR |
20 | ADX SH_ADX | ||
21 | MPC1211 SH_MPC1211 | 19 | MPC1211 SH_MPC1211 |
22 | SNAPGEAR SH_SECUREEDGE5410 | 20 | SNAPGEAR SH_SECUREEDGE5410 |
23 | HS7751RVOIP SH_HS7751RVOIP | 21 | HS7751RVOIP SH_HS7751RVOIP |
diff --git a/include/asm-sh/adx/io.h b/include/asm-sh/adx/io.h deleted file mode 100644 index ab1225f1d557..000000000000 --- a/include/asm-sh/adx/io.h +++ /dev/null | |||
@@ -1,86 +0,0 @@ | |||
1 | /* | ||
2 | * include/asm-sh/io_adx.h | ||
3 | * | ||
4 | * Copyright (C) 2001 A&D Co., Ltd. | ||
5 | * | ||
6 | * This file may be copied or modified under the terms of the GNU | ||
7 | * General Public License. See linux/COPYING for more information. | ||
8 | * | ||
9 | * IO functions for an A&D ADX Board | ||
10 | */ | ||
11 | |||
12 | #ifndef _ASM_SH_IO_ADX_H | ||
13 | #define _ASM_SH_IO_ADX_H | ||
14 | |||
15 | #include <asm/io_generic.h> | ||
16 | |||
17 | extern unsigned char adx_inb(unsigned long port); | ||
18 | extern unsigned short adx_inw(unsigned long port); | ||
19 | extern unsigned int adx_inl(unsigned long port); | ||
20 | |||
21 | extern void adx_outb(unsigned char value, unsigned long port); | ||
22 | extern void adx_outw(unsigned short value, unsigned long port); | ||
23 | extern void adx_outl(unsigned int value, unsigned long port); | ||
24 | |||
25 | extern unsigned char adx_inb_p(unsigned long port); | ||
26 | extern void adx_outb_p(unsigned char value, unsigned long port); | ||
27 | |||
28 | extern void adx_insb(unsigned long port, void *addr, unsigned long count); | ||
29 | extern void adx_insw(unsigned long port, void *addr, unsigned long count); | ||
30 | extern void adx_insl(unsigned long port, void *addr, unsigned long count); | ||
31 | extern void adx_outsb(unsigned long port, const void *addr, unsigned long count); | ||
32 | extern void adx_outsw(unsigned long port, const void *addr, unsigned long count); | ||
33 | extern void adx_outsl(unsigned long port, const void *addr, unsigned long count); | ||
34 | |||
35 | extern unsigned char adx_readb(unsigned long addr); | ||
36 | extern unsigned short adx_readw(unsigned long addr); | ||
37 | extern unsigned int adx_readl(unsigned long addr); | ||
38 | extern void adx_writeb(unsigned char b, unsigned long addr); | ||
39 | extern void adx_writew(unsigned short b, unsigned long addr); | ||
40 | extern void adx_writel(unsigned int b, unsigned long addr); | ||
41 | |||
42 | extern void * adx_ioremap(unsigned long offset, unsigned long size); | ||
43 | extern void adx_iounmap(void *addr); | ||
44 | |||
45 | extern unsigned long adx_isa_port2addr(unsigned long offset); | ||
46 | |||
47 | extern void setup_adx(void); | ||
48 | extern void init_adx_IRQ(void); | ||
49 | |||
50 | #ifdef __WANT_IO_DEF | ||
51 | |||
52 | #define __inb adx_inb | ||
53 | #define __inw adx_inw | ||
54 | #define __inl adx_inl | ||
55 | #define __outb adx_outb | ||
56 | #define __outw adx_outw | ||
57 | #define __outl adx_outl | ||
58 | |||
59 | #define __inb_p adx_inb_p | ||
60 | #define __inw_p adx_inw | ||
61 | #define __inl_p adx_inl | ||
62 | #define __outb_p adx_outb_p | ||
63 | #define __outw_p adx_outw | ||
64 | #define __outl_p adx_outl | ||
65 | |||
66 | #define __insb adx_insb | ||
67 | #define __insw adx_insw | ||
68 | #define __insl adx_insl | ||
69 | #define __outsb adx_outsb | ||
70 | #define __outsw adx_outsw | ||
71 | #define __outsl adx_outsl | ||
72 | |||
73 | #define __readb adx_readb | ||
74 | #define __readw adx_readw | ||
75 | #define __readl adx_readl | ||
76 | #define __writeb adx_writeb | ||
77 | #define __writew adx_writew | ||
78 | #define __writel adx_writel | ||
79 | |||
80 | #define __isa_port2addr adx_isa_port2addr | ||
81 | #define __ioremap adx_ioremap | ||
82 | #define __iounmap adx_iounmap | ||
83 | |||
84 | #endif | ||
85 | |||
86 | #endif /* _ASM_SH_IO_AANDD_H */ | ||
diff --git a/include/asm-sh/cat68701/io.h b/include/asm-sh/cat68701/io.h deleted file mode 100644 index 753b8466ad11..000000000000 --- a/include/asm-sh/cat68701/io.h +++ /dev/null | |||
@@ -1,22 +0,0 @@ | |||
1 | /* | ||
2 | * include/asm-sh/io_cat68701.h | ||
3 | * | ||
4 | * Copyright 2000 Stuart Menefy (stuart.menefy@st.com) | ||
5 | * 2001 Yutarou Ebihar (ebihara@si-linux.com) | ||
6 | * | ||
7 | * May be copied or modified under the terms of the GNU General Public | ||
8 | * License. See linux/COPYING for more information. | ||
9 | * | ||
10 | * IO functions for an AONE Corp. CAT-68701 SH7708 Borad | ||
11 | */ | ||
12 | |||
13 | #ifndef _ASM_SH_IO_CAT68701_H | ||
14 | #define _ASM_SH_IO_CAT68701_H | ||
15 | |||
16 | extern unsigned long cat68701_isa_port2addr(unsigned long offset); | ||
17 | extern int cat68701_irq_demux(int irq); | ||
18 | |||
19 | extern void init_cat68701_IRQ(void); | ||
20 | extern void heartbeat_cat68701(void); | ||
21 | |||
22 | #endif /* _ASM_SH_IO_CAT68701_H */ | ||
diff --git a/include/asm-sh/cqreek/cqreek.h b/include/asm-sh/cqreek/cqreek.h deleted file mode 100644 index 09aecc06693e..000000000000 --- a/include/asm-sh/cqreek/cqreek.h +++ /dev/null | |||
@@ -1,27 +0,0 @@ | |||
1 | #ifndef __ASM_SH_CQREEK_CQREEK_H | ||
2 | #define __ASM_SH_CQREEK_CQREEK_H | ||
3 | |||
4 | #define BRIDGE_FEATURE 0x0002 | ||
5 | |||
6 | #define BRIDGE_IDE_CTRL 0x0018 | ||
7 | #define BRIDGE_IDE_INTR_LVL 0x001A | ||
8 | #define BRIDGE_IDE_INTR_MASK 0x001C | ||
9 | #define BRIDGE_IDE_INTR_STAT 0x001E | ||
10 | |||
11 | #define BRIDGE_ISA_CTRL 0x0028 | ||
12 | #define BRIDGE_ISA_INTR_LVL 0x002A | ||
13 | #define BRIDGE_ISA_INTR_MASK 0x002C | ||
14 | #define BRIDGE_ISA_INTR_STAT 0x002E | ||
15 | |||
16 | /* arch/sh/boards/cqreek/setup.c */ | ||
17 | extern void setup_cqreek(void); | ||
18 | |||
19 | /* arch/sh/boards/cqreek/irq.c */ | ||
20 | extern int cqreek_has_ide, cqreek_has_isa; | ||
21 | extern void init_cqreek_IRQ(void); | ||
22 | |||
23 | /* arch/sh/boards/cqreek/io.c */ | ||
24 | extern unsigned long cqreek_port2addr(unsigned long port); | ||
25 | |||
26 | #endif /* __ASM_SH_CQREEK_CQREEK_H */ | ||
27 | |||
diff --git a/include/asm-sh/dmida/io.h b/include/asm-sh/dmida/io.h deleted file mode 100644 index 21bd416c01c3..000000000000 --- a/include/asm-sh/dmida/io.h +++ /dev/null | |||
@@ -1,10 +0,0 @@ | |||
1 | #ifndef __ASM_SH_DMIDA_IO_H | ||
2 | #define __ASM_SH_DMIDA_IO_H | ||
3 | |||
4 | /* | ||
5 | * Nothing special here.. just use the generic cchip io routines. | ||
6 | */ | ||
7 | #include <asm/hd64465/io.h> | ||
8 | |||
9 | #endif /* __ASM_SH_DMIDA_IO_H */ | ||
10 | |||
diff --git a/include/asm-sh/harp/harp.h b/include/asm-sh/harp/harp.h deleted file mode 100644 index b2fbcfae9940..000000000000 --- a/include/asm-sh/harp/harp.h +++ /dev/null | |||
@@ -1,43 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2001 David J. Mckay (david.mckay@st.com) | ||
3 | * | ||
4 | * May be copied or modified under the terms of the GNU General Public | ||
5 | * License. See linux/COPYING for more information. | ||
6 | * | ||
7 | * Defintions applicable to the STMicroelectronics ST40STB1 HARP and | ||
8 | * compatible boards. | ||
9 | */ | ||
10 | |||
11 | #if defined(CONFIG_SH_STB1_HARP) | ||
12 | |||
13 | #define EPLD_BASE 0xa0800000 | ||
14 | |||
15 | #define EPLD_LED (EPLD_BASE+0x000c0000) | ||
16 | #define EPLD_INTSTAT0 (EPLD_BASE+0x00200000) | ||
17 | #define EPLD_INTSTAT1 (EPLD_BASE+0x00240000) | ||
18 | #define EPLD_INTMASK0 (EPLD_BASE+0x00280000) | ||
19 | #define EPLD_INTMASK1 (EPLD_BASE+0x002c0000) | ||
20 | #define EPLD_PAGEADDR (EPLD_BASE+0x00300000) | ||
21 | #define EPLD_REVID1 (EPLD_BASE+0x00380000) | ||
22 | #define EPLD_REVID2 (EPLD_BASE+0x003c0000) | ||
23 | |||
24 | #define EPLD_LED_ON 1 | ||
25 | #define EPLD_LED_OFF 0 | ||
26 | |||
27 | #elif defined(CONFIG_SH_STB1_OVERDRIVE) | ||
28 | |||
29 | #define EPLD_BASE 0xa7000000 | ||
30 | |||
31 | #define EPLD_REVID (EPLD_BASE+0x00000000) | ||
32 | #define EPLD_LED (EPLD_BASE+0x00040000) | ||
33 | #define EPLD_INTMASK0 (EPLD_BASE+0x001c0000) | ||
34 | #define EPLD_INTMASK1 (EPLD_BASE+0x00200000) | ||
35 | #define EPLD_INTSTAT0 (EPLD_BASE+0x00240000) | ||
36 | #define EPLD_INTSTAT1 (EPLD_BASE+0x00280000) | ||
37 | |||
38 | #define EPLD_LED_ON 0 | ||
39 | #define EPLD_LED_OFF 1 | ||
40 | |||
41 | #else | ||
42 | #error Unknown board | ||
43 | #endif | ||
diff --git a/include/asm-sh/harp/io.h b/include/asm-sh/harp/io.h deleted file mode 100644 index 68f39e0b39de..000000000000 --- a/include/asm-sh/harp/io.h +++ /dev/null | |||
@@ -1,10 +0,0 @@ | |||
1 | #ifndef __ASM_SH_HARP_IO_H | ||
2 | #define __ASM_SH_HARP_IO_H | ||
3 | |||
4 | /* | ||
5 | * Nothing special here.. just use the generic cchip io routines. | ||
6 | */ | ||
7 | #include <asm/hd64465/io.h> | ||
8 | |||
9 | #endif /* __ASM_SH_HARP_IO_H */ | ||
10 | |||
diff --git a/include/asm-sh/overdrive/fpga.h b/include/asm-sh/overdrive/fpga.h deleted file mode 100644 index 1cd87992c124..000000000000 --- a/include/asm-sh/overdrive/fpga.h +++ /dev/null | |||
@@ -1,15 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2000 David J. Mckay (david.mckay@st.com) | ||
3 | * | ||
4 | * May be copied or modified under the terms of the GNU General Public | ||
5 | * License. See linux/COPYING for more information. | ||
6 | * | ||
7 | */ | ||
8 | |||
9 | #ifndef __FPGA_OD_H__ | ||
10 | #define __FPGA_OD_H__ | ||
11 | |||
12 | /* This routine will program up the fpga which interfaces to the galileo */ | ||
13 | int init_overdrive_fpga(void); | ||
14 | |||
15 | #endif | ||
diff --git a/include/asm-sh/overdrive/gt64111.h b/include/asm-sh/overdrive/gt64111.h deleted file mode 100644 index 01d58bc13a44..000000000000 --- a/include/asm-sh/overdrive/gt64111.h +++ /dev/null | |||
@@ -1,109 +0,0 @@ | |||
1 | #ifndef _GT64111_H_ | ||
2 | #define _GT64111_H_ | ||
3 | |||
4 | #define MASTER_INTERFACE 0x0 | ||
5 | #define RAS10_LO_DEC_ADR 0x8 | ||
6 | #define RAS10_HI_DEC_ADR 0x10 | ||
7 | #define RAS32_LO_DEC_ADR 0x18 | ||
8 | #define RAS32_HI_DEC_ADR 0x20 | ||
9 | #define CS20_LO_DEC_ADR 0x28 | ||
10 | #define CS20_HI_DEC_ADR 0x30 | ||
11 | #define CS3_LO_DEC_ADR 0x38 | ||
12 | #define CS3_HI_DEC_ADR 0x40 | ||
13 | #define PCI_IO_LO_DEC_ADR 0x48 | ||
14 | #define PCI_IO_HI_DEC_ADR 0x50 | ||
15 | #define PCI_MEM0_LO_DEC_ADR 0x58 | ||
16 | #define PCI_MEM0_HI_DEC_ADR 0x60 | ||
17 | #define INTERNAL_SPACE_DEC 0x68 | ||
18 | #define BUS_ERR_ADR_LO_CPU 0x70 | ||
19 | #define READONLY0 0x78 | ||
20 | #define PCI_MEM1_LO_DEC_ADR 0x80 | ||
21 | #define PCI_MEM1_HI_DEC_ADR 0x88 | ||
22 | #define RAS0_LO_DEC_ADR 0x400 | ||
23 | #define RAS0_HI_DEC_ADR 0x404 | ||
24 | #define RAS1_LO_DEC_ADR 0x408 | ||
25 | #define RAS1_HI_DEC_ADR 0x40c | ||
26 | #define RAS2_LO_DEC_ADR 0x410 | ||
27 | #define RAS2_HI_DEC_ADR 0x414 | ||
28 | #define RAS3_LO_DEC_ADR 0x418 | ||
29 | #define RAS3_HI_DEC_ADR 0x41c | ||
30 | #define DEV_CS0_LO_DEC_ADR 0x420 | ||
31 | #define DEV_CS0_HI_DEC_ADR 0x424 | ||
32 | #define DEV_CS1_LO_DEC_ADR 0x428 | ||
33 | #define DEV_CS1_HI_DEC_ADR 0x42c | ||
34 | #define DEV_CS2_LO_DEC_ADR 0x430 | ||
35 | #define DEV_CS2_HI_DEC_ADR 0x434 | ||
36 | #define DEV_CS3_LO_DEC_ADR 0x438 | ||
37 | #define DEV_CS3_HI_DEC_ADR 0x43c | ||
38 | #define DEV_BOOTCS_LO_DEC_ADR 0x440 | ||
39 | #define DEV_BOOTCS_HI_DEC_ADR 0x444 | ||
40 | #define DEV_ADR_DEC_ERR 0x470 | ||
41 | #define DRAM_CFG 0x448 | ||
42 | #define DRAM_BANK0_PARMS 0x44c | ||
43 | #define DRAM_BANK1_PARMS 0x450 | ||
44 | #define DRAM_BANK2_PARMS 0x454 | ||
45 | #define DRAM_BANK3_PARMS 0x458 | ||
46 | #define DEV_BANK0_PARMS 0x45c | ||
47 | #define DEV_BANK1_PARMS 0x460 | ||
48 | #define DEV_BANK2_PARMS 0x464 | ||
49 | #define DEV_BANK3_PARMS 0x468 | ||
50 | #define DEV_BOOT_BANK_PARMS 0x46c | ||
51 | #define CH0_DMA_BYTECOUNT 0x800 | ||
52 | #define CH1_DMA_BYTECOUNT 0x804 | ||
53 | #define CH2_DMA_BYTECOUNT 0x808 | ||
54 | #define CH3_DMA_BYTECOUNT 0x80c | ||
55 | #define CH0_DMA_SRC_ADR 0x810 | ||
56 | #define CH1_DMA_SRC_ADR 0x814 | ||
57 | #define CH2_DMA_SRC_ADR 0x818 | ||
58 | #define CH3_DMA_SRC_ADR 0x81c | ||
59 | #define CH0_DMA_DST_ADR 0x820 | ||
60 | #define CH1_DMA_DST_ADR 0x824 | ||
61 | #define CH2_DMA_DST_ADR 0x828 | ||
62 | #define CH3_DMA_DST_ADR 0x82c | ||
63 | #define CH0_NEXT_REC_PTR 0x830 | ||
64 | #define CH1_NEXT_REC_PTR 0x834 | ||
65 | #define CH2_NEXT_REC_PTR 0x838 | ||
66 | #define CH3_NEXT_REC_PTR 0x83c | ||
67 | #define CH0_CTRL 0x840 | ||
68 | #define CH1_CTRL 0x844 | ||
69 | #define CH2_CTRL 0x848 | ||
70 | #define CH3_CTRL 0x84c | ||
71 | #define DMA_ARBITER 0x860 | ||
72 | #define TIMER0 0x850 | ||
73 | #define TIMER1 0x854 | ||
74 | #define TIMER2 0x858 | ||
75 | #define TIMER3 0x85c | ||
76 | #define TIMER_CTRL 0x864 | ||
77 | #define PCI_CMD 0xc00 | ||
78 | #define PCI_TIMEOUT 0xc04 | ||
79 | #define PCI_RAS10_BANK_SIZE 0xc08 | ||
80 | #define PCI_RAS32_BANK_SIZE 0xc0c | ||
81 | #define PCI_CS20_BANK_SIZE 0xc10 | ||
82 | #define PCI_CS3_BANK_SIZE 0xc14 | ||
83 | #define PCI_SERRMASK 0xc28 | ||
84 | #define PCI_INTACK 0xc34 | ||
85 | #define PCI_BAR_EN 0xc3c | ||
86 | #define PCI_CFG_ADR 0xcf8 | ||
87 | #define PCI_CFG_DATA 0xcfc | ||
88 | #define PCI_INTCAUSE 0xc18 | ||
89 | #define PCI_MAST_MASK 0xc1c | ||
90 | #define PCI_PCIMASK 0xc24 | ||
91 | #define BAR_ENABLE_ADR 0xc3c | ||
92 | |||
93 | /* These are config registers, accessible via PCI space */ | ||
94 | #define PCI_CONFIG_RAS10_BASE_ADR 0x010 | ||
95 | #define PCI_CONFIG_RAS32_BASE_ADR 0x014 | ||
96 | #define PCI_CONFIG_CS20_BASE_ADR 0x018 | ||
97 | #define PCI_CONFIG_CS3_BASE_ADR 0x01c | ||
98 | #define PCI_CONFIG_INT_REG_MM_ADR 0x020 | ||
99 | #define PCI_CONFIG_INT_REG_IO_ADR 0x024 | ||
100 | #define PCI_CONFIG_BOARD_VENDOR 0x02c | ||
101 | #define PCI_CONFIG_ROM_ADR 0x030 | ||
102 | #define PCI_CONFIG_INT_PIN_LINE 0x03c | ||
103 | |||
104 | |||
105 | |||
106 | |||
107 | |||
108 | #endif | ||
109 | |||
diff --git a/include/asm-sh/overdrive/io.h b/include/asm-sh/overdrive/io.h deleted file mode 100644 index 0dba700e9643..000000000000 --- a/include/asm-sh/overdrive/io.h +++ /dev/null | |||
@@ -1,39 +0,0 @@ | |||
1 | /* | ||
2 | * include/asm-sh/io_od.h | ||
3 | * | ||
4 | * Copyright 2000 Stuart Menefy (stuart.menefy@st.com) | ||
5 | * | ||
6 | * May be copied or modified under the terms of the GNU General Public | ||
7 | * License. See linux/COPYING for more information. | ||
8 | * | ||
9 | * IO functions for an STMicroelectronics Overdrive | ||
10 | */ | ||
11 | |||
12 | #ifndef _ASM_SH_IO_OD_H | ||
13 | #define _ASM_SH_IO_OD_H | ||
14 | |||
15 | extern unsigned char od_inb(unsigned long port); | ||
16 | extern unsigned short od_inw(unsigned long port); | ||
17 | extern unsigned int od_inl(unsigned long port); | ||
18 | |||
19 | extern void od_outb(unsigned char value, unsigned long port); | ||
20 | extern void od_outw(unsigned short value, unsigned long port); | ||
21 | extern void od_outl(unsigned int value, unsigned long port); | ||
22 | |||
23 | extern unsigned char od_inb_p(unsigned long port); | ||
24 | extern unsigned short od_inw_p(unsigned long port); | ||
25 | extern unsigned int od_inl_p(unsigned long port); | ||
26 | extern void od_outb_p(unsigned char value, unsigned long port); | ||
27 | extern void od_outw_p(unsigned short value, unsigned long port); | ||
28 | extern void od_outl_p(unsigned int value, unsigned long port); | ||
29 | |||
30 | extern void od_insb(unsigned long port, void *addr, unsigned long count); | ||
31 | extern void od_insw(unsigned long port, void *addr, unsigned long count); | ||
32 | extern void od_insl(unsigned long port, void *addr, unsigned long count); | ||
33 | extern void od_outsb(unsigned long port, const void *addr, unsigned long count); | ||
34 | extern void od_outsw(unsigned long port, const void *addr, unsigned long count); | ||
35 | extern void od_outsl(unsigned long port, const void *addr, unsigned long count); | ||
36 | |||
37 | extern unsigned long od_isa_port2addr(unsigned long offset); | ||
38 | |||
39 | #endif /* _ASM_SH_IO_OD_H */ | ||
diff --git a/include/asm-sh/overdrive/overdrive.h b/include/asm-sh/overdrive/overdrive.h deleted file mode 100644 index fc746c244f83..000000000000 --- a/include/asm-sh/overdrive/overdrive.h +++ /dev/null | |||
@@ -1,88 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2000 David J. Mckay (david.mckay@st.com) | ||
3 | * | ||
4 | * May be copied or modified under the terms of the GNU General Public | ||
5 | * License. See linux/COPYING for more information. | ||
6 | * | ||
7 | */ | ||
8 | |||
9 | |||
10 | #ifndef __OVERDRIVE_H__ | ||
11 | #define __OVERDRIVE_H__ | ||
12 | |||
13 | #define OVERDRIVE_INT_CT 0xa3a00000 | ||
14 | #define OVERDRIVE_INT_DT 0xa3b00000 | ||
15 | |||
16 | #define OVERDRIVE_CTRL 0xa3000000 | ||
17 | |||
18 | /* Shoving all these bits into the same register is not a good idea. | ||
19 | * As soon as I get a spare moment, I'll change the FPGA and put each | ||
20 | * bit in a separate register | ||
21 | */ | ||
22 | |||
23 | #define VALID_CTRL_BITS 0x1f | ||
24 | |||
25 | #define ENABLE_RS232_MASK 0x1e | ||
26 | #define DISABLE_RS232_BIT 0x01 | ||
27 | |||
28 | #define ENABLE_NMI_MASK 0x1d | ||
29 | #define DISABLE_NMI_BIT 0x02 | ||
30 | |||
31 | #define RESET_PCI_MASK 0x1b | ||
32 | #define ENABLE_PCI_BIT 0x04 | ||
33 | |||
34 | #define ENABLE_LED_MASK 0x17 | ||
35 | #define DISABLE_LED_BIT 0x08 | ||
36 | |||
37 | #define RESET_FPGA_MASK 0x0f | ||
38 | #define ENABLE_FPGA_BIT 0x10 | ||
39 | |||
40 | |||
41 | #define FPGA_DCLK_ADDRESS 0xA3C00000 | ||
42 | |||
43 | #define FPGA_DATA 0x01 /* W */ | ||
44 | #define FPGA_CONFDONE 0x02 /* R */ | ||
45 | #define FPGA_NOT_STATUS 0x04 /* R */ | ||
46 | #define FPGA_INITDONE 0x08 /* R */ | ||
47 | |||
48 | #define FPGA_TIMEOUT 100000 | ||
49 | |||
50 | |||
51 | /* Interrupts for the overdrive. Note that these numbers have | ||
52 | * nothing to do with the actual IRQ numbers they appear on, | ||
53 | * this is all programmable. This is simply the position in the | ||
54 | * INT_CT register. | ||
55 | */ | ||
56 | |||
57 | #define OVERDRIVE_PCI_INTA 0 | ||
58 | #define OVERDRIVE_PCI_INTB 1 | ||
59 | #define OVERDRIVE_PCI_INTC 2 | ||
60 | #define OVERDRIVE_PCI_INTD 3 | ||
61 | #define OVERDRIVE_GALILEO_INT 4 | ||
62 | #define OVERDRIVE_GALILEO_LOCAL_INT 5 | ||
63 | #define OVERDRIVE_AUDIO_INT 6 | ||
64 | #define OVERDRIVE_KEYBOARD_INT 7 | ||
65 | |||
66 | /* Which Linux IRQ should we assign to each interrupt source? */ | ||
67 | #define OVERDRIVE_PCI_IRQ1 2 | ||
68 | #ifdef CONFIG_HACKED_NE2K | ||
69 | #define OVERDRIVE_PCI_IRQ2 7 | ||
70 | #else | ||
71 | #define OVERDRIVE_PCI_IRQ2 2 | ||
72 | #undef OVERDRIVE_PCI_INTB | ||
73 | #define OVERDRIVE_PCI_INTB OVERDRIVE_PCI_INTA | ||
74 | |||
75 | #endif | ||
76 | |||
77 | /* Put the ESS solo audio chip on IRQ 4 */ | ||
78 | #define OVERDRIVE_ESS_IRQ 4 | ||
79 | |||
80 | /* Where the memory behind the PCI bus appears */ | ||
81 | #define PCI_DRAM_BASE 0xb7000000 | ||
82 | #define PCI_DRAM_SIZE (16*1024*1024) | ||
83 | #define PCI_DRAM_FINISH (PCI_DRAM_BASE+PCI_DRAM_SIZE-1) | ||
84 | |||
85 | /* Where the IO region appears in the memory */ | ||
86 | #define PCI_GTIO_BASE 0xb8000000 | ||
87 | |||
88 | #endif | ||
diff --git a/include/asm-sh/sh2000/sh2000.h b/include/asm-sh/sh2000/sh2000.h deleted file mode 100644 index 8d547324d59a..000000000000 --- a/include/asm-sh/sh2000/sh2000.h +++ /dev/null | |||
@@ -1,8 +0,0 @@ | |||
1 | #ifndef __ASM_SH_SH2000_SH2000_H | ||
2 | #define __ASM_SH_SH2000_SH2000_H | ||
3 | |||
4 | /* arch/sh/boards/sh2000/setup.c */ | ||
5 | extern int setup_sh2000(void); | ||
6 | |||
7 | #endif /* __ASM_SH_SH2000_SH2000_H */ | ||
8 | |||