/*
 * PROJECT:     ReactOS API Tests
 * LICENSE:     LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
 * PURPOSE:     ISA PnP bus register access helpers
 * COPYRIGHT:   Copyright 2024 Dmitry Borisov <di.sean@protonmail.com>
 */

/* INCLUDES *******************************************************************/

#include "precomp.h"

/* GLOBALS ********************************************************************/

PISAPNP_CARD IsapCard;

static PISAPNP_CARD IsapConfigureCard = NULL;
static ULONG IsapCardCount = 0;
static UCHAR IsapAddressLatch = 0;

/* PRIVATE FUNCTIONS **********************************************************/

static
inline
UCHAR
IsaBusNextLFSR(
    _In_ UCHAR Lfsr,
    _In_ UCHAR InputBit)
{
    UCHAR NextLfsr = Lfsr >> 1;

    NextLfsr |= (((Lfsr ^ NextLfsr) ^ InputBit)) << 7;

    return NextLfsr;
}

static
VOID
IsaBusWriteAddressRegister(
    _In_ UCHAR Value)
{
    ULONG i;

    IsapAddressLatch = Value;

    for (i = 0; i < IsapCardCount; ++i)
    {
        PISAPNP_CARD Card = &IsapCard[i];

        if (Card->State != IsaWaitForKey)
            continue;

        /* Reset the LFSR contents */
        if (Card->Lfsr != Value)
        {
            Card->Lfsr = ISAPNP_LFSR_SEED;
            Card->LfsrCount = 0;
            continue;
        }

        /* Generate the next data pattern */
        Card->Lfsr = IsaBusNextLFSR(Card->Lfsr, 0);

        /* 32 bytes of the initiation key compared correctly */
        if (++Card->LfsrCount == 32)
        {
            Card->State = IsaSleep;
        }
    }
}

static
VOID
IsaBusWriteDataRegister(
    _In_ UCHAR Value)
{
    ULONG i, j;

    switch (IsapAddressLatch)
    {
        case ISAPNP_READPORT:
        {
            /* Update the address of the Read Data Port */
            for (i = 0; i < IsapCardCount; ++i)
            {
                PISAPNP_CARD Card = &IsapCard[i];

                if (Card->State != IsaIsolation)
                    continue;

                Card->ReadDataPort = (PUCHAR)(((ULONG_PTR)Value << 2) | 3);
            }
            break;
        }

        case ISAPNP_CONFIGCONTROL:
        {
            if (Value & ISAPNP_CONFIG_WAIT_FOR_KEY)
            {
                IsapConfigureCard = NULL;
            }

            for (i = 0; i < IsapCardCount; ++i)
            {
                PISAPNP_CARD Card = &IsapCard[i];

                if (Card->State != IsaWaitForKey)
                {
                    if (Value & ISAPNP_CONFIG_RESET)
                    {
                        for (j = 0; j < Card->LogicalDevices; ++j)
                        {
                            PISAPNP_CARD_LOGICAL_DEVICE LogDev = &Card->LogDev[j];

                            LogDev->Registers[ISAPNP_ACTIVATE] = 0;
                        }
                    }
                    if (Value & ISAPNP_CONFIG_RESET_CSN)
                    {
                        Card->SelectNumberReg = 0;
                    }
                }
                if (Value & ISAPNP_CONFIG_WAIT_FOR_KEY)
                {
                    Card->State = IsaWaitForKey;
                }
            }
            break;
        }

        case ISAPNP_WAKE:
        {
            for (i = 0; i < IsapCardCount; ++i)
            {
                PISAPNP_CARD Card = &IsapCard[i];

                if (Card->State == IsaWaitForKey)
                    continue;

                if (Card->SelectNumberReg != Value)
                {
                    if (Card->State == IsaConfgure || Card->State == IsaIsolation)
                    {
                        Card->State = IsaSleep;

                        if (IsapConfigureCard == Card)
                        {
                            IsapConfigureCard = NULL;
                        }
                    }

                    continue;
                }

                Card->RomIdx = 0;
                Card->SerialIsolationIdx = 0;

                if (Card->State == IsaSleep)
                {
                    if (Value == 0)
                    {
                        Card->State = IsaIsolation;

                        Card->IsolationRead = 0;
                    }
                    else
                    {
                        Card->State = IsaConfgure;

                        /* Only one card can be in the configure state */
                        IsapConfigureCard = Card;
                    }
                }
            }

            break;
        }

        case ISAPNP_CARDSELECTNUMBER:
        {
            ULONG CsnAssigned = 0;

            /* Assign the CSN */
            for (i = 0; i < IsapCardCount; ++i)
            {
                PISAPNP_CARD Card = &IsapCard[i];

                if (Card->State != IsaIsolation)
                    continue;

                ok(Value != 0, "The new CSN is zero\n");
                ok(Card->SelectNumberReg != Value, "CSNs must be assigned sequentially");

                Card->State = IsaConfgure;
                Card->SelectNumberReg = Value;

                /* Only one card can be in the configure state */
                IsapConfigureCard = Card;

                ++CsnAssigned;
                ok_eq_ulong(CsnAssigned, 1UL);
            }
            break;
        }

        case ISAPNP_LOGICALDEVICENUMBER:
        {
            ok(IsapConfigureCard != NULL, "Invalid write to a LDN register\n");

            if (IsapConfigureCard != NULL)
            {
                ok(IsapConfigureCard->LogicalDevices != 0, "Write to a read-only register\n");
                ok(Value < IsapConfigureCard->LogicalDevices, "Invalid write to a LDN register\n");

                IsapConfigureCard->DeviceNumberReg = Value;
            }
            break;
        }

        case ISAPNP_ACTIVATE:
        {
            Value &= 0x01;
            goto WriteDeviceRegister;
        }

        case ISAPNP_IORANGECHECK:
        {
            Value &= 0x03;
            goto WriteDeviceRegister;
        }

        case ISAPNP_SERIALISOLATION:
        case ISAPNP_RESOURCEDATA:
        case ISAPNP_STATUS:
        {
            ok(FALSE, "Write to a read-only register %02x\n", IsapAddressLatch);
            break;
        }

        default:
        {
            if (IsapAddressLatch >= 0x40)
            {
                PISAPNP_CARD_LOGICAL_DEVICE LogDev;

WriteDeviceRegister:
                ok(IsapConfigureCard != NULL, "Invalid write to device register\n");

                if (IsapConfigureCard != NULL)
                {
                    LogDev = &IsapConfigureCard->LogDev[IsapConfigureCard->DeviceNumberReg];

                    LogDev->Registers[IsapAddressLatch] = Value;
                }
            }
            else
            {
                ok(FALSE, "Unexpected write to register %02x\n", IsapAddressLatch);
            }
            break;
        }
    }
}

