Patched in Tegra support.

5 files changed, 161 insertions, 176 deletions

diff --git a/arch/m68k/amiga/amiints.c b/arch/m68k/amiga/amiints.c
index 47b5f90002a..c5b5212cc3f 100644
--- a/arch/m68k/amiga/amiints.c
+++ b/arch/m68k/amiga/amiints.c
@@ -1,15 +1,43 @@
 /*
- * Amiga Linux interrupt handling code
+ * linux/arch/m68k/amiga/amiints.c -- Amiga Linux interrupt handling code
  *
  * This file is subject to the terms and conditions of the GNU General Public
  * License.  See the file COPYING in the main directory of this archive
  * for more details.
+ *
+ * 11/07/96: rewritten interrupt handling, irq lists are exists now only for
+ *           this sources where it makes sense (VERTB/PORTS/EXTER) and you must
+ *           be careful that dev_id for this sources is unique since this the
+ *           only possibility to distinguish between different handlers for
+ *           free_irq. irq lists also have different irq flags:
+ *           - IRQ_FLG_FAST: handler is inserted at top of list (after other
+ *                           fast handlers)
+ *           - IRQ_FLG_SLOW: handler is inserted at bottom of list and before
+ *                           they're executed irq level is set to the previous
+ *                           one, but handlers don't need to be reentrant, if
+ *                           reentrance occurred, slow handlers will be just
+ *                           called again.
+ *           The whole interrupt handling for CIAs is moved to cia.c
+ *           /Roman Zippel
+ *
+ * 07/08/99: rewamp of the interrupt handling - we now have two types of
+ *           interrupts, normal and fast handlers, fast handlers being
+ *           marked with IRQF_DISABLED and runs with all other interrupts
+ *           disabled. Normal interrupts disable their own source but
+ *           run with all other interrupt sources enabled.
+ *           PORTS and EXTER interrupts are always shared even if the
+ *           drivers do not explicitly mark this when calling
+ *           request_irq which they really should do.
+ *           This is similar to the way interrupts are handled on all
+ *           other architectures and makes a ton of sense besides
+ *           having the advantage of making it easier to share
+ *           drivers.
+ *           /Jes
  */
 
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/errno.h>
-#include <linux/irq.h>
 
 #include <asm/irq.h>
 #include <asm/traps.h>
@@ -17,6 +45,56 @@
 #include <asm/amigaints.h>
 #include <asm/amipcmcia.h>
 
+static void amiga_enable_irq(unsigned int irq);
+static void amiga_disable_irq(unsigned int irq);
+static irqreturn_t ami_int1(int irq, void *dev_id);
+static irqreturn_t ami_int3(int irq, void *dev_id);
+static irqreturn_t ami_int4(int irq, void *dev_id);
+static irqreturn_t ami_int5(int irq, void *dev_id);
+
+static struct irq_controller amiga_irq_controller = {
+        .name           = "amiga",
+        .lock           = __SPIN_LOCK_UNLOCKED(amiga_irq_controller.lock),
+        .enable         = amiga_enable_irq,
+        .disable        = amiga_disable_irq,
+};
+
+/*
+ * void amiga_init_IRQ(void)
+ *
+ * Parameters:  None
+ *
+ * Returns:     Nothing
+ *
+ * This function should be called during kernel startup to initialize
+ * the amiga IRQ handling routines.
+ */
+
+void __init amiga_init_IRQ(void)
+{
+        if (request_irq(IRQ_AUTO_1, ami_int1, 0, "int1", NULL))
+                pr_err("Couldn't register int%d\n", 1);
+        if (request_irq(IRQ_AUTO_3, ami_int3, 0, "int3", NULL))
+                pr_err("Couldn't register int%d\n", 3);
+        if (request_irq(IRQ_AUTO_4, ami_int4, 0, "int4", NULL))
+                pr_err("Couldn't register int%d\n", 4);
+        if (request_irq(IRQ_AUTO_5, ami_int5, 0, "int5", NULL))
+                pr_err("Couldn't register int%d\n", 5);
+
+        m68k_setup_irq_controller(&amiga_irq_controller, IRQ_USER, AMI_STD_IRQS);
+
+        /* turn off PCMCIA interrupts */
+        if (AMIGAHW_PRESENT(PCMCIA))
+                gayle.inten = GAYLE_IRQ_IDE;
+
+        /* turn off all interrupts and enable the master interrupt bit */
+        amiga_custom.intena = 0x7fff;
+        amiga_custom.intreq = 0x7fff;
+        amiga_custom.intena = IF_SETCLR | IF_INTEN;
+
+        cia_init_IRQ(&ciaa_base);
+        cia_init_IRQ(&ciab_base);
+}
 
 /*
  * Enable/disable a particular machine specific interrupt source.
@@ -25,150 +103,112 @@
  * internal data, that may not be changed by the interrupt at the same time.
  */
 
