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 */ 83struct 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 */ 107struct 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 */ 234struct 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 */ 248struct 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 */ 275struct 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 */ 302struct 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 */ 340struct 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 */ 353struct 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 */ 381struct 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 */ 411struct 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 */ 427struct 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 */ 467struct 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 */ 481struct 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 */ 492struct mrq_threaded_ping_request { 493 uint32_t challenge; 494} BPMP_ABI_PACKED; 495 496/** @private */ 497struct 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 */ 520struct 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 */ 535struct 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 */ 583enum 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 */ 598struct 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 */ 613struct 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 */ 624struct 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 */ 635struct 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 */ 657struct 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 */ 669struct 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 */ 711enum 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 */ 747struct 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 */ 758struct 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 */ 771struct 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 */ 790struct 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 */ 809struct 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 */ 824struct 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 */ 848struct 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 */ 866struct 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 890enum 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 */ 936struct 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 */ 948struct 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 */ 967struct 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 1001enum { 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*/ 1020struct 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 */ 1034struct 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 */ 1052struct 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 */ 1062struct 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 */ 1083struct 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 */ 1103enum { 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 */ 1127struct cmd_clk_get_rate_request { 1128 BPMP_ABI_EMPTY 1129} BPMP_ABI_PACKED; 1130 1131struct cmd_clk_get_rate_response { 1132 int64_t rate; 1133} BPMP_ABI_PACKED; 1134 1135struct cmd_clk_set_rate_request { 1136 int32_t unused; 1137 int64_t rate; 1138} BPMP_ABI_PACKED; 1139 1140struct cmd_clk_set_rate_response { 1141 int64_t rate; 1142} BPMP_ABI_PACKED; 1143 1144struct cmd_clk_round_rate_request { 1145 int32_t unused; 1146 int64_t rate; 1147} BPMP_ABI_PACKED; 1148 1149struct cmd_clk_round_rate_response { 1150 int64_t rate; 1151} BPMP_ABI_PACKED; 1152 1153/** @private */ 1154struct cmd_clk_get_parent_request { 1155 BPMP_ABI_EMPTY 1156} BPMP_ABI_PACKED; 1157 1158struct cmd_clk_get_parent_response { 1159 uint32_t parent_id; 1160} BPMP_ABI_PACKED; 1161 1162struct cmd_clk_set_parent_request { 1163 uint32_t parent_id; 1164} BPMP_ABI_PACKED; 1165 1166struct cmd_clk_set_parent_response { 1167 uint32_t parent_id; 1168} BPMP_ABI_PACKED; 1169 1170/** @private */ 1171struct 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 */ 1178struct 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 */ 1194struct cmd_clk_enable_request { 1195 BPMP_ABI_EMPTY 1196} BPMP_ABI_PACKED; 1197 1198/** @private */ 1199struct cmd_clk_enable_response { 1200 BPMP_ABI_EMPTY 1201} BPMP_ABI_PACKED; 1202 1203/** @private */ 1204struct cmd_clk_disable_request { 1205 BPMP_ABI_EMPTY 1206} BPMP_ABI_PACKED; 1207 1208/** @private */ 1209struct cmd_clk_disable_response { 1210 BPMP_ABI_EMPTY 1211} BPMP_ABI_PACKED; 1212 1213/** @private */ 1214struct cmd_clk_get_all_info_request { 1215 BPMP_ABI_EMPTY 1216} BPMP_ABI_PACKED; 1217 1218struct 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 */ 1227struct cmd_clk_get_max_clk_id_request { 1228 BPMP_ABI_EMPTY 1229} BPMP_ABI_PACKED; 1230 1231struct cmd_clk_get_max_clk_id_response { 1232 uint32_t max_id; 1233} BPMP_ABI_PACKED; 1234 1235/** @private */ 1236struct cmd_clk_get_fmax_at_vmin_request { 1237 BPMP_ABI_EMPTY 1238} BPMP_ABI_PACKED; 1239 1240struct 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 1270struct 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 1324struct 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 */ 1363struct 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 */ 1375struct 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 */ 1400struct 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 */ 1410struct 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 */ 1444struct 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 */ 1492enum 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 1547enum 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 1561struct cmd_pg_query_abi_request { 1562 /** @ref mrq_pg_cmd */ 1563 uint32_t type; 1564} BPMP_ABI_PACKED; 1565 1566struct 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 */ 1574struct 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 1589struct cmd_pg_get_name_response { 1590 uint8_t name[MRQ_PG_NAME_MAXLEN]; 1591} BPMP_ABI_PACKED; 1592 1593struct 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 */ 1614struct 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 */ 1638struct 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 */ 1681enum 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 1753enum 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 */ 1775struct 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 */ 1784struct 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 */ 1797struct 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 */ 1809struct 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 */ 1821struct 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 */ 1831struct 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 */ 1840struct 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 */ 1849struct 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 */ 1861struct 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 */ 1877struct 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 */ 1887union 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 */ 1918struct 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 */ 1931struct 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 */ 1995struct 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 */ 2015struct 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 */ 2038struct 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 */ 2049struct 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 */ 2076struct 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 */ 2084struct 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 */ 2124struct 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 */ 2132struct 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 */ 2161enum { 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 */ 2171struct 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 2210enum 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 */ 2247struct cmd_ringbuf_console_query_abi_req { 2248 /** @brief Command identifier to be queried */ 2249 uint32_t cmd; 2250} BPMP_ABI_PACKED; 2251 2252/** @private */ 2253struct 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 */ 2261struct 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 */ 2272struct 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 */ 2283struct 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 */ 2294struct 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 */ 2302struct 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 */ 2310struct 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 */ 2327struct 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 */ 2348union 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 */ 2380enum 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 */ 2390struct 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 */ 2420enum { 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 2429struct 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 2442struct cmd_uphy_margin_status_response { 2443 /** @brief Number of errors observed */ 2444 uint32_t status; 2445} BPMP_ABI_PACKED; 2446 2447struct 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 2452struct 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 2458struct 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 2481struct 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 2510struct 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 */ 2534enum { 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 2561struct cmd_fmon_gear_clamp_request { 2562 int32_t unused; 2563 int64_t rate; 2564} BPMP_ABI_PACKED; 2565 2566/** @private */ 2567struct cmd_fmon_gear_clamp_response { 2568 BPMP_ABI_EMPTY 2569} BPMP_ABI_PACKED; 2570 2571/** @private */ 2572struct cmd_fmon_gear_free_request { 2573 BPMP_ABI_EMPTY 2574} BPMP_ABI_PACKED; 2575 2576/** @private */ 2577struct cmd_fmon_gear_free_response { 2578 BPMP_ABI_EMPTY 2579} BPMP_ABI_PACKED; 2580 2581/** @private */ 2582struct cmd_fmon_gear_get_request { 2583 BPMP_ABI_EMPTY 2584} BPMP_ABI_PACKED; 2585 2586struct 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 2607struct 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 2639struct 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 */ 2670enum { 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 */ 2697enum 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. */ 2772enum 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 */ 2808struct 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 */ 2824struct 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 */ 2840struct 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 */ 2855struct 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 */ 2875struct 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 */ 2883union 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 2891struct 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 */ 2902struct 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 2922struct 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 2966struct 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 2994struct mrq_ec_response { 2995 union { 2996 /** 2997 * @cond DEPRECATED 2998 */ 2999 struct cmd_ec_status_get_response ec_status_get; 3000 /** @endcond */ 3001 struct cmd_ec_status_ex_get_response ec_status_ex_get; 3002 } BPMP_UNION_ANON; 3003} BPMP_ABI_PACKED; 3004 3005/** @} */ 3006/** @endcond */ 3007 3008/** 3009 * @addtogroup Error_Codes 3010 * Negative values for mrq_response::err generally indicate some 3011 * error. The ABI defines the following error codes. Negating these 3012 * defines is an exercise left to the user. 3013 * @{ 3014 */ 3015 3016/** @brief Operation not permitted */ 3017#define BPMP_EPERM 1 3018/** @brief No such file or directory */ 3019#define BPMP_ENOENT 2 3020/** @brief No MRQ handler */ 3021#define BPMP_ENOHANDLER 3 3022/** @brief I/O error */ 3023#define BPMP_EIO 5 3024/** @brief Bad sub-MRQ command */ 3025#define BPMP_EBADCMD 6 3026/** @brief Resource temporarily unavailable */ 3027#define BPMP_EAGAIN 11 3028/** @brief Not enough memory */ 3029#define BPMP_ENOMEM 12 3030/** @brief Permission denied */ 3031#define BPMP_EACCES 13 3032/** @brief Bad address */ 3033#define BPMP_EFAULT 14 3034/** @brief Resource busy */ 3035#define BPMP_EBUSY 16 3036/** @brief No such device */ 3037#define BPMP_ENODEV 19 3038/** @brief Argument is a directory */ 3039#define BPMP_EISDIR 21 3040/** @brief Invalid argument */ 3041#define BPMP_EINVAL 22 3042/** @brief Timeout during operation */ 3043#define BPMP_ETIMEDOUT 23 3044/** @brief Out of range */ 3045#define BPMP_ERANGE 34 3046/** @brief Function not implemented */ 3047#define BPMP_ENOSYS 38 3048/** @brief Invalid slot */ 3049#define BPMP_EBADSLT 57 3050/** @brief Not supported */ 3051#define BPMP_ENOTSUP 134 3052/** @brief No such device or address */ 3053#define BPMP_ENXIO 140 3054 3055/** @} */ 3056 3057#if defined(BPMP_ABI_CHECKS) 3058#include "bpmp_abi_checks.h" 3059#endif 3060 3061#endif 3062