piix4.c 21 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 * ACPI implementation
 *
 * Copyright (c) 2006 Fabrice Bellard
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License version 2 as published by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <http://www.gnu.org/licenses/>
17 18 19
 *
 * Contributions after 2012-01-13 are licensed under the terms of the
 * GNU GPL, version 2 or (at your option) any later version.
20
 */
21
#include "hw/hw.h"
Paolo Bonzini's avatar
Paolo Bonzini committed
22 23 24
#include "hw/i386/pc.h"
#include "hw/isa/apm.h"
#include "hw/i2c/pm_smbus.h"
25
#include "hw/pci/pci.h"
Paolo Bonzini's avatar
Paolo Bonzini committed
26
#include "hw/acpi/acpi.h"
27
#include "sysemu/sysemu.h"
28
#include "qemu/range.h"
29
#include "exec/ioport.h"
Paolo Bonzini's avatar
Paolo Bonzini committed
30
#include "hw/nvram/fw_cfg.h"
31
#include "exec/address-spaces.h"
32 33 34

//#define DEBUG

35 36 37 38 39 40
#ifdef DEBUG
# define PIIX4_DPRINTF(format, ...)     printf(format, ## __VA_ARGS__)
#else
# define PIIX4_DPRINTF(format, ...)     do { } while (0)
#endif

41
#define GPE_BASE 0xafe0
42
#define GPE_LEN 4
43 44 45

#define PCI_HOTPLUG_ADDR 0xae00
#define PCI_HOTPLUG_SIZE 0x000f
46 47
#define PCI_UP_BASE 0xae00
#define PCI_DOWN_BASE 0xae04
48
#define PCI_EJ_BASE 0xae08
49
#define PCI_RMV_BASE 0xae0c
50

51 52 53
#define PIIX4_PROC_BASE 0xaf00
#define PIIX4_PROC_LEN 32

54
#define PIIX4_PCI_HOTPLUG_STATUS 2
55
#define PIIX4_CPU_HOTPLUG_STATUS 4
56

57
struct pci_status {
58
    uint32_t up; /* deprecated, maintained for migration compatibility */
59 60 61
    uint32_t down;
};

62 63 64 65
typedef struct CPUStatus {
    uint8_t sts[PIIX4_PROC_LEN];
} CPUStatus;

66
typedef struct PIIX4PMState {
67 68 69
    /*< private >*/
    PCIDevice parent_obj;
    /*< public >*/
70

71
    MemoryRegion io;
72
    MemoryRegion io_gpe;
73
    MemoryRegion io_pci;
74
    MemoryRegion io_cpu;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
75
    ACPIREGS ar;
76 77 78 79

    APMState apm;

    PMSMBus smb;
Isaku Yamahata's avatar
Isaku Yamahata committed
80
    uint32_t smb_io_base;
81 82 83 84

    qemu_irq irq;
    qemu_irq smi_irq;
    int kvm_enabled;
85
    Notifier machine_ready;
86
    Notifier powerdown_notifier;
87 88 89

    /* for pci hotplug */
    struct pci_status pci0_status;
90
    uint32_t pci0_hotplug_enable;
91
    uint32_t pci0_slot_device_present;
92 93 94 95

    uint8_t disable_s3;
    uint8_t disable_s4;
    uint8_t s4_val;
96 97 98

    CPUStatus gpe_cpu;
    Notifier cpu_added_notifier;
99 100
} PIIX4PMState;

101 102 103 104 105
#define TYPE_PIIX4_PM "PIIX4_PM"

#define PIIX4_PM(obj) \
    OBJECT_CHECK(PIIX4PMState, (obj), TYPE_PIIX4_PM)

106 107
static void piix4_acpi_system_hot_add_init(MemoryRegion *parent,
                                           PCIBus *bus, PIIX4PMState *s);
108

109 110 111 112 113 114 115
#define ACPI_ENABLE 0xf1
#define ACPI_DISABLE 0xf0

