1 files changed, 282 insertions, 35 deletions

diff --git a/arch/ia64/kernel/irq_ia64.c b/arch/ia64/kernel/irq_ia64.c
index bc47049f060f..91797c111162 100644
--- a/arch/ia64/kernel/irq_ia64.c
+++ b/arch/ia64/kernel/irq_ia64.c
@@ -46,6 +46,12 @@
 
 #define IRQ_DEBUG       0
 
+#define IRQ_VECTOR_UNASSIGNED   (0)
+
+#define IRQ_UNUSED              (0)
+#define IRQ_USED                (1)
+#define IRQ_RSVD                (2)
+
 /* These can be overridden in platform_irq_init */
 int ia64_first_device_vector = IA64_DEF_FIRST_DEVICE_VECTOR;
 int ia64_last_device_vector = IA64_DEF_LAST_DEVICE_VECTOR;
@@ -54,6 +60,8 @@ int ia64_last_device_vector = IA64_DEF_LAST_DEVICE_VECTOR;
 void __iomem *ipi_base_addr = ((void __iomem *)
                                (__IA64_UNCACHED_OFFSET | IA64_IPI_DEFAULT_BASE_ADDR));
 
+static cpumask_t vector_allocation_domain(int cpu);
+
 /*
  * Legacy IRQ to IA-64 vector translation table.
  */
@@ -64,46 +72,269 @@ __u8 isa_irq_to_vector_map[16] = {
 };
 EXPORT_SYMBOL(isa_irq_to_vector_map);
 
