#include "pci.h"


/////////////////////////////////////////////////////
PCI::PCI(void)
{
    status = 0;
    CheckBIOS();
}

/////////////////////////////////////////////////////
int PCI::CheckBIOS(void)
{
    int ret_value;
    regs.x.ax = PCI_INSTALLCHECK;

    ret_value = __dpmi_int(PCI_INT_NUM, &regs);
    if(ret_value == -1) {
        status = 1;
        return PCI_FAIL;
    }

    if(regs.d.edx != 0x20494350 || regs.h.ah != 0) {
        status = 2;
        return PCI_FAIL;
    }

    function_number = 0;

    if(status == 0)
    {
        hardware_characteristics = regs.h.al;
        pmode_entry_point = regs.d.edi;
        major_rev_number = regs.h.bh;
        minor_rev_number = regs.h.bl;
        bus_number = regs.h.cl;
    }
    else
    {
        hardware_characteristics = regs.h.al;
        pmode_entry_point = 0;
        major_rev_number = 0;
        minor_rev_number = 0;
        bus_number = 0;
    }
    
    if(status == 0)
        return PCI_PASS;
    else
        return PCI_FAIL;
}

/////////////////////////////////////////////////////
int PCI::FindDevice(int devID, int vendID, int devIndex)
{
    int ret_value;
    if(status != 0)
        return PCI_FAIL;

    regs.x.ax = PCI_FINDDEVICE;
    regs.x.cx = devID;
    regs.x.dx = vendID;
    regs.x.si = devIndex;

    ret_value = __dpmi_int(PCI_INT_NUM, &regs);
    if(ret_value == -1) {
        status = 1;
        return PCI_FAIL;
    }

    bus_number = regs.h.bh;
    function_number = regs.h.bl;

    if(regs.h.ah == SUCCESSFUL)
        return PCI_PASS;
    else
        return PCI_FAIL;
}

/////////////////////////////////////////////////////
int PCI::FindClassCode(int baseclass, int subclass, int interface, int devIndex)
{
    int ret_value;
    int class_code;

    if(status != 0)
        return PCI_FAIL;

    class_code = ((baseclass&0xff)<<16) | ((subclass&0xff<<8) | (interface&0xff));
    regs.x.ax = PCI_FINDCLASSCODE;
    regs.d.ecx = class_code;
    regs.x.si = devIndex;

    ret_value = __dpmi_int(PCI_INT_NUM, &regs);
    if(ret_value == -1) {
        status = 1;
        return PCI_FAIL;
    }

    bus_number = regs.h.bh;
    function_number = regs.h.bl;

    if(regs.h.ah == SUCCESSFUL)
        return PCI_PASS;
    else
        return PCI_FAIL;
}

/////////////////////////////////////////////////////
void PCI::SetFunctionNumber(int funct_num)
{
    function_number = funct_num;
}

/////////////////////////////////////////////////////
int PCI::GetFunctionNumbet(void)
{
    return function_number;
}

/////////////////////////////////////////////////////
void PCI::SetBusNumber(int bus_num)
{
    bus_number = bus_num;
}

/////////////////////////////////////////////////////
int PCI::GetBusNumber(void)
{
    return bus_number;
}

/////////////////////////////////////////////////////
int PCI::ReadConfigBYTE(int reg, BYTE *retBYTE, int funct_num, int bus_num)
{
    int ret_value;
    if(status != 0)
        return PCI_FAIL;

    regs.x.ax = PCI_READCONFIGBYTE;
    if(bus_num == -1)
        regs.h.bh = bus_number;
    else
        regs.h.bh = bus_num;

    if(funct_num == -1)
        regs.h.bl = function_number;
    else
        regs.h.bl = funct_num;

    regs.x.di = reg;

    ret_value = __dpmi_int(PCI_INT_NUM, &regs);
    if(ret_value == -1) {
        status = 1;
        return PCI_FAIL;
    }

    if(regs.h.ah != SUCCESSFUL)
        status = 3;

    *retBYTE = regs.h.cl;

    if(status == 0)
        return PCI_PASS;
    else
        return PCI_FAIL;
}

/////////////////////////////////////////////////////
int PCI::ReadConfigWORD(int reg, WORD *retWORD, int funct_num, int bus_num)
{
    int ret_value;
    if(status != 0)
        return PCI_FAIL;

    regs.x.ax = PCI_READCONFIGWORD;
    if(bus_num == -1)
        regs.h.bh = bus_number;
    else
        regs.h.bh = bus_num;

    if(funct_num == -1)
        regs.h.bl = function_number;
    else
        regs.h.bl = funct_num;

    regs.x.di = reg;

    ret_value = __dpmi_int(PCI_INT_NUM, &regs);
    if(ret_value == -1) {
        status = 1;
        return PCI_FAIL;
    }

    if(regs.h.ah != SUCCESSFUL)
        status = 3;

    *retWORD = regs.x.cx;

    if(status == 0)
        return PCI_PASS;
    else
        return PCI_FAIL;
}

