path: root/Acceleration/include/accel_infra/IxPiuMh.h

/**
 * @file IxPiuMh.h
 *
 * @date 14 Dec 2001
 *
 * @brief This file contains the public API for the PIU Message
 * Handler component.
 *
 *
 * @par
 * This file is provided under a dual BSD/GPLv2 license.  When using or 
 *   redistributing this file, you may do so under either license.
 * 
 *   GPL LICENSE SUMMARY
 * 
 *   Copyright(c) 2007,2008,2009 Intel Corporation. All rights reserved.
 * 
 *   This program is free software; you can redistribute it and/or modify 
 *   it under the terms of version 2 of the GNU General Public License as
 *   published by the Free Software Foundation.
 * 
 *   This program is distributed in the hope that it will be useful, but 
 *   WITHOUT ANY WARRANTY; without even the implied warranty of 
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
 *   General Public License for more details.
 * 
 *   You should have received a copy of the GNU General Public License 
 *   along with this program; if not, write to the Free Software 
 *   Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
 *   The full GNU General Public License is included in this distribution 
 *   in the file called LICENSE.GPL.
 * 
 *   Contact Information:
 *   Intel Corporation
 * 
 *   BSD LICENSE 
 * 
 *   Copyright(c) 2007,2008,2009 Intel Corporation. All rights reserved.
 *   All rights reserved.
 * 
 *   Redistribution and use in source and binary forms, with or without 
 *   modification, are permitted provided that the following conditions 
 *   are met:
 * 
 *     * Redistributions of source code must retain the above copyright 
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright 
 *       notice, this list of conditions and the following disclaimer in 
 *       the documentation and/or other materials provided with the 
 *       distribution.
 *     * Neither the name of Intel Corporation nor the names of its 
 *       contributors may be used to endorse or promote products derived 
 *       from this software without specific prior written permission.
 * 
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 * 
 *
*/

/**
 * @defgroup IxPiuMh Intel (R) Software PIU Message Handler (IxPiuMh) API
 *
 * @brief The public API for the PIU Message Handler component.
 *
 * @{
 */

#ifndef IXPIUMH_H
#define IXPIUMH_H

#include "IxOsal.h"

/*
 * #defines for function return types, etc.
 */

#define IX_PIUMH_MIN_MESSAGE_ID (0x00) /**< minimum valid message ID */
#define IX_PIUMH_MAX_MESSAGE_ID (0xFF) /**< maximum valid message ID */

#define IX_PIUMH_SEND_RETRIES_DEFAULT (3) /**< default msg send retries */


/**
 * @def IX_PIUMH_CRITICAL_PIU_ERR
 *
 * @brief PiuMH function return value for a Critical PIU error occuring during
          sending/receiving message. Assume PIU hang / halt if this value is
          returned.
 */
#define IX_PIUMH_CRITICAL_PIU_ERR        2

/**
 * @enum IxPiuMhPiuId
 *
 * @brief The ID of a particular PIU.
 */

typedef enum
{
#if defined(__ixp23xx)
    IX_PIUMH_PIUID_PIU0 = 0, /**< ID for PIU-0 */
    IX_PIUMH_PIUID_PIU1,     /**< ID for PIU-1 */
#endif
#if defined(__tolapai)
    IX_PIUMH_PIUID_PIU0 = 0, /**< ID for PIU-0 */
#endif
#if defined(__ixp42X) || defined(__ixp46X) || defined(__ixp5XX)
  IX_PIUMH_PIUID_PIUA = 0,    /**< Identifies PIU A */
  IX_PIUMH_PIUID_PIUB,        /**< Identifies PIU B */
#endif
#if defined(__ixp42X) || defined(__ixp46X) && !defined(__ixp5XX)
  IX_PIUMH_PIUID_PIUC,        /**< Identifies PIU C */
#endif /* defined(__ixp42X) || defined(__ixp46X) && !defined(__ixp5XX) */
  IX_PIUMH_NUM_PIUS           /**< Number of PIUs */
} IxPiuMhPiuId;


