#include <fenv.h>
#include <fpu_control.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <time.h>
#include <math.h>
#include "umrbus.h"

#define CMDSIZE    512
#define ALLBYTES   255


  int error;
  char *errormessage;
      
  unsigned int DEVICE_0 = 0;
  unsigned int BUS_1    = 1;

  unsigned int Capim1 = 1;
  unsigned int Capim2 = 2;
  unsigned int Capim3 = 3;
  unsigned int Capim4 = 4;


  int buffer_Adress = -1;
  int upload_buffer[8];
  int buffer_Mask =0;

  int read_buffer_Adress = -1;
  char read_buffer[8];

 
extern  UMR_HANDLE addr_handle;
extern  UMR_HANDLE data1_handle;
extern  UMR_HANDLE data2_handle;
extern  UMR_HANDLE reset_handle;
      


  
void hardwarereset(){

   system("ebpciconfig -reset 0");          
   system("ebpciconfig -reset 1");
}
    
int close_capims()
{ /* CAPIM 1 */
  if((error=umrbus_close(addr_handle, &errormessage)))
    {
      printf("close capim 3 error: %s\n",errormessage);
      umrbus_errormessage_free(&errormessage);
      return 1;
    }
  else
    printf("close capim 3\n");

  /* CAPIM 2 */
  if((error=umrbus_close(data1_handle, &errormessage)))
    {
      printf("close capim 1 error: %s\n",errormessage);
      umrbus_errormessage_free(&errormessage);
      return 1;
    }
  else
    printf("close capim 1\n");

  /* CAPIM 3 */
  if((error=umrbus_close(data2_handle, &errormessage)))
    {
      printf("close capim 2 error: %s\n",errormessage);
      umrbus_errormessage_free(&errormessage);
      return 1;
    }
  else
    printf("close capim 2\n");

 /* CAPIM 4 */
  if((error=umrbus_close(reset_handle, &errormessage)))
    {
      printf("close capim 4 error: %s\n",errormessage);
      umrbus_errormessage_free(&errormessage);
      return 1;
    }
  else
    printf("close capim 4\n");
 
  return 0;
}


int configure_fpga(char *mcs_file)
{
   
    char cmd[CMDSIZE];
     
     
     strcpy(cmd,"ebpciconfig -config ");
     strcat(cmd,mcs_file);

/********* Load Client application  ******************/
    
    printf("\nload client application ... \n");
    if(system(cmd) != 0)
      {
        printf("\nconfiguration error \n");
        return 1;
      }

    printf("\n\nvamp application sucessfully loaded\n");

  /********* Open UMR-BUS and make connection to all CAPIM   ******************/

  fprintf (stdout, "\n");

  /* CAPIM 1 */
  if((addr_handle = umrbus_open(DEVICE_0,BUS_1,Capim3,&errormessage)) == UMR_INVALID_HANDLE)
    {
      printf("open capim 1 error: %s\n", errormessage);
      umrbus_errormessage_free(&errormessage);
      return 1;
    }
  else
    printf("open capim 1 ok \n");

  /* CAPIM 2 */
  if((data1_handle = umrbus_open(DEVICE_0,BUS_1,Capim1,&errormessage)) == UMR_INVALID_HANDLE)
    {
      printf("open capim 2 error: %s \n", errormessage);
      umrbus_errormessage_free(&errormessage);
      return 1;
    }
  else
    printf("open capim 2 ok \n");

  /* CAPIM 3 */
  if((data2_handle = umrbus_open(DEVICE_0,BUS_1,Capim2,&errormessage)) == UMR_INVALID_HANDLE)
    {
      printf("open capim 3 error: %s\n", errormessage);
      umrbus_errormessage_free(&errormessage);
      return 1;
    }
  else
    printf("open capim 3 ok \n");

 /* CAPIM 4 */
  if((reset_handle = umrbus_open(DEVICE_0,BUS_1,Capim4,&errormessage)) == UMR_INVALID_HANDLE)
    {
      printf("open capim 4 error: %s\n", errormessage);
      umrbus_errormessage_free(&errormessage);
      return 1;
    }
  else
    printf("open capim 4 ok \n");

  return 0;
    
}


int configure_fpga_new(char *mcs_file)
{ close_capims();
  return configure_fpga(mcs_file);
}


unsigned long compute_flags(int wr, int bytesize,unsigned long adresse)
{ unsigned long return_value;
 return_value=adresse*1024;
 return_value=return_value+(512*wr);
 return_value=return_value+bytesize*2;
 return return_value;
}



int wait_for_interrupt(UMR_HANDLE handle )
{ 
  char *errormessage;
  umrbus_interrupt_type int_struct;



  /* prepare Interrupt structure */
  int_struct.mode=1;     /* mode = 0 polling; mode = 1 wait on interrupt or timeout */
  int_struct.timeout=3;  /* timeout in second                                       */

  /* poll for interrupt */
  if(umrbus_interrupt(handle, &int_struct, &errormessage))
    {
      printf("interrupt error: %s\n", errormessage);
      umrbus_errormessage_free(&errormessage);               
      goto exit;
    }
            
  if (int_struct.interrupt != 0)
    {   
      return 0;
    }


  /* close connection */
  printf ("Kein Interrupt\n");
  exit (1);
 exit:
  return 1;
}


