{ *************************************************************************** }
MODULE mod_handle_scalers ;
{  Created   7-JUL-1989   MICHIGAN STATE UNIVERSITY, TRIGGER CONTROL SOFTWARE }
{ *************************************************************************** }
INCLUDE
  mod_handle_tracing,
  mod_common_global_flags,
  mod_def_hardware_tables,
  mod_handle_registers,
  mod_common_hard_io,                 {from the TRICS hardware IO library     }
  mod_tcs_io_scaler_handling ;        {from the TRICS hardware IO library     }
{ *************************************************************************** }
EXPORT
  load_sbscalers    {PROCEDURE load all sbsc cards in the framework           }
  read_dbscaler,    {PROCEDURE read a double buffer scaler                    }
  read_sbscalers,   {PROCEDURE read all single buffer scalers on a sbsc card  }
  reset_dbscaler,   {PROCEDURE reset a double buffer scaler                   }
  reset_sbscaler ;  {PROCEDURE reset a single buffer scaler                   }
{ *************************************************************************** }
IMPORT
  status_type, ok, {already_done,} io_failure,
                                      {from module MOD_COMMON_GLOBAL_FLAGS    }

  trace_info, trace_warn, trace_error,{from module MOD_HANDLE_TRACING         }
  inline_tracing,                     {from module MOD_HANDLE_TRACING         }
  io_tracing,{db_tracing,}ON,         {from module MOD_HANDLE_TRACING         }
  handle_trc_inf,                     {from module MOD_HANDLE_TRACING         }
  handle_trc_wrn,                     {from module MOD_HANDLE_TRACING         }
  handle_trc_err,                     {from module MOD_HANDLE_TRACING         }

 {reg_singularities, reg_class,}      {from module MOD_DEF_HARDWARE_TABLES    }
    histdep, multidef, multir,{multiw, dobbuf, ronly, aux_class1, aux_class2, }
  cbus_register, card_header,         {from module MOD_DEF_HARDWARE_TABLES    }
  mtgfwtss,                           {from module MOD_DEF_HARDWARE_TABLES    }
  tss_fw_sbsc_load,                   {from module MOD_DEF_HARDWARE_TABLES    }

  update_register,                    {from module MOD_HANDLE_REGISTERS       }

  cbus_param_list,                    {from module MOD_COMMON_HARD_IO         }

  proced_tcs_read_dbscaler,           {from module MOD_TCS_IO_CBUS_HANDLING   }
  proced_tcs_read_sbscalers ;         {from module MOD_TCS_IO_CBUS_HANDLING   }

{ *************************************************************************** }
{ *************************************************************************** }

TYPE

  byte = [BYTE]   0..255   ;
  s_array (m,n:INTEGER) = ARRAY [m..n] OF INTEGER ;

{ *************************************************************************** }
{ *************************************************************************** }
PROCEDURE load_sbscalers ( tagext : VARYING_STRING(8) := '' ;
                            iopar :^cbus_param_list ;
                       VAR status :[OPTIONAL] status_type ) ;

VAR
  io_status : status_type ;
BEGIN

  IF PRESENT(status) THEN status := ok ;

  update_register ( TAGEXT := tagext,
                      CARD := ADDRESS(mtgfwtss),
                  REGISTER := ADDRESS(mtgfwtss.channelreg[tss_fw_sbsc_load]),
                     IOPAR := iopar,
                      DATA := 25,
                    STATUS := io_status ) ;

  IF ( io_status = io_failure )
  THEN BEGIN
    IF PRESENT(status) THEN status := io_failure ;
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := 'HIO/CBS%'+tagext,
                      MESSAGE := ' Failure Globally Loading all SBSC Cards ' );
  END ;

  update_register ( TAGEXT := tagext,
                      CARD := ADDRESS(mtgfwtss),
                  REGISTER := ADDRESS(mtgfwtss.channelreg[tss_fw_sbsc_load]),
                     IOPAR := iopar,
                      DATA := 9,
                    STATUS := io_status ) ;

END ;
{ *************************************************************************** }
{ *************************************************************************** }
PROCEDURE read_dbscaler ( tagext : VARYING_STRING(8) := '' ;
                            card :^ANYTYPE ;
                        register :^cbus_register ; {appropriate reset register}
                           iopar :^cbus_param_list ;
                      VAR scaler :[OPTIONAL] LARGE_INTEGER ;
                      VAR status :[OPTIONAL] status_type ) ;

 TYPE

  large_int_by_byte =
  PACKED RECORD
    byte : PACKED ARRAY [0..7] OF byte ;
  END ;

