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