Quelle  bpmp-abi.h   Sprache: unbekannt

/* SPDX-License-Identifier: GPL-2.0-only */
/*
 * Copyright (c) 2014-2022, 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
 * Request an answer from the peer.
 * This should be set in mrq_request::flags for all requests targetted
 * at BPMP. For requests originating in BPMP, this flag is optional except
 * for messages targeting MCE, for which the field must be set.
 * When this flag is not set, the remote peer must not send a response
 * back.
 */
#define BPMP_MAIL_DO_ACK (1U << 0U)

/**
 * @ingroup MRQ_Format
 * Ring the sender's doorbell when responding. This should be set unless
 * the sender wants to poll the underlying communications layer directly.
 *
 * An optional direction that can be specified in mrq_request::flags.
 */
#define BPMP_MAIL_RING_DB (1U << 1U)

/**
 * @ingroup MRQ_Format
 * CRC present
 */
#define BPMP_MAIL_CRC_PRESENT (1U << 2U)

/**
 * @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 32bit word containing a number of fields as follows:
 *
 *  struct {
 *  uint8_t options:4;
 *  uint8_t xid:4;
 *  uint8_t payload_length;
 *  uint16_t crc16;
 *  };
 *
 * **options** directions to the receiver and indicates CRC presence.
 *
 * #BPMP_MAIL_DO_ACK and  #BPMP_MAIL_RING_DB see documentation of respective options.
 * #BPMP_MAIL_CRC_PRESENT is supported on T234 and later platforms. It indicates the
 * crc16, xid and length fields are present when set.
 * Some platform configurations, especially when targeted to applications requiring
 * functional safety, mandate this option being set or otherwise will respond with
 * -BPMP_EBADMSG and ignore the request.
 *
 * **xid** is a transaction ID.
 *
 * Only used when #BPMP_MAIL_CRC_PRESENT is set.
 *
 * **payload_length** of the message expressed in bytes without the size of this header.
 * See table below for minimum accepted payload lengths for each MRQ.
 * Note: For DMCE communication, this field expresses the length as a multiple of 4 bytes
 * rather than bytes.
 *
 * Only used when #BPMP_MAIL_CRC_PRESENT is set.
 *
 * | MRQ                  | CMD                                  | minimum payload length
 * | -------------------- | ------------------------------------ | ------------------------------------------ |
 * | MRQ_PING             |                                      | 4                                          |
 * | MRQ_THREADED_PING    |                                      | 4                                          |
 * | MRQ_RESET            | any                                  | 8                                          |
 * | MRQ_I2C              |                                      | 12 + cmd_i2c_xfer_request.data_size        |
 * | MRQ_CLK              | CMD_CLK_GET_RATE                     | 4                                          |
 * | MRQ_CLK              | CMD_CLK_SET_RATE                     | 16                                         |
 * | MRQ_CLK              | CMD_CLK_ROUND_RATE                   | 16                                         |
 * | MRQ_CLK              | CMD_CLK_GET_PARENT                   | 4                                          |
 * | MRQ_CLK              | CMD_CLK_SET_PARENT                   | 8                                          |
 * | MRQ_CLK              | CMD_CLK_ENABLE                       | 4                                          |
 * | MRQ_CLK              | CMD_CLK_DISABLE                      | 4                                          |
 * | MRQ_CLK              | CMD_CLK_IS_ENABLED                   | 4                                          |
 * | MRQ_CLK              | CMD_CLK_GET_ALL_INFO                 | 4                                          |
 * | MRQ_CLK              | CMD_CLK_GET_MAX_CLK_ID               | 4                                          |
 * | MRQ_CLK              | CMD_CLK_GET_FMAX_AT_VMIN             | 4                                          |
 * | MRQ_QUERY_ABI        |                                      | 4                                          |
 * | MRQ_PG               | CMD_PG_QUERY_ABI                     | 12                                         |
 * | MRQ_PG               | CMD_PG_SET_STATE                     | 12                                         |
 * | MRQ_PG               | CMD_PG_GET_STATE                     | 8                                          |
 * | MRQ_PG               | CMD_PG_GET_NAME                      | 8                                          |
 * | MRQ_PG               | CMD_PG_GET_MAX_ID                    | 8                                          |
 * | MRQ_THERMAL          | CMD_THERMAL_QUERY_ABI                | 8                                          |
 * | MRQ_THERMAL          | CMD_THERMAL_GET_TEMP                 | 8                                          |
 * | MRQ_THERMAL          | CMD_THERMAL_SET_TRIP                 | 20                                         |
 * | MRQ_THERMAL          | CMD_THERMAL_GET_NUM_ZONES            | 4                                          |
 * | MRQ_THERMAL          | CMD_THERMAL_GET_THERMTRIP            | 8                                          |
 * | MRQ_CPU_VHINT        |                                      | 8                                          |
 * | MRQ_ABI_RATCHET      |                                      | 2                                          |
 * | MRQ_EMC_DVFS_LATENCY |                                      | 8                                          |
 * | MRQ_EMC_DVFS_EMCHUB  |                                      | 8                                          |
 * | MRQ_EMC_DISP_RFL     |                                      | 4                                          |
 * | MRQ_BWMGR            | CMD_BWMGR_QUERY_ABI                  | 8                                          |
 * | MRQ_BWMGR            | CMD_BWMGR_CALC_RATE                  | 8 + 8 * bwmgr_rate_req.num_iso_clients     |
 * | MRQ_ISO_CLIENT       | CMD_ISO_CLIENT_QUERY_ABI             | 8                                          |
 * | MRQ_ISO_CLIENT       | CMD_ISO_CLIENT_CALCULATE_LA          | 16                                         |
 * | MRQ_ISO_CLIENT       | CMD_ISO_CLIENT_SET_LA                | 16                                         |
 * | MRQ_ISO_CLIENT       | CMD_ISO_CLIENT_GET_MAX_BW            | 8                                          |
 * | MRQ_CPU_NDIV_LIMITS  |                                      | 4                                          |
 * | MRQ_CPU_AUTO_CC3     |                                      | 4                                          |
 * | MRQ_RINGBUF_CONSOLE  | CMD_RINGBUF_CONSOLE_QUERY_ABI        | 8                                          |
 * | MRQ_RINGBUF_CONSOLE  | CMD_RINGBUF_CONSOLE_READ             | 5                                          |
 * | MRQ_RINGBUF_CONSOLE  | CMD_RINGBUF_CONSOLE_WRITE            | 5 + cmd_ringbuf_console_write_req.len      |
 * | MRQ_RINGBUF_CONSOLE  | CMD_RINGBUF_CONSOLE_GET_FIFO         | 4                                          |
 * | MRQ_STRAP            | STRAP_SET                            | 12                                         |
 * | MRQ_UPHY             | CMD_UPHY_PCIE_LANE_MARGIN_CONTROL    | 24                                         |
 * | MRQ_UPHY             | CMD_UPHY_PCIE_LANE_MARGIN_STATUS     | 4                                          |
 * | MRQ_UPHY             | CMD_UPHY_PCIE_EP_CONTROLLER_PLL_INIT | 5                                          |
 * | MRQ_UPHY             | CMD_UPHY_PCIE_CONTROLLER_STATE       | 6                                          |
 * | MRQ_UPHY             | CMD_UPHY_PCIE_EP_CONTROLLER_PLL_OFF  | 5                                          |
 * | MRQ_FMON             | CMD_FMON_GEAR_CLAMP                  | 16                                         |
 * | MRQ_FMON             | CMD_FMON_GEAR_FREE                   | 4                                          |
 * | MRQ_FMON             | CMD_FMON_GEAR_GET                    | 4                                          |
 * | MRQ_FMON             | CMD_FMON_FAULT_STS_GET               | 8                                          |
 * | MRQ_EC               | CMD_EC_STATUS_EX_GET                 | 12                                         |
 * | MRQ_QUERY_FW_TAG     |                                      | 0                                          |
 * | MRQ_DEBUG            | CMD_DEBUG_OPEN_RO                    | 4 + length of cmd_debug_fopen_request.name |
 * | MRQ_DEBUG            | CMD_DEBUG_OPEN_WO                    | 4 + length of cmd_debug_fopen_request.name |
 * | MRQ_DEBUG            | CMD_DEBUG_READ                       | 8                                          |
 * | MRQ_DEBUG            | CMD_DEBUG_WRITE                      | 12 + cmd_debug_fwrite_request.datalen      |
 * | MRQ_DEBUG            | CMD_DEBUG_CLOSE                      | 8                                          |
 * | MRQ_TELEMETRY        |                                      | 8                                          |
 * | MRQ_PWR_LIMIT        | CMD_PWR_LIMIT_QUERY_ABI              | 8                                          |
 * | MRQ_PWR_LIMIT        | CMD_PWR_LIMIT_SET                    | 20                                         |
 * | MRQ_PWR_LIMIT        | CMD_PWR_LIMIT_GET                    | 16                                         |
 * | MRQ_PWR_LIMIT        | CMD_PWR_LIMIT_CURR_CAP               | 8                                          |
 * | MRQ_GEARS            |                                      | 0                                          |
 * | MRQ_BWMGR_INT        | CMD_BWMGR_INT_QUERY_ABI              | 8                                          |
 * | MRQ_BWMGR_INT        | CMD_BWMGR_INT_CALC_AND_SET           | 16                                         |
 * | MRQ_BWMGR_INT        | CMD_BWMGR_INT_CAP_SET                | 8                                          |
 * | MRQ_OC_STATUS        |                                      | 0                                          |
 *
 * **crc16**
 *
 * CRC16 using polynomial x^16 + x^14 + x^12 + x^11 + x^8 + x^5 + x^4 + x^2 + 1
 * and initialization value 0x4657. The CRC is calculated over all bytes of the message
 * including this header. However the crc16 field is considered to be set to 0 when
 * calculating the CRC. Only used when #BPMP_MAIL_CRC_PRESENT is set. If
 * #BPMP_MAIL_CRC_PRESENT is set and this field does not match the CRC as
 * calculated by BPMP, -BPMP_EBADMSG will be returned and the request will
 * be ignored. See code snippet below on how to calculate the CRC.
 *
 * @code
 * uint16_t calc_crc_digest(uint16_t crc, uint8_t *data, size_t size)
 * {
 * for (size_t i = 0; i < size; i++) {
 * crc ^= data[i] << 8;
 * for (size_t j = 0; j < 8; j++) {
 * if ((crc & 0x8000) == 0x8000) {
 * crc = (crc << 1) ^ 0xAC9A;
 * } else {
 * crc = (crc << 1);
 * }
 * }
 * }
 * return crc;
 * }
 *
 * uint16_t calc_crc(uint8_t *data, size_t size)
 * {
 * return calc_crc_digest(0x4657, data, size);
 * }
 * @endcode
 */
 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 32bit word containing a number of fields as follows:
 *
 *  struct {
 *  uint8_t options:4;
 *  uint8_t xid:4;
 *  uint8_t payload_length;
 *  uint16_t crc16;
 *  };
 *
 * **options** indicates CRC presence.
 *
 * #BPMP_MAIL_CRC_PRESENT is supported on T234 and later platforms and
 * indicates the crc16 related fields are present when set.
 *
 * **xid** is the transaction ID as sent by the requestor.
 *
 * **length** of the message expressed in bytes without the size of this header.
 * Note: For DMCE communication, this field expresses the length as a multiple of 4 bytes
 * rather than bytes.
 *
 * **crc16**
 *
 * CRC16 using polynomial x^16 + x^14 + x^12 + x^11 + x^8 + x^5 + x^4 + x^2 + 1
 * and initialization value 0x4657. The CRC is calculated over all bytes of the message
 * including this header. However the crc16 field is considered to be set to 0 when
 * calculating the CRC. Only used when #BPMP_MAIL_CRC_PRESENT is set.
 */
 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_THREADED_PING 9U
