PageRenderTime 35ms CodeModel.GetById 11ms app.highlight 20ms RepoModel.GetById 1ms app.codeStats 0ms

/arch/sparc/kernel/irq.c

https://bitbucket.org/evzijst/gittest
C | 614 lines | 450 code | 79 blank | 85 comment | 56 complexity | f6d93192cd997be2fbda69162d1d779b MD5 | raw file
  1/*  $Id: irq.c,v 1.114 2001/12/11 04:55:51 davem Exp $
  2 *  arch/sparc/kernel/irq.c:  Interrupt request handling routines. On the
  3 *                            Sparc the IRQ's are basically 'cast in stone'
  4 *                            and you are supposed to probe the prom's device
  5 *                            node trees to find out who's got which IRQ.
  6 *
  7 *  Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
  8 *  Copyright (C) 1995 Miguel de Icaza (miguel@nuclecu.unam.mx)
  9 *  Copyright (C) 1995,2002 Pete A. Zaitcev (zaitcev@yahoo.com)
 10 *  Copyright (C) 1996 Dave Redman (djhr@tadpole.co.uk)
 11 *  Copyright (C) 1998-2000 Anton Blanchard (anton@samba.org)
 12 */
 13
 14#include <linux/config.h>
 15#include <linux/module.h>
 16#include <linux/sched.h>
 17#include <linux/ptrace.h>
 18#include <linux/errno.h>
 19#include <linux/linkage.h>
 20#include <linux/kernel_stat.h>
 21#include <linux/signal.h>
 22#include <linux/sched.h>
 23#include <linux/interrupt.h>
 24#include <linux/slab.h>
 25#include <linux/random.h>
 26#include <linux/init.h>
 27#include <linux/smp.h>
 28#include <linux/smp_lock.h>
 29#include <linux/delay.h>
 30#include <linux/threads.h>
 31#include <linux/spinlock.h>
 32#include <linux/seq_file.h>
 33
 34#include <asm/ptrace.h>
 35#include <asm/processor.h>
 36#include <asm/system.h>
 37#include <asm/psr.h>
 38#include <asm/smp.h>
 39#include <asm/vaddrs.h>
 40#include <asm/timer.h>
 41#include <asm/openprom.h>
 42#include <asm/oplib.h>
 43#include <asm/traps.h>
 44#include <asm/irq.h>
 45#include <asm/io.h>
 46#include <asm/pgalloc.h>
 47#include <asm/pgtable.h>
 48#include <asm/pcic.h>
 49#include <asm/cacheflush.h>
 50
 51#ifdef CONFIG_SMP
 52#define SMP_NOP2 "nop; nop;\n\t"
 53#define SMP_NOP3 "nop; nop; nop;\n\t"
 54#else
 55#define SMP_NOP2
 56#define SMP_NOP3
 57#endif /* SMP */
 58unsigned long __local_irq_save(void)
 59{
 60	unsigned long retval;
 61	unsigned long tmp;
 62
 63	__asm__ __volatile__(
 64		"rd	%%psr, %0\n\t"
 65		SMP_NOP3	/* Sun4m + Cypress + SMP bug */
 66		"or	%0, %2, %1\n\t"
 67		"wr	%1, 0, %%psr\n\t"
 68		"nop; nop; nop\n"
 69		: "=&r" (retval), "=r" (tmp)
 70		: "i" (PSR_PIL)
 71		: "memory");
 72
 73	return retval;
 74}
 75
 76void local_irq_enable(void)
 77{
 78	unsigned long tmp;
 79
 80	__asm__ __volatile__(
 81		"rd	%%psr, %0\n\t"
 82		SMP_NOP3	/* Sun4m + Cypress + SMP bug */
 83		"andn	%0, %1, %0\n\t"
 84		"wr	%0, 0, %%psr\n\t"
 85		"nop; nop; nop\n"
 86		: "=&r" (tmp)
 87		: "i" (PSR_PIL)
 88		: "memory");
 89}
 90
 91void local_irq_restore(unsigned long old_psr)
 92{
 93	unsigned long tmp;
 94
 95	__asm__ __volatile__(
 96		"rd	%%psr, %0\n\t"
 97		"and	%2, %1, %2\n\t"
 98		SMP_NOP2	/* Sun4m + Cypress + SMP bug */
 99		"andn	%0, %1, %0\n\t"
100		"wr	%0, %2, %%psr\n\t"
101		"nop; nop; nop\n"
102		: "=&r" (tmp)
103		: "i" (PSR_PIL), "r" (old_psr)
104		: "memory");
105}
106
107EXPORT_SYMBOL(__local_irq_save);
108EXPORT_SYMBOL(local_irq_enable);
109EXPORT_SYMBOL(local_irq_restore);
110
111/*
112 * Dave Redman (djhr@tadpole.co.uk)
113 *
114 * IRQ numbers.. These are no longer restricted to 15..
115 *
116 * this is done to enable SBUS cards and onboard IO to be masked
117 * correctly. using the interrupt level isn't good enough.
118 *
119 * For example:
120 *   A device interrupting at sbus level6 and the Floppy both come in
121 *   at IRQ11, but enabling and disabling them requires writing to
122 *   different bits in the SLAVIO/SEC.
123 *
124 * As a result of these changes sun4m machines could now support
125 * directed CPU interrupts using the existing enable/disable irq code
126 * with tweaks.
127 *
128 */
129
130static void irq_panic(void)
131{
132    extern char *cputypval;
133    prom_printf("machine: %s doesn't have irq handlers defined!\n",cputypval);
134    prom_halt();
135}
136
137void (*sparc_init_timers)(irqreturn_t (*)(int, void *,struct pt_regs *)) =
138    (void (*)(irqreturn_t (*)(int, void *,struct pt_regs *))) irq_panic;
139
140/*
141 * Dave Redman (djhr@tadpole.co.uk)
142 *
143 * There used to be extern calls and hard coded values here.. very sucky!
144 * instead, because some of the devices attach very early, I do something
145 * equally sucky but at least we'll never try to free statically allocated
146 * space or call kmalloc before kmalloc_init :(.
147 * 
148 * In fact it's the timer10 that attaches first.. then timer14
149 * then kmalloc_init is called.. then the tty interrupts attach.
150 * hmmm....
151 *
152 */
153#define MAX_STATIC_ALLOC	4
154struct irqaction static_irqaction[MAX_STATIC_ALLOC];
155int static_irq_count;
156
157struct irqaction *irq_action[NR_IRQS] = {
158	[0 ... (NR_IRQS-1)] = NULL
159};
160
161/* Used to protect the IRQ action lists */
162DEFINE_SPINLOCK(irq_action_lock);
163
164int show_interrupts(struct seq_file *p, void *v)
165{
166	int i = *(loff_t *) v;
167	struct irqaction * action;
168	unsigned long flags;
169#ifdef CONFIG_SMP
170	int j;
171#endif
172
173	if (sparc_cpu_model == sun4d) {
174		extern int show_sun4d_interrupts(struct seq_file *, void *);
175		
176		return show_sun4d_interrupts(p, v);
177	}
178	spin_lock_irqsave(&irq_action_lock, flags);
179	if (i < NR_IRQS) {
180	        action = *(i + irq_action);
181		if (!action) 
182			goto out_unlock;
183		seq_printf(p, "%3d: ", i);
184#ifndef CONFIG_SMP
185		seq_printf(p, "%10u ", kstat_irqs(i));
186#else
187		for (j = 0; j < NR_CPUS; j++) {
188			if (cpu_online(j))
189				seq_printf(p, "%10u ",
190				    kstat_cpu(cpu_logical_map(j)).irqs[i]);
191		}
192#endif
193		seq_printf(p, " %c %s",
194			(action->flags & SA_INTERRUPT) ? '+' : ' ',
195			action->name);
196		for (action=action->next; action; action = action->next) {
197			seq_printf(p, ",%s %s",
198				(action->flags & SA_INTERRUPT) ? " +" : "",
199				action->name);
200		}
201		seq_putc(p, '\n');
202	}
203out_unlock:
204	spin_unlock_irqrestore(&irq_action_lock, flags);
205	return 0;
206}
207
208void free_irq(unsigned int irq, void *dev_id)
209{
210	struct irqaction * action;
211	struct irqaction * tmp = NULL;
212        unsigned long flags;
213	unsigned int cpu_irq;
214	
215	if (sparc_cpu_model == sun4d) {
216		extern void sun4d_free_irq(unsigned int, void *);
217		
218		sun4d_free_irq(irq, dev_id);
219		return;
220	}
221	cpu_irq = irq & (NR_IRQS - 1);
222        if (cpu_irq > 14) {  /* 14 irq levels on the sparc */
223                printk("Trying to free bogus IRQ %d\n", irq);
224                return;
225        }
226
227	spin_lock_irqsave(&irq_action_lock, flags);
228
229	action = *(cpu_irq + irq_action);
230
231	if (!action->handler) {
232		printk("Trying to free free IRQ%d\n",irq);
233		goto out_unlock;
234	}
235	if (dev_id) {
236		for (; action; action = action->next) {
237			if (action->dev_id == dev_id)
238				break;
239			tmp = action;
240		}
241		if (!action) {
242			printk("Trying to free free shared IRQ%d\n",irq);
243			goto out_unlock;
244		}
245	} else if (action->flags & SA_SHIRQ) {
246		printk("Trying to free shared IRQ%d with NULL device ID\n", irq);
247		goto out_unlock;
248	}
249	if (action->flags & SA_STATIC_ALLOC)
250	{
251		/* This interrupt is marked as specially allocated
252		 * so it is a bad idea to free it.
253		 */
254		printk("Attempt to free statically allocated IRQ%d (%s)\n",
255		       irq, action->name);
256		goto out_unlock;
257	}
258	
259	if (action && tmp)
260		tmp->next = action->next;
261	else
262		*(cpu_irq + irq_action) = action->next;
263
264	spin_unlock_irqrestore(&irq_action_lock, flags);
265
266	synchronize_irq(irq);
267
268	spin_lock_irqsave(&irq_action_lock, flags);
269
270	kfree(action);
271
272	if (!(*(cpu_irq + irq_action)))
273		disable_irq(irq);
274
275out_unlock:
276	spin_unlock_irqrestore(&irq_action_lock, flags);
277}
278
279EXPORT_SYMBOL(free_irq);
280
281/*
282 * This is called when we want to synchronize with
283 * interrupts. We may for example tell a device to
284 * stop sending interrupts: but to make sure there
285 * are no interrupts that are executing on another
286 * CPU we need to call this function.
287 */
288#ifdef CONFIG_SMP
289void synchronize_irq(unsigned int irq)
290{
291	printk("synchronize_irq says: implement me!\n");
292	BUG();
293}
294#endif /* SMP */
295
296void unexpected_irq(int irq, void *dev_id, struct pt_regs * regs)
297{
298        int i;
299	struct irqaction * action;
300	unsigned int cpu_irq;
301	
302	cpu_irq = irq & (NR_IRQS - 1);
303	action = *(cpu_irq + irq_action);
304
305        printk("IO device interrupt, irq = %d\n", irq);
306        printk("PC = %08lx NPC = %08lx FP=%08lx\n", regs->pc, 
307		    regs->npc, regs->u_regs[14]);
308	if (action) {
309		printk("Expecting: ");
310        	for (i = 0; i < 16; i++)
311                	if (action->handler)
312                        	printk("[%s:%d:0x%x] ", action->name,
313				       (int) i, (unsigned int) action->handler);
314	}
315        printk("AIEEE\n");
316	panic("bogus interrupt received");
317}
318
319void handler_irq(int irq, struct pt_regs * regs)
320{
321	struct irqaction * action;
322	int cpu = smp_processor_id();
323#ifdef CONFIG_SMP
324	extern void smp4m_irq_rotate(int cpu);
325#endif
326
327	irq_enter();
328	disable_pil_irq(irq);
329#ifdef CONFIG_SMP
330	/* Only rotate on lower priority IRQ's (scsi, ethernet, etc.). */
331	if(irq < 10)
332		smp4m_irq_rotate(cpu);
333#endif
334	action = *(irq + irq_action);
335	kstat_cpu(cpu).irqs[irq]++;
336	do {
337		if (!action || !action->handler)
338			unexpected_irq(irq, NULL, regs);
339		action->handler(irq, action->dev_id, regs);
340		action = action->next;
341	} while (action);
342	enable_pil_irq(irq);
343	irq_exit();
344}
345
346#ifdef CONFIG_BLK_DEV_FD
347extern void floppy_interrupt(int irq, void *dev_id, struct pt_regs *regs);
348
349void sparc_floppy_irq(int irq, void *dev_id, struct pt_regs *regs)
350{
351	int cpu = smp_processor_id();
352
353	disable_pil_irq(irq);
354	irq_enter();
355	kstat_cpu(cpu).irqs[irq]++;
356	floppy_interrupt(irq, dev_id, regs);
357	irq_exit();
358	enable_pil_irq(irq);
359	// XXX Eek, it's totally changed with preempt_count() and such
360	// if (softirq_pending(cpu))
361	//	do_softirq();
362}
363#endif
364
365/* Fast IRQ's on the Sparc can only have one routine attached to them,
366 * thus no sharing possible.
367 */
368int request_fast_irq(unsigned int irq,
369		     irqreturn_t (*handler)(int, void *, struct pt_regs *),
370		     unsigned long irqflags, const char *devname)
371{
372	struct irqaction *action;
373	unsigned long flags;
374	unsigned int cpu_irq;
375	int ret;
376#ifdef CONFIG_SMP
377	struct tt_entry *trap_table;
378	extern struct tt_entry trapbase_cpu1, trapbase_cpu2, trapbase_cpu3;
379#endif
380	
381	cpu_irq = irq & (NR_IRQS - 1);
382	if(cpu_irq > 14) {
383		ret = -EINVAL;
384		goto out;
385	}
386	if(!handler) {
387		ret = -EINVAL;
388		goto out;
389	}
390
391	spin_lock_irqsave(&irq_action_lock, flags);
392
393	action = *(cpu_irq + irq_action);
394	if(action) {
395		if(action->flags & SA_SHIRQ)
396			panic("Trying to register fast irq when already shared.\n");
397		if(irqflags & SA_SHIRQ)
398			panic("Trying to register fast irq as shared.\n");
399
400		/* Anyway, someone already owns it so cannot be made fast. */
401		printk("request_fast_irq: Trying to register yet already owned.\n");
402		ret = -EBUSY;
403		goto out_unlock;
404	}
405
406	/* If this is flagged as statically allocated then we use our
407	 * private struct which is never freed.
408	 */
409	if (irqflags & SA_STATIC_ALLOC) {
410	    if (static_irq_count < MAX_STATIC_ALLOC)
411		action = &static_irqaction[static_irq_count++];
412	    else
413		printk("Fast IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n",
414		       irq, devname);
415	}
416	
417	if (action == NULL)
418	    action = (struct irqaction *)kmalloc(sizeof(struct irqaction),
419						 GFP_ATOMIC);
420	
421	if (!action) { 
422		ret = -ENOMEM;
423		goto out_unlock;
424	}
425
426	/* Dork with trap table if we get this far. */
427#define INSTANTIATE(table) \
428	table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_one = SPARC_RD_PSR_L0; \
429	table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two = \
430		SPARC_BRANCH((unsigned long) handler, \
431			     (unsigned long) &table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_two);\
432	table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_three = SPARC_RD_WIM_L3; \
433	table[SP_TRAP_IRQ1+(cpu_irq-1)].inst_four = SPARC_NOP;
434
435	INSTANTIATE(sparc_ttable)
436#ifdef CONFIG_SMP
437	trap_table = &trapbase_cpu1; INSTANTIATE(trap_table)
438	trap_table = &trapbase_cpu2; INSTANTIATE(trap_table)
439	trap_table = &trapbase_cpu3; INSTANTIATE(trap_table)
440#endif
441#undef INSTANTIATE
442	/*
443	 * XXX Correct thing whould be to flush only I- and D-cache lines
444	 * which contain the handler in question. But as of time of the
445	 * writing we have no CPU-neutral interface to fine-grained flushes.
446	 */
447	flush_cache_all();
448
449	action->handler = handler;
450	action->flags = irqflags;
451	cpus_clear(action->mask);
452	action->name = devname;
453	action->dev_id = NULL;
454	action->next = NULL;
455
456	*(cpu_irq + irq_action) = action;
457
458	enable_irq(irq);
459
460	ret = 0;
461out_unlock:
462	spin_unlock_irqrestore(&irq_action_lock, flags);
463out:
464	return ret;
465}
466
467int request_irq(unsigned int irq,
468		irqreturn_t (*handler)(int, void *, struct pt_regs *),
469		unsigned long irqflags, const char * devname, void *dev_id)
470{
471	struct irqaction * action, *tmp = NULL;
472	unsigned long flags;
473	unsigned int cpu_irq;
474	int ret;
475	
476	if (sparc_cpu_model == sun4d) {
477		extern int sun4d_request_irq(unsigned int, 
478					     irqreturn_t (*)(int, void *, struct pt_regs *),
479					     unsigned long, const char *, void *);
480		return sun4d_request_irq(irq, handler, irqflags, devname, dev_id);
481	}
482	cpu_irq = irq & (NR_IRQS - 1);
483	if(cpu_irq > 14) {
484		ret = -EINVAL;
485		goto out;
486	}
487	if (!handler) {
488		ret = -EINVAL;
489		goto out;
490	}
491	    
492	spin_lock_irqsave(&irq_action_lock, flags);
493
494	action = *(cpu_irq + irq_action);
495	if (action) {
496		if ((action->flags & SA_SHIRQ) && (irqflags & SA_SHIRQ)) {
497			for (tmp = action; tmp->next; tmp = tmp->next);
498		} else {
499			ret = -EBUSY;
500			goto out_unlock;
501		}
502		if ((action->flags & SA_INTERRUPT) ^ (irqflags & SA_INTERRUPT)) {
503			printk("Attempt to mix fast and slow interrupts on IRQ%d denied\n", irq);
504			ret = -EBUSY;
505			goto out_unlock;
506		}   
507		action = NULL;		/* Or else! */
508	}
509
510	/* If this is flagged as statically allocated then we use our
511	 * private struct which is never freed.
512	 */
513	if (irqflags & SA_STATIC_ALLOC) {
514		if (static_irq_count < MAX_STATIC_ALLOC)
515			action = &static_irqaction[static_irq_count++];
516		else
517			printk("Request for IRQ%d (%s) SA_STATIC_ALLOC failed using kmalloc\n", irq, devname);
518	}
519	
520	if (action == NULL)
521		action = (struct irqaction *)kmalloc(sizeof(struct irqaction),
522						     GFP_ATOMIC);
523	
524	if (!action) { 
525		ret = -ENOMEM;
526		goto out_unlock;
527	}
528
529	action->handler = handler;
530	action->flags = irqflags;
531	cpus_clear(action->mask);
532	action->name = devname;
533	action->next = NULL;
534	action->dev_id = dev_id;
535
536	if (tmp)
537		tmp->next = action;
538	else
539		*(cpu_irq + irq_action) = action;
540
541	enable_irq(irq);
542
543	ret = 0;
544out_unlock:
545	spin_unlock_irqrestore(&irq_action_lock, flags);
546out:
547	return ret;
548}
549
550EXPORT_SYMBOL(request_irq);
551
552/* We really don't need these at all on the Sparc.  We only have
553 * stubs here because they are exported to modules.
554 */
555unsigned long probe_irq_on(void)
556{
557	return 0;
558}
559
560EXPORT_SYMBOL(probe_irq_on);
561
562int probe_irq_off(unsigned long mask)
563{
564	return 0;
565}
566
567EXPORT_SYMBOL(probe_irq_off);
568
569/* djhr
570 * This could probably be made indirect too and assigned in the CPU
571 * bits of the code. That would be much nicer I think and would also
572 * fit in with the idea of being able to tune your kernel for your machine
573 * by removing unrequired machine and device support.
574 *
575 */
576
577void __init init_IRQ(void)
578{
579	extern void sun4c_init_IRQ( void );
580	extern void sun4m_init_IRQ( void );
581	extern void sun4d_init_IRQ( void );
582
583	switch(sparc_cpu_model) {
584	case sun4c:
585	case sun4:
586		sun4c_init_IRQ();
587		break;
588
589	case sun4m:
590#ifdef CONFIG_PCI
591		pcic_probe();
592		if (pcic_present()) {
593			sun4m_pci_init_IRQ();
594			break;
595		}
596#endif
597		sun4m_init_IRQ();
598		break;
599		
600	case sun4d:
601		sun4d_init_IRQ();
602		break;
603
604	default:
605		prom_printf("Cannot initialize IRQ's on this Sun machine...");
606		break;
607	}
608	btfixup();
609}
610
611void init_irq_proc(void)
612{
613	/* For now, nothing... */
614}