qemu

1
/*
2
 * Generic ISA Super I/O
3
 *
4
 * Copyright (c) 2010-2012 Herve Poussineau
5
 * Copyright (c) 2011-2012 Andreas Färber
6
 * Copyright (c) 2018 Philippe Mathieu-Daudé
7
 *
8
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
9
 * See the COPYING file in the top-level directory.
10
 * SPDX-License-Identifier: GPL-2.0-or-later
11
 */
12

13
#include "qemu/osdep.h"
14
#include "qemu/error-report.h"
15
#include "qemu/module.h"
16
#include "qapi/error.h"
17
#include "sysemu/blockdev.h"
18
#include "chardev/char.h"
19
#include "hw/char/parallel.h"
20
#include "hw/block/fdc.h"
21
#include "hw/isa/superio.h"
22
#include "hw/qdev-properties.h"
23
#include "hw/input/i8042.h"
24
#include "hw/char/parallel-isa.h"
25
#include "hw/char/serial.h"
26
#include "trace.h"
27

28
static void isa_superio_realize(DeviceState *dev, Error **errp)
29
{
30
    ISASuperIODevice *sio = ISA_SUPERIO(dev);
31
    ISASuperIOClass *k = ISA_SUPERIO_GET_CLASS(sio);
32
    ISABus *bus = isa_bus_from_device(ISA_DEVICE(dev));
33
    ISADevice *isa;
34
    DeviceState *d;
35
    Chardev *chr;
36
    DriveInfo *fd[MAX_FD];
37
    char *name;
38
    int i;
39

40
    /* Parallel port */
41
    for (i = 0; i < k->parallel.count; i++) {
42
        if (i >= ARRAY_SIZE(sio->parallel)) {
43
            warn_report("superio: ignoring %td parallel controllers",
44
                        k->parallel.count - ARRAY_SIZE(sio->parallel));
45
            break;
46
        }
47
        if (!k->parallel.is_enabled || k->parallel.is_enabled(sio, i)) {
48
            /* FIXME use a qdev chardev prop instead of parallel_hds[] */
49
            chr = parallel_hds[i];
50
            if (chr == NULL) {
51
                name = g_strdup_printf("discarding-parallel%d", i);
52
                chr = qemu_chr_new(name, "null", NULL);
53
            } else {
54
                name = g_strdup_printf("parallel%d", i);
55
            }
56
            isa = isa_new(TYPE_ISA_PARALLEL);
57
            d = DEVICE(isa);
58
            qdev_prop_set_uint32(d, "index", i);
59
            if (k->parallel.get_iobase) {
60
                qdev_prop_set_uint32(d, "iobase",
61
                                     k->parallel.get_iobase(sio, i));
62
            }
63
            if (k->parallel.get_irq) {
64
                qdev_prop_set_uint32(d, "irq", k->parallel.get_irq(sio, i));
65
            }
66
            qdev_prop_set_chr(d, "chardev", chr);
67
            object_property_add_child(OBJECT(dev), name, OBJECT(isa));
68
            isa_realize_and_unref(isa, bus, &error_fatal);
69
            sio->parallel[i] = isa;
70
            trace_superio_create_parallel(i,
71
                                          k->parallel.get_iobase ?
72
                                          k->parallel.get_iobase(sio, i) : -1,
73
                                          k->parallel.get_irq ?
74
                                          k->parallel.get_irq(sio, i) : -1);
75
            g_free(name);
76
        }
77
    }
78

79
    /* Serial */
80
    for (i = 0; i < k->serial.count; i++) {
81
        if (i >= ARRAY_SIZE(sio->serial)) {
82
            warn_report("superio: ignoring %td serial controllers",
83
                        k->serial.count - ARRAY_SIZE(sio->serial));
84
            break;
85
        }
86
        if (!k->serial.is_enabled || k->serial.is_enabled(sio, i)) {
87
            /* FIXME use a qdev chardev prop instead of serial_hd() */
88
            chr = serial_hd(i);
89
            if (chr == NULL) {
90
                name = g_strdup_printf("discarding-serial%d", i);
91
                chr = qemu_chr_new(name, "null", NULL);
92
            } else {
93
                name = g_strdup_printf("serial%d", i);
94
            }
95
            isa = isa_new(TYPE_ISA_SERIAL);
96
            d = DEVICE(isa);
97
            qdev_prop_set_uint32(d, "index", i);
98
            if (k->serial.get_iobase) {
99
                qdev_prop_set_uint32(d, "iobase",
100
                                     k->serial.get_iobase(sio, i));
101
            }
102
            if (k->serial.get_irq) {
103
                qdev_prop_set_uint32(d, "irq", k->serial.get_irq(sio, i));
104
            }
105
            qdev_prop_set_chr(d, "chardev", chr);
106
            object_property_add_child(OBJECT(dev), name, OBJECT(isa));
107
            isa_realize_and_unref(isa, bus, &error_fatal);
108
            sio->serial[i] = isa;
109
            trace_superio_create_serial(i,
110
                                        k->serial.get_iobase ?
111
                                        k->serial.get_iobase(sio, i) : -1,
112
                                        k->serial.get_irq ?
113
                                        k->serial.get_irq(sio, i) : -1);
114
            g_free(name);
115
        }
116
    }
117

118
    /* Floppy disc */
119
    assert(k->floppy.count <= 1);
120
    if (k->floppy.count &&
121
        (!k->floppy.is_enabled || k->floppy.is_enabled(sio, 0))) {
122
        isa = isa_new(TYPE_ISA_FDC);
123
        d = DEVICE(isa);
124
        if (k->floppy.get_iobase) {
125
            qdev_prop_set_uint32(d, "iobase", k->floppy.get_iobase(sio, 0));
126
        }
127
        if (k->floppy.get_irq) {
128
            qdev_prop_set_uint32(d, "irq", k->floppy.get_irq(sio, 0));
129
        }
130
        /* FIXME use a qdev drive property instead of drive_get() */
131
        for (i = 0; i < MAX_FD; i++) {
132
            fd[i] = drive_get(IF_FLOPPY, 0, i);
133
        }
134
        object_property_add_child(OBJECT(sio), "isa-fdc", OBJECT(isa));
135
        isa_realize_and_unref(isa, bus, &error_fatal);
136
        isa_fdc_init_drives(isa, fd);
137
        sio->floppy = isa;
138
        trace_superio_create_floppy(0,
139
                                    k->floppy.get_iobase ?
140
                                    k->floppy.get_iobase(sio, 0) : -1,
141
                                    k->floppy.get_irq ?
142
                                    k->floppy.get_irq(sio, 0) : -1);
143
    }
144

145
    /* Keyboard, mouse */
146
    isa = isa_new(TYPE_I8042);
147
    object_property_add_child(OBJECT(sio), TYPE_I8042, OBJECT(isa));
148
    isa_realize_and_unref(isa, bus, &error_fatal);
149
    sio->kbc = isa;
150

151
    /* IDE */
152
    if (k->ide.count && (!k->ide.is_enabled || k->ide.is_enabled(sio, 0))) {
153
        isa = isa_new("isa-ide");
154
        d = DEVICE(isa);
155
        if (k->ide.get_iobase) {
156
            qdev_prop_set_uint32(d, "iobase", k->ide.get_iobase(sio, 0));
157
        }
158
        if (k->ide.get_iobase) {
159
            qdev_prop_set_uint32(d, "iobase2", k->ide.get_iobase(sio, 1));
160
        }
161
        if (k->ide.get_irq) {
162
            qdev_prop_set_uint32(d, "irq", k->ide.get_irq(sio, 0));
163
        }
164
        object_property_add_child(OBJECT(sio), "isa-ide", OBJECT(isa));
165
        isa_realize_and_unref(isa, bus, &error_fatal);
166
        sio->ide = isa;
167
        trace_superio_create_ide(0,
168
                                 k->ide.get_iobase ?
169
                                 k->ide.get_iobase(sio, 0) : -1,
170
                                 k->ide.get_irq ?
171
                                 k->ide.get_irq(sio, 0) : -1);
172
    }
173
}
174

175
static void isa_superio_class_init(ObjectClass *oc, void *data)
176
{
177
    DeviceClass *dc = DEVICE_CLASS(oc);
178

179
    dc->realize = isa_superio_realize;
180
    /* Reason: Uses parallel_hds[0] in realize(), so it can't be used twice */
181
    dc->user_creatable = false;
182
}
183

184
static const TypeInfo isa_superio_type_info = {
185
    .name = TYPE_ISA_SUPERIO,
186
    .parent = TYPE_ISA_DEVICE,
187
    .abstract = true,
188
    .class_size = sizeof(ISASuperIOClass),
189
    .class_init = isa_superio_class_init,
190
    .instance_size = sizeof(ISASuperIODevice),
191
};
192

193
static void isa_superio_register_types(void)
194
{
195
    type_register_static(&isa_superio_type_info);
196
}
197

198
type_init(isa_superio_register_types)
199