aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/mfd
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/mfd')
-rw-r--r--drivers/mfd/Kconfig7
-rw-r--r--drivers/mfd/arizona-core.c41
-rw-r--r--drivers/mfd/max14577.c315
-rw-r--r--drivers/mfd/mc13xxx-core.c10
-rw-r--r--drivers/mfd/rtsx_pcr.c132
-rw-r--r--drivers/mfd/rtsx_usb.c14
-rw-r--r--drivers/mfd/stmpe-i2c.c30
-rw-r--r--drivers/mfd/stmpe.c33
-rw-r--r--drivers/mfd/stmpe.h2
-rw-r--r--drivers/mfd/tps65090.c41
-rw-r--r--drivers/mfd/tps6586x.c4
-rw-r--r--drivers/mfd/twl-core.c15
12 files changed, 460 insertions, 184 deletions
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index 33834120d057..e166d7176d7a 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -331,15 +331,15 @@ config MFD_88PM860X
331 battery-charger under the corresponding menus. 331 battery-charger under the corresponding menus.
332 332
333config MFD_MAX14577 333config MFD_MAX14577
334 bool "Maxim Semiconductor MAX14577 MUIC + Charger Support" 334 bool "Maxim Semiconductor MAX14577/77836 MUIC + Charger Support"
335 depends on I2C=y 335 depends on I2C=y
336 select MFD_CORE 336 select MFD_CORE
337 select REGMAP_I2C 337 select REGMAP_I2C
338 select REGMAP_IRQ 338 select REGMAP_IRQ
339 select IRQ_DOMAIN 339 select IRQ_DOMAIN
340 help 340 help
341 Say yes here to add support for Maxim Semiconductor MAX14577. 341 Say yes here to add support for Maxim Semiconductor MAX14577 and
342 This is a Micro-USB IC with Charger controls on chip. 342 MAX77836 Micro-USB ICs with battery charger.
343 This driver provides common support for accessing the device; 343 This driver provides common support for accessing the device;
344 additional drivers must be enabled in order to use the functionality 344 additional drivers must be enabled in order to use the functionality
345 of the device. 345 of the device.
@@ -675,6 +675,7 @@ config MFD_DB8500_PRCMU
675config MFD_STMPE 675config MFD_STMPE
676 bool "STMicroelectronics STMPE" 676 bool "STMicroelectronics STMPE"
677 depends on (I2C=y || SPI_MASTER=y) 677 depends on (I2C=y || SPI_MASTER=y)
678 depends on OF
678 select MFD_CORE 679 select MFD_CORE
679 help 680 help
680 Support for the STMPE family of I/O Expanders from 681 Support for the STMPE family of I/O Expanders from
diff --git a/drivers/mfd/arizona-core.c b/drivers/mfd/arizona-core.c
index 1c3ae57082ed..07e6e27be23c 100644
--- a/drivers/mfd/arizona-core.c
+++ b/drivers/mfd/arizona-core.c
@@ -508,19 +508,31 @@ int arizona_of_get_type(struct device *dev)
508} 508}
509EXPORT_SYMBOL_GPL(arizona_of_get_type); 509EXPORT_SYMBOL_GPL(arizona_of_get_type);
510 510
511int arizona_of_get_named_gpio(struct arizona *arizona, const char *prop,
512 bool mandatory)
513{
514 int gpio;
515
516 gpio = of_get_named_gpio(arizona->dev->of_node, prop, 0);
517 if (gpio < 0) {
518 if (mandatory)
519 dev_err(arizona->dev,
520 "Mandatory DT gpio %s missing/malformed: %d\n",
521 prop, gpio);
522
523 gpio = 0;
524 }
525
526 return gpio;
527}
528EXPORT_SYMBOL_GPL(arizona_of_get_named_gpio);
529
511static int arizona_of_get_core_pdata(struct arizona *arizona) 530static int arizona_of_get_core_pdata(struct arizona *arizona)
512{ 531{
532 struct arizona_pdata *pdata = &arizona->pdata;
513 int ret, i; 533 int ret, i;
514 534
515 arizona->pdata.reset = of_get_named_gpio(arizona->dev->of_node, 535 pdata->reset = arizona_of_get_named_gpio(arizona, "wlf,reset", true);
516 "wlf,reset", 0);
517 if (arizona->pdata.reset < 0)
518 arizona->pdata.reset = 0;
519
520 arizona->pdata.ldoena = of_get_named_gpio(arizona->dev->of_node,
521 "wlf,ldoena", 0);
522 if (arizona->pdata.ldoena < 0)
523 arizona->pdata.ldoena = 0;
524 536
525 ret = of_property_read_u32_array(arizona->dev->of_node, 537 ret = of_property_read_u32_array(arizona->dev->of_node,
526 "wlf,gpio-defaults", 538 "wlf,gpio-defaults",
@@ -652,6 +664,9 @@ int arizona_dev_init(struct arizona *arizona)
652 return -EINVAL; 664 return -EINVAL;
653 } 665 }
654 666
667 /* Mark DCVDD as external, LDO1 driver will clear if internal */
668 arizona->external_dcvdd = true;
669
655 ret = mfd_add_devices(arizona->dev, -1, early_devs, 670 ret = mfd_add_devices(arizona->dev, -1, early_devs,
656 ARRAY_SIZE(early_devs), NULL, 0, NULL); 671 ARRAY_SIZE(early_devs), NULL, 0, NULL);
657 if (ret != 0) { 672 if (ret != 0) {
@@ -851,14 +866,6 @@ int arizona_dev_init(struct arizona *arizona)
851 arizona->pdata.gpio_defaults[i]); 866 arizona->pdata.gpio_defaults[i]);
852 } 867 }
853 868
854 /*
855 * LDO1 can only be used to supply DCVDD so if it has no
856 * consumers then DCVDD is supplied externally.
857 */
858 if (arizona->pdata.ldo1 &&
859 arizona->pdata.ldo1->num_consumer_supplies == 0)
860 arizona->external_dcvdd = true;
861
862 pm_runtime_set_autosuspend_delay(arizona->dev, 100); 869 pm_runtime_set_autosuspend_delay(arizona->dev, 100);
863 pm_runtime_use_autosuspend(arizona->dev); 870 pm_runtime_use_autosuspend(arizona->dev);
864 pm_runtime_enable(arizona->dev); 871 pm_runtime_enable(arizona->dev);
diff --git a/drivers/mfd/max14577.c b/drivers/mfd/max14577.c
index 5f13cefe8def..484d372a4892 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 2 * max14577.c - mfd core driver for the Maxim 14577/77836
3 * 3 *
4 * Copyright (C) 2013 Samsung Electrnoics 4 * Copyright (C) 2014 Samsung Electrnoics
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 *
@@ -21,6 +21,7 @@
21#include <linux/err.h> 21#include <linux/err.h>
22#include <linux/module.h> 22#include <linux/module.h>
23#include <linux/interrupt.h> 23#include <linux/interrupt.h>
24#include <linux/of_device.h>
24#include <linux/mfd/core.h> 25#include <linux/mfd/core.h>
25#include <linux/mfd/max14577.h> 26#include <linux/mfd/max14577.h>
26#include <linux/mfd/max14577-private.h> 27#include <linux/mfd/max14577-private.h>
@@ -37,7 +38,38 @@ static struct mfd_cell max14577_devs[] = {
37 { .name = "max14577-charger", }, 38 { .name = "max14577-charger", },
38}; 39};
39 40
40static bool max14577_volatile_reg(struct device *dev, unsigned int reg) 41static struct mfd_cell max77836_devs[] = {
42 {
43 .name = "max77836-muic",
44 .of_compatible = "maxim,max77836-muic",
45 },
46 {
47 .name = "max77836-regulator",
48 .of_compatible = "maxim,max77836-regulator",
49 },
50 {
51 .name = "max77836-charger",
52 .of_compatible = "maxim,max77836-charger",
53 },
54 {
55 .name = "max77836-battery",
56 .of_compatible = "maxim,max77836-battery",
57 },
58};
59
60static struct of_device_id max14577_dt_match[] = {
61 {
62 .compatible = "maxim,max14577",
63 .data = (void *)MAXIM_DEVICE_TYPE_MAX14577,
64 },
65 {
66 .compatible = "maxim,max77836",
67 .data = (void *)MAXIM_DEVICE_TYPE_MAX77836,
68 },
69 {},
70};
71
72static bool max14577_muic_volatile_reg(struct device *dev, unsigned int reg)
41{ 73{
42 switch (reg) { 74 switch (reg) {
43 case MAX14577_REG_INT1 ... MAX14577_REG_STATUS3: 75 case MAX14577_REG_INT1 ... MAX14577_REG_STATUS3:
@@ -48,49 +80,221 @@ static bool max14577_volatile_reg(struct device *dev, unsigned int reg)
48 return false; 80 return false;
49} 81}
50 82
51static const struct regmap_config max14577_regmap_config = { 83static bool max77836_muic_volatile_reg(struct device *dev, unsigned int reg)
84{
85 /* Any max14577 volatile registers are also max77836 volatile. */
86 if (max14577_muic_volatile_reg(dev, reg))
87 return true;
88
89 switch (reg) {
90 case MAX77836_FG_REG_VCELL_MSB ... MAX77836_FG_REG_SOC_LSB:
91 case MAX77836_FG_REG_CRATE_MSB ... MAX77836_FG_REG_CRATE_LSB:
92 case MAX77836_FG_REG_STATUS_H ... MAX77836_FG_REG_STATUS_L:
93 case MAX77836_PMIC_REG_INTSRC:
94 case MAX77836_PMIC_REG_TOPSYS_INT:
95 case MAX77836_PMIC_REG_TOPSYS_STAT:
96 return true;
97 default:
98 break;
99 }
100 return false;
101}
102
103static const struct regmap_config max14577_muic_regmap_config = {
52 .reg_bits = 8, 104 .reg_bits = 8,
53 .val_bits = 8, 105 .val_bits = 8,
54 .volatile_reg = max14577_volatile_reg, 106 .volatile_reg = max14577_muic_volatile_reg,
55 .max_register = MAX14577_REG_END, 107 .max_register = MAX14577_REG_END,
56}; 108};
57 109
110static const struct regmap_config max77836_pmic_regmap_config = {
111 .reg_bits = 8,
112 .val_bits = 8,
113 .volatile_reg = max77836_muic_volatile_reg,
114 .max_register = MAX77836_PMIC_REG_END,
115};
116
58static const struct regmap_irq max14577_irqs[] = { 117static const struct regmap_irq max14577_irqs[] = {
59 /* INT1 interrupts */ 118 /* INT1 interrupts */
60 { .reg_offset = 0, .mask = INT1_ADC_MASK, }, 119 { .reg_offset = 0, .mask = MAX14577_INT1_ADC_MASK, },
61 { .reg_offset = 0, .mask = INT1_ADCLOW_MASK, }, 120 { .reg_offset = 0, .mask = MAX14577_INT1_ADCLOW_MASK, },
62 { .reg_offset = 0, .mask = INT1_ADCERR_MASK, }, 121 { .reg_offset = 0, .mask = MAX14577_INT1_ADCERR_MASK, },
63 /* INT2 interrupts */ 122 /* INT2 interrupts */
64 { .reg_offset = 1, .mask = INT2_CHGTYP_MASK, }, 123 { .reg_offset = 1, .mask = MAX14577_INT2_CHGTYP_MASK, },
65 { .reg_offset = 1, .mask = INT2_CHGDETRUN_MASK, }, 124 { .reg_offset = 1, .mask = MAX14577_INT2_CHGDETRUN_MASK, },
66 { .reg_offset = 1, .mask = INT2_DCDTMR_MASK, }, 125 { .reg_offset = 1, .mask = MAX14577_INT2_DCDTMR_MASK, },
67 { .reg_offset = 1, .mask = INT2_DBCHG_MASK, }, 126 { .reg_offset = 1, .mask = MAX14577_INT2_DBCHG_MASK, },
68 { .reg_offset = 1, .mask = INT2_VBVOLT_MASK, }, 127 { .reg_offset = 1, .mask = MAX14577_INT2_VBVOLT_MASK, },
69 /* INT3 interrupts */ 128 /* INT3 interrupts */
70 { .reg_offset = 2, .mask = INT3_EOC_MASK, }, 129 { .reg_offset = 2, .mask = MAX14577_INT3_EOC_MASK, },
71 { .reg_offset = 2, .mask = INT3_CGMBC_MASK, }, 130 { .reg_offset = 2, .mask = MAX14577_INT3_CGMBC_MASK, },
72 { .reg_offset = 2, .mask = INT3_OVP_MASK, }, 131 { .reg_offset = 2, .mask = MAX14577_INT3_OVP_MASK, },
73 { .reg_offset = 2, .mask = INT3_MBCCHGERR_MASK, }, 132 { .reg_offset = 2, .mask = MAX14577_INT3_MBCCHGERR_MASK, },
74}; 133};
75 134
76static const struct regmap_irq_chip max14577_irq_chip = { 135static const struct regmap_irq_chip max14577_irq_chip = {
77 .name = "max14577", 136 .name = "max14577",
78 .status_base = MAX14577_REG_INT1, 137 .status_base = MAX14577_REG_INT1,
79 .mask_base = MAX14577_REG_INTMASK1, 138 .mask_base = MAX14577_REG_INTMASK1,
80 .mask_invert = 1, 139 .mask_invert = true,
81 .num_regs = 3, 140 .num_regs = 3,
82 .irqs = max14577_irqs, 141 .irqs = max14577_irqs,
83 .num_irqs = ARRAY_SIZE(max14577_irqs), 142 .num_irqs = ARRAY_SIZE(max14577_irqs),
84}; 143};
85 144
145static const struct regmap_irq max77836_muic_irqs[] = {
146 /* INT1 interrupts */
147 { .reg_offset = 0, .mask = MAX14577_INT1_ADC_MASK, },
148 { .reg_offset = 0, .mask = MAX14577_INT1_ADCLOW_MASK, },
149 { .reg_offset = 0, .mask = MAX14577_INT1_ADCERR_MASK, },
150 { .reg_offset = 0, .mask = MAX77836_INT1_ADC1K_MASK, },
151 /* INT2 interrupts */
152 { .reg_offset = 1, .mask = MAX14577_INT2_CHGTYP_MASK, },
153 { .reg_offset = 1, .mask = MAX14577_INT2_CHGDETRUN_MASK, },
154 { .reg_offset = 1, .mask = MAX14577_INT2_DCDTMR_MASK, },
155 { .reg_offset = 1, .mask = MAX14577_INT2_DBCHG_MASK, },
156 { .reg_offset = 1, .mask = MAX14577_INT2_VBVOLT_MASK, },
157 { .reg_offset = 1, .mask = MAX77836_INT2_VIDRM_MASK, },
158 /* INT3 interrupts */
159 { .reg_offset = 2, .mask = MAX14577_INT3_EOC_MASK, },
160 { .reg_offset = 2, .mask = MAX14577_INT3_CGMBC_MASK, },
161 { .reg_offset = 2, .mask = MAX14577_INT3_OVP_MASK, },
162 { .reg_offset = 2, .mask = MAX14577_INT3_MBCCHGERR_MASK, },
163};
164
165static const struct regmap_irq_chip max77836_muic_irq_chip = {
166 .name = "max77836-muic",
167 .status_base = MAX14577_REG_INT1,
168 .mask_base = MAX14577_REG_INTMASK1,
169 .mask_invert = true,
170 .num_regs = 3,
171 .irqs = max77836_muic_irqs,
172 .num_irqs = ARRAY_SIZE(max77836_muic_irqs),
173};
174
175static const struct regmap_irq max77836_pmic_irqs[] = {
176 { .reg_offset = 0, .mask = MAX77836_TOPSYS_INT_T120C_MASK, },
177 { .reg_offset = 0, .mask = MAX77836_TOPSYS_INT_T140C_MASK, },
178};
179
180static const struct regmap_irq_chip max77836_pmic_irq_chip = {
181 .name = "max77836-pmic",
182 .status_base = MAX77836_PMIC_REG_TOPSYS_INT,
183 .mask_base = MAX77836_PMIC_REG_TOPSYS_INT_MASK,
184 .mask_invert = false,
185 .num_regs = 1,
186 .irqs = max77836_pmic_irqs,
187 .num_irqs = ARRAY_SIZE(max77836_pmic_irqs),
188};
189
190static void max14577_print_dev_type(struct max14577 *max14577)
191{
192 u8 reg_data, vendor_id, device_id;
193 int ret;
194
195 ret = max14577_read_reg(max14577->regmap, MAX14577_REG_DEVICEID,
196 &reg_data);
197 if (ret) {
198 dev_err(max14577->dev,
199 "Failed to read DEVICEID register: %d\n", ret);
200 return;
201 }
202
203 vendor_id = ((reg_data & DEVID_VENDORID_MASK) >>
204 DEVID_VENDORID_SHIFT);
205 device_id = ((reg_data & DEVID_DEVICEID_MASK) >>
206 DEVID_DEVICEID_SHIFT);
207
208 dev_info(max14577->dev, "Device type: %u (ID: 0x%x, vendor: 0x%x)\n",
209 max14577->dev_type, device_id, vendor_id);
210}
211
212/*
213 * Max77836 specific initialization code for driver probe.
214 * Adds new I2C dummy device, regmap and regmap IRQ chip.
215 * Unmasks Interrupt Source register.
216 *
217 * On success returns 0.
218 * On failure returns errno and reverts any changes done so far (e.g. remove
219 * I2C dummy device), except masking the INT SRC register.
220 */
221static int max77836_init(struct max14577 *max14577)
222{
223 int ret;
224 u8 intsrc_mask;
225
226 max14577->i2c_pmic = i2c_new_dummy(max14577->i2c->adapter,
227 I2C_ADDR_PMIC);
228 if (!max14577->i2c_pmic) {
229 dev_err(max14577->dev, "Failed to register PMIC I2C device\n");
230 return -ENODEV;
231 }
232 i2c_set_clientdata(max14577->i2c_pmic, max14577);
233
234 max14577->regmap_pmic = devm_regmap_init_i2c(max14577->i2c_pmic,
235 &max77836_pmic_regmap_config);
236 if (IS_ERR(max14577->regmap_pmic)) {
237 ret = PTR_ERR(max14577->regmap_pmic);
238 dev_err(max14577->dev, "Failed to allocate PMIC register map: %d\n",
239 ret);
240 goto err;
241 }
242
243 /* Un-mask MAX77836 Interrupt Source register */
244 ret = max14577_read_reg(max14577->regmap_pmic,
245 MAX77836_PMIC_REG_INTSRC_MASK, &intsrc_mask);
246 if (ret < 0) {
247 dev_err(max14577->dev, "Failed to read PMIC register\n");
248 goto err;
249 }
250
251 intsrc_mask &= ~(MAX77836_INTSRC_MASK_TOP_INT_MASK);
252 intsrc_mask &= ~(MAX77836_INTSRC_MASK_MUIC_CHG_INT_MASK);
253 ret = max14577_write_reg(max14577->regmap_pmic,
254 MAX77836_PMIC_REG_INTSRC_MASK, intsrc_mask);
255 if (ret < 0) {
256 dev_err(max14577->dev, "Failed to write PMIC register\n");
257 goto err;
258 }
259
260 ret = regmap_add_irq_chip(max14577->regmap_pmic, max14577->irq,
261 IRQF_TRIGGER_FALLING | IRQF_ONESHOT | IRQF_SHARED,
262 0, &max77836_pmic_irq_chip,
263 &max14577->irq_data_pmic);
264 if (ret != 0) {
265 dev_err(max14577->dev, "Failed to request PMIC IRQ %d: %d\n",
266 max14577->irq, ret);
267 goto err;
268 }
269
270 return 0;
271
272err:
273 i2c_unregister_device(max14577->i2c_pmic);
274
275 return ret;
276}
277
278/*
279 * Max77836 specific de-initialization code for driver remove.
280 */
281static void max77836_remove(struct max14577 *max14577)
282{
283 regmap_del_irq_chip(max14577->irq, max14577->irq_data_pmic);
284 i2c_unregister_device(max14577->i2c_pmic);
285}
286
86static int max14577_i2c_probe(struct i2c_client *i2c, 287static int max14577_i2c_probe(struct i2c_client *i2c,
87 const struct i2c_device_id *id) 288 const struct i2c_device_id *id)
88{ 289{
89 struct max14577 *max14577; 290 struct max14577 *max14577;
90 struct max14577_platform_data *pdata = dev_get_platdata(&i2c->dev); 291 struct max14577_platform_data *pdata = dev_get_platdata(&i2c->dev);
91 struct device_node *np = i2c->dev.of_node; 292 struct device_node *np = i2c->dev.of_node;
92 u8 reg_data;
93 int ret = 0; 293 int ret = 0;
294 const struct regmap_irq_chip *irq_chip;
295 struct mfd_cell *mfd_devs;
296 unsigned int mfd_devs_size;
297 int irq_flags;
94 298
95 if (np) { 299 if (np) {
96 pdata = devm_kzalloc(&i2c->dev, sizeof(*pdata), GFP_KERNEL); 300 pdata = devm_kzalloc(&i2c->dev, sizeof(*pdata), GFP_KERNEL);
@@ -113,7 +317,8 @@ static int max14577_i2c_probe(struct i2c_client *i2c,
113 max14577->i2c = i2c; 317 max14577->i2c = i2c;
114 max14577->irq = i2c->irq; 318 max14577->irq = i2c->irq;
115 319
116 max14577->regmap = devm_regmap_init_i2c(i2c, &max14577_regmap_config); 320 max14577->regmap = devm_regmap_init_i2c(i2c,
321 &max14577_muic_regmap_config);
117 if (IS_ERR(max14577->regmap)) { 322 if (IS_ERR(max14577->regmap)) {
118 ret = PTR_ERR(max14577->regmap); 323 ret = PTR_ERR(max14577->regmap);
119 dev_err(max14577->dev, "Failed to allocate register map: %d\n", 324 dev_err(max14577->dev, "Failed to allocate register map: %d\n",
@@ -121,23 +326,36 @@ static int max14577_i2c_probe(struct i2c_client *i2c,
121 return ret; 326 return ret;
122 } 327 }
123 328
124 ret = max14577_read_reg(max14577->regmap, MAX14577_REG_DEVICEID, 329 if (np) {
125 &reg_data); 330 const struct of_device_id *of_id;
126 if (ret) { 331
127 dev_err(max14577->dev, "Device not found on this channel: %d\n", 332 of_id = of_match_device(max14577_dt_match, &i2c->dev);
128 ret); 333 if (of_id)
129 return ret; 334 max14577->dev_type = (unsigned int)of_id->data;
335 } else {
336 max14577->dev_type = id->driver_data;
337 }
338
339 max14577_print_dev_type(max14577);
340
341 switch (max14577->dev_type) {
342 case MAXIM_DEVICE_TYPE_MAX77836:
343 irq_chip = &max77836_muic_irq_chip;
344 mfd_devs = max77836_devs;
345 mfd_devs_size = ARRAY_SIZE(max77836_devs);
346 irq_flags = IRQF_TRIGGER_FALLING | IRQF_ONESHOT | IRQF_SHARED;
347 break;
348 case MAXIM_DEVICE_TYPE_MAX14577:
349 default:
350 irq_chip = &max14577_irq_chip;
351 mfd_devs = max14577_devs;
352 mfd_devs_size = ARRAY_SIZE(max14577_devs);
353 irq_flags = IRQF_TRIGGER_FALLING | IRQF_ONESHOT;
354 break;
130 } 355 }
131 max14577->vendor_id = ((reg_data & DEVID_VENDORID_MASK) >>
132 DEVID_VENDORID_SHIFT);
133 max14577->device_id = ((reg_data & DEVID_DEVICEID_MASK) >>
134 DEVID_DEVICEID_SHIFT);
135 dev_info(max14577->dev, "Device ID: 0x%x, vendor: 0x%x\n",
136 max14577->device_id, max14577->vendor_id);
137 356
138 ret = regmap_add_irq_chip(max14577->regmap, max14577->irq, 357 ret = regmap_add_irq_chip(max14577->regmap, max14577->irq,
139 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 0, 358 irq_flags, 0, irq_chip,
140 &max14577_irq_chip,
141 &max14577->irq_data); 359 &max14577->irq_data);
142 if (ret != 0) { 360 if (ret != 0) {
143 dev_err(&i2c->dev, "Failed to request IRQ %d: %d\n", 361 dev_err(&i2c->dev, "Failed to request IRQ %d: %d\n",
@@ -145,8 +363,15 @@ static int max14577_i2c_probe(struct i2c_client *i2c,
145 return ret; 363 return ret;
146 } 364 }
147 365
148 ret = mfd_add_devices(max14577->dev, -1, max14577_devs, 366 /* Max77836 specific initialization code (additional regmap) */
149 ARRAY_SIZE(max14577_devs), NULL, 0, 367 if (max14577->dev_type == MAXIM_DEVICE_TYPE_MAX77836) {
368 ret = max77836_init(max14577);
369 if (ret < 0)
370 goto err_max77836;
371 }
372
373 ret = mfd_add_devices(max14577->dev, -1, mfd_devs,
374 mfd_devs_size, NULL, 0,
150 regmap_irq_get_domain(max14577->irq_data)); 375 regmap_irq_get_domain(max14577->irq_data));
151 if (ret < 0) 376 if (ret < 0)
152 goto err_mfd; 377 goto err_mfd;
@@ -156,6 +381,9 @@ static int max14577_i2c_probe(struct i2c_client *i2c,
156 return 0; 381 return 0;
157 382
158err_mfd: 383err_mfd:
384 if (max14577->dev_type == MAXIM_DEVICE_TYPE_MAX77836)
385 max77836_remove(max14577);
386err_max77836:
159 regmap_del_irq_chip(max14577->irq, max14577->irq_data); 387 regmap_del_irq_chip(max14577->irq, max14577->irq_data);
160 388
161 return ret; 389 return ret;
@@ -167,12 +395,15 @@ static int max14577_i2c_remove(struct i2c_client *i2c)
167 395
168 mfd_remove_devices(max14577->dev); 396 mfd_remove_devices(max14577->dev);
169 regmap_del_irq_chip(max14577->irq, max14577->irq_data); 397 regmap_del_irq_chip(max14577->irq, max14577->irq_data);
398 if (max14577->dev_type == MAXIM_DEVICE_TYPE_MAX77836)
399 max77836_remove(max14577);
170 400
171 return 0; 401 return 0;
172} 402}
173 403
174static const struct i2c_device_id max14577_i2c_id[] = { 404static const struct i2c_device_id max14577_i2c_id[] = {
175 { "max14577", 0 }, 405 { "max14577", MAXIM_DEVICE_TYPE_MAX14577, },
406 { "max77836", MAXIM_DEVICE_TYPE_MAX77836, },
176 { } 407 { }
177}; 408};
178MODULE_DEVICE_TABLE(i2c, max14577_i2c_id); 409MODULE_DEVICE_TABLE(i2c, max14577_i2c_id);
@@ -215,11 +446,6 @@ static int max14577_resume(struct device *dev)
215} 446}
216#endif /* CONFIG_PM_SLEEP */ 447#endif /* CONFIG_PM_SLEEP */
217 448
218static struct of_device_id max14577_dt_match[] = {
219 { .compatible = "maxim,max14577", },
220 {},
221};
222
223static SIMPLE_DEV_PM_OPS(max14577_pm, max14577_suspend, max14577_resume); 449static SIMPLE_DEV_PM_OPS(max14577_pm, max14577_suspend, max14577_resume);
224 450
225static struct i2c_driver max14577_i2c_driver = { 451static struct i2c_driver max14577_i2c_driver = {
@@ -236,6 +462,9 @@ static struct i2c_driver max14577_i2c_driver = {
236 462
237static int __init max14577_i2c_init(void) 463static int __init max14577_i2c_init(void)
238{ 464{
465 BUILD_BUG_ON(ARRAY_SIZE(max14577_i2c_id) != MAXIM_DEVICE_TYPE_NUM);
466 BUILD_BUG_ON(ARRAY_SIZE(max14577_dt_match) != MAXIM_DEVICE_TYPE_NUM);
467
239 return i2c_add_driver(&max14577_i2c_driver); 468 return i2c_add_driver(&max14577_i2c_driver);
240} 469}
241subsys_initcall(max14577_i2c_init); 470subsys_initcall(max14577_i2c_init);
@@ -247,5 +476,5 @@ static void __exit max14577_i2c_exit(void)
247module_exit(max14577_i2c_exit); 476module_exit(max14577_i2c_exit);
248 477
249MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>, Krzysztof Kozlowski <k.kozlowski@samsung.com>"); 478MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>, Krzysztof Kozlowski <k.kozlowski@samsung.com>");
250MODULE_DESCRIPTION("MAXIM 14577 multi-function core driver"); 479MODULE_DESCRIPTION("Maxim 14577/77836 multi-function core driver");
251MODULE_LICENSE("GPL"); 480MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/mc13xxx-core.c b/drivers/mfd/mc13xxx-core.c
index 06e64b6fcb89..0c6c21c5b1a8 100644
--- a/drivers/mfd/mc13xxx-core.c
+++ b/drivers/mfd/mc13xxx-core.c
@@ -673,9 +673,13 @@ int mc13xxx_common_init(struct device *dev)
673 if (mc13xxx->flags & MC13XXX_USE_ADC) 673 if (mc13xxx->flags & MC13XXX_USE_ADC)
674 mc13xxx_add_subdevice(mc13xxx, "%s-adc"); 674 mc13xxx_add_subdevice(mc13xxx, "%s-adc");
675 675
676 if (mc13xxx->flags & MC13XXX_USE_CODEC) 676 if (mc13xxx->flags & MC13XXX_USE_CODEC) {
677 mc13xxx_add_subdevice_pdata(mc13xxx, "%s-codec", 677 if (pdata)
678 pdata->codec, sizeof(*pdata->codec)); 678 mc13xxx_add_subdevice_pdata(mc13xxx, "%s-codec",
679 pdata->codec, sizeof(*pdata->codec));
680 else
681 mc13xxx_add_subdevice(mc13xxx, "%s-codec");
682 }
679 683
680 if (mc13xxx->flags & MC13XXX_USE_RTC) 684 if (mc13xxx->flags & MC13XXX_USE_RTC)
681 mc13xxx_add_subdevice(mc13xxx, "%s-rtc"); 685 mc13xxx_add_subdevice(mc13xxx, "%s-rtc");
diff --git a/drivers/mfd/rtsx_pcr.c b/drivers/mfd/rtsx_pcr.c
index c9de3d598ea5..1d15735f9ef9 100644
--- a/drivers/mfd/rtsx_pcr.c
+++ b/drivers/mfd/rtsx_pcr.c
@@ -338,28 +338,58 @@ int rtsx_pci_transfer_data(struct rtsx_pcr *pcr, struct scatterlist *sglist,
338 int num_sg, bool read, int timeout) 338 int num_sg, bool read, int timeout)
339{ 339{
340 struct completion trans_done; 340 struct completion trans_done;
341 int err = 0, count; 341 u8 dir;
342 int err = 0, i, count;
342 long timeleft; 343 long timeleft;
343 unsigned long flags; 344 unsigned long flags;
345 struct scatterlist *sg;
346 enum dma_data_direction dma_dir;
347 u32 val;
348 dma_addr_t addr;
349 unsigned int len;
350
351 dev_dbg(&(pcr->pci->dev), "--> %s: num_sg = %d\n", __func__, num_sg);
352
353 /* don't transfer data during abort processing */
354 if (pcr->remove_pci)
355 return -EINVAL;
356
357 if ((sglist == NULL) || (num_sg <= 0))
358 return -EINVAL;
344 359
345 count = rtsx_pci_dma_map_sg(pcr, sglist, num_sg, read); 360 if (read) {
361 dir = DEVICE_TO_HOST;
362 dma_dir = DMA_FROM_DEVICE;
363 } else {
364 dir = HOST_TO_DEVICE;
365 dma_dir = DMA_TO_DEVICE;
366 }
367
368 count = dma_map_sg(&(pcr->pci->dev), sglist, num_sg, dma_dir);
346 if (count < 1) { 369 if (count < 1) {
347 dev_err(&(pcr->pci->dev), "scatterlist map failed\n"); 370 dev_err(&(pcr->pci->dev), "scatterlist map failed\n");
348 return -EINVAL; 371 return -EINVAL;
349 } 372 }
350 dev_dbg(&(pcr->pci->dev), "DMA mapping count: %d\n", count); 373 dev_dbg(&(pcr->pci->dev), "DMA mapping count: %d\n", count);
351 374
375 val = ((u32)(dir & 0x01) << 29) | TRIG_DMA | ADMA_MODE;
376 pcr->sgi = 0;
377 for_each_sg(sglist, sg, count, i) {
378 addr = sg_dma_address(sg);
379 len = sg_dma_len(sg);
380 rtsx_pci_add_sg_tbl(pcr, addr, len, i == count - 1);
381 }
352 382
353 spin_lock_irqsave(&pcr->lock, flags); 383 spin_lock_irqsave(&pcr->lock, flags);
354 384
355 pcr->done = &trans_done; 385 pcr->done = &trans_done;
356 pcr->trans_result = TRANS_NOT_READY; 386 pcr->trans_result = TRANS_NOT_READY;
357 init_completion(&trans_done); 387 init_completion(&trans_done);
388 rtsx_pci_writel(pcr, RTSX_HDBAR, pcr->host_sg_tbl_addr);
389 rtsx_pci_writel(pcr, RTSX_HDBCTLR, val);
358 390
359 spin_unlock_irqrestore(&pcr->lock, flags); 391 spin_unlock_irqrestore(&pcr->lock, flags);
360 392
361 rtsx_pci_dma_transfer(pcr, sglist, count, read);
362
363 timeleft = wait_for_completion_interruptible_timeout( 393 timeleft = wait_for_completion_interruptible_timeout(
364 &trans_done, msecs_to_jiffies(timeout)); 394 &trans_done, msecs_to_jiffies(timeout));
365 if (timeleft <= 0) { 395 if (timeleft <= 0) {
@@ -383,7 +413,7 @@ out:
383 pcr->done = NULL; 413 pcr->done = NULL;
384 spin_unlock_irqrestore(&pcr->lock, flags); 414 spin_unlock_irqrestore(&pcr->lock, flags);
385 415
386 rtsx_pci_dma_unmap_sg(pcr, sglist, num_sg, read); 416 dma_unmap_sg(&(pcr->pci->dev), sglist, num_sg, dma_dir);
387 417
388 if ((err < 0) && (err != -ENODEV)) 418 if ((err < 0) && (err != -ENODEV))
389 rtsx_pci_stop_cmd(pcr); 419 rtsx_pci_stop_cmd(pcr);
@@ -395,73 +425,6 @@ out:
395} 425}
396EXPORT_SYMBOL_GPL(rtsx_pci_transfer_data); 426EXPORT_SYMBOL_GPL(rtsx_pci_transfer_data);
397 427
398int rtsx_pci_dma_map_sg(struct rtsx_pcr *pcr, struct scatterlist *sglist,
399 int num_sg, bool read)
400{
401 enum dma_data_direction dir = read ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
402
403 if (pcr->remove_pci)
404 return -EINVAL;
405
406 if ((sglist == NULL) || num_sg < 1)
407 return -EINVAL;
408
409 return dma_map_sg(&(pcr->pci->dev), sglist, num_sg, dir);
410}
411EXPORT_SYMBOL_GPL(rtsx_pci_dma_map_sg);
412
413int rtsx_pci_dma_unmap_sg(struct rtsx_pcr *pcr, struct scatterlist *sglist,
414 int num_sg, bool read)
415{
416 enum dma_data_direction dir = read ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
417
418 if (pcr->remove_pci)
419 return -EINVAL;
420
421 if (sglist == NULL || num_sg < 1)
422 return -EINVAL;
423
424 dma_unmap_sg(&(pcr->pci->dev), sglist, num_sg, dir);
425 return num_sg;
426}
427EXPORT_SYMBOL_GPL(rtsx_pci_dma_unmap_sg);
428
429int rtsx_pci_dma_transfer(struct rtsx_pcr *pcr, struct scatterlist *sglist,
430 int sg_count, bool read)
431{
432 struct scatterlist *sg;
433 dma_addr_t addr;
434 unsigned int len;
435 int i;
436 u32 val;
437 u8 dir = read ? DEVICE_TO_HOST : HOST_TO_DEVICE;
438 unsigned long flags;
439
440 if (pcr->remove_pci)
441 return -EINVAL;
442
443 if ((sglist == NULL) || (sg_count < 1))
444 return -EINVAL;
445
446 val = ((u32)(dir & 0x01) << 29) | TRIG_DMA | ADMA_MODE;
447 pcr->sgi = 0;
448 for_each_sg(sglist, sg, sg_count, i) {
449 addr = sg_dma_address(sg);
450 len = sg_dma_len(sg);
451 rtsx_pci_add_sg_tbl(pcr, addr, len, i == sg_count - 1);
452 }
453
454 spin_lock_irqsave(&pcr->lock, flags);
455
456 rtsx_pci_writel(pcr, RTSX_HDBAR, pcr->host_sg_tbl_addr);
457 rtsx_pci_writel(pcr, RTSX_HDBCTLR, val);
458
459 spin_unlock_irqrestore(&pcr->lock, flags);
460
461 return 0;
462}
463EXPORT_SYMBOL_GPL(rtsx_pci_dma_transfer);
464
465int rtsx_pci_read_ppbuf(struct rtsx_pcr *pcr, u8 *buf, int buf_len) 428int rtsx_pci_read_ppbuf(struct rtsx_pcr *pcr, u8 *buf, int buf_len)
466{ 429{
467 int err; 430 int err;
@@ -873,8 +836,6 @@ static irqreturn_t rtsx_pci_isr(int irq, void *dev_id)
873 int_reg = rtsx_pci_readl(pcr, RTSX_BIPR); 836 int_reg = rtsx_pci_readl(pcr, RTSX_BIPR);
874 /* Clear interrupt flag */ 837 /* Clear interrupt flag */
875 rtsx_pci_writel(pcr, RTSX_BIPR, int_reg); 838 rtsx_pci_writel(pcr, RTSX_BIPR, int_reg);
876 dev_dbg(&pcr->pci->dev, "=========== BIPR 0x%8x ==========\n", int_reg);
877
878 if ((int_reg & pcr->bier) == 0) { 839 if ((int_reg & pcr->bier) == 0) {
879 spin_unlock(&pcr->lock); 840 spin_unlock(&pcr->lock);
880 return IRQ_NONE; 841 return IRQ_NONE;
@@ -905,28 +866,17 @@ static irqreturn_t rtsx_pci_isr(int irq, void *dev_id)
905 } 866 }
906 867
907 if (int_reg & (NEED_COMPLETE_INT | DELINK_INT)) { 868 if (int_reg & (NEED_COMPLETE_INT | DELINK_INT)) {
908 if (int_reg & (TRANS_FAIL_INT | DELINK_INT)) 869 if (int_reg & (TRANS_FAIL_INT | DELINK_INT)) {
909 pcr->trans_result = TRANS_RESULT_FAIL; 870 pcr->trans_result = TRANS_RESULT_FAIL;
910 else if (int_reg & TRANS_OK_INT) 871 if (pcr->done)
872 complete(pcr->done);
873 } else if (int_reg & TRANS_OK_INT) {
911 pcr->trans_result = TRANS_RESULT_OK; 874 pcr->trans_result = TRANS_RESULT_OK;
912 875 if (pcr->done)
913 if (pcr->done) 876 complete(pcr->done);
914 complete(pcr->done);
915
916 if (int_reg & SD_EXIST) {
917 struct rtsx_slot *slot = &pcr->slots[RTSX_SD_CARD];
918 if (slot && slot->done_transfer)
919 slot->done_transfer(slot->p_dev);
920 }
921
922 if (int_reg & MS_EXIST) {
923 struct rtsx_slot *slot = &pcr->slots[RTSX_SD_CARD];
924 if (slot && slot->done_transfer)
925 slot->done_transfer(slot->p_dev);
926 } 877 }
927 } 878 }
928 879
929
930 if (pcr->card_inserted || pcr->card_removed) 880 if (pcr->card_inserted || pcr->card_removed)
931 schedule_delayed_work(&pcr->carddet_work, 881 schedule_delayed_work(&pcr->carddet_work,
932 msecs_to_jiffies(200)); 882 msecs_to_jiffies(200));
diff --git a/drivers/mfd/rtsx_usb.c b/drivers/mfd/rtsx_usb.c
index b53b9d46cc45..141ea52c46e3 100644
--- a/drivers/mfd/rtsx_usb.c
+++ b/drivers/mfd/rtsx_usb.c
@@ -67,7 +67,7 @@ static int rtsx_usb_bulk_transfer_sglist(struct rtsx_ucr *ucr,
67 ucr->sg_timer.expires = jiffies + msecs_to_jiffies(timeout); 67 ucr->sg_timer.expires = jiffies + msecs_to_jiffies(timeout);
68 add_timer(&ucr->sg_timer); 68 add_timer(&ucr->sg_timer);
69 usb_sg_wait(&ucr->current_sg); 69 usb_sg_wait(&ucr->current_sg);
70 del_timer(&ucr->sg_timer); 70 del_timer_sync(&ucr->sg_timer);
71 71
72 if (act_len) 72 if (act_len)
73 *act_len = ucr->current_sg.bytes; 73 *act_len = ucr->current_sg.bytes;
@@ -644,14 +644,14 @@ static int rtsx_usb_probe(struct usb_interface *intf,
644 if (ret) 644 if (ret)
645 goto out_init_fail; 645 goto out_init_fail;
646 646
647 /* initialize USB SG transfer timer */
648 setup_timer(&ucr->sg_timer, rtsx_usb_sg_timed_out, (unsigned long) ucr);
649
647 ret = mfd_add_devices(&intf->dev, usb_dev->devnum, rtsx_usb_cells, 650 ret = mfd_add_devices(&intf->dev, usb_dev->devnum, rtsx_usb_cells,
648 ARRAY_SIZE(rtsx_usb_cells), NULL, 0, NULL); 651 ARRAY_SIZE(rtsx_usb_cells), NULL, 0, NULL);
649 if (ret) 652 if (ret)
650 goto out_init_fail; 653 goto out_init_fail;
651 654
652 /* initialize USB SG transfer timer */
653 init_timer(&ucr->sg_timer);
654 setup_timer(&ucr->sg_timer, rtsx_usb_sg_timed_out, (unsigned long) ucr);
655#ifdef CONFIG_PM 655#ifdef CONFIG_PM
656 intf->needs_remote_wakeup = 1; 656 intf->needs_remote_wakeup = 1;
657 usb_enable_autosuspend(usb_dev); 657 usb_enable_autosuspend(usb_dev);
@@ -687,9 +687,15 @@ static int rtsx_usb_suspend(struct usb_interface *intf, pm_message_t message)
687 dev_dbg(&intf->dev, "%s called with pm message 0x%04u\n", 687 dev_dbg(&intf->dev, "%s called with pm message 0x%04u\n",
688 __func__, message.event); 688 __func__, message.event);
689 689
690 /*
691 * Call to make sure LED is off during suspend to save more power.
692 * It is NOT a permanent state and could be turned on anytime later.
693 * Thus no need to call turn_on when resunming.
694 */
690 mutex_lock(&ucr->dev_mutex); 695 mutex_lock(&ucr->dev_mutex);
691 rtsx_usb_turn_off_led(ucr); 696 rtsx_usb_turn_off_led(ucr);
692 mutex_unlock(&ucr->dev_mutex); 697 mutex_unlock(&ucr->dev_mutex);
698
693 return 0; 699 return 0;
694} 700}
695 701
diff --git a/drivers/mfd/stmpe-i2c.c b/drivers/mfd/stmpe-i2c.c
index 0da02e11d58e..a45f9c0a330a 100644
--- a/drivers/mfd/stmpe-i2c.c
+++ b/drivers/mfd/stmpe-i2c.c
@@ -14,6 +14,7 @@
14#include <linux/kernel.h> 14#include <linux/kernel.h>
15#include <linux/module.h> 15#include <linux/module.h>
16#include <linux/types.h> 16#include <linux/types.h>
17#include <linux/of_device.h>
17#include "stmpe.h" 18#include "stmpe.h"
18 19
19static int i2c_reg_read(struct stmpe *stmpe, u8 reg) 20static int i2c_reg_read(struct stmpe *stmpe, u8 reg)
@@ -52,15 +53,41 @@ static struct stmpe_client_info i2c_ci = {
52 .write_block = i2c_block_write, 53 .write_block = i2c_block_write,
53}; 54};
54 55
56static const struct of_device_id stmpe_of_match[] = {
57 { .compatible = "st,stmpe610", .data = (void *)STMPE610, },
58 { .compatible = "st,stmpe801", .data = (void *)STMPE801, },
59 { .compatible = "st,stmpe811", .data = (void *)STMPE811, },
60 { .compatible = "st,stmpe1601", .data = (void *)STMPE1601, },
61 { .compatible = "st,stmpe1801", .data = (void *)STMPE1801, },
62 { .compatible = "st,stmpe2401", .data = (void *)STMPE2401, },
63 { .compatible = "st,stmpe2403", .data = (void *)STMPE2403, },
64 {},
65};
66MODULE_DEVICE_TABLE(of, stmpe_of_match);
67
55static int 68static int
56stmpe_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) 69stmpe_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
57{ 70{
71 int partnum;
72 const struct of_device_id *of_id;
73
58 i2c_ci.data = (void *)id; 74 i2c_ci.data = (void *)id;
59 i2c_ci.irq = i2c->irq; 75 i2c_ci.irq = i2c->irq;
60 i2c_ci.client = i2c; 76 i2c_ci.client = i2c;
61 i2c_ci.dev = &i2c->dev; 77 i2c_ci.dev = &i2c->dev;
62 78
63 return stmpe_probe(&i2c_ci, id->driver_data); 79 of_id = of_match_device(stmpe_of_match, &i2c->dev);
80 if (!of_id) {
81 /*
82 * This happens when the I2C ID matches the node name
83 * but no real compatible string has been given.
84 */
85 dev_info(&i2c->dev, "matching on node name, compatible is preferred\n");
86 partnum = id->driver_data;
87 } else
88 partnum = (int)of_id->data;
89
90 return stmpe_probe(&i2c_ci, partnum);
64} 91}
65 92
66static int stmpe_i2c_remove(struct i2c_client *i2c) 93static int stmpe_i2c_remove(struct i2c_client *i2c)
@@ -89,6 +116,7 @@ static struct i2c_driver stmpe_i2c_driver = {
89#ifdef CONFIG_PM 116#ifdef CONFIG_PM
90 .pm = &stmpe_dev_pm_ops, 117 .pm = &stmpe_dev_pm_ops,
91#endif 118#endif
119 .of_match_table = stmpe_of_match,
92 }, 120 },
93 .probe = stmpe_i2c_probe, 121 .probe = stmpe_i2c_probe,
94 .remove = stmpe_i2c_remove, 122 .remove = stmpe_i2c_remove,
diff --git a/drivers/mfd/stmpe.c b/drivers/mfd/stmpe.c
index 4a91f6771fb8..3b6bfa7184ad 100644
--- a/drivers/mfd/stmpe.c
+++ b/drivers/mfd/stmpe.c
@@ -20,6 +20,7 @@
20#include <linux/slab.h> 20#include <linux/slab.h>
21#include <linux/mfd/core.h> 21#include <linux/mfd/core.h>
22#include <linux/delay.h> 22#include <linux/delay.h>
23#include <linux/regulator/consumer.h>
23#include "stmpe.h" 24#include "stmpe.h"
24 25
25static int __stmpe_enable(struct stmpe *stmpe, unsigned int blocks) 26static int __stmpe_enable(struct stmpe *stmpe, unsigned int blocks)
@@ -605,9 +606,18 @@ static int stmpe1601_enable(struct stmpe *stmpe, unsigned int blocks,
605 606
606 if (blocks & STMPE_BLOCK_GPIO) 607 if (blocks & STMPE_BLOCK_GPIO)
607 mask |= STMPE1601_SYS_CTRL_ENABLE_GPIO; 608 mask |= STMPE1601_SYS_CTRL_ENABLE_GPIO;
609 else
610 mask &= ~STMPE1601_SYS_CTRL_ENABLE_GPIO;
608 611
609 if (blocks & STMPE_BLOCK_KEYPAD) 612 if (blocks & STMPE_BLOCK_KEYPAD)
610 mask |= STMPE1601_SYS_CTRL_ENABLE_KPC; 613 mask |= STMPE1601_SYS_CTRL_ENABLE_KPC;
614 else
615 mask &= ~STMPE1601_SYS_CTRL_ENABLE_KPC;
616
617 if (blocks & STMPE_BLOCK_PWM)
618 mask |= STMPE1601_SYS_CTRL_ENABLE_SPWM;
619 else
620 mask &= ~STMPE1601_SYS_CTRL_ENABLE_SPWM;
611 621
612 return __stmpe_set_bits(stmpe, STMPE1601_REG_SYS_CTRL, mask, 622 return __stmpe_set_bits(stmpe, STMPE1601_REG_SYS_CTRL, mask,
613 enable ? mask : 0); 623 enable ? mask : 0);
@@ -986,9 +996,6 @@ static int stmpe_irq_init(struct stmpe *stmpe, struct device_node *np)
986 int base = 0; 996 int base = 0;
987 int num_irqs = stmpe->variant->num_irqs; 997 int num_irqs = stmpe->variant->num_irqs;
988 998
989 if (!np)
990 base = stmpe->irq_base;
991
992 stmpe->domain = irq_domain_add_simple(np, num_irqs, base, 999 stmpe->domain = irq_domain_add_simple(np, num_irqs, base,
993 &stmpe_irq_ops, stmpe); 1000 &stmpe_irq_ops, stmpe);
994 if (!stmpe->domain) { 1001 if (!stmpe->domain) {
@@ -1067,7 +1074,7 @@ static int stmpe_chip_init(struct stmpe *stmpe)
1067static int stmpe_add_device(struct stmpe *stmpe, const struct mfd_cell *cell) 1074static int stmpe_add_device(struct stmpe *stmpe, const struct mfd_cell *cell)
1068{ 1075{
1069 return mfd_add_devices(stmpe->dev, stmpe->pdata->id, cell, 1, 1076 return mfd_add_devices(stmpe->dev, stmpe->pdata->id, cell, 1,
1070 NULL, stmpe->irq_base, stmpe->domain); 1077 NULL, 0, stmpe->domain);
1071} 1078}
1072 1079
1073static int stmpe_devices_init(struct stmpe *stmpe) 1080static int stmpe_devices_init(struct stmpe *stmpe)
@@ -1171,12 +1178,23 @@ int stmpe_probe(struct stmpe_client_info *ci, int partnum)
1171 stmpe->dev = ci->dev; 1178 stmpe->dev = ci->dev;
1172 stmpe->client = ci->client; 1179 stmpe->client = ci->client;
1173 stmpe->pdata = pdata; 1180 stmpe->pdata = pdata;
1174 stmpe->irq_base = pdata->irq_base;
1175 stmpe->ci = ci; 1181 stmpe->ci = ci;
1176 stmpe->partnum = partnum; 1182 stmpe->partnum = partnum;
1177 stmpe->variant = stmpe_variant_info[partnum]; 1183 stmpe->variant = stmpe_variant_info[partnum];
1178 stmpe->regs = stmpe->variant->regs; 1184 stmpe->regs = stmpe->variant->regs;
1179 stmpe->num_gpios = stmpe->variant->num_gpios; 1185 stmpe->num_gpios = stmpe->variant->num_gpios;
1186 stmpe->vcc = devm_regulator_get_optional(ci->dev, "vcc");
1187 if (!IS_ERR(stmpe->vcc)) {
1188 ret = regulator_enable(stmpe->vcc);
1189 if (ret)
1190 dev_warn(ci->dev, "failed to enable VCC supply\n");
1191 }
1192 stmpe->vio = devm_regulator_get_optional(ci->dev, "vio");
1193 if (!IS_ERR(stmpe->vio)) {
1194 ret = regulator_enable(stmpe->vio);
1195 if (ret)
1196 dev_warn(ci->dev, "failed to enable VIO supply\n");
1197 }
1180 dev_set_drvdata(stmpe->dev, stmpe); 1198 dev_set_drvdata(stmpe->dev, stmpe);
1181 1199
1182 if (ci->init) 1200 if (ci->init)
@@ -1243,6 +1261,11 @@ int stmpe_probe(struct stmpe_client_info *ci, int partnum)
1243 1261
1244int stmpe_remove(struct stmpe *stmpe) 1262int stmpe_remove(struct stmpe *stmpe)
1245{ 1263{
1264 if (!IS_ERR(stmpe->vio))
1265 regulator_disable(stmpe->vio);
1266 if (!IS_ERR(stmpe->vcc))
1267 regulator_disable(stmpe->vcc);
1268
1246 mfd_remove_devices(stmpe->dev); 1269 mfd_remove_devices(stmpe->dev);
1247 1270
1248 return 0; 1271 return 0;
diff --git a/drivers/mfd/stmpe.h b/drivers/mfd/stmpe.h
index 6639f1b0fef5..9e4d21d37a11 100644
--- a/drivers/mfd/stmpe.h
+++ b/drivers/mfd/stmpe.h
@@ -192,7 +192,7 @@ int stmpe_remove(struct stmpe *stmpe);
192 192
193#define STMPE1601_SYS_CTRL_ENABLE_GPIO (1 << 3) 193#define STMPE1601_SYS_CTRL_ENABLE_GPIO (1 << 3)
194#define STMPE1601_SYS_CTRL_ENABLE_KPC (1 << 1) 194#define STMPE1601_SYS_CTRL_ENABLE_KPC (1 << 1)
195#define STMPE1601_SYSCON_ENABLE_SPWM (1 << 0) 195#define STMPE1601_SYS_CTRL_ENABLE_SPWM (1 << 0)
196 196
197/* The 1601/2403 share the same masks */ 197/* The 1601/2403 share the same masks */
198#define STMPE1601_AUTOSLEEP_TIMEOUT_MASK (0x7) 198#define STMPE1601_AUTOSLEEP_TIMEOUT_MASK (0x7)
diff --git a/drivers/mfd/tps65090.c b/drivers/mfd/tps65090.c
index ba1a25d758c1..1c3e6e2efe41 100644
--- a/drivers/mfd/tps65090.c
+++ b/drivers/mfd/tps65090.c
@@ -32,14 +32,6 @@
32#define NUM_INT_REG 2 32#define NUM_INT_REG 2
33#define TOTAL_NUM_REG 0x18 33#define TOTAL_NUM_REG 0x18
34 34
35/* interrupt status registers */
36#define TPS65090_INT_STS 0x0
37#define TPS65090_INT_STS2 0x1
38
39/* interrupt mask registers */
40#define TPS65090_INT_MSK 0x2
41#define TPS65090_INT_MSK2 0x3
42
43#define TPS65090_INT1_MASK_VAC_STATUS_CHANGE 1 35#define TPS65090_INT1_MASK_VAC_STATUS_CHANGE 1
44#define TPS65090_INT1_MASK_VSYS_STATUS_CHANGE 2 36#define TPS65090_INT1_MASK_VSYS_STATUS_CHANGE 2
45#define TPS65090_INT1_MASK_BAT_STATUS_CHANGE 3 37#define TPS65090_INT1_MASK_BAT_STATUS_CHANGE 3
@@ -64,11 +56,16 @@ static struct resource charger_resources[] = {
64 } 56 }
65}; 57};
66 58
67static const struct mfd_cell tps65090s[] = { 59enum tps65090_cells {
68 { 60 PMIC = 0,
61 CHARGER = 1,
62};
63
64static struct mfd_cell tps65090s[] = {
65 [PMIC] = {
69 .name = "tps65090-pmic", 66 .name = "tps65090-pmic",
70 }, 67 },
71 { 68 [CHARGER] = {
72 .name = "tps65090-charger", 69 .name = "tps65090-charger",
73 .num_resources = ARRAY_SIZE(charger_resources), 70 .num_resources = ARRAY_SIZE(charger_resources),
74 .resources = &charger_resources[0], 71 .resources = &charger_resources[0],
@@ -139,17 +136,26 @@ static struct regmap_irq_chip tps65090_irq_chip = {
139 .irqs = tps65090_irqs, 136 .irqs = tps65090_irqs,
140 .num_irqs = ARRAY_SIZE(tps65090_irqs), 137 .num_irqs = ARRAY_SIZE(tps65090_irqs),
141 .num_regs = NUM_INT_REG, 138 .num_regs = NUM_INT_REG,
142 .status_base = TPS65090_INT_STS, 139 .status_base = TPS65090_REG_INTR_STS,
143 .mask_base = TPS65090_INT_MSK, 140 .mask_base = TPS65090_REG_INTR_MASK,
144 .mask_invert = true, 141 .mask_invert = true,
145}; 142};
146 143
147static bool is_volatile_reg(struct device *dev, unsigned int reg) 144static bool is_volatile_reg(struct device *dev, unsigned int reg)
148{ 145{
149 if ((reg == TPS65090_INT_STS) || (reg == TPS65090_INT_STS2)) 146 /* Nearly all registers have status bits mixed in, except a few */
150 return true; 147 switch (reg) {
151 else 148 case TPS65090_REG_INTR_MASK:
149 case TPS65090_REG_INTR_MASK2:
150 case TPS65090_REG_CG_CTRL0:
151 case TPS65090_REG_CG_CTRL1:
152 case TPS65090_REG_CG_CTRL2:
153 case TPS65090_REG_CG_CTRL3:
154 case TPS65090_REG_CG_CTRL4:
155 case TPS65090_REG_CG_CTRL5:
152 return false; 156 return false;
157 }
158 return true;
153} 159}
154 160
155static const struct regmap_config tps65090_regmap_config = { 161static const struct regmap_config tps65090_regmap_config = {
@@ -211,6 +217,9 @@ static int tps65090_i2c_probe(struct i2c_client *client,
211 "IRQ init failed with err: %d\n", ret); 217 "IRQ init failed with err: %d\n", ret);
212 return ret; 218 return ret;
213 } 219 }
220 } else {
221 /* Don't tell children they have an IRQ that'll never fire */
222 tps65090s[CHARGER].num_resources = 0;
214 } 223 }
215 224
216 ret = mfd_add_devices(tps65090->dev, -1, tps65090s, 225 ret = mfd_add_devices(tps65090->dev, -1, tps65090s,
diff --git a/drivers/mfd/tps6586x.c b/drivers/mfd/tps6586x.c
index bbd54414a75d..835e5549ecdd 100644
--- a/drivers/mfd/tps6586x.c
+++ b/drivers/mfd/tps6586x.c
@@ -495,6 +495,10 @@ static void tps6586x_print_version(struct i2c_client *client, int version)
495 case TPS658623: 495 case TPS658623:
496 name = "TPS658623"; 496 name = "TPS658623";
497 break; 497 break;
498 case TPS658640:
499 case TPS658640v2:
500 name = "TPS658640";
501 break;
498 case TPS658643: 502 case TPS658643:
499 name = "TPS658643"; 503 name = "TPS658643";
500 break; 504 break;
diff --git a/drivers/mfd/twl-core.c b/drivers/mfd/twl-core.c
index e87140bef667..db11b4f40611 100644
--- a/drivers/mfd/twl-core.c
+++ b/drivers/mfd/twl-core.c
@@ -98,7 +98,11 @@
98#define TWL4030_BASEADD_BACKUP 0x0014 98#define TWL4030_BASEADD_BACKUP 0x0014
99#define TWL4030_BASEADD_INT 0x002E 99#define TWL4030_BASEADD_INT 0x002E
100#define TWL4030_BASEADD_PM_MASTER 0x0036 100#define TWL4030_BASEADD_PM_MASTER 0x0036
101
101#define TWL4030_BASEADD_PM_RECEIVER 0x005B 102#define TWL4030_BASEADD_PM_RECEIVER 0x005B
103#define TWL4030_DCDC_GLOBAL_CFG 0x06
104#define SMARTREFLEX_ENABLE BIT(3)
105
102#define TWL4030_BASEADD_RTC 0x001C 106#define TWL4030_BASEADD_RTC 0x001C
103#define TWL4030_BASEADD_SECURED_REG 0x0000 107#define TWL4030_BASEADD_SECURED_REG 0x0000
104 108
@@ -1204,6 +1208,11 @@ twl_probe(struct i2c_client *client, const struct i2c_device_id *id)
1204 * Disable TWL4030/TWL5030 I2C Pull-up on I2C1 and I2C4(SR) interface. 1208 * Disable TWL4030/TWL5030 I2C Pull-up on I2C1 and I2C4(SR) interface.
1205 * Program I2C_SCL_CTRL_PU(bit 0)=0, I2C_SDA_CTRL_PU (bit 2)=0, 1209 * Program I2C_SCL_CTRL_PU(bit 0)=0, I2C_SDA_CTRL_PU (bit 2)=0,
1206 * SR_I2C_SCL_CTRL_PU(bit 4)=0 and SR_I2C_SDA_CTRL_PU(bit 6)=0. 1210 * SR_I2C_SCL_CTRL_PU(bit 4)=0 and SR_I2C_SDA_CTRL_PU(bit 6)=0.
1211 *
1212 * Also, always enable SmartReflex bit as that's needed for omaps to
1213 * to do anything over I2C4 for voltage scaling even if SmartReflex
1214 * is disabled. Without the SmartReflex bit omap sys_clkreq idle
1215 * signal will never trigger for retention idle.
1207 */ 1216 */
1208 if (twl_class_is_4030()) { 1217 if (twl_class_is_4030()) {
1209 u8 temp; 1218 u8 temp;
@@ -1212,6 +1221,12 @@ twl_probe(struct i2c_client *client, const struct i2c_device_id *id)
1212 temp &= ~(SR_I2C_SDA_CTRL_PU | SR_I2C_SCL_CTRL_PU | \ 1221 temp &= ~(SR_I2C_SDA_CTRL_PU | SR_I2C_SCL_CTRL_PU | \
1213 I2C_SDA_CTRL_PU | I2C_SCL_CTRL_PU); 1222 I2C_SDA_CTRL_PU | I2C_SCL_CTRL_PU);
1214 twl_i2c_write_u8(TWL4030_MODULE_INTBR, temp, REG_GPPUPDCTR1); 1223 twl_i2c_write_u8(TWL4030_MODULE_INTBR, temp, REG_GPPUPDCTR1);
1224
1225 twl_i2c_read_u8(TWL_MODULE_PM_RECEIVER, &temp,
1226 TWL4030_DCDC_GLOBAL_CFG);
1227 temp |= SMARTREFLEX_ENABLE;
1228 twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, temp,
1229 TWL4030_DCDC_GLOBAL_CFG);
1215 } 1230 }
1216 1231
1217 if (node) { 1232 if (node) {
generated by cgit v1.2.2 (git 2.25.0) at 2025-09-17 23:34:10 -0400