xref: /linux/drivers/gpu/drm/i915/display/intel_parent.c (revision c3fb1fb9e65fa6a108b4d19c61bdcb47fd4fe180) 
1 // SPDX-License-Identifier: MIT
2 /* Copyright © 2025 Intel Corporation */
3 
4 /*
5  * Convenience wrapper functions to call the parent interface functions:
6  *
7  * - display->parent->SUBSTRUCT->FUNCTION()
8  * - display->parent->FUNCTION()
9  *
10  * All functions here should be named accordingly:
11  *
12  * - intel_parent_SUBSTRUCT_FUNCTION()
13  * - intel_parent_FUNCTION()
14  *
15  * These functions may use display driver specific types for parameters and
16  * return values, translating them to and from the generic types used in the
17  * function pointer interface.
18  */
19 
20 #include <drm/drm_print.h>
21 #include <drm/intel/display_parent_interface.h>
22 #include <drm/intel/vlv_iosf_sb_regs.h>
23 
24 #include "intel_display_core.h"
25 #include "intel_parent.h"
26 
27 /* dpt */
28 struct intel_dpt *intel_parent_dpt_create(struct intel_display *display,
29 					  struct drm_gem_object *obj, size_t size)
30 {
31 	if (display->parent->dpt)
32 		return display->parent->dpt->create(obj, size);
33 
34 	return NULL;
35 }
36 
37 void intel_parent_dpt_destroy(struct intel_display *display, struct intel_dpt *dpt)
38 {
39 	if (display->parent->dpt)
40 		display->parent->dpt->destroy(dpt);
41 }
42 
43 void intel_parent_dpt_suspend(struct intel_display *display, struct intel_dpt *dpt)
44 {
45 	if (display->parent->dpt)
46 		display->parent->dpt->suspend(dpt);
47 }
48 
49 void intel_parent_dpt_resume(struct intel_display *display, struct intel_dpt *dpt)
50 {
51 	if (display->parent->dpt)
52 		display->parent->dpt->resume(dpt);
53 }
54 
55 /* frontbuffer */
56 struct intel_frontbuffer *intel_parent_frontbuffer_get(struct intel_display *display, struct drm_gem_object *obj)
57 {
58 	return display->parent->frontbuffer->get(obj);
59 }
60 
61 void intel_parent_frontbuffer_ref(struct intel_display *display, struct intel_frontbuffer *front)
62 {
63 	display->parent->frontbuffer->ref(front);
64 }
65 
66 void intel_parent_frontbuffer_put(struct intel_display *display, struct intel_frontbuffer *front)
67 {
68 	display->parent->frontbuffer->put(front);
69 }
70 
71 void intel_parent_frontbuffer_flush_for_display(struct intel_display *display, struct intel_frontbuffer *front)
72 {
73 	display->parent->frontbuffer->flush_for_display(front);
74 }
75 
76 /* hdcp */
77 ssize_t intel_parent_hdcp_gsc_msg_send(struct intel_display *display,
78 				       struct intel_hdcp_gsc_context *gsc_context,
79 				       void *msg_in, size_t msg_in_len,
80 				       void *msg_out, size_t msg_out_len)
81 {
82 	return display->parent->hdcp->gsc_msg_send(gsc_context, msg_in, msg_in_len, msg_out, msg_out_len);
83 }
84 
85 bool intel_parent_hdcp_gsc_check_status(struct intel_display *display)
86 {
87 	return display->parent->hdcp->gsc_check_status(display->drm);
88 }
89 
90 struct intel_hdcp_gsc_context *intel_parent_hdcp_gsc_context_alloc(struct intel_display *display)
91 {
92 	return display->parent->hdcp->gsc_context_alloc(display->drm);
93 }
94 
95 void intel_parent_hdcp_gsc_context_free(struct intel_display *display,
96 					struct intel_hdcp_gsc_context *gsc_context)
97 {
98 	display->parent->hdcp->gsc_context_free(gsc_context);
99 }
100 
101 /* irq */
102 bool intel_parent_irq_enabled(struct intel_display *display)
103 {
104 	return display->parent->irq->enabled(display->drm);
105 }
106 
107 void intel_parent_irq_synchronize(struct intel_display *display)
108 {
109 	display->parent->irq->synchronize(display->drm);
110 }
111 
112 /* overlay */
113 bool intel_parent_overlay_is_active(struct intel_display *display)
114 {
115 	return display->parent->overlay->is_active(display->drm);
116 }
117 
118 int intel_parent_overlay_on(struct intel_display *display,
119 			    u32 frontbuffer_bits)
120 {
121 	return display->parent->overlay->overlay_on(display->drm,
122 						    frontbuffer_bits);
123 }
124 
125 int intel_parent_overlay_continue(struct intel_display *display,
126 				  struct i915_vma *vma,
127 				  bool load_polyphase_filter)
128 {
129 	return display->parent->overlay->overlay_continue(display->drm, vma,
130 							  load_polyphase_filter);
131 }
132 
133 int intel_parent_overlay_off(struct intel_display *display)
134 {
135 	return display->parent->overlay->overlay_off(display->drm);
136 }
137 
138 int intel_parent_overlay_recover_from_interrupt(struct intel_display *display)
139 {
140 	return display->parent->overlay->recover_from_interrupt(display->drm);
141 }
142 
143 int intel_parent_overlay_release_old_vid(struct intel_display *display)
144 {
145 	return display->parent->overlay->release_old_vid(display->drm);
146 }
147 
148 void intel_parent_overlay_reset(struct intel_display *display)
149 {
150 	display->parent->overlay->reset(display->drm);
151 }
152 
153 struct i915_vma *intel_parent_overlay_pin_fb(struct intel_display *display,
154 					     struct drm_gem_object *obj,
155 					     u32 *offset)
156 {
157 	return display->parent->overlay->pin_fb(display->drm, obj, offset);
158 }
159 
160 void intel_parent_overlay_unpin_fb(struct intel_display *display,
161 				   struct i915_vma *vma)
162 {
163 	return display->parent->overlay->unpin_fb(display->drm, vma);
164 }
165 
166 struct drm_gem_object *intel_parent_overlay_obj_lookup(struct intel_display *display,
167 						       struct drm_file *filp,
168 						       u32 handle)
169 {
170 	return display->parent->overlay->obj_lookup(display->drm,
171 						    filp, handle);
172 }
173 
174 void __iomem *intel_parent_overlay_setup(struct intel_display *display,
175 					 bool needs_physical)
176 {
177 	if (drm_WARN_ON_ONCE(display->drm, !display->parent->overlay))
178 		return ERR_PTR(-ENODEV);
179 
180 	return display->parent->overlay->setup(display->drm, needs_physical);
181 }
182 
183 void intel_parent_overlay_cleanup(struct intel_display *display)
184 {
185 	display->parent->overlay->cleanup(display->drm);
186 }
187 
188 /* panic */
189 struct intel_panic *intel_parent_panic_alloc(struct intel_display *display)
190 {
191 	return display->parent->panic->alloc();
192 }
193 
194 int intel_parent_panic_setup(struct intel_display *display, struct intel_panic *panic, struct drm_scanout_buffer *sb)
195 {
196 	return display->parent->panic->setup(panic, sb);
197 }
198 
199 void intel_parent_panic_finish(struct intel_display *display, struct intel_panic *panic)
200 {
201 	display->parent->panic->finish(panic);
202 }
203 
204 /* pc8 */
205 void intel_parent_pc8_block(struct intel_display *display)
206 {
207 	if (drm_WARN_ON_ONCE(display->drm, !display->parent->pc8))
208 		return;
209 
210 	display->parent->pc8->block(display->drm);
211 }
212 
213 void intel_parent_pc8_unblock(struct intel_display *display)
214 {
215 	if (drm_WARN_ON_ONCE(display->drm, !display->parent->pc8))
216 		return;
217 
218 	display->parent->pc8->unblock(display->drm);
219 }
220 
221 /* pcode */
222 int intel_parent_pcode_read(struct intel_display *display, u32 mbox, u32 *val, u32 *val1)
223 {
224 	return display->parent->pcode->read(display->drm, mbox, val, val1);
225 }
226 
227 int intel_parent_pcode_write_timeout(struct intel_display *display, u32 mbox, u32 val, int timeout_ms)
228 {
229 	return display->parent->pcode->write(display->drm, mbox, val, timeout_ms);
230 }
231 
232 int intel_parent_pcode_write(struct intel_display *display, u32 mbox, u32 val)
233 {
234 	return intel_parent_pcode_write_timeout(display, mbox, val, 1);
235 }
236 
237 int intel_parent_pcode_request(struct intel_display *display, u32 mbox, u32 request,
238 			       u32 reply_mask, u32 reply, int timeout_base_ms)
239 {
240 	return display->parent->pcode->request(display->drm, mbox, request, reply_mask, reply, timeout_base_ms);
241 }
242 
243 /* rps */
244 bool intel_parent_rps_available(struct intel_display *display)
245 {
246 	return display->parent->rps;
247 }
248 
249 void intel_parent_rps_boost_if_not_started(struct intel_display *display, struct dma_fence *fence)
250 {
251 	if (display->parent->rps)
252 		display->parent->rps->boost_if_not_started(fence);
253 }
254 
255 void intel_parent_rps_mark_interactive(struct intel_display *display, bool interactive)
256 {
257 	if (display->parent->rps)
258 		display->parent->rps->mark_interactive(display->drm, interactive);
259 }
260 
261 void intel_parent_rps_ilk_irq_handler(struct intel_display *display)
262 {
263 	if (display->parent->rps)
264 		display->parent->rps->ilk_irq_handler(display->drm);
265 }
266 
267 /* stolen */
268 int intel_parent_stolen_insert_node_in_range(struct intel_display *display,
269 					     struct intel_stolen_node *node, u64 size,
270 					     unsigned int align, u64 start, u64 end)
271 {
272 	return display->parent->stolen->insert_node_in_range(node, size, align, start, end);
273 }
274 
275 int intel_parent_stolen_insert_node(struct intel_display *display, struct intel_stolen_node *node, u64 size,
276 				    unsigned int align)
277 {
278 	if (drm_WARN_ON_ONCE(display->drm, !display->parent->stolen->insert_node))
279 		return -ENODEV;
280 
281 	return display->parent->stolen->insert_node(node, size, align);
282 }
283 
284 void intel_parent_stolen_remove_node(struct intel_display *display,
285 				     struct intel_stolen_node *node)
286 {
287 	display->parent->stolen->remove_node(node);
288 }
289 
290 bool intel_parent_stolen_initialized(struct intel_display *display)
291 {
292 	return display->parent->stolen->initialized(display->drm);
293 }
294 
295 bool intel_parent_stolen_node_allocated(struct intel_display *display,
296 					const struct intel_stolen_node *node)
297 {
298 	return display->parent->stolen->node_allocated(node);
299 }
300 
301 u32 intel_parent_stolen_node_offset(struct intel_display *display, struct intel_stolen_node *node)
302 {
303 	return display->parent->stolen->node_offset(node);
304 }
305 
306 u64 intel_parent_stolen_area_address(struct intel_display *display)
307 {
308 	if (drm_WARN_ON_ONCE(display->drm, !display->parent->stolen->area_address))
309 		return 0;
310 
311 	return display->parent->stolen->area_address(display->drm);
312 }
313 
314 u64 intel_parent_stolen_area_size(struct intel_display *display)
315 {
316 	if (drm_WARN_ON_ONCE(display->drm, !display->parent->stolen->area_size))
317 		return 0;
318 
319 	return display->parent->stolen->area_size(display->drm);
320 }
321 
322 u64 intel_parent_stolen_node_address(struct intel_display *display, struct intel_stolen_node *node)
323 {
324 	return display->parent->stolen->node_address(node);
325 }
326 
327 u64 intel_parent_stolen_node_size(struct intel_display *display, const struct intel_stolen_node *node)
328 {
329 	return display->parent->stolen->node_size(node);
330 }
331 
332 struct intel_stolen_node *intel_parent_stolen_node_alloc(struct intel_display *display)
333 {
334 	return display->parent->stolen->node_alloc(display->drm);
335 }
336 
337 void intel_parent_stolen_node_free(struct intel_display *display, const struct intel_stolen_node *node)
338 {
339 	display->parent->stolen->node_free(node);
340 }
341 
342 /* vlv iosf */
343 void intel_parent_vlv_iosf_get(struct intel_display *display, unsigned long unit_mask)
344 {
345 	if (drm_WARN_ON_ONCE(display->drm, !display->parent->vlv_iosf))
346 		return;
347 
348 	display->parent->vlv_iosf->get(display->drm, unit_mask);
349 }
350 
351 void intel_parent_vlv_iosf_put(struct intel_display *display, unsigned long unit_mask)
352 {
353 	if (drm_WARN_ON_ONCE(display->drm, !display->parent->vlv_iosf))
354 		return;
355 
356 	display->parent->vlv_iosf->put(display->drm, unit_mask);
357 }
358 
359 u32 intel_parent_vlv_iosf_read(struct intel_display *display, enum vlv_iosf_sb_unit unit, u32 addr)
360 {
361 	if (drm_WARN_ON_ONCE(display->drm, !display->parent->vlv_iosf))
362 		return 0;
363 
364 	return display->parent->vlv_iosf->read(display->drm, unit, addr);
365 }
366 
367 int intel_parent_vlv_iosf_write(struct intel_display *display, enum vlv_iosf_sb_unit unit, u32 addr, u32 val)
368 {
369 	if (drm_WARN_ON_ONCE(display->drm, !display->parent->vlv_iosf))
370 		return -EINVAL;
371 
372 	return display->parent->vlv_iosf->write(display->drm, unit, addr, val);
373 }
374 
375 /* generic */
376 void intel_parent_fence_priority_display(struct intel_display *display, struct dma_fence *fence)
377 {
378 	if (display->parent->fence_priority_display)
379 		display->parent->fence_priority_display(fence);
380 }
381 
382 bool intel_parent_has_auxccs(struct intel_display *display)
383 {
384 	return display->parent->has_auxccs && display->parent->has_auxccs(display->drm);
385 }
386 
387 bool intel_parent_has_fenced_regions(struct intel_display *display)
388 {
389 	return display->parent->has_fenced_regions && display->parent->has_fenced_regions(display->drm);
390 }
391 
392 bool intel_parent_vgpu_active(struct intel_display *display)
393 {
394 	return display->parent->vgpu_active && display->parent->vgpu_active(display->drm);
395 }
396