[linux.git] / drivers / mfd / da903x.c

/*
 * Base driver for Dialog Semiconductor DA9030/DA9034
 *
 * Copyright (C) 2008 Compulab, Ltd.
 *	Mike Rapoport <[email protected]>
 *
 * Copyright (C) 2006-2008 Marvell International Ltd.
 *	Eric Miao <[email protected]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/i2c.h>
#include <linux/mfd/da903x.h>
#include <linux/slab.h>

#define DA9030_CHIP_ID		0x00
#define DA9030_EVENT_A		0x01
#define DA9030_EVENT_B		0x02
#define DA9030_EVENT_C		0x03
#define DA9030_STATUS		0x04
#define DA9030_IRQ_MASK_A	0x05
#define DA9030_IRQ_MASK_B	0x06
#define DA9030_IRQ_MASK_C	0x07
#define DA9030_SYS_CTRL_A	0x08
#define DA9030_SYS_CTRL_B	0x09
#define DA9030_FAULT_LOG	0x0a

#define DA9034_CHIP_ID		0x00
#define DA9034_EVENT_A		0x01
#define DA9034_EVENT_B		0x02
#define DA9034_EVENT_C		0x03
#define DA9034_EVENT_D		0x04
#define DA9034_STATUS_A		0x05
#define DA9034_STATUS_B		0x06
#define DA9034_IRQ_MASK_A	0x07
#define DA9034_IRQ_MASK_B	0x08
#define DA9034_IRQ_MASK_C	0x09
#define DA9034_IRQ_MASK_D	0x0a
#define DA9034_SYS_CTRL_A	0x0b
#define DA9034_SYS_CTRL_B	0x0c
#define DA9034_FAULT_LOG	0x0d

struct da903x_chip;

struct da903x_chip_ops {
	int	(*init_chip)(struct da903x_chip *);
	int	(*unmask_events)(struct da903x_chip *, unsigned int events);
	int	(*mask_events)(struct da903x_chip *, unsigned int events);
	int	(*read_events)(struct da903x_chip *, unsigned int *events);
	int	(*read_status)(struct da903x_chip *, unsigned int *status);
};

struct da903x_chip {
	struct i2c_client	*client;
	struct device		*dev;
	const struct da903x_chip_ops *ops;

	int			type;
	uint32_t		events_mask;

	struct mutex		lock;
	struct work_struct	irq_work;

	struct blocking_notifier_head notifier_list;
};

static inline int __da903x_read(struct i2c_client *client,
				int reg, uint8_t *val)
{
	int ret;

	ret = i2c_smbus_read_byte_data(client, reg);
	if (ret < 0) {
		dev_err(&client->dev, "failed reading at 0x%02x\n", reg);
		return ret;
	}

	*val = (uint8_t)ret;
	return 0;
}

static inline int __da903x_reads(struct i2c_client *client, int reg,
				 int len, uint8_t *val)
{
	int ret;

	ret = i2c_smbus_read_i2c_block_data(client, reg, len, val);
	if (ret < 0) {
		dev_err(&client->dev, "failed reading from 0x%02x\n", reg);
		return ret;
	}
	return 0;
}

static inline int __da903x_write(struct i2c_client *client,
				 int reg, uint8_t val)
{
	int ret;

	ret = i2c_smbus_write_byte_data(client, reg, val);
	if (ret < 0) {
		dev_err(&client->dev, "failed writing 0x%02x to 0x%02x\n",
				val, reg);
		return ret;
	}
	return 0;
}

static inline int __da903x_writes(struct i2c_client *client, int reg,
				  int len, uint8_t *val)
{
	int ret;

	ret = i2c_smbus_write_i2c_block_data(client, reg, len, val);
	if (ret < 0) {
		dev_err(&client->dev, "failed writings to 0x%02x\n", reg);
		return ret;
	}
	return 0;
}

int da903x_register_notifier(struct device *dev, struct notifier_block *nb,
				unsigned int events)
{
	struct da903x_chip *chip = dev_get_drvdata(dev);

	chip->ops->unmask_events(chip, events);
	return blocking_notifier_chain_register(&chip->notifier_list, nb);
}
EXPORT_SYMBOL_GPL(da903x_register_notifier);

int da903x_unregister_notifier(struct device *dev, struct notifier_block *nb,
				unsigned int events)
{
	struct da903x_chip *chip = dev_get_drvdata(dev);

	chip->ops->mask_events(chip, events);
	return blocking_notifier_chain_unregister(&chip->notifier_list, nb);
}
EXPORT_SYMBOL_GPL(da903x_unregister_notifier);

int da903x_write(struct device *dev, int reg, uint8_t val)
{
	return __da903x_write(to_i2c_client(dev), reg, val);
}
EXPORT_SYMBOL_GPL(da903x_write);

int da903x_writes(struct device *dev, int reg, int len, uint8_t *val)
{
	return __da903x_writes(to_i2c_client(dev), reg, len, val);
}
EXPORT_SYMBOL_GPL(da903x_writes);

int da903x_read(struct device *dev, int reg, uint8_t *val)
{
	return __da903x_read(to_i2c_client(dev), reg, val);
}
EXPORT_SYMBOL_GPL(da903x_read);

int da903x_reads(struct device *dev, int reg, int len, uint8_t *val)
{
	return __da903x_reads(to_i2c_client(dev), reg, len, val);
}
EXPORT_SYMBOL_GPL(da903x_reads);

int da903x_set_bits(struct device *dev, int reg, uint8_t bit_mask)
{
	struct da903x_chip *chip = dev_get_drvdata(dev);
	uint8_t reg_val;
	int ret = 0;

	mutex_lock(&chip->lock);

	ret = __da903x_read(chip->client, reg, &reg_val);
	if (ret)
		goto out;

	if ((reg_val & bit_mask) != bit_mask) {
		reg_val |= bit_mask;
		ret = __da903x_write(chip->client, reg, reg_val);
	}
out:
	mutex_unlock(&chip->lock);
	return ret;
}
EXPORT_SYMBOL_GPL(da903x_set_bits);

int da903x_clr_bits(struct device *dev, int reg, uint8_t bit_mask)
{
	struct da903x_chip *chip = dev_get_drvdata(dev);
	uint8_t reg_val;
	int ret = 0;

	mutex_lock(&chip->lock);

	ret = __da903x_read(chip->client, reg, &reg_val);
	if (ret)
		goto out;

	if (reg_val & bit_mask) {
		reg_val &= ~bit_mask;
		ret = __da903x_write(chip->client, reg, reg_val);
	}
out:
	mutex_unlock(&chip->lock);
	return ret;
}
EXPORT_SYMBOL_GPL(da903x_clr_bits);

int da903x_update(struct device *dev, int reg, uint8_t val, uint8_t mask)
{
	struct da903x_chip *chip = dev_get_drvdata(dev);
	uint8_t reg_val;
	int ret = 0;

	mutex_lock(&chip->lock);

	ret = __da903x_read(chip->client, reg, &reg_val);
	if (ret)
		goto out;

	if ((reg_val & mask) != val) {
		reg_val = (reg_val & ~mask) | val;
		ret = __da903x_write(chip->client, reg, reg_val);
	}
out:
	mutex_unlock(&chip->lock);
	return ret;
}
EXPORT_SYMBOL_GPL(da903x_update);

int da903x_query_status(struct device *dev, unsigned int sbits)
{
	struct da903x_chip *chip = dev_get_drvdata(dev);
	unsigned int status = 0;

	chip->ops->read_status(chip, &status);
	return ((status & sbits) == sbits);
}
EXPORT_SYMBOL(da903x_query_status);

static int da9030_init_chip(struct da903x_chip *chip)
{
	uint8_t chip_id;
	int err;

	err = __da903x_read(chip->client, DA9030_CHIP_ID, &chip_id);
	if (err)
		return err;

	err = __da903x_write(chip->client, DA9030_SYS_CTRL_A, 0xE8);
	if (err)
		return err;

	dev_info(chip->dev, "DA9030 (CHIP ID: 0x%02x) detected\n", chip_id);
	return 0;
}

static int da9030_unmask_events(struct da903x_chip *chip, unsigned int events)
{
	uint8_t v[3];

	chip->events_mask &= ~events;

	v[0] = (chip->events_mask & 0xff);
	v[1] = (chip->events_mask >> 8) & 0xff;
	v[2] = (chip->events_mask >> 16) & 0xff;

	return __da903x_writes(chip->client, DA9030_IRQ_MASK_A, 3, v);
}

static int da9030_mask_events(struct da903x_chip *chip, unsigned int events)
{
	uint8_t v[3];

	chip->events_mask |= events;

	v[0] = (chip->events_mask & 0xff);
	v[1] = (chip->events_mask >> 8) & 0xff;
	v[2] = (chip->events_mask >> 16) & 0xff;

	return __da903x_writes(chip->client, DA9030_IRQ_MASK_A, 3, v);
}

static int da9030_read_events(struct da903x_chip *chip, unsigned int *events)
{
	uint8_t v[3] = {0, 0, 0};
	int ret;

	ret = __da903x_reads(chip->client, DA9030_EVENT_A, 3, v);
	if (ret < 0)
		return ret;

	*events = (v[2] << 16) | (v[1] << 8) | v[0];
	return 0;
}

static int da9030_read_status(struct da903x_chip *chip, unsigned int *status)
{
	return __da903x_read(chip->client, DA9030_STATUS, (uint8_t *)status);
}

static int da9034_init_chip(struct da903x_chip *chip)
{
	uint8_t chip_id;
	int err;

	err = __da903x_read(chip->client, DA9034_CHIP_ID, &chip_id);
	if (err)
		return err;

	err = __da903x_write(chip->client, DA9034_SYS_CTRL_A, 0xE8);
	if (err)
		return err;

	/* avoid SRAM power off during sleep*/
	__da903x_write(chip->client, 0x10, 0x07);
	__da903x_write(chip->client, 0x11, 0xff);
	__da903x_write(chip->client, 0x12, 0xff);

	/* Enable the ONKEY power down functionality */
	__da903x_write(chip->client, DA9034_SYS_CTRL_B, 0x20);
	__da903x_write(chip->client, DA9034_SYS_CTRL_A, 0x60);

	/* workaround to make LEDs work */
	__da903x_write(chip->client, 0x90, 0x01);
	__da903x_write(chip->client, 0xB0, 0x08);

	/* make ADTV1 and SDTV1 effective */
	__da903x_write(chip->client, 0x20, 0x00);

	dev_info(chip->dev, "DA9034 (CHIP ID: 0x%02x) detected\n", chip_id);
	return 0;
}

