vidfield.cpp

djgpp bt878 capture for DOS

#include <stdio.h>
#include <stdio.h>
#include "Vidfield.h"

VIDEO_FIELD::VIDEO_FIELD(int funct_num, int bus_num)
{
    DWORD VideoBase;
    
    /* Make sure Video is function number #0 */ 
    pci.SetFunctionNumber( funct_num );
    pci.SetBusNumber( bus_num );
    
    /* Get the Physical Address (Remove lower 4 info bits) */ 
    VideoBase = pci.GetBaseAddress() & 0xFFFFFFF0;
    
    /* Check for and invalid address */
    if(VideoBase == 0) {
        printf("ERROR: Bad Video Address (0x0)\n");
        exit(10);
    }
    
    /* Enable memory access if not enabled (some BIOS don't) */
    if(pci.IsMemoryAccess() == FALSE)
        pci.SetMemoryAccess(true);

    /* Create a virtual memory access point */
    virtual_mem.CreateVirtual(VideoBase, 4 * 1024 /*4K*/);
    if(virtual_mem.status != 0) {
        printf("%s\n", virtual_mem.ErrString());
        exit(10);
    } 
    
    RiscDMA = 0;
}

/*************************************************************************/
/*  Clean up Video Field information                                     */
/*************************************************************************/
VIDEO_FIELD::~VIDEO_FIELD()
{
    if(RiscDMA != 0)
        delete RiscDMA;
}

/*************************************************************************/
/*  Allocate DMA memory for Risc program storage.                        */
/*      risc_size - Number of bytes to allocate.                         */
/*************************************************************************/
void VIDEO_FIELD::AllocateRiscMemory(int risc_size)
{
    if(RiscDMA != 0)
        delete RiscDMA;

    /* Make sure that it DWORD(multiple of 4) in size */
    risc_size = (risc_size + 3) & 0xfffffffc;

    RiscDMA = new DMA_BUFFER(risc_size);
}

/*************************************************************************/
/*    Read DWORD from config register (reg).                             */
/*************************************************************************/
DWORD VIDEO_FIELD::ReadConfigDWORD(int reg)
{
    DWORD retDWORD;
    
    if (pci.ReadConfigDWORD( reg, &retDWORD ) == 0) {
        printf("ERROR: reading config register 0x%X\n", reg);
        exit(10);
    }
    
    return retDWORD;
}

/*************************************************************************/
/*    Write DWORD (writeDWORD) to config register (reg).                 */
/*************************************************************************/
void VIDEO_FIELD::WriteConfigDWORD(int reg, DWORD writeDWORD)
{
    if (pci.WriteConfigDWORD(reg, writeDWORD ) == 0 ) {
        printf("ERROR: writing config register 0x%X\n", reg);
        exit(10);
    }
}

/*************************************************************************/
/*    Read DWORD from Local register (reg).                              */
/*************************************************************************/
DWORD VIDEO_FIELD::ReadLocalDWORD(int reg)
{
    DWORD retDWORD;
    
    retDWORD = virtual_mem.Get(reg);
    
    return retDWORD;
}

/*************************************************************************/
/*    Write DWORD (writeDWORD) to Local register (reg).                  */
/*************************************************************************/
void VIDEO_FIELD::WriteLocalDWORD(int reg, DWORD writeDWORD)
{
    virtual_mem.Set(writeDWORD, reg);
}

/*************************************************************************/
/*    Copy the risc program into RiscDMA.                                */
/*    Inputs:                                                            */
/*        risc - pointer to Risc program to copy.                        */
/*        length - number of bytes to copy.                              */
/*        offset - offset to place risc program in RiscDMA               */
/*************************************************************************/
void VIDEO_FIELD::SetRisc(DWORD *risc, int length, int offset)
{
    offset &= 0xFFFFFFFC;   // make sure that offset is DWORD aligned
    
    RiscDMA->CopyFrom(risc, length, offset);
}

/*************************************************************************/
/*    Copy the RiscDMA program into risc.                                */
/*    Inputs:                                                            */
/*        risc_main - pointer to Risc program to copy into.              */
/*        length - number of bytes to copy.                              */
/*        offset - offset to use when getting risc program from RiscDMA  */
/*************************************************************************/
void VIDEO_FIELD::GetRisc( DWORD *risc, int length, int offset)
{
    offset &= 0xFFFFFFFC;   // make sure that offset is DWORD aligned
    
    RiscDMA->CopyTo(risc, length, offset);
}