These changes are the raw update to linux-4.4.6-rt14. Kernel sources

[kvmfornfv.git] / kernel / include / linux / irqdesc.h

diff --git a/kernel/include/linux/irqdesc.h b/kernel/include/linux/irqdesc.h
index 9d97cd5..ad57402 100644 (file)
--- a/kernel/include/linux/irqdesc.h
+++ b/kernel/include/linux/irqdesc.h
@@ -3,9 +3,6 @@
 
 /*
  * Core internal functions to deal with irq descriptors
- *
- * This include will move to kernel/irq once we cleaned up the tree.
- * For now it's included from <linux/irq.h>
  */
 
 struct irq_affinity_notify;
@@ -17,7 +14,7 @@ struct pt_regs;
 
 /**
  * struct irq_desc - interrupt descriptor
- * @irq_data:          per irq and chip data passed down to chip functions
+ * @irq_common_data:   per irq and chip data passed down to chip functions
  * @kstat_irqs:                irq stats per cpu
  * @handle_irq:                highlevel irq-events handler
  * @preflow_handler:   handler called before the flow handler (currently used by sparc)
@@ -47,6 +44,7 @@ struct pt_regs;
  * @name:              flow handler name for /proc/interrupts output
  */
 struct irq_desc {
+       struct irq_common_data  irq_common_data;
        struct irq_data         irq_data;
        unsigned int __percpu   *kstat_irqs;
        irq_flow_handler_t      handle_irq;
@@ -90,10 +88,25 @@ struct irq_desc {
        const char              *name;
 } ____cacheline_internodealigned_in_smp;
 
-#ifndef CONFIG_SPARSE_IRQ
+#ifdef CONFIG_SPARSE_IRQ
+extern void irq_lock_sparse(void);
+extern void irq_unlock_sparse(void);
+#else
+static inline void irq_lock_sparse(void) { }
+static inline void irq_unlock_sparse(void) { }
 extern struct irq_desc irq_desc[NR_IRQS];
 #endif
 
+static inline struct irq_desc *irq_data_to_desc(struct irq_data *data)
+{
+       return container_of(data->common, struct irq_desc, irq_common_data);
+}
+
+static inline unsigned int irq_desc_get_irq(struct irq_desc *desc)
+{
+       return desc->irq_data.irq;
+}
+
 static inline struct irq_data *irq_desc_get_irq_data(struct irq_desc *desc)
 {
        return &desc->irq_data;
@@ -111,23 +124,21 @@ static inline void *irq_desc_get_chip_data(struct irq_desc *desc)
 
 static inline void *irq_desc_get_handler_data(struct irq_desc *desc)
 {
-       return desc->irq_data.handler_data;
+       return desc->irq_common_data.handler_data;
 }
 
 static inline struct msi_desc *irq_desc_get_msi_desc(struct irq_desc *desc)
 {
-       return desc->irq_data.msi_desc;
+       return desc->irq_common_data.msi_desc;
 }
 
 /*
  * Architectures call this to let the generic IRQ layer
- * handle an interrupt. If the descriptor is attached to an
- * irqchip-style controller then we call the ->handle_irq() handler,
- * and it calls __do_IRQ() if it's attached to an irqtype-style controller.
+ * handle an interrupt.
  */
-static inline void generic_handle_irq_desc(unsigned int irq, struct irq_desc *desc)
+static inline void generic_handle_irq_desc(struct irq_desc *desc)
 {
-       desc->handle_irq(irq, desc);
+       desc->handle_irq(desc);
 }
 
 int generic_handle_irq(unsigned int irq);
@@ -150,33 +161,55 @@ static inline int handle_domain_irq(struct irq_domain *domain,
 #endif
 
 /* Test to see if a driver has successfully requested an irq */
-static inline int irq_has_action(unsigned int irq)
+static inline int irq_desc_has_action(struct irq_desc *desc)
 {
-       struct irq_desc *desc = irq_to_desc(irq);
        return desc->action != NULL;
 }
 
-/* caller has locked the irq_desc and both params are valid */
-static inline void __irq_set_handler_locked(unsigned int irq,
-                                           irq_flow_handler_t handler)
+static inline int irq_has_action(unsigned int irq)
 {
-       struct irq_desc *desc;
+       return irq_desc_has_action(irq_to_desc(irq));
+}
+
+/**
+ * irq_set_handler_locked - Set irq handler from a locked region
+ * @data:      Pointer to the irq_data structure which identifies the irq
+ * @handler:   Flow control handler function for this interrupt
+ *
+ * Sets the handler in the irq descriptor associated to @data.
+ *
+ * Must be called with irq_desc locked and valid parameters. Typical
+ * call site is the irq_set_type() callback.
+ */
+static inline void irq_set_handler_locked(struct irq_data *data,
+                                         irq_flow_handler_t handler)
+{
+       struct irq_desc *desc = irq_data_to_desc(data);
 
-       desc = irq_to_desc(irq);
        desc->handle_irq = handler;
 }
 
-/* caller has locked the irq_desc and both params are valid */
+/**
+ * irq_set_chip_handler_name_locked - Set chip, handler and name from a locked region
+ * @data:      Pointer to the irq_data structure for which the chip is set
+ * @chip:      Pointer to the new irq chip
+ * @handler:   Flow control handler function for this interrupt
+ * @name:      Name of the interrupt
+ *
+ * Replace the irq chip at the proper hierarchy level in @data and
+ * sets the handler and name in the associated irq descriptor.
+ *
+ * Must be called with irq_desc locked and valid parameters.
+ */
 static inline void
-__irq_set_chip_handler_name_locked(unsigned int irq, struct irq_chip *chip,
-                                  irq_flow_handler_t handler, const char *name)
+irq_set_chip_handler_name_locked(struct irq_data *data, struct irq_chip *chip,
+                                irq_flow_handler_t handler, const char *name)
 {
-       struct irq_desc *desc;
+       struct irq_desc *desc = irq_data_to_desc(data);
 
-       desc = irq_to_desc(irq);
-       irq_desc_get_irq_data(desc)->chip = chip;
        desc->handle_irq = handler;
        desc->name = name;
+       data->chip = chip;
 }
 
 static inline int irq_balancing_disabled(unsigned int irq)