1 /* 2 * Copyright (c) 2014-2016, NVIDIA CORPORATION. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or modify it 5 * under the terms and conditions of the GNU General Public License, 6 * version 2, as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope it will be useful, but WITHOUT 9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 11 * more details. 12 * 13 * You should have received a copy of the GNU General Public License 14 * along with this program. If not, see <http://www.gnu.org/licenses/>. 15 */ 16 17 #ifndef _ABI_BPMP_ABI_H_ 18 #define _ABI_BPMP_ABI_H_ 19 20 #ifdef LK 21 #include <stdint.h> 22 #endif 23 24 #ifndef __ABI_PACKED 25 #define __ABI_PACKED __attribute__((packed)) 26 #endif 27 28 #ifdef NO_GCC_EXTENSIONS 29 #define EMPTY char empty; 30 #define EMPTY_ARRAY 1 31 #else 32 #define EMPTY 33 #define EMPTY_ARRAY 0 34 #endif 35 36 #ifndef __UNION_ANON 37 #define __UNION_ANON 38 #endif 39 /** 40 * @file 41 */ 42 43 44 /** 45 * @defgroup MRQ MRQ Messages 46 * @brief Messages sent to/from BPMP via IPC 47 * @{ 48 * @defgroup MRQ_Format Message Format 49 * @defgroup MRQ_Codes Message Request (MRQ) Codes 50 * @defgroup MRQ_Payloads Message Payloads 51 * @defgroup Error_Codes Error Codes 52 * @} 53 */ 54 55 /** 56 * @addtogroup MRQ_Format Message Format 57 * @{ 58 * The CPU requests the BPMP to perform a particular service by 59 * sending it an IVC frame containing a single MRQ message. An MRQ 60 * message consists of a @ref mrq_request followed by a payload whose 61 * format depends on mrq_request::mrq. 62 * 63 * The BPMP processes the data and replies with an IVC frame (on the 64 * same IVC channel) containing and MRQ response. An MRQ response 65 * consists of a @ref mrq_response followed by a payload whose format 66 * depends on the associated mrq_request::mrq. 67 * 68 * A well-defined subset of the MRQ messages that the CPU sends to the 69 * BPMP can lead to BPMP eventually sending an MRQ message to the 70 * CPU. For example, when the CPU uses an #MRQ_THERMAL message to set 71 * a thermal trip point, the BPMP may eventually send a single 72 * #MRQ_THERMAL message of its own to the CPU indicating that the trip 73 * point has been crossed. 74 * @} 75 */ 76 77 /** 78 * @ingroup MRQ_Format 79 * @brief header for an MRQ message 80 * 81 * Provides the MRQ number for the MRQ message: #mrq. The remainder of 82 * the MRQ message is a payload (immediately following the 83 * mrq_request) whose format depends on mrq. 84 * 85 * @todo document the flags 86 */ 87 struct mrq_request { 88 /** @brief MRQ number of the request */ 89 uint32_t mrq; 90 /** @brief flags for the request */ 91 uint32_t flags; 92 } __ABI_PACKED; 93 94 /** 95 * @ingroup MRQ_Format 96 * @brief header for an MRQ response 97 * 98 * Provides an error code for the associated MRQ message. The 99 * remainder of the MRQ response is a payload (immediately following 100 * the mrq_response) whose format depends on the associated 101 * mrq_request::mrq 102 * 103 * @todo document the flags 104 */ 105 struct mrq_response { 106 /** @brief error code for the MRQ request itself */ 107 int32_t err; 108 /** @brief flags for the response */ 109 uint32_t flags; 110 } __ABI_PACKED; 111 112 /** 113 * @ingroup MRQ_Format 114 * Minimum needed size for an IPC message buffer 115 */ 116 #define MSG_MIN_SZ 128 117 /** 118 * @ingroup MRQ_Format 119 * Minimum size guaranteed for data in an IPC message buffer 120 */ 121 #define MSG_DATA_MIN_SZ 120 122 123 /** 124 * @ingroup MRQ_Codes 125 * @name Legal MRQ codes 126 * These are the legal values for mrq_request::mrq 127 * @{ 128 */ 129 130 #define MRQ_PING 0 131 #define MRQ_QUERY_TAG 1 132 #define MRQ_MODULE_LOAD 4 133 #define MRQ_MODULE_UNLOAD 5 134 #define MRQ_TRACE_MODIFY 7 135 #define MRQ_WRITE_TRACE 8 136 #define MRQ_THREADED_PING 9 137 #define MRQ_MODULE_MAIL 11 138 #define MRQ_DEBUGFS 19 139 #define MRQ_RESET 20 140 #define MRQ_I2C 21 141 #define MRQ_CLK 22 142 #define MRQ_QUERY_ABI 23 143 #define MRQ_PG_READ_STATE 25 144 #define MRQ_PG_UPDATE_STATE 26 145 #define MRQ_THERMAL 27 146 #define MRQ_CPU_VHINT 28 147 #define MRQ_ABI_RATCHET 29 148 #define MRQ_EMC_DVFS_LATENCY 31 149 #define MRQ_TRACE_ITER 64 150 151 /** @} */ 152 153 /** 154 * @ingroup MRQ_Codes 155 * @brief Maximum MRQ code to be sent by CPU software to 156 * BPMP. Subject to change in future 157 */ 158 #define MAX_CPU_MRQ_ID 64 159 160 /** 161 * @addtogroup MRQ_Payloads Message Payloads 162 * @{ 163 * @defgroup Ping 164 * @defgroup Query_Tag Query Tag 165 * @defgroup Module Loadable Modules 166 * @defgroup Trace 167 * @defgroup Debugfs 168 * @defgroup Reset 169 * @defgroup I2C 170 * @defgroup Clocks 171 * @defgroup ABI_info ABI Info 172 * @defgroup MC_Flush MC Flush 173 * @defgroup Powergating 174 * @defgroup Thermal 175 * @defgroup Vhint CPU Voltage hint 176 * @defgroup MRQ_Deprecated Deprecated MRQ messages 177 * @defgroup EMC 178 * @} 179 */ 180 181 182 /** 183 * @ingroup MRQ_Codes 184 * @def MRQ_PING 185 * @brief A simple ping 186 * 187 * * Platforms: All 188 * * Initiators: Any 189 * * Targets: Any 190 * * Request Payload: @ref mrq_ping_request 191 * * Response Payload: @ref mrq_ping_response 192 * 193 * @ingroup MRQ_Codes 194 * @def MRQ_THREADED_PING 195 * @brief A deeper ping 196 * 197 * * Platforms: All 198 * * Initiators: Any 199 * * Targets: BPMP 200 * * Request Payload: @ref mrq_ping_request 201 * * Response Payload: @ref mrq_ping_response 202 * 203 * Behavior is equivalent to a simple #MRQ_PING except that BPMP 204 * responds from a thread context (providing a slightly more robust 205 * sign of life). 206 * 207 */ 208 209 /** 210 * @ingroup Ping 211 * @brief request with #MRQ_PING 212 * 213 * Used by the sender of an #MRQ_PING message to request a pong from 214 * recipient. The response from the recipient is computed based on 215 * #challenge. 216 */ 217 struct mrq_ping_request { 218 /** @brief arbitrarily chosen value */ 219 uint32_t challenge; 220 } __ABI_PACKED; 221 222 /** 223 * @ingroup Ping 224 * @brief response to #MRQ_PING 225 * 226 * Sent in response to an #MRQ_PING message. #reply should be the 227 * mrq_ping_request challenge left shifted by 1 with the carry-bit 228 * dropped. 229 * 230 */ 231 struct mrq_ping_response { 232 /** @brief response to the MRQ_PING challege */ 233 uint32_t reply; 234 } __ABI_PACKED; 235 236 /** 237 * @ingroup MRQ_Codes 238 * @def MRQ_QUERY_TAG 239 * @brief Query BPMP firmware's tag (i.e. version information) 240 * 241 * * Platforms: All 242 * * Initiators: CCPLEX 243 * * Targets: BPMP 244 * * Request Payload: @ref mrq_query_tag_request 245 * * Response Payload: N/A 246 * 247 */ 248 249 /** 250 * @ingroup Query_Tag 251 * @brief request with #MRQ_QUERY_TAG 252 * 253 * Used by #MRQ_QUERY_TAG call to ask BPMP to fill in the memory 254 * pointed by #addr with BPMP firmware header. 255 * 256 * The sender is reponsible for ensuring that #addr is mapped in to 257 * the recipient's address map. 258 */ 259 struct mrq_query_tag_request { 260 /** @brief base address to store the firmware header */ 261 uint32_t addr; 262 } __ABI_PACKED; 263 264 /** 265 * @ingroup MRQ_Codes 266 * @def MRQ_MODULE_LOAD 267 * @brief dynamically load a BPMP code module 268 * 269 * * Platforms: All 270 * * Initiators: CCPLEX 271 * * Targets: BPMP 272 * * Request Payload: @ref mrq_module_load_request 273 * * Response Payload: @ref mrq_module_load_response 274 * 275 * @note This MRQ is disabled on production systems 276 * 277 */ 278 279 /** 280 * @ingroup Module 281 * @brief request with #MRQ_MODULE_LOAD 282 * 283 * Used by #MRQ_MODULE_LOAD calls to ask the recipient to dynamically 284 * load the code located at #phys_addr and having size #size 285 * bytes. #phys_addr is treated as a void pointer. 286 * 287 * The recipient copies the code from #phys_addr to locally allocated 288 * memory prior to responding to this message. 289 * 290 * @todo document the module header format 291 * 292 * The sender is responsible for ensuring that the code is mapped in 293 * the recipient's address map. 294 * 295 */ 296 struct mrq_module_load_request { 297 /** @brief base address of the code to load. Treated as (void *) */ 298 uint32_t phys_addr; /* (void *) */ 299 /** @brief size in bytes of code to load */ 300 uint32_t size; 301 } __ABI_PACKED; 302 303 /** 304 * @ingroup Module 305 * @brief response to #MRQ_MODULE_LOAD 306 * 307 * @todo document mrq_response::err 308 */ 309 struct mrq_module_load_response { 310 /** @brief handle to the loaded module */ 311 uint32_t base; 312 } __ABI_PACKED; 313 314 /** 315 * @ingroup MRQ_Codes 316 * @def MRQ_MODULE_UNLOAD 317 * @brief unload a previously loaded code module 318 * 319 * * Platforms: All 320 * * Initiators: CCPLEX 321 * * Targets: BPMP 322 * * Request Payload: @ref mrq_module_unload_request 323 * * Response Payload: N/A 324 * 325 * @note This MRQ is disabled on production systems 326 */ 327 328 /** 329 * @ingroup Module 330 * @brief request with #MRQ_MODULE_UNLOAD 331 * 332 * Used by #MRQ_MODULE_UNLOAD calls to request that a previously loaded 333 * module be unloaded. 334 */ 335 struct mrq_module_unload_request { 336 /** @brief handle of the module to unload */ 337 uint32_t base; 338 } __ABI_PACKED; 339 340 /** 341 * @ingroup MRQ_Codes 342 * @def MRQ_TRACE_MODIFY 343 * @brief modify the set of enabled trace events 344 * 345 * * Platforms: All 346 * * Initiators: CCPLEX 347 * * Targets: BPMP 348 * * Request Payload: @ref mrq_trace_modify_request 349 * * Response Payload: @ref mrq_trace_modify_response 350 * 351 * @note This MRQ is disabled on production systems 352 */ 353 354 /** 355 * @ingroup Trace 356 * @brief request with #MRQ_TRACE_MODIFY 357 * 358 * Used by %MRQ_TRACE_MODIFY calls to enable or disable specify trace 359 * events. #set takes precedence for any bit set in both #set and 360 * #clr. 361 */ 362 struct mrq_trace_modify_request { 363 /** @brief bit mask of trace events to disable */ 364 uint32_t clr; 365 /** @brief bit mask of trace events to enable */ 366 uint32_t set; 367 } __ABI_PACKED; 368 369 /** 370 * @ingroup Trace 371 * @brief response to #MRQ_TRACE_MODIFY 372 * 373 * Sent in repsonse to an #MRQ_TRACE_MODIFY message. #mask reflects the 374 * state of which events are enabled after the recipient acted on the 375 * message. 376 * 377 */ 378 struct mrq_trace_modify_response { 379 /** @brief bit mask of trace event enable states */ 380 uint32_t mask; 381 } __ABI_PACKED; 382 383 /** 384 * @ingroup MRQ_Codes 385 * @def MRQ_WRITE_TRACE 386 * @brief Write trace data to a buffer 387 * 388 * * Platforms: All 389 * * Initiators: CCPLEX 390 * * Targets: BPMP 391 * * Request Payload: @ref mrq_write_trace_request 392 * * Response Payload: @ref mrq_write_trace_response 393 * 394 * mrq_response::err depends on the @ref mrq_write_trace_request field 395 * values. err is -#BPMP_EINVAL if size is zero or area is NULL or 396 * area is in an illegal range. A positive value for err indicates the 397 * number of bytes written to area. 398 * 399 * @note This MRQ is disabled on production systems 400 */ 401 402 /** 403 * @ingroup Trace 404 * @brief request with #MRQ_WRITE_TRACE 405 * 406 * Used by MRQ_WRITE_TRACE calls to ask the recipient to copy trace 407 * data from the recipient's local buffer to the output buffer. #area 408 * is treated as a byte-aligned pointer in the recipient's address 409 * space. 410 * 411 * The sender is responsible for ensuring that the output 412 * buffer is mapped in the recipient's address map. The recipient is 413 * responsible for protecting its own code and data from accidental 414 * overwrites. 415 */ 416 struct mrq_write_trace_request { 417 /** @brief base address of output buffer */ 418 uint32_t area; 419 /** @brief size in bytes of the output buffer */ 420 uint32_t size; 421 } __ABI_PACKED; 422 423 /** 424 * @ingroup Trace 425 * @brief response to #MRQ_WRITE_TRACE 426 * 427 * Once this response is sent, the respondent will not access the 428 * output buffer further. 429 */ 430 struct mrq_write_trace_response { 431 /** 432 * @brief flag whether more data remains in local buffer 433 * 434 * Value is 1 if the entire local trace buffer has been 435 * drained to the outputbuffer. Value is 0 otherwise. 436 */ 437 uint32_t eof; 438 } __ABI_PACKED; 439 440 /** @private */ 441 struct mrq_threaded_ping_request { 442 uint32_t challenge; 443 } __ABI_PACKED; 444 445 /** @private */ 446 struct mrq_threaded_ping_response { 447 uint32_t reply; 448 } __ABI_PACKED; 449 450 /** 451 * @ingroup MRQ_Codes 452 * @def MRQ_MODULE_MAIL 453 * @brief send a message to a loadable module 454 * 455 * * Platforms: All 456 * * Initiators: Any 457 * * Targets: BPMP 458 * * Request Payload: @ref mrq_module_mail_request 459 * * Response Payload: @ref mrq_module_mail_response 460 * 461 * @note This MRQ is disabled on production systems 462 */ 463 464 /** 465 * @ingroup Module 466 * @brief request with #MRQ_MODULE_MAIL 467 */ 468 struct mrq_module_mail_request { 469 /** @brief handle to the previously loaded module */ 470 uint32_t base; 471 /** @brief module-specific mail payload 472 * 473 * The length of data[ ] is unknown to the BPMP core firmware 474 * but it is limited to the size of an IPC message. 475 */ 476 uint8_t data[EMPTY_ARRAY]; 477 } __ABI_PACKED; 478 479 /** 480 * @ingroup Module 481 * @brief response to #MRQ_MODULE_MAIL 482 */ 483 struct mrq_module_mail_response { 484 /** @brief module-specific mail payload 485 * 486 * The length of data[ ] is unknown to the BPMP core firmware 487 * but it is limited to the size of an IPC message. 488 */ 489 uint8_t data[EMPTY_ARRAY]; 490 } __ABI_PACKED; 491 492 /** 493 * @ingroup MRQ_Codes 494 * @def MRQ_DEBUGFS 495 * @brief Interact with BPMP's debugfs file nodes 496 * 497 * * Platforms: T186 498 * * Initiators: Any 499 * * Targets: BPMP 500 * * Request Payload: @ref mrq_debugfs_request 501 * * Response Payload: @ref mrq_debugfs_response 502 */ 503 504 /** 505 * @addtogroup Debugfs 506 * @{ 507 * 508 * The BPMP firmware implements a pseudo-filesystem called 509 * debugfs. Any driver within the firmware may register with debugfs 510 * to expose an arbitrary set of "files" in the filesystem. When 511 * software on the CPU writes to a debugfs file, debugfs passes the 512 * written data to a callback provided by the driver. When software on 513 * the CPU reads a debugfs file, debugfs queries the driver for the 514 * data to return to the CPU. The intention of the debugfs filesystem 515 * is to provide information useful for debugging the system at 516 * runtime. 517 * 518 * @note The files exposed via debugfs are not part of the 519 * BPMP firmware's ABI. debugfs files may be added or removed in any 520 * given version of the firmware. Typically the semantics of a debugfs 521 * file are consistent from version to version but even that is not 522 * guaranteed. 523 * 524 * @} 525 */ 526 /** @ingroup Debugfs */ 527 enum mrq_debugfs_commands { 528 CMD_DEBUGFS_READ = 1, 529 CMD_DEBUGFS_WRITE = 2, 530 CMD_DEBUGFS_DUMPDIR = 3, 531 CMD_DEBUGFS_MAX 532 }; 533 534 /** 535 * @ingroup Debugfs 536 * @brief parameters for CMD_DEBUGFS_READ/WRITE command 537 */ 538 struct cmd_debugfs_fileop_request { 539 /** @brief physical address pointing at filename */ 540 uint32_t fnameaddr; 541 /** @brief length in bytes of filename buffer */ 542 uint32_t fnamelen; 543 /** @brief physical address pointing to data buffer */ 544 uint32_t dataaddr; 545 /** @brief length in bytes of data buffer */ 546 uint32_t datalen; 547 } __ABI_PACKED; 548 549 /** 550 * @ingroup Debugfs 551 * @brief parameters for CMD_DEBUGFS_READ/WRITE command 552 */ 553 struct cmd_debugfs_dumpdir_request { 554 /** @brief physical address pointing to data buffer */ 555 uint32_t dataaddr; 556 /** @brief length in bytes of data buffer */ 557 uint32_t datalen; 558 } __ABI_PACKED; 559 560 /** 561 * @ingroup Debugfs 562 * @brief response data for CMD_DEBUGFS_READ/WRITE command 563 */ 564 struct cmd_debugfs_fileop_response { 565 /** @brief always 0 */ 566 uint32_t reserved; 567 /** @brief number of bytes read from or written to data buffer */ 568 uint32_t nbytes; 569 } __ABI_PACKED; 570 571 /** 572 * @ingroup Debugfs 573 * @brief response data for CMD_DEBUGFS_DUMPDIR command 574 */ 575 struct cmd_debugfs_dumpdir_response { 576 /** @brief always 0 */ 577 uint32_t reserved; 578 /** @brief number of bytes read from or written to data buffer */ 579 uint32_t nbytes; 580 } __ABI_PACKED; 581 582 /** 583 * @ingroup Debugfs 584 * @brief request with #MRQ_DEBUGFS. 585 * 586 * The sender of an MRQ_DEBUGFS message uses #cmd to specify a debugfs 587 * command to execute. Legal commands are the values of @ref 588 * mrq_debugfs_commands. Each command requires a specific additional 589 * payload of data. 590 * 591 * |command |payload| 592 * |-------------------|-------| 593 * |CMD_DEBUGFS_READ |fop | 594 * |CMD_DEBUGFS_WRITE |fop | 595 * |CMD_DEBUGFS_DUMPDIR|dumpdir| 596 */ 597 struct mrq_debugfs_request { 598 uint32_t cmd; 599 union { 600 struct cmd_debugfs_fileop_request fop; 601 struct cmd_debugfs_dumpdir_request dumpdir; 602 } __UNION_ANON; 603 } __ABI_PACKED; 604 605 /** 606 * @ingroup Debugfs 607 */ 608 struct mrq_debugfs_response { 609 /** @brief always 0 */ 610 int32_t reserved; 611 union { 612 /** @brief response data for CMD_DEBUGFS_READ OR 613 * CMD_DEBUGFS_WRITE command 614 */ 615 struct cmd_debugfs_fileop_response fop; 616 /** @brief response data for CMD_DEBUGFS_DUMPDIR command */ 617 struct cmd_debugfs_dumpdir_response dumpdir; 618 } __UNION_ANON; 619 } __ABI_PACKED; 620 621 /** 622 * @addtogroup Debugfs 623 * @{ 624 */ 625 #define DEBUGFS_S_ISDIR (1 << 9) 626 #define DEBUGFS_S_IRUSR (1 << 8) 627 #define DEBUGFS_S_IWUSR (1 << 7) 628 /** @} */ 629 630 631 /** 632 * @ingroup MRQ_Codes 633 * @def MRQ_RESET 634 * @brief reset an IP block 635 * 636 * * Platforms: T186 637 * * Initiators: Any 638 * * Targets: BPMP 639 * * Request Payload: @ref mrq_reset_request 640 * * Response Payload: N/A 641 */ 642 643 /** 644 * @ingroup Reset 645 */ 646 enum mrq_reset_commands { 647 CMD_RESET_ASSERT = 1, 648 CMD_RESET_DEASSERT = 2, 649 CMD_RESET_MODULE = 3, 650 CMD_RESET_MAX, /* not part of ABI and subject to change */ 651 }; 652 653 /** 654 * @ingroup Reset 655 * @brief request with MRQ_RESET 656 * 657 * Used by the sender of an #MRQ_RESET message to request BPMP to 658 * assert or or deassert a given reset line. 659 */ 660 struct mrq_reset_request { 661 /** @brief reset action to perform (@enum mrq_reset_commands) */ 662 uint32_t cmd; 663 /** @brief id of the reset to affected */ 664 uint32_t reset_id; 665 } __ABI_PACKED; 666 667 /** 668 * @ingroup MRQ_Codes 669 * @def MRQ_I2C 670 * @brief issue an i2c transaction 671 * 672 * * Platforms: T186 673 * * Initiators: Any 674 * * Targets: BPMP 675 * * Request Payload: @ref mrq_i2c_request 676 * * Response Payload: @ref mrq_i2c_response 677 */ 678 679 /** 680 * @addtogroup I2C 681 * @{ 682 */ 683 #define TEGRA_I2C_IPC_MAX_IN_BUF_SIZE (MSG_DATA_MIN_SZ - 12) 684 #define TEGRA_I2C_IPC_MAX_OUT_BUF_SIZE (MSG_DATA_MIN_SZ - 4) 685 /** @} */ 686 687 /** 688 * @ingroup I2C 689 * @name Serial I2C flags 690 * Use these flags with serial_i2c_request::flags 691 * @{ 692 */ 693 #define SERIALI2C_TEN 0x0010 694 #define SERIALI2C_RD 0x0001 695 #define SERIALI2C_STOP 0x8000 696 #define SERIALI2C_NOSTART 0x4000 697 #define SERIALI2C_REV_DIR_ADDR 0x2000 698 #define SERIALI2C_IGNORE_NAK 0x1000 699 #define SERIALI2C_NO_RD_ACK 0x0800 700 #define SERIALI2C_RECV_LEN 0x0400 701 /** @} */ 702 /** @ingroup I2C */ 703 enum { 704 CMD_I2C_XFER = 1 705 }; 706 707 /** 708 * @ingroup I2C 709 * @brief serializable i2c request 710 * 711 * Instances of this structure are packed (little-endian) into 712 * cmd_i2c_xfer_request::data_buf. Each instance represents a single 713 * transaction (or a portion of a transaction with repeated starts) on 714 * an i2c bus. 715 * 716 * Because these structures are packed, some instances are likely to 717 * be misaligned. Additionally because #data is variable length, it is 718 * not possible to iterate through a serialized list of these 719 * structures without inspecting #len in each instance. It may be 720 * easier to serialize or deserialize cmd_i2c_xfer_request::data_buf 721 * manually rather than using this structure definition. 722 */ 723 struct serial_i2c_request { 724 /** @brief I2C slave address */ 725 uint16_t addr; 726 /** @brief bitmask of SERIALI2C_ flags */ 727 uint16_t flags; 728 /** @brief length of I2C transaction in bytes */ 729 uint16_t len; 730 /** @brief for write transactions only, #len bytes of data */ 731 uint8_t data[]; 732 } __ABI_PACKED; 733 734 /** 735 * @ingroup I2C 736 * @brief trigger one or more i2c transactions 737 */ 738 struct cmd_i2c_xfer_request { 739 /** @brief valid bus number from mach-t186/i2c-t186.h*/ 740 uint32_t bus_id; 741 742 /** @brief count of valid bytes in #data_buf*/ 743 uint32_t data_size; 744 745 /** @brief serialized packed instances of @ref serial_i2c_request*/ 746 uint8_t data_buf[TEGRA_I2C_IPC_MAX_IN_BUF_SIZE]; 747 } __ABI_PACKED; 748 749 /** 750 * @ingroup I2C 751 * @brief container for data read from the i2c bus 752 * 753 * Processing an cmd_i2c_xfer_request::data_buf causes BPMP to execute 754 * zero or more I2C reads. The data read from the bus is serialized 755 * into #data_buf. 756 */ 757 struct cmd_i2c_xfer_response { 758 /** @brief count of valid bytes in #data_buf*/ 759 uint32_t data_size; 760 /** @brief i2c read data */ 761 uint8_t data_buf[TEGRA_I2C_IPC_MAX_OUT_BUF_SIZE]; 762 } __ABI_PACKED; 763 764 /** 765 * @ingroup I2C 766 * @brief request with #MRQ_I2C 767 */ 768 struct mrq_i2c_request { 769 /** @brief always CMD_I2C_XFER (i.e. 1) */ 770 uint32_t cmd; 771 /** @brief parameters of the transfer request */ 772 struct cmd_i2c_xfer_request xfer; 773 } __ABI_PACKED; 774 775 /** 776 * @ingroup I2C 777 * @brief response to #MRQ_I2C 778 */ 779 struct mrq_i2c_response { 780 struct cmd_i2c_xfer_response xfer; 781 } __ABI_PACKED; 782 783 /** 784 * @ingroup MRQ_Codes 785 * @def MRQ_CLK 786 * 787 * * Platforms: T186 788 * * Initiators: Any 789 * * Targets: BPMP 790 * * Request Payload: @ref mrq_clk_request 791 * * Response Payload: @ref mrq_clk_response 792 * @addtogroup Clocks 793 * @{ 794 */ 795 796 /** 797 * @name MRQ_CLK sub-commands 798 * @{ 799 */ 800 enum { 801 CMD_CLK_GET_RATE = 1, 802 CMD_CLK_SET_RATE = 2, 803 CMD_CLK_ROUND_RATE = 3, 804 CMD_CLK_GET_PARENT = 4, 805 CMD_CLK_SET_PARENT = 5, 806 CMD_CLK_IS_ENABLED = 6, 807 CMD_CLK_ENABLE = 7, 808 CMD_CLK_DISABLE = 8, 809 CMD_CLK_GET_ALL_INFO = 14, 810 CMD_CLK_GET_MAX_CLK_ID = 15, 811 CMD_CLK_MAX, 812 }; 813 /** @} */ 814 815 #define MRQ_CLK_NAME_MAXLEN 40 816 #define MRQ_CLK_MAX_PARENTS 16 817 818 /** @private */ 819 struct cmd_clk_get_rate_request { 820 EMPTY 821 } __ABI_PACKED; 822 823 struct cmd_clk_get_rate_response { 824 int64_t rate; 825 } __ABI_PACKED; 826 827 struct cmd_clk_set_rate_request { 828 int32_t unused; 829 int64_t rate; 830 } __ABI_PACKED; 831 832 struct cmd_clk_set_rate_response { 833 int64_t rate; 834 } __ABI_PACKED; 835 836 struct cmd_clk_round_rate_request { 837 int32_t unused; 838 int64_t rate; 839 } __ABI_PACKED; 840 841 struct cmd_clk_round_rate_response { 842 int64_t rate; 843 } __ABI_PACKED; 844 845 /** @private */ 846 struct cmd_clk_get_parent_request { 847 EMPTY 848 } __ABI_PACKED; 849 850 struct cmd_clk_get_parent_response { 851 uint32_t parent_id; 852 } __ABI_PACKED; 853 854 struct cmd_clk_set_parent_request { 855 uint32_t parent_id; 856 } __ABI_PACKED; 857 858 struct cmd_clk_set_parent_response { 859 uint32_t parent_id; 860 } __ABI_PACKED; 861 862 /** @private */ 863 struct cmd_clk_is_enabled_request { 864 EMPTY 865 } __ABI_PACKED; 866 867 struct cmd_clk_is_enabled_response { 868 int32_t state; 869 } __ABI_PACKED; 870 871 /** @private */ 872 struct cmd_clk_enable_request { 873 EMPTY 874 } __ABI_PACKED; 875 876 /** @private */ 877 struct cmd_clk_enable_response { 878 EMPTY 879 } __ABI_PACKED; 880 881 /** @private */ 882 struct cmd_clk_disable_request { 883 EMPTY 884 } __ABI_PACKED; 885 886 /** @private */ 887 struct cmd_clk_disable_response { 888 EMPTY 889 } __ABI_PACKED; 890 891 /** @private */ 892 struct cmd_clk_get_all_info_request { 893 EMPTY 894 } __ABI_PACKED; 895 896 struct cmd_clk_get_all_info_response { 897 uint32_t flags; 898 uint32_t parent; 899 uint32_t parents[MRQ_CLK_MAX_PARENTS]; 900 uint8_t num_parents; 901 uint8_t name[MRQ_CLK_NAME_MAXLEN]; 902 } __ABI_PACKED; 903 904 /** @private */ 905 struct cmd_clk_get_max_clk_id_request { 906 EMPTY 907 } __ABI_PACKED; 908 909 struct cmd_clk_get_max_clk_id_response { 910 uint32_t max_id; 911 } __ABI_PACKED; 912 /** @} */ 913 914 /** 915 * @ingroup Clocks 916 * @brief request with #MRQ_CLK 917 * 918 * Used by the sender of an #MRQ_CLK message to control clocks. The 919 * clk_request is split into several sub-commands. Some sub-commands 920 * require no additional data. Others have a sub-command specific 921 * payload 922 * 923 * |sub-command |payload | 924 * |----------------------------|-----------------------| 925 * |CMD_CLK_GET_RATE |- | 926 * |CMD_CLK_SET_RATE |clk_set_rate | 927 * |CMD_CLK_ROUND_RATE |clk_round_rate | 928 * |CMD_CLK_GET_PARENT |- | 929 * |CMD_CLK_SET_PARENT |clk_set_parent | 930 * |CMD_CLK_IS_ENABLED |- | 931 * |CMD_CLK_ENABLE |- | 932 * |CMD_CLK_DISABLE |- | 933 * |CMD_CLK_GET_ALL_INFO |- | 934 * |CMD_CLK_GET_MAX_CLK_ID |- | 935 * 936 */ 937 938 struct mrq_clk_request { 939 /** @brief sub-command and clock id concatenated to 32-bit word. 940 * - bits[31..24] is the sub-cmd. 941 * - bits[23..0] is the clock id 942 */ 943 uint32_t cmd_and_id; 944 945 union { 946 /** @private */ 947 struct cmd_clk_get_rate_request clk_get_rate; 948 struct cmd_clk_set_rate_request clk_set_rate; 949 struct cmd_clk_round_rate_request clk_round_rate; 950 /** @private */ 951 struct cmd_clk_get_parent_request clk_get_parent; 952 struct cmd_clk_set_parent_request clk_set_parent; 953 /** @private */ 954 struct cmd_clk_enable_request clk_enable; 955 /** @private */ 956 struct cmd_clk_disable_request clk_disable; 957 /** @private */ 958 struct cmd_clk_is_enabled_request clk_is_enabled; 959 /** @private */ 960 struct cmd_clk_get_all_info_request clk_get_all_info; 961 /** @private */ 962 struct cmd_clk_get_max_clk_id_request clk_get_max_clk_id; 963 } __UNION_ANON; 964 } __ABI_PACKED; 965 966 /** 967 * @ingroup Clocks 968 * @brief response to MRQ_CLK 969 * 970 * Each sub-command supported by @ref mrq_clk_request may return 971 * sub-command-specific data. Some do and some do not as indicated in 972 * the following table 973 * 974 * |sub-command |payload | 975 * |----------------------------|------------------------| 976 * |CMD_CLK_GET_RATE |clk_get_rate | 977 * |CMD_CLK_SET_RATE |clk_set_rate | 978 * |CMD_CLK_ROUND_RATE |clk_round_rate | 979 * |CMD_CLK_GET_PARENT |clk_get_parent | 980 * |CMD_CLK_SET_PARENT |clk_set_parent | 981 * |CMD_CLK_IS_ENABLED |clk_is_enabled | 982 * |CMD_CLK_ENABLE |- | 983 * |CMD_CLK_DISABLE |- | 984 * |CMD_CLK_GET_ALL_INFO |clk_get_all_info | 985 * |CMD_CLK_GET_MAX_CLK_ID |clk_get_max_id | 986 * 987 */ 988 989 struct mrq_clk_response { 990 union { 991 struct cmd_clk_get_rate_response clk_get_rate; 992 struct cmd_clk_set_rate_response clk_set_rate; 993 struct cmd_clk_round_rate_response clk_round_rate; 994 struct cmd_clk_get_parent_response clk_get_parent; 995 struct cmd_clk_set_parent_response clk_set_parent; 996 /** @private */ 997 struct cmd_clk_enable_response clk_enable; 998 /** @private */ 999 struct cmd_clk_disable_response clk_disable; 1000 struct cmd_clk_is_enabled_response clk_is_enabled; 1001 struct cmd_clk_get_all_info_response clk_get_all_info; 1002 struct cmd_clk_get_max_clk_id_response clk_get_max_clk_id; 1003 } __UNION_ANON; 1004 } __ABI_PACKED; 1005 1006 /** 1007 * @ingroup MRQ_Codes 1008 * @def MRQ_QUERY_ABI 1009 * @brief check if an MRQ is implemented 1010 * 1011 * * Platforms: All 1012 * * Initiators: Any 1013 * * Targets: Any 1014 * * Request Payload: @ref mrq_query_abi_request 1015 * * Response Payload: @ref mrq_query_abi_response 1016 */ 1017 1018 /** 1019 * @ingroup ABI_info 1020 * @brief request with MRQ_QUERY_ABI 1021 * 1022 * Used by #MRQ_QUERY_ABI call to check if MRQ code #mrq is supported 1023 * by the recipient. 1024 */ 1025 struct mrq_query_abi_request { 1026 /** @brief MRQ code to query */ 1027 uint32_t mrq; 1028 } __ABI_PACKED; 1029 1030 /** 1031 * @ingroup ABI_info 1032 * @brief response to MRQ_QUERY_ABI 1033 */ 1034 struct mrq_query_abi_response { 1035 /** @brief 0 if queried MRQ is supported. Else, -#BPMP_ENODEV */ 1036 int32_t status; 1037 } __ABI_PACKED; 1038 1039 /** 1040 * @ingroup MRQ_Codes 1041 * @def MRQ_PG_READ_STATE 1042 * @brief read the power-gating state of a partition 1043 * 1044 * * Platforms: T186 1045 * * Initiators: Any 1046 * * Targets: BPMP 1047 * * Request Payload: @ref mrq_pg_read_state_request 1048 * * Response Payload: @ref mrq_pg_read_state_response 1049 * @addtogroup Powergating 1050 * @{ 1051 */ 1052 1053 /** 1054 * @brief request with #MRQ_PG_READ_STATE 1055 * 1056 * Used by MRQ_PG_READ_STATE call to read the current state of a 1057 * partition. 1058 */ 1059 struct mrq_pg_read_state_request { 1060 /** @brief ID of partition */ 1061 uint32_t partition_id; 1062 } __ABI_PACKED; 1063 1064 /** 1065 * @brief response to MRQ_PG_READ_STATE 1066 * @todo define possible errors. 1067 */ 1068 struct mrq_pg_read_state_response { 1069 /** @brief read as don't care */ 1070 uint32_t sram_state; 1071 /** @brief state of power partition 1072 * * 0 : off 1073 * * 1 : on 1074 */ 1075 uint32_t logic_state; 1076 } __ABI_PACKED; 1077 1078 /** @} */ 1079 1080 /** 1081 * @ingroup MRQ_Codes 1082 * @def MRQ_PG_UPDATE_STATE 1083 * @brief modify the power-gating state of a partition 1084 * 1085 * * Platforms: T186 1086 * * Initiators: Any 1087 * * Targets: BPMP 1088 * * Request Payload: @ref mrq_pg_update_state_request 1089 * * Response Payload: N/A 1090 * @addtogroup Powergating 1091 * @{ 1092 */ 1093 1094 /** 1095 * @brief request with mrq_pg_update_state_request 1096 * 1097 * Used by #MRQ_PG_UPDATE_STATE call to request BPMP to change the 1098 * state of a power partition #partition_id. 1099 */ 1100 struct mrq_pg_update_state_request { 1101 /** @brief ID of partition */ 1102 uint32_t partition_id; 1103 /** @brief secondary control of power partition 1104 * @details Ignored by many versions of the BPMP 1105 * firmware. For maximum compatibility, set the value 1106 * according to @logic_state 1107 * * 0x1: power ON partition (@ref logic_state == 0x3) 1108 * * 0x3: power OFF partition (@ref logic_state == 0x1) 1109 */ 1110 uint32_t sram_state; 1111 /** @brief controls state of power partition, legal values are 1112 * * 0x1 : power OFF partition 1113 * * 0x3 : power ON partition 1114 */ 1115 uint32_t logic_state; 1116 /** @brief change state of clocks of the power partition, legal values 1117 * * 0x0 : do not change clock state 1118 * * 0x1 : disable partition clocks (only applicable when 1119 * @ref logic_state == 0x1) 1120 * * 0x3 : enable partition clocks (only applicable when 1121 * @ref logic_state == 0x3) 1122 */ 1123 uint32_t clock_state; 1124 } __ABI_PACKED; 1125 /** @} */ 1126 1127 /** 1128 * @ingroup MRQ_Codes 1129 * @def MRQ_THERMAL 1130 * @brief interact with BPMP thermal framework 1131 * 1132 * * Platforms: T186 1133 * * Initiators: Any 1134 * * Targets: Any 1135 * * Request Payload: TODO 1136 * * Response Payload: TODO 1137 * 1138 * @addtogroup Thermal 1139 * 1140 * The BPMP firmware includes a thermal framework. Drivers within the 1141 * bpmp firmware register with the framework to provide thermal 1142 * zones. Each thermal zone corresponds to an entity whose temperature 1143 * can be measured. The framework also has a notion of trip points. A 1144 * trip point consists of a thermal zone id, a temperature, and a 1145 * callback routine. The framework invokes the callback when the zone 1146 * hits the indicated temperature. The BPMP firmware uses this thermal 1147 * framework interally to implement various temperature-dependent 1148 * functions. 1149 * 1150 * Software on the CPU can use #MRQ_THERMAL (with payload @ref 1151 * mrq_thermal_host_to_bpmp_request) to interact with the BPMP thermal 1152 * framework. The CPU must It can query the number of supported zones, 1153 * query zone temperatures, and set trip points. 1154 * 1155 * When a trip point set by the CPU gets crossed, BPMP firmware issues 1156 * an IPC to the CPU having mrq_request::mrq = #MRQ_THERMAL and a 1157 * payload of @ref mrq_thermal_bpmp_to_host_request. 1158 * @{ 1159 */ 1160 enum mrq_thermal_host_to_bpmp_cmd { 1161 /** 1162 * @brief Check whether the BPMP driver supports the specified 1163 * request type. 1164 * 1165 * Host needs to supply request parameters. 1166 * 1167 * mrq_response::err is 0 if the specified request is 1168 * supported and -#BPMP_ENODEV otherwise. 1169 */ 1170 CMD_THERMAL_QUERY_ABI = 0, 1171 1172 /** 1173 * @brief Get the current temperature of the specified zone. 1174 * 1175 * Host needs to supply request parameters. 1176 * 1177 * mrq_response::err is 1178 * * 0: Temperature query succeeded. 1179 * * -#BPMP_EINVAL: Invalid request parameters. 1180 * * -#BPMP_ENOENT: No driver registered for thermal zone.. 1181 * * -#BPMP_EFAULT: Problem reading temperature measurement. 1182 */ 1183 CMD_THERMAL_GET_TEMP = 1, 1184 1185 /** 1186 * @brief Enable or disable and set the lower and upper 1187 * thermal limits for a thermal trip point. Each zone has 1188 * one trip point. 1189 * 1190 * Host needs to supply request parameters. Once the 1191 * temperature hits a trip point, the BPMP will send a message 1192 * to the CPU having MRQ=MRQ_THERMAL and 1193 * type=CMD_THERMAL_HOST_TRIP_REACHED 1194 * 1195 * mrq_response::err is 1196 * * 0: Trip successfully set. 1197 * * -#BPMP_EINVAL: Invalid request parameters. 1198 * * -#BPMP_ENOENT: No driver registered for thermal zone. 1199 * * -#BPMP_EFAULT: Problem setting trip point. 1200 */ 1201 CMD_THERMAL_SET_TRIP = 2, 1202 1203 /** 1204 * @brief Get the number of supported thermal zones. 1205 * 1206 * No request parameters required. 1207 * 1208 * mrq_response::err is always 0, indicating success. 1209 */ 1210 CMD_THERMAL_GET_NUM_ZONES = 3, 1211 1212 /** @brief: number of supported host-to-bpmp commands. May 1213 * increase in future 1214 */ 1215 CMD_THERMAL_HOST_TO_BPMP_NUM 1216 }; 1217 1218 enum mrq_thermal_bpmp_to_host_cmd { 1219 /** 1220 * @brief Indication that the temperature for a zone has 1221 * exceeded the range indicated in the thermal trip point 1222 * for the zone. 1223 * 1224 * BPMP needs to supply request parameters. Host only needs to 1225 * acknowledge. 1226 */ 1227 CMD_THERMAL_HOST_TRIP_REACHED = 100, 1228 1229 /** @brief: number of supported bpmp-to-host commands. May 1230 * increase in future 1231 */ 1232 CMD_THERMAL_BPMP_TO_HOST_NUM 1233 }; 1234 1235 /* 1236 * Host->BPMP request data for request type CMD_THERMAL_QUERY_ABI 1237 * 1238 * zone: Request type for which to check existence. 1239 */ 1240 struct cmd_thermal_query_abi_request { 1241 uint32_t type; 1242 } __ABI_PACKED; 1243 1244 /* 1245 * Host->BPMP request data for request type CMD_THERMAL_GET_TEMP 1246 * 1247 * zone: Number of thermal zone. 1248 */ 1249 struct cmd_thermal_get_temp_request { 1250 uint32_t zone; 1251 } __ABI_PACKED; 1252 1253 /* 1254 * BPMP->Host reply data for request CMD_THERMAL_GET_TEMP 1255 * 1256 * error: 0 if request succeeded. 1257 * -BPMP_EINVAL if request parameters were invalid. 1258 * -BPMP_ENOENT if no driver was registered for the specified thermal zone. 1259 * -BPMP_EFAULT for other thermal zone driver errors. 1260 * temp: Current temperature in millicelsius. 1261 */ 1262 struct cmd_thermal_get_temp_response { 1263 int32_t temp; 1264 } __ABI_PACKED; 1265 1266 /* 1267 * Host->BPMP request data for request type CMD_THERMAL_SET_TRIP 1268 * 1269 * zone: Number of thermal zone. 1270 * low: Temperature of lower trip point in millicelsius 1271 * high: Temperature of upper trip point in millicelsius 1272 * enabled: 1 to enable trip point, 0 to disable trip point 1273 */ 1274 struct cmd_thermal_set_trip_request { 1275 uint32_t zone; 1276 int32_t low; 1277 int32_t high; 1278 uint32_t enabled; 1279 } __ABI_PACKED; 1280 1281 /* 1282 * BPMP->Host request data for request type CMD_THERMAL_HOST_TRIP_REACHED 1283 * 1284 * zone: Number of thermal zone where trip point was reached. 1285 */ 1286 struct cmd_thermal_host_trip_reached_request { 1287 uint32_t zone; 1288 } __ABI_PACKED; 1289 1290 /* 1291 * BPMP->Host reply data for request type CMD_THERMAL_GET_NUM_ZONES 1292 * 1293 * num: Number of supported thermal zones. The thermal zones are indexed 1294 * starting from zero. 1295 */ 1296 struct cmd_thermal_get_num_zones_response { 1297 uint32_t num; 1298 } __ABI_PACKED; 1299 1300 /* 1301 * Host->BPMP request data. 1302 * 1303 * Reply type is union mrq_thermal_bpmp_to_host_response. 1304 * 1305 * type: Type of request. Values listed in enum mrq_thermal_type. 1306 * data: Request type specific parameters. 1307 */ 1308 struct mrq_thermal_host_to_bpmp_request { 1309 uint32_t type; 1310 union { 1311 struct cmd_thermal_query_abi_request query_abi; 1312 struct cmd_thermal_get_temp_request get_temp; 1313 struct cmd_thermal_set_trip_request set_trip; 1314 } __UNION_ANON; 1315 } __ABI_PACKED; 1316 1317 /* 1318 * BPMP->Host request data. 1319 * 1320 * type: Type of request. Values listed in enum mrq_thermal_type. 1321 * data: Request type specific parameters. 1322 */ 1323 struct mrq_thermal_bpmp_to_host_request { 1324 uint32_t type; 1325 union { 1326 struct cmd_thermal_host_trip_reached_request host_trip_reached; 1327 } __UNION_ANON; 1328 } __ABI_PACKED; 1329 1330 /* 1331 * Data in reply to a Host->BPMP request. 1332 */ 1333 union mrq_thermal_bpmp_to_host_response { 1334 struct cmd_thermal_get_temp_response get_temp; 1335 struct cmd_thermal_get_num_zones_response get_num_zones; 1336 } __ABI_PACKED; 1337 /** @} */ 1338 1339 /** 1340 * @ingroup MRQ_Codes 1341 * @def MRQ_CPU_VHINT 1342 * @brief Query CPU voltage hint data 1343 * 1344 * * Platforms: T186 1345 * * Initiators: CCPLEX 1346 * * Targets: BPMP 1347 * * Request Payload: @ref mrq_cpu_vhint_request 1348 * * Response Payload: N/A 1349 * 1350 * @addtogroup Vhint CPU Voltage hint 1351 * @{ 1352 */ 1353 1354 /** 1355 * @brief request with #MRQ_CPU_VHINT 1356 * 1357 * Used by #MRQ_CPU_VHINT call by CCPLEX to retrieve voltage hint data 1358 * from BPMP to memory space pointed by #addr. CCPLEX is responsible 1359 * to allocate sizeof(cpu_vhint_data) sized block of memory and 1360 * appropriately map it for BPMP before sending the request. 1361 */ 1362 struct mrq_cpu_vhint_request { 1363 /** @brief IOVA address for the #cpu_vhint_data */ 1364 uint32_t addr; /* struct cpu_vhint_data * */ 1365 /** @brief ID of the cluster whose data is requested */ 1366 uint32_t cluster_id; /* enum cluster_id */ 1367 } __ABI_PACKED; 1368 1369 /** 1370 * @brief description of the CPU v/f relation 1371 * 1372 * Used by #MRQ_CPU_VHINT call to carry data pointed by #addr of 1373 * struct mrq_cpu_vhint_request 1374 */ 1375 struct cpu_vhint_data { 1376 uint32_t ref_clk_hz; /**< reference frequency in Hz */ 1377 uint16_t pdiv; /**< post divider value */ 1378 uint16_t mdiv; /**< input divider value */ 1379 uint16_t ndiv_max; /**< fMAX expressed with max NDIV value */ 1380 /** table of ndiv values as a function of vINDEX (voltage index) */ 1381 uint16_t ndiv[80]; 1382 /** minimum allowed NDIV value */ 1383 uint16_t ndiv_min; 1384 /** minimum allowed voltage hint value (as in vINDEX) */ 1385 uint16_t vfloor; 1386 /** maximum allowed voltage hint value (as in vINDEX) */ 1387 uint16_t vceil; 1388 /** post-multiplier for vindex value */ 1389 uint16_t vindex_mult; 1390 /** post-divider for vindex value */ 1391 uint16_t vindex_div; 1392 /** reserved for future use */ 1393 uint16_t reserved[328]; 1394 } __ABI_PACKED; 1395 1396 /** @} */ 1397 1398 /** 1399 * @ingroup MRQ_Codes 1400 * @def MRQ_ABI_RATCHET 1401 * @brief ABI ratchet value query 1402 * 1403 * * Platforms: T186 1404 * * Initiators: Any 1405 * * Targets: BPMP 1406 * * Request Payload: @ref mrq_abi_ratchet_request 1407 * * Response Payload: @ref mrq_abi_ratchet_response 1408 * @addtogroup ABI_info 1409 * @{ 1410 */ 1411 1412 /** 1413 * @brief an ABI compatibility mechanism 1414 * 1415 * BPMP_ABI_RATCHET_VALUE may increase for various reasons in a future 1416 * revision of this header file. 1417 * 1. That future revision deprecates some MRQ 1418 * 2. That future revision introduces a breaking change to an existing 1419 * MRQ or 1420 * 3. A bug is discovered in an existing implementation of the BPMP-FW 1421 * (or possibly one of its clients) which warrants deprecating that 1422 * implementation. 1423 */ 1424 #define BPMP_ABI_RATCHET_VALUE 3 1425 1426 /** 1427 * @brief request with #MRQ_ABI_RATCHET. 1428 * 1429 * #ratchet should be #BPMP_ABI_RATCHET_VALUE from the ABI header 1430 * against which the requester was compiled. 1431 * 1432 * If ratchet is less than BPMP's #BPMP_ABI_RATCHET_VALUE, BPMP may 1433 * reply with mrq_response::err = -#BPMP_ERANGE to indicate that 1434 * BPMP-FW cannot interoperate correctly with the requester. Requester 1435 * should cease further communication with BPMP. 1436 * 1437 * Otherwise, err shall be 0. 1438 */ 1439 struct mrq_abi_ratchet_request { 1440 /** @brief requester's ratchet value */ 1441 uint16_t ratchet; 1442 }; 1443 1444 /** 1445 * @brief response to #MRQ_ABI_RATCHET 1446 * 1447 * #ratchet shall be #BPMP_ABI_RATCHET_VALUE from the ABI header 1448 * against which BPMP firwmare was compiled. 1449 * 1450 * If #ratchet is less than the requester's #BPMP_ABI_RATCHET_VALUE, 1451 * the requster must either interoperate with BPMP according to an ABI 1452 * header version with BPMP_ABI_RATCHET_VALUE = ratchet or cease 1453 * communication with BPMP. 1454 * 1455 * If mrq_response::err is 0 and ratchet is greater than or equal to the 1456 * requester's BPMP_ABI_RATCHET_VALUE, the requester should continue 1457 * normal operation. 1458 */ 1459 struct mrq_abi_ratchet_response { 1460 /** @brief BPMP's ratchet value */ 1461 uint16_t ratchet; 1462 }; 1463 /** @} */ 1464 1465 /** 1466 * @ingroup MRQ_Codes 1467 * @def MRQ_EMC_DVFS_LATENCY 1468 * @brief query frequency dependent EMC DVFS latency 1469 * 1470 * * Platforms: T186 1471 * * Initiators: CCPLEX 1472 * * Targets: BPMP 1473 * * Request Payload: N/A 1474 * * Response Payload: @ref mrq_emc_dvfs_latency_response 1475 * @addtogroup EMC 1476 * @{ 1477 */ 1478 1479 /** 1480 * @brief used by @ref mrq_emc_dvfs_latency_response 1481 */ 1482 struct emc_dvfs_latency { 1483 /** @brief EMC frequency in kHz */ 1484 uint32_t freq; 1485 /** @brief EMC DVFS latency in nanoseconds */ 1486 uint32_t latency; 1487 } __ABI_PACKED; 1488 1489 #define EMC_DVFS_LATENCY_MAX_SIZE 14 1490 /** 1491 * @brief response to #MRQ_EMC_DVFS_LATENCY 1492 */ 1493 struct mrq_emc_dvfs_latency_response { 1494 /** @brief the number valid entries in #pairs */ 1495 uint32_t num_pairs; 1496 /** @brief EMC <frequency, latency> information */ 1497 struct emc_dvfs_latency pairs[EMC_DVFS_LATENCY_MAX_SIZE]; 1498 } __ABI_PACKED; 1499 1500 /** @} */ 1501 1502 /** 1503 * @ingroup MRQ_Codes 1504 * @def MRQ_TRACE_ITER 1505 * @brief manage the trace iterator 1506 * 1507 * * Platforms: All 1508 * * Initiators: CCPLEX 1509 * * Targets: BPMP 1510 * * Request Payload: N/A 1511 * * Response Payload: @ref mrq_trace_iter_request 1512 * @addtogroup Trace 1513 * @{ 1514 */ 1515 enum { 1516 /** @brief (re)start the tracing now. Ignore older events */ 1517 TRACE_ITER_INIT = 0, 1518 /** @brief clobber all events in the trace buffer */ 1519 TRACE_ITER_CLEAN = 1 1520 }; 1521 1522 /** 1523 * @brief request with #MRQ_TRACE_ITER 1524 */ 1525 struct mrq_trace_iter_request { 1526 /** @brief TRACE_ITER_INIT or TRACE_ITER_CLEAN */ 1527 uint32_t cmd; 1528 } __ABI_PACKED; 1529 1530 /** @} */ 1531 1532 /* 1533 * 4. Enumerations 1534 */ 1535 1536 /* 1537 * 4.1 CPU enumerations 1538 * 1539 * See <mach-t186/system-t186.h> 1540 * 1541 * 4.2 CPU Cluster enumerations 1542 * 1543 * See <mach-t186/system-t186.h> 1544 * 1545 * 4.3 System low power state enumerations 1546 * 1547 * See <mach-t186/system-t186.h> 1548 */ 1549 1550 /* 1551 * 4.4 Clock enumerations 1552 * 1553 * For clock enumerations, see <mach-t186/clk-t186.h> 1554 */ 1555 1556 /* 1557 * 4.5 Reset enumerations 1558 * 1559 * For reset enumerations, see <mach-t186/reset-t186.h> 1560 */ 1561 1562 /* 1563 * 4.6 Thermal sensor enumerations 1564 * 1565 * For thermal sensor enumerations, see <mach-t186/thermal-t186.h> 1566 */ 1567 1568 /** 1569 * @defgroup Error_Codes 1570 * Negative values for mrq_response::err generally indicate some 1571 * error. The ABI defines the following error codes. Negating these 1572 * defines is an exercise left to the user. 1573 * @{ 1574 */ 1575 /** @brief No such file or directory */ 1576 #define BPMP_ENOENT 2 1577 /** @brief No MRQ handler */ 1578 #define BPMP_ENOHANDLER 3 1579 /** @brief I/O error */ 1580 #define BPMP_EIO 5 1581 /** @brief Bad sub-MRQ command */ 1582 #define BPMP_EBADCMD 6 1583 /** @brief Not enough memory */ 1584 #define BPMP_ENOMEM 12 1585 /** @brief Permission denied */ 1586 #define BPMP_EACCES 13 1587 /** @brief Bad address */ 1588 #define BPMP_EFAULT 14 1589 /** @brief No such device */ 1590 #define BPMP_ENODEV 19 1591 /** @brief Argument is a directory */ 1592 #define BPMP_EISDIR 21 1593 /** @brief Invalid argument */ 1594 #define BPMP_EINVAL 22 1595 /** @brief Timeout during operation */ 1596 #define BPMP_ETIMEDOUT 23 1597 /** @brief Out of range */ 1598 #define BPMP_ERANGE 34 1599 /** @} */ 1600 /** @} */ 1601 #endif 1602