/////////////////////////////////////////////////////////////////////
// File:    convolucao1.c
// Date:    13 August 2000
// Author:  Antonio Esteves, GEC-DI-UM.
//
// S/W part of the HW/SW implementation of a convolution
// between a 256x256 image and a 3x3 Sobel filter.
//
// The H/W part is mapped into EDgAR-2 board.
//
// The accesses to EDgAR-2 is done via WinDriver functions.
//
////////////////////////////////////////////////////////////////////

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

#include "convolucao.h"
#include "edgar2_lib.h"
#include "pci_diag_lib.h"

#define newline()  while(getchar()!='\n')

// Global variable used to sore command input by the user
static char line[256];

//------------------------------------------------------------------------
//  Define which Address Space (memory or i/o) and the access mode
//  to use on EDgAR-2 read/write operations.
//  Calls the function that controls CONVOLUTION execution.
//------------------------------------------------------------------------

void EDGAR2A_AccessRangesForConvolution(EDGAR2A_HANDLE hEDGAR2A)

    {
    EDGAR2A_ADDR  ad_sp   = 0;
    EDGAR2A_MODE  ad_mode = EDGAR2A_MODE_DWORD;

    for (; ad_sp<EDGAR2A_ITEMS && !EDGAR2A_IsAddrSpaceActive(hEDGAR2A,
         ad_sp); ad_sp++)
    if (ad_sp==EDGAR2A_ITEMS)
        {
        printf ("\n No active memory or i/o ranges on EDgAR-2 board!");
        return;
        }

    //-----------------------------------------------------
    // Active memory space is BAR 0
    //-----------------------------------------------------
    ad_sp = 0;
    if (!EDGAR2A_IsAddrSpaceActive(hEDGAR2A, ad_sp))
        printf ("\n Chosen space not active!");

    //-----------------------------------------------------
    // Active access mode is DWORD (32 bit)
    //-----------------------------------------------------
    //
    // The possible access modes are:
    // =============================
    //
    //   * EDGAR2A_MODE_BYTE  ( 8 bit)
    //   * EDGAR2A_MODE_WORD  (16 bit)
    //   * EDGAR2A_MODE_DWORD (32 bit)

    ad_mode = EDGAR2A_MODE_DWORD;

    //-----------------------------------------------------
    //        Access EDgAR-2 memory and i/o ranges
    //-----------------------------------------------------

    if (hEDGAR2A)
        read_write (hEDGAR2A, ad_sp);

    // The possible access modes are:
    // =============================
    //
    // READ IN 8 BIT MODE: ad_mode=EDGAR2A_MODE_BYTE
    //
    // data = EDGAR2A_ReadByte(hEDGAR2A, ad_sp, addr);

    // READ IN 16 BIT MODE: ad_mode=EDGAR2A_MODE_WORD
    //
    // data = EDGAR2A_ReadWord(hEDGAR2A, ad_sp, addr);

    // READ IN 32 BIT MODE: ad_mode=EDGAR2A_MODE_DWORD
    //
    // data = EDGAR2A_ReadDword(hEDGAR2A, ad_sp, addr);

    // WRITE IN 8 BIT MODE: ad_mode=EDGAR2A_MODE_BYTE
    //
    // EDGAR2A_WriteByte(hEDGAR2A, ad_sp, addr, (BYTE) data);

    // WRITE IN 16 BIT MODE: ad_mode=EDGAR2A_MODE_WORD
    //
    // EDGAR2A_WriteWord(hEDGAR2A, ad_sp, addr, (WORD) data);

    // WRITE IN 32 BIT MODE: ad_mode=EDGAR2A_MODE_DWORD
    //
    // EDGAR2A_WriteDword(hEDGAR2A, ad_sp, addr, data);

    }

//================================================================