#define MRQ_DEBUGFS  19U
#define MRQ_RESET  20U
#define MRQ_I2C   21U
#define MRQ_CLK   22U
#define MRQ_QUERY_ABI  23U
#define MRQ_THERMAL  27U
#define MRQ_CPU_VHINT  28U
#define MRQ_ABI_RATCHET  29U
#define MRQ_EMC_DVFS_LATENCY 31U
#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
#define MRQ_EMC_DVFS_EMCHUB 76U
#define MRQ_BWMGR  77U
#define MRQ_ISO_CLIENT  78U
#define MRQ_EMC_DISP_RFL 79U
#define MRQ_TELEMETRY  80U
#define MRQ_PWR_LIMIT  81U
#define MRQ_GEARS  82U
#define MRQ_BWMGR_INT  83U
#define MRQ_OC_STATUS  84U

/** @cond DEPRECATED */
#define MRQ_RESERVED_2  2U
#define MRQ_RESERVED_3  3U
#define MRQ_RESERVED_4  4U
#define MRQ_RESERVED_5    5U
#define MRQ_RESERVED_6  6U
#define MRQ_RESERVED_7  7U
#define MRQ_RESERVED_8  8U
#define MRQ_RESERVED_10  10U
#define MRQ_RESERVED_11  11U
#define MRQ_RESERVED_12  12U
#define MRQ_RESERVED_13  13U
#define MRQ_RESERVED_14  14U
#define MRQ_RESERVED_15  15U
#define MRQ_RESERVED_16  16U
#define MRQ_RESERVED_17  17U
#define MRQ_RESERVED_18  18U
#define MRQ_RESERVED_24  24U
#define MRQ_RESERVED_25  25U
#define MRQ_RESERVED_26  26U
#define MRQ_RESERVED_30  30U
#define MRQ_RESERVED_64  64U
#define MRQ_RESERVED_74  74U
/** @endcond DEPRECATED */

