[linux-2.6-block.git] / drivers / gpio / adp5588-gpio.c

/*
 * GPIO Chip driver for Analog Devices
 * ADP5588 I/O Expander and QWERTY Keypad Controller
 *
 * Copyright 2009 Analog Devices Inc.
 *
 * Licensed under the GPL-2 or later.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/i2c.h>
#include <linux/gpio.h>

#include <linux/i2c/adp5588.h>

#define DRV_NAME		"adp5588-gpio"
#define MAXGPIO			18
#define ADP_BANK(offs)		((offs) >> 3)
#define ADP_BIT(offs)		(1u << ((offs) & 0x7))

struct adp5588_gpio {
	struct i2c_client *client;
	struct gpio_chip gpio_chip;
	struct mutex lock;	/* protect cached dir, dat_out */
	unsigned gpio_start;
	uint8_t dat_out[3];
	uint8_t dir[3];
};

static int adp5588_gpio_read(struct i2c_client *client, u8 reg)
{
	int ret = i2c_smbus_read_byte_data(client, reg);

	if (ret < 0)
		dev_err(&client->dev, "Read Error\n");

	return ret;
}

static int adp5588_gpio_write(struct i2c_client *client, u8 reg, u8 val)
{
	int ret = i2c_smbus_write_byte_data(client, reg, val);

	if (ret < 0)
		dev_err(&client->dev, "Write Error\n");

	return ret;
}

static int adp5588_gpio_get_value(struct gpio_chip *chip, unsigned off)
{
	struct adp5588_gpio *dev =
	    container_of(chip, struct adp5588_gpio, gpio_chip);

	return !!(adp5588_gpio_read(dev->client, GPIO_DAT_STAT1 + ADP_BANK(off))
		  & ADP_BIT(off));
}

static void adp5588_gpio_set_value(struct gpio_chip *chip,
				   unsigned off, int val)
{
	unsigned bank, bit;
	struct adp5588_gpio *dev =
	    container_of(chip, struct adp5588_gpio, gpio_chip);

	bank = ADP_BANK(off);
	bit = ADP_BIT(off);

	mutex_lock(&dev->lock);
	if (val)
		dev->dat_out[bank] |= bit;
	else
		dev->dat_out[bank] &= ~bit;

	adp5588_gpio_write(dev->client, GPIO_DAT_OUT1 + bank,
			   dev->dat_out[bank]);
	mutex_unlock(&dev->lock);
}

static int adp5588_gpio_direction_input(struct gpio_chip *chip, unsigned off)
{
	int ret;
	unsigned bank;
	struct adp5588_gpio *dev =
	    container_of(chip, struct adp5588_gpio, gpio_chip);

	bank = ADP_BANK(off);

	mutex_lock(&dev->lock);
	dev->dir[bank] &= ~ADP_BIT(off);
	ret = adp5588_gpio_write(dev->client, GPIO_DIR1 + bank, dev->dir[bank]);
	mutex_unlock(&dev->lock);

	return ret;
}

static int adp5588_gpio_direction_output(struct gpio_chip *chip,
					 unsigned off, int val)
{
	int ret;
	unsigned bank, bit;
	struct adp5588_gpio *dev =
	    container_of(chip, struct adp5588_gpio, gpio_chip);

	bank = ADP_BANK(off);
	bit = ADP_BIT(off);

	mutex_lock(&dev->lock);
	dev->dir[bank] |= bit;

	if (val)
		dev->dat_out[bank] |= bit;
	else
		dev->dat_out[bank] &= ~bit;

	ret = adp5588_gpio_write(dev->client, GPIO_DAT_OUT1 + bank,
				 dev->dat_out[bank]);
	ret |= adp5588_gpio_write(dev->client, GPIO_DIR1 + bank,
				 dev->dir[bank]);
	mutex_unlock(&dev->lock);

	return ret;
}

