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         DMUB_STATUS_HW_FAILURE,
  88 };
  89
  90 /* enum dmub_asic - dmub asic identifier */
  91 enum dmub_asic {
  92         DMUB_ASIC_NONE = 0,
  93         DMUB_ASIC_DCN20,
  94         DMUB_ASIC_DCN21,
  95         DMUB_ASIC_DCN30,
  96         DMUB_ASIC_DCN301,
  97         DMUB_ASIC_DCN302,
  98         DMUB_ASIC_DCN303,
  99         DMUB_ASIC_DCN31,
 100         DMUB_ASIC_DCN31B,
 101         DMUB_ASIC_DCN314,
 102         DMUB_ASIC_DCN315,
 103         DMUB_ASIC_DCN316,
 104         DMUB_ASIC_DCN32,
 105         DMUB_ASIC_DCN321,
 106         DMUB_ASIC_MAX,
 107 };
 108
 109 /* enum dmub_window_id - dmub window identifier */
 110 enum dmub_window_id {
 111         DMUB_WINDOW_0_INST_CONST = 0,
 112         DMUB_WINDOW_1_STACK,
 113         DMUB_WINDOW_2_BSS_DATA,
 114         DMUB_WINDOW_3_VBIOS,
 115         DMUB_WINDOW_4_MAILBOX,
 116         DMUB_WINDOW_5_TRACEBUFF,
 117         DMUB_WINDOW_6_FW_STATE,
 118         DMUB_WINDOW_7_SCRATCH_MEM,
 119         DMUB_WINDOW_TOTAL,
 120 };
 121
 122 /* enum dmub_notification_type - dmub outbox notification identifier */
 123 enum dmub_notification_type {
 124         DMUB_NOTIFICATION_NO_DATA = 0,
 125         DMUB_NOTIFICATION_AUX_REPLY,
 126         DMUB_NOTIFICATION_HPD,
 127         DMUB_NOTIFICATION_HPD_IRQ,
 128         DMUB_NOTIFICATION_SET_CONFIG_REPLY,
 129         DMUB_NOTIFICATION_DPIA_NOTIFICATION,
 130         DMUB_NOTIFICATION_MAX
 131 };
 132
 133 /**
 134  * DPIA NOTIFICATION Response Type
 135  */
 136 enum dpia_notify_bw_alloc_status {
 137
 138         DPIA_BW_REQ_FAILED = 0,
 139         DPIA_BW_REQ_SUCCESS,
 140         DPIA_EST_BW_CHANGED,
 141         DPIA_BW_ALLOC_CAPS_CHANGED
 142 };
 143
 144 /**
 145  * struct dmub_region - dmub hw memory region
 146  * @base: base address for region, must be 256 byte aligned
 147  * @top: top address for region
 148  */
 149 struct dmub_region {
 150         uint32_t base;
 151         uint32_t top;
 152 };
 153
 154 /**
 155  * struct dmub_window - dmub hw cache window
 156  * @off: offset to the fb memory in gpu address space
 157  * @r: region in uc address space for cache window
 158  */
 159 struct dmub_window {
 160         union dmub_addr offset;
 161         struct dmub_region region;
 162 };
 163
 164 /**
 165  * struct dmub_fb - defines a dmub framebuffer memory region
 166  * @cpu_addr: cpu virtual address for the region, NULL if invalid
 167  * @gpu_addr: gpu virtual address for the region, NULL if invalid
 168  * @size: size of the region in bytes, zero if invalid
 169  */
 170 struct dmub_fb {
 171         void *cpu_addr;
 172         uint64_t gpu_addr;
 173         uint32_t size;
 174 };
 175
 176 /**
 177  * struct dmub_srv_region_params - params used for calculating dmub regions
 178  * @inst_const_size: size of the fw inst const section
 179  * @bss_data_size: size of the fw bss data section
 180  * @vbios_size: size of the vbios data
 181  * @fw_bss_data: raw firmware bss data section
 182  */
 183 struct dmub_srv_region_params {
 184         uint32_t inst_const_size;
 185         uint32_t bss_data_size;
 186         uint32_t vbios_size;
 187         const uint8_t *fw_inst_const;
 188         const uint8_t *fw_bss_data;
 189 };
 190
 191 /**
 192  * struct dmub_srv_region_info - output region info from the dmub service
 193  * @fb_size: required minimum fb size for all regions, aligned to 4096 bytes
 194  * @num_regions: number of regions used by the dmub service
 195  * @regions: region info
 196  *
 197  * The regions are aligned such that they can be all placed within the
 198  * same framebuffer but they can also be placed into different framebuffers.
 199  *
 200  * The size of each region can be calculated by the caller:
 201  * size = reg.top - reg.base
 202  *
 203  * Care must be taken when performing custom allocations to ensure that each
 204  * region base address is 256 byte aligned.
 205  */
 206 struct dmub_srv_region_info {
 207         uint32_t fb_size;
 208         uint8_t num_regions;
 209         struct dmub_region regions[DMUB_WINDOW_TOTAL];
 210 };
 211
 212 /**
 213  * struct dmub_srv_fb_params - parameters used for driver fb setup
 214  * @region_info: region info calculated by dmub service
 215  * @cpu_addr: base cpu address for the framebuffer
 216  * @gpu_addr: base gpu virtual address for the framebuffer
 217  */
 218 struct dmub_srv_fb_params {
 219         const struct dmub_srv_region_info *region_info;
 220         void *cpu_addr;
 221         uint64_t gpu_addr;
 222 };
 223
 224 /**
 225  * struct dmub_srv_fb_info - output fb info from the dmub service
 226  * @num_fbs: number of required dmub framebuffers
 227  * @fbs: fb data for each region
 228  *
 229  * Output from the dmub service helper that can be used by the
 230  * driver to prepare dmub_fb that can be passed into the dmub
 231  * hw init service.
 232  *
 233  * Assumes that all regions are within the same framebuffer
 234  * and have been setup according to the region_info generated
 235  * by the dmub service.
 236  */
 237 struct dmub_srv_fb_info {
 238         uint8_t num_fb;
 239         struct dmub_fb fb[DMUB_WINDOW_TOTAL];
 240 };
 241
 242 /*
 243  * struct dmub_srv_hw_params - params for dmub hardware initialization
 244  * @fb: framebuffer info for each region
 245  * @fb_base: base of the framebuffer aperture
 246  * @fb_offset: offset of the framebuffer aperture
 247  * @psp_version: psp version to pass for DMCU init
 248  * @load_inst_const: true if DMUB should load inst const fw
 249  */
 250 struct dmub_srv_hw_params {
 251         struct dmub_fb *fb[DMUB_WINDOW_TOTAL];
 252         uint64_t fb_base;
 253         uint64_t fb_offset;
 254         uint32_t psp_version;
 255         bool load_inst_const;
 256         bool skip_panel_power_sequence;
 257         bool disable_z10;
 258         bool power_optimization;
 259         bool dpia_supported;
 260         bool disable_dpia;
 261         bool usb4_cm_version;
 262         bool fw_in_system_memory;
 263         bool dpia_hpd_int_enable_supported;
 264         bool disable_clock_gate;
 265         bool disallow_dispclk_dppclk_ds;
 266 };
 267
 268 /**
 269  * struct dmub_diagnostic_data - Diagnostic data retrieved from DMCUB for
 270  * debugging purposes, including logging, crash analysis, etc.
 271  */
 272 struct dmub_diagnostic_data {
 273         uint32_t dmcub_version;
 274         uint32_t scratch[17];
 275         uint32_t pc;
 276         uint32_t undefined_address_fault_addr;
 277         uint32_t inst_fetch_fault_addr;
 278         uint32_t data_write_fault_addr;
 279         uint32_t inbox1_rptr;
 280         uint32_t inbox1_wptr;
 281         uint32_t inbox1_size;
 282         uint32_t inbox0_rptr;
 283         uint32_t inbox0_wptr;
 284         uint32_t inbox0_size;
 285         uint32_t gpint_datain0;
 286         uint8_t is_dmcub_enabled : 1;
 287         uint8_t is_dmcub_soft_reset : 1;
 288         uint8_t is_dmcub_secure_reset : 1;
 289         uint8_t is_traceport_en : 1;
 290         uint8_t is_cw0_enabled : 1;
 291         uint8_t is_cw6_enabled : 1;
 292 };
 293
 294 /**
 295  * struct dmub_srv_base_funcs - Driver specific base callbacks
 296  */
 297 struct dmub_srv_base_funcs {
 298         /**
 299          * @reg_read:
 300          *
 301          * Hook for reading a register.
 302          *
 303          * Return: The 32-bit register value from the given address.
 304          */
 305         uint32_t (*reg_read)(void *ctx, uint32_t address);
 306
 307         /**
 308          * @reg_write:
 309          *
 310          * Hook for writing a value to the register specified by address.
 311          */
 312         void (*reg_write)(void *ctx, uint32_t address, uint32_t value);
 313 };
 314
 315 /**
 316  * struct dmub_srv_hw_funcs - hardware sequencer funcs for dmub
 317  */
 318 struct dmub_srv_hw_funcs {
 319         /* private: internal use only */
 320
 321         void (*init)(struct dmub_srv *dmub);
 322
 323         void (*reset)(struct dmub_srv *dmub);
 324
 325         void (*reset_release)(struct dmub_srv *dmub);
 326
 327         void (*backdoor_load)(struct dmub_srv *dmub,
 328                               const struct dmub_window *cw0,
 329                               const struct dmub_window *cw1);
 330
 331         void (*backdoor_load_zfb_mode)(struct dmub_srv *dmub,
 332                               const struct dmub_window *cw0,
 333                               const struct dmub_window *cw1);
 334         void (*setup_windows)(struct dmub_srv *dmub,
 335                               const struct dmub_window *cw2,
 336                               const struct dmub_window *cw3,
 337                               const struct dmub_window *cw4,
 338                               const struct dmub_window *cw5,
 339                               const struct dmub_window *cw6);
 340
 341         void (*setup_mailbox)(struct dmub_srv *dmub,
 342                               const struct dmub_region *inbox1);
 343
 344         uint32_t (*get_inbox1_wptr)(struct dmub_srv *dmub);
 345
 346         uint32_t (*get_inbox1_rptr)(struct dmub_srv *dmub);
 347
 348         void (*set_inbox1_wptr)(struct dmub_srv *dmub, uint32_t wptr_offset);
 349
 350         void (*setup_out_mailbox)(struct dmub_srv *dmub,
 351                               const struct dmub_region *outbox1);
 352
 353         uint32_t (*get_outbox1_wptr)(struct dmub_srv *dmub);
 354
 355         void (*set_outbox1_rptr)(struct dmub_srv *dmub, uint32_t rptr_offset);
 356
 357         void (*setup_outbox0)(struct dmub_srv *dmub,
 358                               const struct dmub_region *outbox0);
 359
 360         uint32_t (*get_outbox0_wptr)(struct dmub_srv *dmub);
 361
 362         void (*set_outbox0_rptr)(struct dmub_srv *dmub, uint32_t rptr_offset);
 363
 364         uint32_t (*emul_get_inbox1_rptr)(struct dmub_srv *dmub);
 365
 366         void (*emul_set_inbox1_wptr)(struct dmub_srv *dmub, uint32_t wptr_offset);
 367
 368         bool (*is_supported)(struct dmub_srv *dmub);
 369
 370         bool (*is_psrsu_supported)(struct dmub_srv *dmub);
 371
 372         bool (*is_hw_init)(struct dmub_srv *dmub);
 373
 374         void (*enable_dmub_boot_options)(struct dmub_srv *dmub,
 375                                 const struct dmub_srv_hw_params *params);
 376
 377         void (*skip_dmub_panel_power_sequence)(struct dmub_srv *dmub, bool skip);
 378
 379         union dmub_fw_boot_status (*get_fw_status)(struct dmub_srv *dmub);
 380
 381
 382         void (*set_gpint)(struct dmub_srv *dmub,
 383                           union dmub_gpint_data_register reg);
 384
 385         bool (*is_gpint_acked)(struct dmub_srv *dmub,
 386                                union dmub_gpint_data_register reg);
 387
 388         uint32_t (*get_gpint_response)(struct dmub_srv *dmub);
 389
 390         uint32_t (*get_gpint_dataout)(struct dmub_srv *dmub);
 391
 392         void (*configure_dmub_in_system_memory)(struct dmub_srv *dmub);
 393         void (*clear_inbox0_ack_register)(struct dmub_srv *dmub);
 394         uint32_t (*read_inbox0_ack_register)(struct dmub_srv *dmub);
 395         void (*send_inbox0_cmd)(struct dmub_srv *dmub, union dmub_inbox0_data_register data);
 396         uint32_t (*get_current_time)(struct dmub_srv *dmub);
 397
 398         void (*get_diagnostic_data)(struct dmub_srv *dmub, struct dmub_diagnostic_data *dmub_oca);
 399
 400         bool (*should_detect)(struct dmub_srv *dmub);
 401 };
 402
 403 /**
 404  * struct dmub_srv_create_params - params for dmub service creation
 405  * @base_funcs: driver supplied base routines
 406  * @hw_funcs: optional overrides for hw funcs
 407  * @user_ctx: context data for callback funcs
 408  * @asic: driver supplied asic
 409  * @fw_version: the current firmware version, if any
 410  * @is_virtual: false for hw support only
 411  */
 412 struct dmub_srv_create_params {
 413         struct dmub_srv_base_funcs funcs;
 414         struct dmub_srv_hw_funcs *hw_funcs;
 415         void *user_ctx;
 416         enum dmub_asic asic;
 417         uint32_t fw_version;
 418         bool is_virtual;
 419 };
 420
 421 /**
 422  * struct dmub_srv - software state for dmcub
 423  * @asic: dmub asic identifier
 424  * @user_ctx: user provided context for the dmub_srv
 425  * @fw_version: the current firmware version, if any
 426  * @is_virtual: false if hardware support only
 427  * @fw_state: dmub firmware state pointer
 428  */
 429 struct dmub_srv {
 430         enum dmub_asic asic;
 431         void *user_ctx;
 432         uint32_t fw_version;
 433         bool is_virtual;
 434         struct dmub_fb scratch_mem_fb;
 435         volatile const struct dmub_fw_state *fw_state;
 436
 437         /* private: internal use only */
 438         const struct dmub_srv_common_regs *regs;
 439         const struct dmub_srv_dcn31_regs *regs_dcn31;
 440         const struct dmub_srv_dcn32_regs *regs_dcn32;
 441
 442         struct dmub_srv_base_funcs funcs;
 443         struct dmub_srv_hw_funcs hw_funcs;
 444         struct dmub_rb inbox1_rb;
 445         uint32_t inbox1_last_wptr;
 446         /**
 447          * outbox1_rb is accessed without locks (dal & dc)
 448          * and to be used only in dmub_srv_stat_get_notification()
 449          */
 450         struct dmub_rb outbox1_rb;
 451
 452         struct dmub_rb outbox0_rb;
 453
 454         bool sw_init;
 455         bool hw_init;
 456
 457         uint64_t fb_base;
 458         uint64_t fb_offset;
 459         uint32_t psp_version;
 460
 461         /* Feature capabilities reported by fw */
 462         struct dmub_feature_caps feature_caps;
 463         struct dmub_visual_confirm_color visual_confirm_color;
 464 };
 465
 466 /**
 467  * struct dmub_notification - dmub notification data
 468  * @type: dmub notification type
 469  * @link_index: link index to identify aux connection
 470  * @result: USB4 status returned from dmub
 471  * @pending_notification: Indicates there are other pending notifications
 472  * @aux_reply: aux reply
 473  * @hpd_status: hpd status
 474  * @bw_alloc_reply: BW Allocation reply from CM/DPIA
 475  */
 476 struct dmub_notification {
 477         enum dmub_notification_type type;
 478         uint8_t link_index;
 479         uint8_t result;
 480         bool pending_notification;
 481         union {
 482                 struct aux_reply_data aux_reply;
 483                 enum dp_hpd_status hpd_status;
 484                 enum set_config_status sc_status;
 485                 /**
 486                  * DPIA notification command.
 487                  */
 488                 struct dmub_rb_cmd_dpia_notification dpia_notification;
 489         };
 490 };
 491
 492 /**
 493  * DMUB firmware version helper macro - useful for checking if the version
 494  * of a firmware to know if feature or functionality is supported or present.
 495  */
 496 #define DMUB_FW_VERSION(major, minor, revision) \
 497         ((((major) & 0xFF) << 24) | (((minor) & 0xFF) << 16) | (((revision) & 0xFF) << 8))
 498
 499 /**
 500  * dmub_srv_create() - creates the DMUB service.
 501  * @dmub: the dmub service
 502  * @params: creation parameters for the service
 503  *
 504  * Return:
 505  *   DMUB_STATUS_OK - success
 506  *   DMUB_STATUS_INVALID - unspecified error
 507  */
 508 enum dmub_status dmub_srv_create(struct dmub_srv *dmub,
 509                                  const struct dmub_srv_create_params *params);
 510
 511 /**
 512  * dmub_srv_destroy() - destroys the DMUB service.
 513  * @dmub: the dmub service
 514  */
 515 void dmub_srv_destroy(struct dmub_srv *dmub);
 516
 517 /**
 518  * dmub_srv_calc_region_info() - retreives region info from the dmub service
 519  * @dmub: the dmub service
 520  * @params: parameters used to calculate region locations
 521  * @info_out: the output region info from dmub
 522  *
 523  * Calculates the base and top address for all relevant dmub regions
 524  * using the parameters given (if any).
 525  *
 526  * Return:
 527  *   DMUB_STATUS_OK - success
 528  *   DMUB_STATUS_INVALID - unspecified error
 529  */
 530 enum dmub_status
 531 dmub_srv_calc_region_info(struct dmub_srv *dmub,
 532                           const struct dmub_srv_region_params *params,
 533                           struct dmub_srv_region_info *out);
 534
 535 /**
 536  * dmub_srv_calc_region_info() - retreives fb info from the dmub service
 537  * @dmub: the dmub service
 538  * @params: parameters used to calculate fb locations
 539  * @info_out: the output fb info from dmub
 540  *
 541  * Calculates the base and top address for all relevant dmub regions
 542  * using the parameters given (if any).
 543  *
 544  * Return:
 545  *   DMUB_STATUS_OK - success
 546  *   DMUB_STATUS_INVALID - unspecified error
 547  */
 548 enum dmub_status dmub_srv_calc_fb_info(struct dmub_srv *dmub,
 549                                        const struct dmub_srv_fb_params *params,
 550                                        struct dmub_srv_fb_info *out);
 551
 552 /**
 553  * dmub_srv_has_hw_support() - returns hw support state for dmcub
 554  * @dmub: the dmub service
 555  * @is_supported: hw support state
 556  *
 557  * Queries the hardware for DMCUB support and returns the result.
 558  *
 559  * Can be called before dmub_srv_hw_init().
 560  *
 561  * Return:
 562  *   DMUB_STATUS_OK - success
 563  *   DMUB_STATUS_INVALID - unspecified error
 564  */
 565 enum dmub_status dmub_srv_has_hw_support(struct dmub_srv *dmub,
 566                                          bool *is_supported);
 567
 568 /**
 569  * dmub_srv_is_hw_init() - returns hardware init state
 570  *
 571  * Return:
 572  *   DMUB_STATUS_OK - success
 573  *   DMUB_STATUS_INVALID - unspecified error
 574  */
 575 enum dmub_status dmub_srv_is_hw_init(struct dmub_srv *dmub, bool *is_hw_init);
 576
 577 /**
 578  * dmub_srv_hw_init() - initializes the underlying DMUB hardware
 579  * @dmub: the dmub service
 580  * @params: params for hardware initialization
 581  *
 582  * Resets the DMUB hardware and performs backdoor loading of the
 583  * required cache regions based on the input framebuffer regions.
 584  *
 585  * Return:
 586  *   DMUB_STATUS_OK - success
 587  *   DMUB_STATUS_NO_CTX - dmcub context not initialized
 588  *   DMUB_STATUS_INVALID - unspecified error
 589  */
 590 enum dmub_status dmub_srv_hw_init(struct dmub_srv *dmub,
 591                                   const struct dmub_srv_hw_params *params);
 592
 593 /**
 594  * dmub_srv_hw_reset() - puts the DMUB hardware in reset state if initialized
 595  * @dmub: the dmub service
 596  *
 597  * Before destroying the DMUB service or releasing the backing framebuffer
 598  * memory we'll need to put the DMCUB into reset first.
 599  *
 600  * A subsequent call to dmub_srv_hw_init() will re-enable the DMCUB.
 601  *
 602  * Return:
 603  *   DMUB_STATUS_OK - success
 604  *   DMUB_STATUS_INVALID - unspecified error
 605  */
 606 enum dmub_status dmub_srv_hw_reset(struct dmub_srv *dmub);
 607
 608 /**
 609  * dmub_srv_sync_inbox1() - sync sw state with hw state
 610  * @dmub: the dmub service
 611  *
 612  * Sync sw state with hw state when resume from S0i3
 613  *
 614  * Return:
 615  *   DMUB_STATUS_OK - success
 616  *   DMUB_STATUS_INVALID - unspecified error
 617  */
 618 enum dmub_status dmub_srv_sync_inbox1(struct dmub_srv *dmub);
 619
 620 /**
 621  * dmub_srv_cmd_queue() - queues a command to the DMUB
 622  * @dmub: the dmub service
 623  * @cmd: the command to queue
 624  *
 625  * Queues a command to the DMUB service but does not begin execution
 626  * immediately.
 627  *
 628  * Return:
 629  *   DMUB_STATUS_OK - success
 630  *   DMUB_STATUS_QUEUE_FULL - no remaining room in queue
 631  *   DMUB_STATUS_INVALID - unspecified error
 632  */
 633 enum dmub_status dmub_srv_cmd_queue(struct dmub_srv *dmub,
 634                                     const union dmub_rb_cmd *cmd);
 635
 636 /**
 637  * dmub_srv_cmd_execute() - Executes a queued sequence to the dmub
 638  * @dmub: the dmub service
 639  *
 640  * Begins execution of queued commands on the dmub.
 641  *
 642  * Return:
 643  *   DMUB_STATUS_OK - success
 644  *   DMUB_STATUS_INVALID - unspecified error
 645  */
 646 enum dmub_status dmub_srv_cmd_execute(struct dmub_srv *dmub);
 647
 648 /**
 649  * dmub_srv_wait_for_auto_load() - Waits for firmware auto load to complete
 650  * @dmub: the dmub service
 651  * @timeout_us: the maximum number of microseconds to wait
 652  *
 653  * Waits until firmware has been autoloaded by the DMCUB. The maximum
 654  * wait time is given in microseconds to prevent spinning forever.
 655  *
 656  * On ASICs without firmware autoload support this function will return
 657  * immediately.
 658  *
 659  * Return:
 660  *   DMUB_STATUS_OK - success
 661  *   DMUB_STATUS_TIMEOUT - wait for phy init timed out
 662  *   DMUB_STATUS_INVALID - unspecified error
 663  */
 664 enum dmub_status dmub_srv_wait_for_auto_load(struct dmub_srv *dmub,
 665                                              uint32_t timeout_us);
 666
 667 /**
 668  * dmub_srv_wait_for_phy_init() - Waits for DMUB PHY init to complete
 669  * @dmub: the dmub service
 670  * @timeout_us: the maximum number of microseconds to wait
 671  *
 672  * Waits until the PHY has been initialized by the DMUB. The maximum
 673  * wait time is given in microseconds to prevent spinning forever.
 674  *
 675  * On ASICs without PHY init support this function will return
 676  * immediately.
 677  *
 678  * Return:
 679  *   DMUB_STATUS_OK - success
 680  *   DMUB_STATUS_TIMEOUT - wait for phy init timed out
 681  *   DMUB_STATUS_INVALID - unspecified error
 682  */
 683 enum dmub_status dmub_srv_wait_for_phy_init(struct dmub_srv *dmub,
 684                                             uint32_t timeout_us);
 685
 686 /**
 687  * dmub_srv_wait_for_idle() - Waits for the DMUB to be idle
 688  * @dmub: the dmub service
 689  * @timeout_us: the maximum number of microseconds to wait
 690  *
 691  * Waits until the DMUB buffer is empty and all commands have
 692  * finished processing. The maximum wait time is given in
 693  * microseconds to prevent spinning forever.
 694  *
 695  * Return:
 696  *   DMUB_STATUS_OK - success
 697  *   DMUB_STATUS_TIMEOUT - wait for buffer to flush timed out
 698  *   DMUB_STATUS_INVALID - unspecified error
 699  */
 700 enum dmub_status dmub_srv_wait_for_idle(struct dmub_srv *dmub,
 701                                         uint32_t timeout_us);
 702
 703 /**
 704  * dmub_srv_send_gpint_command() - Sends a GPINT based command.
 705  * @dmub: the dmub service
 706  * @command_code: the command code to send
 707  * @param: the command parameter to send
 708  * @timeout_us: the maximum number of microseconds to wait
 709  *
 710  * Sends a command via the general purpose interrupt (GPINT).
 711  * Waits for the number of microseconds specified by timeout_us
 712  * for the command ACK before returning.
 713  *
 714  * Can be called after software initialization.
 715  *
 716  * Return:
 717  *   DMUB_STATUS_OK - success
 718  *   DMUB_STATUS_TIMEOUT - wait for ACK timed out
 719  *   DMUB_STATUS_INVALID - unspecified error
 720  */
 721 enum dmub_status
 722 dmub_srv_send_gpint_command(struct dmub_srv *dmub,
 723                             enum dmub_gpint_command command_code,
 724                             uint16_t param, uint32_t timeout_us);
 725
 726 /**
 727  * dmub_srv_get_gpint_response() - Queries the GPINT response.
 728  * @dmub: the dmub service
 729  * @response: the response for the last GPINT
 730  *
 731  * Returns the response code for the last GPINT interrupt.
 732  *
 733  * Can be called after software initialization.
 734  *
 735  * Return:
 736  *   DMUB_STATUS_OK - success
 737  *   DMUB_STATUS_INVALID - unspecified error
 738  */
 739 enum dmub_status dmub_srv_get_gpint_response(struct dmub_srv *dmub,
 740                                              uint32_t *response);
 741
 742 /**
 743  * dmub_srv_get_gpint_dataout() - Queries the GPINT DATAOUT.
 744  * @dmub: the dmub service
 745  * @dataout: the data for the GPINT DATAOUT
 746  *
 747  * Returns the response code for the last GPINT DATAOUT interrupt.
 748  *
 749  * Can be called after software initialization.
 750  *
 751  * Return:
 752  *   DMUB_STATUS_OK - success
 753  *   DMUB_STATUS_INVALID - unspecified error
 754  */
 755 enum dmub_status dmub_srv_get_gpint_dataout(struct dmub_srv *dmub,
 756                                              uint32_t *dataout);
 757
 758 /**
 759  * dmub_flush_buffer_mem() - Read back entire frame buffer region.
 760  * This ensures that the write from x86 has been flushed and will not
 761  * hang the DMCUB.
 762  * @fb: frame buffer to flush
 763  *
 764  * Can be called after software initialization.
 765  */
 766 void dmub_flush_buffer_mem(const struct dmub_fb *fb);
 767
 768 /**
 769  * dmub_srv_get_fw_boot_status() - Returns the DMUB boot status bits.
 770  *
 771  * @dmub: the dmub service
 772  * @status: out pointer for firmware status
 773  *
 774  * Return:
 775  *   DMUB_STATUS_OK - success
 776  *   DMUB_STATUS_INVALID - unspecified error, unsupported
 777  */
 778 enum dmub_status dmub_srv_get_fw_boot_status(struct dmub_srv *dmub,
 779                                              union dmub_fw_boot_status *status);
 780
 781 enum dmub_status dmub_srv_cmd_with_reply_data(struct dmub_srv *dmub,
 782                                               union dmub_rb_cmd *cmd);
 783
 784 bool dmub_srv_get_outbox0_msg(struct dmub_srv *dmub, struct dmcub_trace_buf_entry *entry);
 785
 786 bool dmub_srv_get_diagnostic_data(struct dmub_srv *dmub, struct dmub_diagnostic_data *diag_data);
 787
 788 bool dmub_srv_should_detect(struct dmub_srv *dmub);
 789
 790 /**
 791  * dmub_srv_send_inbox0_cmd() - Send command to DMUB using INBOX0
 792  * @dmub: the dmub service
 793  * @data: the data to be sent in the INBOX0 command
 794  *
 795  * Send command by writing directly to INBOX0 WPTR
 796  *
 797  * Return:
 798  *   DMUB_STATUS_OK - success
 799  *   DMUB_STATUS_INVALID - hw_init false or hw function does not exist
 800  */
 801 enum dmub_status dmub_srv_send_inbox0_cmd(struct dmub_srv *dmub, union dmub_inbox0_data_register data);
 802
 803 /**
 804  * dmub_srv_wait_for_inbox0_ack() - wait for DMUB to ACK INBOX0 command
 805  * @dmub: the dmub service
 806  * @timeout_us: the maximum number of microseconds to wait
 807  *
 808  * Wait for DMUB to ACK the INBOX0 message
 809  *
 810  * Return:
 811  *   DMUB_STATUS_OK - success
 812  *   DMUB_STATUS_INVALID - hw_init false or hw function does not exist
 813  *   DMUB_STATUS_TIMEOUT - wait for ack timed out
 814  */
 815 enum dmub_status dmub_srv_wait_for_inbox0_ack(struct dmub_srv *dmub, uint32_t timeout_us);
 816
 817 /**
 818  * dmub_srv_wait_for_inbox0_ack() - clear ACK register for INBOX0
 819  * @dmub: the dmub service
 820  *
 821  * Clear ACK register for INBOX0
 822  *
 823  * Return:
 824  *   DMUB_STATUS_OK - success
 825  *   DMUB_STATUS_INVALID - hw_init false or hw function does not exist
 826  */
 827 enum dmub_status dmub_srv_clear_inbox0_ack(struct dmub_srv *dmub);
 828
 829 #if defined(__cplusplus)
 830 }
 831 #endif
 832
 833 #endif /* _DMUB_SRV_H_ */