aboutsummaryrefslogtreecommitdiff
path: root/arch/sh/kernel/cpu/sh4/irq_intc2.c
blob: f6b16ba01932f89929812c088a7d8808f2c5aa87 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
/*
 * linux/arch/sh/kernel/irq_intc2.c
 *
 * Copyright (C) 2001 David J. Mckay (david.mckay@st.com)
 *
 * May be copied or modified under the terms of the GNU General Public
 * License.  See linux/COPYING for more information.                            
 *
 * Interrupt handling for INTC2-based IRQ.
 *
 * These are the "new Hitachi style" interrupts, as present on the 
 * Hitachi 7751 and the STM ST40 STB1.
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/irq.h>

#include <asm/system.h>
#include <asm/io.h>
#include <asm/machvec.h>


struct intc2_data {
	unsigned char msk_offset;
	unsigned char msk_shift;
#ifdef CONFIG_CPU_SUBTYPE_ST40
	int (*clear_irq) (int);
#endif
};


static struct intc2_data intc2_data[NR_INTC2_IRQS];

static void enable_intc2_irq(unsigned int irq);
static void disable_intc2_irq(unsigned int irq);

/* shutdown is same as "disable" */
#define shutdown_intc2_irq disable_intc2_irq

static void mask_and_ack_intc2(unsigned int);
static void end_intc2_irq(unsigned int irq);

static unsigned int startup_intc2_irq(unsigned int irq)
{ 
	enable_intc2_irq(irq);
	return 0; /* never anything pending */
}

static struct hw_interrupt_type intc2_irq_type = {
	.typename = "INTC2-IRQ",
	.startup = startup_intc2_irq,
	.shutdown = shutdown_intc2_irq,
	.enable = enable_intc2_irq,
	.disable = disable_intc2_irq,
	.ack = mask_and_ack_intc2,
	.end = end_intc2_irq
};

static void disable_intc2_irq(unsigned int irq)
{
	int irq_offset = irq - INTC2_FIRST_IRQ;
	int msk_shift, msk_offset;

	// Sanity check
	if((irq_offset<0) || (irq_offset>=NR_INTC2_IRQS))
		return;

	msk_shift = intc2_data[irq_offset].msk_shift;
	msk_offset = intc2_data[irq_offset].msk_offset;

	ctrl_outl(1<<msk_shift,
		  INTC2_BASE+INTC2_INTMSK_OFFSET+msk_offset);
}

static void enable_intc2_irq(unsigned int irq)
{
	int irq_offset = irq - INTC2_FIRST_IRQ;
	int msk_shift, msk_offset;

	/* Sanity check */
	if((irq_offset<0) || (irq_offset>=NR_INTC2_IRQS))
		return;

	msk_shift = intc2_data[irq_offset].msk_shift;
	msk_offset = intc2_data[irq_offset].msk_offset;

	ctrl_outl(1<<msk_shift,
		  INTC2_BASE+INTC2_INTMSKCLR_OFFSET+msk_offset);
}

static void mask_and_ack_intc2(unsigned int irq)
{
	disable_intc2_irq(irq);
}

static void end_intc2_irq(unsigned int irq)
{
	if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS)))
		enable_intc2_irq(irq);

#ifdef CONFIG_CPU_SUBTYPE_ST40
	if (intc2_data[irq - INTC2_FIRST_IRQ].clear_irq)
		intc2_data[irq - INTC2_FIRST_IRQ].clear_irq (irq);
#endif
}

/*
 * Setup an INTC2 style interrupt.
 * NOTE: Unlike IPR interrupts, parameters are not shifted by this code,
 * allowing the use of the numbers straight out of the datasheet.
 * For example:
 *    PIO1 which is INTPRI00[19,16] and INTMSK00[13]
 * would be:               ^     ^             ^  ^
 *                         |     |             |  |
 *    make_intc2_irq(84,   0,   16,            0, 13);
 */