static void pm_update_sci(PIIX4PMState *s)
{
    int sci_level, pmsts;

116
    pmsts = acpi_pm1_evt_get_sts(&s->ar);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
117
    sci_level = (((pmsts & s->ar.pm1.evt.en) &
118 119 120
                  (ACPI_BITMASK_RT_CLOCK_ENABLE |
                   ACPI_BITMASK_POWER_BUTTON_ENABLE |
                   ACPI_BITMASK_GLOBAL_LOCK_ENABLE |
121
                   ACPI_BITMASK_TIMER_ENABLE)) != 0) ||
122 123
        (((s->ar.gpe.sts[0] & s->ar.gpe.en[0]) &
          (PIIX4_PCI_HOTPLUG_STATUS | PIIX4_CPU_HOTPLUG_STATUS)) != 0);
124

125 126
    qemu_set_irq(s->irq, sci_level);
    /* schedule a timer interruption if needed */
Gerd Hoffmann's avatar
Gerd Hoffmann committed
127
    acpi_pm_tmr_update(&s->ar, (s->ar.pm1.evt.en & ACPI_BITMASK_TIMER_ENABLE) &&
128
                       !(pmsts & ACPI_BITMASK_TIMER_STATUS));
129 130
}

Gerd Hoffmann's avatar
Gerd Hoffmann committed
131
static void pm_tmr_timer(ACPIREGS *ar)
132
{
Gerd Hoffmann's avatar
Gerd Hoffmann committed
133
    PIIX4PMState *s = container_of(ar, PIIX4PMState, ar);
134 135 136 137 138 139
    pm_update_sci(s);
}

static void apm_ctrl_changed(uint32_t val, void *arg)
{
    PIIX4PMState *s = arg;
140
    PCIDevice *d = PCI_DEVICE(s);
141 142

    /* ACPI specs 3.0, 4.7.2.5 */
Gerd Hoffmann's avatar
Gerd Hoffmann committed
143
    acpi_pm1_cnt_update(&s->ar, val == ACPI_ENABLE, val == ACPI_DISABLE);
144

145
    if (d->config[0x5b] & (1 << 1)) {
146 147 148 149 150 151 152 153
        if (s->smi_irq) {
            qemu_irq_raise(s->smi_irq);
        }
    }
}

static void pm_io_space_update(PIIX4PMState *s)
{
154
    PCIDevice *d = PCI_DEVICE(s);
155 156
    uint32_t pm_io_base;

157
    pm_io_base = le32_to_cpu(*(uint32_t *)(d->config + 0x40));
158
    pm_io_base &= 0xffc0;
159

160
    memory_region_transaction_begin();
161
    memory_region_set_enabled(&s->io, d->config[0x80] & 1);
162 163
    memory_region_set_address(&s->io, pm_io_base);
    memory_region_transaction_commit();
164 165
}

Gerd Hoffmann's avatar
Gerd Hoffmann committed
166 167
static void smbus_io_space_update(PIIX4PMState *s)
{
168 169 170
    PCIDevice *d = PCI_DEVICE(s);

    s->smb_io_base = le32_to_cpu(*(uint32_t *)(d->config + 0x90));
Gerd Hoffmann's avatar
Gerd Hoffmann committed
171 172 173
    s->smb_io_base &= 0xffc0;

    memory_region_transaction_begin();
174
    memory_region_set_enabled(&s->smb.io, d->config[0xd2] & 1);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
175 176
    memory_region_set_address(&s->smb.io, s->smb_io_base);
    memory_region_transaction_commit();
177 178 179 180 181 182
}

static void pm_write_config(PCIDevice *d,
                            uint32_t address, uint32_t val, int len)
{
    pci_default_write_config(d, address, val, len);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
183 184
    if (range_covers_byte(address, len, 0x80) ||
        ranges_overlap(address, len, 0x40, 4)) {
185
        pm_io_space_update((PIIX4PMState *)d);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
186 187 188 189 190
    }
    if (range_covers_byte(address, len, 0xd2) ||
        ranges_overlap(address, len, 0x90, 4)) {
        smbus_io_space_update((PIIX4PMState *)d);
    }
191 192
}