/**
 * @enum IxPiuMhPiuInterrupts
 *
 * @brief Indicator specifying whether or not PIU interrupts should drive
 * receiving of messages from the PIUs.
 */

typedef enum
{
    IX_PIUMH_PIUINTERRUPTS_NO = 0, /**< Don't use PIU interrupts */
    IX_PIUMH_PIUINTERRUPTS_YES     /**< Do use PIU interrupts */
} IxPiuMhPiuInterrupts;

/**
 * @brief The 2-word message structure to send to and receive from the
 * PIUs.
 */

typedef struct
{
    UINT32 data[2]; /**< the actual data of the message */
} IxPiuMhMessage;

/** message ID */
typedef UINT32 IxPiuMhMessageId;

/**
 * @typedef IxPiuMhCallback
 *
 * @brief This prototype shows the format of a message callback function.
 *
 * This prototype shows the format of a message callback function.  The
 * message callback will be passed the message to be handled and will also
 * be told from which PIU the message was received.  The message callback
 * will either be registered by ixPiuMhUnsolicitedCallbackRegister() or
 * passed as a parameter to ixPiuMhMessageWithResponseSend().  It will be
 * called from within an ISR triggered by the PIU's "outFIFO not empty"
 * interrupt (see ixPiuMhInitialize()).  The parameters passed are the ID
 * of the PIU that the message was received from, and the message to be
 * handled.<P><B>Re-entrancy:</B> This function is only a prototype, and
 * will be implemented by the client.  It does not need to be re-entrant.
 */

typedef void (*IxPiuMhCallback) (IxPiuMhPiuId, IxPiuMhMessage);

/*
 * Prototypes for interface functions.
 */

#if defined(__tolapai)
/**
 * @ingroup IxPiuMh
 *
 * @fn IX_STATUS ixPiuMhPhysicalAddressSet (
 *         IxPiuMhPiuId piuId,
 *         UINT32 address)
 *
 * @brief This function sets the physical base address for the given PIU.
 *
 * @param piuId @ref IxPiuMhPiuId [in] - The ID of the PIU whose physical base
 * address will be set
 * @param address UINT32 [in] - The address to set the physical address to
 *
 * This function sets the physical base address for the given PIU. It must be
 * called when the piuMh component is not initialized i.e. prior to calling the
 * @ref ixPiuMhInitialize function (maps the physical address to a virtual
 * address) or after calling the @ref ixPiuMhUnload function.
 *
 * @return The function returns a status indicating success or failure.
 */
PUBLIC IX_STATUS ixPiuMhPhysicalAddressSet (
    IxPiuMhPiuId piuId,
    UINT32 address);

/**
 * @ingroup IxPiuMh
 *
 * @fn IX_STATUS ixPiuMhInterruptIdSet (
 *         IxPiuMhPiuId piuId,
 *         UINT32 interruptId)
 *
 * @brief This function sets the interruptId for the given piu
 *
 * @param piuId @ref IxPiuMhPiuId [in] - The ID of the PIU whose physical base
 * address will be set
 * @param interruptId UINT32 [in] - The interrupt ID
 *
 * This function sets the interrupt ID for the given PIU. It must be
 * called when the piuMh component is not initialized i.e. prior to calling the
 * @ref ixPiuMhInitialize function or after calling the @ref ixPiuMhUnload
 * function.
 *
 * @return The function returns a status indicating success or failure.
 */
PUBLIC IX_STATUS ixPiuMhInterruptIdSet (
    IxPiuMhPiuId piuId,
    UINT32 interruptId);

#endif // #if defined(__tolapai)



/**
 * @ingroup IxPiuMh
 *
 * @fn void ixPiuMhIsr (void *parameter)
 *
 * @brief This function is the piuMh interrupt handler which is called to
 * receive messages from an PIU
 *
 * @param parameter void [in] - a parameter passed to the routine - in the case
 * of piuMh the parameter is the piuId
 *
 * This function is called by an external component which has registered an
 * interrupt handler for handling PIU interrupts - the PIU has multiple
 * external interrupt lines, but in some platforms these are coalesced into
 * a single interrupt as far as the main processor is concerned - in those
 * cases it is better to register the interrupt handler in an external
 * component which calls several components to handle each interrupt type
 * with the piuMh component being on type
 *
 * @return nothing
 */