VAR
  generic_card :^card_header ;
  io_status    : status_type ;
  temp         : large_int_by_byte ;

BEGIN

  generic_card::BYTE_DATA := card::BYTE_DATA ;
  IF PRESENT(status) THEN status := ok ;

  { *** retrieve the card's hardware parameters                               }
  iopar^.cbus    := generic_card^.cbus ;
  iopar^.mba     := generic_card^.mba ;
  iopar^.ca      := generic_card^.ca ;
  iopar^.fa      := register^.fa + 128 ;

  IF ( io_tracing = ON )
  THEN IF ( inline_tracing(trace_info) <> 0 )
  THEN handle_trc_inf ( TAG := 'HIO/CBS%' + tagext,
                    MESSAGE := ' Reading dbl Buffered Scaler '
                             + ' @ cbus' + CONVERT(STRING(2),iopar^.cbus)
                             + ' mba' + CONVERT(STRING(4),iopar^.mba)
                             + ' ca' + CONVERT(STRING(3),iopar^.ca)
                             + ' fa' + CONVERT(STRING(4),iopar^.fa) ) ;

  IF ( inline_tracing(trace_error) <> 0 )
  THEN IF ( register^.class <> [ histdep, multidef ] )
  THEN BEGIN
    IF PRESENT(status) THEN status := io_failure ;
    handle_trc_err ( TAG := 'HIO/HDB%' + tagext,
                 MESSAGE := ' Not a db Scaler Reset Reg '
                          + ' @ cbus' + CONVERT(STRING(2),iopar^.cbus)
                          + ' mba' + CONVERT(STRING(4),iopar^.mba)
                          + ' ca' + CONVERT(STRING(3),iopar^.ca)
                          + ' fa' + CONVERT(STRING(4),iopar^.fa) ) ;
  END ;

  proced_tcs_read_dbscaler ( PARAM := iopar, STATUS := io_status ) ;

  IF PRESENT(scaler) 
  THEN BEGIN
    temp         := ZERO ;
    temp.byte[0] := iopar^.a_dbsc[1] ;
    temp.byte[1] := iopar^.a_dbsc[2] ;
    temp.byte[2] := iopar^.a_dbsc[3] ;
    temp.byte[3] := iopar^.a_dbsc[4] ;
    temp.byte[4] := iopar^.a_dbsc[5] ;
    scaler       := temp::LARGE_INTEGER ;
  END ;

  IF ( io_status = io_failure )
  THEN BEGIN
    IF PRESENT(status) THEN status := io_failure ;
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := 'HIO/CBS%' + tagext,
                      MESSAGE := ' Failure Reading db Scaler '
                               + ' @ cbus' + CONVERT(STRING(2),iopar^.cbus)
                               + ' mba' + CONVERT(STRING(4),iopar^.mba)
                               + ' ca' + CONVERT(STRING(3),iopar^.ca)
                               + ' fa' + CONVERT(STRING(4),iopar^.fa) ) ;
  END ;

END ;
{ *************************************************************************** }
{ *************************************************************************** }
PROCEDURE read_sbscalers ( tagext : VARYING_STRING(8) := '' ;
                             card :^ANYTYPE ;
                         register :^cbus_register ; { address of data register }
                            iopar :^cbus_param_list ;
                          scalers :^s_array(0,31) := NIL ;
                           loaded : BOOLEAN := FALSE ;
                       VAR status :[OPTIONAL] status_type ) ;

TYPE

  integer_by_byte = [LONG]
  PACKED RECORD
    bytefield : ARRAY [1..4] OF byte ;
  END ;

VAR

  generic_card :^card_header ;
  temp_int     : integer_by_byte ;
  scalernum    : INTEGER ;
  bytenum      : INTEGER ;

