hw/core/gpio.c

   1 /*
   2  * qdev GPIO helpers
   3  *
   4  *  Copyright (c) 2009 CodeSourcery
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "qemu/osdep.h"
  21 #include "hw/qdev-core.h"
  22 #include "hw/irq.h"
  23 #include "qapi/error.h"
  24
  25 static NamedGPIOList *qdev_get_named_gpio_list(DeviceState *dev,
  26                                                const char *name)
  27 {
  28     NamedGPIOList *ngl;
  29
  30     QLIST_FOREACH(ngl, &dev->gpios, node) {
  31         /* NULL is a valid and matchable name. */
  32         if (g_strcmp0(name, ngl->name) == 0) {
  33             return ngl;
  34         }
  35     }
  36
  37     ngl = g_malloc0(sizeof(*ngl));
  38     ngl->name = g_strdup(name);
  39     QLIST_INSERT_HEAD(&dev->gpios, ngl, node);
  40     return ngl;
  41 }
  42
  43 void qdev_init_gpio_in_named_with_opaque(DeviceState *dev,
  44                                          qemu_irq_handler handler,
  45                                          void *opaque,
  46                                          const char *name, int n)
  47 {
  48     int i;
  49     NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
  50
  51     assert(gpio_list->num_out == 0 || !name);
  52     gpio_list->in = qemu_extend_irqs(gpio_list->in, gpio_list->num_in, handler,
  53                                      opaque, n);
  54
  55     if (!name) {
  56         name = "unnamed-gpio-in";
  57     }
  58     for (i = gpio_list->num_in; i < gpio_list->num_in + n; i++) {
  59         gchar *propname = g_strdup_printf("%s[%u]", name, i);
  60
  61         object_property_add_child(OBJECT(dev), propname,
  62                                   OBJECT(gpio_list->in[i]));
  63         g_free(propname);
  64     }
  65
  66     gpio_list->num_in += n;
  67 }
  68
  69 void qdev_init_gpio_in(DeviceState *dev, qemu_irq_handler handler, int n)
  70 {
  71     qdev_init_gpio_in_named(dev, handler, NULL, n);
  72 }
  73
  74 void qdev_init_gpio_out_named(DeviceState *dev, qemu_irq *pins,
  75                               const char *name, int n)
  76 {
  77     int i;
  78     NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
  79
  80     assert(gpio_list->num_in == 0 || !name);
  81
  82     if (!name) {
  83         name = "unnamed-gpio-out";
  84     }
  85     memset(pins, 0, sizeof(*pins) * n);
  86     for (i = 0; i < n; ++i) {
  87         gchar *propname = g_strdup_printf("%s[%u]", name,
  88                                           gpio_list->num_out + i);
  89
  90         object_property_add_link(OBJECT(dev), propname, TYPE_IRQ,
  91                                  (Object **)&pins[i],
  92                                  object_property_allow_set_link,
  93                                  OBJ_PROP_LINK_STRONG);
  94         g_free(propname);
  95     }
  96     gpio_list->num_out += n;
  97 }
  98
  99 void qdev_init_gpio_out(DeviceState *dev, qemu_irq *pins, int n)
 100 {
 101     qdev_init_gpio_out_named(dev, pins, NULL, n);
 102 }
 103
 104 qemu_irq qdev_get_gpio_in_named(DeviceState *dev, const char *name, int n)
 105 {
 106     NamedGPIOList *gpio_list = qdev_get_named_gpio_list(dev, name);
 107
 108     assert(n >= 0 && n < gpio_list->num_in);
 109     return gpio_list->in[n];
 110 }
 111
 112 qemu_irq qdev_get_gpio_in(DeviceState *dev, int n)
 113 {
 114     return qdev_get_gpio_in_named(dev, NULL, n);
 115 }
 116
 117 void qdev_connect_gpio_out_named(DeviceState *dev, const char *name, int n,
 118                                  qemu_irq input_pin)
 119 {
 120     char *propname = g_strdup_printf("%s[%d]",
 121                                      name ? name : "unnamed-gpio-out", n);
 122     if (input_pin && !OBJECT(input_pin)->parent) {
 123         /* We need a name for object_property_set_link to work */
 124         object_property_add_child(container_get(qdev_get_machine(),
 125                                                 "/unattached"),
 126                                   "non-qdev-gpio[*]", OBJECT(input_pin));
 127     }
 128     object_property_set_link(OBJECT(dev), propname,
 129                              OBJECT(input_pin), &error_abort);
 130     g_free(propname);
 131 }
 132
 133 qemu_irq qdev_get_gpio_out_connector(DeviceState *dev, const char *name, int n)
 134 {
 135     g_autofree char *propname = g_strdup_printf("%s[%d]",
 136                                      name ? name : "unnamed-gpio-out", n);
 137
 138     qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname,
 139                                                       NULL);
 140
 141     return ret;
 142 }
 143
 144 /* disconnect a GPIO output, returning the disconnected input (if any) */
 145
 146 static qemu_irq qdev_disconnect_gpio_out_named(DeviceState *dev,
 147                                                const char *name, int n)
 148 {
 149     char *propname = g_strdup_printf("%s[%d]",
 150                                      name ? name : "unnamed-gpio-out", n);
 151
 152     qemu_irq ret = (qemu_irq)object_property_get_link(OBJECT(dev), propname,
 153                                                       NULL);
 154     if (ret) {
 155         object_property_set_link(OBJECT(dev), propname, NULL, NULL);
 156     }
 157     g_free(propname);
 158     return ret;
 159 }
 160
 161 qemu_irq qdev_intercept_gpio_out(DeviceState *dev, qemu_irq icpt,
 162                                  const char *name, int n)
 163 {
 164     qemu_irq disconnected = qdev_disconnect_gpio_out_named(dev, name, n);
 165     qdev_connect_gpio_out_named(dev, name, n, icpt);
 166     return disconnected;
 167 }
 168
 169 void qdev_connect_gpio_out(DeviceState *dev, int n, qemu_irq input_pin)
 170 {
 171     qdev_connect_gpio_out_named(dev, NULL, n, input_pin);
 172 }
 173
 174 void qdev_pass_gpios(DeviceState *dev, DeviceState *container,
 175                      const char *name)
 176 {
 177     int i;
 178     NamedGPIOList *ngl = qdev_get_named_gpio_list(dev, name);
 179
 180     for (i = 0; i < ngl->num_in; i++) {
 181         const char *nm = ngl->name ? ngl->name : "unnamed-gpio-in";
 182         char *propname = g_strdup_printf("%s[%d]", nm, i);
 183
 184         object_property_add_alias(OBJECT(container), propname,
 185                                   OBJECT(dev), propname);
 186         g_free(propname);
 187     }
 188     for (i = 0; i < ngl->num_out; i++) {
 189         const char *nm = ngl->name ? ngl->name : "unnamed-gpio-out";
 190         char *propname = g_strdup_printf("%s[%d]", nm, i);
 191
 192         object_property_add_alias(OBJECT(container), propname,
 193                                   OBJECT(dev), propname);
 194         g_free(propname);
 195     }
 196     QLIST_REMOVE(ngl, node);
 197     QLIST_INSERT_HEAD(&container->gpios, ngl, node);
 198 }