FlxCard.h

/******************************************************************* 
 * \mainpage                                                       * 
 *                                                                 * 
 * @author: Markus Joos, CERN                                      *
 *  Maintainer: Henk Boterenbrood, Nikhef                          * 
 *                                                                 *
 * @brief                                                          *
 * This note defines an application program interface (API) for    *
 * the use of the FLX PCIe I/O card in the ATLAS read-out system.  *
 * The intention of the API is to satisfy the needs of simple      *
 * test programs as well as the requirements of the                *
 * FelixApplication.                                               *
 *                                                                 *
 * @copyright CERN, Nikhef                                         *
 ******************************************************************/ 
 
#ifndef FLXCARD_H
#define FLXCARD_H
 
#include <cstdint>
#include <vector>
#include <string>
#include <sys/types.h>
#include <utility> // std::pair
 
#include "cmem_rcc/cmem_rcc.h"
#include "flxcard/flx_common.h"
#include "regmap/regmap.h"
#include "flxcard/LinkConfig.h"
 
// Constants
#define NUM_INTERRUPTS                    8
#define FLX_GBT_FILE_NOT_FOUND            -1
#define FLX_GBT_VERSION_NOT_FOUND         -2
#define FLX_GBT_TMODE_FEC                 0
#define FLX_GBT_ALIGNMENT_CONTINUOUS      0
#define FLX_DMA_WRAPAROUND                1
#define FLX_GBT_ALIGNMENT_ONE             1
#define FLX_GBT_CHANNEL_AUTO              1
#define FLX_GBT_TMODE_WideBus             1
 
// Firmware types
#define FIRMW_GBT                         0
#define FIRMW_FULL                        1
#define FIRMW_LTDB                        2
#define FIRMW_FEI4                        3
#define FIRMW_PIXEL                       4
#define FIRMW_STRIP                       5
#define FIRMW_FELIG_GBT                   6
#define FIRMW_FELIG                       6 // Backwards compatible
#define FIRMW_FMEMU                       7
#define FIRMW_MROD                        8
#define FIRMW_LPGBT                       9
#define FIRMW_INTERLAKEN                  10
#define FIRMW_FELIG_LPGBT                 11
#define FIRMW_HGTD_LUMI                   12
#define FIRMW_BCM_PRIME                   13
#define FIRMW_FELIG_PIXEL                 14
#define FIRMW_FELIG_STRIP                 15
#define FIRMW_WUPPER                      16
#define FIRMW_TPX4                        17
const std::vector<std::string> FIRMW_STR{ "GBT",   "FULL",  "LTDB",   "FEI4", "PIXEL",
                                          "STRIP", "FELIG", "FM-EMU", "MROD", "LPGBT",
                                          "INTERLAKEN", "FELIG-LPGBT", "HGTD-LUMI",
                                          "BCM-PRIME",  "FELIG-PIXEL", "FELIG-STRIP",
                                          "WUPPER", "TPX4" };
 
// Interrupts
#define ALL_IRQS                          0xFFFFFFFF
 
// Monitoring devices
#define FPGA_MONITOR                      0x001
#define POD_MONITOR_ALL                   0x002
#define POWER_MONITOR                     0x004
#define FIREFLY_MONITOR                   0x008
#define POD_MONITOR_LOS                   0x100
#define POD_MONITOR_TEMP_VOLT             0x200
#define POD_MONITOR_POWER                 0x400
#define POD_MONITOR_POWER_RX              0x800
// (Backwards compatability)
#define POD_MONITOR                       POD_MONITOR_ALL
 
// Resource locking
#define LOCK_NONE                         0x0000
#define LOCK_DMA0                         0x0001
#define LOCK_DMA1                         0x0002
#define LOCK_I2C                          0x0004
#define LOCK_FLASH                        0x0008
#define LOCK_ELINK                        0x0010
#define LOCK_READ_CONFIG                  0x0020
#define LOCK_ALL                          0xFFFFFFFF
#define LOCK_DMA(n)                       (1<<(16+n))
 
// Other constants
#define ALL_BITS                          0xFFFFFFFFFFFFFFFF
 
// Register model
typedef struct
{
  volatile u_long start_address;        /*  low half, bits  63:00 */
  volatile u_long end_address;          /*  low half, bits 127:64 */
  volatile u_long tlp         :11;      /* high half, bits  10:00 */
  volatile u_long fromhost    : 1;      /* high half, bit      11 */
  volatile u_long wrap_around : 1;      /* high half, bit      12 */
  volatile u_long reserved    :51;      /* high half, bits  63:13 */
  volatile u_long sw_pointer;           /* high half, bits 127:64 */
} dma_descriptor_t;
 