BEGIN

  generic_card::BYTE_DATA := card::BYTE_DATA ;
  IF PRESENT(status) THEN status := ok ;

  { *** retrieve the card's hardware parameters                               }
  iopar^.cbus    := generic_card^.cbus ;
  iopar^.mba     := generic_card^.mba ;
  iopar^.ca      := generic_card^.ca ;
  iopar^.fa      := register^.fa ; {fa not used in io but in error message}

  IF ( io_tracing = ON )
  THEN IF ( inline_tracing(trace_info) <> 0 )
  THEN handle_trc_inf ( TAG := 'HIO/CBS%' + tagext,
                    MESSAGE := ' Reading Single Buffered Scalers '
                             + ' @ cbus' + CONVERT(STRING(2),iopar^.cbus)
                             + ' mba' + CONVERT(STRING(4),iopar^.mba)
                             + ' ca' + CONVERT(STRING(3),iopar^.ca) ) ;

  IF ( inline_tracing(trace_error) <> 0 )
  THEN IF ( register^.class <> [ multir ] )
  THEN BEGIN
    IF PRESENT(status) THEN status := io_failure ;
    handle_trc_err ( TAG := 'HIO/HDB%' + tagext,
                 MESSAGE := ' Not a SBSC Card Data Reg '
                          + ' @ cbus' + CONVERT(STRING(2),iopar^.cbus)
                          + ' mba' + CONVERT(STRING(4),iopar^.mba)
                          + ' ca' + CONVERT(STRING(3),iopar^.ca)
                          + ' fa' + CONVERT(STRING(4),iopar^.fa) ) ;
  END ;

  proced_tcs_read_sbscalers ( iopar, LOADED := loaded ) ;

  IF ( scalers <> NIL )
  THEN BEGIN
    FOR scalernum := 0 TO 31
    DO BEGIN

      FOR bytenum := 1 TO 4
      DO temp_int.bytefield[bytenum] := iopar^.a_sbsc[bytenum,scalernum] ;

      scalers^[scalernum] := temp_int::INTEGER ;

    END ;
  END ;

END ;
{ *************************************************************************** }
{ *************************************************************************** }
PROCEDURE reset_dbscaler ( tagext : VARYING_STRING(8) := '' ;
                             card :^ANYTYPE ;
                         register :^cbus_register ;
                      check_reset : BOOLEAN := FALSE ;
                            iopar :^cbus_param_list ;
                       VAR status :[OPTIONAL] status_type ) ;

VAR
  generic_card :^card_header ;
  io_status : status_type ;
BEGIN

  generic_card::BYTE_DATA := card::BYTE_DATA ;
  IF PRESENT(status) THEN status := ok ;

  { *** retrieve the card's hardware parameters                               }
  iopar^.cbus    := generic_card^.cbus ; { not used in io but in tracing msgs }
  iopar^.mba     := generic_card^.mba ;  { not used in io but in tracing msgs }
  iopar^.ca      := generic_card^.ca ;   { not used in io but in tracing msgs }
  iopar^.fa      := register^.fa ;       { not used in io but in tracing msgs }

  IF ( io_tracing = ON )
  THEN IF ( inline_tracing(trace_info) <> 0 )
  THEN handle_trc_inf ( TAG := 'HIO/CBS%' + tagext,
                    MESSAGE := ' Resetting dbl Buf Scaler '
                             + ' @ cbus' + CONVERT(STRING(2),iopar^.cbus)
                             + ' mba' + CONVERT(STRING(4),iopar^.mba)
                             + ' ca' + CONVERT(STRING(3),iopar^.ca)
                             + ' fa' + CONVERT(STRING(4),iopar^.fa) ) ;

  IF ( io_tracing = ON )
  THEN IF ( inline_tracing(trace_warn) <> 0 )
  THEN BEGIN
    read_dbscaler ( TAGEXT := tagext,
                      CARD := card,
                  REGISTER := register,
                     IOPAR := iopar ) ;

    IF ( ( iopar^.a_dbsc[1] = 0 )
     AND ( iopar^.a_dbsc[2] = 0 )
     AND ( iopar^.a_dbsc[3] = 0 )
     AND ( iopar^.a_dbsc[4] = 0 )
     AND ( iopar^.a_dbsc[5] = 0 ) )
    THEN BEGIN
      handle_trc_wrn ( TAG := 'HIO/CBS%' + tagext,
                   MESSAGE := ' db Scaler Already Reset '
                            + ' @ cbus' + CONVERT(STRING(2),iopar^.cbus)
                            + ' mba' + CONVERT(STRING(4),iopar^.mba)
                            + ' ca' + CONVERT(STRING(3),iopar^.ca)
                            + ' fa' + CONVERT(STRING(3),iopar^.fa) ) ;
    END ;
  END ;

  update_register ( TAGEXT := tagext,
                      CARD := card,
                  REGISTER := register,
                      DATA := 5,
                     IOPAR := iopar,
                    STATUS := io_status ) ;

  IF ( check_reset = TRUE ) 
  THEN BEGIN
    read_dbscaler ( TAGEXT := tagext,
                      CARD := card,
                  REGISTER := register,
                    IOPAR := iopar ) ;
 
    IF ( ( iopar^.a_dbsc[1] <> 0 )
      OR ( iopar^.a_dbsc[2] <> 0 )
      OR ( iopar^.a_dbsc[3] <> 0 )
      OR ( iopar^.a_dbsc[4] <> 0 )
      OR ( iopar^.a_dbsc[5] <> 0 ) )
    THEN BEGIN
      IF ( inline_tracing(trace_warn) <> 0 )
      THEN handle_trc_wrn ( TAG := 'HIO/CBS%' + tagext,
                        MESSAGE := ' Cannot Guaranty db Scaler Reset '
                                 + ' @ cbus' + CONVERT(STRING(2),iopar^.cbus)
                                 + ' mba' + CONVERT(STRING(4),iopar^.mba)
                                 + ' ca' + CONVERT(STRING(3),iopar^.ca)
                                 + ' fa' + CONVERT(STRING(4),iopar^.fa) ) ;
    END 
    ELSE BEGIN
      IF ( inline_tracing(trace_info) <> 0 )
      THEN handle_trc_inf ( TAG := 'HIO/CBS%' + tagext,
                        MESSAGE := ' Reset db Scaler Verified '
                                 + ' @ cbus' + CONVERT(STRING(2),iopar^.cbus)
                                 + ' mba' + CONVERT(STRING(4),iopar^.mba)
                                 + ' ca' + CONVERT(STRING(3),iopar^.ca)
                                 + ' fa' + CONVERT(STRING(4),iopar^.fa) ) ;
    END ;
  END ;

END ;
{ *************************************************************************** }
{ *************************************************************************** }
PROCEDURE reset_sbscaler ( tagext : VARYING_STRING(8) := '' ;
                             card :^ANYTYPE ;
                         register :^cbus_register ; {address of data register }
                            iopar :^cbus_param_list ;
                           scaler : INTEGER ;
                      soft_enable : BOOLEAN := FALSE ;
                       VAR status :[OPTIONAL] status_type ) ;

VAR
  generic_card :^card_header ;
  ctrlreg, relbit,data : INTEGER ;
  io_status : status_type ;
BEGIN

  generic_card::BYTE_DATA := card::BYTE_DATA ;
  IF PRESENT(status) THEN status := ok ;

  { *** retrieve the card's hardware parameters                               }
  iopar^.cbus    := generic_card^.cbus ; { here not used in io but in msgs    }
  iopar^.mba     := generic_card^.mba ;  { here not used in io but in msgs    }
  iopar^.ca      := generic_card^.ca ;   { here not used in io but in msgs    }

  { *** compute the correct sb scaler control register and bit number         }
  ctrlreg        := scaler DIV 4 ;
  relbit         := 2 * (scaler MOD 4) + 1 ;
  { *** get ready reset only the requested scaler, enable external gate...    }
  data := generic_card^.register[ctrlreg].content ;
       IF ( relbit = 1 ) THEN data := byte_and(data,255-  2- 1)
  ELSE IF ( relbit = 3 ) THEN data := byte_and(data,255-  8- 4)
  ELSE IF ( relbit = 5 ) THEN data := byte_and(data,255- 32-16)
  ELSE IF ( relbit = 7 ) THEN data := byte_and(data,255-128-64) ;
  { *** ...or software enable if requested                                    }
  IF ( soft_enable = TRUE )
  THEN BEGIN
         IF ( relbit = 1 ) THEN data := data +   1
    ELSE IF ( relbit = 3 ) THEN data := data +   4
    ELSE IF ( relbit = 5 ) THEN data := data +  16
    ELSE IF ( relbit = 7 ) THEN data := data +  64 ;
  END ;

  IF ( io_tracing = ON )
  THEN IF ( inline_tracing(trace_info) <> 0 )
  THEN handle_trc_inf ( TAG := 'HIO/CBS%' + tagext,
                    MESSAGE := ' Resetting sgl Buf Scaler '
                             + ' @ cbus' + CONVERT(STRING(2),iopar^.cbus)
                             + ' mba' + CONVERT(STRING(4),iopar^.mba)
                             + ' ca' + CONVERT(STRING(3),iopar^.ca)
                             + ' scaler' + CONVERT(STRING(4),scaler) ) ;

  IF ( io_tracing = ON )
  THEN IF ( inline_tracing(trace_warn) <> 0 )
  THEN BEGIN
    read_sbscalers ( TAGEXT := tagext,
                       CARD := card,
                   REGISTER := ADDRESS(generic_card^.register[8]),
                      IOPAR := iopar ) ;

    IF ( ( iopar^.a_sbsc[1,scaler] = 0 )
     AND ( iopar^.a_sbsc[2,scaler] = 0 )
     AND ( iopar^.a_sbsc[3,scaler] = 0 )
     AND ( iopar^.a_sbsc[4,scaler] = 0 ) )
    THEN BEGIN
      handle_trc_wrn ( TAG := 'HIO/CBS%' + tagext,
                   MESSAGE := ' sb Scaler Already Reset '
                            + ' @ cbus' + CONVERT(STRING(2),iopar^.cbus)
                            + ' mba' + CONVERT(STRING(4),iopar^.mba)
                            + ' ca' + CONVERT(STRING(3),iopar^.ca)
                            + ' scaler' + CONVERT(STRING(4),scaler) ) ;
    END ;
  END ;

  update_register ( TAGEXT := tagext,
                      CARD := card,
                  REGISTER := ADDRESS(generic_card^.register[ctrlreg]),
                      DATA := data,
                     IOPAR := iopar,
                    STATUS := io_status ) ;

  read_sbscalers ( TAGEXT := tagext,
                     CARD := card,
                 REGISTER := register,
                    IOPAR := iopar ) ;

  IF ( ( iopar^.a_sbsc[1,scaler] <> 0 )
    OR ( iopar^.a_sbsc[2,scaler] <> 0 )
    OR ( iopar^.a_sbsc[3,scaler] <> 0 )
    OR ( iopar^.a_sbsc[4,scaler] <> 0 ) )
  THEN BEGIN
    IF PRESENT(status) THEN status := io_failure ;
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := 'HIO/CBS%' + tagext,
                      MESSAGE := ' Failure Resetting sb Scaler '
                               + ' @ cbus' + CONVERT(STRING(2),iopar^.cbus)
                               + ' mba' + CONVERT(STRING(4),iopar^.mba)
                               + ' ca' + CONVERT(STRING(3),iopar^.ca)
                               + ' scaler' + CONVERT(STRING(4),scaler) ) ;
  END ;

  { *** enable only the requested scaler                                      }
       IF ( relbit = 1 ) THEN data := data +   2
  ELSE IF ( relbit = 3 ) THEN data := data +   8
  ELSE IF ( relbit = 5 ) THEN data := data +  32
  ELSE IF ( relbit = 7 ) THEN data := data + 128 ;

  update_register ( TAGEXT := tagext,
                      CARD := card,
                  REGISTER := ADDRESS(generic_card^.register[ctrlreg]),
                      DATA := data,
                     IOPAR := iopar,
                    STATUS := io_status ) ;

  IF ( io_status = io_failure )
  THEN BEGIN
    IF PRESENT(status) THEN status := io_failure ;
    IF ( inline_tracing(trace_error) <> 0 )
    THEN handle_trc_err ( TAG := 'HIO/CBS%' + tagext,
                      MESSAGE := ' Failure Enabling sb Scaler '
                               + ' @ cbus' + CONVERT(STRING(2),iopar^.cbus)
                               + ' mba' + CONVERT(STRING(4),iopar^.mba)
                               + ' ca' + CONVERT(STRING(3),iopar^.ca)
                               + ' scaler' + CONVERT(STRING(4),scaler) ) ;
  END ;

END ;
{ *************************************************************************** }
{ *************************************************************************** }
FUNCTION byte_and ( op1 , op2 : byte ) : byte ;
VAR bool1, bool2, bool3 : BOOLEAN ;
BEGIN
  bool1::BYTE_DATA           := op1::BYTE_DATA ;
  bool2::BYTE_DATA           := op2::BYTE_DATA ;
  bool3                      := bool1 AND bool2 ;
  byte_and::BYTE_DATA := bool3::BYTE_DATA ;
END ;
{ *************************************************************************** }
{ *************************************************************************** }
END.
{ DEC/CMS REPLACEMENT HISTORY, Element MOD103_HANDLE_SCALERS.PAS}
{ *1    26-MAR-1990 09:02:52 TRIGGER "original loading of pascal source"}
{ DEC/CMS REPLACEMENT HISTORY, Element MOD103_HANDLE_SCALERS.PAS}