void make_intc2_irq(unsigned int irq,
		    unsigned int ipr_offset, unsigned int ipr_shift,
		    unsigned int msk_offset, unsigned int msk_shift,
		    unsigned int priority)
{
	int irq_offset = irq - INTC2_FIRST_IRQ;
	unsigned int flags;
	unsigned long ipr;

	if((irq_offset<0) || (irq_offset>=NR_INTC2_IRQS))
		return;

	disable_irq_nosync(irq);

	/* Fill the data we need */
	intc2_data[irq_offset].msk_offset = msk_offset;
	intc2_data[irq_offset].msk_shift  = msk_shift;
#ifdef CONFIG_CPU_SUBTYPE_ST40
	intc2_data[irq_offset].clear_irq = NULL;
#endif
		
	/* Set the priority level */
	local_irq_save(flags);

	ipr=ctrl_inl(INTC2_BASE+INTC2_INTPRI_OFFSET+ipr_offset);
	ipr&=~(0xf<<ipr_shift);
	ipr|=(priority)<<ipr_shift;
	ctrl_outl(ipr, INTC2_BASE+INTC2_INTPRI_OFFSET+ipr_offset);

	local_irq_restore(flags);

	irq_desc[irq].handler=&intc2_irq_type;

	disable_intc2_irq(irq);
}

#ifdef CONFIG_CPU_SUBTYPE_ST40

struct intc2_init {
	unsigned short irq;
	unsigned char ipr_offset, ipr_shift;
	unsigned char msk_offset, msk_shift;
};

static struct intc2_init intc2_init_data[]  __initdata = {
	{64,  0,  0, 0,  0},	/* PCI serr */
	{65,  0,  4, 0,  1},	/* PCI err */
	{66,  0,  4, 0,  2},	/* PCI ad */
	{67,  0,  4, 0,  3},	/* PCI pwd down */
	{72,  0,  8, 0,  5},	/* DMAC INT0 */
	{73,  0,  8, 0,  6},	/* DMAC INT1 */
	{74,  0,  8, 0,  7},	/* DMAC INT2 */
	{75,  0,  8, 0,  8},	/* DMAC INT3 */
	{76,  0,  8, 0,  9},	/* DMAC INT4 */
	{78,  0,  8, 0, 11},	/* DMAC ERR */
	{80,  0, 12, 0, 12},	/* PIO0 */
	{84,  0, 16, 0, 13},	/* PIO1 */
	{88,  0, 20, 0, 14},	/* PIO2 */
	{112, 4,  0, 4,  0},	/* Mailbox */
#ifdef CONFIG_CPU_SUBTYPE_ST40GX1
	{116, 4,  4, 4,  4},	/* SSC0 */
	{120, 4,  8, 4,  8},	/* IR Blaster */
	{124, 4, 12, 4, 12},	/* USB host */
	{128, 4, 16, 4, 16},	/* Video processor BLITTER */
	{132, 4, 20, 4, 20},	/* UART0 */
	{134, 4, 20, 4, 22},	/* UART2 */
	{136, 4, 24, 4, 24},	/* IO_PIO0 */
	{140, 4, 28, 4, 28},	/* EMPI */
	{144, 8,  0, 8,  0},	/* MAFE */
	{148, 8,  4, 8,  4},	/* PWM */
	{152, 8,  8, 8,  8},	/* SSC1 */
	{156, 8, 12, 8, 12},	/* IO_PIO1 */
	{160, 8, 16, 8, 16},	/* USB target */
	{164, 8, 20, 8, 20},	/* UART1 */
	{168, 8, 24, 8, 24},	/* Teletext */
	{172, 8, 28, 8, 28},	/* VideoSync VTG */
	{173, 8, 28, 8, 29},	/* VideoSync DVP0 */
	{174, 8, 28, 8, 30},	/* VideoSync DVP1 */
#endif
};

void __init init_IRQ_intc2(void)
{
	struct intc2_init *p;

	printk(KERN_ALERT "init_IRQ_intc2\n");

	for (p = intc2_init_data;
	     p<intc2_init_data+ARRAY_SIZE(intc2_init_data);
	     p++) {
		make_intc2_irq(p->irq, p->ipr_offset, p->ipr_shift,
			       p-> msk_offset, p->msk_shift, 13);
	}
}

/* Adds a termination callback to the interrupt */
void intc2_add_clear_irq(int irq, int (*fn)(int))
{
	if (irq < INTC2_FIRST_IRQ)
		return;

	intc2_data[irq - INTC2_FIRST_IRQ].clear_irq = fn;
}

#endif /* CONFIG_CPU_SUBTYPE_ST40 */