typedef struct
{
  volatile u_long fw_pointer;           /* bits  63:00 */
  volatile u_long descriptor_done : 1;  /* bit      64 */
  volatile u_long even_addr_dma   : 1;  /* bit      65 */
  volatile u_long even_addr_pc    : 1;  /* bit      66 */
} dma_status_t;
 
typedef struct
{
  volatile u_int  control;              /* bits  63:00 */
  volatile u_int  data;                 /* bits  95:64 */
  volatile u_long address;              /* bits 127:96 */
} int_vec_t;
 
typedef struct
{
  volatile u_long date_time : 40;       /* bits  39:00 */
  volatile u_long reserved  : 24;       /* bits  63:40 */
  volatile u_long revision  : 16;       /* bits  79:64 */
} board_id_t;
 
typedef struct
{
  dma_descriptor_t DMA_DESC[8];         /* 0x000 - 0x0ff */
  u_char           unused1[256];        /* 0x100 - 0x1ff */
  dma_status_t     DMA_DESC_STATUS[8];  /* 0x200 - 0x27f */
  u_char           unused2[128];        /* 0x280 - 0x2ff */
  volatile u_int   BAR0_VALUE;          /* 0x300 - 0x303 */
  u_char           unused3[12];         /* 0x304 - 0x30f */
  volatile u_int   BAR1_VALUE;          /* 0x310 - 0x313 */
  u_char           unused4[12];         /* 0x314 - 0x31f */
  volatile u_int   BAR2_VALUE;          /* 0x320 - 0x323 */
  u_char           unused5[220];        /* 0x324 - 0x3ff */
  volatile u_int   DMA_DESC_ENABLE;     /* 0x400 - 0x403 */
  u_char           unused7[28];         /* 0x404 - 0x41f */
  volatile u_int   DMA_RESET;           /* 0x420 - 0x423 */
  u_char           unused8[12];         /* 0x424 - 0x42f */
  volatile u_int   SOFT_RESET;          /* 0x430 - 0x433 */
  u_char           unused9[12];         /* 0x434 - 0x43f */
  volatile u_int   REGISTERS_RESET;     /* 0x440 - 0x443 */
} flxcard_bar0_regs_t;
 
typedef struct
{
  int_vec_t        INT_VEC[8];          /* 0x000 - 0x07f */
  u_char           unused1[128];        /* 0x080 - 0x0ff */
  volatile u_int   INT_TAB_ENABLE;      /* 0x100 - 0x103 */
} flxcard_bar1_regs_t;
 
typedef struct
{
  u_int n_devices;
  u_int cdmap[MAXCARDS][2];
} device_list_t;
 
// Forward declaration (see I2CDevices.h)
typedef struct i2c_device i2c_device_t;
 
// Device parameters typedefs
 
typedef struct
{
  float  temperature;
  float  vccint;
  float  vccaux;
  float  vccbram;
  u_long fanspeed;
  u_long dna;
} fpga_parameters_t;
 
typedef struct
{
  bool  absent;
  char  name[10];
  int   temp;
  float v33;
  float v25;
  int   los;
  char  vname[16];
  char  voui[3];
  char  vpnum[16];
  char  vrev[2];
  char  vsernum[16];
  char  vdate[8];
  int   optical_power_uw[12];
} minipod_parameters_t;
 
typedef struct
{
  std::string name;
  float vccint_current;
  float vccint_voltage;
  float mgtavcc_current;
  float mgtavcc_voltage;
  float fpga_internal_diode_temperature;
  float mgtavtt_current;         // Only FLX-712
  float mgtavtt_voltage;         // Only FLX-712
  float mgtavttc_voltage;        // Only FLX-711
  float mgtvccaux_voltage;       // Only FLX-711
  float internal_temperature;
  float vcc;
} ltc2991_1_parameters_t;
 
typedef struct
{
  std::string name;
  float pex0p9v_current;
  float pex0p9v_voltage;
  float sys18_current;
  float sys18_voltage;
  float sys12_voltage;           // Only FLX-711
  float sys25_current;           // Only FLX-712 
  float sys25_voltage;
  float pex8732_internal_diode_temperature;
  float internal_temperature;
  float vcc;
} ltc2991_2_parameters_t;
 
