OSCL-LXR linux-6.0.1/​include/​soc/​tegra/​bpmp-abi.h	Source navigation Diff markup Identifier search General search
	Version: linux-6.0.1 spark-3.0.0 hadoop-3.2.0-src hadoop-3.3.0-src spark-2.4.7 linux-4.15.13 hadoop-2.7.4-src Revert   Change

 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
  * Copyright (c) 2014-2020, NVIDIA CORPORATION.  All rights reserved.
  */
 
 #ifndef ABI_BPMP_ABI_H
 #define ABI_BPMP_ABI_H
 
 #if defined(LK) || defined(BPMP_ABI_HAVE_STDC)
 #include <stddef.h>
 #include <stdint.h>
 #endif
 
 #ifndef BPMP_ABI_PACKED
 #ifdef __ABI_PACKED
 #define BPMP_ABI_PACKED __ABI_PACKED
 #else
 #define BPMP_ABI_PACKED __attribute__((packed))
 #endif
 #endif
 
 #ifdef NO_GCC_EXTENSIONS
 #define BPMP_ABI_EMPTY char empty;
 #define BPMP_ABI_EMPTY_ARRAY 1
 #else
 #define BPMP_ABI_EMPTY
 #define BPMP_ABI_EMPTY_ARRAY 0
 #endif
 
 #ifndef BPMP_UNION_ANON
 #ifdef __UNION_ANON
 #define BPMP_UNION_ANON __UNION_ANON
 #else
 #define BPMP_UNION_ANON
 #endif
 #endif
 
 /**
  * @file
  */
 
 /**
  * @defgroup MRQ MRQ Messages
  * @brief Messages sent to/from BPMP via IPC
  * @{
  *   @defgroup MRQ_Format Message Format
  *   @defgroup MRQ_Codes Message Request (MRQ) Codes
  *   @defgroup MRQ_Payloads Message Payloads
  *   @defgroup Error_Codes Error Codes
  * @}
  */
 
 /**
  * @addtogroup MRQ_Format
  * @{
  * The CPU requests the BPMP to perform a particular service by
  * sending it an IVC frame containing a single MRQ message. An MRQ
  * message consists of a @ref mrq_request followed by a payload whose
  * format depends on mrq_request::mrq.
  *
  * The BPMP processes the data and replies with an IVC frame (on the
  * same IVC channel) containing and MRQ response. An MRQ response
  * consists of a @ref mrq_response followed by a payload whose format
  * depends on the associated mrq_request::mrq.
  *
  * A well-defined subset of the MRQ messages that the CPU sends to the
  * BPMP can lead to BPMP eventually sending an MRQ message to the
  * CPU. For example, when the CPU uses an #MRQ_THERMAL message to set
  * a thermal trip point, the BPMP may eventually send a single
  * #MRQ_THERMAL message of its own to the CPU indicating that the trip
  * point has been crossed.
  * @}
  */
 
 /**
  * @ingroup MRQ_Format
  * @brief Header for an MRQ message
  *
  * Provides the MRQ number for the MRQ message: #mrq. The remainder of
  * the MRQ message is a payload (immediately following the
  * mrq_request) whose format depends on mrq.
  */
 struct mrq_request {
     /** @brief MRQ number of the request */
     uint32_t mrq;
 
     /**
      * @brief Flags providing follow up directions to the receiver
      *
      * | Bit | Description                                |
      * |-----|--------------------------------------------|
      * | 1   | ring the sender's doorbell when responding |
      * | 0   | should be 1                                |
      */
     uint32_t flags;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup MRQ_Format
  * @brief Header for an MRQ response
  *
  *  Provides an error code for the associated MRQ message. The
  *  remainder of the MRQ response is a payload (immediately following
  *  the mrq_response) whose format depends on the associated
  *  mrq_request::mrq
  */
 struct mrq_response {
     /** @brief Error code for the MRQ request itself */
     int32_t err;
     /** @brief Reserved for future use */
     uint32_t flags;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup MRQ_Format
  * Minimum needed size for an IPC message buffer
  */
 #define MSG_MIN_SZ  128U
 /**
  * @ingroup MRQ_Format
  *  Minimum size guaranteed for data in an IPC message buffer
  */
 #define MSG_DATA_MIN_SZ 120U
 
 /**
  * @ingroup MRQ_Codes
  * @name Legal MRQ codes
  * These are the legal values for mrq_request::mrq
  * @{
  */
 
 #define MRQ_PING        0U
 #define MRQ_QUERY_TAG       1U
 #define MRQ_MODULE_LOAD     4U
 #define MRQ_MODULE_UNLOAD   5U
 #define MRQ_TRACE_MODIFY    7U
 #define MRQ_WRITE_TRACE     8U
 #define MRQ_THREADED_PING   9U
 #define MRQ_MODULE_MAIL     11U
 #define MRQ_DEBUGFS     19U
 #define MRQ_RESET       20U
 #define MRQ_I2C         21U
 #define MRQ_CLK         22U
 #define MRQ_QUERY_ABI       23U
 #define MRQ_PG_READ_STATE   25U
 #define MRQ_PG_UPDATE_STATE 26U
 #define MRQ_THERMAL     27U
 #define MRQ_CPU_VHINT       28U
 #define MRQ_ABI_RATCHET     29U
 #define MRQ_EMC_DVFS_LATENCY    31U
 #define MRQ_TRACE_ITER      64U
 #define MRQ_RINGBUF_CONSOLE 65U
 #define MRQ_PG          66U
 #define MRQ_CPU_NDIV_LIMITS 67U
 #define MRQ_STRAP               68U
 #define MRQ_UPHY        69U
 #define MRQ_CPU_AUTO_CC3    70U
 #define MRQ_QUERY_FW_TAG    71U
 #define MRQ_FMON        72U
 #define MRQ_EC          73U
 #define MRQ_DEBUG       75U
 
 /** @} */
 
 /**
  * @ingroup MRQ_Codes
  * @brief Maximum MRQ code to be sent by CPU software to
  * BPMP. Subject to change in future
  */
 #define MAX_CPU_MRQ_ID      75U
 
 /**
  * @addtogroup MRQ_Payloads
  * @{
  *   @defgroup Ping Ping
  *   @defgroup Query_Tag Query Tag
  *   @defgroup Module Loadable Modules
  *   @defgroup Trace Trace
  *   @defgroup Debugfs Debug File System
  *   @defgroup Reset Reset
  *   @defgroup I2C I2C
  *   @defgroup Clocks Clocks
  *   @defgroup ABI_info ABI Info
  *   @defgroup Powergating Power Gating
  *   @defgroup Thermal Thermal
  *   @defgroup Vhint CPU Voltage hint
  *   @defgroup EMC EMC
  *   @defgroup CPU NDIV Limits
  *   @defgroup RingbufConsole Ring Buffer Console
  *   @defgroup Strap Straps
  *   @defgroup UPHY UPHY
  *   @defgroup CC3 Auto-CC3
  *   @defgroup FMON FMON
  *   @defgroup EC EC
  *   @defgroup Fbvolt_status Fuse Burn Voltage Status
  * @}
  */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_PING
  * @brief A simple ping
  *
  * * Platforms: All
  * * Initiators: Any
  * * Targets: Any
  * * Request Payload: @ref mrq_ping_request
  * * Response Payload: @ref mrq_ping_response
  *
  * @ingroup MRQ_Codes
  * @def MRQ_THREADED_PING
  * @brief A deeper ping
  *
  * * Platforms: All
  * * Initiators: Any
  * * Targets: BPMP
  * * Request Payload: @ref mrq_ping_request
  * * Response Payload: @ref mrq_ping_response
  *
  * Behavior is equivalent to a simple #MRQ_PING except that BPMP
  * responds from a thread context (providing a slightly more robust
  * sign of life).
  *
  */
 
 /**
  * @ingroup Ping
  * @brief Request with #MRQ_PING
  *
  * Used by the sender of an #MRQ_PING message to request a pong from
  * recipient. The response from the recipient is computed based on
  * #challenge.
  */
 struct mrq_ping_request {
 /** @brief Arbitrarily chosen value */
     uint32_t challenge;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Ping
  * @brief Response to #MRQ_PING
  *
  * Sent in response to an #MRQ_PING message. #reply should be the
  * mrq_ping_request challenge left shifted by 1 with the carry-bit
  * dropped.
  *
  */
 struct mrq_ping_response {
     /** @brief Response to the MRQ_PING challege */
     uint32_t reply;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_QUERY_TAG
  * @brief Query BPMP firmware's tag (i.e. unique identifer)
  *
  * @deprecated Use #MRQ_QUERY_FW_TAG instead.
  *
  * * Platforms: All
  * * Initiators: CCPLEX
  * * Targets: BPMP
  * * Request Payload: @ref mrq_query_tag_request
  * * Response Payload: N/A
  *
  */
 
 /**
  * @ingroup Query_Tag
  * @brief Request with #MRQ_QUERY_TAG
  *
  * @deprecated This structure will be removed in future version.
  * Use MRQ_QUERY_FW_TAG instead.
  */
 struct mrq_query_tag_request {
   /** @brief Base address to store the firmware tag */
     uint32_t addr;
 } BPMP_ABI_PACKED;
 
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_QUERY_FW_TAG
  * @brief Query BPMP firmware's tag (i.e. unique identifier)
  *
  * * Platforms: All
  * * Initiators: Any
  * * Targets: BPMP
  * * Request Payload: N/A
  * * Response Payload: @ref mrq_query_fw_tag_response
  *
  */
 
 /**
  * @ingroup Query_Tag
  * @brief Response to #MRQ_QUERY_FW_TAG
  *
  * Sent in response to #MRQ_QUERY_FW_TAG message. #tag contains the unique
  * identifier for the version of firmware issuing the reply.
  *
  */
 struct mrq_query_fw_tag_response {
   /** @brief Array to store tag information */
     uint8_t tag[32];
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_MODULE_LOAD
  * @brief Dynamically load a BPMP code module
  *
  * * Platforms: T210, T210B01, T186
  * @cond (bpmp_t210 || bpmp_t210b01 || bpmp_t186)
  * * Initiators: CCPLEX
  * * Targets: BPMP
  * * Request Payload: @ref mrq_module_load_request
  * * Response Payload: @ref mrq_module_load_response
  *
  * @note This MRQ is disabled on production systems
  *
  */
 
 /**
  * @ingroup Module
  * @brief Request with #MRQ_MODULE_LOAD
  *
  * Used by #MRQ_MODULE_LOAD calls to ask the recipient to dynamically
  * load the code located at #phys_addr and having size #size
  * bytes. #phys_addr is treated as a void pointer.
  *
  * The recipient copies the code from #phys_addr to locally allocated
  * memory prior to responding to this message.
  *
  * @todo document the module header format
  *
  * The sender is responsible for ensuring that the code is mapped in
  * the recipient's address map.
  *
  */
 struct mrq_module_load_request {
     /** @brief Base address of the code to load */
     uint32_t phys_addr;
     /** @brief Size in bytes of code to load */
     uint32_t size;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Module
  * @brief Response to #MRQ_MODULE_LOAD
  *
  * @todo document mrq_response::err
  */
 struct mrq_module_load_response {
     /** @brief Handle to the loaded module */
     uint32_t base;
 } BPMP_ABI_PACKED;
 /** @endcond*/
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_MODULE_UNLOAD
  * @brief Unload a previously loaded code module
  *
  * * Platforms: T210, T210B01, T186
  * @cond (bpmp_t210 || bpmp_t210b01 || bpmp_t186)
  * * Initiators: CCPLEX
  * * Targets: BPMP
  * * Request Payload: @ref mrq_module_unload_request
  * * Response Payload: N/A
  *
  * @note This MRQ is disabled on production systems
  */
 
 /**
  * @ingroup Module
  * @brief Request with #MRQ_MODULE_UNLOAD
  *
  * Used by #MRQ_MODULE_UNLOAD calls to request that a previously loaded
  * module be unloaded.
  */
 struct mrq_module_unload_request {
     /** @brief Handle of the module to unload */
     uint32_t base;
 } BPMP_ABI_PACKED;
 /** @endcond*/
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_TRACE_MODIFY
  * @brief Modify the set of enabled trace events
  *
  * @deprecated
  *
  * * Platforms: All
  * * Initiators: CCPLEX
  * * Targets: BPMP
  * * Request Payload: @ref mrq_trace_modify_request
  * * Response Payload: @ref mrq_trace_modify_response
  *
  * @note This MRQ is disabled on production systems
  */
 
 /**
  * @ingroup Trace
  * @brief Request with #MRQ_TRACE_MODIFY
  *
  * Used by %MRQ_TRACE_MODIFY calls to enable or disable specify trace
  * events.  #set takes precedence for any bit set in both #set and
  * #clr.
  */
 struct mrq_trace_modify_request {
     /** @brief Bit mask of trace events to disable */
     uint32_t clr;
     /** @brief Bit mask of trace events to enable */
     uint32_t set;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Trace
  * @brief Response to #MRQ_TRACE_MODIFY
  *
  * Sent in repsonse to an #MRQ_TRACE_MODIFY message. #mask reflects the
  * state of which events are enabled after the recipient acted on the
  * message.
  *
  */
 struct mrq_trace_modify_response {
     /** @brief Bit mask of trace event enable states */
     uint32_t mask;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_WRITE_TRACE
  * @brief Write trace data to a buffer
  *
  * @deprecated
  *
  * * Platforms: All
  * * Initiators: CCPLEX
  * * Targets: BPMP
  * * Request Payload: @ref mrq_write_trace_request
  * * Response Payload: @ref mrq_write_trace_response
  *
  * mrq_response::err depends on the @ref mrq_write_trace_request field
  * values. err is -#BPMP_EINVAL if size is zero or area is NULL or
  * area is in an illegal range. A positive value for err indicates the
  * number of bytes written to area.
  *
  * @note This MRQ is disabled on production systems
  */
 
 /**
  * @ingroup Trace
  * @brief Request with #MRQ_WRITE_TRACE
  *
  * Used by MRQ_WRITE_TRACE calls to ask the recipient to copy trace
  * data from the recipient's local buffer to the output buffer. #area
  * is treated as a byte-aligned pointer in the recipient's address
  * space.
  *
  * The sender is responsible for ensuring that the output
  * buffer is mapped in the recipient's address map. The recipient is
  * responsible for protecting its own code and data from accidental
  * overwrites.
  */
 struct mrq_write_trace_request {
     /** @brief Base address of output buffer */
     uint32_t area;
     /** @brief Size in bytes of the output buffer */
     uint32_t size;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Trace
  * @brief Response to #MRQ_WRITE_TRACE
  *
  * Once this response is sent, the respondent will not access the
  * output buffer further.
  */
 struct mrq_write_trace_response {
     /**
      * @brief Flag whether more data remains in local buffer
      *
      * Value is 1 if the entire local trace buffer has been
      * drained to the outputbuffer. Value is 0 otherwise.
      */
     uint32_t eof;
 } BPMP_ABI_PACKED;
 
 /** @private */
 struct mrq_threaded_ping_request {
     uint32_t challenge;
 } BPMP_ABI_PACKED;
 
 /** @private */
 struct mrq_threaded_ping_response {
     uint32_t reply;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_MODULE_MAIL
  * @brief Send a message to a loadable module
  *
  * * Platforms: T210, T210B01, T186
  * @cond (bpmp_t210 || bpmp_t210b01 || bpmp_t186)
  * * Initiators: Any
  * * Targets: BPMP
  * * Request Payload: @ref mrq_module_mail_request
  * * Response Payload: @ref mrq_module_mail_response
  *
  * @note This MRQ is disabled on production systems
  */
 
 /**
  * @ingroup Module
  * @brief Request with #MRQ_MODULE_MAIL
  */
 struct mrq_module_mail_request {
     /** @brief Handle to the previously loaded module */
     uint32_t base;
     /** @brief Module-specific mail payload
      *
      * The length of data[ ] is unknown to the BPMP core firmware
      * but it is limited to the size of an IPC message.
      */
     uint8_t data[BPMP_ABI_EMPTY_ARRAY];
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Module
  * @brief Response to #MRQ_MODULE_MAIL
  */
 struct mrq_module_mail_response {
     /** @brief Module-specific mail payload
      *
      * The length of data[ ] is unknown to the BPMP core firmware
      * but it is limited to the size of an IPC message.
      */
     uint8_t data[BPMP_ABI_EMPTY_ARRAY];
 } BPMP_ABI_PACKED;
 /** @endcond */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_DEBUGFS
  * @brief Interact with BPMP's debugfs file nodes
  *
  * @deprecated use MRQ_DEBUG instead.
  *
  * * Platforms: T186, T194
  * * Initiators: Any
  * * Targets: BPMP
  * * Request Payload: @ref mrq_debugfs_request
  * * Response Payload: @ref mrq_debugfs_response
  */
 
 /**
  * @addtogroup Debugfs
  * @{
  *
  * The BPMP firmware implements a pseudo-filesystem called
  * debugfs. Any driver within the firmware may register with debugfs
  * to expose an arbitrary set of "files" in the filesystem. When
  * software on the CPU writes to a debugfs file, debugfs passes the
  * written data to a callback provided by the driver. When software on
  * the CPU reads a debugfs file, debugfs queries the driver for the
  * data to return to the CPU. The intention of the debugfs filesystem
  * is to provide information useful for debugging the system at
  * runtime.
  *
  * @note The files exposed via debugfs are not part of the
  * BPMP firmware's ABI. debugfs files may be added or removed in any
  * given version of the firmware. Typically the semantics of a debugfs
  * file are consistent from version to version but even that is not
  * guaranteed.
  *
  * @}
  */
 
 /** @ingroup Debugfs */
 enum mrq_debugfs_commands {
     /** @brief Perform read */
     CMD_DEBUGFS_READ = 1,
     /** @brief Perform write */
     CMD_DEBUGFS_WRITE = 2,
     /** @brief Perform dumping directory */
     CMD_DEBUGFS_DUMPDIR = 3,
     /** @brief Not a command */
     CMD_DEBUGFS_MAX
 };
 
 /**
  * @ingroup Debugfs
  * @brief Parameters for CMD_DEBUGFS_READ/WRITE command
  */
 struct cmd_debugfs_fileop_request {
     /** @brief Physical address pointing at filename */
     uint32_t fnameaddr;
     /** @brief Length in bytes of filename buffer */
     uint32_t fnamelen;
     /** @brief Physical address pointing to data buffer */
     uint32_t dataaddr;
     /** @brief Length in bytes of data buffer */
     uint32_t datalen;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Debugfs
  * @brief Parameters for CMD_DEBUGFS_READ/WRITE command
  */
 struct cmd_debugfs_dumpdir_request {
     /** @brief Physical address pointing to data buffer */
     uint32_t dataaddr;
     /** @brief Length in bytes of data buffer */
     uint32_t datalen;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Debugfs
  * @brief Response data for CMD_DEBUGFS_READ/WRITE command
  */
 struct cmd_debugfs_fileop_response {
     /** @brief Always 0 */
     uint32_t reserved;
     /** @brief Number of bytes read from or written to data buffer */
     uint32_t nbytes;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Debugfs
  * @brief Response data for CMD_DEBUGFS_DUMPDIR command
  */
 struct cmd_debugfs_dumpdir_response {
     /** @brief Always 0 */
     uint32_t reserved;
     /** @brief Number of bytes read from or written to data buffer */
     uint32_t nbytes;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Debugfs
  * @brief Request with #MRQ_DEBUGFS.
  *
  * The sender of an MRQ_DEBUGFS message uses #cmd to specify a debugfs
  * command to execute. Legal commands are the values of @ref
  * mrq_debugfs_commands. Each command requires a specific additional
  * payload of data.
  *
  * |command            |payload|
  * |-------------------|-------|
  * |CMD_DEBUGFS_READ   |fop    |
  * |CMD_DEBUGFS_WRITE  |fop    |
  * |CMD_DEBUGFS_DUMPDIR|dumpdir|
  */
 struct mrq_debugfs_request {
     /** @brief Sub-command (@ref mrq_debugfs_commands) */
     uint32_t cmd;
     union {
         struct cmd_debugfs_fileop_request fop;
         struct cmd_debugfs_dumpdir_request dumpdir;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Debugfs
  */
 struct mrq_debugfs_response {
     /** @brief Always 0 */
     int32_t reserved;
     union {
         /** @brief Response data for CMD_DEBUGFS_READ OR
          * CMD_DEBUGFS_WRITE command
          */
         struct cmd_debugfs_fileop_response fop;
         /** @brief Response data for CMD_DEBUGFS_DUMPDIR command */
         struct cmd_debugfs_dumpdir_response dumpdir;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /**
  * @addtogroup Debugfs
  * @{
  */
 #define DEBUGFS_S_ISDIR (1 << 9)
 #define DEBUGFS_S_IRUSR (1 << 8)
 #define DEBUGFS_S_IWUSR (1 << 7)
 /** @} */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_DEBUG
  * @brief Interact with BPMP's debugfs file nodes. Use message payload
  * for exchanging data. This is functionally equivalent to
  * @ref MRQ_DEBUGFS. But the way in which data is exchanged is different.
  * When software running on CPU tries to read a debugfs file,
  * the file path and read data will be stored in message payload.
  * Since the message payload size is limited, a debugfs file
  * transaction might require multiple frames of data exchanged
  * between BPMP and CPU until the transaction completes.
  *
  * * Platforms: T194
  * * Initiators: Any
  * * Targets: BPMP
  * * Request Payload: @ref mrq_debug_request
  * * Response Payload: @ref mrq_debug_response
  */
 
 /** @ingroup Debugfs */
 enum mrq_debug_commands {
     /** @brief Open required file for read operation */
     CMD_DEBUG_OPEN_RO = 0,
     /** @brief Open required file for write operation */
     CMD_DEBUG_OPEN_WO = 1,
     /** @brief Perform read */
     CMD_DEBUG_READ = 2,
     /** @brief Perform write */
     CMD_DEBUG_WRITE = 3,
     /** @brief Close file */
     CMD_DEBUG_CLOSE = 4,
     /** @brief Not a command */
     CMD_DEBUG_MAX
 };
 
 /**
  * @ingroup Debugfs
  * @brief Maximum number of files that can be open at a given time
  */
 #define DEBUG_MAX_OPEN_FILES    1
 
 /**
  * @ingroup Debugfs
  * @brief Maximum size of null-terminated file name string in bytes.
  * Value is derived from memory available in message payload while
  * using @ref cmd_debug_fopen_request
  * Value 4 corresponds to size of @ref mrq_debug_commands
  * in @ref mrq_debug_request.
  * 120 - 4 dbg_cmd(32bit)  = 116
  */
 #define DEBUG_FNAME_MAX_SZ  (MSG_DATA_MIN_SZ - 4)
 
 /**
  * @ingroup Debugfs
  * @brief Parameters for CMD_DEBUG_OPEN command
  */
 struct cmd_debug_fopen_request {
     /** @brief File name - Null-terminated string with maximum
      * length @ref DEBUG_FNAME_MAX_SZ
      */
     char name[DEBUG_FNAME_MAX_SZ];
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Debugfs
  * @brief Response data for CMD_DEBUG_OPEN_RO/WO command
  */
 struct cmd_debug_fopen_response {
     /** @brief Identifier for file access */
     uint32_t fd;
     /** @brief Data length. File data size for READ command.
      * Maximum allowed length for WRITE command
      */
     uint32_t datalen;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Debugfs
  * @brief Parameters for CMD_DEBUG_READ command
  */
 struct cmd_debug_fread_request {
     /** @brief File access identifier received in response
      * to CMD_DEBUG_OPEN_RO request
      */
     uint32_t fd;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Debugfs
  * @brief Maximum size of read data in bytes.
  * Value is derived from memory available in message payload while
  * using @ref cmd_debug_fread_response.
  */
 #define DEBUG_READ_MAX_SZ   (MSG_DATA_MIN_SZ - 4)
 
 /**
  * @ingroup Debugfs
  * @brief Response data for CMD_DEBUG_READ command
  */
 struct cmd_debug_fread_response {
     /** @brief Size of data provided in this response in bytes */
     uint32_t readlen;
     /** @brief File data from seek position */
     char data[DEBUG_READ_MAX_SZ];
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Debugfs
  * @brief Maximum size of write data in bytes.
  * Value is derived from memory available in message payload while
  * using @ref cmd_debug_fwrite_request.
  */
 #define DEBUG_WRITE_MAX_SZ  (MSG_DATA_MIN_SZ - 12)
 
 /**
  * @ingroup Debugfs
  * @brief Parameters for CMD_DEBUG_WRITE command
  */
 struct cmd_debug_fwrite_request {
     /** @brief File access identifier received in response
      * to CMD_DEBUG_OPEN_RO request
      */
     uint32_t fd;
     /** @brief Size of write data in bytes */
     uint32_t datalen;
     /** @brief Data to be written */
     char data[DEBUG_WRITE_MAX_SZ];
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Debugfs
  * @brief Parameters for CMD_DEBUG_CLOSE command
  */
 struct cmd_debug_fclose_request {
     /** @brief File access identifier received in response
      * to CMD_DEBUG_OPEN_RO request
      */
     uint32_t fd;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Debugfs
  * @brief Request with #MRQ_DEBUG.
  *
  * The sender of an MRQ_DEBUG message uses #cmd to specify a debugfs
  * command to execute. Legal commands are the values of @ref
  * mrq_debug_commands. Each command requires a specific additional
  * payload of data.
  *
  * |command            |payload|
  * |-------------------|-------|
  * |CMD_DEBUG_OPEN_RO  |fop    |
  * |CMD_DEBUG_OPEN_WO  |fop    |
  * |CMD_DEBUG_READ     |frd    |
  * |CMD_DEBUG_WRITE    |fwr    |
  * |CMD_DEBUG_CLOSE    |fcl    |
  */
 struct mrq_debug_request {
     /** @brief Sub-command (@ref mrq_debug_commands) */
     uint32_t cmd;
     union {
         /** @brief Request payload for CMD_DEBUG_OPEN_RO/WO command */
         struct cmd_debug_fopen_request fop;
         /** @brief Request payload for CMD_DEBUG_READ command */
         struct cmd_debug_fread_request frd;
         /** @brief Request payload for CMD_DEBUG_WRITE command */
         struct cmd_debug_fwrite_request fwr;
         /** @brief Request payload for CMD_DEBUG_CLOSE command */
         struct cmd_debug_fclose_request fcl;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Debugfs
  */
 struct mrq_debug_response {
     union {
         /** @brief Response data for CMD_DEBUG_OPEN_RO/WO command */
         struct cmd_debug_fopen_response fop;
         /** @brief Response data for CMD_DEBUG_READ command */
         struct cmd_debug_fread_response frd;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_RESET
  * @brief Reset an IP block
  *
  * * Platforms: T186, T194
  * * Initiators: Any
  * * Targets: BPMP
  * * Request Payload: @ref mrq_reset_request
  * * Response Payload: @ref mrq_reset_response
  *
  * @addtogroup Reset
  * @{
  */
 
 enum mrq_reset_commands {
     /**
      * @brief Assert module reset
      *
      * mrq_response::err is 0 if the operation was successful, or @n
      * -#BPMP_EINVAL if mrq_reset_request::reset_id is invalid @n
      * -#BPMP_EACCES if mrq master is not an owner of target domain reset @n
      * -#BPMP_ENOTSUP if target domain h/w state does not allow reset
      */
     CMD_RESET_ASSERT = 1,
     /**
      * @brief Deassert module reset
      *
      * mrq_response::err is 0 if the operation was successful, or @n
      * -#BPMP_EINVAL if mrq_reset_request::reset_id is invalid @n
      * -#BPMP_EACCES if mrq master is not an owner of target domain reset @n
      * -#BPMP_ENOTSUP if target domain h/w state does not allow reset
      */
     CMD_RESET_DEASSERT = 2,
     /**
      * @brief Assert and deassert the module reset
      *
      * mrq_response::err is 0 if the operation was successful, or @n
      * -#BPMP_EINVAL if mrq_reset_request::reset_id is invalid @n
      * -#BPMP_EACCES if mrq master is not an owner of target domain reset @n
      * -#BPMP_ENOTSUP if target domain h/w state does not allow reset
      */
     CMD_RESET_MODULE = 3,
     /**
      * @brief Get the highest reset ID
      *
      * mrq_response::err is 0 if the operation was successful, or @n
      * -#BPMP_ENODEV if no reset domains are supported (number of IDs is 0)
      */
     CMD_RESET_GET_MAX_ID = 4,
 
     /** @brief Not part of ABI and subject to change */
     CMD_RESET_MAX,
 };
 
 /**
  * @brief Request with MRQ_RESET
  *
  * Used by the sender of an #MRQ_RESET message to request BPMP to
  * assert or deassert a given reset line.
  */
 struct mrq_reset_request {
     /** @brief Reset action to perform (@ref mrq_reset_commands) */
     uint32_t cmd;
     /** @brief Id of the reset to affected */
     uint32_t reset_id;
 } BPMP_ABI_PACKED;
 
 /**
  * @brief Response for MRQ_RESET sub-command CMD_RESET_GET_MAX_ID. When
  * this sub-command is not supported, firmware will return -BPMP_EBADCMD
  * in mrq_response::err.
  */
 struct cmd_reset_get_max_id_response {
     /** @brief Max reset id */
     uint32_t max_id;
 } BPMP_ABI_PACKED;
 
 /**
  * @brief Response with MRQ_RESET
  *
  * Each sub-command supported by @ref mrq_reset_request may return
  * sub-command-specific data. Some do and some do not as indicated
  * in the following table
  *
  * | sub-command          | payload          |
  * |----------------------|------------------|
  * | CMD_RESET_ASSERT     | -                |
  * | CMD_RESET_DEASSERT   | -                |
  * | CMD_RESET_MODULE     | -                |
  * | CMD_RESET_GET_MAX_ID | reset_get_max_id |
  */
 struct mrq_reset_response {
     union {
         struct cmd_reset_get_max_id_response reset_get_max_id;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /** @} */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_I2C
  * @brief Issue an i2c transaction
  *
  * * Platforms: T186, T194
  * * Initiators: Any
  * * Targets: BPMP
  * * Request Payload: @ref mrq_i2c_request
  * * Response Payload: @ref mrq_i2c_response
  *
  * @addtogroup I2C
  * @{
  */
 #define TEGRA_I2C_IPC_MAX_IN_BUF_SIZE   (MSG_DATA_MIN_SZ - 12U)
 #define TEGRA_I2C_IPC_MAX_OUT_BUF_SIZE  (MSG_DATA_MIN_SZ - 4U)
 
 #define SERIALI2C_TEN           0x0010U
 #define SERIALI2C_RD            0x0001U
 #define SERIALI2C_STOP          0x8000U
 #define SERIALI2C_NOSTART       0x4000U
 #define SERIALI2C_REV_DIR_ADDR  0x2000U
 #define SERIALI2C_IGNORE_NAK    0x1000U
 #define SERIALI2C_NO_RD_ACK     0x0800U
 #define SERIALI2C_RECV_LEN      0x0400U
 
 enum {
     CMD_I2C_XFER = 1
 };
 
 /**
  * @brief Serializable i2c request
  *
  * Instances of this structure are packed (little-endian) into
  * cmd_i2c_xfer_request::data_buf. Each instance represents a single
  * transaction (or a portion of a transaction with repeated starts) on
  * an i2c bus.
  *
  * Because these structures are packed, some instances are likely to
  * be misaligned. Additionally because #data is variable length, it is
  * not possible to iterate through a serialized list of these
  * structures without inspecting #len in each instance.  It may be
  * easier to serialize or deserialize cmd_i2c_xfer_request::data_buf
  * manually rather than using this structure definition.
 */
 struct serial_i2c_request {
     /** @brief I2C slave address */
     uint16_t addr;
     /** @brief Bitmask of SERIALI2C_ flags */
     uint16_t flags;
     /** @brief Length of I2C transaction in bytes */
     uint16_t len;
     /** @brief For write transactions only, #len bytes of data */
     uint8_t data[];
 } BPMP_ABI_PACKED;
 
 /**
  * @brief Trigger one or more i2c transactions
  */
 struct cmd_i2c_xfer_request {
     /** @brief Valid bus number from @ref bpmp_i2c_ids*/
     uint32_t bus_id;
 
     /** @brief Count of valid bytes in #data_buf*/
     uint32_t data_size;
 
     /** @brief Serialized packed instances of @ref serial_i2c_request*/
     uint8_t data_buf[TEGRA_I2C_IPC_MAX_IN_BUF_SIZE];
 } BPMP_ABI_PACKED;
 
 /**
  * @brief Container for data read from the i2c bus
  *
  * Processing an cmd_i2c_xfer_request::data_buf causes BPMP to execute
  * zero or more I2C reads. The data read from the bus is serialized
  * into #data_buf.
  */
 struct cmd_i2c_xfer_response {
     /** @brief Count of valid bytes in #data_buf*/
     uint32_t data_size;
     /** @brief I2c read data */
     uint8_t data_buf[TEGRA_I2C_IPC_MAX_OUT_BUF_SIZE];
 } BPMP_ABI_PACKED;
 
 /**
  * @brief Request with #MRQ_I2C
  */
 struct mrq_i2c_request {
     /** @brief Always CMD_I2C_XFER (i.e. 1) */
     uint32_t cmd;
     /** @brief Parameters of the transfer request */
     struct cmd_i2c_xfer_request xfer;
 } BPMP_ABI_PACKED;
 
 /**
  * @brief Response to #MRQ_I2C
  *
  * mrq_response:err is
  *  0: Success
  *  -#BPMP_EBADCMD: if mrq_i2c_request::cmd is other than 1
  *  -#BPMP_EINVAL: if cmd_i2c_xfer_request does not contain correctly formatted request
  *  -#BPMP_ENODEV: if cmd_i2c_xfer_request::bus_id is not supported by BPMP
  *  -#BPMP_EACCES: if i2c transaction is not allowed due to firewall rules
  *  -#BPMP_ETIMEDOUT: if i2c transaction times out
  *  -#BPMP_ENXIO: if i2c slave device does not reply with ACK to the transaction
  *  -#BPMP_EAGAIN: if ARB_LOST condition is detected by the i2c controller
  *  -#BPMP_EIO: any other i2c controller error code than NO_ACK or ARB_LOST
  */
 struct mrq_i2c_response {
     struct cmd_i2c_xfer_response xfer;
 } BPMP_ABI_PACKED;
 
 /** @} */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_CLK
  * @brief Perform a clock operation
  *
  * * Platforms: T186, T194
  * * Initiators: Any
  * * Targets: BPMP
  * * Request Payload: @ref mrq_clk_request
  * * Response Payload: @ref mrq_clk_response
  *
  * @addtogroup Clocks
  * @{
  */
 enum {
     CMD_CLK_GET_RATE = 1,
     CMD_CLK_SET_RATE = 2,
     CMD_CLK_ROUND_RATE = 3,
     CMD_CLK_GET_PARENT = 4,
     CMD_CLK_SET_PARENT = 5,
     CMD_CLK_IS_ENABLED = 6,
     CMD_CLK_ENABLE = 7,
     CMD_CLK_DISABLE = 8,
     CMD_CLK_GET_ALL_INFO = 14,
     CMD_CLK_GET_MAX_CLK_ID = 15,
     CMD_CLK_GET_FMAX_AT_VMIN = 16,
     CMD_CLK_MAX,
 };
 
 #define BPMP_CLK_HAS_MUX    (1U << 0U)
 #define BPMP_CLK_HAS_SET_RATE   (1U << 1U)
 #define BPMP_CLK_IS_ROOT    (1U << 2U)
 #define BPMP_CLK_IS_VAR_ROOT    (1U << 3U)
 
 #define MRQ_CLK_NAME_MAXLEN 40U
 #define MRQ_CLK_MAX_PARENTS 16U
 
 /** @private */
 struct cmd_clk_get_rate_request {
     BPMP_ABI_EMPTY
 } BPMP_ABI_PACKED;
 
 struct cmd_clk_get_rate_response {
     int64_t rate;
 } BPMP_ABI_PACKED;
 
 struct cmd_clk_set_rate_request {
     int32_t unused;
     int64_t rate;
 } BPMP_ABI_PACKED;
 
 struct cmd_clk_set_rate_response {
     int64_t rate;
 } BPMP_ABI_PACKED;
 
 struct cmd_clk_round_rate_request {
     int32_t unused;
     int64_t rate;
 } BPMP_ABI_PACKED;
 
 struct cmd_clk_round_rate_response {
     int64_t rate;
 } BPMP_ABI_PACKED;
 
 /** @private */
 struct cmd_clk_get_parent_request {
     BPMP_ABI_EMPTY
 } BPMP_ABI_PACKED;
 
 struct cmd_clk_get_parent_response {
     uint32_t parent_id;
 } BPMP_ABI_PACKED;
 
 struct cmd_clk_set_parent_request {
     uint32_t parent_id;
 } BPMP_ABI_PACKED;
 
 struct cmd_clk_set_parent_response {
     uint32_t parent_id;
 } BPMP_ABI_PACKED;
 
 /** @private */
 struct cmd_clk_is_enabled_request {
     BPMP_ABI_EMPTY
 } BPMP_ABI_PACKED;
 
 /**
  * @brief Response data to #MRQ_CLK sub-command CMD_CLK_IS_ENABLED
  */
 struct cmd_clk_is_enabled_response {
     /**
      * @brief The state of the clock that has been succesfully
      * requested with CMD_CLK_ENABLE or CMD_CLK_DISABLE by the
      * master invoking the command earlier.
      *
      * The state may not reflect the physical state of the clock
      * if there are some other masters requesting it to be
      * enabled.
      *
      * Value 0 is disabled, all other values indicate enabled.
      */
     int32_t state;
 } BPMP_ABI_PACKED;
 
 /** @private */
 struct cmd_clk_enable_request {
     BPMP_ABI_EMPTY
 } BPMP_ABI_PACKED;
 
 /** @private */
 struct cmd_clk_enable_response {
     BPMP_ABI_EMPTY
 } BPMP_ABI_PACKED;
 
 /** @private */
 struct cmd_clk_disable_request {
     BPMP_ABI_EMPTY
 } BPMP_ABI_PACKED;
 
 /** @private */
 struct cmd_clk_disable_response {
     BPMP_ABI_EMPTY
 } BPMP_ABI_PACKED;
 
 /** @private */
 struct cmd_clk_get_all_info_request {
     BPMP_ABI_EMPTY
 } BPMP_ABI_PACKED;
 
 struct cmd_clk_get_all_info_response {
     uint32_t flags;
     uint32_t parent;
     uint32_t parents[MRQ_CLK_MAX_PARENTS];
     uint8_t num_parents;
     uint8_t name[MRQ_CLK_NAME_MAXLEN];
 } BPMP_ABI_PACKED;
 
 /** @private */
 struct cmd_clk_get_max_clk_id_request {
     BPMP_ABI_EMPTY
 } BPMP_ABI_PACKED;
 
 struct cmd_clk_get_max_clk_id_response {
     uint32_t max_id;
 } BPMP_ABI_PACKED;
 
 /** @private */
 struct cmd_clk_get_fmax_at_vmin_request {
     BPMP_ABI_EMPTY
 } BPMP_ABI_PACKED;
 
 struct cmd_clk_get_fmax_at_vmin_response {
     int64_t rate;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Clocks
  * @brief Request with #MRQ_CLK
  *
  * Used by the sender of an #MRQ_CLK message to control clocks. The
  * clk_request is split into several sub-commands. Some sub-commands
  * require no additional data. Others have a sub-command specific
  * payload
  *
  * |sub-command                 |payload                |
  * |----------------------------|-----------------------|
  * |CMD_CLK_GET_RATE            |-                      |
  * |CMD_CLK_SET_RATE            |clk_set_rate           |
  * |CMD_CLK_ROUND_RATE          |clk_round_rate         |
  * |CMD_CLK_GET_PARENT          |-                      |
  * |CMD_CLK_SET_PARENT          |clk_set_parent         |
  * |CMD_CLK_IS_ENABLED          |-                      |
  * |CMD_CLK_ENABLE              |-                      |
  * |CMD_CLK_DISABLE             |-                      |
  * |CMD_CLK_GET_ALL_INFO        |-                      |
  * |CMD_CLK_GET_MAX_CLK_ID      |-                      |
  * |CMD_CLK_GET_FMAX_AT_VMIN    |-
  * |
  *
  */
 
 struct mrq_clk_request {
     /** @brief Sub-command and clock id concatenated to 32-bit word.
      * - bits[31..24] is the sub-cmd.
      * - bits[23..0] is the clock id
      */
     uint32_t cmd_and_id;
 
     union {
         /** @private */
         struct cmd_clk_get_rate_request clk_get_rate;
         struct cmd_clk_set_rate_request clk_set_rate;
         struct cmd_clk_round_rate_request clk_round_rate;
         /** @private */
         struct cmd_clk_get_parent_request clk_get_parent;
         struct cmd_clk_set_parent_request clk_set_parent;
         /** @private */
         struct cmd_clk_enable_request clk_enable;
         /** @private */
         struct cmd_clk_disable_request clk_disable;
         /** @private */
         struct cmd_clk_is_enabled_request clk_is_enabled;
         /** @private */
         struct cmd_clk_get_all_info_request clk_get_all_info;
         /** @private */
         struct cmd_clk_get_max_clk_id_request clk_get_max_clk_id;
         /** @private */
         struct cmd_clk_get_fmax_at_vmin_request clk_get_fmax_at_vmin;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Clocks
  * @brief Response to MRQ_CLK
  *
  * Each sub-command supported by @ref mrq_clk_request may return
  * sub-command-specific data. Some do and some do not as indicated in
  * the following table
  *
  * |sub-command                 |payload                 |
  * |----------------------------|------------------------|
  * |CMD_CLK_GET_RATE            |clk_get_rate            |
  * |CMD_CLK_SET_RATE            |clk_set_rate            |
  * |CMD_CLK_ROUND_RATE          |clk_round_rate          |
  * |CMD_CLK_GET_PARENT          |clk_get_parent          |
  * |CMD_CLK_SET_PARENT          |clk_set_parent          |
  * |CMD_CLK_IS_ENABLED          |clk_is_enabled          |
  * |CMD_CLK_ENABLE              |-                       |
  * |CMD_CLK_DISABLE             |-                       |
  * |CMD_CLK_GET_ALL_INFO        |clk_get_all_info        |
  * |CMD_CLK_GET_MAX_CLK_ID      |clk_get_max_id          |
  * |CMD_CLK_GET_FMAX_AT_VMIN    |clk_get_fmax_at_vmin    |
  *
  */
 
 struct mrq_clk_response {
     union {
         struct cmd_clk_get_rate_response clk_get_rate;
         struct cmd_clk_set_rate_response clk_set_rate;
         struct cmd_clk_round_rate_response clk_round_rate;
         struct cmd_clk_get_parent_response clk_get_parent;
         struct cmd_clk_set_parent_response clk_set_parent;
         /** @private */
         struct cmd_clk_enable_response clk_enable;
         /** @private */
         struct cmd_clk_disable_response clk_disable;
         struct cmd_clk_is_enabled_response clk_is_enabled;
         struct cmd_clk_get_all_info_response clk_get_all_info;
         struct cmd_clk_get_max_clk_id_response clk_get_max_clk_id;
         struct cmd_clk_get_fmax_at_vmin_response clk_get_fmax_at_vmin;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /** @} */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_QUERY_ABI
  * @brief Check if an MRQ is implemented
  *
  * * Platforms: All
  * * Initiators: Any
  * * Targets: Any except DMCE
  * * Request Payload: @ref mrq_query_abi_request
  * * Response Payload: @ref mrq_query_abi_response
  */
 
 /**
  * @ingroup ABI_info
  * @brief Request with MRQ_QUERY_ABI
  *
  * Used by #MRQ_QUERY_ABI call to check if MRQ code #mrq is supported
  * by the recipient.
  */
 struct mrq_query_abi_request {
     /** @brief MRQ code to query */
     uint32_t mrq;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup ABI_info
  * @brief Response to MRQ_QUERY_ABI
  *
  * @note mrq_response::err of 0 indicates that the query was
  * successful, not that the MRQ itself is supported!
  */
 struct mrq_query_abi_response {
     /** @brief 0 if queried MRQ is supported. Else, -#BPMP_ENODEV */
     int32_t status;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_PG_READ_STATE
  * @brief Read the power-gating state of a partition
  *
  * * Platforms: T186
  * @cond bpmp_t186
  * * Initiators: Any
  * * Targets: BPMP
  * * Request Payload: @ref mrq_pg_read_state_request
  * * Response Payload: @ref mrq_pg_read_state_response
  */
 
 /**
  * @ingroup Powergating
  * @brief Request with #MRQ_PG_READ_STATE
  *
  * Used by MRQ_PG_READ_STATE call to read the current state of a
  * partition.
  */
 struct mrq_pg_read_state_request {
     /** @brief ID of partition */
     uint32_t partition_id;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup Powergating
  * @brief Response to MRQ_PG_READ_STATE
  * @todo define possible errors.
  */
 struct mrq_pg_read_state_response {
     /** @brief Read as don't care */
     uint32_t sram_state;
     /** @brief State of power partition
      * * 0 : off
      * * 1 : on
      */
     uint32_t logic_state;
 } BPMP_ABI_PACKED;
 /** @endcond*/
 /** @} */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_PG_UPDATE_STATE
  * @brief Modify the power-gating state of a partition. In contrast to
  * MRQ_PG calls, the operations that change state (on/off) of power
  * partition are reference counted.
  *
  * * Platforms: T186
  * @cond bpmp_t186
  * * Initiators: Any
  * * Targets: BPMP
  * * Request Payload: @ref mrq_pg_update_state_request
  * * Response Payload: N/A
  */
 
 /**
  * @ingroup Powergating
  * @brief Request with mrq_pg_update_state_request
  *
  * Used by #MRQ_PG_UPDATE_STATE call to request BPMP to change the
  * state of a power partition #partition_id.
  */
 struct mrq_pg_update_state_request {
     /** @brief ID of partition */
     uint32_t partition_id;
     /** @brief Secondary control of power partition
      *  @details Ignored by many versions of the BPMP
      *  firmware. For maximum compatibility, set the value
      *  according to @ref logic_state
      * *  0x1: power ON partition (@ref logic_state == 0x3)
      * *  0x3: power OFF partition (@ref logic_state == 0x1)
      */
     uint32_t sram_state;
     /** @brief Controls state of power partition, legal values are
      * *  0x1 : power OFF partition
      * *  0x3 : power ON partition
      */
     uint32_t logic_state;
     /** @brief Change state of clocks of the power partition, legal values
      * *  0x0 : do not change clock state
      * *  0x1 : disable partition clocks (only applicable when
      *          @ref logic_state == 0x1)
      * *  0x3 : enable partition clocks (only applicable when
      *          @ref logic_state == 0x3)
      */
     uint32_t clock_state;
 } BPMP_ABI_PACKED;
 /** @endcond*/
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_PG
  * @brief Control power-gating state of a partition. In contrast to
  * MRQ_PG_UPDATE_STATE, operations that change the power partition
  * state are NOT reference counted
  *
  * @note BPMP-FW forcefully turns off some partitions as part of SC7 entry
  * because their state cannot be adequately restored on exit. Therefore,
  * it is recommended to power off all domains via MRQ_PG prior to SC7 entry.
  * See @ref bpmp_pdomain_ids for further detail.
  *
  * * Platforms: T186, T194
  * * Initiators: Any
  * * Targets: BPMP
  * * Request Payload: @ref mrq_pg_request
  * * Response Payload: @ref mrq_pg_response
  *
  * @addtogroup Powergating
  * @{
  */
 enum mrq_pg_cmd {
     /**
      * @brief Check whether the BPMP driver supports the specified
      * request type
      *
      * mrq_response::err is 0 if the specified request is
      * supported and -#BPMP_ENODEV otherwise.
      */
     CMD_PG_QUERY_ABI = 0,
 
     /**
      * @brief Set the current state of specified power domain. The
      * possible values for power domains are defined in enum
      * pg_states
      *
      * mrq_response:err is
      * 0: Success
      * -#BPMP_EINVAL: Invalid request parameters
      */
     CMD_PG_SET_STATE = 1,
 
     /**
      * @brief Get the current state of specified power domain. The
      * possible values for power domains are defined in enum
      * pg_states
      *
      * mrq_response:err is
      * 0: Success
      * -#BPMP_EINVAL: Invalid request parameters
      */
     CMD_PG_GET_STATE = 2,
 
     /**
      * @brief Get the name string of specified power domain id.
      *
      * mrq_response:err is
      * 0: Success
      * -#BPMP_EINVAL: Invalid request parameters
      */
     CMD_PG_GET_NAME = 3,
 
 
     /**
      * @brief Get the highest power domain id in the system. Not
      * all IDs between 0 and max_id are valid IDs.
      *
      * mrq_response:err is
      * 0: Success
      * -#BPMP_EINVAL: Invalid request parameters
      */
     CMD_PG_GET_MAX_ID = 4,
 };
 
 #define MRQ_PG_NAME_MAXLEN  40
 
 enum pg_states {
     /** @brief Power domain is OFF */
     PG_STATE_OFF = 0,
     /** @brief Power domain is ON */
     PG_STATE_ON = 1,
     /**
      * @brief a legacy state where power domain and the clock
      * associated to the domain are ON.
      * This state is only supported in T186, and the use of it is
      * deprecated.
      */
     PG_STATE_RUNNING = 2,
 };
 
 struct cmd_pg_query_abi_request {
     /** @ref mrq_pg_cmd */
     uint32_t type;
 } BPMP_ABI_PACKED;
 
 struct cmd_pg_set_state_request {
     /** @ref pg_states */
     uint32_t state;
 } BPMP_ABI_PACKED;
 
 /**
  * @brief Response data to #MRQ_PG sub command #CMD_PG_GET_STATE
  */
 struct cmd_pg_get_state_response {
     /**
      * @brief The state of the power partition that has been
      * succesfuly requested by the master earlier using #MRQ_PG
      * command #CMD_PG_SET_STATE.
      *
      * The state may not reflect the physical state of the power
      * partition if there are some other masters requesting it to
      * be enabled.
      *
      * See @ref pg_states for possible values
      */
     uint32_t state;
 } BPMP_ABI_PACKED;
 
 struct cmd_pg_get_name_response {
     uint8_t name[MRQ_PG_NAME_MAXLEN];
 } BPMP_ABI_PACKED;
 
 struct cmd_pg_get_max_id_response {
     uint32_t max_id;
 } BPMP_ABI_PACKED;
 
 /**
  * @brief Request with #MRQ_PG
  *
  * Used by the sender of an #MRQ_PG message to control power
  * partitions. The pg_request is split into several sub-commands. Some
  * sub-commands require no additional data. Others have a sub-command
  * specific payload
  *
  * |sub-command                 |payload                |
  * |----------------------------|-----------------------|
  * |CMD_PG_QUERY_ABI            | query_abi             |
  * |CMD_PG_SET_STATE            | set_state             |
  * |CMD_PG_GET_STATE            | -                     |
  * |CMD_PG_GET_NAME             | -                     |
  * |CMD_PG_GET_MAX_ID           | -                     |
  *
  */
 struct mrq_pg_request {
     uint32_t cmd;
     uint32_t id;
     union {
         struct cmd_pg_query_abi_request query_abi;
         struct cmd_pg_set_state_request set_state;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /**
  * @brief Response to MRQ_PG
  *
  * Each sub-command supported by @ref mrq_pg_request may return
  * sub-command-specific data. Some do and some do not as indicated in
  * the following table
  *
  * |sub-command                 |payload                |
  * |----------------------------|-----------------------|
  * |CMD_PG_QUERY_ABI            | -                     |
  * |CMD_PG_SET_STATE            | -                     |
  * |CMD_PG_GET_STATE            | get_state             |
  * |CMD_PG_GET_NAME             | get_name              |
  * |CMD_PG_GET_MAX_ID           | get_max_id            |
  */
 struct mrq_pg_response {
     union {
         struct cmd_pg_get_state_response get_state;
         struct cmd_pg_get_name_response get_name;
         struct cmd_pg_get_max_id_response get_max_id;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /** @} */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_THERMAL
  * @brief Interact with BPMP thermal framework
  *
  * * Platforms: T186, T194
  * * Initiators: Any
  * * Targets: Any
  * * Request Payload: TODO
  * * Response Payload: TODO
  *
  * @addtogroup Thermal
  *
  * The BPMP firmware includes a thermal framework. Drivers within the
  * bpmp firmware register with the framework to provide thermal
  * zones. Each thermal zone corresponds to an entity whose temperature
  * can be measured. The framework also has a notion of trip points. A
  * trip point consists of a thermal zone id, a temperature, and a
  * callback routine. The framework invokes the callback when the zone
  * hits the indicated temperature. The BPMP firmware uses this thermal
  * framework interally to implement various temperature-dependent
  * functions.
  *
  * Software on the CPU can use #MRQ_THERMAL (with payload @ref
  * mrq_thermal_host_to_bpmp_request) to interact with the BPMP thermal
  * framework. The CPU must It can query the number of supported zones,
  * query zone temperatures, and set trip points.
  *
  * When a trip point set by the CPU gets crossed, BPMP firmware issues
  * an IPC to the CPU having mrq_request::mrq = #MRQ_THERMAL and a
  * payload of @ref mrq_thermal_bpmp_to_host_request.
  * @{
  */
 enum mrq_thermal_host_to_bpmp_cmd {
     /**
      * @brief Check whether the BPMP driver supports the specified
      * request type.
      *
      * Host needs to supply request parameters.
      *
      * mrq_response::err is 0 if the specified request is
      * supported and -#BPMP_ENODEV otherwise.
      */
     CMD_THERMAL_QUERY_ABI = 0,
 
     /**
      * @brief Get the current temperature of the specified zone.
      *
      * Host needs to supply request parameters.
      *
      * mrq_response::err is
      * *  0: Temperature query succeeded.
      * *  -#BPMP_EINVAL: Invalid request parameters.
      * *  -#BPMP_ENOENT: No driver registered for thermal zone..
      * *  -#BPMP_EFAULT: Problem reading temperature measurement.
      */
     CMD_THERMAL_GET_TEMP = 1,
 
     /**
      * @brief Enable or disable and set the lower and upper
      *   thermal limits for a thermal trip point. Each zone has
      *   one trip point.
      *
      * Host needs to supply request parameters. Once the
      * temperature hits a trip point, the BPMP will send a message
      * to the CPU having MRQ=MRQ_THERMAL and
      * type=CMD_THERMAL_HOST_TRIP_REACHED
      *
      * mrq_response::err is
      * *  0: Trip successfully set.
      * *  -#BPMP_EINVAL: Invalid request parameters.
      * *  -#BPMP_ENOENT: No driver registered for thermal zone.
      * *  -#BPMP_EFAULT: Problem setting trip point.
      */
     CMD_THERMAL_SET_TRIP = 2,
 
     /**
      * @brief Get the number of supported thermal zones.
      *
      * No request parameters required.
      *
      * mrq_response::err is always 0, indicating success.
      */
     CMD_THERMAL_GET_NUM_ZONES = 3,
 
     /**
      * @brief Get the thermtrip of the specified zone.
      *
      * Host needs to supply request parameters.
      *
      * mrq_response::err is
      * *  0: Valid zone information returned.
      * *  -#BPMP_EINVAL: Invalid request parameters.
      * *  -#BPMP_ENOENT: No driver registered for thermal zone.
      * *  -#BPMP_ERANGE if thermtrip is invalid or disabled.
      * *  -#BPMP_EFAULT: Problem reading zone information.
      */
     CMD_THERMAL_GET_THERMTRIP = 4,
 
     /** @brief: number of supported host-to-bpmp commands. May
      * increase in future
      */
     CMD_THERMAL_HOST_TO_BPMP_NUM
 };
 
 enum mrq_thermal_bpmp_to_host_cmd {
     /**
      * @brief Indication that the temperature for a zone has
      *   exceeded the range indicated in the thermal trip point
      *   for the zone.
      *
      * BPMP needs to supply request parameters. Host only needs to
      * acknowledge.
      */
     CMD_THERMAL_HOST_TRIP_REACHED = 100,
 
     /** @brief: number of supported bpmp-to-host commands. May
      * increase in future
      */
     CMD_THERMAL_BPMP_TO_HOST_NUM
 };
 
 /*
  * Host->BPMP request data for request type CMD_THERMAL_QUERY_ABI
  *
  * zone: Request type for which to check existence.
  */
 struct cmd_thermal_query_abi_request {
     uint32_t type;
 } BPMP_ABI_PACKED;
 
 /*
  * Host->BPMP request data for request type CMD_THERMAL_GET_TEMP
  *
  * zone: Number of thermal zone.
  */
 struct cmd_thermal_get_temp_request {
     uint32_t zone;
 } BPMP_ABI_PACKED;
 
 /*
  * BPMP->Host reply data for request CMD_THERMAL_GET_TEMP
  *
  * error: 0 if request succeeded.
  *  -BPMP_EINVAL if request parameters were invalid.
  *      -BPMP_ENOENT if no driver was registered for the specified thermal zone.
  *      -BPMP_EFAULT for other thermal zone driver errors.
  * temp: Current temperature in millicelsius.
  */
 struct cmd_thermal_get_temp_response {
     int32_t temp;
 } BPMP_ABI_PACKED;
 
 /*
  * Host->BPMP request data for request type CMD_THERMAL_SET_TRIP
  *
  * zone: Number of thermal zone.
  * low: Temperature of lower trip point in millicelsius
  * high: Temperature of upper trip point in millicelsius
  * enabled: 1 to enable trip point, 0 to disable trip point
  */
 struct cmd_thermal_set_trip_request {
     uint32_t zone;
     int32_t low;
     int32_t high;
     uint32_t enabled;
 } BPMP_ABI_PACKED;
 
 /*
  * BPMP->Host request data for request type CMD_THERMAL_HOST_TRIP_REACHED
  *
  * zone: Number of thermal zone where trip point was reached.
  */
 struct cmd_thermal_host_trip_reached_request {
     uint32_t zone;
 } BPMP_ABI_PACKED;
 
 /*
  * BPMP->Host reply data for request type CMD_THERMAL_GET_NUM_ZONES
  *
  * num: Number of supported thermal zones. The thermal zones are indexed
  *      starting from zero.
  */
 struct cmd_thermal_get_num_zones_response {
     uint32_t num;
 } BPMP_ABI_PACKED;
 
 /*
  * Host->BPMP request data for request type CMD_THERMAL_GET_THERMTRIP
  *
  * zone: Number of thermal zone.
  */
 struct cmd_thermal_get_thermtrip_request {
     uint32_t zone;
 } BPMP_ABI_PACKED;
 
 /*
  * BPMP->Host reply data for request CMD_THERMAL_GET_THERMTRIP
  *
  * thermtrip: HW shutdown temperature in millicelsius.
  */
 struct cmd_thermal_get_thermtrip_response {
     int32_t thermtrip;
 } BPMP_ABI_PACKED;
 
 /*
  * Host->BPMP request data.
  *
  * Reply type is union mrq_thermal_bpmp_to_host_response.
  *
  * type: Type of request. Values listed in enum mrq_thermal_type.
  * data: Request type specific parameters.
  */
 struct mrq_thermal_host_to_bpmp_request {
     uint32_t type;
     union {
         struct cmd_thermal_query_abi_request query_abi;
         struct cmd_thermal_get_temp_request get_temp;
         struct cmd_thermal_set_trip_request set_trip;
         struct cmd_thermal_get_thermtrip_request get_thermtrip;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /*
  * BPMP->Host request data.
  *
  * type: Type of request. Values listed in enum mrq_thermal_type.
  * data: Request type specific parameters.
  */
 struct mrq_thermal_bpmp_to_host_request {
     uint32_t type;
     union {
         struct cmd_thermal_host_trip_reached_request host_trip_reached;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /*
  * Data in reply to a Host->BPMP request.
  */
 union mrq_thermal_bpmp_to_host_response {
     struct cmd_thermal_get_temp_response get_temp;
     struct cmd_thermal_get_thermtrip_response get_thermtrip;
     struct cmd_thermal_get_num_zones_response get_num_zones;
 } BPMP_ABI_PACKED;
 /** @} */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_CPU_VHINT
  * @brief Query CPU voltage hint data
  *
  * * Platforms: T186
  * @cond bpmp_t186
  * * Initiators: CCPLEX
  * * Targets: BPMP
  * * Request Payload: @ref mrq_cpu_vhint_request
  * * Response Payload: N/A
  *
  * @addtogroup Vhint
  * @{
  */
 
 /**
  * @brief Request with #MRQ_CPU_VHINT
  *
  * Used by #MRQ_CPU_VHINT call by CCPLEX to retrieve voltage hint data
  * from BPMP to memory space pointed by #addr. CCPLEX is responsible
  * to allocate sizeof(cpu_vhint_data) sized block of memory and
  * appropriately map it for BPMP before sending the request.
  */
 struct mrq_cpu_vhint_request {
     /** @brief IOVA address for the #cpu_vhint_data */
     uint32_t addr;
     /** @brief ID of the cluster whose data is requested */
     uint32_t cluster_id;
 } BPMP_ABI_PACKED;
 
 /**
  * @brief Description of the CPU v/f relation
  *
  * Used by #MRQ_CPU_VHINT call to carry data pointed by
  * #mrq_cpu_vhint_request::addr
  */
 struct cpu_vhint_data {
     uint32_t ref_clk_hz; /**< reference frequency in Hz */
     uint16_t pdiv; /**< post divider value */
     uint16_t mdiv; /**< input divider value */
     uint16_t ndiv_max; /**< fMAX expressed with max NDIV value */
     /** table of ndiv values as a function of vINDEX (voltage index) */
     uint16_t ndiv[80];
     /** minimum allowed NDIV value */
     uint16_t ndiv_min;
     /** minimum allowed voltage hint value (as in vINDEX) */
     uint16_t vfloor;
     /** maximum allowed voltage hint value (as in vINDEX) */
     uint16_t vceil;
     /** post-multiplier for vindex value */
     uint16_t vindex_mult;
     /** post-divider for vindex value */
     uint16_t vindex_div;
     /** reserved for future use */
     uint16_t reserved[328];
 } BPMP_ABI_PACKED;
 /** @endcond */
 /** @} */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_ABI_RATCHET
  * @brief ABI ratchet value query
  *
  * * Platforms: T186, T194
  * * Initiators: Any
  * * Targets: BPMP
  * * Request Payload: @ref mrq_abi_ratchet_request
  * * Response Payload: @ref mrq_abi_ratchet_response
  * @addtogroup ABI_info
  * @{
  */
 
 /**
  * @brief An ABI compatibility mechanism
  *
  * BPMP_ABI_RATCHET_VALUE may increase for various reasons in a future
  * revision of this header file.
  * 1. That future revision deprecates some MRQ
  * 2. That future revision introduces a breaking change to an existing
  *    MRQ or
  * 3. A bug is discovered in an existing implementation of the BPMP-FW
  *    (or possibly one of its clients) which warrants deprecating that
  *    implementation.
  */
 #define BPMP_ABI_RATCHET_VALUE 3
 
 /**
  * @brief Request with #MRQ_ABI_RATCHET.
  *
  * #ratchet should be #BPMP_ABI_RATCHET_VALUE from the ABI header
  * against which the requester was compiled.
  *
  * If ratchet is less than BPMP's #BPMP_ABI_RATCHET_VALUE, BPMP may
  * reply with mrq_response::err = -#BPMP_ERANGE to indicate that
  * BPMP-FW cannot interoperate correctly with the requester. Requester
  * should cease further communication with BPMP.
  *
  * Otherwise, err shall be 0.
  */
 struct mrq_abi_ratchet_request {
     /** @brief Requester's ratchet value */
     uint16_t ratchet;
 };
 
 /**
  * @brief Response to #MRQ_ABI_RATCHET
  *
  * #ratchet shall be #BPMP_ABI_RATCHET_VALUE from the ABI header
  * against which BPMP firwmare was compiled.
  *
  * If #ratchet is less than the requester's #BPMP_ABI_RATCHET_VALUE,
  * the requster must either interoperate with BPMP according to an ABI
  * header version with BPMP_ABI_RATCHET_VALUE = ratchet or cease
  * communication with BPMP.
  *
  * If mrq_response::err is 0 and ratchet is greater than or equal to the
  * requester's BPMP_ABI_RATCHET_VALUE, the requester should continue
  * normal operation.
  */
 struct mrq_abi_ratchet_response {
     /** @brief BPMP's ratchet value */
     uint16_t ratchet;
 };
 /** @} */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_EMC_DVFS_LATENCY
  * @brief Query frequency dependent EMC DVFS latency
  *
  * * Platforms: T186, T194
  * * Initiators: CCPLEX
  * * Targets: BPMP
  * * Request Payload: N/A
  * * Response Payload: @ref mrq_emc_dvfs_latency_response
  * @addtogroup EMC
  * @{
  */
 
 /**
  * @brief Used by @ref mrq_emc_dvfs_latency_response
  */
 struct emc_dvfs_latency {
     /** @brief EMC DVFS node frequency in kHz */
     uint32_t freq;
     /** @brief EMC DVFS latency in nanoseconds */
     uint32_t latency;
 } BPMP_ABI_PACKED;
 
 #define EMC_DVFS_LATENCY_MAX_SIZE   14
 /**
  * @brief Response to #MRQ_EMC_DVFS_LATENCY
  */
 struct mrq_emc_dvfs_latency_response {
     /** @brief The number valid entries in #pairs */
     uint32_t num_pairs;
     /** @brief EMC DVFS node <frequency, latency> information */
     struct emc_dvfs_latency pairs[EMC_DVFS_LATENCY_MAX_SIZE];
 } BPMP_ABI_PACKED;
 
 /** @} */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_CPU_NDIV_LIMITS
  * @brief CPU freq. limits in ndiv
  *
  * * Platforms: T194 onwards
  * @cond bpmp_t194
  * * Initiators: CCPLEX
  * * Targets: BPMP
  * * Request Payload: @ref mrq_cpu_ndiv_limits_request
  * * Response Payload: @ref mrq_cpu_ndiv_limits_response
  * @addtogroup CPU
  * @{
  */
 
 /**
  * @brief Request for ndiv limits of a cluster
  */
 struct mrq_cpu_ndiv_limits_request {
     /** @brief Enum cluster_id */
     uint32_t cluster_id;
 } BPMP_ABI_PACKED;
 
 /**
  * @brief Response to #MRQ_CPU_NDIV_LIMITS
  */
 struct mrq_cpu_ndiv_limits_response {
     /** @brief Reference frequency in Hz */
     uint32_t ref_clk_hz;
     /** @brief Post divider value */
     uint16_t pdiv;
     /** @brief Input divider value */
     uint16_t mdiv;
     /** @brief FMAX expressed with max NDIV value */
     uint16_t ndiv_max;
     /** @brief Minimum allowed NDIV value */
     uint16_t ndiv_min;
 } BPMP_ABI_PACKED;
 
 /** @} */
 /** @endcond */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_CPU_AUTO_CC3
  * @brief Query CPU cluster auto-CC3 configuration
  *
  * * Platforms: T194 onwards
  * @cond bpmp_t194
  * * Initiators: CCPLEX
  * * Targets: BPMP
  * * Request Payload: @ref mrq_cpu_auto_cc3_request
  * * Response Payload: @ref mrq_cpu_auto_cc3_response
  * @addtogroup CC3
  *
  * Queries from BPMP auto-CC3 configuration (allowed/not allowed) for a
  * specified cluster. CCPLEX s/w uses this information to override its own
  * device tree auto-CC3 settings, so that BPMP device tree is a single source of
  * auto-CC3 platform configuration.
  *
  * @{
  */
 
 /**
  * @brief Request for auto-CC3 configuration of a cluster
  */
 struct mrq_cpu_auto_cc3_request {
     /** @brief Enum cluster_id (logical cluster id, known to CCPLEX s/w) */
     uint32_t cluster_id;
 } BPMP_ABI_PACKED;
 
 /**
  * @brief Response to #MRQ_CPU_AUTO_CC3
  */
 struct mrq_cpu_auto_cc3_response {
     /**
      * @brief auto-CC3 configuration
      *
      * - bits[31..10] reserved.
      * - bits[9..1] cc3 ndiv
      * - bit [0] if "1" auto-CC3 is allowed, if "0" auto-CC3 is not allowed
      */
     uint32_t auto_cc3_config;
 } BPMP_ABI_PACKED;
 
 /** @} */
 /** @endcond */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_TRACE_ITER
  * @brief Manage the trace iterator
  *
  * @deprecated
  *
  * * Platforms: All
  * * Initiators: CCPLEX
  * * Targets: BPMP
  * * Request Payload: N/A
  * * Response Payload: @ref mrq_trace_iter_request
  * @addtogroup Trace
  * @{
  */
 enum {
     /** @brief (re)start the tracing now. Ignore older events */
     TRACE_ITER_INIT = 0,
     /** @brief Clobber all events in the trace buffer */
     TRACE_ITER_CLEAN = 1
 };
 
 /**
  * @brief Request with #MRQ_TRACE_ITER
  */
 struct mrq_trace_iter_request {
     /** @brief TRACE_ITER_INIT or TRACE_ITER_CLEAN */
     uint32_t cmd;
 } BPMP_ABI_PACKED;
 
 /** @} */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_RINGBUF_CONSOLE
  * @brief A ring buffer debug console for BPMP
  * @addtogroup RingbufConsole
  *
  * The ring buffer debug console aims to be a substitute for the UART debug
  * console. The debug console is implemented with two ring buffers in the
  * BPMP-FW, the RX (receive) and TX (transmit) buffers. Characters can be read
  * and written to the buffers by the host via the MRQ interface.
  *
  * @{
  */
 
 /**
  * @brief Maximum number of bytes transferred in a single write command to the
  * BPMP
  *
  * This is determined by the number of free bytes in the message struct,
  * rounded down to a multiple of four.
  */
 #define MRQ_RINGBUF_CONSOLE_MAX_WRITE_LEN 112
 
 /**
  * @brief Maximum number of bytes transferred in a single read command to the
  * BPMP
  *
  * This is determined by the number of free bytes in the message struct,
  * rounded down to a multiple of four.
  */
 #define MRQ_RINGBUF_CONSOLE_MAX_READ_LEN 116
 
 enum mrq_ringbuf_console_host_to_bpmp_cmd {
     /**
      * @brief Check whether the BPMP driver supports the specified request
      * type
      *
      * mrq_response::err is 0 if the specified request is supported and
      * -#BPMP_ENODEV otherwise
      */
     CMD_RINGBUF_CONSOLE_QUERY_ABI = 0,
     /**
      * @brief Perform a read operation on the BPMP TX buffer
      *
      * mrq_response::err is 0
      */
     CMD_RINGBUF_CONSOLE_READ = 1,
     /**
      * @brief Perform a write operation on the BPMP RX buffer
      *
      * mrq_response::err is 0 if the operation was successful and
      * -#BPMP_ENODEV otherwise
      */
     CMD_RINGBUF_CONSOLE_WRITE = 2,
     /**
      * @brief Get the length of the buffer and the physical addresses of
      * the buffer data and the head and tail counters
      *
      * mrq_response::err is 0 if the operation was successful and
      * -#BPMP_ENODEV otherwise
      */
     CMD_RINGBUF_CONSOLE_GET_FIFO = 3,
 };
 
 /**
  * @ingroup RingbufConsole
  * @brief Host->BPMP request data for request type
  * #CMD_RINGBUF_CONSOLE_QUERY_ABI
  */
 struct cmd_ringbuf_console_query_abi_req {
     /** @brief Command identifier to be queried */
     uint32_t cmd;
 } BPMP_ABI_PACKED;
 
 /** @private */
 struct cmd_ringbuf_console_query_abi_resp {
     BPMP_ABI_EMPTY
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup RingbufConsole
  * @brief Host->BPMP request data for request type #CMD_RINGBUF_CONSOLE_READ
  */
 struct cmd_ringbuf_console_read_req {
     /**
      * @brief Number of bytes requested to be read from the BPMP TX buffer
      */
     uint8_t len;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup RingbufConsole
  * @brief BPMP->Host response data for request type #CMD_RINGBUF_CONSOLE_READ
  */
 struct cmd_ringbuf_console_read_resp {
     /** @brief The actual data read from the BPMP TX buffer */
     uint8_t data[MRQ_RINGBUF_CONSOLE_MAX_READ_LEN];
     /** @brief Number of bytes in cmd_ringbuf_console_read_resp::data */
     uint8_t len;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup RingbufConsole
  * @brief Host->BPMP request data for request type #CMD_RINGBUF_CONSOLE_WRITE
  */
 struct cmd_ringbuf_console_write_req {
     /** @brief The actual data to be written to the BPMP RX buffer */
     uint8_t data[MRQ_RINGBUF_CONSOLE_MAX_WRITE_LEN];
     /** @brief Number of bytes in cmd_ringbuf_console_write_req::data */
     uint8_t len;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup RingbufConsole
  * @brief BPMP->Host response data for request type #CMD_RINGBUF_CONSOLE_WRITE
  */
 struct cmd_ringbuf_console_write_resp {
     /** @brief Number of bytes of available space in the BPMP RX buffer */
     uint32_t space_avail;
     /** @brief Number of bytes that were written to the BPMP RX buffer */
     uint8_t len;
 } BPMP_ABI_PACKED;
 
 /** @private */
 struct cmd_ringbuf_console_get_fifo_req {
     BPMP_ABI_EMPTY
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup RingbufConsole
  * @brief BPMP->Host reply data for request type #CMD_RINGBUF_CONSOLE_GET_FIFO
  */
 struct cmd_ringbuf_console_get_fifo_resp {
     /** @brief Physical address of the BPMP TX buffer */
     uint64_t bpmp_tx_buf_addr;
     /** @brief Physical address of the BPMP TX buffer head counter */
     uint64_t bpmp_tx_head_addr;
     /** @brief Physical address of the BPMP TX buffer tail counter */
     uint64_t bpmp_tx_tail_addr;
     /** @brief Length of the BPMP TX buffer */
     uint32_t bpmp_tx_buf_len;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup RingbufConsole
  * @brief Host->BPMP request data.
  *
  * Reply type is union #mrq_ringbuf_console_bpmp_to_host_response .
  */
 struct mrq_ringbuf_console_host_to_bpmp_request {
     /**
      * @brief Type of request. Values listed in enum
      * #mrq_ringbuf_console_host_to_bpmp_cmd.
      */
     uint32_t type;
     /** @brief  request type specific parameters. */
     union {
         struct cmd_ringbuf_console_query_abi_req query_abi;
         struct cmd_ringbuf_console_read_req read;
         struct cmd_ringbuf_console_write_req write;
         struct cmd_ringbuf_console_get_fifo_req get_fifo;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup RingbufConsole
  * @brief Host->BPMP reply data
  *
  * In response to struct #mrq_ringbuf_console_host_to_bpmp_request.
  */
 union mrq_ringbuf_console_bpmp_to_host_response {
     struct cmd_ringbuf_console_query_abi_resp query_abi;
     struct cmd_ringbuf_console_read_resp read;
     struct cmd_ringbuf_console_write_resp write;
     struct cmd_ringbuf_console_get_fifo_resp get_fifo;
 } BPMP_ABI_PACKED;
 /** @} */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_STRAP
  * @brief Set a strap value controlled by BPMP
  *
  * * Platforms: T194 onwards
  * @cond bpmp_t194
  * * Initiators: CCPLEX
  * * Targets: BPMP
  * * Request Payload: @ref mrq_strap_request
  * * Response Payload: N/A
  * @addtogroup Strap
  *
  * A strap is an input that is sampled by a hardware unit during the
  * unit's startup process. The sampled value of a strap affects the
  * behavior of the unit until the unit is restarted. Many hardware
  * units sample their straps at the instant that their resets are
  * deasserted.
  *
  * BPMP owns registers which act as straps to various units. It
  * exposes limited control of those straps via #MRQ_STRAP.
  *
  * @{
  */
 enum mrq_strap_cmd {
     /** @private */
     STRAP_RESERVED = 0,
     /** @brief Set a strap value */
     STRAP_SET = 1
 };
 
 /**
  * @brief Request with #MRQ_STRAP
  */
 struct mrq_strap_request {
     /** @brief @ref mrq_strap_cmd */
     uint32_t cmd;
     /** @brief Strap ID from @ref Strap_Ids */
     uint32_t id;
     /** @brief Desired value for strap (if cmd is #STRAP_SET) */
     uint32_t value;
 } BPMP_ABI_PACKED;
 
 /**
  * @defgroup Strap_Ids Strap Identifiers
  * @}
  */
 /** @endcond */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_UPHY
  * @brief Perform a UPHY operation
  *
  * * Platforms: T194 onwards
  * @cond bpmp_t194
  * * Initiators: CCPLEX
  * * Targets: BPMP
  * * Request Payload: @ref mrq_uphy_request
  * * Response Payload: @ref mrq_uphy_response
  *
  * @addtogroup UPHY
  * @{
  */
 enum {
     CMD_UPHY_PCIE_LANE_MARGIN_CONTROL = 1,
     CMD_UPHY_PCIE_LANE_MARGIN_STATUS = 2,
     CMD_UPHY_PCIE_EP_CONTROLLER_PLL_INIT = 3,
     CMD_UPHY_PCIE_CONTROLLER_STATE = 4,
     CMD_UPHY_PCIE_EP_CONTROLLER_PLL_OFF = 5,
     CMD_UPHY_MAX,
 };
 
 struct cmd_uphy_margin_control_request {
     /** @brief Enable margin */
     int32_t en;
     /** @brief Clear the number of error and sections */
     int32_t clr;
     /** @brief Set x offset (1's complement) for left/right margin type (y should be 0) */
     uint32_t x;
     /** @brief Set y offset (1's complement) for left/right margin type (x should be 0) */
     uint32_t y;
     /** @brief Set number of bit blocks for each margin section */
     uint32_t nblks;
 } BPMP_ABI_PACKED;
 
 struct cmd_uphy_margin_status_response {
     /** @brief Number of errors observed */
     uint32_t status;
 } BPMP_ABI_PACKED;
 
 struct cmd_uphy_ep_controller_pll_init_request {
     /** @brief EP controller number, valid: 0, 4, 5 */
     uint8_t ep_controller;
 } BPMP_ABI_PACKED;
 
 struct cmd_uphy_pcie_controller_state_request {
     /** @brief PCIE controller number, valid: 0, 1, 2, 3, 4 */
     uint8_t pcie_controller;
     uint8_t enable;
 } BPMP_ABI_PACKED;
 
 struct cmd_uphy_ep_controller_pll_off_request {
     /** @brief EP controller number, valid: 0, 4, 5 */
     uint8_t ep_controller;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup UPHY
  * @brief Request with #MRQ_UPHY
  *
  * Used by the sender of an #MRQ_UPHY message to control UPHY Lane RX margining.
  * The uphy_request is split into several sub-commands. Some sub-commands
  * require no additional data. Others have a sub-command specific payload
  *
  * |sub-command                          |payload                                 |
  * |------------------------------------ |----------------------------------------|
  * |CMD_UPHY_PCIE_LANE_MARGIN_CONTROL    |uphy_set_margin_control                 |
  * |CMD_UPHY_PCIE_LANE_MARGIN_STATUS     |                                        |
  * |CMD_UPHY_PCIE_EP_CONTROLLER_PLL_INIT |cmd_uphy_ep_controller_pll_init_request |
  * |CMD_UPHY_PCIE_CONTROLLER_STATE       |cmd_uphy_pcie_controller_state_request  |
  * |CMD_UPHY_PCIE_EP_CONTROLLER_PLL_OFF  |cmd_uphy_ep_controller_pll_off_request  |
  *
  */
 
 struct mrq_uphy_request {
     /** @brief Lane number. */
     uint16_t lane;
     /** @brief Sub-command id. */
     uint16_t cmd;
 
     union {
         struct cmd_uphy_margin_control_request uphy_set_margin_control;
         struct cmd_uphy_ep_controller_pll_init_request ep_ctrlr_pll_init;
         struct cmd_uphy_pcie_controller_state_request controller_state;
         struct cmd_uphy_ep_controller_pll_off_request ep_ctrlr_pll_off;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup UPHY
  * @brief Response to MRQ_UPHY
  *
  * Each sub-command supported by @ref mrq_uphy_request may return
  * sub-command-specific data. Some do and some do not as indicated in
  * the following table
  *
  * |sub-command                       |payload                 |
  * |----------------------------      |------------------------|
  * |CMD_UPHY_PCIE_LANE_MARGIN_CONTROL |                        |
  * |CMD_UPHY_PCIE_LANE_MARGIN_STATUS  |uphy_get_margin_status  |
  *
  */
 
 struct mrq_uphy_response {
     union {
         struct cmd_uphy_margin_status_response uphy_get_margin_status;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /** @} */
 /** @endcond */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_FMON
  * @brief Perform a frequency monitor configuration operations
  *
  * * Platforms: T194 onwards
  * @cond bpmp_t194
  * * Initiators: CCPLEX
  * * Targets: BPMP
  * * Request Payload: @ref mrq_fmon_request
  * * Response Payload: @ref mrq_fmon_response
  *
  * @addtogroup FMON
  * @{
  */
 enum {
     /**
      * @brief Clamp FMON configuration to specified rate.
      *
      * The monitored clock must be running for clamp to succeed. If
      * clamped, FMON configuration is preserved when clock rate
      * and/or state is changed.
      */
     CMD_FMON_GEAR_CLAMP = 1,
     /**
      * @brief Release clamped FMON configuration.
      *
      * Allow FMON configuration to follow monitored clock rate
      * and/or state changes.
      */
     CMD_FMON_GEAR_FREE = 2,
     /**
      * @brief Return rate FMON is clamped at, or 0 if FMON is not
      *         clamped.
      *
      * Inherently racy, since clamp state can be changed
      * concurrently. Useful for testing.
      */
     CMD_FMON_GEAR_GET = 3,
     CMD_FMON_NUM,
 };
 
 struct cmd_fmon_gear_clamp_request {
     int32_t unused;
     int64_t rate;
 } BPMP_ABI_PACKED;
 
 /** @private */
 struct cmd_fmon_gear_clamp_response {
     BPMP_ABI_EMPTY
 } BPMP_ABI_PACKED;
 
 /** @private */
 struct cmd_fmon_gear_free_request {
     BPMP_ABI_EMPTY
 } BPMP_ABI_PACKED;
 
 /** @private */
 struct cmd_fmon_gear_free_response {
     BPMP_ABI_EMPTY
 } BPMP_ABI_PACKED;
 
 /** @private */
 struct cmd_fmon_gear_get_request {
     BPMP_ABI_EMPTY
 } BPMP_ABI_PACKED;
 
 struct cmd_fmon_gear_get_response {
     int64_t rate;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup FMON
  * @brief Request with #MRQ_FMON
  *
  * Used by the sender of an #MRQ_FMON message to configure clock
  * frequency monitors. The FMON request is split into several
  * sub-commands. Some sub-commands require no additional data.
  * Others have a sub-command specific payload
  *
  * |sub-command                 |payload                |
  * |----------------------------|-----------------------|
  * |CMD_FMON_GEAR_CLAMP         |fmon_gear_clamp        |
  * |CMD_FMON_GEAR_FREE          |-                      |
  * |CMD_FMON_GEAR_GET           |-                      |
  *
  */
 
 struct mrq_fmon_request {
     /** @brief Sub-command and clock id concatenated to 32-bit word.
      * - bits[31..24] is the sub-cmd.
      * - bits[23..0] is monitored clock id used to select target
      *   FMON
      */
     uint32_t cmd_and_id;
 
     union {
         struct cmd_fmon_gear_clamp_request fmon_gear_clamp;
         /** @private */
         struct cmd_fmon_gear_free_request fmon_gear_free;
         /** @private */
         struct cmd_fmon_gear_get_request fmon_gear_get;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup FMON
  * @brief Response to MRQ_FMON
  *
  * Each sub-command supported by @ref mrq_fmon_request may
  * return sub-command-specific data as indicated below.
  *
  * |sub-command                 |payload                 |
  * |----------------------------|------------------------|
  * |CMD_FMON_GEAR_CLAMP         |-                       |
  * |CMD_FMON_GEAR_FREE          |-                       |
  * |CMD_FMON_GEAR_GET           |fmon_gear_get           |
  *
  */
 
 struct mrq_fmon_response {
     union {
         /** @private */
         struct cmd_fmon_gear_clamp_response fmon_gear_clamp;
         /** @private */
         struct cmd_fmon_gear_free_response fmon_gear_free;
         struct cmd_fmon_gear_get_response fmon_gear_get;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /** @} */
 /** @endcond */
 
 /**
  * @ingroup MRQ_Codes
  * @def MRQ_EC
  * @brief Provide status information on faults reported by Error
  *        Collator (EC) to HSM.
  *
  * * Platforms: T194 onwards
  * @cond bpmp_t194
  * * Initiators: CCPLEX
  * * Targets: BPMP
  * * Request Payload: @ref mrq_ec_request
  * * Response Payload: @ref mrq_ec_response
  *
  * @note This MRQ ABI is under construction, and subject to change
  *
  * @addtogroup EC
  * @{
  */
 enum {
     /**
      * @cond DEPRECATED
      * @brief Retrieve specified EC status.
      *
      * mrq_response::err is 0 if the operation was successful, or @n
      * -#BPMP_ENODEV if target EC is not owned by BPMP @n
      * -#BPMP_EACCES if target EC power domain is turned off @n
      * -#BPMP_EBADCMD if subcommand is not supported
      * @endcond
      */
     CMD_EC_STATUS_GET = 1,  /* deprecated */
 
     /**
      * @brief Retrieve specified EC extended status (includes error
      *        counter and user values).
      *
      * mrq_response::err is 0 if the operation was successful, or @n
      * -#BPMP_ENODEV if target EC is not owned by BPMP @n
      * -#BPMP_EACCES if target EC power domain is turned off @n
      * -#BPMP_EBADCMD if subcommand is not supported
      */
     CMD_EC_STATUS_EX_GET = 2,
     CMD_EC_NUM,
 };
 
 /** @brief BPMP ECs error types */
 enum bpmp_ec_err_type {
     /** @brief Parity error on internal data path
      *
      *  Error descriptor @ref ec_err_simple_desc.
      */
     EC_ERR_TYPE_PARITY_INTERNAL     = 1,
 
     /** @brief ECC SEC error on internal data path
      *
      *  Error descriptor @ref ec_err_simple_desc.
      */
     EC_ERR_TYPE_ECC_SEC_INTERNAL        = 2,
 
     /** @brief ECC DED error on internal data path
      *
      *  Error descriptor @ref ec_err_simple_desc.
      */
     EC_ERR_TYPE_ECC_DED_INTERNAL        = 3,
 
     /** @brief Comparator error
      *
      *  Error descriptor @ref ec_err_simple_desc.
      */
     EC_ERR_TYPE_COMPARATOR          = 4,
 
     /** @brief Register parity error
      *
      *  Error descriptor @ref ec_err_reg_parity_desc.
      */
     EC_ERR_TYPE_REGISTER_PARITY     = 5,
 
     /** @brief Parity error from on-chip SRAM/FIFO
      *
      *  Error descriptor @ref ec_err_simple_desc.
      */
     EC_ERR_TYPE_PARITY_SRAM         = 6,
 
     /** @brief Clock Monitor error
      *
      *  Error descriptor @ref ec_err_fmon_desc.
      */
     EC_ERR_TYPE_CLOCK_MONITOR       = 9,
 
     /** @brief Voltage Monitor error
      *
      *  Error descriptor @ref ec_err_vmon_desc.
      */
     EC_ERR_TYPE_VOLTAGE_MONITOR     = 10,
 
     /** @brief SW Correctable error
      *
      *  Error descriptor @ref ec_err_sw_error_desc.
      */
     EC_ERR_TYPE_SW_CORRECTABLE      = 16,
 
     /** @brief SW Uncorrectable error
      *
      *  Error descriptor @ref ec_err_sw_error_desc.
      */
     EC_ERR_TYPE_SW_UNCORRECTABLE        = 17,
 
     /** @brief Other HW Correctable error
      *
      *  Error descriptor @ref ec_err_simple_desc.
      */
     EC_ERR_TYPE_OTHER_HW_CORRECTABLE    = 32,
 
     /** @brief Other HW Uncorrectable error
      *
      *  Error descriptor @ref ec_err_simple_desc.
      */
     EC_ERR_TYPE_OTHER_HW_UNCORRECTABLE  = 33,
 };
 
 /** @brief Group of registers with parity error. */
 enum ec_registers_group {
     /** @brief Functional registers group */
     EC_ERR_GROUP_FUNC_REG       = 0U,
     /** @brief SCR registers group */
     EC_ERR_GROUP_SCR_REG        = 1U,
 };
 
 /**
  * @defgroup bpmp_ec_status_flags EC Status Flags
  * @addtogroup bpmp_ec_status_flags
  * @{
  */
 /** @brief No EC error found flag */
 #define EC_STATUS_FLAG_NO_ERROR     0x0001U
 /** @brief Last EC error found flag */
 #define EC_STATUS_FLAG_LAST_ERROR   0x0002U
 /** @brief EC latent error flag */
 #define EC_STATUS_FLAG_LATENT_ERROR 0x0004U
 /** @} */
 
 /**
  * @defgroup bpmp_ec_desc_flags EC Descriptor Flags
  * @addtogroup bpmp_ec_desc_flags
  * @{
  */
 /** @brief EC descriptor error resolved flag */
 #define EC_DESC_FLAG_RESOLVED       0x0001U
 /** @brief EC descriptor failed to retrieve id flag */
 #define EC_DESC_FLAG_NO_ID      0x0002U
 /** @} */
 
 /**
  * |error type                       | fmon_clk_id values        |
  * |---------------------------------|---------------------------|
  * |@ref EC_ERR_TYPE_CLOCK_MONITOR   |@ref bpmp_clock_ids        |
  */
 struct ec_err_fmon_desc {
     /** @brief Bitmask of @ref bpmp_ec_desc_flags  */
     uint16_t desc_flags;
     /** @brief FMON monitored clock id */
     uint16_t fmon_clk_id;
     /** @brief Bitmask of @ref bpmp_fmon_faults_flags */
     uint32_t fmon_faults;
     /** @brief FMON faults access error */
     int32_t fmon_access_error;
 } BPMP_ABI_PACKED;
 
 /**
  * |error type                       | vmon_adc_id values        |
  * |---------------------------------|---------------------------|
  * |@ref EC_ERR_TYPE_VOLTAGE_MONITOR |@ref bpmp_adc_ids          |
  */
 struct ec_err_vmon_desc {
     /** @brief Bitmask of @ref bpmp_ec_desc_flags  */
     uint16_t desc_flags;
     /** @brief VMON rail adc id */
     uint16_t vmon_adc_id;
     /** @brief Bitmask of @ref bpmp_vmon_faults_flags */
     uint32_t vmon_faults;
     /** @brief VMON faults access error */
     int32_t vmon_access_error;
 } BPMP_ABI_PACKED;
 
 /**
  * |error type                       | reg_id values             |
  * |---------------------------------|---------------------------|
  * |@ref EC_ERR_TYPE_REGISTER_PARITY |@ref bpmp_ec_registers_ids |
  */
 struct ec_err_reg_parity_desc {
     /** @brief Bitmask of @ref bpmp_ec_desc_flags  */
     uint16_t desc_flags;
     /** @brief Register id */
     uint16_t reg_id;
     /** @brief Register group @ref ec_registers_group */
     uint16_t reg_group;
 } BPMP_ABI_PACKED;
 
 /**
  * |error type                        | err_source_id values     |
  * |--------------------------------- |--------------------------|
  * |@ref EC_ERR_TYPE_SW_CORRECTABLE   | @ref bpmp_ec_ce_swd_ids  |
  * |@ref EC_ERR_TYPE_SW_UNCORRECTABLE | @ref bpmp_ec_ue_swd_ids  |
  */
 struct ec_err_sw_error_desc {
     /** @brief Bitmask of @ref bpmp_ec_desc_flags  */
     uint16_t desc_flags;
     /** @brief Error source id */
     uint16_t err_source_id;
     /** @brief Sw error data */
     uint32_t sw_error_data;
 } BPMP_ABI_PACKED;
 
 /**
  * |error type                              | err_source_id values      |
  * |----------------------------------------|---------------------------|
  * |@ref EC_ERR_TYPE_PARITY_INTERNAL        |@ref bpmp_ec_ipath_ids     |
  * |@ref EC_ERR_TYPE_ECC_SEC_INTERNAL       |@ref bpmp_ec_ipath_ids     |
  * |@ref EC_ERR_TYPE_ECC_DED_INTERNAL       |@ref bpmp_ec_ipath_ids     |
  * |@ref EC_ERR_TYPE_COMPARATOR             |@ref bpmp_ec_comparator_ids|
  * |@ref EC_ERR_TYPE_PARITY_SRAM            |@ref bpmp_clock_ids        |
  * |@ref EC_ERR_TYPE_OTHER_HW_CORRECTABLE   |@ref bpmp_ec_misc_hwd_ids  |
  * |@ref EC_ERR_TYPE_OTHER_HW_UNCORRECTABLE |@ref bpmp_ec_misc_hwd_ids  |
  */
 struct ec_err_simple_desc {
     /** @brief Bitmask of @ref bpmp_ec_desc_flags  */
     uint16_t desc_flags;
     /** @brief Error source id. Id space depends on error type. */
     uint16_t err_source_id;
 } BPMP_ABI_PACKED;
 
 /** @brief Union of EC error descriptors */
 union ec_err_desc {
     struct ec_err_fmon_desc fmon_desc;
     struct ec_err_vmon_desc vmon_desc;
     struct ec_err_reg_parity_desc reg_parity_desc;
     struct ec_err_sw_error_desc sw_error_desc;
     struct ec_err_simple_desc simple_desc;
 } BPMP_ABI_PACKED;
 
 struct cmd_ec_status_get_request {
     /** @brief HSM error line number that identifies target EC. */
     uint32_t ec_hsm_id;
 } BPMP_ABI_PACKED;
 
 /** EC status maximum number of descriptors */
 #define EC_ERR_STATUS_DESC_MAX_NUM  4U
 
 /**
  * @cond DEPRECATED
  */
 struct cmd_ec_status_get_response {
     /** @brief Target EC id (the same id received with request). */
     uint32_t ec_hsm_id;
     /**
      * @brief Bitmask of @ref bpmp_ec_status_flags
      *
      * If NO_ERROR flag is set, error_ fields should be ignored
      */
     uint32_t ec_status_flags;
     /** @brief Found EC error index. */
     uint32_t error_idx;
     /** @brief  Found EC error type @ref bpmp_ec_err_type. */
     uint32_t error_type;
     /** @brief  Number of returned EC error descriptors */
     uint32_t error_desc_num;
     /** @brief  EC error descriptors */
     union ec_err_desc error_descs[EC_ERR_STATUS_DESC_MAX_NUM];
 } BPMP_ABI_PACKED;
 /** @endcond */
 
 struct cmd_ec_status_ex_get_response {
     /** @brief Target EC id (the same id received with request). */
     uint32_t ec_hsm_id;
     /**
      * @brief Bitmask of @ref bpmp_ec_status_flags
      *
      * If NO_ERROR flag is set, error_ fields should be ignored
      */
     uint32_t ec_status_flags;
     /** @brief Found EC error index. */
     uint32_t error_idx;
     /** @brief  Found EC error type @ref bpmp_ec_err_type. */
     uint32_t error_type;
     /** @brief  Found EC mission error counter value */
     uint32_t error_counter;
     /** @brief  Found EC mission error user value */
     uint32_t error_uval;
     /** @brief  Reserved entry    */
     uint32_t reserved;
     /** @brief  Number of returned EC error descriptors */
     uint32_t error_desc_num;
     /** @brief  EC error descriptors */
     union ec_err_desc error_descs[EC_ERR_STATUS_DESC_MAX_NUM];
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup EC
  * @brief Request with #MRQ_EC
  *
  * Used by the sender of an #MRQ_EC message to access ECs owned
  * by BPMP.
  *
  * @cond DEPRECATED
  * |sub-command                 |payload                |
  * |----------------------------|-----------------------|
  * |@ref CMD_EC_STATUS_GET      |ec_status_get          |
  * @endcond
  *
  * |sub-command                 |payload                |
  * |----------------------------|-----------------------|
  * |@ref CMD_EC_STATUS_EX_GET   |ec_status_get          |
  *
  */
 
 struct mrq_ec_request {
     /** @brief Sub-command id. */
     uint32_t cmd_id;
 
     union {
         struct cmd_ec_status_get_request ec_status_get;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /**
  * @ingroup EC
  * @brief Response to MRQ_EC
  *
  * Each sub-command supported by @ref mrq_ec_request may return
  * sub-command-specific data as indicated below.
  *
  * @cond DEPRECATED
  * |sub-command                 |payload                 |
  * |----------------------------|------------------------|
  * |@ref CMD_EC_STATUS_GET      |ec_status_get           |
  * @endcond
  *
  * |sub-command                 |payload                 |
  * |----------------------------|------------------------|
  * |@ref CMD_EC_STATUS_EX_GET   |ec_status_ex_get        |
  *
  */
 
 struct mrq_ec_response {
     union {
         /**
          * @cond DEPRECATED
          */
         struct cmd_ec_status_get_response ec_status_get;
         /** @endcond */
         struct cmd_ec_status_ex_get_response ec_status_ex_get;
     } BPMP_UNION_ANON;
 } BPMP_ABI_PACKED;
 
 /** @} */
 /** @endcond */
 
 /**
  * @addtogroup Error_Codes
  * Negative values for mrq_response::err generally indicate some
  * error. The ABI defines the following error codes. Negating these
  * defines is an exercise left to the user.
  * @{
  */
 
 /** @brief Operation not permitted */
 #define BPMP_EPERM  1
 /** @brief No such file or directory */
 #define BPMP_ENOENT 2
 /** @brief No MRQ handler */
 #define BPMP_ENOHANDLER 3
 /** @brief I/O error */
 #define BPMP_EIO    5
 /** @brief Bad sub-MRQ command */
 #define BPMP_EBADCMD    6
 /** @brief Resource temporarily unavailable */
 #define BPMP_EAGAIN 11
 /** @brief Not enough memory */
 #define BPMP_ENOMEM 12
 /** @brief Permission denied */
 #define BPMP_EACCES 13
 /** @brief Bad address */
 #define BPMP_EFAULT 14
 /** @brief Resource busy */
 #define BPMP_EBUSY  16
 /** @brief No such device */
 #define BPMP_ENODEV 19
 /** @brief Argument is a directory */
 #define BPMP_EISDIR 21
 /** @brief Invalid argument */
 #define BPMP_EINVAL 22
 /** @brief Timeout during operation */
 #define BPMP_ETIMEDOUT  23
 /** @brief Out of range */
 #define BPMP_ERANGE 34
 /** @brief Function not implemented */
 #define BPMP_ENOSYS 38
 /** @brief Invalid slot */
 #define BPMP_EBADSLT    57
 /** @brief Not supported */
 #define BPMP_ENOTSUP    134
 /** @brief No such device or address */
 #define BPMP_ENXIO  140
 
 /** @} */
 
 #if defined(BPMP_ABI_CHECKS)
 #include "bpmp_abi_checks.h"
 #endif
 
 #endif

This page was automatically generated by the 2.1.0 LXR engine. The LXR team