ngcbDrv.h

Go to the documentation of this file.

#ifndef ngcbDrv_h
#define ngcbDrv_h
 
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
#include <ngc/core/ngcbAddr.h>
#include <ngc/core/ngcbSched.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef USE
#define USE(x) do {(void)(x);} while (0)
#endif

#ifndef str2str
static __inline__ char *__str2str(char *s1, const char *s2, size_t n) 
{
  size_t size = strlen(s2);
  if (n > size) n = size;
  memcpy(s1, s2, n);
  s1[n] = '\0'; 
  return (s1);
}
#define str2str(s1, s2, n) __str2str(s1, s2, n)
#endif

#define ngcbCOM_DEFAULT_DEVICE "/dev/ngc0_com"

#define ngcbDMA_DEFAULT_DEVICE "/dev/ngc0_dma"

#define ngcbCOM_DEFAULT_TIMEOUT 5

#define ngcbCOM_FIFO_SIZE 128
/*#define ngcbCOM_FIFO_SIZE ngcbIFC_FIFO_SIZE*/
 
/*
 * DMA run-queue error flags
 */
#define ngcbDMA_ERR_FIFO_OVERFLOW 0x1 
#define ngcbDMA_ERR_IPP_OVERRUN   0x2 

typedef struct {
  int fd;                    
  void *mapArea;             
  size_t mapSize;            
  int running;               
  unsigned int cnt;          
  int timer;                 
  int tmo;                   
  int chanSelect;            
  int cpu;                   
  unsigned int ippMode;      
  unsigned int payloadSize;  
  unsigned int unitSize;     
  unsigned int syncMode;     
  unsigned int joinerDelay;  
  unsigned int resync;       
  unsigned int dropped;      
  int stay;                  
  int reserved1;             
  int reserved2;               
  int reserved3;               
  void *appData;                
} ngcb_dma_p_t;

#define ngcbPRI_DMA_BURST 20
 
/*
 * DMA interface API function-type definitions
 */

typedef int (*ngcbDMA_ALLOC)(ngcb_dma_p_t *dma, unsigned char **buffer, 
                 int num, size_t size, char *erms);

typedef void (*ngcbDMA_FREE)(ngcb_dma_p_t *dma, unsigned char **buffer, 
                 int num);

typedef int (*ngcbDMA_OPEN)(const char *devName, ngcb_dma_p_t *dma, 
                char *erms);

typedef int (*ngcbDMA_CLOSE)(ngcb_dma_p_t *dma, char *erms);

typedef int (*ngcbDMA_INIT)(ngcb_dma_p_t *dma, unsigned char **buffer, 
                int num, size_t size, 
                unsigned int *doneCount, char *erms);

typedef int (*ngcbDMA_STOP)(ngcb_dma_p_t *dma, char *erms);

typedef int (*ngcbDMA_CLR)(ngcb_dma_p_t *dma, char *erms);

typedef int (*ngcbDMA_GETCNT)(ngcb_dma_p_t *dma, unsigned int *cnt,
                  char *erms);

typedef int (*ngcbDMA_WAIT)(ngcb_dma_p_t *dma, uint64_t *ts, char *erms);

typedef int (*ngcbDMA_STAT)(ngcb_dma_p_t *dma, size_t *byteCount, char *erms);

typedef int (*ngcbDMA_OVERFLOW)(ngcb_dma_p_t *dma, char *erms);

typedef int (*ngcbDMA_IPP)(ngcb_dma_p_t *dma, int id, int *param, 
               unsigned int n, char *erms);

typedef int (*ngcbDMA_DEVRD)(ngcb_dma_p_t *dma, unsigned int addr, 
                 unsigned int *value, char *erms);

typedef int (*ngcbDMA_DEVWR)(ngcb_dma_p_t *dma, unsigned int addr, 
                 unsigned int value, char *erms);

