HyperDbg/hyperdbg/kdserial/uartio.c

/*++

Copyright (c) Microsoft Corporation.  All rights reserved.

Module Name:

    uartio.c

Abstract:

    This file defines I/O functions and the function pointers used by the serial
    drivers to access the device hardware.

--*/

// ------------------------------------------------------------------- Includes

#include "common.h"

// ---------------------------------------------------------------- Definitions

//
// Maximum addressable register width varies with platform architecture.
//

#if defined(_WIN64)

#    define MAX_REGISTER_WIDTH 64

#else

#    define MAX_REGISTER_WIDTH 32

#endif

// ----------------------------------------------------------------- Date Types

// ------------------------------------------------------------------ Functions

//
// Memory-mapped I/O Routines.
//

static VOID
WriteRegisterWithIndex8(
    _In_ PCPPORT Port,
    const UCHAR  Index,
    const UCHAR  Value)
{
    PUCHAR Pointer;

    Pointer = (PUCHAR)(Port->Address + Index * Port->ByteWidth);
    WRITE_REGISTER_UCHAR(Pointer, Value);
    return;
}

static UCHAR
ReadRegisterWithIndex8(
    _In_ PCPPORT Port,
    const UCHAR  Index)
{
    PUCHAR Pointer;

    Pointer = (PUCHAR)(Port->Address + Index * Port->ByteWidth);
    return READ_REGISTER_UCHAR(Pointer);
}

static VOID
WriteRegisterWithIndex16(
    _In_ PCPPORT Port,
    const UCHAR  Index,
    const UCHAR  Value)
{
    PUSHORT Pointer;

    Pointer = (PUSHORT)(Port->Address + Index * Port->ByteWidth);
    WRITE_REGISTER_USHORT(Pointer, Value);
    return;
}

static UCHAR
ReadRegisterWithIndex16(
    _In_ PCPPORT Port,
    const UCHAR  Index)
{
    PUSHORT Pointer;

    Pointer = (PUSHORT)(Port->Address + Index * Port->ByteWidth);
    return (UCHAR)READ_REGISTER_USHORT(Pointer);
}

static VOID
WriteRegisterWithIndex32(
    _In_ PCPPORT Port,
    const UCHAR  Index,
    const UCHAR  Value)
{
    PULONG Pointer;

    Pointer = (PULONG)(Port->Address + Index * Port->ByteWidth);
    WRITE_REGISTER_ULONG(Pointer, Value);
    return;
}

static UCHAR
ReadRegisterWithIndex32(
    _In_ PCPPORT Port,
    const UCHAR  Index)
{
    PULONG Pointer;

    Pointer = (PULONG)(Port->Address + Index * Port->ByteWidth);
    return (UCHAR)READ_REGISTER_ULONG(Pointer);
}

#if defined(_WIN64)

static VOID
WriteRegisterWithIndex64(
    _In_ PCPPORT Port,
    const UCHAR  Index,
    const UCHAR  Value)
{
    PULONG64 Pointer;

    Pointer = (PULONG64)(Port->Address + Index * Port->ByteWidth);
    WRITE_REGISTER_ULONG64(Pointer, Value);
    return;
}

static UCHAR
ReadRegisterWithIndex64(
    _In_ PCPPORT Port,
    const UCHAR  Index)
{
    PULONG64 Pointer;

    Pointer = (PULONG64)(Port->Address + Index * Port->ByteWidth);
    return (UCHAR)READ_REGISTER_ULONG64(Pointer);
}

#endif

//
// Port I/O Functions. (Only available on architectures that have I/O ports.)
//

#if defined(_X86_) || defined(_AMD64_)

static VOID
WritePortWithIndex8(
    _In_ PCPPORT Port,
    const UCHAR  Index,
    const UCHAR  Value)
{
    PUCHAR Pointer;

    Pointer = (PUCHAR)(Port->Address + Index * Port->ByteWidth);
    WRITE_PORT_UCHAR(Pointer, Value);
    return;
}

static UCHAR
ReadPortWithIndex8(
    _In_ PCPPORT Port,
    const UCHAR  Index)
{
    PUCHAR Pointer;

    Pointer = (PUCHAR)(Port->Address + Index * Port->ByteWidth);
    return (UCHAR)READ_PORT_UCHAR(Pointer);
}

static VOID
WritePortWithIndex16(
    _In_ PCPPORT Port,
    const UCHAR  Index,
    const UCHAR  Value)
{
    PUSHORT Pointer;

    Pointer = (PUSHORT)(Port->Address + Index * Port->ByteWidth);
    WRITE_PORT_USHORT(Pointer, Value);
    return;
}

