isabus.c File Reference

#include "precomp.h"

Include dependency graph for isabus.c:

Go to the source code of this file.

Functions
static UCHAR	IsaBusNextLFSR (_In_ UCHAR Lfsr, _In_ UCHAR InputBit)
static VOID	IsaBusWriteAddressRegister (_In_ UCHAR Value)
static VOID	IsaBusWriteDataRegister (_In_ UCHAR Value)
static UCHAR	IsaBusReadSerialIsolationRegister (_In_ PUCHAR Port)
static UCHAR	IsaBusReadDataPortRegister (_In_ PUCHAR Port)
static UCHAR	IsaBusPnpChecksum (_In_ PISAPNP_IDENTIFIER Identifier)
static UCHAR	IsaBusResourceDataChecksum (_In_ PUCHAR PnpRom, _In_ ULONG RomSize)
static VOID	IsaBusPlugInCard (_Inout_ PISAPNP_CARD Card)
VOID	IsaBusCreateCard (_Inout_ PISAPNP_CARD Card, _In_ PVOID PnpRom, _In_ ULONG RomSize, _In_ ULONG LogicalDevices)
VOID NTAPI	WRITE_PORT_UCHAR (_In_ PUCHAR Port, _In_ UCHAR Value)
UCHAR NTAPI	READ_PORT_UCHAR (_In_ PUCHAR Port)

Variables
PISAPNP_CARD	IsapCard
static PISAPNP_CARD	IsapConfigureCard = NULL
static ULONG	IsapCardCount = 0
static UCHAR	IsapAddressLatch = 0

Function Documentation

IsaBusCreateCard()

VOID IsaBusCreateCard	(	_Inout_ PISAPNP_CARD	Card,
		_In_ PVOID	PnpRom,
		_In_ ULONG	RomSize,
		_In_ ULONG	LogicalDevices
	)

Definition at line 439 of file isabus.c.

{
    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;
}

Referenced by DrvCreateCard1(), and DrvCreateCard2().

IsaBusNextLFSR()

static UCHAR IsaBusNextLFSR ( _In_ UCHAR  Lfsr, _In_ UCHAR  InputBit  )

inlinestatic

Definition at line 25 of file isabus.c.

{
    UCHAR NextLfsr = Lfsr >> 1;
 
    NextLfsr |= (((Lfsr ^ NextLfsr) ^ InputBit)) << 7;
 
    return NextLfsr;
}

Referenced by IsaBusPnpChecksum(), and IsaBusWriteAddressRegister().

IsaBusPlugInCard()

static VOID IsaBusPlugInCard ( _Inout_ PISAPNP_CARD  Card )

static

Definition at line 426 of file isabus.c.

{
    Card->State = IsaWaitForKey;
    Card->Lfsr = ISAPNP_LFSR_SEED;
    Card->LfsrCount = 0;
    Card->SelectNumberReg = 0;
    Card->ReadDataPort = NULL;
}

Referenced by IsaBusCreateCard().

IsaBusPnpChecksum()

static UCHAR IsaBusPnpChecksum ( _In_ PISAPNP_IDENTIFIER  Identifier )

static

Definition at line 391 of file isabus.c.

{
    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;
}

Referenced by IsaBusCreateCard().

IsaBusReadDataPortRegister()

static UCHAR IsaBusReadDataPortRegister ( _In_ PUCHAR  Port )

static

Definition at line 328 of file isabus.c.

{
    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;
}

Referenced by READ_PORT_UCHAR().

IsaBusReadSerialIsolationRegister()

static UCHAR IsaBusReadSerialIsolationRegister ( _In_ PUCHAR  Port )

static

Definition at line 266 of file isabus.c.

{
    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;
}

Referenced by IsaBusReadDataPortRegister().

IsaBusResourceDataChecksum()

static UCHAR IsaBusResourceDataChecksum ( _In_ PUCHAR  PnpRom, _In_ ULONG  RomSize  )

static

Definition at line 413 of file isabus.c.

{
    UNREFERENCED_PARAMETER(PnpRom);
    UNREFERENCED_PARAMETER(RomSize);
 
    /* This means "Checksummed properly" */
    return 0x00;
}

Referenced by IsaBusCreateCard().

IsaBusWriteAddressRegister()

static VOID IsaBusWriteAddressRegister ( _In_ UCHAR  Value )

static

Definition at line 38 of file isabus.c.

{
    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;
        }
    }
}

Referenced by WRITE_PORT_UCHAR().

IsaBusWriteDataRegister()

static VOID IsaBusWriteDataRegister ( _In_ UCHAR  Value )

static

Definition at line 73 of file isabus.c.

{
    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;
        }
    }
}

Referenced by WRITE_PORT_UCHAR().

READ_PORT_UCHAR()

UCHAR NTAPI READ_PORT_UCHAR

(

_In_ PUCHAR

Port

)

Definition at line 480 of file isabus.c.

{
    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;
}

WRITE_PORT_UCHAR()

VOID NTAPI WRITE_PORT_UCHAR	(	_In_ PUCHAR	Port,
		_In_ UCHAR	Value
	)

Definition at line 458 of file isabus.c.

{
    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;
    }
}

Variable Documentation

IsapAddressLatch

UCHAR IsapAddressLatch = 0

static

Definition at line 18 of file isabus.c.

Referenced by IsaBusReadDataPortRegister(), IsaBusWriteAddressRegister(), and IsaBusWriteDataRegister().

IsapCard

PISAPNP_CARD IsapCard

Definition at line 14 of file isabus.c.

Referenced by DrvCreateCards(), DrvTestResources(), IsaBusReadSerialIsolationRegister(), IsaBusWriteAddressRegister(), and IsaBusWriteDataRegister().

IsapCardCount

ULONG IsapCardCount = 0

static

Definition at line 17 of file isabus.c.

Referenced by IsaBusCreateCard(), IsaBusReadSerialIsolationRegister(), IsaBusWriteAddressRegister(), and IsaBusWriteDataRegister().

IsapConfigureCard

PISAPNP_CARD IsapConfigureCard = NULL

static

Definition at line 16 of file isabus.c.

Referenced by IsaBusReadDataPortRegister(), and IsaBusWriteDataRegister().