blob: 07ba82317eceb04493d9fa56e46cacfa98f1c59e [file] [log] [blame]
John Crispin1a0703e2011-12-20 21:40:21 +01001/*
2 * drivers/gpio/devres.c - managed gpio resources
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2
6 * as published by the Free Software Foundation.
7 *
8 * You should have received a copy of the GNU General Public License
9 * along with this program; if not, write to the Free Software
10 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
11 *
12 * This file is based on kernel/irq/devres.c
13 *
14 * Copyright (c) 2011 John Crispin <blogic@openwrt.org>
15 */
16
17#include <linux/module.h>
Alexandre Courbot3c2c6282013-10-20 15:14:58 -070018#include <linux/err.h>
John Crispin1a0703e2011-12-20 21:40:21 +010019#include <linux/gpio.h>
Alexandre Courbot3c2c6282013-10-20 15:14:58 -070020#include <linux/gpio/consumer.h>
John Crispin1a0703e2011-12-20 21:40:21 +010021#include <linux/device.h>
22#include <linux/gfp.h>
23
Alexandre Courbotbae48da2013-10-17 10:21:38 -070024static void devm_gpiod_release(struct device *dev, void *res)
25{
26 struct gpio_desc **desc = res;
27
28 gpiod_put(*desc);
29}
30
31static int devm_gpiod_match(struct device *dev, void *res, void *data)
32{
33 struct gpio_desc **this = res, **gpio = data;
34
35 return *this == *gpio;
36}
37
Rojhalat Ibrahim331758e2015-02-11 17:28:02 +010038static void devm_gpiod_release_array(struct device *dev, void *res)
39{
40 struct gpio_descs **descs = res;
41
42 gpiod_put_array(*descs);
43}
44
45static int devm_gpiod_match_array(struct device *dev, void *res, void *data)
46{
47 struct gpio_descs **this = res, **gpios = data;
48
49 return *this == *gpios;
50}
51
Alexandre Courbotbae48da2013-10-17 10:21:38 -070052/**
53 * devm_gpiod_get - Resource-managed gpiod_get()
54 * @dev: GPIO consumer
55 * @con_id: function within the GPIO consumer
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +090056 * @flags: optional GPIO initialization flags
Alexandre Courbotbae48da2013-10-17 10:21:38 -070057 *
58 * Managed gpiod_get(). GPIO descriptors returned from this function are
59 * automatically disposed on driver detach. See gpiod_get() for detailed
60 * information about behavior and return values.
61 */
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +090062struct gpio_desc *__must_check __devm_gpiod_get(struct device *dev,
63 const char *con_id,
64 enum gpiod_flags flags)
Alexandre Courbotbae48da2013-10-17 10:21:38 -070065{
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +090066 return devm_gpiod_get_index(dev, con_id, 0, flags);
Alexandre Courbotbae48da2013-10-17 10:21:38 -070067}
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +090068EXPORT_SYMBOL(__devm_gpiod_get);
Alexandre Courbotbae48da2013-10-17 10:21:38 -070069
70/**
Thierry Reding29a1f2332014-04-25 17:10:06 +020071 * devm_gpiod_get_optional - Resource-managed gpiod_get_optional()
72 * @dev: GPIO consumer
73 * @con_id: function within the GPIO consumer
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +090074 * @flags: optional GPIO initialization flags
Thierry Reding29a1f2332014-04-25 17:10:06 +020075 *
76 * Managed gpiod_get_optional(). GPIO descriptors returned from this function
77 * are automatically disposed on driver detach. See gpiod_get_optional() for
78 * detailed information about behavior and return values.
79 */
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +090080struct gpio_desc *__must_check __devm_gpiod_get_optional(struct device *dev,
81 const char *con_id,
82 enum gpiod_flags flags)
Thierry Reding29a1f2332014-04-25 17:10:06 +020083{
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +090084 return devm_gpiod_get_index_optional(dev, con_id, 0, flags);
Thierry Reding29a1f2332014-04-25 17:10:06 +020085}
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +090086EXPORT_SYMBOL(__devm_gpiod_get_optional);
Thierry Reding29a1f2332014-04-25 17:10:06 +020087
88/**
Alexandre Courbotbae48da2013-10-17 10:21:38 -070089 * devm_gpiod_get_index - Resource-managed gpiod_get_index()
90 * @dev: GPIO consumer
91 * @con_id: function within the GPIO consumer
92 * @idx: index of the GPIO to obtain in the consumer
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +090093 * @flags: optional GPIO initialization flags
Alexandre Courbotbae48da2013-10-17 10:21:38 -070094 *
95 * Managed gpiod_get_index(). GPIO descriptors returned from this function are
96 * automatically disposed on driver detach. See gpiod_get_index() for detailed
97 * information about behavior and return values.
98 */
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +090099struct gpio_desc *__must_check __devm_gpiod_get_index(struct device *dev,
Alexandre Courbotbae48da2013-10-17 10:21:38 -0700100 const char *con_id,
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +0900101 unsigned int idx,
102 enum gpiod_flags flags)
Alexandre Courbotbae48da2013-10-17 10:21:38 -0700103{
104 struct gpio_desc **dr;
105 struct gpio_desc *desc;
106
Julia Lawall0f05a3a2014-07-29 17:16:48 +0200107 dr = devres_alloc(devm_gpiod_release, sizeof(struct gpio_desc *),
Alexandre Courbotbae48da2013-10-17 10:21:38 -0700108 GFP_KERNEL);
109 if (!dr)
110 return ERR_PTR(-ENOMEM);
111
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +0900112 desc = gpiod_get_index(dev, con_id, idx, flags);
Alexandre Courbotbae48da2013-10-17 10:21:38 -0700113 if (IS_ERR(desc)) {
114 devres_free(dr);
115 return desc;
116 }
117
118 *dr = desc;
119 devres_add(dev, dr);
120
Alexandre Courbot5fcdb9d2013-10-20 15:14:57 -0700121 return desc;
Alexandre Courbotbae48da2013-10-17 10:21:38 -0700122}
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +0900123EXPORT_SYMBOL(__devm_gpiod_get_index);
Alexandre Courbotbae48da2013-10-17 10:21:38 -0700124
125/**
Mika Westerberg40b73182014-10-21 13:33:59 +0200126 * devm_get_gpiod_from_child - get a GPIO descriptor from a device's child node
127 * @dev: GPIO consumer
Olliver Schinagl1feb57a2015-01-21 22:33:46 +0100128 * @con_id: function within the GPIO consumer
Mika Westerberg40b73182014-10-21 13:33:59 +0200129 * @child: firmware node (child of @dev)
130 *
131 * GPIO descriptors returned from this function are automatically disposed on
132 * driver detach.
133 */
134struct gpio_desc *devm_get_gpiod_from_child(struct device *dev,
Olliver Schinagl1feb57a2015-01-21 22:33:46 +0100135 const char *con_id,
Mika Westerberg40b73182014-10-21 13:33:59 +0200136 struct fwnode_handle *child)
137{
Linus Walleijb6202852015-03-11 12:21:17 +0100138 static const char * const suffixes[] = { "gpios", "gpio" };
Olliver Schinagl1feb57a2015-01-21 22:33:46 +0100139 char prop_name[32]; /* 32 is max size of property name */
Mika Westerberg40b73182014-10-21 13:33:59 +0200140 struct gpio_desc **dr;
141 struct gpio_desc *desc;
Olliver Schinagl1feb57a2015-01-21 22:33:46 +0100142 unsigned int i;
Mika Westerberg40b73182014-10-21 13:33:59 +0200143
144 dr = devres_alloc(devm_gpiod_release, sizeof(struct gpio_desc *),
145 GFP_KERNEL);
146 if (!dr)
147 return ERR_PTR(-ENOMEM);
148
Olliver Schinagl1feb57a2015-01-21 22:33:46 +0100149 for (i = 0; i < ARRAY_SIZE(suffixes); i++) {
150 if (con_id)
151 snprintf(prop_name, sizeof(prop_name), "%s-%s",
152 con_id, suffixes[i]);
153 else
154 snprintf(prop_name, sizeof(prop_name), "%s",
155 suffixes[i]);
156
157 desc = fwnode_get_named_gpiod(child, prop_name);
158 if (!IS_ERR(desc) || (PTR_ERR(desc) == -EPROBE_DEFER))
159 break;
160 }
Mika Westerberg40b73182014-10-21 13:33:59 +0200161 if (IS_ERR(desc)) {
162 devres_free(dr);
163 return desc;
164 }
165
166 *dr = desc;
167 devres_add(dev, dr);
168
169 return desc;
170}
171EXPORT_SYMBOL(devm_get_gpiod_from_child);
172
173/**
Thierry Reding29a1f2332014-04-25 17:10:06 +0200174 * devm_gpiod_get_index_optional - Resource-managed gpiod_get_index_optional()
175 * @dev: GPIO consumer
176 * @con_id: function within the GPIO consumer
177 * @index: index of the GPIO to obtain in the consumer
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +0900178 * @flags: optional GPIO initialization flags
Thierry Reding29a1f2332014-04-25 17:10:06 +0200179 *
180 * Managed gpiod_get_index_optional(). GPIO descriptors returned from this
181 * function are automatically disposed on driver detach. See
182 * gpiod_get_index_optional() for detailed information about behavior and
183 * return values.
184 */
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +0900185struct gpio_desc *__must_check __devm_gpiod_get_index_optional(struct device *dev,
Thierry Reding29a1f2332014-04-25 17:10:06 +0200186 const char *con_id,
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +0900187 unsigned int index,
188 enum gpiod_flags flags)
Thierry Reding29a1f2332014-04-25 17:10:06 +0200189{
190 struct gpio_desc *desc;
191
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +0900192 desc = devm_gpiod_get_index(dev, con_id, index, flags);
Thierry Reding29a1f2332014-04-25 17:10:06 +0200193 if (IS_ERR(desc)) {
194 if (PTR_ERR(desc) == -ENOENT)
195 return NULL;
196 }
197
198 return desc;
199}
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +0900200EXPORT_SYMBOL(__devm_gpiod_get_index_optional);
Thierry Reding29a1f2332014-04-25 17:10:06 +0200201
202/**
Rojhalat Ibrahim331758e2015-02-11 17:28:02 +0100203 * devm_gpiod_get_array - Resource-managed gpiod_get_array()
204 * @dev: GPIO consumer
205 * @con_id: function within the GPIO consumer
206 * @flags: optional GPIO initialization flags
207 *
208 * Managed gpiod_get_array(). GPIO descriptors returned from this function are
209 * automatically disposed on driver detach. See gpiod_get_array() for detailed
210 * information about behavior and return values.
211 */
212struct gpio_descs *__must_check devm_gpiod_get_array(struct device *dev,
213 const char *con_id,
214 enum gpiod_flags flags)
215{
216 struct gpio_descs **dr;
217 struct gpio_descs *descs;
218
219 dr = devres_alloc(devm_gpiod_release_array,
220 sizeof(struct gpio_descs *), GFP_KERNEL);
221 if (!dr)
222 return ERR_PTR(-ENOMEM);
223
224 descs = gpiod_get_array(dev, con_id, flags);
225 if (IS_ERR(descs)) {
226 devres_free(dr);
227 return descs;
228 }
229
230 *dr = descs;
231 devres_add(dev, dr);
232
233 return descs;
234}
235EXPORT_SYMBOL(devm_gpiod_get_array);
236
237/**
238 * devm_gpiod_get_array_optional - Resource-managed gpiod_get_array_optional()
239 * @dev: GPIO consumer
240 * @con_id: function within the GPIO consumer
241 * @flags: optional GPIO initialization flags
242 *
243 * Managed gpiod_get_array_optional(). GPIO descriptors returned from this
244 * function are automatically disposed on driver detach.
245 * See gpiod_get_array_optional() for detailed information about behavior and
246 * return values.
247 */
248struct gpio_descs *__must_check
249devm_gpiod_get_array_optional(struct device *dev, const char *con_id,
250 enum gpiod_flags flags)
251{
252 struct gpio_descs *descs;
253
254 descs = devm_gpiod_get_array(dev, con_id, flags);
255 if (IS_ERR(descs) && (PTR_ERR(descs) == -ENOENT))
256 return NULL;
257
258 return descs;
259}
260EXPORT_SYMBOL(devm_gpiod_get_array_optional);
261
262/**
Alexandre Courbotbae48da2013-10-17 10:21:38 -0700263 * devm_gpiod_put - Resource-managed gpiod_put()
264 * @desc: GPIO descriptor to dispose of
265 *
266 * Dispose of a GPIO descriptor obtained with devm_gpiod_get() or
267 * devm_gpiod_get_index(). Normally this function will not be called as the GPIO
268 * will be disposed of by the resource management code.
269 */
270void devm_gpiod_put(struct device *dev, struct gpio_desc *desc)
271{
272 WARN_ON(devres_release(dev, devm_gpiod_release, devm_gpiod_match,
273 &desc));
274}
275EXPORT_SYMBOL(devm_gpiod_put);
276
Rojhalat Ibrahim331758e2015-02-11 17:28:02 +0100277/**
278 * devm_gpiod_put_array - Resource-managed gpiod_put_array()
279 * @descs: GPIO descriptor array to dispose of
280 *
281 * Dispose of an array of GPIO descriptors obtained with devm_gpiod_get_array().
282 * Normally this function will not be called as the GPIOs will be disposed of
283 * by the resource management code.
284 */
285void devm_gpiod_put_array(struct device *dev, struct gpio_descs *descs)
286{
287 WARN_ON(devres_release(dev, devm_gpiod_release_array,
288 devm_gpiod_match_array, &descs));
289}
290EXPORT_SYMBOL(devm_gpiod_put_array);
291
Alexandre Courbotbae48da2013-10-17 10:21:38 -0700292
293
294
John Crispin1a0703e2011-12-20 21:40:21 +0100295static void devm_gpio_release(struct device *dev, void *res)
296{
297 unsigned *gpio = res;
298
299 gpio_free(*gpio);
300}
301
302static int devm_gpio_match(struct device *dev, void *res, void *data)
303{
304 unsigned *this = res, *gpio = data;
305
306 return *this == *gpio;
307}
308
309/**
Wolfram Sang713b7ef2013-06-04 17:48:36 +0200310 * devm_gpio_request - request a GPIO for a managed device
311 * @dev: device to request the GPIO for
312 * @gpio: GPIO to allocate
313 * @label: the name of the requested GPIO
John Crispin1a0703e2011-12-20 21:40:21 +0100314 *
315 * Except for the extra @dev argument, this function takes the
316 * same arguments and performs the same function as
317 * gpio_request(). GPIOs requested with this function will be
318 * automatically freed on driver detach.
319 *
320 * If an GPIO allocated with this function needs to be freed
321 * separately, devm_gpio_free() must be used.
322 */
323
324int devm_gpio_request(struct device *dev, unsigned gpio, const char *label)
325{
326 unsigned *dr;
327 int rc;
328
329 dr = devres_alloc(devm_gpio_release, sizeof(unsigned), GFP_KERNEL);
330 if (!dr)
331 return -ENOMEM;
332
333 rc = gpio_request(gpio, label);
334 if (rc) {
335 devres_free(dr);
336 return rc;
337 }
338
339 *dr = gpio;
340 devres_add(dev, dr);
341
342 return 0;
343}
344EXPORT_SYMBOL(devm_gpio_request);
345
346/**
Mark Brown09d71ff2012-05-02 12:46:46 +0100347 * devm_gpio_request_one - request a single GPIO with initial setup
348 * @dev: device to request for
349 * @gpio: the GPIO number
350 * @flags: GPIO configuration as specified by GPIOF_*
351 * @label: a literal description string of this GPIO
352 */
353int devm_gpio_request_one(struct device *dev, unsigned gpio,
354 unsigned long flags, const char *label)
355{
356 unsigned *dr;
357 int rc;
358
359 dr = devres_alloc(devm_gpio_release, sizeof(unsigned), GFP_KERNEL);
360 if (!dr)
361 return -ENOMEM;
362
363 rc = gpio_request_one(gpio, flags, label);
364 if (rc) {
365 devres_free(dr);
366 return rc;
367 }
368
369 *dr = gpio;
370 devres_add(dev, dr);
371
372 return 0;
373}
Stephen Warren3996bfc2012-06-07 17:56:09 -0600374EXPORT_SYMBOL(devm_gpio_request_one);
Mark Brown09d71ff2012-05-02 12:46:46 +0100375
376/**
Wolfram Sang713b7ef2013-06-04 17:48:36 +0200377 * devm_gpio_free - free a GPIO
378 * @dev: device to free GPIO for
379 * @gpio: GPIO to free
John Crispin1a0703e2011-12-20 21:40:21 +0100380 *
381 * Except for the extra @dev argument, this function takes the
382 * same arguments and performs the same function as gpio_free().
383 * This function instead of gpio_free() should be used to manually
384 * free GPIOs allocated with devm_gpio_request().
385 */
386void devm_gpio_free(struct device *dev, unsigned int gpio)
387{
388
Mark Browna85990b2012-05-03 18:15:14 +0100389 WARN_ON(devres_release(dev, devm_gpio_release, devm_gpio_match,
John Crispin1a0703e2011-12-20 21:40:21 +0100390 &gpio));
John Crispin1a0703e2011-12-20 21:40:21 +0100391}
392EXPORT_SYMBOL(devm_gpio_free);