Merge tag 'v3.2-rc6' of /home/airlied/devel/kernel/linux-2.6 into drm-core-next

Merge in the upstream tree to bring in the mainline fixes.

Conflicts:
	drivers/gpu/drm/exynos/exynos_drm_fbdev.c
	drivers/gpu/drm/nouveau/nouveau_sgdma.c

6 files changed, 98 insertions, 134 deletions

diff --git a/arch/m68k/mac/baboon.c b/arch/m68k/mac/baboon.c
index 2a96bebd8969..b403924a1cad 100644
--- a/arch/m68k/mac/baboon.c
+++ b/arch/m68k/mac/baboon.c
@@ -11,6 +11,7 @@
 #include <linux/mm.h>
 #include <linux/delay.h>
 #include <linux/init.h>
+#include <linux/irq.h>
 
 #include <asm/traps.h>
 #include <asm/bootinfo.h>
@@ -20,9 +21,6 @@
 
 /* #define DEBUG_IRQS */
 
-extern void mac_enable_irq(unsigned int);
-extern void mac_disable_irq(unsigned int);
-
 int baboon_present;
 static volatile struct baboon *baboon;
 static unsigned char baboon_disabled;
@@ -53,7 +51,7 @@ void __init baboon_init(void)
  * Baboon interrupt handler. This works a lot like a VIA.
  */
 
-static irqreturn_t baboon_irq(int irq, void *dev_id)
+static void baboon_irq(unsigned int irq, struct irq_desc *desc)
 {
         int irq_bit, irq_num;
         unsigned char events;
@@ -64,15 +62,16 @@ static irqreturn_t baboon_irq(int irq, void *dev_id)
                 (uint) baboon->mb_status);
 #endif
 
-        if (!(events = baboon->mb_ifr & 0x07))
-                return IRQ_NONE;
+        events = baboon->mb_ifr & 0x07;
+        if (!events)
+                return;
 
         irq_num = IRQ_BABOON_0;
         irq_bit = 1;
         do {
                 if (events & irq_bit) {
                         baboon->mb_ifr &= ~irq_bit;
-                        m68k_handle_int(irq_num);
+                        generic_handle_irq(irq_num);
                 }
                 irq_bit <<= 1;
                 irq_num++;
@@ -82,7 +81,6 @@ static irqreturn_t baboon_irq(int irq, void *dev_id)
         /* for now we need to smash all interrupts */
         baboon->mb_ifr &= ~events;
 #endif
-        return IRQ_HANDLED;
 }
 
 /*
@@ -92,8 +90,7 @@ static irqreturn_t baboon_irq(int irq, void *dev_id)
 void __init baboon_register_interrupts(void)
 {
         baboon_disabled = 0;
-        if (request_irq(IRQ_NUBUS_C, baboon_irq, 0, "baboon", (void *)baboon))
-                pr_err("Couldn't register baboon interrupt\n");
+        irq_set_chained_handler(IRQ_NUBUS_C, baboon_irq);
 }
 
 /*
@@ -111,7 +108,7 @@ void baboon_irq_enable(int irq)
 
         baboon_disabled &= ~(1 << irq_idx);
         if (!baboon_disabled)
-                mac_enable_irq(IRQ_NUBUS_C);
+                mac_irq_enable(irq_get_irq_data(IRQ_NUBUS_C));
 }
 
 void baboon_irq_disable(int irq)
@@ -124,7 +121,7 @@ void baboon_irq_disable(int irq)
 
         baboon_disabled |= 1 << irq_idx;
         if (baboon_disabled)
-                mac_disable_irq(IRQ_NUBUS_C);
+                mac_irq_disable(irq_get_irq_data(IRQ_NUBUS_C));
 }
 
 void baboon_irq_clear(int irq)
diff --git a/arch/m68k/mac/iop.c b/arch/m68k/mac/iop.c
index 1ad4e9d80eba..a5462cc0bfd6 100644
--- a/arch/m68k/mac/iop.c
+++ b/arch/m68k/mac/iop.c
@@ -305,15 +305,13 @@ void __init iop_register_interrupts(void)
 {
         if (iop_ism_present) {
                 if (oss_present) {
-                        if (request_irq(OSS_IRQLEV_IOPISM, iop_ism_irq,
-                                        IRQ_FLG_LOCK, "ISM IOP",
-                                        (void *) IOP_NUM_ISM))
+                        if (request_irq(OSS_IRQLEV_IOPISM, iop_ism_irq, 0,
+                                        "ISM IOP", (void *)IOP_NUM_ISM))
                                 pr_err("Couldn't register ISM IOP interrupt\n");
                         oss_irq_enable(IRQ_MAC_ADB);
                 } else {
-                        if (request_irq(IRQ_VIA2_0, iop_ism_irq,
-                                        IRQ_FLG_LOCK|IRQ_FLG_FAST, "ISM IOP",
-                                        (void *) IOP_NUM_ISM))
+                        if (request_irq(IRQ_VIA2_0, iop_ism_irq, 0, "ISM IOP",
+                                        (void *)IOP_NUM_ISM))
                                 pr_err("Couldn't register ISM IOP interrupt\n");
                 }
                 if (!iop_alive(iop_base[IOP_NUM_ISM])) {
diff --git a/arch/m68k/mac/macints.c b/arch/m68k/mac/macints.c
index f92190c159b4..ba220b70ab8c 100644
--- a/arch/m68k/mac/macints.c
+++ b/arch/m68k/mac/macints.c
@@ -190,14 +190,10 @@ irqreturn_t mac_debug_handler(int, void *);
 
 /* #define DEBUG_MACINTS */
 