193 194 195 196 197 198 199 200 201 202 203
static void vmstate_pci_status_pre_save(void *opaque)
{
    struct pci_status *pci0_status = opaque;
    PIIX4PMState *s = container_of(pci0_status, PIIX4PMState, pci0_status);

    /* We no longer track up, so build a safe value for migrating
     * to a version that still does... of course these might get lost
     * by an old buggy implementation, but we try. */
    pci0_status->up = s->pci0_slot_device_present & s->pci0_hotplug_enable;
}

204 205 206 207 208 209 210 211
static int vmstate_acpi_post_load(void *opaque, int version_id)
{
    PIIX4PMState *s = opaque;

    pm_io_space_update(s);
    return 0;
}

212 213 214 215 216 217
#define VMSTATE_GPE_ARRAY(_field, _state)                            \
 {                                                                   \
     .name       = (stringify(_field)),                              \
     .version_id = 0,                                                \
     .info       = &vmstate_info_uint16,                             \
     .size       = sizeof(uint16_t),                                 \
218
     .flags      = VMS_SINGLE | VMS_POINTER,                         \
219 220 221
     .offset     = vmstate_offset_pointer(_state, _field, uint8_t),  \
 }

222 223 224 225 226 227
static const VMStateDescription vmstate_gpe = {
    .name = "gpe",
    .version_id = 1,
    .minimum_version_id = 1,
    .minimum_version_id_old = 1,
    .fields      = (VMStateField []) {
228 229
        VMSTATE_GPE_ARRAY(sts, ACPIGPE),
        VMSTATE_GPE_ARRAY(en, ACPIGPE),
230 231 232 233 234 235 236 237 238
        VMSTATE_END_OF_LIST()
    }
};

static const VMStateDescription vmstate_pci_status = {
    .name = "pci_status",
    .version_id = 1,
    .minimum_version_id = 1,
    .minimum_version_id_old = 1,
239
    .pre_save = vmstate_pci_status_pre_save,
240 241 242 243 244 245 246
    .fields      = (VMStateField []) {
        VMSTATE_UINT32(up, struct pci_status),
        VMSTATE_UINT32(down, struct pci_status),
        VMSTATE_END_OF_LIST()
    }
};

247 248 249 250 251 252
static int acpi_load_old(QEMUFile *f, void *opaque, int version_id)
{
    PIIX4PMState *s = opaque;
    int ret, i;
    uint16_t temp;

253
    ret = pci_device_load(PCI_DEVICE(s), f);
254 255 256 257 258 259 260
    if (ret < 0) {
        return ret;
    }
    qemu_get_be16s(f, &s->ar.pm1.evt.sts);
    qemu_get_be16s(f, &s->ar.pm1.evt.en);
    qemu_get_be16s(f, &s->ar.pm1.cnt.cnt);

261
    ret = vmstate_load_state(f, &vmstate_apm, &s->apm, 1);
262 263 264 265
    if (ret) {
        return ret;
    }

266
    timer_get(f, s->ar.tmr.timer);
267 268 269 270 271 272 273 274 275 276 277 278
    qemu_get_sbe64s(f, &s->ar.tmr.overflow_time);

    qemu_get_be16s(f, (uint16_t *)s->ar.gpe.sts);
    for (i = 0; i < 3; i++) {
        qemu_get_be16s(f, &temp);
    }

    qemu_get_be16s(f, (uint16_t *)s->ar.gpe.en);
    for (i = 0; i < 3; i++) {
        qemu_get_be16s(f, &temp);
    }

279
    ret = vmstate_load_state(f, &vmstate_pci_status, &s->pci0_status, 1);
280 281 282 283 284 285 286 287 288
    return ret;
}

/* qemu-kvm 1.2 uses version 3 but advertised as 2
 * To support incoming qemu-kvm 1.2 migration, change version_id
 * and minimum_version_id to 2 below (which breaks migration from
 * qemu 1.2).
 *
 */