/** @} */

/**
 * @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  84U

/**
 * @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 OC_status OC status
 *   @defgroup Vhint CPU Voltage hint
 *   @defgroup EMC EMC
 *   @defgroup BWMGR BWMGR
 *   @defgroup ISO_CLIENT ISO_CLIENT
 *   @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 Telemetry Telemetry
 *   @defgroup Pwrlimit PWR_LIMIT
 *   @defgroup Gears Gears
 *   @defgroup BWMGR_INT Bandwidth Manager Integrated
 * @} MRQ_Payloads
 */

/**
 * @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;

/** @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_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)
/** @} Debugfs */

/**
 * @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 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;

/** @} Reset */

/**
 * @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 Tegra PWR_I2C bus identifier
 *
 * @cond (bpmp_t234 || bpmp_t239 || bpmp_t194)
 * Must be set to 5.
 * @endcond (bpmp_t234 || bpmp_t239 || bpmp_t194)
 * @cond bpmp_th500
 * Must be set to 1.
 * @endcond bpmp_th500
 *
 */
 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;

/** @} I2C */

/**
 * @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,
/** @cond DEPRECATED */
 CMD_CLK_PROPERTIES = 9,
 CMD_CLK_POSSIBLE_PARENTS = 10,
 CMD_CLK_NUM_POSSIBLE_PARENTS = 11,
 CMD_CLK_GET_POSSIBLE_PARENT = 12,
 CMD_CLK_RESET_REFCOUNTS = 13,
