We are currently experiencing downtime impacting viewing & cloning the Mesa repo, and some GitLab pages returning 503. Please see #freedesktop on IRC for more updates.

gpio-wm831x.c 7.25 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 105 106
static int wm831x_gpio_set_debounce(struct gpio_chip *chip, unsigned offset,
				    unsigned debounce)
{
107
	struct wm831x_gpio *wm831x_gpio = gpiochip_get_data(chip);
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
	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
135 136 137
#ifdef CONFIG_DEBUG_FS
static void wm831x_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
{
138
	struct wm831x_gpio *wm831x_gpio = gpiochip_get_data(chip);
Mark Brown's avatar
Mark Brown committed
139
	struct wm831x *wm831x = wm831x_gpio->wm831x;
140
	int i, tristated;
Mark Brown's avatar
Mark Brown committed
141 142 143 144 145 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

	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";
176
			break;
Mark Brown's avatar
Mark Brown committed
177 178 179 180 181 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
		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;
		}

208 209 210 211
		tristated = reg & WM831X_GPN_TRI;
		if (wm831x->has_gpio_ena)
			tristated = !tristated;

Mark Brown's avatar
Mark Brown committed
212 213 214 215 216 217
		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,
218
			   reg & WM831X_GPN_POL ? "" : " inverted",
Mark Brown's avatar
Mark Brown committed
219
			   reg & WM831X_GPN_OD ? "open-drain" : "CMOS",
220
			   tristated ? " tristated" : "",
Mark Brown's avatar
Mark Brown committed
221 222 223 224 225 226 227 228 229 230 231 232 233 234
			   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,
235
	.to_irq			= wm831x_gpio_to_irq,
236
	.set_debounce		= wm831x_gpio_set_debounce,
Mark Brown's avatar
Mark Brown committed
237
	.dbg_show		= wm831x_gpio_dbg_show,
238
	.can_sleep		= true,
Mark Brown's avatar
Mark Brown committed
239 240
};

Bill Pemberton's avatar
Bill Pemberton committed
241
static int wm831x_gpio_probe(struct platform_device *pdev)
Mark Brown's avatar
Mark Brown committed
242 243
{
	struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
Jingoo Han's avatar
Jingoo Han committed
244
	struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
Mark Brown's avatar
Mark Brown committed
245 246 247
	struct wm831x_gpio *wm831x_gpio;
	int ret;

248 249
	wm831x_gpio = devm_kzalloc(&pdev->dev, sizeof(*wm831x_gpio),
				   GFP_KERNEL);
Mark Brown's avatar
Mark Brown committed
250 251 252 253 254
	if (wm831x_gpio == NULL)
		return -ENOMEM;

	wm831x_gpio->wm831x = wm831x;
	wm831x_gpio->gpio_chip = template_chip;
255
	wm831x_gpio->gpio_chip.ngpio = wm831x->num_gpio;
256
	wm831x_gpio->gpio_chip.parent = &pdev->dev;
Mark Brown's avatar
Mark Brown committed
257 258 259 260 261
	if (pdata && pdata->gpio_base)
		wm831x_gpio->gpio_chip.base = pdata->gpio_base;
	else
		wm831x_gpio->gpio_chip.base = -1;

262
	ret = gpiochip_add_data(&wm831x_gpio->gpio_chip, wm831x_gpio);
Mark Brown's avatar
Mark Brown committed
263
	if (ret < 0) {
264 265
		dev_err(&pdev->dev, "Could not register gpiochip, %d\n", ret);
		return ret;
Mark Brown's avatar
Mark Brown committed
266 267 268 269 270 271 272
	}

	platform_set_drvdata(pdev, wm831x_gpio);

	return ret;
}

Bill Pemberton's avatar
Bill Pemberton committed
273
static int wm831x_gpio_remove(struct platform_device *pdev)
Mark Brown's avatar
Mark Brown committed
274 275 276
{
	struct wm831x_gpio *wm831x_gpio = platform_get_drvdata(pdev);

277 278
	gpiochip_remove(&wm831x_gpio->gpio_chip);
	return 0;
Mark Brown's avatar
Mark Brown committed
279 280 281 282 283 284
}

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

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