a16find.c

acpi tools for linux include acpiexec and acpixtract

 * PARAMETERS:  Root            - Root of the parse tree
 *
 * RETURN:      None
 *
 * DESCRIPTION:
 *
 *****************************************************************************/

ACPI_STATUS
AfGetAllTables (
    UINT32                  NumberOfTables,
    char                    *TablePtr)
{
    ACPI_STATUS             Status = AE_OK;
    UINT32                  Index;
    ACPI_TABLE_DESC         TableInfo;


    ACPI_FUNCTION_TRACE (AfGetAllTables);


    if (AcpiGbl_DbOpt_verbose)
    {
        AcpiOsPrintf ("Number of tables: %d\n", (UINT32) NumberOfTables);
    }

    /*
     * Loop through all table pointers found in RSDT.
     * This will NOT include the FACS and DSDT - we must get
     * them after the loop
     */
    for (Index = 0; Index < NumberOfTables; Index++)
    {
        /* Get the table via the RSDT */

        CopyExtendedToReal (&AcpiTblHeader, ACPI_GET_ADDRESS (AcpiGbl_XSDT->TableOffsetEntry[Index]),
                            sizeof (ACPI_TABLE_HEADER));

        TableInfo.Pointer       = &AcpiTblHeader;
        TableInfo.Length        = (ACPI_SIZE) AcpiTblHeader.Length;
        TableInfo.Allocation    = ACPI_MEM_ALLOCATED;

        ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Table pointer: %X\n",
            (UINT32) ACPI_GET_ADDRESS (AcpiGbl_XSDT->TableOffsetEntry[Index])));

        Status = AfRecognizeTable (NULL, ACPI_GET_ADDRESS (AcpiGbl_XSDT->TableOffsetEntry[Index]), &TableInfo);
        if (ACPI_SUCCESS (Status))
        {
            AcpiTbInitTableDescriptor (TableInfo.Type, &TableInfo);
        }

       /* Ignore errors, just move on to next table */
    }

    if (!AcpiGbl_FADT)
    {
        AcpiOsPrintf ("FADT was not found, cannot obtain FACS and DSDT!\n");
        return (AE_NO_ACPI_TABLES);
    }

    Status = AcpiTbConvertTableFadt ();
    if (ACPI_FAILURE (Status))
    {
        return_ACPI_STATUS (Status);
    }

    /*
     * Get the FACS
     */
    CopyExtendedToReal (&AcpiTblHeader, ACPI_GET_ADDRESS (AcpiGbl_FADT->XFirmwareCtrl),
                        sizeof (ACPI_TABLE_HEADER));
    AcpiGbl_FACS = ACPI_ALLOCATE (AcpiTblHeader.Length);
    if (!AcpiGbl_FACS)
    {
        AcpiOsPrintf ("Could not allocate buffer for FADT length 0x%X\n",
                        (UINT32) AcpiTblHeader.Length);
        return_ACPI_STATUS (AE_NO_MEMORY);
    }

    CopyExtendedToReal (AcpiGbl_FACS, ACPI_GET_ADDRESS (AcpiGbl_FADT->XFirmwareCtrl), AcpiTblHeader.Length);

    ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "FACS at %p (Phys %8.8X) length %X FADT at%p\n",
                    AcpiGbl_FACS, (UINT32) ACPI_GET_ADDRESS (AcpiGbl_FADT->XFirmwareCtrl),
                    (UINT32) AcpiTblHeader.Length, AcpiGbl_FADT));
    if (AcpiGbl_DbOpt_verbose)
    {
        AcpiUtDumpBuffer ((char *) AcpiGbl_FADT, sizeof (ACPI_TABLE_HEADER), 0, 0);
    }

    TableInfo.Type          = ACPI_TABLE_FADT;
    TableInfo.Pointer       = (void *) AcpiGbl_FADT;
    TableInfo.Length        = (ACPI_SIZE) AcpiTblHeader.Length;
    TableInfo.Allocation    = ACPI_MEM_ALLOCATED;

    /* There is no checksum for the FACS, nothing to verify */

    AcpiTbInitTableDescriptor (TableInfo.Type, &TableInfo);

    AcpiTbBuildCommonFacs (&TableInfo);

    /*
     * Get the DSDT
     */
    CopyExtendedToReal (&AcpiTblHeader, ACPI_GET_ADDRESS (AcpiGbl_FADT->XDsdt), sizeof (ACPI_TABLE_HEADER));
    AcpiGbl_DSDT = ACPI_ALLOCATE (AcpiTblHeader.Length);
    if (!AcpiGbl_DSDT)
    {
        AcpiOsPrintf ("Could not allocate buffer for DSDT length 0x%X\n", (UINT32) AcpiTblHeader.Length);
        return_ACPI_STATUS (AE_NO_MEMORY);
    }

    CopyExtendedToReal (AcpiGbl_DSDT, ACPI_GET_ADDRESS (AcpiGbl_FADT->XDsdt), AcpiTblHeader.Length);

    AcpiOsPrintf ("DSDT at %p (Phys %8.8X) length %X FADT at %p\n",
                    AcpiGbl_DSDT, (UINT32) ACPI_GET_ADDRESS (AcpiGbl_FADT->XDsdt),
                    (UINT32) AcpiTblHeader.Length, AcpiGbl_FADT);
    if (AcpiGbl_DbOpt_verbose)
    {
        AcpiUtDumpBuffer ((char *) AcpiGbl_DSDT, sizeof (ACPI_TABLE_HEADER), 0, 0);
    }

    TableInfo.Type          = ACPI_TABLE_DSDT;
    TableInfo.Pointer       = (void *) AcpiGbl_DSDT;
    TableInfo.Length        = (ACPI_SIZE) AcpiTblHeader.Length;
    TableInfo.Allocation    = ACPI_MEM_ALLOCATED;

    AcpiTbInitTableDescriptor (TableInfo.Type, &TableInfo);
    AcpiTbVerifyTableChecksum ((ACPI_TABLE_HEADER *) AcpiGbl_DSDT);

    return_ACPI_STATUS (AE_OK);
}


