alpha: i8259, alcor, jensen wildfire: Convert irq_chip

Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Signed-off-by: Matt Turner <mattst88@gmail.com>

alpha: i8259, alcor, jensen wildfire: Convert irq_chip
Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Signed-off-by: Matt Turner <mattst88@gmail.com>
Thomas Gleixner · Matt Turner
1 parent 35252254cb
Showing 5 changed files with 58 additions and 52 deletions Side-by-side Diff
arch/alpha/kernel/irq_i8259.c
arch/alpha/kernel/irq_impl.h
arch/alpha/kernel/sys_alcor.c
arch/alpha/kernel/sys_jensen.c
arch/alpha/kernel/sys_wildfire.c
@@ -33,10 +33,10 @@
 }
  
 inline void
-i8259a_enable_irq(unsigned int irq)
+i8259a_enable_irq(struct irq_data *d)
 {
 	spin_lock(&i8259_irq_lock);
-	i8259_update_irq_hw(irq, cached_irq_mask &= ~(1 << irq));
+	i8259_update_irq_hw(d->irq, cached_irq_mask &= ~(1 << d->irq));
 	spin_unlock(&i8259_irq_lock);
 }
  
  
  
  
@@ -47,16 +47,18 @@
 }
  
 void
-i8259a_disable_irq(unsigned int irq)
+i8259a_disable_irq(struct irq_data *d)
 {
 	spin_lock(&i8259_irq_lock);
-	__i8259a_disable_irq(irq);
+	__i8259a_disable_irq(d->irq);
 	spin_unlock(&i8259_irq_lock);
 }
  
 void
-i8259a_mask_and_ack_irq(unsigned int irq)
+i8259a_mask_and_ack_irq(struct irq_data *d)
 {
+	unsigned int irq = d->irq;
+
 	spin_lock(&i8259_irq_lock);
 	__i8259a_disable_irq(irq);
  
@@ -71,9 +73,9 @@
  
 struct irq_chip i8259a_irq_type = {
 	.name		= "XT-PIC",
-	.unmask		= i8259a_enable_irq,
-	.mask		= i8259a_disable_irq,
-	.mask_ack	= i8259a_mask_and_ack_irq,
+	.irq_unmask	= i8259a_enable_irq,
+	.irq_mask	= i8259a_disable_irq,
+	.irq_mask_ack	= i8259a_mask_and_ack_irq,
 };
  
 void __init
@@ -31,11 +31,9 @@
  
 extern void common_init_isa_dma(void);
  
-extern void i8259a_enable_irq(unsigned int);
-extern void i8259a_disable_irq(unsigned int);
-extern void i8259a_mask_and_ack_irq(unsigned int);
-extern unsigned int i8259a_startup_irq(unsigned int);
-extern void i8259a_end_irq(unsigned int);
+extern void i8259a_enable_irq(struct irq_data *d);
+extern void i8259a_disable_irq(struct irq_data *d);
+extern void i8259a_mask_and_ack_irq(struct irq_data *d);
 extern struct irq_chip i8259a_irq_type;
 extern void init_i8259a_irqs(void);
  
@@ -44,31 +44,31 @@
 }
  
 static inline void
-alcor_enable_irq(unsigned int irq)
+alcor_enable_irq(struct irq_data *d)
 {
-	alcor_update_irq_hw(cached_irq_mask |= 1UL << (irq - 16));
+	alcor_update_irq_hw(cached_irq_mask |= 1UL << (d->irq - 16));
 }
  
 static void
-alcor_disable_irq(unsigned int irq)
+alcor_disable_irq(struct irq_data *d)
 {
-	alcor_update_irq_hw(cached_irq_mask &= ~(1UL << (irq - 16)));
+	alcor_update_irq_hw(cached_irq_mask &= ~(1UL << (d->irq - 16)));
 }
  
 static void
-alcor_mask_and_ack_irq(unsigned int irq)
+alcor_mask_and_ack_irq(struct irq_data *d)
 {
-	alcor_disable_irq(irq);
+	alcor_disable_irq(d);
  
 	/* On ALCOR/XLT, need to dismiss interrupt via GRU. */
-	*(vuip)GRU_INT_CLEAR = 1 << (irq - 16); mb();
+	*(vuip)GRU_INT_CLEAR = 1 << (d->irq - 16); mb();
 	*(vuip)GRU_INT_CLEAR = 0; mb();
 }
  
 static void
