1/*
  2 * gpiolib support for Wolfson Arizona class devices
  3 *
  4 * Copyright 2012 Wolfson Microelectronics PLC.
  5 *
  6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
  7 *
  8 *  This program is free software; you can redistribute  it and/or modify it
  9 *  under  the terms of  the GNU General  Public License as published by the
 10 *  Free Software Foundation;  either version 2 of the  License, or (at your
 11 *  option) any later version.
 12 *
 13 */
 14
 15#include <linux/kernel.h>
 16#include <linux/slab.h>
 17#include <linux/module.h>
 18#include <linux/gpio/driver.h>
 19#include <linux/platform_device.h>
 20#include <linux/pm_runtime.h>
 21#include <linux/seq_file.h>
 22
 23#include <linux/mfd/arizona/core.h>
 24#include <linux/mfd/arizona/pdata.h>
 25#include <linux/mfd/arizona/registers.h>
 26
 27struct arizona_gpio {
 28	struct arizona *arizona;
 29	struct gpio_chip gpio_chip;
 30};
 31
 32static int arizona_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
 33{
 34	struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
 35	struct arizona *arizona = arizona_gpio->arizona;
 36	bool persistent = gpiochip_line_is_persistent(chip, offset);
 37	bool change;
 38	int ret;
 39
 40	ret = regmap_update_bits_check(arizona->regmap,
 41				       ARIZONA_GPIO1_CTRL + offset,
 42				       ARIZONA_GPN_DIR, ARIZONA_GPN_DIR,
 43				       &change);
 44	if (ret < 0)
 45		return ret;
 46
 47	if (change && persistent) {
 48		pm_runtime_mark_last_busy(chip->parent);
 49		pm_runtime_put_autosuspend(chip->parent);
 50	}
 51
 52	return 0;
 53}
 54
 55static int arizona_gpio_get(struct gpio_chip *chip, unsigned offset)
 56{
 57	struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
 58	struct arizona *arizona = arizona_gpio->arizona;
 59	unsigned int reg, val;
 60	int ret;
 61
 62	reg = ARIZONA_GPIO1_CTRL + offset;
 63	ret = regmap_read(arizona->regmap, reg, &val);
 64	if (ret < 0)
 65		return ret;
 66
 67	/* Resume to read actual registers for input pins */
 68	if (val & ARIZONA_GPN_DIR) {
 69		ret = pm_runtime_get_sync(chip->parent);
 70		if (ret < 0) {
 71			dev_err(chip->parent, "Failed to resume: %d\n", ret);
 72			return ret;
 73		}
 74
 75		/* Register is cached, drop it to ensure a physical read */
 76		ret = regcache_drop_region(arizona->regmap, reg, reg);
 77		if (ret < 0) {
 78			dev_err(chip->parent, "Failed to drop cache: %d\n",
 79				ret);
 80			return ret;
 81		}
 82
 83		ret = regmap_read(arizona->regmap, reg, &val);
 84		if (ret < 0)
 85			return ret;
 86
 87		pm_runtime_mark_last_busy(chip->parent);
 88		pm_runtime_put_autosuspend(chip->parent);
 89	}
 90
 91	if (val & ARIZONA_GPN_LVL)
 92		return 1;
 93	else
 94		return 0;
 95}
 96
 97static int arizona_gpio_direction_out(struct gpio_chip *chip,
 98				     unsigned offset, int value)
 99{
100	struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
101	struct arizona *arizona = arizona_gpio->arizona;
102	bool persistent = gpiochip_line_is_persistent(chip, offset);
103	unsigned int val;
104	int ret;
105
106	ret = regmap_read(arizona->regmap, ARIZONA_GPIO1_CTRL + offset, &val);
107	if (ret < 0)
108		return ret;
109
110	if ((val & ARIZONA_GPN_DIR) && persistent) {
111		ret = pm_runtime_get_sync(chip->parent);
112		if (ret < 0) {
113			dev_err(chip->parent, "Failed to resume: %d\n", ret);
114			return ret;
115		}
116	}
117
118	if (value)
119		value = ARIZONA_GPN_LVL;
120
121	return regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset,
122				  ARIZONA_GPN_DIR | ARIZONA_GPN_LVL, value);
123}
124
125static void arizona_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
126{
127	struct arizona_gpio *arizona_gpio = gpiochip_get_data(chip);
128	struct arizona *arizona = arizona_gpio->arizona;
129
130	if (value)
131		value = ARIZONA_GPN_LVL;
132
133	regmap_update_bits(arizona->regmap, ARIZONA_GPIO1_CTRL + offset,
134			   ARIZONA_GPN_LVL, value);
135}
136
137static const struct gpio_chip template_chip = {
138	.label			= "arizona",
139	.owner			= THIS_MODULE,
140	.direction_input	= arizona_gpio_direction_in,
141	.get			= arizona_gpio_get,
142	.direction_output	= arizona_gpio_direction_out,
143	.set			= arizona_gpio_set,
144	.can_sleep		= true,
145};
146
147static int arizona_gpio_probe(struct platform_device *pdev)
148{
149	struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
150	struct arizona_pdata *pdata = dev_get_platdata(arizona->dev);
151	struct arizona_gpio *arizona_gpio;
152	int ret;
153
154	arizona_gpio = devm_kzalloc(&pdev->dev, sizeof(*arizona_gpio),
155				    GFP_KERNEL);
156	if (!arizona_gpio)
157		return -ENOMEM;
158
159	arizona_gpio->arizona = arizona;
160	arizona_gpio->gpio_chip = template_chip;
161	arizona_gpio->gpio_chip.parent = &pdev->dev;
162#ifdef CONFIG_OF_GPIO
163	arizona_gpio->gpio_chip.of_node = arizona->dev->of_node;
164#endif
165
166	switch (arizona->type) {
167	case WM5102:
168	case WM5110:
169	case WM8280:
170	case WM8997:
171	case WM8998:
172	case WM1814:
173		arizona_gpio->gpio_chip.ngpio = 5;
174		break;
175	case WM1831:
176	case CS47L24:
177		arizona_gpio->gpio_chip.ngpio = 2;
178		break;
179	default:
180		dev_err(&pdev->dev, "Unknown chip variant %d\n",
181			arizona->type);
182		return -EINVAL;
183	}
184
185	if (pdata && pdata->gpio_base)
186		arizona_gpio->gpio_chip.base = pdata->gpio_base;
187	else
188		arizona_gpio->gpio_chip.base = -1;
189
190	pm_runtime_enable(&pdev->dev);
191
192	ret = devm_gpiochip_add_data(&pdev->dev, &arizona_gpio->gpio_chip,
193				     arizona_gpio);
194	if (ret < 0) {
195		dev_err(&pdev->dev, "Could not register gpiochip, %d\n",
196			ret);
197		return ret;
198	}
199
200	return 0;
201}
202
203static struct platform_driver arizona_gpio_driver = {
204	.driver.name	= "arizona-gpio",
205	.probe		= arizona_gpio_probe,
206};
207
208module_platform_driver(arizona_gpio_driver);
209
210MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
211MODULE_DESCRIPTION("GPIO interface for Arizona devices");
212MODULE_LICENSE("GPL");
213MODULE_ALIAS("platform:arizona-gpio");