ACPI_STATUS
AfGetRsdt (void)
{
    BOOLEAN                 Found;
    UINT32                  PhysicalAddress;
    UINT32                  SignatureLength;
    char                    *TableSignature;
    ACPI_STATUS             Status;
    ACPI_TABLE_DESC         TableInfo;


    ACPI_FUNCTION_TRACE (AfGetRsdt);

    if (AcpiGbl_XSDT)
    {
        return (AE_OK);
    }

    Found = AfFindRsdp (&AcpiGbl_RSDP);
    if (!Found)
    {
        AcpiOsPrintf ("Could not find RSDP in the low megabyte\n");
        return (AE_NO_ACPI_TABLES);
    }

    /* Use XSDT if it is present */

    if ((AcpiGbl_RSDP->Revision >= 2) &&
        ACPI_GET_ADDRESS (AcpiGbl_RSDP->XsdtPhysicalAddress))
    {
        PhysicalAddress = ACPI_GET_ADDRESS (AcpiGbl_RSDP->XsdtPhysicalAddress);
        TableSignature = ACPI_SIG_XSDT;
        SignatureLength = sizeof (ACPI_SIG_XSDT) -1;
        AcpiGbl_RootTableType = ACPI_TABLE_TYPE_XSDT;

        ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Found XSDT\n"));
    }
    else
    {
        /* No XSDT, use the RSDT */

        PhysicalAddress = AcpiGbl_RSDP->RsdtPhysicalAddress;
        TableSignature = ACPI_SIG_RSDT;
        SignatureLength = sizeof (ACPI_SIG_RSDT) -1;
        AcpiGbl_RootTableType = ACPI_TABLE_TYPE_RSDT;

        ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Found RSDT\n"));
    }

    if (AcpiGbl_DbOpt_verbose)
    {
        AcpiUtDumpBuffer ((char *) AcpiGbl_RSDP, sizeof (RSDP_DESCRIPTOR), 0, ACPI_UINT32_MAX);
    }

    /* Get the RSDT/XSDT header to determine the table length */

    CopyExtendedToReal (&AcpiTblHeader, PhysicalAddress, sizeof (ACPI_TABLE_HEADER));

    ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "RSDT/XSDT at %8.8X\n", (UINT32) PhysicalAddress));
    if (AcpiGbl_DbOpt_verbose)
    {
        AcpiUtDumpBuffer ((char *) &AcpiTblHeader, sizeof (ACPI_TABLE_HEADER), 0, ACPI_UINT32_MAX);
    }

    /* Validate the table header */

    Status = AcpiTbValidateTableHeader (&AcpiTblHeader);
    if (ACPI_FAILURE (Status))
    {
        /* Table failed verification, map all errors to BAD_DATA */

        ACPI_ERROR ((AE_INFO, "Invalid RSDT table header"));
        return (AE_BAD_DATA);
    }

    /* Allocate a buffer for the entire table */

    AcpiGbl_XSDT = (void *) malloc ((size_t) AcpiTblHeader.Length);
    if (!AcpiGbl_XSDT)
    {
        AcpiOsPrintf ("Could not allocate buffer for RSDT length 0x%X\n",
            (UINT32) AcpiTblHeader.Length);
        return AE_NO_MEMORY;
    }

    /* Get the entire RSDT/XSDT */

    CopyExtendedToReal (AcpiGbl_XSDT, PhysicalAddress, AcpiTblHeader.Length);
    AcpiOsPrintf ("%s at %p (Phys %8.8X)\n",
        TableSignature, AcpiGbl_XSDT, (UINT32) PhysicalAddress);

    if (AcpiGbl_DbOpt_verbose)
    {
        AcpiUtDumpBuffer ((char *) &AcpiTblHeader, sizeof (ACPI_TABLE_HEADER), 0, 0);
    }

    /* Convert to common format XSDT */

    TableInfo.Pointer       = (ACPI_TABLE_HEADER *) AcpiGbl_XSDT;
    TableInfo.Length        = (ACPI_SIZE) AcpiTblHeader.Length;
    TableInfo.Allocation    = ACPI_MEM_ALLOCATED;

    AcpiGbl_RsdtTableCount = AcpiTbGetTableCount (AcpiGbl_RSDP, TableInfo.Pointer);

    Status = AcpiTbConvertToXsdt (&TableInfo);
    if (ACPI_FAILURE (Status))
    {
        goto ErrorExit;
    }

    AcpiGbl_XSDT = (XSDT_DESCRIPTOR *) TableInfo.Pointer;

