pk_tstlib.cpp

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/mman.h>
#include <termios.h>
#include <unistd.h>
#include <fcntl.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include <sys/mman.h>
#include<sys/types.h>

#include "pcie40_registers.h"
#include "pcie40_s_pages.h"
#include "altera_dma_cmd.h"

// #include "user.h"
#include "pk_tstlib.h"

#define BUFFER_LENGTH 40
char linebis[BUFFER_LENGTH];

#define G_BUFF_SIZE     100 //musi sie dma_status zmiescic !
static char cmdbuff[G_BUFF_SIZE];
static struct dma_cmd G_dma_cmd;
ssize_t f;
static int SHMID;

//---------------------------------------------------------------------------------------------
int dev_init() {

  f = open ("/dev/pcie40_0_dma", O_RDWR);
  if (f == -1) {
    printf ("Couldn't open the device.\n");
    return(-1);
  } else
    printf ("Opened the device: file handle #%lu!\n", (long unsigned int)f);
  return(0);
}
//--------------------------------------------------------------------------------------------------------
void reset() {
  set_reg_bar0(RST_CNTLR_BASE_ADDR,0,1); //"normal" general reset
}

//--------------------------------------------------------------------------------------------------------
void set_act_spage(int link, int spage) {
  unsigned act_spage=(link<<8) | spage;

  G_dma_cmd.cmd  = ALTERA_CMD_ACTSPAGE;
  G_dma_cmd.buf  = cmdbuff;
  *(int *)cmdbuff = act_spage;
  write (f, &G_dma_cmd, 0);
}
//--------------------------------------------------------------------------------------------------------
void modify_link_mask(unsigned mask) {

  unsigned base,data;
  int i;
  char cc;
  G_dma_cmd.cmd  = MODIFY_LINK_MASK;
  G_dma_cmd.buf  = cmdbuff;
  *(int *)cmdbuff = mask;
  write (f, &G_dma_cmd, 0);

  set_reg_bar0(RST_CNTLR_BASE_ADDR,1,mask); //0x404
  set_reg_bar0(RST_CNTLR_BASE_ADDR,0,3);    //reset to update
}
//-------------------------------------------------------------------------------------------------------------------------

void print_menu () {

  printf("\n");
  printf("***********************************************\n");
  printf("** %3d) read status                          **\n", CMD_READ_STATUS                       );
  printf("** %3d) start DAQ                            **\n", CMD_START_DMA                         );
  printf("** %3d) loop number for DAQ                  **\n", LOOP_NUMBER                           );
  printf("** %3d/%3d) read reg/write reg BAR0          **\n", GET_REG_BAR0,SET_REG_BAR0                        );
  printf("** %3d) dump pciedma fifo                    **\n", DEBUG_0                                   );
  printf("** %3d) clean                                **\n", CLEAN                                     );
  printf(" ------------ LAL settings -----------\n");
  printf("** %3d) read lal reg                         **\n", READ_CMD1_REG                                   );
  printf("** %3d) set nb events                        **\n", SET_NB_EVENT                                  );
  printf("** %3d) enable Test Data                 **\n", ENABLE_TEST_DATA                                 );
  printf("** %3d) disable Test Data                **\n", DISABLE_TEST_DATA                                );
 
  printf("** %3d) set nb word by events                **\n", SET_DMA_WORDS                                   );
  printf("** %3d) enable Free from DMA                 **\n", ENABLE_FREE                                 );
  printf("** %3d) disable Free from DMA                **\n", DISABLE_FREE                                );
  printf("** %3d) trigger frequency                    **\n", SET_TRIGGER_FREQUENCY                                 );
  printf("** %3d) Dump fifo latency                    **\n", DUMP_STATE                                );
  printf("** %3d) Data from Fiber                      **\n",SELECT_DATA_FROM_FIBER                                );
  printf("** %3d) Data from Generator                  **\n",     SELECT_DATA_FROM_GENE                        );

  printf("***********************************************\n");
  printf("** %3d) exit                                 **\n", EXIT                                  );
  printf("***********************************************\n");
  printf("# ");
}

//---------------------------------------------------------------------------------------------------
char *read_line (char *buf, size_t length, FILE *f)
{
  char *p;
  if (p = fgets (buf, length, f)) {
    size_t last = strlen(buf) - 1;
    if (buf[last] == '\n') {
      buf[last] = '\0';
    } else {
      fscanf (f, "%*[^\n]");
      (void) fgetc (f);
    }
  }
  return p;
}

//-----------------------------------------------------------------------------------------------------------------
unsigned get_reg_bar2(unsigned offset, unsigned reg) {
  G_dma_cmd.cmd = GET_REG_BAR2;
  G_dma_cmd.buf=cmdbuff;
  *(unsigned *)G_dma_cmd.buf = offset+(reg<<2);
  read (f, &G_dma_cmd, 0);
  return(*(unsigned*)G_dma_cmd.buf);
}
//-----------------------------------------------------------------------------------------------------------------
void     set_reg_bar2 (unsigned offset,unsigned reg,unsigned value) {
  G_dma_cmd.cmd = SET_REG_BAR2;
  G_dma_cmd.buf=cmdbuff;
  *(unsigned *)G_dma_cmd.buf = offset+(reg<<2);
  *(unsigned *)(G_dma_cmd.buf+4) = value;
  write (f, &G_dma_cmd, 0);
  return;
}

