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(crtc
->dev
, 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 cmd
= (struct qxl_cursor_cmd
*)qxl_release_map(qdev
, release
);
379 cmd
->type
= QXL_CURSOR_SET
;
380 cmd
->u
.set
.position
.x
= qcrtc
->cur_x
;
381 cmd
->u
.set
.position
.y
= qcrtc
->cur_y
;
383 cmd
->u
.set
.shape
= qxl_bo_physical_address(qdev
, cursor_bo
, 0);
385 cmd
->u
.set
.visible
= 1;
386 qxl_release_unmap(qdev
, release
, &cmd
->release_info
);
388 qxl_push_cursor_ring_release(qdev
, release
, QXL_CMD_CURSOR
, false);
389 qxl_release_fence_buffer_objects(release
);
391 /* finish with the userspace bo */
392 ret
= qxl_bo_reserve(user_bo
, false);
394 qxl_bo_unpin(user_bo
);
395 qxl_bo_unreserve(user_bo
);
397 drm_gem_object_unreference_unlocked(obj
);
399 qxl_bo_unref(&cursor_bo
);
404 qxl_release_backoff_reserve_list(release
);
406 qxl_bo_unref(&cursor_bo
);
408 qxl_release_free(qdev
, release
);
410 qxl_bo_kunmap(user_bo
);
412 qxl_bo_unpin(user_bo
);
414 drm_gem_object_unreference_unlocked(obj
);
418 static int qxl_crtc_cursor_move(struct drm_crtc
*crtc
,
421 struct drm_device
*dev
= crtc
->dev
;
422 struct qxl_device
*qdev
= dev
->dev_private
;
423 struct qxl_crtc
*qcrtc
= to_qxl_crtc(crtc
);
424 struct qxl_release
*release
;
425 struct qxl_cursor_cmd
*cmd
;
428 ret
= qxl_alloc_release_reserved(qdev
, sizeof(*cmd
), QXL_RELEASE_CURSOR_CMD
,
433 ret
= qxl_release_reserve_list(release
, true);
435 qxl_release_free(qdev
, release
);
442 cmd
= (struct qxl_cursor_cmd
*)qxl_release_map(qdev
, release
);
443 cmd
->type
= QXL_CURSOR_MOVE
;
444 cmd
->u
.position
.x
= qcrtc
->cur_x
;
445 cmd
->u
.position
.y
= qcrtc
->cur_y
;
446 qxl_release_unmap(qdev
, release
, &cmd
->release_info
);
448 qxl_push_cursor_ring_release(qdev
, release
, QXL_CMD_CURSOR
, false);
449 qxl_release_fence_buffer_objects(release
);
455 static const struct drm_crtc_funcs qxl_crtc_funcs
= {
456 .cursor_set2
= qxl_crtc_cursor_set2
,
457 .cursor_move
= qxl_crtc_cursor_move
,
458 .set_config
= drm_crtc_helper_set_config
,
459 .destroy
= qxl_crtc_destroy
,
460 .page_flip
= qxl_crtc_page_flip
,
463 static void qxl_user_framebuffer_destroy(struct drm_framebuffer
*fb
)
465 struct qxl_framebuffer
*qxl_fb
= to_qxl_framebuffer(fb
);
468 drm_gem_object_unreference_unlocked(qxl_fb
->obj
);
469 drm_framebuffer_cleanup(fb
);
473 static int qxl_framebuffer_surface_dirty(struct drm_framebuffer
*fb
,
474 struct drm_file
*file_priv
,
475 unsigned flags
, unsigned color
,
476 struct drm_clip_rect
*clips
,
479 /* TODO: vmwgfx where this was cribbed from had locking. Why? */
480 struct qxl_framebuffer
*qxl_fb
= to_qxl_framebuffer(fb
);
481 struct qxl_device
*qdev
= qxl_fb
->base
.dev
->dev_private
;
482 struct drm_clip_rect norect
;
486 drm_modeset_lock_all(fb
->dev
);
488 qobj
= gem_to_qxl_bo(qxl_fb
->obj
);
489 /* if we aren't primary surface ignore this */
490 if (!qobj
->is_primary
) {
491 drm_modeset_unlock_all(fb
->dev
);
498 norect
.x1
= norect
.y1
= 0;
499 norect
.x2
= fb
->width
;
500 norect
.y2
= fb
->height
;
501 } else if (flags
& DRM_MODE_FB_DIRTY_ANNOTATE_COPY
) {
503 inc
= 2; /* skip source rects */
506 qxl_draw_dirty_fb(qdev
, qxl_fb
, qobj
, flags
, color
,
507 clips
, num_clips
, inc
);
509 drm_modeset_unlock_all(fb
->dev
);
514 static const struct drm_framebuffer_funcs qxl_fb_funcs
= {
515 .destroy
= qxl_user_framebuffer_destroy
,
516 .dirty
= qxl_framebuffer_surface_dirty
,
518 * .create_handle = qxl_user_framebuffer_create_handle, */
522 qxl_framebuffer_init(struct drm_device
*dev
,
523 struct qxl_framebuffer
*qfb
,
524 const struct drm_mode_fb_cmd2
*mode_cmd
,
525 struct drm_gem_object
*obj
)
530 ret
= drm_framebuffer_init(dev
, &qfb
->base
, &qxl_fb_funcs
);
535 drm_helper_mode_fill_fb_struct(&qfb
->base
, mode_cmd
);
539 static void qxl_crtc_dpms(struct drm_crtc
*crtc
, int mode
)
543 static bool qxl_crtc_mode_fixup(struct drm_crtc
*crtc
,
544 const struct drm_display_mode
*mode
,
545 struct drm_display_mode
*adjusted_mode
)
547 struct drm_device
*dev
= crtc
->dev
;
548 struct qxl_device
*qdev
= dev
->dev_private
;
550 qxl_io_log(qdev
, "%s: (%d,%d) => (%d,%d)\n",
552 mode
->hdisplay
, mode
->vdisplay
,
553 adjusted_mode
->hdisplay
,
554 adjusted_mode
->vdisplay
);
559 qxl_send_monitors_config(struct qxl_device
*qdev
)
563 BUG_ON(!qdev
->ram_header
->monitors_config
);
565 if (qdev
->monitors_config
->count
== 0) {
566 qxl_io_log(qdev
, "%s: 0 monitors??\n", __func__
);
569 for (i
= 0 ; i
< qdev
->monitors_config
->count
; ++i
) {
570 struct qxl_head
*head
= &qdev
->monitors_config
->heads
[i
];
572 if (head
->y
> 8192 || head
->x
> 8192 ||
573 head
->width
> 8192 || head
->height
> 8192) {
574 DRM_ERROR("head %d wrong: %dx%d+%d+%d\n",
575 i
, head
->width
, head
->height
,
580 qxl_io_monitors_config(qdev
);
583 static void qxl_monitors_config_set(struct qxl_device
*qdev
,
585 unsigned x
, unsigned y
,
586 unsigned width
, unsigned height
,
589 DRM_DEBUG_KMS("%d:%dx%d+%d+%d\n", index
, width
, height
, x
, y
);
590 qdev
->monitors_config
->heads
[index
].x
= x
;
591 qdev
->monitors_config
->heads
[index
].y
= y
;
592 qdev
->monitors_config
->heads
[index
].width
= width
;
593 qdev
->monitors_config
->heads
[index
].height
= height
;
594 qdev
->monitors_config
->heads
[index
].surface_id
= surf_id
;
598 static int qxl_crtc_mode_set(struct drm_crtc
*crtc
,
599 struct drm_display_mode
*mode
,
600 struct drm_display_mode
*adjusted_mode
,
602 struct drm_framebuffer
*old_fb
)
604 struct drm_device
*dev
= crtc
->dev
;
605 struct qxl_device
*qdev
= dev
->dev_private
;
606 struct qxl_framebuffer
*qfb
;
607 struct qxl_bo
*bo
, *old_bo
= NULL
;
608 struct qxl_crtc
*qcrtc
= to_qxl_crtc(crtc
);
609 bool recreate_primary
= false;
612 if (!crtc
->primary
->fb
) {
613 DRM_DEBUG_KMS("No FB bound\n");
618 qfb
= to_qxl_framebuffer(old_fb
);
619 old_bo
= gem_to_qxl_bo(qfb
->obj
);
621 qfb
= to_qxl_framebuffer(crtc
->primary
->fb
);
622 bo
= gem_to_qxl_bo(qfb
->obj
);
623 DRM_DEBUG("+%d+%d (%d,%d) => (%d,%d)\n",
625 mode
->hdisplay
, mode
->vdisplay
,
626 adjusted_mode
->hdisplay
,
627 adjusted_mode
->vdisplay
);
629 if (bo
->is_primary
== false)
630 recreate_primary
= true;
632 if (bo
->surf
.stride
* bo
->surf
.height
> qdev
->vram_size
) {
633 DRM_ERROR("Mode doesn't fit in vram size (vgamem)");
637 ret
= qxl_bo_reserve(bo
, false);
640 ret
= qxl_bo_pin(bo
, bo
->type
, NULL
);
642 qxl_bo_unreserve(bo
);
645 qxl_bo_unreserve(bo
);
646 if (recreate_primary
) {
647 qxl_io_destroy_primary(qdev
);
649 "recreate primary: %dx%d,%d,%d\n",
650 bo
->surf
.width
, bo
->surf
.height
,
651 bo
->surf
.stride
, bo
->surf
.format
);
652 qxl_io_create_primary(qdev
, 0, bo
);
653 bo
->is_primary
= true;
656 if (bo
->is_primary
) {
657 DRM_DEBUG_KMS("setting surface_id to 0 for primary surface %d on crtc %d\n", bo
->surface_id
, qcrtc
->index
);
660 surf_id
= bo
->surface_id
;
663 if (old_bo
&& old_bo
!= bo
) {
664 old_bo
->is_primary
= false;
665 ret
= qxl_bo_reserve(old_bo
, false);
666 qxl_bo_unpin(old_bo
);
667 qxl_bo_unreserve(old_bo
);
670 qxl_monitors_config_set(qdev
, qcrtc
->index
, x
, y
,
672 mode
->vdisplay
, surf_id
);
676 static void qxl_crtc_prepare(struct drm_crtc
*crtc
)
678 DRM_DEBUG("current: %dx%d+%d+%d (%d).\n",
679 crtc
->mode
.hdisplay
, crtc
->mode
.vdisplay
,
680 crtc
->x
, crtc
->y
, crtc
->enabled
);
683 static void qxl_crtc_commit(struct drm_crtc
*crtc
)
688 static void qxl_crtc_disable(struct drm_crtc
*crtc
)
690 struct qxl_crtc
*qcrtc
= to_qxl_crtc(crtc
);
691 struct drm_device
*dev
= crtc
->dev
;
692 struct qxl_device
*qdev
= dev
->dev_private
;
693 if (crtc
->primary
->fb
) {
694 struct qxl_framebuffer
*qfb
= to_qxl_framebuffer(crtc
->primary
->fb
);
695 struct qxl_bo
*bo
= gem_to_qxl_bo(qfb
->obj
);
697 ret
= qxl_bo_reserve(bo
, false);
699 qxl_bo_unreserve(bo
);
700 crtc
->primary
->fb
= NULL
;
703 qxl_monitors_config_set(qdev
, qcrtc
->index
, 0, 0, 0, 0, 0);
705 qxl_send_monitors_config(qdev
);
708 static const struct drm_crtc_helper_funcs qxl_crtc_helper_funcs
= {
709 .dpms
= qxl_crtc_dpms
,
710 .disable
= qxl_crtc_disable
,
711 .mode_fixup
= qxl_crtc_mode_fixup
,
712 .mode_set
= qxl_crtc_mode_set
,
713 .prepare
= qxl_crtc_prepare
,
714 .commit
= qxl_crtc_commit
,
717 static int qdev_crtc_init(struct drm_device
*dev
, int crtc_id
)
719 struct qxl_crtc
*qxl_crtc
;
721 qxl_crtc
= kzalloc(sizeof(struct qxl_crtc
), GFP_KERNEL
);
725 drm_crtc_init(dev
, &qxl_crtc
->base
, &qxl_crtc_funcs
);
726 qxl_crtc
->index
= crtc_id
;
727 drm_mode_crtc_set_gamma_size(&qxl_crtc
->base
, 256);
728 drm_crtc_helper_add(&qxl_crtc
->base
, &qxl_crtc_helper_funcs
);
732 static void qxl_enc_dpms(struct drm_encoder
*encoder
, int mode
)
737 static void qxl_enc_prepare(struct drm_encoder
*encoder
)
742 static void qxl_write_monitors_config_for_encoder(struct qxl_device
*qdev
,
743 struct drm_encoder
*encoder
)
746 struct qxl_output
*output
= drm_encoder_to_qxl_output(encoder
);
747 struct qxl_head
*head
;
748 struct drm_display_mode
*mode
;
751 /* TODO: ugly, do better */
753 if (!qdev
->monitors_config
||
754 qdev
->monitors_config
->max_allowed
<= i
) {
756 "head number too large or missing monitors config: %p, %d",
757 qdev
->monitors_config
,
758 qdev
->monitors_config
?
759 qdev
->monitors_config
->max_allowed
: -1);
762 if (!encoder
->crtc
) {
763 DRM_ERROR("missing crtc on encoder %p\n", encoder
);
767 DRM_DEBUG("missing for multiple monitors: no head holes\n");
768 head
= &qdev
->monitors_config
->heads
[i
];
770 if (encoder
->crtc
->enabled
) {
771 mode
= &encoder
->crtc
->mode
;
772 head
->width
= mode
->hdisplay
;
773 head
->height
= mode
->vdisplay
;
774 head
->x
= encoder
->crtc
->x
;
775 head
->y
= encoder
->crtc
->y
;
776 if (qdev
->monitors_config
->count
< i
+ 1)
777 qdev
->monitors_config
->count
= i
+ 1;
784 DRM_DEBUG_KMS("setting head %d to +%d+%d %dx%d out of %d\n",
785 i
, head
->x
, head
->y
, head
->width
, head
->height
, qdev
->monitors_config
->count
);
787 /* TODO - somewhere else to call this for multiple monitors
788 * (config_commit?) */
789 qxl_send_monitors_config(qdev
);
792 static void qxl_enc_commit(struct drm_encoder
*encoder
)
794 struct qxl_device
*qdev
= encoder
->dev
->dev_private
;
796 qxl_write_monitors_config_for_encoder(qdev
, encoder
);
800 static void qxl_enc_mode_set(struct drm_encoder
*encoder
,
801 struct drm_display_mode
*mode
,
802 struct drm_display_mode
*adjusted_mode
)
807 static int qxl_conn_get_modes(struct drm_connector
*connector
)
810 struct qxl_device
*qdev
= connector
->dev
->dev_private
;
811 unsigned pwidth
= 1024;
812 unsigned pheight
= 768;
814 DRM_DEBUG_KMS("monitors_config=%p\n", qdev
->monitors_config
);
815 /* TODO: what should we do here? only show the configured modes for the
816 * device, or allow the full list, or both? */
817 if (qdev
->monitors_config
&& qdev
->monitors_config
->count
) {
818 ret
= qxl_add_monitors_config_modes(connector
, &pwidth
, &pheight
);
822 ret
+= qxl_add_common_modes(connector
, pwidth
, pheight
);
826 static int qxl_conn_mode_valid(struct drm_connector
*connector
,
827 struct drm_display_mode
*mode
)
829 struct drm_device
*ddev
= connector
->dev
;
830 struct qxl_device
*qdev
= ddev
->dev_private
;
833 /* TODO: is this called for user defined modes? (xrandr --add-mode)
834 * TODO: check that the mode fits in the framebuffer */
836 if(qdev
->monitors_config_width
== mode
->hdisplay
&&
837 qdev
->monitors_config_height
== mode
->vdisplay
)
840 for (i
= 0; i
< ARRAY_SIZE(common_modes
); i
++) {
841 if (common_modes
[i
].w
== mode
->hdisplay
&& common_modes
[i
].h
== mode
->vdisplay
)
847 static struct drm_encoder
*qxl_best_encoder(struct drm_connector
*connector
)
849 struct qxl_output
*qxl_output
=
850 drm_connector_to_qxl_output(connector
);
853 return &qxl_output
->enc
;
857 static const struct drm_encoder_helper_funcs qxl_enc_helper_funcs
= {
858 .dpms
= qxl_enc_dpms
,
859 .prepare
= qxl_enc_prepare
,
860 .mode_set
= qxl_enc_mode_set
,
861 .commit
= qxl_enc_commit
,
864 static const struct drm_connector_helper_funcs qxl_connector_helper_funcs
= {
865 .get_modes
= qxl_conn_get_modes
,
866 .mode_valid
= qxl_conn_mode_valid
,
867 .best_encoder
= qxl_best_encoder
,
870 static enum drm_connector_status
qxl_conn_detect(
871 struct drm_connector
*connector
,
874 struct qxl_output
*output
=
875 drm_connector_to_qxl_output(connector
);
876 struct drm_device
*ddev
= connector
->dev
;
877 struct qxl_device
*qdev
= ddev
->dev_private
;
878 bool connected
= false;
880 /* The first monitor is always connected */
881 if (!qdev
->client_monitors_config
) {
882 if (output
->index
== 0)
885 connected
= qdev
->client_monitors_config
->count
> output
->index
&&
886 qxl_head_enabled(&qdev
->client_monitors_config
->heads
[output
->index
]);
888 DRM_DEBUG("#%d connected: %d\n", output
->index
, connected
);
890 qxl_monitors_config_set(qdev
, output
->index
, 0, 0, 0, 0, 0);
892 return connected
? connector_status_connected
893 : connector_status_disconnected
;
896 static int qxl_conn_set_property(struct drm_connector
*connector
,
897 struct drm_property
*property
,
904 static void qxl_conn_destroy(struct drm_connector
*connector
)
906 struct qxl_output
*qxl_output
=
907 drm_connector_to_qxl_output(connector
);
909 drm_connector_unregister(connector
);
910 drm_connector_cleanup(connector
);
914 static const struct drm_connector_funcs qxl_connector_funcs
= {
915 .dpms
= drm_helper_connector_dpms
,
916 .detect
= qxl_conn_detect
,
917 .fill_modes
= drm_helper_probe_single_connector_modes
,
918 .set_property
= qxl_conn_set_property
,
919 .destroy
= qxl_conn_destroy
,
922 static void qxl_enc_destroy(struct drm_encoder
*encoder
)
924 drm_encoder_cleanup(encoder
);
927 static const struct drm_encoder_funcs qxl_enc_funcs
= {
928 .destroy
= qxl_enc_destroy
,
931 static int qxl_mode_create_hotplug_mode_update_property(struct qxl_device
*qdev
)
933 if (qdev
->hotplug_mode_update_property
)
936 qdev
->hotplug_mode_update_property
=
937 drm_property_create_range(qdev
->ddev
, DRM_MODE_PROP_IMMUTABLE
,
938 "hotplug_mode_update", 0, 1);
943 static int qdev_output_init(struct drm_device
*dev
, int num_output
)
945 struct qxl_device
*qdev
= dev
->dev_private
;
946 struct qxl_output
*qxl_output
;
947 struct drm_connector
*connector
;
948 struct drm_encoder
*encoder
;
950 qxl_output
= kzalloc(sizeof(struct qxl_output
), GFP_KERNEL
);
954 qxl_output
->index
= num_output
;
956 connector
= &qxl_output
->base
;
957 encoder
= &qxl_output
->enc
;
958 drm_connector_init(dev
, &qxl_output
->base
,
959 &qxl_connector_funcs
, DRM_MODE_CONNECTOR_VIRTUAL
);
961 drm_encoder_init(dev
, &qxl_output
->enc
, &qxl_enc_funcs
,
962 DRM_MODE_ENCODER_VIRTUAL
, NULL
);
964 /* we get HPD via client monitors config */
965 connector
->polled
= DRM_CONNECTOR_POLL_HPD
;
966 encoder
->possible_crtcs
= 1 << num_output
;
967 drm_mode_connector_attach_encoder(&qxl_output
->base
,
969 drm_encoder_helper_add(encoder
, &qxl_enc_helper_funcs
);
970 drm_connector_helper_add(connector
, &qxl_connector_helper_funcs
);
972 drm_object_attach_property(&connector
->base
,
973 qdev
->hotplug_mode_update_property
, 0);
974 drm_object_attach_property(&connector
->base
,
975 dev
->mode_config
.suggested_x_property
, 0);
976 drm_object_attach_property(&connector
->base
,
977 dev
->mode_config
.suggested_y_property
, 0);
978 drm_connector_register(connector
);
982 static struct drm_framebuffer
*
983 qxl_user_framebuffer_create(struct drm_device
*dev
,
984 struct drm_file
*file_priv
,
985 const struct drm_mode_fb_cmd2
*mode_cmd
)
987 struct drm_gem_object
*obj
;
988 struct qxl_framebuffer
*qxl_fb
;
991 obj
= drm_gem_object_lookup(dev
, file_priv
, mode_cmd
->handles
[0]);
993 qxl_fb
= kzalloc(sizeof(*qxl_fb
), GFP_KERNEL
);
997 ret
= qxl_framebuffer_init(dev
, qxl_fb
, mode_cmd
, obj
);
1000 drm_gem_object_unreference_unlocked(obj
);
1004 return &qxl_fb
->base
;
1007 static const struct drm_mode_config_funcs qxl_mode_funcs
= {
1008 .fb_create
= qxl_user_framebuffer_create
,
1011 int qxl_create_monitors_object(struct qxl_device
*qdev
)
1014 struct drm_gem_object
*gobj
;
1015 int max_allowed
= qxl_num_crtc
;
1016 int monitors_config_size
= sizeof(struct qxl_monitors_config
) +
1017 max_allowed
* sizeof(struct qxl_head
);
1019 ret
= qxl_gem_object_create(qdev
, monitors_config_size
, 0,
1020 QXL_GEM_DOMAIN_VRAM
,
1021 false, false, NULL
, &gobj
);
1023 DRM_ERROR("%s: failed to create gem ret=%d\n", __func__
, ret
);
1026 qdev
->monitors_config_bo
= gem_to_qxl_bo(gobj
);
1028 ret
= qxl_bo_reserve(qdev
->monitors_config_bo
, false);
1032 ret
= qxl_bo_pin(qdev
->monitors_config_bo
, QXL_GEM_DOMAIN_VRAM
, NULL
);
1034 qxl_bo_unreserve(qdev
->monitors_config_bo
);
1038 qxl_bo_unreserve(qdev
->monitors_config_bo
);
1040 qxl_bo_kmap(qdev
->monitors_config_bo
, NULL
);
1042 qdev
->monitors_config
= qdev
->monitors_config_bo
->kptr
;
1043 qdev
->ram_header
->monitors_config
=
1044 qxl_bo_physical_address(qdev
, qdev
->monitors_config_bo
, 0);
1046 memset(qdev
->monitors_config
, 0, monitors_config_size
);
1047 qdev
->monitors_config
->max_allowed
= max_allowed
;
1051 int qxl_destroy_monitors_object(struct qxl_device
*qdev
)
1055 qdev
->monitors_config
= NULL
;
1056 qdev
->ram_header
->monitors_config
= 0;
1058 qxl_bo_kunmap(qdev
->monitors_config_bo
);
1059 ret
= qxl_bo_reserve(qdev
->monitors_config_bo
, false);
1063 qxl_bo_unpin(qdev
->monitors_config_bo
);
1064 qxl_bo_unreserve(qdev
->monitors_config_bo
);
1066 qxl_bo_unref(&qdev
->monitors_config_bo
);
1070 int qxl_modeset_init(struct qxl_device
*qdev
)
1075 drm_mode_config_init(qdev
->ddev
);
1077 ret
= qxl_create_monitors_object(qdev
);
1081 qdev
->ddev
->mode_config
.funcs
= (void *)&qxl_mode_funcs
;
1083 /* modes will be validated against the framebuffer size */
1084 qdev
->ddev
->mode_config
.min_width
= 320;
1085 qdev
->ddev
->mode_config
.min_height
= 200;
1086 qdev
->ddev
->mode_config
.max_width
= 8192;
1087 qdev
->ddev
->mode_config
.max_height
= 8192;
1089 qdev
->ddev
->mode_config
.fb_base
= qdev
->vram_base
;
1091 drm_mode_create_suggested_offset_properties(qdev
->ddev
);
1092 qxl_mode_create_hotplug_mode_update_property(qdev
);
1094 for (i
= 0 ; i
< qxl_num_crtc
; ++i
) {
1095 qdev_crtc_init(qdev
->ddev
, i
);
1096 qdev_output_init(qdev
->ddev
, i
);
1099 qdev
->mode_info
.mode_config_initialized
= true;
1101 /* primary surface must be created by this point, to allow
1102 * issuing command queue commands and having them read by
1104 qxl_fbdev_init(qdev
);
1108 void qxl_modeset_fini(struct qxl_device
*qdev
)
1110 qxl_fbdev_fini(qdev
);
1112 qxl_destroy_monitors_object(qdev
);
1113 if (qdev
->mode_info
.mode_config_initialized
) {
1114 drm_mode_config_cleanup(qdev
->ddev
);
1115 qdev
->mode_info
.mode_config_initialized
= false;