qemu

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.1 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 "qemu/error-report.h"
22
#include "qemu/module.h"
23
#include "qapi/error.h"
24
#include "hw/sysbus.h"
25
#include "sysemu/sysemu.h"
26
#include "hw/isa/isa.h"
27

28
static ISABus *isabus;
29

30
static char *isabus_get_fw_dev_path(DeviceState *dev);
31

32
static void isa_bus_class_init(ObjectClass *klass, void *data)
33
{
34
    BusClass *k = BUS_CLASS(klass);
35

36
    k->get_fw_dev_path = isabus_get_fw_dev_path;
37
}
38

39
static const TypeInfo isa_dma_info = {
40
    .name = TYPE_ISADMA,
41
    .parent = TYPE_INTERFACE,
42
    .class_size = sizeof(IsaDmaClass),
43
};
44

45
static const TypeInfo isa_bus_info = {
46
    .name = TYPE_ISA_BUS,
47
    .parent = TYPE_BUS,
48
    .instance_size = sizeof(ISABus),
49
    .class_init = isa_bus_class_init,
50
};
51

52
ISABus *isa_bus_new(DeviceState *dev, MemoryRegion* address_space,
53
                    MemoryRegion *address_space_io, Error **errp)
54
{
55
    DeviceState *bridge = NULL;
56

57
    if (isabus) {
58
        error_setg(errp, "Can't create a second ISA bus");
59
        return NULL;
60
    }
61
    if (!dev) {
62
        bridge = qdev_new("isabus-bridge");
63
        dev = bridge;
64
    }
65

66
    isabus = ISA_BUS(qbus_new(TYPE_ISA_BUS, dev, NULL));
67
    isabus->address_space = address_space;
68
    isabus->address_space_io = address_space_io;
69

70
    if (bridge) {
71
        sysbus_realize_and_unref(SYS_BUS_DEVICE(bridge), &error_fatal);
72
    }
73

74
    return isabus;
75
}
76

77
void isa_bus_register_input_irqs(ISABus *bus, qemu_irq *irqs_in)
78
{
79
    bus->irqs_in = irqs_in;
80
}
81

82
qemu_irq isa_bus_get_irq(ISABus *bus, unsigned irqnum)
83
{
84
    assert(irqnum < ISA_NUM_IRQS);
85
    assert(bus->irqs_in);
86
    return bus->irqs_in[irqnum];
87
}
88

89
/*
90
 * isa_get_irq() returns the corresponding input qemu_irq entry for the i8259.
91
 *
92
 * This function is only for special cases such as the 'ferr', and
93
 * temporary use for normal devices until they are converted to qdev.
94
 */
95
qemu_irq isa_get_irq(ISADevice *dev, unsigned isairq)
96
{
97
    assert(!dev || ISA_BUS(qdev_get_parent_bus(DEVICE(dev))) == isabus);
98
    return isa_bus_get_irq(isabus, isairq);
99
}
100

101
void isa_connect_gpio_out(ISADevice *isadev, int gpioirq, unsigned isairq)
102
{
103
    qemu_irq input_irq = isa_get_irq(isadev, isairq);
104
    qdev_connect_gpio_out(DEVICE(isadev), gpioirq, input_irq);
105
}
106

107
void isa_bus_dma(ISABus *bus, IsaDma *dma8, IsaDma *dma16)
108
{
109
    assert(bus && dma8 && dma16);
110
    assert(!bus->dma[0] && !bus->dma[1]);
111
    bus->dma[0] = dma8;
112
    bus->dma[1] = dma16;
113
}
114

115
IsaDma *isa_bus_get_dma(ISABus *bus, int nchan)
116
{
117
    assert(bus);
118
    return bus->dma[nchan > 3 ? 1 : 0];
119
}
120

121
static inline void isa_init_ioport(ISADevice *dev, uint16_t ioport)
122
{
123
    if (dev && (dev->ioport_id == 0 || ioport < dev->ioport_id)) {
124
        dev->ioport_id = ioport;
125
    }
126
}
127

128
void isa_register_ioport(ISADevice *dev, MemoryRegion *io, uint16_t start)
129
{
130
    memory_region_add_subregion(isa_address_space_io(dev), start, io);
131
    isa_init_ioport(dev, start);
132
}
133

134
int isa_register_portio_list(ISADevice *dev,
135
                             PortioList *piolist, uint16_t start,
136
                             const MemoryRegionPortio *pio_start,
137
                             void *opaque, const char *name)
