GBTWord.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
#ifndef ALICEO2_ITSMFT_GBTWORD_H
#define ALICEO2_ITSMFT_GBTWORD_H
 
// \file GBTWord.h
// \brief Classes for creation/interpretation of ITS/MFT GBT data
 
#include <Rtypes.h>
#include <cstdint>
 
namespace o2
{
namespace itsmft
{
 
constexpr uint64_t LANESMask = (0x1 << 28) - 1; // at most 28 lanes
 
constexpr uint8_t GBTFlagDataHeader = 0xe0;
constexpr uint8_t GBTFlagDataTrailer = 0xf0;
constexpr uint8_t GBTFlagTrigger = 0xe8;
constexpr uint8_t GBTFlagDiagnostic = 0xe4;
constexpr uint8_t GBTFlagCalibration = 0xf8;
 
// GBT header flag in the RDH
constexpr uint8_t GBTFlagRDH = 0x00;
// GBT header flag for the ITS IB: 001 bbbbb with bbbbb -> Lane Number (0-8)
constexpr uint8_t GBTFlagDataIB = 0x20;
// GBT header flag for the ITS OB: 010 bb ccc with bb -> Connector Number (00,01,10,11), ccc -> Lane Number (0-6)
constexpr uint8_t GBTFlagDataOB = 0x40;
// GBT header flag for the MFT
constexpr uint8_t GBTFlagDataMFT = 0x80;
// GBT header flag for the ITS IB idagnostic : 101 bbbbb with bbbbb -> Lane Number (0-8)
constexpr uint8_t GBTFlagDiagnosticIB = 0xa0;
// GBT header flag for the ITS OB diagnostic word: 110 bb ccc with bb -> Connector Number (00,01,10,11), ccc -> Lane Number (0-6)
constexpr uint8_t GBTFlagDiagnosticOB = 0x60;
 
// GBT header flag for the ITS Status word : 111 bbbbb with bbbbb -> Lane Number
constexpr uint8_t GBTFlagStatus = 0xe0;
 
constexpr int GBTWordLength = 10;       // lentgh in bytes
constexpr int GBTPaddedWordLength = 16; // lentgh in bytes with padding
 
struct GBTWord {
  union {
    // RS: packing will be needed only if some of the members cross 64 bit boundary
    struct /*__attribute__((packed))*/ {
      uint64_t activeLanes : 28; 
      uint64_t na0hn : 36;       
      uint64_t na1hn : 8;        
      uint64_t id : 8;           
    };                           // HEADER NEW
 
    struct /*__attribute__((packed))*/ {
      uint64_t packetIdx : 16;    
      uint64_t activeLanesL : 28; 
      uint64_t na0h : 20;         
      uint64_t na1h : 8;          
      //      uint64_t id : 8;           /// 72:79  0xe0; Header Status Word (HSW) identifier
    }; // HEADER Legacy
 
    struct /*__attribute__((packed))*/ {
      uint64_t lanesStops : 28;         
      uint64_t lanesTimeout : 28;       
      uint64_t na1t : 8;                
      uint64_t packetDone : 1;          
      uint64_t transmissionTimeout : 1; 
      uint64_t packetOverflow : 1;      
      uint64_t laneStartsViolation : 1; 
      uint64_t laneTimeouts : 1;        
      uint64_t na2t : 3;                
      //  uint8_t  id : 8;                /// = 0xf0; Trailer Status Word (TSW) identifier
    }; // TRAILER
 
    struct /*__attribute__((packed))*/ {
      uint64_t triggerType : 12; 
      uint64_t internal : 1;     
      uint64_t noData : 1;       
      uint64_t continuation : 1; 
      uint64_t na1tr : 1;        
      uint64_t bc : 12;          
      uint64_t na2tr : 4;        
      uint64_t orbit : 32;       
      uint64_t na3tr : 6;        
      //  uint8_t  id : 8;                /// = 0xc0; Trigger Status Word (TSW) identifier
    }; // TRIGGER
 
    struct /*__attribute__((packed))*/ {
      uint64_t na0diag : 64; 
      //      uint64_t id : 8;           /// 72:79  0xe4; diagnostic word identifier
    }; // HEADER Legacy
 
    struct __attribute__((packed)) {
      uint64_t calibUserField : 48; 
      uint64_t calibCounter : 24;   
      //  uint64_t id : 8;            /// 72:79  0xf8; Calibration Status Word (HSW) identifier
    }; 
 
    struct {
      uint64_t diagnosticData : 64; 
      uint64_t laneErrorID : 8;     
      //      uint64_t id : 8;           /// 72:79  0xe0;  Status Word (HSW) identifier
    }; // HEADER Legacy
 
    uint8_t data8[16]; // 80 bits GBT word + optional padding to 128 bits
    uint64_t data64[2] = {0};
  };
 
  GBTWord() = default;
 
  bool isDataHeader() const { return id == GBTFlagDataHeader; }
 
  bool isDataTrailer() const { return id == GBTFlagDataTrailer; }
 
  bool isTriggerWord() const { return id == GBTFlagTrigger; }
 
  bool isDiagnosticWord() const { return id == GBTFlagDiagnostic; }
 
  bool isCalibrationWord() const { return id == GBTFlagCalibration; }
 
  bool isDataIB() const { return (id & 0xe0) == GBTFlagDataIB; }
 
  bool isCableDiagnosticIB() const { return (id & 0xe0) == GBTFlagDiagnosticIB; }
 
  bool isDataOB() const { return (id & 0xe0) == GBTFlagDataOB; }
 
  bool isDataMFT() const { return (id & 0xe0) == GBTFlagDataMFT; }
 
