void interruptHandler(void)
{
LOG("Interrupt\n");
if ( readReg32(DMA_BASE, DMA_C0_CONFIGURATION) & 0x8000 ) {
LOG("Interrupt ch0 0x%x\n", readReg32(DMA_BASE, DMA_C0_CONFIGURATION));
writeReg32(DMA_BASE, DMA_C0_CONFIGURATION, 0);
interruptCount++;
}
if ( readReg32(DMA_BASE, DMA_C1_CONFIGURATION) & 0x8000 ) {
LOG("Interrupt ch1 0x%x\n", readReg32(DMA_BASE, DMA_C1_CONFIGURATION));
writeReg32(DMA_BASE, DMA_C1_CONFIGURATION, 0);
interruptCount++;
}
}
/***************************************************
* scaler_read()
* return pointer to array of scaler values (on the card)
****************************************************/
STATIC long scaler_read(scalerRecord *psr, long *val)
{
devScalerPvt *dpvt = psr->dpvt;
int card = dpvt->card;
long preset;
unsigned long rawval;
volatile char *addr= scaler_state[card]->localAddr;
int i, offset;
unsigned short mask;
Debug(8,"scaler_read: card %d\n", card);
if ((card+1) > scaler_total_cards) return(ERROR);
if (!scaler_state[card]->card_exists) return(ERROR);
mask = readReg16(addr,DIRECTION_OFFSET);
Debug(5,"scaler_read: readback of up/down mask: 0x%x\n", mask);
mask = readReg16(addr,IRQ_MASK_OFFSET);
Debug(5,"scaler_read: readback of IRQ mask: 0x%x\n", mask);
for (i=0, offset=DATA_0_OFFSET; i < scaler_state[card]->num_channels; i++, offset+=4) {
preset = scaler_state[card]->preset[i];
rawval = readReg32(addr,offset);
val[i] = (mask & (1<<i)) ? preset-rawval:rawval;
if (i <= (devScalerDebug-19)) {
logMsg("scaler_read: channel %d\n", i);
logMsg("scaler_read: ...(dir i = %s)\n", (mask & (1<<i)) ? "DN":"UP");
logMsg("scaler_read: ...(preset i = %d)\n", (unsigned int)preset);
logMsg("scaler_read: ...(data i = %d)\n",rawval);
logMsg("scaler_read: ...(chan i = %d)\n\n", (unsigned int)val[i]);
}
}
return(0);
}
/***************************************************
* scalerVS_read()
* return pointer to array of scaler values (on the card)
****************************************************/
STATIC long scalerVS_read(scalerRecord *psr, long *val)
{
devScalerPvt *dpvt = psr->dpvt;
int card = dpvt->card;
volatile char *addr;
int i, offset;
Debug(8,"scalerVS_read: card %d\n", card);
if (card >= scalerVS_total_cards) return(ERROR);
addr = scalerVS_state[card]->localAddr;
/* any write clocks all transfer registers */
writeReg16(addr,CLOCK_XFER_REG_OFFSET,1);
for (i=0, offset=READ_XFER_REG_OFFSET; i < scalerVS_state[card]->num_channels; i++, offset+=4) {
val[i] = readReg32(addr,offset);
if (i==0) {
Debug2(11,"scalerVS_read: ...(chan %d = %ld)\n", i, val[i]);
} else {
Debug2(20,"scalerVS_read: ...(chan %d = %ld)\n", i, val[i]);
}
}
Debug2(10,"scalerVS_read: status=0x%x; irq vector=0x%x\n",
readReg16(scalerVS_state[card]->localAddr,STATUS_OFFSET),
readReg16(addr,IRQ_3_GATE_VECTOR_OFFSET)&0xff);
return(0);
}
/* debugging function */
void VSCscaler_debug(int card, int numReads, int waitLoops)
{
volatile char *addr = scaler_state[card]->localAddr;
int i, j, offset;
if (vsc_num_cards == 0) {
printf("VSCscaler_debug: No Joerger VSC cards\n");
return;
}
printf("VSCscaler_debug: card %d %s\n", card, scaler_state[card]->card_exists ? "exists" : "not found");
if (!scaler_state[card]->card_exists) return;
for (i=0; i<numReads; i++) {
printf("VSCscaler_debug: ctrl reg = 0x%x\n", readReg16(addr,CTRL_OFFSET) &0xf);
for (j=0; j<waitLoops; j++);
}
for (i=0; i<numReads; i++) {
printf("VSCscaler_debug: dir reg = 0x%x\n",readReg16(addr,DIRECTION_OFFSET) );
for (j=0; j<waitLoops; j++);
}
for (i=0; i<numReads; i++) {
printf("VSCscaler_debug: irq vector = 0x%x\n",readReg16(addr,STATUS_ID_OFFSET) &0xff);
for (j=0; j<waitLoops; j++);
}
for (i=0; i<numReads; i++) {
printf("VSCscaler_debug: irq level/enable = 0x%x\n",readReg16(addr,IRQ_LEVEL_ENABLE_OFFSET) &0xff);
for (j=0; j<waitLoops; j++);
}
for (i=0; i<numReads; i++) {
printf("VSCscaler_debug: irq mask reg = 0x%x\n", readReg16(addr,IRQ_MASK_OFFSET));
for (j=0; j<waitLoops; j++);
}
for (i=0; i<numReads; i++) {
printf("VSCscaler_debug: rev. ser# reg = 0x%x\n", readReg16(addr,REV_SERIAL_NO_OFFSET));
for (j=0; j<waitLoops; j++);
}
for (i=0; i<numReads; i++) {
printf("VSCscaler_debug: module type = 0x%x\n",readReg16(addr,MODULE_TYPE_OFFSET) &0xff);
for (j=0; j<waitLoops; j++);
}
for (i=0; i<numReads; i++) {
printf("VSCscaler_debug: manuf. ID = 0x%x\n",readReg16(addr,MANUFACTURER_ID_OFFSET) &0xff);
for (j=0; j<waitLoops; j++);
}
offset = DATA_0_OFFSET;
for (i=0; i<2; i++, offset+=4 ) {
for (j=0; j<numReads; j++) {
printf(" VSCscaler_debug: channel %d counts = %d\n", i,readReg32(addr,offset) );
}
}
/* Note reading from PRESET_0_OFFSET reads and clears data at DATA_0_OFFSET */
}
/***************************************************
* scaler_read()
* return pointer to array of scaler values (on the card)
****************************************************/
STATIC long scaler_read(scalerRecord *psr, long *val)
{
devScalerPvt *dpvt = psr->dpvt;
int card = dpvt->card;
long preset;
volatile char *addr= scaler_state[card]->localAddr;
int i, offset;
unsigned short mask;
Debug(8,"scaler_read: card %d\n", card);
if ((card+1) > scaler_total_cards) return(ERROR);
if (!scaler_state[card]->card_exists) return(ERROR);
mask = readReg16(scaler_state[card]->localAddr,DIRECTION_OFFSET);
for (i=0, offset=DATA_0_OFFSET; i < scaler_state[card]->num_channels; i++, offset+=4) {
preset = scaler_state[card]->preset[i];
val[i] = (mask & (1<<i)) ? preset-readReg32(addr,offset):readReg32(addr,offset);
Debug(20,"scaler_read: ...(dir i = %s)\n", (mask & (1<<i)) ? "DN":"UP");
Debug(20,"scaler_read: ...(preset i = 0x%x)\n", (unsigned int)preset);
Debug(20,"scaler_read: ...(data i = 0x%x)\n",readReg32(addr,offset));
Debug(10,"scaler_read: ...(chan i = 0x%x)\n\n", (unsigned int)val[i]);
}
return(0);
}
/* debugging function */
void scalerVS_show(int card, int level)
{
volatile char *addr;
int i, num_channels, offset, saveDebug;
char module_type[16];
printf("scalerVS_show: software version: %f\n", VERSION);
printf("scalerVS_show: %ld Joerger VS cards in use.\n", vs_num_cards);
if ((vs_num_cards == 0) || (card >= vs_num_cards)) return;
addr = scalerVS_state[card]->localAddr;
saveDebug = devScaler_VSDebug;
devScaler_VSDebug = 0;
printf("scalerVS_show: card %d\n", card);
printf("scalerVS_show: local address %p\n", addr);
printf("scalerVS_show: control reg = 0x%x\n", readReg16(addr,CTRL_OFFSET) & 0x3);
printf("scalerVS_show: status reg = 0x%x\n", readReg16(addr,STATUS_OFFSET) & 0x1ff);
printf("scalerVS_show: irq level/enable = 0x%x\n", readReg16(addr,IRQ_SETUP_OFFSET) & 0xfff);
printf("scalerVS_show: irq 3 (end-of-gate) interrupt vector = %d\n", readReg16(addr,IRQ_3_GATE_VECTOR_OFFSET) & 0xff);
i = (readReg16(addr,ID_OFFSET) & 0xfc00) >> 10;
if ((i >= 16) && (i <= 29)) {
strncpy(module_type, VS_module_types[i-16].type, 15);
num_channels = VS_module_types[i-16].num_channels;
} else {
sprintf(module_type, "unknown(%d)", i);
num_channels = 0;
}
printf("scalerVS_show: module type = %d ('%s'), %d channels, serial # %d\n",
i, module_type, num_channels, readReg16(addr,ID_OFFSET) & 0x3ff);
num_channels = level ? scalerVS_state[card]->num_channels : 1;
for (i=0, offset=READ_XFER_REG_OFFSET; i<num_channels; i++, offset+=4) {
printf(" scalerVS_show: channel %d xfer-reg counts = %u\n", i, readReg32(addr,offset));
}
printf("scalerVS_show: scalerVS_state[card]->done = %d\n", scalerVS_state[card]->done);
devScaler_VSDebug = saveDebug;
return;
}
/* debugging function */
void VSCscaler_show(int card)
{
volatile char *addr = scaler_state[card]->localAddr;
int i, offset;
if (vsc_num_cards == 0) {
printf("VSCscaler_show: No Joerger VSC cards\n");
return;
}
printf("VSCscaler_show: card %d %s\n", card, scaler_state[card]->card_exists ? "exists" : "not found");
if (!scaler_state[card]->card_exists) return;
printf("VSCscaler_show: ctrl reg = 0x%x\n", readReg16(addr,CTRL_OFFSET) &0xf);
printf("VSCscaler_show: dir reg = 0x%x\n",readReg16(addr,DIRECTION_OFFSET) );
printf("VSCscaler_show: irq vector = 0x%x\n",readReg16(addr,STATUS_ID_OFFSET) &0xff);
printf("VSCscaler_show: irq level/enable = 0x%x\n",readReg16(addr,IRQ_LEVEL_ENABLE_OFFSET) &0xff);
printf("VSCscaler_show: irq mask reg = 0x%x\n", readReg16(addr,IRQ_MASK_OFFSET));
printf("VSCscaler_show: module type = 0x%x\n",readReg16(addr,MODULE_TYPE_OFFSET) &0xff);
offset = DATA_0_OFFSET;
for (i=0; i<scaler_state[card]->num_channels; i++, offset+=4 ) {
printf(" VSCscaler_show: channel %d counts = %d\n", i,readReg32(addr,offset) );
}
printf("VSCscaler_show: scaler_state[card]->done = %d\n", scaler_state[card]->done);
}