289 290
static const VMStateDescription vmstate_acpi = {
    .name = "piix4_pm",
291 292
    .version_id = 3,
    .minimum_version_id = 3,
293
    .minimum_version_id_old = 1,
294
    .load_state_old = acpi_load_old,
295 296
    .post_load = vmstate_acpi_post_load,
    .fields      = (VMStateField []) {
297
        VMSTATE_PCI_DEVICE(parent_obj, PIIX4PMState),
Gerd Hoffmann's avatar
Gerd Hoffmann committed
298 299 300
        VMSTATE_UINT16(ar.pm1.evt.sts, PIIX4PMState),
        VMSTATE_UINT16(ar.pm1.evt.en, PIIX4PMState),
        VMSTATE_UINT16(ar.pm1.cnt.cnt, PIIX4PMState),
301
        VMSTATE_STRUCT(apm, PIIX4PMState, 0, vmstate_apm, APMState),
Gerd Hoffmann's avatar
Gerd Hoffmann committed
302 303 304
        VMSTATE_TIMER(ar.tmr.timer, PIIX4PMState),
        VMSTATE_INT64(ar.tmr.overflow_time, PIIX4PMState),
        VMSTATE_STRUCT(ar.gpe, PIIX4PMState, 2, vmstate_gpe, ACPIGPE),
305 306
        VMSTATE_STRUCT(pci0_status, PIIX4PMState, 2, vmstate_pci_status,
                       struct pci_status),
307 308 309 310
        VMSTATE_END_OF_LIST()
    }
};

311 312
static void acpi_piix_eject_slot(PIIX4PMState *s, unsigned slots)
{
313
    BusChild *kid, *next;
314
    BusState *bus = qdev_get_parent_bus(DEVICE(s));
315
    int slot = ffs(slots) - 1;
316
    bool slot_free = true;
317 318 319 320

    /* Mark request as complete */
    s->pci0_status.down &= ~(1U << slot);

321 322
    QTAILQ_FOREACH_SAFE(kid, &bus->children, sibling, next) {
        DeviceState *qdev = kid->child;
323 324
        PCIDevice *dev = PCI_DEVICE(qdev);
        PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(dev);
325 326 327 328 329 330
        if (PCI_SLOT(dev->devfn) == slot) {
            if (pc->no_hotplug) {
                slot_free = false;
            } else {
                qdev_free(qdev);
            }
331 332
        }
    }
333 334 335
    if (slot_free) {
        s->pci0_slot_device_present &= ~(1U << slot);
    }
336 337
}

338 339
static void piix4_update_hotplug(PIIX4PMState *s)
{
340
    BusState *bus = qdev_get_parent_bus(DEVICE(s));
341
    BusChild *kid, *next;
342

343 344 345 346 347
    /* Execute any pending removes during reset */
    while (s->pci0_status.down) {
        acpi_piix_eject_slot(s, s->pci0_status.down);
    }

348
    s->pci0_hotplug_enable = ~0;
349
    s->pci0_slot_device_present = 0;
350

351 352
    QTAILQ_FOREACH_SAFE(kid, &bus->children, sibling, next) {
        DeviceState *qdev = kid->child;
353 354
        PCIDevice *pdev = PCI_DEVICE(qdev);
        PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(pdev);
355 356
        int slot = PCI_SLOT(pdev->devfn);

357
        if (pc->no_hotplug) {
358
            s->pci0_hotplug_enable &= ~(1U << slot);
359
        }
360 361

        s->pci0_slot_device_present |= (1U << slot);
362 363 364
    }
}

365 366 367
static void piix4_reset(void *opaque)
{
    PIIX4PMState *s = opaque;
368 369
    PCIDevice *d = PCI_DEVICE(s);
    uint8_t *pci_conf = d->config;
370 371 372 373 374 375

    pci_conf[0x58] = 0;
    pci_conf[0x59] = 0;
    pci_conf[0x5a] = 0;
    pci_conf[0x5b] = 0;

376 377 378
    pci_conf[0x40] = 0x01; /* PM io base read only bit */
    pci_conf[0x80] = 0;

379 380 381 382
    if (s->kvm_enabled) {
        /* Mark SMM as already inited (until KVM supports SMM). */
        pci_conf[0x5B] = 0x02;
    }
383
    piix4_update_hotplug(s);
384 385
}

386
static void piix4_pm_powerdown_req(Notifier *n, void *opaque)
387
{
388
    PIIX4PMState *s = container_of(n, PIIX4PMState, powerdown_notifier);
389

Gerd Hoffmann's avatar
Gerd Hoffmann committed
390 391
    assert(s != NULL);
    acpi_pm1_evt_power_down(&s->ar);
392 393
}

394
static void piix4_pm_machine_ready(Notifier *n, void *opaque)
395 396
{
    PIIX4PMState *s = container_of(n, PIIX4PMState, machine_ready);
397 398
    PCIDevice *d = PCI_DEVICE(s);
    MemoryRegion *io_as = pci_address_space_io(d);
399 400
    uint8_t *pci_conf;

401
    pci_conf = d->config;
402
    pci_conf[0x5f] = 0x10 |
403
        (memory_region_present(io_as, 0x378) ? 0x80 : 0);
404
    pci_conf[0x63] = 0x60;
405 406
    pci_conf[0x67] = (memory_region_present(io_as, 0x3f8) ? 0x08 : 0) |
        (memory_region_present(io_as, 0x2f8) ? 0x90 : 0);
407 408
}

Isaku Yamahata's avatar
Isaku Yamahata committed
409
static int piix4_pm_initfn(PCIDevice *dev)
410
{
411
    PIIX4PMState *s = PIIX4_PM(dev);
412 413
    uint8_t *pci_conf;

414
    pci_conf = dev->config;
415 416 417 418 419 420
    pci_conf[0x06] = 0x80;
    pci_conf[0x07] = 0x02;
    pci_conf[0x09] = 0x00;
    pci_conf[0x3d] = 0x01; // interrupt pin 1

    /* APM */
421
    apm_init(dev, &s->apm, apm_ctrl_changed, s);
422 423 424 425 426 427 428 429 430

    if (s->kvm_enabled) {
        /* Mark SMM as already inited to prevent SMM from running.  KVM does not
         * support SMM mode. */
        pci_conf[0x5B] = 0x02;
    }

    /* XXX: which specification is used ? The i82731AB has different
       mappings */
Isaku Yamahata's avatar
Isaku Yamahata committed
431 432
    pci_conf[0x90] = s->smb_io_base | 1;
    pci_conf[0x91] = s->smb_io_base >> 8;
433
    pci_conf[0xd2] = 0x09;
434
    pm_smbus_init(DEVICE(dev), &s->smb);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
435
    memory_region_set_enabled(&s->smb.io, pci_conf[0xd2] & 1);
436 437
    memory_region_add_subregion(pci_address_space_io(dev),
                                s->smb_io_base, &s->smb.io);
438

439
    memory_region_init(&s->io, OBJECT(s), "piix4-pm", 64);
440
    memory_region_set_enabled(&s->io, false);
441 442
    memory_region_add_subregion(pci_address_space_io(dev),
                                0, &s->io);
443

444
    acpi_pm_tmr_init(&s->ar, pm_tmr_timer, &s->io);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
445
    acpi_pm1_evt_init(&s->ar, pm_tmr_timer, &s->io);
446
    acpi_pm1_cnt_init(&s->ar, &s->io, s->s4_val);
Gerd Hoffmann's avatar
Gerd Hoffmann committed
447
    acpi_gpe_init(&s->ar, GPE_LEN);
448

449 450
    s->powerdown_notifier.notify = piix4_pm_powerdown_req;
    qemu_register_powerdown_notifier(&s->powerdown_notifier);
451

452 453
    s->machine_ready.notify = piix4_pm_machine_ready;
    qemu_add_machine_init_done_notifier(&s->machine_ready);
Isaku Yamahata's avatar
Isaku Yamahata committed
454
    qemu_register_reset(piix4_reset, s);
455 456

    piix4_acpi_system_hot_add_init(pci_address_space_io(dev), dev->bus, s);
Isaku Yamahata's avatar
Isaku Yamahata committed
457 458 459 460 461

    return 0;
}

i2c_bus *piix4_pm_init(PCIBus *bus, int devfn, uint32_t smb_io_base,
462
                       qemu_irq sci_irq, qemu_irq smi_irq,
Laszlo Ersek's avatar
Laszlo Ersek committed
463
                       int kvm_enabled, FWCfgState *fw_cfg)
