gpio-wm831x.c 7.61 KB
Newer Older
Mark Brown's avatar
Mark Brown committed
1
/*
Grant Likely's avatar
Grant Likely committed
2
 * gpiolib support for Wolfson WM831x PMICs
Mark Brown's avatar
Mark Brown committed
3 4 5 6 7 8 9 10 11 12 13 14 15
 *
 * Copyright 2009 Wolfson Microelectronics PLC.
 *
 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
 *
 *  This program is free software; you can redistribute  it and/or modify it
 *  under  the terms of  the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the  License, or (at your
 *  option) any later version.
 *
 */

#include <linux/kernel.h>
16
#include <linux/slab.h>
Mark Brown's avatar
Mark Brown committed
17 18 19 20 21 22 23 24 25
#include <linux/module.h>
#include <linux/gpio.h>
#include <linux/mfd/core.h>
#include <linux/platform_device.h>
#include <linux/seq_file.h>

#include <linux/mfd/wm831x/core.h>
#include <linux/mfd/wm831x/pdata.h>
#include <linux/mfd/wm831x/gpio.h>
26
#include <linux/mfd/wm831x/irq.h>
Mark Brown's avatar
Mark Brown committed
27 28 29 30 31 32 33 34

struct wm831x_gpio {
	struct wm831x *wm831x;
	struct gpio_chip gpio_chip;
};

static int wm831x_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
{
35
	struct wm831x_gpio *wm831x_gpio = gpiochip_get_data(chip);
Mark Brown's avatar
Mark Brown committed
36
	struct wm831x *wm831x = wm831x_gpio->wm831x;
37 38 39 40
	int val = WM831X_GPN_DIR;

	if (wm831x->has_gpio_ena)
		val |= WM831X_GPN_TRI;
Mark Brown's avatar
Mark Brown committed
41 42

	return wm831x_set_bits(wm831x, WM831X_GPIO1_CONTROL + offset,
43 44
			       WM831X_GPN_DIR | WM831X_GPN_TRI |
			       WM831X_GPN_FN_MASK, val);
Mark Brown's avatar
Mark Brown committed
45 46 47 48
}

static int wm831x_gpio_get(struct gpio_chip *chip, unsigned offset)
{
49
	struct wm831x_gpio *wm831x_gpio = gpiochip_get_data(chip);
Mark Brown's avatar
Mark Brown committed
50 51 52 53 54 55 56 57 58 59 60 61 62
	struct wm831x *wm831x = wm831x_gpio->wm831x;
	int ret;

	ret = wm831x_reg_read(wm831x, WM831X_GPIO_LEVEL);
	if (ret < 0)
		return ret;

	if (ret & 1 << offset)
		return 1;
	else
		return 0;
}

63
static void wm831x_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
Mark Brown's avatar
Mark Brown committed
64
{
65
	struct wm831x_gpio *wm831x_gpio = gpiochip_get_data(chip);
Mark Brown's avatar
Mark Brown committed
66 67
	struct wm831x *wm831x = wm831x_gpio->wm831x;

68 69
	wm831x_set_bits(wm831x, WM831X_GPIO_LEVEL, 1 << offset,
			value << offset);
Mark Brown's avatar
Mark Brown committed
70 71
}

72 73
static int wm831x_gpio_direction_out(struct gpio_chip *chip,
				     unsigned offset, int value)
Mark Brown's avatar
Mark Brown committed
74
{
75
	struct wm831x_gpio *wm831x_gpio = gpiochip_get_data(chip);
Mark Brown's avatar
Mark Brown committed
76
	struct wm831x *wm831x = wm831x_gpio->wm831x;
77
	int val = 0;
78
	int ret;
Mark Brown's avatar
Mark Brown committed
79

80 81 82
	if (wm831x->has_gpio_ena)
		val |= WM831X_GPN_TRI;

83
	ret = wm831x_set_bits(wm831x, WM831X_GPIO1_CONTROL + offset,
84 85
			      WM831X_GPN_DIR | WM831X_GPN_TRI |
			      WM831X_GPN_FN_MASK, val);
86 87 88 89 90 91 92
	if (ret < 0)
		return ret;

	/* Can only set GPIO state once it's in output mode */
	wm831x_gpio_set(chip, offset, value);

	return 0;
Mark Brown's avatar
Mark Brown committed
93 94
}

