2 * Base driver for Marvell 88PM8607
4 * Copyright (C) 2009 Marvell International Ltd.
5 * Haojian Zhuang <haojian.zhuang@marvell.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/err.h>
15 #include <linux/i2c.h>
16 #include <linux/irq.h>
17 #include <linux/interrupt.h>
18 #include <linux/irqdomain.h>
20 #include <linux/of_platform.h>
21 #include <linux/platform_device.h>
22 #include <linux/regmap.h>
23 #include <linux/slab.h>
24 #include <linux/mfd/core.h>
25 #include <linux/mfd/88pm860x.h>
26 #include <linux/regulator/machine.h>
27 #include <linux/power/charger-manager.h>
29 #define INT_STATUS_NUM 3
31 static struct resource bk0_resources
[] = {
32 {2, 2, "duty cycle", IORESOURCE_REG
, },
33 {3, 3, "always on", IORESOURCE_REG
, },
34 {3, 3, "current", IORESOURCE_REG
, },
36 static struct resource bk1_resources
[] = {
37 {4, 4, "duty cycle", IORESOURCE_REG
, },
38 {5, 5, "always on", IORESOURCE_REG
, },
39 {5, 5, "current", IORESOURCE_REG
, },
41 static struct resource bk2_resources
[] = {
42 {6, 6, "duty cycle", IORESOURCE_REG
, },
43 {7, 7, "always on", IORESOURCE_REG
, },
44 {5, 5, "current", IORESOURCE_REG
, },
47 static struct resource led0_resources
[] = {
49 {0xd, 0xd, "control", IORESOURCE_REG
, },
50 {0xc, 0xc, "blink", IORESOURCE_REG
, },
52 static struct resource led1_resources
[] = {
54 {0xe, 0xe, "control", IORESOURCE_REG
, },
55 {0xc, 0xc, "blink", IORESOURCE_REG
, },
57 static struct resource led2_resources
[] = {
59 {0xf, 0xf, "control", IORESOURCE_REG
, },
60 {0xc, 0xc, "blink", IORESOURCE_REG
, },
62 static struct resource led3_resources
[] = {
64 {0x9, 0x9, "control", IORESOURCE_REG
, },
65 {0x8, 0x8, "blink", IORESOURCE_REG
, },
67 static struct resource led4_resources
[] = {
69 {0xa, 0xa, "control", IORESOURCE_REG
, },
70 {0x8, 0x8, "blink", IORESOURCE_REG
, },
72 static struct resource led5_resources
[] = {
74 {0xb, 0xb, "control", IORESOURCE_REG
, },
75 {0x8, 0x8, "blink", IORESOURCE_REG
, },
78 static struct resource buck1_resources
[] = {
79 {0x24, 0x24, "buck set", IORESOURCE_REG
, },
81 static struct resource buck2_resources
[] = {
82 {0x25, 0x25, "buck set", IORESOURCE_REG
, },
84 static struct resource buck3_resources
[] = {
85 {0x26, 0x26, "buck set", IORESOURCE_REG
, },
87 static struct resource ldo1_resources
[] = {
88 {0x10, 0x10, "ldo set", IORESOURCE_REG
, },
90 static struct resource ldo2_resources
[] = {
91 {0x11, 0x11, "ldo set", IORESOURCE_REG
, },
93 static struct resource ldo3_resources
[] = {
94 {0x12, 0x12, "ldo set", IORESOURCE_REG
, },
96 static struct resource ldo4_resources
[] = {
97 {0x13, 0x13, "ldo set", IORESOURCE_REG
, },
99 static struct resource ldo5_resources
[] = {
100 {0x14, 0x14, "ldo set", IORESOURCE_REG
, },
102 static struct resource ldo6_resources
[] = {
103 {0x15, 0x15, "ldo set", IORESOURCE_REG
, },
105 static struct resource ldo7_resources
[] = {
106 {0x16, 0x16, "ldo set", IORESOURCE_REG
, },
108 static struct resource ldo8_resources
[] = {
109 {0x17, 0x17, "ldo set", IORESOURCE_REG
, },
111 static struct resource ldo9_resources
[] = {
112 {0x18, 0x18, "ldo set", IORESOURCE_REG
, },
114 static struct resource ldo10_resources
[] = {
115 {0x19, 0x19, "ldo set", IORESOURCE_REG
, },
117 static struct resource ldo12_resources
[] = {
118 {0x1a, 0x1a, "ldo set", IORESOURCE_REG
, },
120 static struct resource ldo_vibrator_resources
[] = {
121 {0x28, 0x28, "ldo set", IORESOURCE_REG
, },
123 static struct resource ldo14_resources
[] = {
124 {0x1b, 0x1b, "ldo set", IORESOURCE_REG
, },
127 static struct resource touch_resources
[] = {
128 {PM8607_IRQ_PEN
, PM8607_IRQ_PEN
, "touch", IORESOURCE_IRQ
,},
131 static struct resource onkey_resources
[] = {
132 {PM8607_IRQ_ONKEY
, PM8607_IRQ_ONKEY
, "onkey", IORESOURCE_IRQ
,},
135 static struct resource codec_resources
[] = {
136 /* Headset microphone insertion or removal */
137 {PM8607_IRQ_MICIN
, PM8607_IRQ_MICIN
, "micin", IORESOURCE_IRQ
,},
138 /* Hook-switch press or release */
139 {PM8607_IRQ_HOOK
, PM8607_IRQ_HOOK
, "hook", IORESOURCE_IRQ
,},
140 /* Headset insertion or removal */
141 {PM8607_IRQ_HEADSET
, PM8607_IRQ_HEADSET
, "headset", IORESOURCE_IRQ
,},
143 {PM8607_IRQ_AUDIO_SHORT
, PM8607_IRQ_AUDIO_SHORT
, "audio-short", IORESOURCE_IRQ
,},
146 static struct resource battery_resources
[] = {
147 {PM8607_IRQ_CC
, PM8607_IRQ_CC
, "columb counter", IORESOURCE_IRQ
,},
148 {PM8607_IRQ_BAT
, PM8607_IRQ_BAT
, "battery", IORESOURCE_IRQ
,},
151 static struct resource charger_resources
[] = {
152 {PM8607_IRQ_CHG
, PM8607_IRQ_CHG
, "charger detect", IORESOURCE_IRQ
,},
153 {PM8607_IRQ_CHG_DONE
, PM8607_IRQ_CHG_DONE
, "charging done", IORESOURCE_IRQ
,},
154 {PM8607_IRQ_CHG_FAIL
, PM8607_IRQ_CHG_FAIL
, "charging timeout", IORESOURCE_IRQ
,},
155 {PM8607_IRQ_CHG_FAULT
, PM8607_IRQ_CHG_FAULT
, "charging fault", IORESOURCE_IRQ
,},
156 {PM8607_IRQ_GPADC1
, PM8607_IRQ_GPADC1
, "battery temperature", IORESOURCE_IRQ
,},
157 {PM8607_IRQ_VBAT
, PM8607_IRQ_VBAT
, "battery voltage", IORESOURCE_IRQ
,},
158 {PM8607_IRQ_VCHG
, PM8607_IRQ_VCHG
, "vchg voltage", IORESOURCE_IRQ
,},
161 static struct resource rtc_resources
[] = {
162 {PM8607_IRQ_RTC
, PM8607_IRQ_RTC
, "rtc", IORESOURCE_IRQ
,},
165 static struct mfd_cell bk_devs
[] = {
167 .name
= "88pm860x-backlight",
169 .num_resources
= ARRAY_SIZE(bk0_resources
),
170 .resources
= bk0_resources
,
172 .name
= "88pm860x-backlight",
174 .num_resources
= ARRAY_SIZE(bk1_resources
),
175 .resources
= bk1_resources
,
177 .name
= "88pm860x-backlight",
179 .num_resources
= ARRAY_SIZE(bk2_resources
),
180 .resources
= bk2_resources
,
184 static struct mfd_cell led_devs
[] = {
186 .name
= "88pm860x-led",
188 .num_resources
= ARRAY_SIZE(led0_resources
),
189 .resources
= led0_resources
,
191 .name
= "88pm860x-led",
193 .num_resources
= ARRAY_SIZE(led1_resources
),
194 .resources
= led1_resources
,
196 .name
= "88pm860x-led",
198 .num_resources
= ARRAY_SIZE(led2_resources
),
199 .resources
= led2_resources
,
201 .name
= "88pm860x-led",
203 .num_resources
= ARRAY_SIZE(led3_resources
),
204 .resources
= led3_resources
,
206 .name
= "88pm860x-led",
208 .num_resources
= ARRAY_SIZE(led4_resources
),
209 .resources
= led4_resources
,
211 .name
= "88pm860x-led",
213 .num_resources
= ARRAY_SIZE(led5_resources
),
214 .resources
= led5_resources
,
218 static struct mfd_cell reg_devs
[] = {
220 .name
= "88pm860x-regulator",
222 .num_resources
= ARRAY_SIZE(buck1_resources
),
223 .resources
= buck1_resources
,
225 .name
= "88pm860x-regulator",
227 .num_resources
= ARRAY_SIZE(buck2_resources
),
228 .resources
= buck2_resources
,
230 .name
= "88pm860x-regulator",
232 .num_resources
= ARRAY_SIZE(buck3_resources
),
233 .resources
= buck3_resources
,
235 .name
= "88pm860x-regulator",
237 .num_resources
= ARRAY_SIZE(ldo1_resources
),
238 .resources
= ldo1_resources
,
240 .name
= "88pm860x-regulator",
242 .num_resources
= ARRAY_SIZE(ldo2_resources
),
243 .resources
= ldo2_resources
,
245 .name
= "88pm860x-regulator",
247 .num_resources
= ARRAY_SIZE(ldo3_resources
),
248 .resources
= ldo3_resources
,
250 .name
= "88pm860x-regulator",
252 .num_resources
= ARRAY_SIZE(ldo4_resources
),
253 .resources
= ldo4_resources
,
255 .name
= "88pm860x-regulator",
257 .num_resources
= ARRAY_SIZE(ldo5_resources
),
258 .resources
= ldo5_resources
,
260 .name
= "88pm860x-regulator",
262 .num_resources
= ARRAY_SIZE(ldo6_resources
),
263 .resources
= ldo6_resources
,
265 .name
= "88pm860x-regulator",
267 .num_resources
= ARRAY_SIZE(ldo7_resources
),
268 .resources
= ldo7_resources
,
270 .name
= "88pm860x-regulator",
272 .num_resources
= ARRAY_SIZE(ldo8_resources
),
273 .resources
= ldo8_resources
,
275 .name
= "88pm860x-regulator",
277 .num_resources
= ARRAY_SIZE(ldo9_resources
),
278 .resources
= ldo9_resources
,
280 .name
= "88pm860x-regulator",
282 .num_resources
= ARRAY_SIZE(ldo10_resources
),
283 .resources
= ldo10_resources
,
285 .name
= "88pm860x-regulator",
287 .num_resources
= ARRAY_SIZE(ldo12_resources
),
288 .resources
= ldo12_resources
,
290 .name
= "88pm860x-regulator",
292 .num_resources
= ARRAY_SIZE(ldo_vibrator_resources
),
293 .resources
= ldo_vibrator_resources
,
295 .name
= "88pm860x-regulator",
297 .num_resources
= ARRAY_SIZE(ldo14_resources
),
298 .resources
= ldo14_resources
,
302 static struct mfd_cell touch_devs
[] = {
303 {"88pm860x-touch", -1,},
306 static struct mfd_cell onkey_devs
[] = {
307 {"88pm860x-onkey", -1,},
310 static struct mfd_cell codec_devs
[] = {
311 {"88pm860x-codec", -1,},
314 static struct regulator_consumer_supply preg_supply
[] = {
315 REGULATOR_SUPPLY("preg", "charger-manager"),
318 static struct regulator_init_data preg_init_data
= {
319 .num_consumer_supplies
= ARRAY_SIZE(preg_supply
),
320 .consumer_supplies
= &preg_supply
[0],
323 static struct charger_regulator chg_desc_regulator_data
[] = {
324 { .regulator_name
= "preg", },
327 static struct mfd_cell power_devs
[] = {
328 {"88pm860x-battery", -1,},
329 {"88pm860x-charger", -1,},
330 {"88pm860x-preg", -1,},
331 {"charger-manager", -1,},
334 static struct mfd_cell rtc_devs
[] = {
335 {"88pm860x-rtc", -1,},
339 struct pm860x_irq_data
{
342 int enable
; /* enable or not */
343 int offs
; /* bit offset in mask register */
346 static struct pm860x_irq_data pm860x_irqs
[] = {
347 [PM8607_IRQ_ONKEY
] = {
348 .reg
= PM8607_INT_STATUS1
,
349 .mask_reg
= PM8607_INT_MASK_1
,
352 [PM8607_IRQ_EXTON
] = {
353 .reg
= PM8607_INT_STATUS1
,
354 .mask_reg
= PM8607_INT_MASK_1
,
358 .reg
= PM8607_INT_STATUS1
,
359 .mask_reg
= PM8607_INT_MASK_1
,
363 .reg
= PM8607_INT_STATUS1
,
364 .mask_reg
= PM8607_INT_MASK_1
,
368 .reg
= PM8607_INT_STATUS1
,
369 .mask_reg
= PM8607_INT_MASK_1
,
373 .reg
= PM8607_INT_STATUS1
,
374 .mask_reg
= PM8607_INT_MASK_1
,
377 [PM8607_IRQ_VBAT
] = {
378 .reg
= PM8607_INT_STATUS2
,
379 .mask_reg
= PM8607_INT_MASK_2
,
382 [PM8607_IRQ_VCHG
] = {
383 .reg
= PM8607_INT_STATUS2
,
384 .mask_reg
= PM8607_INT_MASK_2
,
387 [PM8607_IRQ_VSYS
] = {
388 .reg
= PM8607_INT_STATUS2
,
389 .mask_reg
= PM8607_INT_MASK_2
,
392 [PM8607_IRQ_TINT
] = {
393 .reg
= PM8607_INT_STATUS2
,
394 .mask_reg
= PM8607_INT_MASK_2
,
397 [PM8607_IRQ_GPADC0
] = {
398 .reg
= PM8607_INT_STATUS2
,
399 .mask_reg
= PM8607_INT_MASK_2
,
402 [PM8607_IRQ_GPADC1
] = {
403 .reg
= PM8607_INT_STATUS2
,
404 .mask_reg
= PM8607_INT_MASK_2
,
407 [PM8607_IRQ_GPADC2
] = {
408 .reg
= PM8607_INT_STATUS2
,
409 .mask_reg
= PM8607_INT_MASK_2
,
412 [PM8607_IRQ_GPADC3
] = {
413 .reg
= PM8607_INT_STATUS2
,
414 .mask_reg
= PM8607_INT_MASK_2
,
417 [PM8607_IRQ_AUDIO_SHORT
] = {
418 .reg
= PM8607_INT_STATUS3
,
419 .mask_reg
= PM8607_INT_MASK_3
,
423 .reg
= PM8607_INT_STATUS3
,
424 .mask_reg
= PM8607_INT_MASK_3
,
427 [PM8607_IRQ_HEADSET
] = {
428 .reg
= PM8607_INT_STATUS3
,
429 .mask_reg
= PM8607_INT_MASK_3
,
432 [PM8607_IRQ_HOOK
] = {
433 .reg
= PM8607_INT_STATUS3
,
434 .mask_reg
= PM8607_INT_MASK_3
,
437 [PM8607_IRQ_MICIN
] = {
438 .reg
= PM8607_INT_STATUS3
,
439 .mask_reg
= PM8607_INT_MASK_3
,
442 [PM8607_IRQ_CHG_FAIL
] = {
443 .reg
= PM8607_INT_STATUS3
,
444 .mask_reg
= PM8607_INT_MASK_3
,
447 [PM8607_IRQ_CHG_DONE
] = {
448 .reg
= PM8607_INT_STATUS3
,
449 .mask_reg
= PM8607_INT_MASK_3
,
452 [PM8607_IRQ_CHG_FAULT
] = {
453 .reg
= PM8607_INT_STATUS3
,
454 .mask_reg
= PM8607_INT_MASK_3
,
459 static irqreturn_t
pm860x_irq(int irq
, void *data
)
461 struct pm860x_chip
*chip
= data
;
462 struct pm860x_irq_data
*irq_data
;
463 struct i2c_client
*i2c
;
464 int read_reg
= -1, value
= 0;
467 i2c
= (chip
->id
== CHIP_PM8607
) ? chip
->client
: chip
->companion
;
468 for (i
= 0; i
< ARRAY_SIZE(pm860x_irqs
); i
++) {
469 irq_data
= &pm860x_irqs
[i
];
470 if (read_reg
!= irq_data
->reg
) {
471 read_reg
= irq_data
->reg
;
472 value
= pm860x_reg_read(i2c
, irq_data
->reg
);
474 if (value
& irq_data
->enable
)
475 handle_nested_irq(chip
->irq_base
+ i
);
480 static void pm860x_irq_lock(struct irq_data
*data
)
482 struct pm860x_chip
*chip
= irq_data_get_irq_chip_data(data
);
484 mutex_lock(&chip
->irq_lock
);
487 static void pm860x_irq_sync_unlock(struct irq_data
*data
)
489 struct pm860x_chip
*chip
= irq_data_get_irq_chip_data(data
);
490 struct pm860x_irq_data
*irq_data
;
491 struct i2c_client
*i2c
;
492 static unsigned char cached
[3] = {0x0, 0x0, 0x0};
493 unsigned char mask
[3];
496 i2c
= (chip
->id
== CHIP_PM8607
) ? chip
->client
: chip
->companion
;
497 /* Load cached value. In initial, all IRQs are masked */
498 for (i
= 0; i
< 3; i
++)
500 for (i
= 0; i
< ARRAY_SIZE(pm860x_irqs
); i
++) {
501 irq_data
= &pm860x_irqs
[i
];
502 switch (irq_data
->mask_reg
) {
503 case PM8607_INT_MASK_1
:
504 mask
[0] &= ~irq_data
->offs
;
505 mask
[0] |= irq_data
->enable
;
507 case PM8607_INT_MASK_2
:
508 mask
[1] &= ~irq_data
->offs
;
509 mask
[1] |= irq_data
->enable
;
511 case PM8607_INT_MASK_3
:
512 mask
[2] &= ~irq_data
->offs
;
513 mask
[2] |= irq_data
->enable
;
516 dev_err(chip
->dev
, "wrong IRQ\n");
520 /* update mask into registers */
521 for (i
= 0; i
< 3; i
++) {
522 if (mask
[i
] != cached
[i
]) {
524 pm860x_reg_write(i2c
, PM8607_INT_MASK_1
+ i
, mask
[i
]);
528 mutex_unlock(&chip
->irq_lock
);
531 static void pm860x_irq_enable(struct irq_data
*data
)
533 pm860x_irqs
[data
->hwirq
].enable
= pm860x_irqs
[data
->hwirq
].offs
;
536 static void pm860x_irq_disable(struct irq_data
*data
)
538 pm860x_irqs
[data
->hwirq
].enable
= 0;
541 static struct irq_chip pm860x_irq_chip
= {
543 .irq_bus_lock
= pm860x_irq_lock
,
544 .irq_bus_sync_unlock
= pm860x_irq_sync_unlock
,
545 .irq_enable
= pm860x_irq_enable
,
546 .irq_disable
= pm860x_irq_disable
,
549 static int pm860x_irq_domain_map(struct irq_domain
*d
, unsigned int virq
,
552 irq_set_chip_data(virq
, d
->host_data
);
553 irq_set_chip_and_handler(virq
, &pm860x_irq_chip
, handle_edge_irq
);
554 irq_set_nested_thread(virq
, 1);
556 set_irq_flags(virq
, IRQF_VALID
);
558 irq_set_noprobe(virq
);
563 static struct irq_domain_ops pm860x_irq_domain_ops
= {
564 .map
= pm860x_irq_domain_map
,
565 .xlate
= irq_domain_xlate_onetwocell
,
568 static int device_irq_init(struct pm860x_chip
*chip
,
569 struct pm860x_platform_data
*pdata
)
571 struct i2c_client
*i2c
= (chip
->id
== CHIP_PM8607
) ? chip
->client \
573 unsigned char status_buf
[INT_STATUS_NUM
];
574 unsigned long flags
= IRQF_TRIGGER_FALLING
| IRQF_ONESHOT
;
575 int data
, mask
, ret
= -EINVAL
;
576 int nr_irqs
, irq_base
= -1;
577 struct device_node
*node
= i2c
->dev
.of_node
;
579 mask
= PM8607_B0_MISC1_INV_INT
| PM8607_B0_MISC1_INT_CLEAR
580 | PM8607_B0_MISC1_INT_MASK
;
583 if (pdata
&& pdata
->irq_mode
) {
585 * irq_mode defines the way of clearing interrupt. If it's 1,
586 * clear IRQ by write. Otherwise, clear it by read.
587 * This control bit is valid from 88PM8607 B0 steping.
589 data
|= PM8607_B0_MISC1_INT_CLEAR
;
592 ret
= pm860x_set_bits(i2c
, PM8607_B0_MISC1
, mask
, data
);
597 memset(status_buf
, 0, INT_STATUS_NUM
);
598 ret
= pm860x_bulk_write(i2c
, PM8607_INT_MASK_1
,
599 INT_STATUS_NUM
, status_buf
);
603 if (chip
->irq_mode
) {
604 /* clear interrupt status by write */
605 memset(status_buf
, 0xFF, INT_STATUS_NUM
);
606 ret
= pm860x_bulk_write(i2c
, PM8607_INT_STATUS1
,
607 INT_STATUS_NUM
, status_buf
);
609 /* clear interrupt status by read */
610 ret
= pm860x_bulk_read(i2c
, PM8607_INT_STATUS1
,
611 INT_STATUS_NUM
, status_buf
);
616 mutex_init(&chip
->irq_lock
);
618 if (pdata
&& pdata
->irq_base
)
619 irq_base
= pdata
->irq_base
;
620 nr_irqs
= ARRAY_SIZE(pm860x_irqs
);
621 chip
->irq_base
= irq_alloc_descs(irq_base
, 0, nr_irqs
, 0);
622 if (chip
->irq_base
< 0) {
623 dev_err(&i2c
->dev
, "Failed to allocate interrupts, ret:%d\n",
628 irq_domain_add_legacy(node
, nr_irqs
, chip
->irq_base
, 0,
629 &pm860x_irq_domain_ops
, chip
);
630 chip
->core_irq
= i2c
->irq
;
634 ret
= request_threaded_irq(chip
->core_irq
, NULL
, pm860x_irq
, flags
| IRQF_ONESHOT
,
637 dev_err(chip
->dev
, "Failed to request IRQ: %d\n", ret
);
647 static void device_irq_exit(struct pm860x_chip
*chip
)
650 free_irq(chip
->core_irq
, chip
);
653 int pm8606_osc_enable(struct pm860x_chip
*chip
, unsigned short client
)
656 struct i2c_client
*i2c
= (chip
->id
== CHIP_PM8606
) ?
657 chip
->client
: chip
->companion
;
659 dev_dbg(chip
->dev
, "%s(B): client=0x%x\n", __func__
, client
);
660 dev_dbg(chip
->dev
, "%s(B): vote=0x%x status=%d\n",
661 __func__
, chip
->osc_vote
,
664 mutex_lock(&chip
->osc_lock
);
665 /* Update voting status */
666 chip
->osc_vote
|= client
;
667 /* If reference group is off - turn on*/
668 if (chip
->osc_status
!= PM8606_REF_GP_OSC_ON
) {
669 chip
->osc_status
= PM8606_REF_GP_OSC_UNKNOWN
;
670 /* Enable Reference group Vsys */
671 if (pm860x_set_bits(i2c
, PM8606_VSYS
,
672 PM8606_VSYS_EN
, PM8606_VSYS_EN
))
675 /*Enable Internal Oscillator */
676 if (pm860x_set_bits(i2c
, PM8606_MISC
,
677 PM8606_MISC_OSC_EN
, PM8606_MISC_OSC_EN
))
679 /* Update status (only if writes succeed) */
680 chip
->osc_status
= PM8606_REF_GP_OSC_ON
;
682 mutex_unlock(&chip
->osc_lock
);
684 dev_dbg(chip
->dev
, "%s(A): vote=0x%x status=%d ret=%d\n",
685 __func__
, chip
->osc_vote
,
686 chip
->osc_status
, ret
);
689 mutex_unlock(&chip
->osc_lock
);
692 EXPORT_SYMBOL(pm8606_osc_enable
);
694 int pm8606_osc_disable(struct pm860x_chip
*chip
, unsigned short client
)
697 struct i2c_client
*i2c
= (chip
->id
== CHIP_PM8606
) ?
698 chip
->client
: chip
->companion
;
700 dev_dbg(chip
->dev
, "%s(B): client=0x%x\n", __func__
, client
);
701 dev_dbg(chip
->dev
, "%s(B): vote=0x%x status=%d\n",
702 __func__
, chip
->osc_vote
,
705 mutex_lock(&chip
->osc_lock
);
706 /*Update voting status */
707 chip
->osc_vote
&= ~(client
);
708 /* If reference group is off and this is the last client to release
710 if ((chip
->osc_status
!= PM8606_REF_GP_OSC_OFF
) &&
711 (chip
->osc_vote
== REF_GP_NO_CLIENTS
)) {
712 chip
->osc_status
= PM8606_REF_GP_OSC_UNKNOWN
;
713 /* Disable Reference group Vsys */
714 if (pm860x_set_bits(i2c
, PM8606_VSYS
, PM8606_VSYS_EN
, 0))
716 /* Disable Internal Oscillator */
717 if (pm860x_set_bits(i2c
, PM8606_MISC
, PM8606_MISC_OSC_EN
, 0))
719 chip
->osc_status
= PM8606_REF_GP_OSC_OFF
;
721 mutex_unlock(&chip
->osc_lock
);
723 dev_dbg(chip
->dev
, "%s(A): vote=0x%x status=%d ret=%d\n",
724 __func__
, chip
->osc_vote
,
725 chip
->osc_status
, ret
);
728 mutex_unlock(&chip
->osc_lock
);
731 EXPORT_SYMBOL(pm8606_osc_disable
);
733 static void device_osc_init(struct i2c_client
*i2c
)
735 struct pm860x_chip
*chip
= i2c_get_clientdata(i2c
);
737 mutex_init(&chip
->osc_lock
);
738 /* init portofino reference group voting and status */
739 /* Disable Reference group Vsys */
740 pm860x_set_bits(i2c
, PM8606_VSYS
, PM8606_VSYS_EN
, 0);
741 /* Disable Internal Oscillator */
742 pm860x_set_bits(i2c
, PM8606_MISC
, PM8606_MISC_OSC_EN
, 0);
744 chip
->osc_vote
= REF_GP_NO_CLIENTS
;
745 chip
->osc_status
= PM8606_REF_GP_OSC_OFF
;
748 static void device_bk_init(struct pm860x_chip
*chip
,
749 struct pm860x_platform_data
*pdata
)
753 if (pdata
&& pdata
->backlight
) {
754 if (pdata
->num_backlights
> ARRAY_SIZE(bk_devs
))
755 pdata
->num_backlights
= ARRAY_SIZE(bk_devs
);
756 for (i
= 0; i
< pdata
->num_backlights
; i
++) {
757 bk_devs
[i
].platform_data
= &pdata
->backlight
[i
];
758 bk_devs
[i
].pdata_size
=
759 sizeof(struct pm860x_backlight_pdata
);
762 ret
= mfd_add_devices(chip
->dev
, 0, bk_devs
,
763 ARRAY_SIZE(bk_devs
), NULL
, 0, NULL
);
765 dev_err(chip
->dev
, "Failed to add backlight subdev\n");
768 static void device_led_init(struct pm860x_chip
*chip
,
769 struct pm860x_platform_data
*pdata
)
773 if (pdata
&& pdata
->led
) {
774 if (pdata
->num_leds
> ARRAY_SIZE(led_devs
))
775 pdata
->num_leds
= ARRAY_SIZE(led_devs
);
776 for (i
= 0; i
< pdata
->num_leds
; i
++) {
777 led_devs
[i
].platform_data
= &pdata
->led
[i
];
778 led_devs
[i
].pdata_size
=
779 sizeof(struct pm860x_led_pdata
);
782 ret
= mfd_add_devices(chip
->dev
, 0, led_devs
,
783 ARRAY_SIZE(led_devs
), NULL
, 0, NULL
);
785 dev_err(chip
->dev
, "Failed to add led subdev\n");
790 static void device_regulator_init(struct pm860x_chip
*chip
,
791 struct pm860x_platform_data
*pdata
)
798 reg_devs
[0].platform_data
= pdata
->buck1
;
799 reg_devs
[0].pdata_size
= sizeof(struct regulator_init_data
);
802 reg_devs
[1].platform_data
= pdata
->buck2
;
803 reg_devs
[1].pdata_size
= sizeof(struct regulator_init_data
);
806 reg_devs
[2].platform_data
= pdata
->buck3
;
807 reg_devs
[2].pdata_size
= sizeof(struct regulator_init_data
);
810 reg_devs
[3].platform_data
= pdata
->ldo1
;
811 reg_devs
[3].pdata_size
= sizeof(struct regulator_init_data
);
814 reg_devs
[4].platform_data
= pdata
->ldo2
;
815 reg_devs
[4].pdata_size
= sizeof(struct regulator_init_data
);
818 reg_devs
[5].platform_data
= pdata
->ldo3
;
819 reg_devs
[5].pdata_size
= sizeof(struct regulator_init_data
);
822 reg_devs
[6].platform_data
= pdata
->ldo4
;
823 reg_devs
[6].pdata_size
= sizeof(struct regulator_init_data
);
826 reg_devs
[7].platform_data
= pdata
->ldo5
;
827 reg_devs
[7].pdata_size
= sizeof(struct regulator_init_data
);
830 reg_devs
[8].platform_data
= pdata
->ldo6
;
831 reg_devs
[8].pdata_size
= sizeof(struct regulator_init_data
);
834 reg_devs
[9].platform_data
= pdata
->ldo7
;
835 reg_devs
[9].pdata_size
= sizeof(struct regulator_init_data
);
838 reg_devs
[10].platform_data
= pdata
->ldo8
;
839 reg_devs
[10].pdata_size
= sizeof(struct regulator_init_data
);
842 reg_devs
[11].platform_data
= pdata
->ldo9
;
843 reg_devs
[11].pdata_size
= sizeof(struct regulator_init_data
);
846 reg_devs
[12].platform_data
= pdata
->ldo10
;
847 reg_devs
[12].pdata_size
= sizeof(struct regulator_init_data
);
850 reg_devs
[13].platform_data
= pdata
->ldo12
;
851 reg_devs
[13].pdata_size
= sizeof(struct regulator_init_data
);
853 if (pdata
->ldo_vibrator
) {
854 reg_devs
[14].platform_data
= pdata
->ldo_vibrator
;
855 reg_devs
[14].pdata_size
= sizeof(struct regulator_init_data
);
858 reg_devs
[15].platform_data
= pdata
->ldo14
;
859 reg_devs
[15].pdata_size
= sizeof(struct regulator_init_data
);
861 ret
= mfd_add_devices(chip
->dev
, 0, reg_devs
,
862 ARRAY_SIZE(reg_devs
), NULL
, 0, NULL
);
864 dev_err(chip
->dev
, "Failed to add regulator subdev\n");
869 static void device_rtc_init(struct pm860x_chip
*chip
,
870 struct pm860x_platform_data
*pdata
)
877 rtc_devs
[0].platform_data
= pdata
->rtc
;
878 rtc_devs
[0].pdata_size
= sizeof(struct pm860x_rtc_pdata
);
879 rtc_devs
[0].num_resources
= ARRAY_SIZE(rtc_resources
);
880 rtc_devs
[0].resources
= &rtc_resources
[0];
881 ret
= mfd_add_devices(chip
->dev
, 0, &rtc_devs
[0],
882 ARRAY_SIZE(rtc_devs
), &rtc_resources
[0],
883 chip
->irq_base
, NULL
);
885 dev_err(chip
->dev
, "Failed to add rtc subdev\n");
888 static void device_touch_init(struct pm860x_chip
*chip
,
889 struct pm860x_platform_data
*pdata
)
896 touch_devs
[0].platform_data
= pdata
->touch
;
897 touch_devs
[0].pdata_size
= sizeof(struct pm860x_touch_pdata
);
898 touch_devs
[0].num_resources
= ARRAY_SIZE(touch_resources
);
899 touch_devs
[0].resources
= &touch_resources
[0];
900 ret
= mfd_add_devices(chip
->dev
, 0, &touch_devs
[0],
901 ARRAY_SIZE(touch_devs
), &touch_resources
[0],
902 chip
->irq_base
, NULL
);
904 dev_err(chip
->dev
, "Failed to add touch subdev\n");
907 static void device_power_init(struct pm860x_chip
*chip
,
908 struct pm860x_platform_data
*pdata
)
915 power_devs
[0].platform_data
= pdata
->power
;
916 power_devs
[0].pdata_size
= sizeof(struct pm860x_power_pdata
);
917 power_devs
[0].num_resources
= ARRAY_SIZE(battery_resources
);
918 power_devs
[0].resources
= &battery_resources
[0],
919 ret
= mfd_add_devices(chip
->dev
, 0, &power_devs
[0], 1,
920 &battery_resources
[0], chip
->irq_base
, NULL
);
922 dev_err(chip
->dev
, "Failed to add battery subdev\n");
924 power_devs
[1].platform_data
= pdata
->power
;
925 power_devs
[1].pdata_size
= sizeof(struct pm860x_power_pdata
);
926 power_devs
[1].num_resources
= ARRAY_SIZE(charger_resources
);
927 power_devs
[1].resources
= &charger_resources
[0],
928 ret
= mfd_add_devices(chip
->dev
, 0, &power_devs
[1], 1,
929 &charger_resources
[0], chip
->irq_base
, NULL
);
931 dev_err(chip
->dev
, "Failed to add charger subdev\n");
933 power_devs
[2].platform_data
= &preg_init_data
;
934 power_devs
[2].pdata_size
= sizeof(struct regulator_init_data
);
935 ret
= mfd_add_devices(chip
->dev
, 0, &power_devs
[2], 1,
936 NULL
, chip
->irq_base
, NULL
);
938 dev_err(chip
->dev
, "Failed to add preg subdev\n");
940 if (pdata
->chg_desc
) {
941 pdata
->chg_desc
->charger_regulators
=
942 &chg_desc_regulator_data
[0];
943 pdata
->chg_desc
->num_charger_regulators
=
944 ARRAY_SIZE(chg_desc_regulator_data
),
945 power_devs
[3].platform_data
= pdata
->chg_desc
;
946 power_devs
[3].pdata_size
= sizeof(*pdata
->chg_desc
);
947 ret
= mfd_add_devices(chip
->dev
, 0, &power_devs
[3], 1,
948 NULL
, chip
->irq_base
, NULL
);
950 dev_err(chip
->dev
, "Failed to add chg-manager subdev\n");
954 static void device_onkey_init(struct pm860x_chip
*chip
,
955 struct pm860x_platform_data
*pdata
)
959 onkey_devs
[0].num_resources
= ARRAY_SIZE(onkey_resources
);
960 onkey_devs
[0].resources
= &onkey_resources
[0],
961 ret
= mfd_add_devices(chip
->dev
, 0, &onkey_devs
[0],
962 ARRAY_SIZE(onkey_devs
), &onkey_resources
[0],
963 chip
->irq_base
, NULL
);
965 dev_err(chip
->dev
, "Failed to add onkey subdev\n");
968 static void device_codec_init(struct pm860x_chip
*chip
,
969 struct pm860x_platform_data
*pdata
)
973 codec_devs
[0].num_resources
= ARRAY_SIZE(codec_resources
);
974 codec_devs
[0].resources
= &codec_resources
[0],
975 ret
= mfd_add_devices(chip
->dev
, 0, &codec_devs
[0],
976 ARRAY_SIZE(codec_devs
), &codec_resources
[0], 0,
979 dev_err(chip
->dev
, "Failed to add codec subdev\n");
982 static void device_8607_init(struct pm860x_chip
*chip
,
983 struct i2c_client
*i2c
,
984 struct pm860x_platform_data
*pdata
)
988 ret
= pm860x_reg_read(i2c
, PM8607_CHIP_ID
);
990 dev_err(chip
->dev
, "Failed to read CHIP ID: %d\n", ret
);
993 switch (ret
& PM8607_VERSION_MASK
) {
996 dev_info(chip
->dev
, "Marvell 88PM8607 (ID: %02x) detected\n",
1000 dev_err(chip
->dev
, "Failed to detect Marvell 88PM8607. "
1001 "Chip ID: %02x\n", ret
);
1005 ret
= pm860x_reg_read(i2c
, PM8607_BUCK3
);
1007 dev_err(chip
->dev
, "Failed to read BUCK3 register: %d\n", ret
);
1010 if (ret
& PM8607_BUCK3_DOUBLE
)
1011 chip
->buck3_double
= 1;
1013 ret
= pm860x_reg_read(i2c
, PM8607_B0_MISC1
);
1015 dev_err(chip
->dev
, "Failed to read MISC1 register: %d\n", ret
);
1019 if (pdata
&& (pdata
->i2c_port
== PI2C_PORT
))
1020 data
= PM8607_B0_MISC1_PI2C
;
1023 ret
= pm860x_set_bits(i2c
, PM8607_B0_MISC1
, PM8607_B0_MISC1_PI2C
, data
);
1025 dev_err(chip
->dev
, "Failed to access MISC1:%d\n", ret
);
1029 ret
= device_irq_init(chip
, pdata
);
1033 device_regulator_init(chip
, pdata
);
1034 device_rtc_init(chip
, pdata
);
1035 device_onkey_init(chip
, pdata
);
1036 device_touch_init(chip
, pdata
);
1037 device_power_init(chip
, pdata
);
1038 device_codec_init(chip
, pdata
);
1043 static void device_8606_init(struct pm860x_chip
*chip
,
1044 struct i2c_client
*i2c
,
1045 struct pm860x_platform_data
*pdata
)
1047 device_osc_init(i2c
);
1048 device_bk_init(chip
, pdata
);
1049 device_led_init(chip
, pdata
);
1052 static int pm860x_device_init(struct pm860x_chip
*chip
,
1053 struct pm860x_platform_data
*pdata
)
1059 device_8606_init(chip
, chip
->client
, pdata
);
1062 device_8607_init(chip
, chip
->client
, pdata
);
1066 if (chip
->companion
) {
1069 device_8606_init(chip
, chip
->companion
, pdata
);
1072 device_8607_init(chip
, chip
->companion
, pdata
);
1080 static void pm860x_device_exit(struct pm860x_chip
*chip
)
1082 device_irq_exit(chip
);
1083 mfd_remove_devices(chip
->dev
);
1086 static int verify_addr(struct i2c_client
*i2c
)
1088 unsigned short addr_8607
[] = {0x30, 0x34};
1089 unsigned short addr_8606
[] = {0x10, 0x11};
1094 size
= ARRAY_SIZE(addr_8606
);
1095 for (i
= 0; i
< size
; i
++) {
1096 if (i2c
->addr
== *(addr_8606
+ i
))
1099 size
= ARRAY_SIZE(addr_8607
);
1100 for (i
= 0; i
< size
; i
++) {
1101 if (i2c
->addr
== *(addr_8607
+ i
))
1107 static struct regmap_config pm860x_regmap_config
= {
1112 static int pm860x_dt_init(struct device_node
*np
,
1114 struct pm860x_platform_data
*pdata
)
1118 if (of_get_property(np
, "marvell,88pm860x-irq-read-clr", NULL
))
1119 pdata
->irq_mode
= 1;
1120 ret
= of_property_read_u32(np
, "marvell,88pm860x-slave-addr",
1121 &pdata
->companion_addr
);
1123 dev_err(dev
, "Not found \"marvell,88pm860x-slave-addr\" "
1125 pdata
->companion_addr
= 0;
1130 static int pm860x_probe(struct i2c_client
*client
,
1131 const struct i2c_device_id
*id
)
1133 struct pm860x_platform_data
*pdata
= client
->dev
.platform_data
;
1134 struct device_node
*node
= client
->dev
.of_node
;
1135 struct pm860x_chip
*chip
;
1138 if (node
&& !pdata
) {
1139 /* parse DT to get platform data */
1140 pdata
= devm_kzalloc(&client
->dev
,
1141 sizeof(struct pm860x_platform_data
),
1145 ret
= pm860x_dt_init(node
, &client
->dev
, pdata
);
1148 } else if (!pdata
) {
1149 pr_info("No platform data in %s!\n", __func__
);
1153 chip
= kzalloc(sizeof(struct pm860x_chip
), GFP_KERNEL
);
1157 chip
->id
= verify_addr(client
);
1158 chip
->regmap
= regmap_init_i2c(client
, &pm860x_regmap_config
);
1159 if (IS_ERR(chip
->regmap
)) {
1160 ret
= PTR_ERR(chip
->regmap
);
1161 dev_err(&client
->dev
, "Failed to allocate register map: %d\n",
1166 chip
->client
= client
;
1167 i2c_set_clientdata(client
, chip
);
1168 chip
->dev
= &client
->dev
;
1169 dev_set_drvdata(chip
->dev
, chip
);
1172 * Both client and companion client shares same platform driver.
1173 * Driver distinguishes them by pdata->companion_addr.
1174 * pdata->companion_addr is only assigned if companion chip exists.
1175 * At the same time, the companion_addr shouldn't equal to client
1178 if (pdata
->companion_addr
&& (pdata
->companion_addr
!= client
->addr
)) {
1179 chip
->companion_addr
= pdata
->companion_addr
;
1180 chip
->companion
= i2c_new_dummy(chip
->client
->adapter
,
1181 chip
->companion_addr
);
1182 chip
->regmap_companion
= regmap_init_i2c(chip
->companion
,
1183 &pm860x_regmap_config
);
1184 if (IS_ERR(chip
->regmap_companion
)) {
1185 ret
= PTR_ERR(chip
->regmap_companion
);
1186 dev_err(&chip
->companion
->dev
,
1187 "Failed to allocate register map: %d\n", ret
);
1190 i2c_set_clientdata(chip
->companion
, chip
);
1193 pm860x_device_init(chip
, pdata
);
1197 static int pm860x_remove(struct i2c_client
*client
)
1199 struct pm860x_chip
*chip
= i2c_get_clientdata(client
);
1201 pm860x_device_exit(chip
);
1202 if (chip
->companion
) {
1203 regmap_exit(chip
->regmap_companion
);
1204 i2c_unregister_device(chip
->companion
);
1206 regmap_exit(chip
->regmap
);
1211 #ifdef CONFIG_PM_SLEEP
1212 static int pm860x_suspend(struct device
*dev
)
1214 struct i2c_client
*client
= container_of(dev
, struct i2c_client
, dev
);
1215 struct pm860x_chip
*chip
= i2c_get_clientdata(client
);
1217 if (device_may_wakeup(dev
) && chip
->wakeup_flag
)
1218 enable_irq_wake(chip
->core_irq
);
1222 static int pm860x_resume(struct device
*dev
)
1224 struct i2c_client
*client
= container_of(dev
, struct i2c_client
, dev
);
1225 struct pm860x_chip
*chip
= i2c_get_clientdata(client
);
1227 if (device_may_wakeup(dev
) && chip
->wakeup_flag
)
1228 disable_irq_wake(chip
->core_irq
);
1233 static SIMPLE_DEV_PM_OPS(pm860x_pm_ops
, pm860x_suspend
, pm860x_resume
);
1235 static const struct i2c_device_id pm860x_id_table
[] = {
1239 MODULE_DEVICE_TABLE(i2c
, pm860x_id_table
);
1241 static const struct of_device_id pm860x_dt_ids
[] = {
1242 { .compatible
= "marvell,88pm860x", },
1245 MODULE_DEVICE_TABLE(of
, pm860x_dt_ids
);
1247 static struct i2c_driver pm860x_driver
= {
1250 .owner
= THIS_MODULE
,
1251 .pm
= &pm860x_pm_ops
,
1252 .of_match_table
= of_match_ptr(pm860x_dt_ids
),
1254 .probe
= pm860x_probe
,
1255 .remove
= pm860x_remove
,
1256 .id_table
= pm860x_id_table
,
1259 static int __init
pm860x_i2c_init(void)
1262 ret
= i2c_add_driver(&pm860x_driver
);
1264 pr_err("Failed to register 88PM860x I2C driver: %d\n", ret
);
1267 subsys_initcall(pm860x_i2c_init
);
1269 static void __exit
pm860x_i2c_exit(void)
1271 i2c_del_driver(&pm860x_driver
);
1273 module_exit(pm860x_i2c_exit
);
1275 MODULE_DESCRIPTION("PMIC Driver for Marvell 88PM860x");
1276 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
1277 MODULE_LICENSE("GPL");