static int da9034_unmask_events(struct da903x_chip *chip, unsigned int events)
{
	uint8_t v[4];

	chip->events_mask &= ~events;

	v[0] = (chip->events_mask & 0xff);
	v[1] = (chip->events_mask >> 8) & 0xff;
	v[2] = (chip->events_mask >> 16) & 0xff;
	v[3] = (chip->events_mask >> 24) & 0xff;

	return __da903x_writes(chip->client, DA9034_IRQ_MASK_A, 4, v);
}

static int da9034_mask_events(struct da903x_chip *chip, unsigned int events)
{
	uint8_t v[4];

	chip->events_mask |= events;

	v[0] = (chip->events_mask & 0xff);
	v[1] = (chip->events_mask >> 8) & 0xff;
	v[2] = (chip->events_mask >> 16) & 0xff;
	v[3] = (chip->events_mask >> 24) & 0xff;

	return __da903x_writes(chip->client, DA9034_IRQ_MASK_A, 4, v);
}

static int da9034_read_events(struct da903x_chip *chip, unsigned int *events)
{
	uint8_t v[4] = {0, 0, 0, 0};
	int ret;

	ret = __da903x_reads(chip->client, DA9034_EVENT_A, 4, v);
	if (ret < 0)
		return ret;

	*events = (v[3] << 24) | (v[2] << 16) | (v[1] << 8) | v[0];
	return 0;
}