95 96
static int wm831x_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
{
97
	struct wm831x_gpio *wm831x_gpio = gpiochip_get_data(chip);
98 99
	struct wm831x *wm831x = wm831x_gpio->wm831x;

Mark Brown's avatar
Mark Brown committed
100 101
	return irq_create_mapping(wm831x->irq_domain,
				  WM831X_IRQ_GPIO_1 + offset);
102 103
}

104
static int wm831x_gpio_set_debounce(struct wm831x *wm831x, unsigned offset,
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132
				    unsigned debounce)
{
	int reg = WM831X_GPIO1_CONTROL + offset;
	int ret, fn;

	ret = wm831x_reg_read(wm831x, reg);
	if (ret < 0)
		return ret;

	switch (ret & WM831X_GPN_FN_MASK) {
	case 0:
	case 1:
		break;
	default:
		/* Not in GPIO mode */
		return -EBUSY;
	}

	if (debounce >= 32 && debounce <= 64)
		fn = 0;
	else if (debounce >= 4000 && debounce <= 8000)
		fn = 1;
	else
		return -EINVAL;

	return wm831x_set_bits(wm831x, reg, WM831X_GPN_FN_MASK, fn);
}

133 134
static int wm831x_set_config(struct gpio_chip *chip, unsigned int offset,
			     unsigned long config)
135 136 137 138 139
{
	struct wm831x_gpio *wm831x_gpio = gpiochip_get_data(chip);
	struct wm831x *wm831x = wm831x_gpio->wm831x;
	int reg = WM831X_GPIO1_CONTROL + offset;

140 141
	switch (pinconf_to_config_param(config)) {
	case PIN_CONFIG_DRIVE_OPEN_DRAIN:
142 143
		return wm831x_set_bits(wm831x, reg,
				       WM831X_GPN_OD_MASK, WM831X_GPN_OD);
144
	case PIN_CONFIG_DRIVE_PUSH_PULL:
145 146
		return wm831x_set_bits(wm831x, reg,
				       WM831X_GPN_OD_MASK, 0);
147 148 149
	case PIN_CONFIG_INPUT_DEBOUNCE:
		return wm831x_gpio_set_debounce(wm831x, offset,
			pinconf_to_config_argument(config));
150 151 152 153 154 155 156
	default:
		break;
	}

	return -ENOTSUPP;
}

Mark Brown's avatar
Mark Brown committed
157 158 159
#ifdef CONFIG_DEBUG_FS
static void wm831x_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
{
160
	struct wm831x_gpio *wm831x_gpio = gpiochip_get_data(chip);
Mark Brown's avatar
Mark Brown committed
161
	struct wm831x *wm831x = wm831x_gpio->wm831x;
162
	int i, tristated;
Mark Brown's avatar
Mark Brown committed
163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197

	for (i = 0; i < chip->ngpio; i++) {
		int gpio = i + chip->base;
		int reg;
		const char *label, *pull, *powerdomain;

		/* We report the GPIO even if it's not requested since
		 * we're also reporting things like alternate
		 * functions which apply even when the GPIO is not in
		 * use as a GPIO.
		 */
		label = gpiochip_is_requested(chip, i);
		if (!label)
			label = "Unrequested";

		seq_printf(s, " gpio-%-3d (%-20.20s) ", gpio, label);

		reg = wm831x_reg_read(wm831x, WM831X_GPIO1_CONTROL + i);
		if (reg < 0) {
			dev_err(wm831x->dev,
				"GPIO control %d read failed: %d\n",
				gpio, reg);
			seq_printf(s, "\n");
			continue;
		}

		switch (reg & WM831X_GPN_PULL_MASK) {
		case WM831X_GPIO_PULL_NONE:
			pull = "nopull";
			break;
		case WM831X_GPIO_PULL_DOWN:
			pull = "pulldown";
			break;
		case WM831X_GPIO_PULL_UP:
			pull = "pullup";
198
			break;
Mark Brown's avatar
Mark Brown committed
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
		default:
			pull = "INVALID PULL";
			break;
		}

		switch (i + 1) {
		case 1 ... 3:
		case 7 ... 9:
			if (reg & WM831X_GPN_PWR_DOM)
				powerdomain = "VPMIC";
			else
				powerdomain = "DBVDD";
			break;

		case 4 ... 6:
		case 10 ... 12:
			if (reg & WM831X_GPN_PWR_DOM)
				powerdomain = "SYSVDD";
			else
				powerdomain = "DBVDD";
			break;

		case 13 ... 16:
			powerdomain = "TPVDD";
			break;

		default:
			BUG();
			break;
		}

230 231 232 233
		tristated = reg & WM831X_GPN_TRI;
		if (wm831x->has_gpio_ena)
			tristated = !tristated;

Mark Brown's avatar
Mark Brown committed
234 235 236 237 238 239
		seq_printf(s, " %s %s %s %s%s\n"
			   "                                  %s%s (0x%4x)\n",
			   reg & WM831X_GPN_DIR ? "in" : "out",
			   wm831x_gpio_get(chip, i) ? "high" : "low",
			   pull,
			   powerdomain,
240
			   reg & WM831X_GPN_POL ? "" : " inverted",
241
			   reg & WM831X_GPN_OD ? "open-drain" : "push-pull",
242
			   tristated ? " tristated" : "",
Mark Brown's avatar
Mark Brown committed
243 244 245 246 247 248 249
			   reg);
	}
}
#else
#define wm831x_gpio_dbg_show NULL
#endif