static int __devinit adp5588_gpio_probe(struct i2c_client *client,
					const struct i2c_device_id *id)
{
	struct adp5588_gpio_platform_data *pdata = client->dev.platform_data;
	struct adp5588_gpio *dev;
	struct gpio_chip *gc;
	int ret, i, revid;

	if (pdata == NULL) {
		dev_err(&client->dev, "missing platform data\n");
		return -ENODEV;
	}

	if (!i2c_check_functionality(client->adapter,
					I2C_FUNC_SMBUS_BYTE_DATA)) {
		dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
		return -EIO;
	}

	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	if (dev == NULL) {
		dev_err(&client->dev, "failed to alloc memory\n");
		return -ENOMEM;
	}

	dev->client = client;

	gc = &dev->gpio_chip;
	gc->direction_input = adp5588_gpio_direction_input;
	gc->direction_output = adp5588_gpio_direction_output;
	gc->get = adp5588_gpio_get_value;
	gc->set = adp5588_gpio_set_value;
	gc->can_sleep = 1;

	gc->base = pdata->gpio_start;
	gc->ngpio = MAXGPIO;
	gc->label = client->name;
	gc->owner = THIS_MODULE;

	mutex_init(&dev->lock);


	ret = adp5588_gpio_read(dev->client, DEV_ID);
	if (ret < 0)
		goto err;

	revid = ret & ADP5588_DEVICE_ID_MASK;

	for (i = 0, ret = 0; i <= ADP_BANK(MAXGPIO); i++) {
		dev->dat_out[i] = adp5588_gpio_read(client, GPIO_DAT_OUT1 + i);
		dev->dir[i] = adp5588_gpio_read(client, GPIO_DIR1 + i);
		ret |= adp5588_gpio_write(client, KP_GPIO1 + i, 0);
		ret |= adp5588_gpio_write(client, GPIO_PULL1 + i,
				(pdata->pullup_dis_mask >> (8 * i)) & 0xFF);

		if (ret)
			goto err;
	}

	ret = gpiochip_add(&dev->gpio_chip);
	if (ret)
		goto err;

	dev_info(&client->dev, "gpios %d..%d on a %s Rev. %d\n",
			gc->base, gc->base + gc->ngpio - 1,
			client->name, revid);

	if (pdata->setup) {
		ret = pdata->setup(client, gc->base, gc->ngpio, pdata->context);
		if (ret < 0)
			dev_warn(&client->dev, "setup failed, %d\n", ret);
	}

	i2c_set_clientdata(client, dev);
	return 0;

err:
	kfree(dev);
	return ret;
}

static int __devexit adp5588_gpio_remove(struct i2c_client *client)
{
	struct adp5588_gpio_platform_data *pdata = client->dev.platform_data;
	struct adp5588_gpio *dev = i2c_get_clientdata(client);
	int ret;

	if (pdata->teardown) {
		ret = pdata->teardown(client,
				      dev->gpio_chip.base, dev->gpio_chip.ngpio,
				      pdata->context);
		if (ret < 0) {
			dev_err(&client->dev, "teardown failed %d\n", ret);
			return ret;
		}
	}

	ret = gpiochip_remove(&dev->gpio_chip);
	if (ret) {
		dev_err(&client->dev, "gpiochip_remove failed %d\n", ret);
		return ret;
	}

	kfree(dev);
	return 0;
}

static const struct i2c_device_id adp5588_gpio_id[] = {
	{DRV_NAME, 0},
	{}
};

MODULE_DEVICE_TABLE(i2c, adp5588_gpio_id);

static struct i2c_driver adp5588_gpio_driver = {
	.driver = {
		   .name = DRV_NAME,
		   },
	.probe = adp5588_gpio_probe,
	.remove = __devexit_p(adp5588_gpio_remove),
	.id_table = adp5588_gpio_id,
};

static int __init adp5588_gpio_init(void)
{
	return i2c_add_driver(&adp5588_gpio_driver);
}

module_init(adp5588_gpio_init);

static void __exit adp5588_gpio_exit(void)
{
	i2c_del_driver(&adp5588_gpio_driver);
}

module_exit(adp5588_gpio_exit);

MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
MODULE_DESCRIPTION("GPIO ADP5588 Driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
80884094 MH	1	/*
	2	* GPIO Chip driver for Analog Devices
	3	* ADP5588 I/O Expander and QWERTY Keypad Controller
	4	*
	5	* Copyright 2009 Analog Devices Inc.
	6	*
	7	* Licensed under the GPL-2 or later.
	8	*/
	9
	10	#include <linux/module.h>
	11	#include <linux/kernel.h>
5a0e3ad6	12	#include <linux/slab.h>
80884094 MH	13	#include <linux/init.h>
	14	#include <linux/i2c.h>
	15	#include <linux/gpio.h>
	16
	17	#include <linux/i2c/adp5588.h>
	18
	19	#define DRV_NAME "adp5588-gpio"
	20	#define MAXGPIO 18
	21	#define ADP_BANK(offs) ((offs) >> 3)
	22	#define ADP_BIT(offs) (1u << ((offs) & 0x7))
	23
	24	struct adp5588_gpio {
	25	struct i2c_client *client;
	26	struct gpio_chip gpio_chip;
	27	struct mutex lock; /* protect cached dir, dat_out */
	28	unsigned gpio_start;
	29	uint8_t dat_out[3];
	30	uint8_t dir[3];
	31	};
	32
	33	static int adp5588_gpio_read(struct i2c_client *client, u8 reg)
	34	{
	35	int ret = i2c_smbus_read_byte_data(client, reg);
	36
	37	if (ret < 0)
	38	dev_err(&client->dev, "Read Error\n");
	39
	40	return ret;
	41	}
	42
	43	static int adp5588_gpio_write(struct i2c_client *client, u8 reg, u8 val)
	44	{
	45	int ret = i2c_smbus_write_byte_data(client, reg, val);
	46
	47	if (ret < 0)
	48	dev_err(&client->dev, "Write Error\n");
	49
	50	return ret;
	51	}
	52
	53	static int adp5588_gpio_get_value(struct gpio_chip *chip, unsigned off)
	54	{
	55	struct adp5588_gpio *dev =
	56	container_of(chip, struct adp5588_gpio, gpio_chip);
	57
	58	return !!(adp5588_gpio_read(dev->client, GPIO_DAT_STAT1 + ADP_BANK(off))
	59	& ADP_BIT(off));
	60	}
	61
	62	static void adp5588_gpio_set_value(struct gpio_chip *chip,
	63	unsigned off, int val)
	64	{
	65	unsigned bank, bit;
	66	struct adp5588_gpio *dev =
	67	container_of(chip, struct adp5588_gpio, gpio_chip);
	68
	69	bank = ADP_BANK(off);
	70	bit = ADP_BIT(off);
	71
	72	mutex_lock(&dev->lock);
	73	if (val)
	74	dev->dat_out[bank] \|= bit;
	75	else
	76	dev->dat_out[bank] &= ~bit;
77
78	adp5588_gpio_write(dev->client, GPIO_DAT_OUT1 + bank,
79	dev->dat_out[bank]);
80	mutex_unlock(&dev->lock);
81	}
82
83	static int adp5588_gpio_direction_input(struct gpio_chip *chip, unsigned off)
84	{
85	int ret;
86	unsigned bank;
87	struct adp5588_gpio *dev =
88	container_of(chip, struct adp5588_gpio, gpio_chip);
89
90	bank = ADP_BANK(off);
91
92	mutex_lock(&dev->lock);
93	dev->dir[bank] &= ~ADP_BIT(off);
94	ret = adp5588_gpio_write(dev->client, GPIO_DIR1 + bank, dev->dir[bank]);
95	mutex_unlock(&dev->lock);
96
97	return ret;
98	}
99
100	static int adp5588_gpio_direction_output(struct gpio_chip *chip,
101	unsigned off, int val)
102	{
103	int ret;
104	unsigned bank, bit;
105	struct adp5588_gpio *dev =
106	container_of(chip, struct adp5588_gpio, gpio_chip);
107
108	bank = ADP_BANK(off);
109	bit = ADP_BIT(off);
110
111	mutex_lock(&dev->lock);
112	dev->dir[bank] \|= bit;
113
114	if (val)
115	dev->dat_out[bank] \|= bit;
116	else
117	dev->dat_out[bank] &= ~bit;
118
119	ret = adp5588_gpio_write(dev->client, GPIO_DAT_OUT1 + bank,
120	dev->dat_out[bank]);
121	ret \|= adp5588_gpio_write(dev->client, GPIO_DIR1 + bank,
122	dev->dir[bank]);
123	mutex_unlock(&dev->lock);
124
125	return ret;
126	}
127
128	static int __devinit adp5588_gpio_probe(struct i2c_client *client,
129	const struct i2c_device_id *id)
130	{
131	struct adp5588_gpio_platform_data *pdata = client->dev.platform_data;
132	struct adp5588_gpio *dev;
133	struct gpio_chip *gc;
134	int ret, i, revid;
135
136	if (pdata == NULL) {
137	dev_err(&client->dev, "missing platform data\n");
138	return -ENODEV;
139	}
140
141	if (!i2c_check_functionality(client->adapter,
142	I2C_FUNC_SMBUS_BYTE_DATA)) {
143	dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
144	return -EIO;
145	}
146
147	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
148	if (dev == NULL) {
149	dev_err(&client->dev, "failed to alloc memory\n");
150	return -ENOMEM;
151	}
152
153	dev->client = client;
154
155	gc = &dev->gpio_chip;
156	gc->direction_input = adp5588_gpio_direction_input;
157	gc->direction_output = adp5588_gpio_direction_output;
158	gc->get = adp5588_gpio_get_value;
159	gc->set = adp5588_gpio_set_value;
160	gc->can_sleep = 1;
161
162	gc->base = pdata->gpio_start;
163	gc->ngpio = MAXGPIO;
164	gc->label = client->name;
165	gc->owner = THIS_MODULE;
166
167	mutex_init(&dev->lock);
168
169
170	ret = adp5588_gpio_read(dev->client, DEV_ID);
171	if (ret < 0)
172	goto err;
173
174	revid = ret & ADP5588_DEVICE_ID_MASK;
175
176	for (i = 0, ret = 0; i <= ADP_BANK(MAXGPIO); i++) {
177	dev->dat_out[i] = adp5588_gpio_read(client, GPIO_DAT_OUT1 + i);
178	dev->dir[i] = adp5588_gpio_read(client, GPIO_DIR1 + i);
179	ret \|= adp5588_gpio_write(client, KP_GPIO1 + i, 0);
180	ret \|= adp5588_gpio_write(client, GPIO_PULL1 + i,
181	(pdata->pullup_dis_mask >> (8 * i)) & 0xFF);
182
183	if (ret)
184	goto err;
185	}
186
187	ret = gpiochip_add(&dev->gpio_chip);
188	if (ret)
189	goto err;
190
191	dev_info(&client->dev, "gpios %d..%d on a %s Rev. %d\n",
192	gc->base, gc->base + gc->ngpio - 1,
193	client->name, revid);
194
195	if (pdata->setup) {
196	ret = pdata->setup(client, gc->base, gc->ngpio, pdata->context);
197	if (ret < 0)
198	dev_warn(&client->dev, "setup failed, %d\n", ret);
199	}
200
201	i2c_set_clientdata(client, dev);
202	return 0;
203
204	err:
205	kfree(dev);
206	return ret;
207	}
208
209	static int __devexit adp5588_gpio_remove(struct i2c_client *client)
210	{
211	struct adp5588_gpio_platform_data *pdata = client->dev.platform_data;
212	struct adp5588_gpio *dev = i2c_get_clientdata(client);
213	int ret;
214
215	if (pdata->teardown) {
216	ret = pdata->teardown(client,
217	dev->gpio_chip.base, dev->gpio_chip.ngpio,
218	pdata->context);
219	if (ret < 0) {
220	dev_err(&client->dev, "teardown failed %d\n", ret);
221	return ret;
222	}
223	}
224
225	ret = gpiochip_remove(&dev->gpio_chip);
226	if (ret) {
227	dev_err(&client->dev, "gpiochip_remove failed %d\n", ret);
228	return ret;
229	}
230
231	kfree(dev);
232	return 0;
233	}
234
235	static const struct i2c_device_id adp5588_gpio_id[] = {
236	{DRV_NAME, 0},
237	{}
238	};
239
240	MODULE_DEVICE_TABLE(i2c, adp5588_gpio_id);
241
242	static struct i2c_driver adp5588_gpio_driver = {
243	.driver = {
244	.name = DRV_NAME,
245	},
246	.probe = adp5588_gpio_probe,
247	.remove = __devexit_p(adp5588_gpio_remove),
248	.id_table = adp5588_gpio_id,
249	};
250
251	static int __init adp5588_gpio_init(void)
252	{
253	return i2c_add_driver(&adp5588_gpio_driver);
254	}
255
256	module_init(adp5588_gpio_init);
257
258	static void __exit adp5588_gpio_exit(void)
259	{
260	i2c_del_driver(&adp5588_gpio_driver);
261	}
262
263	module_exit(adp5588_gpio_exit);
264
265	MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
266	MODULE_DESCRIPTION("GPIO ADP5588 Driver");
267	MODULE_LICENSE("GPL");