[linux-2.6-block.git] / drivers / regulator / ad5398.c

/*
 * Voltage and current regulation for AD5398 and AD5821
 *
 * Copyright 2010 Analog Devices Inc.
 *
 * Enter bugs at http://blackfin.uclinux.org/
 *
 * Licensed under the GPL-2 or later.
 */

#include <linux/module.h>
#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>

#define AD5398_CURRENT_EN_MASK	0x8000

struct ad5398_chip_info {
	struct i2c_client *client;
	int min_uA;
	int max_uA;
	unsigned int current_level;
	unsigned int current_mask;
	unsigned int current_offset;
	struct regulator_dev *rdev;
};

static int ad5398_calc_current(struct ad5398_chip_info *chip,
	unsigned selector)
{
	unsigned range_uA = chip->max_uA - chip->min_uA;

	return chip->min_uA + (selector * range_uA / chip->current_level);
}

static int ad5398_read_reg(struct i2c_client *client, unsigned short *data)
{
	unsigned short val;
	int ret;

	ret = i2c_master_recv(client, (char *)&val, 2);
	if (ret < 0) {
		dev_err(&client->dev, "I2C read error\n");
		return ret;
	}
	*data = be16_to_cpu(val);

	return ret;
}

static int ad5398_write_reg(struct i2c_client *client, const unsigned short data)
{
	unsigned short val;
	int ret;

	val = cpu_to_be16(data);
	ret = i2c_master_send(client, (char *)&val, 2);
	if (ret < 0)
		dev_err(&client->dev, "I2C write error\n");

	return ret;
}

static int ad5398_get_current_limit(struct regulator_dev *rdev)
{
	struct ad5398_chip_info *chip = rdev_get_drvdata(rdev);
	struct i2c_client *client = chip->client;
	unsigned short data;
	int ret;

	ret = ad5398_read_reg(client, &data);
	if (ret < 0)
		return ret;

	ret = (data & chip->current_mask) >> chip->current_offset;

	return ad5398_calc_current(chip, ret);
}

static int ad5398_set_current_limit(struct regulator_dev *rdev, int min_uA, int max_uA)
{
	struct ad5398_chip_info *chip = rdev_get_drvdata(rdev);
	struct i2c_client *client = chip->client;
	unsigned range_uA = chip->max_uA - chip->min_uA;
	unsigned selector;
	unsigned short data;
	int ret;

	if (min_uA < chip->min_uA)
		min_uA = chip->min_uA;
	if (max_uA > chip->max_uA)
		max_uA = chip->max_uA;

	if (min_uA > chip->max_uA || max_uA < chip->min_uA)
		return -EINVAL;

	selector = DIV_ROUND_UP((min_uA - chip->min_uA) * chip->current_level,
				range_uA);
	if (ad5398_calc_current(chip, selector) > max_uA)
		return -EINVAL;

	dev_dbg(&client->dev, "changing current %duA\n",
		ad5398_calc_current(chip, selector));

	/* read chip enable bit */
	ret = ad5398_read_reg(client, &data);
	if (ret < 0)
		return ret;

	/* prepare register data */
	selector = (selector << chip->current_offset) & chip->current_mask;
	data = (unsigned short)selector | (data & AD5398_CURRENT_EN_MASK);

	/* write the new current value back as well as enable bit */
	ret = ad5398_write_reg(client, data);

	return ret;
}

static int ad5398_is_enabled(struct regulator_dev *rdev)
{
	struct ad5398_chip_info *chip = rdev_get_drvdata(rdev);
	struct i2c_client *client = chip->client;
	unsigned short data;
	int ret;

	ret = ad5398_read_reg(client, &data);
	if (ret < 0)
		return ret;

	if (data & AD5398_CURRENT_EN_MASK)
		return 1;
	else
		return 0;
}

static int ad5398_enable(struct regulator_dev *rdev)
{
	struct ad5398_chip_info *chip = rdev_get_drvdata(rdev);
	struct i2c_client *client = chip->client;
	unsigned short data;
	int ret;

	ret = ad5398_read_reg(client, &data);
	if (ret < 0)
		return ret;

	if (data & AD5398_CURRENT_EN_MASK)
		return 0;

	data |= AD5398_CURRENT_EN_MASK;

	ret = ad5398_write_reg(client, data);

	return ret;
}