-alcor_isa_mask_and_ack_irq(unsigned int irq)
+alcor_isa_mask_and_ack_irq(struct irq_data *d)
 {
-	i8259a_mask_and_ack_irq(irq);
+	i8259a_mask_and_ack_irq(d);
  
 	/* On ALCOR/XLT, need to dismiss interrupt via GRU. */
 	*(vuip)GRU_INT_CLEAR = 0x80000000; mb();
@@ -77,9 +77,9 @@
  
 static struct irq_chip alcor_irq_type = {
 	.name		= "ALCOR",
-	.unmask		= alcor_enable_irq,
-	.mask		= alcor_disable_irq,
-	.mask_ack	= alcor_mask_and_ack_irq,
+	.irq_unmask	= alcor_enable_irq,
+	.irq_mask	= alcor_disable_irq,
+	.irq_mask_ack	= alcor_mask_and_ack_irq,
 };
  
 static void
  
@@ -126,9 +126,9 @@
 		if (i >= 16+20 && i <= 16+30)
 			continue;
 		set_irq_chip_and_handler(i, &alcor_irq_type, handle_level_irq);
-		irq_to_desc(i)->status |= IRQ_LEVEL;
+		irq_set_status_flags(i, IRQ_LEVEL);
 	}
-	i8259a_irq_type.ack = alcor_isa_mask_and_ack_irq;
+	i8259a_irq_type.irq_ack = alcor_isa_mask_and_ack_irq;
  
 	init_i8259a_irqs();
 	common_init_isa_dma();
@@ -63,34 +63,34 @@
  */
  
 static void
-jensen_local_enable(unsigned int irq)
+jensen_local_enable(struct irq_data *d)
 {
 	/* the parport is really hw IRQ 1, silly Jensen.  */
-	if (irq == 7)
-		i8259a_enable_irq(1);
+	if (d->irq == 7)
+		i8259a_enable_irq(d);
 }
  
 static void
-jensen_local_disable(unsigned int irq)
+jensen_local_disable(struct irq_data *d)
 {
 	/* the parport is really hw IRQ 1, silly Jensen.  */
-	if (irq == 7)
-		i8259a_disable_irq(1);
+	if (d->irq == 7)
+		i8259a_disable_irq(d);
 }
  
 static void
-jensen_local_mask_ack(unsigned int irq)
+jensen_local_mask_ack(struct irq_data *d)
 {
 	/* the parport is really hw IRQ 1, silly Jensen.  */
-	if (irq == 7)
-		i8259a_mask_and_ack_irq(1);
+	if (d->irq == 7)
+		i8259a_mask_and_ack_irq(d);
 }
  
 static struct irq_chip jensen_local_irq_type = {
 	.name		= "LOCAL",
-	.unmask		= jensen_local_enable,
-	.mask		= jensen_local_disable,
-	.mask_ack	= jensen_local_mask_ack,
+	.irq_unmask	= jensen_local_enable,
+	.irq_mask	= jensen_local_disable,
+	.irq_mask_ack	= jensen_local_mask_ack,
 };
  
 static void 
@@ -104,10 +104,12 @@
 }
  
 static void
-wildfire_enable_irq(unsigned int irq)
+wildfire_enable_irq(struct irq_data *d)
 {
+	unsigned int irq = d->irq;
+
 	if (irq < 16)
-		i8259a_enable_irq(irq);
+		i8259a_enable_irq(d);
  
 	spin_lock(&wildfire_irq_lock);
 	set_bit(irq, &cached_irq_mask);
  
  
@@ -116,10 +118,12 @@
 }
  
 static void
-wildfire_disable_irq(unsigned int irq)
+wildfire_disable_irq(struct irq_data *d)
 {
+	unsigned int irq = d->irq;
+
 	if (irq < 16)
-		i8259a_disable_irq(irq);
+		i8259a_disable_irq(d);
  
 	spin_lock(&wildfire_irq_lock);
 	clear_bit(irq, &cached_irq_mask);
  
  
@@ -128,10 +132,12 @@
 }
  
 static void