Isaku Yamahata's avatar
Isaku Yamahata committed
464
{
465
    DeviceState *dev;
Isaku Yamahata's avatar
Isaku Yamahata committed
466 467
    PIIX4PMState *s;

468 469
    dev = DEVICE(pci_create(bus, devfn, TYPE_PIIX4_PM));
    qdev_prop_set_uint32(dev, "smb_io_base", smb_io_base);
470

471
    s = PIIX4_PM(dev);
472 473
    s->irq = sci_irq;
    s->smi_irq = smi_irq;
Isaku Yamahata's avatar
Isaku Yamahata committed
474 475
    s->kvm_enabled = kvm_enabled;

476
    qdev_init_nofail(dev);
477

478 479 480 481 482 483 484 485
    if (fw_cfg) {
        uint8_t suspend[6] = {128, 0, 0, 129, 128, 128};
        suspend[3] = 1 | ((!s->disable_s3) << 7);
        suspend[4] = s->s4_val | ((!s->disable_s4) << 7);

        fw_cfg_add_file(fw_cfg, "etc/system-states", g_memdup(suspend, 6), 6);
    }

486 487 488
    return s->smb.smbus;
}

489 490
static Property piix4_pm_properties[] = {
    DEFINE_PROP_UINT32("smb_io_base", PIIX4PMState, smb_io_base, 0),
491 492 493
    DEFINE_PROP_UINT8("disable_s3", PIIX4PMState, disable_s3, 0),
    DEFINE_PROP_UINT8("disable_s4", PIIX4PMState, disable_s4, 0),
    DEFINE_PROP_UINT8("s4_val", PIIX4PMState, s4_val, 2),
494 495 496 497 498
    DEFINE_PROP_END_OF_LIST(),
};

static void piix4_pm_class_init(ObjectClass *klass, void *data)
{
499
    DeviceClass *dc = DEVICE_CLASS(klass);
500 501 502 503 504 505 506 507 508
    PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);

    k->no_hotplug = 1;
    k->init = piix4_pm_initfn;
    k->config_write = pm_write_config;
    k->vendor_id = PCI_VENDOR_ID_INTEL;
    k->device_id = PCI_DEVICE_ID_INTEL_82371AB_3;
    k->revision = 0x03;
    k->class_id = PCI_CLASS_BRIDGE_OTHER;
509 510 511 512
    dc->desc = "PM";
    dc->no_user = 1;
    dc->vmsd = &vmstate_acpi;
    dc->props = piix4_pm_properties;
513 514
}

515
static const TypeInfo piix4_pm_info = {
516
    .name          = TYPE_PIIX4_PM,
517 518 519
    .parent        = TYPE_PCI_DEVICE,
    .instance_size = sizeof(PIIX4PMState),
    .class_init    = piix4_pm_class_init,
Isaku Yamahata's avatar
Isaku Yamahata committed
520 521
};

Andreas Färber's avatar
Andreas Färber committed
522
static void piix4_pm_register_types(void)
Isaku Yamahata's avatar
Isaku Yamahata committed
523
{
524
    type_register_static(&piix4_pm_info);
Isaku Yamahata's avatar
Isaku Yamahata committed
525 526
}

Andreas Färber's avatar
Andreas Färber committed
527
type_init(piix4_pm_register_types)
Isaku Yamahata's avatar
Isaku Yamahata committed
528

529
static uint64_t gpe_readb(void *opaque, hwaddr addr, unsigned width)
530
{
531
    PIIX4PMState *s = opaque;
Gerd Hoffmann's avatar
Gerd Hoffmann committed
532
    uint32_t val = acpi_gpe_ioport_readb(&s->ar, addr);
533

534
    PIIX4_DPRINTF("gpe read %" HWADDR_PRIx " == %" PRIu32 "\n", addr, val);
535 536 537
    return val;
}

538 539
static void gpe_writeb(void *opaque, hwaddr addr, uint64_t val,
                       unsigned width)
