path: root/src/usr/i2c/eepromdd.C

/* IBM_PROLOG_BEGIN_TAG                                                   */
/* This is an automatically generated prolog.                             */
/*                                                                        */
/* $Source: src/usr/i2c/eepromdd.C $                                      */
/*                                                                        */
/* IBM CONFIDENTIAL                                                       */
/*                                                                        */
/* COPYRIGHT International Business Machines Corp. 2011,2013              */
/*                                                                        */
/* p1                                                                     */
/*                                                                        */
/* Object Code Only (OCO) source materials                                */
/* Licensed Internal Code Source Materials                                */
/* IBM HostBoot Licensed Internal Code                                    */
/*                                                                        */
/* The source code for this program is not published or otherwise         */
/* divested of its trade secrets, irrespective of what has been           */
/* deposited with the U.S. Copyright Office.                              */
/*                                                                        */
/* Origin: 30                                                             */
/*                                                                        */
/* IBM_PROLOG_END_TAG                                                     */
/**
 * @file eepromdd.C
 *
 * @brief Implementation of the EEPROM device driver,
 *      which will access various EEPROMs within the
 *      system via the I2C device driver
 *
 */

// ----------------------------------------------
// Includes
// ----------------------------------------------
#include <string.h>
#include <sys/time.h>

#include <trace/interface.H>
#include <errl/errlentry.H>
#include <errl/errlmanager.H>
#include <errl/errludtarget.H>
#include <targeting/common/targetservice.H>
#include <devicefw/driverif.H>
#include <sys/time.h>
#include <i2c/eepromddreasoncodes.H>
#include <i2c/eepromif.H>
#include "eepromdd.H"

// ----------------------------------------------
// Globals
// ----------------------------------------------
mutex_t g_eepromMutex = MUTEX_INITIALIZER;

// ----------------------------------------------
// Trace definitions
// ----------------------------------------------
trace_desc_t* g_trac_eeprom = NULL;
TRAC_INIT( & g_trac_eeprom, "EEPROM", KILOBYTE );

trace_desc_t* g_trac_eepromr = NULL;
TRAC_INIT( & g_trac_eepromr, "EEPROMR", KILOBYTE );

// Easy macro replace for unit testing
//#define TRACUCOMP(args...)  TRACFCOMP(args)
#define TRACUCOMP(args...)

// ----------------------------------------------
// Defines
// ----------------------------------------------
#define MAX_BYTE_ADDR 2
// ----------------------------------------------