typedef struct
{
  std::string name;
  uint32_t t_local_hi;  // In degrees C
  uint32_t t_local_lo;  // In 1/10000ths C
  uint32_t t_remote_hi; // In degrees C
  uint32_t t_remote_lo; // In 1/10000ths C
  uint32_t status;
  uint32_t device_id;
  uint32_t manufacturer_id;
} tmp435_parameters_t;
 
typedef struct
{
  std::string name;
  uint32_t    config_reg;
  uint32_t    shunt_volt_reg;
  uint32_t    bus_volt_reg;
  uint32_t    power_reg;
  uint32_t    current_reg;
  uint32_t    calib_reg;
  uint32_t    manufacturer_id;
  float       r_shunt;
} ina226_parameters_t;
 
typedef struct
{
  std::string name;
  uint32_t    mfr_special_id;
  uint32_t    vin;
  uint32_t    iin;
  uint32_t    pin;
  uint32_t    vout[2];
  uint32_t    iout[2];
  uint32_t    pout[2];
  uint32_t    temp_die;
  uint32_t    temp_ext[2];
} ltm4700_parameters_t;
 
typedef struct
{
  std::string name;
  bool        valid;
  uint32_t    manufacturer_id;
  uint32_t    silicon_rev;
  uint8_t     input_cfg[10][8];
  uint32_t    fault_stat[6];
  uint32_t    adc[12];
  float       adc_fullscale[12];
  std::string adc_name[12];
} adm1066_parameters_t;
 
typedef struct
{
  std::string name;
  bool        valid;
  uint32_t    ic_device_id;
  uint64_t    ic_device_rev;
  uint32_t    vout[17];
  uint32_t    vout_mode[17];
  uint32_t    status_vout[17];
  std::string vout_name[17];
  uint32_t    vout_uv_warn[17];
  uint32_t    vout_uv_fault[17];
  uint32_t    vout_ov_warn[17];
  uint32_t    vout_ov_fault[17];
} adm1266_parameters_t;
 
class FireFlyTxParams
{
public:
  std::string name;
  bool absent;
 
  // FireFly TX lower memory map
  uint32_t status;
  uint32_t status_summ;
  uint32_t latched_alarms_tx_los;
  uint32_t latched_alarms_tx_fault;
  uint32_t latched_alarms_temp;
  uint32_t latched_alarms_vcc33;
  uint32_t latched_alarms_cdr_lol;
  int32_t  case_temp;
  uint32_t vcc;
  uint32_t elapsed_optime;
  uint32_t chan_disable;
  uint32_t squelch_disable;
  uint32_t polarity_invert;
  uint64_t input_equalization;
  uint32_t cdr_enable;
  uint32_t mask_tx_los_alarms;
  uint32_t mask_fault_flags;
  uint32_t mask_temp_alarms;
  uint32_t mask_vcc33_alarms;
  uint32_t mask_cdr_lol_alarms;
  uint32_t firmware_version;
 
  // Upper page 0
  std::string vendor_part;
  std::string vendor_serial;
};
 
class FireFlyRxParams
{
public:
  std::string name;
  bool absent;
 
  // FireFly RX lower memory map
  uint32_t status;
  uint32_t status_summ;
  uint32_t latched_alarms_rx_los;
  uint32_t latched_alarms_rx_power;
  uint32_t latched_alarms_temp;
  uint32_t latched_alarms_vcc33;
  uint32_t latched_alarms_cdr_lol;
  int32_t  case_temp;
  uint32_t vcc;
  uint32_t elapsed_optime;
  uint32_t chan_disable;
  uint32_t output_disable;
  uint32_t polarity_invert;
  uint64_t output_swing;
  uint64_t output_preemphasis;
  uint32_t cdr_enable;
  uint32_t firmware_version;
 
  // Upper page 0
  std::string vendor_part;
  std::string vendor_serial;
 
  // Upper page 1
  uint32_t optical_power[12];
};
 
class FireFlyTxRxParams
{
public:
  std::string name;
  bool absent;
 