138
{
139
    assert(piolist && !piolist->owner);
140

141
    if (!isabus) {
142
        return -ENODEV;
143
    }
144

145
    /* START is how we should treat DEV, regardless of the actual
146
       contents of the portio array.  This is how the old code
147
       actually handled e.g. the FDC device.  */
148
    isa_init_ioport(dev, start);
149

150
    portio_list_init(piolist, OBJECT(dev), pio_start, opaque, name);
151
    portio_list_add(piolist, isa_address_space_io(dev), start);
152

153
    return 0;
154
}
155

156
ISADevice *isa_new(const char *name)
157
{
158
    return ISA_DEVICE(qdev_new(name));
159
}
160

161
ISADevice *isa_try_new(const char *name)
162
{
163
    return ISA_DEVICE(qdev_try_new(name));
164
}
165

166
ISADevice *isa_create_simple(ISABus *bus, const char *name)
167
{
168
    ISADevice *dev;
169

170
    dev = isa_new(name);
171
    isa_realize_and_unref(dev, bus, &error_fatal);
172
    return dev;
173
}
174

175
bool isa_realize_and_unref(ISADevice *dev, ISABus *bus, Error **errp)
176
{
177
    return qdev_realize_and_unref(&dev->parent_obj, &bus->parent_obj, errp);
178
}
179

180
ISABus *isa_bus_from_device(ISADevice *dev)
181
{
182
    return ISA_BUS(qdev_get_parent_bus(DEVICE(dev)));
183
}
184

185
ISADevice *isa_vga_init(ISABus *bus)
186
{
187
    vga_interface_created = true;
188
    switch (vga_interface_type) {
189
    case VGA_CIRRUS:
190
        return isa_create_simple(bus, "isa-cirrus-vga");
191
    case VGA_QXL:
192
        error_report("%s: qxl: no PCI bus", __func__);
193
        return NULL;
194
    case VGA_STD:
195
        return isa_create_simple(bus, "isa-vga");
196
    case VGA_VMWARE:
197
        error_report("%s: vmware_vga: no PCI bus", __func__);
198
        return NULL;
199
    case VGA_VIRTIO:
200
        error_report("%s: virtio-vga: no PCI bus", __func__);
201
        return NULL;
202
    case VGA_NONE:
203
    default:
204
        return NULL;
205
    }
206
}
207

208
static void isabus_bridge_class_init(ObjectClass *klass, void *data)
209
{
210
    DeviceClass *dc = DEVICE_CLASS(klass);
211

212
    set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
213
    dc->fw_name = "isa";
214
}
215

216
static const TypeInfo isabus_bridge_info = {
217
    .name          = "isabus-bridge",
218
    .parent        = TYPE_SYS_BUS_DEVICE,
219
    .instance_size = sizeof(SysBusDevice),
220
    .class_init    = isabus_bridge_class_init,
221
};
222

223
static void isa_device_class_init(ObjectClass *klass, void *data)
224
{
225
    DeviceClass *k = DEVICE_CLASS(klass);
226
    k->bus_type = TYPE_ISA_BUS;
227
}
228

229
static const TypeInfo isa_device_type_info = {
230
    .name = TYPE_ISA_DEVICE,
231
    .parent = TYPE_DEVICE,
232
    .instance_size = sizeof(ISADevice),
233
    .abstract = true,
234
    .class_init = isa_device_class_init,
235
};
236

237
static void isabus_register_types(void)
238
{
239
    type_register_static(&isa_dma_info);
240
    type_register_static(&isa_bus_info);
241
    type_register_static(&isabus_bridge_info);
242
    type_register_static(&isa_device_type_info);
243
}
244

245
static char *isabus_get_fw_dev_path(DeviceState *dev)
246
{
247
    ISADevice *d = ISA_DEVICE(dev);
248
    char path[40];
249
    int off;
250

251
    off = snprintf(path, sizeof(path), "%s", qdev_fw_name(dev));
252
    if (d->ioport_id) {
253
        snprintf(path + off, sizeof(path) - off, "@%04x", d->ioport_id);
254
    }
255

256
    return g_strdup(path);
257
}
258

259
MemoryRegion *isa_address_space(ISADevice *dev)
260
{
261
    if (dev) {
262
        return isa_bus_from_device(dev)->address_space;
263
    }
264

265
    return isabus->address_space;
266
}
267

268
MemoryRegion *isa_address_space_io(ISADevice *dev)
269
{
270
    if (dev) {
271
        return isa_bus_from_device(dev)->address_space_io;
272
    }
273

274
    return isabus->address_space_io;
275
}
276

277
type_init(isabus_register_types)
278