VirtualBox

source: vbox/trunk/src/VBox/Devices/PC/DevACPI.cpp@ 58466

Last change on this file since 58466 was 58132, checked in by vboxsync, 9 years ago

*: Doxygen fixes.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id Revision
File size: 127.7 KB
Line 
1/* $Id: DevACPI.cpp 58132 2015-10-09 00:09:37Z vboxsync $ */
2/** @file
3 * DevACPI - Advanced Configuration and Power Interface (ACPI) Device.
4 */
5
6/*
7 * Copyright (C) 2006-2015 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#define LOG_GROUP LOG_GROUP_DEV_ACPI
23#include <VBox/vmm/pdmdev.h>
24#include <VBox/vmm/pgm.h>
25#include <VBox/vmm/dbgftrace.h>
26#include <VBox/vmm/vmcpuset.h>
27#include <VBox/log.h>
28#include <VBox/param.h>
29#include <iprt/assert.h>
30#include <iprt/asm.h>
31#include <iprt/asm-math.h>
32#include <iprt/file.h>
33#ifdef IN_RING3
34# include <iprt/alloc.h>
35# include <iprt/string.h>
36# include <iprt/uuid.h>
37#endif /* IN_RING3 */
38
39#include "VBoxDD.h"
40
41#ifdef LOG_ENABLED
42# define DEBUG_ACPI
43#endif
44
45
46
47/*********************************************************************************************************************************
48* Defined Constants And Macros *
49*********************************************************************************************************************************/
50#ifdef IN_RING3
51/** Locks the device state, ring-3 only. */
52# define DEVACPI_LOCK_R3(a_pThis) \
53 do { \
54 int rcLock = PDMCritSectEnter(&(a_pThis)->CritSect, VERR_IGNORED); \
55 AssertRC(rcLock); \
56 } while (0)
57#endif
58/** Unlocks the device state (all contexts). */
59#define DEVACPI_UNLOCK(a_pThis) \
60 do { PDMCritSectLeave(&(a_pThis)->CritSect); } while (0)
61
62
63#define DEBUG_HEX 0x3000
64#define DEBUG_CHR 0x3001
65
66#define PM_TMR_FREQ 3579545
67/* Default base for PM PIIX4 device */
68#define PM_PORT_BASE 0x4000
69/* Port offsets in PM device */
70enum
71{
72 PM1a_EVT_OFFSET = 0x00,
73 PM1b_EVT_OFFSET = -1, /**< not supported */
74 PM1a_CTL_OFFSET = 0x04,
75 PM1b_CTL_OFFSET = -1, /**< not supported */
76 PM2_CTL_OFFSET = -1, /**< not supported */
77 PM_TMR_OFFSET = 0x08,
78 GPE0_OFFSET = 0x20,
79 GPE1_OFFSET = -1 /**< not supported */
80};
81
82/* Undef this to enable 24 bit PM timer (mostly for debugging purposes) */
83#define PM_TMR_32BIT
84
85#define BAT_INDEX 0x00004040
86#define BAT_DATA 0x00004044
87#define SYSI_INDEX 0x00004048
88#define SYSI_DATA 0x0000404c
89#define ACPI_RESET_BLK 0x00004050
90
91/* PM1x status register bits */
92#define TMR_STS RT_BIT(0)
93#define RSR1_STS (RT_BIT(1) | RT_BIT(2) | RT_BIT(3))
94#define BM_STS RT_BIT(4)
95#define GBL_STS RT_BIT(5)
96#define RSR2_STS (RT_BIT(6) | RT_BIT(7))
97#define PWRBTN_STS RT_BIT(8)
98#define SLPBTN_STS RT_BIT(9)
99#define RTC_STS RT_BIT(10)
100#define IGN_STS RT_BIT(11)
101#define RSR3_STS (RT_BIT(12) | RT_BIT(13) | RT_BIT(14))
102#define WAK_STS RT_BIT(15)
103#define RSR_STS (RSR1_STS | RSR2_STS | RSR3_STS)
104
105/* PM1x enable register bits */
106#define TMR_EN RT_BIT(0)
107#define RSR1_EN (RT_BIT(1) | RT_BIT(2) | RT_BIT(3) | RT_BIT(4))
108#define GBL_EN RT_BIT(5)
109#define RSR2_EN (RT_BIT(6) | RT_BIT(7))
110#define PWRBTN_EN RT_BIT(8)
111#define SLPBTN_EN RT_BIT(9)
112#define RTC_EN RT_BIT(10)
113#define RSR3_EN (RT_BIT(11) | RT_BIT(12) | RT_BIT(13) | RT_BIT(14) | RT_BIT(15))
114#define RSR_EN (RSR1_EN | RSR2_EN | RSR3_EN)
115#define IGN_EN 0
116
117/* PM1x control register bits */
118#define SCI_EN RT_BIT(0)
119#define BM_RLD RT_BIT(1)
120#define GBL_RLS RT_BIT(2)
121#define RSR1_CNT (RT_BIT(3) | RT_BIT(4) | RT_BIT(5) | RT_BIT(6) | RT_BIT(7) | RT_BIT(8))
122#define IGN_CNT RT_BIT(9)
123#define SLP_TYPx_SHIFT 10
124#define SLP_TYPx_MASK 7
125#define SLP_EN RT_BIT(13)
126#define RSR2_CNT (RT_BIT(14) | RT_BIT(15))
127#define RSR_CNT (RSR1_CNT | RSR2_CNT)
128
129#define GPE0_BATTERY_INFO_CHANGED RT_BIT(0)
130
131enum
132{
133 BAT_STATUS_STATE = 0x00, /**< BST battery state */
134 BAT_STATUS_PRESENT_RATE = 0x01, /**< BST battery present rate */
135 BAT_STATUS_REMAINING_CAPACITY = 0x02, /**< BST battery remaining capacity */
136 BAT_STATUS_PRESENT_VOLTAGE = 0x03, /**< BST battery present voltage */
137 BAT_INFO_UNITS = 0x04, /**< BIF power unit */
138 BAT_INFO_DESIGN_CAPACITY = 0x05, /**< BIF design capacity */
139 BAT_INFO_LAST_FULL_CHARGE_CAPACITY = 0x06, /**< BIF last full charge capacity */
140 BAT_INFO_TECHNOLOGY = 0x07, /**< BIF battery technology */
141 BAT_INFO_DESIGN_VOLTAGE = 0x08, /**< BIF design voltage */
142 BAT_INFO_DESIGN_CAPACITY_OF_WARNING = 0x09, /**< BIF design capacity of warning */
143 BAT_INFO_DESIGN_CAPACITY_OF_LOW = 0x0A, /**< BIF design capacity of low */
144 BAT_INFO_CAPACITY_GRANULARITY_1 = 0x0B, /**< BIF battery capacity granularity 1 */
145 BAT_INFO_CAPACITY_GRANULARITY_2 = 0x0C, /**< BIF battery capacity granularity 2 */
146 BAT_DEVICE_STATUS = 0x0D, /**< STA device status */
147 BAT_POWER_SOURCE = 0x0E, /**< PSR power source */
148 BAT_INDEX_LAST
149};
150
151enum
152{
153 CPU_EVENT_TYPE_ADD = 0x01, /**< Event type add */
154 CPU_EVENT_TYPE_REMOVE = 0x03 /**< Event type remove */
155};
156
157enum
158{
159 SYSTEM_INFO_INDEX_LOW_MEMORY_LENGTH = 0,
160 SYSTEM_INFO_INDEX_USE_IOAPIC = 1,
161 SYSTEM_INFO_INDEX_HPET_STATUS = 2,
162 SYSTEM_INFO_INDEX_SMC_STATUS = 3,
163 SYSTEM_INFO_INDEX_FDC_STATUS = 4,
164 SYSTEM_INFO_INDEX_CPU0_STATUS = 5, /**< For compatibility with older saved states. */
165 SYSTEM_INFO_INDEX_CPU1_STATUS = 6, /**< For compatibility with older saved states. */
166 SYSTEM_INFO_INDEX_CPU2_STATUS = 7, /**< For compatibility with older saved states. */
167 SYSTEM_INFO_INDEX_CPU3_STATUS = 8, /**< For compatibility with older saved states. */
168 SYSTEM_INFO_INDEX_HIGH_MEMORY_LENGTH= 9,
169 SYSTEM_INFO_INDEX_RTC_STATUS = 10,
170 SYSTEM_INFO_INDEX_CPU_LOCKED = 11, /**< Contains a flag indicating whether the CPU is locked or not */
171 SYSTEM_INFO_INDEX_CPU_LOCK_CHECK = 12, /**< For which CPU the lock status should be checked */
172 SYSTEM_INFO_INDEX_CPU_EVENT_TYPE = 13, /**< Type of the CPU hot-plug event */
173 SYSTEM_INFO_INDEX_CPU_EVENT = 14, /**< The CPU id the event is for */
174 SYSTEM_INFO_INDEX_NIC_ADDRESS = 15, /**< NIC PCI address, or 0 */
175 SYSTEM_INFO_INDEX_AUDIO_ADDRESS = 16, /**< Audio card PCI address, or 0 */
176 SYSTEM_INFO_INDEX_POWER_STATES = 17,
177 SYSTEM_INFO_INDEX_IOC_ADDRESS = 18, /**< IO controller PCI address */
178 SYSTEM_INFO_INDEX_HBC_ADDRESS = 19, /**< host bus controller PCI address */
179 SYSTEM_INFO_INDEX_PCI_BASE = 20, /**< PCI bus MCFG MMIO range base */
180 SYSTEM_INFO_INDEX_PCI_LENGTH = 21, /**< PCI bus MCFG MMIO range length */
181 SYSTEM_INFO_INDEX_SERIAL0_IOBASE = 22,
182 SYSTEM_INFO_INDEX_SERIAL0_IRQ = 23,
183 SYSTEM_INFO_INDEX_SERIAL1_IOBASE = 24,
184 SYSTEM_INFO_INDEX_SERIAL1_IRQ = 25,
185 SYSTEM_INFO_INDEX_PARALLEL0_IOBASE = 26,
186 SYSTEM_INFO_INDEX_PARALLEL0_IRQ = 27,
187 SYSTEM_INFO_INDEX_PARALLEL1_IOBASE = 28,
188 SYSTEM_INFO_INDEX_PARALLEL1_IRQ = 29,
189 SYSTEM_INFO_INDEX_END = 30,
190 SYSTEM_INFO_INDEX_INVALID = 0x80,
191 SYSTEM_INFO_INDEX_VALID = 0x200
192};
193
194#define AC_OFFLINE 0
195#define AC_ONLINE 1
196
197#define BAT_TECH_PRIMARY 1
198#define BAT_TECH_SECONDARY 2
199
200#define STA_DEVICE_PRESENT_MASK RT_BIT(0) /**< present */
201#define STA_DEVICE_ENABLED_MASK RT_BIT(1) /**< enabled and decodes its resources */
202#define STA_DEVICE_SHOW_IN_UI_MASK RT_BIT(2) /**< should be shown in UI */
203#define STA_DEVICE_FUNCTIONING_PROPERLY_MASK RT_BIT(3) /**< functioning properly */
204#define STA_BATTERY_PRESENT_MASK RT_BIT(4) /**< the battery is present */
205
206
207/*********************************************************************************************************************************
208* Structures and Typedefs *
209*********************************************************************************************************************************/
210/**
211 * The ACPI device state.
212 */
213typedef struct ACPIState
214{
215 PCIDevice dev;
216 /** Critical section protecting the ACPI state. */
217 PDMCRITSECT CritSect;
218
219 uint16_t pm1a_en;
220 uint16_t pm1a_sts;
221 uint16_t pm1a_ctl;
222 /** Number of logical CPUs in guest */
223 uint16_t cCpus;
224 uint64_t u64PmTimerInitial;
225 PTMTIMERR3 pPmTimerR3;
226 PTMTIMERR0 pPmTimerR0;
227 PTMTIMERRC pPmTimerRC;
228
229 /* PM Timer last calculated value */
230 uint32_t uPmTimerVal;
231 uint32_t Alignment0;
232
233 uint32_t gpe0_en;
234 uint32_t gpe0_sts;
235
236 uint32_t uBatteryIndex;
237 uint32_t au8BatteryInfo[13];
238
239 uint32_t uSystemInfoIndex;
240 uint64_t u64RamSize;
241 /** The number of bytes above 4GB. */
242 uint64_t cbRamHigh;
243 /** The number of bytes below 4GB. */
244 uint32_t cbRamLow;
245
246 /** Current ACPI S* state. We support S0 and S5. */
247 uint32_t uSleepState;
248 uint8_t au8RSDPPage[0x1000];
249 /** This is a workaround for incorrect index field handling by Intels ACPICA.
250 * The system info _INI method writes to offset 0x200. We either observe a
251 * write request to index 0x80 (in that case we don't change the index) or a
252 * write request to offset 0x200 (in that case we divide the index value by
253 * 4. Note that the _STA method is sometimes called prior to the _INI method
254 * (ACPI spec 6.3.7, _STA). See the special case for BAT_DEVICE_STATUS in
255 * acpiR3BatIndexWrite() for handling this. */
256 uint8_t u8IndexShift;
257 /** provide an I/O-APIC */
258 uint8_t u8UseIOApic;
259 /** provide a floppy controller */
260 bool fUseFdc;
261 /** If High Precision Event Timer device should be supported */
262 bool fUseHpet;
263 /** If System Management Controller device should be supported */
264 bool fUseSmc;
265 /** the guest handled the last power button event */
266 bool fPowerButtonHandled;
267 /** If ACPI CPU device should be shown */
268 bool fShowCpu;
269 /** If Real Time Clock ACPI object to be shown */
270 bool fShowRtc;
271 /** I/O port address of PM device. */
272 RTIOPORT uPmIoPortBase;
273 /** Flag whether the GC part of the device is enabled. */
274 bool fGCEnabled;
275 /** Flag whether the R0 part of the device is enabled. */
276 bool fR0Enabled;
277 /** Array of flags of attached CPUs */
278 VMCPUSET CpuSetAttached;
279 /** Which CPU to check for the locked status. */
280 uint32_t idCpuLockCheck;
281 /** Mask of locked CPUs (used by the guest). */
282 VMCPUSET CpuSetLocked;
283 /** The CPU event type. */
284 uint32_t u32CpuEventType;
285 /** The CPU id affected. */
286 uint32_t u32CpuEvent;
287 /** Flag whether CPU hot plugging is enabled. */
288 bool fCpuHotPlug;
289 /** If MCFG ACPI table shown to the guest */
290 bool fUseMcfg;
291 /** Primary NIC PCI address. */
292 uint32_t u32NicPciAddress;
293 /** Primary audio card PCI address. */
294 uint32_t u32AudioPciAddress;
295 /** Flag whether S1 power state is enabled. */
296 bool fS1Enabled;
297 /** Flag whether S4 power state is enabled. */
298 bool fS4Enabled;
299 /** Flag whether S1 triggers a state save. */
300 bool fSuspendToSavedState;
301 /** Flag whether to set WAK_STS on resume (restore included). */
302 bool fSetWakeupOnResume;
303 /** PCI address of the IO controller device. */
304 uint32_t u32IocPciAddress;
305 /** PCI address of the host bus controller device. */
306 uint32_t u32HbcPciAddress;
307 /* Physical address of PCI config space MMIO region */
308 uint64_t u64PciConfigMMioAddress;
309 /* Length of PCI config space MMIO region */
310 uint64_t u64PciConfigMMioLength;
311 /** Serial 0 IRQ number */
312 uint8_t uSerial0Irq;
313 /** Serial 1 IRQ number */
314 uint8_t uSerial1Irq;
315 /** Serial 0 IO port base */
316 RTIOPORT uSerial0IoPortBase;
317 /** Serial 1 IO port base */
318 RTIOPORT uSerial1IoPortBase;
319
320 /** @name Parallel port config bits
321 * @{ */
322 /** Parallel 0 IRQ number */
323 uint8_t uParallel0Irq;
324 /** Parallel 1 IRQ number */
325 uint8_t uParallel1Irq;
326 /** Parallel 0 IO port base */
327 RTIOPORT uParallel0IoPortBase;
328 /** Parallel 1 IO port base */
329 RTIOPORT uParallel1IoPortBase;
330 /** @} */
331
332 uint32_t u32Alignment1;
333
334 /** ACPI port base interface. */
335 PDMIBASE IBase;
336 /** ACPI port interface. */
337 PDMIACPIPORT IACPIPort;
338 /** Pointer to the device instance. */
339 PPDMDEVINSR3 pDevInsR3;
340 PPDMDEVINSR0 pDevInsR0;
341 PPDMDEVINSRC pDevInsRC;
342
343 uint32_t Alignment2;
344 /** Pointer to the driver base interface. */
345 R3PTRTYPE(PPDMIBASE) pDrvBase;
346 /** Pointer to the driver connector interface. */
347 R3PTRTYPE(PPDMIACPICONNECTOR) pDrv;
348
349 /** Pointer to default PCI config read function. */
350 R3PTRTYPE(PFNPCICONFIGREAD) pfnAcpiPciConfigRead;
351 /** Pointer to default PCI config write function. */
352 R3PTRTYPE(PFNPCICONFIGWRITE) pfnAcpiPciConfigWrite;
353
354 /** If custom table should be supported */
355 bool fUseCust;
356 /** ACPI OEM ID */
357 uint8_t au8OemId[6];
358 /** ACPI Crator ID */
359 uint8_t au8CreatorId[4];
360 /** ACPI Crator Rev */
361 uint32_t u32CreatorRev;
362 /** ACPI custom OEM Tab ID */
363 uint8_t au8OemTabId[8];
364 /** ACPI custom OEM Rev */
365 uint32_t u32OemRevision;
366 uint32_t Alignment3;
367
368 /** The custom table binary data. */
369 R3PTRTYPE(uint8_t *) pu8CustBin;
370 /** The size of the custom table binary. */
371 uint64_t cbCustBin;
372} ACPIState;
373
374#pragma pack(1)
375
376/** Generic Address Structure (see ACPIspec 3.0, 5.2.3.1) */
377struct ACPIGENADDR
378{
379 uint8_t u8AddressSpaceId; /**< 0=sys, 1=IO, 2=PCICfg, 3=emb, 4=SMBus */
380 uint8_t u8RegisterBitWidth; /**< size in bits of the given register */
381 uint8_t u8RegisterBitOffset; /**< bit offset of register */
382 uint8_t u8AccessSize; /**< 1=byte, 2=word, 3=dword, 4=qword */
383 uint64_t u64Address; /**< 64-bit address of register */
384};
385AssertCompileSize(ACPIGENADDR, 12);
386
387/** Root System Description Pointer */
388struct ACPITBLRSDP
389{
390 uint8_t au8Signature[8]; /**< 'RSD PTR ' */
391 uint8_t u8Checksum; /**< checksum for the first 20 bytes */
392 uint8_t au8OemId[6]; /**< OEM-supplied identifier */
393 uint8_t u8Revision; /**< revision number, currently 2 */
394#define ACPI_REVISION 2 /**< ACPI 3.0 */
395 uint32_t u32RSDT; /**< phys addr of RSDT */
396 uint32_t u32Length; /**< bytes of this table */
397 uint64_t u64XSDT; /**< 64-bit phys addr of XSDT */
398 uint8_t u8ExtChecksum; /**< checksum of entire table */
399 uint8_t u8Reserved[3]; /**< reserved */
400};
401AssertCompileSize(ACPITBLRSDP, 36);
402
403/** System Description Table Header */
404struct ACPITBLHEADER
405{
406 uint8_t au8Signature[4]; /**< table identifier */
407 uint32_t u32Length; /**< length of the table including header */
408 uint8_t u8Revision; /**< revision number */
409 uint8_t u8Checksum; /**< all fields inclusive this add to zero */
410 uint8_t au8OemId[6]; /**< OEM-supplied string */
411 uint8_t au8OemTabId[8]; /**< to identify the particular data table */
412 uint32_t u32OemRevision; /**< OEM-supplied revision number */
413 uint8_t au8CreatorId[4]; /**< ID for the ASL compiler */
414 uint32_t u32CreatorRev; /**< revision for the ASL compiler */
415};
416AssertCompileSize(ACPITBLHEADER, 36);
417
418/** Root System Description Table */
419struct ACPITBLRSDT
420{
421 ACPITBLHEADER header;
422 uint32_t u32Entry[1]; /**< array of phys. addresses to other tables */
423};
424AssertCompileSize(ACPITBLRSDT, 40);
425
426/** Extended System Description Table */
427struct ACPITBLXSDT
428{
429 ACPITBLHEADER header;
430 uint64_t u64Entry[1]; /**< array of phys. addresses to other tables */
431};
432AssertCompileSize(ACPITBLXSDT, 44);
433
434/** Fixed ACPI Description Table */
435struct ACPITBLFADT
436{
437 ACPITBLHEADER header;
438 uint32_t u32FACS; /**< phys. address of FACS */
439 uint32_t u32DSDT; /**< phys. address of DSDT */
440 uint8_t u8IntModel; /**< was eleminated in ACPI 2.0 */
441#define INT_MODEL_DUAL_PIC 1 /**< for ACPI 2+ */
442#define INT_MODEL_MULTIPLE_APIC 2
443 uint8_t u8PreferredPMProfile; /**< preferred power management profile */
444 uint16_t u16SCIInt; /**< system vector the SCI is wired in 8259 mode */
445#define SCI_INT 9
446 uint32_t u32SMICmd; /**< system port address of SMI command port */
447#define SMI_CMD 0x0000442e
448 uint8_t u8AcpiEnable; /**< SMICmd val to disable ownership of ACPIregs */
449#define ACPI_ENABLE 0xa1
450 uint8_t u8AcpiDisable; /**< SMICmd val to re-enable ownership of ACPIregs */
451#define ACPI_DISABLE 0xa0
452 uint8_t u8S4BIOSReq; /**< SMICmd val to enter S4BIOS state */
453 uint8_t u8PStateCnt; /**< SMICmd val to assume processor performance
454 state control responsibility */
455 uint32_t u32PM1aEVTBLK; /**< port addr of PM1a event regs block */
456 uint32_t u32PM1bEVTBLK; /**< port addr of PM1b event regs block */
457 uint32_t u32PM1aCTLBLK; /**< port addr of PM1a control regs block */
458 uint32_t u32PM1bCTLBLK; /**< port addr of PM1b control regs block */
459 uint32_t u32PM2CTLBLK; /**< port addr of PM2 control regs block */
460 uint32_t u32PMTMRBLK; /**< port addr of PMTMR regs block */
461 uint32_t u32GPE0BLK; /**< port addr of gen-purp event 0 regs block */
462 uint32_t u32GPE1BLK; /**< port addr of gen-purp event 1 regs block */
463 uint8_t u8PM1EVTLEN; /**< bytes decoded by PM1a_EVT_BLK. >= 4 */
464 uint8_t u8PM1CTLLEN; /**< bytes decoded by PM1b_CNT_BLK. >= 2 */
465 uint8_t u8PM2CTLLEN; /**< bytes decoded by PM2_CNT_BLK. >= 1 or 0 */
466 uint8_t u8PMTMLEN; /**< bytes decoded by PM_TMR_BLK. ==4 */
467 uint8_t u8GPE0BLKLEN; /**< bytes decoded by GPE0_BLK. %2==0 */
468#define GPE0_BLK_LEN 2
469 uint8_t u8GPE1BLKLEN; /**< bytes decoded by GPE1_BLK. %2==0 */
470#define GPE1_BLK_LEN 0
471 uint8_t u8GPE1BASE; /**< offset of GPE1 based events */
472#define GPE1_BASE 0
473 uint8_t u8CSTCNT; /**< SMICmd val to indicate OS supp for C states */
474 uint16_t u16PLVL2LAT; /**< us to enter/exit C2. >100 => unsupported */
475#define P_LVL2_LAT 101 /**< C2 state not supported */
476 uint16_t u16PLVL3LAT; /**< us to enter/exit C3. >1000 => unsupported */
477#define P_LVL3_LAT 1001 /**< C3 state not supported */
478 uint16_t u16FlushSize; /**< # of flush strides to read to flush dirty
479 lines from any processors memory caches */
480#define FLUSH_SIZE 0 /**< Ignored if WBVIND set in FADT_FLAGS */
481 uint16_t u16FlushStride; /**< cache line width */
482#define FLUSH_STRIDE 0 /**< Ignored if WBVIND set in FADT_FLAGS */
483 uint8_t u8DutyOffset;
484 uint8_t u8DutyWidth;
485 uint8_t u8DayAlarm; /**< RTC CMOS RAM index of day-of-month alarm */
486 uint8_t u8MonAlarm; /**< RTC CMOS RAM index of month-of-year alarm */
487 uint8_t u8Century; /**< RTC CMOS RAM index of century */
488 uint16_t u16IAPCBOOTARCH; /**< IA-PC boot architecture flags */
489#define IAPC_BOOT_ARCH_LEGACY_DEV RT_BIT(0) /**< legacy devices present such as LPT
490 (COM too?) */
491#define IAPC_BOOT_ARCH_8042 RT_BIT(1) /**< legacy keyboard device present */
492#define IAPC_BOOT_ARCH_NO_VGA RT_BIT(2) /**< VGA not present */
493#define IAPC_BOOT_ARCH_NO_MSI RT_BIT(3) /**< OSPM must not enable MSIs on this platform */
494#define IAPC_BOOT_ARCH_NO_ASPM RT_BIT(4) /**< OSPM must not enable ASPM on this platform */
495 uint8_t u8Must0_0; /**< must be 0 */
496 uint32_t u32Flags; /**< fixed feature flags */
497#define FADT_FL_WBINVD RT_BIT(0) /**< emulation of WBINVD available */
498#define FADT_FL_WBINVD_FLUSH RT_BIT(1)
499#define FADT_FL_PROC_C1 RT_BIT(2) /**< 1=C1 supported on all processors */
500#define FADT_FL_P_LVL2_UP RT_BIT(3) /**< 1=C2 works on SMP and UNI systems */
501#define FADT_FL_PWR_BUTTON RT_BIT(4) /**< 1=power button handled as ctrl method dev */
502#define FADT_FL_SLP_BUTTON RT_BIT(5) /**< 1=sleep button handled as ctrl method dev */
503#define FADT_FL_FIX_RTC RT_BIT(6) /**< 0=RTC wake status in fixed register */
504#define FADT_FL_RTC_S4 RT_BIT(7) /**< 1=RTC can wake system from S4 */
505#define FADT_FL_TMR_VAL_EXT RT_BIT(8) /**< 1=TMR_VAL implemented as 32 bit */
506#define FADT_FL_DCK_CAP RT_BIT(9) /**< 0=system cannot support docking */
507#define FADT_FL_RESET_REG_SUP RT_BIT(10) /**< 1=system supports system resets */
508#define FADT_FL_SEALED_CASE RT_BIT(11) /**< 1=case is sealed */
509#define FADT_FL_HEADLESS RT_BIT(12) /**< 1=system cannot detect moni/keyb/mouse */
510#define FADT_FL_CPU_SW_SLP RT_BIT(13)
511#define FADT_FL_PCI_EXT_WAK RT_BIT(14) /**< 1=system supports PCIEXP_WAKE_STS */
512#define FADT_FL_USE_PLATFORM_CLOCK RT_BIT(15) /**< 1=system has ACPI PM timer */
513#define FADT_FL_S4_RTC_STS_VALID RT_BIT(16) /**< 1=RTC_STS flag is valid when waking from S4 */
514#define FADT_FL_REMOVE_POWER_ON_CAPABLE RT_BIT(17) /**< 1=platform can remote power on */
515#define FADT_FL_FORCE_APIC_CLUSTER_MODEL RT_BIT(18)
516#define FADT_FL_FORCE_APIC_PHYS_DEST_MODE RT_BIT(19)
517
518/* PM Timer mask and msb */
519#ifndef PM_TMR_32BIT
520#define TMR_VAL_MSB 0x800000
521#define TMR_VAL_MASK 0xffffff
522#undef FADT_FL_TMR_VAL_EXT
523#define FADT_FL_TMR_VAL_EXT 0
524#else
525#define TMR_VAL_MSB 0x80000000
526#define TMR_VAL_MASK 0xffffffff
527#endif
528
529 /** Start of the ACPI 2.0 extension. */
530 ACPIGENADDR ResetReg; /**< ext addr of reset register */
531 uint8_t u8ResetVal; /**< ResetReg value to reset the system */
532#define ACPI_RESET_REG_VAL 0x10
533 uint8_t au8Must0_1[3]; /**< must be 0 */
534 uint64_t u64XFACS; /**< 64-bit phys address of FACS */
535 uint64_t u64XDSDT; /**< 64-bit phys address of DSDT */
536 ACPIGENADDR X_PM1aEVTBLK; /**< ext addr of PM1a event regs block */
537 ACPIGENADDR X_PM1bEVTBLK; /**< ext addr of PM1b event regs block */
538 ACPIGENADDR X_PM1aCTLBLK; /**< ext addr of PM1a control regs block */
539 ACPIGENADDR X_PM1bCTLBLK; /**< ext addr of PM1b control regs block */
540 ACPIGENADDR X_PM2CTLBLK; /**< ext addr of PM2 control regs block */
541 ACPIGENADDR X_PMTMRBLK; /**< ext addr of PMTMR control regs block */
542 ACPIGENADDR X_GPE0BLK; /**< ext addr of GPE1 regs block */
543 ACPIGENADDR X_GPE1BLK; /**< ext addr of GPE1 regs block */
544};
545AssertCompileSize(ACPITBLFADT, 244);
546#define ACPITBLFADT_VERSION1_SIZE RT_OFFSETOF(ACPITBLFADT, ResetReg)
547
548/** Firmware ACPI Control Structure */
549struct ACPITBLFACS
550{
551 uint8_t au8Signature[4]; /**< 'FACS' */
552 uint32_t u32Length; /**< bytes of entire FACS structure >= 64 */
553 uint32_t u32HWSignature; /**< systems HW signature at last boot */
554 uint32_t u32FWVector; /**< address of waking vector */
555 uint32_t u32GlobalLock; /**< global lock to sync HW/SW */
556 uint32_t u32Flags; /**< FACS flags */
557 uint64_t u64X_FWVector; /**< 64-bit waking vector */
558 uint8_t u8Version; /**< version of this table */
559 uint8_t au8Reserved[31]; /**< zero */
560};
561AssertCompileSize(ACPITBLFACS, 64);
562
563/** Processor Local APIC Structure */
564struct ACPITBLLAPIC
565{
566 uint8_t u8Type; /**< 0 = LAPIC */
567 uint8_t u8Length; /**< 8 */
568 uint8_t u8ProcId; /**< processor ID */
569 uint8_t u8ApicId; /**< local APIC ID */
570 uint32_t u32Flags; /**< Flags */
571#define LAPIC_ENABLED 0x1
572};
573AssertCompileSize(ACPITBLLAPIC, 8);
574
575/** I/O APIC Structure */
576struct ACPITBLIOAPIC
577{
578 uint8_t u8Type; /**< 1 == I/O APIC */
579 uint8_t u8Length; /**< 12 */
580 uint8_t u8IOApicId; /**< I/O APIC ID */
581 uint8_t u8Reserved; /**< 0 */
582 uint32_t u32Address; /**< phys address to access I/O APIC */
583 uint32_t u32GSIB; /**< global system interrupt number to start */
584};
585AssertCompileSize(ACPITBLIOAPIC, 12);
586
587/** Interrupt Source Override Structure */
588struct ACPITBLISO
589{
590 uint8_t u8Type; /**< 2 == Interrupt Source Override*/
591 uint8_t u8Length; /**< 10 */
592 uint8_t u8Bus; /**< Bus */
593 uint8_t u8Source; /**< Bus-relative interrupt source (IRQ) */
594 uint32_t u32GSI; /**< Global System Interrupt */
595 uint16_t u16Flags; /**< MPS INTI flags Global */
596};
597AssertCompileSize(ACPITBLISO, 10);
598#define NUMBER_OF_IRQ_SOURCE_OVERRIDES 2
599
600/** HPET Descriptor Structure */
601struct ACPITBLHPET
602{
603 ACPITBLHEADER aHeader;
604 uint32_t u32Id; /**< hardware ID of event timer block
605 [31:16] PCI vendor ID of first timer block
606 [15] legacy replacement IRQ routing capable
607 [14] reserved
608 [13] COUNT_SIZE_CAP counter size
609 [12:8] number of comparators in first timer block
610 [7:0] hardware rev ID */
611 ACPIGENADDR HpetAddr; /**< lower 32-bit base address */
612 uint8_t u32Number; /**< sequence number starting at 0 */
613 uint16_t u32MinTick; /**< minimum clock ticks which can be set without
614 lost interrupts while the counter is programmed
615 to operate in periodic mode. Unit: clock tick. */
616 uint8_t u8Attributes; /**< page protection and OEM attribute. */
617};
618AssertCompileSize(ACPITBLHPET, 56);
619
620/** MCFG Descriptor Structure */
621typedef struct ACPITBLMCFG
622{
623 ACPITBLHEADER aHeader;
624 uint64_t u64Reserved;
625} ACPITBLMCFG;
626AssertCompileSize(ACPITBLMCFG, 44);
627
628/** Number of such entries can be computed from the whole table length in header */
629typedef struct ACPITBLMCFGENTRY
630{
631 uint64_t u64BaseAddress;
632 uint16_t u16PciSegmentGroup;
633 uint8_t u8StartBus;
634 uint8_t u8EndBus;
635 uint32_t u32Reserved;
636} ACPITBLMCFGENTRY;
637AssertCompileSize(ACPITBLMCFGENTRY, 16);
638
639#define PCAT_COMPAT 0x1 /**< system has also a dual-8259 setup */
640
641/** Custom Description Table */
642struct ACPITBLCUST
643{
644 ACPITBLHEADER header;
645 uint8_t au8Data[476];
646};
647AssertCompileSize(ACPITBLCUST, 512);
648
649
650#pragma pack()
651
652
653#ifndef VBOX_DEVICE_STRUCT_TESTCASE /* exclude the rest of the file */
654
655
656/*********************************************************************************************************************************
657* Internal Functions *
658*********************************************************************************************************************************/
659RT_C_DECLS_BEGIN
660PDMBOTHCBDECL(int) acpiPMTmrRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb);
661RT_C_DECLS_END
662#ifdef IN_RING3
663static int acpiR3PlantTables(ACPIState *pThis);
664#endif
665
666/* SCI IRQ */
667DECLINLINE(void) acpiSetIrq(ACPIState *pThis, int level)
668{
669 if (pThis->pm1a_ctl & SCI_EN)
670 PDMDevHlpPCISetIrq(pThis->CTX_SUFF(pDevIns), 0, level);
671}
672
673DECLINLINE(uint32_t) pm1a_pure_en(uint32_t en)
674{
675 return en & ~(RSR_EN | IGN_EN);
676}
677
678DECLINLINE(uint32_t) pm1a_pure_sts(uint32_t sts)
679{
680 return sts & ~(RSR_STS | IGN_STS);
681}
682
683DECLINLINE(int) pm1a_level(ACPIState *pThis)
684{
685 return (pm1a_pure_en(pThis->pm1a_en) & pm1a_pure_sts(pThis->pm1a_sts)) != 0;
686}
687
688DECLINLINE(bool) gpe0_level(ACPIState *pThis)
689{
690 return (pThis->gpe0_en & pThis->gpe0_sts) != 0;
691}
692
693/**
694 * Used by acpiR3PM1aStsWrite, acpiR3PM1aEnWrite, acpiR3PmTimer,
695 * acpiR3Port_PowerBuffonPress, acpiR3Port_SleepButtonPress
696 * and acpiPmTmrRead to update the PM1a.STS and PM1a.EN
697 * registers and trigger IRQs.
698 *
699 * Caller must hold the state lock.
700 *
701 * @param pThis The ACPI instance.
702 * @param sts The new PM1a.STS value.
703 * @param en The new PM1a.EN value.
704 */
705static void apicUpdatePm1a(ACPIState *pThis, uint32_t sts, uint32_t en)
706{
707 Assert(PDMCritSectIsOwner(&pThis->CritSect));
708
709 if (gpe0_level(pThis))
710 return;
711
712 int const old_level = pm1a_level(pThis);
713 int const new_level = (pm1a_pure_en(en) & pm1a_pure_sts(sts)) != 0;
714
715 Log(("apicUpdatePm1a() old=%x new=%x\n", old_level, new_level));
716
717 pThis->pm1a_en = en;
718 pThis->pm1a_sts = sts;
719
720 if (new_level != old_level)
721 acpiSetIrq(pThis, new_level);
722}
723
724#ifdef IN_RING3
725
726/**
727 * Used by acpiR3Gpe0StsWrite, acpiR3Gpe0EnWrite, acpiAttach and acpiDetach to
728 * update the GPE0.STS and GPE0.EN registers and trigger IRQs.
729 *
730 * Caller must hold the state lock.
731 *
732 * @param pThis The ACPI instance.
733 * @param sts The new GPE0.STS value.
734 * @param en The new GPE0.EN value.
735 */
736static void apicR3UpdateGpe0(ACPIState *pThis, uint32_t sts, uint32_t en)
737{
738 Assert(PDMCritSectIsOwner(&pThis->CritSect));
739
740 if (pm1a_level(pThis))
741 return;
742
743 int const old_level = gpe0_level(pThis);
744 int const new_level = (en & sts) != 0;
745
746 pThis->gpe0_en = en;
747 pThis->gpe0_sts = sts;
748
749 if (new_level != old_level)
750 acpiSetIrq(pThis, new_level);
751}
752
753/**
754 * Used by acpiR3PM1aCtlWrite to power off the VM.
755 *
756 * @param pThis The ACPI instance.
757 * @returns Strict VBox status code.
758 */
759static int acpiR3DoPowerOff(ACPIState *pThis)
760{
761 int rc = PDMDevHlpVMPowerOff(pThis->pDevInsR3);
762 if (RT_FAILURE(rc))
763 AssertMsgFailed(("Could not power down the VM. rc = %Rrc\n", rc));
764 return rc;
765}
766
767/**
768 * Used by acpiR3PM1aCtlWrite to put the VM to sleep.
769 *
770 * @param pThis The ACPI instance.
771 * @returns Strict VBox status code.
772 */
773static int acpiR3DoSleep(ACPIState *pThis)
774{
775 /* We must set WAK_STS on resume (includes restore) so the guest knows that
776 we've woken up and can continue executing code. The guest is probably
777 reading the PMSTS register in a loop to check this. */
778 int rc;
779 pThis->fSetWakeupOnResume = true;
780 if (pThis->fSuspendToSavedState)
781 {
782 rc = PDMDevHlpVMSuspendSaveAndPowerOff(pThis->pDevInsR3);
783 if (rc != VERR_NOT_SUPPORTED)
784 AssertRC(rc);
785 else
786 {
787 LogRel(("ACPI: PDMDevHlpVMSuspendSaveAndPowerOff is not supported, falling back to suspend-only\n"));
788 rc = PDMDevHlpVMSuspend(pThis->pDevInsR3);
789 AssertRC(rc);
790 }
791 }
792 else
793 {
794 rc = PDMDevHlpVMSuspend(pThis->pDevInsR3);
795 AssertRC(rc);
796 }
797 return rc;
798}
799
800
801/**
802 * @interface_method_impl{PDMIACPIPORT,pfnPowerButtonPress}
803 */
804static DECLCALLBACK(int) acpiR3Port_PowerButtonPress(PPDMIACPIPORT pInterface)
805{
806 ACPIState *pThis = RT_FROM_MEMBER(pInterface, ACPIState, IACPIPort);
807 DEVACPI_LOCK_R3(pThis);
808
809 Log(("acpiR3Port_PowerButtonPress: handled=%d status=%x\n", pThis->fPowerButtonHandled, pThis->pm1a_sts));
810 pThis->fPowerButtonHandled = false;
811 apicUpdatePm1a(pThis, pThis->pm1a_sts | PWRBTN_STS, pThis->pm1a_en);
812
813 DEVACPI_UNLOCK(pThis);
814 return VINF_SUCCESS;
815}
816
817/**
818 * @interface_method_impl{PDMIACPIPORT,pfnGetPowerButtonHandled}
819 */
820static DECLCALLBACK(int) acpiR3Port_GetPowerButtonHandled(PPDMIACPIPORT pInterface, bool *pfHandled)
821{
822 ACPIState *pThis = RT_FROM_MEMBER(pInterface, ACPIState, IACPIPort);
823 DEVACPI_LOCK_R3(pThis);
824
825 *pfHandled = pThis->fPowerButtonHandled;
826
827 DEVACPI_UNLOCK(pThis);
828 return VINF_SUCCESS;
829}
830
831/**
832 * @interface_method_impl{PDMIACPIPORT,pfnGetGuestEnteredACPIMode, Check if the
833 * Guest entered into G0 (working) or G1 (sleeping)}
834 */
835static DECLCALLBACK(int) acpiR3Port_GetGuestEnteredACPIMode(PPDMIACPIPORT pInterface, bool *pfEntered)
836{
837 ACPIState *pThis = RT_FROM_MEMBER(pInterface, ACPIState, IACPIPort);
838 DEVACPI_LOCK_R3(pThis);
839
840 *pfEntered = (pThis->pm1a_ctl & SCI_EN) != 0;
841
842 DEVACPI_UNLOCK(pThis);
843 return VINF_SUCCESS;
844}
845
846/**
847 * @interface_method_impl{PDMIACPIPORT,pfnGetCpuStatus}
848 */
849static DECLCALLBACK(int) acpiR3Port_GetCpuStatus(PPDMIACPIPORT pInterface, unsigned uCpu, bool *pfLocked)
850{
851 ACPIState *pThis = RT_FROM_MEMBER(pInterface, ACPIState, IACPIPort);
852 DEVACPI_LOCK_R3(pThis);
853
854 *pfLocked = VMCPUSET_IS_PRESENT(&pThis->CpuSetLocked, uCpu);
855
856 DEVACPI_UNLOCK(pThis);
857 return VINF_SUCCESS;
858}
859
860/**
861 * Send an ACPI sleep button event.
862 *
863 * @returns VBox status code
864 * @param pInterface Pointer to the interface structure containing the called function pointer.
865 */
866static DECLCALLBACK(int) acpiR3Port_SleepButtonPress(PPDMIACPIPORT pInterface)
867{
868 ACPIState *pThis = RT_FROM_MEMBER(pInterface, ACPIState, IACPIPort);
869 DEVACPI_LOCK_R3(pThis);
870
871 apicUpdatePm1a(pThis, pThis->pm1a_sts | SLPBTN_STS, pThis->pm1a_en);
872
873 DEVACPI_UNLOCK(pThis);
874 return VINF_SUCCESS;
875}
876
877/**
878 * Send an ACPI monitor hot-plug event.
879 *
880 * @returns VBox status code
881 * @param pInterface Pointer to the interface structure containing the
882 * called function pointer.
883 */
884static DECLCALLBACK(int) acpiR3Port_MonitorHotPlugEvent(PPDMIACPIPORT pInterface)
885{
886 ACPIState *pThis = RT_FROM_MEMBER(pInterface, ACPIState, IACPIPort);
887 DEVACPI_LOCK_R3(pThis);
888
889 apicR3UpdateGpe0(pThis, pThis->gpe0_sts | 0x4, pThis->gpe0_en);
890
891 DEVACPI_UNLOCK(pThis);
892 return VINF_SUCCESS;
893}
894
895/**
896 * Used by acpiR3PmTimer to re-arm the PM timer.
897 *
898 * The caller is expected to either hold the clock lock or to have made sure
899 * the VM is resetting or loading state.
900 *
901 * @param pThis The ACPI instance.
902 * @param uNow The current time.
903 */
904static void acpiR3PmTimerReset(ACPIState *pThis, uint64_t uNow)
905{
906 uint64_t uTimerFreq = TMTimerGetFreq(pThis->CTX_SUFF(pPmTimer));
907 uint32_t uPmTmrCyclesToRollover = TMR_VAL_MSB - (pThis->uPmTimerVal & (TMR_VAL_MSB - 1));
908 uint64_t uInterval = ASMMultU64ByU32DivByU32(uPmTmrCyclesToRollover, uTimerFreq, PM_TMR_FREQ);
909 TMTimerSet(pThis->pPmTimerR3, uNow + uInterval + 1);
910 Log(("acpi: uInterval = %RU64\n", uInterval));
911}
912
913#endif
914
915/**
916 * Used by acpiR3PMTimer & acpiPmTmrRead to update TMR_VAL and update TMR_STS
917 *
918 * The caller is expected to either hold the clock lock or to have made sure
919 * the VM is resetting or loading state.
920 *
921 * @param pThis The ACPI instance
922 * @param uNow The current time
923 */
924
925static void acpiPmTimerUpdate(ACPIState *pThis, uint64_t u64Now)
926{
927 uint32_t msb = pThis->uPmTimerVal & TMR_VAL_MSB;
928 uint64_t u64Elapsed = u64Now - pThis->u64PmTimerInitial;
929 Assert(TMTimerIsLockOwner(pThis->CTX_SUFF(pPmTimer)));
930
931 pThis->uPmTimerVal = ASMMultU64ByU32DivByU32(u64Elapsed, PM_TMR_FREQ, TMTimerGetFreq(pThis->CTX_SUFF(pPmTimer))) & TMR_VAL_MASK;
932
933 if ( (pThis->uPmTimerVal & TMR_VAL_MSB) != msb)
934 {
935 apicUpdatePm1a(pThis, pThis->pm1a_sts | TMR_STS, pThis->pm1a_en);
936 }
937}
938
939#ifdef IN_RING3
940
941/**
942 * @callback_method_impl{FNTMTIMERDEV, PM Timer callback}
943 */
944static DECLCALLBACK(void) acpiR3PmTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
945{
946 ACPIState *pThis = (ACPIState *)pvUser;
947 Assert(TMTimerIsLockOwner(pTimer));
948 NOREF(pDevIns);
949
950 DEVACPI_LOCK_R3(pThis);
951 Log(("acpi: pm timer sts %#x (%d), en %#x (%d)\n",
952 pThis->pm1a_sts, (pThis->pm1a_sts & TMR_STS) != 0,
953 pThis->pm1a_en, (pThis->pm1a_en & TMR_EN) != 0));
954 uint64_t u64Now = TMTimerGet(pTimer);
955 acpiPmTimerUpdate(pThis, u64Now);
956 DEVACPI_UNLOCK(pThis);
957
958 acpiR3PmTimerReset(pThis, u64Now);
959}
960
961/**
962 * _BST method - used by acpiR3BatDataRead to implement BAT_STATUS_STATE and
963 * acpiR3LoadState.
964 *
965 * @returns VINF_SUCCESS.
966 * @param pThis The ACPI instance.
967 */
968static int acpiR3FetchBatteryStatus(ACPIState *pThis)
969{
970 uint32_t *p = pThis->au8BatteryInfo;
971 bool fPresent; /* battery present? */
972 PDMACPIBATCAPACITY hostRemainingCapacity; /* 0..100 */
973 PDMACPIBATSTATE hostBatteryState; /* bitfield */
974 uint32_t hostPresentRate; /* 0..1000 */
975 int rc;
976
977 if (!pThis->pDrv)
978 return VINF_SUCCESS;
979 rc = pThis->pDrv->pfnQueryBatteryStatus(pThis->pDrv, &fPresent, &hostRemainingCapacity,
980 &hostBatteryState, &hostPresentRate);
981 AssertRC(rc);
982
983 /* default values */
984 p[BAT_STATUS_STATE] = hostBatteryState;
985 p[BAT_STATUS_PRESENT_RATE] = hostPresentRate == ~0U ? 0xFFFFFFFF
986 : hostPresentRate * 50; /* mW */
987 p[BAT_STATUS_REMAINING_CAPACITY] = 50000; /* mWh */
988 p[BAT_STATUS_PRESENT_VOLTAGE] = 10000; /* mV */
989
990 /* did we get a valid battery state? */
991 if (hostRemainingCapacity != PDM_ACPI_BAT_CAPACITY_UNKNOWN)
992 p[BAT_STATUS_REMAINING_CAPACITY] = hostRemainingCapacity * 500; /* mWh */
993 if (hostBatteryState == PDM_ACPI_BAT_STATE_CHARGED)
994 p[BAT_STATUS_PRESENT_RATE] = 0; /* mV */
995
996 return VINF_SUCCESS;
997}
998
999/**
1000 * _BIF method - used by acpiR3BatDataRead to implement BAT_INFO_UNITS and
1001 * acpiR3LoadState.
1002 *
1003 * @returns VINF_SUCCESS.
1004 * @param pThis The ACPI instance.
1005 */
1006static int acpiR3FetchBatteryInfo(ACPIState *pThis)
1007{
1008 uint32_t *p = pThis->au8BatteryInfo;
1009
1010 p[BAT_INFO_UNITS] = 0; /* mWh */
1011 p[BAT_INFO_DESIGN_CAPACITY] = 50000; /* mWh */
1012 p[BAT_INFO_LAST_FULL_CHARGE_CAPACITY] = 50000; /* mWh */
1013 p[BAT_INFO_TECHNOLOGY] = BAT_TECH_PRIMARY;
1014 p[BAT_INFO_DESIGN_VOLTAGE] = 10000; /* mV */
1015 p[BAT_INFO_DESIGN_CAPACITY_OF_WARNING] = 100; /* mWh */
1016 p[BAT_INFO_DESIGN_CAPACITY_OF_LOW] = 50; /* mWh */
1017 p[BAT_INFO_CAPACITY_GRANULARITY_1] = 1; /* mWh */
1018 p[BAT_INFO_CAPACITY_GRANULARITY_2] = 1; /* mWh */
1019
1020 return VINF_SUCCESS;
1021}
1022
1023/**
1024 * The _STA method - used by acpiR3BatDataRead to implement BAT_DEVICE_STATUS.
1025 *
1026 * @returns status mask or 0.
1027 * @param pThis The ACPI instance.
1028 */
1029static uint32_t acpiR3GetBatteryDeviceStatus(ACPIState *pThis)
1030{
1031 bool fPresent; /* battery present? */
1032 PDMACPIBATCAPACITY hostRemainingCapacity; /* 0..100 */
1033 PDMACPIBATSTATE hostBatteryState; /* bitfield */
1034 uint32_t hostPresentRate; /* 0..1000 */
1035 int rc;
1036
1037 if (!pThis->pDrv)
1038 return 0;
1039 rc = pThis->pDrv->pfnQueryBatteryStatus(pThis->pDrv, &fPresent, &hostRemainingCapacity,
1040 &hostBatteryState, &hostPresentRate);
1041 AssertRC(rc);
1042
1043 return fPresent
1044 ? STA_DEVICE_PRESENT_MASK /* present */
1045 | STA_DEVICE_ENABLED_MASK /* enabled and decodes its resources */
1046 | STA_DEVICE_SHOW_IN_UI_MASK /* should be shown in UI */
1047 | STA_DEVICE_FUNCTIONING_PROPERLY_MASK /* functioning properly */
1048 | STA_BATTERY_PRESENT_MASK /* battery is present */
1049 : 0; /* device not present */
1050}
1051
1052/**
1053 * Used by acpiR3BatDataRead to implement BAT_POWER_SOURCE.
1054 *
1055 * @returns status.
1056 * @param pThis The ACPI instance.
1057 */
1058static uint32_t acpiR3GetPowerSource(ACPIState *pThis)
1059{
1060 /* query the current power source from the host driver */
1061 if (!pThis->pDrv)
1062 return AC_ONLINE;
1063
1064 PDMACPIPOWERSOURCE ps;
1065 int rc = pThis->pDrv->pfnQueryPowerSource(pThis->pDrv, &ps);
1066 AssertRC(rc);
1067 return ps == PDM_ACPI_POWER_SOURCE_BATTERY ? AC_OFFLINE : AC_ONLINE;
1068}
1069
1070/**
1071 * @callback_method_impl{FNIOMIOPORTOUT, Battery status index}
1072 */
1073PDMBOTHCBDECL(int) acpiR3BatIndexWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
1074{
1075 Log(("acpiR3BatIndexWrite: %#x (%#x)\n", u32, u32 >> 2));
1076 if (cb != 4)
1077 return PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u u32=%#x\n", cb, Port, u32);
1078
1079 ACPIState *pThis = (ACPIState *)pvUser;
1080 DEVACPI_LOCK_R3(pThis);
1081
1082 u32 >>= pThis->u8IndexShift;
1083 /* see comment at the declaration of u8IndexShift */
1084 if (pThis->u8IndexShift == 0 && u32 == (BAT_DEVICE_STATUS << 2))
1085 {
1086 pThis->u8IndexShift = 2;
1087 u32 >>= 2;
1088 }
1089 Assert(u32 < BAT_INDEX_LAST);
1090 pThis->uBatteryIndex = u32;
1091
1092 DEVACPI_UNLOCK(pThis);
1093 return VINF_SUCCESS;
1094}
1095
1096/**
1097 * @callback_method_impl{FNIOMIOPORTIN, Battery status data}
1098 */
1099PDMBOTHCBDECL(int) acpiR3BatDataRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
1100{
1101 if (cb != 4)
1102 return VERR_IOM_IOPORT_UNUSED;
1103
1104 ACPIState *pThis = (ACPIState *)pvUser;
1105 DEVACPI_LOCK_R3(pThis);
1106
1107 int rc = VINF_SUCCESS;
1108 switch (pThis->uBatteryIndex)
1109 {
1110 case BAT_STATUS_STATE:
1111 acpiR3FetchBatteryStatus(pThis);
1112 /* fall thru */
1113 case BAT_STATUS_PRESENT_RATE:
1114 case BAT_STATUS_REMAINING_CAPACITY:
1115 case BAT_STATUS_PRESENT_VOLTAGE:
1116 *pu32 = pThis->au8BatteryInfo[pThis->uBatteryIndex];
1117 break;
1118
1119 case BAT_INFO_UNITS:
1120 acpiR3FetchBatteryInfo(pThis);
1121 /* fall thru */
1122 case BAT_INFO_DESIGN_CAPACITY:
1123 case BAT_INFO_LAST_FULL_CHARGE_CAPACITY:
1124 case BAT_INFO_TECHNOLOGY:
1125 case BAT_INFO_DESIGN_VOLTAGE:
1126 case BAT_INFO_DESIGN_CAPACITY_OF_WARNING:
1127 case BAT_INFO_DESIGN_CAPACITY_OF_LOW:
1128 case BAT_INFO_CAPACITY_GRANULARITY_1:
1129 case BAT_INFO_CAPACITY_GRANULARITY_2:
1130 *pu32 = pThis->au8BatteryInfo[pThis->uBatteryIndex];
1131 break;
1132
1133 case BAT_DEVICE_STATUS:
1134 *pu32 = acpiR3GetBatteryDeviceStatus(pThis);
1135 break;
1136
1137 case BAT_POWER_SOURCE:
1138 *pu32 = acpiR3GetPowerSource(pThis);
1139 break;
1140
1141 default:
1142 rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u idx=%u\n", cb, Port, pThis->uBatteryIndex);
1143 *pu32 = UINT32_MAX;
1144 break;
1145 }
1146
1147 DEVACPI_UNLOCK(pThis);
1148 return rc;
1149}
1150
1151/**
1152 * @callback_method_impl{FNIOMIOPORTOUT, System info index}
1153 */
1154PDMBOTHCBDECL(int) acpiR3SysInfoIndexWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
1155{
1156 Log(("acpiR3SysInfoIndexWrite: %#x (%#x)\n", u32, u32 >> 2));
1157 if (cb != 4)
1158 return PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u u32=%#x\n", cb, Port, u32);
1159
1160 ACPIState *pThis = (ACPIState *)pvUser;
1161 DEVACPI_LOCK_R3(pThis);
1162
1163 if (u32 == SYSTEM_INFO_INDEX_VALID || u32 == SYSTEM_INFO_INDEX_INVALID)
1164 pThis->uSystemInfoIndex = u32;
1165 else
1166 {
1167 /* see comment at the declaration of u8IndexShift */
1168 if (u32 > SYSTEM_INFO_INDEX_END && pThis->u8IndexShift == 0)
1169 {
1170 if ((u32 >> 2) < SYSTEM_INFO_INDEX_END && (u32 & 0x3) == 0)
1171 pThis->u8IndexShift = 2;
1172 }
1173
1174 u32 >>= pThis->u8IndexShift;
1175 Assert(u32 < SYSTEM_INFO_INDEX_END);
1176 pThis->uSystemInfoIndex = u32;
1177 }
1178
1179 DEVACPI_UNLOCK(pThis);
1180 return VINF_SUCCESS;
1181}
1182
1183/**
1184 * @callback_method_impl{FNIOMIOPORTIN, System info data}
1185 */
1186PDMBOTHCBDECL(int) acpiR3SysInfoDataRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
1187{
1188 if (cb != 4)
1189 return VERR_IOM_IOPORT_UNUSED;
1190
1191 ACPIState *pThis = (ACPIState *)pvUser;
1192 DEVACPI_LOCK_R3(pThis);
1193
1194 int rc = VINF_SUCCESS;
1195 uint32_t const uSystemInfoIndex = pThis->uSystemInfoIndex;
1196 switch (uSystemInfoIndex)
1197 {
1198 case SYSTEM_INFO_INDEX_LOW_MEMORY_LENGTH:
1199 *pu32 = pThis->cbRamLow;
1200 break;
1201
1202 case SYSTEM_INFO_INDEX_HIGH_MEMORY_LENGTH:
1203 *pu32 = pThis->cbRamHigh >> 16; /* 64KB units */
1204 Assert(((uint64_t)*pu32 << 16) == pThis->cbRamHigh);
1205 break;
1206
1207 case SYSTEM_INFO_INDEX_USE_IOAPIC:
1208 *pu32 = pThis->u8UseIOApic;
1209 break;
1210
1211 case SYSTEM_INFO_INDEX_HPET_STATUS:
1212 *pu32 = pThis->fUseHpet
1213 ? ( STA_DEVICE_PRESENT_MASK
1214 | STA_DEVICE_ENABLED_MASK
1215 | STA_DEVICE_SHOW_IN_UI_MASK
1216 | STA_DEVICE_FUNCTIONING_PROPERLY_MASK)
1217 : 0;
1218 break;
1219
1220 case SYSTEM_INFO_INDEX_SMC_STATUS:
1221 *pu32 = pThis->fUseSmc
1222 ? ( STA_DEVICE_PRESENT_MASK
1223 | STA_DEVICE_ENABLED_MASK
1224 /* no need to show this device in the UI */
1225 | STA_DEVICE_FUNCTIONING_PROPERLY_MASK)
1226 : 0;
1227 break;
1228
1229 case SYSTEM_INFO_INDEX_FDC_STATUS:
1230 *pu32 = pThis->fUseFdc
1231 ? ( STA_DEVICE_PRESENT_MASK
1232 | STA_DEVICE_ENABLED_MASK
1233 | STA_DEVICE_SHOW_IN_UI_MASK
1234 | STA_DEVICE_FUNCTIONING_PROPERLY_MASK)
1235 : 0;
1236 break;
1237
1238 case SYSTEM_INFO_INDEX_NIC_ADDRESS:
1239 *pu32 = pThis->u32NicPciAddress;
1240 break;
1241
1242 case SYSTEM_INFO_INDEX_AUDIO_ADDRESS:
1243 *pu32 = pThis->u32AudioPciAddress;
1244 break;
1245
1246 case SYSTEM_INFO_INDEX_POWER_STATES:
1247 *pu32 = RT_BIT(0) | RT_BIT(5); /* S1 and S5 always exposed */
1248 if (pThis->fS1Enabled) /* Optionally expose S1 and S4 */
1249 *pu32 |= RT_BIT(1);
1250 if (pThis->fS4Enabled)
1251 *pu32 |= RT_BIT(4);
1252 break;
1253
1254 case SYSTEM_INFO_INDEX_IOC_ADDRESS:
1255 *pu32 = pThis->u32IocPciAddress;
1256 break;
1257
1258 case SYSTEM_INFO_INDEX_HBC_ADDRESS:
1259 *pu32 = pThis->u32HbcPciAddress;
1260 break;
1261
1262 case SYSTEM_INFO_INDEX_PCI_BASE:
1263 /** @todo couldn't MCFG be in 64-bit range? */
1264 Assert(pThis->u64PciConfigMMioAddress < 0xffffffff);
1265 *pu32 = (uint32_t)pThis->u64PciConfigMMioAddress;
1266 break;
1267
1268 case SYSTEM_INFO_INDEX_PCI_LENGTH:
1269 /** @todo couldn't MCFG be in 64-bit range? */
1270 Assert(pThis->u64PciConfigMMioLength< 0xffffffff);
1271 *pu32 = (uint32_t)pThis->u64PciConfigMMioLength;
1272 break;
1273
1274 /* This is only for compatibility with older saved states that
1275 may include ACPI code that read these values. Legacy is
1276 a wonderful thing, isn't it? :-) */
1277 case SYSTEM_INFO_INDEX_CPU0_STATUS:
1278 case SYSTEM_INFO_INDEX_CPU1_STATUS:
1279 case SYSTEM_INFO_INDEX_CPU2_STATUS:
1280 case SYSTEM_INFO_INDEX_CPU3_STATUS:
1281 *pu32 = ( pThis->fShowCpu
1282 && pThis->uSystemInfoIndex - SYSTEM_INFO_INDEX_CPU0_STATUS < pThis->cCpus
1283 && VMCPUSET_IS_PRESENT(&pThis->CpuSetAttached,
1284 pThis->uSystemInfoIndex - SYSTEM_INFO_INDEX_CPU0_STATUS) )
1285 ? ( STA_DEVICE_PRESENT_MASK
1286 | STA_DEVICE_ENABLED_MASK
1287 | STA_DEVICE_SHOW_IN_UI_MASK
1288 | STA_DEVICE_FUNCTIONING_PROPERLY_MASK)
1289 : 0;
1290 break;
1291
1292 case SYSTEM_INFO_INDEX_RTC_STATUS:
1293 *pu32 = pThis->fShowRtc
1294 ? ( STA_DEVICE_PRESENT_MASK
1295 | STA_DEVICE_ENABLED_MASK
1296 | STA_DEVICE_SHOW_IN_UI_MASK
1297 | STA_DEVICE_FUNCTIONING_PROPERLY_MASK)
1298 : 0;
1299 break;
1300
1301 case SYSTEM_INFO_INDEX_CPU_LOCKED:
1302 if (pThis->idCpuLockCheck < VMM_MAX_CPU_COUNT)
1303 {
1304 *pu32 = VMCPUSET_IS_PRESENT(&pThis->CpuSetLocked, pThis->idCpuLockCheck);
1305 pThis->idCpuLockCheck = UINT32_C(0xffffffff); /* Make the entry invalid */
1306 }
1307 else
1308 {
1309 rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "CPU lock check protocol violation (idCpuLockCheck=%#x)\n",
1310 pThis->idCpuLockCheck);
1311 /* Always return locked status just to be safe */
1312 *pu32 = 1;
1313 }
1314 break;
1315
1316 case SYSTEM_INFO_INDEX_CPU_EVENT_TYPE:
1317 *pu32 = pThis->u32CpuEventType;
1318 break;
1319
1320 case SYSTEM_INFO_INDEX_CPU_EVENT:
1321 *pu32 = pThis->u32CpuEvent;
1322 break;
1323
1324 case SYSTEM_INFO_INDEX_SERIAL0_IOBASE:
1325 *pu32 = pThis->uSerial0IoPortBase;
1326 break;
1327
1328 case SYSTEM_INFO_INDEX_SERIAL0_IRQ:
1329 *pu32 = pThis->uSerial0Irq;
1330 break;
1331
1332 case SYSTEM_INFO_INDEX_SERIAL1_IOBASE:
1333 *pu32 = pThis->uSerial1IoPortBase;
1334 break;
1335
1336 case SYSTEM_INFO_INDEX_SERIAL1_IRQ:
1337 *pu32 = pThis->uSerial1Irq;
1338 break;
1339
1340 case SYSTEM_INFO_INDEX_PARALLEL0_IOBASE:
1341 *pu32 = pThis->uParallel0IoPortBase;
1342 break;
1343
1344 case SYSTEM_INFO_INDEX_PARALLEL0_IRQ:
1345 *pu32 = pThis->uParallel0Irq;
1346 break;
1347
1348 case SYSTEM_INFO_INDEX_PARALLEL1_IOBASE:
1349 *pu32 = pThis->uParallel1IoPortBase;
1350 break;
1351
1352 case SYSTEM_INFO_INDEX_PARALLEL1_IRQ:
1353 *pu32 = pThis->uParallel1Irq;
1354 break;
1355
1356 case SYSTEM_INFO_INDEX_END:
1357 /** @todo why isn't this setting any output value? */
1358 break;
1359
1360 /* Solaris 9 tries to read from this index */
1361 case SYSTEM_INFO_INDEX_INVALID:
1362 *pu32 = 0;
1363 break;
1364
1365 default:
1366 *pu32 = UINT32_MAX;
1367 rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u idx=%u\n", cb, Port, pThis->uBatteryIndex);
1368 break;
1369 }
1370
1371 DEVACPI_UNLOCK(pThis);
1372 Log(("acpiR3SysInfoDataRead: idx=%d val=%#x (%d) rc=%Rrc\n", uSystemInfoIndex, *pu32, *pu32, rc));
1373 return rc;
1374}
1375
1376/**
1377 * @callback_method_impl{FNIOMIOPORTOUT, System info data}
1378 */
1379PDMBOTHCBDECL(int) acpiR3SysInfoDataWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
1380{
1381 ACPIState *pThis = (ACPIState *)pvUser;
1382 if (cb != 4)
1383 return PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u u32=%#x idx=%u\n", cb, Port, u32, pThis->uSystemInfoIndex);
1384
1385 DEVACPI_LOCK_R3(pThis);
1386 Log(("addr=%#x cb=%d u32=%#x si=%#x\n", Port, cb, u32, pThis->uSystemInfoIndex));
1387
1388 int rc = VINF_SUCCESS;
1389 switch (pThis->uSystemInfoIndex)
1390 {
1391 case SYSTEM_INFO_INDEX_INVALID:
1392 AssertMsg(u32 == 0xbadc0de, ("u32=%u\n", u32));
1393 pThis->u8IndexShift = 0;
1394 break;
1395
1396 case SYSTEM_INFO_INDEX_VALID:
1397 AssertMsg(u32 == 0xbadc0de, ("u32=%u\n", u32));
1398 pThis->u8IndexShift = 2;
1399 break;
1400
1401 case SYSTEM_INFO_INDEX_CPU_LOCK_CHECK:
1402 pThis->idCpuLockCheck = u32;
1403 break;
1404
1405 case SYSTEM_INFO_INDEX_CPU_LOCKED:
1406 if (u32 < pThis->cCpus)
1407 VMCPUSET_DEL(&pThis->CpuSetLocked, u32); /* Unlock the CPU */
1408 else
1409 LogRel(("ACPI: CPU %u does not exist\n", u32));
1410 break;
1411
1412 default:
1413 rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u u32=%#x idx=%u\n", cb, Port, u32, pThis->uSystemInfoIndex);
1414 break;
1415 }
1416
1417 DEVACPI_UNLOCK(pThis);
1418 return rc;
1419}
1420
1421/**
1422 * @callback_method_impl{FNIOMIOPORTIN, PM1a Enable}
1423 */
1424PDMBOTHCBDECL(int) acpiR3Pm1aEnRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
1425{
1426 NOREF(pDevIns); NOREF(Port);
1427 if (cb != 2)
1428 return VERR_IOM_IOPORT_UNUSED;
1429
1430 ACPIState *pThis = (ACPIState *)pvUser;
1431 DEVACPI_LOCK_R3(pThis);
1432
1433 *pu32 = pThis->pm1a_en;
1434
1435 DEVACPI_UNLOCK(pThis);
1436 Log(("acpiR3Pm1aEnRead -> %#x\n", *pu32));
1437 return VINF_SUCCESS;
1438}
1439
1440/**
1441 * @callback_method_impl{FNIOMIOPORTOUT, PM1a Enable}
1442 */
1443PDMBOTHCBDECL(int) acpiR3PM1aEnWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
1444{
1445 if (cb != 2 && cb != 4)
1446 return PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u u32=%#x\n", cb, Port, u32);
1447
1448 ACPIState *pThis = (ACPIState *)pvUser;
1449 DEVACPI_LOCK_R3(pThis);
1450
1451 Log(("acpiR3PM1aEnWrite: %#x (%#x)\n", u32, u32 & ~(RSR_EN | IGN_EN) & 0xffff));
1452 u32 &= ~(RSR_EN | IGN_EN);
1453 u32 &= 0xffff;
1454 apicUpdatePm1a(pThis, pThis->pm1a_sts, u32);
1455
1456 DEVACPI_UNLOCK(pThis);
1457 return VINF_SUCCESS;
1458}
1459
1460/**
1461 * @callback_method_impl{FNIOMIOPORTIN, PM1a Status}
1462 */
1463PDMBOTHCBDECL(int) acpiR3Pm1aStsRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
1464{
1465 if (cb != 2)
1466 {
1467 int rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u\n", cb, Port);
1468 return rc == VINF_SUCCESS ? VERR_IOM_IOPORT_UNUSED : rc;
1469 }
1470
1471 ACPIState *pThis = (ACPIState *)pvUser;
1472 DEVACPI_LOCK_R3(pThis);
1473
1474 *pu32 = pThis->pm1a_sts;
1475
1476 DEVACPI_UNLOCK(pThis);
1477 Log(("acpiR3Pm1aStsRead: %#x\n", *pu32));
1478 return VINF_SUCCESS;
1479}
1480
1481/**
1482 * @callback_method_impl{FNIOMIOPORTOUT, PM1a Status}
1483 */
1484PDMBOTHCBDECL(int) acpiR3PM1aStsWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
1485{
1486 if (cb != 2 && cb != 4)
1487 return PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u u32=%#x\n", cb, Port, u32);
1488
1489 ACPIState *pThis = (ACPIState *)pvUser;
1490 DEVACPI_LOCK_R3(pThis);
1491
1492 Log(("acpiR3PM1aStsWrite: %#x (%#x)\n", u32, u32 & ~(RSR_STS | IGN_STS) & 0xffff));
1493 u32 &= 0xffff;
1494 if (u32 & PWRBTN_STS)
1495 pThis->fPowerButtonHandled = true; /* Remember that the guest handled the last power button event */
1496 u32 = pThis->pm1a_sts & ~(u32 & ~(RSR_STS | IGN_STS));
1497 apicUpdatePm1a(pThis, u32, pThis->pm1a_en);
1498
1499 DEVACPI_UNLOCK(pThis);
1500 return VINF_SUCCESS;
1501}
1502
1503/**
1504 * @callback_method_impl{FNIOMIOPORTIN, PM1a Control}
1505 */
1506PDMBOTHCBDECL(int) acpiR3Pm1aCtlRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
1507{
1508 if (cb != 2)
1509 {
1510 int rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u\n", cb, Port);
1511 return rc == VINF_SUCCESS ? VERR_IOM_IOPORT_UNUSED : rc;
1512 }
1513
1514 ACPIState *pThis = (ACPIState *)pvUser;
1515 DEVACPI_LOCK_R3(pThis);
1516
1517 *pu32 = pThis->pm1a_ctl;
1518
1519 DEVACPI_UNLOCK(pThis);
1520 Log(("acpiR3Pm1aCtlRead: %#x\n", *pu32));
1521 return VINF_SUCCESS;
1522}
1523
1524/**
1525 * @callback_method_impl{FNIOMIOPORTOUT, PM1a Control}
1526 */
1527PDMBOTHCBDECL(int) acpiR3PM1aCtlWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
1528{
1529 if (cb != 2 && cb != 4)
1530 return PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u u32=%#x\n", cb, Port, u32);
1531
1532 ACPIState *pThis = (ACPIState *)pvUser;
1533 DEVACPI_LOCK_R3(pThis);
1534
1535 Log(("acpiR3PM1aCtlWrite: %#x (%#x)\n", u32, u32 & ~(RSR_CNT | IGN_CNT) & 0xffff));
1536 u32 &= 0xffff;
1537 pThis->pm1a_ctl = u32 & ~(RSR_CNT | IGN_CNT);
1538
1539 int rc = VINF_SUCCESS;
1540 uint32_t const uSleepState = (pThis->pm1a_ctl >> SLP_TYPx_SHIFT) & SLP_TYPx_MASK;
1541 if (uSleepState != pThis->uSleepState)
1542 {
1543 pThis->uSleepState = uSleepState;
1544 switch (uSleepState)
1545 {
1546 case 0x00: /* S0 */
1547 break;
1548
1549 case 0x01: /* S1 */
1550 if (pThis->fS1Enabled)
1551 {
1552 LogRel(("ACPI: Entering S1 power state (powered-on suspend)\n"));
1553 rc = acpiR3DoSleep(pThis);
1554 break;
1555 }
1556 LogRel(("ACPI: Ignoring guest attempt to enter S1 power state (powered-on suspend)!\n"));
1557 /* fall thru */
1558
1559 case 0x04: /* S4 */
1560 if (pThis->fS4Enabled)
1561 {
1562 LogRel(("ACPI: Entering S4 power state (suspend to disk)\n"));
1563 rc = acpiR3DoPowerOff(pThis);/* Same behavior as S5 */
1564 break;
1565 }
1566 LogRel(("ACPI: Ignoring guest attempt to enter S4 power state (suspend to disk)!\n"));
1567 /* fall thru */
1568
1569 case 0x05: /* S5 */
1570 LogRel(("ACPI: Entering S5 power state (power down)\n"));
1571 rc = acpiR3DoPowerOff(pThis);
1572 break;
1573
1574 default:
1575 rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "Unknown sleep state %#x (u32=%#x)\n", uSleepState, u32);
1576 break;
1577 }
1578 }
1579
1580 DEVACPI_UNLOCK(pThis);
1581 Log(("acpiR3PM1aCtlWrite: rc=%Rrc\n", rc));
1582 return rc;
1583}
1584
1585#endif /* IN_RING3 */
1586
1587/**
1588 * @callback_method_impl{FNIOMIOPORTIN, PMTMR}
1589 *
1590 * @remarks Only I/O port currently implemented in all contexts.
1591 */
1592PDMBOTHCBDECL(int) acpiPMTmrRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
1593{
1594 if (cb != 4)
1595 return VERR_IOM_IOPORT_UNUSED;
1596
1597 ACPIState *pThis = PDMINS_2_DATA(pDevIns, ACPIState *);
1598
1599 /*
1600 * We use the clock lock to serialize access to u64PmTimerInitial and to
1601 * make sure we get a reliable time from the clock
1602 * as well as and to prevent uPmTimerVal from being updated during read.
1603 */
1604
1605 int rc = TMTimerLock(pThis->CTX_SUFF(pPmTimer), VINF_IOM_R3_IOPORT_READ);
1606 if (rc != VINF_SUCCESS)
1607 return rc;
1608
1609 rc = PDMCritSectEnter(&pThis->CritSect, VINF_IOM_R3_IOPORT_READ);
1610 if (rc != VINF_SUCCESS)
1611 {
1612 TMTimerUnlock(pThis->CTX_SUFF(pPmTimer));
1613 return rc;
1614 }
1615
1616 uint64_t u64Now = TMTimerGet(pThis->CTX_SUFF(pPmTimer));
1617 acpiPmTimerUpdate(pThis, u64Now);
1618 *pu32 = pThis->uPmTimerVal;
1619
1620 DEVACPI_UNLOCK(pThis);
1621 TMTimerUnlock(pThis->CTX_SUFF(pPmTimer));
1622
1623 DBGFTRACE_PDM_U64_TAG(pDevIns, u64Now, "acpi");
1624 Log(("acpi: acpiPMTmrRead -> %#x\n", *pu32));
1625
1626 NOREF(pvUser); NOREF(Port);
1627 return rc;
1628}
1629
1630#ifdef IN_RING3
1631
1632/**
1633 * @callback_method_impl{FNIOMIOPORTIN, GPE0 Status}
1634 */
1635PDMBOTHCBDECL(int) acpiR3Gpe0StsRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
1636{
1637 if (cb != 1)
1638 {
1639 int rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u\n", cb, Port);
1640 return rc == VINF_SUCCESS ? VERR_IOM_IOPORT_UNUSED : rc;
1641 }
1642
1643 ACPIState *pThis = (ACPIState *)pvUser;
1644 DEVACPI_LOCK_R3(pThis);
1645
1646 *pu32 = pThis->gpe0_sts & 0xff;
1647
1648 DEVACPI_UNLOCK(pThis);
1649 Log(("acpiR3Gpe0StsRead: %#x\n", *pu32));
1650 return VINF_SUCCESS;
1651}
1652
1653/**
1654 * @callback_method_impl{FNIOMIOPORTOUT, GPE0 Status}
1655 */
1656PDMBOTHCBDECL(int) acpiR3Gpe0StsWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
1657{
1658 if (cb != 1)
1659 return PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u u32=%#x\n", cb, Port, u32);
1660
1661 ACPIState *pThis = (ACPIState *)pvUser;
1662 DEVACPI_LOCK_R3(pThis);
1663
1664 Log(("acpiR3Gpe0StsWrite: %#x (%#x)\n", u32, pThis->gpe0_sts & ~u32));
1665 u32 = pThis->gpe0_sts & ~u32;
1666 apicR3UpdateGpe0(pThis, u32, pThis->gpe0_en);
1667
1668 DEVACPI_UNLOCK(pThis);
1669 return VINF_SUCCESS;
1670}
1671
1672/**
1673 * @callback_method_impl{FNIOMIOPORTIN, GPE0 Enable}
1674 */
1675PDMBOTHCBDECL(int) acpiR3Gpe0EnRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t *pu32, unsigned cb)
1676{
1677 if (cb != 1)
1678 {
1679 int rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u\n", cb, Port);
1680 return rc == VINF_SUCCESS ? VERR_IOM_IOPORT_UNUSED : rc;
1681 }
1682
1683 ACPIState *pThis = (ACPIState *)pvUser;
1684 DEVACPI_LOCK_R3(pThis);
1685
1686 *pu32 = pThis->gpe0_en & 0xff;
1687
1688 DEVACPI_UNLOCK(pThis);
1689 Log(("acpiR3Gpe0EnRead: %#x\n", *pu32));
1690 return VINF_SUCCESS;
1691}
1692
1693/**
1694 * @callback_method_impl{FNIOMIOPORTOUT, GPE0 Enable}
1695 */
1696PDMBOTHCBDECL(int) acpiR3Gpe0EnWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
1697{
1698 if (cb != 1)
1699 return PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u u32=%#x\n", cb, Port, u32);
1700
1701 ACPIState *pThis = (ACPIState *)pvUser;
1702 DEVACPI_LOCK_R3(pThis);
1703
1704 Log(("acpiR3Gpe0EnWrite: %#x\n", u32));
1705 apicR3UpdateGpe0(pThis, pThis->gpe0_sts, u32);
1706
1707 DEVACPI_UNLOCK(pThis);
1708 return VINF_SUCCESS;
1709}
1710
1711/**
1712 * @callback_method_impl{FNIOMIOPORTOUT, SMI_CMD}
1713 */
1714PDMBOTHCBDECL(int) acpiR3SmiWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
1715{
1716 Log(("acpiR3SmiWrite %#x\n", u32));
1717 if (cb != 1)
1718 return PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u u32=%#x\n", cb, Port, u32);
1719
1720 ACPIState *pThis = (ACPIState *)pvUser;
1721 DEVACPI_LOCK_R3(pThis);
1722
1723 if (u32 == ACPI_ENABLE)
1724 pThis->pm1a_ctl |= SCI_EN;
1725 else if (u32 == ACPI_DISABLE)
1726 pThis->pm1a_ctl &= ~SCI_EN;
1727 else
1728 Log(("acpiR3SmiWrite: %#x <- unknown value\n", u32));
1729
1730 DEVACPI_UNLOCK(pThis);
1731 return VINF_SUCCESS;
1732}
1733
1734/**
1735 * @{FNIOMIOPORTOUT, ACPI_RESET_BLK}
1736 */
1737PDMBOTHCBDECL(int) acpiR3ResetWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
1738{
1739 Log(("acpiR3ResetWrite: %#x\n", u32));
1740 NOREF(pvUser);
1741 if (cb != 1)
1742 return PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u u32=%#x\n", cb, Port, u32);
1743
1744 /* No state locking required. */
1745 int rc = VINF_SUCCESS;
1746 if (u32 == ACPI_RESET_REG_VAL)
1747 {
1748 LogRel(("ACPI: Reset initiated by ACPI\n"));
1749 rc = PDMDevHlpVMReset(pDevIns);
1750 }
1751 else
1752 Log(("acpiR3ResetWrite: %#x <- unknown value\n", u32));
1753
1754 return rc;
1755}
1756
1757# ifdef DEBUG_ACPI
1758
1759/**
1760 * @callback_method_impl{FNIOMIOPORTOUT, Debug hex value logger}
1761 */
1762PDMBOTHCBDECL(int) acpiR3DhexWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
1763{
1764 NOREF(pvUser);
1765 switch (cb)
1766 {
1767 case 1:
1768 Log(("%#x\n", u32 & 0xff));
1769 break;
1770 case 2:
1771 Log(("%#6x\n", u32 & 0xffff));
1772 case 4:
1773 Log(("%#10x\n", u32));
1774 break;
1775 default:
1776 return PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u u32=%#x\n", cb, Port, u32);
1777 }
1778 return VINF_SUCCESS;
1779}
1780
1781/**
1782 * @callback_method_impl{FNIOMIOPORTOUT, Debug char logger}
1783 */
1784PDMBOTHCBDECL(int) acpiR3DchrWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT Port, uint32_t u32, unsigned cb)
1785{
1786 NOREF(pvUser);
1787 switch (cb)
1788 {
1789 case 1:
1790 Log(("%c", u32 & 0xff));
1791 break;
1792 default:
1793 return PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "cb=%d Port=%u u32=%#x\n", cb, Port, u32);
1794 }
1795 return VINF_SUCCESS;
1796}
1797
1798# endif /* DEBUG_ACPI */
1799
1800/**
1801 * Used to calculate the value of a PM I/O port.
1802 *
1803 * @returns The actual I/O port value.
1804 * @param pThis The ACPI instance.
1805 * @param offset The offset into the I/O space, or -1 if invalid.
1806 */
1807static RTIOPORT acpiR3CalcPmPort(ACPIState *pThis, int32_t offset)
1808{
1809 Assert(pThis->uPmIoPortBase != 0);
1810
1811 if (offset == -1)
1812 return 0;
1813
1814 return (RTIOPORT)(pThis->uPmIoPortBase + offset);
1815}
1816
1817/**
1818 * Called by acpiR3LoadState and acpiR3UpdatePmHandlers to register the PM1a, PM
1819 * timer and GPE0 I/O ports.
1820 *
1821 * @returns VBox status code.
1822 * @param pThis The ACPI instance.
1823 */
1824static int acpiR3RegisterPmHandlers(ACPIState *pThis)
1825{
1826 int rc = VINF_SUCCESS;
1827
1828#define R(offset, cnt, writer, reader, description) \
1829 do { \
1830 rc = PDMDevHlpIOPortRegister(pThis->pDevInsR3, acpiR3CalcPmPort(pThis, offset), cnt, pThis, writer, reader, \
1831 NULL, NULL, description); \
1832 if (RT_FAILURE(rc)) \
1833 return rc; \
1834 } while (0)
1835#define L (GPE0_BLK_LEN / 2)
1836
1837 R(PM1a_EVT_OFFSET+2, 1, acpiR3PM1aEnWrite, acpiR3Pm1aEnRead, "ACPI PM1a Enable");
1838 R(PM1a_EVT_OFFSET, 1, acpiR3PM1aStsWrite, acpiR3Pm1aStsRead, "ACPI PM1a Status");
1839 R(PM1a_CTL_OFFSET, 1, acpiR3PM1aCtlWrite, acpiR3Pm1aCtlRead, "ACPI PM1a Control");
1840 R(PM_TMR_OFFSET, 1, NULL, acpiPMTmrRead, "ACPI PM Timer");
1841 R(GPE0_OFFSET + L, L, acpiR3Gpe0EnWrite, acpiR3Gpe0EnRead, "ACPI GPE0 Enable");
1842 R(GPE0_OFFSET, L, acpiR3Gpe0StsWrite, acpiR3Gpe0StsRead, "ACPI GPE0 Status");
1843#undef L
1844#undef R
1845
1846 /* register RC stuff */
1847 if (pThis->fGCEnabled)
1848 {
1849 rc = PDMDevHlpIOPortRegisterRC(pThis->pDevInsR3, acpiR3CalcPmPort(pThis, PM_TMR_OFFSET),
1850 1, 0, NULL, "acpiPMTmrRead",
1851 NULL, NULL, "ACPI PM Timer");
1852 AssertRCReturn(rc, rc);
1853 }
1854
1855 /* register R0 stuff */
1856 if (pThis->fR0Enabled)
1857 {
1858 rc = PDMDevHlpIOPortRegisterR0(pThis->pDevInsR3, acpiR3CalcPmPort(pThis, PM_TMR_OFFSET),
1859 1, 0, NULL, "acpiPMTmrRead",
1860 NULL, NULL, "ACPI PM Timer");
1861 AssertRCReturn(rc, rc);
1862 }
1863
1864 return rc;
1865}
1866
1867/**
1868 * Called by acpiR3LoadState and acpiR3UpdatePmHandlers to unregister the PM1a, PM
1869 * timer and GPE0 I/O ports.
1870 *
1871 * @returns VBox status code.
1872 * @param pThis The ACPI instance.
1873 */
1874static int acpiR3UnregisterPmHandlers(ACPIState *pThis)
1875{
1876#define U(offset, cnt) \
1877 do { \
1878 int rc = PDMDevHlpIOPortDeregister(pThis->pDevInsR3, acpiR3CalcPmPort(pThis, offset), cnt); \
1879 AssertRCReturn(rc, rc); \
1880 } while (0)
1881#define L (GPE0_BLK_LEN / 2)
1882
1883 U(PM1a_EVT_OFFSET+2, 1);
1884 U(PM1a_EVT_OFFSET, 1);
1885 U(PM1a_CTL_OFFSET, 1);
1886 U(PM_TMR_OFFSET, 1);
1887 U(GPE0_OFFSET + L, L);
1888 U(GPE0_OFFSET, L);
1889#undef L
1890#undef U
1891
1892 return VINF_SUCCESS;
1893}
1894
1895/**
1896 * Called by acpiR3PciConfigWrite and acpiReset to change the location of the
1897 * PM1a, PM timer and GPE0 ports.
1898 *
1899 * @returns VBox status code.
1900 *
1901 * @param pThis The ACPI instance.
1902 * @param NewIoPortBase The new base address of the I/O ports.
1903 */
1904static int acpiR3UpdatePmHandlers(ACPIState *pThis, RTIOPORT NewIoPortBase)
1905{
1906 Log(("acpi: rebasing PM 0x%x -> 0x%x\n", pThis->uPmIoPortBase, NewIoPortBase));
1907 if (NewIoPortBase != pThis->uPmIoPortBase)
1908 {
1909 int rc = acpiR3UnregisterPmHandlers(pThis);
1910 if (RT_FAILURE(rc))
1911 return rc;
1912
1913 pThis->uPmIoPortBase = NewIoPortBase;
1914
1915 rc = acpiR3RegisterPmHandlers(pThis);
1916 if (RT_FAILURE(rc))
1917 return rc;
1918
1919 /* We have to update FADT table acccording to the new base */
1920 rc = acpiR3PlantTables(pThis);
1921 AssertRC(rc);
1922 if (RT_FAILURE(rc))
1923 return rc;
1924 }
1925
1926 return VINF_SUCCESS;
1927}
1928
1929
1930/**
1931 * Saved state structure description, version 4.
1932 */
1933static const SSMFIELD g_AcpiSavedStateFields4[] =
1934{
1935 SSMFIELD_ENTRY(ACPIState, pm1a_en),
1936 SSMFIELD_ENTRY(ACPIState, pm1a_sts),
1937 SSMFIELD_ENTRY(ACPIState, pm1a_ctl),
1938 SSMFIELD_ENTRY(ACPIState, u64PmTimerInitial),
1939 SSMFIELD_ENTRY(ACPIState, gpe0_en),
1940 SSMFIELD_ENTRY(ACPIState, gpe0_sts),
1941 SSMFIELD_ENTRY(ACPIState, uBatteryIndex),
1942 SSMFIELD_ENTRY(ACPIState, uSystemInfoIndex),
1943 SSMFIELD_ENTRY(ACPIState, u64RamSize),
1944 SSMFIELD_ENTRY(ACPIState, u8IndexShift),
1945 SSMFIELD_ENTRY(ACPIState, u8UseIOApic),
1946 SSMFIELD_ENTRY(ACPIState, uSleepState),
1947 SSMFIELD_ENTRY_TERM()
1948};
1949
1950/**
1951 * Saved state structure description, version 5.
1952 */
1953static const SSMFIELD g_AcpiSavedStateFields5[] =
1954{
1955 SSMFIELD_ENTRY(ACPIState, pm1a_en),
1956 SSMFIELD_ENTRY(ACPIState, pm1a_sts),
1957 SSMFIELD_ENTRY(ACPIState, pm1a_ctl),
1958 SSMFIELD_ENTRY(ACPIState, u64PmTimerInitial),
1959 SSMFIELD_ENTRY(ACPIState, gpe0_en),
1960 SSMFIELD_ENTRY(ACPIState, gpe0_sts),
1961 SSMFIELD_ENTRY(ACPIState, uBatteryIndex),
1962 SSMFIELD_ENTRY(ACPIState, uSystemInfoIndex),
1963 SSMFIELD_ENTRY(ACPIState, uSleepState),
1964 SSMFIELD_ENTRY(ACPIState, u8IndexShift),
1965 SSMFIELD_ENTRY(ACPIState, uPmIoPortBase),
1966 SSMFIELD_ENTRY_TERM()
1967};
1968
1969/**
1970 * Saved state structure description, version 6.
1971 */
1972static const SSMFIELD g_AcpiSavedStateFields6[] =
1973{
1974 SSMFIELD_ENTRY(ACPIState, pm1a_en),
1975 SSMFIELD_ENTRY(ACPIState, pm1a_sts),
1976 SSMFIELD_ENTRY(ACPIState, pm1a_ctl),
1977 SSMFIELD_ENTRY(ACPIState, u64PmTimerInitial),
1978 SSMFIELD_ENTRY(ACPIState, gpe0_en),
1979 SSMFIELD_ENTRY(ACPIState, gpe0_sts),
1980 SSMFIELD_ENTRY(ACPIState, uBatteryIndex),
1981 SSMFIELD_ENTRY(ACPIState, uSystemInfoIndex),
1982 SSMFIELD_ENTRY(ACPIState, uSleepState),
1983 SSMFIELD_ENTRY(ACPIState, u8IndexShift),
1984 SSMFIELD_ENTRY(ACPIState, uPmIoPortBase),
1985 SSMFIELD_ENTRY(ACPIState, fSuspendToSavedState),
1986 SSMFIELD_ENTRY_TERM()
1987};
1988
1989/**
1990 * Saved state structure description, version 7.
1991 */
1992static const SSMFIELD g_AcpiSavedStateFields7[] =
1993{
1994 SSMFIELD_ENTRY(ACPIState, pm1a_en),
1995 SSMFIELD_ENTRY(ACPIState, pm1a_sts),
1996 SSMFIELD_ENTRY(ACPIState, pm1a_ctl),
1997 SSMFIELD_ENTRY(ACPIState, u64PmTimerInitial),
1998 SSMFIELD_ENTRY(ACPIState, uPmTimerVal),
1999 SSMFIELD_ENTRY(ACPIState, gpe0_en),
2000 SSMFIELD_ENTRY(ACPIState, gpe0_sts),
2001 SSMFIELD_ENTRY(ACPIState, uBatteryIndex),
2002 SSMFIELD_ENTRY(ACPIState, uSystemInfoIndex),
2003 SSMFIELD_ENTRY(ACPIState, uSleepState),
2004 SSMFIELD_ENTRY(ACPIState, u8IndexShift),
2005 SSMFIELD_ENTRY(ACPIState, uPmIoPortBase),
2006 SSMFIELD_ENTRY(ACPIState, fSuspendToSavedState),
2007 SSMFIELD_ENTRY_TERM()
2008};
2009
2010/**
2011 * @callback_method_impl{FNSSMDEVSAVEEXEC}
2012 */
2013static DECLCALLBACK(int) acpiR3SaveState(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
2014{
2015 ACPIState *pThis = PDMINS_2_DATA(pDevIns, ACPIState *);
2016 return SSMR3PutStruct(pSSM, pThis, &g_AcpiSavedStateFields7[0]);
2017}
2018
2019/**
2020 * @callback_method_impl{FNSSMDEVLOADEXEC}
2021 */
2022static DECLCALLBACK(int) acpiR3LoadState(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
2023{
2024 ACPIState *pThis = PDMINS_2_DATA(pDevIns, ACPIState *);
2025 Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
2026
2027 /*
2028 * Unregister PM handlers, will register with actual base after state
2029 * successfully loaded.
2030 */
2031 int rc = acpiR3UnregisterPmHandlers(pThis);
2032 if (RT_FAILURE(rc))
2033 return rc;
2034
2035 switch (uVersion)
2036 {
2037 case 4:
2038 rc = SSMR3GetStruct(pSSM, pThis, &g_AcpiSavedStateFields4[0]);
2039 break;
2040 case 5:
2041 rc = SSMR3GetStruct(pSSM, pThis, &g_AcpiSavedStateFields5[0]);
2042 break;
2043 case 6:
2044 rc = SSMR3GetStruct(pSSM, pThis, &g_AcpiSavedStateFields6[0]);
2045 break;
2046 case 7:
2047 rc = SSMR3GetStruct(pSSM, pThis, &g_AcpiSavedStateFields7[0]);
2048 break;
2049 default:
2050 rc = VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION;
2051 break;
2052 }
2053 if (RT_SUCCESS(rc))
2054 {
2055 rc = acpiR3RegisterPmHandlers(pThis);
2056 if (RT_FAILURE(rc))
2057 return rc;
2058 rc = acpiR3FetchBatteryStatus(pThis);
2059 if (RT_FAILURE(rc))
2060 return rc;
2061 rc = acpiR3FetchBatteryInfo(pThis);
2062 if (RT_FAILURE(rc))
2063 return rc;
2064 TMTimerLock(pThis->pPmTimerR3, VERR_IGNORED);
2065 DEVACPI_LOCK_R3(pThis);
2066 uint64_t u64Now = TMTimerGet(pThis->pPmTimerR3);
2067 /* The interrupt may be incorrectly re-generated
2068 * if the state is restored from versions < 7
2069 */
2070 acpiPmTimerUpdate(pThis, u64Now);
2071 acpiR3PmTimerReset(pThis, u64Now);
2072 DEVACPI_UNLOCK(pThis);
2073 TMTimerUnlock(pThis->pPmTimerR3);
2074 }
2075 return rc;
2076}
2077
2078/**
2079 * @interface_method_impl{PDMIBASE,pfnQueryInterface}
2080 */
2081static DECLCALLBACK(void *) acpiR3QueryInterface(PPDMIBASE pInterface, const char *pszIID)
2082{
2083 ACPIState *pThis = RT_FROM_MEMBER(pInterface, ACPIState, IBase);
2084 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
2085 PDMIBASE_RETURN_INTERFACE(pszIID, PDMIACPIPORT, &pThis->IACPIPort);
2086 return NULL;
2087}
2088
2089/**
2090 * Calculate the check sum for some ACPI data before planting it.
2091 *
2092 * All the bytes must add up to 0.
2093 *
2094 * @returns check sum.
2095 * @param pvSrc What to check sum.
2096 * @param cbData The amount of data to checksum.
2097 */
2098static uint8_t acpiR3Checksum(const void * const pvSrc, size_t cbData)
2099{
2100 uint8_t const *pbSrc = (uint8_t const *)pvSrc;
2101 uint8_t uSum = 0;
2102 for (size_t i = 0; i < cbData; ++i)
2103 uSum += pbSrc[i];
2104 return -uSum;
2105}
2106
2107/**
2108 * Prepare a ACPI table header.
2109 */
2110static void acpiR3PrepareHeader(ACPIState *pThis, ACPITBLHEADER *header,
2111 const char au8Signature[4],
2112 uint32_t u32Length, uint8_t u8Revision)
2113{
2114 memcpy(header->au8Signature, au8Signature, 4);
2115 header->u32Length = RT_H2LE_U32(u32Length);
2116 header->u8Revision = u8Revision;
2117 memcpy(header->au8OemId, pThis->au8OemId, 6);
2118 memcpy(header->au8OemTabId, "VBOX", 4);
2119 memcpy(header->au8OemTabId+4, au8Signature, 4);
2120 header->u32OemRevision = RT_H2LE_U32(1);
2121 memcpy(header->au8CreatorId, pThis->au8CreatorId, 4);
2122 header->u32CreatorRev = pThis->u32CreatorRev;
2123}
2124
2125/**
2126 * Initialize a generic address structure (ACPIGENADDR).
2127 */
2128static void acpiR3WriteGenericAddr(ACPIGENADDR *g, uint8_t u8AddressSpaceId,
2129 uint8_t u8RegisterBitWidth, uint8_t u8RegisterBitOffset,
2130 uint8_t u8AccessSize, uint64_t u64Address)
2131{
2132 g->u8AddressSpaceId = u8AddressSpaceId;
2133 g->u8RegisterBitWidth = u8RegisterBitWidth;
2134 g->u8RegisterBitOffset = u8RegisterBitOffset;
2135 g->u8AccessSize = u8AccessSize;
2136 g->u64Address = RT_H2LE_U64(u64Address);
2137}
2138
2139/**
2140 * Wrapper around PDMDevHlpPhysWrite used when planting ACPI tables.
2141 */
2142DECLINLINE(void) acpiR3PhysCopy(ACPIState *pThis, RTGCPHYS32 GCPhys32Dst, const void *pvSrc, size_t cbToCopy)
2143{
2144 PDMDevHlpPhysWrite(pThis->pDevInsR3, GCPhys32Dst, pvSrc, cbToCopy);
2145}
2146
2147/**
2148 * Plant the Differentiated System Description Table (DSDT).
2149 */
2150static void acpiR3SetupDsdt(ACPIState *pThis, RTGCPHYS32 GCPhys32, void *pvPtr, size_t cbDsdt)
2151{
2152 acpiR3PhysCopy(pThis, GCPhys32, pvPtr, cbDsdt);
2153}
2154
2155/**
2156 * Plan the Secondary System Description Table (SSDT).
2157 */
2158static void acpiR3SetupSsdt(ACPIState *pThis, RTGCPHYS32 addr,
2159 void* pPtr, size_t uSsdtLen)
2160{
2161 acpiR3PhysCopy(pThis, addr, pPtr, uSsdtLen);
2162}
2163
2164/**
2165 * Plant the Firmware ACPI Control Structure (FACS).
2166 */
2167static void acpiR3SetupFacs(ACPIState *pThis, RTGCPHYS32 addr)
2168{
2169 ACPITBLFACS facs;
2170
2171 memset(&facs, 0, sizeof(facs));
2172 memcpy(facs.au8Signature, "FACS", 4);
2173 facs.u32Length = RT_H2LE_U32(sizeof(ACPITBLFACS));
2174 facs.u32HWSignature = RT_H2LE_U32(0);
2175 facs.u32FWVector = RT_H2LE_U32(0);
2176 facs.u32GlobalLock = RT_H2LE_U32(0);
2177 facs.u32Flags = RT_H2LE_U32(0);
2178 facs.u64X_FWVector = RT_H2LE_U64(0);
2179 facs.u8Version = 1;
2180
2181 acpiR3PhysCopy(pThis, addr, (const uint8_t *)&facs, sizeof(facs));
2182}
2183
2184/**
2185 * Plant the Fixed ACPI Description Table (FADT aka FACP).
2186 */
2187static void acpiR3SetupFadt(ACPIState *pThis, RTGCPHYS32 GCPhysAcpi1, RTGCPHYS32 GCPhysAcpi2,
2188 RTGCPHYS32 GCPhysFacs, RTGCPHYS GCPhysDsdt)
2189{
2190 ACPITBLFADT fadt;
2191
2192 /* First the ACPI version 2+ version of the structure. */
2193 memset(&fadt, 0, sizeof(fadt));
2194 acpiR3PrepareHeader(pThis, &fadt.header, "FACP", sizeof(fadt), 4);
2195 fadt.u32FACS = RT_H2LE_U32(GCPhysFacs);
2196 fadt.u32DSDT = RT_H2LE_U32(GCPhysDsdt);
2197 fadt.u8IntModel = 0; /* dropped from the ACPI 2.0 spec. */
2198 fadt.u8PreferredPMProfile = 0; /* unspecified */
2199 fadt.u16SCIInt = RT_H2LE_U16(SCI_INT);
2200 fadt.u32SMICmd = RT_H2LE_U32(SMI_CMD);
2201 fadt.u8AcpiEnable = ACPI_ENABLE;
2202 fadt.u8AcpiDisable = ACPI_DISABLE;
2203 fadt.u8S4BIOSReq = 0;
2204 fadt.u8PStateCnt = 0;
2205 fadt.u32PM1aEVTBLK = RT_H2LE_U32(acpiR3CalcPmPort(pThis, PM1a_EVT_OFFSET));
2206 fadt.u32PM1bEVTBLK = RT_H2LE_U32(acpiR3CalcPmPort(pThis, PM1b_EVT_OFFSET));
2207 fadt.u32PM1aCTLBLK = RT_H2LE_U32(acpiR3CalcPmPort(pThis, PM1a_CTL_OFFSET));
2208 fadt.u32PM1bCTLBLK = RT_H2LE_U32(acpiR3CalcPmPort(pThis, PM1b_CTL_OFFSET));
2209 fadt.u32PM2CTLBLK = RT_H2LE_U32(acpiR3CalcPmPort(pThis, PM2_CTL_OFFSET));
2210 fadt.u32PMTMRBLK = RT_H2LE_U32(acpiR3CalcPmPort(pThis, PM_TMR_OFFSET));
2211 fadt.u32GPE0BLK = RT_H2LE_U32(acpiR3CalcPmPort(pThis, GPE0_OFFSET));
2212 fadt.u32GPE1BLK = RT_H2LE_U32(acpiR3CalcPmPort(pThis, GPE1_OFFSET));
2213 fadt.u8PM1EVTLEN = 4;
2214 fadt.u8PM1CTLLEN = 2;
2215 fadt.u8PM2CTLLEN = 0;
2216 fadt.u8PMTMLEN = 4;
2217 fadt.u8GPE0BLKLEN = GPE0_BLK_LEN;
2218 fadt.u8GPE1BLKLEN = GPE1_BLK_LEN;
2219 fadt.u8GPE1BASE = GPE1_BASE;
2220 fadt.u8CSTCNT = 0;
2221 fadt.u16PLVL2LAT = RT_H2LE_U16(P_LVL2_LAT);
2222 fadt.u16PLVL3LAT = RT_H2LE_U16(P_LVL3_LAT);
2223 fadt.u16FlushSize = RT_H2LE_U16(FLUSH_SIZE);
2224 fadt.u16FlushStride = RT_H2LE_U16(FLUSH_STRIDE);
2225 fadt.u8DutyOffset = 0;
2226 fadt.u8DutyWidth = 0;
2227 fadt.u8DayAlarm = 0;
2228 fadt.u8MonAlarm = 0;
2229 fadt.u8Century = 0;
2230 fadt.u16IAPCBOOTARCH = RT_H2LE_U16(IAPC_BOOT_ARCH_LEGACY_DEV | IAPC_BOOT_ARCH_8042);
2231 /** @note WBINVD is required for ACPI versions newer than 1.0 */
2232 fadt.u32Flags = RT_H2LE_U32( FADT_FL_WBINVD
2233 | FADT_FL_FIX_RTC
2234 | FADT_FL_TMR_VAL_EXT
2235 | FADT_FL_RESET_REG_SUP);
2236
2237 /* We have to force physical APIC mode or Linux can't use more than 8 CPUs */
2238 if (pThis->fCpuHotPlug)
2239 fadt.u32Flags |= RT_H2LE_U32(FADT_FL_FORCE_APIC_PHYS_DEST_MODE);
2240
2241 acpiR3WriteGenericAddr(&fadt.ResetReg, 1, 8, 0, 1, ACPI_RESET_BLK);
2242 fadt.u8ResetVal = ACPI_RESET_REG_VAL;
2243 fadt.u64XFACS = RT_H2LE_U64((uint64_t)GCPhysFacs);
2244 fadt.u64XDSDT = RT_H2LE_U64((uint64_t)GCPhysDsdt);
2245 acpiR3WriteGenericAddr(&fadt.X_PM1aEVTBLK, 1, 32, 0, 2, acpiR3CalcPmPort(pThis, PM1a_EVT_OFFSET));
2246 acpiR3WriteGenericAddr(&fadt.X_PM1bEVTBLK, 0, 0, 0, 0, acpiR3CalcPmPort(pThis, PM1b_EVT_OFFSET));
2247 acpiR3WriteGenericAddr(&fadt.X_PM1aCTLBLK, 1, 16, 0, 2, acpiR3CalcPmPort(pThis, PM1a_CTL_OFFSET));
2248 acpiR3WriteGenericAddr(&fadt.X_PM1bCTLBLK, 0, 0, 0, 0, acpiR3CalcPmPort(pThis, PM1b_CTL_OFFSET));
2249 acpiR3WriteGenericAddr(&fadt.X_PM2CTLBLK, 0, 0, 0, 0, acpiR3CalcPmPort(pThis, PM2_CTL_OFFSET));
2250 acpiR3WriteGenericAddr(&fadt.X_PMTMRBLK, 1, 32, 0, 3, acpiR3CalcPmPort(pThis, PM_TMR_OFFSET));
2251 acpiR3WriteGenericAddr(&fadt.X_GPE0BLK, 1, 16, 0, 1, acpiR3CalcPmPort(pThis, GPE0_OFFSET));
2252 acpiR3WriteGenericAddr(&fadt.X_GPE1BLK, 0, 0, 0, 0, acpiR3CalcPmPort(pThis, GPE1_OFFSET));
2253 fadt.header.u8Checksum = acpiR3Checksum(&fadt, sizeof(fadt));
2254 acpiR3PhysCopy(pThis, GCPhysAcpi2, &fadt, sizeof(fadt));
2255
2256 /* Now the ACPI 1.0 version. */
2257 fadt.header.u32Length = ACPITBLFADT_VERSION1_SIZE;
2258 fadt.u8IntModel = INT_MODEL_DUAL_PIC;
2259 fadt.header.u8Checksum = 0; /* Must be zeroed before recalculating checksum! */
2260 fadt.header.u8Checksum = acpiR3Checksum(&fadt, ACPITBLFADT_VERSION1_SIZE);
2261 acpiR3PhysCopy(pThis, GCPhysAcpi1, &fadt, ACPITBLFADT_VERSION1_SIZE);
2262}
2263
2264/**
2265 * Plant the root System Description Table.
2266 *
2267 * The RSDT and XSDT tables are basically identical. The only difference is 32
2268 * vs 64 bits addresses for description headers. RSDT is for ACPI 1.0. XSDT for
2269 * ACPI 2.0 and up.
2270 */
2271static int acpiR3SetupRsdt(ACPIState *pThis, RTGCPHYS32 addr, unsigned int nb_entries, uint32_t *addrs)
2272{
2273 ACPITBLRSDT *rsdt;
2274 const size_t size = sizeof(ACPITBLHEADER) + nb_entries * sizeof(rsdt->u32Entry[0]);
2275
2276 rsdt = (ACPITBLRSDT*)RTMemAllocZ(size);
2277 if (!rsdt)
2278 return PDMDEV_SET_ERROR(pThis->pDevInsR3, VERR_NO_TMP_MEMORY, N_("Cannot allocate RSDT"));
2279
2280 acpiR3PrepareHeader(pThis, &rsdt->header, "RSDT", (uint32_t)size, 1);
2281 for (unsigned int i = 0; i < nb_entries; ++i)
2282 {
2283 rsdt->u32Entry[i] = RT_H2LE_U32(addrs[i]);
2284 Log(("Setup RSDT: [%d] = %x\n", i, rsdt->u32Entry[i]));
2285 }
2286 rsdt->header.u8Checksum = acpiR3Checksum(rsdt, size);
2287 acpiR3PhysCopy(pThis, addr, rsdt, size);
2288 RTMemFree(rsdt);
2289 return VINF_SUCCESS;
2290}
2291
2292/**
2293 * Plant the Extended System Description Table.
2294 */
2295static int acpiR3SetupXsdt(ACPIState *pThis, RTGCPHYS32 addr, unsigned int nb_entries, uint32_t *addrs)
2296{
2297 ACPITBLXSDT *xsdt;
2298 const size_t size = sizeof(ACPITBLHEADER) + nb_entries * sizeof(xsdt->u64Entry[0]);
2299
2300 xsdt = (ACPITBLXSDT*)RTMemAllocZ(size);
2301 if (!xsdt)
2302 return VERR_NO_TMP_MEMORY;
2303
2304 acpiR3PrepareHeader(pThis, &xsdt->header, "XSDT", (uint32_t)size, 1 /* according to ACPI 3.0 specs */);
2305
2306 if (pThis->fUseCust)
2307 memcpy(xsdt->header.au8OemTabId, pThis->au8OemTabId, 8);
2308
2309 for (unsigned int i = 0; i < nb_entries; ++i)
2310 {
2311 xsdt->u64Entry[i] = RT_H2LE_U64((uint64_t)addrs[i]);
2312 Log(("Setup XSDT: [%d] = %RX64\n", i, xsdt->u64Entry[i]));
2313 }
2314 xsdt->header.u8Checksum = acpiR3Checksum(xsdt, size);
2315 acpiR3PhysCopy(pThis, addr, xsdt, size);
2316 RTMemFree(xsdt);
2317 return VINF_SUCCESS;
2318}
2319
2320/**
2321 * Plant the Root System Description Pointer (RSDP).
2322 */
2323static void acpiR3SetupRsdp(ACPIState *pThis, ACPITBLRSDP *rsdp, RTGCPHYS32 GCPhysRsdt, RTGCPHYS GCPhysXsdt)
2324{
2325 memset(rsdp, 0, sizeof(*rsdp));
2326
2327 /* ACPI 1.0 part (RSDT) */
2328 memcpy(rsdp->au8Signature, "RSD PTR ", 8);
2329 memcpy(rsdp->au8OemId, pThis->au8OemId, 6);
2330 rsdp->u8Revision = ACPI_REVISION;
2331 rsdp->u32RSDT = RT_H2LE_U32(GCPhysRsdt);
2332 rsdp->u8Checksum = acpiR3Checksum(rsdp, RT_OFFSETOF(ACPITBLRSDP, u32Length));
2333
2334 /* ACPI 2.0 part (XSDT) */
2335 rsdp->u32Length = RT_H2LE_U32(sizeof(ACPITBLRSDP));
2336 rsdp->u64XSDT = RT_H2LE_U64(GCPhysXsdt);
2337 rsdp->u8ExtChecksum = acpiR3Checksum(rsdp, sizeof(ACPITBLRSDP));
2338}
2339
2340/**
2341 * Multiple APIC Description Table.
2342 *
2343 * This structure looks somewhat convoluted due layout of MADT table in MP case.
2344 * There extpected to be multiple LAPIC records for each CPU, thus we cannot
2345 * use regular C structure and proxy to raw memory instead.
2346 */
2347class AcpiTableMadt
2348{
2349 /**
2350 * All actual data stored in dynamically allocated memory pointed by this field.
2351 */
2352 uint8_t *m_pbData;
2353 /**
2354 * Number of CPU entries in this MADT.
2355 */
2356 uint32_t m_cCpus;
2357
2358 /**
2359 * Number of interrupt overrides.
2360 */
2361 uint32_t m_cIsos;
2362
2363public:
2364 /**
2365 * Address of ACPI header
2366 */
2367 inline ACPITBLHEADER *header_addr(void) const
2368 {
2369 return (ACPITBLHEADER *)m_pbData;
2370 }
2371
2372 /**
2373 * Address of local APIC for each CPU. Note that different CPUs address different LAPICs,
2374 * although address is the same for all of them.
2375 */
2376 inline uint32_t *u32LAPIC_addr(void) const
2377 {
2378 return (uint32_t *)(header_addr() + 1);
2379 }
2380
2381 /**
2382 * Address of APIC flags
2383 */
2384 inline uint32_t *u32Flags_addr(void) const
2385 {
2386 return (uint32_t *)(u32LAPIC_addr() + 1);
2387 }
2388
2389 /**
2390 * Address of ISO description
2391 */
2392 inline ACPITBLISO *ISO_addr(void) const
2393 {
2394 return (ACPITBLISO *)(u32Flags_addr() + 1);
2395 }
2396
2397 /**
2398 * Address of per-CPU LAPIC descriptions
2399 */
2400 inline ACPITBLLAPIC *LApics_addr(void) const
2401 {
2402 return (ACPITBLLAPIC *)(ISO_addr() + m_cIsos);
2403 }
2404
2405 /**
2406 * Address of IO APIC description
2407 */
2408 inline ACPITBLIOAPIC *IOApic_addr(void) const
2409 {
2410 return (ACPITBLIOAPIC *)(LApics_addr() + m_cCpus);
2411 }
2412
2413 /**
2414 * Size of MADT.
2415 * Note that this function assumes IOApic to be the last field in structure.
2416 */
2417 inline uint32_t size(void) const
2418 {
2419 return (uint8_t *)(IOApic_addr() + 1) - (uint8_t *)header_addr();
2420 }
2421
2422 /**
2423 * Raw data of MADT.
2424 */
2425 inline const uint8_t *data(void) const
2426 {
2427 return m_pbData;
2428 }
2429
2430 /**
2431 * Size of MADT for given ACPI config, useful to compute layout.
2432 */
2433 static uint32_t sizeFor(ACPIState *pThis, uint32_t cIsos)
2434 {
2435 return AcpiTableMadt(pThis->cCpus, cIsos).size();
2436 }
2437
2438 /*
2439 * Constructor, only works in Ring 3, doesn't look like a big deal.
2440 */
2441 AcpiTableMadt(uint32_t cCpus, uint32_t cIsos)
2442 {
2443 m_cCpus = cCpus;
2444 m_cIsos = cIsos;
2445 m_pbData = NULL; /* size() uses this and gcc will complain if not initialized. */
2446 uint32_t cb = size();
2447 m_pbData = (uint8_t *)RTMemAllocZ(cb);
2448 }
2449
2450 ~AcpiTableMadt()
2451 {
2452 RTMemFree(m_pbData);
2453 }
2454};
2455
2456
2457/**
2458 * Plant the Multiple APIC Description Table (MADT).
2459 *
2460 * @note APIC without IO-APIC hangs Windows Vista therefore we setup both.
2461 *
2462 * @todo All hardcoded, should set this up based on the actual VM config!!!!!
2463 */
2464static void acpiR3SetupMadt(ACPIState *pThis, RTGCPHYS32 addr)
2465{
2466 uint16_t cpus = pThis->cCpus;
2467 AcpiTableMadt madt(cpus, NUMBER_OF_IRQ_SOURCE_OVERRIDES);
2468
2469 acpiR3PrepareHeader(pThis, madt.header_addr(), "APIC", madt.size(), 2);
2470
2471 *madt.u32LAPIC_addr() = RT_H2LE_U32(0xfee00000);
2472 *madt.u32Flags_addr() = RT_H2LE_U32(PCAT_COMPAT);
2473
2474 /* LAPICs records */
2475 ACPITBLLAPIC* lapic = madt.LApics_addr();
2476 for (uint16_t i = 0; i < cpus; i++)
2477 {
2478 lapic->u8Type = 0;
2479 lapic->u8Length = sizeof(ACPITBLLAPIC);
2480 lapic->u8ProcId = i;
2481 /** Must match numbering convention in MPTABLES */
2482 lapic->u8ApicId = i;
2483 lapic->u32Flags = VMCPUSET_IS_PRESENT(&pThis->CpuSetAttached, i) ? RT_H2LE_U32(LAPIC_ENABLED) : 0;
2484 lapic++;
2485 }
2486
2487 /* IO-APIC record */
2488 ACPITBLIOAPIC* ioapic = madt.IOApic_addr();
2489 ioapic->u8Type = 1;
2490 ioapic->u8Length = sizeof(ACPITBLIOAPIC);
2491 /** Must match MP tables ID */
2492 ioapic->u8IOApicId = cpus;
2493 ioapic->u8Reserved = 0;
2494 ioapic->u32Address = RT_H2LE_U32(0xfec00000);
2495 ioapic->u32GSIB = RT_H2LE_U32(0);
2496
2497 /* Interrupt Source Overrides */
2498 /* Flags:
2499 bits[3:2]:
2500 00 conforms to the bus
2501 01 edge-triggered
2502 10 reserved
2503 11 level-triggered
2504 bits[1:0]
2505 00 conforms to the bus
2506 01 active-high
2507 10 reserved
2508 11 active-low */
2509 /* If changing, also update PDMIsaSetIrq() and MPS */
2510 ACPITBLISO* isos = madt.ISO_addr();
2511 /* Timer interrupt rule IRQ0 to GSI2 */
2512 isos[0].u8Type = 2;
2513 isos[0].u8Length = sizeof(ACPITBLISO);
2514 isos[0].u8Bus = 0; /* Must be 0 */
2515 isos[0].u8Source = 0; /* IRQ0 */
2516 isos[0].u32GSI = 2; /* connected to pin 2 */
2517 isos[0].u16Flags = 0; /* conform to the bus */
2518
2519 /* ACPI interrupt rule - IRQ9 to GSI9 */
2520 isos[1].u8Type = 2;
2521 isos[1].u8Length = sizeof(ACPITBLISO);
2522 isos[1].u8Bus = 0; /* Must be 0 */
2523 isos[1].u8Source = 9; /* IRQ9 */
2524 isos[1].u32GSI = 9; /* connected to pin 9 */
2525 isos[1].u16Flags = 0xd; /* active high, level triggered */
2526 Assert(NUMBER_OF_IRQ_SOURCE_OVERRIDES == 2);
2527
2528 madt.header_addr()->u8Checksum = acpiR3Checksum(madt.data(), madt.size());
2529 acpiR3PhysCopy(pThis, addr, madt.data(), madt.size());
2530}
2531
2532/**
2533 * Plant the High Performance Event Timer (HPET) descriptor.
2534 */
2535static void acpiR3SetupHpet(ACPIState *pThis, RTGCPHYS32 addr)
2536{
2537 ACPITBLHPET hpet;
2538
2539 memset(&hpet, 0, sizeof(hpet));
2540
2541 acpiR3PrepareHeader(pThis, &hpet.aHeader, "HPET", sizeof(hpet), 1);
2542 /* Keep base address consistent with appropriate DSDT entry (vbox.dsl) */
2543 acpiR3WriteGenericAddr(&hpet.HpetAddr,
2544 0 /* Memory address space */,
2545 64 /* Register bit width */,
2546 0 /* Bit offset */,
2547 0, /* Register access size, is it correct? */
2548 0xfed00000 /* Address */);
2549
2550 hpet.u32Id = 0x8086a201; /* must match what HPET ID returns, is it correct ? */
2551 hpet.u32Number = 0;
2552 hpet.u32MinTick = 4096;
2553 hpet.u8Attributes = 0;
2554
2555 hpet.aHeader.u8Checksum = acpiR3Checksum(&hpet, sizeof(hpet));
2556
2557 acpiR3PhysCopy(pThis, addr, (const uint8_t *)&hpet, sizeof(hpet));
2558}
2559
2560
2561/** Custom Description Table */
2562static void acpiR3SetupCust(ACPIState *pThis, RTGCPHYS32 addr)
2563{
2564 ACPITBLCUST cust;
2565
2566 /* First the ACPI version 1 version of the structure. */
2567 memset(&cust, 0, sizeof(cust));
2568 acpiR3PrepareHeader(pThis, &cust.header, "CUST", sizeof(cust), 1);
2569
2570 memcpy(cust.header.au8OemTabId, pThis->au8OemTabId, 8);
2571 cust.header.u32OemRevision = RT_H2LE_U32(pThis->u32OemRevision);
2572 cust.header.u8Checksum = acpiR3Checksum((uint8_t *)&cust, sizeof(cust));
2573
2574 acpiR3PhysCopy(pThis, addr, pThis->pu8CustBin, pThis->cbCustBin);
2575}
2576
2577/**
2578 * Used by acpiR3PlantTables to plant a MMCONFIG PCI config space access (MCFG)
2579 * descriptor.
2580 *
2581 * @param pThis The ACPI instance.
2582 * @param GCPhysDst Where to plant it.
2583 */
2584static void acpiR3SetupMcfg(ACPIState *pThis, RTGCPHYS32 GCPhysDst)
2585{
2586 struct
2587 {
2588 ACPITBLMCFG hdr;
2589 ACPITBLMCFGENTRY entry;
2590 } tbl;
2591 uint8_t u8StartBus = 0;
2592 uint8_t u8EndBus = (pThis->u64PciConfigMMioLength >> 20) - 1;
2593
2594 RT_ZERO(tbl);
2595
2596 acpiR3PrepareHeader(pThis, &tbl.hdr.aHeader, "MCFG", sizeof(tbl), 1);
2597 tbl.entry.u64BaseAddress = pThis->u64PciConfigMMioAddress;
2598 tbl.entry.u8StartBus = u8StartBus;
2599 tbl.entry.u8EndBus = u8EndBus;
2600 // u16PciSegmentGroup must match _SEG in ACPI table
2601
2602 tbl.hdr.aHeader.u8Checksum = acpiR3Checksum(&tbl, sizeof(tbl));
2603
2604 acpiR3PhysCopy(pThis, GCPhysDst, (const uint8_t *)&tbl, sizeof(tbl));
2605}
2606
2607/**
2608 * Used by acpiR3PlantTables and acpiConstruct.
2609 *
2610 * @returns Guest memory address.
2611 */
2612static uint32_t apicR3FindRsdpSpace(void)
2613{
2614 return 0xe0000;
2615}
2616
2617/**
2618 * Create the ACPI tables in guest memory.
2619 */
2620static int acpiR3PlantTables(ACPIState *pThis)
2621{
2622 int rc;
2623 RTGCPHYS32 GCPhysCur, GCPhysRsdt, GCPhysXsdt, GCPhysFadtAcpi1, GCPhysFadtAcpi2, GCPhysFacs, GCPhysDsdt;
2624 RTGCPHYS32 GCPhysHpet = 0;
2625 RTGCPHYS32 GCPhysApic = 0;
2626 RTGCPHYS32 GCPhysSsdt = 0;
2627 RTGCPHYS32 GCPhysMcfg = 0;
2628 RTGCPHYS32 GCPhysCust = 0;
2629 uint32_t addend = 0;
2630 RTGCPHYS32 aGCPhysRsdt[8];
2631 RTGCPHYS32 aGCPhysXsdt[8];
2632 uint32_t cAddr;
2633 uint32_t iMadt = 0;
2634 uint32_t iHpet = 0;
2635 uint32_t iSsdt = 0;
2636 uint32_t iMcfg = 0;
2637 uint32_t iCust = 0;
2638 size_t cbRsdt = sizeof(ACPITBLHEADER);
2639 size_t cbXsdt = sizeof(ACPITBLHEADER);
2640
2641 cAddr = 1; /* FADT */
2642 if (pThis->u8UseIOApic)
2643 iMadt = cAddr++; /* MADT */
2644
2645 if (pThis->fUseHpet)
2646 iHpet = cAddr++; /* HPET */
2647
2648 if (pThis->fUseMcfg)
2649 iMcfg = cAddr++; /* MCFG */
2650
2651 if (pThis->fUseCust)
2652 iCust = cAddr++; /* CUST */
2653
2654 iSsdt = cAddr++; /* SSDT */
2655
2656 Assert(cAddr < RT_ELEMENTS(aGCPhysRsdt));
2657 Assert(cAddr < RT_ELEMENTS(aGCPhysXsdt));
2658
2659 cbRsdt += cAddr*sizeof(uint32_t); /* each entry: 32 bits phys. address. */
2660 cbXsdt += cAddr*sizeof(uint64_t); /* each entry: 64 bits phys. address. */
2661
2662 rc = CFGMR3QueryU64(pThis->pDevInsR3->pCfg, "RamSize", &pThis->u64RamSize);
2663 if (RT_FAILURE(rc))
2664 return PDMDEV_SET_ERROR(pThis->pDevInsR3, rc,
2665 N_("Configuration error: Querying \"RamSize\" as integer failed"));
2666
2667 uint32_t cbRamHole;
2668 rc = CFGMR3QueryU32Def(pThis->pDevInsR3->pCfg, "RamHoleSize", &cbRamHole, MM_RAM_HOLE_SIZE_DEFAULT);
2669 if (RT_FAILURE(rc))
2670 return PDMDEV_SET_ERROR(pThis->pDevInsR3, rc,
2671 N_("Configuration error: Querying \"RamHoleSize\" as integer failed"));
2672
2673 /*
2674 * Calculate the sizes for the high and low regions.
2675 */
2676 const uint64_t offRamHole = _4G - cbRamHole;
2677 pThis->cbRamHigh = offRamHole < pThis->u64RamSize ? pThis->u64RamSize - offRamHole : 0;
2678 uint64_t cbRamLow = offRamHole < pThis->u64RamSize ? offRamHole : pThis->u64RamSize;
2679 if (cbRamLow > UINT32_C(0xffe00000)) /* See MEM3. */
2680 {
2681 /* Note: This is also enforced by DevPcBios.cpp. */
2682 LogRel(("ACPI: Clipping cbRamLow=%#RX64 down to 0xffe00000.\n", cbRamLow));
2683 cbRamLow = UINT32_C(0xffe00000);
2684 }
2685 pThis->cbRamLow = (uint32_t)cbRamLow;
2686
2687 GCPhysCur = 0;
2688 GCPhysRsdt = GCPhysCur;
2689
2690 GCPhysCur = RT_ALIGN_32(GCPhysCur + cbRsdt, 16);
2691 GCPhysXsdt = GCPhysCur;
2692
2693 GCPhysCur = RT_ALIGN_32(GCPhysCur + cbXsdt, 16);
2694 GCPhysFadtAcpi1 = GCPhysCur;
2695
2696 GCPhysCur = RT_ALIGN_32(GCPhysCur + ACPITBLFADT_VERSION1_SIZE, 16);
2697 GCPhysFadtAcpi2 = GCPhysCur;
2698
2699 GCPhysCur = RT_ALIGN_32(GCPhysCur + sizeof(ACPITBLFADT), 64);
2700 GCPhysFacs = GCPhysCur;
2701
2702 GCPhysCur = RT_ALIGN_32(GCPhysCur + sizeof(ACPITBLFACS), 16);
2703 if (pThis->u8UseIOApic)
2704 {
2705 GCPhysApic = GCPhysCur;
2706 GCPhysCur = RT_ALIGN_32(GCPhysCur + AcpiTableMadt::sizeFor(pThis, NUMBER_OF_IRQ_SOURCE_OVERRIDES), 16);
2707 }
2708 if (pThis->fUseHpet)
2709 {
2710 GCPhysHpet = GCPhysCur;
2711 GCPhysCur = RT_ALIGN_32(GCPhysCur + sizeof(ACPITBLHPET), 16);
2712 }
2713 if (pThis->fUseMcfg)
2714 {
2715 GCPhysMcfg = GCPhysCur;
2716 /* Assume one entry */
2717 GCPhysCur = RT_ALIGN_32(GCPhysCur + sizeof(ACPITBLMCFG) + sizeof(ACPITBLMCFGENTRY), 16);
2718 }
2719 if (pThis->fUseCust)
2720 {
2721 GCPhysCust = GCPhysCur;
2722 GCPhysCur = RT_ALIGN_32(GCPhysCur + pThis->cbCustBin, 16);
2723 }
2724
2725 void *pvSsdtCode = NULL;
2726 size_t cbSsdt = 0;
2727 rc = acpiPrepareSsdt(pThis->pDevInsR3, &pvSsdtCode, &cbSsdt);
2728 if (RT_FAILURE(rc))
2729 return rc;
2730
2731 GCPhysSsdt = GCPhysCur;
2732 GCPhysCur = RT_ALIGN_32(GCPhysCur + cbSsdt, 16);
2733
2734 GCPhysDsdt = GCPhysCur;
2735
2736 void *pvDsdtCode = NULL;
2737 size_t cbDsdt = 0;
2738 rc = acpiPrepareDsdt(pThis->pDevInsR3, &pvDsdtCode, &cbDsdt);
2739 if (RT_FAILURE(rc))
2740 return rc;
2741
2742 GCPhysCur = RT_ALIGN_32(GCPhysCur + cbDsdt, 16);
2743
2744 if (GCPhysCur > 0x10000)
2745 return PDMDEV_SET_ERROR(pThis->pDevInsR3, VERR_TOO_MUCH_DATA,
2746 N_("Error: ACPI tables bigger than 64KB"));
2747
2748 Log(("RSDP 0x%08X\n", apicR3FindRsdpSpace()));
2749 addend = pThis->cbRamLow - 0x10000;
2750 Log(("RSDT 0x%08X XSDT 0x%08X\n", GCPhysRsdt + addend, GCPhysXsdt + addend));
2751 Log(("FACS 0x%08X FADT (1.0) 0x%08X, FADT (2+) 0x%08X\n", GCPhysFacs + addend, GCPhysFadtAcpi1 + addend, GCPhysFadtAcpi2 + addend));
2752 Log(("DSDT 0x%08X", GCPhysDsdt + addend));
2753 if (pThis->u8UseIOApic)
2754 Log((" MADT 0x%08X", GCPhysApic + addend));
2755 if (pThis->fUseHpet)
2756 Log((" HPET 0x%08X", GCPhysHpet + addend));
2757 if (pThis->fUseMcfg)
2758 Log((" MCFG 0x%08X", GCPhysMcfg + addend));
2759 if (pThis->fUseCust)
2760 Log((" CUST 0x%08X", GCPhysCust + addend));
2761 Log((" SSDT 0x%08X", GCPhysSsdt + addend));
2762 Log(("\n"));
2763
2764 acpiR3SetupRsdp(pThis, (ACPITBLRSDP *)pThis->au8RSDPPage, GCPhysRsdt + addend, GCPhysXsdt + addend);
2765 acpiR3SetupDsdt(pThis, GCPhysDsdt + addend, pvDsdtCode, cbDsdt);
2766 acpiCleanupDsdt(pThis->pDevInsR3, pvDsdtCode);
2767 acpiR3SetupFacs(pThis, GCPhysFacs + addend);
2768 acpiR3SetupFadt(pThis, GCPhysFadtAcpi1 + addend, GCPhysFadtAcpi2 + addend, GCPhysFacs + addend, GCPhysDsdt + addend);
2769
2770 aGCPhysRsdt[0] = GCPhysFadtAcpi1 + addend;
2771 aGCPhysXsdt[0] = GCPhysFadtAcpi2 + addend;
2772 if (pThis->u8UseIOApic)
2773 {
2774 acpiR3SetupMadt(pThis, GCPhysApic + addend);
2775 aGCPhysRsdt[iMadt] = GCPhysApic + addend;
2776 aGCPhysXsdt[iMadt] = GCPhysApic + addend;
2777 }
2778 if (pThis->fUseHpet)
2779 {
2780 acpiR3SetupHpet(pThis, GCPhysHpet + addend);
2781 aGCPhysRsdt[iHpet] = GCPhysHpet + addend;
2782 aGCPhysXsdt[iHpet] = GCPhysHpet + addend;
2783 }
2784 if (pThis->fUseMcfg)
2785 {
2786 acpiR3SetupMcfg(pThis, GCPhysMcfg + addend);
2787 aGCPhysRsdt[iMcfg] = GCPhysMcfg + addend;
2788 aGCPhysXsdt[iMcfg] = GCPhysMcfg + addend;
2789 }
2790 if (pThis->fUseCust)
2791 {
2792 acpiR3SetupCust(pThis, GCPhysCust + addend);
2793 aGCPhysRsdt[iCust] = GCPhysCust + addend;
2794 aGCPhysXsdt[iCust] = GCPhysCust + addend;
2795 }
2796
2797 acpiR3SetupSsdt(pThis, GCPhysSsdt + addend, pvSsdtCode, cbSsdt);
2798 acpiCleanupSsdt(pThis->pDevInsR3, pvSsdtCode);
2799 aGCPhysRsdt[iSsdt] = GCPhysSsdt + addend;
2800 aGCPhysXsdt[iSsdt] = GCPhysSsdt + addend;
2801
2802 rc = acpiR3SetupRsdt(pThis, GCPhysRsdt + addend, cAddr, aGCPhysRsdt);
2803 if (RT_FAILURE(rc))
2804 return rc;
2805 return acpiR3SetupXsdt(pThis, GCPhysXsdt + addend, cAddr, aGCPhysXsdt);
2806}
2807
2808/**
2809 * @callback_method_impl{FNPCICONFIGREAD}
2810 */
2811static DECLCALLBACK(uint32_t) acpiR3PciConfigRead(PPCIDEVICE pPciDev, uint32_t Address, unsigned cb)
2812{
2813 PPDMDEVINS pDevIns = pPciDev->pDevIns;
2814 ACPIState *pThis = PDMINS_2_DATA(pDevIns, ACPIState *);
2815
2816 Log2(("acpi: PCI config read: 0x%x (%d)\n", Address, cb));
2817 return pThis->pfnAcpiPciConfigRead(pPciDev, Address, cb);
2818}
2819
2820/**
2821 * @callback_method_impl{FNPCICONFIGWRITE}
2822 */
2823static DECLCALLBACK(void) acpiR3PciConfigWrite(PPCIDEVICE pPciDev, uint32_t Address, uint32_t u32Value, unsigned cb)
2824{
2825 PPDMDEVINS pDevIns = pPciDev->pDevIns;
2826 ACPIState *pThis = PDMINS_2_DATA(pDevIns, ACPIState *);
2827
2828 Log2(("acpi: PCI config write: 0x%x -> 0x%x (%d)\n", u32Value, Address, cb));
2829 DEVACPI_LOCK_R3(pThis);
2830
2831 if (Address == VBOX_PCI_INTERRUPT_LINE)
2832 {
2833 Log(("acpi: ignore interrupt line settings: %d, we'll use hardcoded value %d\n", u32Value, SCI_INT));
2834 u32Value = SCI_INT;
2835 }
2836
2837 pThis->pfnAcpiPciConfigWrite(pPciDev, Address, u32Value, cb);
2838
2839 /* PMREGMISC written */
2840 if (Address == 0x80)
2841 {
2842 /* Check Power Management IO Space Enable (PMIOSE) bit */
2843 if (pPciDev->config[0x80] & 0x1)
2844 {
2845 RTIOPORT NewIoPortBase = (RTIOPORT)PCIDevGetDWord(pPciDev, 0x40);
2846 NewIoPortBase &= 0xffc0;
2847
2848 int rc = acpiR3UpdatePmHandlers(pThis, NewIoPortBase);
2849 AssertRC(rc);
2850 }
2851 }
2852
2853 DEVACPI_UNLOCK(pThis);
2854}
2855
2856/**
2857 * Attach a new CPU.
2858 *
2859 * @returns VBox status code.
2860 * @param pDevIns The device instance.
2861 * @param iLUN The logical unit which is being attached.
2862 * @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
2863 *
2864 * @remarks This code path is not used during construction.
2865 */
2866static DECLCALLBACK(int) acpiR3Attach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
2867{
2868 ACPIState *pThis = PDMINS_2_DATA(pDevIns, ACPIState *);
2869 LogFlow(("acpiAttach: pDevIns=%p iLUN=%u fFlags=%#x\n", pDevIns, iLUN, fFlags));
2870
2871 AssertMsgReturn(!(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG),
2872 ("Hot-plug flag is not set\n"),
2873 VERR_NOT_SUPPORTED);
2874 AssertReturn(iLUN < VMM_MAX_CPU_COUNT, VERR_PDM_NO_SUCH_LUN);
2875
2876 /* Check if it was already attached */
2877 int rc = VINF_SUCCESS;
2878 DEVACPI_LOCK_R3(pThis);
2879 if (!VMCPUSET_IS_PRESENT(&pThis->CpuSetAttached, iLUN))
2880 {
2881 PPDMIBASE IBaseTmp;
2882 rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pThis->IBase, &IBaseTmp, "ACPI CPU");
2883 if (RT_SUCCESS(rc))
2884 {
2885 /* Enable the CPU */
2886 VMCPUSET_ADD(&pThis->CpuSetAttached, iLUN);
2887
2888 /*
2889 * Lock the CPU because we don't know if the guest will use it or not.
2890 * Prevents ejection while the CPU is still used
2891 */
2892 VMCPUSET_ADD(&pThis->CpuSetLocked, iLUN);
2893 pThis->u32CpuEventType = CPU_EVENT_TYPE_ADD;
2894 pThis->u32CpuEvent = iLUN;
2895
2896 /* Notify the guest */
2897 apicR3UpdateGpe0(pThis, pThis->gpe0_sts | 0x2, pThis->gpe0_en);
2898 }
2899 }
2900 DEVACPI_UNLOCK(pThis);
2901 return rc;
2902}
2903
2904/**
2905 * Detach notification.
2906 *
2907 * @param pDevIns The device instance.
2908 * @param iLUN The logical unit which is being detached.
2909 * @param fFlags Flags, combination of the PDMDEVATT_FLAGS_* \#defines.
2910 */
2911static DECLCALLBACK(void) acpiR3Detach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
2912{
2913 ACPIState *pThis = PDMINS_2_DATA(pDevIns, ACPIState *);
2914
2915 LogFlow(("acpiDetach: pDevIns=%p iLUN=%u fFlags=%#x\n", pDevIns, iLUN, fFlags));
2916
2917 AssertMsgReturnVoid(!(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG),
2918 ("Hot-plug flag is not set\n"));
2919
2920 /* Check if it was already detached */
2921 DEVACPI_LOCK_R3(pThis);
2922 if (VMCPUSET_IS_PRESENT(&pThis->CpuSetAttached, iLUN))
2923 {
2924 if (!VMCPUSET_IS_PRESENT(&pThis->CpuSetLocked, iLUN))
2925 {
2926 /* Disable the CPU */
2927 VMCPUSET_DEL(&pThis->CpuSetAttached, iLUN);
2928 pThis->u32CpuEventType = CPU_EVENT_TYPE_REMOVE;
2929 pThis->u32CpuEvent = iLUN;
2930
2931 /* Notify the guest */
2932 apicR3UpdateGpe0(pThis, pThis->gpe0_sts | 0x2, pThis->gpe0_en);
2933 }
2934 else
2935 AssertMsgFailed(("CPU is still locked by the guest\n"));
2936 }
2937 DEVACPI_UNLOCK(pThis);
2938}
2939
2940/**
2941 * @interface_method_impl{PDMDEVREG,pfnResume}
2942 */
2943static DECLCALLBACK(void) acpiR3Resume(PPDMDEVINS pDevIns)
2944{
2945 ACPIState *pThis = PDMINS_2_DATA(pDevIns, ACPIState *);
2946 if (pThis->fSetWakeupOnResume)
2947 {
2948 Log(("acpiResume: setting WAK_STS\n"));
2949 pThis->fSetWakeupOnResume = false;
2950 pThis->pm1a_sts |= WAK_STS;
2951 }
2952}
2953
2954/**
2955 * @interface_method_impl{PDMDEVREG,pfnMemSetup}
2956 */
2957static DECLCALLBACK(void) acpiR3MemSetup(PPDMDEVINS pDevIns, PDMDEVMEMSETUPCTX enmCtx)
2958{
2959 ACPIState *pThis = PDMINS_2_DATA(pDevIns, ACPIState *);
2960 acpiR3PlantTables(pThis);
2961}
2962
2963/**
2964 * @interface_method_impl{PDMDEVREG,pfnReset}
2965 */
2966static DECLCALLBACK(void) acpiR3Reset(PPDMDEVINS pDevIns)
2967{
2968 ACPIState *pThis = PDMINS_2_DATA(pDevIns, ACPIState *);
2969
2970 TMTimerLock(pThis->pPmTimerR3, VERR_IGNORED);
2971 pThis->pm1a_en = 0;
2972 pThis->pm1a_sts = 0;
2973 pThis->pm1a_ctl = 0;
2974 pThis->u64PmTimerInitial = TMTimerGet(pThis->pPmTimerR3);
2975 pThis->uPmTimerVal = 0;
2976 acpiR3PmTimerReset(pThis, pThis->u64PmTimerInitial);
2977 pThis->uBatteryIndex = 0;
2978 pThis->uSystemInfoIndex = 0;
2979 pThis->gpe0_en = 0;
2980 pThis->gpe0_sts = 0;
2981 pThis->uSleepState = 0;
2982 TMTimerUnlock(pThis->pPmTimerR3);
2983
2984 /** @todo Should we really reset PM base? */
2985 acpiR3UpdatePmHandlers(pThis, PM_PORT_BASE);
2986}
2987
2988/**
2989 * @interface_method_impl{PDMDEVREG,pfnRelocate}
2990 */
2991static DECLCALLBACK(void) acpiR3Relocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta)
2992{
2993 ACPIState *pThis = PDMINS_2_DATA(pDevIns, ACPIState *);
2994 pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
2995 pThis->pPmTimerRC = TMTimerRCPtr(pThis->pPmTimerR3);
2996 NOREF(offDelta);
2997}
2998
2999/**
3000 * @interface_method_impl{PDMDEVREG,pfnDestruct}
3001 */
3002static DECLCALLBACK(int) acpiR3Destruct(PPDMDEVINS pDevIns)
3003{
3004 ACPIState *pThis = PDMINS_2_DATA(pDevIns, ACPIState *);
3005 if (pThis->pu8CustBin)
3006 {
3007 MMR3HeapFree(pThis->pu8CustBin);
3008 pThis->pu8CustBin = NULL;
3009 }
3010 return VINF_SUCCESS;
3011}
3012
3013/**
3014 * @interface_method_impl{PDMDEVREG,pfnConstruct}
3015 */
3016static DECLCALLBACK(int) acpiR3Construct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
3017{
3018 ACPIState *pThis = PDMINS_2_DATA(pDevIns, ACPIState *);
3019 PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
3020
3021 /*
3022 * Init data and set defaults.
3023 */
3024 /** @todo move more of the code up! */
3025
3026 pThis->pDevInsR3 = pDevIns;
3027 pThis->pDevInsR0 = PDMDEVINS_2_R0PTR(pDevIns);
3028 pThis->pDevInsRC = PDMDEVINS_2_RCPTR(pDevIns);
3029 VMCPUSET_EMPTY(&pThis->CpuSetAttached);
3030 VMCPUSET_EMPTY(&pThis->CpuSetLocked);
3031 pThis->idCpuLockCheck = UINT32_C(0xffffffff);
3032 pThis->u32CpuEventType = 0;
3033 pThis->u32CpuEvent = UINT32_C(0xffffffff);
3034
3035 /* The first CPU can't be attached/detached */
3036 VMCPUSET_ADD(&pThis->CpuSetAttached, 0);
3037 VMCPUSET_ADD(&pThis->CpuSetLocked, 0);
3038
3039 /* IBase */
3040 pThis->IBase.pfnQueryInterface = acpiR3QueryInterface;
3041 /* IACPIPort */
3042 pThis->IACPIPort.pfnSleepButtonPress = acpiR3Port_SleepButtonPress;
3043 pThis->IACPIPort.pfnPowerButtonPress = acpiR3Port_PowerButtonPress;
3044 pThis->IACPIPort.pfnGetPowerButtonHandled = acpiR3Port_GetPowerButtonHandled;
3045 pThis->IACPIPort.pfnGetGuestEnteredACPIMode = acpiR3Port_GetGuestEnteredACPIMode;
3046 pThis->IACPIPort.pfnGetCpuStatus = acpiR3Port_GetCpuStatus;
3047 pThis->IACPIPort.pfnMonitorHotPlugEvent = acpiR3Port_MonitorHotPlugEvent;
3048
3049 /*
3050 * Set the default critical section to NOP (related to the PM timer).
3051 */
3052 int rc = PDMDevHlpSetDeviceCritSect(pDevIns, PDMDevHlpCritSectGetNop(pDevIns));
3053 AssertRCReturn(rc, rc);
3054
3055 rc = PDMDevHlpCritSectInit(pDevIns, &pThis->CritSect, RT_SRC_POS, "acpi#%u", iInstance);
3056 AssertRCReturn(rc, rc);
3057
3058 /*
3059 * Validate and read the configuration.
3060 */
3061 if (!CFGMR3AreValuesValid(pCfg,
3062 "RamSize\0"
3063 "RamHoleSize\0"
3064 "IOAPIC\0"
3065 "NumCPUs\0"
3066 "GCEnabled\0"
3067 "R0Enabled\0"
3068 "HpetEnabled\0"
3069 "McfgEnabled\0"
3070 "McfgBase\0"
3071 "McfgLength\0"
3072 "SmcEnabled\0"
3073 "FdcEnabled\0"
3074 "ShowRtc\0"
3075 "ShowCpu\0"
3076 "NicPciAddress\0"
3077 "AudioPciAddress\0"
3078 "IocPciAddress\0"
3079 "HostBusPciAddress\0"
3080 "EnableSuspendToDisk\0"
3081 "PowerS1Enabled\0"
3082 "PowerS4Enabled\0"
3083 "CpuHotPlug\0"
3084 "AmlFilePath\0"
3085 "Serial0IoPortBase\0"
3086 "Serial1IoPortBase\0"
3087 "Serial0Irq\0"
3088 "Serial1Irq\0"
3089 "AcpiOemId\0"
3090 "AcpiCreatorId\0"
3091 "AcpiCreatorRev\0"
3092 "CustomTable\0"
3093 "SLICTable\0"
3094 "Parallel0IoPortBase\0"
3095 "Parallel1IoPortBase\0"
3096 "Parallel0Irq\0"
3097 "Parallel1Irq\0"
3098 ))
3099 return PDMDEV_SET_ERROR(pDevIns, VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES,
3100 N_("Configuration error: Invalid config key for ACPI device"));
3101
3102 /* query whether we are supposed to present an IOAPIC */
3103 rc = CFGMR3QueryU8Def(pCfg, "IOAPIC", &pThis->u8UseIOApic, 1);
3104 if (RT_FAILURE(rc))
3105 return PDMDEV_SET_ERROR(pDevIns, rc,
3106 N_("Configuration error: Failed to read \"IOAPIC\""));
3107
3108 rc = CFGMR3QueryU16Def(pCfg, "NumCPUs", &pThis->cCpus, 1);
3109 if (RT_FAILURE(rc))
3110 return PDMDEV_SET_ERROR(pDevIns, rc,
3111 N_("Configuration error: Querying \"NumCPUs\" as integer failed"));
3112
3113 /* query whether we are supposed to present an FDC controller */
3114 rc = CFGMR3QueryBoolDef(pCfg, "FdcEnabled", &pThis->fUseFdc, true);
3115 if (RT_FAILURE(rc))
3116 return PDMDEV_SET_ERROR(pDevIns, rc,
3117 N_("Configuration error: Failed to read \"FdcEnabled\""));
3118
3119 /* query whether we are supposed to present HPET */
3120 rc = CFGMR3QueryBoolDef(pCfg, "HpetEnabled", &pThis->fUseHpet, false);
3121 if (RT_FAILURE(rc))
3122 return PDMDEV_SET_ERROR(pDevIns, rc,
3123 N_("Configuration error: Failed to read \"HpetEnabled\""));
3124 /* query MCFG configuration */
3125 rc = CFGMR3QueryU64Def(pCfg, "McfgBase", &pThis->u64PciConfigMMioAddress, 0);
3126 if (RT_FAILURE(rc))
3127 return PDMDEV_SET_ERROR(pDevIns, rc,
3128 N_("Configuration error: Failed to read \"McfgBase\""));
3129 rc = CFGMR3QueryU64Def(pCfg, "McfgLength", &pThis->u64PciConfigMMioLength, 0);
3130 if (RT_FAILURE(rc))
3131 return PDMDEV_SET_ERROR(pDevIns, rc,
3132 N_("Configuration error: Failed to read \"McfgLength\""));
3133 pThis->fUseMcfg = (pThis->u64PciConfigMMioAddress != 0) && (pThis->u64PciConfigMMioLength != 0);
3134
3135 /* query whether we are supposed to present custom table */
3136 pThis->fUseCust = false;
3137
3138 /* query whether we are supposed to present SMC */
3139 rc = CFGMR3QueryBoolDef(pCfg, "SmcEnabled", &pThis->fUseSmc, false);
3140 if (RT_FAILURE(rc))
3141 return PDMDEV_SET_ERROR(pDevIns, rc,
3142 N_("Configuration error: Failed to read \"SmcEnabled\""));
3143
3144 /* query whether we are supposed to present RTC object */
3145 rc = CFGMR3QueryBoolDef(pCfg, "ShowRtc", &pThis->fShowRtc, false);
3146 if (RT_FAILURE(rc))
3147 return PDMDEV_SET_ERROR(pDevIns, rc,
3148 N_("Configuration error: Failed to read \"ShowRtc\""));
3149
3150 /* query whether we are supposed to present CPU objects */
3151 rc = CFGMR3QueryBoolDef(pCfg, "ShowCpu", &pThis->fShowCpu, false);
3152 if (RT_FAILURE(rc))
3153 return PDMDEV_SET_ERROR(pDevIns, rc,
3154 N_("Configuration error: Failed to read \"ShowCpu\""));
3155
3156 /* query primary NIC PCI address */
3157 rc = CFGMR3QueryU32Def(pCfg, "NicPciAddress", &pThis->u32NicPciAddress, 0);
3158 if (RT_FAILURE(rc))
3159 return PDMDEV_SET_ERROR(pDevIns, rc,
3160 N_("Configuration error: Failed to read \"NicPciAddress\""));
3161
3162 /* query primary NIC PCI address */
3163 rc = CFGMR3QueryU32Def(pCfg, "AudioPciAddress", &pThis->u32AudioPciAddress, 0);
3164 if (RT_FAILURE(rc))
3165 return PDMDEV_SET_ERROR(pDevIns, rc,
3166 N_("Configuration error: Failed to read \"AudioPciAddress\""));
3167
3168 /* query IO controller (southbridge) PCI address */
3169 rc = CFGMR3QueryU32Def(pCfg, "IocPciAddress", &pThis->u32IocPciAddress, 0);
3170 if (RT_FAILURE(rc))
3171 return PDMDEV_SET_ERROR(pDevIns, rc,
3172 N_("Configuration error: Failed to read \"IocPciAddress\""));
3173
3174 /* query host bus controller PCI address */
3175 rc = CFGMR3QueryU32Def(pCfg, "HostBusPciAddress", &pThis->u32HbcPciAddress, 0);
3176 if (RT_FAILURE(rc))
3177 return PDMDEV_SET_ERROR(pDevIns, rc,
3178 N_("Configuration error: Failed to read \"HostBusPciAddress\""));
3179
3180 /* query whether S1 power state should be exposed */
3181 rc = CFGMR3QueryBoolDef(pCfg, "PowerS1Enabled", &pThis->fS1Enabled, false);
3182 if (RT_FAILURE(rc))
3183 return PDMDEV_SET_ERROR(pDevIns, rc,
3184 N_("Configuration error: Failed to read \"PowerS1Enabled\""));
3185
3186 /* query whether S4 power state should be exposed */
3187 rc = CFGMR3QueryBoolDef(pCfg, "PowerS4Enabled", &pThis->fS4Enabled, false);
3188 if (RT_FAILURE(rc))
3189 return PDMDEV_SET_ERROR(pDevIns, rc,
3190 N_("Configuration error: Failed to read \"PowerS4Enabled\""));
3191
3192 /* query whether S1 power state should save the VM state */
3193 rc = CFGMR3QueryBoolDef(pCfg, "EnableSuspendToDisk", &pThis->fSuspendToSavedState, false);
3194 if (RT_FAILURE(rc))
3195 return PDMDEV_SET_ERROR(pDevIns, rc,
3196 N_("Configuration error: Failed to read \"EnableSuspendToDisk\""));
3197
3198 /* query whether we are allow CPU hot plugging */
3199 rc = CFGMR3QueryBoolDef(pCfg, "CpuHotPlug", &pThis->fCpuHotPlug, false);
3200 if (RT_FAILURE(rc))
3201 return PDMDEV_SET_ERROR(pDevIns, rc,
3202 N_("Configuration error: Failed to read \"CpuHotPlug\""));
3203
3204 rc = CFGMR3QueryBoolDef(pCfg, "GCEnabled", &pThis->fGCEnabled, true);
3205 if (RT_FAILURE(rc))
3206 return PDMDEV_SET_ERROR(pDevIns, rc,
3207 N_("Configuration error: Failed to read \"GCEnabled\""));
3208
3209 rc = CFGMR3QueryBoolDef(pCfg, "R0Enabled", &pThis->fR0Enabled, true);
3210 if (RT_FAILURE(rc))
3211 return PDMDEV_SET_ERROR(pDevIns, rc,
3212 N_("configuration error: failed to read \"R0Enabled\""));
3213
3214 /* query serial info */
3215 rc = CFGMR3QueryU8Def(pCfg, "Serial0Irq", &pThis->uSerial0Irq, 4);
3216 if (RT_FAILURE(rc))
3217 return PDMDEV_SET_ERROR(pDevIns, rc,
3218 N_("Configuration error: Failed to read \"Serial0Irq\""));
3219
3220 rc = CFGMR3QueryU16Def(pCfg, "Serial0IoPortBase", &pThis->uSerial0IoPortBase, 0x3f8);
3221 if (RT_FAILURE(rc))
3222 return PDMDEV_SET_ERROR(pDevIns, rc,
3223 N_("Configuration error: Failed to read \"Serial0IoPortBase\""));
3224
3225 /* Serial 1 is enabled, get config data */
3226 rc = CFGMR3QueryU8Def(pCfg, "Serial1Irq", &pThis->uSerial1Irq, 3);
3227 if (RT_FAILURE(rc))
3228 return PDMDEV_SET_ERROR(pDevIns, rc,
3229 N_("Configuration error: Failed to read \"Serial1Irq\""));
3230
3231 rc = CFGMR3QueryU16Def(pCfg, "Serial1IoPortBase", &pThis->uSerial1IoPortBase, 0x2f8);
3232 if (RT_FAILURE(rc))
3233 return PDMDEV_SET_ERROR(pDevIns, rc,
3234 N_("Configuration error: Failed to read \"Serial1IoPortBase\""));
3235
3236 /*
3237 * Query settings for both parallel ports, if the CFGM keys don't exist pretend that
3238 * the corresponding parallel port is not enabled.
3239 */
3240 rc = CFGMR3QueryU8Def(pCfg, "Parallel0Irq", &pThis->uParallel0Irq, 0);
3241 if (RT_FAILURE(rc))
3242 return PDMDEV_SET_ERROR(pDevIns, rc,
3243 N_("Configuration error: Failed to read \"Parallel0Irq\""));
3244
3245 rc = CFGMR3QueryU16Def(pCfg, "Parallel0IoPortBase", &pThis->uParallel0IoPortBase, 0);
3246 if (RT_FAILURE(rc))
3247 return PDMDEV_SET_ERROR(pDevIns, rc,
3248 N_("Configuration error: Failed to read \"Parallel0IoPortBase\""));
3249
3250 rc = CFGMR3QueryU8Def(pCfg, "Parallel1Irq", &pThis->uParallel1Irq, 0);
3251 if (RT_FAILURE(rc))
3252 return PDMDEV_SET_ERROR(pDevIns, rc,
3253 N_("Configuration error: Failed to read \"Parallel1Irq\""));
3254
3255 rc = CFGMR3QueryU16Def(pCfg, "Parallel1IoPortBase", &pThis->uParallel1IoPortBase, 0);
3256 if (RT_FAILURE(rc))
3257 return PDMDEV_SET_ERROR(pDevIns, rc,
3258 N_("Configuration error: Failed to read \"Parallel1IoPortBase\""));
3259
3260 /* Try to attach the other CPUs */
3261 for (unsigned i = 1; i < pThis->cCpus; i++)
3262 {
3263 if (pThis->fCpuHotPlug)
3264 {
3265 PPDMIBASE IBaseTmp;
3266 rc = PDMDevHlpDriverAttach(pDevIns, i, &pThis->IBase, &IBaseTmp, "ACPI CPU");
3267
3268 if (RT_SUCCESS(rc))
3269 {
3270 VMCPUSET_ADD(&pThis->CpuSetAttached, i);
3271 VMCPUSET_ADD(&pThis->CpuSetLocked, i);
3272 Log(("acpi: Attached CPU %u\n", i));
3273 }
3274 else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
3275 Log(("acpi: CPU %u not attached yet\n", i));
3276 else
3277 return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to attach CPU object\n"));
3278 }
3279 else
3280 {
3281 /* CPU is always attached if hot-plug is not enabled. */
3282 VMCPUSET_ADD(&pThis->CpuSetAttached, i);
3283 VMCPUSET_ADD(&pThis->CpuSetLocked, i);
3284 }
3285 }
3286
3287 char *pszOemId = NULL;
3288 rc = CFGMR3QueryStringAllocDef(pCfg, "AcpiOemId", &pszOemId, "VBOX ");
3289 if (RT_FAILURE(rc))
3290 return PDMDEV_SET_ERROR(pDevIns, rc,
3291 N_("Configuration error: Querying \"AcpiOemId\" as string failed"));
3292 size_t cbOemId = strlen(pszOemId);
3293 if (cbOemId > 6)
3294 return PDMDEV_SET_ERROR(pDevIns, rc,
3295 N_("Configuration error: \"AcpiOemId\" must contain not more than 6 characters"));
3296 memset(pThis->au8OemId, ' ', sizeof(pThis->au8OemId));
3297 memcpy(pThis->au8OemId, pszOemId, cbOemId);
3298 MMR3HeapFree(pszOemId);
3299
3300 char *pszCreatorId = NULL;
3301 rc = CFGMR3QueryStringAllocDef(pCfg, "AcpiCreatorId", &pszCreatorId, "ASL ");
3302 if (RT_FAILURE(rc))
3303 return PDMDEV_SET_ERROR(pDevIns, rc,
3304 N_("Configuration error: Querying \"AcpiCreatorId\" as string failed"));
3305 size_t cbCreatorId = strlen(pszCreatorId);
3306 if (cbCreatorId > 4)
3307 return PDMDEV_SET_ERROR(pDevIns, rc,
3308 N_("Configuration error: \"AcpiCreatorId\" must contain not more than 4 characters"));
3309 memset(pThis->au8CreatorId, ' ', sizeof(pThis->au8CreatorId));
3310 memcpy(pThis->au8CreatorId, pszCreatorId, cbCreatorId);
3311 MMR3HeapFree(pszCreatorId);
3312
3313 rc = CFGMR3QueryU32Def(pCfg, "AcpiCreatorRev", &pThis->u32CreatorRev, RT_H2LE_U32(0x61));
3314 if (RT_FAILURE(rc))
3315 return PDMDEV_SET_ERROR(pDevIns, rc,
3316 N_("Configuration error: Querying \"AcpiCreatorRev\" as integer failed"));
3317 pThis->u32OemRevision = RT_H2LE_U32(0x1);
3318
3319 /*
3320 * Get the custom table binary file name.
3321 */
3322 char *pszCustBinFile;
3323 rc = CFGMR3QueryStringAlloc(pCfg, "CustomTable", &pszCustBinFile);
3324 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
3325 rc = CFGMR3QueryStringAlloc(pCfg, "SLICTable", &pszCustBinFile);
3326 if (rc == VERR_CFGM_VALUE_NOT_FOUND)
3327 {
3328 pszCustBinFile = NULL;
3329 rc = VINF_SUCCESS;
3330 }
3331 else if (RT_FAILURE(rc))
3332 return PDMDEV_SET_ERROR(pDevIns, rc,
3333 N_("Configuration error: Querying \"CustomTable\" as a string failed"));
3334 else if (!*pszCustBinFile)
3335 {
3336 MMR3HeapFree(pszCustBinFile);
3337 pszCustBinFile = NULL;
3338 }
3339
3340 /*
3341 * Determine the custom table binary size, open specified ROM file in the process.
3342 */
3343 if (pszCustBinFile)
3344 {
3345 RTFILE FileCUSTBin;
3346 rc = RTFileOpen(&FileCUSTBin, pszCustBinFile,
3347 RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
3348 if (RT_SUCCESS(rc))
3349 {
3350 rc = RTFileGetSize(FileCUSTBin, &pThis->cbCustBin);
3351 if (RT_SUCCESS(rc))
3352 {
3353 /* The following checks should be in sync the AssertReleaseMsg's below. */
3354 if ( pThis->cbCustBin > 3072
3355 || pThis->cbCustBin < sizeof(ACPITBLHEADER))
3356 rc = VERR_TOO_MUCH_DATA;
3357
3358 /*
3359 * Allocate buffer for the custom table binary data.
3360 */
3361 pThis->pu8CustBin = (uint8_t *)PDMDevHlpMMHeapAlloc(pDevIns, pThis->cbCustBin);
3362 if (pThis->pu8CustBin)
3363 {
3364 rc = RTFileRead(FileCUSTBin, pThis->pu8CustBin, pThis->cbCustBin, NULL);
3365 if (RT_FAILURE(rc))
3366 {
3367 AssertMsgFailed(("RTFileRead(,,%d,NULL) -> %Rrc\n", pThis->cbCustBin, rc));
3368 MMR3HeapFree(pThis->pu8CustBin);
3369 pThis->pu8CustBin = NULL;
3370 }
3371 else
3372 {
3373 pThis->fUseCust = true;
3374 memcpy(&pThis->au8OemId[0], &pThis->pu8CustBin[10], 6);
3375 memcpy(&pThis->au8OemTabId[0], &pThis->pu8CustBin[16], 8);
3376 memcpy(&pThis->u32OemRevision, &pThis->pu8CustBin[24], 4);
3377 memcpy(&pThis->au8CreatorId[0], &pThis->pu8CustBin[28], 4);
3378 memcpy(&pThis->u32CreatorRev, &pThis->pu8CustBin[32], 4);
3379 LogRel(("ACPI: Reading custom ACPI table from file '%s' (%d bytes)\n", pszCustBinFile,
3380 pThis->cbCustBin));
3381 }
3382 }
3383 else
3384 rc = VERR_NO_MEMORY;
3385
3386 RTFileClose(FileCUSTBin);
3387 }
3388 }
3389 MMR3HeapFree(pszCustBinFile);
3390 if (RT_FAILURE(rc))
3391 return PDMDEV_SET_ERROR(pDevIns, rc,
3392 N_("Error reading custom ACPI table"));
3393 }
3394
3395 /* Set default port base */
3396 pThis->uPmIoPortBase = PM_PORT_BASE;
3397
3398 /*
3399 * FDC and SMC try to use the same non-shareable interrupt (6),
3400 * enable only one device.
3401 */
3402 if (pThis->fUseSmc)
3403 pThis->fUseFdc = false;
3404
3405 /*
3406 * Plant ACPI tables.
3407 */
3408 /** @todo Part of this is redone by acpiR3MemSetup, we only need to init the
3409 * au8RSDPPage here. However, there should be no harm in doing it
3410 * twice, so the lazy bird is taking the quick way out for now. */
3411 RTGCPHYS32 GCPhysRsdp = apicR3FindRsdpSpace();
3412 if (!GCPhysRsdp)
3413 return PDMDEV_SET_ERROR(pDevIns, VERR_NO_MEMORY,
3414 N_("Can not find space for RSDP. ACPI is disabled"));
3415
3416 rc = acpiR3PlantTables(pThis);
3417 if (RT_FAILURE(rc))
3418 return rc;
3419
3420 rc = PDMDevHlpROMRegister(pDevIns, GCPhysRsdp, 0x1000, pThis->au8RSDPPage, 0x1000,
3421 PGMPHYS_ROM_FLAGS_PERMANENT_BINARY, "ACPI RSDP");
3422 if (RT_FAILURE(rc))
3423 return rc;
3424
3425 /*
3426 * Register I/O ports.
3427 */
3428 rc = acpiR3RegisterPmHandlers(pThis);
3429 if (RT_FAILURE(rc))
3430 return rc;
3431
3432#define R(addr, cnt, writer, reader, description) \
3433 do { \
3434 rc = PDMDevHlpIOPortRegister(pDevIns, addr, cnt, pThis, writer, reader, \
3435 NULL, NULL, description); \
3436 if (RT_FAILURE(rc)) \
3437 return rc; \
3438 } while (0)
3439 R(SMI_CMD, 1, acpiR3SmiWrite, NULL, "ACPI SMI");
3440#ifdef DEBUG_ACPI
3441 R(DEBUG_HEX, 1, acpiR3DhexWrite, NULL, "ACPI Debug hex");
3442 R(DEBUG_CHR, 1, acpiR3DchrWrite, NULL, "ACPI Debug char");
3443#endif
3444 R(BAT_INDEX, 1, acpiR3BatIndexWrite, NULL, "ACPI Battery status index");
3445 R(BAT_DATA, 1, NULL, acpiR3BatDataRead, "ACPI Battery status data");
3446 R(SYSI_INDEX, 1, acpiR3SysInfoIndexWrite, NULL, "ACPI system info index");
3447 R(SYSI_DATA, 1, acpiR3SysInfoDataWrite, acpiR3SysInfoDataRead, "ACPI system info data");
3448 R(ACPI_RESET_BLK, 1, acpiR3ResetWrite, NULL, "ACPI Reset");
3449#undef R
3450
3451 /*
3452 * Create the PM timer.
3453 */
3454 PTMTIMER pTimer;
3455 rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL_SYNC, acpiR3PmTimer, &pThis->dev,
3456 TMTIMER_FLAGS_NO_CRIT_SECT, "ACPI PM Timer", &pTimer);
3457 AssertRCReturn(rc, rc);
3458 pThis->pPmTimerR3 = pTimer;
3459 pThis->pPmTimerR0 = TMTimerR0Ptr(pTimer);
3460 pThis->pPmTimerRC = TMTimerRCPtr(pTimer);
3461
3462 rc = TMTimerLock(pTimer, VERR_IGNORED);
3463 AssertRCReturn(rc, rc);
3464 pThis->u64PmTimerInitial = TMTimerGet(pTimer);
3465 acpiR3PmTimerReset(pThis, pThis->u64PmTimerInitial);
3466 TMTimerUnlock(pTimer);
3467
3468 /*
3469 * Set up the PCI device.
3470 */
3471 PCIDevSetVendorId(&pThis->dev, 0x8086); /* Intel */
3472 PCIDevSetDeviceId(&pThis->dev, 0x7113); /* 82371AB */
3473
3474 /* See p. 50 of PIIX4 manual */
3475 PCIDevSetCommand(&pThis->dev, 0x01);
3476 PCIDevSetStatus(&pThis->dev, 0x0280);
3477
3478 PCIDevSetRevisionId(&pThis->dev, 0x08);
3479
3480 PCIDevSetClassProg(&pThis->dev, 0x00);
3481 PCIDevSetClassSub(&pThis->dev, 0x80);
3482 PCIDevSetClassBase(&pThis->dev, 0x06);
3483
3484 PCIDevSetHeaderType(&pThis->dev, 0x80);
3485
3486 PCIDevSetBIST(&pThis->dev, 0x00);
3487
3488 PCIDevSetInterruptLine(&pThis->dev, SCI_INT);
3489 PCIDevSetInterruptPin (&pThis->dev, 0x01);
3490
3491 pThis->dev.config[0x40] = 0x01; /* PM base address, this bit marks it as IO range, not PA */
3492
3493#if 0
3494 int smb_io_base = 0xb100;
3495 dev->config[0x90] = smb_io_base | 1; /* SMBus base address */
3496 dev->config[0x90] = smb_io_base >> 8;
3497#endif
3498
3499 rc = PDMDevHlpPCIRegister(pDevIns, &pThis->dev);
3500 if (RT_FAILURE(rc))
3501 return rc;
3502
3503 PDMDevHlpPCISetConfigCallbacks(pDevIns, &pThis->dev,
3504 acpiR3PciConfigRead, &pThis->pfnAcpiPciConfigRead,
3505 acpiR3PciConfigWrite, &pThis->pfnAcpiPciConfigWrite);
3506
3507 /*
3508 * Register the saved state.
3509 */
3510 rc = PDMDevHlpSSMRegister(pDevIns, 7, sizeof(*pThis), acpiR3SaveState, acpiR3LoadState);
3511 if (RT_FAILURE(rc))
3512 return rc;
3513
3514 /*
3515 * Get the corresponding connector interface
3516 */
3517 rc = PDMDevHlpDriverAttach(pDevIns, 0, &pThis->IBase, &pThis->pDrvBase, "ACPI Driver Port");
3518 if (RT_SUCCESS(rc))
3519 {
3520 pThis->pDrv = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBase, PDMIACPICONNECTOR);
3521 if (!pThis->pDrv)
3522 return PDMDEV_SET_ERROR(pDevIns, VERR_PDM_MISSING_INTERFACE,
3523 N_("LUN #0 doesn't have an ACPI connector interface"));
3524 }
3525 else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
3526 {
3527 Log(("acpi: %s/%d: warning: no driver attached to LUN #0!\n",
3528 pDevIns->pReg->szName, pDevIns->iInstance));
3529 rc = VINF_SUCCESS;
3530 }
3531 else
3532 return PDMDEV_SET_ERROR(pDevIns, rc, N_("Failed to attach LUN #0"));
3533
3534 return rc;
3535}
3536
3537/**
3538 * The device registration structure.
3539 */
3540const PDMDEVREG g_DeviceACPI =
3541{
3542 /* u32Version */
3543 PDM_DEVREG_VERSION,
3544 /* szName */
3545 "acpi",
3546 /* szRCMod */
3547 "VBoxDDRC.rc",
3548 /* szR0Mod */
3549 "VBoxDDR0.r0",
3550 /* pszDescription */
3551 "Advanced Configuration and Power Interface",
3552 /* fFlags */
3553 PDM_DEVREG_FLAGS_DEFAULT_BITS | PDM_DEVREG_FLAGS_RC | PDM_DEVREG_FLAGS_R0,
3554 /* fClass */
3555 PDM_DEVREG_CLASS_ACPI,
3556 /* cMaxInstances */
3557 ~0U,
3558 /* cbInstance */
3559 sizeof(ACPIState),
3560 /* pfnConstruct */
3561 acpiR3Construct,
3562 /* pfnDestruct */
3563 acpiR3Destruct,
3564 /* pfnRelocate */
3565 acpiR3Relocate,
3566 /* pfnMemSetup */
3567 acpiR3MemSetup,
3568 /* pfnPowerOn */
3569 NULL,
3570 /* pfnReset */
3571 acpiR3Reset,
3572 /* pfnSuspend */
3573 NULL,
3574 /* pfnResume */
3575 acpiR3Resume,
3576 /* pfnAttach */
3577 acpiR3Attach,
3578 /* pfnDetach */
3579 acpiR3Detach,
3580 /* pfnQueryInterface. */
3581 NULL,
3582 /* pfnInitComplete */
3583 NULL,
3584 /* pfnPowerOff */
3585 NULL,
3586 /* pfnSoftReset */
3587 NULL,
3588 /* u32VersionEnd */
3589 PDM_DEVREG_VERSION
3590};
3591
3592#endif /* IN_RING3 */
3593#endif /* !VBOX_DEVICE_STRUCT_TESTCASE */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette