[u/mrichter/AliRoot.git] / TRD / AliTRDtrapConfig.h

#ifndef ALITRDTRAPCONFIG_H
#define ALITRDTRAPCONFIG_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

// Configuration of the TRD TRAcklet Processor
// (TRD Front-End Electronics)
//
// TRAP registers
// TRAP data memory (DMEM)

#include <TObject.h>
#include <TNamed.h>
#include <TString.h>
#include <fstream>

class AliTRDtrapConfig : public TNamed
{
 public:
  AliTRDtrapConfig(const TString &name = "", const TString &title = "");
  ~AliTRDtrapConfig();

  // allocation
  enum Alloc_t {
    kAllocNone,
    kAllocGlobal,
    kAllocByDetector,
    kAllocByHC,
    kAllocByMCM,
    kAllocByMergerType,
    kAllocByLayer,
    kAllocByMCMinSM,
    kAllocLast
  }; // possible granularities for allocation
     // common to registers and DMEM

  // registers
  enum TrapReg_t { kSML0,
		  kSML1,
		  kSML2,
		  kSMMODE,
		  kSMCMD,
		  kNITM0,
		  kNITM1,
		  kNITM2,
		  kNIP4D,
		  kCPU0CLK,
		  kCPU1CLK,
		  kCPU2CLK,
		  kCPU3CLK,
		  kNICLK,
		  kFILCLK,
		  kPRECLK,
		  kADCEN,
		  kNIODE,
		  kNIOCE,
		  kNIIDE,
		  kNIICE,
		  kARBTIM,
		  kIA0IRQ0,
		  kIA0IRQ1,
		  kIA0IRQ2,
		  kIA0IRQ3,
		  kIA0IRQ4,
		  kIA0IRQ5,
		  kIA0IRQ6,
		  kIA0IRQ7,
		  kIA0IRQ8,
		  kIA0IRQ9,
		  kIA0IRQA,
		  kIA0IRQB,
		  kIA0IRQC,
		  kIRQSW0,
		  kIRQHW0,
		  kIRQHL0,
		  kIA1IRQ0,
		  kIA1IRQ1,
		  kIA1IRQ2,
		  kIA1IRQ3,
		  kIA1IRQ4,
		  kIA1IRQ5,
		  kIA1IRQ6,
		  kIA1IRQ7,
		  kIA1IRQ8,
		  kIA1IRQ9,
		  kIA1IRQA,
		  kIA1IRQB,
		  kIA1IRQC,
		  kIRQSW1,
		  kIRQHW1,
		  kIRQHL1,
		  kIA2IRQ0,
		  kIA2IRQ1,
		  kIA2IRQ2,
		  kIA2IRQ3,
		  kIA2IRQ4,
		  kIA2IRQ5,
		  kIA2IRQ6,
		  kIA2IRQ7,
		  kIA2IRQ8,
		  kIA2IRQ9,
		  kIA2IRQA,
		  kIA2IRQB,
		  kIA2IRQC,
		  kIRQSW2,
		  kIRQHW2,
		  kIRQHL2,
		  kIA3IRQ0,
		  kIA3IRQ1,
		  kIA3IRQ2,
		  kIA3IRQ3,
		  kIA3IRQ4,
		  kIA3IRQ5,
		  kIA3IRQ6,
		  kIA3IRQ7,
		  kIA3IRQ8,
		  kIA3IRQ9,
		  kIA3IRQA,
		  kIA3IRQB,
		  kIA3IRQC,
		  kIRQSW3,
		  kIRQHW3,
		  kIRQHL3,
		  kCTGDINI,
		  kCTGCTRL,
		  kC08CPU0,
		  kC09CPU0,
		  kC10CPU0,
		  kC11CPU0,
		  kC12CPUA,
		  kC13CPUA,
		  kC14CPUA,
		  kC15CPUA,
		  kC08CPU1,
		  kC09CPU1,
		  kC10CPU1,
		  kC11CPU1,
		  kC08CPU2,
		  kC09CPU2,
		  kC10CPU2,
		  kC11CPU2,
		  kC08CPU3,
		  kC09CPU3,
		  kC10CPU3,
		  kC11CPU3,
		  kNMOD,
		  kNDLY,
		  kNED,
		  kNTRO,
		  kNRRO,
		  kNES,
		  kNTP,
		  kNBND,
		  kNP0,
		  kNP1,
		  kNP2,
		  kNP3,
		  kNCUT,
		  kTPPT0,
		  kTPFS,
		  kTPFE,
		  kTPPGR,
		  kTPPAE,
		  kTPQS0,
		  kTPQE0,
		  kTPQS1,
		  kTPQE1,
		  kEBD,
		  kEBAQA,
		  kEBSIA,
		  kEBSF,
		  kEBSIM,
		  kEBPP,
		  kEBPC,
		  kEBIS,
		  kEBIT,
		  kEBIL,
		  kEBIN,
		  kFLBY,
		  kFPBY,
		  kFGBY,
		  kFTBY,
		  kFCBY,
		  kFPTC,
		  kFPNP,
		  kFPCL,
		  kFGTA,
		  kFGTB,
		  kFGCL,
		  kFTAL,
		  kFTLL,
		  kFTLS,
		  kFCW1,
		  kFCW2,
		  kFCW3,
		  kFCW4,
		  kFCW5,
		  kTPFP,
		  kTPHT,
		  kTPVT,
		  kTPVBY,
		  kTPCT,
		  kTPCL,
		  kTPCBY,
		  kTPD,
		  kTPCI0,
		  kTPCI1,
		  kTPCI2,
		  kTPCI3,
		  kADCMSK,
		  kADCINB,
		  kADCDAC,
		  kADCPAR,
		  kADCTST,
		  kSADCAZ,
		  kFGF0,
		  kFGF1,
		  kFGF2,
		  kFGF3,
		  kFGF4,
		  kFGF5,
		  kFGF6,
		  kFGF7,
		  kFGF8,
		  kFGF9,
		  kFGF10,
		  kFGF11,
		  kFGF12,
		  kFGF13,
		  kFGF14,
		  kFGF15,
		  kFGF16,
		  kFGF17,
		  kFGF18,
		  kFGF19,
		  kFGF20,
		  kFGA0,
		  kFGA1,
		  kFGA2,
		  kFGA3,
		  kFGA4,
		  kFGA5,
		  kFGA6,
		  kFGA7,
		  kFGA8,
		  kFGA9,
		  kFGA10,
		  kFGA11,
		  kFGA12,
		  kFGA13,
		  kFGA14,
		  kFGA15,
		  kFGA16,
		  kFGA17,
		  kFGA18,
		  kFGA19,
		  kFGA20,
		  kFLL00,
		  kFLL01,
		  kFLL02,
		  kFLL03,
		  kFLL04,
		  kFLL05,
		  kFLL06,
		  kFLL07,
		  kFLL08,
		  kFLL09,
		  kFLL0A,
		  kFLL0B,
		  kFLL0C,
		  kFLL0D,
		  kFLL0E,
		  kFLL0F,
		  kFLL10,
		  kFLL11,
		  kFLL12,
		  kFLL13,
		  kFLL14,
		  kFLL15,
		  kFLL16,
		  kFLL17,
		  kFLL18,
		  kFLL19,
		  kFLL1A,
		  kFLL1B,
		  kFLL1C,
		  kFLL1D,
		  kFLL1E,
		  kFLL1F,
		  kFLL20,
		  kFLL21,
		  kFLL22,
		  kFLL23,
		  kFLL24,
		  kFLL25,
		  kFLL26,
		  kFLL27,
		  kFLL28,
		  kFLL29,
		  kFLL2A,
		  kFLL2B,
		  kFLL2C,
		  kFLL2D,
		  kFLL2E,
		  kFLL2F,
		  kFLL30,
		  kFLL31,
		  kFLL32,
		  kFLL33,
		  kFLL34,
		  kFLL35,
		  kFLL36,
		  kFLL37,
		  kFLL38,
		  kFLL39,
		  kFLL3A,
		  kFLL3B,
		  kFLL3C,
		  kFLL3D,
		  kFLL3E,
		  kFLL3F,
		  kPASADEL,
		  kPASAPHA,
		  kPASAPRA,
		  kPASADAC,
		  kPASACHM,
		  kPASASTL,
		  kPASAPR1,
		  kPASAPR0,
		  kSADCTRG,
		  kSADCRUN,
		  kSADCPWR,
		  kL0TSIM,
		  kSADCEC,
		  kSADCMC,
		  kSADCOC,
		  kSADCGTB,
		  kSEBDEN,
		  kSEBDOU,
		  kTPL00,
		  kTPL01,
		  kTPL02,
		  kTPL03,
		  kTPL04,
		  kTPL05,
		  kTPL06,
		  kTPL07,
		  kTPL08,
		  kTPL09,
		  kTPL0A,
		  kTPL0B,
		  kTPL0C,
		  kTPL0D,
		  kTPL0E,
		  kTPL0F,
		  kTPL10,
		  kTPL11,
		  kTPL12,
		  kTPL13,
		  kTPL14,
		  kTPL15,
		  kTPL16,
		  kTPL17,
		  kTPL18,
		  kTPL19,
		  kTPL1A,
		  kTPL1B,
		  kTPL1C,
		  kTPL1D,
		  kTPL1E,
		  kTPL1F,
		  kTPL20,
		  kTPL21,
		  kTPL22,
		  kTPL23,
		  kTPL24,
		  kTPL25,
		  kTPL26,
		  kTPL27,
		  kTPL28,
		  kTPL29,
		  kTPL2A,
		  kTPL2B,
		  kTPL2C,
		  kTPL2D,
		  kTPL2E,
		  kTPL2F,
		  kTPL30,
		  kTPL31,
		  kTPL32,
		  kTPL33,
		  kTPL34,
		  kTPL35,
		  kTPL36,
		  kTPL37,
		  kTPL38,
		  kTPL39,
		  kTPL3A,
		  kTPL3B,
		  kTPL3C,
		  kTPL3D,
		  kTPL3E,
		  kTPL3F,
		  kTPL40,
		  kTPL41,
		  kTPL42,
		  kTPL43,
		  kTPL44,
		  kTPL45,
		  kTPL46,
		  kTPL47,
		  kTPL48,
		  kTPL49,
		  kTPL4A,
		  kTPL4B,
		  kTPL4C,
		  kTPL4D,
		  kTPL4E,
		  kTPL4F,
		  kTPL50,
		  kTPL51,
		  kTPL52,
		  kTPL53,
		  kTPL54,
		  kTPL55,
		  kTPL56,
		  kTPL57,
		  kTPL58,
		  kTPL59,
		  kTPL5A,
		  kTPL5B,
		  kTPL5C,
		  kTPL5D,
		  kTPL5E,
		  kTPL5F,
		  kTPL60,
		  kTPL61,
		  kTPL62,
		  kTPL63,
		  kTPL64,
		  kTPL65,
		  kTPL66,
		  kTPL67,
		  kTPL68,
		  kTPL69,
		  kTPL6A,
		  kTPL6B,
		  kTPL6C,
		  kTPL6D,
		  kTPL6E,
		  kTPL6F,
		  kTPL70,
		  kTPL71,
		  kTPL72,
		  kTPL73,
		  kTPL74,
		  kTPL75,
		  kTPL76,
		  kTPL77,
		  kTPL78,
		  kTPL79,
		  kTPL7A,
		  kTPL7B,
		  kTPL7C,
		  kTPL7D,
		  kTPL7E,
		  kTPL7F,
		  kMEMRW,
		  kMEMCOR,
		  kDMDELA,
		  kDMDELS,
		  kLastReg };   // enum of all TRAP registers, to be used for access to them