void ixPiuMhIsr (void *parameter);


/**
 * @ingroup IxPiuMh
 *
 * @fn IX_STATUS ixPiuMhInitialize (
           IxPiuMhPiuInterrupts piuInterrupts)
 *
 * @brief This function will initialise the IxPiuMh component.
 *
 * @param piuInterrupts @ref IxPiuMhPiuInterrupts [in] - This parameter
 * dictates whether or not the IxPiuMh component will service PIU "outFIFO
 * not empty" interrupts to trigger receiving and processing of messages
 * from the PIUs.  If not then the client must use ixPiuMhMessagesReceive()
 * to control message receiving and processing.
 *
 * This function will initialise the IxPiuMh component.  It should only be
 * called once, prior to using the IxPiuMh component.  The following
 * actions will be performed by this function:<OL><LI>Initialization of
 * internal data structures (e.g. solicited and unsolicited callback
 * tables).</LI><LI>Configuration of the interface with the PIUs (e.g.
 * enabling of PIU "outFIFO not empty" interrupts).</LI><LI>Registration of
 * ISRs that will receive and handle messages when the PIUs' "outFIFO not
 * empty" interrupts fire (if piuInterrupts equals
 * IX_PIUMH_PIUINTERRUPTS_YES).</LI></OL>
 *
 * @return The function returns a status indicating success or failure.
 */

PUBLIC IX_STATUS ixPiuMhInitialize (
    IxPiuMhPiuInterrupts piuInterrupts);

/**
 * @ingroup IxPiuMh
 *
 * @fn IX_STATUS ixPiuMhUnload (void)
 *
 * @brief This function will uninitialise the IxPiuMh component.
 *
 * This function will uninitialise the IxPiuMh component.  It should only be
 * called once, and only if the IxPiuMh component has already been initialised.
 * No other IxPiuMh API functions should be called until @ref ixPiuMhInitialize
 * is called again.
 * If possible, this function should be called before a soft reboot or unloading
 * a kernel module to perform any clean up operations required for IxPiuMh.
 *
 * The following actions will be performed by this function:
 * <OL><LI>Unmapping of kernel memory mapped by the function
 * @ref ixPiuMhInitialize.</LI></OL>
 *
 * @return The function returns a status indicating success or failure.
 */

PUBLIC IX_STATUS ixPiuMhUnload (void);

/**
 * @ingroup IxPiuMh
 *
 * @fn IX_STATUS ixPiuMhUnsolicitedCallbackRegister (
           IxPiuMhPiuId piuId,
           IxPiuMhMessageId messageId,
           IxPiuMhCallback unsolicitedCallback)
 *
 * @brief This function will register an unsolicited callback for a
 * particular PIU and message ID.
 *
 * @param piuId @ref IxPiuMhPiuId [in] - The ID of the PIU whose messages
 * the unsolicited callback will handle.
 * @param messageId @ref IxPiuMhMessageId [in] - The ID of the messages the
 * unsolicited callback will handle.
 * @param unsolicitedCallback @ref IxPiuMhCallback [in] - The unsolicited
 * callback function.  A value of NULL will deregister any previously
 * registered callback for this PIU and message ID.
 *
 * This function will register an unsolicited message callback for a
 * particular PIU and message ID.<P>If an unsolicited callback is already
 * registered for the specified PIU and message ID then the callback will
 * be overwritten.  Only one client will be responsible for handling a
 * particular message ID associated with a PIU.  Registering a NULL
 * unsolicited callback will deregister any previously registered
 * callback.<P>The callback function will be called from an ISR that will
 * be triggered by the PIU's "outFIFO not empty" interrupt (see
 * ixPiuMhInitialize()) to handle any unsolicited messages of the specific
 * message ID received from the PIU.  Unsolicited messages will be handled
 * in the order they are received.<P>If no unsolicited callback can be
 * found for a received message then it is assumed that the message is
 * solicited.<P>If more than one client may be interested in a particular
 * unsolicited message then the suggested strategy is to register a
 * callback for the message that can itself distribute the message to
 * multiple clients as necessary.<P>See also
 * ixPiuMhUnsolicitedCallbackForRangeRegister().<P><B>Re-entrancy:</B> This
 * function will be callable from any thread at any time.  IxOsal
 * will be used for any necessary resource protection.
 *
 * @return The function returns a status indicating success or failure.
 */

