#-- $Id: sample.initfile,v 1.1 2011/07/13 16:03:44 andrewg Exp $
#-- CHANGE HISTORY:
#--------------------------------------------------------------------------------
#-- Version:|Author: | Date:  | Comment:
#-- --------|--------|--------|--------------------------------------------------
#--     0.01|andrewg |05/24/11|Created sample file
#-- --------|--------|--------|--------------------------------------------------
#--------------------------------------------------------------------------------
# End of revision history
#--------------------------------------------------------------------------------

#--Master list of variables that can be used in this file is at:
#--<Attribute Definition Location>

SyntaxVersion = 1

#-- -----------------------------------------------------------------------------
#--******************************************************************************
#-- -----------------------------------------------------------------------------
#--
#-- Includes
#-- Note:
#   Must specify the path to the .define file here; i.e. 
#      "include ./hwp/initfiles/sample.define"
#   Or specify the directories to search for the include file (-I <path to search>)
#   in priority order at the initCompiler command line; i.e.
#      "initCompiler -init ./sample.initfile -outdir . -attr ./fapiAttributeIds.H \
#      -I hwp/initfiles -I hwp"
#       
#-- -----------------------------------------------------------------------------
#--******************************************************************************
#-- -----------------------------------------------------------------------------
include sample.define

#-- -----------------------------------------------------------------------------
#--******************************************************************************
#-- -----------------------------------------------------------------------------
#--
#-- Defines
#--
#-- -----------------------------------------------------------------------------
#--******************************************************************************
#-- -----------------------------------------------------------------------------

define def_equal_test     =  (SYS.ATTR_SCRATCH_UINT32_1 == SYS.ATTR_SCRATCH_UINT32_2);
define def_not_equal_test =  (SYS.ATTR_SCRATCH_UINT64_1 != SYS.ATTR_SCRATCH_UINT64_2);

#-- -----------------------------------------------------------------------------
#--******************************************************************************
#-- -----------------------------------------------------------------------------
#--
#-- Defines for associated targets
#-- User can either use the generic target name TGTn within the initfile or
#-- define a more informative name to use here.
#-- By default attributes without the associated target name prefix or the "SYS."
#-- prefix is the primary target's attribute.  The targets must be passed to
#-- fapiHwpExecInitFile() as a std::vector<fapi::Target> with the elements in the
#-- same order as defined in the initfile; i.e. the primary target is the first
#-- element followed by TGT1, 2, 3...
#--
#-- -----------------------------------------------------------------------------
#--******************************************************************************
define MBA0 = TGT1;
define MBA1 = TGT2;

#--******************************************************************************
#-- Basic SCOM to PORE_GPE0_SCRATCH0_0x0006000A
#--******************************************************************************
scom 0x000000000006000A              {
  scom_data                 ;
  0x0ABBC00000000000        ;
}

#--******************************************************************************
#-- SCOM with Address and Data of Array Type, Range of Index, Bit Support to
#-- PORE_GPE0_SCRATCH1_0x0006000B and PORE_GPE0_SCRATCH2_0x0006000C
#-- The following Scom is equivalent to:
#scom 0x000000000006000B           {
#  bits, scom_data             ,              expr;
#  0:7,  SYS.ATTR_SCRATCH_UINT8_ARRAY_1[2],   SYS.ATTR_SCRATCH_UINT8_ARRAY_1[2] > SYS.ATTR_SCRATCH_UINT8_1;
#  24:31, SYS.ATTR_SCRATCH_UINT8_ARRAY_1[2],  SYS.ATTR_SCRATCH_UINT8_1 == SYS.ATTR_SCRATCH_UINT8_ARRAY_1[3];
#  32:39, SYS.ATTR_SCRATCH_UINT8_ARRAY_2[0][1][2], SYS.ATTR_SCRATCH_UINT8_ARRAY_1[0] < SYS.ATTR_SCRATCH_UINT8_ARRAY_1[1];
#}
#
#scom 0x000000000006000C           {
#  bits, scom_data             ,              expr;
#  0:7,  SYS.ATTR_SCRATCH_UINT8_ARRAY_1[2],   SYS.ATTR_SCRATCH_UINT8_ARRAY_1[31] > SYS.ATTR_SCRATCH_UINT8_1;
#  24:31, SYS.ATTR_SCRATCH_UINT8_ARRAY_1[31], SYS.ATTR_SCRATCH_UINT8_1 == SYS.ATTR_SCRATCH_UINT8_ARRAY_1[7];
#  32:39, SYS.ATTR_SCRATCH_UINT8_ARRAY_2[1][2][3], SYS.ATTR_SCRATCH_UINT8_ARRAY_1[17] < SYS.ATTR_SCRATCH_UINT8_ARRAY_1[18];
#}
scom 0x000000000006000(B,C)        {
  bits, scom_data             ,              expr;
  0:7,  SYS.ATTR_SCRATCH_UINT8_ARRAY_1[2],   SYS.ATTR_SCRATCH_UINT8_ARRAY_1[2,31] > SYS.ATTR_SCRATCH_UINT8_1;
  24:31, SYS.ATTR_SCRATCH_UINT8_ARRAY_1[2,31], SYS.ATTR_SCRATCH_UINT8_1 == SYS.ATTR_SCRATCH_UINT8_ARRAY_1[3,7];
  32:39, SYS.ATTR_SCRATCH_UINT8_ARRAY_2[0..1][1,2][2,3], SYS.ATTR_SCRATCH_UINT8_ARRAY_1[0,17] < SYS.ATTR_SCRATCH_UINT8_ARRAY_1[1,18];
}

