hw/acpi/piix4.c

   1 /*
   2  * ACPI implementation
   3  *
   4  * Copyright (c) 2006 Fabrice Bellard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License version 2 as published by the Free Software Foundation.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, see <http://www.gnu.org/licenses/>
  17  *
  18  * Contributions after 2012-01-13 are licensed under the terms of the
  19  * GNU GPL, version 2 or (at your option) any later version.
  20  */
  21 #include "hw/hw.h"
  22 #include "hw/i386/pc.h"
  23 #include "hw/isa/apm.h"
  24 #include "hw/i2c/pm_smbus.h"
  25 #include "hw/pci/pci.h"
  26 #include "hw/acpi/acpi.h"
  27 #include "sysemu/sysemu.h"
  28 #include "qemu/range.h"
  29 #include "exec/ioport.h"
  30 #include "hw/nvram/fw_cfg.h"
  31 #include "exec/address-spaces.h"
  32 #include "hw/acpi/piix4.h"
  33
  34 //#define DEBUG
  35
  36 #ifdef DEBUG
  37 # define PIIX4_DPRINTF(format, ...)     printf(format, ## __VA_ARGS__)
  38 #else
  39 # define PIIX4_DPRINTF(format, ...)     do { } while (0)
  40 #endif
  41
  42 #define GPE_BASE 0xafe0
  43 #define GPE_LEN 4
  44
  45 #define PCI_HOTPLUG_ADDR 0xae00
  46 #define PCI_HOTPLUG_SIZE 0x000f
  47 #define PCI_UP_BASE 0xae00
  48 #define PCI_DOWN_BASE 0xae04
  49 #define PCI_EJ_BASE 0xae08
  50 #define PCI_RMV_BASE 0xae0c
  51
  52 #define PIIX4_PROC_BASE 0xaf00
  53 #define PIIX4_PROC_LEN 32
  54
  55 #define PIIX4_PCI_HOTPLUG_STATUS 2
  56 #define PIIX4_CPU_HOTPLUG_STATUS 4
  57
  58 struct pci_status {
  59     uint32_t up; /* deprecated, maintained for migration compatibility */
  60     uint32_t down;
  61 };
  62
  63 typedef struct CPUStatus {
  64     uint8_t sts[PIIX4_PROC_LEN];
  65 } CPUStatus;
  66
  67 typedef struct PIIX4PMState {
  68     /*< private >*/
  69     PCIDevice parent_obj;
  70     /*< public >*/
  71
  72     MemoryRegion io;
  73     uint32_t io_base;
  74
  75     MemoryRegion io_gpe;
  76     MemoryRegion io_pci;
  77     MemoryRegion io_cpu;
  78     ACPIREGS ar;
  79
  80     APMState apm;
  81
  82     PMSMBus smb;
  83     uint32_t smb_io_base;
  84
  85     qemu_irq irq;
  86     qemu_irq smi_irq;
  87     int kvm_enabled;
  88     Notifier machine_ready;
  89     Notifier powerdown_notifier;
  90
  91     /* for pci hotplug */
  92     struct pci_status pci0_status;
  93     uint32_t pci0_hotplug_enable;
  94     uint32_t pci0_slot_device_present;
  95
  96     uint8_t disable_s3;
  97     uint8_t disable_s4;
  98     uint8_t s4_val;
  99
 100     CPUStatus gpe_cpu;
 101     Notifier cpu_added_notifier;
 102 } PIIX4PMState;
 103
 104 #define TYPE_PIIX4_PM "PIIX4_PM"
 105
 106 #define PIIX4_PM(obj) \
 107     OBJECT_CHECK(PIIX4PMState, (obj), TYPE_PIIX4_PM)
 108
 109 static void piix4_acpi_system_hot_add_init(MemoryRegion *parent,
 110                                            PCIBus *bus, PIIX4PMState *s);
 111
 112 #define ACPI_ENABLE 0xf1
 113 #define ACPI_DISABLE 0xf0
 114
 115 static void pm_tmr_timer(ACPIREGS *ar)
 116 {
 117     PIIX4PMState *s = container_of(ar, PIIX4PMState, ar);
 118     acpi_update_sci(&s->ar, s->irq);
 119 }
 120
 121 static void apm_ctrl_changed(uint32_t val, void *arg)
 122 {
 123     PIIX4PMState *s = arg;
 124     PCIDevice *d = PCI_DEVICE(s);
 125
 126     /* ACPI specs 3.0, 4.7.2.5 */
 127     acpi_pm1_cnt_update(&s->ar, val == ACPI_ENABLE, val == ACPI_DISABLE);
 128
 129     if (d->config[0x5b] & (1 << 1)) {
 130         if (s->smi_irq) {
 131             qemu_irq_raise(s->smi_irq);
 132         }
 133     }
 134 }
 135
 136 static void pm_io_space_update(PIIX4PMState *s)
 137 {
 138     PCIDevice *d = PCI_DEVICE(s);
 139
 140     s->io_base = le32_to_cpu(*(uint32_t *)(d->config + 0x40));
 141     s->io_base &= 0xffc0;
 142
 143     memory_region_transaction_begin();
 144     memory_region_set_enabled(&s->io, d->config[0x80] & 1);
 145     memory_region_set_address(&s->io, s->io_base);
 146     memory_region_transaction_commit();
 147 }
 148
 149 static void smbus_io_space_update(PIIX4PMState *s)
 150 {
 151     PCIDevice *d = PCI_DEVICE(s);
 152
 153     s->smb_io_base = le32_to_cpu(*(uint32_t *)(d->config + 0x90));
 154     s->smb_io_base &= 0xffc0;
 155
 156     memory_region_transaction_begin();
 157     memory_region_set_enabled(&s->smb.io, d->config[0xd2] & 1);
 158     memory_region_set_address(&s->smb.io, s->smb_io_base);
 159     memory_region_transaction_commit();
 160 }
 161
 162 static void pm_write_config(PCIDevice *d,
 163                             uint32_t address, uint32_t val, int len)
 164 {
 165     pci_default_write_config(d, address, val, len);
 166     if (range_covers_byte(address, len, 0x80) ||
 167         ranges_overlap(address, len, 0x40, 4)) {
 168         pm_io_space_update((PIIX4PMState *)d);
 169     }
 170     if (range_covers_byte(address, len, 0xd2) ||
 171         ranges_overlap(address, len, 0x90, 4)) {
 172         smbus_io_space_update((PIIX4PMState *)d);
 173     }
 174 }
 175
 176 static void vmstate_pci_status_pre_save(void *opaque)
 177 {
 178     struct pci_status *pci0_status = opaque;
 179     PIIX4PMState *s = container_of(pci0_status, PIIX4PMState, pci0_status);
 180
 181     /* We no longer track up, so build a safe value for migrating
 182      * to a version that still does... of course these might get lost
 183      * by an old buggy implementation, but we try. */
 184     pci0_status->up = s->pci0_slot_device_present & s->pci0_hotplug_enable;
 185 }
 186
 187 static int vmstate_acpi_post_load(void *opaque, int version_id)
 188 {
 189     PIIX4PMState *s = opaque;
 190
 191     pm_io_space_update(s);
 192     return 0;
 193 }
 194
 195 #define VMSTATE_GPE_ARRAY(_field, _state)                            \
 196  {                                                                   \
 197      .name       = (stringify(_field)),                              \
 198      .version_id = 0,                                                \
 199      .info       = &vmstate_info_uint16,                             \
 200      .size       = sizeof(uint16_t),                                 \
 201      .flags      = VMS_SINGLE | VMS_POINTER,                         \
 202      .offset     = vmstate_offset_pointer(_state, _field, uint8_t),  \
 203  }
 204
 205 static const VMStateDescription vmstate_gpe = {
 206     .name = "gpe",
 207     .version_id = 1,
 208     .minimum_version_id = 1,
 209     .minimum_version_id_old = 1,
 210     .fields      = (VMStateField []) {
 211         VMSTATE_GPE_ARRAY(sts, ACPIGPE),
 212         VMSTATE_GPE_ARRAY(en, ACPIGPE),
 213         VMSTATE_END_OF_LIST()
 214     }
 215 };
 216
 217 static const VMStateDescription vmstate_pci_status = {
 218     .name = "pci_status",
 219     .version_id = 1,
 220     .minimum_version_id = 1,
 221     .minimum_version_id_old = 1,
 222     .pre_save = vmstate_pci_status_pre_save,
 223     .fields      = (VMStateField []) {
 224         VMSTATE_UINT32(up, struct pci_status),
 225         VMSTATE_UINT32(down, struct pci_status),
 226         VMSTATE_END_OF_LIST()
 227     }
 228 };
 229
 230 static int acpi_load_old(QEMUFile *f, void *opaque, int version_id)
 231 {
 232     PIIX4PMState *s = opaque;
 233     int ret, i;
 234     uint16_t temp;
 235
 236     ret = pci_device_load(PCI_DEVICE(s), f);
 237     if (ret < 0) {
 238         return ret;
 239     }
 240     qemu_get_be16s(f, &s->ar.pm1.evt.sts);
 241     qemu_get_be16s(f, &s->ar.pm1.evt.en);
 242     qemu_get_be16s(f, &s->ar.pm1.cnt.cnt);
 243
 244     ret = vmstate_load_state(f, &vmstate_apm, &s->apm, 1);
 245     if (ret) {
 246         return ret;
 247     }
 248
 249     timer_get(f, s->ar.tmr.timer);
 250     qemu_get_sbe64s(f, &s->ar.tmr.overflow_time);
 251
 252     qemu_get_be16s(f, (uint16_t *)s->ar.gpe.sts);
 253     for (i = 0; i < 3; i++) {
 254         qemu_get_be16s(f, &temp);
 255     }
 256
 257     qemu_get_be16s(f, (uint16_t *)s->ar.gpe.en);
 258     for (i = 0; i < 3; i++) {
 259         qemu_get_be16s(f, &temp);
 260     }
 261
 262     ret = vmstate_load_state(f, &vmstate_pci_status, &s->pci0_status, 1);
 263     return ret;
 264 }
 265
 266 /* qemu-kvm 1.2 uses version 3 but advertised as 2
 267  * To support incoming qemu-kvm 1.2 migration, change version_id
 268  * and minimum_version_id to 2 below (which breaks migration from
 269  * qemu 1.2).
 270  *
 271  */
 272 static const VMStateDescription vmstate_acpi = {
 273     .name = "piix4_pm",
 274     .version_id = 3,
 275     .minimum_version_id = 3,
 276     .minimum_version_id_old = 1,
 277     .load_state_old = acpi_load_old,
 278     .post_load = vmstate_acpi_post_load,
 279     .fields      = (VMStateField []) {
 280         VMSTATE_PCI_DEVICE(parent_obj, PIIX4PMState),
 281         VMSTATE_UINT16(ar.pm1.evt.sts, PIIX4PMState),
 282         VMSTATE_UINT16(ar.pm1.evt.en, PIIX4PMState),
 283         VMSTATE_UINT16(ar.pm1.cnt.cnt, PIIX4PMState),
 284         VMSTATE_STRUCT(apm, PIIX4PMState, 0, vmstate_apm, APMState),
 285         VMSTATE_TIMER(ar.tmr.timer, PIIX4PMState),
 286         VMSTATE_INT64(ar.tmr.overflow_time, PIIX4PMState),
 287         VMSTATE_STRUCT(ar.gpe, PIIX4PMState, 2, vmstate_gpe, ACPIGPE),
 288         VMSTATE_STRUCT(pci0_status, PIIX4PMState, 2, vmstate_pci_status,
 289                        struct pci_status),
 290         VMSTATE_END_OF_LIST()
 291     }
 292 };
 293
 294 static void acpi_piix_eject_slot(PIIX4PMState *s, unsigned slots)
 295 {
 296     BusChild *kid, *next;
 297     BusState *bus = qdev_get_parent_bus(DEVICE(s));
 298     int slot = ffs(slots) - 1;
 299     bool slot_free = true;
 300
 301     /* Mark request as complete */
 302     s->pci0_status.down &= ~(1U << slot);
 303
 304     QTAILQ_FOREACH_SAFE(kid, &bus->children, sibling, next) {
 305         DeviceState *qdev = kid->child;
 306         PCIDevice *dev = PCI_DEVICE(qdev);
 307         PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(dev);
 308         if (PCI_SLOT(dev->devfn) == slot) {
 309             if (pc->no_hotplug) {
 310                 slot_free = false;
 311             } else {
 312                 object_unparent(OBJECT(qdev));
 313             }
 314         }
 315     }
 316     if (slot_free) {
 317         s->pci0_slot_device_present &= ~(1U << slot);
 318     }
 319 }
 320
 321 static void piix4_update_hotplug(PIIX4PMState *s)
 322 {
 323     BusState *bus = qdev_get_parent_bus(DEVICE(s));
 324     BusChild *kid, *next;
 325
 326     /* Execute any pending removes during reset */
 327     while (s->pci0_status.down) {
 328         acpi_piix_eject_slot(s, s->pci0_status.down);
 329     }
 330
 331     s->pci0_hotplug_enable = ~0;
 332     s->pci0_slot_device_present = 0;
 333
 334     QTAILQ_FOREACH_SAFE(kid, &bus->children, sibling, next) {
 335         DeviceState *qdev = kid->child;
 336         PCIDevice *pdev = PCI_DEVICE(qdev);
 337         PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(pdev);
 338         int slot = PCI_SLOT(pdev->devfn);
 339
 340         if (pc->no_hotplug) {
 341             s->pci0_hotplug_enable &= ~(1U << slot);
 342         }
 343
 344         s->pci0_slot_device_present |= (1U << slot);
 345     }
 346 }
 347
 348 static void piix4_reset(void *opaque)
 349 {
 350     PIIX4PMState *s = opaque;
 351     PCIDevice *d = PCI_DEVICE(s);
 352     uint8_t *pci_conf = d->config;
 353
 354     pci_conf[0x58] = 0;
 355     pci_conf[0x59] = 0;
 356     pci_conf[0x5a] = 0;
 357     pci_conf[0x5b] = 0;
 358
 359     pci_conf[0x40] = 0x01; /* PM io base read only bit */
 360     pci_conf[0x80] = 0;
 361
 362     if (s->kvm_enabled) {
 363         /* Mark SMM as already inited (until KVM supports SMM). */
 364         pci_conf[0x5B] = 0x02;
 365     }
 366     pm_io_space_update(s);
 367     piix4_update_hotplug(s);
 368 }
 369
 370 static void piix4_pm_powerdown_req(Notifier *n, void *opaque)
 371 {
 372     PIIX4PMState *s = container_of(n, PIIX4PMState, powerdown_notifier);
 373
 374     assert(s != NULL);
 375     acpi_pm1_evt_power_down(&s->ar);
 376 }
 377
 378 static void piix4_pm_machine_ready(Notifier *n, void *opaque)
 379 {
 380     PIIX4PMState *s = container_of(n, PIIX4PMState, machine_ready);
 381     PCIDevice *d = PCI_DEVICE(s);
 382     MemoryRegion *io_as = pci_address_space_io(d);
 383     uint8_t *pci_conf;
 384
 385     pci_conf = d->config;
 386     pci_conf[0x5f] = 0x10 |
 387         (memory_region_present(io_as, 0x378) ? 0x80 : 0);
 388     pci_conf[0x63] = 0x60;
 389     pci_conf[0x67] = (memory_region_present(io_as, 0x3f8) ? 0x08 : 0) |
 390         (memory_region_present(io_as, 0x2f8) ? 0x90 : 0);
 391 }
 392
 393 static void piix4_pm_add_propeties(PIIX4PMState *s)
 394 {
 395     static const uint8_t acpi_enable_cmd = ACPI_ENABLE;
 396     static const uint8_t acpi_disable_cmd = ACPI_DISABLE;
 397     static const uint32_t gpe0_blk = GPE_BASE;
 398     static const uint32_t gpe0_blk_len = GPE_LEN;
 399     static const uint16_t sci_int = 9;
 400
 401     object_property_add_uint8_ptr(OBJECT(s), ACPI_PM_PROP_ACPI_ENABLE_CMD,
 402                                   &acpi_enable_cmd, NULL);
 403     object_property_add_uint8_ptr(OBJECT(s), ACPI_PM_PROP_ACPI_DISABLE_CMD,
 404                                   &acpi_disable_cmd, NULL);
 405     object_property_add_uint32_ptr(OBJECT(s), ACPI_PM_PROP_GPE0_BLK,
 406                                   &gpe0_blk, NULL);
 407     object_property_add_uint32_ptr(OBJECT(s), ACPI_PM_PROP_GPE0_BLK_LEN,
 408                                   &gpe0_blk_len, NULL);
 409     object_property_add_uint16_ptr(OBJECT(s), ACPI_PM_PROP_SCI_INT,
 410                                   &sci_int, NULL);
 411     object_property_add_uint32_ptr(OBJECT(s), ACPI_PM_PROP_PM_IO_BASE,
 412                                   &s->io_base, NULL);
 413 }
 414
 415 static int piix4_pm_initfn(PCIDevice *dev)
 416 {
 417     PIIX4PMState *s = PIIX4_PM(dev);
 418     uint8_t *pci_conf;
 419
 420     pci_conf = dev->config;
 421     pci_conf[0x06] = 0x80;
 422     pci_conf[0x07] = 0x02;
 423     pci_conf[0x09] = 0x00;
 424     pci_conf[0x3d] = 0x01; // interrupt pin 1
 425
 426     /* APM */
 427     apm_init(dev, &s->apm, apm_ctrl_changed, s);
 428
 429     if (s->kvm_enabled) {
 430         /* Mark SMM as already inited to prevent SMM from running.  KVM does not
 431          * support SMM mode. */
 432         pci_conf[0x5B] = 0x02;
 433     }
 434
 435     /* XXX: which specification is used ? The i82731AB has different
 436        mappings */
 437     pci_conf[0x90] = s->smb_io_base | 1;
 438     pci_conf[0x91] = s->smb_io_base >> 8;
 439     pci_conf[0xd2] = 0x09;
 440     pm_smbus_init(DEVICE(dev), &s->smb);
 441     memory_region_set_enabled(&s->smb.io, pci_conf[0xd2] & 1);
 442     memory_region_add_subregion(pci_address_space_io(dev),
 443                                 s->smb_io_base, &s->smb.io);
 444
 445     memory_region_init(&s->io, OBJECT(s), "piix4-pm", 64);
 446     memory_region_set_enabled(&s->io, false);
 447     memory_region_add_subregion(pci_address_space_io(dev),
 448                                 0, &s->io);
 449
 450     acpi_pm_tmr_init(&s->ar, pm_tmr_timer, &s->io);
 451     acpi_pm1_evt_init(&s->ar, pm_tmr_timer, &s->io);
 452     acpi_pm1_cnt_init(&s->ar, &s->io, s->s4_val);
 453     acpi_gpe_init(&s->ar, GPE_LEN);
 454
 455     s->powerdown_notifier.notify = piix4_pm_powerdown_req;
 456     qemu_register_powerdown_notifier(&s->powerdown_notifier);
 457
 458     s->machine_ready.notify = piix4_pm_machine_ready;
 459     qemu_add_machine_init_done_notifier(&s->machine_ready);
 460     qemu_register_reset(piix4_reset, s);
 461
 462     piix4_acpi_system_hot_add_init(pci_address_space_io(dev), dev->bus, s);
 463
 464     piix4_pm_add_propeties(s);
 465     return 0;
 466 }
 467
 468 Object *piix4_pm_find(void)
 469 {
 470     bool ambig;
 471     Object *o = object_resolve_path_type("", TYPE_PIIX4_PM, &ambig);
 472
 473     if (ambig || !o) {
 474         return NULL;
 475     }
 476     return o;
 477 }
 478
 479 i2c_bus *piix4_pm_init(PCIBus *bus, int devfn, uint32_t smb_io_base,
 480                        qemu_irq sci_irq, qemu_irq smi_irq,
 481                        int kvm_enabled, FWCfgState *fw_cfg)
 482 {
 483     DeviceState *dev;
 484     PIIX4PMState *s;
 485
 486     dev = DEVICE(pci_create(bus, devfn, TYPE_PIIX4_PM));
 487     qdev_prop_set_uint32(dev, "smb_io_base", smb_io_base);
 488
 489     s = PIIX4_PM(dev);
 490     s->irq = sci_irq;
 491     s->smi_irq = smi_irq;
 492     s->kvm_enabled = kvm_enabled;
 493
 494     qdev_init_nofail(dev);
 495
 496     if (fw_cfg) {
 497         uint8_t suspend[6] = {128, 0, 0, 129, 128, 128};
 498         suspend[3] = 1 | ((!s->disable_s3) << 7);
 499         suspend[4] = s->s4_val | ((!s->disable_s4) << 7);
 500
 501         fw_cfg_add_file(fw_cfg, "etc/system-states", g_memdup(suspend, 6), 6);
 502     }
 503
 504     return s->smb.smbus;
 505 }
 506
 507 static Property piix4_pm_properties[] = {
 508     DEFINE_PROP_UINT32("smb_io_base", PIIX4PMState, smb_io_base, 0),
 509     DEFINE_PROP_UINT8(ACPI_PM_PROP_S3_DISABLED, PIIX4PMState, disable_s3, 0),
 510     DEFINE_PROP_UINT8(ACPI_PM_PROP_S4_DISABLED, PIIX4PMState, disable_s4, 0),
 511     DEFINE_PROP_UINT8(ACPI_PM_PROP_S4_VAL, PIIX4PMState, s4_val, 2),
 512     DEFINE_PROP_END_OF_LIST(),
 513 };
 514
 515 static void piix4_pm_class_init(ObjectClass *klass, void *data)
 516 {
 517     DeviceClass *dc = DEVICE_CLASS(klass);
 518     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
 519
 520     k->no_hotplug = 1;
 521     k->init = piix4_pm_initfn;
 522     k->config_write = pm_write_config;
 523     k->vendor_id = PCI_VENDOR_ID_INTEL;
 524     k->device_id = PCI_DEVICE_ID_INTEL_82371AB_3;
 525     k->revision = 0x03;
 526     k->class_id = PCI_CLASS_BRIDGE_OTHER;
 527     dc->desc = "PM";
 528     dc->vmsd = &vmstate_acpi;
 529     dc->props = piix4_pm_properties;
 530     /*
 531      * Reason: part of PIIX4 southbridge, needs to be wired up,
 532      * e.g. by mips_malta_init()
 533      */
 534     dc->cannot_instantiate_with_device_add_yet = true;
 535 }
 536
 537 static const TypeInfo piix4_pm_info = {
 538     .name          = TYPE_PIIX4_PM,
 539     .parent        = TYPE_PCI_DEVICE,
 540     .instance_size = sizeof(PIIX4PMState),
 541     .class_init    = piix4_pm_class_init,
 542 };
 543
 544 static void piix4_pm_register_types(void)
 545 {
 546     type_register_static(&piix4_pm_info);
 547 }
 548
 549 type_init(piix4_pm_register_types)
 550
 551 static uint64_t gpe_readb(void *opaque, hwaddr addr, unsigned width)
 552 {
 553     PIIX4PMState *s = opaque;
 554     uint32_t val = acpi_gpe_ioport_readb(&s->ar, addr);
 555
 556     PIIX4_DPRINTF("gpe read %" HWADDR_PRIx " == %" PRIu32 "\n", addr, val);
 557     return val;
 558 }
 559
 560 static void gpe_writeb(void *opaque, hwaddr addr, uint64_t val,
 561                        unsigned width)
 562 {
 563     PIIX4PMState *s = opaque;
 564
 565     acpi_gpe_ioport_writeb(&s->ar, addr, val);
 566     acpi_update_sci(&s->ar, s->irq);
 567
 568     PIIX4_DPRINTF("gpe write %" HWADDR_PRIx " <== %" PRIu64 "\n", addr, val);
 569 }
 570
 571 static const MemoryRegionOps piix4_gpe_ops = {
 572     .read = gpe_readb,
 573     .write = gpe_writeb,
 574     .valid.min_access_size = 1,
 575     .valid.max_access_size = 4,
 576     .impl.min_access_size = 1,
 577     .impl.max_access_size = 1,
 578     .endianness = DEVICE_LITTLE_ENDIAN,
 579 };
 580
 581 static uint64_t pci_read(void *opaque, hwaddr addr, unsigned int size)
 582 {
 583     PIIX4PMState *s = opaque;
 584     uint32_t val = 0;
 585
 586     switch (addr) {
 587     case PCI_UP_BASE - PCI_HOTPLUG_ADDR:
 588         /* Manufacture an "up" value to cause a device check on any hotplug
 589          * slot with a device.  Extra device checks are harmless. */
 590         val = s->pci0_slot_device_present & s->pci0_hotplug_enable;
 591         PIIX4_DPRINTF("pci_up_read %" PRIu32 "\n", val);
 592         break;
 593     case PCI_DOWN_BASE - PCI_HOTPLUG_ADDR:
 594         val = s->pci0_status.down;
 595         PIIX4_DPRINTF("pci_down_read %" PRIu32 "\n", val);
 596         break;
 597     case PCI_EJ_BASE - PCI_HOTPLUG_ADDR:
 598         /* No feature defined yet */
 599         PIIX4_DPRINTF("pci_features_read %" PRIu32 "\n", val);
 600         break;
 601     case PCI_RMV_BASE - PCI_HOTPLUG_ADDR:
 602         val = s->pci0_hotplug_enable;
 603         break;
 604     default:
 605         break;
 606     }
 607
 608     return val;
 609 }
 610
 611 static void pci_write(void *opaque, hwaddr addr, uint64_t data,
 612                       unsigned int size)
 613 {
 614     switch (addr) {
 615     case PCI_EJ_BASE - PCI_HOTPLUG_ADDR:
 616         acpi_piix_eject_slot(opaque, (uint32_t)data);
 617         PIIX4_DPRINTF("pciej write %" HWADDR_PRIx " <== %" PRIu64 "\n",
 618                       addr, data);
 619         break;
 620     default:
 621         break;
 622     }
 623 }
 624
 625 static const MemoryRegionOps piix4_pci_ops = {
 626     .read = pci_read,
 627     .write = pci_write,
 628     .endianness = DEVICE_LITTLE_ENDIAN,
 629     .valid = {
 630         .min_access_size = 4,
 631         .max_access_size = 4,
 632     },
 633 };
 634
 635 static uint64_t cpu_status_read(void *opaque, hwaddr addr, unsigned int size)
 636 {
 637     PIIX4PMState *s = opaque;
 638     CPUStatus *cpus = &s->gpe_cpu;
 639     uint64_t val = cpus->sts[addr];
 640
 641     return val;
 642 }
 643
 644 static void cpu_status_write(void *opaque, hwaddr addr, uint64_t data,
 645                              unsigned int size)
 646 {
 647     /* TODO: implement VCPU removal on guest signal that CPU can be removed */
 648 }
 649
 650 static const MemoryRegionOps cpu_hotplug_ops = {
 651     .read = cpu_status_read,
 652     .write = cpu_status_write,
 653     .endianness = DEVICE_LITTLE_ENDIAN,
 654     .valid = {
 655         .min_access_size = 1,
 656         .max_access_size = 1,
 657     },
 658 };
 659
 660 typedef enum {
 661     PLUG,
 662     UNPLUG,
 663 } HotplugEventType;
 664
 665 static void piix4_cpu_hotplug_req(PIIX4PMState *s, CPUState *cpu,
 666                                   HotplugEventType action)
 667 {
 668     CPUStatus *g = &s->gpe_cpu;
 669     ACPIGPE *gpe = &s->ar.gpe;
 670     CPUClass *k = CPU_GET_CLASS(cpu);
 671     int64_t cpu_id;
 672
 673     assert(s != NULL);
 674
 675     *gpe->sts = *gpe->sts | PIIX4_CPU_HOTPLUG_STATUS;
 676     cpu_id = k->get_arch_id(CPU(cpu));
 677     if (action == PLUG) {
 678         g->sts[cpu_id / 8] |= (1 << (cpu_id % 8));
 679     } else {
 680         g->sts[cpu_id / 8] &= ~(1 << (cpu_id % 8));
 681     }
 682     acpi_update_sci(&s->ar, s->irq);
 683 }
 684
 685 static void piix4_cpu_added_req(Notifier *n, void *opaque)
 686 {
 687     PIIX4PMState *s = container_of(n, PIIX4PMState, cpu_added_notifier);
 688
 689     piix4_cpu_hotplug_req(s, CPU(opaque), PLUG);
 690 }
 691
 692 static int piix4_device_hotplug(DeviceState *qdev, PCIDevice *dev,
 693                                 PCIHotplugState state);
 694
 695 static void piix4_acpi_system_hot_add_init(MemoryRegion *parent,
 696                                            PCIBus *bus, PIIX4PMState *s)
 697 {
 698     CPUState *cpu;
 699
 700     memory_region_init_io(&s->io_gpe, OBJECT(s), &piix4_gpe_ops, s,
 701                           "acpi-gpe0", GPE_LEN);
 702     memory_region_add_subregion(parent, GPE_BASE, &s->io_gpe);
 703
 704     memory_region_init_io(&s->io_pci, OBJECT(s), &piix4_pci_ops, s,
 705                           "acpi-pci-hotplug", PCI_HOTPLUG_SIZE);
 706     memory_region_add_subregion(parent, PCI_HOTPLUG_ADDR,
 707                                 &s->io_pci);
 708     pci_bus_hotplug(bus, piix4_device_hotplug, DEVICE(s));
 709
 710     CPU_FOREACH(cpu) {
 711         CPUClass *cc = CPU_GET_CLASS(cpu);
 712         int64_t id = cc->get_arch_id(cpu);
 713
 714         g_assert((id / 8) < PIIX4_PROC_LEN);
 715         s->gpe_cpu.sts[id / 8] |= (1 << (id % 8));
 716     }
 717     memory_region_init_io(&s->io_cpu, OBJECT(s), &cpu_hotplug_ops, s,
 718                           "acpi-cpu-hotplug", PIIX4_PROC_LEN);
 719     memory_region_add_subregion(parent, PIIX4_PROC_BASE, &s->io_cpu);
 720     s->cpu_added_notifier.notify = piix4_cpu_added_req;
 721     qemu_register_cpu_added_notifier(&s->cpu_added_notifier);
 722 }
 723
 724 static void enable_device(PIIX4PMState *s, int slot)
 725 {
 726     s->ar.gpe.sts[0] |= PIIX4_PCI_HOTPLUG_STATUS;
 727     s->pci0_slot_device_present |= (1U << slot);
 728 }
 729
 730 static void disable_device(PIIX4PMState *s, int slot)
 731 {
 732     s->ar.gpe.sts[0] |= PIIX4_PCI_HOTPLUG_STATUS;
 733     s->pci0_status.down |= (1U << slot);
 734 }
 735
 736 static int piix4_device_hotplug(DeviceState *qdev, PCIDevice *dev,
 737                                 PCIHotplugState state)
 738 {
 739     int slot = PCI_SLOT(dev->devfn);
 740     PIIX4PMState *s = PIIX4_PM(qdev);
 741
 742     /* Don't send event when device is enabled during qemu machine creation:
 743      * it is present on boot, no hotplug event is necessary. We do send an
 744      * event when the device is disabled later. */
 745     if (state == PCI_COLDPLUG_ENABLED) {
 746         s->pci0_slot_device_present |= (1U << slot);
 747         return 0;
 748     }
 749
 750     if (state == PCI_HOTPLUG_ENABLED) {
 751         enable_device(s, slot);
 752     } else {
 753         disable_device(s, slot);
 754     }
 755
 756     acpi_update_sci(&s->ar, s->irq);
 757
 758     return 0;
 759 }