ppc64: remove ppc_irq_dispatch_handler

Use __do_IRQ instead. The only difference is that every controller is now assumed to have an end() routine (only xics_8259 did not). Signed-off-by: Stephen Rothwell <sfr@canb.auug.org.au>

ppc64: remove ppc_irq_dispatch_handler
Use __do_IRQ instead. The only difference is that every controller is now assumed to have an end() routine (only xics_8259 did not). Signed-off-by: Stephen Rothwell <sfr@canb.auug.org.au>
Stephen Rothwell
1 parent 5a7b3ff467
Showing 7 changed files with 12 additions and 118 deletions Side-by-side Diff
arch/powerpc/kernel/misc_64.S
arch/powerpc/platforms/iseries/irq.c
arch/powerpc/platforms/pseries/xics.c
arch/ppc64/kernel/irq.c
arch/ppc64/kernel/misc.S
include/asm-powerpc/hw_irq.h
include/asm-powerpc/irq.h
@@ -89,12 +89,12 @@
 	mtlr	r0
 	blr
  
-_GLOBAL(call_ppc_irq_dispatch_handler)
+_GLOBAL(call___do_IRQ)
 	mflr	r0
 	std	r0,16(r1)
 	stdu	r1,THREAD_SIZE-112(r5)
 	mr	r1,r5
-	bl	.ppc_irq_dispatch_handler
+	bl	.__do_IRQ
 	ld	r1,0(r1)
 	ld	r0,16(r1)
 	mtlr	r0
@@ -120,13 +120,13 @@
 		if (curtp != irqtp) {
 			irqtp->task = curtp->task;
 			irqtp->flags = 0;
-			call_ppc_irq_dispatch_handler(regsParm, irq, irqtp);
+			call___do_IRQ(irq, regsParm, irqtp);
 			irqtp->task = NULL;
 			if (irqtp->flags)
 				set_bits(irqtp->flags, &curtp->flags);
 		} else
 #endif
-			ppc_irq_dispatch_handler(regsParm, irq);
+			__do_IRQ(irq, regsParm);
 		HvCallPci_eoi(eventParm->eventData.slotInterrupt.busNumber,
 			eventParm->eventData.slotInterrupt.subBusNumber,
 			eventParm->eventData.slotInterrupt.deviceId);
@@ -326,10 +326,8 @@
 }
  
 /*
- * Need to define this so ppc_irq_dispatch_handler will NOT call
- * enable_IRQ at the end of interrupt handling.  However, this does
- * nothing because there is not enough information provided to do
- * the EOI HvCall.  This is done by XmPciLpEvent.c
+ * This does nothing because there is not enough information
+ * provided to do the EOI HvCall.  This is done by XmPciLpEvent.c
  */
 static void iSeries_end_IRQ(unsigned int irq)
 {
@@ -567,6 +567,7 @@
  
 	xics_8259_pic.enable = i8259_pic.enable;
 	xics_8259_pic.disable = i8259_pic.disable;
+	xics_8259_pic.end = i8259_pic.end;
 	for (i = 0; i < 16; ++i)
 		get_irq_desc(i)->handler = &xics_8259_pic;
 	for (; i < NR_IRQS; ++i)
@@ -144,110 +144,6 @@
 }
 #endif
  