-static unsigned long ia64_vector_mask[BITS_TO_LONGS(IA64_MAX_DEVICE_VECTORS)];
+DEFINE_SPINLOCK(vector_lock);
+
+struct irq_cfg irq_cfg[NR_IRQS] __read_mostly = {
+        [0 ... NR_IRQS - 1] = {
+                .vector = IRQ_VECTOR_UNASSIGNED,
+                .domain = CPU_MASK_NONE
+        }
+};
+
+DEFINE_PER_CPU(int[IA64_NUM_VECTORS], vector_irq) = {
+        [0 ... IA64_NUM_VECTORS - 1] = IA64_SPURIOUS_INT_VECTOR
+};
+
+static cpumask_t vector_table[IA64_MAX_DEVICE_VECTORS] = {
+        [0 ... IA64_MAX_DEVICE_VECTORS - 1] = CPU_MASK_NONE
+};
+
+static int irq_status[NR_IRQS] = {
+        [0 ... NR_IRQS -1] = IRQ_UNUSED
+};
+
+int check_irq_used(int irq)
+{
+        if (irq_status[irq] == IRQ_USED)
+                return 1;
+
+        return -1;
+}
+
+static void reserve_irq(unsigned int irq)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&vector_lock, flags);
+        irq_status[irq] = IRQ_RSVD;
+        spin_unlock_irqrestore(&vector_lock, flags);
+}
+
+static inline int find_unassigned_irq(void)
+{
+        int irq;
+
+        for (irq = IA64_FIRST_DEVICE_VECTOR; irq < NR_IRQS; irq++)
+                if (irq_status[irq] == IRQ_UNUSED)
+                        return irq;
+        return -ENOSPC;
+}
+
+static inline int find_unassigned_vector(cpumask_t domain)
+{
+        cpumask_t mask;
+        int pos;
+
+        cpus_and(mask, domain, cpu_online_map);
+        if (cpus_empty(mask))
+                return -EINVAL;
+
+        for (pos = 0; pos < IA64_NUM_DEVICE_VECTORS; pos++) {
+                cpus_and(mask, domain, vector_table[pos]);
+                if (!cpus_empty(mask))
+                        continue;
+                return IA64_FIRST_DEVICE_VECTOR + pos;
+        }
+        return -ENOSPC;
+}
+
+static int __bind_irq_vector(int irq, int vector, cpumask_t domain)
+{
+        cpumask_t mask;
+        int cpu, pos;
+        struct irq_cfg *cfg = &irq_cfg[irq];
+
+        cpus_and(mask, domain, cpu_online_map);
+        if (cpus_empty(mask))
+                return -EINVAL;
+        if ((cfg->vector == vector) && cpus_equal(cfg->domain, domain))
+                return 0;
+        if (cfg->vector != IRQ_VECTOR_UNASSIGNED)
+                return -EBUSY;
+        for_each_cpu_mask(cpu, mask)
+                per_cpu(vector_irq, cpu)[vector] = irq;
+        cfg->vector = vector;
+        cfg->domain = domain;
+        irq_status[irq] = IRQ_USED;
+        pos = vector - IA64_FIRST_DEVICE_VECTOR;
+        cpus_or(vector_table[pos], vector_table[pos], domain);
+        return 0;
+}
+
+int bind_irq_vector(int irq, int vector, cpumask_t domain)
+{
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&vector_lock, flags);
+        ret = __bind_irq_vector(irq, vector, domain);
+        spin_unlock_irqrestore(&vector_lock, flags);
+        return ret;
+}
+
+static void __clear_irq_vector(int irq)
+{
+        int vector, cpu, pos;
+        cpumask_t mask;
+        cpumask_t domain;
+        struct irq_cfg *cfg = &irq_cfg[irq];
+
+        BUG_ON((unsigned)irq >= NR_IRQS);
+        BUG_ON(cfg->vector == IRQ_VECTOR_UNASSIGNED);
+        vector = cfg->vector;
+        domain = cfg->domain;
+        cpus_and(mask, cfg->domain, cpu_online_map);
+        for_each_cpu_mask(cpu, mask)
+                per_cpu(vector_irq, cpu)[vector] = IA64_SPURIOUS_INT_VECTOR;
+        cfg->vector = IRQ_VECTOR_UNASSIGNED;
+        cfg->domain = CPU_MASK_NONE;
+        irq_status[irq] = IRQ_UNUSED;
+        pos = vector - IA64_FIRST_DEVICE_VECTOR;
+        cpus_andnot(vector_table[pos], vector_table[pos], domain);
+}
+
+static void clear_irq_vector(int irq)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&vector_lock, flags);
+        __clear_irq_vector(irq);
+        spin_unlock_irqrestore(&vector_lock, flags);
+}
 
 int
 assign_irq_vector (int irq)
 {
-        int pos, vector;
- again:
-        pos = find_first_zero_bit(ia64_vector_mask, IA64_NUM_DEVICE_VECTORS);
-        vector = IA64_FIRST_DEVICE_VECTOR + pos;
-        if (vector > IA64_LAST_DEVICE_VECTOR)
-                return -ENOSPC;
-        if (test_and_set_bit(pos, ia64_vector_mask))
-                goto again;
+        unsigned long flags;
+        int vector, cpu;
+        cpumask_t domain;
+
+        vector = -ENOSPC;
+
+        spin_lock_irqsave(&vector_lock, flags);
+        if (irq < 0) {
+                goto out;
+        }
+        for_each_online_cpu(cpu) {
+                domain = vector_allocation_domain(cpu);
+                vector = find_unassigned_vector(domain);
+                if (vector >= 0)
+                        break;
+        }
+        if (vector < 0)
+                goto out;
+        BUG_ON(__bind_irq_vector(irq, vector, domain));
+ out:
+        spin_unlock_irqrestore(&vector_lock, flags);
         return vector;
 }
 
 void
 free_irq_vector (int vector)
 {
-        int pos;
-
-        if (vector < IA64_FIRST_DEVICE_VECTOR || vector > IA64_LAST_DEVICE_VECTOR)
+        if (vector < IA64_FIRST_DEVICE_VECTOR ||
+            vector > IA64_LAST_DEVICE_VECTOR)
                 return;
-
-        pos = vector - IA64_FIRST_DEVICE_VECTOR;
-        if (!test_and_clear_bit(pos, ia64_vector_mask))
-                printk(KERN_WARNING "%s: double free!\n", __FUNCTION__);
+        clear_irq_vector(vector);
 }
 
 int
 reserve_irq_vector (int vector)
 {
-        int pos;
-
         if (vector < IA64_FIRST_DEVICE_VECTOR ||
             vector > IA64_LAST_DEVICE_VECTOR)
                 return -EINVAL;
+        return !!bind_irq_vector(vector, vector, CPU_MASK_ALL);
+}
 