static int da9034_read_status(struct da903x_chip *chip, unsigned int *status)
{
	uint8_t v[2] = {0, 0};
	int ret = 0;

	ret = __da903x_reads(chip->client, DA9034_STATUS_A, 2, v);
	if (ret)
		return ret;

	*status = (v[1] << 8) | v[0];
	return 0;
}

static void da903x_irq_work(struct work_struct *work)
{
	struct da903x_chip *chip =
		container_of(work, struct da903x_chip, irq_work);
	unsigned int events = 0;

	while (1) {
		if (chip->ops->read_events(chip, &events))
			break;

		events &= ~chip->events_mask;
		if (events == 0)
			break;

		blocking_notifier_call_chain(
				&chip->notifier_list, events, NULL);
	}
	enable_irq(chip->client->irq);
}

static irqreturn_t da903x_irq_handler(int irq, void *data)
{
	struct da903x_chip *chip = data;

	disable_irq_nosync(irq);
	(void)schedule_work(&chip->irq_work);

	return IRQ_HANDLED;
}

static const struct da903x_chip_ops da903x_ops[] = {
	[0] = {
		.init_chip	= da9030_init_chip,
		.unmask_events	= da9030_unmask_events,
		.mask_events	= da9030_mask_events,
		.read_events	= da9030_read_events,
		.read_status	= da9030_read_status,
	},
	[1] = {
		.init_chip	= da9034_init_chip,
		.unmask_events	= da9034_unmask_events,
		.mask_events	= da9034_mask_events,
		.read_events	= da9034_read_events,
		.read_status	= da9034_read_status,
	}
};