-static void amiga_irq_enable(struct irq_data *data)
+static void amiga_enable_irq(unsigned int irq)
 {
-        amiga_custom.intena = IF_SETCLR | (1 << (data->irq - IRQ_USER));
+        amiga_custom.intena = IF_SETCLR | (1 << (irq - IRQ_USER));
 }
 
-static void amiga_irq_disable(struct irq_data *data)
+static void amiga_disable_irq(unsigned int irq)
 {
-        amiga_custom.intena = 1 << (data->irq - IRQ_USER);
+        amiga_custom.intena = 1 << (irq - IRQ_USER);
 }
 
-static struct irq_chip amiga_irq_chip = {
-        .name           = "amiga",
-        .irq_enable     = amiga_irq_enable,
-        .irq_disable    = amiga_irq_disable,
-};
-
-
 /*
  * The builtin Amiga hardware interrupt handlers.
  */
 
-static void ami_int1(unsigned int irq, struct irq_desc *desc)
+static irqreturn_t ami_int1(int irq, void *dev_id)
 {
         unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;
 
         /* if serial transmit buffer empty, interrupt */
         if (ints & IF_TBE) {
                 amiga_custom.intreq = IF_TBE;
-                generic_handle_irq(IRQ_AMIGA_TBE);
+                m68k_handle_int(IRQ_AMIGA_TBE);
         }
 
         /* if floppy disk transfer complete, interrupt */
         if (ints & IF_DSKBLK) {
                 amiga_custom.intreq = IF_DSKBLK;
-                generic_handle_irq(IRQ_AMIGA_DSKBLK);
+                m68k_handle_int(IRQ_AMIGA_DSKBLK);
         }
 
         /* if software interrupt set, interrupt */
         if (ints & IF_SOFT) {
                 amiga_custom.intreq = IF_SOFT;
-                generic_handle_irq(IRQ_AMIGA_SOFT);
+                m68k_handle_int(IRQ_AMIGA_SOFT);
         }
+        return IRQ_HANDLED;
 }
 
-static void ami_int3(unsigned int irq, struct irq_desc *desc)
+static irqreturn_t ami_int3(int irq, void *dev_id)
 {
         unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;
 
         /* if a blitter interrupt */
         if (ints & IF_BLIT) {
                 amiga_custom.intreq = IF_BLIT;
-                generic_handle_irq(IRQ_AMIGA_BLIT);
+                m68k_handle_int(IRQ_AMIGA_BLIT);
         }
 
         /* if a copper interrupt */
         if (ints & IF_COPER) {
                 amiga_custom.intreq = IF_COPER;
-                generic_handle_irq(IRQ_AMIGA_COPPER);
+                m68k_handle_int(IRQ_AMIGA_COPPER);
         }
 
         /* if a vertical blank interrupt */
         if (ints & IF_VERTB) {
                 amiga_custom.intreq = IF_VERTB;
-                generic_handle_irq(IRQ_AMIGA_VERTB);
+                m68k_handle_int(IRQ_AMIGA_VERTB);
         }
+        return IRQ_HANDLED;
 }
 