-        pos = vector - IA64_FIRST_DEVICE_VECTOR;
-        return test_and_set_bit(pos, ia64_vector_mask);
+/*
+ * Initialize vector_irq on a new cpu. This function must be called
+ * with vector_lock held.
+ */
+void __setup_vector_irq(int cpu)
+{
+        int irq, vector;
+
+        /* Clear vector_irq */
+        for (vector = 0; vector < IA64_NUM_VECTORS; ++vector)
+                per_cpu(vector_irq, cpu)[vector] = IA64_SPURIOUS_INT_VECTOR;
+        /* Mark the inuse vectors */
+        for (irq = 0; irq < NR_IRQS; ++irq) {
+                if (!cpu_isset(cpu, irq_cfg[irq].domain))
+                        continue;
+                vector = irq_to_vector(irq);
+                per_cpu(vector_irq, cpu)[vector] = irq;
+        }
+}
+
+#if defined(CONFIG_SMP) && (defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_DIG))
+static enum vector_domain_type {
+        VECTOR_DOMAIN_NONE,
+        VECTOR_DOMAIN_PERCPU
+} vector_domain_type = VECTOR_DOMAIN_NONE;
+
+static cpumask_t vector_allocation_domain(int cpu)
+{
+        if (vector_domain_type == VECTOR_DOMAIN_PERCPU)
+                return cpumask_of_cpu(cpu);
+        return CPU_MASK_ALL;
+}
+
+static int __init parse_vector_domain(char *arg)
+{
+        if (!arg)
+                return -EINVAL;
+        if (!strcmp(arg, "percpu")) {
+                vector_domain_type = VECTOR_DOMAIN_PERCPU;
+                no_int_routing = 1;
+        }
+        return 1;
+}
+early_param("vector", parse_vector_domain);
+#else
+static cpumask_t vector_allocation_domain(int cpu)
+{
+        return CPU_MASK_ALL;
+}
+#endif
+
+
+void destroy_and_reserve_irq(unsigned int irq)
+{
+        dynamic_irq_cleanup(irq);
+
+        clear_irq_vector(irq);
+        reserve_irq(irq);
+}
+
+static int __reassign_irq_vector(int irq, int cpu)
+{
+        struct irq_cfg *cfg = &irq_cfg[irq];
+        int vector;
+        cpumask_t domain;
+
+        if (cfg->vector == IRQ_VECTOR_UNASSIGNED || !cpu_online(cpu))
+                return -EINVAL;
+        if (cpu_isset(cpu, cfg->domain))
+                return 0;
+        domain = vector_allocation_domain(cpu);
+        vector = find_unassigned_vector(domain);
+        if (vector < 0)
+                return -ENOSPC;
+        __clear_irq_vector(irq);
+        BUG_ON(__bind_irq_vector(irq, vector, domain));
+        return 0;
+}
+
+int reassign_irq_vector(int irq, int cpu)
+{
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&vector_lock, flags);
+        ret = __reassign_irq_vector(irq, cpu);
+        spin_unlock_irqrestore(&vector_lock, flags);
+        return ret;
 }
 
 /*
@@ -111,18 +342,35 @@ reserve_irq_vector (int vector)
  */
 int create_irq(void)
 {
-        int vector = assign_irq_vector(AUTO_ASSIGN);
-
-        if (vector >= 0)
-                dynamic_irq_init(vector);
-
-        return vector;
+        unsigned long flags;
+        int irq, vector, cpu;
+        cpumask_t domain;
+
+        irq = vector = -ENOSPC;
+        spin_lock_irqsave(&vector_lock, flags);
+        for_each_online_cpu(cpu) {
+                domain = vector_allocation_domain(cpu);
+                vector = find_unassigned_vector(domain);
+                if (vector >= 0)
+                        break;
+        }
+        if (vector < 0)
+                goto out;
+        irq = find_unassigned_irq();
+        if (irq < 0)
+                goto out;
+        BUG_ON(__bind_irq_vector(irq, vector, domain));
+ out:
+        spin_unlock_irqrestore(&vector_lock, flags);
+        if (irq >= 0)
+                dynamic_irq_init(irq);
+        return irq;
 }
 
 void destroy_irq(unsigned int irq)
 {
         dynamic_irq_cleanup(irq);
-        free_irq_vector(irq);
+        clear_irq_vector(irq);
 }
 
 #ifdef CONFIG_SMP
@@ -301,14 +549,13 @@ register_percpu_irq (ia64_vector vec, struct irqaction *action)
         irq_desc_t *desc;
         unsigned int irq;
 
-        for (irq = 0; irq < NR_IRQS; ++irq)
-                if (irq_to_vector(irq) == vec) {
-                        desc = irq_desc + irq;
-                        desc->status |= IRQ_PER_CPU;
-                        desc->chip = &irq_type_ia64_lsapic;
-                        if (action)
-                                setup_irq(irq, action);
-                }
+        irq = vec;
+        BUG_ON(bind_irq_vector(irq, vec, CPU_MASK_ALL));
+        desc = irq_desc + irq;
+        desc->status |= IRQ_PER_CPU;
+        desc->chip = &irq_type_ia64_lsapic;
+        if (action)
+                setup_irq(irq, action);
 }
 
 void __init