1/*
2 * OF helpers for the GPIO API
3 *
4 * Copyright (c) 2007-2008  MontaVista Software, Inc.
5 *
6 * Author: Anton Vorontsov <avorontsov@ru.mvista.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 */
13
14#include <linux/device.h>
15#include <linux/err.h>
16#include <linux/errno.h>
17#include <linux/module.h>
18#include <linux/io.h>
19#include <linux/gpio/consumer.h>
20#include <linux/of.h>
21#include <linux/of_address.h>
22#include <linux/of_gpio.h>
23#include <linux/pinctrl/pinctrl.h>
24#include <linux/slab.h>
25#include <linux/gpio/machine.h>
26
27#include "gpiolib.h"
28
29/* Private data structure for of_gpiochip_find_and_xlate */
30struct gg_data {
31	enum of_gpio_flags *flags;
32	struct of_phandle_args gpiospec;
33
34	struct gpio_desc *out_gpio;
35};
36
37/* Private function for resolving node pointer to gpio_chip */
38static int of_gpiochip_find_and_xlate(struct gpio_chip *gc, void *data)
39{
40	struct gg_data *gg_data = data;
41	int ret;
42
43	if ((gc->of_node != gg_data->gpiospec.np) ||
44	    (gc->of_gpio_n_cells != gg_data->gpiospec.args_count) ||
45	    (!gc->of_xlate))
46		return false;
47
48	ret = gc->of_xlate(gc, &gg_data->gpiospec, gg_data->flags);
49	if (ret < 0) {
50		/* We've found a gpio chip, but the translation failed.
51		 * Store translation error in out_gpio.
52		 * Return false to keep looking, as more than one gpio chip
53		 * could be registered per of-node.
54		 */
55		gg_data->out_gpio = ERR_PTR(ret);
56		return false;
57	 }
58
59	gg_data->out_gpio = gpiochip_get_desc(gc, ret);
60	return true;
61}
62
63/**
64 * of_get_named_gpiod_flags() - Get a GPIO descriptor and flags for GPIO API
65 * @np:		device node to get GPIO from
66 * @propname:	property name containing gpio specifier(s)
67 * @index:	index of the GPIO
68 * @flags:	a flags pointer to fill in
69 *
70 * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
71 * value on the error condition. If @flags is not NULL the function also fills
72 * in flags for the GPIO.
73 */
74struct gpio_desc *of_get_named_gpiod_flags(struct device_node *np,
75		     const char *propname, int index, enum of_gpio_flags *flags)
76{
77	/* Return -EPROBE_DEFER to support probe() functions to be called
78	 * later when the GPIO actually becomes available
79	 */
80	struct gg_data gg_data = {
81		.flags = flags,
82		.out_gpio = ERR_PTR(-EPROBE_DEFER)
83	};
84	int ret;
85
86	/* .of_xlate might decide to not fill in the flags, so clear it. */
87	if (flags)
88		*flags = 0;
89
90	ret = of_parse_phandle_with_args(np, propname, "#gpio-cells", index,
91					 &gg_data.gpiospec);
92	if (ret) {
93		pr_debug("%s: can't parse '%s' property of node '%s[%d]'\n",
94			__func__, propname, np->full_name, index);
95		return ERR_PTR(ret);
96	}
97
98	gpiochip_find(&gg_data, of_gpiochip_find_and_xlate);
99
100	of_node_put(gg_data.gpiospec.np);
101	pr_debug("%s: parsed '%s' property of node '%s[%d]' - status (%d)\n",
102		 __func__, propname, np->full_name, index,
103		 PTR_ERR_OR_ZERO(gg_data.out_gpio));
104	return gg_data.out_gpio;
105}
106
107int of_get_named_gpio_flags(struct device_node *np, const char *list_name,
108			    int index, enum of_gpio_flags *flags)
109{
110	struct gpio_desc *desc;
111
112	desc = of_get_named_gpiod_flags(np, list_name, index, flags);
113
114	if (IS_ERR(desc))
115		return PTR_ERR(desc);
116	else
117		return desc_to_gpio(desc);
118}
119EXPORT_SYMBOL(of_get_named_gpio_flags);
120
121/**
122 * of_get_gpio_hog() - Get a GPIO hog descriptor, names and flags for GPIO API
123 * @np:		device node to get GPIO from
124 * @name:	GPIO line name
125 * @lflags:	gpio_lookup_flags - returned from of_find_gpio() or
126 *		of_get_gpio_hog()
127 * @dflags:	gpiod_flags - optional GPIO initialization flags
128 *
129 * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
130 * value on the error condition.
131 */
132static struct gpio_desc *of_get_gpio_hog(struct device_node *np,
133				  const char **name,
134				  enum gpio_lookup_flags *lflags,
135				  enum gpiod_flags *dflags)
136{
137	struct device_node *chip_np;
138	enum of_gpio_flags xlate_flags;
139	struct gpio_desc *desc;
140	struct gg_data gg_data = {
141		.flags = &xlate_flags,
142	};
143	u32 tmp;
144	int i, ret;
145
146	chip_np = np->parent;
147	if (!chip_np)
148		return ERR_PTR(-EINVAL);
149
150	xlate_flags = 0;
151	*lflags = 0;
152	*dflags = 0;
153
154	ret = of_property_read_u32(chip_np, "#gpio-cells", &tmp);
155	if (ret)
156		return ERR_PTR(ret);
157
158	if (tmp > MAX_PHANDLE_ARGS)
159		return ERR_PTR(-EINVAL);
160
161	gg_data.gpiospec.args_count = tmp;
162	gg_data.gpiospec.np = chip_np;
163	for (i = 0; i < tmp; i++) {
164		ret = of_property_read_u32_index(np, "gpios", i,
165					   &gg_data.gpiospec.args[i]);
166		if (ret)
167			return ERR_PTR(ret);
168	}
169
170	gpiochip_find(&gg_data, of_gpiochip_find_and_xlate);
171	if (!gg_data.out_gpio) {
172		if (np->parent == np)
173			return ERR_PTR(-ENXIO);
174		else
175			return ERR_PTR(-EINVAL);
176	}
177
178	if (xlate_flags & OF_GPIO_ACTIVE_LOW)
179		*lflags |= GPIO_ACTIVE_LOW;
180
181	if (of_property_read_bool(np, "input"))
182		*dflags |= GPIOD_IN;
183	else if (of_property_read_bool(np, "output-low"))
184		*dflags |= GPIOD_OUT_LOW;
185	else if (of_property_read_bool(np, "output-high"))
186		*dflags |= GPIOD_OUT_HIGH;
187	else {
188		pr_warn("GPIO line %d (%s): no hogging state specified, bailing out\n",
189			desc_to_gpio(gg_data.out_gpio), np->name);
190		return ERR_PTR(-EINVAL);
191	}
192
193	if (name && of_property_read_string(np, "line-name", name))
194		*name = np->name;
195
196	desc = gg_data.out_gpio;
197
198	return desc;
199}
200
201/**
202 * of_gpiochip_scan_hogs - Scan gpio-controller and apply GPIO hog as requested
203 * @chip:	gpio chip to act on
204 *
205 * This is only used by of_gpiochip_add to request/set GPIO initial
206 * configuration.
207 */
208static void of_gpiochip_scan_hogs(struct gpio_chip *chip)
209{
210	struct gpio_desc *desc = NULL;
211	struct device_node *np;
212	const char *name;
213	enum gpio_lookup_flags lflags;
214	enum gpiod_flags dflags;
215
216	for_each_child_of_node(chip->of_node, np) {
217		if (!of_property_read_bool(np, "gpio-hog"))
218			continue;
219
220		desc = of_get_gpio_hog(np, &name, &lflags, &dflags);
221		if (IS_ERR(desc))
222			continue;
223
224		if (gpiod_hog(desc, name, lflags, dflags))
225			continue;
226	}
227}
228
229/**
230 * of_gpio_simple_xlate - translate gpio_spec to the GPIO number and flags
231 * @gc:		pointer to the gpio_chip structure
232 * @np:		device node of the GPIO chip
233 * @gpio_spec:	gpio specifier as found in the device tree
234 * @flags:	a flags pointer to fill in
235 *
236 * This is simple translation function, suitable for the most 1:1 mapped
237 * gpio chips. This function performs only one sanity check: whether gpio
238 * is less than ngpios (that is specified in the gpio_chip).
239 */
240int of_gpio_simple_xlate(struct gpio_chip *gc,
241			 const struct of_phandle_args *gpiospec, u32 *flags)
242{
243	/*
244	 * We're discouraging gpio_cells < 2, since that way you'll have to
245	 * write your own xlate function (that will have to retrive the GPIO
246	 * number and the flags from a single gpio cell -- this is possible,
247	 * but not recommended).
248	 */
249	if (gc->of_gpio_n_cells < 2) {
250		WARN_ON(1);
251		return -EINVAL;
252	}
253
254	if (WARN_ON(gpiospec->args_count < gc->of_gpio_n_cells))
255		return -EINVAL;
256
257	if (gpiospec->args[0] >= gc->ngpio)
258		return -EINVAL;
259
260	if (flags)
261		*flags = gpiospec->args[1];
262
263	return gpiospec->args[0];
264}
265EXPORT_SYMBOL(of_gpio_simple_xlate);
266
267/**
268 * of_mm_gpiochip_add - Add memory mapped GPIO chip (bank)
269 * @np:		device node of the GPIO chip
270 * @mm_gc:	pointer to the of_mm_gpio_chip allocated structure
271 *
272 * To use this function you should allocate and fill mm_gc with:
273 *
274 * 1) In the gpio_chip structure:
275 *    - all the callbacks
276 *    - of_gpio_n_cells
277 *    - of_xlate callback (optional)
278 *
279 * 3) In the of_mm_gpio_chip structure:
280 *    - save_regs callback (optional)
281 *
282 * If succeeded, this function will map bank's memory and will
283 * do all necessary work for you. Then you'll able to use .regs
284 * to manage GPIOs from the callbacks.
285 */
286int of_mm_gpiochip_add(struct device_node *np,
287		       struct of_mm_gpio_chip *mm_gc)
288{
289	int ret = -ENOMEM;
290	struct gpio_chip *gc = &mm_gc->gc;
291
292	gc->label = kstrdup(np->full_name, GFP_KERNEL);
293	if (!gc->label)
294		goto err0;
295
296	mm_gc->regs = of_iomap(np, 0);
297	if (!mm_gc->regs)
298		goto err1;
299
300	gc->base = -1;
301
302	if (mm_gc->save_regs)
303		mm_gc->save_regs(mm_gc);
304
305	mm_gc->gc.of_node = np;
306
307	ret = gpiochip_add(gc);
308	if (ret)
309		goto err2;
310
311	return 0;
312err2:
313	iounmap(mm_gc->regs);
314err1:
315	kfree(gc->label);
316err0:
317	pr_err("%s: GPIO chip registration failed with status %d\n",
318	       np->full_name, ret);
319	return ret;
320}
321EXPORT_SYMBOL(of_mm_gpiochip_add);
322
323/**
324 * of_mm_gpiochip_remove - Remove memory mapped GPIO chip (bank)
325 * @mm_gc:	pointer to the of_mm_gpio_chip allocated structure
326 */
327void of_mm_gpiochip_remove(struct of_mm_gpio_chip *mm_gc)
328{
329	struct gpio_chip *gc = &mm_gc->gc;
330
331	if (!mm_gc)
332		return;
333
334	gpiochip_remove(gc);
335	iounmap(mm_gc->regs);
336	kfree(gc->label);
337}
338EXPORT_SYMBOL(of_mm_gpiochip_remove);
339
340#ifdef CONFIG_PINCTRL
341static void of_gpiochip_add_pin_range(struct gpio_chip *chip)
342{
343	struct device_node *np = chip->of_node;
344	struct of_phandle_args pinspec;
345	struct pinctrl_dev *pctldev;
346	int index = 0, ret;
347	const char *name;
348	static const char group_names_propname[] = "gpio-ranges-group-names";
349	struct property *group_names;
350
351	if (!np)
352		return;
353
354	group_names = of_find_property(np, group_names_propname, NULL);
355
356	for (;; index++) {
357		ret = of_parse_phandle_with_fixed_args(np, "gpio-ranges", 3,
358				index, &pinspec);
359		if (ret)
360			break;
361
362		pctldev = of_pinctrl_get(pinspec.np);
363		if (!pctldev)
364			break;
365
366		if (pinspec.args[2]) {
367			if (group_names) {
368				ret = of_property_read_string_index(np,
369						group_names_propname,
370						index, &name);
371				if (strlen(name)) {
372					pr_err("%s: Group name of numeric GPIO ranges must be the empty string.\n",
373						np->full_name);
374					break;
375				}
376			}
377			/* npins != 0: linear range */
378			ret = gpiochip_add_pin_range(chip,
379					pinctrl_dev_get_devname(pctldev),
380					pinspec.args[0],
381					pinspec.args[1],
382					pinspec.args[2]);
383			if (ret)
384				break;
385		} else {
386			/* npins == 0: special range */
387			if (pinspec.args[1]) {
388				pr_err("%s: Illegal gpio-range format.\n",
389					np->full_name);
390				break;
391			}
392
393			if (!group_names) {
394				pr_err("%s: GPIO group range requested but no %s property.\n",
395					np->full_name, group_names_propname);
396				break;
397			}
398
399			ret = of_property_read_string_index(np,
400						group_names_propname,
401						index, &name);
402			if (ret)
403				break;
404
405			if (!strlen(name)) {
406				pr_err("%s: Group name of GPIO group range cannot be the empty string.\n",
407				np->full_name);
408				break;
409			}
410
411			ret = gpiochip_add_pingroup_range(chip, pctldev,
412						pinspec.args[0], name);
413			if (ret)
414				break;
415		}
416	}
417}
418
419#else
420static void of_gpiochip_add_pin_range(struct gpio_chip *chip) {}
421#endif
422
423void of_gpiochip_add(struct gpio_chip *chip)
424{
425	if ((!chip->of_node) && (chip->dev))
426		chip->of_node = chip->dev->of_node;
427
428	if (!chip->of_node)
429		return;
430
431	if (!chip->of_xlate) {
432		chip->of_gpio_n_cells = 2;
433		chip->of_xlate = of_gpio_simple_xlate;
434	}
435
436	of_gpiochip_add_pin_range(chip);
437	of_node_get(chip->of_node);
438
439	of_gpiochip_scan_hogs(chip);
440}
441
442void of_gpiochip_remove(struct gpio_chip *chip)
443{
444	gpiochip_remove_pin_ranges(chip);
445	of_node_put(chip->of_node);
446}
447