aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/mfd
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/mfd')
-rw-r--r--drivers/mfd/88pm860x-core.c36
-rw-r--r--drivers/mfd/Kconfig16
-rw-r--r--drivers/mfd/Makefile3
-rw-r--r--drivers/mfd/ab3550-core.c28
-rw-r--r--drivers/mfd/ab8500-core.c306
-rw-r--r--drivers/mfd/ab8500-debugfs.c1016
-rw-r--r--drivers/mfd/ab8500-spi.c143
-rw-r--r--drivers/mfd/asic3.c62
-rw-r--r--drivers/mfd/cs5535-mfd.c151
-rw-r--r--drivers/mfd/ezx-pcap.c25
-rw-r--r--drivers/mfd/htc-egpio.c27
-rw-r--r--drivers/mfd/htc-i2cpld.c40
-rw-r--r--drivers/mfd/jz4740-adc.c25
-rw-r--r--drivers/mfd/max8925-core.c30
-rw-r--r--drivers/mfd/max8998-irq.c37
-rw-r--r--drivers/mfd/max8998.c134
-rw-r--r--drivers/mfd/mc13xxx-core.c2
-rw-r--r--drivers/mfd/mfd-core.c4
-rw-r--r--drivers/mfd/sh_mobile_sdhi.c6
-rw-r--r--drivers/mfd/sm501.c9
-rw-r--r--drivers/mfd/stmpe.c28
-rw-r--r--drivers/mfd/t7l66xb.c20
-rw-r--r--drivers/mfd/tc6393xb.c22
-rw-r--r--drivers/mfd/tps65010.c2
-rw-r--r--drivers/mfd/tps6586x.c36
-rw-r--r--drivers/mfd/twl-core.c2
-rw-r--r--drivers/mfd/twl4030-irq.c28
-rw-r--r--drivers/mfd/twl6030-irq.c2
-rw-r--r--drivers/mfd/vx855.c2
-rw-r--r--drivers/mfd/wm831x-core.c17
-rw-r--r--drivers/mfd/wm831x-i2c.c14
-rw-r--r--drivers/mfd/wm831x-irq.c53
-rw-r--r--drivers/mfd/wm831x-spi.c18
-rw-r--r--drivers/mfd/wm8350-irq.c32
-rw-r--r--drivers/mfd/wm8994-core.c139
-rw-r--r--drivers/mfd/wm8994-irq.c32
36 files changed, 1510 insertions, 1037 deletions
diff --git a/drivers/mfd/88pm860x-core.c b/drivers/mfd/88pm860x-core.c
index 20895e7a99c9..793300c554b4 100644
--- a/drivers/mfd/88pm860x-core.c
+++ b/drivers/mfd/88pm860x-core.c
@@ -361,12 +361,6 @@ static struct pm860x_irq_data pm860x_irqs[] = {
361 }, 361 },
362}; 362};
363 363
364static inline struct pm860x_irq_data *irq_to_pm860x(struct pm860x_chip *chip,
365 int irq)
366{
367 return &pm860x_irqs[irq - chip->irq_base];
368}
369
370static irqreturn_t pm860x_irq(int irq, void *data) 364static irqreturn_t pm860x_irq(int irq, void *data)
371{ 365{
372 struct pm860x_chip *chip = data; 366 struct pm860x_chip *chip = data;
@@ -388,16 +382,16 @@ static irqreturn_t pm860x_irq(int irq, void *data)
388 return IRQ_HANDLED; 382 return IRQ_HANDLED;
389} 383}
390 384
391static void pm860x_irq_lock(unsigned int irq) 385static void pm860x_irq_lock(struct irq_data *data)
392{ 386{
393 struct pm860x_chip *chip = get_irq_chip_data(irq); 387 struct pm860x_chip *chip = irq_data_get_irq_chip_data(data);
394 388
395 mutex_lock(&chip->irq_lock); 389 mutex_lock(&chip->irq_lock);
396} 390}
397 391
398static void pm860x_irq_sync_unlock(unsigned int irq) 392static void pm860x_irq_sync_unlock(struct irq_data *data)
399{ 393{
400 struct pm860x_chip *chip = get_irq_chip_data(irq); 394 struct pm860x_chip *chip = irq_data_get_irq_chip_data(data);
401 struct pm860x_irq_data *irq_data; 395 struct pm860x_irq_data *irq_data;
402 struct i2c_client *i2c; 396 struct i2c_client *i2c;
403 static unsigned char cached[3] = {0x0, 0x0, 0x0}; 397 static unsigned char cached[3] = {0x0, 0x0, 0x0};
@@ -439,25 +433,25 @@ static void pm860x_irq_sync_unlock(unsigned int irq)
439 mutex_unlock(&chip->irq_lock); 433 mutex_unlock(&chip->irq_lock);
440} 434}
441 435
442static void pm860x_irq_enable(unsigned int irq) 436static void pm860x_irq_enable(struct irq_data *data)
443{ 437{
444 struct pm860x_chip *chip = get_irq_chip_data(irq); 438 struct pm860x_chip *chip = irq_data_get_irq_chip_data(data);
445 pm860x_irqs[irq - chip->irq_base].enable 439 pm860x_irqs[data->irq - chip->irq_base].enable
446 = pm860x_irqs[irq - chip->irq_base].offs; 440 = pm860x_irqs[data->irq - chip->irq_base].offs;
447} 441}
448 442
449static void pm860x_irq_disable(unsigned int irq) 443static void pm860x_irq_disable(struct irq_data *data)
450{ 444{
451 struct pm860x_chip *chip = get_irq_chip_data(irq); 445 struct pm860x_chip *chip = irq_data_get_irq_chip_data(data);
452 pm860x_irqs[irq - chip->irq_base].enable = 0; 446 pm860x_irqs[data->irq - chip->irq_base].enable = 0;
453} 447}
454 448
455static struct irq_chip pm860x_irq_chip = { 449static struct irq_chip pm860x_irq_chip = {
456 .name = "88pm860x", 450 .name = "88pm860x",
457 .bus_lock = pm860x_irq_lock, 451 .irq_bus_lock = pm860x_irq_lock,
458 .bus_sync_unlock = pm860x_irq_sync_unlock, 452 .irq_bus_sync_unlock = pm860x_irq_sync_unlock,
459 .enable = pm860x_irq_enable, 453 .irq_enable = pm860x_irq_enable,
460 .disable = pm860x_irq_disable, 454 .irq_disable = pm860x_irq_disable,
461}; 455};
462 456
463static int __devinit device_gpadc_init(struct pm860x_chip *chip, 457static int __devinit device_gpadc_init(struct pm860x_chip *chip,
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index da9d2971102e..fd018366d670 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -496,13 +496,13 @@ config EZX_PCAP
496 496
497config AB8500_CORE 497config AB8500_CORE
498 bool "ST-Ericsson AB8500 Mixed Signal Power Management chip" 498 bool "ST-Ericsson AB8500 Mixed Signal Power Management chip"
499 depends on GENERIC_HARDIRQS && ABX500_CORE && SPI_MASTER && ARCH_U8500 499 depends on GENERIC_HARDIRQS && ABX500_CORE
500 select MFD_CORE 500 select MFD_CORE
501 help 501 help
502 Select this option to enable access to AB8500 power management 502 Select this option to enable access to AB8500 power management
503 chip. This connects to U8500 either on the SSP/SPI bus 503 chip. This connects to U8500 either on the SSP/SPI bus (deprecated
504 or the I2C bus via PRCMU. It also adds the irq_chip 504 since hardware version v1.0) or the I2C bus via PRCMU. It also adds
505 parts for handling the Mixed Signal chip events. 505 the irq_chip parts for handling the Mixed Signal chip events.
506 This chip embeds various other multimedia funtionalities as well. 506 This chip embeds various other multimedia funtionalities as well.
507 507
508config AB8500_I2C_CORE 508config AB8500_I2C_CORE
@@ -537,6 +537,14 @@ config AB3550_CORE
537 LEDs, vibrator, system power and temperature, power management 537 LEDs, vibrator, system power and temperature, power management
538 and ALSA sound. 538 and ALSA sound.
539 539
540config MFD_CS5535
541 tristate "Support for CS5535 and CS5536 southbridge core functions"
542 select MFD_CORE
543 depends on PCI
544 ---help---
545 This is the core driver for CS5535/CS5536 MFD functions. This is
546 necessary for using the board's GPIO and MFGPT functionality.
547
540config MFD_TIMBERDALE 548config MFD_TIMBERDALE
541 tristate "Support for the Timberdale FPGA" 549 tristate "Support for the Timberdale FPGA"
542 select MFD_CORE 550 select MFD_CORE
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 848e7eac75aa..a54e2c7c6a1c 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -70,7 +70,7 @@ obj-$(CONFIG_ABX500_CORE) += abx500-core.o
70obj-$(CONFIG_AB3100_CORE) += ab3100-core.o 70obj-$(CONFIG_AB3100_CORE) += ab3100-core.o
71obj-$(CONFIG_AB3100_OTP) += ab3100-otp.o 71obj-$(CONFIG_AB3100_OTP) += ab3100-otp.o
72obj-$(CONFIG_AB3550_CORE) += ab3550-core.o 72obj-$(CONFIG_AB3550_CORE) += ab3550-core.o
73obj-$(CONFIG_AB8500_CORE) += ab8500-core.o ab8500-spi.o 73obj-$(CONFIG_AB8500_CORE) += ab8500-core.o
74obj-$(CONFIG_AB8500_I2C_CORE) += ab8500-i2c.o 74obj-$(CONFIG_AB8500_I2C_CORE) += ab8500-i2c.o
75obj-$(CONFIG_AB8500_DEBUG) += ab8500-debugfs.o 75obj-$(CONFIG_AB8500_DEBUG) += ab8500-debugfs.o
76obj-$(CONFIG_MFD_TIMBERDALE) += timberdale.o 76obj-$(CONFIG_MFD_TIMBERDALE) += timberdale.o
@@ -82,3 +82,4 @@ obj-$(CONFIG_MFD_JZ4740_ADC) += jz4740-adc.o
82obj-$(CONFIG_MFD_TPS6586X) += tps6586x.o 82obj-$(CONFIG_MFD_TPS6586X) += tps6586x.o
83obj-$(CONFIG_MFD_VX855) += vx855.o 83obj-$(CONFIG_MFD_VX855) += vx855.o
84obj-$(CONFIG_MFD_WL1273_CORE) += wl1273-core.o 84obj-$(CONFIG_MFD_WL1273_CORE) += wl1273-core.o
85obj-$(CONFIG_MFD_CS5535) += cs5535-mfd.o
diff --git a/drivers/mfd/ab3550-core.c b/drivers/mfd/ab3550-core.c
index 8a98739e6d9c..5fbca346b998 100644
--- a/drivers/mfd/ab3550-core.c
+++ b/drivers/mfd/ab3550-core.c
@@ -1159,15 +1159,16 @@ static void ab3550_mask_work(struct work_struct *work)
1159 } 1159 }
1160} 1160}
1161 1161
1162static void ab3550_mask(unsigned int irq) 1162static void ab3550_mask(struct irq_data *data)
1163{ 1163{
1164 unsigned long flags; 1164 unsigned long flags;
1165 struct ab3550 *ab; 1165 struct ab3550 *ab;
1166 struct ab3550_platform_data *plf_data; 1166 struct ab3550_platform_data *plf_data;
1167 int irq;
1167 1168
1168 ab = get_irq_chip_data(irq); 1169 ab = irq_data_get_irq_chip_data(data);
1169 plf_data = ab->i2c_client[0]->dev.platform_data; 1170 plf_data = ab->i2c_client[0]->dev.platform_data;
1170 irq -= plf_data->irq.base; 1171 irq = data->irq - plf_data->irq.base;
1171 1172
1172 spin_lock_irqsave(&ab->event_lock, flags); 1173 spin_lock_irqsave(&ab->event_lock, flags);
1173 ab->event_mask[irq / 8] |= BIT(irq % 8); 1174 ab->event_mask[irq / 8] |= BIT(irq % 8);
@@ -1176,15 +1177,16 @@ static void ab3550_mask(unsigned int irq)
1176 schedule_work(&ab->mask_work); 1177 schedule_work(&ab->mask_work);
1177} 1178}
1178 1179
1179static void ab3550_unmask(unsigned int irq) 1180static void ab3550_unmask(struct irq_data *data)
1180{ 1181{
1181 unsigned long flags; 1182 unsigned long flags;
1182 struct ab3550 *ab; 1183 struct ab3550 *ab;
1183 struct ab3550_platform_data *plf_data; 1184 struct ab3550_platform_data *plf_data;
1185 int irq;
1184 1186
1185 ab = get_irq_chip_data(irq); 1187 ab = irq_data_get_irq_chip_data(data);
1186 plf_data = ab->i2c_client[0]->dev.platform_data; 1188 plf_data = ab->i2c_client[0]->dev.platform_data;
1187 irq -= plf_data->irq.base; 1189 irq = data->irq - plf_data->irq.base;
1188 1190
1189 spin_lock_irqsave(&ab->event_lock, flags); 1191 spin_lock_irqsave(&ab->event_lock, flags);
1190 ab->event_mask[irq / 8] &= ~BIT(irq % 8); 1192 ab->event_mask[irq / 8] &= ~BIT(irq % 8);
@@ -1193,20 +1195,16 @@ static void ab3550_unmask(unsigned int irq)
1193 schedule_work(&ab->mask_work); 1195 schedule_work(&ab->mask_work);
1194} 1196}
1195 1197
1196static void noop(unsigned int irq) 1198static void noop(struct irq_data *data)
1197{ 1199{
1198} 1200}
1199 1201
1200static struct irq_chip ab3550_irq_chip = { 1202static struct irq_chip ab3550_irq_chip = {
1201 .name = "ab3550-core", /* Keep the same name as the request */ 1203 .name = "ab3550-core", /* Keep the same name as the request */
1202 .startup = NULL, /* defaults to enable */ 1204 .irq_disable = ab3550_mask, /* No default to mask in chip.c */
1203 .shutdown = NULL, /* defaults to disable */ 1205 .irq_ack = noop,
1204 .enable = NULL, /* defaults to unmask */ 1206 .irq_mask = ab3550_mask,
1205 .disable = ab3550_mask, /* No default to mask in chip.c */ 1207 .irq_unmask = ab3550_unmask,
1206 .ack = noop,
1207 .mask = ab3550_mask,
1208 .unmask = ab3550_unmask,
1209 .end = NULL,
1210}; 1208};
1211 1209
1212struct ab_family_id { 1210struct ab_family_id {
diff --git a/drivers/mfd/ab8500-core.c b/drivers/mfd/ab8500-core.c
index d9640a623ff4..b6887014d687 100644
--- a/drivers/mfd/ab8500-core.c
+++ b/drivers/mfd/ab8500-core.c
@@ -52,6 +52,7 @@
52#define AB8500_IT_LATCH8_REG 0x27 52#define AB8500_IT_LATCH8_REG 0x27
53#define AB8500_IT_LATCH9_REG 0x28 53#define AB8500_IT_LATCH9_REG 0x28
54#define AB8500_IT_LATCH10_REG 0x29 54#define AB8500_IT_LATCH10_REG 0x29
55#define AB8500_IT_LATCH12_REG 0x2B
55#define AB8500_IT_LATCH19_REG 0x32 56#define AB8500_IT_LATCH19_REG 0x32
56#define AB8500_IT_LATCH20_REG 0x33 57#define AB8500_IT_LATCH20_REG 0x33
57#define AB8500_IT_LATCH21_REG 0x34 58#define AB8500_IT_LATCH21_REG 0x34
@@ -98,13 +99,17 @@
98 * offset 0. 99 * offset 0.
99 */ 100 */
100static const int ab8500_irq_regoffset[AB8500_NUM_IRQ_REGS] = { 101static const int ab8500_irq_regoffset[AB8500_NUM_IRQ_REGS] = {
101 0, 1, 2, 3, 4, 6, 7, 8, 9, 18, 19, 20, 21, 102 0, 1, 2, 3, 4, 6, 7, 8, 9, 11, 18, 19, 20, 21,
102}; 103};
103 104
104static int ab8500_get_chip_id(struct device *dev) 105static int ab8500_get_chip_id(struct device *dev)
105{ 106{
106 struct ab8500 *ab8500 = dev_get_drvdata(dev->parent); 107 struct ab8500 *ab8500;
107 return (int)ab8500->chip_id; 108
109 if (!dev)
110 return -EINVAL;
111 ab8500 = dev_get_drvdata(dev->parent);
112 return ab8500 ? (int)ab8500->chip_id : -EINVAL;
108} 113}
109 114
110static int set_register_interruptible(struct ab8500 *ab8500, u8 bank, 115static int set_register_interruptible(struct ab8500 *ab8500, u8 bank,
@@ -228,16 +233,16 @@ static struct abx500_ops ab8500_ops = {
228 .startup_irq_enabled = NULL, 233 .startup_irq_enabled = NULL,
229}; 234};
230 235
231static void ab8500_irq_lock(unsigned int irq) 236static void ab8500_irq_lock(struct irq_data *data)
232{ 237{
233 struct ab8500 *ab8500 = get_irq_chip_data(irq); 238 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
234 239
235 mutex_lock(&ab8500->irq_lock); 240 mutex_lock(&ab8500->irq_lock);
236} 241}
237 242
238static void ab8500_irq_sync_unlock(unsigned int irq) 243static void ab8500_irq_sync_unlock(struct irq_data *data)
239{ 244{
240 struct ab8500 *ab8500 = get_irq_chip_data(irq); 245 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
241 int i; 246 int i;
242 247
243 for (i = 0; i < AB8500_NUM_IRQ_REGS; i++) { 248 for (i = 0; i < AB8500_NUM_IRQ_REGS; i++) {
@@ -248,6 +253,10 @@ static void ab8500_irq_sync_unlock(unsigned int irq)
248 if (new == old) 253 if (new == old)
249 continue; 254 continue;
250 255
256 /* Interrupt register 12 does'nt exist prior to version 0x20 */
257 if (ab8500_irq_regoffset[i] == 11 && ab8500->chip_id < 0x20)
258 continue;
259
251 ab8500->oldmask[i] = new; 260 ab8500->oldmask[i] = new;
252 261
253 reg = AB8500_IT_MASK1_REG + ab8500_irq_regoffset[i]; 262 reg = AB8500_IT_MASK1_REG + ab8500_irq_regoffset[i];
@@ -257,20 +266,20 @@ static void ab8500_irq_sync_unlock(unsigned int irq)
257 mutex_unlock(&ab8500->irq_lock); 266 mutex_unlock(&ab8500->irq_lock);
258} 267}
259 268
260static void ab8500_irq_mask(unsigned int irq) 269static void ab8500_irq_mask(struct irq_data *data)
261{ 270{
262 struct ab8500 *ab8500 = get_irq_chip_data(irq); 271 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
263 int offset = irq - ab8500->irq_base; 272 int offset = data->irq - ab8500->irq_base;
264 int index = offset / 8; 273 int index = offset / 8;
265 int mask = 1 << (offset % 8); 274 int mask = 1 << (offset % 8);
266 275
267 ab8500->mask[index] |= mask; 276 ab8500->mask[index] |= mask;
268} 277}
269 278
270static void ab8500_irq_unmask(unsigned int irq) 279static void ab8500_irq_unmask(struct irq_data *data)
271{ 280{
272 struct ab8500 *ab8500 = get_irq_chip_data(irq); 281 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
273 int offset = irq - ab8500->irq_base; 282 int offset = data->irq - ab8500->irq_base;
274 int index = offset / 8; 283 int index = offset / 8;
275 int mask = 1 << (offset % 8); 284 int mask = 1 << (offset % 8);
276 285
@@ -279,10 +288,10 @@ static void ab8500_irq_unmask(unsigned int irq)
279 288
280static struct irq_chip ab8500_irq_chip = { 289static struct irq_chip ab8500_irq_chip = {
281 .name = "ab8500", 290 .name = "ab8500",
282 .bus_lock = ab8500_irq_lock, 291 .irq_bus_lock = ab8500_irq_lock,
283 .bus_sync_unlock = ab8500_irq_sync_unlock, 292 .irq_bus_sync_unlock = ab8500_irq_sync_unlock,
284 .mask = ab8500_irq_mask, 293 .irq_mask = ab8500_irq_mask,
285 .unmask = ab8500_irq_unmask, 294 .irq_unmask = ab8500_irq_unmask,
286}; 295};
287 296
288static irqreturn_t ab8500_irq(int irq, void *dev) 297static irqreturn_t ab8500_irq(int irq, void *dev)
@@ -297,6 +306,10 @@ static irqreturn_t ab8500_irq(int irq, void *dev)
297 int status; 306 int status;
298 u8 value; 307 u8 value;
299 308
309 /* Interrupt register 12 does'nt exist prior to version 0x20 */
310 if (regoffset == 11 && ab8500->chip_id < 0x20)
311 continue;
312
300 status = get_register_interruptible(ab8500, AB8500_INTERRUPT, 313 status = get_register_interruptible(ab8500, AB8500_INTERRUPT,
301 AB8500_IT_LATCH1_REG + regoffset, &value); 314 AB8500_IT_LATCH1_REG + regoffset, &value);
302 if (status < 0 || value == 0) 315 if (status < 0 || value == 0)
@@ -393,13 +406,195 @@ static struct resource ab8500_poweronkey_db_resources[] = {
393 }, 406 },
394}; 407};
395 408
409static struct resource ab8500_bm_resources[] = {
410 {
411 .name = "MAIN_EXT_CH_NOT_OK",
412 .start = AB8500_INT_MAIN_EXT_CH_NOT_OK,
413 .end = AB8500_INT_MAIN_EXT_CH_NOT_OK,
414 .flags = IORESOURCE_IRQ,
415 },
416 {
417 .name = "BATT_OVV",
418 .start = AB8500_INT_BATT_OVV,
419 .end = AB8500_INT_BATT_OVV,
420 .flags = IORESOURCE_IRQ,
421 },
422 {
423 .name = "MAIN_CH_UNPLUG_DET",
424 .start = AB8500_INT_MAIN_CH_UNPLUG_DET,
425 .end = AB8500_INT_MAIN_CH_UNPLUG_DET,
426 .flags = IORESOURCE_IRQ,
427 },
428 {
429 .name = "MAIN_CHARGE_PLUG_DET",
430 .start = AB8500_INT_MAIN_CH_PLUG_DET,
431 .end = AB8500_INT_MAIN_CH_PLUG_DET,
432 .flags = IORESOURCE_IRQ,
433 },
434 {
435 .name = "VBUS_DET_F",
436 .start = AB8500_INT_VBUS_DET_F,
437 .end = AB8500_INT_VBUS_DET_F,
438 .flags = IORESOURCE_IRQ,
439 },
440 {
441 .name = "VBUS_DET_R",
442 .start = AB8500_INT_VBUS_DET_R,
443 .end = AB8500_INT_VBUS_DET_R,
444 .flags = IORESOURCE_IRQ,
445 },
446 {
447 .name = "BAT_CTRL_INDB",
448 .start = AB8500_INT_BAT_CTRL_INDB,
449 .end = AB8500_INT_BAT_CTRL_INDB,
450 .flags = IORESOURCE_IRQ,
451 },
452 {
453 .name = "CH_WD_EXP",
454 .start = AB8500_INT_CH_WD_EXP,
455 .end = AB8500_INT_CH_WD_EXP,
456 .flags = IORESOURCE_IRQ,
457 },
458 {
459 .name = "VBUS_OVV",
460 .start = AB8500_INT_VBUS_OVV,
461 .end = AB8500_INT_VBUS_OVV,
462 .flags = IORESOURCE_IRQ,
463 },
464 {
465 .name = "NCONV_ACCU",
466 .start = AB8500_INT_CCN_CONV_ACC,
467 .end = AB8500_INT_CCN_CONV_ACC,
468 .flags = IORESOURCE_IRQ,
469 },
470 {
471 .name = "LOW_BAT_F",
472 .start = AB8500_INT_LOW_BAT_F,
473 .end = AB8500_INT_LOW_BAT_F,
474 .flags = IORESOURCE_IRQ,
475 },
476 {
477 .name = "LOW_BAT_R",
478 .start = AB8500_INT_LOW_BAT_R,
479 .end = AB8500_INT_LOW_BAT_R,
480 .flags = IORESOURCE_IRQ,
481 },
482 {
483 .name = "BTEMP_LOW",
484 .start = AB8500_INT_BTEMP_LOW,
485 .end = AB8500_INT_BTEMP_LOW,
486 .flags = IORESOURCE_IRQ,
487 },
488 {
489 .name = "BTEMP_HIGH",
490 .start = AB8500_INT_BTEMP_HIGH,
491 .end = AB8500_INT_BTEMP_HIGH,
492 .flags = IORESOURCE_IRQ,
493 },
494 {
495 .name = "USB_CHARGER_NOT_OKR",
496 .start = AB8500_INT_USB_CHARGER_NOT_OK,
497 .end = AB8500_INT_USB_CHARGER_NOT_OK,
498 .flags = IORESOURCE_IRQ,
499 },
500 {
501 .name = "USB_CHARGE_DET_DONE",
502 .start = AB8500_INT_USB_CHG_DET_DONE,
503 .end = AB8500_INT_USB_CHG_DET_DONE,
504 .flags = IORESOURCE_IRQ,
505 },
506 {
507 .name = "USB_CH_TH_PROT_R",
508 .start = AB8500_INT_USB_CH_TH_PROT_R,
509 .end = AB8500_INT_USB_CH_TH_PROT_R,
510 .flags = IORESOURCE_IRQ,
511 },
512 {
513 .name = "MAIN_CH_TH_PROT_R",
514 .start = AB8500_INT_MAIN_CH_TH_PROT_R,
515 .end = AB8500_INT_MAIN_CH_TH_PROT_R,
516 .flags = IORESOURCE_IRQ,
517 },
518 {
519 .name = "USB_CHARGER_NOT_OKF",
520 .start = AB8500_INT_USB_CHARGER_NOT_OKF,
521 .end = AB8500_INT_USB_CHARGER_NOT_OKF,
522 .flags = IORESOURCE_IRQ,
523 },
524};
525
526static struct resource ab8500_debug_resources[] = {
527 {
528 .name = "IRQ_FIRST",
529 .start = AB8500_INT_MAIN_EXT_CH_NOT_OK,
530 .end = AB8500_INT_MAIN_EXT_CH_NOT_OK,
531 .flags = IORESOURCE_IRQ,
532 },
533 {
534 .name = "IRQ_LAST",
535 .start = AB8500_INT_USB_CHARGER_NOT_OKF,
536 .end = AB8500_INT_USB_CHARGER_NOT_OKF,
537 .flags = IORESOURCE_IRQ,
538 },
539};
540
541static struct resource ab8500_usb_resources[] = {
542 {
543 .name = "ID_WAKEUP_R",
544 .start = AB8500_INT_ID_WAKEUP_R,
545 .end = AB8500_INT_ID_WAKEUP_R,
546 .flags = IORESOURCE_IRQ,
547 },
548 {
549 .name = "ID_WAKEUP_F",
550 .start = AB8500_INT_ID_WAKEUP_F,
551 .end = AB8500_INT_ID_WAKEUP_F,
552 .flags = IORESOURCE_IRQ,
553 },
554 {
555 .name = "VBUS_DET_F",
556 .start = AB8500_INT_VBUS_DET_F,
557 .end = AB8500_INT_VBUS_DET_F,
558 .flags = IORESOURCE_IRQ,
559 },
560 {
561 .name = "VBUS_DET_R",
562 .start = AB8500_INT_VBUS_DET_R,
563 .end = AB8500_INT_VBUS_DET_R,
564 .flags = IORESOURCE_IRQ,
565 },
566 {
567 .name = "USB_LINK_STATUS",
568 .start = AB8500_INT_USB_LINK_STATUS,
569 .end = AB8500_INT_USB_LINK_STATUS,
570 .flags = IORESOURCE_IRQ,
571 },
572};
573
574static struct resource ab8500_temp_resources[] = {
575 {
576 .name = "AB8500_TEMP_WARM",
577 .start = AB8500_INT_TEMP_WARM,
578 .end = AB8500_INT_TEMP_WARM,
579 .flags = IORESOURCE_IRQ,
580 },
581};
582
396static struct mfd_cell ab8500_devs[] = { 583static struct mfd_cell ab8500_devs[] = {
397#ifdef CONFIG_DEBUG_FS 584#ifdef CONFIG_DEBUG_FS
398 { 585 {
399 .name = "ab8500-debug", 586 .name = "ab8500-debug",
587 .num_resources = ARRAY_SIZE(ab8500_debug_resources),
588 .resources = ab8500_debug_resources,
400 }, 589 },
401#endif 590#endif
402 { 591 {
592 .name = "ab8500-sysctrl",
593 },
594 {
595 .name = "ab8500-regulator",
596 },
597 {
403 .name = "ab8500-gpadc", 598 .name = "ab8500-gpadc",
404 .num_resources = ARRAY_SIZE(ab8500_gpadc_resources), 599 .num_resources = ARRAY_SIZE(ab8500_gpadc_resources),
405 .resources = ab8500_gpadc_resources, 600 .resources = ab8500_gpadc_resources,
@@ -410,6 +605,22 @@ static struct mfd_cell ab8500_devs[] = {
410 .resources = ab8500_rtc_resources, 605 .resources = ab8500_rtc_resources,
411 }, 606 },
412 { 607 {
608 .name = "ab8500-bm",
609 .num_resources = ARRAY_SIZE(ab8500_bm_resources),
610 .resources = ab8500_bm_resources,
611 },
612 { .name = "ab8500-codec", },
613 {
614 .name = "ab8500-usb",
615 .num_resources = ARRAY_SIZE(ab8500_usb_resources),
616 .resources = ab8500_usb_resources,
617 },
618 {
619 .name = "ab8500-poweron-key",
620 .num_resources = ARRAY_SIZE(ab8500_poweronkey_db_resources),
621 .resources = ab8500_poweronkey_db_resources,
622 },
623 {
413 .name = "ab8500-pwm", 624 .name = "ab8500-pwm",
414 .id = 1, 625 .id = 1,
415 }, 626 },
@@ -421,17 +632,37 @@ static struct mfd_cell ab8500_devs[] = {
421 .name = "ab8500-pwm", 632 .name = "ab8500-pwm",
422 .id = 3, 633 .id = 3,
423 }, 634 },
424 { .name = "ab8500-charger", }, 635 { .name = "ab8500-leds", },
425 { .name = "ab8500-audio", },
426 { .name = "ab8500-usb", },
427 { .name = "ab8500-regulator", },
428 { 636 {
429 .name = "ab8500-poweron-key", 637 .name = "ab8500-denc",
430 .num_resources = ARRAY_SIZE(ab8500_poweronkey_db_resources), 638 },
431 .resources = ab8500_poweronkey_db_resources, 639 {
640 .name = "ab8500-temp",
641 .num_resources = ARRAY_SIZE(ab8500_temp_resources),
642 .resources = ab8500_temp_resources,
432 }, 643 },
433}; 644};
434 645
646static ssize_t show_chip_id(struct device *dev,
647 struct device_attribute *attr, char *buf)
648{
649 struct ab8500 *ab8500;
650
651 ab8500 = dev_get_drvdata(dev);
652 return sprintf(buf, "%#x\n", ab8500 ? ab8500->chip_id : -EINVAL);
653}
654
655static DEVICE_ATTR(chip_id, S_IRUGO, show_chip_id, NULL);
656
657static struct attribute *ab8500_sysfs_entries[] = {
658 &dev_attr_chip_id.attr,
659 NULL,
660};
661
662static struct attribute_group ab8500_attr_group = {
663 .attrs = ab8500_sysfs_entries,
664};
665
435int __devinit ab8500_init(struct ab8500 *ab8500) 666int __devinit ab8500_init(struct ab8500 *ab8500)
436{ 667{
437 struct ab8500_platform_data *plat = dev_get_platdata(ab8500->dev); 668 struct ab8500_platform_data *plat = dev_get_platdata(ab8500->dev);
@@ -454,8 +685,9 @@ int __devinit ab8500_init(struct ab8500 *ab8500)
454 * 0x0 - Early Drop 685 * 0x0 - Early Drop
455 * 0x10 - Cut 1.0 686 * 0x10 - Cut 1.0
456 * 0x11 - Cut 1.1 687 * 0x11 - Cut 1.1
688 * 0x20 - Cut 2.0
457 */ 689 */
458 if (value == 0x0 || value == 0x10 || value == 0x11) { 690 if (value == 0x0 || value == 0x10 || value == 0x11 || value == 0x20) {
459 ab8500->revision = value; 691 ab8500->revision = value;
460 dev_info(ab8500->dev, "detected chip, revision: %#x\n", value); 692 dev_info(ab8500->dev, "detected chip, revision: %#x\n", value);
461 } else { 693 } else {
@@ -468,18 +700,16 @@ int __devinit ab8500_init(struct ab8500 *ab8500)
468 plat->init(ab8500); 700 plat->init(ab8500);
469 701
470 /* Clear and mask all interrupts */ 702 /* Clear and mask all interrupts */
471 for (i = 0; i < 10; i++) { 703 for (i = 0; i < AB8500_NUM_IRQ_REGS; i++) {
472 get_register_interruptible(ab8500, AB8500_INTERRUPT, 704 /* Interrupt register 12 does'nt exist prior to version 0x20 */
473 AB8500_IT_LATCH1_REG + i, &value); 705 if (ab8500_irq_regoffset[i] == 11 && ab8500->chip_id < 0x20)
474 set_register_interruptible(ab8500, AB8500_INTERRUPT, 706 continue;
475 AB8500_IT_MASK1_REG + i, 0xff);
476 }
477 707
478 for (i = 18; i < 24; i++) {
479 get_register_interruptible(ab8500, AB8500_INTERRUPT, 708 get_register_interruptible(ab8500, AB8500_INTERRUPT,
480 AB8500_IT_LATCH1_REG + i, &value); 709 AB8500_IT_LATCH1_REG + ab8500_irq_regoffset[i],
710 &value);
481 set_register_interruptible(ab8500, AB8500_INTERRUPT, 711 set_register_interruptible(ab8500, AB8500_INTERRUPT,
482 AB8500_IT_MASK1_REG + i, 0xff); 712 AB8500_IT_MASK1_REG + ab8500_irq_regoffset[i], 0xff);
483 } 713 }
484 714
485 ret = abx500_register_ops(ab8500->dev, &ab8500_ops); 715 ret = abx500_register_ops(ab8500->dev, &ab8500_ops);
@@ -495,7 +725,8 @@ int __devinit ab8500_init(struct ab8500 *ab8500)
495 return ret; 725 return ret;
496 726
497 ret = request_threaded_irq(ab8500->irq, NULL, ab8500_irq, 727 ret = request_threaded_irq(ab8500->irq, NULL, ab8500_irq,
498 IRQF_ONESHOT, "ab8500", ab8500); 728 IRQF_ONESHOT | IRQF_NO_SUSPEND,
729 "ab8500", ab8500);
499 if (ret) 730 if (ret)
500 goto out_removeirq; 731 goto out_removeirq;
501 } 732 }
@@ -506,6 +737,10 @@ int __devinit ab8500_init(struct ab8500 *ab8500)
506 if (ret) 737 if (ret)
507 goto out_freeirq; 738 goto out_freeirq;
508 739
740 ret = sysfs_create_group(&ab8500->dev->kobj, &ab8500_attr_group);
741 if (ret)
742 dev_err(ab8500->dev, "error creating sysfs entries\n");
743
509 return ret; 744 return ret;
510 745
511out_freeirq: 746out_freeirq:
@@ -519,6 +754,7 @@ out_removeirq:
519 754
520int __devexit ab8500_exit(struct ab8500 *ab8500) 755int __devexit ab8500_exit(struct ab8500 *ab8500)
521{ 756{
757 sysfs_remove_group(&ab8500->dev->kobj, &ab8500_attr_group);
522 mfd_remove_devices(ab8500->dev); 758 mfd_remove_devices(ab8500->dev);
523 if (ab8500->irq_base) { 759 if (ab8500->irq_base) {
524 free_irq(ab8500->irq, ab8500); 760 free_irq(ab8500->irq, ab8500);
diff --git a/drivers/mfd/ab8500-debugfs.c b/drivers/mfd/ab8500-debugfs.c
index 8d1e05a39815..3c1541ae7223 100644
--- a/drivers/mfd/ab8500-debugfs.c
+++ b/drivers/mfd/ab8500-debugfs.c
@@ -24,9 +24,9 @@ static u32 debug_address;
24 * @perm: access permissions for the range 24 * @perm: access permissions for the range
25 */ 25 */
26struct ab8500_reg_range { 26struct ab8500_reg_range {
27 u8 first; 27 u8 first;
28 u8 last; 28 u8 last;
29 u8 perm; 29 u8 perm;
30}; 30};
31 31
32/** 32/**
@@ -36,9 +36,9 @@ struct ab8500_reg_range {
36 * @range: the list of register ranges 36 * @range: the list of register ranges
37 */ 37 */
38struct ab8500_i2c_ranges { 38struct ab8500_i2c_ranges {
39 u8 num_ranges; 39 u8 num_ranges;
40 u8 bankid; 40 u8 bankid;
41 const struct ab8500_reg_range *range; 41 const struct ab8500_reg_range *range;
42}; 42};
43 43
44#define AB8500_NAME_STRING "ab8500" 44#define AB8500_NAME_STRING "ab8500"
@@ -47,521 +47,521 @@ struct ab8500_i2c_ranges {
47#define AB8500_REV_REG 0x80 47#define AB8500_REV_REG 0x80
48 48
49static struct ab8500_i2c_ranges debug_ranges[AB8500_NUM_BANKS] = { 49static struct ab8500_i2c_ranges debug_ranges[AB8500_NUM_BANKS] = {
50 [0x0] = { 50 [0x0] = {
51 .num_ranges = 0, 51 .num_ranges = 0,
52 .range = 0, 52 .range = 0,
53 }, 53 },
54 [AB8500_SYS_CTRL1_BLOCK] = { 54 [AB8500_SYS_CTRL1_BLOCK] = {
55 .num_ranges = 3, 55 .num_ranges = 3,
56 .range = (struct ab8500_reg_range[]) { 56 .range = (struct ab8500_reg_range[]) {
57 { 57 {
58 .first = 0x00, 58 .first = 0x00,
59 .last = 0x02, 59 .last = 0x02,
60 }, 60 },
61 { 61 {
62 .first = 0x42, 62 .first = 0x42,
63 .last = 0x42, 63 .last = 0x42,
64 }, 64 },
65 { 65 {
66 .first = 0x80, 66 .first = 0x80,
67 .last = 0x81, 67 .last = 0x81,
68 }, 68 },
69 }, 69 },
70 }, 70 },
71 [AB8500_SYS_CTRL2_BLOCK] = { 71 [AB8500_SYS_CTRL2_BLOCK] = {
72 .num_ranges = 4, 72 .num_ranges = 4,
73 .range = (struct ab8500_reg_range[]) { 73 .range = (struct ab8500_reg_range[]) {
74 { 74 {
75 .first = 0x00, 75 .first = 0x00,
76 .last = 0x0D, 76 .last = 0x0D,
77 }, 77 },
78 { 78 {
79 .first = 0x0F, 79 .first = 0x0F,
80 .last = 0x17, 80 .last = 0x17,
81 }, 81 },
82 { 82 {
83 .first = 0x30, 83 .first = 0x30,
84 .last = 0x30, 84 .last = 0x30,
85 }, 85 },
86 { 86 {
87 .first = 0x32, 87 .first = 0x32,
88 .last = 0x33, 88 .last = 0x33,
89 }, 89 },
90 }, 90 },
91 }, 91 },
92 [AB8500_REGU_CTRL1] = { 92 [AB8500_REGU_CTRL1] = {
93 .num_ranges = 3, 93 .num_ranges = 3,
94 .range = (struct ab8500_reg_range[]) { 94 .range = (struct ab8500_reg_range[]) {
95 { 95 {
96 .first = 0x00, 96 .first = 0x00,
97 .last = 0x00, 97 .last = 0x00,
98 }, 98 },
99 { 99 {
100 .first = 0x03, 100 .first = 0x03,
101 .last = 0x10, 101 .last = 0x10,
102 }, 102 },
103 { 103 {
104 .first = 0x80, 104 .first = 0x80,
105 .last = 0x84, 105 .last = 0x84,
106 }, 106 },
107 }, 107 },
108 }, 108 },
109 [AB8500_REGU_CTRL2] = { 109 [AB8500_REGU_CTRL2] = {
110 .num_ranges = 5, 110 .num_ranges = 5,
111 .range = (struct ab8500_reg_range[]) { 111 .range = (struct ab8500_reg_range[]) {
112 { 112 {
113 .first = 0x00, 113 .first = 0x00,
114 .last = 0x15, 114 .last = 0x15,
115 }, 115 },
116 { 116 {
117 .first = 0x17, 117 .first = 0x17,
118 .last = 0x19, 118 .last = 0x19,
119 }, 119 },
120 { 120 {
121 .first = 0x1B, 121 .first = 0x1B,
122 .last = 0x1D, 122 .last = 0x1D,
123 }, 123 },
124 { 124 {
125 .first = 0x1F, 125 .first = 0x1F,
126 .last = 0x22, 126 .last = 0x22,
127 }, 127 },
128 { 128 {
129 .first = 0x40, 129 .first = 0x40,
130 .last = 0x44, 130 .last = 0x44,
131 }, 131 },
132 /* 0x80-0x8B is SIM registers and should 132 /* 0x80-0x8B is SIM registers and should
133 * not be accessed from here */ 133 * not be accessed from here */
134 }, 134 },
135 }, 135 },
136 [AB8500_USB] = { 136 [AB8500_USB] = {
137 .num_ranges = 2, 137 .num_ranges = 2,
138 .range = (struct ab8500_reg_range[]) { 138 .range = (struct ab8500_reg_range[]) {
139 { 139 {
140 .first = 0x80, 140 .first = 0x80,
141 .last = 0x83, 141 .last = 0x83,
142 }, 142 },
143 { 143 {
144 .first = 0x87, 144 .first = 0x87,
145 .last = 0x8A, 145 .last = 0x8A,
146 }, 146 },
147 }, 147 },
148 }, 148 },
149 [AB8500_TVOUT] = { 149 [AB8500_TVOUT] = {
150 .num_ranges = 9, 150 .num_ranges = 9,
151 .range = (struct ab8500_reg_range[]) { 151 .range = (struct ab8500_reg_range[]) {
152 { 152 {
153 .first = 0x00, 153 .first = 0x00,
154 .last = 0x12, 154 .last = 0x12,
155 }, 155 },
156 { 156 {
157 .first = 0x15, 157 .first = 0x15,
158 .last = 0x17, 158 .last = 0x17,
159 }, 159 },
160 { 160 {
161 .first = 0x19, 161 .first = 0x19,
162 .last = 0x21, 162 .last = 0x21,
163 }, 163 },
164 { 164 {
165 .first = 0x27, 165 .first = 0x27,
166 .last = 0x2C, 166 .last = 0x2C,
167 }, 167 },
168 { 168 {
169 .first = 0x41, 169 .first = 0x41,
170 .last = 0x41, 170 .last = 0x41,
171 }, 171 },
172 { 172 {
173 .first = 0x45, 173 .first = 0x45,
174 .last = 0x5B, 174 .last = 0x5B,
175 }, 175 },
176 { 176 {
177 .first = 0x5D, 177 .first = 0x5D,
178 .last = 0x5D, 178 .last = 0x5D,
179 }, 179 },
180 { 180 {
181 .first = 0x69, 181 .first = 0x69,
182 .last = 0x69, 182 .last = 0x69,
183 }, 183 },
184 { 184 {
185 .first = 0x80, 185 .first = 0x80,
186 .last = 0x81, 186 .last = 0x81,
187 }, 187 },
188 }, 188 },
189 }, 189 },
190 [AB8500_DBI] = { 190 [AB8500_DBI] = {
191 .num_ranges = 0, 191 .num_ranges = 0,
192 .range = 0, 192 .range = NULL,
193 }, 193 },
194 [AB8500_ECI_AV_ACC] = { 194 [AB8500_ECI_AV_ACC] = {
195 .num_ranges = 1, 195 .num_ranges = 1,
196 .range = (struct ab8500_reg_range[]) { 196 .range = (struct ab8500_reg_range[]) {
197 { 197 {
198 .first = 0x80, 198 .first = 0x80,
199 .last = 0x82, 199 .last = 0x82,
200 }, 200 },
201 }, 201 },
202 }, 202 },
203 [0x9] = { 203 [0x9] = {
204 .num_ranges = 0, 204 .num_ranges = 0,
205 .range = 0, 205 .range = NULL,
206 }, 206 },
207 [AB8500_GPADC] = { 207 [AB8500_GPADC] = {
208 .num_ranges = 1, 208 .num_ranges = 1,
209 .range = (struct ab8500_reg_range[]) { 209 .range = (struct ab8500_reg_range[]) {
210 { 210 {
211 .first = 0x00, 211 .first = 0x00,
212 .last = 0x08, 212 .last = 0x08,
213 }, 213 },
214 }, 214 },
215 }, 215 },
216 [AB8500_CHARGER] = { 216 [AB8500_CHARGER] = {
217 .num_ranges = 8, 217 .num_ranges = 8,
218 .range = (struct ab8500_reg_range[]) { 218 .range = (struct ab8500_reg_range[]) {
219 { 219 {
220 .first = 0x00, 220 .first = 0x00,
221 .last = 0x03, 221 .last = 0x03,
222 }, 222 },
223 { 223 {
224 .first = 0x05, 224 .first = 0x05,
225 .last = 0x05, 225 .last = 0x05,
226 }, 226 },
227 { 227 {
228 .first = 0x40, 228 .first = 0x40,
229 .last = 0x40, 229 .last = 0x40,
230 }, 230 },
231 { 231 {
232 .first = 0x42, 232 .first = 0x42,
233 .last = 0x42, 233 .last = 0x42,
234 }, 234 },
235 { 235 {
236 .first = 0x44, 236 .first = 0x44,
237 .last = 0x44, 237 .last = 0x44,
238 }, 238 },
239 { 239 {
240 .first = 0x50, 240 .first = 0x50,
241 .last = 0x55, 241 .last = 0x55,
242 }, 242 },
243 { 243 {
244 .first = 0x80, 244 .first = 0x80,
245 .last = 0x82, 245 .last = 0x82,
246 }, 246 },
247 { 247 {
248 .first = 0xC0, 248 .first = 0xC0,
249 .last = 0xC2, 249 .last = 0xC2,
250 }, 250 },
251 }, 251 },
252 }, 252 },
253 [AB8500_GAS_GAUGE] = { 253 [AB8500_GAS_GAUGE] = {
254 .num_ranges = 3, 254 .num_ranges = 3,
255 .range = (struct ab8500_reg_range[]) { 255 .range = (struct ab8500_reg_range[]) {
256 { 256 {
257 .first = 0x00, 257 .first = 0x00,
258 .last = 0x00, 258 .last = 0x00,
259 }, 259 },
260 { 260 {
261 .first = 0x07, 261 .first = 0x07,
262 .last = 0x0A, 262 .last = 0x0A,
263 }, 263 },
264 { 264 {
265 .first = 0x10, 265 .first = 0x10,
266 .last = 0x14, 266 .last = 0x14,
267 }, 267 },
268 }, 268 },
269 }, 269 },
270 [AB8500_AUDIO] = { 270 [AB8500_AUDIO] = {
271 .num_ranges = 1, 271 .num_ranges = 1,
272 .range = (struct ab8500_reg_range[]) { 272 .range = (struct ab8500_reg_range[]) {
273 { 273 {
274 .first = 0x00, 274 .first = 0x00,
275 .last = 0x6F, 275 .last = 0x6F,
276 }, 276 },
277 }, 277 },
278 }, 278 },
279 [AB8500_INTERRUPT] = { 279 [AB8500_INTERRUPT] = {
280 .num_ranges = 0, 280 .num_ranges = 0,
281 .range = 0, 281 .range = NULL,
282 }, 282 },
283 [AB8500_RTC] = { 283 [AB8500_RTC] = {
284 .num_ranges = 1, 284 .num_ranges = 1,
285 .range = (struct ab8500_reg_range[]) { 285 .range = (struct ab8500_reg_range[]) {
286 { 286 {
287 .first = 0x00, 287 .first = 0x00,
288 .last = 0x0F, 288 .last = 0x0F,
289 }, 289 },
290 }, 290 },
291 }, 291 },
292 [AB8500_MISC] = { 292 [AB8500_MISC] = {
293 .num_ranges = 8, 293 .num_ranges = 8,
294 .range = (struct ab8500_reg_range[]) { 294 .range = (struct ab8500_reg_range[]) {
295 { 295 {
296 .first = 0x00, 296 .first = 0x00,
297 .last = 0x05, 297 .last = 0x05,
298 }, 298 },
299 { 299 {
300 .first = 0x10, 300 .first = 0x10,
301 .last = 0x15, 301 .last = 0x15,
302 }, 302 },
303 { 303 {
304 .first = 0x20, 304 .first = 0x20,
305 .last = 0x25, 305 .last = 0x25,
306 }, 306 },
307 { 307 {
308 .first = 0x30, 308 .first = 0x30,
309 .last = 0x35, 309 .last = 0x35,
310 }, 310 },
311 { 311 {
312 .first = 0x40, 312 .first = 0x40,
313 .last = 0x45, 313 .last = 0x45,
314 }, 314 },
315 { 315 {
316 .first = 0x50, 316 .first = 0x50,
317 .last = 0x50, 317 .last = 0x50,
318 }, 318 },
319 { 319 {
320 .first = 0x60, 320 .first = 0x60,
321 .last = 0x67, 321 .last = 0x67,
322 }, 322 },
323 { 323 {
324 .first = 0x80, 324 .first = 0x80,
325 .last = 0x80, 325 .last = 0x80,
326 }, 326 },
327 }, 327 },
328 }, 328 },
329 [0x11] = { 329 [0x11] = {
330 .num_ranges = 0, 330 .num_ranges = 0,
331 .range = 0, 331 .range = NULL,
332 }, 332 },
333 [0x12] = { 333 [0x12] = {
334 .num_ranges = 0, 334 .num_ranges = 0,
335 .range = 0, 335 .range = NULL,
336 }, 336 },
337 [0x13] = { 337 [0x13] = {
338 .num_ranges = 0, 338 .num_ranges = 0,
339 .range = 0, 339 .range = NULL,
340 }, 340 },
341 [0x14] = { 341 [0x14] = {
342 .num_ranges = 0, 342 .num_ranges = 0,
343 .range = 0, 343 .range = NULL,
344 }, 344 },
345 [AB8500_OTP_EMUL] = { 345 [AB8500_OTP_EMUL] = {
346 .num_ranges = 1, 346 .num_ranges = 1,
347 .range = (struct ab8500_reg_range[]) { 347 .range = (struct ab8500_reg_range[]) {
348 { 348 {
349 .first = 0x01, 349 .first = 0x01,
350 .last = 0x0F, 350 .last = 0x0F,
351 }, 351 },
352 }, 352 },
353 }, 353 },
354}; 354};
355 355
356static int ab8500_registers_print(struct seq_file *s, void *p) 356static int ab8500_registers_print(struct seq_file *s, void *p)
357{ 357{
358 struct device *dev = s->private; 358 struct device *dev = s->private;
359 unsigned int i; 359 unsigned int i;
360 u32 bank = debug_bank; 360 u32 bank = debug_bank;
361 361
362 seq_printf(s, AB8500_NAME_STRING " register values:\n"); 362 seq_printf(s, AB8500_NAME_STRING " register values:\n");
363 363
364 seq_printf(s, " bank %u:\n", bank); 364 seq_printf(s, " bank %u:\n", bank);
365 for (i = 0; i < debug_ranges[bank].num_ranges; i++) { 365 for (i = 0; i < debug_ranges[bank].num_ranges; i++) {
366 u32 reg; 366 u32 reg;
367 367
368 for (reg = debug_ranges[bank].range[i].first; 368 for (reg = debug_ranges[bank].range[i].first;
369 reg <= debug_ranges[bank].range[i].last; 369 reg <= debug_ranges[bank].range[i].last;
370 reg++) { 370 reg++) {
371 u8 value; 371 u8 value;
372 int err; 372 int err;
373 373
374 err = abx500_get_register_interruptible(dev, 374 err = abx500_get_register_interruptible(dev,
375 (u8)bank, (u8)reg, &value); 375 (u8)bank, (u8)reg, &value);
376 if (err < 0) { 376 if (err < 0) {
377 dev_err(dev, "ab->read fail %d\n", err); 377 dev_err(dev, "ab->read fail %d\n", err);
378 return err; 378 return err;
379 } 379 }
380 380
381 err = seq_printf(s, " [%u/0x%02X]: 0x%02X\n", bank, 381 err = seq_printf(s, " [%u/0x%02X]: 0x%02X\n", bank,
382 reg, value); 382 reg, value);
383 if (err < 0) { 383 if (err < 0) {
384 dev_err(dev, "seq_printf overflow\n"); 384 dev_err(dev, "seq_printf overflow\n");
385 /* Error is not returned here since 385 /* Error is not returned here since
386 * the output is wanted in any case */ 386 * the output is wanted in any case */
387 return 0; 387 return 0;
388 } 388 }
389 } 389 }
390 } 390 }
391 return 0; 391 return 0;
392} 392}
393 393
394static int ab8500_registers_open(struct inode *inode, struct file *file) 394static int ab8500_registers_open(struct inode *inode, struct file *file)
395{ 395{
396 return single_open(file, ab8500_registers_print, inode->i_private); 396 return single_open(file, ab8500_registers_print, inode->i_private);
397} 397}
398 398
399static const struct file_operations ab8500_registers_fops = { 399static const struct file_operations ab8500_registers_fops = {
400 .open = ab8500_registers_open, 400 .open = ab8500_registers_open,
401 .read = seq_read, 401 .read = seq_read,
402 .llseek = seq_lseek, 402 .llseek = seq_lseek,
403 .release = single_release, 403 .release = single_release,
404 .owner = THIS_MODULE, 404 .owner = THIS_MODULE,
405}; 405};
406 406
407static int ab8500_bank_print(struct seq_file *s, void *p) 407static int ab8500_bank_print(struct seq_file *s, void *p)
408{ 408{
409 return seq_printf(s, "%d\n", debug_bank); 409 return seq_printf(s, "%d\n", debug_bank);
410} 410}
411 411
412static int ab8500_bank_open(struct inode *inode, struct file *file) 412static int ab8500_bank_open(struct inode *inode, struct file *file)
413{ 413{
414 return single_open(file, ab8500_bank_print, inode->i_private); 414 return single_open(file, ab8500_bank_print, inode->i_private);
415} 415}
416 416
417static ssize_t ab8500_bank_write(struct file *file, 417static ssize_t ab8500_bank_write(struct file *file,
418 const char __user *user_buf, 418 const char __user *user_buf,
419 size_t count, loff_t *ppos) 419 size_t count, loff_t *ppos)
420{ 420{
421 struct device *dev = ((struct seq_file *)(file->private_data))->private; 421 struct device *dev = ((struct seq_file *)(file->private_data))->private;
422 char buf[32]; 422 char buf[32];
423 int buf_size; 423 int buf_size;
424 unsigned long user_bank; 424 unsigned long user_bank;
425 int err; 425 int err;
426 426
427 /* Get userspace string and assure termination */ 427 /* Get userspace string and assure termination */
428 buf_size = min(count, (sizeof(buf) - 1)); 428 buf_size = min(count, (sizeof(buf) - 1));
429 if (copy_from_user(buf, user_buf, buf_size)) 429 if (copy_from_user(buf, user_buf, buf_size))
430 return -EFAULT; 430 return -EFAULT;
431 buf[buf_size] = 0; 431 buf[buf_size] = 0;
432 432
433 err = strict_strtoul(buf, 0, &user_bank); 433 err = strict_strtoul(buf, 0, &user_bank);
434 if (err) 434 if (err)
435 return -EINVAL; 435 return -EINVAL;
436 436
437 if (user_bank >= AB8500_NUM_BANKS) { 437 if (user_bank >= AB8500_NUM_BANKS) {
438 dev_err(dev, "debugfs error input > number of banks\n"); 438 dev_err(dev, "debugfs error input > number of banks\n");
439 return -EINVAL; 439 return -EINVAL;
440 } 440 }
441 441
442 debug_bank = user_bank; 442 debug_bank = user_bank;
443 443
444 return buf_size; 444 return buf_size;
445} 445}
446 446
447static int ab8500_address_print(struct seq_file *s, void *p) 447static int ab8500_address_print(struct seq_file *s, void *p)
448{ 448{
449 return seq_printf(s, "0x%02X\n", debug_address); 449 return seq_printf(s, "0x%02X\n", debug_address);
450} 450}
451 451
452static int ab8500_address_open(struct inode *inode, struct file *file) 452static int ab8500_address_open(struct inode *inode, struct file *file)
453{ 453{
454 return single_open(file, ab8500_address_print, inode->i_private); 454 return single_open(file, ab8500_address_print, inode->i_private);
455} 455}
456 456
457static ssize_t ab8500_address_write(struct file *file, 457static ssize_t ab8500_address_write(struct file *file,
458 const char __user *user_buf, 458 const char __user *user_buf,
459 size_t count, loff_t *ppos) 459 size_t count, loff_t *ppos)
460{ 460{
461 struct device *dev = ((struct seq_file *)(file->private_data))->private; 461 struct device *dev = ((struct seq_file *)(file->private_data))->private;
462 char buf[32]; 462 char buf[32];
463 int buf_size; 463 int buf_size;
464 unsigned long user_address; 464 unsigned long user_address;
465 int err; 465 int err;
466 466
467 /* Get userspace string and assure termination */ 467 /* Get userspace string and assure termination */
468 buf_size = min(count, (sizeof(buf) - 1)); 468 buf_size = min(count, (sizeof(buf) - 1));
469 if (copy_from_user(buf, user_buf, buf_size)) 469 if (copy_from_user(buf, user_buf, buf_size))
470 return -EFAULT; 470 return -EFAULT;
471 buf[buf_size] = 0; 471 buf[buf_size] = 0;
472 472
473 err = strict_strtoul(buf, 0, &user_address); 473 err = strict_strtoul(buf, 0, &user_address);
474 if (err) 474 if (err)
475 return -EINVAL; 475 return -EINVAL;
476 if (user_address > 0xff) { 476 if (user_address > 0xff) {
477 dev_err(dev, "debugfs error input > 0xff\n"); 477 dev_err(dev, "debugfs error input > 0xff\n");
478 return -EINVAL; 478 return -EINVAL;
479 } 479 }
480 debug_address = user_address; 480 debug_address = user_address;
481 return buf_size; 481 return buf_size;
482} 482}
483 483
484static int ab8500_val_print(struct seq_file *s, void *p) 484static int ab8500_val_print(struct seq_file *s, void *p)
485{ 485{
486 struct device *dev = s->private; 486 struct device *dev = s->private;
487 int ret; 487 int ret;
488 u8 regvalue; 488 u8 regvalue;
489 489
490 ret = abx500_get_register_interruptible(dev, 490 ret = abx500_get_register_interruptible(dev,
491 (u8)debug_bank, (u8)debug_address, &regvalue); 491 (u8)debug_bank, (u8)debug_address, &regvalue);
492 if (ret < 0) { 492 if (ret < 0) {
493 dev_err(dev, "abx500_get_reg fail %d, %d\n", 493 dev_err(dev, "abx500_get_reg fail %d, %d\n",
494 ret, __LINE__); 494 ret, __LINE__);
495 return -EINVAL; 495 return -EINVAL;
496 } 496 }
497 seq_printf(s, "0x%02X\n", regvalue); 497 seq_printf(s, "0x%02X\n", regvalue);
498 498
499 return 0; 499 return 0;
500} 500}
501 501
502static int ab8500_val_open(struct inode *inode, struct file *file) 502static int ab8500_val_open(struct inode *inode, struct file *file)
503{ 503{
504 return single_open(file, ab8500_val_print, inode->i_private); 504 return single_open(file, ab8500_val_print, inode->i_private);
505} 505}
506 506
507static ssize_t ab8500_val_write(struct file *file, 507static ssize_t ab8500_val_write(struct file *file,
508 const char __user *user_buf, 508 const char __user *user_buf,
509 size_t count, loff_t *ppos) 509 size_t count, loff_t *ppos)
510{ 510{
511 struct device *dev = ((struct seq_file *)(file->private_data))->private; 511 struct device *dev = ((struct seq_file *)(file->private_data))->private;
512 char buf[32]; 512 char buf[32];
513 int buf_size; 513 int buf_size;
514 unsigned long user_val; 514 unsigned long user_val;
515 int err; 515 int err;
516 516
517 /* Get userspace string and assure termination */ 517 /* Get userspace string and assure termination */
518 buf_size = min(count, (sizeof(buf)-1)); 518 buf_size = min(count, (sizeof(buf)-1));
519 if (copy_from_user(buf, user_buf, buf_size)) 519 if (copy_from_user(buf, user_buf, buf_size))
520 return -EFAULT; 520 return -EFAULT;
521 buf[buf_size] = 0; 521 buf[buf_size] = 0;
522 522
523 err = strict_strtoul(buf, 0, &user_val); 523 err = strict_strtoul(buf, 0, &user_val);
524 if (err) 524 if (err)
525 return -EINVAL; 525 return -EINVAL;
526 if (user_val > 0xff) { 526 if (user_val > 0xff) {
527 dev_err(dev, "debugfs error input > 0xff\n"); 527 dev_err(dev, "debugfs error input > 0xff\n");
528 return -EINVAL; 528 return -EINVAL;
529 } 529 }
530 err = abx500_set_register_interruptible(dev, 530 err = abx500_set_register_interruptible(dev,
531 (u8)debug_bank, debug_address, (u8)user_val); 531 (u8)debug_bank, debug_address, (u8)user_val);
532 if (err < 0) { 532 if (err < 0) {
533 printk(KERN_ERR "abx500_set_reg failed %d, %d", err, __LINE__); 533 printk(KERN_ERR "abx500_set_reg failed %d, %d", err, __LINE__);
534 return -EINVAL; 534 return -EINVAL;
535 } 535 }
536 536
537 return buf_size; 537 return buf_size;
538} 538}
539 539
540static const struct file_operations ab8500_bank_fops = { 540static const struct file_operations ab8500_bank_fops = {
541 .open = ab8500_bank_open, 541 .open = ab8500_bank_open,
542 .write = ab8500_bank_write, 542 .write = ab8500_bank_write,
543 .read = seq_read, 543 .read = seq_read,
544 .llseek = seq_lseek, 544 .llseek = seq_lseek,
545 .release = single_release, 545 .release = single_release,
546 .owner = THIS_MODULE, 546 .owner = THIS_MODULE,
547}; 547};
548 548
549static const struct file_operations ab8500_address_fops = { 549static const struct file_operations ab8500_address_fops = {
550 .open = ab8500_address_open, 550 .open = ab8500_address_open,
551 .write = ab8500_address_write, 551 .write = ab8500_address_write,
552 .read = seq_read, 552 .read = seq_read,
553 .llseek = seq_lseek, 553 .llseek = seq_lseek,
554 .release = single_release, 554 .release = single_release,
555 .owner = THIS_MODULE, 555 .owner = THIS_MODULE,
556}; 556};
557 557
558static const struct file_operations ab8500_val_fops = { 558static const struct file_operations ab8500_val_fops = {
559 .open = ab8500_val_open, 559 .open = ab8500_val_open,
560 .write = ab8500_val_write, 560 .write = ab8500_val_write,
561 .read = seq_read, 561 .read = seq_read,
562 .llseek = seq_lseek, 562 .llseek = seq_lseek,
563 .release = single_release, 563 .release = single_release,
564 .owner = THIS_MODULE, 564 .owner = THIS_MODULE,
565}; 565};
566 566
567static struct dentry *ab8500_dir; 567static struct dentry *ab8500_dir;
@@ -572,77 +572,77 @@ static struct dentry *ab8500_val_file;
572 572
573static int __devinit ab8500_debug_probe(struct platform_device *plf) 573static int __devinit ab8500_debug_probe(struct platform_device *plf)
574{ 574{
575 debug_bank = AB8500_MISC; 575 debug_bank = AB8500_MISC;
576 debug_address = AB8500_REV_REG & 0x00FF; 576 debug_address = AB8500_REV_REG & 0x00FF;
577 577
578 ab8500_dir = debugfs_create_dir(AB8500_NAME_STRING, NULL); 578 ab8500_dir = debugfs_create_dir(AB8500_NAME_STRING, NULL);
579 if (!ab8500_dir) 579 if (!ab8500_dir)
580 goto exit_no_debugfs; 580 goto exit_no_debugfs;
581 581
582 ab8500_reg_file = debugfs_create_file("all-bank-registers", 582 ab8500_reg_file = debugfs_create_file("all-bank-registers",
583 S_IRUGO, ab8500_dir, &plf->dev, &ab8500_registers_fops); 583 S_IRUGO, ab8500_dir, &plf->dev, &ab8500_registers_fops);
584 if (!ab8500_reg_file) 584 if (!ab8500_reg_file)
585 goto exit_destroy_dir; 585 goto exit_destroy_dir;
586 586
587 ab8500_bank_file = debugfs_create_file("register-bank", 587 ab8500_bank_file = debugfs_create_file("register-bank",
588 (S_IRUGO | S_IWUGO), ab8500_dir, &plf->dev, &ab8500_bank_fops); 588 (S_IRUGO | S_IWUGO), ab8500_dir, &plf->dev, &ab8500_bank_fops);
589 if (!ab8500_bank_file) 589 if (!ab8500_bank_file)
590 goto exit_destroy_reg; 590 goto exit_destroy_reg;
591 591
592 ab8500_address_file = debugfs_create_file("register-address", 592 ab8500_address_file = debugfs_create_file("register-address",
593 (S_IRUGO | S_IWUGO), ab8500_dir, &plf->dev, 593 (S_IRUGO | S_IWUGO), ab8500_dir, &plf->dev,
594 &ab8500_address_fops); 594 &ab8500_address_fops);
595 if (!ab8500_address_file) 595 if (!ab8500_address_file)
596 goto exit_destroy_bank; 596 goto exit_destroy_bank;
597 597
598 ab8500_val_file = debugfs_create_file("register-value", 598 ab8500_val_file = debugfs_create_file("register-value",
599 (S_IRUGO | S_IWUGO), ab8500_dir, &plf->dev, &ab8500_val_fops); 599 (S_IRUGO | S_IWUGO), ab8500_dir, &plf->dev, &ab8500_val_fops);
600 if (!ab8500_val_file) 600 if (!ab8500_val_file)
601 goto exit_destroy_address; 601 goto exit_destroy_address;
602 602
603 return 0; 603 return 0;
604 604
605exit_destroy_address: 605exit_destroy_address:
606 debugfs_remove(ab8500_address_file); 606 debugfs_remove(ab8500_address_file);
607exit_destroy_bank: 607exit_destroy_bank:
608 debugfs_remove(ab8500_bank_file); 608 debugfs_remove(ab8500_bank_file);
609exit_destroy_reg: 609exit_destroy_reg:
610 debugfs_remove(ab8500_reg_file); 610 debugfs_remove(ab8500_reg_file);
611exit_destroy_dir: 611exit_destroy_dir:
612 debugfs_remove(ab8500_dir); 612 debugfs_remove(ab8500_dir);
613exit_no_debugfs: 613exit_no_debugfs:
614 dev_err(&plf->dev, "failed to create debugfs entries.\n"); 614 dev_err(&plf->dev, "failed to create debugfs entries.\n");
615 return -ENOMEM; 615 return -ENOMEM;
616} 616}
617 617
618static int __devexit ab8500_debug_remove(struct platform_device *plf) 618static int __devexit ab8500_debug_remove(struct platform_device *plf)
619{ 619{
620 debugfs_remove(ab8500_val_file); 620 debugfs_remove(ab8500_val_file);
621 debugfs_remove(ab8500_address_file); 621 debugfs_remove(ab8500_address_file);
622 debugfs_remove(ab8500_bank_file); 622 debugfs_remove(ab8500_bank_file);
623 debugfs_remove(ab8500_reg_file); 623 debugfs_remove(ab8500_reg_file);
624 debugfs_remove(ab8500_dir); 624 debugfs_remove(ab8500_dir);
625 625
626 return 0; 626 return 0;
627} 627}
628 628
629static struct platform_driver ab8500_debug_driver = { 629static struct platform_driver ab8500_debug_driver = {
630 .driver = { 630 .driver = {
631 .name = "ab8500-debug", 631 .name = "ab8500-debug",
632 .owner = THIS_MODULE, 632 .owner = THIS_MODULE,
633 }, 633 },
634 .probe = ab8500_debug_probe, 634 .probe = ab8500_debug_probe,
635 .remove = __devexit_p(ab8500_debug_remove) 635 .remove = __devexit_p(ab8500_debug_remove)
636}; 636};
637 637
638static int __init ab8500_debug_init(void) 638static int __init ab8500_debug_init(void)
639{ 639{
640 return platform_driver_register(&ab8500_debug_driver); 640 return platform_driver_register(&ab8500_debug_driver);
641} 641}
642 642
643static void __exit ab8500_debug_exit(void) 643static void __exit ab8500_debug_exit(void)
644{ 644{
645 platform_driver_unregister(&ab8500_debug_driver); 645 platform_driver_unregister(&ab8500_debug_driver);
646} 646}
647subsys_initcall(ab8500_debug_init); 647subsys_initcall(ab8500_debug_init);
648module_exit(ab8500_debug_exit); 648module_exit(ab8500_debug_exit);
diff --git a/drivers/mfd/ab8500-spi.c b/drivers/mfd/ab8500-spi.c
deleted file mode 100644
index b1653421edb5..000000000000
--- a/drivers/mfd/ab8500-spi.c
+++ /dev/null
@@ -1,143 +0,0 @@
1/*
2 * Copyright (C) ST-Ericsson SA 2010
3 *
4 * License Terms: GNU General Public License v2
5 * Author: Srinidhi Kasagar <srinidhi.kasagar@stericsson.com>
6 */
7
8#include <linux/kernel.h>
9#include <linux/slab.h>
10#include <linux/init.h>
11#include <linux/module.h>
12#include <linux/platform_device.h>
13#include <linux/spi/spi.h>
14#include <linux/mfd/ab8500.h>
15
16/*
17 * This funtion writes to any AB8500 registers using
18 * SPI protocol & before it writes it packs the data
19 * in the below 24 bit frame format
20 *
21 * *|------------------------------------|
22 * *| 23|22...18|17.......10|9|8|7......0|
23 * *| r/w bank adr data |
24 * * ------------------------------------
25 *
26 * This function shouldn't be called from interrupt
27 * context
28 */
29static int ab8500_spi_write(struct ab8500 *ab8500, u16 addr, u8 data)
30{
31 struct spi_device *spi = container_of(ab8500->dev, struct spi_device,
32 dev);
33 unsigned long spi_data = addr << 10 | data;
34 struct spi_transfer xfer;
35 struct spi_message msg;
36
37 ab8500->tx_buf[0] = spi_data;
38 ab8500->rx_buf[0] = 0;
39
40 xfer.tx_buf = ab8500->tx_buf;
41 xfer.rx_buf = NULL;
42 xfer.len = sizeof(unsigned long);
43
44 spi_message_init(&msg);
45 spi_message_add_tail(&xfer, &msg);
46
47 return spi_sync(spi, &msg);
48}
49
50static int ab8500_spi_read(struct ab8500 *ab8500, u16 addr)
51{
52 struct spi_device *spi = container_of(ab8500->dev, struct spi_device,
53 dev);
54 unsigned long spi_data = 1 << 23 | addr << 10;
55 struct spi_transfer xfer;
56 struct spi_message msg;
57 int ret;
58
59 ab8500->tx_buf[0] = spi_data;
60 ab8500->rx_buf[0] = 0;
61
62 xfer.tx_buf = ab8500->tx_buf;
63 xfer.rx_buf = ab8500->rx_buf;
64 xfer.len = sizeof(unsigned long);
65
66 spi_message_init(&msg);
67 spi_message_add_tail(&xfer, &msg);
68
69 ret = spi_sync(spi, &msg);
70 if (!ret)
71 /*
72 * Only the 8 lowermost bytes are
73 * defined with value, the rest may
74 * vary depending on chip/board noise.
75 */
76 ret = ab8500->rx_buf[0] & 0xFFU;
77
78 return ret;
79}
80
81static int __devinit ab8500_spi_probe(struct spi_device *spi)
82{
83 struct ab8500 *ab8500;
84 int ret;
85
86 spi->bits_per_word = 24;
87 ret = spi_setup(spi);
88 if (ret < 0)
89 return ret;
90
91 ab8500 = kzalloc(sizeof *ab8500, GFP_KERNEL);
92 if (!ab8500)
93 return -ENOMEM;
94
95 ab8500->dev = &spi->dev;
96 ab8500->irq = spi->irq;
97
98 ab8500->read = ab8500_spi_read;
99 ab8500->write = ab8500_spi_write;
100
101 spi_set_drvdata(spi, ab8500);
102
103 ret = ab8500_init(ab8500);
104 if (ret)
105 kfree(ab8500);
106
107 return ret;
108}
109
110static int __devexit ab8500_spi_remove(struct spi_device *spi)
111{
112 struct ab8500 *ab8500 = spi_get_drvdata(spi);
113
114 ab8500_exit(ab8500);
115 kfree(ab8500);
116
117 return 0;
118}
119
120static struct spi_driver ab8500_spi_driver = {
121 .driver = {
122 .name = "ab8500-spi",
123 .owner = THIS_MODULE,
124 },
125 .probe = ab8500_spi_probe,
126 .remove = __devexit_p(ab8500_spi_remove)
127};
128
129static int __init ab8500_spi_init(void)
130{
131 return spi_register_driver(&ab8500_spi_driver);
132}
133subsys_initcall(ab8500_spi_init);
134
135static void __exit ab8500_spi_exit(void)
136{
137 spi_unregister_driver(&ab8500_spi_driver);
138}
139module_exit(ab8500_spi_exit);
140
141MODULE_AUTHOR("Srinidhi KASAGAR <srinidhi.kasagar@stericsson.com");
142MODULE_DESCRIPTION("AB8500 SPI");
143MODULE_LICENSE("GPL v2");
diff --git a/drivers/mfd/asic3.c b/drivers/mfd/asic3.c
index 7de708d15d72..6a1f94042612 100644
--- a/drivers/mfd/asic3.c
+++ b/drivers/mfd/asic3.c
@@ -57,7 +57,7 @@ struct asic3_clk {
57 .rate = _rate, \ 57 .rate = _rate, \
58 } 58 }
59 59
60struct asic3_clk asic3_clk_init[] __initdata = { 60static struct asic3_clk asic3_clk_init[] __initdata = {
61 INIT_CDEX(SPI, 0), 61 INIT_CDEX(SPI, 0),
62 INIT_CDEX(OWM, 5000000), 62 INIT_CDEX(OWM, 5000000),
63 INIT_CDEX(PWM0, 0), 63 INIT_CDEX(PWM0, 0),
@@ -102,7 +102,7 @@ static inline u32 asic3_read_register(struct asic3 *asic,
102 (reg >> asic->bus_shift)); 102 (reg >> asic->bus_shift));
103} 103}
104 104
105void asic3_set_register(struct asic3 *asic, u32 reg, u32 bits, bool set) 105static void asic3_set_register(struct asic3 *asic, u32 reg, u32 bits, bool set)
106{ 106{
107 unsigned long flags; 107 unsigned long flags;
108 u32 val; 108 u32 val;
@@ -226,14 +226,14 @@ static inline int asic3_irq_to_index(struct asic3 *asic, int irq)
226 return (irq - asic->irq_base) & 0xf; 226 return (irq - asic->irq_base) & 0xf;
227} 227}
228 228
229static void asic3_mask_gpio_irq(unsigned int irq) 229static void asic3_mask_gpio_irq(struct irq_data *data)
230{ 230{
231 struct asic3 *asic = get_irq_chip_data(irq); 231 struct asic3 *asic = irq_data_get_irq_chip_data(data);
232 u32 val, bank, index; 232 u32 val, bank, index;
233 unsigned long flags; 233 unsigned long flags;
234 234
235 bank = asic3_irq_to_bank(asic, irq); 235 bank = asic3_irq_to_bank(asic, data->irq);
236 index = asic3_irq_to_index(asic, irq); 236 index = asic3_irq_to_index(asic, data->irq);
237 237
238 spin_lock_irqsave(&asic->lock, flags); 238 spin_lock_irqsave(&asic->lock, flags);
239 val = asic3_read_register(asic, bank + ASIC3_GPIO_MASK); 239 val = asic3_read_register(asic, bank + ASIC3_GPIO_MASK);
@@ -242,9 +242,9 @@ static void asic3_mask_gpio_irq(unsigned int irq)
242 spin_unlock_irqrestore(&asic->lock, flags); 242 spin_unlock_irqrestore(&asic->lock, flags);
243} 243}
244 244
245static void asic3_mask_irq(unsigned int irq) 245static void asic3_mask_irq(struct irq_data *data)
246{ 246{
247 struct asic3 *asic = get_irq_chip_data(irq); 247 struct asic3 *asic = irq_data_get_irq_chip_data(data);
248 int regval; 248 int regval;
249 unsigned long flags; 249 unsigned long flags;
250 250
@@ -254,7 +254,7 @@ static void asic3_mask_irq(unsigned int irq)
254 ASIC3_INTR_INT_MASK); 254 ASIC3_INTR_INT_MASK);
255 255
256 regval &= ~(ASIC3_INTMASK_MASK0 << 256 regval &= ~(ASIC3_INTMASK_MASK0 <<
257 (irq - (asic->irq_base + ASIC3_NUM_GPIOS))); 257 (data->irq - (asic->irq_base + ASIC3_NUM_GPIOS)));
258 258
259 asic3_write_register(asic, 259 asic3_write_register(asic,
260 ASIC3_INTR_BASE + 260 ASIC3_INTR_BASE +
@@ -263,14 +263,14 @@ static void asic3_mask_irq(unsigned int irq)
263 spin_unlock_irqrestore(&asic->lock, flags); 263 spin_unlock_irqrestore(&asic->lock, flags);
264} 264}
265 265
266static void asic3_unmask_gpio_irq(unsigned int irq) 266static void asic3_unmask_gpio_irq(struct irq_data *data)
267{ 267{
268 struct asic3 *asic = get_irq_chip_data(irq); 268 struct asic3 *asic = irq_data_get_irq_chip_data(data);
269 u32 val, bank, index; 269 u32 val, bank, index;
270 unsigned long flags; 270 unsigned long flags;
271 271
272 bank = asic3_irq_to_bank(asic, irq); 272 bank = asic3_irq_to_bank(asic, data->irq);
273 index = asic3_irq_to_index(asic, irq); 273 index = asic3_irq_to_index(asic, data->irq);
274 274
275 spin_lock_irqsave(&asic->lock, flags); 275 spin_lock_irqsave(&asic->lock, flags);
276 val = asic3_read_register(asic, bank + ASIC3_GPIO_MASK); 276 val = asic3_read_register(asic, bank + ASIC3_GPIO_MASK);
@@ -279,9 +279,9 @@ static void asic3_unmask_gpio_irq(unsigned int irq)
279 spin_unlock_irqrestore(&asic->lock, flags); 279 spin_unlock_irqrestore(&asic->lock, flags);
280} 280}
281 281
282static void asic3_unmask_irq(unsigned int irq) 282static void asic3_unmask_irq(struct irq_data *data)
283{ 283{
284 struct asic3 *asic = get_irq_chip_data(irq); 284 struct asic3 *asic = irq_data_get_irq_chip_data(data);
285 int regval; 285 int regval;
286 unsigned long flags; 286 unsigned long flags;
287 287
@@ -291,7 +291,7 @@ static void asic3_unmask_irq(unsigned int irq)
291 ASIC3_INTR_INT_MASK); 291 ASIC3_INTR_INT_MASK);
292 292
293 regval |= (ASIC3_INTMASK_MASK0 << 293 regval |= (ASIC3_INTMASK_MASK0 <<
294 (irq - (asic->irq_base + ASIC3_NUM_GPIOS))); 294 (data->irq - (asic->irq_base + ASIC3_NUM_GPIOS)));
295 295
296 asic3_write_register(asic, 296 asic3_write_register(asic,
297 ASIC3_INTR_BASE + 297 ASIC3_INTR_BASE +
@@ -300,15 +300,15 @@ static void asic3_unmask_irq(unsigned int irq)
300 spin_unlock_irqrestore(&asic->lock, flags); 300 spin_unlock_irqrestore(&asic->lock, flags);
301} 301}
302 302
303static int asic3_gpio_irq_type(unsigned int irq, unsigned int type) 303static int asic3_gpio_irq_type(struct irq_data *data, unsigned int type)
304{ 304{
305 struct asic3 *asic = get_irq_chip_data(irq); 305 struct asic3 *asic = irq_data_get_irq_chip_data(data);
306 u32 bank, index; 306 u32 bank, index;
307 u16 trigger, level, edge, bit; 307 u16 trigger, level, edge, bit;
308 unsigned long flags; 308 unsigned long flags;
309 309
310 bank = asic3_irq_to_bank(asic, irq); 310 bank = asic3_irq_to_bank(asic, data->irq);
311 index = asic3_irq_to_index(asic, irq); 311 index = asic3_irq_to_index(asic, data->irq);
312 bit = 1<<index; 312 bit = 1<<index;
313 313
314 spin_lock_irqsave(&asic->lock, flags); 314 spin_lock_irqsave(&asic->lock, flags);
@@ -318,7 +318,7 @@ static int asic3_gpio_irq_type(unsigned int irq, unsigned int type)
318 bank + ASIC3_GPIO_EDGE_TRIGGER); 318 bank + ASIC3_GPIO_EDGE_TRIGGER);
319 trigger = asic3_read_register(asic, 319 trigger = asic3_read_register(asic,
320 bank + ASIC3_GPIO_TRIGGER_TYPE); 320 bank + ASIC3_GPIO_TRIGGER_TYPE);
321 asic->irq_bothedge[(irq - asic->irq_base) >> 4] &= ~bit; 321 asic->irq_bothedge[(data->irq - asic->irq_base) >> 4] &= ~bit;
322 322
323 if (type == IRQ_TYPE_EDGE_RISING) { 323 if (type == IRQ_TYPE_EDGE_RISING) {
324 trigger |= bit; 324 trigger |= bit;
@@ -328,11 +328,11 @@ static int asic3_gpio_irq_type(unsigned int irq, unsigned int type)
328 edge &= ~bit; 328 edge &= ~bit;
329 } else if (type == IRQ_TYPE_EDGE_BOTH) { 329 } else if (type == IRQ_TYPE_EDGE_BOTH) {
330 trigger |= bit; 330 trigger |= bit;
331 if (asic3_gpio_get(&asic->gpio, irq - asic->irq_base)) 331 if (asic3_gpio_get(&asic->gpio, data->irq - asic->irq_base))
332 edge &= ~bit; 332 edge &= ~bit;
333 else 333 else
334 edge |= bit; 334 edge |= bit;
335 asic->irq_bothedge[(irq - asic->irq_base) >> 4] |= bit; 335 asic->irq_bothedge[(data->irq - asic->irq_base) >> 4] |= bit;
336 } else if (type == IRQ_TYPE_LEVEL_LOW) { 336 } else if (type == IRQ_TYPE_LEVEL_LOW) {
337 trigger &= ~bit; 337 trigger &= ~bit;
338 level &= ~bit; 338 level &= ~bit;
@@ -359,17 +359,17 @@ static int asic3_gpio_irq_type(unsigned int irq, unsigned int type)
359 359
360static struct irq_chip asic3_gpio_irq_chip = { 360static struct irq_chip asic3_gpio_irq_chip = {
361 .name = "ASIC3-GPIO", 361 .name = "ASIC3-GPIO",
362 .ack = asic3_mask_gpio_irq, 362 .irq_ack = asic3_mask_gpio_irq,
363 .mask = asic3_mask_gpio_irq, 363 .irq_mask = asic3_mask_gpio_irq,
364 .unmask = asic3_unmask_gpio_irq, 364 .irq_unmask = asic3_unmask_gpio_irq,
365 .set_type = asic3_gpio_irq_type, 365 .irq_set_type = asic3_gpio_irq_type,
366}; 366};
367 367
368static struct irq_chip asic3_irq_chip = { 368static struct irq_chip asic3_irq_chip = {
369 .name = "ASIC3", 369 .name = "ASIC3",
370 .ack = asic3_mask_irq, 370 .irq_ack = asic3_mask_irq,
371 .mask = asic3_mask_irq, 371 .irq_mask = asic3_mask_irq,
372 .unmask = asic3_unmask_irq, 372 .irq_unmask = asic3_unmask_irq,
373}; 373};
374 374
375static int __init asic3_irq_probe(struct platform_device *pdev) 375static int __init asic3_irq_probe(struct platform_device *pdev)
@@ -635,7 +635,7 @@ static struct resource ds1wm_resources[] = {
635 }, 635 },
636 { 636 {
637 .start = ASIC3_IRQ_OWM, 637 .start = ASIC3_IRQ_OWM,
638 .start = ASIC3_IRQ_OWM, 638 .end = ASIC3_IRQ_OWM,
639 .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE, 639 .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHEDGE,
640 }, 640 },
641}; 641};
diff --git a/drivers/mfd/cs5535-mfd.c b/drivers/mfd/cs5535-mfd.c
new file mode 100644
index 000000000000..59ca6f151e78
--- /dev/null
+++ b/drivers/mfd/cs5535-mfd.c
@@ -0,0 +1,151 @@
1/*
2 * cs5535-mfd.c - core MFD driver for CS5535/CS5536 southbridges
3 *
4 * The CS5535 and CS5536 has an ISA bridge on the PCI bus that is
5 * used for accessing GPIOs, MFGPTs, ACPI, etc. Each subdevice has
6 * an IO range that's specified in a single BAR. The BAR order is
7 * hardcoded in the CS553x specifications.
8 *
9 * Copyright (c) 2010 Andres Salomon <dilinger@queued.net>
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25#include <linux/kernel.h>
26#include <linux/init.h>
27#include <linux/mfd/core.h>
28#include <linux/module.h>
29#include <linux/pci.h>
30
31#define DRV_NAME "cs5535-mfd"
32
33enum cs5535_mfd_bars {
34 SMB_BAR = 0,
35 GPIO_BAR = 1,
36 MFGPT_BAR = 2,
37 PMS_BAR = 4,
38 ACPI_BAR = 5,
39 NR_BARS,
40};
41
42static __devinitdata struct resource cs5535_mfd_resources[NR_BARS];
43
44static __devinitdata struct mfd_cell cs5535_mfd_cells[] = {
45 {
46 .id = SMB_BAR,
47 .name = "cs5535-smb",
48 .num_resources = 1,
49 .resources = &cs5535_mfd_resources[SMB_BAR],
50 },
51 {
52 .id = GPIO_BAR,
53 .name = "cs5535-gpio",
54 .num_resources = 1,
55 .resources = &cs5535_mfd_resources[GPIO_BAR],
56 },
57 {
58 .id = MFGPT_BAR,
59 .name = "cs5535-mfgpt",
60 .num_resources = 1,
61 .resources = &cs5535_mfd_resources[MFGPT_BAR],
62 },
63 {
64 .id = PMS_BAR,
65 .name = "cs5535-pms",
66 .num_resources = 1,
67 .resources = &cs5535_mfd_resources[PMS_BAR],
68 },
69 {
70 .id = ACPI_BAR,
71 .name = "cs5535-acpi",
72 .num_resources = 1,
73 .resources = &cs5535_mfd_resources[ACPI_BAR],
74 },
75};
76
77static int __devinit cs5535_mfd_probe(struct pci_dev *pdev,
78 const struct pci_device_id *id)
79{
80 int err, i;
81
82 err = pci_enable_device(pdev);
83 if (err)
84 return err;
85
86 /* fill in IO range for each cell; subdrivers handle the region */
87 for (i = 0; i < ARRAY_SIZE(cs5535_mfd_cells); i++) {
88 int bar = cs5535_mfd_cells[i].id;
89 struct resource *r = &cs5535_mfd_resources[bar];
90
91 r->flags = IORESOURCE_IO;
92 r->start = pci_resource_start(pdev, bar);
93 r->end = pci_resource_end(pdev, bar);
94
95 /* id is used for temporarily storing BAR; unset it now */
96 cs5535_mfd_cells[i].id = 0;
97 }
98
99 err = mfd_add_devices(&pdev->dev, -1, cs5535_mfd_cells,
100 ARRAY_SIZE(cs5535_mfd_cells), NULL, 0);
101 if (err) {
102 dev_err(&pdev->dev, "MFD add devices failed: %d\n", err);
103 goto err_disable;
104 }
105
106 dev_info(&pdev->dev, "%zu devices registered.\n",
107 ARRAY_SIZE(cs5535_mfd_cells));
108
109 return 0;
110
111err_disable:
112 pci_disable_device(pdev);
113 return err;
114}
115
116static void __devexit cs5535_mfd_remove(struct pci_dev *pdev)
117{
118 mfd_remove_devices(&pdev->dev);
119 pci_disable_device(pdev);
120}
121
122static struct pci_device_id cs5535_mfd_pci_tbl[] = {
123 { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_CS5535_ISA) },
124 { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_ISA) },
125 { 0, }
126};
127MODULE_DEVICE_TABLE(pci, cs5535_mfd_pci_tbl);
128
129static struct pci_driver cs5535_mfd_drv = {
130 .name = DRV_NAME,
131 .id_table = cs5535_mfd_pci_tbl,
132 .probe = cs5535_mfd_probe,
133 .remove = __devexit_p(cs5535_mfd_remove),
134};
135
136static int __init cs5535_mfd_init(void)
137{
138 return pci_register_driver(&cs5535_mfd_drv);
139}
140
141static void __exit cs5535_mfd_exit(void)
142{
143 pci_unregister_driver(&cs5535_mfd_drv);
144}
145
146module_init(cs5535_mfd_init);
147module_exit(cs5535_mfd_exit);
148
149MODULE_AUTHOR("Andres Salomon <dilinger@queued.net>");
150MODULE_DESCRIPTION("MFD driver for CS5535/CS5536 southbridge's ISA PCI device");
151MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/ezx-pcap.c b/drivers/mfd/ezx-pcap.c
index c2b698d69a93..9e2d8dd5f9e5 100644
--- a/drivers/mfd/ezx-pcap.c
+++ b/drivers/mfd/ezx-pcap.c
@@ -144,26 +144,26 @@ int pcap_to_irq(struct pcap_chip *pcap, int irq)
144} 144}
145EXPORT_SYMBOL_GPL(pcap_to_irq); 145EXPORT_SYMBOL_GPL(pcap_to_irq);
146 146
147static void pcap_mask_irq(unsigned int irq) 147static void pcap_mask_irq(struct irq_data *d)
148{ 148{
149 struct pcap_chip *pcap = get_irq_chip_data(irq); 149 struct pcap_chip *pcap = irq_data_get_irq_chip_data(d);
150 150
151 pcap->msr |= 1 << irq_to_pcap(pcap, irq); 151 pcap->msr |= 1 << irq_to_pcap(pcap, d->irq);
152 queue_work(pcap->workqueue, &pcap->msr_work); 152 queue_work(pcap->workqueue, &pcap->msr_work);
153} 153}
154 154
155static void pcap_unmask_irq(unsigned int irq) 155static void pcap_unmask_irq(struct irq_data *d)
156{ 156{
157 struct pcap_chip *pcap = get_irq_chip_data(irq); 157 struct pcap_chip *pcap = irq_data_get_irq_chip_data(d);
158 158
159 pcap->msr &= ~(1 << irq_to_pcap(pcap, irq)); 159 pcap->msr &= ~(1 << irq_to_pcap(pcap, d->irq));
160 queue_work(pcap->workqueue, &pcap->msr_work); 160 queue_work(pcap->workqueue, &pcap->msr_work);
161} 161}
162 162
163static struct irq_chip pcap_irq_chip = { 163static struct irq_chip pcap_irq_chip = {
164 .name = "pcap", 164 .name = "pcap",
165 .mask = pcap_mask_irq, 165 .irq_mask = pcap_mask_irq,
166 .unmask = pcap_unmask_irq, 166 .irq_unmask = pcap_unmask_irq,
167}; 167};
168 168
169static void pcap_msr_work(struct work_struct *work) 169static void pcap_msr_work(struct work_struct *work)
@@ -199,8 +199,7 @@ static void pcap_isr_work(struct work_struct *work)
199 if (service & 1) { 199 if (service & 1) {
200 struct irq_desc *desc = irq_to_desc(irq); 200 struct irq_desc *desc = irq_to_desc(irq);
201 201
202 if (WARN(!desc, KERN_WARNING 202 if (WARN(!desc, "Invalid PCAP IRQ %d\n", irq))
203 "Invalid PCAP IRQ %d\n", irq))
204 break; 203 break;
205 204
206 if (desc->status & IRQ_DISABLED) 205 if (desc->status & IRQ_DISABLED)
@@ -218,7 +217,7 @@ static void pcap_irq_handler(unsigned int irq, struct irq_desc *desc)
218{ 217{
219 struct pcap_chip *pcap = get_irq_data(irq); 218 struct pcap_chip *pcap = get_irq_data(irq);
220 219
221 desc->chip->ack(irq); 220 desc->irq_data.chip->irq_ack(&desc->irq_data);
222 queue_work(pcap->workqueue, &pcap->isr_work); 221 queue_work(pcap->workqueue, &pcap->isr_work);
223 return; 222 return;
224} 223}
@@ -282,7 +281,7 @@ static irqreturn_t pcap_adc_irq(int irq, void *_pcap)
282 mutex_lock(&pcap->adc_mutex); 281 mutex_lock(&pcap->adc_mutex);
283 req = pcap->adc_queue[pcap->adc_head]; 282 req = pcap->adc_queue[pcap->adc_head];
284 283
285 if (WARN(!req, KERN_WARNING "adc irq without pending request\n")) { 284 if (WARN(!req, "adc irq without pending request\n")) {
286 mutex_unlock(&pcap->adc_mutex); 285 mutex_unlock(&pcap->adc_mutex);
287 return IRQ_HANDLED; 286 return IRQ_HANDLED;
288 } 287 }
diff --git a/drivers/mfd/htc-egpio.c b/drivers/mfd/htc-egpio.c
index d3e74f8585e0..d00b6d1a69e5 100644
--- a/drivers/mfd/htc-egpio.c
+++ b/drivers/mfd/htc-egpio.c
@@ -70,31 +70,32 @@ static inline void ack_irqs(struct egpio_info *ei)
70 ei->ack_write, ei->ack_register << ei->bus_shift); 70 ei->ack_write, ei->ack_register << ei->bus_shift);
71} 71}
72 72
73static void egpio_ack(unsigned int irq) 73static void egpio_ack(struct irq_data *data)
74{ 74{
75} 75}
76 76
77/* There does not appear to be a way to proactively mask interrupts 77/* There does not appear to be a way to proactively mask interrupts
78 * on the egpio chip itself. So, we simply ignore interrupts that 78 * on the egpio chip itself. So, we simply ignore interrupts that
79 * aren't desired. */ 79 * aren't desired. */
80static void egpio_mask(unsigned int irq) 80static void egpio_mask(struct irq_data *data)
81{ 81{
82 struct egpio_info *ei = get_irq_chip_data(irq); 82 struct egpio_info *ei = irq_data_get_irq_chip_data(data);
83 ei->irqs_enabled &= ~(1 << (irq - ei->irq_start)); 83 ei->irqs_enabled &= ~(1 << (data->irq - ei->irq_start));
84 pr_debug("EGPIO mask %d %04x\n", irq, ei->irqs_enabled); 84 pr_debug("EGPIO mask %d %04x\n", data->irq, ei->irqs_enabled);
85} 85}
86static void egpio_unmask(unsigned int irq) 86
87static void egpio_unmask(struct irq_data *data)
87{ 88{
88 struct egpio_info *ei = get_irq_chip_data(irq); 89 struct egpio_info *ei = irq_data_get_irq_chip_data(data);
89 ei->irqs_enabled |= 1 << (irq - ei->irq_start); 90 ei->irqs_enabled |= 1 << (data->irq - ei->irq_start);
90 pr_debug("EGPIO unmask %d %04x\n", irq, ei->irqs_enabled); 91 pr_debug("EGPIO unmask %d %04x\n", data->irq, ei->irqs_enabled);
91} 92}
92 93
93static struct irq_chip egpio_muxed_chip = { 94static struct irq_chip egpio_muxed_chip = {
94 .name = "htc-egpio", 95 .name = "htc-egpio",
95 .ack = egpio_ack, 96 .irq_ack = egpio_ack,
96 .mask = egpio_mask, 97 .irq_mask = egpio_mask,
97 .unmask = egpio_unmask, 98 .irq_unmask = egpio_unmask,
98}; 99};
99 100
100static void egpio_handler(unsigned int irq, struct irq_desc *desc) 101static void egpio_handler(unsigned int irq, struct irq_desc *desc)
diff --git a/drivers/mfd/htc-i2cpld.c b/drivers/mfd/htc-i2cpld.c
index 594c9a8e25e1..296ad1562f69 100644
--- a/drivers/mfd/htc-i2cpld.c
+++ b/drivers/mfd/htc-i2cpld.c
@@ -82,25 +82,25 @@ struct htcpld_data {
82/* There does not appear to be a way to proactively mask interrupts 82/* There does not appear to be a way to proactively mask interrupts
83 * on the htcpld chip itself. So, we simply ignore interrupts that 83 * on the htcpld chip itself. So, we simply ignore interrupts that
84 * aren't desired. */ 84 * aren't desired. */
85static void htcpld_mask(unsigned int irq) 85static void htcpld_mask(struct irq_data *data)
86{ 86{
87 struct htcpld_chip *chip = get_irq_chip_data(irq); 87 struct htcpld_chip *chip = irq_data_get_irq_chip_data(data);
88 chip->irqs_enabled &= ~(1 << (irq - chip->irq_start)); 88 chip->irqs_enabled &= ~(1 << (data->irq - chip->irq_start));
89 pr_debug("HTCPLD mask %d %04x\n", irq, chip->irqs_enabled); 89 pr_debug("HTCPLD mask %d %04x\n", data->irq, chip->irqs_enabled);
90} 90}
91static void htcpld_unmask(unsigned int irq) 91static void htcpld_unmask(struct irq_data *data)
92{ 92{
93 struct htcpld_chip *chip = get_irq_chip_data(irq); 93 struct htcpld_chip *chip = irq_data_get_irq_chip_data(data);
94 chip->irqs_enabled |= 1 << (irq - chip->irq_start); 94 chip->irqs_enabled |= 1 << (data->irq - chip->irq_start);
95 pr_debug("HTCPLD unmask %d %04x\n", irq, chip->irqs_enabled); 95 pr_debug("HTCPLD unmask %d %04x\n", data->irq, chip->irqs_enabled);
96} 96}
97 97
98static int htcpld_set_type(unsigned int irq, unsigned int flags) 98static int htcpld_set_type(struct irq_data *data, unsigned int flags)
99{ 99{
100 struct irq_desc *d = irq_to_desc(irq); 100 struct irq_desc *d = irq_to_desc(data->irq);
101 101
102 if (!d) { 102 if (!d) {
103 pr_err("HTCPLD invalid IRQ: %d\n", irq); 103 pr_err("HTCPLD invalid IRQ: %d\n", data->irq);
104 return -EINVAL; 104 return -EINVAL;
105 } 105 }
106 106
@@ -118,10 +118,10 @@ static int htcpld_set_type(unsigned int irq, unsigned int flags)
118} 118}
119 119
120static struct irq_chip htcpld_muxed_chip = { 120static struct irq_chip htcpld_muxed_chip = {
121 .name = "htcpld", 121 .name = "htcpld",
122 .mask = htcpld_mask, 122 .irq_mask = htcpld_mask,
123 .unmask = htcpld_unmask, 123 .irq_unmask = htcpld_unmask,
124 .set_type = htcpld_set_type, 124 .irq_set_type = htcpld_set_type,
125}; 125};
126 126
127/* To properly dispatch IRQ events, we need to read from the 127/* To properly dispatch IRQ events, we need to read from the
@@ -235,7 +235,7 @@ static irqreturn_t htcpld_handler(int irq, void *dev)
235 * and that work is scheduled in the set routine. The kernel can then run 235 * and that work is scheduled in the set routine. The kernel can then run
236 * the I2C functions, which will sleep, in process context. 236 * the I2C functions, which will sleep, in process context.
237 */ 237 */
238void htcpld_chip_set(struct gpio_chip *chip, unsigned offset, int val) 238static void htcpld_chip_set(struct gpio_chip *chip, unsigned offset, int val)
239{ 239{
240 struct i2c_client *client; 240 struct i2c_client *client;
241 struct htcpld_chip *chip_data; 241 struct htcpld_chip *chip_data;
@@ -259,7 +259,7 @@ void htcpld_chip_set(struct gpio_chip *chip, unsigned offset, int val)
259 schedule_work(&(chip_data->set_val_work)); 259 schedule_work(&(chip_data->set_val_work));
260} 260}
261 261
262void htcpld_chip_set_ni(struct work_struct *work) 262static void htcpld_chip_set_ni(struct work_struct *work)
263{ 263{
264 struct htcpld_chip *chip_data; 264 struct htcpld_chip *chip_data;
265 struct i2c_client *client; 265 struct i2c_client *client;
@@ -269,7 +269,7 @@ void htcpld_chip_set_ni(struct work_struct *work)
269 i2c_smbus_read_byte_data(client, chip_data->cache_out); 269 i2c_smbus_read_byte_data(client, chip_data->cache_out);
270} 270}
271 271
272int htcpld_chip_get(struct gpio_chip *chip, unsigned offset) 272static int htcpld_chip_get(struct gpio_chip *chip, unsigned offset)
273{ 273{
274 struct htcpld_chip *chip_data; 274 struct htcpld_chip *chip_data;
275 int val = 0; 275 int val = 0;
@@ -316,7 +316,7 @@ static int htcpld_direction_input(struct gpio_chip *chip,
316 return (offset < chip->ngpio) ? 0 : -EINVAL; 316 return (offset < chip->ngpio) ? 0 : -EINVAL;
317} 317}
318 318
319int htcpld_chip_to_irq(struct gpio_chip *chip, unsigned offset) 319static int htcpld_chip_to_irq(struct gpio_chip *chip, unsigned offset)
320{ 320{
321 struct htcpld_chip *chip_data; 321 struct htcpld_chip *chip_data;
322 322
@@ -328,7 +328,7 @@ int htcpld_chip_to_irq(struct gpio_chip *chip, unsigned offset)
328 return -EINVAL; 328 return -EINVAL;
329} 329}
330 330
331void htcpld_chip_reset(struct i2c_client *client) 331static void htcpld_chip_reset(struct i2c_client *client)
332{ 332{
333 struct htcpld_chip *chip_data = i2c_get_clientdata(client); 333 struct htcpld_chip *chip_data = i2c_get_clientdata(client);
334 if (!chip_data) 334 if (!chip_data)
diff --git a/drivers/mfd/jz4740-adc.c b/drivers/mfd/jz4740-adc.c
index 9dd1b33f2275..0cc59795f600 100644
--- a/drivers/mfd/jz4740-adc.c
+++ b/drivers/mfd/jz4740-adc.c
@@ -84,31 +84,30 @@ static inline void jz4740_adc_irq_set_masked(struct jz4740_adc *adc, int irq,
84 spin_unlock_irqrestore(&adc->lock, flags); 84 spin_unlock_irqrestore(&adc->lock, flags);
85} 85}
86 86
87static void jz4740_adc_irq_mask(unsigned int irq) 87static void jz4740_adc_irq_mask(struct irq_data *data)
88{ 88{
89 struct jz4740_adc *adc = get_irq_chip_data(irq); 89 struct jz4740_adc *adc = irq_data_get_irq_chip_data(data);
90 jz4740_adc_irq_set_masked(adc, irq, true); 90 jz4740_adc_irq_set_masked(adc, data->irq, true);
91} 91}
92 92
93static void jz4740_adc_irq_unmask(unsigned int irq) 93static void jz4740_adc_irq_unmask(struct irq_data *data)
94{ 94{
95 struct jz4740_adc *adc = get_irq_chip_data(irq); 95 struct jz4740_adc *adc = irq_data_get_irq_chip_data(data);
96 jz4740_adc_irq_set_masked(adc, irq, false); 96 jz4740_adc_irq_set_masked(adc, data->irq, false);
97} 97}
98 98
99static void jz4740_adc_irq_ack(unsigned int irq) 99static void jz4740_adc_irq_ack(struct irq_data *data)
100{ 100{
101 struct jz4740_adc *adc = get_irq_chip_data(irq); 101 struct jz4740_adc *adc = irq_data_get_irq_chip_data(data);
102 102 unsigned int irq = data->irq - adc->irq_base;
103 irq -= adc->irq_base;
104 writeb(BIT(irq), adc->base + JZ_REG_ADC_STATUS); 103 writeb(BIT(irq), adc->base + JZ_REG_ADC_STATUS);
105} 104}
106 105
107static struct irq_chip jz4740_adc_irq_chip = { 106static struct irq_chip jz4740_adc_irq_chip = {
108 .name = "jz4740-adc", 107 .name = "jz4740-adc",
109 .mask = jz4740_adc_irq_mask, 108 .irq_mask = jz4740_adc_irq_mask,
110 .unmask = jz4740_adc_irq_unmask, 109 .irq_unmask = jz4740_adc_irq_unmask,
111 .ack = jz4740_adc_irq_ack, 110 .irq_ack = jz4740_adc_irq_ack,
112}; 111};
113 112
114static void jz4740_adc_irq_demux(unsigned int irq, struct irq_desc *desc) 113static void jz4740_adc_irq_demux(unsigned int irq, struct irq_desc *desc)
diff --git a/drivers/mfd/max8925-core.c b/drivers/mfd/max8925-core.c
index 44695f5a1800..0e998dc4e7d8 100644
--- a/drivers/mfd/max8925-core.c
+++ b/drivers/mfd/max8925-core.c
@@ -407,16 +407,16 @@ static irqreturn_t max8925_tsc_irq(int irq, void *data)
407 return IRQ_HANDLED; 407 return IRQ_HANDLED;
408} 408}
409 409
410static void max8925_irq_lock(unsigned int irq) 410static void max8925_irq_lock(struct irq_data *data)
411{ 411{
412 struct max8925_chip *chip = get_irq_chip_data(irq); 412 struct max8925_chip *chip = irq_data_get_irq_chip_data(data);
413 413
414 mutex_lock(&chip->irq_lock); 414 mutex_lock(&chip->irq_lock);
415} 415}
416 416
417static void max8925_irq_sync_unlock(unsigned int irq) 417static void max8925_irq_sync_unlock(struct irq_data *data)
418{ 418{
419 struct max8925_chip *chip = get_irq_chip_data(irq); 419 struct max8925_chip *chip = irq_data_get_irq_chip_data(data);
420 struct max8925_irq_data *irq_data; 420 struct max8925_irq_data *irq_data;
421 static unsigned char cache_chg[2] = {0xff, 0xff}; 421 static unsigned char cache_chg[2] = {0xff, 0xff};
422 static unsigned char cache_on[2] = {0xff, 0xff}; 422 static unsigned char cache_on[2] = {0xff, 0xff};
@@ -492,25 +492,25 @@ static void max8925_irq_sync_unlock(unsigned int irq)
492 mutex_unlock(&chip->irq_lock); 492 mutex_unlock(&chip->irq_lock);
493} 493}
494 494
495static void max8925_irq_enable(unsigned int irq) 495static void max8925_irq_enable(struct irq_data *data)
496{ 496{
497 struct max8925_chip *chip = get_irq_chip_data(irq); 497 struct max8925_chip *chip = irq_data_get_irq_chip_data(data);
498 max8925_irqs[irq - chip->irq_base].enable 498 max8925_irqs[data->irq - chip->irq_base].enable
499 = max8925_irqs[irq - chip->irq_base].offs; 499 = max8925_irqs[data->irq - chip->irq_base].offs;
500} 500}
501 501
502static void max8925_irq_disable(unsigned int irq) 502static void max8925_irq_disable(struct irq_data *data)
503{ 503{
504 struct max8925_chip *chip = get_irq_chip_data(irq); 504 struct max8925_chip *chip = irq_data_get_irq_chip_data(data);
505 max8925_irqs[irq - chip->irq_base].enable = 0; 505 max8925_irqs[data->irq - chip->irq_base].enable = 0;
506} 506}
507 507
508static struct irq_chip max8925_irq_chip = { 508static struct irq_chip max8925_irq_chip = {
509 .name = "max8925", 509 .name = "max8925",
510 .bus_lock = max8925_irq_lock, 510 .irq_bus_lock = max8925_irq_lock,
511 .bus_sync_unlock = max8925_irq_sync_unlock, 511 .irq_bus_sync_unlock = max8925_irq_sync_unlock,
512 .enable = max8925_irq_enable, 512 .irq_enable = max8925_irq_enable,
513 .disable = max8925_irq_disable, 513 .irq_disable = max8925_irq_disable,
514}; 514};
515 515
516static int max8925_irq_init(struct max8925_chip *chip, int irq, 516static int max8925_irq_init(struct max8925_chip *chip, int irq,
diff --git a/drivers/mfd/max8998-irq.c b/drivers/mfd/max8998-irq.c
index 45bfe77b639b..3903e1fbb334 100644
--- a/drivers/mfd/max8998-irq.c
+++ b/drivers/mfd/max8998-irq.c
@@ -102,16 +102,16 @@ irq_to_max8998_irq(struct max8998_dev *max8998, int irq)
102 return &max8998_irqs[irq - max8998->irq_base]; 102 return &max8998_irqs[irq - max8998->irq_base];
103} 103}
104 104
105static void max8998_irq_lock(unsigned int irq) 105static void max8998_irq_lock(struct irq_data *data)
106{ 106{
107 struct max8998_dev *max8998 = get_irq_chip_data(irq); 107 struct max8998_dev *max8998 = irq_data_get_irq_chip_data(data);
108 108
109 mutex_lock(&max8998->irqlock); 109 mutex_lock(&max8998->irqlock);
110} 110}
111 111
112static void max8998_irq_sync_unlock(unsigned int irq) 112static void max8998_irq_sync_unlock(struct irq_data *data)
113{ 113{
114 struct max8998_dev *max8998 = get_irq_chip_data(irq); 114 struct max8998_dev *max8998 = irq_data_get_irq_chip_data(data);
115 int i; 115 int i;
116 116
117 for (i = 0; i < ARRAY_SIZE(max8998->irq_masks_cur); i++) { 117 for (i = 0; i < ARRAY_SIZE(max8998->irq_masks_cur); i++) {
@@ -129,28 +129,30 @@ static void max8998_irq_sync_unlock(unsigned int irq)
129 mutex_unlock(&max8998->irqlock); 129 mutex_unlock(&max8998->irqlock);
130} 130}
131 131
132static void max8998_irq_unmask(unsigned int irq) 132static void max8998_irq_unmask(struct irq_data *data)
133{ 133{
134 struct max8998_dev *max8998 = get_irq_chip_data(irq); 134 struct max8998_dev *max8998 = irq_data_get_irq_chip_data(data);
135 struct max8998_irq_data *irq_data = irq_to_max8998_irq(max8998, irq); 135 struct max8998_irq_data *irq_data = irq_to_max8998_irq(max8998,
136 data->irq);
136 137
137 max8998->irq_masks_cur[irq_data->reg - 1] &= ~irq_data->mask; 138 max8998->irq_masks_cur[irq_data->reg - 1] &= ~irq_data->mask;
138} 139}
139 140
140static void max8998_irq_mask(unsigned int irq) 141static void max8998_irq_mask(struct irq_data *data)
141{ 142{
142 struct max8998_dev *max8998 = get_irq_chip_data(irq); 143 struct max8998_dev *max8998 = irq_data_get_irq_chip_data(data);
143 struct max8998_irq_data *irq_data = irq_to_max8998_irq(max8998, irq); 144 struct max8998_irq_data *irq_data = irq_to_max8998_irq(max8998,
145 data->irq);
144 146
145 max8998->irq_masks_cur[irq_data->reg - 1] |= irq_data->mask; 147 max8998->irq_masks_cur[irq_data->reg - 1] |= irq_data->mask;
146} 148}
147 149
148static struct irq_chip max8998_irq_chip = { 150static struct irq_chip max8998_irq_chip = {
149 .name = "max8998", 151 .name = "max8998",
150 .bus_lock = max8998_irq_lock, 152 .irq_bus_lock = max8998_irq_lock,
151 .bus_sync_unlock = max8998_irq_sync_unlock, 153 .irq_bus_sync_unlock = max8998_irq_sync_unlock,
152 .mask = max8998_irq_mask, 154 .irq_mask = max8998_irq_mask,
153 .unmask = max8998_irq_unmask, 155 .irq_unmask = max8998_irq_unmask,
154}; 156};
155 157
156static irqreturn_t max8998_irq_thread(int irq, void *data) 158static irqreturn_t max8998_irq_thread(int irq, void *data)
@@ -181,6 +183,13 @@ static irqreturn_t max8998_irq_thread(int irq, void *data)
181 return IRQ_HANDLED; 183 return IRQ_HANDLED;
182} 184}
183 185
186int max8998_irq_resume(struct max8998_dev *max8998)
187{
188 if (max8998->irq && max8998->irq_base)
189 max8998_irq_thread(max8998->irq_base, max8998);
190 return 0;
191}
192
184int max8998_irq_init(struct max8998_dev *max8998) 193int max8998_irq_init(struct max8998_dev *max8998)
185{ 194{
186 int i; 195 int i;
diff --git a/drivers/mfd/max8998.c b/drivers/mfd/max8998.c
index bb9977bebe78..bbfe86732602 100644
--- a/drivers/mfd/max8998.c
+++ b/drivers/mfd/max8998.c
@@ -25,6 +25,8 @@
25#include <linux/init.h> 25#include <linux/init.h>
26#include <linux/slab.h> 26#include <linux/slab.h>
27#include <linux/i2c.h> 27#include <linux/i2c.h>
28#include <linux/interrupt.h>
29#include <linux/pm_runtime.h>
28#include <linux/mutex.h> 30#include <linux/mutex.h>
29#include <linux/mfd/core.h> 31#include <linux/mfd/core.h>
30#include <linux/mfd/max8998.h> 32#include <linux/mfd/max8998.h>
@@ -40,6 +42,14 @@ static struct mfd_cell max8998_devs[] = {
40 }, 42 },
41}; 43};
42 44
45static struct mfd_cell lp3974_devs[] = {
46 {
47 .name = "lp3974-pmic",
48 }, {
49 .name = "lp3974-rtc",
50 },
51};
52
43int max8998_read_reg(struct i2c_client *i2c, u8 reg, u8 *dest) 53int max8998_read_reg(struct i2c_client *i2c, u8 reg, u8 *dest)
44{ 54{
45 struct max8998_dev *max8998 = i2c_get_clientdata(i2c); 55 struct max8998_dev *max8998 = i2c_get_clientdata(i2c);
@@ -135,6 +145,7 @@ static int max8998_i2c_probe(struct i2c_client *i2c,
135 if (pdata) { 145 if (pdata) {
136 max8998->ono = pdata->ono; 146 max8998->ono = pdata->ono;
137 max8998->irq_base = pdata->irq_base; 147 max8998->irq_base = pdata->irq_base;
148 max8998->wakeup = pdata->wakeup;
138 } 149 }
139 mutex_init(&max8998->iolock); 150 mutex_init(&max8998->iolock);
140 151
@@ -143,9 +154,23 @@ static int max8998_i2c_probe(struct i2c_client *i2c,
143 154
144 max8998_irq_init(max8998); 155 max8998_irq_init(max8998);
145 156
146 ret = mfd_add_devices(max8998->dev, -1, 157 pm_runtime_set_active(max8998->dev);
147 max8998_devs, ARRAY_SIZE(max8998_devs), 158
148 NULL, 0); 159 switch (id->driver_data) {
160 case TYPE_LP3974:
161 ret = mfd_add_devices(max8998->dev, -1,
162 lp3974_devs, ARRAY_SIZE(lp3974_devs),
163 NULL, 0);
164 break;
165 case TYPE_MAX8998:
166 ret = mfd_add_devices(max8998->dev, -1,
167 max8998_devs, ARRAY_SIZE(max8998_devs),
168 NULL, 0);
169 break;
170 default:
171 ret = -EINVAL;
172 }
173
149 if (ret < 0) 174 if (ret < 0)
150 goto err; 175 goto err;
151 176
@@ -178,10 +203,113 @@ static const struct i2c_device_id max8998_i2c_id[] = {
178}; 203};
179MODULE_DEVICE_TABLE(i2c, max8998_i2c_id); 204MODULE_DEVICE_TABLE(i2c, max8998_i2c_id);
180 205
206static int max8998_suspend(struct device *dev)
207{
208 struct i2c_client *i2c = container_of(dev, struct i2c_client, dev);
209 struct max8998_dev *max8998 = i2c_get_clientdata(i2c);
210
211 if (max8998->wakeup)
212 set_irq_wake(max8998->irq, 1);
213 return 0;
214}
215
216static int max8998_resume(struct device *dev)
217{
218 struct i2c_client *i2c = container_of(dev, struct i2c_client, dev);
219 struct max8998_dev *max8998 = i2c_get_clientdata(i2c);
220
221 if (max8998->wakeup)
222 set_irq_wake(max8998->irq, 0);
223 /*
224 * In LP3974, if IRQ registers are not "read & clear"
225 * when it's set during sleep, the interrupt becomes
226 * disabled.
227 */
228 return max8998_irq_resume(i2c_get_clientdata(i2c));
229}
230
231struct max8998_reg_dump {
232 u8 addr;
233 u8 val;
234};
235#define SAVE_ITEM(x) { .addr = (x), .val = 0x0, }
236struct max8998_reg_dump max8998_dump[] = {
237 SAVE_ITEM(MAX8998_REG_IRQM1),
238 SAVE_ITEM(MAX8998_REG_IRQM2),
239 SAVE_ITEM(MAX8998_REG_IRQM3),
240 SAVE_ITEM(MAX8998_REG_IRQM4),
241 SAVE_ITEM(MAX8998_REG_STATUSM1),
242 SAVE_ITEM(MAX8998_REG_STATUSM2),
243 SAVE_ITEM(MAX8998_REG_CHGR1),
244 SAVE_ITEM(MAX8998_REG_CHGR2),
245 SAVE_ITEM(MAX8998_REG_LDO_ACTIVE_DISCHARGE1),
246 SAVE_ITEM(MAX8998_REG_LDO_ACTIVE_DISCHARGE1),
247 SAVE_ITEM(MAX8998_REG_BUCK_ACTIVE_DISCHARGE3),
248 SAVE_ITEM(MAX8998_REG_ONOFF1),
249 SAVE_ITEM(MAX8998_REG_ONOFF2),
250 SAVE_ITEM(MAX8998_REG_ONOFF3),
251 SAVE_ITEM(MAX8998_REG_ONOFF4),
252 SAVE_ITEM(MAX8998_REG_BUCK1_VOLTAGE1),
253 SAVE_ITEM(MAX8998_REG_BUCK1_VOLTAGE2),
254 SAVE_ITEM(MAX8998_REG_BUCK1_VOLTAGE3),
255 SAVE_ITEM(MAX8998_REG_BUCK1_VOLTAGE4),
256 SAVE_ITEM(MAX8998_REG_BUCK2_VOLTAGE1),
257 SAVE_ITEM(MAX8998_REG_BUCK2_VOLTAGE2),
258 SAVE_ITEM(MAX8998_REG_LDO2_LDO3),
259 SAVE_ITEM(MAX8998_REG_LDO4),
260 SAVE_ITEM(MAX8998_REG_LDO5),
261 SAVE_ITEM(MAX8998_REG_LDO6),
262 SAVE_ITEM(MAX8998_REG_LDO7),
263 SAVE_ITEM(MAX8998_REG_LDO8_LDO9),
264 SAVE_ITEM(MAX8998_REG_LDO10_LDO11),
265 SAVE_ITEM(MAX8998_REG_LDO12),
266 SAVE_ITEM(MAX8998_REG_LDO13),
267 SAVE_ITEM(MAX8998_REG_LDO14),
268 SAVE_ITEM(MAX8998_REG_LDO15),
269 SAVE_ITEM(MAX8998_REG_LDO16),
270 SAVE_ITEM(MAX8998_REG_LDO17),
271 SAVE_ITEM(MAX8998_REG_BKCHR),
272 SAVE_ITEM(MAX8998_REG_LBCNFG1),
273 SAVE_ITEM(MAX8998_REG_LBCNFG2),
274};
275/* Save registers before hibernation */
276static int max8998_freeze(struct device *dev)
277{
278 struct i2c_client *i2c = container_of(dev, struct i2c_client, dev);
279 int i;
280
281 for (i = 0; i < ARRAY_SIZE(max8998_dump); i++)
282 max8998_read_reg(i2c, max8998_dump[i].addr,
283 &max8998_dump[i].val);
284
285 return 0;
286}
287
288/* Restore registers after hibernation */
289static int max8998_restore(struct device *dev)
290{
291 struct i2c_client *i2c = container_of(dev, struct i2c_client, dev);
292 int i;
293
294 for (i = 0; i < ARRAY_SIZE(max8998_dump); i++)
295 max8998_write_reg(i2c, max8998_dump[i].addr,
296 max8998_dump[i].val);
297
298 return 0;
299}
300
301const struct dev_pm_ops max8998_pm = {
302 .suspend = max8998_suspend,
303 .resume = max8998_resume,
304 .freeze = max8998_freeze,
305 .restore = max8998_restore,
306};
307
181static struct i2c_driver max8998_i2c_driver = { 308static struct i2c_driver max8998_i2c_driver = {
182 .driver = { 309 .driver = {
183 .name = "max8998", 310 .name = "max8998",
184 .owner = THIS_MODULE, 311 .owner = THIS_MODULE,
312 .pm = &max8998_pm,
185 }, 313 },
186 .probe = max8998_i2c_probe, 314 .probe = max8998_i2c_probe,
187 .remove = max8998_i2c_remove, 315 .remove = max8998_i2c_remove,
diff --git a/drivers/mfd/mc13xxx-core.c b/drivers/mfd/mc13xxx-core.c
index a2ac2ed6d64c..b9fcaf0004da 100644
--- a/drivers/mfd/mc13xxx-core.c
+++ b/drivers/mfd/mc13xxx-core.c
@@ -749,7 +749,7 @@ static int mc13xxx_probe(struct spi_device *spi)
749 if (ret) { 749 if (ret) {
750err_mask: 750err_mask:
751err_revision: 751err_revision:
752 mutex_unlock(&mc13xxx->lock); 752 mc13xxx_unlock(mc13xxx);
753 dev_set_drvdata(&spi->dev, NULL); 753 dev_set_drvdata(&spi->dev, NULL);
754 kfree(mc13xxx); 754 kfree(mc13xxx);
755 return ret; 755 return ret;
diff --git a/drivers/mfd/mfd-core.c b/drivers/mfd/mfd-core.c
index ec99f681e773..d83ad0f141af 100644
--- a/drivers/mfd/mfd-core.c
+++ b/drivers/mfd/mfd-core.c
@@ -15,6 +15,7 @@
15#include <linux/platform_device.h> 15#include <linux/platform_device.h>
16#include <linux/acpi.h> 16#include <linux/acpi.h>
17#include <linux/mfd/core.h> 17#include <linux/mfd/core.h>
18#include <linux/pm_runtime.h>
18#include <linux/slab.h> 19#include <linux/slab.h>
19 20
20static int mfd_add_device(struct device *parent, int id, 21static int mfd_add_device(struct device *parent, int id,
@@ -82,6 +83,9 @@ static int mfd_add_device(struct device *parent, int id,
82 if (ret) 83 if (ret)
83 goto fail_res; 84 goto fail_res;
84 85
86 if (cell->pm_runtime_no_callbacks)
87 pm_runtime_no_callbacks(&pdev->dev);
88
85 kfree(res); 89 kfree(res);
86 90
87 return 0; 91 return 0;
diff --git a/drivers/mfd/sh_mobile_sdhi.c b/drivers/mfd/sh_mobile_sdhi.c
index f1714f93af9d..0a7df44a93c0 100644
--- a/drivers/mfd/sh_mobile_sdhi.c
+++ b/drivers/mfd/sh_mobile_sdhi.c
@@ -131,11 +131,17 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev)
131 */ 131 */
132 mmc_data->flags |= TMIO_MMC_BLKSZ_2BYTES; 132 mmc_data->flags |= TMIO_MMC_BLKSZ_2BYTES;
133 133
134 /*
135 * All SDHI blocks support SDIO IRQ signalling.
136 */
137 mmc_data->flags |= TMIO_MMC_SDIO_IRQ;
138
134 if (p && p->dma_slave_tx >= 0 && p->dma_slave_rx >= 0) { 139 if (p && p->dma_slave_tx >= 0 && p->dma_slave_rx >= 0) {
135 priv->param_tx.slave_id = p->dma_slave_tx; 140 priv->param_tx.slave_id = p->dma_slave_tx;
136 priv->param_rx.slave_id = p->dma_slave_rx; 141 priv->param_rx.slave_id = p->dma_slave_rx;
137 priv->dma_priv.chan_priv_tx = &priv->param_tx; 142 priv->dma_priv.chan_priv_tx = &priv->param_tx;
138 priv->dma_priv.chan_priv_rx = &priv->param_rx; 143 priv->dma_priv.chan_priv_rx = &priv->param_rx;
144 priv->dma_priv.alignment_shift = 1; /* 2-byte alignment */
139 mmc_data->dma = &priv->dma_priv; 145 mmc_data->dma = &priv->dma_priv;
140 } 146 }
141 147
diff --git a/drivers/mfd/sm501.c b/drivers/mfd/sm501.c
index bc9275c12133..5de3a760ea1e 100644
--- a/drivers/mfd/sm501.c
+++ b/drivers/mfd/sm501.c
@@ -26,7 +26,7 @@
26#include <linux/sm501-regs.h> 26#include <linux/sm501-regs.h>
27#include <linux/serial_8250.h> 27#include <linux/serial_8250.h>
28 28
29#include <asm/io.h> 29#include <linux/io.h>
30 30
31struct sm501_device { 31struct sm501_device {
32 struct list_head list; 32 struct list_head list;
@@ -745,11 +745,8 @@ static int sm501_register_device(struct sm501_devdata *sm,
745 int ret; 745 int ret;
746 746
747 for (ptr = 0; ptr < pdev->num_resources; ptr++) { 747 for (ptr = 0; ptr < pdev->num_resources; ptr++) {
748 printk(KERN_DEBUG "%s[%d] flags %08lx: %08llx..%08llx\n", 748 printk(KERN_DEBUG "%s[%d] %pR\n",
749 pdev->name, ptr, 749 pdev->name, ptr, &pdev->resource[ptr]);
750 pdev->resource[ptr].flags,
751 (unsigned long long)pdev->resource[ptr].start,
752 (unsigned long long)pdev->resource[ptr].end);
753 } 750 }
754 751
755 ret = platform_device_register(pdev); 752 ret = platform_device_register(pdev);
diff --git a/drivers/mfd/stmpe.c b/drivers/mfd/stmpe.c
index b11487f1e1cb..3e5732b58c49 100644
--- a/drivers/mfd/stmpe.c
+++ b/drivers/mfd/stmpe.c
@@ -699,16 +699,16 @@ static irqreturn_t stmpe_irq(int irq, void *data)
699 return IRQ_HANDLED; 699 return IRQ_HANDLED;
700} 700}
701 701
702static void stmpe_irq_lock(unsigned int irq) 702static void stmpe_irq_lock(struct irq_data *data)
703{ 703{
704 struct stmpe *stmpe = get_irq_chip_data(irq); 704 struct stmpe *stmpe = irq_data_get_irq_chip_data(data);
705 705
706 mutex_lock(&stmpe->irq_lock); 706 mutex_lock(&stmpe->irq_lock);
707} 707}
708 708
709static void stmpe_irq_sync_unlock(unsigned int irq) 709static void stmpe_irq_sync_unlock(struct irq_data *data)
710{ 710{
711 struct stmpe *stmpe = get_irq_chip_data(irq); 711 struct stmpe *stmpe = irq_data_get_irq_chip_data(data);
712 struct stmpe_variant_info *variant = stmpe->variant; 712 struct stmpe_variant_info *variant = stmpe->variant;
713 int num = DIV_ROUND_UP(variant->num_irqs, 8); 713 int num = DIV_ROUND_UP(variant->num_irqs, 8);
714 int i; 714 int i;
@@ -727,20 +727,20 @@ static void stmpe_irq_sync_unlock(unsigned int irq)
727 mutex_unlock(&stmpe->irq_lock); 727 mutex_unlock(&stmpe->irq_lock);
728} 728}
729 729
730static void stmpe_irq_mask(unsigned int irq) 730static void stmpe_irq_mask(struct irq_data *data)
731{ 731{
732 struct stmpe *stmpe = get_irq_chip_data(irq); 732 struct stmpe *stmpe = irq_data_get_irq_chip_data(data);
733 int offset = irq - stmpe->irq_base; 733 int offset = data->irq - stmpe->irq_base;
734 int regoffset = offset / 8; 734 int regoffset = offset / 8;
735 int mask = 1 << (offset % 8); 735 int mask = 1 << (offset % 8);
736 736
737 stmpe->ier[regoffset] &= ~mask; 737 stmpe->ier[regoffset] &= ~mask;
738} 738}
739 739
740static void stmpe_irq_unmask(unsigned int irq) 740static void stmpe_irq_unmask(struct irq_data *data)
741{ 741{
742 struct stmpe *stmpe = get_irq_chip_data(irq); 742 struct stmpe *stmpe = irq_data_get_irq_chip_data(data);
743 int offset = irq - stmpe->irq_base; 743 int offset = data->irq - stmpe->irq_base;
744 int regoffset = offset / 8; 744 int regoffset = offset / 8;
745 int mask = 1 << (offset % 8); 745 int mask = 1 << (offset % 8);
746 746
@@ -749,10 +749,10 @@ static void stmpe_irq_unmask(unsigned int irq)
749 749
750static struct irq_chip stmpe_irq_chip = { 750static struct irq_chip stmpe_irq_chip = {
751 .name = "stmpe", 751 .name = "stmpe",
752 .bus_lock = stmpe_irq_lock, 752 .irq_bus_lock = stmpe_irq_lock,
753 .bus_sync_unlock = stmpe_irq_sync_unlock, 753 .irq_bus_sync_unlock = stmpe_irq_sync_unlock,
754 .mask = stmpe_irq_mask, 754 .irq_mask = stmpe_irq_mask,
755 .unmask = stmpe_irq_unmask, 755 .irq_unmask = stmpe_irq_unmask,
756}; 756};
757 757
758static int __devinit stmpe_irq_init(struct stmpe *stmpe) 758static int __devinit stmpe_irq_init(struct stmpe *stmpe)
diff --git a/drivers/mfd/t7l66xb.c b/drivers/mfd/t7l66xb.c
index 006c121f3f0d..9caeb4ac6ea6 100644
--- a/drivers/mfd/t7l66xb.c
+++ b/drivers/mfd/t7l66xb.c
@@ -199,37 +199,37 @@ static void t7l66xb_irq(unsigned int irq, struct irq_desc *desc)
199 generic_handle_irq(irq_base + i); 199 generic_handle_irq(irq_base + i);
200} 200}
201 201
202static void t7l66xb_irq_mask(unsigned int irq) 202static void t7l66xb_irq_mask(struct irq_data *data)
203{ 203{
204 struct t7l66xb *t7l66xb = get_irq_chip_data(irq); 204 struct t7l66xb *t7l66xb = irq_data_get_irq_chip_data(data);
205 unsigned long flags; 205 unsigned long flags;
206 u8 imr; 206 u8 imr;
207 207
208 spin_lock_irqsave(&t7l66xb->lock, flags); 208 spin_lock_irqsave(&t7l66xb->lock, flags);
209 imr = tmio_ioread8(t7l66xb->scr + SCR_IMR); 209 imr = tmio_ioread8(t7l66xb->scr + SCR_IMR);
210 imr |= 1 << (irq - t7l66xb->irq_base); 210 imr |= 1 << (data->irq - t7l66xb->irq_base);
211 tmio_iowrite8(imr, t7l66xb->scr + SCR_IMR); 211 tmio_iowrite8(imr, t7l66xb->scr + SCR_IMR);
212 spin_unlock_irqrestore(&t7l66xb->lock, flags); 212 spin_unlock_irqrestore(&t7l66xb->lock, flags);
213} 213}
214 214
215static void t7l66xb_irq_unmask(unsigned int irq) 215static void t7l66xb_irq_unmask(struct irq_data *data)
216{ 216{
217 struct t7l66xb *t7l66xb = get_irq_chip_data(irq); 217 struct t7l66xb *t7l66xb = irq_data_get_irq_chip_data(data);
218 unsigned long flags; 218 unsigned long flags;
219 u8 imr; 219 u8 imr;
220 220
221 spin_lock_irqsave(&t7l66xb->lock, flags); 221 spin_lock_irqsave(&t7l66xb->lock, flags);
222 imr = tmio_ioread8(t7l66xb->scr + SCR_IMR); 222 imr = tmio_ioread8(t7l66xb->scr + SCR_IMR);
223 imr &= ~(1 << (irq - t7l66xb->irq_base)); 223 imr &= ~(1 << (data->irq - t7l66xb->irq_base));
224 tmio_iowrite8(imr, t7l66xb->scr + SCR_IMR); 224 tmio_iowrite8(imr, t7l66xb->scr + SCR_IMR);
225 spin_unlock_irqrestore(&t7l66xb->lock, flags); 225 spin_unlock_irqrestore(&t7l66xb->lock, flags);
226} 226}
227 227
228static struct irq_chip t7l66xb_chip = { 228static struct irq_chip t7l66xb_chip = {
229 .name = "t7l66xb", 229 .name = "t7l66xb",
230 .ack = t7l66xb_irq_mask, 230 .irq_ack = t7l66xb_irq_mask,
231 .mask = t7l66xb_irq_mask, 231 .irq_mask = t7l66xb_irq_mask,
232 .unmask = t7l66xb_irq_unmask, 232 .irq_unmask = t7l66xb_irq_unmask,
233}; 233};
234 234
235/*--------------------------------------------------------------------------*/ 235/*--------------------------------------------------------------------------*/
diff --git a/drivers/mfd/tc6393xb.c b/drivers/mfd/tc6393xb.c
index 1ea80d8ad915..9a238633a54d 100644
--- a/drivers/mfd/tc6393xb.c
+++ b/drivers/mfd/tc6393xb.c
@@ -527,41 +527,41 @@ tc6393xb_irq(unsigned int irq, struct irq_desc *desc)
527 } 527 }
528} 528}
529 529
530static void tc6393xb_irq_ack(unsigned int irq) 530static void tc6393xb_irq_ack(struct irq_data *data)
531{ 531{
532} 532}
533 533
534static void tc6393xb_irq_mask(unsigned int irq) 534static void tc6393xb_irq_mask(struct irq_data *data)
535{ 535{
536 struct tc6393xb *tc6393xb = get_irq_chip_data(irq); 536 struct tc6393xb *tc6393xb = irq_data_get_irq_chip_data(data);
537 unsigned long flags; 537 unsigned long flags;
538 u8 imr; 538 u8 imr;
539 539
540 spin_lock_irqsave(&tc6393xb->lock, flags); 540 spin_lock_irqsave(&tc6393xb->lock, flags);
541 imr = tmio_ioread8(tc6393xb->scr + SCR_IMR); 541 imr = tmio_ioread8(tc6393xb->scr + SCR_IMR);
542 imr |= 1 << (irq - tc6393xb->irq_base); 542 imr |= 1 << (data->irq - tc6393xb->irq_base);
543 tmio_iowrite8(imr, tc6393xb->scr + SCR_IMR); 543 tmio_iowrite8(imr, tc6393xb->scr + SCR_IMR);
544 spin_unlock_irqrestore(&tc6393xb->lock, flags); 544 spin_unlock_irqrestore(&tc6393xb->lock, flags);
545} 545}
546 546
547static void tc6393xb_irq_unmask(unsigned int irq) 547static void tc6393xb_irq_unmask(struct irq_data *data)
548{ 548{
549 struct tc6393xb *tc6393xb = get_irq_chip_data(irq); 549 struct tc6393xb *tc6393xb = irq_data_get_irq_chip_data(data);
550 unsigned long flags; 550 unsigned long flags;
551 u8 imr; 551 u8 imr;
552 552
553 spin_lock_irqsave(&tc6393xb->lock, flags); 553 spin_lock_irqsave(&tc6393xb->lock, flags);
554 imr = tmio_ioread8(tc6393xb->scr + SCR_IMR); 554 imr = tmio_ioread8(tc6393xb->scr + SCR_IMR);
555 imr &= ~(1 << (irq - tc6393xb->irq_base)); 555 imr &= ~(1 << (data->irq - tc6393xb->irq_base));
556 tmio_iowrite8(imr, tc6393xb->scr + SCR_IMR); 556 tmio_iowrite8(imr, tc6393xb->scr + SCR_IMR);
557 spin_unlock_irqrestore(&tc6393xb->lock, flags); 557 spin_unlock_irqrestore(&tc6393xb->lock, flags);
558} 558}
559 559
560static struct irq_chip tc6393xb_chip = { 560static struct irq_chip tc6393xb_chip = {
561 .name = "tc6393xb", 561 .name = "tc6393xb",
562 .ack = tc6393xb_irq_ack, 562 .irq_ack = tc6393xb_irq_ack,
563 .mask = tc6393xb_irq_mask, 563 .irq_mask = tc6393xb_irq_mask,
564 .unmask = tc6393xb_irq_unmask, 564 .irq_unmask = tc6393xb_irq_unmask,
565}; 565};
566 566
567static void tc6393xb_attach_irq(struct platform_device *dev) 567static void tc6393xb_attach_irq(struct platform_device *dev)
diff --git a/drivers/mfd/tps65010.c b/drivers/mfd/tps65010.c
index 90187fe33e04..93d5fdf020c7 100644
--- a/drivers/mfd/tps65010.c
+++ b/drivers/mfd/tps65010.c
@@ -34,7 +34,7 @@
34 34
35#include <linux/i2c/tps65010.h> 35#include <linux/i2c/tps65010.h>
36 36
37#include <asm/gpio.h> 37#include <linux/gpio.h>
38 38
39 39
40/*-------------------------------------------------------------------------*/ 40/*-------------------------------------------------------------------------*/
diff --git a/drivers/mfd/tps6586x.c b/drivers/mfd/tps6586x.c
index b4931ab34929..627cf577b16d 100644
--- a/drivers/mfd/tps6586x.c
+++ b/drivers/mfd/tps6586x.c
@@ -46,8 +46,6 @@
46 46
47/* device id */ 47/* device id */
48#define TPS6586X_VERSIONCRC 0xcd 48#define TPS6586X_VERSIONCRC 0xcd
49#define TPS658621A_VERSIONCRC 0x15
50#define TPS658621C_VERSIONCRC 0x2c
51 49
52struct tps6586x_irq_data { 50struct tps6586x_irq_data {
53 u8 mask_reg; 51 u8 mask_reg;
@@ -325,37 +323,37 @@ static int tps6586x_remove_subdevs(struct tps6586x *tps6586x)
325 return device_for_each_child(tps6586x->dev, NULL, __remove_subdev); 323 return device_for_each_child(tps6586x->dev, NULL, __remove_subdev);
326} 324}
327 325
328static void tps6586x_irq_lock(unsigned int irq) 326static void tps6586x_irq_lock(struct irq_data *data)
329{ 327{
330 struct tps6586x *tps6586x = get_irq_chip_data(irq); 328 struct tps6586x *tps6586x = irq_data_get_irq_chip_data(data);
331 329
332 mutex_lock(&tps6586x->irq_lock); 330 mutex_lock(&tps6586x->irq_lock);
333} 331}
334 332
335static void tps6586x_irq_enable(unsigned int irq) 333static void tps6586x_irq_enable(struct irq_data *irq_data)
336{ 334{
337 struct tps6586x *tps6586x = get_irq_chip_data(irq); 335 struct tps6586x *tps6586x = irq_data_get_irq_chip_data(irq_data);
338 unsigned int __irq = irq - tps6586x->irq_base; 336 unsigned int __irq = irq_data->irq - tps6586x->irq_base;
339 const struct tps6586x_irq_data *data = &tps6586x_irqs[__irq]; 337 const struct tps6586x_irq_data *data = &tps6586x_irqs[__irq];
340 338
341 tps6586x->mask_reg[data->mask_reg] &= ~data->mask_mask; 339 tps6586x->mask_reg[data->mask_reg] &= ~data->mask_mask;
342 tps6586x->irq_en |= (1 << __irq); 340 tps6586x->irq_en |= (1 << __irq);
343} 341}
344 342
345static void tps6586x_irq_disable(unsigned int irq) 343static void tps6586x_irq_disable(struct irq_data *irq_data)
346{ 344{
347 struct tps6586x *tps6586x = get_irq_chip_data(irq); 345 struct tps6586x *tps6586x = irq_data_get_irq_chip_data(irq_data);
348 346
349 unsigned int __irq = irq - tps6586x->irq_base; 347 unsigned int __irq = irq_data->irq - tps6586x->irq_base;
350 const struct tps6586x_irq_data *data = &tps6586x_irqs[__irq]; 348 const struct tps6586x_irq_data *data = &tps6586x_irqs[__irq];
351 349
352 tps6586x->mask_reg[data->mask_reg] |= data->mask_mask; 350 tps6586x->mask_reg[data->mask_reg] |= data->mask_mask;
353 tps6586x->irq_en &= ~(1 << __irq); 351 tps6586x->irq_en &= ~(1 << __irq);
354} 352}
355 353
356static void tps6586x_irq_sync_unlock(unsigned int irq) 354static void tps6586x_irq_sync_unlock(struct irq_data *data)
357{ 355{
358 struct tps6586x *tps6586x = get_irq_chip_data(irq); 356 struct tps6586x *tps6586x = irq_data_get_irq_chip_data(data);
359 int i; 357 int i;
360 358
361 for (i = 0; i < ARRAY_SIZE(tps6586x->mask_reg); i++) { 359 for (i = 0; i < ARRAY_SIZE(tps6586x->mask_reg); i++) {
@@ -421,10 +419,10 @@ static int __devinit tps6586x_irq_init(struct tps6586x *tps6586x, int irq,
421 tps6586x->irq_base = irq_base; 419 tps6586x->irq_base = irq_base;
422 420
423 tps6586x->irq_chip.name = "tps6586x"; 421 tps6586x->irq_chip.name = "tps6586x";
424 tps6586x->irq_chip.enable = tps6586x_irq_enable; 422 tps6586x->irq_chip.irq_enable = tps6586x_irq_enable;
425 tps6586x->irq_chip.disable = tps6586x_irq_disable; 423 tps6586x->irq_chip.irq_disable = tps6586x_irq_disable;
426 tps6586x->irq_chip.bus_lock = tps6586x_irq_lock; 424 tps6586x->irq_chip.irq_bus_lock = tps6586x_irq_lock;
427 tps6586x->irq_chip.bus_sync_unlock = tps6586x_irq_sync_unlock; 425 tps6586x->irq_chip.irq_bus_sync_unlock = tps6586x_irq_sync_unlock;
428 426
429 for (i = 0; i < ARRAY_SIZE(tps6586x_irqs); i++) { 427 for (i = 0; i < ARRAY_SIZE(tps6586x_irqs); i++) {
430 int __irq = i + tps6586x->irq_base; 428 int __irq = i + tps6586x->irq_base;
@@ -498,11 +496,7 @@ static int __devinit tps6586x_i2c_probe(struct i2c_client *client,
498 return -EIO; 496 return -EIO;
499 } 497 }
500 498
501 if ((ret != TPS658621A_VERSIONCRC) && 499 dev_info(&client->dev, "VERSIONCRC is %02x\n", ret);
502 (ret != TPS658621C_VERSIONCRC)) {
503 dev_err(&client->dev, "Unsupported chip ID: %x\n", ret);
504 return -ENODEV;
505 }
506 500
507 tps6586x = kzalloc(sizeof(struct tps6586x), GFP_KERNEL); 501 tps6586x = kzalloc(sizeof(struct tps6586x), GFP_KERNEL);
508 if (tps6586x == NULL) 502 if (tps6586x == NULL)
diff --git a/drivers/mfd/twl-core.c b/drivers/mfd/twl-core.c
index 12abd5b924b3..a35fa7dcbf53 100644
--- a/drivers/mfd/twl-core.c
+++ b/drivers/mfd/twl-core.c
@@ -1003,7 +1003,7 @@ static int twl_remove(struct i2c_client *client)
1003} 1003}
1004 1004
1005/* NOTE: this driver only handles a single twl4030/tps659x0 chip */ 1005/* NOTE: this driver only handles a single twl4030/tps659x0 chip */
1006static int __init 1006static int __devinit
1007twl_probe(struct i2c_client *client, const struct i2c_device_id *id) 1007twl_probe(struct i2c_client *client, const struct i2c_device_id *id)
1008{ 1008{
1009 int status; 1009 int status;
diff --git a/drivers/mfd/twl4030-irq.c b/drivers/mfd/twl4030-irq.c
index 5d3a1478004b..63a30e88908f 100644
--- a/drivers/mfd/twl4030-irq.c
+++ b/drivers/mfd/twl4030-irq.c
@@ -599,38 +599,38 @@ static void twl4030_sih_do_edge(struct work_struct *work)
599 * completion, potentially including some re-ordering, of these requests. 599 * completion, potentially including some re-ordering, of these requests.
600 */ 600 */
601 601
602static void twl4030_sih_mask(unsigned irq) 602static void twl4030_sih_mask(struct irq_data *data)
603{ 603{
604 struct sih_agent *sih = get_irq_chip_data(irq); 604 struct sih_agent *sih = irq_data_get_irq_chip_data(data);
605 unsigned long flags; 605 unsigned long flags;
606 606
607 spin_lock_irqsave(&sih_agent_lock, flags); 607 spin_lock_irqsave(&sih_agent_lock, flags);
608 sih->imr |= BIT(irq - sih->irq_base); 608 sih->imr |= BIT(data->irq - sih->irq_base);
609 sih->imr_change_pending = true; 609 sih->imr_change_pending = true;
610 queue_work(wq, &sih->mask_work); 610 queue_work(wq, &sih->mask_work);
611 spin_unlock_irqrestore(&sih_agent_lock, flags); 611 spin_unlock_irqrestore(&sih_agent_lock, flags);
612} 612}
613 613
614static void twl4030_sih_unmask(unsigned irq) 614static void twl4030_sih_unmask(struct irq_data *data)
615{ 615{
616 struct sih_agent *sih = get_irq_chip_data(irq); 616 struct sih_agent *sih = irq_data_get_irq_chip_data(data);
617 unsigned long flags; 617 unsigned long flags;
618 618
619 spin_lock_irqsave(&sih_agent_lock, flags); 619 spin_lock_irqsave(&sih_agent_lock, flags);
620 sih->imr &= ~BIT(irq - sih->irq_base); 620 sih->imr &= ~BIT(data->irq - sih->irq_base);
621 sih->imr_change_pending = true; 621 sih->imr_change_pending = true;
622 queue_work(wq, &sih->mask_work); 622 queue_work(wq, &sih->mask_work);
623 spin_unlock_irqrestore(&sih_agent_lock, flags); 623 spin_unlock_irqrestore(&sih_agent_lock, flags);
624} 624}
625 625
626static int twl4030_sih_set_type(unsigned irq, unsigned trigger) 626static int twl4030_sih_set_type(struct irq_data *data, unsigned trigger)
627{ 627{
628 struct sih_agent *sih = get_irq_chip_data(irq); 628 struct sih_agent *sih = irq_data_get_irq_chip_data(data);
629 struct irq_desc *desc = irq_to_desc(irq); 629 struct irq_desc *desc = irq_to_desc(data->irq);
630 unsigned long flags; 630 unsigned long flags;
631 631
632 if (!desc) { 632 if (!desc) {
633 pr_err("twl4030: Invalid IRQ: %d\n", irq); 633 pr_err("twl4030: Invalid IRQ: %d\n", data->irq);
634 return -EINVAL; 634 return -EINVAL;
635 } 635 }
636 636
@@ -641,7 +641,7 @@ static int twl4030_sih_set_type(unsigned irq, unsigned trigger)
641 if ((desc->status & IRQ_TYPE_SENSE_MASK) != trigger) { 641 if ((desc->status & IRQ_TYPE_SENSE_MASK) != trigger) {
642 desc->status &= ~IRQ_TYPE_SENSE_MASK; 642 desc->status &= ~IRQ_TYPE_SENSE_MASK;
643 desc->status |= trigger; 643 desc->status |= trigger;
644 sih->edge_change |= BIT(irq - sih->irq_base); 644 sih->edge_change |= BIT(data->irq - sih->irq_base);
645 queue_work(wq, &sih->edge_work); 645 queue_work(wq, &sih->edge_work);
646 } 646 }
647 spin_unlock_irqrestore(&sih_agent_lock, flags); 647 spin_unlock_irqrestore(&sih_agent_lock, flags);
@@ -650,9 +650,9 @@ static int twl4030_sih_set_type(unsigned irq, unsigned trigger)
650 650
651static struct irq_chip twl4030_sih_irq_chip = { 651static struct irq_chip twl4030_sih_irq_chip = {
652 .name = "twl4030", 652 .name = "twl4030",
653 .mask = twl4030_sih_mask, 653 .irq_mask = twl4030_sih_mask,
654 .unmask = twl4030_sih_unmask, 654 .irq_unmask = twl4030_sih_unmask,
655 .set_type = twl4030_sih_set_type, 655 .irq_set_type = twl4030_sih_set_type,
656}; 656};
657 657
658/*----------------------------------------------------------------------*/ 658/*----------------------------------------------------------------------*/
diff --git a/drivers/mfd/twl6030-irq.c b/drivers/mfd/twl6030-irq.c
index 06c8955907e9..4082ed73613f 100644
--- a/drivers/mfd/twl6030-irq.c
+++ b/drivers/mfd/twl6030-irq.c
@@ -332,7 +332,7 @@ int twl6030_init_irq(int irq_num, unsigned irq_base, unsigned irq_end)
332 */ 332 */
333 twl6030_irq_chip = dummy_irq_chip; 333 twl6030_irq_chip = dummy_irq_chip;
334 twl6030_irq_chip.name = "twl6030"; 334 twl6030_irq_chip.name = "twl6030";
335 twl6030_irq_chip.set_type = NULL; 335 twl6030_irq_chip.irq_set_type = NULL;
336 336
337 for (i = irq_base; i < irq_end; i++) { 337 for (i = irq_base; i < irq_end; i++) {
338 set_irq_chip_and_handler(i, &twl6030_irq_chip, 338 set_irq_chip_and_handler(i, &twl6030_irq_chip,
diff --git a/drivers/mfd/vx855.c b/drivers/mfd/vx855.c
index ebb059765edd..348052aa5dbf 100644
--- a/drivers/mfd/vx855.c
+++ b/drivers/mfd/vx855.c
@@ -112,7 +112,7 @@ out:
112 return ret; 112 return ret;
113} 113}
114 114
115static void vx855_remove(struct pci_dev *pdev) 115static void __devexit vx855_remove(struct pci_dev *pdev)
116{ 116{
117 mfd_remove_devices(&pdev->dev); 117 mfd_remove_devices(&pdev->dev);
118 pci_disable_device(pdev); 118 pci_disable_device(pdev);
diff --git a/drivers/mfd/wm831x-core.c b/drivers/mfd/wm831x-core.c
index 76cadcf3b1fe..3fe9a58fe6c7 100644
--- a/drivers/mfd/wm831x-core.c
+++ b/drivers/mfd/wm831x-core.c
@@ -1541,6 +1541,12 @@ int wm831x_device_init(struct wm831x *wm831x, unsigned long id, int irq)
1541 dev_info(wm831x->dev, "WM8325 revision %c\n", 'A' + rev); 1541 dev_info(wm831x->dev, "WM8325 revision %c\n", 'A' + rev);
1542 break; 1542 break;
1543 1543
1544 case WM8326:
1545 parent = WM8326;
1546 wm831x->num_gpio = 12;
1547 dev_info(wm831x->dev, "WM8326 revision %c\n", 'A' + rev);
1548 break;
1549
1544 default: 1550 default:
1545 dev_err(wm831x->dev, "Unknown WM831x device %04x\n", ret); 1551 dev_err(wm831x->dev, "Unknown WM831x device %04x\n", ret);
1546 ret = -EINVAL; 1552 ret = -EINVAL;
@@ -1610,18 +1616,9 @@ int wm831x_device_init(struct wm831x *wm831x, unsigned long id, int irq)
1610 break; 1616 break;
1611 1617
1612 case WM8320: 1618 case WM8320:
1613 ret = mfd_add_devices(wm831x->dev, -1,
1614 wm8320_devs, ARRAY_SIZE(wm8320_devs),
1615 NULL, 0);
1616 break;
1617
1618 case WM8321: 1619 case WM8321:
1619 ret = mfd_add_devices(wm831x->dev, -1,
1620 wm8320_devs, ARRAY_SIZE(wm8320_devs),
1621 NULL, 0);
1622 break;
1623
1624 case WM8325: 1620 case WM8325:
1621 case WM8326:
1625 ret = mfd_add_devices(wm831x->dev, -1, 1622 ret = mfd_add_devices(wm831x->dev, -1,
1626 wm8320_devs, ARRAY_SIZE(wm8320_devs), 1623 wm8320_devs, ARRAY_SIZE(wm8320_devs),
1627 NULL, wm831x->irq_base); 1624 NULL, wm831x->irq_base);
diff --git a/drivers/mfd/wm831x-i2c.c b/drivers/mfd/wm831x-i2c.c
index 156b19859e81..3853fa8e7cc2 100644
--- a/drivers/mfd/wm831x-i2c.c
+++ b/drivers/mfd/wm831x-i2c.c
@@ -94,9 +94,9 @@ static int wm831x_i2c_remove(struct i2c_client *i2c)
94 return 0; 94 return 0;
95} 95}
96 96
97static int wm831x_i2c_suspend(struct i2c_client *i2c, pm_message_t mesg) 97static int wm831x_i2c_suspend(struct device *dev)
98{ 98{
99 struct wm831x *wm831x = i2c_get_clientdata(i2c); 99 struct wm831x *wm831x = dev_get_drvdata(dev);
100 100
101 return wm831x_device_suspend(wm831x); 101 return wm831x_device_suspend(wm831x);
102} 102}
@@ -108,19 +108,23 @@ static const struct i2c_device_id wm831x_i2c_id[] = {
108 { "wm8320", WM8320 }, 108 { "wm8320", WM8320 },
109 { "wm8321", WM8321 }, 109 { "wm8321", WM8321 },
110 { "wm8325", WM8325 }, 110 { "wm8325", WM8325 },
111 { "wm8326", WM8326 },
111 { } 112 { }
112}; 113};
113MODULE_DEVICE_TABLE(i2c, wm831x_i2c_id); 114MODULE_DEVICE_TABLE(i2c, wm831x_i2c_id);
114 115
116static const struct dev_pm_ops wm831x_pm_ops = {
117 .suspend = wm831x_i2c_suspend,
118};
115 119
116static struct i2c_driver wm831x_i2c_driver = { 120static struct i2c_driver wm831x_i2c_driver = {
117 .driver = { 121 .driver = {
118 .name = "wm831x", 122 .name = "wm831x",
119 .owner = THIS_MODULE, 123 .owner = THIS_MODULE,
124 .pm = &wm831x_pm_ops,
120 }, 125 },
121 .probe = wm831x_i2c_probe, 126 .probe = wm831x_i2c_probe,
122 .remove = wm831x_i2c_remove, 127 .remove = wm831x_i2c_remove,
123 .suspend = wm831x_i2c_suspend,
124 .id_table = wm831x_i2c_id, 128 .id_table = wm831x_i2c_id,
125}; 129};
126 130
diff --git a/drivers/mfd/wm831x-irq.c b/drivers/mfd/wm831x-irq.c
index 294183b6260b..f7192d438aab 100644
--- a/drivers/mfd/wm831x-irq.c
+++ b/drivers/mfd/wm831x-irq.c
@@ -345,16 +345,16 @@ static inline struct wm831x_irq_data *irq_to_wm831x_irq(struct wm831x *wm831x,
345 return &wm831x_irqs[irq - wm831x->irq_base]; 345 return &wm831x_irqs[irq - wm831x->irq_base];
346} 346}
347 347
348static void wm831x_irq_lock(unsigned int irq) 348static void wm831x_irq_lock(struct irq_data *data)
349{ 349{
350 struct wm831x *wm831x = get_irq_chip_data(irq); 350 struct wm831x *wm831x = irq_data_get_irq_chip_data(data);
351 351
352 mutex_lock(&wm831x->irq_lock); 352 mutex_lock(&wm831x->irq_lock);
353} 353}
354 354
355static void wm831x_irq_sync_unlock(unsigned int irq) 355static void wm831x_irq_sync_unlock(struct irq_data *data)
356{ 356{
357 struct wm831x *wm831x = get_irq_chip_data(irq); 357 struct wm831x *wm831x = irq_data_get_irq_chip_data(data);
358 int i; 358 int i;
359 359
360 for (i = 0; i < ARRAY_SIZE(wm831x->irq_masks_cur); i++) { 360 for (i = 0; i < ARRAY_SIZE(wm831x->irq_masks_cur); i++) {
@@ -371,28 +371,30 @@ static void wm831x_irq_sync_unlock(unsigned int irq)
371 mutex_unlock(&wm831x->irq_lock); 371 mutex_unlock(&wm831x->irq_lock);
372} 372}
373 373
374static void wm831x_irq_unmask(unsigned int irq) 374static void wm831x_irq_unmask(struct irq_data *data)
375{ 375{
376 struct wm831x *wm831x = get_irq_chip_data(irq); 376 struct wm831x *wm831x = irq_data_get_irq_chip_data(data);
377 struct wm831x_irq_data *irq_data = irq_to_wm831x_irq(wm831x, irq); 377 struct wm831x_irq_data *irq_data = irq_to_wm831x_irq(wm831x,
378 data->irq);
378 379
379 wm831x->irq_masks_cur[irq_data->reg - 1] &= ~irq_data->mask; 380 wm831x->irq_masks_cur[irq_data->reg - 1] &= ~irq_data->mask;
380} 381}
381 382
382static void wm831x_irq_mask(unsigned int irq) 383static void wm831x_irq_mask(struct irq_data *data)
383{ 384{
384 struct wm831x *wm831x = get_irq_chip_data(irq); 385 struct wm831x *wm831x = irq_data_get_irq_chip_data(data);
385 struct wm831x_irq_data *irq_data = irq_to_wm831x_irq(wm831x, irq); 386 struct wm831x_irq_data *irq_data = irq_to_wm831x_irq(wm831x,
387 data->irq);
386 388
387 wm831x->irq_masks_cur[irq_data->reg - 1] |= irq_data->mask; 389 wm831x->irq_masks_cur[irq_data->reg - 1] |= irq_data->mask;
388} 390}
389 391
390static int wm831x_irq_set_type(unsigned int irq, unsigned int type) 392static int wm831x_irq_set_type(struct irq_data *data, unsigned int type)
391{ 393{
392 struct wm831x *wm831x = get_irq_chip_data(irq); 394 struct wm831x *wm831x = irq_data_get_irq_chip_data(data);
393 int val; 395 int val, irq;
394 396
395 irq = irq - wm831x->irq_base; 397 irq = data->irq - wm831x->irq_base;
396 398
397 if (irq < WM831X_IRQ_GPIO_1 || irq > WM831X_IRQ_GPIO_11) { 399 if (irq < WM831X_IRQ_GPIO_1 || irq > WM831X_IRQ_GPIO_11) {
398 /* Ignore internal-only IRQs */ 400 /* Ignore internal-only IRQs */
@@ -421,12 +423,12 @@ static int wm831x_irq_set_type(unsigned int irq, unsigned int type)
421} 423}
422 424
423static struct irq_chip wm831x_irq_chip = { 425static struct irq_chip wm831x_irq_chip = {
424 .name = "wm831x", 426 .name = "wm831x",
425 .bus_lock = wm831x_irq_lock, 427 .irq_bus_lock = wm831x_irq_lock,
426 .bus_sync_unlock = wm831x_irq_sync_unlock, 428 .irq_bus_sync_unlock = wm831x_irq_sync_unlock,
427 .mask = wm831x_irq_mask, 429 .irq_mask = wm831x_irq_mask,
428 .unmask = wm831x_irq_unmask, 430 .irq_unmask = wm831x_irq_unmask,
429 .set_type = wm831x_irq_set_type, 431 .irq_set_type = wm831x_irq_set_type,
430}; 432};
431 433
432/* The processing of the primary interrupt occurs in a thread so that 434/* The processing of the primary interrupt occurs in a thread so that
@@ -515,6 +517,17 @@ int wm831x_irq_init(struct wm831x *wm831x, int irq)
515 return 0; 517 return 0;
516 } 518 }
517 519
520 /* Try to flag /IRQ as a wake source; there are a number of
521 * unconditional wake sources in the PMIC so this isn't
522 * conditional but we don't actually care *too* much if it
523 * fails.
524 */
525 ret = enable_irq_wake(irq);
526 if (ret != 0) {
527 dev_warn(wm831x->dev, "Can't enable IRQ as wake source: %d\n",
528 ret);
529 }
530
518 wm831x->irq = irq; 531 wm831x->irq = irq;
519 wm831x->irq_base = pdata->irq_base; 532 wm831x->irq_base = pdata->irq_base;
520 533
diff --git a/drivers/mfd/wm831x-spi.c b/drivers/mfd/wm831x-spi.c
index 2789b151b0f9..0a8f772be88c 100644
--- a/drivers/mfd/wm831x-spi.c
+++ b/drivers/mfd/wm831x-spi.c
@@ -81,6 +81,8 @@ static int __devinit wm831x_spi_probe(struct spi_device *spi)
81 type = WM8321; 81 type = WM8321;
82 else if (strcmp(spi->modalias, "wm8325") == 0) 82 else if (strcmp(spi->modalias, "wm8325") == 0)
83 type = WM8325; 83 type = WM8325;
84 else if (strcmp(spi->modalias, "wm8326") == 0)
85 type = WM8326;
84 else { 86 else {
85 dev_err(&spi->dev, "Unknown device type\n"); 87 dev_err(&spi->dev, "Unknown device type\n");
86 return -EINVAL; 88 return -EINVAL;
@@ -184,6 +186,17 @@ static struct spi_driver wm8325_spi_driver = {
184 .suspend = wm831x_spi_suspend, 186 .suspend = wm831x_spi_suspend,
185}; 187};
186 188
189static struct spi_driver wm8326_spi_driver = {
190 .driver = {
191 .name = "wm8326",
192 .bus = &spi_bus_type,
193 .owner = THIS_MODULE,
194 },
195 .probe = wm831x_spi_probe,
196 .remove = __devexit_p(wm831x_spi_remove),
197 .suspend = wm831x_spi_suspend,
198};
199
187static int __init wm831x_spi_init(void) 200static int __init wm831x_spi_init(void)
188{ 201{
189 int ret; 202 int ret;
@@ -212,12 +225,17 @@ static int __init wm831x_spi_init(void)
212 if (ret != 0) 225 if (ret != 0)
213 pr_err("Failed to register WM8325 SPI driver: %d\n", ret); 226 pr_err("Failed to register WM8325 SPI driver: %d\n", ret);
214 227
228 ret = spi_register_driver(&wm8326_spi_driver);
229 if (ret != 0)
230 pr_err("Failed to register WM8326 SPI driver: %d\n", ret);
231
215 return 0; 232 return 0;
216} 233}
217subsys_initcall(wm831x_spi_init); 234subsys_initcall(wm831x_spi_init);
218 235
219static void __exit wm831x_spi_exit(void) 236static void __exit wm831x_spi_exit(void)
220{ 237{
238 spi_unregister_driver(&wm8326_spi_driver);
221 spi_unregister_driver(&wm8325_spi_driver); 239 spi_unregister_driver(&wm8325_spi_driver);
222 spi_unregister_driver(&wm8321_spi_driver); 240 spi_unregister_driver(&wm8321_spi_driver);
223 spi_unregister_driver(&wm8320_spi_driver); 241 spi_unregister_driver(&wm8320_spi_driver);
diff --git a/drivers/mfd/wm8350-irq.c b/drivers/mfd/wm8350-irq.c
index f56c9adf9493..5839966ebd85 100644
--- a/drivers/mfd/wm8350-irq.c
+++ b/drivers/mfd/wm8350-irq.c
@@ -417,16 +417,16 @@ static irqreturn_t wm8350_irq(int irq, void *irq_data)
417 return IRQ_HANDLED; 417 return IRQ_HANDLED;
418} 418}
419 419
420static void wm8350_irq_lock(unsigned int irq) 420static void wm8350_irq_lock(struct irq_data *data)
421{ 421{
422 struct wm8350 *wm8350 = get_irq_chip_data(irq); 422 struct wm8350 *wm8350 = irq_data_get_irq_chip_data(data);
423 423
424 mutex_lock(&wm8350->irq_lock); 424 mutex_lock(&wm8350->irq_lock);
425} 425}
426 426
427static void wm8350_irq_sync_unlock(unsigned int irq) 427static void wm8350_irq_sync_unlock(struct irq_data *data)
428{ 428{
429 struct wm8350 *wm8350 = get_irq_chip_data(irq); 429 struct wm8350 *wm8350 = irq_data_get_irq_chip_data(data);
430 int i; 430 int i;
431 431
432 for (i = 0; i < ARRAY_SIZE(wm8350->irq_masks); i++) { 432 for (i = 0; i < ARRAY_SIZE(wm8350->irq_masks); i++) {
@@ -442,28 +442,30 @@ static void wm8350_irq_sync_unlock(unsigned int irq)
442 mutex_unlock(&wm8350->irq_lock); 442 mutex_unlock(&wm8350->irq_lock);
443} 443}
444 444
445static void wm8350_irq_enable(unsigned int irq) 445static void wm8350_irq_enable(struct irq_data *data)
446{ 446{
447 struct wm8350 *wm8350 = get_irq_chip_data(irq); 447 struct wm8350 *wm8350 = irq_data_get_irq_chip_data(data);
448 struct wm8350_irq_data *irq_data = irq_to_wm8350_irq(wm8350, irq); 448 struct wm8350_irq_data *irq_data = irq_to_wm8350_irq(wm8350,
449 data->irq);
449 450
450 wm8350->irq_masks[irq_data->reg] &= ~irq_data->mask; 451 wm8350->irq_masks[irq_data->reg] &= ~irq_data->mask;
451} 452}
452 453
453static void wm8350_irq_disable(unsigned int irq) 454static void wm8350_irq_disable(struct irq_data *data)
454{ 455{
455 struct wm8350 *wm8350 = get_irq_chip_data(irq); 456 struct wm8350 *wm8350 = irq_data_get_irq_chip_data(data);
456 struct wm8350_irq_data *irq_data = irq_to_wm8350_irq(wm8350, irq); 457 struct wm8350_irq_data *irq_data = irq_to_wm8350_irq(wm8350,
458 data->irq);
457 459
458 wm8350->irq_masks[irq_data->reg] |= irq_data->mask; 460 wm8350->irq_masks[irq_data->reg] |= irq_data->mask;
459} 461}
460 462
461static struct irq_chip wm8350_irq_chip = { 463static struct irq_chip wm8350_irq_chip = {
462 .name = "wm8350", 464 .name = "wm8350",
463 .bus_lock = wm8350_irq_lock, 465 .irq_bus_lock = wm8350_irq_lock,
464 .bus_sync_unlock = wm8350_irq_sync_unlock, 466 .irq_bus_sync_unlock = wm8350_irq_sync_unlock,
465 .disable = wm8350_irq_disable, 467 .irq_disable = wm8350_irq_disable,
466 .enable = wm8350_irq_enable, 468 .irq_enable = wm8350_irq_enable,
467}; 469};
468 470
469int wm8350_irq_init(struct wm8350 *wm8350, int irq, 471int wm8350_irq_init(struct wm8350 *wm8350, int irq,
diff --git a/drivers/mfd/wm8994-core.c b/drivers/mfd/wm8994-core.c
index b3b2aaf89dbe..41233c7fa581 100644
--- a/drivers/mfd/wm8994-core.c
+++ b/drivers/mfd/wm8994-core.c
@@ -18,6 +18,7 @@
18#include <linux/i2c.h> 18#include <linux/i2c.h>
19#include <linux/delay.h> 19#include <linux/delay.h>
20#include <linux/mfd/core.h> 20#include <linux/mfd/core.h>
21#include <linux/pm_runtime.h>
21#include <linux/regulator/consumer.h> 22#include <linux/regulator/consumer.h>
22#include <linux/regulator/machine.h> 23#include <linux/regulator/machine.h>
23 24
@@ -169,8 +170,16 @@ out:
169EXPORT_SYMBOL_GPL(wm8994_set_bits); 170EXPORT_SYMBOL_GPL(wm8994_set_bits);
170 171
171static struct mfd_cell wm8994_regulator_devs[] = { 172static struct mfd_cell wm8994_regulator_devs[] = {
172 { .name = "wm8994-ldo", .id = 1 }, 173 {
173 { .name = "wm8994-ldo", .id = 2 }, 174 .name = "wm8994-ldo",
175 .id = 1,
176 .pm_runtime_no_callbacks = true,
177 },
178 {
179 .name = "wm8994-ldo",
180 .id = 2,
181 .pm_runtime_no_callbacks = true,
182 },
174}; 183};
175 184
176static struct resource wm8994_codec_resources[] = { 185static struct resource wm8994_codec_resources[] = {
@@ -200,6 +209,7 @@ static struct mfd_cell wm8994_devs[] = {
200 .name = "wm8994-gpio", 209 .name = "wm8994-gpio",
201 .num_resources = ARRAY_SIZE(wm8994_gpio_resources), 210 .num_resources = ARRAY_SIZE(wm8994_gpio_resources),
202 .resources = wm8994_gpio_resources, 211 .resources = wm8994_gpio_resources,
212 .pm_runtime_no_callbacks = true,
203 }, 213 },
204}; 214};
205 215
@@ -218,8 +228,20 @@ static const char *wm8994_main_supplies[] = {
218 "SPKVDD2", 228 "SPKVDD2",
219}; 229};
220 230
231static const char *wm8958_main_supplies[] = {
232 "DBVDD1",
233 "DBVDD2",
234 "DBVDD3",
235 "DCVDD",
236 "AVDD1",
237 "AVDD2",
238 "CPVDD",
239 "SPKVDD1",
240 "SPKVDD2",
241};
242
221#ifdef CONFIG_PM 243#ifdef CONFIG_PM
222static int wm8994_device_suspend(struct device *dev) 244static int wm8994_suspend(struct device *dev)
223{ 245{
224 struct wm8994 *wm8994 = dev_get_drvdata(dev); 246 struct wm8994 *wm8994 = dev_get_drvdata(dev);
225 int ret; 247 int ret;
@@ -239,7 +261,7 @@ static int wm8994_device_suspend(struct device *dev)
239 if (ret < 0) 261 if (ret < 0)
240 dev_err(dev, "Failed to save LDO registers: %d\n", ret); 262 dev_err(dev, "Failed to save LDO registers: %d\n", ret);
241 263
242 ret = regulator_bulk_disable(ARRAY_SIZE(wm8994_main_supplies), 264 ret = regulator_bulk_disable(wm8994->num_supplies,
243 wm8994->supplies); 265 wm8994->supplies);
244 if (ret != 0) { 266 if (ret != 0) {
245 dev_err(dev, "Failed to disable supplies: %d\n", ret); 267 dev_err(dev, "Failed to disable supplies: %d\n", ret);
@@ -249,12 +271,12 @@ static int wm8994_device_suspend(struct device *dev)
249 return 0; 271 return 0;
250} 272}
251 273
252static int wm8994_device_resume(struct device *dev) 274static int wm8994_resume(struct device *dev)
253{ 275{
254 struct wm8994 *wm8994 = dev_get_drvdata(dev); 276 struct wm8994 *wm8994 = dev_get_drvdata(dev);
255 int ret; 277 int ret;
256 278
257 ret = regulator_bulk_enable(ARRAY_SIZE(wm8994_main_supplies), 279 ret = regulator_bulk_enable(wm8994->num_supplies,
258 wm8994->supplies); 280 wm8994->supplies);
259 if (ret != 0) { 281 if (ret != 0) {
260 dev_err(dev, "Failed to enable supplies: %d\n", ret); 282 dev_err(dev, "Failed to enable supplies: %d\n", ret);
@@ -305,9 +327,10 @@ static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
305/* 327/*
306 * Instantiate the generic non-control parts of the device. 328 * Instantiate the generic non-control parts of the device.
307 */ 329 */
308static int wm8994_device_init(struct wm8994 *wm8994, unsigned long id, int irq) 330static int wm8994_device_init(struct wm8994 *wm8994, int irq)
309{ 331{
310 struct wm8994_pdata *pdata = wm8994->dev->platform_data; 332 struct wm8994_pdata *pdata = wm8994->dev->platform_data;
333 const char *devname;
311 int ret, i; 334 int ret, i;
312 335
313 mutex_init(&wm8994->io_lock); 336 mutex_init(&wm8994->io_lock);
@@ -323,25 +346,48 @@ static int wm8994_device_init(struct wm8994 *wm8994, unsigned long id, int irq)
323 goto err; 346 goto err;
324 } 347 }
325 348
349 switch (wm8994->type) {
350 case WM8994:
351 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
352 break;
353 case WM8958:
354 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
355 break;
356 default:
357 BUG();
358 return -EINVAL;
359 }
360
326 wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) * 361 wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) *
327 ARRAY_SIZE(wm8994_main_supplies), 362 wm8994->num_supplies,
328 GFP_KERNEL); 363 GFP_KERNEL);
329 if (!wm8994->supplies) { 364 if (!wm8994->supplies) {
330 ret = -ENOMEM; 365 ret = -ENOMEM;
331 goto err; 366 goto err;
332 } 367 }
333 368
334 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++) 369 switch (wm8994->type) {
335 wm8994->supplies[i].supply = wm8994_main_supplies[i]; 370 case WM8994:
336 371 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
337 ret = regulator_bulk_get(wm8994->dev, ARRAY_SIZE(wm8994_main_supplies), 372 wm8994->supplies[i].supply = wm8994_main_supplies[i];
373 break;
374 case WM8958:
375 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
376 wm8994->supplies[i].supply = wm8958_main_supplies[i];
377 break;
378 default:
379 BUG();
380 return -EINVAL;
381 }
382
383 ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
338 wm8994->supplies); 384 wm8994->supplies);
339 if (ret != 0) { 385 if (ret != 0) {
340 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret); 386 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
341 goto err_supplies; 387 goto err_supplies;
342 } 388 }
343 389
344 ret = regulator_bulk_enable(ARRAY_SIZE(wm8994_main_supplies), 390 ret = regulator_bulk_enable(wm8994->num_supplies,
345 wm8994->supplies); 391 wm8994->supplies);
346 if (ret != 0) { 392 if (ret != 0) {
347 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret); 393 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
@@ -353,7 +399,22 @@ static int wm8994_device_init(struct wm8994 *wm8994, unsigned long id, int irq)
353 dev_err(wm8994->dev, "Failed to read ID register\n"); 399 dev_err(wm8994->dev, "Failed to read ID register\n");
354 goto err_enable; 400 goto err_enable;
355 } 401 }
356 if (ret != 0x8994) { 402 switch (ret) {
403 case 0x8994:
404 devname = "WM8994";
405 if (wm8994->type != WM8994)
406 dev_warn(wm8994->dev, "Device registered as type %d\n",
407 wm8994->type);
408 wm8994->type = WM8994;
409 break;
410 case 0x8958:
411 devname = "WM8958";
412 if (wm8994->type != WM8958)
413 dev_warn(wm8994->dev, "Device registered as type %d\n",
414 wm8994->type);
415 wm8994->type = WM8958;
416 break;
417 default:
357 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n", 418 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
358 ret); 419 ret);
359 ret = -EINVAL; 420 ret = -EINVAL;
@@ -370,14 +431,16 @@ static int wm8994_device_init(struct wm8994 *wm8994, unsigned long id, int irq)
370 switch (ret) { 431 switch (ret) {
371 case 0: 432 case 0:
372 case 1: 433 case 1:
373 dev_warn(wm8994->dev, "revision %c not fully supported\n", 434 if (wm8994->type == WM8994)
374 'A' + ret); 435 dev_warn(wm8994->dev,
436 "revision %c not fully supported\n",
437 'A' + ret);
375 break; 438 break;
376 default: 439 default:
377 dev_info(wm8994->dev, "revision %c\n", 'A' + ret);
378 break; 440 break;
379 } 441 }
380 442
443 dev_info(wm8994->dev, "%s revision %c\n", devname, 'A' + ret);
381 444
382 if (pdata) { 445 if (pdata) {
383 wm8994->irq_base = pdata->irq_base; 446 wm8994->irq_base = pdata->irq_base;
@@ -418,15 +481,18 @@ static int wm8994_device_init(struct wm8994 *wm8994, unsigned long id, int irq)
418 goto err_irq; 481 goto err_irq;
419 } 482 }
420 483
484 pm_runtime_enable(wm8994->dev);
485 pm_runtime_resume(wm8994->dev);
486
421 return 0; 487 return 0;
422 488
423err_irq: 489err_irq:
424 wm8994_irq_exit(wm8994); 490 wm8994_irq_exit(wm8994);
425err_enable: 491err_enable:
426 regulator_bulk_disable(ARRAY_SIZE(wm8994_main_supplies), 492 regulator_bulk_disable(wm8994->num_supplies,
427 wm8994->supplies); 493 wm8994->supplies);
428err_get: 494err_get:
429 regulator_bulk_free(ARRAY_SIZE(wm8994_main_supplies), wm8994->supplies); 495 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
430err_supplies: 496err_supplies:
431 kfree(wm8994->supplies); 497 kfree(wm8994->supplies);
432err: 498err:
@@ -437,11 +503,12 @@ err:
437 503
438static void wm8994_device_exit(struct wm8994 *wm8994) 504static void wm8994_device_exit(struct wm8994 *wm8994)
439{ 505{
506 pm_runtime_disable(wm8994->dev);
440 mfd_remove_devices(wm8994->dev); 507 mfd_remove_devices(wm8994->dev);
441 wm8994_irq_exit(wm8994); 508 wm8994_irq_exit(wm8994);
442 regulator_bulk_disable(ARRAY_SIZE(wm8994_main_supplies), 509 regulator_bulk_disable(wm8994->num_supplies,
443 wm8994->supplies); 510 wm8994->supplies);
444 regulator_bulk_free(ARRAY_SIZE(wm8994_main_supplies), wm8994->supplies); 511 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
445 kfree(wm8994->supplies); 512 kfree(wm8994->supplies);
446 kfree(wm8994); 513 kfree(wm8994);
447} 514}
@@ -506,8 +573,9 @@ static int wm8994_i2c_probe(struct i2c_client *i2c,
506 wm8994->read_dev = wm8994_i2c_read_device; 573 wm8994->read_dev = wm8994_i2c_read_device;
507 wm8994->write_dev = wm8994_i2c_write_device; 574 wm8994->write_dev = wm8994_i2c_write_device;
508 wm8994->irq = i2c->irq; 575 wm8994->irq = i2c->irq;
576 wm8994->type = id->driver_data;
509 577
510 return wm8994_device_init(wm8994, id->driver_data, i2c->irq); 578 return wm8994_device_init(wm8994, i2c->irq);
511} 579}
512 580
513static int wm8994_i2c_remove(struct i2c_client *i2c) 581static int wm8994_i2c_remove(struct i2c_client *i2c)
@@ -519,36 +587,23 @@ static int wm8994_i2c_remove(struct i2c_client *i2c)
519 return 0; 587 return 0;
520} 588}
521 589
522#ifdef CONFIG_PM
523static int wm8994_i2c_suspend(struct i2c_client *i2c, pm_message_t state)
524{
525 return wm8994_device_suspend(&i2c->dev);
526}
527
528static int wm8994_i2c_resume(struct i2c_client *i2c)
529{
530 return wm8994_device_resume(&i2c->dev);
531}
532#else
533#define wm8994_i2c_suspend NULL
534#define wm8994_i2c_resume NULL
535#endif
536
537static const struct i2c_device_id wm8994_i2c_id[] = { 590static const struct i2c_device_id wm8994_i2c_id[] = {
538 { "wm8994", 0 }, 591 { "wm8994", WM8994 },
592 { "wm8958", WM8958 },
539 { } 593 { }
540}; 594};
541MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id); 595MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
542 596
597UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume, NULL);
598
543static struct i2c_driver wm8994_i2c_driver = { 599static struct i2c_driver wm8994_i2c_driver = {
544 .driver = { 600 .driver = {
545 .name = "wm8994", 601 .name = "wm8994",
546 .owner = THIS_MODULE, 602 .owner = THIS_MODULE,
603 .pm = &wm8994_pm_ops,
547 }, 604 },
548 .probe = wm8994_i2c_probe, 605 .probe = wm8994_i2c_probe,
549 .remove = wm8994_i2c_remove, 606 .remove = wm8994_i2c_remove,
550 .suspend = wm8994_i2c_suspend,
551 .resume = wm8994_i2c_resume,
552 .id_table = wm8994_i2c_id, 607 .id_table = wm8994_i2c_id,
553}; 608};
554 609
diff --git a/drivers/mfd/wm8994-irq.c b/drivers/mfd/wm8994-irq.c
index 8400eb1ee5db..29e8faf9c01c 100644
--- a/drivers/mfd/wm8994-irq.c
+++ b/drivers/mfd/wm8994-irq.c
@@ -156,16 +156,16 @@ static inline struct wm8994_irq_data *irq_to_wm8994_irq(struct wm8994 *wm8994,
156 return &wm8994_irqs[irq - wm8994->irq_base]; 156 return &wm8994_irqs[irq - wm8994->irq_base];
157} 157}
158 158
159static void wm8994_irq_lock(unsigned int irq) 159static void wm8994_irq_lock(struct irq_data *data)
160{ 160{
161 struct wm8994 *wm8994 = get_irq_chip_data(irq); 161 struct wm8994 *wm8994 = irq_data_get_irq_chip_data(data);
162 162
163 mutex_lock(&wm8994->irq_lock); 163 mutex_lock(&wm8994->irq_lock);
164} 164}
165 165
166static void wm8994_irq_sync_unlock(unsigned int irq) 166static void wm8994_irq_sync_unlock(struct irq_data *data)
167{ 167{
168 struct wm8994 *wm8994 = get_irq_chip_data(irq); 168 struct wm8994 *wm8994 = irq_data_get_irq_chip_data(data);
169 int i; 169 int i;
170 170
171 for (i = 0; i < ARRAY_SIZE(wm8994->irq_masks_cur); i++) { 171 for (i = 0; i < ARRAY_SIZE(wm8994->irq_masks_cur); i++) {
@@ -182,28 +182,30 @@ static void wm8994_irq_sync_unlock(unsigned int irq)
182 mutex_unlock(&wm8994->irq_lock); 182 mutex_unlock(&wm8994->irq_lock);
183} 183}
184 184
185static void wm8994_irq_unmask(unsigned int irq) 185static void wm8994_irq_unmask(struct irq_data *data)
186{ 186{
187 struct wm8994 *wm8994 = get_irq_chip_data(irq); 187 struct wm8994 *wm8994 = irq_data_get_irq_chip_data(data);
188 struct wm8994_irq_data *irq_data = irq_to_wm8994_irq(wm8994, irq); 188 struct wm8994_irq_data *irq_data = irq_to_wm8994_irq(wm8994,
189 data->irq);
189 190
190 wm8994->irq_masks_cur[irq_data->reg - 1] &= ~irq_data->mask; 191 wm8994->irq_masks_cur[irq_data->reg - 1] &= ~irq_data->mask;
191} 192}
192 193
193static void wm8994_irq_mask(unsigned int irq) 194static void wm8994_irq_mask(struct irq_data *data)
194{ 195{
195 struct wm8994 *wm8994 = get_irq_chip_data(irq); 196 struct wm8994 *wm8994 = irq_data_get_irq_chip_data(data);
196 struct wm8994_irq_data *irq_data = irq_to_wm8994_irq(wm8994, irq); 197 struct wm8994_irq_data *irq_data = irq_to_wm8994_irq(wm8994,
198 data->irq);
197 199
198 wm8994->irq_masks_cur[irq_data->reg - 1] |= irq_data->mask; 200 wm8994->irq_masks_cur[irq_data->reg - 1] |= irq_data->mask;
199} 201}
200 202
201static struct irq_chip wm8994_irq_chip = { 203static struct irq_chip wm8994_irq_chip = {
202 .name = "wm8994", 204 .name = "wm8994",
203 .bus_lock = wm8994_irq_lock, 205 .irq_bus_lock = wm8994_irq_lock,
204 .bus_sync_unlock = wm8994_irq_sync_unlock, 206 .irq_bus_sync_unlock = wm8994_irq_sync_unlock,
205 .mask = wm8994_irq_mask, 207 .irq_mask = wm8994_irq_mask,
206 .unmask = wm8994_irq_unmask, 208 .irq_unmask = wm8994_irq_unmask,
207}; 209};
208 210
209/* The processing of the primary interrupt occurs in a thread so that 211/* The processing of the primary interrupt occurs in a thread so that
generated by cgit v1.2.2 (git 2.25.0) at 2025-03-08 01:48:12 -0500