namespace EEPROM
{

// Register the perform Op with the routing code for Procs.
DEVICE_REGISTER_ROUTE( DeviceFW::WILDCARD,
                       DeviceFW::EEPROM,
                       TARGETING::TYPE_PROC,
                       eepromPerformOp );

// Register the perform Op with the routing code for DIMMs.
DEVICE_REGISTER_ROUTE( DeviceFW::WILDCARD,
                       DeviceFW::EEPROM,
                       TARGETING::TYPE_DIMM,
                       eepromPerformOp );

// Register the perform Op with the routing code for Memory Buffers.
DEVICE_REGISTER_ROUTE( DeviceFW::WILDCARD,
                       DeviceFW::EEPROM,
                       TARGETING::TYPE_MEMBUF,
                       eepromPerformOp );


// ------------------------------------------------------------------
// eepromPerformOp
// ------------------------------------------------------------------
errlHndl_t eepromPerformOp( DeviceFW::OperationType i_opType,
                            TARGETING::Target * i_target,
                            void * io_buffer,
                            size_t & io_buflen,
                            int64_t i_accessType,
                            va_list i_args )
{
    errlHndl_t err = NULL;
    TARGETING::Target * theTarget = NULL;
    eeprom_addr_t i2cInfo;

    i2cInfo.chip = va_arg( i_args, uint64_t );
    i2cInfo.offset = va_arg( i_args, uint64_t );

    TRACDCOMP( g_trac_eeprom,
               ENTER_MRK"eepromPerformOp()" );

    TRACUCOMP (g_trac_eeprom, ENTER_MRK"eepromPerformOp(): "
               "i_opType=%d, chip=%d, offset=%d, len=%d",
               (uint64_t) i_opType, i2cInfo.chip, i2cInfo.offset, io_buflen);


    do
    {
        // Read Attributes needed to complete the operation
        err = eepromReadAttributes( i_target,
                                    i2cInfo );

        if( err )
        {
            break;
        }

        // Check to see if we need to find a new target for
        // the I2C Master
        err = eepromGetI2CMasterTarget( i_target,
                                        i2cInfo,
                                        theTarget );

        if( err )
        {
            break;
        }

        // Check that the offset + data length is less than device max size
        if ( ( i2cInfo.offset + io_buflen ) >
             ( i2cInfo.devSize_KB * KILOBYTE  ) )
        {
            TRACFCOMP( g_trac_eeprom,
                       ERR_MRK"eepromPerformOp(): Device Overflow! "
                       "C-p/e/dA=%d-%d/%d/0x%X, offset=0x%X, len=0x%X "
                       "devSizeKB=0x%X", i2cInfo.chip, i2cInfo.port,
                       i2cInfo.engine, i2cInfo.devAddr, i2cInfo.offset,
                       io_buflen, i2cInfo.devSize_KB);


            /*@
             * @errortype
             * @reasoncode       EEPROM_OVERFLOW_ERROR
             * @severity         ERRL_SEV_UNRECOVERABLE
             * @moduleid         EEPROM_PERFORM_OP
             * @userdata1[0:31]  Offset
             * @userdata1[32:63] Buffer Length
             * @userdata2        Device Max Size (in KB)
             * @devdesc          I2C Buffer Length + Offset > Max Size
             */
            err = new ERRORLOG::ErrlEntry( ERRORLOG::ERRL_SEV_UNRECOVERABLE,
                                           EEPROM_PERFORM_OP,
                                           EEPROM_OVERFLOW_ERROR,
                                           TWO_UINT32_TO_UINT64(
                                               i2cInfo.offset,
                                               io_buflen       ),
                                           i2cInfo.devSize_KB );
            break;
        }

        // Do the read or write
        if( i_opType == DeviceFW::READ )
        {
            err = eepromRead( theTarget,
                              io_buffer,
                              io_buflen,
                              i2cInfo );

            if( err )
            {
                break;
            }
        }
        else if( i_opType == DeviceFW::WRITE )
        {
            err = eepromWrite( theTarget,
                               io_buffer,
                               io_buflen,
                               i2cInfo );

            if( err )
            {
                break;
            }
        }
        else
        {
            TRACFCOMP( g_trac_eeprom,
                       ERR_MRK"eepromPerformOp(): Invalid EEPROM Operation!");

            /*@
             * @errortype
             * @reasoncode     EEPROM_INVALID_OPERATION
             * @severity       ERRL_SEV_UNRECOVERABLE
             * @moduleid       EEPROM_PERFORM_OP
             * @userdata1      Operation Type
             * @userdata2      Chip to Access
             * @devdesc        Invalid Operation type.
             */
            err = new ERRORLOG::ErrlEntry( ERRORLOG::ERRL_SEV_UNRECOVERABLE,
                                           EEPROM_PERFORM_OP,
                                           EEPROM_INVALID_OPERATION,
                                           i_opType,
                                           i2cInfo.chip );

            break;
        }
    } while( 0 );


    // If there is an error, add target to log
    if ( (err != NULL) && (i_target != NULL) )
    {
        ERRORLOG::ErrlUserDetailsTarget(i_target).addToLog(err);
    }

    TRACDCOMP( g_trac_eeprom,
               EXIT_MRK"eepromPerformOp() - %s",
               ((NULL == err) ? "No Error" : "With Error") );

    return err;
} // end eepromPerformOp


// ------------------------------------------------------------------
// eepromRead
// ------------------------------------------------------------------
errlHndl_t eepromRead ( TARGETING::Target * i_target,
                        void * o_buffer,
                        size_t i_buflen,
                        eeprom_addr_t i_i2cInfo )
{
    errlHndl_t err = NULL;
    uint8_t byteAddr[MAX_BYTE_ADDR];
    size_t byteAddrSize = 0;
    bool unlock = false;

    TRACDCOMP( g_trac_eeprom,
               ENTER_MRK"eepromRead()" );

    do
    {
        TRACSCOMP( g_trac_eepromr,
                   "EEPROM READ  START : Chip: %02d : Offset %.2X : Len %d",
                   i_i2cInfo.chip, i_i2cInfo.offset, i_buflen );

        err = eepromPrepareAddress( &byteAddr,
                                    byteAddrSize,
                                    i_i2cInfo );

        if( err )
        {
            break;
        }

        // Lock to sequence operations
        mutex_lock( &g_eepromMutex );
        unlock = true;

        // Only write the byte address if we have data to write
        if( 0 != byteAddrSize )
        {

            // Use the I2C OFFSET Interface for the READ
            err = deviceOp( DeviceFW::READ,
                            i_target,
                            o_buffer,
                            i_buflen,
                            DEVICE_I2C_ADDRESS_OFFSET(
                                       i_i2cInfo.port,
                                       i_i2cInfo.engine,
                                       i_i2cInfo.devAddr,
                                       byteAddrSize,
                                       reinterpret_cast<uint8_t*>(&byteAddr)));

            if( err )
            {
                TRACFCOMP(g_trac_eeprom,
                          ERR_MRK"eepromRead(): I2C Read-Offset failed on "
                          "%d/%d/0x%X",
                          i_i2cInfo.port, i_i2cInfo.engine, i_i2cInfo.devAddr);
                break;
            }
        }
        else
        {
            // Do the actual read via I2C
            err = deviceOp( DeviceFW::READ,
                            i_target,
                            o_buffer,
                            i_buflen,
                            DEVICE_I2C_ADDRESS( i_i2cInfo.port,
                                                i_i2cInfo.engine,
                                                i_i2cInfo.devAddr ) );

            if( err )
            {
                TRACFCOMP(g_trac_eeprom,
                          ERR_MRK"eepromRead(): I2C Read failed on %d/%d/0x%0X",
                          i_i2cInfo.port, i_i2cInfo.engine, i_i2cInfo.devAddr);
                break;
            }
        }

        mutex_unlock( &g_eepromMutex );
        unlock = false;

        TRACSCOMP( g_trac_eepromr,
                   "EEPROM READ  END   : Chip: %02d : Offset %.2X : Len %d : %016llx",
                   i_i2cInfo.chip, i_i2cInfo.offset, i_buflen,
                   *((uint64_t*)o_buffer) );

    } while( 0 );

    // Catch it if we break out early.
    if( unlock )
    {
        mutex_unlock( & g_eepromMutex );
    }

    TRACDCOMP( g_trac_eeprom,
               EXIT_MRK"eepromRead()" );

    return err;
} // end eepromRead


// ------------------------------------------------------------------
// eepromWrite
// ------------------------------------------------------------------
errlHndl_t eepromWrite ( TARGETING::Target * i_target,
                         void * io_buffer,
                         size_t io_buflen,
                         eeprom_addr_t i_i2cInfo )
{
    errlHndl_t err = NULL;
    uint8_t byteAddr[MAX_BYTE_ADDR];
    size_t byteAddrSize = 0;
    uint8_t * newBuffer = NULL;
    bool needFree = false;
    bool unlock = false;

    TRACDCOMP( g_trac_eeprom,
               ENTER_MRK"eepromWrite()" );

    do
    {
        TRACSCOMP( g_trac_eepromr,
                   "EEPROM WRITE START : Chip: %02d : Offset %.2X : Len %d : %016llx",
                   i_i2cInfo.chip, i_i2cInfo.offset, io_buflen,
                   *((uint64_t*)io_buffer) );

        err = eepromPrepareAddress( &byteAddr,
                                    byteAddrSize,
                                    i_i2cInfo );

        if( err )
        {
            break;
        }


        // EEPROM devices have write page boundaries, so when necessary
        // need to split up command into multiple write operations

        // Setup a max-size buffer of writePageSize
        size_t newBufLen = i_i2cInfo.writePageSize;
        newBuffer = static_cast<uint8_t*>(malloc( newBufLen ));
        needFree = true;

        // Point a uint8_t ptr at io_buffer for array addressing below
        uint8_t * l_data_ptr = reinterpret_cast<uint8_t*>(io_buffer);

        // Lock for operation sequencing
        mutex_lock( &g_eepromMutex );
        unlock = true;

        // variables to store different amount of data length
        size_t loop_data_length = 0;
        size_t total_bytes_written = 0;

        for ( uint64_t i = 0 ;
              (i * i_i2cInfo.writePageSize) < io_buflen ;
              i++)
        {

            if ( (io_buflen - (i * i_i2cInfo.writePageSize) )
                 >= i_i2cInfo.writePageSize)
            {
                // Data to write >= to writePageSize, so write
                //  the maximum amount: writePageSize
                loop_data_length = i_i2cInfo.writePageSize;
            }
            else
            {
                // Less than writePageSize to write
                loop_data_length = io_buflen % i_i2cInfo.writePageSize;
            }

            // Add the data the user wanted to write
            memcpy( newBuffer,
                    &l_data_ptr[i * i_i2cInfo.writePageSize],
                    loop_data_length);



            // Update the offset for each loop after the first one
            if ( i > 0 )
            {
                i_i2cInfo.offset += i_i2cInfo.writePageSize;
            }

            // Setup offset/address parms
            err = eepromPrepareAddress(  &byteAddr,
                                         byteAddrSize,
                                         i_i2cInfo );

            if( err )
            {
                break;
            }


            TRACUCOMP(g_trac_eeprom,"eepromWrite() Loop: %d/%d/0x%X "
                "loop=%d, l_d_l=%d, offset=0x%X, bAS=%d",
                i_i2cInfo.port, i_i2cInfo.engine, i_i2cInfo.devAddr,
                i, loop_data_length, i_i2cInfo.offset, byteAddrSize);


            // Do the actual data write
            err = deviceOp( DeviceFW::WRITE,
                            i_target,
                            newBuffer,
                            loop_data_length,
                            DEVICE_I2C_ADDRESS_OFFSET(
                                               i_i2cInfo.port,
                                               i_i2cInfo.engine,
                                               i_i2cInfo.devAddr,
                                               byteAddrSize,
                                               reinterpret_cast<uint8_t*>(
                                               &byteAddr)));

            if( err )
            {
                TRACFCOMP(g_trac_eeprom,
                    ERR_MRK"eepromWrite(): I2C Write failed on %d/%d/0x%X "
                    "loop=%d, l_d_l=%d, offset=0x%X, aS=%d",
                    i_i2cInfo.port, i_i2cInfo.engine, i_i2cInfo.devAddr, i,
                    loop_data_length, i_i2cInfo.offset, i_i2cInfo.addrSize);

                // Can't assume that anything was written if
                // there was an error, so no update to total_bytes_written
                // for this loop
                break;
            }

            // Wait 5ms for EEPROM o write data to its internal memory
            nanosleep(0,5 * NS_PER_MSEC);   // 5 msec


            // Update how much data was written
            total_bytes_written += loop_data_length;

        } // end of write for-loop

        // Release mutex lock
        mutex_unlock( &g_eepromMutex );
        unlock = false;

        // Set how much data was actually written
        io_buflen = total_bytes_written;

        if( err )
        {
            // Leave do-while loop
            break;
        }

        TRACSCOMP( g_trac_eepromr,
                   "EEPROM WRITE END   : Chip: %02d : Offset %.2X : Len %d",
                   i_i2cInfo.chip, i_i2cInfo.offset, io_buflen );
    } while( 0 );

    // Free memory
    if( needFree )
    {
        free( newBuffer );
    }

    // Catch it if we break out early.
    if( unlock )
    {
        mutex_unlock( & g_eepromMutex );
    }

    TRACDCOMP( g_trac_eeprom,
               EXIT_MRK"eepromWrite()" );

    return err;
} // end eepromWrite


// ------------------------------------------------------------------
// eepromPrepareAddress
// ------------------------------------------------------------------
errlHndl_t eepromPrepareAddress ( void * io_buffer,
                                  size_t & o_bufSize,
                                  eeprom_addr_t i_i2cInfo )
{
    errlHndl_t err = NULL;

    o_bufSize = 0;

    TRACDCOMP( g_trac_eeprom,
               ENTER_MRK"eepromPrepareAddress()" );

    do
    {

        // --------------------------------------------------------------------
        // Currently only supporting I2C devices and that use 0, 1, or 2 bytes
        // to set the offset (ie, internal address) into the device.
        // --------------------------------------------------------------------
        switch( i_i2cInfo.addrSize )
        {
            case TWO_BYTE_ADDR:
                o_bufSize = 2;
                memset( io_buffer, 0x0, o_bufSize );
                *((uint8_t*)io_buffer) = (i_i2cInfo.offset & 0xFF00ull) >> 8;
                *((uint8_t*)io_buffer+1) = (i_i2cInfo.offset & 0x00FFull);
                break;

            case ONE_BYTE_ADDR:
                o_bufSize = 1;
                memset( io_buffer, 0x0, o_bufSize );
                *((uint8_t*)io_buffer) = (i_i2cInfo.offset & 0xFFull);
                break;

            case ZERO_BYTE_ADDR:
                o_bufSize = 0;
                // nothing to do with the buffer in this case
                break;

            default:
                TRACFCOMP( g_trac_eeprom,
                           ERR_MRK"eepromPrepareAddress() - Invalid Device "
                           "Address Size: 0x%08x", i_i2cInfo.addrSize);

                /*@
                 * @errortype
                 * @reasoncode       EEPROM_INVALID_DEVICE_TYPE
                 * @severity         ERRL_SEV_UNRECOVERABLE
                 * @moduleid         EEPROM_PREPAREADDRESS
                 * @userdata1        Address Size (aka Device Type)
                 * @userdata2        EEPROM chip
                 * @devdesc          The Device type not supported (addrSize)
                 */
                err = new ERRORLOG::ErrlEntry( ERRORLOG::ERRL_SEV_UNRECOVERABLE,
                                               EEPROM_PREPAREADDRESS,
                                               EEPROM_INVALID_DEVICE_TYPE,
                                               i_i2cInfo.addrSize,
                                               i_i2cInfo.chip);
                break;
        }

    } while( 0 );

    TRACDCOMP( g_trac_eeprom,
               EXIT_MRK"eepromPrepareAddress()" );

    return err;
} // end eepromPrepareAddress


// ------------------------------------------------------------------
// eepromReadAttributes
// ------------------------------------------------------------------
errlHndl_t eepromReadAttributes ( TARGETING::Target * i_target,
                                  eeprom_addr_t & o_i2cInfo )
{
    errlHndl_t err = NULL;
    bool fail_reading_attribute = false;

    TRACDCOMP( g_trac_eeprom,
               ENTER_MRK"eepromReadAttributes()" );

    // These variables will be used to hold the EEPROM attribute data
    // Note:  each 'EepromVpd' struct is kept the same via the attributes
    //        so will be copying each to eepromData to save code space
    TARGETING::EepromVpdPrimaryInfo eepromData;

    do
    {

        switch (o_i2cInfo.chip )
        {
            case VPD_PRIMARY:
                if( !( i_target->
                         tryGetAttr<TARGETING::ATTR_EEPROM_VPD_PRIMARY_INFO>
                             ( eepromData ) ) )

                {
                    fail_reading_attribute = true;
                }
                break;

            case VPD_BACKUP:

                if( !(i_target->
                        tryGetAttr<TARGETING::ATTR_EEPROM_VPD_BACKUP_INFO>
                        ( reinterpret_cast<
                            TARGETING::ATTR_EEPROM_VPD_BACKUP_INFO_type&>
                                ( eepromData) ) ) )
                {
                    fail_reading_attribute = true;
                }
                break;

            case SBE_PRIMARY:
                if( !(i_target->
                        tryGetAttr<TARGETING::ATTR_EEPROM_SBE_PRIMARY_INFO>
                        ( reinterpret_cast<
                            TARGETING::ATTR_EEPROM_SBE_PRIMARY_INFO_type&>
                                ( eepromData) ) ) )
                {
                    fail_reading_attribute = true;
                }
                break;

            case SBE_BACKUP:

                if( (!i_target->
                        tryGetAttr<TARGETING::ATTR_EEPROM_SBE_BACKUP_INFO>
                        ( reinterpret_cast<
                            TARGETING::ATTR_EEPROM_SBE_BACKUP_INFO_type&>
                                ( eepromData) ) ) )
                {
                    fail_reading_attribute = true;
                }
                break;

            default:
                TRACFCOMP( g_trac_eeprom,ERR_MRK"eepromReadAttributes() - "
                           "Invalid chip (%d) to read attributes from!",
                            o_i2cInfo.chip );

                /*@
                 * @errortype
                 * @reasoncode       EEPROM_INVALID_CHIP
                 * @severity         ERRORLOG::ERRL_SEV_UNRECOVERABLE
                 * @moduleid         EEPROM_READATTRIBUTES
                 * @userdata1        EEPROM Chip
                 * @userdata2        HUID of target
                 * @devdesc          Invalid EEPROM chip to access
                 */
                err = new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_UNRECOVERABLE,
                                           EEPROM_READATTRIBUTES,
                                           EEPROM_INVALID_CHIP,
                                           o_i2cInfo.chip,
                                           TARGETING::get_huid(i_target) );

                break;
        }

        // Check if Attribute Data was found
        if( fail_reading_attribute == true )
        {
            TRACFCOMP( g_trac_eeprom,
                       ERR_MRK"eepromReadAttributes() - ERROR reading "
                       "attributes for chip %d!",
                       o_i2cInfo.chip );

                /*@
                 * @errortype
                 * @reasoncode       EEPROM_ATTR_INFO_NOT_FOUND
                 * @severity         ERRORLOG::ERRL_SEV_UNRECOVERABLE
                 * @moduleid         EEPROM_READATTRIBUTES
                 * @userdata1        HUID of target
                 * @userdata2        EEPROM chip
                 * @devdesc          EEPROM Attribute was not found
                 */
                err = new ERRORLOG::ErrlEntry(
                                    ERRORLOG::ERRL_SEV_UNRECOVERABLE,
                                    EEPROM_READATTRIBUTES,
                                    EEPROM_ATTR_INFO_NOT_FOUND,
                                    TARGETING::get_huid(i_target),
                                    o_i2cInfo.chip);

                break;

        }

        // Successful reading of Attribute, so extract the data
        o_i2cInfo.port          = eepromData.port;
        o_i2cInfo.devAddr       = eepromData.devAddr;
        o_i2cInfo.engine        = eepromData.engine;
        o_i2cInfo.i2cMasterPath = eepromData.i2cMasterPath;
        o_i2cInfo.writePageSize = eepromData.writePageSize;
        o_i2cInfo.devSize_KB    = eepromData.maxMemorySizeKB;

        // Convert attribute info to eeprom_addr_size_t enum
        if ( eepromData.byteAddrOffset == 0x2 )
        {
            o_i2cInfo.addrSize = TWO_BYTE_ADDR;
        }
        else if ( eepromData.byteAddrOffset == 0x1 )
        {
            o_i2cInfo.addrSize = ONE_BYTE_ADDR;
        }
        else if ( eepromData.byteAddrOffset == 0x0 )
        {
            o_i2cInfo.addrSize = ZERO_BYTE_ADDR;
        }
        else
        {
            TRACFCOMP( g_trac_eeprom,
                       ERR_MRK"eepromReadAttributes() - INVALID ADDRESS "
                       "OFFSET SIZE %d!",
                       o_i2cInfo.addrSize );

                /*@
                 * @errortype
                 * @reasoncode       EEPROM_INVALID_ADDR_OFFSET_SIZE
                 * @severity         ERRORLOG::ERRL_SEV_UNRECOVERABLE
                 * @moduleid         EEPROM_READATTRIBUTES
                 * @userdata1        HUID of target
                 * @userdata2        Address Offset Size
                 * @devdesc          Invalid Address Offset Size
                 */
                err = new ERRORLOG::ErrlEntry(
                                    ERRORLOG::ERRL_SEV_UNRECOVERABLE,
                                    EEPROM_READATTRIBUTES,
                                    EEPROM_INVALID_ADDR_OFFSET_SIZE,
                                    TARGETING::get_huid(i_target),
                                    o_i2cInfo.addrSize);

                break;

        }

    } while( 0 );