540
{
541 542
    PIIX4PMState *s = opaque;

Gerd Hoffmann's avatar
Gerd Hoffmann committed
543
    acpi_gpe_ioport_writeb(&s->ar, addr, val);
544
    pm_update_sci(s);
545

546
    PIIX4_DPRINTF("gpe write %" HWADDR_PRIx " <== %" PRIu64 "\n", addr, val);
547 548
}

549 550 551 552 553 554 555 556 557 558
static const MemoryRegionOps piix4_gpe_ops = {
    .read = gpe_readb,
    .write = gpe_writeb,
    .valid.min_access_size = 1,
    .valid.max_access_size = 4,
    .impl.min_access_size = 1,
    .impl.max_access_size = 1,
    .endianness = DEVICE_LITTLE_ENDIAN,
};

559
static uint64_t pci_read(void *opaque, hwaddr addr, unsigned int size)
560
{
561
    PIIX4PMState *s = opaque;
562 563 564 565 566 567 568
    uint32_t val = 0;

    switch (addr) {
    case PCI_UP_BASE - PCI_HOTPLUG_ADDR:
        /* Manufacture an "up" value to cause a device check on any hotplug
         * slot with a device.  Extra device checks are harmless. */
        val = s->pci0_slot_device_present & s->pci0_hotplug_enable;
569
        PIIX4_DPRINTF("pci_up_read %" PRIu32 "\n", val);
570 571 572
        break;
    case PCI_DOWN_BASE - PCI_HOTPLUG_ADDR:
        val = s->pci0_status.down;
573
        PIIX4_DPRINTF("pci_down_read %" PRIu32 "\n", val);
574 575 576
        break;
    case PCI_EJ_BASE - PCI_HOTPLUG_ADDR:
        /* No feature defined yet */
577
        PIIX4_DPRINTF("pci_features_read %" PRIu32 "\n", val);
578 579 580 581 582 583 584
        break;
    case PCI_RMV_BASE - PCI_HOTPLUG_ADDR:
        val = s->pci0_hotplug_enable;
        break;
    default:
        break;
    }
585 586

    return val;
587 588
}

589 590
static void pci_write(void *opaque, hwaddr addr, uint64_t data,
                      unsigned int size)
591
{
592 593 594
    switch (addr) {
    case PCI_EJ_BASE - PCI_HOTPLUG_ADDR:
        acpi_piix_eject_slot(opaque, (uint32_t)data);
595
        PIIX4_DPRINTF("pciej write %" HWADDR_PRIx " <== %" PRIu64 "\n",
596 597 598 599 600
                      addr, data);
        break;
    default:
        break;
    }
601 602
}

603
static const MemoryRegionOps piix4_pci_ops = {
604 605
    .read = pci_read,
    .write = pci_write,
606
    .endianness = DEVICE_LITTLE_ENDIAN,
607 608 609 610
    .valid = {
        .min_access_size = 4,
        .max_access_size = 4,
    },
611 612
};

613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679
static uint64_t cpu_status_read(void *opaque, hwaddr addr, unsigned int size)
{
    PIIX4PMState *s = opaque;
    CPUStatus *cpus = &s->gpe_cpu;
    uint64_t val = cpus->sts[addr];

    return val;
}

static void cpu_status_write(void *opaque, hwaddr addr, uint64_t data,
                             unsigned int size)
{
    /* TODO: implement VCPU removal on guest signal that CPU can be removed */
}

static const MemoryRegionOps cpu_hotplug_ops = {
    .read = cpu_status_read,
    .write = cpu_status_write,
    .endianness = DEVICE_LITTLE_ENDIAN,
    .valid = {
        .min_access_size = 1,
        .max_access_size = 1,
    },
};

typedef enum {
    PLUG,
    UNPLUG,
} HotplugEventType;