-static void ami_int4(unsigned int irq, struct irq_desc *desc)
+static irqreturn_t ami_int4(int irq, void *dev_id)
 {
         unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;
 
         /* if audio 0 interrupt */
         if (ints & IF_AUD0) {
                 amiga_custom.intreq = IF_AUD0;
-                generic_handle_irq(IRQ_AMIGA_AUD0);
+                m68k_handle_int(IRQ_AMIGA_AUD0);
         }
 
         /* if audio 1 interrupt */
         if (ints & IF_AUD1) {
                 amiga_custom.intreq = IF_AUD1;
-                generic_handle_irq(IRQ_AMIGA_AUD1);
+                m68k_handle_int(IRQ_AMIGA_AUD1);
         }
 
         /* if audio 2 interrupt */
         if (ints & IF_AUD2) {
                 amiga_custom.intreq = IF_AUD2;
-                generic_handle_irq(IRQ_AMIGA_AUD2);
+                m68k_handle_int(IRQ_AMIGA_AUD2);
         }
 
         /* if audio 3 interrupt */
         if (ints & IF_AUD3) {
                 amiga_custom.intreq = IF_AUD3;
-                generic_handle_irq(IRQ_AMIGA_AUD3);
+                m68k_handle_int(IRQ_AMIGA_AUD3);
         }
+        return IRQ_HANDLED;
 }
 
-static void ami_int5(unsigned int irq, struct irq_desc *desc)
+static irqreturn_t ami_int5(int irq, void *dev_id)
 {
         unsigned short ints = amiga_custom.intreqr & amiga_custom.intenar;
 
         /* if serial receive buffer full interrupt */
         if (ints & IF_RBF) {
                 /* acknowledge of IF_RBF must be done by the serial interrupt */
-                generic_handle_irq(IRQ_AMIGA_RBF);
+                m68k_handle_int(IRQ_AMIGA_RBF);
         }
 
         /* if a disk sync interrupt */
         if (ints & IF_DSKSYN) {
                 amiga_custom.intreq = IF_DSKSYN;
-                generic_handle_irq(IRQ_AMIGA_DSKSYN);
+                m68k_handle_int(IRQ_AMIGA_DSKSYN);
         }
-}
-
-
-/*
- * void amiga_init_IRQ(void)
- *
- * Parameters:  None
- *
- * Returns:     Nothing
- *
- * This function should be called during kernel startup to initialize
- * the amiga IRQ handling routines.
- */
-
-void __init amiga_init_IRQ(void)
-{
-        m68k_setup_irq_controller(&amiga_irq_chip, handle_simple_irq, IRQ_USER,
-                                  AMI_STD_IRQS);
-
-        irq_set_chained_handler(IRQ_AUTO_1, ami_int1);
-        irq_set_chained_handler(IRQ_AUTO_3, ami_int3);
-        irq_set_chained_handler(IRQ_AUTO_4, ami_int4);
-        irq_set_chained_handler(IRQ_AUTO_5, ami_int5);
-
-        /* turn off PCMCIA interrupts */
-        if (AMIGAHW_PRESENT(PCMCIA))
-                gayle.inten = GAYLE_IRQ_IDE;
-
-        /* turn off all interrupts and enable the master interrupt bit */
-        amiga_custom.intena = 0x7fff;
-        amiga_custom.intreq = 0x7fff;
-        amiga_custom.intena = IF_SETCLR | IF_INTEN;
-
-        cia_init_IRQ(&ciaa_base);
-        cia_init_IRQ(&ciab_base);
+        return IRQ_HANDLED;
 }
diff --git a/arch/m68k/amiga/amisound.c b/arch/m68k/amiga/amisound.c
index 2559eefc6af..61e5c54625a 100644
--- a/arch/m68k/amiga/amisound.c
+++ b/arch/m68k/amiga/amisound.c
@@ -14,6 +14,7 @@
 #include <linux/string.h>
 #include <linux/module.h>
 
+#include <asm/system.h>
 #include <asm/amigahw.h>
 
 static unsigned short *snd_data;
diff --git a/arch/m68k/amiga/cia.c b/arch/m68k/amiga/cia.c
index 18c0e29976e..ecd0f7ca6f0 100644
--- a/arch/m68k/amiga/cia.c
+++ b/arch/m68k/amiga/cia.c
@@ -93,14 +93,13 @@ static irqreturn_t cia_handler(int irq, void *dev_id)
         amiga_custom.intreq = base->int_mask;
         for (; ints; mach_irq++, ints >>= 1) {
                 if (ints & 1)
-                        generic_handle_irq(mach_irq);
+                        m68k_handle_int(mach_irq);
         }
         return IRQ_HANDLED;
 }
 