    TRACUCOMP(g_trac_eeprom,"eepromReadAttributes() %d/%d/0x%X "
              "wpw=0x%X, dsKb=0x%X, aS=%d (%d)",
              o_i2cInfo.port, o_i2cInfo.engine, o_i2cInfo.devAddr,
              o_i2cInfo.writePageSize, o_i2cInfo.devSize_KB,
              o_i2cInfo.addrSize, eepromData.byteAddrOffset);


    TRACDCOMP( g_trac_eeprom,
               EXIT_MRK"eepromReadAttributes()" );

    return err;
} // end eepromReadAttributes


// ------------------------------------------------------------------
// eepromGetI2CMasterTarget
// ------------------------------------------------------------------
errlHndl_t eepromGetI2CMasterTarget ( TARGETING::Target * i_target,
                                      eeprom_addr_t i_i2cInfo,
                                      TARGETING::Target * &o_target )
{
    errlHndl_t err = NULL;
    o_target = NULL;

    TRACDCOMP( g_trac_eeprom,
               ENTER_MRK"eepromGetI2CMasterTarget()" );

    do
    {
        if( TARGETING::TYPE_DIMM == i_target->getAttr<TARGETING::ATTR_TYPE>() )
        {
            TARGETING::TargetService& tS = TARGETING::targetService();

            // For DIMMs we need to get the parent that contains the
            // I2C Master that talks to the DIMM EEPROM

            // The path was read from the attribute via eepromReadAttributes()
            // and passed to this function in i_i2cInfo


            // check that the path exists
            bool exists = false;
            tS.exists( i_i2cInfo.i2cMasterPath,
                       exists );

            if( !exists )
            {
                TRACFCOMP( g_trac_eeprom,
                           ERR_MRK"eepromGetI2CMasterTarget() - i2cMasterPath attribute path "
                           "doesn't exist!" );

                /*@
                 * @errortype
                 * @reasoncode       EEPROM_DIMM_I2C_MASTER_PATH_ERROR
                 * @severity         ERRORLOG::ERRL_SEV_UNRECOVERABLE
                 * @moduleid         EEPROM_GETI2CMASTERTARGET
                 * @userdata1        Attribute Chip Type Enum
                 * @userdata2        HUID of target
                 * @devdesc          DIMM I2C Master Entity path doesn't exist.
                 */
                err = new ERRORLOG::ErrlEntry(
                                    ERRORLOG::ERRL_SEV_UNRECOVERABLE,
                                    EEPROM_GETI2CMASTERTARGET,
                                    EEPROM_DIMM_I2C_MASTER_PATH_ERROR,
                                    i_i2cInfo.chip,
                                    TARGETING::get_huid(i_target) );

                break;
            }

            // Since it exists, convert to a target
            o_target = tS.toTarget( i_i2cInfo.i2cMasterPath );

            if( NULL == o_target )
            {
                TRACFCOMP( g_trac_eeprom,
                           ERR_MRK"eepromGetI2CMasterTarget() - I2C Master "
                                  "Path target was NULL!" );

                /*@
                 * @errortype
                 * @reasoncode       EEPROM_TARGET_NULL
                 * @severity         ERRORLOG::ERRL_SEV_UNRECOVERABLE
                 * @moduleid         EEPROM_GETI2CMASTERTARGET
                 * @userdata1        Attribute Chip Type Enum
                 * @userdata2        HUID of target
                 * @devdesc          I2C Master Path Target is NULL.
                 */
                err = new ERRORLOG::ErrlEntry( ERRORLOG::ERRL_SEV_UNRECOVERABLE,
                                               EEPROM_GETI2CMASTERTARGET,
                                               EEPROM_TARGET_NULL,
                                               i_i2cInfo.chip,
                                               TARGETING::get_huid(i_target) );

                break;
            }
        }
        else
        {
            // Since current target is not a DIMM, use the target we have
            o_target = i_target;
        }
    } while( 0 );

    TRACDCOMP( g_trac_eeprom,
               EXIT_MRK"eepromGetI2CMasterTarget()" );

    return err;
} // end eepromGetI2CMasterTarget

} // end namespace EEPROM