2 * Copyright (C) 2015 Red Hat, Inc.
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
16 * The above copyright notice and this permission notice shall be included in
17 * all copies or substantial portions of the Software.
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
23 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
24 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
25 * OTHER DEALINGS IN THE SOFTWARE.
28 #include "virtgpu_drv.h"
29 #include <drm/drm_crtc_helper.h>
30 #include <drm/drm_atomic_helper.h>
31 #include <drm/drm_gem_framebuffer_helper.h>
42 static const struct drm_crtc_funcs virtio_gpu_crtc_funcs
= {
43 .set_config
= drm_atomic_helper_set_config
,
44 .destroy
= drm_crtc_cleanup
,
46 .page_flip
= drm_atomic_helper_page_flip
,
47 .reset
= drm_atomic_helper_crtc_reset
,
48 .atomic_duplicate_state
= drm_atomic_helper_crtc_duplicate_state
,
49 .atomic_destroy_state
= drm_atomic_helper_crtc_destroy_state
,
53 virtio_gpu_framebuffer_surface_dirty(struct drm_framebuffer
*fb
,
54 struct drm_file
*file_priv
,
55 unsigned int flags
, unsigned int color
,
56 struct drm_clip_rect
*clips
,
57 unsigned int num_clips
)
59 struct virtio_gpu_framebuffer
*virtio_gpu_fb
60 = to_virtio_gpu_framebuffer(fb
);
62 return virtio_gpu_surface_dirty(virtio_gpu_fb
, clips
, num_clips
);
65 static const struct drm_framebuffer_funcs virtio_gpu_fb_funcs
= {
66 .create_handle
= drm_gem_fb_create_handle
,
67 .destroy
= drm_gem_fb_destroy
,
68 .dirty
= virtio_gpu_framebuffer_surface_dirty
,
72 virtio_gpu_framebuffer_init(struct drm_device
*dev
,
73 struct virtio_gpu_framebuffer
*vgfb
,
74 const struct drm_mode_fb_cmd2
*mode_cmd
,
75 struct drm_gem_object
*obj
)
78 struct virtio_gpu_object
*bo
;
80 vgfb
->base
.obj
[0] = obj
;
82 bo
= gem_to_virtio_gpu_obj(obj
);
84 drm_helper_mode_fill_fb_struct(dev
, &vgfb
->base
, mode_cmd
);
86 ret
= drm_framebuffer_init(dev
, &vgfb
->base
, &virtio_gpu_fb_funcs
);
88 vgfb
->base
.obj
[0] = NULL
;
92 spin_lock_init(&vgfb
->dirty_lock
);
93 vgfb
->x1
= vgfb
->y1
= INT_MAX
;
94 vgfb
->x2
= vgfb
->y2
= 0;
98 static void virtio_gpu_crtc_mode_set_nofb(struct drm_crtc
*crtc
)
100 struct drm_device
*dev
= crtc
->dev
;
101 struct virtio_gpu_device
*vgdev
= dev
->dev_private
;
102 struct virtio_gpu_output
*output
= drm_crtc_to_virtio_gpu_output(crtc
);
104 virtio_gpu_cmd_set_scanout(vgdev
, output
->index
, 0,
106 crtc
->mode
.vdisplay
, 0, 0);
109 static void virtio_gpu_crtc_atomic_enable(struct drm_crtc
*crtc
,
110 struct drm_crtc_state
*old_state
)
114 static void virtio_gpu_crtc_atomic_disable(struct drm_crtc
*crtc
,
115 struct drm_crtc_state
*old_state
)
117 struct drm_device
*dev
= crtc
->dev
;
118 struct virtio_gpu_device
*vgdev
= dev
->dev_private
;
119 struct virtio_gpu_output
*output
= drm_crtc_to_virtio_gpu_output(crtc
);
121 virtio_gpu_cmd_set_scanout(vgdev
, output
->index
, 0, 0, 0, 0, 0);
124 static int virtio_gpu_crtc_atomic_check(struct drm_crtc
*crtc
,
125 struct drm_crtc_state
*state
)
130 static void virtio_gpu_crtc_atomic_flush(struct drm_crtc
*crtc
,
131 struct drm_crtc_state
*old_state
)
135 spin_lock_irqsave(&crtc
->dev
->event_lock
, flags
);
136 if (crtc
->state
->event
)
137 drm_crtc_send_vblank_event(crtc
, crtc
->state
->event
);
138 crtc
->state
->event
= NULL
;
139 spin_unlock_irqrestore(&crtc
->dev
->event_lock
, flags
);
142 static const struct drm_crtc_helper_funcs virtio_gpu_crtc_helper_funcs
= {
143 .mode_set_nofb
= virtio_gpu_crtc_mode_set_nofb
,
144 .atomic_check
= virtio_gpu_crtc_atomic_check
,
145 .atomic_flush
= virtio_gpu_crtc_atomic_flush
,
146 .atomic_enable
= virtio_gpu_crtc_atomic_enable
,
147 .atomic_disable
= virtio_gpu_crtc_atomic_disable
,
150 static void virtio_gpu_enc_mode_set(struct drm_encoder
*encoder
,
151 struct drm_display_mode
*mode
,
152 struct drm_display_mode
*adjusted_mode
)
156 static void virtio_gpu_enc_enable(struct drm_encoder
*encoder
)
160 static void virtio_gpu_enc_disable(struct drm_encoder
*encoder
)
164 static int virtio_gpu_conn_get_modes(struct drm_connector
*connector
)
166 struct virtio_gpu_output
*output
=
167 drm_connector_to_virtio_gpu_output(connector
);
168 struct drm_display_mode
*mode
= NULL
;
169 int count
, width
, height
;
171 width
= le32_to_cpu(output
->info
.r
.width
);
172 height
= le32_to_cpu(output
->info
.r
.height
);
173 count
= drm_add_modes_noedid(connector
, XRES_MAX
, YRES_MAX
);
175 if (width
== 0 || height
== 0) {
178 drm_set_preferred_mode(connector
, XRES_DEF
, YRES_DEF
);
180 DRM_DEBUG("add mode: %dx%d\n", width
, height
);
181 mode
= drm_cvt_mode(connector
->dev
, width
, height
, 60,
182 false, false, false);
183 mode
->type
|= DRM_MODE_TYPE_PREFERRED
;
184 drm_mode_probed_add(connector
, mode
);
191 static enum drm_mode_status
virtio_gpu_conn_mode_valid(struct drm_connector
*connector
,
192 struct drm_display_mode
*mode
)
194 struct virtio_gpu_output
*output
=
195 drm_connector_to_virtio_gpu_output(connector
);
198 width
= le32_to_cpu(output
->info
.r
.width
);
199 height
= le32_to_cpu(output
->info
.r
.height
);
201 if (!(mode
->type
& DRM_MODE_TYPE_PREFERRED
))
203 if (mode
->hdisplay
== XRES_DEF
&& mode
->vdisplay
== YRES_DEF
)
205 if (mode
->hdisplay
<= width
&& mode
->hdisplay
>= width
- 16 &&
206 mode
->vdisplay
<= height
&& mode
->vdisplay
>= height
- 16)
209 DRM_DEBUG("del mode: %dx%d\n", mode
->hdisplay
, mode
->vdisplay
);
213 static const struct drm_encoder_helper_funcs virtio_gpu_enc_helper_funcs
= {
214 .mode_set
= virtio_gpu_enc_mode_set
,
215 .enable
= virtio_gpu_enc_enable
,
216 .disable
= virtio_gpu_enc_disable
,
219 static const struct drm_connector_helper_funcs virtio_gpu_conn_helper_funcs
= {
220 .get_modes
= virtio_gpu_conn_get_modes
,
221 .mode_valid
= virtio_gpu_conn_mode_valid
,
224 static enum drm_connector_status
virtio_gpu_conn_detect(
225 struct drm_connector
*connector
,
228 struct virtio_gpu_output
*output
=
229 drm_connector_to_virtio_gpu_output(connector
);
231 if (output
->info
.enabled
)
232 return connector_status_connected
;
234 return connector_status_disconnected
;
237 static void virtio_gpu_conn_destroy(struct drm_connector
*connector
)
239 struct virtio_gpu_output
*virtio_gpu_output
=
240 drm_connector_to_virtio_gpu_output(connector
);
242 drm_connector_unregister(connector
);
243 drm_connector_cleanup(connector
);
244 kfree(virtio_gpu_output
);
247 static const struct drm_connector_funcs virtio_gpu_connector_funcs
= {
248 .detect
= virtio_gpu_conn_detect
,
249 .fill_modes
= drm_helper_probe_single_connector_modes
,
250 .destroy
= virtio_gpu_conn_destroy
,
251 .reset
= drm_atomic_helper_connector_reset
,
252 .atomic_duplicate_state
= drm_atomic_helper_connector_duplicate_state
,
253 .atomic_destroy_state
= drm_atomic_helper_connector_destroy_state
,
256 static const struct drm_encoder_funcs virtio_gpu_enc_funcs
= {
257 .destroy
= drm_encoder_cleanup
,
260 static int vgdev_output_init(struct virtio_gpu_device
*vgdev
, int index
)
262 struct drm_device
*dev
= vgdev
->ddev
;
263 struct virtio_gpu_output
*output
= vgdev
->outputs
+ index
;
264 struct drm_connector
*connector
= &output
->conn
;
265 struct drm_encoder
*encoder
= &output
->enc
;
266 struct drm_crtc
*crtc
= &output
->crtc
;
267 struct drm_plane
*primary
, *cursor
;
269 output
->index
= index
;
271 output
->info
.enabled
= cpu_to_le32(true);
272 output
->info
.r
.width
= cpu_to_le32(XRES_DEF
);
273 output
->info
.r
.height
= cpu_to_le32(YRES_DEF
);
276 primary
= virtio_gpu_plane_init(vgdev
, DRM_PLANE_TYPE_PRIMARY
, index
);
278 return PTR_ERR(primary
);
279 cursor
= virtio_gpu_plane_init(vgdev
, DRM_PLANE_TYPE_CURSOR
, index
);
281 return PTR_ERR(cursor
);
282 drm_crtc_init_with_planes(dev
, crtc
, primary
, cursor
,
283 &virtio_gpu_crtc_funcs
, NULL
);
284 drm_crtc_helper_add(crtc
, &virtio_gpu_crtc_helper_funcs
);
286 drm_connector_init(dev
, connector
, &virtio_gpu_connector_funcs
,
287 DRM_MODE_CONNECTOR_VIRTUAL
);
288 drm_connector_helper_add(connector
, &virtio_gpu_conn_helper_funcs
);
290 drm_encoder_init(dev
, encoder
, &virtio_gpu_enc_funcs
,
291 DRM_MODE_ENCODER_VIRTUAL
, NULL
);
292 drm_encoder_helper_add(encoder
, &virtio_gpu_enc_helper_funcs
);
293 encoder
->possible_crtcs
= 1 << index
;
295 drm_connector_attach_encoder(connector
, encoder
);
296 drm_connector_register(connector
);
300 static struct drm_framebuffer
*
301 virtio_gpu_user_framebuffer_create(struct drm_device
*dev
,
302 struct drm_file
*file_priv
,
303 const struct drm_mode_fb_cmd2
*mode_cmd
)
305 struct drm_gem_object
*obj
= NULL
;
306 struct virtio_gpu_framebuffer
*virtio_gpu_fb
;
309 /* lookup object associated with res handle */
310 obj
= drm_gem_object_lookup(file_priv
, mode_cmd
->handles
[0]);
312 return ERR_PTR(-EINVAL
);
314 virtio_gpu_fb
= kzalloc(sizeof(*virtio_gpu_fb
), GFP_KERNEL
);
315 if (virtio_gpu_fb
== NULL
)
316 return ERR_PTR(-ENOMEM
);
318 ret
= virtio_gpu_framebuffer_init(dev
, virtio_gpu_fb
, mode_cmd
, obj
);
320 kfree(virtio_gpu_fb
);
321 drm_gem_object_put_unlocked(obj
);
325 return &virtio_gpu_fb
->base
;
328 static void vgdev_atomic_commit_tail(struct drm_atomic_state
*state
)
330 struct drm_device
*dev
= state
->dev
;
332 drm_atomic_helper_commit_modeset_disables(dev
, state
);
333 drm_atomic_helper_commit_modeset_enables(dev
, state
);
334 drm_atomic_helper_commit_planes(dev
, state
, 0);
336 drm_atomic_helper_commit_hw_done(state
);
338 drm_atomic_helper_wait_for_vblanks(dev
, state
);
339 drm_atomic_helper_cleanup_planes(dev
, state
);
342 static const struct drm_mode_config_helper_funcs virtio_mode_config_helpers
= {
343 .atomic_commit_tail
= vgdev_atomic_commit_tail
,
346 static const struct drm_mode_config_funcs virtio_gpu_mode_funcs
= {
347 .fb_create
= virtio_gpu_user_framebuffer_create
,
348 .atomic_check
= drm_atomic_helper_check
,
349 .atomic_commit
= drm_atomic_helper_commit
,
352 int virtio_gpu_modeset_init(struct virtio_gpu_device
*vgdev
)
356 drm_mode_config_init(vgdev
->ddev
);
357 vgdev
->ddev
->mode_config
.funcs
= &virtio_gpu_mode_funcs
;
358 vgdev
->ddev
->mode_config
.helper_private
= &virtio_mode_config_helpers
;
360 /* modes will be validated against the framebuffer size */
361 vgdev
->ddev
->mode_config
.min_width
= XRES_MIN
;
362 vgdev
->ddev
->mode_config
.min_height
= YRES_MIN
;
363 vgdev
->ddev
->mode_config
.max_width
= XRES_MAX
;
364 vgdev
->ddev
->mode_config
.max_height
= YRES_MAX
;
366 for (i
= 0 ; i
< vgdev
->num_scanouts
; ++i
)
367 vgdev_output_init(vgdev
, i
);
369 drm_mode_config_reset(vgdev
->ddev
);
373 void virtio_gpu_modeset_fini(struct virtio_gpu_device
*vgdev
)
375 virtio_gpu_fbdev_fini(vgdev
);
376 drm_mode_config_cleanup(vgdev
->ddev
);