void EDGAR2A_AccessRegistersForConvolution(EDGAR2A_HANDLE hEDGAR2A)

    {
    DWORD data;

    // Write to enable PCI control
    data = (DWORD)0x1E;
    printf("\n Enabled the (5) PCI transactions control signals ...");
    EDGAR2A_WriteenablePciCtlSignals ( hEDGAR2A, data);

    // Write to define JTAG chain
    data = (DWORD)2;
    printf("\n JTAG chain was setup to program CPLDs ...");
    EDGAR2A_WriteprogramJtagChain( hEDGAR2A, data);

    // Write to program SCLOCK
    data = (DWORD)7;
    printf("\n Secondary clock was defined as the Cristal Output ...");
    EDGAR2A_WriteSCLOCK( hEDGAR2A, data);

    // Write to FPGA /PROGRAM
    data = (DWORD)0xF;
    printf("\n The 4 FPGAs will be Programmed Next ...");
    EDGAR2A_WritenotProgramFpga( hEDGAR2A, data);

    // Read from FPGAs DONE
    data = EDGAR2A_ReadDONE( hEDGAR2A);
    printf("\n FPGAs DONE pins are %x", data);

    // Read from FPGAs /INIT
    data = EDGAR2A_ReadnotINIT( hEDGAR2A);
    printf("\n FPGAs /INIT pins are %x", data);

    // Read from FPGAs RDY/BUSY
    data = EDGAR2A_ReadfpgaRdyNotBusy( hEDGAR2A);
    printf("\n FPGAs RDY/notBUSY pins are %x", data);

    // Write cfg to the 4 FPGAs
    programar4Fpgas ( hEDGAR2A, "f-all-convol.bit");

    // Read from FPGAs DONE
    data = EDGAR2A_ReadDONE( hEDGAR2A);
    printf("\n FPGAs DONE pins are %x", data);

    // Read from FPGAs /INIT
    data = EDGAR2A_ReadnotINIT( hEDGAR2A);
    printf("\n FPGAs /INIT pins are %x", data);

    // Read from FPGAs RDY/BUSY
    data = EDGAR2A_ReadfpgaRdyNotBusy( hEDGAR2A);
    printf("\n FPGAs RDY/notBUSY pins are %x", data);

    }

//------------------------------------------------------------------------
// Interrupt Handler Routine (IT IS NOT USED)
//------------------------------------------------------------------------

void WINAPI EDGAR2A_IntHandlerRoutine(EDGAR2A_HANDLE hEDGAR2A,
     EDGAR2A_INT_RESULT *intResult)
    {
    printf ("\n Got Int number %d", intResult->dwCounter);
    }

//------------------------------------------------------------------------
//                  Enable/disable interrupts
//------------------------------------------------------------------------

void EDGAR2A_EnableDisableInterrupts(EDGAR2A_HANDLE hEDGAR2A,
    BOOL intEnable)
    {
    if (EDGAR2A_IntIsEnabled(hEDGAR2A)) // interrupts are enabled
        {
        if(intEnable == FALSE)          // order to disable interrupts
            {
            printf ("\n Disabling Interrupt");
            EDGAR2A_IntDisable(hEDGAR2A);
            }
        else                            // order to enable interrupts
            {;}
        }
    else                                // interrupts are disabled
        {
        if(intEnable == TRUE)           // order to enable interrupts
            {
            printf ("\n Enabling Interrupt");
            if (!EDGAR2A_IntEnable(hEDGAR2A, EDGAR2A_IntHandlerRoutine))
                printf ("\n Failed enabling Interrupt");
            }
        else                            // order to disable interrupts
            {;}
        }
    }

//------------------------------------------------------------------------
//                   Locate and Open EDgAR-2 Board
//------------------------------------------------------------------------

EDGAR2A_HANDLE EDGAR2A_LocateAndOpenBoard (DWORD dwVendorID,
    DWORD dwDeviceID, BOOL fUseInt)
{
    DWORD cards, my_card;
    EDGAR2A_HANDLE hEDGAR2A = NULL;

    if (dwVendorID==0)
    {
        printf ("Enter VendorID: ");
        gets(line);
        sscanf (line, "%x",&dwVendorID);
        if (dwVendorID==0) return NULL;

        printf ("Enter DeviceID: ");
        gets(line);
        sscanf (line, "%x",&dwDeviceID);
    }
    cards = EDGAR2A_CountCards (dwVendorID, dwDeviceID);
    if (cards==0)
    {
        printf("%s", EDGAR2A_ErrorString);
        return NULL;
    }
    else if (cards==1) my_card = 1;
    else
    {
        DWORD i;

        printf("\n Found %d matching PCI cards. ", cards);
        printf("Select card (1-%d): ", cards);
        i = 0;
        gets(line);
        sscanf (line, "%d",&i);
        if (i>=1 && i <=cards) my_card = i;
        else
        {
            printf ("\n Choice out of range.");
            return NULL;
        }
    }
    if (EDGAR2A_Open (&hEDGAR2A, dwVendorID, dwDeviceID, my_card - 1,
            fUseInt ? EDGAR2A_OPEN_USE_INT : 0 ))
        printf ("\n EDgAR-2 PCI card found.");
    else printf ("%s", EDGAR2A_ErrorString);
    return hEDGAR2A;
}

