v792.c

Go to the documentation of this file.
00001 /*********************************************************************
00002   @file
00003   Name:         v792.c
00004   Created by:   Pierre-Andre Amaudruz
00005   Contributors: Sergio Ballestrero
00006 
00007   Contents:     V792 32ch. QDC
00008                 V785 32ch. Peak ADC include
00009                 V792 and V785 are mostly identical;
00010                 v792_ identifies commands supported by both
00011                 v792_ identifies commands supported by V792 only
00012                 v785_ identifies commands supported by V785 only
00013                 
00014   $Id: v792.c 4078 2007-11-21 18:48:11Z olchanski $
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 Read single event, return event length (number of entries)
00039 Uses single vme access! (1us/D32)
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)); // skip up to the header
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)); // copy until the trailer
00061 
00062     nentry--;
00063   }
00064   mvme_set_dmode(mvme, cmode);
00065   return *nentry;
00066 }
00067 
00068 /*****************************************************************/
00069 /*
00070 Read nentry of data from the data buffer. Will use the DMA engine
00071 if size is larger than 127 bytes.
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  * Write Thresholds and read them back
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  * Read Thresholds
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   /* Use the trigger buffer for int enable/disable
00346   mvme_write_value(mvme, base+V792_INT_LEVEL_WO, (level & 0x7));
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   /* Use the trigger buffer for int enable/disable
00359      Setting a level 0 reboot the VMIC !
00360   mvme_write_value(mvme, base+V792_INT_LEVEL_WO, 0);
00361   */
00362   mvme_set_dmode(mvme, cmode);
00363 }
00364 
00365 /*****************************************************************/
00366 /**
00367  * read Control Register 1 (0x1010,16 bit)
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  * write Control Register 1 (0x1010,16 bit)
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  * cause a software trigger
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 Sets all the necessary paramters for a given configuration.
00406 The configuration is provided by the mode argument.
00407 Add your own configuration in the case statement. Let me know
00408 your setting if you want to include it in the distribution.
00409 @param *mvme VME structure
00410 @param  base Module base address
00411 @param mode  Configuration mode number
00412 @param *nentry number of entries requested and returned.
00413 @return MVME_SUCCESS
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  * decoded printout of readout entry
00514  * Not to be trusted for data decoding but acceptable for display
00515  * purpose as its implementation is strongly compiler dependent and
00516  * not flawless.
00517  * @param v
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 /*-PAA- For test purpose only */
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   // Test under vmic
00576   status = mvme_open(&myvme, 0);
00577 
00578   // Set am to A24 non-privileged Data
00579   mvme_set_am(myvme, MVME_AM_A24_ND);
00580 
00581   // Set dmode to D32
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     // Read Event Counter
00608     v792_EvtCntRead(myvme, V792_BASE, &cnt);
00609     printf("Event counter: 0x%lx\n", cnt);
00610 
00611     // Set 0x3 in pulse mode for timing purpose
00612     mvme_write_value(myvme, VMEIO_BASE+0x8, 0xF);
00613 
00614     // Write pulse for timing purpose
00615     mvme_write_value(myvme, VMEIO_BASE+0xc, 0x2);
00616 
00617     //  cnt=32;
00618     //  v792_DataRead(myvme, V792_BASE, dest, &cnt);
00619 
00620     // Write pulse for timing purpose
00621     mvme_write_value(myvme, VMEIO_BASE+0xc, 0x8);
00622 
00623     //  for (i=0;i<32;i++) {
00624     //    printf("Data[%i]=0x%x\n", i, dest[i]);
00625     //  }
00626 
00627     //  status = 32;
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 /* emacs
00641  * Local Variables:
00642  * mode:C
00643  * mode:font-lock
00644  * tab-width: 8
00645  * c-basic-offset: 2
00646  * End:
00647  */

Midas DOC Version 2.0.2 ---- PSI Stefan Ritt ----
Contributions: Pierre-Andre Amaudruz - Sergio Ballestrero - Suzannah Daviel - Doxygen - Peter Green - Qing Gu - Greg Hackman - Gertjan Hofman - Paul Knowles - Exaos Lee - Rudi Meier - Glenn Moloney - Dave Morris - John M O'Donnell - Konstantin Olchanski - Renee Poutissou - Tamsen Schurman - Andreas Suter - Jan M.Wouters - Piotr Adam Zolnierczuk