PUBLIC IX_STATUS ixPiuMhUnsolicitedCallbackRegister (
    IxPiuMhPiuId piuId,
    IxPiuMhMessageId messageId,
    IxPiuMhCallback unsolicitedCallback);

/**
 * @ingroup IxPiuMh
 *
 * @fn IX_STATUS ixPiuMhUnsolicitedCallbackForRangeRegister (
           IxPiuMhPiuId piuId,
           IxPiuMhMessageId minMessageId,
           IxPiuMhMessageId maxMessageId,
           IxPiuMhCallback unsolicitedCallback)
 *
 * @brief This function will register an unsolicited callback for a
 * particular PIU and range of message IDs.
 *
 * @param piuId @ref IxPiuMhPiuId [in] - The ID of the PIU whose messages the
 * unsolicited callback will handle.
 * @param minMessageId @ref IxPiuMhMessageId [in] - The minimum message ID in
 * the range of message IDs the unsolicited callback will handle.
 * @param maxMessageId @ref IxPiuMhMessageId [in] - The maximum message ID in
 * the range of message IDs the unsolicited callback will handle.
 * @param unsolicitedCallback @ref IxPiuMhCallback [in] - The unsolicited
 * callback function.  A value of NULL will deregister any previously
 * registered callback(s) for this PIU and range of message IDs.
 *
 * This function will register an unsolicited callback for a particular PIU
 * and range of message IDs.  It is a convenience function that is
 * effectively the same as calling ixPiuMhUnsolicitedCallbackRegister() for
 * each ID in the specified range.  See
 * ixPiuMhUnsolicitedCallbackRegister() for more
 * information.<P><B>Re-entrancy:</B> This function will be callable from
 * any thread at any time.  IxOsal will be used for any necessary
 * resource protection.
 *
 * @return The function returns a status indicating success or failure.
 */

PUBLIC IX_STATUS ixPiuMhUnsolicitedCallbackForRangeRegister (
    IxPiuMhPiuId piuId,
    IxPiuMhMessageId minMessageId,
    IxPiuMhMessageId maxMessageId,
    IxPiuMhCallback unsolicitedCallback);

/**
 * @ingroup IxPiuMh
 *
 * @fn IX_STATUS ixPiuMhMessageSend (
           IxPiuMhPiuId piuId,
           IxPiuMhMessage message,
           UINT32 maxSendRetries)
 *
 * @brief This function will send a message to a particular PIU.
 *
 * @param piuId @ref IxPiuMhPiuId [in] - The ID of the PIU to send the message
 * to.
 * @param message @ref IxPiuMhMessage [in] - The message to send.
 * @param maxSendRetries UINT32 [in] - Max num. of retries to perform
 * if the PIU's inFIFO is full.
 *
 * This function will send a message to a particular PIU.  It will be the
 * client's responsibility to ensure that the message is properly formed.
 * The return status will signify to the client if the message was
 * successfully sent or not.<P>If the message is sent to the PIU then this
 * function will return a status of success.  Note that this will only mean
 * the message has been placed in the PIU's inFIFO.  There will be no way
 * of knowing that the PIU has actually read the message, but once in the
 * incoming message queue it will be safe to assume that the PIU will
 * process it.
 * <P>The inFIFO may fill up sometimes if the Xscale is sending messages
 * faster than the PIU can handle them. This forces us to retry attempts
 * to send the message until the PIU services the inFIFO. The client should
 * specify a ceiling value for the number of retries suitable to their
 * needs. IX_PIUMH_SEND_RETRIES_DEFAULT can be used as a default value for
 * the <i>maxSendRetries</i> parameter for this function. Each retry
 * exceeding this default number will incur a blocking delay of 1 microsecond,
 * to avoid consuming too much AHB bus bandwidth while performing retries.
 * <P>Note this function <B>must</B> only be used for messages.
 * that do not solicit responses. If the message being sent will solicit a
 * response then the ixPiuMhMessageWithResponseSend() function <B>must</B>
 * be used to ensure that the response is correctly
 * handled. <P> This function will return timeout status if PIU hang / halt
 * while sending message. The timeout error is not related to the
 * <i>maxSendRetries</i> as mentioned above. The timeout error will only occur
 * if the first word of the message has been sent to PIU (not exceeding
 * <i>maxSendRetries</i> when sending 1st message word), but the second word of
 * the message can't be written to PIU's inFIFO due to PIU hang / halt after
 * maximum waiting time (IX_PIU_MH_MAX_NUM_OF_RETRIES).
 * <P><B>Re-entrancy:</B> This function will be callable from any
 * thread at any time.  IxOsal will be used for any necessary
 * resource protection.
 *
 * @return The function returns a status indicating success, failure or timeout.
 */

