drivers/of/gpio.c

   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 - Get a GPIO number from the device tree to use with GPIO API
  23  * @np:         device node to get GPIO from
  24  * @index:      index of the GPIO
  25  *
  26  * Returns GPIO number to use with Linux generic GPIO API, or one of the errno
  27  * value on the error condition.
  28  */
  29 int of_get_gpio(struct device_node *np, int index)
  30 {
  31         int ret = -EINVAL;
  32         struct device_node *gc;
  33         struct of_gpio_chip *of_gc = NULL;
  34         int size;
  35         const u32 *gpios;
  36         u32 nr_cells;
  37         int i;
  38         const void *gpio_spec;
  39         const u32 *gpio_cells;
  40         int gpio_index = 0;
  41
  42         gpios = of_get_property(np, "gpios", &size);
  43         if (!gpios) {
  44                 ret = -ENOENT;
  45                 goto err0;
  46         }
  47         nr_cells = size / sizeof(u32);
  48
  49         for (i = 0; i < nr_cells; gpio_index++) {
  50                 const phandle *gpio_phandle;
  51
  52                 gpio_phandle = gpios + i;
  53                 gpio_spec = gpio_phandle + 1;
  54
  55                 /* one cell hole in the gpios = <>; */
  56                 if (!*gpio_phandle) {
  57                         if (gpio_index == index)
  58                                 return -ENOENT;
  59                         i++;
  60                         continue;
  61                 }
  62
  63                 gc = of_find_node_by_phandle(*gpio_phandle);
  64                 if (!gc) {
  65                         pr_debug("%s: could not find phandle for gpios\n",
  66                                  np->full_name);
  67                         goto err0;
  68                 }
  69
  70                 of_gc = gc->data;
  71                 if (!of_gc) {
  72                         pr_debug("%s: gpio controller %s isn't registered\n",
  73                                  np->full_name, gc->full_name);
  74                         goto err1;
  75                 }
  76
  77                 gpio_cells = of_get_property(gc, "#gpio-cells", &size);
  78                 if (!gpio_cells || size != sizeof(*gpio_cells) ||
  79                                 *gpio_cells != of_gc->gpio_cells) {
  80                         pr_debug("%s: wrong #gpio-cells for %s\n",
  81                                  np->full_name, gc->full_name);
  82                         goto err1;
  83                 }
  84
  85                 /* Next phandle is at phandle cells + #gpio-cells */
  86                 i += sizeof(*gpio_phandle) / sizeof(u32) + *gpio_cells;
  87                 if (i >= nr_cells + 1) {
  88                         pr_debug("%s: insufficient gpio-spec length\n",
  89                                  np->full_name);
  90                         goto err1;
  91                 }
  92
  93                 if (gpio_index == index)
  94                         break;
  95
  96                 of_gc = NULL;
  97                 of_node_put(gc);
  98         }
  99
 100         if (!of_gc) {
 101                 ret = -ENOENT;
 102                 goto err0;
 103         }
 104
 105         ret = of_gc->xlate(of_gc, np, gpio_spec);
 106         if (ret < 0)
 107                 goto err1;
 108
 109         ret += of_gc->gc.base;
 110 err1:
 111         of_node_put(gc);
 112 err0:
 113         pr_debug("%s exited with status %d\n", __func__, ret);
 114         return ret;
 115 }
 116 EXPORT_SYMBOL(of_get_gpio);
 117
 118 /**
 119  * of_gpio_simple_xlate - translate gpio_spec to the GPIO number
 120  * @of_gc:      pointer to the of_gpio_chip structure
 121  * @np:         device node of the GPIO chip
 122  * @gpio_spec:  gpio specifier as found in the device tree
 123  *
 124  * This is simple translation function, suitable for the most 1:1 mapped
 125  * gpio chips. This function performs only one sanity check: whether gpio
 126  * is less than ngpios (that is specified in the gpio_chip).
 127  */
 128 int of_gpio_simple_xlate(struct of_gpio_chip *of_gc, struct device_node *np,
 129                          const void *gpio_spec)
 130 {
 131         const u32 *gpio = gpio_spec;
 132
 133         if (*gpio > of_gc->gc.ngpio)
 134                 return -EINVAL;
 135
 136         return *gpio;
 137 }
 138 EXPORT_SYMBOL(of_gpio_simple_xlate);
 139
 140 /**
 141  * of_mm_gpiochip_add - Add memory mapped GPIO chip (bank)
 142  * @np:         device node of the GPIO chip
 143  * @mm_gc:      pointer to the of_mm_gpio_chip allocated structure
 144  *
 145  * To use this function you should allocate and fill mm_gc with:
 146  *
 147  * 1) In the gpio_chip structure:
 148  *    - all the callbacks
 149  *
 150  * 2) In the of_gpio_chip structure:
 151  *    - gpio_cells
 152  *    - xlate callback (optional)
 153  *
 154  * 3) In the of_mm_gpio_chip structure:
 155  *    - save_regs callback (optional)
 156  *
 157  * If succeeded, this function will map bank's memory and will
 158  * do all necessary work for you. Then you'll able to use .regs
 159  * to manage GPIOs from the callbacks.
 160  */
 161 int of_mm_gpiochip_add(struct device_node *np,
 162                        struct of_mm_gpio_chip *mm_gc)
 163 {
 164         int ret = -ENOMEM;
 165         struct of_gpio_chip *of_gc = &mm_gc->of_gc;
 166         struct gpio_chip *gc = &of_gc->gc;
 167
 168         gc->label = kstrdup(np->full_name, GFP_KERNEL);
 169         if (!gc->label)
 170                 goto err0;
 171
 172         mm_gc->regs = of_iomap(np, 0);
 173         if (!mm_gc->regs)
 174                 goto err1;
 175
 176         gc->base = -1;
 177
 178         if (!of_gc->xlate)
 179                 of_gc->xlate = of_gpio_simple_xlate;
 180
 181         if (mm_gc->save_regs)
 182                 mm_gc->save_regs(mm_gc);
 183
 184         np->data = of_gc;
 185
 186         ret = gpiochip_add(gc);
 187         if (ret)
 188                 goto err2;
 189
 190         /* We don't want to lose the node and its ->data */
 191         of_node_get(np);
 192
 193         pr_debug("%s: registered as generic GPIO chip, base is %d\n",
 194                  np->full_name, gc->base);
 195         return 0;
 196 err2:
 197         np->data = NULL;
 198         iounmap(mm_gc->regs);
 199 err1:
 200         kfree(gc->label);
 201 err0:
 202         pr_err("%s: GPIO chip registration failed with status %d\n",
 203                np->full_name, ret);
 204         return ret;
 205 }
 206 EXPORT_SYMBOL(of_mm_gpiochip_add);