  // FireFly TX/RX lower memory map
  uint32_t status;
  uint32_t latched_alarms_tx_los;
  uint32_t latched_alarms_tx_fault;
  uint32_t latched_alarms_cdr_lol;
  uint32_t latched_alarms_temp;
  uint32_t latched_alarms_vcc;
  uint32_t latched_alarms_rx_power;
  uint32_t elapsed_optime;
  int32_t  case_temp;
  uint32_t vcc_3v3;
  uint32_t vcc_1v8;
  uint32_t rx_optical_power[4];
  uint32_t firmware_revision;
  uint32_t tx_chan_disable;
  uint32_t cdr_enable;
  uint32_t cdr_rate_select;
  uint32_t mask_los_alarms;
  uint32_t mask_tx_fault_flags;
  uint32_t mask_cdr_lol_alarms;
  uint32_t mask_temp_alarms;
  uint32_t mask_vcc_alarms;
 
  // Upper page 0;
  std::string vendor_part;
  std::string vendor_serial;
};
 
// Device monitoring data collections typedefs
 
typedef fpga_parameters_t fpga_monitoring_t;
 
typedef struct
{
  ltc2991_1_parameters_t  ltc2991_1;
  ltc2991_2_parameters_t  ltc2991_2;
} ltc_monitoring_t;
 
typedef struct
{
  ina226_parameters_t  ina226[10+1]; // +1 for FLX-155
} ina_monitoring_t;
 
typedef struct
{
  tmp435_parameters_t  tmp435[7+1];  // +1 for FLX-155
} tmp_monitoring_t;
 
typedef ltm4700_parameters_t ltm_monitoring_t;
 
typedef struct
{
  adm1066_parameters_t  adm1066[2];
  adm1266_parameters_t  adm1266;
} adm_monitoring_t;
 
class FireFlyMonitorData
{
public:
  FireFlyTxParams   ffly_tx[2+2]; // +2 for FLX-155
  FireFlyRxParams   ffly_rx[2+2]; // +2 for FLX-155
  FireFlyTxRxParams ffly_tr[1+1]; // +1 for FLX-155
};
 
typedef struct
{
  minipod_parameters_t  minipod[8];
} minipod_monitoring_t;
 
typedef struct
{
  fpga_monitoring_t     fpga;
  ltc_monitoring_t      ltc;
  ina_monitoring_t      ina;
  ltm_monitoring_t      ltm;
  tmp_monitoring_t      tmp;
  adm_monitoring_t      adm;
  minipod_monitoring_t  pod;
  FireFlyMonitorData    firefly;
} monitoring_data_t;
 
// Macros
#define TOHEX(n) std::hex << "0x" << ((uint64_t)n) << std::dec
 
class FlxCard
{
public:
    FlxCard();
 
    ~FlxCard();
 
    void card_open( int device_nr, u_int lock_mask,
                    bool read_config = false,
                    bool ignore_version = false );
    
    void card_close();
    
    static u_int number_of_cards();
    
    static u_int number_of_devices();
 
    static device_list_t device_list();
 
    static int card_to_device_number( int card_number );
 
    u_int lock_mask( int device_nr );
    u_int get_lock_mask( int device_nr ) { return lock_mask( device_nr ); } // Backwards-compatibility
    
    u_long openBackDoor( int bar );
    u_long bar0Address() { return openBackDoor( 0 ); }
    u_long bar1Address() { return openBackDoor( 1 ); }
    u_long bar2Address() { return openBackDoor( 2 ); }
    int  dma_max_tlp_bytes() { return m_maxTlpBytes; }
    
    void dma_to_host( u_int dma_id, u_long dst, size_t size, u_int flags );
    
    void dma_from_host( u_int dma_id, u_long src, size_t size, u_int flags );
    
    bool dma_enabled( u_int dma_id );
 
    void dma_wait( u_int dma_id );
    
    void dma_stop( u_int dma_id );
    
    void dma_advance_ptr( u_int dma_id, u_long dst, size_t size, size_t bytes );
    
    void dma_set_ptr( u_int dma_id, u_long dst );
    
    u_long dma_get_ptr( u_int dma_id );
    /* For backwards compatibility: */
    u_long dma_get_read_ptr( u_int dma_id ) { return dma_get_ptr( dma_id ); }
    
    // Sets the DMA_FIFO_FLUSH register to "1".
    //void dma_fifo_flush();  //MJ: disabled. See FlxCard.cpp
    
    void dma_reset();
    
    u_long dma_get_fw_ptr( u_int dma_id );
    /* For backwards compatibility: */
    u_long dma_get_current_address( u_int dma_id ) { return dma_get_fw_ptr( dma_id ); }
    
