2 * Base driver for Dialog Semiconductor DA9030/DA9034
4 * Copyright (C) 2008 Compulab, Ltd.
5 * Mike Rapoport <mike@compulab.co.il>
7 * Copyright (C) 2006-2008 Marvell International Ltd.
8 * Eric Miao <eric.miao@marvell.com>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/interrupt.h>
18 #include <linux/platform_device.h>
19 #include <linux/i2c.h>
20 #include <linux/mfd/da903x.h>
21 #include <linux/slab.h>
23 #define DA9030_CHIP_ID 0x00
24 #define DA9030_EVENT_A 0x01
25 #define DA9030_EVENT_B 0x02
26 #define DA9030_EVENT_C 0x03
27 #define DA9030_STATUS 0x04
28 #define DA9030_IRQ_MASK_A 0x05
29 #define DA9030_IRQ_MASK_B 0x06
30 #define DA9030_IRQ_MASK_C 0x07
31 #define DA9030_SYS_CTRL_A 0x08
32 #define DA9030_SYS_CTRL_B 0x09
33 #define DA9030_FAULT_LOG 0x0a
35 #define DA9034_CHIP_ID 0x00
36 #define DA9034_EVENT_A 0x01
37 #define DA9034_EVENT_B 0x02
38 #define DA9034_EVENT_C 0x03
39 #define DA9034_EVENT_D 0x04
40 #define DA9034_STATUS_A 0x05
41 #define DA9034_STATUS_B 0x06
42 #define DA9034_IRQ_MASK_A 0x07
43 #define DA9034_IRQ_MASK_B 0x08
44 #define DA9034_IRQ_MASK_C 0x09
45 #define DA9034_IRQ_MASK_D 0x0a
46 #define DA9034_SYS_CTRL_A 0x0b
47 #define DA9034_SYS_CTRL_B 0x0c
48 #define DA9034_FAULT_LOG 0x0d
52 struct da903x_chip_ops
{
53 int (*init_chip
)(struct da903x_chip
*);
54 int (*unmask_events
)(struct da903x_chip
*, unsigned int events
);
55 int (*mask_events
)(struct da903x_chip
*, unsigned int events
);
56 int (*read_events
)(struct da903x_chip
*, unsigned int *events
);
57 int (*read_status
)(struct da903x_chip
*, unsigned int *status
);
61 struct i2c_client
*client
;
63 struct da903x_chip_ops
*ops
;
69 struct work_struct irq_work
;
71 struct blocking_notifier_head notifier_list
;
74 static inline int __da903x_read(struct i2c_client
*client
,
75 int reg
, uint8_t *val
)
79 ret
= i2c_smbus_read_byte_data(client
, reg
);
81 dev_err(&client
->dev
, "failed reading at 0x%02x\n", reg
);
89 static inline int __da903x_reads(struct i2c_client
*client
, int reg
,
90 int len
, uint8_t *val
)
94 ret
= i2c_smbus_read_i2c_block_data(client
, reg
, len
, val
);
96 dev_err(&client
->dev
, "failed reading from 0x%02x\n", reg
);
102 static inline int __da903x_write(struct i2c_client
*client
,
103 int reg
, uint8_t val
)
107 ret
= i2c_smbus_write_byte_data(client
, reg
, val
);
109 dev_err(&client
->dev
, "failed writing 0x%02x to 0x%02x\n",
116 static inline int __da903x_writes(struct i2c_client
*client
, int reg
,
117 int len
, uint8_t *val
)
121 ret
= i2c_smbus_write_i2c_block_data(client
, reg
, len
, val
);
123 dev_err(&client
->dev
, "failed writings to 0x%02x\n", reg
);
129 int da903x_register_notifier(struct device
*dev
, struct notifier_block
*nb
,
132 struct da903x_chip
*chip
= dev_get_drvdata(dev
);
134 chip
->ops
->unmask_events(chip
, events
);
135 return blocking_notifier_chain_register(&chip
->notifier_list
, nb
);
137 EXPORT_SYMBOL_GPL(da903x_register_notifier
);
139 int da903x_unregister_notifier(struct device
*dev
, struct notifier_block
*nb
,
142 struct da903x_chip
*chip
= dev_get_drvdata(dev
);
144 chip
->ops
->mask_events(chip
, events
);
145 return blocking_notifier_chain_unregister(&chip
->notifier_list
, nb
);
147 EXPORT_SYMBOL_GPL(da903x_unregister_notifier
);
149 int da903x_write(struct device
*dev
, int reg
, uint8_t val
)
151 return __da903x_write(to_i2c_client(dev
), reg
, val
);
153 EXPORT_SYMBOL_GPL(da903x_write
);
155 int da903x_writes(struct device
*dev
, int reg
, int len
, uint8_t *val
)
157 return __da903x_writes(to_i2c_client(dev
), reg
, len
, val
);
159 EXPORT_SYMBOL_GPL(da903x_writes
);
161 int da903x_read(struct device
*dev
, int reg
, uint8_t *val
)
163 return __da903x_read(to_i2c_client(dev
), reg
, val
);
165 EXPORT_SYMBOL_GPL(da903x_read
);
167 int da903x_reads(struct device
*dev
, int reg
, int len
, uint8_t *val
)
169 return __da903x_reads(to_i2c_client(dev
), reg
, len
, val
);
171 EXPORT_SYMBOL_GPL(da903x_reads
);
173 int da903x_set_bits(struct device
*dev
, int reg
, uint8_t bit_mask
)
175 struct da903x_chip
*chip
= dev_get_drvdata(dev
);
179 mutex_lock(&chip
->lock
);
181 ret
= __da903x_read(chip
->client
, reg
, ®_val
);
185 if ((reg_val
& bit_mask
) == 0) {
187 ret
= __da903x_write(chip
->client
, reg
, reg_val
);
190 mutex_unlock(&chip
->lock
);
193 EXPORT_SYMBOL_GPL(da903x_set_bits
);
195 int da903x_clr_bits(struct device
*dev
, int reg
, uint8_t bit_mask
)
197 struct da903x_chip
*chip
= dev_get_drvdata(dev
);
201 mutex_lock(&chip
->lock
);
203 ret
= __da903x_read(chip
->client
, reg
, ®_val
);
207 if (reg_val
& bit_mask
) {
208 reg_val
&= ~bit_mask
;
209 ret
= __da903x_write(chip
->client
, reg
, reg_val
);
212 mutex_unlock(&chip
->lock
);
215 EXPORT_SYMBOL_GPL(da903x_clr_bits
);
217 int da903x_update(struct device
*dev
, int reg
, uint8_t val
, uint8_t mask
)
219 struct da903x_chip
*chip
= dev_get_drvdata(dev
);
223 mutex_lock(&chip
->lock
);
225 ret
= __da903x_read(chip
->client
, reg
, ®_val
);
229 if ((reg_val
& mask
) != val
) {
230 reg_val
= (reg_val
& ~mask
) | val
;
231 ret
= __da903x_write(chip
->client
, reg
, reg_val
);
234 mutex_unlock(&chip
->lock
);
237 EXPORT_SYMBOL_GPL(da903x_update
);
239 int da903x_query_status(struct device
*dev
, unsigned int sbits
)
241 struct da903x_chip
*chip
= dev_get_drvdata(dev
);
242 unsigned int status
= 0;
244 chip
->ops
->read_status(chip
, &status
);
245 return ((status
& sbits
) == sbits
);
247 EXPORT_SYMBOL(da903x_query_status
);
249 static int __devinit
da9030_init_chip(struct da903x_chip
*chip
)
254 err
= __da903x_read(chip
->client
, DA9030_CHIP_ID
, &chip_id
);
258 err
= __da903x_write(chip
->client
, DA9030_SYS_CTRL_A
, 0xE8);
262 dev_info(chip
->dev
, "DA9030 (CHIP ID: 0x%02x) detected\n", chip_id
);
266 static int da9030_unmask_events(struct da903x_chip
*chip
, unsigned int events
)
270 chip
->events_mask
&= ~events
;
272 v
[0] = (chip
->events_mask
& 0xff);
273 v
[1] = (chip
->events_mask
>> 8) & 0xff;
274 v
[2] = (chip
->events_mask
>> 16) & 0xff;
276 return __da903x_writes(chip
->client
, DA9030_IRQ_MASK_A
, 3, v
);
279 static int da9030_mask_events(struct da903x_chip
*chip
, unsigned int events
)
283 chip
->events_mask
|= events
;
285 v
[0] = (chip
->events_mask
& 0xff);
286 v
[1] = (chip
->events_mask
>> 8) & 0xff;
287 v
[2] = (chip
->events_mask
>> 16) & 0xff;
289 return __da903x_writes(chip
->client
, DA9030_IRQ_MASK_A
, 3, v
);
292 static int da9030_read_events(struct da903x_chip
*chip
, unsigned int *events
)
294 uint8_t v
[3] = {0, 0, 0};
297 ret
= __da903x_reads(chip
->client
, DA9030_EVENT_A
, 3, v
);
301 *events
= (v
[2] << 16) | (v
[1] << 8) | v
[0];
305 static int da9030_read_status(struct da903x_chip
*chip
, unsigned int *status
)
307 return __da903x_read(chip
->client
, DA9030_STATUS
, (uint8_t *)status
);
310 static int da9034_init_chip(struct da903x_chip
*chip
)
315 err
= __da903x_read(chip
->client
, DA9034_CHIP_ID
, &chip_id
);
319 err
= __da903x_write(chip
->client
, DA9034_SYS_CTRL_A
, 0xE8);
323 /* avoid SRAM power off during sleep*/
324 __da903x_write(chip
->client
, 0x10, 0x07);
325 __da903x_write(chip
->client
, 0x11, 0xff);
326 __da903x_write(chip
->client
, 0x12, 0xff);
328 /* Enable the ONKEY power down functionality */
329 __da903x_write(chip
->client
, DA9034_SYS_CTRL_B
, 0x20);
330 __da903x_write(chip
->client
, DA9034_SYS_CTRL_A
, 0x60);
332 /* workaround to make LEDs work */
333 __da903x_write(chip
->client
, 0x90, 0x01);
334 __da903x_write(chip
->client
, 0xB0, 0x08);
336 /* make ADTV1 and SDTV1 effective */
337 __da903x_write(chip
->client
, 0x20, 0x00);
339 dev_info(chip
->dev
, "DA9034 (CHIP ID: 0x%02x) detected\n", chip_id
);
343 static int da9034_unmask_events(struct da903x_chip
*chip
, unsigned int events
)
347 chip
->events_mask
&= ~events
;
349 v
[0] = (chip
->events_mask
& 0xff);
350 v
[1] = (chip
->events_mask
>> 8) & 0xff;
351 v
[2] = (chip
->events_mask
>> 16) & 0xff;
352 v
[3] = (chip
->events_mask
>> 24) & 0xff;
354 return __da903x_writes(chip
->client
, DA9034_IRQ_MASK_A
, 4, v
);
357 static int da9034_mask_events(struct da903x_chip
*chip
, unsigned int events
)
361 chip
->events_mask
|= events
;
363 v
[0] = (chip
->events_mask
& 0xff);
364 v
[1] = (chip
->events_mask
>> 8) & 0xff;
365 v
[2] = (chip
->events_mask
>> 16) & 0xff;
366 v
[3] = (chip
->events_mask
>> 24) & 0xff;
368 return __da903x_writes(chip
->client
, DA9034_IRQ_MASK_A
, 4, v
);
371 static int da9034_read_events(struct da903x_chip
*chip
, unsigned int *events
)
373 uint8_t v
[4] = {0, 0, 0, 0};
376 ret
= __da903x_reads(chip
->client
, DA9034_EVENT_A
, 4, v
);
380 *events
= (v
[3] << 24) | (v
[2] << 16) | (v
[1] << 8) | v
[0];
384 static int da9034_read_status(struct da903x_chip
*chip
, unsigned int *status
)
386 uint8_t v
[2] = {0, 0};
389 ret
= __da903x_reads(chip
->client
, DA9034_STATUS_A
, 2, v
);
393 *status
= (v
[1] << 8) | v
[0];
397 static void da903x_irq_work(struct work_struct
*work
)
399 struct da903x_chip
*chip
=
400 container_of(work
, struct da903x_chip
, irq_work
);
401 unsigned int events
= 0;
404 if (chip
->ops
->read_events(chip
, &events
))
407 events
&= ~chip
->events_mask
;
411 blocking_notifier_call_chain(
412 &chip
->notifier_list
, events
, NULL
);
414 enable_irq(chip
->client
->irq
);
417 static irqreturn_t
da903x_irq_handler(int irq
, void *data
)
419 struct da903x_chip
*chip
= data
;
421 disable_irq_nosync(irq
);
422 (void)schedule_work(&chip
->irq_work
);
427 static struct da903x_chip_ops da903x_ops
[] = {
429 .init_chip
= da9030_init_chip
,
430 .unmask_events
= da9030_unmask_events
,
431 .mask_events
= da9030_mask_events
,
432 .read_events
= da9030_read_events
,
433 .read_status
= da9030_read_status
,
436 .init_chip
= da9034_init_chip
,
437 .unmask_events
= da9034_unmask_events
,
438 .mask_events
= da9034_mask_events
,
439 .read_events
= da9034_read_events
,
440 .read_status
= da9034_read_status
,
444 static const struct i2c_device_id da903x_id_table
[] = {
449 MODULE_DEVICE_TABLE(i2c
, da903x_id_table
);
451 static int __remove_subdev(struct device
*dev
, void *unused
)
453 platform_device_unregister(to_platform_device(dev
));
457 static int da903x_remove_subdevs(struct da903x_chip
*chip
)
459 return device_for_each_child(chip
->dev
, NULL
, __remove_subdev
);
462 static int __devinit
da903x_add_subdevs(struct da903x_chip
*chip
,
463 struct da903x_platform_data
*pdata
)
465 struct da903x_subdev_info
*subdev
;
466 struct platform_device
*pdev
;
469 for (i
= 0; i
< pdata
->num_subdevs
; i
++) {
470 subdev
= &pdata
->subdevs
[i
];
472 pdev
= platform_device_alloc(subdev
->name
, subdev
->id
);
474 pdev
->dev
.parent
= chip
->dev
;
475 pdev
->dev
.platform_data
= subdev
->platform_data
;
477 ret
= platform_device_add(pdev
);
484 da903x_remove_subdevs(chip
);
488 static int __devinit
da903x_probe(struct i2c_client
*client
,
489 const struct i2c_device_id
*id
)
491 struct da903x_platform_data
*pdata
= client
->dev
.platform_data
;
492 struct da903x_chip
*chip
;
496 chip
= kzalloc(sizeof(struct da903x_chip
), GFP_KERNEL
);
500 chip
->client
= client
;
501 chip
->dev
= &client
->dev
;
502 chip
->ops
= &da903x_ops
[id
->driver_data
];
504 mutex_init(&chip
->lock
);
505 INIT_WORK(&chip
->irq_work
, da903x_irq_work
);
506 BLOCKING_INIT_NOTIFIER_HEAD(&chip
->notifier_list
);
508 i2c_set_clientdata(client
, chip
);
510 ret
= chip
->ops
->init_chip(chip
);
514 /* mask and clear all IRQs */
515 chip
->events_mask
= 0xffffffff;
516 chip
->ops
->mask_events(chip
, chip
->events_mask
);
517 chip
->ops
->read_events(chip
, &tmp
);
519 ret
= request_irq(client
->irq
, da903x_irq_handler
,
520 IRQF_DISABLED
| IRQF_TRIGGER_FALLING
,
523 dev_err(&client
->dev
, "failed to request irq %d\n",
528 ret
= da903x_add_subdevs(chip
, pdata
);
535 free_irq(client
->irq
, chip
);
541 static int __devexit
da903x_remove(struct i2c_client
*client
)
543 struct da903x_chip
*chip
= i2c_get_clientdata(client
);
545 da903x_remove_subdevs(chip
);
550 static struct i2c_driver da903x_driver
= {
553 .owner
= THIS_MODULE
,
555 .probe
= da903x_probe
,
556 .remove
= __devexit_p(da903x_remove
),
557 .id_table
= da903x_id_table
,
560 static int __init
da903x_init(void)
562 return i2c_add_driver(&da903x_driver
);
564 subsys_initcall(da903x_init
);
566 static void __exit
da903x_exit(void)
568 i2c_del_driver(&da903x_driver
);
570 module_exit(da903x_exit
);
572 MODULE_DESCRIPTION("PMIC Driver for Dialog Semiconductor DA9034");
573 MODULE_AUTHOR("Eric Miao <eric.miao@marvell.com>"
574 "Mike Rapoport <mike@compulab.co.il>");
575 MODULE_LICENSE("GPL");