2 * Copyright 2013 Red Hat Inc.
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
22 * Authors: Dave Airlie
27 #include <linux/crc32.h>
30 #include "qxl_object.h"
31 #include "drm_crtc_helper.h"
32 #include <drm/drm_plane_helper.h>
34 static bool qxl_head_enabled(struct qxl_head
*head
)
36 return head
->width
&& head
->height
;
39 void qxl_alloc_client_monitors_config(struct qxl_device
*qdev
, unsigned count
)
41 if (qdev
->client_monitors_config
&&
42 count
> qdev
->client_monitors_config
->count
) {
43 kfree(qdev
->client_monitors_config
);
44 qdev
->client_monitors_config
= NULL
;
46 if (!qdev
->client_monitors_config
) {
47 qdev
->client_monitors_config
= kzalloc(
48 sizeof(struct qxl_monitors_config
) +
49 sizeof(struct qxl_head
) * count
, GFP_KERNEL
);
50 if (!qdev
->client_monitors_config
) {
52 "%s: allocation failure for %u heads\n",
57 qdev
->client_monitors_config
->count
= count
;
60 static int qxl_display_copy_rom_client_monitors_config(struct qxl_device
*qdev
)
66 num_monitors
= qdev
->rom
->client_monitors_config
.count
;
67 crc
= crc32(0, (const uint8_t *)&qdev
->rom
->client_monitors_config
,
68 sizeof(qdev
->rom
->client_monitors_config
));
69 if (crc
!= qdev
->rom
->client_monitors_config_crc
) {
70 qxl_io_log(qdev
, "crc mismatch: have %X (%zd) != %X\n", crc
,
71 sizeof(qdev
->rom
->client_monitors_config
),
72 qdev
->rom
->client_monitors_config_crc
);
75 if (num_monitors
> qdev
->monitors_config
->max_allowed
) {
76 DRM_DEBUG_KMS("client monitors list will be truncated: %d < %d\n",
77 qdev
->monitors_config
->max_allowed
, num_monitors
);
78 num_monitors
= qdev
->monitors_config
->max_allowed
;
80 num_monitors
= qdev
->rom
->client_monitors_config
.count
;
82 qxl_alloc_client_monitors_config(qdev
, num_monitors
);
83 /* we copy max from the client but it isn't used */
84 qdev
->client_monitors_config
->max_allowed
=
85 qdev
->monitors_config
->max_allowed
;
86 for (i
= 0 ; i
< qdev
->client_monitors_config
->count
; ++i
) {
87 struct qxl_urect
*c_rect
=
88 &qdev
->rom
->client_monitors_config
.heads
[i
];
89 struct qxl_head
*client_head
=
90 &qdev
->client_monitors_config
->heads
[i
];
91 client_head
->x
= c_rect
->left
;
92 client_head
->y
= c_rect
->top
;
93 client_head
->width
= c_rect
->right
- c_rect
->left
;
94 client_head
->height
= c_rect
->bottom
- c_rect
->top
;
95 client_head
->surface_id
= 0;
97 client_head
->flags
= 0;
98 DRM_DEBUG_KMS("read %dx%d+%d+%d\n", client_head
->width
, client_head
->height
,
99 client_head
->x
, client_head
->y
);
104 static void qxl_update_offset_props(struct qxl_device
*qdev
)
106 struct drm_device
*dev
= qdev
->ddev
;
107 struct drm_connector
*connector
;
108 struct qxl_output
*output
;
109 struct qxl_head
*head
;
111 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
, head
) {
112 output
= drm_connector_to_qxl_output(connector
);
114 head
= &qdev
->client_monitors_config
->heads
[output
->index
];
116 drm_object_property_set_value(&connector
->base
,
117 dev
->mode_config
.suggested_x_property
, head
->x
);
118 drm_object_property_set_value(&connector
->base
,
119 dev
->mode_config
.suggested_y_property
, head
->y
);
123 void qxl_display_read_client_monitors_config(struct qxl_device
*qdev
)
126 struct drm_device
*dev
= qdev
->ddev
;
127 while (qxl_display_copy_rom_client_monitors_config(qdev
)) {
128 qxl_io_log(qdev
, "failed crc check for client_monitors_config,"
132 drm_modeset_lock_all(dev
);
133 qxl_update_offset_props(qdev
);
134 drm_modeset_unlock_all(dev
);
135 if (!drm_helper_hpd_irq_event(qdev
->ddev
)) {
136 /* notify that the monitor configuration changed, to
137 adjust at the arbitrary resolution */
138 drm_kms_helper_hotplug_event(qdev
->ddev
);
142 static int qxl_add_monitors_config_modes(struct drm_connector
*connector
,
146 struct drm_device
*dev
= connector
->dev
;
147 struct qxl_device
*qdev
= dev
->dev_private
;
148 struct qxl_output
*output
= drm_connector_to_qxl_output(connector
);
149 int h
= output
->index
;
150 struct drm_display_mode
*mode
= NULL
;
151 struct qxl_head
*head
;
153 if (!qdev
->client_monitors_config
)
155 head
= &qdev
->client_monitors_config
->heads
[h
];
157 mode
= drm_cvt_mode(dev
, head
->width
, head
->height
, 60, false, false,
159 mode
->type
|= DRM_MODE_TYPE_PREFERRED
;
160 *pwidth
= head
->width
;
161 *pheight
= head
->height
;
162 drm_mode_probed_add(connector
, mode
);
163 /* remember the last custom size for mode validation */
164 qdev
->monitors_config_width
= mode
->hdisplay
;
165 qdev
->monitors_config_height
= mode
->vdisplay
;
169 static struct mode_size
{
192 static int qxl_add_common_modes(struct drm_connector
*connector
,
196 struct drm_device
*dev
= connector
->dev
;
197 struct drm_display_mode
*mode
= NULL
;
199 for (i
= 0; i
< ARRAY_SIZE(common_modes
); i
++) {
200 mode
= drm_cvt_mode(dev
, common_modes
[i
].w
, common_modes
[i
].h
,
201 60, false, false, false);
202 if (common_modes
[i
].w
== pwidth
&& common_modes
[i
].h
== pheight
)
203 mode
->type
|= DRM_MODE_TYPE_PREFERRED
;
204 drm_mode_probed_add(connector
, mode
);
209 static void qxl_crtc_destroy(struct drm_crtc
*crtc
)
211 struct qxl_crtc
*qxl_crtc
= to_qxl_crtc(crtc
);
213 drm_crtc_cleanup(crtc
);
217 static int qxl_crtc_page_flip(struct drm_crtc
*crtc
,
218 struct drm_framebuffer
*fb
,
219 struct drm_pending_vblank_event
*event
,
220 uint32_t page_flip_flags
)
222 struct drm_device
*dev
= crtc
->dev
;
223 struct qxl_device
*qdev
= dev
->dev_private
;
224 struct qxl_crtc
*qcrtc
= to_qxl_crtc(crtc
);
225 struct qxl_framebuffer
*qfb_src
= to_qxl_framebuffer(fb
);
226 struct qxl_framebuffer
*qfb_old
= to_qxl_framebuffer(crtc
->primary
->fb
);
227 struct qxl_bo
*bo_old
= gem_to_qxl_bo(qfb_old
->obj
);
228 struct qxl_bo
*bo
= gem_to_qxl_bo(qfb_src
->obj
);
230 struct drm_clip_rect norect
= {
237 int one_clip_rect
= 1;
240 crtc
->primary
->fb
= fb
;
241 bo_old
->is_primary
= false;
242 bo
->is_primary
= true;
244 ret
= qxl_bo_reserve(bo
, false);
247 ret
= qxl_bo_pin(bo
, bo
->type
, NULL
);
248 qxl_bo_unreserve(bo
);
252 qxl_draw_dirty_fb(qdev
, qfb_src
, bo
, 0, 0,
253 &norect
, one_clip_rect
, inc
);
255 drm_vblank_get(dev
, qcrtc
->index
);
258 spin_lock_irqsave(&dev
->event_lock
, flags
);
259 drm_send_vblank_event(dev
, qcrtc
->index
, event
);
260 spin_unlock_irqrestore(&dev
->event_lock
, flags
);
262 drm_vblank_put(dev
, qcrtc
->index
);
264 ret
= qxl_bo_reserve(bo
, false);
267 qxl_bo_unreserve(bo
);
274 qxl_hide_cursor(struct qxl_device
*qdev
)
276 struct qxl_release
*release
;
277 struct qxl_cursor_cmd
*cmd
;
280 ret
= qxl_alloc_release_reserved(qdev
, sizeof(*cmd
), QXL_RELEASE_CURSOR_CMD
,
285 ret
= qxl_release_reserve_list(release
, true);
287 qxl_release_free(qdev
, release
);
291 cmd
= (struct qxl_cursor_cmd
*)qxl_release_map(qdev
, release
);
292 cmd
->type
= QXL_CURSOR_HIDE
;
293 qxl_release_unmap(qdev
, release
, &cmd
->release_info
);
295 qxl_push_cursor_ring_release(qdev
, release
, QXL_CMD_CURSOR
, false);
296 qxl_release_fence_buffer_objects(release
);
300 static int qxl_crtc_cursor_set2(struct drm_crtc
*crtc
,
301 struct drm_file
*file_priv
,
304 uint32_t height
, int32_t hot_x
, int32_t hot_y
)
306 struct drm_device
*dev
= crtc
->dev
;
307 struct qxl_device
*qdev
= dev
->dev_private
;
308 struct qxl_crtc
*qcrtc
= to_qxl_crtc(crtc
);
309 struct drm_gem_object
*obj
;
310 struct qxl_cursor
*cursor
;
311 struct qxl_cursor_cmd
*cmd
;
312 struct qxl_bo
*cursor_bo
, *user_bo
;
313 struct qxl_release
*release
;
319 return qxl_hide_cursor(qdev
);
321 obj
= drm_gem_object_lookup(file_priv
, handle
);
323 DRM_ERROR("cannot find cursor object\n");
327 user_bo
= gem_to_qxl_bo(obj
);
329 ret
= qxl_bo_reserve(user_bo
, false);
333 ret
= qxl_bo_pin(user_bo
, QXL_GEM_DOMAIN_CPU
, NULL
);
334 qxl_bo_unreserve(user_bo
);
338 ret
= qxl_bo_kmap(user_bo
, &user_ptr
);
342 ret
= qxl_alloc_release_reserved(qdev
, sizeof(*cmd
),
343 QXL_RELEASE_CURSOR_CMD
,
348 ret
= qxl_alloc_bo_reserved(qdev
, release
, sizeof(struct qxl_cursor
) + size
,
351 goto out_free_release
;
353 ret
= qxl_release_reserve_list(release
, false);
357 ret
= qxl_bo_kmap(cursor_bo
, (void **)&cursor
);
361 cursor
->header
.unique
= 0;
362 cursor
->header
.type
= SPICE_CURSOR_TYPE_ALPHA
;
363 cursor
->header
.width
= 64;
364 cursor
->header
.height
= 64;
365 cursor
->header
.hot_spot_x
= hot_x
;
366 cursor
->header
.hot_spot_y
= hot_y
;
367 cursor
->data_size
= size
;
368 cursor
->chunk
.next_chunk
= 0;
369 cursor
->chunk
.prev_chunk
= 0;
370 cursor
->chunk
.data_size
= size
;
372 memcpy(cursor
->chunk
.data
, user_ptr
, size
);
374 qxl_bo_kunmap(cursor_bo
);
376 qxl_bo_kunmap(user_bo
);
378 qcrtc
->cur_x
+= qcrtc
->hot_spot_x
- hot_x
;
379 qcrtc
->cur_y
+= qcrtc
->hot_spot_y
- hot_y
;
380 qcrtc
->hot_spot_x
= hot_x
;
381 qcrtc
->hot_spot_y
= hot_y
;
383 cmd
= (struct qxl_cursor_cmd
*)qxl_release_map(qdev
, release
);
384 cmd
->type
= QXL_CURSOR_SET
;
385 cmd
->u
.set
.position
.x
= qcrtc
->cur_x
+ qcrtc
->hot_spot_x
;
386 cmd
->u
.set
.position
.y
= qcrtc
->cur_y
+ qcrtc
->hot_spot_y
;
388 cmd
->u
.set
.shape
= qxl_bo_physical_address(qdev
, cursor_bo
, 0);
390 cmd
->u
.set
.visible
= 1;
391 qxl_release_unmap(qdev
, release
, &cmd
->release_info
);
393 qxl_push_cursor_ring_release(qdev
, release
, QXL_CMD_CURSOR
, false);
394 qxl_release_fence_buffer_objects(release
);
396 /* finish with the userspace bo */
397 ret
= qxl_bo_reserve(user_bo
, false);
399 qxl_bo_unpin(user_bo
);
400 qxl_bo_unreserve(user_bo
);
402 drm_gem_object_unreference_unlocked(obj
);
404 qxl_bo_unref(&cursor_bo
);
409 qxl_release_backoff_reserve_list(release
);
411 qxl_bo_unref(&cursor_bo
);
413 qxl_release_free(qdev
, release
);
415 qxl_bo_kunmap(user_bo
);
417 qxl_bo_unpin(user_bo
);
419 drm_gem_object_unreference_unlocked(obj
);
423 static int qxl_crtc_cursor_move(struct drm_crtc
*crtc
,
426 struct drm_device
*dev
= crtc
->dev
;
427 struct qxl_device
*qdev
= dev
->dev_private
;
428 struct qxl_crtc
*qcrtc
= to_qxl_crtc(crtc
);
429 struct qxl_release
*release
;
430 struct qxl_cursor_cmd
*cmd
;
433 ret
= qxl_alloc_release_reserved(qdev
, sizeof(*cmd
), QXL_RELEASE_CURSOR_CMD
,
438 ret
= qxl_release_reserve_list(release
, true);
440 qxl_release_free(qdev
, release
);
447 cmd
= (struct qxl_cursor_cmd
*)qxl_release_map(qdev
, release
);
448 cmd
->type
= QXL_CURSOR_MOVE
;
449 cmd
->u
.position
.x
= qcrtc
->cur_x
+ qcrtc
->hot_spot_x
;
450 cmd
->u
.position
.y
= qcrtc
->cur_y
+ qcrtc
->hot_spot_y
;
451 qxl_release_unmap(qdev
, release
, &cmd
->release_info
);
453 qxl_push_cursor_ring_release(qdev
, release
, QXL_CMD_CURSOR
, false);
454 qxl_release_fence_buffer_objects(release
);
460 static const struct drm_crtc_funcs qxl_crtc_funcs
= {
461 .cursor_set2
= qxl_crtc_cursor_set2
,
462 .cursor_move
= qxl_crtc_cursor_move
,
463 .set_config
= drm_crtc_helper_set_config
,
464 .destroy
= qxl_crtc_destroy
,
465 .page_flip
= qxl_crtc_page_flip
,
468 void qxl_user_framebuffer_destroy(struct drm_framebuffer
*fb
)
470 struct qxl_framebuffer
*qxl_fb
= to_qxl_framebuffer(fb
);
473 drm_gem_object_unreference_unlocked(qxl_fb
->obj
);
474 drm_framebuffer_cleanup(fb
);
478 static int qxl_framebuffer_surface_dirty(struct drm_framebuffer
*fb
,
479 struct drm_file
*file_priv
,
480 unsigned flags
, unsigned color
,
481 struct drm_clip_rect
*clips
,
484 /* TODO: vmwgfx where this was cribbed from had locking. Why? */
485 struct qxl_framebuffer
*qxl_fb
= to_qxl_framebuffer(fb
);
486 struct qxl_device
*qdev
= qxl_fb
->base
.dev
->dev_private
;
487 struct drm_clip_rect norect
;
491 drm_modeset_lock_all(fb
->dev
);
493 qobj
= gem_to_qxl_bo(qxl_fb
->obj
);
494 /* if we aren't primary surface ignore this */
495 if (!qobj
->is_primary
) {
496 drm_modeset_unlock_all(fb
->dev
);
503 norect
.x1
= norect
.y1
= 0;
504 norect
.x2
= fb
->width
;
505 norect
.y2
= fb
->height
;
506 } else if (flags
& DRM_MODE_FB_DIRTY_ANNOTATE_COPY
) {
508 inc
= 2; /* skip source rects */
511 qxl_draw_dirty_fb(qdev
, qxl_fb
, qobj
, flags
, color
,
512 clips
, num_clips
, inc
);
514 drm_modeset_unlock_all(fb
->dev
);
519 static const struct drm_framebuffer_funcs qxl_fb_funcs
= {
520 .destroy
= qxl_user_framebuffer_destroy
,
521 .dirty
= qxl_framebuffer_surface_dirty
,
523 * .create_handle = qxl_user_framebuffer_create_handle, */
527 qxl_framebuffer_init(struct drm_device
*dev
,
528 struct qxl_framebuffer
*qfb
,
529 const struct drm_mode_fb_cmd2
*mode_cmd
,
530 struct drm_gem_object
*obj
,
531 const struct drm_framebuffer_funcs
*funcs
)
536 ret
= drm_framebuffer_init(dev
, &qfb
->base
, funcs
);
541 drm_helper_mode_fill_fb_struct(&qfb
->base
, mode_cmd
);
545 static void qxl_crtc_dpms(struct drm_crtc
*crtc
, int mode
)
549 static bool qxl_crtc_mode_fixup(struct drm_crtc
*crtc
,
550 const struct drm_display_mode
*mode
,
551 struct drm_display_mode
*adjusted_mode
)
553 struct drm_device
*dev
= crtc
->dev
;
554 struct qxl_device
*qdev
= dev
->dev_private
;
556 qxl_io_log(qdev
, "%s: (%d,%d) => (%d,%d)\n",
558 mode
->hdisplay
, mode
->vdisplay
,
559 adjusted_mode
->hdisplay
,
560 adjusted_mode
->vdisplay
);
565 qxl_send_monitors_config(struct qxl_device
*qdev
)
569 BUG_ON(!qdev
->ram_header
->monitors_config
);
571 if (qdev
->monitors_config
->count
== 0) {
572 qxl_io_log(qdev
, "%s: 0 monitors??\n", __func__
);
575 for (i
= 0 ; i
< qdev
->monitors_config
->count
; ++i
) {
576 struct qxl_head
*head
= &qdev
->monitors_config
->heads
[i
];
578 if (head
->y
> 8192 || head
->x
> 8192 ||
579 head
->width
> 8192 || head
->height
> 8192) {
580 DRM_ERROR("head %d wrong: %dx%d+%d+%d\n",
581 i
, head
->width
, head
->height
,
586 qxl_io_monitors_config(qdev
);
589 static void qxl_monitors_config_set(struct qxl_device
*qdev
,
591 unsigned x
, unsigned y
,
592 unsigned width
, unsigned height
,
595 DRM_DEBUG_KMS("%d:%dx%d+%d+%d\n", index
, width
, height
, x
, y
);
596 qdev
->monitors_config
->heads
[index
].x
= x
;
597 qdev
->monitors_config
->heads
[index
].y
= y
;
598 qdev
->monitors_config
->heads
[index
].width
= width
;
599 qdev
->monitors_config
->heads
[index
].height
= height
;
600 qdev
->monitors_config
->heads
[index
].surface_id
= surf_id
;
604 static int qxl_crtc_mode_set(struct drm_crtc
*crtc
,
605 struct drm_display_mode
*mode
,
606 struct drm_display_mode
*adjusted_mode
,
608 struct drm_framebuffer
*old_fb
)
610 struct drm_device
*dev
= crtc
->dev
;
611 struct qxl_device
*qdev
= dev
->dev_private
;
612 struct qxl_framebuffer
*qfb
;
613 struct qxl_bo
*bo
, *old_bo
= NULL
;
614 struct qxl_crtc
*qcrtc
= to_qxl_crtc(crtc
);
615 bool recreate_primary
= false;
618 if (!crtc
->primary
->fb
) {
619 DRM_DEBUG_KMS("No FB bound\n");
624 qfb
= to_qxl_framebuffer(old_fb
);
625 old_bo
= gem_to_qxl_bo(qfb
->obj
);
627 qfb
= to_qxl_framebuffer(crtc
->primary
->fb
);
628 bo
= gem_to_qxl_bo(qfb
->obj
);
629 DRM_DEBUG("+%d+%d (%d,%d) => (%d,%d)\n",
631 mode
->hdisplay
, mode
->vdisplay
,
632 adjusted_mode
->hdisplay
,
633 adjusted_mode
->vdisplay
);
635 if (bo
->is_primary
== false)
636 recreate_primary
= true;
638 if (bo
->surf
.stride
* bo
->surf
.height
> qdev
->vram_size
) {
639 DRM_ERROR("Mode doesn't fit in vram size (vgamem)");
643 ret
= qxl_bo_reserve(bo
, false);
646 ret
= qxl_bo_pin(bo
, bo
->type
, NULL
);
648 qxl_bo_unreserve(bo
);
651 qxl_bo_unreserve(bo
);
652 if (recreate_primary
) {
653 qxl_io_destroy_primary(qdev
);
655 "recreate primary: %dx%d,%d,%d\n",
656 bo
->surf
.width
, bo
->surf
.height
,
657 bo
->surf
.stride
, bo
->surf
.format
);
658 qxl_io_create_primary(qdev
, 0, bo
);
659 bo
->is_primary
= true;
662 if (bo
->is_primary
) {
663 DRM_DEBUG_KMS("setting surface_id to 0 for primary surface %d on crtc %d\n", bo
->surface_id
, qcrtc
->index
);
666 surf_id
= bo
->surface_id
;
669 if (old_bo
&& old_bo
!= bo
) {
670 old_bo
->is_primary
= false;
671 ret
= qxl_bo_reserve(old_bo
, false);
672 qxl_bo_unpin(old_bo
);
673 qxl_bo_unreserve(old_bo
);
676 qxl_monitors_config_set(qdev
, qcrtc
->index
, x
, y
,
678 mode
->vdisplay
, surf_id
);
682 static void qxl_crtc_prepare(struct drm_crtc
*crtc
)
684 DRM_DEBUG("current: %dx%d+%d+%d (%d).\n",
685 crtc
->mode
.hdisplay
, crtc
->mode
.vdisplay
,
686 crtc
->x
, crtc
->y
, crtc
->enabled
);
689 static void qxl_crtc_commit(struct drm_crtc
*crtc
)
694 static void qxl_crtc_disable(struct drm_crtc
*crtc
)
696 struct qxl_crtc
*qcrtc
= to_qxl_crtc(crtc
);
697 struct drm_device
*dev
= crtc
->dev
;
698 struct qxl_device
*qdev
= dev
->dev_private
;
699 if (crtc
->primary
->fb
) {
700 struct qxl_framebuffer
*qfb
= to_qxl_framebuffer(crtc
->primary
->fb
);
701 struct qxl_bo
*bo
= gem_to_qxl_bo(qfb
->obj
);
703 ret
= qxl_bo_reserve(bo
, false);
705 qxl_bo_unreserve(bo
);
706 crtc
->primary
->fb
= NULL
;
709 qxl_monitors_config_set(qdev
, qcrtc
->index
, 0, 0, 0, 0, 0);
711 qxl_send_monitors_config(qdev
);
714 static const struct drm_crtc_helper_funcs qxl_crtc_helper_funcs
= {
715 .dpms
= qxl_crtc_dpms
,
716 .disable
= qxl_crtc_disable
,
717 .mode_fixup
= qxl_crtc_mode_fixup
,
718 .mode_set
= qxl_crtc_mode_set
,
719 .prepare
= qxl_crtc_prepare
,
720 .commit
= qxl_crtc_commit
,
723 static int qdev_crtc_init(struct drm_device
*dev
, int crtc_id
)
725 struct qxl_crtc
*qxl_crtc
;
727 qxl_crtc
= kzalloc(sizeof(struct qxl_crtc
), GFP_KERNEL
);
731 drm_crtc_init(dev
, &qxl_crtc
->base
, &qxl_crtc_funcs
);
732 qxl_crtc
->index
= crtc_id
;
733 drm_mode_crtc_set_gamma_size(&qxl_crtc
->base
, 256);
734 drm_crtc_helper_add(&qxl_crtc
->base
, &qxl_crtc_helper_funcs
);
738 static void qxl_enc_dpms(struct drm_encoder
*encoder
, int mode
)
743 static void qxl_enc_prepare(struct drm_encoder
*encoder
)
748 static void qxl_write_monitors_config_for_encoder(struct qxl_device
*qdev
,
749 struct drm_encoder
*encoder
)
752 struct qxl_output
*output
= drm_encoder_to_qxl_output(encoder
);
753 struct qxl_head
*head
;
754 struct drm_display_mode
*mode
;
757 /* TODO: ugly, do better */
759 if (!qdev
->monitors_config
||
760 qdev
->monitors_config
->max_allowed
<= i
) {
762 "head number too large or missing monitors config: %p, %d",
763 qdev
->monitors_config
,
764 qdev
->monitors_config
?
765 qdev
->monitors_config
->max_allowed
: -1);
768 if (!encoder
->crtc
) {
769 DRM_ERROR("missing crtc on encoder %p\n", encoder
);
773 DRM_DEBUG("missing for multiple monitors: no head holes\n");
774 head
= &qdev
->monitors_config
->heads
[i
];
776 if (encoder
->crtc
->enabled
) {
777 mode
= &encoder
->crtc
->mode
;
778 head
->width
= mode
->hdisplay
;
779 head
->height
= mode
->vdisplay
;
780 head
->x
= encoder
->crtc
->x
;
781 head
->y
= encoder
->crtc
->y
;
782 if (qdev
->monitors_config
->count
< i
+ 1)
783 qdev
->monitors_config
->count
= i
+ 1;
790 DRM_DEBUG_KMS("setting head %d to +%d+%d %dx%d out of %d\n",
791 i
, head
->x
, head
->y
, head
->width
, head
->height
, qdev
->monitors_config
->count
);
793 /* TODO - somewhere else to call this for multiple monitors
794 * (config_commit?) */
795 qxl_send_monitors_config(qdev
);
798 static void qxl_enc_commit(struct drm_encoder
*encoder
)
800 struct qxl_device
*qdev
= encoder
->dev
->dev_private
;
802 qxl_write_monitors_config_for_encoder(qdev
, encoder
);
806 static void qxl_enc_mode_set(struct drm_encoder
*encoder
,
807 struct drm_display_mode
*mode
,
808 struct drm_display_mode
*adjusted_mode
)
813 static int qxl_conn_get_modes(struct drm_connector
*connector
)
816 struct qxl_device
*qdev
= connector
->dev
->dev_private
;
817 unsigned pwidth
= 1024;
818 unsigned pheight
= 768;
820 DRM_DEBUG_KMS("monitors_config=%p\n", qdev
->monitors_config
);
821 /* TODO: what should we do here? only show the configured modes for the
822 * device, or allow the full list, or both? */
823 if (qdev
->monitors_config
&& qdev
->monitors_config
->count
) {
824 ret
= qxl_add_monitors_config_modes(connector
, &pwidth
, &pheight
);
828 ret
+= qxl_add_common_modes(connector
, pwidth
, pheight
);
832 static int qxl_conn_mode_valid(struct drm_connector
*connector
,
833 struct drm_display_mode
*mode
)
835 struct drm_device
*ddev
= connector
->dev
;
836 struct qxl_device
*qdev
= ddev
->dev_private
;
839 /* TODO: is this called for user defined modes? (xrandr --add-mode)
840 * TODO: check that the mode fits in the framebuffer */
842 if(qdev
->monitors_config_width
== mode
->hdisplay
&&
843 qdev
->monitors_config_height
== mode
->vdisplay
)
846 for (i
= 0; i
< ARRAY_SIZE(common_modes
); i
++) {
847 if (common_modes
[i
].w
== mode
->hdisplay
&& common_modes
[i
].h
== mode
->vdisplay
)
853 static struct drm_encoder
*qxl_best_encoder(struct drm_connector
*connector
)
855 struct qxl_output
*qxl_output
=
856 drm_connector_to_qxl_output(connector
);
859 return &qxl_output
->enc
;
863 static const struct drm_encoder_helper_funcs qxl_enc_helper_funcs
= {
864 .dpms
= qxl_enc_dpms
,
865 .prepare
= qxl_enc_prepare
,
866 .mode_set
= qxl_enc_mode_set
,
867 .commit
= qxl_enc_commit
,
870 static const struct drm_connector_helper_funcs qxl_connector_helper_funcs
= {
871 .get_modes
= qxl_conn_get_modes
,
872 .mode_valid
= qxl_conn_mode_valid
,
873 .best_encoder
= qxl_best_encoder
,
876 static enum drm_connector_status
qxl_conn_detect(
877 struct drm_connector
*connector
,
880 struct qxl_output
*output
=
881 drm_connector_to_qxl_output(connector
);
882 struct drm_device
*ddev
= connector
->dev
;
883 struct qxl_device
*qdev
= ddev
->dev_private
;
884 bool connected
= false;
886 /* The first monitor is always connected */
887 if (!qdev
->client_monitors_config
) {
888 if (output
->index
== 0)
891 connected
= qdev
->client_monitors_config
->count
> output
->index
&&
892 qxl_head_enabled(&qdev
->client_monitors_config
->heads
[output
->index
]);
894 DRM_DEBUG("#%d connected: %d\n", output
->index
, connected
);
896 qxl_monitors_config_set(qdev
, output
->index
, 0, 0, 0, 0, 0);
898 return connected
? connector_status_connected
899 : connector_status_disconnected
;
902 static int qxl_conn_set_property(struct drm_connector
*connector
,
903 struct drm_property
*property
,
910 static void qxl_conn_destroy(struct drm_connector
*connector
)
912 struct qxl_output
*qxl_output
=
913 drm_connector_to_qxl_output(connector
);
915 drm_connector_unregister(connector
);
916 drm_connector_cleanup(connector
);
920 static const struct drm_connector_funcs qxl_connector_funcs
= {
921 .dpms
= drm_helper_connector_dpms
,
922 .detect
= qxl_conn_detect
,
923 .fill_modes
= drm_helper_probe_single_connector_modes
,
924 .set_property
= qxl_conn_set_property
,
925 .destroy
= qxl_conn_destroy
,
928 static void qxl_enc_destroy(struct drm_encoder
*encoder
)
930 drm_encoder_cleanup(encoder
);
933 static const struct drm_encoder_funcs qxl_enc_funcs
= {
934 .destroy
= qxl_enc_destroy
,
937 static int qxl_mode_create_hotplug_mode_update_property(struct qxl_device
*qdev
)
939 if (qdev
->hotplug_mode_update_property
)
942 qdev
->hotplug_mode_update_property
=
943 drm_property_create_range(qdev
->ddev
, DRM_MODE_PROP_IMMUTABLE
,
944 "hotplug_mode_update", 0, 1);
949 static int qdev_output_init(struct drm_device
*dev
, int num_output
)
951 struct qxl_device
*qdev
= dev
->dev_private
;
952 struct qxl_output
*qxl_output
;
953 struct drm_connector
*connector
;
954 struct drm_encoder
*encoder
;
956 qxl_output
= kzalloc(sizeof(struct qxl_output
), GFP_KERNEL
);
960 qxl_output
->index
= num_output
;
962 connector
= &qxl_output
->base
;
963 encoder
= &qxl_output
->enc
;
964 drm_connector_init(dev
, &qxl_output
->base
,
965 &qxl_connector_funcs
, DRM_MODE_CONNECTOR_VIRTUAL
);
967 drm_encoder_init(dev
, &qxl_output
->enc
, &qxl_enc_funcs
,
968 DRM_MODE_ENCODER_VIRTUAL
, NULL
);
970 /* we get HPD via client monitors config */
971 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
972 encoder
->possible_crtcs
= 1 << num_output
;
973 drm_mode_connector_attach_encoder(&qxl_output
->base
,
975 drm_encoder_helper_add(encoder
, &qxl_enc_helper_funcs
);
976 drm_connector_helper_add(connector
, &qxl_connector_helper_funcs
);
978 drm_object_attach_property(&connector
->base
,
979 qdev
->hotplug_mode_update_property
, 0);
980 drm_object_attach_property(&connector
->base
,
981 dev
->mode_config
.suggested_x_property
, 0);
982 drm_object_attach_property(&connector
->base
,
983 dev
->mode_config
.suggested_y_property
, 0);
984 drm_connector_register(connector
);
988 static struct drm_framebuffer
*
989 qxl_user_framebuffer_create(struct drm_device
*dev
,
990 struct drm_file
*file_priv
,
991 const struct drm_mode_fb_cmd2
*mode_cmd
)
993 struct drm_gem_object
*obj
;
994 struct qxl_framebuffer
*qxl_fb
;
997 obj
= drm_gem_object_lookup(file_priv
, mode_cmd
->handles
[0]);
1001 qxl_fb
= kzalloc(sizeof(*qxl_fb
), GFP_KERNEL
);
1005 ret
= qxl_framebuffer_init(dev
, qxl_fb
, mode_cmd
, obj
, &qxl_fb_funcs
);
1008 drm_gem_object_unreference_unlocked(obj
);
1012 return &qxl_fb
->base
;
1015 static const struct drm_mode_config_funcs qxl_mode_funcs
= {
1016 .fb_create
= qxl_user_framebuffer_create
,
1019 int qxl_create_monitors_object(struct qxl_device
*qdev
)
1022 struct drm_gem_object
*gobj
;
1023 int max_allowed
= qxl_num_crtc
;
1024 int monitors_config_size
= sizeof(struct qxl_monitors_config
) +
1025 max_allowed
* sizeof(struct qxl_head
);
1027 ret
= qxl_gem_object_create(qdev
, monitors_config_size
, 0,
1028 QXL_GEM_DOMAIN_VRAM
,
1029 false, false, NULL
, &gobj
);
1031 DRM_ERROR("%s: failed to create gem ret=%d\n", __func__
, ret
);
1034 qdev
->monitors_config_bo
= gem_to_qxl_bo(gobj
);
1036 ret
= qxl_bo_reserve(qdev
->monitors_config_bo
, false);
1040 ret
= qxl_bo_pin(qdev
->monitors_config_bo
, QXL_GEM_DOMAIN_VRAM
, NULL
);
1042 qxl_bo_unreserve(qdev
->monitors_config_bo
);
1046 qxl_bo_unreserve(qdev
->monitors_config_bo
);
1048 qxl_bo_kmap(qdev
->monitors_config_bo
, NULL
);
1050 qdev
->monitors_config
= qdev
->monitors_config_bo
->kptr
;
1051 qdev
->ram_header
->monitors_config
=
1052 qxl_bo_physical_address(qdev
, qdev
->monitors_config_bo
, 0);
1054 memset(qdev
->monitors_config
, 0, monitors_config_size
);
1055 qdev
->monitors_config
->max_allowed
= max_allowed
;
1059 int qxl_destroy_monitors_object(struct qxl_device
*qdev
)
1063 qdev
->monitors_config
= NULL
;
1064 qdev
->ram_header
->monitors_config
= 0;
1066 qxl_bo_kunmap(qdev
->monitors_config_bo
);
1067 ret
= qxl_bo_reserve(qdev
->monitors_config_bo
, false);
1071 qxl_bo_unpin(qdev
->monitors_config_bo
);
1072 qxl_bo_unreserve(qdev
->monitors_config_bo
);
1074 qxl_bo_unref(&qdev
->monitors_config_bo
);
1078 int qxl_modeset_init(struct qxl_device
*qdev
)
1083 drm_mode_config_init(qdev
->ddev
);
1085 ret
= qxl_create_monitors_object(qdev
);
1089 qdev
->ddev
->mode_config
.funcs
= (void *)&qxl_mode_funcs
;
1091 /* modes will be validated against the framebuffer size */
1092 qdev
->ddev
->mode_config
.min_width
= 320;
1093 qdev
->ddev
->mode_config
.min_height
= 200;
1094 qdev
->ddev
->mode_config
.max_width
= 8192;
1095 qdev
->ddev
->mode_config
.max_height
= 8192;
1097 qdev
->ddev
->mode_config
.fb_base
= qdev
->vram_base
;
1099 drm_mode_create_suggested_offset_properties(qdev
->ddev
);
1100 qxl_mode_create_hotplug_mode_update_property(qdev
);
1102 for (i
= 0 ; i
< qxl_num_crtc
; ++i
) {
1103 qdev_crtc_init(qdev
->ddev
, i
);
1104 qdev_output_init(qdev
->ddev
, i
);
1107 qdev
->mode_info
.mode_config_initialized
= true;
1109 /* primary surface must be created by this point, to allow
1110 * issuing command queue commands and having them read by
1112 qxl_fbdev_init(qdev
);
1116 void qxl_modeset_fini(struct qxl_device
*qdev
)
1118 qxl_fbdev_fini(qdev
);
1120 qxl_destroy_monitors_object(qdev
);
1121 if (qdev
->mode_info
.mode_config_initialized
) {
1122 drm_mode_config_cleanup(qdev
->ddev
);
1123 qdev
->mode_info
.mode_config_initialized
= false;