SBE code restructure: sbe -> src rename

Change-Id: I6e4378d0e71a00ed2b239658d43f180df2a9b748
RTC:159709
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/28875
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: RAJA DAS <rajadas2@in.ibm.com>
Reviewed-by: Sachin Gupta <sgupta2m@in.ibm.com>

8 files changed, 5499 insertions, 0 deletions

diff --git a/src/tools/scripts/parseErrorInfo.pl b/src/tools/scripts/parseErrorInfo.pl
new file mode 100755
index 00000000..839a836c
--- /dev/null
+++ b/src/tools/scripts/parseErrorInfo.pl
@@ -0,0 +1,1663 @@
+#!/usr/bin/perl
+# IBM_PROLOG_BEGIN_TAG
+# This is an automatically generated prolog.
+#
+# $Source: src/tools/scripts/parseErrorInfo.pl $
+#
+# OpenPOWER sbe Project
+#
+# Contributors Listed Below - COPYRIGHT 2015,2016
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+#
+# IBM_PROLOG_END_TAG
+#
+# @file   parseErrorInfo.pl
+# @brief  This perl script will parse HWP Error XML files and generate required
+#         FAPI code to create and error log and add FFDC to the error.
+#
+# *HWP HWP Owner: N/A
+# *HWP FW Owner: Thi Tran <thi@us.ibm.com>
+# *HWP Team: N/A
+# *HWP Level: 1
+# *HWP Consumed by: HB
+#
+# Usage:
+# parseErrorInfo.pl <output dir> <filename1> <filename2> ...
+
+use strict;
+
+#------------------------------------------------------------------------------
+# Set PREFERRED_PARSER to XML::Parser. Otherwise it uses XML::SAX which contains
+# bugs that result in XML parse errors that can be fixed by adjusting white-
+# space (i.e. parse errors that do not make sense).
+#------------------------------------------------------------------------------
+$XML::Simple::PREFERRED_PARSER = 'XML::Parser';
+
+#------------------------------------------------------------------------------
+# Specify perl modules to use
+#------------------------------------------------------------------------------
+use Digest::MD5 qw(md5_hex);
+use XML::Simple;
+my $xml = new XML::Simple (KeyAttr=>[]);
+
+# Uncomment to enable debug output
+use Data::Dumper;
+use Getopt::Long;
+
+my $target_ffdc_type = "fapi2::Target<T>";
+my $buffer_ffdc_type = "fapi2::buffer";
+my $variable_buffer_ffdc_type = "fapi2::variable_buffer";
+my $ffdc_type = "fapi2::ffdc_t";
+my $mcast_type = "fapi2::mcast_t";
+
+# We want to keep the signatures for the ffdc gathering hwp so that
+# we can create members of the proper types for the ffdc classes.
+my %signatures = ("proc_extract_pore_halt_ffdc" => ["por_base_state",
+                                                    "por_halt_type_t",
+                                                    "por_ffdc_offset_t"],
+                  "hwpTestFfdc1" => [$target_ffdc_type],
+                  "proc_extract_pore_base_ffdc" => ["por_base_state", "por_sbe_base_state"],
+                  "proc_tp_collect_dbg_data" => [$target_ffdc_type],
+    );
+
+# There are some names used in the XML files which exist in either
+# c++ keywords (case, for example) or macros (DOMAIN). The one's which
+# cause problems and need to be changed are here.
+#
+# DOMAIN is defined to 1 in math.h
+my %mangle_names = ("DOMAIN" => "FAPI2_DOMAIN");
+
+# A list of deprecated elements. These will report messages to the
+# user, and not define anything. They have not been found to be used,
+# but that doesn't mean they're not ...
+my %deprecated = ("RC_PROCPM_PMCINIT_TIMEOUT" => "CHIP_IN_ERROR is defined as a callout procedure");
+
+#------------------------------------------------------------------------------
+# Print Command Line Help
+#------------------------------------------------------------------------------
+my $arg_empty_ffdc = undef;
+my $arg_local_ffdc = undef;
+my $arg_output_dir = undef;
+my $arg_use_variable_buffers = undef;
+
+# Get the options from the command line - the rest of @ARGV will
+# be filenames
+GetOptions("empty-ffdc-classes" => \$arg_empty_ffdc,
+           "local-ffdc" => \$arg_local_ffdc,
+           "output-dir=s" => \$arg_output_dir,
+           "use-variable-buffers" => \$arg_use_variable_buffers);
+
+my $numArgs = $#ARGV + 1;
+if (($numArgs < 1) || ($arg_output_dir eq undef))
+{
+    print ("Usage: parseErrorInfo.pl [--empty-ffdc-classes] [--use-variable-buffers] --output-dir=<output dir> <filename1> <filename2> ...\n");
+    print ("  This perl script will parse HWP Error XML files and creates\n");
+    print ("  the following files:\n");
+    print ("  - hwp_return_codes.H. HwpReturnCode enumeration (HWP generated errors)\n");
+    print ("  - hwp_error_info.H.   Error information (used by FAPI_SET_HWP_ERROR\n");
+    print ("                        when a HWP generates an error)\n");
+    print ("  - collect_reg_ffdc.H. Function to collect register FFDC\n");
+    print ("  - set_sbe_error.H.    Macro to create an SBE error\n");
+    print ("  The --empty-ffdc-classes option is for platforms which don't collect ffdc.\n");
+    exit(1);
+}
+
+#------------------------------------------------------------------------------
+# Hashes containing error names/enum-values
+#------------------------------------------------------------------------------
+my %errNameToValueHash;
+my %errValuePresentHash;
+
+#------------------------------------------------------------------------------
+# Hashes containing ffdc names/enum-values
+#------------------------------------------------------------------------------
+my %ffdcNameToValueHash;
+my %ffdcValuePresentHash;
+
+#------------------------------------------------------------------------------
+# Subroutine that checks if an entry exists in an array. If it doesn't exist
+# then it is added. The index of the entry within the array is returned
+#------------------------------------------------------------------------------
+sub addEntryToArray
+{
+    my ($arrayref, $entry ) = @_;
+
+    my $match = 0;
+    my $index = 0;
+
+    foreach my $element (@$arrayref)
+    {
+        if ($element eq $entry)
+        {
+            $match = 1;
+            last;
+        }
+        else
+        {
+            $index++;
+        }
+    }
+
+    if (!($match))
+    {
+        push(@$arrayref, $entry);
+    }
+
+    return $index;
+}
+
+#------------------------------------------------------------------------------
+# Subroutine that figures out an error enum value from an error name and stores
+# it in global hashes
+#------------------------------------------------------------------------------
+sub setErrorEnumValue
+{
+    my $name = $_[0];
+
+    #--------------------------------------------------------------------------
+    # Check that the error name is not a duplicate
+    #--------------------------------------------------------------------------
+    if (exists($errNameToValueHash{$name}))
+    {
+        # Two different errors with the same name!
+        print ("fapiParseErrorInfo.pl ERROR. Duplicate error name ", $name, "\n");
+        exit(1);
+    }
+
+    #--------------------------------------------------------------------------
+    # Figure out the error enum-value. This is a hash value generated from
+    # the error name. A hash is used for Cronus so that if a HWP is not
+    # recompiled against a new eCMD/Cronus version where the errors have
+    # changed then there will not be a mismatch in error values.
+    # This is a 24bit hash value because FAPI has a requirement that the
+    # top byte of the 32 bit error value be zero to store flags indicating
+    # the creator of the error
+    #--------------------------------------------------------------------------
+    my $errHash128Bit = md5_hex($name);
+    my $errHash24Bit = substr($errHash128Bit, 0, 6);
+
+    #--------------------------------------------------------------------------
+    # Check that the error enum-value is not a duplicate
+    #--------------------------------------------------------------------------
+    if (exists($errValuePresentHash{$errHash24Bit}))
+    {
+        # Two different errors generate the same hash-value!
+        print ("fapiParseAttributeInfo.pl ERROR. Duplicate error hash value\n");
+        exit(1);
+    }
+
+    #--------------------------------------------------------------------------
+    # Update the hashes with the error name and ID
+    #--------------------------------------------------------------------------
+    $errValuePresentHash{$errHash24Bit} = 1;
+    $errNameToValueHash{$name} = $errHash24Bit;
+}
+
+#------------------------------------------------------------------------------
+# Subroutine that figures out an FFDC ID value from an FFDC name and stores it
+# in global hashes for use when creating the enumeration of FFDC IDs
+#------------------------------------------------------------------------------
+sub setFfdcIdValue
+{
+    my $name = $_[0];
+
+    #--------------------------------------------------------------------------
+    # Check that the FFDC name is not a duplicate
+    #--------------------------------------------------------------------------
+    if (exists($ffdcNameToValueHash{$name}))
+    {
+        # Two different FFDCs with the same name!
+        print ("fapiParseErrorInfo.pl ERROR. Duplicate FFDC name ", $name, "\n");
+        exit(1);
+    }
+
+    #--------------------------------------------------------------------------
+    # Figure out the FFDC enum-value. This is a hash value generated from
+    # the FFDC name.
+    #--------------------------------------------------------------------------
+    my $ffdcHash128Bit = md5_hex($name);
+    my $ffdcHash32Bit = substr($ffdcHash128Bit, 0, 8);
+
+    #--------------------------------------------------------------------------
+    # Check that the error enum-value is not a duplicate
+    #--------------------------------------------------------------------------
+    if (exists($ffdcValuePresentHash{$ffdcHash32Bit}))
+    {
+        # Two different FFDCs generate the same hash-value!
+        print ("fapiParseAttributeInfo.pl ERROR. Duplicate FFDC hash value\n");
+        exit(1);
+    }
+
+    #--------------------------------------------------------------------------
+    # Update the hashes with the error name and ID
+    #--------------------------------------------------------------------------
+    $ffdcValuePresentHash{$ffdcHash32Bit} = 1;
+    $ffdcNameToValueHash{$name} = $ffdcHash32Bit;
+}
+
+#------------------------------------------------------------------------------
+# Subroutine to create ffdc methods
+#------------------------------------------------------------------------------
+sub addFfdcMethod
+{
+    my $methods = shift;
+    my $ffdc_uc = shift;
+    my $class_name = shift;
+    my $type = shift;
+    my $objectNumber = shift;
+
+    # Remove the leading *_
+    $class_name = (split (/_/, $class_name, 2))[1];
+
+    # If we didn't get a type passed in, this element will get an ffdc_t pair.
+    $type = $ffdc_type if ($type eq undef);
+
+    # Mangle the uppercase name if needed
+    $ffdc_uc = $mangle_names{$ffdc_uc} if ($mangle_names{$ffdc_uc} ne undef);
+
+    my $key = $ffdc_uc.$type;
+    my $key_target = $ffdc_uc.$target_ffdc_type;
+    my $key_ffdc = $ffdc_uc.$ffdc_type;
+
+    # Check to see if this element already has been recorded with this
+    # type or a target type. Note the effect we're shooting for here is
+    # to define the member if it's not been defined before *or* it's
+    # changing from an ffdc_t to a target due to other information in the xml
+    return if ($methods->{$key}{type} eq $type);
+    return if ($methods->{$key_target}{type} eq $target_ffdc_type);
+
+    # Just leave if this is a variable_buffer ans we're not supporting that.
+    return if (($type eq $variable_buffer_ffdc_type) && ($arg_use_variable_buffers eq undef));
+
+    # Set the proper type, and clear out any previous members/methods if
+    # we're going from an ffdc_t to a target.
+    $methods->{$key}{type} = $type;
+    delete $methods->{$key_ffdc} if ($type eq $target_ffdc_type);
+
+    my $method = "";
+    my $method_body = "";
+
+    # If we're generating empty classes, not using an argument name will avoid the unused parameter warnings
+    my $param = ($arg_empty_ffdc eq undef) ? "i_value" : "";
+
+    if ($type eq $ffdc_type)
+    {
+        $method =      "\ttemplate< typename T >\n";
+        $method  .=      "\tinline $class_name& set_$ffdc_uc(const T& $param)\n";
+
+        if(!$arg_local_ffdc)
+        {
+            $method_body  =  "    {$ffdc_uc.ptr() = &i_value; $ffdc_uc.size() =";
+            $method_body  .= " fapi2::getErrorInfoFfdcSize(i_value); return *this;}\n\n";
+            $methods->{$key}{member} = "$ffdc_type $ffdc_uc;\n    ";
+        }
+        else
+        {
+           # need to use the objectNumber here so when we decode the info at the hwsv/hb side we have a reference, they will
+           # be copied into/out of the sbe buffer in the correct order
+           $method_body .= "\t{\n\t\tfapi2::g_FfdcData.ffdcData[$objectNumber].data= convertType(i_value);\n";
+           $method_body .= "\t\tfapi2::g_FfdcData.ffdcData[$objectNumber].size =";
+           $method_body .=" fapi2::getErrorInfoFfdcSize(i_value);\n";
+           $method_body .= "\t\tfapi2::g_FfdcData.ffdcLength += sizeof(sbeFfdc_t);\n";
+           $method_body .= "\t\treturn *this;\n\t};\n\n";
+       }
+
+    }
+   elsif ($type eq $mcast_type )
+   {
+# uncomment once multicast is understood more
+#       $method =      "\n\t\ttemplate< typename T >\n";
+#       $method  .=      "\t\tinline $class_name& set_$ffdc_uc(const T& $param)\n";
+#
+#       if(!$arg_local_ffdc)
+#       {
+#           $method_body  =  "    {$ffdc_uc.ptr() = &i_value; $ffdc_uc.size() = fapi2::getErrorInfoFfdcSize(i_value); return *this;}\n\n";
+#           $methods->{$key}{member} = "$mcast_type $ffdc_uc;\n    ";
+#       }
+#        else
+#        {
+#           $method_body .= "\t\t{\n\t\t\tfapi2::g_ErrorInfoFfdc[$objectNumber].iv_ffdcId = fapi2::EI_TYPE_FFDC;\n";
+#            $method_body .= "\t\t\tfapi2::g_ErrorInfoFfdc[$objectNumber].iv_ffdc.ptr() = &i_value;\n";
+#            $method_body .= "\t\t\tfapi2::g_ErrorInfoFfdc[$objectNumber].iv_ffdc.size() = fapi2::getErrorInfoFfdcSize(i_value);";
+#            $method_body .= "\n\t\t\treturn *this;\n\t\t};\n\n";
+#        }
+#
+    }
+    elsif ($type eq $buffer_ffdc_type)
+    {
+        # Two methods - one for integral buffers and one for variable_buffers
+        $method =      "\n    template< typename T >\n";
+        $method  .=      "    inline $class_name& set_$ffdc_uc(const fapi2::buffer<T>& $param)\n";
+        $method_body  =  "    {$ffdc_uc.ptr() = &i_value(); $ffdc_uc.size() = i_value.template getLength<uint8_t>(); return *this;}\n\n";
+
+        $methods->{$key}{member} = "$ffdc_type $ffdc_uc;\n    ";
+    }
+
+    elsif ($type eq $variable_buffer_ffdc_type)
+    {
+        $method       =  "\n    inline $class_name& set_$ffdc_uc(const fapi2::variable_buffer& $param)\n";
+        $method_body  =    "    {$ffdc_uc.ptr() = &i_value(); $ffdc_uc.size() = i_value.template getLength<uint8_t>(); return *this;}\n\n";
+
+        # No need to add the member here, it was added with fapi2::buffer. And we can't have variable
+        # buffer support with out integral buffer support (can we?)
+    }
+
+    elsif ($type eq $target_ffdc_type)
+    {
+        $method =      "\n    template< TargetType T >\n";
+        $method .=       "    inline $class_name& set_$ffdc_uc(const $type& $param)\n";
+        $method_body .=  "    {$ffdc_uc.ptr() = &i_value; $ffdc_uc.size() = fapi2::getErrorInfoFfdcSize(i_value); return *this;}\n\n";
+
+        $methods->{$key}{member} = "$ffdc_type $ffdc_uc;\n    ";
+    }
+
+    else
+    {
+        print ("ffdc type $type is unknown\n");
+        exit(1);
+    }
+
+    $method .= ($arg_empty_ffdc eq undef) ? $method_body : "    {return *this;}\n\n";
+    $methods->{$key}{method} = $method;
+}
+
+#------------------------------------------------------------------------------
+# Open output files for writing
+#------------------------------------------------------------------------------
+my $rcFile = $arg_output_dir;
+$rcFile .= "/";
+$rcFile .= "hwp_return_codes.H";
+open(RCFILE, ">", $rcFile);
+
+my $eiFile = $arg_output_dir;
+$eiFile .= "/";
+$eiFile .= "hwp_error_info.H";
+open(EIFILE, ">", $eiFile);
+
+my $ecFile = $arg_output_dir;
+$ecFile .= "/";
+$ecFile .= "hwp_ffdc_classes.H";
+open(ECFILE, ">", $ecFile);
+
+my $crFile = $arg_output_dir;
+$crFile .= "/";
+$crFile .= "collect_reg_ffdc.H";
+open(CRFILE, ">", $crFile);
+
+my $sbFile = $arg_output_dir;
+$sbFile .= "/";
+$sbFile .= "set_sbe_error.H";
+open(SBFILE, ">", $sbFile);
+
+#------------------------------------------------------------------------------
+# Print start of file information to hwp_error_info.H
+#------------------------------------------------------------------------------
+print EIFILE "// hwp_error_info.H\n";
+print EIFILE "// This file is generated by the perl script parseErrorInfo.pl\n\n";
+print EIFILE "#ifndef FAPI2_HWPERRORINFO_H_\n";
+print EIFILE "#define FAPI2_HWPERRORINFO_H_\n\n";
+print EIFILE "#include <target.H>\n";
+print EIFILE "#include <plat_trace.H>\n";
+print EIFILE "#include <hwp_return_codes.H>\n";
+print EIFILE "#include <set_sbe_error.H>\n";
+print EIFILE "/**\n";
+print EIFILE " * \@brief Error Information macros and HwpFfdcId enumeration\n";
+print EIFILE " *\/\n";
+#------------------------------------------------------------------------------
+# Print start of file information to hwp_ffdc_classes.H
+#------------------------------------------------------------------------------
+print ECFILE "// hwp_ffdc_classes.H\n";
+print ECFILE "// This file is generated by the perl script parseErrorInfo.pl\n\n";
+print ECFILE "#ifndef FAPI2_HWP_FFDC_CLASSES_H_\n";
+print ECFILE "#define FAPI2_HWP_FFDC_CLASSES_H_\n\n";
+print ECFILE "#include <ffdc.H>\n";
+print ECFILE "#include <buffer.H>\n";
+print ECFILE "#include <variable_buffer.H>\n" if ($arg_use_variable_buffers ne undef);
+print ECFILE "#include <error_info.H>\n";
+print ECFILE "#include <utils.H>\n";
+print ECFILE "#include <hwp_error_info.H>\n";
+print ECFILE "#if !defined(FAPI2_NO_FFDC) && !defined(MINIMUM_FFDC)\n";
+#print ECFILE "#include <collect_reg_ffdc.H>\n";
+print ECFILE "#endif\n";
+#print ECFILE "#include <proc_extract_sbe_rc.H>\n\n";
+print ECFILE "/**\n";
+print ECFILE " * \@brief FFDC gathering classes\n";
+print ECFILE " *\/\n";
+print ECFILE "namespace fapi2\n{\n";
+if($arg_local_ffdc)
+{
+    print ECFILE "extern SbeFfdcData_t g_FfdcData; \n";
+}
+#------------------------------------------------------------------------------
+# Print start of file information to collectRegFfdc.H
+#------------------------------------------------------------------------------
+print CRFILE "// collect_reg_ffdc.H\n";
+print CRFILE "// This file is generated by the perl script parseErrorInfo.pl\n\n";
+print CRFILE "#ifndef FAPI2_COLLECT_REG_FFDC_H_\n";
+print CRFILE "#define FAPI2_COLLECT_REG_FFDC_H_\n";
+print CRFILE "#include <stdint.h>\n";
+print CRFILE "#include <vector>\n";
+print CRFILE "#include <ffdc.H>\n";
+print CRFILE "#include <hwp_error_info.H>\n";
+print CRFILE "#include <error_info_defs.H>\n";
+print CRFILE "#include <buffer.H>\n";
+print CRFILE "#include <target.H>\n";
+print CRFILE "#include <return_code.H>\n";
+print CRFILE "#include <hw_access.H>\n";
+print CRFILE "#include <plat_trace.H>\n";
+print CRFILE "namespace fapi2\n";
+print CRFILE "{\n";
+print CRFILE "template< TargetType C, TargetType P >\n";
+print CRFILE "void collectRegFfdc(const fapi2::ffdc_t& i_target,\n";
+print CRFILE "                        const fapi2::HwpFfdcId i_ffdcId,\n";
+print CRFILE "                        fapi2::ReturnCode & o_rc,\n";
+print CRFILE "                        uint32_t i_childOffsetMult = 0)\n";
+print CRFILE "{\n";
+print CRFILE "    FAPI_INF(\"collectRegFfdc. FFDC ID: 0x%x\", i_ffdcId);\n";
+print CRFILE "    fapi2::ReturnCode l_rc;\n";
+print CRFILE "    fapi2::buffer<uint64_t> l_buf;\n";
+print CRFILE "    uint32_t l_cfamData = 0;\n";
+print CRFILE "    uint64_t l_scomData = 0;\n";
+print CRFILE "    std::vector<uint32_t> l_cfamAddresses;\n";
+print CRFILE "    std::vector<uint64_t> l_scomAddresses;\n";
+print CRFILE "    uint32_t l_ffdcSize = 0;\n\n";
+print CRFILE "    switch (i_ffdcId)\n";
+print CRFILE "    {\n";
+print CRFILE "        // void statments for the unused variables\n";
+print CRFILE "        static_cast<void>(l_cfamData);\n";
+print CRFILE "        static_cast<void>(l_scomData);\n";
+print CRFILE "        static_cast<void>(l_ffdcSize);\n";
+print CRFILE "        static_cast<const void>(i_target);\n";
+print CRFILE "        static_cast<void>(o_rc);\n";
+print CRFILE "        static_cast<void>(i_childOffsetMult);\n";
+#------------------------------------------------------------------------------
+# Print start of file information to setSbeError.H
+#------------------------------------------------------------------------------
+print SBFILE "// setSbeError.H\n";
+print SBFILE "// This file is generated by the perl script parseErrorInfo.pl\n\n";
+print SBFILE "// When SBE code creates an error, it produces an error value\n";
+print SBFILE "// that matches a value in the HwpReturnCode enum in\n";
+print SBFILE "// fapiHwpReturnCodes.H. The SBE uses the __ASSEMBLER__\n";
+print SBFILE "// primitives in hwpReturnCodes.H to do this. The function\n";
+print SBFILE "// that extracts the error value from the SBE needs to call\n";
+print SBFILE "// FAPI_SET_HWP_ERROR to create the error and get all the\n";
+print SBFILE "// actions in the error XML file performed, but that macro can\n";
+print SBFILE "// only be called with the enumerator, not the value. This\n";
+print SBFILE "// FAPI_SET_SBE_ERROR macro can be called instead, it calls\n";
+print SBFILE "// FAPI_SET_HWP_ERROR with the correct error enumerator.\n";
+print SBFILE "// Errors containing <sbeError/> in their XML are supported\n";
+print SBFILE "// in this macro.\n\n";
+print SBFILE "// Note that it is expected that this macro will be called\n";
+print SBFILE "// in one place (the function that extracts the error from\n";
+print SBFILE "// the SBE), if this changes and it is called in multiple\n";
+print SBFILE "// places then the macro could be turned into a function to\n";
+print SBFILE "// avoid the code size increase of expanding the macro in\n";
+print SBFILE "// multiple places. The function approach is slightly more\n";
+print SBFILE "// complicated, there is an extra C file and the function\n";
+print SBFILE "// must take a parameter for the generic chip ID in the error\n";
+print SBFILE "// XML.\n\n";
+print SBFILE "#ifndef FAPI2_SETSBEERROR_H_\n";
+print SBFILE "#define FAPI2_SETSBEERROR_H_\n\n";
+print SBFILE "#define FAPI_SET_SBE_ERROR(RC, ERRVAL, FFDC_BUFFER)\\\n";
+print SBFILE "{\\\n";
+print SBFILE "switch (ERRVAL)\\\n";
+print SBFILE "{\\\n";
+
+#------------------------------------------------------------------------------
+# For each XML file
+#------------------------------------------------------------------------------
+foreach my $argnum (0 .. $#ARGV)
+{
+    my $infile = $ARGV[$argnum];
+    my $count = 0;
+
+    #--------------------------------------------------------------------------
+    # Read XML file. The ForceArray option ensures that there is an array of
+    # elements even if there is only one element
+    #--------------------------------------------------------------------------
+    my $errors = $xml->XMLin($infile, ForceArray =>
+        ['hwpError', 'collectFfdc', 'ffdc','mcastId', 'callout', 'deconfigure', 'gard',
+         'registerFfdc', 'collectRegisterFfdc', 'cfamRegister', 'scomRegister',
+         'id','collectTrace', 'buffer']);
+
+    # Uncomment to get debug output of all errors
+    #print "\nFile: ", $infile, "\n", Dumper($errors), "\n";
+
+    #--------------------------------------------------------------------------
+    # For each Error
+    #--------------------------------------------------------------------------
+    foreach my $err (@{$errors->{hwpError}})
+    {
+        my $objectStr = "";
+        # Hash of methods for the ffdc-gathering class
+        my %methods;
+
+        #----------------------------------------------------------------------
+        # Check that expected fields are present
+        #----------------------------------------------------------------------
+        if (! exists $err->{rc})
+        {
+            print ("parseErrorInfo.pl ERROR. rc missing\n");
+            exit(1);
+        }
+
+        if (! exists $err->{description})
+        {
+            print ("parseErrorInfo.pl ERROR in $err->{rc}. description missing\n");
+            exit(1);
+        }
+
+        #----------------------------------------------------------------------
+        # Check that this rc hasn't been deprecated
+        #----------------------------------------------------------------------
+        if ($deprecated{$err->{rc}} ne undef)
+        {
+            print "WARNING: $err->{rc} has been deprecated because $deprecated{$err->{rc}}\n";
+            next;
+        }
+
+        #----------------------------------------------------------------------
+        # Set the error enum value in a global hash
+        #---------------------------------------------------------------------
+        setErrorEnumValue($err->{rc});
+
+
+        #----------------------------------------------------------------------
+        # Print the CALL_FUNCS_TO_COLLECT_FFDC macro to hwp_error_info.H
+        #----------------------------------------------------------------------
+        print EIFILE "#define $err->{rc}_CALL_FUNCS_TO_COLLECT_FFDC(RC) ";
+
+        # For now, this code is removed. It appears to work just fine but
+        # will require more of the fapi2 infrastructure to be in place.
+        # Because the ffdc collection classes create members with real types,
+        # the declarations of the types need to be visible - and they're not
+        # right now. When we get further along, we can enable this code.
+        $count = 0;
+        foreach my $collectFfdc (@{$err->{collectFfdc}})
+        {
+            if ($count == 0)
+            {
+                print EIFILE "{ fapi2::ReturnCode l_tempRc; ";
+            }
+            $count++;
+
+            print EIFILE "FAPI_EXEC_HWP(l_tempRc, $collectFfdc, RC); ";
+
+            # collectFfdc is a string we're going to stuff into FAPI_EXEC_HWP
+            # but we need to create the arguments in the ffdc class. The first
+            # element inthe collectFfdc string is the function to call.
+            my @elements = split /,/, $collectFfdc;
+#            my @signature = @{$signatures{@elements[0]}};
+#
+#            $TODO for SBE errors we need to get the parameters from the FFDC_BUFFER passed
+            for (my $i = 1; $i <= $#elements; $i++)
+            {
+                @elements[$i] =~ s/^\s+|\s+$//g;
+                addFfdcMethod(\%methods, @elements[$i], $err->{rc});
+            }
+        }
+
+        if ($count > 0)
+        {
+            print EIFILE "}";
+        }
+        print EIFILE "\n";
+
+        #----------------------------------------------------------------------
+        # Print the CALL_FUNCS_TO_COLLECT_REG_FFDC macro to hwp_error_info.H
+        #----------------------------------------------------------------------
+        print EIFILE "#define $err->{rc}_CALL_FUNCS_TO_COLLECT_REG_FFDC(RC) ";
+
+        if(!$arg_local_ffdc)
+        {
+        foreach my $collectRegisterFfdc (@{$err->{collectRegisterFfdc}})
+        {
+            #------------------------------------------------------------------
+            # Check that expected fields are present
+            #------------------------------------------------------------------
+            if (! exists $collectRegisterFfdc->{id}[0])
+            {
+                print ("parseErrorInfo.pl ERROR in $err->{rc}. id(s) missing from collectRegisterFfdc\n");
+                exit(1);
+            }
+=begin
+            foreach my $id (@{$collectRegisterFfdc->{id}})
+            {
+                #---------------------------------------------------------------------------------
+                # Check FFDC register collection type: target, child, or based on present children
+                #---------------------------------------------------------------------------------
+                if (exists $collectRegisterFfdc->{target})
+                {
+                    print EIFILE "fapi2::collectRegFfdc<fapi2::TARGET_TYPE_NONE, fapi2::TARGET_TYPE_NONE>($collectRegisterFfdc->{target}, ";
+                    print EIFILE "fapi2::$id, RC); ";
+                    addFfdcMethod(\%methods, $collectRegisterFfdc->{target},
+                                  $err->{rc}, $target_ffdc_type);
+                }
+                elsif (exists $collectRegisterFfdc->{childTargets})
+                {
+                    if (! exists $collectRegisterFfdc->{childTargets}->{parent})
+                    {
+                        print ("parseErrorInfo.pl ERROR: parent missing from collectRegisterFfdc\n");
+                        exit(1);
+                    }
+                    if (! exists $collectRegisterFfdc->{childTargets}->{childType})
+                    {
+                        print ("parseErrorInfo.pl ERROR: childType missing from collectRegisterFfdc\n");
+                        exit(1);
+                    }
+                    print EIFILE "fapi2::collectRegFfdc<fapi2::$collectRegisterFfdc->{childTargets}->{childType}, fapi2::TARGET_TYPE_NONE>";
+                    print EIFILE "($collectRegisterFfdc->{childTargets}->{parent}, fapi2::$id, RC); ";
+                    addFfdcMethod(\%methods, $collectRegisterFfdc->{childTargets}->{parent},
+                                  $err->{rc}, $target_ffdc_type);
+                }
+                elsif (exists $collectRegisterFfdc->{basedOnPresentChildren})
+                {
+                    if (! exists $collectRegisterFfdc->{basedOnPresentChildren}->{target})
+                    {
+                        print ("parseErrorInfo.pl ERROR: target missing from collectRegisterFfdc\n");
+                        exit(1);
+                    }
+                    if (! exists $collectRegisterFfdc->{basedOnPresentChildren}->{childType})
+                    {
+                        print ("parseErrorInfo.pl ERROR: childType missing from collectRegisterFfdc\n");
+                        exit(1);
+                    }
+                    if (! exists $collectRegisterFfdc->{basedOnPresentChildren}->{childPosOffsetMultiplier})
+                    {
+                        print ("parseErrorInfo.pl ERROR: childPosOffsetMultiplier missing from collectRegisterFfdc\n");
+                        exit(1);
+                    }
+                    print EIFILE "fapi2::collectRegFfdc<fapi2::$collectRegisterFfdc->{basedOnPresentChildren}->{childType}, fapi2::TARGET_TYPE_NONE>";
+                    print EIFILE "($collectRegisterFfdc->{basedOnPresentChildren}->{target}, fapi2::$id, RC, ";
+                    print EIFILE "$collectRegisterFfdc->{basedOnPresentChildren}->{childPosOffsetMultiplier}); ";
+                    addFfdcMethod(\%methods, $collectRegisterFfdc->{basedOnPresentChildren}->{target},
+                                  $err->{rc}, $target_ffdc_type);
+                }
+                else
+                {
+                    print ("parseErrorInfo.pl ERROR: Invalid collectRegisterFfdc configuration\n");
+                    exit(1);
+                }
+            }
+=cut
+        }
+
+       }
+        print EIFILE "\n";
+
+        #----------------------------------------------------------------------
+        # Print the ADD_ERROR_INFO macro to hwp_error_info.H
+        #----------------------------------------------------------------------
+        print EIFILE "#define $err->{rc}_ADD_ERROR_INFO(RC) ";
+
+        # Array of EI Objects
+        my @eiObjects;
+
+        my $eiEntryStr = "";
+        my $eiObjectMap = "";  #object names to buffer address mapping
+        my $eiObjectStr = "const void * l_objects[] = {";
+        my $executeStr = "";
+        my $eiEntryCount = 0;
+        my %cdgTargetHash; # Records the callout/deconfigure/gards for Targets
+        my %cdgChildHash;  # Records the callout/deconfigure/gards for Children
+
+        # collect firmware trace
+        foreach my $collectTrace (@{$err->{collectTrace}})
+        {
+            # Add an EI entry to eiEntryStr
+            $eiEntryStr .= "  l_entries[$eiEntryCount].iv_type = fapi2::EI_TYPE_COLLECT_TRACE; \\\n";
+            $eiEntryStr .= "  l_entries[$eiEntryCount].collect_trace.iv_eieTraceId =  fapi2::CollectTraces::$collectTrace; \\\n";
+            $eiEntryCount++;
+        }
+        # Local FFDC
+        foreach my $ffdc (@{$err->{ffdc}})
+        {
+
+            # Set the FFDC ID value in a global hash. The name is <rc>_<ffdc>
+            my $ffdcName = $err->{rc} . "_";
+            $ffdcName = $ffdcName . $ffdc;
+            setFfdcIdValue($ffdcName);
+
+            # Add the FFDC data to the EI Object array if it doesn't already exist
+            my $objNum = addEntryToArray(\@eiObjects, $ffdc);
+
+            # Add a method to the ffdc-gathering class
+            addFfdcMethod(\%methods, $ffdc, $err->{rc},$ffdc_type,$objNum);
+
+            $ffdc = $mangle_names{$ffdc} if ($mangle_names{$ffdc} ne undef);
+
+            # Add an EI entry to eiEntryStr
+            $eiEntryStr .= "  l_entries[$eiEntryCount].iv_type = fapi2::EI_TYPE_FFDC; \\\n";
+            $eiEntryStr .= "  l_entries[$eiEntryCount].ffdc.iv_ffdcObjIndex = $objNum; \\\n";
+            $eiEntryStr .= "  l_entries[$eiEntryCount].ffdc.iv_ffdcId = fapi2::$ffdcName; \\\n";
+            $eiEntryStr .= "  l_entries[$eiEntryCount].ffdc.iv_ffdcSize = $ffdc.size(); \\\n";
+            $eiEntryCount++;
+        }
+
+        # Multicast ID
+        foreach my $mcast (@{$err->{mcastId}})
+        {
+            # Set the FFDC ID value in a global hash. The name is <rc>_<ffdc>
+            my $ffdcName = $err->{rc} . "_";
+            $ffdcName = $ffdcName . $mcast;
+            setFfdcIdValue($ffdcName);
+
+            # Add the FFDC data to the EI Object array if it doesn't already exist
+            my $objNum = addEntryToArray(\@eiObjects, $mcast);
+
+            # Add a method to the ffdc-gathering class
+            addFfdcMethod(\%methods, $mcast, $err->{rc},$mcast_type,$objNum);
+
+            $mcast = $mangle_names{$mcast} if ($mangle_names{$mcast} ne undef);
+
+            # Add an EI entry to eiEntryStr
+            $eiEntryStr .= "  l_entries[$eiEntryCount].iv_type = fapi2::EI_TYPE_FFDC; \\\n";
+            $eiEntryStr .= "  l_entries[$eiEntryCount].ffdc.iv_ffdcObjIndex = $objNum; \\\n";
+            $eiEntryStr .= "  l_entries[$eiEntryCount].ffdc.iv_ffdcId = fapi2::$ffdcName; \\\n";
+            $eiEntryStr .= "  l_entries[$eiEntryCount].ffdc.iv_ffdcSize = 4; \\\n";
+            $eiEntryCount++;
+        }
+
+        if(!$arg_local_ffdc)
+        {
+            # Buffers, looks a lot like local ffdc
+            foreach my $buffer (@{$err->{buffer}})
+            {
+                # Set the FFDC ID value in a global hash. The name is <rc>_<ffdc>
+                my $bufferName = $err->{rc} . "_";
+                $bufferName = $bufferName . $buffer;
+                setFfdcIdValue($bufferName);
+
+                # Add the FFDC data to the EI Object array if it doesn't already exist
+                my $objNum = addEntryToArray(\@eiObjects, $buffer);
+
+                # Add a method to the ffdc-gathering class - one for each buffer type
+                addFfdcMethod(\%methods, $buffer, $err->{rc}, $buffer_ffdc_type);
+                addFfdcMethod(\%methods, $buffer, $err->{rc}, $variable_buffer_ffdc_type);
+
+                # Add an EI entry to eiEntryStr
+                $eiEntryStr .= "  l_entries[$eiEntryCount].iv_type = fapi2::EI_TYPE_FFDC; \\\n";
+                $eiEntryStr .= "  l_entries[$eiEntryCount].ffdc.iv_ffdcObjIndex = $objNum; \\\n";
+                $eiEntryStr .= "  l_entries[$eiEntryCount].ffdc.iv_ffdcId = fapi2::$bufferName; \\\n";
+                $eiEntryStr .= "  l_entries[$eiEntryCount].ffdc.iv_ffdcSize = fapi2::getErrorInfoFfdcSize($buffer); \\\n";
+                $eiEntryCount++;
+            }
+
+            # Procedure/Target/Bus/Child callouts
+            foreach my $callout (@{$err->{callout}})
+            {
+                if (! exists $callout->{priority})
+                {
+                    print ("parseErrorInfo.pl ERROR in $err->{rc}. Callout priority missing\n");
+                    exit(1);
+                }
+
+                my $elementsFound = 0;
+                if (exists $callout->{hw})
+                {
+                    # HW Callout
+                    if (! exists $callout->{hw}->{hwid})
+                    {
+                        print ("parseErrorInfo.pl ERROR in $err->{rc}. HW Callout hwid missing\n");
+                        exit(1);
+                    }
+
+                    # Check that those HW callouts that need reference targets have them
+                    if (($callout->{hw}->{hwid} eq "TOD_CLOCK") ||
+                        ($callout->{hw}->{hwid} eq "MEM_REF_CLOCK") ||
+                        ($callout->{hw}->{hwid} eq "PROC_REF_CLOCK") ||
+                        ($callout->{hw}->{hwid} eq "PCI_REF_CLOCK"))
+                    {
+                        if (! exists $callout->{hw}->{refTarget})
+                        {
+                            print ("parseErrorInfo.pl ERROR in $err->{rc}. Callout missing refTarget\n");
+                            exit(1);
+                        }
+                    }
+
+                    # Add an EI entry to eiEntryStr
+                    $eiEntryStr .= "  l_entries[$eiEntryCount].iv_type = fapi2::EI_TYPE_HW_CALLOUT; \\\n";
+                    $eiEntryStr .= "  l_entries[$eiEntryCount].hw_callout.iv_hw = fapi2::HwCallouts::$callout->{hw}->{hwid}; \\\n";
+                    $eiEntryStr .= "  l_entries[$eiEntryCount].hw_callout.iv_calloutPriority = fapi2::CalloutPriorities::$callout->{priority}; \\\n";
+                    if (exists $callout->{hw}->{refTarget})
+                    {
+                        # Add the Targets to the objectlist if they don't already exist
+                        my $objNum = addEntryToArray(\@eiObjects, $callout->{hw}->{refTarget});
+                        $eiEntryStr .= "  l_entries[$eiEntryCount].hw_callout.iv_refObjIndex = $objNum; \\\n";
+
+                        # Add a method to the ffdc-gathering class
+                        addFfdcMethod(\%methods, $callout->{hw}->{refTarget}, $err->{rc});
+                    }
+                    else
+                    {
+                        $eiEntryStr .= "  l_entries[$eiEntryCount].hw_callout.iv_refObjIndex = 0xff; \\\n";
+                    }
+                    $eiEntryCount++;
+                    $elementsFound++;
+                }
+                if (exists $callout->{procedure})
+                {
+                    # Procedure Callout
+                    # Add an EI entry to eiEntryStr
+                    $eiEntryStr .= "  l_entries[$eiEntryCount].iv_type = fapi2::EI_TYPE_PROCEDURE_CALLOUT; \\\n";
+                    $eiEntryStr .= "  l_entries[$eiEntryCount].proc_callout.iv_procedure = fapi2::ProcedureCallouts::$callout->{procedure}; \\\n";
+                    $eiEntryStr .= "  l_entries[$eiEntryCount].proc_callout.iv_calloutPriority = fapi2::CalloutPriorities::$callout->{priority}; \\\n";
+                    $eiEntryCount++;
+                    $elementsFound++;
+                }
+                if (exists $callout->{bus})
+                {
+                    # A Bus Callout consists of two targets separated by
+                    # commas/spaces
+                    my @targets = split(/\s*,\s*|\s+/, $callout->{bus});
+
+                    if (scalar @targets != 2)
+                    {
+                        print ("parseErrorInfo.pl ERROR in $err->{rc}. did not find two targets in bus callout\n");
+                        exit(1);
+                    }
+
+                    # Add the Targets to the objectlist if they don't already exist
+                    my $objNum1 = addEntryToArray(\@eiObjects, $targets[0]);
+
+                    my $objNum2 = addEntryToArray(\@eiObjects, $targets[1]);
+
+                    # Add a method to the ffdc-gathering class
+                    addFfdcMethod(\%methods, $targets[0], $err->{rc}, $target_ffdc_type);
+                    addFfdcMethod(\%methods, $targets[1], $err->{rc}, $target_ffdc_type);
+
+                    # Add an EI entry to eiEntryStr
+                    $eiEntryStr .= "  l_entries[$eiEntryCount].iv_type = fapi2::EI_TYPE_BUS_CALLOUT; \\\n";
+                    $eiEntryStr .= "  l_entries[$eiEntryCount].bus_callout.iv_endpoint1ObjIndex = $objNum1; \\\n";
+                    $eiEntryStr .= "  l_entries[$eiEntryCount].bus_callout.iv_endpoint2ObjIndex = $objNum2; \\\n";
+                    $eiEntryStr .= "  l_entries[$eiEntryCount].bus_callout.iv_calloutPriority = fapi2::CalloutPriorities::$callout->{priority}; \\\n";
+                    $eiEntryCount++;
+                    $elementsFound++;
+                }
+                if (exists $callout->{target})
+                {
+                    # Add the Target to cdgTargetHash to be processed with any
+                    # deconfigure and GARD requests
+                    $cdgTargetHash{$callout->{target}}{callout} = 1;
+                    $cdgTargetHash{$callout->{target}}{priority} =
+                    $callout->{priority};
+
+                    $elementsFound++;
+                }
+                if (exists $callout->{childTargets})
+                {
+                    # Check that the parent and childType subelements exist
+                    if (! exists $callout->{childTargets}->{parent})
+                    {
+                        print ("parseErrorInfo.pl ERROR in $err->{rc}. Child Callout parent missing\n");
+                        exit(1);
+                    }
+
+                    if (! exists $callout->{childTargets}->{childType})
+                    {
+                        print ("parseErrorInfo.pl ERROR in $err->{rc}. Child Callout childType missing\n");
+                        exit(1);
+                    }
+
+                    # Add the child info to cdgChildHash to be processed with
+                    # any deconfigure and GARD requests
+                    my $parent = $callout->{childTargets}->{parent};
+                    my $childType = $callout->{childTargets}->{childType};
+                    $cdgChildHash{$parent}{$childType}{callout} = 1;
+                    $cdgChildHash{$parent}{$childType}{priority} =
+                    $callout->{priority};
+
+                    $elementsFound++;
+
+                    if (exists $callout->{childTargets}->{childPort})
+                    {
+                        my $childPort = $callout->{childTargets}->{childPort};
+
+                        $cdgChildHash{$parent}{$childType}{childPort} = $childPort;
+                    }
+
+                    if (exists $callout->{childTargets}->{childNumber})
+                    {
+                        my $childNum = $callout->{childTargets}->{childNumber};
+                        $cdgChildHash{$parent}{$childType}{childNumber} = $childNum;
+                    }
+
+                }
+                if ($elementsFound == 0)
+                {
+                    print ("parseErrorInfo.pl ERROR in $err->{rc}. Callout incomplete\n");
+                    exit(1);
+                }
+                elsif ($elementsFound > 1)
+                {
+                    print ("parseErrorInfo.pl ERROR in $err->{rc}. Callout has multiple elements\n");
+                    exit(1);
+                }
+            } # callout
+
+            # Target/Child deconfigures
+            foreach my $deconfigure (@{$err->{deconfigure}})
+            {
+                my $elementsFound = 0;
+                if (exists $deconfigure->{target})
+                {
+                    # Add the Target to cdgTargetHash to be processed with any
+                    # callout and GARD requests
+                    $cdgTargetHash{$deconfigure->{target}}{deconf} = 1;
+                    $elementsFound++;
+                }
+                if (exists $deconfigure->{childTargets})
+                {
+                    # Check that the parent and childType subelements exist
+                    if (! exists $deconfigure->{childTargets}->{parent})
+                    {
+                        print ("parseErrorInfo.pl ERROR in $err->{rc}. Child Deconfigure parent missing\n");
+                        exit(1);
+                    }
+                    if (! exists $deconfigure->{childTargets}->{childType})
+                    {
+                        print ("parseErrorInfo.pl ERROR in $err->{rc}. Child Deconfigure childType missing\n");
+                        exit(1);
+                    }
+
+                    # Add the child info to cdgChildHash to be processed with
+                    # any callout and GARD requests
+                    my $parent = $deconfigure->{childTargets}->{parent};
+                    my $childType = $deconfigure->{childTargets}->{childType};
+                    $cdgChildHash{$parent}{$childType}{deconf} = 1;
+
+                    $elementsFound++;
+
+                    if ( exists $deconfigure->{childTargets}->{childPort})
+                    {
+                        my $childPort = $deconfigure->{childTargets}->{childPort};
+
+                        $cdgChildHash{$parent}{$childType}{childPort} = $childPort;
+                    }
+
+                    if ( exists $deconfigure->{childTargets}->{childNumber})
+                    {
+                        my $childNum = $deconfigure->{childTargets}->{childNumber};
+                        $cdgChildHash{$parent}{$childType}{childNumber} = $childNum;
+
+                    }
+                }
+                if ($elementsFound == 0)
+                {
+                    print ("parseErrorInfo.pl ERROR in $err->{rc}. Deconfigure incomplete\n");
+                    exit(1);
+                }
+                elsif ($elementsFound > 1)
+                {
+                    print ("parseErrorInfo.pl ERROR in $err->{rc}. Deconfigure has multiple elements\n");
+                    exit(1);
+                }
+            } # deconfigure
+
+            # Target/Child Gards
+            foreach my $gard (@{$err->{gard}})
+            {
+                my $elementsFound = 0;
+                if (exists $gard->{target})
+                {
+                    # Add the Target to cdgTargetHash to be processed with any
+                    # callout and deconfigure requests
+                    $cdgTargetHash{$gard->{target}}{gard} = 1;
+                    $elementsFound++;
+                }
+                if (exists $gard->{childTargets})
+                {
+                    # Check that the parent and childType subelements exist
+                    if (! exists $gard->{childTargets}->{parent})
+                    {
+                        print ("parseErrorInfo.pl ERROR in $err->{rc}. Child GARD parent missing\n");
+                        exit(1);
+                    }
+                    if (! exists $gard->{childTargets}->{childType})
+                    {
+                        print ("parseErrorInfo.pl ERROR in $err->{rc}. Child GARD childType missing\n");
+                        exit(1);
+                    }
+
+                    # Add the child info to cdgChildHash to be processed with
+                    # any callout and deconfigure requests
+                    my $parent = $gard->{childTargets}->{parent};
+                    my $childType = $gard->{childTargets}->{childType};
+                    $cdgChildHash{$parent}{$childType}{gard} = 1;
+
+                    $elementsFound++;
+
+                    if ( exists $gard->{childTargets}->{childPort})
+                    {
+                        my $childPort = $gard->{childTargets}->{childPort};
+
+                        $cdgChildHash{$parent}{$childType}{childPort} = $childPort;
+
+                    }
+
+                    if ( exists $gard->{childTargets}->{childNumber})
+                    {
+                        my $childNum = $gard->{childTargets}->{childNumber};
+                        $cdgChildHash{$parent}{$childType}{childNumber} = $childNum;
+                    }
+                }
+                if ($elementsFound == 0)
+                {
+                    print ("parseErrorInfo.pl ERROR in $err->{rc}. GARD incomplete\n");
+                    exit(1);
+                }
+                elsif ($elementsFound > 1)
+                {
+                    print ("parseErrorInfo.pl ERROR in $err->{rc}. GARD has multiple elements\n");
+                    exit(1);
+                }
+            } # gard
+
+            # Process the callout, deconfigures and GARDs for each Target
+            foreach my $cdg (keys %cdgTargetHash)
+            {
+                my $callout = 0;
+                my $priority = 'LOW';
+                my $deconf = 0;
+                my $gard = 0;
+
+                if (exists $cdgTargetHash{$cdg}->{callout})
+                {
+                    $callout = 1;
+                }
+                if (exists $cdgTargetHash{$cdg}->{priority})
+                {
+                    $priority = $cdgTargetHash{$cdg}->{priority};
+                }
+                if (exists $cdgTargetHash{$cdg}->{deconf})
+                {
+                    $deconf = 1;
+                }
+                if (exists $cdgTargetHash{$cdg}->{gard})
+                {
+                    $gard = 1;
+                }
+
+                # Add the Target to the objectlist if it doesn't already exist
+                my $objNum = addEntryToArray(\@eiObjects, $cdg);
+
+                # Add a method to the ffdc-gathering class
+                addFfdcMethod(\%methods, $cdg, $err->{rc}, $target_ffdc_type);
+
+                # Add an EI entry to eiEntryStr
+                $eiEntryStr .= "  l_entries[$eiEntryCount].iv_type = fapi2::EI_TYPE_CDG; \\\n";
+                $eiEntryStr .= "  l_entries[$eiEntryCount].target_cdg.iv_targetObjIndex = $objNum; \\\n";
+                $eiEntryStr .= "  l_entries[$eiEntryCount].target_cdg.iv_callout = $callout; \\\n";
+                $eiEntryStr .= "  l_entries[$eiEntryCount].target_cdg.iv_deconfigure = $deconf; \\\n";
+                $eiEntryStr .= "  l_entries[$eiEntryCount].target_cdg.iv_gard = $gard; \\\n";
+                $eiEntryStr .= "  l_entries[$eiEntryCount].target_cdg.iv_calloutPriority = fapi2::CalloutPriorities::$priority; \\\n";
+                $eiEntryCount++;
+            }
+
+            # Process the callout, deconfigures and GARDs for Child Targets
+            foreach my $parent (keys %cdgChildHash)
+            {
+                foreach my $childType (keys %{$cdgChildHash{$parent}})
+                {
+                    my $callout = 0;
+                    my $priority = 'LOW';
+                    my $deconf = 0;
+                    my $gard = 0;
+                    my $childPort = 0xFF;
+                    my $childNumber = 0xFF;
+
+                    if (exists $cdgChildHash{$parent}{$childType}->{callout})
+                    {
+                        $callout = 1;
+                    }
+                    if (exists $cdgChildHash{$parent}->{$childType}->{priority})
+                    {
+                        $priority =
+                        $cdgChildHash{$parent}->{$childType}->{priority};
+                    }
+                    if (exists $cdgChildHash{$parent}->{$childType}->{deconf})
+                    {
+                        $deconf = 1;
+                    }
+                    if (exists $cdgChildHash{$parent}->{$childType}->{childPort})
+                    {
+                        $childPort =
+                        $cdgChildHash{$parent}->{$childType}->{childPort} ;
+                        addFfdcMethod(\%methods, $childPort, $err->{rc});
+                    }
+                    if (exists $cdgChildHash{$parent}->{$childType}->{childNumber})
+                    {
+                        $childNumber =
+                        $cdgChildHash{$parent}->{$childType}->{childNumber} ;
+                        addFfdcMethod(\%methods, $childNumber, $err->{rc});
+                    }
+                    if (exists $cdgChildHash{$parent}->{$childType}->{gard})
+                    {
+                        $gard = 1;
+                    }
+
+
+                    # Add the Target to the objectlist if it doesn't already exist
+                    my $objNum = addEntryToArray(\@eiObjects, $parent);
+                    addFfdcMethod(\%methods, $parent, $err->{rc}, $target_ffdc_type);
+
+                    # Add an EI entry to eiEntryStr
+                    $eiEntryStr .=
+                    "  l_entries[$eiEntryCount].iv_type = fapi2::EI_TYPE_CHILDREN_CDG; \\\n";
+                    $eiEntryStr .=
+                    "  l_entries[$eiEntryCount].children_cdg.iv_parentObjIndex = $objNum; \\\n";
+                    $eiEntryStr .=
+                    "  l_entries[$eiEntryCount].children_cdg.iv_callout = $callout; \\\n";
+                    $eiEntryStr .=
+                    "  l_entries[$eiEntryCount].children_cdg.iv_deconfigure = $deconf; \\\n";
+                    $eiEntryStr .=
+                    "  l_entries[$eiEntryCount].children_cdg.iv_childType = fapi2::$childType; \\\n";
+                    $eiEntryStr .=
+                    "  l_entries[$eiEntryCount].children_cdg.iv_childPort = $childPort; \\\n";
+                    $eiEntryStr .=
+                    "  l_entries[$eiEntryCount].children_cdg.iv_childNumber = $childNumber; \\\n";
+                    $eiEntryStr .=
+                    "  l_entries[$eiEntryCount].children_cdg.iv_gard = $gard; \\\n";
+                    $eiEntryStr .=
+                    "  l_entries[$eiEntryCount].children_cdg.iv_calloutPriority = fapi2::CalloutPriorities::$priority; \\\n";
+                    $eiEntryCount++;
+                }
+            }
+        }
+        # Add all objects to $eiObjectStr
+        my $objCount = 0;
+
+        foreach my $eiObject (@eiObjects)
+        {
+            if ($objCount > 0)
+            {
+                $eiObjectStr .= ", ";
+            }
+
+            if ($mangle_names{$eiObject} eq undef)
+            {
+                $eiObjectStr .= "$eiObject";
+
+                if ((exists $err->{sbeError}) )
+                {
+                     $objectStr .= "\t\tfapi2::ffdc_t $eiObject = getFfdcData(FFDC_BUFFER[$objCount]); \\\n";
+                }
+            }
+            else
+            {
+                $eiObjectStr .= $mangle_names{$eiObject};
+            }
+
+            $objCount++;
+        }
+        $eiObjectStr .= "};";
+
+
+        # Print info to file
+        if ($eiEntryCount > 0)
+        {
+            print EIFILE "\\\n{ \\\n $eiObjectStr \\\n";
+            print EIFILE "  fapi2::ErrorInfoEntry l_entries[$eiEntryCount]; \\\n";
+            print EIFILE "$eiEntryStr";
+            print EIFILE "  RC.addErrorInfo(l_objects, l_entries, $eiEntryCount); \\\n}";
+        }
+
+        print EIFILE "\n";
+
+        #----------------------------------------------------------------------
+        # Print the return code class to hwp_error_info.H
+        #----------------------------------------------------------------------
+        # Remove the repeated whitespace and newlines other characters from the description
+        $err->{description} =~ s/^\s+|\s+$|"//g;
+        $err->{description} =~ tr{\n}{ };
+        $err->{description} =~ s/\h+/ /g;
+
+        #----------------------------------------------------------------------
+        # Print the return code class to hwp_error_info.H
+        #----------------------------------------------------------------------
+        my $class_name = $err->{rc};
+        # Remove everything upto and including the first _. This makes the ffdc class
+        # names different from the error code value enum names.
+        $class_name = (split (/_/, $class_name, 2))[1];
+
+        # Class declaration
+        print ECFILE "\nclass $class_name\n{\n  public:\n";
+
+        # Constructor. This traces the description. If this is too much, we can
+        # remove it.
+        if ($arg_empty_ffdc eq undef)
+        {
+            if(!$arg_local_ffdc)
+            {
+                print ECFILE "    $class_name(fapi2::errlSeverity_t i_sev = fapi2::FAPI2_ERRL_SEV_UNRECOVERABLE, fapi2::ReturnCode& i_rc = fapi2::current_err):\n";
+                print ECFILE "        iv_rc(i_rc),\n";
+                print ECFILE "        iv_sev(i_sev)\n";
+                print ECFILE "    { FAPI_ERR(\"$err->{description}\"); }\n";
+            }
+            else
+            {
+                print ECFILE "    $class_name()\n";
+                print ECFILE "    {\n\t\tfapi2::current_err = RC_$class_name;\n\t\tFAPI_ERR(\"$err->{description}\");\n";
+                print ECFILE "    \tfapi2::g_FfdcData.fapiRc = RC_$class_name;\n\t}\n\n";
+            }
+        }
+        else
+        {
+            # Void expression keeps the compiler from complaining about the unused arguments.
+            # We want to set the i_rc to the RC if we're empty. This otherwise gets done in _setHwpError()
+            print ECFILE "    $class_name(fapi2::errlSeverity_t i_sev = fapi2::FAPI2_ERRL_SEV_UNRECOVERABLE, fapi2::ReturnCode& i_rc = fapi2::current_err)\n";
+            print ECFILE "    {\n";
+            print ECFILE "        static_cast<void>(i_sev);\n";
+            print ECFILE "        i_rc = $err->{rc};\n";
+            print ECFILE "    }\n\n";
+        }
+
+        my $method_count = 0;
+        # Methods
+        foreach my $key (keys %methods)
+        {
+            print ECFILE $methods{$key}{method};
+            $method_count++;
+        }
+        if(!$arg_local_ffdc)
+        {
+            # add a method to adjust the severity if desired
+            print ECFILE "    inline void setSev(const fapi2::errlSeverity_t i_sev)\n";
+            if ($arg_empty_ffdc eq undef)
+            {
+                print ECFILE "                      { iv_sev = i_sev; };\n\n";
+            }
+            else
+            {
+                print ECFILE "                      { static_cast<void>(i_sev); };\n\n";
+            }
+
+            # add a method to read the severity if desired
+            print ECFILE "    inline fapi2::errlSeverity_t getSev() const\n";
+            if ($arg_empty_ffdc eq undef)
+            {
+                print ECFILE "                      { return iv_sev; };\n\n";
+            }
+            else
+            {
+                print ECFILE "                      { return fapi2::FAPI2_ERRL_SEV_UNDEFINED; };\n\n";
+            }
+
+        }
+
+        if( $arg_local_ffdc eq undef )
+        {
+            # Stick the execute method at the end of the other methods. We allow
+            # passing in of the severity so that macros which call execute() can over-ride
+            # the default severity.
+            print ECFILE "    void execute(fapi2::errlSeverity_t" .
+            " i_sev = fapi2::FAPI2_ERRL_SEV_UNDEFINED," .
+            "bool commit = false )\n";
+            if ($arg_empty_ffdc eq undef )
+            {
+                print ECFILE "    {\n";
+                print ECFILE "      FAPI_SET_HWP_ERROR(iv_rc, $err->{rc});\n";
+                print ECFILE "      if( commit )\n";
+                print ECFILE "      {\n";
+                print ECFILE "        fapi2::logError(iv_rc, " .
+                "(i_sev == fapi2::FAPI2_ERRL_SEV_UNDEFINED)" .
+                " ? iv_sev : i_sev);\n";
+                print ECFILE "      }\n";
+                print ECFILE "    }\n";
+
+            }
+            else
+            {
+                print ECFILE "    {\n";
+                print ECFILE "        static_cast<void>(i_sev);\n";
+                print ECFILE "        static_cast<void>(commit);\n";
+                print ECFILE "    }\n\n";
+            }
+
+            # Instance variables
+            if ($arg_empty_ffdc eq undef)
+            {
+                print ECFILE "  public:\n    ";
+                foreach my $key (keys %methods)
+                {
+                    print ECFILE $methods{$key}{member};
+                }
+
+                print ECFILE "fapi2::ReturnCode& iv_rc;\n";
+                print ECFILE "    fapi2::errlSeverity_t iv_sev;\n";
+            }
+
+        }
+        else
+        {
+            print ECFILE "    void execute()\n";
+            print ECFILE "    {\n";
+            print ECFILE "$executeStr\n";
+            print ECFILE "    }\n";
+        }
+
+        print ECFILE "};\n\n";
+
+        #----------------------------------------------------------------------
+        # If this is an SBE error, add it to set_sbe_error.H
+        #----------------------------------------------------------------------
+        if (exists $err->{sbeError})
+        {
+            print SBFILE "\tcase fapi2::$err->{rc}: \\\n";
+            print SBFILE "\t{ \\\n$objectStr";
+            print SBFILE "\t\tFAPI_SET_HWP_ERROR(RC, $err->{rc});\\\n";
+            print SBFILE "        break; \\\n\t} \\\n";
+        }
+
+    }
+
+=pos
+    #
+    #--------------------------------------------------------------------------
+    # For each registerFfdc.
+    #--------------------------------------------------------------------------
+    foreach my $registerFfdc (@{$errors->{registerFfdc}})
+    {
+        #----------------------------------------------------------------------
+        # Check that expected fields are present
+        #----------------------------------------------------------------------
+        if (! exists $registerFfdc->{id}[0])
+        {
+            print ("parseErrorInfo.pl ERROR. id missing from registerFfdc\n");
+            exit(1);
+        }
+
+        if (scalar @{$registerFfdc->{id}} > 1)
+        {
+            print ("parseErrorInfo.pl ERROR. multiple ids in registerFfdc\n");
+            exit(1);
+        }
+
+        #----------------------------------------------------------------------
+        # Set the FFDC ID value in a global hash
+        #----------------------------------------------------------------------
+        setFfdcIdValue($registerFfdc->{id}[0]);
+
+        #----------------------------------------------------------------------
+        # Generate code to capture the registers in collect_reg_ffdc.C
+        #----------------------------------------------------------------------
+        print CRFILE "        case $registerFfdc->{id}[0]:\n";
+
+# TODO: RTC 132226 
+=begin NEED_P9_REGISTERS
+        # Look for CFAM Register addresses
+        foreach my $cfamRegister (@{$registerFfdc->{cfamRegister}})
+        {
+            print CRFILE "            l_cfamAddresses.push_back($cfamRegister);\n";
+            print CRFILE "            l_ffdcSize += sizeof(l_cfamData);\n";
+        }
+
+        # Look for SCOM Register addresses
+        foreach my $scomRegister (@{$registerFfdc->{scomRegister}})
+        {
+            print CRFILE "            l_scomAddresses.push_back($scomRegister);\n";
+            print CRFILE "            l_ffdcSize += sizeof(l_scomData);\n";
+        }
+=cut NEED_P9_REGISTERS
+
+print CRFILE "            break;\n";
+    }
+=cut
+}
+
+#------------------------------------------------------------------------------
+# Print end of file information to collect_reg_ffdc.C
+#------------------------------------------------------------------------------
+print CRFILE "        default:\n";
+print CRFILE "            FAPI_ERR(\"collect_reg_ffdc.C: Invalid FFDC ID 0x%x\", ";
+print CRFILE                     "i_ffdcId);\n";
+print CRFILE "            return;\n";
+print CRFILE "    }\n\n";
+
+# TODO: RTC 132226 
+=begin NEED_P9_REGISTERS
+print CRFILE "    uint8_t * l_pBuf = NULL;\n";
+print CRFILE "    uint8_t * l_pData = NULL;\n";
+print CRFILE "    std::vector<fapi::Target> l_targets;\n";
+print CRFILE "    uint32_t l_chipletPos32 = 0;\n";
+
+#---------------------------------------------------------------------------------------------------------
+# Populate chiplet vectors (if required by register collection method) and adjust buffer sizes accordingly
+#---------------------------------------------------------------------------------------------------------
+print CRFILE "    if (C != TARGET_TYPE_NONE)\n";
+print CRFILE "    {\n";
+print CRFILE "        l_rc = fapiGetChildChiplets(i_target, i_child, l_targets, TARGET_STATE_FUNCTIONAL);\n";
+print CRFILE "        if (l_rc)\n";
+print CRFILE "        {\n";
+print CRFILE "            FAPI_ERR(\"collect_reg_ffdc.C: Error: fapiGetChildChiplets: failed to get chiplets.\");\n";
+print CRFILE "            return;\n";
+print CRFILE "        }\n";
+print CRFILE "        if (l_targets.empty())\n";
+print CRFILE "        {\n";
+print CRFILE "            FAPI_INF(\"collect_reg_ffdc.C: Error: No functional chiplets found. \");\n";
+print CRFILE "            return;\n";
+print CRFILE "        }\n";
+print CRFILE "        l_ffdcSize += sizeof(l_chipletPos32);\n";
+print CRFILE "        l_ffdcSize *= l_targets.size();\n";
+print CRFILE "        l_pBuf = new uint8_t[l_ffdcSize];\n";
+print CRFILE "        l_pData = l_pBuf;\n";
+print CRFILE "    }\n";
+print CRFILE "    else if (P != TARGET_TYPE_NONE)\n";
+print CRFILE "    {\n";
+print CRFILE "        l_rc = fapiGetChildChiplets(i_target, i_presChild, l_targets, TARGET_STATE_PRESENT);\n";
+print CRFILE "        if (l_rc)\n";
+print CRFILE "        {\n";
+print CRFILE "            FAPI_ERR(\"collect_reg_ffdc.C: Error: fapiGetChildChiplets: failed to get chiplets.\");\n";
+print CRFILE "            return;\n";
+print CRFILE "        }\n";
+print CRFILE "        if (l_targets.empty())\n";
+print CRFILE "        {\n";
+print CRFILE "            FAPI_INF(\"collect_reg_ffdc.C: Error: No functional chiplets found. \");\n";
+print CRFILE "            return;\n";
+print CRFILE "        }\n";
+print CRFILE "        l_ffdcSize += sizeof(l_chipletPos32);\n";
+print CRFILE "        l_ffdcSize *= l_targets.size();\n";
+print CRFILE "        l_pBuf = new uint8_t[l_ffdcSize];\n";
+print CRFILE "        l_pData = l_pBuf;\n";
+print CRFILE "    }\n";
+print CRFILE "    else\n";
+print CRFILE "    {\n";
+print CRFILE "        l_ffdcSize += sizeof(l_chipletPos32);\n";
+print CRFILE "        l_pBuf = new uint8_t[l_ffdcSize];\n";
+print CRFILE "        l_pData = l_pBuf;\n";
+print CRFILE "        l_targets.push_back(i_target);\n";
+print CRFILE "    }\n\n";
+
+#---------------------------------------------------------------------------------------------------------
+# Obtain target position and insert as the first word in the buffer
+#---------------------------------------------------------------------------------------------------------
+print CRFILE "    bool l_targIsChiplet = i_target.isChiplet();\n\n";
+print CRFILE "    for (std::vector<fapi::Target>::const_iterator targetIter = l_targets.begin();\n";
+print CRFILE "        targetIter != l_targets.end(); ++targetIter)\n";
+print CRFILE "    {\n";
+print CRFILE "        if ((fapi2::TARGET_TYPE_NONE != i_child) ||\n";
+print CRFILE "            (fapi2::TARGET_TYPE_NONE != i_presChild) ||\n";
+print CRFILE "            (true == l_targIsChiplet))\n";
+print CRFILE "        {\n";
+print CRFILE "            uint8_t l_chipletPos = 0;\n";
+print CRFILE "            l_rc = FAPI_ATTR_GET(ATTR_CHIP_UNIT_POS, &(*targetIter), l_chipletPos);\n";
+print CRFILE "            if (l_rc)\n";
+print CRFILE "            {\n";
+print CRFILE "                FAPI_ERR(\"collect_reg_ffdc.C: Error getting chiplet position\");\n";
+print CRFILE "                l_chipletPos = 0xFF;\n";
+print CRFILE "            }\n";
+                          #-------------------------------------------------------------------------
+                          # We print the target's position in the error log whether the target is a
+                          # chip or chiplet, so we need to store the chiplet position in a uint32_t
+                          # to have consitency in the buffer as ATTR_POS below returns a uint32_t
+                          #-------------------------------------------------------------------------
+print CRFILE "            l_chipletPos32 = l_chipletPos;\n";
+print CRFILE "        }\n";
+print CRFILE "        else\n";
+print CRFILE "        {\n";
+print CRFILE "            l_rc = FAPI_ATTR_GET(ATTR_POS, &(*targetIter), l_chipletPos32);\n";
+print CRFILE "            if (l_rc)\n";
+print CRFILE "            {\n";
+print CRFILE "                FAPI_ERR(\"collect_reg_ffdc.C: Error getting chip position\");\n";
+print CRFILE "                l_chipletPos32 = 0xFFFFFFFF;\n";
+print CRFILE "            }\n";
+print CRFILE "        }\n";
+print CRFILE "        *(reinterpret_cast<uint32_t *>(l_pData)) = l_chipletPos32;\n";
+print CRFILE "        l_pData += sizeof(l_chipletPos32);\n";
+#---------------------------------------------------------------------------------------------------------
+# Instert cfam data (if any) related to this chip / chiplet into the buffer
+# If collecting FFDC based on present children, adjust the register address by the appropriate offset
+#---------------------------------------------------------------------------------------------------------
+print CRFILE "        for (std::vector<uint32_t>::const_iterator cfamIter = l_cfamAddresses.begin();\n";
+print CRFILE "             cfamIter != l_cfamAddresses.end(); ++cfamIter)\n";
+print CRFILE "        {\n";
+print CRFILE "            if (fapi2::TARGET_TYPE_NONE != i_presChild)\n";
+print CRFILE "            {\n";
+print CRFILE "                l_rc = fapiGetCfamRegister(i_target, (*cfamIter + (l_chipletPos32 * i_childOffsetMult)), l_buf);\n";
+print CRFILE "            }\n";
+print CRFILE "            else\n";
+print CRFILE "            {\n";
+print CRFILE "                l_rc = fapiGetCfamRegister(*targetIter, *cfamIter, l_buf);\n";
+print CRFILE "            }\n";
+print CRFILE "            if (l_rc)\n";
+print CRFILE "            {\n";
+print CRFILE "                FAPI_ERR(\"collect_reg_ffdc.C: CFAM error for 0x%x\",";
+print CRFILE                          "*cfamIter);\n";
+print CRFILE "                l_cfamData = 0xbaddbadd;\n";
+print CRFILE "            }\n";
+print CRFILE "            else\n";
+print CRFILE "            {\n";
+print CRFILE "                l_cfamData = l_buf.getWord(0);\n";
+print CRFILE "            }\n";
+print CRFILE "            *(reinterpret_cast<uint32_t *>(l_pData)) = l_cfamData;\n";
+print CRFILE "            l_pData += sizeof(l_cfamData);\n";
+print CRFILE "        }\n\n";
+#---------------------------------------------------------------------------------------------------------
+# Instert any scom data (if any) related to this chip / chiplet into the buffer
+# If collecting FFDC based on present children, adjust the register address by the appropriate offset
+#---------------------------------------------------------------------------------------------------------
+print CRFILE "        for (std::vector<uint64_t>::const_iterator scomIter = l_scomAddresses.begin();\n";
+print CRFILE "            scomIter != l_scomAddresses.end(); ++scomIter)\n";
+print CRFILE "        {\n";
+print CRFILE "            if (fapi2::TARGET_TYPE_NONE != i_presChild)\n";
+print CRFILE "            {\n";
+print CRFILE "                l_rc = fapiGetScom(i_target, (*scomIter + (l_chipletPos32 * i_childOffsetMult)), l_buf);\n";
+print CRFILE "            }\n";
+print CRFILE "            else\n";
+print CRFILE "            {\n";
+print CRFILE "                l_rc = fapiGetScom(*targetIter, *scomIter, l_buf);\n";
+print CRFILE "            }\n";
+print CRFILE "            if (l_rc)\n";
+print CRFILE "            {\n";
+print CRFILE "                FAPI_ERR(\"collect_reg_ffdc.C: SCOM error for 0x%llx\",";
+print CRFILE                         "*scomIter);\n";
+print CRFILE "                l_scomData = 0xbaddbaddbaddbaddULL;\n";
+print CRFILE "            }\n";
+print CRFILE "            else\n";
+print CRFILE "            {\n";
+print CRFILE "                 l_scomData = l_buf.getDoubleWord(0);\n";
+print CRFILE "            }\n";
+print CRFILE "            *(reinterpret_cast<uint64_t *>(l_pData)) = l_scomData;\n";
+print CRFILE "            l_pData += sizeof(l_scomData);\n";
+print CRFILE "        }\n";
+print CRFILE "    }\n\n";
+print CRFILE "    o_rc.addEIFfdc(i_ffdcId, l_pBuf, l_ffdcSize);\n";
+print CRFILE "    delete [] l_pBuf;\n";
+
+=cut NEED_P9_REGISTERS
+
+print CRFILE "}\n";
+print CRFILE "}\n";
+print CRFILE "#endif\n";
+
+#------------------------------------------------------------------------------
+# Print the fapiHwpReturnCodes.H file
+#------------------------------------------------------------------------------
+print RCFILE "// fapiHwpReturnCodes.H\n";
+print RCFILE "// This file is generated by perl script parseErrorInfo.pl\n\n";
+print RCFILE "#ifndef FAPI2_HWPRETURNCODES_H_\n";
+print RCFILE "#define FAPI2_HWPRETURNCODES_H_\n\n";
+print RCFILE "#ifndef __ASSEMBLER__\n";
+print RCFILE "namespace fapi2\n";
+print RCFILE "{\n\n";
+print RCFILE "/**\n";
+print RCFILE " * \@brief Enumeration of HWP return codes\n";
+print RCFILE " *\/\n";
+print RCFILE "enum HwpReturnCode\n";
+print RCFILE "{\n";
+foreach my $key (keys %errNameToValueHash)
+{
+    print RCFILE "    $key = 0x$errNameToValueHash{$key},\n";
+}
+print RCFILE "};\n\n";
+print RCFILE "}\n\n";
+print RCFILE "#else\n";
+foreach my $key (keys %errNameToValueHash)
+{
+    print RCFILE "    .set $key, 0x$errNameToValueHash{$key}\n";
+}
+print RCFILE "#endif\n";
+print RCFILE "#endif\n";
+
+#------------------------------------------------------------------------------
+# Print the HwpFfdcId enumeration to hwp_error_info.H
+#------------------------------------------------------------------------------
+print EIFILE "namespace fapi2\n";
+print EIFILE "{\n\n";
+if($arg_local_ffdc)
+{
+    print EIFILE "  extern SbeFfdcData_t g_FfdcData;\n";
+}
+print EIFILE "/**\n";
+print EIFILE " * \@brief Enumeration of FFDC identifiers\n";
+print EIFILE " *\/\n";
+print EIFILE "enum HwpFfdcId\n";
+print EIFILE "{\n";
+foreach my $key (keys %ffdcNameToValueHash)
+{
+    print EIFILE "    $key = 0x$ffdcNameToValueHash{$key},\n";
+}
+print EIFILE "};\n\n";
+print EIFILE "}\n\n";
+
+#------------------------------------------------------------------------------
+# Print end of file information to hwp_error_info.H
+#------------------------------------------------------------------------------
+print EIFILE "\n\n#endif\n";
+
+#------------------------------------------------------------------------------
+# Print end of file information to hwp_ffdc_classes.H
+#------------------------------------------------------------------------------
+print ECFILE "\n};\n"; # close the namespace
+print ECFILE "\n\n#endif\n";
+
+#------------------------------------------------------------------------------
+# Print end of file information to set_sbe_error.H
+#------------------------------------------------------------------------------
+print SBFILE "    default:\\\n";
+#print SBFILE "        FAPI_SET_HWP_ERROR(RC, RC_SBE_UNKNOWN_ERROR,0);\\\n";
+print SBFILE "        break;\\\n";
+print SBFILE "}\\\n";
+print SBFILE "}\n\n";
+print SBFILE "#endif\n";
+
+#------------------------------------------------------------------------------
+# Close output files
+#------------------------------------------------------------------------------
+close(RCFILE);
+close(EIFILE);
+close(ECFILE);
+close(CRFILE);
+close(SBFILE);
diff --git a/src/tools/scripts/ppeCreateAttrGetSetMacros.pl b/src/tools/scripts/ppeCreateAttrGetSetMacros.pl
new file mode 100755
index 00000000..72ae2aa8
--- /dev/null
+++ b/src/tools/scripts/ppeCreateAttrGetSetMacros.pl
@@ -0,0 +1,571 @@
+#!/usr/bin/perl -w
+# IBM_PROLOG_BEGIN_TAG
+# This is an automatically generated prolog.
+#
+# $Source: src/tools/scripts/ppeCreateAttrGetSetMacros.pl $
+#
+# OpenPOWER sbe Project
+#
+# Contributors Listed Below - COPYRIGHT 2015,2016
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+#
+# IBM_PROLOG_END_TAG
+#find enums in AttributeId
+#for each enum check for ${enum}_Type
+#check for type and array values
+#Check Plat file for ${enum}_GETMACRO and ${enum}_SETMACRO
+#If they do not exist add apporpriate _SETMACRO and _GETMACRO to Plat file
+
+use strict;
+use File::Copy;
+use Getopt::Long;
+
+sub enumParser ($);
+sub help;
+
+my $DEBUG = 0;
+my $VERBOSE = 0;
+
+my $state = 0;
+my $last_value = -1;
+my $current_entry;
+my $current_enum_name;
+
+my %enums;
+
+my %attributeTypes;
+my %attributeArrayTypes;
+
+my %getMacros;
+my %setMacros;
+my %targetMacros;
+
+
+
+my $fapiAttributeIdsFile = "fapi2AttributeIds.H";
+my $fapiPlatAttributeServiceFile= "fapi2PlatAttributeService.H";
+
+
+my $includePath = "./";
+my $srcPath = "./";
+
+my @newAttributeDefines;
+my @newTargetDefines;
+my @newTargetImplementations;
+
+
+my $servicePath;
+my $help;
+
+GetOptions ("verbose" => \$VERBOSE,
+            "help" => \$help,
+            "debug" => \$DEBUG,
+            "path=s" => \$servicePath,
+            "inc=s" => \$includePath,
+            "src=s" => \$srcPath,
+);
+
+help() if $help;
+
+open (FILE, $includePath . "/" . $fapiAttributeIdsFile) or die "ERROR:: could not open $fapiAttributeIdsFile\n";
+
+while (<FILE>) {
+  # attempt to parse attributes from current line in file
+  enumParser($_);
+
+  # see if the line describes an attribute
+  if (m/\s*typedef\s+(\w+)\s+(\w+)_Type(\S*)\s*;/) {
+    my $type = $1;
+    my $attribute = $2;
+    my $arrayType = $3;
+
+    if ($DEBUG) { print "DEBUG:: type = $type : attribute = $attribute : arrayType = $arrayType\n"; }
+
+    # save attribute type and if it is an array and its size
+    $attributeTypes{$attribute} = $type;
+    if ($arrayType) {
+      $attributeArrayTypes{$attribute} = $arrayType;
+    } else {
+      $attributeArrayTypes{$attribute} = "none";
+    }
+  }
+
+  # look for MACROs
+  # look for: #define ATTR_CHIP_HAS_SBE_GETMACRO ATTRIBUTE_NOT_WRITABLE
+  if (m/\s*#define\s+(\w+)_GETMACRO\s+(\S+)\s*/) {
+    $getMacros{$1} = $2;
+    if ($DEBUG) { print "DEBUG:: attribute = $1 : GETMACRO = $2\n"; }
+  # look for: #define ATTR_CHIP_EC_FEATURE_TEST1_GETMACRO(ID, PTARGET, VAL) fapi::fapiQueryChipEcFeature(ID, PTARGET, VAL)
+  } elsif (m/\s*#define\s+(\w+)_GETMACRO\(ID\,\sPTARGET\,\sVAL\)\s(.+)/) {
+    $getMacros{$1} = $2;
+    if ($DEBUG) { print "DEBUG:: attribute = $1 : GETMACRO = $2\n"; }
+  # look for: #define ATTR_CHIP_HAS_SBE_SETMACRO ATTRIBUTE_NOT_WRITABLE
+  } elsif (m/\s*#define\s+(\w+)_SETMACRO\s+(\S+)\s*/) {
+    $setMacros{$1} = $2;
+    if ($DEBUG) { print "DEBUG:: attribute = $1 : SETMACRO = $2\n"; }
+  # look for: #define ATTR_CHIP_EC_FEATURE_TEST2_SETMACRO(ID, PTARGET, VAL) CHIP_EC_FEATURE_ATTRIBUTE_NOT_WRITABLE
+  } elsif (m/\s*#define\s+(\w+)_SETMACRO\(ID\,\sPTARGET\,\sVAL\)\s(.+)/) {
+    $setMacros{$1} = $2;
+    if ($DEBUG) { print "DEBUG:: attribute = $1 : SETMACRO = $2\n"; }
+  } elsif (m/\s*const\s*TargetType\s+(\w+)_TargetTypes\s*=\s*(\S+)\s*;\s*/) {
+    $targetMacros{$1} = $2;
+#    print "DEBUG:: attribute = $1 : TARGET = $2\n";
+    if ($DEBUG) { print "DEBUG:: attribute = $1 : TARGET = $2\n"; }
+  }
+}
+
+close (FILE);
+
+#find copy of fapiPlatAttributeService.H
+if (!$servicePath) {
+  #$CTEPATH/tools/ecmd/$ECMD_RELEASE/ext/fapi/capi
+  my $ctepath = $ENV{CTEPATH};
+  my $ecmd_release = $ENV{ECMD_RELEASE};
+  if ($DEBUG) { print "DEBUG:: ctepath = $ctepath\n"; }
+  if ($DEBUG) { print "DEBUG:: ecmd_release = $ecmd_release\n"; }
+  if (!$ctepath) {
+    print "ERROR:: environment variable CTEPATH not defined!\n";
+    exit 1;
+  }
+  if (!$ecmd_release) {
+    print "ERROR:: environment variable ECMD_RELEASE not defined!\n";
+    exit 1;
+  }
+  $servicePath = "$ctepath/tools/ecmd/$ecmd_release/ext/fapi/capi";
+}
+
+if ($DEBUG) { print "DEBUG:: servicePath = $servicePath\n"; }
+
+# test that servicePath exists
+if (!-d $servicePath) {
+  print "ERROR:: path $servicePath does not exist!\n";
+  exit 1;
+}
+
+# test that fapiPlatAttributeService.H is in that directory
+if (!-f "$servicePath/$fapiPlatAttributeServiceFile") {
+  print "ERROR:: $fapiPlatAttributeServiceFile does not exist in $servicePath\n";
+  exit 1;
+}
+
+# copy fapiPlatAttributeService.H to local dir
+#my $systemRc = system("cp $servicePath/$fapiPlatAttributeServiceFile $includePath");
+copy("$servicePath/$fapiPlatAttributeServiceFile","$includePath") or die "Copy failed: $!";
+
+#if ($systemRc) {
+#  print "ERROR:: error copying $fapiPlatAttributeServiceFile from $servicePath\n";
+#  exit 1;
+#}
+
+
+
+# look in fapiPlatAttributeService.H for MACROs
+open (FILE, $includePath . "/". $fapiPlatAttributeServiceFile) or die "ERROR:: could not open $fapiPlatAttributeServiceFile\n";
+while (<FILE>) {
+  if (m/\s*#define\s+(\w+)_GETMACRO\s+(\S+)\s*/) {
+    $getMacros{$1} = $2;
+    if ($DEBUG) { print "DEBUG:: attribute = $1 : GETMACRO = $2\n"; }
+  } elsif (m/\s*#define\s+(\w+)_SETMACRO\s+(\S+)\s*/) {
+    $setMacros{$1} = $2;
+    if ($DEBUG) { print "DEBUG:: attribute = $1 : SETMACRO = $2\n"; }
+  } elsif (m/\s*const\s*TargetType\s+(\w+)_TargetTypes\s*=\s*(\S+)\s*;\s*/) {
+    $targetMacros{$1} = $2;
+    if ($DEBUG) { print "DEBUG:: attribute = $1 : TARGET = $2\n"; }
+  }
+}
+close (FILE);
+
+# go through attributes found in file
+for my $attribute (sort keys %{$enums{AttributeId}}) {
+  if ($DEBUG) { print "DEBUG:: attribute = $attribute\n"; }
+  my $type;
+  my $arrayType;
+  my $dimension = 0;
+
+  # check that each attribute has attributeType
+  if ($attributeTypes{$attribute}) {
+    if ($attributeArrayTypes{$attribute}) {
+      $type = $attributeTypes{$attribute};
+      $arrayType = $attributeArrayTypes{$attribute};
+    } else {
+      print "ERROR:: arrayType not found for $attribute\n";
+      next;
+    }
+  } else {
+    print "ERROR:: type not found for $attribute\n";
+    next;
+  }
+
+  # determine if attribute is an array
+  if ($arrayType =~ m/none/) {
+    if ($DEBUG) { print "DEBUG:: $attribute = $type\n"; }
+  } else {
+    # find dimension for array
+    my $tempArrayType = $arrayType;
+    while ($tempArrayType =~ m/\[\d*\].*/) {
+      $dimension++;
+      $tempArrayType =~ s/\[\d*\]//;
+    }
+    if ($DEBUG) { print "DEBUG:: $attribute = $type$arrayType dimension = $dimension\n"; }
+  }
+
+  my $setMacro = $setMacros{$attribute};
+  my $getMacro = $getMacros{$attribute};
+  my $targetMacro = $targetMacros{$attribute};
+
+#  print "$attribute $setMacro $getMacro $targetMacro \n";
+
+  # if an attribute is missing the SET or GET MACRO add to list in insert into file later
+  if (!($getMacro && $setMacro)) {
+    my $macroPrefix = "PLAT_ATTR_";
+    my $macroPostfix = "";
+
+    if ($dimension == 0) {
+      $macroPostfix = "_GLOBAL_INT";
+    } else {
+      if ($type =~ m/uint8_t/) {
+        $macroPostfix = "_UINT8_" . $dimension . "D_ARRAY";
+      } elsif ($type =~ m/uint16_t/) {
+        $macroPostfix = "_UINT16_" . $dimension . "D_ARRAY";
+      } elsif ($type =~ m/uint32_t/) {
+        $macroPostfix = "_UINT32_" . $dimension . "D_ARRAY";
+      } elsif ($type =~ m/uint64_t/) {
+        $macroPostfix = "_UINT64_" . $dimension . "D_ARRAY";
+      } elsif ($type =~ m/int8_t/) {
+        $macroPostfix = "_INT8_" . $dimension . "D_ARRAY";
+      } elsif ($type =~ m/int16_t/) {
+        $macroPostfix = "_INT16_" . $dimension . "D_ARRAY";
+      } elsif ($type =~ m/int32_t/) {
+        $macroPostfix = "_INT32_" . $dimension . "D_ARRAY";
+      } elsif ($type =~ m/int64_t/) {
+        $macroPostfix = "_INT64_" . $dimension . "D_ARRAY";
+      } else {
+        print "ERROR:: unknown type $type for attribute $attribute\n";
+        next;
+      }
+    }
+
+    my $macroTarget = "";
+    if(defined $targetMacro) {
+        if($targetMacro eq "TARGET_TYPE_SYSTEM") {
+            $macroTarget = "SystemAttributes_t";
+        } elsif ($targetMacro eq "TARGET_TYPE_PROC_CHIP") {
+            $macroTarget = "ProcChipAttributes_t";
+        } elsif ($targetMacro eq "TARGET_TYPE_CORE") {
+            $macroTarget = "CoreAttributes_t";
+        } elsif ($targetMacro eq "TARGET_TYPE_EX") {
+            $macroTarget = "EXAttributes_t";
+        } elsif ($targetMacro eq "TARGET_TYPE_EQ") {
+            $macroTarget = "EQAttributes_t";
+        } elsif ($targetMacro eq "TARGET_TYPE_PERV") {
+            $macroTarget = "PervAttributes_t";
+        } else {
+        print "ERROR:: unknown type $targetMacro for attribute $attribute\n";
+        next;
+      }
+    }
+
+    if (!$getMacro) {
+      if ($VERBOSE) { print "INFO:: did not find ${attribute}_GETMACRO\n"; }
+      my $attributeDefine = "#define ${attribute}_GETMACRO ${macroPrefix}GET${macroPostfix}";
+      push(@newAttributeDefines, $attributeDefine);
+
+      if(defined $targetMacro) {
+
+
+          my $targetFunction = "template<> inline void __get<fapi2::$targetMacro, fapi2attr::$macroTarget, $type, fapi2::${attribute}>   ( const fapi2::Target<fapi2::$targetMacro>& i_ptarget, const fapi2attr::$macroTarget* object, const fapi2::AttributeId attrid, $type* o_pvalue )";
+          push(@newTargetDefines, $targetFunction . ";");
+
+          my $targetImplementation = "";
+          if($targetMacro eq "TARGET_TYPE_PROC_CHIP" | $targetMacro eq "TARGET_TYPE_SYSTEM") {
+
+              $targetImplementation .= "\n" . $targetFunction . "\n{\n   *o_pvalue = object->fapi2attr::${macroTarget}::${attribute};\n}\n";
+
+          } elsif($targetMacro eq "TARGET_TYPE_PERV") {
+
+              $targetImplementation .= "\n" . $targetFunction .
+"\n{
+    *o_pvalue = object->fapi2attr::${macroTarget}::${attribute}[getPervAttrIndex(i_ptarget)];
+}\n";
+
+          } else {
+$targetImplementation .= "\n" . $targetFunction . "\n{\n   uint32_t index = i_ptarget.getTargetNumber();\n   *o_pvalue = object->fapi2attr::${macroTarget}::${attribute}[index];\n}\n"
+          }
+          push(@newTargetImplementations, $targetImplementation);
+      }
+    }
+    if (!$setMacro) {
+      if ($VERBOSE) { print "INFO:: did not find ${attribute}_SETMACRO\n"; }
+      my $attributeDefine = "#define ${attribute}_SETMACRO ${macroPrefix}SET${macroPostfix}";
+      push(@newAttributeDefines, $attributeDefine);
+
+      if(defined $targetMacro) {
+
+          my $targetFunction = "template<> inline void __set<fapi2::$targetMacro, fapi2attr::$macroTarget, $type, fapi2::${attribute}>   ( const fapi2::Target<fapi2::$targetMacro>& i_ptarget, fapi2attr::$macroTarget* object, const fapi2::AttributeId attrid,  const $type& i_pvalue )";
+          push(@newTargetDefines, $targetFunction . ";");
+
+          my $targetImplementation = "";
+
+          if($targetMacro eq "TARGET_TYPE_PROC_CHIP" | $targetMacro eq "TARGET_TYPE_SYSTEM") {
+
+              $targetImplementation = "\n" . $targetFunction . "\n{\n  object->fapi2attr::${macroTarget}::${attribute} = i_pvalue;\n}\n";
+          } else {
+              $targetImplementation = "\n" . $targetFunction . "\n{\n   uint32_t index = i_ptarget.getTargetNumber();\n   object->fapi2attr::${macroTarget}::${attribute}[index] = i_pvalue;\n}\n";
+          }
+
+          push(@newTargetImplementations, $targetImplementation);
+      }
+    }
+  }
+}
+
+# if file is missing any GET or SET MACROs
+if (@newAttributeDefines != 0) {
+
+  my $updatedFapiPlatAttributeServiceFile = "$fapiPlatAttributeServiceFile.temp";
+  open (OUTFILE, ">$updatedFapiPlatAttributeServiceFile") or die "ERROR:: could not open $updatedFapiPlatAttributeServiceFile\n";
+  open (FILE, $includePath . "/" . $fapiPlatAttributeServiceFile) or die "ERROR:: could not open $fapiPlatAttributeServiceFile\n";
+
+  my $insertTagFound = 0;
+
+  while (<FILE>) {
+    print OUTFILE $_;
+    # search for tag to insert after
+    if (m/\/\*.*INSERT NEW ATTRIBUTES HERE.*\*\//) {
+      $insertTagFound = 1;
+      # insert missing GET or SET MACROs
+      print OUTFILE "\n";
+      foreach my $attributeDefine (@newAttributeDefines) {
+        print OUTFILE "$attributeDefine\n";
+        if ($VERBOSE) { print "INFO:: adding $attributeDefine\n"; }
+      }
+    }
+
+    if (m/\/\*.*INSERT NEW GETTER AND SETTER FUNCTIONS HERE.*\*\//) {
+
+      $insertTagFound = 1;
+      # insert missing GET or SET MACROs
+      print OUTFILE "\n";
+      foreach my $targetDefine (@newTargetDefines) {
+        print OUTFILE "$targetDefine\n";
+        if ($VERBOSE) { print "INFO:: adding getter setter method\n"; }
+      }
+        print OUTFILE "
+        __attribute__((always_inline)) inline uint32_t getPervAttrIndex(const fapi2::Target<TARGET_TYPE_PERV> &i_target)
+        {
+            uint32_t l_index = i_target.getTargetNumber();
+            if(PPE_TARGET_TYPE_EQ & i_target.getTargetType())
+            {
+                l_index += (EQ_TARGET_OFFSET);
+            }
+            else if(PPE_TARGET_TYPE_CORE & i_target.getTargetType())
+            {
+                l_index += (CORE_TARGET_OFFSET);
+            }
+            else if(PPE_TARGET_TYPE_MCBIST & i_target.getTargetType())
+            {
+                l_index += (MCBIST_TARGET_OFFSET);
+            }
+            else
+            {
+                l_index += (NEST_GROUP1_TARGET_OFFSET);
+            }
+            return (l_index - NEST_GROUP1_TARGET_OFFSET);
+        }
+        ";
+
+
+      foreach my $impl (@newTargetImplementations) {
+
+          print OUTFILE $impl;
+
+      }
+    }
+
+
+  }
+  close (FILE);
+  close (OUTFILE);
+
+  if ($insertTagFound == 0) {
+    # remove file that we did not update
+    system("rm $updatedFapiPlatAttributeServiceFile");
+    print ("WARNING:: did not find tag \"INSERT NEW ATTRIBUTES HERE\" in $fapiPlatAttributeServiceFile. no updates performed.\n");
+  } else {
+    # copy new file over the old one
+    system("mv $updatedFapiPlatAttributeServiceFile $includePath/$fapiPlatAttributeServiceFile");
+  }
+}
+
+
+
+
+exit;
+
+# enumParser state machine
+#     "enum"      "enum_name"      "{"        "entry"          "}"
+# [0] ------> [1] -------------> [2] ---> [3] -----------> [4] -------------------------------------> [7]
+#                                                      ","     "="       "value"       "}"
+#                                         [3] <----------- [4] ----> [5] --------> [6] -------------> [7]
+#                                              "}"                                                        ";"
+#                                         [3]  -----------------------------------------------------> [7] ---> [0]
+#                                                                              ","
+#
+#                                         [3] <----------------------------------- [6]
+#
+
+sub enumParser ($){
+  my $line = $_[0];
+  chomp($line);
+
+  if ($DEBUG) { print "DEBUG:: state = $state : line = \"$line\"\n"; }
+
+  if ($state == 0) {
+    # find enum as first word
+    if ($line =~ m/\s*enum\s*.*/) {
+      if ($DEBUG) { print "DEBUG:: found enum in $line\n"; }
+      $state = 1;
+      # reset last_value
+      $last_value = -1;
+      # reset current_entry
+      $current_entry = "";
+      # reset current_enum_name;
+      $current_enum_name = "";
+      # remove enum from line recheck
+      $line =~ s/\s*enum\s*//;
+      enumParser($line);
+    }
+  } elsif ($state == 1) {
+    # find ENUM_NAME as first word
+    if ($line =~ m/\s*(\w+)\s*.*/) {
+      if ($DEBUG) { print "DEBUG:: found ENUM_NAME $1 in $line\n"; }
+      $state = 2;
+      my $enum_name = $1;
+      $current_enum_name = $enum_name;
+      # remove ENUM_NAME from line
+      $line =~ s/\s*$enum_name\s*//;
+      #recheck
+      enumParser($line);
+    }
+  } elsif ($state == 2) {
+    # find { as first word
+    if ($line =~ m/\s*{\s*.*/) {
+      if ($DEBUG) { print "DEBUG:: found { in $line\n"; }
+      $state = 3;
+      # remove { from line recheck
+      $line =~ s/\s*{\s*//;
+      enumParser($line);
+    }
+  } elsif ($state == 3) {
+    # find ENTRY as first word
+    if ($line =~ m/\s*(\w+)\s*.*/) {
+      if ($DEBUG) { print "DEBUG:: found ENTRY $1 in $line\n"; }
+      my $entry = $1;
+      $current_entry = $entry;
+      # remove ENTRY from line
+      $line =~ s/\s*$entry\s*//;
+      $state = 4;
+      #recheck
+      enumParser($line);
+    }
+    # find } as first word
+    elsif ($line =~ m/\s*}\s*.*/) {
+      if ($DEBUG) { print "DEBUG:: found } in $line\n"; }
+      $state = 7;
+      # remove } from line recheck
+      $line =~ s/\s*}\s*//;
+      enumParser($line);
+    }
+  } elsif ($state == 4) {
+    # find = as first word
+    if ($line =~ m/\s*=\s*.*/) {
+      if ($DEBUG) { print "DEBUG:: found = in $line\n"; }
+      $state = 5;
+      # remove = from line recheck
+      $line =~ s/\s*=\s*//;
+      enumParser($line);
+    }
+    # find , as first word
+    elsif ($line =~ m/\s*,\s*.*/) {
+      if ($DEBUG) { print "DEBUG:: found , in $line\n"; }
+      $state = 3;
+      # assign next last_value to entry
+      $last_value++;
+      my $value = $last_value;
+      if ($DEBUG) { print "DEBUG:: default VALUE $value assigned to $current_entry\n"; }
+      $enums{$current_enum_name}{$current_entry} = $value;
+      # remove , from line recheck
+      $line =~ s/\s*,\s*//;
+      enumParser($line);
+    }
+    # find } as first word
+    elsif ($line =~ m/\s*}\s*.*/) {
+      if ($DEBUG) { print "DEBUG:: found } in $line\n"; }
+      $state = 7;
+      # remove } from line recheck
+      $line =~ s/\s*}\s*//;
+      enumParser($line);
+    }
+  } elsif ($state == 5) {
+    # find VALUE as first word
+    if ($line =~ m/\s*(\w+)\s*.*/) {
+      if ($DEBUG) { print "DEBUG:: found VALUE $1 in $line\n"; }
+      my $value = $1;
+      $last_value = $value;
+      # assign value to entry
+      if ($DEBUG) { print "DEBUG:: VALUE $value assigned to $current_entry\n"; }
+      $enums{$current_enum_name}{$current_entry} = $value;
+      # remove VALUE from line
+      $line =~ s/\s*$value\s*//;
+      $state = 6;
+      #recheck
+      enumParser($line);
+    }
+  } elsif ($state == 6) {
+    # find , as first word
+    if ($line =~ m/\s*,\s*.*/) {
+      if ($DEBUG) { print "DEBUG:: found , in $line\n"; }
+      $state = 3;
+      # remove , from line recheck
+      $line =~ s/\s*,\s*//;
+      enumParser($line);
+    }
+    # find } as first word
+    elsif ($line =~ m/\s*}\s*.*/) {
+      if ($DEBUG) { print "DEBUG:: found } in $line\n"; }
+      $state = 7;
+      # remove } from line recheck
+      $line =~ s/\s*}\s*//;
+      enumParser($line);
+    }
+  } elsif ($state == 7) {
+    # find ; as first word
+    if ($line =~ m/\s*;\s*.*/) {
+      if ($DEBUG) { print "DEBUG:: found ; in $line\n"; }
+      $state = 0;
+      # remove ; from line recheck
+      $line =~ s/\s*;\s*//;
+      enumParser($line);
+    }
+  }
+}
+
+sub help {
+  printf("Usage:  ppeCreateAttrGetSetMacros.pl [--path <pathToFapiHeaders>] [--verbose] [--help] [--src <pathToFapiTemplate>] [--inc <pathToFapiOutput]\n");
+  printf("-path <pathToFapiHeaders>     Option to enable specifying alternate path to fapi headers\n");
+  printf("-v | -verbose     Inform user of findings and changes\n");
+  printf("-h | -help        print this message\n");
+  exit(0);
+}
diff --git a/src/tools/scripts/ppeCreateIfAttrService.pl b/src/tools/scripts/ppeCreateIfAttrService.pl
new file mode 100755
index 00000000..1202505a
--- /dev/null
+++ b/src/tools/scripts/ppeCreateIfAttrService.pl
@@ -0,0 +1,240 @@
+#!/usr/bin/perl
+# IBM_PROLOG_BEGIN_TAG
+# This is an automatically generated prolog.
+#
+# $Source: src/tools/scripts/ppeCreateIfAttrService.pl $
+#
+# OpenPOWER sbe Project
+#
+# Contributors Listed Below - COPYRIGHT 2016
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+#
+# IBM_PROLOG_END_TAG
+# Purpose:  This perl script will parse HWP Attribute XML files and
+# initfile attr files and create the fapiGetInitFileAttr() function
+# in a file called fapi2AttributeService.C
+
+use strict;
+
+#------------------------------------------------------------------------------
+# Print Command Line Help
+#------------------------------------------------------------------------------
+my $numArgs = $#ARGV + 1;
+if ($numArgs < 3)
+{
+    print ("Usage: fapi2CreateIfAttrService.pl <output dir>\n");
+    print ("           [<if-attr-file1> <if-attr-file2> ...]\n");
+    print ("           -a <attr-xml-file1> [<attr-xml-file2> ...]\n");
+    print ("  This perl script will parse if-attr files (containing the\n");
+    print ("  attributes used by the initfile) and attribute XML files\n");
+    print ("  (containing all HWPF attributes) and create the\n");
+    print ("  fapiGetInitFileAttr() function in a file called\n");
+    print ("  fapiAttributeService.C. Only the attributes specified in\n");
+    print ("  the if-attr files are supported. If no if-attr files are\n");
+    print ("  specified then all attributes are supported\n");
+    exit(1);
+}
+
+#------------------------------------------------------------------------------
+# Specify perl modules to use
+#------------------------------------------------------------------------------
+use XML::Simple;
+my $xml = new XML::Simple (KeyAttr=>[]);
+
+# Uncomment to enable debug output
+#use Data::Dumper;
+
+#------------------------------------------------------------------------------
+# Open output file for writing
+#------------------------------------------------------------------------------
+my $asFile = $ARGV[0];
+$asFile .= "/";
+$asFile .= "fapi2AttributeService.C";
+open(ASFILE, ">", $asFile);
+
+#------------------------------------------------------------------------------
+# Print Start of file information to fapiAttributeService.C
+#------------------------------------------------------------------------------
+print ASFILE "// fapi2AttributeService.C\n";
+print ASFILE "// This file is generated by perl script fapi2CreateIfAttrService.pl\n\n";
+print ASFILE "#include <fapi2AttributeService.H>\n";
+print ASFILE "//#include <fapi2ChipEcFeature.H>\n";
+print ASFILE "//#include <fapi2PlatTrace.H>\n\n";
+print ASFILE "namespace fapi2\n";
+print ASFILE "{\n\n";
+print ASFILE "ReturnCode fapiGetInitFileAttr(const AttributeId i_id,\n";
+print ASFILE "                               const Target * i_pTarget,\n";
+print ASFILE "                               uint64_t & o_val,\n";
+print ASFILE "                               const uint32_t i_arrayIndex1,\n";
+print ASFILE "                               const uint32_t i_arrayIndex2,\n";
+print ASFILE "                               const uint32_t i_arrayIndex3,\n";
+print ASFILE "                               const uint32_t i_arrayIndex4)\n";
+print ASFILE "{\n";
+print ASFILE "    ReturnCode l_rc;\n\n";
+
+my $xmlFiles = 0;
+my $attCount = 0;
+my $numIfAttrFiles = 0;
+my @attrIds;
+
+#------------------------------------------------------------------------------
+# Element names
+#------------------------------------------------------------------------------
+my $attribute = 'attribute';
+
+#------------------------------------------------------------------------------
+# For each argument
+#------------------------------------------------------------------------------
+my $argfile = $ARGV[1];
+my $entries = $xml->XMLin($argfile, ForceArray => ['entry']);
+foreach my $entr (@{$entries->{entry}}) {
+
+    my $inname = $entr->{name};
+
+    # read XML file. The ForceArray option ensures that there is an array of
+    # elements even if there is only one such element in the file
+
+    foreach my $argnum (2 .. $#ARGV)
+    {
+        my $infile = $ARGV[$argnum];
+
+        my $attributes = $xml->XMLin($infile, ForceArray => ['attribute']);
+
+        # Uncomment to get debug output of all attributes
+        #print "\nFile: ", $infile, "\n", Dumper($attributes), "\n";
+
+        #--------------------------------------------------------------------------
+        # For each Attribute
+        #--------------------------------------------------------------------------
+        foreach my $attr (@{$attributes->{attribute}})
+        {
+
+
+
+            if($attr->{id} eq $inname) {
+
+            #------------------------------------------------------------------
+            # Check that the AttributeId exists
+            #------------------------------------------------------------------
+            if (! exists $attr->{id})
+            {
+                print ("fapiParseAttributeInfo.pl ERROR. Att 'id' missing\n");
+                exit(1);
+            }
+
+
+            #------------------------------------------------------------------
+            # Figure out the number of attribute array dimensions
+            #------------------------------------------------------------------
+            my $numArrayDimensions = 0;
+            if ($attr->{array})
+            {
+                # Remove leading whitespace
+                my $dimText = $attr->{array};
+                $dimText =~ s/^\s+//;
+
+                # Split on commas or whitespace
+                my @vals = split(/\s*,\s*|\s+/, $dimText);
+
+                $numArrayDimensions=@vals;
+            }
+
+            #------------------------------------------------------------------
+            # Print the attribute get code to fapiAttributeService.C
+            #------------------------------------------------------------------
+            if ($attCount > 0)
+            {
+                print ASFILE "    else ";
+            }
+            else
+            {
+                print ASFILE "    ";
+            }
+            $attCount++;
+
+            print ASFILE "if (i_id == $attr->{id})\n";
+            print ASFILE "    {\n"; 
+            print ASFILE "        $attr->{id}_Type l_attr;\n";
+
+            if (exists $attr->{privileged})
+            {
+                print ASFILE "        l_rc = FAPI_ATTR_GET_PRIVILEGED($attr->{id}, i_pTarget, l_attr);\n";
+            }
+            else
+            {
+                print ASFILE "        l_rc = FAPI_ATTR_GET($attr->{id}, i_pTarget, l_attr);\n";
+            }
+            print ASFILE "        o_val = l_attr";
+
+            if ($numArrayDimensions >= 5)
+            {
+                print ("fapiParseAttributeInfo.pl ERROR. More than 4 array dimensions!!\n");
+                exit(1);
+            }
+            else
+            {
+                for (my $i = 0; $i < $numArrayDimensions; $i++)
+                {
+                    print ASFILE "[i_arrayIndex";
+                    print ASFILE $i+1;
+                    print ASFILE "]";
+                }
+            }
+
+            print ASFILE ";\n";
+            print ASFILE "    }\n";
+                
+
+
+            }
+        }
+    }
+
+}
+
+#------------------------------------------------------------------------------
+# Print End of file information to fapiAttributeService.C
+#--------------------------------------------------------------------------
+if ($attCount > 0)
+{
+    print ASFILE "    else\n";
+}
+print ASFILE "    {\n";
+print ASFILE "        FAPI_ERR(\"fapiGetInitFileAttr: Unrecognized attr ID: 0x%x\", i_id);\n";
+print ASFILE "        l_rc.setFapiError(FAPI_RC_INVALID_ATTR_GET);\n";
+print ASFILE "        l_rc.addEIFfdc(0, &i_id, sizeof(i_id));\n";
+print ASFILE "    }\n\n";
+print ASFILE "    if (l_rc)\n";
+print ASFILE "    {\n";
+print ASFILE "        if (i_pTarget)\n";
+print ASFILE "        {\n";
+print ASFILE "            FAPI_ERR(\"fapiGetInitFileAttr: Error getting attr ID 0x%x from targType 0x%x\",\n";
+print ASFILE "                     i_id, i_pTarget->getType());\n";
+print ASFILE "        }\n";
+print ASFILE "        else\n";
+print ASFILE "        {\n";
+print ASFILE "            FAPI_ERR(\"fapiGetInitFileAttr: Error getting attr ID 0x%x from system target\",\n";
+print ASFILE "                     i_id);\n";
+print ASFILE "        }\n";
+print ASFILE "    }\n\n";
+print ASFILE "    return l_rc;\n";
+print ASFILE "}\n\n";
+print ASFILE "}\n";
+
+
+#------------------------------------------------------------------------------
+# Close output file
+#------------------------------------------------------------------------------
+close(ASFILE);
diff --git a/src/tools/scripts/ppeParseAttrGetSetMacros.pl b/src/tools/scripts/ppeParseAttrGetSetMacros.pl
new file mode 100644
index 00000000..013cad96
--- /dev/null
+++ b/src/tools/scripts/ppeParseAttrGetSetMacros.pl
@@ -0,0 +1,286 @@
+#!/usr/bin/perl
+# IBM_PROLOG_BEGIN_TAG
+# This is an automatically generated prolog.
+#
+# $Source: src/tools/scripts/ppeParseAttrGetSetMacros.pl $
+#
+# OpenPOWER sbe Project
+#
+# Contributors Listed Below - COPYRIGHT 2016
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+#
+# IBM_PROLOG_END_TAG
+# Purpose:  This perl script will parse HWP Attribute XML files and
+# initfile attr files and create the fapiGetInitFileAttr() function
+# in a file called fapiAttributeService.C
+
+use strict;
+
+#------------------------------------------------------------------------------
+# Print Command Line Help
+#------------------------------------------------------------------------------
+my $numArgs = $#ARGV + 1;
+if ($numArgs < 3)
+{
+    print ("Usage: ppeParseAttrGetSetMacros.pl <output dir>\n");
+    print ("           [<if-attr-file1> <if-attr-file2> ...]\n");
+    print ("           -a <attr-xml-file1> [<attr-xml-file2> ...]\n");
+    print ("  This perl script will parse if-attr files (containing the\n");
+    print ("  attributes used by the initfile) and attribute XML files\n");
+    print ("  (containing all HWPF attributes) and create the\n");
+    print ("  fapiGetInitFileAttr() function in a file called\n");
+    print ("  fapiAttributeService.C. Only the attributes specified in\n");
+    print ("  the if-attr files are supported. If no if-attr files are\n");
+    print ("  specified then all attributes are supported\n");
+    exit(1);
+}
+
+#------------------------------------------------------------------------------
+# Specify perl modules to use
+#------------------------------------------------------------------------------
+use XML::Simple;
+my $xml = new XML::Simple (KeyAttr=>[]);
+
+# Uncomment to enable debug output
+#use Data::Dumper;
+
+#------------------------------------------------------------------------------
+# Open output file for writing
+#------------------------------------------------------------------------------
+my $chipFile = $ARGV[0];
+$chipFile .= "/";
+$chipFile .= "proc_sbe_fixed_proc_chip.H";
+open(CHFILE, ">", $chipFile);
+
+my $exFile = $ARGV[0];
+$exFile .= "/";
+$exFile .= "proc_sbe_fixed_ex.H";
+open(EXFILE, ">", $exFile);
+
+my $coreFile = $ARGV[0];
+$coreFile .= "/";
+$coreFile .= "proc_sbe_fixed_core.H";
+open(COFILE, ">", $coreFile);
+
+my $eqFile = $ARGV[0];
+$eqFile .= "/";
+$eqFile .= "proc_sbe_fixed_eq.H";
+open(EQFILE, ">", $eqFile);
+
+my $pervFile = $ARGV[0];
+$pervFile .= "/";
+$pervFile .= "proc_sbe_fixed_perv.H";
+open(PEFILE, ">", $pervFile);
+
+
+#------------------------------------------------------------------------------
+# Print Start of file information to fapiAttributeService.C
+#------------------------------------------------------------------------------
+#print ASFILE "// proc_sbe_func.H\n";
+#print ASFILE "// This file is generated by perl script fapi2ParseProcSbeFixed.pl\n\n";
+#print ASFILE "#ifndef __PROC_SBE_FIXED_H__\n";
+#print ASFILE "#define __PROC_SBE_FIXED_H__\n";
+#print ASFILE "#include \"p9_sbe.H\"\n";
+#print ASFILE "#include \"plat_target_parms.H\"\n";
+#print ASFILE "#include \"fapi2AttributeIds.H\"\n\n";
+
+
+my $xmlFiles = 0;
+my $attCount = 0;
+my $numIfAttrFiles = 0;
+my @attrSystemIds;
+my @attrChipIds;
+my @attrExIds;
+my @attrCoreIds;
+my @attrEqIds;
+my @attrPervIds;
+
+
+
+#------------------------------------------------------------------------------
+# Element names
+#------------------------------------------------------------------------------
+my $attribute = 'attribute';
+
+#------------------------------------------------------------------------------
+# For each argument
+#------------------------------------------------------------------------------
+my $argfile = $ARGV[1];
+my $entries = $xml->XMLin($argfile, ForceArray => ['entry']);
+foreach my $entr (@{$entries->{entry}}) {
+
+    my $inname = $entr->{name};
+
+    # read XML file. The ForceArray option ensures that there is an array of
+    # elements even if there is only one such element in the file
+
+    foreach my $argnum (2 .. $#ARGV)
+    {
+        my $infile = $ARGV[$argnum];
+
+        my $attributes = $xml->XMLin($infile, ForceArray => ['attribute']);
+
+        # Uncomment to get debug output of all attributes
+        #print "\nFile: ", $infile, "\n", Dumper($attributes), "\n";
+
+        #--------------------------------------------------------------------------
+        # For each Attribute
+        #--------------------------------------------------------------------------
+        foreach my $attr (@{$attributes->{attribute}})
+        {
+
+            if($attr->{id} eq $inname) {
+
+            #------------------------------------------------------------------
+            # Check that the AttributeId exists
+            #------------------------------------------------------------------
+            if (! exists $attr->{id})
+            {
+                print ("ppeParseGetSetMacros.pl ERROR. Att 'id' missing\n");
+                exit(1);
+            }
+
+            if($attr->{targetType} eq "TARGET_TYPE_SYSTEM") {
+
+                push(@attrSystemIds, $attr);
+
+            } elsif($attr->{targetType} eq "TARGET_TYPE_PROC_CHIP") {
+
+                push(@attrChipIds, $attr);
+
+            } elsif($attr->{targetType} eq "TARGET_TYPE_CORE") {
+
+                push(@attrCoreIds, $attr);
+
+            } elsif($attr->{targetType} eq "TARGET_TYPE_EQ") {
+
+                push(@attrEqIds, $attr);
+
+            } elsif($attr->{targetType} eq "TARGET_TYPE_EX") {
+
+                push(@attrExIds, $attr);
+
+            } elsif($attr->{targetType} eq "TARGET_TYPE_PERV") {
+
+#                push(@attrPervIds, $attr->{id});
+                push(@attrPervIds, $attr);
+
+            } else {
+
+                print ("ppeParseAttrGetSetMacros.pl ERROR. Wrong attribute type: $attr->{targetType}\n");
+                exit(1);
+
+            }
+
+            }
+        }
+    }
+}
+
+print SYFILE "// proc_sbe_fixed_system.H\n";
+print SYFILE "// This file is generated by perl script ppeParseAttrGetSetMacros.pl\n\n";
+print SYFILE "#ifndef __PROC_SBE_FIXED_SYSTEM_H__\n";
+print SYFILE "#define __PROC_SBE_FIXED_SYSTEM_H__\n\n";
+foreach my $attr (@attrSystemIds)
+{
+
+    my $value = uc $attr->{valueType};
+    print SYFILE "PROC_SBE_FIXED_$value($attr->{id});\n"
+
+
+}
+print SYFILE "\n#endif  // __PROC_SBE_FIXED_SYSTEM_H__";
+
+print CHFILE "// proc_sbe_fixed_proc_chip.H\n";
+print CHFILE "// This file is generated by perl script ppeParseAttrGetSetMacros.pl\n\n";
+print CHFILE "#ifndef __PROC_SBE_FIXED_PROC_CHIP_H__\n";
+print CHFILE "#define __PROC_SBE_FIXED_PROC_CHIP_H__\n\n";
+foreach my $attr (@attrChipIds)
+{
+
+    my $value = uc $attr->{valueType};
+    print CHFILE "PROC_SBE_FIXED_$value($attr->{id});\n"
+
+
+}
+print CHFILE "\n#endif  // __PROC_SBE_FIXED_PROC_CHIP_H__";
+
+print EXFILE "// proc_sbe_fixed_ex.H\n";
+print EXFILE "// This file is generated by perl script ppeParseAttrGetSetMacros.pl\n\n";
+print EXFILE "#ifndef __PROC_SBE_FIXED_EX_H__\n";
+print EXFILE "#define __PROC_SBE_FIXED_EX_H__\n";
+foreach my $attr (@attrExIds)
+{
+
+    my $value = uc $attr->{valueType};
+    print EXFILE "PROC_SBE_FIXED_TARGET_$value($attr->{id}, EX_TARGET_COUNT);\n"
+
+
+}
+print EXFILE "\n#endif  // __PROC_SBE_FIXED_EX_H__";
+
+print COFILE "// proc_sbe_fixed_co.H\n";
+print COFILE "// This file is generated by perl script ppeParseAttrGetSetMacros.pl\n\n";
+print COFILE "#ifndef __PROC_SBE_FIXED_CO_H__\n";
+print COFILE "#define __PROC_SBE_FIXED_CO_H__\n";
+foreach my $attr (@attrCoreIds)
+{
+
+    my $value = uc $attr->{valueType};
+    print COFILE "PROC_SBE_FIXED_TARGET_$value($attr->{id}, CORE_TARGET_COUNT);\n"
+
+
+}
+print COFILE "\n#endif  // __PROC_SBE_FIXED_CO_H__";
+
+print EQFILE "// proc_sbe_fixed_eq.H\n";
+print EQFILE "// This file is generated by perl script ppeParseAttrGetSetMacros.pl\n\n";
+print EQFILE "#ifndef __PROC_SBE_FIXED_EQ_H__\n";
+print EQFILE "#define __PROC_SBE_FIXED_EQ_H__\n";
+foreach my $attr (@attrEqIds)
+{
+
+    my $value = uc $attr->{valueType};
+    print EQFILE "PROC_SBE_FIXED_TARGET_$value($attr->{id}, EQ_TARGET_COUNT);\n"
+
+
+}
+print EQFILE "\n#endif  // __PROC_SBE_FIXED_EQ_H__";
+
+print PEFILE "// proc_sbe_fixed_perv.H\n";
+print PEFILE "// This file is generated by perl script ppeParseAttrGetSetMacros.pl\n\n";
+print PEFILE "#ifndef __PROC_SBE_FIXED_PERV_H__\n";
+print PEFILE "#define __PROC_SBE_FIXED_PERV_H__\n";
+foreach my $attr (@attrPervIds)
+{
+
+    my $value = uc $attr->{valueType};
+    print PEFILE "PROC_SBE_FIXED_TARGET_$value($attr->{id}, PERV_TARGET_COUNT);\n"
+
+
+}
+print PEFILE "\n#endif  // __PROC_SBE_FIXED_PERV_H__";
+
+#print ASFILE "#endif  // __PROC_SBE_FIXED_H__";
+
+#------------------------------------------------------------------------------
+# Close output file
+#------------------------------------------------------------------------------
+close(CHFILE);
+close(COFILE);
+close(EXFILE);
+close(PEFILE);
+close(EQFILE);
+
diff --git a/src/tools/scripts/ppeParseAttributeInfo.pl b/src/tools/scripts/ppeParseAttributeInfo.pl
new file mode 100755
index 00000000..1b881a4d
--- /dev/null
+++ b/src/tools/scripts/ppeParseAttributeInfo.pl
@@ -0,0 +1,746 @@
+#!/usr/bin/perl -w
+# IBM_PROLOG_BEGIN_TAG
+# This is an automatically generated prolog.
+#
+# $Source: src/tools/scripts/ppeParseAttributeInfo.pl $
+#
+# OpenPOWER sbe Project
+#
+# Contributors Listed Below - COPYRIGHT 2015,2016
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+#
+# IBM_PROLOG_END_TAG
+# Purpose:  This perl script will parse HWP Attribute XML files
+# and add attribute information to a file called fapi2AttributeIds.H
+
+use strict;
+
+sub help {
+    print ("Usage: ppeParseAttributeInfo.pl <output dir> <attr-xml-file1> [<attr-xml-file2> ...]\n");
+    print ("  This perl script will parse attribute XML files and create the following files:\n");
+    print ("  - fapi2AttributeIds.H.          Contains IDs, type, value enums and other information\n");
+    print ("  - fapi2ChipEcFeature.C.         Contains a function to query chip EC features\n");
+    print ("  - fapi2AttributePlatCheck.H.    Contains compile time checks that all attributes are\n");
+    print ("                                  handled by the platform\n");
+    print ("  - fapi2AttributesSupported.html Contains the HWPF attributes supported\n");
+    print ("  - fapi2AttrInfo.csv             Used to process Attribute Override Text files\n");
+    print ("  - fapi2AttrEnumInfo.csv         Used to process Attribute Override Text files\n");
+}
+
+my $DEBUG = 0;
+my $VERBOSE = 0;
+my $help = 0;
+
+#------------------------------------------------------------------------------
+# Print Command Line Help
+#------------------------------------------------------------------------------
+my $numArgs = $#ARGV + 1;
+if ($numArgs < 2)
+{
+    print ("Invalid number of arguments\n\n");
+    help();
+    exit(1);
+}
+
+#------------------------------------------------------------------------------
+# Specify perl modules to use
+#------------------------------------------------------------------------------
+use Getopt::Long;
+use Digest::MD5 qw(md5_hex);
+use XML::Simple;
+my $xml = new XML::Simple (KeyAttr=>[]);
+
+GetOptions ("verbose" => \$VERBOSE,
+            "help" => \$help,
+            "debug" => \$DEBUG,
+           );
+
+if ($help)
+{
+    help();
+    exit(0);
+}
+
+if ($DEBUG)
+{
+    print "DEBUG enabled!!!!\n";
+}
+
+# Uncomment to enable debug output
+# use Data::Dumper;
+
+#------------------------------------------------------------------------------
+# Set PREFERRED_PARSER to XML::Parser. Otherwise it uses XML::SAX which contains
+# bugs that result in XML parse errors that can be fixed by adjusting white-
+# space (i.e. parse errors that do not make sense).
+#------------------------------------------------------------------------------
+$XML::Simple::PREFERRED_PARSER = 'XML::Parser';
+
+#------------------------------------------------------------------------------
+# Open output files for writing
+#------------------------------------------------------------------------------
+my $aiFile = $ARGV[0];
+$aiFile .= "/";
+$aiFile .= "fapi2AttributeIds.H";
+open(AIFILE, ">", $aiFile);
+
+my $echFile = $ARGV[0];
+$echFile .= "/";
+$echFile .= "fapi2ChipEcFeature.H";
+open(ECHFILE, ">", $echFile);
+
+my $acFile = $ARGV[0];
+$acFile .= "/";
+$acFile .= "fapi2AttributePlatCheck.H";
+open(ACFILE, ">", $acFile);
+
+my $asFile = $ARGV[0];
+$asFile .= "/";
+$asFile .= "fapi2AttributesSupported.html";
+open(ASFILE, ">", $asFile);
+
+my $itFile = $ARGV[0];
+$itFile .= "/";
+$itFile .= "fapi2AttrInfo.csv";
+open(ITFILE, ">", $itFile);
+
+my $etFile = $ARGV[0];
+$etFile .= "/";
+$etFile .= "fapi2AttrEnumInfo.csv";
+open(ETFILE, ">", $etFile);
+
+#------------------------------------------------------------------------------
+# Print Start of file information to fapiAttributeIds.H
+#------------------------------------------------------------------------------
+print AIFILE "// fapi2AttributeIds.H\n";
+print AIFILE "// This file is generated by perl script fapiParseAttributeInfo.pl\n\n";
+print AIFILE "#ifndef FAPI2ATTRIBUTEIDS_H_\n";
+print AIFILE "#define FAPI2ATTRIBUTEIDS_H_\n\n";
+print AIFILE "#ifndef __ASSEMBLER__\n\n";
+print AIFILE "#include <target.H>\n";
+print AIFILE "#include <target_types.H>\n\n";
+print AIFILE "namespace fapi2\n";
+print AIFILE "{\n\n";
+print AIFILE "\/**\n";
+print AIFILE " * \@brief Enumeration of attribute IDs\n";
+print AIFILE " *\/\n";
+print AIFILE "enum AttributeId\n{\n";
+
+#------------------------------------------------------------------------------
+# Print Start of file information to fapi2_chip_ec_feature.H
+#------------------------------------------------------------------------------
+print ECHFILE "// This file is generated by perl script parseAttributeInfo.pl\n";
+print ECHFILE "// It implements the fapi2_chip_ec_feature function\n\n";
+print ECHFILE "#ifndef __FAPI2_CHIP_EC_FEATURE_H_\n";
+print ECHFILE "#define __FAPI2_CHIP_EC_FEATURE_H_\n";
+print ECHFILE "#include <fapi2AttributeService.H>\n";
+print ECHFILE "#include <fapi2AttributeIds.H>\n";
+print ECHFILE "namespace fapi2\n";
+print ECHFILE "{\n\n";
+print ECHFILE "// create a unique type from an int ( or attribute id) \n";
+print ECHFILE "template<int I>\n";
+print ECHFILE  "struct int2Type {\n";
+print ECHFILE  "enum { value = I };\n";
+print ECHFILE "};\n";
+print ECHFILE "ReturnCode queryChipEcAndName(\n";
+print ECHFILE "                    const Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,\n";
+print ECHFILE "                    fapi2::ATTR_NAME_Type& , fapi2::ATTR_EC_Type & );\n\n";
+print ECHFILE "template<int T>\n";
+print ECHFILE "ReturnCode queryChipEcFeature(int2Type<T> id,\n";
+print ECHFILE "                    const Target<fapi2::TARGET_TYPE_PROC_CHIP>& i_target,\n";
+print ECHFILE "                    uint8_t & o_hasFeature)\n";
+print ECHFILE "{\n";
+print ECHFILE "    fapi2::ATTR_NAME_Type l_chipName;\n";
+print ECHFILE "    fapi2::ATTR_EC_Type l_chipEc;\n\n";
+print ECHFILE "    o_hasFeature = 0;\n\n";
+print ECHFILE "    ReturnCode l_rc = queryChipEcAndName(i_target, l_chipName, l_chipEc);\n";
+print ECHFILE "    if (l_rc)\n";
+print ECHFILE "    {\n";
+print ECHFILE "        FAPI_ERR(\"queryChipEcFeature: error getting chip name\");\n";
+print ECHFILE "    }\n";
+print ECHFILE "    else\n";
+print ECHFILE "    {\n";
+print ECHFILE "        o_hasFeature = hasFeature(int2Type<T>(), l_chipName, l_chipEc);\n";
+print ECHFILE "    }\n";
+print ECHFILE "    return l_rc;\n";
+print ECHFILE "}\n\n";
+
+#------------------------------------------------------------------------------
+# Print Start of file information to fapiAttributePlatCheck.H
+#------------------------------------------------------------------------------
+print ACFILE "// fapiAttributePlatCheck.H\n";
+print ACFILE "// This file is generated by perl script fapiParseAttributeInfo.pl\n";
+print ACFILE "// A platform can include it to ensure that it handles all HWPF\n";
+print ACFILE "// attributes\n\n";
+print ACFILE "#ifndef FAPIATTRIBUTEPLATCHECK_H_\n";
+print ACFILE "#define FAPIATTRIBUTEPLATCHECK_H_\n\n";
+
+#------------------------------------------------------------------------------
+# Print Start of file information to fapiAttributesSupported.html
+#------------------------------------------------------------------------------
+print ASFILE "<html>\n";
+print ASFILE "<body>\n\n";
+print ASFILE "<!-- fapiAttributesSupported.html -->\n";
+print ASFILE "<!-- This file is generated by perl script fapiParseAttributeInfo.pl -->\n";
+print ASFILE "<!-- It lists all HWPF attributes supported -->\n\n";
+print ASFILE "<h4>HWPF Attributes supported by this build.</h4>\n";
+print ASFILE "<table border=\"4\">\n";
+print ASFILE "<tr><th>Attribute ID</th><th>Attribute Description</th></tr>";
+
+#------------------------------------------------------------------------------
+# Print Start of file information to fapiAttrInfo.csv
+#------------------------------------------------------------------------------
+print ITFILE "# fapiAttrInfo.csv\n";
+print ITFILE "# This file is generated by perl script fapiParseAttributeInfo.pl\n";
+print ITFILE "# It lists information about FAPI attributes and is used to\n";
+print ITFILE "# process FAPI Attribute text files (overrides/syncs)\n";
+print ITFILE "# Format:\n";
+print ITFILE "# <FAPI-ATTR-ID-STR>,<LAYER-ATTR-ID-STR>,<ATTR-ID-VAL>,<ATTR-TYPE>\n";
+print ITFILE "# Note that for the AttributeTanks at the FAPI layer, the\n";
+print ITFILE "# FAPI-ATTR-ID-STR and LAYER-ATTR-ID-STR will be identical\n";
+
+#------------------------------------------------------------------------------
+# Print Start of file information to fapiAttrEnumInfo.csv
+#------------------------------------------------------------------------------
+print ETFILE "# fapiAttrEnumInfo.csv\n";
+print ETFILE "# This file is generated by perl script fapiParseAttributeInfo.pl\n";
+print ETFILE "# It lists information about FAPI attribute enumeratorss and is\n";
+print ETFILE "# used to process FAPI Attribute text files (overrides/syncs)\n";
+print ETFILE "# Format:\n";
+print ETFILE "# <ENUM-STR>,<ENUM-VAL>\n";
+
+my %attrIdHash;  # Records which Attribute IDs have been used
+my %attrValHash; # Records which Attribute values have been used
+
+#------------------------------------------------------------------------------
+# For each XML file
+#------------------------------------------------------------------------------
+#my $argfile = "p9_ppe_attributes.xml";
+my $argfile = $ARGV[1];
+if ($DEBUG) { print "DEBUG:: XML filter file - $argfile\n" }
+my $entries = $xml->XMLin($argfile, ForceArray => ['entry']);
+foreach my $entr (@{$entries->{entry}}) {
+
+    my $inname = $entr->{name};
+    if ($DEBUG) { print "DEBUG:: entr->file = $entr->{file}; \n" }
+
+    foreach my $argnum (2 .. $#ARGV)
+    {
+        my $infile = $ARGV[$argnum];
+
+        # read XML file. The ForceArray option ensures that there is an array of
+        # elements even if there is only one such element in the file
+        my $attributes = $xml->XMLin($infile, ForceArray => ['attribute', 'chip']);
+
+        if ($DEBUG) { print "DEBUG:: File: ", $infile, "\n", Dumper($attributes), "\n"; }
+
+        #--------------------------------------------------------------------------
+        # For each Attribute
+        #--------------------------------------------------------------------------
+        foreach my $attr (@{$attributes->{attribute}})
+        {
+
+            #print "?    $attr->{id}, $inname\n";
+
+            if($attr->{id} eq $inname) {
+
+            #print "yes    $attr->{id}, $inname\n";
+
+            #----------------------------------------------------------------------
+            # Print the Attribute ID and calculated value to fapiAttributeIds.H and
+            # fapiAttributeIds.txt. The value for an attribute is a hash value
+            # generated from the attribute name, this ties a specific value to a
+            # specific attribute name. This is done for Cronus so that if a HWP is
+            # not recompiled against a new eCMD/Cronus version where the attributes
+            # have changed then there will not be a mismatch in enumerator values.
+            # This is a 28bit hash value because the Initfile compiler has a
+            # requirement that the top nibble of the 32 bit attribute ID be zero to
+            # store flags
+            #----------------------------------------------------------------------
+            if (! exists $attr->{id})
+            {
+                print ("fapiParseAttributeInfo.pl ERROR. Attribute 'id' missing in $infile\n");
+                exit(1);
+            }
+
+            if (exists($attrIdHash{$attr->{id}}))
+            {
+                # Two different attributes with the same id!
+                print ("fapiParseAttributeInfo.pl ERROR. Duplicate Attribute id $attr->{id} in $infile\\n");
+                exit(1);
+            }
+
+            # Calculate a 28 bit hash value.
+            my $attrHash128Bit = md5_hex($attr->{id});
+            my $attrHash28Bit = substr($attrHash128Bit, 0, 7);
+
+            # Print the attribute ID/value to fapiAttributeIds.H
+            print AIFILE "    $attr->{id} = 0x$attrHash28Bit,\n";
+
+            if (exists($attrValHash{$attrHash28Bit}))
+            {
+                # Two different attributes generate the same hash-value!
+                print ("fapiParseAttributeInfo.pl ERROR. Duplicate attr id hash value for $attr->{id} in $infile\ \n");
+                exit(1);
+            }
+
+            $attrIdHash{$attr->{id}} = $attrHash28Bit;
+            $attrValHash{$attrHash28Bit} = 1;
+            }
+        };
+    }
+}
+
+#------------------------------------------------------------------------------
+# Print AttributeId enumeration end to fapiAttributeIds.H
+#------------------------------------------------------------------------------
+print AIFILE "};\n\n";
+
+#------------------------------------------------------------------------------
+# Print Attribute Information comment to fapiAttributeIds.H
+#------------------------------------------------------------------------------
+print AIFILE "\/**\n";
+print AIFILE " * \@brief Attribute Information\n";
+print AIFILE " *\/\n";
+
+
+foreach my $entr (@{$entries->{entry}}) {
+
+#    print "    $entr->{file}, $entr->{name}\n";
+
+#    my $infile = $entr->{file};
+    my $inname = $entr->{name};
+
+    # read XML file. The ForceArray option ensures that there is an array of
+    # elements even if there is only one such element in the file
+
+    foreach my $argnum (2 .. $#ARGV)
+    {
+        my $infile = $ARGV[$argnum];
+
+        my $attributes = $xml->XMLin($infile, ForceArray => ['attribute', 'chip']);
+
+        # Uncomment to get debug output of all attributes
+        if ($DEBUG) { print "DEBUG::  File: ", $infile, "\n", Dumper($attributes), "\n"; }
+
+        #--------------------------------------------------------------------------
+        # For each Attribute
+        #--------------------------------------------------------------------------
+        foreach my $attr (@{$attributes->{attribute}})
+        {
+
+            if($attr->{id} eq $inname) {
+
+            #----------------------------------------------------------------------
+            # Print a comment with the attribute ID fapiAttributeIds.H
+            #----------------------------------------------------------------------
+            print AIFILE "/* $attr->{id} */\n";
+
+            #----------------------------------------------------------------------
+            # Print the AttributeId and description to fapiAttributesSupported.html
+            #----------------------------------------------------------------------
+            if (! exists $attr->{description})
+            {
+                print ("fapiParseAttributeInfo.pl ERROR. Attribute 'description' missing for $attr->{id} in $infile\n");
+                exit(1);
+            }
+
+
+            #----------------------------------------------------------------------
+            # Figure out the attribute array dimensions (if array)
+            #----------------------------------------------------------------------
+            my $arrayDimensions = "";
+            my $numArrayDimensions = 0;
+            if ($attr->{array})
+            {
+                # Remove leading whitespace
+                my $dimText = $attr->{array};
+                $dimText =~ s/^\s+//;
+
+                # Split on commas or whitespace
+                my @vals = split(/\s*,\s*|\s+/, $dimText);
+
+                foreach my $val (@vals)
+                {
+                    $arrayDimensions .= "[${val}]";
+                    $numArrayDimensions++;
+                }
+            }
+
+            #----------------------------------------------------------------------
+            # Print the typedef for each attribute's val type to fapiAttributeIds.H
+            # Print the attribute information to fapiAttrInfo.csv
+            #----------------------------------------------------------------------
+            if (exists $attr->{chipEcFeature})
+            {
+                # The value type of chip EC feature attributes is uint8_t
+                print AIFILE "typedef uint8_t $attr->{id}_Type;\n";
+                print ITFILE "$attr->{id},$attr->{id},0x$attrIdHash{$attr->{id}},u8\n"
+            }
+            else
+            {
+                if (! exists $attr->{valueType})
+                {
+                    print ("fapiParseAttributeInfo.pl ERROR. Att 'valueType' missing for $attr->{id} in $infile\n");
+                    exit(1);
+                }
+
+                if ($attr->{valueType} eq 'uint8')
+                {
+                    print AIFILE "typedef uint8_t $attr->{id}_Type$arrayDimensions;\n";
+                    print ITFILE "$attr->{id},$attr->{id},0x$attrIdHash{$attr->{id}},u8" .
+                                 "$arrayDimensions\n";
+                }
+                elsif ($attr->{valueType} eq 'uint16')
+                {
+                    print AIFILE "typedef uint16_t $attr->{id}_Type$arrayDimensions;\n";
+                    print ITFILE "$attr->{id},$attr->{id},0x$attrIdHash{$attr->{id}},u8" .
+                                 "$arrayDimensions\n";
+                }
+                elsif ($attr->{valueType} eq 'uint32')
+                {
+                    print AIFILE "typedef uint32_t $attr->{id}_Type$arrayDimensions;\n";
+                    print ITFILE "$attr->{id},$attr->{id},0x$attrIdHash{$attr->{id}},u32" .
+                                 "$arrayDimensions\n";
+                }
+                elsif ($attr->{valueType} eq 'uint64')
+                {
+                    print AIFILE "typedef uint64_t $attr->{id}_Type$arrayDimensions;\n";
+                    print ITFILE "$attr->{id},$attr->{id},0x$attrIdHash{$attr->{id}},u64" .
+                                 "$arrayDimensions\n";
+                }
+                elsif ($attr->{valueType} eq 'int8')
+                {
+                    print AIFILE "typedef int8_t $attr->{id}_Type$arrayDimensions;\n";
+                    print ITFILE "$attr->{id},$attr->{id},0x$attrIdHash{$attr->{id}},8" .
+                                 "$arrayDimensions\n";
+                }
+                 elsif ($attr->{valueType} eq 'int16')
+                {
+                    print AIFILE "typedef int16_t $attr->{id}_Type$arrayDimensions;\n";
+                    print ITFILE "$attr->{id},$attr->{id},0x$attrIdHash{$attr->{id}},32" .
+                                 "$arrayDimensions\n";
+                }
+                elsif ($attr->{valueType} eq 'int32')
+                {
+                    print AIFILE "typedef int32_t $attr->{id}_Type$arrayDimensions;\n";
+                    print ITFILE "$attr->{id},$attr->{id},0x$attrIdHash{$attr->{id}},32" .
+                                 "$arrayDimensions\n";
+                }
+                elsif ($attr->{valueType} eq 'int64')
+                {
+                    print AIFILE "typedef int64_t $attr->{id}_Type$arrayDimensions;\n";
+                    print ITFILE "$attr->{id},$attr->{id},0x$attrIdHash{$attr->{id}},64" .
+                                 "$arrayDimensions\n";
+                }
+                else
+                {
+                    print ("fapi2ParseAttributeInfo.pl ERROR. valueType not recognized: ");
+                    print $attr->{valueType}, " for $attr->{id} in $infile\n";
+                    exit(1);
+                }
+            }
+
+            #----------------------------------------------------------------------
+            # Print if the attribute is privileged
+            #----------------------------------------------------------------------
+            if (exists $attr->{privileged})
+            {
+                print AIFILE "const bool $attr->{id}_Privileged = true;\n";
+            }
+            else
+            {
+                print AIFILE "const bool $attr->{id}_Privileged = false;\n";
+            }
+
+            #----------------------------------------------------------------------
+            # Print the target type(s) that the attribute is associated with
+            #----------------------------------------------------------------------
+            if (! exists $attr->{targetType})
+            {
+                print ("fapiParseAttributeInfo.pl ERROR. Att 'targetType' missing for $attr->{id} in $infile\n");
+                exit(1);
+            }
+
+            print AIFILE "const TargetType $attr->{id}_TargetTypes = ";
+
+            # Split on commas
+            my @targTypes = split(',', $attr->{targetType});
+            my $targType = $targTypes[0];
+
+            foreach my $targType (@targTypes)
+            {
+                # Remove newlines and leading/trailing whitespace
+                $targType =~ s/\n//;
+                $targType =~ s/^\s+//;
+                $targType =~ s/\s+$//;
+
+                # Consider only supported target types. The rest are ignored
+                if($targType ~~ ["TARGET_TYPE_PROC_CHIP", "TARGET_TYPE_SYSTEM",
+                    "TARGET_TYPE_CORE", "TARGET_TYPE_MCS", "TARGET_TYPE_PERV",
+                    "TARGET_TYPE_EQ", "TARGET_TYPE_EX"])
+                {
+                    print AIFILE "$targType";
+                    last;
+                }
+                else
+                {
+                    next;
+                }
+            }
+            print AIFILE ";\n";
+
+            #----------------------------------------------------------------------
+            # Print if the attribute is a platInit attribute
+            #----------------------------------------------------------------------
+            if (exists $attr->{platInit})
+            {
+                print AIFILE "const bool $attr->{id}_PlatInit = true;\n";
+            }
+            else
+            {
+                print AIFILE "const bool $attr->{id}_PlatInit = false;\n";
+            }
+
+            #----------------------------------------------------------------------
+            # Print if the attribute is a initToZero attribute
+            #----------------------------------------------------------------------
+            if (exists $attr->{initToZero})
+            {
+                print AIFILE "const bool $attr->{id}_InitToZero = true;\n";
+            }
+            else
+            {
+                print AIFILE "const bool $attr->{id}_InitToZero = false;\n";
+            }
+
+            #----------------------------------------------------------------------
+            # Print the value enumeration (if specified) to fapiAttributeIds.H and
+            # fapiAttributeEnums.txt
+            #----------------------------------------------------------------------
+            if (exists $attr->{enum})
+            {
+                print AIFILE "enum $attr->{id}_Enum\n{\n";
+
+                # Values must be separated by commas to allow for values to be
+                # specified: <enum>VAL_A = 3, VAL_B = 5, VAL_C = 0x23</enum>
+                my @vals = split(',', $attr->{enum});
+
+                foreach my $val (@vals)
+                {
+                    # Remove newlines and leading/trailing whitespace
+                    $val =~ s/\n//;
+                    $val =~ s/^\s+//;
+                    $val =~ s/\s+$//;
+
+                    # Print the attribute enum to fapiAttributeIds.H
+                    print AIFILE "    ENUM_$attr->{id}_${val}";
+
+                    # Print the attribute enum to fapiAttrEnumInfo.csv
+                    my $attrEnumTxt = "$attr->{id}_${val}\n";
+                    $attrEnumTxt =~ s/ = /,/;
+                    print ETFILE $attrEnumTxt;
+
+                    if ($attr->{valueType} eq 'uint64')
+                    {
+                        print AIFILE "ULL";
+                    }
+
+                    print AIFILE ",\n";
+                }
+
+                print AIFILE "};\n";
+            }
+
+            #----------------------------------------------------------------------
+            # Print _GETMACRO and _SETMACRO where appropriate to fapiAttributeIds.H
+            #----------------------------------------------------------------------
+            if (exists $attr->{chipEcFeature})
+            {
+                #------------------------------------------------------------------
+                # The attribute is a Chip EC Feature, define _GETMACRO to call a
+                # fapi function and define _SETMACRO to something that will cause a
+                # compile failure if a set is attempted
+                #------------------------------------------------------------------
+                print AIFILE "#define $attr->{id}_GETMACRO(ID, PTARGET, VAL) \\\n";
+                print AIFILE "    PLAT_GET_CHIP_EC_FEATURE_OVERRIDE(ID, PTARGET, VAL) ? fapi2::FAPI2_RC_SUCCESS : \\\n";
+                print AIFILE " fapi2::queryChipEcFeature(fapi2::int2Type<ID>(), PTARGET, VAL)\n";
+                print AIFILE "#define $attr->{id}_SETMACRO(ID, PTARGET, VAL) ";
+                print AIFILE "CHIP_EC_FEATURE_ATTRIBUTE_NOT_WRITABLE\n";
+            }
+            elsif (! exists $attr->{writeable})
+            {
+                #------------------------------------------------------------------
+                # The attribute is read-only, define the _SETMACRO to something
+                # that will cause a compile failure if a set is attempted
+                #------------------------------------------------------------------
+                if (! exists $attr->{writeable})
+                {
+                    print AIFILE "#define $attr->{id}_SETMACRO ATTRIBUTE_NOT_WRITABLE\n";
+                }
+            }
+
+        #----------------------------------------------------------------------
+        # If the attribute is a Chip EC Feature, print the chip EC feature
+        # query to fapi2_chip_ec_feature.H
+        #----------------------------------------------------------------------
+        # Each EC attribute will generate a new inline overloaded version of
+        # hasFeature with the attribute specific logic
+        if (exists $attr->{chipEcFeature})
+        {
+            my $chipCount = 0;
+            print ECHFILE " inline uint8_t hasFeature(int2Type<$attr->{id}>,\n";
+            print ECHFILE "                       fapi2::ATTR_NAME_Type i_name,\n";
+            print ECHFILE "                       fapi2::ATTR_EC_Type i_ec)\n";
+            print ECHFILE " {\n";
+            print ECHFILE "    uint8_t hasFeature = 0;\n\n";
+            print ECHFILE "    if(";
+
+            foreach my $chip (@{$attr->{chipEcFeature}->{chip}})
+            {
+                if (! exists $chip->{name})
+                {
+                    print ("parseAttributeInfo.pl ERROR. Att 'name' missing\n");
+                    exit(1);
+                }
+
+                if (! exists $chip->{ec})
+                {
+                    print ("parseAttributeInfo.pl ERROR. Att 'ec' missing\n");
+                    exit(1);
+                }
+
+                if (! exists $chip->{ec}->{value})
+                {
+                    print ("parseAttributeInfo.pl ERROR. Att 'value' missing\n");
+                    exit(1);
+                }
+
+                if (! exists $chip->{ec}->{test})
+                {
+                    print ("parseAttributeInfo.pl ERROR. Att 'test' missing\n");
+                    exit(1);
+                }
+
+                if($chip->{name} eq 'ENUM_ATTR_NAME_CENTAUR')
+                {
+                    # Skip Centaur chip
+                    next;
+                }
+
+                $chipCount++;
+                my $test;
+                if ($chip->{ec}->{test} eq 'EQUAL')
+                {
+                    $test = '==';
+                }
+                elsif ($chip->{ec}->{test} eq 'GREATER_THAN')
+                {
+                    $test = '>';
+                }
+                elsif ($chip->{ec}->{test} eq 'GREATER_THAN_OR_EQUAL')
+                {
+                    $test = '>=';
+                }
+                elsif ($chip->{ec}->{test} eq 'LESS_THAN')
+                {
+                    $test = '<';
+                }
+                elsif ($chip->{ec}->{test} eq 'LESS_THAN_OR_EQUAL')
+                {
+                    $test = '<=';
+                }
+                else
+                {
+                    print ("parseAttributeInfo.pl ERROR. test '$chip->{ec}->{test}' unrecognized\n");
+                    exit(1);
+                }
+
+                if ($chipCount > 1)
+                {
+                    print ECHFILE " ||\n\t";
+                }
+                print ECHFILE "((i_name == $chip->{name}) && ";
+                print ECHFILE " (i_ec $test $chip->{ec}->{value}))";
+            }
+            print ECHFILE ")\n";
+            print ECHFILE "     {\n";
+            print ECHFILE "         hasFeature = 1;\n";
+            print ECHFILE "     }\n";
+            print ECHFILE "     return hasFeature;\n";
+            print ECHFILE " };\n";
+        }
+
+            #----------------------------------------------------------------------
+            # Print the platform attribute checks to fapiAttributePlatCheck.H
+            #----------------------------------------------------------------------
+            if (exists $attr->{writeable})
+            {
+                print ACFILE "#ifndef $attr->{id}_SETMACRO\n";
+                print ACFILE "#error Platform does not support set of HWPF attr $attr->{id}\n";
+                print ACFILE "#endif\n";
+            }
+
+            print ACFILE "#ifndef $attr->{id}_GETMACRO\n";
+            print ACFILE "#error Platform does not support get of HWPF attr $attr->{id}\n";
+            print ACFILE "#endif\n\n";
+
+            #----------------------------------------------------------------------
+            # Print newline between each attribute's info to fapiAttributeIds.H
+            #----------------------------------------------------------------------
+            print AIFILE "\n";
+
+
+
+
+
+            }
+        };
+    }
+}
+
+#------------------------------------------------------------------------------
+# Print End of file information to fapiAttributeIds.H
+#------------------------------------------------------------------------------
+print AIFILE "} //fapi2 \n\n";
+print AIFILE "#endif // __ASSEMBLER__\n\n";
+print AIFILE "#endif\n";
+
+print ECHFILE "}\n";
+print ECHFILE "#endif\n";
+
+
+#------------------------------------------------------------------------------
+# Print End of file information to fapiAttributePlatCheck.H
+#------------------------------------------------------------------------------
+print ACFILE "#endif\n";
+
+#------------------------------------------------------------------------------
+# Print End of file information to fapiAttributesSupported.html
+#------------------------------------------------------------------------------
+print ASFILE "</table>\n\n";
+print ASFILE "</body>\n";
+print ASFILE "</html>\n";
+
+
+#------------------------------------------------------------------------------
+# Close output files
+#------------------------------------------------------------------------------
+close(AIFILE);
+close(ECHFILE);
+close(ACFILE);
+close(ASFILE);
+close(ITFILE);
+close(ETFILE);
diff --git a/src/tools/scripts/ppeParseProcSbeFixed.pl b/src/tools/scripts/ppeParseProcSbeFixed.pl
new file mode 100755
index 00000000..4279ca3b
--- /dev/null
+++ b/src/tools/scripts/ppeParseProcSbeFixed.pl
@@ -0,0 +1,318 @@
+#!/usr/bin/perl
+# IBM_PROLOG_BEGIN_TAG
+# This is an automatically generated prolog.
+#
+# $Source: src/tools/scripts/ppeParseProcSbeFixed.pl $
+#
+# OpenPOWER sbe Project
+#
+# Contributors Listed Below - COPYRIGHT 2015,2016
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+#
+# IBM_PROLOG_END_TAG
+# Purpose:  This perl script will parse HWP Attribute XML files and
+# initfile attr files and create the fapiGetInitFileAttr() function
+# in a file called fapiAttributeService.C
+
+use strict;
+
+#------------------------------------------------------------------------------
+# Print Command Line Help
+#------------------------------------------------------------------------------
+my $numArgs = $#ARGV + 1;
+if ($numArgs < 3)
+{
+    print ("Usage: ppeParseProcSbeFixed.pl <output dir>\n");
+    print ("           [<if-attr-file1> <if-attr-file2> ...]\n");
+    print ("           -a <attr-xml-file1> [<attr-xml-file2> ...]\n");
+    print ("  This perl script will parse if-attr files (containing the\n");
+    print ("  attributes used by the initfile) and attribute XML files\n");
+    print ("  (containing all HWPF attributes) and create the\n");
+    print ("  fapiGetInitFileAttr() function in a file called\n");
+    print ("  fapiAttributeService.C. Only the attributes specified in\n");
+    print ("  the if-attr files are supported. If no if-attr files are\n");
+    print ("  specified then all attributes are supported\n");
+    exit(1);
+}
+
+#------------------------------------------------------------------------------
+# Specify perl modules to use
+#------------------------------------------------------------------------------
+use XML::Simple;
+my $xml = new XML::Simple (KeyAttr=>[]);
+
+# Uncomment to enable debug output
+#use Data::Dumper;
+
+#------------------------------------------------------------------------------
+# Open output file for writing
+#------------------------------------------------------------------------------
+my $sysFile = $ARGV[0];
+$sysFile .= "/";
+$sysFile .= "proc_sbe_fixed_system.H";
+open(SYFILE, ">", $sysFile);
+
+my $chipFile = $ARGV[0];
+$chipFile .= "/";
+$chipFile .= "proc_sbe_fixed_proc_chip.H";
+open(CHFILE, ">", $chipFile);
+
+my $exFile = $ARGV[0];
+$exFile .= "/";
+$exFile .= "proc_sbe_fixed_ex.H";
+open(EXFILE, ">", $exFile);
+
+my $coreFile = $ARGV[0];
+$coreFile .= "/";
+$coreFile .= "proc_sbe_fixed_core.H";
+open(COFILE, ">", $coreFile);
+
+my $eqFile = $ARGV[0];
+$eqFile .= "/";
+$eqFile .= "proc_sbe_fixed_eq.H";
+open(EQFILE, ">", $eqFile);
+
+my $pervFile = $ARGV[0];
+$pervFile .= "/";
+$pervFile .= "proc_sbe_fixed_perv.H";
+open(PEFILE, ">", $pervFile);
+
+
+
+my $xmlFiles = 0;
+my $attCount = 0;
+my $numIfAttrFiles = 0;
+my @attrSystemIds;
+my @attrChipIds;
+my @attrExIds;
+my @attrCoreIds;
+my @attrEqIds;
+my @attrPervIds;
+
+
+
+#------------------------------------------------------------------------------
+# Element names
+#------------------------------------------------------------------------------
+my $attribute = 'attribute';
+
+#------------------------------------------------------------------------------
+# For each argument
+#------------------------------------------------------------------------------
+my $argfile = $ARGV[1];
+my $entries = $xml->XMLin($argfile, ForceArray => ['entry']);
+foreach my $entr (@{$entries->{entry}}) {
+
+    my $inname = $entr->{name};
+
+    # Skip virtual attributes
+    if(exists $entr->{virtual})
+    {
+        next;
+    }
+
+    # read XML file. The ForceArray option ensures that there is an array of
+    # elements even if there is only one such element in the file
+
+    foreach my $argnum (2 .. $#ARGV)
+    {
+        my $infile = $ARGV[$argnum];
+
+        my $attributes = $xml->XMLin($infile, ForceArray => ['attribute']);
+
+        # Uncomment to get debug output of all attributes
+        #print "\nFile: ", $infile, "\n", Dumper($attributes), "\n";
+
+        #--------------------------------------------------------------------------
+        # For each Attribute
+        #--------------------------------------------------------------------------
+        foreach my $attr (@{$attributes->{attribute}})
+        {
+
+            if($attr->{id} eq $inname) {
+
+                #------------------------------------------------------------------
+                # Check that the AttributeId exists
+                #------------------------------------------------------------------
+                if (! exists $attr->{id})
+                {
+                    print ("fapiParseAttributeInfo.pl ERROR. Att 'id' missing\n");
+                    exit(1);
+                }
+
+                my @targets = split(",", $attr->{targetType});
+                my $targetTypeMatched = 0;
+
+                foreach my $target (@targets)
+                {
+
+                    if ($target eq "TARGET_TYPE_SYSTEM") {
+
+                        push(@attrSystemIds, $attr);
+                        $targetTypeMatched = 1;
+                        last;
+
+                    } elsif ($target eq "TARGET_TYPE_PROC_CHIP") {
+
+                        push(@attrChipIds, $attr);
+                        $targetTypeMatched = 1;
+                        last;
+
+                    } elsif ($target eq "TARGET_TYPE_CORE") {
+
+                        push(@attrCoreIds, $attr);
+                        $targetTypeMatched = 1;
+                        last;
+
+                    } elsif ($target eq "TARGET_TYPE_EQ") {
+
+                        push(@attrEqIds, $attr);
+                        $targetTypeMatched = 1;
+                        last;
+
+                    } elsif ($target eq "TARGET_TYPE_EX") {
+
+                        push(@attrExIds, $attr);
+                        $targetTypeMatched = 1;
+                        last;
+
+                    } elsif ($target eq "TARGET_TYPE_PERV") {
+
+                        push(@attrPervIds, $attr);
+                        $targetTypeMatched = 1;
+                        last;
+
+                    } else {
+
+                        print ("ppeParseProcSbeFixed.pl WARNING. Unsupported ".
+                            "target type: $target for attribute $inname in $infile\n");
+                        next;
+
+                    }
+                }
+                if($targetTypeMatched eq 0)
+                {
+                        print ("ppeParseProcSbeFixed.pl ERROR. Unsupported ".
+                            "target type: $attr->{targetType} for attribute $inname in $infile\n");
+                        exit(1);
+                }
+            }
+        }
+    }
+}
+
+
+print SYFILE "// proc_sbe_fixed_system.H\n";
+print SYFILE "// This file is generated by perl script ppeParseProcSbeFixed.pl\n\n";
+print SYFILE "#ifndef __PROC_SBE_FIXED_SYSTEM_H__\n";
+print SYFILE "#define __PROC_SBE_FIXED_SYSTEM_H__\n\n";
+foreach my $attr (@attrSystemIds)
+{
+
+    my $value = uc $attr->{valueType};
+    print SYFILE "PROC_SBE_FIXED_$value($attr->{id});\n"
+
+
+}
+print SYFILE "\n#endif  // __PROC_SBE_FIXED_SYSTEM_H__";
+
+print CHFILE "// proc_sbe_fixed_proc_chip.H\n";
+print CHFILE "// This file is generated by perl script ppeParseProcSbeFixed.pl\n\n";
+print CHFILE "#ifndef __PROC_SBE_FIXED_PROC_CHIP_H__\n";
+print CHFILE "#define __PROC_SBE_FIXED_PROC_CHIP_H__\n\n";
+foreach my $attr (@attrChipIds)
+{
+
+    my $value = uc $attr->{valueType};
+    print CHFILE "PROC_SBE_FIXED_$value($attr->{id});\n"
+
+
+}
+print CHFILE "\n#endif  // __PROC_SBE_FIXED_PROC_CHIP_H__";
+
+print EXFILE "// proc_sbe_fixed_ex.H\n";
+print EXFILE "// This file is generated by perl script ppeParseProcSbeFixed.pl\n\n";
+print EXFILE "#ifndef __PROC_SBE_FIXED_EX_H__\n";
+print EXFILE "#define __PROC_SBE_FIXED_EX_H__\n";
+foreach my $attr (@attrExIds)
+{
+
+    my $value = uc $attr->{valueType};
+    print EXFILE "PROC_SBE_FIXED_TARGET_$value($attr->{id}, EX_TARGET_COUNT);\n"
+
+
+}
+print EXFILE "\n#endif  // __PROC_SBE_FIXED_EX_H__";
+
+
+print COFILE "// proc_sbe_fixed_co.H\n";
+print COFILE "// This file is generated by perl script ppeParseProcSbeFixed.pl\n\n";
+print COFILE "#ifndef __PROC_SBE_FIXED_CO_H__\n";
+print COFILE "#define __PROC_SBE_FIXED_CO_H__\n";
+foreach my $attr (@attrCoreIds)
+{
+
+    my $value = uc $attr->{valueType};
+    print COFILE "PROC_SBE_FIXED_TARGET_$value($attr->{id}, CORE_TARGET_COUNT);\n"
+
+
+}
+print COFILE "\n#endif  // __PROC_SBE_FIXED_CO_H__";
+
+
+
+print EQFILE "// proc_sbe_fixed_eq.H\n";
+print EQFILE "// This file is generated by perl script ppeParseProcSbeFixed.pl\n\n";
+print EQFILE "#ifndef __PROC_SBE_FIXED_EQ_H__\n";
+print EQFILE "#define __PROC_SBE_FIXED_EQ_H__\n";
+foreach my $attr (@attrEqIds)
+{
+
+    my $value = uc $attr->{valueType};
+    print EQFILE "PROC_SBE_FIXED_TARGET_$value($attr->{id}, EQ_TARGET_COUNT);\n"
+
+
+}
+print EQFILE "\n#endif  // __PROC_SBE_FIXED_EQ_H__";
+
+
+
+print PEFILE "// proc_sbe_fixed_perv.H\n";
+print PEFILE "// This file is generated by perl script ppeParseProcSbeFixed.pl\n\n";
+print PEFILE "#ifndef __PROC_SBE_FIXED_PERV_H__\n";
+print PEFILE "#define __PROC_SBE_FIXED_PERV_H__\n";
+foreach my $attr (@attrPervIds)
+{
+
+    my $value = uc $attr->{valueType};
+    print PEFILE "PROC_SBE_FIXED_TARGET_$value($attr->{id}, PERV_TARGET_COUNT);\n"
+
+
+}
+print PEFILE "\n#endif  // __PROC_SBE_FIXED_PERV_H__";
+
+
+#print ASFILE "#endif  // __PROC_SBE_FIXED_H__";
+
+
+#------------------------------------------------------------------------------
+# Close output file
+#------------------------------------------------------------------------------
+close(CHFILE);
+close(COFILE);
+close(EXFILE);
+close(PEFILE);
+close(EQFILE);
+
diff --git a/src/tools/scripts/ppeSetFixed.pl b/src/tools/scripts/ppeSetFixed.pl
new file mode 100755
index 00000000..ab92ec42
--- /dev/null
+++ b/src/tools/scripts/ppeSetFixed.pl
@@ -0,0 +1,259 @@
+#!/usr/bin/perl
+# IBM_PROLOG_BEGIN_TAG
+# This is an automatically generated prolog.
+#
+# $Source: src/tools/scripts/ppeSetFixed.pl $
+#
+# OpenPOWER sbe Project
+#
+# Contributors Listed Below - COPYRIGHT 2015,2016
+#
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# permissions and limitations under the License.
+#
+# IBM_PROLOG_END_TAG
+# Purpose:  This perl script will parse the attribute and default list and
+# and set the default values into the image.
+
+use strict;
+
+my $attrpath = "../../importtemp/xml";
+my $sbedefaultpath = "../../script/image";
+
+#------------------------------------------------------------------------------
+# Print Command Line Help
+#------------------------------------------------------------------------------
+my $numArgs = $#ARGV + 1;
+if ($numArgs < 3)
+{
+    print ("Usage: ppeSetFixed.pl <image> <attributes and default list> <attribute file> ...\n");
+    print ("  This perl script will the attributes and default list to lookup the defaults\n");
+    print ("  and parse the attribute file to lookup the types.\n");
+    print ("  The default values will be set in the image.\n");
+    print ("example:\n");
+    print ("./ppeSetFixed.pl \\\n" );
+    print (". \\\n" );
+    print (" ../../obj/seeprom_main.bin \\\n" );
+    print ("$attrpath/p9_ppe_attributes.xml \\\n" );
+    print ("$attrpath/attribute_info/perv_attributes.xml \\\n" );
+    print ("$attrpath/attribute_info/proc_attributes.xml \\\n" );
+    print ("$attrpath/attribute_info/ex_attributes.xml \\\n" );
+    print ("$attrpath/attribute_info/eq_attributes.xml \\\n" );
+    print ("$attrpath/attribute_info/core_attributes.xml \\ \n");
+    print ("$attrpath/attribute_info/nest_attributes.xml \n");
+    exit(1);
+}
+
+#------------------------------------------------------------------------------
+# Specify perl modules to use
+#------------------------------------------------------------------------------
+use XML::Simple;
+my $xml = new XML::Simple (KeyAttr=>[]);
+
+
+my $xmlFiles = 0;
+my $attCount = 0;
+my $numIfAttrFiles = 0;
+my @attrSystemIds;
+my @attrChipIds;
+my @attrExIds;
+my @attrCoreIds;
+my @attrEqIds;
+my @attrPervIds;
+
+
+
+#------------------------------------------------------------------------------
+# Element names
+#------------------------------------------------------------------------------
+my $attribute = 'attribute';
+
+#------------------------------------------------------------------------------
+# For each argument
+#------------------------------------------------------------------------------
+my $sbedefaultpath = $ARGV[0];
+my $image = $ARGV[1];
+my $argfile = $ARGV[2];
+my $entries = $xml->XMLin($argfile, ForceArray => ['entry']);
+
+if ( ! -e $image) {die "ppeSetFixed.pl: $image $!"};
+
+foreach my $entr (@{$entries->{entry}}) {
+
+    # Skip virtual attributes
+    if(exists $entr->{virtual})
+    {
+        next;
+    }
+
+    my $inname = $entr->{name};
+
+    # read XML file. The ForceArray option ensures that there is an array of
+    # elements even if there is only one such element in the file
+
+    foreach my $argnum (3 .. $#ARGV)
+    {
+        my $infile = $ARGV[$argnum];
+
+        if ( ! -e $infile) {die "ppeSetFixed.pl: $infile $!"};
+
+        my $attributes = $xml->XMLin($infile, ForceArray => ['attribute']);
+
+        #--------------------------------------------------------------------------
+        # For each Attribute
+        #--------------------------------------------------------------------------
+        foreach my $attr (@{$attributes->{attribute}})
+        {
+            if($attr->{id} eq $inname) {
+
+                #------------------------------------------------------------------
+                # Check that the AttributeId exists
+                #------------------------------------------------------------------
+                if (! exists $attr->{id})
+                {
+                    print ("ppeSbeFixed.pl ERROR. Att 'id' missing\n");
+                    exit(1);
+                }
+
+                my @targets = split(",", $attr->{targetType});
+
+                my $targetTypeMatched = 0;
+
+                foreach my $target (@targets)
+                {
+                    if($target eq "TARGET_TYPE_SYSTEM") {
+
+                        push(@attrSystemIds, $entr);
+                        $targetTypeMatched = 1;
+                        last;
+
+                    } elsif($target eq "TARGET_TYPE_PROC_CHIP") {
+
+                        push(@attrChipIds, $entr);
+                        $targetTypeMatched = 1;
+                        last;
+
+                    } elsif($target eq "TARGET_TYPE_CORE") {
+
+                        push(@attrCoreIds, $entr);
+                        $targetTypeMatched = 1;
+                        last;
+
+                    } elsif($target eq "TARGET_TYPE_EQ") {
+
+                        push(@attrEqIds, $entr);
+                        $targetTypeMatched = 1;
+                        last;
+
+                    } elsif($target eq "TARGET_TYPE_EX") {
+
+                        push(@attrExIds, $entr);
+                        $targetTypeMatched = 1;
+                        last;
+
+                    } elsif($target eq "TARGET_TYPE_PERV") {
+
+                        push(@attrPervIds, $entr);
+                        $targetTypeMatched = 1;
+                        last;
+
+                    } else {
+
+                        print ("ppeSetFixed.pl WARNING. Ignoring unsupported".
+                            " target type: $target for attribute: $inname\n");
+                        next;
+
+                    }
+                }
+                if($targetTypeMatched eq 0)
+                {
+                    print ("ppeSetFixed.pl ERROR. No matching target type ".
+                        "found for attribute: $inname\n");
+                    exit(1);
+                }
+
+            }
+        }
+    }
+}
+
+
+setFixed("TARGET_TYPE_SYSTEM", @attrSystemIds);
+setFixed("TARGET_TYPE_PROC_CHIP", @attrChipIds);
+setFixed("TARGET_TYPE_CORE", @attrCoreIds);
+setFixed("TARGET_TYPE_EQ", @attrEqIds);
+setFixed("TARGET_TYPE_EX", @attrExIds);
+setFixed("TARGET_TYPE_PERV", @attrPervIds);
+
+
+
+sub setFixed {
+
+    my ($string, @entries) =  @_;
+
+    foreach my $attr (@entries)
+    {
+
+        my $inname = $attr->{name};
+
+        my @values = $attr->{value};
+
+
+        if(scalar @values > 0) {
+            foreach my $val (@values)
+            {
+
+                if(defined $val && ref($val) eq "") {
+
+                    if ($val =~ /(0x)?[0-9a-fA-F]+/) {
+
+                        my $systemRc = system("$sbedefaultpath/sbe_default_tool $image $inname $val $string 0");
+
+                        if ($systemRc) {
+                            print "sbe_default_tool: error in execution\n";
+                            exit 1;
+                        }
+
+                    } else {
+                        print ("ppeSetFixed.pl ERROR. not hex\n");
+                        exit(1);
+                    }
+
+                } elsif(defined $val && ref($val) eq "ARRAY") {
+
+                    my $index = 0;
+
+                    foreach my $arr (@{$val}) {
+
+                        if(defined $arr && ref($arr) eq "") {
+                            if ($arr =~ /(0x)?[0-9a-fA-F]+/) {
+
+                                my $systemRc = system("$sbedefaultpath/sbe_default_tool $image $inname $arr $string $index");
+
+                                if ($systemRc) {
+                                    print "sbe_default_tool: error in execution\n";
+                                    exit 1;
+                                }
+
+
+                            }
+                        }
+                        $index++;
+                    }
+                }
+            }
+        }
+    }
+}
+
+
diff --git a/src/tools/scripts/src/fapi2PlatAttributeService.H b/src/tools/scripts/src/fapi2PlatAttributeService.H
new file mode 100644
index 00000000..7c992d65
--- /dev/null
+++ b/src/tools/scripts/src/fapi2PlatAttributeService.H
@@ -0,0 +1,1416 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: src/tools/scripts/src/fapi2PlatAttributeService.H $           */
+/*                                                                        */
+/* OpenPOWER sbe Project                                                  */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2015,2016                        */
+/*                                                                        */
+/*                                                                        */
+/* Licensed under the Apache License, Version 2.0 (the "License");        */
+/* you may not use this file except in compliance with the License.       */
+/* You may obtain a copy of the License at                                */
+/*                                                                        */
+/*     http://www.apache.org/licenses/LICENSE-2.0                         */
+/*                                                                        */
+/* Unless required by applicable law or agreed to in writing, software    */
+/* distributed under the License is distributed on an "AS IS" BASIS,      */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
+/* implied. See the License for the specific language governing           */
+/* permissions and limitations under the License.                         */
+/*                                                                        */
+/* IBM_PROLOG_END_TAG                                                     */
+/**
+ *  @file fapiPlatAttributeService.H
+ *
+ *  @brief Defines the PLAT attribute access macros and defines which macro
+ *         handles each attribute.
+ *
+ */
+
+
+#ifndef FAPI2PLATATTRIBUTESERVICE_H_
+#define FAPI2PLATATTRIBUTESERVICE_H_
+
+#include <stdint.h>
+#include <stddef.h>
+#include <type_traits>
+#include <fapi2AttributeIds.H>
+#include <fapi2ChipEcFeature.H>
+#include <plat_includes.H>
+#include "proc_sbe_fixed.H"
+#include "plat_target_parms.H"
+
+#define PLAT_GET_CHIP_EC_FEATURE_OVERRIDE(ID, PTARGET, VAL) \
+      _getEcFeatureOverride<ID##_Type>(ID, PTARGET, VAL)
+
+/* INSERT NEW ATTRIBUTES HERE */
+
+
+/******************************************************************************/
+/*                          * Global macros *                                 */
+/* These macros are called by the macros above to invoke the appropriate API. */
+/* These macros do not need to change when a new attribute is introduced.     */
+/******************************************************************************/
+
+/* global get uint8_t 1D array macro */
+#define PLAT_ATTR_GET_UINT8_1D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeArrayShort<ID##_Type, static_cast<fapi2::TargetType>(ID##_TargetTypes), ID> \
+            (ID, PTARGET, VAL)
+
+/* global set uint8_t 1D array macro */
+#define PLAT_ATTR_SET_UINT8_1D_ARRAY(ID, PTARGET, VAL) \
+     _setAttributeArrayShort<ID##_Type, static_cast<fapi2::TargetType>(ID##_TargetTypes), ID> \
+            (ID, PTARGET, VAL)
+
+/* global get uint8_t 2D array macro */
+#define PLAT_ATTR_GET_UINT8_2D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeArrayShort(ID, PTARGET, VAL[0])
+/* global set uint8_t 2D array macro */
+#define PLAT_ATTR_SET_UINT8_2D_ARRAY(ID, PTARGET, VAL) \
+     _setAttributeArrayShort(ID, PTARGET, VAL[0])
+
+/* global get uint8_t 3D array macro */
+#define PLAT_ATTR_GET_UINT8_3D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeArrayShort(ID, PTARGET, VAL[0][0])
+/* global set uint8_t 3D array macro */
+#define PLAT_ATTR_SET_UINT8_3D_ARRAY(ID, PTARGET, VAL) \
+     _setAttributeArrayShort(ID, PTARGET, VAL[0][0])
+
+/* global get uint8_t 4D array macro */
+#define PLAT_ATTR_GET_UINT8_4D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeArrayShort(ID, PTARGET, VAL[0][0][0])
+/* global set uint8_t 4D array macro */
+#define PLAT_ATTR_SET_UINT8_4D_ARRAY(ID, PTARGET, VAL) \
+     _setAttributeArrayShort(ID, PTARGET, VAL[0][0][0])
+
+/* global get uint32_t 1D array macro */
+#define PLAT_ATTR_GET_UINT32_1D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeArrayWord(ID, PTARGET, VAL)
+/* global set uint32_t 1D array macro */
+#define PLAT_ATTR_SET_UINT32_1D_ARRAY(ID, PTARGET, VAL) \
+     _setAttributeArrayWord(ID, PTARGET, VAL)
+
+/* global get uint32_t 2D array macro */
+#define PLAT_ATTR_GET_UINT32_2D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeArrayWord(ID, PTARGET, VAL[0])
+/* global set uint32_t 2D array macro */
+#define PLAT_ATTR_SET_UINT32_2D_ARRAY(ID, PTARGET, VAL) \
+     _setAttributeArrayWord(ID, PTARGET, VAL[0])
+
+/* global get uint32_t 3D array macro */
+#define PLAT_ATTR_GET_UINT32_3D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeArrayWord(ID, PTARGET, VAL[0][0])
+/* global set uint32_t 3D array macro */
+#define PLAT_ATTR_SET_UINT32_3D_ARRAY(ID, PTARGET, VAL) \
+     _setAttributeArrayWord(ID, PTARGET, VAL[0][0])
+
+/* global get uint32_t 4D array macro */
+#define PLAT_ATTR_GET_UINT32_4D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeArrayWord(ID, PTARGET, VAL[0][0][0])
+/* global set uint32_t 4D array macro */
+#define PLAT_ATTR_SET_UINT32_4D_ARRAY(ID, PTARGET, VAL) \
+     _setAttributeArrayWord(ID, PTARGET, VAL[0][0][0])
+
+
+/* global get uint64_t 1D array macro */
+#define PLAT_ATTR_GET_UINT64_1D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeArrayDoubleWord(ID, PTARGET, VAL)
+/* global set uint64_t 1D array macro */
+#define PLAT_ATTR_SET_UINT64_1D_ARRAY(ID, PTARGET, VAL) \
+     _setAttributeArrayDoubleWord(ID, PTARGET, VAL)
+
+/* global get uint64_t 2D array macro */
+#define PLAT_ATTR_GET_UINT64_2D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeArrayDoubleWord(ID, PTARGET, VAL[0])
+/* global set uint64_t 2D array macro */
+#define PLAT_ATTR_SET_UINT64_2D_ARRAY(ID, PTARGET, VAL) \
+     _setAttributeArrayDoubleWord(ID, PTARGET, VAL[0])
+
+/* global get uint64_t 3D array macro */
+#define PLAT_ATTR_GET_UINT64_3D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeArrayDoubleWord(ID, PTARGET, VAL[0][0])
+/* global set uint64_t 3D array macro */
+#define PLAT_ATTR_SET_UINT64_3D_ARRAY(ID, PTARGET, VAL) \
+     _setAttributeArrayDoubleWord(ID, PTARGET, VAL[0][0])
+
+/* global get uint64_t 4D array macro */
+#define PLAT_ATTR_GET_UINT64_4D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeArrayDoubleWord(ID, PTARGET, VAL[0][0][0])
+/* global set uint64_t 4D array macro */
+#define PLAT_ATTR_SET_UINT64_4D_ARRAY(ID, PTARGET, VAL) \
+     _setAttributeArrayDoubleWord(ID, PTARGET, VAL[0][0][0])
+
+/* global get int macro (uint8_t, 16, 32 and 64) */
+#define PLAT_ATTR_GET_GLOBAL_INT(ID, PTARGET, VAL) \
+     _get<ID##_Type, static_cast<fapi2::TargetType>(ID##_TargetTypes), ID> \
+                (ID, PTARGET, VAL)
+
+/* global set int macro (uint8_t, 16, 32 and 64) */
+#define PLAT_ATTR_SET_GLOBAL_INT(ID, PTARGET, VAL) \
+     _set<ID##_Type, static_cast<fapi2::TargetType>(ID##_TargetTypes), ID> \
+                (ID, PTARGET, VAL)
+
+
+//here
+
+/******************************************************************************/
+// Get Override Macros
+/******************************************************************************/
+/* global get override uint8_t 1D array macro */
+#define PLAT_ATTR_GET_OVERRIDE_UINT8_1D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeOverrideArrayShort(ID, PTARGET, VAL)
+/* global get override uint8_t 2D array macro */
+#define PLAT_ATTR_GET_OVERRIDE_UINT8_2D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeOverrideArrayShort(ID, PTARGET, VAL[0])
+/* global get override uint8_t 3D array macro */
+#define PLAT_ATTR_GET_OVERRIDE_UINT8_3D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeOverrideArrayShort(ID, PTARGET, VAL[0][0])
+/* global get override uint8_t 4D array macro */
+#define PLAT_ATTR_GET_OVERRIDE_UINT8_4D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeOverrideArrayShort(ID, PTARGET, VAL[0][0][0])
+
+
+/* global get override uint32_t 1D array macro */
+#define PLAT_ATTR_GET_OVERRIDE_UINT32_1D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeOverrideArrayWord(ID, PTARGET, VAL)
+/* global get override uint32_t 2D array macro */
+#define PLAT_ATTR_GET_OVERRIDE_UINT32_2D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeOverrideArrayWord(ID, PTARGET, VAL[0])
+/* global get override uint32_t 3D array macro */
+#define PLAT_ATTR_GET_OVERRIDE_UINT32_3D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeOverrideArrayWord(ID, PTARGET, VAL[0][0])
+/* global get override uint32_t 4D array macro */
+#define PLAT_ATTR_GET_OVERRIDE_UINT32_4D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeOverrideArrayWord(ID, PTARGET, VAL[0][0][0])
+
+
+/* global get override uint64_t 1D array macro */
+#define PLAT_ATTR_GET_OVERRIDE_UINT64_1D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeOverrideArrayDoubleWord(ID, PTARGET, VAL)
+/* global get override uint64_t 2D array macro */
+#define PLAT_ATTR_GET_OVERRIDE_UINT64_2D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeOverrideArrayDoubleWord(ID, PTARGET, VAL[0])
+/* global get override uint64_t 3D array macro */
+#define PLAT_ATTR_GET_OVERRIDE_UINT64_3D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeOverrideArrayDoubleWord(ID, PTARGET, VAL[0][0])
+/* global get override uint64_t 4D array macro */
+#define PLAT_ATTR_GET_OVERRIDE_UINT64_4D_ARRAY(ID, PTARGET, VAL) \
+     _getAttributeOverrideArrayDoubleWord(ID, PTARGET, VAL[0][0][0])
+
+/* global get override int macro (uint8_t, 32 and 64) */
+#define PLAT_ATTR_GET_OVERRIDE_GLOBAL_INT(ID, PTARGET, VAL) \
+     _getOverride<ID##_Type>(ID, PTARGET, VAL)
+
+/******************************************************************************/
+// Get string
+/******************************************************************************/
+
+extern "C"
+{
+    extern fapi2attr::SystemAttributes_t    G_system_attributes    asm("G_system_attributes")     __attribute__ ((section (".fixed")));
+    extern fapi2attr::ProcChipAttributes_t  G_proc_chip_attributes asm("G_proc_chip_attributes")  __attribute__ ((section (".fixed")));
+    extern fapi2attr::PervAttributes_t      G_perv_attributes      asm("G_perv_attributes")       __attribute__ ((section (".fixed")));
+    extern fapi2attr::CoreAttributes_t      G_core_attributes      asm("G_core_attributes")       __attribute__ ((section (".fixed")));
+    extern fapi2attr::EQAttributes_t        G_eq_attributes        asm("G_eq_attributes")         __attribute__ ((section (".fixed")));
+    extern fapi2attr::EXAttributes_t        G_ex_attributes        asm("G_ex_attributes")         __attribute__ ((section (".fixed")));
+
+    extern fapi2attr::SystemAttributes_t*   G_system_attributes_ptr;
+    extern fapi2attr::ProcChipAttributes_t* G_proc_chip_attributes_ptr;
+    extern fapi2attr::PervAttributes_t*     G_perv_attributes_ptr;
+    extern fapi2attr::CoreAttributes_t*     G_core_attributes_ptr;
+    extern fapi2attr::EQAttributes_t*       G_eq_attributes_ptr;
+    extern fapi2attr::EXAttributes_t*       G_ex_attributes_ptr;
+
+}
+
+namespace fapi2
+{
+
+
+// Parameters are done as pointers (vs references) to allow the attribute
+// storage to be relocated
+template<TargetType K, typename TAttrStruct, typename TValue, AttributeId AId>
+void __set( const Target<K>& i_ptarget, TAttrStruct* object, const AttributeId attrid, const TValue& value );
+
+template<TargetType K, typename TAttrStruct, typename TValue, AttributeId AId>
+void __get( const Target<K>& i_ptarget, const TAttrStruct* object, const AttributeId attrid, TValue* value );
+
+
+/* INSERT NEW GETTER AND SETTER FUNCTIONS HERE */
+
+
+
+//******************************************************************************
+// Get base template
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _get(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                T& o_value)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Get uint8_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _get(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                uint8_t& o_value)
+{
+    static_assert(std::is_same<T, uint8_t>::value, "Attribute type mismatch");
+
+    if(K & TARGET_TYPE_SYSTEM)
+    {
+        __get<K, fapi2attr::SystemAttributes_t, T, A>( i_pTarget, G_system_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_PROC_CHIP)
+    {
+        __get<K, fapi2attr::ProcChipAttributes_t, T, A>( i_pTarget, G_proc_chip_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_PERV)
+    {
+         __get<K, fapi2attr::PervAttributes_t, T, A>( i_pTarget, G_perv_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_CORE)
+    {
+        __get<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_core_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_EQ)
+    {
+        __get<K, fapi2attr::EQAttributes_t, T, A>( i_pTarget, G_eq_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_EX)
+    {
+        __get<K, fapi2attr::EXAttributes_t, T, A>( i_pTarget, G_ex_attributes_ptr, i_id, &o_value );
+    }
+
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Get uint16_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _get(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                uint16_t& o_value)
+{
+    static_assert(std::is_same<T, uint16_t>::value, "Attribute type mismatch");
+
+    if(K & TARGET_TYPE_SYSTEM)
+    {
+        __get<K, fapi2attr::SystemAttributes_t, T, A>( i_pTarget, G_system_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_PROC_CHIP)
+    {
+        __get<K, fapi2attr::ProcChipAttributes_t, T, A>( i_pTarget, G_proc_chip_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_PERV)
+    {
+         __get<K, fapi2attr::PervAttributes_t, T, A>( i_pTarget, G_perv_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_CORE)
+    {
+        __get<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_core_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_EQ)
+    {
+        __get<K, fapi2attr::EQAttributes_t, T, A>( i_pTarget, G_eq_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_EX)
+    {
+        __get<K, fapi2attr::EXAttributes_t, T, A>( i_pTarget, G_ex_attributes_ptr, i_id, &o_value );
+    }
+
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Get uint32_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _get(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                uint32_t& o_value)
+{
+    static_assert(std::is_same<T, uint32_t>::value, "Attribute type mismatch");
+
+    if(K & TARGET_TYPE_SYSTEM)
+    {
+        __get<K, fapi2attr::SystemAttributes_t, T, A>( i_pTarget, G_system_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_PROC_CHIP)
+    {
+        __get<K, fapi2attr::ProcChipAttributes_t, T, A>( i_pTarget, G_proc_chip_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_PERV)
+    {
+         __get<K, fapi2attr::PervAttributes_t, T, A>( i_pTarget, G_perv_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_CORE)
+    {
+        __get<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_core_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_EQ)
+    {
+        __get<K, fapi2attr::EQAttributes_t, T, A>( i_pTarget, G_eq_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_EX)
+    {
+        __get<K, fapi2attr::EXAttributes_t, T, A>( i_pTarget, G_ex_attributes_ptr, i_id, &o_value );
+    }
+
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Get uint64_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _get(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                uint64_t& o_value)
+{
+    static_assert(std::is_same<T, uint64_t>::value, "Attribute type mismatch");
+
+    if(K & TARGET_TYPE_SYSTEM)
+    {
+        __get<K, fapi2attr::SystemAttributes_t, T, A>( i_pTarget, G_system_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_PROC_CHIP)
+    {
+        __get<K, fapi2attr::ProcChipAttributes_t, T, A>( i_pTarget, G_proc_chip_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_PERV)
+    {
+         __get<K, fapi2attr::PervAttributes_t, T, A>( i_pTarget, G_perv_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_CORE)
+    {
+        __get<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_core_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_EQ)
+    {
+        __get<K, fapi2attr::EQAttributes_t, T, A>( i_pTarget, G_eq_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_EX)
+    {
+        __get<K, fapi2attr::EXAttributes_t, T, A>( i_pTarget, G_ex_attributes_ptr, i_id, &o_value );
+    }
+
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Get Override uint8_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _getOverride(const AttributeId i_id,
+                        const Target<K> & i_pTarget,
+                        uint8_t& o_value)
+{
+    static_assert(std::is_same<T, uint8_t>::value, "Attribute type mismatch");
+
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Get Override uint16_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _getOverride(const AttributeId i_id,
+                        const Target<K> & i_pTarget,
+                        uint16_t& o_value)
+{
+    static_assert(std::is_same<T, uint16_t>::value, "Attribute type mismatch");
+
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Get Override uint32_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _getOverride(const AttributeId i_id,
+                        const Target<K> & i_pTarget,
+                        uint32_t& o_value)
+{
+    static_assert(std::is_same<T, uint32_t>::value, "Attribute type mismatch");
+
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Get Override uint64_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _getOverride(const AttributeId i_id,
+                        const Target<K> & i_pTarget,
+                        uint64_t& o_value)
+{
+    static_assert(std::is_same<T, uint64_t>::value, "Attribute type mismatch");
+
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Get override EC Feature (uint8_t)
+//******************************************************************************
+template<typename T, TargetType K>
+ReturnCode _getEcFeatureOverride(const AttributeId i_id,
+                                 const Target<K> & i_pTarget,
+                                 uint8_t& o_value)
+{
+    static_assert(std::is_same<T, uint8_t>::value, "Attribute type mismatch");
+
+    // The way this is implemented, we want to return a non-zero return code if we found an override.
+    // Return 0 if there was an error.
+    // This is how it's implemented:
+    // PLAT_GET_CHIP_EC_FEATURE_OVERRIDE(ID, PTARGET, VAL) ? fapi::FAPI_RC_SUCCESS : fapi::fapiQueryChipEcFeature(fapi::ID, PTARGET, VAL)
+
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Get uint8_t array
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _getAttributeArrayShort(const AttributeId i_id,
+                                   const Target<K> & i_pTarget,
+                                   uint8_t * o_pValues)
+{
+//       fapi2::Attributeta o_data;
+//     fapi2::ReturnCode l_fapi_rc(FAPI2_RC_SUCCESS);
+//     uint32_t l_ecmd_rc = ECMD_SUCCESS;
+//
+//     ecmdChipTarget l_ecmd_target;
+//     fapiTargetPointerToEcmdTarget(i_pTarget, l_ecmd_target);
+//
+//     o_data.faValidMask = FAPI_ATTRIBUTE_TYPE_UINT8ARY;
+//     o_data.faUint8ary = o_pValues;
+//
+//     l_ecmd_rc = fapi2GetAttribute(l_ecmd_target, i_id, o_data);
+//     if (l_ecmd_rc)
+//     {
+//         l_fapi_rc = (ReturnCodes) l_ecmd_rc;
+//     }
+//     return l_fapi_rc;
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Set uint8_t array
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _setAttributeArrayShort(const AttributeId i_id,
+                                   const Target<K> & i_pTarget,
+                                   uint8_t * i_pValues)
+{
+    if(K & TARGET_TYPE_SYSTEM)
+    {
+        __set<K, fapi2attr::SystemAttributes_t, T, A>( i_pTarget, G_system_attributes_ptr, i_id, *i_pValues );
+    }
+
+    if(K & TARGET_TYPE_PROC_CHIP)
+    {
+        __set<K, fapi2attr::ProcChipAttributes_t, T, A>( i_pTarget, G_proc_chip_attributes_ptr, *i_pValues );
+    }
+
+    if(K & TARGET_TYPE_PERV)
+    {
+        __set<K, fapi2attr::PervAttributes_t, T, A>( i_pTarget, G_perv_attributes_ptr, *i_pValues );
+    }
+
+    if(K & TARGET_TYPE_CORE)
+    {
+        __set<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_core_attributes_ptr, *i_pValues );
+    }
+
+    if(K & TARGET_TYPE_EQ)
+    {
+        __set<K, fapi2attr::EQAttributes_t, T, A>( i_pTarget, G_eq_attributes_ptr, *i_pValues );
+    }
+
+    if(K & TARGET_TYPE_EX)
+    {
+        __set<K, fapi2attr::EXAttributes_t, T, A>( i_pTarget, G_ex_attributes_ptr, *i_pValues );
+    }
+
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Get uint16_t array
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _getAttributeArrayWord(const AttributeId i_id,
+                                  const Target<K> & i_pTarget,
+                                  uint16_t * o_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Set uint16_t array
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _setAttributeArrayWord(const AttributeId i_id,
+                                  const Target<K> & i_pTarget,
+                                  uint16_t * i_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Get uint32_t array
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _getAttributeArrayWord(const AttributeId i_id,
+                                  const Target<K> & i_pTarget,
+                                  uint32_t * o_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Set uint32_t array
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _setAttributeArrayWord(const AttributeId i_id,
+                                  const Target<K> & i_pTarget,
+                                  uint32_t * i_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Get uint64_t array
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _getAttributeArrayDoubleWord(const AttributeId i_id,
+                                        const Target<K> & i_pTarget,
+                                        uint64_t * o_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Set uint64_t array
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _setAttributeArrayDoubleWord(const AttributeId i_id,
+                                        const Target<K> & i_pTarget,
+                                        uint64_t * i_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Get Override uint8_t array
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _getAttributeOverrideArrayShort(const AttributeId i_id,
+                                           const Target<K> & i_pTarget,
+                                           uint8_t * o_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Get Override uint16_t array
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _getAttributeOverrideArrayWord(const AttributeId i_id,
+                                          const Target<K> & i_pTarget,
+                                          uint16_t * o_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Get Override uint32_t array
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _getAttributeOverrideArrayWord(const AttributeId i_id,
+                                          const Target<K> & i_pTarget,
+                                          uint32_t * o_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Get Override uint64_t array
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _getAttributeOverrideArrayDoubleWord(const AttributeId i_id,
+                                                const Target<K> & i_pTarget,
+                                                uint64_t * o_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Set base template
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _set(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                const T& i_value)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+
+
+//******************************************************************************
+// Set uint8_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _set(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                const uint8_t& i_value)
+{
+    static_assert(std::is_same<T, uint8_t>::value, "Attribute type mismatch"); // May need to remove
+
+    if(K & TARGET_TYPE_SYSTEM)
+    {
+        __set<K, fapi2attr::SystemAttributes_t, T, A>( i_pTarget, G_system_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_PROC_CHIP)
+    {
+        __set<K, fapi2attr::ProcChipAttributes_t, T, A>( i_pTarget, G_proc_chip_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_PERV)
+    {
+        __set<K, fapi2attr::PervAttributes_t, T, A>( i_pTarget, G_perv_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_CORE)
+    {
+        __set<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_core_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_EQ)
+    {
+        __set<K, fapi2attr::EQAttributes_t, T, A>( i_pTarget, G_eq_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_EX)
+    {
+        __set<K, fapi2attr::EXAttributes_t, T, A>( i_pTarget, G_ex_attributes_ptr, i_id, i_value );
+    }
+
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Set uint16_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _set(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                const uint16_t& i_value)
+{
+    static_assert(std::is_same<T, uint16_t>::value, "Attribute type mismatch"); // May need to remove
+
+    if(K & TARGET_TYPE_SYSTEM)
+    {
+        __set<K, fapi2attr::SystemAttributes_t, T, A>( i_pTarget, G_system_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_PROC_CHIP)
+    {
+        __set<K, fapi2attr::ProcChipAttributes_t, T, A>( i_pTarget, G_proc_chip_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_PERV)
+    {
+        __set<K, fapi2attr::PervAttributes_t, T, A>( i_pTarget, G_perv_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_CORE)
+    {
+        __set<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_core_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_EQ)
+    {
+        __set<K, fapi2attr::EQAttributes_t, T, A>( i_pTarget, G_eq_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_EX)
+    {
+        __set<K, fapi2attr::EXAttributes_t, T, A>( i_pTarget, G_ex_attributes_ptr, i_id, i_value );
+    }
+
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Set uint32_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _set(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                const uint32_t& i_value)
+{
+    static_assert(std::is_same<T, uint32_t>::value, "Attribute type mismatch"); // May need to remove
+
+    if(K & TARGET_TYPE_SYSTEM)
+    {
+        __set<K, fapi2attr::SystemAttributes_t, T, A>( i_pTarget, G_system_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_PROC_CHIP)
+    {
+        __set<K, fapi2attr::ProcChipAttributes_t, T, A>( i_pTarget, G_proc_chip_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_PERV)
+    {
+        __set<K, fapi2attr::PervAttributes_t, T, A>( i_pTarget, G_perv_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_CORE)
+    {
+        __set<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_core_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_EQ)
+    {
+        __set<K, fapi2attr::EQAttributes_t, T, A>( i_pTarget, G_eq_attributes_ptr, i_id,i_value );
+    }
+
+    if(K & TARGET_TYPE_EX)
+    {
+        __set<K, fapi2attr::EXAttributes_t, T, A>( i_pTarget, G_ex_attributes_ptr, i_id, i_value );
+    }
+
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Set uint64_t
+//******************************************************************************
+
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _set(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                const uint64_t & i_value)
+{
+    static_assert(std::is_same<T, uint64_t>::value, "Attribute type mismatch"); // May need to remove
+
+    if(K & TARGET_TYPE_SYSTEM)
+    {
+        __set<K, fapi2attr::SystemAttributes_t, T, A>( i_pTarget, G_system_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_PROC_CHIP)
+    {
+        __set<K, fapi2attr::ProcChipAttributes_t, T, A>( i_pTarget, G_proc_chip_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_PERV)
+    {
+        __set<K, fapi2attr::PervAttributes_t, T, A>( i_pTarget, G_perv_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_CORE)
+    {
+        __set<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_core_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_EQ)
+    {
+        __set<K, fapi2attr::EQAttributes_t, T, A>( i_pTarget, G_eq_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_EX)
+    {
+        __set<K, fapi2attr::EXAttributes_t, T, A>( i_pTarget, G_ex_attributes_ptr, i_id, i_value );
+    }
+
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Get int8_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _get(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                int8_t& o_value)
+{
+    static_assert(std::is_same<T, int8_t>::value, "Attribute type mismatch");
+
+    if(K & TARGET_TYPE_SYSTEM)
+    {
+        __get<K, fapi2attr::SystemAttributes_t, T, A>( i_pTarget, G_system_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_PROC_CHIP)
+    {
+        __get<K, fapi2attr::ProcChipAttributes_t, T, A>( i_pTarget, G_proc_chip_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_PERV)
+    {
+         __get<K, fapi2attr::PervAttributes_t, T, A>( i_pTarget, G_perv_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_CORE)
+    {
+        __get<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_core_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_EQ)
+    {
+        __get<K, fapi2attr::EQAttributes_t, T, A>( i_pTarget, G_eq_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_EX)
+    {
+        __get<K, fapi2attr::EXAttributes_t, T, A>( i_pTarget, G_ex_attributes_ptr, i_id, &o_value );
+    }
+
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Get int16_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _get(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                int16_t& o_value)
+{
+    static_assert(std::is_same<T, int16_t>::value, "Attribute type mismatch");
+
+    if(K & TARGET_TYPE_SYSTEM)
+    {
+        __get<K, fapi2attr::SystemAttributes_t, T, A>( i_pTarget, G_system_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_PROC_CHIP)
+    {
+        __get<K, fapi2attr::ProcChipAttributes_t, T, A>( i_pTarget, G_proc_chip_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_PERV)
+    {
+         __get<K, fapi2attr::PervAttributes_t, T, A>( i_pTarget, G_perv_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_CORE)
+    {
+        __get<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_core_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_EQ)
+    {
+        __get<K, fapi2attr::EQAttributes_t, T, A>( i_pTarget, G_eq_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_EX)
+    {
+        __get<K, fapi2attr::EXAttributes_t, T, A>( i_pTarget, G_ex_attributes_ptr, i_id, &o_value );
+    }
+
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Get int32_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _get(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                int32_t& o_value)
+{
+    static_assert(std::is_same<T, int32_t>::value, "Attribute type mismatch");
+
+    if(K & TARGET_TYPE_SYSTEM)
+    {
+        __get<K, fapi2attr::SystemAttributes_t, T, A>( i_pTarget, G_system_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_PROC_CHIP)
+    {
+        __get<K, fapi2attr::ProcChipAttributes_t, T, A>( i_pTarget, G_proc_chip_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_PERV)
+    {
+         __get<K, fapi2attr::PervAttributes_t, T, A>( i_pTarget, G_perv_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_CORE)
+    {
+        __get<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_core_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_EQ)
+    {
+        __get<K, fapi2attr::EQAttributes_t, T, A>( i_pTarget, G_eq_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_EX)
+    {
+        __get<K, fapi2attr::EXAttributes_t, T, A>( i_pTarget, G_ex_attributes_ptr, i_id, &o_value );
+    }
+
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Get int64_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _get(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                int64_t& o_value)
+{
+    static_assert(std::is_same<T, int64_t>::value, "Attribute type mismatch");
+
+    if(K & TARGET_TYPE_SYSTEM)
+    {
+        __set<K, fapi2attr::SystemAttributes_t, T, A>( i_pTarget, G_system_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_PROC_CHIP)
+    {
+        __get<K, fapi2attr::ProcChipAttributes_t, T, A>( i_pTarget, G_proc_chip_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_PERV)
+    {
+         __get<K, fapi2attr::PervAttributes_t, T, A>( i_pTarget, G_perv_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_CORE)
+    {
+        __get<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_core_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_EQ)
+    {
+        __get<K, fapi2attr::EQAttributes_t, T, A>( i_pTarget, G_eq_attributes_ptr, i_id, &o_value );
+    }
+
+    if(K & TARGET_TYPE_EX)
+    {
+        __get<K, fapi2attr::EXAttributes_t, T, A>( i_pTarget, G_ex_attributes_ptr, i_id, &o_value );
+    }
+
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Get Override int8_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _getOverride(const AttributeId i_id,
+                        const Target<K> & i_pTarget,
+                        int8_t& o_value)
+{
+    static_assert(std::is_same<T, int8_t>::value, "Attribute type mismatch");
+
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Get Override int16_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _getOverride(const AttributeId i_id,
+                        const Target<K> & i_pTarget,
+                        int16_t& o_value)
+{
+    static_assert(std::is_same<T, int16_t>::value, "Attribute type mismatch");
+
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Get Override int32_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _getOverride(const AttributeId i_id,
+                        const Target<K> & i_pTarget,
+                        int32_t& o_value)
+{
+    static_assert(std::is_same<T, int32_t>::value, "Attribute type mismatch");
+
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Get Override int64_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _getOverride(const AttributeId i_id,
+                        const Target<K> & i_pTarget,
+                        int64_t& o_value)
+{
+    static_assert(std::is_same<T, int64_t>::value, "Attribute type mismatch");
+
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Get int8_t array
+//******************************************************************************
+template<TargetType K>
+ReturnCode _getAttributeArraySignedShort(const AttributeId i_id,
+                                         const Target<K> & i_pTarget,
+                                         int8_t * o_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Set int8_t array
+//******************************************************************************
+template<TargetType K>
+ReturnCode _setAttributeArraySignedShort(const AttributeId i_id,
+                                         const Target<K> & i_pTarget,
+                                         int8_t * i_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Get int16_t array
+//******************************************************************************
+template<TargetType K>
+ReturnCode _getAttributeArraySignedWord(const AttributeId i_id,
+                                        const Target<K> & i_pTarget,
+                                        int16_t * o_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Set int16_t array
+//******************************************************************************
+template<TargetType K>
+ReturnCode _setAttributeArraySignedWord(const AttributeId i_id,
+                                        const Target<K> & i_pTarget,
+                                        int16_t * i_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Get int32_t array
+//******************************************************************************
+template<TargetType K>
+ReturnCode _getAttributeArraySignedWord(const AttributeId i_id,
+                                        const Target<K> & i_pTarget,
+                                        int32_t * o_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Set int32_t array
+//******************************************************************************
+template<TargetType K>
+ReturnCode _setAttributeArraySignedWord(const AttributeId i_id,
+                                        const Target<K> & i_pTarget,
+                                        int32_t * i_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Get int64_t array
+//******************************************************************************
+template<TargetType K>
+ReturnCode _getAttributeArraySignedDoubleWord(const AttributeId i_id,
+                                              const Target<K> & i_pTarget,
+                                              int64_t * o_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Set int64_t array
+//******************************************************************************
+template<TargetType K>
+ReturnCode _setAttributeArraySignedDoubleWord(const AttributeId i_id,
+                                              const Target<K> & i_pTarget,
+                                              int64_t * i_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Get Override int8_t array
+//******************************************************************************
+template<TargetType K>
+ReturnCode _getAttributeOverrideArraySignedShort(const AttributeId i_id,
+                                                 const Target<K> & i_pTarget,
+                                                 int8_t * o_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Get Override int16_t array
+//******************************************************************************
+template<TargetType K>
+ReturnCode _getAttributeOverrideArraySignedWord(const AttributeId i_id,
+                                                const Target<K> & i_pTarget,
+                                                int16_t * o_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Get Override int32_t array
+//******************************************************************************
+template<TargetType K>
+ReturnCode _getAttributeOverrideArraySignedWord(const AttributeId i_id,
+                                                const Target<K> & i_pTarget,
+                                                int32_t * o_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Get Override int64_t array
+//******************************************************************************
+template<TargetType K>
+ReturnCode _getAttributeOverrideArraySignedDoubleWord(const AttributeId i_id,
+                                                      const Target<K> & i_pTarget,
+                                                      int64_t * o_pValues)
+{
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Set int8_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _set(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                const int8_t& i_value)
+{
+    static_assert(std::is_same<T, int8_t>::value, "Attribute type mismatch"); // May need to remove
+
+    if(K & TARGET_TYPE_SYSTEM)
+    {
+        __set<K, fapi2attr::SystemAttributes_t, T, A>( i_pTarget, G_system_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_PROC_CHIP)
+    {
+        __set<K, fapi2attr::ProcChipAttributes_t, T, A>( i_pTarget, G_proc_chip_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_PERV)
+    {
+        __set<K, fapi2attr::PervAttributes_t, T, A>( i_pTarget, G_perv_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_CORE)
+    {
+        __set<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_core_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_EQ)
+    {
+        __set<K, fapi2attr::EQAttributes_t, T, A>( i_pTarget, G_eq_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_EX)
+    {
+        __set<K, fapi2attr::EXAttributes_t, T, A>( i_pTarget, G_ex_attributes_ptr, i_id, i_value );
+    }
+
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Set int16_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _set(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                const int16_t& i_value)
+{
+    static_assert(std::is_same<T, int16_t>::value, "Attribute type mismatch"); // May need to remove
+
+    if(K & TARGET_TYPE_SYSTEM)
+    {
+        __set<K, fapi2attr::SystemAttributes_t, T, A>( i_pTarget, G_system_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_PROC_CHIP)
+    {
+        __set<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_proc_chip_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_PERV)
+    {
+        __set<K, fapi2attr::ProcChipAttributes_t, T, A>( i_pTarget, G_perv_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_CORE)
+    {
+        __set<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_core_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_EQ)
+    {
+        __set<K, fapi2attr::EQAttributes_t, T, A>( i_pTarget, G_eq_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_EX)
+    {
+        __set<K, fapi2attr::EXAttributes_t, T, A>( i_pTarget, G_ex_attributes_ptr, i_id, i_value );
+    }
+
+    return FAPI2_RC_SUCCESS;
+}
+
+//******************************************************************************
+// Set int32_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _set(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                const int32_t& i_value)
+{
+    static_assert(std::is_same<T, int32_t>::value, "Attribute type mismatch"); // May need to remove
+
+    if(K & TARGET_TYPE_SYSTEM)
+    {
+        __set<K, fapi2attr::SystemAttributes_t, T, A>( i_pTarget, G_system_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_PROC_CHIP)
+    {
+        __set<K, fapi2attr::ProcChipAttributes_t, T, A>( i_pTarget, G_proc_chip_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_PERV)
+    {
+        __set<K, fapi2attr::PervAttributes_t, T, A>( i_pTarget, G_perv_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_CORE)
+    {
+        __set<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_core_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_EQ)
+    {
+        __set<K, fapi2attr::EQAttributes_t, T, A>( i_pTarget, G_eq_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_EX)
+    {
+        __set<K, fapi2attr::EXAttributes_t, T, A>( i_pTarget, G_ex_attributes_ptr, i_id, i_value );
+    }
+
+    return FAPI2_RC_SUCCESS;
+}
+
+
+//******************************************************************************
+// Set int64_t
+//******************************************************************************
+template<typename T, TargetType K, AttributeId A>
+ReturnCode _set(const AttributeId i_id,
+                const Target<K> & i_pTarget,
+                const int64_t & i_value)
+{
+    static_assert(std::is_same<T, int64_t>::value, "Attribute type mismatch"); // May need to remove
+
+    if(K & TARGET_TYPE_SYSTEM)
+    {
+        __set<K, fapi2attr::SystemAttributes_t, T, A>( i_pTarget, G_system_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_PROC_CHIP)
+    {
+        __set<K, fapi2attr::ProcChipAttributes_t, T, A>( i_pTarget, G_proc_chip_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_PERV)
+    {
+        __set<K, fapi2attr::PervAttributes_t, T, A>( i_pTarget, G_perv_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_CORE)
+    {
+        __set<K, fapi2attr::CoreAttributes_t, T, A>( i_pTarget, G_core_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_EQ)
+    {
+        __set<K, fapi2attr::EQAttributes_t, T, A>( i_pTarget, G_eq_attributes_ptr, i_id, i_value );
+    }
+
+    if(K & TARGET_TYPE_EX)
+    {
+        __set<K, fapi2attr::EXAttributes_t, T, A>( i_pTarget, G_ex_attributes_ptr, i_id, i_value );
+    }
+
+    return FAPI2_RC_SUCCESS;
+}
+
+
+} // namespace fapi2
+#endif // FAPIPLATATTRIBUTESERVICE_H_