-static void cia_irq_enable(struct irq_data *data)
+static void cia_enable_irq(unsigned int irq)
 {
-        unsigned int irq = data->irq;
         unsigned char mask;
 
         if (irq >= IRQ_AMIGA_CIAB) {
@@ -114,20 +113,19 @@ static void cia_irq_enable(struct irq_data *data)
         }
 }
 
-static void cia_irq_disable(struct irq_data *data)
+static void cia_disable_irq(unsigned int irq)
 {
-        unsigned int irq = data->irq;
-
         if (irq >= IRQ_AMIGA_CIAB)
                 cia_able_irq(&ciab_base, 1 << (irq - IRQ_AMIGA_CIAB));
         else
                 cia_able_irq(&ciaa_base, 1 << (irq - IRQ_AMIGA_CIAA));
 }
 
-static struct irq_chip cia_irq_chip = {
+static struct irq_controller cia_irq_controller = {
         .name           = "cia",
-        .irq_enable     = cia_irq_enable,
-        .irq_disable    = cia_irq_disable,
+        .lock           = __SPIN_LOCK_UNLOCKED(cia_irq_controller.lock),
+        .enable         = cia_enable_irq,
+        .disable        = cia_disable_irq,
 };
 
 /*
@@ -136,9 +134,9 @@ static struct irq_chip cia_irq_chip = {
  * into this chain.
  */
 
-static void auto_irq_enable(struct irq_data *data)
+static void auto_enable_irq(unsigned int irq)
 {
-        switch (data->irq) {
+        switch (irq) {
         case IRQ_AUTO_2:
                 amiga_custom.intena = IF_SETCLR | IF_PORTS;
                 break;
@@ -148,9 +146,9 @@ static void auto_irq_enable(struct irq_data *data)
         }
 }
 
-static void auto_irq_disable(struct irq_data *data)
+static void auto_disable_irq(unsigned int irq)
 {
-        switch (data->irq) {
+        switch (irq) {
         case IRQ_AUTO_2:
                 amiga_custom.intena = IF_PORTS;
                 break;
@@ -160,25 +158,24 @@ static void auto_irq_disable(struct irq_data *data)
         }
 }
 
-static struct irq_chip auto_irq_chip = {
+static struct irq_controller auto_irq_controller = {
         .name           = "auto",
-        .irq_enable     = auto_irq_enable,
-        .irq_disable    = auto_irq_disable,
+        .lock           = __SPIN_LOCK_UNLOCKED(auto_irq_controller.lock),
+        .enable         = auto_enable_irq,
+        .disable        = auto_disable_irq,
 };
 
 void __init cia_init_IRQ(struct ciabase *base)
 {
-        m68k_setup_irq_controller(&cia_irq_chip, handle_simple_irq,
-                                  base->cia_irq, CIA_IRQS);
+        m68k_setup_irq_controller(&cia_irq_controller, base->cia_irq, CIA_IRQS);
 
         /* clear any pending interrupt and turn off all interrupts */
         cia_set_irq(base, CIA_ICR_ALL);
         cia_able_irq(base, CIA_ICR_ALL);
 
         /* override auto int and install CIA handler */
-        m68k_setup_irq_controller(&auto_irq_chip, handle_simple_irq,
-                                  base->handler_irq, 1);
-        m68k_irq_startup_irq(base->handler_irq);
+        m68k_setup_irq_controller(&auto_irq_controller, base->handler_irq, 1);
+        m68k_irq_startup(base->handler_irq);
         if (request_irq(base->handler_irq, cia_handler, IRQF_SHARED,
                         base->name, base))
                 pr_err("Couldn't register %s interrupt\n", base->name);
diff --git a/arch/m68k/amiga/config.c b/arch/m68k/amiga/config.c
index ee01b7a38e5..82a4bb51d5d 100644
--- a/arch/m68k/amiga/config.c
+++ b/arch/m68k/amiga/config.c
@@ -29,6 +29,7 @@
 
 #include <asm/bootinfo.h>
 #include <asm/setup.h>
+#include <asm/system.h>
 #include <asm/pgtable.h>
 #include <asm/amigahw.h>
 #include <asm/amigaints.h>
@@ -510,7 +511,8 @@ static unsigned long amiga_gettimeoffset(void)
         return ticks + offset;
 }
 
-static void amiga_reset(void)  __noreturn;
+static NORET_TYPE void amiga_reset(void)
+    ATTRIB_NORET;
 
 static void amiga_reset(void)
 {
diff --git a/arch/m68k/amiga/platform.c b/arch/m68k/amiga/platform.c
index 6083088c0cc..7fd8b41723e 100644
--- a/arch/m68k/amiga/platform.c
+++ b/arch/m68k/amiga/platform.c
@@ -6,7 +6,6 @@
  * for more details.
  */
 
-#include <linux/err.h>
 #include <linux/init.h>
 #include <linux/platform_device.h>
 #include <linux/zorro.h>
@@ -47,22 +46,18 @@ static const struct resource zorro_resources[] __initconst = {
 
 static int __init amiga_init_bus(void)
 {
-        struct platform_device *pdev;
-        unsigned int n;
-
         if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(ZORRO))
                 return -ENODEV;
 
-        n = AMIGAHW_PRESENT(ZORRO3) ? 4 : 2;
-        pdev = platform_device_register_simple("amiga-zorro", -1,
-                                               zorro_resources, n);
-        return PTR_RET(pdev);
+        platform_device_register_simple("amiga-zorro", -1, zorro_resources,
+                                        AMIGAHW_PRESENT(ZORRO3) ? 4 : 2);
+        return 0;
 }
 
 subsys_initcall(amiga_init_bus);
 
 
-static int __init z_dev_present(zorro_id id)
+static int z_dev_present(zorro_id id)
 {
         unsigned int i;
 
@@ -131,122 +126,72 @@ static const struct resource amiga_rtc_resource __initconst = {
 static int __init amiga_init_devices(void)
 {
         struct platform_device *pdev;
-        int error;
 
         if (!MACH_IS_AMIGA)
                 return -ENODEV;
 
         /* video hardware */
-        if (AMIGAHW_PRESENT(AMI_VIDEO)) {
-                pdev = platform_device_register_simple("amiga-video", -1, NULL,
-                                                       0);
-                if (IS_ERR(pdev))
-                        return PTR_ERR(pdev);
-        }
+        if (AMIGAHW_PRESENT(AMI_VIDEO))
+                platform_device_register_simple("amiga-video", -1, NULL, 0);
 
 
         /* sound hardware */
-        if (AMIGAHW_PRESENT(AMI_AUDIO)) {
-                pdev = platform_device_register_simple("amiga-audio", -1, NULL,
-                                                       0);
-                if (IS_ERR(pdev))
-                        return PTR_ERR(pdev);
-        }
+        if (AMIGAHW_PRESENT(AMI_AUDIO))
+                platform_device_register_simple("amiga-audio", -1, NULL, 0);
 
 
         /* storage interfaces */
-        if (AMIGAHW_PRESENT(AMI_FLOPPY)) {
-                pdev = platform_device_register_simple("amiga-floppy", -1,
-                                                       NULL, 0);
-                if (IS_ERR(pdev))
-                        return PTR_ERR(pdev);
-        }
+        if (AMIGAHW_PRESENT(AMI_FLOPPY))
+                platform_device_register_simple("amiga-floppy", -1, NULL, 0);
 
-        if (AMIGAHW_PRESENT(A3000_SCSI)) {
-                pdev = platform_device_register_simple("amiga-a3000-scsi", -1,
-                                                       &a3000_scsi_resource, 1);
-                if (IS_ERR(pdev))
-                        return PTR_ERR(pdev);
-        }
+        if (AMIGAHW_PRESENT(A3000_SCSI))
+                platform_device_register_simple("amiga-a3000-scsi", -1,
+                                                &a3000_scsi_resource, 1);
 
-        if (AMIGAHW_PRESENT(A4000_SCSI)) {
-                pdev = platform_device_register_simple("amiga-a4000t-scsi", -1,
-                                                       &a4000t_scsi_resource,
-                                                       1);
-                if (IS_ERR(pdev))
-                        return PTR_ERR(pdev);
-        }
+        if (AMIGAHW_PRESENT(A4000_SCSI))
+                platform_device_register_simple("amiga-a4000t-scsi", -1,
+                                                &a4000t_scsi_resource, 1);
 
         if (AMIGAHW_PRESENT(A1200_IDE) ||
             z_dev_present(ZORRO_PROD_MTEC_VIPER_MK_V_E_MATRIX_530_SCSI_IDE)) {
                 pdev = platform_device_register_simple("amiga-gayle-ide", -1,
                                                        &a1200_ide_resource, 1);
-                if (IS_ERR(pdev))
-                        return PTR_ERR(pdev);
-                error = platform_device_add_data(pdev, &a1200_ide_pdata,
-                                                 sizeof(a1200_ide_pdata));
-                if (error)
-                        return error;
+                platform_device_add_data(pdev, &a1200_ide_pdata,
+                                         sizeof(a1200_ide_pdata));
         }
 
         if (AMIGAHW_PRESENT(A4000_IDE)) {
                 pdev = platform_device_register_simple("amiga-gayle-ide", -1,
                                                        &a4000_ide_resource, 1);
-                if (IS_ERR(pdev))
-                        return PTR_ERR(pdev);
-                error = platform_device_add_data(pdev, &a4000_ide_pdata,
-                                                 sizeof(a4000_ide_pdata));
-                if (error)
-                        return error;
+                platform_device_add_data(pdev, &a4000_ide_pdata,
+                                         sizeof(a4000_ide_pdata));
         }
 
 
         /* other I/O hardware */
-        if (AMIGAHW_PRESENT(AMI_KEYBOARD)) {
-                pdev = platform_device_register_simple("amiga-keyboard", -1,
-                                                       NULL, 0);
-                if (IS_ERR(pdev))
-                        return PTR_ERR(pdev);
-        }
+        if (AMIGAHW_PRESENT(AMI_KEYBOARD))
+                platform_device_register_simple("amiga-keyboard", -1, NULL, 0);
 
-        if (AMIGAHW_PRESENT(AMI_MOUSE)) {
-                pdev = platform_device_register_simple("amiga-mouse", -1, NULL,
-                                                       0);
-                if (IS_ERR(pdev))
-                        return PTR_ERR(pdev);
-        }
+        if (AMIGAHW_PRESENT(AMI_MOUSE))
+                platform_device_register_simple("amiga-mouse", -1, NULL, 0);
 
-        if (AMIGAHW_PRESENT(AMI_SERIAL)) {
-                pdev = platform_device_register_simple("amiga-serial", -1,
-                                                       NULL, 0);
-                if (IS_ERR(pdev))
-                        return PTR_ERR(pdev);
-        }
+        if (AMIGAHW_PRESENT(AMI_SERIAL))
+                platform_device_register_simple("amiga-serial", -1, NULL, 0);
 
-        if (AMIGAHW_PRESENT(AMI_PARALLEL)) {
-                pdev = platform_device_register_simple("amiga-parallel", -1,
-                                                       NULL, 0);
-                if (IS_ERR(pdev))
-                        return PTR_ERR(pdev);
-        }
+        if (AMIGAHW_PRESENT(AMI_PARALLEL))
+                platform_device_register_simple("amiga-parallel", -1, NULL, 0);
 
 
         /* real time clocks */
-        if (AMIGAHW_PRESENT(A2000_CLK)) {
-                pdev = platform_device_register_simple("rtc-msm6242", -1,
-                                                       &amiga_rtc_resource, 1);
-                if (IS_ERR(pdev))
-                        return PTR_ERR(pdev);
-        }
+        if (AMIGAHW_PRESENT(A2000_CLK))
+                platform_device_register_simple("rtc-msm6242", -1,
+                                                &amiga_rtc_resource, 1);
 
-        if (AMIGAHW_PRESENT(A3000_CLK)) {
-                pdev = platform_device_register_simple("rtc-rp5c01", -1,
-                                                       &amiga_rtc_resource, 1);
-                if (IS_ERR(pdev))
-                        return PTR_ERR(pdev);
-        }
+        if (AMIGAHW_PRESENT(A3000_CLK))
+                platform_device_register_simple("rtc-rp5c01", -1,
+                                                &amiga_rtc_resource, 1);
 
         return 0;
 }
 
-arch_initcall(amiga_init_devices);
+device_initcall(amiga_init_devices);