/////////////////////////////////////////////////////
int PCI::ReadConfigDWORD(int reg, DWORD *retDWORD, int funct_num, int bus_num)
{
    int ret_value;
    if(status != 0)
        return PCI_FAIL;

    regs.x.ax = PCI_READCONFIGDWORD;
    if(bus_num == -1)
        regs.h.bh = bus_number;
    else
        regs.h.bh = bus_num;

    if(funct_num == -1)
        regs.h.bl = function_number;
    else
        regs.h.bl = funct_num;

    regs.x.di = reg;

    ret_value = __dpmi_int(PCI_INT_NUM, &regs);
    if(ret_value == -1) {
        status = 1;
        return PCI_FAIL;
    }

    if(regs.h.ah != SUCCESSFUL)
        status = 3;

    *retDWORD = regs.d.ecx;

    if(status == 0)
        return PCI_PASS;
    else
        return PCI_FAIL;
}

/////////////////////////////////////////////////////
int PCI::WriteConfigBYTE(int reg, BYTE writeBYTE, int funct_num, int bus_num)
{
    int ret_value;
    if(status != 0)
        return PCI_FAIL;

    regs.x.ax = PCI_WRITECONFIGBYTE;
    if(bus_num == -1)
        regs.h.bh = bus_number;
    else
    regs.h.bl = bus_num;
     
    if(funct_num == -1)
        regs.h.bh = function_number;
    else
        regs.h.bh = funct_num;
    regs.x.di = reg;
    regs.h.cl = writeBYTE;

    ret_value = __dpmi_int(PCI_INT_NUM, &regs);
    if(ret_value == -1) {
        status = 1;
        return PCI_FAIL;
    }
    
    if(regs.h.ah != SUCCESSFUL)
        status = 4;

    if(status == 0)
        return PCI_PASS;
    else
        return PCI_FAIL;
}

/////////////////////////////////////////////////////
int PCI::WriteConfigWORD(int reg, WORD writeWORD, int funct_num, int bus_num)
{
    int ret_value;
    if(status !=0)
        return PCI_FAIL;

    regs.x.ax = PCI_WRITECONFIGWORD;
    if(bus_num == -1)
        regs.h.bh = bus_number;
    else
        regs.h.bl = bus_num;
     
    if(funct_num == -1)
        regs.h.bh = function_number;
    else
        regs.h.bh = funct_num;
    regs.x.di = reg;
    regs.x.cx = writeWORD;

    ret_value = __dpmi_int(PCI_INT_NUM, &regs);
    if(ret_value == -1) {
        status = 1;
        return PCI_FAIL;
    }
    
    if(regs.h.ah != SUCCESSFUL)
        status = 4;

    if(status == 0)
        return PCI_PASS;
    else
        return PCI_FAIL;
}

/////////////////////////////////////////////////////
int PCI::WriteConfigDWORD(int reg, DWORD writeDWORD, int funct_num, int bus_num)
{
    int ret_value;
    if(status !=0)
        return PCI_FAIL;

    regs.x.ax = PCI_WRITECONFIGDWORD;
    if(bus_num == -1)
        regs.h.bh = bus_number;
    else
        regs.h.bl = bus_num;
     
    if(funct_num == -1)
        regs.h.bh = function_number;
    else
        regs.h.bh = funct_num;
    regs.x.di = reg;
    regs.d.ecx = writeDWORD;

    ret_value = __dpmi_int(PCI_INT_NUM, &regs);
    if(ret_value == -1) {
        status = 1;
        return PCI_FAIL;
    }
    
    if(regs.h.ah != SUCCESSFUL)
        status = 4;

    if(status == 0)
        return PCI_PASS;
    else
        return PCI_FAIL;
}

/////////////////////////////////////////////////////
WORD PCI::GetVendorID(int funct_num, int bus_num)
{
    DWORD value;
        
    if(ReadConfigDWORD(0, &value, funct_num, bus_num) == PCI_FAIL)
        return 0xFFFF;
    
    return(value & 0xFFFF);
}

/////////////////////////////////////////////////////
WORD PCI::GetDeviceID(int funct_num, int bus_num)
{
    DWORD value;
        
    if(ReadConfigDWORD(0, &value, funct_num, bus_num) == PCI_FAIL)
        return 0xFFFF;
    
    return((value>>16) & 0xFFFF);
}

/////////////////////////////////////////////////////
WORD PCI::GetStatusReg(int funct_num, int bus_num)
{
    DWORD value;
        
    if(ReadConfigDWORD(4, &value, funct_num, bus_num) == PCI_FAIL)
        return 0x0000;
    
    return((value>>16) & 0xFFFF);
}

/////////////////////////////////////////////////////
WORD PCI::GetCommandReg(int funct_num, int bus_num)
{
    DWORD value;
        
    if(ReadConfigDWORD(4, &value, funct_num, bus_num) == PCI_FAIL)
        return 0xFFFF;
    
    return(value & 0xFFFF);
}

/////////////////////////////////////////////////////
DWORD PCI::GetClassCodeReg(int funct_num, int bus_num)
{
    DWORD value;
        
    if(ReadConfigDWORD(8, &value, funct_num, bus_num) == PCI_FAIL)
        return 0x000000;
    
    return((value>>8) & 0xFFFFFF);
}

/////////////////////////////////////////////////////
BYTE PCI::GetRevisionID(int funct_num, int bus_num)
{
    DWORD value;
        
    if(ReadConfigDWORD(8, &value, funct_num, bus_num) == PCI_FAIL)
        return 0x00;
    
    return(value & 0xFF);
}

/////////////////////////////////////////////////////