250
static const struct gpio_chip template_chip = {
Mark Brown's avatar
Mark Brown committed
251 252 253 254 255 256
	.label			= "wm831x",
	.owner			= THIS_MODULE,
	.direction_input	= wm831x_gpio_direction_in,
	.get			= wm831x_gpio_get,
	.direction_output	= wm831x_gpio_direction_out,
	.set			= wm831x_gpio_set,
257
	.to_irq			= wm831x_gpio_to_irq,
258
	.set_config		= wm831x_set_config,
Mark Brown's avatar
Mark Brown committed
259
	.dbg_show		= wm831x_gpio_dbg_show,
260
	.can_sleep		= true,
Mark Brown's avatar
Mark Brown committed
261 262
};

Bill Pemberton's avatar
Bill Pemberton committed
263
static int wm831x_gpio_probe(struct platform_device *pdev)
Mark Brown's avatar
Mark Brown committed
264 265
{
	struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
Jingoo Han's avatar
Jingoo Han committed
266
	struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
Mark Brown's avatar
Mark Brown committed
267 268 269
	struct wm831x_gpio *wm831x_gpio;
	int ret;

270 271
	wm831x_gpio = devm_kzalloc(&pdev->dev, sizeof(*wm831x_gpio),
				   GFP_KERNEL);
Mark Brown's avatar
Mark Brown committed
272 273 274 275 276
	if (wm831x_gpio == NULL)
		return -ENOMEM;

	wm831x_gpio->wm831x = wm831x;
	wm831x_gpio->gpio_chip = template_chip;
277
	wm831x_gpio->gpio_chip.ngpio = wm831x->num_gpio;
278
	wm831x_gpio->gpio_chip.parent = &pdev->dev;
Mark Brown's avatar
Mark Brown committed
279 280 281 282 283
	if (pdata && pdata->gpio_base)
		wm831x_gpio->gpio_chip.base = pdata->gpio_base;
	else
		wm831x_gpio->gpio_chip.base = -1;

284 285
	ret = devm_gpiochip_add_data(&pdev->dev, &wm831x_gpio->gpio_chip,
				     wm831x_gpio);
Mark Brown's avatar
Mark Brown committed
286
	if (ret < 0) {
287 288
		dev_err(&pdev->dev, "Could not register gpiochip, %d\n", ret);
		return ret;
Mark Brown's avatar
Mark Brown committed
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
	}

	platform_set_drvdata(pdev, wm831x_gpio);

	return ret;
}

static struct platform_driver wm831x_gpio_driver = {
	.driver.name	= "wm831x-gpio",
	.probe		= wm831x_gpio_probe,
};

static int __init wm831x_gpio_init(void)
{
	return platform_driver_register(&wm831x_gpio_driver);
}
subsys_initcall(wm831x_gpio_init);

static void __exit wm831x_gpio_exit(void)
{
	platform_driver_unregister(&wm831x_gpio_driver);
}
module_exit(wm831x_gpio_exit);

MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
MODULE_DESCRIPTION("GPIO interface for WM831x PMICs");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:wm831x-gpio");