StRoot: RTS/src/DAQ_SSD/ssd_reader.cxx Source File

00001 #include <string.h>
00002 #include <arpa/inet.h>
00003 
00004 #include <daqFormats.h>
00005 #include <rtsSystems.h>
00006 #include <rtsLog.h>
00007 #include <rts.h>
00008 
00009 
00010 #include "daq_ssd.h"
00011 
00012 static int unpackRaw(int rb, int mz, int what, char *mem, ssd_t *ssd) ;
00013 
00014 
00015 /* UNUSED 
00016 static struct ssdMap {
00017         u_char start_ladder ;
00018         u_char side ;
00019 } ssdMap[4][2] = {
00020         { {0,0}, {5,0} },
00021         { {10,0}, {15,0} },
00022         { {0,1}, {5,1} },
00023         { {10,1}, {15,1} }
00024 } ;
00025 */
00026 
00027 int ssd_reader(char *m, struct ssd_t *ssd, u_int driver)
00028 {
00029         int sec ;
00030         int rb, mz ;
00031         int len ;
00032         u_int off ;
00033         static int init ;
00034 
00035         struct TPCP *ssdp ;
00036         struct TPCSECP *secp ;
00037         struct TPCRBP *rbp ;
00038         struct TPCMZP *mzp ;
00039         struct TPCSEQD *seqd ;
00040         struct TPCADCD *adcd ;
00041         struct TPCPADK *padk ;
00042         struct TPCADCR_l *adcr ;
00043         struct TPCCPPR_l *cppr ;
00044         struct TPCPEDR *pedr ;
00045         struct TPCRMSR *rmsr ;
00046         struct DATAP *datap ;
00047         struct DATAPX *datapx ;
00048 
00049 
00050 
00051         // clear total channels 
00052         ssd->channels = 0 ;
00053 
00054         // set the max channel num - constant
00055         ssd->max_channels = 20*16*2*768 ;
00056 
00057 
00058         if(m == NULL) return 0 ;
00059 
00060         datap = (struct DATAP *)m ;
00061 
00062         int swapdatap = 0;
00063         if(datap->bh.byte_order != DAQ_RAW_FORMAT_ORDER) swapdatap = 1;
00064         
00065         len = qswap32(swapdatap, datap->det[EXT_ID].len) ;
00066         if(len == 0) return 0 ; // not even a xtended det
00067         off = qswap32(swapdatap, datap->det[EXT_ID].off) ;
00068         if(off == 0) return 0 ; // not even a xtended det
00069 
00070         datapx = (struct DATAPX *)((u_int *)m + off) ;
00071 
00072         int swapdatapx = 0;
00073         if(datapx->bh.byte_order != DAQ_RAW_FORMAT_ORDER) swapdatapx = 1;
00074 
00075         // verify bank
00076         if(checkBank(datapx->bh.bank_type, CHAR_DATAPX) < 0) {
00077                 return 0 ;
00078         }
00079 
00080 
00081         len = qswap32(swapdatapx, datapx->det[SSD_ID-10].len) * 4 ;
00082         if(len == 0) return 0 ;
00083 
00084 
00085         off = qswap32(swapdatapx, datapx->det[SSD_ID-10].off) ;
00086         if(off == 0) return 0 ;
00087 
00088         ssdp = (struct TPCP *)((u_int *)datapx + off) ;
00089         if(checkBank((char *)ssdp,"SSDP") < 0) return 0 ;       // wrong bank!
00090 
00091 
00092         if(!init) {     // this is the first call
00093                 // fool the system into clearing stuff
00094                 ssd->mode = 1 ;
00095 
00096                 init = 1 ;
00097         }
00098 
00099 
00100         // clear the raw contrib
00101         memset(ssd->raw,0,sizeof(ssd->raw)) ;
00102 
00103         // clear the data part
00104         memset((char *)ssd->counts,0,sizeof(ssd->counts)) ;
00105 
00106         // clear mode before
00107         ssd->mode = 0 ;
00108 
00109         u_int occup[4][3] ;
00110         memset(occup,0,sizeof(occup)) ;
00111 
00112         for(sec=0;sec<1;sec++) {        // just one sector! I kept the for loop for compatibility
00113                 int last ;
00114 
00115 
00116                 if(ssdp->sb[sec].len == 0) continue ;
00117 
00118                 secp = (struct TPCSECP *) ((u_int *)ssdp + b2h32(ssdp->sb[sec].off)) ;
00119                 if(checkBank((char *)secp,"SSDSECP") < 0) return 0 ;
00120 
00121                 last = 4 ;      // 4 RBs max!
00122 
00123                 for(rb=0;rb<last;rb++) {
00124 
00125 
00126                         if(secp->rb[rb].len == 0) continue ;
00127 
00128                         rbp = (struct TPCRBP *) ((u_int *)secp + b2h32(secp->rb[rb].off)) ;
00129                         if(checkBank((char *)rbp,"SSDRBP") < 0) {
00130                                 continue ;
00131                         }
00132 
00133                         // at this point (RBP) data is different endianess...
00134 
00135                         for(mz=0;mz<2;mz++) {   // 3rd mezzanine will be always empty...
00136                                 if(rbp->mz[mz].len == 0) continue ;
00137 
00138                                 mzp = (struct TPCMZP *)((u_int *)rbp + l2h32(rbp->mz[mz].off)) ;
00139                                 if(checkBank((char *)mzp,"SSDMZP") < 0) {
00140                                         continue ;
00141                                 }
00142 
00143                                 // what do we have here...
00144                                 if((mzp->banks[TPC_ADCD].len != 0) && (ssd->mode==0)) { // zero-suppressed
00145 
00146 
00147                                         seqd = (struct TPCSEQD *)((u_int *)mzp + l2h32(mzp->banks[TPC_SEQD].off)) ;
00148                                         adcd = (struct TPCADCD *)((u_int *)mzp + l2h32(mzp->banks[TPC_ADCD].off)) ;
00149 
00150                                         if(checkBank((char *)seqd,"SSDSEQD") < 0) continue ;
00151                                         if(checkBank((char *)adcd,"SSDADCD") < 0) continue ;
00152 
00153                                         int len = l2h32(seqd->bh.length) - 10 ;
00154                                         len *= 2 ;
00155 
00156                                         int adccou = 0 ;
00157                                         int jj ;
00158 
00159                                         int rr, pp ;
00160 
00161                                         rr = pp = 1 ;
00162 
00163                                         for(jj=0;jj<len;jj++) {
00164                                                 int start, last, length, stop ;
00165                                                 u_short ss, f8 ;
00166                                                 int tbin ;
00167 
00168                                                 ss = l2h16(seqd->seq[jj]) ;
00169                                                 f8 = ss & 0x8000 ;
00170 
00171 
00172                                                 if(f8) {        // new pad flags
00173                                                         pp = (ss & 0x7FFF) % 256 ;      // pad
00174                                                         rr = (ss & 0x7FFF) / 256 ;      // row
00175 
00176                                                         //LOG(DBG,"f8: last %d, start %d, stop %d, pp %d, rr %d",last,start,stop,pp,rr) ;
00177                                                         if(pp == 0xff) break ;
00178                                                 }
00179                                                 else {
00180                                                         last = ss & 0x0020 ;
00181                                                         length = ss & 0x1F ;
00182                                                         start = (ss & 0x7FC0) >> 6 ;
00183                                                         stop = start + length ;
00184 
00185                                                         //LOG(DBG,"last %d, start %d, stop %d, pp %d, rr %d",last,start,stop,pp,rr) ;
00186 
00187                                                         for(tbin=start;tbin<stop;tbin++) {
00188                                                                 u_char val ;
00189                                                                 int counter ;
00190 
00191                                                                 val = adcd->adc[adccou++] ;
00192 
00193 
00194 
00195                                                                 //printf("SSD %d:%d strip %d: adc %d\n",rr,pp,tbin,val) ;
00196 
00197                                                                 if(val==0) continue ;
00198 
00199                                                                 counter = ssd->counts[rr-1][pp-1] ;
00200 
00201                                                                 ssd->adc[rr-1][pp-1][counter] = val ;
00202                                                                 ssd->strip[rr-1][pp-1][counter] = tbin ;
00203                                                                 ssd->counts[rr-1][pp-1] += 1 ;
00204                                                                 ssd->channels++ ;
00205 
00206                                                                 occup[rb][mz]++ ;
00207                                                         }
00208 
00209                                                         if(last) pp++ ; // increment the pad for next time
00210                                                 }
00211 
00212                                         }
00213 
00214                                 LOG(NOTE,"SSD: RB %d, MZ %d: counts %d",rb,mz,occup[rb][mz]) ;
00215 
00216                                         continue ;      // don;t look at more banks!
00217 
00218 
00219                                 }
00220 
00221                                 padk = NULL ;
00222                                 if(mzp->banks[TPC_PADK].len != 0) {     
00223                                         padk = (struct TPCPADK *)((u_int *)mzp + l2h32(mzp->banks[TPC_PADK].off)) ;
00224 
00225                                         if(checkBank((char *)padk,"SSDPADK") < 0) return 0 ;
00226 
00227                                 }
00228 
00229                                 cppr = NULL ;
00230                                 if(mzp->banks[TPC_CPPR].len != 0) {
00231 
00232                                         cppr = (struct TPCCPPR_l *)((u_int *)mzp + l2h32(mzp->banks[TPC_CPPR].off)) ;
00233                                         if(checkBank((char *)cppr,"SSDCPPR") < 0) return 0 ;
00234                                 }
00235 
00236                                 if((mzp->banks[TPC_ADCR].len != 0) && (ssd->mode==0)) { // raw ...
00237                                         adcr = (struct TPCADCR_l *)((u_int *)mzp + l2h32(mzp->banks[TPC_ADCR].off)) ;
00238 
00239                                         if(checkBank((char *)adcr,"SSDADCR") < 0) return 0 ;
00240 
00241                                         if(unpackRaw(rb, mz, 0, (char *)adcr, ssd) < 0) {
00242                                                 LOG(ERR,"Problems in RAW data in sector %d, RB %d, MZ %d - skipping...",
00243                                                     sec+1,rb+1,mz+1,0,0) ;
00244                                         }
00245 
00246                                         LOG(DBG,"SSD Raw data bank in sector %d, RB %d, MZ %d!",
00247                                             sec+1,rb+1,mz+1,0,0) ;
00248                                         continue ;
00249                                 }
00250 
00251                                 if(mzp->banks[TPC_PEDR].len != 0) {     // pedestal data!
00252                                         pedr = (struct TPCPEDR *)((u_int *)mzp + l2h32(mzp->banks[TPC_PEDR].off)) ;
00253 
00254                                         if(checkBank((char *)pedr,"SSDPEDR") < 0) return 0 ;
00255 
00256                                         unpackRaw(rb, mz, 1,(char *)pedr,ssd) ;
00257                                         ssd->mode = 1 ; // pedestal data!
00258                         
00259                                 }
00260 
00261                                 if(mzp->banks[TPC_RMSR].len != 0) {     // RMS too 
00262                                         rmsr = (struct TPCRMSR *)((u_int *)mzp + l2h32(mzp->banks[TPC_RMSR].off)) ;
00263 
00264                                         if(checkBank((char *)rmsr,"SSDRMSR") < 0) return 0 ;
00265 
00266                                         unpackRaw(rb, mz, 2, (char *)rmsr, ssd) ;
00267                                         ssd->mode = 1 ; // pedestal data!
00268 
00269                                 }
00270                                 
00271 
00272                         }
00273                                 
00274                 }
00275                         
00276         }
00277 
00278 
00279 
00280         return len ;
00281 }
00282 
00283 
00284 /*
00285         what    == 0    ADCR
00286         what    == 1    PEDR
00287         what    == 2    RMSR
00288 */
00289 
00290 static int unpackRaw(int rb, int mz, int what, char *mem, ssd_t *ssd)
00291 {
00292 
00293         u_char *adcdata ;
00294         int as, ch, strip, cou ;
00295         u_char *dta ;
00296         int row ;
00297 
00298         if(mem == NULL) {
00299                 LOG(WARN,"No DATA? - skipping...",0,0,0,0,0) ;
00300                 return 0 ;
00301         }
00302 
00303         if(mz == 2) {
00304                 LOG(WARN,"MZ3 should not exist in SSD's RB %d - skipping...",rb+1,0,0,0,0) ;
00305         }
00306 
00307         adcdata = NULL ;
00308 
00309         switch(what) {
00310         case 0 :        // ADCR 
00311                 adcdata = (u_char *) mem + sizeof(struct TPCADCR_l);
00312                 ssd->raw[rb][mz] = adcdata ;
00313                 LOG(NOTE,"SSD rb %d, mz %d: raw...",rb,mz) ;
00314                 break ;
00315         case 1 :        // PEDR
00316                 adcdata = ((struct TPCPEDR *)mem)->ped ;
00317                 ssd->raw[rb][mz] = adcdata ;
00318                 for(as=0;as<5;as++) {
00319                         row = rb*10+mz*5+as ;   // calc the pseudo-row
00320 
00321                         //printf("Doing RB %d, MZ %c: AS %c\n",rb+1,'A'+mz,'A'+as);
00322 
00323                         for(ch=0;ch<64;ch++) {
00324                                 dta = adcdata + (as*64*512) + (ch*512) ;
00325                                 memcpy(ssd->adc[row][ch],dta,192) ;
00326                         }
00327                 }
00328 
00329                 ssd->channels += 5*64*192 ;
00330                 return 0 ;
00331         case 2 :        // RMSR
00332                 adcdata = ((struct TPCRMSR *)mem)->rms ;
00333                 for(as=0;as<5;as++) {
00334                         row = rb*10+mz*5+as ;
00335                         for(ch=0;ch<64;ch++) {
00336                                 dta = adcdata + (as*64*512) + (ch*512) ;
00337                                 memcpy(ssd->strip[row][ch],dta,192) ;
00338                         }
00339                 }
00340                 return 0 ;
00341 
00342         }
00343 
00344 
00345 
00346         // I'll go over the first 5 ASIC blocks
00347 
00348         for(as=0;as<5;as++) {
00349                 row = rb*10+mz*5+as ;   // pseudo-row
00350 
00351                 for(ch=0;ch<64;ch++) {
00352 
00353                         dta = adcdata + (as*64*512) + ch*512 ;
00354 
00355                         cou = 0 ;
00356                         for(strip=0;strip<192;strip++) {
00357 
00358 
00359                                 if(*dta) {
00360                                         ssd->channels++ ;
00361                                         ssd->strip[row][ch][cou] = strip ;
00362                                         ssd->adc[row][ch][cou] = *dta ;
00363                                         cou++ ;
00364                                 }
00365 
00366                                 dta++ ;
00367                         }
00368 
00369                         ssd->counts[row][ch] += cou ;
00370                 }
00371 
00372 
00373         }
00374         
00375 
00376         return 0 ;
00377 
00378 }