/** @endcond DEPRECATED */
 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)
/**
 * @brief Protection against rate and parent changes
 *
 * #MRQ_CLK command #CMD_CLK_SET_RATE or #MRQ_CLK command #CMD_CLK_SET_PARENT will return
 * -#BPMP_EACCES.
 */
#define BPMP_CLK_RATE_PARENT_CHANGE_DENIED (1U << 30)

/**
 * @brief Protection against state changes
 *
 * #MRQ_CLK command #CMD_CLK_ENABLE or #MRQ_CLK command #CMD_CLK_DISABLE will return
 * -#BPMP_EACCES.
 */
#define BPMP_CLK_STATE_CHANGE_DENIED (1U << 31)

#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 successfully
 * 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;

/** @cond DEPRECATED */
/** @private */
struct cmd_clk_properties_request {
 BPMP_ABI_EMPTY
} BPMP_ABI_PACKED;

/** @todo flags need to be spelled out here */
struct cmd_clk_properties_response {
 uint32_t flags;
} BPMP_ABI_PACKED;

/** @private */
struct cmd_clk_possible_parents_request {
 BPMP_ABI_EMPTY
} BPMP_ABI_PACKED;

struct cmd_clk_possible_parents_response {
 uint8_t num_parents;
 uint8_t reserved[3];
 uint32_t parent_id[MRQ_CLK_MAX_PARENTS];
} BPMP_ABI_PACKED;

