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) 442