#--******************************************************************************
#-- Basic SCOM with define used to PORE_GPE1_SCRATCH0_0x0006002A
#--******************************************************************************
scom 0x000000000006002A              {
  scom_data,            expr                 ;
  0x0000000000000184,   def_equal_test       ;
}

#--******************************************************************************
#-- Basic SCOM with a single bit set to PORE_GPE1_SCRATCH1_0x0006002B
#--******************************************************************************
scom 0x000000000006002B             {
    bits ,                    scom_data        ;
    23   ,                    0b1              ;
}

#--******************************************************************************
#-- Basic SCOM with same address but different bits set & Scom data of Attr type
#-- Simple operations on Scom data
#--******************************************************************************
scom 0x000000000006002B              {
    bits , scom_data                                                                  , expr       ;
    24:31, (MBA1.ATTR_CHIP_UNIT_POS + SYS.ATTR_SCRATCH_UINT8_ARRAY_2[1][2][3])          , (SYS.ATTR_SCRATCH_UINT8_1 | 0b00000001) != 1;
    24:31, ((MBA1.ATTR_CHIP_UNIT_POS | SYS.ATTR_SCRATCH_UINT8_ARRAY_2[1][2][3]) + 1) / 2, !(SYS.ATTR_SCRATCH_UINT8_1 == 3);
    32:63, (((SYS.ATTR_SCRATCH_UINT32_1 * 20) & 0x000000F0)) << 8                       , (SYS.ATTR_SCRATCH_UINT32_1 & 0x0000FFFF) == 3;
}

#--******************************************************************************
#-- Basic SCOM with bits to PORE_GPE1_SCRATCH2_0x0006002C
#--******************************************************************************
scom 0x000000000006002C              {
    bits ,                    scom_data        ;
    0:11 ,                    0b000011001001   ;
    12   ,                    0b1              ;
    13   ,                    0x1              ;
    14:59,                    0x00c190010480   ;
    60:63,                    0b1101           ;
}

#--******************************************************************************
#-- Complex SCOM with Bit Support, define, and attributes to
#-- PORE_SLW_SCRATCH0_0x0006800A
#--******************************************************************************
scom 0x000000000006800A              {
    bits ,                    scom_data,        expr                                  ;
    0:11 ,                    0b000011001001,   ANY                                   ;
    12   ,                    0b1,              def_equal_test                        ;
    12   ,                    0b0,              def_not_equal_test                    ;
    13   ,                    0b1,              def_uint8_greater_test                ;
    14:59, 0b0000001100000110010000000000010000010010000000,  SYS.ATTR_SCRATCH_UINT64_2 == ENUM_ATTR_SCRATCH_UINT64_2_VAL_C;
}

#--******************************************************************************
#-- Complex SCOM with Bit Support, and logical operators to
#-- PORE_SLW_SCRATCH1_0x0006800B
#--******************************************************************************
scom 0x000000000006800B              {
    bits ,                    scom_data,        expr                                  ;
    12   ,                    0b1,              def_equal_test && def_not_equal_test  ;
    12   ,                    0b0,              def_equal_test || def_not_equal_test  ;
    14   ,                    0b1,              SYS.ATTR_SCRATCH_UINT32_1 < SYS.ATTR_SCRATCH_UINT32_2   ;
    15   ,                    0b1,              def_uint32_greater_test                                 ;
    16   ,                    0b1,              SYS.ATTR_SCRATCH_UINT32_1 >= SYS.ATTR_SCRATCH_UINT32_2  ;
    17   ,                    0b1,              SYS.ATTR_SCRATCH_UINT32_1 <= SYS.ATTR_SCRATCH_UINT32_2  ;
    18   ,                    0b1,              SYS.ATTR_SCRATCH_UINT32_1 == SYS.ATTR_SCRATCH_UINT32_2  ;
    19   ,                    0b1,              SYS.ATTR_SCRATCH_UINT32_1 != SYS.ATTR_SCRATCH_UINT32_2  ;
    20   ,                    0b1,              (SYS.ATTR_SCRATCH_UINT32_1 + SYS.ATTR_SCRATCH_UINT32_2) == 4 ;
    21:59, 0b000000110000011001000000000001000001001, SYS.ATTR_SCRATCH_UINT8_1 == SYS.ATTR_SCRATCH_UINT8_2 ;
}

