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

Pull MFD bits from Samuel Ortiz:
 "We have support for a few new drivers:
   - Samsung s2mps11
   - Wolfson Microelectronics wm5102 and wm5110
   - Marvell 88PM800 and 88PM805
   - TI twl6041

  We also have our regular driver improvements:
   - Device tree and IRQ domain support for STE AB8500
   - Regmap and devm_* API conversion for TI tps6586x
   - Device tree support for Samsung max77686
   - devm_* API conversion for STE AB3100

  Besides that, quite a lot of fixing and cleanup for mc13xxx, tps65910,
  tps65090, da9052 and twl-core."

Fix up mostly trivial conflicts, with the exception of
drivers/usb/host/ehci-omap.c in particular, which had some
re-organization of the reset sequence (commit 1a49e2ac9651: "EHCI:
centralize controller initialization") that clashed with commit
2761a6394516 ("mfd: USB: Fix the omap-usb EHCI ULPI PHY reset fix
issues").

In particular, commit 2761a6394516 moved the usb_add_hcd() to the
*middle* of the reset sequence, which clashes fairly badly with the
reset sequence re-organization (although it could have been done inside
the new omap_ehci_init() function).

I left that part of commit 2761a6394516 just undone.

* tag 'mfd-3.6-1' of git://git.kernel.org/pub/scm/linux/kernel/git/sameo/mfd-2.6: (110 commits)
  mfd: Ensure AB8500 platform data is passed through db8500-prcmu to MFD Core
  mfd: Arizone core should select MFD_CORE
  mfd: Fix arizona-irq.c build by selecting REGMAP_IRQ
  mfd: Add debug trace on entering and leaving arizone runtime suspend
  mfd: Correct tps65090 cell names
  mfd: Remove gpio support from tps6586x core driver
  ARM: tegra: defconfig: Enable tps6586x gpio
  gpio: tps6586x: Add gpio support through platform driver
  mfd: Cache tps6586x register through regmap
  mfd: Use regmap for tps6586x register access.
  mfd: Use devm managed resources for tps6586x
  input: Add onkey support for 88PM80X PMIC
  mfd: Add support for twl6041
  mfd: Fix twl6040 revision information
  mfd: Matches should be NULL when populate anatop child devices
  input: ab8500-ponkey: Create AB8500 domain IRQ mapping
  mfd: Add missing out of memory check for pcf50633
  Documentation: Describe the AB8500 Device Tree bindings
  mfd: Add tps65910 32-kHz-crystal-input init
  mfd: Drop modifying mc13xxx driver's id_table in probe
  ...

4 files changed, 37 insertions, 49 deletions

diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig
index f34c3be6c9fe..4e932cc695e9 100644
--- a/drivers/regulator/Kconfig
+++ b/drivers/regulator/Kconfig
@@ -272,7 +272,7 @@ config REGULATOR_S2MPS11
 
 config REGULATOR_S5M8767
         tristate "Samsung S5M8767A voltage regulator"
-        depends on MFD_S5M_CORE
+        depends on MFD_SEC_CORE
         help
          This driver supports a Samsung S5M8767A voltage output regulator
          via I2C bus. S5M8767A have 9 Bucks and 28 LDOs output and
diff --git a/drivers/regulator/ab8500.c b/drivers/regulator/ab8500.c
index 13d424fc1c14..10f2f4d4d190 100644
--- a/drivers/regulator/ab8500.c
+++ b/drivers/regulator/ab8500.c
@@ -848,18 +848,12 @@ static __devexit int ab8500_regulator_remove(struct platform_device *pdev)
         return 0;
 }
 
-static const struct of_device_id ab8500_regulator_match[] = {
-        { .compatible = "stericsson,ab8500-regulator", },
-        {}
-};
-
 static struct platform_driver ab8500_regulator_driver = {
         .probe = ab8500_regulator_probe,
         .remove = __devexit_p(ab8500_regulator_remove),
         .driver         = {
                 .name   = "ab8500-regulator",
                 .owner  = THIS_MODULE,
-                .of_match_table = ab8500_regulator_match,
         },
 };
 
diff --git a/drivers/regulator/db8500-prcmu.c b/drivers/regulator/db8500-prcmu.c
index 9dbb491b6efa..359f8d18fc3f 100644
--- a/drivers/regulator/db8500-prcmu.c
+++ b/drivers/regulator/db8500-prcmu.c
@@ -547,16 +547,10 @@ static int __exit db8500_regulator_remove(struct platform_device *pdev)
         return 0;
 }
 