static int ad5398_disable(struct regulator_dev *rdev)
{
	struct ad5398_chip_info *chip = rdev_get_drvdata(rdev);
	struct i2c_client *client = chip->client;
	unsigned short data;
	int ret;

	ret = ad5398_read_reg(client, &data);
	if (ret < 0)
		return ret;

	if (!(data & AD5398_CURRENT_EN_MASK))
		return 0;

	data &= ~AD5398_CURRENT_EN_MASK;

	ret = ad5398_write_reg(client, data);

	return ret;
}

static struct regulator_ops ad5398_ops = {
	.get_current_limit = ad5398_get_current_limit,
	.set_current_limit = ad5398_set_current_limit,
	.enable = ad5398_enable,
	.disable = ad5398_disable,
	.is_enabled = ad5398_is_enabled,
};

static const struct regulator_desc ad5398_reg = {
	.name = "isink",
	.id = 0,
	.ops = &ad5398_ops,
	.type = REGULATOR_CURRENT,
	.owner = THIS_MODULE,
};

struct ad5398_current_data_format {
	int current_bits;
	int current_offset;
	int min_uA;
	int max_uA;
};

static const struct ad5398_current_data_format df_10_4_120 = {10, 4, 0, 120000};

static const struct i2c_device_id ad5398_id[] = {
	{ "ad5398", (kernel_ulong_t)&df_10_4_120 },
	{ "ad5821", (kernel_ulong_t)&df_10_4_120 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, ad5398_id);

static int ad5398_probe(struct i2c_client *client,
				const struct i2c_device_id *id)
{
	struct regulator_init_data *init_data = dev_get_platdata(&client->dev);
	struct regulator_config config = { };
	struct ad5398_chip_info *chip;
	const struct ad5398_current_data_format *df =
			(struct ad5398_current_data_format *)id->driver_data;

	if (!init_data)
		return -EINVAL;

	chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
	if (!chip)
		return -ENOMEM;

	config.dev = &client->dev;
	config.init_data = init_data;
	config.driver_data = chip;

	chip->client = client;

	chip->min_uA = df->min_uA;
	chip->max_uA = df->max_uA;
	chip->current_level = 1 << df->current_bits;
	chip->current_offset = df->current_offset;
	chip->current_mask = (chip->current_level - 1) << chip->current_offset;

	chip->rdev = devm_regulator_register(&client->dev, &ad5398_reg,
					     &config);
	if (IS_ERR(chip->rdev)) {
		dev_err(&client->dev, "failed to register %s %s\n",
			id->name, ad5398_reg.name);
		return PTR_ERR(chip->rdev);
	}

	i2c_set_clientdata(client, chip);
	dev_dbg(&client->dev, "%s regulator driver is registered.\n", id->name);
	return 0;
}

static struct i2c_driver ad5398_driver = {
	.probe = ad5398_probe,
	.driver		= {
		.name	= "ad5398",
	},
	.id_table	= ad5398_id,
};

static int __init ad5398_init(void)
{
	return i2c_add_driver(&ad5398_driver);
}
subsys_initcall(ad5398_init);

static void __exit ad5398_exit(void)
{
	i2c_del_driver(&ad5398_driver);
}
module_exit(ad5398_exit);

MODULE_DESCRIPTION("AD5398 and AD5821 current regulator driver");
MODULE_AUTHOR("Sonic Zhang");
MODULE_LICENSE("GPL");
Commit	Line	Data
8b385d9b SZ	1	/*
	2	* Voltage and current regulation for AD5398 and AD5821
	3	*
	4	* Copyright 2010 Analog Devices Inc.
	5	*
	6	* Enter bugs at http://blackfin.uclinux.org/
	7	*
	8	* Licensed under the GPL-2 or later.
	9	*/
	10
	11	#include <linux/module.h>
	12	#include <linux/err.h>
	13	#include <linux/i2c.h>
	14	#include <linux/slab.h>
	15	#include <linux/platform_device.h>
	16	#include <linux/regulator/driver.h>
	17	#include <linux/regulator/machine.h>
	18
	19	#define AD5398_CURRENT_EN_MASK 0x8000
	20
	21	struct ad5398_chip_info {
	22	struct i2c_client *client;
	23	int min_uA;
	24	int max_uA;
	25	unsigned int current_level;
	26	unsigned int current_mask;
	27	unsigned int current_offset;
58d463ee	28	struct regulator_dev *rdev;
8b385d9b SZ	29	};
	30
	31	static int ad5398_calc_current(struct ad5398_chip_info *chip,
	32	unsigned selector)
	33	{
	34	unsigned range_uA = chip->max_uA - chip->min_uA;
	35
	36	return chip->min_uA + (selector * range_uA / chip->current_level);
	37	}
	38
	39	static int ad5398_read_reg(struct i2c_client client, unsigned short data)
	40	{
	41	unsigned short val;
	42	int ret;
	43
	44	ret = i2c_master_recv(client, (char *)&val, 2);
	45	if (ret < 0) {
	46	dev_err(&client->dev, "I2C read error\n");
	47	return ret;
	48	}
	49	*data = be16_to_cpu(val);
	50
	51	return ret;
	52	}
	53
	54	static int ad5398_write_reg(struct i2c_client *client, const unsigned short data)
	55	{
	56	unsigned short val;
	57	int ret;
	58
	59	val = cpu_to_be16(data);
	60	ret = i2c_master_send(client, (char *)&val, 2);
	61	if (ret < 0)
	62	dev_err(&client->dev, "I2C write error\n");
	63
	64	return ret;
	65	}
	66
	67	static int ad5398_get_current_limit(struct regulator_dev *rdev)
	68	{
	69	struct ad5398_chip_info *chip = rdev_get_drvdata(rdev);
	70	struct i2c_client *client = chip->client;
	71	unsigned short data;
	72	int ret;
	73
	74	ret = ad5398_read_reg(client, &data);
	75	if (ret < 0)
	76	return ret;
	77
	78	ret = (data & chip->current_mask) >> chip->current_offset;
	79
	80	return ad5398_calc_current(chip, ret);
	81	}
	82
	83	static int ad5398_set_current_limit(struct regulator_dev *rdev, int min_uA, int max_uA)
	84	{
	85	struct ad5398_chip_info *chip = rdev_get_drvdata(rdev);
	86	struct i2c_client *client = chip->client;
	87	unsigned range_uA = chip->max_uA - chip->min_uA;
	88	unsigned selector;
	89	unsigned short data;
	90	int ret;
	91
9c6a74c5 AL	92	if (min_uA < chip->min_uA)
	93	min_uA = chip->min_uA;
	94	if (max_uA > chip->max_uA)
	95	max_uA = chip->max_uA;
	96
	97	if (min_uA > chip->max_uA \|\| max_uA < chip->min_uA)
8b385d9b SZ	98	return -EINVAL;
8b385d9b SZ	99
8148ed6e AL	100	selector = DIV_ROUND_UP((min_uA - chip->min_uA) * chip->current_level,
8148ed6e AL	101	range_uA);
8b385d9b SZ	102	if (ad5398_calc_current(chip, selector) > max_uA)
	103	return -EINVAL;
	104
935c14a2 AL	105	dev_dbg(&client->dev, "changing current %duA\n",
935c14a2 AL	106	ad5398_calc_current(chip, selector));
8b385d9b SZ	107
	108	/* read chip enable bit */
	109	ret = ad5398_read_reg(client, &data);
	110	if (ret < 0)
	111	return ret;
	112
	113	/* prepare register data */
	114	selector = (selector << chip->current_offset) & chip->current_mask;
	115	data = (unsigned short)selector \| (data & AD5398_CURRENT_EN_MASK);
	116
	117	/* write the new current value back as well as enable bit */
	118	ret = ad5398_write_reg(client, data);
	119
	120	return ret;
	121	}
	122
	123	static int ad5398_is_enabled(struct regulator_dev *rdev)
	124	{
	125	struct ad5398_chip_info *chip = rdev_get_drvdata(rdev);
	126	struct i2c_client *client = chip->client;
	127	unsigned short data;
	128	int ret;
	129
	130	ret = ad5398_read_reg(client, &data);
	131	if (ret < 0)
	132	return ret;
	133
	134	if (data & AD5398_CURRENT_EN_MASK)
	135	return 1;
	136	else
	137	return 0;
	138	}
	139
	140	static int ad5398_enable(struct regulator_dev *rdev)
	141	{
	142	struct ad5398_chip_info *chip = rdev_get_drvdata(rdev);
	143	struct i2c_client *client = chip->client;
	144	unsigned short data;
	145	int ret;
	146
	147	ret = ad5398_read_reg(client, &data);
	148	if (ret < 0)
	149	return ret;
	150
	151	if (data & AD5398_CURRENT_EN_MASK)
	152	return 0;
	153
	154	data \|= AD5398_CURRENT_EN_MASK;
	155
	156	ret = ad5398_write_reg(client, data);
	157
	158	return ret;
	159	}
	160
	161	static int ad5398_disable(struct regulator_dev *rdev)
	162	{
	163	struct ad5398_chip_info *chip = rdev_get_drvdata(rdev);
	164	struct i2c_client *client = chip->client;
	165	unsigned short data;
	166	int ret;
	167
	168	ret = ad5398_read_reg(client, &data);
	169	if (ret < 0)
	170	return ret;
171
172	if (!(data & AD5398_CURRENT_EN_MASK))
173	return 0;
174
175	data &= ~AD5398_CURRENT_EN_MASK;
176
177	ret = ad5398_write_reg(client, data);
178
179	return ret;
180	}
181
182	static struct regulator_ops ad5398_ops = {
183	.get_current_limit = ad5398_get_current_limit,
184	.set_current_limit = ad5398_set_current_limit,
185	.enable = ad5398_enable,
186	.disable = ad5398_disable,
187	.is_enabled = ad5398_is_enabled,
188	};
189
487f71e6	190	static const struct regulator_desc ad5398_reg = {
8b385d9b SZ	191	.name = "isink",
	192	.id = 0,
	193	.ops = &ad5398_ops,
	194	.type = REGULATOR_CURRENT,
	195	.owner = THIS_MODULE,
	196	};
	197
	198	struct ad5398_current_data_format {
	199	int current_bits;
	200	int current_offset;
	201	int min_uA;
	202	int max_uA;
	203	};
	204
	205	static const struct ad5398_current_data_format df_10_4_120 = {10, 4, 0, 120000};
	206
	207	static const struct i2c_device_id ad5398_id[] = {
	208	{ "ad5398", (kernel_ulong_t)&df_10_4_120 },
	209	{ "ad5821", (kernel_ulong_t)&df_10_4_120 },
	210	{ }
	211	};
	212	MODULE_DEVICE_TABLE(i2c, ad5398_id);
	213
a5023574	214	static int ad5398_probe(struct i2c_client *client,
8b385d9b SZ	215	const struct i2c_device_id *id)
8b385d9b SZ	216	{
dff91d0b	217	struct regulator_init_data *init_data = dev_get_platdata(&client->dev);
c172708d	218	struct regulator_config config = { };
8b385d9b SZ	219	struct ad5398_chip_info *chip;
	220	const struct ad5398_current_data_format *df =
	221	(struct ad5398_current_data_format *)id->driver_data;
8b385d9b SZ	222
	223	if (!init_data)
	224	return -EINVAL;
	225
0df8c96f	226	chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
8b385d9b SZ	227	if (!chip)
	228	return -ENOMEM;
	229
c172708d MB	230	config.dev = &client->dev;
	231	config.init_data = init_data;
	232	config.driver_data = chip;
	233
8b385d9b SZ	234	chip->client = client;
	235
	236	chip->min_uA = df->min_uA;
	237	chip->max_uA = df->max_uA;
	238	chip->current_level = 1 << df->current_bits;
	239	chip->current_offset = df->current_offset;
	240	chip->current_mask = (chip->current_level - 1) << chip->current_offset;
	241
9b2cdac7 AL	242	chip->rdev = devm_regulator_register(&client->dev, &ad5398_reg,
9b2cdac7 AL	243	&config);
58d463ee	244	if (IS_ERR(chip->rdev)) {
8b385d9b SZ	245	dev_err(&client->dev, "failed to register %s %s\n",
8b385d9b SZ	246	id->name, ad5398_reg.name);
9b2cdac7	247	return PTR_ERR(chip->rdev);
8b385d9b SZ	248	}
	249
	250	i2c_set_clientdata(client, chip);
	251	dev_dbg(&client->dev, "%s regulator driver is registered.\n", id->name);
	252	return 0;
8b385d9b SZ	253	}
	254
	255	static struct i2c_driver ad5398_driver = {
	256	.probe = ad5398_probe,
8b385d9b SZ	257	.driver = {
	258	.name = "ad5398",
	259	},
	260	.id_table = ad5398_id,
	261	};
	262
	263	static int __init ad5398_init(void)
	264	{
	265	return i2c_add_driver(&ad5398_driver);
	266	}
839b8362	267	subsys_initcall(ad5398_init);
8b385d9b SZ	268
	269	static void __exit ad5398_exit(void)
	270	{
	271	i2c_del_driver(&ad5398_driver);
	272	}
	273	module_exit(ad5398_exit);
	274
	275	MODULE_DESCRIPTION("AD5398 and AD5821 current regulator driver");
	276	MODULE_AUTHOR("Sonic Zhang");
	277	MODULE_LICENSE("GPL");