Merge tag 'gpio-v5.11-1' of git://git.kernel.org/pub/scm/linux/kernel/git/linusw...
[linux-2.6-microblaze.git] / include / soc / tegra / bpmp-abi.h
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 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