Merge tag 'mfd-3.8-1' of git://git.kernel.org/pub/scm/linux/kernel/git/sameo/mfd-2.6

Pull MFS update from Samuel Ortiz:
 "This is the MFD patch set for the 3.8 merge window.

  We have several new drivers, most of the time coming with their sub
  devices drivers:

   - Austria Microsystem's AS3711
   - Nano River's viperboard
   - TI's TPS80031, AM335x TS/ADC,
   - Realtek's MMC/memstick card reader
   - Nokia's retu

  We also got some notable cleanups and improvements:

   - tps6586x got converted to IRQ domains.
   - tps65910 and tps65090 moved to the regmap IRQ API.
   - STMPE is now Device Tree aware.
   - A general twl6040 and twl-core cleanup, with moves to the regmap
     I/O and IRQ APIs and a conversion to the recently added PWM
     framework.
   - sta2x11 gained regmap support.

  Then the rest is mostly tiny cleanups and fixes, among which we have
  Mark's wm5xxx and wm8xxx patchset."

Far amount of annoying but largely trivial conflicts.  Many due to
__devinit/exit removal, others due to one or two of the new drivers also
having come in through another tree.

* tag 'mfd-3.8-1' of git://git.kernel.org/pub/scm/linux/kernel/git/sameo/mfd-2.6: (119 commits)
  mfd: tps6507x: Convert to devm_kzalloc
  mfd: stmpe: Update DT support for stmpe driver
  mfd: wm5102: Add readback of DSP status 3 register
  mfd: arizona: Log if we fail to create the primary IRQ domain
  mfd: tps80031: MFD_TPS80031 needs to select REGMAP_IRQ
  mfd: tps80031: Add terminating entry for tps80031_id_table
  mfd: sta2x11: Fix potential NULL pointer dereference in __sta2x11_mfd_mask()
  mfd: wm5102: Add tuning for revision B
  mfd: arizona: Defer patch initialistation until after first device boot
  mfd: tps65910: Fix wrong ack_base register
  mfd: tps65910: Remove unused data
  mfd: stmpe: Get rid of irq_invert_polarity
  mfd: ab8500-core: Fix invalid free of devm_ allocated data
  mfd: wm5102: Mark DSP memory regions as volatile
  mfd: wm5102: Correct default for LDO1_CONTROL_2
  mfd: arizona: Register haptics devices
  mfd: wm8994: Make current device behaviour the default
  mfd: tps65090: MFD_TPS65090 needs to select REGMAP_IRQ
  mfd: Fix stmpe.c build when OF is not enabled
  mfd: jz4740-adc: Use devm_kzalloc
  ...

1 files changed, 380 insertions, 156 deletions

diff --git a/drivers/mfd/sta2x11-mfd.c b/drivers/mfd/sta2x11-mfd.c
index d6284cacd27a..1225dcbcfcfc 100644
--- a/drivers/mfd/sta2x11-mfd.c
+++ b/drivers/mfd/sta2x11-mfd.c
@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2009-2011 Wind River Systems, Inc.
- * Copyright (c) 2011 ST Microelectronics (Alessandro Rubini)
+ * Copyright (c) 2011 ST Microelectronics (Alessandro Rubini, Davide Ciminaghi)
  *
  * 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
@@ -27,21 +27,28 @@
 #include <linux/io.h>
 #include <linux/ioport.h>
 #include <linux/pci.h>
-#include <linux/debugfs.h>
 #include <linux/seq_file.h>
 #include <linux/platform_device.h>
 #include <linux/mfd/core.h>
 #include <linux/mfd/sta2x11-mfd.h>
+#include <linux/regmap.h>
 
 #include <asm/sta2x11.h>
 
+static inline int __reg_within_range(unsigned int r,
+                                     unsigned int start,
+                                     unsigned int end)
+{
+        return ((r >= start) && (r <= end));
+}
+
 /* This describes STA2X11 MFD chip for us, we may have several */
 struct sta2x11_mfd {
         struct sta2x11_instance *instance;
-        spinlock_t lock;
+        struct regmap *regmap[sta2x11_n_mfd_plat_devs];
+        spinlock_t lock[sta2x11_n_mfd_plat_devs];
         struct list_head list;
-        void __iomem *sctl_regs;
-        void __iomem *apbreg_regs;
+        void __iomem *regs[sta2x11_n_mfd_plat_devs];
 };
 
 static LIST_HEAD(sta2x11_mfd_list);
@@ -71,6 +78,7 @@ static struct sta2x11_mfd *sta2x11_mfd_find(struct pci_dev *pdev)
 
 static int sta2x11_mfd_add(struct pci_dev *pdev, gfp_t flags)
 {
+        int i;
         struct sta2x11_mfd *mfd = sta2x11_mfd_find(pdev);
         struct sta2x11_instance *instance;
 
@@ -83,7 +91,8 @@ static int sta2x11_mfd_add(struct pci_dev *pdev, gfp_t flags)
         if (!mfd)
                 return -ENOMEM;
         INIT_LIST_HEAD(&mfd->list);
-        spin_lock_init(&mfd->lock);
+        for (i = 0; i < ARRAY_SIZE(mfd->lock); i++)
+                spin_lock_init(&mfd->lock[i]);
         mfd->instance = instance;
         list_add(&mfd->list, &sta2x11_mfd_list);
         return 0;
@@ -100,161 +109,276 @@ static int mfd_remove(struct pci_dev *pdev)
         return 0;
 }
 
-/* These two functions are exported and are not expected to fail */
-u32 sta2x11_sctl_mask(struct pci_dev *pdev, u32 reg, u32 mask, u32 val)
+/* This function is exported and is not expected to fail */
+u32 __sta2x11_mfd_mask(struct pci_dev *pdev, u32 reg, u32 mask, u32 val,
+                       enum sta2x11_mfd_plat_dev index)
 {
         struct sta2x11_mfd *mfd = sta2x11_mfd_find(pdev);
         u32 r;
         unsigned long flags;
+        void __iomem *regs;
 
         if (!mfd) {
                 dev_warn(&pdev->dev, ": can't access sctl regs\n");
                 return 0;
         }
-        if (!mfd->sctl_regs) {
+
+        regs = mfd->regs[index];
+        if (!regs) {
                 dev_warn(&pdev->dev, ": system ctl not initialized\n");
                 return 0;
         }
-        spin_lock_irqsave(&mfd->lock, flags);
-        r = readl(mfd->sctl_regs + reg);
+        spin_lock_irqsave(&mfd->lock[index], flags);
+        r = readl(regs + reg);
         r &= ~mask;
         r |= val;
         if (mask)
-                writel(r, mfd->sctl_regs + reg);
-        spin_unlock_irqrestore(&mfd->lock, flags);
+                writel(r, regs + reg);
+        spin_unlock_irqrestore(&mfd->lock[index], flags);
         return r;
 }
-EXPORT_SYMBOL(sta2x11_sctl_mask);
+EXPORT_SYMBOL(__sta2x11_mfd_mask);
 
-u32 sta2x11_apbreg_mask(struct pci_dev *pdev, u32 reg, u32 mask, u32 val)
+int sta2x11_mfd_get_regs_data(struct platform_device *dev,
+                              enum sta2x11_mfd_plat_dev index,
+                              void __iomem **regs,
+                              spinlock_t **lock)
 {
-        struct sta2x11_mfd *mfd = sta2x11_mfd_find(pdev);
-        u32 r;
-        unsigned long flags;
+        struct pci_dev *pdev = *(struct pci_dev **)(dev->dev.platform_data);
+        struct sta2x11_mfd *mfd;
 
-        if (!mfd) {
-                dev_warn(&pdev->dev, ": can't access apb regs\n");
-                return 0;
-        }
-        if (!mfd->apbreg_regs) {
-                dev_warn(&pdev->dev, ": apb bridge not initialized\n");
-                return 0;
-        }
-        spin_lock_irqsave(&mfd->lock, flags);
-        r = readl(mfd->apbreg_regs + reg);
-        r &= ~mask;
-        r |= val;
-        if (mask)
-                writel(r, mfd->apbreg_regs + reg);
-        spin_unlock_irqrestore(&mfd->lock, flags);
-        return r;
+        if (!pdev)
+                return -ENODEV;
+        mfd = sta2x11_mfd_find(pdev);
+        if (!mfd)
+                return -ENODEV;
+        if (index >= sta2x11_n_mfd_plat_devs)
+                return -ENODEV;
+        *regs = mfd->regs[index];
+        *lock = &mfd->lock[index];
+        pr_debug("%s %d *regs = %p\n", __func__, __LINE__, *regs);
+        return *regs ? 0 : -ENODEV;
 }
-EXPORT_SYMBOL(sta2x11_apbreg_mask);
-
-/* Two debugfs files, for our registers (FIXME: one instance only) */
-#define REG(regname) {.name = #regname, .offset = SCTL_ ## regname}
-static struct debugfs_reg32 sta2x11_sctl_regs[] = {
-        REG(SCCTL), REG(ARMCFG), REG(SCPLLCTL), REG(SCPLLFCTRL),
-        REG(SCRESFRACT), REG(SCRESCTRL1), REG(SCRESXTRL2), REG(SCPEREN0),
-        REG(SCPEREN1), REG(SCPEREN2), REG(SCGRST), REG(SCPCIPMCR1),
-        REG(SCPCIPMCR2), REG(SCPCIPMSR1), REG(SCPCIPMSR2), REG(SCPCIPMSR3),
-        REG(SCINTREN), REG(SCRISR), REG(SCCLKSTAT0), REG(SCCLKSTAT1),
-        REG(SCCLKSTAT2), REG(SCRSTSTA),
-};
-#undef REG
+EXPORT_SYMBOL(sta2x11_mfd_get_regs_data);
 
-static struct debugfs_regset32 sctl_regset = {
-        .regs = sta2x11_sctl_regs,
-        .nregs = ARRAY_SIZE(sta2x11_sctl_regs),
-};
+/*
+ * Special sta2x11-mfd regmap lock/unlock functions
+ */
+
+static void sta2x11_regmap_lock(void *__lock)
+{
+        spinlock_t *lock = __lock;
+        spin_lock(lock);
+}
 
-#define REG(regname) {.name = #regname, .offset = regname}
-static struct debugfs_reg32 sta2x11_apbreg_regs[] = {
-        REG(APBREG_BSR), REG(APBREG_PAER), REG(APBREG_PWAC), REG(APBREG_PRAC),
-        REG(APBREG_PCG), REG(APBREG_PUR), REG(APBREG_EMU_PCG),
+static void sta2x11_regmap_unlock(void *__lock)
+{
+        spinlock_t *lock = __lock;
+        spin_unlock(lock);
+}
+
+/* OTP (one time programmable registers do not require locking */
+static void sta2x11_regmap_nolock(void *__lock)
+{
+}
+
+static const char *sta2x11_mfd_names[sta2x11_n_mfd_plat_devs] = {
+        [sta2x11_sctl] = STA2X11_MFD_SCTL_NAME,
+        [sta2x11_apbreg] = STA2X11_MFD_APBREG_NAME,
+        [sta2x11_apb_soc_regs] = STA2X11_MFD_APB_SOC_REGS_NAME,
+        [sta2x11_scr] = STA2X11_MFD_SCR_NAME,
 };
-#undef REG
 
-static struct debugfs_regset32 apbreg_regset = {
-        .regs = sta2x11_apbreg_regs,
-        .nregs = ARRAY_SIZE(sta2x11_apbreg_regs),
+static bool sta2x11_sctl_writeable_reg(struct device *dev, unsigned int reg)
+{
+        return !__reg_within_range(reg, SCTL_SCPCIECSBRST, SCTL_SCRSTSTA);
+}
+
+static struct regmap_config sta2x11_sctl_regmap_config = {
+        .reg_bits = 32,
+        .reg_stride = 4,
+        .val_bits = 32,
+        .lock = sta2x11_regmap_lock,
+        .unlock = sta2x11_regmap_unlock,
+        .max_register = SCTL_SCRSTSTA,
+        .writeable_reg = sta2x11_sctl_writeable_reg,
 };
 
-static struct dentry *sta2x11_sctl_debugfs;
-static struct dentry *sta2x11_apbreg_debugfs;
+static bool sta2x11_scr_readable_reg(struct device *dev, unsigned int reg)
+{
+        return (reg == STA2X11_SECR_CR) ||
+                __reg_within_range(reg, STA2X11_SECR_FVR0, STA2X11_SECR_FVR1);
+}
 
-/* Probe for the two platform devices */
-static int sta2x11_sctl_probe(struct platform_device *dev)
+static bool sta2x11_scr_writeable_reg(struct device *dev, unsigned int reg)
 {
-        struct pci_dev **pdev;
-        struct sta2x11_mfd *mfd;
-        struct resource *res;
+        return false;
+}
 
-        pdev = dev->dev.platform_data;
-        mfd = sta2x11_mfd_find(*pdev);
-        if (!mfd)
-                return -ENODEV;
+static struct regmap_config sta2x11_scr_regmap_config = {
+        .reg_bits = 32,
+        .reg_stride = 4,
+        .val_bits = 32,
+        .lock = sta2x11_regmap_nolock,
+        .unlock = sta2x11_regmap_nolock,
+        .max_register = STA2X11_SECR_FVR1,
+        .readable_reg = sta2x11_scr_readable_reg,
+        .writeable_reg = sta2x11_scr_writeable_reg,
+};
 
-        res = platform_get_resource(dev, IORESOURCE_MEM, 0);
-        if (!res)
-                return -ENOMEM;
+static bool sta2x11_apbreg_readable_reg(struct device *dev, unsigned int reg)
+{
+        /* Two blocks (CAN and MLB, SARAC) 0x100 bytes apart */
+        if (reg >= APBREG_BSR_SARAC)
+                reg -= APBREG_BSR_SARAC;
+        switch (reg) {
+        case APBREG_BSR:
+        case APBREG_PAER:
+        case APBREG_PWAC:
+        case APBREG_PRAC:
+        case APBREG_PCG:
+        case APBREG_PUR:
+        case APBREG_EMU_PCG:
+                return true;
+        default:
+                return false;
+        }
+}
 
-        if (!request_mem_region(res->start, resource_size(res),
-                                "sta2x11-sctl"))
-                return -EBUSY;
+static bool sta2x11_apbreg_writeable_reg(struct device *dev, unsigned int reg)
+{
+        if (reg >= APBREG_BSR_SARAC)
+                reg -= APBREG_BSR_SARAC;
+        if (!sta2x11_apbreg_readable_reg(dev, reg))
+                return false;
+        return reg != APBREG_PAER;
+}
 
-        mfd->sctl_regs = ioremap(res->start, resource_size(res));
-        if (!mfd->sctl_regs) {
-                release_mem_region(res->start, resource_size(res));
-                return -ENOMEM;
+static struct regmap_config sta2x11_apbreg_regmap_config = {
+        .reg_bits = 32,
+        .reg_stride = 4,
+        .val_bits = 32,
+        .lock = sta2x11_regmap_lock,
+        .unlock = sta2x11_regmap_unlock,
+        .max_register = APBREG_EMU_PCG_SARAC,
+        .readable_reg = sta2x11_apbreg_readable_reg,
+        .writeable_reg = sta2x11_apbreg_writeable_reg,
+};
+
+static bool sta2x11_apb_soc_regs_readable_reg(struct device *dev,
+                                              unsigned int reg)
+{
+        return reg <= PCIE_SoC_INT_ROUTER_STATUS3_REG ||
+                __reg_within_range(reg, DMA_IP_CTRL_REG, SPARE3_RESERVED) ||
+                __reg_within_range(reg, MASTER_LOCK_REG,
+                                   SYSTEM_CONFIG_STATUS_REG) ||
+                reg == MSP_CLK_CTRL_REG ||
+                __reg_within_range(reg, COMPENSATION_REG1, TEST_CTL_REG);
+}
+
+static bool sta2x11_apb_soc_regs_writeable_reg(struct device *dev,
+                                               unsigned int reg)
+{
+        if (!sta2x11_apb_soc_regs_readable_reg(dev, reg))
+                return false;
+        switch (reg) {
+        case PCIE_COMMON_CLOCK_CONFIG_0_4_0:
+        case SYSTEM_CONFIG_STATUS_REG:
+        case COMPENSATION_REG1:
+        case PCIE_SoC_INT_ROUTER_STATUS0_REG...PCIE_SoC_INT_ROUTER_STATUS3_REG:
+        case PCIE_PM_STATUS_0_PORT_0_4...PCIE_PM_STATUS_7_0_EP4:
+                return false;
+        default:
+                return true;
         }
-        sctl_regset.base = mfd->sctl_regs;
-        sta2x11_sctl_debugfs = debugfs_create_regset32("sta2x11-sctl",
-                                                  S_IFREG | S_IRUGO,
-                                                  NULL, &sctl_regset);
-        return 0;
 }
 
-static int sta2x11_apbreg_probe(struct platform_device *dev)
+static struct regmap_config sta2x11_apb_soc_regs_regmap_config = {
+        .reg_bits = 32,
+        .reg_stride = 4,
+        .val_bits = 32,
+        .lock = sta2x11_regmap_lock,
+        .unlock = sta2x11_regmap_unlock,
+        .max_register = TEST_CTL_REG,
+        .readable_reg = sta2x11_apb_soc_regs_readable_reg,
+        .writeable_reg = sta2x11_apb_soc_regs_writeable_reg,
+};
+
+static struct regmap_config *
+sta2x11_mfd_regmap_configs[sta2x11_n_mfd_plat_devs] = {
+        [sta2x11_sctl] = &sta2x11_sctl_regmap_config,
+        [sta2x11_apbreg] = &sta2x11_apbreg_regmap_config,
+        [sta2x11_apb_soc_regs] = &sta2x11_apb_soc_regs_regmap_config,
+        [sta2x11_scr] = &sta2x11_scr_regmap_config,
+};
+
+/* Probe for the four platform devices */
+
+static int sta2x11_mfd_platform_probe(struct platform_device *dev,
+                                      enum sta2x11_mfd_plat_dev index)
 {
         struct pci_dev **pdev;
         struct sta2x11_mfd *mfd;
         struct resource *res;
+        const char *name = sta2x11_mfd_names[index];
+        struct regmap_config *regmap_config = sta2x11_mfd_regmap_configs[index];
 
         pdev = dev->dev.platform_data;
-        dev_dbg(&dev->dev, "%s: pdata is %p\n", __func__, pdev);
-        dev_dbg(&dev->dev, "%s: *pdata is %p\n", __func__, *pdev);
-
         mfd = sta2x11_mfd_find(*pdev);
         if (!mfd)
                 return -ENODEV;
+        if (!regmap_config)
+                return -ENODEV;
 
         res = platform_get_resource(dev, IORESOURCE_MEM, 0);
         if (!res)
                 return -ENOMEM;
 
-        if (!request_mem_region(res->start, resource_size(res),
-                                "sta2x11-apbreg"))
+        if (!request_mem_region(res->start, resource_size(res), name))
                 return -EBUSY;
 
-        mfd->apbreg_regs = ioremap(res->start, resource_size(res));
-        if (!mfd->apbreg_regs) {
+        mfd->regs[index] = ioremap(res->start, resource_size(res));
+        if (!mfd->regs[index]) {
                 release_mem_region(res->start, resource_size(res));
                 return -ENOMEM;
         }
-        dev_dbg(&dev->dev, "%s: regbase %p\n", __func__, mfd->apbreg_regs);
+        regmap_config->lock_arg = &mfd->lock;
+        /*
+           No caching, registers could be reached both via regmap and via
+           void __iomem *
+        */
+        regmap_config->cache_type = REGCACHE_NONE;
+        mfd->regmap[index] = devm_regmap_init_mmio(&dev->dev, mfd->regs[index],
+                                                   regmap_config);
+        WARN_ON(!mfd->regmap[index]);
 
-        apbreg_regset.base = mfd->apbreg_regs;
-        sta2x11_apbreg_debugfs = debugfs_create_regset32("sta2x11-apbreg",
-                                                  S_IFREG | S_IRUGO,
-                                                  NULL, &apbreg_regset);
         return 0;
 }
 
-/* The two platform drivers */
+static int sta2x11_sctl_probe(struct platform_device *dev)
+{
+        return sta2x11_mfd_platform_probe(dev, sta2x11_sctl);
+}
+
+static int sta2x11_apbreg_probe(struct platform_device *dev)
+{
+        return sta2x11_mfd_platform_probe(dev, sta2x11_apbreg);
+}
+
+static int sta2x11_apb_soc_regs_probe(struct platform_device *dev)
+{
+        return sta2x11_mfd_platform_probe(dev, sta2x11_apb_soc_regs);
+}
+
+static int sta2x11_scr_probe(struct platform_device *dev)
+{
+        return sta2x11_mfd_platform_probe(dev, sta2x11_scr);
+}
+
+/* The three platform drivers */
 static struct platform_driver sta2x11_sctl_platform_driver = {
         .driver = {
-                .name   = "sta2x11-sctl",
+                .name   = STA2X11_MFD_SCTL_NAME,
                 .owner  = THIS_MODULE,
         },
         .probe          = sta2x11_sctl_probe,
@@ -268,7 +392,7 @@ static int __init sta2x11_sctl_init(void)
 
 static struct platform_driver sta2x11_platform_driver = {
         .driver = {
-                .name   = "sta2x11-apbreg",
+                .name   = STA2X11_MFD_APBREG_NAME,
                 .owner  = THIS_MODULE,
         },
         .probe          = sta2x11_apbreg_probe,
@@ -280,13 +404,44 @@ static int __init sta2x11_apbreg_init(void)
         return platform_driver_register(&sta2x11_platform_driver);
 }
 
+static struct platform_driver sta2x11_apb_soc_regs_platform_driver = {
+        .driver = {
+                .name   = STA2X11_MFD_APB_SOC_REGS_NAME,
+                .owner  = THIS_MODULE,
+        },
+        .probe          = sta2x11_apb_soc_regs_probe,
+};
+
+static int __init sta2x11_apb_soc_regs_init(void)
+{
+        pr_info("%s\n", __func__);
+        return platform_driver_register(&sta2x11_apb_soc_regs_platform_driver);
+}
+
+static struct platform_driver sta2x11_scr_platform_driver = {
+        .driver = {
+                .name = STA2X11_MFD_SCR_NAME,
+                .owner = THIS_MODULE,
+        },
+        .probe = sta2x11_scr_probe,
+};
+
+static int __init sta2x11_scr_init(void)
+{
+        pr_info("%s\n", __func__);
+        return platform_driver_register(&sta2x11_scr_platform_driver);
+}
+
+
 /*
- * What follows is the PCI device that hosts the above two pdevs.
+ * What follows are the PCI devices that host the above pdevs.
  * Each logic block is 4kB and they are all consecutive: we use this info.
  */
 
-/* Bar 0 */
-enum bar0_cells {
+/* Mfd 0 device */
+
+/* Mfd 0, Bar 0 */
+enum mfd0_bar0_cells {
         STA2X11_GPIO_0 = 0,
         STA2X11_GPIO_1,
         STA2X11_GPIO_2,
@@ -295,8 +450,8 @@ enum bar0_cells {
         STA2X11_SCR,
         STA2X11_TIME,
 };
-/* Bar 1 */
-enum bar1_cells {
+/* Mfd 0 , Bar 1 */
+enum mfd0_bar1_cells {
         STA2X11_APBREG = 0,
 };
 #define CELL_4K(_name, _cell) { \
@@ -307,40 +462,71 @@ enum bar1_cells {
 
 static const struct resource gpio_resources[] = {
         {
-                .name = "sta2x11_gpio", /* 4 consecutive cells, 1 driver */
+                /* 4 consecutive cells, 1 driver */
+                .name = STA2X11_MFD_GPIO_NAME,
                 .start = 0,
                 .end = (4 * 4096) - 1,
                 .flags = IORESOURCE_MEM,
         }
 };
 static const struct resource sctl_resources[] = {
-        CELL_4K("sta2x11-sctl", STA2X11_SCTL),
+        CELL_4K(STA2X11_MFD_SCTL_NAME, STA2X11_SCTL),
 };
 static const struct resource scr_resources[] = {
-        CELL_4K("sta2x11-scr", STA2X11_SCR),
+        CELL_4K(STA2X11_MFD_SCR_NAME, STA2X11_SCR),
 };
 static const struct resource time_resources[] = {
-        CELL_4K("sta2x11-time", STA2X11_TIME),
+        CELL_4K(STA2X11_MFD_TIME_NAME, STA2X11_TIME),
 };
 
 static const struct resource apbreg_resources[] = {
-        CELL_4K("sta2x11-apbreg", STA2X11_APBREG),
+        CELL_4K(STA2X11_MFD_APBREG_NAME, STA2X11_APBREG),
 };
 
 #define DEV(_name, _r) \
         { .name = _name, .num_resources = ARRAY_SIZE(_r), .resources = _r, }
 
-static struct mfd_cell sta2x11_mfd_bar0[] = {
-        DEV("sta2x11-gpio", gpio_resources), /* offset 0: we add pdata later */
-        DEV("sta2x11-sctl", sctl_resources),
-        DEV("sta2x11-scr", scr_resources),
-        DEV("sta2x11-time", time_resources),
+static struct mfd_cell sta2x11_mfd0_bar0[] = {
+        /* offset 0: we add pdata later */
+        DEV(STA2X11_MFD_GPIO_NAME, gpio_resources),
+        DEV(STA2X11_MFD_SCTL_NAME, sctl_resources),
+        DEV(STA2X11_MFD_SCR_NAME,  scr_resources),
+        DEV(STA2X11_MFD_TIME_NAME, time_resources),
 };
 
-static struct mfd_cell sta2x11_mfd_bar1[] = {
-        DEV("sta2x11-apbreg", apbreg_resources),
+static struct mfd_cell sta2x11_mfd0_bar1[] = {
+        DEV(STA2X11_MFD_APBREG_NAME, apbreg_resources),
 };
 
+/* Mfd 1 devices */
+
+/* Mfd 1, Bar 0 */
+enum mfd1_bar0_cells {
+        STA2X11_VIC = 0,
+};
+
+/* Mfd 1, Bar 1 */
+enum mfd1_bar1_cells {
+        STA2X11_APB_SOC_REGS = 0,
+};
+
+static const __devinitconst struct resource vic_resources[] = {
+        CELL_4K(STA2X11_MFD_VIC_NAME, STA2X11_VIC),
+};
+
+static const __devinitconst struct resource apb_soc_regs_resources[] = {
+        CELL_4K(STA2X11_MFD_APB_SOC_REGS_NAME, STA2X11_APB_SOC_REGS),
+};
+
+static __devinitdata struct mfd_cell sta2x11_mfd1_bar0[] = {
+        DEV(STA2X11_MFD_VIC_NAME, vic_resources),
+};
+
+static __devinitdata struct mfd_cell sta2x11_mfd1_bar1[] = {
+        DEV(STA2X11_MFD_APB_SOC_REGS_NAME, apb_soc_regs_resources),
+};
+
+
 static int sta2x11_mfd_suspend(struct pci_dev *pdev, pm_message_t state)
 {
         pci_save_state(pdev);
@@ -363,11 +549,63 @@ static int sta2x11_mfd_resume(struct pci_dev *pdev)
         return 0;
 }
 
+struct sta2x11_mfd_bar_setup_data {
+        struct mfd_cell *cells;
+        int ncells;
+};
+
+struct sta2x11_mfd_setup_data {
+        struct sta2x11_mfd_bar_setup_data bars[2];
+};
+
+#define STA2X11_MFD0 0
+#define STA2X11_MFD1 1
+
+static struct sta2x11_mfd_setup_data mfd_setup_data[] = {
+        /* Mfd 0: gpio, sctl, scr, timers / apbregs */
+        [STA2X11_MFD0] = {
+                .bars = {
+                        [0] = {
+                                .cells = sta2x11_mfd0_bar0,
+                                .ncells = ARRAY_SIZE(sta2x11_mfd0_bar0),
+                        },
+                        [1] = {
+                                .cells = sta2x11_mfd0_bar1,
+                                .ncells = ARRAY_SIZE(sta2x11_mfd0_bar1),
+                        },
+                },
+        },
+        /* Mfd 1: vic / apb-soc-regs */
+        [STA2X11_MFD1] = {
+                .bars = {
+                        [0] = {
+                                .cells = sta2x11_mfd1_bar0,
+                                .ncells = ARRAY_SIZE(sta2x11_mfd1_bar0),
+                        },
+                        [1] = {
+                                .cells = sta2x11_mfd1_bar1,
+                                .ncells = ARRAY_SIZE(sta2x11_mfd1_bar1),
+                        },
+                },
+        },
+};
+
+static void sta2x11_mfd_setup(struct pci_dev *pdev,
+                              struct sta2x11_mfd_setup_data *sd)
+{
+        int i, j;
+        for (i = 0; i < ARRAY_SIZE(sd->bars); i++)
+                for (j = 0; j < sd->bars[i].ncells; j++) {
+                        sd->bars[i].cells[j].pdata_size = sizeof(pdev);
+                        sd->bars[i].cells[j].platform_data = &pdev;
+                }
+}
+
 static int sta2x11_mfd_probe(struct pci_dev *pdev,
-                                       const struct pci_device_id *pci_id)
+                             const struct pci_device_id *pci_id)
 {
         int err, i;
-        struct sta2x11_gpio_pdata *gpio_data;
+        struct sta2x11_mfd_setup_data *setup_data;
 
         dev_info(&pdev->dev, "%s\n", __func__);
 
@@ -381,46 +619,29 @@ static int sta2x11_mfd_probe(struct pci_dev *pdev,
         if (err)
                 dev_info(&pdev->dev, "Enable msi failed\n");
 
-        /* Read gpio config data as pci device's platform data */
-        gpio_data = dev_get_platdata(&pdev->dev);
-        if (!gpio_data)
-                dev_warn(&pdev->dev, "no gpio configuration\n");
-
-        dev_dbg(&pdev->dev, "%s, gpio_data = %p (%p)\n", __func__,
-                gpio_data, &gpio_data);
-        dev_dbg(&pdev->dev, "%s, pdev = %p (%p)\n", __func__,
-                pdev, &pdev);
+        setup_data = pci_id->device == PCI_DEVICE_ID_STMICRO_GPIO ?
+                &mfd_setup_data[STA2X11_MFD0] :
+                &mfd_setup_data[STA2X11_MFD1];
 
         /* platform data is the pci device for all of them */
-        for (i = 0; i < ARRAY_SIZE(sta2x11_mfd_bar0); i++) {
-                sta2x11_mfd_bar0[i].pdata_size = sizeof(pdev);
-                sta2x11_mfd_bar0[i].platform_data = &pdev;
-        }
-        sta2x11_mfd_bar1[0].pdata_size = sizeof(pdev);
-        sta2x11_mfd_bar1[0].platform_data = &pdev;
+        sta2x11_mfd_setup(pdev, setup_data);
 
         /* Record this pdev before mfd_add_devices: their probe looks for it */
-        sta2x11_mfd_add(pdev, GFP_ATOMIC);
-
-
-        err = mfd_add_devices(&pdev->dev, -1,
-                              sta2x11_mfd_bar0,
-                              ARRAY_SIZE(sta2x11_mfd_bar0),
-                              &pdev->resource[0],
-                              0, NULL);
-        if (err) {
-                dev_err(&pdev->dev, "mfd_add_devices[0] failed: %d\n", err);
-                goto err_disable;
-        }
-
-        err = mfd_add_devices(&pdev->dev, -1,
-                              sta2x11_mfd_bar1,
-                              ARRAY_SIZE(sta2x11_mfd_bar1),
-                              &pdev->resource[1],
-                              0, NULL);
-        if (err) {
-                dev_err(&pdev->dev, "mfd_add_devices[1] failed: %d\n", err);
-                goto err_disable;
+        if (!sta2x11_mfd_find(pdev))
+                sta2x11_mfd_add(pdev, GFP_ATOMIC);
+
+        /* Just 2 bars for all mfd's at present */
+        for (i = 0; i < 2; i++) {
+                err = mfd_add_devices(&pdev->dev, -1,
+                                      setup_data->bars[i].cells,
+                                      setup_data->bars[i].ncells,
+                                      &pdev->resource[i],
+                                      0, NULL);
+                if (err) {
+                        dev_err(&pdev->dev,
+                                "mfd_add_devices[%d] failed: %d\n", i, err);
+                        goto err_disable;
+                }
         }
 
         return 0;
@@ -434,6 +655,7 @@ err_disable:
 
 static DEFINE_PCI_DEVICE_TABLE(sta2x11_mfd_tbl) = {
         {PCI_DEVICE(PCI_VENDOR_ID_STMICRO, PCI_DEVICE_ID_STMICRO_GPIO)},
+        {PCI_DEVICE(PCI_VENDOR_ID_STMICRO, PCI_DEVICE_ID_STMICRO_VIC)},
         {0,},
 };
 
@@ -459,6 +681,8 @@ static int __init sta2x11_mfd_init(void)
  */
 subsys_initcall(sta2x11_apbreg_init);
 subsys_initcall(sta2x11_sctl_init);
+subsys_initcall(sta2x11_apb_soc_regs_init);
+subsys_initcall(sta2x11_scr_init);
 rootfs_initcall(sta2x11_mfd_init);
 
 MODULE_LICENSE("GPL v2");