LXR qemu/hw/core/sysbus.c

   1/*
   2 *  System (CPU) Bus device support code
   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 "qapi/error.h"
  22#include "hw/sysbus.h"
  23#include "monitor/monitor.h"
  24#include "exec/address-spaces.h"
  25
  26static void sysbus_dev_print(Monitor *mon, DeviceState *dev, int indent);
  27static char *sysbus_get_fw_dev_path(DeviceState *dev);
  28
  29typedef struct SysBusFind {
  30    void *opaque;
  31    FindSysbusDeviceFunc *func;
  32} SysBusFind;
  33
  34/* Run func() for every sysbus device, traverse the tree for everything else */
  35static int find_sysbus_device(Object *obj, void *opaque)
  36{
  37    SysBusFind *find = opaque;
  38    Object *dev;
  39    SysBusDevice *sbdev;
  40
  41    dev = object_dynamic_cast(obj, TYPE_SYS_BUS_DEVICE);
  42    sbdev = (SysBusDevice *)dev;
  43
  44    if (!sbdev) {
  45        /* Container, traverse it for children */
  46        return object_child_foreach(obj, find_sysbus_device, opaque);
  47    }
  48
  49    find->func(sbdev, find->opaque);
  50
  51    return 0;
  52}
  53
  54/*
  55 * Loop through all dynamically created sysbus devices and call
  56 * func() for each instance.
  57 */
  58void foreach_dynamic_sysbus_device(FindSysbusDeviceFunc *func, void *opaque)
  59{
  60    Object *container;
  61    SysBusFind find = {
  62        .func = func,
  63        .opaque = opaque,
  64    };
  65
  66    /* Loop through all sysbus devices that were spawened outside the machine */
  67    container = container_get(qdev_get_machine(), "/peripheral");
  68    find_sysbus_device(container, &find);
  69    container = container_get(qdev_get_machine(), "/peripheral-anon");
  70    find_sysbus_device(container, &find);
  71}
  72
  73
  74static void system_bus_class_init(ObjectClass *klass, void *data)
  75{
  76    BusClass *k = BUS_CLASS(klass);
  77
  78    k->print_dev = sysbus_dev_print;
  79    k->get_fw_dev_path = sysbus_get_fw_dev_path;
  80}
  81
  82static const TypeInfo system_bus_info = {
  83    .name = TYPE_SYSTEM_BUS,
  84    .parent = TYPE_BUS,
  85    .instance_size = sizeof(BusState),
  86    .class_init = system_bus_class_init,
  87};
  88
  89/* Check whether an IRQ source exists */
  90bool sysbus_has_irq(SysBusDevice *dev, int n)
  91{
  92    char *prop = g_strdup_printf("%s[%d]", SYSBUS_DEVICE_GPIO_IRQ, n);
  93    ObjectProperty *r;
  94
  95    r = object_property_find(OBJECT(dev), prop, NULL);
  96    g_free(prop);
  97
  98    return (r != NULL);
  99}
 100
 101bool sysbus_is_irq_connected(SysBusDevice *dev, int n)
 102{
 103    return !!sysbus_get_connected_irq(dev, n);
 104}
 105
 106qemu_irq sysbus_get_connected_irq(SysBusDevice *dev, int n)
 107{
 108    DeviceState *d = DEVICE(dev);
 109    return qdev_get_gpio_out_connector(d, SYSBUS_DEVICE_GPIO_IRQ, n);
 110}
 111
 112void sysbus_connect_irq(SysBusDevice *dev, int n, qemu_irq irq)
 113{
 114    SysBusDeviceClass *sbd = SYS_BUS_DEVICE_GET_CLASS(dev);
 115
 116    qdev_connect_gpio_out_named(DEVICE(dev), SYSBUS_DEVICE_GPIO_IRQ, n, irq);
 117
 118    if (sbd->connect_irq_notifier) {
 119        sbd->connect_irq_notifier(dev, irq);
 120    }
 121}
 122
 123/* Check whether an MMIO region exists */
 124bool sysbus_has_mmio(SysBusDevice *dev, unsigned int n)
 125{
 126    return (n < dev->num_mmio);
 127}
 128
 129static void sysbus_mmio_map_common(SysBusDevice *dev, int n, hwaddr addr,
 130                                   bool may_overlap, int priority)
 131{
 132    assert(n >= 0 && n < dev->num_mmio);
 133
 134    if (dev->mmio[n].addr == addr) {
 135        /* ??? region already mapped here.  */
 136        return;
 137    }
 138    if (dev->mmio[n].addr != (hwaddr)-1) {
 139        /* Unregister previous mapping.  */
 140        memory_region_del_subregion(get_system_memory(), dev->mmio[n].memory);
 141    }
 142    dev->mmio[n].addr = addr;
 143    if (may_overlap) {
 144        memory_region_add_subregion_overlap(get_system_memory(),
 145                                            addr,
 146                                            dev->mmio[n].memory,
 147                                            priority);
 148    }
 149    else {
 150        memory_region_add_subregion(get_system_memory(),
 151                                    addr,
 152                                    dev->mmio[n].memory);
 153    }
 154}
 155
 156void sysbus_mmio_map(SysBusDevice *dev, int n, hwaddr addr)
 157{
 158    sysbus_mmio_map_common(dev, n, addr, false, 0);
 159}
 160
 161void sysbus_mmio_map_overlap(SysBusDevice *dev, int n, hwaddr addr,
 162                             int priority)
 163{
 164    sysbus_mmio_map_common(dev, n, addr, true, priority);
 165}
 166
 167/* Request an IRQ source.  The actual IRQ object may be populated later.  */
 168void sysbus_init_irq(SysBusDevice *dev, qemu_irq *p)
 169{
 170    qdev_init_gpio_out_named(DEVICE(dev), p, SYSBUS_DEVICE_GPIO_IRQ, 1);
 171}
 172
 173/* Pass IRQs from a target device.  */
 174void sysbus_pass_irq(SysBusDevice *dev, SysBusDevice *target)
 175{
 176    qdev_pass_gpios(DEVICE(target), DEVICE(dev), SYSBUS_DEVICE_GPIO_IRQ);
 177}
 178
 179void sysbus_init_mmio(SysBusDevice *dev, MemoryRegion *memory)
 180{
 181    int n;
 182
 183    assert(dev->num_mmio < QDEV_MAX_MMIO);
 184    n = dev->num_mmio++;
 185    dev->mmio[n].addr = -1;
 186    dev->mmio[n].memory = memory;
 187}
 188
 189MemoryRegion *sysbus_mmio_get_region(SysBusDevice *dev, int n)
 190{
 191    return dev->mmio[n].memory;
 192}
 193
 194void sysbus_init_ioports(SysBusDevice *dev, uint32_t ioport, uint32_t size)
 195{
 196    uint32_t i;
 197
 198    for (i = 0; i < size; i++) {
 199        assert(dev->num_pio < QDEV_MAX_PIO);
 200        dev->pio[dev->num_pio++] = ioport++;
 201    }
 202}
 203
 204/* The purpose of preserving this empty realize function
 205 * is to prevent the parent_realize field of some subclasses
 206 * from being set to NULL to break the normal init/realize
 207 * of some devices.
 208 */
 209static void sysbus_realize(DeviceState *dev, Error **errp)
 210{
 211}
 212
 213DeviceState *sysbus_create_varargs(const char *name,
 214                                   hwaddr addr, ...)
 215{
 216    DeviceState *dev;
 217    SysBusDevice *s;
 218    va_list va;
 219    qemu_irq irq;
 220    int n;
 221
 222    dev = qdev_create(NULL, name);
 223    s = SYS_BUS_DEVICE(dev);
 224    qdev_init_nofail(dev);
 225    if (addr != (hwaddr)-1) {
 226        sysbus_mmio_map(s, 0, addr);
 227    }
 228    va_start(va, addr);
 229    n = 0;
 230    while (1) {
 231        irq = va_arg(va, qemu_irq);
 232        if (!irq) {
 233            break;
 234        }
 235        sysbus_connect_irq(s, n, irq);
 236        n++;
 237    }
 238    va_end(va);
 239    return dev;
 240}
 241
 242DeviceState *sysbus_try_create_varargs(const char *name,
 243                                       hwaddr addr, ...)
 244{
 245    DeviceState *dev;
 246    SysBusDevice *s;
 247    va_list va;
 248    qemu_irq irq;
 249    int n;
 250
 251    dev = qdev_try_create(NULL, name);
 252    if (!dev) {
 253        return NULL;
 254    }
 255    s = SYS_BUS_DEVICE(dev);
 256    qdev_init_nofail(dev);
 257    if (addr != (hwaddr)-1) {
 258        sysbus_mmio_map(s, 0, addr);
 259    }
 260    va_start(va, addr);
 261    n = 0;
 262    while (1) {
 263        irq = va_arg(va, qemu_irq);
 264        if (!irq) {
 265            break;
 266        }
 267        sysbus_connect_irq(s, n, irq);
 268        n++;
 269    }
 270    va_end(va);
 271    return dev;
 272}
 273
 274static void sysbus_dev_print(Monitor *mon, DeviceState *dev, int indent)
 275{
 276    SysBusDevice *s = SYS_BUS_DEVICE(dev);
 277    hwaddr size;
 278    int i;
 279
 280    for (i = 0; i < s->num_mmio; i++) {
 281        size = memory_region_size(s->mmio[i].memory);
 282        monitor_printf(mon, "%*smmio " TARGET_FMT_plx "/" TARGET_FMT_plx "\n",
 283                       indent, "", s->mmio[i].addr, size);
 284    }
 285}
 286
 287static char *sysbus_get_fw_dev_path(DeviceState *dev)
 288{
 289    SysBusDevice *s = SYS_BUS_DEVICE(dev);
 290    SysBusDeviceClass *sbc = SYS_BUS_DEVICE_GET_CLASS(s);
 291    char *addr, *fw_dev_path;
 292
 293    if (sbc->explicit_ofw_unit_address) {
 294        addr = sbc->explicit_ofw_unit_address(s);
 295        if (addr) {
 296            fw_dev_path = g_strdup_printf("%s@%s", qdev_fw_name(dev), addr);
 297            g_free(addr);
 298            return fw_dev_path;
 299        }
 300    }
 301    if (s->num_mmio) {
 302        return g_strdup_printf("%s@" TARGET_FMT_plx, qdev_fw_name(dev),
 303                               s->mmio[0].addr);
 304    }
 305    if (s->num_pio) {
 306        return g_strdup_printf("%s@i%04x", qdev_fw_name(dev), s->pio[0]);
 307    }
 308    return g_strdup(qdev_fw_name(dev));
 309}
 310
 311void sysbus_add_io(SysBusDevice *dev, hwaddr addr,
 312                       MemoryRegion *mem)
 313{
 314    memory_region_add_subregion(get_system_io(), addr, mem);
 315}
 316
 317MemoryRegion *sysbus_address_space(SysBusDevice *dev)
 318{
 319    return get_system_memory();
 320}
 321
 322static void sysbus_device_class_init(ObjectClass *klass, void *data)
 323{
 324    DeviceClass *k = DEVICE_CLASS(klass);
 325    k->realize = sysbus_realize;
 326    k->bus_type = TYPE_SYSTEM_BUS;
 327    /*
 328     * device_add plugs devices into a suitable bus.  For "real" buses,
 329     * that actually connects the device.  For sysbus, the connections
 330     * need to be made separately, and device_add can't do that.  The
 331     * device would be left unconnected, and will probably not work
 332     *
 333     * However, a few machines can handle device_add/-device with
 334     * a few specific sysbus devices. In those cases, the device
 335     * subclass needs to override it and set user_creatable=true.
 336     */
 337    k->user_creatable = false;
 338}
 339
 340static const TypeInfo sysbus_device_type_info = {
 341    .name = TYPE_SYS_BUS_DEVICE,
 342    .parent = TYPE_DEVICE,
 343    .instance_size = sizeof(SysBusDevice),
 344    .abstract = true,
 345    .class_size = sizeof(SysBusDeviceClass),
 346    .class_init = sysbus_device_class_init,
 347};
 348
 349/* This is a nasty hack to allow passing a NULL bus to qdev_create.  */
 350static BusState *main_system_bus;
 351
 352static void main_system_bus_create(void)
 353{
 354    /* assign main_system_bus before qbus_create_inplace()
 355     * in order to make "if (bus != sysbus_get_default())" work */
 356    main_system_bus = g_malloc0(system_bus_info.instance_size);
 357    qbus_create_inplace(main_system_bus, system_bus_info.instance_size,
 358                        TYPE_SYSTEM_BUS, NULL, "main-system-bus");
 359    OBJECT(main_system_bus)->free = g_free;
 360}
 361
 362BusState *sysbus_get_default(void)
 363{
 364    if (!main_system_bus) {
 365        main_system_bus_create();
 366    }
 367    return main_system_bus;
 368}
 369
 370void sysbus_init_child_obj(Object *parent, const char *childname, void *child,
 371                           size_t childsize, const char *childtype)
 372{
 373    object_initialize_child(parent, childname, child, childsize, childtype,
 374                            &error_abort, NULL);
 375    qdev_set_parent_bus(DEVICE(child), sysbus_get_default());
 376}
 377
 378static void sysbus_register_types(void)
 379{
 380    type_register_static(&system_bus_info);
 381    type_register_static(&sysbus_device_type_info);
 382}
 383
 384type_init(sysbus_register_types)
 385