gpio-wm831x.c 7.35 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 35 36 37 38 39 40 41

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

static inline struct wm831x_gpio *to_wm831x_gpio(struct gpio_chip *chip)
{
	return container_of(chip, struct wm831x_gpio, gpio_chip);
}

static int wm831x_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
{
	struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
	struct wm831x *wm831x = wm831x_gpio->wm831x;
42 43 44 45
	int val = WM831X_GPN_DIR;

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

	return wm831x_set_bits(wm831x, WM831X_GPIO1_CONTROL + offset,
48 49
			       WM831X_GPN_DIR | WM831X_GPN_TRI |
			       WM831X_GPN_FN_MASK, val);
Mark Brown's avatar
Mark Brown committed
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
}

static int wm831x_gpio_get(struct gpio_chip *chip, unsigned offset)
{
	struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
	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;
}

68
static void wm831x_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
Mark Brown's avatar
Mark Brown committed
69 70 71 72
{
	struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
	struct wm831x *wm831x = wm831x_gpio->wm831x;

73 74
	wm831x_set_bits(wm831x, WM831X_GPIO_LEVEL, 1 << offset,
			value << offset);
Mark Brown's avatar
Mark Brown committed
75 76
}

77 78
static int wm831x_gpio_direction_out(struct gpio_chip *chip,
				     unsigned offset, int value)
Mark Brown's avatar
Mark Brown committed
79 80 81
{
	struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
	struct wm831x *wm831x = wm831x_gpio->wm831x;
82
	int val = 0;
83
	int ret;
Mark Brown's avatar
Mark Brown committed
84

85 86 87
	if (wm831x->has_gpio_ena)
		val |= WM831X_GPN_TRI;

88
	ret = wm831x_set_bits(wm831x, WM831X_GPIO1_CONTROL + offset,
89 90
			      WM831X_GPN_DIR | WM831X_GPN_TRI |
			      WM831X_GPN_FN_MASK, val);
91 92 93 94 95 96 97
	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
98 99
}

100 101 102 103 104
static int wm831x_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
{
	struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
	struct wm831x *wm831x = wm831x_gpio->wm831x;

Mark Brown's avatar
Mark Brown committed
105 106
	return irq_create_mapping(wm831x->irq_domain,
				  WM831X_IRQ_GPIO_1 + offset);
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 133 134 135 136 137 138 139
static int wm831x_gpio_set_debounce(struct gpio_chip *chip, unsigned offset,
				    unsigned debounce)
{
	struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
	struct wm831x *wm831x = wm831x_gpio->wm831x;
	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);
}

Mark Brown's avatar
Mark Brown committed
140 141 142 143 144
#ifdef CONFIG_DEBUG_FS
static void wm831x_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
{
	struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
	struct wm831x *wm831x = wm831x_gpio->wm831x;
145
	int i, tristated;
Mark Brown's avatar
Mark Brown committed
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180

	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";
181
			break;
Mark Brown's avatar
Mark Brown committed
182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
		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;
		}

213 214 215 216
		tristated = reg & WM831X_GPN_TRI;
		if (wm831x->has_gpio_ena)
			tristated = !tristated;

Mark Brown's avatar
Mark Brown committed
217 218 219 220 221 222
		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,
223
			   reg & WM831X_GPN_POL ? "" : " inverted",
Mark Brown's avatar
Mark Brown committed
224
			   reg & WM831X_GPN_OD ? "open-drain" : "CMOS",
225
			   tristated ? " tristated" : "",
Mark Brown's avatar
Mark Brown committed
226 227 228 229 230 231 232 233 234 235 236 237 238 239
			   reg);
	}
}
#else
#define wm831x_gpio_dbg_show NULL
#endif

static struct gpio_chip template_chip = {
	.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,
240
	.to_irq			= wm831x_gpio_to_irq,
241
	.set_debounce		= wm831x_gpio_set_debounce,
Mark Brown's avatar
Mark Brown committed
242
	.dbg_show		= wm831x_gpio_dbg_show,
243
	.can_sleep		= true,
Mark Brown's avatar
Mark Brown committed
244 245
};

Bill Pemberton's avatar
Bill Pemberton committed
246
static int wm831x_gpio_probe(struct platform_device *pdev)
Mark Brown's avatar
Mark Brown committed
247 248
{
	struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
Jingoo Han's avatar
Jingoo Han committed
249
	struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
Mark Brown's avatar
Mark Brown committed
250 251 252
	struct wm831x_gpio *wm831x_gpio;
	int ret;

253 254
	wm831x_gpio = devm_kzalloc(&pdev->dev, sizeof(*wm831x_gpio),
				   GFP_KERNEL);
Mark Brown's avatar
Mark Brown committed
255 256 257 258 259
	if (wm831x_gpio == NULL)
		return -ENOMEM;

	wm831x_gpio->wm831x = wm831x;
	wm831x_gpio->gpio_chip = template_chip;
260
	wm831x_gpio->gpio_chip.ngpio = wm831x->num_gpio;
Mark Brown's avatar
Mark Brown committed
261 262 263 264 265 266 267 268
	wm831x_gpio->gpio_chip.dev = &pdev->dev;
	if (pdata && pdata->gpio_base)
		wm831x_gpio->gpio_chip.base = pdata->gpio_base;
	else
		wm831x_gpio->gpio_chip.base = -1;

	ret = gpiochip_add(&wm831x_gpio->gpio_chip);
	if (ret < 0) {
269 270
		dev_err(&pdev->dev, "Could not register gpiochip, %d\n", ret);
		return ret;
Mark Brown's avatar
Mark Brown committed
271 272 273 274 275 276 277
	}

	platform_set_drvdata(pdev, wm831x_gpio);

	return ret;
}

Bill Pemberton's avatar
Bill Pemberton committed
278
static int wm831x_gpio_remove(struct platform_device *pdev)
Mark Brown's avatar
Mark Brown committed
279 280 281
{
	struct wm831x_gpio *wm831x_gpio = platform_get_drvdata(pdev);

282 283
	gpiochip_remove(&wm831x_gpio->gpio_chip);
	return 0;
Mark Brown's avatar
Mark Brown committed
284 285 286 287 288 289
}

static struct platform_driver wm831x_gpio_driver = {
	.driver.name	= "wm831x-gpio",
	.driver.owner	= THIS_MODULE,
	.probe		= wm831x_gpio_probe,
290
	.remove		= wm831x_gpio_remove,
Mark Brown's avatar
Mark Brown committed
291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308
};

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");