//-----------------------------------------------------------------------------------------------------------------
void     set_reg_bar0(unsigned offset,unsigned reg,unsigned value) {
  G_dma_cmd.cmd = SET_REG_BAR0;
  G_dma_cmd.buf=cmdbuff;
  *(unsigned *)G_dma_cmd.buf = offset+(reg<<2);
  *(unsigned *)(G_dma_cmd.buf+4) = value;
  write (f, &G_dma_cmd, 0);
  return;
}
//-----------------------------------------------------------------------------------------------------------------
unsigned get_reg_bar0(unsigned offset, unsigned reg) {
  G_dma_cmd.cmd = GET_REG_BAR0;
  G_dma_cmd.buf=cmdbuff;
  *(unsigned *)G_dma_cmd.buf = offset+(reg<<2);
  read (f, &G_dma_cmd, 0);
  return(*(unsigned*)G_dma_cmd.buf);
}

//--------------------------------------------------------------------------------------------
void show_status() {
  unsigned dat;

  printf("infifo:  %x ",dat=get_reg_bar0(DMAFIFO_BAR_CONTROLLER_BASE_ADDR,0xA));
  dat=(dat & 0x3FF00000)>>20;
  printf("wrdw: %x\n",dat);
  return;
}

//---------------------------------------------------------------------------------------------
void print_infifo(int n) {
  int i,j;
  unsigned dat;
  set_reg_bar0(DMAFIFO_BAR_CONTROLLER_BASE_ADDR,0,1); //readout through "BARs"


  for(j=0;j<n;j++) {
    dat=get_reg_bar0(DMAFIFO_BAR_CONTROLLER_BASE_ADDR,0xA);
    if(!(dat & 0x80000000)) {
      set_reg_bar0(DMAFIFO_BAR_CONTROLLER_BASE_ADDR,1,1); //pulse rd_fifo
      for(i=2;i<10;i++)
        printf(" %08x",get_reg_bar0(DMAFIFO_BAR_CONTROLLER_BASE_ADDR,i));  //8 x 32
      printf(" | ");
      printf(" %08x\n",get_reg_bar0(DMAFIFO_BAR_CONTROLLER_BASE_ADDR,10)); //control bits etc
      set_reg_bar0(DMAFIFO_BAR_CONTROLLER_BASE_ADDR,1,0); //clear pulse rd_fifo
    }
    else
      break;
  }
  printf("infifo empty ?\n");
  set_reg_bar0(DMAFIFO_BAR_CONTROLLER_BASE_ADDR,0,0); //clear "BARs" readout
}
//---------------------------------------------------------------------------------------------

void DumpMem ( unsigned int * mem,int size_in_byte) {
  int j;
  for(j=0;j<size_in_byte/4;j++) {
    printf(" %08x", mem[j]);
    if (!((j+1)%8)) printf("\n");
  }
  printf("\n");
  return;
}

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

void SendDatas( void * buffer,int size_in_byte){

  unsigned int * mem;


  mem = (unsigned int *)malloc( size_in_byte );
  memcpy(mem,buffer,size_in_byte);  

  //  DumpMem (mem,size_in_byte);
  free (mem);
  return;
}
//--------------------------------------------------------------------------------------------------------------------
void read_registers(){
  char cc;
  printf("Cmd1 nb events    ---->REG_TRIG_FREE_RESET= %x REG_NB_WORD_IN_EVENT= %x REG_NB_EVENT= %x\n",get_reg_bar2(REG_TRIG_FREE_RESET,0) , get_reg_bar2( REG_NB_WORD_IN_EVENT,0) , get_reg_bar2(REG_NB_EVENT,0));
  cc=getchar();
  return;
}

//--------------------------------------------------------------------------------------------------------------------
void set_dma_word(){
  unsigned val=0x10,i=0;
  while(i!=1) {
    printf("set nb WORDS by event val (hex)\n");
    read_line(linebis, BUFFER_LENGTH, stdin);
    i=sscanf(linebis,"%x",&val);
  }
 if ( val < 2 ) {
     printf( " not permit should be > 2 \n");
    sleep (1);
    return;
  }
 set_reg_bar2( REG_NB_WORD_IN_EVENT,0,(val&0xFF));	  
  return;
}

