blob: 24c3606217f86a5db00bbf36547ba90d0489e2b2 [file] [log] [blame]
Anton Vorontsov863fbf42008-04-11 23:06:45 +10001/*
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/**
Anton Vorontsovb908b532008-12-01 06:30:04 +000022 * of_get_gpio_flags - Get a GPIO number and flags to use with GPIO API
Anton Vorontsov863fbf42008-04-11 23:06:45 +100023 * @np: device node to get GPIO from
24 * @index: index of the GPIO
Anton Vorontsovb908b532008-12-01 06:30:04 +000025 * @flags: a flags pointer to fill in
Anton Vorontsov863fbf42008-04-11 23:06:45 +100026 *
27 * Returns GPIO number to use with Linux generic GPIO API, or one of the errno
Anton Vorontsovb908b532008-12-01 06:30:04 +000028 * value on the error condition. If @flags is not NULL the function also fills
29 * in flags for the GPIO.
Anton Vorontsov863fbf42008-04-11 23:06:45 +100030 */
Anton Vorontsovb908b532008-12-01 06:30:04 +000031int of_get_gpio_flags(struct device_node *np, int index,
32 enum of_gpio_flags *flags)
Anton Vorontsov863fbf42008-04-11 23:06:45 +100033{
Anton Vorontsov64b60e02008-10-10 04:43:17 +000034 int ret;
Anton Vorontsov863fbf42008-04-11 23:06:45 +100035 struct device_node *gc;
36 struct of_gpio_chip *of_gc = NULL;
37 int size;
Anton Vorontsov863fbf42008-04-11 23:06:45 +100038 const void *gpio_spec;
Jeremy Kerr33714882010-01-30 01:45:26 -070039 const __be32 *gpio_cells;
Anton Vorontsov863fbf42008-04-11 23:06:45 +100040
Anton Vorontsov64b60e02008-10-10 04:43:17 +000041 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__);
Anton Vorontsov863fbf42008-04-11 23:06:45 +100045 goto err0;
46 }
Anton Vorontsov863fbf42008-04-11 23:06:45 +100047
Anton Vorontsov64b60e02008-10-10 04:43:17 +000048 of_gc = gc->data;
Anton Vorontsov863fbf42008-04-11 23:06:45 +100049 if (!of_gc) {
Anton Vorontsov64b60e02008-10-10 04:43:17 +000050 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) ||
Jeremy Kerr33714882010-01-30 01:45:26 -070058 be32_to_cpup(gpio_cells) != of_gc->gpio_cells) {
Anton Vorontsov64b60e02008-10-10 04:43:17 +000059 pr_debug("%s: wrong #gpio-cells for %s\n",
60 np->full_name, gc->full_name);
61 ret = -EINVAL;
62 goto err1;
Anton Vorontsov863fbf42008-04-11 23:06:45 +100063 }
64
Anton Vorontsovb908b532008-12-01 06:30:04 +000065 /* .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);
Anton Vorontsov863fbf42008-04-11 23:06:45 +100070 if (ret < 0)
71 goto err1;
72
73 ret += of_gc->gc.base;
74err1:
75 of_node_put(gc);
76err0:
77 pr_debug("%s exited with status %d\n", __func__, ret);
78 return ret;
79}
Anton Vorontsovb908b532008-12-01 06:30:04 +000080EXPORT_SYMBOL(of_get_gpio_flags);
Anton Vorontsov863fbf42008-04-11 23:06:45 +100081
82/**
Anton Vorontsov74982092008-12-05 08:15:54 +000083 * 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 */
98unsigned 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}
114EXPORT_SYMBOL(of_gpio_count);
115
116/**
Anton Vorontsovb908b532008-12-01 06:30:04 +0000117 * of_gpio_simple_xlate - translate gpio_spec to the GPIO number and flags
Anton Vorontsov863fbf42008-04-11 23:06:45 +1000118 * @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
Anton Vorontsovb908b532008-12-01 06:30:04 +0000121 * @flags: a flags pointer to fill in
Anton Vorontsov863fbf42008-04-11 23:06:45 +1000122 *
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 */
127int of_gpio_simple_xlate(struct of_gpio_chip *of_gc, struct device_node *np,
Anton Vorontsovb908b532008-12-01 06:30:04 +0000128 const void *gpio_spec, enum of_gpio_flags *flags)
Anton Vorontsov863fbf42008-04-11 23:06:45 +1000129{
Jeremy Kerr33714882010-01-30 01:45:26 -0700130 const __be32 *gpio = gpio_spec;
131 const u32 n = be32_to_cpup(gpio);
Anton Vorontsov863fbf42008-04-11 23:06:45 +1000132
Anton Vorontsovb908b532008-12-01 06:30:04 +0000133 /*
134 * We're discouraging gpio_cells < 2, since that way you'll have to
135 * write your own xlate function (that will have to retrive the GPIO
136 * number and the flags from a single gpio cell -- this is possible,
137 * but not recommended).
138 */
139 if (of_gc->gpio_cells < 2) {
140 WARN_ON(1);
141 return -EINVAL;
142 }
143
Jeremy Kerr33714882010-01-30 01:45:26 -0700144 if (n > of_gc->gc.ngpio)
Anton Vorontsov863fbf42008-04-11 23:06:45 +1000145 return -EINVAL;
146
Anton Vorontsovb908b532008-12-01 06:30:04 +0000147 if (flags)
Jeremy Kerr33714882010-01-30 01:45:26 -0700148 *flags = be32_to_cpu(gpio[1]);
Anton Vorontsovb908b532008-12-01 06:30:04 +0000149
Jeremy Kerr33714882010-01-30 01:45:26 -0700150 return n;
Anton Vorontsov863fbf42008-04-11 23:06:45 +1000151}
152EXPORT_SYMBOL(of_gpio_simple_xlate);
153
Anton Vorontsov863fbf42008-04-11 23:06:45 +1000154/**
155 * of_mm_gpiochip_add - Add memory mapped GPIO chip (bank)
156 * @np: device node of the GPIO chip
157 * @mm_gc: pointer to the of_mm_gpio_chip allocated structure
158 *
159 * To use this function you should allocate and fill mm_gc with:
160 *
161 * 1) In the gpio_chip structure:
162 * - all the callbacks
163 *
164 * 2) In the of_gpio_chip structure:
165 * - gpio_cells
166 * - xlate callback (optional)
167 *
168 * 3) In the of_mm_gpio_chip structure:
169 * - save_regs callback (optional)
170 *
171 * If succeeded, this function will map bank's memory and will
172 * do all necessary work for you. Then you'll able to use .regs
173 * to manage GPIOs from the callbacks.
174 */
175int of_mm_gpiochip_add(struct device_node *np,
176 struct of_mm_gpio_chip *mm_gc)
177{
178 int ret = -ENOMEM;
179 struct of_gpio_chip *of_gc = &mm_gc->of_gc;
180 struct gpio_chip *gc = &of_gc->gc;
181
182 gc->label = kstrdup(np->full_name, GFP_KERNEL);
183 if (!gc->label)
184 goto err0;
185
186 mm_gc->regs = of_iomap(np, 0);
187 if (!mm_gc->regs)
188 goto err1;
189
Anton Vorontsov21451152008-04-30 00:05:24 +1000190 gc->base = -1;
Anton Vorontsov863fbf42008-04-11 23:06:45 +1000191
192 if (!of_gc->xlate)
193 of_gc->xlate = of_gpio_simple_xlate;
194
195 if (mm_gc->save_regs)
196 mm_gc->save_regs(mm_gc);
197
198 np->data = of_gc;
199
200 ret = gpiochip_add(gc);
201 if (ret)
202 goto err2;
203
204 /* We don't want to lose the node and its ->data */
205 of_node_get(np);
206
207 pr_debug("%s: registered as generic GPIO chip, base is %d\n",
208 np->full_name, gc->base);
209 return 0;
210err2:
211 np->data = NULL;
212 iounmap(mm_gc->regs);
213err1:
214 kfree(gc->label);
215err0:
216 pr_err("%s: GPIO chip registration failed with status %d\n",
217 np->full_name, ret);
218 return ret;
219}
220EXPORT_SYMBOL(of_mm_gpiochip_add);