-extern int noirqdebug;
-
-/*
- * Eventually, this should take an array of interrupts and an array size
- * so it can dispatch multiple interrupts.
- */
-void ppc_irq_dispatch_handler(struct pt_regs *regs, int irq)
-{
-	int status;
-	struct irqaction *action;
-	int cpu = smp_processor_id();
-	irq_desc_t *desc = get_irq_desc(irq);
-	irqreturn_t action_ret;
-
-	kstat_cpu(cpu).irqs[irq]++;
-
-	if (desc->status & IRQ_PER_CPU) {
-		/* no locking required for CPU-local interrupts: */
-		ack_irq(irq);
-		action_ret = handle_IRQ_event(irq, regs, desc->action);
-		desc->handler->end(irq);
-		return;
-	}
-
-	spin_lock(&desc->lock);
-	ack_irq(irq);	
-	/*
-	   REPLAY is when Linux resends an IRQ that was dropped earlier
-	   WAITING is used by probe to mark irqs that are being tested
-	   */
-	status = desc->status & ~(IRQ_REPLAY | IRQ_WAITING);
-	status |= IRQ_PENDING; /* we _want_ to handle it */
-
-	/*
-	 * If the IRQ is disabled for whatever reason, we cannot
-	 * use the action we have.
-	 */
-	action = NULL;
-	if (likely(!(status & (IRQ_DISABLED | IRQ_INPROGRESS)))) {
-		action = desc->action;
-		if (!action || !action->handler) {
-			ppc_spurious_interrupts++;
-			printk(KERN_DEBUG "Unhandled interrupt %x, disabled\n", irq);
-			/* We can't call disable_irq here, it would deadlock */
-			if (!desc->depth)
-				desc->depth = 1;
-			desc->status |= IRQ_DISABLED;
-			/* This is not a real spurrious interrupt, we
-			 * have to eoi it, so we jump to out
-			 */
-			mask_irq(irq);
-			goto out;
-		}
-		status &= ~IRQ_PENDING; /* we commit to handling */
-		status |= IRQ_INPROGRESS; /* we are handling it */
-	}
-	desc->status = status;
-
-	/*
-	 * If there is no IRQ handler or it was disabled, exit early.
-	   Since we set PENDING, if another processor is handling
-	   a different instance of this same irq, the other processor
-	   will take care of it.
-	 */
-	if (unlikely(!action))
-		goto out;
-
-	/*
-	 * Edge triggered interrupts need to remember
-	 * pending events.
-	 * This applies to any hw interrupts that allow a second
-	 * instance of the same irq to arrive while we are in do_IRQ
-	 * or in the handler. But the code here only handles the _second_
-	 * instance of the irq, not the third or fourth. So it is mostly
-	 * useful for irq hardware that does not mask cleanly in an
-	 * SMP environment.
-	 */
-	for (;;) {
-		spin_unlock(&desc->lock);
-
-		action_ret = handle_IRQ_event(irq, regs, action);
-
-		spin_lock(&desc->lock);
-		if (!noirqdebug)
-			note_interrupt(irq, desc, action_ret, regs);
-		if (likely(!(desc->status & IRQ_PENDING)))
-			break;
-		desc->status &= ~IRQ_PENDING;
-	}
-out:
-	desc->status &= ~IRQ_INPROGRESS;
-	/*
-	 * The ->end() handler has to deal with interrupts which got
-	 * disabled while the handler was running.
-	 */
-	if (desc->handler) {
-		if (desc->handler->end)
-			desc->handler->end(irq);
-		else if (desc->handler->enable)
-			desc->handler->enable(irq);
-	}
-	spin_unlock(&desc->lock);
-}
-
 #ifdef CONFIG_PPC_ISERIES
 void do_IRQ(struct pt_regs *regs)
 {
  
@@ -325,13 +221,13 @@
 		if (curtp != irqtp) {
 			irqtp->task = curtp->task;
 			irqtp->flags = 0;
-			call_ppc_irq_dispatch_handler(regs, irq, irqtp);
+			call___do_IRQ(irq, regs, irqtp);
 			irqtp->task = NULL;
 			if (irqtp->flags)
 				set_bits(irqtp->flags, &curtp->flags);
 		} else
 #endif
-			ppc_irq_dispatch_handler(regs, irq);
+			__do_IRQ(irq, regs);
 	} else
 		/* That's not SMP safe ... but who cares ? */
 		ppc_spurious_interrupts++;
@@ -78,12 +78,12 @@
 	mtlr	r0
 	blr
  
-_GLOBAL(call_ppc_irq_dispatch_handler)
+_GLOBAL(call___do_IRQ)
 	mflr	r0
 	std	r0,16(r1)
 	stdu	r1,THREAD_SIZE-112(r5)
 	mr	r1,r5
-	bl	.ppc_irq_dispatch_handler
+	bl	.__do_IRQ
 	ld	r1,0(r1)
 	ld	r0,16(r1)
 	mtlr	r0
@@ -12,7 +12,6 @@
 #include <asm/processor.h>
  
 extern void timer_interrupt(struct pt_regs *);
-extern void ppc_irq_dispatch_handler(struct pt_regs *regs, int irq);
  
 #ifdef CONFIG_PPC_ISERIES
  
@@ -488,7 +488,7 @@
  
 extern void irq_ctx_init(void);
 extern void call_do_softirq(struct thread_info *tp);
