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/* TODO remove once all sysbus devices have been converted to realize */
 205static void sysbus_realize(DeviceState *dev, Error **errp)
 206{
 207    SysBusDevice *sd = SYS_BUS_DEVICE(dev);
 208    SysBusDeviceClass *sbc = SYS_BUS_DEVICE_GET_CLASS(sd);
 209
 210    if (!sbc->init) {
 211        return;
 212    }
 213    if (sbc->init(sd) < 0) {
 214        error_setg(errp, "Device initialization failed");
 215    }
 216}
 217
 218DeviceState *sysbus_create_varargs(const char *name,
 219                                   hwaddr addr, ...)
 220{
 221    DeviceState *dev;
 222    SysBusDevice *s;
 223    va_list va;
 224    qemu_irq irq;
 225    int n;
 226
 227    dev = qdev_create(NULL, name);
 228    s = SYS_BUS_DEVICE(dev);
 229    qdev_init_nofail(dev);
 230    if (addr != (hwaddr)-1) {
 231        sysbus_mmio_map(s, 0, addr);
 232    }
 233    va_start(va, addr);
 234    n = 0;
 235    while (1) {
 236        irq = va_arg(va, qemu_irq);
 237        if (!irq) {
 238            break;
 239        }
 240        sysbus_connect_irq(s, n, irq);
 241        n++;
 242    }
 243    va_end(va);
 244    return dev;
 245}
 246
 247DeviceState *sysbus_try_create_varargs(const char *name,
 248                                       hwaddr addr, ...)
 249{
 250    DeviceState *dev;
 251    SysBusDevice *s;
 252    va_list va;
 253    qemu_irq irq;
 254    int n;
 255
 256    dev = qdev_try_create(NULL, name);
 257    if (!dev) {
 258        return NULL;
 259    }
 260    s = SYS_BUS_DEVICE(dev);
 261    qdev_init_nofail(dev);
 262    if (addr != (hwaddr)-1) {
 263        sysbus_mmio_map(s, 0, addr);
 264    }
 265    va_start(va, addr);
 266    n = 0;
 267    while (1) {
 268        irq = va_arg(va, qemu_irq);
 269        if (!irq) {
 270            break;
 271        }
 272        sysbus_connect_irq(s, n, irq);
 273        n++;
 274    }
 275    va_end(va);
 276    return dev;
 277}
 278
 279static void sysbus_dev_print(Monitor *mon, DeviceState *dev, int indent)
 280{
 281    SysBusDevice *s = SYS_BUS_DEVICE(dev);
 282    hwaddr size;
 283    int i;
 284
 285    for (i = 0; i < s->num_mmio; i++) {
 286        size = memory_region_size(s->mmio[i].memory);
 287        monitor_printf(mon, "%*smmio " TARGET_FMT_plx "/" TARGET_FMT_plx "\n",
 288                       indent, "", s->mmio[i].addr, size);
 289    }
 290}
 291
 292static char *sysbus_get_fw_dev_path(DeviceState *dev)
 293{
 294    SysBusDevice *s = SYS_BUS_DEVICE(dev);
 295    SysBusDeviceClass *sbc = SYS_BUS_DEVICE_GET_CLASS(s);
 296    /* for the explicit unit address fallback case: */
 297    char *addr, *fw_dev_path;
 298
 299    if (s->num_mmio) {
 300        return g_strdup_printf("%s@" TARGET_FMT_plx, qdev_fw_name(dev),
 301                               s->mmio[0].addr);
 302    }
 303    if (s->num_pio) {
 304        return g_strdup_printf("%s@i%04x", qdev_fw_name(dev), s->pio[0]);
 305    }
 306    if (sbc->explicit_ofw_unit_address) {
 307        addr = sbc->explicit_ofw_unit_address(s);
 308        if (addr) {
 309            fw_dev_path = g_strdup_printf("%s@%s", qdev_fw_name(dev), addr);
 310            g_free(addr);
 311            return fw_dev_path;
 312        }
 313    }
 314    return g_strdup(qdev_fw_name(dev));
 315}
 316
 317void sysbus_add_io(SysBusDevice *dev, hwaddr addr,
 318                       MemoryRegion *mem)
 319{
 320    memory_region_add_subregion(get_system_io(), addr, mem);
 321}
 322
 323MemoryRegion *sysbus_address_space(SysBusDevice *dev)
 324{
 325    return get_system_memory();
 326}
 327
 328static void sysbus_device_class_init(ObjectClass *klass, void *data)
 329{
 330    DeviceClass *k = DEVICE_CLASS(klass);
 331    k->realize = sysbus_realize;
 332    k->bus_type = TYPE_SYSTEM_BUS;
 333    /*
 334     * device_add plugs devices into a suitable bus.  For "real" buses,
 335     * that actually connects the device.  For sysbus, the connections
 336     * need to be made separately, and device_add can't do that.  The
 337     * device would be left unconnected, and will probably not work
 338     *
 339     * However, a few machines can handle device_add/-device with
 340     * a few specific sysbus devices. In those cases, the device
 341     * subclass needs to override it and set user_creatable=true.
 342     */
 343    k->user_creatable = false;
 344}
 345
 346static const TypeInfo sysbus_device_type_info = {
 347    .name = TYPE_SYS_BUS_DEVICE,
 348    .parent = TYPE_DEVICE,
 349    .instance_size = sizeof(SysBusDevice),
 350    .abstract = true,
 351    .class_size = sizeof(SysBusDeviceClass),
 352    .class_init = sysbus_device_class_init,
 353};
 354
 355/* This is a nasty hack to allow passing a NULL bus to qdev_create.  */
 356static BusState *main_system_bus;
 357
 358static void main_system_bus_create(void)
 359{
 360    /* assign main_system_bus before qbus_create_inplace()
 361     * in order to make "if (bus != sysbus_get_default())" work */
 362    main_system_bus = g_malloc0(system_bus_info.instance_size);
 363    qbus_create_inplace(main_system_bus, system_bus_info.instance_size,
 364                        TYPE_SYSTEM_BUS, NULL, "main-system-bus");
 365    OBJECT(main_system_bus)->free = g_free;
 366    object_property_add_child(container_get(qdev_get_machine(),
 367                                            "/unattached"),
 368                              "sysbus", OBJECT(main_system_bus), NULL);
 369}
 370
 371BusState *sysbus_get_default(void)
 372{
 373    if (!main_system_bus) {
 374        main_system_bus_create();
 375    }
 376    return main_system_bus;
 377}
 378
 379void sysbus_init_child_obj(Object *parent, const char *childname, void *child,
 380                           size_t childsize, const char *childtype)
 381{
 382    object_initialize_child(parent, childname, child, childsize, childtype,
 383                            &error_abort, NULL);
 384    qdev_set_parent_bus(DEVICE(child), sysbus_get_default());
 385}
 386
 387static void sysbus_register_types(void)
 388{
 389    type_register_static(&system_bus_info);
 390    type_register_static(&sysbus_device_type_info);
 391}
 392
 393type_init(sysbus_register_types)
 394