TRD/AliTRDtrapConfig.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 ////////////////////////////////////////////////////////////////////////////
  17 //                                                                        //
  18 //  TRAP config                                                           //
  19 //                                                                        //
  20 //  Author: J. Klein (Jochen.Klein@cern.ch)                               //
  21 //                                                                        //
  22 ////////////////////////////////////////////////////////////////////////////
  23
  24 #include "AliLog.h"
  25
  26 #include "AliTRDgeometry.h"
  27 #include "AliTRDfeeParam.h"
  28 #include "AliTRDtrapConfig.h"
  29
  30 #include <fstream>
  31 #include <iostream>
  32 #include <iomanip>
  33
  34 ClassImp(AliTRDtrapConfig)
  35
  36 AliTRDtrapConfig* AliTRDtrapConfig::fgInstance = 0x0;
  37 const Int_t AliTRDtrapConfig::fgkMaxMcm = AliTRDfeeParam::GetNmcmRob() + 2;
  38 const Int_t AliTRDtrapConfig::fgkDmemStartAddress = 0xc000;
  39
  40 AliTRDtrapConfig::AliTRDtrapConfig() :
  41   TObject()
  42 {
  43   // default constructor, initializing array of TRAP registers
  44
  45   //                              Name          Address  Nbits   Reset Value
  46   fRegs[kSML0]    =   SimpleReg_t("SML0",        0x0A00, 15,     0x4050     );  // Global state machine
  47   fRegs[kSML1]    =   SimpleReg_t("SML1",        0x0A01, 15,     0x4200     );
  48   fRegs[kSML2]    =   SimpleReg_t("SML2",        0x0A02, 15,     0x4384     );
  49   fRegs[kSMMODE]  =   SimpleReg_t("SMMODE",      0x0A03, 16,     0xF0E2     );
  50   fRegs[kNITM0]   =   SimpleReg_t("NITM0",       0x0A08, 14,     0x3FFF     );
  51   fRegs[kNITM1]   =   SimpleReg_t("NITM1",       0x0A09, 14,     0x3FFF     );
  52   fRegs[kNITM2]   =   SimpleReg_t("NITM2",       0x0A0A, 14,     0x3FFF     );
  53   fRegs[kNIP4D]   =   SimpleReg_t("NIP4D",       0x0A0B, 7,      0x7F       );
  54   fRegs[kCPU0CLK] =   SimpleReg_t("CPU0CLK",     0x0A20, 5,      0x07       );
  55   fRegs[kCPU1CLK] =   SimpleReg_t("CPU1CLK",     0x0A22, 5,      0x07       );
  56   fRegs[kCPU2CLK] =   SimpleReg_t("CPU2CLK",     0x0A24, 5,      0x07       );
  57   fRegs[kCPU3CLK] =   SimpleReg_t("CPU3CLK",     0x0A26, 5,      0x07       );
  58   fRegs[kNICLK]   =   SimpleReg_t("NICLK",       0x0A28, 5,      0x07       );
  59   fRegs[kFILCLK]  =   SimpleReg_t("FILCLK",      0x0A2A, 5,      0x07       );
  60   fRegs[kPRECLK]  =   SimpleReg_t("PRECLK",      0x0A2C, 5,      0x07       );
  61   fRegs[kADCEN]   =   SimpleReg_t("ADCEN",       0x0A2E, 5,      0x07       );
  62   fRegs[kNIODE]   =   SimpleReg_t("NIODE",       0x0A30, 5,      0x07       );
  63   fRegs[kNIOCE]   =   SimpleReg_t("NIOCE",       0x0A32, 6,      0x21       );  // bit 5 is status bit (read-only)!
  64   fRegs[kNIIDE]   =   SimpleReg_t("NIIDE",       0x0A34, 5,      0x07       );
  65   fRegs[kNIICE]   =   SimpleReg_t("NIICE",       0x0A36, 5,      0x07       );
  66   fRegs[kARBTIM]  =   SimpleReg_t("ARBTIM",      0x0A3F, 4,      0x0        );  // Arbiter
  67   fRegs[kIA0IRQ0] =   SimpleReg_t("IA0IRQ0",     0x0B00, 12,     0x000      );  // IVT of CPU0
  68   fRegs[kIA0IRQ1] =   SimpleReg_t("IA0IRQ1",     0x0B01, 12,     0x000      );
  69   fRegs[kIA0IRQ2] =   SimpleReg_t("IA0IRQ2",     0x0B02, 12,     0x000      );
  70   fRegs[kIA0IRQ3] =   SimpleReg_t("IA0IRQ3",     0x0B03, 12,     0x000      );
  71   fRegs[kIA0IRQ4] =   SimpleReg_t("IA0IRQ4",     0x0B04, 12,     0x000      );
  72   fRegs[kIA0IRQ5] =   SimpleReg_t("IA0IRQ5",     0x0B05, 12,     0x000      );
  73   fRegs[kIA0IRQ6] =   SimpleReg_t("IA0IRQ6",     0x0B06, 12,     0x000      );
  74   fRegs[kIA0IRQ7] =   SimpleReg_t("IA0IRQ7",     0x0B07, 12,     0x000      );
  75   fRegs[kIA0IRQ8] =   SimpleReg_t("IA0IRQ8",     0x0B08, 12,     0x000      );
  76   fRegs[kIA0IRQ9] =   SimpleReg_t("IA0IRQ9",     0x0B09, 12,     0x000      );
  77   fRegs[kIA0IRQA] =   SimpleReg_t("IA0IRQA",     0x0B0A, 12,     0x000      );
  78   fRegs[kIA0IRQB] =   SimpleReg_t("IA0IRQB",     0x0B0B, 12,     0x000      );
  79   fRegs[kIA0IRQC] =   SimpleReg_t("IA0IRQC",     0x0B0C, 12,     0x000      );
  80   fRegs[kIRQSW0]  =   SimpleReg_t("IRQSW0",      0x0B0D, 13,     0x1FFF     );
  81   fRegs[kIRQHW0]  =   SimpleReg_t("IRQHW0",      0x0B0E, 13,     0x0000     );
  82   fRegs[kIRQHL0]  =   SimpleReg_t("IRQHL0",      0x0B0F, 13,     0x0000     );
  83   fRegs[kIA1IRQ0] =   SimpleReg_t("IA1IRQ0",     0x0B20, 12,     0x000      );  // IVT of CPU1
  84   fRegs[kIA1IRQ1] =   SimpleReg_t("IA1IRQ1",     0x0B21, 12,     0x000      );
  85   fRegs[kIA1IRQ2] =   SimpleReg_t("IA1IRQ2",     0x0B22, 12,     0x000      );
  86   fRegs[kIA1IRQ3] =   SimpleReg_t("IA1IRQ3",     0x0B23, 12,     0x000      );
  87   fRegs[kIA1IRQ4] =   SimpleReg_t("IA1IRQ4",     0x0B24, 12,     0x000      );
  88   fRegs[kIA1IRQ5] =   SimpleReg_t("IA1IRQ5",     0x0B25, 12,     0x000      );
  89   fRegs[kIA1IRQ6] =   SimpleReg_t("IA1IRQ6",     0x0B26, 12,     0x000      );
  90   fRegs[kIA1IRQ7] =   SimpleReg_t("IA1IRQ7",     0x0B27, 12,     0x000      );
  91   fRegs[kIA1IRQ8] =   SimpleReg_t("IA1IRQ8",     0x0B28, 12,     0x000      );
  92   fRegs[kIA1IRQ9] =   SimpleReg_t("IA1IRQ9",     0x0B29, 12,     0x000      );
  93   fRegs[kIA1IRQA] =   SimpleReg_t("IA1IRQA",     0x0B2A, 12,     0x000      );
  94   fRegs[kIA1IRQB] =   SimpleReg_t("IA1IRQB",     0x0B2B, 12,     0x000      );
  95   fRegs[kIA1IRQC] =   SimpleReg_t("IA1IRQC",     0x0B2C, 12,     0x000      );
  96   fRegs[kIRQSW1]  =   SimpleReg_t("IRQSW1",      0x0B2D, 13,     0x1FFF     );
  97   fRegs[kIRQHW1]  =   SimpleReg_t("IRQHW1",      0x0B2E, 13,     0x0000     );
  98   fRegs[kIRQHL1]  =   SimpleReg_t("IRQHL1",      0x0B2F, 13,     0x0000     );
  99   fRegs[kIA2IRQ0] =   SimpleReg_t("IA2IRQ0",     0x0B40, 12,     0x000      );  // IVT of CPU2
 100   fRegs[kIA2IRQ1] =   SimpleReg_t("IA2IRQ1",     0x0B41, 12,     0x000      );
 101   fRegs[kIA2IRQ2] =   SimpleReg_t("IA2IRQ2",     0x0B42, 12,     0x000      );
 102   fRegs[kIA2IRQ3] =   SimpleReg_t("IA2IRQ3",     0x0B43, 12,     0x000      );
 103   fRegs[kIA2IRQ4] =   SimpleReg_t("IA2IRQ4",     0x0B44, 12,     0x000      );
 104   fRegs[kIA2IRQ5] =   SimpleReg_t("IA2IRQ5",     0x0B45, 12,     0x000      );
 105   fRegs[kIA2IRQ6] =   SimpleReg_t("IA2IRQ6",     0x0B46, 12,     0x000      );
 106   fRegs[kIA2IRQ7] =   SimpleReg_t("IA2IRQ7",     0x0B47, 12,     0x000      );
 107   fRegs[kIA2IRQ8] =   SimpleReg_t("IA2IRQ8",     0x0B48, 12,     0x000      );
 108   fRegs[kIA2IRQ9] =   SimpleReg_t("IA2IRQ9",     0x0B49, 12,     0x000      );
 109   fRegs[kIA2IRQA] =   SimpleReg_t("IA2IRQA",     0x0B4A, 12,     0x000      );
 110   fRegs[kIA2IRQB] =   SimpleReg_t("IA2IRQB",     0x0B4B, 12,     0x000      );
 111   fRegs[kIA2IRQC] =   SimpleReg_t("IA2IRQC",     0x0B4C, 12,     0x000      );
 112   fRegs[kIRQSW2]  =   SimpleReg_t("IRQSW2",      0x0B4D, 13,     0x1FFF     );
 113   fRegs[kIRQHW2]  =   SimpleReg_t("IRQHW2",      0x0B4E, 13,     0x0000     );
 114   fRegs[kIRQHL2]  =   SimpleReg_t("IRQHL2",      0x0B4F, 13,     0x0000     );
 115   fRegs[kIA3IRQ0] =   SimpleReg_t("IA3IRQ0",     0x0B60, 12,     0x000      );  // IVT of CPU3
 116   fRegs[kIA3IRQ1] =   SimpleReg_t("IA3IRQ1",     0x0B61, 12,     0x000      );
 117   fRegs[kIA3IRQ2] =   SimpleReg_t("IA3IRQ2",     0x0B62, 12,     0x000      );
 118   fRegs[kIA3IRQ3] =   SimpleReg_t("IA3IRQ3",     0x0B63, 12,     0x000      );
 119   fRegs[kIA3IRQ4] =   SimpleReg_t("IA3IRQ4",     0x0B64, 12,     0x000      );
 120   fRegs[kIA3IRQ5] =   SimpleReg_t("IA3IRQ5",     0x0B65, 12,     0x000      );
 121   fRegs[kIA3IRQ6] =   SimpleReg_t("IA3IRQ6",     0x0B66, 12,     0x000      );
 122   fRegs[kIA3IRQ7] =   SimpleReg_t("IA3IRQ7",     0x0B67, 12,     0x000      );
 123   fRegs[kIA3IRQ8] =   SimpleReg_t("IA3IRQ8",     0x0B68, 12,     0x000      );
 124   fRegs[kIA3IRQ9] =   SimpleReg_t("IA3IRQ9",     0x0B69, 12,     0x000      );
 125   fRegs[kIA3IRQA] =   SimpleReg_t("IA3IRQA",     0x0B6A, 12,     0x000      );
 126   fRegs[kIA3IRQB] =   SimpleReg_t("IA3IRQB",     0x0B6B, 12,     0x000      );
 127   fRegs[kIA3IRQC] =   SimpleReg_t("IA3IRQC",     0x0B6C, 12,     0x000      );
 128   fRegs[kIRQSW3]  =   SimpleReg_t("IRQSW3",      0x0B6D, 13,     0x1FFF     );
 129   fRegs[kIRQHW3]  =   SimpleReg_t("IRQHW3",      0x0B6E, 13,     0x0000     );
 130   fRegs[kIRQHL3]  =   SimpleReg_t("IRQHL3",      0x0B6F, 13,     0x0000     );
 131   fRegs[kCTGDINI] =   SimpleReg_t("CTGDINI",     0x0B80, 32,     0x00000000 );  // Global Counter/Timer
 132   fRegs[kCTGCTRL] =   SimpleReg_t("CTGCTRL",     0x0B81, 12,     0xE3F      );
 133   fRegs[kC08CPU0] =   SimpleReg_t("C08CPU0",     0x0C00, 32,     0x00000000 );  // CPU constants
 134   fRegs[kC09CPU0] =   SimpleReg_t("C09CPU0",     0x0C01, 32,     0x00000000 );
 135   fRegs[kC10CPU0] =   SimpleReg_t("C10CPU0",     0x0C02, 32,     0x00000000 );
 136   fRegs[kC11CPU0] =   SimpleReg_t("C11CPU0",     0x0C03, 32,     0x00000000 );
 137   fRegs[kC12CPUA] =   SimpleReg_t("C12CPUA",     0x0C04, 32,     0x00000000 );
 138   fRegs[kC13CPUA] =   SimpleReg_t("C13CPUA",     0x0C05, 32,     0x00000000 );
 139   fRegs[kC14CPUA] =   SimpleReg_t("C14CPUA",     0x0C06, 32,     0x00000000 );
 140   fRegs[kC15CPUA] =   SimpleReg_t("C15CPUA",     0x0C07, 32,     0x00000000 );
 141   fRegs[kC08CPU1] =   SimpleReg_t("C08CPU1",     0x0C08, 32,     0x00000000 );
 142   fRegs[kC09CPU1] =   SimpleReg_t("C09CPU1",     0x0C09, 32,     0x00000000 );
 143   fRegs[kC10CPU1] =   SimpleReg_t("C10CPU1",     0x0C0A, 32,     0x00000000 );
 144   fRegs[kC11CPU1] =   SimpleReg_t("C11CPU1",     0x0C0B, 32,     0x00000000 );
 145   fRegs[kC08CPU2] =   SimpleReg_t("C08CPU2",     0x0C10, 32,     0x00000000 );
 146   fRegs[kC09CPU2] =   SimpleReg_t("C09CPU2",     0x0C11, 32,     0x00000000 );
 147   fRegs[kC10CPU2] =   SimpleReg_t("C10CPU2",     0x0C12, 32,     0x00000000 );
 148   fRegs[kC11CPU2] =   SimpleReg_t("C11CPU2",     0x0C13, 32,     0x00000000 );
 149   fRegs[kC08CPU3] =   SimpleReg_t("C08CPU3",     0x0C18, 32,     0x00000000 );
 150   fRegs[kC09CPU3] =   SimpleReg_t("C09CPU3",     0x0C19, 32,     0x00000000 );
 151   fRegs[kC10CPU3] =   SimpleReg_t("C10CPU3",     0x0C1A, 32,     0x00000000 );
 152   fRegs[kC11CPU3] =   SimpleReg_t("C11CPU3",     0x0C1B, 32,     0x00000000 );
 153   fRegs[kNMOD]    =   SimpleReg_t("NMOD",        0x0D40, 6,      0x08       );  // NI interface
 154   fRegs[kNDLY]    =   SimpleReg_t("NDLY",        0x0D41, 30,     0x24924924 );
 155   fRegs[kNED]     =   SimpleReg_t("NED",         0x0D42, 16,     0xA240     );
 156   fRegs[kNTRO]    =   SimpleReg_t("NTRO",        0x0D43, 18,     0x3FFFC    );
 157   fRegs[kNRRO]    =   SimpleReg_t("NRRO",        0x0D44, 18,     0x3FFFC    );
 158   fRegs[kNES]     =   SimpleReg_t("NES",         0x0D45, 32,     0x00000000 );
 159   fRegs[kNTP]     =   SimpleReg_t("NTP",         0x0D46, 32,     0x0000FFFF );
 160   fRegs[kNBND]    =   SimpleReg_t("NBND",        0x0D47, 16,     0x6020     );
 161   fRegs[kNP0]     =   SimpleReg_t("NP0",         0x0D48, 11,     0x44C      );
 162   fRegs[kNP1]     =   SimpleReg_t("NP1",         0x0D49, 11,     0x44C      );
 163   fRegs[kNP2]     =   SimpleReg_t("NP2",         0x0D4A, 11,     0x44C      );
 164   fRegs[kNP3]     =   SimpleReg_t("NP3",         0x0D4B, 11,     0x44C      );
 165   fRegs[kNCUT]    =   SimpleReg_t("NCUT",        0x0D4C, 32,     0xFFFFFFFF );
 166   fRegs[kTPPT0]   =   SimpleReg_t("TPPT0",       0x3000, 7,      0x01       );  // Filter and Preprocessor
 167   fRegs[kTPFS]    =   SimpleReg_t("TPFS",        0x3001, 7,      0x05       );
 168   fRegs[kTPFE]    =   SimpleReg_t("TPFE",        0x3002, 7,      0x14       );
 169   fRegs[kTPPGR]   =   SimpleReg_t("TPPGR",       0x3003, 7,      0x15       );
 170   fRegs[kTPPAE]   =   SimpleReg_t("TPPAE",       0x3004, 7,      0x1E       );
 171   fRegs[kTPQS0]   =   SimpleReg_t("TPQS0",       0x3005, 7,      0x00       );
 172   fRegs[kTPQE0]   =   SimpleReg_t("TPQE0",       0x3006, 7,      0x0A       );
 173   fRegs[kTPQS1]   =   SimpleReg_t("TPQS1",       0x3007, 7,      0x0B       );
 174   fRegs[kTPQE1]   =   SimpleReg_t("TPQE1",       0x3008, 7,      0x14       );
 175   fRegs[kEBD]     =   SimpleReg_t("EBD",         0x3009, 3,      0x0        );
 176   fRegs[kEBAQA]   =   SimpleReg_t("EBAQA",       0x300A, 7,      0x00       );
 177   fRegs[kEBSIA]   =   SimpleReg_t("EBSIA",       0x300B, 7,      0x20       );
 178   fRegs[kEBSF]    =   SimpleReg_t("EBSF",        0x300C, 1,      0x1        );
 179   fRegs[kEBSIM]   =   SimpleReg_t("EBSIM",       0x300D, 1,      0x1        );
 180   fRegs[kEBPP]    =   SimpleReg_t("EBPP",        0x300E, 1,      0x1        );
 181   fRegs[kEBPC]    =   SimpleReg_t("EBPC",        0x300F, 1,      0x1        );
 182   fRegs[kEBIS]    =   SimpleReg_t("EBIS",        0x3014, 10,     0x005      );
 183   fRegs[kEBIT]    =   SimpleReg_t("EBIT",        0x3015, 12,     0x028      );
 184   fRegs[kEBIL]    =   SimpleReg_t("EBIL",        0x3016, 8,      0xF0       );
 185   fRegs[kEBIN]    =   SimpleReg_t("EBIN",        0x3017, 1,      0x1        );
 186   fRegs[kFLBY]    =   SimpleReg_t("FLBY",        0x3018, 1,      0x0        );
 187   fRegs[kFPBY]    =   SimpleReg_t("FPBY",        0x3019, 1,      0x0        );
 188   fRegs[kFGBY]    =   SimpleReg_t("FGBY",        0x301A, 1,      0x0        );
 189   fRegs[kFTBY]    =   SimpleReg_t("FTBY",        0x301B, 1,      0x0        );
 190   fRegs[kFCBY]    =   SimpleReg_t("FCBY",        0x301C, 1,      0x0        );
 191   fRegs[kFPTC]    =   SimpleReg_t("FPTC",        0x3020, 2,      0x3        );
 192   fRegs[kFPNP]    =   SimpleReg_t("FPNP",        0x3021, 9,      0x078      );
 193   fRegs[kFPCL]    =   SimpleReg_t("FPCL",        0x3022, 1,      0x1        );
 194   fRegs[kFGTA]    =   SimpleReg_t("FGTA",        0x3028, 12,     0x014      );
 195   fRegs[kFGTB]    =   SimpleReg_t("FGTB",        0x3029, 12,     0x80C      );
 196   fRegs[kFGCL]    =   SimpleReg_t("FGCL",        0x302A, 1,      0x1        );
 197   fRegs[kFTAL]    =   SimpleReg_t("FTAL",        0x3030, 10,     0x0F6      );
 198   fRegs[kFTLL]    =   SimpleReg_t("FTLL",        0x3031, 9,      0x11D      );
 199   fRegs[kFTLS]    =   SimpleReg_t("FTLS",        0x3032, 9,      0x0D3      );
 200   fRegs[kFCW1]    =   SimpleReg_t("FCW1",        0x3038, 8,      0x1E       );
 201   fRegs[kFCW2]    =   SimpleReg_t("FCW2",        0x3039, 8,      0xD4       );
 202   fRegs[kFCW3]    =   SimpleReg_t("FCW3",        0x303A, 8,      0xE6       );
 203   fRegs[kFCW4]    =   SimpleReg_t("FCW4",        0x303B, 8,      0x4A       );
 204   fRegs[kFCW5]    =   SimpleReg_t("FCW5",        0x303C, 8,      0xEF       );
 205   fRegs[kTPFP]    =   SimpleReg_t("TPFP",        0x3040, 9,      0x037      );
 206   fRegs[kTPHT]    =   SimpleReg_t("TPHT",        0x3041, 14,     0x00A0     );
 207   fRegs[kTPVT]    =   SimpleReg_t("TPVT",        0x3042, 6,      0x00       );
 208   fRegs[kTPVBY]   =   SimpleReg_t("TPVBY",       0x3043, 1,      0x0        );
 209   fRegs[kTPCT]    =   SimpleReg_t("TPCT",        0x3044, 5,      0x08       );
 210   fRegs[kTPCL]    =   SimpleReg_t("TPCL",        0x3045, 5,      0x01       );
 211   fRegs[kTPCBY]   =   SimpleReg_t("TPCBY",       0x3046, 1,      0x1        );
 212   fRegs[kTPD]     =   SimpleReg_t("TPD",         0x3047, 4,      0xF        );
 213   fRegs[kTPCI0]   =   SimpleReg_t("TPCI0",       0x3048, 5,      0x00       );
 214   fRegs[kTPCI1]   =   SimpleReg_t("TPCI1",       0x3049, 5,      0x00       );
 215   fRegs[kTPCI2]   =   SimpleReg_t("TPCI2",       0x304A, 5,      0x00       );
 216   fRegs[kTPCI3]   =   SimpleReg_t("TPCI3",       0x304B, 5,      0x00       );
 217   fRegs[kADCMSK]  =   SimpleReg_t("ADCMSK",      0x3050, 21,     0x1FFFFF   );
 218   fRegs[kADCINB]  =   SimpleReg_t("ADCINB",      0x3051, 2,      0x2        );
 219   fRegs[kADCDAC]  =   SimpleReg_t("ADCDAC",      0x3052, 5,      0x10       );
 220   fRegs[kADCPAR]  =   SimpleReg_t("ADCPAR",      0x3053, 18,     0x195EF    );
 221   fRegs[kADCTST]  =   SimpleReg_t("ADCTST",      0x3054, 2,      0x0        );
 222   fRegs[kSADCAZ]  =   SimpleReg_t("SADCAZ",      0x3055, 1,      0x1        );
 223   fRegs[kFGF0]    =   SimpleReg_t("FGF0",        0x3080, 9,      0x000      );
 224   fRegs[kFGF1]    =   SimpleReg_t("FGF1",        0x3081, 9,      0x000      );
 225   fRegs[kFGF2]    =   SimpleReg_t("FGF2",        0x3082, 9,      0x000      );
 226   fRegs[kFGF3]    =   SimpleReg_t("FGF3",        0x3083, 9,      0x000      );
 227   fRegs[kFGF4]    =   SimpleReg_t("FGF4",        0x3084, 9,      0x000      );
 228   fRegs[kFGF5]    =   SimpleReg_t("FGF5",        0x3085, 9,      0x000      );
 229   fRegs[kFGF6]    =   SimpleReg_t("FGF6",        0x3086, 9,      0x000      );
 230   fRegs[kFGF7]    =   SimpleReg_t("FGF7",        0x3087, 9,      0x000      );
 231   fRegs[kFGF8]    =   SimpleReg_t("FGF8",        0x3088, 9,      0x000      );
 232   fRegs[kFGF9]    =   SimpleReg_t("FGF9",        0x3089, 9,      0x000      );
 233   fRegs[kFGF10]   =   SimpleReg_t("FGF10",       0x308A, 9,      0x000      );
 234   fRegs[kFGF11]   =   SimpleReg_t("FGF11",       0x308B, 9,      0x000      );
 235   fRegs[kFGF12]   =   SimpleReg_t("FGF12",       0x308C, 9,      0x000      );
 236   fRegs[kFGF13]   =   SimpleReg_t("FGF13",       0x308D, 9,      0x000      );
 237   fRegs[kFGF14]   =   SimpleReg_t("FGF14",       0x308E, 9,      0x000      );
 238   fRegs[kFGF15]   =   SimpleReg_t("FGF15",       0x308F, 9,      0x000      );
 239   fRegs[kFGF16]   =   SimpleReg_t("FGF16",       0x3090, 9,      0x000      );
 240   fRegs[kFGF17]   =   SimpleReg_t("FGF17",       0x3091, 9,      0x000      );
 241   fRegs[kFGF18]   =   SimpleReg_t("FGF18",       0x3092, 9,      0x000      );
 242   fRegs[kFGF19]   =   SimpleReg_t("FGF19",       0x3093, 9,      0x000      );
 243   fRegs[kFGF20]   =   SimpleReg_t("FGF20",       0x3094, 9,      0x000      );
 244   fRegs[kFGA0]    =   SimpleReg_t("FGA0",        0x30A0, 6,      0x00       );
 245   fRegs[kFGA1]    =   SimpleReg_t("FGA1",        0x30A1, 6,      0x00       );
 246   fRegs[kFGA2]    =   SimpleReg_t("FGA2",        0x30A2, 6,      0x00       );
 247   fRegs[kFGA3]    =   SimpleReg_t("FGA3",        0x30A3, 6,      0x00       );
 248   fRegs[kFGA4]    =   SimpleReg_t("FGA4",        0x30A4, 6,      0x00       );
 249   fRegs[kFGA5]    =   SimpleReg_t("FGA5",        0x30A5, 6,      0x00       );
 250   fRegs[kFGA6]    =   SimpleReg_t("FGA6",        0x30A6, 6,      0x00       );
 251   fRegs[kFGA7]    =   SimpleReg_t("FGA7",        0x30A7, 6,      0x00       );
 252   fRegs[kFGA8]    =   SimpleReg_t("FGA8",        0x30A8, 6,      0x00       );
 253   fRegs[kFGA9]    =   SimpleReg_t("FGA9",        0x30A9, 6,      0x00       );
 254   fRegs[kFGA10]   =   SimpleReg_t("FGA10",       0x30AA, 6,      0x00       );
 255   fRegs[kFGA11]   =   SimpleReg_t("FGA11",       0x30AB, 6,      0x00       );
 256   fRegs[kFGA12]   =   SimpleReg_t("FGA12",       0x30AC, 6,      0x00       );
 257   fRegs[kFGA13]   =   SimpleReg_t("FGA13",       0x30AD, 6,      0x00       );
 258   fRegs[kFGA14]   =   SimpleReg_t("FGA14",       0x30AE, 6,      0x00       );
 259   fRegs[kFGA15]   =   SimpleReg_t("FGA15",       0x30AF, 6,      0x00       );
 260   fRegs[kFGA16]   =   SimpleReg_t("FGA16",       0x30B0, 6,      0x00       );
 261   fRegs[kFGA17]   =   SimpleReg_t("FGA17",       0x30B1, 6,      0x00       );
 262   fRegs[kFGA18]   =   SimpleReg_t("FGA18",       0x30B2, 6,      0x00       );
 263   fRegs[kFGA19]   =   SimpleReg_t("FGA19",       0x30B3, 6,      0x00       );
 264   fRegs[kFGA20]   =   SimpleReg_t("FGA20",       0x30B4, 6,      0x00       );
 265   fRegs[kFLL00]   =   SimpleReg_t("FLL00",       0x3100, 6,      0x00       );  // non-linearity table, 64 x 6 bits
 266   fRegs[kFLL01]   =   SimpleReg_t("FLL01",       0x3101, 6,      0x00       );
 267   fRegs[kFLL02]   =   SimpleReg_t("FLL02",       0x3102, 6,      0x00       );
 268   fRegs[kFLL03]   =   SimpleReg_t("FLL03",       0x3103, 6,      0x00       );
 269   fRegs[kFLL04]   =   SimpleReg_t("FLL04",       0x3104, 6,      0x00       );
 270   fRegs[kFLL05]   =   SimpleReg_t("FLL05",       0x3105, 6,      0x00       );
 271   fRegs[kFLL06]   =   SimpleReg_t("FLL06",       0x3106, 6,      0x00       );
 272   fRegs[kFLL07]   =   SimpleReg_t("FLL07",       0x3107, 6,      0x00       );
 273   fRegs[kFLL08]   =   SimpleReg_t("FLL08",       0x3108, 6,      0x00       );
 274   fRegs[kFLL09]   =   SimpleReg_t("FLL09",       0x3109, 6,      0x00       );
 275   fRegs[kFLL0A]   =   SimpleReg_t("FLL0A",       0x310A, 6,      0x00       );
 276   fRegs[kFLL0B]   =   SimpleReg_t("FLL0B",       0x310B, 6,      0x00       );
 277   fRegs[kFLL0C]   =   SimpleReg_t("FLL0C",       0x310C, 6,      0x00       );
 278   fRegs[kFLL0D]   =   SimpleReg_t("FLL0D",       0x310D, 6,      0x00       );
 279   fRegs[kFLL0E]   =   SimpleReg_t("FLL0E",       0x310E, 6,      0x00       );
 280   fRegs[kFLL0F]   =   SimpleReg_t("FLL0F",       0x310F, 6,      0x00       );
 281   fRegs[kFLL10]   =   SimpleReg_t("FLL10",       0x3110, 6,      0x00       );
 282   fRegs[kFLL11]   =   SimpleReg_t("FLL11",       0x3111, 6,      0x00       );
 283   fRegs[kFLL12]   =   SimpleReg_t("FLL12",       0x3112, 6,      0x00       );
 284   fRegs[kFLL13]   =   SimpleReg_t("FLL13",       0x3113, 6,      0x00       );
 285   fRegs[kFLL14]   =   SimpleReg_t("FLL14",       0x3114, 6,      0x00       );
 286   fRegs[kFLL15]   =   SimpleReg_t("FLL15",       0x3115, 6,      0x00       );
 287   fRegs[kFLL16]   =   SimpleReg_t("FLL16",       0x3116, 6,      0x00       );
 288   fRegs[kFLL17]   =   SimpleReg_t("FLL17",       0x3117, 6,      0x00       );
 289   fRegs[kFLL18]   =   SimpleReg_t("FLL18",       0x3118, 6,      0x00       );
 290   fRegs[kFLL19]   =   SimpleReg_t("FLL19",       0x3119, 6,      0x00       );
 291   fRegs[kFLL1A]   =   SimpleReg_t("FLL1A",       0x311A, 6,      0x00       );
 292   fRegs[kFLL1B]   =   SimpleReg_t("FLL1B",       0x311B, 6,      0x00       );
 293   fRegs[kFLL1C]   =   SimpleReg_t("FLL1C",       0x311C, 6,      0x00       );
 294   fRegs[kFLL1D]   =   SimpleReg_t("FLL1D",       0x311D, 6,      0x00       );
 295   fRegs[kFLL1E]   =   SimpleReg_t("FLL1E",       0x311E, 6,      0x00       );
 296   fRegs[kFLL1F]   =   SimpleReg_t("FLL1F",       0x311F, 6,      0x00       );
 297   fRegs[kFLL20]   =   SimpleReg_t("FLL20",       0x3120, 6,      0x00       );
 298   fRegs[kFLL21]   =   SimpleReg_t("FLL21",       0x3121, 6,      0x00       );
 299   fRegs[kFLL22]   =   SimpleReg_t("FLL22",       0x3122, 6,      0x00       );
 300   fRegs[kFLL23]   =   SimpleReg_t("FLL23",       0x3123, 6,      0x00       );
 301   fRegs[kFLL24]   =   SimpleReg_t("FLL24",       0x3124, 6,      0x00       );
 302   fRegs[kFLL25]   =   SimpleReg_t("FLL25",       0x3125, 6,      0x00       );
 303   fRegs[kFLL26]   =   SimpleReg_t("FLL26",       0x3126, 6,      0x00       );
 304   fRegs[kFLL27]   =   SimpleReg_t("FLL27",       0x3127, 6,      0x00       );
 305   fRegs[kFLL28]   =   SimpleReg_t("FLL28",       0x3128, 6,      0x00       );
 306   fRegs[kFLL29]   =   SimpleReg_t("FLL29",       0x3129, 6,      0x00       );
 307   fRegs[kFLL2A]   =   SimpleReg_t("FLL2A",       0x312A, 6,      0x00       );
 308   fRegs[kFLL2B]   =   SimpleReg_t("FLL2B",       0x312B, 6,      0x00       );
 309   fRegs[kFLL2C]   =   SimpleReg_t("FLL2C",       0x312C, 6,      0x00       );
 310   fRegs[kFLL2D]   =   SimpleReg_t("FLL2D",       0x312D, 6,      0x00       );
 311   fRegs[kFLL2E]   =   SimpleReg_t("FLL2E",       0x312E, 6,      0x00       );
 312   fRegs[kFLL2F]   =   SimpleReg_t("FLL2F",       0x312F, 6,      0x00       );
 313   fRegs[kFLL30]   =   SimpleReg_t("FLL30",       0x3130, 6,      0x00       );
 314   fRegs[kFLL31]   =   SimpleReg_t("FLL31",       0x3131, 6,      0x00       );
 315   fRegs[kFLL32]   =   SimpleReg_t("FLL32",       0x3132, 6,      0x00       );
 316   fRegs[kFLL33]   =   SimpleReg_t("FLL33",       0x3133, 6,      0x00       );
 317   fRegs[kFLL34]   =   SimpleReg_t("FLL34",       0x3134, 6,      0x00       );
 318   fRegs[kFLL35]   =   SimpleReg_t("FLL35",       0x3135, 6,      0x00       );
 319   fRegs[kFLL36]   =   SimpleReg_t("FLL36",       0x3136, 6,      0x00       );
 320   fRegs[kFLL37]   =   SimpleReg_t("FLL37",       0x3137, 6,      0x00       );
 321   fRegs[kFLL38]   =   SimpleReg_t("FLL38",       0x3138, 6,      0x00       );
 322   fRegs[kFLL39]   =   SimpleReg_t("FLL39",       0x3139, 6,      0x00       );
 323   fRegs[kFLL3A]   =   SimpleReg_t("FLL3A",       0x313A, 6,      0x00       );
 324   fRegs[kFLL3B]   =   SimpleReg_t("FLL3B",       0x313B, 6,      0x00       );
 325   fRegs[kFLL3C]   =   SimpleReg_t("FLL3C",       0x313C, 6,      0x00       );
 326   fRegs[kFLL3D]   =   SimpleReg_t("FLL3D",       0x313D, 6,      0x00       );
 327   fRegs[kFLL3E]   =   SimpleReg_t("FLL3E",       0x313E, 6,      0x00       );
 328   fRegs[kFLL3F]   =   SimpleReg_t("FLL3F",       0x313F, 6,      0x00       );
 329   fRegs[kPASADEL] =   SimpleReg_t("PASADEL",     0x3158, 8,      0xFF       );  // end of non-lin table
 330   fRegs[kPASAPHA] =   SimpleReg_t("PASAPHA",     0x3159, 6,      0x3F       );
 331   fRegs[kPASAPRA] =   SimpleReg_t("PASAPRA",     0x315A, 6,      0x0F       );
 332   fRegs[kPASADAC] =   SimpleReg_t("PASADAC",     0x315B, 8,      0x80       );
 333   fRegs[kPASACHM] =   SimpleReg_t("PASACHM",     0x315C, 19,     0x7FFFF    );
 334   fRegs[kPASASTL] =   SimpleReg_t("PASASTL",     0x315D, 8,      0xFF       );
 335   fRegs[kPASAPR1] =   SimpleReg_t("PASAPR1",     0x315E, 1,      0x0        );
 336   fRegs[kPASAPR0] =   SimpleReg_t("PASAPR0",     0x315F, 1,      0x0        );
 337   fRegs[kSADCTRG] =   SimpleReg_t("SADCTRG",     0x3161, 1,      0x0        );
 338   fRegs[kSADCRUN] =   SimpleReg_t("SADCRUN",     0x3162, 1,      0x0        );
 339   fRegs[kSADCPWR] =   SimpleReg_t("SADCPWR",     0x3163, 3,      0x7        );
 340   fRegs[kL0TSIM]  =   SimpleReg_t("L0TSIM",      0x3165, 14,     0x0050     );
 341   fRegs[kSADCEC]  =   SimpleReg_t("SADCEC",      0x3166, 7,      0x00       );
 342   fRegs[kSADCMC]  =   SimpleReg_t("SADCMC",      0x3170, 8,      0xC0       );
 343   fRegs[kSADCOC]  =   SimpleReg_t("SADCOC",      0x3171, 8,      0x19       );
 344   fRegs[kSADCGTB] =   SimpleReg_t("SADCGTB",     0x3172, 32,     0x37737700 );
 345   fRegs[kSEBDEN]  =   SimpleReg_t("SEBDEN",      0x3178, 3,      0x0        );
 346   fRegs[kSEBDOU]  =   SimpleReg_t("SEBDOU",      0x3179, 3,      0x0        );
 347   fRegs[kTPL00]   =   SimpleReg_t("TPL00",       0x3180, 5,      0x00       );  // pos table, 128 x 5 bits
 348   fRegs[kTPL01]   =   SimpleReg_t("TPL01",       0x3181, 5,      0x00       );
 349   fRegs[kTPL02]   =   SimpleReg_t("TPL02",       0x3182, 5,      0x00       );
 350   fRegs[kTPL03]   =   SimpleReg_t("TPL03",       0x3183, 5,      0x00       );
 351   fRegs[kTPL04]   =   SimpleReg_t("TPL04",       0x3184, 5,      0x00       );
 352   fRegs[kTPL05]   =   SimpleReg_t("TPL05",       0x3185, 5,      0x00       );
 353   fRegs[kTPL06]   =   SimpleReg_t("TPL06",       0x3186, 5,      0x00       );
 354   fRegs[kTPL07]   =   SimpleReg_t("TPL07",       0x3187, 5,      0x00       );
 355   fRegs[kTPL08]   =   SimpleReg_t("TPL08",       0x3188, 5,      0x00       );
 356   fRegs[kTPL09]   =   SimpleReg_t("TPL09",       0x3189, 5,      0x00       );
 357   fRegs[kTPL0A]   =   SimpleReg_t("TPL0A",       0x318A, 5,      0x00       );
 358   fRegs[kTPL0B]   =   SimpleReg_t("TPL0B",       0x318B, 5,      0x00       );
 359   fRegs[kTPL0C]   =   SimpleReg_t("TPL0C",       0x318C, 5,      0x00       );
 360   fRegs[kTPL0D]   =   SimpleReg_t("TPL0D",       0x318D, 5,      0x00       );
 361   fRegs[kTPL0E]   =   SimpleReg_t("TPL0E",       0x318E, 5,      0x00       );
 362   fRegs[kTPL0F]   =   SimpleReg_t("TPL0F",       0x318F, 5,      0x00       );
 363   fRegs[kTPL10]   =   SimpleReg_t("TPL10",       0x3190, 5,      0x00       );
 364   fRegs[kTPL11]   =   SimpleReg_t("TPL11",       0x3191, 5,      0x00       );
 365   fRegs[kTPL12]   =   SimpleReg_t("TPL12",       0x3192, 5,      0x00       );
 366   fRegs[kTPL13]   =   SimpleReg_t("TPL13",       0x3193, 5,      0x00       );
 367   fRegs[kTPL14]   =   SimpleReg_t("TPL14",       0x3194, 5,      0x00       );
 368   fRegs[kTPL15]   =   SimpleReg_t("TPL15",       0x3195, 5,      0x00       );
 369   fRegs[kTPL16]   =   SimpleReg_t("TPL16",       0x3196, 5,      0x00       );
 370   fRegs[kTPL17]   =   SimpleReg_t("TPL17",       0x3197, 5,      0x00       );
 371   fRegs[kTPL18]   =   SimpleReg_t("TPL18",       0x3198, 5,      0x00       );
 372   fRegs[kTPL19]   =   SimpleReg_t("TPL19",       0x3199, 5,      0x00       );
 373   fRegs[kTPL1A]   =   SimpleReg_t("TPL1A",       0x319A, 5,      0x00       );
 374   fRegs[kTPL1B]   =   SimpleReg_t("TPL1B",       0x319B, 5,      0x00       );
 375   fRegs[kTPL1C]   =   SimpleReg_t("TPL1C",       0x319C, 5,      0x00       );
 376   fRegs[kTPL1D]   =   SimpleReg_t("TPL1D",       0x319D, 5,      0x00       );
 377   fRegs[kTPL1E]   =   SimpleReg_t("TPL1E",       0x319E, 5,      0x00       );
 378   fRegs[kTPL1F]   =   SimpleReg_t("TPL1F",       0x319F, 5,      0x00       );
 379   fRegs[kTPL20]   =   SimpleReg_t("TPL20",       0x31A0, 5,      0x00       );
 380   fRegs[kTPL21]   =   SimpleReg_t("TPL21",       0x31A1, 5,      0x00       );
 381   fRegs[kTPL22]   =   SimpleReg_t("TPL22",       0x31A2, 5,      0x00       );
 382   fRegs[kTPL23]   =   SimpleReg_t("TPL23",       0x31A3, 5,      0x00       );
 383   fRegs[kTPL24]   =   SimpleReg_t("TPL24",       0x31A4, 5,      0x00       );
 384   fRegs[kTPL25]   =   SimpleReg_t("TPL25",       0x31A5, 5,      0x00       );
 385   fRegs[kTPL26]   =   SimpleReg_t("TPL26",       0x31A6, 5,      0x00       );
 386   fRegs[kTPL27]   =   SimpleReg_t("TPL27",       0x31A7, 5,      0x00       );
 387   fRegs[kTPL28]   =   SimpleReg_t("TPL28",       0x31A8, 5,      0x00       );
 388   fRegs[kTPL29]   =   SimpleReg_t("TPL29",       0x31A9, 5,      0x00       );
 389   fRegs[kTPL2A]   =   SimpleReg_t("TPL2A",       0x31AA, 5,      0x00       );
 390   fRegs[kTPL2B]   =   SimpleReg_t("TPL2B",       0x31AB, 5,      0x00       );
 391   fRegs[kTPL2C]   =   SimpleReg_t("TPL2C",       0x31AC, 5,      0x00       );
 392   fRegs[kTPL2D]   =   SimpleReg_t("TPL2D",       0x31AD, 5,      0x00       );
 393   fRegs[kTPL2E]   =   SimpleReg_t("TPL2E",       0x31AE, 5,      0x00       );
 394   fRegs[kTPL2F]   =   SimpleReg_t("TPL2F",       0x31AF, 5,      0x00       );
 395   fRegs[kTPL30]   =   SimpleReg_t("TPL30",       0x31B0, 5,      0x00       );
 396   fRegs[kTPL31]   =   SimpleReg_t("TPL31",       0x31B1, 5,      0x00       );
 397   fRegs[kTPL32]   =   SimpleReg_t("TPL32",       0x31B2, 5,      0x00       );
 398   fRegs[kTPL33]   =   SimpleReg_t("TPL33",       0x31B3, 5,      0x00       );
 399   fRegs[kTPL34]   =   SimpleReg_t("TPL34",       0x31B4, 5,      0x00       );
 400   fRegs[kTPL35]   =   SimpleReg_t("TPL35",       0x31B5, 5,      0x00       );
 401   fRegs[kTPL36]   =   SimpleReg_t("TPL36",       0x31B6, 5,      0x00       );
 402   fRegs[kTPL37]   =   SimpleReg_t("TPL37",       0x31B7, 5,      0x00       );
 403   fRegs[kTPL38]   =   SimpleReg_t("TPL38",       0x31B8, 5,      0x00       );
 404   fRegs[kTPL39]   =   SimpleReg_t("TPL39",       0x31B9, 5,      0x00       );
 405   fRegs[kTPL3A]   =   SimpleReg_t("TPL3A",       0x31BA, 5,      0x00       );
 406   fRegs[kTPL3B]   =   SimpleReg_t("TPL3B",       0x31BB, 5,      0x00       );
 407   fRegs[kTPL3C]   =   SimpleReg_t("TPL3C",       0x31BC, 5,      0x00       );
 408   fRegs[kTPL3D]   =   SimpleReg_t("TPL3D",       0x31BD, 5,      0x00       );
 409   fRegs[kTPL3E]   =   SimpleReg_t("TPL3E",       0x31BE, 5,      0x00       );
 410   fRegs[kTPL3F]   =   SimpleReg_t("TPL3F",       0x31BF, 5,      0x00       );
 411   fRegs[kTPL40]   =   SimpleReg_t("TPL40",       0x31C0, 5,      0x00       );
 412   fRegs[kTPL41]   =   SimpleReg_t("TPL41",       0x31C1, 5,      0x00       );
 413   fRegs[kTPL42]   =   SimpleReg_t("TPL42",       0x31C2, 5,      0x00       );
 414   fRegs[kTPL43]   =   SimpleReg_t("TPL43",       0x31C3, 5,      0x00       );
 415   fRegs[kTPL44]   =   SimpleReg_t("TPL44",       0x31C4, 5,      0x00       );
 416   fRegs[kTPL45]   =   SimpleReg_t("TPL45",       0x31C5, 5,      0x00       );
 417   fRegs[kTPL46]   =   SimpleReg_t("TPL46",       0x31C6, 5,      0x00       );
 418   fRegs[kTPL47]   =   SimpleReg_t("TPL47",       0x31C7, 5,      0x00       );
 419   fRegs[kTPL48]   =   SimpleReg_t("TPL48",       0x31C8, 5,      0x00       );
 420   fRegs[kTPL49]   =   SimpleReg_t("TPL49",       0x31C9, 5,      0x00       );
 421   fRegs[kTPL4A]   =   SimpleReg_t("TPL4A",       0x31CA, 5,      0x00       );
 422   fRegs[kTPL4B]   =   SimpleReg_t("TPL4B",       0x31CB, 5,      0x00       );
 423   fRegs[kTPL4C]   =   SimpleReg_t("TPL4C",       0x31CC, 5,      0x00       );
 424   fRegs[kTPL4D]   =   SimpleReg_t("TPL4D",       0x31CD, 5,      0x00       );
 425   fRegs[kTPL4E]   =   SimpleReg_t("TPL4E",       0x31CE, 5,      0x00       );
 426   fRegs[kTPL4F]   =   SimpleReg_t("TPL4F",       0x31CF, 5,      0x00       );
 427   fRegs[kTPL50]   =   SimpleReg_t("TPL50",       0x31D0, 5,      0x00       );
 428   fRegs[kTPL51]   =   SimpleReg_t("TPL51",       0x31D1, 5,      0x00       );
 429   fRegs[kTPL52]   =   SimpleReg_t("TPL52",       0x31D2, 5,      0x00       );
 430   fRegs[kTPL53]   =   SimpleReg_t("TPL53",       0x31D3, 5,      0x00       );
 431   fRegs[kTPL54]   =   SimpleReg_t("TPL54",       0x31D4, 5,      0x00       );
 432   fRegs[kTPL55]   =   SimpleReg_t("TPL55",       0x31D5, 5,      0x00       );
 433   fRegs[kTPL56]   =   SimpleReg_t("TPL56",       0x31D6, 5,      0x00       );
 434   fRegs[kTPL57]   =   SimpleReg_t("TPL57",       0x31D7, 5,      0x00       );
 435   fRegs[kTPL58]   =   SimpleReg_t("TPL58",       0x31D8, 5,      0x00       );
 436   fRegs[kTPL59]   =   SimpleReg_t("TPL59",       0x31D9, 5,      0x00       );
 437   fRegs[kTPL5A]   =   SimpleReg_t("TPL5A",       0x31DA, 5,      0x00       );
 438   fRegs[kTPL5B]   =   SimpleReg_t("TPL5B",       0x31DB, 5,      0x00       );
 439   fRegs[kTPL5C]   =   SimpleReg_t("TPL5C",       0x31DC, 5,      0x00       );
 440   fRegs[kTPL5D]   =   SimpleReg_t("TPL5D",       0x31DD, 5,      0x00       );
 441   fRegs[kTPL5E]   =   SimpleReg_t("TPL5E",       0x31DE, 5,      0x00       );
 442   fRegs[kTPL5F]   =   SimpleReg_t("TPL5F",       0x31DF, 5,      0x00       );
 443   fRegs[kTPL60]   =   SimpleReg_t("TPL60",       0x31E0, 5,      0x00       );
 444   fRegs[kTPL61]   =   SimpleReg_t("TPL61",       0x31E1, 5,      0x00       );
 445   fRegs[kTPL62]   =   SimpleReg_t("TPL62",       0x31E2, 5,      0x00       );
 446   fRegs[kTPL63]   =   SimpleReg_t("TPL63",       0x31E3, 5,      0x00       );
 447   fRegs[kTPL64]   =   SimpleReg_t("TPL64",       0x31E4, 5,      0x00       );
 448   fRegs[kTPL65]   =   SimpleReg_t("TPL65",       0x31E5, 5,      0x00       );
 449   fRegs[kTPL66]   =   SimpleReg_t("TPL66",       0x31E6, 5,      0x00       );
 450   fRegs[kTPL67]   =   SimpleReg_t("TPL67",       0x31E7, 5,      0x00       );
 451   fRegs[kTPL68]   =   SimpleReg_t("TPL68",       0x31E8, 5,      0x00       );
 452   fRegs[kTPL69]   =   SimpleReg_t("TPL69",       0x31E9, 5,      0x00       );
 453   fRegs[kTPL6A]   =   SimpleReg_t("TPL6A",       0x31EA, 5,      0x00       );
 454   fRegs[kTPL6B]   =   SimpleReg_t("TPL6B",       0x31EB, 5,      0x00       );
 455   fRegs[kTPL6C]   =   SimpleReg_t("TPL6C",       0x31EC, 5,      0x00       );
 456   fRegs[kTPL6D]   =   SimpleReg_t("TPL6D",       0x31ED, 5,      0x00       );
 457   fRegs[kTPL6E]   =   SimpleReg_t("TPL6E",       0x31EE, 5,      0x00       );
 458   fRegs[kTPL6F]   =   SimpleReg_t("TPL6F",       0x31EF, 5,      0x00       );
 459   fRegs[kTPL70]   =   SimpleReg_t("TPL70",       0x31F0, 5,      0x00       );
 460   fRegs[kTPL71]   =   SimpleReg_t("TPL71",       0x31F1, 5,      0x00       );
 461   fRegs[kTPL72]   =   SimpleReg_t("TPL72",       0x31F2, 5,      0x00       );
 462   fRegs[kTPL73]   =   SimpleReg_t("TPL73",       0x31F3, 5,      0x00       );
 463   fRegs[kTPL74]   =   SimpleReg_t("TPL74",       0x31F4, 5,      0x00       );
 464   fRegs[kTPL75]   =   SimpleReg_t("TPL75",       0x31F5, 5,      0x00       );
 465   fRegs[kTPL76]   =   SimpleReg_t("TPL76",       0x31F6, 5,      0x00       );
 466   fRegs[kTPL77]   =   SimpleReg_t("TPL77",       0x31F7, 5,      0x00       );
 467   fRegs[kTPL78]   =   SimpleReg_t("TPL78",       0x31F8, 5,      0x00       );
 468   fRegs[kTPL79]   =   SimpleReg_t("TPL79",       0x31F9, 5,      0x00       );
 469   fRegs[kTPL7A]   =   SimpleReg_t("TPL7A",       0x31FA, 5,      0x00       );
 470   fRegs[kTPL7B]   =   SimpleReg_t("TPL7B",       0x31FB, 5,      0x00       );
 471   fRegs[kTPL7C]   =   SimpleReg_t("TPL7C",       0x31FC, 5,      0x00       );
 472   fRegs[kTPL7D]   =   SimpleReg_t("TPL7D",       0x31FD, 5,      0x00       );
 473   fRegs[kTPL7E]   =   SimpleReg_t("TPL7E",       0x31FE, 5,      0x00       );
 474   fRegs[kTPL7F]   =   SimpleReg_t("TPL7F",       0x31FF, 5,      0x00       );
 475   fRegs[kMEMRW]   =   SimpleReg_t("MEMRW",       0xD000, 7,      0x79       );  // end of pos table
 476   fRegs[kMEMCOR]  =   SimpleReg_t("MEMCOR",      0xD001, 9,      0x000      );
 477   fRegs[kDMDELA]  =   SimpleReg_t("DMDELA",      0xD002, 4,      0x8        );
 478   fRegs[kDMDELS]  =   SimpleReg_t("DMDELS",      0xD003, 4,      0x8        );
 479
 480   InitRegs();
 481 }
 482
 483
 484 AliTRDtrapConfig* AliTRDtrapConfig::Instance()
 485 {
 486   // return a pointer to an instance of this class
 487
 488   if (!fgInstance) {
 489     fgInstance = new AliTRDtrapConfig();
 490     fgInstance->LoadConfig();
 491   }
 492
 493   return fgInstance;
 494 }
 495
 496
 497 void AliTRDtrapConfig::InitRegs(void)
 498 {
 499    // Reset the content of all TRAP registers to the reset values (see TRAP User Manual)
 500
 501    for (Int_t iReg = 0; iReg < kLastReg; iReg++) {
 502
 503      fRegisterValue[iReg].individualValue = 0x0;
 504
 505      fRegisterValue[iReg].globalValue = GetRegResetValue((TrapReg_t) iReg);
 506      fRegisterValue[iReg].state = RegValue_t::kGlobal;
 507    }
 508 }
 509
 510
 511 void AliTRDtrapConfig::ResetRegs(void)
 512 {
 513    // Reset the content of all TRAP registers to the reset values (see TRAP User Manual)
 514
 515    for (Int_t iReg = 0; iReg < kLastReg; iReg++) {
 516       if(fRegisterValue[iReg].state == RegValue_t::kIndividual) {
 517         if (fRegisterValue[iReg].individualValue) {
 518           delete [] fRegisterValue[iReg].individualValue;
 519           fRegisterValue[iReg].individualValue = 0x0;
 520         }
 521       }
 522
 523       fRegisterValue[iReg].globalValue = GetRegResetValue((TrapReg_t) iReg);
 524       fRegisterValue[iReg].state = RegValue_t::kGlobal;
 525       //    printf("%-8s: 0x%08x\n", GetRegName((TrapReg_t) iReg), fRegisterValue[iReg].globalValue);
 526    }
 527 }
 528
 529
 530 Int_t AliTRDtrapConfig::GetTrapReg(TrapReg_t reg, Int_t det, Int_t rob, Int_t mcm)
 531 {
 532   // get the value of an individual TRAP register
 533   // if it is individual for TRAPs a valid TRAP has to be specified
 534
 535   if ((reg < 0) || (reg >= kLastReg)) {
 536     AliError("Non-existing register requested");
 537     return -1;
 538   }
 539   else {
 540     if (fRegisterValue[reg].state == RegValue_t::kGlobal) {
 541       return fRegisterValue[reg].globalValue;
 542     }
 543     else if (fRegisterValue[reg].state == RegValue_t::kIndividual) {
 544        if((det >= 0 && det < AliTRDgeometry::Ndet()) &&
 545           (rob >= 0 && rob < AliTRDfeeParam::GetNrobC1()) &&
 546           (mcm >= 0 && mcm < fgkMaxMcm)) {
 547          return fRegisterValue[reg].individualValue[det*AliTRDfeeParam::GetNrobC1()*fgkMaxMcm + rob*fgkMaxMcm + mcm];
 548        }
 549        else {
 550          AliError("Invalid MCM specified or register is individual");
 551          return -1;
 552        }
 553     }
 554     else {  // should never be reached
 555       AliError("MCM register status neither kGlobal nor kIndividual");
 556       return -1;
 557     }
 558   }
 559   return -1;
 560 }
 561
 562
 563 Bool_t AliTRDtrapConfig::SetTrapReg(TrapReg_t reg, Int_t value)
 564 {
 565   // set a global value for the given TRAP register,
 566   // i.e. the same value for all TRAPs
 567
 568    if (fRegisterValue[reg].state == RegValue_t::kGlobal) {
 569       fRegisterValue[reg].globalValue = value;
 570       return kTRUE;
 571    }
 572    else {
 573       AliError("Register has individual values");
 574    }
 575    return kFALSE;
 576 }
 577
 578
 579 Bool_t AliTRDtrapConfig::SetTrapReg(TrapReg_t reg, Int_t value, Int_t det)
 580 {
 581   // set a global value for the given TRAP register,
 582   // i.e. the same value for all TRAPs
 583
 584    if (fRegisterValue[reg].state == RegValue_t::kGlobal) {
 585       fRegisterValue[reg].globalValue = value;
 586       return kTRUE;
 587    }
 588    else if (fRegisterValue[reg].state == RegValue_t::kIndividual) {
 589       // if the register is in idividual mode but a broadcast is requested, the selected register is
 590       // set to value for all MCMs on the chamber
 591
 592       if( (det>=0 && det<AliTRDgeometry::Ndet())) {
 593          for(Int_t rob=0; rob<AliTRDfeeParam::GetNrobC1(); rob++) {
 594             for(Int_t mcm=0; mcm<fgkMaxMcm; mcm++)
 595                fRegisterValue[reg].individualValue[det*AliTRDfeeParam::GetNrobC1()*fgkMaxMcm + rob*fgkMaxMcm + mcm] = value;
 596          }
 597       }
 598       else {
 599          AliError("Invalid value for det, ROB or MCM selected");
 600          return kFALSE;
 601       }
 602    }
 603    else {  // should never be reached
 604       AliError("MCM register status neither kGlobal nor kIndividual");
 605       return kFALSE;
 606    }
 607
 608    return kFALSE;
 609 }
 610
 611
 612 Bool_t AliTRDtrapConfig::SetTrapReg(TrapReg_t reg, Int_t value, Int_t det, Int_t rob, Int_t mcm)
 613 {
 614   // set the value for the given TRAP register of an individual MCM
 615
 616    //std::cout << "-- reg: 0x" << std::hex << fRegs[reg].addr << std::dec << ", data " << value << ", det " << det << ", rob " << rob << ", mcm " << mcm << std::endl;
 617
 618    if( (det >= 0 && det < AliTRDgeometry::Ndet()) &&
 619        (rob >= 0 && rob < AliTRDfeeParam::GetNrobC1()) &&
 620        (mcm >= 0 && mcm < fgkMaxMcm) ) {
 621      if (fRegisterValue[reg].state == RegValue_t::kGlobal) {
 622         Int_t defaultValue = fRegisterValue[reg].globalValue;
 623
 624         fRegisterValue[reg].state = RegValue_t::kIndividual;
 625         fRegisterValue[reg].individualValue = new Int_t[AliTRDgeometry::Ndet()*AliTRDfeeParam::GetNrobC1()*fgkMaxMcm];
 626
 627         for(Int_t i = 0; i < AliTRDgeometry::Ndet()*AliTRDfeeParam::GetNrobC1()*fgkMaxMcm; i++)
 628            fRegisterValue[reg].individualValue[i] = defaultValue; // set the requested register of all MCMs to the value previously stored
 629
 630         fRegisterValue[reg].individualValue[det*AliTRDfeeParam::GetNrobC1()*fgkMaxMcm + rob*fgkMaxMcm + mcm] = value;
 631      }
 632      else if (fRegisterValue[reg].state == RegValue_t::kIndividual) {
 633         fRegisterValue[reg].individualValue[det*AliTRDfeeParam::GetNrobC1()*fgkMaxMcm + rob*fgkMaxMcm + mcm] = value;
 634      }
 635      else {  // should never be reached
 636         AliError("MCM register status neither kGlobal nor kIndividual");
 637         return kFALSE;
 638      }
 639   }
 640    else {
 641       AliError("Invalid value for det, ROB or MCM selected");
 642      return kFALSE;
 643    }
 644
 645   return kTRUE;
 646 }
 647
 648
 649 Int_t AliTRDtrapConfig::Peek(Int_t addr, Int_t /* det */, Int_t /* rob */, Int_t /* mcm */)
 650 {
 651   // reading from given address
 652   // not to be used yet
 653
 654   if ( (addr >= fgkDmemStartAddress) &&
 655        (addr < (fgkDmemStartAddress + fgkDmemWords)) ) {
 656     printf("DMEM\n");
 657     return 0;
 658   }
 659   else {
 660     TrapReg_t mcmReg = GetRegByAddress(addr);
 661     if ( mcmReg >= 0 && mcmReg < kLastReg) {
 662       printf("Register: %s\n", GetRegName(mcmReg));
 663       return 0;
 664     }
 665   }
 666
 667   return -1;
 668 }
 669
 670
 671 Bool_t AliTRDtrapConfig::Poke(Int_t addr, Int_t value, Int_t /* det */, Int_t /* rob */, Int_t /* mcm */)
 672 {
 673   // writing to given address
 674   // not to be used yet
 675
 676   if ( (addr >= fgkDmemStartAddress) &&
 677        (addr < (fgkDmemStartAddress + fgkDmemWords)) ) {
 678     printf("DMEM 0x%08x : %i\n", addr, value);
 679     return kTRUE;
 680   }
 681   else {
 682     TrapReg_t mcmReg = GetRegByAddress(addr);
 683     if ( mcmReg >= 0 && mcmReg < kLastReg) {
 684       printf("Register: %s : %i\n", GetRegName(mcmReg), value);
 685       return kTRUE;
 686     }
 687   }
 688
 689   return kFALSE;
 690 }
 691
 692
 693 Bool_t AliTRDtrapConfig::SetDmem(Int_t addr, Int_t value)
 694 {
 695   if ( (addr >> 14) != 0x3) {
 696     AliError(Form("No DMEM address: 0x%08x", addr));
 697     return kFALSE;
 698   }
 699
 700   for (Int_t iDet = 0; iDet < 540; iDet++) {
 701     for (Int_t iROB = 0; iROB < AliTRDfeeParam::GetNrobC1(); iROB++) {
 702       for (Int_t iMCM = 0; iMCM < fgkMaxMcm; iMCM++) {
 703         fDmem[iDet*AliTRDfeeParam::GetNrobC1()*fgkMaxMcm + iROB*fgkMaxMcm + iMCM]
 704           [addr - fgkDmemStartAddress] = value;
 705       }
 706     }
 707   }
 708   return kTRUE;
 709 }
 710
 711
 712 Bool_t AliTRDtrapConfig::SetDmem(Int_t addr, Int_t value, Int_t det)
 713 {
 714   for (Int_t iROB = 0; iROB < AliTRDfeeParam::GetNrobC1(); iROB++) {
 715     for (Int_t iMCM = 0; iMCM < fgkMaxMcm; iMCM++) {
 716       fDmem[det*AliTRDfeeParam::GetNrobC1()*fgkMaxMcm + iROB*fgkMaxMcm + iMCM]
 717         [addr - fgkDmemStartAddress] = value;
 718     }
 719   }
 720   return kTRUE;
 721 }
 722
 723
 724 Bool_t AliTRDtrapConfig::SetDmem(Int_t addr, Int_t value, Int_t det, Int_t rob, Int_t mcm)
 725 {
 726   fDmem[det*AliTRDfeeParam::GetNrobC1()*fgkMaxMcm + rob*fgkMaxMcm + mcm]
 727     [addr - fgkDmemStartAddress] = value;
 728   return kTRUE;
 729 }
 730
 731
 732 Int_t AliTRDtrapConfig::GetDmem(Int_t addr, Int_t det, Int_t rob, Int_t mcm)
 733 {
 734   return fDmem[det*AliTRDfeeParam::GetNrobC1()*fgkMaxMcm + rob*fgkMaxMcm + mcm]
 735     [addr - fgkDmemStartAddress];
 736 }
 737
 738
 739 Bool_t AliTRDtrapConfig::LoadConfig()
 740 {
 741   // load a set of TRAP register values (configuration)
 742   // here a default set is implemented for testing
 743   // for a detailed description of the registers see the TRAP manual
 744
 745   // no. of timebins
 746   SetTrapReg(kC13CPUA, 24);
 747
 748   // pedestal filter
 749   SetTrapReg(kFPNP, 4*10);
 750   SetTrapReg(kFPTC, 0);
 751   SetTrapReg(kFPBY, 0); // bypassed!
 752
 753   // gain filter
 754   for (Int_t adc = 0; adc < 20; adc++) {
 755     SetTrapReg(TrapReg_t(kFGA0+adc), 40);
 756     SetTrapReg(TrapReg_t(kFGF0+adc), 15);
 757   }
 758   SetTrapReg(kFGTA, 20);
 759   SetTrapReg(kFGTB, 2060);
 760   SetTrapReg(kFGBY, 0);  // bypassed!
 761
 762   // tail cancellation
 763   SetTrapReg(kFTAL, 267);
 764   SetTrapReg(kFTLL, 356);
 765   SetTrapReg(kFTLS, 387);
 766   SetTrapReg(kFTBY, 0);
 767
 768   // tracklet calculation
 769   SetTrapReg(kTPQS0, 5);
 770   SetTrapReg(kTPQE0, 10);
 771   SetTrapReg(kTPQS1, 11);
 772   SetTrapReg(kTPQE1, 20);
 773   SetTrapReg(kTPFS, 5);
 774   SetTrapReg(kTPFE, 20);
 775   SetTrapReg(kTPVBY, 0);
 776   SetTrapReg(kTPVT, 10);
 777   SetTrapReg(kTPHT, 150);
 778   SetTrapReg(kTPFP, 40);
 779   SetTrapReg(kTPCL, 1);
 780   SetTrapReg(kTPCT, 10);
 781
 782   // ndrift (+ 5 binary digits)
 783   SetDmem(0xc025, 20 << 5);
 784   // deflection + tilt correction
 785   SetDmem(0xc022, 0);
 786   // deflection range table
 787   for (Int_t iTrklCh = 0; iTrklCh < 18; iTrklCh++) {
 788     SetDmem(0xc030 + 2 * iTrklCh, -64); // min. deflection
 789     SetDmem(0xc031 + 2 * iTrklCh,  63); // max. deflection
 790   }
 791
 792   // hit position LUT
 793   const UShort_t lutPos[128] = {
 794     0,  1,  1,  2,  2,  3,  3,  4,  4,  5,  5,  6,  6,  7,  7,  8,  8,  9,  9, 10, 10, 11, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15,
 795     16, 16, 16, 17, 17, 18, 18, 19, 19, 19, 20, 20, 20, 21, 21, 22, 22, 22, 23, 23, 23, 24, 24, 24, 24, 25, 25, 25, 26, 26, 26, 26,
 796     27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 27, 27, 27, 27, 26,
 797     26, 26, 26, 25, 25, 25, 24, 24, 23, 23, 22, 22, 21, 21, 20, 20, 19, 18, 18, 17, 17, 16, 15, 14, 13, 12, 11, 10,  9,  8,  7,  7};
 798   for (Int_t iCOG = 0; iCOG < 128; iCOG++)
 799     SetTrapReg((TrapReg_t) (kTPL00 + iCOG), lutPos[iCOG]);
 800
 801   // event buffer
 802   SetTrapReg(kEBSF, 1);  // 0: store filtered; 1: store unfiltered
 803   // zs applied to data stored in event buffer (sel. by EBSF)
 804   SetTrapReg(kEBIS, 15 << 2); // single indicator threshold (plus two digits)
 805   SetTrapReg(kEBIT, 30 << 2); // sum indicator threshold (plus two digits)
 806   SetTrapReg(kEBIL, 0xf0);   // lookup table
 807   SetTrapReg(kEBIN, 0);      // neighbour sensitivity
 808
 809   // raw data
 810   SetTrapReg(kNES, (0x0000 << 16) | 0x1000);
 811
 812   return kTRUE;
 813 }
 814
 815
 816 Bool_t  AliTRDtrapConfig::LoadConfig(Int_t det, TString filename)
 817 {
 818    // load a TRAP configuration from a file
 819    // The file format is the format created by the standalone
 820    // command coder: scc / show_cfdat
 821    // which are two tools to inspect/export configurations from wingDB
 822
 823   ResetRegs(); // does not really make sense here???
 824
 825   std::ifstream infile;
 826   infile.open(filename.Data(), std::ifstream::in);
 827   if (!infile.is_open()) {
 828     AliError("Can not open MCM configuration file");
 829     return kFALSE;
 830   }
 831
 832   Int_t cmd, extali, addr, data;
 833   Int_t no;
 834   char tmp;
 835
 836   while(infile.good()) {
 837     cmd=-1;
 838     extali=-1;
 839     addr=-1;
 840     data=-1;
 841     infile >> std::skipws >> no >> tmp >> cmd >> extali >> addr >> data;
 842     //      std::cout << "no: " << no << ", cmd " << cmd << ", extali " << extali << ", addr " << addr << ", data " << data <<  endl;
 843
 844     if(cmd!=-1 && extali!=-1 && addr != -1 && data!= -1) {
 845       AddValues(det, cmd, extali, addr, data);
 846     }
 847     else if(!infile.eof() && !infile.good()) {
 848       infile.clear();
 849       infile.ignore(256, '\n');
 850     }
 851
 852     if(!infile.eof())
 853       infile.clear();
 854   }
 855
 856   infile.close();
 857
 858   return kTRUE;
 859 }
 860
 861
 862 Bool_t AliTRDtrapConfig::ReadPackedConfig(UInt_t *data, Int_t size)
 863 {
 864   Int_t idx = 0;
 865   Int_t err = 0;
 866   Int_t step, bwidth, nwords, exit_flag, bitcnt;
 867
 868   UShort_t caddr;
 869   UInt_t dat, msk, header, data_hi;
 870
 871   while (idx < size) {
 872
 873     header = *data;
 874     data++;
 875     idx++;
 876
 877     AliDebug(5, Form("read: 0x%08x", header));
 878
 879     if (header & 0x01) // single data
 880     {
 881       dat   = (header >>  2) & 0xFFFF;       // 16 bit data
 882       caddr = (header >> 18) & 0x3FFF;    // 14 bit address
 883
 884       if (caddr != 0x1FFF)  // temp!!! because the end marker was wrong
 885       {
 886         if (header & 0x02) // check if > 16 bits
 887         {
 888           data_hi = *data;
 889           AliDebug(5, Form("read: 0x%08x", data_hi));
 890           data++;
 891           idx++;
 892           err += ((data_hi ^ (dat | 1)) & 0xFFFF) != 0;
 893           dat = (data_hi & 0xFFFF0000) | dat;
 894         }
 895         AliDebug(5, Form("addr=0x%04x (%s) data=0x%08x\n", caddr, GetRegName(GetRegByAddress(caddr)), dat));
 896         if ( ! Poke(caddr, dat, 0, 0, 0) )
 897           AliDebug(5, Form("(single-write): non-existing address 0x%04x containing 0x%08x\n", caddr, header));
 898         if (idx > size)
 899         {
 900           AliDebug(5, Form("(single-write): no more data, missing end marker\n"));
 901           return -err;
 902         }
 903       }
 904       else
 905       {
 906         AliDebug(5, Form("(single-write): address 0x%04x => old endmarker?\n", caddr));
 907         return err;
 908       }
 909     }
 910
 911     else               // block of data
 912     {
 913       step   =  (header >>  1) & 0x0003;
 914       bwidth = ((header >>  3) & 0x001F) + 1;
 915       nwords =  (header >>  8) & 0x00FF;
 916       caddr  =  (header >> 16) & 0xFFFF;
 917       exit_flag = (step == 0) || (step == 3) || (nwords == 0);
 918
 919       if (exit_flag)
 920         return err;
 921
 922       switch (bwidth)
 923       {
 924           case    15:
 925           case    10:
 926           case     7:
 927           case     6:
 928           case     5:
 929           {
 930             msk = (1 << bwidth) - 1;
 931             bitcnt = 0;
 932             while (nwords > 0)
 933             {
 934               nwords--;
 935               bitcnt -= bwidth;
 936               if (bitcnt < 0)
 937               {
 938                 header = *data;
 939                 AliDebug(5, Form("read 0x%08x", header));
 940                 data++;
 941                 idx++;
 942                 err += (header & 1);
 943                 header = header >> 1;
 944                 bitcnt = 31 - bwidth;
 945               }
 946               AliDebug(5, Form("addr=0x%04x (%s) data=0x%08x\n", caddr, GetRegName(GetRegByAddress(caddr)), header & msk));
 947               if ( ! Poke(caddr, header & msk, 0, 0, 0) )
 948                 AliDebug(5, Form("(single-write): non-existing address 0x%04x containing 0x%08x\n", caddr, header));
 949
 950               caddr += step;
 951               header = header >> bwidth;
 952               if (idx >= size)
 953               {
 954                 AliDebug(5, Form("(block-write): no end marker! %d words read\n", idx));
 955                 return -err;
 956               }
 957             }
 958             break;
 959           } // end case 5-15
 960           case 31:
 961           {
 962             while (nwords > 0)
 963             {
 964               header = *data;
 965               AliDebug(5, Form("read 0x%08x", header));
 966               data++;
 967               idx++;
 968               nwords--;
 969               err += (header & 1);
 970
 971               AliDebug(5, Form("addr=0x%04x (%s) data=0x%08x", caddr, GetRegName(GetRegByAddress(caddr)), header >> 1));
 972               if ( ! Poke(caddr, header >> 1, 0, 0, 0) )
 973                 AliDebug(5, Form("(single-write): non-existing address 0x%04x containing 0x%08x\n", caddr, header));
 974
 975               caddr += step;
 976               if (idx >= size)
 977               {
 978                 AliDebug(5, Form("no end marker! %d words read", idx));
 979                 return -err;
 980               }
 981             }
 982             break;
 983           }
 984           default: return err;
 985       } // end switch
 986     } // end block case
 987   } // end while
 988   AliDebug(5, Form("no end marker! %d words read", idx));
 989   return -err; // only if the max length of the block reached!
 990 }
 991
 992
 993 Bool_t AliTRDtrapConfig::PrintTrapReg(TrapReg_t reg, Int_t det, Int_t rob, Int_t mcm)
 994 {
 995   // print the value stored in the given register
 996   // if it is individual a valid MCM has to be specified
 997
 998   if (fRegisterValue[reg].state == RegValue_t::kGlobal) {
 999     printf("%s (%i bits) at 0x%08x is 0x%08x and resets to: 0x%08x (currently global mode)\n",
1000            GetRegName((TrapReg_t) reg),
1001            GetRegNBits((TrapReg_t) reg),
1002            GetRegAddress((TrapReg_t) reg),
1003            fRegisterValue[reg].globalValue,
1004            GetRegResetValue((TrapReg_t) reg));
1005   }
1006   else if (fRegisterValue[reg].state == RegValue_t::kIndividual) {
1007     if((det >= 0 && det < AliTRDgeometry::Ndet()) &&
1008        (rob >= 0 && rob < AliTRDfeeParam::GetNrobC1()) &&
1009        (mcm >= 0 && mcm < fgkMaxMcm)) {
1010       printf("%s (%i bits) at 0x%08x is 0x%08x and resets to: 0x%08x (currently individual mode)\n",
1011              GetRegName((TrapReg_t) reg),
1012              GetRegNBits((TrapReg_t) reg),
1013              GetRegAddress((TrapReg_t) reg),
1014              fRegisterValue[reg].individualValue[det*AliTRDfeeParam::GetNrobC1()*fgkMaxMcm + rob*fgkMaxMcm + mcm],
1015              GetRegResetValue((TrapReg_t) reg));
1016     }
1017     else {
1018       AliError("Register value is MCM-specific: Invalid detector, ROB or MCM requested");
1019       return kFALSE;
1020     }
1021   }
1022   else {  // should never be reached
1023     AliError("MCM register status neither kGlobal nor kIndividual");
1024     return kFALSE;
1025   }
1026   return kTRUE;
1027 }
1028
1029
1030 Bool_t AliTRDtrapConfig::PrintTrapAddr(Int_t addr, Int_t det, Int_t rob, Int_t mcm)
1031 {
1032   // print the value stored at the given address in the MCM chip
1033   TrapReg_t reg = GetRegByAddress(addr);
1034   if (reg >= 0 && reg < kLastReg) {
1035     return PrintTrapReg(reg, det, rob, mcm);
1036   }
1037   else {
1038     AliError(Form("There is no register at address 0x%08x in the simulator", addr));
1039     return kFALSE;
1040   }
1041 }
1042
1043
1044 Bool_t AliTRDtrapConfig::AddValues(UInt_t det, UInt_t cmd, UInt_t extali, Int_t addr, UInt_t data)
1045 {
1046    // transfer the informations provided by LoadConfig to the internal class variables
1047
1048   if(cmd != fgkScsnCmdWrite) {
1049     AliError(Form("Invalid command received: %i", cmd));
1050     return kFALSE;
1051   }
1052
1053   TrapReg_t mcmReg = GetRegByAddress(addr);
1054   Int_t rocType = AliTRDgeometry::GetStack(det) == 2 ? 0 : 1;
1055
1056   // configuration registers
1057   if(mcmReg >= 0 && mcmReg < kLastReg) {
1058
1059     for(Int_t linkPair=0; linkPair<fgkMaxLinkPairs; linkPair++) {
1060       if(ExtAliToAli(extali, linkPair, rocType)!=0) {
1061         Int_t i=0;
1062         while(fMcmlist[i] != -1 && i<fgkMcmlistSize) {
1063           if(fMcmlist[i]==127)
1064             SetTrapReg( (TrapReg_t) mcmReg, data, det);
1065           else
1066             SetTrapReg( (TrapReg_t) mcmReg, data, det, (fMcmlist[i]>>7), (fMcmlist[i]&0x7F));
1067           i++;
1068         }
1069       }
1070     }
1071     return kTRUE;
1072   }
1073   // DMEM
1074   else if ( (addr >= fgkDmemStartAddress) &&
1075             (addr < (fgkDmemStartAddress + fgkDmemWords))) {
1076     for(Int_t linkPair=0; linkPair<fgkMaxLinkPairs; linkPair++) {
1077       if(ExtAliToAli(extali, linkPair, rocType)!=0) {
1078         Int_t i=0;
1079         while(fMcmlist[i] != -1 && i < fgkMcmlistSize) {
1080           if(fMcmlist[i] == 127)
1081             //      fDmem[0][addr - fgkDmemStartAddress] = data;
1082             SetDmem(addr, data, det);
1083           else
1084             //      fDmem[det*AliTRDfeeParam::GetNrobC1()*fgkMaxMcm + (fMcmlist[i] >> 7)*fgkMaxMcm + (fMcmlist[i]&0x7f)]
1085             //        [addr - fgkDmemStartAddress] = data;
1086               SetDmem(addr, data, det, fMcmlist[i] >> 7, fMcmlist[i] & 0x7f);
1087           i++;
1088         }
1089       }
1090     }
1091     return kTRUE;
1092   }
1093   else
1094     return kFALSE;
1095 }
1096
1097
1098 Int_t AliTRDtrapConfig::ExtAliToAli( UInt_t dest, UShort_t linkpair, UShort_t rocType)
1099 {
1100    // Converts an extended ALICE ID which identifies a single MCM or a group of MCMs to
1101    // the corresponding list of MCMs. Only broadcasts (127) are encoded as 127
1102    // The return value is the number of MCMs in the list
1103
1104    fMcmlist[0]=-1;
1105
1106   Short_t nmcm = 0;
1107   UInt_t mcm, rob, robAB;
1108   UInt_t cmA = 0, cmB = 0;  // Chipmask for each A and B side
1109
1110   // Default chipmask for 4 linkpairs (each bit correponds each alice-mcm)
1111   static const UInt_t gkChipmaskDefLp[4] = { 0x1FFFF, 0x1FFFF, 0x3FFFF, 0x1FFFF };
1112
1113   rob = dest >> 7;                              // Extract ROB pattern from dest.
1114   mcm = dest & 0x07F;                           // Extract MCM pattern from dest.
1115   robAB = GetRobAB( rob, linkpair ); // Get which ROB sides are selected.
1116
1117   // Abort if no ROB is selected
1118   if( robAB == 0 ) {
1119     return 0;
1120   }
1121
1122   // Special case
1123   if( mcm == 127 ) {
1124     if( robAB == 3 ) {      // This is very special 127 can stay only if two ROBs are selected
1125       fMcmlist[0]=127;      // broadcase to ALL
1126       fMcmlist[1]=-1;
1127       return 1;
1128     }
1129     cmA = cmB = 0x3FFFF;
1130   } else if( (mcm & 0x40) != 0 ) { // If top bit is 1 but not 127, this is chip group.
1131     if( (mcm & 0x01) != 0 )                  { cmA |= 0x04444; cmB |= 0x04444; } // chip_cmrg
1132     if( (mcm & 0x02) != 0 )                  { cmA |= 0x10000; cmB |= 0x10000; } // chip_bmrg
1133     if( (mcm & 0x04) != 0 && rocType == 0 ) { cmA |= 0x20000; cmB |= 0x20000; } // chip_hm3
1134     if( (mcm & 0x08) != 0 && rocType == 1 ) { cmA |= 0x20000; cmB |= 0x20000; } // chip_hm4
1135     if( (mcm & 0x10) != 0 )                  { cmA |= 0x01111; cmB |= 0x08888; } // chip_edge
1136     if( (mcm & 0x20) != 0 )                  { cmA |= 0x0aaaa; cmB |= 0x03333; } // chip_norm
1137   } else { // Otherwise, this is normal chip ID, turn on only one chip.
1138     cmA = 1 << mcm;
1139     cmB = 1 << mcm;
1140   }
1141
1142   // Mask non-existing MCMs
1143   cmA &= gkChipmaskDefLp[linkpair];
1144   cmB &= gkChipmaskDefLp[linkpair];
1145   // Remove if only one side is selected
1146   if( robAB == 1 )
1147     cmB = 0;
1148   if( robAB == 2 )
1149     cmA = 0;
1150   if( robAB == 4 && linkpair != 2 )
1151     cmA = cmB = 0; // Restrict to only T3A and T3B
1152
1153   // Finally convert chipmask to list of slaves
1154   nmcm = ChipmaskToMCMlist( cmA, cmB, linkpair );
1155
1156   return nmcm;
1157 }
1158
1159
1160 Short_t AliTRDtrapConfig::GetRobAB( UShort_t robsel, UShort_t linkpair ) const
1161 {
1162   // Converts the ROB part of the extended ALICE ID to robs
1163
1164   if( (robsel & 0x8) != 0 ) { // 1000 .. direct ROB selection. Only one of the 8 ROBs are used.
1165     robsel = robsel & 7;
1166     if( (robsel % 2) == 0 && (robsel / 2) == linkpair )
1167       return 1;  // Even means A side (position 0,2,4,6)
1168     if( (robsel % 2) == 1 && (robsel / 2) == linkpair )
1169       return 2;  // Odd  means B side (position 1,3,5,7)
1170     return 0;
1171   }
1172
1173   // ROB group
1174   if( robsel == 0 ) { return 3; } // Both   ROB
1175   if( robsel == 1 ) { return 1; } // A-side ROB
1176   if( robsel == 2 ) { return 2; } // B-side ROB
1177   if( robsel == 3 ) { return 3; } // Both   ROB
1178   if( robsel == 4 ) { return 4; } // Only T3A and T3B
1179   // Other number 5 to 7 are ignored (not defined)
1180
1181   return 0;
1182 }
1183
1184
1185 Short_t AliTRDtrapConfig::ChipmaskToMCMlist( Int_t cmA, Int_t cmB, UShort_t linkpair )
1186 {
1187   // Converts the chipmask to a list of MCMs
1188
1189   Short_t nmcm = 0;
1190   Short_t i;
1191   for( i = 0 ; i < fgkMaxMcm ; i++ ) {
1192      if( (cmA & (1 << i)) != 0 ) {
1193         fMcmlist[nmcm] = ((linkpair*2) << 7) | i;
1194         ++nmcm;
1195     }
1196     if( (cmB & (1 << i)) != 0 ) {
1197        fMcmlist[nmcm] = ((linkpair*2+1) << 7) | i;
1198        ++nmcm;
1199     }
1200   }
1201
1202   fMcmlist[nmcm]=-1;
1203   return nmcm;
1204 }
1205
1206
1207 AliTRDtrapConfig::TrapReg_t AliTRDtrapConfig::GetRegByAddress(Int_t address) const
1208 {
1209   // get register by its address
1210   // used for reading of configuration data as sent to real FEE
1211
1212   TrapReg_t mcmReg = kLastReg;
1213   Int_t reg  = 0;
1214   do {
1215     if(fRegs[reg].fAddr == address)
1216       mcmReg = (TrapReg_t) reg;
1217     reg++;
1218   }  while (mcmReg == kLastReg && reg < kLastReg);
1219
1220   return mcmReg;
1221 }
1222
1223