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