[Openvortex-dev] Asp4FIFO.cpp

[Shamus]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Hi all!

Here's a partial reconstruction of Asp4FIFO.cpp (which contains the
SetAdbCtrl__9CAsp4FIFOiiiiii function). It's fairly easy to see from
the parameters being passed into SetAdbCtrl(...) that the first
parameter is an index into the adbFifo (& HW registers) and that the
other 5 parameters are bit fields that get written into 0x16100 +
(baseAddr*4). Now as to what they actually *do*, that will take some
more investigation.

I did find out that the CAsp4DmaChannel (which calls the CAsp4FIFO
object's SetAdbCtrl function) is a base class to the CAsp4AbdDma and
CAsp4WtDma classes. I'll post my findings once I get those properly
translated.

Any more requests? Jeff? Manuel?

- -- Shamus

- ----------------------------------------------------------------

// Asp4FIFO.cpp
//
// Reconstructed by James L. Hammons <address@hidden>


class CAsp4FIFO
{
    public:
        CAsp4FIFO(CAsp4HwIO *);
        ~CAsp4FIFO();
        InitializeAdb(int, int);
        InitializeWt(int, int);
        SetAdbCtrl(int, int, int, int, int, int);
        SetWtCtrl(int, int, int, int, int, int);
        ClearAdbData(int, int);
        SetADBValid(int, int);
        SetWTValid(int, int);
        GetADBValid(int);
        GetWTValid(int);
        GetADBEmpty(int);
        GetWTEmpty(int);
        ClearWtData(int, int);

    private:
        CAsp4HwIO * pHwIO;
        DWORD this04;
        DWORD adbFifo[32];
        DWORD wtFifo[64];
};


CAsp4FIFO::CAsp4FIFO(CAsp4HwIO * pHwIO)
{
    this.pHwIO = pHwIO;
    this04 = 1;

    DWORD addr = 0x1617C;
    for(int i=31; i>=0; i--)
    {
        pHwIO->Write(addr, 0x042000);
        ClearAdbData(i, 64);
        addr -= 4;
    }

    DWORD addr = 0x160FC;
    for(int i=63; i>=0; i--)
    {
        pHwIO->Write(addr, 0x042000);
        ClearWtData(i, 64);
        addr -= 4;
    }

    DWORD val = ((1 & 0xFFFFFF81) | 0x00000060);
    pHwIO->Write(0x17000, val);
    pHwIO->Write(0x17004, val);
    pHwIO->Write(0x17008, val);
}

CAsp4FIFO::~CAsp4FIFO()
{
}

CAsp4FIFO::InitializeAdb(int baseAddr, int val1)
{
    this04 = val1;
    ClearAdbData(baseAddr, 64);
    DWORD value = ((this04 & 0x3F) << 12) | 0x040000;
    pHwIO->Write(0x16100 + (baseAddr * 4), value);
    adbFifo[baseAddr] = 0;
}

CAsp4FIFO::InitializeWt(int baseAddr, int val1)
{
    this04 = val1;
    ClearWtData(baseAddr, 64);
    DWORD value = ((this04 & 0x3F) << 12) | 0x040000;
    pHwIO->Write(0x16000 + (baseAddr * 4), value);
    wtFifo[baseAddr] = 0;
}

CAsp4FIFO::SetAdbCtrl(int baseAddr, int i2, int i3, int i4, int i5,
int i6)
{
    DWORD baseAddrX4 = baseAddr * 4;
    DWORD esi = 0x16100 + baseAddrX4;
    DWORD ebx, edi;

    do
    {
        ebx = pHwIO->ReadDWORD(esi);
    }
    while (ebx & 0x01);

    if (i5 == 0)
    {
        if (ebx & 0x0010)
        {
            ebx &= 0xFFFFFFEF;

            if (64 % this04 == 0)
            {
                ebx |= 0x1C400000;
                pHwIO->Write(0x16100 + baseAddrX4, ebx);
                esi = (ebx >> 6) & 0x3F;
                DWORD ebp = ((ebx >> 6) & 0x3F) + 56;
                DWORD var08 = (esi == (ebx >> 12) & 0x3F ? 1 : 0);
                DWORD var10 = 0;
                DWORD var14 = 56 - (ebp % this04);
                DWORD var18 = (256 / (var14 - 4)) + 1;
                ebp = 256 - var18;
                DWORD var04 = 0;

                if (var14 > 0)
                {
                    DWORD var20 = baseAddr << 8;
                    DWORD addr = 0x14000 + (esi * 4) + var20;

                    do
                    {
                        if (var08)
                            var40 = var10;
                        else
                            // Sign extend 16 -> 32 bits
                            var10 = var40 =
(SDWORD)(SWORD)(pHwIO->ReadDWORD(addr) & 0x0000FFFF);

                        pHwIO->Write(0x14000 + (esi * 4) + var20,
(SDWORD)(var40 * ebp) >> 8);
                        addr += 4;
                        esi++;

                        if (esi > 63)
                        {
                            addr = 0x14000 + var20;
                            esi = 0;
                        }

                        if (esi == ((ebx >> 12) & 0x3F))
                            var08 = 1;

                        ebp -= var18;

                        if (ebp < 0)
                            ebp = 0;
                    }
                    while (++var04 < var14);
                }

                ebx = (((((ebx & 0xFFFC0FFF) | ((esi & 0x3F) << 12)) &
0x7FFFFFFF) | 0x08000000) & 0xEFFFFFFF) | 0x04400000;
                adbFifo[baseAddr] = 1;
            }
        }
        else
        {
            if (adbFifo[baseAddr] == 0)
                ClearAdbData(baseAddr, 64);
        }
    }
    else
    {
        if (!(ebx & 0x0010))
        {
            adbFifo[baseAddr] = 0;

            if ((64 % this04) == 0)
                ebx = (ebx & 0xFFFC0FFF) | ((ebx << 6) & 0x0003F000);
            else
            {
                ClearAbdData(baseAddr, this04);
                ebx = (this04 & 0x3F) << 12;
            }

            ebx = (ebx & 0xFFFFFFFD) | ((i2 & 0x0001) << 1);
            ebx = (ebx & 0xFFFFFFF3) | ((i3 & 0x0003) << 2);
            ebx = (ebx & 0xFFFFFFEF) | ((i5 & 0x0001) << 4);
            ebx |= 0x00040000;
            ebx = (ebx & 0xFFFFFFDF) | ((i4 & 0x0001) << 5);
            ebx = (ebx & 0xF7FFFFFF) | ((i6 & 0x0001) << 27);
            ebx = (ebx & 0xEFFFFFFF) | ((i6 & 0x0001) << 28);
        }
    }

    pHwIO->Write(0x16100 + baseAddrX4, ebx);
}

CAsp4FIFO::SetWtCtrl(int, int, int, int, int, int)
{
}

CAsp4FIFO::ClearAdbData(int baseAddr, int num)
{
    DWORD addr = 0x14000 + (baseAddr << 8) + ((num - 1) * 4);

    for(int i=0; i<num; i++)
    {
        pHwIO->Write(addr, (DWORD)0);
        addr -= 4;
    }
}

CAsp4FIFO::SetADBValid(int, int)
{
}

CAsp4FIFO::SetWTValid(int, int)
{
}

CAsp4FIFO::GetADBValid(int)
{
}

CAsp4FIFO::GetWTValid(int)
{
}

CAsp4FIFO::GetADBEmpty(int)
{
}

CAsp4FIFO::GetWTEmpty(int)
{
}

CAsp4FIFO::ClearWtData(int, int)
{
    DWORD addr = 0x10000 + (baseAddr << 8) + ((num - 1) * 4);

    for(int i=0; i<num; i++)
    {
        pHwIO->Write(addr, (DWORD)0);
        addr -= 4;
    }
}


-----BEGIN PGP SIGNATURE-----
Version: Encrypted with PGP Plugin for Calypso

iQA/AwUBPp83CphOW/ztyY5GEQL9qQCg32bTLBQcLtYjb03KkJ4dCw/cinkAoMjt
eG3/fnEpQqHwQggGel+OivY6
=vZV1
-----END PGP SIGNATURE-----