    bool dma_cmp_even_bits( u_int dma_id );
 
    void i2c_read( const char *device_str, u_char reg_addr, u_char *value, int nbytes = 1 );
    
    void i2c_write( const char *device_str, u_char reg_addr, u_char data );
    void i2c_write( const char *device_str, u_char reg_addr, u_char *data, int nbytes );
 
    void i2c_write_byte( u_char dev_addr, u_char byte );
    
    void i2c_write_byte( u_char dev_addr, u_char reg_addr, u_char byte );
    
    u_char i2c_read_byte( u_char dev_addr, u_char reg_addr );
    
    bool i2c_flush( u_int *count = 0 );
 
    void i2c_write_bytes( uint8_t dev_addr, uint8_t reg_addr,
                          int nbytes, uint8_t *bytes );
    void i2c_read_bytes ( uint8_t dev_addr, uint8_t reg_addr,
                          int nbytes, uint8_t *bytes );
 
    u_int gbt_setup( int alignment, int channel_mode );
    
    long int gbt_version_delay( u_long svn_version, char *filename );
    
    u_long rxusrclk_freq( u_int channel );
    
    void gth_rx_reset( int quad = -1 );
 
    void irq_enable( u_int interrupt = ALL_IRQS );
    
    void irq_disable( u_int interrupt = ALL_IRQS );
    
    void irq_wait( u_int interrupt );
    
    void irq_clear( u_int interrupt = ALL_IRQS );
    
    void irq_cancel( u_int interrupt = ALL_IRQS );
    
    void irq_reset_counters( u_int interrupt = ALL_IRQS );
    
    u_long cfg_get_option( const char *key, bool show_options = false );
    
    void cfg_set_option( const char *key, u_long value, bool show_options = false );
    
    u_long cfg_get_reg( const char *key );
 
    void cfg_set_reg( const char *key, u_long value );
    
    void registers_reset();
 
    static regmap_register_t *cfg_register( const char *name );
    static regmap_bitfield_t *cfg_bitfield( const char *name );
    static std::string cfg_bitfield_options( const char *name, bool include_all_substr = true );
 
    u_int card_model() { return m_cardType; }
    u_int card_type() { return card_model(); }
 
    u_int firmware_type() { return m_firmwareType; }
 
    std::string firmware_type_string()
      { return( m_firmwareType<FIRMW_STR.size() ? FIRMW_STR[m_firmwareType] : std::string("????") ); }
 
    std::string firmware_string() { return m_firmwareString; }
 
    bool lpgbt_type() { return m_lpgbtType; }
 
    bool lpgbt_fec12() { return m_lpgbtFec12; }
 
    bool lpgbt_5gbps() { return m_lpgbt5Gbps; }
 
    bool fullmode_type() { return m_fullmodeType; }
 
    void soft_reset();
    
    void cr_fromhost_reset();
 
    u_int number_of_channels() { return m_numberOfChans; }
 
    std::pair<int,int> ec_elink_indices();
 
    std::pair<int,int> ic_elink_indices();
 
    fpga_monitoring_t     fpga_monitoring();
    ltc_monitoring_t      power_monitoring_ltc2991();
    ina_monitoring_t      power_monitoring_ina226( int *ina_count = 0 );
    tmp_monitoring_t      temperature_monitoring_tmp435( int *tmp_count = 0 );
    ltm_monitoring_t      power_monitoring_ltm4700();
    adm_monitoring_t      powersequencer_monitoring_adm1x66( int *adm_count = 0 );
    minipod_monitoring_t  minipod_monitoring( u_int selection, int *number_of_pods = 0 );
    FireFlyMonitorData    firefly_monitoring( int *tx_count = 0, int *rx_count = 0, int *tr_count = 0 );
 
    monitoring_data_t get_monitoring_data( u_int mon_mask );
 
    float fpga_temperature();
 
    int fpga_fanspeed();
    
    std::vector<int> minipods_temperature();
 
    std::vector<std::pair<std::string, std::vector<int>>> minipods_optical_power();
 
    std::vector<std::pair<std::string, std::vector<int>>> firefly_optical_power();
 
    bool firefly_detect( const std::string &device_name,
                         std::string &vendor_part,
                         std::string &vendor_sn );
 
    void configure( std::string filename, bool do_links = true, bool do_registers = true );
 
    void readConfiguration( std::string filename );
 
    void readConfiguration();
 
    u_int number_of_elinks_tohost( int dma_index = -1 );
 
