hw/isa/isa-bus.c

   1 /*
   2  * isa bus support for qdev.
   3  *
   4  * Copyright (c) 2009 Gerd Hoffmann <kraxel@redhat.com>
   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 #include "hw/hw.h"
  20 #include "monitor/monitor.h"
  21 #include "hw/sysbus.h"
  22 #include "sysemu/sysemu.h"
  23 #include "hw/isa/isa.h"
  24
  25 static ISABus *isabus;
  26 hwaddr isa_mem_base = 0;
  27
  28 static void isabus_dev_print(Monitor *mon, DeviceState *dev, int indent);
  29 static char *isabus_get_fw_dev_path(DeviceState *dev);
  30
  31 static void isa_bus_class_init(ObjectClass *klass, void *data)
  32 {
  33     BusClass *k = BUS_CLASS(klass);
  34
  35     k->print_dev = isabus_dev_print;
  36     k->get_fw_dev_path = isabus_get_fw_dev_path;
  37 }
  38
  39 static const TypeInfo isa_bus_info = {
  40     .name = TYPE_ISA_BUS,
  41     .parent = TYPE_BUS,
  42     .instance_size = sizeof(ISABus),
  43     .class_init = isa_bus_class_init,
  44 };
  45
  46 ISABus *isa_bus_new(DeviceState *dev, MemoryRegion* address_space,
  47                     MemoryRegion *address_space_io)
  48 {
  49     if (isabus) {
  50         fprintf(stderr, "Can't create a second ISA bus\n");
  51         return NULL;
  52     }
  53     if (!dev) {
  54         dev = qdev_create(NULL, "isabus-bridge");
  55         qdev_init_nofail(dev);
  56     }
  57
  58     isabus = ISA_BUS(qbus_create(TYPE_ISA_BUS, dev, NULL));
  59     isabus->address_space = address_space;
  60     isabus->address_space_io = address_space_io;
  61     return isabus;
  62 }
  63
  64 void isa_bus_irqs(ISABus *bus, qemu_irq *irqs)
  65 {
  66     if (!bus) {
  67         hw_error("Can't set isa irqs with no isa bus present.");
  68     }
  69     bus->irqs = irqs;
  70 }
  71
  72 /*
  73  * isa_get_irq() returns the corresponding qemu_irq entry for the i8259.
  74  *
  75  * This function is only for special cases such as the 'ferr', and
  76  * temporary use for normal devices until they are converted to qdev.
  77  */
  78 qemu_irq isa_get_irq(ISADevice *dev, int isairq)
  79 {
  80     assert(!dev || ISA_BUS(qdev_get_parent_bus(DEVICE(dev))) == isabus);
  81     if (isairq < 0 || isairq > 15) {
  82         hw_error("isa irq %d invalid", isairq);
  83     }
  84     return isabus->irqs[isairq];
  85 }
  86
  87 void isa_init_irq(ISADevice *dev, qemu_irq *p, int isairq)
  88 {
  89     assert(dev->nirqs < ARRAY_SIZE(dev->isairq));
  90     dev->isairq[dev->nirqs] = isairq;
  91     *p = isa_get_irq(dev, isairq);
  92     dev->nirqs++;
  93 }
  94
  95 static inline void isa_init_ioport(ISADevice *dev, uint16_t ioport)
  96 {
  97     if (dev && (dev->ioport_id == 0 || ioport < dev->ioport_id)) {
  98         dev->ioport_id = ioport;
  99     }
 100 }
 101
 102 void isa_register_ioport(ISADevice *dev, MemoryRegion *io, uint16_t start)
 103 {
 104     memory_region_add_subregion(isabus->address_space_io, start, io);
 105     isa_init_ioport(dev, start);
 106 }
 107
 108 void isa_register_portio_list(ISADevice *dev, uint16_t start,
 109                               const MemoryRegionPortio *pio_start,
 110                               void *opaque, const char *name)
 111 {
 112     PortioList piolist;
 113
 114     /* START is how we should treat DEV, regardless of the actual
 115        contents of the portio array.  This is how the old code
 116        actually handled e.g. the FDC device.  */
 117     isa_init_ioport(dev, start);
 118
 119     /* FIXME: the device should store created PortioList in its state.  Note
 120        that DEV can be NULL here and that single device can register several
 121        portio lists.  Current implementation is leaking memory allocated
 122        in portio_list_init.  The leak is not critical because it happens only
 123        at initialization time.  */
 124     portio_list_init(&piolist, OBJECT(dev), pio_start, opaque, name);
 125     portio_list_add(&piolist, isabus->address_space_io, start);
 126 }
 127
 128 static void isa_device_init(Object *obj)
 129 {
 130     ISADevice *dev = ISA_DEVICE(obj);
 131
 132     dev->isairq[0] = -1;
 133     dev->isairq[1] = -1;
 134 }
 135
 136 ISADevice *isa_create(ISABus *bus, const char *name)
 137 {
 138     DeviceState *dev;
 139
 140     if (!bus) {
 141         hw_error("Tried to create isa device %s with no isa bus present.",
 142                  name);
 143     }
 144     dev = qdev_create(BUS(bus), name);
 145     return ISA_DEVICE(dev);
 146 }
 147
 148 ISADevice *isa_try_create(ISABus *bus, const char *name)
 149 {
 150     DeviceState *dev;
 151
 152     if (!bus) {
 153         hw_error("Tried to create isa device %s with no isa bus present.",
 154                  name);
 155     }
 156     dev = qdev_try_create(BUS(bus), name);
 157     return ISA_DEVICE(dev);
 158 }
 159
 160 ISADevice *isa_create_simple(ISABus *bus, const char *name)
 161 {
 162     ISADevice *dev;
 163
 164     dev = isa_create(bus, name);
 165     qdev_init_nofail(DEVICE(dev));
 166     return dev;
 167 }
 168
 169 ISADevice *isa_vga_init(ISABus *bus)
 170 {
 171     switch (vga_interface_type) {
 172     case VGA_CIRRUS:
 173         return isa_create_simple(bus, "isa-cirrus-vga");
 174     case VGA_QXL:
 175         fprintf(stderr, "%s: qxl: no PCI bus\n", __func__);
 176         return NULL;
 177     case VGA_STD:
 178         return isa_create_simple(bus, "isa-vga");
 179     case VGA_VMWARE:
 180         fprintf(stderr, "%s: vmware_vga: no PCI bus\n", __func__);
 181         return NULL;
 182     case VGA_NONE:
 183     default:
 184         return NULL;
 185     }
 186 }
 187
 188 static void isabus_dev_print(Monitor *mon, DeviceState *dev, int indent)
 189 {
 190     ISADevice *d = ISA_DEVICE(dev);
 191
 192     if (d->isairq[1] != -1) {
 193         monitor_printf(mon, "%*sisa irqs %d,%d\n", indent, "",
 194                        d->isairq[0], d->isairq[1]);
 195     } else if (d->isairq[0] != -1) {
 196         monitor_printf(mon, "%*sisa irq %d\n", indent, "",
 197                        d->isairq[0]);
 198     }
 199 }
 200
 201 static void isabus_bridge_class_init(ObjectClass *klass, void *data)
 202 {
 203     DeviceClass *dc = DEVICE_CLASS(klass);
 204
 205     dc->fw_name = "isa";
 206 }
 207
 208 static const TypeInfo isabus_bridge_info = {
 209     .name          = "isabus-bridge",
 210     .parent        = TYPE_SYS_BUS_DEVICE,
 211     .instance_size = sizeof(SysBusDevice),
 212     .class_init    = isabus_bridge_class_init,
 213 };
 214
 215 static void isa_device_class_init(ObjectClass *klass, void *data)
 216 {
 217     DeviceClass *k = DEVICE_CLASS(klass);
 218     k->bus_type = TYPE_ISA_BUS;
 219 }
 220
 221 static const TypeInfo isa_device_type_info = {
 222     .name = TYPE_ISA_DEVICE,
 223     .parent = TYPE_DEVICE,
 224     .instance_size = sizeof(ISADevice),
 225     .instance_init = isa_device_init,
 226     .abstract = true,
 227     .class_size = sizeof(ISADeviceClass),
 228     .class_init = isa_device_class_init,
 229 };
 230
 231 static void isabus_register_types(void)
 232 {
 233     type_register_static(&isa_bus_info);
 234     type_register_static(&isabus_bridge_info);
 235     type_register_static(&isa_device_type_info);
 236 }
 237
 238 static char *isabus_get_fw_dev_path(DeviceState *dev)
 239 {
 240     ISADevice *d = ISA_DEVICE(dev);
 241     char path[40];
 242     int off;
 243
 244     off = snprintf(path, sizeof(path), "%s", qdev_fw_name(dev));
 245     if (d->ioport_id) {
 246         snprintf(path + off, sizeof(path) - off, "@%04x", d->ioport_id);
 247     }
 248
 249     return g_strdup(path);
 250 }
 251
 252 MemoryRegion *isa_address_space(ISADevice *dev)
 253 {
 254     if (dev) {
 255         return isa_bus_from_device(dev)->address_space;
 256     }
 257
 258     return isabus->address_space;
 259 }
 260
 261 MemoryRegion *isa_address_space_io(ISADevice *dev)
 262 {
 263     if (dev) {
 264         return isa_bus_from_device(dev)->address_space_io;
 265     }
 266
 267     return isabus->address_space_io;
 268 }
 269
 270 type_init(isabus_register_types)