static const struct i2c_device_id da903x_id_table[] = {
	{ "da9030", 0 },
	{ "da9034", 1 },
	{ },
};
MODULE_DEVICE_TABLE(i2c, da903x_id_table);

static int __remove_subdev(struct device *dev, void *unused)
{
	platform_device_unregister(to_platform_device(dev));
	return 0;
}

static int da903x_remove_subdevs(struct da903x_chip *chip)
{
	return device_for_each_child(chip->dev, NULL, __remove_subdev);
}

static int da903x_add_subdevs(struct da903x_chip *chip,
					struct da903x_platform_data *pdata)
{
	struct da903x_subdev_info *subdev;
	struct platform_device *pdev;
	int i, ret = 0;

	for (i = 0; i < pdata->num_subdevs; i++) {
		subdev = &pdata->subdevs[i];

		pdev = platform_device_alloc(subdev->name, subdev->id);
		if (!pdev) {
			ret = -ENOMEM;
			goto failed;
		}

		pdev->dev.parent = chip->dev;
		pdev->dev.platform_data = subdev->platform_data;

		ret = platform_device_add(pdev);
		if (ret) {
			platform_device_put(pdev);
			goto failed;
		}
	}
	return 0;

failed:
	da903x_remove_subdevs(chip);
	return ret;
}