static UCHAR
ReadPortWithIndex16(
    _In_ PCPPORT Port,
    const UCHAR  Index)
{
    PUSHORT Pointer;

    Pointer = (PUSHORT)(Port->Address + Index * Port->ByteWidth);
    return (UCHAR)READ_PORT_USHORT(Pointer);
}

static VOID
WritePortWithIndex32(
    _In_ PCPPORT Port,
    const UCHAR  Index,
    const UCHAR  Value)
{
    PULONG Pointer;

    Pointer = (PULONG)(Port->Address + Index * Port->ByteWidth);
    WRITE_PORT_ULONG(Pointer, Value);
    return;
}

static UCHAR
ReadPortWithIndex32(
    _In_ PCPPORT Port,
    const UCHAR  Index)
{
    PULONG Pointer;

    Pointer = (PULONG)(Port->Address + Index * Port->ByteWidth);
    return (UCHAR)READ_PORT_ULONG(Pointer);
}

#endif

BOOLEAN
UartpSetAccess(
    _Inout_ PCPPORT Port,
    const BOOLEAN   MemoryMapped,
    const UCHAR     AccessSize,
    const UCHAR     BitWidth)

/*++

Routine Description:

    This routine sets the access type (port I/O or memory mapped I/O), access
    size and bit width for the given port. This routine must be called before
    attempting to access the UART hardware.

Arguments:

    Port - Supplies a pointer to the structure that holds the port's state.

    MemoryMapped - TRUE if the port uses MMIO, FALSE if it uses legacy port I/O.

    AccessSize - Supplies the ACPI Generic Access Size of the register's bus.

    BitWidth - Supplies the size in bits of the device's registers.

Return value:

    TRUE if the pointers were assigned, FALSE if a parameter was not valid.

--*/

{
    UCHAR                             MinRegisterWidth;
    BOOLEAN                           PowerOfTwo;
    UART_HARDWARE_READ_INDEXED_UCHAR  ReadFunction;
    UART_HARDWARE_WRITE_INDEXED_UCHAR WriteFunction;

    MinRegisterWidth = 8;

    //
    // Select the appropriate port access routines depending upon whether this
    // serial port is mapped into memory or I/O space.
    //

    if (MemoryMapped == FALSE)
    {
        switch ((ACPI_GENERIC_ACCESS_SIZE)AccessSize)
        {
#if defined(_X86_) || defined(_AMD64_)

        case AcpiGenericAccessSizeLegacy:
            __fallthrough;

        case AcpiGenericAccessSizeByte:
            WriteFunction = WritePortWithIndex8;
            ReadFunction  = ReadPortWithIndex8;
            break;

        case AcpiGenericAccessSizeWord:
            WriteFunction    = WritePortWithIndex16;
            ReadFunction     = ReadPortWithIndex16;
            MinRegisterWidth = 16;
            break;

        case AcpiGenericAccessSizeDWord:
            WriteFunction    = WritePortWithIndex32;
            ReadFunction     = ReadPortWithIndex32;
            MinRegisterWidth = 32;
            break;

            //
            // The quad word access size isn't supported for port based I/O.
            //

#endif

        default:
            return FALSE;
        }
    }
    else
    {
        switch ((ACPI_GENERIC_ACCESS_SIZE)AccessSize)
        {
        case AcpiGenericAccessSizeLegacy:
            __fallthrough;

        case AcpiGenericAccessSizeByte:
            WriteFunction = WriteRegisterWithIndex8;
            ReadFunction  = ReadRegisterWithIndex8;
            break;

        case AcpiGenericAccessSizeWord:
            WriteFunction    = WriteRegisterWithIndex16;
            ReadFunction     = ReadRegisterWithIndex16;
            MinRegisterWidth = 16;
            break;

        case AcpiGenericAccessSizeDWord:
            WriteFunction    = WriteRegisterWithIndex32;
            ReadFunction     = ReadRegisterWithIndex32;
            MinRegisterWidth = 32;
            break;

#if defined(_WIN64)

        case AcpiGenericAccessSizeQWord:
            WriteFunction    = WriteRegisterWithIndex64;
            ReadFunction     = ReadRegisterWithIndex64;
            MinRegisterWidth = 64;
            break;

#endif

        default:
            return FALSE;
        }
    }

    //
    // Validate BitWidth parameter.
    //

    PowerOfTwo = ((BitWidth & (BitWidth - 1)) == 0);
    if ((PowerOfTwo == FALSE) ||
        (BitWidth < MinRegisterWidth) ||
        (BitWidth > MAX_REGISTER_WIDTH))
    {
        return FALSE;
    }

    Port->ByteWidth = BitWidth / 8;
    Port->Write     = WriteFunction;
    Port->Read      = ReadFunction;
    return TRUE;
}