ErrorExit:
    return (Status);
}


void
AfDumpRsdt (void)
{
    UINT32                  i;
    UINT32                  NumTables;
    UINT32                  PhysicalAddress;
    ACPI_TABLE_HEADER       **Table;
    ACPI_TABLE_HEADER       ThisTable;


    NumTables = (AcpiGbl_XSDT->Length - sizeof (ACPI_TABLE_HEADER)) / 8;

    AcpiOsPrintf ("%d Tables defined in RSDT/XSDT:\n", NumTables);

    for (i = 0; i < NumTables; i++)
    {
        PhysicalAddress = (UINT32) AcpiGbl_XSDT->TableOffsetEntry[i].Lo;
        CopyExtendedToReal (&ThisTable, PhysicalAddress, sizeof (ACPI_TABLE_HEADER));
        AcpiOsPrintf ("[%4.4s] ", ThisTable.Signature);
        ((char *) Table) += 8;
    }

    AcpiOsPrintf ("\n");
}

ACPI_STATUS
AfGetTable (
    ACPI_TABLE_HEADER       *TableHeader,
    UINT32                  PhysicalAddress,
    UINT8                   **TablePtr)
{

    /* Allocate a buffer for the entire table */

    *TablePtr = (void *) malloc ((size_t) TableHeader->Length);
    if (!*TablePtr)
    {
        AcpiOsPrintf ("Could not allocate buffer for table length 0x%X\n",
            (UINT32) TableHeader->Length);
        return AE_NO_MEMORY;
    }

    /* Get the entire table */

    CopyExtendedToReal (*TablePtr, PhysicalAddress, TableHeader->Length);
    AcpiOsPrintf ("%4.4s at %p (Phys %8.8X)\n",
        TableHeader->Signature, *TablePtr, (UINT32) PhysicalAddress);

    if (AcpiGbl_DbOpt_verbose)
    {
        AcpiUtDumpBuffer ((char *) TableHeader, sizeof (ACPI_TABLE_HEADER), 0, 0);
    }

    return (AE_OK);
}


ACPI_STATUS
AfGetTableFromXsdt (
    char                    *TableName,
    UINT8                   **TablePtr)
{
    UINT32                  i;
    UINT32                  NumTables;
    UINT32                  PhysicalAddress;
    ACPI_TABLE_HEADER       ThisTable;


    NumTables = (AcpiGbl_XSDT->Length - sizeof (ACPI_TABLE_HEADER)) / 8;

    for (i = 0; i < NumTables; i++)
    {
        PhysicalAddress = (UINT32) AcpiGbl_XSDT->TableOffsetEntry[i].Lo;
        CopyExtendedToReal (&ThisTable, PhysicalAddress, sizeof (ACPI_TABLE_HEADER));

        if (ACPI_COMPARE_NAME (TableName, ThisTable.Signature))
        {
            AfGetTable (&ThisTable, PhysicalAddress, TablePtr);
            return (AE_OK);
        }
    }

    return (AE_NOT_FOUND);
}


