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 "hw/acpi/acpi.h"
  15 #include "hw/acpi/generic_event_device.h"
  16 #include "hw/irq.h"
  17 #include "hw/mem/pc-dimm.h"
  18 #include "hw/mem/nvdimm.h"
  19 #include "hw/qdev-properties.h"
  20 #include "migration/vmstate.h"
  21 #include "qemu/error-report.h"
  22 #include "sysemu/runstate.h"
  23
  24 static const uint32_t ged_supported_events[] = {
  25     ACPI_GED_MEM_HOTPLUG_EVT,
  26     ACPI_GED_PWR_DOWN_EVT,
  27     ACPI_GED_NVDIMM_HOTPLUG_EVT,
  28 };
  29
  30 /*
  31  * The ACPI Generic Event Device (GED) is a hardware-reduced specific
  32  * device[ACPI v6.1 Section 5.6.9] that handles all platform events,
  33  * including the hotplug ones. Platforms need to specify their own
  34  * GED Event bitmap to describe what kind of events they want to support
  35  * through GED. This routine uses a single interrupt for the GED device,
  36  * relying on IO memory region to communicate the type of device
  37  * affected by the interrupt. This way, we can support up to 32 events
  38  * with a unique interrupt.
  39  */
  40 void build_ged_aml(Aml *table, const char *name, HotplugHandler *hotplug_dev,
  41                    uint32_t ged_irq, AmlRegionSpace rs, hwaddr ged_base)
  42 {
  43     AcpiGedState *s = ACPI_GED(hotplug_dev);
  44     Aml *crs = aml_resource_template();
  45     Aml *evt, *field;
  46     Aml *dev = aml_device("%s", name);
  47     Aml *evt_sel = aml_local(0);
  48     Aml *esel = aml_name(AML_GED_EVT_SEL);
  49
  50     /* _CRS interrupt */
  51     aml_append(crs, aml_interrupt(AML_CONSUMER, AML_EDGE, AML_ACTIVE_HIGH,
  52                                   AML_EXCLUSIVE, &ged_irq, 1));
  53
  54     aml_append(dev, aml_name_decl("_HID", aml_string("ACPI0013")));
  55     aml_append(dev, aml_name_decl("_UID", aml_string(GED_DEVICE)));
  56     aml_append(dev, aml_name_decl("_CRS", crs));
  57
  58     /* Append IO region */
  59     aml_append(dev, aml_operation_region(AML_GED_EVT_REG, rs,
  60                aml_int(ged_base + ACPI_GED_EVT_SEL_OFFSET),
  61                ACPI_GED_EVT_SEL_LEN));
  62     field = aml_field(AML_GED_EVT_REG, AML_DWORD_ACC, AML_NOLOCK,
  63                       AML_WRITE_AS_ZEROS);
  64     aml_append(field, aml_named_field(AML_GED_EVT_SEL,
  65                                       ACPI_GED_EVT_SEL_LEN * BITS_PER_BYTE));
  66     aml_append(dev, field);
  67
  68     /*
  69      * For each GED event we:
  70      * - Add a conditional block for each event, inside a loop.
  71      * - Call a method for each supported GED event type.
  72      *
  73      * The resulting ASL code looks like:
  74      *
  75      * Local0 = ESEL
  76      * If ((Local0 & One) == One)
  77      * {
  78      *     MethodEvent0()
  79      * }
  80      *
  81      * If ((Local0 & 0x2) == 0x2)
  82      * {
  83      *     MethodEvent1()
  84      * }
  85      * ...
  86      */
  87     evt = aml_method("_EVT", 1, AML_SERIALIZED);
  88     {
  89         Aml *if_ctx;
  90         uint32_t i;
  91         uint32_t ged_events = ctpop32(s->ged_event_bitmap);
  92
  93         /* Local0 = ESEL */
  94         aml_append(evt, aml_store(esel, evt_sel));
  95
  96         for (i = 0; i < ARRAY_SIZE(ged_supported_events) && ged_events; i++) {
  97             uint32_t event = s->ged_event_bitmap & ged_supported_events[i];
  98
  99             if (!event) {
 100                 continue;
 101             }
 102
 103             if_ctx = aml_if(aml_equal(aml_and(evt_sel, aml_int(event), NULL),
 104                                       aml_int(event)));
 105             switch (event) {
 106             case ACPI_GED_MEM_HOTPLUG_EVT:
 107                 aml_append(if_ctx, aml_call0(MEMORY_DEVICES_CONTAINER "."
 108                                              MEMORY_SLOT_SCAN_METHOD));
 109                 break;
 110             case ACPI_GED_PWR_DOWN_EVT:
 111                 aml_append(if_ctx,
 112                            aml_notify(aml_name(ACPI_POWER_BUTTON_DEVICE),
 113                                       aml_int(0x80)));
 114                 break;
 115             case ACPI_GED_NVDIMM_HOTPLUG_EVT:
 116                 aml_append(if_ctx,
 117                            aml_notify(aml_name("\\_SB.NVDR"),
 118                                       aml_int(0x80)));
 119                 break;
 120             default:
 121                 /*
 122                  * Please make sure all the events in ged_supported_events[]
 123                  * are handled above.
 124                  */
 125                 g_assert_not_reached();
 126             }
 127
 128             aml_append(evt, if_ctx);
 129             ged_events--;
 130         }
 131
 132         if (ged_events) {
 133             error_report("Unsupported events specified");
 134             abort();
 135         }
 136     }
 137
 138     /* Append _EVT method */
 139     aml_append(dev, evt);
 140
 141     aml_append(table, dev);
 142 }
 143
 144 void acpi_dsdt_add_power_button(Aml *scope)
 145 {
 146     Aml *dev = aml_device(ACPI_POWER_BUTTON_DEVICE);
 147     aml_append(dev, aml_name_decl("_HID", aml_string("PNP0C0C")));
 148     aml_append(dev, aml_name_decl("_UID", aml_int(0)));
 149     aml_append(scope, dev);
 150 }
 151
 152 /* Memory read by the GED _EVT AML dynamic method */
 153 static uint64_t ged_evt_read(void *opaque, hwaddr addr, unsigned size)
 154 {
 155     uint64_t val = 0;
 156     GEDState *ged_st = opaque;
 157
 158     switch (addr) {
 159     case ACPI_GED_EVT_SEL_OFFSET:
 160         /* Read the selector value and reset it */
 161         val = ged_st->sel;
 162         ged_st->sel = 0;
 163         break;
 164     default:
 165         break;
 166     }
 167
 168     return val;
 169 }
 170
 171 /* Nothing is expected to be written to the GED memory region */
 172 static void ged_evt_write(void *opaque, hwaddr addr, uint64_t data,
 173                           unsigned int size)
 174 {
 175 }
 176
 177 static const MemoryRegionOps ged_evt_ops = {
 178     .read = ged_evt_read,
 179     .write = ged_evt_write,
 180     .endianness = DEVICE_LITTLE_ENDIAN,
 181     .valid = {
 182         .min_access_size = 4,
 183         .max_access_size = 4,
 184     },
 185 };
 186
 187 static uint64_t ged_regs_read(void *opaque, hwaddr addr, unsigned size)
 188 {
 189     return 0;
 190 }
 191
 192 static void ged_regs_write(void *opaque, hwaddr addr, uint64_t data,
 193                            unsigned int size)
 194 {
 195     bool slp_en;
 196     int slp_typ;
 197
 198     switch (addr) {
 199     case ACPI_GED_REG_SLEEP_CTL:
 200         slp_typ = (data >> 2) & 0x07;
 201         slp_en  = (data >> 5) & 0x01;
 202         if (slp_en && slp_typ == 5) {
 203             qemu_system_shutdown_request(SHUTDOWN_CAUSE_GUEST_SHUTDOWN);
 204         }
 205         return;
 206     case ACPI_GED_REG_SLEEP_STS:
 207         return;
 208     case ACPI_GED_REG_RESET:
 209         if (data == ACPI_GED_RESET_VALUE) {
 210             qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET);
 211         }
 212         return;
 213     }
 214 }
 215
 216 static const MemoryRegionOps ged_regs_ops = {
 217     .read = ged_regs_read,
 218     .write = ged_regs_write,
 219     .endianness = DEVICE_LITTLE_ENDIAN,
 220     .valid = {
 221         .min_access_size = 1,
 222         .max_access_size = 1,
 223     },
 224 };
 225
 226 static void acpi_ged_device_plug_cb(HotplugHandler *hotplug_dev,
 227                                     DeviceState *dev, Error **errp)
 228 {
 229     AcpiGedState *s = ACPI_GED(hotplug_dev);
 230
 231     if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) {
 232         if (object_dynamic_cast(OBJECT(dev), TYPE_NVDIMM)) {
 233             nvdimm_acpi_plug_cb(hotplug_dev, dev);
 234         } else {
 235             acpi_memory_plug_cb(hotplug_dev, &s->memhp_state, dev, errp);
 236         }
 237     } else {
 238         error_setg(errp, "virt: device plug request for unsupported device"
 239                    " type: %s", object_get_typename(OBJECT(dev)));
 240     }
 241 }
 242
 243 static void acpi_ged_unplug_request_cb(HotplugHandler *hotplug_dev,
 244                                        DeviceState *dev, Error **errp)
 245 {
 246     AcpiGedState *s = ACPI_GED(hotplug_dev);
 247
 248     if ((object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) &&
 249                        !(object_dynamic_cast(OBJECT(dev), TYPE_NVDIMM)))) {
 250         acpi_memory_unplug_request_cb(hotplug_dev, &s->memhp_state, dev, errp);
 251     } else {
 252         error_setg(errp, "acpi: device unplug request for unsupported device"
 253                    " type: %s", object_get_typename(OBJECT(dev)));
 254     }
 255 }
 256
 257 static void acpi_ged_unplug_cb(HotplugHandler *hotplug_dev,
 258                                DeviceState *dev, Error **errp)
 259 {
 260     AcpiGedState *s = ACPI_GED(hotplug_dev);
 261
 262     if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) {
 263         acpi_memory_unplug_cb(&s->memhp_state, dev, errp);
 264     } else {
 265         error_setg(errp, "acpi: device unplug for unsupported device"
 266                    " type: %s", object_get_typename(OBJECT(dev)));
 267     }
 268 }
 269
 270 static void acpi_ged_ospm_status(AcpiDeviceIf *adev, ACPIOSTInfoList ***list)
 271 {
 272     AcpiGedState *s = ACPI_GED(adev);
 273
 274     acpi_memory_ospm_status(&s->memhp_state, list);
 275 }
 276
 277 static void acpi_ged_send_event(AcpiDeviceIf *adev, AcpiEventStatusBits ev)
 278 {
 279     AcpiGedState *s = ACPI_GED(adev);
 280     GEDState *ged_st = &s->ged_state;
 281     uint32_t sel;
 282
 283     if (ev & ACPI_MEMORY_HOTPLUG_STATUS) {
 284         sel = ACPI_GED_MEM_HOTPLUG_EVT;
 285     } else if (ev & ACPI_POWER_DOWN_STATUS) {
 286         sel = ACPI_GED_PWR_DOWN_EVT;
 287     } else if (ev & ACPI_NVDIMM_HOTPLUG_STATUS) {
 288         sel = ACPI_GED_NVDIMM_HOTPLUG_EVT;
 289     } else {
 290         /* Unknown event. Return without generating interrupt. */
 291         warn_report("GED: Unsupported event %d. No irq injected", ev);
 292         return;
 293     }
 294
 295     /*
 296      * Set the GED selector field to communicate the event type.
 297      * This will be read by GED aml code to select the appropriate
 298      * event method.
 299      */
 300     ged_st->sel |= sel;
 301
 302     /* Trigger the event by sending an interrupt to the guest. */
 303     qemu_irq_pulse(s->irq);
 304 }
 305
 306 static Property acpi_ged_properties[] = {
 307     DEFINE_PROP_UINT32("ged-event", AcpiGedState, ged_event_bitmap, 0),
 308     DEFINE_PROP_END_OF_LIST(),
 309 };
 310
 311 static const VMStateDescription vmstate_memhp_state = {
 312     .name = "acpi-ged/memhp",
 313     .version_id = 1,
 314     .minimum_version_id = 1,
 315     .fields = (const VMStateField[]) {
 316         VMSTATE_MEMORY_HOTPLUG(memhp_state, AcpiGedState),
 317         VMSTATE_END_OF_LIST()
 318     }
 319 };
 320
 321 static const VMStateDescription vmstate_ged_state = {
 322     .name = "acpi-ged-state",
 323     .version_id = 1,
 324     .minimum_version_id = 1,
 325     .fields = (const VMStateField[]) {
 326         VMSTATE_UINT32(sel, GEDState),
 327         VMSTATE_END_OF_LIST()
 328     }
 329 };
 330
 331 static const VMStateDescription vmstate_ghes = {
 332     .name = "acpi-ghes",
 333     .version_id = 1,
 334     .minimum_version_id = 1,
 335     .fields = (const VMStateField[]) {
 336         VMSTATE_UINT64(ghes_addr_le, AcpiGhesState),
 337         VMSTATE_END_OF_LIST()
 338     },
 339 };
 340
 341 static bool ghes_needed(void *opaque)
 342 {
 343     AcpiGedState *s = opaque;
 344     return s->ghes_state.ghes_addr_le;
 345 }
 346
 347 static const VMStateDescription vmstate_ghes_state = {
 348     .name = "acpi-ged/ghes",
 349     .version_id = 1,
 350     .minimum_version_id = 1,
 351     .needed = ghes_needed,
 352     .fields = (const VMStateField[]) {
 353         VMSTATE_STRUCT(ghes_state, AcpiGedState, 1,
 354                        vmstate_ghes, AcpiGhesState),
 355         VMSTATE_END_OF_LIST()
 356     }
 357 };
 358
 359 static const VMStateDescription vmstate_acpi_ged = {
 360     .name = "acpi-ged",
 361     .version_id = 1,
 362     .minimum_version_id = 1,
 363     .fields = (const VMStateField[]) {
 364         VMSTATE_STRUCT(ged_state, AcpiGedState, 1, vmstate_ged_state, GEDState),
 365         VMSTATE_END_OF_LIST(),
 366     },
 367     .subsections = (const VMStateDescription * const []) {
 368         &vmstate_memhp_state,
 369         &vmstate_ghes_state,
 370         NULL
 371     }
 372 };
 373
 374 static void acpi_ged_initfn(Object *obj)
 375 {
 376     DeviceState *dev = DEVICE(obj);
 377     AcpiGedState *s = ACPI_GED(dev);
 378     SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
 379     GEDState *ged_st = &s->ged_state;
 380
 381     memory_region_init_io(&ged_st->evt, obj, &ged_evt_ops, ged_st,
 382                           TYPE_ACPI_GED, ACPI_GED_EVT_SEL_LEN);
 383     sysbus_init_mmio(sbd, &ged_st->evt);
 384
 385     sysbus_init_irq(sbd, &s->irq);
 386
 387     s->memhp_state.is_enabled = true;
 388     /*
 389      * GED handles memory hotplug event and acpi-mem-hotplug
 390      * memory region gets initialized here. Create an exclusive
 391      * container for memory hotplug IO and expose it as GED sysbus
 392      * MMIO so that boards can map it separately.
 393      */
 394      memory_region_init(&s->container_memhp, OBJECT(dev), "memhp container",
 395                         MEMORY_HOTPLUG_IO_LEN);
 396      sysbus_init_mmio(sbd, &s->container_memhp);
 397      acpi_memory_hotplug_init(&s->container_memhp, OBJECT(dev),
 398                               &s->memhp_state, 0);
 399
 400     memory_region_init_io(&ged_st->regs, obj, &ged_regs_ops, ged_st,
 401                           TYPE_ACPI_GED "-regs", ACPI_GED_REG_COUNT);
 402     sysbus_init_mmio(sbd, &ged_st->regs);
 403 }
 404
 405 static void acpi_ged_class_init(ObjectClass *class, void *data)
 406 {
 407     DeviceClass *dc = DEVICE_CLASS(class);
 408     HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(class);
 409     AcpiDeviceIfClass *adevc = ACPI_DEVICE_IF_CLASS(class);
 410
 411     dc->desc = "ACPI Generic Event Device";
 412     device_class_set_props(dc, acpi_ged_properties);
 413     dc->vmsd = &vmstate_acpi_ged;
 414
 415     hc->plug = acpi_ged_device_plug_cb;
 416     hc->unplug_request = acpi_ged_unplug_request_cb;
 417     hc->unplug = acpi_ged_unplug_cb;
 418
 419     adevc->ospm_status = acpi_ged_ospm_status;
 420     adevc->send_event = acpi_ged_send_event;
 421 }
 422
 423 static const TypeInfo acpi_ged_info = {
 424     .name          = TYPE_ACPI_GED,
 425     .parent        = TYPE_SYS_BUS_DEVICE,
 426     .instance_size = sizeof(AcpiGedState),
 427     .instance_init  = acpi_ged_initfn,
 428     .class_init    = acpi_ged_class_init,
 429     .interfaces = (InterfaceInfo[]) {
 430         { TYPE_HOTPLUG_HANDLER },
 431         { TYPE_ACPI_DEVICE_IF },
 432         { }
 433     }
 434 };
 435
 436 static void acpi_ged_register_types(void)
 437 {
 438     type_register_static(&acpi_ged_info);
 439 }
 440
 441 type_init(acpi_ged_register_types)