-extern int call_ppc_irq_dispatch_handler(struct pt_regs *regs, int irq,
+extern int call___do_IRQ(int irq, struct pt_regs *regs,
 		struct thread_info *tp);
  
 #define __ARCH_HAS_DO_SOFTIRQ
...	...	@@ -89,12 +89,12 @@
89	89	mtlr r0
90	90	blr
91	91
92		-_GLOBAL(call_ppc_irq_dispatch_handler)
	92	+_GLOBAL(call___do_IRQ)
93	93	mflr r0
94	94	std r0,16(r1)
95	95	stdu r1,THREAD_SIZE-112(r5)
96	96	mr r1,r5
97		- bl .ppc_irq_dispatch_handler
	97	+ bl .__do_IRQ
98	98	ld r1,0(r1)
99	99	ld r0,16(r1)
100	100	mtlr r0
...	...	@@ -120,13 +120,13 @@
120	120	if (curtp != irqtp) {
121	121	irqtp->task = curtp->task;
122	122	irqtp->flags = 0;
123		- call_ppc_irq_dispatch_handler(regsParm, irq, irqtp);
	123	+ call___do_IRQ(irq, regsParm, irqtp);
124	124	irqtp->task = NULL;
125	125	if (irqtp->flags)
126	126	set_bits(irqtp->flags, &curtp->flags);
127	127	} else
128	128	#endif
129		- ppc_irq_dispatch_handler(regsParm, irq);
	129	+ __do_IRQ(irq, regsParm);
130	130	HvCallPci_eoi(eventParm->eventData.slotInterrupt.busNumber,
131	131	eventParm->eventData.slotInterrupt.subBusNumber,
132	132	eventParm->eventData.slotInterrupt.deviceId);
...	...	@@ -326,10 +326,8 @@
326	326	}
327	327
328	328	/*
329		- * Need to define this so ppc_irq_dispatch_handler will NOT call
330		- * enable_IRQ at the end of interrupt handling. However, this does
331		- * nothing because there is not enough information provided to do
332		- * the EOI HvCall. This is done by XmPciLpEvent.c
	329	+ * This does nothing because there is not enough information
	330	+ * provided to do the EOI HvCall. This is done by XmPciLpEvent.c
333	331	*/
334	332	static void iSeries_end_IRQ(unsigned int irq)
335	333	{
...	...	@@ -567,6 +567,7 @@
567	567
568	568	xics_8259_pic.enable = i8259_pic.enable;
569	569	xics_8259_pic.disable = i8259_pic.disable;
	570	+ xics_8259_pic.end = i8259_pic.end;
570	571	for (i = 0; i < 16; ++i)
571	572	get_irq_desc(i)->handler = &xics_8259_pic;
572	573	for (; i < NR_IRQS; ++i)
...	...	@@ -144,110 +144,6 @@
144	144	}
145	145	#endif
146	146
147		-extern int noirqdebug;
148		-
149		-/*
150		- * Eventually, this should take an array of interrupts and an array size
151		- * so it can dispatch multiple interrupts.
152		- */
153		-void ppc_irq_dispatch_handler(struct pt_regs *regs, int irq)
154		-{
155		- int status;
156		- struct irqaction *action;
157		- int cpu = smp_processor_id();
158		- irq_desc_t *desc = get_irq_desc(irq);
159		- irqreturn_t action_ret;
160		-
161		- kstat_cpu(cpu).irqs[irq]++;
162		-
163		- if (desc->status & IRQ_PER_CPU) {
164		- /* no locking required for CPU-local interrupts: */
165		- ack_irq(irq);
166		- action_ret = handle_IRQ_event(irq, regs, desc->action);
167		- desc->handler->end(irq);
168		- return;
169		- }
170		-
171		- spin_lock(&desc->lock);
172		- ack_irq(irq);
173		- /*
174		- REPLAY is when Linux resends an IRQ that was dropped earlier
175		- WAITING is used by probe to mark irqs that are being tested
176		- */
177		- status = desc->status & ~(IRQ_REPLAY \| IRQ_WAITING);
178		- status \|= IRQ_PENDING; /* we _want_ to handle it */
179		-
180		- /*
181		- * If the IRQ is disabled for whatever reason, we cannot
182		- * use the action we have.
183		- */
184		- action = NULL;
185		- if (likely(!(status & (IRQ_DISABLED \| IRQ_INPROGRESS)))) {
186		- action = desc->action;
187		- if (!action \|\| !action->handler) {
188		- ppc_spurious_interrupts++;
189		- printk(KERN_DEBUG "Unhandled interrupt %x, disabled\n", irq);
190		- /* We can't call disable_irq here, it would deadlock */
191		- if (!desc->depth)
192		- desc->depth = 1;
193		- desc->status \|= IRQ_DISABLED;
194		- /* This is not a real spurrious interrupt, we
195		- * have to eoi it, so we jump to out
196		- */
197		- mask_irq(irq);
198		- goto out;
199		- }
200		- status &= ~IRQ_PENDING; /* we commit to handling */
201		- status \|= IRQ_INPROGRESS; /* we are handling it */
202		- }
203		- desc->status = status;
204		-
205		- /*
206		- * If there is no IRQ handler or it was disabled, exit early.
207		- Since we set PENDING, if another processor is handling
208		- a different instance of this same irq, the other processor
209		- will take care of it.
210		- */
211		- if (unlikely(!action))
212		- goto out;
213		-
214		- /*
215		- * Edge triggered interrupts need to remember
216		- * pending events.
217		- * This applies to any hw interrupts that allow a second
218		- * instance of the same irq to arrive while we are in do_IRQ
219		- * or in the handler. But the code here only handles the _second_
220		- * instance of the irq, not the third or fourth. So it is mostly
221		- * useful for irq hardware that does not mask cleanly in an
222		- * SMP environment.
223		- */
224		- for (;;) {
225		- spin_unlock(&desc->lock);
226		-
227		- action_ret = handle_IRQ_event(irq, regs, action);
228		-
229		- spin_lock(&desc->lock);
230		- if (!noirqdebug)
231		- note_interrupt(irq, desc, action_ret, regs);
232		- if (likely(!(desc->status & IRQ_PENDING)))
233		- break;
234		- desc->status &= ~IRQ_PENDING;
235		- }
236		-out:
237		- desc->status &= ~IRQ_INPROGRESS;
238		- /*
239		- * The ->end() handler has to deal with interrupts which got
240		- * disabled while the handler was running.
241		- */
242		- if (desc->handler) {
243		- if (desc->handler->end)
244		- desc->handler->end(irq);
245		- else if (desc->handler->enable)
246		- desc->handler->enable(irq);
247		- }
248		- spin_unlock(&desc->lock);
249		-}
250		-
251	147	#ifdef CONFIG_PPC_ISERIES
252	148	void do_IRQ(struct pt_regs *regs)
253	149	{
254	150
...	...	@@ -325,13 +221,13 @@
325	221	if (curtp != irqtp) {
326	222	irqtp->task = curtp->task;
327	223	irqtp->flags = 0;
328		- call_ppc_irq_dispatch_handler(regs, irq, irqtp);
	224	+ call___do_IRQ(irq, regs, irqtp);
329	225	irqtp->task = NULL;
330	226	if (irqtp->flags)
331	227	set_bits(irqtp->flags, &curtp->flags);
332	228	} else
333	229	#endif
334		- ppc_irq_dispatch_handler(regs, irq);
	230	+ __do_IRQ(irq, regs);
335	231	} else
336	232	/* That's not SMP safe ... but who cares ? */
337	233	ppc_spurious_interrupts++;
...	...	@@ -78,12 +78,12 @@
78	78	mtlr r0
79	79	blr
80	80
81		-_GLOBAL(call_ppc_irq_dispatch_handler)
	81	+_GLOBAL(call___do_IRQ)
82	82	mflr r0
83	83	std r0,16(r1)
84	84	stdu r1,THREAD_SIZE-112(r5)
85	85	mr r1,r5
86		- bl .ppc_irq_dispatch_handler
	86	+ bl .__do_IRQ
87	87	ld r1,0(r1)
88	88	ld r0,16(r1)
89	89	mtlr r0
...	...	@@ -12,7 +12,6 @@
12	12	#include <asm/processor.h>
13	13
14	14	extern void timer_interrupt(struct pt_regs *);
15		-extern void ppc_irq_dispatch_handler(struct pt_regs *regs, int irq);
16	15
17	16	#ifdef CONFIG_PPC_ISERIES
18	17
...	...	@@ -488,7 +488,7 @@
488	488
489	489	extern void irq_ctx_init(void);
490	490	extern void call_do_softirq(struct thread_info *tp);
491		-extern int call_ppc_irq_dispatch_handler(struct pt_regs *regs, int irq,
	491	+extern int call___do_IRQ(int irq, struct pt_regs *regs,
492	492	struct thread_info *tp);
493	493
494	494	#define __ARCH_HAS_DO_SOFTIRQ