  Bool_t SetTrapRegAlloc(TrapReg_t reg, Alloc_t mode) { return fRegisterValue[reg].Allocate(mode); }
  Bool_t SetTrapReg(TrapReg_t reg, Int_t value, Int_t det);
  Bool_t SetTrapReg(TrapReg_t reg, Int_t value, Int_t det, Int_t rob, Int_t mcm);

  Int_t  GetTrapReg(TrapReg_t reg, Int_t det = -1, Int_t rob = -1, Int_t mcm = -1) const;

  void ResetRegs();

  // data memory (DMEM)
  Bool_t SetDmemAlloc(Int_t addr, Alloc_t mode);
  Bool_t SetDmem(Int_t addr, UInt_t value, Int_t det);
  Bool_t SetDmem(Int_t addr, UInt_t value, Int_t det, Int_t rob, Int_t mcm);
  Bool_t SetDmem(Int_t addr, Int_t value) { return SetDmem(addr, (UInt_t) value); }
  Bool_t SetDmem(Int_t addr, Int_t value, Int_t det, Int_t rob, Int_t mcm) { return SetDmem(addr, (UInt_t) value, det, rob, mcm); }

  UInt_t GetDmemUnsigned(Int_t addr, Int_t det, Int_t rob, Int_t mcm) const;

  void ResetDmem();

  // access by 16-bit address
  UInt_t Peek(Int_t addr, Int_t det, Int_t rob, Int_t mcm) const;
  Bool_t Poke(Int_t addr, UInt_t value, Int_t det, Int_t rob, Int_t mcm);

  // helper methods
  const char* GetRegName(TrapReg_t reg)       const { return ((reg >= 0) && (reg < kLastReg)) ? fRegisterValue[reg].GetName() : ""; }
  UShort_t    GetRegAddress(TrapReg_t reg)    const { return ((reg >= 0) && (reg < kLastReg)) ? fRegisterValue[reg].GetAddr() : 0; }
  UShort_t    GetRegNBits(TrapReg_t reg)      const { return ((reg >= 0) && (reg < kLastReg)) ? fRegisterValue[reg].GetNbits() : 0; }
  UInt_t      GetRegResetValue(TrapReg_t reg) const { return ((reg >= 0) && (reg < kLastReg)) ? fRegisterValue[reg].GetResetValue() : 0; }

  TrapReg_t   GetRegByAddress(Int_t address) const;

  Bool_t PrintTrapReg(TrapReg_t reg, Int_t det = -1, Int_t rob = -1, Int_t mcm = -1) const;
  Bool_t PrintTrapAddr(Int_t addr, Int_t det = -1, Int_t rob = -1, Int_t mcm = -1) const;

  void PrintMemDatx(ostream &os, Int_t addr) const;
  void PrintMemDatx(ostream &os, Int_t addr, Int_t det, Int_t rob, Int_t mcm) const;
  void PrintMemDatx(ostream &os, TrapReg_t reg) const;
  void PrintMemDatx(ostream &os, TrapReg_t reg, Int_t det, Int_t rob, Int_t mcm) const;
  void PrintDatx(ostream &os, UInt_t addr, UInt_t data, Int_t rob, Int_t mcm) const;

  static const Int_t fgkDmemStartAddress  = 0xc000; // start address in TRAP GIO
  static const Int_t fgkDmemWords = 0x400;          // number of words in DMEM

  static const Int_t fgkImemStartAddress = 0xe000;  // start address in TRAP GIO
  static const Int_t fgkImemWords = 0x1000;         // number of words in IMEM

  static const Int_t fgkDbankStartAddress = 0xf000; // start address in TRAP GIO
  static const Int_t fgkDbankWords = 0x0100;        // number of words in DBANK

 protected:
  void InitRegs();

  class AliTRDtrapValue : public TObject {
  public:
    AliTRDtrapValue();
    virtual ~AliTRDtrapValue() {}

    virtual Bool_t Allocate(Alloc_t mode);

  protected:
    Bool_t SetData(UInt_t value);
    Bool_t SetData(UInt_t value, Int_t det);
    Bool_t SetData(UInt_t value, Int_t det, Int_t rob, Int_t mcm);

    UInt_t GetData(Int_t det, Int_t rob, Int_t mcm) const;

    Int_t  GetIdx(Int_t det, Int_t rob, Int_t mcm) const;