/** @private */
struct cmd_clk_num_possible_parents_request {
 BPMP_ABI_EMPTY
} BPMP_ABI_PACKED;

struct cmd_clk_num_possible_parents_response {
 uint8_t num_parents;
} BPMP_ABI_PACKED;

struct cmd_clk_get_possible_parent_request {
 uint8_t parent_idx;
} BPMP_ABI_PACKED;

struct cmd_clk_get_possible_parent_response {
 uint32_t parent_id;
} BPMP_ABI_PACKED;
/** @endcond DEPRECATED */

/** @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    |-
 * |
 *
 */

/** @cond DEPRECATED
 *
 * Older versions of firmware also supported following sub-commands:
 * |CMD_CLK_PROPERTIES          |-                      |
 * |CMD_CLK_POSSIBLE_PARENTS    |-                      |
 * |CMD_CLK_NUM_POSSIBLE_PARENTS|-                      |
 * |CMD_CLK_GET_POSSIBLE_PARENT |clk_get_possible_parent|
 * |CMD_CLK_RESET_REFCOUNTS     |-                      |
 *
 * @endcond DEPRECATED */

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;
  /** @cond DEPRECATED */
  /** @private */
  struct cmd_clk_properties_request clk_properties;
  /** @private */
  struct cmd_clk_possible_parents_request clk_possible_parents;
  /** @private */
  struct cmd_clk_num_possible_parents_request clk_num_possible_parents;
  struct cmd_clk_get_possible_parent_request clk_get_possible_parent;
  /** @endcond DEPRECATED */
  /** @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    |
 *
 */

/** @cond DEPRECATED
 *
 * Older versions of firmware also supported following sub-commands:
 * |CMD_CLK_PROPERTIES          |clk_properties          |
 * |CMD_CLK_POSSIBLE_PARENTS    |clk_possible_parents    |
 * |CMD_CLK_NUM_POSSIBLE_PARENTS|clk_num_possible_parents|
 * |CMD_CLK_GET_POSSIBLE_PARENT |clk_get_possible_parents|
 * |CMD_CLK_RESET_REFCOUNTS     |-                       |
 *
 * @endcond DEPRECATED */

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;
  /** @cond DEPRECATED */
  struct cmd_clk_properties_response clk_properties;
  struct cmd_clk_possible_parents_response clk_possible_parents;
  struct cmd_clk_num_possible_parents_response clk_num_possible_parents;
  struct cmd_clk_get_possible_parent_response clk_get_possible_parent;
  /** @endcond DEPRECATED */
  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;

/** @} Clocks */

/**
 * @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
 * @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
 *
 * @cond (bpmp_t194 || bpmp_t186)
 * @note On T194 and earlier 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.
 * @endcond (bpmp_t194 || bpmp_t186)
 *
 * * 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;

/** @} Powergating */

/**
 * @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;

/** @} Thermal */