//------------------------------------------------------------------------
//  Function that sends configuration bytes to all FPGAs bytes, from
//  a file that contains the junction of the 4 FPGAs configurations.
//------------------------------------------------------------------------

int programar4Fpgas(EDGAR2A_HANDLE hEDGAR2, char *nome)
    {
    FILE          *fp;
    unsigned int  i=0, num, n, tmp=0;
    DWORD         data[512], status;

    if((fp=fopen(nome,"rb")) == NULL)
        {
        printf("\n Error when opening %s file.",nome);
        return(0);
        }

    for(n=0;;)
        {
        num = fread( data, sizeof(DWORD), 512, fp);

        for(i=0;i<num;++i,++n)
            {
            do  { // verify if a new byte can be sent to the fpgas
                status = EDGAR2A_ReadfpgaRdyNotBusy( hEDGAR2 );
                ++tmp;
                } while (status != 0xffffffff);

            // send 1 configuration byte
            EDGAR2A_Writecfg_3_2_1_0 (hEDGAR2, data[i]);
            }

        if(num < 512)
            break;
        }

    printf("\n They were read %d times the FPGAs status.",tmp);
    printf("\n They were sent %d bytes to each FPGA.",n);

    fclose(fp);
    return(1);
    }

//------------------------------------------------------------------------
//------------------------------------------------------------------------

int main(int argc, char *argv[])

    {
    EDGAR2A_HANDLE hEDGAR2A = NULL;
    HANDLE         hWD;
    BOOL           fUseInt = FALSE; // by default do not install interrupts

    printf ("\n+--------------------------------------------------------+");
    printf ("\n|              EDgAR-2 User Mode Driver                  |");
    printf ("\n|              ========================                  |");
    printf ("\n|                                                        |");
    printf ("\n| Convolution of a 256x256 Image with a 3x3 Sobel filter |");
    printf ("\n+--------------------------------------------------------+");
    printf ("\n");

    //-----------------------------------------------------
    //         Verify that WinDriver is loaded
    //-----------------------------------------------------

    if (!PCI_Get_WD_handle(&hWD))
        return 0;

    //-----------------------------------------------------
    //           Locate and Open EDgAR-2 Board
    //-----------------------------------------------------

    if (EDGAR2A_DEFAULT_VENDOR_ID)
        hEDGAR2A = EDGAR2A_LocateAndOpenBoard(EDGAR2A_DEFAULT_VENDOR_ID,
            EDGAR2A_DEFAULT_DEVICE_ID, fUseInt);

    //-----------------------------------------------------
    // Enable/Disable interrupts
    //-----------------------------------------------------
    // if (hEDGAR2A && hEDGAR2A->fUseInt)
    //    EDGAR2A_EnableDisableInterrupts(hEDGAR2A);

    //-----------------------------------------------------
    // Access EDgAR-2 local registers
    //-----------------------------------------------------

    //if (hEDGAR2A) EDGAR2A_AccessRegistersForConvolution(hEDGAR2A);

    //-----------------------------------------------------
    //        Access EDgAR-2 memory and i/o ranges
    //-----------------------------------------------------

    if (hEDGAR2A)
        EDGAR2A_AccessRangesForConvolution(hEDGAR2A);

    //-----------------------------------------------------
    //                 Close EDgAR-2 Board Access
    //-----------------------------------------------------

    if (hEDGAR2A)
        EDGAR2A_Close(hEDGAR2A);

    WD_Close (hWD);

    printf ("\n                                                           ");
    printf ("\n               END OF CODESIGN SESSION                     ");
    printf ("\n+--------------------------------------------------------+ \n");
    getchar();
    return 0;

    }