/******************************************************************************
 *
 * FUNCTION:    AfFindTable
 *
 * PARAMETERS:
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Load the DSDT from the file pointer
 *
 *****************************************************************************/

ACPI_STATUS
AfFindTable (
    char                    *TableName,
    UINT8                   **TablePtr,
    UINT32                  *TableLength)
{
    ACPI_STATUS             Status;


    ACPI_FUNCTION_TRACE (AfFindTable);


    if (!AcpiGbl_DSDT)
    {
        Status = AfGetRsdt ();
        if (ACPI_FAILURE (Status))
        {
            return (Status);
        }

        AfDumpRsdt ();

        /* Get the rest of the required tables (DSDT, FADT) */

        Status = AfGetAllTables (AcpiGbl_RsdtTableCount, NULL);
        if (ACPI_FAILURE (Status))
        {
            goto ErrorExit;
        }

        ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "ACPI Tables successfully acquired\n"));
    }


    if (ACPI_COMPARE_NAME (TableName, ACPI_SIG_DSDT))
    {
        *TablePtr = (UINT8 *) AcpiGbl_DSDT;
        *TableLength = AcpiGbl_DSDT->Length;
    }
    else if (ACPI_COMPARE_NAME (TableName, ACPI_SIG_FADT))
    {
        *TablePtr = (UINT8 *) AcpiGbl_FADT;
        *TableLength = AcpiGbl_FADT->Length;
    }
    else if (ACPI_COMPARE_NAME (TableName, ACPI_SIG_FACS))
    {
        *TablePtr = (UINT8 *) AcpiGbl_FACS;
        *TableLength = AcpiGbl_FACS->Length;
    }
    else if (ACPI_COMPARE_NAME (TableName, ACPI_SIG_RSDT))
    {
        *TablePtr = (UINT8 *) AcpiGbl_XSDT;
        *TableLength = AcpiGbl_XSDT->Length;
    }
    else if (ACPI_COMPARE_NAME (TableName, ACPI_SIG_SSDT))
    {
        AcpiOsPrintf ("Unsupported table signature: [%4.4s]\n", TableName);
        *TablePtr = NULL;
        return AE_SUPPORT;
    }
    else
    {
        Status = AfGetTableFromXsdt (TableName, TablePtr);
        if (ACPI_FAILURE (Status))
        {
            goto ErrorExit;
        }

        *TableLength = (*((ACPI_TABLE_HEADER **)TablePtr))->Length;
    }

    return AE_OK;

ErrorExit:

    ACPI_EXCEPTION ((AE_INFO, Status, "During ACPI Table initialization");
    return (Status);
}

#ifdef _HPET
UINT8           Hbuf[1024];

void
AfGetHpet (void)
{
    HPET_DESCRIPTION_TABLE  *NewTable;
    ACPI_TABLE_HEADER       TableHeader;
    ACPI_STATUS             Status;
    UINT16                  i;
    UINT32                  Value;
    UINT32                  Value2;


    /* Get HPET  TEMP! */

    ACPI_STRNCPY (TableHeader.Signature, "HPET", 4);
    Status = AcpiOsTableOverride (&TableHeader, (ACPI_TABLE_HEADER **) &NewTable);
    if (ACPI_FAILURE (Status))
    {
        return;
    }

    AcpiDbgLevel |= ACPI_LV_TABLES;
    AcpiOsPrintf ("HPET table :\n");
    AcpiUtDumpBuffer ((char *) NewTable, NewTable->Header.Length, DB_BYTE_DISPLAY, ACPI_UINT32_MAX);

    for (i = 0; i < 1024; i++)
    {
        Hbuf[i] = (UINT8) i;
    }

    /* enable HPET */

    CopyExtendedToReal (&Value, 0xD0, 4);
    AcpiOsPrintf ("Reg 0xD0: %8.8X\n", Value);

    Value = dIn32 (0xD0);
    AcpiOsPrintf ("Port 0xD0: %8.8X\n", Value);
    Value |= ACPI_ENABLE_HPET;

    vOut32 (0xD0, Value);
    Value2 = dIn32 (0xD0);
    AcpiOsPrintf ("Port 0xD0: Wrote: %8.8X got %8.8X\n", Value, Value2);

    AcpiOsPrintf ("HPET block(at %8.8X):\n", NewTable->BaseAddress[2]);
    CopyExtendedToReal (Hbuf, NewTable->BaseAddress[2], 1024);
    AcpiUtDumpBuffer ((char *) Hbuf, 1024, DB_BYTE_DISPLAY, ACPI_UINT32_MAX);
}
#endif /* _HPET */

#endif /* IA16 */