hw/acpi/memory_hotplug.c

   1 #include "hw/acpi/memory_hotplug.h"
   2 #include "hw/acpi/pc-hotplug.h"
   3 #include "hw/mem/pc-dimm.h"
   4 #include "hw/boards.h"
   5 #include "trace.h"
   6 #include "qapi-event.h"
   7
   8 static ACPIOSTInfo *acpi_memory_device_status(int slot, MemStatus *mdev)
   9 {
  10     ACPIOSTInfo *info = g_new0(ACPIOSTInfo, 1);
  11
  12     info->slot_type = ACPI_SLOT_TYPE_DIMM;
  13     info->slot = g_strdup_printf("%d", slot);
  14     info->source = mdev->ost_event;
  15     info->status = mdev->ost_status;
  16     if (mdev->dimm) {
  17         DeviceState *dev = DEVICE(mdev->dimm);
  18         if (dev->id) {
  19             info->device = g_strdup(dev->id);
  20             info->has_device = true;
  21         }
  22     }
  23     return info;
  24 }
  25
  26 void acpi_memory_ospm_status(MemHotplugState *mem_st, ACPIOSTInfoList ***list)
  27 {
  28     int i;
  29
  30     for (i = 0; i < mem_st->dev_count; i++) {
  31         ACPIOSTInfoList *elem = g_new0(ACPIOSTInfoList, 1);
  32         elem->value = acpi_memory_device_status(i, &mem_st->devs[i]);
  33         elem->next = NULL;
  34         **list = elem;
  35         *list = &elem->next;
  36     }
  37 }
  38
  39 static uint64_t acpi_memory_hotplug_read(void *opaque, hwaddr addr,
  40                                          unsigned int size)
  41 {
  42     uint32_t val = 0;
  43     MemHotplugState *mem_st = opaque;
  44     MemStatus *mdev;
  45     Object *o;
  46
  47     if (mem_st->selector >= mem_st->dev_count) {
  48         trace_mhp_acpi_invalid_slot_selected(mem_st->selector);
  49         return 0;
  50     }
  51
  52     mdev = &mem_st->devs[mem_st->selector];
  53     o = OBJECT(mdev->dimm);
  54     switch (addr) {
  55     case 0x0: /* Lo part of phys address where DIMM is mapped */
  56         val = o ? object_property_get_int(o, PC_DIMM_ADDR_PROP, NULL) : 0;
  57         trace_mhp_acpi_read_addr_lo(mem_st->selector, val);
  58         break;
  59     case 0x4: /* Hi part of phys address where DIMM is mapped */
  60         val = o ? object_property_get_int(o, PC_DIMM_ADDR_PROP, NULL) >> 32 : 0;
  61         trace_mhp_acpi_read_addr_hi(mem_st->selector, val);
  62         break;
  63     case 0x8: /* Lo part of DIMM size */
  64         val = o ? object_property_get_int(o, PC_DIMM_SIZE_PROP, NULL) : 0;
  65         trace_mhp_acpi_read_size_lo(mem_st->selector, val);
  66         break;
  67     case 0xc: /* Hi part of DIMM size */
  68         val = o ? object_property_get_int(o, PC_DIMM_SIZE_PROP, NULL) >> 32 : 0;
  69         trace_mhp_acpi_read_size_hi(mem_st->selector, val);
  70         break;
  71     case 0x10: /* node proximity for _PXM method */
  72         val = o ? object_property_get_int(o, PC_DIMM_NODE_PROP, NULL) : 0;
  73         trace_mhp_acpi_read_pxm(mem_st->selector, val);
  74         break;
  75     case 0x14: /* pack and return is_* fields */
  76         val |= mdev->is_enabled   ? 1 : 0;
  77         val |= mdev->is_inserting ? 2 : 0;
  78         val |= mdev->is_removing  ? 4 : 0;
  79         trace_mhp_acpi_read_flags(mem_st->selector, val);
  80         break;
  81     default:
  82         val = ~0;
  83         break;
  84     }
  85     return val;
  86 }
  87
  88 static void acpi_memory_hotplug_write(void *opaque, hwaddr addr, uint64_t data,
  89                                       unsigned int size)
  90 {
  91     MemHotplugState *mem_st = opaque;
  92     MemStatus *mdev;
  93     ACPIOSTInfo *info;
  94
  95     if (!mem_st->dev_count) {
  96         return;
  97     }
  98
  99     if (addr) {
 100         if (mem_st->selector >= mem_st->dev_count) {
 101             trace_mhp_acpi_invalid_slot_selected(mem_st->selector);
 102             return;
 103         }
 104     }
 105
 106     switch (addr) {
 107     case 0x0: /* DIMM slot selector */
 108         mem_st->selector = data;
 109         trace_mhp_acpi_write_slot(mem_st->selector);
 110         break;
 111     case 0x4: /* _OST event  */
 112         mdev = &mem_st->devs[mem_st->selector];
 113         if (data == 1) {
 114             /* TODO: handle device insert OST event */
 115         } else if (data == 3) {
 116             /* TODO: handle device remove OST event */
 117         }
 118         mdev->ost_event = data;
 119         trace_mhp_acpi_write_ost_ev(mem_st->selector, mdev->ost_event);
 120         break;
 121     case 0x8: /* _OST status */
 122         mdev = &mem_st->devs[mem_st->selector];
 123         mdev->ost_status = data;
 124         trace_mhp_acpi_write_ost_status(mem_st->selector, mdev->ost_status);
 125         /* TODO: implement memory removal on guest signal */
 126
 127         info = acpi_memory_device_status(mem_st->selector, mdev);
 128         qapi_event_send_acpi_device_ost(info, &error_abort);
 129         qapi_free_ACPIOSTInfo(info);
 130         break;
 131     case 0x14:
 132         mdev = &mem_st->devs[mem_st->selector];
 133         if (data & 2) { /* clear insert event */
 134             mdev->is_inserting  = false;
 135             trace_mhp_acpi_clear_insert_evt(mem_st->selector);
 136         }
 137         break;
 138     }
 139
 140 }
 141 static const MemoryRegionOps acpi_memory_hotplug_ops = {
 142     .read = acpi_memory_hotplug_read,
 143     .write = acpi_memory_hotplug_write,
 144     .endianness = DEVICE_LITTLE_ENDIAN,
 145     .valid = {
 146         .min_access_size = 1,
 147         .max_access_size = 4,
 148     },
 149 };
 150
 151 void acpi_memory_hotplug_init(MemoryRegion *as, Object *owner,
 152                               MemHotplugState *state)
 153 {
 154     MachineState *machine = MACHINE(qdev_get_machine());
 155
 156     state->dev_count = machine->ram_slots;
 157     if (!state->dev_count) {
 158         return;
 159     }
 160
 161     state->devs = g_malloc0(sizeof(*state->devs) * state->dev_count);
 162     memory_region_init_io(&state->io, owner, &acpi_memory_hotplug_ops, state,
 163                           "acpi-mem-hotplug", ACPI_MEMORY_HOTPLUG_IO_LEN);
 164     memory_region_add_subregion(as, ACPI_MEMORY_HOTPLUG_BASE, &state->io);
 165 }
 166
 167 /**
 168  * acpi_memory_slot_status:
 169  * @mem_st: memory hotplug state
 170  * @dev: device
 171  * @errp: set in case of an error
 172  *
 173  * Obtain a single memory slot status.
 174  *
 175  * This function will be called by memory unplug request cb and unplug cb.
 176  */
 177 static MemStatus *
 178 acpi_memory_slot_status(MemHotplugState *mem_st,
 179                         DeviceState *dev, Error **errp)
 180 {
 181     Error *local_err = NULL;
 182     int slot = object_property_get_int(OBJECT(dev), PC_DIMM_SLOT_PROP,
 183                                        &local_err);
 184
 185     if (local_err) {
 186         error_propagate(errp, local_err);
 187         return NULL;
 188     }
 189
 190     if (slot >= mem_st->dev_count) {
 191         char *dev_path = object_get_canonical_path(OBJECT(dev));
 192         error_setg(errp, "acpi_memory_slot_status: "
 193                    "device [%s] returned invalid memory slot[%d]",
 194                     dev_path, slot);
 195         g_free(dev_path);
 196         return NULL;
 197     }
 198
 199     return &mem_st->devs[slot];
 200 }
 201
 202 void acpi_memory_plug_cb(ACPIREGS *ar, qemu_irq irq, MemHotplugState *mem_st,
 203                          DeviceState *dev, Error **errp)
 204 {
 205     MemStatus *mdev;
 206
 207     mdev = acpi_memory_slot_status(mem_st, dev, errp);
 208     if (!mdev) {
 209         return;
 210     }
 211
 212     mdev->dimm = dev;
 213     mdev->is_enabled = true;
 214     mdev->is_inserting = true;
 215
 216     /* do ACPI magic */
 217     ar->gpe.sts[0] |= ACPI_MEMORY_HOTPLUG_STATUS;
 218     acpi_update_sci(ar, irq);
 219     return;
 220 }
 221
 222 void acpi_memory_unplug_request_cb(ACPIREGS *ar, qemu_irq irq,
 223                                    MemHotplugState *mem_st,
 224                                    DeviceState *dev, Error **errp)
 225 {
 226     MemStatus *mdev;
 227
 228     mdev = acpi_memory_slot_status(mem_st, dev, errp);
 229     if (!mdev) {
 230         return;
 231     }
 232
 233     mdev->is_removing = true;
 234
 235     /* Do ACPI magic */
 236     ar->gpe.sts[0] |= ACPI_MEMORY_HOTPLUG_STATUS;
 237     acpi_update_sci(ar, irq);
 238 }
 239
 240 static const VMStateDescription vmstate_memhp_sts = {
 241     .name = "memory hotplug device state",
 242     .version_id = 1,
 243     .minimum_version_id = 1,
 244     .minimum_version_id_old = 1,
 245     .fields      = (VMStateField[]) {
 246         VMSTATE_BOOL(is_enabled, MemStatus),
 247         VMSTATE_BOOL(is_inserting, MemStatus),
 248         VMSTATE_UINT32(ost_event, MemStatus),
 249         VMSTATE_UINT32(ost_status, MemStatus),
 250         VMSTATE_END_OF_LIST()
 251     }
 252 };
 253
 254 const VMStateDescription vmstate_memory_hotplug = {
 255     .name = "memory hotplug state",
 256     .version_id = 1,
 257     .minimum_version_id = 1,
 258     .minimum_version_id_old = 1,
 259     .fields      = (VMStateField[]) {
 260         VMSTATE_UINT32(selector, MemHotplugState),
 261         VMSTATE_STRUCT_VARRAY_POINTER_UINT32(devs, MemHotplugState, dev_count,
 262                                              vmstate_memhp_sts, MemStatus),
 263         VMSTATE_END_OF_LIST()
 264     }
 265 };