1 | // SPDX-License-Identifier: GPL-2.0 OR MIT |
2 | /************************************************************************** |
3 | * |
4 | * Copyright 2009-2023 VMware, Inc., Palo Alto, CA., USA |
5 | * |
6 | * Permission is hereby granted, free of charge, to any person obtaining a |
7 | * copy of this software and associated documentation files (the |
8 | * "Software"), to deal in the Software without restriction, including |
9 | * without limitation the rights to use, copy, modify, merge, publish, |
10 | * distribute, sub license, and/or sell copies of the Software, and to |
11 | * permit persons to whom the Software is furnished to do so, subject to |
12 | * the following conditions: |
13 | * |
14 | * The above copyright notice and this permission notice (including the |
15 | * next paragraph) shall be included in all copies or substantial portions |
16 | * of the Software. |
17 | * |
18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
19 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
20 | * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL |
21 | * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, |
22 | * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR |
23 | * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE |
24 | * USE OR OTHER DEALINGS IN THE SOFTWARE. |
25 | * |
26 | **************************************************************************/ |
27 | |
28 | #include "vmwgfx_bo.h" |
29 | #include "vmwgfx_kms.h" |
30 | |
31 | #include <drm/drm_atomic.h> |
32 | #include <drm/drm_atomic_helper.h> |
33 | #include <drm/drm_fourcc.h> |
34 | |
35 | |
36 | #define vmw_crtc_to_ldu(x) \ |
37 | container_of(x, struct vmw_legacy_display_unit, base.crtc) |
38 | #define vmw_encoder_to_ldu(x) \ |
39 | container_of(x, struct vmw_legacy_display_unit, base.encoder) |
40 | #define vmw_connector_to_ldu(x) \ |
41 | container_of(x, struct vmw_legacy_display_unit, base.connector) |
42 | |
43 | struct vmw_legacy_display { |
44 | struct list_head active; |
45 | |
46 | unsigned num_active; |
47 | unsigned last_num_active; |
48 | |
49 | struct vmw_framebuffer *fb; |
50 | }; |
51 | |
52 | /* |
53 | * Display unit using the legacy register interface. |
54 | */ |
55 | struct vmw_legacy_display_unit { |
56 | struct vmw_display_unit base; |
57 | |
58 | struct list_head active; |
59 | }; |
60 | |
61 | static void vmw_ldu_destroy(struct vmw_legacy_display_unit *ldu) |
62 | { |
63 | list_del_init(entry: &ldu->active); |
64 | vmw_du_cleanup(du: &ldu->base); |
65 | kfree(objp: ldu); |
66 | } |
67 | |
68 | |
69 | /* |
70 | * Legacy Display Unit CRTC functions |
71 | */ |
72 | |
73 | static void vmw_ldu_crtc_destroy(struct drm_crtc *crtc) |
74 | { |
75 | vmw_ldu_destroy(vmw_crtc_to_ldu(crtc)); |
76 | } |
77 | |
78 | static int vmw_ldu_commit_list(struct vmw_private *dev_priv) |
79 | { |
80 | struct vmw_legacy_display *lds = dev_priv->ldu_priv; |
81 | struct vmw_legacy_display_unit *entry; |
82 | struct drm_framebuffer *fb = NULL; |
83 | struct drm_crtc *crtc = NULL; |
84 | int i; |
85 | |
86 | /* If there is no display topology the host just assumes |
87 | * that the guest will set the same layout as the host. |
88 | */ |
89 | if (!(dev_priv->capabilities & SVGA_CAP_DISPLAY_TOPOLOGY)) { |
90 | int w = 0, h = 0; |
91 | list_for_each_entry(entry, &lds->active, active) { |
92 | crtc = &entry->base.crtc; |
93 | w = max(w, crtc->x + crtc->mode.hdisplay); |
94 | h = max(h, crtc->y + crtc->mode.vdisplay); |
95 | } |
96 | |
97 | if (crtc == NULL) |
98 | return 0; |
99 | fb = crtc->primary->state->fb; |
100 | |
101 | return vmw_kms_write_svga(vmw_priv: dev_priv, width: w, height: h, pitch: fb->pitches[0], |
102 | bpp: fb->format->cpp[0] * 8, |
103 | depth: fb->format->depth); |
104 | } |
105 | |
106 | if (!list_empty(head: &lds->active)) { |
107 | entry = list_entry(lds->active.next, typeof(*entry), active); |
108 | fb = entry->base.crtc.primary->state->fb; |
109 | |
110 | vmw_kms_write_svga(vmw_priv: dev_priv, width: fb->width, height: fb->height, pitch: fb->pitches[0], |
111 | bpp: fb->format->cpp[0] * 8, depth: fb->format->depth); |
112 | } |
113 | |
114 | /* Make sure we always show something. */ |
115 | vmw_write(dev_priv, offset: SVGA_REG_NUM_GUEST_DISPLAYS, |
116 | value: lds->num_active ? lds->num_active : 1); |
117 | |
118 | i = 0; |
119 | list_for_each_entry(entry, &lds->active, active) { |
120 | crtc = &entry->base.crtc; |
121 | |
122 | vmw_write(dev_priv, offset: SVGA_REG_DISPLAY_ID, value: i); |
123 | vmw_write(dev_priv, offset: SVGA_REG_DISPLAY_IS_PRIMARY, value: !i); |
124 | vmw_write(dev_priv, offset: SVGA_REG_DISPLAY_POSITION_X, value: crtc->x); |
125 | vmw_write(dev_priv, offset: SVGA_REG_DISPLAY_POSITION_Y, value: crtc->y); |
126 | vmw_write(dev_priv, offset: SVGA_REG_DISPLAY_WIDTH, value: crtc->mode.hdisplay); |
127 | vmw_write(dev_priv, offset: SVGA_REG_DISPLAY_HEIGHT, value: crtc->mode.vdisplay); |
128 | |
129 | i++; |
130 | } |
131 | |
132 | BUG_ON(i != lds->num_active); |
133 | |
134 | lds->last_num_active = lds->num_active; |
135 | |
136 | return 0; |
137 | } |
138 | |
139 | /* |
140 | * Pin the buffer in a location suitable for access by the |
141 | * display system. |
142 | */ |
143 | static int vmw_ldu_fb_pin(struct vmw_framebuffer *vfb) |
144 | { |
145 | struct vmw_private *dev_priv = vmw_priv(dev: vfb->base.dev); |
146 | struct vmw_bo *buf; |
147 | int ret; |
148 | |
149 | buf = vfb->bo ? vmw_framebuffer_to_vfbd(&vfb->base)->buffer : |
150 | vmw_framebuffer_to_vfbs(&vfb->base)->surface->res.guest_memory_bo; |
151 | |
152 | if (!buf) |
153 | return 0; |
154 | WARN_ON(dev_priv->active_display_unit != vmw_du_legacy); |
155 | |
156 | if (dev_priv->active_display_unit == vmw_du_legacy) { |
157 | vmw_overlay_pause_all(dev_priv); |
158 | ret = vmw_bo_pin_in_start_of_vram(vmw_priv: dev_priv, bo: buf, interruptible: false); |
159 | vmw_overlay_resume_all(dev_priv); |
160 | } else |
161 | ret = -EINVAL; |
162 | |
163 | return ret; |
164 | } |
165 | |
166 | static int vmw_ldu_fb_unpin(struct vmw_framebuffer *vfb) |
167 | { |
168 | struct vmw_private *dev_priv = vmw_priv(dev: vfb->base.dev); |
169 | struct vmw_bo *buf; |
170 | |
171 | buf = vfb->bo ? vmw_framebuffer_to_vfbd(&vfb->base)->buffer : |
172 | vmw_framebuffer_to_vfbs(&vfb->base)->surface->res.guest_memory_bo; |
173 | |
174 | if (WARN_ON(!buf)) |
175 | return 0; |
176 | |
177 | return vmw_bo_unpin(vmw_priv: dev_priv, bo: buf, interruptible: false); |
178 | } |
179 | |
180 | static int vmw_ldu_del_active(struct vmw_private *vmw_priv, |
181 | struct vmw_legacy_display_unit *ldu) |
182 | { |
183 | struct vmw_legacy_display *ld = vmw_priv->ldu_priv; |
184 | if (list_empty(head: &ldu->active)) |
185 | return 0; |
186 | |
187 | /* Must init otherwise list_empty(&ldu->active) will not work. */ |
188 | list_del_init(entry: &ldu->active); |
189 | if (--(ld->num_active) == 0) { |
190 | BUG_ON(!ld->fb); |
191 | WARN_ON(vmw_ldu_fb_unpin(ld->fb)); |
192 | ld->fb = NULL; |
193 | } |
194 | |
195 | return 0; |
196 | } |
197 | |
198 | static int vmw_ldu_add_active(struct vmw_private *vmw_priv, |
199 | struct vmw_legacy_display_unit *ldu, |
200 | struct vmw_framebuffer *vfb) |
201 | { |
202 | struct vmw_legacy_display *ld = vmw_priv->ldu_priv; |
203 | struct vmw_legacy_display_unit *entry; |
204 | struct list_head *at; |
205 | |
206 | BUG_ON(!ld->num_active && ld->fb); |
207 | if (vfb != ld->fb) { |
208 | if (ld->fb) |
209 | WARN_ON(vmw_ldu_fb_unpin(ld->fb)); |
210 | vmw_svga_enable(dev_priv: vmw_priv); |
211 | WARN_ON(vmw_ldu_fb_pin(vfb)); |
212 | ld->fb = vfb; |
213 | } |
214 | |
215 | if (!list_empty(head: &ldu->active)) |
216 | return 0; |
217 | |
218 | at = &ld->active; |
219 | list_for_each_entry(entry, &ld->active, active) { |
220 | if (entry->base.unit > ldu->base.unit) |
221 | break; |
222 | |
223 | at = &entry->active; |
224 | } |
225 | |
226 | list_add(new: &ldu->active, head: at); |
227 | |
228 | ld->num_active++; |
229 | |
230 | return 0; |
231 | } |
232 | |
233 | /** |
234 | * vmw_ldu_crtc_mode_set_nofb - Enable svga |
235 | * |
236 | * @crtc: CRTC associated with the new screen |
237 | * |
238 | * For LDU, just enable the svga |
239 | */ |
240 | static void vmw_ldu_crtc_mode_set_nofb(struct drm_crtc *crtc) |
241 | { |
242 | } |
243 | |
244 | /** |
245 | * vmw_ldu_crtc_atomic_enable - Noop |
246 | * |
247 | * @crtc: CRTC associated with the new screen |
248 | * @state: Unused |
249 | * |
250 | * This is called after a mode set has been completed. Here's |
251 | * usually a good place to call vmw_ldu_add_active/vmw_ldu_del_active |
252 | * but since for LDU the display plane is closely tied to the |
253 | * CRTC, it makes more sense to do those at plane update time. |
254 | */ |
255 | static void vmw_ldu_crtc_atomic_enable(struct drm_crtc *crtc, |
256 | struct drm_atomic_state *state) |
257 | { |
258 | } |
259 | |
260 | /** |
261 | * vmw_ldu_crtc_atomic_disable - Turns off CRTC |
262 | * |
263 | * @crtc: CRTC to be turned off |
264 | * @state: Unused |
265 | */ |
266 | static void vmw_ldu_crtc_atomic_disable(struct drm_crtc *crtc, |
267 | struct drm_atomic_state *state) |
268 | { |
269 | } |
270 | |
271 | static const struct drm_crtc_funcs vmw_legacy_crtc_funcs = { |
272 | .gamma_set = vmw_du_crtc_gamma_set, |
273 | .destroy = vmw_ldu_crtc_destroy, |
274 | .reset = vmw_du_crtc_reset, |
275 | .atomic_duplicate_state = vmw_du_crtc_duplicate_state, |
276 | .atomic_destroy_state = vmw_du_crtc_destroy_state, |
277 | .set_config = drm_atomic_helper_set_config, |
278 | .page_flip = drm_atomic_helper_page_flip, |
279 | }; |
280 | |
281 | |
282 | /* |
283 | * Legacy Display Unit encoder functions |
284 | */ |
285 | |
286 | static void vmw_ldu_encoder_destroy(struct drm_encoder *encoder) |
287 | { |
288 | vmw_ldu_destroy(vmw_encoder_to_ldu(encoder)); |
289 | } |
290 | |
291 | static const struct drm_encoder_funcs vmw_legacy_encoder_funcs = { |
292 | .destroy = vmw_ldu_encoder_destroy, |
293 | }; |
294 | |
295 | /* |
296 | * Legacy Display Unit connector functions |
297 | */ |
298 | |
299 | static void vmw_ldu_connector_destroy(struct drm_connector *connector) |
300 | { |
301 | vmw_ldu_destroy(vmw_connector_to_ldu(connector)); |
302 | } |
303 | |
304 | static const struct drm_connector_funcs vmw_legacy_connector_funcs = { |
305 | .dpms = vmw_du_connector_dpms, |
306 | .detect = vmw_du_connector_detect, |
307 | .fill_modes = drm_helper_probe_single_connector_modes, |
308 | .destroy = vmw_ldu_connector_destroy, |
309 | .reset = vmw_du_connector_reset, |
310 | .atomic_duplicate_state = vmw_du_connector_duplicate_state, |
311 | .atomic_destroy_state = vmw_du_connector_destroy_state, |
312 | }; |
313 | |
314 | static const struct |
315 | drm_connector_helper_funcs vmw_ldu_connector_helper_funcs = { |
316 | .get_modes = vmw_connector_get_modes, |
317 | .mode_valid = vmw_connector_mode_valid |
318 | }; |
319 | |
320 | static int vmw_kms_ldu_do_bo_dirty(struct vmw_private *dev_priv, |
321 | struct vmw_framebuffer *framebuffer, |
322 | unsigned int flags, unsigned int color, |
323 | struct drm_mode_rect *clips, |
324 | unsigned int num_clips); |
325 | |
326 | /* |
327 | * Legacy Display Plane Functions |
328 | */ |
329 | |
330 | static void |
331 | vmw_ldu_primary_plane_atomic_update(struct drm_plane *plane, |
332 | struct drm_atomic_state *state) |
333 | { |
334 | struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state, |
335 | plane); |
336 | struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state, |
337 | plane); |
338 | struct vmw_private *dev_priv; |
339 | struct vmw_legacy_display_unit *ldu; |
340 | struct vmw_framebuffer *vfb; |
341 | struct drm_framebuffer *fb; |
342 | struct drm_crtc *crtc = new_state->crtc ?: old_state->crtc; |
343 | |
344 | ldu = vmw_crtc_to_ldu(crtc); |
345 | dev_priv = vmw_priv(dev: plane->dev); |
346 | fb = new_state->fb; |
347 | |
348 | vfb = (fb) ? vmw_framebuffer_to_vfb(fb) : NULL; |
349 | |
350 | if (vfb) |
351 | vmw_ldu_add_active(vmw_priv: dev_priv, ldu, vfb); |
352 | else |
353 | vmw_ldu_del_active(vmw_priv: dev_priv, ldu); |
354 | |
355 | vmw_ldu_commit_list(dev_priv); |
356 | |
357 | if (vfb && vmw_cmd_supported(vmw: dev_priv)) { |
358 | struct drm_mode_rect fb_rect = { |
359 | .x1 = 0, |
360 | .y1 = 0, |
361 | .x2 = vfb->base.width, |
362 | .y2 = vfb->base.height |
363 | }; |
364 | struct drm_mode_rect *damage_rects = drm_plane_get_damage_clips(state: new_state); |
365 | u32 rect_count = drm_plane_get_damage_clips_count(state: new_state); |
366 | int ret; |
367 | |
368 | if (!damage_rects) { |
369 | damage_rects = &fb_rect; |
370 | rect_count = 1; |
371 | } |
372 | |
373 | ret = vmw_kms_ldu_do_bo_dirty(dev_priv, framebuffer: vfb, flags: 0, color: 0, clips: damage_rects, num_clips: rect_count); |
374 | |
375 | drm_WARN_ONCE(plane->dev, ret, |
376 | "vmw_kms_ldu_do_bo_dirty failed with: ret=%d\n" , ret); |
377 | |
378 | vmw_cmd_flush(dev_priv, interruptible: false); |
379 | } |
380 | } |
381 | |
382 | static const struct drm_plane_funcs vmw_ldu_plane_funcs = { |
383 | .update_plane = drm_atomic_helper_update_plane, |
384 | .disable_plane = drm_atomic_helper_disable_plane, |
385 | .destroy = vmw_du_primary_plane_destroy, |
386 | .reset = vmw_du_plane_reset, |
387 | .atomic_duplicate_state = vmw_du_plane_duplicate_state, |
388 | .atomic_destroy_state = vmw_du_plane_destroy_state, |
389 | }; |
390 | |
391 | static const struct drm_plane_funcs vmw_ldu_cursor_funcs = { |
392 | .update_plane = drm_atomic_helper_update_plane, |
393 | .disable_plane = drm_atomic_helper_disable_plane, |
394 | .destroy = vmw_du_cursor_plane_destroy, |
395 | .reset = vmw_du_plane_reset, |
396 | .atomic_duplicate_state = vmw_du_plane_duplicate_state, |
397 | .atomic_destroy_state = vmw_du_plane_destroy_state, |
398 | }; |
399 | |
400 | /* |
401 | * Atomic Helpers |
402 | */ |
403 | static const struct |
404 | drm_plane_helper_funcs vmw_ldu_cursor_plane_helper_funcs = { |
405 | .atomic_check = vmw_du_cursor_plane_atomic_check, |
406 | .atomic_update = vmw_du_cursor_plane_atomic_update, |
407 | .prepare_fb = vmw_du_cursor_plane_prepare_fb, |
408 | .cleanup_fb = vmw_du_cursor_plane_cleanup_fb, |
409 | }; |
410 | |
411 | static const struct |
412 | drm_plane_helper_funcs vmw_ldu_primary_plane_helper_funcs = { |
413 | .atomic_check = vmw_du_primary_plane_atomic_check, |
414 | .atomic_update = vmw_ldu_primary_plane_atomic_update, |
415 | }; |
416 | |
417 | static const struct drm_crtc_helper_funcs vmw_ldu_crtc_helper_funcs = { |
418 | .mode_set_nofb = vmw_ldu_crtc_mode_set_nofb, |
419 | .atomic_check = vmw_du_crtc_atomic_check, |
420 | .atomic_begin = vmw_du_crtc_atomic_begin, |
421 | .atomic_flush = vmw_du_crtc_atomic_flush, |
422 | .atomic_enable = vmw_ldu_crtc_atomic_enable, |
423 | .atomic_disable = vmw_ldu_crtc_atomic_disable, |
424 | }; |
425 | |
426 | |
427 | static int vmw_ldu_init(struct vmw_private *dev_priv, unsigned unit) |
428 | { |
429 | struct vmw_legacy_display_unit *ldu; |
430 | struct drm_device *dev = &dev_priv->drm; |
431 | struct drm_connector *connector; |
432 | struct drm_encoder *encoder; |
433 | struct drm_plane *primary; |
434 | struct vmw_cursor_plane *cursor; |
435 | struct drm_crtc *crtc; |
436 | int ret; |
437 | |
438 | ldu = kzalloc(size: sizeof(*ldu), GFP_KERNEL); |
439 | if (!ldu) |
440 | return -ENOMEM; |
441 | |
442 | ldu->base.unit = unit; |
443 | crtc = &ldu->base.crtc; |
444 | encoder = &ldu->base.encoder; |
445 | connector = &ldu->base.connector; |
446 | primary = &ldu->base.primary; |
447 | cursor = &ldu->base.cursor; |
448 | |
449 | INIT_LIST_HEAD(list: &ldu->active); |
450 | |
451 | ldu->base.pref_active = (unit == 0); |
452 | ldu->base.pref_width = dev_priv->initial_width; |
453 | ldu->base.pref_height = dev_priv->initial_height; |
454 | |
455 | /* |
456 | * Remove this after enabling atomic because property values can |
457 | * only exist in a state object |
458 | */ |
459 | ldu->base.is_implicit = true; |
460 | |
461 | /* Initialize primary plane */ |
462 | ret = drm_universal_plane_init(dev, plane: primary, |
463 | possible_crtcs: 0, funcs: &vmw_ldu_plane_funcs, |
464 | formats: vmw_primary_plane_formats, |
465 | ARRAY_SIZE(vmw_primary_plane_formats), |
466 | NULL, type: DRM_PLANE_TYPE_PRIMARY, NULL); |
467 | if (ret) { |
468 | DRM_ERROR("Failed to initialize primary plane" ); |
469 | goto err_free; |
470 | } |
471 | |
472 | drm_plane_helper_add(plane: primary, funcs: &vmw_ldu_primary_plane_helper_funcs); |
473 | |
474 | /* |
475 | * We're going to be using traces and software cursors |
476 | */ |
477 | if (vmw_cmd_supported(vmw: dev_priv)) { |
478 | /* Initialize cursor plane */ |
479 | ret = drm_universal_plane_init(dev, plane: &cursor->base, |
480 | possible_crtcs: 0, funcs: &vmw_ldu_cursor_funcs, |
481 | formats: vmw_cursor_plane_formats, |
482 | ARRAY_SIZE(vmw_cursor_plane_formats), |
483 | NULL, type: DRM_PLANE_TYPE_CURSOR, NULL); |
484 | if (ret) { |
485 | DRM_ERROR("Failed to initialize cursor plane" ); |
486 | drm_plane_cleanup(plane: &ldu->base.primary); |
487 | goto err_free; |
488 | } |
489 | |
490 | drm_plane_helper_add(plane: &cursor->base, funcs: &vmw_ldu_cursor_plane_helper_funcs); |
491 | } |
492 | |
493 | ret = drm_connector_init(dev, connector, funcs: &vmw_legacy_connector_funcs, |
494 | DRM_MODE_CONNECTOR_VIRTUAL); |
495 | if (ret) { |
496 | DRM_ERROR("Failed to initialize connector\n" ); |
497 | goto err_free; |
498 | } |
499 | |
500 | drm_connector_helper_add(connector, funcs: &vmw_ldu_connector_helper_funcs); |
501 | connector->status = vmw_du_connector_detect(connector, force: true); |
502 | |
503 | ret = drm_encoder_init(dev, encoder, funcs: &vmw_legacy_encoder_funcs, |
504 | DRM_MODE_ENCODER_VIRTUAL, NULL); |
505 | if (ret) { |
506 | DRM_ERROR("Failed to initialize encoder\n" ); |
507 | goto err_free_connector; |
508 | } |
509 | |
510 | (void) drm_connector_attach_encoder(connector, encoder); |
511 | encoder->possible_crtcs = (1 << unit); |
512 | encoder->possible_clones = 0; |
513 | |
514 | ret = drm_connector_register(connector); |
515 | if (ret) { |
516 | DRM_ERROR("Failed to register connector\n" ); |
517 | goto err_free_encoder; |
518 | } |
519 | |
520 | ret = drm_crtc_init_with_planes(dev, crtc, primary, |
521 | cursor: vmw_cmd_supported(vmw: dev_priv) ? &cursor->base : NULL, |
522 | funcs: &vmw_legacy_crtc_funcs, NULL); |
523 | if (ret) { |
524 | DRM_ERROR("Failed to initialize CRTC\n" ); |
525 | goto err_free_unregister; |
526 | } |
527 | |
528 | drm_crtc_helper_add(crtc, funcs: &vmw_ldu_crtc_helper_funcs); |
529 | |
530 | drm_mode_crtc_set_gamma_size(crtc, gamma_size: 256); |
531 | |
532 | drm_object_attach_property(obj: &connector->base, |
533 | property: dev_priv->hotplug_mode_update_property, init_val: 1); |
534 | drm_object_attach_property(obj: &connector->base, |
535 | property: dev->mode_config.suggested_x_property, init_val: 0); |
536 | drm_object_attach_property(obj: &connector->base, |
537 | property: dev->mode_config.suggested_y_property, init_val: 0); |
538 | if (dev_priv->implicit_placement_property) |
539 | drm_object_attach_property |
540 | (obj: &connector->base, |
541 | property: dev_priv->implicit_placement_property, |
542 | init_val: 1); |
543 | |
544 | return 0; |
545 | |
546 | err_free_unregister: |
547 | drm_connector_unregister(connector); |
548 | err_free_encoder: |
549 | drm_encoder_cleanup(encoder); |
550 | err_free_connector: |
551 | drm_connector_cleanup(connector); |
552 | err_free: |
553 | kfree(objp: ldu); |
554 | return ret; |
555 | } |
556 | |
557 | int vmw_kms_ldu_init_display(struct vmw_private *dev_priv) |
558 | { |
559 | struct drm_device *dev = &dev_priv->drm; |
560 | int i, ret; |
561 | int num_display_units = (dev_priv->capabilities & SVGA_CAP_MULTIMON) ? |
562 | VMWGFX_NUM_DISPLAY_UNITS : 1; |
563 | |
564 | if (unlikely(dev_priv->ldu_priv)) { |
565 | return -EINVAL; |
566 | } |
567 | |
568 | dev_priv->ldu_priv = kmalloc(size: sizeof(*dev_priv->ldu_priv), GFP_KERNEL); |
569 | if (!dev_priv->ldu_priv) |
570 | return -ENOMEM; |
571 | |
572 | INIT_LIST_HEAD(list: &dev_priv->ldu_priv->active); |
573 | dev_priv->ldu_priv->num_active = 0; |
574 | dev_priv->ldu_priv->last_num_active = 0; |
575 | dev_priv->ldu_priv->fb = NULL; |
576 | |
577 | vmw_kms_create_implicit_placement_property(dev_priv); |
578 | |
579 | for (i = 0; i < num_display_units; ++i) { |
580 | ret = vmw_ldu_init(dev_priv, unit: i); |
581 | if (ret != 0) |
582 | goto err_free; |
583 | } |
584 | |
585 | dev_priv->active_display_unit = vmw_du_legacy; |
586 | |
587 | drm_mode_config_reset(dev); |
588 | |
589 | return 0; |
590 | |
591 | err_free: |
592 | kfree(objp: dev_priv->ldu_priv); |
593 | dev_priv->ldu_priv = NULL; |
594 | return ret; |
595 | } |
596 | |
597 | int vmw_kms_ldu_close_display(struct vmw_private *dev_priv) |
598 | { |
599 | if (!dev_priv->ldu_priv) |
600 | return -ENOSYS; |
601 | |
602 | BUG_ON(!list_empty(&dev_priv->ldu_priv->active)); |
603 | |
604 | kfree(objp: dev_priv->ldu_priv); |
605 | |
606 | return 0; |
607 | } |
608 | |
609 | |
610 | static int vmw_kms_ldu_do_bo_dirty(struct vmw_private *dev_priv, |
611 | struct vmw_framebuffer *framebuffer, |
612 | unsigned int flags, unsigned int color, |
613 | struct drm_mode_rect *clips, |
614 | unsigned int num_clips) |
615 | { |
616 | size_t fifo_size; |
617 | int i; |
618 | |
619 | struct { |
620 | uint32_t ; |
621 | SVGAFifoCmdUpdate body; |
622 | } *cmd; |
623 | |
624 | fifo_size = sizeof(*cmd) * num_clips; |
625 | cmd = VMW_CMD_RESERVE(dev_priv, fifo_size); |
626 | if (unlikely(cmd == NULL)) |
627 | return -ENOMEM; |
628 | |
629 | memset(cmd, 0, fifo_size); |
630 | for (i = 0; i < num_clips; i++, clips++) { |
631 | cmd[i].header = SVGA_CMD_UPDATE; |
632 | cmd[i].body.x = clips->x1; |
633 | cmd[i].body.y = clips->y1; |
634 | cmd[i].body.width = clips->x2 - clips->x1; |
635 | cmd[i].body.height = clips->y2 - clips->y1; |
636 | } |
637 | |
638 | vmw_cmd_commit(dev_priv, bytes: fifo_size); |
639 | return 0; |
640 | } |
641 | |