//*****************************************************************************
// THIS CODE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED 
// OR IMPLIED. THIS CODE IS LABELED "OPEN SOFTWARE" AND MAY BE FREELY USED, 
// REPRODUCED, MODIFIED, AND/OR REDISTRIBUTED WITH THE STIPULATION THAT THIS 
// NOTICE REMAIN INTACT. REDISTRIBUTION OF ANY KIND IMPLIES THAT ALL
// MODIFICATIONS FALL UNDER THIS "OPEN SOFTWARE" LABEL.
//
// Copyright (C) 2000, Foxen Solutions
// Copyright (C) 2000, FXN
//
// All Rights Reserved.
//*****************************************************************************
//
//
// This is TestPCIDP.cpp.  It is a console application that tests the basic
// functionality of the PCI-DP Development Board.
//
// NOTE: for optimal readability set your TABs option to 2 spaces.
//*****************************************************************************

#include "PCIDP_IF.h"
#include "windows.h"
#include "stdio.h"

void PrintState(unsigned long Status){

	if(Status == ERROR_SUCCESS)
		printf("PASSED\n");
	else
		printf("ERROR (%ld)\n", Status);
}


void main(){

	unsigned long BoardNumber;
	unsigned long BoardCount;
	unsigned long PCIDPHandle[16];
	unsigned long Status;
	unsigned char* CAddress;
	unsigned long* Address;
	unsigned long* DMALinAddress;
	unsigned long DMAPhyAddress;
	unsigned long IOAddress;
	unsigned long IOSpace;
	unsigned long Length;
	unsigned long SM[20];
	int i;
	PCIDP_CONFIG PCIConfiguration;
	HANDLE InterruptID;
	HANDLE InterruptEvt;
	DWORD WaitStatus;
	unsigned long Version;

	Status = ERROR_SUCCESS;
	BoardCount = 0;
	while(Status == ERROR_SUCCESS){

		Status = OpenPCIDP(
			BoardCount, 
			&PCIDPHandle[BoardCount]
		);
		BoardCount++;
	}
	BoardCount--;
	printf("Number of boards: %ld\n", BoardCount);

	BoardNumber = 0;
	while(BoardNumber < BoardCount){

		printf("\nTesting board #%ld...\n", BoardNumber);

		Status = GetDriverVersion(PCIDPHandle[BoardNumber], &Version);
		printf("\nDriver version: %lx\n", Version);

		printf("Map base register 0...");
		Length = 0x8000;
		Status = MapBaseRegister(
			PCIDPHandle[BoardNumber],
			0,
			&Length,
			&Address,
			&IOAddress,
			&IOSpace
		);
		PrintState(Status);

		if(Status == ERROR_SUCCESS){
			printf("Access shared memory...");
			for(i=0; i<19; i++)
				SM[i] = Address[i+0x1000];
			SM[i] = Address[0x4fc/4];
			printf("PASSED\n");

			printf("Unmap base register 0...");
			Status = UnMapBaseRegister(
				PCIDPHandle[BoardNumber],
				Address
			);
			PrintState(Status);
		}

		printf("Map base register 1...");
		Length = 8;
		Status = MapBaseRegister(
			PCIDPHandle[BoardNumber],
			1,
			&Length,
			&Address,
			&IOAddress,
			&IOSpace
		);
		PrintState(Status);

		printf("Map base register 2...");
		Length = 0x8000;
		Status = MapBaseRegister(
			PCIDPHandle[BoardNumber],
			2,
			&Length,
			&Address,
			&IOAddress,
			&IOSpace
		);
		PrintState(Status);

		printf("Map base register 11...");
		Length = 0x8000;
		Status = MapBaseRegister(
			PCIDPHandle[BoardNumber],
			11,
			&Length,
			&Address,
			&IOAddress,
			&IOSpace
		);
		PrintState(Status);

		printf("Map DMA memory...");
		Status = MapDMAMemory(
			PCIDPHandle[BoardNumber],
			&Address, 
			&IOAddress
		);
		PrintState(Status);

		if(Status == ERROR_SUCCESS){
			printf("Access DMA memory...");
			for(i=0; i<20; i++)
				SM[i] = Address[i];
			printf("PASSED\n");

			printf("Unmap DMA memory...");
			Status = UnMapDMAMemory(
				PCIDPHandle[BoardNumber],
				Address
			);
			PrintState(Status);
		}

		printf("Get PCI Configuration...");
		Status = GetPCIConfigurationSpace(
			PCIDPHandle[BoardNumber],
			&PCIConfiguration
		);
		PrintState(Status);

		printf("Set PCI Configuration...");
		Status = SetPCIConfigurationSpace(
			PCIDPHandle[BoardNumber],
			&PCIConfiguration
		);
		PrintState(Status);

		printf("Register interrupt 'DMAComplete'...");
		Status = RegisterInterrupt(
			PCIDPHandle[BoardNumber],
			PCIDP_DMAComplete,
			&InterruptID,
			&InterruptEvt
		);
		PrintState(Status);

		printf("Unregister interrupt 'DMAComplete'...");
		Status = UnRegisterInterrupt(
			PCIDPHandle[BoardNumber],
			InterruptID
		);
		PrintState(Status);

		printf("Register interrupt 'Unknown'...");
		Status = RegisterInterrupt(
			PCIDPHandle[BoardNumber],
			0x400,
			&InterruptID,
			&InterruptEvt
		);
		PrintState(Status);

		printf("\nTest I20 PCI FIFO Overflow...\n");
		printf("  1. Register 'I2OPCIFIFOOverflow' interrupt...");
		Status = RegisterInterrupt(
			PCIDPHandle[BoardNumber],
			PCIDP_I2OPCIFIFOOverflow,
			&InterruptID,
			&InterruptEvt
		);
		PrintState(Status);

		if(Status != ERROR_SUCCESS) goto EndTestFIFO;
		printf("  2. Map Base Register 0...");
		Length = 0x8000;
		Status = MapBaseRegister(
			PCIDPHandle[BoardNumber],
			0,
			&Length,
			&Address,
			&IOAddress,
			&IOSpace
		);
		PrintState(Status);

		if(Status != ERROR_SUCCESS) goto EndTestFIFOA;
		ResetEvent(InterruptEvt);
		printf("  3. Begin overflow FIFO...");
		for(i=0; i<33; i++)
			Address[0x11] = 0xA5A5A5A5;

		WaitStatus = WaitForSingleObject(InterruptEvt, 1000);
		if(WaitStatus == WAIT_TIMEOUT)
			printf("TIMEOUT\n");
		else
			printf("PASSED\n");

		Status = UnMapBaseRegister(
			PCIDPHandle[BoardNumber],
			Address
		);

		EndTestFIFOA:
		Status = UnRegisterInterrupt(
			PCIDPHandle[BoardNumber],
			InterruptID
		);

		EndTestFIFO:		

		printf("\nPerform DMA transfer with interrupts (host to local)...\n");
		printf("  1. Register 'DMAComplete' interrupt...");
		Status = RegisterInterrupt(
			PCIDPHandle[BoardNumber],
			PCIDP_DMAComplete,
			&InterruptID,
			&InterruptEvt
		);
		PrintState(Status);

		if(Status != ERROR_SUCCESS) goto EndDMAHostLocal;
		printf("  2. Map Base Register 0...");
		Length = 0x8000;
		Status = MapBaseRegister(
			PCIDPHandle[BoardNumber],
			0,
			&Length,
			&Address,
			&IOAddress,
			&IOSpace
		);
		CAddress = (unsigned char*)Address;
		PrintState(Status);

		if(Status != ERROR_SUCCESS) goto EndDMAHostLocalA;
		printf("  3. Map DMA memory...");
		Status = MapDMAMemory(
			PCIDPHandle[BoardNumber],
			&DMALinAddress, 
			&DMAPhyAddress
		);
		PrintState(Status);
		
		if(Status != ERROR_SUCCESS) goto EndDMAHostLocalB;
		printf("  4. Fill host DMA memory...");
		for(i=0; i<0x1000; i++)
			DMALinAddress[i] = 0xFEDC0000 | i;
		printf("OK\n");
		
		if(Status != ERROR_SUCCESS) goto EndDMAHostLocalC;
		ResetEvent(InterruptEvt);
		printf("  5. Perform DMA transfer...");
		Address[0x04B0/4] = 0x100;
		Address[0x04B4/4] = DMAPhyAddress;
		Address[0x04B8/4] = 0x3FFC-0x100;

		for(i=0; i<10000; i++){
			CAddress[0x04BC] = 0;
			WaitStatus = WaitForSingleObject(InterruptEvt, 1000);
			if(WaitStatus == WAIT_TIMEOUT){
				printf("TIMEOUT\n");
				break;
			}
			ResetEvent(InterruptEvt);
		}
		if(WaitStatus != WAIT_TIMEOUT)
			printf("OK - %d bytes transfered\n", 10000*0x3F00);

		EndDMAHostLocalC:
		Status = UnMapDMAMemory(
			PCIDPHandle[BoardNumber],
			DMALinAddress
		);

		EndDMAHostLocalB:
		Status = UnMapBaseRegister(
			PCIDPHandle[BoardNumber],
			Address
		);

		EndDMAHostLocalA:
		Status = UnRegisterInterrupt(
			PCIDPHandle[BoardNumber],
			InterruptID
		);

		EndDMAHostLocal:


		BoardNumber++;
	}

	Sleep(100);
}