PUBLIC IX_STATUS ixPiuMhMessageSend (
    IxPiuMhPiuId piuId,
    IxPiuMhMessage message,
    UINT32 maxSendRetries);

/**
 * @ingroup IxPiuMh
 *
 * @fn IX_STATUS ixPiuMhMessageWithResponseSend (
           IxPiuMhPiuId piuId,
           IxPiuMhMessage message,
           IxPiuMhMessageId solicitedMessageId,
           IxPiuMhCallback solicitedCallback,
           UINT32 maxSendRetries)
 *
 * @brief This function is equivalent to the ixPiuMhMessageSend() function,
 * but must be used when the message being sent will solicited a response.
 *
 * @param piuId @ref IxPiuMhPiuId [in] - The ID of the PIU to send the message
 * to.
 * @param message @ref IxPiuMhMessage [in] - The message to send.
 * @param solicitedMessageId @ref IxPiuMhMessageId [in] - The ID of the
 * solicited response message.
 * @param solicitedCallback @ref IxPiuMhCallback [in] - The function to use to
 * pass the response message back to the client.  A value of NULL will
 * cause the response message to be discarded.
 * @param maxSendRetries UINT32 [in] - Max num. of retries to perform
 * if the PIU's inFIFO is full.
 *
 * This function is equivalent to the ixPiuMhMessageSend() function, but
 * must be used when the message being sent will solicited a
 * response.<P>The client must specify the ID of the solicited response
 * message to allow the response to be recognised when it is received.  The
 * client must also specify a callback function to handle the received
 * response.  The IxPiuMh component will not offer the facility to send a
 * message to a PIU and receive a response within the same context.<P>Note
 * if the client is not interested in the response, specifying a NULL
 * callback will cause the response message to be discarded.<P>The
 * solicited callback will be stored and called some time later from an ISR
 * that will be triggered by the PIU's "outFIFO not empty" interrupt (see
 * ixPiuMhInitialize()) to handle the response message corresponding to the
 * message sent.  Response messages will be handled in the order they are
 * received.<P>
 * <P>The inFIFO may fill up sometimes if the Xscale is sending messages
 * faster than the PIU can handle them. This forces us to retry attempts
 * to send the message until the PIU services the inFIFO. The client should
 * specify a ceiling value for the number of retries suitable to their
 * needs. IX_PIUMH_SEND_RETRIES_DEFAULT can be used as a default value for
 * the <i>maxSendRetries</i> parameter for this function. Each retry
 * exceeding this default number will incur a blocking delay of 1 microsecond,
 * to avoid consuming too much AHB bus bandwidth while performing retries.
 * <P> This function will return timeout status if PIU hang / halt
 * while sending message. The timeout error is not related to the
 * <i>maxSendRetries</i> as mentioned above. The timeout error will only occur
 * if the first word of the message has been sent to PIU (not exceeding
 * <i>maxSendRetries</i> when sending 1st message word), but the second word of
 * the message can't be written to PIU's inFIFO due to PIU hang / halt after
 * maximum waiting time (IX_PIU_MH_MAX_NUM_OF_RETRIES).
 * <P><B>Re-entrancy:</B> This function will be callable from any
 * thread at any time.  IxOsal will be used for any necessary
 * resource protection.
 *
 * @return The function returns a status indicating success or failure.
 */

