drivers/gpu/drm/amd/display/dmub/dmub_srv.h

   1 /*
   2  * Copyright 2019 Advanced Micro Devices, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * Authors: AMD
  23  *
  24  */
  25
  26 #ifndef _DMUB_SRV_H_
  27 #define _DMUB_SRV_H_
  28
  29 /**
  30  * DOC: DMUB interface and operation
  31  *
  32  * DMUB is the interface to the display DMCUB microcontroller on DCN hardware.
  33  * It delegates hardware initialization and command submission to the
  34  * microcontroller. DMUB is the shortname for DMCUB.
  35  *
  36  * This interface is not thread-safe. Ensure that all access to the interface
  37  * is properly synchronized by the caller.
  38  *
  39  * Initialization and usage of the DMUB service should be done in the
  40  * steps given below:
  41  *
  42  * 1. dmub_srv_create()
  43  * 2. dmub_srv_has_hw_support()
  44  * 3. dmub_srv_calc_region_info()
  45  * 4. dmub_srv_hw_init()
  46  *
  47  * The call to dmub_srv_create() is required to use the server.
  48  *
  49  * The calls to dmub_srv_has_hw_support() and dmub_srv_calc_region_info()
  50  * are helpers to query cache window size and allocate framebuffer(s)
  51  * for the cache windows.
  52  *
  53  * The call to dmub_srv_hw_init() programs the DMCUB registers to prepare
  54  * for command submission. Commands can be queued via dmub_srv_cmd_queue()
  55  * and executed via dmub_srv_cmd_execute().
  56  *
  57  * If the queue is full the dmub_srv_wait_for_idle() call can be used to
  58  * wait until the queue has been cleared.
  59  *
  60  * Destroying the DMUB service can be done by calling dmub_srv_destroy().
  61  * This does not clear DMUB hardware state, only software state.
  62  *
  63  * The interface is intended to be standalone and should not depend on any
  64  * other component within DAL.
  65  */
  66
  67 #include "inc/dmub_cmd.h"
  68
  69 #if defined(__cplusplus)
  70 extern "C" {
  71 #endif
  72
  73 /* Forward declarations */
  74 struct dmub_srv;
  75 struct dmub_srv_common_regs;
  76 struct dmub_srv_dcn31_regs;
  77
  78 struct dmcub_trace_buf_entry;
  79
  80 /* enum dmub_status - return code for dmcub functions */
  81 enum dmub_status {
  82         DMUB_STATUS_OK = 0,
  83         DMUB_STATUS_NO_CTX,
  84         DMUB_STATUS_QUEUE_FULL,
  85         DMUB_STATUS_TIMEOUT,
  86         DMUB_STATUS_INVALID,
  87 };
  88
  89 /* enum dmub_asic - dmub asic identifier */
  90 enum dmub_asic {
  91         DMUB_ASIC_NONE = 0,
  92         DMUB_ASIC_DCN20,
  93         DMUB_ASIC_DCN21,
  94         DMUB_ASIC_DCN30,
  95         DMUB_ASIC_DCN301,
  96         DMUB_ASIC_DCN302,
  97         DMUB_ASIC_DCN303,
  98         DMUB_ASIC_DCN31,
  99         DMUB_ASIC_MAX,
 100 };
 101
 102 /* enum dmub_window_id - dmub window identifier */
 103 enum dmub_window_id {
 104         DMUB_WINDOW_0_INST_CONST = 0,
 105         DMUB_WINDOW_1_STACK,
 106         DMUB_WINDOW_2_BSS_DATA,
 107         DMUB_WINDOW_3_VBIOS,
 108         DMUB_WINDOW_4_MAILBOX,
 109         DMUB_WINDOW_5_TRACEBUFF,
 110         DMUB_WINDOW_6_FW_STATE,
 111         DMUB_WINDOW_7_SCRATCH_MEM,
 112         DMUB_WINDOW_TOTAL,
 113 };
 114
 115 /* enum dmub_notification_type - dmub outbox notification identifier */
 116 enum dmub_notification_type {
 117         DMUB_NOTIFICATION_NO_DATA = 0,
 118         DMUB_NOTIFICATION_AUX_REPLY,
 119         DMUB_NOTIFICATION_HPD,
 120         DMUB_NOTIFICATION_HPD_IRQ,
 121         DMUB_NOTIFICATION_MAX
 122 };
 123
 124 /**
 125  * struct dmub_region - dmub hw memory region
 126  * @base: base address for region, must be 256 byte aligned
 127  * @top: top address for region
 128  */
 129 struct dmub_region {
 130         uint32_t base;
 131         uint32_t top;
 132 };
 133
 134 /**
 135  * struct dmub_window - dmub hw cache window
 136  * @off: offset to the fb memory in gpu address space
 137  * @r: region in uc address space for cache window
 138  */
 139 struct dmub_window {
 140         union dmub_addr offset;
 141         struct dmub_region region;
 142 };
 143
 144 /**
 145  * struct dmub_fb - defines a dmub framebuffer memory region
 146  * @cpu_addr: cpu virtual address for the region, NULL if invalid
 147  * @gpu_addr: gpu virtual address for the region, NULL if invalid
 148  * @size: size of the region in bytes, zero if invalid
 149  */
 150 struct dmub_fb {
 151         void *cpu_addr;
 152         uint64_t gpu_addr;
 153         uint32_t size;
 154 };
 155
 156 /**
 157  * struct dmub_srv_region_params - params used for calculating dmub regions
 158  * @inst_const_size: size of the fw inst const section
 159  * @bss_data_size: size of the fw bss data section
 160  * @vbios_size: size of the vbios data
 161  * @fw_bss_data: raw firmware bss data section
 162  */
 163 struct dmub_srv_region_params {
 164         uint32_t inst_const_size;
 165         uint32_t bss_data_size;
 166         uint32_t vbios_size;
 167         const uint8_t *fw_inst_const;
 168         const uint8_t *fw_bss_data;
 169 };
 170
 171 /**
 172  * struct dmub_srv_region_info - output region info from the dmub service
 173  * @fb_size: required minimum fb size for all regions, aligned to 4096 bytes
 174  * @num_regions: number of regions used by the dmub service
 175  * @regions: region info
 176  *
 177  * The regions are aligned such that they can be all placed within the
 178  * same framebuffer but they can also be placed into different framebuffers.
 179  *
 180  * The size of each region can be calculated by the caller:
 181  * size = reg.top - reg.base
 182  *
 183  * Care must be taken when performing custom allocations to ensure that each
 184  * region base address is 256 byte aligned.
 185  */
 186 struct dmub_srv_region_info {
 187         uint32_t fb_size;
 188         uint8_t num_regions;
 189         struct dmub_region regions[DMUB_WINDOW_TOTAL];
 190 };
 191
 192 /**
 193  * struct dmub_srv_fb_params - parameters used for driver fb setup
 194  * @region_info: region info calculated by dmub service
 195  * @cpu_addr: base cpu address for the framebuffer
 196  * @gpu_addr: base gpu virtual address for the framebuffer
 197  */
 198 struct dmub_srv_fb_params {
 199         const struct dmub_srv_region_info *region_info;
 200         void *cpu_addr;
 201         uint64_t gpu_addr;
 202 };
 203
 204 /**
 205  * struct dmub_srv_fb_info - output fb info from the dmub service
 206  * @num_fbs: number of required dmub framebuffers
 207  * @fbs: fb data for each region
 208  *
 209  * Output from the dmub service helper that can be used by the
 210  * driver to prepare dmub_fb that can be passed into the dmub
 211  * hw init service.
 212  *
 213  * Assumes that all regions are within the same framebuffer
 214  * and have been setup according to the region_info generated
 215  * by the dmub service.
 216  */
 217 struct dmub_srv_fb_info {
 218         uint8_t num_fb;
 219         struct dmub_fb fb[DMUB_WINDOW_TOTAL];
 220 };
 221
 222 /*
 223  * struct dmub_srv_hw_params - params for dmub hardware initialization
 224  * @fb: framebuffer info for each region
 225  * @fb_base: base of the framebuffer aperture
 226  * @fb_offset: offset of the framebuffer aperture
 227  * @psp_version: psp version to pass for DMCU init
 228  * @load_inst_const: true if DMUB should load inst const fw
 229  */
 230 struct dmub_srv_hw_params {
 231         struct dmub_fb *fb[DMUB_WINDOW_TOTAL];
 232         uint64_t fb_base;
 233         uint64_t fb_offset;
 234         uint32_t psp_version;
 235         bool load_inst_const;
 236         bool skip_panel_power_sequence;
 237         bool disable_z10;
 238 };
 239
 240 /**
 241  * struct dmub_diagnostic_data - Diagnostic data retrieved from DMCUB for
 242  * debugging purposes, including logging, crash analysis, etc.
 243  */
 244 struct dmub_diagnostic_data {
 245         uint32_t dmcub_version;
 246         uint32_t scratch[16];
 247         uint32_t pc;
 248         uint32_t undefined_address_fault_addr;
 249         uint32_t inst_fetch_fault_addr;
 250         uint32_t data_write_fault_addr;
 251         uint32_t inbox1_rptr;
 252         uint32_t inbox1_wptr;
 253         uint32_t inbox1_size;
 254         uint32_t inbox0_rptr;
 255         uint32_t inbox0_wptr;
 256         uint32_t inbox0_size;
 257         uint8_t is_dmcub_enabled : 1;
 258         uint8_t is_dmcub_soft_reset : 1;
 259         uint8_t is_dmcub_secure_reset : 1;
 260         uint8_t is_traceport_en : 1;
 261         uint8_t is_cw0_enabled : 1;
 262         uint8_t is_cw6_enabled : 1;
 263 };
 264
 265 /**
 266  * struct dmub_srv_base_funcs - Driver specific base callbacks
 267  */
 268 struct dmub_srv_base_funcs {
 269         /**
 270          * @reg_read:
 271          *
 272          * Hook for reading a register.
 273          *
 274          * Return: The 32-bit register value from the given address.
 275          */
 276         uint32_t (*reg_read)(void *ctx, uint32_t address);
 277
 278         /**
 279          * @reg_write:
 280          *
 281          * Hook for writing a value to the register specified by address.
 282          */
 283         void (*reg_write)(void *ctx, uint32_t address, uint32_t value);
 284 };
 285
 286 /**
 287  * struct dmub_srv_hw_funcs - hardware sequencer funcs for dmub
 288  */
 289 struct dmub_srv_hw_funcs {
 290         /* private: internal use only */
 291
 292         void (*init)(struct dmub_srv *dmub);
 293
 294         void (*reset)(struct dmub_srv *dmub);
 295
 296         void (*reset_release)(struct dmub_srv *dmub);
 297
 298         void (*backdoor_load)(struct dmub_srv *dmub,
 299                               const struct dmub_window *cw0,
 300                               const struct dmub_window *cw1);
 301
 302         void (*setup_windows)(struct dmub_srv *dmub,
 303                               const struct dmub_window *cw2,
 304                               const struct dmub_window *cw3,
 305                               const struct dmub_window *cw4,
 306                               const struct dmub_window *cw5,
 307                               const struct dmub_window *cw6);
 308
 309         void (*setup_mailbox)(struct dmub_srv *dmub,
 310                               const struct dmub_region *inbox1);
 311
 312         uint32_t (*get_inbox1_rptr)(struct dmub_srv *dmub);
 313
 314         void (*set_inbox1_wptr)(struct dmub_srv *dmub, uint32_t wptr_offset);
 315
 316         void (*setup_out_mailbox)(struct dmub_srv *dmub,
 317                               const struct dmub_region *outbox1);
 318
 319         uint32_t (*get_outbox1_wptr)(struct dmub_srv *dmub);
 320
 321         void (*set_outbox1_rptr)(struct dmub_srv *dmub, uint32_t rptr_offset);
 322
 323         void (*setup_outbox0)(struct dmub_srv *dmub,
 324                               const struct dmub_region *outbox0);
 325
 326         uint32_t (*get_outbox0_wptr)(struct dmub_srv *dmub);
 327
 328         void (*set_outbox0_rptr)(struct dmub_srv *dmub, uint32_t rptr_offset);
 329
 330         uint32_t (*emul_get_inbox1_rptr)(struct dmub_srv *dmub);
 331
 332         void (*emul_set_inbox1_wptr)(struct dmub_srv *dmub, uint32_t wptr_offset);
 333
 334         bool (*is_supported)(struct dmub_srv *dmub);
 335
 336         bool (*is_hw_init)(struct dmub_srv *dmub);
 337
 338         bool (*is_phy_init)(struct dmub_srv *dmub);
 339         void (*enable_dmub_boot_options)(struct dmub_srv *dmub,
 340                                 const struct dmub_srv_hw_params *params);
 341
 342         void (*skip_dmub_panel_power_sequence)(struct dmub_srv *dmub, bool skip);
 343
 344         union dmub_fw_boot_status (*get_fw_status)(struct dmub_srv *dmub);
 345
 346
 347         void (*set_gpint)(struct dmub_srv *dmub,
 348                           union dmub_gpint_data_register reg);
 349
 350         bool (*is_gpint_acked)(struct dmub_srv *dmub,
 351                                union dmub_gpint_data_register reg);
 352
 353         uint32_t (*get_gpint_response)(struct dmub_srv *dmub);
 354
 355         uint32_t (*get_gpint_dataout)(struct dmub_srv *dmub);
 356
 357         void (*send_inbox0_cmd)(struct dmub_srv *dmub, union dmub_inbox0_data_register data);
 358         uint32_t (*get_current_time)(struct dmub_srv *dmub);
 359
 360         void (*get_diagnostic_data)(struct dmub_srv *dmub, struct dmub_diagnostic_data *dmub_oca);
 361
 362         bool (*should_detect)(struct dmub_srv *dmub);
 363 };
 364
 365 /**
 366  * struct dmub_srv_create_params - params for dmub service creation
 367  * @base_funcs: driver supplied base routines
 368  * @hw_funcs: optional overrides for hw funcs
 369  * @user_ctx: context data for callback funcs
 370  * @asic: driver supplied asic
 371  * @fw_version: the current firmware version, if any
 372  * @is_virtual: false for hw support only
 373  */
 374 struct dmub_srv_create_params {
 375         struct dmub_srv_base_funcs funcs;
 376         struct dmub_srv_hw_funcs *hw_funcs;
 377         void *user_ctx;
 378         enum dmub_asic asic;
 379         uint32_t fw_version;
 380         bool is_virtual;
 381 };
 382
 383 /**
 384  * struct dmub_srv - software state for dmcub
 385  * @asic: dmub asic identifier
 386  * @user_ctx: user provided context for the dmub_srv
 387  * @fw_version: the current firmware version, if any
 388  * @is_virtual: false if hardware support only
 389  * @fw_state: dmub firmware state pointer
 390  */
 391 struct dmub_srv {
 392         enum dmub_asic asic;
 393         void *user_ctx;
 394         uint32_t fw_version;
 395         bool is_virtual;
 396         struct dmub_fb scratch_mem_fb;
 397         volatile const struct dmub_fw_state *fw_state;
 398
 399         /* private: internal use only */
 400         const struct dmub_srv_common_regs *regs;
 401         const struct dmub_srv_dcn31_regs *regs_dcn31;
 402
 403         struct dmub_srv_base_funcs funcs;
 404         struct dmub_srv_hw_funcs hw_funcs;
 405         struct dmub_rb inbox1_rb;
 406         /**
 407          * outbox1_rb is accessed without locks (dal & dc)
 408          * and to be used only in dmub_srv_stat_get_notification()
 409          */
 410         struct dmub_rb outbox1_rb;
 411
 412         struct dmub_rb outbox0_rb;
 413
 414         bool sw_init;
 415         bool hw_init;
 416
 417         uint64_t fb_base;
 418         uint64_t fb_offset;
 419         uint32_t psp_version;
 420
 421         /* Feature capabilities reported by fw */
 422         struct dmub_feature_caps feature_caps;
 423 };
 424
 425 /**
 426  * struct dmub_notification - dmub notification data
 427  * @type: dmub notification type
 428  * @link_index: link index to identify aux connection
 429  * @result: USB4 status returned from dmub
 430  * @pending_notification: Indicates there are other pending notifications
 431  * @aux_reply: aux reply
 432  * @hpd_status: hpd status
 433  */
 434 struct dmub_notification {
 435         enum dmub_notification_type type;
 436         uint8_t link_index;
 437         uint8_t result;
 438         bool pending_notification;
 439         union {
 440                 struct aux_reply_data aux_reply;
 441                 enum dp_hpd_status hpd_status;
 442         };
 443 };
 444
 445 /**
 446  * DMUB firmware version helper macro - useful for checking if the version
 447  * of a firmware to know if feature or functionality is supported or present.
 448  */
 449 #define DMUB_FW_VERSION(major, minor, revision) \
 450         ((((major) & 0xFF) << 24) | (((minor) & 0xFF) << 16) | ((revision) & 0xFFFF))
 451
 452 /**
 453  * dmub_srv_create() - creates the DMUB service.
 454  * @dmub: the dmub service
 455  * @params: creation parameters for the service
 456  *
 457  * Return:
 458  *   DMUB_STATUS_OK - success
 459  *   DMUB_STATUS_INVALID - unspecified error
 460  */
 461 enum dmub_status dmub_srv_create(struct dmub_srv *dmub,
 462                                  const struct dmub_srv_create_params *params);
 463
 464 /**
 465  * dmub_srv_destroy() - destroys the DMUB service.
 466  * @dmub: the dmub service
 467  */
 468 void dmub_srv_destroy(struct dmub_srv *dmub);
 469
 470 /**
 471  * dmub_srv_calc_region_info() - retreives region info from the dmub service
 472  * @dmub: the dmub service
 473  * @params: parameters used to calculate region locations
 474  * @info_out: the output region info from dmub
 475  *
 476  * Calculates the base and top address for all relevant dmub regions
 477  * using the parameters given (if any).
 478  *
 479  * Return:
 480  *   DMUB_STATUS_OK - success
 481  *   DMUB_STATUS_INVALID - unspecified error
 482  */
 483 enum dmub_status
 484 dmub_srv_calc_region_info(struct dmub_srv *dmub,
 485                           const struct dmub_srv_region_params *params,
 486                           struct dmub_srv_region_info *out);
 487
 488 /**
 489  * dmub_srv_calc_region_info() - retreives fb info from the dmub service
 490  * @dmub: the dmub service
 491  * @params: parameters used to calculate fb locations
 492  * @info_out: the output fb info from dmub
 493  *
 494  * Calculates the base and top address for all relevant dmub regions
 495  * using the parameters given (if any).
 496  *
 497  * Return:
 498  *   DMUB_STATUS_OK - success
 499  *   DMUB_STATUS_INVALID - unspecified error
 500  */
 501 enum dmub_status dmub_srv_calc_fb_info(struct dmub_srv *dmub,
 502                                        const struct dmub_srv_fb_params *params,
 503                                        struct dmub_srv_fb_info *out);
 504
 505 /**
 506  * dmub_srv_has_hw_support() - returns hw support state for dmcub
 507  * @dmub: the dmub service
 508  * @is_supported: hw support state
 509  *
 510  * Queries the hardware for DMCUB support and returns the result.
 511  *
 512  * Can be called before dmub_srv_hw_init().
 513  *
 514  * Return:
 515  *   DMUB_STATUS_OK - success
 516  *   DMUB_STATUS_INVALID - unspecified error
 517  */
 518 enum dmub_status dmub_srv_has_hw_support(struct dmub_srv *dmub,
 519                                          bool *is_supported);
 520
 521 /**
 522  * dmub_srv_is_hw_init() - returns hardware init state
 523  *
 524  * Return:
 525  *   DMUB_STATUS_OK - success
 526  *   DMUB_STATUS_INVALID - unspecified error
 527  */
 528 enum dmub_status dmub_srv_is_hw_init(struct dmub_srv *dmub, bool *is_hw_init);
 529
 530 /**
 531  * dmub_srv_hw_init() - initializes the underlying DMUB hardware
 532  * @dmub: the dmub service
 533  * @params: params for hardware initialization
 534  *
 535  * Resets the DMUB hardware and performs backdoor loading of the
 536  * required cache regions based on the input framebuffer regions.
 537  *
 538  * Return:
 539  *   DMUB_STATUS_OK - success
 540  *   DMUB_STATUS_NO_CTX - dmcub context not initialized
 541  *   DMUB_STATUS_INVALID - unspecified error
 542  */
 543 enum dmub_status dmub_srv_hw_init(struct dmub_srv *dmub,
 544                                   const struct dmub_srv_hw_params *params);
 545
 546 /**
 547  * dmub_srv_hw_reset() - puts the DMUB hardware in reset state if initialized
 548  * @dmub: the dmub service
 549  *
 550  * Before destroying the DMUB service or releasing the backing framebuffer
 551  * memory we'll need to put the DMCUB into reset first.
 552  *
 553  * A subsequent call to dmub_srv_hw_init() will re-enable the DMCUB.
 554  *
 555  * Return:
 556  *   DMUB_STATUS_OK - success
 557  *   DMUB_STATUS_INVALID - unspecified error
 558  */
 559 enum dmub_status dmub_srv_hw_reset(struct dmub_srv *dmub);
 560
 561 /**
 562  * dmub_srv_cmd_queue() - queues a command to the DMUB
 563  * @dmub: the dmub service
 564  * @cmd: the command to queue
 565  *
 566  * Queues a command to the DMUB service but does not begin execution
 567  * immediately.
 568  *
 569  * Return:
 570  *   DMUB_STATUS_OK - success
 571  *   DMUB_STATUS_QUEUE_FULL - no remaining room in queue
 572  *   DMUB_STATUS_INVALID - unspecified error
 573  */
 574 enum dmub_status dmub_srv_cmd_queue(struct dmub_srv *dmub,
 575                                     const union dmub_rb_cmd *cmd);
 576
 577 /**
 578  * dmub_srv_cmd_execute() - Executes a queued sequence to the dmub
 579  * @dmub: the dmub service
 580  *
 581  * Begins execution of queued commands on the dmub.
 582  *
 583  * Return:
 584  *   DMUB_STATUS_OK - success
 585  *   DMUB_STATUS_INVALID - unspecified error
 586  */
 587 enum dmub_status dmub_srv_cmd_execute(struct dmub_srv *dmub);
 588
 589 /**
 590  * dmub_srv_wait_for_auto_load() - Waits for firmware auto load to complete
 591  * @dmub: the dmub service
 592  * @timeout_us: the maximum number of microseconds to wait
 593  *
 594  * Waits until firmware has been autoloaded by the DMCUB. The maximum
 595  * wait time is given in microseconds to prevent spinning forever.
 596  *
 597  * On ASICs without firmware autoload support this function will return
 598  * immediately.
 599  *
 600  * Return:
 601  *   DMUB_STATUS_OK - success
 602  *   DMUB_STATUS_TIMEOUT - wait for phy init timed out
 603  *   DMUB_STATUS_INVALID - unspecified error
 604  */
 605 enum dmub_status dmub_srv_wait_for_auto_load(struct dmub_srv *dmub,
 606                                              uint32_t timeout_us);
 607
 608 /**
 609  * dmub_srv_wait_for_phy_init() - Waits for DMUB PHY init to complete
 610  * @dmub: the dmub service
 611  * @timeout_us: the maximum number of microseconds to wait
 612  *
 613  * Waits until the PHY has been initialized by the DMUB. The maximum
 614  * wait time is given in microseconds to prevent spinning forever.
 615  *
 616  * On ASICs without PHY init support this function will return
 617  * immediately.
 618  *
 619  * Return:
 620  *   DMUB_STATUS_OK - success
 621  *   DMUB_STATUS_TIMEOUT - wait for phy init timed out
 622  *   DMUB_STATUS_INVALID - unspecified error
 623  */
 624 enum dmub_status dmub_srv_wait_for_phy_init(struct dmub_srv *dmub,
 625                                             uint32_t timeout_us);
 626
 627 /**
 628  * dmub_srv_wait_for_idle() - Waits for the DMUB to be idle
 629  * @dmub: the dmub service
 630  * @timeout_us: the maximum number of microseconds to wait
 631  *
 632  * Waits until the DMUB buffer is empty and all commands have
 633  * finished processing. The maximum wait time is given in
 634  * microseconds to prevent spinning forever.
 635  *
 636  * Return:
 637  *   DMUB_STATUS_OK - success
 638  *   DMUB_STATUS_TIMEOUT - wait for buffer to flush timed out
 639  *   DMUB_STATUS_INVALID - unspecified error
 640  */
 641 enum dmub_status dmub_srv_wait_for_idle(struct dmub_srv *dmub,
 642                                         uint32_t timeout_us);
 643
 644 /**
 645  * dmub_srv_send_gpint_command() - Sends a GPINT based command.
 646  * @dmub: the dmub service
 647  * @command_code: the command code to send
 648  * @param: the command parameter to send
 649  * @timeout_us: the maximum number of microseconds to wait
 650  *
 651  * Sends a command via the general purpose interrupt (GPINT).
 652  * Waits for the number of microseconds specified by timeout_us
 653  * for the command ACK before returning.
 654  *
 655  * Can be called after software initialization.
 656  *
 657  * Return:
 658  *   DMUB_STATUS_OK - success
 659  *   DMUB_STATUS_TIMEOUT - wait for ACK timed out
 660  *   DMUB_STATUS_INVALID - unspecified error
 661  */
 662 enum dmub_status
 663 dmub_srv_send_gpint_command(struct dmub_srv *dmub,
 664                             enum dmub_gpint_command command_code,
 665                             uint16_t param, uint32_t timeout_us);
 666
 667 /**
 668  * dmub_srv_get_gpint_response() - Queries the GPINT response.
 669  * @dmub: the dmub service
 670  * @response: the response for the last GPINT
 671  *
 672  * Returns the response code for the last GPINT interrupt.
 673  *
 674  * Can be called after software initialization.
 675  *
 676  * Return:
 677  *   DMUB_STATUS_OK - success
 678  *   DMUB_STATUS_INVALID - unspecified error
 679  */
 680 enum dmub_status dmub_srv_get_gpint_response(struct dmub_srv *dmub,
 681                                              uint32_t *response);
 682
 683 /**
 684  * dmub_srv_get_gpint_dataout() - Queries the GPINT DATAOUT.
 685  * @dmub: the dmub service
 686  * @dataout: the data for the GPINT DATAOUT
 687  *
 688  * Returns the response code for the last GPINT DATAOUT interrupt.
 689  *
 690  * Can be called after software initialization.
 691  *
 692  * Return:
 693  *   DMUB_STATUS_OK - success
 694  *   DMUB_STATUS_INVALID - unspecified error
 695  */
 696 enum dmub_status dmub_srv_get_gpint_dataout(struct dmub_srv *dmub,
 697                                              uint32_t *dataout);
 698
 699 /**
 700  * dmub_flush_buffer_mem() - Read back entire frame buffer region.
 701  * This ensures that the write from x86 has been flushed and will not
 702  * hang the DMCUB.
 703  * @fb: frame buffer to flush
 704  *
 705  * Can be called after software initialization.
 706  */
 707 void dmub_flush_buffer_mem(const struct dmub_fb *fb);
 708
 709 /**
 710  * dmub_srv_get_fw_boot_status() - Returns the DMUB boot status bits.
 711  *
 712  * @dmub: the dmub service
 713  * @status: out pointer for firmware status
 714  *
 715  * Return:
 716  *   DMUB_STATUS_OK - success
 717  *   DMUB_STATUS_INVALID - unspecified error, unsupported
 718  */
 719 enum dmub_status dmub_srv_get_fw_boot_status(struct dmub_srv *dmub,
 720                                              union dmub_fw_boot_status *status);
 721
 722 enum dmub_status dmub_srv_cmd_with_reply_data(struct dmub_srv *dmub,
 723                                               union dmub_rb_cmd *cmd);
 724
 725 bool dmub_srv_get_outbox0_msg(struct dmub_srv *dmub, struct dmcub_trace_buf_entry *entry);
 726
 727 bool dmub_srv_get_diagnostic_data(struct dmub_srv *dmub, struct dmub_diagnostic_data *diag_data);
 728
 729 bool dmub_srv_should_detect(struct dmub_srv *dmub);
 730
 731 #if defined(__cplusplus)
 732 }
 733 #endif
 734
 735 #endif /* _DMUB_SRV_H_ */