| /* |
| * |
| * Copyright (c) 2018 Intel Corporation |
| * Copyright (c) 2019 Huawei Technologies R & D (UK) Ltd |
| * Written by Samuel Ortiz, Shameer Kolothum |
| * |
| * This program is free software; you can redistribute it and/or modify it |
| * under the terms and conditions of the GNU General Public License, |
| * version 2 or later, as published by the Free Software Foundation. |
| */ |
| |
| #include "qemu/osdep.h" |
| #include "qapi/error.h" |
| #include "hw/acpi/acpi.h" |
| #include "hw/acpi/generic_event_device.h" |
| #include "hw/irq.h" |
| #include "hw/mem/pc-dimm.h" |
| #include "hw/mem/nvdimm.h" |
| #include "hw/qdev-properties.h" |
| #include "migration/vmstate.h" |
| #include "qemu/error-report.h" |
| #include "sysemu/runstate.h" |
| |
| static const uint32_t ged_supported_events[] = { |
| ACPI_GED_MEM_HOTPLUG_EVT, |
| ACPI_GED_PWR_DOWN_EVT, |
| ACPI_GED_NVDIMM_HOTPLUG_EVT, |
| }; |
| |
| /* |
| * The ACPI Generic Event Device (GED) is a hardware-reduced specific |
| * device[ACPI v6.1 Section 5.6.9] that handles all platform events, |
| * including the hotplug ones. Platforms need to specify their own |
| * GED Event bitmap to describe what kind of events they want to support |
| * through GED. This routine uses a single interrupt for the GED device, |
| * relying on IO memory region to communicate the type of device |
| * affected by the interrupt. This way, we can support up to 32 events |
| * with a unique interrupt. |
| */ |
| void build_ged_aml(Aml *table, const char *name, HotplugHandler *hotplug_dev, |
| uint32_t ged_irq, AmlRegionSpace rs, hwaddr ged_base) |
| { |
| AcpiGedState *s = ACPI_GED(hotplug_dev); |
| Aml *crs = aml_resource_template(); |
| Aml *evt, *field; |
| Aml *dev = aml_device("%s", name); |
| Aml *evt_sel = aml_local(0); |
| Aml *esel = aml_name(AML_GED_EVT_SEL); |
| |
| /* _CRS interrupt */ |
| aml_append(crs, aml_interrupt(AML_CONSUMER, AML_EDGE, AML_ACTIVE_HIGH, |
| AML_EXCLUSIVE, &ged_irq, 1)); |
| |
| aml_append(dev, aml_name_decl("_HID", aml_string("ACPI0013"))); |
| aml_append(dev, aml_name_decl("_UID", aml_string(GED_DEVICE))); |
| aml_append(dev, aml_name_decl("_CRS", crs)); |
| |
| /* Append IO region */ |
| aml_append(dev, aml_operation_region(AML_GED_EVT_REG, rs, |
| aml_int(ged_base + ACPI_GED_EVT_SEL_OFFSET), |
| ACPI_GED_EVT_SEL_LEN)); |
| field = aml_field(AML_GED_EVT_REG, AML_DWORD_ACC, AML_NOLOCK, |
| AML_WRITE_AS_ZEROS); |
| aml_append(field, aml_named_field(AML_GED_EVT_SEL, |
| ACPI_GED_EVT_SEL_LEN * BITS_PER_BYTE)); |
| aml_append(dev, field); |
| |
| /* |
| * For each GED event we: |
| * - Add a conditional block for each event, inside a loop. |
| * - Call a method for each supported GED event type. |
| * |
| * The resulting ASL code looks like: |
| * |
| * Local0 = ESEL |
| * If ((Local0 & One) == One) |
| * { |
| * MethodEvent0() |
| * } |
| * |
| * If ((Local0 & 0x2) == 0x2) |
| * { |
| * MethodEvent1() |
| * } |
| * ... |
| */ |
| evt = aml_method("_EVT", 1, AML_SERIALIZED); |
| { |
| Aml *if_ctx; |
| uint32_t i; |
| uint32_t ged_events = ctpop32(s->ged_event_bitmap); |
| |
| /* Local0 = ESEL */ |
| aml_append(evt, aml_store(esel, evt_sel)); |
| |
| for (i = 0; i < ARRAY_SIZE(ged_supported_events) && ged_events; i++) { |
| uint32_t event = s->ged_event_bitmap & ged_supported_events[i]; |
| |
| if (!event) { |
| continue; |
| } |
| |
| if_ctx = aml_if(aml_equal(aml_and(evt_sel, aml_int(event), NULL), |
| aml_int(event))); |
| switch (event) { |
| case ACPI_GED_MEM_HOTPLUG_EVT: |
| aml_append(if_ctx, aml_call0(MEMORY_DEVICES_CONTAINER "." |
| MEMORY_SLOT_SCAN_METHOD)); |
| break; |
| case ACPI_GED_PWR_DOWN_EVT: |
| aml_append(if_ctx, |
| aml_notify(aml_name(ACPI_POWER_BUTTON_DEVICE), |
| aml_int(0x80))); |
| break; |
| case ACPI_GED_NVDIMM_HOTPLUG_EVT: |
| aml_append(if_ctx, |
| aml_notify(aml_name("\\_SB.NVDR"), |
| aml_int(0x80))); |
| break; |
| default: |
| /* |
| * Please make sure all the events in ged_supported_events[] |
| * are handled above. |
| */ |
| g_assert_not_reached(); |
| } |
| |
| aml_append(evt, if_ctx); |
| ged_events--; |
| } |
| |
| if (ged_events) { |
| error_report("Unsupported events specified"); |
| abort(); |
| } |
| } |
| |
| /* Append _EVT method */ |
| aml_append(dev, evt); |
| |
| aml_append(table, dev); |
| } |
| |
| void acpi_dsdt_add_power_button(Aml *scope) |
| { |
| Aml *dev = aml_device(ACPI_POWER_BUTTON_DEVICE); |
| aml_append(dev, aml_name_decl("_HID", aml_string("PNP0C0C"))); |
| aml_append(dev, aml_name_decl("_UID", aml_int(0))); |
| aml_append(scope, dev); |
| } |
| |
| /* Memory read by the GED _EVT AML dynamic method */ |
| static uint64_t ged_evt_read(void *opaque, hwaddr addr, unsigned size) |
| { |
| uint64_t val = 0; |
| GEDState *ged_st = opaque; |
| |
| switch (addr) { |
| case ACPI_GED_EVT_SEL_OFFSET: |
| /* Read the selector value and reset it */ |
| val = ged_st->sel; |
| ged_st->sel = 0; |
| break; |
| default: |
| break; |
| } |
| |
| return val; |
| } |
| |
| /* Nothing is expected to be written to the GED memory region */ |
| static void ged_evt_write(void *opaque, hwaddr addr, uint64_t data, |
| unsigned int size) |
| { |
| } |
| |
| static const MemoryRegionOps ged_evt_ops = { |
| .read = ged_evt_read, |
| .write = ged_evt_write, |
| .endianness = DEVICE_LITTLE_ENDIAN, |
| .valid = { |
| .min_access_size = 4, |
| .max_access_size = 4, |
| }, |
| }; |
| |
| static uint64_t ged_regs_read(void *opaque, hwaddr addr, unsigned size) |
| { |
| return 0; |
| } |
| |
| static void ged_regs_write(void *opaque, hwaddr addr, uint64_t data, |
| unsigned int size) |
| { |
| bool slp_en; |
| int slp_typ; |
| |
| switch (addr) { |
| case ACPI_GED_REG_SLEEP_CTL: |
| slp_typ = (data >> 2) & 0x07; |
| slp_en = (data >> 5) & 0x01; |
| if (slp_en && slp_typ == 5) { |
| qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN); |
| } |
| return; |
| case ACPI_GED_REG_SLEEP_STS: |
| return; |
| case ACPI_GED_REG_RESET: |
| if (data == ACPI_GED_RESET_VALUE) { |
| qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET); |
| } |
| return; |
| } |
| } |
| |
| static const MemoryRegionOps ged_regs_ops = { |
| .read = ged_regs_read, |
| .write = ged_regs_write, |
| .endianness = DEVICE_LITTLE_ENDIAN, |
| .valid = { |
| .min_access_size = 1, |
| .max_access_size = 1, |
| }, |
| }; |
| |
| static void acpi_ged_device_plug_cb(HotplugHandler *hotplug_dev, |
| DeviceState *dev, Error **errp) |
| { |
| AcpiGedState *s = ACPI_GED(hotplug_dev); |
| |
| if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { |
| if (object_dynamic_cast(OBJECT(dev), TYPE_NVDIMM)) { |
| nvdimm_acpi_plug_cb(hotplug_dev, dev); |
| } else { |
| acpi_memory_plug_cb(hotplug_dev, &s->memhp_state, dev, errp); |
| } |
| } else { |
| error_setg(errp, "virt: device plug request for unsupported device" |
| " type: %s", object_get_typename(OBJECT(dev))); |
| } |
| } |
| |
| static void acpi_ged_unplug_request_cb(HotplugHandler *hotplug_dev, |
| DeviceState *dev, Error **errp) |
| { |
| AcpiGedState *s = ACPI_GED(hotplug_dev); |
| |
| if ((object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) && |
| !(object_dynamic_cast(OBJECT(dev), TYPE_NVDIMM)))) { |
| acpi_memory_unplug_request_cb(hotplug_dev, &s->memhp_state, dev, errp); |
| } else { |
| error_setg(errp, "acpi: device unplug request for unsupported device" |
| " type: %s", object_get_typename(OBJECT(dev))); |
| } |
| } |
| |
| static void acpi_ged_unplug_cb(HotplugHandler *hotplug_dev, |
| DeviceState *dev, Error **errp) |
| { |
| AcpiGedState *s = ACPI_GED(hotplug_dev); |
| |
| if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) { |
| acpi_memory_unplug_cb(&s->memhp_state, dev, errp); |
| } else { |
| error_setg(errp, "acpi: device unplug for unsupported device" |
| " type: %s", object_get_typename(OBJECT(dev))); |
| } |
| } |
| |
| static void acpi_ged_send_event(AcpiDeviceIf *adev, AcpiEventStatusBits ev) |
| { |
| AcpiGedState *s = ACPI_GED(adev); |
| GEDState *ged_st = &s->ged_state; |
| uint32_t sel; |
| |
| if (ev & ACPI_MEMORY_HOTPLUG_STATUS) { |
| sel = ACPI_GED_MEM_HOTPLUG_EVT; |
| } else if (ev & ACPI_POWER_DOWN_STATUS) { |
| sel = ACPI_GED_PWR_DOWN_EVT; |
| } else if (ev & ACPI_NVDIMM_HOTPLUG_STATUS) { |
| sel = ACPI_GED_NVDIMM_HOTPLUG_EVT; |
| } else { |
| /* Unknown event. Return without generating interrupt. */ |
| warn_report("GED: Unsupported event %d. No irq injected", ev); |
| return; |
| } |
| |
| /* |
| * Set the GED selector field to communicate the event type. |
| * This will be read by GED aml code to select the appropriate |
| * event method. |
| */ |
| ged_st->sel |= sel; |
| |
| /* Trigger the event by sending an interrupt to the guest. */ |
| qemu_irq_pulse(s->irq); |
| } |
| |
| static Property acpi_ged_properties[] = { |
| DEFINE_PROP_UINT32("ged-event", AcpiGedState, ged_event_bitmap, 0), |
| DEFINE_PROP_END_OF_LIST(), |
| }; |
| |
| static const VMStateDescription vmstate_memhp_state = { |
| .name = "acpi-ged/memhp", |
| .version_id = 1, |
| .minimum_version_id = 1, |
| .fields = (VMStateField[]) { |
| VMSTATE_MEMORY_HOTPLUG(memhp_state, AcpiGedState), |
| VMSTATE_END_OF_LIST() |
| } |
| }; |
| |
| static const VMStateDescription vmstate_ged_state = { |
| .name = "acpi-ged-state", |
| .version_id = 1, |
| .minimum_version_id = 1, |
| .fields = (VMStateField[]) { |
| VMSTATE_UINT32(sel, GEDState), |
| VMSTATE_END_OF_LIST() |
| } |
| }; |
| |
| static const VMStateDescription vmstate_ghes = { |
| .name = "acpi-ghes", |
| .version_id = 1, |
| .minimum_version_id = 1, |
| .fields = (VMStateField[]) { |
| VMSTATE_UINT64(ghes_addr_le, AcpiGhesState), |
| VMSTATE_END_OF_LIST() |
| }, |
| }; |
| |
| static bool ghes_needed(void *opaque) |
| { |
| AcpiGedState *s = opaque; |
| return s->ghes_state.ghes_addr_le; |
| } |
| |
| static const VMStateDescription vmstate_ghes_state = { |
| .name = "acpi-ged/ghes", |
| .version_id = 1, |
| .minimum_version_id = 1, |
| .needed = ghes_needed, |
| .fields = (VMStateField[]) { |
| VMSTATE_STRUCT(ghes_state, AcpiGedState, 1, |
| vmstate_ghes, AcpiGhesState), |
| VMSTATE_END_OF_LIST() |
| } |
| }; |
| |
| static const VMStateDescription vmstate_acpi_ged = { |
| .name = "acpi-ged", |
| .version_id = 1, |
| .minimum_version_id = 1, |
| .fields = (VMStateField[]) { |
| VMSTATE_STRUCT(ged_state, AcpiGedState, 1, vmstate_ged_state, GEDState), |
| VMSTATE_END_OF_LIST(), |
| }, |
| .subsections = (const VMStateDescription * []) { |
| &vmstate_memhp_state, |
| &vmstate_ghes_state, |
| NULL |
| } |
| }; |
| |
| static void acpi_ged_initfn(Object *obj) |
| { |
| DeviceState *dev = DEVICE(obj); |
| AcpiGedState *s = ACPI_GED(dev); |
| SysBusDevice *sbd = SYS_BUS_DEVICE(obj); |
| GEDState *ged_st = &s->ged_state; |
| |
| memory_region_init_io(&ged_st->evt, obj, &ged_evt_ops, ged_st, |
| TYPE_ACPI_GED, ACPI_GED_EVT_SEL_LEN); |
| sysbus_init_mmio(sbd, &ged_st->evt); |
| |
| sysbus_init_irq(sbd, &s->irq); |
| |
| s->memhp_state.is_enabled = true; |
| /* |
| * GED handles memory hotplug event and acpi-mem-hotplug |
| * memory region gets initialized here. Create an exclusive |
| * container for memory hotplug IO and expose it as GED sysbus |
| * MMIO so that boards can map it separately. |
| */ |
| memory_region_init(&s->container_memhp, OBJECT(dev), "memhp container", |
| MEMORY_HOTPLUG_IO_LEN); |
| sysbus_init_mmio(sbd, &s->container_memhp); |
| acpi_memory_hotplug_init(&s->container_memhp, OBJECT(dev), |
| &s->memhp_state, 0); |
| |
| memory_region_init_io(&ged_st->regs, obj, &ged_regs_ops, ged_st, |
| TYPE_ACPI_GED "-regs", ACPI_GED_REG_COUNT); |
| sysbus_init_mmio(sbd, &ged_st->regs); |
| } |
| |
| static void acpi_ged_class_init(ObjectClass *class, void *data) |
| { |
| DeviceClass *dc = DEVICE_CLASS(class); |
| HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(class); |
| AcpiDeviceIfClass *adevc = ACPI_DEVICE_IF_CLASS(class); |
| |
| dc->desc = "ACPI Generic Event Device"; |
| device_class_set_props(dc, acpi_ged_properties); |
| dc->vmsd = &vmstate_acpi_ged; |
| |
| hc->plug = acpi_ged_device_plug_cb; |
| hc->unplug_request = acpi_ged_unplug_request_cb; |
| hc->unplug = acpi_ged_unplug_cb; |
| |
| adevc->send_event = acpi_ged_send_event; |
| } |
| |
| static const TypeInfo acpi_ged_info = { |
| .name = TYPE_ACPI_GED, |
| .parent = TYPE_SYS_BUS_DEVICE, |
| .instance_size = sizeof(AcpiGedState), |
| .instance_init = acpi_ged_initfn, |
| .class_init = acpi_ged_class_init, |
| .interfaces = (InterfaceInfo[]) { |
| { TYPE_HOTPLUG_HANDLER }, |
| { TYPE_ACPI_DEVICE_IF }, |
| { } |
| } |
| }; |
| |
| static void acpi_ged_register_types(void) |
| { |
| type_register_static(&acpi_ged_info); |
| } |
| |
| type_init(acpi_ged_register_types) |