static
UCHAR
IsaBusReadSerialIsolationRegister(
    _In_ PUCHAR Port)
{
    ULONG i, ResponseMap = 0, ListenMap = 0;
    UCHAR Result = 0xFF;

    for (i = 0; i < IsapCardCount; ++i)
    {
        PISAPNP_CARD Card = &IsapCard[i];

        if (Card->State != IsaIsolation || Card->ReadDataPort != Port)
            continue;

        /* The hardware on each card expects 72 pairs of reads */
        if (Card->SerialIsolationIdx == RTL_BITS_OF(ISAPNP_IDENTIFIER))
            continue;

        Card->IsolationRead ^= 1;

        if (Card->IsolationRead)
        {
            if (Card->PnpRom[Card->SerialIsolationIdx / 8] & (1 << (Card->SerialIsolationIdx % 8)))
                Card->SerialIdResponse = 0x55;
            else
                Card->SerialIdResponse = 0x00;

            ++Card->RomIdx;
            ++Card->SerialIsolationIdx;
        }
        else
        {
            Card->SerialIdResponse <<= 1;

            if (Card->SerialIdResponse == 0xAA)
                ResponseMap |= (1 << i);
            else
                ListenMap |= (1 << i);
        }

        if ((Card->SerialIdResponse > Result) || (Result == 0xFF))
            Result = Card->SerialIdResponse;
    }

    /* Release passive cards from the isolation state */
    if (ResponseMap != 0 && ListenMap != 0)
    {
        for (i = 0; i < RTL_BITS_OF(ListenMap); ++i)
        {
            if (ListenMap & (1 << i))
            {
                PISAPNP_CARD Card = &IsapCard[i];

                Card->State = IsaSleep;
            }
        }
    }

    return Result;
}

