1 /*
2  * Base driver for Dialog Semiconductor DA9030/DA9034
3  *
4  * Copyright (C) 2008 Compulab, Ltd.
5  * 	Mike Rapoport <mike@compulab.co.il>
6  *
7  * Copyright (C) 2006-2008 Marvell International Ltd.
8  * 	Eric Miao <eric.miao@marvell.com>
9  *
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.
13  */
14 
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>
22 
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
34 
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
49 
50 struct da903x_chip;
51 
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);
58 };
59 
60 struct da903x_chip {
61 	struct i2c_client	*client;
62 	struct device		*dev;
63 	struct da903x_chip_ops	*ops;
64 
65 	int			type;
66 	uint32_t		events_mask;
67 
68 	struct mutex		lock;
69 	struct work_struct	irq_work;
70 
71 	struct blocking_notifier_head notifier_list;
72 };
73 
__da903x_read(struct i2c_client * client,int reg,uint8_t * val)74 static inline int __da903x_read(struct i2c_client *client,
75 				int reg, uint8_t *val)
76 {
77 	int ret;
78 
79 	ret = i2c_smbus_read_byte_data(client, reg);
80 	if (ret < 0) {
81 		dev_err(&client->dev, "failed reading at 0x%02x\n", reg);
82 		return ret;
83 	}
84 
85 	*val = (uint8_t)ret;
86 	return 0;
87 }
88 
__da903x_reads(struct i2c_client * client,int reg,int len,uint8_t * val)89 static inline int __da903x_reads(struct i2c_client *client, int reg,
90 				 int len, uint8_t *val)
91 {
92 	int ret;
93 
94 	ret = i2c_smbus_read_i2c_block_data(client, reg, len, val);
95 	if (ret < 0) {
96 		dev_err(&client->dev, "failed reading from 0x%02x\n", reg);
97 		return ret;
98 	}
99 	return 0;
100 }
101 
__da903x_write(struct i2c_client * client,int reg,uint8_t val)102 static inline int __da903x_write(struct i2c_client *client,
103 				 int reg, uint8_t val)
104 {
105 	int ret;
106 
107 	ret = i2c_smbus_write_byte_data(client, reg, val);
108 	if (ret < 0) {
109 		dev_err(&client->dev, "failed writing 0x%02x to 0x%02x\n",
110 				val, reg);
111 		return ret;
112 	}
113 	return 0;
114 }
115 
__da903x_writes(struct i2c_client * client,int reg,int len,uint8_t * val)116 static inline int __da903x_writes(struct i2c_client *client, int reg,
117 				  int len, uint8_t *val)
118 {
119 	int ret;
120 
121 	ret = i2c_smbus_write_i2c_block_data(client, reg, len, val);
122 	if (ret < 0) {
123 		dev_err(&client->dev, "failed writings to 0x%02x\n", reg);
124 		return ret;
125 	}
126 	return 0;
127 }
128 
da903x_register_notifier(struct device * dev,struct notifier_block * nb,unsigned int events)129 int da903x_register_notifier(struct device *dev, struct notifier_block *nb,
130 				unsigned int events)
131 {
132 	struct da903x_chip *chip = dev_get_drvdata(dev);
133 
134 	chip->ops->unmask_events(chip, events);
135 	return blocking_notifier_chain_register(&chip->notifier_list, nb);
136 }
137 EXPORT_SYMBOL_GPL(da903x_register_notifier);
138 
da903x_unregister_notifier(struct device * dev,struct notifier_block * nb,unsigned int events)139 int da903x_unregister_notifier(struct device *dev, struct notifier_block *nb,
140 				unsigned int events)
141 {
142 	struct da903x_chip *chip = dev_get_drvdata(dev);
143 
144 	chip->ops->mask_events(chip, events);
145 	return blocking_notifier_chain_unregister(&chip->notifier_list, nb);
146 }
147 EXPORT_SYMBOL_GPL(da903x_unregister_notifier);
148 
da903x_write(struct device * dev,int reg,uint8_t val)149 int da903x_write(struct device *dev, int reg, uint8_t val)
150 {
151 	return __da903x_write(to_i2c_client(dev), reg, val);
152 }
153 EXPORT_SYMBOL_GPL(da903x_write);
154 
da903x_writes(struct device * dev,int reg,int len,uint8_t * val)155 int da903x_writes(struct device *dev, int reg, int len, uint8_t *val)
156 {
157 	return __da903x_writes(to_i2c_client(dev), reg, len, val);
158 }
159 EXPORT_SYMBOL_GPL(da903x_writes);
160 
da903x_read(struct device * dev,int reg,uint8_t * val)161 int da903x_read(struct device *dev, int reg, uint8_t *val)
162 {
163 	return __da903x_read(to_i2c_client(dev), reg, val);
164 }
165 EXPORT_SYMBOL_GPL(da903x_read);
166 
da903x_reads(struct device * dev,int reg,int len,uint8_t * val)167 int da903x_reads(struct device *dev, int reg, int len, uint8_t *val)
168 {
169 	return __da903x_reads(to_i2c_client(dev), reg, len, val);
170 }
171 EXPORT_SYMBOL_GPL(da903x_reads);
172 
da903x_set_bits(struct device * dev,int reg,uint8_t bit_mask)173 int da903x_set_bits(struct device *dev, int reg, uint8_t bit_mask)
174 {
175 	struct da903x_chip *chip = dev_get_drvdata(dev);
176 	uint8_t reg_val;
177 	int ret = 0;
178 
179 	mutex_lock(&chip->lock);
180 
181 	ret = __da903x_read(chip->client, reg, &reg_val);
182 	if (ret)
183 		goto out;
184 
185 	if ((reg_val & bit_mask) == 0) {
186 		reg_val |= bit_mask;
187 		ret = __da903x_write(chip->client, reg, reg_val);
188 	}
189 out:
190 	mutex_unlock(&chip->lock);
191 	return ret;
192 }
193 EXPORT_SYMBOL_GPL(da903x_set_bits);
194 
da903x_clr_bits(struct device * dev,int reg,uint8_t bit_mask)195 int da903x_clr_bits(struct device *dev, int reg, uint8_t bit_mask)
196 {
197 	struct da903x_chip *chip = dev_get_drvdata(dev);
198 	uint8_t reg_val;
199 	int ret = 0;
200 
201 	mutex_lock(&chip->lock);
202 
203 	ret = __da903x_read(chip->client, reg, &reg_val);
204 	if (ret)
205 		goto out;
206 
207 	if (reg_val & bit_mask) {
208 		reg_val &= ~bit_mask;
209 		ret = __da903x_write(chip->client, reg, reg_val);
210 	}
211 out:
212 	mutex_unlock(&chip->lock);
213 	return ret;
214 }
215 EXPORT_SYMBOL_GPL(da903x_clr_bits);
216 
da903x_update(struct device * dev,int reg,uint8_t val,uint8_t mask)217 int da903x_update(struct device *dev, int reg, uint8_t val, uint8_t mask)
218 {
219 	struct da903x_chip *chip = dev_get_drvdata(dev);
220 	uint8_t reg_val;
221 	int ret = 0;
222 
223 	mutex_lock(&chip->lock);
224 
225 	ret = __da903x_read(chip->client, reg, &reg_val);
226 	if (ret)
227 		goto out;
228 
229 	if ((reg_val & mask) != val) {
230 		reg_val = (reg_val & ~mask) | val;
231 		ret = __da903x_write(chip->client, reg, reg_val);
232 	}
233 out:
234 	mutex_unlock(&chip->lock);
235 	return ret;
236 }
237 EXPORT_SYMBOL_GPL(da903x_update);
238 
da903x_query_status(struct device * dev,unsigned int sbits)239 int da903x_query_status(struct device *dev, unsigned int sbits)
240 {
241 	struct da903x_chip *chip = dev_get_drvdata(dev);
242 	unsigned int status = 0;
243 
244 	chip->ops->read_status(chip, &status);
245 	return ((status & sbits) == sbits);
246 }
247 EXPORT_SYMBOL(da903x_query_status);
248 
da9030_init_chip(struct da903x_chip * chip)249 static int __devinit da9030_init_chip(struct da903x_chip *chip)
250 {
251 	uint8_t chip_id;
252 	int err;
253 
254 	err = __da903x_read(chip->client, DA9030_CHIP_ID, &chip_id);
255 	if (err)
256 		return err;
257 
258 	err = __da903x_write(chip->client, DA9030_SYS_CTRL_A, 0xE8);
259 	if (err)
260 		return err;
261 
262 	dev_info(chip->dev, "DA9030 (CHIP ID: 0x%02x) detected\n", chip_id);
263 	return 0;
264 }
265 
da9030_unmask_events(struct da903x_chip * chip,unsigned int events)266 static int da9030_unmask_events(struct da903x_chip *chip, unsigned int events)
267 {
268 	uint8_t v[3];
269 
270 	chip->events_mask &= ~events;
271 
272 	v[0] = (chip->events_mask & 0xff);
273 	v[1] = (chip->events_mask >> 8) & 0xff;
274 	v[2] = (chip->events_mask >> 16) & 0xff;
275 
276 	return __da903x_writes(chip->client, DA9030_IRQ_MASK_A, 3, v);
277 }
278 
da9030_mask_events(struct da903x_chip * chip,unsigned int events)279 static int da9030_mask_events(struct da903x_chip *chip, unsigned int events)
280 {
281 	uint8_t v[3];
282 
283 	chip->events_mask |= events;
284 
285 	v[0] = (chip->events_mask & 0xff);
286 	v[1] = (chip->events_mask >> 8) & 0xff;
287 	v[2] = (chip->events_mask >> 16) & 0xff;
288 
289 	return __da903x_writes(chip->client, DA9030_IRQ_MASK_A, 3, v);
290 }
291 
da9030_read_events(struct da903x_chip * chip,unsigned int * events)292 static int da9030_read_events(struct da903x_chip *chip, unsigned int *events)
293 {
294 	uint8_t v[3] = {0, 0, 0};
295 	int ret;
296 
297 	ret = __da903x_reads(chip->client, DA9030_EVENT_A, 3, v);
298 	if (ret < 0)
299 		return ret;
300 
301 	*events = (v[2] << 16) | (v[1] << 8) | v[0];
302 	return 0;
303 }
304 
da9030_read_status(struct da903x_chip * chip,unsigned int * status)305 static int da9030_read_status(struct da903x_chip *chip, unsigned int *status)
306 {
307 	return __da903x_read(chip->client, DA9030_STATUS, (uint8_t *)status);
308 }
309 
da9034_init_chip(struct da903x_chip * chip)310 static int da9034_init_chip(struct da903x_chip *chip)
311 {
312 	uint8_t chip_id;
313 	int err;
314 
315 	err = __da903x_read(chip->client, DA9034_CHIP_ID, &chip_id);
316 	if (err)
317 		return err;
318 
319 	err = __da903x_write(chip->client, DA9034_SYS_CTRL_A, 0xE8);
320 	if (err)
321 		return err;
322 
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);
327 
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);
331 
332 	/* workaround to make LEDs work */
333 	__da903x_write(chip->client, 0x90, 0x01);
334 	__da903x_write(chip->client, 0xB0, 0x08);
335 
336 	/* make ADTV1 and SDTV1 effective */
337 	__da903x_write(chip->client, 0x20, 0x00);
338 
339 	dev_info(chip->dev, "DA9034 (CHIP ID: 0x%02x) detected\n", chip_id);
340 	return 0;
341 }
342 
da9034_unmask_events(struct da903x_chip * chip,unsigned int events)343 static int da9034_unmask_events(struct da903x_chip *chip, unsigned int events)
344 {
345 	uint8_t v[4];
346 
347 	chip->events_mask &= ~events;
348 
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;
353 
354 	return __da903x_writes(chip->client, DA9034_IRQ_MASK_A, 4, v);
355 }
356 
da9034_mask_events(struct da903x_chip * chip,unsigned int events)357 static int da9034_mask_events(struct da903x_chip *chip, unsigned int events)
358 {
359 	uint8_t v[4];
360 
361 	chip->events_mask |= events;
362 
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;
367 
368 	return __da903x_writes(chip->client, DA9034_IRQ_MASK_A, 4, v);
369 }
370 
da9034_read_events(struct da903x_chip * chip,unsigned int * events)371 static int da9034_read_events(struct da903x_chip *chip, unsigned int *events)
372 {
373 	uint8_t v[4] = {0, 0, 0, 0};
374 	int ret;
375 
376 	ret = __da903x_reads(chip->client, DA9034_EVENT_A, 4, v);
377 	if (ret < 0)
378 		return ret;
379 
380 	*events = (v[3] << 24) | (v[2] << 16) | (v[1] << 8) | v[0];
381 	return 0;
382 }
383 
da9034_read_status(struct da903x_chip * chip,unsigned int * status)384 static int da9034_read_status(struct da903x_chip *chip, unsigned int *status)
385 {
386 	uint8_t v[2] = {0, 0};
387 	int ret = 0;
388 
389 	ret = __da903x_reads(chip->client, DA9034_STATUS_A, 2, v);
390 	if (ret)
391 		return ret;
392 
393 	*status = (v[1] << 8) | v[0];
394 	return 0;
395 }
396 
da903x_irq_work(struct work_struct * work)397 static void da903x_irq_work(struct work_struct *work)
398 {
399 	struct da903x_chip *chip =
400 		container_of(work, struct da903x_chip, irq_work);
401 	unsigned int events = 0;
402 
403 	while (1) {
404 		if (chip->ops->read_events(chip, &events))
405 			break;
406 
407 		events &= ~chip->events_mask;
408 		if (events == 0)
409 			break;
410 
411 		blocking_notifier_call_chain(
412 				&chip->notifier_list, events, NULL);
413 	}
414 	enable_irq(chip->client->irq);
415 }
416 
da903x_irq_handler(int irq,void * data)417 static irqreturn_t da903x_irq_handler(int irq, void *data)
418 {
419 	struct da903x_chip *chip = data;
420 
421 	disable_irq_nosync(irq);
422 	(void)schedule_work(&chip->irq_work);
423 
424 	return IRQ_HANDLED;
425 }
426 
427 static struct da903x_chip_ops da903x_ops[] = {
428 	[0] = {
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,
434 	},
435 	[1] = {
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,
441 	}
442 };
443 
444 static const struct i2c_device_id da903x_id_table[] = {
445 	{ "da9030", 0 },
446 	{ "da9034", 1 },
447 	{ },
448 };
449 MODULE_DEVICE_TABLE(i2c, da903x_id_table);
450 
__remove_subdev(struct device * dev,void * unused)451 static int __remove_subdev(struct device *dev, void *unused)
452 {
453 	platform_device_unregister(to_platform_device(dev));
454 	return 0;
455 }
456 
da903x_remove_subdevs(struct da903x_chip * chip)457 static int da903x_remove_subdevs(struct da903x_chip *chip)
458 {
459 	return device_for_each_child(chip->dev, NULL, __remove_subdev);
460 }
461 
da903x_add_subdevs(struct da903x_chip * chip,struct da903x_platform_data * pdata)462 static int __devinit da903x_add_subdevs(struct da903x_chip *chip,
463 					struct da903x_platform_data *pdata)
464 {
465 	struct da903x_subdev_info *subdev;
466 	struct platform_device *pdev;
467 	int i, ret = 0;
468 
469 	for (i = 0; i < pdata->num_subdevs; i++) {
470 		subdev = &pdata->subdevs[i];
471 
472 		pdev = platform_device_alloc(subdev->name, subdev->id);
473 		if (!pdev) {
474 			ret = -ENOMEM;
475 			goto failed;
476 		}
477 
478 		pdev->dev.parent = chip->dev;
479 		pdev->dev.platform_data = subdev->platform_data;
480 
481 		ret = platform_device_add(pdev);
482 		if (ret) {
483 			platform_device_put(pdev);
484 			goto failed;
485 		}
486 	}
487 	return 0;
488 
489 failed:
490 	da903x_remove_subdevs(chip);
491 	return ret;
492 }
493 
da903x_probe(struct i2c_client * client,const struct i2c_device_id * id)494 static int __devinit da903x_probe(struct i2c_client *client,
495 				  const struct i2c_device_id *id)
496 {
497 	struct da903x_platform_data *pdata = client->dev.platform_data;
498 	struct da903x_chip *chip;
499 	unsigned int tmp;
500 	int ret;
501 
502 	chip = kzalloc(sizeof(struct da903x_chip), GFP_KERNEL);
503 	if (chip == NULL)
504 		return -ENOMEM;
505 
506 	chip->client = client;
507 	chip->dev = &client->dev;
508 	chip->ops = &da903x_ops[id->driver_data];
509 
510 	mutex_init(&chip->lock);
511 	INIT_WORK(&chip->irq_work, da903x_irq_work);
512 	BLOCKING_INIT_NOTIFIER_HEAD(&chip->notifier_list);
513 
514 	i2c_set_clientdata(client, chip);
515 
516 	ret = chip->ops->init_chip(chip);
517 	if (ret)
518 		goto out_free_chip;
519 
520 	/* mask and clear all IRQs */
521 	chip->events_mask = 0xffffffff;
522 	chip->ops->mask_events(chip, chip->events_mask);
523 	chip->ops->read_events(chip, &tmp);
524 
525 	ret = request_irq(client->irq, da903x_irq_handler,
526 			IRQF_DISABLED | IRQF_TRIGGER_FALLING,
527 			"da903x", chip);
528 	if (ret) {
529 		dev_err(&client->dev, "failed to request irq %d\n",
530 				client->irq);
531 		goto out_free_chip;
532 	}
533 
534 	ret = da903x_add_subdevs(chip, pdata);
535 	if (ret)
536 		goto out_free_irq;
537 
538 	return 0;
539 
540 out_free_irq:
541 	free_irq(client->irq, chip);
542 out_free_chip:
543 	kfree(chip);
544 	return ret;
545 }
546 
da903x_remove(struct i2c_client * client)547 static int __devexit da903x_remove(struct i2c_client *client)
548 {
549 	struct da903x_chip *chip = i2c_get_clientdata(client);
550 
551 	da903x_remove_subdevs(chip);
552 	kfree(chip);
553 	return 0;
554 }
555 
556 static struct i2c_driver da903x_driver = {
557 	.driver	= {
558 		.name	= "da903x",
559 		.owner	= THIS_MODULE,
560 	},
561 	.probe		= da903x_probe,
562 	.remove		= __devexit_p(da903x_remove),
563 	.id_table	= da903x_id_table,
564 };
565 
da903x_init(void)566 static int __init da903x_init(void)
567 {
568 	return i2c_add_driver(&da903x_driver);
569 }
570 subsys_initcall(da903x_init);
571 
da903x_exit(void)572 static void __exit da903x_exit(void)
573 {
574 	i2c_del_driver(&da903x_driver);
575 }
576 module_exit(da903x_exit);
577 
578 MODULE_DESCRIPTION("PMIC Driver for Dialog Semiconductor DA9034");
579 MODULE_AUTHOR("Eric Miao <eric.miao@marvell.com>"
580 	      "Mike Rapoport <mike@compulab.co.il>");
581 MODULE_LICENSE("GPL");
582