diff options
Diffstat (limited to 'arch/sh/boards')
44 files changed, 488 insertions, 2100 deletions
diff --git a/arch/sh/boards/bigsur/Makefile b/arch/sh/boards/bigsur/Makefile deleted file mode 100644 index 0ff9497ac58e..000000000000 --- a/arch/sh/boards/bigsur/Makefile +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | # | ||
2 | # Makefile for the BigSur specific parts of the kernel | ||
3 | # | ||
4 | |||
5 | obj-y := setup.o io.o irq.o led.o | ||
6 | |||
diff --git a/arch/sh/boards/bigsur/io.c b/arch/sh/boards/bigsur/io.c deleted file mode 100644 index 23071f97eec3..000000000000 --- a/arch/sh/boards/bigsur/io.c +++ /dev/null | |||
@@ -1,120 +0,0 @@ | |||
1 | /* | ||
2 | * arch/sh/boards/bigsur/io.c | ||
3 | * | ||
4 | * By Dustin McIntire (dustin@sensoria.com) (c)2001 | ||
5 | * Derived from io_hd64465.h, which bore the message: | ||
6 | * By Greg Banks <gbanks@pocketpenguins.com> | ||
7 | * (c) 2000 PocketPenguins Inc. | ||
8 | * and from io_hd64461.h, which bore the message: | ||
9 | * Copyright 2000 Stuart Menefy (stuart.menefy@st.com) | ||
10 | * | ||
11 | * May be copied or modified under the terms of the GNU General Public | ||
12 | * License. See linux/COPYING for more information. | ||
13 | * | ||
14 | * IO functions for a Hitachi Big Sur Evaluation Board. | ||
15 | */ | ||
16 | |||
17 | #include <linux/kernel.h> | ||
18 | #include <linux/module.h> | ||
19 | #include <asm/machvec.h> | ||
20 | #include <asm/io.h> | ||
21 | #include <asm/bigsur/bigsur.h> | ||
22 | |||
23 | /* Low iomap maps port 0-1K to addresses in 8byte chunks */ | ||
24 | #define BIGSUR_IOMAP_LO_THRESH 0x400 | ||
25 | #define BIGSUR_IOMAP_LO_SHIFT 3 | ||
26 | #define BIGSUR_IOMAP_LO_MASK ((1<<BIGSUR_IOMAP_LO_SHIFT)-1) | ||
27 | #define BIGSUR_IOMAP_LO_NMAP (BIGSUR_IOMAP_LO_THRESH>>BIGSUR_IOMAP_LO_SHIFT) | ||
28 | static u32 bigsur_iomap_lo[BIGSUR_IOMAP_LO_NMAP]; | ||
29 | static u8 bigsur_iomap_lo_shift[BIGSUR_IOMAP_LO_NMAP]; | ||
30 | |||
31 | /* High iomap maps port 1K-64K to addresses in 1K chunks */ | ||
32 | #define BIGSUR_IOMAP_HI_THRESH 0x10000 | ||
33 | #define BIGSUR_IOMAP_HI_SHIFT 10 | ||
34 | #define BIGSUR_IOMAP_HI_MASK ((1<<BIGSUR_IOMAP_HI_SHIFT)-1) | ||
35 | #define BIGSUR_IOMAP_HI_NMAP (BIGSUR_IOMAP_HI_THRESH>>BIGSUR_IOMAP_HI_SHIFT) | ||
36 | static u32 bigsur_iomap_hi[BIGSUR_IOMAP_HI_NMAP]; | ||
37 | static u8 bigsur_iomap_hi_shift[BIGSUR_IOMAP_HI_NMAP]; | ||
38 | |||
39 | void bigsur_port_map(u32 baseport, u32 nports, u32 addr, u8 shift) | ||
40 | { | ||
41 | u32 port, endport = baseport + nports; | ||
42 | |||
43 | pr_debug("bigsur_port_map(base=0x%0x, n=0x%0x, addr=0x%08x)\n", | ||
44 | baseport, nports, addr); | ||
45 | |||
46 | for (port = baseport ; | ||
47 | port < endport && port < BIGSUR_IOMAP_LO_THRESH ; | ||
48 | port += (1<<BIGSUR_IOMAP_LO_SHIFT)) { | ||
49 | pr_debug(" maplo[0x%x] = 0x%08x\n", port, addr); | ||
50 | bigsur_iomap_lo[port>>BIGSUR_IOMAP_LO_SHIFT] = addr; | ||
51 | bigsur_iomap_lo_shift[port>>BIGSUR_IOMAP_LO_SHIFT] = shift; | ||
52 | addr += (1<<(BIGSUR_IOMAP_LO_SHIFT)); | ||
53 | } | ||
54 | |||
55 | for (port = max_t(u32, baseport, BIGSUR_IOMAP_LO_THRESH); | ||
56 | port < endport && port < BIGSUR_IOMAP_HI_THRESH ; | ||
57 | port += (1<<BIGSUR_IOMAP_HI_SHIFT)) { | ||
58 | pr_debug(" maphi[0x%x] = 0x%08x\n", port, addr); | ||
59 | bigsur_iomap_hi[port>>BIGSUR_IOMAP_HI_SHIFT] = addr; | ||
60 | bigsur_iomap_hi_shift[port>>BIGSUR_IOMAP_HI_SHIFT] = shift; | ||
61 | addr += (1<<(BIGSUR_IOMAP_HI_SHIFT)); | ||
62 | } | ||
63 | } | ||
64 | EXPORT_SYMBOL(bigsur_port_map); | ||
65 | |||
66 | void bigsur_port_unmap(u32 baseport, u32 nports) | ||
67 | { | ||
68 | u32 port, endport = baseport + nports; | ||
69 | |||
70 | pr_debug("bigsur_port_unmap(base=0x%0x, n=0x%0x)\n", baseport, nports); | ||
71 | |||
72 | for (port = baseport ; | ||
73 | port < endport && port < BIGSUR_IOMAP_LO_THRESH ; | ||
74 | port += (1<<BIGSUR_IOMAP_LO_SHIFT)) { | ||
75 | bigsur_iomap_lo[port>>BIGSUR_IOMAP_LO_SHIFT] = 0; | ||
76 | } | ||
77 | |||
78 | for (port = max_t(u32, baseport, BIGSUR_IOMAP_LO_THRESH); | ||
79 | port < endport && port < BIGSUR_IOMAP_HI_THRESH ; | ||
80 | port += (1<<BIGSUR_IOMAP_HI_SHIFT)) { | ||
81 | bigsur_iomap_hi[port>>BIGSUR_IOMAP_HI_SHIFT] = 0; | ||
82 | } | ||
83 | } | ||
84 | EXPORT_SYMBOL(bigsur_port_unmap); | ||
85 | |||
86 | unsigned long bigsur_isa_port2addr(unsigned long port) | ||
87 | { | ||
88 | unsigned long addr = 0; | ||
89 | unsigned char shift; | ||
90 | |||
91 | /* Physical address not in P0, do nothing */ | ||
92 | if (PXSEG(port)) { | ||
93 | addr = port; | ||
94 | /* physical address in P0, map to P2 */ | ||
95 | } else if (port >= 0x30000) { | ||
96 | addr = P2SEGADDR(port); | ||
97 | /* Big Sur I/O + HD64465 registers 0x10000-0x30000 */ | ||
98 | } else if (port >= BIGSUR_IOMAP_HI_THRESH) { | ||
99 | addr = BIGSUR_INTERNAL_BASE + (port - BIGSUR_IOMAP_HI_THRESH); | ||
100 | /* Handle remapping of high IO/PCI IO ports */ | ||
101 | } else if (port >= BIGSUR_IOMAP_LO_THRESH) { | ||
102 | addr = bigsur_iomap_hi[port >> BIGSUR_IOMAP_HI_SHIFT]; | ||
103 | shift = bigsur_iomap_hi_shift[port >> BIGSUR_IOMAP_HI_SHIFT]; | ||
104 | |||
105 | if (addr != 0) | ||
106 | addr += (port & BIGSUR_IOMAP_HI_MASK) << shift; | ||
107 | } else { | ||
108 | /* Handle remapping of low IO ports */ | ||
109 | addr = bigsur_iomap_lo[port >> BIGSUR_IOMAP_LO_SHIFT]; | ||
110 | shift = bigsur_iomap_lo_shift[port >> BIGSUR_IOMAP_LO_SHIFT]; | ||
111 | |||
112 | if (addr != 0) | ||
113 | addr += (port & BIGSUR_IOMAP_LO_MASK) << shift; | ||
114 | } | ||
115 | |||
116 | pr_debug("%s(0x%08lx) = 0x%08lx\n", __FUNCTION__, port, addr); | ||
117 | |||
118 | return addr; | ||
119 | } | ||
120 | |||
diff --git a/arch/sh/boards/bigsur/irq.c b/arch/sh/boards/bigsur/irq.c deleted file mode 100644 index 1ab04da36382..000000000000 --- a/arch/sh/boards/bigsur/irq.c +++ /dev/null | |||
@@ -1,334 +0,0 @@ | |||
1 | /* | ||
2 | * | ||
3 | * By Dustin McIntire (dustin@sensoria.com) (c)2001 | ||
4 | * | ||
5 | * Setup and IRQ handling code for the HD64465 companion chip. | ||
6 | * by Greg Banks <gbanks@pocketpenguins.com> | ||
7 | * Copyright (c) 2000 PocketPenguins Inc | ||
8 | * | ||
9 | * Derived from setup_hd64465.c which bore the message: | ||
10 | * Greg Banks <gbanks@pocketpenguins.com> | ||
11 | * Copyright (c) 2000 PocketPenguins Inc and | ||
12 | * Copyright (C) 2000 YAEGASHI Takeshi | ||
13 | * and setup_cqreek.c which bore message: | ||
14 | * Copyright (C) 2000 Niibe Yutaka | ||
15 | * | ||
16 | * May be copied or modified under the terms of the GNU General Public | ||
17 | * License. See linux/COPYING for more information. | ||
18 | * | ||
19 | * IRQ functions for a Hitachi Big Sur Evaluation Board. | ||
20 | * | ||
21 | */ | ||
22 | #undef DEBUG | ||
23 | |||
24 | #include <linux/sched.h> | ||
25 | #include <linux/module.h> | ||
26 | #include <linux/kernel.h> | ||
27 | #include <linux/param.h> | ||
28 | #include <linux/ioport.h> | ||
29 | #include <linux/interrupt.h> | ||
30 | #include <linux/init.h> | ||
31 | #include <linux/irq.h> | ||
32 | #include <linux/bitops.h> | ||
33 | |||
34 | #include <asm/io.h> | ||
35 | #include <asm/irq.h> | ||
36 | |||
37 | #include <asm/bigsur/io.h> | ||
38 | #include <asm/hd64465/hd64465.h> | ||
39 | #include <asm/bigsur/bigsur.h> | ||
40 | |||
41 | //#define BIGSUR_DEBUG 3 | ||
42 | #undef BIGSUR_DEBUG | ||
43 | |||
44 | #ifdef BIGSUR_DEBUG | ||
45 | #define DIPRINTK(n, args...) if (BIGSUR_DEBUG>(n)) printk(args) | ||
46 | #else | ||
47 | #define DIPRINTK(n, args...) | ||
48 | #endif /* BIGSUR_DEBUG */ | ||
49 | |||
50 | #ifdef CONFIG_HD64465 | ||
51 | extern int hd64465_irq_demux(int irq); | ||
52 | #endif /* CONFIG_HD64465 */ | ||
53 | |||
54 | |||
55 | /*===========================================================*/ | ||
56 | // Big Sur CPLD IRQ Routines | ||
57 | /*===========================================================*/ | ||
58 | |||
59 | /* Level 1 IRQ routines */ | ||
60 | static void disable_bigsur_l1irq(unsigned int irq) | ||
61 | { | ||
62 | unsigned char mask; | ||
63 | unsigned int mask_port = ((irq - BIGSUR_IRQ_LOW)/8) ? BIGSUR_IRLMR1 : BIGSUR_IRLMR0; | ||
64 | unsigned char bit = (1 << ((irq - MGATE_IRQ_LOW)%8) ); | ||
65 | |||
66 | if(irq >= BIGSUR_IRQ_LOW && irq < BIGSUR_IRQ_HIGH) { | ||
67 | pr_debug("Disable L1 IRQ %d\n", irq); | ||
68 | DIPRINTK(2,"disable_bigsur_l1irq: IMR=0x%08x mask=0x%x\n", | ||
69 | mask_port, bit); | ||
70 | |||
71 | /* Disable IRQ - set mask bit */ | ||
72 | mask = inb(mask_port) | bit; | ||
73 | outb(mask, mask_port); | ||
74 | return; | ||
75 | } | ||
76 | pr_debug("disable_bigsur_l1irq: Invalid IRQ %d\n", irq); | ||
77 | } | ||
78 | |||
79 | static void enable_bigsur_l1irq(unsigned int irq) | ||
80 | { | ||
81 | unsigned char mask; | ||
82 | unsigned int mask_port = ((irq - BIGSUR_IRQ_LOW)/8) ? BIGSUR_IRLMR1 : BIGSUR_IRLMR0; | ||
83 | unsigned char bit = (1 << ((irq - MGATE_IRQ_LOW)%8) ); | ||
84 | |||
85 | if(irq >= BIGSUR_IRQ_LOW && irq < BIGSUR_IRQ_HIGH) { | ||
86 | pr_debug("Enable L1 IRQ %d\n", irq); | ||
87 | DIPRINTK(2,"enable_bigsur_l1irq: IMR=0x%08x mask=0x%x\n", | ||
88 | mask_port, bit); | ||
89 | /* Enable L1 IRQ - clear mask bit */ | ||
90 | mask = inb(mask_port) & ~bit; | ||
91 | outb(mask, mask_port); | ||
92 | return; | ||
93 | } | ||
94 | pr_debug("enable_bigsur_l1irq: Invalid IRQ %d\n", irq); | ||
95 | } | ||
96 | |||
97 | |||
98 | /* Level 2 irq masks and registers for L2 decoding */ | ||
99 | /* Level2 bitmasks for each level 1 IRQ */ | ||
100 | const u32 bigsur_l2irq_mask[] = | ||
101 | {0x40,0x80,0x08,0x01,0x01,0x3C,0x3E,0xFF,0x40,0x80,0x06,0x03}; | ||
102 | /* Level2 to ISR[n] map for each level 1 IRQ */ | ||
103 | const u32 bigsur_l2irq_reg[] = | ||
104 | { 2, 2, 3, 3, 1, 2, 1, 0, 1, 1, 3, 2}; | ||
105 | /* Level2 to Level 1 IRQ map */ | ||
106 | const u32 bigsur_l2_l1_map[] = | ||
107 | {7,7,7,7,7,7,7,7, 4,6,6,6,6,6,8,9, 11,11,5,5,5,5,0,1, 3,10,10,2,-1,-1,-1,-1}; | ||
108 | /* IRQ inactive level (high or low) */ | ||
109 | const u32 bigsur_l2_inactv_state[] = {0x00, 0xBE, 0xFC, 0xF7}; | ||
110 | |||
111 | /* CPLD external status and mask registers base and offsets */ | ||
112 | static const u32 isr_base = BIGSUR_IRQ0; | ||
113 | static const u32 isr_offset = BIGSUR_IRQ0 - BIGSUR_IRQ1; | ||
114 | static const u32 imr_base = BIGSUR_IMR0; | ||
115 | static const u32 imr_offset = BIGSUR_IMR0 - BIGSUR_IMR1; | ||
116 | |||
117 | #define REG_NUM(irq) ((irq-BIGSUR_2NDLVL_IRQ_LOW)/8 ) | ||
118 | |||
119 | /* Level 2 IRQ routines */ | ||
120 | static void disable_bigsur_l2irq(unsigned int irq) | ||
121 | { | ||
122 | unsigned char mask; | ||
123 | unsigned char bit = 1 << ((irq-BIGSUR_2NDLVL_IRQ_LOW)%8); | ||
124 | unsigned int mask_port = imr_base - REG_NUM(irq)*imr_offset; | ||
125 | |||
126 | if(irq >= BIGSUR_2NDLVL_IRQ_LOW && irq < BIGSUR_2NDLVL_IRQ_HIGH) { | ||
127 | pr_debug("Disable L2 IRQ %d\n", irq); | ||
128 | DIPRINTK(2,"disable_bigsur_l2irq: IMR=0x%08x mask=0x%x\n", | ||
129 | mask_port, bit); | ||
130 | |||
131 | /* Disable L2 IRQ - set mask bit */ | ||
132 | mask = inb(mask_port) | bit; | ||
133 | outb(mask, mask_port); | ||
134 | return; | ||
135 | } | ||
136 | pr_debug("disable_bigsur_l2irq: Invalid IRQ %d\n", irq); | ||
137 | } | ||
138 | |||
139 | static void enable_bigsur_l2irq(unsigned int irq) | ||
140 | { | ||
141 | unsigned char mask; | ||
142 | unsigned char bit = 1 << ((irq-BIGSUR_2NDLVL_IRQ_LOW)%8); | ||
143 | unsigned int mask_port = imr_base - REG_NUM(irq)*imr_offset; | ||
144 | |||
145 | if(irq >= BIGSUR_2NDLVL_IRQ_LOW && irq < BIGSUR_2NDLVL_IRQ_HIGH) { | ||
146 | pr_debug("Enable L2 IRQ %d\n", irq); | ||
147 | DIPRINTK(2,"enable_bigsur_l2irq: IMR=0x%08x mask=0x%x\n", | ||
148 | mask_port, bit); | ||
149 | |||
150 | /* Enable L2 IRQ - clear mask bit */ | ||
151 | mask = inb(mask_port) & ~bit; | ||
152 | outb(mask, mask_port); | ||
153 | return; | ||
154 | } | ||
155 | pr_debug("enable_bigsur_l2irq: Invalid IRQ %d\n", irq); | ||
156 | } | ||
157 | |||
158 | static void mask_and_ack_bigsur(unsigned int irq) | ||
159 | { | ||
160 | pr_debug("mask_and_ack_bigsur IRQ %d\n", irq); | ||
161 | if(irq >= BIGSUR_IRQ_LOW && irq < BIGSUR_IRQ_HIGH) | ||
162 | disable_bigsur_l1irq(irq); | ||
163 | else | ||
164 | disable_bigsur_l2irq(irq); | ||
165 | } | ||
166 | |||
167 | static void end_bigsur_irq(unsigned int irq) | ||
168 | { | ||
169 | pr_debug("end_bigsur_irq IRQ %d\n", irq); | ||
170 | if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS))) { | ||
171 | if(irq >= BIGSUR_IRQ_LOW && irq < BIGSUR_IRQ_HIGH) | ||
172 | enable_bigsur_l1irq(irq); | ||
173 | else | ||
174 | enable_bigsur_l2irq(irq); | ||
175 | } | ||
176 | } | ||
177 | |||
178 | static unsigned int startup_bigsur_irq(unsigned int irq) | ||
179 | { | ||
180 | u8 mask; | ||
181 | u32 reg; | ||
182 | |||
183 | pr_debug("startup_bigsur_irq IRQ %d\n", irq); | ||
184 | |||
185 | if(irq >= BIGSUR_IRQ_LOW && irq < BIGSUR_IRQ_HIGH) { | ||
186 | /* Enable the L1 IRQ */ | ||
187 | enable_bigsur_l1irq(irq); | ||
188 | /* Enable all L2 IRQs in this L1 IRQ */ | ||
189 | mask = ~(bigsur_l2irq_mask[irq-BIGSUR_IRQ_LOW]); | ||
190 | reg = imr_base - bigsur_l2irq_reg[irq-BIGSUR_IRQ_LOW] * imr_offset; | ||
191 | mask &= inb(reg); | ||
192 | outb(mask,reg); | ||
193 | DIPRINTK(2,"startup_bigsur_irq: IMR=0x%08x mask=0x%x\n",reg,inb(reg)); | ||
194 | } | ||
195 | else { | ||
196 | /* Enable the L2 IRQ - clear mask bit */ | ||
197 | enable_bigsur_l2irq(irq); | ||
198 | /* Enable the L1 bit masking this L2 IRQ */ | ||
199 | enable_bigsur_l1irq(bigsur_l2_l1_map[irq-BIGSUR_2NDLVL_IRQ_LOW]); | ||
200 | DIPRINTK(2,"startup_bigsur_irq: L1=%d L2=%d\n", | ||
201 | bigsur_l2_l1_map[irq-BIGSUR_2NDLVL_IRQ_LOW],irq); | ||
202 | } | ||
203 | return 0; | ||
204 | } | ||
205 | |||
206 | static void shutdown_bigsur_irq(unsigned int irq) | ||
207 | { | ||
208 | pr_debug("shutdown_bigsur_irq IRQ %d\n", irq); | ||
209 | if(irq >= BIGSUR_IRQ_LOW && irq < BIGSUR_IRQ_HIGH) | ||
210 | disable_bigsur_l1irq(irq); | ||
211 | else | ||
212 | disable_bigsur_l2irq(irq); | ||
213 | } | ||
214 | |||
215 | /* Define the IRQ structures for the L1 and L2 IRQ types */ | ||
216 | static struct hw_interrupt_type bigsur_l1irq_type = { | ||
217 | .typename = "BigSur-CPLD-Level1-IRQ", | ||
218 | .startup = startup_bigsur_irq, | ||
219 | .shutdown = shutdown_bigsur_irq, | ||
220 | .enable = enable_bigsur_l1irq, | ||
221 | .disable = disable_bigsur_l1irq, | ||
222 | .ack = mask_and_ack_bigsur, | ||
223 | .end = end_bigsur_irq | ||
224 | }; | ||
225 | |||
226 | static struct hw_interrupt_type bigsur_l2irq_type = { | ||
227 | .typename = "BigSur-CPLD-Level2-IRQ", | ||
228 | .startup = startup_bigsur_irq, | ||
229 | .shutdown =shutdown_bigsur_irq, | ||
230 | .enable = enable_bigsur_l2irq, | ||
231 | .disable = disable_bigsur_l2irq, | ||
232 | .ack = mask_and_ack_bigsur, | ||
233 | .end = end_bigsur_irq | ||
234 | }; | ||
235 | |||
236 | |||
237 | static void make_bigsur_l1isr(unsigned int irq) { | ||
238 | |||
239 | /* sanity check first */ | ||
240 | if(irq >= BIGSUR_IRQ_LOW && irq < BIGSUR_IRQ_HIGH) { | ||
241 | /* save the handler in the main description table */ | ||
242 | irq_desc[irq].chip = &bigsur_l1irq_type; | ||
243 | irq_desc[irq].status = IRQ_DISABLED; | ||
244 | irq_desc[irq].action = 0; | ||
245 | irq_desc[irq].depth = 1; | ||
246 | |||
247 | disable_bigsur_l1irq(irq); | ||
248 | return; | ||
249 | } | ||
250 | pr_debug("make_bigsur_l1isr: bad irq, %d\n", irq); | ||
251 | return; | ||
252 | } | ||
253 | |||
254 | static void make_bigsur_l2isr(unsigned int irq) { | ||
255 | |||
256 | /* sanity check first */ | ||
257 | if(irq >= BIGSUR_2NDLVL_IRQ_LOW && irq < BIGSUR_2NDLVL_IRQ_HIGH) { | ||
258 | /* save the handler in the main description table */ | ||
259 | irq_desc[irq].chip = &bigsur_l2irq_type; | ||
260 | irq_desc[irq].status = IRQ_DISABLED; | ||
261 | irq_desc[irq].action = 0; | ||
262 | irq_desc[irq].depth = 1; | ||
263 | |||
264 | disable_bigsur_l2irq(irq); | ||
265 | return; | ||
266 | } | ||
267 | pr_debug("make_bigsur_l2isr: bad irq, %d\n", irq); | ||
268 | return; | ||
269 | } | ||
270 | |||
271 | /* The IRQ's will be decoded as follows: | ||
272 | * If a level 2 handler exists and there is an unmasked active | ||
273 | * IRQ, the 2nd level handler will be called. | ||
274 | * If a level 2 handler does not exist for the active IRQ | ||
275 | * the 1st level handler will be called. | ||
276 | */ | ||
277 | |||
278 | int bigsur_irq_demux(int irq) | ||
279 | { | ||
280 | int dmux_irq = irq; | ||
281 | u8 mask, actv_irqs; | ||
282 | u32 reg_num; | ||
283 | |||
284 | DIPRINTK(3,"bigsur_irq_demux, irq=%d\n", irq); | ||
285 | /* decode the 1st level IRQ */ | ||
286 | if(irq >= BIGSUR_IRQ_LOW && irq < BIGSUR_IRQ_HIGH) { | ||
287 | /* Get corresponding L2 ISR bitmask and ISR number */ | ||
288 | mask = bigsur_l2irq_mask[irq-BIGSUR_IRQ_LOW]; | ||
289 | reg_num = bigsur_l2irq_reg[irq-BIGSUR_IRQ_LOW]; | ||
290 | /* find the active IRQ's (XOR with inactive level)*/ | ||
291 | actv_irqs = inb(isr_base-reg_num*isr_offset) ^ | ||
292 | bigsur_l2_inactv_state[reg_num]; | ||
293 | /* decode active IRQ's */ | ||
294 | actv_irqs = actv_irqs & mask & ~(inb(imr_base-reg_num*imr_offset)); | ||
295 | /* if NEZ then we have an active L2 IRQ */ | ||
296 | if(actv_irqs) dmux_irq = ffz(~actv_irqs) + reg_num*8+BIGSUR_2NDLVL_IRQ_LOW; | ||
297 | /* if no 2nd level IRQ action, but has 1st level, use 1st level handler */ | ||
298 | if(!irq_desc[dmux_irq].action && irq_desc[irq].action) | ||
299 | dmux_irq = irq; | ||
300 | DIPRINTK(1,"bigsur_irq_demux: irq=%d dmux_irq=%d mask=0x%04x reg=%d\n", | ||
301 | irq, dmux_irq, mask, reg_num); | ||
302 | } | ||
303 | #ifdef CONFIG_HD64465 | ||
304 | dmux_irq = hd64465_irq_demux(dmux_irq); | ||
305 | #endif /* CONFIG_HD64465 */ | ||
306 | DIPRINTK(3,"bigsur_irq_demux, demux_irq=%d\n", dmux_irq); | ||
307 | |||
308 | return dmux_irq; | ||
309 | } | ||
310 | |||
311 | /*===========================================================*/ | ||
312 | // Big Sur Init Routines | ||
313 | /*===========================================================*/ | ||
314 | void __init init_bigsur_IRQ(void) | ||
315 | { | ||
316 | int i; | ||
317 | |||
318 | if (!MACH_BIGSUR) return; | ||
319 | |||
320 | /* Create ISR's for Big Sur CPLD IRQ's */ | ||
321 | /*==============================================================*/ | ||
322 | for(i=BIGSUR_IRQ_LOW;i<BIGSUR_IRQ_HIGH;i++) | ||
323 | make_bigsur_l1isr(i); | ||
324 | |||
325 | printk(KERN_INFO "Big Sur CPLD L1 interrupts %d to %d.\n", | ||
326 | BIGSUR_IRQ_LOW,BIGSUR_IRQ_HIGH); | ||
327 | |||
328 | for(i=BIGSUR_2NDLVL_IRQ_LOW;i<BIGSUR_2NDLVL_IRQ_HIGH;i++) | ||
329 | make_bigsur_l2isr(i); | ||
330 | |||
331 | printk(KERN_INFO "Big Sur CPLD L2 interrupts %d to %d.\n", | ||
332 | BIGSUR_2NDLVL_IRQ_LOW,BIGSUR_2NDLVL_IRQ_HIGH); | ||
333 | |||
334 | } | ||
diff --git a/arch/sh/boards/bigsur/led.c b/arch/sh/boards/bigsur/led.c deleted file mode 100644 index d221439aafcc..000000000000 --- a/arch/sh/boards/bigsur/led.c +++ /dev/null | |||
@@ -1,54 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/boards/bigsur/led.c | ||
3 | * | ||
4 | * By Dustin McIntire (dustin@sensoria.com) (c)2001 | ||
5 | * Derived from led_se.c and led.c, which bore the message: | ||
6 | * Copyright (C) 2000 Stuart Menefy <stuart.menefy@st.com> | ||
7 | * | ||
8 | * May be copied or modified under the terms of the GNU General Public | ||
9 | * License. See linux/COPYING for more information. | ||
10 | * | ||
11 | * This file contains Big Sur specific LED code. | ||
12 | */ | ||
13 | |||
14 | #include <asm/io.h> | ||
15 | #include <asm/bigsur/bigsur.h> | ||
16 | |||
17 | static void mach_led(int position, int value) | ||
18 | { | ||
19 | int word; | ||
20 | |||
21 | word = bigsur_inl(BIGSUR_CSLR); | ||
22 | if (value) { | ||
23 | bigsur_outl(word & ~BIGSUR_LED, BIGSUR_CSLR); | ||
24 | } else { | ||
25 | bigsur_outl(word | BIGSUR_LED, BIGSUR_CSLR); | ||
26 | } | ||
27 | } | ||
28 | |||
29 | #ifdef CONFIG_HEARTBEAT | ||
30 | |||
31 | #include <linux/sched.h> | ||
32 | |||
33 | /* Cycle the LED on/off */ | ||
34 | void heartbeat_bigsur(void) | ||
35 | { | ||
36 | static unsigned cnt = 0, period = 0, dist = 0; | ||
37 | |||
38 | if (cnt == 0 || cnt == dist) | ||
39 | mach_led( -1, 1); | ||
40 | else if (cnt == 7 || cnt == dist+7) | ||
41 | mach_led( -1, 0); | ||
42 | |||
43 | if (++cnt > period) { | ||
44 | cnt = 0; | ||
45 | /* The hyperbolic function below modifies the heartbeat period | ||
46 | * length in dependency of the current (5min) load. It goes | ||
47 | * through the points f(0)=126, f(1)=86, f(5)=51, | ||
48 | * f(inf)->30. */ | ||
49 | period = ((672<<FSHIFT)/(5*avenrun[0]+(7<<FSHIFT))) + 30; | ||
50 | dist = period / 4; | ||
51 | } | ||
52 | } | ||
53 | #endif /* CONFIG_HEARTBEAT */ | ||
54 | |||
diff --git a/arch/sh/boards/bigsur/setup.c b/arch/sh/boards/bigsur/setup.c deleted file mode 100644 index 9711c20fc9e4..000000000000 --- a/arch/sh/boards/bigsur/setup.c +++ /dev/null | |||
@@ -1,88 +0,0 @@ | |||
1 | /* | ||
2 | * | ||
3 | * By Dustin McIntire (dustin@sensoria.com) (c)2001 | ||
4 | * | ||
5 | * Setup and IRQ handling code for the HD64465 companion chip. | ||
6 | * by Greg Banks <gbanks@pocketpenguins.com> | ||
7 | * Copyright (c) 2000 PocketPenguins Inc | ||
8 | * | ||
9 | * Derived from setup_hd64465.c which bore the message: | ||
10 | * Greg Banks <gbanks@pocketpenguins.com> | ||
11 | * Copyright (c) 2000 PocketPenguins Inc and | ||
12 | * Copyright (C) 2000 YAEGASHI Takeshi | ||
13 | * and setup_cqreek.c which bore message: | ||
14 | * Copyright (C) 2000 Niibe Yutaka | ||
15 | * | ||
16 | * May be copied or modified under the terms of the GNU General Public | ||
17 | * License. See linux/COPYING for more information. | ||
18 | * | ||
19 | * Setup functions for a Hitachi Big Sur Evaluation Board. | ||
20 | * | ||
21 | */ | ||
22 | |||
23 | #include <linux/sched.h> | ||
24 | #include <linux/module.h> | ||
25 | #include <linux/kernel.h> | ||
26 | #include <linux/param.h> | ||
27 | #include <linux/ioport.h> | ||
28 | #include <linux/interrupt.h> | ||
29 | #include <linux/init.h> | ||
30 | #include <linux/irq.h> | ||
31 | #include <linux/bitops.h> | ||
32 | |||
33 | #include <asm/io.h> | ||
34 | #include <asm/irq.h> | ||
35 | #include <asm/machvec.h> | ||
36 | #include <asm/bigsur/io.h> | ||
37 | #include <asm/hd64465/hd64465.h> | ||
38 | #include <asm/bigsur/bigsur.h> | ||
39 | |||
40 | /*===========================================================*/ | ||
41 | // Big Sur Init Routines | ||
42 | /*===========================================================*/ | ||
43 | |||
44 | static void __init bigsur_setup(char **cmdline_p) | ||
45 | { | ||
46 | /* Mask all 2nd level IRQ's */ | ||
47 | outb(-1,BIGSUR_IMR0); | ||
48 | outb(-1,BIGSUR_IMR1); | ||
49 | outb(-1,BIGSUR_IMR2); | ||
50 | outb(-1,BIGSUR_IMR3); | ||
51 | |||
52 | /* Mask 1st level interrupts */ | ||
53 | outb(-1,BIGSUR_IRLMR0); | ||
54 | outb(-1,BIGSUR_IRLMR1); | ||
55 | |||
56 | #if defined (CONFIG_HD64465) && defined (CONFIG_SERIAL) | ||
57 | /* remap IO ports for first ISA serial port to HD64465 UART */ | ||
58 | bigsur_port_map(0x3f8, 8, CONFIG_HD64465_IOBASE + 0x8000, 1); | ||
59 | #endif /* CONFIG_HD64465 && CONFIG_SERIAL */ | ||
60 | /* TODO: setup IDE registers */ | ||
61 | bigsur_port_map(BIGSUR_IDECTL_IOPORT, 2, BIGSUR_ICTL, 8); | ||
62 | /* Setup the Ethernet port to BIGSUR_ETHER_IOPORT */ | ||
63 | bigsur_port_map(BIGSUR_ETHER_IOPORT, 16, BIGSUR_ETHR+BIGSUR_ETHER_IOPORT, 0); | ||
64 | /* set page to 1 */ | ||
65 | outw(1, BIGSUR_ETHR+0xe); | ||
66 | /* set the IO port to BIGSUR_ETHER_IOPORT */ | ||
67 | outw(BIGSUR_ETHER_IOPORT<<3, BIGSUR_ETHR+0x2); | ||
68 | } | ||
69 | |||
70 | /* | ||
71 | * The Machine Vector | ||
72 | */ | ||
73 | extern void heartbeat_bigsur(void); | ||
74 | extern void init_bigsur_IRQ(void); | ||
75 | |||
76 | struct sh_machine_vector mv_bigsur __initmv = { | ||
77 | .mv_name = "Big Sur", | ||
78 | .mv_setup = bigsur_setup, | ||
79 | |||
80 | .mv_isa_port2addr = bigsur_isa_port2addr, | ||
81 | .mv_irq_demux = bigsur_irq_demux, | ||
82 | |||
83 | .mv_init_irq = init_bigsur_IRQ, | ||
84 | #ifdef CONFIG_HEARTBEAT | ||
85 | .mv_heartbeat = heartbeat_bigsur, | ||
86 | #endif | ||
87 | }; | ||
88 | ALIAS_MV(bigsur) | ||
diff --git a/arch/sh/boards/ec3104/Makefile b/arch/sh/boards/ec3104/Makefile deleted file mode 100644 index 178891534b67..000000000000 --- a/arch/sh/boards/ec3104/Makefile +++ /dev/null | |||
@@ -1,6 +0,0 @@ | |||
1 | # | ||
2 | # Makefile for the EC3104 specific parts of the kernel | ||
3 | # | ||
4 | |||
5 | obj-y := setup.o io.o irq.o | ||
6 | |||
diff --git a/arch/sh/boards/ec3104/io.c b/arch/sh/boards/ec3104/io.c deleted file mode 100644 index 2f86394b280b..000000000000 --- a/arch/sh/boards/ec3104/io.c +++ /dev/null | |||
@@ -1,81 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/boards/ec3104/io.c | ||
3 | * EC3104 companion chip support | ||
4 | * | ||
5 | * Copyright (C) 2000 Philipp Rumpf <prumpf@tux.org> | ||
6 | * | ||
7 | */ | ||
8 | /* EC3104 note: | ||
9 | * This code was written without any documentation about the EC3104 chip. While | ||
10 | * I hope I got most of the basic functionality right, the register names I use | ||
11 | * are most likely completely different from those in the chip documentation. | ||
12 | * | ||
13 | * If you have any further information about the EC3104, please tell me | ||
14 | * (prumpf@tux.org). | ||
15 | */ | ||
16 | |||
17 | #include <linux/kernel.h> | ||
18 | #include <linux/types.h> | ||
19 | #include <asm/io.h> | ||
20 | #include <asm/page.h> | ||
21 | #include <asm/ec3104/ec3104.h> | ||
22 | |||
23 | /* | ||
24 | * EC3104 has a real ISA bus which we redirect low port accesses to (the | ||
25 | * actual device on mine is a ESS 1868, and I don't want to hack the driver | ||
26 | * more than strictly necessary). I am not going to duplicate the | ||
27 | * hard coding of PC addresses (for the 16550s aso) here though; it's just | ||
28 | * too ugly. | ||
29 | */ | ||
30 | |||
31 | #define low_port(port) ((port) < 0x10000) | ||
32 | |||
33 | static inline unsigned long port2addr(unsigned long port) | ||
34 | { | ||
35 | switch(port >> 16) { | ||
36 | case 0: | ||
37 | return EC3104_ISA_BASE + port * 2; | ||
38 | |||
39 | /* XXX hack. it's unclear what to do about the serial ports */ | ||
40 | case 1: | ||
41 | return EC3104_BASE + (port&0xffff) * 4; | ||
42 | |||
43 | default: | ||
44 | /* XXX PCMCIA */ | ||
45 | return 0; | ||
46 | } | ||
47 | } | ||
48 | |||
49 | unsigned char ec3104_inb(unsigned long port) | ||
50 | { | ||
51 | u8 ret; | ||
52 | |||
53 | ret = *(volatile u8 *)port2addr(port); | ||
54 | |||
55 | return ret; | ||
56 | } | ||
57 | |||
58 | unsigned short ec3104_inw(unsigned long port) | ||
59 | { | ||
60 | BUG(); | ||
61 | } | ||
62 | |||
63 | unsigned long ec3104_inl(unsigned long port) | ||
64 | { | ||
65 | BUG(); | ||
66 | } | ||
67 | |||
68 | void ec3104_outb(unsigned char data, unsigned long port) | ||
69 | { | ||
70 | *(volatile u8 *)port2addr(port) = data; | ||
71 | } | ||
72 | |||
73 | void ec3104_outw(unsigned short data, unsigned long port) | ||
74 | { | ||
75 | BUG(); | ||
76 | } | ||
77 | |||
78 | void ec3104_outl(unsigned long data, unsigned long port) | ||
79 | { | ||
80 | BUG(); | ||
81 | } | ||
diff --git a/arch/sh/boards/ec3104/irq.c b/arch/sh/boards/ec3104/irq.c deleted file mode 100644 index ffa4ff1f090f..000000000000 --- a/arch/sh/boards/ec3104/irq.c +++ /dev/null | |||
@@ -1,196 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/boards/ec3104/irq.c | ||
3 | * EC3104 companion chip support | ||
4 | * | ||
5 | * Copyright (C) 2000 Philipp Rumpf <prumpf@tux.org> | ||
6 | * | ||
7 | */ | ||
8 | |||
9 | #include <asm/io.h> | ||
10 | #include <asm/irq.h> | ||
11 | #include <asm/ec3104/ec3104.h> | ||
12 | |||
13 | /* This is for debugging mostly; here's the table that I intend to keep | ||
14 | * in here: | ||
15 | * | ||
16 | * index function base addr power interrupt bit | ||
17 | * 0 power b0ec0000 --- 00000001 (unused) | ||
18 | * 1 irqs b0ec1000 --- 00000002 (unused) | ||
19 | * 2 ?? b0ec2000 b0ec0008 00000004 | ||
20 | * 3 PS2 (1) b0ec3000 b0ec000c 00000008 | ||
21 | * 4 PS2 (2) b0ec4000 b0ec0010 00000010 | ||
22 | * 5 ?? b0ec5000 b0ec0014 00000020 | ||
23 | * 6 I2C b0ec6000 b0ec0018 00000040 | ||
24 | * 7 serial (1) b0ec7000 b0ec001c 00000080 | ||
25 | * 8 serial (2) b0ec8000 b0ec0020 00000100 | ||
26 | * 9 serial (3) b0ec9000 b0ec0024 00000200 | ||
27 | * 10 serial (4) b0eca000 b0ec0028 00000400 | ||
28 | * 12 GPIO (1) b0ecc000 b0ec0030 | ||
29 | * 13 GPIO (2) b0ecc000 b0ec0030 | ||
30 | * 16 pcmcia (1) b0ed0000 b0ec0040 00010000 | ||
31 | * 17 pcmcia (2) b0ed1000 b0ec0044 00020000 | ||
32 | */ | ||
33 | |||
34 | /* I used the register names from another interrupt controller I worked with, | ||
35 | * since it seems to be identical to the ec3104 except that all bits are | ||
36 | * inverted: | ||
37 | * | ||
38 | * IRR: Interrupt Request Register (pending and enabled interrupts) | ||
39 | * IMR: Interrupt Mask Register (which interrupts are enabled) | ||
40 | * IPR: Interrupt Pending Register (pending interrupts, even disabled ones) | ||
41 | * | ||
42 | * 0 bits mean pending or enabled, 1 bits mean not pending or disabled. all | ||
43 | * IRQs seem to be level-triggered. | ||
44 | */ | ||
45 | |||
46 | #define EC3104_IRR (EC3104_BASE + 0x1000) | ||
47 | #define EC3104_IMR (EC3104_BASE + 0x1004) | ||
48 | #define EC3104_IPR (EC3104_BASE + 0x1008) | ||
49 | |||
50 | #define ctrl_readl(addr) (*(volatile u32 *)(addr)) | ||
51 | #define ctrl_writel(data,addr) (*(volatile u32 *)(addr) = (data)) | ||
52 | #define ctrl_readb(addr) (*(volatile u8 *)(addr)) | ||
53 | |||
54 | static char *ec3104_name(unsigned index) | ||
55 | { | ||
56 | switch(index) { | ||
57 | case 0: | ||
58 | return "power management"; | ||
59 | case 1: | ||
60 | return "interrupts"; | ||
61 | case 3: | ||
62 | return "PS2 (1)"; | ||
63 | case 4: | ||
64 | return "PS2 (2)"; | ||
65 | case 5: | ||
66 | return "I2C (1)"; | ||
67 | case 6: | ||
68 | return "I2C (2)"; | ||
69 | case 7: | ||
70 | return "serial (1)"; | ||
71 | case 8: | ||
72 | return "serial (2)"; | ||
73 | case 9: | ||
74 | return "serial (3)"; | ||
75 | case 10: | ||
76 | return "serial (4)"; | ||
77 | case 16: | ||
78 | return "pcmcia (1)"; | ||
79 | case 17: | ||
80 | return "pcmcia (2)"; | ||
81 | default: { | ||
82 | static char buf[32]; | ||
83 | |||
84 | sprintf(buf, "unknown (%d)", index); | ||
85 | |||
86 | return buf; | ||
87 | } | ||
88 | } | ||
89 | } | ||
90 | |||
91 | int get_pending_interrupts(char *buf) | ||
92 | { | ||
93 | u32 ipr; | ||
94 | u32 bit; | ||
95 | char *p = buf; | ||
96 | |||
97 | p += sprintf(p, "pending: ("); | ||
98 | |||
99 | ipr = ctrl_inl(EC3104_IPR); | ||
100 | |||
101 | for (bit = 1; bit < 32; bit++) | ||
102 | if (!(ipr & (1<<bit))) | ||
103 | p += sprintf(p, "%s ", ec3104_name(bit)); | ||
104 | |||
105 | p += sprintf(p, ")\n"); | ||
106 | |||
107 | return p - buf; | ||
108 | } | ||
109 | |||
110 | static inline u32 ec3104_irq2mask(unsigned int irq) | ||
111 | { | ||
112 | return (1 << (irq - EC3104_IRQBASE)); | ||
113 | } | ||
114 | |||
115 | static inline void mask_ec3104_irq(unsigned int irq) | ||
116 | { | ||
117 | u32 mask; | ||
118 | |||
119 | mask = ctrl_readl(EC3104_IMR); | ||
120 | |||
121 | mask |= ec3104_irq2mask(irq); | ||
122 | |||
123 | ctrl_writel(mask, EC3104_IMR); | ||
124 | } | ||
125 | |||
126 | static inline void unmask_ec3104_irq(unsigned int irq) | ||
127 | { | ||
128 | u32 mask; | ||
129 | |||
130 | mask = ctrl_readl(EC3104_IMR); | ||
131 | |||
132 | mask &= ~ec3104_irq2mask(irq); | ||
133 | |||
134 | ctrl_writel(mask, EC3104_IMR); | ||
135 | } | ||
136 | |||
137 | static void disable_ec3104_irq(unsigned int irq) | ||
138 | { | ||
139 | mask_ec3104_irq(irq); | ||
140 | } | ||
141 | |||
142 | static void enable_ec3104_irq(unsigned int irq) | ||
143 | { | ||
144 | unmask_ec3104_irq(irq); | ||
145 | } | ||
146 | |||
147 | static void mask_and_ack_ec3104_irq(unsigned int irq) | ||
148 | { | ||
149 | mask_ec3104_irq(irq); | ||
150 | } | ||
151 | |||
152 | static void end_ec3104_irq(unsigned int irq) | ||
153 | { | ||
154 | if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS))) | ||
155 | unmask_ec3104_irq(irq); | ||
156 | } | ||
157 | |||
158 | static unsigned int startup_ec3104_irq(unsigned int irq) | ||
159 | { | ||
160 | unmask_ec3104_irq(irq); | ||
161 | |||
162 | return 0; | ||
163 | } | ||
164 | |||
165 | static void shutdown_ec3104_irq(unsigned int irq) | ||
166 | { | ||
167 | mask_ec3104_irq(irq); | ||
168 | |||
169 | } | ||
170 | |||
171 | static struct hw_interrupt_type ec3104_int = { | ||
172 | .typename = "EC3104", | ||
173 | .enable = enable_ec3104_irq, | ||
174 | .disable = disable_ec3104_irq, | ||
175 | .ack = mask_and_ack_ec3104_irq, | ||
176 | .end = end_ec3104_irq, | ||
177 | .startup = startup_ec3104_irq, | ||
178 | .shutdown = shutdown_ec3104_irq, | ||
179 | }; | ||
180 | |||
181 | /* Yuck. the _demux API is ugly */ | ||
182 | int ec3104_irq_demux(int irq) | ||
183 | { | ||
184 | if (irq == EC3104_IRQ) { | ||
185 | unsigned int mask; | ||
186 | |||
187 | mask = ctrl_readl(EC3104_IRR); | ||
188 | |||
189 | if (mask == 0xffffffff) | ||
190 | return EC3104_IRQ; | ||
191 | else | ||
192 | return EC3104_IRQBASE + ffz(mask); | ||
193 | } | ||
194 | |||
195 | return irq; | ||
196 | } | ||
diff --git a/arch/sh/boards/ec3104/setup.c b/arch/sh/boards/ec3104/setup.c deleted file mode 100644 index 902bc975a13e..000000000000 --- a/arch/sh/boards/ec3104/setup.c +++ /dev/null | |||
@@ -1,65 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/boards/ec3104/setup.c | ||
3 | * EC3104 companion chip support | ||
4 | * | ||
5 | * Copyright (C) 2000 Philipp Rumpf <prumpf@tux.org> | ||
6 | * | ||
7 | */ | ||
8 | /* EC3104 note: | ||
9 | * This code was written without any documentation about the EC3104 chip. While | ||
10 | * I hope I got most of the basic functionality right, the register names I use | ||
11 | * are most likely completely different from those in the chip documentation. | ||
12 | * | ||
13 | * If you have any further information about the EC3104, please tell me | ||
14 | * (prumpf@tux.org). | ||
15 | */ | ||
16 | |||
17 | #include <linux/sched.h> | ||
18 | #include <linux/kernel.h> | ||
19 | #include <linux/param.h> | ||
20 | #include <linux/interrupt.h> | ||
21 | #include <linux/init.h> | ||
22 | #include <linux/irq.h> | ||
23 | #include <linux/types.h> | ||
24 | #include <asm/io.h> | ||
25 | #include <asm/irq.h> | ||
26 | #include <asm/machvec.h> | ||
27 | #include <asm/mach/ec3104.h> | ||
28 | |||
29 | static void __init ec3104_setup(char **cmdline_p) | ||
30 | { | ||
31 | char str[8]; | ||
32 | int i; | ||
33 | |||
34 | for (i=0; i<8; i++) | ||
35 | str[i] = ctrl_readb(EC3104_BASE + i); | ||
36 | |||
37 | for (i = EC3104_IRQBASE; i < EC3104_IRQBASE + 32; i++) | ||
38 | irq_desc[i].handler = &ec3104_int; | ||
39 | |||
40 | printk("initializing EC3104 \"%.8s\" at %08x, IRQ %d, IRQ base %d\n", | ||
41 | str, EC3104_BASE, EC3104_IRQ, EC3104_IRQBASE); | ||
42 | |||
43 | /* mask all interrupts. this should have been done by the boot | ||
44 | * loader for us but we want to be sure ... */ | ||
45 | ctrl_writel(0xffffffff, EC3104_IMR); | ||
46 | } | ||
47 | |||
48 | /* | ||
49 | * The Machine Vector | ||
50 | */ | ||
51 | struct sh_machine_vector mv_ec3104 __initmv = { | ||
52 | .mv_name = "EC3104", | ||
53 | .mv_setup = ec3104_setup, | ||
54 | .mv_nr_irqs = 96, | ||
55 | |||
56 | .mv_inb = ec3104_inb, | ||
57 | .mv_inw = ec3104_inw, | ||
58 | .mv_inl = ec3104_inl, | ||
59 | .mv_outb = ec3104_outb, | ||
60 | .mv_outw = ec3104_outw, | ||
61 | .mv_outl = ec3104_outl, | ||
62 | |||
63 | .mv_irq_demux = ec3104_irq_demux, | ||
64 | }; | ||
65 | ALIAS_MV(ec3104) | ||
diff --git a/arch/sh/boards/mpc1211/Makefile b/arch/sh/boards/mpc1211/Makefile index 1644ebed78cb..8cd31b5d200b 100644 --- a/arch/sh/boards/mpc1211/Makefile +++ b/arch/sh/boards/mpc1211/Makefile | |||
@@ -2,7 +2,7 @@ | |||
2 | # Makefile for the Interface (CTP/PCI/MPC-SH02) specific parts of the kernel | 2 | # Makefile for the Interface (CTP/PCI/MPC-SH02) specific parts of the kernel |
3 | # | 3 | # |
4 | 4 | ||
5 | obj-y := setup.o rtc.o led.o | 5 | obj-y := setup.o rtc.o |
6 | 6 | ||
7 | obj-$(CONFIG_PCI) += pci.o | 7 | obj-$(CONFIG_PCI) += pci.o |
8 | 8 | ||
diff --git a/arch/sh/boards/mpc1211/led.c b/arch/sh/boards/mpc1211/led.c deleted file mode 100644 index 8df1591823d6..000000000000 --- a/arch/sh/boards/mpc1211/led.c +++ /dev/null | |||
@@ -1,63 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/boards/mpc1211/led.c | ||
3 | * | ||
4 | * Copyright (C) 2001 Saito.K & Jeanne | ||
5 | * | ||
6 | * This file contains Interface MPC-1211 specific LED code. | ||
7 | */ | ||
8 | |||
9 | |||
10 | static void mach_led(int position, int value) | ||
11 | { | ||
12 | volatile unsigned char* p = (volatile unsigned char*)0xa2000000; | ||
13 | |||
14 | if (value) { | ||
15 | *p |= 1; | ||
16 | } else { | ||
17 | *p &= ~1; | ||
18 | } | ||
19 | } | ||
20 | |||
21 | #ifdef CONFIG_HEARTBEAT | ||
22 | |||
23 | #include <linux/sched.h> | ||
24 | |||
25 | /* Cycle the LED's in the clasic Knightrider/Sun pattern */ | ||
26 | void heartbeat_mpc1211(void) | ||
27 | { | ||
28 | static unsigned int cnt = 0, period = 0; | ||
29 | volatile unsigned char* p = (volatile unsigned char*)0xa2000000; | ||
30 | static unsigned bit = 0, up = 1; | ||
31 | |||
32 | cnt += 1; | ||
33 | if (cnt < period) { | ||
34 | return; | ||
35 | } | ||
36 | |||
37 | cnt = 0; | ||
38 | |||
39 | /* Go through the points (roughly!): | ||
40 | * f(0)=10, f(1)=16, f(2)=20, f(5)=35,f(inf)->110 | ||
41 | */ | ||
42 | period = 110 - ( (300<<FSHIFT)/ | ||
43 | ((avenrun[0]/5) + (3<<FSHIFT)) ); | ||
44 | |||
45 | if (up) { | ||
46 | if (bit == 7) { | ||
47 | bit--; | ||
48 | up=0; | ||
49 | } else { | ||
50 | bit ++; | ||
51 | } | ||
52 | } else { | ||
53 | if (bit == 0) { | ||
54 | bit++; | ||
55 | up=1; | ||
56 | } else { | ||
57 | bit--; | ||
58 | } | ||
59 | } | ||
60 | *p = 1<<bit; | ||
61 | |||
62 | } | ||
63 | #endif /* CONFIG_HEARTBEAT */ | ||
diff --git a/arch/sh/boards/mpc1211/setup.c b/arch/sh/boards/mpc1211/setup.c index 7c3d1d304157..1a0604b23ce0 100644 --- a/arch/sh/boards/mpc1211/setup.c +++ b/arch/sh/boards/mpc1211/setup.c | |||
@@ -10,6 +10,7 @@ | |||
10 | #include <linux/hdreg.h> | 10 | #include <linux/hdreg.h> |
11 | #include <linux/ide.h> | 11 | #include <linux/ide.h> |
12 | #include <linux/interrupt.h> | 12 | #include <linux/interrupt.h> |
13 | #include <linux/platform_device.h> | ||
13 | #include <asm/io.h> | 14 | #include <asm/io.h> |
14 | #include <asm/machvec.h> | 15 | #include <asm/machvec.h> |
15 | #include <asm/mpc1211/mpc1211.h> | 16 | #include <asm/mpc1211/mpc1211.h> |
@@ -281,6 +282,32 @@ static int put_smb_blk(unsigned char *p, int address, int command, int no) | |||
281 | return 0; | 282 | return 0; |
282 | } | 283 | } |
283 | 284 | ||
285 | static struct resource heartbeat_resources[] = { | ||
286 | [0] = { | ||
287 | .start = 0xa2000000, | ||
288 | .end = 0xa2000000 + 8 - 1, | ||
289 | .flags = IORESOURCE_MEM, | ||
290 | }, | ||
291 | }; | ||
292 | |||
293 | static struct platform_device heartbeat_device = { | ||
294 | .name = "heartbeat", | ||
295 | .id = -1, | ||
296 | .num_resources = ARRAY_SIZE(heartbeat_resources), | ||
297 | .resource = heartbeat_resources, | ||
298 | }; | ||
299 | |||
300 | static struct platform_device *mpc1211_devices[] __initdata = { | ||
301 | &heartbeat_device, | ||
302 | }; | ||
303 | |||
304 | static int __init mpc1211_devices_setup(void) | ||
305 | { | ||
306 | return platform_add_devices(mpc1211_devices, | ||
307 | ARRAY_SIZE(mpc1211_devices)); | ||
308 | } | ||
309 | __initcall(mpc1211_devices_setup); | ||
310 | |||
284 | /* arch/sh/boards/mpc1211/rtc.c */ | 311 | /* arch/sh/boards/mpc1211/rtc.c */ |
285 | void mpc1211_time_init(void); | 312 | void mpc1211_time_init(void); |
286 | 313 | ||
@@ -317,9 +344,5 @@ struct sh_machine_vector mv_mpc1211 __initmv = { | |||
317 | .mv_nr_irqs = 48, | 344 | .mv_nr_irqs = 48, |
318 | .mv_irq_demux = mpc1211_irq_demux, | 345 | .mv_irq_demux = mpc1211_irq_demux, |
319 | .mv_init_irq = init_mpc1211_IRQ, | 346 | .mv_init_irq = init_mpc1211_IRQ, |
320 | |||
321 | #ifdef CONFIG_HEARTBEAT | ||
322 | .mv_heartbeat = heartbeat_mpc1211, | ||
323 | #endif | ||
324 | }; | 347 | }; |
325 | ALIAS_MV(mpc1211) | 348 | ALIAS_MV(mpc1211) |
diff --git a/arch/sh/boards/renesas/r7780rp/Makefile b/arch/sh/boards/renesas/r7780rp/Makefile index 574b0316ed56..3c93012e91a3 100644 --- a/arch/sh/boards/renesas/r7780rp/Makefile +++ b/arch/sh/boards/renesas/r7780rp/Makefile | |||
@@ -4,5 +4,4 @@ | |||
4 | 4 | ||
5 | obj-y := setup.o io.o irq.o | 5 | obj-y := setup.o io.o irq.o |
6 | 6 | ||
7 | obj-$(CONFIG_HEARTBEAT) += led.o | ||
8 | obj-$(CONFIG_PUSH_SWITCH) += psw.o | 7 | obj-$(CONFIG_PUSH_SWITCH) += psw.o |
diff --git a/arch/sh/boards/renesas/r7780rp/io.c b/arch/sh/boards/renesas/r7780rp/io.c index 311ccccba718..f74d2ffb3851 100644 --- a/arch/sh/boards/renesas/r7780rp/io.c +++ b/arch/sh/boards/renesas/r7780rp/io.c | |||
@@ -11,22 +11,9 @@ | |||
11 | #include <linux/pci.h> | 11 | #include <linux/pci.h> |
12 | #include <linux/kernel.h> | 12 | #include <linux/kernel.h> |
13 | #include <linux/types.h> | 13 | #include <linux/types.h> |
14 | #include <linux/io.h> | ||
14 | #include <asm/r7780rp.h> | 15 | #include <asm/r7780rp.h> |
15 | #include <asm/addrspace.h> | 16 | #include <asm/addrspace.h> |
16 | #include <asm/io.h> | ||
17 | |||
18 | static inline unsigned long port2adr(unsigned int port) | ||
19 | { | ||
20 | if ((0x1f0 <= port && port < 0x1f8) || port == 0x3f6) | ||
21 | if (port == 0x3f6) | ||
22 | return (PA_AREA5_IO + 0x80c); | ||
23 | else | ||
24 | return (PA_AREA5_IO + 0x1000 + ((port-0x1f0) << 1)); | ||
25 | else | ||
26 | maybebadio((unsigned long)port); | ||
27 | |||
28 | return port; | ||
29 | } | ||
30 | 17 | ||
31 | static inline unsigned long port88796l(unsigned int port, int flag) | 18 | static inline unsigned long port88796l(unsigned int port, int flag) |
32 | { | 19 | { |
@@ -40,18 +27,6 @@ static inline unsigned long port88796l(unsigned int port, int flag) | |||
40 | return addr; | 27 | return addr; |
41 | } | 28 | } |
42 | 29 | ||
43 | /* The 7780 R7780RP-1 seems to have everything hooked */ | ||
44 | /* up pretty normally (nothing on high-bytes only...) so this */ | ||
45 | /* shouldn't be needed */ | ||
46 | static inline int shifted_port(unsigned long port) | ||
47 | { | ||
48 | /* For IDE registers, value is not shifted */ | ||
49 | if ((0x1f0 <= port && port < 0x1f8) || port == 0x3f6) | ||
50 | return 0; | ||
51 | else | ||
52 | return 1; | ||
53 | } | ||
54 | |||
55 | #if defined(CONFIG_NE2000) || defined(CONFIG_NE2000_MODULE) | 30 | #if defined(CONFIG_NE2000) || defined(CONFIG_NE2000_MODULE) |
56 | #define CHECK_AX88796L_PORT(port) \ | 31 | #define CHECK_AX88796L_PORT(port) \ |
57 | ((port >= AX88796L_IO_BASE) && (port < (AX88796L_IO_BASE+0x20))) | 32 | ((port >= AX88796L_IO_BASE) && (port < (AX88796L_IO_BASE+0x20))) |
@@ -70,12 +45,10 @@ u8 r7780rp_inb(unsigned long port) | |||
70 | { | 45 | { |
71 | if (CHECK_AX88796L_PORT(port)) | 46 | if (CHECK_AX88796L_PORT(port)) |
72 | return ctrl_inw(port88796l(port, 0)) & 0xff; | 47 | return ctrl_inw(port88796l(port, 0)) & 0xff; |
73 | else if (PXSEG(port)) | 48 | else if (is_pci_ioaddr(port)) |
74 | return ctrl_inb(port); | ||
75 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
76 | return ctrl_inb(pci_ioaddr(port)); | 49 | return ctrl_inb(pci_ioaddr(port)); |
77 | 50 | ||
78 | return ctrl_inw(port2adr(port)) & 0xff; | 51 | return ctrl_inw(port) & 0xff; |
79 | } | 52 | } |
80 | 53 | ||
81 | u8 r7780rp_inb_p(unsigned long port) | 54 | u8 r7780rp_inb_p(unsigned long port) |
@@ -84,12 +57,10 @@ u8 r7780rp_inb_p(unsigned long port) | |||
84 | 57 | ||
85 | if (CHECK_AX88796L_PORT(port)) | 58 | if (CHECK_AX88796L_PORT(port)) |
86 | v = ctrl_inw(port88796l(port, 0)) & 0xff; | 59 | v = ctrl_inw(port88796l(port, 0)) & 0xff; |
87 | else if (PXSEG(port)) | 60 | else if (is_pci_ioaddr(port)) |
88 | v = ctrl_inb(port); | ||
89 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
90 | v = ctrl_inb(pci_ioaddr(port)); | 61 | v = ctrl_inb(pci_ioaddr(port)); |
91 | else | 62 | else |
92 | v = ctrl_inw(port2adr(port)) & 0xff; | 63 | v = ctrl_inw(port) & 0xff; |
93 | 64 | ||
94 | ctrl_delay(); | 65 | ctrl_delay(); |
95 | 66 | ||
@@ -98,80 +69,56 @@ u8 r7780rp_inb_p(unsigned long port) | |||
98 | 69 | ||
99 | u16 r7780rp_inw(unsigned long port) | 70 | u16 r7780rp_inw(unsigned long port) |
100 | { | 71 | { |
101 | if (CHECK_AX88796L_PORT(port)) | 72 | if (is_pci_ioaddr(port)) |
102 | maybebadio(port); | ||
103 | else if (PXSEG(port)) | ||
104 | return ctrl_inw(port); | ||
105 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
106 | return ctrl_inw(pci_ioaddr(port)); | 73 | return ctrl_inw(pci_ioaddr(port)); |
107 | else | ||
108 | maybebadio(port); | ||
109 | 74 | ||
110 | return 0; | 75 | return ctrl_inw(port); |
111 | } | 76 | } |
112 | 77 | ||
113 | u32 r7780rp_inl(unsigned long port) | 78 | u32 r7780rp_inl(unsigned long port) |
114 | { | 79 | { |
115 | if (CHECK_AX88796L_PORT(port)) | 80 | if (is_pci_ioaddr(port)) |
116 | maybebadio(port); | ||
117 | else if (PXSEG(port)) | ||
118 | return ctrl_inl(port); | ||
119 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
120 | return ctrl_inl(pci_ioaddr(port)); | 81 | return ctrl_inl(pci_ioaddr(port)); |
121 | else | ||
122 | maybebadio(port); | ||
123 | 82 | ||
124 | return 0; | 83 | return ctrl_inl(port); |
125 | } | 84 | } |
126 | 85 | ||
127 | void r7780rp_outb(u8 value, unsigned long port) | 86 | void r7780rp_outb(u8 value, unsigned long port) |
128 | { | 87 | { |
129 | if (CHECK_AX88796L_PORT(port)) | 88 | if (CHECK_AX88796L_PORT(port)) |
130 | ctrl_outw(value, port88796l(port, 0)); | 89 | ctrl_outw(value, port88796l(port, 0)); |
131 | else if (PXSEG(port)) | 90 | else if (is_pci_ioaddr(port)) |
132 | ctrl_outb(value, port); | ||
133 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
134 | ctrl_outb(value, pci_ioaddr(port)); | 91 | ctrl_outb(value, pci_ioaddr(port)); |
135 | else | 92 | else |
136 | ctrl_outw(value, port2adr(port)); | 93 | ctrl_outb(value, port); |
137 | } | 94 | } |
138 | 95 | ||
139 | void r7780rp_outb_p(u8 value, unsigned long port) | 96 | void r7780rp_outb_p(u8 value, unsigned long port) |
140 | { | 97 | { |
141 | if (CHECK_AX88796L_PORT(port)) | 98 | if (CHECK_AX88796L_PORT(port)) |
142 | ctrl_outw(value, port88796l(port, 0)); | 99 | ctrl_outw(value, port88796l(port, 0)); |
143 | else if (PXSEG(port)) | 100 | else if (is_pci_ioaddr(port)) |
144 | ctrl_outb(value, port); | ||
145 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
146 | ctrl_outb(value, pci_ioaddr(port)); | 101 | ctrl_outb(value, pci_ioaddr(port)); |
147 | else | 102 | else |
148 | ctrl_outw(value, port2adr(port)); | 103 | ctrl_outb(value, port); |
149 | 104 | ||
150 | ctrl_delay(); | 105 | ctrl_delay(); |
151 | } | 106 | } |
152 | 107 | ||
153 | void r7780rp_outw(u16 value, unsigned long port) | 108 | void r7780rp_outw(u16 value, unsigned long port) |
154 | { | 109 | { |
155 | if (CHECK_AX88796L_PORT(port)) | 110 | if (is_pci_ioaddr(port)) |
156 | maybebadio(port); | ||
157 | else if (PXSEG(port)) | ||
158 | ctrl_outw(value, port); | ||
159 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
160 | ctrl_outw(value, pci_ioaddr(port)); | 111 | ctrl_outw(value, pci_ioaddr(port)); |
161 | else | 112 | else |
162 | maybebadio(port); | 113 | ctrl_outw(value, port); |
163 | } | 114 | } |
164 | 115 | ||
165 | void r7780rp_outl(u32 value, unsigned long port) | 116 | void r7780rp_outl(u32 value, unsigned long port) |
166 | { | 117 | { |
167 | if (CHECK_AX88796L_PORT(port)) | 118 | if (is_pci_ioaddr(port)) |
168 | maybebadio(port); | ||
169 | else if (PXSEG(port)) | ||
170 | ctrl_outl(value, port); | ||
171 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
172 | ctrl_outl(value, pci_ioaddr(port)); | 119 | ctrl_outl(value, pci_ioaddr(port)); |
173 | else | 120 | else |
174 | maybebadio(port); | 121 | ctrl_outl(value, port); |
175 | } | 122 | } |
176 | 123 | ||
177 | void r7780rp_insb(unsigned long port, void *dst, unsigned long count) | 124 | void r7780rp_insb(unsigned long port, void *dst, unsigned long count) |
@@ -183,16 +130,13 @@ void r7780rp_insb(unsigned long port, void *dst, unsigned long count) | |||
183 | p = (volatile u16 *)port88796l(port, 0); | 130 | p = (volatile u16 *)port88796l(port, 0); |
184 | while (count--) | 131 | while (count--) |
185 | *buf++ = *p & 0xff; | 132 | *buf++ = *p & 0xff; |
186 | } else if (PXSEG(port)) { | 133 | } else if (is_pci_ioaddr(port)) { |
187 | while (count--) | ||
188 | *buf++ = *(volatile u8 *)port; | ||
189 | } else if (is_pci_ioaddr(port) || shifted_port(port)) { | ||
190 | volatile u8 *bp = (volatile u8 *)pci_ioaddr(port); | 134 | volatile u8 *bp = (volatile u8 *)pci_ioaddr(port); |
191 | 135 | ||
192 | while (count--) | 136 | while (count--) |
193 | *buf++ = *bp; | 137 | *buf++ = *bp; |
194 | } else { | 138 | } else { |
195 | p = (volatile u16 *)port2adr(port); | 139 | p = (volatile u16 *)port; |
196 | while (count--) | 140 | while (count--) |
197 | *buf++ = *p & 0xff; | 141 | *buf++ = *p & 0xff; |
198 | } | 142 | } |
@@ -205,30 +149,26 @@ void r7780rp_insw(unsigned long port, void *dst, unsigned long count) | |||
205 | 149 | ||
206 | if (CHECK_AX88796L_PORT(port)) | 150 | if (CHECK_AX88796L_PORT(port)) |
207 | p = (volatile u16 *)port88796l(port, 1); | 151 | p = (volatile u16 *)port88796l(port, 1); |
208 | else if (PXSEG(port)) | 152 | else if (is_pci_ioaddr(port)) |
209 | p = (volatile u16 *)port; | ||
210 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
211 | p = (volatile u16 *)pci_ioaddr(port); | 153 | p = (volatile u16 *)pci_ioaddr(port); |
212 | else | 154 | else |
213 | p = (volatile u16 *)port2adr(port); | 155 | p = (volatile u16 *)port; |
214 | 156 | ||
215 | while (count--) | 157 | while (count--) |
216 | *buf++ = *p; | 158 | *buf++ = *p; |
159 | |||
160 | flush_dcache_all(); | ||
217 | } | 161 | } |
218 | 162 | ||
219 | void r7780rp_insl(unsigned long port, void *dst, unsigned long count) | 163 | void r7780rp_insl(unsigned long port, void *dst, unsigned long count) |
220 | { | 164 | { |
221 | u32 *buf = dst; | 165 | if (is_pci_ioaddr(port)) { |
222 | |||
223 | if (CHECK_AX88796L_PORT(port)) | ||
224 | maybebadio(port); | ||
225 | else if (is_pci_ioaddr(port) || shifted_port(port)) { | ||
226 | volatile u32 *p = (volatile u32 *)pci_ioaddr(port); | 166 | volatile u32 *p = (volatile u32 *)pci_ioaddr(port); |
167 | u32 *buf = dst; | ||
227 | 168 | ||
228 | while (count--) | 169 | while (count--) |
229 | *buf++ = *p; | 170 | *buf++ = *p; |
230 | } else | 171 | } |
231 | maybebadio(port); | ||
232 | } | 172 | } |
233 | 173 | ||
234 | void r7780rp_outsb(unsigned long port, const void *src, unsigned long count) | 174 | void r7780rp_outsb(unsigned long port, const void *src, unsigned long count) |
@@ -240,19 +180,14 @@ void r7780rp_outsb(unsigned long port, const void *src, unsigned long count) | |||
240 | p = (volatile u16 *)port88796l(port, 0); | 180 | p = (volatile u16 *)port88796l(port, 0); |
241 | while (count--) | 181 | while (count--) |
242 | *p = *buf++; | 182 | *p = *buf++; |
243 | } else if (PXSEG(port)) | 183 | } else if (is_pci_ioaddr(port)) { |
244 | while (count--) | ||
245 | ctrl_outb(*buf++, port); | ||
246 | else if (is_pci_ioaddr(port) || shifted_port(port)) { | ||
247 | volatile u8 *bp = (volatile u8 *)pci_ioaddr(port); | 184 | volatile u8 *bp = (volatile u8 *)pci_ioaddr(port); |
248 | 185 | ||
249 | while (count--) | 186 | while (count--) |
250 | *bp = *buf++; | 187 | *bp = *buf++; |
251 | } else { | 188 | } else |
252 | p = (volatile u16 *)port2adr(port); | ||
253 | while (count--) | 189 | while (count--) |
254 | *p = *buf++; | 190 | ctrl_outb(*buf++, port); |
255 | } | ||
256 | } | 191 | } |
257 | 192 | ||
258 | void r7780rp_outsw(unsigned long port, const void *src, unsigned long count) | 193 | void r7780rp_outsw(unsigned long port, const void *src, unsigned long count) |
@@ -262,40 +197,37 @@ void r7780rp_outsw(unsigned long port, const void *src, unsigned long count) | |||
262 | 197 | ||
263 | if (CHECK_AX88796L_PORT(port)) | 198 | if (CHECK_AX88796L_PORT(port)) |
264 | p = (volatile u16 *)port88796l(port, 1); | 199 | p = (volatile u16 *)port88796l(port, 1); |
265 | else if (PXSEG(port)) | 200 | else if (is_pci_ioaddr(port)) |
266 | p = (volatile u16 *)port; | ||
267 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
268 | p = (volatile u16 *)pci_ioaddr(port); | 201 | p = (volatile u16 *)pci_ioaddr(port); |
269 | else | 202 | else |
270 | p = (volatile u16 *)port2adr(port); | 203 | p = (volatile u16 *)port; |
271 | 204 | ||
272 | while (count--) | 205 | while (count--) |
273 | *p = *buf++; | 206 | *p = *buf++; |
207 | |||
208 | flush_dcache_all(); | ||
274 | } | 209 | } |
275 | 210 | ||
276 | void r7780rp_outsl(unsigned long port, const void *src, unsigned long count) | 211 | void r7780rp_outsl(unsigned long port, const void *src, unsigned long count) |
277 | { | 212 | { |
278 | const u32 *buf = src; | 213 | const u32 *buf = src; |
214 | u32 *p; | ||
279 | 215 | ||
280 | if (CHECK_AX88796L_PORT(port)) | 216 | if (is_pci_ioaddr(port)) |
281 | maybebadio(port); | 217 | p = (u32 *)pci_ioaddr(port); |
282 | else if (is_pci_ioaddr(port) || shifted_port(port)) { | 218 | else |
283 | volatile u32 *p = (volatile u32 *)pci_ioaddr(port); | 219 | p = (u32 *)port; |
284 | 220 | ||
285 | while (count--) | 221 | while (count--) |
286 | *p = *buf++; | 222 | ctrl_outl(*buf++, (unsigned long)p); |
287 | } else | ||
288 | maybebadio(port); | ||
289 | } | 223 | } |
290 | 224 | ||
291 | void __iomem *r7780rp_ioport_map(unsigned long port, unsigned int size) | 225 | void __iomem *r7780rp_ioport_map(unsigned long port, unsigned int size) |
292 | { | 226 | { |
293 | if (CHECK_AX88796L_PORT(port)) | 227 | if (CHECK_AX88796L_PORT(port)) |
294 | return (void __iomem *)port88796l(port, size > 1); | 228 | return (void __iomem *)port88796l(port, size > 1); |
295 | else if (PXSEG(port)) | 229 | else if (is_pci_ioaddr(port)) |
296 | return (void __iomem *)port; | ||
297 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
298 | return (void __iomem *)pci_ioaddr(port); | 230 | return (void __iomem *)pci_ioaddr(port); |
299 | 231 | ||
300 | return (void __iomem *)port2adr(port); | 232 | return (void __iomem *)port; |
301 | } | 233 | } |
diff --git a/arch/sh/boards/renesas/r7780rp/led.c b/arch/sh/boards/renesas/r7780rp/led.c deleted file mode 100644 index 6a00a257afd2..000000000000 --- a/arch/sh/boards/renesas/r7780rp/led.c +++ /dev/null | |||
@@ -1,43 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) Atom Create Engineering Co., Ltd. | ||
3 | * | ||
4 | * May be copied or modified under the terms of GNU General Public | ||
5 | * License. See linux/COPYING for more information. | ||
6 | * | ||
7 | * This file contains Renesas Solutions HIGHLANDER R7780RP-1 specific LED code. | ||
8 | */ | ||
9 | #include <linux/sched.h> | ||
10 | #include <asm/io.h> | ||
11 | #include <asm/r7780rp/r7780rp.h> | ||
12 | |||
13 | /* Cycle the LED's in the clasic Knightriger/Sun pattern */ | ||
14 | void heartbeat_r7780rp(void) | ||
15 | { | ||
16 | static unsigned int cnt = 0, period = 0; | ||
17 | volatile unsigned short *p = (volatile unsigned short *)PA_OBLED; | ||
18 | static unsigned bit = 0, up = 1; | ||
19 | unsigned bit_pos[] = {2, 1, 0, 3, 6, 5, 4, 7}; | ||
20 | |||
21 | cnt += 1; | ||
22 | if (cnt < period) | ||
23 | return; | ||
24 | |||
25 | cnt = 0; | ||
26 | |||
27 | /* Go through the points (roughly!): | ||
28 | * f(0)=10, f(1)=16, f(2)=20, f(5)=35, f(int)->110 | ||
29 | */ | ||
30 | period = 110 - ((300 << FSHIFT)/((avenrun[0]/5) + (3<<FSHIFT))); | ||
31 | |||
32 | *p = 1 << bit_pos[bit]; | ||
33 | if (up) | ||
34 | if (bit == 7) { | ||
35 | bit--; | ||
36 | up = 0; | ||
37 | } else | ||
38 | bit++; | ||
39 | else if (bit == 0) | ||
40 | up = 1; | ||
41 | else | ||
42 | bit--; | ||
43 | } | ||
diff --git a/arch/sh/boards/renesas/r7780rp/setup.c b/arch/sh/boards/renesas/r7780rp/setup.c index 9f89c8de9db9..0d74db9f1792 100644 --- a/arch/sh/boards/renesas/r7780rp/setup.c +++ b/arch/sh/boards/renesas/r7780rp/setup.c | |||
@@ -2,7 +2,7 @@ | |||
2 | * arch/sh/boards/renesas/r7780rp/setup.c | 2 | * arch/sh/boards/renesas/r7780rp/setup.c |
3 | * | 3 | * |
4 | * Copyright (C) 2002 Atom Create Engineering Co., Ltd. | 4 | * Copyright (C) 2002 Atom Create Engineering Co., Ltd. |
5 | * Copyright (C) 2005, 2006 Paul Mundt | 5 | * Copyright (C) 2005 - 2007 Paul Mundt |
6 | * | 6 | * |
7 | * Renesas Solutions Highlander R7780RP-1 Support. | 7 | * Renesas Solutions Highlander R7780RP-1 Support. |
8 | * | 8 | * |
@@ -12,12 +12,12 @@ | |||
12 | */ | 12 | */ |
13 | #include <linux/init.h> | 13 | #include <linux/init.h> |
14 | #include <linux/platform_device.h> | 14 | #include <linux/platform_device.h> |
15 | #include <linux/pata_platform.h> | ||
15 | #include <asm/machvec.h> | 16 | #include <asm/machvec.h> |
16 | #include <asm/r7780rp.h> | 17 | #include <asm/r7780rp.h> |
17 | #include <asm/clock.h> | 18 | #include <asm/clock.h> |
18 | #include <asm/io.h> | 19 | #include <asm/io.h> |
19 | 20 | ||
20 | extern void heartbeat_r7780rp(void); | ||
21 | extern void init_r7780rp_IRQ(void); | 21 | extern void init_r7780rp_IRQ(void); |
22 | 22 | ||
23 | static struct resource m66596_usb_host_resources[] = { | 23 | static struct resource m66596_usb_host_resources[] = { |
@@ -46,14 +46,14 @@ static struct platform_device m66596_usb_host_device = { | |||
46 | 46 | ||
47 | static struct resource cf_ide_resources[] = { | 47 | static struct resource cf_ide_resources[] = { |
48 | [0] = { | 48 | [0] = { |
49 | .start = 0x1f0, | 49 | .start = PA_AREA5_IO + 0x1000, |
50 | .end = 0x1f0 + 8, | 50 | .end = PA_AREA5_IO + 0x1000 + 0x08 - 1, |
51 | .flags = IORESOURCE_IO, | 51 | .flags = IORESOURCE_MEM, |
52 | }, | 52 | }, |
53 | [1] = { | 53 | [1] = { |
54 | .start = 0x1f0 + 0x206, | 54 | .start = PA_AREA5_IO + 0x80c, |
55 | .end = 0x1f0 + 8 + 0x206 + 8, | 55 | .end = PA_AREA5_IO + 0x80c + 0x16 - 1, |
56 | .flags = IORESOURCE_IO, | 56 | .flags = IORESOURCE_MEM, |
57 | }, | 57 | }, |
58 | [2] = { | 58 | [2] = { |
59 | #ifdef CONFIG_SH_R7780MP | 59 | #ifdef CONFIG_SH_R7780MP |
@@ -65,16 +65,44 @@ static struct resource cf_ide_resources[] = { | |||
65 | }, | 65 | }, |
66 | }; | 66 | }; |
67 | 67 | ||
68 | static struct pata_platform_info pata_info = { | ||
69 | .ioport_shift = 1, | ||
70 | }; | ||
71 | |||
68 | static struct platform_device cf_ide_device = { | 72 | static struct platform_device cf_ide_device = { |
69 | .name = "pata_platform", | 73 | .name = "pata_platform", |
70 | .id = -1, | 74 | .id = -1, |
71 | .num_resources = ARRAY_SIZE(cf_ide_resources), | 75 | .num_resources = ARRAY_SIZE(cf_ide_resources), |
72 | .resource = cf_ide_resources, | 76 | .resource = cf_ide_resources, |
77 | .dev = { | ||
78 | .platform_data = &pata_info, | ||
79 | }, | ||
80 | }; | ||
81 | |||
82 | static unsigned char heartbeat_bit_pos[] = { 2, 1, 0, 3, 6, 5, 4, 7 }; | ||
83 | |||
84 | static struct resource heartbeat_resources[] = { | ||
85 | [0] = { | ||
86 | .start = PA_OBLED, | ||
87 | .end = PA_OBLED + ARRAY_SIZE(heartbeat_bit_pos) - 1, | ||
88 | .flags = IORESOURCE_MEM, | ||
89 | }, | ||
90 | }; | ||
91 | |||
92 | static struct platform_device heartbeat_device = { | ||
93 | .name = "heartbeat", | ||
94 | .id = -1, | ||
95 | .dev = { | ||
96 | .platform_data = heartbeat_bit_pos, | ||
97 | }, | ||
98 | .num_resources = ARRAY_SIZE(heartbeat_resources), | ||
99 | .resource = heartbeat_resources, | ||
73 | }; | 100 | }; |
74 | 101 | ||
75 | static struct platform_device *r7780rp_devices[] __initdata = { | 102 | static struct platform_device *r7780rp_devices[] __initdata = { |
76 | &m66596_usb_host_device, | 103 | &m66596_usb_host_device, |
77 | &cf_ide_device, | 104 | &cf_ide_device, |
105 | &heartbeat_device, | ||
78 | }; | 106 | }; |
79 | 107 | ||
80 | static int __init r7780rp_devices_setup(void) | 108 | static int __init r7780rp_devices_setup(void) |
@@ -148,7 +176,7 @@ static void __init r7780rp_setup(char **cmdline_p) | |||
148 | #ifndef CONFIG_SH_R7780MP | 176 | #ifndef CONFIG_SH_R7780MP |
149 | ctrl_outw(0x0001, PA_SDPOW); /* SD Power ON */ | 177 | ctrl_outw(0x0001, PA_SDPOW); /* SD Power ON */ |
150 | #endif | 178 | #endif |
151 | ctrl_outw(ctrl_inw(PA_IVDRCTL) | 0x0100, PA_IVDRCTL); /* Si13112 */ | 179 | ctrl_outw(ctrl_inw(PA_IVDRCTL) | 0x01, PA_IVDRCTL); /* Si13112 */ |
152 | 180 | ||
153 | pm_power_off = r7780rp_power_off; | 181 | pm_power_off = r7780rp_power_off; |
154 | } | 182 | } |
@@ -185,8 +213,5 @@ struct sh_machine_vector mv_r7780rp __initmv = { | |||
185 | 213 | ||
186 | .mv_ioport_map = r7780rp_ioport_map, | 214 | .mv_ioport_map = r7780rp_ioport_map, |
187 | .mv_init_irq = init_r7780rp_IRQ, | 215 | .mv_init_irq = init_r7780rp_IRQ, |
188 | #ifdef CONFIG_HEARTBEAT | ||
189 | .mv_heartbeat = heartbeat_r7780rp, | ||
190 | #endif | ||
191 | }; | 216 | }; |
192 | ALIAS_MV(r7780rp) | 217 | ALIAS_MV(r7780rp) |
diff --git a/arch/sh/boards/renesas/rts7751r2d/Makefile b/arch/sh/boards/renesas/rts7751r2d/Makefile index 686fc9ea5989..0d4c75a72be0 100644 --- a/arch/sh/boards/renesas/rts7751r2d/Makefile +++ b/arch/sh/boards/renesas/rts7751r2d/Makefile | |||
@@ -2,5 +2,4 @@ | |||
2 | # Makefile for the RTS7751R2D specific parts of the kernel | 2 | # Makefile for the RTS7751R2D specific parts of the kernel |
3 | # | 3 | # |
4 | 4 | ||
5 | obj-y := setup.o io.o irq.o | 5 | obj-y := setup.o irq.o |
6 | obj-$(CONFIG_HEARTBEAT) += led.o | ||
diff --git a/arch/sh/boards/renesas/rts7751r2d/io.c b/arch/sh/boards/renesas/rts7751r2d/io.c deleted file mode 100644 index f2507a804979..000000000000 --- a/arch/sh/boards/renesas/rts7751r2d/io.c +++ /dev/null | |||
@@ -1,302 +0,0 @@ | |||
1 | /* | ||
2 | * Copyright (C) 2001 Ian da Silva, Jeremy Siegel | ||
3 | * Based largely on io_se.c. | ||
4 | * | ||
5 | * I/O routine for Renesas Technology sales RTS7751R2D. | ||
6 | * | ||
7 | * Initial version only to support LAN access; some | ||
8 | * placeholder code from io_rts7751r2d.c left in with the | ||
9 | * expectation of later SuperIO and PCMCIA access. | ||
10 | */ | ||
11 | #include <linux/kernel.h> | ||
12 | #include <linux/types.h> | ||
13 | #include <linux/pci.h> | ||
14 | #include <linux/io.h> | ||
15 | #include <asm/rts7751r2d.h> | ||
16 | #include <asm/addrspace.h> | ||
17 | |||
18 | /* | ||
19 | * The 7751R RTS7751R2D uses the built-in PCI controller (PCIC) | ||
20 | * of the 7751R processor, and has a SuperIO accessible via the PCI. | ||
21 | * The board also includes a PCMCIA controller on its memory bus, | ||
22 | * like the other Solution Engine boards. | ||
23 | */ | ||
24 | |||
25 | static inline unsigned long port2adr(unsigned int port) | ||
26 | { | ||
27 | if ((0x1f0 <= port && port < 0x1f8) || port == 0x3f6) | ||
28 | if (port == 0x3f6) | ||
29 | return (PA_AREA5_IO + 0x80c); | ||
30 | else | ||
31 | return (PA_AREA5_IO + 0x1000 + ((port-0x1f0) << 1)); | ||
32 | else | ||
33 | maybebadio((unsigned long)port); | ||
34 | |||
35 | return port; | ||
36 | } | ||
37 | |||
38 | static inline unsigned long port88796l(unsigned int port, int flag) | ||
39 | { | ||
40 | unsigned long addr; | ||
41 | |||
42 | if (flag) | ||
43 | addr = PA_AX88796L + ((port - AX88796L_IO_BASE) << 1); | ||
44 | else | ||
45 | addr = PA_AX88796L + ((port - AX88796L_IO_BASE) << 1) + 0x1000; | ||
46 | |||
47 | return addr; | ||
48 | } | ||
49 | |||
50 | /* The 7751R RTS7751R2D seems to have everything hooked */ | ||
51 | /* up pretty normally (nothing on high-bytes only...) so this */ | ||
52 | /* shouldn't be needed */ | ||
53 | static inline int shifted_port(unsigned long port) | ||
54 | { | ||
55 | /* For IDE registers, value is not shifted */ | ||
56 | if ((0x1f0 <= port && port < 0x1f8) || port == 0x3f6) | ||
57 | return 0; | ||
58 | else | ||
59 | return 1; | ||
60 | } | ||
61 | |||
62 | #if defined(CONFIG_NE2000) || defined(CONFIG_NE2000_MODULE) | ||
63 | #define CHECK_AX88796L_PORT(port) \ | ||
64 | ((port >= AX88796L_IO_BASE) && (port < (AX88796L_IO_BASE+0x20))) | ||
65 | #else | ||
66 | #define CHECK_AX88796L_PORT(port) (0) | ||
67 | #endif | ||
68 | |||
69 | /* | ||
70 | * General outline: remap really low stuff [eventually] to SuperIO, | ||
71 | * stuff in PCI IO space (at or above window at pci.h:PCIBIOS_MIN_IO) | ||
72 | * is mapped through the PCI IO window. Stuff with high bits (PXSEG) | ||
73 | * should be way beyond the window, and is used w/o translation for | ||
74 | * compatibility. | ||
75 | */ | ||
76 | unsigned char rts7751r2d_inb(unsigned long port) | ||
77 | { | ||
78 | if (CHECK_AX88796L_PORT(port)) | ||
79 | return (*(volatile unsigned short *)port88796l(port, 0)) & 0xff; | ||
80 | else if (PXSEG(port)) | ||
81 | return *(volatile unsigned char *)port; | ||
82 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
83 | return *(volatile unsigned char *)pci_ioaddr(port); | ||
84 | else | ||
85 | return (*(volatile unsigned short *)port2adr(port) & 0xff); | ||
86 | } | ||
87 | |||
88 | unsigned char rts7751r2d_inb_p(unsigned long port) | ||
89 | { | ||
90 | unsigned char v; | ||
91 | |||
92 | if (CHECK_AX88796L_PORT(port)) | ||
93 | v = (*(volatile unsigned short *)port88796l(port, 0)) & 0xff; | ||
94 | else if (PXSEG(port)) | ||
95 | v = *(volatile unsigned char *)port; | ||
96 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
97 | v = *(volatile unsigned char *)pci_ioaddr(port); | ||
98 | else | ||
99 | v = (*(volatile unsigned short *)port2adr(port) & 0xff); | ||
100 | |||
101 | ctrl_delay(); | ||
102 | |||
103 | return v; | ||
104 | } | ||
105 | |||
106 | unsigned short rts7751r2d_inw(unsigned long port) | ||
107 | { | ||
108 | if (CHECK_AX88796L_PORT(port)) | ||
109 | maybebadio(port); | ||
110 | else if (PXSEG(port)) | ||
111 | return *(volatile unsigned short *)port; | ||
112 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
113 | return *(volatile unsigned short *)pci_ioaddr(port); | ||
114 | else | ||
115 | maybebadio(port); | ||
116 | |||
117 | return 0; | ||
118 | } | ||
119 | |||
120 | unsigned int rts7751r2d_inl(unsigned long port) | ||
121 | { | ||
122 | if (CHECK_AX88796L_PORT(port)) | ||
123 | maybebadio(port); | ||
124 | else if (PXSEG(port)) | ||
125 | return *(volatile unsigned long *)port; | ||
126 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
127 | return *(volatile unsigned long *)pci_ioaddr(port); | ||
128 | else | ||
129 | maybebadio(port); | ||
130 | |||
131 | return 0; | ||
132 | } | ||
133 | |||
134 | void rts7751r2d_outb(unsigned char value, unsigned long port) | ||
135 | { | ||
136 | if (CHECK_AX88796L_PORT(port)) | ||
137 | *((volatile unsigned short *)port88796l(port, 0)) = value; | ||
138 | else if (PXSEG(port)) | ||
139 | *(volatile unsigned char *)port = value; | ||
140 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
141 | *(volatile unsigned char *)pci_ioaddr(port) = value; | ||
142 | else | ||
143 | *(volatile unsigned short *)port2adr(port) = value; | ||
144 | } | ||
145 | |||
146 | void rts7751r2d_outb_p(unsigned char value, unsigned long port) | ||
147 | { | ||
148 | if (CHECK_AX88796L_PORT(port)) | ||
149 | *((volatile unsigned short *)port88796l(port, 0)) = value; | ||
150 | else if (PXSEG(port)) | ||
151 | *(volatile unsigned char *)port = value; | ||
152 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
153 | *(volatile unsigned char *)pci_ioaddr(port) = value; | ||
154 | else | ||
155 | *(volatile unsigned short *)port2adr(port) = value; | ||
156 | |||
157 | ctrl_delay(); | ||
158 | } | ||
159 | |||
160 | void rts7751r2d_outw(unsigned short value, unsigned long port) | ||
161 | { | ||
162 | if (CHECK_AX88796L_PORT(port)) | ||
163 | maybebadio(port); | ||
164 | else if (PXSEG(port)) | ||
165 | *(volatile unsigned short *)port = value; | ||
166 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
167 | *(volatile unsigned short *)pci_ioaddr(port) = value; | ||
168 | else | ||
169 | maybebadio(port); | ||
170 | } | ||
171 | |||
172 | void rts7751r2d_outl(unsigned int value, unsigned long port) | ||
173 | { | ||
174 | if (CHECK_AX88796L_PORT(port)) | ||
175 | maybebadio(port); | ||
176 | else if (PXSEG(port)) | ||
177 | *(volatile unsigned long *)port = value; | ||
178 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
179 | *(volatile unsigned long *)pci_ioaddr(port) = value; | ||
180 | else | ||
181 | maybebadio(port); | ||
182 | } | ||
183 | |||
184 | void rts7751r2d_insb(unsigned long port, void *addr, unsigned long count) | ||
185 | { | ||
186 | unsigned long a = (unsigned long)addr; | ||
187 | volatile __u8 *bp; | ||
188 | volatile __u16 *p; | ||
189 | |||
190 | if (CHECK_AX88796L_PORT(port)) { | ||
191 | p = (volatile unsigned short *)port88796l(port, 0); | ||
192 | while (count--) | ||
193 | ctrl_outb(*p & 0xff, a++); | ||
194 | } else if (PXSEG(port)) | ||
195 | while (count--) | ||
196 | ctrl_outb(ctrl_inb(port), a++); | ||
197 | else if (is_pci_ioaddr(port) || shifted_port(port)) { | ||
198 | bp = (__u8 *)pci_ioaddr(port); | ||
199 | while (count--) | ||
200 | ctrl_outb(*bp, a++); | ||
201 | } else { | ||
202 | p = (volatile unsigned short *)port2adr(port); | ||
203 | while (count--) | ||
204 | ctrl_outb(*p & 0xff, a++); | ||
205 | } | ||
206 | } | ||
207 | |||
208 | void rts7751r2d_insw(unsigned long port, void *addr, unsigned long count) | ||
209 | { | ||
210 | unsigned long a = (unsigned long)addr; | ||
211 | volatile __u16 *p; | ||
212 | |||
213 | if (CHECK_AX88796L_PORT(port)) | ||
214 | p = (volatile unsigned short *)port88796l(port, 1); | ||
215 | else if (PXSEG(port)) | ||
216 | p = (volatile unsigned short *)port; | ||
217 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
218 | p = (volatile unsigned short *)pci_ioaddr(port); | ||
219 | else | ||
220 | p = (volatile unsigned short *)port2adr(port); | ||
221 | while (count--) | ||
222 | ctrl_outw(*p, a++); | ||
223 | } | ||
224 | |||
225 | void rts7751r2d_insl(unsigned long port, void *addr, unsigned long count) | ||
226 | { | ||
227 | if (CHECK_AX88796L_PORT(port)) | ||
228 | maybebadio(port); | ||
229 | else if (is_pci_ioaddr(port) || shifted_port(port)) { | ||
230 | unsigned long a = (unsigned long)addr; | ||
231 | |||
232 | while (count--) { | ||
233 | ctrl_outl(ctrl_inl(pci_ioaddr(port)), a); | ||
234 | a += 4; | ||
235 | } | ||
236 | } else | ||
237 | maybebadio(port); | ||
238 | } | ||
239 | |||
240 | void rts7751r2d_outsb(unsigned long port, const void *addr, unsigned long count) | ||
241 | { | ||
242 | unsigned long a = (unsigned long)addr; | ||
243 | volatile __u8 *bp; | ||
244 | volatile __u16 *p; | ||
245 | |||
246 | if (CHECK_AX88796L_PORT(port)) { | ||
247 | p = (volatile unsigned short *)port88796l(port, 0); | ||
248 | while (count--) | ||
249 | *p = ctrl_inb(a++); | ||
250 | } else if (PXSEG(port)) | ||
251 | while (count--) | ||
252 | ctrl_outb(a++, port); | ||
253 | else if (is_pci_ioaddr(port) || shifted_port(port)) { | ||
254 | bp = (__u8 *)pci_ioaddr(port); | ||
255 | while (count--) | ||
256 | *bp = ctrl_inb(a++); | ||
257 | } else { | ||
258 | p = (volatile unsigned short *)port2adr(port); | ||
259 | while (count--) | ||
260 | *p = ctrl_inb(a++); | ||
261 | } | ||
262 | } | ||
263 | |||
264 | void rts7751r2d_outsw(unsigned long port, const void *addr, unsigned long count) | ||
265 | { | ||
266 | unsigned long a = (unsigned long)addr; | ||
267 | volatile __u16 *p; | ||
268 | |||
269 | if (CHECK_AX88796L_PORT(port)) | ||
270 | p = (volatile unsigned short *)port88796l(port, 1); | ||
271 | else if (PXSEG(port)) | ||
272 | p = (volatile unsigned short *)port; | ||
273 | else if (is_pci_ioaddr(port) || shifted_port(port)) | ||
274 | p = (volatile unsigned short *)pci_ioaddr(port); | ||
275 | else | ||
276 | p = (volatile unsigned short *)port2adr(port); | ||
277 | |||
278 | while (count--) { | ||
279 | ctrl_outw(*p, a); | ||
280 | a += 2; | ||
281 | } | ||
282 | } | ||
283 | |||
284 | void rts7751r2d_outsl(unsigned long port, const void *addr, unsigned long count) | ||
285 | { | ||
286 | if (CHECK_AX88796L_PORT(port)) | ||
287 | maybebadio(port); | ||
288 | else if (is_pci_ioaddr(port) || shifted_port(port)) { | ||
289 | unsigned long a = (unsigned long)addr; | ||
290 | |||
291 | while (count--) { | ||
292 | ctrl_outl(ctrl_inl(a), pci_ioaddr(port)); | ||
293 | a += 4; | ||
294 | } | ||
295 | } else | ||
296 | maybebadio(port); | ||
297 | } | ||
298 | |||
299 | unsigned long rts7751r2d_isa_port2addr(unsigned long offset) | ||
300 | { | ||
301 | return port2adr(offset); | ||
302 | } | ||
diff --git a/arch/sh/boards/renesas/rts7751r2d/irq.c b/arch/sh/boards/renesas/rts7751r2d/irq.c index cb0eb20d1b43..0bae9041aceb 100644 --- a/arch/sh/boards/renesas/rts7751r2d/irq.c +++ b/arch/sh/boards/renesas/rts7751r2d/irq.c | |||
@@ -9,7 +9,9 @@ | |||
9 | * Atom Create Engineering Co., Ltd. 2002. | 9 | * Atom Create Engineering Co., Ltd. 2002. |
10 | */ | 10 | */ |
11 | #include <linux/init.h> | 11 | #include <linux/init.h> |
12 | #include <linux/interrupt.h> | ||
12 | #include <linux/irq.h> | 13 | #include <linux/irq.h> |
14 | #include <linux/interrupt.h> | ||
13 | #include <linux/io.h> | 15 | #include <linux/io.h> |
14 | #include <asm/rts7751r2d.h> | 16 | #include <asm/rts7751r2d.h> |
15 | 17 | ||
@@ -22,79 +24,31 @@ static int mask_pos[] = {6, 11, 9, 8, 12, 10, 5, 4, 7, 14, 13, 0, 0, 0, 0}; | |||
22 | extern int voyagergx_irq_demux(int irq); | 24 | extern int voyagergx_irq_demux(int irq); |
23 | extern void setup_voyagergx_irq(void); | 25 | extern void setup_voyagergx_irq(void); |
24 | 26 | ||
25 | static void enable_rts7751r2d_irq(unsigned int irq); | 27 | static void enable_rts7751r2d_irq(unsigned int irq) |
26 | static void disable_rts7751r2d_irq(unsigned int irq); | ||
27 | |||
28 | /* shutdown is same as "disable" */ | ||
29 | #define shutdown_rts7751r2d_irq disable_rts7751r2d_irq | ||
30 | |||
31 | static void ack_rts7751r2d_irq(unsigned int irq); | ||
32 | static void end_rts7751r2d_irq(unsigned int irq); | ||
33 | |||
34 | static unsigned int startup_rts7751r2d_irq(unsigned int irq) | ||
35 | { | 28 | { |
36 | enable_rts7751r2d_irq(irq); | 29 | /* Set priority in IPR back to original value */ |
37 | return 0; /* never anything pending */ | 30 | ctrl_outw(ctrl_inw(IRLCNTR1) | (1 << mask_pos[irq]), IRLCNTR1); |
38 | } | 31 | } |
39 | 32 | ||
40 | static void disable_rts7751r2d_irq(unsigned int irq) | 33 | static void disable_rts7751r2d_irq(unsigned int irq) |
41 | { | 34 | { |
42 | unsigned short val; | ||
43 | unsigned short mask = 0xffff ^ (0x0001 << mask_pos[irq]); | ||
44 | |||
45 | /* Set the priority in IPR to 0 */ | 35 | /* Set the priority in IPR to 0 */ |
46 | val = ctrl_inw(IRLCNTR1); | 36 | ctrl_outw(ctrl_inw(IRLCNTR1) & (0xffff ^ (1 << mask_pos[irq])), |
47 | val &= mask; | 37 | IRLCNTR1); |
48 | ctrl_outw(val, IRLCNTR1); | ||
49 | } | ||
50 | |||
51 | static void enable_rts7751r2d_irq(unsigned int irq) | ||
52 | { | ||
53 | unsigned short val; | ||
54 | unsigned short value = (0x0001 << mask_pos[irq]); | ||
55 | |||
56 | /* Set priority in IPR back to original value */ | ||
57 | val = ctrl_inw(IRLCNTR1); | ||
58 | val |= value; | ||
59 | ctrl_outw(val, IRLCNTR1); | ||
60 | } | 38 | } |
61 | 39 | ||
62 | int rts7751r2d_irq_demux(int irq) | 40 | int rts7751r2d_irq_demux(int irq) |
63 | { | 41 | { |
64 | int demux_irq; | 42 | return voyagergx_irq_demux(irq); |
65 | |||
66 | demux_irq = voyagergx_irq_demux(irq); | ||
67 | return demux_irq; | ||
68 | } | ||
69 | |||
70 | static void ack_rts7751r2d_irq(unsigned int irq) | ||
71 | { | ||
72 | disable_rts7751r2d_irq(irq); | ||
73 | } | 43 | } |
74 | 44 | ||
75 | static void end_rts7751r2d_irq(unsigned int irq) | 45 | static struct irq_chip rts7751r2d_irq_chip __read_mostly = { |
76 | { | 46 | .name = "rts7751r2d", |
77 | if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS))) | 47 | .mask = disable_rts7751r2d_irq, |
78 | enable_rts7751r2d_irq(irq); | 48 | .unmask = enable_rts7751r2d_irq, |
79 | } | 49 | .mask_ack = disable_rts7751r2d_irq, |
80 | |||
81 | static struct hw_interrupt_type rts7751r2d_irq_type = { | ||
82 | .typename = "RTS7751R2D IRQ", | ||
83 | .startup = startup_rts7751r2d_irq, | ||
84 | .shutdown = shutdown_rts7751r2d_irq, | ||
85 | .enable = enable_rts7751r2d_irq, | ||
86 | .disable = disable_rts7751r2d_irq, | ||
87 | .ack = ack_rts7751r2d_irq, | ||
88 | .end = end_rts7751r2d_irq, | ||
89 | }; | 50 | }; |
90 | 51 | ||
91 | static void make_rts7751r2d_irq(unsigned int irq) | ||
92 | { | ||
93 | disable_irq_nosync(irq); | ||
94 | irq_desc[irq].chip = &rts7751r2d_irq_type; | ||
95 | disable_rts7751r2d_irq(irq); | ||
96 | } | ||
97 | |||
98 | /* | 52 | /* |
99 | * Initialize IRQ setting | 53 | * Initialize IRQ setting |
100 | */ | 54 | */ |
@@ -119,8 +73,12 @@ void __init init_rts7751r2d_IRQ(void) | |||
119 | * IRL14=Extention #3 | 73 | * IRL14=Extention #3 |
120 | */ | 74 | */ |
121 | 75 | ||
122 | for (i=0; i<15; i++) | 76 | for (i=0; i<15; i++) { |
123 | make_rts7751r2d_irq(i); | 77 | disable_irq_nosync(i); |
78 | set_irq_chip_and_handler_name(i, &rts7751r2d_irq_chip, | ||
79 | handle_level_irq, "level"); | ||
80 | enable_rts7751r2d_irq(i); | ||
81 | } | ||
124 | 82 | ||
125 | setup_voyagergx_irq(); | 83 | setup_voyagergx_irq(); |
126 | } | 84 | } |
diff --git a/arch/sh/boards/renesas/rts7751r2d/led.c b/arch/sh/boards/renesas/rts7751r2d/led.c deleted file mode 100644 index 509f548bdce0..000000000000 --- a/arch/sh/boards/renesas/rts7751r2d/led.c +++ /dev/null | |||
@@ -1,44 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/boards/renesas/rts7751r2d/led.c | ||
3 | * | ||
4 | * Copyright (C) Atom Create Engineering Co., Ltd. | ||
5 | * | ||
6 | * May be copied or modified under the terms of GNU General Public | ||
7 | * License. See linux/COPYING for more information. | ||
8 | * | ||
9 | * This file contains Renesas Technology Sales RTS7751R2D specific LED code. | ||
10 | */ | ||
11 | #include <linux/io.h> | ||
12 | #include <linux/sched.h> | ||
13 | #include <asm/rts7751r2d.h> | ||
14 | |||
15 | /* Cycle the LED's in the clasic Knightriger/Sun pattern */ | ||
16 | void heartbeat_rts7751r2d(void) | ||
17 | { | ||
18 | static unsigned int cnt = 0, period = 0; | ||
19 | volatile unsigned short *p = (volatile unsigned short *)PA_OUTPORT; | ||
20 | static unsigned bit = 0, up = 1; | ||
21 | |||
22 | cnt += 1; | ||
23 | if (cnt < period) | ||
24 | return; | ||
25 | |||
26 | cnt = 0; | ||
27 | |||
28 | /* Go through the points (roughly!): | ||
29 | * f(0)=10, f(1)=16, f(2)=20, f(5)=35, f(int)->110 | ||
30 | */ | ||
31 | period = 110 - ((300 << FSHIFT)/((avenrun[0]/5) + (3<<FSHIFT))); | ||
32 | |||
33 | *p = 1 << bit; | ||
34 | if (up) | ||
35 | if (bit == 7) { | ||
36 | bit--; | ||
37 | up = 0; | ||
38 | } else | ||
39 | bit++; | ||
40 | else if (bit == 0) | ||
41 | up = 1; | ||
42 | else | ||
43 | bit--; | ||
44 | } | ||
diff --git a/arch/sh/boards/renesas/rts7751r2d/setup.c b/arch/sh/boards/renesas/rts7751r2d/setup.c index 5c042d35ec91..44b42082a0af 100644 --- a/arch/sh/boards/renesas/rts7751r2d/setup.c +++ b/arch/sh/boards/renesas/rts7751r2d/setup.c | |||
@@ -1,8 +1,8 @@ | |||
1 | /* | 1 | /* |
2 | * Renesas Technology Sales RTS7751R2D Support. | 2 | * Renesas Technology Sales RTS7751R2D Support. |
3 | * | 3 | * |
4 | * Copyright (C) 2002 Atom Create Engineering Co., Ltd. | 4 | * Copyright (C) 2002 - 2006 Atom Create Engineering Co., Ltd. |
5 | * Copyright (C) 2004 - 2006 Paul Mundt | 5 | * Copyright (C) 2004 - 2007 Paul Mundt |
6 | * | 6 | * |
7 | * This file is subject to the terms and conditions of the GNU General Public | 7 | * This file is subject to the terms and conditions of the GNU General Public |
8 | * License. See the file "COPYING" in the main directory of this archive | 8 | * License. See the file "COPYING" in the main directory of this archive |
@@ -10,33 +10,13 @@ | |||
10 | */ | 10 | */ |
11 | #include <linux/init.h> | 11 | #include <linux/init.h> |
12 | #include <linux/platform_device.h> | 12 | #include <linux/platform_device.h> |
13 | #include <linux/pata_platform.h> | ||
13 | #include <linux/serial_8250.h> | 14 | #include <linux/serial_8250.h> |
14 | #include <linux/pm.h> | 15 | #include <linux/pm.h> |
15 | #include <asm/machvec.h> | 16 | #include <asm/machvec.h> |
16 | #include <asm/mach/rts7751r2d.h> | 17 | #include <asm/rts7751r2d.h> |
17 | #include <asm/io.h> | ||
18 | #include <asm/voyagergx.h> | 18 | #include <asm/voyagergx.h> |
19 | 19 | #include <asm/io.h> | |
20 | extern void heartbeat_rts7751r2d(void); | ||
21 | extern void init_rts7751r2d_IRQ(void); | ||
22 | extern int rts7751r2d_irq_demux(int irq); | ||
23 | |||
24 | extern void *voyagergx_consistent_alloc(struct device *, size_t, dma_addr_t *, gfp_t); | ||
25 | extern int voyagergx_consistent_free(struct device *, size_t, void *, dma_addr_t); | ||
26 | |||
27 | static struct plat_serial8250_port uart_platform_data[] = { | ||
28 | { | ||
29 | .membase = (void *)VOYAGER_UART_BASE, | ||
30 | .mapbase = VOYAGER_UART_BASE, | ||
31 | .iotype = UPIO_MEM, | ||
32 | .irq = VOYAGER_UART0_IRQ, | ||
33 | .flags = UPF_BOOT_AUTOCONF, | ||
34 | .regshift = 2, | ||
35 | .uartclk = (9600 * 16), | ||
36 | }, { | ||
37 | .flags = 0, | ||
38 | }, | ||
39 | }; | ||
40 | 20 | ||
41 | static void __init voyagergx_serial_init(void) | 21 | static void __init voyagergx_serial_init(void) |
42 | { | 22 | { |
@@ -45,32 +25,96 @@ static void __init voyagergx_serial_init(void) | |||
45 | /* | 25 | /* |
46 | * GPIO Control | 26 | * GPIO Control |
47 | */ | 27 | */ |
48 | val = inl(GPIO_MUX_HIGH); | 28 | val = readl((void __iomem *)GPIO_MUX_HIGH); |
49 | val |= 0x00001fe0; | 29 | val |= 0x00001fe0; |
50 | outl(val, GPIO_MUX_HIGH); | 30 | writel(val, (void __iomem *)GPIO_MUX_HIGH); |
51 | 31 | ||
52 | /* | 32 | /* |
53 | * Power Mode Gate | 33 | * Power Mode Gate |
54 | */ | 34 | */ |
55 | val = inl(POWER_MODE0_GATE); | 35 | val = readl((void __iomem *)POWER_MODE0_GATE); |
56 | val |= (POWER_MODE0_GATE_U0 | POWER_MODE0_GATE_U1); | 36 | val |= (POWER_MODE0_GATE_U0 | POWER_MODE0_GATE_U1); |
57 | outl(val, POWER_MODE0_GATE); | 37 | writel(val, (void __iomem *)POWER_MODE0_GATE); |
58 | 38 | ||
59 | val = inl(POWER_MODE1_GATE); | 39 | val = readl((void __iomem *)POWER_MODE1_GATE); |
60 | val |= (POWER_MODE1_GATE_U0 | POWER_MODE1_GATE_U1); | 40 | val |= (POWER_MODE1_GATE_U0 | POWER_MODE1_GATE_U1); |
61 | outl(val, POWER_MODE1_GATE); | 41 | writel(val, (void __iomem *)POWER_MODE1_GATE); |
62 | } | 42 | } |
63 | 43 | ||
44 | static struct resource cf_ide_resources[] = { | ||
45 | [0] = { | ||
46 | .start = PA_AREA5_IO + 0x1000, | ||
47 | .end = PA_AREA5_IO + 0x1000 + 0x08 - 1, | ||
48 | .flags = IORESOURCE_MEM, | ||
49 | }, | ||
50 | [1] = { | ||
51 | .start = PA_AREA5_IO + 0x80c, | ||
52 | .end = PA_AREA5_IO + 0x80c + 0x16 - 1, | ||
53 | .flags = IORESOURCE_MEM, | ||
54 | }, | ||
55 | [2] = { | ||
56 | #ifdef CONFIG_RTS7751R2D_REV11 | ||
57 | .start = 1, | ||
58 | #else | ||
59 | .start = 2, | ||
60 | #endif | ||
61 | .flags = IORESOURCE_IRQ, | ||
62 | }, | ||
63 | }; | ||
64 | |||
65 | static struct pata_platform_info pata_info = { | ||
66 | .ioport_shift = 1, | ||
67 | }; | ||
68 | |||
69 | static struct platform_device cf_ide_device = { | ||
70 | .name = "pata_platform", | ||
71 | .id = -1, | ||
72 | .num_resources = ARRAY_SIZE(cf_ide_resources), | ||
73 | .resource = cf_ide_resources, | ||
74 | .dev = { | ||
75 | .platform_data = &pata_info, | ||
76 | }, | ||
77 | }; | ||
78 | |||
79 | static struct plat_serial8250_port uart_platform_data[] = { | ||
80 | { | ||
81 | .membase = (void __iomem *)VOYAGER_UART_BASE, | ||
82 | .mapbase = VOYAGER_UART_BASE, | ||
83 | .iotype = UPIO_MEM, | ||
84 | .irq = VOYAGER_UART0_IRQ, | ||
85 | .flags = UPF_BOOT_AUTOCONF | UPF_SKIP_TEST, | ||
86 | .regshift = 2, | ||
87 | .uartclk = (9600 * 16), | ||
88 | } | ||
89 | }; | ||
90 | |||
64 | static struct platform_device uart_device = { | 91 | static struct platform_device uart_device = { |
65 | .name = "serial8250", | 92 | .name = "serial8250", |
66 | .id = -1, | 93 | .id = PLAT8250_DEV_PLATFORM, |
67 | .dev = { | 94 | .dev = { |
68 | .platform_data = uart_platform_data, | 95 | .platform_data = uart_platform_data, |
69 | }, | 96 | }, |
70 | }; | 97 | }; |
71 | 98 | ||
99 | static struct resource heartbeat_resources[] = { | ||
100 | [0] = { | ||
101 | .start = PA_OUTPORT, | ||
102 | .end = PA_OUTPORT + 8 - 1, | ||
103 | .flags = IORESOURCE_MEM, | ||
104 | }, | ||
105 | }; | ||
106 | |||
107 | static struct platform_device heartbeat_device = { | ||
108 | .name = "heartbeat", | ||
109 | .id = -1, | ||
110 | .num_resources = ARRAY_SIZE(heartbeat_resources), | ||
111 | .resource = heartbeat_resources, | ||
112 | }; | ||
113 | |||
72 | static struct platform_device *rts7751r2d_devices[] __initdata = { | 114 | static struct platform_device *rts7751r2d_devices[] __initdata = { |
73 | &uart_device, | 115 | &uart_device, |
116 | &heartbeat_device, | ||
117 | &cf_ide_device, | ||
74 | }; | 118 | }; |
75 | 119 | ||
76 | static int __init rts7751r2d_devices_setup(void) | 120 | static int __init rts7751r2d_devices_setup(void) |
@@ -78,6 +122,7 @@ static int __init rts7751r2d_devices_setup(void) | |||
78 | return platform_add_devices(rts7751r2d_devices, | 122 | return platform_add_devices(rts7751r2d_devices, |
79 | ARRAY_SIZE(rts7751r2d_devices)); | 123 | ARRAY_SIZE(rts7751r2d_devices)); |
80 | } | 124 | } |
125 | __initcall(rts7751r2d_devices_setup); | ||
81 | 126 | ||
82 | static void rts7751r2d_power_off(void) | 127 | static void rts7751r2d_power_off(void) |
83 | { | 128 | { |
@@ -89,14 +134,17 @@ static void rts7751r2d_power_off(void) | |||
89 | */ | 134 | */ |
90 | static void __init rts7751r2d_setup(char **cmdline_p) | 135 | static void __init rts7751r2d_setup(char **cmdline_p) |
91 | { | 136 | { |
92 | device_initcall(rts7751r2d_devices_setup); | 137 | u16 ver = ctrl_inw(PA_VERREG); |
138 | |||
139 | printk(KERN_INFO "Renesas Technology Sales RTS7751R2D support.\n"); | ||
140 | |||
141 | printk(KERN_INFO "FPGA version:%d (revision:%d)\n", | ||
142 | (ver >> 4) & 0xf, ver & 0xf); | ||
93 | 143 | ||
94 | ctrl_outw(0x0000, PA_OUTPORT); | 144 | ctrl_outw(0x0000, PA_OUTPORT); |
95 | pm_power_off = rts7751r2d_power_off; | 145 | pm_power_off = rts7751r2d_power_off; |
96 | 146 | ||
97 | voyagergx_serial_init(); | 147 | voyagergx_serial_init(); |
98 | |||
99 | printk(KERN_INFO "Renesas Technology Sales RTS7751R2D support.\n"); | ||
100 | } | 148 | } |
101 | 149 | ||
102 | /* | 150 | /* |
@@ -107,31 +155,7 @@ struct sh_machine_vector mv_rts7751r2d __initmv = { | |||
107 | .mv_setup = rts7751r2d_setup, | 155 | .mv_setup = rts7751r2d_setup, |
108 | .mv_nr_irqs = 72, | 156 | .mv_nr_irqs = 72, |
109 | 157 | ||
110 | .mv_inb = rts7751r2d_inb, | ||
111 | .mv_inw = rts7751r2d_inw, | ||
112 | .mv_inl = rts7751r2d_inl, | ||
113 | .mv_outb = rts7751r2d_outb, | ||
114 | .mv_outw = rts7751r2d_outw, | ||
115 | .mv_outl = rts7751r2d_outl, | ||
116 | |||
117 | .mv_inb_p = rts7751r2d_inb_p, | ||
118 | .mv_inw_p = rts7751r2d_inw, | ||
119 | .mv_inl_p = rts7751r2d_inl, | ||
120 | .mv_outb_p = rts7751r2d_outb_p, | ||
121 | .mv_outw_p = rts7751r2d_outw, | ||
122 | .mv_outl_p = rts7751r2d_outl, | ||
123 | |||
124 | .mv_insb = rts7751r2d_insb, | ||
125 | .mv_insw = rts7751r2d_insw, | ||
126 | .mv_insl = rts7751r2d_insl, | ||
127 | .mv_outsb = rts7751r2d_outsb, | ||
128 | .mv_outsw = rts7751r2d_outsw, | ||
129 | .mv_outsl = rts7751r2d_outsl, | ||
130 | |||
131 | .mv_init_irq = init_rts7751r2d_IRQ, | 158 | .mv_init_irq = init_rts7751r2d_IRQ, |
132 | #ifdef CONFIG_HEARTBEAT | ||
133 | .mv_heartbeat = heartbeat_rts7751r2d, | ||
134 | #endif | ||
135 | .mv_irq_demux = rts7751r2d_irq_demux, | 159 | .mv_irq_demux = rts7751r2d_irq_demux, |
136 | 160 | ||
137 | #ifdef CONFIG_USB_SM501 | 161 | #ifdef CONFIG_USB_SM501 |
diff --git a/arch/sh/boards/se/7206/Makefile b/arch/sh/boards/se/7206/Makefile index 63950f4f2453..63e7ed699f39 100644 --- a/arch/sh/boards/se/7206/Makefile +++ b/arch/sh/boards/se/7206/Makefile | |||
@@ -3,5 +3,3 @@ | |||
3 | # | 3 | # |
4 | 4 | ||
5 | obj-y := setup.o io.o irq.o | 5 | obj-y := setup.o io.o irq.o |
6 | obj-$(CONFIG_HEARTBEAT) += led.o | ||
7 | |||
diff --git a/arch/sh/boards/se/7206/led.c b/arch/sh/boards/se/7206/led.c deleted file mode 100644 index ef794601ab86..000000000000 --- a/arch/sh/boards/se/7206/led.c +++ /dev/null | |||
@@ -1,57 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/kernel/led_se.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 Solution Engine specific LED code. | ||
10 | */ | ||
11 | |||
12 | #include <linux/config.h> | ||
13 | #include <asm/se7206.h> | ||
14 | |||
15 | #ifdef CONFIG_HEARTBEAT | ||
16 | |||
17 | #include <linux/sched.h> | ||
18 | |||
19 | /* Cycle the LED's in the clasic Knightrider/Sun pattern */ | ||
20 | void heartbeat_se(void) | ||
21 | { | ||
22 | static unsigned int cnt = 0, period = 0; | ||
23 | volatile unsigned short* p = (volatile unsigned short*)PA_LED; | ||
24 | static unsigned bit = 0, up = 1; | ||
25 | |||
26 | cnt += 1; | ||
27 | if (cnt < period) { | ||
28 | return; | ||
29 | } | ||
30 | |||
31 | cnt = 0; | ||
32 | |||
33 | /* Go through the points (roughly!): | ||
34 | * f(0)=10, f(1)=16, f(2)=20, f(5)=35,f(inf)->110 | ||
35 | */ | ||
36 | period = 110 - ( (300<<FSHIFT)/ | ||
37 | ((avenrun[0]/5) + (3<<FSHIFT)) ); | ||
38 | |||
39 | if (up) { | ||
40 | if (bit == 7) { | ||
41 | bit--; | ||
42 | up=0; | ||
43 | } else { | ||
44 | bit ++; | ||
45 | } | ||
46 | } else { | ||
47 | if (bit == 0) { | ||
48 | bit++; | ||
49 | up=1; | ||
50 | } else { | ||
51 | bit--; | ||
52 | } | ||
53 | } | ||
54 | *p = 1<<(bit+8); | ||
55 | |||
56 | } | ||
57 | #endif /* CONFIG_HEARTBEAT */ | ||
diff --git a/arch/sh/boards/se/7206/setup.c b/arch/sh/boards/se/7206/setup.c index 0f42e91a3238..ca714879f559 100644 --- a/arch/sh/boards/se/7206/setup.c +++ b/arch/sh/boards/se/7206/setup.c | |||
@@ -3,6 +3,7 @@ | |||
3 | * linux/arch/sh/boards/se/7206/setup.c | 3 | * linux/arch/sh/boards/se/7206/setup.c |
4 | * | 4 | * |
5 | * Copyright (C) 2006 Yoshinori Sato | 5 | * Copyright (C) 2006 Yoshinori Sato |
6 | * Copyright (C) 2007 Paul Mundt | ||
6 | * | 7 | * |
7 | * Hitachi 7206 SolutionEngine Support. | 8 | * Hitachi 7206 SolutionEngine Support. |
8 | * | 9 | * |
@@ -34,15 +35,37 @@ static struct platform_device smc91x_device = { | |||
34 | .resource = smc91x_resources, | 35 | .resource = smc91x_resources, |
35 | }; | 36 | }; |
36 | 37 | ||
38 | static unsigned char heartbeat_bit_pos[] = { 8, 9, 10, 11, 12, 13, 14, 15 }; | ||
39 | |||
40 | static struct resource heartbeat_resources[] = { | ||
41 | [0] = { | ||
42 | .start = PA_LED, | ||
43 | .end = PA_LED + ARRAY_SIZE(heartbeat_bit_pos) - 1, | ||
44 | .flags = IORESOURCE_MEM, | ||
45 | }, | ||
46 | }; | ||
47 | |||
48 | static struct platform_device heartbeat_device = { | ||
49 | .name = "heartbeat", | ||
50 | .id = -1, | ||
51 | .dev = { | ||
52 | .platform_data = heartbeat_bit_pos, | ||
53 | }, | ||
54 | .num_resources = ARRAY_SIZE(heartbeat_resources), | ||
55 | .resource = heartbeat_resources, | ||
56 | }; | ||
57 | |||
58 | static struct platform_device *se7206_devices[] __initdata = { | ||
59 | &smc91x_device, | ||
60 | &heartbeat_device, | ||
61 | }; | ||
62 | |||
37 | static int __init se7206_devices_setup(void) | 63 | static int __init se7206_devices_setup(void) |
38 | { | 64 | { |
39 | return platform_device_register(&smc91x_device); | 65 | return platform_add_devices(se7206_devices, ARRAY_SIZE(se7206_devices)); |
40 | } | 66 | } |
41 | |||
42 | __initcall(se7206_devices_setup); | 67 | __initcall(se7206_devices_setup); |
43 | 68 | ||
44 | void heartbeat_se(void); | ||
45 | |||
46 | /* | 69 | /* |
47 | * The Machine Vector | 70 | * The Machine Vector |
48 | */ | 71 | */ |
@@ -72,8 +95,5 @@ struct sh_machine_vector mv_se __initmv = { | |||
72 | .mv_outsl = se7206_outsl, | 95 | .mv_outsl = se7206_outsl, |
73 | 96 | ||
74 | .mv_init_irq = init_se7206_IRQ, | 97 | .mv_init_irq = init_se7206_IRQ, |
75 | #ifdef CONFIG_HEARTBEAT | ||
76 | .mv_heartbeat = heartbeat_se, | ||
77 | #endif | ||
78 | }; | 98 | }; |
79 | ALIAS_MV(se) | 99 | ALIAS_MV(se) |
diff --git a/arch/sh/boards/se/7300/Makefile b/arch/sh/boards/se/7300/Makefile index 0fbd4f47815c..46247368f14b 100644 --- a/arch/sh/boards/se/7300/Makefile +++ b/arch/sh/boards/se/7300/Makefile | |||
@@ -3,5 +3,3 @@ | |||
3 | # | 3 | # |
4 | 4 | ||
5 | obj-y := setup.o io.o irq.o | 5 | obj-y := setup.o io.o irq.o |
6 | |||
7 | obj-$(CONFIG_HEARTBEAT) += led.o | ||
diff --git a/arch/sh/boards/se/7300/led.c b/arch/sh/boards/se/7300/led.c deleted file mode 100644 index 4d03bb7774be..000000000000 --- a/arch/sh/boards/se/7300/led.c +++ /dev/null | |||
@@ -1,54 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/boards/se/7300/led.c | ||
3 | * | ||
4 | * Derived from linux/arch/sh/boards/se/770x/led.c | ||
5 | * | ||
6 | * Copyright (C) 2000 Stuart Menefy <stuart.menefy@st.com> | ||
7 | * | ||
8 | * May be copied or modified under the terms of the GNU General Public | ||
9 | * License. See linux/COPYING for more information. | ||
10 | * | ||
11 | * This file contains Solution Engine specific LED code. | ||
12 | */ | ||
13 | |||
14 | #include <linux/sched.h> | ||
15 | #include <asm/se7300.h> | ||
16 | |||
17 | /* Cycle the LED's in the clasic Knightrider/Sun pattern */ | ||
18 | void heartbeat_7300se(void) | ||
19 | { | ||
20 | static unsigned int cnt = 0, period = 0; | ||
21 | volatile unsigned short *p = (volatile unsigned short *) PA_LED; | ||
22 | static unsigned bit = 0, up = 1; | ||
23 | |||
24 | cnt += 1; | ||
25 | if (cnt < period) { | ||
26 | return; | ||
27 | } | ||
28 | |||
29 | cnt = 0; | ||
30 | |||
31 | /* Go through the points (roughly!): | ||
32 | * f(0)=10, f(1)=16, f(2)=20, f(5)=35,f(inf)->110 | ||
33 | */ | ||
34 | period = 110 - ((300 << FSHIFT) / ((avenrun[0] / 5) + (3 << FSHIFT))); | ||
35 | |||
36 | if (up) { | ||
37 | if (bit == 7) { | ||
38 | bit--; | ||
39 | up = 0; | ||
40 | } else { | ||
41 | bit++; | ||
42 | } | ||
43 | } else { | ||
44 | if (bit == 0) { | ||
45 | bit++; | ||
46 | up = 1; | ||
47 | } else { | ||
48 | bit--; | ||
49 | } | ||
50 | } | ||
51 | *p = 1 << (bit + 8); | ||
52 | |||
53 | } | ||
54 | |||
diff --git a/arch/sh/boards/se/7300/setup.c b/arch/sh/boards/se/7300/setup.c index 6f082a722d42..f1960956bad0 100644 --- a/arch/sh/boards/se/7300/setup.c +++ b/arch/sh/boards/se/7300/setup.c | |||
@@ -6,14 +6,43 @@ | |||
6 | * SH-Mobile SolutionEngine 7300 Support. | 6 | * SH-Mobile SolutionEngine 7300 Support. |
7 | * | 7 | * |
8 | */ | 8 | */ |
9 | |||
10 | #include <linux/init.h> | 9 | #include <linux/init.h> |
10 | #include <linux/platform_device.h> | ||
11 | #include <asm/machvec.h> | 11 | #include <asm/machvec.h> |
12 | #include <asm/se7300.h> | 12 | #include <asm/se7300.h> |
13 | 13 | ||
14 | void heartbeat_7300se(void); | ||
15 | void init_7300se_IRQ(void); | 14 | void init_7300se_IRQ(void); |
16 | 15 | ||
16 | static unsigned char heartbeat_bit_pos[] = { 8, 9, 10, 11, 12, 13, 14, 15 }; | ||
17 | |||
18 | static struct resource heartbeat_resources[] = { | ||
19 | [0] = { | ||
20 | .start = PA_LED, | ||
21 | .end = PA_LED + ARRAY_SIZE(heartbeat_bit_pos) - 1, | ||
22 | .flags = IORESOURCE_MEM, | ||
23 | }, | ||
24 | }; | ||
25 | |||
26 | static struct platform_device heartbeat_device = { | ||
27 | .name = "heartbeat", | ||
28 | .id = -1, | ||
29 | .dev = { | ||
30 | .platform_data = heartbeat_bit_pos, | ||
31 | }, | ||
32 | .num_resources = ARRAY_SIZE(heartbeat_resources), | ||
33 | .resource = heartbeat_resources, | ||
34 | }; | ||
35 | |||
36 | static struct platform_device *se7300_devices[] __initdata = { | ||
37 | &heartbeat_device, | ||
38 | }; | ||
39 | |||
40 | static int __init se7300_devices_setup(void) | ||
41 | { | ||
42 | return platform_add_devices(se7300_devices, ARRAY_SIZE(se7300_devices)); | ||
43 | } | ||
44 | __initcall(se7300_devices_setup); | ||
45 | |||
17 | /* | 46 | /* |
18 | * The Machine Vector | 47 | * The Machine Vector |
19 | */ | 48 | */ |
@@ -42,8 +71,5 @@ struct sh_machine_vector mv_7300se __initmv = { | |||
42 | .mv_outsl = sh7300se_outsl, | 71 | .mv_outsl = sh7300se_outsl, |
43 | 72 | ||
44 | .mv_init_irq = init_7300se_IRQ, | 73 | .mv_init_irq = init_7300se_IRQ, |
45 | #ifdef CONFIG_HEARTBEAT | ||
46 | .mv_heartbeat = heartbeat_7300se, | ||
47 | #endif | ||
48 | }; | 74 | }; |
49 | ALIAS_MV(7300se) | 75 | ALIAS_MV(7300se) |
diff --git a/arch/sh/boards/se/73180/Makefile b/arch/sh/boards/se/73180/Makefile index 8f63886a0f3f..e7c09967c529 100644 --- a/arch/sh/boards/se/73180/Makefile +++ b/arch/sh/boards/se/73180/Makefile | |||
@@ -3,5 +3,3 @@ | |||
3 | # | 3 | # |
4 | 4 | ||
5 | obj-y := setup.o io.o irq.o | 5 | obj-y := setup.o io.o irq.o |
6 | |||
7 | obj-$(CONFIG_HEARTBEAT) += led.o | ||
diff --git a/arch/sh/boards/se/73180/led.c b/arch/sh/boards/se/73180/led.c deleted file mode 100644 index 4b72e9a3ead9..000000000000 --- a/arch/sh/boards/se/73180/led.c +++ /dev/null | |||
@@ -1,53 +0,0 @@ | |||
1 | /* | ||
2 | * arch/sh/boards/se/73180/led.c | ||
3 | * | ||
4 | * Derived from arch/sh/boards/se/770x/led.c | ||
5 | * | ||
6 | * Copyright (C) 2000 Stuart Menefy <stuart.menefy@st.com> | ||
7 | * | ||
8 | * May be copied or modified under the terms of the GNU General Public | ||
9 | * License. See linux/COPYING for more information. | ||
10 | * | ||
11 | * This file contains Solution Engine specific LED code. | ||
12 | */ | ||
13 | |||
14 | #include <linux/sched.h> | ||
15 | #include <asm/mach/se73180.h> | ||
16 | |||
17 | /* Cycle the LED's in the clasic Knightrider/Sun pattern */ | ||
18 | void heartbeat_73180se(void) | ||
19 | { | ||
20 | static unsigned int cnt = 0, period = 0; | ||
21 | volatile unsigned short *p = (volatile unsigned short *) PA_LED; | ||
22 | static unsigned bit = 0, up = 1; | ||
23 | |||
24 | cnt += 1; | ||
25 | if (cnt < period) { | ||
26 | return; | ||
27 | } | ||
28 | |||
29 | cnt = 0; | ||
30 | |||
31 | /* Go through the points (roughly!): | ||
32 | * f(0)=10, f(1)=16, f(2)=20, f(5)=35,f(inf)->110 | ||
33 | */ | ||
34 | period = 110 - ((300 << FSHIFT) / ((avenrun[0] / 5) + (3 << FSHIFT))); | ||
35 | |||
36 | if (up) { | ||
37 | if (bit == 7) { | ||
38 | bit--; | ||
39 | up = 0; | ||
40 | } else { | ||
41 | bit++; | ||
42 | } | ||
43 | } else { | ||
44 | if (bit == 0) { | ||
45 | bit++; | ||
46 | up = 1; | ||
47 | } else { | ||
48 | bit--; | ||
49 | } | ||
50 | } | ||
51 | *p = 1 << (bit + LED_SHIFT); | ||
52 | |||
53 | } | ||
diff --git a/arch/sh/boards/se/73180/setup.c b/arch/sh/boards/se/73180/setup.c index b38ef50a160a..911ce1cdbd7f 100644 --- a/arch/sh/boards/se/73180/setup.c +++ b/arch/sh/boards/se/73180/setup.c | |||
@@ -10,13 +10,39 @@ | |||
10 | */ | 10 | */ |
11 | 11 | ||
12 | #include <linux/init.h> | 12 | #include <linux/init.h> |
13 | #include <linux/platform_device.h> | ||
13 | #include <asm/machvec.h> | 14 | #include <asm/machvec.h> |
14 | #include <asm/se73180.h> | 15 | #include <asm/se73180.h> |
15 | #include <asm/irq.h> | 16 | #include <asm/irq.h> |
16 | 17 | ||
17 | void heartbeat_73180se(void); | ||
18 | void init_73180se_IRQ(void); | 18 | void init_73180se_IRQ(void); |
19 | 19 | ||
20 | static struct resource heartbeat_resources[] = { | ||
21 | [0] = { | ||
22 | .start = PA_LED, | ||
23 | .end = PA_LED + 8 - 1, | ||
24 | .flags = IORESOURCE_MEM, | ||
25 | }, | ||
26 | }; | ||
27 | |||
28 | static struct platform_device heartbeat_device = { | ||
29 | .name = "heartbeat", | ||
30 | .id = -1, | ||
31 | .num_resources = ARRAY_SIZE(heartbeat_resources), | ||
32 | .resource = heartbeat_resources, | ||
33 | }; | ||
34 | |||
35 | static struct platform_device *se73180_devices[] __initdata = { | ||
36 | &heartbeat_device, | ||
37 | }; | ||
38 | |||
39 | static int __init se73180_devices_setup(void) | ||
40 | { | ||
41 | return platform_add_devices(sh7343se_platform_devices, | ||
42 | ARRAY_SIZE(sh7343se_platform_devices)); | ||
43 | } | ||
44 | __initcall(se73180_devices_setup); | ||
45 | |||
20 | /* | 46 | /* |
21 | * The Machine Vector | 47 | * The Machine Vector |
22 | */ | 48 | */ |
@@ -46,8 +72,5 @@ struct sh_machine_vector mv_73180se __initmv = { | |||
46 | 72 | ||
47 | .mv_init_irq = init_73180se_IRQ, | 73 | .mv_init_irq = init_73180se_IRQ, |
48 | .mv_irq_demux = shmse_irq_demux, | 74 | .mv_irq_demux = shmse_irq_demux, |
49 | #ifdef CONFIG_HEARTBEAT | ||
50 | .mv_heartbeat = heartbeat_73180se, | ||
51 | #endif | ||
52 | }; | 75 | }; |
53 | ALIAS_MV(73180se) | 76 | ALIAS_MV(73180se) |
diff --git a/arch/sh/boards/se/7343/Makefile b/arch/sh/boards/se/7343/Makefile index 4291069c0b4f..3024796c6203 100644 --- a/arch/sh/boards/se/7343/Makefile +++ b/arch/sh/boards/se/7343/Makefile | |||
@@ -3,5 +3,3 @@ | |||
3 | # | 3 | # |
4 | 4 | ||
5 | obj-y := setup.o io.o irq.o | 5 | obj-y := setup.o io.o irq.o |
6 | |||
7 | obj-$(CONFIG_HEARTBEAT) += led.o | ||
diff --git a/arch/sh/boards/se/7343/led.c b/arch/sh/boards/se/7343/led.c deleted file mode 100644 index 6b39e191c420..000000000000 --- a/arch/sh/boards/se/7343/led.c +++ /dev/null | |||
@@ -1,44 +0,0 @@ | |||
1 | /* | ||
2 | * arch/sh/boards/se/7343/led.c | ||
3 | * | ||
4 | */ | ||
5 | #include <linux/sched.h> | ||
6 | #include <asm/mach/se7343.h> | ||
7 | |||
8 | /* Cycle the LED's in the clasic Knightrider/Sun pattern */ | ||
9 | void heartbeat_7343se(void) | ||
10 | { | ||
11 | static unsigned int cnt = 0, period = 0; | ||
12 | volatile unsigned short *p = (volatile unsigned short *) PA_LED; | ||
13 | static unsigned bit = 0, up = 1; | ||
14 | |||
15 | cnt += 1; | ||
16 | if (cnt < period) { | ||
17 | return; | ||
18 | } | ||
19 | |||
20 | cnt = 0; | ||
21 | |||
22 | /* Go through the points (roughly!): | ||
23 | * f(0)=10, f(1)=16, f(2)=20, f(5)=35,f(inf)->110 | ||
24 | */ | ||
25 | period = 110 - ((300 << FSHIFT) / ((avenrun[0] / 5) + (3 << FSHIFT))); | ||
26 | |||
27 | if (up) { | ||
28 | if (bit == 7) { | ||
29 | bit--; | ||
30 | up = 0; | ||
31 | } else { | ||
32 | bit++; | ||
33 | } | ||
34 | } else { | ||
35 | if (bit == 0) { | ||
36 | bit++; | ||
37 | up = 1; | ||
38 | } else { | ||
39 | bit--; | ||
40 | } | ||
41 | } | ||
42 | *p = 1 << (bit + LED_SHIFT); | ||
43 | |||
44 | } | ||
diff --git a/arch/sh/boards/se/7343/setup.c b/arch/sh/boards/se/7343/setup.c index c7d17fe7764e..3fdb16f2cef1 100644 --- a/arch/sh/boards/se/7343/setup.c +++ b/arch/sh/boards/se/7343/setup.c | |||
@@ -4,7 +4,6 @@ | |||
4 | #include <asm/mach/se7343.h> | 4 | #include <asm/mach/se7343.h> |
5 | #include <asm/irq.h> | 5 | #include <asm/irq.h> |
6 | 6 | ||
7 | void heartbeat_7343se(void); | ||
8 | void init_7343se_IRQ(void); | 7 | void init_7343se_IRQ(void); |
9 | 8 | ||
10 | static struct resource smc91x_resources[] = { | 9 | static struct resource smc91x_resources[] = { |
@@ -31,14 +30,30 @@ static struct platform_device smc91x_device = { | |||
31 | .resource = smc91x_resources, | 30 | .resource = smc91x_resources, |
32 | }; | 31 | }; |
33 | 32 | ||
34 | static struct platform_device *smc91x_platform_devices[] __initdata = { | 33 | static struct resource heartbeat_resources[] = { |
34 | [0] = { | ||
35 | .start = PA_LED, | ||
36 | .end = PA_LED + 8 - 1, | ||
37 | .flags = IORESOURCE_MEM, | ||
38 | }, | ||
39 | }; | ||
40 | |||
41 | static struct platform_device heartbeat_device = { | ||
42 | .name = "heartbeat", | ||
43 | .id = -1, | ||
44 | .num_resources = ARRAY_SIZE(heartbeat_resources), | ||
45 | .resource = heartbeat_resources, | ||
46 | }; | ||
47 | |||
48 | static struct platform_device *sh7343se_platform_devices[] __initdata = { | ||
35 | &smc91x_device, | 49 | &smc91x_device, |
50 | &heartbeat_device, | ||
36 | }; | 51 | }; |
37 | 52 | ||
38 | static int __init sh7343se_devices_setup(void) | 53 | static int __init sh7343se_devices_setup(void) |
39 | { | 54 | { |
40 | return platform_add_devices(smc91x_platform_devices, | 55 | return platform_add_devices(sh7343se_platform_devices, |
41 | ARRAY_SIZE(smc91x_platform_devices)); | 56 | ARRAY_SIZE(sh7343se_platform_devices)); |
42 | } | 57 | } |
43 | 58 | ||
44 | static void __init sh7343se_setup(char **cmdline_p) | 59 | static void __init sh7343se_setup(char **cmdline_p) |
@@ -76,8 +91,5 @@ struct sh_machine_vector mv_7343se __initmv = { | |||
76 | 91 | ||
77 | .mv_init_irq = init_7343se_IRQ, | 92 | .mv_init_irq = init_7343se_IRQ, |
78 | .mv_irq_demux = shmse_irq_demux, | 93 | .mv_irq_demux = shmse_irq_demux, |
79 | #ifdef CONFIG_HEARTBEAT | ||
80 | .mv_heartbeat = heartbeat_7343se, | ||
81 | #endif | ||
82 | }; | 94 | }; |
83 | ALIAS_MV(7343se) | 95 | ALIAS_MV(7343se) |
diff --git a/arch/sh/boards/se/770x/Makefile b/arch/sh/boards/se/770x/Makefile index 9a5035f80ec0..8e624b06d5ea 100644 --- a/arch/sh/boards/se/770x/Makefile +++ b/arch/sh/boards/se/770x/Makefile | |||
@@ -3,4 +3,3 @@ | |||
3 | # | 3 | # |
4 | 4 | ||
5 | obj-y := setup.o io.o irq.o | 5 | obj-y := setup.o io.o irq.o |
6 | obj-$(CONFIG_HEARTBEAT) += led.o | ||
diff --git a/arch/sh/boards/se/770x/irq.c b/arch/sh/boards/se/770x/irq.c index fcd7cd7fa05f..307ca5da6232 100644 --- a/arch/sh/boards/se/770x/irq.c +++ b/arch/sh/boards/se/770x/irq.c | |||
@@ -2,56 +2,96 @@ | |||
2 | * linux/arch/sh/boards/se/770x/irq.c | 2 | * linux/arch/sh/boards/se/770x/irq.c |
3 | * | 3 | * |
4 | * Copyright (C) 2000 Kazumoto Kojima | 4 | * Copyright (C) 2000 Kazumoto Kojima |
5 | * Copyright (C) 2006 Nobuhiro Iwamatsu | ||
5 | * | 6 | * |
6 | * Hitachi SolutionEngine Support. | 7 | * Hitachi SolutionEngine Support. |
7 | * | 8 | * |
8 | */ | 9 | */ |
9 | 10 | ||
10 | #include <linux/init.h> | 11 | #include <linux/init.h> |
12 | #include <linux/interrupt.h> | ||
11 | #include <linux/irq.h> | 13 | #include <linux/irq.h> |
12 | #include <asm/irq.h> | 14 | #include <asm/irq.h> |
13 | #include <asm/io.h> | 15 | #include <asm/io.h> |
14 | #include <asm/se.h> | 16 | #include <asm/se.h> |
15 | 17 | ||
18 | /* | ||
19 | * If the problem of make_ipr_irq is solved, | ||
20 | * this code will become unnecessary. :-) | ||
21 | */ | ||
22 | static void se770x_disable_ipr_irq(unsigned int irq) | ||
23 | { | ||
24 | struct ipr_data *p = get_irq_chip_data(irq); | ||
25 | |||
26 | ctrl_outw(ctrl_inw(p->addr) & (0xffff ^ (0xf << p->shift)), p->addr); | ||
27 | } | ||
28 | |||
29 | static void se770x_enable_ipr_irq(unsigned int irq) | ||
30 | { | ||
31 | struct ipr_data *p = get_irq_chip_data(irq); | ||
32 | |||
33 | ctrl_outw(ctrl_inw(p->addr) | (p->priority << p->shift), p->addr); | ||
34 | } | ||
35 | |||
36 | static struct irq_chip se770x_irq_chip = { | ||
37 | .name = "MS770xSE-FPGA", | ||
38 | .mask = se770x_disable_ipr_irq, | ||
39 | .unmask = se770x_enable_ipr_irq, | ||
40 | .mask_ack = se770x_disable_ipr_irq, | ||
41 | }; | ||
42 | |||
43 | void make_se770x_irq(struct ipr_data *table, unsigned int nr_irqs) | ||
44 | { | ||
45 | int i; | ||
46 | |||
47 | for (i = 0; i < nr_irqs; i++) { | ||
48 | unsigned int irq = table[i].irq; | ||
49 | disable_irq_nosync(irq); | ||
50 | set_irq_chip_and_handler_name(irq, &se770x_irq_chip, | ||
51 | handle_level_irq, "level"); | ||
52 | set_irq_chip_data(irq, &table[i]); | ||
53 | se770x_enable_ipr_irq(irq); | ||
54 | } | ||
55 | } | ||
56 | |||
16 | static struct ipr_data se770x_ipr_map[] = { | 57 | static struct ipr_data se770x_ipr_map[] = { |
17 | #if defined(CONFIG_CPU_SUBTYPE_SH7705) | 58 | #if defined(CONFIG_CPU_SUBTYPE_SH7705) |
18 | /* This is default value */ | 59 | /* This is default value */ |
19 | { 0xf-0x2, BCR_ILCRA, 2, 0x2 }, | 60 | { 0xf-0x2, 0, 8, 0x2 , BCR_ILCRA}, |
20 | { 0xf-0xa, BCR_ILCRA, 1, 0xa }, | 61 | { 0xf-0xa, 0, 4, 0xa , BCR_ILCRA}, |
21 | { 0xf-0x5, BCR_ILCRB, 0, 0x5 }, | 62 | { 0xf-0x5, 0, 0, 0x5 , BCR_ILCRB}, |
22 | { 0xf-0x8, BCR_ILCRC, 1, 0x8 }, | 63 | { 0xf-0x8, 0, 4, 0x8 , BCR_ILCRC}, |
23 | { 0xf-0xc, BCR_ILCRC, 0, 0xc }, | 64 | { 0xf-0xc, 0, 0, 0xc , BCR_ILCRC}, |
24 | { 0xf-0xe, BCR_ILCRD, 3, 0xe }, | 65 | { 0xf-0xe, 0, 12, 0xe , BCR_ILCRD}, |
25 | { 0xf-0x3, BCR_ILCRD, 1, 0x3 }, /* LAN */ | 66 | { 0xf-0x3, 0, 4, 0x3 , BCR_ILCRD}, /* LAN */ |
26 | { 0xf-0xd, BCR_ILCRE, 2, 0xd }, | 67 | { 0xf-0xd, 0, 8, 0xd , BCR_ILCRE}, |
27 | { 0xf-0x9, BCR_ILCRE, 1, 0x9 }, | 68 | { 0xf-0x9, 0, 4, 0x9 , BCR_ILCRE}, |
28 | { 0xf-0x1, BCR_ILCRE, 0, 0x1 }, | 69 | { 0xf-0x1, 0, 0, 0x1 , BCR_ILCRE}, |
29 | { 0xf-0xf, BCR_ILCRF, 3, 0xf }, | 70 | { 0xf-0xf, 0, 12, 0xf , BCR_ILCRF}, |
30 | { 0xf-0xb, BCR_ILCRF, 1, 0xb }, | 71 | { 0xf-0xb, 0, 4, 0xb , BCR_ILCRF}, |
31 | { 0xf-0x7, BCR_ILCRG, 3, 0x7 }, | 72 | { 0xf-0x7, 0, 12, 0x7 , BCR_ILCRG}, |
32 | { 0xf-0x6, BCR_ILCRG, 2, 0x6 }, | 73 | { 0xf-0x6, 0, 8, 0x6 , BCR_ILCRG}, |
33 | { 0xf-0x4, BCR_ILCRG, 1, 0x4 }, | 74 | { 0xf-0x4, 0, 4, 0x4 , BCR_ILCRG}, |
34 | #else | 75 | #else |
35 | { 14, BCR_ILCRA, 2, 0x0f-14 }, | 76 | { 14, 0, 8, 0x0f-14 ,BCR_ILCRA}, |
36 | { 12, BCR_ILCRA, 1, 0x0f-12 }, | 77 | { 12, 0, 4, 0x0f-12 ,BCR_ILCRA}, |
37 | { 8, BCR_ILCRB, 1, 0x0f- 8 }, | 78 | { 8, 0, 4, 0x0f- 8 ,BCR_ILCRB}, |
38 | { 6, BCR_ILCRC, 3, 0x0f- 6 }, | 79 | { 6, 0, 12, 0x0f- 6 ,BCR_ILCRC}, |
39 | { 5, BCR_ILCRC, 2, 0x0f- 5 }, | 80 | { 5, 0, 8, 0x0f- 5 ,BCR_ILCRC}, |
40 | { 4, BCR_ILCRC, 1, 0x0f- 4 }, | 81 | { 4, 0, 4, 0x0f- 4 ,BCR_ILCRC}, |
41 | { 3, BCR_ILCRC, 0, 0x0f- 3 }, | 82 | { 3, 0, 0, 0x0f- 3 ,BCR_ILCRC}, |
42 | { 1, BCR_ILCRD, 3, 0x0f- 1 }, | 83 | { 1, 0, 12, 0x0f- 1 ,BCR_ILCRD}, |
43 | 84 | /* ST NIC */ | |
44 | { 10, BCR_ILCRD, 1, 0x0f-10 }, /* LAN */ | 85 | { 10, 0, 4, 0x0f-10 ,BCR_ILCRD}, /* LAN */ |
45 | 86 | /* MRSHPC IRQs setting */ | |
46 | { 0, BCR_ILCRE, 3, 0x0f- 0 }, /* PCIRQ3 */ | 87 | { 0, 0, 12, 0x0f- 0 ,BCR_ILCRE}, /* PCIRQ3 */ |
47 | { 11, BCR_ILCRE, 2, 0x0f-11 }, /* PCIRQ2 */ | 88 | { 11, 0, 8, 0x0f-11 ,BCR_ILCRE}, /* PCIRQ2 */ |
48 | { 9, BCR_ILCRE, 1, 0x0f- 9 }, /* PCIRQ1 */ | 89 | { 9, 0, 4, 0x0f- 9 ,BCR_ILCRE}, /* PCIRQ1 */ |
49 | { 7, BCR_ILCRE, 0, 0x0f- 7 }, /* PCIRQ0 */ | 90 | { 7, 0, 0, 0x0f- 7 ,BCR_ILCRE}, /* PCIRQ0 */ |
50 | |||
51 | /* #2, #13 are allocated for SLOT IRQ #1 and #2 (for now) */ | 91 | /* #2, #13 are allocated for SLOT IRQ #1 and #2 (for now) */ |
52 | /* NOTE: #2 and #13 are not used on PC */ | 92 | /* NOTE: #2 and #13 are not used on PC */ |
53 | { 13, BCR_ILCRG, 1, 0x0f-13 }, /* SLOTIRQ2 */ | 93 | { 13, 0, 4, 0x0f-13 ,BCR_ILCRG}, /* SLOTIRQ2 */ |
54 | { 2, BCR_ILCRG, 0, 0x0f- 2 }, /* SLOTIRQ1 */ | 94 | { 2, 0, 0, 0x0f- 2 ,BCR_ILCRG}, /* SLOTIRQ1 */ |
55 | #endif | 95 | #endif |
56 | }; | 96 | }; |
57 | 97 | ||
@@ -81,5 +121,5 @@ void __init init_se_IRQ(void) | |||
81 | ctrl_outw(0, BCR_ILCRF); | 121 | ctrl_outw(0, BCR_ILCRF); |
82 | ctrl_outw(0, BCR_ILCRG); | 122 | ctrl_outw(0, BCR_ILCRG); |
83 | #endif | 123 | #endif |
84 | make_ipr_irq(se770x_ipr_map, ARRAY_SIZE(se770x_ipr_map)); | 124 | make_se770x_irq(se770x_ipr_map, ARRAY_SIZE(se770x_ipr_map)); |
85 | } | 125 | } |
diff --git a/arch/sh/boards/se/770x/led.c b/arch/sh/boards/se/770x/led.c deleted file mode 100644 index d93dd831b2ad..000000000000 --- a/arch/sh/boards/se/770x/led.c +++ /dev/null | |||
@@ -1,52 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/boards/se/770x/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 Solution Engine specific LED code. | ||
10 | */ | ||
11 | |||
12 | #include <linux/sched.h> | ||
13 | #include <asm/se.h> | ||
14 | |||
15 | /* Cycle the LED's in the clasic Knightrider/Sun pattern */ | ||
16 | void heartbeat_se(void) | ||
17 | { | ||
18 | static unsigned int cnt = 0, period = 0; | ||
19 | volatile unsigned short* p = (volatile unsigned short*)PA_LED; | ||
20 | static unsigned bit = 0, up = 1; | ||
21 | |||
22 | cnt += 1; | ||
23 | if (cnt < period) { | ||
24 | return; | ||
25 | } | ||
26 | |||
27 | cnt = 0; | ||
28 | |||
29 | /* Go through the points (roughly!): | ||
30 | * f(0)=10, f(1)=16, f(2)=20, f(5)=35,f(inf)->110 | ||
31 | */ | ||
32 | period = 110 - ( (300<<FSHIFT)/ | ||
33 | ((avenrun[0]/5) + (3<<FSHIFT)) ); | ||
34 | |||
35 | if (up) { | ||
36 | if (bit == 7) { | ||
37 | bit--; | ||
38 | up=0; | ||
39 | } else { | ||
40 | bit ++; | ||
41 | } | ||
42 | } else { | ||
43 | if (bit == 0) { | ||
44 | bit++; | ||
45 | up=1; | ||
46 | } else { | ||
47 | bit--; | ||
48 | } | ||
49 | } | ||
50 | *p = 1<<(bit+8); | ||
51 | |||
52 | } | ||
diff --git a/arch/sh/boards/se/770x/setup.c b/arch/sh/boards/se/770x/setup.c index a1d51d5fa925..45cbc36b9fb7 100644 --- a/arch/sh/boards/se/770x/setup.c +++ b/arch/sh/boards/se/770x/setup.c | |||
@@ -1,5 +1,4 @@ | |||
1 | /* $Id: setup.c,v 1.1.2.4 2002/03/02 21:57:07 lethal Exp $ | 1 | /* |
2 | * | ||
3 | * linux/arch/sh/boards/se/770x/setup.c | 2 | * linux/arch/sh/boards/se/770x/setup.c |
4 | * | 3 | * |
5 | * Copyright (C) 2000 Kazumoto Kojima | 4 | * Copyright (C) 2000 Kazumoto Kojima |
@@ -8,12 +7,12 @@ | |||
8 | * | 7 | * |
9 | */ | 8 | */ |
10 | #include <linux/init.h> | 9 | #include <linux/init.h> |
10 | #include <linux/platform_device.h> | ||
11 | #include <asm/machvec.h> | 11 | #include <asm/machvec.h> |
12 | #include <asm/se.h> | 12 | #include <asm/se.h> |
13 | #include <asm/io.h> | 13 | #include <asm/io.h> |
14 | #include <asm/smc37c93x.h> | 14 | #include <asm/smc37c93x.h> |
15 | 15 | ||
16 | void heartbeat_se(void); | ||
17 | void init_se_IRQ(void); | 16 | void init_se_IRQ(void); |
18 | 17 | ||
19 | /* | 18 | /* |
@@ -36,11 +35,6 @@ static void __init smsc_setup(char **cmdline_p) | |||
36 | smsc_config(ACTIVATE_INDEX, 0x01); | 35 | smsc_config(ACTIVATE_INDEX, 0x01); |
37 | smsc_config(IRQ_SELECT_INDEX, 6); /* IRQ6 */ | 36 | smsc_config(IRQ_SELECT_INDEX, 6); /* IRQ6 */ |
38 | 37 | ||
39 | /* IDE1 */ | ||
40 | smsc_config(CURRENT_LDN_INDEX, LDN_IDE1); | ||
41 | smsc_config(ACTIVATE_INDEX, 0x01); | ||
42 | smsc_config(IRQ_SELECT_INDEX, 14); /* IRQ14 */ | ||
43 | |||
44 | /* AUXIO (GPIO): to use IDE1 */ | 38 | /* AUXIO (GPIO): to use IDE1 */ |
45 | smsc_config(CURRENT_LDN_INDEX, LDN_AUXIO); | 39 | smsc_config(CURRENT_LDN_INDEX, LDN_AUXIO); |
46 | smsc_config(GPIO46_INDEX, 0x00); /* nIOROP */ | 40 | smsc_config(GPIO46_INDEX, 0x00); /* nIOROP */ |
@@ -69,6 +63,36 @@ static void __init smsc_setup(char **cmdline_p) | |||
69 | outb_p(CONFIG_EXIT, CONFIG_PORT); | 63 | outb_p(CONFIG_EXIT, CONFIG_PORT); |
70 | } | 64 | } |
71 | 65 | ||
66 | static unsigned char heartbeat_bit_pos[] = { 8, 9, 10, 11, 12, 13, 14, 15 }; | ||
67 | |||
68 | static struct resource heartbeat_resources[] = { | ||
69 | [0] = { | ||
70 | .start = PA_LED, | ||
71 | .end = PA_LED + ARRAY_SIZE(heartbeat_bit_pos) - 1, | ||
72 | .flags = IORESOURCE_MEM, | ||
73 | }, | ||
74 | }; | ||
75 | |||
76 | static struct platform_device heartbeat_device = { | ||
77 | .name = "heartbeat", | ||
78 | .id = -1, | ||
79 | .dev = { | ||
80 | .platform_data = heartbeat_bit_pos, | ||
81 | }, | ||
82 | .num_resources = ARRAY_SIZE(heartbeat_resources), | ||
83 | .resource = heartbeat_resources, | ||
84 | }; | ||
85 | |||
86 | static struct platform_device *se_devices[] __initdata = { | ||
87 | &heartbeat_device, | ||
88 | }; | ||
89 | |||
90 | static int __init se_devices_setup(void) | ||
91 | { | ||
92 | return platform_add_devices(se_devices, ARRAY_SIZE(se_devices)); | ||
93 | } | ||
94 | __initcall(se_devices_setup); | ||
95 | |||
72 | /* | 96 | /* |
73 | * The Machine Vector | 97 | * The Machine Vector |
74 | */ | 98 | */ |
@@ -107,8 +131,5 @@ struct sh_machine_vector mv_se __initmv = { | |||
107 | .mv_outsl = se_outsl, | 131 | .mv_outsl = se_outsl, |
108 | 132 | ||
109 | .mv_init_irq = init_se_IRQ, | 133 | .mv_init_irq = init_se_IRQ, |
110 | #ifdef CONFIG_HEARTBEAT | ||
111 | .mv_heartbeat = heartbeat_se, | ||
112 | #endif | ||
113 | }; | 134 | }; |
114 | ALIAS_MV(se) | 135 | ALIAS_MV(se) |
diff --git a/arch/sh/boards/se/7751/Makefile b/arch/sh/boards/se/7751/Makefile index 188900c48321..dbc29f3a9de5 100644 --- a/arch/sh/boards/se/7751/Makefile +++ b/arch/sh/boards/se/7751/Makefile | |||
@@ -5,4 +5,3 @@ | |||
5 | obj-y := setup.o io.o irq.o | 5 | obj-y := setup.o io.o irq.o |
6 | 6 | ||
7 | obj-$(CONFIG_PCI) += pci.o | 7 | obj-$(CONFIG_PCI) += pci.o |
8 | obj-$(CONFIG_HEARTBEAT) += led.o | ||
diff --git a/arch/sh/boards/se/7751/led.c b/arch/sh/boards/se/7751/led.c deleted file mode 100644 index de4194d97c88..000000000000 --- a/arch/sh/boards/se/7751/led.c +++ /dev/null | |||
@@ -1,51 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/boards/se/7751/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 Solution Engine specific LED code. | ||
10 | */ | ||
11 | #include <linux/sched.h> | ||
12 | #include <asm/se7751.h> | ||
13 | |||
14 | /* Cycle the LED's in the clasic Knightrider/Sun pattern */ | ||
15 | void heartbeat_7751se(void) | ||
16 | { | ||
17 | static unsigned int cnt = 0, period = 0; | ||
18 | volatile unsigned short* p = (volatile unsigned short*)PA_LED; | ||
19 | static unsigned bit = 0, up = 1; | ||
20 | |||
21 | cnt += 1; | ||
22 | if (cnt < period) { | ||
23 | return; | ||
24 | } | ||
25 | |||
26 | cnt = 0; | ||
27 | |||
28 | /* Go through the points (roughly!): | ||
29 | * f(0)=10, f(1)=16, f(2)=20, f(5)=35,f(inf)->110 | ||
30 | */ | ||
31 | period = 110 - ( (300<<FSHIFT)/ | ||
32 | ((avenrun[0]/5) + (3<<FSHIFT)) ); | ||
33 | |||
34 | if (up) { | ||
35 | if (bit == 7) { | ||
36 | bit--; | ||
37 | up=0; | ||
38 | } else { | ||
39 | bit ++; | ||
40 | } | ||
41 | } else { | ||
42 | if (bit == 0) { | ||
43 | bit++; | ||
44 | up=1; | ||
45 | } else { | ||
46 | bit--; | ||
47 | } | ||
48 | } | ||
49 | *p = 1<<(bit+8); | ||
50 | |||
51 | } | ||
diff --git a/arch/sh/boards/se/7751/setup.c b/arch/sh/boards/se/7751/setup.c index f7e1dd39c836..e3feae6ec0bf 100644 --- a/arch/sh/boards/se/7751/setup.c +++ b/arch/sh/boards/se/7751/setup.c | |||
@@ -9,11 +9,11 @@ | |||
9 | * Ian da Silva and Jeremy Siegel, 2001. | 9 | * Ian da Silva and Jeremy Siegel, 2001. |
10 | */ | 10 | */ |
11 | #include <linux/init.h> | 11 | #include <linux/init.h> |
12 | #include <linux/platform_device.h> | ||
12 | #include <asm/machvec.h> | 13 | #include <asm/machvec.h> |
13 | #include <asm/se7751.h> | 14 | #include <asm/se7751.h> |
14 | #include <asm/io.h> | 15 | #include <asm/io.h> |
15 | 16 | ||
16 | void heartbeat_7751se(void); | ||
17 | void init_7751se_IRQ(void); | 17 | void init_7751se_IRQ(void); |
18 | 18 | ||
19 | #ifdef CONFIG_SH_KGDB | 19 | #ifdef CONFIG_SH_KGDB |
@@ -161,11 +161,40 @@ static int kgdb_uart_setup(void) | |||
161 | } | 161 | } |
162 | #endif /* CONFIG_SH_KGDB */ | 162 | #endif /* CONFIG_SH_KGDB */ |
163 | 163 | ||
164 | static unsigned char heartbeat_bit_pos[] = { 8, 9, 10, 11, 12, 13, 14, 15 }; | ||
165 | |||
166 | static struct resource heartbeat_resources[] = { | ||
167 | [0] = { | ||
168 | .start = PA_LED, | ||
169 | .end = PA_LED + ARRAY_SIZE(heartbeat_bit_pos) - 1, | ||
170 | .flags = IORESOURCE_MEM, | ||
171 | }, | ||
172 | }; | ||
173 | |||
174 | static struct platform_device heartbeat_device = { | ||
175 | .name = "heartbeat", | ||
176 | .id = -1, | ||
177 | .dev = { | ||
178 | .platform_data = heartbeat_bit_pos, | ||
179 | }, | ||
180 | .num_resources = ARRAY_SIZE(heartbeat_resources), | ||
181 | .resource = heartbeat_resources, | ||
182 | }; | ||
183 | |||
184 | static struct platform_device *se7751_devices[] __initdata = { | ||
185 | &smc91x_device, | ||
186 | &heartbeat_device, | ||
187 | }; | ||
188 | |||
189 | static int __init se7751_devices_setup(void) | ||
190 | { | ||
191 | return platform_add_devices(se7751_devices, ARRAY_SIZE(se7751_devices)); | ||
192 | } | ||
193 | __initcall(se7751_devices_setup); | ||
164 | 194 | ||
165 | /* | 195 | /* |
166 | * The Machine Vector | 196 | * The Machine Vector |
167 | */ | 197 | */ |
168 | |||
169 | struct sh_machine_vector mv_7751se __initmv = { | 198 | struct sh_machine_vector mv_7751se __initmv = { |
170 | .mv_name = "7751 SolutionEngine", | 199 | .mv_name = "7751 SolutionEngine", |
171 | .mv_setup = sh7751se_setup, | 200 | .mv_setup = sh7751se_setup, |
@@ -189,8 +218,5 @@ struct sh_machine_vector mv_7751se __initmv = { | |||
189 | .mv_outsl = sh7751se_outsl, | 218 | .mv_outsl = sh7751se_outsl, |
190 | 219 | ||
191 | .mv_init_irq = init_7751se_IRQ, | 220 | .mv_init_irq = init_7751se_IRQ, |
192 | #ifdef CONFIG_HEARTBEAT | ||
193 | .mv_heartbeat = heartbeat_7751se, | ||
194 | #endif | ||
195 | }; | 221 | }; |
196 | ALIAS_MV(7751se) | 222 | ALIAS_MV(7751se) |
diff --git a/arch/sh/boards/sh03/Makefile b/arch/sh/boards/sh03/Makefile index 321be50e36a5..400306a796ec 100644 --- a/arch/sh/boards/sh03/Makefile +++ b/arch/sh/boards/sh03/Makefile | |||
@@ -3,4 +3,3 @@ | |||
3 | # | 3 | # |
4 | 4 | ||
5 | obj-y := setup.o rtc.o | 5 | obj-y := setup.o rtc.o |
6 | obj-$(CONFIG_HEARTBEAT) += led.o | ||
diff --git a/arch/sh/boards/sh03/led.c b/arch/sh/boards/sh03/led.c deleted file mode 100644 index d38562ad6be8..000000000000 --- a/arch/sh/boards/sh03/led.c +++ /dev/null | |||
@@ -1,48 +0,0 @@ | |||
1 | /* | ||
2 | * linux/arch/sh/boards/sh03/led.c | ||
3 | * | ||
4 | * Copyright (C) 2004 Saito.K Interface Corporation. | ||
5 | * | ||
6 | * This file contains Interface CTP/PCI-SH03 specific LED code. | ||
7 | */ | ||
8 | |||
9 | #include <linux/sched.h> | ||
10 | |||
11 | /* Cycle the LED's in the clasic Knightrider/Sun pattern */ | ||
12 | void heartbeat_sh03(void) | ||
13 | { | ||
14 | static unsigned int cnt = 0, period = 0; | ||
15 | volatile unsigned char* p = (volatile unsigned char*)0xa0800000; | ||
16 | static unsigned bit = 0, up = 1; | ||
17 | |||
18 | cnt += 1; | ||
19 | if (cnt < period) { | ||
20 | return; | ||
21 | } | ||
22 | |||
23 | cnt = 0; | ||
24 | |||
25 | /* Go through the points (roughly!): | ||
26 | * f(0)=10, f(1)=16, f(2)=20, f(5)=35,f(inf)->110 | ||
27 | */ | ||
28 | period = 110 - ( (300<<FSHIFT)/ | ||
29 | ((avenrun[0]/5) + (3<<FSHIFT)) ); | ||
30 | |||
31 | if (up) { | ||
32 | if (bit == 7) { | ||
33 | bit--; | ||
34 | up=0; | ||
35 | } else { | ||
36 | bit ++; | ||
37 | } | ||
38 | } else { | ||
39 | if (bit == 0) { | ||
40 | bit++; | ||
41 | up=1; | ||
42 | } else { | ||
43 | bit--; | ||
44 | } | ||
45 | } | ||
46 | *p = 1<<bit; | ||
47 | |||
48 | } | ||
diff --git a/arch/sh/boards/sh03/setup.c b/arch/sh/boards/sh03/setup.c index 5ad1e19771be..c069c444b4ec 100644 --- a/arch/sh/boards/sh03/setup.c +++ b/arch/sh/boards/sh03/setup.c | |||
@@ -8,6 +8,7 @@ | |||
8 | #include <linux/init.h> | 8 | #include <linux/init.h> |
9 | #include <linux/irq.h> | 9 | #include <linux/irq.h> |
10 | #include <linux/pci.h> | 10 | #include <linux/pci.h> |
11 | #include <linux/platform_device.h> | ||
11 | #include <asm/io.h> | 12 | #include <asm/io.h> |
12 | #include <asm/rtc.h> | 13 | #include <asm/rtc.h> |
13 | #include <asm/sh03/io.h> | 14 | #include <asm/sh03/io.h> |
@@ -48,15 +49,36 @@ static void __init sh03_setup(char **cmdline_p) | |||
48 | board_time_init = sh03_time_init; | 49 | board_time_init = sh03_time_init; |
49 | } | 50 | } |
50 | 51 | ||
52 | static struct resource heartbeat_resources[] = { | ||
53 | [0] = { | ||
54 | .start = 0xa0800000, | ||
55 | .end = 0xa0800000 + 8 - 1, | ||
56 | .flags = IORESOURCE_MEM, | ||
57 | }, | ||
58 | }; | ||
59 | |||
60 | static struct platform_device heartbeat_device = { | ||
61 | .name = "heartbeat", | ||
62 | .id = -1, | ||
63 | .num_resources = ARRAY_SIZE(heartbeat_resources), | ||
64 | .resource = heartbeat_resources, | ||
65 | }; | ||
66 | |||
67 | static struct platform_device *sh03_devices[] __initdata = { | ||
68 | &heartbeat_device, | ||
69 | }; | ||
70 | |||
71 | static int __init sh03_devices_setup(void) | ||
72 | { | ||
73 | return platform_add_devices(sh03_devices, ARRAY_SIZE(sh03_devices)); | ||
74 | } | ||
75 | __initcall(sh03_devices_setup); | ||
76 | |||
51 | struct sh_machine_vector mv_sh03 __initmv = { | 77 | struct sh_machine_vector mv_sh03 __initmv = { |
52 | .mv_name = "Interface (CTP/PCI-SH03)", | 78 | .mv_name = "Interface (CTP/PCI-SH03)", |
53 | .mv_setup = sh03_setup, | 79 | .mv_setup = sh03_setup, |
54 | .mv_nr_irqs = 48, | 80 | .mv_nr_irqs = 48, |
55 | .mv_ioport_map = sh03_ioport_map, | 81 | .mv_ioport_map = sh03_ioport_map, |
56 | .mv_init_irq = init_sh03_IRQ, | 82 | .mv_init_irq = init_sh03_IRQ, |
57 | |||
58 | #ifdef CONFIG_HEARTBEAT | ||
59 | .mv_heartbeat = heartbeat_sh03, | ||
60 | #endif | ||
61 | }; | 83 | }; |
62 | ALIAS_MV(sh03) | 84 | ALIAS_MV(sh03) |
diff --git a/arch/sh/boards/shmin/setup.c b/arch/sh/boards/shmin/setup.c index a31a1d1e2681..4a9df4a6b034 100644 --- a/arch/sh/boards/shmin/setup.c +++ b/arch/sh/boards/shmin/setup.c | |||
@@ -12,12 +12,22 @@ | |||
12 | #include <asm/irq.h> | 12 | #include <asm/irq.h> |
13 | #include <asm/io.h> | 13 | #include <asm/io.h> |
14 | 14 | ||
15 | #define PFC_PHCR 0xa400010e | 15 | #define PFC_PHCR 0xa400010eUL |
16 | #define INTC_ICR1 0xa4000010UL | ||
17 | #define INTC_IPRC 0xa4000016UL | ||
18 | |||
19 | static struct ipr_data shmin_ipr_map[] = { | ||
20 | { .irq=32, .addr=INTC_IPRC, .shift= 0, .priority=0 }, | ||
21 | { .irq=33, .addr=INTC_IPRC, .shift= 4, .priority=0 }, | ||
22 | { .irq=34, .addr=INTC_IPRC, .shift= 8, .priority=8 }, | ||
23 | { .irq=35, .addr=INTC_IPRC, .shift=12, .priority=0 }, | ||
24 | }; | ||
16 | 25 | ||
17 | static void __init init_shmin_irq(void) | 26 | static void __init init_shmin_irq(void) |
18 | { | 27 | { |
19 | ctrl_outw(0x2a00, PFC_PHCR); // IRQ0-3=IRQ | 28 | ctrl_outw(0x2a00, PFC_PHCR); // IRQ0-3=IRQ |
20 | ctrl_outw(0x0aaa, INTC_ICR1); // IRQ0-3=IRQ-mode,Low-active. | 29 | ctrl_outw(0x0aaa, INTC_ICR1); // IRQ0-3=IRQ-mode,Low-active. |
30 | make_ipr_irq(shmin_ipr_map, ARRAY_SIZE(shmin_ipr_map)); | ||
21 | } | 31 | } |
22 | 32 | ||
23 | static void __iomem *shmin_ioport_map(unsigned long port, unsigned int size) | 33 | static void __iomem *shmin_ioport_map(unsigned long port, unsigned int size) |