-wildfire_mask_and_ack_irq(unsigned int irq)
+wildfire_mask_and_ack_irq(struct irq_data *d)
 {
+	unsigned int irq = d->irq;
+
 	if (irq < 16)
-		i8259a_mask_and_ack_irq(irq);
+		i8259a_mask_and_ack_irq(d);
  
 	spin_lock(&wildfire_irq_lock);
 	clear_bit(irq, &cached_irq_mask);
@@ -141,9 +147,9 @@
  
 static struct irq_chip wildfire_irq_type = {
 	.name		= "WILDFIRE",
-	.unmask		= wildfire_enable_irq,
-	.mask		= wildfire_disable_irq,
-	.mask_ack	= wildfire_mask_and_ack_irq,
+	.irq_unmask	= wildfire_enable_irq,
+	.irq_mask	= wildfire_disable_irq,
+	.irq_mask_ack	= wildfire_mask_and_ack_irq,
 };
  
 static void __init
  
  
  
  
  
  
@@ -177,21 +183,21 @@
 	for (i = 0; i < 16; ++i) {
 		if (i == 2)
 			continue;
-		irq_to_desc(i+irq_bias)->status |= IRQ_LEVEL;
 		set_irq_chip_and_handler(i+irq_bias, &wildfire_irq_type,
 			handle_level_irq);
+		irq_set_status_flags(i + irq_bias, IRQ_LEVEL);
 	}
  
-	irq_to_desc(36+irq_bias)->status |= IRQ_LEVEL;
 	set_irq_chip_and_handler(36+irq_bias, &wildfire_irq_type,
 		handle_level_irq);
+	irq_set_status_flags(36 + irq_bias, IRQ_LEVEL);
 	for (i = 40; i < 64; ++i) {
-		irq_to_desc(i+irq_bias)->status |= IRQ_LEVEL;
 		set_irq_chip_and_handler(i+irq_bias, &wildfire_irq_type,
 			handle_level_irq);
+		irq_set_status_flags(i + irq_bias, IRQ_LEVEL);
 	}
  
-	setup_irq(32+irq_bias, &isa_enable);	
+	setup_irq(32+irq_bias, &isa_enable);
 }
  
 static void __init
...	...	@@ -33,10 +33,10 @@
33	33	}
34	34
35	35	inline void
36		-i8259a_enable_irq(unsigned int irq)
	36	+i8259a_enable_irq(struct irq_data *d)
37	37	{
38	38	spin_lock(&i8259_irq_lock);
39		- i8259_update_irq_hw(irq, cached_irq_mask &= ~(1 << irq));
	39	+ i8259_update_irq_hw(d->irq, cached_irq_mask &= ~(1 << d->irq));
40	40	spin_unlock(&i8259_irq_lock);
41	41	}
42	42
43	43
44	44
45	45
...	...	@@ -47,16 +47,18 @@
47	47	}
48	48
49	49	void
50		-i8259a_disable_irq(unsigned int irq)
	50	+i8259a_disable_irq(struct irq_data *d)
51	51	{
52	52	spin_lock(&i8259_irq_lock);
53		- __i8259a_disable_irq(irq);
	53	+ __i8259a_disable_irq(d->irq);
54	54	spin_unlock(&i8259_irq_lock);
55	55	}
56	56
57	57	void
58		-i8259a_mask_and_ack_irq(unsigned int irq)
	58	+i8259a_mask_and_ack_irq(struct irq_data *d)
59	59	{
	60	+ unsigned int irq = d->irq;
	61	+
60	62	spin_lock(&i8259_irq_lock);
61	63	__i8259a_disable_irq(irq);
62	64
...	...	@@ -71,9 +73,9 @@
71	73
72	74	struct irq_chip i8259a_irq_type = {
73	75	.name = "XT-PIC",
74		- .unmask = i8259a_enable_irq,
75		- .mask = i8259a_disable_irq,
76		- .mask_ack = i8259a_mask_and_ack_irq,
	76	+ .irq_unmask = i8259a_enable_irq,
	77	+ .irq_mask = i8259a_disable_irq,
	78	+ .irq_mask_ack = i8259a_mask_and_ack_irq,
77	79	};
78	80
79	81	void __init
...	...	@@ -31,11 +31,9 @@
31	31
32	32	extern void common_init_isa_dma(void);
33	33
34		-extern void i8259a_enable_irq(unsigned int);
35		-extern void i8259a_disable_irq(unsigned int);
36		-extern void i8259a_mask_and_ack_irq(unsigned int);
37		-extern unsigned int i8259a_startup_irq(unsigned int);
38		-extern void i8259a_end_irq(unsigned int);
	34	+extern void i8259a_enable_irq(struct irq_data *d);
	35	+extern void i8259a_disable_irq(struct irq_data *d);
	36	+extern void i8259a_mask_and_ack_irq(struct irq_data *d);
39	37	extern struct irq_chip i8259a_irq_type;
40	38	extern void init_i8259a_irqs(void);
41	39
...	...	@@ -44,31 +44,31 @@
44	44	}
45	45
46	46	static inline void
47		-alcor_enable_irq(unsigned int irq)
	47	+alcor_enable_irq(struct irq_data *d)
