f90a161ca97a9d106b4eec04aba7d238132f3f4d
[sfrench/cifs-2.6.git] / drivers / gpio / gpiolib-of.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * OF helpers for the GPIO API
4  *
5  * Copyright (c) 2007-2008  MontaVista Software, Inc.
6  *
7  * Author: Anton Vorontsov <avorontsov@ru.mvista.com>
8  */
9
10 #include <linux/device.h>
11 #include <linux/err.h>
12 #include <linux/errno.h>
13 #include <linux/module.h>
14 #include <linux/io.h>
15 #include <linux/gpio/consumer.h>
16 #include <linux/of.h>
17 #include <linux/of_address.h>
18 #include <linux/of_gpio.h>
19 #include <linux/pinctrl/pinctrl.h>
20 #include <linux/slab.h>
21 #include <linux/gpio/machine.h>
22
23 #include "gpiolib.h"
24 #include "gpiolib-of.h"
25
26 /**
27  * of_gpio_spi_cs_get_count() - special GPIO counting for SPI
28  * Some elder GPIO controllers need special quirks. Currently we handle
29  * the Freescale GPIO controller with bindings that doesn't use the
30  * established "cs-gpios" for chip selects but instead rely on
31  * "gpios" for the chip select lines. If we detect this, we redirect
32  * the counting of "cs-gpios" to count "gpios" transparent to the
33  * driver.
34  */
35 static int of_gpio_spi_cs_get_count(struct device *dev, const char *con_id)
36 {
37         struct device_node *np = dev->of_node;
38
39         if (!IS_ENABLED(CONFIG_SPI_MASTER))
40                 return 0;
41         if (!con_id || strcmp(con_id, "cs"))
42                 return 0;
43         if (!of_device_is_compatible(np, "fsl,spi") &&
44             !of_device_is_compatible(np, "aeroflexgaisler,spictrl"))
45                 return 0;
46         return of_gpio_named_count(np, "gpios");
47 }
48
49 /*
50  * This is used by external users of of_gpio_count() from <linux/of_gpio.h>
51  *
52  * FIXME: get rid of those external users by converting them to GPIO
53  * descriptors and let them all use gpiod_get_count()
54  */
55 int of_gpio_get_count(struct device *dev, const char *con_id)
56 {
57         int ret;
58         char propname[32];
59         unsigned int i;
60
61         ret = of_gpio_spi_cs_get_count(dev, con_id);
62         if (ret > 0)
63                 return ret;
64
65         for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
66                 if (con_id)
67                         snprintf(propname, sizeof(propname), "%s-%s",
68                                  con_id, gpio_suffixes[i]);
69                 else
70                         snprintf(propname, sizeof(propname), "%s",
71                                  gpio_suffixes[i]);
72
73                 ret = of_gpio_named_count(dev->of_node, propname);
74                 if (ret > 0)
75                         break;
76         }
77         return ret ? ret : -ENOENT;
78 }
79
80 static int of_gpiochip_match_node_and_xlate(struct gpio_chip *chip, void *data)
81 {
82         struct of_phandle_args *gpiospec = data;
83
84         return chip->gpiodev->dev.of_node == gpiospec->np &&
85                                 chip->of_xlate &&
86                                 chip->of_xlate(chip, gpiospec, NULL) >= 0;
87 }
88
89 static struct gpio_chip *of_find_gpiochip_by_xlate(
90                                         struct of_phandle_args *gpiospec)
91 {
92         return gpiochip_find(gpiospec, of_gpiochip_match_node_and_xlate);
93 }
94
95 static struct gpio_desc *of_xlate_and_get_gpiod_flags(struct gpio_chip *chip,
96                                         struct of_phandle_args *gpiospec,
97                                         enum of_gpio_flags *flags)
98 {
99         int ret;
100
101         if (chip->of_gpio_n_cells != gpiospec->args_count)
102                 return ERR_PTR(-EINVAL);
103
104         ret = chip->of_xlate(chip, gpiospec, flags);
105         if (ret < 0)
106                 return ERR_PTR(ret);
107
108         return gpiochip_get_desc(chip, ret);
109 }
110
111 /**
112  * of_gpio_need_valid_mask() - figure out if the OF GPIO driver needs
113  * to set the .valid_mask
114  * @dev: the device for the GPIO provider
115  * @return: true if the valid mask needs to be set
116  */
117 bool of_gpio_need_valid_mask(const struct gpio_chip *gc)
118 {
119         int size;
120         struct device_node *np = gc->of_node;
121
122         size = of_property_count_u32_elems(np,  "gpio-reserved-ranges");
123         if (size > 0 && size % 2 == 0)
124                 return true;
125         return false;
126 }
127
128 static void of_gpio_flags_quirks(struct device_node *np,
129                                  const char *propname,
130                                  enum of_gpio_flags *flags,
131                                  int index)
132 {
133         /*
134          * Handle MMC "cd-inverted" and "wp-inverted" semantics.
135          */
136         if (IS_ENABLED(CONFIG_MMC)) {
137                 /*
138                  * Active low is the default according to the
139                  * SDHCI specification and the device tree
140                  * bindings. However the code in the current
141                  * kernel was written such that the phandle
142                  * flags were always respected, and "cd-inverted"
143                  * would invert the flag from the device phandle.
144                  */
145                 if (!strcmp(propname, "cd-gpios")) {
146                         if (of_property_read_bool(np, "cd-inverted"))
147                                 *flags ^= OF_GPIO_ACTIVE_LOW;
148                 }
149                 if (!strcmp(propname, "wp-gpios")) {
150                         if (of_property_read_bool(np, "wp-inverted"))
151                                 *flags ^= OF_GPIO_ACTIVE_LOW;
152                 }
153         }
154         /*
155          * Some GPIO fixed regulator quirks.
156          * Note that active low is the default.
157          */
158         if (IS_ENABLED(CONFIG_REGULATOR) &&
159             (of_device_is_compatible(np, "regulator-fixed") ||
160              of_device_is_compatible(np, "reg-fixed-voltage") ||
161              (!(strcmp(propname, "enable-gpio") &&
162                 strcmp(propname, "enable-gpios")) &&
163               of_device_is_compatible(np, "regulator-gpio")))) {
164                 /*
165                  * The regulator GPIO handles are specified such that the
166                  * presence or absence of "enable-active-high" solely controls
167                  * the polarity of the GPIO line. Any phandle flags must
168                  * be actively ignored.
169                  */
170                 if (*flags & OF_GPIO_ACTIVE_LOW) {
171                         pr_warn("%s GPIO handle specifies active low - ignored\n",
172                                 of_node_full_name(np));
173                         *flags &= ~OF_GPIO_ACTIVE_LOW;
174                 }
175                 if (!of_property_read_bool(np, "enable-active-high"))
176                         *flags |= OF_GPIO_ACTIVE_LOW;
177         }
178         /*
179          * Legacy open drain handling for fixed voltage regulators.
180          */
181         if (IS_ENABLED(CONFIG_REGULATOR) &&
182             of_device_is_compatible(np, "reg-fixed-voltage") &&
183             of_property_read_bool(np, "gpio-open-drain")) {
184                 *flags |= (OF_GPIO_SINGLE_ENDED | OF_GPIO_OPEN_DRAIN);
185                 pr_info("%s uses legacy open drain flag - update the DTS if you can\n",
186                         of_node_full_name(np));
187         }
188
189         /*
190          * Legacy handling of SPI active high chip select. If we have a
191          * property named "cs-gpios" we need to inspect the child node
192          * to determine if the flags should have inverted semantics.
193          */
194         if (IS_ENABLED(CONFIG_SPI_MASTER) && !strcmp(propname, "cs-gpios") &&
195             of_property_read_bool(np, "cs-gpios")) {
196                 struct device_node *child;
197                 u32 cs;
198                 int ret;
199
200                 for_each_child_of_node(np, child) {
201                         ret = of_property_read_u32(child, "reg", &cs);
202                         if (ret)
203                                 continue;
204                         if (cs == index) {
205                                 /*
206                                  * SPI children have active low chip selects
207                                  * by default. This can be specified negatively
208                                  * by just omitting "spi-cs-high" in the
209                                  * device node, or actively by tagging on
210                                  * GPIO_ACTIVE_LOW as flag in the device
211                                  * tree. If the line is simultaneously
212                                  * tagged as active low in the device tree
213                                  * and has the "spi-cs-high" set, we get a
214                                  * conflict and the "spi-cs-high" flag will
215                                  * take precedence.
216                                  */
217                                 if (of_property_read_bool(child, "spi-cs-high")) {
218                                         if (*flags & OF_GPIO_ACTIVE_LOW) {
219                                                 pr_warn("%s GPIO handle specifies active low - ignored\n",
220                                                         of_node_full_name(child));
221                                                 *flags &= ~OF_GPIO_ACTIVE_LOW;
222                                         }
223                                 } else {
224                                         if (!(*flags & OF_GPIO_ACTIVE_LOW))
225                                                 pr_info("%s enforce active low on chipselect handle\n",
226                                                         of_node_full_name(child));
227                                         *flags |= OF_GPIO_ACTIVE_LOW;
228                                 }
229                                 of_node_put(child);
230                                 break;
231                         }
232                 }
233         }
234
235         /* Legacy handling of stmmac's active-low PHY reset line */
236         if (IS_ENABLED(CONFIG_STMMAC_ETH) &&
237             !strcmp(propname, "snps,reset-gpio") &&
238             of_property_read_bool(np, "snps,reset-active-low"))
239                 *flags |= OF_GPIO_ACTIVE_LOW;
240 }
241
242 /**
243  * of_get_named_gpiod_flags() - Get a GPIO descriptor and flags for GPIO API
244  * @np:         device node to get GPIO from
245  * @propname:   property name containing gpio specifier(s)
246  * @index:      index of the GPIO
247  * @flags:      a flags pointer to fill in
248  *
249  * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
250  * value on the error condition. If @flags is not NULL the function also fills
251  * in flags for the GPIO.
252  */
253 static struct gpio_desc *of_get_named_gpiod_flags(struct device_node *np,
254                      const char *propname, int index, enum of_gpio_flags *flags)
255 {
256         struct of_phandle_args gpiospec;
257         struct gpio_chip *chip;
258         struct gpio_desc *desc;
259         int ret;
260
261         ret = of_parse_phandle_with_args_map(np, propname, "gpio", index,
262                                              &gpiospec);
263         if (ret) {
264                 pr_debug("%s: can't parse '%s' property of node '%pOF[%d]'\n",
265                         __func__, propname, np, index);
266                 return ERR_PTR(ret);
267         }
268
269         chip = of_find_gpiochip_by_xlate(&gpiospec);
270         if (!chip) {
271                 desc = ERR_PTR(-EPROBE_DEFER);
272                 goto out;
273         }
274
275         desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, flags);
276         if (IS_ERR(desc))
277                 goto out;
278
279         if (flags)
280                 of_gpio_flags_quirks(np, propname, flags, index);
281
282         pr_debug("%s: parsed '%s' property of node '%pOF[%d]' - status (%d)\n",
283                  __func__, propname, np, index,
284                  PTR_ERR_OR_ZERO(desc));
285
286 out:
287         of_node_put(gpiospec.np);
288
289         return desc;
290 }
291
292 int of_get_named_gpio_flags(struct device_node *np, const char *list_name,
293                             int index, enum of_gpio_flags *flags)
294 {
295         struct gpio_desc *desc;
296
297         desc = of_get_named_gpiod_flags(np, list_name, index, flags);
298
299         if (IS_ERR(desc))
300                 return PTR_ERR(desc);
301         else
302                 return desc_to_gpio(desc);
303 }
304 EXPORT_SYMBOL_GPL(of_get_named_gpio_flags);
305
306 /**
307  * gpiod_get_from_of_node() - obtain a GPIO from an OF node
308  * @node:       handle of the OF node
309  * @propname:   name of the DT property representing the GPIO
310  * @index:      index of the GPIO to obtain for the consumer
311  * @dflags:     GPIO initialization flags
312  * @label:      label to attach to the requested GPIO
313  *
314  * Returns:
315  * On successful request the GPIO pin is configured in accordance with
316  * provided @dflags.
317  *
318  * In case of error an ERR_PTR() is returned.
319  */
320 struct gpio_desc *gpiod_get_from_of_node(struct device_node *node,
321                                          const char *propname, int index,
322                                          enum gpiod_flags dflags,
323                                          const char *label)
324 {
325         unsigned long lflags = GPIO_LOOKUP_FLAGS_DEFAULT;
326         struct gpio_desc *desc;
327         enum of_gpio_flags flags;
328         bool active_low = false;
329         bool single_ended = false;
330         bool open_drain = false;
331         bool transitory = false;
332         int ret;
333
334         desc = of_get_named_gpiod_flags(node, propname,
335                                         index, &flags);
336
337         if (!desc || IS_ERR(desc)) {
338                 return desc;
339         }
340
341         active_low = flags & OF_GPIO_ACTIVE_LOW;
342         single_ended = flags & OF_GPIO_SINGLE_ENDED;
343         open_drain = flags & OF_GPIO_OPEN_DRAIN;
344         transitory = flags & OF_GPIO_TRANSITORY;
345
346         ret = gpiod_request(desc, label);
347         if (ret == -EBUSY && (flags & GPIOD_FLAGS_BIT_NONEXCLUSIVE))
348                 return desc;
349         if (ret)
350                 return ERR_PTR(ret);
351
352         if (active_low)
353                 lflags |= GPIO_ACTIVE_LOW;
354
355         if (single_ended) {
356                 if (open_drain)
357                         lflags |= GPIO_OPEN_DRAIN;
358                 else
359                         lflags |= GPIO_OPEN_SOURCE;
360         }
361
362         if (transitory)
363                 lflags |= GPIO_TRANSITORY;
364
365         ret = gpiod_configure_flags(desc, propname, lflags, dflags);
366         if (ret < 0) {
367                 gpiod_put(desc);
368                 return ERR_PTR(ret);
369         }
370
371         return desc;
372 }
373 EXPORT_SYMBOL_GPL(gpiod_get_from_of_node);
374
375 /*
376  * The SPI GPIO bindings happened before we managed to establish that GPIO
377  * properties should be named "foo-gpios" so we have this special kludge for
378  * them.
379  */
380 static struct gpio_desc *of_find_spi_gpio(struct device *dev, const char *con_id,
381                                           enum of_gpio_flags *of_flags)
382 {
383         char prop_name[32]; /* 32 is max size of property name */
384         struct device_node *np = dev->of_node;
385         struct gpio_desc *desc;
386
387         /*
388          * Hopefully the compiler stubs the rest of the function if this
389          * is false.
390          */
391         if (!IS_ENABLED(CONFIG_SPI_MASTER))
392                 return ERR_PTR(-ENOENT);
393
394         /* Allow this specifically for "spi-gpio" devices */
395         if (!of_device_is_compatible(np, "spi-gpio") || !con_id)
396                 return ERR_PTR(-ENOENT);
397
398         /* Will be "gpio-sck", "gpio-mosi" or "gpio-miso" */
399         snprintf(prop_name, sizeof(prop_name), "%s-%s", "gpio", con_id);
400
401         desc = of_get_named_gpiod_flags(np, prop_name, 0, of_flags);
402         return desc;
403 }
404
405 /*
406  * The old Freescale bindings use simply "gpios" as name for the chip select
407  * lines rather than "cs-gpios" like all other SPI hardware. Account for this
408  * with a special quirk.
409  */
410 static struct gpio_desc *of_find_spi_cs_gpio(struct device *dev,
411                                              const char *con_id,
412                                              unsigned int idx,
413                                              unsigned long *flags)
414 {
415         struct device_node *np = dev->of_node;
416
417         if (!IS_ENABLED(CONFIG_SPI_MASTER))
418                 return ERR_PTR(-ENOENT);
419
420         /* Allow this specifically for Freescale devices */
421         if (!of_device_is_compatible(np, "fsl,spi") &&
422             !of_device_is_compatible(np, "aeroflexgaisler,spictrl"))
423                 return ERR_PTR(-ENOENT);
424         /* Allow only if asking for "cs-gpios" */
425         if (!con_id || strcmp(con_id, "cs"))
426                 return ERR_PTR(-ENOENT);
427
428         /*
429          * While all other SPI controllers use "cs-gpios" the Freescale
430          * uses just "gpios" so translate to that when "cs-gpios" is
431          * requested.
432          */
433         return of_find_gpio(dev, NULL, idx, flags);
434 }
435
436 /*
437  * Some regulator bindings happened before we managed to establish that GPIO
438  * properties should be named "foo-gpios" so we have this special kludge for
439  * them.
440  */
441 static struct gpio_desc *of_find_regulator_gpio(struct device *dev, const char *con_id,
442                                                 enum of_gpio_flags *of_flags)
443 {
444         /* These are the connection IDs we accept as legacy GPIO phandles */
445         const char *whitelist[] = {
446                 "wlf,ldoena", /* Arizona */
447                 "wlf,ldo1ena", /* WM8994 */
448                 "wlf,ldo2ena", /* WM8994 */
449         };
450         struct device_node *np = dev->of_node;
451         struct gpio_desc *desc;
452         int i;
453
454         if (!IS_ENABLED(CONFIG_REGULATOR))
455                 return ERR_PTR(-ENOENT);
456
457         if (!con_id)
458                 return ERR_PTR(-ENOENT);
459
460         i = match_string(whitelist, ARRAY_SIZE(whitelist), con_id);
461         if (i < 0)
462                 return ERR_PTR(-ENOENT);
463
464         desc = of_get_named_gpiod_flags(np, con_id, 0, of_flags);
465         return desc;
466 }
467
468 static struct gpio_desc *of_find_arizona_gpio(struct device *dev,
469                                               const char *con_id,
470                                               enum of_gpio_flags *of_flags)
471 {
472         if (!IS_ENABLED(CONFIG_MFD_ARIZONA))
473                 return ERR_PTR(-ENOENT);
474
475         if (!con_id || strcmp(con_id, "wlf,reset"))
476                 return ERR_PTR(-ENOENT);
477
478         return of_get_named_gpiod_flags(dev->of_node, con_id, 0, of_flags);
479 }
480
481 struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
482                                unsigned int idx, unsigned long *flags)
483 {
484         char prop_name[32]; /* 32 is max size of property name */
485         enum of_gpio_flags of_flags;
486         struct gpio_desc *desc;
487         unsigned int i;
488
489         /* Try GPIO property "foo-gpios" and "foo-gpio" */
490         for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
491                 if (con_id)
492                         snprintf(prop_name, sizeof(prop_name), "%s-%s", con_id,
493                                  gpio_suffixes[i]);
494                 else
495                         snprintf(prop_name, sizeof(prop_name), "%s",
496                                  gpio_suffixes[i]);
497
498                 desc = of_get_named_gpiod_flags(dev->of_node, prop_name, idx,
499                                                 &of_flags);
500
501                 if (!IS_ERR(desc) || PTR_ERR(desc) != -ENOENT)
502                         break;
503         }
504
505         if (IS_ERR(desc) && PTR_ERR(desc) == -ENOENT) {
506                 /* Special handling for SPI GPIOs if used */
507                 desc = of_find_spi_gpio(dev, con_id, &of_flags);
508         }
509
510         if (IS_ERR(desc) && PTR_ERR(desc) == -ENOENT) {
511                 /* This quirk looks up flags and all */
512                 desc = of_find_spi_cs_gpio(dev, con_id, idx, flags);
513                 if (!IS_ERR(desc))
514                         return desc;
515         }
516
517         if (IS_ERR(desc) && PTR_ERR(desc) == -ENOENT) {
518                 /* Special handling for regulator GPIOs if used */
519                 desc = of_find_regulator_gpio(dev, con_id, &of_flags);
520         }
521
522         if (IS_ERR(desc) && PTR_ERR(desc) == -ENOENT)
523                 desc = of_find_arizona_gpio(dev, con_id, &of_flags);
524
525         if (IS_ERR(desc))
526                 return desc;
527
528         if (of_flags & OF_GPIO_ACTIVE_LOW)
529                 *flags |= GPIO_ACTIVE_LOW;
530
531         if (of_flags & OF_GPIO_SINGLE_ENDED) {
532                 if (of_flags & OF_GPIO_OPEN_DRAIN)
533                         *flags |= GPIO_OPEN_DRAIN;
534                 else
535                         *flags |= GPIO_OPEN_SOURCE;
536         }
537
538         if (of_flags & OF_GPIO_TRANSITORY)
539                 *flags |= GPIO_TRANSITORY;
540
541         if (of_flags & OF_GPIO_PULL_UP)
542                 *flags |= GPIO_PULL_UP;
543         if (of_flags & OF_GPIO_PULL_DOWN)
544                 *flags |= GPIO_PULL_DOWN;
545
546         return desc;
547 }
548
549 /**
550  * of_parse_own_gpio() - Get a GPIO hog descriptor, names and flags for GPIO API
551  * @np:         device node to get GPIO from
552  * @chip:       GPIO chip whose hog is parsed
553  * @idx:        Index of the GPIO to parse
554  * @name:       GPIO line name
555  * @lflags:     bitmask of gpio_lookup_flags GPIO_* values - returned from
556  *              of_find_gpio() or of_parse_own_gpio()
557  * @dflags:     gpiod_flags - optional GPIO initialization flags
558  *
559  * Returns GPIO descriptor to use with Linux GPIO API, or one of the errno
560  * value on the error condition.
561  */
562 static struct gpio_desc *of_parse_own_gpio(struct device_node *np,
563                                            struct gpio_chip *chip,
564                                            unsigned int idx, const char **name,
565                                            unsigned long *lflags,
566                                            enum gpiod_flags *dflags)
567 {
568         struct device_node *chip_np;
569         enum of_gpio_flags xlate_flags;
570         struct of_phandle_args gpiospec;
571         struct gpio_desc *desc;
572         unsigned int i;
573         u32 tmp;
574         int ret;
575
576         chip_np = chip->of_node;
577         if (!chip_np)
578                 return ERR_PTR(-EINVAL);
579
580         xlate_flags = 0;
581         *lflags = GPIO_LOOKUP_FLAGS_DEFAULT;
582         *dflags = 0;
583
584         ret = of_property_read_u32(chip_np, "#gpio-cells", &tmp);
585         if (ret)
586                 return ERR_PTR(ret);
587
588         gpiospec.np = chip_np;
589         gpiospec.args_count = tmp;
590
591         for (i = 0; i < tmp; i++) {
592                 ret = of_property_read_u32_index(np, "gpios", idx * tmp + i,
593                                                  &gpiospec.args[i]);
594                 if (ret)
595                         return ERR_PTR(ret);
596         }
597
598         desc = of_xlate_and_get_gpiod_flags(chip, &gpiospec, &xlate_flags);
599         if (IS_ERR(desc))
600                 return desc;
601
602         if (xlate_flags & OF_GPIO_ACTIVE_LOW)
603                 *lflags |= GPIO_ACTIVE_LOW;
604         if (xlate_flags & OF_GPIO_TRANSITORY)
605                 *lflags |= GPIO_TRANSITORY;
606
607         if (of_property_read_bool(np, "input"))
608                 *dflags |= GPIOD_IN;
609         else if (of_property_read_bool(np, "output-low"))
610                 *dflags |= GPIOD_OUT_LOW;
611         else if (of_property_read_bool(np, "output-high"))
612                 *dflags |= GPIOD_OUT_HIGH;
613         else {
614                 pr_warn("GPIO line %d (%pOFn): no hogging state specified, bailing out\n",
615                         desc_to_gpio(desc), np);
616                 return ERR_PTR(-EINVAL);
617         }
618
619         if (name && of_property_read_string(np, "line-name", name))
620                 *name = np->name;
621
622         return desc;
623 }
624
625 /**
626  * of_gpiochip_scan_gpios - Scan gpio-controller for gpio definitions
627  * @chip:       gpio chip to act on
628  *
629  * This is only used by of_gpiochip_add to request/set GPIO initial
630  * configuration.
631  * It returns error if it fails otherwise 0 on success.
632  */
633 static int of_gpiochip_scan_gpios(struct gpio_chip *chip)
634 {
635         struct gpio_desc *desc = NULL;
636         struct device_node *np;
637         const char *name;
638         unsigned long lflags;
639         enum gpiod_flags dflags;
640         unsigned int i;
641         int ret;
642
643         for_each_available_child_of_node(chip->of_node, np) {
644                 if (!of_property_read_bool(np, "gpio-hog"))
645                         continue;
646
647                 for (i = 0;; i++) {
648                         desc = of_parse_own_gpio(np, chip, i, &name, &lflags,
649                                                  &dflags);
650                         if (IS_ERR(desc))
651                                 break;
652
653                         ret = gpiod_hog(desc, name, lflags, dflags);
654                         if (ret < 0) {
655                                 of_node_put(np);
656                                 return ret;
657                         }
658                 }
659         }
660
661         return 0;
662 }
663
664 /**
665  * of_gpio_simple_xlate - translate gpiospec to the GPIO number and flags
666  * @gc:         pointer to the gpio_chip structure
667  * @gpiospec:   GPIO specifier as found in the device tree
668  * @flags:      a flags pointer to fill in
669  *
670  * This is simple translation function, suitable for the most 1:1 mapped
671  * GPIO chips. This function performs only one sanity check: whether GPIO
672  * is less than ngpios (that is specified in the gpio_chip).
673  */
674 static int of_gpio_simple_xlate(struct gpio_chip *gc,
675                                 const struct of_phandle_args *gpiospec,
676                                 u32 *flags)
677 {
678         /*
679          * We're discouraging gpio_cells < 2, since that way you'll have to
680          * write your own xlate function (that will have to retrieve the GPIO
681          * number and the flags from a single gpio cell -- this is possible,
682          * but not recommended).
683          */
684         if (gc->of_gpio_n_cells < 2) {
685                 WARN_ON(1);
686                 return -EINVAL;
687         }
688
689         if (WARN_ON(gpiospec->args_count < gc->of_gpio_n_cells))
690                 return -EINVAL;
691
692         if (gpiospec->args[0] >= gc->ngpio)
693                 return -EINVAL;
694
695         if (flags)
696                 *flags = gpiospec->args[1];
697
698         return gpiospec->args[0];
699 }
700
701 /**
702  * of_mm_gpiochip_add_data - Add memory mapped GPIO chip (bank)
703  * @np:         device node of the GPIO chip
704  * @mm_gc:      pointer to the of_mm_gpio_chip allocated structure
705  * @data:       driver data to store in the struct gpio_chip
706  *
707  * To use this function you should allocate and fill mm_gc with:
708  *
709  * 1) In the gpio_chip structure:
710  *    - all the callbacks
711  *    - of_gpio_n_cells
712  *    - of_xlate callback (optional)
713  *
714  * 3) In the of_mm_gpio_chip structure:
715  *    - save_regs callback (optional)
716  *
717  * If succeeded, this function will map bank's memory and will
718  * do all necessary work for you. Then you'll able to use .regs
719  * to manage GPIOs from the callbacks.
720  */
721 int of_mm_gpiochip_add_data(struct device_node *np,
722                             struct of_mm_gpio_chip *mm_gc,
723                             void *data)
724 {
725         int ret = -ENOMEM;
726         struct gpio_chip *gc = &mm_gc->gc;
727
728         gc->label = kasprintf(GFP_KERNEL, "%pOF", np);
729         if (!gc->label)
730                 goto err0;
731
732         mm_gc->regs = of_iomap(np, 0);
733         if (!mm_gc->regs)
734                 goto err1;
735
736         gc->base = -1;
737
738         if (mm_gc->save_regs)
739                 mm_gc->save_regs(mm_gc);
740
741         mm_gc->gc.of_node = np;
742
743         ret = gpiochip_add_data(gc, data);
744         if (ret)
745                 goto err2;
746
747         return 0;
748 err2:
749         iounmap(mm_gc->regs);
750 err1:
751         kfree(gc->label);
752 err0:
753         pr_err("%pOF: GPIO chip registration failed with status %d\n", np, ret);
754         return ret;
755 }
756 EXPORT_SYMBOL_GPL(of_mm_gpiochip_add_data);
757
758 /**
759  * of_mm_gpiochip_remove - Remove memory mapped GPIO chip (bank)
760  * @mm_gc:      pointer to the of_mm_gpio_chip allocated structure
761  */
762 void of_mm_gpiochip_remove(struct of_mm_gpio_chip *mm_gc)
763 {
764         struct gpio_chip *gc = &mm_gc->gc;
765
766         if (!mm_gc)
767                 return;
768
769         gpiochip_remove(gc);
770         iounmap(mm_gc->regs);
771         kfree(gc->label);
772 }
773 EXPORT_SYMBOL_GPL(of_mm_gpiochip_remove);
774
775 static void of_gpiochip_init_valid_mask(struct gpio_chip *chip)
776 {
777         int len, i;
778         u32 start, count;
779         struct device_node *np = chip->of_node;
780
781         len = of_property_count_u32_elems(np,  "gpio-reserved-ranges");
782         if (len < 0 || len % 2 != 0)
783                 return;
784
785         for (i = 0; i < len; i += 2) {
786                 of_property_read_u32_index(np, "gpio-reserved-ranges",
787                                            i, &start);
788                 of_property_read_u32_index(np, "gpio-reserved-ranges",
789                                            i + 1, &count);
790                 if (start >= chip->ngpio || start + count >= chip->ngpio)
791                         continue;
792
793                 bitmap_clear(chip->valid_mask, start, count);
794         }
795 };
796
797 #ifdef CONFIG_PINCTRL
798 static int of_gpiochip_add_pin_range(struct gpio_chip *chip)
799 {
800         struct device_node *np = chip->of_node;
801         struct of_phandle_args pinspec;
802         struct pinctrl_dev *pctldev;
803         int index = 0, ret;
804         const char *name;
805         static const char group_names_propname[] = "gpio-ranges-group-names";
806         struct property *group_names;
807
808         if (!np)
809                 return 0;
810
811         group_names = of_find_property(np, group_names_propname, NULL);
812
813         for (;; index++) {
814                 ret = of_parse_phandle_with_fixed_args(np, "gpio-ranges", 3,
815                                 index, &pinspec);
816                 if (ret)
817                         break;
818
819                 pctldev = of_pinctrl_get(pinspec.np);
820                 of_node_put(pinspec.np);
821                 if (!pctldev)
822                         return -EPROBE_DEFER;
823
824                 if (pinspec.args[2]) {
825                         if (group_names) {
826                                 of_property_read_string_index(np,
827                                                 group_names_propname,
828                                                 index, &name);
829                                 if (strlen(name)) {
830                                         pr_err("%pOF: Group name of numeric GPIO ranges must be the empty string.\n",
831                                                 np);
832                                         break;
833                                 }
834                         }
835                         /* npins != 0: linear range */
836                         ret = gpiochip_add_pin_range(chip,
837                                         pinctrl_dev_get_devname(pctldev),
838                                         pinspec.args[0],
839                                         pinspec.args[1],
840                                         pinspec.args[2]);
841                         if (ret)
842                                 return ret;
843                 } else {
844                         /* npins == 0: special range */
845                         if (pinspec.args[1]) {
846                                 pr_err("%pOF: Illegal gpio-range format.\n",
847                                         np);
848                                 break;
849                         }
850
851                         if (!group_names) {
852                                 pr_err("%pOF: GPIO group range requested but no %s property.\n",
853                                         np, group_names_propname);
854                                 break;
855                         }
856
857                         ret = of_property_read_string_index(np,
858                                                 group_names_propname,
859                                                 index, &name);
860                         if (ret)
861                                 break;
862
863                         if (!strlen(name)) {
864                                 pr_err("%pOF: Group name of GPIO group range cannot be the empty string.\n",
865                                 np);
866                                 break;
867                         }
868
869                         ret = gpiochip_add_pingroup_range(chip, pctldev,
870                                                 pinspec.args[0], name);
871                         if (ret)
872                                 return ret;
873                 }
874         }
875
876         return 0;
877 }
878
879 #else
880 static int of_gpiochip_add_pin_range(struct gpio_chip *chip) { return 0; }
881 #endif
882
883 int of_gpiochip_add(struct gpio_chip *chip)
884 {
885         int ret;
886
887         if (!chip->of_node)
888                 return 0;
889
890         if (!chip->of_xlate) {
891                 chip->of_gpio_n_cells = 2;
892                 chip->of_xlate = of_gpio_simple_xlate;
893         }
894
895         if (chip->of_gpio_n_cells > MAX_PHANDLE_ARGS)
896                 return -EINVAL;
897
898         of_gpiochip_init_valid_mask(chip);
899
900         ret = of_gpiochip_add_pin_range(chip);
901         if (ret)
902                 return ret;
903
904         /* If the chip defines names itself, these take precedence */
905         if (!chip->names)
906                 devprop_gpiochip_set_names(chip,
907                                            of_fwnode_handle(chip->of_node));
908
909         of_node_get(chip->of_node);
910
911         ret = of_gpiochip_scan_gpios(chip);
912         if (ret) {
913                 of_node_put(chip->of_node);
914                 gpiochip_remove_pin_ranges(chip);
915         }
916
917         return ret;
918 }
919
920 void of_gpiochip_remove(struct gpio_chip *chip)
921 {
922         gpiochip_remove_pin_ranges(chip);
923         of_node_put(chip->of_node);
924 }