Cleanup naming for ia64 and x86 interrupt handling functions

- Append '_IRQ' to AUTO_ASSIGN, NEVER_ASSIGN, and FREE_TO_ASSIGN
- Rename {request,setup}_irq to {request,setup}_irq_vector
- Rename free_irq to release_irq_vector
- Add {request,setup,release}_irq wrappers for their
  {request,setup,release}_irq_vector counterparts
- Added generic irq_to_vector inline for ia64
- Changed ia64 to use the new naming scheme

Signed-off-by: Espen Skoglund <espen.skoglund@netronome.com>
Signed-off-by: Isaku Yamahata <yamahata@valinux.co.jp>

xen/arch/ia64/linux-xen/iosapic.c

@@ -93,6 +93,16 @@
 #include <asm/ptrace.h>
 #include <asm/system.h>
 
+#ifdef XEN
+static inline int iosapic_irq_to_vector (int irq)
+{
+	return irq;
+}
+
+#undef irq_to_vector
+#define irq_to_vector(irq)      iosapic_irq_to_vector(irq)
+#define AUTO_ASSIGN	AUTO_ASSIGN_IRQ
+#endif
 
 #undef DEBUG_INTERRUPT_ROUTING
 

xen/arch/ia64/linux-xen/irq_ia64.c

@@ -250,6 +250,7 @@ void
 register_percpu_irq (ia64_vector vec, struct irqaction *action)
 {
 	irq_desc_t *desc;
+#ifndef XEN
 	unsigned int irq;
 
 	for (irq = 0; irq < NR_IRQS; ++irq)
@@ -258,16 +259,19 @@ register_percpu_irq (ia64_vector vec, struct irqaction *action)
 			desc->status |= IRQ_PER_CPU;
 			desc->handler = &irq_type_ia64_lsapic;
 			if (action)
-#ifdef XEN
-				setup_vector(irq, action);
-#else
 				setup_irq(irq, action);
-#endif
 		}
+#else
+	desc = irq_descp(vec);
+	desc->status |= IRQ_PER_CPU;
+	desc->handler = &irq_type_ia64_lsapic;
+	if (action)
+		setup_vector(vec, action);
+#endif
 }
 
 #ifdef XEN