48	48	{
49		- alcor_update_irq_hw(cached_irq_mask \|= 1UL << (irq - 16));
	49	+ alcor_update_irq_hw(cached_irq_mask \|= 1UL << (d->irq - 16));
50	50	}
51	51
52	52	static void
53		-alcor_disable_irq(unsigned int irq)
	53	+alcor_disable_irq(struct irq_data *d)
54	54	{
55		- alcor_update_irq_hw(cached_irq_mask &= ~(1UL << (irq - 16)));
	55	+ alcor_update_irq_hw(cached_irq_mask &= ~(1UL << (d->irq - 16)));
56	56	}
57	57
58	58	static void
59		-alcor_mask_and_ack_irq(unsigned int irq)
	59	+alcor_mask_and_ack_irq(struct irq_data *d)
60	60	{
61		- alcor_disable_irq(irq);
	61	+ alcor_disable_irq(d);
62	62
63	63	/* On ALCOR/XLT, need to dismiss interrupt via GRU. */
64		- *(vuip)GRU_INT_CLEAR = 1 << (irq - 16); mb();
	64	+ *(vuip)GRU_INT_CLEAR = 1 << (d->irq - 16); mb();
65	65	*(vuip)GRU_INT_CLEAR = 0; mb();
66	66	}
67	67
68	68	static void
69		-alcor_isa_mask_and_ack_irq(unsigned int irq)
	69	+alcor_isa_mask_and_ack_irq(struct irq_data *d)
70	70	{
71		- i8259a_mask_and_ack_irq(irq);
	71	+ i8259a_mask_and_ack_irq(d);
72	72
73	73	/* On ALCOR/XLT, need to dismiss interrupt via GRU. */
74	74	*(vuip)GRU_INT_CLEAR = 0x80000000; mb();
...	...	@@ -77,9 +77,9 @@
77	77
78	78	static struct irq_chip alcor_irq_type = {
79	79	.name = "ALCOR",
80		- .unmask = alcor_enable_irq,
81		- .mask = alcor_disable_irq,
82		- .mask_ack = alcor_mask_and_ack_irq,
	80	+ .irq_unmask = alcor_enable_irq,
	81	+ .irq_mask = alcor_disable_irq,
	82	+ .irq_mask_ack = alcor_mask_and_ack_irq,
83	83	};
84	84
85	85	static void
86	86
...	...	@@ -126,9 +126,9 @@
126	126	if (i >= 16+20 && i <= 16+30)
127	127	continue;
128	128	set_irq_chip_and_handler(i, &alcor_irq_type, handle_level_irq);
129		- irq_to_desc(i)->status \|= IRQ_LEVEL;
	129	+ irq_set_status_flags(i, IRQ_LEVEL);
130	130	}
131		- i8259a_irq_type.ack = alcor_isa_mask_and_ack_irq;
	131	+ i8259a_irq_type.irq_ack = alcor_isa_mask_and_ack_irq;
132	132
133	133	init_i8259a_irqs();
134	134	common_init_isa_dma();
...	...	@@ -63,34 +63,34 @@
63	63	*/
64	64
65	65	static void
66		-jensen_local_enable(unsigned int irq)
	66	+jensen_local_enable(struct irq_data *d)
67	67	{
68	68	/* the parport is really hw IRQ 1, silly Jensen. */
69		- if (irq == 7)
70		- i8259a_enable_irq(1);
	69	+ if (d->irq == 7)
	70	+ i8259a_enable_irq(d);
71	71	}
72	72
73	73	static void
74		-jensen_local_disable(unsigned int irq)
	74	+jensen_local_disable(struct irq_data *d)
75	75	{
76	76	/* the parport is really hw IRQ 1, silly Jensen. */
77		- if (irq == 7)
78		- i8259a_disable_irq(1);
	77	+ if (d->irq == 7)
	78	+ i8259a_disable_irq(d);
79	79	}
80	80
81	81	static void
82		-jensen_local_mask_ack(unsigned int irq)
	82	+jensen_local_mask_ack(struct irq_data *d)