#--******************************************************************************
#-- SCOM with 'ec' column - Use scratch for now since all attributes work
#-- To PORE_SLW_SCRATCH2_0x0006800C
#--******************************************************************************
scom 0x000000000006800C              {
  scom_data,            SYS.ATTR_SCRATCH_UINT32_1,  SYS.ATTR_SCRATCH_UINT32_2        ;
  0x0000000000000192,   != 0,                       >= ENUM_ATTR_SCRATCH_UINT64_ARRAY_2_VAL_B       ;
}

#--******************************************************************************
#-- Basic SCOM with an array to PORE_SBE_SCRATCH0_0x000E000A
#--******************************************************************************
scom 0x00000000000E000A              {
  scom_data,            expr                 ;
  0x0000000000000182,   SYS.ATTR_SCRATCH_UINT8_ARRAY_1[2] == SYS.ATTR_SCRATCH_UINT8_1    ;
}

#--******************************************************************************
#-- SCOM with 'ec' & expr column - Use scratch for now since all attributes work
#-- To PORE_SBE_SCRATCH1_0x000E000B
#--******************************************************************************
scom 0x00000000000E000B              {
  scom_data,            SYS.ATTR_SCRATCH_UINT32_1,   expr;
  0x0000000000000192,   3,                           SYS.ATTR_SCRATCH_UINT8_ARRAY_2[1][2][3] == 0x00000000000000BE;
}

#--******************************************************************************
#-- Complex SCOM with Bit Support, associated attributes and logical operators
#-- To PORE_SBE_SCRATCH2_0x000E000C
#--******************************************************************************
# TODO:  RTC:Issue 66579   remove this register as it is now being used by dump
scom 0x00000000000E000C              {
  bits,  scom_data,               MBA1.ATTR_CHIP_UNIT_POS, expr;
  23,    0b0,                     1,                       MBA0.ATTR_CHIP_UNIT_POS == 1;
  23,    MBA1.ATTR_CHIP_UNIT_POS, 1,                       MBA0.ATTR_CHIP_UNIT_POS == 0;
  24:25, 0b10,                    0,                       any;
  24:25, 0b01,                    1,                       SYS.ATTR_SCRATCH_UINT8_ARRAY_1[2] == SYS.ATTR_SCRATCH_UINT8_1;
}

#--******************************************************************************
#-- Basic SCOM with Multiple Arrays/Address Ranges
#-- Note: These are not valid SCOM addresses. Just included here as an example of
#-- the supported syntax.  Uncomment only for debugging code.
#--******************************************************************************
#scom 0x0000006(0E..10,3c)4(A,1)(D..F)56(7,8,9,0)1       {
#  scom_data             ;
#  0x0000000000000193    ;
#}

#--******************************************************************************
#-- Basic SCOM with Bin and Hex Scom Addresses of Multiple Arrays/Address Ranges
#-- Note: These are not valid SCOM addresses. Just included here as an example of
#-- the supported syntax.  Uncomment only for debugging code.
#--******************************************************************************
#scom 0x(7,8)000001301.0b1(01..10,00)(00,01)0(1,0)1.0xD(8A,8B)C {
#  scom_data                 ;
#  0x0000000000000194    ;
#}

#--******************************************************************************
#-- SCOM with defines for Scom address and each supported column.
#-- Note: This SCOM is inluded here as an example of the supported syntax.
#-- Uncomment only for debugging code.
#--******************************************************************************
#scom addr.rx_mode_reg(rx0,rx1)(lane0, lane2..lane3).addr2(xbus0,xbus3)addr3 {
#  bits     , scom_data,              SYS.ATTR_SCRATCH_UINT32_1, expr;
#  rx_field1, rx_field1_enum_value1,  any,                       def_equal_test;
#  rx_field1, rx_field1_enum_value2,  attr_value1,               def_not_equal_test;
#}