  private:
    AliTRDtrapValue(const AliTRDtrapValue &rhs); // not implemented
    AliTRDtrapValue& operator=(const AliTRDtrapValue &rhs); // not implemented

    Alloc_t  fAllocMode;	// allocation mode
    Int_t    fSize;		// array size
    UInt_t  *fData;		//[fSize] data array
    Bool_t  *fValid;		//[fSize] valid flag

    static const Int_t fgkSize[kAllocLast]; // required array dimension for different allocation modes

    ClassDef(AliTRDtrapValue, 1);
  };

  class AliTRDtrapRegister : public AliTRDtrapValue {
  public:
    AliTRDtrapRegister();
    virtual ~AliTRDtrapRegister();

    void    Init(const char* name, Int_t addr, Int_t nBits, Int_t resetValue);
    void    Reset() { SetData(fResetValue); }

    Bool_t  SetValue(Int_t value, Int_t det) { return SetData(value, det); }
    Bool_t  SetValue(Int_t value, Int_t det, Int_t rob, Int_t mcm) { return SetData(value, det, rob, mcm); }

    Int_t   GetValue(Int_t det, Int_t rob, Int_t mcm) const { return GetData(det, rob, mcm); }

    const char*  GetName() const { return fName.Data(); }
    UShort_t GetAddr() const { return fAddr; }
    UShort_t GetNbits() const { return fNbits; }
    UInt_t   GetResetValue() const { return fResetValue; }

  protected:
    AliTRDtrapRegister(const AliTRDtrapRegister &rhs);
    AliTRDtrapRegister& operator=(const AliTRDtrapRegister &rhs);

    // fixed properties of the register
    // which do not need to be stored
    TString   fName;            //! Name of the register
    UShort_t  fAddr;            //! Address in GIO of TRAP
    UShort_t  fNbits;           //! Number of bits, from 1 to 32
    UInt_t    fResetValue;      //! reset value

    ClassDef(AliTRDtrapRegister, 1);
  };

  class AliTRDtrapDmemWord : public AliTRDtrapValue {
  public:
    AliTRDtrapDmemWord() : AliTRDtrapValue(), fName(""), fAddr(0) {}
    virtual ~AliTRDtrapDmemWord() {}

    void    Reset() { SetData(0); }

    Bool_t  SetValue(UInt_t value, Int_t det) { return SetData(value, det); }
    Bool_t  SetValue(UInt_t value, Int_t det, Int_t rob, Int_t mcm) { return SetData(value, det, rob, mcm); }

    UInt_t  GetValue(Int_t det, Int_t rob, Int_t mcm) const { return GetData(det, rob, mcm); }

    void    SetAddress(UShort_t addr) { fAddr = addr; fName.Form("DMEM 0x%04x", fAddr); }
    const char* GetName() const { return fName.Data(); }

  protected:
    AliTRDtrapDmemWord(const AliTRDtrapDmemWord &rhs); // not implemented
    AliTRDtrapDmemWord& operator=(const AliTRDtrapDmemWord &rhs); // not implemented

    TString  fName;
    UShort_t fAddr;		//! address

    ClassDef(AliTRDtrapDmemWord, 1);
  };

  // configuration registers
  AliTRDtrapRegister fRegisterValue[kLastReg];  // array of TRAP register values in use

  // DMEM
  AliTRDtrapDmemWord fDmem[fgkDmemWords]; // TRAP data memory

  static const Int_t fgkMaxMcm;            // max. no. of MCMs to be treated
  static const Int_t fgkMcmlistSize=256;     // list of MCMs to which a value has to be written

  static Bool_t    fgRegAddressMapInitialized;
  static TrapReg_t fgRegAddressMap[0x400 + 0x200 + 0x3];
  static const Int_t fgkRegisterAddressBlockStart[];
  static const Int_t fgkRegisterAddressBlockSize[];

 private:
  AliTRDtrapConfig& operator=(const AliTRDtrapConfig &rhs); // not implemented
  AliTRDtrapConfig(const AliTRDtrapConfig& cfg); // not implemented

  ClassDef(AliTRDtrapConfig, 3);
};

