drivers/gpu/drm/xe/xe_display.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright © 2023 Intel Corporation
   4  */
   5
   6 #include "xe_display.h"
   7 #include "regs/xe_regs.h"
   8
   9 #include <linux/fb.h>
  10
  11 #include <drm/drm_drv.h>
  12 #include <drm/drm_managed.h>
  13 #include <drm/xe_drm.h>
  14
  15 #include "soc/intel_dram.h"
  16 #include "i915_drv.h"           /* FIXME: HAS_DISPLAY() depends on this */
  17 #include "intel_acpi.h"
  18 #include "intel_audio.h"
  19 #include "intel_bw.h"
  20 #include "intel_display.h"
  21 #include "intel_display_driver.h"
  22 #include "intel_display_irq.h"
  23 #include "intel_display_types.h"
  24 #include "intel_dmc.h"
  25 #include "intel_dp.h"
  26 #include "intel_fbdev.h"
  27 #include "intel_hdcp.h"
  28 #include "intel_hotplug.h"
  29 #include "intel_opregion.h"
  30 #include "xe_module.h"
  31
  32 /* Xe device functions */
  33
  34 static bool has_display(struct xe_device *xe)
  35 {
  36         return HAS_DISPLAY(xe);
  37 }
  38
  39 /**
  40  * xe_display_driver_probe_defer - Detect if we need to wait for other drivers
  41  *                                 early on
  42  * @pdev: PCI device
  43  *
  44  * Returns: true if probe needs to be deferred, false otherwise
  45  */
  46 bool xe_display_driver_probe_defer(struct pci_dev *pdev)
  47 {
  48         if (!enable_display)
  49                 return 0;
  50
  51         return intel_display_driver_probe_defer(pdev);
  52 }
  53
  54 static void xe_display_last_close(struct drm_device *dev)
  55 {
  56         struct xe_device *xe = to_xe_device(dev);
  57
  58         if (xe->info.enable_display)
  59                 intel_fbdev_restore_mode(to_xe_device(dev));
  60 }
  61
  62 /**
  63  * xe_display_driver_set_hooks - Add driver flags and hooks for display
  64  * @driver: DRM device driver
  65  *
  66  * Set features and function hooks in @driver that are needed for driving the
  67  * display IP. This sets the driver's capability of driving display, regardless
  68  * if the device has it enabled
  69  */
  70 void xe_display_driver_set_hooks(struct drm_driver *driver)
  71 {
  72         if (!enable_display)
  73                 return;
  74
  75         driver->driver_features |= DRIVER_MODESET | DRIVER_ATOMIC;
  76         driver->lastclose = xe_display_last_close;
  77 }
  78
  79 static void unset_display_features(struct xe_device *xe)
  80 {
  81         xe->drm.driver_features &= ~(DRIVER_MODESET | DRIVER_ATOMIC);
  82 }
  83
  84 static void display_destroy(struct drm_device *dev, void *dummy)
  85 {
  86         struct xe_device *xe = to_xe_device(dev);
  87
  88         destroy_workqueue(xe->display.hotplug.dp_wq);
  89 }
  90
  91 /**
  92  * xe_display_create - create display struct
  93  * @xe: XE device instance
  94  *
  95  * Initialize all fields used by the display part.
  96  *
  97  * TODO: once everything can be inside a single struct, make the struct opaque
  98  * to the rest of xe and return it to be xe->display.
  99  *
 100  * Returns: 0 on success
 101  */
 102 int xe_display_create(struct xe_device *xe)
 103 {
 104         int err;
 105
 106         spin_lock_init(&xe->display.fb_tracking.lock);
 107
 108         xe->display.hotplug.dp_wq = alloc_ordered_workqueue("xe-dp", 0);
 109
 110         drmm_mutex_init(&xe->drm, &xe->sb_lock);
 111         drmm_mutex_init(&xe->drm, &xe->display.backlight.lock);
 112         drmm_mutex_init(&xe->drm, &xe->display.audio.mutex);
 113         drmm_mutex_init(&xe->drm, &xe->display.wm.wm_mutex);
 114         drmm_mutex_init(&xe->drm, &xe->display.pps.mutex);
 115         drmm_mutex_init(&xe->drm, &xe->display.hdcp.hdcp_mutex);
 116         xe->enabled_irq_mask = ~0;
 117
 118         err = drmm_add_action_or_reset(&xe->drm, display_destroy, NULL);
 119         if (err)
 120                 return err;
 121
 122         return 0;
 123 }
 124
 125 static void xe_display_fini_nommio(struct drm_device *dev, void *dummy)
 126 {
 127         struct xe_device *xe = to_xe_device(dev);
 128
 129         if (!xe->info.enable_display)
 130                 return;
 131
 132         intel_power_domains_cleanup(xe);
 133 }
 134
 135 int xe_display_init_nommio(struct xe_device *xe)
 136 {
 137         int err;
 138
 139         if (!xe->info.enable_display)
 140                 return 0;
 141
 142         /* Fake uncore lock */
 143         spin_lock_init(&xe->uncore.lock);
 144
 145         /* This must be called before any calls to HAS_PCH_* */
 146         intel_detect_pch(xe);
 147
 148         err = intel_power_domains_init(xe);
 149         if (err)
 150                 return err;
 151
 152         return drmm_add_action_or_reset(&xe->drm, xe_display_fini_nommio, xe);
 153 }
 154
 155 static void xe_display_fini_noirq(struct drm_device *dev, void *dummy)
 156 {
 157         struct xe_device *xe = to_xe_device(dev);
 158
 159         if (!xe->info.enable_display)
 160                 return;
 161
 162         intel_display_driver_remove_noirq(xe);
 163         intel_power_domains_driver_remove(xe);
 164 }
 165
 166 int xe_display_init_noirq(struct xe_device *xe)
 167 {
 168         int err;
 169
 170         if (!xe->info.enable_display)
 171                 return 0;
 172
 173         intel_display_driver_early_probe(xe);
 174
 175         /* Early display init.. */
 176         intel_opregion_setup(xe);
 177
 178         /*
 179          * Fill the dram structure to get the system dram info. This will be
 180          * used for memory latency calculation.
 181          */
 182         intel_dram_detect(xe);
 183
 184         intel_bw_init_hw(xe);
 185
 186         intel_display_device_info_runtime_init(xe);
 187
 188         err = intel_display_driver_probe_noirq(xe);
 189         if (err)
 190                 return err;
 191
 192         return drmm_add_action_or_reset(&xe->drm, xe_display_fini_noirq, NULL);
 193 }
 194
 195 static void xe_display_fini_noaccel(struct drm_device *dev, void *dummy)
 196 {
 197         struct xe_device *xe = to_xe_device(dev);
 198
 199         if (!xe->info.enable_display)
 200                 return;
 201
 202         intel_display_driver_remove_nogem(xe);
 203 }
 204
 205 int xe_display_init_noaccel(struct xe_device *xe)
 206 {
 207         int err;
 208
 209         if (!xe->info.enable_display)
 210                 return 0;
 211
 212         err = intel_display_driver_probe_nogem(xe);
 213         if (err)
 214                 return err;
 215
 216         return drmm_add_action_or_reset(&xe->drm, xe_display_fini_noaccel, NULL);
 217 }
 218
 219 int xe_display_init(struct xe_device *xe)
 220 {
 221         if (!xe->info.enable_display)
 222                 return 0;
 223
 224         return intel_display_driver_probe(xe);
 225 }
 226
 227 void xe_display_fini(struct xe_device *xe)
 228 {
 229         if (!xe->info.enable_display)
 230                 return;
 231
 232         /* poll work can call into fbdev, hence clean that up afterwards */
 233         intel_hpd_poll_fini(xe);
 234         intel_fbdev_fini(xe);
 235
 236         intel_hdcp_component_fini(xe);
 237         intel_audio_deinit(xe);
 238 }
 239
 240 void xe_display_register(struct xe_device *xe)
 241 {
 242         if (!xe->info.enable_display)
 243                 return;
 244
 245         intel_display_driver_register(xe);
 246         intel_register_dsm_handler();
 247         intel_power_domains_enable(xe);
 248 }
 249
 250 void xe_display_unregister(struct xe_device *xe)
 251 {
 252         if (!xe->info.enable_display)
 253                 return;
 254
 255         intel_unregister_dsm_handler();
 256         intel_power_domains_disable(xe);
 257         intel_display_driver_unregister(xe);
 258 }
 259
 260 void xe_display_driver_remove(struct xe_device *xe)
 261 {
 262         if (!xe->info.enable_display)
 263                 return;
 264
 265         intel_display_driver_remove(xe);
 266
 267         intel_display_device_remove(xe);
 268 }
 269
 270 /* IRQ-related functions */
 271
 272 void xe_display_irq_handler(struct xe_device *xe, u32 master_ctl)
 273 {
 274         if (!xe->info.enable_display)
 275                 return;
 276
 277         if (master_ctl & DISPLAY_IRQ)
 278                 gen11_display_irq_handler(xe);
 279 }
 280
 281 void xe_display_irq_enable(struct xe_device *xe, u32 gu_misc_iir)
 282 {
 283         if (!xe->info.enable_display)
 284                 return;
 285
 286         if (gu_misc_iir & GU_MISC_GSE)
 287                 intel_opregion_asle_intr(xe);
 288 }
 289
 290 void xe_display_irq_reset(struct xe_device *xe)
 291 {
 292         if (!xe->info.enable_display)
 293                 return;
 294
 295         gen11_display_irq_reset(xe);
 296 }
 297
 298 void xe_display_irq_postinstall(struct xe_device *xe, struct xe_gt *gt)
 299 {
 300         if (!xe->info.enable_display)
 301                 return;
 302
 303         if (gt->info.id == XE_GT0)
 304                 gen11_de_irq_postinstall(xe);
 305 }
 306
 307 static void intel_suspend_encoders(struct xe_device *xe)
 308 {
 309         struct drm_device *dev = &xe->drm;
 310         struct intel_encoder *encoder;
 311
 312         if (has_display(xe))
 313                 return;
 314
 315         drm_modeset_lock_all(dev);
 316         for_each_intel_encoder(dev, encoder)
 317                 if (encoder->suspend)
 318                         encoder->suspend(encoder);
 319         drm_modeset_unlock_all(dev);
 320 }
 321
 322 void xe_display_pm_suspend(struct xe_device *xe)
 323 {
 324         if (!xe->info.enable_display)
 325                 return;
 326
 327         /*
 328          * We do a lot of poking in a lot of registers, make sure they work
 329          * properly.
 330          */
 331         intel_power_domains_disable(xe);
 332         if (has_display(xe))
 333                 drm_kms_helper_poll_disable(&xe->drm);
 334
 335         intel_display_driver_suspend(xe);
 336
 337         intel_dp_mst_suspend(xe);
 338
 339         intel_hpd_cancel_work(xe);
 340
 341         intel_suspend_encoders(xe);
 342
 343         intel_opregion_suspend(xe, PCI_D3cold);
 344
 345         intel_fbdev_set_suspend(&xe->drm, FBINFO_STATE_SUSPENDED, true);
 346
 347         intel_dmc_suspend(xe);
 348 }
 349
 350 void xe_display_pm_suspend_late(struct xe_device *xe)
 351 {
 352         if (!xe->info.enable_display)
 353                 return;
 354
 355         intel_power_domains_suspend(xe, I915_DRM_SUSPEND_MEM);
 356
 357         intel_display_power_suspend_late(xe);
 358 }
 359
 360 void xe_display_pm_resume_early(struct xe_device *xe)
 361 {
 362         if (!xe->info.enable_display)
 363                 return;
 364
 365         intel_display_power_resume_early(xe);
 366
 367         intel_power_domains_resume(xe);
 368 }
 369
 370 void xe_display_pm_resume(struct xe_device *xe)
 371 {
 372         if (!xe->info.enable_display)
 373                 return;
 374
 375         intel_dmc_resume(xe);
 376
 377         if (has_display(xe))
 378                 drm_mode_config_reset(&xe->drm);
 379
 380         intel_display_driver_init_hw(xe);
 381         intel_hpd_init(xe);
 382
 383         /* MST sideband requires HPD interrupts enabled */
 384         intel_dp_mst_resume(xe);
 385         intel_display_driver_resume(xe);
 386
 387         intel_hpd_poll_disable(xe);
 388         if (has_display(xe))
 389                 drm_kms_helper_poll_enable(&xe->drm);
 390
 391         intel_opregion_resume(xe);
 392
 393         intel_fbdev_set_suspend(&xe->drm, FBINFO_STATE_RUNNING, false);
 394
 395         intel_power_domains_enable(xe);
 396 }
 397
 398 void xe_display_probe(struct xe_device *xe)
 399 {
 400         if (!xe->info.enable_display)
 401                 goto no_display;
 402
 403         intel_display_device_probe(xe);
 404
 405         if (has_display(xe))
 406                 return;
 407
 408 no_display:
 409         xe->info.enable_display = false;
 410         unset_display_features(xe);
 411 }