aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/mfd
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/mfd')
-rw-r--r--drivers/mfd/Kconfig25
-rw-r--r--drivers/mfd/Makefile4
-rw-r--r--drivers/mfd/ab8500-gpadc.c2
-rw-r--r--drivers/mfd/ab8500-sysctrl.c57
-rw-r--r--drivers/mfd/arizona-core.c4
-rw-r--r--drivers/mfd/arizona-spi.c2
-rw-r--r--drivers/mfd/atmel-hlcdc.c122
-rw-r--r--drivers/mfd/axp20x.c364
-rw-r--r--drivers/mfd/da9063-core.c4
-rw-r--r--drivers/mfd/db8500-prcmu.c22
-rw-r--r--drivers/mfd/dln2.c781
-rw-r--r--drivers/mfd/intel_soc_pmic_crc.c3
-rw-r--r--drivers/mfd/lpc_sch.c6
-rw-r--r--drivers/mfd/max14577.c2
-rw-r--r--drivers/mfd/max77693.c31
-rw-r--r--drivers/mfd/mfd-core.c8
-rw-r--r--drivers/mfd/rts5227.c6
-rw-r--r--drivers/mfd/rts5249.c4
-rw-r--r--drivers/mfd/rtsx_gops.c37
-rw-r--r--drivers/mfd/rtsx_pcr.h3
-rw-r--r--drivers/mfd/rtsx_usb.c4
-rw-r--r--drivers/mfd/sec-core.c39
-rw-r--r--drivers/mfd/sec-irq.c23
-rw-r--r--drivers/mfd/syscon.c96
-rw-r--r--drivers/mfd/t7l66xb.c14
-rw-r--r--drivers/mfd/tc3589x.c9
-rw-r--r--drivers/mfd/tc6387xb.c10
-rw-r--r--drivers/mfd/tc6393xb.c23
-rw-r--r--drivers/mfd/tps65090.c62
-rw-r--r--drivers/mfd/tps65217.c2
-rw-r--r--drivers/mfd/twl4030-power.c3
-rw-r--r--drivers/mfd/viperboard.c5
-rw-r--r--drivers/mfd/wm5102-tables.c6
-rw-r--r--drivers/mfd/wm5110-tables.c20
-rw-r--r--drivers/mfd/wm8350-core.c2
-rw-r--r--drivers/mfd/wm8994-core.c2
-rw-r--r--drivers/mfd/wm8997-tables.c6
37 files changed, 1570 insertions, 243 deletions
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index 1456ea70bbc7..2e6b7311fabc 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -59,6 +59,17 @@ config MFD_AAT2870_CORE
59 additional drivers must be enabled in order to use the 59 additional drivers must be enabled in order to use the
60 functionality of the device. 60 functionality of the device.
61 61
62config MFD_ATMEL_HLCDC
63 tristate "Atmel HLCDC (High-end LCD Controller)"
64 select MFD_CORE
65 select REGMAP_MMIO
66 depends on OF
67 help
68 If you say yes here you get support for the HLCDC block.
69 This driver provides common support for accessing the device,
70 additional drivers must be enabled in order to use the
71 functionality of the device.
72
62config MFD_BCM590XX 73config MFD_BCM590XX
63 tristate "Broadcom BCM590xx PMUs" 74 tristate "Broadcom BCM590xx PMUs"
64 select MFD_CORE 75 select MFD_CORE
@@ -74,7 +85,8 @@ config MFD_AXP20X
74 select REGMAP_IRQ 85 select REGMAP_IRQ
75 depends on I2C=y 86 depends on I2C=y
76 help 87 help
77 If you say Y here you get support for the X-Powers AXP202 and AXP209. 88 If you say Y here you get support for the X-Powers AXP202, AXP209 and
89 AXP288 power management IC (PMIC).
78 This driver include only the core APIs. You have to select individual 90 This driver include only the core APIs. You have to select individual
79 components like regulators or the PEK (Power Enable Key) under the 91 components like regulators or the PEK (Power Enable Key) under the
80 corresponding menus. 92 corresponding menus.
@@ -183,6 +195,16 @@ config MFD_DA9063
183 Additional drivers must be enabled in order to use the functionality 195 Additional drivers must be enabled in order to use the functionality
184 of the device. 196 of the device.
185 197
198config MFD_DLN2
199 tristate "Diolan DLN2 support"
200 select MFD_CORE
201 depends on USB
202 help
203 This adds support for Diolan USB-I2C/SPI/GPIO Master Adapter
204 DLN-2. Additional drivers such as I2C_DLN2, GPIO_DLN2,
205 etc. must be enabled in order to use the functionality of
206 the device.
207
186config MFD_MC13XXX 208config MFD_MC13XXX
187 tristate 209 tristate
188 depends on (SPI_MASTER || I2C) 210 depends on (SPI_MASTER || I2C)
@@ -655,7 +677,6 @@ config MFD_SEC_CORE
655 select MFD_CORE 677 select MFD_CORE
656 select REGMAP_I2C 678 select REGMAP_I2C
657 select REGMAP_IRQ 679 select REGMAP_IRQ
658 select REGULATOR
659 help 680 help
660 Support for the Samsung Electronics MFD series. 681 Support for the Samsung Electronics MFD series.
661 This driver provides common support for accessing the device, 682 This driver provides common support for accessing the device,
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 8bd54b1253af..53467e211381 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -13,7 +13,7 @@ obj-$(CONFIG_MFD_CROS_EC) += cros_ec.o
13obj-$(CONFIG_MFD_CROS_EC_I2C) += cros_ec_i2c.o 13obj-$(CONFIG_MFD_CROS_EC_I2C) += cros_ec_i2c.o
14obj-$(CONFIG_MFD_CROS_EC_SPI) += cros_ec_spi.o 14obj-$(CONFIG_MFD_CROS_EC_SPI) += cros_ec_spi.o
15 15
16rtsx_pci-objs := rtsx_pcr.o rts5209.o rts5229.o rtl8411.o rts5227.o rts5249.o 16rtsx_pci-objs := rtsx_pcr.o rtsx_gops.o rts5209.o rts5229.o rtl8411.o rts5227.o rts5249.o
17obj-$(CONFIG_MFD_RTSX_PCI) += rtsx_pci.o 17obj-$(CONFIG_MFD_RTSX_PCI) += rtsx_pci.o
18obj-$(CONFIG_MFD_RTSX_USB) += rtsx_usb.o 18obj-$(CONFIG_MFD_RTSX_USB) += rtsx_usb.o
19 19
@@ -157,6 +157,7 @@ obj-$(CONFIG_MFD_SPMI_PMIC) += qcom-spmi-pmic.o
157obj-$(CONFIG_TPS65911_COMPARATOR) += tps65911-comparator.o 157obj-$(CONFIG_TPS65911_COMPARATOR) += tps65911-comparator.o
158obj-$(CONFIG_MFD_TPS65090) += tps65090.o 158obj-$(CONFIG_MFD_TPS65090) += tps65090.o
159obj-$(CONFIG_MFD_AAT2870_CORE) += aat2870-core.o 159obj-$(CONFIG_MFD_AAT2870_CORE) += aat2870-core.o
160obj-$(CONFIG_MFD_ATMEL_HLCDC) += atmel-hlcdc.o
160obj-$(CONFIG_MFD_INTEL_MSIC) += intel_msic.o 161obj-$(CONFIG_MFD_INTEL_MSIC) += intel_msic.o
161obj-$(CONFIG_MFD_PALMAS) += palmas.o 162obj-$(CONFIG_MFD_PALMAS) += palmas.o
162obj-$(CONFIG_MFD_VIPERBOARD) += viperboard.o 163obj-$(CONFIG_MFD_VIPERBOARD) += viperboard.o
@@ -174,6 +175,7 @@ obj-$(CONFIG_MFD_STW481X) += stw481x.o
174obj-$(CONFIG_MFD_IPAQ_MICRO) += ipaq-micro.o 175obj-$(CONFIG_MFD_IPAQ_MICRO) += ipaq-micro.o
175obj-$(CONFIG_MFD_MENF21BMC) += menf21bmc.o 176obj-$(CONFIG_MFD_MENF21BMC) += menf21bmc.o
176obj-$(CONFIG_MFD_HI6421_PMIC) += hi6421-pmic-core.o 177obj-$(CONFIG_MFD_HI6421_PMIC) += hi6421-pmic-core.o
178obj-$(CONFIG_MFD_DLN2) += dln2.o
177 179
178intel-soc-pmic-objs := intel_soc_pmic_core.o intel_soc_pmic_crc.o 180intel-soc-pmic-objs := intel_soc_pmic_core.o intel_soc_pmic_crc.o
179obj-$(CONFIG_INTEL_SOC_PMIC) += intel-soc-pmic.o 181obj-$(CONFIG_INTEL_SOC_PMIC) += intel-soc-pmic.o
diff --git a/drivers/mfd/ab8500-gpadc.c b/drivers/mfd/ab8500-gpadc.c
index 36000f920981..8e3168d160b2 100644
--- a/drivers/mfd/ab8500-gpadc.c
+++ b/drivers/mfd/ab8500-gpadc.c
@@ -867,7 +867,7 @@ static void ab8500_gpadc_read_calibration_data(struct ab8500_gpadc *gpadc)
867 gpadc->cal_data[ADC_INPUT_VBAT].offset); 867 gpadc->cal_data[ADC_INPUT_VBAT].offset);
868} 868}
869 869
870#ifdef CONFIG_PM_RUNTIME 870#ifdef CONFIG_PM
871static int ab8500_gpadc_runtime_suspend(struct device *dev) 871static int ab8500_gpadc_runtime_suspend(struct device *dev)
872{ 872{
873 struct ab8500_gpadc *gpadc = dev_get_drvdata(dev); 873 struct ab8500_gpadc *gpadc = dev_get_drvdata(dev);
diff --git a/drivers/mfd/ab8500-sysctrl.c b/drivers/mfd/ab8500-sysctrl.c
index 8e0dae59844d..94dbcdd2a1ff 100644
--- a/drivers/mfd/ab8500-sysctrl.c
+++ b/drivers/mfd/ab8500-sysctrl.c
@@ -85,63 +85,6 @@ shutdown:
85 } 85 }
86} 86}
87 87
88/*
89 * Use the AB WD to reset the platform. It will perform a hard
90 * reset instead of a soft reset. Write the reset reason to
91 * the AB before reset, which can be read upon restart.
92 */
93void ab8500_restart(char mode, const char *cmd)
94{
95 struct ab8500_platform_data *plat;
96 struct ab8500_sysctrl_platform_data *pdata;
97 u16 reason = 0;
98 u8 val;
99
100 if (sysctrl_dev == NULL) {
101 pr_err("%s: sysctrl not initialized\n", __func__);
102 return;
103 }
104
105 plat = dev_get_platdata(sysctrl_dev->parent);
106 pdata = plat->sysctrl;
107 if (pdata && pdata->reboot_reason_code)
108 reason = pdata->reboot_reason_code(cmd);
109 else
110 pr_warn("[%s] No reboot reason set. Default reason %d\n",
111 __func__, reason);
112
113 /*
114 * Disable RTC alarm, just a precaution so that no alarm
115 * is running when WD reset is executed.
116 */
117 abx500_get_register_interruptible(sysctrl_dev, AB8500_RTC,
118 RTC_CTRL , &val);
119 abx500_set_register_interruptible(sysctrl_dev, AB8500_RTC,
120 RTC_CTRL , (val & ~RTC_ALARM_ENABLE));
121
122 /*
123 * Android is not using the RTC alarm registers during reboot
124 * so we borrow them for writing the reason of reset
125 */
126
127 /* reason[8 LSB] */
128 val = reason & 0xFF;
129 abx500_set_register_interruptible(sysctrl_dev, AB8500_RTC,
130 AB8500_ALARM_MIN_LOW , val);
131
132 /* reason[8 MSB] */
133 val = (reason>>8) & 0xFF;
134 abx500_set_register_interruptible(sysctrl_dev, AB8500_RTC,
135 AB8500_ALARM_MIN_MID , val);
136
137 /* Setting WD timeout to 0 */
138 ab8500_sysctrl_write(AB8500_MAINWDOGTIMER, 0xFF, 0x0);
139
140 /* Setting the parameters to AB8500 WD*/
141 ab8500_sysctrl_write(AB8500_MAINWDOGCTRL, 0xFF, (AB8500_ENABLE_WD |
142 AB8500_WD_RESTART_ON_EXPIRE | AB8500_KICK_WD));
143}
144
145static inline bool valid_bank(u8 bank) 88static inline bool valid_bank(u8 bank)
146{ 89{
147 return ((bank == AB8500_SYS_CTRL1_BLOCK) || 90 return ((bank == AB8500_SYS_CTRL1_BLOCK) ||
diff --git a/drivers/mfd/arizona-core.c b/drivers/mfd/arizona-core.c
index bce7c0784b6b..09ba8f186e6a 100644
--- a/drivers/mfd/arizona-core.c
+++ b/drivers/mfd/arizona-core.c
@@ -330,7 +330,7 @@ err_fll:
330 return err; 330 return err;
331} 331}
332 332
333#ifdef CONFIG_PM_RUNTIME 333#ifdef CONFIG_PM
334static int arizona_runtime_resume(struct device *dev) 334static int arizona_runtime_resume(struct device *dev)
335{ 335{
336 struct arizona *arizona = dev_get_drvdata(dev); 336 struct arizona *arizona = dev_get_drvdata(dev);
@@ -1024,7 +1024,7 @@ int arizona_dev_init(struct arizona *arizona)
1024 goto err_irq; 1024 goto err_irq;
1025 } 1025 }
1026 1026
1027#ifdef CONFIG_PM_RUNTIME 1027#ifdef CONFIG_PM
1028 regulator_disable(arizona->dcvdd); 1028 regulator_disable(arizona->dcvdd);
1029#endif 1029#endif
1030 1030
diff --git a/drivers/mfd/arizona-spi.c b/drivers/mfd/arizona-spi.c
index 5145d78bf07e..8ef58bcff193 100644
--- a/drivers/mfd/arizona-spi.c
+++ b/drivers/mfd/arizona-spi.c
@@ -75,7 +75,9 @@ static int arizona_spi_probe(struct spi_device *spi)
75static int arizona_spi_remove(struct spi_device *spi) 75static int arizona_spi_remove(struct spi_device *spi)
76{ 76{
77 struct arizona *arizona = spi_get_drvdata(spi); 77 struct arizona *arizona = spi_get_drvdata(spi);
78
78 arizona_dev_exit(arizona); 79 arizona_dev_exit(arizona);
80
79 return 0; 81 return 0;
80} 82}
81 83
diff --git a/drivers/mfd/atmel-hlcdc.c b/drivers/mfd/atmel-hlcdc.c
new file mode 100644
index 000000000000..cfd58f4cc5c3
--- /dev/null
+++ b/drivers/mfd/atmel-hlcdc.c
@@ -0,0 +1,122 @@
1/*
2 * Copyright (C) 2014 Free Electrons
3 * Copyright (C) 2014 Atmel
4 *
5 * Author: Boris BREZILLON <boris.brezillon@free-electrons.com>
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License version 2 as published by
9 * the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along with
17 * this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20#include <linux/clk.h>
21#include <linux/mfd/atmel-hlcdc.h>
22#include <linux/mfd/core.h>
23#include <linux/module.h>
24#include <linux/platform_device.h>
25#include <linux/regmap.h>
26
27#define ATMEL_HLCDC_REG_MAX (0x4000 - 0x4)
28
29static const struct mfd_cell atmel_hlcdc_cells[] = {
30 {
31 .name = "atmel-hlcdc-pwm",
32 .of_compatible = "atmel,hlcdc-pwm",
33 },
34 {
35 .name = "atmel-hlcdc-dc",
36 .of_compatible = "atmel,hlcdc-display-controller",
37 },
38};
39
40static const struct regmap_config atmel_hlcdc_regmap_config = {
41 .reg_bits = 32,
42 .val_bits = 32,
43 .reg_stride = 4,
44 .max_register = ATMEL_HLCDC_REG_MAX,
45};
46
47static int atmel_hlcdc_probe(struct platform_device *pdev)
48{
49 struct device *dev = &pdev->dev;
50 struct atmel_hlcdc *hlcdc;
51 struct resource *res;
52 void __iomem *regs;
53
54 hlcdc = devm_kzalloc(dev, sizeof(*hlcdc), GFP_KERNEL);
55 if (!hlcdc)
56 return -ENOMEM;
57
58 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
59 regs = devm_ioremap_resource(dev, res);
60 if (IS_ERR(regs))
61 return PTR_ERR(regs);
62
63 hlcdc->irq = platform_get_irq(pdev, 0);
64 if (hlcdc->irq < 0)
65 return hlcdc->irq;
66
67 hlcdc->periph_clk = devm_clk_get(dev, "periph_clk");
68 if (IS_ERR(hlcdc->periph_clk)) {
69 dev_err(dev, "failed to get peripheral clock\n");
70 return PTR_ERR(hlcdc->periph_clk);
71 }
72
73 hlcdc->sys_clk = devm_clk_get(dev, "sys_clk");
74 if (IS_ERR(hlcdc->sys_clk)) {
75 dev_err(dev, "failed to get system clock\n");
76 return PTR_ERR(hlcdc->sys_clk);
77 }
78
79 hlcdc->slow_clk = devm_clk_get(dev, "slow_clk");
80 if (IS_ERR(hlcdc->slow_clk)) {
81 dev_err(dev, "failed to get slow clock\n");
82 return PTR_ERR(hlcdc->slow_clk);
83 }
84
85 hlcdc->regmap = devm_regmap_init_mmio(dev, regs,
86 &atmel_hlcdc_regmap_config);
87 if (IS_ERR(hlcdc->regmap))
88 return PTR_ERR(hlcdc->regmap);
89
90 dev_set_drvdata(dev, hlcdc);
91
92 return mfd_add_devices(dev, -1, atmel_hlcdc_cells,
93 ARRAY_SIZE(atmel_hlcdc_cells),
94 NULL, 0, NULL);
95}
96
97static int atmel_hlcdc_remove(struct platform_device *pdev)
98{
99 mfd_remove_devices(&pdev->dev);
100
101 return 0;
102}
103
104static const struct of_device_id atmel_hlcdc_match[] = {
105 { .compatible = "atmel,sama5d3-hlcdc" },
106 { /* sentinel */ },
107};
108
109static struct platform_driver atmel_hlcdc_driver = {
110 .probe = atmel_hlcdc_probe,
111 .remove = atmel_hlcdc_remove,
112 .driver = {
113 .name = "atmel-hlcdc",
114 .of_match_table = atmel_hlcdc_match,
115 },
116};
117module_platform_driver(atmel_hlcdc_driver);
118
119MODULE_ALIAS("platform:atmel-hlcdc");
120MODULE_AUTHOR("Boris Brezillon <boris.brezillon@free-electrons.com>");
121MODULE_DESCRIPTION("Atmel HLCDC driver");
122MODULE_LICENSE("GPL v2");
diff --git a/drivers/mfd/axp20x.c b/drivers/mfd/axp20x.c
index 6231adbb295d..b1b580a88654 100644
--- a/drivers/mfd/axp20x.c
+++ b/drivers/mfd/axp20x.c
@@ -1,9 +1,9 @@
1/* 1/*
2 * axp20x.c - MFD core driver for the X-Powers AXP202 and AXP209 2 * axp20x.c - MFD core driver for the X-Powers' Power Management ICs
3 * 3 *
4 * AXP20x comprises an adaptive USB-Compatible PWM charger, 2 BUCK DC-DC 4 * AXP20x typically comprises an adaptive USB-Compatible PWM charger, BUCK DC-DC
5 * converters, 5 LDOs, multiple 12-bit ADCs of voltage, current and temperature 5 * converters, LDOs, multiple 12-bit ADCs of voltage, current and temperature
6 * as well as 4 configurable GPIOs. 6 * as well as configurable GPIOs.
7 * 7 *
8 * Author: Carlo Caione <carlo@caione.org> 8 * Author: Carlo Caione <carlo@caione.org>
9 * 9 *
@@ -25,9 +25,16 @@
25#include <linux/mfd/core.h> 25#include <linux/mfd/core.h>
26#include <linux/of_device.h> 26#include <linux/of_device.h>
27#include <linux/of_irq.h> 27#include <linux/of_irq.h>
28#include <linux/acpi.h>
28 29
29#define AXP20X_OFF 0x80 30#define AXP20X_OFF 0x80
30 31
32static const char const *axp20x_model_names[] = {
33 "AXP202",
34 "AXP209",
35 "AXP288",
36};
37
31static const struct regmap_range axp20x_writeable_ranges[] = { 38static const struct regmap_range axp20x_writeable_ranges[] = {
32 regmap_reg_range(AXP20X_DATACACHE(0), AXP20X_IRQ5_STATE), 39 regmap_reg_range(AXP20X_DATACACHE(0), AXP20X_IRQ5_STATE),
33 regmap_reg_range(AXP20X_DCDC_MODE, AXP20X_FG_RES), 40 regmap_reg_range(AXP20X_DCDC_MODE, AXP20X_FG_RES),
@@ -47,6 +54,25 @@ static const struct regmap_access_table axp20x_volatile_table = {
47 .n_yes_ranges = ARRAY_SIZE(axp20x_volatile_ranges), 54 .n_yes_ranges = ARRAY_SIZE(axp20x_volatile_ranges),
48}; 55};
49 56
57static const struct regmap_range axp288_writeable_ranges[] = {
58 regmap_reg_range(AXP20X_DATACACHE(0), AXP20X_IRQ6_STATE),
59 regmap_reg_range(AXP20X_DCDC_MODE, AXP288_FG_TUNE5),
60};
61
62static const struct regmap_range axp288_volatile_ranges[] = {
63 regmap_reg_range(AXP20X_IRQ1_EN, AXP20X_IPSOUT_V_HIGH_L),
64};
65
66static const struct regmap_access_table axp288_writeable_table = {
67 .yes_ranges = axp288_writeable_ranges,
68 .n_yes_ranges = ARRAY_SIZE(axp288_writeable_ranges),
69};
70
71static const struct regmap_access_table axp288_volatile_table = {
72 .yes_ranges = axp288_volatile_ranges,
73 .n_yes_ranges = ARRAY_SIZE(axp288_volatile_ranges),
74};
75
50static struct resource axp20x_pek_resources[] = { 76static struct resource axp20x_pek_resources[] = {
51 { 77 {
52 .name = "PEK_DBR", 78 .name = "PEK_DBR",
@@ -61,6 +87,39 @@ static struct resource axp20x_pek_resources[] = {
61 }, 87 },
62}; 88};
63 89
90static struct resource axp288_battery_resources[] = {
91 {
92 .start = AXP288_IRQ_QWBTU,
93 .end = AXP288_IRQ_QWBTU,
94 .flags = IORESOURCE_IRQ,
95 },
96 {
97 .start = AXP288_IRQ_WBTU,
98 .end = AXP288_IRQ_WBTU,
99 .flags = IORESOURCE_IRQ,
100 },
101 {
102 .start = AXP288_IRQ_QWBTO,
103 .end = AXP288_IRQ_QWBTO,
104 .flags = IORESOURCE_IRQ,
105 },
106 {
107 .start = AXP288_IRQ_WBTO,
108 .end = AXP288_IRQ_WBTO,
109 .flags = IORESOURCE_IRQ,
110 },
111 {
112 .start = AXP288_IRQ_WL2,
113 .end = AXP288_IRQ_WL2,
114 .flags = IORESOURCE_IRQ,
115 },
116 {
117 .start = AXP288_IRQ_WL1,
118 .end = AXP288_IRQ_WL1,
119 .flags = IORESOURCE_IRQ,
120 },
121};
122
64static const struct regmap_config axp20x_regmap_config = { 123static const struct regmap_config axp20x_regmap_config = {
65 .reg_bits = 8, 124 .reg_bits = 8,
66 .val_bits = 8, 125 .val_bits = 8,
@@ -70,47 +129,96 @@ static const struct regmap_config axp20x_regmap_config = {
70 .cache_type = REGCACHE_RBTREE, 129 .cache_type = REGCACHE_RBTREE,
71}; 130};
72 131
73#define AXP20X_IRQ(_irq, _off, _mask) \ 132static const struct regmap_config axp288_regmap_config = {
74 [AXP20X_IRQ_##_irq] = { .reg_offset = (_off), .mask = BIT(_mask) } 133 .reg_bits = 8,
134 .val_bits = 8,
135 .wr_table = &axp288_writeable_table,
136 .volatile_table = &axp288_volatile_table,
137 .max_register = AXP288_FG_TUNE5,
138 .cache_type = REGCACHE_RBTREE,
139};
140
141#define INIT_REGMAP_IRQ(_variant, _irq, _off, _mask) \
142 [_variant##_IRQ_##_irq] = { .reg_offset = (_off), .mask = BIT(_mask) }
75 143
76static const struct regmap_irq axp20x_regmap_irqs[] = { 144static const struct regmap_irq axp20x_regmap_irqs[] = {
77 AXP20X_IRQ(ACIN_OVER_V, 0, 7), 145 INIT_REGMAP_IRQ(AXP20X, ACIN_OVER_V, 0, 7),
78 AXP20X_IRQ(ACIN_PLUGIN, 0, 6), 146 INIT_REGMAP_IRQ(AXP20X, ACIN_PLUGIN, 0, 6),
79 AXP20X_IRQ(ACIN_REMOVAL, 0, 5), 147 INIT_REGMAP_IRQ(AXP20X, ACIN_REMOVAL, 0, 5),
80 AXP20X_IRQ(VBUS_OVER_V, 0, 4), 148 INIT_REGMAP_IRQ(AXP20X, VBUS_OVER_V, 0, 4),
81 AXP20X_IRQ(VBUS_PLUGIN, 0, 3), 149 INIT_REGMAP_IRQ(AXP20X, VBUS_PLUGIN, 0, 3),
82 AXP20X_IRQ(VBUS_REMOVAL, 0, 2), 150 INIT_REGMAP_IRQ(AXP20X, VBUS_REMOVAL, 0, 2),
83 AXP20X_IRQ(VBUS_V_LOW, 0, 1), 151 INIT_REGMAP_IRQ(AXP20X, VBUS_V_LOW, 0, 1),
84 AXP20X_IRQ(BATT_PLUGIN, 1, 7), 152 INIT_REGMAP_IRQ(AXP20X, BATT_PLUGIN, 1, 7),
85 AXP20X_IRQ(BATT_REMOVAL, 1, 6), 153 INIT_REGMAP_IRQ(AXP20X, BATT_REMOVAL, 1, 6),
86 AXP20X_IRQ(BATT_ENT_ACT_MODE, 1, 5), 154 INIT_REGMAP_IRQ(AXP20X, BATT_ENT_ACT_MODE, 1, 5),
87 AXP20X_IRQ(BATT_EXIT_ACT_MODE, 1, 4), 155 INIT_REGMAP_IRQ(AXP20X, BATT_EXIT_ACT_MODE, 1, 4),
88 AXP20X_IRQ(CHARG, 1, 3), 156 INIT_REGMAP_IRQ(AXP20X, CHARG, 1, 3),
89 AXP20X_IRQ(CHARG_DONE, 1, 2), 157 INIT_REGMAP_IRQ(AXP20X, CHARG_DONE, 1, 2),
90 AXP20X_IRQ(BATT_TEMP_HIGH, 1, 1), 158 INIT_REGMAP_IRQ(AXP20X, BATT_TEMP_HIGH, 1, 1),
91 AXP20X_IRQ(BATT_TEMP_LOW, 1, 0), 159 INIT_REGMAP_IRQ(AXP20X, BATT_TEMP_LOW, 1, 0),
92 AXP20X_IRQ(DIE_TEMP_HIGH, 2, 7), 160 INIT_REGMAP_IRQ(AXP20X, DIE_TEMP_HIGH, 2, 7),
93 AXP20X_IRQ(CHARG_I_LOW, 2, 6), 161 INIT_REGMAP_IRQ(AXP20X, CHARG_I_LOW, 2, 6),
94 AXP20X_IRQ(DCDC1_V_LONG, 2, 5), 162 INIT_REGMAP_IRQ(AXP20X, DCDC1_V_LONG, 2, 5),
95 AXP20X_IRQ(DCDC2_V_LONG, 2, 4), 163 INIT_REGMAP_IRQ(AXP20X, DCDC2_V_LONG, 2, 4),
96 AXP20X_IRQ(DCDC3_V_LONG, 2, 3), 164 INIT_REGMAP_IRQ(AXP20X, DCDC3_V_LONG, 2, 3),
97 AXP20X_IRQ(PEK_SHORT, 2, 1), 165 INIT_REGMAP_IRQ(AXP20X, PEK_SHORT, 2, 1),
98 AXP20X_IRQ(PEK_LONG, 2, 0), 166 INIT_REGMAP_IRQ(AXP20X, PEK_LONG, 2, 0),
99 AXP20X_IRQ(N_OE_PWR_ON, 3, 7), 167 INIT_REGMAP_IRQ(AXP20X, N_OE_PWR_ON, 3, 7),
100 AXP20X_IRQ(N_OE_PWR_OFF, 3, 6), 168 INIT_REGMAP_IRQ(AXP20X, N_OE_PWR_OFF, 3, 6),
101 AXP20X_IRQ(VBUS_VALID, 3, 5), 169 INIT_REGMAP_IRQ(AXP20X, VBUS_VALID, 3, 5),
102 AXP20X_IRQ(VBUS_NOT_VALID, 3, 4), 170 INIT_REGMAP_IRQ(AXP20X, VBUS_NOT_VALID, 3, 4),
103 AXP20X_IRQ(VBUS_SESS_VALID, 3, 3), 171 INIT_REGMAP_IRQ(AXP20X, VBUS_SESS_VALID, 3, 3),
104 AXP20X_IRQ(VBUS_SESS_END, 3, 2), 172 INIT_REGMAP_IRQ(AXP20X, VBUS_SESS_END, 3, 2),
105 AXP20X_IRQ(LOW_PWR_LVL1, 3, 1), 173 INIT_REGMAP_IRQ(AXP20X, LOW_PWR_LVL1, 3, 1),
106 AXP20X_IRQ(LOW_PWR_LVL2, 3, 0), 174 INIT_REGMAP_IRQ(AXP20X, LOW_PWR_LVL2, 3, 0),
107 AXP20X_IRQ(TIMER, 4, 7), 175 INIT_REGMAP_IRQ(AXP20X, TIMER, 4, 7),
108 AXP20X_IRQ(PEK_RIS_EDGE, 4, 6), 176 INIT_REGMAP_IRQ(AXP20X, PEK_RIS_EDGE, 4, 6),
109 AXP20X_IRQ(PEK_FAL_EDGE, 4, 5), 177 INIT_REGMAP_IRQ(AXP20X, PEK_FAL_EDGE, 4, 5),
110 AXP20X_IRQ(GPIO3_INPUT, 4, 3), 178 INIT_REGMAP_IRQ(AXP20X, GPIO3_INPUT, 4, 3),
111 AXP20X_IRQ(GPIO2_INPUT, 4, 2), 179 INIT_REGMAP_IRQ(AXP20X, GPIO2_INPUT, 4, 2),
112 AXP20X_IRQ(GPIO1_INPUT, 4, 1), 180 INIT_REGMAP_IRQ(AXP20X, GPIO1_INPUT, 4, 1),
113 AXP20X_IRQ(GPIO0_INPUT, 4, 0), 181 INIT_REGMAP_IRQ(AXP20X, GPIO0_INPUT, 4, 0),
182};
183
184/* some IRQs are compatible with axp20x models */
185static const struct regmap_irq axp288_regmap_irqs[] = {
186 INIT_REGMAP_IRQ(AXP288, VBUS_FALL, 0, 2),
187 INIT_REGMAP_IRQ(AXP288, VBUS_RISE, 0, 3),
188 INIT_REGMAP_IRQ(AXP288, OV, 0, 4),
189
190 INIT_REGMAP_IRQ(AXP288, DONE, 1, 2),
191 INIT_REGMAP_IRQ(AXP288, CHARGING, 1, 3),
192 INIT_REGMAP_IRQ(AXP288, SAFE_QUIT, 1, 4),
193 INIT_REGMAP_IRQ(AXP288, SAFE_ENTER, 1, 5),
194 INIT_REGMAP_IRQ(AXP288, ABSENT, 1, 6),
195 INIT_REGMAP_IRQ(AXP288, APPEND, 1, 7),
196
197 INIT_REGMAP_IRQ(AXP288, QWBTU, 2, 0),
198 INIT_REGMAP_IRQ(AXP288, WBTU, 2, 1),
199 INIT_REGMAP_IRQ(AXP288, QWBTO, 2, 2),
200 INIT_REGMAP_IRQ(AXP288, WBTO, 2, 3),
201 INIT_REGMAP_IRQ(AXP288, QCBTU, 2, 4),
202 INIT_REGMAP_IRQ(AXP288, CBTU, 2, 5),
203 INIT_REGMAP_IRQ(AXP288, QCBTO, 2, 6),
204 INIT_REGMAP_IRQ(AXP288, CBTO, 2, 7),
205
206 INIT_REGMAP_IRQ(AXP288, WL2, 3, 0),
207 INIT_REGMAP_IRQ(AXP288, WL1, 3, 1),
208 INIT_REGMAP_IRQ(AXP288, GPADC, 3, 2),
209 INIT_REGMAP_IRQ(AXP288, OT, 3, 7),
210
211 INIT_REGMAP_IRQ(AXP288, GPIO0, 4, 0),
212 INIT_REGMAP_IRQ(AXP288, GPIO1, 4, 1),
213 INIT_REGMAP_IRQ(AXP288, POKO, 4, 2),
214 INIT_REGMAP_IRQ(AXP288, POKL, 4, 3),
215 INIT_REGMAP_IRQ(AXP288, POKS, 4, 4),
216 INIT_REGMAP_IRQ(AXP288, POKN, 4, 5),
217 INIT_REGMAP_IRQ(AXP288, POKP, 4, 6),
218 INIT_REGMAP_IRQ(AXP288, TIMER, 4, 7),
219
220 INIT_REGMAP_IRQ(AXP288, MV_CHNG, 5, 0),
221 INIT_REGMAP_IRQ(AXP288, BC_USB_CHNG, 5, 1),
114}; 222};
115 223
116static const struct of_device_id axp20x_of_match[] = { 224static const struct of_device_id axp20x_of_match[] = {
@@ -128,16 +236,39 @@ static const struct i2c_device_id axp20x_i2c_id[] = {
128}; 236};
129MODULE_DEVICE_TABLE(i2c, axp20x_i2c_id); 237MODULE_DEVICE_TABLE(i2c, axp20x_i2c_id);
130 238
239static const struct acpi_device_id axp20x_acpi_match[] = {
240 {
241 .id = "INT33F4",
242 .driver_data = AXP288_ID,
243 },
244 { },
245};
246MODULE_DEVICE_TABLE(acpi, axp20x_acpi_match);
247
131static const struct regmap_irq_chip axp20x_regmap_irq_chip = { 248static const struct regmap_irq_chip axp20x_regmap_irq_chip = {
132 .name = "axp20x_irq_chip", 249 .name = "axp20x_irq_chip",
133 .status_base = AXP20X_IRQ1_STATE, 250 .status_base = AXP20X_IRQ1_STATE,
134 .ack_base = AXP20X_IRQ1_STATE, 251 .ack_base = AXP20X_IRQ1_STATE,
135 .mask_base = AXP20X_IRQ1_EN, 252 .mask_base = AXP20X_IRQ1_EN,
136 .num_regs = 5, 253 .mask_invert = true,
254 .init_ack_masked = true,
137 .irqs = axp20x_regmap_irqs, 255 .irqs = axp20x_regmap_irqs,
138 .num_irqs = ARRAY_SIZE(axp20x_regmap_irqs), 256 .num_irqs = ARRAY_SIZE(axp20x_regmap_irqs),
257 .num_regs = 5,
258
259};
260
261static const struct regmap_irq_chip axp288_regmap_irq_chip = {
262 .name = "axp288_irq_chip",
263 .status_base = AXP20X_IRQ1_STATE,
264 .ack_base = AXP20X_IRQ1_STATE,
265 .mask_base = AXP20X_IRQ1_EN,
139 .mask_invert = true, 266 .mask_invert = true,
140 .init_ack_masked = true, 267 .init_ack_masked = true,
268 .irqs = axp288_regmap_irqs,
269 .num_irqs = ARRAY_SIZE(axp288_regmap_irqs),
270 .num_regs = 6,
271
141}; 272};
142 273
143static struct mfd_cell axp20x_cells[] = { 274static struct mfd_cell axp20x_cells[] = {
@@ -150,36 +281,158 @@ static struct mfd_cell axp20x_cells[] = {
150 }, 281 },
151}; 282};
152 283
284static struct resource axp288_adc_resources[] = {
285 {
286 .name = "GPADC",
287 .start = AXP288_IRQ_GPADC,
288 .end = AXP288_IRQ_GPADC,
289 .flags = IORESOURCE_IRQ,
290 },
291};
292
293static struct resource axp288_charger_resources[] = {
294 {
295 .start = AXP288_IRQ_OV,
296 .end = AXP288_IRQ_OV,
297 .flags = IORESOURCE_IRQ,
298 },
299 {
300 .start = AXP288_IRQ_DONE,
301 .end = AXP288_IRQ_DONE,
302 .flags = IORESOURCE_IRQ,
303 },
304 {
305 .start = AXP288_IRQ_CHARGING,
306 .end = AXP288_IRQ_CHARGING,
307 .flags = IORESOURCE_IRQ,
308 },
309 {
310 .start = AXP288_IRQ_SAFE_QUIT,
311 .end = AXP288_IRQ_SAFE_QUIT,
312 .flags = IORESOURCE_IRQ,
313 },
314 {
315 .start = AXP288_IRQ_SAFE_ENTER,
316 .end = AXP288_IRQ_SAFE_ENTER,
317 .flags = IORESOURCE_IRQ,
318 },
319 {
320 .start = AXP288_IRQ_QCBTU,
321 .end = AXP288_IRQ_QCBTU,
322 .flags = IORESOURCE_IRQ,
323 },
324 {
325 .start = AXP288_IRQ_CBTU,
326 .end = AXP288_IRQ_CBTU,
327 .flags = IORESOURCE_IRQ,
328 },
329 {
330 .start = AXP288_IRQ_QCBTO,
331 .end = AXP288_IRQ_QCBTO,
332 .flags = IORESOURCE_IRQ,
333 },
334 {
335 .start = AXP288_IRQ_CBTO,
336 .end = AXP288_IRQ_CBTO,
337 .flags = IORESOURCE_IRQ,
338 },
339};
340
341static struct mfd_cell axp288_cells[] = {
342 {
343 .name = "axp288_adc",
344 .num_resources = ARRAY_SIZE(axp288_adc_resources),
345 .resources = axp288_adc_resources,
346 },
347 {
348 .name = "axp288_charger",
349 .num_resources = ARRAY_SIZE(axp288_charger_resources),
350 .resources = axp288_charger_resources,
351 },
352 {
353 .name = "axp288_battery",
354 .num_resources = ARRAY_SIZE(axp288_battery_resources),
355 .resources = axp288_battery_resources,
356 },
357 {
358 .name = "axp288_pmic_acpi",
359 },
360};
361
153static struct axp20x_dev *axp20x_pm_power_off; 362static struct axp20x_dev *axp20x_pm_power_off;
154static void axp20x_power_off(void) 363static void axp20x_power_off(void)
155{ 364{
365 if (axp20x_pm_power_off->variant == AXP288_ID)
366 return;
367
156 regmap_write(axp20x_pm_power_off->regmap, AXP20X_OFF_CTRL, 368 regmap_write(axp20x_pm_power_off->regmap, AXP20X_OFF_CTRL,
157 AXP20X_OFF); 369 AXP20X_OFF);
158} 370}
159 371
372static int axp20x_match_device(struct axp20x_dev *axp20x, struct device *dev)
373{
374 const struct acpi_device_id *acpi_id;
375 const struct of_device_id *of_id;
376
377 if (dev->of_node) {
378 of_id = of_match_device(axp20x_of_match, dev);
379 if (!of_id) {
380 dev_err(dev, "Unable to match OF ID\n");
381 return -ENODEV;
382 }
383 axp20x->variant = (long) of_id->data;
384 } else {
385 acpi_id = acpi_match_device(dev->driver->acpi_match_table, dev);
386 if (!acpi_id || !acpi_id->driver_data) {
387 dev_err(dev, "Unable to match ACPI ID and data\n");
388 return -ENODEV;
389 }
390 axp20x->variant = (long) acpi_id->driver_data;
391 }
392
393 switch (axp20x->variant) {
394 case AXP202_ID:
395 case AXP209_ID:
396 axp20x->nr_cells = ARRAY_SIZE(axp20x_cells);
397 axp20x->cells = axp20x_cells;
398 axp20x->regmap_cfg = &axp20x_regmap_config;
399 axp20x->regmap_irq_chip = &axp20x_regmap_irq_chip;
400 break;
401 case AXP288_ID:
402 axp20x->cells = axp288_cells;
403 axp20x->nr_cells = ARRAY_SIZE(axp288_cells);
404 axp20x->regmap_cfg = &axp288_regmap_config;
405 axp20x->regmap_irq_chip = &axp288_regmap_irq_chip;
406 break;
407 default:
408 dev_err(dev, "unsupported AXP20X ID %lu\n", axp20x->variant);
409 return -EINVAL;
410 }
411 dev_info(dev, "AXP20x variant %s found\n",
412 axp20x_model_names[axp20x->variant]);
413
414 return 0;
415}
416
160static int axp20x_i2c_probe(struct i2c_client *i2c, 417static int axp20x_i2c_probe(struct i2c_client *i2c,
161 const struct i2c_device_id *id) 418 const struct i2c_device_id *id)
162{ 419{
163 struct axp20x_dev *axp20x; 420 struct axp20x_dev *axp20x;
164 const struct of_device_id *of_id;
165 int ret; 421 int ret;
166 422
167 axp20x = devm_kzalloc(&i2c->dev, sizeof(*axp20x), GFP_KERNEL); 423 axp20x = devm_kzalloc(&i2c->dev, sizeof(*axp20x), GFP_KERNEL);
168 if (!axp20x) 424 if (!axp20x)
169 return -ENOMEM; 425 return -ENOMEM;
170 426
171 of_id = of_match_device(axp20x_of_match, &i2c->dev); 427 ret = axp20x_match_device(axp20x, &i2c->dev);
172 if (!of_id) { 428 if (ret)
173 dev_err(&i2c->dev, "Unable to setup AXP20X data\n"); 429 return ret;
174 return -ENODEV;
175 }
176 axp20x->variant = (long) of_id->data;
177 430
178 axp20x->i2c_client = i2c; 431 axp20x->i2c_client = i2c;
179 axp20x->dev = &i2c->dev; 432 axp20x->dev = &i2c->dev;
180 dev_set_drvdata(axp20x->dev, axp20x); 433 dev_set_drvdata(axp20x->dev, axp20x);
181 434
182 axp20x->regmap = devm_regmap_init_i2c(i2c, &axp20x_regmap_config); 435 axp20x->regmap = devm_regmap_init_i2c(i2c, axp20x->regmap_cfg);
183 if (IS_ERR(axp20x->regmap)) { 436 if (IS_ERR(axp20x->regmap)) {
184 ret = PTR_ERR(axp20x->regmap); 437 ret = PTR_ERR(axp20x->regmap);
185 dev_err(&i2c->dev, "regmap init failed: %d\n", ret); 438 dev_err(&i2c->dev, "regmap init failed: %d\n", ret);
@@ -188,15 +441,15 @@ static int axp20x_i2c_probe(struct i2c_client *i2c,
188 441
189 ret = regmap_add_irq_chip(axp20x->regmap, i2c->irq, 442 ret = regmap_add_irq_chip(axp20x->regmap, i2c->irq,
190 IRQF_ONESHOT | IRQF_SHARED, -1, 443 IRQF_ONESHOT | IRQF_SHARED, -1,
191 &axp20x_regmap_irq_chip, 444 axp20x->regmap_irq_chip,
192 &axp20x->regmap_irqc); 445 &axp20x->regmap_irqc);
193 if (ret) { 446 if (ret) {
194 dev_err(&i2c->dev, "failed to add irq chip: %d\n", ret); 447 dev_err(&i2c->dev, "failed to add irq chip: %d\n", ret);
195 return ret; 448 return ret;
196 } 449 }
197 450
198 ret = mfd_add_devices(axp20x->dev, -1, axp20x_cells, 451 ret = mfd_add_devices(axp20x->dev, -1, axp20x->cells,
199 ARRAY_SIZE(axp20x_cells), NULL, 0, NULL); 452 axp20x->nr_cells, NULL, 0, NULL);
200 453
201 if (ret) { 454 if (ret) {
202 dev_err(&i2c->dev, "failed to add MFD devices: %d\n", ret); 455 dev_err(&i2c->dev, "failed to add MFD devices: %d\n", ret);
@@ -234,6 +487,7 @@ static struct i2c_driver axp20x_i2c_driver = {
234 .name = "axp20x", 487 .name = "axp20x",
235 .owner = THIS_MODULE, 488 .owner = THIS_MODULE,
236 .of_match_table = of_match_ptr(axp20x_of_match), 489 .of_match_table = of_match_ptr(axp20x_of_match),
490 .acpi_match_table = ACPI_PTR(axp20x_acpi_match),
237 }, 491 },
238 .probe = axp20x_i2c_probe, 492 .probe = axp20x_i2c_probe,
239 .remove = axp20x_i2c_remove, 493 .remove = axp20x_i2c_remove,
diff --git a/drivers/mfd/da9063-core.c b/drivers/mfd/da9063-core.c
index 93db8bb8c8f0..f38bc98a3c57 100644
--- a/drivers/mfd/da9063-core.c
+++ b/drivers/mfd/da9063-core.c
@@ -118,7 +118,7 @@ int da9063_device_init(struct da9063 *da9063, unsigned int irq)
118 da9063->irq_base = pdata->irq_base; 118 da9063->irq_base = pdata->irq_base;
119 } else { 119 } else {
120 da9063->flags = 0; 120 da9063->flags = 0;
121 da9063->irq_base = 0; 121 da9063->irq_base = -1;
122 } 122 }
123 da9063->chip_irq = irq; 123 da9063->chip_irq = irq;
124 124
@@ -168,6 +168,8 @@ int da9063_device_init(struct da9063 *da9063, unsigned int irq)
168 return ret; 168 return ret;
169 } 169 }
170 170
171 da9063->irq_base = regmap_irq_chip_get_base(da9063->regmap_irq);
172
171 ret = mfd_add_devices(da9063->dev, -1, da9063_devs, 173 ret = mfd_add_devices(da9063->dev, -1, da9063_devs,
172 ARRAY_SIZE(da9063_devs), NULL, da9063->irq_base, 174 ARRAY_SIZE(da9063_devs), NULL, da9063->irq_base,
173 NULL); 175 NULL);
diff --git a/drivers/mfd/db8500-prcmu.c b/drivers/mfd/db8500-prcmu.c
index 193cf168ba84..a8204730f01c 100644
--- a/drivers/mfd/db8500-prcmu.c
+++ b/drivers/mfd/db8500-prcmu.c
@@ -3150,23 +3150,28 @@ static int db8500_prcmu_probe(struct platform_device *pdev)
3150 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "prcmu"); 3150 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "prcmu");
3151 if (!res) { 3151 if (!res) {
3152 dev_err(&pdev->dev, "no prcmu memory region provided\n"); 3152 dev_err(&pdev->dev, "no prcmu memory region provided\n");
3153 return -ENOENT; 3153 return -EINVAL;
3154 } 3154 }
3155 prcmu_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); 3155 prcmu_base = devm_ioremap(&pdev->dev, res->start, resource_size(res));
3156 if (!prcmu_base) { 3156 if (!prcmu_base) {
3157 dev_err(&pdev->dev, 3157 dev_err(&pdev->dev,
3158 "failed to ioremap prcmu register memory\n"); 3158 "failed to ioremap prcmu register memory\n");
3159 return -ENOENT; 3159 return -ENOMEM;
3160 } 3160 }
3161 init_prcm_registers(); 3161 init_prcm_registers();
3162 dbx500_fw_version_init(pdev, pdata->version_offset); 3162 dbx500_fw_version_init(pdev, pdata->version_offset);
3163 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "prcmu-tcdm"); 3163 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "prcmu-tcdm");
3164 if (!res) { 3164 if (!res) {
3165 dev_err(&pdev->dev, "no prcmu tcdm region provided\n"); 3165 dev_err(&pdev->dev, "no prcmu tcdm region provided\n");
3166 return -ENOENT; 3166 return -EINVAL;
3167 } 3167 }
3168 tcdm_base = devm_ioremap(&pdev->dev, res->start, 3168 tcdm_base = devm_ioremap(&pdev->dev, res->start,
3169 resource_size(res)); 3169 resource_size(res));
3170 if (!tcdm_base) {
3171 dev_err(&pdev->dev,
3172 "failed to ioremap prcmu-tcdm register memory\n");
3173 return -ENOMEM;
3174 }
3170 3175
3171 /* Clean up the mailbox interrupts after pre-kernel code. */ 3176 /* Clean up the mailbox interrupts after pre-kernel code. */
3172 writel(ALL_MBOX_BITS, PRCM_ARM_IT1_CLR); 3177 writel(ALL_MBOX_BITS, PRCM_ARM_IT1_CLR);
@@ -3174,15 +3179,14 @@ static int db8500_prcmu_probe(struct platform_device *pdev)
3174 irq = platform_get_irq(pdev, 0); 3179 irq = platform_get_irq(pdev, 0);
3175 if (irq <= 0) { 3180 if (irq <= 0) {
3176 dev_err(&pdev->dev, "no prcmu irq provided\n"); 3181 dev_err(&pdev->dev, "no prcmu irq provided\n");
3177 return -ENOENT; 3182 return irq;
3178 } 3183 }
3179 3184
3180 err = request_threaded_irq(irq, prcmu_irq_handler, 3185 err = request_threaded_irq(irq, prcmu_irq_handler,
3181 prcmu_irq_thread_fn, IRQF_NO_SUSPEND, "prcmu", NULL); 3186 prcmu_irq_thread_fn, IRQF_NO_SUSPEND, "prcmu", NULL);
3182 if (err < 0) { 3187 if (err < 0) {
3183 pr_err("prcmu: Failed to allocate IRQ_DB8500_PRCMU1.\n"); 3188 pr_err("prcmu: Failed to allocate IRQ_DB8500_PRCMU1.\n");
3184 err = -EBUSY; 3189 return err;
3185 goto no_irq_return;
3186 } 3190 }
3187 3191
3188 db8500_irq_init(np); 3192 db8500_irq_init(np);
@@ -3206,7 +3210,7 @@ static int db8500_prcmu_probe(struct platform_device *pdev)
3206 if (err) { 3210 if (err) {
3207 mfd_remove_devices(&pdev->dev); 3211 mfd_remove_devices(&pdev->dev);
3208 pr_err("prcmu: Failed to add subdevices\n"); 3212 pr_err("prcmu: Failed to add subdevices\n");
3209 goto no_irq_return; 3213 return err;
3210 } 3214 }
3211 } 3215 }
3212 3216
@@ -3214,12 +3218,10 @@ static int db8500_prcmu_probe(struct platform_device *pdev)
3214 if (err) { 3218 if (err) {
3215 mfd_remove_devices(&pdev->dev); 3219 mfd_remove_devices(&pdev->dev);
3216 pr_err("prcmu: Failed to add ab8500 subdevice\n"); 3220 pr_err("prcmu: Failed to add ab8500 subdevice\n");
3217 goto no_irq_return; 3221 return err;
3218 } 3222 }
3219 3223
3220 pr_info("DB8500 PRCMU initialized\n"); 3224 pr_info("DB8500 PRCMU initialized\n");
3221
3222no_irq_return:
3223 return err; 3225 return err;
3224} 3226}
3225static const struct of_device_id db8500_prcmu_match[] = { 3227static const struct of_device_id db8500_prcmu_match[] = {
diff --git a/drivers/mfd/dln2.c b/drivers/mfd/dln2.c
new file mode 100644
index 000000000000..6d49685d4ee4
--- /dev/null
+++ b/drivers/mfd/dln2.c
@@ -0,0 +1,781 @@
1/*
2 * Driver for the Diolan DLN-2 USB adapter
3 *
4 * Copyright (c) 2014 Intel Corporation
5 *
6 * Derived from:
7 * i2c-diolan-u2c.c
8 * Copyright (c) 2010-2011 Ericsson AB
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License as
12 * published by the Free Software Foundation, version 2.
13 */
14
15#include <linux/kernel.h>
16#include <linux/module.h>
17#include <linux/types.h>
18#include <linux/slab.h>
19#include <linux/usb.h>
20#include <linux/i2c.h>
21#include <linux/mutex.h>
22#include <linux/platform_device.h>
23#include <linux/mfd/core.h>
24#include <linux/mfd/dln2.h>
25#include <linux/rculist.h>
26
27struct dln2_header {
28 __le16 size;
29 __le16 id;
30 __le16 echo;
31 __le16 handle;
32};
33
34struct dln2_response {
35 struct dln2_header hdr;
36 __le16 result;
37};
38
39#define DLN2_GENERIC_MODULE_ID 0x00
40#define DLN2_GENERIC_CMD(cmd) DLN2_CMD(cmd, DLN2_GENERIC_MODULE_ID)
41#define CMD_GET_DEVICE_VER DLN2_GENERIC_CMD(0x30)
42#define CMD_GET_DEVICE_SN DLN2_GENERIC_CMD(0x31)
43
44#define DLN2_HW_ID 0x200
45#define DLN2_USB_TIMEOUT 200 /* in ms */
46#define DLN2_MAX_RX_SLOTS 16
47#define DLN2_MAX_URBS 16
48#define DLN2_RX_BUF_SIZE 512
49
50enum dln2_handle {
51 DLN2_HANDLE_EVENT = 0, /* don't change, hardware defined */
52 DLN2_HANDLE_CTRL,
53 DLN2_HANDLE_GPIO,
54 DLN2_HANDLE_I2C,
55 DLN2_HANDLE_SPI,
56 DLN2_HANDLES
57};
58
59/*
60 * Receive context used between the receive demultiplexer and the transfer
61 * routine. While sending a request the transfer routine will look for a free
62 * receive context and use it to wait for a response and to receive the URB and
63 * thus the response data.
64 */
65struct dln2_rx_context {
66 /* completion used to wait for a response */
67 struct completion done;
68
69 /* if non-NULL the URB contains the response */
70 struct urb *urb;
71
72 /* if true then this context is used to wait for a response */
73 bool in_use;
74};
75
76/*
77 * Receive contexts for a particular DLN2 module (i2c, gpio, etc.). We use the
78 * handle header field to identify the module in dln2_dev.mod_rx_slots and then
79 * the echo header field to index the slots field and find the receive context
80 * for a particular request.
81 */
82struct dln2_mod_rx_slots {
83 /* RX slots bitmap */
84 DECLARE_BITMAP(bmap, DLN2_MAX_RX_SLOTS);
85
86 /* used to wait for a free RX slot */
87 wait_queue_head_t wq;
88
89 /* used to wait for an RX operation to complete */
90 struct dln2_rx_context slots[DLN2_MAX_RX_SLOTS];
91
92 /* avoid races between alloc/free_rx_slot and dln2_rx_transfer */
93 spinlock_t lock;
94};
95
96struct dln2_dev {
97 struct usb_device *usb_dev;
98 struct usb_interface *interface;
99 u8 ep_in;
100 u8 ep_out;
101
102 struct urb *rx_urb[DLN2_MAX_URBS];
103 void *rx_buf[DLN2_MAX_URBS];
104
105 struct dln2_mod_rx_slots mod_rx_slots[DLN2_HANDLES];
106
107 struct list_head event_cb_list;
108 spinlock_t event_cb_lock;
109
110 bool disconnect;
111 int active_transfers;
112 wait_queue_head_t disconnect_wq;
113 spinlock_t disconnect_lock;
114};
115
116struct dln2_event_cb_entry {
117 struct list_head list;
118 u16 id;
119 struct platform_device *pdev;
120 dln2_event_cb_t callback;
121};
122
123int dln2_register_event_cb(struct platform_device *pdev, u16 id,
124 dln2_event_cb_t event_cb)
125{
126 struct dln2_dev *dln2 = dev_get_drvdata(pdev->dev.parent);
127 struct dln2_event_cb_entry *i, *entry;
128 unsigned long flags;
129 int ret = 0;
130
131 entry = kzalloc(sizeof(*entry), GFP_KERNEL);
132 if (!entry)
133 return -ENOMEM;
134
135 entry->id = id;
136 entry->callback = event_cb;
137 entry->pdev = pdev;
138
139 spin_lock_irqsave(&dln2->event_cb_lock, flags);
140
141 list_for_each_entry(i, &dln2->event_cb_list, list) {
142 if (i->id == id) {
143 ret = -EBUSY;
144 break;
145 }
146 }
147
148 if (!ret)
149 list_add_rcu(&entry->list, &dln2->event_cb_list);
150
151 spin_unlock_irqrestore(&dln2->event_cb_lock, flags);
152
153 if (ret)
154 kfree(entry);
155
156 return ret;
157}
158EXPORT_SYMBOL(dln2_register_event_cb);
159
160void dln2_unregister_event_cb(struct platform_device *pdev, u16 id)
161{
162 struct dln2_dev *dln2 = dev_get_drvdata(pdev->dev.parent);
163 struct dln2_event_cb_entry *i;
164 unsigned long flags;
165 bool found = false;
166
167 spin_lock_irqsave(&dln2->event_cb_lock, flags);
168
169 list_for_each_entry(i, &dln2->event_cb_list, list) {
170 if (i->id == id) {
171 list_del_rcu(&i->list);
172 found = true;
173 break;
174 }
175 }
176
177 spin_unlock_irqrestore(&dln2->event_cb_lock, flags);
178
179 if (found) {
180 synchronize_rcu();
181 kfree(i);
182 }
183}
184EXPORT_SYMBOL(dln2_unregister_event_cb);
185
186/*
187 * Returns true if a valid transfer slot is found. In this case the URB must not
188 * be resubmitted immediately in dln2_rx as we need the data when dln2_transfer
189 * is woke up. It will be resubmitted there.
190 */
191static bool dln2_transfer_complete(struct dln2_dev *dln2, struct urb *urb,
192 u16 handle, u16 rx_slot)
193{
194 struct device *dev = &dln2->interface->dev;
195 struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle];
196 struct dln2_rx_context *rxc;
197 bool valid_slot = false;
198
199 if (rx_slot >= DLN2_MAX_RX_SLOTS)
200 goto out;
201
202 rxc = &rxs->slots[rx_slot];
203
204 /*
205 * No need to disable interrupts as this lock is not taken in interrupt
206 * context elsewhere in this driver. This function (or its callers) are
207 * also not exported to other modules.
208 */
209 spin_lock(&rxs->lock);
210 if (rxc->in_use && !rxc->urb) {
211 rxc->urb = urb;
212 complete(&rxc->done);
213 valid_slot = true;
214 }
215 spin_unlock(&rxs->lock);
216
217out:
218 if (!valid_slot)
219 dev_warn(dev, "bad/late response %d/%d\n", handle, rx_slot);
220
221 return valid_slot;
222}
223
224static void dln2_run_event_callbacks(struct dln2_dev *dln2, u16 id, u16 echo,
225 void *data, int len)
226{
227 struct dln2_event_cb_entry *i;
228
229 rcu_read_lock();
230
231 list_for_each_entry_rcu(i, &dln2->event_cb_list, list) {
232 if (i->id == id) {
233 i->callback(i->pdev, echo, data, len);
234 break;
235 }
236 }
237
238 rcu_read_unlock();
239}
240
241static void dln2_rx(struct urb *urb)
242{
243 struct dln2_dev *dln2 = urb->context;
244 struct dln2_header *hdr = urb->transfer_buffer;
245 struct device *dev = &dln2->interface->dev;
246 u16 id, echo, handle, size;
247 u8 *data;
248 int len;
249 int err;
250
251 switch (urb->status) {
252 case 0:
253 /* success */
254 break;
255 case -ECONNRESET:
256 case -ENOENT:
257 case -ESHUTDOWN:
258 case -EPIPE:
259 /* this urb is terminated, clean up */
260 dev_dbg(dev, "urb shutting down with status %d\n", urb->status);
261 return;
262 default:
263 dev_dbg(dev, "nonzero urb status received %d\n", urb->status);
264 goto out;
265 }
266
267 if (urb->actual_length < sizeof(struct dln2_header)) {
268 dev_err(dev, "short response: %d\n", urb->actual_length);
269 goto out;
270 }
271
272 handle = le16_to_cpu(hdr->handle);
273 id = le16_to_cpu(hdr->id);
274 echo = le16_to_cpu(hdr->echo);
275 size = le16_to_cpu(hdr->size);
276
277 if (size != urb->actual_length) {
278 dev_err(dev, "size mismatch: handle %x cmd %x echo %x size %d actual %d\n",
279 handle, id, echo, size, urb->actual_length);
280 goto out;
281 }
282
283 if (handle >= DLN2_HANDLES) {
284 dev_warn(dev, "invalid handle %d\n", handle);
285 goto out;
286 }
287
288 data = urb->transfer_buffer + sizeof(struct dln2_header);
289 len = urb->actual_length - sizeof(struct dln2_header);
290
291 if (handle == DLN2_HANDLE_EVENT) {
292 dln2_run_event_callbacks(dln2, id, echo, data, len);
293 } else {
294 /* URB will be re-submitted in _dln2_transfer (free_rx_slot) */
295 if (dln2_transfer_complete(dln2, urb, handle, echo))
296 return;
297 }
298
299out:
300 err = usb_submit_urb(urb, GFP_ATOMIC);
301 if (err < 0)
302 dev_err(dev, "failed to resubmit RX URB: %d\n", err);
303}
304
305static void *dln2_prep_buf(u16 handle, u16 cmd, u16 echo, const void *obuf,
306 int *obuf_len, gfp_t gfp)
307{
308 int len;
309 void *buf;
310 struct dln2_header *hdr;
311
312 len = *obuf_len + sizeof(*hdr);
313 buf = kmalloc(len, gfp);
314 if (!buf)
315 return NULL;
316
317 hdr = (struct dln2_header *)buf;
318 hdr->id = cpu_to_le16(cmd);
319 hdr->size = cpu_to_le16(len);
320 hdr->echo = cpu_to_le16(echo);
321 hdr->handle = cpu_to_le16(handle);
322
323 memcpy(buf + sizeof(*hdr), obuf, *obuf_len);
324
325 *obuf_len = len;
326
327 return buf;
328}
329
330static int dln2_send_wait(struct dln2_dev *dln2, u16 handle, u16 cmd, u16 echo,
331 const void *obuf, int obuf_len)
332{
333 int ret = 0;
334 int len = obuf_len;
335 void *buf;
336 int actual;
337
338 buf = dln2_prep_buf(handle, cmd, echo, obuf, &len, GFP_KERNEL);
339 if (!buf)
340 return -ENOMEM;
341
342 ret = usb_bulk_msg(dln2->usb_dev,
343 usb_sndbulkpipe(dln2->usb_dev, dln2->ep_out),
344 buf, len, &actual, DLN2_USB_TIMEOUT);
345
346 kfree(buf);
347
348 return ret;
349}
350
351static bool find_free_slot(struct dln2_dev *dln2, u16 handle, int *slot)
352{
353 struct dln2_mod_rx_slots *rxs;
354 unsigned long flags;
355
356 if (dln2->disconnect) {
357 *slot = -ENODEV;
358 return true;
359 }
360
361 rxs = &dln2->mod_rx_slots[handle];
362
363 spin_lock_irqsave(&rxs->lock, flags);
364
365 *slot = find_first_zero_bit(rxs->bmap, DLN2_MAX_RX_SLOTS);
366
367 if (*slot < DLN2_MAX_RX_SLOTS) {
368 struct dln2_rx_context *rxc = &rxs->slots[*slot];
369
370 set_bit(*slot, rxs->bmap);
371 rxc->in_use = true;
372 }
373
374 spin_unlock_irqrestore(&rxs->lock, flags);
375
376 return *slot < DLN2_MAX_RX_SLOTS;
377}
378
379static int alloc_rx_slot(struct dln2_dev *dln2, u16 handle)
380{
381 int ret;
382 int slot;
383
384 /*
385 * No need to timeout here, the wait is bounded by the timeout in
386 * _dln2_transfer.
387 */
388 ret = wait_event_interruptible(dln2->mod_rx_slots[handle].wq,
389 find_free_slot(dln2, handle, &slot));
390 if (ret < 0)
391 return ret;
392
393 return slot;
394}
395
396static void free_rx_slot(struct dln2_dev *dln2, u16 handle, int slot)
397{
398 struct dln2_mod_rx_slots *rxs;
399 struct urb *urb = NULL;
400 unsigned long flags;
401 struct dln2_rx_context *rxc;
402
403 rxs = &dln2->mod_rx_slots[handle];
404
405 spin_lock_irqsave(&rxs->lock, flags);
406
407 clear_bit(slot, rxs->bmap);
408
409 rxc = &rxs->slots[slot];
410 rxc->in_use = false;
411 urb = rxc->urb;
412 rxc->urb = NULL;
413 reinit_completion(&rxc->done);
414
415 spin_unlock_irqrestore(&rxs->lock, flags);
416
417 if (urb) {
418 int err;
419 struct device *dev = &dln2->interface->dev;
420
421 err = usb_submit_urb(urb, GFP_KERNEL);
422 if (err < 0)
423 dev_err(dev, "failed to resubmit RX URB: %d\n", err);
424 }
425
426 wake_up_interruptible(&rxs->wq);
427}
428
429static int _dln2_transfer(struct dln2_dev *dln2, u16 handle, u16 cmd,
430 const void *obuf, unsigned obuf_len,
431 void *ibuf, unsigned *ibuf_len)
432{
433 int ret = 0;
434 int rx_slot;
435 struct dln2_response *rsp;
436 struct dln2_rx_context *rxc;
437 struct device *dev = &dln2->interface->dev;
438 const unsigned long timeout = DLN2_USB_TIMEOUT * HZ / 1000;
439 struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle];
440 int size;
441
442 spin_lock(&dln2->disconnect_lock);
443 if (!dln2->disconnect)
444 dln2->active_transfers++;
445 else
446 ret = -ENODEV;
447 spin_unlock(&dln2->disconnect_lock);
448
449 if (ret)
450 return ret;
451
452 rx_slot = alloc_rx_slot(dln2, handle);
453 if (rx_slot < 0) {
454 ret = rx_slot;
455 goto out_decr;
456 }
457
458 ret = dln2_send_wait(dln2, handle, cmd, rx_slot, obuf, obuf_len);
459 if (ret < 0) {
460 dev_err(dev, "USB write failed: %d\n", ret);
461 goto out_free_rx_slot;
462 }
463
464 rxc = &rxs->slots[rx_slot];
465
466 ret = wait_for_completion_interruptible_timeout(&rxc->done, timeout);
467 if (ret <= 0) {
468 if (!ret)
469 ret = -ETIMEDOUT;
470 goto out_free_rx_slot;
471 } else {
472 ret = 0;
473 }
474
475 if (dln2->disconnect) {
476 ret = -ENODEV;
477 goto out_free_rx_slot;
478 }
479
480 /* if we got here we know that the response header has been checked */
481 rsp = rxc->urb->transfer_buffer;
482 size = le16_to_cpu(rsp->hdr.size);
483
484 if (size < sizeof(*rsp)) {
485 ret = -EPROTO;
486 goto out_free_rx_slot;
487 }
488
489 if (le16_to_cpu(rsp->result) > 0x80) {
490 dev_dbg(dev, "%d received response with error %d\n",
491 handle, le16_to_cpu(rsp->result));
492 ret = -EREMOTEIO;
493 goto out_free_rx_slot;
494 }
495
496 if (!ibuf)
497 goto out_free_rx_slot;
498
499 if (*ibuf_len > size - sizeof(*rsp))
500 *ibuf_len = size - sizeof(*rsp);
501
502 memcpy(ibuf, rsp + 1, *ibuf_len);
503
504out_free_rx_slot:
505 free_rx_slot(dln2, handle, rx_slot);
506out_decr:
507 spin_lock(&dln2->disconnect_lock);
508 dln2->active_transfers--;
509 spin_unlock(&dln2->disconnect_lock);
510 if (dln2->disconnect)
511 wake_up(&dln2->disconnect_wq);
512
513 return ret;
514}
515
516int dln2_transfer(struct platform_device *pdev, u16 cmd,
517 const void *obuf, unsigned obuf_len,
518 void *ibuf, unsigned *ibuf_len)
519{
520 struct dln2_platform_data *dln2_pdata;
521 struct dln2_dev *dln2;
522 u16 handle;
523
524 dln2 = dev_get_drvdata(pdev->dev.parent);
525 dln2_pdata = dev_get_platdata(&pdev->dev);
526 handle = dln2_pdata->handle;
527
528 return _dln2_transfer(dln2, handle, cmd, obuf, obuf_len, ibuf,
529 ibuf_len);
530}
531EXPORT_SYMBOL(dln2_transfer);
532
533static int dln2_check_hw(struct dln2_dev *dln2)
534{
535 int ret;
536 __le32 hw_type;
537 int len = sizeof(hw_type);
538
539 ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_VER,
540 NULL, 0, &hw_type, &len);
541 if (ret < 0)
542 return ret;
543 if (len < sizeof(hw_type))
544 return -EREMOTEIO;
545
546 if (le32_to_cpu(hw_type) != DLN2_HW_ID) {
547 dev_err(&dln2->interface->dev, "Device ID 0x%x not supported\n",
548 le32_to_cpu(hw_type));
549 return -ENODEV;
550 }
551
552 return 0;
553}
554
555static int dln2_print_serialno(struct dln2_dev *dln2)
556{
557 int ret;
558 __le32 serial_no;
559 int len = sizeof(serial_no);
560 struct device *dev = &dln2->interface->dev;
561
562 ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_SN, NULL, 0,
563 &serial_no, &len);
564 if (ret < 0)
565 return ret;
566 if (len < sizeof(serial_no))
567 return -EREMOTEIO;
568
569 dev_info(dev, "Diolan DLN2 serial %u\n", le32_to_cpu(serial_no));
570
571 return 0;
572}
573
574static int dln2_hw_init(struct dln2_dev *dln2)
575{
576 int ret;
577
578 ret = dln2_check_hw(dln2);
579 if (ret < 0)
580 return ret;
581
582 return dln2_print_serialno(dln2);
583}
584
585static void dln2_free_rx_urbs(struct dln2_dev *dln2)
586{
587 int i;
588
589 for (i = 0; i < DLN2_MAX_URBS; i++) {
590 usb_kill_urb(dln2->rx_urb[i]);
591 usb_free_urb(dln2->rx_urb[i]);
592 kfree(dln2->rx_buf[i]);
593 }
594}
595
596static void dln2_free(struct dln2_dev *dln2)
597{
598 dln2_free_rx_urbs(dln2);
599 usb_put_dev(dln2->usb_dev);
600 kfree(dln2);
601}
602
603static int dln2_setup_rx_urbs(struct dln2_dev *dln2,
604 struct usb_host_interface *hostif)
605{
606 int i;
607 int ret;
608 const int rx_max_size = DLN2_RX_BUF_SIZE;
609 struct device *dev = &dln2->interface->dev;
610
611 for (i = 0; i < DLN2_MAX_URBS; i++) {
612 dln2->rx_buf[i] = kmalloc(rx_max_size, GFP_KERNEL);
613 if (!dln2->rx_buf[i])
614 return -ENOMEM;
615
616 dln2->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
617 if (!dln2->rx_urb[i])
618 return -ENOMEM;
619
620 usb_fill_bulk_urb(dln2->rx_urb[i], dln2->usb_dev,
621 usb_rcvbulkpipe(dln2->usb_dev, dln2->ep_in),
622 dln2->rx_buf[i], rx_max_size, dln2_rx, dln2);
623
624 ret = usb_submit_urb(dln2->rx_urb[i], GFP_KERNEL);
625 if (ret < 0) {
626 dev_err(dev, "failed to submit RX URB: %d\n", ret);
627 return ret;
628 }
629 }
630
631 return 0;
632}
633
634static struct dln2_platform_data dln2_pdata_gpio = {
635 .handle = DLN2_HANDLE_GPIO,
636};
637
638/* Only one I2C port seems to be supported on current hardware */
639static struct dln2_platform_data dln2_pdata_i2c = {
640 .handle = DLN2_HANDLE_I2C,
641 .port = 0,
642};
643
644/* Only one SPI port supported */
645static struct dln2_platform_data dln2_pdata_spi = {
646 .handle = DLN2_HANDLE_SPI,
647 .port = 0,
648};
649
650static const struct mfd_cell dln2_devs[] = {
651 {
652 .name = "dln2-gpio",
653 .platform_data = &dln2_pdata_gpio,
654 .pdata_size = sizeof(struct dln2_platform_data),
655 },
656 {
657 .name = "dln2-i2c",
658 .platform_data = &dln2_pdata_i2c,
659 .pdata_size = sizeof(struct dln2_platform_data),
660 },
661 {
662 .name = "dln2-spi",
663 .platform_data = &dln2_pdata_spi,
664 .pdata_size = sizeof(struct dln2_platform_data),
665 },
666};
667
668static void dln2_disconnect(struct usb_interface *interface)
669{
670 struct dln2_dev *dln2 = usb_get_intfdata(interface);
671 int i, j;
672
673 /* don't allow starting new transfers */
674 spin_lock(&dln2->disconnect_lock);
675 dln2->disconnect = true;
676 spin_unlock(&dln2->disconnect_lock);
677
678 /* cancel in progress transfers */
679 for (i = 0; i < DLN2_HANDLES; i++) {
680 struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[i];
681 unsigned long flags;
682
683 spin_lock_irqsave(&rxs->lock, flags);
684
685 /* cancel all response waiters */
686 for (j = 0; j < DLN2_MAX_RX_SLOTS; j++) {
687 struct dln2_rx_context *rxc = &rxs->slots[j];
688
689 if (rxc->in_use)
690 complete(&rxc->done);
691 }
692
693 spin_unlock_irqrestore(&rxs->lock, flags);
694 }
695
696 /* wait for transfers to end */
697 wait_event(dln2->disconnect_wq, !dln2->active_transfers);
698
699 mfd_remove_devices(&interface->dev);
700
701 dln2_free(dln2);
702}
703
704static int dln2_probe(struct usb_interface *interface,
705 const struct usb_device_id *usb_id)
706{
707 struct usb_host_interface *hostif = interface->cur_altsetting;
708 struct device *dev = &interface->dev;
709 struct dln2_dev *dln2;
710 int ret;
711 int i, j;
712
713 if (hostif->desc.bInterfaceNumber != 0 ||
714 hostif->desc.bNumEndpoints < 2)
715 return -ENODEV;
716
717 dln2 = kzalloc(sizeof(*dln2), GFP_KERNEL);
718 if (!dln2)
719 return -ENOMEM;
720
721 dln2->ep_out = hostif->endpoint[0].desc.bEndpointAddress;
722 dln2->ep_in = hostif->endpoint[1].desc.bEndpointAddress;
723 dln2->usb_dev = usb_get_dev(interface_to_usbdev(interface));
724 dln2->interface = interface;
725 usb_set_intfdata(interface, dln2);
726 init_waitqueue_head(&dln2->disconnect_wq);
727
728 for (i = 0; i < DLN2_HANDLES; i++) {
729 init_waitqueue_head(&dln2->mod_rx_slots[i].wq);
730 spin_lock_init(&dln2->mod_rx_slots[i].lock);
731 for (j = 0; j < DLN2_MAX_RX_SLOTS; j++)
732 init_completion(&dln2->mod_rx_slots[i].slots[j].done);
733 }
734
735 spin_lock_init(&dln2->event_cb_lock);
736 spin_lock_init(&dln2->disconnect_lock);
737 INIT_LIST_HEAD(&dln2->event_cb_list);
738
739 ret = dln2_setup_rx_urbs(dln2, hostif);
740 if (ret)
741 goto out_cleanup;
742
743 ret = dln2_hw_init(dln2);
744 if (ret < 0) {
745 dev_err(dev, "failed to initialize hardware\n");
746 goto out_cleanup;
747 }
748
749 ret = mfd_add_hotplug_devices(dev, dln2_devs, ARRAY_SIZE(dln2_devs));
750 if (ret != 0) {
751 dev_err(dev, "failed to add mfd devices to core\n");
752 goto out_cleanup;
753 }
754
755 return 0;
756
757out_cleanup:
758 dln2_free(dln2);
759
760 return ret;
761}
762
763static const struct usb_device_id dln2_table[] = {
764 { USB_DEVICE(0xa257, 0x2013) },
765 { }
766};
767
768MODULE_DEVICE_TABLE(usb, dln2_table);
769
770static struct usb_driver dln2_driver = {
771 .name = "dln2",
772 .probe = dln2_probe,
773 .disconnect = dln2_disconnect,
774 .id_table = dln2_table,
775};
776
777module_usb_driver(dln2_driver);
778
779MODULE_AUTHOR("Octavian Purdila <octavian.purdila@intel.com>");
780MODULE_DESCRIPTION("Core driver for the Diolan DLN2 interface adapter");
781MODULE_LICENSE("GPL v2");
diff --git a/drivers/mfd/intel_soc_pmic_crc.c b/drivers/mfd/intel_soc_pmic_crc.c
index 7107cab832e6..c85e2ecb868a 100644
--- a/drivers/mfd/intel_soc_pmic_crc.c
+++ b/drivers/mfd/intel_soc_pmic_crc.c
@@ -106,6 +106,9 @@ static struct mfd_cell crystal_cove_dev[] = {
106 .num_resources = ARRAY_SIZE(gpio_resources), 106 .num_resources = ARRAY_SIZE(gpio_resources),
107 .resources = gpio_resources, 107 .resources = gpio_resources,
108 }, 108 },
109 {
110 .name = "crystal_cove_pmic",
111 },
109}; 112};
110 113
111static struct regmap_config crystal_cove_regmap_config = { 114static struct regmap_config crystal_cove_regmap_config = {
diff --git a/drivers/mfd/lpc_sch.c b/drivers/mfd/lpc_sch.c
index c980da479a35..5c38df35a84d 100644
--- a/drivers/mfd/lpc_sch.c
+++ b/drivers/mfd/lpc_sch.c
@@ -193,11 +193,7 @@ static int lpc_sch_probe(struct pci_dev *dev, const struct pci_device_id *id)
193 return -ENODEV; 193 return -ENODEV;
194 } 194 }
195 195
196 ret = mfd_add_devices(&dev->dev, 0, lpc_sch_cells, cells, NULL, 0, NULL); 196 return mfd_add_devices(&dev->dev, 0, lpc_sch_cells, cells, NULL, 0, NULL);
197 if (ret)
198 mfd_remove_devices(&dev->dev);
199
200 return ret;
201} 197}
202 198
203static void lpc_sch_remove(struct pci_dev *dev) 199static void lpc_sch_remove(struct pci_dev *dev)
diff --git a/drivers/mfd/max14577.c b/drivers/mfd/max14577.c
index de96b7fb1f6d..3bf8def82f1e 100644
--- a/drivers/mfd/max14577.c
+++ b/drivers/mfd/max14577.c
@@ -1,7 +1,7 @@
1/* 1/*
2 * max14577.c - mfd core driver for the Maxim 14577/77836 2 * max14577.c - mfd core driver for the Maxim 14577/77836
3 * 3 *
4 * Copyright (C) 2014 Samsung Electrnoics 4 * Copyright (C) 2014 Samsung Electronics
5 * Chanwoo Choi <cw00.choi@samsung.com> 5 * Chanwoo Choi <cw00.choi@samsung.com>
6 * Krzysztof Kozlowski <k.kozlowski@samsung.com> 6 * Krzysztof Kozlowski <k.kozlowski@samsung.com>
7 * 7 *
diff --git a/drivers/mfd/max77693.c b/drivers/mfd/max77693.c
index 711773e8e64b..a159593e27a0 100644
--- a/drivers/mfd/max77693.c
+++ b/drivers/mfd/max77693.c
@@ -43,9 +43,15 @@
43 43
44static const struct mfd_cell max77693_devs[] = { 44static const struct mfd_cell max77693_devs[] = {
45 { .name = "max77693-pmic", }, 45 { .name = "max77693-pmic", },
46 { .name = "max77693-charger", }, 46 {
47 .name = "max77693-charger",
48 .of_compatible = "maxim,max77693-charger",
49 },
47 { .name = "max77693-muic", }, 50 { .name = "max77693-muic", },
48 { .name = "max77693-haptic", }, 51 {
52 .name = "max77693-haptic",
53 .of_compatible = "maxim,max77693-haptic",
54 },
49 { 55 {
50 .name = "max77693-flash", 56 .name = "max77693-flash",
51 .of_compatible = "maxim,max77693-flash", 57 .of_compatible = "maxim,max77693-flash",
@@ -147,6 +153,12 @@ static const struct regmap_irq_chip max77693_muic_irq_chip = {
147 .num_irqs = ARRAY_SIZE(max77693_muic_irqs), 153 .num_irqs = ARRAY_SIZE(max77693_muic_irqs),
148}; 154};
149 155
156static const struct regmap_config max77693_regmap_haptic_config = {
157 .reg_bits = 8,
158 .val_bits = 8,
159 .max_register = MAX77693_HAPTIC_REG_END,
160};
161
150static int max77693_i2c_probe(struct i2c_client *i2c, 162static int max77693_i2c_probe(struct i2c_client *i2c,
151 const struct i2c_device_id *id) 163 const struct i2c_device_id *id)
152{ 164{
@@ -196,6 +208,15 @@ static int max77693_i2c_probe(struct i2c_client *i2c,
196 } 208 }
197 i2c_set_clientdata(max77693->haptic, max77693); 209 i2c_set_clientdata(max77693->haptic, max77693);
198 210
211 max77693->regmap_haptic = devm_regmap_init_i2c(max77693->haptic,
212 &max77693_regmap_haptic_config);
213 if (IS_ERR(max77693->regmap_haptic)) {
214 ret = PTR_ERR(max77693->regmap_haptic);
215 dev_err(max77693->dev,
216 "failed to initialize haptic register map: %d\n", ret);
217 goto err_regmap;
218 }
219
199 /* 220 /*
200 * Initialize register map for MUIC device because use regmap-muic 221 * Initialize register map for MUIC device because use regmap-muic
201 * instance of MUIC device when irq of max77693 is initialized 222 * instance of MUIC device when irq of max77693 is initialized
@@ -207,7 +228,7 @@ static int max77693_i2c_probe(struct i2c_client *i2c,
207 ret = PTR_ERR(max77693->regmap_muic); 228 ret = PTR_ERR(max77693->regmap_muic);
208 dev_err(max77693->dev, 229 dev_err(max77693->dev,
209 "failed to allocate register map: %d\n", ret); 230 "failed to allocate register map: %d\n", ret);
210 goto err_regmap_muic; 231 goto err_regmap;
211 } 232 }
212 233
213 ret = regmap_add_irq_chip(max77693->regmap, max77693->irq, 234 ret = regmap_add_irq_chip(max77693->regmap, max77693->irq,
@@ -217,7 +238,7 @@ static int max77693_i2c_probe(struct i2c_client *i2c,
217 &max77693->irq_data_led); 238 &max77693->irq_data_led);
218 if (ret) { 239 if (ret) {
219 dev_err(max77693->dev, "failed to add irq chip: %d\n", ret); 240 dev_err(max77693->dev, "failed to add irq chip: %d\n", ret);
220 goto err_regmap_muic; 241 goto err_regmap;
221 } 242 }
222 243
223 ret = regmap_add_irq_chip(max77693->regmap, max77693->irq, 244 ret = regmap_add_irq_chip(max77693->regmap, max77693->irq,
@@ -280,7 +301,7 @@ err_irq_charger:
280 regmap_del_irq_chip(max77693->irq, max77693->irq_data_topsys); 301 regmap_del_irq_chip(max77693->irq, max77693->irq_data_topsys);
281err_irq_topsys: 302err_irq_topsys:
282 regmap_del_irq_chip(max77693->irq, max77693->irq_data_led); 303 regmap_del_irq_chip(max77693->irq, max77693->irq_data_led);
283err_regmap_muic: 304err_regmap:
284 i2c_unregister_device(max77693->haptic); 305 i2c_unregister_device(max77693->haptic);
285err_i2c_haptic: 306err_i2c_haptic:
286 i2c_unregister_device(max77693->muic); 307 i2c_unregister_device(max77693->muic);
diff --git a/drivers/mfd/mfd-core.c b/drivers/mfd/mfd-core.c
index f3338fe9d069..2a87f69be53d 100644
--- a/drivers/mfd/mfd-core.c
+++ b/drivers/mfd/mfd-core.c
@@ -125,9 +125,15 @@ static int mfd_add_device(struct device *parent, int id,
125 struct platform_device *pdev; 125 struct platform_device *pdev;
126 struct device_node *np = NULL; 126 struct device_node *np = NULL;
127 int ret = -ENOMEM; 127 int ret = -ENOMEM;
128 int platform_id;
128 int r; 129 int r;
129 130
130 pdev = platform_device_alloc(cell->name, id + cell->id); 131 if (id < 0)
132 platform_id = id;
133 else
134 platform_id = id + cell->id;
135
136 pdev = platform_device_alloc(cell->name, platform_id);
131 if (!pdev) 137 if (!pdev)
132 goto fail_alloc; 138 goto fail_alloc;
133 139
diff --git a/drivers/mfd/rts5227.c b/drivers/mfd/rts5227.c
index 9c8eec80ceed..32407404d838 100644
--- a/drivers/mfd/rts5227.c
+++ b/drivers/mfd/rts5227.c
@@ -130,6 +130,12 @@ static int rts5227_extra_init_hw(struct rtsx_pcr *pcr)
130 130
131static int rts5227_optimize_phy(struct rtsx_pcr *pcr) 131static int rts5227_optimize_phy(struct rtsx_pcr *pcr)
132{ 132{
133 int err;
134
135 err = rtsx_gops_pm_reset(pcr);
136 if (err < 0)
137 return err;
138
133 /* Optimize RX sensitivity */ 139 /* Optimize RX sensitivity */
134 return rtsx_pci_write_phy_register(pcr, 0x00, 0xBA42); 140 return rtsx_pci_write_phy_register(pcr, 0x00, 0xBA42);
135} 141}
diff --git a/drivers/mfd/rts5249.c b/drivers/mfd/rts5249.c
index 573de7bfcced..cf425cc959d5 100644
--- a/drivers/mfd/rts5249.c
+++ b/drivers/mfd/rts5249.c
@@ -130,6 +130,10 @@ static int rts5249_optimize_phy(struct rtsx_pcr *pcr)
130{ 130{
131 int err; 131 int err;
132 132
133 err = rtsx_gops_pm_reset(pcr);
134 if (err < 0)
135 return err;
136
133 err = rtsx_pci_write_phy_register(pcr, PHY_REG_REV, 137 err = rtsx_pci_write_phy_register(pcr, PHY_REG_REV,
134 PHY_REG_REV_RESV | PHY_REG_REV_RXIDLE_LATCHED | 138 PHY_REG_REV_RESV | PHY_REG_REV_RXIDLE_LATCHED |
135 PHY_REG_REV_P1_EN | PHY_REG_REV_RXIDLE_EN | 139 PHY_REG_REV_P1_EN | PHY_REG_REV_RXIDLE_EN |
diff --git a/drivers/mfd/rtsx_gops.c b/drivers/mfd/rtsx_gops.c
new file mode 100644
index 000000000000..b1a98c678593
--- /dev/null
+++ b/drivers/mfd/rtsx_gops.c
@@ -0,0 +1,37 @@
1/* Driver for Realtek PCI-Express card reader
2 *
3 * Copyright(c) 2009-2013 Realtek Semiconductor Corp. All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; either version 2, or (at your option) any
8 * later version.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, see <http://www.gnu.org/licenses/>.
17 *
18 * Author:
19 * Micky Ching <micky_ching@realsil.com.cn>
20 */
21
22#include <linux/mfd/rtsx_pci.h>
23#include "rtsx_pcr.h"
24
25int rtsx_gops_pm_reset(struct rtsx_pcr *pcr)
26{
27 int err;
28
29 /* init aspm */
30 rtsx_pci_write_register(pcr, ASPM_FORCE_CTL, 0xFF, 0x00);
31 err = rtsx_pci_update_cfg_byte(pcr, LCTLR, ~LCTLR_ASPM_CTL_MASK, 0x00);
32 if (err < 0)
33 return err;
34
35 /* reset PM_CTRL3 before send buffer cmd */
36 return rtsx_pci_write_register(pcr, PM_CTRL3, D3_DELINK_MODE_EN, 0x00);
37}
diff --git a/drivers/mfd/rtsx_pcr.h b/drivers/mfd/rtsx_pcr.h
index 07e4c2ebf05a..fe2bbb67defc 100644
--- a/drivers/mfd/rtsx_pcr.h
+++ b/drivers/mfd/rtsx_pcr.h
@@ -72,4 +72,7 @@ do { \
72 pcr->ms_pull_ctl_disable_tbl = __device##_ms_pull_ctl_disable_tbl; \ 72 pcr->ms_pull_ctl_disable_tbl = __device##_ms_pull_ctl_disable_tbl; \
73} while (0) 73} while (0)
74 74
75/* generic operations */
76int rtsx_gops_pm_reset(struct rtsx_pcr *pcr);
77
75#endif 78#endif
diff --git a/drivers/mfd/rtsx_usb.c b/drivers/mfd/rtsx_usb.c
index 9cf98d142d9a..dbdd0faeb6ce 100644
--- a/drivers/mfd/rtsx_usb.c
+++ b/drivers/mfd/rtsx_usb.c
@@ -647,8 +647,8 @@ static int rtsx_usb_probe(struct usb_interface *intf,
647 /* initialize USB SG transfer timer */ 647 /* initialize USB SG transfer timer */
648 setup_timer(&ucr->sg_timer, rtsx_usb_sg_timed_out, (unsigned long) ucr); 648 setup_timer(&ucr->sg_timer, rtsx_usb_sg_timed_out, (unsigned long) ucr);
649 649
650 ret = mfd_add_devices(&intf->dev, usb_dev->devnum, rtsx_usb_cells, 650 ret = mfd_add_hotplug_devices(&intf->dev, rtsx_usb_cells,
651 ARRAY_SIZE(rtsx_usb_cells), NULL, 0, NULL); 651 ARRAY_SIZE(rtsx_usb_cells));
652 if (ret) 652 if (ret)
653 goto out_init_fail; 653 goto out_init_fail;
654 654
diff --git a/drivers/mfd/sec-core.c b/drivers/mfd/sec-core.c
index dba7e2b6f8e9..0a7bc43db4e4 100644
--- a/drivers/mfd/sec-core.c
+++ b/drivers/mfd/sec-core.c
@@ -27,11 +27,11 @@
27#include <linux/mfd/samsung/irq.h> 27#include <linux/mfd/samsung/irq.h>
28#include <linux/mfd/samsung/s2mpa01.h> 28#include <linux/mfd/samsung/s2mpa01.h>
29#include <linux/mfd/samsung/s2mps11.h> 29#include <linux/mfd/samsung/s2mps11.h>
30#include <linux/mfd/samsung/s2mps13.h>
30#include <linux/mfd/samsung/s2mps14.h> 31#include <linux/mfd/samsung/s2mps14.h>
31#include <linux/mfd/samsung/s2mpu02.h> 32#include <linux/mfd/samsung/s2mpu02.h>
32#include <linux/mfd/samsung/s5m8763.h> 33#include <linux/mfd/samsung/s5m8763.h>
33#include <linux/mfd/samsung/s5m8767.h> 34#include <linux/mfd/samsung/s5m8767.h>
34#include <linux/regulator/machine.h>
35#include <linux/regmap.h> 35#include <linux/regmap.h>
36 36
37static const struct mfd_cell s5m8751_devs[] = { 37static const struct mfd_cell s5m8751_devs[] = {
@@ -74,6 +74,15 @@ static const struct mfd_cell s2mps11_devs[] = {
74 } 74 }
75}; 75};
76 76
77static const struct mfd_cell s2mps13_devs[] = {
78 { .name = "s2mps13-pmic", },
79 { .name = "s2mps13-rtc", },
80 {
81 .name = "s2mps13-clk",
82 .of_compatible = "samsung,s2mps13-clk",
83 },
84};
85
77static const struct mfd_cell s2mps14_devs[] = { 86static const struct mfd_cell s2mps14_devs[] = {
78 { 87 {
79 .name = "s2mps14-pmic", 88 .name = "s2mps14-pmic",
@@ -108,6 +117,9 @@ static const struct of_device_id sec_dt_match[] = {
108 .compatible = "samsung,s2mps11-pmic", 117 .compatible = "samsung,s2mps11-pmic",
109 .data = (void *)S2MPS11X, 118 .data = (void *)S2MPS11X,
110 }, { 119 }, {
120 .compatible = "samsung,s2mps13-pmic",
121 .data = (void *)S2MPS13X,
122 }, {
111 .compatible = "samsung,s2mps14-pmic", 123 .compatible = "samsung,s2mps14-pmic",
112 .data = (void *)S2MPS14X, 124 .data = (void *)S2MPS14X,
113 }, { 125 }, {
@@ -194,6 +206,15 @@ static const struct regmap_config s2mps11_regmap_config = {
194 .cache_type = REGCACHE_FLAT, 206 .cache_type = REGCACHE_FLAT,
195}; 207};
196 208
209static const struct regmap_config s2mps13_regmap_config = {
210 .reg_bits = 8,
211 .val_bits = 8,
212
213 .max_register = S2MPS13_REG_LDODSCH5,
214 .volatile_reg = s2mps11_volatile,
215 .cache_type = REGCACHE_FLAT,
216};
217
197static const struct regmap_config s2mps14_regmap_config = { 218static const struct regmap_config s2mps14_regmap_config = {
198 .reg_bits = 8, 219 .reg_bits = 8,
199 .val_bits = 8, 220 .val_bits = 8,
@@ -325,6 +346,9 @@ static int sec_pmic_probe(struct i2c_client *i2c,
325 case S2MPS11X: 346 case S2MPS11X:
326 regmap = &s2mps11_regmap_config; 347 regmap = &s2mps11_regmap_config;
327 break; 348 break;
349 case S2MPS13X:
350 regmap = &s2mps13_regmap_config;
351 break;
328 case S2MPS14X: 352 case S2MPS14X:
329 regmap = &s2mps14_regmap_config; 353 regmap = &s2mps14_regmap_config;
330 break; 354 break;
@@ -378,6 +402,10 @@ static int sec_pmic_probe(struct i2c_client *i2c,
378 sec_devs = s2mps11_devs; 402 sec_devs = s2mps11_devs;
379 num_sec_devs = ARRAY_SIZE(s2mps11_devs); 403 num_sec_devs = ARRAY_SIZE(s2mps11_devs);
380 break; 404 break;
405 case S2MPS13X:
406 sec_devs = s2mps13_devs;
407 num_sec_devs = ARRAY_SIZE(s2mps13_devs);
408 break;
381 case S2MPS14X: 409 case S2MPS14X:
382 sec_devs = s2mps14_devs; 410 sec_devs = s2mps14_devs;
383 num_sec_devs = ARRAY_SIZE(s2mps14_devs); 411 num_sec_devs = ARRAY_SIZE(s2mps14_devs);
@@ -432,15 +460,6 @@ static int sec_pmic_suspend(struct device *dev)
432 */ 460 */
433 disable_irq(sec_pmic->irq); 461 disable_irq(sec_pmic->irq);
434 462
435 switch (sec_pmic->device_type) {
436 case S2MPS14X:
437 case S2MPU02:
438 regulator_suspend_prepare(PM_SUSPEND_MEM);
439 break;
440 default:
441 break;
442 }
443
444 return 0; 463 return 0;
445} 464}
446 465
diff --git a/drivers/mfd/sec-irq.c b/drivers/mfd/sec-irq.c
index f9a57869e3ec..ba86a918c2da 100644
--- a/drivers/mfd/sec-irq.c
+++ b/drivers/mfd/sec-irq.c
@@ -389,14 +389,22 @@ static const struct regmap_irq_chip s2mps11_irq_chip = {
389 .ack_base = S2MPS11_REG_INT1, 389 .ack_base = S2MPS11_REG_INT1,
390}; 390};
391 391
392#define S2MPS1X_IRQ_CHIP_COMMON_DATA \
393 .irqs = s2mps14_irqs, \
394 .num_irqs = ARRAY_SIZE(s2mps14_irqs), \
395 .num_regs = 3, \
396 .status_base = S2MPS14_REG_INT1, \
397 .mask_base = S2MPS14_REG_INT1M, \
398 .ack_base = S2MPS14_REG_INT1 \
399
400static const struct regmap_irq_chip s2mps13_irq_chip = {
401 .name = "s2mps13",
402 S2MPS1X_IRQ_CHIP_COMMON_DATA,
403};
404
392static const struct regmap_irq_chip s2mps14_irq_chip = { 405static const struct regmap_irq_chip s2mps14_irq_chip = {
393 .name = "s2mps14", 406 .name = "s2mps14",
394 .irqs = s2mps14_irqs, 407 S2MPS1X_IRQ_CHIP_COMMON_DATA,
395 .num_irqs = ARRAY_SIZE(s2mps14_irqs),
396 .num_regs = 3,
397 .status_base = S2MPS14_REG_INT1,
398 .mask_base = S2MPS14_REG_INT1M,
399 .ack_base = S2MPS14_REG_INT1,
400}; 408};
401 409
402static const struct regmap_irq_chip s2mpu02_irq_chip = { 410static const struct regmap_irq_chip s2mpu02_irq_chip = {
@@ -452,6 +460,9 @@ int sec_irq_init(struct sec_pmic_dev *sec_pmic)
452 case S2MPS11X: 460 case S2MPS11X:
453 sec_irq_chip = &s2mps11_irq_chip; 461 sec_irq_chip = &s2mps11_irq_chip;
454 break; 462 break;
463 case S2MPS13X:
464 sec_irq_chip = &s2mps13_irq_chip;
465 break;
455 case S2MPS14X: 466 case S2MPS14X:
456 sec_irq_chip = &s2mps14_irq_chip; 467 sec_irq_chip = &s2mps14_irq_chip;
457 break; 468 break;
diff --git a/drivers/mfd/syscon.c b/drivers/mfd/syscon.c
index ca15878ce5c0..72373b113885 100644
--- a/drivers/mfd/syscon.c
+++ b/drivers/mfd/syscon.c
@@ -15,6 +15,7 @@
15#include <linux/err.h> 15#include <linux/err.h>
16#include <linux/io.h> 16#include <linux/io.h>
17#include <linux/module.h> 17#include <linux/module.h>
18#include <linux/list.h>
18#include <linux/of.h> 19#include <linux/of.h>
19#include <linux/of_address.h> 20#include <linux/of_address.h>
20#include <linux/of_platform.h> 21#include <linux/of_platform.h>
@@ -22,31 +23,94 @@
22#include <linux/platform_device.h> 23#include <linux/platform_device.h>
23#include <linux/regmap.h> 24#include <linux/regmap.h>
24#include <linux/mfd/syscon.h> 25#include <linux/mfd/syscon.h>
26#include <linux/slab.h>
25 27
26static struct platform_driver syscon_driver; 28static struct platform_driver syscon_driver;
27 29
30static DEFINE_SPINLOCK(syscon_list_slock);
31static LIST_HEAD(syscon_list);
32
28struct syscon { 33struct syscon {
34 struct device_node *np;
29 struct regmap *regmap; 35 struct regmap *regmap;
36 struct list_head list;
37};
38
39static struct regmap_config syscon_regmap_config = {
40 .reg_bits = 32,
41 .val_bits = 32,
42 .reg_stride = 4,
30}; 43};
31 44
32static int syscon_match_node(struct device *dev, void *data) 45static struct syscon *of_syscon_register(struct device_node *np)
33{ 46{
34 struct device_node *dn = data; 47 struct syscon *syscon;
48 struct regmap *regmap;
49 void __iomem *base;
50 int ret;
51 struct regmap_config syscon_config = syscon_regmap_config;
52
53 if (!of_device_is_compatible(np, "syscon"))
54 return ERR_PTR(-EINVAL);
55
56 syscon = kzalloc(sizeof(*syscon), GFP_KERNEL);
57 if (!syscon)
58 return ERR_PTR(-ENOMEM);
59
60 base = of_iomap(np, 0);
61 if (!base) {
62 ret = -ENOMEM;
63 goto err_map;
64 }
65
66 /* Parse the device's DT node for an endianness specification */
67 if (of_property_read_bool(np, "big-endian"))
68 syscon_config.val_format_endian = REGMAP_ENDIAN_BIG;
69 else if (of_property_read_bool(np, "little-endian"))
70 syscon_config.val_format_endian = REGMAP_ENDIAN_LITTLE;
71
72 regmap = regmap_init_mmio(NULL, base, &syscon_config);
73 if (IS_ERR(regmap)) {
74 pr_err("regmap init failed\n");
75 ret = PTR_ERR(regmap);
76 goto err_regmap;
77 }
78
79 syscon->regmap = regmap;
80 syscon->np = np;
81
82 spin_lock(&syscon_list_slock);
83 list_add_tail(&syscon->list, &syscon_list);
84 spin_unlock(&syscon_list_slock);
35 85
36 return (dev->of_node == dn) ? 1 : 0; 86 return syscon;
87
88err_regmap:
89 iounmap(base);
90err_map:
91 kfree(syscon);
92 return ERR_PTR(ret);
37} 93}
38 94
39struct regmap *syscon_node_to_regmap(struct device_node *np) 95struct regmap *syscon_node_to_regmap(struct device_node *np)
40{ 96{
41 struct syscon *syscon; 97 struct syscon *entry, *syscon = NULL;
42 struct device *dev;
43 98
44 dev = driver_find_device(&syscon_driver.driver, NULL, np, 99 spin_lock(&syscon_list_slock);
45 syscon_match_node);
46 if (!dev)
47 return ERR_PTR(-EPROBE_DEFER);
48 100
49 syscon = dev_get_drvdata(dev); 101 list_for_each_entry(entry, &syscon_list, list)
102 if (entry->np == np) {
103 syscon = entry;
104 break;
105 }
106
107 spin_unlock(&syscon_list_slock);
108
109 if (!syscon)
110 syscon = of_syscon_register(np);
111
112 if (IS_ERR(syscon))
113 return ERR_CAST(syscon);
50 114
51 return syscon->regmap; 115 return syscon->regmap;
52} 116}
@@ -110,17 +174,6 @@ struct regmap *syscon_regmap_lookup_by_phandle(struct device_node *np,
110} 174}
111EXPORT_SYMBOL_GPL(syscon_regmap_lookup_by_phandle); 175EXPORT_SYMBOL_GPL(syscon_regmap_lookup_by_phandle);
112 176
113static const struct of_device_id of_syscon_match[] = {
114 { .compatible = "syscon", },
115 { },
116};
117
118static struct regmap_config syscon_regmap_config = {
119 .reg_bits = 32,
120 .val_bits = 32,
121 .reg_stride = 4,
122};
123
124static int syscon_probe(struct platform_device *pdev) 177static int syscon_probe(struct platform_device *pdev)
125{ 178{
126 struct device *dev = &pdev->dev; 179 struct device *dev = &pdev->dev;
@@ -167,7 +220,6 @@ static struct platform_driver syscon_driver = {
167 .driver = { 220 .driver = {
168 .name = "syscon", 221 .name = "syscon",
169 .owner = THIS_MODULE, 222 .owner = THIS_MODULE,
170 .of_match_table = of_syscon_match,
171 }, 223 },
172 .probe = syscon_probe, 224 .probe = syscon_probe,
173 .id_table = syscon_ids, 225 .id_table = syscon_ids,
diff --git a/drivers/mfd/t7l66xb.c b/drivers/mfd/t7l66xb.c
index 9e04a7485981..439d905bb219 100644
--- a/drivers/mfd/t7l66xb.c
+++ b/drivers/mfd/t7l66xb.c
@@ -87,7 +87,7 @@ static int t7l66xb_mmc_enable(struct platform_device *mmc)
87 unsigned long flags; 87 unsigned long flags;
88 u8 dev_ctl; 88 u8 dev_ctl;
89 89
90 clk_enable(t7l66xb->clk32k); 90 clk_prepare_enable(t7l66xb->clk32k);
91 91
92 spin_lock_irqsave(&t7l66xb->lock, flags); 92 spin_lock_irqsave(&t7l66xb->lock, flags);
93 93
@@ -118,7 +118,7 @@ static int t7l66xb_mmc_disable(struct platform_device *mmc)
118 118
119 spin_unlock_irqrestore(&t7l66xb->lock, flags); 119 spin_unlock_irqrestore(&t7l66xb->lock, flags);
120 120
121 clk_disable(t7l66xb->clk32k); 121 clk_disable_unprepare(t7l66xb->clk32k);
122 122
123 return 0; 123 return 0;
124} 124}
@@ -285,7 +285,7 @@ static int t7l66xb_suspend(struct platform_device *dev, pm_message_t state)
285 285
286 if (pdata && pdata->suspend) 286 if (pdata && pdata->suspend)
287 pdata->suspend(dev); 287 pdata->suspend(dev);
288 clk_disable(t7l66xb->clk48m); 288 clk_disable_unprepare(t7l66xb->clk48m);
289 289
290 return 0; 290 return 0;
291} 291}
@@ -295,7 +295,7 @@ static int t7l66xb_resume(struct platform_device *dev)
295 struct t7l66xb *t7l66xb = platform_get_drvdata(dev); 295 struct t7l66xb *t7l66xb = platform_get_drvdata(dev);
296 struct t7l66xb_platform_data *pdata = dev_get_platdata(&dev->dev); 296 struct t7l66xb_platform_data *pdata = dev_get_platdata(&dev->dev);
297 297
298 clk_enable(t7l66xb->clk48m); 298 clk_prepare_enable(t7l66xb->clk48m);
299 if (pdata && pdata->resume) 299 if (pdata && pdata->resume)
300 pdata->resume(dev); 300 pdata->resume(dev);
301 301
@@ -369,7 +369,7 @@ static int t7l66xb_probe(struct platform_device *dev)
369 goto err_ioremap; 369 goto err_ioremap;
370 } 370 }
371 371
372 clk_enable(t7l66xb->clk48m); 372 clk_prepare_enable(t7l66xb->clk48m);
373 373
374 if (pdata && pdata->enable) 374 if (pdata && pdata->enable)
375 pdata->enable(dev); 375 pdata->enable(dev);
@@ -414,9 +414,9 @@ static int t7l66xb_remove(struct platform_device *dev)
414 int ret; 414 int ret;
415 415
416 ret = pdata->disable(dev); 416 ret = pdata->disable(dev);
417 clk_disable(t7l66xb->clk48m); 417 clk_disable_unprepare(t7l66xb->clk48m);
418 clk_put(t7l66xb->clk48m); 418 clk_put(t7l66xb->clk48m);
419 clk_disable(t7l66xb->clk32k); 419 clk_disable_unprepare(t7l66xb->clk32k);
420 clk_put(t7l66xb->clk32k); 420 clk_put(t7l66xb->clk32k);
421 t7l66xb_detach_irq(dev); 421 t7l66xb_detach_irq(dev);
422 iounmap(t7l66xb->scr); 422 iounmap(t7l66xb->scr);
diff --git a/drivers/mfd/tc3589x.c b/drivers/mfd/tc3589x.c
index 0072e668c208..aacb3720065c 100644
--- a/drivers/mfd/tc3589x.c
+++ b/drivers/mfd/tc3589x.c
@@ -241,10 +241,8 @@ static struct irq_domain_ops tc3589x_irq_ops = {
241 241
242static int tc3589x_irq_init(struct tc3589x *tc3589x, struct device_node *np) 242static int tc3589x_irq_init(struct tc3589x *tc3589x, struct device_node *np)
243{ 243{
244 int base = tc3589x->irq_base;
245
246 tc3589x->domain = irq_domain_add_simple( 244 tc3589x->domain = irq_domain_add_simple(
247 np, TC3589x_NR_INTERNAL_IRQS, base, 245 np, TC3589x_NR_INTERNAL_IRQS, 0,
248 &tc3589x_irq_ops, tc3589x); 246 &tc3589x_irq_ops, tc3589x);
249 247
250 if (!tc3589x->domain) { 248 if (!tc3589x->domain) {
@@ -298,7 +296,7 @@ static int tc3589x_device_init(struct tc3589x *tc3589x)
298 if (blocks & TC3589x_BLOCK_GPIO) { 296 if (blocks & TC3589x_BLOCK_GPIO) {
299 ret = mfd_add_devices(tc3589x->dev, -1, tc3589x_dev_gpio, 297 ret = mfd_add_devices(tc3589x->dev, -1, tc3589x_dev_gpio,
300 ARRAY_SIZE(tc3589x_dev_gpio), NULL, 298 ARRAY_SIZE(tc3589x_dev_gpio), NULL,
301 tc3589x->irq_base, tc3589x->domain); 299 0, tc3589x->domain);
302 if (ret) { 300 if (ret) {
303 dev_err(tc3589x->dev, "failed to add gpio child\n"); 301 dev_err(tc3589x->dev, "failed to add gpio child\n");
304 return ret; 302 return ret;
@@ -309,7 +307,7 @@ static int tc3589x_device_init(struct tc3589x *tc3589x)
309 if (blocks & TC3589x_BLOCK_KEYPAD) { 307 if (blocks & TC3589x_BLOCK_KEYPAD) {
310 ret = mfd_add_devices(tc3589x->dev, -1, tc3589x_dev_keypad, 308 ret = mfd_add_devices(tc3589x->dev, -1, tc3589x_dev_keypad,
311 ARRAY_SIZE(tc3589x_dev_keypad), NULL, 309 ARRAY_SIZE(tc3589x_dev_keypad), NULL,
312 tc3589x->irq_base, tc3589x->domain); 310 0, tc3589x->domain);
313 if (ret) { 311 if (ret) {
314 dev_err(tc3589x->dev, "failed to keypad child\n"); 312 dev_err(tc3589x->dev, "failed to keypad child\n");
315 return ret; 313 return ret;
@@ -404,7 +402,6 @@ static int tc3589x_probe(struct i2c_client *i2c,
404 tc3589x->dev = &i2c->dev; 402 tc3589x->dev = &i2c->dev;
405 tc3589x->i2c = i2c; 403 tc3589x->i2c = i2c;
406 tc3589x->pdata = pdata; 404 tc3589x->pdata = pdata;
407 tc3589x->irq_base = pdata->irq_base;
408 405
409 switch (version) { 406 switch (version) {
410 case TC3589X_TC35893: 407 case TC3589X_TC35893:
diff --git a/drivers/mfd/tc6387xb.c b/drivers/mfd/tc6387xb.c
index e71f88000ae5..85fab3729102 100644
--- a/drivers/mfd/tc6387xb.c
+++ b/drivers/mfd/tc6387xb.c
@@ -52,7 +52,7 @@ static int tc6387xb_suspend(struct platform_device *dev, pm_message_t state)
52 52
53 if (pdata && pdata->suspend) 53 if (pdata && pdata->suspend)
54 pdata->suspend(dev); 54 pdata->suspend(dev);
55 clk_disable(tc6387xb->clk32k); 55 clk_disable_unprepare(tc6387xb->clk32k);
56 56
57 return 0; 57 return 0;
58} 58}
@@ -62,7 +62,7 @@ static int tc6387xb_resume(struct platform_device *dev)
62 struct tc6387xb *tc6387xb = platform_get_drvdata(dev); 62 struct tc6387xb *tc6387xb = platform_get_drvdata(dev);
63 struct tc6387xb_platform_data *pdata = dev_get_platdata(&dev->dev); 63 struct tc6387xb_platform_data *pdata = dev_get_platdata(&dev->dev);
64 64
65 clk_enable(tc6387xb->clk32k); 65 clk_prepare_enable(tc6387xb->clk32k);
66 if (pdata && pdata->resume) 66 if (pdata && pdata->resume)
67 pdata->resume(dev); 67 pdata->resume(dev);
68 68
@@ -100,7 +100,7 @@ static int tc6387xb_mmc_enable(struct platform_device *mmc)
100 struct platform_device *dev = to_platform_device(mmc->dev.parent); 100 struct platform_device *dev = to_platform_device(mmc->dev.parent);
101 struct tc6387xb *tc6387xb = platform_get_drvdata(dev); 101 struct tc6387xb *tc6387xb = platform_get_drvdata(dev);
102 102
103 clk_enable(tc6387xb->clk32k); 103 clk_prepare_enable(tc6387xb->clk32k);
104 104
105 tmio_core_mmc_enable(tc6387xb->scr + 0x200, 0, 105 tmio_core_mmc_enable(tc6387xb->scr + 0x200, 0,
106 tc6387xb_mmc_resources[0].start & 0xfffe); 106 tc6387xb_mmc_resources[0].start & 0xfffe);
@@ -113,7 +113,7 @@ static int tc6387xb_mmc_disable(struct platform_device *mmc)
113 struct platform_device *dev = to_platform_device(mmc->dev.parent); 113 struct platform_device *dev = to_platform_device(mmc->dev.parent);
114 struct tc6387xb *tc6387xb = platform_get_drvdata(dev); 114 struct tc6387xb *tc6387xb = platform_get_drvdata(dev);
115 115
116 clk_disable(tc6387xb->clk32k); 116 clk_disable_unprepare(tc6387xb->clk32k);
117 117
118 return 0; 118 return 0;
119} 119}
@@ -214,7 +214,7 @@ static int tc6387xb_remove(struct platform_device *dev)
214 mfd_remove_devices(&dev->dev); 214 mfd_remove_devices(&dev->dev);
215 iounmap(tc6387xb->scr); 215 iounmap(tc6387xb->scr);
216 release_resource(&tc6387xb->rscr); 216 release_resource(&tc6387xb->rscr);
217 clk_disable(tc6387xb->clk32k); 217 clk_disable_unprepare(tc6387xb->clk32k);
218 clk_put(tc6387xb->clk32k); 218 clk_put(tc6387xb->clk32k);
219 kfree(tc6387xb); 219 kfree(tc6387xb);
220 220
diff --git a/drivers/mfd/tc6393xb.c b/drivers/mfd/tc6393xb.c
index 4fac16bcd732..d35f11fbeab7 100644
--- a/drivers/mfd/tc6393xb.c
+++ b/drivers/mfd/tc6393xb.c
@@ -263,6 +263,17 @@ static int tc6393xb_ohci_disable(struct platform_device *dev)
263 return 0; 263 return 0;
264} 264}
265 265
266static int tc6393xb_ohci_suspend(struct platform_device *dev)
267{
268 struct tc6393xb_platform_data *tcpd = dev_get_platdata(dev->dev.parent);
269
270 /* We can't properly store/restore OHCI state, so fail here */
271 if (tcpd->resume_restore)
272 return -EBUSY;
273
274 return tc6393xb_ohci_disable(dev);
275}
276
266static int tc6393xb_fb_enable(struct platform_device *dev) 277static int tc6393xb_fb_enable(struct platform_device *dev)
267{ 278{
268 struct tc6393xb *tc6393xb = dev_get_drvdata(dev->dev.parent); 279 struct tc6393xb *tc6393xb = dev_get_drvdata(dev->dev.parent);
@@ -403,7 +414,7 @@ static struct mfd_cell tc6393xb_cells[] = {
403 .num_resources = ARRAY_SIZE(tc6393xb_ohci_resources), 414 .num_resources = ARRAY_SIZE(tc6393xb_ohci_resources),
404 .resources = tc6393xb_ohci_resources, 415 .resources = tc6393xb_ohci_resources,
405 .enable = tc6393xb_ohci_enable, 416 .enable = tc6393xb_ohci_enable,
406 .suspend = tc6393xb_ohci_disable, 417 .suspend = tc6393xb_ohci_suspend,
407 .resume = tc6393xb_ohci_enable, 418 .resume = tc6393xb_ohci_enable,
408 .disable = tc6393xb_ohci_disable, 419 .disable = tc6393xb_ohci_disable,
409 }, 420 },
@@ -654,7 +665,7 @@ static int tc6393xb_probe(struct platform_device *dev)
654 goto err_ioremap; 665 goto err_ioremap;
655 } 666 }
656 667
657 ret = clk_enable(tc6393xb->clk); 668 ret = clk_prepare_enable(tc6393xb->clk);
658 if (ret) 669 if (ret)
659 goto err_clk_enable; 670 goto err_clk_enable;
660 671
@@ -717,7 +728,7 @@ err_gpio_add:
717 gpiochip_remove(&tc6393xb->gpio); 728 gpiochip_remove(&tc6393xb->gpio);
718 tcpd->disable(dev); 729 tcpd->disable(dev);
719err_enable: 730err_enable:
720 clk_disable(tc6393xb->clk); 731 clk_disable_unprepare(tc6393xb->clk);
721err_clk_enable: 732err_clk_enable:
722 iounmap(tc6393xb->scr); 733 iounmap(tc6393xb->scr);
723err_ioremap: 734err_ioremap:
@@ -748,7 +759,7 @@ static int tc6393xb_remove(struct platform_device *dev)
748 gpiochip_remove(&tc6393xb->gpio); 759 gpiochip_remove(&tc6393xb->gpio);
749 760
750 ret = tcpd->disable(dev); 761 ret = tcpd->disable(dev);
751 clk_disable(tc6393xb->clk); 762 clk_disable_unprepare(tc6393xb->clk);
752 iounmap(tc6393xb->scr); 763 iounmap(tc6393xb->scr);
753 release_resource(&tc6393xb->rscr); 764 release_resource(&tc6393xb->rscr);
754 clk_put(tc6393xb->clk); 765 clk_put(tc6393xb->clk);
@@ -776,7 +787,7 @@ static int tc6393xb_suspend(struct platform_device *dev, pm_message_t state)
776 ioread8(tc6393xb->scr + SCR_GPI_BCR(i)); 787 ioread8(tc6393xb->scr + SCR_GPI_BCR(i));
777 } 788 }
778 ret = tcpd->suspend(dev); 789 ret = tcpd->suspend(dev);
779 clk_disable(tc6393xb->clk); 790 clk_disable_unprepare(tc6393xb->clk);
780 791
781 return ret; 792 return ret;
782} 793}
@@ -788,7 +799,7 @@ static int tc6393xb_resume(struct platform_device *dev)
788 int ret; 799 int ret;
789 int i; 800 int i;
790 801
791 clk_enable(tc6393xb->clk); 802 clk_prepare_enable(tc6393xb->clk);
792 803
793 ret = tcpd->resume(dev); 804 ret = tcpd->resume(dev);
794 if (ret) 805 if (ret)
diff --git a/drivers/mfd/tps65090.c b/drivers/mfd/tps65090.c
index 1c3e6e2efe41..14b62e11aff4 100644
--- a/drivers/mfd/tps65090.c
+++ b/drivers/mfd/tps65090.c
@@ -76,58 +76,58 @@ static struct mfd_cell tps65090s[] = {
76static const struct regmap_irq tps65090_irqs[] = { 76static const struct regmap_irq tps65090_irqs[] = {
77 /* INT1 IRQs*/ 77 /* INT1 IRQs*/
78 [TPS65090_IRQ_VAC_STATUS_CHANGE] = { 78 [TPS65090_IRQ_VAC_STATUS_CHANGE] = {
79 .mask = TPS65090_INT1_MASK_VAC_STATUS_CHANGE, 79 .mask = TPS65090_INT1_MASK_VAC_STATUS_CHANGE,
80 }, 80 },
81 [TPS65090_IRQ_VSYS_STATUS_CHANGE] = { 81 [TPS65090_IRQ_VSYS_STATUS_CHANGE] = {
82 .mask = TPS65090_INT1_MASK_VSYS_STATUS_CHANGE, 82 .mask = TPS65090_INT1_MASK_VSYS_STATUS_CHANGE,
83 }, 83 },
84 [TPS65090_IRQ_BAT_STATUS_CHANGE] = { 84 [TPS65090_IRQ_BAT_STATUS_CHANGE] = {
85 .mask = TPS65090_INT1_MASK_BAT_STATUS_CHANGE, 85 .mask = TPS65090_INT1_MASK_BAT_STATUS_CHANGE,
86 }, 86 },
87 [TPS65090_IRQ_CHARGING_STATUS_CHANGE] = { 87 [TPS65090_IRQ_CHARGING_STATUS_CHANGE] = {
88 .mask = TPS65090_INT1_MASK_CHARGING_STATUS_CHANGE, 88 .mask = TPS65090_INT1_MASK_CHARGING_STATUS_CHANGE,
89 }, 89 },
90 [TPS65090_IRQ_CHARGING_COMPLETE] = { 90 [TPS65090_IRQ_CHARGING_COMPLETE] = {
91 .mask = TPS65090_INT1_MASK_CHARGING_COMPLETE, 91 .mask = TPS65090_INT1_MASK_CHARGING_COMPLETE,
92 }, 92 },
93 [TPS65090_IRQ_OVERLOAD_DCDC1] = { 93 [TPS65090_IRQ_OVERLOAD_DCDC1] = {
94 .mask = TPS65090_INT1_MASK_OVERLOAD_DCDC1, 94 .mask = TPS65090_INT1_MASK_OVERLOAD_DCDC1,
95 }, 95 },
96 [TPS65090_IRQ_OVERLOAD_DCDC2] = { 96 [TPS65090_IRQ_OVERLOAD_DCDC2] = {
97 .mask = TPS65090_INT1_MASK_OVERLOAD_DCDC2, 97 .mask = TPS65090_INT1_MASK_OVERLOAD_DCDC2,
98 }, 98 },
99 /* INT2 IRQs*/ 99 /* INT2 IRQs*/
100 [TPS65090_IRQ_OVERLOAD_DCDC3] = { 100 [TPS65090_IRQ_OVERLOAD_DCDC3] = {
101 .reg_offset = 1, 101 .reg_offset = 1,
102 .mask = TPS65090_INT2_MASK_OVERLOAD_DCDC3, 102 .mask = TPS65090_INT2_MASK_OVERLOAD_DCDC3,
103 }, 103 },
104 [TPS65090_IRQ_OVERLOAD_FET1] = { 104 [TPS65090_IRQ_OVERLOAD_FET1] = {
105 .reg_offset = 1, 105 .reg_offset = 1,
106 .mask = TPS65090_INT2_MASK_OVERLOAD_FET1, 106 .mask = TPS65090_INT2_MASK_OVERLOAD_FET1,
107 }, 107 },
108 [TPS65090_IRQ_OVERLOAD_FET2] = { 108 [TPS65090_IRQ_OVERLOAD_FET2] = {
109 .reg_offset = 1, 109 .reg_offset = 1,
110 .mask = TPS65090_INT2_MASK_OVERLOAD_FET2, 110 .mask = TPS65090_INT2_MASK_OVERLOAD_FET2,
111 }, 111 },
112 [TPS65090_IRQ_OVERLOAD_FET3] = { 112 [TPS65090_IRQ_OVERLOAD_FET3] = {
113 .reg_offset = 1, 113 .reg_offset = 1,
114 .mask = TPS65090_INT2_MASK_OVERLOAD_FET3, 114 .mask = TPS65090_INT2_MASK_OVERLOAD_FET3,
115 }, 115 },
116 [TPS65090_IRQ_OVERLOAD_FET4] = { 116 [TPS65090_IRQ_OVERLOAD_FET4] = {
117 .reg_offset = 1, 117 .reg_offset = 1,
118 .mask = TPS65090_INT2_MASK_OVERLOAD_FET4, 118 .mask = TPS65090_INT2_MASK_OVERLOAD_FET4,
119 }, 119 },
120 [TPS65090_IRQ_OVERLOAD_FET5] = { 120 [TPS65090_IRQ_OVERLOAD_FET5] = {
121 .reg_offset = 1, 121 .reg_offset = 1,
122 .mask = TPS65090_INT2_MASK_OVERLOAD_FET5, 122 .mask = TPS65090_INT2_MASK_OVERLOAD_FET5,
123 }, 123 },
124 [TPS65090_IRQ_OVERLOAD_FET6] = { 124 [TPS65090_IRQ_OVERLOAD_FET6] = {
125 .reg_offset = 1, 125 .reg_offset = 1,
126 .mask = TPS65090_INT2_MASK_OVERLOAD_FET6, 126 .mask = TPS65090_INT2_MASK_OVERLOAD_FET6,
127 }, 127 },
128 [TPS65090_IRQ_OVERLOAD_FET7] = { 128 [TPS65090_IRQ_OVERLOAD_FET7] = {
129 .reg_offset = 1, 129 .reg_offset = 1,
130 .mask = TPS65090_INT2_MASK_OVERLOAD_FET7, 130 .mask = TPS65090_INT2_MASK_OVERLOAD_FET7,
131 }, 131 },
132}; 132};
133 133
@@ -176,7 +176,7 @@ MODULE_DEVICE_TABLE(of, tps65090_of_match);
176#endif 176#endif
177 177
178static int tps65090_i2c_probe(struct i2c_client *client, 178static int tps65090_i2c_probe(struct i2c_client *client,
179 const struct i2c_device_id *id) 179 const struct i2c_device_id *id)
180{ 180{
181 struct tps65090_platform_data *pdata = dev_get_platdata(&client->dev); 181 struct tps65090_platform_data *pdata = dev_get_platdata(&client->dev);
182 int irq_base = 0; 182 int irq_base = 0;
@@ -210,11 +210,11 @@ static int tps65090_i2c_probe(struct i2c_client *client,
210 210
211 if (client->irq) { 211 if (client->irq) {
212 ret = regmap_add_irq_chip(tps65090->rmap, client->irq, 212 ret = regmap_add_irq_chip(tps65090->rmap, client->irq,
213 IRQF_ONESHOT | IRQF_TRIGGER_LOW, irq_base, 213 IRQF_ONESHOT | IRQF_TRIGGER_LOW, irq_base,
214 &tps65090_irq_chip, &tps65090->irq_data); 214 &tps65090_irq_chip, &tps65090->irq_data);
215 if (ret) { 215 if (ret) {
216 dev_err(&client->dev, 216 dev_err(&client->dev,
217 "IRQ init failed with err: %d\n", ret); 217 "IRQ init failed with err: %d\n", ret);
218 return ret; 218 return ret;
219 } 219 }
220 } else { 220 } else {
@@ -223,8 +223,8 @@ static int tps65090_i2c_probe(struct i2c_client *client,
223 } 223 }
224 224
225 ret = mfd_add_devices(tps65090->dev, -1, tps65090s, 225 ret = mfd_add_devices(tps65090->dev, -1, tps65090s,
226 ARRAY_SIZE(tps65090s), NULL, 226 ARRAY_SIZE(tps65090s), NULL,
227 0, regmap_irq_get_domain(tps65090->irq_data)); 227 0, regmap_irq_get_domain(tps65090->irq_data));
228 if (ret) { 228 if (ret) {
229 dev_err(&client->dev, "add mfd devices failed with err: %d\n", 229 dev_err(&client->dev, "add mfd devices failed with err: %d\n",
230 ret); 230 ret);
diff --git a/drivers/mfd/tps65217.c b/drivers/mfd/tps65217.c
index a8ee52c95f2f..80a919a8ca97 100644
--- a/drivers/mfd/tps65217.c
+++ b/drivers/mfd/tps65217.c
@@ -33,9 +33,11 @@
33static const struct mfd_cell tps65217s[] = { 33static const struct mfd_cell tps65217s[] = {
34 { 34 {
35 .name = "tps65217-pmic", 35 .name = "tps65217-pmic",
36 .of_compatible = "ti,tps65217-pmic",
36 }, 37 },
37 { 38 {
38 .name = "tps65217-bl", 39 .name = "tps65217-bl",
40 .of_compatible = "ti,tps65217-bl",
39 }, 41 },
40}; 42};
41 43
diff --git a/drivers/mfd/twl4030-power.c b/drivers/mfd/twl4030-power.c
index 50f9091bcd38..7d63e324e6a8 100644
--- a/drivers/mfd/twl4030-power.c
+++ b/drivers/mfd/twl4030-power.c
@@ -831,6 +831,9 @@ static struct twl4030_power_data osc_off_idle = {
831 831
832static struct of_device_id twl4030_power_of_match[] = { 832static struct of_device_id twl4030_power_of_match[] = {
833 { 833 {
834 .compatible = "ti,twl4030-power",
835 },
836 {
834 .compatible = "ti,twl4030-power-reset", 837 .compatible = "ti,twl4030-power-reset",
835 .data = &omap3_reset, 838 .data = &omap3_reset,
836 }, 839 },
diff --git a/drivers/mfd/viperboard.c b/drivers/mfd/viperboard.c
index 3c2b8f9e3c84..e6b3c70aeb22 100644
--- a/drivers/mfd/viperboard.c
+++ b/drivers/mfd/viperboard.c
@@ -93,9 +93,8 @@ static int vprbrd_probe(struct usb_interface *interface,
93 version >> 8, version & 0xff, 93 version >> 8, version & 0xff,
94 vb->usb_dev->bus->busnum, vb->usb_dev->devnum); 94 vb->usb_dev->bus->busnum, vb->usb_dev->devnum);
95 95
96 ret = mfd_add_devices(&interface->dev, PLATFORM_DEVID_AUTO, 96 ret = mfd_add_hotplug_devices(&interface->dev, vprbrd_devs,
97 vprbrd_devs, ARRAY_SIZE(vprbrd_devs), NULL, 0, 97 ARRAY_SIZE(vprbrd_devs));
98 NULL);
99 if (ret != 0) { 98 if (ret != 0) {
100 dev_err(&interface->dev, "Failed to add mfd devices to core."); 99 dev_err(&interface->dev, "Failed to add mfd devices to core.");
101 goto error; 100 goto error;
diff --git a/drivers/mfd/wm5102-tables.c b/drivers/mfd/wm5102-tables.c
index d6f35bbf795b..b326a82017ee 100644
--- a/drivers/mfd/wm5102-tables.c
+++ b/drivers/mfd/wm5102-tables.c
@@ -336,8 +336,6 @@ static const struct reg_default wm5102_reg_default[] = {
336 { 0x00000218, 0x01A6 }, /* R536 - Mic Bias Ctrl 1 */ 336 { 0x00000218, 0x01A6 }, /* R536 - Mic Bias Ctrl 1 */
337 { 0x00000219, 0x01A6 }, /* R537 - Mic Bias Ctrl 2 */ 337 { 0x00000219, 0x01A6 }, /* R537 - Mic Bias Ctrl 2 */
338 { 0x0000021A, 0x01A6 }, /* R538 - Mic Bias Ctrl 3 */ 338 { 0x0000021A, 0x01A6 }, /* R538 - Mic Bias Ctrl 3 */
339 { 0x00000225, 0x0400 }, /* R549 - HP Ctrl 1L */
340 { 0x00000226, 0x0400 }, /* R550 - HP Ctrl 1R */
341 { 0x00000293, 0x0000 }, /* R659 - Accessory Detect Mode 1 */ 339 { 0x00000293, 0x0000 }, /* R659 - Accessory Detect Mode 1 */
342 { 0x0000029B, 0x0020 }, /* R667 - Headphone Detect 1 */ 340 { 0x0000029B, 0x0020 }, /* R667 - Headphone Detect 1 */
343 { 0x0000029C, 0x0000 }, /* R668 - Headphone Detect 2 */ 341 { 0x0000029C, 0x0000 }, /* R668 - Headphone Detect 2 */
@@ -1112,6 +1110,8 @@ static bool wm5102_readable_register(struct device *dev, unsigned int reg)
1112 case ARIZONA_MIC_BIAS_CTRL_1: 1110 case ARIZONA_MIC_BIAS_CTRL_1:
1113 case ARIZONA_MIC_BIAS_CTRL_2: 1111 case ARIZONA_MIC_BIAS_CTRL_2:
1114 case ARIZONA_MIC_BIAS_CTRL_3: 1112 case ARIZONA_MIC_BIAS_CTRL_3:
1113 case ARIZONA_HP_CTRL_1L:
1114 case ARIZONA_HP_CTRL_1R:
1115 case ARIZONA_ACCESSORY_DETECT_MODE_1: 1115 case ARIZONA_ACCESSORY_DETECT_MODE_1:
1116 case ARIZONA_HEADPHONE_DETECT_1: 1116 case ARIZONA_HEADPHONE_DETECT_1:
1117 case ARIZONA_HEADPHONE_DETECT_2: 1117 case ARIZONA_HEADPHONE_DETECT_2:
@@ -1949,6 +1949,8 @@ static bool wm5102_volatile_register(struct device *dev, unsigned int reg)
1949 case ARIZONA_DSP1_SCRATCH_1: 1949 case ARIZONA_DSP1_SCRATCH_1:
1950 case ARIZONA_DSP1_SCRATCH_2: 1950 case ARIZONA_DSP1_SCRATCH_2:
1951 case ARIZONA_DSP1_SCRATCH_3: 1951 case ARIZONA_DSP1_SCRATCH_3:
1952 case ARIZONA_HP_CTRL_1L:
1953 case ARIZONA_HP_CTRL_1R:
1952 case ARIZONA_HEADPHONE_DETECT_2: 1954 case ARIZONA_HEADPHONE_DETECT_2:
1953 case ARIZONA_HP_DACVAL: 1955 case ARIZONA_HP_DACVAL:
1954 case ARIZONA_MIC_DETECT_3: 1956 case ARIZONA_MIC_DETECT_3:
diff --git a/drivers/mfd/wm5110-tables.c b/drivers/mfd/wm5110-tables.c
index 4642b5b816a0..12cad94b4035 100644
--- a/drivers/mfd/wm5110-tables.c
+++ b/drivers/mfd/wm5110-tables.c
@@ -895,8 +895,16 @@ static const struct reg_default wm5110_reg_default[] = {
895 { 0x00000548, 0x1818 }, /* R1352 - AIF2 Frame Ctrl 2 */ 895 { 0x00000548, 0x1818 }, /* R1352 - AIF2 Frame Ctrl 2 */
896 { 0x00000549, 0x0000 }, /* R1353 - AIF2 Frame Ctrl 3 */ 896 { 0x00000549, 0x0000 }, /* R1353 - AIF2 Frame Ctrl 3 */
897 { 0x0000054A, 0x0001 }, /* R1354 - AIF2 Frame Ctrl 4 */ 897 { 0x0000054A, 0x0001 }, /* R1354 - AIF2 Frame Ctrl 4 */
898 { 0x0000054B, 0x0002 }, /* R1355 - AIF2 Frame Ctrl 5 */
899 { 0x0000054C, 0x0003 }, /* R1356 - AIF2 Frame Ctrl 6 */
900 { 0x0000054D, 0x0004 }, /* R1357 - AIF2 Frame Ctrl 7 */
901 { 0x0000054E, 0x0005 }, /* R1358 - AIF2 Frame Ctrl 8 */
898 { 0x00000551, 0x0000 }, /* R1361 - AIF2 Frame Ctrl 11 */ 902 { 0x00000551, 0x0000 }, /* R1361 - AIF2 Frame Ctrl 11 */
899 { 0x00000552, 0x0001 }, /* R1362 - AIF2 Frame Ctrl 12 */ 903 { 0x00000552, 0x0001 }, /* R1362 - AIF2 Frame Ctrl 12 */
904 { 0x00000553, 0x0002 }, /* R1363 - AIF2 Frame Ctrl 13 */
905 { 0x00000554, 0x0003 }, /* R1364 - AIF2 Frame Ctrl 14 */
906 { 0x00000555, 0x0004 }, /* R1365 - AIF2 Frame Ctrl 15 */
907 { 0x00000556, 0x0005 }, /* R1366 - AIF2 Frame Ctrl 16 */
900 { 0x00000559, 0x0000 }, /* R1369 - AIF2 Tx Enables */ 908 { 0x00000559, 0x0000 }, /* R1369 - AIF2 Tx Enables */
901 { 0x0000055A, 0x0000 }, /* R1370 - AIF2 Rx Enables */ 909 { 0x0000055A, 0x0000 }, /* R1370 - AIF2 Rx Enables */
902 { 0x00000580, 0x000C }, /* R1408 - AIF3 BCLK Ctrl */ 910 { 0x00000580, 0x000C }, /* R1408 - AIF3 BCLK Ctrl */
@@ -1790,6 +1798,8 @@ static bool wm5110_readable_register(struct device *dev, unsigned int reg)
1790 case ARIZONA_MIC_BIAS_CTRL_1: 1798 case ARIZONA_MIC_BIAS_CTRL_1:
1791 case ARIZONA_MIC_BIAS_CTRL_2: 1799 case ARIZONA_MIC_BIAS_CTRL_2:
1792 case ARIZONA_MIC_BIAS_CTRL_3: 1800 case ARIZONA_MIC_BIAS_CTRL_3:
1801 case ARIZONA_HP_CTRL_1L:
1802 case ARIZONA_HP_CTRL_1R:
1793 case ARIZONA_ACCESSORY_DETECT_MODE_1: 1803 case ARIZONA_ACCESSORY_DETECT_MODE_1:
1794 case ARIZONA_HEADPHONE_DETECT_1: 1804 case ARIZONA_HEADPHONE_DETECT_1:
1795 case ARIZONA_HEADPHONE_DETECT_2: 1805 case ARIZONA_HEADPHONE_DETECT_2:
@@ -1934,8 +1944,16 @@ static bool wm5110_readable_register(struct device *dev, unsigned int reg)
1934 case ARIZONA_AIF2_FRAME_CTRL_2: 1944 case ARIZONA_AIF2_FRAME_CTRL_2:
1935 case ARIZONA_AIF2_FRAME_CTRL_3: 1945 case ARIZONA_AIF2_FRAME_CTRL_3:
1936 case ARIZONA_AIF2_FRAME_CTRL_4: 1946 case ARIZONA_AIF2_FRAME_CTRL_4:
1947 case ARIZONA_AIF2_FRAME_CTRL_5:
1948 case ARIZONA_AIF2_FRAME_CTRL_6:
1949 case ARIZONA_AIF2_FRAME_CTRL_7:
1950 case ARIZONA_AIF2_FRAME_CTRL_8:
1937 case ARIZONA_AIF2_FRAME_CTRL_11: 1951 case ARIZONA_AIF2_FRAME_CTRL_11:
1938 case ARIZONA_AIF2_FRAME_CTRL_12: 1952 case ARIZONA_AIF2_FRAME_CTRL_12:
1953 case ARIZONA_AIF2_FRAME_CTRL_13:
1954 case ARIZONA_AIF2_FRAME_CTRL_14:
1955 case ARIZONA_AIF2_FRAME_CTRL_15:
1956 case ARIZONA_AIF2_FRAME_CTRL_16:
1939 case ARIZONA_AIF2_TX_ENABLES: 1957 case ARIZONA_AIF2_TX_ENABLES:
1940 case ARIZONA_AIF2_RX_ENABLES: 1958 case ARIZONA_AIF2_RX_ENABLES:
1941 case ARIZONA_AIF3_BCLK_CTRL: 1959 case ARIZONA_AIF3_BCLK_CTRL:
@@ -2825,6 +2843,8 @@ static bool wm5110_volatile_register(struct device *dev, unsigned int reg)
2825 case ARIZONA_ASYNC_SAMPLE_RATE_1_STATUS: 2843 case ARIZONA_ASYNC_SAMPLE_RATE_1_STATUS:
2826 case ARIZONA_ASYNC_SAMPLE_RATE_2_STATUS: 2844 case ARIZONA_ASYNC_SAMPLE_RATE_2_STATUS:
2827 case ARIZONA_MIC_DETECT_3: 2845 case ARIZONA_MIC_DETECT_3:
2846 case ARIZONA_HP_CTRL_1L:
2847 case ARIZONA_HP_CTRL_1R:
2828 case ARIZONA_HEADPHONE_DETECT_2: 2848 case ARIZONA_HEADPHONE_DETECT_2:
2829 case ARIZONA_INPUT_ENABLES_STATUS: 2849 case ARIZONA_INPUT_ENABLES_STATUS:
2830 case ARIZONA_OUTPUT_STATUS_1: 2850 case ARIZONA_OUTPUT_STATUS_1:
diff --git a/drivers/mfd/wm8350-core.c b/drivers/mfd/wm8350-core.c
index 4ab527f5c53b..f5124a8acad8 100644
--- a/drivers/mfd/wm8350-core.c
+++ b/drivers/mfd/wm8350-core.c
@@ -308,7 +308,7 @@ int wm8350_device_init(struct wm8350 *wm8350, int irq,
308 goto err; 308 goto err;
309 } 309 }
310 310
311 mode = id2 & WM8350_CONF_STS_MASK >> 10; 311 mode = (id2 & WM8350_CONF_STS_MASK) >> 10;
312 cust_id = id2 & WM8350_CUST_ID_MASK; 312 cust_id = id2 & WM8350_CUST_ID_MASK;
313 chip_rev = (id2 & WM8350_CHIP_REV_MASK) >> 12; 313 chip_rev = (id2 & WM8350_CHIP_REV_MASK) >> 12;
314 dev_info(wm8350->dev, 314 dev_info(wm8350->dev,
diff --git a/drivers/mfd/wm8994-core.c b/drivers/mfd/wm8994-core.c
index e6fab94e2c8a..6ca9d25cc3f0 100644
--- a/drivers/mfd/wm8994-core.c
+++ b/drivers/mfd/wm8994-core.c
@@ -116,7 +116,7 @@ static const char *wm8958_main_supplies[] = {
116 "SPKVDD2", 116 "SPKVDD2",
117}; 117};
118 118
119#ifdef CONFIG_PM_RUNTIME 119#ifdef CONFIG_PM
120static int wm8994_suspend(struct device *dev) 120static int wm8994_suspend(struct device *dev)
121{ 121{
122 struct wm8994 *wm8994 = dev_get_drvdata(dev); 122 struct wm8994 *wm8994 = dev_get_drvdata(dev);
diff --git a/drivers/mfd/wm8997-tables.c b/drivers/mfd/wm8997-tables.c
index 510da3b52324..c0c25d75aacc 100644
--- a/drivers/mfd/wm8997-tables.c
+++ b/drivers/mfd/wm8997-tables.c
@@ -670,6 +670,7 @@ static const struct reg_default wm8997_reg_default[] = {
670 { 0x00000C23, 0x0000 }, /* R3107 - Misc Pad Ctrl 4 */ 670 { 0x00000C23, 0x0000 }, /* R3107 - Misc Pad Ctrl 4 */
671 { 0x00000C24, 0x0000 }, /* R3108 - Misc Pad Ctrl 5 */ 671 { 0x00000C24, 0x0000 }, /* R3108 - Misc Pad Ctrl 5 */
672 { 0x00000D08, 0xFFFF }, /* R3336 - Interrupt Status 1 Mask */ 672 { 0x00000D08, 0xFFFF }, /* R3336 - Interrupt Status 1 Mask */
673 { 0x00000D09, 0xFFFF }, /* R3337 - Interrupt Status 2 Mask */
673 { 0x00000D0A, 0xFFFF }, /* R3338 - Interrupt Status 3 Mask */ 674 { 0x00000D0A, 0xFFFF }, /* R3338 - Interrupt Status 3 Mask */
674 { 0x00000D0B, 0xFFFF }, /* R3339 - Interrupt Status 4 Mask */ 675 { 0x00000D0B, 0xFFFF }, /* R3339 - Interrupt Status 4 Mask */
675 { 0x00000D0C, 0xFEFF }, /* R3340 - Interrupt Status 5 Mask */ 676 { 0x00000D0C, 0xFEFF }, /* R3340 - Interrupt Status 5 Mask */
@@ -886,6 +887,8 @@ static bool wm8997_readable_register(struct device *dev, unsigned int reg)
886 case ARIZONA_MIC_BIAS_CTRL_1: 887 case ARIZONA_MIC_BIAS_CTRL_1:
887 case ARIZONA_MIC_BIAS_CTRL_2: 888 case ARIZONA_MIC_BIAS_CTRL_2:
888 case ARIZONA_MIC_BIAS_CTRL_3: 889 case ARIZONA_MIC_BIAS_CTRL_3:
890 case ARIZONA_HP_CTRL_1L:
891 case ARIZONA_HP_CTRL_1R:
889 case ARIZONA_ACCESSORY_DETECT_MODE_1: 892 case ARIZONA_ACCESSORY_DETECT_MODE_1:
890 case ARIZONA_HEADPHONE_DETECT_1: 893 case ARIZONA_HEADPHONE_DETECT_1:
891 case ARIZONA_HEADPHONE_DETECT_2: 894 case ARIZONA_HEADPHONE_DETECT_2:
@@ -1328,6 +1331,7 @@ static bool wm8997_readable_register(struct device *dev, unsigned int reg)
1328 case ARIZONA_INTERRUPT_STATUS_4: 1331 case ARIZONA_INTERRUPT_STATUS_4:
1329 case ARIZONA_INTERRUPT_STATUS_5: 1332 case ARIZONA_INTERRUPT_STATUS_5:
1330 case ARIZONA_INTERRUPT_STATUS_1_MASK: 1333 case ARIZONA_INTERRUPT_STATUS_1_MASK:
1334 case ARIZONA_INTERRUPT_STATUS_2_MASK:
1331 case ARIZONA_INTERRUPT_STATUS_3_MASK: 1335 case ARIZONA_INTERRUPT_STATUS_3_MASK:
1332 case ARIZONA_INTERRUPT_STATUS_4_MASK: 1336 case ARIZONA_INTERRUPT_STATUS_4_MASK:
1333 case ARIZONA_INTERRUPT_STATUS_5_MASK: 1337 case ARIZONA_INTERRUPT_STATUS_5_MASK:
@@ -1477,6 +1481,8 @@ static bool wm8997_volatile_register(struct device *dev, unsigned int reg)
1477 case ARIZONA_SAMPLE_RATE_3_STATUS: 1481 case ARIZONA_SAMPLE_RATE_3_STATUS:
1478 case ARIZONA_ASYNC_SAMPLE_RATE_1_STATUS: 1482 case ARIZONA_ASYNC_SAMPLE_RATE_1_STATUS:
1479 case ARIZONA_MIC_DETECT_3: 1483 case ARIZONA_MIC_DETECT_3:
1484 case ARIZONA_HP_CTRL_1L:
1485 case ARIZONA_HP_CTRL_1R:
1480 case ARIZONA_HEADPHONE_DETECT_2: 1486 case ARIZONA_HEADPHONE_DETECT_2:
1481 case ARIZONA_INPUT_ENABLES_STATUS: 1487 case ARIZONA_INPUT_ENABLES_STATUS:
1482 case ARIZONA_OUTPUT_STATUS_1: 1488 case ARIZONA_OUTPUT_STATUS_1:
generated by cgit v1.2.2 (git 2.25.0) at 2024-09-22 05:28:29 -0400