00001
00002
00003
00004
00005
00006
00007
00008
00009
00010 #include <stdio.h>
00011 #include <stdint.h>
00012 #include <string.h>
00013 #include "v1740drv.h"
00014 #include "mvmestd.h"
00015
00016
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
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
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
00138
00139 *n32word = 8 * V1740_NSAMPLES_MODE[regRead(mvme, base, V1740_BUFFER_ORGANIZATION)];
00140
00141
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;
00150 *n32word += 4;
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
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
00203
00204
00205
00206
00207
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
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
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
00244
00245
00246
00247
00248
00249
00250
00251
00252
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);
00266 regWrite(mvme, base, V1740_BUFFER_ORGANIZATION, 0x0A);
00267 regWrite(mvme, base, V1740_TRIG_SRCE_EN_MASK, 0x4000);
00268 regWrite(mvme, base, V1740_GROUP_EN_MASK, 0xFF);
00269 regWrite(mvme, base, V1740_POST_TRIGGER_SETTING, 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
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
00304 status = mvme_open(&myvme, 0);
00305
00306 v1740_Setup(myvme, V1740_BASE, 1);
00307
00308 v1740_AcqCtl(myvme, V1740_BASE, REGISTER_RUN_MODE);
00309
00310 v1740_TrgCtl(myvme, V1740_BASE, V1740_TRIG_SRCE_EN_MASK, V1740_SOFT_TRIGGER|V1740_EXTERNAL_TRIGGER);
00311
00312 v1740_TrgCtl(myvme, V1740_BASE, V1740_FP_TRIGGER_OUT_EN_MASK, V1740_SOFT_TRIGGER|V1740_EXTERNAL_TRIGGER);
00313
00314 v1740_GroupCtl(myvme, V1740_BASE, V1740_GROUP_EN_MASK, 0x1);
00315
00316
00317 group = 0;
00318
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
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
00360
00361
00362
00363
00364
00365
00366
00367
00368