  bool isCableDiagnosticOB() const { return (id & 0xe0) == GBTFlagDiagnosticIB; }
 
  bool isData() const { return isDataIB() || isDataOB() || isDataMFT(); }
 
  bool isCableDiagnostic() const { return isCableDiagnosticIB() || isCableDiagnosticIB(); }
 
  bool isStatus() const { return (id & 0xe0) == GBTFlagStatus; }
 
  const uint64_t* getW64() const { return data64; }
  const uint8_t* getW8() const { return data8; }
 
  uint8_t getHeader() const { return id; }
 
  void printX(bool padded = true, std::string com = "") const;
  void printB(bool padded = true) const;
 
  ClassDefNV(GBTWord, 1);
};
 
struct GBTDataHeader : public GBTWord {
 
  GBTDataHeader() { id = GBTFlagDataHeader; }
  GBTDataHeader(uint32_t lanes)
  {
    id = GBTFlagDataHeader;
    activeLanes = lanes;
  }
  ClassDefNV(GBTDataHeader, 1);
};
 
struct GBTDataHeaderL : public GBTWord { // legacy version
 
  GBTDataHeaderL() { id = GBTFlagDataHeader; }
  GBTDataHeaderL(int packetID, uint32_t lanes)
  {
    id = GBTFlagDataHeader;
    activeLanesL = lanes;
    packetIdx = packetID;
  }
  ClassDefNV(GBTDataHeaderL, 1);
};
 
struct GBTDataTrailer : public GBTWord {
  enum PacketStates : int {
    PacketDone = 0,                              // Packet finished
    TransmissionTimeout = 1,                     // if timeout of transmission (lanes)
    PacketOverflow = 2,                          // if max number of packets reached
    LaneStartsViolation = 3,                     // if at least 1 lane had a start violation
    LaneTimeouts = 4,                            // if at least 1 lane timed out
    NStatesDefined,                              // total number of states defined
    MaxStateCombinations = 0x1 << NStatesDefined // number of possible combinations
  };
 
  GBTDataTrailer() { id = GBTFlagDataTrailer; }
  GBTDataTrailer(int lanesStop, int lanesTimeOut, bool done, bool transmTO, bool overflow, bool laneStViol, bool laneTO)
  {
    lanesStops = lanesStop;
    lanesTimeout = lanesTimeOut;
    packetDone = done;
    transmissionTimeout = transmTO;
    packetOverflow = overflow;
    laneStartsViolation = laneStViol;
    laneTimeouts = laneTO;
    id = GBTFlagDataTrailer;
  }
 
  uint8_t getPacketState() const { return data8[8] & (MaxStateCombinations - 1); }
 
  void setByte(uint8_t v, int which) = delete;
 
  ClassDefNV(GBTDataTrailer, 1);
};
 
struct GBTTrigger : public GBTWord {
 
  GBTTrigger() { id = GBTFlagTrigger; }
  void setByte(uint8_t v, int which) = delete;
 
  ClassDefNV(GBTTrigger, 1);
};
 
struct GBTData : public GBTWord {
 public:
  static int getLaneIB(uint8_t v) { return v & 0x1f; }
  static int getConnectorOB(uint8_t v) { return (v & 0x18) >> 3; } // lane only
  static int getLaneOB(uint8_t v) { return v & 0x7; }              // connector only
  static int getLaneOB(uint8_t v, int& connector)
  { // separately lane and connector
    connector = getConnectorOB(v);
    return getLaneOB(v);
  }
  static int getCableID(uint8_t v) { return v & 0x1f; } // combined connector and lane
 
  int getLaneIB() const { return getLaneIB(id); }
  int getConnectorOB() const { return getConnectorOB(id); }                // lane only
  int getLaneOB() const { return getLaneOB(id); }                          // connector only
  int getLaneOB(int& connector) const { return getLaneOB(id, connector); } // separately lane and connector
  int getCableID() const { return getCableID(id); }                        // combined connector and lane
 
  ClassDefNV(GBTData, 1);
};
 
struct GBTDiagnostic : public GBTWord {
 
  GBTDiagnostic() { id = GBTFlagDiagnostic; }
  ClassDefNV(GBTDiagnostic, 1);
};
 
struct GBTCableDiagnostic : public GBTWord {
 
  GBTCableDiagnostic(bool ib = true, int lane = 0) { id = (ib ? GBTFlagDiagnosticIB : GBTFlagDiagnosticOB) | (lane & 0x1f); }
  int getCableID() const { return id & 0x1f; } // combined connector and lane
  bool isIB() const { return (id & 0xe0) == GBTFlagDiagnosticIB; }
  bool isOB() const { return (id & 0xe0) == GBTFlagDiagnosticOB; }
  ClassDefNV(GBTCableDiagnostic, 1);
};
 
struct GBTCableStatus : public GBTWord { // not sure this is correct, FIXME
 
  GBTCableStatus(int lane = 0) { id = GBTFlagStatus | (lane & 0x1f); }
  int getCableID() const { return id & 0x1f; } // combined connector and lane
  ClassDefNV(GBTCableStatus, 1);
};
 
struct GBTCalibration : public GBTWord { // calibration data word
 
  GBTCalibration() { id = GBTFlagCalibration; }
  GBTCalibration(uint64_t userData, uint16_t counter = 0)
  {
    id = GBTFlagCalibration;
    calibUserField = userData & ((0x1UL << 48) - 1);
    calibCounter = counter & ((0x1 << 24) - 1);
  }
  ClassDefNV(GBTCalibration, 1);
};
 
} // namespace itsmft
} // namespace o2
 
#endif