int write_data(unsigned long *data1, unsigned long *data2, unsigned long *location, int bytesize)
{

  char *errormessage;
  unsigned long buf1[1];
  unsigned long buf2[1];
  unsigned long addr[1];
 
  unsigned long *parameter_out1=buf1;
  unsigned long *parameter_out2=buf2;
  unsigned long *address=addr;
    
  buf1[0]=*data1;
  buf2[0]=*data2;
  addr[0]=compute_flags(1,bytesize,*location);

  //printf("write %08x%08x at %d, be=%2x\n", *data1, *data2, *location, bytesize);

  if(umrbus_write(data1_handle,parameter_out1, 1, &errormessage))

    {
      printf("write data error: %s \n", errormessage);
      umrbus_errormessage_free(&errormessage);
      goto exit;
    }   

  if(umrbus_write(data2_handle,parameter_out2, 1, &errormessage))

    {
      printf("write data error: %s \n", errormessage);
      umrbus_errormessage_free(&errormessage);
      goto exit;
    } 
  // sleep(1);
  if(umrbus_write(addr_handle,address, 1, &errormessage))

    {
      printf("write data error: %s \n", errormessage);
      umrbus_errormessage_free(&errormessage);
      goto exit;
    }       
  
 
  wait_for_interrupt(addr_handle);

  //printf(" successs !!! /n");
 exit:
  
  return 0;

}



int  read_data(unsigned long *location,unsigned long* return_buf )
{
  char *errormessage;
  unsigned long buf1[1];
  unsigned long buf2[1]; 
  unsigned long addr[1];
    
  unsigned long *address=addr;
  addr[0]=compute_flags(0,ALLBYTES,*location);      

  if(umrbus_write(addr_handle,address, 1, &errormessage))

    {
      printf("write data error: %s \n", errormessage);
      umrbus_errormessage_free(&errormessage);
      goto exit;
    }

  wait_for_interrupt(addr_handle); 
  
  //  sleep(1);

  if(umrbus_read(data2_handle,buf2, 1, &errormessage))
    {
      printf("read data error: %s \n", errormessage);
      umrbus_errormessage_free(&errormessage);
      goto exit;
    }
  /* reading data  */
  if(umrbus_read(data1_handle,buf1, 1, &errormessage))
    {
      printf("read data error: %s \n", errormessage);
      umrbus_errormessage_free(&errormessage);
      goto exit;
    }

   //printf ("Gelesen : %lx\n",buf1[0]);
   //printf ("Gelesen : %lx\n",buf2[0]);
  return_buf[1]=buf1[0];
  return_buf[0]=buf2[0];

  return 0;


 exit:
  
  return 1;
}


int flush_Buffer(){
   unsigned long adresse;
   unsigned long data_out1=0;
   unsigned long data_out2=0;
   int i;
   //unsigned long readbuffer[2]; 
     
   adresse = (unsigned long) buffer_Adress;

   for(i = 0; i < 4; i++)
       data_out2 = data_out2 + ( upload_buffer[i]<< 8*i);//compute data_out2, the low bits

   for(i = 0; i < 4; i++)
       data_out1 = data_out1 + ( upload_buffer[i+4]<< 8*i);//compute data_out2, the high bits

   if( write_data(&data_out1,&data_out2,&adresse,buffer_Mask))  return 1 ;

   //printf("Adresse %x : %lx %lx %x\n",buffer_Adress,data_out1,data_out2,buffer_Mask);
   //read_data(&adresse,readbuffer);
   //printf("Adresse %x : %lx %lx %x\n",buffer_Adress,readbuffer[0],readbuffer[1],buffer_Mask);
  
   buffer_Mask = 0;
 
   return 0;
}

int set_Memory_Byte(int adresse, int value)
{
  if (adresse >> 3 != buffer_Adress)
  {
    flush_Buffer();
    buffer_Adress = adresse >> 3;
  }
  upload_buffer[adresse % 8] = value;
  buffer_Mask |= 1 << (adresse % 8);
   
  return 0;
}

char read_Byte(int adresse)
{
  unsigned long readbuffer[2];
  unsigned long tmpadr;
  int i;

  tmpadr= adresse >> 3;

  if (tmpadr != read_buffer_Adress)
  {
    read_data(&tmpadr, readbuffer);
    read_buffer_Adress = tmpadr;

    for (i=0; i<4; i++){
      read_buffer[i]=(char)((readbuffer[0] << 8*(3-i)) >> 24);    
    }
     for (i=0; i<4; i++){
      read_buffer[i+4]=(char)((readbuffer[1] <<8*(3-i)) >> 24);    
    }
   }
  return read_buffer[adresse % 8];
}