8 files changed, 295 insertions, 30 deletions

diff --git a/drivers/cdrom/gdrom.c b/drivers/cdrom/gdrom.c
index a762283d2a21..e789e6c9a422 100644
--- a/drivers/cdrom/gdrom.c
+++ b/drivers/cdrom/gdrom.c
@@ -214,7 +214,7 @@ static void gdrom_spicommand(void *spi_string, int buflen)
                 gdrom_getsense(NULL);
                 return;
         }
-        outsw(PHYSADDR(GDROM_DATA_REG), cmd, 6);
+        outsw(GDROM_DATA_REG, cmd, 6);
 }
 
 
@@ -298,7 +298,7 @@ static int gdrom_readtoc_cmd(struct gdromtoc *toc, int session)
                 err = -EINVAL;
                 goto cleanup_readtoc;
         }
-        insw(PHYSADDR(GDROM_DATA_REG), toc, tocsize/2);
+        insw(GDROM_DATA_REG, toc, tocsize/2);
         if (gd.status & 0x01)
                 err = -EINVAL;
 
@@ -449,7 +449,7 @@ static int gdrom_getsense(short *bufstring)
                 GDROM_DEFAULT_TIMEOUT);
         if (gd.pending)
                 goto cleanup_sense;
-        insw(PHYSADDR(GDROM_DATA_REG), &sense, sense_command->buflen/2);
+        insw(GDROM_DATA_REG, &sense, sense_command->buflen/2);
         if (sense[1] & 40) {
                 printk(KERN_INFO "GDROM: Drive not ready - command aborted\n");
                 goto cleanup_sense;
@@ -586,7 +586,7 @@ static void gdrom_readdisk_dma(struct work_struct *work)
                 spin_unlock(&gdrom_lock);
                 block = blk_rq_pos(req)/GD_TO_BLK + GD_SESSION_OFFSET;
                 block_cnt = blk_rq_sectors(req)/GD_TO_BLK;
-                ctrl_outl(PHYSADDR(req->buffer), GDROM_DMA_STARTADDR_REG);
+                ctrl_outl(virt_to_phys(req->buffer), GDROM_DMA_STARTADDR_REG);
                 ctrl_outl(block_cnt * GDROM_HARD_SECTOR, GDROM_DMA_LENGTH_REG);
                 ctrl_outl(1, GDROM_DMA_DIRECTION_REG);
                 ctrl_outl(1, GDROM_DMA_ENABLE_REG);
@@ -615,7 +615,7 @@ static void gdrom_readdisk_dma(struct work_struct *work)
                         cpu_relax();
                 gd.pending = 1;
                 gd.transfer = 1;
-                outsw(PHYSADDR(GDROM_DATA_REG), &read_command->cmd, 6);
+                outsw(GDROM_DATA_REG, &read_command->cmd, 6);
                 timeout = jiffies + HZ / 2;
                 /* Wait for any pending DMA to finish */
                 while (ctrl_inb(GDROM_DMA_STATUS_REG) &&
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index 570be139f9df..96956b3cc178 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -35,6 +35,14 @@ config MFD_ASIC3
           This driver supports the ASIC3 multifunction chip found on many
           PDAs (mainly iPAQ and HTC based ones)
 
+config MFD_SH_MOBILE_SDHI
+        bool "Support for SuperH Mobile SDHI"
+        depends on SUPERH
+        select MFD_CORE
+         ---help---
+          This driver supports the SDHI hardware block found in many
+          SuperH Mobile SoCs.
+
 config MFD_DM355EVM_MSP
         bool "DaVinci DM355 EVM microcontroller"
         depends on I2C && MACH_DAVINCI_DM355_EVM
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index f3b277b90d40..d9522943d2fb 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -4,6 +4,7 @@
 
 obj-$(CONFIG_MFD_SM501)         += sm501.o
 obj-$(CONFIG_MFD_ASIC3)         += asic3.o
+obj-$(CONFIG_MFD_SH_MOBILE_SDHI)                += sh_mobile_sdhi.o
 
 obj-$(CONFIG_HTC_EGPIO)         += htc-egpio.o
 obj-$(CONFIG_HTC_PASIC3)        += htc-pasic3.o
diff --git a/drivers/mfd/sh_mobile_sdhi.c b/drivers/mfd/sh_mobile_sdhi.c
new file mode 100644
index 000000000000..56f72cc1d569
--- /dev/null
+++ b/drivers/mfd/sh_mobile_sdhi.c
@@ -0,0 +1,145 @@
+/*
+ * SuperH Mobile SDHI
+ *
+ * Copyright (C) 2009 Magnus Damm
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Based on "Compaq ASIC3 support":
+ *
+ * Copyright 2001 Compaq Computer Corporation.
+ * Copyright 2004-2005 Phil Blundell
+ * Copyright 2007-2008 OpenedHand Ltd.
+ *
+ * Authors: Phil Blundell <pb@handhelds.org>,
+ *          Samuel Ortiz <sameo@openedhand.com>
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/clk.h>
+#include <linux/platform_device.h>
+
+#include <linux/mfd/core.h>
+#include <linux/mfd/tmio.h>
+
+struct sh_mobile_sdhi {
+        struct clk *clk;
+        struct tmio_mmc_data mmc_data;
+        struct mfd_cell cell_mmc;
+};
+
+static struct resource sh_mobile_sdhi_resources[] = {
+        {
+                .start = 0x000,
+                .end   = 0x1ff,
+                .flags = IORESOURCE_MEM,
+        },
+        {
+                .start = 0,
+                .end   = 0,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct mfd_cell sh_mobile_sdhi_cell = {
+        .name          = "tmio-mmc",
+        .num_resources = ARRAY_SIZE(sh_mobile_sdhi_resources),
+        .resources     = sh_mobile_sdhi_resources,
+};
+
+static int __init sh_mobile_sdhi_probe(struct platform_device *pdev)
+{
+        struct sh_mobile_sdhi *priv;
+        struct resource *mem;
+        char clk_name[8];
+        int ret, irq;
+
+        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!mem)
+                dev_err(&pdev->dev, "missing MEM resource\n");
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0)
+                dev_err(&pdev->dev, "missing IRQ resource\n");
+
+        if (!mem || (irq < 0))
+                return -EINVAL;
+
+        priv = kzalloc(sizeof(struct sh_mobile_sdhi), GFP_KERNEL);
+        if (priv == NULL) {
+                dev_err(&pdev->dev, "kzalloc failed\n");
+                return -ENOMEM;
+        }
+
+        snprintf(clk_name, sizeof(clk_name), "sdhi%d", pdev->id);
+        priv->clk = clk_get(&pdev->dev, clk_name);
+        if (IS_ERR(priv->clk)) {
+                dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
+                ret = PTR_ERR(priv->clk);
+                kfree(priv);
+                return ret;
+        }
+
+        clk_enable(priv->clk);
+
+        /* FIXME: silly const unsigned int hclk */
+        *(unsigned int *)&priv->mmc_data.hclk = clk_get_rate(priv->clk);
+
+        memcpy(&priv->cell_mmc, &sh_mobile_sdhi_cell, sizeof(priv->cell_mmc));
+        priv->cell_mmc.driver_data = &priv->mmc_data;
+        priv->cell_mmc.platform_data = &priv->cell_mmc;
+        priv->cell_mmc.data_size = sizeof(priv->cell_mmc);
+
+        platform_set_drvdata(pdev, priv);
+
+        ret = mfd_add_devices(&pdev->dev, pdev->id,
+                              &priv->cell_mmc, 1, mem, irq);
+        if (ret) {
+                clk_disable(priv->clk);
+                clk_put(priv->clk);
+                kfree(priv);
+        }
+
+        return ret;
+}
+
+static int sh_mobile_sdhi_remove(struct platform_device *pdev)
+{
+        struct sh_mobile_sdhi *priv = platform_get_drvdata(pdev);
+
+        mfd_remove_devices(&pdev->dev);
+        clk_disable(priv->clk);
+        clk_put(priv->clk);
+        kfree(priv);
+
+        return 0;
+}
+
+static struct platform_driver sh_mobile_sdhi_driver = {
+        .driver         = {
+                .name   = "sh_mobile_sdhi",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = sh_mobile_sdhi_probe,
+        .remove         = __devexit_p(sh_mobile_sdhi_remove),
+};
+
+static int __init sh_mobile_sdhi_init(void)
+{
+        return platform_driver_register(&sh_mobile_sdhi_driver);
+}
+
+static void __exit sh_mobile_sdhi_exit(void)
+{
+        platform_driver_unregister(&sh_mobile_sdhi_driver);
+}
+
+module_init(sh_mobile_sdhi_init);
+module_exit(sh_mobile_sdhi_exit);
+
+MODULE_DESCRIPTION("SuperH Mobile SDHI driver");
+MODULE_AUTHOR("Magnus Damm");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index 432ae8358c86..e04b751680d0 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -329,7 +329,7 @@ config MMC_SDRICOH_CS
 
 config MMC_TMIO
         tristate "Toshiba Mobile IO Controller (TMIO) MMC/SD function support"
-        depends on MFD_TMIO || MFD_ASIC3
+        depends on MFD_TMIO || MFD_ASIC3 || SUPERH
         help
           This provides support for the SD/MMC cell found in TC6393XB,
           T7L66XB and also HTC ASIC3
diff --git a/drivers/sh/intc.c b/drivers/sh/intc.c
index 559b5fe9dc0f..a7e5c2e9986c 100644
--- a/drivers/sh/intc.c
+++ b/drivers/sh/intc.c
@@ -2,6 +2,7 @@
  * Shared interrupt handling code for IPR and INTC2 types of IRQs.
  *
  * Copyright (C) 2007, 2008 Magnus Damm
+ * Copyright (C) 2009 Paul Mundt
  *
  * Based on intc2.c and ipr.c
  *
@@ -24,6 +25,7 @@
 #include <linux/sysdev.h>
 #include <linux/list.h>
 #include <linux/topology.h>
+#include <linux/bitmap.h>
 
 #define _INTC_MK(fn, mode, addr_e, addr_d, width, shift) \
         ((shift) | ((width) << 5) | ((fn) << 9) | ((mode) << 13) | \
@@ -59,6 +61,20 @@ struct intc_desc_int {
 
 static LIST_HEAD(intc_list);
 
+/*
+ * The intc_irq_map provides a global map of bound IRQ vectors for a
+ * given platform. Allocation of IRQs are either static through the CPU
+ * vector map, or dynamic in the case of board mux vectors or MSI.
+ *
+ * As this is a central point for all IRQ controllers on the system,
+ * each of the available sources are mapped out here. This combined with
+ * sparseirq makes it quite trivial to keep the vector map tightly packed
+ * when dynamically creating IRQs, as well as tying in to otherwise
+ * unused irq_desc positions in the sparse array.
+ */
+static DECLARE_BITMAP(intc_irq_map, NR_IRQS);
+static DEFINE_SPINLOCK(vector_lock);
+
 #ifdef CONFIG_SMP
 #define IS_SMP(x) x.smp
 #define INTC_REG(d, x, c) (d->reg[(x)] + ((d->smp[(x)] & 0xff) * c))
@@ -70,9 +86,7 @@ static LIST_HEAD(intc_list);
 #endif
 
 static unsigned int intc_prio_level[NR_IRQS]; /* for now */
-#if defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4A)
 static unsigned long ack_handle[NR_IRQS];
-#endif
 
 static inline struct intc_desc_int *get_intc_desc(unsigned int irq)
 {
@@ -250,7 +264,6 @@ static int intc_set_wake(unsigned int irq, unsigned int on)
         return 0; /* allow wakeup, but setup hardware in intc_suspend() */
 }
 
-#if defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4A)
 static void intc_mask_ack(unsigned int irq)
 {
         struct intc_desc_int *d = get_intc_desc(irq);
@@ -282,7 +295,6 @@ static void intc_mask_ack(unsigned int irq)
                 }
         }
 }
-#endif
 
 static struct intc_handle_int *intc_find_irq(struct intc_handle_int *hp,
                                              unsigned int nr_hp,
@@ -501,7 +513,6 @@ static unsigned int __init intc_prio_data(struct intc_desc *desc,
         return 0;
 }
 
-#if defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4A)
 static unsigned int __init intc_ack_data(struct intc_desc *desc,
                                           struct intc_desc_int *d,
                                           intc_enum enum_id)
@@ -533,7 +544,6 @@ static unsigned int __init intc_ack_data(struct intc_desc *desc,
 
         return 0;
 }
-#endif
 
 static unsigned int __init intc_sense_data(struct intc_desc *desc,
                                            struct intc_desc_int *d,
@@ -572,6 +582,11 @@ static void __init intc_register_irq(struct intc_desc *desc,
         struct intc_handle_int *hp;
         unsigned int data[2], primary;
 
+        /*
+         * Register the IRQ position with the global IRQ map
+         */
+        set_bit(irq, intc_irq_map);
+
         /* Prefer single interrupt source bitmap over other combinations:
          * 1. bitmap, single interrupt source
          * 2. priority, single interrupt source
@@ -641,10 +656,8 @@ static void __init intc_register_irq(struct intc_desc *desc,
         /* irq should be disabled by default */
         d->chip.mask(irq);
 
-#if defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4A)
         if (desc->ack_regs)
                 ack_handle[irq] = intc_ack_data(desc, d, enum_id);
-#endif
 }
 
 static unsigned int __init save_reg(struct intc_desc_int *d,
@@ -681,10 +694,8 @@ void __init register_intc_controller(struct intc_desc *desc)
         d->nr_reg = desc->mask_regs ? desc->nr_mask_regs * 2 : 0;
         d->nr_reg += desc->prio_regs ? desc->nr_prio_regs * 2 : 0;
         d->nr_reg += desc->sense_regs ? desc->nr_sense_regs : 0;
-
-#if defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4A)
         d->nr_reg += desc->ack_regs ? desc->nr_ack_regs : 0;
-#endif
+
         d->reg = kzalloc(d->nr_reg * sizeof(*d->reg), GFP_NOWAIT);
 #ifdef CONFIG_SMP
         d->smp = kzalloc(d->nr_reg * sizeof(*d->smp), GFP_NOWAIT);
@@ -727,14 +738,12 @@ void __init register_intc_controller(struct intc_desc *desc)
         d->chip.set_type = intc_set_sense;
         d->chip.set_wake = intc_set_wake;
 
-#if defined(CONFIG_CPU_SH3) || defined(CONFIG_CPU_SH4A)
         if (desc->ack_regs) {
                 for (i = 0; i < desc->nr_ack_regs; i++)
                         k += save_reg(d, k, desc->ack_regs[i].set_reg, 0);
 
                 d->chip.mask_ack = intc_mask_ack;
         }
-#endif
 
         BUG_ON(k > 256); /* _INTC_ADDR_E() and _INTC_ADDR_D() are 8 bits */
 
@@ -856,5 +865,91 @@ static int __init register_intc_sysdevs(void)
 
         return error;
 }
-
 device_initcall(register_intc_sysdevs);
+
+/*
+ * Dynamic IRQ allocation and deallocation
+ */
+static unsigned int create_irq_on_node(unsigned int irq_want, int node)
+{
+        unsigned int irq = 0, new;
+        unsigned long flags;
+        struct irq_desc *desc;
+
+        spin_lock_irqsave(&vector_lock, flags);
+
+        /*
+         * First try the wanted IRQ, then scan.
+         */
+        if (test_and_set_bit(irq_want, intc_irq_map)) {
+                new = find_first_zero_bit(intc_irq_map, nr_irqs);
+                if (unlikely(new == nr_irqs))
+                        goto out_unlock;
+
+                desc = irq_to_desc_alloc_node(new, node);
+                if (unlikely(!desc)) {
+                        pr_info("can't get irq_desc for %d\n", new);
+                        goto out_unlock;
+                }
+
+                desc = move_irq_desc(desc, node);
+                __set_bit(new, intc_irq_map);
+                irq = new;
+        }
+
+out_unlock:
+        spin_unlock_irqrestore(&vector_lock, flags);
+
+        if (irq > 0)
+                dynamic_irq_init(irq);
+
+        return irq;
+}
+
+int create_irq(void)
+{
+        int nid = cpu_to_node(smp_processor_id());
+        int irq;
+
+        irq = create_irq_on_node(NR_IRQS_LEGACY, nid);
+        if (irq == 0)
+                irq = -1;
+
+        return irq;
+}
+
+void destroy_irq(unsigned int irq)
+{
+        unsigned long flags;
+
+        dynamic_irq_cleanup(irq);
+
+        spin_lock_irqsave(&vector_lock, flags);
+        __clear_bit(irq, intc_irq_map);
+        spin_unlock_irqrestore(&vector_lock, flags);
+}
+
+int reserve_irq_vector(unsigned int irq)
+{
+        unsigned long flags;
+        int ret = 0;
+
+        spin_lock_irqsave(&vector_lock, flags);
+        if (test_and_set_bit(irq, intc_irq_map))
+                ret = -EBUSY;
+        spin_unlock_irqrestore(&vector_lock, flags);
+
+        return ret;
+}
+
+void reserve_irq_legacy(void)
+{
+        unsigned long flags;
+        int i, j;
+
+        spin_lock_irqsave(&vector_lock, flags);
+        j = find_first_bit(intc_irq_map, nr_irqs);
+        for (i = 0; i < j; i++)
+                __set_bit(i, intc_irq_map);
+        spin_unlock_irqrestore(&vector_lock, flags);
+}
diff --git a/drivers/sh/maple/maple.c b/drivers/sh/maple/maple.c
index 93c20e135ee1..4e8f57d4131f 100644
--- a/drivers/sh/maple/maple.c
+++ b/drivers/sh/maple/maple.c
@@ -106,7 +106,7 @@ static void maple_dma_reset(void)
         * max delay is 11
         */
         ctrl_outl(MAPLE_2MBPS | MAPLE_TIMEOUT(0xFFFF), MAPLE_SPEED);
-        ctrl_outl(PHYSADDR(maple_sendbuf), MAPLE_DMAADDR);
+        ctrl_outl(virt_to_phys(maple_sendbuf), MAPLE_DMAADDR);
         ctrl_outl(1, MAPLE_ENABLE);
 }
 
@@ -258,7 +258,7 @@ static void maple_build_block(struct mapleq *mq)
         maple_lastptr = maple_sendptr;
 
         *maple_sendptr++ = (port << 16) | len | 0x80000000;
-        *maple_sendptr++ = PHYSADDR(mq->recvbuf->buf);
+        *maple_sendptr++ = virt_to_phys(mq->recvbuf->buf);
         *maple_sendptr++ =
             mq->command | (to << 8) | (from << 16) | (len << 24);
         while (len-- > 0)
diff --git a/drivers/video/sh_mobile_lcdcfb.c b/drivers/video/sh_mobile_lcdcfb.c
index 3ad5157f9899..b4b5de930cf5 100644
--- a/drivers/video/sh_mobile_lcdcfb.c
+++ b/drivers/video/sh_mobile_lcdcfb.c
@@ -281,18 +281,34 @@ static void sh_mobile_lcdc_deferred_io(struct fb_info *info,
                                        struct list_head *pagelist)
 {
         struct sh_mobile_lcdc_chan *ch = info->par;
-        unsigned int nr_pages;
 
         /* enable clocks before accessing hardware */
         sh_mobile_lcdc_clk_on(ch->lcdc);
 
-        nr_pages = sh_mobile_lcdc_sginit(info, pagelist);
-        dma_map_sg(info->dev, ch->sglist, nr_pages, DMA_TO_DEVICE);
-
-        /* trigger panel update */
-        lcdc_write_chan(ch, LDSM2R, 1);
-
-        dma_unmap_sg(info->dev, ch->sglist, nr_pages, DMA_TO_DEVICE);
+        /*
+         * It's possible to get here without anything on the pagelist via
+         * sh_mobile_lcdc_deferred_io_touch() or via a userspace fsync()
+         * invocation. In the former case, the acceleration routines are
+         * stepped in to when using the framebuffer console causing the
+         * workqueue to be scheduled without any dirty pages on the list.
+         *
+         * Despite this, a panel update is still needed given that the
+         * acceleration routines have their own methods for writing in
+         * that still need to be updated.
+         *
+         * The fsync() and empty pagelist case could be optimized for,
+         * but we don't bother, as any application exhibiting such
+         * behaviour is fundamentally broken anyways.
+         */
+        if (!list_empty(pagelist)) {
+                unsigned int nr_pages = sh_mobile_lcdc_sginit(info, pagelist);
+
+                /* trigger panel update */
+                dma_map_sg(info->dev, ch->sglist, nr_pages, DMA_TO_DEVICE);
+                lcdc_write_chan(ch, LDSM2R, 1);
+                dma_unmap_sg(info->dev, ch->sglist, nr_pages, DMA_TO_DEVICE);
+        } else
+                lcdc_write_chan(ch, LDSM2R, 1);
 }
 
 static void sh_mobile_lcdc_deferred_io_touch(struct fb_info *info)