v1740.c

Go to the documentation of this file.
00001 /*********************************************************************
00002 
00003   Name:         v1740.c
00004   Created by:   Pierre-A. Amaudruz / K.Olchanski
00005 
00006   Contents:     V1740 64 ch. 12bit 65Msps
00007  
00008   $Id: v1740.c 4728 2010-05-12 05:34:44Z svn $
00009 *********************************************************************/
00010 #include <stdio.h>
00011 #include <stdint.h>
00012 #include <string.h>
00013 #include "v1740drv.h"
00014 #include "mvmestd.h"
00015 
00016 // Buffer organization map for number of samples
00017 uint32_t V1740_NSAMPLES_MODE[11] = { (1024*192), (512*192), (256*192), (128*192), (64*192), (32*192)
00018                                ,(16*192), (8*192), (4*192), (2*192), (192)};
00019 
00020 /*****************************************************************/
00021 /*
00022 Read V1740 register value
00023 */
00024 static uint32_t regRead(MVME_INTERFACE *mvme, uint32_t base, int offset)
00025 {
00026   mvme_set_am(mvme, MVME_AM_A32);
00027   mvme_set_dmode(mvme, MVME_DMODE_D32);
00028   return mvme_read_value(mvme, base + offset);
00029 }
00030 
00031 /*****************************************************************/
00032 /*
00033 Write V1740 register value
00034 */
00035 static void regWrite(MVME_INTERFACE *mvme, uint32_t base, int offset, uint32_t value)
00036 {
00037   mvme_set_am(mvme, MVME_AM_A32);
00038   mvme_set_dmode(mvme, MVME_DMODE_D32);
00039   mvme_write_value(mvme, base + offset, value);
00040 }
00041 
00042 /*****************************************************************/
00043 uint32_t v1740_RegisterRead(MVME_INTERFACE *mvme, uint32_t base, int offset)
00044 {
00045   return regRead(mvme, base, offset);
00046 }
00047 
00048 /*****************************************************************/
00049 void v1740_RegisterWrite(MVME_INTERFACE *mvme, uint32_t base, int offset, uint32_t value)
00050 {
00051   regWrite(mvme, base, offset, value);
00052 }
00053 
00054 /*****************************************************************/
00055 void v1740_Reset(MVME_INTERFACE *mvme, uint32_t base)
00056 {
00057   regWrite(mvme, base, V1740_SW_RESET, 0);
00058 }
00059 
00060 /*****************************************************************/
00061 void v1740_TrgCtl(MVME_INTERFACE *mvme, uint32_t base, uint32_t reg, uint32_t mask)
00062 {
00063   regWrite(mvme, base, reg, mask);
00064 }
00065 
00066 /*****************************************************************/
00067 void v1740_GroupCtl(MVME_INTERFACE *mvme, uint32_t base, uint32_t reg, uint32_t mask)
00068 {
00069   regWrite(mvme, base, reg, mask);
00070 }
00071 
00072 /*****************************************************************/
00073 void v1740_GroupThreshold(MVME_INTERFACE *mvme, uint32_t base, uint16_t group, uint16_t threshold)
00074 {
00075   uint32_t reg;
00076   
00077   reg = V1740_GROUP_THRESHOLD | (group << 8);
00078   regWrite(mvme, base, reg, (threshold & 0xFFF));
00079 }
00080 
00081 /*****************************************************************/
00082 void v1740_GroupDAC(MVME_INTERFACE *mvme, uint32_t base, uint16_t group, uint16_t dac)
00083 {
00084   uint32_t reg;
00085   
00086   reg = V1740_GROUP_DAC | (group << 8);
00087   regWrite(mvme, base, reg, (dac & 0xFFFF));
00088 }
00089 
00090 /*****************************************************************/
00091 void v1740_AcqCtl(MVME_INTERFACE *mvme, uint32_t base, uint32_t operation)
00092 {
00093   uint32_t reg;
00094   
00095   reg = regRead(mvme, base, V1740_ACQUISITION_CONTROL);  
00096   switch (operation) {
00097   case V1740_RUN_START:
00098     regWrite(mvme, base, V1740_ACQUISITION_CONTROL, (reg | 0x4));
00099     break;
00100   case V1740_RUN_STOP:
00101     regWrite(mvme, base, V1740_ACQUISITION_CONTROL, (reg & ~(0x4)));
00102     break;
00103   case V1740_REGISTER_RUN_MODE:
00104     regWrite(mvme, base, V1740_ACQUISITION_CONTROL, (reg & ~(0x3)));
00105     break;
00106   case V1740_SIN_RUN_MODE:
00107     regWrite(mvme, base, V1740_ACQUISITION_CONTROL, (reg | 0x01));
00108     break;
00109   case V1740_SIN_GATE_RUN_MODE:
00110     regWrite(mvme, base, V1740_ACQUISITION_CONTROL, (reg | 0x02));
00111     break;
00112   case V1740_MULTI_BOARD_SYNC_MODE:
00113     regWrite(mvme, base, V1740_ACQUISITION_CONTROL, (reg | 0x03));
00114     break;
00115   case V1740_COUNT_ACCEPTED_TRIGGER:
00116     regWrite(mvme, base, V1740_ACQUISITION_CONTROL, (reg | 0x08));
00117     break;
00118   case V1740_COUNT_ALL_TRIGGER:
00119     regWrite(mvme, base, V1740_ACQUISITION_CONTROL, (reg & ~(0x08)));
00120     break;
00121   case V1740_DOWNSAMPLE_ENABLE:
00122     regWrite(mvme, base, V1740_ACQUISITION_CONTROL, (reg & 0x10));
00123     break;
00124   case V1740_DOWNSAMPLE_DISABLE:
00125     regWrite(mvme, base, V1740_ACQUISITION_CONTROL, (reg & ~(0x10)));
00126     break;
00127   default:
00128     break;
00129   }
00130 }
00131 
00132 /*****************************************************************/
00133 void v1740_info(MVME_INTERFACE *mvme, uint32_t base, int *ngroups, uint32_t *n32word)
00134 {
00135   int i, grpmask;
00136 
00137   // Evaluate the event size
00138   // Number of samples per group (8 channels)
00139   *n32word = 8 * V1740_NSAMPLES_MODE[regRead(mvme, base, V1740_BUFFER_ORGANIZATION)];
00140 
00141   // times the number of active group
00142   grpmask = 0xff & regRead(mvme, base, V1740_GROUP_EN_MASK); 
00143   *ngroups = 0;
00144   for (i=0;i<8;i++) {
00145     if (grpmask & (1<<i))
00146       *ngroups += 1;
00147   }
00148   
00149   *n32word = *n32word * *ngroups * 12 / 32;  // 12bit/Sample , 32bits/DW
00150   *n32word += 4;    // Headers
00151 }
00152 
00153 /*****************************************************************/
00154 uint32_t v1740_BufferOccupancy(MVME_INTERFACE *mvme, uint32_t base, uint32_t group)
00155 {
00156   uint32_t reg;
00157   reg = V1740_GROUP_BUFFER_OCCUPANCY + (group<<16);
00158   return regRead(mvme, base, reg);
00159 }
00160 
00161 
00162 /*****************************************************************/
00163 uint32_t v1740_BufferFree(MVME_INTERFACE *mvme, uint32_t base, int nbuffer)
00164 {
00165   int mode;
00166 
00167   mode = regRead(mvme, base, V1740_BUFFER_ORGANIZATION);
00168   if (nbuffer <= (1<< mode) ) {
00169     regWrite(mvme, base, V1740_BUFFER_FREE, nbuffer);
00170     return mode;
00171   } else
00172     return mode;
00173 }
00174 
00175 /*****************************************************************/
00176 uint32_t v1740_BufferFreeRead(MVME_INTERFACE *mvme, uint32_t base)
00177 {
00178   return regRead(mvme, base, V1740_BUFFER_FREE);
00179 }
00180 
00181 /*****************************************************************/
00182 uint32_t v1740_DataRead(MVME_INTERFACE *mvme, uint32_t base, uint32_t *pdata, uint32_t n32w)
00183 {
00184   uint32_t i;
00185 
00186   mvme_set_am(  mvme, MVME_AM_A32);
00187   mvme_set_dmode(  mvme, MVME_DMODE_D32);
00188   n32w = 0xFFFFFF & regRead(mvme, base, V1740_EVENT_READOUT_BUFFER);
00189   //  printf("DataRead n32w:%d 0x%x\n", n32w, n32w);
00190   *pdata++ = n32w;
00191   for (i=0;i<n32w-1;i++) {
00192     *pdata = regRead(mvme, base, V1740_EVENT_READOUT_BUFFER);
00193     if (*pdata != 0xffffffff)
00194       pdata++;
00195     else
00196       break;
00197   }
00198   return i+1;
00199 }
00200 
00201 /********************************************************************/
00202 /** v1740_DataBlockRead
00203 Read N entries (32bit) 
00204 @param mvme vme structure
00205 @param base  base address
00206 @param pdest Destination pointer
00207 @return nentry
00208 */
00209 uint32_t v1740_DataBlockRead(MVME_INTERFACE *mvme, uint32_t base, uint32_t *pdest, uint32_t *nentry)
00210 {
00211   int status, ngroups;
00212 
00213   mvme_set_am(  mvme, MVME_AM_A32);
00214   mvme_set_dmode(  mvme, MVME_DMODE_D32);
00215   v1740_info(mvme, base, &ngroups, nentry);
00216   // *nentry = 0xFFFFFF & regRead(mvme, base, V1740_EVENT_READOUT_BUFFER);
00217   printf("DataBlockRead n32w:%d 0x%x\n", *nentry, *nentry);
00218   mvme_set_blt(  mvme, MVME_BLT_MBLT64);
00219   mvme_set_blt(  mvme, 0);
00220   //
00221   // Transfer in MBLT64 (8bytes), nentry is in 32bits
00222   status = mvme_read(mvme, pdest, base+V1740_EVENT_READOUT_BUFFER, *nentry<<2);
00223   if (status != MVME_SUCCESS)
00224     return 0;
00225 
00226   return (*nentry);
00227 }
00228 
00229 
00230 /*****************************************************************/
00231 void  v1740_Status(MVME_INTERFACE *mvme, uint32_t base)
00232 {
00233   printf("================================================\n");
00234   printf("V1740 at A32 0x%x\n", (int)base);
00235   printf("Board ID             : 0x%x\n", regRead(mvme, base, V1740_BOARD_ID));
00236   printf("Board Info           : 0x%x\n", regRead(mvme, base, V1740_BOARD_INFO));
00237   printf("Acquisition status   : 0x%8.8x\n", regRead(mvme, base, V1740_ACQUISITION_STATUS));
00238   printf("================================================\n");
00239 }
00240 
00241 /*****************************************************************/
00242 /**
00243 Sets all the necessary paramters for a given configuration.
00244 The configuration is provided by the mode argument.
00245 Add your own configuration in the case statement. Let me know
00246 your setting if you want to include it in the distribution.
00247 - <b>Mode 1</b> : 
00248 
00249 @param *mvme VME structure
00250 @param  base Module base address
00251 @param mode  Configuration mode number
00252 @return 0: OK. -1: Bad
00253 */
00254 int  v1740_Setup(MVME_INTERFACE *mvme, uint32_t base, int mode)
00255 {
00256   switch (mode) {
00257   case 0x0:
00258     printf("--------------------------------------------\n");
00259     printf("Setup Skip\n");
00260     printf("--------------------------------------------\n");
00261   case 0x1:
00262     printf("--------------------------------------------\n");
00263     printf("Trigger from FP, 8 group, 1Ks, postTrigger 800\n");
00264     printf("--------------------------------------------\n");
00265     regWrite(mvme, base, V1740_ACQUISITION_CONTROL,   0x00);   // Reset Acq Control
00266     regWrite(mvme, base, V1740_BUFFER_ORGANIZATION,  0x0A);    // 1K Nbuffers=1024, bufferSize=192
00267     regWrite(mvme, base, V1740_TRIG_SRCE_EN_MASK,    0x4000);  // External Trigger
00268     regWrite(mvme, base, V1740_GROUP_EN_MASK,      0xFF);    // 8grp enable
00269     regWrite(mvme, base, V1740_POST_TRIGGER_SETTING, 800);     // PreTrigger (1K-800)
00270     printf("\n");
00271     break;
00272   case 0x2:
00273     printf("--------------------------------------------\n");
00274     printf("Trigger from LEMO\n");
00275     printf("--------------------------------------------\n");
00276     regWrite(mvme, base, V1740_BUFFER_ORGANIZATION, 1);
00277     printf("\n");
00278     break;
00279   default:
00280     printf("Unknown setup mode\n");
00281     return -1;
00282   }
00283   v1740_Status(mvme, base);
00284   return 0;
00285 }
00286 
00287 /*****************************************************************/
00288 /*-PAA- For test purpose only */
00289 #ifdef MAIN_ENABLE
00290 int main (int argc, char* argv[]) {
00291 
00292   uint32_t V1740_BASE  = 0x32100000;
00293 
00294   MVME_INTERFACE *myvme;
00295 
00296   uint32_t data[100000], n32word, n32read;
00297   int i, status, group, ngroups=0;
00298 
00299   if (argc>1) {
00300     sscanf(argv[1],"%x", &V1740_BASE);
00301   }
00302 
00303   // Test under vmic
00304   status = mvme_open(&myvme, 0);
00305 
00306   v1740_Setup(myvme, V1740_BASE, 1);
00307   // Run control by register
00308   v1740_AcqCtl(myvme, V1740_BASE, REGISTER_RUN_MODE);
00309   // Soft or External trigger
00310   v1740_TrgCtl(myvme, V1740_BASE, V1740_TRIG_SRCE_EN_MASK, V1740_SOFT_TRIGGER|V1740_EXTERNAL_TRIGGER);
00311   // Soft and External trigger output
00312   v1740_TrgCtl(myvme, V1740_BASE, V1740_FP_TRIGGER_OUT_EN_MASK, V1740_SOFT_TRIGGER|V1740_EXTERNAL_TRIGGER);
00313   // Enabled groups
00314   v1740_GroupCtl(myvme, V1740_BASE, V1740_GROUP_EN_MASK, 0x1);
00315   //  sleep(1);
00316 
00317   group = 0;
00318   // Evaluate the event size
00319   v1740_info(myvme, V1740_BASE, &ngroups, &n32word);
00320   printf("ngroups: %d  n32word: %d\n", ngroups, n32word);
00321   printf("Occupancy for group %d = %d\n", group, v1740_BufferOccupancy(myvme, V1740_BASE, group)); 
00322 
00323   // Start run then wait for trigger
00324   v1740_AcqCtl(myvme, V1740_BASE, RUN_START);
00325   sleep(1);
00326 
00327   regWrite(myvme, V1740_BASE, V1740_SOFTWARE_TRIGGER, 1);
00328   
00329 #if 0
00330   do {
00331     status = regRead(myvme, V1740_BASE, V1740_ACQUISITION_STATUS);
00332     printf("Acq Status:0x%x\n", status);
00333   } while ((status & 0x8)==0);
00334   
00335   n32read = v1740_DataRead(myvme, V1740_BASE, &(data[0]), n32word);
00336   printf("n32read:%d\n", n32read);
00337 }
00338 #endif
00339 
00340 #if 1
00341   n32read = v1740_DataBlockRead(myvme, V1740_BASE, &(data[0]), &n32word);
00342 #endif  
00343 
00344   for (i=0; i<n32read;i+=4) {
00345     printf("[%3d]:0x%8.8x - [%3d]:0x%8.8x - [%3d]:0x%8.8x - [%3d]:0x%8.8x\n"
00346          , i, data[i], i+1, data[i+1], i+2, data[i+2], i+3, data[i+3]);
00347   }
00348   
00349   v1740_AcqCtl(myvme, V1740_BASE, RUN_STOP);
00350   
00351   regRead(myvme, V1740_BASE, V1740_ACQUISITION_CONTROL);
00352   status = mvme_close(myvme);
00353 
00354   return 1;
00355 
00356 }
00357 #endif
00358 
00359 /* emacs
00360  * Local Variables:
00361  * mode:C
00362  * mode:font-lock
00363  * tab-width: 8
00364  * c-basic-offset: 2
00365  * End:
00366  */
00367 
00368 //end

Midas DOC Version 3.0.0 ---- 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