-void mac_enable_irq(unsigned int irq);
-void mac_disable_irq(unsigned int irq);
-
-static struct irq_controller mac_irq_controller = {
+static struct irq_chip mac_irq_chip = {
         .name           = "mac",
-        .lock           = __SPIN_LOCK_UNLOCKED(mac_irq_controller.lock),
-        .enable         = mac_enable_irq,
-        .disable        = mac_disable_irq,
+        .irq_enable     = mac_irq_enable,
+        .irq_disable    = mac_irq_disable,
 };
 
 void __init mac_init_IRQ(void)
@@ -205,7 +201,7 @@ void __init mac_init_IRQ(void)
 #ifdef DEBUG_MACINTS
         printk("mac_init_IRQ(): Setting things up...\n");
 #endif
-        m68k_setup_irq_controller(&mac_irq_controller, IRQ_USER,
+        m68k_setup_irq_controller(&mac_irq_chip, handle_simple_irq, IRQ_USER,
                                   NUM_MAC_SOURCES - IRQ_USER);
         /* Make sure the SONIC interrupt is cleared or things get ugly */
 #ifdef SHUTUP_SONIC
@@ -241,16 +237,17 @@ void __init mac_init_IRQ(void)
 }
 
 /*
- *  mac_enable_irq - enable an interrupt source
- * mac_disable_irq - disable an interrupt source
+ *  mac_irq_enable - enable an interrupt source
+ * mac_irq_disable - disable an interrupt source
  *   mac_clear_irq - clears a pending interrupt
- * mac_pending_irq - Returns the pending status of an IRQ (nonzero = pending)
+ * mac_irq_pending - returns the pending status of an IRQ (nonzero = pending)
  *
  * These routines are just dispatchers to the VIA/OSS/PSC routines.
  */
 
-void mac_enable_irq(unsigned int irq)
+void mac_irq_enable(struct irq_data *data)
 {
+        int irq = data->irq;
         int irq_src = IRQ_SRC(irq);
 
         switch(irq_src) {
@@ -283,8 +280,9 @@ void mac_enable_irq(unsigned int irq)
         }
 }
 
-void mac_disable_irq(unsigned int irq)
+void mac_irq_disable(struct irq_data *data)
 {
+        int irq = data->irq;
         int irq_src = IRQ_SRC(irq);
 
         switch(irq_src) {
diff --git a/arch/m68k/mac/oss.c b/arch/m68k/mac/oss.c
index a9c0f5ab4cc0..a4c82dab9ff1 100644
--- a/arch/m68k/mac/oss.c
+++ b/arch/m68k/mac/oss.c
@@ -19,6 +19,7 @@
 #include <linux/mm.h>
 #include <linux/delay.h>
 #include <linux/init.h>
+#include <linux/irq.h>
 
 #include <asm/bootinfo.h>
 #include <asm/macintosh.h>
@@ -29,10 +30,7 @@
 int oss_present;
 volatile struct mac_oss *oss;
 
-static irqreturn_t oss_irq(int, void *);
-static irqreturn_t oss_nubus_irq(int, void *);
-
-extern irqreturn_t via1_irq(int, void *);
+extern void via1_irq(unsigned int irq, struct irq_desc *desc);
 
 /*
  * Initialize the OSS
@@ -60,26 +58,6 @@ void __init oss_init(void)
 }
 
 /*
- * Register the OSS and NuBus interrupt dispatchers.
- */
-
-void __init oss_register_interrupts(void)
-{
-        if (request_irq(OSS_IRQLEV_SCSI, oss_irq, IRQ_FLG_LOCK,
-                        "scsi", (void *) oss))
-                pr_err("Couldn't register %s interrupt\n", "scsi");
-        if (request_irq(OSS_IRQLEV_NUBUS, oss_nubus_irq, IRQ_FLG_LOCK,
-                        "nubus", (void *) oss))
-                pr_err("Couldn't register %s interrupt\n", "nubus");
-        if (request_irq(OSS_IRQLEV_SOUND, oss_irq, IRQ_FLG_LOCK,
-                        "sound", (void *) oss))
-                pr_err("Couldn't register %s interrupt\n", "sound");
-        if (request_irq(OSS_IRQLEV_VIA1, via1_irq, IRQ_FLG_LOCK,
-                        "via1", (void *) via1))
-                pr_err("Couldn't register %s interrupt\n", "via1");
-}
-
-/*
  * Initialize OSS for Nubus access
  */
 
@@ -92,17 +70,17 @@ void __init oss_nubus_init(void)
  * and SCSI; everything else is routed to its own autovector IRQ.
  */
 
-static irqreturn_t oss_irq(int irq, void *dev_id)
+static void oss_irq(unsigned int irq, struct irq_desc *desc)
 {
         int events;
 
         events = oss->irq_pending & (OSS_IP_SOUND|OSS_IP_SCSI);
         if (!events)
-                return IRQ_NONE;
+                return;
 
 #ifdef DEBUG_IRQS
         if ((console_loglevel == 10) && !(events & OSS_IP_SCSI)) {
-                printk("oss_irq: irq %d events = 0x%04X\n", irq,
+                printk("oss_irq: irq %u events = 0x%04X\n", irq,
                         (int) oss->irq_pending);
         }
 #endif
@@ -113,11 +91,10 @@ static irqreturn_t oss_irq(int irq, void *dev_id)
                 /* FIXME: call sound handler */
         } else if (events & OSS_IP_SCSI) {
                 oss->irq_pending &= ~OSS_IP_SCSI;
-                m68k_handle_int(IRQ_MAC_SCSI);
+                generic_handle_irq(IRQ_MAC_SCSI);
         } else {
                 /* FIXME: error check here? */
         }
-        return IRQ_HANDLED;
 }
 
 /*
@@ -126,13 +103,13 @@ static irqreturn_t oss_irq(int irq, void *dev_id)
  * Unlike the VIA/RBV this is on its own autovector interrupt level.
  */
 
-static irqreturn_t oss_nubus_irq(int irq, void *dev_id)
+static void oss_nubus_irq(unsigned int irq, struct irq_desc *desc)
 {
         int events, irq_bit, i;
 
         events = oss->irq_pending & OSS_IP_NUBUS;
         if (!events)
-                return IRQ_NONE;
+                return;
 
 #ifdef DEBUG_NUBUS_INT
         if (console_loglevel > 7) {
@@ -148,10 +125,21 @@ static irqreturn_t oss_nubus_irq(int irq, void *dev_id)
                 irq_bit >>= 1;
                 if (events & irq_bit) {
                         oss->irq_pending &= ~irq_bit;
-                        m68k_handle_int(NUBUS_SOURCE_BASE + i);
+                        generic_handle_irq(NUBUS_SOURCE_BASE + i);
                 }
         } while(events & (irq_bit - 1));
-        return IRQ_HANDLED;
+}
+
+/*
+ * Register the OSS and NuBus interrupt dispatchers.
+ */
+
+void __init oss_register_interrupts(void)
+{
+        irq_set_chained_handler(OSS_IRQLEV_SCSI, oss_irq);
+        irq_set_chained_handler(OSS_IRQLEV_NUBUS, oss_nubus_irq);
+        irq_set_chained_handler(OSS_IRQLEV_SOUND, oss_irq);
+        irq_set_chained_handler(OSS_IRQLEV_VIA1, via1_irq);
 }
 
 /*
diff --git a/arch/m68k/mac/psc.c b/arch/m68k/mac/psc.c
index a4c3eb60706e..e6c2d20f328d 100644
--- a/arch/m68k/mac/psc.c
+++ b/arch/m68k/mac/psc.c
@@ -18,6 +18,7 @@
 #include <linux/mm.h>
 #include <linux/delay.h>
 #include <linux/init.h>
+#include <linux/irq.h>
 
 #include <asm/traps.h>
 #include <asm/bootinfo.h>
@@ -30,8 +31,6 @@
 int psc_present;
 volatile __u8 *psc;
 
-irqreturn_t psc_irq(int, void *);
-
 /*
  * Debugging dump, used in various places to see what's going on.
  */
@@ -112,52 +111,52 @@ void __init psc_init(void)
 }
 
 /*
- * Register the PSC interrupt dispatchers for autovector interrupts 3-6.
- */
-
-void __init psc_register_interrupts(void)
-{
-        if (request_irq(IRQ_AUTO_3, psc_irq, 0, "psc3", (void *) 0x30))
-                pr_err("Couldn't register psc%d interrupt\n", 3);
-        if (request_irq(IRQ_AUTO_4, psc_irq, 0, "psc4", (void *) 0x40))
-                pr_err("Couldn't register psc%d interrupt\n", 4);
-        if (request_irq(IRQ_AUTO_5, psc_irq, 0, "psc5", (void *) 0x50))
-                pr_err("Couldn't register psc%d interrupt\n", 5);
-        if (request_irq(IRQ_AUTO_6, psc_irq, 0, "psc6", (void *) 0x60))
-                pr_err("Couldn't register psc%d interrupt\n", 6);
-}
-
-/*
  * PSC interrupt handler. It's a lot like the VIA interrupt handler.
  */
 
-irqreturn_t psc_irq(int irq, void *dev_id)
+static void psc_irq(unsigned int irq, struct irq_desc *desc)
 {
-        int pIFR        = pIFRbase + ((int) dev_id);
-        int pIER        = pIERbase + ((int) dev_id);
+        unsigned int offset = (unsigned int)irq_desc_get_handler_data(desc);
+        int pIFR        = pIFRbase + offset;
+        int pIER        = pIERbase + offset;
         int irq_num;
         unsigned char irq_bit, events;
 
 #ifdef DEBUG_IRQS
-        printk("psc_irq: irq %d pIFR = 0x%02X pIER = 0x%02X\n",
+        printk("psc_irq: irq %u pIFR = 0x%02X pIER = 0x%02X\n",
                 irq, (int) psc_read_byte(pIFR), (int) psc_read_byte(pIER));
 #endif
 
         events = psc_read_byte(pIFR) & psc_read_byte(pIER) & 0xF;
         if (!events)
-                return IRQ_NONE;
+                return;
 
         irq_num = irq << 3;
         irq_bit = 1;
         do {
                 if (events & irq_bit) {
                         psc_write_byte(pIFR, irq_bit);
-                        m68k_handle_int(irq_num);
+                        generic_handle_irq(irq_num);
                 }
                 irq_num++;
                 irq_bit <<= 1;
         } while (events >= irq_bit);
-        return IRQ_HANDLED;
+}
+
+/*
+ * Register the PSC interrupt dispatchers for autovector interrupts 3-6.
+ */
+
+void __init psc_register_interrupts(void)
+{
+        irq_set_chained_handler(IRQ_AUTO_3, psc_irq);
+        irq_set_handler_data(IRQ_AUTO_3, (void *)0x30);
+        irq_set_chained_handler(IRQ_AUTO_4, psc_irq);
+        irq_set_handler_data(IRQ_AUTO_4, (void *)0x40);
+        irq_set_chained_handler(IRQ_AUTO_5, psc_irq);
+        irq_set_handler_data(IRQ_AUTO_5, (void *)0x50);
+        irq_set_chained_handler(IRQ_AUTO_6, psc_irq);
+        irq_set_handler_data(IRQ_AUTO_6, (void *)0x60);
 }
 
 void psc_irq_enable(int irq) {
diff --git a/arch/m68k/mac/via.c b/arch/m68k/mac/via.c
index e71166daec6a..f1600ad26621 100644
--- a/arch/m68k/mac/via.c
+++ b/arch/m68k/mac/via.c
@@ -28,6 +28,7 @@
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/irq.h>
 
 #include <asm/bootinfo.h>
 #include <asm/macintosh.h>
@@ -77,9 +78,6 @@ static int gIER,gIFR,gBufA,gBufB;
 static u8 nubus_disabled;
 
 void via_debug_dump(void);
-irqreturn_t via1_irq(int, void *);
-irqreturn_t via2_irq(int, void *);
-irqreturn_t via_nubus_irq(int, void *);
 void via_irq_enable(int irq);
 void via_irq_disable(int irq);
 void via_irq_clear(int irq);
@@ -281,40 +279,11 @@ void __init via_init_clock(irq_handler_t func)
         via1[vT1CL] = MAC_CLOCK_LOW;
         via1[vT1CH] = MAC_CLOCK_HIGH;
 
-        if (request_irq(IRQ_MAC_TIMER_1, func, IRQ_FLG_LOCK, "timer", func))
+        if (request_irq(IRQ_MAC_TIMER_1, func, 0, "timer", func))
                 pr_err("Couldn't register %s interrupt\n", "timer");
 }
 
 /*
- * Register the interrupt dispatchers for VIA or RBV machines only.
- */
-
-void __init via_register_interrupts(void)
-{
-        if (via_alt_mapping) {
-                if (request_irq(IRQ_AUTO_1, via1_irq,
-                                IRQ_FLG_LOCK|IRQ_FLG_FAST, "software",
-                                (void *) via1))
-                        pr_err("Couldn't register %s interrupt\n", "software");
-                if (request_irq(IRQ_AUTO_6, via1_irq,
-                                IRQ_FLG_LOCK|IRQ_FLG_FAST, "via1",
-                                (void *) via1))
-                        pr_err("Couldn't register %s interrupt\n", "via1");
-        } else {
-                if (request_irq(IRQ_AUTO_1, via1_irq,
-                                IRQ_FLG_LOCK|IRQ_FLG_FAST, "via1",
-                                (void *) via1))
-                        pr_err("Couldn't register %s interrupt\n", "via1");
-        }
-        if (request_irq(IRQ_AUTO_2, via2_irq, IRQ_FLG_LOCK|IRQ_FLG_FAST,
-                        "via2", (void *) via2))
-                pr_err("Couldn't register %s interrupt\n", "via2");
-        if (request_irq(IRQ_MAC_NUBUS, via_nubus_irq,
-                        IRQ_FLG_LOCK|IRQ_FLG_FAST, "nubus", (void *) via2))
-                pr_err("Couldn't register %s interrupt\n", "nubus");
-}
-
-/*
  * Debugging dump, used in various places to see what's going on.
  */
 
@@ -446,48 +415,46 @@ void __init via_nubus_init(void)
  * via6522.c :-), disable/pending masks added.
  */
 
-irqreturn_t via1_irq(int irq, void *dev_id)
+void via1_irq(unsigned int irq, struct irq_desc *desc)
 {
         int irq_num;
         unsigned char irq_bit, events;
 
         events = via1[vIFR] & via1[vIER] & 0x7F;
         if (!events)
-                return IRQ_NONE;
+                return;
 
         irq_num = VIA1_SOURCE_BASE;
         irq_bit = 1;
         do {
                 if (events & irq_bit) {
                         via1[vIFR] = irq_bit;
-                        m68k_handle_int(irq_num);
+                        generic_handle_irq(irq_num);
                 }
                 ++irq_num;
                 irq_bit <<= 1;
         } while (events >= irq_bit);
-        return IRQ_HANDLED;
 }
 
-irqreturn_t via2_irq(int irq, void *dev_id)
+static void via2_irq(unsigned int irq, struct irq_desc *desc)
 {
         int irq_num;
         unsigned char irq_bit, events;
 
         events = via2[gIFR] & via2[gIER] & 0x7F;
         if (!events)
-                return IRQ_NONE;
+                return;
 
         irq_num = VIA2_SOURCE_BASE;
         irq_bit = 1;
         do {
                 if (events & irq_bit) {
                         via2[gIFR] = irq_bit | rbv_clear;
-                        m68k_handle_int(irq_num);
+                        generic_handle_irq(irq_num);
                 }
                 ++irq_num;
                 irq_bit <<= 1;
         } while (events >= irq_bit);
-        return IRQ_HANDLED;
 }
 
 /*
@@ -495,7 +462,7 @@ irqreturn_t via2_irq(int irq, void *dev_id)
  * VIA2 dispatcher as a fast interrupt handler.
  */
 
-irqreturn_t via_nubus_irq(int irq, void *dev_id)
+void via_nubus_irq(unsigned int irq, struct irq_desc *desc)
 {
         int slot_irq;
         unsigned char slot_bit, events;
@@ -506,7 +473,7 @@ irqreturn_t via_nubus_irq(int irq, void *dev_id)
         else
                 events &= ~via2[vDirA];
         if (!events)
-                return IRQ_NONE;
+                return;
 
         do {
                 slot_irq = IRQ_NUBUS_F;
@@ -514,7 +481,7 @@ irqreturn_t via_nubus_irq(int irq, void *dev_id)
                 do {
                         if (events & slot_bit) {
                                 events &= ~slot_bit;
-                                m68k_handle_int(slot_irq);
+                                generic_handle_irq(slot_irq);
                         }
                         --slot_irq;
                         slot_bit >>= 1;
@@ -528,7 +495,24 @@ irqreturn_t via_nubus_irq(int irq, void *dev_id)
                 else
                         events &= ~via2[vDirA];
         } while (events);
-        return IRQ_HANDLED;
+}
+
+/*
+ * Register the interrupt dispatchers for VIA or RBV machines only.
+ */
+
+void __init via_register_interrupts(void)
+{
+        if (via_alt_mapping) {
+                /* software interrupt */
+                irq_set_chained_handler(IRQ_AUTO_1, via1_irq);
+                /* via1 interrupt */
+                irq_set_chained_handler(IRQ_AUTO_6, via1_irq);
+        } else {
+                irq_set_chained_handler(IRQ_AUTO_1, via1_irq);
+        }
+        irq_set_chained_handler(IRQ_AUTO_2, via2_irq);
+        irq_set_chained_handler(IRQ_MAC_NUBUS, via_nubus_irq);
 }
 
 void via_irq_enable(int irq) {