1 /* SPDX-License-Identifier: GPL-2.0-only */
2 /*
3  * Copyright (c) 2014-2020, NVIDIA CORPORATION.  All rights reserved.
4  */
5 
6 #ifndef ABI_BPMP_ABI_H
7 #define ABI_BPMP_ABI_H
8 
9 #if defined(LK) || defined(BPMP_ABI_HAVE_STDC)
10 #include <stddef.h>
11 #include <stdint.h>
12 #endif
13 
14 #ifndef BPMP_ABI_PACKED
15 #ifdef __ABI_PACKED
16 #define BPMP_ABI_PACKED __ABI_PACKED
17 #else
18 #define BPMP_ABI_PACKED __attribute__((packed))
19 #endif
20 #endif
21 
22 #ifdef NO_GCC_EXTENSIONS
23 #define BPMP_ABI_EMPTY char empty;
24 #define BPMP_ABI_EMPTY_ARRAY 1
25 #else
26 #define BPMP_ABI_EMPTY
27 #define BPMP_ABI_EMPTY_ARRAY 0
28 #endif
29 
30 #ifndef BPMP_UNION_ANON
31 #ifdef __UNION_ANON
32 #define BPMP_UNION_ANON __UNION_ANON
33 #else
34 #define BPMP_UNION_ANON
35 #endif
36 #endif
37 
38 /**
39  * @file
40  */
41 
42 /**
43  * @defgroup MRQ MRQ Messages
44  * @brief Messages sent to/from BPMP via IPC
45  * @{
46  *   @defgroup MRQ_Format Message Format
47  *   @defgroup MRQ_Codes Message Request (MRQ) Codes
48  *   @defgroup MRQ_Payloads Message Payloads
49  *   @defgroup Error_Codes Error Codes
50  * @}
51  */
52 
53 /**
54  * @addtogroup MRQ_Format
55  * @{
56  * The CPU requests the BPMP to perform a particular service by
57  * sending it an IVC frame containing a single MRQ message. An MRQ
58  * message consists of a @ref mrq_request followed by a payload whose
59  * format depends on mrq_request::mrq.
60  *
61  * The BPMP processes the data and replies with an IVC frame (on the
62  * same IVC channel) containing and MRQ response. An MRQ response
63  * consists of a @ref mrq_response followed by a payload whose format
64  * depends on the associated mrq_request::mrq.
65  *
66  * A well-defined subset of the MRQ messages that the CPU sends to the
67  * BPMP can lead to BPMP eventually sending an MRQ message to the
68  * CPU. For example, when the CPU uses an #MRQ_THERMAL message to set
69  * a thermal trip point, the BPMP may eventually send a single
70  * #MRQ_THERMAL message of its own to the CPU indicating that the trip
71  * point has been crossed.
72  * @}
73  */
74 
75 /**
76  * @ingroup MRQ_Format
77  * @brief Header for an MRQ message
78  *
79  * Provides the MRQ number for the MRQ message: #mrq. The remainder of
80  * the MRQ message is a payload (immediately following the
81  * mrq_request) whose format depends on mrq.
82  */
83 struct mrq_request {
84 	/** @brief MRQ number of the request */
85 	uint32_t mrq;
86 
87 	/**
88 	 * @brief Flags providing follow up directions to the receiver
89 	 *
90 	 * | Bit | Description                                |
91 	 * |-----|--------------------------------------------|
92 	 * | 1   | ring the sender's doorbell when responding |
93 	 * | 0   | should be 1                                |
94 	 */
95 	uint32_t flags;
96 } BPMP_ABI_PACKED;
97 
98 /**
99  * @ingroup MRQ_Format
100  * @brief Header for an MRQ response
101  *
102  *  Provides an error code for the associated MRQ message. The
103  *  remainder of the MRQ response is a payload (immediately following
104  *  the mrq_response) whose format depends on the associated
105  *  mrq_request::mrq
106  */
107 struct mrq_response {
108 	/** @brief Error code for the MRQ request itself */
109 	int32_t err;
110 	/** @brief Reserved for future use */
111 	uint32_t flags;
112 } BPMP_ABI_PACKED;
113 
114 /**
115  * @ingroup MRQ_Format
116  * Minimum needed size for an IPC message buffer
117  */
118 #define MSG_MIN_SZ	128U
119 /**
120  * @ingroup MRQ_Format
121  *  Minimum size guaranteed for data in an IPC message buffer
122  */
123 #define MSG_DATA_MIN_SZ	120U
124 
125 /**
126  * @ingroup MRQ_Codes
127  * @name Legal MRQ codes
128  * These are the legal values for mrq_request::mrq
129  * @{
130  */
131 
132 #define MRQ_PING		0U
133 #define MRQ_QUERY_TAG		1U
134 #define MRQ_MODULE_LOAD		4U
135 #define MRQ_MODULE_UNLOAD	5U
136 #define MRQ_TRACE_MODIFY	7U
137 #define MRQ_WRITE_TRACE		8U
138 #define MRQ_THREADED_PING	9U
139 #define MRQ_MODULE_MAIL		11U
140 #define MRQ_DEBUGFS		19U
141 #define MRQ_RESET		20U
142 #define MRQ_I2C			21U
143 #define MRQ_CLK			22U
144 #define MRQ_QUERY_ABI		23U
145 #define MRQ_PG_READ_STATE	25U
146 #define MRQ_PG_UPDATE_STATE	26U
147 #define MRQ_THERMAL		27U
148 #define MRQ_CPU_VHINT		28U
149 #define MRQ_ABI_RATCHET		29U
150 #define MRQ_EMC_DVFS_LATENCY	31U
151 #define MRQ_TRACE_ITER		64U
152 #define MRQ_RINGBUF_CONSOLE	65U
153 #define MRQ_PG			66U
154 #define MRQ_CPU_NDIV_LIMITS	67U
155 #define MRQ_STRAP               68U
156 #define MRQ_UPHY		69U
157 #define MRQ_CPU_AUTO_CC3	70U
158 #define MRQ_QUERY_FW_TAG	71U
159 #define MRQ_FMON		72U
160 #define MRQ_EC			73U
161 #define MRQ_DEBUG		75U
162 
163 /** @} */
164 
165 /**
166  * @ingroup MRQ_Codes
167  * @brief Maximum MRQ code to be sent by CPU software to
168  * BPMP. Subject to change in future
169  */
170 #define MAX_CPU_MRQ_ID		75U
171 
172 /**
173  * @addtogroup MRQ_Payloads
174  * @{
175  *   @defgroup Ping Ping
176  *   @defgroup Query_Tag Query Tag
177  *   @defgroup Module Loadable Modules
178  *   @defgroup Trace Trace
179  *   @defgroup Debugfs Debug File System
180  *   @defgroup Reset Reset
181  *   @defgroup I2C I2C
182  *   @defgroup Clocks Clocks
183  *   @defgroup ABI_info ABI Info
184  *   @defgroup Powergating Power Gating
185  *   @defgroup Thermal Thermal
186  *   @defgroup Vhint CPU Voltage hint
187  *   @defgroup EMC EMC
188  *   @defgroup CPU NDIV Limits
189  *   @defgroup RingbufConsole Ring Buffer Console
190  *   @defgroup Strap Straps
191  *   @defgroup UPHY UPHY
192  *   @defgroup CC3 Auto-CC3
193  *   @defgroup FMON FMON
194  *   @defgroup EC EC
195  *   @defgroup Fbvolt_status Fuse Burn Voltage Status
196  * @}
197  */
198 
199 /**
200  * @ingroup MRQ_Codes
201  * @def MRQ_PING
202  * @brief A simple ping
203  *
204  * * Platforms: All
205  * * Initiators: Any
206  * * Targets: Any
207  * * Request Payload: @ref mrq_ping_request
208  * * Response Payload: @ref mrq_ping_response
209  *
210  * @ingroup MRQ_Codes
211  * @def MRQ_THREADED_PING
212  * @brief A deeper ping
213  *
214  * * Platforms: All
215  * * Initiators: Any
216  * * Targets: BPMP
217  * * Request Payload: @ref mrq_ping_request
218  * * Response Payload: @ref mrq_ping_response
219  *
220  * Behavior is equivalent to a simple #MRQ_PING except that BPMP
221  * responds from a thread context (providing a slightly more robust
222  * sign of life).
223  *
224  */
225 
226 /**
227  * @ingroup Ping
228  * @brief Request with #MRQ_PING
229  *
230  * Used by the sender of an #MRQ_PING message to request a pong from
231  * recipient. The response from the recipient is computed based on
232  * #challenge.
233  */
234 struct mrq_ping_request {
235 /** @brief Arbitrarily chosen value */
236 	uint32_t challenge;
237 } BPMP_ABI_PACKED;
238 
239 /**
240  * @ingroup Ping
241  * @brief Response to #MRQ_PING
242  *
243  * Sent in response to an #MRQ_PING message. #reply should be the
244  * mrq_ping_request challenge left shifted by 1 with the carry-bit
245  * dropped.
246  *
247  */
248 struct mrq_ping_response {
249 	/** @brief Response to the MRQ_PING challege */
250 	uint32_t reply;
251 } BPMP_ABI_PACKED;
252 
253 /**
254  * @ingroup MRQ_Codes
255  * @def MRQ_QUERY_TAG
256  * @brief Query BPMP firmware's tag (i.e. unique identifer)
257  *
258  * @deprecated Use #MRQ_QUERY_FW_TAG instead.
259  *
260  * * Platforms: All
261  * * Initiators: CCPLEX
262  * * Targets: BPMP
263  * * Request Payload: @ref mrq_query_tag_request
264  * * Response Payload: N/A
265  *
266  */
267 
268 /**
269  * @ingroup Query_Tag
270  * @brief Request with #MRQ_QUERY_TAG
271  *
272  * @deprecated This structure will be removed in future version.
273  * Use MRQ_QUERY_FW_TAG instead.
274  */
275 struct mrq_query_tag_request {
276   /** @brief Base address to store the firmware tag */
277 	uint32_t addr;
278 } BPMP_ABI_PACKED;
279 
280 
281 /**
282  * @ingroup MRQ_Codes
283  * @def MRQ_QUERY_FW_TAG
284  * @brief Query BPMP firmware's tag (i.e. unique identifier)
285  *
286  * * Platforms: All
287  * * Initiators: Any
288  * * Targets: BPMP
289  * * Request Payload: N/A
290  * * Response Payload: @ref mrq_query_fw_tag_response
291  *
292  */
293 
294 /**
295  * @ingroup Query_Tag
296  * @brief Response to #MRQ_QUERY_FW_TAG
297  *
298  * Sent in response to #MRQ_QUERY_FW_TAG message. #tag contains the unique
299  * identifier for the version of firmware issuing the reply.
300  *
301  */
302 struct mrq_query_fw_tag_response {
303   /** @brief Array to store tag information */
304 	uint8_t tag[32];
305 } BPMP_ABI_PACKED;
306 
307 /**
308  * @ingroup MRQ_Codes
309  * @def MRQ_MODULE_LOAD
310  * @brief Dynamically load a BPMP code module
311  *
312  * * Platforms: T210, T210B01, T186
313  * @cond (bpmp_t210 || bpmp_t210b01 || bpmp_t186)
314  * * Initiators: CCPLEX
315  * * Targets: BPMP
316  * * Request Payload: @ref mrq_module_load_request
317  * * Response Payload: @ref mrq_module_load_response
318  *
319  * @note This MRQ is disabled on production systems
320  *
321  */
322 
323 /**
324  * @ingroup Module
325  * @brief Request with #MRQ_MODULE_LOAD
326  *
327  * Used by #MRQ_MODULE_LOAD calls to ask the recipient to dynamically
328  * load the code located at #phys_addr and having size #size
329  * bytes. #phys_addr is treated as a void pointer.
330  *
331  * The recipient copies the code from #phys_addr to locally allocated
332  * memory prior to responding to this message.
333  *
334  * @todo document the module header format
335  *
336  * The sender is responsible for ensuring that the code is mapped in
337  * the recipient's address map.
338  *
339  */
340 struct mrq_module_load_request {
341 	/** @brief Base address of the code to load */
342 	uint32_t phys_addr;
343 	/** @brief Size in bytes of code to load */
344 	uint32_t size;
345 } BPMP_ABI_PACKED;
346 
347 /**
348  * @ingroup Module
349  * @brief Response to #MRQ_MODULE_LOAD
350  *
351  * @todo document mrq_response::err
352  */
353 struct mrq_module_load_response {
354 	/** @brief Handle to the loaded module */
355 	uint32_t base;
356 } BPMP_ABI_PACKED;
357 /** @endcond*/
358 
359 /**
360  * @ingroup MRQ_Codes
361  * @def MRQ_MODULE_UNLOAD
362  * @brief Unload a previously loaded code module
363  *
364  * * Platforms: T210, T210B01, T186
365  * @cond (bpmp_t210 || bpmp_t210b01 || bpmp_t186)
366  * * Initiators: CCPLEX
367  * * Targets: BPMP
368  * * Request Payload: @ref mrq_module_unload_request
369  * * Response Payload: N/A
370  *
371  * @note This MRQ is disabled on production systems
372  */
373 
374 /**
375  * @ingroup Module
376  * @brief Request with #MRQ_MODULE_UNLOAD
377  *
378  * Used by #MRQ_MODULE_UNLOAD calls to request that a previously loaded
379  * module be unloaded.
380  */
381 struct mrq_module_unload_request {
382 	/** @brief Handle of the module to unload */
383 	uint32_t base;
384 } BPMP_ABI_PACKED;
385 /** @endcond*/
386 
387 /**
388  * @ingroup MRQ_Codes
389  * @def MRQ_TRACE_MODIFY
390  * @brief Modify the set of enabled trace events
391  *
392  * @deprecated
393  *
394  * * Platforms: All
395  * * Initiators: CCPLEX
396  * * Targets: BPMP
397  * * Request Payload: @ref mrq_trace_modify_request
398  * * Response Payload: @ref mrq_trace_modify_response
399  *
400  * @note This MRQ is disabled on production systems
401  */
402 
403 /**
404  * @ingroup Trace
405  * @brief Request with #MRQ_TRACE_MODIFY
406  *
407  * Used by %MRQ_TRACE_MODIFY calls to enable or disable specify trace
408  * events.  #set takes precedence for any bit set in both #set and
409  * #clr.
410  */
411 struct mrq_trace_modify_request {
412 	/** @brief Bit mask of trace events to disable */
413 	uint32_t clr;
414 	/** @brief Bit mask of trace events to enable */
415 	uint32_t set;
416 } BPMP_ABI_PACKED;
417 
418 /**
419  * @ingroup Trace
420  * @brief Response to #MRQ_TRACE_MODIFY
421  *
422  * Sent in repsonse to an #MRQ_TRACE_MODIFY message. #mask reflects the
423  * state of which events are enabled after the recipient acted on the
424  * message.
425  *
426  */
427 struct mrq_trace_modify_response {
428 	/** @brief Bit mask of trace event enable states */
429 	uint32_t mask;
430 } BPMP_ABI_PACKED;
431 
432 /**
433  * @ingroup MRQ_Codes
434  * @def MRQ_WRITE_TRACE
435  * @brief Write trace data to a buffer
436  *
437  * @deprecated
438  *
439  * * Platforms: All
440  * * Initiators: CCPLEX
441  * * Targets: BPMP
442  * * Request Payload: @ref mrq_write_trace_request
443  * * Response Payload: @ref mrq_write_trace_response
444  *
445  * mrq_response::err depends on the @ref mrq_write_trace_request field
446  * values. err is -#BPMP_EINVAL if size is zero or area is NULL or
447  * area is in an illegal range. A positive value for err indicates the
448  * number of bytes written to area.
449  *
450  * @note This MRQ is disabled on production systems
451  */
452 
453 /**
454  * @ingroup Trace
455  * @brief Request with #MRQ_WRITE_TRACE
456  *
457  * Used by MRQ_WRITE_TRACE calls to ask the recipient to copy trace
458  * data from the recipient's local buffer to the output buffer. #area
459  * is treated as a byte-aligned pointer in the recipient's address
460  * space.
461  *
462  * The sender is responsible for ensuring that the output
463  * buffer is mapped in the recipient's address map. The recipient is
464  * responsible for protecting its own code and data from accidental
465  * overwrites.
466  */
467 struct mrq_write_trace_request {
468 	/** @brief Base address of output buffer */
469 	uint32_t area;
470 	/** @brief Size in bytes of the output buffer */
471 	uint32_t size;
472 } BPMP_ABI_PACKED;
473 
474 /**
475  * @ingroup Trace
476  * @brief Response to #MRQ_WRITE_TRACE
477  *
478  * Once this response is sent, the respondent will not access the
479  * output buffer further.
480  */
481 struct mrq_write_trace_response {
482 	/**
483 	 * @brief Flag whether more data remains in local buffer
484 	 *
485 	 * Value is 1 if the entire local trace buffer has been
486 	 * drained to the outputbuffer. Value is 0 otherwise.
487 	 */
488 	uint32_t eof;
489 } BPMP_ABI_PACKED;
490 
491 /** @private */
492 struct mrq_threaded_ping_request {
493 	uint32_t challenge;
494 } BPMP_ABI_PACKED;
495 
496 /** @private */
497 struct mrq_threaded_ping_response {
498 	uint32_t reply;
499 } BPMP_ABI_PACKED;
500 
501 /**
502  * @ingroup MRQ_Codes
503  * @def MRQ_MODULE_MAIL
504  * @brief Send a message to a loadable module
505  *
506  * * Platforms: T210, T210B01, T186
507  * @cond (bpmp_t210 || bpmp_t210b01 || bpmp_t186)
508  * * Initiators: Any
509  * * Targets: BPMP
510  * * Request Payload: @ref mrq_module_mail_request
511  * * Response Payload: @ref mrq_module_mail_response
512  *
513  * @note This MRQ is disabled on production systems
514  */
515 
516 /**
517  * @ingroup Module
518  * @brief Request with #MRQ_MODULE_MAIL
519  */
520 struct mrq_module_mail_request {
521 	/** @brief Handle to the previously loaded module */
522 	uint32_t base;
523 	/** @brief Module-specific mail payload
524 	 *
525 	 * The length of data[ ] is unknown to the BPMP core firmware
526 	 * but it is limited to the size of an IPC message.
527 	 */
528 	uint8_t data[BPMP_ABI_EMPTY_ARRAY];
529 } BPMP_ABI_PACKED;
530 
531 /**
532  * @ingroup Module
533  * @brief Response to #MRQ_MODULE_MAIL
534  */
535 struct mrq_module_mail_response {
536 	/** @brief Module-specific mail payload
537 	 *
538 	 * The length of data[ ] is unknown to the BPMP core firmware
539 	 * but it is limited to the size of an IPC message.
540 	 */
541 	uint8_t data[BPMP_ABI_EMPTY_ARRAY];
542 } BPMP_ABI_PACKED;
543 /** @endcond */
544 
545 /**
546  * @ingroup MRQ_Codes
547  * @def MRQ_DEBUGFS
548  * @brief Interact with BPMP's debugfs file nodes
549  *
550  * @deprecated use MRQ_DEBUG instead.
551  *
552  * * Platforms: T186, T194
553  * * Initiators: Any
554  * * Targets: BPMP
555  * * Request Payload: @ref mrq_debugfs_request
556  * * Response Payload: @ref mrq_debugfs_response
557  */
558 
559 /**
560  * @addtogroup Debugfs
561  * @{
562  *
563  * The BPMP firmware implements a pseudo-filesystem called
564  * debugfs. Any driver within the firmware may register with debugfs
565  * to expose an arbitrary set of "files" in the filesystem. When
566  * software on the CPU writes to a debugfs file, debugfs passes the
567  * written data to a callback provided by the driver. When software on
568  * the CPU reads a debugfs file, debugfs queries the driver for the
569  * data to return to the CPU. The intention of the debugfs filesystem
570  * is to provide information useful for debugging the system at
571  * runtime.
572  *
573  * @note The files exposed via debugfs are not part of the
574  * BPMP firmware's ABI. debugfs files may be added or removed in any
575  * given version of the firmware. Typically the semantics of a debugfs
576  * file are consistent from version to version but even that is not
577  * guaranteed.
578  *
579  * @}
580  */
581 
582 /** @ingroup Debugfs */
583 enum mrq_debugfs_commands {
584 	/** @brief Perform read */
585 	CMD_DEBUGFS_READ = 1,
586 	/** @brief Perform write */
587 	CMD_DEBUGFS_WRITE = 2,
588 	/** @brief Perform dumping directory */
589 	CMD_DEBUGFS_DUMPDIR = 3,
590 	/** @brief Not a command */
591 	CMD_DEBUGFS_MAX
592 };
593 
594 /**
595  * @ingroup Debugfs
596  * @brief Parameters for CMD_DEBUGFS_READ/WRITE command
597  */
598 struct cmd_debugfs_fileop_request {
599 	/** @brief Physical address pointing at filename */
600 	uint32_t fnameaddr;
601 	/** @brief Length in bytes of filename buffer */
602 	uint32_t fnamelen;
603 	/** @brief Physical address pointing to data buffer */
604 	uint32_t dataaddr;
605 	/** @brief Length in bytes of data buffer */
606 	uint32_t datalen;
607 } BPMP_ABI_PACKED;
608 
609 /**
610  * @ingroup Debugfs
611  * @brief Parameters for CMD_DEBUGFS_READ/WRITE command
612  */
613 struct cmd_debugfs_dumpdir_request {
614 	/** @brief Physical address pointing to data buffer */
615 	uint32_t dataaddr;
616 	/** @brief Length in bytes of data buffer */
617 	uint32_t datalen;
618 } BPMP_ABI_PACKED;
619 
620 /**
621  * @ingroup Debugfs
622  * @brief Response data for CMD_DEBUGFS_READ/WRITE command
623  */
624 struct cmd_debugfs_fileop_response {
625 	/** @brief Always 0 */
626 	uint32_t reserved;
627 	/** @brief Number of bytes read from or written to data buffer */
628 	uint32_t nbytes;
629 } BPMP_ABI_PACKED;
630 
631 /**
632  * @ingroup Debugfs
633  * @brief Response data for CMD_DEBUGFS_DUMPDIR command
634  */
635 struct cmd_debugfs_dumpdir_response {
636 	/** @brief Always 0 */
637 	uint32_t reserved;
638 	/** @brief Number of bytes read from or written to data buffer */
639 	uint32_t nbytes;
640 } BPMP_ABI_PACKED;
641 
642 /**
643  * @ingroup Debugfs
644  * @brief Request with #MRQ_DEBUGFS.
645  *
646  * The sender of an MRQ_DEBUGFS message uses #cmd to specify a debugfs
647  * command to execute. Legal commands are the values of @ref
648  * mrq_debugfs_commands. Each command requires a specific additional
649  * payload of data.
650  *
651  * |command            |payload|
652  * |-------------------|-------|
653  * |CMD_DEBUGFS_READ   |fop    |
654  * |CMD_DEBUGFS_WRITE  |fop    |
655  * |CMD_DEBUGFS_DUMPDIR|dumpdir|
656  */
657 struct mrq_debugfs_request {
658 	/** @brief Sub-command (@ref mrq_debugfs_commands) */
659 	uint32_t cmd;
660 	union {
661 		struct cmd_debugfs_fileop_request fop;
662 		struct cmd_debugfs_dumpdir_request dumpdir;
663 	} BPMP_UNION_ANON;
664 } BPMP_ABI_PACKED;
665 
666 /**
667  * @ingroup Debugfs
668  */
669 struct mrq_debugfs_response {
670 	/** @brief Always 0 */
671 	int32_t reserved;
672 	union {
673 		/** @brief Response data for CMD_DEBUGFS_READ OR
674 		 * CMD_DEBUGFS_WRITE command
675 		 */
676 		struct cmd_debugfs_fileop_response fop;
677 		/** @brief Response data for CMD_DEBUGFS_DUMPDIR command */
678 		struct cmd_debugfs_dumpdir_response dumpdir;
679 	} BPMP_UNION_ANON;
680 } BPMP_ABI_PACKED;
681 
682 /**
683  * @addtogroup Debugfs
684  * @{
685  */
686 #define DEBUGFS_S_ISDIR	(1 << 9)
687 #define DEBUGFS_S_IRUSR	(1 << 8)
688 #define DEBUGFS_S_IWUSR	(1 << 7)
689 /** @} */
690 
691 /**
692  * @ingroup MRQ_Codes
693  * @def MRQ_DEBUG
694  * @brief Interact with BPMP's debugfs file nodes. Use message payload
695  * for exchanging data. This is functionally equivalent to
696  * @ref MRQ_DEBUGFS. But the way in which data is exchanged is different.
697  * When software running on CPU tries to read a debugfs file,
698  * the file path and read data will be stored in message payload.
699  * Since the message payload size is limited, a debugfs file
700  * transaction might require multiple frames of data exchanged
701  * between BPMP and CPU until the transaction completes.
702  *
703  * * Platforms: T194
704  * * Initiators: Any
705  * * Targets: BPMP
706  * * Request Payload: @ref mrq_debug_request
707  * * Response Payload: @ref mrq_debug_response
708  */
709 
710 /** @ingroup Debugfs */
711 enum mrq_debug_commands {
712 	/** @brief Open required file for read operation */
713 	CMD_DEBUG_OPEN_RO = 0,
714 	/** @brief Open required file for write operation */
715 	CMD_DEBUG_OPEN_WO = 1,
716 	/** @brief Perform read */
717 	CMD_DEBUG_READ = 2,
718 	/** @brief Perform write */
719 	CMD_DEBUG_WRITE = 3,
720 	/** @brief Close file */
721 	CMD_DEBUG_CLOSE = 4,
722 	/** @brief Not a command */
723 	CMD_DEBUG_MAX
724 };
725 
726 /**
727  * @ingroup Debugfs
728  * @brief Maximum number of files that can be open at a given time
729  */
730 #define DEBUG_MAX_OPEN_FILES	1
731 
732 /**
733  * @ingroup Debugfs
734  * @brief Maximum size of null-terminated file name string in bytes.
735  * Value is derived from memory available in message payload while
736  * using @ref cmd_debug_fopen_request
737  * Value 4 corresponds to size of @ref mrq_debug_commands
738  * in @ref mrq_debug_request.
739  * 120 - 4 dbg_cmd(32bit)  = 116
740  */
741 #define DEBUG_FNAME_MAX_SZ	(MSG_DATA_MIN_SZ - 4)
742 
743 /**
744  * @ingroup Debugfs
745  * @brief Parameters for CMD_DEBUG_OPEN command
746  */
747 struct cmd_debug_fopen_request {
748 	/** @brief File name - Null-terminated string with maximum
749 	 * length @ref DEBUG_FNAME_MAX_SZ
750 	 */
751 	char name[DEBUG_FNAME_MAX_SZ];
752 } BPMP_ABI_PACKED;
753 
754 /**
755  * @ingroup Debugfs
756  * @brief Response data for CMD_DEBUG_OPEN_RO/WO command
757  */
758 struct cmd_debug_fopen_response {
759 	/** @brief Identifier for file access */
760 	uint32_t fd;
761 	/** @brief Data length. File data size for READ command.
762 	 * Maximum allowed length for WRITE command
763 	 */
764 	uint32_t datalen;
765 } BPMP_ABI_PACKED;
766 
767 /**
768  * @ingroup Debugfs
769  * @brief Parameters for CMD_DEBUG_READ command
770  */
771 struct cmd_debug_fread_request {
772 	/** @brief File access identifier received in response
773 	 * to CMD_DEBUG_OPEN_RO request
774 	 */
775 	uint32_t fd;
776 } BPMP_ABI_PACKED;
777 
778 /**
779  * @ingroup Debugfs
780  * @brief Maximum size of read data in bytes.
781  * Value is derived from memory available in message payload while
782  * using @ref cmd_debug_fread_response.
783  */
784 #define DEBUG_READ_MAX_SZ	(MSG_DATA_MIN_SZ - 4)
785 
786 /**
787  * @ingroup Debugfs
788  * @brief Response data for CMD_DEBUG_READ command
789  */
790 struct cmd_debug_fread_response {
791 	/** @brief Size of data provided in this response in bytes */
792 	uint32_t readlen;
793 	/** @brief File data from seek position */
794 	char data[DEBUG_READ_MAX_SZ];
795 } BPMP_ABI_PACKED;
796 
797 /**
798  * @ingroup Debugfs
799  * @brief Maximum size of write data in bytes.
800  * Value is derived from memory available in message payload while
801  * using @ref cmd_debug_fwrite_request.
802  */
803 #define DEBUG_WRITE_MAX_SZ	(MSG_DATA_MIN_SZ - 12)
804 
805 /**
806  * @ingroup Debugfs
807  * @brief Parameters for CMD_DEBUG_WRITE command
808  */
809 struct cmd_debug_fwrite_request {
810 	/** @brief File access identifier received in response
811 	 * to CMD_DEBUG_OPEN_RO request
812 	 */
813 	uint32_t fd;
814 	/** @brief Size of write data in bytes */
815 	uint32_t datalen;
816 	/** @brief Data to be written */
817 	char data[DEBUG_WRITE_MAX_SZ];
818 } BPMP_ABI_PACKED;
819 
820 /**
821  * @ingroup Debugfs
822  * @brief Parameters for CMD_DEBUG_CLOSE command
823  */
824 struct cmd_debug_fclose_request {
825 	/** @brief File access identifier received in response
826 	 * to CMD_DEBUG_OPEN_RO request
827 	 */
828 	uint32_t fd;
829 } BPMP_ABI_PACKED;
830 
831 /**
832  * @ingroup Debugfs
833  * @brief Request with #MRQ_DEBUG.
834  *
835  * The sender of an MRQ_DEBUG message uses #cmd to specify a debugfs
836  * command to execute. Legal commands are the values of @ref
837  * mrq_debug_commands. Each command requires a specific additional
838  * payload of data.
839  *
840  * |command            |payload|
841  * |-------------------|-------|
842  * |CMD_DEBUG_OPEN_RO  |fop    |
843  * |CMD_DEBUG_OPEN_WO  |fop    |
844  * |CMD_DEBUG_READ     |frd    |
845  * |CMD_DEBUG_WRITE    |fwr    |
846  * |CMD_DEBUG_CLOSE    |fcl    |
847  */
848 struct mrq_debug_request {
849 	/** @brief Sub-command (@ref mrq_debug_commands) */
850 	uint32_t cmd;
851 	union {
852 		/** @brief Request payload for CMD_DEBUG_OPEN_RO/WO command */
853 		struct cmd_debug_fopen_request fop;
854 		/** @brief Request payload for CMD_DEBUG_READ command */
855 		struct cmd_debug_fread_request frd;
856 		/** @brief Request payload for CMD_DEBUG_WRITE command */
857 		struct cmd_debug_fwrite_request fwr;
858 		/** @brief Request payload for CMD_DEBUG_CLOSE command */
859 		struct cmd_debug_fclose_request fcl;
860 	} BPMP_UNION_ANON;
861 } BPMP_ABI_PACKED;
862 
863 /**
864  * @ingroup Debugfs
865  */
866 struct mrq_debug_response {
867 	union {
868 		/** @brief Response data for CMD_DEBUG_OPEN_RO/WO command */
869 		struct cmd_debug_fopen_response fop;
870 		/** @brief Response data for CMD_DEBUG_READ command */
871 		struct cmd_debug_fread_response frd;
872 	} BPMP_UNION_ANON;
873 } BPMP_ABI_PACKED;
874 
875 /**
876  * @ingroup MRQ_Codes
877  * @def MRQ_RESET
878  * @brief Reset an IP block
879  *
880  * * Platforms: T186, T194
881  * * Initiators: Any
882  * * Targets: BPMP
883  * * Request Payload: @ref mrq_reset_request
884  * * Response Payload: @ref mrq_reset_response
885  *
886  * @addtogroup Reset
887  * @{
888  */
889 
890 enum mrq_reset_commands {
891 	/**
892 	 * @brief Assert module reset
893 	 *
894 	 * mrq_response::err is 0 if the operation was successful, or @n
895 	 * -#BPMP_EINVAL if mrq_reset_request::reset_id is invalid @n
896 	 * -#BPMP_EACCES if mrq master is not an owner of target domain reset @n
897 	 * -#BPMP_ENOTSUP if target domain h/w state does not allow reset
898 	 */
899 	CMD_RESET_ASSERT = 1,
900 	/**
901 	 * @brief Deassert module reset
902 	 *
903 	 * mrq_response::err is 0 if the operation was successful, or @n
904 	 * -#BPMP_EINVAL if mrq_reset_request::reset_id is invalid @n
905 	 * -#BPMP_EACCES if mrq master is not an owner of target domain reset @n
906 	 * -#BPMP_ENOTSUP if target domain h/w state does not allow reset
907 	 */
908 	CMD_RESET_DEASSERT = 2,
909 	/**
910 	 * @brief Assert and deassert the module reset
911 	 *
912 	 * mrq_response::err is 0 if the operation was successful, or @n
913 	 * -#BPMP_EINVAL if mrq_reset_request::reset_id is invalid @n
914 	 * -#BPMP_EACCES if mrq master is not an owner of target domain reset @n
915 	 * -#BPMP_ENOTSUP if target domain h/w state does not allow reset
916 	 */
917 	CMD_RESET_MODULE = 3,
918 	/**
919 	 * @brief Get the highest reset ID
920 	 *
921 	 * mrq_response::err is 0 if the operation was successful, or @n
922 	 * -#BPMP_ENODEV if no reset domains are supported (number of IDs is 0)
923 	 */
924 	CMD_RESET_GET_MAX_ID = 4,
925 
926 	/** @brief Not part of ABI and subject to change */
927 	CMD_RESET_MAX,
928 };
929 
930 /**
931  * @brief Request with MRQ_RESET
932  *
933  * Used by the sender of an #MRQ_RESET message to request BPMP to
934  * assert or deassert a given reset line.
935  */
936 struct mrq_reset_request {
937 	/** @brief Reset action to perform (@ref mrq_reset_commands) */
938 	uint32_t cmd;
939 	/** @brief Id of the reset to affected */
940 	uint32_t reset_id;
941 } BPMP_ABI_PACKED;
942 
943 /**
944  * @brief Response for MRQ_RESET sub-command CMD_RESET_GET_MAX_ID. When
945  * this sub-command is not supported, firmware will return -BPMP_EBADCMD
946  * in mrq_response::err.
947  */
948 struct cmd_reset_get_max_id_response {
949 	/** @brief Max reset id */
950 	uint32_t max_id;
951 } BPMP_ABI_PACKED;
952 
953 /**
954  * @brief Response with MRQ_RESET
955  *
956  * Each sub-command supported by @ref mrq_reset_request may return
957  * sub-command-specific data. Some do and some do not as indicated
958  * in the following table
959  *
960  * | sub-command          | payload          |
961  * |----------------------|------------------|
962  * | CMD_RESET_ASSERT     | -                |
963  * | CMD_RESET_DEASSERT   | -                |
964  * | CMD_RESET_MODULE     | -                |
965  * | CMD_RESET_GET_MAX_ID | reset_get_max_id |
966  */
967 struct mrq_reset_response {
968 	union {
969 		struct cmd_reset_get_max_id_response reset_get_max_id;
970 	} BPMP_UNION_ANON;
971 } BPMP_ABI_PACKED;
972 
973 /** @} */
974 
975 /**
976  * @ingroup MRQ_Codes
977  * @def MRQ_I2C
978  * @brief Issue an i2c transaction
979  *
980  * * Platforms: T186, T194
981  * * Initiators: Any
982  * * Targets: BPMP
983  * * Request Payload: @ref mrq_i2c_request
984  * * Response Payload: @ref mrq_i2c_response
985  *
986  * @addtogroup I2C
987  * @{
988  */
989 #define TEGRA_I2C_IPC_MAX_IN_BUF_SIZE	(MSG_DATA_MIN_SZ - 12U)
990 #define TEGRA_I2C_IPC_MAX_OUT_BUF_SIZE	(MSG_DATA_MIN_SZ - 4U)
991 
992 #define SERIALI2C_TEN           0x0010U
993 #define SERIALI2C_RD            0x0001U
994 #define SERIALI2C_STOP          0x8000U
995 #define SERIALI2C_NOSTART       0x4000U
996 #define SERIALI2C_REV_DIR_ADDR  0x2000U
997 #define SERIALI2C_IGNORE_NAK    0x1000U
998 #define SERIALI2C_NO_RD_ACK     0x0800U
999 #define SERIALI2C_RECV_LEN      0x0400U
1000 
1001 enum {
1002 	CMD_I2C_XFER = 1
1003 };
1004 
1005 /**
1006  * @brief Serializable i2c request
1007  *
1008  * Instances of this structure are packed (little-endian) into
1009  * cmd_i2c_xfer_request::data_buf. Each instance represents a single
1010  * transaction (or a portion of a transaction with repeated starts) on
1011  * an i2c bus.
1012  *
1013  * Because these structures are packed, some instances are likely to
1014  * be misaligned. Additionally because #data is variable length, it is
1015  * not possible to iterate through a serialized list of these
1016  * structures without inspecting #len in each instance.  It may be
1017  * easier to serialize or deserialize cmd_i2c_xfer_request::data_buf
1018  * manually rather than using this structure definition.
1019 */
1020 struct serial_i2c_request {
1021 	/** @brief I2C slave address */
1022 	uint16_t addr;
1023 	/** @brief Bitmask of SERIALI2C_ flags */
1024 	uint16_t flags;
1025 	/** @brief Length of I2C transaction in bytes */
1026 	uint16_t len;
1027 	/** @brief For write transactions only, #len bytes of data */
1028 	uint8_t data[];
1029 } BPMP_ABI_PACKED;
1030 
1031 /**
1032  * @brief Trigger one or more i2c transactions
1033  */
1034 struct cmd_i2c_xfer_request {
1035 	/** @brief Valid bus number from @ref bpmp_i2c_ids*/
1036 	uint32_t bus_id;
1037 
1038 	/** @brief Count of valid bytes in #data_buf*/
1039 	uint32_t data_size;
1040 
1041 	/** @brief Serialized packed instances of @ref serial_i2c_request*/
1042 	uint8_t data_buf[TEGRA_I2C_IPC_MAX_IN_BUF_SIZE];
1043 } BPMP_ABI_PACKED;
1044 
1045 /**
1046  * @brief Container for data read from the i2c bus
1047  *
1048  * Processing an cmd_i2c_xfer_request::data_buf causes BPMP to execute
1049  * zero or more I2C reads. The data read from the bus is serialized
1050  * into #data_buf.
1051  */
1052 struct cmd_i2c_xfer_response {
1053 	/** @brief Count of valid bytes in #data_buf*/
1054 	uint32_t data_size;
1055 	/** @brief I2c read data */
1056 	uint8_t data_buf[TEGRA_I2C_IPC_MAX_OUT_BUF_SIZE];
1057 } BPMP_ABI_PACKED;
1058 
1059 /**
1060  * @brief Request with #MRQ_I2C
1061  */
1062 struct mrq_i2c_request {
1063 	/** @brief Always CMD_I2C_XFER (i.e. 1) */
1064 	uint32_t cmd;
1065 	/** @brief Parameters of the transfer request */
1066 	struct cmd_i2c_xfer_request xfer;
1067 } BPMP_ABI_PACKED;
1068 
1069 /**
1070  * @brief Response to #MRQ_I2C
1071  *
1072  * mrq_response:err is
1073  *  0: Success
1074  *  -#BPMP_EBADCMD: if mrq_i2c_request::cmd is other than 1
1075  *  -#BPMP_EINVAL: if cmd_i2c_xfer_request does not contain correctly formatted request
1076  *  -#BPMP_ENODEV: if cmd_i2c_xfer_request::bus_id is not supported by BPMP
1077  *  -#BPMP_EACCES: if i2c transaction is not allowed due to firewall rules
1078  *  -#BPMP_ETIMEDOUT: if i2c transaction times out
1079  *  -#BPMP_ENXIO: if i2c slave device does not reply with ACK to the transaction
1080  *  -#BPMP_EAGAIN: if ARB_LOST condition is detected by the i2c controller
1081  *  -#BPMP_EIO: any other i2c controller error code than NO_ACK or ARB_LOST
1082  */
1083 struct mrq_i2c_response {
1084 	struct cmd_i2c_xfer_response xfer;
1085 } BPMP_ABI_PACKED;
1086 
1087 /** @} */
1088 
1089 /**
1090  * @ingroup MRQ_Codes
1091  * @def MRQ_CLK
1092  * @brief Perform a clock operation
1093  *
1094  * * Platforms: T186, T194
1095  * * Initiators: Any
1096  * * Targets: BPMP
1097  * * Request Payload: @ref mrq_clk_request
1098  * * Response Payload: @ref mrq_clk_response
1099  *
1100  * @addtogroup Clocks
1101  * @{
1102  */
1103 enum {
1104 	CMD_CLK_GET_RATE = 1,
1105 	CMD_CLK_SET_RATE = 2,
1106 	CMD_CLK_ROUND_RATE = 3,
1107 	CMD_CLK_GET_PARENT = 4,
1108 	CMD_CLK_SET_PARENT = 5,
1109 	CMD_CLK_IS_ENABLED = 6,
1110 	CMD_CLK_ENABLE = 7,
1111 	CMD_CLK_DISABLE = 8,
1112 	CMD_CLK_GET_ALL_INFO = 14,
1113 	CMD_CLK_GET_MAX_CLK_ID = 15,
1114 	CMD_CLK_GET_FMAX_AT_VMIN = 16,
1115 	CMD_CLK_MAX,
1116 };
1117 
1118 #define BPMP_CLK_HAS_MUX	(1U << 0U)
1119 #define BPMP_CLK_HAS_SET_RATE	(1U << 1U)
1120 #define BPMP_CLK_IS_ROOT	(1U << 2U)
1121 #define BPMP_CLK_IS_VAR_ROOT	(1U << 3U)
1122 
1123 #define MRQ_CLK_NAME_MAXLEN	40U
1124 #define MRQ_CLK_MAX_PARENTS	16U
1125 
1126 /** @private */
1127 struct cmd_clk_get_rate_request {
1128 	BPMP_ABI_EMPTY
1129 } BPMP_ABI_PACKED;
1130 
1131 struct cmd_clk_get_rate_response {
1132 	int64_t rate;
1133 } BPMP_ABI_PACKED;
1134 
1135 struct cmd_clk_set_rate_request {
1136 	int32_t unused;
1137 	int64_t rate;
1138 } BPMP_ABI_PACKED;
1139 
1140 struct cmd_clk_set_rate_response {
1141 	int64_t rate;
1142 } BPMP_ABI_PACKED;
1143 
1144 struct cmd_clk_round_rate_request {
1145 	int32_t unused;
1146 	int64_t rate;
1147 } BPMP_ABI_PACKED;
1148 
1149 struct cmd_clk_round_rate_response {
1150 	int64_t rate;
1151 } BPMP_ABI_PACKED;
1152 
1153 /** @private */
1154 struct cmd_clk_get_parent_request {
1155 	BPMP_ABI_EMPTY
1156 } BPMP_ABI_PACKED;
1157 
1158 struct cmd_clk_get_parent_response {
1159 	uint32_t parent_id;
1160 } BPMP_ABI_PACKED;
1161 
1162 struct cmd_clk_set_parent_request {
1163 	uint32_t parent_id;
1164 } BPMP_ABI_PACKED;
1165 
1166 struct cmd_clk_set_parent_response {
1167 	uint32_t parent_id;
1168 } BPMP_ABI_PACKED;
1169 
1170 /** @private */
1171 struct cmd_clk_is_enabled_request {
1172 	BPMP_ABI_EMPTY
1173 } BPMP_ABI_PACKED;
1174 
1175 /**
1176  * @brief Response data to #MRQ_CLK sub-command CMD_CLK_IS_ENABLED
1177  */
1178 struct cmd_clk_is_enabled_response {
1179 	/**
1180 	 * @brief The state of the clock that has been succesfully
1181 	 * requested with CMD_CLK_ENABLE or CMD_CLK_DISABLE by the
1182 	 * master invoking the command earlier.
1183 	 *
1184 	 * The state may not reflect the physical state of the clock
1185 	 * if there are some other masters requesting it to be
1186 	 * enabled.
1187 	 *
1188 	 * Value 0 is disabled, all other values indicate enabled.
1189 	 */
1190 	int32_t state;
1191 } BPMP_ABI_PACKED;
1192 
1193 /** @private */
1194 struct cmd_clk_enable_request {
1195 	BPMP_ABI_EMPTY
1196 } BPMP_ABI_PACKED;
1197 
1198 /** @private */
1199 struct cmd_clk_enable_response {
1200 	BPMP_ABI_EMPTY
1201 } BPMP_ABI_PACKED;
1202 
1203 /** @private */
1204 struct cmd_clk_disable_request {
1205 	BPMP_ABI_EMPTY
1206 } BPMP_ABI_PACKED;
1207 
1208 /** @private */
1209 struct cmd_clk_disable_response {
1210 	BPMP_ABI_EMPTY
1211 } BPMP_ABI_PACKED;
1212 
1213 /** @private */
1214 struct cmd_clk_get_all_info_request {
1215 	BPMP_ABI_EMPTY
1216 } BPMP_ABI_PACKED;
1217 
1218 struct cmd_clk_get_all_info_response {
1219 	uint32_t flags;
1220 	uint32_t parent;
1221 	uint32_t parents[MRQ_CLK_MAX_PARENTS];
1222 	uint8_t num_parents;
1223 	uint8_t name[MRQ_CLK_NAME_MAXLEN];
1224 } BPMP_ABI_PACKED;
1225 
1226 /** @private */
1227 struct cmd_clk_get_max_clk_id_request {
1228 	BPMP_ABI_EMPTY
1229 } BPMP_ABI_PACKED;
1230 
1231 struct cmd_clk_get_max_clk_id_response {
1232 	uint32_t max_id;
1233 } BPMP_ABI_PACKED;
1234 
1235 /** @private */
1236 struct cmd_clk_get_fmax_at_vmin_request {
1237 	BPMP_ABI_EMPTY
1238 } BPMP_ABI_PACKED;
1239 
1240 struct cmd_clk_get_fmax_at_vmin_response {
1241 	int64_t rate;
1242 } BPMP_ABI_PACKED;
1243 
1244 /**
1245  * @ingroup Clocks
1246  * @brief Request with #MRQ_CLK
1247  *
1248  * Used by the sender of an #MRQ_CLK message to control clocks. The
1249  * clk_request is split into several sub-commands. Some sub-commands
1250  * require no additional data. Others have a sub-command specific
1251  * payload
1252  *
1253  * |sub-command                 |payload                |
1254  * |----------------------------|-----------------------|
1255  * |CMD_CLK_GET_RATE            |-                      |
1256  * |CMD_CLK_SET_RATE            |clk_set_rate           |
1257  * |CMD_CLK_ROUND_RATE          |clk_round_rate         |
1258  * |CMD_CLK_GET_PARENT          |-                      |
1259  * |CMD_CLK_SET_PARENT          |clk_set_parent         |
1260  * |CMD_CLK_IS_ENABLED          |-                      |
1261  * |CMD_CLK_ENABLE              |-                      |
1262  * |CMD_CLK_DISABLE             |-                      |
1263  * |CMD_CLK_GET_ALL_INFO        |-                      |
1264  * |CMD_CLK_GET_MAX_CLK_ID      |-                      |
1265  * |CMD_CLK_GET_FMAX_AT_VMIN    |-
1266  * |
1267  *
1268  */
1269 
1270 struct mrq_clk_request {
1271 	/** @brief Sub-command and clock id concatenated to 32-bit word.
1272 	 * - bits[31..24] is the sub-cmd.
1273 	 * - bits[23..0] is the clock id
1274 	 */
1275 	uint32_t cmd_and_id;
1276 
1277 	union {
1278 		/** @private */
1279 		struct cmd_clk_get_rate_request clk_get_rate;
1280 		struct cmd_clk_set_rate_request clk_set_rate;
1281 		struct cmd_clk_round_rate_request clk_round_rate;
1282 		/** @private */
1283 		struct cmd_clk_get_parent_request clk_get_parent;
1284 		struct cmd_clk_set_parent_request clk_set_parent;
1285 		/** @private */
1286 		struct cmd_clk_enable_request clk_enable;
1287 		/** @private */
1288 		struct cmd_clk_disable_request clk_disable;
1289 		/** @private */
1290 		struct cmd_clk_is_enabled_request clk_is_enabled;
1291 		/** @private */
1292 		struct cmd_clk_get_all_info_request clk_get_all_info;
1293 		/** @private */
1294 		struct cmd_clk_get_max_clk_id_request clk_get_max_clk_id;
1295 		/** @private */
1296 		struct cmd_clk_get_fmax_at_vmin_request clk_get_fmax_at_vmin;
1297 	} BPMP_UNION_ANON;
1298 } BPMP_ABI_PACKED;
1299 
1300 /**
1301  * @ingroup Clocks
1302  * @brief Response to MRQ_CLK
1303  *
1304  * Each sub-command supported by @ref mrq_clk_request may return
1305  * sub-command-specific data. Some do and some do not as indicated in
1306  * the following table
1307  *
1308  * |sub-command                 |payload                 |
1309  * |----------------------------|------------------------|
1310  * |CMD_CLK_GET_RATE            |clk_get_rate            |
1311  * |CMD_CLK_SET_RATE            |clk_set_rate            |
1312  * |CMD_CLK_ROUND_RATE          |clk_round_rate          |
1313  * |CMD_CLK_GET_PARENT          |clk_get_parent          |
1314  * |CMD_CLK_SET_PARENT          |clk_set_parent          |
1315  * |CMD_CLK_IS_ENABLED          |clk_is_enabled          |
1316  * |CMD_CLK_ENABLE              |-                       |
1317  * |CMD_CLK_DISABLE             |-                       |
1318  * |CMD_CLK_GET_ALL_INFO        |clk_get_all_info        |
1319  * |CMD_CLK_GET_MAX_CLK_ID      |clk_get_max_id          |
1320  * |CMD_CLK_GET_FMAX_AT_VMIN    |clk_get_fmax_at_vmin    |
1321  *
1322  */
1323 
1324 struct mrq_clk_response {
1325 	union {
1326 		struct cmd_clk_get_rate_response clk_get_rate;
1327 		struct cmd_clk_set_rate_response clk_set_rate;
1328 		struct cmd_clk_round_rate_response clk_round_rate;
1329 		struct cmd_clk_get_parent_response clk_get_parent;
1330 		struct cmd_clk_set_parent_response clk_set_parent;
1331 		/** @private */
1332 		struct cmd_clk_enable_response clk_enable;
1333 		/** @private */
1334 		struct cmd_clk_disable_response clk_disable;
1335 		struct cmd_clk_is_enabled_response clk_is_enabled;
1336 		struct cmd_clk_get_all_info_response clk_get_all_info;
1337 		struct cmd_clk_get_max_clk_id_response clk_get_max_clk_id;
1338 		struct cmd_clk_get_fmax_at_vmin_response clk_get_fmax_at_vmin;
1339 	} BPMP_UNION_ANON;
1340 } BPMP_ABI_PACKED;
1341 
1342 /** @} */
1343 
1344 /**
1345  * @ingroup MRQ_Codes
1346  * @def MRQ_QUERY_ABI
1347  * @brief Check if an MRQ is implemented
1348  *
1349  * * Platforms: All
1350  * * Initiators: Any
1351  * * Targets: Any except DMCE
1352  * * Request Payload: @ref mrq_query_abi_request
1353  * * Response Payload: @ref mrq_query_abi_response
1354  */
1355 
1356 /**
1357  * @ingroup ABI_info
1358  * @brief Request with MRQ_QUERY_ABI
1359  *
1360  * Used by #MRQ_QUERY_ABI call to check if MRQ code #mrq is supported
1361  * by the recipient.
1362  */
1363 struct mrq_query_abi_request {
1364 	/** @brief MRQ code to query */
1365 	uint32_t mrq;
1366 } BPMP_ABI_PACKED;
1367 
1368 /**
1369  * @ingroup ABI_info
1370  * @brief Response to MRQ_QUERY_ABI
1371  *
1372  * @note mrq_response::err of 0 indicates that the query was
1373  * successful, not that the MRQ itself is supported!
1374  */
1375 struct mrq_query_abi_response {
1376 	/** @brief 0 if queried MRQ is supported. Else, -#BPMP_ENODEV */
1377 	int32_t status;
1378 } BPMP_ABI_PACKED;
1379 
1380 /**
1381  * @ingroup MRQ_Codes
1382  * @def MRQ_PG_READ_STATE
1383  * @brief Read the power-gating state of a partition
1384  *
1385  * * Platforms: T186
1386  * @cond bpmp_t186
1387  * * Initiators: Any
1388  * * Targets: BPMP
1389  * * Request Payload: @ref mrq_pg_read_state_request
1390  * * Response Payload: @ref mrq_pg_read_state_response
1391  */
1392 
1393 /**
1394  * @ingroup Powergating
1395  * @brief Request with #MRQ_PG_READ_STATE
1396  *
1397  * Used by MRQ_PG_READ_STATE call to read the current state of a
1398  * partition.
1399  */
1400 struct mrq_pg_read_state_request {
1401 	/** @brief ID of partition */
1402 	uint32_t partition_id;
1403 } BPMP_ABI_PACKED;
1404 
1405 /**
1406  * @ingroup Powergating
1407  * @brief Response to MRQ_PG_READ_STATE
1408  * @todo define possible errors.
1409  */
1410 struct mrq_pg_read_state_response {
1411 	/** @brief Read as don't care */
1412 	uint32_t sram_state;
1413 	/** @brief State of power partition
1414 	 * * 0 : off
1415 	 * * 1 : on
1416 	 */
1417 	uint32_t logic_state;
1418 } BPMP_ABI_PACKED;
1419 /** @endcond*/
1420 /** @} */
1421 
1422 /**
1423  * @ingroup MRQ_Codes
1424  * @def MRQ_PG_UPDATE_STATE
1425  * @brief Modify the power-gating state of a partition. In contrast to
1426  * MRQ_PG calls, the operations that change state (on/off) of power
1427  * partition are reference counted.
1428  *
1429  * * Platforms: T186
1430  * @cond bpmp_t186
1431  * * Initiators: Any
1432  * * Targets: BPMP
1433  * * Request Payload: @ref mrq_pg_update_state_request
1434  * * Response Payload: N/A
1435  */
1436 
1437 /**
1438  * @ingroup Powergating
1439  * @brief Request with mrq_pg_update_state_request
1440  *
1441  * Used by #MRQ_PG_UPDATE_STATE call to request BPMP to change the
1442  * state of a power partition #partition_id.
1443  */
1444 struct mrq_pg_update_state_request {
1445 	/** @brief ID of partition */
1446 	uint32_t partition_id;
1447 	/** @brief Secondary control of power partition
1448 	 *  @details Ignored by many versions of the BPMP
1449 	 *  firmware. For maximum compatibility, set the value
1450 	 *  according to @ref logic_state
1451 	 * *  0x1: power ON partition (@ref logic_state == 0x3)
1452 	 * *  0x3: power OFF partition (@ref logic_state == 0x1)
1453 	 */
1454 	uint32_t sram_state;
1455 	/** @brief Controls state of power partition, legal values are
1456 	 * *  0x1 : power OFF partition
1457 	 * *  0x3 : power ON partition
1458 	 */
1459 	uint32_t logic_state;
1460 	/** @brief Change state of clocks of the power partition, legal values
1461 	 * *  0x0 : do not change clock state
1462 	 * *  0x1 : disable partition clocks (only applicable when
1463 	 *          @ref logic_state == 0x1)
1464 	 * *  0x3 : enable partition clocks (only applicable when
1465 	 *          @ref logic_state == 0x3)
1466 	 */
1467 	uint32_t clock_state;
1468 } BPMP_ABI_PACKED;
1469 /** @endcond*/
1470 
1471 /**
1472  * @ingroup MRQ_Codes
1473  * @def MRQ_PG
1474  * @brief Control power-gating state of a partition. In contrast to
1475  * MRQ_PG_UPDATE_STATE, operations that change the power partition
1476  * state are NOT reference counted
1477  *
1478  * @note BPMP-FW forcefully turns off some partitions as part of SC7 entry
1479  * because their state cannot be adequately restored on exit. Therefore,
1480  * it is recommended to power off all domains via MRQ_PG prior to SC7 entry.
1481  * See @ref bpmp_pdomain_ids for further detail.
1482  *
1483  * * Platforms: T186, T194
1484  * * Initiators: Any
1485  * * Targets: BPMP
1486  * * Request Payload: @ref mrq_pg_request
1487  * * Response Payload: @ref mrq_pg_response
1488  *
1489  * @addtogroup Powergating
1490  * @{
1491  */
1492 enum mrq_pg_cmd {
1493 	/**
1494 	 * @brief Check whether the BPMP driver supports the specified
1495 	 * request type
1496 	 *
1497 	 * mrq_response::err is 0 if the specified request is
1498 	 * supported and -#BPMP_ENODEV otherwise.
1499 	 */
1500 	CMD_PG_QUERY_ABI = 0,
1501 
1502 	/**
1503 	 * @brief Set the current state of specified power domain. The
1504 	 * possible values for power domains are defined in enum
1505 	 * pg_states
1506 	 *
1507 	 * mrq_response:err is
1508 	 * 0: Success
1509 	 * -#BPMP_EINVAL: Invalid request parameters
1510 	 */
1511 	CMD_PG_SET_STATE = 1,
1512 
1513 	/**
1514 	 * @brief Get the current state of specified power domain. The
1515 	 * possible values for power domains are defined in enum
1516 	 * pg_states
1517 	 *
1518 	 * mrq_response:err is
1519 	 * 0: Success
1520 	 * -#BPMP_EINVAL: Invalid request parameters
1521 	 */
1522 	CMD_PG_GET_STATE = 2,
1523 
1524 	/**
1525 	 * @brief Get the name string of specified power domain id.
1526 	 *
1527 	 * mrq_response:err is
1528 	 * 0: Success
1529 	 * -#BPMP_EINVAL: Invalid request parameters
1530 	 */
1531 	CMD_PG_GET_NAME = 3,
1532 
1533 
1534 	/**
1535 	 * @brief Get the highest power domain id in the system. Not
1536 	 * all IDs between 0 and max_id are valid IDs.
1537 	 *
1538 	 * mrq_response:err is
1539 	 * 0: Success
1540 	 * -#BPMP_EINVAL: Invalid request parameters
1541 	 */
1542 	CMD_PG_GET_MAX_ID = 4,
1543 };
1544 
1545 #define MRQ_PG_NAME_MAXLEN	40
1546 
1547 enum pg_states {
1548 	/** @brief Power domain is OFF */
1549 	PG_STATE_OFF = 0,
1550 	/** @brief Power domain is ON */
1551 	PG_STATE_ON = 1,
1552 	/**
1553 	 * @brief a legacy state where power domain and the clock
1554 	 * associated to the domain are ON.
1555 	 * This state is only supported in T186, and the use of it is
1556 	 * deprecated.
1557 	 */
1558 	PG_STATE_RUNNING = 2,
1559 };
1560 
1561 struct cmd_pg_query_abi_request {
1562 	/** @ref mrq_pg_cmd */
1563 	uint32_t type;
1564 } BPMP_ABI_PACKED;
1565 
1566 struct cmd_pg_set_state_request {
1567 	/** @ref pg_states */
1568 	uint32_t state;
1569 } BPMP_ABI_PACKED;
1570 
1571 /**
1572  * @brief Response data to #MRQ_PG sub command #CMD_PG_GET_STATE
1573  */
1574 struct cmd_pg_get_state_response {
1575 	/**
1576 	 * @brief The state of the power partition that has been
1577 	 * succesfuly requested by the master earlier using #MRQ_PG
1578 	 * command #CMD_PG_SET_STATE.
1579 	 *
1580 	 * The state may not reflect the physical state of the power
1581 	 * partition if there are some other masters requesting it to
1582 	 * be enabled.
1583 	 *
1584 	 * See @ref pg_states for possible values
1585 	 */
1586 	uint32_t state;
1587 } BPMP_ABI_PACKED;
1588 
1589 struct cmd_pg_get_name_response {
1590 	uint8_t name[MRQ_PG_NAME_MAXLEN];
1591 } BPMP_ABI_PACKED;
1592 
1593 struct cmd_pg_get_max_id_response {
1594 	uint32_t max_id;
1595 } BPMP_ABI_PACKED;
1596 
1597 /**
1598  * @brief Request with #MRQ_PG
1599  *
1600  * Used by the sender of an #MRQ_PG message to control power
1601  * partitions. The pg_request is split into several sub-commands. Some
1602  * sub-commands require no additional data. Others have a sub-command
1603  * specific payload
1604  *
1605  * |sub-command                 |payload                |
1606  * |----------------------------|-----------------------|
1607  * |CMD_PG_QUERY_ABI            | query_abi             |
1608  * |CMD_PG_SET_STATE            | set_state             |
1609  * |CMD_PG_GET_STATE            | -                     |
1610  * |CMD_PG_GET_NAME             | -                     |
1611  * |CMD_PG_GET_MAX_ID           | -                     |
1612  *
1613  */
1614 struct mrq_pg_request {
1615 	uint32_t cmd;
1616 	uint32_t id;
1617 	union {
1618 		struct cmd_pg_query_abi_request query_abi;
1619 		struct cmd_pg_set_state_request set_state;
1620 	} BPMP_UNION_ANON;
1621 } BPMP_ABI_PACKED;
1622 
1623 /**
1624  * @brief Response to MRQ_PG
1625  *
1626  * Each sub-command supported by @ref mrq_pg_request may return
1627  * sub-command-specific data. Some do and some do not as indicated in
1628  * the following table
1629  *
1630  * |sub-command                 |payload                |
1631  * |----------------------------|-----------------------|
1632  * |CMD_PG_QUERY_ABI            | -                     |
1633  * |CMD_PG_SET_STATE            | -                     |
1634  * |CMD_PG_GET_STATE            | get_state             |
1635  * |CMD_PG_GET_NAME             | get_name              |
1636  * |CMD_PG_GET_MAX_ID           | get_max_id            |
1637  */
1638 struct mrq_pg_response {
1639 	union {
1640 		struct cmd_pg_get_state_response get_state;
1641 		struct cmd_pg_get_name_response get_name;
1642 		struct cmd_pg_get_max_id_response get_max_id;
1643 	} BPMP_UNION_ANON;
1644 } BPMP_ABI_PACKED;
1645 
1646 /** @} */
1647 
1648 /**
1649  * @ingroup MRQ_Codes
1650  * @def MRQ_THERMAL
1651  * @brief Interact with BPMP thermal framework
1652  *
1653  * * Platforms: T186, T194
1654  * * Initiators: Any
1655  * * Targets: Any
1656  * * Request Payload: TODO
1657  * * Response Payload: TODO
1658  *
1659  * @addtogroup Thermal
1660  *
1661  * The BPMP firmware includes a thermal framework. Drivers within the
1662  * bpmp firmware register with the framework to provide thermal
1663  * zones. Each thermal zone corresponds to an entity whose temperature
1664  * can be measured. The framework also has a notion of trip points. A
1665  * trip point consists of a thermal zone id, a temperature, and a
1666  * callback routine. The framework invokes the callback when the zone
1667  * hits the indicated temperature. The BPMP firmware uses this thermal
1668  * framework interally to implement various temperature-dependent
1669  * functions.
1670  *
1671  * Software on the CPU can use #MRQ_THERMAL (with payload @ref
1672  * mrq_thermal_host_to_bpmp_request) to interact with the BPMP thermal
1673  * framework. The CPU must It can query the number of supported zones,
1674  * query zone temperatures, and set trip points.
1675  *
1676  * When a trip point set by the CPU gets crossed, BPMP firmware issues
1677  * an IPC to the CPU having mrq_request::mrq = #MRQ_THERMAL and a
1678  * payload of @ref mrq_thermal_bpmp_to_host_request.
1679  * @{
1680  */
1681 enum mrq_thermal_host_to_bpmp_cmd {
1682 	/**
1683 	 * @brief Check whether the BPMP driver supports the specified
1684 	 * request type.
1685 	 *
1686 	 * Host needs to supply request parameters.
1687 	 *
1688 	 * mrq_response::err is 0 if the specified request is
1689 	 * supported and -#BPMP_ENODEV otherwise.
1690 	 */
1691 	CMD_THERMAL_QUERY_ABI = 0,
1692 
1693 	/**
1694 	 * @brief Get the current temperature of the specified zone.
1695 	 *
1696 	 * Host needs to supply request parameters.
1697 	 *
1698 	 * mrq_response::err is
1699 	 * *  0: Temperature query succeeded.
1700 	 * *  -#BPMP_EINVAL: Invalid request parameters.
1701 	 * *  -#BPMP_ENOENT: No driver registered for thermal zone..
1702 	 * *  -#BPMP_EFAULT: Problem reading temperature measurement.
1703 	 */
1704 	CMD_THERMAL_GET_TEMP = 1,
1705 
1706 	/**
1707 	 * @brief Enable or disable and set the lower and upper
1708 	 *   thermal limits for a thermal trip point. Each zone has
1709 	 *   one trip point.
1710 	 *
1711 	 * Host needs to supply request parameters. Once the
1712 	 * temperature hits a trip point, the BPMP will send a message
1713 	 * to the CPU having MRQ=MRQ_THERMAL and
1714 	 * type=CMD_THERMAL_HOST_TRIP_REACHED
1715 	 *
1716 	 * mrq_response::err is
1717 	 * *  0: Trip successfully set.
1718 	 * *  -#BPMP_EINVAL: Invalid request parameters.
1719 	 * *  -#BPMP_ENOENT: No driver registered for thermal zone.
1720 	 * *  -#BPMP_EFAULT: Problem setting trip point.
1721 	 */
1722 	CMD_THERMAL_SET_TRIP = 2,
1723 
1724 	/**
1725 	 * @brief Get the number of supported thermal zones.
1726 	 *
1727 	 * No request parameters required.
1728 	 *
1729 	 * mrq_response::err is always 0, indicating success.
1730 	 */
1731 	CMD_THERMAL_GET_NUM_ZONES = 3,
1732 
1733 	/**
1734 	 * @brief Get the thermtrip of the specified zone.
1735 	 *
1736 	 * Host needs to supply request parameters.
1737 	 *
1738 	 * mrq_response::err is
1739 	 * *  0: Valid zone information returned.
1740 	 * *  -#BPMP_EINVAL: Invalid request parameters.
1741 	 * *  -#BPMP_ENOENT: No driver registered for thermal zone.
1742 	 * *  -#BPMP_ERANGE if thermtrip is invalid or disabled.
1743 	 * *  -#BPMP_EFAULT: Problem reading zone information.
1744 	 */
1745 	CMD_THERMAL_GET_THERMTRIP = 4,
1746 
1747 	/** @brief: number of supported host-to-bpmp commands. May
1748 	 * increase in future
1749 	 */
1750 	CMD_THERMAL_HOST_TO_BPMP_NUM
1751 };
1752 
1753 enum mrq_thermal_bpmp_to_host_cmd {
1754 	/**
1755 	 * @brief Indication that the temperature for a zone has
1756 	 *   exceeded the range indicated in the thermal trip point
1757 	 *   for the zone.
1758 	 *
1759 	 * BPMP needs to supply request parameters. Host only needs to
1760 	 * acknowledge.
1761 	 */
1762 	CMD_THERMAL_HOST_TRIP_REACHED = 100,
1763 
1764 	/** @brief: number of supported bpmp-to-host commands. May
1765 	 * increase in future
1766 	 */
1767 	CMD_THERMAL_BPMP_TO_HOST_NUM
1768 };
1769 
1770 /*
1771  * Host->BPMP request data for request type CMD_THERMAL_QUERY_ABI
1772  *
1773  * zone: Request type for which to check existence.
1774  */
1775 struct cmd_thermal_query_abi_request {
1776 	uint32_t type;
1777 } BPMP_ABI_PACKED;
1778 
1779 /*
1780  * Host->BPMP request data for request type CMD_THERMAL_GET_TEMP
1781  *
1782  * zone: Number of thermal zone.
1783  */
1784 struct cmd_thermal_get_temp_request {
1785 	uint32_t zone;
1786 } BPMP_ABI_PACKED;
1787 
1788 /*
1789  * BPMP->Host reply data for request CMD_THERMAL_GET_TEMP
1790  *
1791  * error: 0 if request succeeded.
1792  *	-BPMP_EINVAL if request parameters were invalid.
1793  *      -BPMP_ENOENT if no driver was registered for the specified thermal zone.
1794  *      -BPMP_EFAULT for other thermal zone driver errors.
1795  * temp: Current temperature in millicelsius.
1796  */
1797 struct cmd_thermal_get_temp_response {
1798 	int32_t temp;
1799 } BPMP_ABI_PACKED;
1800 
1801 /*
1802  * Host->BPMP request data for request type CMD_THERMAL_SET_TRIP
1803  *
1804  * zone: Number of thermal zone.
1805  * low: Temperature of lower trip point in millicelsius
1806  * high: Temperature of upper trip point in millicelsius
1807  * enabled: 1 to enable trip point, 0 to disable trip point
1808  */
1809 struct cmd_thermal_set_trip_request {
1810 	uint32_t zone;
1811 	int32_t low;
1812 	int32_t high;
1813 	uint32_t enabled;
1814 } BPMP_ABI_PACKED;
1815 
1816 /*
1817  * BPMP->Host request data for request type CMD_THERMAL_HOST_TRIP_REACHED
1818  *
1819  * zone: Number of thermal zone where trip point was reached.
1820  */
1821 struct cmd_thermal_host_trip_reached_request {
1822 	uint32_t zone;
1823 } BPMP_ABI_PACKED;
1824 
1825 /*
1826  * BPMP->Host reply data for request type CMD_THERMAL_GET_NUM_ZONES
1827  *
1828  * num: Number of supported thermal zones. The thermal zones are indexed
1829  *      starting from zero.
1830  */
1831 struct cmd_thermal_get_num_zones_response {
1832 	uint32_t num;
1833 } BPMP_ABI_PACKED;
1834 
1835 /*
1836  * Host->BPMP request data for request type CMD_THERMAL_GET_THERMTRIP
1837  *
1838  * zone: Number of thermal zone.
1839  */
1840 struct cmd_thermal_get_thermtrip_request {
1841 	uint32_t zone;
1842 } BPMP_ABI_PACKED;
1843 
1844 /*
1845  * BPMP->Host reply data for request CMD_THERMAL_GET_THERMTRIP
1846  *
1847  * thermtrip: HW shutdown temperature in millicelsius.
1848  */
1849 struct cmd_thermal_get_thermtrip_response {
1850 	int32_t thermtrip;
1851 } BPMP_ABI_PACKED;
1852 
1853 /*
1854  * Host->BPMP request data.
1855  *
1856  * Reply type is union mrq_thermal_bpmp_to_host_response.
1857  *
1858  * type: Type of request. Values listed in enum mrq_thermal_type.
1859  * data: Request type specific parameters.
1860  */
1861 struct mrq_thermal_host_to_bpmp_request {
1862 	uint32_t type;
1863 	union {
1864 		struct cmd_thermal_query_abi_request query_abi;
1865 		struct cmd_thermal_get_temp_request get_temp;
1866 		struct cmd_thermal_set_trip_request set_trip;
1867 		struct cmd_thermal_get_thermtrip_request get_thermtrip;
1868 	} BPMP_UNION_ANON;
1869 } BPMP_ABI_PACKED;
1870 
1871 /*
1872  * BPMP->Host request data.
1873  *
1874  * type: Type of request. Values listed in enum mrq_thermal_type.
1875  * data: Request type specific parameters.
1876  */
1877 struct mrq_thermal_bpmp_to_host_request {
1878 	uint32_t type;
1879 	union {
1880 		struct cmd_thermal_host_trip_reached_request host_trip_reached;
1881 	} BPMP_UNION_ANON;
1882 } BPMP_ABI_PACKED;
1883 
1884 /*
1885  * Data in reply to a Host->BPMP request.
1886  */
1887 union mrq_thermal_bpmp_to_host_response {
1888 	struct cmd_thermal_get_temp_response get_temp;
1889 	struct cmd_thermal_get_thermtrip_response get_thermtrip;
1890 	struct cmd_thermal_get_num_zones_response get_num_zones;
1891 } BPMP_ABI_PACKED;
1892 /** @} */
1893 
1894 /**
1895  * @ingroup MRQ_Codes
1896  * @def MRQ_CPU_VHINT
1897  * @brief Query CPU voltage hint data
1898  *
1899  * * Platforms: T186
1900  * @cond bpmp_t186
1901  * * Initiators: CCPLEX
1902  * * Targets: BPMP
1903  * * Request Payload: @ref mrq_cpu_vhint_request
1904  * * Response Payload: N/A
1905  *
1906  * @addtogroup Vhint
1907  * @{
1908  */
1909 
1910 /**
1911  * @brief Request with #MRQ_CPU_VHINT
1912  *
1913  * Used by #MRQ_CPU_VHINT call by CCPLEX to retrieve voltage hint data
1914  * from BPMP to memory space pointed by #addr. CCPLEX is responsible
1915  * to allocate sizeof(cpu_vhint_data) sized block of memory and
1916  * appropriately map it for BPMP before sending the request.
1917  */
1918 struct mrq_cpu_vhint_request {
1919 	/** @brief IOVA address for the #cpu_vhint_data */
1920 	uint32_t addr;
1921 	/** @brief ID of the cluster whose data is requested */
1922 	uint32_t cluster_id;
1923 } BPMP_ABI_PACKED;
1924 
1925 /**
1926  * @brief Description of the CPU v/f relation
1927  *
1928  * Used by #MRQ_CPU_VHINT call to carry data pointed by
1929  * #mrq_cpu_vhint_request::addr
1930  */
1931 struct cpu_vhint_data {
1932 	uint32_t ref_clk_hz; /**< reference frequency in Hz */
1933 	uint16_t pdiv; /**< post divider value */
1934 	uint16_t mdiv; /**< input divider value */
1935 	uint16_t ndiv_max; /**< fMAX expressed with max NDIV value */
1936 	/** table of ndiv values as a function of vINDEX (voltage index) */
1937 	uint16_t ndiv[80];
1938 	/** minimum allowed NDIV value */
1939 	uint16_t ndiv_min;
1940 	/** minimum allowed voltage hint value (as in vINDEX) */
1941 	uint16_t vfloor;
1942 	/** maximum allowed voltage hint value (as in vINDEX) */
1943 	uint16_t vceil;
1944 	/** post-multiplier for vindex value */
1945 	uint16_t vindex_mult;
1946 	/** post-divider for vindex value */
1947 	uint16_t vindex_div;
1948 	/** reserved for future use */
1949 	uint16_t reserved[328];
1950 } BPMP_ABI_PACKED;
1951 /** @endcond */
1952 /** @} */
1953 
1954 /**
1955  * @ingroup MRQ_Codes
1956  * @def MRQ_ABI_RATCHET
1957  * @brief ABI ratchet value query
1958  *
1959  * * Platforms: T186, T194
1960  * * Initiators: Any
1961  * * Targets: BPMP
1962  * * Request Payload: @ref mrq_abi_ratchet_request
1963  * * Response Payload: @ref mrq_abi_ratchet_response
1964  * @addtogroup ABI_info
1965  * @{
1966  */
1967 
1968 /**
1969  * @brief An ABI compatibility mechanism
1970  *
1971  * BPMP_ABI_RATCHET_VALUE may increase for various reasons in a future
1972  * revision of this header file.
1973  * 1. That future revision deprecates some MRQ
1974  * 2. That future revision introduces a breaking change to an existing
1975  *    MRQ or
1976  * 3. A bug is discovered in an existing implementation of the BPMP-FW
1977  *    (or possibly one of its clients) which warrants deprecating that
1978  *    implementation.
1979  */
1980 #define BPMP_ABI_RATCHET_VALUE 3
1981 
1982 /**
1983  * @brief Request with #MRQ_ABI_RATCHET.
1984  *
1985  * #ratchet should be #BPMP_ABI_RATCHET_VALUE from the ABI header
1986  * against which the requester was compiled.
1987  *
1988  * If ratchet is less than BPMP's #BPMP_ABI_RATCHET_VALUE, BPMP may
1989  * reply with mrq_response::err = -#BPMP_ERANGE to indicate that
1990  * BPMP-FW cannot interoperate correctly with the requester. Requester
1991  * should cease further communication with BPMP.
1992  *
1993  * Otherwise, err shall be 0.
1994  */
1995 struct mrq_abi_ratchet_request {
1996 	/** @brief Requester's ratchet value */
1997 	uint16_t ratchet;
1998 };
1999 
2000 /**
2001  * @brief Response to #MRQ_ABI_RATCHET
2002  *
2003  * #ratchet shall be #BPMP_ABI_RATCHET_VALUE from the ABI header
2004  * against which BPMP firwmare was compiled.
2005  *
2006  * If #ratchet is less than the requester's #BPMP_ABI_RATCHET_VALUE,
2007  * the requster must either interoperate with BPMP according to an ABI
2008  * header version with BPMP_ABI_RATCHET_VALUE = ratchet or cease
2009  * communication with BPMP.
2010  *
2011  * If mrq_response::err is 0 and ratchet is greater than or equal to the
2012  * requester's BPMP_ABI_RATCHET_VALUE, the requester should continue
2013  * normal operation.
2014  */
2015 struct mrq_abi_ratchet_response {
2016 	/** @brief BPMP's ratchet value */
2017 	uint16_t ratchet;
2018 };
2019 /** @} */
2020 
2021 /**
2022  * @ingroup MRQ_Codes
2023  * @def MRQ_EMC_DVFS_LATENCY
2024  * @brief Query frequency dependent EMC DVFS latency
2025  *
2026  * * Platforms: T186, T194
2027  * * Initiators: CCPLEX
2028  * * Targets: BPMP
2029  * * Request Payload: N/A
2030  * * Response Payload: @ref mrq_emc_dvfs_latency_response
2031  * @addtogroup EMC
2032  * @{
2033  */
2034 
2035 /**
2036  * @brief Used by @ref mrq_emc_dvfs_latency_response
2037  */
2038 struct emc_dvfs_latency {
2039 	/** @brief EMC DVFS node frequency in kHz */
2040 	uint32_t freq;
2041 	/** @brief EMC DVFS latency in nanoseconds */
2042 	uint32_t latency;
2043 } BPMP_ABI_PACKED;
2044 
2045 #define EMC_DVFS_LATENCY_MAX_SIZE	14
2046 /**
2047  * @brief Response to #MRQ_EMC_DVFS_LATENCY
2048  */
2049 struct mrq_emc_dvfs_latency_response {
2050 	/** @brief The number valid entries in #pairs */
2051 	uint32_t num_pairs;
2052 	/** @brief EMC DVFS node <frequency, latency> information */
2053 	struct emc_dvfs_latency pairs[EMC_DVFS_LATENCY_MAX_SIZE];
2054 } BPMP_ABI_PACKED;
2055 
2056 /** @} */
2057 
2058 /**
2059  * @ingroup MRQ_Codes
2060  * @def MRQ_CPU_NDIV_LIMITS
2061  * @brief CPU freq. limits in ndiv
2062  *
2063  * * Platforms: T194 onwards
2064  * @cond bpmp_t194
2065  * * Initiators: CCPLEX
2066  * * Targets: BPMP
2067  * * Request Payload: @ref mrq_cpu_ndiv_limits_request
2068  * * Response Payload: @ref mrq_cpu_ndiv_limits_response
2069  * @addtogroup CPU
2070  * @{
2071  */
2072 
2073 /**
2074  * @brief Request for ndiv limits of a cluster
2075  */
2076 struct mrq_cpu_ndiv_limits_request {
2077 	/** @brief Enum cluster_id */
2078 	uint32_t cluster_id;
2079 } BPMP_ABI_PACKED;
2080 
2081 /**
2082  * @brief Response to #MRQ_CPU_NDIV_LIMITS
2083  */
2084 struct mrq_cpu_ndiv_limits_response {
2085 	/** @brief Reference frequency in Hz */
2086 	uint32_t ref_clk_hz;
2087 	/** @brief Post divider value */
2088 	uint16_t pdiv;
2089 	/** @brief Input divider value */
2090 	uint16_t mdiv;
2091 	/** @brief FMAX expressed with max NDIV value */
2092 	uint16_t ndiv_max;
2093 	/** @brief Minimum allowed NDIV value */
2094 	uint16_t ndiv_min;
2095 } BPMP_ABI_PACKED;
2096 
2097 /** @} */
2098 /** @endcond */
2099 
2100 /**
2101  * @ingroup MRQ_Codes
2102  * @def MRQ_CPU_AUTO_CC3
2103  * @brief Query CPU cluster auto-CC3 configuration
2104  *
2105  * * Platforms: T194 onwards
2106  * @cond bpmp_t194
2107  * * Initiators: CCPLEX
2108  * * Targets: BPMP
2109  * * Request Payload: @ref mrq_cpu_auto_cc3_request
2110  * * Response Payload: @ref mrq_cpu_auto_cc3_response
2111  * @addtogroup CC3
2112  *
2113  * Queries from BPMP auto-CC3 configuration (allowed/not allowed) for a
2114  * specified cluster. CCPLEX s/w uses this information to override its own
2115  * device tree auto-CC3 settings, so that BPMP device tree is a single source of
2116  * auto-CC3 platform configuration.
2117  *
2118  * @{
2119  */
2120 
2121 /**
2122  * @brief Request for auto-CC3 configuration of a cluster
2123  */
2124 struct mrq_cpu_auto_cc3_request {
2125 	/** @brief Enum cluster_id (logical cluster id, known to CCPLEX s/w) */
2126 	uint32_t cluster_id;
2127 } BPMP_ABI_PACKED;
2128 
2129 /**
2130  * @brief Response to #MRQ_CPU_AUTO_CC3
2131  */
2132 struct mrq_cpu_auto_cc3_response {
2133 	/**
2134 	 * @brief auto-CC3 configuration
2135 	 *
2136 	 * - bits[31..10] reserved.
2137 	 * - bits[9..1] cc3 ndiv
2138 	 * - bit [0] if "1" auto-CC3 is allowed, if "0" auto-CC3 is not allowed
2139 	 */
2140 	uint32_t auto_cc3_config;
2141 } BPMP_ABI_PACKED;
2142 
2143 /** @} */
2144 /** @endcond */
2145 
2146 /**
2147  * @ingroup MRQ_Codes
2148  * @def MRQ_TRACE_ITER
2149  * @brief Manage the trace iterator
2150  *
2151  * @deprecated
2152  *
2153  * * Platforms: All
2154  * * Initiators: CCPLEX
2155  * * Targets: BPMP
2156  * * Request Payload: N/A
2157  * * Response Payload: @ref mrq_trace_iter_request
2158  * @addtogroup Trace
2159  * @{
2160  */
2161 enum {
2162 	/** @brief (re)start the tracing now. Ignore older events */
2163 	TRACE_ITER_INIT = 0,
2164 	/** @brief Clobber all events in the trace buffer */
2165 	TRACE_ITER_CLEAN = 1
2166 };
2167 
2168 /**
2169  * @brief Request with #MRQ_TRACE_ITER
2170  */
2171 struct mrq_trace_iter_request {
2172 	/** @brief TRACE_ITER_INIT or TRACE_ITER_CLEAN */
2173 	uint32_t cmd;
2174 } BPMP_ABI_PACKED;
2175 
2176 /** @} */
2177 
2178 /**
2179  * @ingroup MRQ_Codes
2180  * @def MRQ_RINGBUF_CONSOLE
2181  * @brief A ring buffer debug console for BPMP
2182  * @addtogroup RingbufConsole
2183  *
2184  * The ring buffer debug console aims to be a substitute for the UART debug
2185  * console. The debug console is implemented with two ring buffers in the
2186  * BPMP-FW, the RX (receive) and TX (transmit) buffers. Characters can be read
2187  * and written to the buffers by the host via the MRQ interface.
2188  *
2189  * @{
2190  */
2191 
2192 /**
2193  * @brief Maximum number of bytes transferred in a single write command to the
2194  * BPMP
2195  *
2196  * This is determined by the number of free bytes in the message struct,
2197  * rounded down to a multiple of four.
2198  */
2199 #define MRQ_RINGBUF_CONSOLE_MAX_WRITE_LEN 112
2200 
2201 /**
2202  * @brief Maximum number of bytes transferred in a single read command to the
2203  * BPMP
2204  *
2205  * This is determined by the number of free bytes in the message struct,
2206  * rounded down to a multiple of four.
2207  */
2208 #define MRQ_RINGBUF_CONSOLE_MAX_READ_LEN 116
2209 
2210 enum mrq_ringbuf_console_host_to_bpmp_cmd {
2211 	/**
2212 	 * @brief Check whether the BPMP driver supports the specified request
2213 	 * type
2214 	 *
2215 	 * mrq_response::err is 0 if the specified request is supported and
2216 	 * -#BPMP_ENODEV otherwise
2217 	 */
2218 	CMD_RINGBUF_CONSOLE_QUERY_ABI = 0,
2219 	/**
2220 	 * @brief Perform a read operation on the BPMP TX buffer
2221 	 *
2222 	 * mrq_response::err is 0
2223 	 */
2224 	CMD_RINGBUF_CONSOLE_READ = 1,
2225 	/**
2226 	 * @brief Perform a write operation on the BPMP RX buffer
2227 	 *
2228 	 * mrq_response::err is 0 if the operation was successful and
2229 	 * -#BPMP_ENODEV otherwise
2230 	 */
2231 	CMD_RINGBUF_CONSOLE_WRITE = 2,
2232 	/**
2233 	 * @brief Get the length of the buffer and the physical addresses of
2234 	 * the buffer data and the head and tail counters
2235 	 *
2236 	 * mrq_response::err is 0 if the operation was successful and
2237 	 * -#BPMP_ENODEV otherwise
2238 	 */
2239 	CMD_RINGBUF_CONSOLE_GET_FIFO = 3,
2240 };
2241 
2242 /**
2243  * @ingroup RingbufConsole
2244  * @brief Host->BPMP request data for request type
2245  * #CMD_RINGBUF_CONSOLE_QUERY_ABI
2246  */
2247 struct cmd_ringbuf_console_query_abi_req {
2248 	/** @brief Command identifier to be queried */
2249 	uint32_t cmd;
2250 } BPMP_ABI_PACKED;
2251 
2252 /** @private */
2253 struct cmd_ringbuf_console_query_abi_resp {
2254 	BPMP_ABI_EMPTY
2255 } BPMP_ABI_PACKED;
2256 
2257 /**
2258  * @ingroup RingbufConsole
2259  * @brief Host->BPMP request data for request type #CMD_RINGBUF_CONSOLE_READ
2260  */
2261 struct cmd_ringbuf_console_read_req {
2262 	/**
2263 	 * @brief Number of bytes requested to be read from the BPMP TX buffer
2264 	 */
2265 	uint8_t len;
2266 } BPMP_ABI_PACKED;
2267 
2268 /**
2269  * @ingroup RingbufConsole
2270  * @brief BPMP->Host response data for request type #CMD_RINGBUF_CONSOLE_READ
2271  */
2272 struct cmd_ringbuf_console_read_resp {
2273 	/** @brief The actual data read from the BPMP TX buffer */
2274 	uint8_t data[MRQ_RINGBUF_CONSOLE_MAX_READ_LEN];
2275 	/** @brief Number of bytes in cmd_ringbuf_console_read_resp::data */
2276 	uint8_t len;
2277 } BPMP_ABI_PACKED;
2278 
2279 /**
2280  * @ingroup RingbufConsole
2281  * @brief Host->BPMP request data for request type #CMD_RINGBUF_CONSOLE_WRITE
2282  */
2283 struct cmd_ringbuf_console_write_req {
2284 	/** @brief The actual data to be written to the BPMP RX buffer */
2285 	uint8_t data[MRQ_RINGBUF_CONSOLE_MAX_WRITE_LEN];
2286 	/** @brief Number of bytes in cmd_ringbuf_console_write_req::data */
2287 	uint8_t len;
2288 } BPMP_ABI_PACKED;
2289 
2290 /**
2291  * @ingroup RingbufConsole
2292  * @brief BPMP->Host response data for request type #CMD_RINGBUF_CONSOLE_WRITE
2293  */
2294 struct cmd_ringbuf_console_write_resp {
2295 	/** @brief Number of bytes of available space in the BPMP RX buffer */
2296 	uint32_t space_avail;
2297 	/** @brief Number of bytes that were written to the BPMP RX buffer */
2298 	uint8_t len;
2299 } BPMP_ABI_PACKED;
2300 
2301 /** @private */
2302 struct cmd_ringbuf_console_get_fifo_req {
2303 	BPMP_ABI_EMPTY
2304 } BPMP_ABI_PACKED;
2305 
2306 /**
2307  * @ingroup RingbufConsole
2308  * @brief BPMP->Host reply data for request type #CMD_RINGBUF_CONSOLE_GET_FIFO
2309  */
2310 struct cmd_ringbuf_console_get_fifo_resp {
2311 	/** @brief Physical address of the BPMP TX buffer */
2312 	uint64_t bpmp_tx_buf_addr;
2313 	/** @brief Physical address of the BPMP TX buffer head counter */
2314 	uint64_t bpmp_tx_head_addr;
2315 	/** @brief Physical address of the BPMP TX buffer tail counter */
2316 	uint64_t bpmp_tx_tail_addr;
2317 	/** @brief Length of the BPMP TX buffer */
2318 	uint32_t bpmp_tx_buf_len;
2319 } BPMP_ABI_PACKED;
2320 
2321 /**
2322  * @ingroup RingbufConsole
2323  * @brief Host->BPMP request data.
2324  *
2325  * Reply type is union #mrq_ringbuf_console_bpmp_to_host_response .
2326  */
2327 struct mrq_ringbuf_console_host_to_bpmp_request {
2328 	/**
2329 	 * @brief Type of request. Values listed in enum
2330 	 * #mrq_ringbuf_console_host_to_bpmp_cmd.
2331 	 */
2332 	uint32_t type;
2333 	/** @brief  request type specific parameters. */
2334 	union {
2335 		struct cmd_ringbuf_console_query_abi_req query_abi;
2336 		struct cmd_ringbuf_console_read_req read;
2337 		struct cmd_ringbuf_console_write_req write;
2338 		struct cmd_ringbuf_console_get_fifo_req get_fifo;
2339 	} BPMP_UNION_ANON;
2340 } BPMP_ABI_PACKED;
2341 
2342 /**
2343  * @ingroup RingbufConsole
2344  * @brief Host->BPMP reply data
2345  *
2346  * In response to struct #mrq_ringbuf_console_host_to_bpmp_request.
2347  */
2348 union mrq_ringbuf_console_bpmp_to_host_response {
2349 	struct cmd_ringbuf_console_query_abi_resp query_abi;
2350 	struct cmd_ringbuf_console_read_resp read;
2351 	struct cmd_ringbuf_console_write_resp write;
2352 	struct cmd_ringbuf_console_get_fifo_resp get_fifo;
2353 } BPMP_ABI_PACKED;
2354 /** @} */
2355 
2356 /**
2357  * @ingroup MRQ_Codes
2358  * @def MRQ_STRAP
2359  * @brief Set a strap value controlled by BPMP
2360  *
2361  * * Platforms: T194 onwards
2362  * @cond bpmp_t194
2363  * * Initiators: CCPLEX
2364  * * Targets: BPMP
2365  * * Request Payload: @ref mrq_strap_request
2366  * * Response Payload: N/A
2367  * @addtogroup Strap
2368  *
2369  * A strap is an input that is sampled by a hardware unit during the
2370  * unit's startup process. The sampled value of a strap affects the
2371  * behavior of the unit until the unit is restarted. Many hardware
2372  * units sample their straps at the instant that their resets are
2373  * deasserted.
2374  *
2375  * BPMP owns registers which act as straps to various units. It
2376  * exposes limited control of those straps via #MRQ_STRAP.
2377  *
2378  * @{
2379  */
2380 enum mrq_strap_cmd {
2381 	/** @private */
2382 	STRAP_RESERVED = 0,
2383 	/** @brief Set a strap value */
2384 	STRAP_SET = 1
2385 };
2386 
2387 /**
2388  * @brief Request with #MRQ_STRAP
2389  */
2390 struct mrq_strap_request {
2391 	/** @brief @ref mrq_strap_cmd */
2392 	uint32_t cmd;
2393 	/** @brief Strap ID from @ref Strap_Ids */
2394 	uint32_t id;
2395 	/** @brief Desired value for strap (if cmd is #STRAP_SET) */
2396 	uint32_t value;
2397 } BPMP_ABI_PACKED;
2398 
2399 /**
2400  * @defgroup Strap_Ids Strap Identifiers
2401  * @}
2402  */
2403 /** @endcond */
2404 
2405 /**
2406  * @ingroup MRQ_Codes
2407  * @def MRQ_UPHY
2408  * @brief Perform a UPHY operation
2409  *
2410  * * Platforms: T194 onwards
2411  * @cond bpmp_t194
2412  * * Initiators: CCPLEX
2413  * * Targets: BPMP
2414  * * Request Payload: @ref mrq_uphy_request
2415  * * Response Payload: @ref mrq_uphy_response
2416  *
2417  * @addtogroup UPHY
2418  * @{
2419  */
2420 enum {
2421 	CMD_UPHY_PCIE_LANE_MARGIN_CONTROL = 1,
2422 	CMD_UPHY_PCIE_LANE_MARGIN_STATUS = 2,
2423 	CMD_UPHY_PCIE_EP_CONTROLLER_PLL_INIT = 3,
2424 	CMD_UPHY_PCIE_CONTROLLER_STATE = 4,
2425 	CMD_UPHY_PCIE_EP_CONTROLLER_PLL_OFF = 5,
2426 	CMD_UPHY_MAX,
2427 };
2428 
2429 struct cmd_uphy_margin_control_request {
2430 	/** @brief Enable margin */
2431 	int32_t en;
2432 	/** @brief Clear the number of error and sections */
2433 	int32_t clr;
2434 	/** @brief Set x offset (1's complement) for left/right margin type (y should be 0) */
2435 	uint32_t x;
2436 	/** @brief Set y offset (1's complement) for left/right margin type (x should be 0) */
2437 	uint32_t y;
2438 	/** @brief Set number of bit blocks for each margin section */
2439 	uint32_t nblks;
2440 } BPMP_ABI_PACKED;
2441 
2442 struct cmd_uphy_margin_status_response {
2443 	/** @brief Number of errors observed */
2444 	uint32_t status;
2445 } BPMP_ABI_PACKED;
2446 
2447 struct cmd_uphy_ep_controller_pll_init_request {
2448 	/** @brief EP controller number, valid: 0, 4, 5 */
2449 	uint8_t ep_controller;
2450 } BPMP_ABI_PACKED;
2451 
2452 struct cmd_uphy_pcie_controller_state_request {
2453 	/** @brief PCIE controller number, valid: 0, 1, 2, 3, 4 */
2454 	uint8_t pcie_controller;
2455 	uint8_t enable;
2456 } BPMP_ABI_PACKED;
2457 
2458 struct cmd_uphy_ep_controller_pll_off_request {
2459 	/** @brief EP controller number, valid: 0, 4, 5 */
2460 	uint8_t ep_controller;
2461 } BPMP_ABI_PACKED;
2462 
2463 /**
2464  * @ingroup UPHY
2465  * @brief Request with #MRQ_UPHY
2466  *
2467  * Used by the sender of an #MRQ_UPHY message to control UPHY Lane RX margining.
2468  * The uphy_request is split into several sub-commands. Some sub-commands
2469  * require no additional data. Others have a sub-command specific payload
2470  *
2471  * |sub-command                          |payload                                 |
2472  * |------------------------------------ |----------------------------------------|
2473  * |CMD_UPHY_PCIE_LANE_MARGIN_CONTROL    |uphy_set_margin_control                 |
2474  * |CMD_UPHY_PCIE_LANE_MARGIN_STATUS     |                                        |
2475  * |CMD_UPHY_PCIE_EP_CONTROLLER_PLL_INIT |cmd_uphy_ep_controller_pll_init_request |
2476  * |CMD_UPHY_PCIE_CONTROLLER_STATE       |cmd_uphy_pcie_controller_state_request  |
2477  * |CMD_UPHY_PCIE_EP_CONTROLLER_PLL_OFF  |cmd_uphy_ep_controller_pll_off_request  |
2478  *
2479  */
2480 
2481 struct mrq_uphy_request {
2482 	/** @brief Lane number. */
2483 	uint16_t lane;
2484 	/** @brief Sub-command id. */
2485 	uint16_t cmd;
2486 
2487 	union {
2488 		struct cmd_uphy_margin_control_request uphy_set_margin_control;
2489 		struct cmd_uphy_ep_controller_pll_init_request ep_ctrlr_pll_init;
2490 		struct cmd_uphy_pcie_controller_state_request controller_state;
2491 		struct cmd_uphy_ep_controller_pll_off_request ep_ctrlr_pll_off;
2492 	} BPMP_UNION_ANON;
2493 } BPMP_ABI_PACKED;
2494 
2495 /**
2496  * @ingroup UPHY
2497  * @brief Response to MRQ_UPHY
2498  *
2499  * Each sub-command supported by @ref mrq_uphy_request may return
2500  * sub-command-specific data. Some do and some do not as indicated in
2501  * the following table
2502  *
2503  * |sub-command                       |payload                 |
2504  * |----------------------------      |------------------------|
2505  * |CMD_UPHY_PCIE_LANE_MARGIN_CONTROL |                        |
2506  * |CMD_UPHY_PCIE_LANE_MARGIN_STATUS  |uphy_get_margin_status  |
2507  *
2508  */
2509 
2510 struct mrq_uphy_response {
2511 	union {
2512 		struct cmd_uphy_margin_status_response uphy_get_margin_status;
2513 	} BPMP_UNION_ANON;
2514 } BPMP_ABI_PACKED;
2515 
2516 /** @} */
2517 /** @endcond */
2518 
2519 /**
2520  * @ingroup MRQ_Codes
2521  * @def MRQ_FMON
2522  * @brief Perform a frequency monitor configuration operations
2523  *
2524  * * Platforms: T194 onwards
2525  * @cond bpmp_t194
2526  * * Initiators: CCPLEX
2527  * * Targets: BPMP
2528  * * Request Payload: @ref mrq_fmon_request
2529  * * Response Payload: @ref mrq_fmon_response
2530  *
2531  * @addtogroup FMON
2532  * @{
2533  */
2534 enum {
2535 	/**
2536 	 * @brief Clamp FMON configuration to specified rate.
2537 	 *
2538 	 * The monitored clock must be running for clamp to succeed. If
2539 	 * clamped, FMON configuration is preserved when clock rate
2540 	 * and/or state is changed.
2541 	 */
2542 	CMD_FMON_GEAR_CLAMP = 1,
2543 	/**
2544 	 * @brief Release clamped FMON configuration.
2545 	 *
2546 	 * Allow FMON configuration to follow monitored clock rate
2547 	 * and/or state changes.
2548 	 */
2549 	CMD_FMON_GEAR_FREE = 2,
2550 	/**
2551 	 * @brief Return rate FMON is clamped at, or 0 if FMON is not
2552 	 *         clamped.
2553 	 *
2554 	 * Inherently racy, since clamp state can be changed
2555 	 * concurrently. Useful for testing.
2556 	 */
2557 	CMD_FMON_GEAR_GET = 3,
2558 	CMD_FMON_NUM,
2559 };
2560 
2561 struct cmd_fmon_gear_clamp_request {
2562 	int32_t unused;
2563 	int64_t rate;
2564 } BPMP_ABI_PACKED;
2565 
2566 /** @private */
2567 struct cmd_fmon_gear_clamp_response {
2568 	BPMP_ABI_EMPTY
2569 } BPMP_ABI_PACKED;
2570 
2571 /** @private */
2572 struct cmd_fmon_gear_free_request {
2573 	BPMP_ABI_EMPTY
2574 } BPMP_ABI_PACKED;
2575 
2576 /** @private */
2577 struct cmd_fmon_gear_free_response {
2578 	BPMP_ABI_EMPTY
2579 } BPMP_ABI_PACKED;
2580 
2581 /** @private */
2582 struct cmd_fmon_gear_get_request {
2583 	BPMP_ABI_EMPTY
2584 } BPMP_ABI_PACKED;
2585 
2586 struct cmd_fmon_gear_get_response {
2587 	int64_t rate;
2588 } BPMP_ABI_PACKED;
2589 
2590 /**
2591  * @ingroup FMON
2592  * @brief Request with #MRQ_FMON
2593  *
2594  * Used by the sender of an #MRQ_FMON message to configure clock
2595  * frequency monitors. The FMON request is split into several
2596  * sub-commands. Some sub-commands require no additional data.
2597  * Others have a sub-command specific payload
2598  *
2599  * |sub-command                 |payload                |
2600  * |----------------------------|-----------------------|
2601  * |CMD_FMON_GEAR_CLAMP         |fmon_gear_clamp        |
2602  * |CMD_FMON_GEAR_FREE          |-                      |
2603  * |CMD_FMON_GEAR_GET           |-                      |
2604  *
2605  */
2606 
2607 struct mrq_fmon_request {
2608 	/** @brief Sub-command and clock id concatenated to 32-bit word.
2609 	 * - bits[31..24] is the sub-cmd.
2610 	 * - bits[23..0] is monitored clock id used to select target
2611 	 *   FMON
2612 	 */
2613 	uint32_t cmd_and_id;
2614 
2615 	union {
2616 		struct cmd_fmon_gear_clamp_request fmon_gear_clamp;
2617 		/** @private */
2618 		struct cmd_fmon_gear_free_request fmon_gear_free;
2619 		/** @private */
2620 		struct cmd_fmon_gear_get_request fmon_gear_get;
2621 	} BPMP_UNION_ANON;
2622 } BPMP_ABI_PACKED;
2623 
2624 /**
2625  * @ingroup FMON
2626  * @brief Response to MRQ_FMON
2627  *
2628  * Each sub-command supported by @ref mrq_fmon_request may
2629  * return sub-command-specific data as indicated below.
2630  *
2631  * |sub-command                 |payload                 |
2632  * |----------------------------|------------------------|
2633  * |CMD_FMON_GEAR_CLAMP         |-                       |
2634  * |CMD_FMON_GEAR_FREE          |-                       |
2635  * |CMD_FMON_GEAR_GET           |fmon_gear_get           |
2636  *
2637  */
2638 
2639 struct mrq_fmon_response {
2640 	union {
2641 		/** @private */
2642 		struct cmd_fmon_gear_clamp_response fmon_gear_clamp;
2643 		/** @private */
2644 		struct cmd_fmon_gear_free_response fmon_gear_free;
2645 		struct cmd_fmon_gear_get_response fmon_gear_get;
2646 	} BPMP_UNION_ANON;
2647 } BPMP_ABI_PACKED;
2648 
2649 /** @} */
2650 /** @endcond */
2651 
2652 /**
2653  * @ingroup MRQ_Codes
2654  * @def MRQ_EC
2655  * @brief Provide status information on faults reported by Error
2656  *        Collator (EC) to HSM.
2657  *
2658  * * Platforms: T194 onwards
2659  * @cond bpmp_t194
2660  * * Initiators: CCPLEX
2661  * * Targets: BPMP
2662  * * Request Payload: @ref mrq_ec_request
2663  * * Response Payload: @ref mrq_ec_response
2664  *
2665  * @note This MRQ ABI is under construction, and subject to change
2666  *
2667  * @addtogroup EC
2668  * @{
2669  */
2670 enum {
2671 	/**
2672 	 * @cond DEPRECATED
2673 	 * @brief Retrieve specified EC status.
2674 	 *
2675 	 * mrq_response::err is 0 if the operation was successful, or @n
2676 	 * -#BPMP_ENODEV if target EC is not owned by BPMP @n
2677 	 * -#BPMP_EACCES if target EC power domain is turned off @n
2678 	 * -#BPMP_EBADCMD if subcommand is not supported
2679 	 * @endcond
2680 	 */
2681 	CMD_EC_STATUS_GET = 1,	/* deprecated */
2682 
2683 	/**
2684 	 * @brief Retrieve specified EC extended status (includes error
2685 	 *        counter and user values).
2686 	 *
2687 	 * mrq_response::err is 0 if the operation was successful, or @n
2688 	 * -#BPMP_ENODEV if target EC is not owned by BPMP @n
2689 	 * -#BPMP_EACCES if target EC power domain is turned off @n
2690 	 * -#BPMP_EBADCMD if subcommand is not supported
2691 	 */
2692 	CMD_EC_STATUS_EX_GET = 2,
2693 	CMD_EC_NUM,
2694 };
2695 
2696 /** @brief BPMP ECs error types */
2697 enum bpmp_ec_err_type {
2698 	/** @brief Parity error on internal data path
2699 	 *
2700 	 *  Error descriptor @ref ec_err_simple_desc.
2701 	 */
2702 	EC_ERR_TYPE_PARITY_INTERNAL		= 1,
2703 
2704 	/** @brief ECC SEC error on internal data path
2705 	 *
2706 	 *  Error descriptor @ref ec_err_simple_desc.
2707 	 */
2708 	EC_ERR_TYPE_ECC_SEC_INTERNAL		= 2,
2709 
2710 	/** @brief ECC DED error on internal data path
2711 	 *
2712 	 *  Error descriptor @ref ec_err_simple_desc.
2713 	 */
2714 	EC_ERR_TYPE_ECC_DED_INTERNAL		= 3,
2715 
2716 	/** @brief Comparator error
2717 	 *
2718 	 *  Error descriptor @ref ec_err_simple_desc.
2719 	 */
2720 	EC_ERR_TYPE_COMPARATOR			= 4,
2721 
2722 	/** @brief Register parity error
2723 	 *
2724 	 *  Error descriptor @ref ec_err_reg_parity_desc.
2725 	 */
2726 	EC_ERR_TYPE_REGISTER_PARITY		= 5,
2727 
2728 	/** @brief Parity error from on-chip SRAM/FIFO
2729 	 *
2730 	 *  Error descriptor @ref ec_err_simple_desc.
2731 	 */
2732 	EC_ERR_TYPE_PARITY_SRAM			= 6,
2733 
2734 	/** @brief Clock Monitor error
2735 	 *
2736 	 *  Error descriptor @ref ec_err_fmon_desc.
2737 	 */
2738 	EC_ERR_TYPE_CLOCK_MONITOR		= 9,
2739 
2740 	/** @brief Voltage Monitor error
2741 	 *
2742 	 *  Error descriptor @ref ec_err_vmon_desc.
2743 	 */
2744 	EC_ERR_TYPE_VOLTAGE_MONITOR		= 10,
2745 
2746 	/** @brief SW Correctable error
2747 	 *
2748 	 *  Error descriptor @ref ec_err_sw_error_desc.
2749 	 */
2750 	EC_ERR_TYPE_SW_CORRECTABLE		= 16,
2751 
2752 	/** @brief SW Uncorrectable error
2753 	 *
2754 	 *  Error descriptor @ref ec_err_sw_error_desc.
2755 	 */
2756 	EC_ERR_TYPE_SW_UNCORRECTABLE		= 17,
2757 
2758 	/** @brief Other HW Correctable error
2759 	 *
2760 	 *  Error descriptor @ref ec_err_simple_desc.
2761 	 */
2762 	EC_ERR_TYPE_OTHER_HW_CORRECTABLE	= 32,
2763 
2764 	/** @brief Other HW Uncorrectable error
2765 	 *
2766 	 *  Error descriptor @ref ec_err_simple_desc.
2767 	 */
2768 	EC_ERR_TYPE_OTHER_HW_UNCORRECTABLE	= 33,
2769 };
2770 
2771 /** @brief Group of registers with parity error. */
2772 enum ec_registers_group {
2773 	/** @brief Functional registers group */
2774 	EC_ERR_GROUP_FUNC_REG		= 0U,
2775 	/** @brief SCR registers group */
2776 	EC_ERR_GROUP_SCR_REG		= 1U,
2777 };
2778 
2779 /**
2780  * @defgroup bpmp_ec_status_flags EC Status Flags
2781  * @addtogroup bpmp_ec_status_flags
2782  * @{
2783  */
2784 /** @brief No EC error found flag */
2785 #define EC_STATUS_FLAG_NO_ERROR		0x0001U
2786 /** @brief Last EC error found flag */
2787 #define EC_STATUS_FLAG_LAST_ERROR	0x0002U
2788 /** @brief EC latent error flag */
2789 #define EC_STATUS_FLAG_LATENT_ERROR	0x0004U
2790 /** @} */
2791 
2792 /**
2793  * @defgroup bpmp_ec_desc_flags EC Descriptor Flags
2794  * @addtogroup bpmp_ec_desc_flags
2795  * @{
2796  */
2797 /** @brief EC descriptor error resolved flag */
2798 #define EC_DESC_FLAG_RESOLVED		0x0001U
2799 /** @brief EC descriptor failed to retrieve id flag */
2800 #define EC_DESC_FLAG_NO_ID		0x0002U
2801 /** @} */
2802 
2803 /**
2804  * |error type                       | fmon_clk_id values        |
2805  * |---------------------------------|---------------------------|
2806  * |@ref EC_ERR_TYPE_CLOCK_MONITOR   |@ref bpmp_clock_ids        |
2807  */
2808 struct ec_err_fmon_desc {
2809 	/** @brief Bitmask of @ref bpmp_ec_desc_flags  */
2810 	uint16_t desc_flags;
2811 	/** @brief FMON monitored clock id */
2812 	uint16_t fmon_clk_id;
2813 	/** @brief Bitmask of @ref bpmp_fmon_faults_flags */
2814 	uint32_t fmon_faults;
2815 	/** @brief FMON faults access error */
2816 	int32_t fmon_access_error;
2817 } BPMP_ABI_PACKED;
2818 
2819 /**
2820  * |error type                       | vmon_adc_id values        |
2821  * |---------------------------------|---------------------------|
2822  * |@ref EC_ERR_TYPE_VOLTAGE_MONITOR |@ref bpmp_adc_ids          |
2823  */
2824 struct ec_err_vmon_desc {
2825 	/** @brief Bitmask of @ref bpmp_ec_desc_flags  */
2826 	uint16_t desc_flags;
2827 	/** @brief VMON rail adc id */
2828 	uint16_t vmon_adc_id;
2829 	/** @brief Bitmask of @ref bpmp_vmon_faults_flags */
2830 	uint32_t vmon_faults;
2831 	/** @brief VMON faults access error */
2832 	int32_t vmon_access_error;
2833 } BPMP_ABI_PACKED;
2834 
2835 /**
2836  * |error type                       | reg_id values             |
2837  * |---------------------------------|---------------------------|
2838  * |@ref EC_ERR_TYPE_REGISTER_PARITY |@ref bpmp_ec_registers_ids |
2839  */
2840 struct ec_err_reg_parity_desc {
2841 	/** @brief Bitmask of @ref bpmp_ec_desc_flags  */
2842 	uint16_t desc_flags;
2843 	/** @brief Register id */
2844 	uint16_t reg_id;
2845 	/** @brief Register group @ref ec_registers_group */
2846 	uint16_t reg_group;
2847 } BPMP_ABI_PACKED;
2848 
2849 /**
2850  * |error type                        | err_source_id values     |
2851  * |--------------------------------- |--------------------------|
2852  * |@ref EC_ERR_TYPE_SW_CORRECTABLE   | @ref bpmp_ec_ce_swd_ids  |
2853  * |@ref EC_ERR_TYPE_SW_UNCORRECTABLE | @ref bpmp_ec_ue_swd_ids  |
2854  */
2855 struct ec_err_sw_error_desc {
2856 	/** @brief Bitmask of @ref bpmp_ec_desc_flags  */
2857 	uint16_t desc_flags;
2858 	/** @brief Error source id */
2859 	uint16_t err_source_id;
2860 	/** @brief Sw error data */
2861 	uint32_t sw_error_data;
2862 } BPMP_ABI_PACKED;
2863 
2864 /**
2865  * |error type                              | err_source_id values      |
2866  * |----------------------------------------|---------------------------|
2867  * |@ref EC_ERR_TYPE_PARITY_INTERNAL        |@ref bpmp_ec_ipath_ids     |
2868  * |@ref EC_ERR_TYPE_ECC_SEC_INTERNAL       |@ref bpmp_ec_ipath_ids     |
2869  * |@ref EC_ERR_TYPE_ECC_DED_INTERNAL       |@ref bpmp_ec_ipath_ids     |
2870  * |@ref EC_ERR_TYPE_COMPARATOR             |@ref bpmp_ec_comparator_ids|
2871  * |@ref EC_ERR_TYPE_PARITY_SRAM            |@ref bpmp_clock_ids        |
2872  * |@ref EC_ERR_TYPE_OTHER_HW_CORRECTABLE   |@ref bpmp_ec_misc_hwd_ids  |
2873  * |@ref EC_ERR_TYPE_OTHER_HW_UNCORRECTABLE |@ref bpmp_ec_misc_hwd_ids  |
2874  */
2875 struct ec_err_simple_desc {
2876 	/** @brief Bitmask of @ref bpmp_ec_desc_flags  */
2877 	uint16_t desc_flags;
2878 	/** @brief Error source id. Id space depends on error type. */
2879 	uint16_t err_source_id;
2880 } BPMP_ABI_PACKED;
2881 
2882 /** @brief Union of EC error descriptors */
2883 union ec_err_desc {
2884 	struct ec_err_fmon_desc fmon_desc;
2885 	struct ec_err_vmon_desc vmon_desc;
2886 	struct ec_err_reg_parity_desc reg_parity_desc;
2887 	struct ec_err_sw_error_desc sw_error_desc;
2888 	struct ec_err_simple_desc simple_desc;
2889 } BPMP_ABI_PACKED;
2890 
2891 struct cmd_ec_status_get_request {
2892 	/** @brief HSM error line number that identifies target EC. */
2893 	uint32_t ec_hsm_id;
2894 } BPMP_ABI_PACKED;
2895 
2896 /** EC status maximum number of descriptors */
2897 #define EC_ERR_STATUS_DESC_MAX_NUM	4U
2898 
2899 /**
2900  * @cond DEPRECATED
2901  */
2902 struct cmd_ec_status_get_response {
2903 	/** @brief Target EC id (the same id received with request). */
2904 	uint32_t ec_hsm_id;
2905 	/**
2906 	 * @brief Bitmask of @ref bpmp_ec_status_flags
2907 	 *
2908 	 * If NO_ERROR flag is set, error_ fields should be ignored
2909 	 */
2910 	uint32_t ec_status_flags;
2911 	/** @brief Found EC error index. */
2912 	uint32_t error_idx;
2913 	/** @brief  Found EC error type @ref bpmp_ec_err_type. */
2914 	uint32_t error_type;
2915 	/** @brief  Number of returned EC error descriptors */
2916 	uint32_t error_desc_num;
2917 	/** @brief  EC error descriptors */
2918 	union ec_err_desc error_descs[EC_ERR_STATUS_DESC_MAX_NUM];
2919 } BPMP_ABI_PACKED;
2920 /** @endcond */
2921 
2922 struct cmd_ec_status_ex_get_response {
2923 	/** @brief Target EC id (the same id received with request). */
2924 	uint32_t ec_hsm_id;
2925 	/**
2926 	 * @brief Bitmask of @ref bpmp_ec_status_flags
2927 	 *
2928 	 * If NO_ERROR flag is set, error_ fields should be ignored
2929 	 */
2930 	uint32_t ec_status_flags;
2931 	/** @brief Found EC error index. */
2932 	uint32_t error_idx;
2933 	/** @brief  Found EC error type @ref bpmp_ec_err_type. */
2934 	uint32_t error_type;
2935 	/** @brief  Found EC mission error counter value */
2936 	uint32_t error_counter;
2937 	/** @brief  Found EC mission error user value */
2938 	uint32_t error_uval;
2939 	/** @brief  Reserved entry    */
2940 	uint32_t reserved;
2941 	/** @brief  Number of returned EC error descriptors */
2942 	uint32_t error_desc_num;
2943 	/** @brief  EC error descriptors */
2944 	union ec_err_desc error_descs[EC_ERR_STATUS_DESC_MAX_NUM];
2945 } BPMP_ABI_PACKED;
2946 
2947 /**
2948  * @ingroup EC
2949  * @brief Request with #MRQ_EC
2950  *
2951  * Used by the sender of an #MRQ_EC message to access ECs owned
2952  * by BPMP.
2953  *
2954  * @cond DEPRECATED
2955  * |sub-command                 |payload                |
2956  * |----------------------------|-----------------------|
2957  * |@ref CMD_EC_STATUS_GET      |ec_status_get          |
2958  * @endcond
2959  *
2960  * |sub-command                 |payload                |
2961  * |----------------------------|-----------------------|
2962  * |@ref CMD_EC_STATUS_EX_GET   |ec_status_get          |
2963  *
2964  */
2965 
2966 struct mrq_ec_request {
2967 	/** @brief Sub-command id. */
2968 	uint32_t cmd_id;
2969 
2970 	union {
2971 		struct cmd_ec_status_get_request ec_status_get;
2972 	} BPMP_UNION_ANON;
2973 } BPMP_ABI_PACKED;
2974 
2975 /**
2976  * @ingroup EC
2977  * @brief Response to MRQ_EC
2978  *
2979  * Each sub-command supported by @ref mrq_ec_request may return
2980  * sub-command-specific data as indicated below.
2981  *
2982  * @cond DEPRECATED
2983  * |sub-command                 |payload                 |
2984  * |----------------------------|------------------------|
2985  * |@ref CMD_EC_STATUS_GET      |ec_status_get           |
2986  * @endcond
2987  *
2988  * |sub-command                 |payload                 |
2989  * |----------------------------|------------------------|
2990  * |@ref CMD_EC_STATUS_EX_GET   |ec_status_ex_get        |
2991  *
2992  */
2993 
2994 struct mrq_ec_response {
2995 	union {
2996 		/**
2997 		 * @cond DEPRECATED
2998 		 */
2999 		struct cmd_ec_status_get_response ec_status_get;
3000 		/** @endcond */
3001 		struct cmd_ec_status_ex_get_response ec_status_ex_get;
3002 	} BPMP_UNION_ANON;
3003 } BPMP_ABI_PACKED;
3004 
3005 /** @} */
3006 /** @endcond */
3007 
3008 /**
3009  * @addtogroup Error_Codes
3010  * Negative values for mrq_response::err generally indicate some
3011  * error. The ABI defines the following error codes. Negating these
3012  * defines is an exercise left to the user.
3013  * @{
3014  */
3015 
3016 /** @brief Operation not permitted */
3017 #define BPMP_EPERM	1
3018 /** @brief No such file or directory */
3019 #define BPMP_ENOENT	2
3020 /** @brief No MRQ handler */
3021 #define BPMP_ENOHANDLER	3
3022 /** @brief I/O error */
3023 #define BPMP_EIO	5
3024 /** @brief Bad sub-MRQ command */
3025 #define BPMP_EBADCMD	6
3026 /** @brief Resource temporarily unavailable */
3027 #define BPMP_EAGAIN	11
3028 /** @brief Not enough memory */
3029 #define BPMP_ENOMEM	12
3030 /** @brief Permission denied */
3031 #define BPMP_EACCES	13
3032 /** @brief Bad address */
3033 #define BPMP_EFAULT	14
3034 /** @brief Resource busy */
3035 #define BPMP_EBUSY	16
3036 /** @brief No such device */
3037 #define BPMP_ENODEV	19
3038 /** @brief Argument is a directory */
3039 #define BPMP_EISDIR	21
3040 /** @brief Invalid argument */
3041 #define BPMP_EINVAL	22
3042 /** @brief Timeout during operation */
3043 #define BPMP_ETIMEDOUT  23
3044 /** @brief Out of range */
3045 #define BPMP_ERANGE	34
3046 /** @brief Function not implemented */
3047 #define BPMP_ENOSYS	38
3048 /** @brief Invalid slot */
3049 #define BPMP_EBADSLT	57
3050 /** @brief Not supported */
3051 #define BPMP_ENOTSUP	134
3052 /** @brief No such device or address */
3053 #define BPMP_ENXIO	140
3054 
3055 /** @} */
3056 
3057 #if defined(BPMP_ABI_CHECKS)
3058 #include "bpmp_abi_checks.h"
3059 #endif
3060 
3061 #endif
3062