* access to this structure takes a TLB miss it could cause
* the 5-level sparc v9 trap stack to overflow.
*/
-struct irq_work_struct {
- unsigned int irq_worklists[16];
-};
-struct irq_work_struct __irq_work[NR_CPUS];
-#define irq_work(__cpu, __pil) &(__irq_work[(__cpu)].irq_worklists[(__pil)])
+#define irq_work(__cpu) &(trap_block[(__cpu)].irq_worklist)
-static struct irqaction *irq_action[NR_IRQS+1];
+static struct irqaction *irq_action[NR_IRQS];
/* This only synchronizes entities which modify IRQ handler
* state and some selected user-level spots that want to
*/
#define put_ino_in_irqaction(action, irq) \
action->flags &= 0xffffffffffffUL; \
- if (__bucket(irq) == &pil0_dummy_bucket) \
- action->flags |= 0xdeadUL << 48; \
- else \
- action->flags |= __irq_ino(irq) << 48;
+ action->flags |= __irq_ino(irq) << 48;
+
#define get_ino_in_irqaction(action) (action->flags >> 48)
#define put_smpaff_in_irqaction(action, smpaff) (action)->mask = (smpaff)
kstat_cpu(j).irqs[i]);
}
#endif
- seq_printf(p, " %s:%lx", action->name,
- get_ino_in_irqaction(action));
- for (action = action->next; action; action = action->next) {
- seq_printf(p, ", %s:%lx", action->name,
- get_ino_in_irqaction(action));
- }
+ seq_printf(p, " %s", action->name);
+ for (action = action->next; action; action = action->next)
+ seq_printf(p, ", %s", action->name);
seq_putc(p, '\n');
}
out_unlock:
}
}
-/* The timer is the one "weird" interrupt which is generated by
- * the CPU %tick register and not by some normal vectored interrupt
- * source. To handle this special case, we use this dummy INO bucket.
- */
-static struct irq_desc pil0_dummy_desc;
-static struct ino_bucket pil0_dummy_bucket = {
- .irq_info = &pil0_dummy_desc,
-};
-
-static void build_irq_error(const char *msg, unsigned int ino, int pil, int inofixup,
+static void build_irq_error(const char *msg, unsigned int ino, int inofixup,
unsigned long iclr, unsigned long imap,
struct ino_bucket *bucket)
{
- prom_printf("IRQ: INO %04x (%d:%016lx:%016lx) --> "
- "(%d:%d:%016lx:%016lx), halting...\n",
- ino, bucket->pil, bucket->iclr, bucket->imap,
- pil, inofixup, iclr, imap);
+ prom_printf("IRQ: INO %04x (%016lx:%016lx) --> "
+ "(%d:%016lx:%016lx), halting...\n",
+ ino, bucket->iclr, bucket->imap,
+ inofixup, iclr, imap);
prom_halt();
}
-unsigned int build_irq(int pil, int inofixup, unsigned long iclr, unsigned long imap)
+unsigned int build_irq(int inofixup, unsigned long iclr, unsigned long imap)
{
struct ino_bucket *bucket;
int ino;
- if (pil == 0) {
- if (iclr != 0UL || imap != 0UL) {
- prom_printf("Invalid dummy bucket for PIL0 (%lx:%lx)\n",
- iclr, imap);
- prom_halt();
- }
- return __irq(&pil0_dummy_bucket);
- }
-
BUG_ON(tlb_type == hypervisor);
/* RULE: Both must be specified in all other cases. */
if (iclr == 0UL || imap == 0UL) {
- prom_printf("Invalid build_irq %d %d %016lx %016lx\n",
- pil, inofixup, iclr, imap);
+ prom_printf("Invalid build_irq %d %016lx %016lx\n",
+ inofixup, iclr, imap);
prom_halt();
}
ino = (upa_readl(imap) & (IMAP_IGN | IMAP_INO)) + inofixup;
if (ino > NUM_IVECS) {
- prom_printf("Invalid INO %04x (%d:%d:%016lx:%016lx)\n",
- ino, pil, inofixup, iclr, imap);
+ prom_printf("Invalid INO %04x (%d:%016lx:%016lx)\n",
+ ino, inofixup, iclr, imap);
prom_halt();
}
bucket = &ivector_table[ino];
if (bucket->flags & IBF_ACTIVE)
build_irq_error("IRQ: Trying to build active INO bucket.\n",
- ino, pil, inofixup, iclr, imap, bucket);
+ ino, inofixup, iclr, imap, bucket);
if (bucket->irq_info) {
if (bucket->imap != imap || bucket->iclr != iclr)
build_irq_error("IRQ: Trying to reinit INO bucket.\n",
- ino, pil, inofixup, iclr, imap, bucket);
+ ino, inofixup, iclr, imap, bucket);
goto out;
}
*/
bucket->imap = imap;
bucket->iclr = iclr;
- bucket->pil = pil;
bucket->flags = 0;
out:
return __irq(bucket);
}
-unsigned int sun4v_build_irq(u32 devhandle, unsigned int devino, int pil, unsigned char flags)
+unsigned int sun4v_build_irq(u32 devhandle, unsigned int devino, unsigned char flags)
{
struct ino_bucket *bucket;
unsigned long sysino;
bucket->imap = ~0UL - sysino;
bucket->iclr = ~0UL - sysino;
- bucket->pil = pil;
bucket->flags = flags;
bucket->irq_info = kzalloc(sizeof(struct irq_desc), GFP_ATOMIC);
__asm__ __volatile__("rdpr %%pstate, %0" : "=r" (pstate));
__asm__ __volatile__("wrpr %0, %1, %%pstate"
: : "r" (pstate), "i" (PSTATE_IE));
- ent = irq_work(smp_processor_id(), bucket->pil);
+ ent = irq_work(smp_processor_id());
bucket->irq_chain = *ent;
*ent = __irq(bucket);
__asm__ __volatile__("wrpr %0, 0x0, %%pstate" : : "r" (pstate));
static int check_irq_sharing(int pil, unsigned long irqflags)
{
- struct irqaction *action, *tmp;
+ struct irqaction *action;
action = *(irq_action + pil);
if (action) {
- if ((action->flags & SA_SHIRQ) && (irqflags & SA_SHIRQ)) {
- for (tmp = action; tmp->next; tmp = tmp->next)
- ;
- } else {
+ if (!(action->flags & SA_SHIRQ) || !(irqflags & SA_SHIRQ))
return -EBUSY;
- }
}
return 0;
}
if (unlikely(!bucket->irq_info))
return -ENODEV;
- if ((bucket != &pil0_dummy_bucket) && (irqflags & SA_SAMPLE_RANDOM)) {
+ if (irqflags & SA_SAMPLE_RANDOM) {
/*
* This function might sleep, we want to call it first,
* outside of the atomic block. In SA_STATIC_ALLOC case,
* installing a new handler, but is this really a problem,
* only the sysadmin is able to do this.
*/
- rand_initialize_irq(irq);
+ rand_initialize_irq(PIL_DEVICE_IRQ);
}
spin_lock_irqsave(&irq_action_lock, flags);
- if (check_irq_sharing(bucket->pil, irqflags)) {
+ if (check_irq_sharing(PIL_DEVICE_IRQ, irqflags)) {
spin_unlock_irqrestore(&irq_action_lock, flags);
return -EBUSY;
}
}
bucket->flags |= IBF_ACTIVE;
- pending = 0;
- if (bucket != &pil0_dummy_bucket) {
- pending = bucket->pending;
- if (pending)
- bucket->pending = 0;
- }
+ pending = bucket->pending;
+ if (pending)
+ bucket->pending = 0;
action->handler = handler;
action->flags = irqflags;
put_ino_in_irqaction(action, irq);
put_smpaff_in_irqaction(action, CPU_MASK_NONE);
- append_irq_action(bucket->pil, action);
+ append_irq_action(PIL_DEVICE_IRQ, action);
enable_irq(irq);
/* We ate the IVEC already, this makes sure it does not get lost. */
if (pending) {
atomic_bucket_insert(bucket);
- set_softint(1 << bucket->pil);
+ set_softint(1 << PIL_DEVICE_IRQ);
}
spin_unlock_irqrestore(&irq_action_lock, flags);
- if (bucket != &pil0_dummy_bucket)
- register_irq_proc(__irq_ino(irq));
+ register_irq_proc(__irq_ino(irq));
#ifdef CONFIG_SMP
distribute_irqs();
static struct irqaction *unlink_irq_action(unsigned int irq, void *dev_id)
{
- struct ino_bucket *bucket = __bucket(irq);
struct irqaction *action, **pp;
- pp = irq_action + bucket->pil;
+ pp = irq_action + PIL_DEVICE_IRQ;
action = *pp;
if (unlikely(!action))
return NULL;
if (unlikely(!action->handler)) {
- printk("Freeing free IRQ %d\n", bucket->pil);
+ printk("Freeing free IRQ %d\n", PIL_DEVICE_IRQ);
return NULL;
}
{
struct irqaction *action;
struct ino_bucket *bucket;
+ struct irq_desc *desc;
unsigned long flags;
+ int ent, i;
spin_lock_irqsave(&irq_action_lock, flags);
spin_lock_irqsave(&irq_action_lock, flags);
bucket = __bucket(irq);
- if (bucket != &pil0_dummy_bucket) {
- struct irq_desc *desc = bucket->irq_info;
- int ent, i;
+ desc = bucket->irq_info;
- for (i = 0; i < MAX_IRQ_DESC_ACTION; i++) {
- struct irqaction *p = &desc->action[i];
+ for (i = 0; i < MAX_IRQ_DESC_ACTION; i++) {
+ struct irqaction *p = &desc->action[i];
- if (p == action) {
- desc->action_active_mask &= ~(1 << i);
- break;
- }
+ if (p == action) {
+ desc->action_active_mask &= ~(1 << i);
+ break;
}
+ }
- if (!desc->action_active_mask) {
- unsigned long imap = bucket->imap;
+ if (!desc->action_active_mask) {
+ unsigned long imap = bucket->imap;
- /* This unique interrupt source is now inactive. */
- bucket->flags &= ~IBF_ACTIVE;
+ /* This unique interrupt source is now inactive. */
+ bucket->flags &= ~IBF_ACTIVE;
- /* See if any other buckets share this bucket's IMAP
- * and are still active.
- */
- for (ent = 0; ent < NUM_IVECS; ent++) {
- struct ino_bucket *bp = &ivector_table[ent];
- if (bp != bucket &&
- bp->imap == imap &&
- (bp->flags & IBF_ACTIVE) != 0)
- break;
- }
-
- /* Only disable when no other sub-irq levels of
- * the same IMAP are active.
- */
- if (ent == NUM_IVECS)
- disable_irq(irq);
+ /* See if any other buckets share this bucket's IMAP
+ * and are still active.
+ */
+ for (ent = 0; ent < NUM_IVECS; ent++) {
+ struct ino_bucket *bp = &ivector_table[ent];
+ if (bp != bucket &&
+ bp->imap == imap &&
+ (bp->flags & IBF_ACTIVE) != 0)
+ break;
}
+
+ /* Only disable when no other sub-irq levels of
+ * the same IMAP are active.
+ */
+ if (ent == NUM_IVECS)
+ disable_irq(irq);
}
spin_unlock_irqrestore(&irq_action_lock, flags);
}
#endif /* CONFIG_SMP */
-static void process_bucket(int irq, struct ino_bucket *bp, struct pt_regs *regs)
+static void process_bucket(struct ino_bucket *bp, struct pt_regs *regs)
{
struct irq_desc *desc = bp->irq_info;
unsigned char flags = bp->flags;
if (!action_mask)
break;
}
- if (bp->pil != 0) {
- if (tlb_type == hypervisor) {
- unsigned int ino = __irq_ino(bp);
- int err;
- err = sun4v_intr_setstate(ino, HV_INTR_STATE_IDLE);
- if (err != HV_EOK)
- printk("sun4v_intr_setstate(%x): "
- "err(%d)\n", ino, err);
- } else {
- upa_writel(ICLR_IDLE, bp->iclr);
- }
+ if (tlb_type == hypervisor) {
+ unsigned int ino = __irq_ino(bp);
+ int err;
- /* Test and add entropy */
- if (random & SA_SAMPLE_RANDOM)
- add_interrupt_randomness(irq);
+ err = sun4v_intr_setstate(ino, HV_INTR_STATE_IDLE);
+ if (err != HV_EOK)
+ printk("sun4v_intr_setstate(%x): "
+ "err(%d)\n", ino, err);
+ } else {
+ upa_writel(ICLR_IDLE, bp->iclr);
}
+
+ /* Test and add entropy */
+ if (random & SA_SAMPLE_RANDOM)
+ add_interrupt_randomness(PIL_DEVICE_IRQ);
out:
bp->flags &= ~IBF_INPROGRESS;
}
+#ifndef CONFIG_SMP
+extern irqreturn_t timer_interrupt(int, void *, struct pt_regs *);
+
+void timer_irq(int irq, struct pt_regs *regs)
+{
+ unsigned long clr_mask = 1 << irq;
+ unsigned long tick_mask = tick_ops->softint_mask;
+
+ if (get_softint() & tick_mask) {
+ irq = 0;
+ clr_mask = tick_mask;
+ }
+ clear_softint(clr_mask);
+
+ irq_enter();
+ kstat_this_cpu.irqs[irq]++;
+ timer_interrupt(irq, NULL, regs);
+ irq_exit();
+}
+#endif
+
void handler_irq(int irq, struct pt_regs *regs)
{
struct ino_bucket *bp;
int cpu = smp_processor_id();
-#ifndef CONFIG_SMP
- /*
- * Check for TICK_INT on level 14 softint.
+ /* XXX at this point we should be able to assert that
+ * XXX irq is PIL_DEVICE_IRQ...
*/
- {
- unsigned long clr_mask = 1 << irq;
- unsigned long tick_mask = tick_ops->softint_mask;
-
- if ((irq == 14) && (get_softint() & tick_mask)) {
- irq = 0;
- clr_mask = tick_mask;
- }
- clear_softint(clr_mask);
- }
-#else
clear_softint(1 << irq);
-#endif
irq_enter();
- kstat_this_cpu.irqs[irq]++;
/* Sliiiick... */
-#ifndef CONFIG_SMP
- bp = ((irq != 0) ?
- __bucket(xchg32(irq_work(cpu, irq), 0)) :
- &pil0_dummy_bucket);
-#else
- bp = __bucket(xchg32(irq_work(cpu, irq), 0));
-#endif
+ bp = __bucket(xchg32(irq_work(cpu), 0));
while (bp) {
struct ino_bucket *nbp = __bucket(bp->irq_chain);
+ kstat_this_cpu.irqs[bp->virt_irq]++;
+
bp->irq_chain = 0;
- process_bucket(irq, bp, regs);
+ process_bucket(bp, regs);
bp = nbp;
}
irq_exit();
spin_lock_irqsave(&irq_action_lock, flags);
cpu = 0;
- /*
- * Skip the timer at [0], and very rare error/power intrs at [15].
- * Also level [12], it causes problems on Ex000 systems.
- */
for (level = 1; level < NR_IRQS; level++) {
struct irqaction *p = irq_action[level];
- if (level == 12)
- continue;
-
while(p) {
cpu = retarget_one_irq(p, cpu);
p = p->next;
{
int cpu = hard_smp_processor_id();
- memset(__irq_work + cpu, 0, sizeof(struct irq_work_struct));
+ trap_block[cpu].irq_worklist = 0;
}
static void __cpuinit register_one_mondo(unsigned long paddr, unsigned long type)