Add virtio_mmio_setup_one() to setup virtio mmio devices. Add vp_init_mmio() to initialize device struct. Because virtio-pci and virtio-mmio are quite simliar we reuse the infrastructure we already have for virtio-pci and just setup struct vp_cap for virtio-mmio. Signed-off-by: Gerd Hoffmann <kraxel@redhat.com> --- Makefile | 2 +- src/hw/virtio-mmio.h | 76 ++++++++++++++++++++++++++++++++++++++++++++ src/hw/virtio-pci.h | 1 + src/hw/virtio-mmio.c | 58 +++++++++++++++++++++++++++++++++ 4 files changed, 136 insertions(+), 1 deletion(-) create mode 100644 src/hw/virtio-mmio.h create mode 100644 src/hw/virtio-mmio.c diff --git a/Makefile b/Makefile index 5f7d5370198a..985ef591a13b 100644 --- a/Makefile +++ b/Makefile @@ -43,7 +43,7 @@ SRC32FLAT=$(SRCBOTH) post.c e820map.c malloc.c romfile.c x86.c optionroms.c \ fw/coreboot.c fw/lzmadecode.c fw/multiboot.c fw/csm.c fw/biostables.c \ fw/paravirt.c fw/shadow.c fw/pciinit.c fw/smm.c fw/smp.c fw/mtrr.c fw/xen.c \ fw/acpi.c fw/mptable.c fw/pirtable.c fw/smbios.c fw/romfile_loader.c \ - hw/virtio-ring.c hw/virtio-pci.c hw/virtio-blk.c hw/virtio-scsi.c \ + hw/virtio-ring.c hw/virtio-pci.c hw/virtio-mmio.c hw/virtio-blk.c hw/virtio-scsi.c \ hw/tpm_drivers.c hw/nvme.c SRC32SEG=string.c output.c pcibios.c apm.c stacks.c hw/pci.c hw/serialio.c DIRS=src src/hw src/fw vgasrc diff --git a/src/hw/virtio-mmio.h b/src/hw/virtio-mmio.h new file mode 100644 index 000000000000..9e0dae421009 --- /dev/null +++ b/src/hw/virtio-mmio.h @@ -0,0 +1,76 @@ +#ifndef _VIRTIO_MMIO_H +#define _VIRTIO_MMIO_H + +struct vp_device; + +typedef struct virtio_mmio_cfg { + u32 magic; + u32 version; + u32 device_id; + u32 vendor_id; + + u32 device_feature; + u32 device_feature_select; + u32 res_18; + u32 res_1c; + + u32 guest_feature; + u32 guest_feature_select; + u32 legacy_guest_page_size; + u32 res_2c; + + u32 queue_select; + u32 queue_num_max; + u32 queue_num; + u32 legacy_queue_align; + + u32 legacy_queue_pfn; + u32 queue_ready; + u32 res_48; + u32 res_4c; + + u32 queue_notify; + u32 res_54; + u32 res_58; + u32 res_5c; + + u32 irq_status; + u32 irq_ack; + u32 res_68; + u32 res_6c; + + u32 device_status; + u32 res_74; + u32 res_78; + u32 res_7c; + + u32 queue_desc_lo; + u32 queue_desc_hi; + u32 res_88; + u32 res_8c; + + u32 queue_driver_lo; + u32 queue_driver_hi; + u32 res_98; + u32 res_9c; + + u32 queue_device_lo; + u32 queue_device_hi; + u32 res_a8; + u32 shm_sel; + + u32 shmem_len_lo; + u32 shmem_len_hi; + u32 shmem_base_lo; + u32 shmem_base_hi; + + u32 res_c0_f7[14]; + + u32 res_f8; + u32 config_generation; +} virtio_mmio_cfg; + +void virtio_mmio_setup_one(u64 mmio); +void vp_init_mmio(struct vp_device *vp, void *mmio); + +#endif /* _VIRTIO_MMIO_H */ diff --git a/src/hw/virtio-pci.h b/src/hw/virtio-pci.h index 492e5c7c9166..269626448558 100644 --- a/src/hw/virtio-pci.h +++ b/src/hw/virtio-pci.h @@ -111,6 +111,7 @@ struct vp_device { struct vp_cap common, notify, isr, device, legacy; u32 notify_off_multiplier; u8 use_modern; + u8 use_mmio; }; u64 _vp_read(struct vp_cap *cap, u32 offset, u8 size); diff --git a/src/hw/virtio-mmio.c b/src/hw/virtio-mmio.c new file mode 100644 index 000000000000..0d6ef6e2f19d --- /dev/null +++ b/src/hw/virtio-mmio.c @@ -0,0 +1,58 @@ +#include "config.h" // CONFIG_DEBUG_LEVEL +#include "malloc.h" // free +#include "output.h" // dprintf +#include "stacks.h" // run_thread +#include "string.h" // memset +#include "virtio-pci.h" +#include "virtio-ring.h" +#include "virtio-mmio.h" + +void virtio_mmio_setup_one(u64 addr) +{ + u32 magic, version, devid; + void *mmio; + + if (addr >= 0x100000000) { + dprintf(1, "virtio-mmio: %llx: above 4G\n", addr); + return; + } + + mmio = (void*)(u32)(addr); + magic = readl(mmio); + if (magic != 0x74726976) { + dprintf(1, "virtio-mmio: %llx: magic mismatch\n", addr); + return; + } + version = readl(mmio+4); + if (version != 1 /* legacy */ && + version != 2 /* 1.0 */) { + dprintf(1, "virtio-mmio: %llx: unknown version %d\n", addr, version); + return; + } + devid = readl(mmio+8); + dprintf(1, "virtio-mmio: %llx: device id %x%s\n", + addr, devid, version == 1 ? " (legacy)" : ""); + switch (devid) { + case 2: /* blk */ + /* TODO */ + break; + case 8: /* scsi */ + /* TODO */ + break; + default: + break; + } +} + +void vp_init_mmio(struct vp_device *vp, void *mmio) +{ + memset(vp, 0, sizeof(*vp)); + vp->use_mmio = 1; + vp->common.mode = VP_ACCESS_MMIO; + vp->common.memaddr = mmio; + vp->device.mode = VP_ACCESS_MMIO; + vp->device.memaddr = mmio + 0x100; + vp_reset(vp); + vp_set_status(vp, VIRTIO_CONFIG_S_ACKNOWLEDGE | + VIRTIO_CONFIG_S_DRIVER); +} -- 2.18.2

