00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016 #include <stdio.h>
00017 #include <string.h>
00018 #include <signal.h>
00019 #if defined(OS_LINUX)
00020 #include <unistd.h>
00021 #endif
00022 #include "v792.h"
00023
00024 WORD v792_Read16(MVME_INTERFACE *mvme, DWORD base, int offset)
00025 {
00026 mvme_set_dmode(mvme, MVME_DMODE_D16);
00027 return mvme_read_value(mvme, base+offset);
00028 }
00029
00030 void v792_Write16(MVME_INTERFACE *mvme, DWORD base, int offset, WORD value)
00031 {
00032 mvme_set_dmode(mvme, MVME_DMODE_D16);
00033 mvme_write_value(mvme, base+offset, value);
00034 }
00035
00036
00037
00038
00039
00040
00041 int v792_EventRead(MVME_INTERFACE *mvme, DWORD base, DWORD *pdest, int *nentry)
00042 {
00043 DWORD hdata;
00044 int cmode;
00045
00046 mvme_get_dmode(mvme, &cmode);
00047 mvme_set_dmode(mvme, MVME_DMODE_D32);
00048
00049 *nentry = 0;
00050 if (v792_DataReady(mvme, base)) {
00051 do {
00052 hdata = mvme_read_value(mvme, base);
00053 } while (!(hdata & 0x02000000));
00054
00055 pdest[*nentry] = hdata;
00056 *nentry += 1;
00057 do {
00058 pdest[*nentry] = mvme_read_value(mvme, base);
00059 *nentry += 1;
00060 } while (!(pdest[*nentry-1] & 0x04000000));
00061
00062 nentry--;
00063 }
00064 mvme_set_dmode(mvme, cmode);
00065 return *nentry;
00066 }
00067
00068
00069
00070
00071
00072
00073 int v792_DataRead(MVME_INTERFACE *mvme, DWORD base, DWORD *pdest, int *nentry)
00074 {
00075 int cmode;
00076
00077 mvme_get_dmode(mvme, &cmode);
00078 mvme_set_dmode(mvme, MVME_DMODE_D32);
00079 *nentry = 128;
00080 if (v792_DataReady(mvme, base)) {
00081 mvme_read(mvme, pdest, base, *nentry*4);
00082 }
00083 mvme_set_dmode(mvme, cmode);
00084 return *nentry;
00085 }
00086
00087
00088
00089
00090
00091 int v792_ThresholdWrite(MVME_INTERFACE *mvme, DWORD base, WORD *threshold)
00092 {
00093 int k, cmode;
00094
00095 mvme_get_dmode(mvme, &cmode);
00096 mvme_set_dmode(mvme, MVME_DMODE_D16);
00097 for (k=0; k<V792_MAX_CHANNELS ; k++) {
00098 mvme_write_value(mvme, base+V792_THRES_BASE+2*k, threshold[k] & 0x1FF);
00099 }
00100
00101 for (k=0; k<V792_MAX_CHANNELS ; k++) {
00102 threshold[k] = mvme_read_value(mvme, base+V792_THRES_BASE+2*k) & 0x1FF;
00103 }
00104
00105 mvme_set_dmode(mvme, cmode);
00106 return V792_MAX_CHANNELS;
00107 }
00108
00109
00110
00111
00112
00113 int v792_ThresholdRead(MVME_INTERFACE *mvme, DWORD base, WORD *threshold)
00114 {
00115 int k, cmode;
00116
00117 mvme_get_dmode(mvme, &cmode);
00118 mvme_set_dmode(mvme, MVME_DMODE_D16);
00119
00120 for (k=0; k<V792_MAX_CHANNELS ; k++) {
00121 threshold[k] = mvme_read_value(mvme, base+V792_THRES_BASE+2*k) & 0x1FF;
00122 }
00123 mvme_set_dmode(mvme, cmode);
00124 return V792_MAX_CHANNELS;
00125 }
00126
00127
00128 void v792_EvtTriggerSet(MVME_INTERFACE *mvme, DWORD base, int count)
00129 {
00130 int cmode;
00131
00132 mvme_get_dmode(mvme, &cmode);
00133 mvme_set_dmode(mvme, MVME_DMODE_D16);
00134 mvme_write_value(mvme, base+V792_EVTRIG_REG_RW, (count & 0x1F));
00135 mvme_set_dmode(mvme, cmode);
00136 }
00137
00138
00139 void v792_EvtCntRead(MVME_INTERFACE *mvme, DWORD base, DWORD *evtcnt)
00140 {
00141 int cmode;
00142
00143 mvme_get_dmode(mvme, &cmode);
00144 mvme_set_dmode(mvme, MVME_DMODE_D16);
00145 *evtcnt = mvme_read_value(mvme, base+V792_EVT_CNT_L_RO);
00146 *evtcnt += (mvme_read_value(mvme, base+V792_EVT_CNT_H_RO) << 16);
00147 mvme_set_dmode(mvme, cmode);
00148 }
00149
00150
00151 int v792_CSR1Read(MVME_INTERFACE *mvme, DWORD base)
00152 {
00153 int status, cmode;
00154
00155 mvme_get_dmode(mvme, &cmode);
00156 mvme_set_dmode(mvme, MVME_DMODE_D16);
00157 status = mvme_read_value(mvme, base+V792_CSR1_RO);
00158 mvme_set_dmode(mvme, cmode);
00159 return status;
00160 }
00161
00162
00163 int v792_isBusy(MVME_INTERFACE *mvme, DWORD base)
00164 {
00165 int status, busy, timeout, cmode;
00166
00167 mvme_get_dmode(mvme, &cmode);
00168 mvme_set_dmode(mvme, MVME_DMODE_D16);
00169 timeout = 1000;
00170 do {
00171 status = mvme_read_value(mvme, base+V792_CSR1_RO);
00172 busy = status & 0x4;
00173 timeout--;
00174 } while (busy || timeout);
00175 mvme_set_dmode(mvme, cmode);
00176 return (busy != 0 ? 1 : 0);
00177 }
00178
00179
00180 int v792_CSR2Read(MVME_INTERFACE *mvme, DWORD base)
00181 {
00182 int status, cmode;
00183
00184 mvme_get_dmode(mvme, &cmode);
00185 mvme_set_dmode(mvme, MVME_DMODE_D16);
00186 status = mvme_read_value(mvme, base+V792_CSR2_RO);
00187 mvme_set_dmode(mvme, cmode);
00188 return status;
00189 }
00190
00191
00192 int v792_BitSet2Read(MVME_INTERFACE *mvme, DWORD base)
00193 {
00194 int status, cmode;
00195
00196 mvme_get_dmode(mvme, &cmode);
00197 mvme_set_dmode(mvme, MVME_DMODE_D16);
00198 status = mvme_read_value(mvme, base+V792_BIT_SET2_RW);
00199 mvme_set_dmode(mvme, cmode);
00200 return status;
00201 }
00202
00203
00204 void v792_BitSet2Set(MVME_INTERFACE *mvme, DWORD base, WORD pat)
00205 {
00206 int cmode;
00207 mvme_get_dmode(mvme, &cmode);
00208 mvme_set_dmode(mvme, MVME_DMODE_D16);
00209 mvme_write_value(mvme, base+V792_BIT_SET1_RW, 0xA0);
00210 mvme_write_value(mvme, base+V792_BIT_CLEAR1_WO, 0xA0);
00211 mvme_set_dmode(mvme, cmode);
00212 }
00213
00214
00215 void v792_BitSet2Clear(MVME_INTERFACE *mvme, DWORD base, WORD pat)
00216 {
00217 int cmode;
00218 mvme_get_dmode(mvme, &cmode);
00219 mvme_set_dmode(mvme, MVME_DMODE_D16);
00220 mvme_write_value(mvme, base+V792_BIT_SET1_RW, 0xA0);
00221 mvme_write_value(mvme, base+V792_BIT_CLEAR1_WO, 0xA0);
00222 mvme_set_dmode(mvme, cmode);
00223 }
00224
00225
00226 void v792_DataClear(MVME_INTERFACE *mvme, DWORD base)
00227 {
00228 int cmode;
00229 mvme_get_dmode(mvme, &cmode);
00230 mvme_set_dmode(mvme, MVME_DMODE_D16);
00231 mvme_write_value(mvme, base+V792_BIT_SET2_RW, 0x4);
00232 mvme_write_value(mvme, base+V792_BIT_CLEAR2_WO, 0x4);
00233 mvme_set_dmode(mvme, cmode);
00234 }
00235
00236
00237 void v792_SoftReset(MVME_INTERFACE *mvme, DWORD base)
00238 {
00239 int cmode;
00240 mvme_get_dmode(mvme, &cmode);
00241 mvme_set_dmode(mvme, MVME_DMODE_D16);
00242 mvme_write_value(mvme, base+V792_BIT_SET1_RW, 0xA0);
00243 mvme_write_value(mvme, base+V792_BIT_CLEAR1_WO, 0xA0);
00244 mvme_set_dmode(mvme, cmode);
00245 }
00246
00247
00248 void v792_OnlineSet(MVME_INTERFACE *mvme, DWORD base)
00249 {
00250 int cmode;
00251 mvme_get_dmode(mvme, &cmode);
00252 mvme_set_dmode(mvme, MVME_DMODE_D16);
00253 mvme_write_value(mvme, base+V792_BIT_CLEAR2_WO, 0x2);
00254 mvme_set_dmode(mvme, cmode);
00255 }
00256
00257
00258 void v792_LowThEnable(MVME_INTERFACE *mvme, DWORD base)
00259 {
00260 int cmode;
00261 mvme_get_dmode(mvme, &cmode);
00262 mvme_set_dmode(mvme, MVME_DMODE_D16);
00263 mvme_write_value(mvme, base+V792_BIT_CLEAR2_WO, 0x10);
00264 mvme_set_dmode(mvme, cmode);
00265 }
00266
00267
00268 void v792_LowThDisable(MVME_INTERFACE *mvme, DWORD base)
00269 {
00270 int cmode;
00271 mvme_get_dmode(mvme, &cmode);
00272 mvme_set_dmode(mvme, MVME_DMODE_D16);
00273 mvme_write_value(mvme, base+V792_BIT_SET2_RW, 0x10);
00274 mvme_set_dmode(mvme, cmode);
00275 }
00276
00277
00278 void v792_EmptyEnable(MVME_INTERFACE *mvme, DWORD base)
00279 {
00280 int cmode;
00281 mvme_get_dmode(mvme, &cmode);
00282 mvme_set_dmode(mvme, MVME_DMODE_D16);
00283 mvme_write_value(mvme, base+V792_BIT_SET2_RW, 0x1000);
00284 mvme_set_dmode(mvme, cmode);
00285 }
00286
00287
00288 void v792_EvtCntReset(MVME_INTERFACE *mvme, DWORD base)
00289 {
00290 int cmode;
00291 mvme_get_dmode(mvme, &cmode);
00292 mvme_set_dmode(mvme, MVME_DMODE_D16);
00293 mvme_write_value(mvme, base+V792_EVT_CNT_RST_WO, 1);
00294 mvme_set_dmode(mvme, cmode);
00295 }
00296
00297
00298 void v792_SingleShotReset(MVME_INTERFACE *mvme, DWORD base)
00299 {
00300 int cmode;
00301 mvme_get_dmode(mvme, &cmode);
00302 mvme_set_dmode(mvme, MVME_DMODE_D16);
00303 mvme_write_value(mvme, base+V792_SINGLE_RST_WO, 1);
00304 mvme_set_dmode(mvme, cmode);
00305 }
00306
00307
00308 int v792_DataReady(MVME_INTERFACE *mvme, DWORD base)
00309 {
00310 int data_ready, cmode;
00311
00312 mvme_get_dmode(mvme, &cmode);
00313 mvme_set_dmode(mvme, MVME_DMODE_D16);
00314 data_ready = mvme_read_value(mvme, base+V792_CSR1_RO) & 0x1;
00315 mvme_set_dmode(mvme, cmode);
00316 return data_ready;
00317 }
00318
00319
00320 int v792_isEvtReady(MVME_INTERFACE *mvme, DWORD base)
00321 {
00322 int csr;
00323 csr = v792_CSR1Read(mvme, base);
00324 return (csr & 0x100);
00325 }
00326
00327
00328 void v792_IntSet(MVME_INTERFACE *mvme, DWORD base, int level, int vector)
00329 {
00330 int cmode;
00331 mvme_get_dmode(mvme, &cmode);
00332 mvme_set_dmode(mvme, MVME_DMODE_D16);
00333 mvme_write_value(mvme, base+V792_INT_VECTOR_WO, (vector & 0xFF));
00334 mvme_write_value(mvme, base+V792_INT_LEVEL_WO, (level & 0x7));
00335 mvme_set_dmode(mvme, cmode);
00336 }
00337
00338
00339 void v792_IntEnable(MVME_INTERFACE *mvme, DWORD base, int level)
00340 {
00341 int cmode;
00342 mvme_get_dmode(mvme, &cmode);
00343 mvme_set_dmode(mvme, MVME_DMODE_D16);
00344 mvme_write_value(mvme, base+V792_EVTRIG_REG_RW, (level & 0x1F));
00345
00346
00347
00348 mvme_set_dmode(mvme, cmode);
00349 }
00350
00351
00352 void v792_IntDisable(MVME_INTERFACE *mvme, DWORD base)
00353 {
00354 int cmode;
00355 mvme_get_dmode(mvme, &cmode);
00356 mvme_set_dmode(mvme, MVME_DMODE_D16);
00357 mvme_write_value(mvme, base+V792_EVTRIG_REG_RW, 0);
00358
00359
00360
00361
00362 mvme_set_dmode(mvme, cmode);
00363 }
00364
00365
00366
00367
00368
00369 WORD v792_ControlRegister1Read(MVME_INTERFACE *mvme, DWORD base) {
00370 int cmode;
00371 WORD pat;
00372 mvme_get_dmode(mvme, &cmode);
00373 mvme_set_dmode(mvme, MVME_DMODE_D16);
00374 pat = mvme_read_value(mvme, base+V792_CR1_RW);
00375 mvme_set_dmode(mvme, cmode);
00376 return pat;
00377 }
00378
00379
00380
00381
00382
00383 void v792_ControlRegister1Write(MVME_INTERFACE *mvme, DWORD base, WORD pat) {
00384 int cmode;
00385 mvme_get_dmode(mvme, &cmode);
00386 mvme_set_dmode(mvme, MVME_DMODE_D16);
00387 mvme_write_value(mvme, base+V792_CR1_RW,pat);
00388 mvme_set_dmode(mvme, cmode);
00389 }
00390
00391
00392
00393
00394
00395 void v792_Trigger(MVME_INTERFACE *mvme, DWORD base) {
00396 int cmode;
00397 mvme_get_dmode(mvme, &cmode);
00398 mvme_set_dmode(mvme, MVME_DMODE_D16);
00399 mvme_write_value(mvme, base+V792_SWCOMM_WO, 0);
00400 mvme_set_dmode(mvme, cmode);
00401 }
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415 int v792_Setup(MVME_INTERFACE *mvme, DWORD base, int mode)
00416 {
00417 int cmode;
00418
00419 mvme_get_dmode(mvme, &cmode);
00420 mvme_set_dmode(mvme, MVME_DMODE_D16);
00421
00422 switch (mode) {
00423 case 0x1:
00424 printf("Default setting after power up (mode:%d)\n", mode);
00425 printf("\n");
00426 break;
00427 case 0x2:
00428 printf("Modified setting (mode:%d)\n", mode);
00429 printf("Empty Enable, Over Range disable, Low Th Enable\n");
00430 v792_OnlineSet(mvme, base);
00431 v792_EmptyEnable(mvme, base);
00432 v792_LowThEnable(mvme, base);
00433 break;
00434 default:
00435 printf("Unknown setup mode\n");
00436 mvme_set_dmode(mvme, cmode);
00437 return -1;
00438 }
00439 mvme_set_dmode(mvme, cmode);
00440 return 0;
00441 }
00442
00443
00444 void v792_Status(MVME_INTERFACE *mvme, DWORD base)
00445 {
00446 int status, cmode, i;
00447 WORD threshold[V792_MAX_CHANNELS];
00448
00449 mvme_get_dmode(mvme, &cmode);
00450 mvme_set_dmode(mvme, MVME_DMODE_D16);
00451 printf("V792 at VME A24 0x%06x:\n", base);
00452 status = mvme_read_value(mvme, base+V792_FIRM_REV);
00453 printf("Firmware revision: 0x%x\n", status);
00454 if (status == 0xFFFF) {
00455 printf("Module not present!\n");
00456 return;
00457 }
00458 status = v792_CSR1Read(mvme, base);
00459 printf("CSR1: 0x%x\n", status);
00460 printf("DataReady :%s\t", status & 0x1 ? "Y" : "N");
00461 printf(" - Global Dready:%s\t", status & 0x2 ? "Y" : "N");
00462 printf(" - Busy :%s\n", status & 0x4 ? "Y" : "N");
00463 printf("Global Busy :%s\t", status & 0x8 ? "Y" : "N");
00464 printf(" - Amnesia :%s\t", status & 0x10 ? "Y" : "N");
00465 printf(" - Purge :%s\n", status & 0x20 ? "Y" : "N");
00466 printf("Term ON :%s\t", status & 0x40 ? "Y" : "N");
00467 printf(" - TermOFF :%s\t", status & 0x80 ? "Y" : "N");
00468 printf(" - Event Ready :%s\n", status & 0x100 ? "Y" : "N");
00469 status = v792_CSR2Read(mvme, base);
00470 printf("CSR2: 0x%x\n", status);
00471 printf("Buffer Empty :%s\t", status & 0x2 ? "Y" : "N");
00472 printf(" - Buffer Full :%s\n", status & 0x4 ? "Y" : "N");
00473 int dtype = (status & 0xF0) >> 4;
00474 printf("Daughter card type (CSEL/DSEL) :%d%d%d%d (0x%x) ",
00475 status & 0x80 ? 1 : 0,
00476 status & 0x40 ? 1 : 0,
00477 status & 0x20 ? 1 : 0,
00478 status & 0x10 ? 1 : 0,
00479 dtype);
00480 switch (dtype) {
00481 default:
00482 printf("\n");
00483 break;
00484 case 2:
00485 printf("V792 32ch QDC\n");
00486 break;
00487 }
00488 status = v792_BitSet2Read(mvme, base);
00489 printf("BitSet2: 0x%x\n", status);
00490 printf("Test Mem :%s\t", status & 0x1 ? "Y" : "N");
00491 printf(" - Offline :%s\t", status & 0x2 ? "Y" : "N");
00492 printf(" - Clear Data :%s\n", status & 0x4 ? "Y" : "N");
00493 printf("Over Range En:%s\t", status & 0x8 ? "Y" : "N");
00494 printf(" - Low Thres En :%s\t", status & 0x10 ? "Y" : "N");
00495 printf(" - Auto Incr :%s\n", status & 0x20 ? "Y" : "N");
00496 printf("Empty Enable :%s\t", status & 0x1000 ? "Y" : "N");
00497 printf(" - Slide sub En :%s\t", status & 0x2000 ? "Y" : "N");
00498 printf(" - All Triggers :%s\n", status & 0x4000 ? "Y" : "N");
00499 v792_EvtCntRead(mvme, base, &status);
00500 printf("Event counter: %d\n", status);
00501 printf("Iped value: %d\n", v792_Read16(mvme, base, V792_IPED_RW));
00502
00503 v792_ThresholdRead(mvme, base, threshold);
00504 for (i=0;i<V792_MAX_CHANNELS;i+=2) {
00505 printf("Threshold[%2i] = 0x%4.4x\t - ", i, threshold[i]);
00506 printf("Threshold[%2i] = 0x%4.4x\n", i+1, threshold[i+1]);
00507 }
00508 mvme_set_dmode(mvme, cmode);
00509 }
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519 void v792_printEntry(const v792_Data* v) {
00520 switch (v->data.type) {
00521 case v792_typeMeasurement:
00522 printf("Data=0x%08x Measurement ch=%3d v=%6d over=%1d under=%1d\n",
00523 (int)v->raw,v->data.channel,v->data.adc,v->data.ov,v->data.un);
00524 break;
00525 case v792_typeHeader:
00526 printf("Data=0x%08x Header geo=%2x crate=%2x cnt=%2d\n",
00527 (int)v->raw,v->header.geo,v->header.crate,v->header.cnt);
00528 break;
00529 case v792_typeFooter:
00530 printf("Data=0x%08x Footer geo=%2x evtCnt=%7d\n",
00531 (int)v->raw,v->footer.geo,v->footer.evtCnt);
00532 break;
00533 case v792_typeFiller:
00534 printf("Data=0x%08x Filler\n",(int)v->raw);
00535 break;
00536 default:
00537 printf("Data=0x%08x Unknown %04x\n",(int)v->raw,v->data.type);
00538 break;
00539 }
00540 }
00541
00542
00543 int v792_isPresent(MVME_INTERFACE *mvme, DWORD base)
00544 {
00545 int status, cmode;
00546 mvme_get_dmode(mvme, &cmode);
00547 mvme_set_dmode(mvme, MVME_DMODE_D16);
00548 status = mvme_read_value(mvme, base+V792_FIRM_REV);
00549 mvme_set_dmode(mvme, cmode);
00550 if (status == 0xFFFF)
00551 return 0;
00552 else
00553 return 1;
00554 }
00555
00556
00557
00558 #ifdef MAIN_ENABLE
00559 int main (int argc, char* argv[]) {
00560
00561 DWORD VMEIO_BASE = 0x780000;
00562 DWORD V792_BASE = 0x500000;
00563
00564 MVME_INTERFACE *myvme;
00565
00566 int status, csr, i;
00567 DWORD cnt;
00568 DWORD dest[1000];
00569 WORD threshold[32];
00570
00571 if (argc>1) {
00572 sscanf(argv[1],"%lx",&V792_BASE);
00573 }
00574
00575
00576 status = mvme_open(&myvme, 0);
00577
00578
00579 mvme_set_am(myvme, MVME_AM_A24_ND);
00580
00581
00582 mvme_set_dmode(myvme, MVME_DMODE_D32);
00583
00584 v792_SingleShotReset(myvme, V792_BASE);
00585
00586 for (i=0;i<V792_MAX_CHANNELS;i++) {
00587 threshold[i] = 0;
00588 }
00589 v792_ThresholdWrite(myvme, V792_BASE, threshold);
00590 v792_DataClear(myvme, V792_BASE);
00591 v792_Setup(myvme, V792_BASE, 2);
00592
00593 v792_Status(myvme, V792_BASE);
00594
00595 while (1) {
00596 do {
00597 csr = v792_CSR1Read(myvme, V792_BASE);
00598 printf("CSR1: 0x%x\n", csr);
00599 csr = v792_CSR2Read(myvme, V792_BASE);
00600 printf("CSR2: 0x%x\n", csr);
00601 printf("Busy : %d\n", v792_isBusy(myvme, V792_BASE));
00602 #if defined(OS_LINUX)
00603 sleep(1);
00604 #endif
00605 } while (csr == 0);
00606
00607
00608 v792_EvtCntRead(myvme, V792_BASE, &cnt);
00609 printf("Event counter: 0x%lx\n", cnt);
00610
00611
00612 mvme_write_value(myvme, VMEIO_BASE+0x8, 0xF);
00613
00614
00615 mvme_write_value(myvme, VMEIO_BASE+0xc, 0x2);
00616
00617
00618
00619
00620
00621 mvme_write_value(myvme, VMEIO_BASE+0xc, 0x8);
00622
00623
00624
00625
00626
00627
00628 v792_EventRead(myvme, V792_BASE, dest, &status);
00629 printf("count: 0x%x\n", status);
00630 for (i=0;i<status;i++) {
00631 printf("%02d)",i);
00632 v792_printEntry((v792_Data*)&dest[i]);
00633 }
00634 }
00635 status = mvme_close(myvme);
00636 return 1;
00637 }
00638 #endif
00639
00640
00641
00642
00643
00644
00645
00646
00647