VirtualBox

Changeset 26057 in vbox


Ignore:
Timestamp:
Jan 27, 2010 8:53:32 AM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
56976
Message:

ACPI: spaces, coding style, some comments, FACS 64-bit aligned

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/PC/DevACPI.cpp

    r26056 r26057  
    386386#define IAPC_BOOT_ARCH_8042             RT_BIT(1)  /**< legacy keyboard device present */
    387387#define IAPC_BOOT_ARCH_NO_VGA           RT_BIT(2)  /**< VGA not present */
    388     uint8_t             u8Must0_0;              /**< must be 0 */
    389     uint32_t            u32Flags;               /**< fixed feature flags */
     388    uint8_t             u8Must0_0;                 /**< must be 0 */
     389    uint32_t            u32Flags;                  /**< fixed feature flags */
    390390#define FADT_FL_WBINVD                  RT_BIT(0)  /**< emulation of WBINVD available */
    391391#define FADT_FL_WBINVD_FLUSH            RT_BIT(1)
    … …  
    468468
    469469
    470 
    471 /* HPET Descriptor Structure */
     470/** HPET Descriptor Structure */
    472471struct ACPITBLHPET
    473472{
    474473    ACPITBLHEADER aHeader;
    475     uint32_t      u32Id;
    476     ACPIGENADDR   HpetAddr;
    477     uint8_t       u32Number;
    478     uint16_t      u32MinTick;
    479     uint8_t       u8Attributes;
     474    uint32_t      u32Id;                        /**< hardware ID of event timer block
     475                                                     [31:16] PCI vendor ID of first timer block
     476                                                     [15]    legacy replacement IRQ routing capable
     477                                                     [14]    reserved
     478                                                     [13]    COUNT_SIZE_CAP counter size
     479                                                     [12:8]  number of comparators in first timer block
     480                                                     [7:0]   hardware rev ID */
     481    ACPIGENADDR   HpetAddr;                     /**< lower 32-bit base address */
     482    uint8_t       u32Number;                    /**< sequence number starting at 0 */
     483    uint16_t      u32MinTick;                   /**< minimum clock ticks which can be set without
     484                                                     lost interrupts while the counter is programmed
     485                                                     to operate in periodic mode. Unit: clock tick. */
     486    uint8_t       u8Attributes;                 /**< page protextion and OEM attribute. */
    480487};
     488AssertCompileSize(ACPITBLHPET, 56);
    481489
    482490# ifdef IN_RING3 /** @todo r=bird: Move this down to where it's used. */
    … …  
    699707
    700708/** Fixed ACPI Description Table (FADT aka FACP) */
    701 static void acpiSetupFADT(ACPIState *s, RTGCPHYS32 addr_acpi1, RTGCPHYS32 addr_acpi2, uint32_t facs_addr, uint32_t dsdt_addr)
     709static void acpiSetupFADT(ACPIState *s, RTGCPHYS32 GCPhysAcpi1, RTGCPHYS32 GCPhysAcpi2, RTGCPHYS32 GCPhysFacs, RTGCPHYS GCPhysDsdt)
    702710{
    703711    ACPITBLFADT fadt;
    … …  
    706714    memset(&fadt, 0, sizeof(fadt));
    707715    acpiPrepareHeader(&fadt.header, "FACP", sizeof(fadt), 4);
    708     fadt.u32FACS              = RT_H2LE_U32(facs_addr);
    709     fadt.u32DSDT              = RT_H2LE_U32(dsdt_addr);
     716    fadt.u32FACS              = RT_H2LE_U32(GCPhysFacs);
     717    fadt.u32DSDT              = RT_H2LE_U32(GCPhysDsdt);
    710718    fadt.u8IntModel           = 0;  /* dropped from the ACPI 2.0 spec. */
    711719    fadt.u8PreferredPMProfile = 0;  /* unspecified */
    … …  
    753761    acpiWriteGenericAddr(&fadt.ResetReg,     1,  8, 0, 1, ACPI_RESET_BLK);
    754762    fadt.u8ResetVal           = ACPI_RESET_REG_VAL;
    755     fadt.u64XFACS             = RT_H2LE_U64((uint64_t)facs_addr);
    756     fadt.u64XDSDT             = RT_H2LE_U64((uint64_t)dsdt_addr);
     763    fadt.u64XFACS             = RT_H2LE_U64((uint64_t)GCPhysFacs);
     764    fadt.u64XDSDT             = RT_H2LE_U64((uint64_t)GCPhysDsdt);
    757765    acpiWriteGenericAddr(&fadt.X_PM1aEVTBLK, 1, 32, 0, 2, acpiPmPort(s, PM1a_EVT_OFFSET));
    758766    acpiWriteGenericAddr(&fadt.X_PM1bEVTBLK, 0,  0, 0, 0, acpiPmPort(s, PM1b_EVT_OFFSET));
    … …  
    764772    acpiWriteGenericAddr(&fadt.X_GPE1BLK,    0,  0, 0, 0, acpiPmPort(s, GPE1_OFFSET));
    765773    fadt.header.u8Checksum    = acpiChecksum((uint8_t *)&fadt, sizeof(fadt));
    766     acpiPhyscpy(s, addr_acpi2, &fadt, sizeof(fadt));
     774    acpiPhyscpy(s, GCPhysAcpi2, &fadt, sizeof(fadt));
    767775
    768776    /* Now the ACPI 1.0 version. */
    … …  
    771779    fadt.header.u8Checksum    = 0;  /* Must be zeroed before recalculating checksum! */
    772780    fadt.header.u8Checksum    = acpiChecksum((uint8_t *)&fadt, ACPITBLFADT_VERSION1_SIZE);
    773     acpiPhyscpy(s, addr_acpi1, &fadt, ACPITBLFADT_VERSION1_SIZE);
     781    acpiPhyscpy(s, GCPhysAcpi1, &fadt, ACPITBLFADT_VERSION1_SIZE);
    774782}
    775783
    … …  
    823831
    824832/** Root System Description Pointer (RSDP) */
    825 static void acpiSetupRSDP(ACPITBLRSDP *rsdp, uint32_t rsdt_addr, uint64_t xsdt_addr)
     833static void acpiSetupRSDP(ACPITBLRSDP *rsdp, RTGCPHYS32 GCPhysRsdt, RTGCPHYS GCPhysXsdt)
    826834{
    827835    memset(rsdp, 0, sizeof(*rsdp));
    … …  
    831839    memcpy(rsdp->au8OemId, "VBOX  ", 6);
    832840    rsdp->u8Revision    = ACPI_REVISION;
    833     rsdp->u32RSDT       = RT_H2LE_U32(rsdt_addr);
     841    rsdp->u32RSDT       = RT_H2LE_U32(GCPhysRsdt);
    834842    rsdp->u8Checksum    = acpiChecksum((uint8_t*)rsdp, RT_OFFSETOF(ACPITBLRSDP, u32Length));
    835843
    836844    /* ACPI 2.0 part (XSDT) */
    837845    rsdp->u32Length     = RT_H2LE_U32(sizeof(ACPITBLRSDP));
    838     rsdp->u64XSDT       = RT_H2LE_U64(xsdt_addr);
     846    rsdp->u64XSDT       = RT_H2LE_U64(GCPhysXsdt);
    839847    rsdp->u8ExtChecksum = acpiChecksum((uint8_t*)rsdp, sizeof(ACPITBLRSDP));
    840848}
    … …  
    15391547                    LogRel(("ACPI: CPU %u does not exist\n", u32));
    15401548                break;
     1549
    15411550            case SYSTEM_INFO_INDEX_CPU_LOCKED:
    15421551                if (u32 < s->cCpus)
    … …  
    18961905    ACPIState *s = PDMINS_2_DATA(pDevIns, ACPIState *);
    18971906
    1898 
    18991907    Assert(uPass == SSM_PASS_FINAL); NOREF(uPass);
    19001908    /*
    … …  
    19531961{
    19541962    int        rc;
    1955     RTGCPHYS32 cur_addr, rsdt_addr, xsdt_addr, fadt_acpi1_addr, fadt_acpi2_addr, facs_addr, dsdt_addr, hpet_addr, apic_addr = 0;
     1963    RTGCPHYS32 GCPhysCur, GCPhysRsdt, GCPhysXsdt, GCPhysFadtAcpi1, GCPhysFadtAcpi2, GCPhysFacs, GCPhysDsdt;
     1964    RTGCPHYS32 GCPhysHpet = 0, GCPhysApic = 0;
    19561965    uint32_t   addend = 0;
    1957     RTGCPHYS32 rsdt_addrs[4];
    1958     RTGCPHYS32 xsdt_addrs[4];
    1959     uint32_t   cAddr, madt_index, hpet_index;
    1960     size_t     rsdt_tbl_len = sizeof(ACPITBLHEADER);
    1961     size_t     xsdt_tbl_len = sizeof(ACPITBLHEADER);
    1962 
    1963     cAddr = 1;           /* FADT */
     1966    RTGCPHYS32 aGCPhysRsdt[4];
     1967    RTGCPHYS32 aGCPhysXsdt[4];
     1968    uint32_t   cAddr, iMadt = 0, iHpet = 0;
     1969    size_t     cbRsdt = sizeof(ACPITBLHEADER);
     1970    size_t     cbXsdt = sizeof(ACPITBLHEADER);
     1971
     1972    cAddr = 1;                  /* FADT */
    19641973    if (s->u8UseIOApic)
    1965         madt_index = cAddr++;         /* MADT */
    1966 
     1974        iMadt = cAddr++;        /* MADT */
    19671975
    19681976    if (s->fUseHpet)
    1969         hpet_index = cAddr++;         /* HPET */
    1970 
    1971     rsdt_tbl_len += cAddr*4;  /* each entry: 32 bits phys. address. */
    1972     xsdt_tbl_len += cAddr*8;  /* each entry: 64 bits phys. address. */
     1977        iHpet = cAddr++;        /* HPET */
     1978
     1979    cbRsdt += cAddr*sizeof(uint32_t);  /* each entry: 32 bits phys. address. */
     1980    cbXsdt += cAddr*sizeof(uint64_t);  /* each entry: 64 bits phys. address. */
    19731981
    19741982    rc = CFGMR3QueryU64(s->pDevIns->pCfgHandle, "RamSize", &s->u64RamSize);
    19751983    if (RT_FAILURE(rc))
    19761984        return PDMDEV_SET_ERROR(s->pDevIns, rc,
    1977                                 N_("Configuration error: Querying "
    1978                                    "\"RamSize\" as integer failed"));
     1985                                N_("Configuration error: Querying \"RamSize\" as integer failed"));
    19791986
    19801987    uint32_t cbRamHole;
    … …  
    19851992
    19861993    /*
    1987      * Calc the sizes for the high and low regions.
     1994     * Calculate the sizes for the high and low regions.
    19881995     */
    19891996    const uint64_t offRamHole = _4G - cbRamHole;
    … …  
    19982005    s->cbRamLow = (uint32_t)cbRamLow;
    19992006
    2000     cur_addr = 0;
    2001 
    2002     rsdt_addr = cur_addr;
    2003     cur_addr = RT_ALIGN_32(cur_addr + rsdt_tbl_len, 16);
    2004 
    2005     xsdt_addr = cur_addr;
    2006     cur_addr = RT_ALIGN_32(cur_addr       + xsdt_tbl_len, 16);
    2007 
    2008     fadt_acpi1_addr = cur_addr;
    2009     cur_addr = RT_ALIGN_32(cur_addr + ACPITBLFADT_VERSION1_SIZE, 16);
    2010 
    2011     fadt_acpi2_addr = cur_addr;
    2012     /** @todo ACPI 3.0 doc says it needs to be aligned on a 64 byte boundary. */
    2013     cur_addr = RT_ALIGN_32(cur_addr + sizeof(ACPITBLFADT), 16);
    2014 
    2015 
    2016     facs_addr = cur_addr;
    2017     cur_addr = RT_ALIGN_32(cur_addr + sizeof(ACPITBLFACS), 16);
    2018 
     2007    GCPhysCur = 0;
     2008    GCPhysRsdt = GCPhysCur;
     2009
     2010    GCPhysCur = RT_ALIGN_32(GCPhysCur + cbRsdt, 16);
     2011    GCPhysXsdt = GCPhysCur;
     2012
     2013    GCPhysCur = RT_ALIGN_32(GCPhysCur + cbXsdt, 16);
     2014    GCPhysFadtAcpi1 = GCPhysCur;
     2015
     2016    GCPhysCur = RT_ALIGN_32(GCPhysCur + ACPITBLFADT_VERSION1_SIZE, 16);
     2017    GCPhysFadtAcpi2 = GCPhysCur;
     2018
     2019    GCPhysCur = RT_ALIGN_32(GCPhysCur + sizeof(ACPITBLFADT), 64);
     2020    GCPhysFacs = GCPhysCur;
     2021
     2022    GCPhysCur = RT_ALIGN_32(GCPhysCur + sizeof(ACPITBLFACS), 16);
    20192023    if (s->u8UseIOApic)
    20202024    {
    2021         apic_addr = cur_addr;
    2022         cur_addr = RT_ALIGN_32(cur_addr + AcpiTableMADT::sizeFor(s), 16);
     2025        GCPhysApic = GCPhysCur;
     2026        GCPhysCur = RT_ALIGN_32(GCPhysCur + AcpiTableMADT::sizeFor(s), 16);
    20232027    }
    20242028    if (s->fUseHpet)
    20252029    {
    2026         hpet_addr = cur_addr;
    2027         cur_addr = RT_ALIGN_32(cur_addr + sizeof(ACPITBLHPET), 16);
    2028     }
     2030        GCPhysHpet = GCPhysCur;
     2031        GCPhysCur = RT_ALIGN_32(GCPhysCur + sizeof(ACPITBLHPET), 16);
     2032    }
     2033    GCPhysDsdt = GCPhysCur;
    20292034
    20302035    void*  pDsdtCode = NULL;
    2031     size_t uDsdtSize = 0;
    2032     rc = acpiPrepareDsdt(s->pDevIns, &pDsdtCode, &uDsdtSize);
     2036    size_t cbDsdtSize = 0;
     2037    rc = acpiPrepareDsdt(s->pDevIns, &pDsdtCode, &cbDsdtSize);
    20332038    if (RT_FAILURE(rc))
    20342039        return rc;
    20352040
    2036     dsdt_addr = cur_addr;
    2037     cur_addr = RT_ALIGN_32(cur_addr + uDsdtSize, 16);
    2038 
    2039     if (cur_addr > 0x10000)
     2041    GCPhysCur = RT_ALIGN_32(GCPhysCur + cbDsdtSize, 16);
     2042    if (GCPhysCur > 0x10000)
    20402043        return PDMDEV_SET_ERROR(s->pDevIns, VERR_TOO_MUCH_DATA,
    2041                                 N_("Error: ACPI tables > 64KB"));
     2044                                N_("Error: ACPI tables bigger than 64KB"));
    20422045
    20432046    Log(("RSDP 0x%08X\n", find_rsdp_space()));
    20442047    addend = s->cbRamLow - 0x10000;
    2045     Log(("RSDT 0x%08X XSDT 0x%08X\n", rsdt_addr + addend, xsdt_addr + addend));
    2046     Log(("FACS 0x%08X FADT (1.0) 0x%08X, FADT (2+) 0x%08X\n", facs_addr + addend, fadt_acpi1_addr + addend, fadt_acpi2_addr + addend));
    2047     Log(("DSDT 0x%08X\n", dsdt_addr + addend));
     2048    Log(("RSDT 0x%08X XSDT 0x%08X\n", GCPhysRsdt + addend, GCPhysXsdt + addend));
     2049    Log(("FACS 0x%08X FADT (1.0) 0x%08X, FADT (2+) 0x%08X\n", GCPhysFacs + addend, GCPhysFadtAcpi1 + addend, GCPhysFadtAcpi2 + addend));
     2050    Log(("DSDT 0x%08X", GCPhysDsdt + addend));
     2051    if (s->u8UseIOApic)
     2052        Log((" MADT 0x%08X", GCPhysApic + addend));
    20482053    if (s->fUseHpet)
    2049     {
    2050         Log(("HPET 0x%08X\n", hpet_addr + addend));
    2051     }
    2052     acpiSetupRSDP((ACPITBLRSDP*)s->au8RSDPPage, rsdt_addr + addend, xsdt_addr + addend);
    2053     acpiSetupDSDT(s, dsdt_addr + addend, pDsdtCode, uDsdtSize);
     2054        Log((" HPET 0x%08X", GCPhysHpet + addend));
     2055    Log(("\n"));
     2056
     2057    acpiSetupRSDP((ACPITBLRSDP*)s->au8RSDPPage, GCPhysRsdt + addend, GCPhysXsdt + addend);
     2058    acpiSetupDSDT(s, GCPhysDsdt + addend, pDsdtCode, cbDsdtSize);
    20542059    acpiCleanupDsdt(s->pDevIns, pDsdtCode);
    2055     acpiSetupFACS(s, facs_addr + addend);
    2056     acpiSetupFADT(s, fadt_acpi1_addr + addend, fadt_acpi2_addr + addend, facs_addr + addend, dsdt_addr + addend);
    2057 
    2058     rsdt_addrs[0] = fadt_acpi1_addr + addend;
    2059     xsdt_addrs[0] = fadt_acpi2_addr + addend;
     2060    acpiSetupFACS(s, GCPhysFacs + addend);
     2061    acpiSetupFADT(s, GCPhysFadtAcpi1 + addend, GCPhysFadtAcpi2 + addend, GCPhysFacs + addend, GCPhysDsdt + addend);
     2062
     2063    aGCPhysRsdt[0] = GCPhysFadtAcpi1 + addend;
     2064    aGCPhysXsdt[0] = GCPhysFadtAcpi2 + addend;
    20602065    if (s->u8UseIOApic)
    20612066    {
    2062         acpiSetupMADT(s, apic_addr + addend);
    2063         rsdt_addrs[madt_index] = apic_addr + addend;
    2064         xsdt_addrs[madt_index] = apic_addr + addend;
     2067        acpiSetupMADT(s, GCPhysApic + addend);
     2068        aGCPhysRsdt[iMadt] = GCPhysApic + addend;
     2069        aGCPhysXsdt[iMadt] = GCPhysApic + addend;
    20652070    }
    20662071    if (s->fUseHpet)
    20672072    {
    2068         acpiSetupHPET(s, hpet_addr + addend);
    2069         rsdt_addrs[hpet_index] = hpet_addr + addend;
    2070         xsdt_addrs[hpet_index] = hpet_addr + addend;
    2071     }
    2072 
    2073     rc = acpiSetupRSDT(s, rsdt_addr + addend, cAddr, rsdt_addrs);
     2073        acpiSetupHPET(s, GCPhysHpet + addend);
     2074        aGCPhysRsdt[iHpet] = GCPhysHpet + addend;
     2075        aGCPhysXsdt[iHpet] = GCPhysHpet + addend;
     2076    }
     2077
     2078    rc = acpiSetupRSDT(s, GCPhysRsdt + addend, cAddr, aGCPhysRsdt);
    20742079    if (RT_FAILURE(rc))
    20752080        return rc;
    2076     return acpiSetupXSDT(s, xsdt_addr + addend, cAddr, xsdt_addrs);
     2081    return acpiSetupXSDT(s, GCPhysXsdt + addend, cAddr, aGCPhysXsdt);
    20772082}
    20782083
    … …  
    24092414
    24102415    /* */
    2411     uint32_t rsdp_addr = find_rsdp_space();
    2412     if (!rsdp_addr)
     2416    RTGCPHYS32 GCPhysRsdp = find_rsdp_space();
     2417    if (!GCPhysRsdp)
    24132418        return PDMDEV_SET_ERROR(pDevIns, VERR_NO_MEMORY,
    24142419                                N_("Can not find space for RSDP. ACPI is disabled"));
    … …  
    24182423        return rc;
    24192424
    2420     rc = PDMDevHlpROMRegister(pDevIns, rsdp_addr, 0x1000, s->au8RSDPPage,
     2425    rc = PDMDevHlpROMRegister(pDevIns, GCPhysRsdp, 0x1000, s->au8RSDPPage,
    24212426                              PGMPHYS_ROM_FLAGS_PERMANENT_BINARY, "ACPI RSDP");
    24222427    if (RT_FAILURE(rc))
Note: See TracChangeset for help on using the changeset viewer.

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