-static const struct of_device_id db8500_prcmu_regulator_match[] = {
-        { .compatible = "stericsson,db8500-prcmu-regulator", },
-        {}
-};
-
 static struct platform_driver db8500_regulator_driver = {
         .driver = {
                 .name = "db8500-prcmu-regulators",
                 .owner = THIS_MODULE,
-                .of_match_table = db8500_prcmu_regulator_match,
         },
         .probe = db8500_regulator_probe,
         .remove = __exit_p(db8500_regulator_remove),
diff --git a/drivers/regulator/s5m8767.c b/drivers/regulator/s5m8767.c
index 102287fa7ecb..5a0d18a7aa2a 100644
--- a/drivers/regulator/s5m8767.c
+++ b/drivers/regulator/s5m8767.c
@@ -19,15 +19,15 @@
 #include <linux/platform_device.h>
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
-#include <linux/mfd/s5m87xx/s5m-core.h>
-#include <linux/mfd/s5m87xx/s5m-pmic.h>
+#include <linux/mfd/samsung/core.h>
+#include <linux/mfd/samsung/s5m8767.h>
 
 struct s5m8767_info {
         struct device *dev;
-        struct s5m87xx_dev *iodev;
+        struct sec_pmic_dev *iodev;
         int num_regulators;
         struct regulator_dev **rdev;
-        struct s5m_opmode_data *opmode;
+        struct sec_opmode_data *opmode;
 
         int ramp_delay;
         bool buck2_ramp;
@@ -45,43 +45,43 @@ struct s5m8767_info {
         int buck_gpioindex;
 };
 
-struct s5m_voltage_desc {
+struct sec_voltage_desc {
         int max;
         int min;
         int step;
 };
 
-static const struct s5m_voltage_desc buck_voltage_val1 = {
+static const struct sec_voltage_desc buck_voltage_val1 = {
         .max = 2225000,
         .min =  650000,
         .step =   6250,
 };
 
-static const struct s5m_voltage_desc buck_voltage_val2 = {
+static const struct sec_voltage_desc buck_voltage_val2 = {
         .max = 1600000,
         .min =  600000,
         .step =   6250,
 };
 
-static const struct s5m_voltage_desc buck_voltage_val3 = {
+static const struct sec_voltage_desc buck_voltage_val3 = {
         .max = 3000000,
         .min =  750000,
         .step =  12500,
 };
 
-static const struct s5m_voltage_desc ldo_voltage_val1 = {
+static const struct sec_voltage_desc ldo_voltage_val1 = {
         .max = 3950000,
         .min =  800000,
         .step =  50000,
 };
 
-static const struct s5m_voltage_desc ldo_voltage_val2 = {
+static const struct sec_voltage_desc ldo_voltage_val2 = {
         .max = 2375000,
         .min =  800000,
         .step =  25000,
 };
 
-static const struct s5m_voltage_desc *reg_voltage_map[] = {
+static const struct sec_voltage_desc *reg_voltage_map[] = {
         [S5M8767_LDO1] = &ldo_voltage_val2,
         [S5M8767_LDO2] = &ldo_voltage_val2,
         [S5M8767_LDO3] = &ldo_voltage_val1,
@@ -213,7 +213,7 @@ static int s5m8767_reg_is_enabled(struct regulator_dev *rdev)
         else if (ret)
                 return ret;
 
-        ret = s5m_reg_read(s5m8767->iodev, reg, &val);
+        ret = sec_reg_read(s5m8767->iodev, reg, &val);
         if (ret)
                 return ret;
 
@@ -230,7 +230,7 @@ static int s5m8767_reg_enable(struct regulator_dev *rdev)
         if (ret)
                 return ret;
 
-        return s5m_reg_update(s5m8767->iodev, reg, enable_ctrl, mask);
+        return sec_reg_update(s5m8767->iodev, reg, enable_ctrl, mask);
 }
 
 static int s5m8767_reg_disable(struct regulator_dev *rdev)
@@ -243,7 +243,7 @@ static int s5m8767_reg_disable(struct regulator_dev *rdev)
         if (ret)
                 return ret;
 
-        return s5m_reg_update(s5m8767->iodev, reg, ~mask, mask);
+        return sec_reg_update(s5m8767->iodev, reg, ~mask, mask);
 }
 
 static int s5m8767_get_voltage_register(struct regulator_dev *rdev, int *_reg)
@@ -305,7 +305,7 @@ static int s5m8767_get_voltage_sel(struct regulator_dev *rdev)
 
         mask = (reg_id < S5M8767_BUCK1) ? 0x3f : 0xff;
 
-        ret = s5m_reg_read(s5m8767->iodev, reg, &val);
+        ret = sec_reg_read(s5m8767->iodev, reg, &val);
         if (ret)
                 return ret;
 
@@ -315,7 +315,7 @@ static int s5m8767_get_voltage_sel(struct regulator_dev *rdev)
 }
 
 static int s5m8767_convert_voltage_to_sel(
-                const struct s5m_voltage_desc *desc,
+                const struct sec_voltage_desc *desc,
                 int min_vol, int max_vol)
 {
         int selector = 0;
@@ -407,7 +407,7 @@ static int s5m8767_set_voltage_sel(struct regulator_dev *rdev,
                 if (ret)
                         return ret;
 
-                return s5m_reg_update(s5m8767->iodev, reg, selector, mask);
+                return sec_reg_update(s5m8767->iodev, reg, selector, mask);
         }
 }
 
@@ -416,7 +416,7 @@ static int s5m8767_set_voltage_time_sel(struct regulator_dev *rdev,
                                              unsigned int new_sel)
 {
         struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
-        const struct s5m_voltage_desc *desc;
+        const struct sec_voltage_desc *desc;
         int reg_id = rdev_get_id(rdev);
 
         desc = reg_voltage_map[reg_id];
@@ -501,8 +501,8 @@ static struct regulator_desc regulators[] = {
 
 static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
 {
-        struct s5m87xx_dev *iodev = dev_get_drvdata(pdev->dev.parent);
-        struct s5m_platform_data *pdata = dev_get_platdata(iodev->dev);
+        struct sec_pmic_dev *iodev = dev_get_drvdata(pdev->dev.parent);
+        struct sec_platform_data *pdata = dev_get_platdata(iodev->dev);
         struct regulator_config config = { };
         struct regulator_dev **rdev;
         struct s5m8767_info *s5m8767;
@@ -671,13 +671,13 @@ static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
 
         if (pdata->buck2_gpiodvs || pdata->buck3_gpiodvs ||
            pdata->buck4_gpiodvs) {
-                s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK2CTRL,
+                sec_reg_update(s5m8767->iodev, S5M8767_REG_BUCK2CTRL,
                                 (pdata->buck2_gpiodvs) ? (1 << 1) : (0 << 1),
                                 1 << 1);
-                s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK3CTRL,
+                sec_reg_update(s5m8767->iodev, S5M8767_REG_BUCK3CTRL,
                                 (pdata->buck3_gpiodvs) ? (1 << 1) : (0 << 1),
                                 1 << 1);
-                s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK4CTRL,
+                sec_reg_update(s5m8767->iodev, S5M8767_REG_BUCK4CTRL,
                                 (pdata->buck4_gpiodvs) ? (1 << 1) : (0 << 1),
                                 1 << 1);
         }
@@ -685,61 +685,61 @@ static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
         /* Initialize GPIO DVS registers */
         for (i = 0; i < 8; i++) {
                 if (s5m8767->buck2_gpiodvs) {
-                        s5m_reg_write(s5m8767->iodev, S5M8767_REG_BUCK2DVS1 + i,
+                        sec_reg_write(s5m8767->iodev, S5M8767_REG_BUCK2DVS1 + i,
                                            s5m8767->buck2_vol[i]);
                 }
 
                 if (s5m8767->buck3_gpiodvs) {
-                        s5m_reg_write(s5m8767->iodev, S5M8767_REG_BUCK3DVS1 + i,
+                        sec_reg_write(s5m8767->iodev, S5M8767_REG_BUCK3DVS1 + i,
                                            s5m8767->buck3_vol[i]);
                 }
 
                 if (s5m8767->buck4_gpiodvs) {
-                        s5m_reg_write(s5m8767->iodev, S5M8767_REG_BUCK4DVS1 + i,
+                        sec_reg_write(s5m8767->iodev, S5M8767_REG_BUCK4DVS1 + i,
                                            s5m8767->buck4_vol[i]);
                 }
         }
 
         if (s5m8767->buck2_ramp)
-                s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 0x08, 0x08);
+                sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 0x08, 0x08);
 
         if (s5m8767->buck3_ramp)
-                s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 0x04, 0x04);
+                sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 0x04, 0x04);
 
         if (s5m8767->buck4_ramp)
-                s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 0x02, 0x02);
+                sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 0x02, 0x02);
 
         if (s5m8767->buck2_ramp || s5m8767->buck3_ramp
                 || s5m8767->buck4_ramp) {
                 switch (s5m8767->ramp_delay) {
                 case 5:
-                        s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
+                        sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
                                         0x40, 0xf0);
                         break;
                 case 10:
-                        s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
+                        sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
                                         0x90, 0xf0);
                         break;
                 case 25:
-                        s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
+                        sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
                                         0xd0, 0xf0);
                         break;
                 case 50:
-                        s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
+                        sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
                                         0xe0, 0xf0);
                         break;
                 case 100:
-                        s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
+                        sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
                                         0xf0, 0xf0);
                         break;
                 default:
-                        s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
+                        sec_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
                                         0x90, 0xf0);
                 }
         }
 
         for (i = 0; i < pdata->num_regulators; i++) {
-                const struct s5m_voltage_desc *desc;
+                const struct sec_voltage_desc *desc;
                 int id = pdata->regulators[i].id;
 
                 desc = reg_voltage_map[id];