hw/isa/isa-superio.c

   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)