/**
 * @ingroup MRQ_Codes
 * @def MRQ_OC_STATUS
 * @brief Query over current status
 *
 * * Platforms: T234
 * @cond bpmp_t234
 * * Initiators: CCPLEX
 * * Targets: BPMP
 * * Request Payload: N/A
 * * Response Payload: @ref mrq_oc_status_response
 *
 * @addtogroup OC_status
 * @{
 */

#define OC_STATUS_MAX_SIZE 24U

/*
 * @brief Response to #MRQ_OC_STATUS
 *
 * throt_en: Value for each OC alarm where zero signifies throttle is
 *           disabled, and non-zero throttle is enabled.
 * event_cnt: Total number of OC events for each OC alarm.
 *
 * mrq_response::err is 0 if the operation was successful and
 * -#BPMP_ENODEV otherwise.
 */
struct mrq_oc_status_response {
 uint8_t throt_en[OC_STATUS_MAX_SIZE];
 uint32_t event_cnt[OC_STATUS_MAX_SIZE];
} BPMP_ABI_PACKED;

/** @} OC_status */
/** @endcond bpmp_t234 */

/**
 * @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;

/** @} Vhint */
/** @endcond bpmp_t186 */

/**
 * @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;
};

/** @} ABI_info */

/**
 * @ingroup MRQ_Codes
 * @def MRQ_EMC_DVFS_LATENCY
 * @brief Query frequency dependent EMC DVFS latency
 *
 * * Platforms: T186, T194, T234
 * * 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;

/** @} EMC */

/**
 * @ingroup MRQ_Codes
 * @def MRQ_EMC_DVFS_EMCHUB
 * @brief Query EMC HUB frequencies
 *
 * * Platforms: T234 onwards
 * @cond (bpmp_t234 || bpmp_t239 || bpmp_th500)
 * * Initiators: CCPLEX
 * * Targets: BPMP
 * * Request Payload: N/A
 * * Response Payload: @ref mrq_emc_dvfs_emchub_response
 * @addtogroup EMC
 * @{
 */

/**
 * @brief Used by @ref mrq_emc_dvfs_emchub_response
 */
struct emc_dvfs_emchub {
 /** @brief EMC DVFS node frequency in kHz */
 uint32_t freq;
 /** @brief EMC HUB frequency in kHz */
 uint32_t hub_freq;
} BPMP_ABI_PACKED;

#define EMC_DVFS_EMCHUB_MAX_SIZE EMC_DVFS_LATENCY_MAX_SIZE
/**
 * @brief Response to #MRQ_EMC_DVFS_EMCHUB
 */
struct mrq_emc_dvfs_emchub_response {
 /** @brief The number valid entries in #pairs */
 uint32_t num_pairs;
 /** @brief EMC DVFS node <frequency, hub frequency> information */
 struct emc_dvfs_emchub pairs[EMC_DVFS_EMCHUB_MAX_SIZE];
} BPMP_ABI_PACKED;

/** @} EMC */
/** @endcond (bpmp_t234 || bpmp_t239 || bpmp_th500) */

/**
 * @ingroup MRQ_Codes
 * @def MRQ_EMC_DISP_RFL
 * @brief Set EMC display RFL handshake mode of operations
 *
 * * Platforms: T234 onwards
 * @cond (bpmp_t234 || bpmp_t239 || bpmp_th500)
 * * Initiators: CCPLEX
 * * Targets: BPMP
 * * Request Payload: @ref mrq_emc_disp_rfl_request
 * * Response Payload: N/A
 *
 * @addtogroup EMC
 * @{
 */

enum mrq_emc_disp_rfl_mode {
 /** @brief EMC display RFL handshake disabled  */
 EMC_DISP_RFL_MODE_DISABLED = 0,
 /** @brief EMC display RFL handshake enabled  */
 EMC_DISP_RFL_MODE_ENABLED = 1,
};

/**
 * @ingroup EMC
--> --------------------

--> maximum size reached

--> --------------------