static int da903x_probe(struct i2c_client *client,
				  const struct i2c_device_id *id)
{
	struct da903x_platform_data *pdata = dev_get_platdata(&client->dev);
	struct da903x_chip *chip;
	unsigned int tmp;
	int ret;

	chip = devm_kzalloc(&client->dev, sizeof(struct da903x_chip),
				GFP_KERNEL);
	if (chip == NULL)
		return -ENOMEM;

	chip->client = client;
	chip->dev = &client->dev;
	chip->ops = &da903x_ops[id->driver_data];

	mutex_init(&chip->lock);
	INIT_WORK(&chip->irq_work, da903x_irq_work);
	BLOCKING_INIT_NOTIFIER_HEAD(&chip->notifier_list);

	i2c_set_clientdata(client, chip);

	ret = chip->ops->init_chip(chip);
	if (ret)
		return ret;

	/* mask and clear all IRQs */
	chip->events_mask = 0xffffffff;
	chip->ops->mask_events(chip, chip->events_mask);
	chip->ops->read_events(chip, &tmp);

	ret = devm_request_irq(&client->dev, client->irq, da903x_irq_handler,
			IRQF_TRIGGER_FALLING,
			"da903x", chip);
	if (ret) {
		dev_err(&client->dev, "failed to request irq %d\n",
				client->irq);
		return ret;
	}

	return da903x_add_subdevs(chip, pdata);
}

static int da903x_remove(struct i2c_client *client)
{
	struct da903x_chip *chip = i2c_get_clientdata(client);

	da903x_remove_subdevs(chip);
	return 0;
}

static struct i2c_driver da903x_driver = {
	.driver	= {
		.name	= "da903x",
	},
	.probe		= da903x_probe,
	.remove		= da903x_remove,
	.id_table	= da903x_id_table,
};

static int __init da903x_init(void)
{
	return i2c_add_driver(&da903x_driver);
}
subsys_initcall(da903x_init);

static void __exit da903x_exit(void)
{
	i2c_del_driver(&da903x_driver);
}
module_exit(da903x_exit);