typedef struct {
  ngcbDMA_ALLOC Alloc;       
  ngcbDMA_FREE Free;         
  ngcbDMA_OPEN Open;         
  ngcbDMA_CLOSE Close;       
  ngcbDMA_INIT Init;         
  ngcbDMA_STOP Stop;         
  ngcbDMA_CLR Clr;           
  ngcbDMA_GETCNT GetCnt;     
  ngcbDMA_WAIT Wait;         
  ngcbDMA_STAT Stat;         
  ngcbDMA_OVERFLOW Overflow; 
  ngcbDMA_IPP IppCfg;        
  ngcbDMA_DEVRD DevRd;       
  ngcbDMA_DEVWR DevWr;       
  ngcb_dma_p_t *param;       
  int deviceOpen;            
} ngcb_dma_api;

typedef int (*ngcb_dma_select)(const char *devName, ngcb_dma_api *api);

extern ngcb_dma_select ngcbDmaApiSelect;

typedef struct {
  unsigned int offset; 
  int flags;           
  int fifo;            
  unsigned int period; 
  int fd;              
  FILE *sim;           
} ngcb_mod_t;

typedef struct {
  ngcb_dma_api api;    
  ngcb_dma_p_t param;  
} ngcb_dma_t;

typedef struct {
  unsigned char *buffer;     
  size_t size;                                 
  ngcb_dma_t dma;                   
  unsigned char **dmaBuffer;  
  size_t dmaSize;                        
  int dmaNumBuf;                   
  int dmaStarted;                      
  int tmo;                             
  unsigned int doneCount;        
  char erms[256];                 
  ngcb_thread_t threadId;          
  int threadCreated;            
  ngcb_sema_t semStart;          
  ngcb_sema_t semSync;           
  ngcb_sema_t semStat;           
  ngcb_sema_t semWdStart;    
  ngcb_sema_t semWdSync;          
  int watchdog;                 
  ngcb_thread_t wdThreadId;   
  int wdfd[2];                  
  int timeout;               
} ngcb_burst_t;

extern ngcb_dma_api ngcbDma0;

extern ngcb_dma_api ngcbDmaPci;

extern ngcb_dma_api ngcbAcqTcp;

extern ngcb_dma_api ngcbAcqUdp;

extern ngcb_dma_api ngcbDmaRtSim;
 
/*
 * Communication line prototypes
 */

int ngcbComOpen(const char *name, char *erms);

int ngcbComClose(int fd);

int ngcbComGetRev(int fd);

int ngcbComRstDev(int fd);

int ngcbComReset(int fd);

int ngcbComTimeout(int fd, int seconds);

int ngcbComUpLink(int fd, int routeThrough, int rst);

int ngcbComRead(int fd, char *buffer, int size, char *erms);

int ngcbComWrite(int fd, const char *buffer, int size, char *erms);

int ngcbComReadStatus(int fd);

int ngcbComErrStatus(void);

void ngcbComErrStr(int status, char *s);

void ngcbComStatStr(int status, char *s);

void ngcbModInit(ngcb_mod_t *m);

int ngcbModOpen(const char *path, ngcb_mod_t *m, char *erms);

int ngcbModClose(ngcb_mod_t *m, char *erms);

int ngcbModTimeout(ngcb_mod_t *m, int seconds, char *erms);

int ngcbModFifo(ngcb_mod_t *m, int size, char *erms);

int ngcbModRead(ngcb_mod_t *m, int addr, int *buffer, int size, 
        char *erms);

int ngcbModWrite(ngcb_mod_t *m, int addr, const int *buffer, int size,
         char *erms);

int ngcbModWait(ngcb_mod_t *m, int addr, int mask, int timeout, char *erms);
 
/*
 * DMA interface prototypes
 */

int ngcbDmaOpen(const char *devName, ngcb_dma_t *dma, char *erms);

int ngcbDmaClose(ngcb_dma_t *dma, char *erms);

int ngcbDmaAlloc(ngcb_dma_t dma, unsigned char **buffer, int num, 
         size_t size, char *erms);