-int request_irq(unsigned int irq,
+int request_irq_vector(unsigned int vector,
 		void (*handler)(int, void *, struct cpu_user_regs *),
 		unsigned long irqflags, const char * devname, void *dev_id)
 {
@@ -279,7 +283,7 @@ int request_irq(unsigned int irq,
 	 * otherwise we'll have trouble later trying to figure out
 	 * which interrupt is which (messes up the interrupt freeing logic etc).
 	 *                          */
-	if (irq >= NR_IRQS)
+	if (vector >= NR_VECTORS)
 		return -EINVAL;
 	if (!handler)
 		return -EINVAL;
@@ -291,7 +295,7 @@ int request_irq(unsigned int irq,
 	action->handler = handler;
 	action->name = devname;
 	action->dev_id = dev_id;
-	setup_vector(irq, action);
+	setup_vector(vector, action);
 	if (retval)
 		xfree(action);
 

xen/arch/ia64/linux-xen/mca.c

@@ -114,7 +114,6 @@ extern void			ia64_monarch_init_handler (void);
 extern void			ia64_slave_init_handler (void);
 #ifdef XEN
 extern void setup_vector (unsigned int vec, struct irqaction *action);
-#define setup_irq(irq, action)	setup_vector(irq, action)
 #endif
 
 static ia64_mc_info_t		ia64_mc_info;
@@ -1922,12 +1921,18 @@ ia64_mca_late_init(void)
 		if (cpe_vector >= 0) {
 			/* If platform supports CPEI, enable the irq. */
 			cpe_poll_enabled = 0;
+#ifndef XEN
 			for (irq = 0; irq < NR_IRQS; ++irq)
 				if (irq_to_vector(irq) == cpe_vector) {
 					desc = irq_descp(irq);
 					desc->status |= IRQ_PER_CPU;
-					setup_irq(irq, &mca_cpe_irqaction);
+					setup_vector(irq, &mca_cpe_irqaction);
 				}
+#else
+			desc = irq_descp(cpe_vector);
+			desc->status |= IRQ_PER_CPU;
+			setup_vector(cpe_vector, &mca_cpe_irqaction);
+#endif
 			ia64_mca_register_cpev(cpe_vector);
 			IA64_MCA_DEBUG("%s: CPEI/P setup and enabled.\n", __FUNCTION__);
 		} else {

xen/arch/ia64/xen/hypercall.c

@@ -543,7 +543,7 @@ long do_physdev_op(int cmd, XEN_GUEST_HANDLE(void) arg)
             break;
         irq_status_query.flags = 0;
         /* Edge-triggered interrupts don't need an explicit unmask downcall. */
-        if ( !strstr(irq_desc[irq_to_vector(irq)].handler->typename, "edge") )
+        if ( !strstr(irq_descp(irq)->handler->typename, "edge") )
             irq_status_query.flags |= XENIRQSTAT_needs_eoi;
         ret = copy_to_guest(arg, &irq_status_query, 1) ? -EFAULT : 0;
         break;

xen/arch/ia64/xen/irq.c

@@ -228,11 +228,11 @@ out:
  * disabled.
  */
 
-int setup_vector(unsigned int irq, struct irqaction * new)
+int setup_vector(unsigned int vector, struct irqaction * new)
 {
 	unsigned long flags;
 	struct irqaction *old, **p;
-	irq_desc_t *desc = irq_descp(irq);
+	irq_desc_t *desc = irq_descp(vector);
 
 	/*
 	 * The following block of code has to be executed atomically
@@ -248,8 +248,8 @@ int setup_vector(unsigned int irq, struct irqaction * new)
 
 	desc->depth = 0;
 	desc->status &= ~(IRQ_DISABLED | IRQ_INPROGRESS | IRQ_GUEST);
-	desc->handler->startup(irq);
-	desc->handler->enable(irq);
+	desc->handler->startup(vector);
+	desc->handler->enable(vector);
 	spin_unlock_irqrestore(&desc->lock,flags);
 
 	return 0;
@@ -258,13 +258,11 @@ int setup_vector(unsigned int irq, struct irqaction * new)
 /* Vectors reserved by xen (and thus not sharable with domains).  */
 unsigned long ia64_xen_vector[BITS_TO_LONGS(NR_IRQS)];
 
-int setup_irq(unsigned int irq, struct irqaction * new)
+int setup_irq_vector(unsigned int vec, struct irqaction * new)
 {
-	unsigned int vec;
 	int res;
 
-	/* Get vector for IRQ.  */
-	if (acpi_gsi_to_irq (irq, &vec) < 0)
+	if ( vec == IA64_INVALID_VECTOR )
 		return -ENOSYS;
 	/* Reserve the vector (and thus the irq).  */
 	if (test_and_set_bit(vec, ia64_xen_vector))
@@ -273,14 +271,12 @@ int setup_irq(unsigned int irq, struct irqaction * new)
 	return res;
 }
 
-void free_irq(unsigned int irq)
+void release_irq_vector(unsigned int vec)
 {
-	unsigned int vec;
 	unsigned long flags;
 	irq_desc_t *desc;
 
-	/* Get vector for IRQ.  */
-	if (acpi_gsi_to_irq(irq, &vec) < 0)
+	if ( vec == IA64_INVALID_VECTOR )
 		return;
 
 	desc = irq_descp(vec);

xen/arch/x86/i8259.c

@@ -410,8 +410,8 @@ void __init init_IRQ(void)
     }
 
     /* Never allocate the hypercall vector or Linux/BSD fast-trap vector. */
-    vector_irq[HYPERCALL_VECTOR] = NEVER_ASSIGN;
-    vector_irq[0x80] = NEVER_ASSIGN;
+    vector_irq[HYPERCALL_VECTOR] = NEVER_ASSIGN_IRQ;
+    vector_irq[0x80] = NEVER_ASSIGN_IRQ;
 
     apic_intr_init();
 

xen/arch/x86/irq.c

@@ -29,7 +29,7 @@ irq_desc_t irq_desc[NR_VECTORS];
 
 static DEFINE_SPINLOCK(vector_lock);
 int vector_irq[NR_VECTORS] __read_mostly = {
-    [0 ... NR_VECTORS - 1] = FREE_TO_ASSIGN
+    [0 ... NR_VECTORS - 1] = FREE_TO_ASSIGN_IRQ
 };
 
 static void __do_IRQ_guest(int vector);
@@ -66,11 +66,11 @@ int free_irq_vector(int vector)
     BUG_ON((vector > LAST_DYNAMIC_VECTOR) || (vector < FIRST_DYNAMIC_VECTOR));
 
     spin_lock(&vector_lock);
-    if ((irq = vector_irq[vector]) == AUTO_ASSIGN)
-        vector_irq[vector] = FREE_TO_ASSIGN;
+    if ((irq = vector_irq[vector]) == AUTO_ASSIGN_IRQ)
+        vector_irq[vector] = FREE_TO_ASSIGN_IRQ;
     spin_unlock(&vector_lock);
 
-    return (irq == AUTO_ASSIGN) ? 0 : -EINVAL;
+    return (irq == AUTO_ASSIGN_IRQ) ? 0 : -EINVAL;
 }
 
 int assign_irq_vector(int irq)
@@ -82,13 +82,13 @@ int assign_irq_vector(int irq)
 
     spin_lock(&vector_lock);
 
-    if ((irq != AUTO_ASSIGN) && (IO_APIC_VECTOR(irq) > 0)) {
+    if ((irq != AUTO_ASSIGN_IRQ) && (IO_APIC_VECTOR(irq) > 0)) {
         spin_unlock(&vector_lock);
         return IO_APIC_VECTOR(irq);
     }
 
     vector = current_vector;
-    while (vector_irq[vector] != FREE_TO_ASSIGN) {
+    while (vector_irq[vector] != FREE_TO_ASSIGN_IRQ) {
         vector += 8;
         if (vector > LAST_DYNAMIC_VECTOR)
             vector = FIRST_DYNAMIC_VECTOR + ((vector + 1) & 7);
@@ -101,7 +101,7 @@ int assign_irq_vector(int irq)
 
     current_vector = vector;
     vector_irq[vector] = irq;
-    if (irq != AUTO_ASSIGN)
+    if (irq != AUTO_ASSIGN_IRQ)
         IO_APIC_VECTOR(irq) = vector;
 
     spin_unlock(&vector_lock);
@@ -159,7 +159,7 @@ asmlinkage void do_IRQ(struct cpu_user_regs *regs)
     spin_unlock(&desc->lock);
 }
 
-int request_irq(unsigned int irq,
+int request_irq_vector(unsigned int vector,
         void (*handler)(int, void *, struct cpu_user_regs *),
         unsigned long irqflags, const char * devname, void *dev_id)
 {
@@ -172,7 +172,7 @@ int request_irq(unsigned int irq,
      * which interrupt is which (messes up the interrupt freeing
      * logic etc).
      */
-    if (irq >= NR_IRQS)
+    if (vector >= NR_VECTORS)
         return -EINVAL;
     if (!handler)
         return -EINVAL;
@@ -185,17 +185,16 @@ int request_irq(unsigned int irq,
     action->name = devname;
     action->dev_id = dev_id;
 
-    retval = setup_irq(irq, action);
+    retval = setup_irq_vector(vector, action);
     if (retval)
         xfree(action);
 
     return retval;
 }
 
-void free_irq(unsigned int irq)
+void release_irq_vector(unsigned int vector)
 {
-    unsigned int  vector = irq_to_vector(irq);
-    irq_desc_t   *desc = &irq_desc[vector];
+    irq_desc_t *desc = &irq_desc[vector];
     unsigned long flags;
 
     spin_lock_irqsave(&desc->lock,flags);
@@ -209,10 +208,9 @@ void free_irq(unsigned int irq)
     do { smp_mb(); } while ( desc->status & IRQ_INPROGRESS );
 }
 
-int setup_irq(unsigned int irq, struct irqaction *new)
+int setup_irq_vector(unsigned int vector, struct irqaction *new)
 {
-    unsigned int  vector = irq_to_vector(irq);
-    irq_desc_t   *desc = &irq_desc[vector];
+    irq_desc_t *desc = &irq_desc[vector];
     unsigned long flags;
  
     spin_lock_irqsave(&desc->lock,flags);

xen/arch/x86/physdev.c

@@ -75,7 +75,7 @@ static int physdev_map_pirq(struct physdev_map_pirq *map)
         case MAP_PIRQ_TYPE_MSI:
             vector = map->index;
             if ( vector == -1 )
-                vector = assign_irq_vector(AUTO_ASSIGN);
+                vector = assign_irq_vector(AUTO_ASSIGN_IRQ);
 
             if ( vector < 0 || vector >= NR_VECTORS )
             {

xen/drivers/char/serial.c

@@ -471,7 +471,7 @@ void serial_suspend(void)
     int i, irq;
     for ( i = 0; i < ARRAY_SIZE(com); i++ )
         if ( (irq = serial_irq(i)) >= 0 )
-            free_irq(irq);
+            release_irq(irq);
 }
 
 void serial_resume(void)

xen/drivers/passthrough/amd/iommu_init.c

@@ -479,7 +479,7 @@ static int set_iommu_interrupt_handler(struct amd_iommu *iommu)
 {
     int vector, ret;
 
-    vector = assign_irq_vector(AUTO_ASSIGN);
+    vector = assign_irq_vector(AUTO_ASSIGN_IRQ);
     if ( vector <= 0 )
     {
         gdprintk(XENLOG_ERR VTDPREFIX, "IOMMU: no vectors\n");
@@ -487,7 +487,8 @@ static int set_iommu_interrupt_handler(struct amd_iommu *iommu)
     }
 
     irq_desc[vector].handler = &iommu_msi_type;
-    ret = request_irq(vector, amd_iommu_page_fault, 0, "amd_iommu", iommu);
+    ret = request_irq_vector(vector, amd_iommu_page_fault, 0,
+                             "amd_iommu", iommu);
     if ( ret )
     {
         irq_desc[vector].handler = &no_irq_type;
@@ -497,7 +498,7 @@ static int set_iommu_interrupt_handler(struct amd_iommu *iommu)
     }
 
     /* Make sure that vector is never re-used. */
-    vector_irq[vector] = NEVER_ASSIGN;
+    vector_irq[vector] = NEVER_ASSIGN_IRQ;
     vector_to_iommu[vector] = iommu;
     iommu->vector = vector;
     return vector;

xen/drivers/passthrough/vtd/ia64/vtd.c

@@ -29,7 +29,9 @@
 #include "../vtd.h"
 
 
-int vector_irq[NR_VECTORS] __read_mostly = { [0 ... NR_VECTORS - 1] = -1};
+int vector_irq[NR_VECTORS] __read_mostly = {
+    [0 ... NR_VECTORS - 1] = FREE_TO_ASSIGN_IRQ
+};
 /* irq_vectors is indexed by the sum of all RTEs in all I/O APICs. */
 u8 irq_vector[NR_IRQS] __read_mostly;
 

xen/drivers/passthrough/vtd/iommu.c

@@ -874,7 +874,7 @@ int iommu_set_interrupt(struct iommu *iommu)
 {
     int vector, ret;
 
-    vector = assign_irq_vector(AUTO_ASSIGN);
+    vector = assign_irq_vector(AUTO_ASSIGN_IRQ);
     if ( vector <= 0 )
     {
         gdprintk(XENLOG_ERR VTDPREFIX, "IOMMU: no vectors\n");
@@ -882,7 +882,7 @@ int iommu_set_interrupt(struct iommu *iommu)
     }
 
     irq_desc[vector].handler = &dma_msi_type;
-    ret = request_irq(vector, iommu_page_fault, 0, "dmar", iommu);
+    ret = request_irq_vector(vector, iommu_page_fault, 0, "dmar", iommu);
     if ( ret )
     {
         irq_desc[vector].handler = &no_irq_type;
@@ -892,7 +892,7 @@ int iommu_set_interrupt(struct iommu *iommu)
     }
 
     /* Make sure that vector is never re-used. */
-    vector_irq[vector] = NEVER_ASSIGN;
+    vector_irq[vector] = NEVER_ASSIGN_IRQ;
     vector_to_iommu[vector] = iommu;
 
     return vector;
@@ -970,7 +970,7 @@ static void iommu_free(struct acpi_drhd_unit *drhd)
         iounmap(iommu->reg);
 
     free_intel_iommu(iommu->intel);
-    free_irq(iommu->vector);
+    release_irq_vector(iommu->vector);
     xfree(iommu);
 
     drhd->iommu = NULL;

xen/include/asm-ia64/hvm/iommu.h

@@ -28,10 +28,6 @@ static inline void pci_cleanup_msi(struct pci_dev *pdev)
     /* TODO */
 }
 
-/* Special IRQ numbers */
-#define AUTO_ASSIGN     (-1)
-#define NEVER_ASSIGN    (-2)
-#define FREE_TO_ASSIGN  (-3)
 
 extern int assign_irq_vector (int irq);
 

xen/include/asm-ia64/hvm/irq.h

@@ -90,13 +90,17 @@ struct hvm_irq {
 #define hvm_pci_intx_link(dev, intx) \
     (((dev) + (intx)) & 3)
 
-/* Extract the IA-64 vector that corresponds to IRQ.  */
-static inline int
-irq_to_vector (int irq)
+#define IA64_INVALID_VECTOR	((unsigned int)((int)-1))
+static inline unsigned int irq_to_vector(int irq)
 {
-    return irq;
-}
+    int acpi_gsi_to_irq (u32 gsi, unsigned int *irq);
+    unsigned int vector;
 
+    if ( acpi_gsi_to_irq(irq, &vector) < 0)
+        return 0;
+
+    return vector;
+}
 
 extern u8 irq_vector[NR_IRQS];
 extern int vector_irq[NR_VECTORS];

xen/include/asm-ia64/linux-xen/linux/interrupt.h

@@ -52,10 +52,10 @@ struct irqaction {
 };
 
 extern irqreturn_t no_action(int cpl, void *dev_id, struct pt_regs *regs);
-extern int request_irq(unsigned int,
+extern int request_irq_vector(unsigned int,
 		       irqreturn_t (*handler)(int, void *, struct pt_regs *),
 		       unsigned long, const char *, void *);
-extern void free_irq(unsigned int, void *);
+extern void release_irq_vector(unsigned int, void *);
 #endif
 
 

xen/include/asm-ia64/linux/asm/hw_irq.h

@@ -34,7 +34,7 @@ typedef u8 ia64_vector;
 #define IA64_MAX_VECTORED_IRQ		255
 #define IA64_NUM_VECTORS		256
 
-#define AUTO_ASSIGN			-1
+#define AUTO_ASSIGN_IRQ			(-1)
 
 #define IA64_SPURIOUS_INT_VECTOR	0x0f
 

xen/include/asm-x86/irq.h

@@ -19,9 +19,6 @@
 
 extern int vector_irq[NR_VECTORS];
 extern u8 irq_vector[NR_IRQS];
-#define AUTO_ASSIGN    -1
-#define NEVER_ASSIGN   -2
-#define FREE_TO_ASSIGN -3
 
 #define platform_legacy_irq(irq)	((irq) < 16)
 

xen/include/xen/irq.h

@@ -25,6 +25,11 @@ struct irqaction
 #define IRQ_GUEST_EOI_PENDING 32 /* IRQ was disabled, pending a guest EOI */
 #define IRQ_PER_CPU     256     /* IRQ is per CPU */
 
+/* Special IRQ numbers. */
+#define AUTO_ASSIGN_IRQ         (-1)
+#define NEVER_ASSIGN_IRQ        (-2)
+#define FREE_TO_ASSIGN_IRQ      (-3)
+
 /*
  * Interrupt controller descriptor. This is all we need
  * to describe about the low-level hardware. 
@@ -64,12 +69,21 @@ typedef struct {
 
 extern irq_desc_t irq_desc[NR_VECTORS];
 
-extern int setup_irq(unsigned int, struct irqaction *);
-extern void free_irq(unsigned int);
-extern int request_irq(unsigned int irq,
+extern int setup_irq_vector(unsigned int, struct irqaction *);
+extern void release_irq_vector(unsigned int);
+extern int request_irq_vector(unsigned int vector,
                void (*handler)(int, void *, struct cpu_user_regs *),
                unsigned long irqflags, const char * devname, void *dev_id);
 
+#define setup_irq(irq, action) \
+    setup_irq_vector(irq_to_vector(irq), action)
+
+#define release_irq(irq) \
+    release_irq_vector(irq_to_vector(irq))
+
+#define request_irq(irq, handler, irqflags, devname, devid) \
+    request_irq_vector(irq_to_vector(irq), handler, irqflags, defname, devid)
+
 extern hw_irq_controller no_irq_type;
 extern void no_action(int cpl, void *dev_id, struct cpu_user_regs *regs);