• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/io.h>
17 #include <linux/of.h>
18 #include <linux/of_gpio.h>
19 #include <asm/prom.h>
20 
21 /**
22  * of_get_gpio_flags - Get a GPIO number and flags to use with GPIO API
23  * @np:		device node to get GPIO from
24  * @index:	index of the GPIO
25  * @flags:	a flags pointer to fill in
26  *
27  * Returns GPIO number to use with Linux generic GPIO API, or one of the errno
28  * value on the error condition. If @flags is not NULL the function also fills
29  * in flags for the GPIO.
30  */
of_get_gpio_flags(struct device_node * np,int index,enum of_gpio_flags * flags)31 int of_get_gpio_flags(struct device_node *np, int index,
32 		      enum of_gpio_flags *flags)
33 {
34 	int ret;
35 	struct device_node *gc;
36 	struct of_gpio_chip *of_gc = NULL;
37 	int size;
38 	const void *gpio_spec;
39 	const u32 *gpio_cells;
40 
41 	ret = of_parse_phandles_with_args(np, "gpios", "#gpio-cells", index,
42 					  &gc, &gpio_spec);
43 	if (ret) {
44 		pr_debug("%s: can't parse gpios property\n", __func__);
45 		goto err0;
46 	}
47 
48 	of_gc = gc->data;
49 	if (!of_gc) {
50 		pr_debug("%s: gpio controller %s isn't registered\n",
51 			 np->full_name, gc->full_name);
52 		ret = -ENODEV;
53 		goto err1;
54 	}
55 
56 	gpio_cells = of_get_property(gc, "#gpio-cells", &size);
57 	if (!gpio_cells || size != sizeof(*gpio_cells) ||
58 			*gpio_cells != of_gc->gpio_cells) {
59 		pr_debug("%s: wrong #gpio-cells for %s\n",
60 			 np->full_name, gc->full_name);
61 		ret = -EINVAL;
62 		goto err1;
63 	}
64 
65 	/* .xlate might decide to not fill in the flags, so clear it. */
66 	if (flags)
67 		*flags = 0;
68 
69 	ret = of_gc->xlate(of_gc, np, gpio_spec, flags);
70 	if (ret < 0)
71 		goto err1;
72 
73 	ret += of_gc->gc.base;
74 err1:
75 	of_node_put(gc);
76 err0:
77 	pr_debug("%s exited with status %d\n", __func__, ret);
78 	return ret;
79 }
80 EXPORT_SYMBOL(of_get_gpio_flags);
81 
82 /**
83  * of_gpio_count - Count GPIOs for a device
84  * @np:		device node to count GPIOs for
85  *
86  * The function returns the count of GPIOs specified for a node.
87  *
88  * Note that the empty GPIO specifiers counts too. For example,
89  *
90  * gpios = <0
91  *          &pio1 1 2
92  *          0
93  *          &pio2 3 4>;
94  *
95  * defines four GPIOs (so this function will return 4), two of which
96  * are not specified.
97  */
of_gpio_count(struct device_node * np)98 unsigned int of_gpio_count(struct device_node *np)
99 {
100 	unsigned int cnt = 0;
101 
102 	do {
103 		int ret;
104 
105 		ret = of_parse_phandles_with_args(np, "gpios", "#gpio-cells",
106 						  cnt, NULL, NULL);
107 		/* A hole in the gpios = <> counts anyway. */
108 		if (ret < 0 && ret != -EEXIST)
109 			break;
110 	} while (++cnt);
111 
112 	return cnt;
113 }
114 EXPORT_SYMBOL(of_gpio_count);
115 
116 /**
117  * of_gpio_simple_xlate - translate gpio_spec to the GPIO number and flags
118  * @of_gc:	pointer to the of_gpio_chip structure
119  * @np:		device node of the GPIO chip
120  * @gpio_spec:	gpio specifier as found in the device tree
121  * @flags:	a flags pointer to fill in
122  *
123  * This is simple translation function, suitable for the most 1:1 mapped
124  * gpio chips. This function performs only one sanity check: whether gpio
125  * is less than ngpios (that is specified in the gpio_chip).
126  */
of_gpio_simple_xlate(struct of_gpio_chip * of_gc,struct device_node * np,const void * gpio_spec,enum of_gpio_flags * flags)127 int of_gpio_simple_xlate(struct of_gpio_chip *of_gc, struct device_node *np,
128 			 const void *gpio_spec, enum of_gpio_flags *flags)
129 {
130 	const u32 *gpio = gpio_spec;
131 
132 	/*
133 	 * We're discouraging gpio_cells < 2, since that way you'll have to
134 	 * write your own xlate function (that will have to retrive the GPIO
135 	 * number and the flags from a single gpio cell -- this is possible,
136 	 * but not recommended).
137 	 */
138 	if (of_gc->gpio_cells < 2) {
139 		WARN_ON(1);
140 		return -EINVAL;
141 	}
142 
143 	if (*gpio > of_gc->gc.ngpio)
144 		return -EINVAL;
145 
146 	if (flags)
147 		*flags = gpio[1];
148 
149 	return *gpio;
150 }
151 EXPORT_SYMBOL(of_gpio_simple_xlate);
152 
153 /**
154  * of_mm_gpiochip_add - Add memory mapped GPIO chip (bank)
155  * @np:		device node of the GPIO chip
156  * @mm_gc:	pointer to the of_mm_gpio_chip allocated structure
157  *
158  * To use this function you should allocate and fill mm_gc with:
159  *
160  * 1) In the gpio_chip structure:
161  *    - all the callbacks
162  *
163  * 2) In the of_gpio_chip structure:
164  *    - gpio_cells
165  *    - xlate callback (optional)
166  *
167  * 3) In the of_mm_gpio_chip structure:
168  *    - save_regs callback (optional)
169  *
170  * If succeeded, this function will map bank's memory and will
171  * do all necessary work for you. Then you'll able to use .regs
172  * to manage GPIOs from the callbacks.
173  */
of_mm_gpiochip_add(struct device_node * np,struct of_mm_gpio_chip * mm_gc)174 int of_mm_gpiochip_add(struct device_node *np,
175 		       struct of_mm_gpio_chip *mm_gc)
176 {
177 	int ret = -ENOMEM;
178 	struct of_gpio_chip *of_gc = &mm_gc->of_gc;
179 	struct gpio_chip *gc = &of_gc->gc;
180 
181 	gc->label = kstrdup(np->full_name, GFP_KERNEL);
182 	if (!gc->label)
183 		goto err0;
184 
185 	mm_gc->regs = of_iomap(np, 0);
186 	if (!mm_gc->regs)
187 		goto err1;
188 
189 	gc->base = -1;
190 
191 	if (!of_gc->xlate)
192 		of_gc->xlate = of_gpio_simple_xlate;
193 
194 	if (mm_gc->save_regs)
195 		mm_gc->save_regs(mm_gc);
196 
197 	np->data = of_gc;
198 
199 	ret = gpiochip_add(gc);
200 	if (ret)
201 		goto err2;
202 
203 	/* We don't want to lose the node and its ->data */
204 	of_node_get(np);
205 
206 	pr_debug("%s: registered as generic GPIO chip, base is %d\n",
207 		 np->full_name, gc->base);
208 	return 0;
209 err2:
210 	np->data = NULL;
211 	iounmap(mm_gc->regs);
212 err1:
213 	kfree(gc->label);
214 err0:
215 	pr_err("%s: GPIO chip registration failed with status %d\n",
216 	       np->full_name, ret);
217 	return ret;
218 }
219 EXPORT_SYMBOL(of_mm_gpiochip_add);
220