PUBLIC IX_STATUS ixPiuMhMessageWithResponseSend (
    IxPiuMhPiuId piuId,
    IxPiuMhMessage message,
    IxPiuMhMessageId solicitedMessageId,
    IxPiuMhCallback solicitedCallback,
    UINT32 maxSendRetries);

/**
 * @ingroup IxPiuMh
 *
 * @fn IX_STATUS ixPiuMhMessagesReceive (
           IxPiuMhPiuId piuId)
 *
 * @brief This function will receive messages from a particular PIU and
 * pass each message to the client via a solicited callback (for solicited
 * messages) or an unsolicited callback (for unsolicited messages).
 *
 * @param piuId @ref IxPiuMhPiuId [in] - The ID of the PIU to receive and
 * process messages from.
 *
 * This function will receive messages from a particular PIU and pass each
 * message to the client via a solicited callback (for solicited messages)
 * or an unsolicited callback (for unsolicited messages).<P>If the IxPiuMh
 * component is initialised to service PIU "outFIFO not empty" interrupts
 * (see ixPiuMhInitialize()) then there is no need to call this function.
 * This function is only provided as an alternative mechanism to control
 * the receiving and processing of messages from the PIUs.<P> This function
 * will return timeout status if PIU hang / halt while receiving message. The
 * timeout error will only occur if this function has read the first word of
 * the message and can't read second word of the message from PIU's outFIFO
 * after maximum retries (IX_PIU_MH_MAX_NUM_OF_RETRIES).
 * <P>Note this function cannot be called from within
 * an ISR as it will use resource protection mechanisms.<P><B>Re-entrancy:</B>
 * This function will be callable from any thread at any time.  IxOsal will be
 * used for any necessary resource protection.
 *
 * @return The function returns a status indicating success, failure or timeout.
 */

PUBLIC IX_STATUS ixPiuMhMessagesReceive (
    IxPiuMhPiuId piuId);

/**
 * @ingroup IxPiuMh
 *
 * @fn IX_STATUS ixPiuMhShow (
           IxPiuMhPiuId piuId)
 *
 * @brief This function will display the current state of the IxPiuMh
 * component.
 *
 * <B>Re-entrancy:</B> This function will be callable from
 * any thread at any time.  However, no resource protection will be used
 * so as not to impact system performance.  As this function is only
 * reading statistical information then this is acceptable.
 *
 * @param piuId @ref IxPiuMhPiuId [in] - The ID of the PIU to display state
 * information for.
 *
 * @return The function returns a status indicating success or failure.
 */

PUBLIC IX_STATUS ixPiuMhShow (
    IxPiuMhPiuId piuId);

/**
 * @ingroup IxPiuMh
 *
 * @fn IX_STATUS ixPiuMhShowReset (
           IxPiuMhPiuId piuId)
 *
 * @brief This function will reset the current state of the IxPiuMh
 * component.
 *
 * <B>Re-entrancy:</B> This function will be callable from
 * any thread at any time.  However, no resource protection will be used
 * so as not to impact system performance.  As this function is only
 * writing statistical information then this is acceptable.
 *
 * @param piuId @ref IxPiuMhPiuId [in] - The ID of the PIU to reset state
 * information for.
 *
 * @return The function returns a status indicating success or failure.
 */

PUBLIC IX_STATUS ixPiuMhShowReset (
    IxPiuMhPiuId piuId);

#endif /* IXPIUMH_H */

/**
 * @} defgroup IxPiuMh
 */