1/* SPDX-License-Identifier: GPL-2.0 OR MIT */
2/**************************************************************************
3 *
4 * Copyright (c) 2009-2025 Broadcom. All Rights Reserved. The term
5 * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
6 *
7 **************************************************************************/
8
9#ifndef VMWGFX_KMS_H_
10#define VMWGFX_KMS_H_
11
12#include "vmwgfx_cursor_plane.h"
13#include "vmwgfx_drv.h"
14
15#include <drm/drm_encoder.h>
16#include <drm/drm_framebuffer.h>
17#include <drm/drm_probe_helper.h>
18
19/**
20 * struct vmw_du_update_plane - Closure structure for vmw_du_helper_plane_update
21 * @plane: Plane which is being updated.
22 * @old_state: Old state of plane.
23 * @dev_priv: Device private.
24 * @du: Display unit on which to update the plane.
25 * @vfb: Framebuffer which is blitted to display unit.
26 * @out_fence: Out fence for resource finish.
27 * @mutex: The mutex used to protect resource reservation.
28 * @cpu_blit: True if need cpu blit.
29 * @intr: Whether to perform waits interruptible if possible.
30 *
31 * This structure loosely represent the set of operations needed to perform a
32 * plane update on a display unit. Implementer will define that functionality
33 * according to the function callbacks for this structure. In brief it involves
34 * surface/buffer object validation, populate FIFO commands and command
35 * submission to the device.
36 */
37struct vmw_du_update_plane {
38 /**
39 * @calc_fifo_size: Calculate fifo size.
40 *
41 * Determine fifo size for the commands needed for update. The number of
42 * damage clips on display unit @num_hits will be passed to allocate
43 * sufficient fifo space.
44 *
45 * Return: Fifo size needed
46 */
47 uint32_t (*calc_fifo_size)(struct vmw_du_update_plane *update,
48 uint32_t num_hits);
49
50 /**
51 * @post_prepare: Populate fifo for resource preparation.
52 *
53 * Some surface resource or buffer object need some extra cmd submission
54 * like update GB image for proxy surface and define a GMRFB for screen
55 * object. That should be done here as this callback will be
56 * called after FIFO allocation with the address of command buufer.
57 *
58 * This callback is optional.
59 *
60 * Return: Size of commands populated to command buffer.
61 */
62 uint32_t (*post_prepare)(struct vmw_du_update_plane *update, void *cmd);
63
64 /**
65 * @pre_clip: Populate fifo before clip.
66 *
67 * This is where pre clip related command should be populated like
68 * surface copy/DMA, etc.
69 *
70 * This callback is optional.
71 *
72 * Return: Size of commands populated to command buffer.
73 */
74 uint32_t (*pre_clip)(struct vmw_du_update_plane *update, void *cmd,
75 uint32_t num_hits);
76
77 /**
78 * @clip: Populate fifo for clip.
79 *
80 * This is where to populate clips for surface copy/dma or blit commands
81 * if needed. This will be called times have damage in display unit,
82 * which is one if doing full update. @clip is the damage in destination
83 * coordinates which is crtc/DU and @src_x, @src_y is damage clip src in
84 * framebuffer coordinate.
85 *
86 * This callback is optional.
87 *
88 * Return: Size of commands populated to command buffer.
89 */
90 uint32_t (*clip)(struct vmw_du_update_plane *update, void *cmd,
91 struct drm_rect *clip, uint32_t src_x, uint32_t src_y);
92
93 /**
94 * @post_clip: Populate fifo after clip.
95 *
96 * This is where to populate display unit update commands or blit
97 * commands.
98 *
99 * Return: Size of commands populated to command buffer.
100 */
101 uint32_t (*post_clip)(struct vmw_du_update_plane *update, void *cmd,
102 struct drm_rect *bb);
103
104 struct drm_plane *plane;
105 struct drm_plane_state *old_state;
106 struct vmw_private *dev_priv;
107 struct vmw_display_unit *du;
108 struct vmw_framebuffer *vfb;
109 struct vmw_fence_obj **out_fence;
110 struct mutex *mutex;
111 bool intr;
112};
113
114/**
115 * struct vmw_du_update_plane_surface - closure structure for surface
116 * @base: base closure structure.
117 * @cmd_start: FIFO command start address (used by SOU only).
118 */
119struct vmw_du_update_plane_surface {
120 struct vmw_du_update_plane base;
121 /* This member is to handle special case SOU surface update */
122 void *cmd_start;
123};
124
125/**
126 * struct vmw_du_update_plane_buffer - Closure structure for buffer object
127 * @base: Base closure structure.
128 * @fb_left: x1 for fb damage bounding box.
129 * @fb_top: y1 for fb damage bounding box.
130 */
131struct vmw_du_update_plane_buffer {
132 struct vmw_du_update_plane base;
133 int fb_left, fb_top;
134};
135
136/**
137 * struct vmw_kms_dirty - closure structure for the vmw_kms_helper_dirty
138 * function.
139 *
140 * @fifo_commit: Callback that is called once for each display unit after
141 * all clip rects. This function must commit the fifo space reserved by the
142 * helper. Set up by the caller.
143 * @clip: Callback that is called for each cliprect on each display unit.
144 * Set up by the caller.
145 * @fifo_reserve_size: Fifo size that the helper should try to allocat for
146 * each display unit. Set up by the caller.
147 * @dev_priv: Pointer to the device private. Set up by the helper.
148 * @unit: The current display unit. Set up by the helper before a call to @clip.
149 * @cmd: The allocated fifo space. Set up by the helper before the first @clip
150 * call.
151 * @crtc: The crtc for which to build dirty commands.
152 * @num_hits: Number of clip rect commands for this display unit.
153 * Cleared by the helper before the first @clip call. Updated by the @clip
154 * callback.
155 * @fb_x: Clip rect left side in framebuffer coordinates.
156 * @fb_y: Clip rect right side in framebuffer coordinates.
157 * @unit_x1: Clip rect left side in crtc coordinates.
158 * @unit_y1: Clip rect top side in crtc coordinates.
159 * @unit_x2: Clip rect right side in crtc coordinates.
160 * @unit_y2: Clip rect bottom side in crtc coordinates.
161 *
162 * The clip rect coordinates are updated by the helper for each @clip call.
163 * Note that this may be derived from if more info needs to be passed between
164 * helper caller and helper callbacks.
165 */
166struct vmw_kms_dirty {
167 void (*fifo_commit)(struct vmw_kms_dirty *);
168 void (*clip)(struct vmw_kms_dirty *);
169 size_t fifo_reserve_size;
170 struct vmw_private *dev_priv;
171 struct vmw_display_unit *unit;
172 void *cmd;
173 struct drm_crtc *crtc;
174 u32 num_hits;
175 s32 fb_x;
176 s32 fb_y;
177 s32 unit_x1;
178 s32 unit_y1;
179 s32 unit_x2;
180 s32 unit_y2;
181};
182
183#define vmw_framebuffer_to_vfb(x) \
184 container_of(x, struct vmw_framebuffer, base)
185#define vmw_framebuffer_to_vfbs(x) \
186 container_of(x, struct vmw_framebuffer_surface, base.base)
187#define vmw_framebuffer_to_vfbd(x) \
188 container_of(x, struct vmw_framebuffer_bo, base.base)
189
190/**
191 * Base class for framebuffers
192 *
193 * @pin is called the when ever a crtc uses this framebuffer
194 * @unpin is called
195 */
196struct vmw_framebuffer {
197 struct drm_framebuffer base;
198 bool bo;
199};
200
201struct vmw_framebuffer_surface {
202 struct vmw_framebuffer base;
203 struct vmw_user_object uo;
204};
205
206struct vmw_framebuffer_bo {
207 struct vmw_framebuffer base;
208 struct vmw_bo *buffer;
209};
210
211
212static const uint32_t __maybe_unused vmw_primary_plane_formats[] = {
213 DRM_FORMAT_XRGB8888,
214 DRM_FORMAT_ARGB8888,
215 DRM_FORMAT_RGB565,
216 DRM_FORMAT_XRGB1555,
217};
218
219
220#define vmw_crtc_state_to_vcs(x) container_of(x, struct vmw_crtc_state, base)
221#define vmw_plane_state_to_vps(x) container_of(x, struct vmw_plane_state, base)
222#define vmw_connector_state_to_vcs(x) \
223 container_of(x, struct vmw_connector_state, base)
224
225/**
226 * Derived class for crtc state object
227 *
228 * @base DRM crtc object
229 */
230struct vmw_crtc_state {
231 struct drm_crtc_state base;
232};
233
234
235/**
236 * Derived class for plane state object
237 *
238 * @base DRM plane object
239 * @surf Display surface for STDU
240 * @bo display bo for SOU
241 * @content_fb_type Used by STDU.
242 * @bo_size Size of the bo, used by Screen Object Display Unit
243 * @pinned pin count for STDU display surface
244 */
245struct vmw_plane_state {
246 struct drm_plane_state base;
247 struct vmw_user_object uo;
248
249 int content_fb_type;
250 unsigned long bo_size;
251
252 int pinned;
253
254 /* For CPU Blit */
255 unsigned int cpp;
256
257 struct vmw_cursor_plane_state cursor;
258};
259
260
261/**
262 * Derived class for connector state object
263 *
264 * @base DRM connector object
265 * @is_implicit connector property
266 *
267 */
268struct vmw_connector_state {
269 struct drm_connector_state base;
270
271 /**
272 * @gui_x:
273 *
274 * vmwgfx connector property representing the x position of this display
275 * unit (connector is synonymous to display unit) in overall topology.
276 * This is what the device expect as xRoot while creating screen.
277 */
278 int gui_x;
279
280 /**
281 * @gui_y:
282 *
283 * vmwgfx connector property representing the y position of this display
284 * unit (connector is synonymous to display unit) in overall topology.
285 * This is what the device expect as yRoot while creating screen.
286 */
287 int gui_y;
288};
289
290
291/**
292 * Base class display unit.
293 *
294 * Since the SVGA hw doesn't have a concept of a crtc, encoder or connector
295 * so the display unit is all of them at the same time. This is true for both
296 * legacy multimon and screen objects.
297 */
298struct vmw_display_unit {
299 struct drm_crtc crtc;
300 struct drm_encoder encoder;
301 struct drm_connector connector;
302 struct drm_plane primary;
303 struct vmw_cursor_plane cursor;
304
305 unsigned unit;
306
307 /*
308 * Prefered mode tracking.
309 */
310 unsigned pref_width;
311 unsigned pref_height;
312 bool pref_active;
313
314 /*
315 * Gui positioning
316 */
317 int gui_x;
318 int gui_y;
319 bool is_implicit;
320 int set_gui_x;
321 int set_gui_y;
322
323 struct {
324 struct work_struct crc_generator_work;
325 struct hrtimer timer;
326 ktime_t period_ns;
327
328 /* protects concurrent access to the vblank handler */
329 atomic_t atomic_lock;
330 /* protected by @atomic_lock */
331 bool crc_enabled;
332 struct vmw_surface *surface;
333
334 /* protects concurrent access to the crc worker */
335 spinlock_t crc_state_lock;
336 /* protected by @crc_state_lock */
337 bool crc_pending;
338 u64 frame_start;
339 u64 frame_end;
340 } vkms;
341};
342
343#define vmw_crtc_to_du(x) \
344 container_of(x, struct vmw_display_unit, crtc)
345#define vmw_connector_to_du(x) \
346 container_of(x, struct vmw_display_unit, connector)
347
348
349/*
350 * Shared display unit functions - vmwgfx_kms.c
351 */
352void vmw_du_init(struct vmw_display_unit *du);
353void vmw_du_cleanup(struct vmw_display_unit *du);
354int vmw_du_crtc_gamma_set(struct drm_crtc *crtc,
355 u16 *r, u16 *g, u16 *b,
356 uint32_t size,
357 struct drm_modeset_acquire_ctx *ctx);
358int vmw_du_connector_set_property(struct drm_connector *connector,
359 struct drm_property *property,
360 uint64_t val);
361int vmw_du_connector_atomic_set_property(struct drm_connector *connector,
362 struct drm_connector_state *state,
363 struct drm_property *property,
364 uint64_t val);
365int
366vmw_du_connector_atomic_get_property(struct drm_connector *connector,
367 const struct drm_connector_state *state,
368 struct drm_property *property,
369 uint64_t *val);
370int vmw_du_connector_dpms(struct drm_connector *connector, int mode);
371void vmw_du_connector_save(struct drm_connector *connector);
372void vmw_du_connector_restore(struct drm_connector *connector);
373enum drm_connector_status
374vmw_du_connector_detect(struct drm_connector *connector, bool force);
375int vmw_kms_helper_dirty(struct vmw_private *dev_priv,
376 struct vmw_framebuffer *framebuffer,
377 const struct drm_clip_rect *clips,
378 const struct drm_vmw_rect *vclips,
379 s32 dest_x, s32 dest_y,
380 int num_clips,
381 int increment,
382 struct vmw_kms_dirty *dirty);
383enum drm_mode_status vmw_connector_mode_valid(struct drm_connector *connector,
384 const struct drm_display_mode *mode);
385int vmw_connector_get_modes(struct drm_connector *connector);
386
387void vmw_kms_helper_validation_finish(struct vmw_private *dev_priv,
388 struct drm_file *file_priv,
389 struct vmw_validation_context *ctx,
390 struct vmw_fence_obj **out_fence,
391 struct drm_vmw_fence_rep __user *
392 user_fence_rep);
393int vmw_kms_readback(struct vmw_private *dev_priv,
394 struct drm_file *file_priv,
395 struct vmw_framebuffer *vfb,
396 struct drm_vmw_fence_rep __user *user_fence_rep,
397 struct drm_vmw_rect *vclips,
398 uint32_t num_clips);
399struct vmw_framebuffer *
400vmw_kms_new_framebuffer(struct vmw_private *dev_priv,
401 struct vmw_user_object *uo,
402 const struct drm_format_info *info,
403 const struct drm_mode_fb_cmd2 *mode_cmd);
404void vmw_guess_mode_timing(struct drm_display_mode *mode);
405void vmw_kms_update_implicit_fb(struct vmw_private *dev_priv);
406void vmw_kms_create_implicit_placement_property(struct vmw_private *dev_priv);
407
408/* Universal Plane Helpers */
409void vmw_du_primary_plane_destroy(struct drm_plane *plane);
410
411/* Atomic Helpers */
412int vmw_du_primary_plane_atomic_check(struct drm_plane *plane,
413 struct drm_atomic_state *state);
414void vmw_du_plane_cleanup_fb(struct drm_plane *plane,
415 struct drm_plane_state *old_state);
416void vmw_du_plane_reset(struct drm_plane *plane);
417struct drm_plane_state *vmw_du_plane_duplicate_state(struct drm_plane *plane);
418void vmw_du_plane_destroy_state(struct drm_plane *plane,
419 struct drm_plane_state *state);
420void vmw_du_plane_unpin_surf(struct vmw_plane_state *vps);
421
422int vmw_du_crtc_atomic_check(struct drm_crtc *crtc,
423 struct drm_atomic_state *state);
424void vmw_du_crtc_atomic_begin(struct drm_crtc *crtc,
425 struct drm_atomic_state *state);
426void vmw_du_crtc_reset(struct drm_crtc *crtc);
427struct drm_crtc_state *vmw_du_crtc_duplicate_state(struct drm_crtc *crtc);
428void vmw_du_crtc_destroy_state(struct drm_crtc *crtc,
429 struct drm_crtc_state *state);
430void vmw_du_connector_reset(struct drm_connector *connector);
431struct drm_connector_state *
432vmw_du_connector_duplicate_state(struct drm_connector *connector);
433
434void vmw_du_connector_destroy_state(struct drm_connector *connector,
435 struct drm_connector_state *state);
436
437/*
438 * Legacy display unit functions - vmwgfx_ldu.c
439 */
440int vmw_kms_ldu_init_display(struct vmw_private *dev_priv);
441int vmw_kms_ldu_close_display(struct vmw_private *dev_priv);
442int vmw_kms_update_proxy(struct vmw_resource *res,
443 const struct drm_clip_rect *clips,
444 unsigned num_clips,
445 int increment);
446
447/*
448 * Screen Objects display functions - vmwgfx_scrn.c
449 */
450int vmw_kms_sou_init_display(struct vmw_private *dev_priv);
451int vmw_kms_sou_do_surface_dirty(struct vmw_private *dev_priv,
452 struct vmw_framebuffer *framebuffer,
453 struct drm_clip_rect *clips,
454 struct drm_vmw_rect *vclips,
455 struct vmw_resource *srf,
456 s32 dest_x,
457 s32 dest_y,
458 unsigned num_clips, int inc,
459 struct vmw_fence_obj **out_fence,
460 struct drm_crtc *crtc);
461int vmw_kms_sou_do_bo_dirty(struct vmw_private *dev_priv,
462 struct vmw_framebuffer *framebuffer,
463 struct drm_clip_rect *clips,
464 struct drm_vmw_rect *vclips,
465 unsigned int num_clips, int increment,
466 bool interruptible,
467 struct vmw_fence_obj **out_fence,
468 struct drm_crtc *crtc);
469int vmw_kms_sou_readback(struct vmw_private *dev_priv,
470 struct drm_file *file_priv,
471 struct vmw_framebuffer *vfb,
472 struct drm_vmw_fence_rep __user *user_fence_rep,
473 struct drm_vmw_rect *vclips,
474 uint32_t num_clips,
475 struct drm_crtc *crtc);
476
477/*
478 * Screen Target Display Unit functions - vmwgfx_stdu.c
479 */
480int vmw_kms_stdu_init_display(struct vmw_private *dev_priv);
481int vmw_kms_stdu_surface_dirty(struct vmw_private *dev_priv,
482 struct vmw_framebuffer *framebuffer,
483 struct drm_clip_rect *clips,
484 struct drm_vmw_rect *vclips,
485 struct vmw_resource *srf,
486 s32 dest_x,
487 s32 dest_y,
488 unsigned num_clips, int inc,
489 struct vmw_fence_obj **out_fence,
490 struct drm_crtc *crtc);
491int vmw_kms_stdu_readback(struct vmw_private *dev_priv,
492 struct drm_file *file_priv,
493 struct vmw_framebuffer *vfb,
494 struct drm_vmw_fence_rep __user *user_fence_rep,
495 struct drm_clip_rect *clips,
496 struct drm_vmw_rect *vclips,
497 uint32_t num_clips,
498 int increment,
499 struct drm_crtc *crtc);
500
501int vmw_du_helper_plane_update(struct vmw_du_update_plane *update);
502
503/**
504 * vmw_du_translate_to_crtc - Translate a rect from framebuffer to crtc
505 * @state: Plane state.
506 * @r: Rectangle to translate.
507 */
508static inline void vmw_du_translate_to_crtc(struct drm_plane_state *state,
509 struct drm_rect *r)
510{
511 int translate_crtc_x = -((state->src_x >> 16) - state->crtc_x);
512 int translate_crtc_y = -((state->src_y >> 16) - state->crtc_y);
513
514 drm_rect_translate(r, dx: translate_crtc_x, dy: translate_crtc_y);
515}
516
517#endif
518

source code of linux/drivers/gpu/drm/vmwgfx/vmwgfx_kms.h