static
UCHAR
IsaBusReadDataPortRegister(
    _In_ PUCHAR Port)
{
    if (IsapAddressLatch == ISAPNP_SERIALISOLATION)
        return IsaBusReadSerialIsolationRegister(Port);

    if (IsapConfigureCard == NULL || IsapConfigureCard->ReadDataPort != Port)
        return 0xFF;

    switch (IsapAddressLatch)
    {
        case ISAPNP_RESOURCEDATA:
        {
            if (IsapConfigureCard->RomIdx >= IsapConfigureCard->RomSize)
                break;

            /* The resource data register may return an invalid identifier checksum byte */
            if (IsapConfigureCard->RomIdx == FIELD_OFFSET(ISAPNP_IDENTIFIER, Checksum))
            {
                ++IsapConfigureCard->RomIdx;
                break;
            }

            return IsapConfigureCard->PnpRom[IsapConfigureCard->RomIdx++];
        }

        case ISAPNP_STATUS:
            return 0x01; /* Resource data byte available */

        case ISAPNP_CARDSELECTNUMBER:
            return IsapConfigureCard->SelectNumberReg;

        case ISAPNP_LOGICALDEVICENUMBER:
            return IsapConfigureCard->DeviceNumberReg;

        case ISAPNP_ACTIVATE:
        case ISAPNP_IORANGECHECK:
            goto ReadDeviceRegister;

        default:
        {
            if (IsapAddressLatch >= 0x40)
            {
                PISAPNP_CARD_LOGICAL_DEVICE LogDev;

ReadDeviceRegister:
                LogDev = &IsapConfigureCard->LogDev[IsapConfigureCard->DeviceNumberReg];

                return LogDev->Registers[IsapAddressLatch];
            }
            else
            {
                ok(FALSE, "Unexpected read from register %02x\n", IsapAddressLatch);
            }
            break;
        }
    }

    return 0xFF;
}

static
UCHAR
IsaBusPnpChecksum(
    _In_ PISAPNP_IDENTIFIER Identifier)
{
    UCHAR i, j, Lfsr;

    Lfsr = ISAPNP_LFSR_SEED;
    for (i = 0; i < FIELD_OFFSET(ISAPNP_IDENTIFIER, Checksum); ++i)
    {
        UCHAR Byte = ((PUCHAR)Identifier)[i];

        for (j = 0; j < RTL_BITS_OF(Byte); ++j)
        {
            Lfsr = IsaBusNextLFSR(Lfsr, Byte);
            Byte >>= 1;
        }
    }

    return Lfsr;
}

static
UCHAR
IsaBusResourceDataChecksum(
    _In_ PUCHAR PnpRom,
    _In_ ULONG RomSize)
{
    UNREFERENCED_PARAMETER(PnpRom);
    UNREFERENCED_PARAMETER(RomSize);

    /* This means "Checksummed properly" */
    return 0x00;
}

static
VOID
IsaBusPlugInCard(
    _Inout_ PISAPNP_CARD Card)
{
    Card->State = IsaWaitForKey;
    Card->Lfsr = ISAPNP_LFSR_SEED;
    Card->LfsrCount = 0;
    Card->SelectNumberReg = 0;
    Card->ReadDataPort = NULL;
}

/* PUBLIC FUNCTIONS ***********************************************************/

VOID
IsaBusCreateCard(
    _Inout_ PISAPNP_CARD Card,
    _In_ PVOID PnpRom,
    _In_ ULONG RomSize,
    _In_ ULONG LogicalDevices)
{
    Card->RomSize = RomSize;
    Card->PnpRom = PnpRom;
    Card->PnpRom[FIELD_OFFSET(ISAPNP_IDENTIFIER, Checksum)] = IsaBusPnpChecksum(PnpRom);
    Card->PnpRom[RomSize - 1] = IsaBusResourceDataChecksum(PnpRom, RomSize);
    Card->LogicalDevices = LogicalDevices;

    IsaBusPlugInCard(Card);

    ++IsapCardCount;
}

VOID
NTAPI
WRITE_PORT_UCHAR(
    _In_ PUCHAR Port,
    _In_ UCHAR Value)
{
    switch ((ULONG_PTR)Port)
    {
        case 0x279:
            IsaBusWriteAddressRegister(Value);
            break;

        case 0xA79:
            IsaBusWriteDataRegister(Value);
            break;

        default:
            ok(FALSE, "Unexpected write to port %p %02x\n", Port, Value);
            break;
    }
}

UCHAR
NTAPI
READ_PORT_UCHAR(
    _In_ PUCHAR Port)
{
    UCHAR Result;

    /* We can write only to NT Read Data Ports */
    switch ((ULONG_PTR)Port)
    {
        case 0x2F4 | 3:
            Result = IsaBusReadDataPortRegister(Port);
            break;

        /* Indicate that the Read Data Port is in conflict */
        case 0x274 | 3:
        case 0x3E4 | 3:
        case 0x204 | 3:
        case 0x2E4 | 3:
        case 0x354 | 3:
            Result = 0x00;
            break;

        default:
            ok(FALSE, "Unexpected read from port %p\n", Port);
            Result = 0xFF;
            break;
    }

    return Result;
}