2016-01-26 19:17:03 +01:00
|
|
|
#include "qemu/osdep.h"
|
2014-06-02 15:25:16 +02:00
|
|
|
#include "hw/acpi/memory_hotplug.h"
|
|
|
|
#include "hw/acpi/pc-hotplug.h"
|
|
|
|
#include "hw/mem/pc-dimm.h"
|
|
|
|
#include "hw/boards.h"
|
2015-04-27 10:47:21 +02:00
|
|
|
#include "hw/qdev-core.h"
|
2019-08-12 07:23:45 +02:00
|
|
|
#include "migration/vmstate.h"
|
2014-06-02 15:25:17 +02:00
|
|
|
#include "trace.h"
|
2018-02-01 12:18:31 +01:00
|
|
|
#include "qapi/error.h"
|
2020-09-13 21:53:47 +02:00
|
|
|
#include "qapi/qapi-events-acpi.h"
|
2020-09-13 21:53:46 +02:00
|
|
|
#include "qapi/qapi-events-machine.h"
|
2014-06-02 15:25:16 +02:00
|
|
|
|
2016-12-06 00:32:27 +01:00
|
|
|
#define MEMORY_SLOTS_NUMBER "MDNR"
|
|
|
|
#define MEMORY_HOTPLUG_IO_REGION "HPMR"
|
|
|
|
#define MEMORY_SLOT_ADDR_LOW "MRBL"
|
|
|
|
#define MEMORY_SLOT_ADDR_HIGH "MRBH"
|
|
|
|
#define MEMORY_SLOT_SIZE_LOW "MRLL"
|
|
|
|
#define MEMORY_SLOT_SIZE_HIGH "MRLH"
|
|
|
|
#define MEMORY_SLOT_PROXIMITY "MPX"
|
|
|
|
#define MEMORY_SLOT_ENABLED "MES"
|
|
|
|
#define MEMORY_SLOT_INSERT_EVENT "MINS"
|
|
|
|
#define MEMORY_SLOT_REMOVE_EVENT "MRMV"
|
|
|
|
#define MEMORY_SLOT_EJECT "MEJ"
|
|
|
|
#define MEMORY_SLOT_SLECTOR "MSEL"
|
|
|
|
#define MEMORY_SLOT_OST_EVENT "MOEV"
|
|
|
|
#define MEMORY_SLOT_OST_STATUS "MOSC"
|
|
|
|
#define MEMORY_SLOT_LOCK "MLCK"
|
|
|
|
#define MEMORY_SLOT_STATUS_METHOD "MRST"
|
|
|
|
#define MEMORY_SLOT_CRS_METHOD "MCRS"
|
|
|
|
#define MEMORY_SLOT_OST_METHOD "MOST"
|
|
|
|
#define MEMORY_SLOT_PROXIMITY_METHOD "MPXM"
|
|
|
|
#define MEMORY_SLOT_EJECT_METHOD "MEJ0"
|
|
|
|
#define MEMORY_SLOT_NOTIFY_METHOD "MTFY"
|
|
|
|
#define MEMORY_HOTPLUG_DEVICE "MHPD"
|
|
|
|
|
2014-06-16 19:12:27 +02:00
|
|
|
static ACPIOSTInfo *acpi_memory_device_status(int slot, MemStatus *mdev)
|
|
|
|
{
|
|
|
|
ACPIOSTInfo *info = g_new0(ACPIOSTInfo, 1);
|
|
|
|
|
|
|
|
info->slot_type = ACPI_SLOT_TYPE_DIMM;
|
|
|
|
info->slot = g_strdup_printf("%d", slot);
|
|
|
|
info->source = mdev->ost_event;
|
|
|
|
info->status = mdev->ost_status;
|
|
|
|
if (mdev->dimm) {
|
|
|
|
DeviceState *dev = DEVICE(mdev->dimm);
|
|
|
|
if (dev->id) {
|
|
|
|
info->device = g_strdup(dev->id);
|
|
|
|
info->has_device = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return info;
|
|
|
|
}
|
|
|
|
|
|
|
|
void acpi_memory_ospm_status(MemHotplugState *mem_st, ACPIOSTInfoList ***list)
|
|
|
|
{
|
2021-01-13 23:10:12 +01:00
|
|
|
ACPIOSTInfoList ***tail = list;
|
2014-06-16 19:12:27 +02:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < mem_st->dev_count; i++) {
|
2021-01-13 23:10:12 +01:00
|
|
|
QAPI_LIST_APPEND(*tail,
|
|
|
|
acpi_memory_device_status(i, &mem_st->devs[i]));
|
2014-06-16 19:12:27 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-02 15:25:16 +02:00
|
|
|
static uint64_t acpi_memory_hotplug_read(void *opaque, hwaddr addr,
|
|
|
|
unsigned int size)
|
|
|
|
{
|
|
|
|
uint32_t val = 0;
|
|
|
|
MemHotplugState *mem_st = opaque;
|
|
|
|
MemStatus *mdev;
|
|
|
|
Object *o;
|
|
|
|
|
|
|
|
if (mem_st->selector >= mem_st->dev_count) {
|
2014-06-02 15:25:17 +02:00
|
|
|
trace_mhp_acpi_invalid_slot_selected(mem_st->selector);
|
2014-06-02 15:25:16 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
mdev = &mem_st->devs[mem_st->selector];
|
|
|
|
o = OBJECT(mdev->dimm);
|
|
|
|
switch (addr) {
|
|
|
|
case 0x0: /* Lo part of phys address where DIMM is mapped */
|
2017-06-07 18:36:13 +02:00
|
|
|
val = o ? object_property_get_uint(o, PC_DIMM_ADDR_PROP, NULL) : 0;
|
2014-06-02 15:25:17 +02:00
|
|
|
trace_mhp_acpi_read_addr_lo(mem_st->selector, val);
|
2014-06-02 15:25:16 +02:00
|
|
|
break;
|
|
|
|
case 0x4: /* Hi part of phys address where DIMM is mapped */
|
2017-06-07 18:36:13 +02:00
|
|
|
val =
|
|
|
|
o ? object_property_get_uint(o, PC_DIMM_ADDR_PROP, NULL) >> 32 : 0;
|
2014-06-02 15:25:17 +02:00
|
|
|
trace_mhp_acpi_read_addr_hi(mem_st->selector, val);
|
2014-06-02 15:25:16 +02:00
|
|
|
break;
|
|
|
|
case 0x8: /* Lo part of DIMM size */
|
2017-06-07 18:36:14 +02:00
|
|
|
val = o ? object_property_get_uint(o, PC_DIMM_SIZE_PROP, NULL) : 0;
|
2014-06-02 15:25:17 +02:00
|
|
|
trace_mhp_acpi_read_size_lo(mem_st->selector, val);
|
2014-06-02 15:25:16 +02:00
|
|
|
break;
|
|
|
|
case 0xc: /* Hi part of DIMM size */
|
2017-06-07 18:36:14 +02:00
|
|
|
val =
|
|
|
|
o ? object_property_get_uint(o, PC_DIMM_SIZE_PROP, NULL) >> 32 : 0;
|
2014-06-02 15:25:17 +02:00
|
|
|
trace_mhp_acpi_read_size_hi(mem_st->selector, val);
|
2014-06-02 15:25:16 +02:00
|
|
|
break;
|
|
|
|
case 0x10: /* node proximity for _PXM method */
|
2017-06-07 18:36:13 +02:00
|
|
|
val = o ? object_property_get_uint(o, PC_DIMM_NODE_PROP, NULL) : 0;
|
2014-06-02 15:25:17 +02:00
|
|
|
trace_mhp_acpi_read_pxm(mem_st->selector, val);
|
2014-06-02 15:25:16 +02:00
|
|
|
break;
|
|
|
|
case 0x14: /* pack and return is_* fields */
|
|
|
|
val |= mdev->is_enabled ? 1 : 0;
|
|
|
|
val |= mdev->is_inserting ? 2 : 0;
|
2015-04-27 10:47:17 +02:00
|
|
|
val |= mdev->is_removing ? 4 : 0;
|
2014-06-02 15:25:17 +02:00
|
|
|
trace_mhp_acpi_read_flags(mem_st->selector, val);
|
2014-06-02 15:25:16 +02:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
val = ~0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void acpi_memory_hotplug_write(void *opaque, hwaddr addr, uint64_t data,
|
|
|
|
unsigned int size)
|
|
|
|
{
|
|
|
|
MemHotplugState *mem_st = opaque;
|
|
|
|
MemStatus *mdev;
|
2014-06-23 15:26:57 +02:00
|
|
|
ACPIOSTInfo *info;
|
2015-04-27 10:47:21 +02:00
|
|
|
DeviceState *dev = NULL;
|
|
|
|
HotplugHandler *hotplug_ctrl = NULL;
|
2015-04-27 10:47:22 +02:00
|
|
|
Error *local_err = NULL;
|
2014-06-02 15:25:16 +02:00
|
|
|
|
|
|
|
if (!mem_st->dev_count) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (addr) {
|
|
|
|
if (mem_st->selector >= mem_st->dev_count) {
|
2014-06-02 15:25:17 +02:00
|
|
|
trace_mhp_acpi_invalid_slot_selected(mem_st->selector);
|
2014-06-02 15:25:16 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (addr) {
|
|
|
|
case 0x0: /* DIMM slot selector */
|
|
|
|
mem_st->selector = data;
|
2014-06-02 15:25:17 +02:00
|
|
|
trace_mhp_acpi_write_slot(mem_st->selector);
|
2014-06-02 15:25:16 +02:00
|
|
|
break;
|
|
|
|
case 0x4: /* _OST event */
|
|
|
|
mdev = &mem_st->devs[mem_st->selector];
|
|
|
|
if (data == 1) {
|
|
|
|
/* TODO: handle device insert OST event */
|
|
|
|
} else if (data == 3) {
|
|
|
|
/* TODO: handle device remove OST event */
|
|
|
|
}
|
|
|
|
mdev->ost_event = data;
|
2014-06-02 15:25:17 +02:00
|
|
|
trace_mhp_acpi_write_ost_ev(mem_st->selector, mdev->ost_event);
|
2014-06-02 15:25:16 +02:00
|
|
|
break;
|
|
|
|
case 0x8: /* _OST status */
|
|
|
|
mdev = &mem_st->devs[mem_st->selector];
|
|
|
|
mdev->ost_status = data;
|
2014-06-02 15:25:17 +02:00
|
|
|
trace_mhp_acpi_write_ost_status(mem_st->selector, mdev->ost_status);
|
2014-06-02 15:25:16 +02:00
|
|
|
/* TODO: implement memory removal on guest signal */
|
2014-06-23 15:26:57 +02:00
|
|
|
|
|
|
|
info = acpi_memory_device_status(mem_st->selector, mdev);
|
2018-08-15 15:37:37 +02:00
|
|
|
qapi_event_send_acpi_device_ost(info);
|
2014-06-23 15:26:57 +02:00
|
|
|
qapi_free_ACPIOSTInfo(info);
|
2014-06-02 15:25:16 +02:00
|
|
|
break;
|
2015-04-27 10:47:21 +02:00
|
|
|
case 0x14: /* set is_* fields */
|
2014-06-02 15:25:16 +02:00
|
|
|
mdev = &mem_st->devs[mem_st->selector];
|
|
|
|
if (data & 2) { /* clear insert event */
|
|
|
|
mdev->is_inserting = false;
|
2014-06-02 15:25:17 +02:00
|
|
|
trace_mhp_acpi_clear_insert_evt(mem_st->selector);
|
2015-04-27 10:47:21 +02:00
|
|
|
} else if (data & 4) {
|
|
|
|
mdev->is_removing = false;
|
|
|
|
trace_mhp_acpi_clear_remove_evt(mem_st->selector);
|
|
|
|
} else if (data & 8) {
|
|
|
|
if (!mdev->is_enabled) {
|
|
|
|
trace_mhp_acpi_ejecting_invalid_slot(mem_st->selector);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev = DEVICE(mdev->dimm);
|
|
|
|
hotplug_ctrl = qdev_get_hotplug_handler(dev);
|
|
|
|
/* call pc-dimm unplug cb */
|
2015-04-27 10:47:22 +02:00
|
|
|
hotplug_handler_unplug(hotplug_ctrl, dev, &local_err);
|
|
|
|
if (local_err) {
|
|
|
|
trace_mhp_acpi_pc_dimm_delete_failed(mem_st->selector);
|
|
|
|
qapi_event_send_mem_unplug_error(dev->id,
|
2018-08-15 15:37:37 +02:00
|
|
|
error_get_pretty(local_err));
|
2015-11-26 13:00:12 +01:00
|
|
|
error_free(local_err);
|
2015-04-27 10:47:22 +02:00
|
|
|
break;
|
|
|
|
}
|
qdev: Let the hotplug_handler_unplug() caller delete the device
When unplugging a device, at one point the device will be destroyed
via object_unparent(). This will, one the one hand, unrealize the
removed device hierarchy, and on the other hand, destroy/free the
device hierarchy.
When chaining hotplug handlers, we want to overwrite a bus hotplug
handler by the machine hotplug handler, to be able to perform
some part of the plug/unplug and to forward the calls to the bus hotplug
handler.
For now, the bus hotplug handler would trigger an object_unparent(), not
allowing us to perform some unplug action on a device after we forwarded
the call to the bus hotplug handler. The device would be gone at that
point.
machine_unplug_handler(dev)
/* eventually do unplug stuff */
bus_unplug_handler(dev)
/* dev is gone, we can't do more unplug stuff */
So move the object_unparent() to the original caller of the unplug. For
now, keep the unrealize() at the original places of the
object_unparent(). For implicitly chained hotplug handlers (e.g. pc
code calling acpi hotplug handlers), the object_unparent() has to be
done by the outermost caller. So when calling hotplug_handler_unplug()
from inside an unplug handler, nothing is to be done.
hotplug_handler_unplug(dev) -> calls machine_unplug_handler()
machine_unplug_handler(dev) {
/* eventually do unplug stuff */
bus_unplug_handler(dev) -> calls unrealize(dev)
/* we can do more unplug stuff but device already unrealized */
}
object_unparent(dev)
In the long run, every unplug action should be factored out of the
unrealize() function into the unplug handler (especially for PCI). Then
we can get rid of the additonal unrealize() calls and object_unparent()
will properly unrealize the device hierarchy after the device has been
unplugged.
hotplug_handler_unplug(dev) -> calls machine_unplug_handler()
machine_unplug_handler(dev) {
/* eventually do unplug stuff */
bus_unplug_handler(dev) -> only unplugs, does not unrealize
/* we can do more unplug stuff */
}
object_unparent(dev) -> will unrealize
The original approach was suggested by Igor Mammedov for the PCI
part, but I extended it to all hotplug handlers. I consider this one
step into the right direction.
To summarize:
- object_unparent() on synchronous unplugs is done by common code
-- "Caller of hotplug_handler_unplug"
- object_unparent() on asynchronous unplugs ("unplug requests") has to
be done manually
-- "Caller of hotplug_handler_unplug"
Reviewed-by: Igor Mammedov <imammedo@redhat.com>
Acked-by: Cornelia Huck <cohuck@redhat.com>
Signed-off-by: David Hildenbrand <david@redhat.com>
Message-Id: <20190228122849.4296-2-david@redhat.com>
Reviewed-by: Greg Kurz <groug@kaod.org>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
2019-02-28 13:28:47 +01:00
|
|
|
object_unparent(OBJECT(dev));
|
2015-04-27 10:47:21 +02:00
|
|
|
trace_mhp_acpi_pc_dimm_deleted(mem_st->selector);
|
2014-06-02 15:25:16 +02:00
|
|
|
}
|
|
|
|
break;
|
2015-04-27 10:47:21 +02:00
|
|
|
default:
|
|
|
|
break;
|
2014-06-02 15:25:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
static const MemoryRegionOps acpi_memory_hotplug_ops = {
|
|
|
|
.read = acpi_memory_hotplug_read,
|
|
|
|
.write = acpi_memory_hotplug_write,
|
|
|
|
.endianness = DEVICE_LITTLE_ENDIAN,
|
|
|
|
.valid = {
|
|
|
|
.min_access_size = 1,
|
|
|
|
.max_access_size = 4,
|
|
|
|
},
|
|
|
|
};
|
|
|
|
|
|
|
|
void acpi_memory_hotplug_init(MemoryRegion *as, Object *owner,
|
2019-09-18 15:06:23 +02:00
|
|
|
MemHotplugState *state, hwaddr io_base)
|
2014-06-02 15:25:16 +02:00
|
|
|
{
|
|
|
|
MachineState *machine = MACHINE(qdev_get_machine());
|
|
|
|
|
|
|
|
state->dev_count = machine->ram_slots;
|
|
|
|
if (!state->dev_count) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
state->devs = g_malloc0(sizeof(*state->devs) * state->dev_count);
|
|
|
|
memory_region_init_io(&state->io, owner, &acpi_memory_hotplug_ops, state,
|
2016-12-06 00:32:28 +01:00
|
|
|
"acpi-mem-hotplug", MEMORY_HOTPLUG_IO_LEN);
|
2019-09-18 15:06:23 +02:00
|
|
|
memory_region_add_subregion(as, io_base, &state->io);
|
2014-06-02 15:25:16 +02:00
|
|
|
}
|
|
|
|
|
2015-04-27 10:47:16 +02:00
|
|
|
/**
|
|
|
|
* acpi_memory_slot_status:
|
|
|
|
* @mem_st: memory hotplug state
|
|
|
|
* @dev: device
|
|
|
|
* @errp: set in case of an error
|
|
|
|
*
|
|
|
|
* Obtain a single memory slot status.
|
|
|
|
*
|
|
|
|
* This function will be called by memory unplug request cb and unplug cb.
|
|
|
|
*/
|
|
|
|
static MemStatus *
|
|
|
|
acpi_memory_slot_status(MemHotplugState *mem_st,
|
|
|
|
DeviceState *dev, Error **errp)
|
2014-06-02 15:25:16 +02:00
|
|
|
{
|
|
|
|
Error *local_err = NULL;
|
2015-02-26 02:16:43 +01:00
|
|
|
int slot = object_property_get_int(OBJECT(dev), PC_DIMM_SLOT_PROP,
|
|
|
|
&local_err);
|
2014-06-02 15:25:16 +02:00
|
|
|
|
|
|
|
if (local_err) {
|
|
|
|
error_propagate(errp, local_err);
|
2015-04-27 10:47:16 +02:00
|
|
|
return NULL;
|
2014-06-02 15:25:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (slot >= mem_st->dev_count) {
|
|
|
|
char *dev_path = object_get_canonical_path(OBJECT(dev));
|
2015-04-27 10:47:16 +02:00
|
|
|
error_setg(errp, "acpi_memory_slot_status: "
|
2014-06-02 15:25:16 +02:00
|
|
|
"device [%s] returned invalid memory slot[%d]",
|
|
|
|
dev_path, slot);
|
|
|
|
g_free(dev_path);
|
2015-04-27 10:47:16 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return &mem_st->devs[slot];
|
|
|
|
}
|
|
|
|
|
2016-05-31 12:01:17 +02:00
|
|
|
void acpi_memory_plug_cb(HotplugHandler *hotplug_dev, MemHotplugState *mem_st,
|
2015-04-27 10:47:16 +02:00
|
|
|
DeviceState *dev, Error **errp)
|
|
|
|
{
|
|
|
|
MemStatus *mdev;
|
2016-11-07 12:13:38 +01:00
|
|
|
DeviceClass *dc = DEVICE_GET_CLASS(dev);
|
|
|
|
|
|
|
|
if (!dc->hotpluggable) {
|
|
|
|
return;
|
|
|
|
}
|
2015-04-27 10:47:16 +02:00
|
|
|
|
|
|
|
mdev = acpi_memory_slot_status(mem_st, dev, errp);
|
|
|
|
if (!mdev) {
|
2014-06-02 15:25:16 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
mdev->dimm = dev;
|
2016-11-07 12:13:38 +01:00
|
|
|
mdev->is_enabled = true;
|
2015-10-23 14:55:26 +02:00
|
|
|
if (dev->hotplugged) {
|
2016-11-07 12:13:38 +01:00
|
|
|
mdev->is_inserting = true;
|
|
|
|
acpi_send_event(DEVICE(hotplug_dev), ACPI_MEMORY_HOTPLUG_STATUS);
|
2015-10-23 14:55:26 +02:00
|
|
|
}
|
2014-06-02 15:25:16 +02:00
|
|
|
}
|
2014-06-02 15:25:23 +02:00
|
|
|
|
2016-05-31 12:01:17 +02:00
|
|
|
void acpi_memory_unplug_request_cb(HotplugHandler *hotplug_dev,
|
2015-04-27 10:47:17 +02:00
|
|
|
MemHotplugState *mem_st,
|
|
|
|
DeviceState *dev, Error **errp)
|
|
|
|
{
|
|
|
|
MemStatus *mdev;
|
|
|
|
|
|
|
|
mdev = acpi_memory_slot_status(mem_st, dev, errp);
|
|
|
|
if (!mdev) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
mdev->is_removing = true;
|
2016-05-31 12:01:17 +02:00
|
|
|
acpi_send_event(DEVICE(hotplug_dev), ACPI_MEMORY_HOTPLUG_STATUS);
|
2015-04-27 10:47:17 +02:00
|
|
|
}
|
|
|
|
|
2015-04-27 10:47:18 +02:00
|
|
|
void acpi_memory_unplug_cb(MemHotplugState *mem_st,
|
|
|
|
DeviceState *dev, Error **errp)
|
|
|
|
{
|
|
|
|
MemStatus *mdev;
|
|
|
|
|
|
|
|
mdev = acpi_memory_slot_status(mem_st, dev, errp);
|
|
|
|
if (!mdev) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
mdev->is_enabled = false;
|
|
|
|
mdev->dimm = NULL;
|
|
|
|
}
|
|
|
|
|
2014-06-02 15:25:23 +02:00
|
|
|
static const VMStateDescription vmstate_memhp_sts = {
|
|
|
|
.name = "memory hotplug device state",
|
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
|
|
|
.minimum_version_id_old = 1,
|
|
|
|
.fields = (VMStateField[]) {
|
|
|
|
VMSTATE_BOOL(is_enabled, MemStatus),
|
|
|
|
VMSTATE_BOOL(is_inserting, MemStatus),
|
|
|
|
VMSTATE_UINT32(ost_event, MemStatus),
|
|
|
|
VMSTATE_UINT32(ost_status, MemStatus),
|
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
const VMStateDescription vmstate_memory_hotplug = {
|
|
|
|
.name = "memory hotplug state",
|
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
|
|
|
.minimum_version_id_old = 1,
|
|
|
|
.fields = (VMStateField[]) {
|
|
|
|
VMSTATE_UINT32(selector, MemHotplugState),
|
|
|
|
VMSTATE_STRUCT_VARRAY_POINTER_UINT32(devs, MemHotplugState, dev_count,
|
|
|
|
vmstate_memhp_sts, MemStatus),
|
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
}
|
|
|
|
};
|
2016-12-06 00:32:22 +01:00
|
|
|
|
2016-12-06 00:32:24 +01:00
|
|
|
void build_memory_hotplug_aml(Aml *table, uint32_t nr_mem,
|
2016-12-06 00:32:26 +01:00
|
|
|
const char *res_root,
|
2019-09-18 15:06:23 +02:00
|
|
|
const char *event_handler_method,
|
|
|
|
AmlRegionSpace rs, hwaddr memhp_io_base)
|
2016-12-06 00:32:22 +01:00
|
|
|
{
|
2016-12-06 00:32:25 +01:00
|
|
|
int i;
|
2016-12-06 00:32:22 +01:00
|
|
|
Aml *ifctx;
|
|
|
|
Aml *method;
|
2016-12-06 00:32:29 +01:00
|
|
|
Aml *dev_container;
|
2016-12-06 00:32:22 +01:00
|
|
|
Aml *mem_ctrl_dev;
|
2016-12-06 00:32:28 +01:00
|
|
|
char *mhp_res_path;
|
|
|
|
|
|
|
|
mhp_res_path = g_strdup_printf("%s." MEMORY_HOTPLUG_DEVICE, res_root);
|
2016-12-06 00:32:26 +01:00
|
|
|
mem_ctrl_dev = aml_device("%s", mhp_res_path);
|
2016-12-06 00:32:22 +01:00
|
|
|
{
|
2016-12-06 00:32:24 +01:00
|
|
|
Aml *crs;
|
2016-12-06 00:32:22 +01:00
|
|
|
|
|
|
|
aml_append(mem_ctrl_dev, aml_name_decl("_HID", aml_string("PNP0A06")));
|
|
|
|
aml_append(mem_ctrl_dev,
|
|
|
|
aml_name_decl("_UID", aml_string("Memory hotplug resources")));
|
|
|
|
|
2016-12-06 00:32:24 +01:00
|
|
|
crs = aml_resource_template();
|
2019-09-18 15:06:23 +02:00
|
|
|
if (rs == AML_SYSTEM_IO) {
|
|
|
|
aml_append(crs,
|
|
|
|
aml_io(AML_DECODE16, memhp_io_base, memhp_io_base, 0,
|
|
|
|
MEMORY_HOTPLUG_IO_LEN)
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
aml_append(crs, aml_memory32_fixed(memhp_io_base,
|
|
|
|
MEMORY_HOTPLUG_IO_LEN, AML_READ_WRITE));
|
|
|
|
}
|
2016-12-06 00:32:24 +01:00
|
|
|
aml_append(mem_ctrl_dev, aml_name_decl("_CRS", crs));
|
|
|
|
|
|
|
|
aml_append(mem_ctrl_dev, aml_operation_region(
|
2019-09-18 15:06:23 +02:00
|
|
|
MEMORY_HOTPLUG_IO_REGION, rs,
|
2016-12-06 00:32:28 +01:00
|
|
|
aml_int(memhp_io_base), MEMORY_HOTPLUG_IO_LEN)
|
2016-12-06 00:32:24 +01:00
|
|
|
);
|
|
|
|
|
2016-12-06 00:32:29 +01:00
|
|
|
}
|
|
|
|
aml_append(table, mem_ctrl_dev);
|
|
|
|
|
|
|
|
dev_container = aml_device(MEMORY_DEVICES_CONTAINER);
|
|
|
|
{
|
|
|
|
Aml *field;
|
|
|
|
Aml *one = aml_int(1);
|
|
|
|
Aml *zero = aml_int(0);
|
|
|
|
Aml *ret_val = aml_local(0);
|
|
|
|
Aml *slot_arg0 = aml_arg(0);
|
|
|
|
Aml *slots_nr = aml_name(MEMORY_SLOTS_NUMBER);
|
|
|
|
Aml *ctrl_lock = aml_name(MEMORY_SLOT_LOCK);
|
|
|
|
Aml *slot_selector = aml_name(MEMORY_SLOT_SLECTOR);
|
|
|
|
char *mmio_path = g_strdup_printf("%s." MEMORY_HOTPLUG_IO_REGION,
|
|
|
|
mhp_res_path);
|
|
|
|
|
|
|
|
aml_append(dev_container, aml_name_decl("_HID", aml_string("PNP0A06")));
|
|
|
|
aml_append(dev_container,
|
|
|
|
aml_name_decl("_UID", aml_string("DIMM devices")));
|
|
|
|
|
|
|
|
assert(nr_mem <= ACPI_MAX_RAM_SLOTS);
|
|
|
|
aml_append(dev_container,
|
|
|
|
aml_name_decl(MEMORY_SLOTS_NUMBER, aml_int(nr_mem))
|
|
|
|
);
|
|
|
|
|
|
|
|
field = aml_field(mmio_path, AML_DWORD_ACC,
|
2016-12-06 00:32:24 +01:00
|
|
|
AML_NOLOCK, AML_PRESERVE);
|
|
|
|
aml_append(field, /* read only */
|
|
|
|
aml_named_field(MEMORY_SLOT_ADDR_LOW, 32));
|
|
|
|
aml_append(field, /* read only */
|
|
|
|
aml_named_field(MEMORY_SLOT_ADDR_HIGH, 32));
|
|
|
|
aml_append(field, /* read only */
|
|
|
|
aml_named_field(MEMORY_SLOT_SIZE_LOW, 32));
|
|
|
|
aml_append(field, /* read only */
|
|
|
|
aml_named_field(MEMORY_SLOT_SIZE_HIGH, 32));
|
|
|
|
aml_append(field, /* read only */
|
|
|
|
aml_named_field(MEMORY_SLOT_PROXIMITY, 32));
|
2016-12-06 00:32:29 +01:00
|
|
|
aml_append(dev_container, field);
|
2016-12-06 00:32:24 +01:00
|
|
|
|
2016-12-06 00:32:29 +01:00
|
|
|
field = aml_field(mmio_path, AML_BYTE_ACC,
|
2016-12-06 00:32:24 +01:00
|
|
|
AML_NOLOCK, AML_WRITE_AS_ZEROS);
|
|
|
|
aml_append(field, aml_reserved_field(160 /* bits, Offset(20) */));
|
|
|
|
aml_append(field, /* 1 if enabled, read only */
|
|
|
|
aml_named_field(MEMORY_SLOT_ENABLED, 1));
|
|
|
|
aml_append(field,
|
|
|
|
/*(read) 1 if has a insert event. (write) 1 to clear event */
|
|
|
|
aml_named_field(MEMORY_SLOT_INSERT_EVENT, 1));
|
|
|
|
aml_append(field,
|
|
|
|
/* (read) 1 if has a remove event. (write) 1 to clear event */
|
|
|
|
aml_named_field(MEMORY_SLOT_REMOVE_EVENT, 1));
|
|
|
|
aml_append(field,
|
|
|
|
/* initiates device eject, write only */
|
|
|
|
aml_named_field(MEMORY_SLOT_EJECT, 1));
|
2016-12-06 00:32:29 +01:00
|
|
|
aml_append(dev_container, field);
|
2016-12-06 00:32:24 +01:00
|
|
|
|
2016-12-06 00:32:29 +01:00
|
|
|
field = aml_field(mmio_path, AML_DWORD_ACC,
|
2016-12-06 00:32:24 +01:00
|
|
|
AML_NOLOCK, AML_PRESERVE);
|
|
|
|
aml_append(field, /* DIMM selector, write only */
|
|
|
|
aml_named_field(MEMORY_SLOT_SLECTOR, 32));
|
|
|
|
aml_append(field, /* _OST event code, write only */
|
|
|
|
aml_named_field(MEMORY_SLOT_OST_EVENT, 32));
|
|
|
|
aml_append(field, /* _OST status code, write only */
|
|
|
|
aml_named_field(MEMORY_SLOT_OST_STATUS, 32));
|
2016-12-06 00:32:29 +01:00
|
|
|
aml_append(dev_container, field);
|
|
|
|
g_free(mmio_path);
|
2016-12-06 00:32:24 +01:00
|
|
|
|
2016-12-06 00:32:22 +01:00
|
|
|
method = aml_method("_STA", 0, AML_NOTSERIALIZED);
|
|
|
|
ifctx = aml_if(aml_equal(slots_nr, zero));
|
|
|
|
{
|
|
|
|
aml_append(ifctx, aml_return(zero));
|
|
|
|
}
|
|
|
|
aml_append(method, ifctx);
|
|
|
|
/* present, functioning, decoding, not shown in UI */
|
|
|
|
aml_append(method, aml_return(aml_int(0xB)));
|
2016-12-06 00:32:29 +01:00
|
|
|
aml_append(dev_container, method);
|
2016-12-06 00:32:22 +01:00
|
|
|
|
2016-12-06 00:32:29 +01:00
|
|
|
aml_append(dev_container, aml_mutex(MEMORY_SLOT_LOCK, 0));
|
2016-12-06 00:32:22 +01:00
|
|
|
|
|
|
|
method = aml_method(MEMORY_SLOT_SCAN_METHOD, 0, AML_NOTSERIALIZED);
|
|
|
|
{
|
|
|
|
Aml *else_ctx;
|
|
|
|
Aml *while_ctx;
|
|
|
|
Aml *idx = aml_local(0);
|
|
|
|
Aml *eject_req = aml_int(3);
|
|
|
|
Aml *dev_chk = aml_int(1);
|
|
|
|
|
|
|
|
ifctx = aml_if(aml_equal(slots_nr, zero));
|
|
|
|
{
|
|
|
|
aml_append(ifctx, aml_return(zero));
|
|
|
|
}
|
|
|
|
aml_append(method, ifctx);
|
|
|
|
|
|
|
|
aml_append(method, aml_store(zero, idx));
|
|
|
|
aml_append(method, aml_acquire(ctrl_lock, 0xFFFF));
|
|
|
|
/* build AML that:
|
|
|
|
* loops over all slots and Notifies DIMMs with
|
|
|
|
* Device Check or Eject Request notifications if
|
|
|
|
* slot has corresponding status bit set and clears
|
|
|
|
* slot status.
|
|
|
|
*/
|
|
|
|
while_ctx = aml_while(aml_lless(idx, slots_nr));
|
|
|
|
{
|
|
|
|
Aml *ins_evt = aml_name(MEMORY_SLOT_INSERT_EVENT);
|
|
|
|
Aml *rm_evt = aml_name(MEMORY_SLOT_REMOVE_EVENT);
|
|
|
|
|
|
|
|
aml_append(while_ctx, aml_store(idx, slot_selector));
|
|
|
|
ifctx = aml_if(aml_equal(ins_evt, one));
|
|
|
|
{
|
|
|
|
aml_append(ifctx,
|
|
|
|
aml_call2(MEMORY_SLOT_NOTIFY_METHOD,
|
|
|
|
idx, dev_chk));
|
|
|
|
aml_append(ifctx, aml_store(one, ins_evt));
|
|
|
|
}
|
|
|
|
aml_append(while_ctx, ifctx);
|
|
|
|
|
|
|
|
else_ctx = aml_else();
|
|
|
|
ifctx = aml_if(aml_equal(rm_evt, one));
|
|
|
|
{
|
|
|
|
aml_append(ifctx,
|
|
|
|
aml_call2(MEMORY_SLOT_NOTIFY_METHOD,
|
|
|
|
idx, eject_req));
|
|
|
|
aml_append(ifctx, aml_store(one, rm_evt));
|
|
|
|
}
|
|
|
|
aml_append(else_ctx, ifctx);
|
|
|
|
aml_append(while_ctx, else_ctx);
|
|
|
|
|
|
|
|
aml_append(while_ctx, aml_add(idx, one, idx));
|
|
|
|
}
|
|
|
|
aml_append(method, while_ctx);
|
|
|
|
aml_append(method, aml_release(ctrl_lock));
|
|
|
|
aml_append(method, aml_return(one));
|
|
|
|
}
|
2016-12-06 00:32:29 +01:00
|
|
|
aml_append(dev_container, method);
|
2016-12-06 00:32:22 +01:00
|
|
|
|
|
|
|
method = aml_method(MEMORY_SLOT_STATUS_METHOD, 1, AML_NOTSERIALIZED);
|
|
|
|
{
|
|
|
|
Aml *slot_enabled = aml_name(MEMORY_SLOT_ENABLED);
|
|
|
|
|
|
|
|
aml_append(method, aml_store(zero, ret_val));
|
|
|
|
aml_append(method, aml_acquire(ctrl_lock, 0xFFFF));
|
|
|
|
aml_append(method,
|
|
|
|
aml_store(aml_to_integer(slot_arg0), slot_selector));
|
|
|
|
|
|
|
|
ifctx = aml_if(aml_equal(slot_enabled, one));
|
|
|
|
{
|
|
|
|
aml_append(ifctx, aml_store(aml_int(0xF), ret_val));
|
|
|
|
}
|
|
|
|
aml_append(method, ifctx);
|
|
|
|
|
|
|
|
aml_append(method, aml_release(ctrl_lock));
|
|
|
|
aml_append(method, aml_return(ret_val));
|
|
|
|
}
|
2016-12-06 00:32:29 +01:00
|
|
|
aml_append(dev_container, method);
|
2016-12-06 00:32:22 +01:00
|
|
|
|
|
|
|
method = aml_method(MEMORY_SLOT_CRS_METHOD, 1, AML_SERIALIZED);
|
|
|
|
{
|
|
|
|
Aml *mr64 = aml_name("MR64");
|
|
|
|
Aml *mr32 = aml_name("MR32");
|
|
|
|
Aml *crs_tmpl = aml_resource_template();
|
|
|
|
Aml *minl = aml_name("MINL");
|
|
|
|
Aml *minh = aml_name("MINH");
|
|
|
|
Aml *maxl = aml_name("MAXL");
|
|
|
|
Aml *maxh = aml_name("MAXH");
|
|
|
|
Aml *lenl = aml_name("LENL");
|
|
|
|
Aml *lenh = aml_name("LENH");
|
|
|
|
|
|
|
|
aml_append(method, aml_acquire(ctrl_lock, 0xFFFF));
|
|
|
|
aml_append(method, aml_store(aml_to_integer(slot_arg0),
|
|
|
|
slot_selector));
|
|
|
|
|
|
|
|
aml_append(crs_tmpl,
|
|
|
|
aml_qword_memory(AML_POS_DECODE, AML_MIN_FIXED, AML_MAX_FIXED,
|
|
|
|
AML_CACHEABLE, AML_READ_WRITE,
|
|
|
|
0, 0x0, 0xFFFFFFFFFFFFFFFEULL, 0,
|
|
|
|
0xFFFFFFFFFFFFFFFFULL));
|
|
|
|
aml_append(method, aml_name_decl("MR64", crs_tmpl));
|
|
|
|
aml_append(method,
|
|
|
|
aml_create_dword_field(mr64, aml_int(14), "MINL"));
|
|
|
|
aml_append(method,
|
|
|
|
aml_create_dword_field(mr64, aml_int(18), "MINH"));
|
|
|
|
aml_append(method,
|
|
|
|
aml_create_dword_field(mr64, aml_int(38), "LENL"));
|
|
|
|
aml_append(method,
|
|
|
|
aml_create_dword_field(mr64, aml_int(42), "LENH"));
|
|
|
|
aml_append(method,
|
|
|
|
aml_create_dword_field(mr64, aml_int(22), "MAXL"));
|
|
|
|
aml_append(method,
|
|
|
|
aml_create_dword_field(mr64, aml_int(26), "MAXH"));
|
|
|
|
|
|
|
|
aml_append(method,
|
|
|
|
aml_store(aml_name(MEMORY_SLOT_ADDR_HIGH), minh));
|
|
|
|
aml_append(method,
|
|
|
|
aml_store(aml_name(MEMORY_SLOT_ADDR_LOW), minl));
|
|
|
|
aml_append(method,
|
|
|
|
aml_store(aml_name(MEMORY_SLOT_SIZE_HIGH), lenh));
|
|
|
|
aml_append(method,
|
|
|
|
aml_store(aml_name(MEMORY_SLOT_SIZE_LOW), lenl));
|
|
|
|
|
|
|
|
/* 64-bit math: MAX = MIN + LEN - 1 */
|
|
|
|
aml_append(method, aml_add(minl, lenl, maxl));
|
|
|
|
aml_append(method, aml_add(minh, lenh, maxh));
|
|
|
|
ifctx = aml_if(aml_lless(maxl, minl));
|
|
|
|
{
|
|
|
|
aml_append(ifctx, aml_add(maxh, one, maxh));
|
|
|
|
}
|
|
|
|
aml_append(method, ifctx);
|
|
|
|
ifctx = aml_if(aml_lless(maxl, one));
|
|
|
|
{
|
|
|
|
aml_append(ifctx, aml_subtract(maxh, one, maxh));
|
|
|
|
}
|
|
|
|
aml_append(method, ifctx);
|
|
|
|
aml_append(method, aml_subtract(maxl, one, maxl));
|
|
|
|
|
|
|
|
/* return 32-bit _CRS if addr/size is in low mem */
|
|
|
|
/* TODO: remove it since all hotplugged DIMMs are in high mem */
|
|
|
|
ifctx = aml_if(aml_equal(maxh, zero));
|
|
|
|
{
|
|
|
|
crs_tmpl = aml_resource_template();
|
|
|
|
aml_append(crs_tmpl,
|
|
|
|
aml_dword_memory(AML_POS_DECODE, AML_MIN_FIXED,
|
|
|
|
AML_MAX_FIXED, AML_CACHEABLE,
|
|
|
|
AML_READ_WRITE,
|
|
|
|
0, 0x0, 0xFFFFFFFE, 0,
|
|
|
|
0xFFFFFFFF));
|
|
|
|
aml_append(ifctx, aml_name_decl("MR32", crs_tmpl));
|
|
|
|
aml_append(ifctx,
|
|
|
|
aml_create_dword_field(mr32, aml_int(10), "MIN"));
|
|
|
|
aml_append(ifctx,
|
|
|
|
aml_create_dword_field(mr32, aml_int(14), "MAX"));
|
|
|
|
aml_append(ifctx,
|
|
|
|
aml_create_dword_field(mr32, aml_int(22), "LEN"));
|
|
|
|
aml_append(ifctx, aml_store(minl, aml_name("MIN")));
|
|
|
|
aml_append(ifctx, aml_store(maxl, aml_name("MAX")));
|
|
|
|
aml_append(ifctx, aml_store(lenl, aml_name("LEN")));
|
|
|
|
|
|
|
|
aml_append(ifctx, aml_release(ctrl_lock));
|
|
|
|
aml_append(ifctx, aml_return(mr32));
|
|
|
|
}
|
|
|
|
aml_append(method, ifctx);
|
|
|
|
|
|
|
|
aml_append(method, aml_release(ctrl_lock));
|
|
|
|
aml_append(method, aml_return(mr64));
|
|
|
|
}
|
2016-12-06 00:32:29 +01:00
|
|
|
aml_append(dev_container, method);
|
2016-12-06 00:32:22 +01:00
|
|
|
|
|
|
|
method = aml_method(MEMORY_SLOT_PROXIMITY_METHOD, 1,
|
|
|
|
AML_NOTSERIALIZED);
|
|
|
|
{
|
|
|
|
Aml *proximity = aml_name(MEMORY_SLOT_PROXIMITY);
|
|
|
|
|
|
|
|
aml_append(method, aml_acquire(ctrl_lock, 0xFFFF));
|
|
|
|
aml_append(method, aml_store(aml_to_integer(slot_arg0),
|
|
|
|
slot_selector));
|
|
|
|
aml_append(method, aml_store(proximity, ret_val));
|
|
|
|
aml_append(method, aml_release(ctrl_lock));
|
|
|
|
aml_append(method, aml_return(ret_val));
|
|
|
|
}
|
2016-12-06 00:32:29 +01:00
|
|
|
aml_append(dev_container, method);
|
2016-12-06 00:32:22 +01:00
|
|
|
|
|
|
|
method = aml_method(MEMORY_SLOT_OST_METHOD, 4, AML_NOTSERIALIZED);
|
|
|
|
{
|
|
|
|
Aml *ost_evt = aml_name(MEMORY_SLOT_OST_EVENT);
|
|
|
|
Aml *ost_status = aml_name(MEMORY_SLOT_OST_STATUS);
|
|
|
|
|
|
|
|
aml_append(method, aml_acquire(ctrl_lock, 0xFFFF));
|
|
|
|
aml_append(method, aml_store(aml_to_integer(slot_arg0),
|
|
|
|
slot_selector));
|
|
|
|
aml_append(method, aml_store(aml_arg(1), ost_evt));
|
|
|
|
aml_append(method, aml_store(aml_arg(2), ost_status));
|
|
|
|
aml_append(method, aml_release(ctrl_lock));
|
|
|
|
}
|
2016-12-06 00:32:29 +01:00
|
|
|
aml_append(dev_container, method);
|
2016-12-06 00:32:22 +01:00
|
|
|
|
|
|
|
method = aml_method(MEMORY_SLOT_EJECT_METHOD, 2, AML_NOTSERIALIZED);
|
|
|
|
{
|
|
|
|
Aml *eject = aml_name(MEMORY_SLOT_EJECT);
|
|
|
|
|
|
|
|
aml_append(method, aml_acquire(ctrl_lock, 0xFFFF));
|
|
|
|
aml_append(method, aml_store(aml_to_integer(slot_arg0),
|
|
|
|
slot_selector));
|
|
|
|
aml_append(method, aml_store(one, eject));
|
|
|
|
aml_append(method, aml_release(ctrl_lock));
|
|
|
|
}
|
2016-12-06 00:32:29 +01:00
|
|
|
aml_append(dev_container, method);
|
|
|
|
|
|
|
|
/* build memory devices */
|
|
|
|
for (i = 0; i < nr_mem; i++) {
|
|
|
|
Aml *dev;
|
|
|
|
const char *s;
|
|
|
|
|
|
|
|
dev = aml_device("MP%02X", i);
|
|
|
|
aml_append(dev, aml_name_decl("_UID", aml_string("0x%02X", i)));
|
|
|
|
aml_append(dev, aml_name_decl("_HID", aml_eisaid("PNP0C80")));
|
|
|
|
|
|
|
|
method = aml_method("_CRS", 0, AML_NOTSERIALIZED);
|
|
|
|
s = MEMORY_SLOT_CRS_METHOD;
|
|
|
|
aml_append(method, aml_return(aml_call1(s, aml_name("_UID"))));
|
|
|
|
aml_append(dev, method);
|
|
|
|
|
|
|
|
method = aml_method("_STA", 0, AML_NOTSERIALIZED);
|
|
|
|
s = MEMORY_SLOT_STATUS_METHOD;
|
|
|
|
aml_append(method, aml_return(aml_call1(s, aml_name("_UID"))));
|
|
|
|
aml_append(dev, method);
|
|
|
|
|
|
|
|
method = aml_method("_PXM", 0, AML_NOTSERIALIZED);
|
|
|
|
s = MEMORY_SLOT_PROXIMITY_METHOD;
|
|
|
|
aml_append(method, aml_return(aml_call1(s, aml_name("_UID"))));
|
|
|
|
aml_append(dev, method);
|
|
|
|
|
|
|
|
method = aml_method("_OST", 3, AML_NOTSERIALIZED);
|
|
|
|
s = MEMORY_SLOT_OST_METHOD;
|
2018-11-05 02:40:39 +01:00
|
|
|
aml_append(method,
|
|
|
|
aml_call4(s, aml_name("_UID"), aml_arg(0),
|
|
|
|
aml_arg(1), aml_arg(2)));
|
2016-12-06 00:32:29 +01:00
|
|
|
aml_append(dev, method);
|
|
|
|
|
|
|
|
method = aml_method("_EJ0", 1, AML_NOTSERIALIZED);
|
|
|
|
s = MEMORY_SLOT_EJECT_METHOD;
|
2018-11-05 02:40:39 +01:00
|
|
|
aml_append(method,
|
|
|
|
aml_call2(s, aml_name("_UID"), aml_arg(0)));
|
2016-12-06 00:32:29 +01:00
|
|
|
aml_append(dev, method);
|
|
|
|
|
|
|
|
aml_append(dev_container, dev);
|
|
|
|
}
|
2016-12-06 00:32:23 +01:00
|
|
|
|
2016-12-06 00:32:29 +01:00
|
|
|
/* build Method(MEMORY_SLOT_NOTIFY_METHOD, 2) {
|
|
|
|
* If (LEqual(Arg0, 0x00)) {Notify(MP00, Arg1)} ... }
|
|
|
|
*/
|
|
|
|
method = aml_method(MEMORY_SLOT_NOTIFY_METHOD, 2, AML_NOTSERIALIZED);
|
|
|
|
for (i = 0; i < nr_mem; i++) {
|
|
|
|
ifctx = aml_if(aml_equal(aml_arg(0), aml_int(i)));
|
|
|
|
aml_append(ifctx,
|
|
|
|
aml_notify(aml_name("MP%.02X", i), aml_arg(1))
|
|
|
|
);
|
|
|
|
aml_append(method, ifctx);
|
|
|
|
}
|
|
|
|
aml_append(dev_container, method);
|
2016-12-06 00:32:23 +01:00
|
|
|
}
|
2016-12-06 00:32:29 +01:00
|
|
|
aml_append(table, dev_container);
|
2016-12-06 00:32:26 +01:00
|
|
|
|
2019-09-18 15:06:24 +02:00
|
|
|
if (event_handler_method) {
|
|
|
|
method = aml_method(event_handler_method, 0, AML_NOTSERIALIZED);
|
|
|
|
aml_append(method, aml_call0(MEMORY_DEVICES_CONTAINER "."
|
|
|
|
MEMORY_SLOT_SCAN_METHOD));
|
|
|
|
aml_append(table, method);
|
|
|
|
}
|
2016-12-06 00:32:26 +01:00
|
|
|
|
|
|
|
g_free(mhp_res_path);
|
2016-12-06 00:32:23 +01:00
|
|
|
}
|