static void piix4_cpu_hotplug_req(PIIX4PMState *s, CPUState *cpu,
                                  HotplugEventType action)
{
    CPUStatus *g = &s->gpe_cpu;
    ACPIGPE *gpe = &s->ar.gpe;
    CPUClass *k = CPU_GET_CLASS(cpu);
    int64_t cpu_id;

    assert(s != NULL);

    *gpe->sts = *gpe->sts | PIIX4_CPU_HOTPLUG_STATUS;
    cpu_id = k->get_arch_id(CPU(cpu));
    if (action == PLUG) {
        g->sts[cpu_id / 8] |= (1 << (cpu_id % 8));
    } else {
        g->sts[cpu_id / 8] &= ~(1 << (cpu_id % 8));
    }
    pm_update_sci(s);
}

static void piix4_cpu_added_req(Notifier *n, void *opaque)
{
    PIIX4PMState *s = container_of(n, PIIX4PMState, cpu_added_notifier);

    piix4_cpu_hotplug_req(s, CPU(opaque), PLUG);
}

static void piix4_init_cpu_status(CPUState *cpu, void *data)
{
    CPUStatus *g = (CPUStatus *)data;
    CPUClass *k = CPU_GET_CLASS(cpu);
    int64_t id = k->get_arch_id(cpu);

    g_assert((id / 8) < PIIX4_PROC_LEN);
    g->sts[id / 8] |= (1 << (id % 8));
}

680 681
static int piix4_device_hotplug(DeviceState *qdev, PCIDevice *dev,
                                PCIHotplugState state);
682

683 684
static void piix4_acpi_system_hot_add_init(MemoryRegion *parent,
                                           PCIBus *bus, PIIX4PMState *s)
685
{
686 687
    memory_region_init_io(&s->io_gpe, OBJECT(s), &piix4_gpe_ops, s,
                          "acpi-gpe0", GPE_LEN);
688
    memory_region_add_subregion(parent, GPE_BASE, &s->io_gpe);
689

690 691
    memory_region_init_io(&s->io_pci, OBJECT(s), &piix4_pci_ops, s,
                          "acpi-pci-hotplug", PCI_HOTPLUG_SIZE);
692
    memory_region_add_subregion(parent, PCI_HOTPLUG_ADDR,
693
                                &s->io_pci);
694
    pci_bus_hotplug(bus, piix4_device_hotplug, DEVICE(s));
695 696

    qemu_for_each_cpu(piix4_init_cpu_status, &s->gpe_cpu);
697 698
    memory_region_init_io(&s->io_cpu, OBJECT(s), &cpu_hotplug_ops, s,
                          "acpi-cpu-hotplug", PIIX4_PROC_LEN);
699 700 701
    memory_region_add_subregion(parent, PIIX4_PROC_BASE, &s->io_cpu);
    s->cpu_added_notifier.notify = piix4_cpu_added_req;
    qemu_register_cpu_added_notifier(&s->cpu_added_notifier);
702 703
}

704
static void enable_device(PIIX4PMState *s, int slot)
705
{
Gerd Hoffmann's avatar
Gerd Hoffmann committed
706
    s->ar.gpe.sts[0] |= PIIX4_PCI_HOTPLUG_STATUS;
707
    s->pci0_slot_device_present |= (1U << slot);
708 709
}

710
static void disable_device(PIIX4PMState *s, int slot)
711
{
Gerd Hoffmann's avatar
Gerd Hoffmann committed
712
    s->ar.gpe.sts[0] |= PIIX4_PCI_HOTPLUG_STATUS;
713
    s->pci0_status.down |= (1U << slot);
714 715
}

716 717
static int piix4_device_hotplug(DeviceState *qdev, PCIDevice *dev,
				PCIHotplugState state)
718 719
{
    int slot = PCI_SLOT(dev->devfn);
720
    PIIX4PMState *s = PIIX4_PM(qdev);
721

722 723 724 725
    /* Don't send event when device is enabled during qemu machine creation:
     * it is present on boot, no hotplug event is necessary. We do send an
     * event when the device is disabled later. */
    if (state == PCI_COLDPLUG_ENABLED) {
726
        s->pci0_slot_device_present |= (1U << slot);
727
        return 0;
728
    }
729

730
    if (state == PCI_HOTPLUG_ENABLED) {
731 732 733 734
        enable_device(s, slot);
    } else {
        disable_device(s, slot);
    }
735 736 737

    pm_update_sci(s);

738 739
    return 0;
}