void ngcbDmaFree(ngcb_dma_t dma, unsigned char **buffer, int num);

int ngcbDmaInit(ngcb_dma_t *dma, unsigned char **buffer, int num, 
        size_t size, unsigned int *doneCount, char *erms);

int ngcbDmaStop(ngcb_dma_t dma, char *erms);

int ngcbDmaClr(ngcb_dma_t dma, char *erms);

int ngcbDmaGetCnt(ngcb_dma_t dma, unsigned int *cnt, char *erms);

int ngcbDmaWait(ngcb_dma_t dma, char *erms);

int ngcbDmaWait2(ngcb_dma_t dma, uint64_t *ts, char *erms);

int ngcbDmaWaitTmo(ngcb_dma_t dma, int timeout, char *erms);

int ngcbDmaWaitTmo2(ngcb_dma_t dma, uint64_t *ts, int timeout, char *erms);

int ngcbDmaStat(ngcb_dma_t dma, size_t *byteCount, char *erms);

int ngcbDmaOverflow(ngcb_dma_t dma, char *erms);

int ngcbDmaIppCfg(ngcb_dma_t dma, int id, int *param, unsigned int n, 
          char *erms);

int ngcbDmaDevRd(ngcb_dma_t dma, unsigned int addr, unsigned int *value,
         char *erms);

int ngcbDmaDevWr(ngcb_dma_t dma, unsigned int addr, unsigned int value,
         char *erms);
 
/*
 *  DMA interface template API
 */

int ngcbDma0Open(const char *devName, ngcb_dma_p_t *dma, char *erms);

int ngcbDma0Close(ngcb_dma_p_t *dma, char *erms);

int ngcbDma0Alloc(ngcb_dma_p_t *dma, unsigned char **buffer, int num, 
          size_t size, char *erms);

void ngcbDma0Free(ngcb_dma_p_t *dma, unsigned char **buffer, int num);

int ngcbDma0Clr(ngcb_dma_p_t *dma, char *erms);

int ngcbDma0Init(ngcb_dma_p_t *dma, unsigned char **buffer, int num, 
         size_t size, unsigned int *doneCount, char *erms);

int ngcbDma0Stop(ngcb_dma_p_t *dma, char *erms);

int ngcbDma0GetCnt(ngcb_dma_p_t *dma, unsigned int *cnt, char *erms);

int ngcbDma0Wait(ngcb_dma_p_t *dma, uint64_t *ts, char *erms);

int ngcbDma0Stat(ngcb_dma_p_t *dma, size_t *byteCount, char *erms);

int ngcbDma0Overflow(ngcb_dma_p_t *dma, char *erms);

int ngcbDma0IppCfg(ngcb_dma_p_t *dma, int id, int *param, unsigned int n, 
           char *erms);

int ngcbDma0DevRd(ngcb_dma_p_t *dma, unsigned int addr, unsigned int *value,
          char *erms);

int ngcbDma0DevWr(ngcb_dma_p_t *dma, unsigned int addr, unsigned int value,
          char *erms);

int ngcbDmaBurstInit(ngcb_burst_t *burst, char *erms);

void ngcbDmaBurstRelease(ngcb_burst_t *burst);

int ngcbDmaBurstOpen(const char *devName, ngcb_burst_t *burst, char *erms);

int ngcbDmaBurstClose(ngcb_burst_t *burst, char *erms);

int ngcbDmaBurstAlloc(ngcb_burst_t *burst, size_t size, size_t dmaSize, 
              int numBuf, char *erms);

void ngcbDmaBurstFree(ngcb_burst_t *burst);

int ngcbDmaBurstStart(ngcb_burst_t *burst, char *erms);

int ngcbDmaBurstStop(ngcb_burst_t *burst, char *erms);

int ngcbDmaBurstWait(ngcb_burst_t *burst, char *erms);
 
#ifdef __cplusplus
}
#endif
 
#endif