    u_int number_of_elinks_toflx();
    u_int number_of_elinks_fromhost() { return number_of_elinks_toflx(); }
 
    std::vector<flxcard::elink_descr_t> elinks_tohost( int dma_index = -1 );
 
    std::vector<flxcard::elink_descr_t> elinks_toflx();
    std::vector<flxcard::elink_descr_t> elinks_fromhost() { return elinks_toflx(); }
 
    std::vector<flxcard::elink_descr_t> elinks_toflx_broadcast();
    std::vector<flxcard::elink_descr_t> elinks_fromhost_broadcast() { return elinks_toflx_broadcast(); }
 
    u_int number_of_dma_tohost() { return m_numberOfDma; }
 
    bool uses_dma_index_mask() { return m_useDmaIndexMask; }
 
    void set_hdlc_instant_timeout( bool b ) { m_hdlcInstantTimeout = b; }
    bool hdlc_instant_timeout( ) { return m_hdlcInstantTimeout; }
 
    unsigned int link_mode();
 
    bool is_elink_enabled( u_int channel, u_int egroup, u_int epath, bool is_to_flx );
 
    unsigned int tohost_elink_dmaid( u_int channel, u_int egroup, u_int epath );
 
    unsigned int tohost_elink_dmaid( uint16_t elinknr );
 
    bool has_tohost_elink_streams( u_int channel, u_int egroup, u_int epath );
 
    uint8_t detector_id();
 
    uint16_t connector_id( uint16_t channel );
 
private:
    static int  m_cardsOpen;
    int         m_fd;
    int         m_deviceNumber;
    int         m_maxTlpBytes;
    u_int       m_cardType;
    u_int       m_firmwareType;
    bool        m_configRead;
    bool        m_lpgbtType;
    bool        m_lpgbtFec12;
    bool        m_lpgbt5Gbps;
    bool        m_fullmodeType;
    bool        m_useDmaIndexMask;
    bool        m_hdlcInstantTimeout;
    u_int       m_numberOfChans;
    u_int       m_numberOfDma;
    u_int       m_fromHostDataFormat;
    std::string m_firmwareString;
    u_int       m_myLocks;
    u_int       m_myLockTag;  //MJ: do we still need the lock tag??
    u_long      m_bar0Base;
    u_long      m_bar1Base;
    u_long      m_bar2Base;
 
    // Space to store a device's e-link configuration, for all links + Emulator 'link'
    flxcard::LinkConfig m_linkConfig[flxcard::FLX_LINKS + 1];
 
    // Space to store additional register settings
    std::vector<flxcard::regsetting_t> m_regSettings;
 
public:
    volatile flxcard_bar0_regs_t *m_bar0;
    volatile flxcard_bar1_regs_t *m_bar1;
    volatile flxcard_bar2_regs_t *m_bar2;
 
    // Pointer to a list of this FLX device's I2C devices
    i2c_device_t const *m_i2cDevices;
 
private:    
    u_long map_memory_bar( u_long pci_addr, size_t size );
    void   unmap_memory_bar( u_long vaddr, size_t size );
 
    void   i2c_wait_not_full( );
    void   i2c_wait_not_empty( );
    int    i2c_parse_address_string( const char *str,
                                     u_char *port1, u_char *port2, u_char *port3,
                                     u_char *dev_addr );
    void   i2c_set_switches( u_char switch1_val, u_char switch2_val, u_char switch3_val );
 
    void   gbt_tx_configuration( int channel_tx_mode, int alignment );
    int    gbt_rx_configuration( int channel_rx_mode );
    int    gbt_software_alignment( int number_channels );
    bool   gbt_channel_alignment( u_int channel );
    void   gbt_topbot_oddeven_set( u_int channel, u_int topbot, u_int oddeven );
    bool   gbt_topbot_alignment( u_int channel, u_int topbot,
                                 u_long *phase_found, u_int *oddeven );
    u_long gbt_shift_phase( u_int channel );
 
    int    check_digic_value2( const char *str, u_long *version, u_long *delay );
 
    std::string lockbits2string( u_int locks );
 
    void configureLinks( flxcard::LinkConfig *link_config,
                         int *dma_index_invalid_count,
                         int *unsupported_tohost_elinks_count,
                         int *unsupported_fromhost_elinks_count );
 
    void lockForConfiguration( FlxCard &flx );
};
 
#endif // FLXCARD_H