-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/agent.c,v 6.10 2002-11-09 10:03:18 hadaq Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/agent.c,v 6.11 2003-03-02 15:50:08 hadaq Exp $";
#define _GNU_SOURCE
#include <unistd.h>
return &retVal;
}
-int * rpcworker_start_1_svc(RpcWorker_startArgs *dummy, struct svc_req *x)
+int *rpcworker_start_1_svc(RpcWorker_startArgs * dummy, struct svc_req *x)
{
return rpcworker_start_1(dummy, NULL);
}
return &retVal;
}
-char ** rpcworker_status_1_svc(int *dummy, struct svc_req *x)
+char **rpcworker_status_1_svc(int *dummy, struct svc_req *x)
{
return rpcworker_status_1(dummy, NULL);
}
return &retVal;
}
-int * rpcworker_stop_1_svc(int *dummy, struct svc_req *x)
+int *rpcworker_stop_1_svc(int *dummy, struct svc_req *x)
{
return rpcworker_stop_1(dummy, NULL);
}
return &retVal;
}
-void * rpcsystem_1_svc(char **dummy, struct svc_req *x)
+void *rpcsystem_1_svc(char **dummy, struct svc_req *x)
{
return rpcsystem_1(dummy, NULL);
}
return &retVal;
}
-int * rpcjoin_1_svc(int *dummy, struct svc_req *x)
+int *rpcjoin_1_svc(int *dummy, struct svc_req *x)
{
return rpcjoin_1(dummy, NULL);
}
+
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <syslog.h>
#include <unistd.h>
-
+
/* For st */
#include <sys/ioctl.h>
#include <sys/mtio.h>
#include "ansiTape.h"
#include "ansiTapeLabel.h"
-AnsiTape *openAnsiTape(const char* filename, const char *dev) {
+AnsiTape *openAnsiTape(const char *filename, const char *dev)
+{
#if defined(MTIOCTOP)
int tape;
int fileSeqNum = 0;
syslog(LOG_ERR, "Could not allocate memory for ansiTape.");
return NULL;
}
-
tape = open(dev, O_RDWR);
- if(tape == -1) {
+ if (tape == -1) {
syslog(LOG_ERR, "Could not open tape.");
return NULL;
}
-
#if defined(MTEOM)
mtoper->mt_op = MTEOM;
#elif defined(MTSEOD)
syslog(LOG_ERR, "Could not go to the eom of the tape.");
return NULL;
}
-
mtoper->mt_op = MTBSF;
/* BUGBUG this varies from tape to tape. *
* Old DLT III drives seem to work with 2, *
syslog(LOG_ERR, "Could not rewind tape.");
return NULL;
}
-
isNewTape = readVolumeLabel(tape, vol);
stat = ioctl(tape, MTIOCTOP, mtoper);
syslog(LOG_ERR, "Could not rewind tape.");
return NULL;
}
-
if (isNewTape == 0) {
writeVolumeLabel(tape, vol);
} else {
syslog(LOG_ERR, "Could not write filemark.");
return NULL;
}
-
thisAnsiTape->fd = tape;
thisAnsiTape->bytesWritten = 0;
{
#if defined(MTIOCTOP)
int retVal = 0;
- while(size >= BLOCKSIZE - openTape->bufferFull) {
+ while (size >= BLOCKSIZE - openTape->bufferFull) {
if (openTape->bufferFull < BLOCKSIZE) {
memcpy(openTape->buf + openTape->bufferFull, src, BLOCKSIZE - openTape->bufferFull);
src += (BLOCKSIZE - openTape->bufferFull);
}
/* BUGBUG the last write may have less than BLOCKSIZE bytes */
-int closeAnsiTape(AnsiTape *openTape) {
+int closeAnsiTape(AnsiTape *openTape)
+{
#if defined(MTIOCTOP)
int stat;
struct mtop mtoperS, *mtoper = &mtoperS;
- if(openTape->bufferFull != 0) {
+ if (openTape->bufferFull != 0) {
write(openTape->fd, openTape->buf, openTape->bufferFull);
}
-
mtoper->mt_op = MTWEOF;
mtoper->mt_count = 1;
stat = ioctl(openTape->fd, MTIOCTOP, mtoper);
syslog(LOG_ERR, "Could not write filemark.");
return -1;
}
-
writeTrailer(openTape->fd, openTape->fileSeqNum, openTape->bytesWritten, openTape->filename);
stat = close(openTape->fd);
if (stat == -1) {
syslog(LOG_ERR, "Could not close file on tape.");
return -1;
- free(openTape);
+ free(openTape);
}
-
return 0;
#else
return -1;
#endif
}
-
+
#ifndef ANSITAPE_H
#define ANSITAPE_H
const char *filename;
int fileSeqNum;
-} AnsiTape;
+}
+
+AnsiTape;
AnsiTape *openAnsiTape(const char *, const char *);
int closeAnsiTape(AnsiTape *);
#endif
-
+
#include <ctype.h>
#include "ansiTapeChar.h"
-char *ansichar(char *s, int length) {
+char *ansichar(char *s, int length)
+{
int i, end = 0;
- for(i=0 ; i<length ; i++) {
+ for (i = 0; i < length; i++) {
if (end == 0) {
- if(isupper(s[i]) || isdigit(s[i])) {
- } else if(islower(s[i])) {
+ if (isupper(s[i]) || isdigit(s[i])) {
+ } else if (islower(s[i])) {
s[i] = toupper(s[i]);
} else {
switch (s[i]) {
- case (' '):
- case ('!'):
- case ('"'):
- case ('%'):
- case ('&'):
- case ('\''):
- case ('('):
- case (')'):
- case ('*'):
- case ('+'):
- case (','):
- case ('-'):
- case ('_'):
- case ('.'):
- case ('/'):
- case (':'):
- case (';'):
- case ('<'):
- case ('='):
- case ('>'):
- case ('?'):
- break;
- case ('\0'):
- s[i] = ' ';
- end = 1;
- break;
- default:
- s[i] = 'Z';
- break;
+ case (' '):
+ case ('!'):
+ case ('"'):
+ case ('%'):
+ case ('&'):
+ case ('\''):
+ case ('('):
+ case (')'):
+ case ('*'):
+ case ('+'):
+ case (','):
+ case ('-'):
+ case ('_'):
+ case ('.'):
+ case ('/'):
+ case (':'):
+ case (';'):
+ case ('<'):
+ case ('='):
+ case ('>'):
+ case ('?'):
+ break;
+ case ('\0'):
+ s[i] = ' ';
+ end = 1;
+ break;
+ default:
+ s[i] = 'Z';
+ break;
}
}
} else {
return s;
}
-char *unixchar(char *s, int length) {
+char *unixchar(char *s, int length)
+{
int i;
int end = 0;
- for(i=0 ; i<length ; i++) {
+ for (i = 0; i < length; i++) {
if (end == 0) {
- if(s[i] == '\0') {
+ if (s[i] == '\0') {
s[i] = ' ';
end = 1;
}
return s;
}
-
+
#ifndef ANSITAPECHAR_H
#define ANSITAPECHAR_H
char *unixchar(char *, int);
#endif
-
+
#define _XOPEN_SOURCE
#define _XOPEN_SOURCE_EXTENDED
#include <unistd.h>
/* Functions concerning the volume label */
-int readVolumeLabel(int tape, char *vol) {
+int readVolumeLabel(int tape, char *vol)
+{
int stat;
stat = read(tape, vol, LABELSIZE);
- if(stat != LABELSIZE) {
+ if (stat != LABELSIZE) {
return -1;
}
-
return 0;
}
-int writeVolumeLabel(int tape, const char *vol) {
+int writeVolumeLabel(int tape, const char *vol)
+{
int stat;
stat = write(tape, vol, LABELSIZE);
- if(stat != LABELSIZE) {
+ if (stat != LABELSIZE) {
syslog(LOG_ERR, "Could not write volume label to tape.");
return -1;
}
-
return 0;
}
-int writeNewVolumeLabel(int tape, const char *volId, const char *ownerId) {
+int writeNewVolumeLabel(int tape, const char *volId, const char *ownerId)
+{
int stat;
char vol[LABELSIZE];
char oid[15];
syslog(LOG_ERR, "Volume label not %d char.", LABELSIZE);
return -1;
}
-
stat = write(tape, vol, LABELSIZE);
- if(stat != LABELSIZE) {
+ if (stat != LABELSIZE) {
syslog(LOG_ERR, "Could not write volume label to tape.");
return -1;
}
-
return 0;
}
/* Functions concerning the hdr-label and the eof-label */
-static int writeLabel(int tape, const char *hdreof, int fileSeqNum, int bytes, const char *filename) {
+static int writeLabel(int tape, const char *hdreof, int fileSeqNum, int bytes, const char *filename)
+{
int stat;
int i;
int blockSize = BLOCKSIZE;
tim = time(0);
cd = gmtime(&tim);
- if ((cd->tm_year)/100 == 19) {
+ if ((cd->tm_year) / 100 == 19) {
creaCent = " ";
} else {
creaCent = "0";
strcpy(fn, filename);
if (LABELSIZE != sprintf(label, "%-3s%1d%-17s%06d%04d%04d%04d%02d%1s%02d%03d%6d%1s%06d%-13s%-7s",
- hdreof,
- 1,
- ansichar(fn, 17),
- 1,
- 1,
- fileSeqNum,
- 1,
- 0,
- creaCent, (cd->tm_year)%100, cd->tm_yday,
- 99366,
- " ",
- (bytes + BLOCKSIZE - 1) / BLOCKSIZE,
- impId,
- "")
- ) {
+ hdreof,
+ 1,
+ ansichar(fn, 17),
+ 1,
+ 1,
+ fileSeqNum,
+ 1,
+ 0,
+ creaCent, (cd->tm_year) % 100, cd->tm_yday,
+ 99366,
+ " ",
+ (bytes + BLOCKSIZE - 1) / BLOCKSIZE,
+ impId,
+ "")
+ ) {
syslog(LOG_ERR, "Label 1 not %d char.", LABELSIZE);
return -1;
}
-
stat = write(tape, label, LABELSIZE);
- if(stat != LABELSIZE) {
+ if (stat != LABELSIZE) {
syslog(LOG_ERR, "Could not write ANSI label 1 on tape.");
return -1;
}
-
if (LABELSIZE != sprintf(label, "%-3s%1d%1s%05d%05d%-21s%1s%010d%-3s%02d%28s",
- hdreof,
- 2,
- "F",
- blockSize,
- blockSize,
- "",
- "M",
- bytes,
- "",
- 0,
- "")
- ) {
+ hdreof,
+ 2,
+ "F",
+ blockSize,
+ blockSize,
+ "",
+ "M",
+ bytes,
+ "",
+ 0,
+ "")
+ ) {
syslog(LOG_ERR, "Label 2 not %d char.", LABELSIZE);
return -1;
}
stat = write(tape, label, LABELSIZE);
- if(stat != LABELSIZE) {
+ if (stat != LABELSIZE) {
syslog(LOG_ERR, "Could not write ANSI label 2 on tape.");
return -1;
}
-
uid = getuid();
while (NULL != (pwentry = getpwent()) && pwentry->pw_uid != uid) {
}
gethostname(hostname, 20);
if (LABELSIZE != sprintf(label, "%-3s%1d%010d%-10s%-20s%-36s",
- hdreof,
- 3,
- tim,
- user,
- hostname,
- filename)
- ) {
+ hdreof,
+ 3,
+ tim,
+ user,
+ hostname,
+ filename)
+ ) {
syslog(LOG_ERR, "Label 3 not %d char.", LABELSIZE);
return -1;
}
-
stat = write(tape, label, LABELSIZE);
- if(stat != LABELSIZE) {
+ if (stat != LABELSIZE) {
syslog(LOG_ERR, "Could not write ANSI label 3 on tape.");
return -1;
}
return 0;
}
-int writeHeader(int tape, int fileSeqNum, const char *filename) {
+int writeHeader(int tape, int fileSeqNum, const char *filename)
+{
return writeLabel(tape, "HDR", fileSeqNum, 0, filename);
}
-int writeTrailer(int tape, int fileSeqNum, unsigned long numBytes, const char *filename) {
+int writeTrailer(int tape, int fileSeqNum, unsigned long numBytes, const char *filename)
+{
return writeLabel(tape, "EOF", fileSeqNum, numBytes, filename);
}
-
+
#ifndef ANSITAPELABEL_H
#define ANSITAPELABEL_H
int writeTrailer(int, int, unsigned long, const char *);
#endif
-
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/ctrlctu.c,v 6.13 2003-02-21 18:58:44 sailer Exp $";
+
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/ctrlctu.c,v 6.14 2003-03-02 15:50:09 hadaq Exp $";
#define _XOPEN_SOURCE
#define _POSIX_C_SOURCE 199506L
unsigned long value;
int oper;
unsigned long *ctuEnabled;
- struct timespec t1 = {1, 0};
- struct timespec t3 = {3, 0};
+ struct timespec t1 =
+ {1, 0};
+ struct timespec t3 =
+ {3, 0};
- openlog(argv[0], LOG_PID|LOG_PERROR, LOG_LOCAL0);
+ openlog(argv[0], LOG_PID | LOG_PERROR, LOG_LOCAL0);
setlogmask(LOG_UPTO(LOG_INFO));
isStandalone = 1;
break;
case 'v':
for (i = 0; prioritynames[i].c_name != NULL
- && 0 != strcmp(prioritynames[i].c_name, optarg); i++) {
+ && 0 != strcmp(prioritynames[i].c_name, optarg); i++) {
}
if (prioritynames[i].c_name == NULL) {
usage(argv[0]);
+
#ifndef CTU_H
#define CTU_H
#define MAGIC 0x3c
typedef struct CtuS {
- volatile uint8_t *base;
- uint16_t internalTrigNr;
-} Ctu;
+ volatile uint8_t *base;
+ uint16_t internalTrigNr;
+}
+
+Ctu;
static uint8_t Ctu_rdStatus(Ctu * my)
{
- return *(my->base + STATUS1);
+ return *(my->base + STATUS1);
}
static uint8_t Ctu_rdDeadtime(Ctu * my)
{
- return *(my->base + DEAD1);
+ return *(my->base + DEAD1);
}
static void Ctu_wrDelay(Ctu * my, uint8_t delay)
static uint8_t Ctu_magicIsOk(Ctu * my)
{
- return *(my->base + MAGIC) == 0x51;
+ return *(my->base + MAGIC) == 0x51;
}
-static void Ctu_clear(Ctu *my)
+static void Ctu_clear(Ctu * my)
{
*(my->base + STATUS1) |= 0x01;
*(my->base + STATUS1) &= ~0x01;
*(my->base + STATUS2) &= ~0x01;
}
-static void Ctu_inhibit(Ctu *my, int v)
+static void Ctu_inhibit(Ctu * my, int v)
{
- if (v) {
+ if (v) {
*(my->base + STATUS1) |= 0x02;
*(my->base + STATUS2) |= 0x02;
} else {
}
}
-static void Ctu_maskBusy(Ctu *my, int v)
+static void Ctu_maskBusy(Ctu * my, int v)
{
- if (v) {
+ if (v) {
*(my->base + STATUS1) |= 0x40;
} else {
*(my->base + STATUS1) &= ~0x40;
}
}
-static void Ctu_maskTrig(Ctu *my, int v)
+static void Ctu_maskTrig(Ctu * my, int v)
{
- if (v) {
+ if (v) {
*(my->base + STATUS1) |= 0x08;
} else {
*(my->base + STATUS1) &= ~0x08;
}
}
-static void Ctu_lockBusy(Ctu *my, int v)
+static void Ctu_lockBusy(Ctu * my, int v)
{
- if (v) {
+ if (v) {
*(my->base + STATUS1) |= 0x01;
} else {
*(my->base + STATUS1) &= ~0x01;
}
}
-static void Ctu_softBusy(Ctu *my, int v)
+static void Ctu_softBusy(Ctu * my, int v)
{
- if (v) {
+ if (v) {
*(my->base + STATUS1) |= 0x20;
} else {
*(my->base + STATUS1) &= ~0x20;
}
}
-static int Ctu_isBusy(Ctu *my)
+static int Ctu_isBusy(Ctu * my)
{
- return (*(my->base + STATUS1) & 0x40) != 0;
+ return (*(my->base + STATUS1) & 0x40) != 0;
}
-static int Ctu_isError(Ctu *my)
+static int Ctu_isError(Ctu * my)
{
- return (*(my->base + STATUS1) & 0x80) != 0;
+ return (*(my->base + STATUS1) & 0x80) != 0;
}
static void Ctu_wrDeadtime(Ctu * my, uint8_t time)
*(my->base + FIPO2) = 0;
}
-static void Ctu_softTrig(Ctu *my, uint8_t trigType) {
+static void Ctu_softTrig(Ctu * my, uint8_t trigType)
+{
struct timespec tS, *t = &tS;
t->tv_sec = 0;
t->tv_nsec = 1;
static char *Ctu_2charP(Ctu * my)
{
- static char s[7 * 80];
-
- sprintf(s,
- "base: 0x%08x\n"
- "status: 0x%02x\n"
- "deadtime: 0x%02x\n"
- "trigCode: 0x%01x\n"
- "trigTag: 0x%02x\n"
- "magicIsOk: %d\n",
- my->base,
- Ctu_rdStatus(my),
- Ctu_rdDeadtime(my),
- Ctu_rdTrigCode(my),
- Ctu_rdTrigTag(my),
- Ctu_magicIsOk(my)
- );
- return s;
+ static char s[7 * 80];
+
+ sprintf(s,
+ "base: 0x%08x\n"
+ "status: 0x%02x\n"
+ "deadtime: 0x%02x\n"
+ "trigCode: 0x%01x\n"
+ "trigTag: 0x%02x\n"
+ "magicIsOk: %d\n",
+ my->base,
+ Ctu_rdStatus(my),
+ Ctu_rdDeadtime(my),
+ Ctu_rdTrigCode(my),
+ Ctu_rdTrigTag(my),
+ Ctu_magicIsOk(my)
+ );
+ return s;
}
static int Ctu_invariant(Ctu * my)
{
- return 1;
+ return 1;
}
static int conCtu(Ctu * my, unsigned long cardBase)
{
- struct pdparam_master paramS, *param = ¶mS;
-unsigned char init_code1[] = {0, 1, 4, 4, 5, 5, 5, 5,
- 6, 6, 6, 6, 6, 6, 6, 6,
- 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2,
- 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3};
+ struct pdparam_master paramS, *param = ¶mS;
+ unsigned char init_code1[] =
+ {0, 1, 4, 4, 5, 5, 5, 5,
+ 6, 6, 6, 6, 6, 6, 6, 6,
+ 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2,
+ 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3};
int i;
- assert(my != NULL);
-
- param->iack = 1;
- param->rdpref = 0;
- param->wrpost = 0;
- param->swap = 2;
+ assert(my != NULL);
+ param->iack = 1;
+ param->rdpref = 0;
+ param->wrpost = 0;
+ param->swap = 2;
- if (
- (volatile uint8_t *)-1 == (my->base = (volatile uint8_t *)find_controller(
- cardBase, 0x10000UL, 0x09UL, 0x0000003cUL, 1UL, param
- ))
- ) {
- return -1;
- }
+ if (
+ (volatile uint8_t *) -1 == (my->base = (volatile uint8_t *) find_controller(
+ cardBase, 0x10000UL, 0x09UL, 0x0000003cUL, 1UL, param
+ ))
+ ) {
+ return -1;
+ }
*(my->base + STATUS1) = 0;
*(my->base + STATUS2) = 0;
- for(i=0; i<64; ++i)
- {
+ for (i = 0; i < 64; ++i) {
*(my->base + TAG1) = i;
*(my->base + CODE1) = init_code1[i];
}
*(my->base + TAG1) = 0;
- assert(Ctu_invariant(my));
+ assert(Ctu_invariant(my));
- return 0;
+ return 0;
}
static void desCtu(Ctu * my)
{
- assert(Ctu_invariant(my));
+ assert(Ctu_invariant(my));
- Ctu_inhibit(my, 0);
- return_controller((unsigned long)my->base, 0x10000UL);
+ Ctu_inhibit(my, 0);
+ return_controller((unsigned long) my->base, 0x10000UL);
}
#endif
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/evt.c,v 6.12 2002-11-22 21:54:37 hadaq Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/evt.c,v 6.13 2003-03-02 15:50:09 hadaq Exp $";
#define _ANSI_C_SOURCE
return my;
}
-void *Evt_fget(FILE * file)
+void *Evt_fget(FILE *file)
{
static char pool[EVT_MAXSIZE];
static void *evt = pool;
syslog(LOG_DEBUG, "%s:%d: %s", __FILE__, __LINE__, strerror(errno));
return NULL;
}
-
/* BUGBUG quickhack for a "Evt_paddedDataSize" */
if (Evt_paddedSize(evt) - Evt_hdrSize() != fread(Evt_data(evt), 1, Evt_paddedSize(evt) - Evt_hdrSize(), file)) {
syslog(LOG_ERR, "%s:%d: %s", __FILE__, __LINE__, strerror(errno));
+
#ifndef EVT_H
#define EVT_H
static const int evtBlockSize = 8 * 1024;
enum EvtId {
- EvtId_data = 1,
- EvtId_runStart = 0x00010002,
- EvtId_runStop = 0x00010003
+ EvtId_data = 1,
+ EvtId_runStart = 0x00010002,
+ EvtId_runStop = 0x00010003
};
enum EvtDecoding {
- EvtDecoding_default = 1,
- EvtDecoding_64bitAligned = (0x03 << 16) | 0x0001
+ EvtDecoding_default = 1,
+ EvtDecoding_64bitAligned = (0x03 << 16) | 0x0001
};
#define Evt_hdr HadTu_hdr
static uint32_t Evt_pureId(const void *my)
{
- return Evt_id(my) & 0x7fffffffUL;
+ return Evt_id(my) & 0x7fffffffUL;
}
static int Evt_dataError(const void *my)
{
- return (Evt_id(my) & 0x80000000UL) != 0;
+ return (Evt_id(my) & 0x80000000UL) != 0;
}
void Evt_setId(void *my, uint32_t id);
-static int Evt_setDataError(void *my) {
- Evt_setId(my, Evt_id(my) | 0x80000000UL);
+static int Evt_setDataError(void *my)
+{
+ Evt_setId(my, Evt_id(my) | 0x80000000UL);
}
-static int Evt_clrDataError(void *my) {
- Evt_setId(my, Evt_id(my) & ~0x80000000UL);
+static int Evt_clrDataError(void *my)
+{
+ Evt_setId(my, Evt_id(my) & ~0x80000000UL);
}
uint32_t Evt_seqNr(const void *my);
void *newEvt(uint32_t decoding, uint32_t id);
void deleteEvt(void *my);
-void *Evt_fget(FILE * file);
+void *Evt_fget(FILE *file);
void *Evt_appendSubEvt(void *my, void *subEvt);
#endif
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/evtbuild.c,v 6.59 2002-12-01 15:58:30 hadaq Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/evtbuild.c,v 6.60 2003-03-02 15:50:09 hadaq Exp $";
#define _POSIX_C_SOURCE 199309L
#include "genid32.h"
#define NEVTIDS 64UL /* must be 2^n */
-#define NEVTIDS_IN_FILE 0UL /* must be 2^n */
+#define NEVTIDS_IN_FILE 0UL /* must be 2^n */
static FILE *outFile;
static AnsiTape *outTape;
syslog(LOG_ERR, "Usage: [-a (agent)] [-p priority]");
}
-static void argsDump(TheArgs * my)
+static void argsDump(TheArgs *my)
{
int i;
syslog(LOG_DEBUG, "verbosity: %s", my->verbosity);
}
-static void argsDefault(TheArgs * my)
+static void argsDefault(TheArgs *my)
{
int i;
strcpy(my->verbosity, "info");
}
-static int argsFromCL(TheArgs * my, int argc, char *argv[])
+static int argsFromCL(TheArgs *my, int argc, char *argv[])
{
extern char *optarg;
int i;
return 0;
}
-static int argsFromParam(TheArgs * my, int argc, char *argv[])
+static int argsFromParam(TheArgs *my, int argc, char *argv[])
{
Param paramS, *param = ¶mS;
int paramWasFound;
Param_getInt(param, argv[0], "nrofmsgs", ¶mWasFound, &my->nrOfMsgs);
Param_getStringArray(param, argv[0], "slwctrlfile",
- PARAM_MAX_ARRAY_LEN, &my->slowCtrlFileCnt, my->slowCtrlFiles);
+ PARAM_MAX_ARRAY_LEN, &my->slowCtrlFileCnt, my->slowCtrlFiles);
Param_getString(param, argv[0], "outpath", ¶mWasFound, my->outPath);
Param_getString(param, argv[0], "outdev", ¶mWasFound, my->outDev);
Param_getString(param, argv[0], "expid", ¶mWasFound, my->expId);
return retVal;
}
-static void statsDump(TheArgs * theArgs, TheStats * my, int interval)
+static void statsDump(TheArgs *theArgs, TheStats *my, int interval)
{
static unsigned long lastEC;
static unsigned long lastEE;
}
-static void storeInfoStart(const char *n, time_t t, TheArgs * my)
+static void storeInfoStart(const char *n, time_t t, TheArgs *my)
{
Param pS, *p = &pS;
int i;
desParam(p);
}
-static int openFile(TheArgs *theArgs) {
+static int openFile(TheArgs *theArgs)
+{
char fileName[_POSIX_PATH_MAX];
static char outPath[_POSIX_PATH_MAX];
static once = 1;
return 0;
}
-static int writeFile(void *evt) {
+static int writeFile(void *evt)
+{
int writeFileR;
Evt_setSeqNr(evt, seqNr++);
return writeFileR;
}
-static int closeFile() {
+static int closeFile()
+{
int closeFileR;
if (outFile != NULL) {
syslog(LOG_ERR, "error opening output file, exiting");
exit(EXIT_FAILURE);
}
-
storeInfoStart(argv[0], ourTime, theArgs);
evt = newEvt(EvtDecoding_64bitAligned, EvtId_runStart);
writeFile(evt);
deleteEvt(evt);
}
-
evt = newEvt(EvtDecoding_64bitAligned, EvtId_data);
for (i = 0; i < theArgs->nrOfMsgs && !evtIsBroken; i += step) {
uint32_t trigNr;
Evt_setDataError(evt);
(*theStats->evtsTagError)++;
}
-
(*theStats->bytesWritten) += Evt_size(evt);
writeFile(evt);
Evt_online(evt);
+
/*
* gen_uuid.c --- generate a DCE-compatible uuid
*
* Copyright (C) 1996, 1997, 1998, 1999 Theodore Ts'o.
*
* %Begin-Header%
- * This file may be redistributed under the terms of the GNU
+ * This file may be redistributed under the terms of the GNU
* Library General Public License.
* %End-Header%
*/
/*
* uuid.h -- private header file for uuids
- *
+ *
* Copyright (C) 1996, 1997 Theodore Ts'o.
*
* %Begin-Header%
- * This file may be redistributed under the terms of the GNU
+ * This file may be redistributed under the terms of the GNU
* Library General Public License.
* %End-Header%
*/
#define TIME_OFFSET_LOW 0x13814000
struct uuid {
- uint32_t time_low;
- uint16_t time_mid;
- uint16_t time_hi_and_version;
- uint16_t clock_seq;
- uint8_t node[6];
+ uint32_t time_low;
+ uint16_t time_mid;
+ uint16_t time_hi_and_version;
+ uint16_t clock_seq;
+ uint8_t node[6];
};
static int get_random_fd(void)
{
- struct timeval tv;
- static int fd = -2;
- int i;
+ struct timeval tv;
+ static int fd = -2;
+ int i;
if (fd == -2) {
gettimeofday(&tv, 0);
while (nbytes > 0) {
i = read(fd, cp, nbytes);
if ((i < 0) &&
- ((errno == EINTR) || (errno == EAGAIN)))
+ ((errno == EINTR) || (errno == EAGAIN)))
continue;
if (i <= 0) {
if (lose_counter++ == 8)
lose_counter = 0;
}
}
-
/* XXX put something better here if no /dev/random! */
for (i = 0; i < nbytes; i++)
*cp++ = rand() & 0xFF;
static int get_node_id(unsigned char *node_id)
{
#ifdef HAVE_NET_IF_H
- int sd;
- struct ifreq ifr, *ifrp;
- struct ifconf ifc;
+ int sd;
+ struct ifreq ifr, *ifrp;
+ struct ifconf ifc;
char buf[1024];
- int n, i;
- unsigned char *a;
-
+ int n, i;
+ unsigned char *a;
+
/*
* BSD 4.4 defines the size of an ifreq to be
* max(sizeof(ifreq), sizeof(ifreq.ifr_name)+ifreq.ifr_addr.sa_len
- * However, under earlier systems, sa_len isn't present, so the size is
+ * However, under earlier systems, sa_len isn't present, so the size is
* just sizeof(struct ifreq)
*/
#ifdef HAVE_SA_LEN
sizeof((i).ifr_name)+(i).ifr_addr.sa_len)
#else
#define ifreq_size(i) sizeof(struct ifreq)
-#endif /* HAVE_SA_LEN*/
+#endif /* HAVE_SA_LEN*/
sd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
if (sd < 0) {
memset(buf, 0, sizeof(buf));
ifc.ifc_len = sizeof(buf);
ifc.ifc_buf = buf;
- if (ioctl (sd, SIOCGIFCONF, (char *)&ifc) < 0) {
+ if (ioctl(sd, SIOCGIFCONF, (char *) &ifc) < 0) {
close(sd);
return -1;
}
n = ifc.ifc_len;
- for (i = 0; i < n; i+= ifreq_size(*ifr) ) {
- ifrp = (struct ifreq *)((char *) ifc.ifc_buf+i);
+ for (i = 0; i < n; i += ifreq_size(*ifr)) {
+ ifrp = (struct ifreq *) ((char *) ifc.ifc_buf + i);
strncpy(ifr.ifr_name, ifrp->ifr_name, IFNAMSIZ);
#ifdef SIOCGIFHWADDR
if (ioctl(sd, SIOCGIFHWADDR, &ifr) < 0)
*/
close(sd);
return 0;
-#endif /* SIOCGENADDR */
-#endif /* SIOCGIFHWADDR */
+#endif /* SIOCGENADDR */
+#endif /* SIOCGIFHWADDR */
if (!a[0] && !a[1] && !a[2] && !a[3] && !a[4] && !a[5])
continue;
if (node_id) {
static int get_clock(uint32_t *clock_high, uint32_t *clock_low, uint16_t *ret_clock_seq)
{
- static int adjustment = 0;
- static struct timeval last = {0, 0};
- static uint16_t clock_seq;
- struct timeval tv;
- unsigned long long clock_reg;
-
-try_again:
+ static int adjustment = 0;
+ static struct timeval last =
+ {0, 0};
+ static uint16_t clock_seq;
+ struct timeval tv;
+ unsigned long long clock_reg;
+
+ try_again:
gettimeofday(&tv, 0);
if ((last.tv_sec == 0) && (last.tv_usec == 0)) {
get_random_bytes(&clock_seq, sizeof(clock_seq));
last.tv_sec--;
}
if ((tv.tv_sec < last.tv_sec) ||
- ((tv.tv_sec == last.tv_sec) &&
- (tv.tv_usec < last.tv_usec))) {
- clock_seq = (clock_seq+1) & 0x1FFF;
+ ((tv.tv_sec == last.tv_sec) &&
+ (tv.tv_usec < last.tv_usec))) {
+ clock_seq = (clock_seq + 1) & 0x1FFF;
adjustment = 0;
last = tv;
} else if ((tv.tv_sec == last.tv_sec) &&
- (tv.tv_usec == last.tv_usec)) {
+ (tv.tv_usec == last.tv_usec)) {
if (adjustment >= MAX_ADJUSTMENT)
goto try_again;
adjustment++;
adjustment = 0;
last = tv;
}
-
- clock_reg = tv.tv_usec*10 + adjustment;
- clock_reg += ((unsigned long long) tv.tv_sec)*10000000;
+
+ clock_reg = tv.tv_usec * 10 + adjustment;
+ clock_reg += ((unsigned long long) tv.tv_sec) * 10000000;
clock_reg += (((unsigned long long) 0x01B21DD2) << 32) + 0x13814000;
*clock_high = clock_reg >> 32;
static unsigned char node_id[6];
static int has_init = 0;
struct uuid uu;
- uint32_t clock_mid;
+ uint32_t clock_mid;
if (!has_init) {
if (get_node_id(node_id) <= 0) {
}
get_clock(&clock_mid, &uu.time_low, &uu.clock_seq);
uu.clock_seq |= 0x8000;
- uu.time_mid = (uint16_t) clock_mid;
+ uu.time_mid = (uint16_t) clock_mid;
uu.time_hi_and_version = (clock_mid >> 16) | 0x1000;
memcpy(uu.node, node_id, 6);
uuid_pack(&uu, out);
static void uuid_generate_random(uuid_t out)
{
- uuid_t buf;
+ uuid_t buf;
struct uuid uu;
get_random_bytes(buf, sizeof(buf));
/*
* Internal routine for packing UUID's
- *
+ *
* Copyright (C) 1996, 1997 Theodore Ts'o.
*
* %Begin-Header%
- * This file may be redistributed under the terms of the GNU
+ * This file may be redistributed under the terms of the GNU
* Library General Public License.
* %End-Header%
*/
static void uuid_pack(const struct uuid *uu, uuid_t ptr)
{
- uint32_t tmp;
- unsigned char *out = ptr;
+ uint32_t tmp;
+ unsigned char *out = ptr;
tmp = uu->time_low;
out[3] = (unsigned char) tmp;
out[1] = (unsigned char) tmp;
tmp >>= 8;
out[0] = (unsigned char) tmp;
-
+
tmp = uu->time_mid;
out[5] = (unsigned char) tmp;
tmp >>= 8;
tmp >>= 8;
out[8] = (unsigned char) tmp;
- memcpy(out+10, uu->node, 6);
+ memcpy(out + 10, uu->node, 6);
}
/*
* Internal routine for unpacking UUID
- *
+ *
* Copyright (C) 1996, 1997 Theodore Ts'o.
*
* %Begin-Header%
- * This file may be redistributed under the terms of the GNU
+ * This file may be redistributed under the terms of the GNU
* Library General Public License.
* %End-Header%
*/
static void uuid_unpack(const uuid_t in, struct uuid *uu)
{
- const uint8_t *ptr = in;
- uint32_t tmp;
+ const uint8_t *ptr = in;
+ uint32_t tmp;
tmp = *ptr++;
tmp = (tmp << 8) | *ptr++;
tmp = *ptr++;
tmp = (tmp << 8) | *ptr++;
uu->time_mid = tmp;
-
+
tmp = *ptr++;
tmp = (tmp << 8) | *ptr++;
uu->time_hi_and_version = tmp;
-uint32_t genId32(void) {
+uint32_t genId32(void)
+{
uuid_t uu;
uint32_t v;
uuid_generate(uu);
- v = ((uu[0]^uu[4]^uu[8]^uu[12])<<0)
- |((uu[1]^uu[5]^uu[9]^uu[13])<<8)
- |((uu[2]^uu[6]^uu[10]^uu[14])<<16)
- |((uu[3]^uu[7]^uu[11]^uu[15])<<24);
+ v = ((uu[0] ^ uu[4] ^ uu[8] ^ uu[12]) << 0)
+ | ((uu[1] ^ uu[5] ^ uu[9] ^ uu[13]) << 8)
+ | ((uu[2] ^ uu[6] ^ uu[10] ^ uu[14]) << 16)
+ | ((uu[3] ^ uu[7] ^ uu[11] ^ uu[15]) << 24);
return v & 0x7fffffff;
}
+
#ifndef GENID32_H
#define GENID32_H
+
#ifndef HADTU_H
#define HADTU_H
enum HadTu_Decoding {
- HadTu_queueDecoding = 3 << 16 | 99
+ HadTu_queueDecoding = 3 << 16 | 99
};
static uint32_t *HadTu_hdr(const void *my);
char *HadTu_2charP(const void *my);
enum HadTuIdx {
- HadTuIdx_size,
- HadTuIdx_decoding,
- HadTuIdx_data
+ HadTuIdx_size,
+ HadTuIdx_decoding,
+ HadTuIdx_data
};
static uint32_t *HadTu_hdr(const void *my)
{
- return (uint32_t *) my;
+ return (uint32_t *) my;
}
static size_t HadTu_hdrLen(void)
{
- return HadTuIdx_data;
+ return HadTuIdx_data;
}
static size_t HadTu_hdrSize(void)
{
- return HadTu_hdrLen() * sizeof(uint32_t);
+ return HadTu_hdrLen() * sizeof(uint32_t);
}
static int HadTu_isSwapped(const void *my)
{
- uint32_t *hdr = HadTu_hdr(my);
+ uint32_t *hdr = HadTu_hdr(my);
- return hdr[HadTuIdx_decoding] > 0xffffff;
+ return hdr[HadTuIdx_decoding] > 0xffffff;
}
static uint32_t HadTu_hdrValue(const void *my, unsigned idx)
{
- uint32_t *hdr = HadTu_hdr(my);
+ uint32_t *hdr = HadTu_hdr(my);
- if (HadTu_isSwapped(my)) {
- uint32_t tmp0;
- uint32_t tmp1;
+ if (HadTu_isSwapped(my)) {
+ uint32_t tmp0;
+ uint32_t tmp1;
- tmp0 = hdr[idx];
- ((char *) &tmp1)[0] = ((char *) &tmp0)[3];
- ((char *) &tmp1)[1] = ((char *) &tmp0)[2];
- ((char *) &tmp1)[2] = ((char *) &tmp0)[1];
- ((char *) &tmp1)[3] = ((char *) &tmp0)[0];
- return tmp1;
- } else {
- return hdr[idx];
- }
+ tmp0 = hdr[idx];
+ ((char *) &tmp1)[0] = ((char *) &tmp0)[3];
+ ((char *) &tmp1)[1] = ((char *) &tmp0)[2];
+ ((char *) &tmp1)[2] = ((char *) &tmp0)[1];
+ ((char *) &tmp1)[3] = ((char *) &tmp0)[0];
+ return tmp1;
+ } else {
+ return hdr[idx];
+ }
}
static void HadTu_setHdrValue(const void *my, unsigned idx, uint32_t value)
{
- uint32_t *hdr = HadTu_hdr(my);
+ uint32_t *hdr = HadTu_hdr(my);
- hdr[idx] = value;
+ hdr[idx] = value;
}
static uint32_t HadTu_decoding(const void *my)
{
- return HadTu_hdrValue(my, HadTuIdx_decoding);
+ return HadTu_hdrValue(my, HadTuIdx_decoding);
}
static void HadTu_setDecoding(void *my, uint32_t decoding)
{
- HadTu_setHdrValue(my, HadTuIdx_decoding, decoding);
+ HadTu_setHdrValue(my, HadTuIdx_decoding, decoding);
}
static unsigned HadTu_alignment(const void *my)
{
- return 1 << (HadTu_decoding(my) >> 16 & 0xff);
+ return 1 << (HadTu_decoding(my) >> 16 & 0xff);
}
static uint32_t HadTu_size(const void *my)
{
- return HadTu_hdrValue(my, HadTuIdx_size);
+ return HadTu_hdrValue(my, HadTuIdx_size);
}
static void HadTu_setSize(void *my, uint32_t size)
{
- HadTu_setHdrValue(my, HadTuIdx_size, size);
+ HadTu_setHdrValue(my, HadTuIdx_size, size);
}
static size_t HadTu_paddedSize(const void *my)
{
- uint32_t size;
- uint32_t alignment;
+ uint32_t size;
+ uint32_t alignment;
- size = HadTu_size(my);
- alignment = HadTu_alignment(my);
- return (size & (alignment - 1))
- ? (size & ~(alignment - 1)) + alignment : size;
+ size = HadTu_size(my);
+ alignment = HadTu_alignment(my);
+ return (size & (alignment - 1))
+ ? (size & ~(alignment - 1)) + alignment : size;
}
static void *HadTu_begin(const void *my)
{
- return (void *) my;
+ return (void *) my;
}
static void *HadTu_end(const void *my)
{
- return (void *) ((char *) my + HadTu_paddedSize(my));
+ return (void *) ((char *) my + HadTu_paddedSize(my));
}
static size_t HadTu_dataSize(const void *my)
{
- return HadTu_size(my) - HadTu_hdrSize();
+ return HadTu_size(my) - HadTu_hdrSize();
}
static void *HadTu_data(const void *my)
{
- return (void *) ((char *) my + HadTu_hdrSize());
+ return (void *) ((char *) my + HadTu_hdrSize());
}
static void *HadTu_next(const void *my, const void *hadTu)
{
- uint32_t size;
- uint32_t alignment;
- size_t paddedSize;
+ uint32_t size;
+ uint32_t alignment;
+ size_t paddedSize;
- size = HadTu_size(hadTu);
- alignment = HadTu_alignment(my);
- paddedSize = (size & (alignment - 1))
- ? (size & ~(alignment - 1)) + alignment : size;
+ size = HadTu_size(hadTu);
+ alignment = HadTu_alignment(my);
+ paddedSize = (size & (alignment - 1))
+ ? (size & ~(alignment - 1)) + alignment : size;
- return (void *) ((char *) hadTu + paddedSize);
+ return (void *) ((char *) hadTu + paddedSize);
}
#endif
typedef struct HadTuQueueS HadTuQueue;
typedef enum HadTuQueueProtE {
- HadTuQueueProt_read,
- HadTuQueueProt_write
+ HadTuQueueProt_read,
+ HadTuQueueProt_write
} HadTuQueueProt;
void conHadTuQueue(HadTuQueue *my, void *mem, size_t size);
typedef struct HardwareS Hardware;
-Hardware *newHardware(); /* allowed as newHardware(void) and newHardware(const char *subsystem) UFN */
-void deleteHardware(Hardware * my);
-int Hardware_inSpill(const Hardware * my);
-size_t Hardware_maxSubEvtSize(const Hardware * my);
-void Hardware_waitForTrigger(Hardware * my, void *subEvt);
-void Hardware_readout(Hardware * my, void *subEvt);
-
-static int getCards(Param *param, const char *subsystem, const char *cardtype, int *nCards, char **cards) {
+Hardware *newHardware(); /* allowed as newHardware(void) and newHardware(const char *subsystem) UFN */
+void deleteHardware(Hardware *my);
+int Hardware_inSpill(const Hardware *my);
+size_t Hardware_maxSubEvtSize(const Hardware *my);
+void Hardware_waitForTrigger(Hardware *my, void *subEvt);
+void Hardware_readout(Hardware *my, void *subEvt);
+
+static int getCards(Param *param, const char *subsystem, const char *cardtype, int *nCards, char **cards)
+{
int getCardsR;
int i;
char unitsS[PARAM_MAX_ARRAY_LEN][PARAM_MAX_VALUE_LEN];
for (unit = 0; unit < r; unit++) {
char ct[PARAM_MAX_VALUE_LEN];
int r;
-
+
if (Param_getString(param, units[unit], "cardtype", &r, ct) || r == 0) {
syslog(LOG_ERR, "Parameter %s(cardtype) not found", units[unit]);
getCardsR = -1;
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/hldread.c,v 6.5 2002-10-09 12:42:17 hadaq Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/hldread.c,v 6.6 2003-03-02 15:50:09 hadaq Exp $";
#define _POSIX_C_SOURCE 199309L
char **analArgv = malloc(sizeof(char *));
int analArgc = 1; /* Filename is in analArgv[0] */
- openlog(argv[0], LOG_PID|LOG_PERROR, LOG_LOCAL0);
+ openlog(argv[0], LOG_PID | LOG_PERROR, LOG_LOCAL0);
setlogmask(LOG_UPTO(LOG_INFO));
break;
case 'v':
for (i = 0; prioritynames[i].c_name != NULL
- && 0 != strcmp(prioritynames[i].c_name, optarg); i++) {
+ && 0 != strcmp(prioritynames[i].c_name, optarg); i++) {
}
if (prioritynames[i].c_name != NULL) {
setlogmask(LOG_UPTO(prioritynames[i].c_val));
default:
syslog(
LOG_ERR,
- "Usage: %s -f firstEvent -n numEvents -e echoRate",
+ "Usage: %s -f firstEvent -n numEvents -e echoRate",
argv[0]
);
syslog(
LOG_ERR,
- "-t timeout -o analArgs -x (excludeAnal) [fileName]"
+ "-t timeout -o analArgs -x (excludeAnal) [fileName]"
);
exit(EXIT_FAILURE);
break;
+
#ifndef HLDREAD_H
#define HLDREAD_H
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/Attic/hwrich.c,v 6.37 2003-02-14 11:54:40 sailer Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/Attic/hwrich.c,v 6.38 2003-03-02 15:50:09 hadaq Exp $";
#define _POSIX_C_SOURCE 199309L
#include <unistd.h>
}
subEvt = SubEvt_next(partEvt, subEvt);
}
-
if (dataError) {
SubEvt_setDataError(partEvt);
}
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/Attic/hwsam.c,v 6.16 2002-11-19 02:32:14 hadaq Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/Attic/hwsam.c,v 6.17 2003-03-02 15:50:09 hadaq Exp $";
#include <assert.h>
#include <string.h>
Param_getInt(param, my->name, "cardbase", ¶mWasFound, &cardBase);
if (!paramWasFound) {
syslog(LOG_WARNING,
- "Parameter %s(%s) not found, default = 0", my->name, "cardbase");
+ "Parameter %s(%s) not found, default = 0", my->name, "cardbase");
cardBase = 0;
}
my->cram = malloc(sizeof(LVme));
syslog(LOG_ERR, "HwSam on %p not found", cardBase);
return -1;
}
- my->bankRequested = LVme_tstBitL(my->cram, CRR, 0); /* assumes that init is done by Sam */
- if(my->bankRequested == 1) {
+ my->bankRequested = LVme_tstBitL(my->cram, CRR, 0); /* assumes that init is done by Sam */
+ if (my->bankRequested == 1) {
syslog(LOG_ERR, "HwSam readout bit = 1, should be 0, intialization bug");
}
my->currAddr = SAM_BUFSIZE;
/* CAUTION this ist just for clearing buffer request state,
if also makes the being always empty in HwSam_isEmpty which makes
hwmdc.c working by coincidence */
-
+
my->endOfData = 1;
}
/* Subevent Header + some data */
-#define SAM_NODATASIZE 16
+#define SAM_NODATASIZE 16
int HwSam_readSubEvt(HwSam *my, void *subEvt)
{
- uint32_t * data = (uint32_t *) subEvt;
+ uint32_t *data = (uint32_t *) subEvt;
int lastAddr;
int currAddr = my->currAddr;
int size;
lastAddr = currAddr + size;
if (size > SAM_BUFSIZE - SAM_BUFOFFSET) {
- syslog(LOG_CRIT, "subEvt throw away : %d, %d", size, SAM_BUFSIZE-SAM_BUFOFFSET);
+ syslog(LOG_CRIT, "subEvt throw away : %d, %d", size, SAM_BUFSIZE - SAM_BUFOFFSET);
/* damaged data, no repair possible, skip subevent*/
return -1;
}
- if(size <= SAM_NODATASIZE) {
- /* skip dataless subevent */
+ if (size <= SAM_NODATASIZE) {
+ /* skip dataless subevent */
return 1;
}
#ifndef NDEBUG
#endif
/* copy one sub evt from Sam to memory */
*data++ = size;
- while ((currAddr+=4)<lastAddr) {
+ while ((currAddr += 4) < lastAddr) {
*data++ = LVme_getL(my->cram, currAddr);
}
#endif
return 0;
}
-
-
-
-
-
-
-
+
+
+
+
+
+
+
#ifndef HwSam_H
#define HwSam_H
#include "sam_defs.h"
typedef struct HwSamS {
- char name[12];
- LVme *cram;
- LVme *regs;
- int bankRequested;
- unsigned long currAddr;
- unsigned long endOfData;
-} HwSam;
+ char name[12];
+ LVme *cram;
+ LVme *regs;
+ int bankRequested;
+ unsigned long currAddr;
+ unsigned long endOfData;
+}
+
+HwSam;
int conHwSam(HwSam *my, const char *name, const Param *param);
void desHwSam(HwSam *my);
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/Attic/hwsoft.c,v 6.26 2003-02-14 11:54:41 sailer Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/Attic/hwsoft.c,v 6.27 2003-03-02 15:50:10 hadaq Exp $";
#define _POSIX_C_SOURCE 199309L
Param_getInt(param, "soft", "size", ¶mWasFound, &size);
if (!paramWasFound) {
syslog(LOG_WARNING,
- "Parameter %s(%s) not found, defaulting to 0", "soft", "size");
+ "Parameter %s(%s) not found, defaulting to 0", "soft", "size");
size = 0;
}
desParam(param);
*data++ = 0x2;
}
- SubEvt_setSize(subEvt, (char *)data - (char *)subEvt);
+ SubEvt_setSize(subEvt, (char *) data - (char *) subEvt);
SubEvt_setId(subEvt, SubEvtId_trigCode);
SubEvt_setTrigNr(subEvt, trigTag);
syslog(LOG_DEBUG, "subEvt: %s", SubEvt_2charP(subEvt));
data += (int) ((1000.0 * rand()) / RAND_MAX);
#endif
- size = (char *)data - (char *)subEvt;
+ size = (char *) data - (char *) subEvt;
id = SubEvtId_test1;
#if 1
if (size > 5000) {
if (err) {
SubEvt_setDataError(partEvt);
}
- SubEvt_setSize(partEvt, (char *)subEvt - (char *)partEvt);
+ SubEvt_setSize(partEvt, (char *) subEvt - (char *) partEvt);
SubEvt_setTrigNr(partEvt, (trigNr << 8) | trigTag);
syslog(LOG_DEBUG, "partEvt: %s", SubEvt_2charP(partEvt));
}
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/Attic/hwtip.c,v 1.28 2002-11-07 10:39:04 hadaq Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/Attic/hwtip.c,v 1.29 2003-03-02 15:50:10 hadaq Exp $";
#include <assert.h>
#include <string.h>
#define TIP_BUFSIZE 0x40000
-int conHwTip(HwTip * my, const char *name, const Param *param)
+int conHwTip(HwTip *my, const char *name, const Param *param)
{
unsigned long cardBase;
int paramWasFound;
Param_getInt(param, my->name, "cardbase", ¶mWasFound, &cardBase);
if (!paramWasFound) {
syslog(LOG_WARNING,
- "Parameter %s(%s) not found, default = 0", my->name, "cardbase");
+ "Parameter %s(%s) not found, default = 0", my->name, "cardbase");
cardBase = 0;
}
- syslog(LOG_INFO, "conc cardbase %.8x", cardBase );
+ syslog(LOG_INFO, "conc cardbase %.8x", cardBase);
- my->lvme = (LVme *)malloc(sizeof(LVme));
+ my->lvme = (LVme *) malloc(sizeof(LVme));
if (0 > conLVme(my->lvme, cardBase, 0x3000000UL, 0x09UL, 0, 0)) {
syslog(LOG_ERR, "HwTip on %p not found", cardBase);
return -1;
}
-
my->currAddr = 0x7fffffff; /* start at the end */
my->bankRequested = 1; /* of the empty bank */
my->endOfData = 0;
return 0;
}
-void desHwTip(HwTip * my)
+void desHwTip(HwTip *my)
{
desLVme(my->lvme);
signal(SIGBUS, SIG_DFL);
}
-void HwTip_requestBuffer(HwTip * my)
+void HwTip_requestBuffer(HwTip *my)
{
LVme_clrBitL(my->lvme, CONFIG1BASE + CFG_MASTER_CONTROL, my->daqRq);
my->currAddr = my->fifo + 0x4;
}
-int HwTip_readSubEvt(HwTip * my, void *subEvt)
+int HwTip_readSubEvt(HwTip *my, void *subEvt)
{
uint32_t *data = (uint32_t *) subEvt;
unsigned long currAddr = my->currAddr;
int errorFlag = 0;
unsigned long dataWord;
unsigned long tdcCounter = 0;
- unsigned long tdcEventCounter, trigTag,evtC;
- int arrayCounter = 0,i;
+ unsigned long tdcEventCounter, trigTag, evtC;
+ int arrayCounter = 0, i;
#ifdef BUFFER_PRINTOUT_ENABLED
unsigned long tempArray[500];
#endif
header = LVme_getL(my->lvme, currAddr);
size = header & 0xfff;
- byteSize = size<<2;
+ byteSize = size << 2;
my->currAddr += byteSize;
- if(byteSize > (TIP_BUFSIZE - my->currAddr + my->fifo)) {
- syslog(LOG_ERR, "size too large! size: %.8x ",size);
- size = (TIP_BUFSIZE - my->currAddr + my->fifo)>>2;
- header &= 0x80000000;
+ if (byteSize > (TIP_BUFSIZE - my->currAddr + my->fifo)) {
+ syslog(LOG_ERR, "size too large! size: %.8x ", size);
+ size = (TIP_BUFSIZE - my->currAddr + my->fifo) >> 2;
+ header &= 0x80000000;
}
- trigTag = ((header>>16) & 0xff);
+ trigTag = ((header >> 16) & 0xff);
/* copy one sub evt from RC to memory */
while (--size) {
-
- /* *data++ = LVme_getL(my->lvme, currAddr+=4); */
- dataWord = LVme_getL(my->lvme, currAddr+=4);
- *data++ = dataWord;
+
+ /* *data++ = LVme_getL(my->lvme, currAddr+=4); */
+ dataWord = LVme_getL(my->lvme, currAddr += 4);
+ *data++ = dataWord;
#ifdef BUFFER_PRINTOUT_ENABLED
- tempArray[arrayCounter++] = dataWord;
+ tempArray[arrayCounter++] = dataWord;
#endif
- statusWord = ((dataWord>>24) & 0x7);
- if( statusWord == 2 ) {
- /* Header */
- tdcCounter++;
- crateNumber = ((dataWord>>16) & 0xff);
- if( foundCBLTHeaderFlag == 1) {
- syslog(LOG_ERR, "header: %.8x, at least two headers came without a trailer, data: %.8x",
- header, dataWord);
- errorFlag = 1;
- }
-
- currentGeo = (dataWord >>27 ) & 0x1f;
+ statusWord = ((dataWord >> 24) & 0x7);
+ if (statusWord == 2) {
+ /* Header */
+ tdcCounter++;
+ crateNumber = ((dataWord >> 16) & 0xff);
+ if (foundCBLTHeaderFlag == 1) {
+ syslog(LOG_ERR, "header: %.8x, at least two headers came without a trailer, data: %.8x",
+ header, dataWord);
+ errorFlag = 1;
+ }
+ currentGeo = (dataWord >> 27) & 0x1f;
#if 0
- if (lastGeo == 0) {
- lastGeo=currentGeo-1;
- }
- if( lastGeo +1 != currentGeo ) {
- syslog(LOG_ERR, "header: %.8x, Geo not incremental, crate: %d data: %.8x, lastGeo %d, currentGeo %d",
- header, crateNumber, dataWord, lastGeo, currentGeo);
- errorFlag = 1;
- }
- lastGeo = currentGeo;
+ if (lastGeo == 0) {
+ lastGeo = currentGeo - 1;
+ }
+ if (lastGeo + 1 != currentGeo) {
+ syslog(LOG_ERR, "header: %.8x, Geo not incremental, crate: %d data: %.8x, lastGeo %d, currentGeo %d",
+ header, crateNumber, dataWord, lastGeo, currentGeo);
+ errorFlag = 1;
+ }
+ lastGeo = currentGeo;
#endif
- foundCBLTHeaderFlag = 1;
- }
- else if ( statusWord == 4 ) {
- /* Trailer */
- tdcEventCounter = dataWord & 0xffffff;
- foundCBLTTrailerFlag = 1;
- if( foundCBLTTrailerFlag == 1 && foundCBLTHeaderFlag == 0) {
- syslog(LOG_ERR, "header: %.8x, trailer came before header! data: %.8x",
- header, dataWord);
- errorFlag = 1;
- }
-
- evtC = (tdcEventCounter &0xff);
+ foundCBLTHeaderFlag = 1;
+ } else if (statusWord == 4) {
+ /* Trailer */
+ tdcEventCounter = dataWord & 0xffffff;
+ foundCBLTTrailerFlag = 1;
+ if (foundCBLTTrailerFlag == 1 && foundCBLTHeaderFlag == 0) {
+ syslog(LOG_ERR, "header: %.8x, trailer came before header! data: %.8x",
+ header, dataWord);
+ errorFlag = 1;
+ }
+ evtC = (tdcEventCounter & 0xff);
#if 1
- if( (tdcEventCounter &0xff) != trigTag) {
- /* if( (max(evtC, trigTag) - min(evtC, trigTag) >=2) && (max(evtC, trigTag) - min(evtC, trigTag) <= 0xfe )) { */
- syslog(LOG_ERR, "header: %.8x, crate: %d, tdc_num: %d, tag (%.8x) != EvtCounter (%.8x), dataWord: %.8x ",
- header, crateNumber, tdcCounter, trigTag, tdcEventCounter, dataWord);
- errorFlag = 1;
- }
+ if ((tdcEventCounter & 0xff) != trigTag) {
+ /* if( (max(evtC, trigTag) - min(evtC, trigTag) >=2) && (max(evtC, trigTag) - min(evtC, trigTag) <= 0xfe )) { */
+ syslog(LOG_ERR, "header: %.8x, crate: %d, tdc_num: %d, tag (%.8x) != EvtCounter (%.8x), dataWord: %.8x ",
+ header, crateNumber, tdcCounter, trigTag, tdcEventCounter, dataWord);
+ errorFlag = 1;
+ }
#endif
- foundCBLTTrailerFlag = 0;
- foundCBLTHeaderFlag = 0;
- }
- else if (statusWord == 0) {
- /* data word, nothing to do... */
- }
- else {
-#if 0
- syslog(LOG_ERR, "status word of tdc not 0,2 or 4, header: %.8x, data: %.8x", header, dataWord);
- errorFlag = 1;
+ foundCBLTTrailerFlag = 0;
+ foundCBLTHeaderFlag = 0;
+ } else if (statusWord == 0) {
+ /* data word, nothing to do... */
+ } else {
+#if 0
+ syslog(LOG_ERR, "status word of tdc not 0,2 or 4, header: %.8x, data: %.8x", header, dataWord);
+ errorFlag = 1;
#endif
- }
+ }
+
-
}
-
-#ifdef BUFFER_PRINTOUT_ENABLED
- if(errorFlag) {
- str[0] = 0;
- for(i=0;i < arrayCounter; i++) {
- sprintf(buff, "%.8x ", tempArray[i]);
- strcpy((char *) ((unsigned int)str + strlen(str)) , buff);
- if( ((i+1)%4) == 0) {
- syslog(LOG_ERR, str);
- str[0] = 0;
- }
- }
- if( (i%4)) {
- syslog(LOG_ERR, str);
- str[0] = 0;
- }
+#ifdef BUFFER_PRINTOUT_ENABLED
+ if (errorFlag) {
+ str[0] = 0;
+ for (i = 0; i < arrayCounter; i++) {
+ sprintf(buff, "%.8x ", tempArray[i]);
+ strcpy((char *) ((unsigned int) str + strlen(str)), buff);
+ if (((i + 1) % 4) == 0) {
+ syslog(LOG_ERR, str);
+ str[0] = 0;
+ }
+ }
+ if ((i % 4)) {
+ syslog(LOG_ERR, str);
+ str[0] = 0;
+ }
}
-#endif
+#endif
return header;
}
-
-
+
+
#ifndef HWTIP_H
#define HWTIP_H
#include "tof_defs.h"
typedef struct HwTipS {
- char name[12];
- LVme *lvme;
- int bankRequested;
- int daqRq;
- int daqGr;
- int currAddr;
- int fifo;
- int endOfData;
-} HwTip;
+ char name[12];
+ LVme *lvme;
+ int bankRequested;
+ int daqRq;
+ int daqGr;
+ int currAddr;
+ int fifo;
+ int endOfData;
+}
+
+HwTip;
int conHwTip(HwTip *my, const char *name, const Param *param);
void desHwTip(HwTip *my);
-static int HwTip_isBusy(HwTip * my)
+static int HwTip_isBusy(HwTip *my)
{
return !LVme_tstBitL(my->lvme, CONFIG1BASE + CFG_MASTER_STATUS, my->daqGr);
}
-static void HwTip_getEndOfData(HwTip * my)
+static void HwTip_getEndOfData(HwTip *my)
{
my->endOfData = LVme_getL(my->lvme, my->fifo) + my->fifo;
}
-static int HwTip_isEmpty(HwTip * my)
+static int HwTip_isEmpty(HwTip *my)
{
return my->currAddr >= my->endOfData;
}
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/Attic/hwtrig.c,v 6.34 2003-02-14 11:54:41 sailer Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/Attic/hwtrig.c,v 6.35 2003-03-02 15:50:10 hadaq Exp $";
#define _POSIX_C_SOURCE 199309L
#include <unistd.h>
syslog(LOG_ERR, "MU on %p not found", cardBase);
return NULL;
}
-
if (my->nConcs > 0) {
my->tip = malloc(sizeof(HwTip));
if (0 > conHwTip(my->tip, conc, param)) {
return NULL;
}
}
-
desParam(param);
return my;
}
desHwTip(my->tip);
free(my->tip);
}
-
desLVme(my->lvme6);
free(my->lvme6);
desLVme(my->lvme4);
if (SubEvt_dataError(subEvt)) {
dataError = 1;
}
-
SubEvt_setId(partEvt, trigCode);
trigTag = SubEvt_trigNr(subEvt) & 0xff;
SubEvt_setId(subEvt, 0x19c);
SubEvt_setTrigNr(subEvt, trigTag);
- subEvtInfo = data++; /* leave space for an info word */
+ subEvtInfo = data++; /* leave space for an info word */
for (i = 0; i < NCRATES; i++) {
header = HwTip_readSubEvt(my->tip, data);
}
*subEvtInfo = header >> 16;
- SubEvt_setSize(subEvt, (char *)data - (char *)subEvt);
+ SubEvt_setSize(subEvt, (char *) data - (char *) subEvt);
subEvt = SubEvt_next(partEvt, subEvt);
}
-
if (dataError) {
SubEvt_setDataError(partEvt);
}
+
/* ------------------------------------------------------------
- Header File for the Image Processing Card (Basis-Module) -
------------------------------------------------------------
#define RC3_ACCESS_ON 0x04020
#define RC3_VME_REG_B 0x0401a
#define RC3_VME_REG_A 0x04018
-#define RC3_LM_BADDRREG 0x04016
+#define RC3_LM_BADDRREG 0x04016
#define RC3_ERRREG_B 0x04014
#define RC3_ERRREG_A 0x04012
#define RC3_BYSREG_B 0x04010
#define LUT12_WE 0x00012 /* bzw. LUT34_WE */
#define LUT1234_READ 0x00014
#define LUT_CTR_LD_F12_ENAB 0x00016
-#define LUT_CTR_LD_F12_DISAB 0x00018
+#define LUT_CTR_LD_F12_DISAB 0x00018
#define LUT_CTR_LD_REG 0x0001a
-#define LUT_CTR_LD_STR 0x0001e
+#define LUT_CTR_LD_STR 0x0001e
/* -- Operational Modes of the Image Processing Card --
#define POS 1
#define NEG 0
-#define END_PATTERN 0x23ad
+#define END_PATTERN 0x23ad
#define ZERO_SUPPRESSION_ON 0x8
#define ZERO_SUPPRESSION_OFF 0x0
#define PEDASTAL_ON 0x1
#define LVL2_REVID_VMEREG 0x5
/* Layers, Rows, Columns per Image Processing Card */
-#define IPC_LAYS 3
-#define IPC_ROWS 16
-#define IPC_COLS 32
+#define IPC_LAYS 3
+#define IPC_ROWS 16
+#define IPC_COLS 32
/* Layers, Rows, Columns per Readout Board */
-#define RB_LAYS 3
-#define RB_ROWS 32
-#define RB_COLS 16
-#define NUM_RBS 2 /* Number of RBs in current test 1 or 2 */
-#define NUM_RB_FIFOS 2 /* Number of fifos per RB */
-#define NUM_ROWS_RB_FIFO 8 /* Number of detector colmuns per RB fifo */
+#define RB_LAYS 3
+#define RB_ROWS 32
+#define RB_COLS 16
+#define NUM_RBS 2 /* Number of RBs in current test 1 or 2 */
+#define NUM_RB_FIFOS 2 /* Number of fifos per RB */
+#define NUM_ROWS_RB_FIFO 8 /* Number of detector colmuns per RB fifo */
#define MAX_LINE_CHARS 50
void IPC_Write_SubID(LVme *lvme, unsigned long ul_daten);
void IPC_Set_Lvl2_MemBank(LVme *lvme, int i_l2ab);
void IPC_Write_LMAddr(LVme *lvme, unsigned short us_lmbaddr,
- int i_mode);
+ int i_mode);
void IPC_Set_BsyErr_Mask(LVme *lvme, int i_bsymsk, int i_errmsk,
- int i_mode);
+ int i_mode);
void IPC_Set_Lvl2_Mode(LVme *lvme, unsigned long us_daten);
void IPC_Set_PedMode(LVme *lvme, unsigned short us_pedes,
- int i_mode);
+ int i_mode);
void IPC_Clear_Lvl2(LVme *lvme, int i_mode);
void IPC_Set_Shower_Threshold(LVme *lvme, int i_device,
- int i_shower_threshold, int i_mode);
+ int i_shower_threshold, int i_mode);
void IPC_Get_Shower_Threshold(LVme *lvme, int i_device,
- unsigned i_shower_threshold,
- int i_mode);
+ unsigned i_shower_threshold,
+ int i_mode);
void IPC_Set_Addon_Status(LVme *lvme, int i_device,
- int i_addon_status, int i_mode);
-void IPC_Get_Addon_Status(LVme *lvme, int i_device,
- int i_addon_status, int i_mode);
+ int i_addon_status, int i_mode);
+void IPC_Get_Addon_Status(LVme *lvme, int i_device,
+ int i_addon_status, int i_mode);
void IPC_Set_Addon_SubID(LVme *lvme, int i_device,
- int i_subevt_id, int i_mode);
-void IPC_Get_Addon_SubID(LVme *lvme, int i_device,
- int i_subevt_id, int i_mode);
+ int i_subevt_id, int i_mode);
+void IPC_Get_Addon_SubID(LVme *lvme, int i_device,
+ int i_subevt_id, int i_mode);
void IPC_Conf_Lut1234(LVme *lvme, const char *filename, int i_calmode,
- int i_sector, int i_rbhigh, int i_mode);
+ int i_sector, int i_rbhigh, int i_mode);
int IPC_Lut1234_Access(LVme *lvme, int i_layer, int i_row,
- int i_column, int i_ucal_pad, int i_cal_pad,
- int i_mode);
-void IPC_Conf_Lut5(LVme *lvme, const char *filename, int ipc_sector,
- int ipc_rbhigh, int i_mode);
+ int i_column, int i_ucal_pad, int i_cal_pad,
+ int i_mode);
+void IPC_Conf_Lut5(LVme *lvme, const char *filename, int ipc_sector,
+ int ipc_rbhigh, int i_mode);
void IPC_Conf_FPGA(LVme *lvme, const char *filename, int dev_chain,
- int mode);
+ int mode);
int IPC_Status_FPGA(LVme *lvme, int dev_chain, int mode);
void IPC_Init_FPGA(LVme *lvme, int mode, int dev_chain);
void IPC_Read_Status_Regs(LVme *lvme);
int IPC_GetPedestals(const char *pFileName, int iSector, int iRBHigh,
- unsigned char pedestals[][][]);
+ unsigned char pedestals[][][]);
void IPC_create_lut1234_daten();
#endif
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/memnet.c,v 6.15 2002-10-09 12:42:18 hadaq Exp $";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/memnet.c,v 6.16 2003-03-02 15:50:10 hadaq Exp $";
#define _POSIX_C_SOURCE 199309L
unsigned long priority;
unsigned long queueSize;
char verbosity[PARAM_MAX_VALUE_LEN];
-} TheArgs;
+}
+
+TheArgs;
static jmp_buf terminateJmp;
syslog(LOG_ERR, "Usage: [-w bandwidth] [-p priority] [-q queueSize]");
}
-static void argsDump(TheArgs *my) {
+static void argsDump(TheArgs *my)
+{
syslog(LOG_DEBUG, "outPath: %s", my->outPath);
syslog(LOG_DEBUG, "bandWidth: %d", my->bandWidth);
syslog(LOG_DEBUG, "priority: %d", my->priority);
syslog(LOG_DEBUG, "verbosity: %s", my->verbosity);
}
-static void argsDefault(TheArgs *my) {
+static void argsDefault(TheArgs *my)
+{
strcpy(my->outPath, "");
my->bandWidth = 0;
my->priority = 0;
strcpy(my->verbosity, "info");
}
-static int argsFromCL(TheArgs *my, int argc, char *argv[]) {
+static int argsFromCL(TheArgs *my, int argc, char *argv[])
+{
extern char *optarg;
int i;
return 0;
}
-static int argsFromParam(TheArgs *my, int argc, char *argv[]) {
+static int argsFromParam(TheArgs *my, int argc, char *argv[])
+{
Param paramS, *param = ¶mS;
int paramWasFound;
desParam(param);
}
-static void storeInfoStart(const char *n, time_t t, TheArgs *my) {
+static void storeInfoStart(const char *n, time_t t, TheArgs *my)
+{
Param pS, *p = &pS;
int i;
char s[20];
desParam(p);
}
-static void storeInfoStop(const char *n, time_t t, Worker *w) {
+static void storeInfoStop(const char *n, time_t t, Worker *w)
+{
Param pS, *p = &pS;
int i;
char s[20];
conSetupParam(p, getenv("DAQ_SETUP"));
- for ( i = 0; i < 32 && strcmp(w->statistics[i].name, "") != 0; i++) {
+ for (i = 0; i < 32 && strcmp(w->statistics[i].name, "") != 0; i++) {
Param_storeInt(p, n, w->statistics[i].name, w->statistics[i].value);
}
strftime(s, 20, "%Y-%m-%dT%H:%M:%S", localtime(&t));
ShmTrans *shmTrans;
int exitStat;
- openlog(argv[0], LOG_PID|LOG_PERROR, LOG_LOCAL0);
+ openlog(argv[0], LOG_PID | LOG_PERROR, LOG_LOCAL0);
setlogmask(LOG_UPTO(LOG_INFO));
usage(argv[0]);
exit(EXIT_FAILURE);
}
-
for (i = 0; prioritynames[i].c_name != NULL
- && 0 != strcmp(prioritynames[i].c_name, theArgs->verbosity); i++) {
+ && 0 != strcmp(prioritynames[i].c_name, theArgs->verbosity); i++) {
}
if (prioritynames[i].c_name == NULL) {
exit(EXIT_FAILURE);
}
if (NULL == (shmTrans = ShmTrans_create("subevtqueue", 2 * theArgs->queueSize))) {
syslog(LOG_ERR,
- "creating shared memory \"subevtqueue\": %s"), strerror(errno);
+ "creating shared memory \"subevtqueue\": %s"), strerror(errno);
exitStat = EXIT_FAILURE;
goto bailOut1;
}
if (NULL == (netTrans = NetTrans_open(theArgs->outPath, theArgs->bandWidth, worker))) {
syslog(LOG_ERR,
- "opening network transport %s: %s", theArgs->outPath, strerror(errno));
+ "opening network transport %s: %s", theArgs->outPath, strerror(errno));
exitStat = EXIT_FAILURE;
goto bailOut2;
}
exitStat = EXIT_FAILURE;
goto bailOut3;
}
-
ShmTrans_free(shmTrans);
}
exitStat = EXIT_SUCCESS;
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/netmem.c,v 6.23 2002-10-23 14:56:47 hadaq Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/netmem.c,v 6.24 2003-03-02 15:50:10 hadaq Exp $";
#define _POSIX_C_SOURCE 199309L
#define MAXINPATH 32
typedef struct TheArgsS {
- char inPathS[MAXINPATH][PARAM_MAX_NAME_LEN];
- char *inPath[MAXINPATH];
- int inPathCnt;
- unsigned long nrOfMsgs;
- unsigned long isStandalone;
- unsigned long priority;
- unsigned long queueSize;
- char verbosity[PARAM_MAX_VALUE_LEN];
-} TheArgs;
+ char inPathS[MAXINPATH][PARAM_MAX_NAME_LEN];
+ char *inPath[MAXINPATH];
+ int inPathCnt;
+ unsigned long nrOfMsgs;
+ unsigned long isStandalone;
+ unsigned long priority;
+ unsigned long queueSize;
+ char verbosity[PARAM_MAX_VALUE_LEN];
+}
+
+TheArgs;
static jmp_buf terminateJmp;
void sigHandler(int sig)
{
- longjmp(terminateJmp, sig);
+ longjmp(terminateJmp, sig);
}
static void usage(const char *progName)
{
- syslog(LOG_ERR, "Usage: %s -i inPath [-i inPath] -m nrOfMsgs [-p priority]", progName);
+ syslog(LOG_ERR, "Usage: %s -i inPath [-i inPath] -m nrOfMsgs [-p priority]", progName);
}
-static void argsDump(TheArgs *my) {
+static void argsDump(TheArgs *my)
+{
int i;
for (i = 0; i < my->inPathCnt; i++) {
syslog(LOG_DEBUG, "verbosity: %s", my->verbosity);
}
-static void argsDefault(TheArgs *my) {
- int i;
-
- for (i = 0; i < MAXINPATH; i++) {
- my->inPath[i] = my->inPathS[i];
- }
- my->inPathCnt = 0;
- my->nrOfMsgs = 0;
- my->priority = 0;
- my->isStandalone = 1;
- my->queueSize = 1 * 1024 * 1024;
- strcpy(my->verbosity, "info");
+static void argsDefault(TheArgs *my)
+{
+ int i;
+
+ for (i = 0; i < MAXINPATH; i++) {
+ my->inPath[i] = my->inPathS[i];
+ }
+ my->inPathCnt = 0;
+ my->nrOfMsgs = 0;
+ my->priority = 0;
+ my->isStandalone = 1;
+ my->queueSize = 1 * 1024 * 1024;
+ strcpy(my->verbosity, "info");
}
-static int argsFromCL(TheArgs *my, int argc, char *argv[]) {
+static int argsFromCL(TheArgs *my, int argc, char *argv[])
+{
extern char *optarg;
- int i;
-
- while ((i = getopt(argc, argv, "ai:m:q:p:v:")) != -1) {
- switch (i) {
- case 'm':
- my->nrOfMsgs = atoi(optarg);
- break;
- case 'i':
- strcpy(my->inPath[my->inPathCnt++], optarg);
- break;
- case 'a':
- my->isStandalone = 0;
- break;
- case 'p':
- my->priority = atoi(optarg);
- break;
- case 'q':
- my->queueSize = atoi(optarg);
- break;
- case 'v':
- strcpy(my->verbosity, optarg);
- break;
- default:
- return -1;
- break;
- }
- }
- return 0;
+ int i;
+
+ while ((i = getopt(argc, argv, "ai:m:q:p:v:")) != -1) {
+ switch (i) {
+ case 'm':
+ my->nrOfMsgs = atoi(optarg);
+ break;
+ case 'i':
+ strcpy(my->inPath[my->inPathCnt++], optarg);
+ break;
+ case 'a':
+ my->isStandalone = 0;
+ break;
+ case 'p':
+ my->priority = atoi(optarg);
+ break;
+ case 'q':
+ my->queueSize = atoi(optarg);
+ break;
+ case 'v':
+ strcpy(my->verbosity, optarg);
+ break;
+ default:
+ return -1;
+ break;
+ }
+ }
+ return 0;
}
-static int argsFromParam(TheArgs *my, int argc, char *argv[]) {
+static int argsFromParam(TheArgs *my, int argc, char *argv[])
+{
Param paramS, *param = ¶mS;
int paramWasFound;
conSetupParam(param, getenv("DAQ_SETUP"));
Param_getStringArray(param, argv[0], "inpath",
- MAXINPATH, &my->inPathCnt, my->inPath);
+ MAXINPATH, &my->inPathCnt, my->inPath);
Param_getInt(param, argv[0], "nrofmsgs", ¶mWasFound, &my->nrOfMsgs);
Param_getInt(param, argv[0], "stndln", ¶mWasFound, &my->isStandalone);
Param_getInt(param, argv[0], "prio", ¶mWasFound, &my->priority);
desParam(param);
}
-static char *unit(unsigned long v) {
+static char *unit(unsigned long v)
+{
static char retVal[6];
static char u[] = " kM";
int i;
return retVal;
}
-static void statsDump(TheArgs *theArgs, NetTrans **my, int interval) {
+static void statsDump(TheArgs *theArgs, NetTrans **my, int interval)
+{
static unsigned long lastBR[32];
static time_t lastTime = 0;
time_t dT;
int i;
-
+
if (theArgs->isStandalone
&& strcmp(theArgs->verbosity, "info") == 0
&& (dT = (time(NULL) - lastTime)) >= interval
- ) {
+ ) {
fputs("==============================================================================\n", stderr);
for (i = 0; i < theArgs->nrOfMsgs; i++) {
fprintf(stderr, "%17s%02d:%6s",
- "pktsReceived", i, unit(*my[i]->pktsReceived));
+ "pktsReceived", i, unit(*my[i]->pktsReceived));
fprintf(stderr, "%17s%02d:%6s",
- "pktsDiscarded", i, unit(*my[i]->pktsDiscarded));
+ "pktsDiscarded", i, unit(*my[i]->pktsDiscarded));
fprintf(stderr, "%15s%02d :%6s",
- "bytesReceived", i, unit(*my[i]->bytesReceived));
+ "bytesReceived", i, unit(*my[i]->bytesReceived));
fputc('\n', stderr);
fprintf(stderr, "%17s%02d:%6s",
- "msgsReceived", i, unit(*my[i]->msgsReceived));
+ "msgsReceived", i, unit(*my[i]->msgsReceived));
fprintf(stderr, "%17s%02d:%6s",
- "msgsDiscarded", i, unit(*my[i]->msgsDiscarded));
+ "msgsDiscarded", i, unit(*my[i]->msgsDiscarded));
fprintf(stderr, "%15s%02d/s:%6s",
- "bytesReceived", i, unit(*my[i]->bytesReceived - lastBR[i]));
+ "bytesReceived", i, unit(*my[i]->bytesReceived - lastBR[i]));
lastBR[i] = *my[i]->bytesReceived;
fputc('\n', stderr);
fputs("------------------------------------------------------------------------------\n", stderr);
}
}
-static void storeInfoStart(const char *n, time_t t, TheArgs *my) {
+static void storeInfoStart(const char *n, time_t t, TheArgs *my)
+{
Param pS, *p = &pS;
int i;
char s[20];
desParam(p);
}
-static void storeInfoStop(const char *n, time_t t, Worker *w) {
+static void storeInfoStop(const char *n, time_t t, Worker *w)
+{
Param pS, *p = &pS;
int i;
char s[20];
conSetupParam(p, getenv("DAQ_SETUP"));
- for ( i = 0; i < 32 && strcmp(w->statistics[i].name, "") != 0; i++) {
+ for (i = 0; i < 32 && strcmp(w->statistics[i].name, "") != 0; i++) {
Param_storeInt(p, n, w->statistics[i].name, w->statistics[i].value);
}
strftime(s, 20, "%Y-%m-%dT%H:%M:%S", localtime(&t));
int main(int argc, char *argv[])
{
- int i;
- TheArgs theArgsS, *theArgs = &theArgsS;
- Worker *worker;
- NetTrans **netTrans;
- ShmTrans **shmTrans;
- void **hadTu;
- size_t *hadTuSize;
-
- openlog(argv[0], LOG_PID|LOG_PERROR, LOG_LOCAL0);
- setlogmask(LOG_UPTO(LOG_INFO));
-
-
-
- argsDefault(theArgs);
- argsFromParam(theArgs, argc, argv);
- if (0 > argsFromCL(theArgs, argc, argv)) {
- usage(argv[0]);
- exit(EXIT_FAILURE);
- }
-
- for (i = 0; prioritynames[i].c_name != NULL
- && 0 != strcmp(prioritynames[i].c_name, theArgs->verbosity); i++) {
- }
- if (prioritynames[i].c_name == NULL) {
- exit(EXIT_FAILURE);
- } else {
- setlogmask(LOG_UPTO(prioritynames[i].c_val));
- }
-
- argsDump(theArgs);
-
- if (theArgs->inPathCnt == 0 || theArgs->nrOfMsgs == 0 || theArgs->inPathCnt != theArgs->nrOfMsgs) {
- usage(argv[0]);
- exit(EXIT_FAILURE);
- }
- netTrans = malloc(theArgs->nrOfMsgs * sizeof(NetTrans *));
- shmTrans = malloc(theArgs->nrOfMsgs * sizeof(ShmTrans *));
- hadTu = malloc(theArgs->nrOfMsgs * sizeof(void *));
- hadTuSize = malloc(theArgs->nrOfMsgs * sizeof(size_t));
-
- if (NULL == (worker = Worker_initBegin(argv[0], sigHandler, theArgs->priority, theArgs->isStandalone))) {
- syslog(LOG_ERR, "%s, %d: %s", __FILE__, __LINE__, strerror(errno));
- exit(EXIT_FAILURE);
- }
- for (i = 0; i < theArgs->nrOfMsgs; i++) {
- char buf[80];
-
- netTrans[i] = NetTrans_create(theArgs->inPath[i], 0, worker);
- if (netTrans[i] == NULL) {
- syslog(LOG_ERR, "%s, %d: %s", __FILE__, __LINE__, strerror(errno));
- exit(EXIT_FAILURE);
- }
-
- sprintf(buf, "netqueue%d", i);
- shmTrans[i] = ShmTrans_open(buf, 2 * theArgs->queueSize);
- if (shmTrans[i] == NULL) {
- syslog(LOG_ERR, "%s, %d: %s", __FILE__, __LINE__, strerror(errno));
- exit(EXIT_FAILURE);
- }
-
- hadTu[i] = NULL;
- hadTuSize[i] = theArgs->queueSize - HadTu_hdrSize();
- }
- storeInfoStart(argv[0], time(NULL), theArgs);
- Worker_initEnd(worker);
-
- if (setjmp(terminateJmp) == 0) {
- while (1) {
- long msgsCompleted;
-
- statsDump(theArgs, netTrans, 1);
-
- for (i = 0; i < theArgs->nrOfMsgs; i++) {
- if (hadTu[i] == NULL) {
- ShmTrans_requestSpace(shmTrans[i]);
- hadTu[i] = ShmTrans_tryAlloc(shmTrans[i], hadTuSize[i]);
- }
- }
-
- msgsCompleted = NetTrans_multiRecv(netTrans, hadTu, hadTuSize, theArgs->nrOfMsgs);
-
- for (i = 0; i < theArgs->nrOfMsgs; i++) {
- if ((msgsCompleted & (1 << i)) != 0) {
- ShmTrans_send(shmTrans[i]);
- hadTu[i] = NULL;
- }
- }
- }
- }
- storeInfoStop(argv[0], time(NULL), worker);
- statsDump(theArgs, netTrans, 0);
-
- for (i = 0; i < theArgs->nrOfMsgs; i++) {
- ShmTrans_remove(shmTrans[i]);
- NetTrans_remove(netTrans[i]);
- }
- Worker_fini(worker);
- exit(EXIT_SUCCESS);
+ int i;
+ TheArgs theArgsS, *theArgs = &theArgsS;
+ Worker *worker;
+ NetTrans **netTrans;
+ ShmTrans **shmTrans;
+ void **hadTu;
+ size_t *hadTuSize;
+
+ openlog(argv[0], LOG_PID | LOG_PERROR, LOG_LOCAL0);
+ setlogmask(LOG_UPTO(LOG_INFO));
+
+
+
+ argsDefault(theArgs);
+ argsFromParam(theArgs, argc, argv);
+ if (0 > argsFromCL(theArgs, argc, argv)) {
+ usage(argv[0]);
+ exit(EXIT_FAILURE);
+ }
+ for (i = 0; prioritynames[i].c_name != NULL
+ && 0 != strcmp(prioritynames[i].c_name, theArgs->verbosity); i++) {
+ }
+ if (prioritynames[i].c_name == NULL) {
+ exit(EXIT_FAILURE);
+ } else {
+ setlogmask(LOG_UPTO(prioritynames[i].c_val));
+ }
+
+ argsDump(theArgs);
+
+ if (theArgs->inPathCnt == 0 || theArgs->nrOfMsgs == 0 || theArgs->inPathCnt != theArgs->nrOfMsgs) {
+ usage(argv[0]);
+ exit(EXIT_FAILURE);
+ }
+ netTrans = malloc(theArgs->nrOfMsgs * sizeof(NetTrans *));
+ shmTrans = malloc(theArgs->nrOfMsgs * sizeof(ShmTrans *));
+ hadTu = malloc(theArgs->nrOfMsgs * sizeof(void *));
+ hadTuSize = malloc(theArgs->nrOfMsgs * sizeof(size_t));
+
+ if (NULL == (worker = Worker_initBegin(argv[0], sigHandler, theArgs->priority, theArgs->isStandalone))) {
+ syslog(LOG_ERR, "%s, %d: %s", __FILE__, __LINE__, strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+ for (i = 0; i < theArgs->nrOfMsgs; i++) {
+ char buf[80];
+
+ netTrans[i] = NetTrans_create(theArgs->inPath[i], 0, worker);
+ if (netTrans[i] == NULL) {
+ syslog(LOG_ERR, "%s, %d: %s", __FILE__, __LINE__, strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+ sprintf(buf, "netqueue%d", i);
+ shmTrans[i] = ShmTrans_open(buf, 2 * theArgs->queueSize);
+ if (shmTrans[i] == NULL) {
+ syslog(LOG_ERR, "%s, %d: %s", __FILE__, __LINE__, strerror(errno));
+ exit(EXIT_FAILURE);
+ }
+ hadTu[i] = NULL;
+ hadTuSize[i] = theArgs->queueSize - HadTu_hdrSize();
+ }
+ storeInfoStart(argv[0], time(NULL), theArgs);
+ Worker_initEnd(worker);
+
+ if (setjmp(terminateJmp) == 0) {
+ while (1) {
+ long msgsCompleted;
+
+ statsDump(theArgs, netTrans, 1);
+
+ for (i = 0; i < theArgs->nrOfMsgs; i++) {
+ if (hadTu[i] == NULL) {
+ ShmTrans_requestSpace(shmTrans[i]);
+ hadTu[i] = ShmTrans_tryAlloc(shmTrans[i], hadTuSize[i]);
+ }
+ }
+
+ msgsCompleted = NetTrans_multiRecv(netTrans, hadTu, hadTuSize, theArgs->nrOfMsgs);
+
+ for (i = 0; i < theArgs->nrOfMsgs; i++) {
+ if ((msgsCompleted & (1 << i)) != 0) {
+ ShmTrans_send(shmTrans[i]);
+ hadTu[i] = NULL;
+ }
+ }
+ }
+ }
+ storeInfoStop(argv[0], time(NULL), worker);
+ statsDump(theArgs, netTrans, 0);
+
+ for (i = 0; i < theArgs->nrOfMsgs; i++) {
+ ShmTrans_remove(shmTrans[i]);
+ NetTrans_remove(netTrans[i]);
+ }
+ Worker_fini(worker);
+ exit(EXIT_SUCCESS);
}
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/nettrans.c,v 6.25 2002-10-09 12:42:18 hadaq Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/nettrans.c,v 6.26 2003-03-02 15:50:10 hadaq Exp $";
#define _GNU_SOURCE
return a < b ? a : b;
}
-static int openUdp(NetTrans *my, unsigned long addr, int port, int fl) {
+static int openUdp(NetTrans *my, unsigned long addr, int port, int fl)
+{
int retVal;
struct sockaddr_in sa;
sa.sin_family = AF_INET;
sa.sin_port = htons(port);
sa.sin_addr.s_addr = 0;
- retVal = bind(my->fd, (struct sockaddr *)&sa, sizeof(sa));
+ retVal = bind(my->fd, (struct sockaddr *) &sa, sizeof(sa));
break;
case O_WRONLY:
sa.sin_family = AF_INET;
sa.sin_port = htons(port);
sa.sin_addr.s_addr = addr;
- retVal = connect(my->fd, (struct sockaddr *)&sa, sizeof(sa));
+ retVal = connect(my->fd, (struct sockaddr *) &sa, sizeof(sa));
break;
default:
errno = EINVAL;
return retVal;
}
-static int openAtm(NetTrans *my, int vpi, int vci, size_t bw, int fl) {
+static int openAtm(NetTrans *my, int vpi, int vci, size_t bw, int fl)
+{
int retVal;
LAtmAttr lAtmAttrS, *lAtmAttr = &lAtmAttrS;
lAtmAttr->peakBandwidth = bw;
syslog(LOG_DEBUG, "aal: %d; vpi: %d; vci: %d; bandwidth: %d",
- lAtmAttr->aal, lAtmAttr->vpi, lAtmAttr->vci, lAtmAttr->peakBandwidth);
+ lAtmAttr->aal, lAtmAttr->vpi, lAtmAttr->vci, lAtmAttr->peakBandwidth);
my->lAtm = newLAtm("/dev/fa0", fl);
return retVal;
}
-int openGeneric(NetTrans *my, const char *name, int flags, size_t bandwidth) {
+int openGeneric(NetTrans *my, const char *name, int flags, size_t bandwidth)
+{
int retVal;
char fam[32];
char pa[32];
addr = inet_addr(pa);
port = atoi(ep);
my->type = NetTransType_udp;
- retVal = openUdp(my, addr, port,flags);
+ retVal = openUdp(my, addr, port, flags);
} else {
my->type = NetTransType_invalid;
errno = EINVAL;
return retVal;
}
-int closeGeneric(NetTrans *my) {
+int closeGeneric(NetTrans *my)
+{
int retVal;
assert(my != NULL);
return retVal;
}
-int sendGeneric(NetTrans *my) {
+int sendGeneric(NetTrans *my)
+{
int retVal;
assert(NetTrans_invariant(my));
}
break;
case NetTransType_udp:
-#if 0 /* This limits the output data rate to 100 * mtuSize / s */
+#if 0 /* This limits the output data rate to 100 * mtuSize / s */
{
static int i = 0;
if (i++ % 2 != 0) {
if (retVal != my->pktSize) {
retVal = -1;
}
-
if (0 > retVal) {
syslog(LOG_DEBUG, "sendGeneric: %s", strerror(errno));
}
return retVal;
}
-int recvGeneric(NetTrans *my) {
+int recvGeneric(NetTrans *my)
+{
int retVal;
assert(NetTrans_invariant(my));
return retVal;
}
-int NetTrans_invariant(const NetTrans *my) {
+int NetTrans_invariant(const NetTrans *my)
+{
return (
- my != NULL
- && (my->type == NetTransType_atm || my->type == NetTransType_udp)
+ my != NULL
+ && (my->type == NetTransType_atm || my->type == NetTransType_udp)
);
}
if (0 > openGeneric(my, name, O_RDONLY, bandwidth)) {
return NULL;
}
-
my->pktSize = 0;
my->offset = 0;
my->msgsDiscarded = Worker_addStatistic(worker, buf);
sprintf(buf, "%s%d", "bytesReceived", instance);
my->bytesReceived = Worker_addStatistic(worker, buf);
-
- instance++;
+
+ instance++;
return my;
}
if (0 > openGeneric(my, name, O_WRONLY, bandwidth)) {
return NULL;
}
-
my->pktSize = 0;
my->offset = 0;
free(my);
}
-static size_t adjustedSize(NetTrans *my, void *hadTu) {
+static size_t adjustedSize(NetTrans *my, void *hadTu)
+{
size_t size;
size = HadTu_paddedSize(hadTu) + 32;
my->offset = 0;
do {
- my->pkt = (char *)hadTu + my->offset;
+ my->pkt = (char *) hadTu + my->offset;
my->pktSize = min(my->mtuSize, size - my->offset);
if (0 > sendGeneric(my)) {
return -1;
}
-
my->offset += my->pktSize;
(*my->pktsSent)++;
} while (my->pktSize == my->mtuSize);
free(my->pkt);
return 0;
}
-
- my->pkt = (char *)hadTu + my->offset;
+ my->pkt = (char *) hadTu + my->offset;
if (0 > recvGeneric(my)) {
abort();
}
+
#ifndef NETTRANS_H
#define NETTRANS_H
} NetTransType;
typedef struct NetTransS {
- char name[512];
- NetTransType type;
- LAtm *lAtm;
- size_t mtuSize;
- int fd;
- void *pkt;
- size_t pktSize;
- size_t offset;
- unsigned long *pktsSent;
- unsigned long *msgsSent;
- unsigned long *bytesSent;
- unsigned long *pktsReceived;
- unsigned long *pktsDiscarded;
- unsigned long *msgsReceived;
- unsigned long *msgsDiscarded;
- unsigned long *bytesReceived;
-} NetTrans;
+ char name[512];
+ NetTransType type;
+ LAtm *lAtm;
+ size_t mtuSize;
+ int fd;
+ void *pkt;
+ size_t pktSize;
+ size_t offset;
+ unsigned long *pktsSent;
+ unsigned long *msgsSent;
+ unsigned long *bytesSent;
+ unsigned long *pktsReceived;
+ unsigned long *pktsDiscarded;
+ unsigned long *msgsReceived;
+ unsigned long *msgsDiscarded;
+ unsigned long *bytesReceived;
+}
+
+NetTrans;
int NetTrans_invariant(const NetTrans *my);
-NetTrans *NetTrans_create(const char *name, size_t bandwidth, Worker * worker);
-NetTrans *NetTrans_open(const char *name, size_t bandwidth, Worker * worker);
+NetTrans *NetTrans_create(const char *name, size_t bandwidth, Worker *worker);
+NetTrans *NetTrans_open(const char *name, size_t bandwidth, Worker *worker);
void NetTrans_close(NetTrans *my);
void NetTrans_remove(NetTrans *my);
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/online.c,v 6.6 2001-11-18 11:56:21 hadaq Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/online.c,v 6.7 2003-03-02 15:50:10 hadaq Exp $";
#define _GNU_SOURCE
return &result;
}
-rpcevt * onlineevt_1_svc(void *dummy, struct svc_req *x)
+rpcevt *onlineevt_1_svc(void *dummy, struct svc_req * x)
{
return onlineevt_1(dummy, NULL);
}
+
#ifndef PSXSHM_H
#define PSXSHM_H
#include <sys/types.h>
typedef struct PsxShmS {
- int fd;
- void *addr;
- off_t size;
-} PsxShm;
+ int fd;
+ void *addr;
+ off_t size;
+}
+
+PsxShm;
PsxShm *PsxShm_open(const char *name, int oflag, mode_t mode, off_t size);
-int PsxShm_close(PsxShm * my);
+int PsxShm_close(PsxShm *my);
int PsxShm_unlink(const char *name);
#endif
+
#ifndef RC_H
#define RC_H
typedef struct RcS {
LVme *lvme;
-} Rc;
+}
+
+Rc;
/**********************************
* INTERFACE3 Xilinx part *
**********************************/
enum Rc_regions {
- memRegion = 0x100000,
- busRegion = 0x200000,
- regRegion = 0x300000,
- xcRegion = 0x400000,
- dprRegion = 0x500000
+ memRegion = 0x100000,
+ busRegion = 0x200000,
+ regRegion = 0x300000,
+ xcRegion = 0x400000,
+ dprRegion = 0x500000
};
static const size_t Rc_addrSpace = 0x600000;
/* Offsets for INTERFACE2 registers */
-static const ptrdiff_t ctrlReg = regRegion + 0x000;
-static const ptrdiff_t ctrlPad = regRegion + 0x002;
-static const ptrdiff_t trgReg = regRegion + 0x004;
-static const ptrdiff_t trgPad = regRegion + 0x006;
-static const ptrdiff_t trgCtr = regRegion + 0x008;
+static const ptrdiff_t ctrlReg = regRegion + 0x000;
+static const ptrdiff_t ctrlPad = regRegion + 0x002;
+static const ptrdiff_t trgReg = regRegion + 0x004;
+static const ptrdiff_t trgPad = regRegion + 0x006;
+static const ptrdiff_t trgCtr = regRegion + 0x008;
static const ptrdiff_t prdoutCtr = regRegion + 0x00a;
static const ptrdiff_t ardoutCtr = regRegion + 0x00c;
-static const ptrdiff_t adelCtr = regRegion + 0x00e;
-static const ptrdiff_t tagReg = regRegion + 0x010;
-static const ptrdiff_t lcReg = regRegion + 0x012;
+static const ptrdiff_t adelCtr = regRegion + 0x00e;
+static const ptrdiff_t tagReg = regRegion + 0x010;
+static const ptrdiff_t lcReg = regRegion + 0x012;
/* static const ptrdiff_t unused1 = regRegion + 0x014; */
/* static const ptrdiff_t unused2 = regRegion + 0x016; */
/* static const ptrdiff_t unused3 = regRegion + 0x018; */
/* static const ptrdiff_t unused4 = regRegion + 0x01a; */
-static const ptrdiff_t giopReg = regRegion + 0x01c;
-static const ptrdiff_t giopPad = regRegion + 0x01e;
+static const ptrdiff_t giopReg = regRegion + 0x01c;
+static const ptrdiff_t giopPad = regRegion + 0x01e;
/* CTRL register definitions */
-static unsigned short Rc_getCtrlReg(Rc * my) { return LVme_getW(my->lvme, ctrlReg); }
-static unsigned short Rc_getCtrlPad(Rc * my) { return LVme_getW(my->lvme, ctrlPad); }
-
-static void Rc_setReset(Rc * my) { LVme_setBitW(my->lvme, ctrlReg, 6); }
-static void Rc_clrReset(Rc * my) { LVme_clrBitW(my->lvme, ctrlReg, 6); }
-static int Rc_getReset(Rc * my) { return LVme_tstBitW(my->lvme, ctrlReg, 6); }
-static int Rc_padReset(Rc * my) { return LVme_tstBitW(my->lvme, ctrlPad, 6); }
-
-static void Rc_setMwr(Rc * my) { LVme_setBitW(my->lvme, ctrlReg, 7); }
-static void Rc_clrMwr(Rc * my) { LVme_clrBitW(my->lvme, ctrlReg, 7); }
-static int Rc_getMwr(Rc * my) { return LVme_tstBitW(my->lvme, ctrlReg, 7); }
-static int Rc_padMwr(Rc * my) { return LVme_tstBitW(my->lvme, ctrlPad, 7); }
-
-static void Rc_setMsel(Rc * my) { LVme_setBitW(my->lvme, ctrlReg, 8); }
-static void Rc_clrMsel(Rc * my) { LVme_clrBitW(my->lvme, ctrlReg, 8); }
-static int Rc_getMsel(Rc * my) { return LVme_tstBitW(my->lvme, ctrlReg, 8); }
-static int Rc_padMsel(Rc * my) { return LVme_tstBitW(my->lvme, ctrlPad, 8); }
-
-static void Rc_setEvtend(Rc * my) { LVme_setBitW(my->lvme, ctrlReg, 9); }
-static void Rc_clrEvtend(Rc * my) { LVme_clrBitW(my->lvme, ctrlReg, 9); }
-static int Rc_getEvtend(Rc * my) { return LVme_tstBitW(my->lvme, ctrlReg, 9); }
-static int Rc_padEvtend(Rc * my) { return LVme_tstBitW(my->lvme, ctrlPad, 9); }
-
-static void Rc_setEvtbeg(Rc * my) { LVme_setBitW(my->lvme, ctrlReg, 10); }
-static void Rc_clrEvtbeg(Rc * my) { LVme_clrBitW(my->lvme, ctrlReg, 10); }
-static int Rc_getEvtbeg(Rc * my) { return LVme_tstBitW(my->lvme, ctrlReg, 10); }
-static int Rc_padEvtbeg(Rc * my) { return LVme_tstBitW(my->lvme, ctrlPad, 10); }
-
-static void Rc_setSysclk(Rc * my) { LVme_setBitW(my->lvme, ctrlReg, 11); }
-static void Rc_clrSysclk(Rc * my) { LVme_clrBitW(my->lvme, ctrlReg, 11); }
-static int Rc_getSysclk(Rc * my) { return LVme_tstBitW(my->lvme, ctrlReg, 11); }
-static int Rc_padSysclk(Rc * my) { return LVme_tstBitW(my->lvme, ctrlPad, 11); }
-
-static void Rc_Cycle(Rc * my)
-{
- if(Rc_getSysclk(my))
- {
+static unsigned short Rc_getCtrlReg(Rc *my)
+{
+ return LVme_getW(my->lvme, ctrlReg);
+}
+static unsigned short Rc_getCtrlPad(Rc *my)
+{
+ return LVme_getW(my->lvme, ctrlPad);
+}
+
+static void Rc_setReset(Rc *my)
+{
+ LVme_setBitW(my->lvme, ctrlReg, 6);
+}
+static void Rc_clrReset(Rc *my)
+{
+ LVme_clrBitW(my->lvme, ctrlReg, 6);
+}
+static int Rc_getReset(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlReg, 6);
+}
+static int Rc_padReset(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlPad, 6);
+}
+
+static void Rc_setMwr(Rc *my)
+{
+ LVme_setBitW(my->lvme, ctrlReg, 7);
+}
+static void Rc_clrMwr(Rc *my)
+{
+ LVme_clrBitW(my->lvme, ctrlReg, 7);
+}
+static int Rc_getMwr(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlReg, 7);
+}
+static int Rc_padMwr(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlPad, 7);
+}
+
+static void Rc_setMsel(Rc *my)
+{
+ LVme_setBitW(my->lvme, ctrlReg, 8);
+}
+static void Rc_clrMsel(Rc *my)
+{
+ LVme_clrBitW(my->lvme, ctrlReg, 8);
+}
+static int Rc_getMsel(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlReg, 8);
+}
+static int Rc_padMsel(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlPad, 8);
+}
+
+static void Rc_setEvtend(Rc *my)
+{
+ LVme_setBitW(my->lvme, ctrlReg, 9);
+}
+static void Rc_clrEvtend(Rc *my)
+{
+ LVme_clrBitW(my->lvme, ctrlReg, 9);
+}
+static int Rc_getEvtend(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlReg, 9);
+}
+static int Rc_padEvtend(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlPad, 9);
+}
+
+static void Rc_setEvtbeg(Rc *my)
+{
+ LVme_setBitW(my->lvme, ctrlReg, 10);
+}
+static void Rc_clrEvtbeg(Rc *my)
+{
+ LVme_clrBitW(my->lvme, ctrlReg, 10);
+}
+static int Rc_getEvtbeg(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlReg, 10);
+}
+static int Rc_padEvtbeg(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlPad, 10);
+}
+
+static void Rc_setSysclk(Rc *my)
+{
+ LVme_setBitW(my->lvme, ctrlReg, 11);
+}
+static void Rc_clrSysclk(Rc *my)
+{
+ LVme_clrBitW(my->lvme, ctrlReg, 11);
+}
+static int Rc_getSysclk(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlReg, 11);
+}
+static int Rc_padSysclk(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlPad, 11);
+}
+
+static void Rc_Cycle(Rc *my)
+{
+ if (Rc_getSysclk(my)) {
Rc_clrSysclk(my);
Rc_setSysclk(my);
- }
- else
- {
+ } else {
Rc_setSysclk(my);
Rc_clrSysclk(my);
}
}
-
-static void Rc_setSwrq(Rc * my) { LVme_setBitW(my->lvme, ctrlReg, 12); }
-static void Rc_clrSwrq(Rc * my) { LVme_clrBitW(my->lvme, ctrlReg, 12); }
-static int Rc_getSwrq(Rc * my) { return LVme_tstBitW(my->lvme, ctrlReg, 12); }
-static int Rc_padSwrq(Rc * my) { return LVme_tstBitW(my->lvme, ctrlPad, 12); }
-static void Rc_setStop(Rc * my) { LVme_setBitW(my->lvme, ctrlReg, 13); }
-static void Rc_clrStop(Rc * my) { LVme_clrBitW(my->lvme, ctrlReg, 13); }
-static int Rc_getStop(Rc * my) { return LVme_tstBitW(my->lvme, ctrlReg, 13); }
-static int Rc_padStop(Rc * my) { return LVme_tstBitW(my->lvme, ctrlPad, 13); }
+static void Rc_setSwrq(Rc *my)
+{
+ LVme_setBitW(my->lvme, ctrlReg, 12);
+}
+static void Rc_clrSwrq(Rc *my)
+{
+ LVme_clrBitW(my->lvme, ctrlReg, 12);
+}
+static int Rc_getSwrq(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlReg, 12);
+}
+static int Rc_padSwrq(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlPad, 12);
+}
+
+static void Rc_setStop(Rc *my)
+{
+ LVme_setBitW(my->lvme, ctrlReg, 13);
+}
+static void Rc_clrStop(Rc *my)
+{
+ LVme_clrBitW(my->lvme, ctrlReg, 13);
+}
+static int Rc_getStop(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlReg, 13);
+}
+static int Rc_padStop(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlPad, 13);
+}
/* Magic numbers */
static const int PRDOUT = 0x00; /* Pattern readout (daisy chain) */
-static const int TEST = 0x01; /* Test Mode activation (buslike) */
+static const int TEST = 0x01; /* Test Mode activation (buslike) */
static const int ARDOUT = 0x02; /* Analog readout (daisy chain) */
-static const int ADEL = 0x03; /* Analog delete (buslike) */
-static const int RFIFO = 0x04; /* Reset FIFO (buslike) */
+static const int ADEL = 0x03; /* Analog delete (buslike) */
+static const int RFIFO = 0x04; /* Reset FIFO (buslike) */
static const int RDAISY = 0x05; /* Reset daisy chain (buslike) */
-static const int WCFG = 0x06; /* Write configuration (daisy chain) */
-static const int RCFG = 0x07; /* Read configuration (daisy chain) */
-static const int NOP = 0x0F; /* No OPeration - do nothing */
+static const int WCFG = 0x06; /* Write configuration (daisy chain) */
+static const int RCFG = 0x07; /* Read configuration (daisy chain) */
+static const int NOP = 0x0F; /* No OPeration - do nothing */
/* Test mode is available only in the GUF (Grand Unified Frontend) */
-static void Rc_setFc(Rc * my, int fc)
+static void Rc_setFc(Rc *my, int fc)
{
unsigned short savedCtrlReg;
savedCtrlReg = LVme_getW(my->lvme, ctrlReg);
- savedCtrlReg = ( savedCtrlReg & 0xFFF0 ) | ( fc & 0x000F );
+ savedCtrlReg = (savedCtrlReg & 0xFFF0) | (fc & 0x000F);
LVme_setW(my->lvme, ctrlReg, savedCtrlReg);
}
-static int Rc_getFc(Rc * my)
+static int Rc_getFc(Rc *my)
{
return LVme_getW(my->lvme, ctrlReg) & 0x000f;
}
-static void Rc_setError(Rc * my) { LVme_setBitW(my->lvme, ctrlReg, 4); }
-static void Rc_clrError(Rc * my) { LVme_clrBitW(my->lvme, ctrlReg, 4); }
-static int Rc_getError(Rc * my) { return LVme_tstBitW(my->lvme, ctrlReg, 4); }
-static int Rc_padError(Rc * my) { return LVme_tstBitW(my->lvme, ctrlPad, 4); }
+static void Rc_setError(Rc *my)
+{
+ LVme_setBitW(my->lvme, ctrlReg, 4);
+}
+static void Rc_clrError(Rc *my)
+{
+ LVme_clrBitW(my->lvme, ctrlReg, 4);
+}
+static int Rc_getError(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlReg, 4);
+}
+static int Rc_padError(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlPad, 4);
+}
-static void Rc_setRcbsy(Rc * my) { LVme_setBitW(my->lvme, ctrlReg, 5); }
-static void Rc_clrRcbsy(Rc * my) { LVme_clrBitW(my->lvme, ctrlReg, 5); }
-static int Rc_getRcbsy(Rc * my) { return LVme_tstBitW(my->lvme, ctrlReg, 5); }
-static int Rc_padRcbsy(Rc * my) { return LVme_tstBitW(my->lvme, ctrlPad, 5); }
+static void Rc_setRcbsy(Rc *my)
+{
+ LVme_setBitW(my->lvme, ctrlReg, 5);
+}
+static void Rc_clrRcbsy(Rc *my)
+{
+ LVme_clrBitW(my->lvme, ctrlReg, 5);
+}
+static int Rc_getRcbsy(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlReg, 5);
+}
+static int Rc_padRcbsy(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, ctrlPad, 5);
+}
/* TRG register definitions */
-static unsigned short Rc_getTrgReg(Rc * my) { return LVme_getW(my->lvme, trgReg); }
-static unsigned short Rc_getTrgPad(Rc * my) { return LVme_getW(my->lvme, trgPad); }
-
-static void Rc_setStrb0(Rc * my) { LVme_setBitW(my->lvme, trgReg, 0); }
-static void Rc_clrStrb0(Rc * my) { LVme_clrBitW(my->lvme, trgReg, 0); }
-static int Rc_getStrb0(Rc * my) { return LVme_tstBitW(my->lvme, trgReg, 0); }
-static int Rc_padStrb0(Rc * my) { return LVme_tstBitW(my->lvme, trgPad, 0); }
-
-static void Rc_setStrb1(Rc * my) { LVme_setBitW(my->lvme, trgReg, 1); }
-static void Rc_clrStrb1(Rc * my) { LVme_clrBitW(my->lvme, trgReg, 1); }
-static int Rc_getStrb1(Rc * my) { return LVme_tstBitW(my->lvme, trgReg, 1); }
-static int Rc_padStrb1(Rc * my) { return LVme_tstBitW(my->lvme, trgPad, 1); }
-
-static void Rc_setStrb2(Rc * my) { LVme_setBitW(my->lvme, trgReg, 2); }
-static void Rc_clrStrb2(Rc * my) { LVme_clrBitW(my->lvme, trgReg, 2); }
-static int Rc_getStrb2(Rc * my) { return LVme_tstBitW(my->lvme, trgReg, 2); }
-static int Rc_padStrb2(Rc * my) { return LVme_tstBitW(my->lvme, trgPad, 2); }
-
-static void Rc_setStrb3(Rc * my) { LVme_setBitW(my->lvme, trgReg, 3); }
-static void Rc_clrStrb3(Rc * my) { LVme_clrBitW(my->lvme, trgReg, 3); }
-static int Rc_getStrb3(Rc * my) { return LVme_tstBitW(my->lvme, trgReg, 3); }
-static int Rc_padStrb3(Rc * my) { return LVme_tstBitW(my->lvme, trgPad, 3); }
-
-static void Rc_setStrb4(Rc * my) { LVme_setBitW(my->lvme, trgReg, 4); }
-static void Rc_clrStrb4(Rc * my) { LVme_clrBitW(my->lvme, trgReg, 4); }
-static int Rc_getStrb4(Rc * my) { return LVme_tstBitW(my->lvme, trgReg, 4); }
-static int Rc_padStrb4(Rc * my) { return LVme_tstBitW(my->lvme, trgPad, 4); }
-
-static void Rc_setStrb5(Rc * my) { LVme_setBitW(my->lvme, trgReg, 5); }
-static void Rc_clrStrb5(Rc * my) { LVme_clrBitW(my->lvme, trgReg, 5); }
-static int Rc_getStrb5(Rc * my) { return LVme_tstBitW(my->lvme, trgReg, 5); }
-static int Rc_padStrb5(Rc * my) { return LVme_tstBitW(my->lvme, trgPad, 5); }
-
-static void Rc_setStrb6(Rc * my) { LVme_setBitW(my->lvme, trgReg, 6); }
-static void Rc_clrStrb6(Rc * my) { LVme_clrBitW(my->lvme, trgReg, 6); }
-static int Rc_getStrb6(Rc * my) { return LVme_tstBitW(my->lvme, trgReg, 6); }
-static int Rc_padStrb6(Rc * my) { return LVme_tstBitW(my->lvme, trgPad, 6); }
-
-static void Rc_setStrb7(Rc * my) { LVme_setBitW(my->lvme, trgReg, 7); }
-static void Rc_clrStrb7(Rc * my) { LVme_clrBitW(my->lvme, trgReg, 7); }
-static int Rc_getStrb7(Rc * my) { return LVme_tstBitW(my->lvme, trgReg, 7); }
-static int Rc_padStrb7(Rc * my) { return LVme_tstBitW(my->lvme, trgPad, 7); }
+static unsigned short Rc_getTrgReg(Rc *my)
+{
+ return LVme_getW(my->lvme, trgReg);
+}
+static unsigned short Rc_getTrgPad(Rc *my)
+{
+ return LVme_getW(my->lvme, trgPad);
+}
+
+static void Rc_setStrb0(Rc *my)
+{
+ LVme_setBitW(my->lvme, trgReg, 0);
+}
+static void Rc_clrStrb0(Rc *my)
+{
+ LVme_clrBitW(my->lvme, trgReg, 0);
+}
+static int Rc_getStrb0(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgReg, 0);
+}
+static int Rc_padStrb0(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgPad, 0);
+}
+
+static void Rc_setStrb1(Rc *my)
+{
+ LVme_setBitW(my->lvme, trgReg, 1);
+}
+static void Rc_clrStrb1(Rc *my)
+{
+ LVme_clrBitW(my->lvme, trgReg, 1);
+}
+static int Rc_getStrb1(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgReg, 1);
+}
+static int Rc_padStrb1(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgPad, 1);
+}
+
+static void Rc_setStrb2(Rc *my)
+{
+ LVme_setBitW(my->lvme, trgReg, 2);
+}
+static void Rc_clrStrb2(Rc *my)
+{
+ LVme_clrBitW(my->lvme, trgReg, 2);
+}
+static int Rc_getStrb2(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgReg, 2);
+}
+static int Rc_padStrb2(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgPad, 2);
+}
+
+static void Rc_setStrb3(Rc *my)
+{
+ LVme_setBitW(my->lvme, trgReg, 3);
+}
+static void Rc_clrStrb3(Rc *my)
+{
+ LVme_clrBitW(my->lvme, trgReg, 3);
+}
+static int Rc_getStrb3(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgReg, 3);
+}
+static int Rc_padStrb3(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgPad, 3);
+}
+
+static void Rc_setStrb4(Rc *my)
+{
+ LVme_setBitW(my->lvme, trgReg, 4);
+}
+static void Rc_clrStrb4(Rc *my)
+{
+ LVme_clrBitW(my->lvme, trgReg, 4);
+}
+static int Rc_getStrb4(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgReg, 4);
+}
+static int Rc_padStrb4(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgPad, 4);
+}
+
+static void Rc_setStrb5(Rc *my)
+{
+ LVme_setBitW(my->lvme, trgReg, 5);
+}
+static void Rc_clrStrb5(Rc *my)
+{
+ LVme_clrBitW(my->lvme, trgReg, 5);
+}
+static int Rc_getStrb5(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgReg, 5);
+}
+static int Rc_padStrb5(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgPad, 5);
+}
+
+static void Rc_setStrb6(Rc *my)
+{
+ LVme_setBitW(my->lvme, trgReg, 6);
+}
+static void Rc_clrStrb6(Rc *my)
+{
+ LVme_clrBitW(my->lvme, trgReg, 6);
+}
+static int Rc_getStrb6(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgReg, 6);
+}
+static int Rc_padStrb6(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgPad, 6);
+}
+
+static void Rc_setStrb7(Rc *my)
+{
+ LVme_setBitW(my->lvme, trgReg, 7);
+}
+static void Rc_clrStrb7(Rc *my)
+{
+ LVme_clrBitW(my->lvme, trgReg, 7);
+}
+static int Rc_getStrb7(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgReg, 7);
+}
+static int Rc_padStrb7(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgPad, 7);
+}
/* Range for port: 0...7; other values are dangerous and no checking for the correct value is done ! */
-static void Rc_setStrbPort(Rc * my, int port) { LVme_setBitW(my->lvme, trgReg, port & 0x07); }
-static void Rc_clrStrbPort(Rc * my, int port) { LVme_clrBitW(my->lvme, trgReg, port & 0x07); }
-static int Rc_getStrbPort(Rc * my, int port) { return LVme_tstBitW(my->lvme, trgReg, port & 0x07); }
-static int Rc_padStrbPort(Rc * my, int port) { return LVme_tstBitW(my->lvme, trgPad, port & 0x07); }
+static void Rc_setStrbPort(Rc *my, int port)
+{
+ LVme_setBitW(my->lvme, trgReg, port & 0x07);
+}
+static void Rc_clrStrbPort(Rc *my, int port)
+{
+ LVme_clrBitW(my->lvme, trgReg, port & 0x07);
+}
+static int Rc_getStrbPort(Rc *my, int port)
+{
+ return LVme_tstBitW(my->lvme, trgReg, port & 0x07);
+}
+static int Rc_padStrbPort(Rc *my, int port)
+{
+ return LVme_tstBitW(my->lvme, trgPad, port & 0x07);
+}
-static void Rc_StrobePort(Rc * my, int port)
+static void Rc_StrobePort(Rc *my, int port)
{
Rc_clrStrbPort(my, port);
Rc_setStrbPort(my, port);
}
-static void Rc_setDecision(Rc * my) { LVme_setBitW(my->lvme, trgReg, 8); }
-static void Rc_clrDecision(Rc * my) { LVme_clrBitW(my->lvme, trgReg, 8); }
-static int Rc_getDecision(Rc * my) { return LVme_tstBitW(my->lvme, trgReg, 8); }
-static int Rc_padDecision(Rc * my) { return LVme_tstBitW(my->lvme, trgPad, 8); }
+static void Rc_setDecision(Rc *my)
+{
+ LVme_setBitW(my->lvme, trgReg, 8);
+}
+static void Rc_clrDecision(Rc *my)
+{
+ LVme_clrBitW(my->lvme, trgReg, 8);
+}
+static int Rc_getDecision(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgReg, 8);
+}
+static int Rc_padDecision(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgPad, 8);
+}
-static void Rc_setArdout(Rc * my) { LVme_setBitW(my->lvme, trgReg, 9); }
-static void Rc_clrArdout(Rc * my) { LVme_clrBitW(my->lvme, trgReg, 9); }
-static int Rc_getArdout(Rc * my) { return LVme_tstBitW(my->lvme, trgReg, 9); }
-static int Rc_padArdout(Rc * my) { return LVme_tstBitW(my->lvme, trgPad, 9); }
+static void Rc_setArdout(Rc *my)
+{
+ LVme_setBitW(my->lvme, trgReg, 9);
+}
+static void Rc_clrArdout(Rc *my)
+{
+ LVme_clrBitW(my->lvme, trgReg, 9);
+}
+static int Rc_getArdout(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgReg, 9);
+}
+static int Rc_padArdout(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgPad, 9);
+}
-static void Rc_setPrdout(Rc * my) { LVme_setBitW(my->lvme, trgReg, 10); }
-static void Rc_clrPrdout(Rc * my) { LVme_clrBitW(my->lvme, trgReg, 10); }
-static int Rc_getPrdout(Rc * my) { return LVme_tstBitW(my->lvme, trgReg, 10); }
-static int Rc_padPrdout(Rc * my) { return LVme_tstBitW(my->lvme, trgPad, 10); }
+static void Rc_setPrdout(Rc *my)
+{
+ LVme_setBitW(my->lvme, trgReg, 10);
+}
+static void Rc_clrPrdout(Rc *my)
+{
+ LVme_clrBitW(my->lvme, trgReg, 10);
+}
+static int Rc_getPrdout(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgReg, 10);
+}
+static int Rc_padPrdout(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgPad, 10);
+}
-static void Rc_setBegrun(Rc * my) { LVme_setBitW(my->lvme, trgReg, 11); }
-static void Rc_clrBegrun(Rc * my) { LVme_clrBitW(my->lvme, trgReg, 11); }
-static int Rc_getBegrun(Rc * my) { return LVme_tstBitW(my->lvme, trgReg, 11); }
-static int Rc_padBegrun(Rc * my) { return LVme_tstBitW(my->lvme, trgPad, 11); }
+static void Rc_setBegrun(Rc *my)
+{
+ LVme_setBitW(my->lvme, trgReg, 11);
+}
+static void Rc_clrBegrun(Rc *my)
+{
+ LVme_clrBitW(my->lvme, trgReg, 11);
+}
+static int Rc_getBegrun(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgReg, 11);
+}
+static int Rc_padBegrun(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgPad, 11);
+}
-static void Rc_setTagclk(Rc * my) { LVme_setBitW(my->lvme, trgReg, 12); }
-static void Rc_clrTagclk(Rc * my) { LVme_clrBitW(my->lvme, trgReg, 12); }
-static int Rc_getTagclk(Rc * my) { return LVme_tstBitW(my->lvme, trgReg, 12); }
-static int Rc_padTagclk(Rc * my) { return LVme_tstBitW(my->lvme, trgPad, 12); }
+static void Rc_setTagclk(Rc *my)
+{
+ LVme_setBitW(my->lvme, trgReg, 12);
+}
+static void Rc_clrTagclk(Rc *my)
+{
+ LVme_clrBitW(my->lvme, trgReg, 12);
+}
+static int Rc_getTagclk(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgReg, 12);
+}
+static int Rc_padTagclk(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgPad, 12);
+}
-static void Rc_setTagdata(Rc * my) { LVme_setBitW(my->lvme, trgReg, 13); }
-static void Rc_clrTagdata(Rc * my) { LVme_clrBitW(my->lvme, trgReg, 13); }
-static int Rc_getTagdata(Rc * my) { return LVme_tstBitW(my->lvme, trgReg, 13); }
-static int Rc_padTagdata(Rc * my) { return LVme_tstBitW(my->lvme, trgPad, 13); }
+static void Rc_setTagdata(Rc *my)
+{
+ LVme_setBitW(my->lvme, trgReg, 13);
+}
+static void Rc_clrTagdata(Rc *my)
+{
+ LVme_clrBitW(my->lvme, trgReg, 13);
+}
+static int Rc_getTagdata(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgReg, 13);
+}
+static int Rc_padTagdata(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgPad, 13);
+}
-static void Rc_setTbsy(Rc * my) { LVme_setBitW(my->lvme, trgReg, 14); }
-static void Rc_clrTbsy(Rc * my) { LVme_clrBitW(my->lvme, trgReg, 14); }
-static int Rc_getTbsy(Rc * my) { return LVme_tstBitW(my->lvme, trgReg, 14); }
-static int Rc_padTbsy(Rc * my) { return LVme_tstBitW(my->lvme, trgPad, 14); }
+static void Rc_setTbsy(Rc *my)
+{
+ LVme_setBitW(my->lvme, trgReg, 14);
+}
+static void Rc_clrTbsy(Rc *my)
+{
+ LVme_clrBitW(my->lvme, trgReg, 14);
+}
+static int Rc_getTbsy(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgReg, 14);
+}
+static int Rc_padTbsy(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgPad, 14);
+}
-static void Rc_setTrg(Rc * my) { LVme_setBitW(my->lvme, trgReg, 15); }
-static void Rc_clrTrg(Rc * my) { LVme_clrBitW(my->lvme, trgReg, 15); }
-static int Rc_getTrg(Rc * my) { return LVme_tstBitW(my->lvme, trgReg, 15); }
-static int Rc_padTrg(Rc * my) { return LVme_tstBitW(my->lvme, trgPad, 15); }
+static void Rc_setTrg(Rc *my)
+{
+ LVme_setBitW(my->lvme, trgReg, 15);
+}
+static void Rc_clrTrg(Rc *my)
+{
+ LVme_clrBitW(my->lvme, trgReg, 15);
+}
+static int Rc_getTrg(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgReg, 15);
+}
+static int Rc_padTrg(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, trgPad, 15);
+}
-static void Rc_TriggerPort(Rc * my)
+static void Rc_TriggerPort(Rc *my)
{
Rc_clrTrg(my);
Rc_setTrg(my);
}
/* Status counter access */
-static unsigned short Rc_getTrgCtr(Rc * my) { return LVme_getW(my->lvme, trgCtr); }
-static unsigned short Rc_getPrdoutCtr(Rc * my) { return LVme_getW(my->lvme, prdoutCtr); }
-static unsigned short Rc_getArdoutCtr(Rc * my) { return LVme_getW(my->lvme, ardoutCtr); }
-static unsigned short Rc_getAdelCtr(Rc * my) { return LVme_getW(my->lvme, adelCtr); }
+static unsigned short Rc_getTrgCtr(Rc *my)
+{
+ return LVme_getW(my->lvme, trgCtr);
+}
+static unsigned short Rc_getPrdoutCtr(Rc *my)
+{
+ return LVme_getW(my->lvme, prdoutCtr);
+}
+static unsigned short Rc_getArdoutCtr(Rc *my)
+{
+ return LVme_getW(my->lvme, ardoutCtr);
+}
+static unsigned short Rc_getAdelCtr(Rc *my)
+{
+ return LVme_getW(my->lvme, adelCtr);
+}
-static void Rc_setRctr(Rc * my) { LVme_setBitW(my->lvme, ctrlReg, 15); }
-static void Rc_clrRctr(Rc * my) { LVme_clrBitW(my->lvme, ctrlReg, 15); }
+static void Rc_setRctr(Rc *my)
+{
+ LVme_setBitW(my->lvme, ctrlReg, 15);
+}
+static void Rc_clrRctr(Rc *my)
+{
+ LVme_clrBitW(my->lvme, ctrlReg, 15);
+}
-static void Rc_ClrCtrs(Rc * my)
+static void Rc_ClrCtrs(Rc *my)
{
Rc_setRctr(my);
Rc_clrRctr(my);
/* TAG register definitions */
/* This register contains the last distributed SubEventTag */
-static unsigned short Rc_getTagReg(Rc * my) { return LVme_getW(my->lvme, tagReg); }
+static unsigned short Rc_getTagReg(Rc *my)
+{
+ return LVme_getW(my->lvme, tagReg);
+}
/* LC register definitions */
/* This register contains information on the last command delivered by the DTU_RICH as well */
/* missing acknowledge of the RC99 hardware can be easily detected. */
/* Do not use this function alone ! */
-static unsigned short Rc_getLcReg(Rc * my) { return LVme_getW(my->lvme, lcReg); }
+static unsigned short Rc_getLcReg(Rc *my)
+{
+ return LVme_getW(my->lvme, lcReg);
+}
-static unsigned short Rc_getLcStatus(Rc * my)
+static unsigned short Rc_getLcStatus(Rc *my)
{
unsigned short LcStatus = 0x0000;
return LcStatus = (Rc_getLcReg(my) & 0x001f);
/* By default, these pads are unconnected and can be used for test purposes. */
/* Do not use these functions alone ! */
-static unsigned short Rc_getgiopReg(Rc * my) { return LVme_getW(my->lvme, giopReg); }
-static unsigned short Rc_getgiopPad(Rc * my) { return LVme_getW(my->lvme, giopPad); }
+static unsigned short Rc_getgiopReg(Rc *my)
+{
+ return LVme_getW(my->lvme, giopReg);
+}
+static unsigned short Rc_getgiopPad(Rc *my)
+{
+ return LVme_getW(my->lvme, giopPad);
+}
-static unsigned short Rc_getInterfaceVersion(Rc * my)
+static unsigned short Rc_getInterfaceVersion(Rc *my)
{
- short giopPadValue;
- giopPadValue = (0xFF00 & Rc_getgiopPad(my)) >> 8;
- return giopPadValue;
+ short giopPadValue;
+ giopPadValue = (0xFF00 & Rc_getgiopPad(my)) >> 8;
+ return giopPadValue;
}
*********************************/
/* Offsets for MEMORY2 registers */
-static const ptrdiff_t statusid = regRegion + 0x100;
-static const ptrdiff_t bugreg = regRegion + 0x102;
-static const ptrdiff_t memreg = regRegion + 0x104;
-static const ptrdiff_t pages = regRegion + 0x106;
+static const ptrdiff_t statusid = regRegion + 0x100;
+static const ptrdiff_t bugreg = regRegion + 0x102;
+static const ptrdiff_t memreg = regRegion + 0x104;
+static const ptrdiff_t pages = regRegion + 0x106;
static const ptrdiff_t sedec_high = regRegion + 0x108;
-static const ptrdiff_t sedec_low = regRegion + 0x10a;
-static const ptrdiff_t seid_high = regRegion + 0x10c;
-static const ptrdiff_t seid_low = regRegion + 0x10e;
+static const ptrdiff_t sedec_low = regRegion + 0x10a;
+static const ptrdiff_t seid_high = regRegion + 0x10c;
+static const ptrdiff_t seid_low = regRegion + 0x10e;
static const ptrdiff_t versionMem = regRegion + 0x110;
-static const ptrdiff_t swCtr = regRegion + 0x112;
-static const ptrdiff_t codeMem = regRegion + 0x114;
+static const ptrdiff_t swCtr = regRegion + 0x112;
+static const ptrdiff_t codeMem = regRegion + 0x114;
/* static const ptrdiff_t unused3 = regRegion + 0x116; */
/* static const ptrdiff_t unused4 = regRegion + 0x118; */
/* static const ptrdiff_t unused5 = regRegion + 0x11a; */
/* static const ptrdiff_t unused7 = regRegion + 0x11e; */
/* STATUSID register */
-static unsigned int Rc_readStatusid(Rc * my)
+static unsigned int Rc_readStatusid(Rc *my)
{
int realId;
realId = 0x00FF & LVme_getW(my->lvme, statusid);
return realId;
}
-static void Rc_writeStatusid(Rc * my, unsigned char value)
+static void Rc_writeStatusid(Rc *my, unsigned char value)
{
unsigned short savedStatusId;
savedStatusId = LVme_getW(my->lvme, statusid);
- savedStatusId = ( savedStatusId & 0xFF00 ) | ( value & 0x00FF );
+ savedStatusId = (savedStatusId & 0xFF00) | (value & 0x00FF);
LVme_setW(my->lvme, statusid, savedStatusId);
}
-static unsigned short Rc_getStatusID(Rc * my)
+static unsigned short Rc_getStatusID(Rc *my)
{
return LVme_getW(my->lvme, statusid);
}
-static void Rc_setIrqR(Rc * my) { LVme_setBitW(my->lvme, statusid, 15); }
-static void Rc_clrIrqR(Rc * my) { LVme_clrBitW(my->lvme, statusid, 15); }
-static int Rc_getIrqR(Rc * my) { return LVme_tstBitW(my->lvme, statusid, 15); }
-static void Rc_setIrqS(Rc * my) { LVme_setBitW(my->lvme, statusid, 14); }
-static void Rc_clrIrqS(Rc * my) { LVme_clrBitW(my->lvme, statusid, 14); }
-static int Rc_getIrqS(Rc * my) { return LVme_tstBitW(my->lvme, statusid, 14); }
+static void Rc_setIrqR(Rc *my)
+{
+ LVme_setBitW(my->lvme, statusid, 15);
+}
+static void Rc_clrIrqR(Rc *my)
+{
+ LVme_clrBitW(my->lvme, statusid, 15);
+}
+static int Rc_getIrqR(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, statusid, 15);
+}
+static void Rc_setIrqS(Rc *my)
+{
+ LVme_setBitW(my->lvme, statusid, 14);
+}
+static void Rc_clrIrqS(Rc *my)
+{
+ LVme_clrBitW(my->lvme, statusid, 14);
+}
+static int Rc_getIrqS(Rc *my)
+{
+ return LVme_tstBitW(my->lvme, statusid, 14);
+}
-static void Rc_IrqRon(Rc * my)
+static void Rc_IrqRon(Rc *my)
{
Rc_setIrqR(my);
}
-static void Rc_IrqRoff(Rc * my)
+static void Rc_IrqRoff(Rc *my)
{
Rc_clrIrqR(my);
}
-static void Rc_IrqSon(Rc * my)
+static void Rc_IrqSon(Rc *my)
{
Rc_setIrqS(my);
}
-static void Rc_IrqSoff(Rc * my)
+static void Rc_IrqSoff(Rc *my)
{
Rc_clrIrqS(my);
}
/* BUG register */
-static unsigned short Rc_getBug(Rc * my)
+static unsigned short Rc_getBug(Rc *my)
{
return LVme_getW(my->lvme, bugreg);
}
/* MEMREG register */
/* Do not use this function alone */
-static unsigned short Rc_readMemreg(Rc * my)
+static unsigned short Rc_readMemreg(Rc *my)
{
return LVme_getW(my->lvme, memreg);
}
+
/* Do not use this function alone */
-static void Rc_writeMemreg(Rc * my, unsigned short value)
+static void Rc_writeMemreg(Rc *my, unsigned short value)
{
LVme_setW(my->lvme, memreg, value);
}
-static void Rc_setMemfull(Rc * my, unsigned short pages)
+static void Rc_setMemfull(Rc *my, unsigned short pages)
{
unsigned short realMemreg = 0x0000;
- pages = pages & 0x07FF; /* PAGES auf untere 11 bits begrenzen */
- if(pages == 0x0000)
- {
- pages++; /* PAGES muss groesser 1 sein (RCBSY) */
- }
- realMemreg = Rc_readMemreg(my); /* Altes Memreg retten */
- realMemreg = realMemreg & 0xF800 ; /* Alte PAGES loeschen */
- realMemreg = realMemreg | pages ; /* Neue PAGES einblenden */
- Rc_writeMemreg(my, realMemreg); /* Memreg zurueckschreiben */
+ pages = pages & 0x07FF; /* PAGES auf untere 11 bits begrenzen */
+ if (pages == 0x0000) {
+ pages++; /* PAGES muss groesser 1 sein (RCBSY) */
+ }
+ realMemreg = Rc_readMemreg(my); /* Altes Memreg retten */
+ realMemreg = realMemreg & 0xF800; /* Alte PAGES loeschen */
+ realMemreg = realMemreg | pages; /* Neue PAGES einblenden */
+ Rc_writeMemreg(my, realMemreg); /* Memreg zurueckschreiben */
}
/* PAGES register */
/* Do not use this function alone */
-static unsigned short Rc_readPages(Rc * my)
+static unsigned short Rc_readPages(Rc *my)
{
return LVme_getW(my->lvme, pages);
}
static unsigned short Rc_getPages(Rc *my)
{
- unsigned short realPages = 0x0000;
- realPages = Rc_readPages(my); /* read PAGES content */
- realPages = realPages & 0x07ff; /* mask the number out */
+ unsigned short realPages = 0x0000;
+ realPages = Rc_readPages(my); /* read PAGES content */
+ realPages = realPages & 0x07ff; /* mask the number out */
return realPages; /* return value */
}
-static void Rc_waitSwitchcomplete(Rc * my)
+static void Rc_waitSwitchcomplete(Rc *my)
{
- unsigned short realPages = 0x0000;
- realPages = Rc_readPages(my); /* Altes Register retten */
- realPages = realPages & 0xc000; /* oberste zwei Bits anschauen */
- while((realPages != 0x0000) || (realPages != 0xc000)) /* Schleife, bis beide Bits gleich */
- {
- realPages = (Rc_readPages(my) & 0xc000); /* immer wieder reingucken */
+ unsigned short realPages = 0x0000;
+ realPages = Rc_readPages(my); /* Altes Register retten */
+ realPages = realPages & 0xc000; /* oberste zwei Bits anschauen */
+ while ((realPages != 0x0000) || (realPages != 0xc000)) { /* Schleife, bis beide Bits gleich */
+ realPages = (Rc_readPages(my) & 0xc000); /* immer wieder reingucken */
}
}
-static int Rc_bankRequested(Rc * my)
+static int Rc_bankRequested(Rc *my)
{
unsigned short realPages = 0x0000;
realPages = Rc_readPages(my);
realPages = ((realPages & 0x4000) >> 14);
return (int) realPages;
}
-static int Rc_bankConfirmed(Rc * my)
+static int Rc_bankConfirmed(Rc *my)
{
unsigned short realPages = 0x0000;
realPages = Rc_readPages(my);
realPages = ((realPages & 0x8000) >> 15);
return (int) realPages;
}
-static int Rc_SwitchStatus(Rc * my)
+static int Rc_SwitchStatus(Rc *my)
{
unsigned short realPages = 0x0000;
realPages = Rc_readPages(my);
0x01: Bank A requested, request still pending
0x00: Bank B requested and activated */
}
-static int Rc_testMemfull(Rc * my)
+static int Rc_testMemfull(Rc *my)
{
unsigned short realPages = 0x0000;
realPages = Rc_readPages(my);
}
/* SEDEC_HIGH register */
-static unsigned short Rc_readSedec_high(Rc * my)
+static unsigned short Rc_readSedec_high(Rc *my)
{
return LVme_getW(my->lvme, sedec_high);
}
-static void Rc_writeSedec_high(Rc * my, unsigned short value)
+static void Rc_writeSedec_high(Rc *my, unsigned short value)
{
LVme_setW(my->lvme, sedec_high, value);
}
/* SEDEC_LOW register */
-static unsigned short Rc_readSedec_low(Rc * my)
+static unsigned short Rc_readSedec_low(Rc *my)
{
return LVme_getW(my->lvme, sedec_low);
}
-static void Rc_writeSedec_low(Rc * my, unsigned short value)
+static void Rc_writeSedec_low(Rc *my, unsigned short value)
{
LVme_setW(my->lvme, sedec_low, value);
}
/* SEID_HIGH register */
-static unsigned short Rc_readSeid_high(Rc * my)
+static unsigned short Rc_readSeid_high(Rc *my)
{
return LVme_getW(my->lvme, seid_high);
}
-static void Rc_writeSeid_high(Rc * my, unsigned short value)
+static void Rc_writeSeid_high(Rc *my, unsigned short value)
{
LVme_setW(my->lvme, seid_high, value);
}
/* SEID_LOW register */
-static unsigned short Rc_readSeid_low(Rc * my)
+static unsigned short Rc_readSeid_low(Rc *my)
{
return LVme_getW(my->lvme, seid_low);
}
-static void Rc_writeSeid_low(Rc * my, unsigned short value)
+static void Rc_writeSeid_low(Rc *my, unsigned short value)
{
LVme_setW(my->lvme, seid_low, value);
}
/* VERSIONMEM register */
-static unsigned short Rc_readVersionMem(Rc * my)
+static unsigned short Rc_readVersionMem(Rc *my)
{
return LVme_getW(my->lvme, versionMem);
}
/* SWCTR register */
-static unsigned short Rc_readSwCtr(Rc * my)
+static unsigned short Rc_readSwCtr(Rc *my)
{
return LVme_getW(my->lvme, swCtr);
}
LVme_setW(my->lvme, codeMem, 0xc0de);
- do
- {
+ do {
word = LVme_getW(my->lvme, codeMem);
low = word & 0xff;
high = (word >> 8) & 0xff;
fame[i++] = high;
fame[i++] = low;
-
+
}
- while(high != 0 || low != 0);
+ while (high != 0 || low != 0);
printf(fame);
}
/* Offsets for TIMING2 registers */
static const ptrdiff_t evtgReg = busRegion + 0x100;
-static const ptrdiff_t errReg = busRegion + 0x102;
-static const ptrdiff_t mskReg = busRegion + 0x104;
-static const ptrdiff_t stwReg = busRegion + 0x106;
+static const ptrdiff_t errReg = busRegion + 0x102;
+static const ptrdiff_t mskReg = busRegion + 0x104;
+static const ptrdiff_t stwReg = busRegion + 0x106;
/* EVTG-Register read/write (16bit wide) */
-static unsigned short Rc_readEvtgreg(Rc * my)
+static unsigned short Rc_readEvtgreg(Rc *my)
{
return LVme_getW(my->lvme, evtgReg);
}
-static void Rc_writeEvtgreg(Rc * my, unsigned short value)
+static void Rc_writeEvtgreg(Rc *my, unsigned short value)
{
LVme_setW(my->lvme, evtgReg, value);
}
/* ERR-Register read; write resets register to zero (8bit wide) */
-static int Rc_readErrreg(Rc * my)
+static int Rc_readErrreg(Rc *my)
{
return LVme_getW(my->lvme, errReg);
}
-static void Rc_writeErrreg(Rc * my, int value)
+static void Rc_writeErrreg(Rc *my, int value)
{
unsigned short realValue = 0x0000;
- realValue = 0x0000 | value;
+ realValue = 0x0000 | value;
LVme_setW(my->lvme, errReg, realValue);
}
/* MSK-Register read/write (8bit wide) */
-static int Rc_readMskreg(Rc * my)
+static int Rc_readMskreg(Rc *my)
{
return LVme_getW(my->lvme, mskReg);
}
-static void Rc_writeMskreg(Rc * my, int value)
+static void Rc_writeMskreg(Rc *my, int value)
{
unsigned short realValue = 0x0000;
- realValue = 0x0000 | value;
+ realValue = 0x0000 | value;
LVme_setW(my->lvme, mskReg, realValue);
}
/* STW-Register read/write (8bit wide) */
-static int Rc_readStwreg(Rc * my)
+static int Rc_readStwreg(Rc *my)
{
return LVme_getW(my->lvme, stwReg);
}
-static void Rc_writeStwreg(Rc * my, int value)
+static void Rc_writeStwreg(Rc *my, int value)
{
unsigned short realValue = 0x0000;
realValue = 0x0000 | value;
* Port XC part *
****************/
-static const ptrdiff_t Pstatus = busRegion + 0x002;
-static const ptrdiff_t Pcontrol = busRegion + 0x008;
+static const ptrdiff_t Pstatus = busRegion + 0x002;
+static const ptrdiff_t Pcontrol = busRegion + 0x008;
static const ptrdiff_t portOffset = 0x020;
-static unsigned short Rc_getPstat(Rc * my, int port)
-{
+static unsigned short Rc_getPstat(Rc *my, int port)
+{
port = port & 0x07;
- return LVme_getW(my->lvme, (port * portOffset + Pstatus));
+ return LVme_getW(my->lvme, (port * portOffset + Pstatus));
}
-static unsigned short Rc_getPctrl(Rc * my, int port)
-{
+static unsigned short Rc_getPctrl(Rc *my, int port)
+{
port = port & 0x07;
- return LVme_getW(my->lvme, (port * portOffset + Pcontrol));
+ return LVme_getW(my->lvme, (port * portOffset + Pcontrol));
}
/* ENXCFG bit: enable configuration of frontend FPGAs */
-static void Rc_setXcfg(Rc * my, int port)
+static void Rc_setXcfg(Rc *my, int port)
{
- LVme_setBitW(my->lvme, port * portOffset + Pcontrol, 0);
+ LVme_setBitW(my->lvme, port * portOffset + Pcontrol, 0);
}
-static void Rc_clrXcfg(Rc * my, int port)
+static void Rc_clrXcfg(Rc *my, int port)
{
- LVme_clrBitW(my->lvme, port * portOffset + Pcontrol, 0);
+ LVme_clrBitW(my->lvme, port * portOffset + Pcontrol, 0);
}
-static int Rc_getXcfg(Rc * my, int port)
+static int Rc_getXcfg(Rc *my, int port)
{
- return LVme_tstBitW(my->lvme, port * portOffset + Pcontrol, 0);
+ return LVme_tstBitW(my->lvme, port * portOffset + Pcontrol, 0);
}
-/***************
+/***************
* Memory part *
* *
***************/
-static unsigned long Rc_readMem(Rc * my, unsigned long offsetValue)
+static unsigned long Rc_readMem(Rc *my, unsigned long offsetValue)
{
return LVme_getL(my->lvme, memRegion + offsetValue);
}
-static void Rc_writeMem(Rc * my, unsigned long offsetValue, unsigned long value)
+static void Rc_writeMem(Rc *my, unsigned long offsetValue, unsigned long value)
{
LVme_setL(my->lvme, memRegion + offsetValue, value);
}
-static void Rc_clearMem(Rc * my)
+static void Rc_clearMem(Rc *my)
{
long i;
- const long memSize = 0x80000;
+ const long memSize = 0x80000;
const long clearValue = 0x00000000;
- for(i = 0; i < memSize; i = i + 0x04)
- {
+ for (i = 0; i < memSize; i = i + 0x04) {
Rc_writeMem(my, i, clearValue);
}
}
-static long Rc_testMem(Rc * my)
+static long Rc_testMem(Rc *my)
{
long i;
- const long memSize = 0x80000;
+ const long memSize = 0x80000;
const long clearValue = 0x00000000;
unsigned long different = 0x00000000;
unsigned long memValue = 0x00000000;
- for(i = 0; i < memSize; i = i + 0x04)
- {
+ for (i = 0; i < memSize; i = i + 0x04) {
memValue = Rc_readMem(my, i);
- if(memValue != clearValue)
- {
+ if (memValue != clearValue) {
different++;
printf("A: 0x%08x: 0x%08x\n", i, memValue);
}
* *
***********************/
-static unsigned short Rc_readDpr(Rc * my, unsigned long offsetValue)
+static unsigned short Rc_readDpr(Rc *my, unsigned long offsetValue)
{
unsigned long realValue = 0x00000000;
realValue = LVme_getL(my->lvme, dprRegion + offsetValue);
realValue = 0x0000FFFF & realValue;
return realValue;
}
-static void Rc_writeDpr(Rc * my, unsigned long offsetValue, unsigned short value)
+static void Rc_writeDpr(Rc *my, unsigned long offsetValue, unsigned short value)
{
unsigned long realValue;
realValue = 0x0000FFFF & value;
LVme_setL(my->lvme, dprRegion + offsetValue, realValue);
}
-static void Rc_clearDpr(Rc * my)
+static void Rc_clearDpr(Rc *my)
{
unsigned short i;
- const unsigned short dprSize = 0x8000;
+ const unsigned short dprSize = 0x8000;
const unsigned short clearValue = 0x0000;
- for(i = 0; i < dprSize; i = i + 0x04)
- {
- if (i % 256 == 0)
- {
+ for (i = 0; i < dprSize; i = i + 0x04) {
+ if (i % 256 == 0) {
printf(".");
}
Rc_writeDpr(my, i, clearValue);
}
printf("\n");
}
-static unsigned short Rc_testDpr(Rc * my)
+static unsigned short Rc_testDpr(Rc *my)
{
unsigned short i;
- const unsigned short dprSize = 0x8000;
+ const unsigned short dprSize = 0x8000;
const unsigned short clearValue = 0x0000;
unsigned short different = 0x0000;
unsigned short memValue = 0x0000;
- for(i = 0; i < dprSize; i = i + 0x04)
- {
+ for (i = 0; i < dprSize; i = i + 0x04) {
memValue = Rc_readDpr(my, i);
- if(memValue != clearValue)
- {
+ if (memValue != clearValue) {
different++;
printf(" -> A: 0x%08x: 0x%04x\n", i, memValue);
}
* *
************************/
-static void Rc_writeDB(Rc * my, ptrdiff_t offset, unsigned short data)
+static void Rc_writeDB(Rc *my, ptrdiff_t offset, unsigned short data)
{
LVme_setW(my->lvme, busRegion + offset, data);
}
-static unsigned short Rc_readDB(Rc * my, ptrdiff_t offset)
+static unsigned short Rc_readDB(Rc *my, ptrdiff_t offset)
{
return LVme_getW(my->lvme, busRegion + offset);
}
-/* This is a comment */
+/* This is a comment */
#endif
-
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/readout.c,v 6.24 2002-10-09 16:00:20 hadaq Exp $";
+
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/readout.c,v 6.25 2003-03-02 15:50:10 hadaq Exp $";
#define _POSIX_C_SOURCE 199309L
#define SYSLOG_NAMES
unsigned long queueSize;
char verbosity[PARAM_MAX_VALUE_LEN];
char subsystem[PARAM_MAX_VALUE_LEN];
-} TheArgs;
+}
+
+TheArgs;
static jmp_buf terminateJmp;
syslog(LOG_ERR, "Usage: [-q queueSize] [-w waterMark]");
}
-static void argsDump(TheArgs *my) {
+static void argsDump(TheArgs *my)
+{
syslog(LOG_DEBUG, "waterMark: %d", my->waterMark);
syslog(LOG_DEBUG, "priority: %d", my->priority);
syslog(LOG_DEBUG, "isStandalone: %d", my->isStandalone);
syslog(LOG_DEBUG, "subsystem: %s", my->subsystem);
}
-static void argsDefault(TheArgs *my) {
+static void argsDefault(TheArgs *my)
+{
my->waterMark = 56 * 1024;
my->priority = 0;
my->isStandalone = 1;
strcpy(my->subsystem, "unknown");
}
-static int argsFromCL(TheArgs *my, int argc, char *argv[]) {
+static int argsFromCL(TheArgs *my, int argc, char *argv[])
+{
extern char *optarg;
int i;
return 0;
}
-static int argsFromParam(TheArgs *my, int argc, char *argv[]) {
+static int argsFromParam(TheArgs *my, int argc, char *argv[])
+{
Param paramS, *param = ¶mS;
int paramWasFound;
desParam(param);
}
-static void storeInfoStart(const char *n, time_t t, TheArgs *my) {
+static void storeInfoStart(const char *n, time_t t, TheArgs *my)
+{
Param pS, *p = &pS;
int i;
char s[20];
desParam(p);
}
-static void storeInfoStop(const char *n, time_t t, Worker *w) {
+static void storeInfoStop(const char *n, time_t t, Worker *w)
+{
Param pS, *p = &pS;
int i;
char s[20];
conSetupParam(p, getenv("DAQ_SETUP"));
- for ( i = 0; i < 32 && strcmp(w->statistics[i].name, "") != 0; i++) {
+ for (i = 0; i < 32 && strcmp(w->statistics[i].name, "") != 0; i++) {
Param_storeInt(p, n, w->statistics[i].name, w->statistics[i].value);
}
strftime(s, 20, "%Y-%m-%dT%H:%M:%S", localtime(&t));
desParam(p);
}
-int main(int argc, char *argv[])
+int main(int argc, char *argv[])
{
int i;
TheArgs theArgsS, *theArgs = &theArgsS;
unsigned long *subevtsRead;
unsigned long *subevtsDataErr;
- openlog(argv[0], LOG_PID|LOG_PERROR, LOG_LOCAL0);
+ openlog(argv[0], LOG_PID | LOG_PERROR, LOG_LOCAL0);
setlogmask(LOG_UPTO(LOG_INFO));
usage(argv[0]);
goto bailOut0;
}
-
for (i = 0; prioritynames[i].c_name != NULL
- && 0 != strcmp(prioritynames[i].c_name, theArgs->verbosity); i++) {
+ && 0 != strcmp(prioritynames[i].c_name, theArgs->verbosity); i++) {
}
if (prioritynames[i].c_name == NULL) {
goto bailOut0;
}
if (NULL == (shmTrans = ShmTrans_open("subevtqueue", 2 * theArgs->queueSize))) {
syslog(LOG_ERR,
- "opening shared memory \"%s\": %s", "subevtqueue", strerror(errno));
+ "opening shared memory \"%s\": %s", "subevtqueue", strerror(errno));
goto bailOut2;
}
trigAccepted = Worker_addStatistic(worker, "trigAccepted");
storeInfoStart(argv[0], time(NULL), theArgs);
Worker_initEnd(worker);
-
+
/* at somewhat more than the HadTuQueue header must fit into watermark */
if (theArgs->waterMark < HadTu_hdrSize()) {
theArgs->waterMark = HadTu_hdrSize();
}
-
while (setjmp(terminateJmp) == 0) {
void *hadTu;
HadTuQueue *hadTuQueue;
- size_t transportSize = theArgs->waterMark + Hardware_maxSubEvtSize(hw) + + sizeof(long); /* BUGBUG HadTuQueue truncates size to alignment, so add sizeof(long) here */
+ size_t transportSize = theArgs->waterMark + Hardware_maxSubEvtSize(hw) + +sizeof(long); /* BUGBUG HadTuQueue truncates size to alignment, so add sizeof(long) here */
Worker_dump(worker, 1);
hadTu = ShmTrans_alloc(shmTrans, transportSize);
#ifndef NDEBUG
syslog(LOG_DEBUG,
- "shmTrans: %p = hadTu: %s", hadTu, HadTu_2charP(hadTu));
+ "shmTrans: %p = hadTu: %s", hadTu, HadTu_2charP(hadTu));
#endif
hadTuQueue = malloc(HadTuQueue_sizeOf());
conHadTuQueue(hadTuQueue, hadTu, transportSize);
while (
- HadTuQueue_size(hadTuQueue) <= theArgs->waterMark
- && NULL != (subEvt = HadTuQueue_alloc(hadTuQueue, Hardware_maxSubEvtSize(hw)))
- ) {
+ HadTuQueue_size(hadTuQueue) <= theArgs->waterMark
+ && NULL != (subEvt = HadTuQueue_alloc(hadTuQueue, Hardware_maxSubEvtSize(hw)))
+ ) {
Hardware_waitForTrigger(hw, subEvt);
Hardware_readout(hw, subEvt);
+
#ifndef SAM_DEFS_H
#define SAM_DEFS_H
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/shmtrans.c,v 6.6 2002-10-09 12:42:18 hadaq Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/shmtrans.c,v 6.7 2003-03-02 15:50:10 hadaq Exp $";
#define _POSIX_C_SOURCE 199309L
break;
default:
syslog(LOG_DEBUG,
- "%s, line %d: %s", __FILE__, __LINE__, strerror(errno));
+ "%s, line %d: %s", __FILE__, __LINE__, strerror(errno));
goto bailOut1;
break;
}
break;
default:
syslog(LOG_DEBUG,
- "%s, line %d: %s", __FILE__, __LINE__, strerror(errno));
+ "%s, line %d: %s", __FILE__, __LINE__, strerror(errno));
goto bailOut2;
break;
}
break;
default:
syslog(LOG_DEBUG,
- "%s, line %d: %s", __FILE__, __LINE__, strerror(errno));
+ "%s, line %d: %s", __FILE__, __LINE__, strerror(errno));
goto bailOut3;
break;
}
+
#ifndef SHMTRANS_H
#define SHMTRANS_H
#include "hadtuqueue.h"
typedef struct ShmTransS {
- char name[_POSIX_PATH_MAX];
- PsxShm *shm;
- HadTuQueue *rdQueue;
- HadTuQueue *wrQueue;
- sem_t *switchRequest;
- sem_t *switchComplete;
-} ShmTrans;
+ char name[_POSIX_PATH_MAX];
+ PsxShm *shm;
+ HadTuQueue *rdQueue;
+ HadTuQueue *wrQueue;
+ sem_t *switchRequest;
+ sem_t *switchComplete;
+}
+
+ShmTrans;
ShmTrans *ShmTrans_create(const char *name, size_t size);
ShmTrans *ShmTrans_open(const char *name, size_t size);
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/showevt.c,v 6.7 2001-11-18 11:56:21 hadaq Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/showevt.c,v 6.8 2003-03-02 15:50:10 hadaq Exp $";
#define _ANSI_C_SOURCE
/* print the event header */
printf(
- "size: 0x%08x decoding: 0x%08x id: 0x%08x seqNr: 0x%08x\n"
- "date: %s time: %s runNr: 0x%08x expId: %s\n",
- Evt_size(evt), Evt_decoding(evt), Evt_id(evt), Evt_seqNr(evt),
- Evt_date2charP(evt), Evt_time2charP(evt), Evt_runNr(evt),
- Evt_expId2charP(evt)
+ "size: 0x%08x decoding: 0x%08x id: 0x%08x seqNr: 0x%08x\n"
+ "date: %s time: %s runNr: 0x%08x expId: %s\n",
+ Evt_size(evt), Evt_decoding(evt), Evt_id(evt), Evt_seqNr(evt),
+ Evt_date2charP(evt), Evt_time2charP(evt), Evt_runNr(evt),
+ Evt_expId2charP(evt)
);
i = 0;
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/sniff.c,v 6.7 2003-02-21 18:58:44 sailer Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/sniff.c,v 6.8 2003-03-02 15:50:10 hadaq Exp $";
#define SYSLOG_NAMES
CLIENT *cl;
char *server;
int i;
- struct timespec t = {5, 0};
+ struct timespec t =
+ {5, 0};
struct rpc_err rpcErrS, *rpcErr = &rpcErrS;
rpcevt rpcEvtS, *rpcEvt = &rpcEvtS;
- openlog(argv[0], LOG_PID|LOG_PERROR, LOG_LOCAL0);
+ openlog(argv[0], LOG_PID | LOG_PERROR, LOG_LOCAL0);
setlogmask(LOG_UPTO(LOG_INFO));
break;
case 'v':
for (i = 0; prioritynames[i].c_name != NULL
- && 0 != strcmp(prioritynames[i].c_name, optarg); i++) {
+ && 0 != strcmp(prioritynames[i].c_name, optarg); i++) {
}
if (prioritynames[i].c_name != NULL) {
setlogmask(LOG_UPTO(prioritynames[i].c_val));
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/subevt.c,v 6.9 2002-10-09 12:42:19 hadaq Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/subevt.c,v 6.10 2003-03-02 15:50:10 hadaq Exp $";
#include <stdlib.h>
#include "subevt.h"
-uint32_t SubEvt_dataValue(const void *my, unsigned idx) {
- uint32_t val;
-
- switch (SubEvt_alignment(my)) {
- case 4:
- if (SubEvt_isSwapped(my)) {
- uint32_t tmp0;
- uint32_t tmp1;
-
- tmp0 = ((uint32_t *)SubEvt_data(my))[idx];
- ((char *) &tmp1)[0] = ((char *) &tmp0)[3];
- ((char *) &tmp1)[1] = ((char *) &tmp0)[2];
- ((char *) &tmp1)[2] = ((char *) &tmp0)[1];
- ((char *) &tmp1)[3] = ((char *) &tmp0)[0];
- val = tmp1;
- } else {
- val = ((uint32_t *)SubEvt_data(my))[idx];
- }
- break;
- case 2:
- if (SubEvt_isSwapped(my)) {
- uint16_t v;
- swab(((uint16_t *)SubEvt_data(my)) + idx, &v, 2);
- val = v;
- } else {
- val = ((uint16_t *)SubEvt_data(my))[idx];
- }
- break;
- default:
- val = ((uint8_t *)SubEvt_data(my))[idx];
- break;
- }
- return val;
+uint32_t SubEvt_dataValue(const void *my, unsigned idx)
+{
+ uint32_t val;
+
+ switch (SubEvt_alignment(my)) {
+ case 4:
+ if (SubEvt_isSwapped(my)) {
+ uint32_t tmp0;
+ uint32_t tmp1;
+
+ tmp0 = ((uint32_t *) SubEvt_data(my))[idx];
+ ((char *) &tmp1)[0] = ((char *) &tmp0)[3];
+ ((char *) &tmp1)[1] = ((char *) &tmp0)[2];
+ ((char *) &tmp1)[2] = ((char *) &tmp0)[1];
+ ((char *) &tmp1)[3] = ((char *) &tmp0)[0];
+ val = tmp1;
+ } else {
+ val = ((uint32_t *) SubEvt_data(my))[idx];
+ }
+ break;
+ case 2:
+ if (SubEvt_isSwapped(my)) {
+ uint16_t v;
+ swab(((uint16_t *) SubEvt_data(my)) + idx, &v, 2);
+ val = v;
+ } else {
+ val = ((uint16_t *) SubEvt_data(my))[idx];
+ }
+ break;
+ default:
+ val = ((uint8_t *) SubEvt_data(my))[idx];
+ break;
+ }
+ return val;
}
char *SubEvt_2charP(const void *my)
{
- static char buf[132];
+ static char buf[132];
- sprintf(buf, "size: 0x%08x\tdecoding: 0x%08x\tid: 0x%08x\ttrigNr: 0x%08x",
- SubEvt_size(my), SubEvt_decoding(my), SubEvt_id(my), SubEvt_trigNr(my));
+ sprintf(buf, "size: 0x%08x\tdecoding: 0x%08x\tid: 0x%08x\ttrigNr: 0x%08x",
+ SubEvt_size(my), SubEvt_decoding(my), SubEvt_id(my), SubEvt_trigNr(my));
- return buf;
+ return buf;
}
void *newSubEvt(uint32_t decoding, uint32_t id, uint32_t trigNr)
{
- void *my;
+ void *my;
- my = malloc(SubEvt_hdrSize());
+ my = malloc(SubEvt_hdrSize());
- SubEvt_setSize(my, SubEvt_hdrSize());
- SubEvt_setDecoding(my, decoding);
- SubEvt_setId(my, id);
- SubEvt_setTrigNr(my, trigNr);
+ SubEvt_setSize(my, SubEvt_hdrSize());
+ SubEvt_setDecoding(my, decoding);
+ SubEvt_setId(my, id);
+ SubEvt_setTrigNr(my, trigNr);
- return my;
+ return my;
}
void deleteSubEvt(void *my)
{
- free(my);
+ free(my);
}
void *SubEvt_appendData(void *my, const void *data, size_t size)
{
- my = realloc(my, SubEvt_paddedSize(my) + size);
- memcpy(SubEvt_end(my), data, size);
- SubEvt_setSize(my, SubEvt_paddedSize(my) + size);
+ my = realloc(my, SubEvt_paddedSize(my) + size);
+ memcpy(SubEvt_end(my), data, size);
+ SubEvt_setSize(my, SubEvt_paddedSize(my) + size);
- return my;
+ return my;
}
+
#ifndef SUBEVT_H
#define SUBEVT_H
#include "hadtu.h"
enum SubEvtId {
- SubEvtId_invalid = 0,
- SubEvtId_test1 = 1,
- SubEvtId_slow = 2,
- SubEvtId_test2 = 3,
- SubEvtId_mdc = 6,
- SubEvtId_shower = 7,
- SubEvtId_rich = 8,
- SubEvtId_tof = 9,
- SubEvtId_start = 10,
- SubEvtId_veto = 11,
- SubEvtId_richPed = 12,
- SubEvtId_tofTest = 400,
- SubEvtId_trigCode = 500,
- SubEvtId_trigInfo = 501,
- SubEvtId_slowTest = 600
+ SubEvtId_invalid = 0,
+ SubEvtId_test1 = 1,
+ SubEvtId_slow = 2,
+ SubEvtId_test2 = 3,
+ SubEvtId_mdc = 6,
+ SubEvtId_shower = 7,
+ SubEvtId_rich = 8,
+ SubEvtId_tof = 9,
+ SubEvtId_start = 10,
+ SubEvtId_veto = 11,
+ SubEvtId_richPed = 12,
+ SubEvtId_tofTest = 400,
+ SubEvtId_trigCode = 500,
+ SubEvtId_trigInfo = 501,
+ SubEvtId_slowTest = 600
};
enum SubEvtDecoding {
- SubEvtDecoding_8bitData = 1,
- SubEvtDecoding_16bitData = (1 << 16) | 1,
- SubEvtDecoding_32bitData = (2 << 16) | 1,
- SubEvtDecoding_text = 2,
- SubEvtDecoding_SubEvts = (3 << 16) | 3
+ SubEvtDecoding_8bitData = 1,
+ SubEvtDecoding_16bitData = (1 << 16) | 1,
+ SubEvtDecoding_32bitData = (2 << 16) | 1,
+ SubEvtDecoding_text = 2,
+ SubEvtDecoding_SubEvts = (3 << 16) | 3
};
#define SubEvt_hdr HadTu_hdr
enum SubEvtIdx {
- SubEvtIdx_size,
- SubEvtIdx_decoding,
- SubEvtIdx_id,
- SubEvtIdx_trigNr,
- SubEvtIdx_data
+ SubEvtIdx_size,
+ SubEvtIdx_decoding,
+ SubEvtIdx_id,
+ SubEvtIdx_trigNr,
+ SubEvtIdx_data
};
static size_t SubEvt_hdrLen(void)
{
- return SubEvtIdx_data;
+ return SubEvtIdx_data;
}
static size_t SubEvt_hdrSize(void)
{
- return SubEvt_hdrLen() * sizeof(uint32_t);
+ return SubEvt_hdrLen() * sizeof(uint32_t);
}
static size_t SubEvt_dataSize(const void *my)
{
- return SubEvt_size(my) - SubEvt_hdrSize();
+ return SubEvt_size(my) - SubEvt_hdrSize();
}
static void *SubEvt_data(const void *my)
{
- return (void *) ((char *) my + SubEvt_hdrSize());
+ return (void *) ((char *) my + SubEvt_hdrSize());
}
uint32_t SubEvt_dataValue(const void *my, unsigned idx);
static uint32_t SubEvt_id(const void *my)
{
- return SubEvt_hdrValue(my, SubEvtIdx_id);
+ return SubEvt_hdrValue(my, SubEvtIdx_id);
}
static uint32_t SubEvt_pureId(const void *my)
{
- return SubEvt_id(my) & 0x7fffffffUL;
+ return SubEvt_id(my) & 0x7fffffffUL;
}
static int SubEvt_dataError(const void *my)
{
- return (SubEvt_id(my) & 0x80000000UL) != 0;
+ return (SubEvt_id(my) & 0x80000000UL) != 0;
}
static void SubEvt_setId(void *my, uint32_t id)
{
- SubEvt_setHdrValue(my, SubEvtIdx_id, id);
+ SubEvt_setHdrValue(my, SubEvtIdx_id, id);
}
-static int SubEvt_setDataError(void *my) {
- SubEvt_setId(my, SubEvt_id(my) | 0x80000000UL);
+static int SubEvt_setDataError(void *my)
+{
+ SubEvt_setId(my, SubEvt_id(my) | 0x80000000UL);
}
-static int SubEvt_clrDataError(void *my) {
- SubEvt_setId(my, SubEvt_id(my) & ~0x80000000UL);
+static int SubEvt_clrDataError(void *my)
+{
+ SubEvt_setId(my, SubEvt_id(my) & ~0x80000000UL);
}
static uint32_t SubEvt_trigNr(const void *my)
{
- return SubEvt_hdrValue(my, SubEvtIdx_trigNr);
+ return SubEvt_hdrValue(my, SubEvtIdx_trigNr);
}
static void SubEvt_setTrigNr(void *my, uint32_t trigNr)
{
- SubEvt_setHdrValue(my, SubEvtIdx_trigNr, trigNr);
+ SubEvt_setHdrValue(my, SubEvtIdx_trigNr, trigNr);
}
void *newSubEvt(uint32_t decoding, uint32_t id, uint32_t trigNr);
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/tcldaq.c,v 6.11 2003-02-06 10:06:51 hadaq Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/tcldaq.c,v 6.12 2003-03-02 15:50:10 hadaq Exp $";
#define _GNU_SOURCE
#include <unistd.h>
int id;
char *agent;
char *command;
-} ThrArgs;
+}
+
+ThrArgs;
int AgentCmd(ClientData clientData, Tcl_Interp * interp, int argc, char *argv[])
{
Tcl_AppendResult(interp, "usage: c_system <agent> command", NULL);
return TCL_ERROR;
}
-
strcpy(agents[nThr++], argv[1]);
if (NULL == (cl = clnt_create(argv[1], DAQAGENTPROG, DAQAGENTVERS, "tcp"))) {
Tcl_AppendResult(interp, clnt_spcreateerror(argv[1]), NULL);
SystemCmdR = TCL_ERROR;
} else {
- struct timeval TIMEOUT = { 0, 0 };
+ struct timeval TIMEOUT =
+ {0, 0};
struct rpc_err rpcErr;
- clnt_control(cl, CLSET_TIMEOUT, (char *)&TIMEOUT);
- rpcsystem_1(&argv[2], cl); /* will produce a timeout */
+ clnt_control(cl, CLSET_TIMEOUT, (char *) &TIMEOUT);
+ rpcsystem_1(&argv[2], cl); /* will produce a timeout */
clnt_geterr(cl, &rpcErr);
- if (rpcErr.re_status != RPC_TIMEDOUT) { /* a real error */
+ if (rpcErr.re_status != RPC_TIMEDOUT) { /* a real error */
Tcl_AppendResult(interp, clnt_sperror(cl, "rpcsystem_1"), NULL);
SystemCmdR = TCL_ERROR;
} else {
Tcl_AppendResult(interp, clnt_spcreateerror(argv[1]), NULL);
JoinAllCmdR = TCL_ERROR;
} else {
- struct timeval TIMEOUT = { 120, 0 };
+ struct timeval TIMEOUT =
+ {120, 0};
- clnt_control(cl, CLSET_TIMEOUT, (char *)&TIMEOUT);
+ clnt_control(cl, CLSET_TIMEOUT, (char *) &TIMEOUT);
if (NULL == rpcjoin_1(&dummy, cl)) {
Tcl_AppendResult(interp, clnt_sperror(cl, "rpcjoin_1"), NULL);
JoinAllCmdR = TCL_ERROR;
+
/**** Headerfile for TOF-IPU registers */
/**** created: E.Lins 13-Jan-2000 */
-/* $Id: tof_defs.h,v 1.3 2000-11-11 11:32:33 hades Exp $ */
+/* $Id: tof_defs.h,v 1.4 2003-03-02 15:50:10 hadaq Exp $ */
/* $Source: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/Attic/tof_defs.h,v $ */
/* register offsets (32bit words) in configbase area */
#define CFG_MASTER_CONTROL 0x0000
-#define _START_TIP 0
-#define _LVL2_TRIG_ACTIVE 1
-#define _LVL2_LINK_ACTIVE 2
-#define _MU_LINK_ACTIVE 3
+#define _START_TIP 0
+#define _LVL2_TRIG_ACTIVE 1
+#define _LVL2_LINK_ACTIVE 2
+#define _MU_LINK_ACTIVE 3
#define _LVL2_PIPE1_RQ 4
#define _LVL2_PIPE2_RQ 5
#define CFG_MASTER_STATUS 0x0004
-#define _LVL1_PIPE_FULL 0
+#define _LVL1_PIPE_FULL 0
#define _LVL2_PIPE1_FULL 1
#define _LVL2_PIPE2_FULL 2
#define _LVL2_PIPE 3
#define _LVL2_PIPE2_GR 5
#define CFG_DEBUG_CONTROL 0x0008
-#define _DEBUG_DUMP 3
+#define _DEBUG_DUMP 3
#define CFG_LVL1_PIPE_SIZE 0x000c
#define CFG_TOTAL_EVENTS 0x0020
-
+
/* number of vme modules to be rout */
#define CFG_NOF_MODULES 0x002c
-
+
/* declaration of vme modules toread out starts here */
#define CFG_VME_MODULES 0x0030
/* one vme module is described with ... words */
-static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/worker.c,v 6.17 2003-02-21 18:58:44 sailer Exp $";
+static char *rcsId = "$Header: /misc/hadesprojects/daq/cvsroot/eventbuilder/hadaq/worker.c,v 6.18 2003-03-02 15:50:11 hadaq Exp $";
#define _POSIX_C_SOURCE 199309L
#include <unistd.h>
static int removeSigHandlers(Worker *my)
{
return sigaction(my->signal0, my->oldSigAction0, NULL)
- | sigaction(my->signal1, my->oldSigAction1, NULL);
+ | sigaction(my->signal1, my->oldSigAction1, NULL);
}
static int installSigHandlers(Worker *my, int s0, int s1,
syslog(LOG_DEBUG, "%s:%d: %s", __FILE__, __LINE__, strerror(errno));
my->oldSigAction0 = NULL;
}
-
my->signal1 = s1;
my->oldSigAction1 = &my->oldSigAction1S;
if (0 > sigaction(my->signal1, act, my->oldSigAction1)) {
syslog(LOG_DEBUG, "%s:%d: %s", __FILE__, __LINE__, strerror(errno));
my->oldSigAction1 = NULL;
}
-
if (my->oldSigAction0 == NULL || my->oldSigAction1 == NULL) {
removeSigHandlers(my);
retVal = -1;
syslog(LOG_ERR, "%s:%d: %s", __FILE__, __LINE__, strerror(errno));
return NULL;
}
-
strcpy(my->name, name);
my->pid = getpid();
my->isStandalone = isStandalone;
if (0 > changePriority(priority)) {
syslog(LOG_WARNING, "changeing priority: %s", strerror(errno));
}
-
retVal = my;
}
{
int retVal;
Worker myS, *my = &myS;
- struct timespec t = {1, 0};
+ struct timespec t =
+ {1, 0};
strcpy(my->name, argv[0]);
#ifndef WORKER_NEW_PROTOCOL
/* BUGBUG there should be a timeout here */
sigemptyset(sigMask); /* This is the parent, so wait for the */
- sigsuspend(sigMask); /* child to initialize */
+ sigsuspend(sigMask);/* child to initialize */
if (sigReceived == SIGCHLD) {
nanosleep(&t, NULL);
void Worker_stop(const char *name, int timeout)
{
Worker myS, *my = &myS;
- struct timespec t = {1, 0};
+ struct timespec t =
+ {1, 0};
strcpy(my->name, name);
my->pid = my->statistics[0].value;
if (my->pid > 0) {
if (0 == kill(my->pid, SIGTERM)) {
- nanosleep(&t, NULL); /* LynxOS had problem without this */
+ nanosleep(&t, NULL); /* LynxOS had problem without this */
waitpid(my->pid, NULL, 0);
}
}
+
#ifndef WORKER_H
#define WORKER_H
typedef struct StatisticS {
char name[WORKER_MAX_NAME_LEN];
unsigned long value;
-} Statistic;
+}
+
+Statistic;
typedef struct WorkerS {
char name[_POSIX_PATH_MAX];
Statistic *statistics;
pid_t pid;
int isStandalone;
-} Worker;
+}
+
+Worker;
int Worker_start(const char *path, char *const argv[]);
char *Worker_status(const char *name);
jspc29 / daqdata.git / commitdiff