#endif
Commit	Line	Data
ce4786b9	1	#ifndef ALITRDTRAPCONFIG_H
ce4786b9	2	#define ALITRDTRAPCONFIG_H
36dc3337	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
2b2b540f	6	// Configuration of the TRD TRAcklet Processor
2b2b540f	7	// (TRD Front-End Electronics)
5f006bd7	8	//
2b2b540f	9	// TRAP registers
2b2b540f	10	// TRAP data memory (DMEM)
ce4786b9	11
ce4786b9	12	#include <TObject.h>
2b2b540f	13	#include <TNamed.h>
ce4786b9	14	#include <TString.h>
8ea391e3	15	#include <fstream>
ce4786b9	16
2b2b540f	17	class AliTRDtrapConfig : public TNamed
ce4786b9	18	{
ce4786b9	19	public:
2b2b540f	20	AliTRDtrapConfig(const TString &name = "", const TString &title = "");
5f006bd7	21	~AliTRDtrapConfig();
051af255	22
2b2b540f	23	// allocation
	24	enum Alloc_t {
	25	kAllocNone,
	26	kAllocGlobal,
	27	kAllocByDetector,
	28	kAllocByHC,
	29	kAllocByMCM,
	30	kAllocByMergerType,
	31	kAllocByLayer,
	32	kAllocByMCMinSM,
	33	kAllocLast
	34	}; // possible granularities for allocation
	35	// common to registers and DMEM
	36
	37	// registers
5f006bd7	38	enum TrapReg_t { kSML0,
5f006bd7	39	kSML1,
ce4786b9	40	kSML2,
ce4786b9	41	kSMMODE,
2b2b540f	42	kSMCMD,
ce4786b9	43	kNITM0,
	44	kNITM1,
	45	kNITM2,
	46	kNIP4D,
	47	kCPU0CLK,
	48	kCPU1CLK,
	49	kCPU2CLK,
	50	kCPU3CLK,
	51	kNICLK,
	52	kFILCLK,
	53	kPRECLK,
	54	kADCEN,
	55	kNIODE,
	56	kNIOCE,
	57	kNIIDE,
	58	kNIICE,
5f006bd7	59	kARBTIM,
	60	kIA0IRQ0,
	61	kIA0IRQ1,
	62	kIA0IRQ2,
	63	kIA0IRQ3,
	64	kIA0IRQ4,
	65	kIA0IRQ5,
	66	kIA0IRQ6,
	67	kIA0IRQ7,
	68	kIA0IRQ8,
	69	kIA0IRQ9,
	70	kIA0IRQA,
	71	kIA0IRQB,
	72	kIA0IRQC,
	73	kIRQSW0,
	74	kIRQHW0,
	75	kIRQHL0,
	76	kIA1IRQ0,
	77	kIA1IRQ1,
	78	kIA1IRQ2,
	79	kIA1IRQ3,
	80	kIA1IRQ4,
	81	kIA1IRQ5,
	82	kIA1IRQ6,
	83	kIA1IRQ7,
	84	kIA1IRQ8,
	85	kIA1IRQ9,
	86	kIA1IRQA,
	87	kIA1IRQB,
	88	kIA1IRQC,
	89	kIRQSW1,
	90	kIRQHW1,
	91	kIRQHL1,
	92	kIA2IRQ0,
	93	kIA2IRQ1,
	94	kIA2IRQ2,
	95	kIA2IRQ3,
	96	kIA2IRQ4,
	97	kIA2IRQ5,
	98	kIA2IRQ6,
	99	kIA2IRQ7,
	100	kIA2IRQ8,
	101	kIA2IRQ9,
	102	kIA2IRQA,
	103	kIA2IRQB,
	104	kIA2IRQC,
	105	kIRQSW2,
	106	kIRQHW2,
	107	kIRQHL2,
	108	kIA3IRQ0,
	109	kIA3IRQ1,
	110	kIA3IRQ2,
	111	kIA3IRQ3,
	112	kIA3IRQ4,
	113	kIA3IRQ5,
	114	kIA3IRQ6,
	115	kIA3IRQ7,
	116	kIA3IRQ8,
	117	kIA3IRQ9,
	118	kIA3IRQA,
	119	kIA3IRQB,
	120	kIA3IRQC,
	121	kIRQSW3,
	122	kIRQHW3,
123	kIRQHL3,
124	kCTGDINI,
125	kCTGCTRL,
126	kC08CPU0,
127	kC09CPU0,
128	kC10CPU0,
129	kC11CPU0,
130	kC12CPUA,
131	kC13CPUA,
132	kC14CPUA,
133	kC15CPUA,
134	kC08CPU1,
135	kC09CPU1,
136	kC10CPU1,
137	kC11CPU1,
138	kC08CPU2,
139	kC09CPU2,
140	kC10CPU2,
141	kC11CPU2,
142	kC08CPU3,
143	kC09CPU3,
144	kC10CPU3,
145	kC11CPU3,
146	kNMOD,
147	kNDLY,
148	kNED,
149	kNTRO,
150	kNRRO,
151	kNES,
152	kNTP,
153	kNBND,
154	kNP0,
155	kNP1,
156	kNP2,
157	kNP3,
158	kNCUT,
159	kTPPT0,
160	kTPFS,
161	kTPFE,
162	kTPPGR,
163	kTPPAE,
164	kTPQS0,
165	kTPQE0,
166	kTPQS1,
167	kTPQE1,
168	kEBD,
169	kEBAQA,
170	kEBSIA,
171	kEBSF,
172	kEBSIM,
173	kEBPP,
174	kEBPC,
175	kEBIS,
176	kEBIT,
177	kEBIL,
178	kEBIN,
179	kFLBY,
180	kFPBY,
181	kFGBY,
182	kFTBY,
183	kFCBY,
184	kFPTC,
185	kFPNP,
186	kFPCL,
187	kFGTA,
188	kFGTB,
189	kFGCL,
190	kFTAL,
191	kFTLL,
192	kFTLS,
193	kFCW1,
194	kFCW2,
195	kFCW3,
196	kFCW4,
197	kFCW5,
198	kTPFP,
199	kTPHT,
200	kTPVT,
201	kTPVBY,
202	kTPCT,
203	kTPCL,
204	kTPCBY,
205	kTPD,
206	kTPCI0,
207	kTPCI1,
208	kTPCI2,
209	kTPCI3,
210	kADCMSK,
211	kADCINB,
212	kADCDAC,
213	kADCPAR,
214	kADCTST,
215	kSADCAZ,
216	kFGF0,
217	kFGF1,
218	kFGF2,
219	kFGF3,
220	kFGF4,
221	kFGF5,
222	kFGF6,
223	kFGF7,
224	kFGF8,
225	kFGF9,
226	kFGF10,
227	kFGF11,
228	kFGF12,
229	kFGF13,
230	kFGF14,
231	kFGF15,
232	kFGF16,
233	kFGF17,
234	kFGF18,
235	kFGF19,
236	kFGF20,
237	kFGA0,
238	kFGA1,
239	kFGA2,
240	kFGA3,
241	kFGA4,
242	kFGA5,
243	kFGA6,
244	kFGA7,
245	kFGA8,
246	kFGA9,
247	kFGA10,
248	kFGA11,
249	kFGA12,
250	kFGA13,
251	kFGA14,
252	kFGA15,
253	kFGA16,
254	kFGA17,
255	kFGA18,
256	kFGA19,
257	kFGA20,
258	kFLL00,
259	kFLL01,
260	kFLL02,
261	kFLL03,
262	kFLL04,
263	kFLL05,
264	kFLL06,
265	kFLL07,
266	kFLL08,
267	kFLL09,
268	kFLL0A,
269	kFLL0B,
270	kFLL0C,
271	kFLL0D,
272	kFLL0E,
273	kFLL0F,
274	kFLL10,
275	kFLL11,
276	kFLL12,
277	kFLL13,
278	kFLL14,
279	kFLL15,
280	kFLL16,
281	kFLL17,
282	kFLL18,
283	kFLL19,
284	kFLL1A,
285	kFLL1B,
286	kFLL1C,
287	kFLL1D,
288	kFLL1E,
289	kFLL1F,
290	kFLL20,
291	kFLL21,
292	kFLL22,
293	kFLL23,
294	kFLL24,
295	kFLL25,
296	kFLL26,
297	kFLL27,
298	kFLL28,
299	kFLL29,
300	kFLL2A,
301	kFLL2B,
302	kFLL2C,
303	kFLL2D,
304	kFLL2E,
305	kFLL2F,
306	kFLL30,
307	kFLL31,
308	kFLL32,
309	kFLL33,
310	kFLL34,
311	kFLL35,
312	kFLL36,
313	kFLL37,
314	kFLL38,
315	kFLL39,
316	kFLL3A,
317	kFLL3B,
318	kFLL3C,
319	kFLL3D,
320	kFLL3E,
321	kFLL3F,
322	kPASADEL,
323	kPASAPHA,
324	kPASAPRA,
325	kPASADAC,
326	kPASACHM,
327	kPASASTL,
328	kPASAPR1,
329	kPASAPR0,
330	kSADCTRG,
331	kSADCRUN,
332	kSADCPWR,
333	kL0TSIM,
334	kSADCEC,
335	kSADCMC,
336	kSADCOC,
337	kSADCGTB,
338	kSEBDEN,
339	kSEBDOU,
340	kTPL00,
341	kTPL01,
342	kTPL02,
343	kTPL03,
344	kTPL04,
345	kTPL05,
346	kTPL06,
347	kTPL07,
348	kTPL08,
349	kTPL09,
350	kTPL0A,
351	kTPL0B,
352	kTPL0C,
353	kTPL0D,
354	kTPL0E,
355	kTPL0F,
356	kTPL10,
357	kTPL11,
358	kTPL12,
359	kTPL13,
360	kTPL14,
361	kTPL15,
362	kTPL16,
363	kTPL17,
364	kTPL18,
365	kTPL19,
366	kTPL1A,
367	kTPL1B,
368	kTPL1C,
369	kTPL1D,
370	kTPL1E,
371	kTPL1F,
372	kTPL20,
373	kTPL21,
374	kTPL22,
375	kTPL23,
376	kTPL24,
377	kTPL25,
378	kTPL26,
379	kTPL27,
380	kTPL28,
381	kTPL29,
382	kTPL2A,
383	kTPL2B,
384	kTPL2C,
385	kTPL2D,
386	kTPL2E,
387	kTPL2F,
388	kTPL30,
389	kTPL31,
390	kTPL32,
391	kTPL33,
392	kTPL34,
393	kTPL35,
394	kTPL36,
395	kTPL37,
396	kTPL38,
397	kTPL39,
398	kTPL3A,
399	kTPL3B,
400	kTPL3C,
401	kTPL3D,
402	kTPL3E,
403	kTPL3F,
404	kTPL40,
405	kTPL41,
406	kTPL42,
407	kTPL43,
408	kTPL44,
409	kTPL45,
410	kTPL46,
411	kTPL47,
412	kTPL48,
413	kTPL49,
414	kTPL4A,
415	kTPL4B,
416	kTPL4C,
417	kTPL4D,
418	kTPL4E,
419	kTPL4F,
420	kTPL50,
421	kTPL51,
422	kTPL52,
423	kTPL53,
424	kTPL54,
425	kTPL55,
426	kTPL56,
427	kTPL57,
428	kTPL58,
429	kTPL59,
430	kTPL5A,
431	kTPL5B,
432	kTPL5C,
433	kTPL5D,
434	kTPL5E,
435	kTPL5F,
436	kTPL60,
437	kTPL61,
438	kTPL62,
439	kTPL63,
440	kTPL64,
441	kTPL65,
442	kTPL66,
443	kTPL67,
444	kTPL68,
445	kTPL69,
446	kTPL6A,
447	kTPL6B,
448	kTPL6C,
449	kTPL6D,
450	kTPL6E,
451	kTPL6F,
452	kTPL70,
453	kTPL71,
454	kTPL72,
455	kTPL73,
456	kTPL74,
457	kTPL75,
458	kTPL76,
459	kTPL77,
460	kTPL78,
461	kTPL79,
462	kTPL7A,
463	kTPL7B,
464	kTPL7C,
465	kTPL7D,
466	kTPL7E,
467	kTPL7F,
468	kMEMRW,
469	kMEMCOR,
470	kDMDELA,
471	kDMDELS,
ce4786b9	472	kLastReg }; // enum of all TRAP registers, to be used for access to them
ce4786b9	473
2b2b540f	474	Bool_t SetTrapRegAlloc(TrapReg_t reg, Alloc_t mode) { return fRegisterValue[reg].Allocate(mode); }
ce4786b9	475	Bool_t SetTrapReg(TrapReg_t reg, Int_t value, Int_t det);
	476	Bool_t SetTrapReg(TrapReg_t reg, Int_t value, Int_t det, Int_t rob, Int_t mcm);
	477
2b2b540f	478	Int_t GetTrapReg(TrapReg_t reg, Int_t det = -1, Int_t rob = -1, Int_t mcm = -1) const;
ce4786b9	479
ce4786b9	480	void ResetRegs();
ce4786b9	481
2b2b540f	482	// data memory (DMEM)
	483	Bool_t SetDmemAlloc(Int_t addr, Alloc_t mode);
	484	Bool_t SetDmem(Int_t addr, UInt_t value, Int_t det);
051af255	485	Bool_t SetDmem(Int_t addr, UInt_t value, Int_t det, Int_t rob, Int_t mcm);
051af255	486	Bool_t SetDmem(Int_t addr, Int_t value) { return SetDmem(addr, (UInt_t) value); }
051af255	487	Bool_t SetDmem(Int_t addr, Int_t value, Int_t det, Int_t rob, Int_t mcm) { return SetDmem(addr, (UInt_t) value, det, rob, mcm); }
ce4786b9	488
8ea391e3	489	UInt_t GetDmemUnsigned(Int_t addr, Int_t det, Int_t rob, Int_t mcm) const;
8ea391e3	490
2b2b540f	491	void ResetDmem();
	492
	493	// access by 16-bit address
	494	UInt_t Peek(Int_t addr, Int_t det, Int_t rob, Int_t mcm) const;
	495	Bool_t Poke(Int_t addr, UInt_t value, Int_t det, Int_t rob, Int_t mcm);
	496
	497	// helper methods
	498	const char* GetRegName(TrapReg_t reg) const { return ((reg >= 0) && (reg < kLastReg)) ? fRegisterValue[reg].GetName() : ""; }
	499	UShort_t GetRegAddress(TrapReg_t reg) const { return ((reg >= 0) && (reg < kLastReg)) ? fRegisterValue[reg].GetAddr() : 0; }
	500	UShort_t GetRegNBits(TrapReg_t reg) const { return ((reg >= 0) && (reg < kLastReg)) ? fRegisterValue[reg].GetNbits() : 0; }
	501	UInt_t GetRegResetValue(TrapReg_t reg) const { return ((reg >= 0) && (reg < kLastReg)) ? fRegisterValue[reg].GetResetValue() : 0; }
	502
	503	TrapReg_t GetRegByAddress(Int_t address) const;
	504
	505	Bool_t PrintTrapReg(TrapReg_t reg, Int_t det = -1, Int_t rob = -1, Int_t mcm = -1) const;
	506	Bool_t PrintTrapAddr(Int_t addr, Int_t det = -1, Int_t rob = -1, Int_t mcm = -1) const;
	507
8ea391e3	508	void PrintMemDatx(ostream &os, Int_t addr) const;
	509	void PrintMemDatx(ostream &os, Int_t addr, Int_t det, Int_t rob, Int_t mcm) const;
	510	void PrintMemDatx(ostream &os, TrapReg_t reg) const;
	511	void PrintMemDatx(ostream &os, TrapReg_t reg, Int_t det, Int_t rob, Int_t mcm) const;
	512	void PrintDatx(ostream &os, UInt_t addr, UInt_t data, Int_t rob, Int_t mcm) const;
5f006bd7	513
2b2b540f	514	static const Int_t fgkDmemStartAddress = 0xc000; // start address in TRAP GIO
2b2b540f	515	static const Int_t fgkDmemWords = 0x400; // number of words in DMEM
ce4786b9	516
2b2b540f	517	static const Int_t fgkImemStartAddress = 0xe000; // start address in TRAP GIO
2b2b540f	518	static const Int_t fgkImemWords = 0x1000; // number of words in IMEM
ce4786b9	519
2b2b540f	520	static const Int_t fgkDbankStartAddress = 0xf000; // start address in TRAP GIO
2b2b540f	521	static const Int_t fgkDbankWords = 0x0100; // number of words in DBANK
5f006bd7	522
2b2b540f	523	protected:
2b2b540f	524	void InitRegs();
5f006bd7	525
2b2b540f	526	class AliTRDtrapValue : public TObject {
	527	public:
	528	AliTRDtrapValue();
	529	virtual ~AliTRDtrapValue() {}
051af255	530
2b2b540f	531	virtual Bool_t Allocate(Alloc_t mode);
051af255	532
2b2b540f	533	protected:
3df58e28	534	Bool_t SetData(UInt_t value);
	535	Bool_t SetData(UInt_t value, Int_t det);
	536	Bool_t SetData(UInt_t value, Int_t det, Int_t rob, Int_t mcm);
8ea391e3	537
3df58e28	538	UInt_t GetData(Int_t det, Int_t rob, Int_t mcm) const;
2b2b540f	539
	540	Int_t GetIdx(Int_t det, Int_t rob, Int_t mcm) const;
	541
	542	private:
	543	AliTRDtrapValue(const AliTRDtrapValue &rhs); // not implemented
	544	AliTRDtrapValue& operator=(const AliTRDtrapValue &rhs); // not implemented
	545
	546	Alloc_t fAllocMode; // allocation mode
	547	Int_t fSize; // array size
	548	UInt_t *fData; //[fSize] data array
	549	Bool_t *fValid; //[fSize] valid flag
ce4786b9	550
2b2b540f	551	static const Int_t fgkSize[kAllocLast]; // required array dimension for different allocation modes
	552
	553	ClassDef(AliTRDtrapValue, 1);
ce4786b9	554	};
ce4786b9	555
2b2b540f	556	class AliTRDtrapRegister : public AliTRDtrapValue {
	557	public:
	558	AliTRDtrapRegister();
	559	virtual ~AliTRDtrapRegister();
ce4786b9	560
2b2b540f	561	void Init(const char* name, Int_t addr, Int_t nBits, Int_t resetValue);
2b2b540f	562	void Reset() { SetData(fResetValue); }
ce4786b9	563
2b2b540f	564	Bool_t SetValue(Int_t value, Int_t det) { return SetData(value, det); }
	565	Bool_t SetValue(Int_t value, Int_t det, Int_t rob, Int_t mcm) { return SetData(value, det, rob, mcm); }
	566
	567	Int_t GetValue(Int_t det, Int_t rob, Int_t mcm) const { return GetData(det, rob, mcm); }
	568
	569	const char* GetName() const { return fName.Data(); }
	570	UShort_t GetAddr() const { return fAddr; }
	571	UShort_t GetNbits() const { return fNbits; }
	572	UInt_t GetResetValue() const { return fResetValue; }
	573
	574	protected:
	575	AliTRDtrapRegister(const AliTRDtrapRegister &rhs);
	576	AliTRDtrapRegister& operator=(const AliTRDtrapRegister &rhs);
	577
	578	// fixed properties of the register
	579	// which do not need to be stored
	580	TString fName; //! Name of the register
	581	UShort_t fAddr; //! Address in GIO of TRAP
	582	UShort_t fNbits; //! Number of bits, from 1 to 32
	583	UInt_t fResetValue; //! reset value
	584
	585	ClassDef(AliTRDtrapRegister, 1);
ce4786b9	586	};
ce4786b9	587
2b2b540f	588	class AliTRDtrapDmemWord : public AliTRDtrapValue {
	589	public:
	590	AliTRDtrapDmemWord() : AliTRDtrapValue(), fName(""), fAddr(0) {}
	591	virtual ~AliTRDtrapDmemWord() {}
	592
	593	void Reset() { SetData(0); }
	594
	595	Bool_t SetValue(UInt_t value, Int_t det) { return SetData(value, det); }
	596	Bool_t SetValue(UInt_t value, Int_t det, Int_t rob, Int_t mcm) { return SetData(value, det, rob, mcm); }
	597
	598	UInt_t GetValue(Int_t det, Int_t rob, Int_t mcm) const { return GetData(det, rob, mcm); }
	599
	600	void SetAddress(UShort_t addr) { fAddr = addr; fName.Form("DMEM 0x%04x", fAddr); }
	601	const char* GetName() const { return fName.Data(); }
	602
	603	protected:
	604	AliTRDtrapDmemWord(const AliTRDtrapDmemWord &rhs); // not implemented
	605	AliTRDtrapDmemWord& operator=(const AliTRDtrapDmemWord &rhs); // not implemented
	606
	607	TString fName;
	608	UShort_t fAddr; //! address
	609
	610	ClassDef(AliTRDtrapDmemWord, 1);
ce4786b9	611	};
ce4786b9	612
2b2b540f	613	// configuration registers
2b2b540f	614	AliTRDtrapRegister fRegisterValue[kLastReg]; // array of TRAP register values in use
ce4786b9	615
2b2b540f	616	// DMEM
	617	AliTRDtrapDmemWord fDmem[fgkDmemWords]; // TRAP data memory
	618
	619	static const Int_t fgkMaxMcm; // max. no. of MCMs to be treated
	620	static const Int_t fgkMcmlistSize=256; // list of MCMs to which a value has to be written
	621
	622	static Bool_t fgRegAddressMapInitialized;
	623	static TrapReg_t fgRegAddressMap[0x400 + 0x200 + 0x3];
	624	static const Int_t fgkRegisterAddressBlockStart[];
	625	static const Int_t fgkRegisterAddressBlockSize[];
36dc3337	626
	627	private:
	628	AliTRDtrapConfig& operator=(const AliTRDtrapConfig &rhs); // not implemented
	629	AliTRDtrapConfig(const AliTRDtrapConfig& cfg); // not implemented
	630
2b2b540f	631	ClassDef(AliTRDtrapConfig, 3);
ce4786b9	632	};
	633
	634	#endif