MODULE_DESCRIPTION("PMIC Driver for Dialog Semiconductor DA9034");
MODULE_AUTHOR("Eric Miao <[email protected]>");
MODULE_AUTHOR("Mike Rapoport <[email protected]>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
26b8f5e1 EM	1	/*
	2	* Base driver for Dialog Semiconductor DA9030/DA9034
	3	*
	4	* Copyright (C) 2008 Compulab, Ltd.
8b277578	5	* Mike Rapoport <[email protected]>
26b8f5e1 EM	6	*
26b8f5e1 EM	7	* Copyright (C) 2006-2008 Marvell International Ltd.
8b277578	8	* Eric Miao <[email protected]>
26b8f5e1 EM	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>
5a0e3ad6	21	#include <linux/slab.h>
26b8f5e1 EM	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;
f83e7d81	63	const struct da903x_chip_ops *ops;
26b8f5e1 EM	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
	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
	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
	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
	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
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
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
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
856f6fd1 MR	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
26b8f5e1 EM	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
856f6fd1 MR	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
26b8f5e1 EM	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
af65e6ce	185	if ((reg_val & bit_mask) != bit_mask) {
26b8f5e1 EM	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
	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
	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
	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
f791be49	249	static int da9030_init_chip(struct da903x_chip *chip)
26b8f5e1 EM	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
	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
	279	static int da9030_mask_events(struct da903x_chip *chip, unsigned int events)
	280	{
	281	uint8_t v[3];
	282
b1ccbdc4	283	chip->events_mask \|= events;
26b8f5e1 EM	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
	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
	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
	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
	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
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
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
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
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
fa15ce8a	417	static irqreturn_t da903x_irq_handler(int irq, void *data)
26b8f5e1 EM	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
f83e7d81	427	static const struct da903x_chip_ops da903x_ops[] = {
26b8f5e1 EM	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
3f874b66	451	static int __remove_subdev(struct device dev, void unused)
26b8f5e1 EM	452	{
	453	platform_device_unregister(to_platform_device(dev));
	454	return 0;
	455	}
	456
3f874b66	457	static int da903x_remove_subdevs(struct da903x_chip *chip)
26b8f5e1 EM	458	{
	459	return device_for_each_child(chip->dev, NULL, __remove_subdev);
	460	}
	461
f791be49	462	static int da903x_add_subdevs(struct da903x_chip *chip,
26b8f5e1 EM	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);
b59cedef AL	473	if (!pdev) {
	474	ret = -ENOMEM;
	475	goto failed;
	476	}
26b8f5e1 EM	477
	478	pdev->dev.parent = chip->dev;
	479	pdev->dev.platform_data = subdev->platform_data;
	480
	481	ret = platform_device_add(pdev);
b59cedef AL	482	if (ret) {
b59cedef AL	483	platform_device_put(pdev);
26b8f5e1	484	goto failed;
b59cedef	485	}
26b8f5e1 EM	486	}
	487	return 0;
	488
	489	failed:
	490	da903x_remove_subdevs(chip);
	491	return ret;
	492	}
	493
f791be49	494	static int da903x_probe(struct i2c_client *client,
26b8f5e1 EM	495	const struct i2c_device_id *id)
26b8f5e1 EM	496	{
334a41ce	497	struct da903x_platform_data *pdata = dev_get_platdata(&client->dev);
26b8f5e1 EM	498	struct da903x_chip *chip;
	499	unsigned int tmp;
	500	int ret;
	501
aa4dcf5b JH	502	chip = devm_kzalloc(&client->dev, sizeof(struct da903x_chip),
aa4dcf5b JH	503	GFP_KERNEL);
26b8f5e1 EM	504	if (chip == NULL)
	505	return -ENOMEM;
	506
	507	chip->client = client;
	508	chip->dev = &client->dev;
	509	chip->ops = &da903x_ops[id->driver_data];
	510
	511	mutex_init(&chip->lock);
	512	INIT_WORK(&chip->irq_work, da903x_irq_work);
	513	BLOCKING_INIT_NOTIFIER_HEAD(&chip->notifier_list);
	514
	515	i2c_set_clientdata(client, chip);
	516
	517	ret = chip->ops->init_chip(chip);
	518	if (ret)
aa4dcf5b	519	return ret;
26b8f5e1 EM	520
	521	/* mask and clear all IRQs */
	522	chip->events_mask = 0xffffffff;
	523	chip->ops->mask_events(chip, chip->events_mask);
	524	chip->ops->read_events(chip, &tmp);
	525
aa4dcf5b	526	ret = devm_request_irq(&client->dev, client->irq, da903x_irq_handler,
f742b96e	527	IRQF_TRIGGER_FALLING,
26b8f5e1 EM	528	"da903x", chip);
	529	if (ret) {
	530	dev_err(&client->dev, "failed to request irq %d\n",
	531	client->irq);
aa4dcf5b	532	return ret;
26b8f5e1 EM	533	}
26b8f5e1 EM	534
5597da29	535	return da903x_add_subdevs(chip, pdata);
26b8f5e1 EM	536	}
26b8f5e1 EM	537
4740f73f	538	static int da903x_remove(struct i2c_client *client)
26b8f5e1 EM	539	{
	540	struct da903x_chip *chip = i2c_get_clientdata(client);
	541
	542	da903x_remove_subdevs(chip);
26b8f5e1 EM	543	return 0;
	544	}
	545
	546	static struct i2c_driver da903x_driver = {
	547	.driver = {
	548	.name = "da903x",
26b8f5e1 EM	549	},
26b8f5e1 EM	550	.probe = da903x_probe,
84449216	551	.remove = da903x_remove,
26b8f5e1 EM	552	.id_table = da903x_id_table,
	553	};
	554
	555	static int __init da903x_init(void)
	556	{
	557	return i2c_add_driver(&da903x_driver);
	558	}
2021de87	559	subsys_initcall(da903x_init);
26b8f5e1 EM	560
	561	static void __exit da903x_exit(void)
	562	{
	563	i2c_del_driver(&da903x_driver);
	564	}
	565	module_exit(da903x_exit);
	566
	567	MODULE_DESCRIPTION("PMIC Driver for Dialog Semiconductor DA9034");
8b277578 LJ	568	MODULE_AUTHOR("Eric Miao <[email protected]>");
	569	MODULE_AUTHOR("Mike Rapoport <[email protected]>");
	570	MODULE_LICENSE("GPL v2");