83	83	{
84	84	/* the parport is really hw IRQ 1, silly Jensen. */
85		- if (irq == 7)
86		- i8259a_mask_and_ack_irq(1);
	85	+ if (d->irq == 7)
	86	+ i8259a_mask_and_ack_irq(d);
87	87	}
88	88
89	89	static struct irq_chip jensen_local_irq_type = {
90	90	.name = "LOCAL",
91		- .unmask = jensen_local_enable,
92		- .mask = jensen_local_disable,
93		- .mask_ack = jensen_local_mask_ack,
	91	+ .irq_unmask = jensen_local_enable,
	92	+ .irq_mask = jensen_local_disable,
	93	+ .irq_mask_ack = jensen_local_mask_ack,
94	94	};
95	95
96	96	static void
...	...	@@ -104,10 +104,12 @@
104	104	}
105	105
106	106	static void
107		-wildfire_enable_irq(unsigned int irq)
	107	+wildfire_enable_irq(struct irq_data *d)
108	108	{
	109	+ unsigned int irq = d->irq;
	110	+
109	111	if (irq < 16)
110		- i8259a_enable_irq(irq);
	112	+ i8259a_enable_irq(d);
111	113
112	114	spin_lock(&wildfire_irq_lock);
113	115	set_bit(irq, &cached_irq_mask);
114	116
115	117
...	...	@@ -116,10 +118,12 @@
116	118	}
117	119
118	120	static void
119		-wildfire_disable_irq(unsigned int irq)
	121	+wildfire_disable_irq(struct irq_data *d)
120	122	{
	123	+ unsigned int irq = d->irq;
	124	+
121	125	if (irq < 16)
122		- i8259a_disable_irq(irq);
	126	+ i8259a_disable_irq(d);
123	127
124	128	spin_lock(&wildfire_irq_lock);
125	129	clear_bit(irq, &cached_irq_mask);
126	130
127	131
...	...	@@ -128,10 +132,12 @@
128	132	}
129	133
130	134	static void
131		-wildfire_mask_and_ack_irq(unsigned int irq)
	135	+wildfire_mask_and_ack_irq(struct irq_data *d)
132	136	{
	137	+ unsigned int irq = d->irq;
	138	+
133	139	if (irq < 16)
134		- i8259a_mask_and_ack_irq(irq);
	140	+ i8259a_mask_and_ack_irq(d);
135	141
136	142	spin_lock(&wildfire_irq_lock);
137	143	clear_bit(irq, &cached_irq_mask);
...	...	@@ -141,9 +147,9 @@
141	147
142	148	static struct irq_chip wildfire_irq_type = {
143	149	.name = "WILDFIRE",
144		- .unmask = wildfire_enable_irq,
145		- .mask = wildfire_disable_irq,
146		- .mask_ack = wildfire_mask_and_ack_irq,
	150	+ .irq_unmask = wildfire_enable_irq,
	151	+ .irq_mask = wildfire_disable_irq,
	152	+ .irq_mask_ack = wildfire_mask_and_ack_irq,
147	153	};
148	154
149	155	static void __init
150	156
151	157
152	158
153	159
154	160
155	161
...	...	@@ -177,21 +183,21 @@
177	183	for (i = 0; i < 16; ++i) {
178	184	if (i == 2)
179	185	continue;
180		- irq_to_desc(i+irq_bias)->status \|= IRQ_LEVEL;
181	186	set_irq_chip_and_handler(i+irq_bias, &wildfire_irq_type,
182	187	handle_level_irq);
	188	+ irq_set_status_flags(i + irq_bias, IRQ_LEVEL);
183	189	}
184	190
185		- irq_to_desc(36+irq_bias)->status \|= IRQ_LEVEL;
186	191	set_irq_chip_and_handler(36+irq_bias, &wildfire_irq_type,
187	192	handle_level_irq);
	193	+ irq_set_status_flags(36 + irq_bias, IRQ_LEVEL);
188	194	for (i = 40; i < 64; ++i) {
189		- irq_to_desc(i+irq_bias)->status \|= IRQ_LEVEL;
190	195	set_irq_chip_and_handler(i+irq_bias, &wildfire_irq_type,
191	196	handle_level_irq);
	197	+ irq_set_status_flags(i + irq_bias, IRQ_LEVEL);
192	198	}
193	199
194		- setup_irq(32+irq_bias, &isa_enable);
	200	+ setup_irq(32+irq_bias, &isa_enable);
195	201	}
196	202
197	203	static void __init