xref: /linux/drivers/gpu/drm/xe/display/xe_display.c (revision 815e260a18a3af4dab59025ee99a7156c0e8b5e0) 
1 // SPDX-License-Identifier: MIT
2 /*
3  * Copyright © 2023 Intel Corporation
4  */
5 
6 #include "xe_display.h"
7 #include "regs/xe_irq_regs.h"
8 
9 #include <linux/fb.h>
10 
11 #include <drm/drm_client.h>
12 #include <drm/drm_client_event.h>
13 #include <drm/drm_drv.h>
14 #include <drm/drm_managed.h>
15 #include <drm/drm_probe_helper.h>
16 #include <drm/intel/display_member.h>
17 #include <drm/intel/display_parent_interface.h>
18 #include <uapi/drm/xe_drm.h>
19 
20 #include "soc/intel_dram.h"
21 #include "intel_acpi.h"
22 #include "intel_audio.h"
23 #include "intel_bw.h"
24 #include "intel_display.h"
25 #include "intel_display_device.h"
26 #include "intel_display_driver.h"
27 #include "intel_display_irq.h"
28 #include "intel_display_types.h"
29 #include "intel_dmc.h"
30 #include "intel_dmc_wl.h"
31 #include "intel_dp.h"
32 #include "intel_encoder.h"
33 #include "intel_fbdev.h"
34 #include "intel_hdcp.h"
35 #include "intel_hotplug.h"
36 #include "intel_opregion.h"
37 #include "skl_watermark.h"
38 #include "xe_display_rpm.h"
39 #include "xe_module.h"
40 
41 /* Ensure drm and display members are placed properly. */
42 INTEL_DISPLAY_MEMBER_STATIC_ASSERT(struct xe_device, drm, display);
43 
44 /* Xe device functions */
45 
46 /**
47  * xe_display_driver_probe_defer - Detect if we need to wait for other drivers
48  *				   early on
49  * @pdev: PCI device
50  *
51  * Note: This is called before xe or display device creation.
52  *
53  * Returns: true if probe needs to be deferred, false otherwise
54  */
55 bool xe_display_driver_probe_defer(struct pci_dev *pdev)
56 {
57 	if (!xe_modparam.probe_display)
58 		return 0;
59 
60 	return intel_display_driver_probe_defer(pdev);
61 }
62 
63 /**
64  * xe_display_driver_set_hooks - Add driver flags and hooks for display
65  * @driver: DRM device driver
66  *
67  * Set features and function hooks in @driver that are needed for driving the
68  * display IP. This sets the driver's capability of driving display, regardless
69  * if the device has it enabled
70  *
71  * Note: This is called before xe or display device creation.
72  */
73 void xe_display_driver_set_hooks(struct drm_driver *driver)
74 {
75 	if (!xe_modparam.probe_display)
76 		return;
77 
78 #ifdef CONFIG_DRM_FBDEV_EMULATION
79 	driver->fbdev_probe = intel_fbdev_driver_fbdev_probe;
80 #endif
81 
82 	driver->driver_features |= DRIVER_MODESET | DRIVER_ATOMIC;
83 }
84 
85 static void unset_display_features(struct xe_device *xe)
86 {
87 	xe->drm.driver_features &= ~(DRIVER_MODESET | DRIVER_ATOMIC);
88 }
89 
90 static void xe_display_fini_early(void *arg)
91 {
92 	struct xe_device *xe = arg;
93 	struct intel_display *display = xe->display;
94 
95 	if (!xe->info.probe_display)
96 		return;
97 
98 	intel_hpd_cancel_work(display);
99 	intel_display_driver_remove_nogem(display);
100 	intel_display_driver_remove_noirq(display);
101 	intel_opregion_cleanup(display);
102 	intel_power_domains_cleanup(display);
103 }
104 
105 int xe_display_init_early(struct xe_device *xe)
106 {
107 	struct intel_display *display = xe->display;
108 	int err;
109 
110 	if (!xe->info.probe_display)
111 		return 0;
112 
113 	/* Fake uncore lock */
114 	spin_lock_init(&xe->uncore.lock);
115 
116 	intel_display_driver_early_probe(display);
117 
118 	/* Early display init.. */
119 	intel_opregion_setup(display);
120 
121 	/*
122 	 * Fill the dram structure to get the system dram info. This will be
123 	 * used for memory latency calculation.
124 	 */
125 	err = intel_dram_detect(xe);
126 	if (err)
127 		goto err_opregion;
128 
129 	intel_bw_init_hw(display);
130 
131 	intel_display_device_info_runtime_init(display);
132 
133 	err = intel_display_driver_probe_noirq(display);
134 	if (err)
135 		goto err_opregion;
136 
137 	err = intel_display_driver_probe_nogem(display);
138 	if (err)
139 		goto err_noirq;
140 
141 	return devm_add_action_or_reset(xe->drm.dev, xe_display_fini_early, xe);
142 err_noirq:
143 	intel_display_driver_remove_noirq(display);
144 	intel_power_domains_cleanup(display);
145 err_opregion:
146 	intel_opregion_cleanup(display);
147 	return err;
148 }
149 
150 static void xe_display_fini(void *arg)
151 {
152 	struct xe_device *xe = arg;
153 	struct intel_display *display = xe->display;
154 
155 	intel_hpd_poll_fini(display);
156 	intel_hdcp_component_fini(display);
157 	intel_audio_deinit(display);
158 	intel_display_driver_remove(display);
159 }
160 
161 int xe_display_init(struct xe_device *xe)
162 {
163 	struct intel_display *display = xe->display;
164 	int err;
165 
166 	if (!xe->info.probe_display)
167 		return 0;
168 
169 	err = intel_display_driver_probe(display);
170 	if (err)
171 		return err;
172 
173 	return devm_add_action_or_reset(xe->drm.dev, xe_display_fini, xe);
174 }
175 
176 void xe_display_register(struct xe_device *xe)
177 {
178 	struct intel_display *display = xe->display;
179 
180 	if (!xe->info.probe_display)
181 		return;
182 
183 	intel_display_driver_register(display);
184 	intel_power_domains_enable(display);
185 }
186 
187 void xe_display_unregister(struct xe_device *xe)
188 {
189 	struct intel_display *display = xe->display;
190 
191 	if (!xe->info.probe_display)
192 		return;
193 
194 	intel_power_domains_disable(display);
195 	intel_display_driver_unregister(display);
196 }
197 
198 /* IRQ-related functions */
199 
200 void xe_display_irq_handler(struct xe_device *xe, u32 master_ctl)
201 {
202 	struct intel_display *display = xe->display;
203 
204 	if (!xe->info.probe_display)
205 		return;
206 
207 	if (master_ctl & DISPLAY_IRQ)
208 		gen11_display_irq_handler(display);
209 }
210 
211 void xe_display_irq_enable(struct xe_device *xe, u32 gu_misc_iir)
212 {
213 	struct intel_display *display = xe->display;
214 
215 	if (!xe->info.probe_display)
216 		return;
217 
218 	if (gu_misc_iir & GU_MISC_GSE)
219 		intel_opregion_asle_intr(display);
220 }
221 
222 void xe_display_irq_reset(struct xe_device *xe)
223 {
224 	struct intel_display *display = xe->display;
225 
226 	if (!xe->info.probe_display)
227 		return;
228 
229 	gen11_display_irq_reset(display);
230 }
231 
232 void xe_display_irq_postinstall(struct xe_device *xe)
233 {
234 	struct intel_display *display = xe->display;
235 
236 	if (!xe->info.probe_display)
237 		return;
238 
239 	gen11_de_irq_postinstall(display);
240 }
241 
242 static bool suspend_to_idle(void)
243 {
244 #if IS_ENABLED(CONFIG_ACPI_SLEEP)
245 	if (acpi_target_system_state() < ACPI_STATE_S3)
246 		return true;
247 #endif
248 	return false;
249 }
250 
251 static void xe_display_flush_cleanup_work(struct xe_device *xe)
252 {
253 	struct intel_crtc *crtc;
254 
255 	for_each_intel_crtc(&xe->drm, crtc) {
256 		struct drm_crtc_commit *commit;
257 
258 		spin_lock(&crtc->base.commit_lock);
259 		commit = list_first_entry_or_null(&crtc->base.commit_list,
260 						  struct drm_crtc_commit, commit_entry);
261 		if (commit)
262 			drm_crtc_commit_get(commit);
263 		spin_unlock(&crtc->base.commit_lock);
264 
265 		if (commit) {
266 			wait_for_completion(&commit->cleanup_done);
267 			drm_crtc_commit_put(commit);
268 		}
269 	}
270 }
271 
272 static void xe_display_enable_d3cold(struct xe_device *xe)
273 {
274 	struct intel_display *display = xe->display;
275 
276 	if (!xe->info.probe_display)
277 		return;
278 
279 	/*
280 	 * We do a lot of poking in a lot of registers, make sure they work
281 	 * properly.
282 	 */
283 	intel_power_domains_disable(display);
284 
285 	xe_display_flush_cleanup_work(xe);
286 
287 	intel_opregion_suspend(display, PCI_D3cold);
288 
289 	intel_dmc_suspend(display);
290 
291 	if (intel_display_device_present(display))
292 		intel_hpd_poll_enable(display);
293 }
294 
295 static void xe_display_disable_d3cold(struct xe_device *xe)
296 {
297 	struct intel_display *display = xe->display;
298 
299 	if (!xe->info.probe_display)
300 		return;
301 
302 	intel_dmc_resume(display);
303 
304 	if (intel_display_device_present(display))
305 		drm_mode_config_reset(&xe->drm);
306 
307 	intel_display_driver_init_hw(display);
308 
309 	intel_hpd_init(display);
310 
311 	if (intel_display_device_present(display))
312 		intel_hpd_poll_disable(display);
313 
314 	intel_opregion_resume(display);
315 
316 	intel_power_domains_enable(display);
317 }
318 
319 void xe_display_pm_suspend(struct xe_device *xe)
320 {
321 	struct intel_display *display = xe->display;
322 	bool s2idle = suspend_to_idle();
323 
324 	if (!xe->info.probe_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(display);
332 	drm_client_dev_suspend(&xe->drm);
333 
334 	if (intel_display_device_present(display)) {
335 		drm_kms_helper_poll_disable(&xe->drm);
336 		intel_display_driver_disable_user_access(display);
337 		intel_display_driver_suspend(display);
338 	}
339 
340 	xe_display_flush_cleanup_work(xe);
341 
342 	intel_encoder_block_all_hpds(display);
343 
344 	intel_hpd_cancel_work(display);
345 
346 	if (intel_display_device_present(display)) {
347 		intel_display_driver_suspend_access(display);
348 		intel_encoder_suspend_all(display);
349 	}
350 
351 	intel_opregion_suspend(display, s2idle ? PCI_D1 : PCI_D3cold);
352 
353 	intel_dmc_suspend(display);
354 }
355 
356 void xe_display_pm_shutdown(struct xe_device *xe)
357 {
358 	struct intel_display *display = xe->display;
359 
360 	if (!xe->info.probe_display)
361 		return;
362 
363 	intel_power_domains_disable(display);
364 	drm_client_dev_suspend(&xe->drm);
365 
366 	if (intel_display_device_present(display)) {
367 		drm_kms_helper_poll_disable(&xe->drm);
368 		intel_display_driver_disable_user_access(display);
369 		intel_display_driver_suspend(display);
370 	}
371 
372 	xe_display_flush_cleanup_work(xe);
373 	intel_dp_mst_suspend(display);
374 	intel_encoder_block_all_hpds(display);
375 	intel_hpd_cancel_work(display);
376 
377 	if (intel_display_device_present(display))
378 		intel_display_driver_suspend_access(display);
379 
380 	intel_encoder_suspend_all(display);
381 	intel_encoder_shutdown_all(display);
382 
383 	intel_opregion_suspend(display, PCI_D3cold);
384 
385 	intel_dmc_suspend(display);
386 }
387 
388 void xe_display_pm_runtime_suspend(struct xe_device *xe)
389 {
390 	struct intel_display *display = xe->display;
391 
392 	if (!xe->info.probe_display)
393 		return;
394 
395 	if (xe->d3cold.allowed) {
396 		xe_display_enable_d3cold(xe);
397 		return;
398 	}
399 
400 	intel_hpd_poll_enable(display);
401 }
402 
403 void xe_display_pm_suspend_late(struct xe_device *xe)
404 {
405 	struct intel_display *display = xe->display;
406 	bool s2idle = suspend_to_idle();
407 
408 	if (!xe->info.probe_display)
409 		return;
410 
411 	intel_display_power_suspend_late(display, s2idle);
412 }
413 
414 void xe_display_pm_runtime_suspend_late(struct xe_device *xe)
415 {
416 	struct intel_display *display = xe->display;
417 
418 	if (!xe->info.probe_display)
419 		return;
420 
421 	if (xe->d3cold.allowed)
422 		xe_display_pm_suspend_late(xe);
423 
424 	/*
425 	 * If xe_display_pm_suspend_late() is not called, it is likely
426 	 * that we will be on dynamic DC states with DMC wakelock enabled. We
427 	 * need to flush the release work in that case.
428 	 */
429 	intel_dmc_wl_flush_release_work(display);
430 }
431 
432 void xe_display_pm_shutdown_late(struct xe_device *xe)
433 {
434 	struct intel_display *display = xe->display;
435 
436 	if (!xe->info.probe_display)
437 		return;
438 
439 	/*
440 	 * The only requirement is to reboot with display DC states disabled,
441 	 * for now leaving all display power wells in the INIT power domain
442 	 * enabled.
443 	 */
444 	intel_power_domains_driver_remove(display);
445 }
446 
447 void xe_display_pm_resume_early(struct xe_device *xe)
448 {
449 	struct intel_display *display = xe->display;
450 
451 	if (!xe->info.probe_display)
452 		return;
453 
454 	intel_display_power_resume_early(display);
455 }
456 
457 void xe_display_pm_resume(struct xe_device *xe)
458 {
459 	struct intel_display *display = xe->display;
460 
461 	if (!xe->info.probe_display)
462 		return;
463 
464 	intel_dmc_resume(display);
465 
466 	if (intel_display_device_present(display))
467 		drm_mode_config_reset(&xe->drm);
468 
469 	intel_display_driver_init_hw(display);
470 
471 	if (intel_display_device_present(display))
472 		intel_display_driver_resume_access(display);
473 
474 	intel_hpd_init(display);
475 
476 	intel_encoder_unblock_all_hpds(display);
477 
478 	if (intel_display_device_present(display)) {
479 		intel_display_driver_resume(display);
480 		drm_kms_helper_poll_enable(&xe->drm);
481 		intel_display_driver_enable_user_access(display);
482 	}
483 
484 	if (intel_display_device_present(display))
485 		intel_hpd_poll_disable(display);
486 
487 	intel_opregion_resume(display);
488 
489 	drm_client_dev_resume(&xe->drm);
490 
491 	intel_power_domains_enable(display);
492 }
493 
494 void xe_display_pm_runtime_resume(struct xe_device *xe)
495 {
496 	struct intel_display *display = xe->display;
497 
498 	if (!xe->info.probe_display)
499 		return;
500 
501 	if (xe->d3cold.allowed) {
502 		xe_display_disable_d3cold(xe);
503 		return;
504 	}
505 
506 	intel_hpd_init(display);
507 	intel_hpd_poll_disable(display);
508 	skl_watermark_ipc_update(display);
509 }
510 
511 
512 static void display_device_remove(struct drm_device *dev, void *arg)
513 {
514 	struct intel_display *display = arg;
515 
516 	intel_display_device_remove(display);
517 }
518 
519 static const struct intel_display_parent_interface parent = {
520 	.rpm = &xe_display_rpm_interface,
521 };
522 
523 /**
524  * xe_display_probe - probe display and create display struct
525  * @xe: XE device instance
526  *
527  * Initialize all fields used by the display part.
528  *
529  * TODO: once everything can be inside a single struct, make the struct opaque
530  * to the rest of xe and return it to be xe->display.
531  *
532  * Returns: 0 on success
533  */
534 int xe_display_probe(struct xe_device *xe)
535 {
536 	struct pci_dev *pdev = to_pci_dev(xe->drm.dev);
537 	struct intel_display *display;
538 	int err;
539 
540 	if (!xe->info.probe_display)
541 		goto no_display;
542 
543 	display = intel_display_device_probe(pdev, &parent);
544 	if (IS_ERR(display))
545 		return PTR_ERR(display);
546 
547 	err = drmm_add_action_or_reset(&xe->drm, display_device_remove, display);
548 	if (err)
549 		return err;
550 
551 	xe->display = display;
552 
553 	if (intel_display_device_present(display))
554 		return 0;
555 
556 no_display:
557 	xe->info.probe_display = false;
558 	unset_display_features(xe);
559 	return 0;
560 }
561