xref: /openbmc/linux/drivers/gpio/gpiolib-of.c (revision c61307a7) 
1f141ed65SGrant Likely /*
2f141ed65SGrant Likely  * OF helpers for the GPIO API
3f141ed65SGrant Likely  *
4f141ed65SGrant Likely  * Copyright (c) 2007-2008  MontaVista Software, Inc.
5f141ed65SGrant Likely  *
6f141ed65SGrant Likely  * Author: Anton Vorontsov <avorontsov@ru.mvista.com>
7f141ed65SGrant Likely  *
8f141ed65SGrant Likely  * This program is free software; you can redistribute it and/or modify
9f141ed65SGrant Likely  * it under the terms of the GNU General Public License as published by
10f141ed65SGrant Likely  * the Free Software Foundation; either version 2 of the License, or
11f141ed65SGrant Likely  * (at your option) any later version.
12f141ed65SGrant Likely  */
13f141ed65SGrant Likely 
14f141ed65SGrant Likely #include <linux/device.h>
15f141ed65SGrant Likely #include <linux/errno.h>
16f141ed65SGrant Likely #include <linux/module.h>
17f141ed65SGrant Likely #include <linux/io.h>
183d0f7cf0SGrant Likely #include <linux/gpio.h>
19f141ed65SGrant Likely #include <linux/of.h>
20f141ed65SGrant Likely #include <linux/of_address.h>
21f141ed65SGrant Likely #include <linux/of_gpio.h>
22f141ed65SGrant Likely #include <linux/slab.h>
23f141ed65SGrant Likely 
240df2c999SDong Aisheng /* Private data structure for of_gpiochip_find_and_xlate */
253d0f7cf0SGrant Likely struct gg_data {
263d0f7cf0SGrant Likely 	enum of_gpio_flags *flags;
273d0f7cf0SGrant Likely 	struct of_phandle_args gpiospec;
283d0f7cf0SGrant Likely 
293d0f7cf0SGrant Likely 	int out_gpio;
303d0f7cf0SGrant Likely };
313d0f7cf0SGrant Likely 
323d0f7cf0SGrant Likely /* Private function for resolving node pointer to gpio_chip */
333d0f7cf0SGrant Likely static int of_gpiochip_find_and_xlate(struct gpio_chip *gc, void *data)
343d0f7cf0SGrant Likely {
353d0f7cf0SGrant Likely 	struct gg_data *gg_data = data;
363d0f7cf0SGrant Likely 	int ret;
373d0f7cf0SGrant Likely 
383d0f7cf0SGrant Likely 	if ((gc->of_node != gg_data->gpiospec.np) ||
393d0f7cf0SGrant Likely 	    (gc->of_gpio_n_cells != gg_data->gpiospec.args_count) ||
403d0f7cf0SGrant Likely 	    (!gc->of_xlate))
413d0f7cf0SGrant Likely 		return false;
423d0f7cf0SGrant Likely 
433d0f7cf0SGrant Likely 	ret = gc->of_xlate(gc, &gg_data->gpiospec, gg_data->flags);
443d0f7cf0SGrant Likely 	if (ret < 0)
453d0f7cf0SGrant Likely 		return false;
463d0f7cf0SGrant Likely 
473d0f7cf0SGrant Likely 	gg_data->out_gpio = ret + gc->base;
483d0f7cf0SGrant Likely 	return true;
493d0f7cf0SGrant Likely }
503d0f7cf0SGrant Likely 
51f141ed65SGrant Likely /**
52f141ed65SGrant Likely  * of_get_named_gpio_flags() - Get a GPIO number and flags to use with GPIO API
53f141ed65SGrant Likely  * @np:		device node to get GPIO from
54f141ed65SGrant Likely  * @propname:	property name containing gpio specifier(s)
55f141ed65SGrant Likely  * @index:	index of the GPIO
56f141ed65SGrant Likely  * @flags:	a flags pointer to fill in
57f141ed65SGrant Likely  *
58f141ed65SGrant Likely  * Returns GPIO number to use with Linux generic GPIO API, or one of the errno
59f141ed65SGrant Likely  * value on the error condition. If @flags is not NULL the function also fills
60f141ed65SGrant Likely  * in flags for the GPIO.
61f141ed65SGrant Likely  */
62f141ed65SGrant Likely int of_get_named_gpio_flags(struct device_node *np, const char *propname,
63f141ed65SGrant Likely                            int index, enum of_gpio_flags *flags)
64f141ed65SGrant Likely {
654fbb0022SRoland Stigge 	/* Return -EPROBE_DEFER to support probe() functions to be called
664fbb0022SRoland Stigge 	 * later when the GPIO actually becomes available
674fbb0022SRoland Stigge 	 */
684fbb0022SRoland Stigge 	struct gg_data gg_data = { .flags = flags, .out_gpio = -EPROBE_DEFER };
69f141ed65SGrant Likely 	int ret;
70f141ed65SGrant Likely 
713d0f7cf0SGrant Likely 	/* .of_xlate might decide to not fill in the flags, so clear it. */
72f141ed65SGrant Likely 	if (flags)
73f141ed65SGrant Likely 		*flags = 0;
74f141ed65SGrant Likely 
753d0f7cf0SGrant Likely 	ret = of_parse_phandle_with_args(np, propname, "#gpio-cells", index,
763d0f7cf0SGrant Likely 					 &gg_data.gpiospec);
773d0f7cf0SGrant Likely 	if (ret) {
783d0f7cf0SGrant Likely 		pr_debug("%s: can't parse gpios property\n", __func__);
7941920d16SAlexandre Courbot 		return ret;
803d0f7cf0SGrant Likely 	}
81f141ed65SGrant Likely 
823d0f7cf0SGrant Likely 	gpiochip_find(&gg_data, of_gpiochip_find_and_xlate);
833d0f7cf0SGrant Likely 
843d0f7cf0SGrant Likely 	of_node_put(gg_data.gpiospec.np);
85c61307a7SThierry Reding 	pr_debug("%s exited with status %d\n", __func__, gg_data.out_gpio);
863d0f7cf0SGrant Likely 	return gg_data.out_gpio;
87f141ed65SGrant Likely }
88f141ed65SGrant Likely EXPORT_SYMBOL(of_get_named_gpio_flags);
89f141ed65SGrant Likely 
90f141ed65SGrant Likely /**
91f141ed65SGrant Likely  * of_gpio_named_count - Count GPIOs for a device
92f141ed65SGrant Likely  * @np:		device node to count GPIOs for
93f141ed65SGrant Likely  * @propname:	property name containing gpio specifier(s)
94f141ed65SGrant Likely  *
95f141ed65SGrant Likely  * The function returns the count of GPIOs specified for a node.
96f141ed65SGrant Likely  *
97f141ed65SGrant Likely  * Note that the empty GPIO specifiers counts too. For example,
98f141ed65SGrant Likely  *
99f141ed65SGrant Likely  * gpios = <0
100f141ed65SGrant Likely  *          &pio1 1 2
101f141ed65SGrant Likely  *          0
102f141ed65SGrant Likely  *          &pio2 3 4>;
103f141ed65SGrant Likely  *
104f141ed65SGrant Likely  * defines four GPIOs (so this function will return 4), two of which
105f141ed65SGrant Likely  * are not specified.
106f141ed65SGrant Likely  */
107f141ed65SGrant Likely unsigned int of_gpio_named_count(struct device_node *np, const char* propname)
108f141ed65SGrant Likely {
109f141ed65SGrant Likely 	unsigned int cnt = 0;
110f141ed65SGrant Likely 
111f141ed65SGrant Likely 	do {
112f141ed65SGrant Likely 		int ret;
113f141ed65SGrant Likely 
114f141ed65SGrant Likely 		ret = of_parse_phandle_with_args(np, propname, "#gpio-cells",
115f141ed65SGrant Likely 						 cnt, NULL);
116f141ed65SGrant Likely 		/* A hole in the gpios = <> counts anyway. */
117f141ed65SGrant Likely 		if (ret < 0 && ret != -EEXIST)
118f141ed65SGrant Likely 			break;
119f141ed65SGrant Likely 	} while (++cnt);
120f141ed65SGrant Likely 
121f141ed65SGrant Likely 	return cnt;
122f141ed65SGrant Likely }
123f141ed65SGrant Likely EXPORT_SYMBOL(of_gpio_named_count);
124f141ed65SGrant Likely 
125f141ed65SGrant Likely /**
126f141ed65SGrant Likely  * of_gpio_simple_xlate - translate gpio_spec to the GPIO number and flags
127f141ed65SGrant Likely  * @gc:		pointer to the gpio_chip structure
128f141ed65SGrant Likely  * @np:		device node of the GPIO chip
129f141ed65SGrant Likely  * @gpio_spec:	gpio specifier as found in the device tree
130f141ed65SGrant Likely  * @flags:	a flags pointer to fill in
131f141ed65SGrant Likely  *
132f141ed65SGrant Likely  * This is simple translation function, suitable for the most 1:1 mapped
133f141ed65SGrant Likely  * gpio chips. This function performs only one sanity check: whether gpio
134f141ed65SGrant Likely  * is less than ngpios (that is specified in the gpio_chip).
135f141ed65SGrant Likely  */
136f141ed65SGrant Likely int of_gpio_simple_xlate(struct gpio_chip *gc,
137f141ed65SGrant Likely 			 const struct of_phandle_args *gpiospec, u32 *flags)
138f141ed65SGrant Likely {
139f141ed65SGrant Likely 	/*
140f141ed65SGrant Likely 	 * We're discouraging gpio_cells < 2, since that way you'll have to
141f141ed65SGrant Likely 	 * write your own xlate function (that will have to retrive the GPIO
142f141ed65SGrant Likely 	 * number and the flags from a single gpio cell -- this is possible,
143f141ed65SGrant Likely 	 * but not recommended).
144f141ed65SGrant Likely 	 */
145f141ed65SGrant Likely 	if (gc->of_gpio_n_cells < 2) {
146f141ed65SGrant Likely 		WARN_ON(1);
147f141ed65SGrant Likely 		return -EINVAL;
148f141ed65SGrant Likely 	}
149f141ed65SGrant Likely 
150f141ed65SGrant Likely 	if (WARN_ON(gpiospec->args_count < gc->of_gpio_n_cells))
151f141ed65SGrant Likely 		return -EINVAL;
152f141ed65SGrant Likely 
1537b96c686SGrant Likely 	if (gpiospec->args[0] >= gc->ngpio)
154f141ed65SGrant Likely 		return -EINVAL;
155f141ed65SGrant Likely 
156f141ed65SGrant Likely 	if (flags)
157f141ed65SGrant Likely 		*flags = gpiospec->args[1];
158f141ed65SGrant Likely 
159f141ed65SGrant Likely 	return gpiospec->args[0];
160f141ed65SGrant Likely }
161f141ed65SGrant Likely EXPORT_SYMBOL(of_gpio_simple_xlate);
162f141ed65SGrant Likely 
163f141ed65SGrant Likely /**
164f141ed65SGrant Likely  * of_mm_gpiochip_add - Add memory mapped GPIO chip (bank)
165f141ed65SGrant Likely  * @np:		device node of the GPIO chip
166f141ed65SGrant Likely  * @mm_gc:	pointer to the of_mm_gpio_chip allocated structure
167f141ed65SGrant Likely  *
168f141ed65SGrant Likely  * To use this function you should allocate and fill mm_gc with:
169f141ed65SGrant Likely  *
170f141ed65SGrant Likely  * 1) In the gpio_chip structure:
171f141ed65SGrant Likely  *    - all the callbacks
172f141ed65SGrant Likely  *    - of_gpio_n_cells
173f141ed65SGrant Likely  *    - of_xlate callback (optional)
174f141ed65SGrant Likely  *
175f141ed65SGrant Likely  * 3) In the of_mm_gpio_chip structure:
176f141ed65SGrant Likely  *    - save_regs callback (optional)
177f141ed65SGrant Likely  *
178f141ed65SGrant Likely  * If succeeded, this function will map bank's memory and will
179f141ed65SGrant Likely  * do all necessary work for you. Then you'll able to use .regs
180f141ed65SGrant Likely  * to manage GPIOs from the callbacks.
181f141ed65SGrant Likely  */
182f141ed65SGrant Likely int of_mm_gpiochip_add(struct device_node *np,
183f141ed65SGrant Likely 		       struct of_mm_gpio_chip *mm_gc)
184f141ed65SGrant Likely {
185f141ed65SGrant Likely 	int ret = -ENOMEM;
186f141ed65SGrant Likely 	struct gpio_chip *gc = &mm_gc->gc;
187f141ed65SGrant Likely 
188f141ed65SGrant Likely 	gc->label = kstrdup(np->full_name, GFP_KERNEL);
189f141ed65SGrant Likely 	if (!gc->label)
190f141ed65SGrant Likely 		goto err0;
191f141ed65SGrant Likely 
192f141ed65SGrant Likely 	mm_gc->regs = of_iomap(np, 0);
193f141ed65SGrant Likely 	if (!mm_gc->regs)
194f141ed65SGrant Likely 		goto err1;
195f141ed65SGrant Likely 
196f141ed65SGrant Likely 	gc->base = -1;
197f141ed65SGrant Likely 
198f141ed65SGrant Likely 	if (mm_gc->save_regs)
199f141ed65SGrant Likely 		mm_gc->save_regs(mm_gc);
200f141ed65SGrant Likely 
201f141ed65SGrant Likely 	mm_gc->gc.of_node = np;
202f141ed65SGrant Likely 
203f141ed65SGrant Likely 	ret = gpiochip_add(gc);
204f141ed65SGrant Likely 	if (ret)
205f141ed65SGrant Likely 		goto err2;
206f141ed65SGrant Likely 
207f141ed65SGrant Likely 	return 0;
208f141ed65SGrant Likely err2:
209f141ed65SGrant Likely 	iounmap(mm_gc->regs);
210f141ed65SGrant Likely err1:
211f141ed65SGrant Likely 	kfree(gc->label);
212f141ed65SGrant Likely err0:
213f141ed65SGrant Likely 	pr_err("%s: GPIO chip registration failed with status %d\n",
214f141ed65SGrant Likely 	       np->full_name, ret);
215f141ed65SGrant Likely 	return ret;
216f141ed65SGrant Likely }
217f141ed65SGrant Likely EXPORT_SYMBOL(of_mm_gpiochip_add);
218f141ed65SGrant Likely 
219f141ed65SGrant Likely void of_gpiochip_add(struct gpio_chip *chip)
220f141ed65SGrant Likely {
221f141ed65SGrant Likely 	if ((!chip->of_node) && (chip->dev))
222f141ed65SGrant Likely 		chip->of_node = chip->dev->of_node;
223f141ed65SGrant Likely 
224f141ed65SGrant Likely 	if (!chip->of_node)
225f141ed65SGrant Likely 		return;
226f141ed65SGrant Likely 
227f141ed65SGrant Likely 	if (!chip->of_xlate) {
228f141ed65SGrant Likely 		chip->of_gpio_n_cells = 2;
229f141ed65SGrant Likely 		chip->of_xlate = of_gpio_simple_xlate;
230f141ed65SGrant Likely 	}
231f141ed65SGrant Likely 
232f141ed65SGrant Likely 	of_node_get(chip->of_node);
233f141ed65SGrant Likely }
234f141ed65SGrant Likely 
235f141ed65SGrant Likely void of_gpiochip_remove(struct gpio_chip *chip)
236f141ed65SGrant Likely {
237f141ed65SGrant Likely 	if (chip->of_node)
238f141ed65SGrant Likely 		of_node_put(chip->of_node);
239f141ed65SGrant Likely }
240