/////////////////////////////////////////////////////////////////////
// File:    DESmedium_SW1.c
// Date:    04 December 2000
// Author:  Antonio Esteves, GEC-DI-UM.
//
// Software part of the hardware/software implementation of DES.
// The hardware 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 "DESmedium_SW.h"
#include "edgar2_lib.h"
#include "pci_diag_lib.h"

// Global variable used to store 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.
//  Call the function that controls DES execution.
//------------------------------------------------------------------------

void EDGAR2A_AccessRangesForDES(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!");

    //-----------------------------------------------------
    //      Set active access mode to DWORD (32 bit)
    //-----------------------------------------------------

    // 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);

    ad_mode = EDGAR2A_MODE_DWORD;

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

    if (hEDGAR2A)
        read_write (hEDGAR2A, ad_sp);
    }

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

void EDGAR2A_AccessRegistersForDES(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-DES.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)
            {
            // verify if a new byte can be sent to the fpgas

            do  {
                status = EDGAR2A_ReadfpgaRdyNotBusy( hEDGAR2 );
                ++tmp;
                } while (status != 0xffffffff);

            // send a 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 |           Hardware/software implementation of             |");
    printf ("\n |          Decryption Encryption Standard  (DES)            |");
    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_AccessRegistersForDES(hEDGAR2A);

    //-----------------------------------------------------
    //        Access EDgAR-2 memory and I/O ranges
    //-----------------------------------------------------

    if (hEDGAR2A)
        EDGAR2A_AccessRangesForDES(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;
    }