1/*
  2 * GPIO driver for Analog Devices ADP5520 MFD PMICs
  3 *
  4 * Copyright 2009 Analog Devices Inc.
  5 *
  6 * Licensed under the GPL-2 or later.
  7 */
  8
  9#include <linux/module.h>
 10#include <linux/slab.h>
 11#include <linux/kernel.h>
 12#include <linux/init.h>
 13#include <linux/platform_device.h>
 14#include <linux/mfd/adp5520.h>
 15
 16#include <linux/gpio.h>
 17
 18struct adp5520_gpio {
 19	struct device *master;
 20	struct gpio_chip gpio_chip;
 21	unsigned char lut[ADP5520_MAXGPIOS];
 22	unsigned long output;
 23};
 24
 25static int adp5520_gpio_get_value(struct gpio_chip *chip, unsigned off)
 26{
 27	struct adp5520_gpio *dev;
 28	uint8_t reg_val;
 29
 30	dev = gpiochip_get_data(chip);
 31
 32	/*
 33	 * There are dedicated registers for GPIO IN/OUT.
 34	 * Make sure we return the right value, even when configured as output
 35	 */
 36
 37	if (test_bit(off, &dev->output))
 38		adp5520_read(dev->master, ADP5520_GPIO_OUT, &reg_val);
 39	else
 40		adp5520_read(dev->master, ADP5520_GPIO_IN, &reg_val);
 41
 42	return !!(reg_val & dev->lut[off]);
 43}
 44
 45static void adp5520_gpio_set_value(struct gpio_chip *chip,
 46		unsigned off, int val)
 47{
 48	struct adp5520_gpio *dev;
 49	dev = gpiochip_get_data(chip);
 50
 51	if (val)
 52		adp5520_set_bits(dev->master, ADP5520_GPIO_OUT, dev->lut[off]);
 53	else
 54		adp5520_clr_bits(dev->master, ADP5520_GPIO_OUT, dev->lut[off]);
 55}
 56
 57static int adp5520_gpio_direction_input(struct gpio_chip *chip, unsigned off)
 58{
 59	struct adp5520_gpio *dev;
 60	dev = gpiochip_get_data(chip);
 61
 62	clear_bit(off, &dev->output);
 63
 64	return adp5520_clr_bits(dev->master, ADP5520_GPIO_CFG_2,
 65				dev->lut[off]);
 66}
 67
 68static int adp5520_gpio_direction_output(struct gpio_chip *chip,
 69		unsigned off, int val)
 70{
 71	struct adp5520_gpio *dev;
 72	int ret = 0;
 73	dev = gpiochip_get_data(chip);
 74
 75	set_bit(off, &dev->output);
 76
 77	if (val)
 78		ret |= adp5520_set_bits(dev->master, ADP5520_GPIO_OUT,
 79					dev->lut[off]);
 80	else
 81		ret |= adp5520_clr_bits(dev->master, ADP5520_GPIO_OUT,
 82					dev->lut[off]);
 83
 84	ret |= adp5520_set_bits(dev->master, ADP5520_GPIO_CFG_2,
 85					dev->lut[off]);
 86
 87	return ret;
 88}
 89
 90static int adp5520_gpio_probe(struct platform_device *pdev)
 91{
 92	struct adp5520_gpio_platform_data *pdata = dev_get_platdata(&pdev->dev);
 93	struct adp5520_gpio *dev;
 94	struct gpio_chip *gc;
 95	int ret, i, gpios;
 96	unsigned char ctl_mask = 0;
 97
 98	if (pdata == NULL) {
 99		dev_err(&pdev->dev, "missing platform data\n");
100		return -ENODEV;
101	}
102
103	if (pdev->id != ID_ADP5520) {
104		dev_err(&pdev->dev, "only ADP5520 supports GPIO\n");
105		return -ENODEV;
106	}
107
108	dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
109	if (dev == NULL)
110		return -ENOMEM;
111
112	dev->master = pdev->dev.parent;
113
114	for (gpios = 0, i = 0; i < ADP5520_MAXGPIOS; i++)
115		if (pdata->gpio_en_mask & (1 << i))
116			dev->lut[gpios++] = 1 << i;
117
118	if (gpios < 1) {
119		ret = -EINVAL;
120		goto err;
121	}
122
123	gc = &dev->gpio_chip;
124	gc->direction_input  = adp5520_gpio_direction_input;
125	gc->direction_output = adp5520_gpio_direction_output;
126	gc->get = adp5520_gpio_get_value;
127	gc->set = adp5520_gpio_set_value;
128	gc->can_sleep = true;
129
130	gc->base = pdata->gpio_start;
131	gc->ngpio = gpios;
132	gc->label = pdev->name;
133	gc->owner = THIS_MODULE;
134
135	ret = adp5520_clr_bits(dev->master, ADP5520_GPIO_CFG_1,
136		pdata->gpio_en_mask);
137
138	if (pdata->gpio_en_mask & ADP5520_GPIO_C3)
139		ctl_mask |= ADP5520_C3_MODE;
140
141	if (pdata->gpio_en_mask & ADP5520_GPIO_R3)
142		ctl_mask |= ADP5520_R3_MODE;
143
144	if (ctl_mask)
145		ret = adp5520_set_bits(dev->master, ADP5520_LED_CONTROL,
146			ctl_mask);
147
148	ret |= adp5520_set_bits(dev->master, ADP5520_GPIO_PULLUP,
149		pdata->gpio_pullup_mask);
150
151	if (ret) {
152		dev_err(&pdev->dev, "failed to write\n");
153		goto err;
154	}
155
156	ret = devm_gpiochip_add_data(&pdev->dev, &dev->gpio_chip, dev);
157	if (ret)
158		goto err;
159
160	platform_set_drvdata(pdev, dev);
161	return 0;
162
163err:
164	return ret;
165}
166
167static struct platform_driver adp5520_gpio_driver = {
168	.driver	= {
169		.name	= "adp5520-gpio",
170	},
171	.probe		= adp5520_gpio_probe,
172};
173
174module_platform_driver(adp5520_gpio_driver);
175
176MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
177MODULE_DESCRIPTION("GPIO ADP5520 Driver");
178MODULE_LICENSE("GPL");
179MODULE_ALIAS("platform:adp5520-gpio");

  1/*
  2 * GPIO driver for Analog Devices ADP5520 MFD PMICs
  3 *
  4 * Copyright 2009 Analog Devices Inc.
  5 *
  6 * Licensed under the GPL-2 or later.
  7 */
  8
  9#include <linux/module.h>
 10#include <linux/slab.h>
 11#include <linux/kernel.h>
 12#include <linux/init.h>
 13#include <linux/platform_device.h>
 14#include <linux/mfd/adp5520.h>
 15#include <linux/gpio/driver.h>
 
 16
 17struct adp5520_gpio {
 18	struct device *master;
 19	struct gpio_chip gpio_chip;
 20	unsigned char lut[ADP5520_MAXGPIOS];
 21	unsigned long output;
 22};
 23
 24static int adp5520_gpio_get_value(struct gpio_chip *chip, unsigned off)
 25{
 26	struct adp5520_gpio *dev;
 27	uint8_t reg_val;
 28
 29	dev = gpiochip_get_data(chip);
 30
 31	/*
 32	 * There are dedicated registers for GPIO IN/OUT.
 33	 * Make sure we return the right value, even when configured as output
 34	 */
 35
 36	if (test_bit(off, &dev->output))
 37		adp5520_read(dev->master, ADP5520_GPIO_OUT, &reg_val);
 38	else
 39		adp5520_read(dev->master, ADP5520_GPIO_IN, &reg_val);
 40
 41	return !!(reg_val & dev->lut[off]);
 42}
 43
 44static void adp5520_gpio_set_value(struct gpio_chip *chip,
 45		unsigned off, int val)
 46{
 47	struct adp5520_gpio *dev;
 48	dev = gpiochip_get_data(chip);
 49
 50	if (val)
 51		adp5520_set_bits(dev->master, ADP5520_GPIO_OUT, dev->lut[off]);
 52	else
 53		adp5520_clr_bits(dev->master, ADP5520_GPIO_OUT, dev->lut[off]);
 54}
 55
 56static int adp5520_gpio_direction_input(struct gpio_chip *chip, unsigned off)
 57{
 58	struct adp5520_gpio *dev;
 59	dev = gpiochip_get_data(chip);
 60
 61	clear_bit(off, &dev->output);
 62
 63	return adp5520_clr_bits(dev->master, ADP5520_GPIO_CFG_2,
 64				dev->lut[off]);
 65}
 66
 67static int adp5520_gpio_direction_output(struct gpio_chip *chip,
 68		unsigned off, int val)
 69{
 70	struct adp5520_gpio *dev;
 71	int ret = 0;
 72	dev = gpiochip_get_data(chip);
 73
 74	set_bit(off, &dev->output);
 75
 76	if (val)
 77		ret |= adp5520_set_bits(dev->master, ADP5520_GPIO_OUT,
 78					dev->lut[off]);
 79	else
 80		ret |= adp5520_clr_bits(dev->master, ADP5520_GPIO_OUT,
 81					dev->lut[off]);
 82
 83	ret |= adp5520_set_bits(dev->master, ADP5520_GPIO_CFG_2,
 84					dev->lut[off]);
 85
 86	return ret;
 87}
 88
 89static int adp5520_gpio_probe(struct platform_device *pdev)
 90{
 91	struct adp5520_gpio_platform_data *pdata = dev_get_platdata(&pdev->dev);
 92	struct adp5520_gpio *dev;
 93	struct gpio_chip *gc;
 94	int ret, i, gpios;
 95	unsigned char ctl_mask = 0;
 96
 97	if (pdata == NULL) {
 98		dev_err(&pdev->dev, "missing platform data\n");
 99		return -ENODEV;
100	}
101
102	if (pdev->id != ID_ADP5520) {
103		dev_err(&pdev->dev, "only ADP5520 supports GPIO\n");
104		return -ENODEV;
105	}
106
107	dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
108	if (dev == NULL)
109		return -ENOMEM;
110
111	dev->master = pdev->dev.parent;
112
113	for (gpios = 0, i = 0; i < ADP5520_MAXGPIOS; i++)
114		if (pdata->gpio_en_mask & (1 << i))
115			dev->lut[gpios++] = 1 << i;
116
117	if (gpios < 1) {
118		ret = -EINVAL;
119		goto err;
120	}
121
122	gc = &dev->gpio_chip;
123	gc->direction_input  = adp5520_gpio_direction_input;
124	gc->direction_output = adp5520_gpio_direction_output;
125	gc->get = adp5520_gpio_get_value;
126	gc->set = adp5520_gpio_set_value;
127	gc->can_sleep = true;
128
129	gc->base = pdata->gpio_start;
130	gc->ngpio = gpios;
131	gc->label = pdev->name;
132	gc->owner = THIS_MODULE;
133
134	ret = adp5520_clr_bits(dev->master, ADP5520_GPIO_CFG_1,
135		pdata->gpio_en_mask);
136
137	if (pdata->gpio_en_mask & ADP5520_GPIO_C3)
138		ctl_mask |= ADP5520_C3_MODE;
139
140	if (pdata->gpio_en_mask & ADP5520_GPIO_R3)
141		ctl_mask |= ADP5520_R3_MODE;
142
143	if (ctl_mask)
144		ret = adp5520_set_bits(dev->master, ADP5520_LED_CONTROL,
145			ctl_mask);
146
147	ret |= adp5520_set_bits(dev->master, ADP5520_GPIO_PULLUP,
148		pdata->gpio_pullup_mask);
149
150	if (ret) {
151		dev_err(&pdev->dev, "failed to write\n");
152		goto err;
153	}
154
155	ret = devm_gpiochip_add_data(&pdev->dev, &dev->gpio_chip, dev);
156	if (ret)
157		goto err;
158
159	platform_set_drvdata(pdev, dev);
160	return 0;
161
162err:
163	return ret;
164}
165
166static struct platform_driver adp5520_gpio_driver = {
167	.driver	= {
168		.name	= "adp5520-gpio",
169	},
170	.probe		= adp5520_gpio_probe,
171};
172
173module_platform_driver(adp5520_gpio_driver);
174
175MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
176MODULE_DESCRIPTION("GPIO ADP5520 Driver");
177MODULE_LICENSE("GPL");
178MODULE_ALIAS("platform:adp5520-gpio");