hw/acpi/generic_event_device.c

   1 /*
   2  *
   3  * Copyright (c) 2018 Intel Corporation
   4  * Copyright (c) 2019 Huawei Technologies R & D (UK) Ltd
   5  * Written by Samuel Ortiz, Shameer Kolothum
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms and conditions of the GNU General Public License,
   9  * version 2 or later, as published by the Free Software Foundation.
  10  */
  11
  12 #include "qemu/osdep.h"
  13 #include "qapi/error.h"
  14 #include "exec/address-spaces.h"
  15 #include "hw/acpi/acpi.h"
  16 #include "hw/acpi/generic_event_device.h"
  17 #include "hw/irq.h"
  18 #include "hw/mem/pc-dimm.h"
  19 #include "hw/qdev-properties.h"
  20 #include "migration/vmstate.h"
  21 #include "qemu/error-report.h"
  22
  23 static const uint32_t ged_supported_events[] = {
  24     ACPI_GED_MEM_HOTPLUG_EVT,
  25     ACPI_GED_PWR_DOWN_EVT,
  26 };
  27
  28 /*
  29  * The ACPI Generic Event Device (GED) is a hardware-reduced specific
  30  * device[ACPI v6.1 Section 5.6.9] that handles all platform events,
  31  * including the hotplug ones. Platforms need to specify their own
  32  * GED Event bitmap to describe what kind of events they want to support
  33  * through GED. This routine uses a single interrupt for the GED device,
  34  * relying on IO memory region to communicate the type of device
  35  * affected by the interrupt. This way, we can support up to 32 events
  36  * with a unique interrupt.
  37  */
  38 void build_ged_aml(Aml *table, const char *name, HotplugHandler *hotplug_dev,
  39                    uint32_t ged_irq, AmlRegionSpace rs, hwaddr ged_base)
  40 {
  41     AcpiGedState *s = ACPI_GED(hotplug_dev);
  42     Aml *crs = aml_resource_template();
  43     Aml *evt, *field;
  44     Aml *dev = aml_device("%s", name);
  45     Aml *evt_sel = aml_local(0);
  46     Aml *esel = aml_name(AML_GED_EVT_SEL);
  47
  48     /* _CRS interrupt */
  49     aml_append(crs, aml_interrupt(AML_CONSUMER, AML_EDGE, AML_ACTIVE_HIGH,
  50                                   AML_EXCLUSIVE, &ged_irq, 1));
  51
  52     aml_append(dev, aml_name_decl("_HID", aml_string("ACPI0013")));
  53     aml_append(dev, aml_name_decl("_UID", aml_string(GED_DEVICE)));
  54     aml_append(dev, aml_name_decl("_CRS", crs));
  55
  56     /* Append IO region */
  57     aml_append(dev, aml_operation_region(AML_GED_EVT_REG, rs,
  58                aml_int(ged_base + ACPI_GED_EVT_SEL_OFFSET),
  59                ACPI_GED_EVT_SEL_LEN));
  60     field = aml_field(AML_GED_EVT_REG, AML_DWORD_ACC, AML_NOLOCK,
  61                       AML_WRITE_AS_ZEROS);
  62     aml_append(field, aml_named_field(AML_GED_EVT_SEL,
  63                                       ACPI_GED_EVT_SEL_LEN * BITS_PER_BYTE));
  64     aml_append(dev, field);
  65
  66     /*
  67      * For each GED event we:
  68      * - Add a conditional block for each event, inside a loop.
  69      * - Call a method for each supported GED event type.
  70      *
  71      * The resulting ASL code looks like:
  72      *
  73      * Local0 = ESEL
  74      * If ((Local0 & One) == One)
  75      * {
  76      *     MethodEvent0()
  77      * }
  78      *
  79      * If ((Local0 & 0x2) == 0x2)
  80      * {
  81      *     MethodEvent1()
  82      * }
  83      * ...
  84      */
  85     evt = aml_method("_EVT", 1, AML_SERIALIZED);
  86     {
  87         Aml *if_ctx;
  88         uint32_t i;
  89         uint32_t ged_events = ctpop32(s->ged_event_bitmap);
  90
  91         /* Local0 = ESEL */
  92         aml_append(evt, aml_store(esel, evt_sel));
  93
  94         for (i = 0; i < ARRAY_SIZE(ged_supported_events) && ged_events; i++) {
  95             uint32_t event = s->ged_event_bitmap & ged_supported_events[i];
  96
  97             if (!event) {
  98                 continue;
  99             }
 100
 101             if_ctx = aml_if(aml_equal(aml_and(evt_sel, aml_int(event), NULL),
 102                                       aml_int(event)));
 103             switch (event) {
 104             case ACPI_GED_MEM_HOTPLUG_EVT:
 105                 aml_append(if_ctx, aml_call0(MEMORY_DEVICES_CONTAINER "."
 106                                              MEMORY_SLOT_SCAN_METHOD));
 107                 break;
 108             case ACPI_GED_PWR_DOWN_EVT:
 109                 aml_append(if_ctx,
 110                            aml_notify(aml_name(ACPI_POWER_BUTTON_DEVICE),
 111                                       aml_int(0x80)));
 112                 break;
 113             default:
 114                 /*
 115                  * Please make sure all the events in ged_supported_events[]
 116                  * are handled above.
 117                  */
 118                 g_assert_not_reached();
 119             }
 120
 121             aml_append(evt, if_ctx);
 122             ged_events--;
 123         }
 124
 125         if (ged_events) {
 126             error_report("Unsupported events specified");
 127             abort();
 128         }
 129     }
 130
 131     /* Append _EVT method */
 132     aml_append(dev, evt);
 133
 134     aml_append(table, dev);
 135 }
 136
 137 /* Memory read by the GED _EVT AML dynamic method */
 138 static uint64_t ged_read(void *opaque, hwaddr addr, unsigned size)
 139 {
 140     uint64_t val = 0;
 141     GEDState *ged_st = opaque;
 142
 143     switch (addr) {
 144     case ACPI_GED_EVT_SEL_OFFSET:
 145         /* Read the selector value and reset it */
 146         val = ged_st->sel;
 147         ged_st->sel = 0;
 148         break;
 149     default:
 150         break;
 151     }
 152
 153     return val;
 154 }
 155
 156 /* Nothing is expected to be written to the GED memory region */
 157 static void ged_write(void *opaque, hwaddr addr, uint64_t data,
 158                       unsigned int size)
 159 {
 160 }
 161
 162 static const MemoryRegionOps ged_ops = {
 163     .read = ged_read,
 164     .write = ged_write,
 165     .endianness = DEVICE_LITTLE_ENDIAN,
 166     .valid = {
 167         .min_access_size = 4,
 168         .max_access_size = 4,
 169     },
 170 };
 171
 172 static void acpi_ged_device_plug_cb(HotplugHandler *hotplug_dev,
 173                                     DeviceState *dev, Error **errp)
 174 {
 175     AcpiGedState *s = ACPI_GED(hotplug_dev);
 176
 177     if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) {
 178         acpi_memory_plug_cb(hotplug_dev, &s->memhp_state, dev, errp);
 179     } else {
 180         error_setg(errp, "virt: device plug request for unsupported device"
 181                    " type: %s", object_get_typename(OBJECT(dev)));
 182     }
 183 }
 184
 185 static void acpi_ged_send_event(AcpiDeviceIf *adev, AcpiEventStatusBits ev)
 186 {
 187     AcpiGedState *s = ACPI_GED(adev);
 188     GEDState *ged_st = &s->ged_state;
 189     uint32_t sel;
 190
 191     if (ev & ACPI_MEMORY_HOTPLUG_STATUS) {
 192         sel = ACPI_GED_MEM_HOTPLUG_EVT;
 193     } else if (ev & ACPI_POWER_DOWN_STATUS) {
 194         sel = ACPI_GED_PWR_DOWN_EVT;
 195     } else {
 196         /* Unknown event. Return without generating interrupt. */
 197         warn_report("GED: Unsupported event %d. No irq injected", ev);
 198         return;
 199     }
 200
 201     /*
 202      * Set the GED selector field to communicate the event type.
 203      * This will be read by GED aml code to select the appropriate
 204      * event method.
 205      */
 206     ged_st->sel |= sel;
 207
 208     /* Trigger the event by sending an interrupt to the guest. */
 209     qemu_irq_pulse(s->irq);
 210 }
 211
 212 static Property acpi_ged_properties[] = {
 213     DEFINE_PROP_UINT32("ged-event", AcpiGedState, ged_event_bitmap, 0),
 214     DEFINE_PROP_END_OF_LIST(),
 215 };
 216
 217 static const VMStateDescription vmstate_memhp_state = {
 218     .name = "acpi-ged/memhp",
 219     .version_id = 1,
 220     .minimum_version_id = 1,
 221     .fields      = (VMStateField[]) {
 222         VMSTATE_MEMORY_HOTPLUG(memhp_state, AcpiGedState),
 223         VMSTATE_END_OF_LIST()
 224     }
 225 };
 226
 227 static const VMStateDescription vmstate_ged_state = {
 228     .name = "acpi-ged-state",
 229     .version_id = 1,
 230     .minimum_version_id = 1,
 231     .fields      = (VMStateField[]) {
 232         VMSTATE_UINT32(sel, GEDState),
 233         VMSTATE_END_OF_LIST()
 234     }
 235 };
 236
 237 static const VMStateDescription vmstate_acpi_ged = {
 238     .name = "acpi-ged",
 239     .version_id = 1,
 240     .minimum_version_id = 1,
 241     .fields = (VMStateField[]) {
 242         VMSTATE_STRUCT(ged_state, AcpiGedState, 1, vmstate_ged_state, GEDState),
 243         VMSTATE_END_OF_LIST(),
 244     },
 245     .subsections = (const VMStateDescription * []) {
 246         &vmstate_memhp_state,
 247         NULL
 248     }
 249 };
 250
 251 static void acpi_ged_initfn(Object *obj)
 252 {
 253     DeviceState *dev = DEVICE(obj);
 254     AcpiGedState *s = ACPI_GED(dev);
 255     SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
 256     GEDState *ged_st = &s->ged_state;
 257
 258     memory_region_init_io(&ged_st->io, obj, &ged_ops, ged_st,
 259                           TYPE_ACPI_GED, ACPI_GED_EVT_SEL_LEN);
 260     sysbus_init_mmio(sbd, &ged_st->io);
 261
 262     sysbus_init_irq(sbd, &s->irq);
 263
 264     s->memhp_state.is_enabled = true;
 265     /*
 266      * GED handles memory hotplug event and acpi-mem-hotplug
 267      * memory region gets initialized here. Create an exclusive
 268      * container for memory hotplug IO and expose it as GED sysbus
 269      * MMIO so that boards can map it separately.
 270      */
 271      memory_region_init(&s->container_memhp, OBJECT(dev), "memhp container",
 272                         MEMORY_HOTPLUG_IO_LEN);
 273      sysbus_init_mmio(sbd, &s->container_memhp);
 274      acpi_memory_hotplug_init(&s->container_memhp, OBJECT(dev),
 275                               &s->memhp_state, 0);
 276 }
 277
 278 static void acpi_ged_class_init(ObjectClass *class, void *data)
 279 {
 280     DeviceClass *dc = DEVICE_CLASS(class);
 281     HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(class);
 282     AcpiDeviceIfClass *adevc = ACPI_DEVICE_IF_CLASS(class);
 283
 284     dc->desc = "ACPI Generic Event Device";
 285     dc->props = acpi_ged_properties;
 286     dc->vmsd = &vmstate_acpi_ged;
 287
 288     hc->plug = acpi_ged_device_plug_cb;
 289
 290     adevc->send_event = acpi_ged_send_event;
 291 }
 292
 293 static const TypeInfo acpi_ged_info = {
 294     .name          = TYPE_ACPI_GED,
 295     .parent        = TYPE_SYS_BUS_DEVICE,
 296     .instance_size = sizeof(AcpiGedState),
 297     .instance_init  = acpi_ged_initfn,
 298     .class_init    = acpi_ged_class_init,
 299     .interfaces = (InterfaceInfo[]) {
 300         { TYPE_HOTPLUG_HANDLER },
 301         { TYPE_ACPI_DEVICE_IF },
 302         { }
 303     }
 304 };
 305
 306 static void acpi_ged_register_types(void)
 307 {
 308     type_register_static(&acpi_ged_info);
 309 }
 310
 311 type_init(acpi_ged_register_types)