//--------------------------------------------------------------------------------------------------------------------
void set_nb_event(){
  unsigned val=0,i=0;
  while(i!=1) {
    printf("set nb of events   val (hex) 0 infinit loop else if < at loop*128 => Timeout !! \n");
    read_line(linebis, BUFFER_LENGTH, stdin);
    i=sscanf(linebis,"%x",&val);
  }

  set_reg_bar2(REG_NB_EVENT,0,(val&0xFFFF));
  return;
}
//--------------------------------------------------------------------------------------------------------------------
void enable_free(){
  unsigned chip,val,i=0;
  printf("Enable Free \n");
  val= get_reg_bar2(REG_TRIG_FREE_RESET,0);
#ifdef OLD
  set_reg_bar2(REG_TRIG_FREE_RESET,0,((val | ( 1<< 10))));
#else
 set_reg_bar2(REG_TRIG_FREE_RESET,0,((val | ( 1<< 8))));
#endif
  return;
}
//--------------------------------------------------------------------------------------------------------------------
void disable_free(){
  unsigned chip,val,i=0;
  printf("Disable free \n");
  val= get_reg_bar2(REG_TRIG_FREE_RESET,0);
#ifdef OLD
  set_reg_bar2(REG_TRIG_FREE_RESET,0,((val &(0xFFFFFBFF))));
#else
 set_reg_bar2(REG_TRIG_FREE_RESET,0,((val &(0xFFFFFEFF))));
#endif
  return;
}
//--------------------------------------------------------------------------------------------------------------------
void enable_test_data(){
  unsigned chip,val,i=0;
  printf("Enable Test Data \n");
  val= get_reg_bar2(REG_TRIG_FREE_RESET,0);
#ifdef OLD
#else
  set_reg_bar2(REG_TRIG_FREE_RESET,0,((val | ( 1<< 10))));
#endif
  return;
}
//--------------------------------------------------------------------------------------------------------------------
void disable_test_data(){
  unsigned chip,val,i=0;
  printf("Disable Test Data \n");
  val= get_reg_bar2(REG_TRIG_FREE_RESET,0);
#ifdef OLD
#else
  set_reg_bar2(REG_TRIG_FREE_RESET,0,((val &(0xFFFFFBFF))));
#endif
  return;
}
//--------------------------------------------------------------------------------------------------------------------
void data_from_fiber(){
  unsigned val,i=0;
  printf("Data From fiber  \n");
  val= get_reg_bar2(REG_SELECT_DATA_INPUT,0);
#ifdef OLD
#else
  set_reg_bar2( REG_SELECT_DATA_INPUT,0,((val | ( 1<< 9))));  // bit 9
#endif
  return;
}
//--------------------------------------------------------------------------------------------------------------------
void data_from_generator(){
  unsigned val,i=0;
  printf("Diata from generator \n");
  val= get_reg_bar2( REG_SELECT_DATA_INPUT,0);
#ifdef OLD
#else
  set_reg_bar2( REG_SELECT_DATA_INPUT,0,((val &(0xFFFFFDFF)))); // bit 9
#endif
  return;
}


//--------------------------------------------------------------------------------------------------------------------
double set_trigger_frequency(){
  unsigned freq,val,i=0;
  double frequenc;
  printf("Set Frequency (0 - 255 max) \n");
  read_line(linebis, BUFFER_LENGTH, stdin);
  i=sscanf(linebis,"%x",&freq);
  val= get_reg_bar2(REG_TRIG_FREE_RESET,0);
#ifdef OLD
  set_reg_bar2(REG_TRIG_FREE_RESET,0,( (val & 0xFFF00FFF)| ( (freq&0xFF) <<12)) );
#else
  set_reg_bar2(REG_TRIG_FREE_RESET,0,( (val & 0xFFFFFF00)| ( freq&0xFF)) );
#endif
  frequenc=125000000.0/ (12* freq);
  printf(" Frequency %f KHz\n",frequenc);
  return (frequenc);
}
//--------------------------------------------------------------------------------------------------------------------
void dump_fifo_latency(){
  unsigned nb_word,i,value=0;
  FILE *file;

  nb_word=  get_reg_bar0(0x1820,0);

  file= fopen("./DumpFifo.txt","w");
  if (file == NULL) {
    printf( " file not open %s ", file);
    return;
  }
  for ( i=0 ; i< nb_word ; i++)
    {
      value =  get_reg_bar0(0x1800,0);
      fprintf(file, "%d ",value);

    }
  fclose(file);
  return;
}
//--------------------------------------------------------------------------------------------------------------------
int trigger(unsigned type,unsigned rate,unsigned triggers) {

  char *buff= (char *) malloc(300);
  char  crate[7];
  char ctrig[15];
  char ctype[15];
  
  
  sprintf(crate,"%d ",rate);
  sprintf(ctrig,"%d ",triggers);
  switch (type)  {
  case 0:
    strcpy(ctype,"pulse");
    break;
  case 1:
    strcpy(ctype,"poisson");
    break;
  case 2:
    strcpy(ctype,"random");
    break;
  default:
    printf("wrong type; set to pulse\n");
    strcpy(ctype,"pulse");
    break;
  }
  strcpy(buff, "echo trigft -60 ");
  strcat(buff, ctype);
  strcat(buff,crate);
  strcat(buff,ctrig);
  strcat(buff,  " | nc 192.168.1.12 4201");
  printf("mamy: %s\n",buff);
  system(buff);
  return 0 ;
}