Add new fields to struct virtio_lun_s for mmio support, add mmio parameter to virtio_scsi_init_lun(), so both pci and mmio devices can be handled. Add and use bootprio_find_scsi_mmio_device() to figure boot priority of devices connected to a virtio-mmio scsi controller. Finally add init_virtio_scsi_mmio() to initialize one virtio-mmio scsi controller. Signed-off-by: Gerd Hoffmann <kraxel@redhat.com> --- src/hw/virtio-scsi.h | 1 + src/util.h | 1 + src/boot.c | 10 ++++++ src/hw/virtio-mmio.c | 3 +- src/hw/virtio-scsi.c | 73 +++++++++++++++++++++++++++++++++++++------- 5 files changed, 76 insertions(+), 12 deletions(-) diff --git a/src/hw/virtio-scsi.h b/src/hw/virtio-scsi.h index 7532cc98e56e..8f01de4cba99 100644 --- a/src/hw/virtio-scsi.h +++ b/src/hw/virtio-scsi.h @@ -43,5 +43,6 @@ struct virtio_scsi_resp_cmd { struct disk_op_s; int virtio_scsi_process_op(struct disk_op_s *op); void virtio_scsi_setup(void); +void init_virtio_scsi_mmio(void *data); #endif /* _VIRTIO_SCSI_H */ diff --git a/src/util.h b/src/util.h index 94592a2d2e8d..1c82e09ed87b 100644 --- a/src/util.h +++ b/src/util.h @@ -31,6 +31,7 @@ u8 is_bootprio_strict(void); struct pci_device; int bootprio_find_pci_device(struct pci_device *pci); int bootprio_find_scsi_device(struct pci_device *pci, int target, int lun); +int bootprio_find_scsi_mmio_device(void *mmio, int target, int lun); int bootprio_find_ata_device(struct pci_device *pci, int chanid, int slave); int bootprio_find_fdc_device(struct pci_device *pci, int port, int fdid); int bootprio_find_pci_rom(struct pci_device *pci, int instance); diff --git a/src/boot.c b/src/boot.c index 4f12988f687c..f2f084bea843 100644 --- a/src/boot.c +++ b/src/boot.c @@ -328,6 +328,16 @@ int bootprio_find_scsi_device(struct pci_device *pci, int target, int lun) return find_prio(desc); } +int bootprio_find_scsi_mmio_device(void *mmio, int target, int lun) +{ + if (!CONFIG_BOOTORDER) + return -1; + char desc[256]; + snprintf(desc, sizeof(desc), "/virtio-mmio@%016x/*@0/*@%x,%x", + (u32)mmio, target, lun); + return find_prio(desc); +} + int bootprio_find_ata_device(struct pci_device *pci, int chanid, int slave) { if (CONFIG_CSM) diff --git a/src/hw/virtio-mmio.c b/src/hw/virtio-mmio.c index 0d6ef6e2f19d..daca8a098a0b 100644 --- a/src/hw/virtio-mmio.c +++ b/src/hw/virtio-mmio.c @@ -4,6 +4,7 @@ #include "stacks.h" // run_thread #include "string.h" // memset #include "virtio-pci.h" +#include "virtio-scsi.h" #include "virtio-ring.h" #include "virtio-mmio.h" @@ -37,7 +38,7 @@ void virtio_mmio_setup_one(u64 addr) /* TODO */ break; case 8: /* scsi */ - /* TODO */ + run_thread(init_virtio_scsi_mmio, mmio); break; default: break; diff --git a/src/hw/virtio-scsi.c b/src/hw/virtio-scsi.c index a5332848b8c8..59f1c654d76b 100644 --- a/src/hw/virtio-scsi.c +++ b/src/hw/virtio-scsi.c @@ -22,10 +22,13 @@ #include "virtio-pci.h" #include "virtio-ring.h" #include "virtio-scsi.h" +#include "virtio-mmio.h" struct virtio_lun_s { struct drive_s drive; struct pci_device *pci; + void *mmio; + char name[16]; struct vring_virtqueue *vq; struct vp_device *vp; u16 target; @@ -94,7 +97,8 @@ virtio_scsi_process_op(struct disk_op_s *op) } static void -virtio_scsi_init_lun(struct virtio_lun_s *vlun, struct pci_device *pci, +virtio_scsi_init_lun(struct virtio_lun_s *vlun, + struct pci_device *pci, void *mmio, struct vp_device *vp, struct vring_virtqueue *vq, u16 target, u16 lun) { @@ -102,10 +106,15 @@ virtio_scsi_init_lun(struct virtio_lun_s *vlun, struct pci_device *pci, vlun->drive.type = DTYPE_VIRTIO_SCSI; vlun->drive.cntl_id = pci->bdf; vlun->pci = pci; + vlun->mmio = mmio; vlun->vp = vp; vlun->vq = vq; vlun->target = target; vlun->lun = lun; + if (vlun->pci) + snprintf(vlun->name, sizeof(vlun->name), "pci:%pP", vlun->pci); + if (vlun->mmio) + snprintf(vlun->name, sizeof(vlun->name), "mmio:%08x", (u32)vlun->mmio); } static int @@ -114,12 +123,17 @@ virtio_scsi_add_lun(u32 lun, struct drive_s *tmpl_drv) u8 skip_nonbootable = is_bootprio_strict(); struct virtio_lun_s *tmpl_vlun = container_of(tmpl_drv, struct virtio_lun_s, drive); - int prio = bootprio_find_scsi_device(tmpl_vlun->pci, tmpl_vlun->target, tmpl_vlun->lun); + int prio = -1; + + if (tmpl_vlun->pci) + prio = bootprio_find_scsi_device(tmpl_vlun->pci, tmpl_vlun->target, tmpl_vlun->lun); + if (tmpl_vlun->mmio) + prio = bootprio_find_scsi_mmio_device(tmpl_vlun->mmio, tmpl_vlun->target, tmpl_vlun->lun); if (skip_nonbootable && prio < 0) { - dprintf(1, "skipping init of a non-bootable virtio-scsi dev at %pP," + dprintf(1, "skipping init of a non-bootable virtio-scsi dev at %s," " target %d, lun %d\n", - tmpl_vlun->pci, tmpl_vlun->target, tmpl_vlun->lun); + tmpl_vlun->name, tmpl_vlun->target, tmpl_vlun->lun); return -1; } @@ -128,11 +142,12 @@ virtio_scsi_add_lun(u32 lun, struct drive_s *tmpl_drv) warn_noalloc(); return -1; } - virtio_scsi_init_lun(vlun, tmpl_vlun->pci, tmpl_vlun->vp, tmpl_vlun->vq, - tmpl_vlun->target, lun); + virtio_scsi_init_lun(vlun, tmpl_vlun->pci, tmpl_vlun->mmio,tmpl_vlun->vp, + tmpl_vlun->vq, tmpl_vlun->target, lun); - boot_lchs_find_scsi_device(vlun->pci, vlun->target, vlun->lun, - &(vlun->drive.lchs)); + if (vlun->pci) + boot_lchs_find_scsi_device(vlun->pci, vlun->target, vlun->lun, + &(vlun->drive.lchs)); int ret = scsi_drive_setup(&vlun->drive, "virtio-scsi", prio); if (ret) goto fail; @@ -144,13 +159,13 @@ fail: } static int -virtio_scsi_scan_target(struct pci_device *pci, struct vp_device *vp, +virtio_scsi_scan_target(struct pci_device *pci, void *mmio, struct vp_device *vp, struct vring_virtqueue *vq, u16 target) { struct virtio_lun_s vlun0; - virtio_scsi_init_lun(&vlun0, pci, vp, vq, target, 0); + virtio_scsi_init_lun(&vlun0, pci, mmio, vp, vq, target, 0); int ret = scsi_rep_luns_scan(&vlun0.drive, virtio_scsi_add_lun); return ret < 0 ? 0 : ret; @@ -198,7 +213,43 @@ init_virtio_scsi(void *data) int i, tot; for (tot = 0, i = 0; i < 256; i++) - tot += virtio_scsi_scan_target(pci, vp, vq, i); + tot += virtio_scsi_scan_target(pci, NULL, vp, vq, i); + + if (!tot) + goto fail; + + return; + +fail: + vp_reset(vp); + free(vp); + free(vq); +} + +void +init_virtio_scsi_mmio(void *mmio) +{ + dprintf(1, "found virtio-scsi-mmio at %p\n", mmio); + struct vring_virtqueue *vq = NULL; + struct vp_device *vp = malloc_high(sizeof(*vp)); + if (!vp) { + warn_noalloc(); + return; + } + vp_init_mmio(vp, mmio); + u8 status = VIRTIO_CONFIG_S_ACKNOWLEDGE | VIRTIO_CONFIG_S_DRIVER; + + if (vp_find_vq(vp, 2, &vq) < 0 ) { + dprintf(1, "fail to find vq for virtio-scsi-mmio %p\n", mmio); + goto fail; + } + + status |= VIRTIO_CONFIG_S_DRIVER_OK; + vp_set_status(vp, status); + + int i, tot; + for (tot = 0, i = 0; i < 256; i++) + tot += virtio_scsi_scan_target(NULL, mmio, vp, vq, i); if (!tot) goto fail; -- 2.18.2

--- src/hw/virtio-mmio.c | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/src/hw/virtio-mmio.c b/src/hw/virtio-mmio.c index adb28f730592..dabef7b7e53a 100644 --- a/src/hw/virtio-mmio.c +++ b/src/hw/virtio-mmio.c @@ -11,6 +11,19 @@ void virtio_mmio_setup_one(u64 addr) { + static const char *names[] = { + [ 1 ] = "net", + [ 2 ] = "blk", + [ 3 ] = "console", + [ 4 ] = "rng", + [ 8 ] = "scsi", + [ 9 ] = "9p", + [ 16 ] = "gpu", + [ 19 ] = "vsock", + [ 18 ] = "input", + [ 26 ] = "fs", + }; + const char *name; u32 magic, version, devid; void *mmio; @@ -32,8 +45,12 @@ void virtio_mmio_setup_one(u64 addr) return; } devid = readl(mmio+8); - dprintf(1, "virtio-mmio: %llx: device id %x%s\n", - addr, devid, version == 1 ? " (legacy)" : ""); + + name = (devid < ARRAY_SIZE(names) && names[devid] != NULL) + ? names[devid] : "unknown"; + dprintf(1, "virtio-mmio: %llx: device id %x (%s%s)\n", + addr, devid, name, version == 1 ? ", legacy" : ""); + switch (devid) { case 2: /* blk */ run_thread(init_virtio_blk_mmio, mmio); -- 2.18.2

Create a list of devices found in the DSDT table. Add helper functions to find devices, walk the list and figure device informations like mmio ranges and irqs. Signed-off-by: Gerd Hoffmann <kraxel@redhat.com> --- Makefile | 2 +- src/util.h | 11 + src/fw/biostables.c | 9 + src/fw/dsdt_parser.c | 668 +++++++++++++++++++++++++++++++++++++++++++ src/fw/paravirt.c | 5 +- src/Kconfig | 7 + 6 files changed, 699 insertions(+), 3 deletions(-) create mode 100644 src/fw/dsdt_parser.c diff --git a/Makefile b/Makefile index 985ef591a13b..f02eda314784 100644 --- a/Makefile +++ b/Makefile @@ -42,7 +42,7 @@ SRC32FLAT=$(SRCBOTH) post.c e820map.c malloc.c romfile.c x86.c optionroms.c \ hw/pcidevice.c hw/ahci.c hw/pvscsi.c hw/usb-xhci.c hw/usb-hub.c hw/sdcard.c \ fw/coreboot.c fw/lzmadecode.c fw/multiboot.c fw/csm.c fw/biostables.c \ fw/paravirt.c fw/shadow.c fw/pciinit.c fw/smm.c fw/smp.c fw/mtrr.c fw/xen.c \ - fw/acpi.c fw/mptable.c fw/pirtable.c fw/smbios.c fw/romfile_loader.c \ + fw/acpi.c fw/mptable.c fw/pirtable.c fw/smbios.c fw/romfile_loader.c fw/dsdt_parser.c \ hw/virtio-ring.c hw/virtio-pci.c hw/virtio-mmio.c hw/virtio-blk.c hw/virtio-scsi.c \ hw/tpm_drivers.c hw/nvme.c SRC32SEG=string.c output.c pcibios.c apm.c stacks.c hw/pci.c hw/serialio.c diff --git a/src/util.h b/src/util.h index 4f27fc307439..0de35229dc0c 100644 --- a/src/util.h +++ b/src/util.h @@ -94,6 +94,17 @@ void display_uuid(void); void copy_table(void *pos); void smbios_setup(void); +// fw/dsdt_parser.c +struct acpi_device; +void acpi_dsdt_parse(void); +struct acpi_device *acpi_dsdt_find_string(struct acpi_device *prev, const char *hid); +struct acpi_device *acpi_dsdt_find_eisaid(struct acpi_device *prev, u16 eisaid); +char *acpi_dsdt_name(struct acpi_device *dev); +int acpi_dsdt_present_eisaid(u16 eisaid); +int acpi_dsdt_find_io(struct acpi_device *dev, u64 *min, u64 *max); +int acpi_dsdt_find_mem(struct acpi_device *dev, u64 *min, u64 *max); +int acpi_dsdt_find_irq(struct acpi_device *dev, u64 *irq); + // fw/coreboot.c extern const char *CBvendor, *CBpart; struct cbfs_file; diff --git a/src/fw/biostables.c b/src/fw/biostables.c index 0d4fdb9c22e8..0597459e9875 100644 --- a/src/fw/biostables.c +++ b/src/fw/biostables.c @@ -4,6 +4,14 @@ // // This file may be distributed under the terms of the GNU LGPLv3 license. +#include "byteorder.h" // le32_to_cpu +#include "config.h" // CONFIG_* +// Support for manipulating bios tables (pir, mptable, acpi, smbios). +// +// Copyright (C) 2008,2009 Kevin O'Connor <kevin@koconnor.net> +// +// This file may be distributed under the terms of the GNU LGPLv3 license. + #include "byteorder.h" // le32_to_cpu #include "config.h" // CONFIG_* #include "hw/pci.h" // pci_config_writeb @@ -256,6 +264,7 @@ find_acpi_features(void) void *p = fadt; acpi_set_reset_reg(p + 116, *(u8 *)(p + 128)); } + acpi_dsdt_parse(); } diff --git a/src/fw/dsdt_parser.c b/src/fw/dsdt_parser.c new file mode 100644 index 000000000000..87c1a3ac3a00 --- /dev/null +++ b/src/fw/dsdt_parser.c @@ -0,0 +1,668 @@ +// Support for parsing dsdt acpi tables +// +// Copyright (C) 2008,2009 Kevin O'Connor <kevin@koconnor.net> +// +// This file may be distributed under the terms of the GNU LGPLv3 license. + +#include "config.h" // CONFIG_* +#include "list.h" // hlist_* +#include "malloc.h" // malloc_* +#include "output.h" // dprintf +#include "string.h" // memcpy +#include "util.h" +#include "std/acpi.h" // struct rsdp_descriptor + +/**************************************************************** + * DSDT parser + ****************************************************************/ + +struct acpi_device { + struct hlist_node node; + char name[16]; + u8 *hid_aml; + u8 *sta_aml; + u8 *crs_data; + int crs_size; +}; +static struct hlist_head acpi_devices VARVERIFY32INIT; +static const int parse_dumpdevs = 0; + +struct parse_state { + char name[32]; + struct acpi_device *dev; + int error; + int depth; +}; + +static void parse_termlist(struct parse_state *s, + u8 *ptr, int offset, int pkglength); + +static void hex(const u8 *ptr, int count, int lvl, const char *item) +{ + int l = 0, i; + + do { + dprintf(lvl, "%s: %04x: ", item, l); + for (i = l; i < l+16; i += 4) + dprintf(lvl, "%02x %02x %02x %02x ", + ptr[i+0], ptr[i+1], ptr[i+2], ptr[i+3]); + for (i = l; i < l+16; i++) + dprintf(lvl, "%c", (ptr[i] > 0x20 && ptr[i] < 0x80) + ? ptr[i] : '.'); + dprintf(lvl, "\n"); + l += 16; + } while (l < count); +} + +static u64 parse_resource_int(u8 *ptr, int count) +{ + u64 value = 0; + int index = 0; + + for (index = 0; index < count; index++) + value |= (u64)ptr[index] << (index * 8); + return value; +} + +static int parse_resource_bit(u8 *ptr, int count) +{ + int bit; + + for (bit = 0; bit < count*8; bit++) + if (ptr[bit/8] & (1 << (bit%8))) + return bit; + return 0; +} + +static int parse_resource(u8 *ptr, int length, int *type, u64 *min, u64 *max) +{ + int rname, rsize; + u64 len; + + *type = -1; + *min = 0; + *max = 0; + len = 0; + if (!(ptr[0] & 0x80)) { + /* small resource */ + rname = (ptr[0] >> 3) & 0x0f; + rsize = ptr[0] & 0x07; + rsize++; + switch (rname) { + case 0x04: /* irq */ + *min = parse_resource_bit(ptr + 1, rsize); + *max = *min; + *type = 3; + break; + case 0x0f: /* end marker */ + return 0; + case 0x08: /* io */ + *min = parse_resource_int(ptr + 2, 2); + *max = parse_resource_int(ptr + 4, 2); + if (*min == *max) { + *max = *min + ptr[7] - 1; + *type = 1; + } + break; + case 0x09: /* fixed io */ + *min = parse_resource_int(ptr + 2, 2); + *max = *min + ptr[4] - 1; + *type = 1; + break; + default: + dprintf(3, "%s: small: 0x%x (len %d)\n", + __func__, rname, rsize); + break; + } + } else { + /* large resource */ + rname = ptr[0] & 0x7f; + rsize = ptr[2] << 8 | ptr[1]; + rsize += 3; + switch (rname) { + case 0x06: /* 32-bit Fixed Location Memory Range Descriptor */ + *min = parse_resource_int(ptr + 4, 4); + len = parse_resource_int(ptr + 8, 4); + *max = *min + len - 1; + *type = 0; + break; + case 0x07: /* DWORD Address Space Descriptor */ + *min = parse_resource_int(ptr + 10, 4); + *max = parse_resource_int(ptr + 14, 4); + *type = ptr[3]; + break; + case 0x08: /* WORD Address Space Descriptor */ + *min = parse_resource_int(ptr + 8, 2); + *max = parse_resource_int(ptr + 10, 2); + *type = ptr[3]; + break; + case 0x09: /* irq */ + *min = parse_resource_int(ptr + 5, 4); + *max = *min; + *type = 3; + break; + case 0x0a: /* QWORD Address Space Descriptor */ + *min = parse_resource_int(ptr + 14, 8); + *max = parse_resource_int(ptr + 22, 8); + *type = ptr[3]; + break; + default: + dprintf(3, "%s: large: 0x%x (len %d)\n", __func__, rname, rsize); + break; + } + } + return rsize; +} + +static int find_resource(u8 *ptr, int len, int kind, u64 *min, u64 *max) +{ + int type, size, offset = 0; + + do { + size = parse_resource(ptr + offset, len - offset, + &type, min, max); + if (kind == type) + return 0; + offset += size; + } while (size > 0 && offset < len); + return -1; +} + +static int print_resources(const char *prefix, u8 *ptr, int len) +{ + static const char *typename[] = { "mem", "i/o", "bus" }; + int type, size, offset = 0; + u64 min, max; + + do { + size = parse_resource(ptr + offset, len - offset, + &type, &min, &max); + switch (type) { + case 0: + case 1: + case 2: + dprintf(1, "%s%s 0x%llx -> 0x%llx\n", + prefix, typename[type], min, max); + break; + case 3: + dprintf(1, "%sirq %lld\n", prefix, min); + break; + } + offset += size; + } while (size > 0 && offset < len); + return -1; +} + +static int parse_nameseg(u8 *ptr, char **dst) +{ + if (dst && *dst) { + *(dst[0]++) = ptr[0]; + if (ptr[1] != '_') + *(dst[0]++) = ptr[1]; + if (ptr[2] != '_') + *(dst[0]++) = ptr[2]; + if (ptr[3] != '_') + *(dst[0]++) = ptr[3]; + *(dst[0]) = 0; + } + return 4; +} + +static int parse_namestring(struct parse_state *s, + u8 *ptr, const char *item) +{ + char *dst = s->name; + int offset = 0; + int i, count; + + for (;;) { + switch (ptr[offset]) { + case 0: /* null name */ + offset++; + *(dst++) = 0; + break; + case 0x2e: + offset++; + offset += parse_nameseg(ptr + offset, &dst); + *(dst++) = '.'; + offset += parse_nameseg(ptr + offset, &dst); + break; + case 0x2f: + offset++; + count = ptr[offset]; + offset++; + for (i = 0; i < count; i++) { + if (i) + *(dst++) = '.'; + offset += parse_nameseg(ptr + offset, &dst); + } + break; + case '\\': + *(dst++) = '\\'; + offset++; + continue; + case '^': + *(dst++) = '^'; + offset++; + continue; + case 'A' ... 'Z': + case '_': + offset += parse_nameseg(ptr, &dst); + break; + default: + hex(ptr, 16, 3, __func__); + s->error = 1; + break; + } + break; + } + dprintf(5, "%s: %d %s '%s'\n", __func__, s->depth, + item, s->name); + return offset; +} + +static int parse_termarg_int(u8 *ptr, int *error, u64 *dst) +{ + u64 value; + int offset = 1; + + switch (ptr[0]) { + case 0x00: /* zero */ + value = 0; + break; + case 0x01: /* one */ + value = 1; + break; + case 0x0a: /* byte prefix */ + value = ptr[1]; + offset++; + break; + case 0x0b: /* word prefix */ + value = ptr[1] | + ((unsigned long)ptr[2] << 8); + offset += 2; + break; + case 0x0c: /* dword prefix */ + value = ptr[1] | + ((unsigned long)ptr[2] << 8) | + ((unsigned long)ptr[3] << 16) | + ((unsigned long)ptr[4] << 24); + offset += 4; + break; + default: + value = 0; + hex(ptr, 16, 3, __func__); + if (error) + *error = 1; + break; + } + + if (dst) + *dst = value; + dprintf(5, "%s: 0x%llx\n", __func__, value); + return offset; +} + +static int parse_pkglength(u8 *ptr, int *pkglength) +{ + int offset = 2; + + *pkglength = 0; + switch (ptr[0] >> 6) { + case 3: + *pkglength |= ptr[3] << 20; + offset++; + case 2: + *pkglength |= ptr[2] << 12; + offset++; + case 1: + *pkglength |= ptr[1] << 4; + *pkglength |= ptr[0] & 0x0f; + return offset; + case 0: + default: + *pkglength |= ptr[0] & 0x3f; + return 1; + } +} + +static int parse_pkg_common(struct parse_state *s, + u8 *ptr, const char *item, int *pkglength) +{ + int offset; + + offset = parse_pkglength(ptr, pkglength); + offset += parse_namestring(s, ptr + offset, item); + return offset; +} + +static int parse_pkg_scope(struct parse_state *s, + u8 *ptr) +{ + int offset, pkglength; + + offset = parse_pkg_common(s, ptr, "scope", &pkglength); + parse_termlist(s, ptr, offset, pkglength); + return pkglength; +} + +static int parse_pkg_device(struct parse_state *s, + u8 *ptr) +{ + int offset, pkglength; + + offset = parse_pkg_common(s, ptr, "device", &pkglength); + + s->dev = malloc_tmp(sizeof(struct acpi_device)); + if (!s->dev) { + warn_noalloc(); + s->error = 1; + return pkglength; + } + + memset(s->dev, 0, sizeof(struct acpi_device)); + hlist_add_head(&s->dev->node, &acpi_devices); + strtcpy(s->dev->name, s->name, sizeof(s->name)); + parse_termlist(s, ptr, offset, pkglength); + s->dev = NULL; + + return pkglength; +} + +static int parse_pkg_buffer(struct parse_state *s, + u8 *ptr) +{ + u64 blen; + int pkglength, offset; + + offset = parse_pkglength(ptr, &pkglength); + offset += parse_termarg_int(ptr + offset, &s->error, &blen); + if (s->dev && strcmp(s->name, "_CRS") == 0) { + s->dev->crs_data = ptr + offset; + s->dev->crs_size = blen; + } + return pkglength; +} + +static int parse_pkg_skip(struct parse_state *s, + u8 *ptr, int op, int name) +{ + int pkglength, offset; + char item[8]; + + snprintf(item, sizeof(item), "op %x", op); + offset = parse_pkglength(ptr, &pkglength); + if (name) { + parse_namestring(s, ptr + offset, item); + } else { + dprintf(5, "%s: %s (%d)\n", __func__, item, pkglength); + } + return pkglength; +} + +static int parse_termobj(struct parse_state *s, + u8 *ptr) +{ + int offset = 1; + + if (s->depth == 16) { + dprintf(1, "%s: deep recursion\n", __func__); + s->error = 1; + return offset; + } + + s->depth++; + switch (ptr[0]) { + case 0x00: /* zero */ + break; + case 0x01: /* one */ + break; + case 0x08: /* name op */ + offset += parse_namestring(s, ptr + offset, "name"); + offset += parse_termobj(s, ptr + offset); + if (s->dev && strcmp(s->name, "_HID") == 0) + s->dev->hid_aml = ptr; + if (s->dev && strcmp(s->name, "_STA") == 0) + s->dev->sta_aml = ptr; + break; + case 0x0a: /* byte prefix */ + offset++; + break; + case 0x0b: /* word prefix */ + offset += 2; + break; + case 0x0c: /* dword prefix */ + offset += 4; + break; + case 0x0d: /* string prefix */ + while (ptr[offset]) + offset++; + offset++; + break; + case 0x10: /* scope op */ + offset += parse_pkg_scope(s, ptr + offset); + break; + case 0x11: /* buffer op */ + offset += parse_pkg_buffer(s, ptr + offset); + break; + case 0x12: /* package op */ + case 0x13: /* var package op */ + offset += parse_pkg_skip(s, ptr + offset, ptr[0], 0); + break; + case 0x14: /* method op */ + offset += parse_pkg_skip(s, ptr + offset, ptr[0], 1); + if (s->dev && strcmp(s->name, "_STA") == 0) + s->dev->sta_aml = ptr; + break; + case 0x5b: /* ext op prefix */ + offset++; + switch (ptr[1]) { + case 0x01: /* mutex op */ + offset += parse_namestring(s, ptr + offset, "mutex"); + offset++; /* sync flags */ + break; + case 0x80: /* op region op */ + offset += parse_namestring(s, ptr + offset, "op region"); + offset++; /* region space */ + offset += parse_termarg_int(ptr + offset, &s->error, NULL); + offset += parse_termarg_int(ptr + offset, &s->error, NULL); + break; + case 0x81: /* field op */ + case 0x83: /* processor op */ + case 0x84: /* power resource op */ + case 0x85: /* thermal zone op */ + offset += parse_pkg_skip(s, ptr + offset, 0x5b00 | ptr[1], 1); + break; + case 0x82: /* device op */ + offset += parse_pkg_device(s, ptr + offset); + break; + default: + hex(ptr, 16, 3, __func__); + s->error = 1; + break; + } + break; + default: + hex(ptr, 16, 3, __func__); + s->error = 1; + break; + } + s->depth--; + + return offset; +} + +static void parse_termlist(struct parse_state *s, + u8 *ptr, int offset, int pkglength) +{ + for (;;) { + offset += parse_termobj(s, ptr + offset); + if (offset == pkglength) + return; + if (offset > pkglength) { + dprintf(1, "%s: overrun: %d/%d\n", __func__, + offset, pkglength); + s->error = 1; + return; + } + if (s->error) { + dprintf(1, "%s: parse error, skip from %d/%d\n", __func__, + offset, pkglength); + s->error = 0; + return; + } + } +} + +static struct acpi_device *acpi_dsdt_find(struct acpi_device *prev, + const u8 *aml, int size) +{ + struct acpi_device *dev; + struct hlist_node *node; + + if (!prev) + node = acpi_devices.first; + else + node = prev->node.next; + + for (; node != NULL; node = dev->node.next) { + dev = container_of(node, struct acpi_device, node); + if (!aml) + return dev; + if (!dev->hid_aml) + continue; + if (memcmp(dev->hid_aml + 5, aml, size) == 0) + return dev; + } + return NULL; +} + +static int acpi_dsdt_present(struct acpi_device *dev) +{ + if (!dev) + return 0; /* no */ + if (!dev->sta_aml) + return 1; /* yes */ + if (dev->sta_aml[0] == 0x14) + return -1; /* unknown (can't evaluate method) */ + if (dev->sta_aml[0] == 0x08) { + u64 value = 0; + parse_termarg_int(dev->sta_aml + 5, NULL, &value); + if (value == 0) + return 0; /* no */ + else + return 1; /* yes */ + } + return -1; /* unknown (should not happen) */ +} + +/**************************************************************** + * DSDT parser, public interface + ****************************************************************/ + +struct acpi_device *acpi_dsdt_find_string(struct acpi_device *prev, + const char *hid) +{ + if (!CONFIG_ACPI_PARSE) + return NULL; + + u8 aml[10]; + int len = snprintf((char*)aml, sizeof(aml), "\x0d%s", hid); + return acpi_dsdt_find(prev, aml, len); +} + +struct acpi_device *acpi_dsdt_find_eisaid(struct acpi_device *prev, u16 eisaid) +{ + if (!CONFIG_ACPI_PARSE) + return NULL; + u8 aml[] = { + 0x0c, 0x41, 0xd0, + eisaid >> 8, + eisaid & 0xff + }; + return acpi_dsdt_find(prev, aml, 5); +} + +char *acpi_dsdt_name(struct acpi_device *dev) +{ + if (!CONFIG_ACPI_PARSE || !dev) + return NULL; + return dev->name; +} + +int acpi_dsdt_find_io(struct acpi_device *dev, u64 *min, u64 *max) +{ + if (!CONFIG_ACPI_PARSE || !dev || !dev->crs_data) + return -1; + return find_resource(dev->crs_data, dev->crs_size, + 1 /* I/O */, min, max); +} + +int acpi_dsdt_find_mem(struct acpi_device *dev, u64 *min, u64 *max) +{ + if (!CONFIG_ACPI_PARSE || !dev || !dev->crs_data) + return -1; + return find_resource(dev->crs_data, dev->crs_size, + 0 /* mem */, min, max); +} + +int acpi_dsdt_find_irq(struct acpi_device *dev, u64 *irq) +{ + u64 max; + if (!CONFIG_ACPI_PARSE || !dev || !dev->crs_data) + return -1; + return find_resource(dev->crs_data, dev->crs_size, + 3 /* irq */, irq, &max); +} + +int acpi_dsdt_present_eisaid(u16 eisaid) +{ + if (!CONFIG_ACPI_PARSE) + return -1; /* unknown */ + if (hlist_empty(&acpi_devices)) + return -1; /* unknown (no dsdt table) */ + + struct acpi_device *dev = acpi_dsdt_find_eisaid(NULL, eisaid); + return acpi_dsdt_present(dev); +} + +void acpi_dsdt_parse(void) +{ + if (!CONFIG_ACPI_PARSE) + return; + + struct fadt_descriptor_rev1 *fadt = find_acpi_table(FACP_SIGNATURE); + if (!fadt) + return; + u8 *dsdt = (void*)(fadt->dsdt); + if (!dsdt) + return; + + u32 length = *(u32*)(dsdt + 4); + u32 offset = 0x24; + dprintf(1, "ACPI: parse DSDT at %p (len %d)\n", dsdt, length); + + struct parse_state s; + memset(&s, 0, sizeof(s)); + parse_termlist(&s, dsdt, offset, length); + + if (!parse_dumpdevs) + return; + + struct acpi_device *dev; + dprintf(1, "ACPI: dumping dsdt devices\n"); + for (dev = acpi_dsdt_find(NULL, NULL, 0); + dev != NULL; + dev = acpi_dsdt_find(dev, NULL, 0)) { + dprintf(1, " %s", acpi_dsdt_name(dev)); + if (dev->hid_aml) + dprintf(1, ", hid"); + if (dev->sta_aml) + dprintf(1, ", sta (0x%x)", dev->sta_aml[0]); + if (dev->crs_data) + dprintf(1, ", crs"); + dprintf(1, "\n"); + if (dev->crs_data) + print_resources(" ", dev->crs_data, dev->crs_size); + } +} diff --git a/src/fw/paravirt.c b/src/fw/paravirt.c index 119280c574fd..9247288a28c3 100644 --- a/src/fw/paravirt.c +++ b/src/fw/paravirt.c @@ -233,9 +233,10 @@ qemu_platform_setup(void) RsdpAddr = find_acpi_rsdp(); - if (RsdpAddr) + if (RsdpAddr) { + acpi_dsdt_parse(); return; - + } /* If present, loader should have installed an RSDP. * Not installed? We might still be able to continue * using the builtin RSDP. diff --git a/src/Kconfig b/src/Kconfig index 6606ce4d46c9..3a8ffa15fded 100644 --- a/src/Kconfig +++ b/src/Kconfig @@ -524,6 +524,13 @@ menu "BIOS Tables" This option can be disabled for QEMU 1.6 and older to save some space in the ROM file. If unsure, say Y. + config ACPI_PARSE + bool "Include ACPI DSDT parser." + default y + help + Support parsing ACPI DSDT for device probing. + Needed to find virtio-mmio devices. + If unsure, say Y. endmenu source vgasrc/Kconfig -- 2.18.2

Seach for virtio-mmio devices in the DSDT table, register the devices found. Signed-off-by: Gerd Hoffmann <kraxel@redhat.com> --- src/hw/virtio-mmio.h | 1 + src/fw/paravirt.c | 2 ++ src/hw/virtio-mmio.c | 20 ++++++++++++++++++++ 3 files changed, 23 insertions(+) diff --git a/src/hw/virtio-mmio.h b/src/hw/virtio-mmio.h index 9e0dae421009..69fbd23c3101 100644 --- a/src/hw/virtio-mmio.h +++ b/src/hw/virtio-mmio.h @@ -70,6 +70,7 @@ typedef struct virtio_mmio_cfg { u32 config_generation; } virtio_mmio_cfg; +void virtio_mmio_setup_acpi(void); void virtio_mmio_setup_one(u64 mmio); void vp_init_mmio(struct vp_device *vp, void *mmio); diff --git a/src/fw/paravirt.c b/src/fw/paravirt.c index 9247288a28c3..e446569345c1 100644 --- a/src/fw/paravirt.c +++ b/src/fw/paravirt.c @@ -16,6 +16,7 @@ #include "hw/pci_regs.h" // PCI_DEVICE_ID #include "hw/serialio.h" // PORT_SERIAL1 #include "hw/rtc.h" // CMOS_* +#include "hw/virtio-mmio.h" // virtio_mmio_acpi #include "malloc.h" // malloc_tmp #include "output.h" // dprintf #include "paravirt.h" // qemu_cfg_preinit @@ -235,6 +236,7 @@ qemu_platform_setup(void) if (RsdpAddr) { acpi_dsdt_parse(); + virtio_mmio_setup_acpi(); return; } /* If present, loader should have installed an RSDP. diff --git a/src/hw/virtio-mmio.c b/src/hw/virtio-mmio.c index dabef7b7e53a..44344a4993f4 100644 --- a/src/hw/virtio-mmio.c +++ b/src/hw/virtio-mmio.c @@ -3,12 +3,32 @@ #include "output.h" // dprintf #include "stacks.h" // run_thread #include "string.h" // memset +#include "util.h" // acpi_dsdt_* #include "virtio-pci.h" #include "virtio-blk.h" #include "virtio-scsi.h" #include "virtio-ring.h" #include "virtio-mmio.h" +void virtio_mmio_setup_acpi(void) +{ + static const char *virtio_hid = "LNRO0005"; + struct acpi_device *dev; + u64 mem, irq, unused; + + for (dev = acpi_dsdt_find_string(NULL, virtio_hid); + dev != NULL; + dev = acpi_dsdt_find_string(dev, virtio_hid)) { + if (acpi_dsdt_find_mem(dev, &mem, &unused) < 0) + continue; + if (acpi_dsdt_find_irq(dev, &irq) < 0) + continue; + dprintf(1, "ACPI: virtio-mmio device %s at 0x%llx, irq %lld\n", + acpi_dsdt_name(dev), mem, irq); + virtio_mmio_setup_one(mem); + } +} + void virtio_mmio_setup_one(u64 addr) { static const char *names[] = { -- 2.18.2