xref: /openbmc/linux/drivers/gpu/drm/qxl/qxl_display.c (revision a2cce7a9)
1 /*
2  * Copyright 2013 Red Hat Inc.
3  *
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:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *
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.
21  *
22  * Authors: Dave Airlie
23  *          Alon Levy
24  */
25 
26 
27 #include <linux/crc32.h>
28 
29 #include "qxl_drv.h"
30 #include "qxl_object.h"
31 #include "drm_crtc_helper.h"
32 #include <drm/drm_plane_helper.h>
33 
34 static bool qxl_head_enabled(struct qxl_head *head)
35 {
36 	return head->width && head->height;
37 }
38 
39 void qxl_alloc_client_monitors_config(struct qxl_device *qdev, unsigned count)
40 {
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;
45 	}
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) {
51 			qxl_io_log(qdev,
52 				   "%s: allocation failure for %u heads\n",
53 				   __func__, count);
54 			return;
55 		}
56 	}
57 	qdev->client_monitors_config->count = count;
58 }
59 
60 static int qxl_display_copy_rom_client_monitors_config(struct qxl_device *qdev)
61 {
62 	int i;
63 	int num_monitors;
64 	uint32_t crc;
65 
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);
73 		return 1;
74 	}
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;
79 	} else {
80 		num_monitors = qdev->rom->client_monitors_config.count;
81 	}
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;
96 		client_head->id = i;
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);
100 	}
101 	return 0;
102 }
103 
104 static void qxl_update_offset_props(struct qxl_device *qdev)
105 {
106 	struct drm_device *dev = qdev->ddev;
107 	struct drm_connector *connector;
108 	struct qxl_output *output;
109 	struct qxl_head *head;
110 
111 	list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
112 		output = drm_connector_to_qxl_output(connector);
113 
114 		head = &qdev->client_monitors_config->heads[output->index];
115 
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);
120 	}
121 }
122 
123 void qxl_display_read_client_monitors_config(struct qxl_device *qdev)
124 {
125 
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,"
129 				 " retrying\n");
130 	}
131 
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);
139 	}
140 }
141 
142 static int qxl_add_monitors_config_modes(struct drm_connector *connector,
143                                          unsigned *pwidth,
144                                          unsigned *pheight)
145 {
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;
152 
153 	if (!qdev->client_monitors_config)
154 		return 0;
155 	head = &qdev->client_monitors_config->heads[h];
156 
157 	mode = drm_cvt_mode(dev, head->width, head->height, 60, false, false,
158 			    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;
166 	return 1;
167 }
168 
169 static struct mode_size {
170 	int w;
171 	int h;
172 } common_modes[] = {
173 	{ 640,  480},
174 	{ 720,  480},
175 	{ 800,  600},
176 	{ 848,  480},
177 	{1024,  768},
178 	{1152,  768},
179 	{1280,  720},
180 	{1280,  800},
181 	{1280,  854},
182 	{1280,  960},
183 	{1280, 1024},
184 	{1440,  900},
185 	{1400, 1050},
186 	{1680, 1050},
187 	{1600, 1200},
188 	{1920, 1080},
189 	{1920, 1200}
190 };
191 
192 static int qxl_add_common_modes(struct drm_connector *connector,
193                                 unsigned pwidth,
194                                 unsigned pheight)
195 {
196 	struct drm_device *dev = connector->dev;
197 	struct drm_display_mode *mode = NULL;
198 	int i;
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);
205 	}
206 	return i - 1;
207 }
208 
209 static void qxl_crtc_destroy(struct drm_crtc *crtc)
210 {
211 	struct qxl_crtc *qxl_crtc = to_qxl_crtc(crtc);
212 
213 	drm_crtc_cleanup(crtc);
214 	kfree(qxl_crtc);
215 }
216 
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)
221 {
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);
229 	unsigned long flags;
230 	struct drm_clip_rect norect = {
231 	    .x1 = 0,
232 	    .y1 = 0,
233 	    .x2 = fb->width,
234 	    .y2 = fb->height
235 	};
236 	int inc = 1;
237 	int one_clip_rect = 1;
238 	int ret = 0;
239 
240 	crtc->primary->fb = fb;
241 	bo_old->is_primary = false;
242 	bo->is_primary = true;
243 
244 	ret = qxl_bo_reserve(bo, false);
245 	if (ret)
246 		return ret;
247 
248 	qxl_draw_dirty_fb(qdev, qfb_src, bo, 0, 0,
249 			  &norect, one_clip_rect, inc);
250 
251 	drm_vblank_get(dev, qcrtc->index);
252 
253 	if (event) {
254 		spin_lock_irqsave(&dev->event_lock, flags);
255 		drm_send_vblank_event(dev, qcrtc->index, event);
256 		spin_unlock_irqrestore(&dev->event_lock, flags);
257 	}
258 	drm_vblank_put(dev, qcrtc->index);
259 
260 	qxl_bo_unreserve(bo);
261 
262 	return 0;
263 }
264 
265 static int
266 qxl_hide_cursor(struct qxl_device *qdev)
267 {
268 	struct qxl_release *release;
269 	struct qxl_cursor_cmd *cmd;
270 	int ret;
271 
272 	ret = qxl_alloc_release_reserved(qdev, sizeof(*cmd), QXL_RELEASE_CURSOR_CMD,
273 					 &release, NULL);
274 	if (ret)
275 		return ret;
276 
277 	ret = qxl_release_reserve_list(release, true);
278 	if (ret) {
279 		qxl_release_free(qdev, release);
280 		return ret;
281 	}
282 
283 	cmd = (struct qxl_cursor_cmd *)qxl_release_map(qdev, release);
284 	cmd->type = QXL_CURSOR_HIDE;
285 	qxl_release_unmap(qdev, release, &cmd->release_info);
286 
287 	qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
288 	qxl_release_fence_buffer_objects(release);
289 	return 0;
290 }
291 
292 static int qxl_crtc_cursor_set2(struct drm_crtc *crtc,
293 				struct drm_file *file_priv,
294 				uint32_t handle,
295 				uint32_t width,
296 				uint32_t height, int32_t hot_x, int32_t hot_y)
297 {
298 	struct drm_device *dev = crtc->dev;
299 	struct qxl_device *qdev = dev->dev_private;
300 	struct qxl_crtc *qcrtc = to_qxl_crtc(crtc);
301 	struct drm_gem_object *obj;
302 	struct qxl_cursor *cursor;
303 	struct qxl_cursor_cmd *cmd;
304 	struct qxl_bo *cursor_bo, *user_bo;
305 	struct qxl_release *release;
306 	void *user_ptr;
307 
308 	int size = 64*64*4;
309 	int ret = 0;
310 	if (!handle)
311 		return qxl_hide_cursor(qdev);
312 
313 	obj = drm_gem_object_lookup(crtc->dev, file_priv, handle);
314 	if (!obj) {
315 		DRM_ERROR("cannot find cursor object\n");
316 		return -ENOENT;
317 	}
318 
319 	user_bo = gem_to_qxl_bo(obj);
320 
321 	ret = qxl_bo_reserve(user_bo, false);
322 	if (ret)
323 		goto out_unref;
324 
325 	ret = qxl_bo_pin(user_bo, QXL_GEM_DOMAIN_CPU, NULL);
326 	qxl_bo_unreserve(user_bo);
327 	if (ret)
328 		goto out_unref;
329 
330 	ret = qxl_bo_kmap(user_bo, &user_ptr);
331 	if (ret)
332 		goto out_unpin;
333 
334 	ret = qxl_alloc_release_reserved(qdev, sizeof(*cmd),
335 					 QXL_RELEASE_CURSOR_CMD,
336 					 &release, NULL);
337 	if (ret)
338 		goto out_kunmap;
339 
340 	ret = qxl_alloc_bo_reserved(qdev, release, sizeof(struct qxl_cursor) + size,
341 			   &cursor_bo);
342 	if (ret)
343 		goto out_free_release;
344 
345 	ret = qxl_release_reserve_list(release, false);
346 	if (ret)
347 		goto out_free_bo;
348 
349 	ret = qxl_bo_kmap(cursor_bo, (void **)&cursor);
350 	if (ret)
351 		goto out_backoff;
352 
353 	cursor->header.unique = 0;
354 	cursor->header.type = SPICE_CURSOR_TYPE_ALPHA;
355 	cursor->header.width = 64;
356 	cursor->header.height = 64;
357 	cursor->header.hot_spot_x = hot_x;
358 	cursor->header.hot_spot_y = hot_y;
359 	cursor->data_size = size;
360 	cursor->chunk.next_chunk = 0;
361 	cursor->chunk.prev_chunk = 0;
362 	cursor->chunk.data_size = size;
363 
364 	memcpy(cursor->chunk.data, user_ptr, size);
365 
366 	qxl_bo_kunmap(cursor_bo);
367 
368 	qxl_bo_kunmap(user_bo);
369 
370 	cmd = (struct qxl_cursor_cmd *)qxl_release_map(qdev, release);
371 	cmd->type = QXL_CURSOR_SET;
372 	cmd->u.set.position.x = qcrtc->cur_x;
373 	cmd->u.set.position.y = qcrtc->cur_y;
374 
375 	cmd->u.set.shape = qxl_bo_physical_address(qdev, cursor_bo, 0);
376 
377 	cmd->u.set.visible = 1;
378 	qxl_release_unmap(qdev, release, &cmd->release_info);
379 
380 	qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
381 	qxl_release_fence_buffer_objects(release);
382 
383 	/* finish with the userspace bo */
384 	ret = qxl_bo_reserve(user_bo, false);
385 	if (!ret) {
386 		qxl_bo_unpin(user_bo);
387 		qxl_bo_unreserve(user_bo);
388 	}
389 	drm_gem_object_unreference_unlocked(obj);
390 
391 	qxl_bo_unref(&cursor_bo);
392 
393 	return ret;
394 
395 out_backoff:
396 	qxl_release_backoff_reserve_list(release);
397 out_free_bo:
398 	qxl_bo_unref(&cursor_bo);
399 out_free_release:
400 	qxl_release_free(qdev, release);
401 out_kunmap:
402 	qxl_bo_kunmap(user_bo);
403 out_unpin:
404 	qxl_bo_unpin(user_bo);
405 out_unref:
406 	drm_gem_object_unreference_unlocked(obj);
407 	return ret;
408 }
409 
410 static int qxl_crtc_cursor_move(struct drm_crtc *crtc,
411 				int x, int y)
412 {
413 	struct drm_device *dev = crtc->dev;
414 	struct qxl_device *qdev = dev->dev_private;
415 	struct qxl_crtc *qcrtc = to_qxl_crtc(crtc);
416 	struct qxl_release *release;
417 	struct qxl_cursor_cmd *cmd;
418 	int ret;
419 
420 	ret = qxl_alloc_release_reserved(qdev, sizeof(*cmd), QXL_RELEASE_CURSOR_CMD,
421 				   &release, NULL);
422 	if (ret)
423 		return ret;
424 
425 	ret = qxl_release_reserve_list(release, true);
426 	if (ret) {
427 		qxl_release_free(qdev, release);
428 		return ret;
429 	}
430 
431 	qcrtc->cur_x = x;
432 	qcrtc->cur_y = y;
433 
434 	cmd = (struct qxl_cursor_cmd *)qxl_release_map(qdev, release);
435 	cmd->type = QXL_CURSOR_MOVE;
436 	cmd->u.position.x = qcrtc->cur_x;
437 	cmd->u.position.y = qcrtc->cur_y;
438 	qxl_release_unmap(qdev, release, &cmd->release_info);
439 
440 	qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
441 	qxl_release_fence_buffer_objects(release);
442 
443 	return 0;
444 }
445 
446 
447 static const struct drm_crtc_funcs qxl_crtc_funcs = {
448 	.cursor_set2 = qxl_crtc_cursor_set2,
449 	.cursor_move = qxl_crtc_cursor_move,
450 	.set_config = drm_crtc_helper_set_config,
451 	.destroy = qxl_crtc_destroy,
452 	.page_flip = qxl_crtc_page_flip,
453 };
454 
455 static void qxl_user_framebuffer_destroy(struct drm_framebuffer *fb)
456 {
457 	struct qxl_framebuffer *qxl_fb = to_qxl_framebuffer(fb);
458 
459 	if (qxl_fb->obj)
460 		drm_gem_object_unreference_unlocked(qxl_fb->obj);
461 	drm_framebuffer_cleanup(fb);
462 	kfree(qxl_fb);
463 }
464 
465 static int qxl_framebuffer_surface_dirty(struct drm_framebuffer *fb,
466 					 struct drm_file *file_priv,
467 					 unsigned flags, unsigned color,
468 					 struct drm_clip_rect *clips,
469 					 unsigned num_clips)
470 {
471 	/* TODO: vmwgfx where this was cribbed from had locking. Why? */
472 	struct qxl_framebuffer *qxl_fb = to_qxl_framebuffer(fb);
473 	struct qxl_device *qdev = qxl_fb->base.dev->dev_private;
474 	struct drm_clip_rect norect;
475 	struct qxl_bo *qobj;
476 	int inc = 1;
477 
478 	drm_modeset_lock_all(fb->dev);
479 
480 	qobj = gem_to_qxl_bo(qxl_fb->obj);
481 	/* if we aren't primary surface ignore this */
482 	if (!qobj->is_primary) {
483 		drm_modeset_unlock_all(fb->dev);
484 		return 0;
485 	}
486 
487 	if (!num_clips) {
488 		num_clips = 1;
489 		clips = &norect;
490 		norect.x1 = norect.y1 = 0;
491 		norect.x2 = fb->width;
492 		norect.y2 = fb->height;
493 	} else if (flags & DRM_MODE_FB_DIRTY_ANNOTATE_COPY) {
494 		num_clips /= 2;
495 		inc = 2; /* skip source rects */
496 	}
497 
498 	qxl_draw_dirty_fb(qdev, qxl_fb, qobj, flags, color,
499 			  clips, num_clips, inc);
500 
501 	drm_modeset_unlock_all(fb->dev);
502 
503 	return 0;
504 }
505 
506 static const struct drm_framebuffer_funcs qxl_fb_funcs = {
507 	.destroy = qxl_user_framebuffer_destroy,
508 	.dirty = qxl_framebuffer_surface_dirty,
509 /*	TODO?
510  *	.create_handle = qxl_user_framebuffer_create_handle, */
511 };
512 
513 int
514 qxl_framebuffer_init(struct drm_device *dev,
515 		     struct qxl_framebuffer *qfb,
516 		     struct drm_mode_fb_cmd2 *mode_cmd,
517 		     struct drm_gem_object *obj)
518 {
519 	int ret;
520 
521 	qfb->obj = obj;
522 	ret = drm_framebuffer_init(dev, &qfb->base, &qxl_fb_funcs);
523 	if (ret) {
524 		qfb->obj = NULL;
525 		return ret;
526 	}
527 	drm_helper_mode_fill_fb_struct(&qfb->base, mode_cmd);
528 	return 0;
529 }
530 
531 static void qxl_crtc_dpms(struct drm_crtc *crtc, int mode)
532 {
533 }
534 
535 static bool qxl_crtc_mode_fixup(struct drm_crtc *crtc,
536 				  const struct drm_display_mode *mode,
537 				  struct drm_display_mode *adjusted_mode)
538 {
539 	struct drm_device *dev = crtc->dev;
540 	struct qxl_device *qdev = dev->dev_private;
541 
542 	qxl_io_log(qdev, "%s: (%d,%d) => (%d,%d)\n",
543 		   __func__,
544 		   mode->hdisplay, mode->vdisplay,
545 		   adjusted_mode->hdisplay,
546 		   adjusted_mode->vdisplay);
547 	return true;
548 }
549 
550 void
551 qxl_send_monitors_config(struct qxl_device *qdev)
552 {
553 	int i;
554 
555 	BUG_ON(!qdev->ram_header->monitors_config);
556 
557 	if (qdev->monitors_config->count == 0) {
558 		qxl_io_log(qdev, "%s: 0 monitors??\n", __func__);
559 		return;
560 	}
561 	for (i = 0 ; i < qdev->monitors_config->count ; ++i) {
562 		struct qxl_head *head = &qdev->monitors_config->heads[i];
563 
564 		if (head->y > 8192 || head->x > 8192 ||
565 		    head->width > 8192 || head->height > 8192) {
566 			DRM_ERROR("head %d wrong: %dx%d+%d+%d\n",
567 				  i, head->width, head->height,
568 				  head->x, head->y);
569 			return;
570 		}
571 	}
572 	qxl_io_monitors_config(qdev);
573 }
574 
575 static void qxl_monitors_config_set(struct qxl_device *qdev,
576 				    int index,
577 				    unsigned x, unsigned y,
578 				    unsigned width, unsigned height,
579 				    unsigned surf_id)
580 {
581 	DRM_DEBUG_KMS("%d:%dx%d+%d+%d\n", index, width, height, x, y);
582 	qdev->monitors_config->heads[index].x = x;
583 	qdev->monitors_config->heads[index].y = y;
584 	qdev->monitors_config->heads[index].width = width;
585 	qdev->monitors_config->heads[index].height = height;
586 	qdev->monitors_config->heads[index].surface_id = surf_id;
587 
588 }
589 
590 static int qxl_crtc_mode_set(struct drm_crtc *crtc,
591 			       struct drm_display_mode *mode,
592 			       struct drm_display_mode *adjusted_mode,
593 			       int x, int y,
594 			       struct drm_framebuffer *old_fb)
595 {
596 	struct drm_device *dev = crtc->dev;
597 	struct qxl_device *qdev = dev->dev_private;
598 	struct qxl_framebuffer *qfb;
599 	struct qxl_bo *bo, *old_bo = NULL;
600 	struct qxl_crtc *qcrtc = to_qxl_crtc(crtc);
601 	bool recreate_primary = false;
602 	int ret;
603 	int surf_id;
604 	if (!crtc->primary->fb) {
605 		DRM_DEBUG_KMS("No FB bound\n");
606 		return 0;
607 	}
608 
609 	if (old_fb) {
610 		qfb = to_qxl_framebuffer(old_fb);
611 		old_bo = gem_to_qxl_bo(qfb->obj);
612 	}
613 	qfb = to_qxl_framebuffer(crtc->primary->fb);
614 	bo = gem_to_qxl_bo(qfb->obj);
615 	DRM_DEBUG("+%d+%d (%d,%d) => (%d,%d)\n",
616 		  x, y,
617 		  mode->hdisplay, mode->vdisplay,
618 		  adjusted_mode->hdisplay,
619 		  adjusted_mode->vdisplay);
620 
621 	if (bo->is_primary == false)
622 		recreate_primary = true;
623 
624 	if (bo->surf.stride * bo->surf.height > qdev->vram_size) {
625 		DRM_ERROR("Mode doesn't fit in vram size (vgamem)");
626 		return -EINVAL;
627         }
628 
629 	ret = qxl_bo_reserve(bo, false);
630 	if (ret != 0)
631 		return ret;
632 	ret = qxl_bo_pin(bo, bo->type, NULL);
633 	if (ret != 0) {
634 		qxl_bo_unreserve(bo);
635 		return -EINVAL;
636 	}
637 	qxl_bo_unreserve(bo);
638 	if (recreate_primary) {
639 		qxl_io_destroy_primary(qdev);
640 		qxl_io_log(qdev,
641 			   "recreate primary: %dx%d,%d,%d\n",
642 			   bo->surf.width, bo->surf.height,
643 			   bo->surf.stride, bo->surf.format);
644 		qxl_io_create_primary(qdev, 0, bo);
645 		bo->is_primary = true;
646 	}
647 
648 	if (bo->is_primary) {
649 		DRM_DEBUG_KMS("setting surface_id to 0 for primary surface %d on crtc %d\n", bo->surface_id, qcrtc->index);
650 		surf_id = 0;
651 	} else {
652 		surf_id = bo->surface_id;
653 	}
654 
655 	if (old_bo && old_bo != bo) {
656 		old_bo->is_primary = false;
657 		ret = qxl_bo_reserve(old_bo, false);
658 		qxl_bo_unpin(old_bo);
659 		qxl_bo_unreserve(old_bo);
660 	}
661 
662 	qxl_monitors_config_set(qdev, qcrtc->index, x, y,
663 				mode->hdisplay,
664 				mode->vdisplay, surf_id);
665 	return 0;
666 }
667 
668 static void qxl_crtc_prepare(struct drm_crtc *crtc)
669 {
670 	DRM_DEBUG("current: %dx%d+%d+%d (%d).\n",
671 		  crtc->mode.hdisplay, crtc->mode.vdisplay,
672 		  crtc->x, crtc->y, crtc->enabled);
673 }
674 
675 static void qxl_crtc_commit(struct drm_crtc *crtc)
676 {
677 	DRM_DEBUG("\n");
678 }
679 
680 static void qxl_crtc_disable(struct drm_crtc *crtc)
681 {
682 	struct qxl_crtc *qcrtc = to_qxl_crtc(crtc);
683 	struct drm_device *dev = crtc->dev;
684 	struct qxl_device *qdev = dev->dev_private;
685 	if (crtc->primary->fb) {
686 		struct qxl_framebuffer *qfb = to_qxl_framebuffer(crtc->primary->fb);
687 		struct qxl_bo *bo = gem_to_qxl_bo(qfb->obj);
688 		int ret;
689 		ret = qxl_bo_reserve(bo, false);
690 		qxl_bo_unpin(bo);
691 		qxl_bo_unreserve(bo);
692 		crtc->primary->fb = NULL;
693 	}
694 
695 	qxl_monitors_config_set(qdev, qcrtc->index, 0, 0, 0, 0, 0);
696 
697 	qxl_send_monitors_config(qdev);
698 }
699 
700 static const struct drm_crtc_helper_funcs qxl_crtc_helper_funcs = {
701 	.dpms = qxl_crtc_dpms,
702 	.disable = qxl_crtc_disable,
703 	.mode_fixup = qxl_crtc_mode_fixup,
704 	.mode_set = qxl_crtc_mode_set,
705 	.prepare = qxl_crtc_prepare,
706 	.commit = qxl_crtc_commit,
707 };
708 
709 static int qdev_crtc_init(struct drm_device *dev, int crtc_id)
710 {
711 	struct qxl_crtc *qxl_crtc;
712 
713 	qxl_crtc = kzalloc(sizeof(struct qxl_crtc), GFP_KERNEL);
714 	if (!qxl_crtc)
715 		return -ENOMEM;
716 
717 	drm_crtc_init(dev, &qxl_crtc->base, &qxl_crtc_funcs);
718 	qxl_crtc->index = crtc_id;
719 	drm_mode_crtc_set_gamma_size(&qxl_crtc->base, 256);
720 	drm_crtc_helper_add(&qxl_crtc->base, &qxl_crtc_helper_funcs);
721 	return 0;
722 }
723 
724 static void qxl_enc_dpms(struct drm_encoder *encoder, int mode)
725 {
726 	DRM_DEBUG("\n");
727 }
728 
729 static bool qxl_enc_mode_fixup(struct drm_encoder *encoder,
730 			       const struct drm_display_mode *mode,
731 			       struct drm_display_mode *adjusted_mode)
732 {
733 	DRM_DEBUG("\n");
734 	return true;
735 }
736 
737 static void qxl_enc_prepare(struct drm_encoder *encoder)
738 {
739 	DRM_DEBUG("\n");
740 }
741 
742 static void qxl_write_monitors_config_for_encoder(struct qxl_device *qdev,
743 		struct drm_encoder *encoder)
744 {
745 	int i;
746 	struct qxl_output *output = drm_encoder_to_qxl_output(encoder);
747 	struct qxl_head *head;
748 	struct drm_display_mode *mode;
749 
750 	BUG_ON(!encoder);
751 	/* TODO: ugly, do better */
752 	i = output->index;
753 	if (!qdev->monitors_config ||
754 	    qdev->monitors_config->max_allowed <= i) {
755 		DRM_ERROR(
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);
760 		return;
761 	}
762 	if (!encoder->crtc) {
763 		DRM_ERROR("missing crtc on encoder %p\n", encoder);
764 		return;
765 	}
766 	if (i != 0)
767 		DRM_DEBUG("missing for multiple monitors: no head holes\n");
768 	head = &qdev->monitors_config->heads[i];
769 	head->id = 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;
778 	} else {
779 		head->width = 0;
780 		head->height = 0;
781 		head->x = 0;
782 		head->y = 0;
783 	}
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);
786 	head->flags = 0;
787 	/* TODO - somewhere else to call this for multiple monitors
788 	 * (config_commit?) */
789 	qxl_send_monitors_config(qdev);
790 }
791 
792 static void qxl_enc_commit(struct drm_encoder *encoder)
793 {
794 	struct qxl_device *qdev = encoder->dev->dev_private;
795 
796 	qxl_write_monitors_config_for_encoder(qdev, encoder);
797 	DRM_DEBUG("\n");
798 }
799 
800 static void qxl_enc_mode_set(struct drm_encoder *encoder,
801 				struct drm_display_mode *mode,
802 				struct drm_display_mode *adjusted_mode)
803 {
804 	DRM_DEBUG("\n");
805 }
806 
807 static int qxl_conn_get_modes(struct drm_connector *connector)
808 {
809 	int ret = 0;
810 	struct qxl_device *qdev = connector->dev->dev_private;
811 	unsigned pwidth = 1024;
812 	unsigned pheight = 768;
813 
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);
819 		if (ret < 0)
820 			return ret;
821 	}
822 	ret += qxl_add_common_modes(connector, pwidth, pheight);
823 	return ret;
824 }
825 
826 static int qxl_conn_mode_valid(struct drm_connector *connector,
827 			       struct drm_display_mode *mode)
828 {
829 	struct drm_device *ddev = connector->dev;
830 	struct qxl_device *qdev = ddev->dev_private;
831 	int i;
832 
833 	/* TODO: is this called for user defined modes? (xrandr --add-mode)
834 	 * TODO: check that the mode fits in the framebuffer */
835 
836 	if(qdev->monitors_config_width == mode->hdisplay &&
837 	   qdev->monitors_config_height == mode->vdisplay)
838 		return MODE_OK;
839 
840 	for (i = 0; i < ARRAY_SIZE(common_modes); i++) {
841 		if (common_modes[i].w == mode->hdisplay && common_modes[i].h == mode->vdisplay)
842 			return MODE_OK;
843 	}
844 	return MODE_BAD;
845 }
846 
847 static struct drm_encoder *qxl_best_encoder(struct drm_connector *connector)
848 {
849 	struct qxl_output *qxl_output =
850 		drm_connector_to_qxl_output(connector);
851 
852 	DRM_DEBUG("\n");
853 	return &qxl_output->enc;
854 }
855 
856 
857 static const struct drm_encoder_helper_funcs qxl_enc_helper_funcs = {
858 	.dpms = qxl_enc_dpms,
859 	.mode_fixup = qxl_enc_mode_fixup,
860 	.prepare = qxl_enc_prepare,
861 	.mode_set = qxl_enc_mode_set,
862 	.commit = qxl_enc_commit,
863 };
864 
865 static const struct drm_connector_helper_funcs qxl_connector_helper_funcs = {
866 	.get_modes = qxl_conn_get_modes,
867 	.mode_valid = qxl_conn_mode_valid,
868 	.best_encoder = qxl_best_encoder,
869 };
870 
871 static void qxl_conn_save(struct drm_connector *connector)
872 {
873 	DRM_DEBUG("\n");
874 }
875 
876 static void qxl_conn_restore(struct drm_connector *connector)
877 {
878 	DRM_DEBUG("\n");
879 }
880 
881 static enum drm_connector_status qxl_conn_detect(
882 			struct drm_connector *connector,
883 			bool force)
884 {
885 	struct qxl_output *output =
886 		drm_connector_to_qxl_output(connector);
887 	struct drm_device *ddev = connector->dev;
888 	struct qxl_device *qdev = ddev->dev_private;
889 	bool connected = false;
890 
891 	/* The first monitor is always connected */
892 	if (!qdev->client_monitors_config) {
893 		if (output->index == 0)
894 			connected = true;
895 	} else
896 		connected = qdev->client_monitors_config->count > output->index &&
897 		     qxl_head_enabled(&qdev->client_monitors_config->heads[output->index]);
898 
899 	DRM_DEBUG("#%d connected: %d\n", output->index, connected);
900 	if (!connected)
901 		qxl_monitors_config_set(qdev, output->index, 0, 0, 0, 0, 0);
902 
903 	return connected ? connector_status_connected
904 			 : connector_status_disconnected;
905 }
906 
907 static int qxl_conn_set_property(struct drm_connector *connector,
908 				   struct drm_property *property,
909 				   uint64_t value)
910 {
911 	DRM_DEBUG("\n");
912 	return 0;
913 }
914 
915 static void qxl_conn_destroy(struct drm_connector *connector)
916 {
917 	struct qxl_output *qxl_output =
918 		drm_connector_to_qxl_output(connector);
919 
920 	drm_connector_unregister(connector);
921 	drm_connector_cleanup(connector);
922 	kfree(qxl_output);
923 }
924 
925 static const struct drm_connector_funcs qxl_connector_funcs = {
926 	.dpms = drm_helper_connector_dpms,
927 	.save = qxl_conn_save,
928 	.restore = qxl_conn_restore,
929 	.detect = qxl_conn_detect,
930 	.fill_modes = drm_helper_probe_single_connector_modes_nomerge,
931 	.set_property = qxl_conn_set_property,
932 	.destroy = qxl_conn_destroy,
933 };
934 
935 static void qxl_enc_destroy(struct drm_encoder *encoder)
936 {
937 	drm_encoder_cleanup(encoder);
938 }
939 
940 static const struct drm_encoder_funcs qxl_enc_funcs = {
941 	.destroy = qxl_enc_destroy,
942 };
943 
944 static int qxl_mode_create_hotplug_mode_update_property(struct qxl_device *qdev)
945 {
946 	if (qdev->hotplug_mode_update_property)
947 		return 0;
948 
949 	qdev->hotplug_mode_update_property =
950 		drm_property_create_range(qdev->ddev, DRM_MODE_PROP_IMMUTABLE,
951 					  "hotplug_mode_update", 0, 1);
952 
953 	return 0;
954 }
955 
956 static int qdev_output_init(struct drm_device *dev, int num_output)
957 {
958 	struct qxl_device *qdev = dev->dev_private;
959 	struct qxl_output *qxl_output;
960 	struct drm_connector *connector;
961 	struct drm_encoder *encoder;
962 
963 	qxl_output = kzalloc(sizeof(struct qxl_output), GFP_KERNEL);
964 	if (!qxl_output)
965 		return -ENOMEM;
966 
967 	qxl_output->index = num_output;
968 
969 	connector = &qxl_output->base;
970 	encoder = &qxl_output->enc;
971 	drm_connector_init(dev, &qxl_output->base,
972 			   &qxl_connector_funcs, DRM_MODE_CONNECTOR_VIRTUAL);
973 
974 	drm_encoder_init(dev, &qxl_output->enc, &qxl_enc_funcs,
975 			 DRM_MODE_ENCODER_VIRTUAL);
976 
977 	/* we get HPD via client monitors config */
978 	connector->polled = DRM_CONNECTOR_POLL_HPD;
979 	encoder->possible_crtcs = 1 << num_output;
980 	drm_mode_connector_attach_encoder(&qxl_output->base,
981 					  &qxl_output->enc);
982 	drm_encoder_helper_add(encoder, &qxl_enc_helper_funcs);
983 	drm_connector_helper_add(connector, &qxl_connector_helper_funcs);
984 
985 	drm_object_attach_property(&connector->base,
986 				   qdev->hotplug_mode_update_property, 0);
987 	drm_object_attach_property(&connector->base,
988 				   dev->mode_config.suggested_x_property, 0);
989 	drm_object_attach_property(&connector->base,
990 				   dev->mode_config.suggested_y_property, 0);
991 	drm_connector_register(connector);
992 	return 0;
993 }
994 
995 static struct drm_framebuffer *
996 qxl_user_framebuffer_create(struct drm_device *dev,
997 			    struct drm_file *file_priv,
998 			    struct drm_mode_fb_cmd2 *mode_cmd)
999 {
1000 	struct drm_gem_object *obj;
1001 	struct qxl_framebuffer *qxl_fb;
1002 	int ret;
1003 
1004 	obj = drm_gem_object_lookup(dev, file_priv, mode_cmd->handles[0]);
1005 
1006 	qxl_fb = kzalloc(sizeof(*qxl_fb), GFP_KERNEL);
1007 	if (qxl_fb == NULL)
1008 		return NULL;
1009 
1010 	ret = qxl_framebuffer_init(dev, qxl_fb, mode_cmd, obj);
1011 	if (ret) {
1012 		kfree(qxl_fb);
1013 		drm_gem_object_unreference_unlocked(obj);
1014 		return NULL;
1015 	}
1016 
1017 	return &qxl_fb->base;
1018 }
1019 
1020 static const struct drm_mode_config_funcs qxl_mode_funcs = {
1021 	.fb_create = qxl_user_framebuffer_create,
1022 };
1023 
1024 int qxl_create_monitors_object(struct qxl_device *qdev)
1025 {
1026 	int ret;
1027 	struct drm_gem_object *gobj;
1028 	int max_allowed = qxl_num_crtc;
1029 	int monitors_config_size = sizeof(struct qxl_monitors_config) +
1030 		max_allowed * sizeof(struct qxl_head);
1031 
1032 	ret = qxl_gem_object_create(qdev, monitors_config_size, 0,
1033 				    QXL_GEM_DOMAIN_VRAM,
1034 				    false, false, NULL, &gobj);
1035 	if (ret) {
1036 		DRM_ERROR("%s: failed to create gem ret=%d\n", __func__, ret);
1037 		return -ENOMEM;
1038 	}
1039 	qdev->monitors_config_bo = gem_to_qxl_bo(gobj);
1040 
1041 	ret = qxl_bo_reserve(qdev->monitors_config_bo, false);
1042 	if (ret)
1043 		return ret;
1044 
1045 	ret = qxl_bo_pin(qdev->monitors_config_bo, QXL_GEM_DOMAIN_VRAM, NULL);
1046 	if (ret) {
1047 		qxl_bo_unreserve(qdev->monitors_config_bo);
1048 		return ret;
1049 	}
1050 
1051 	qxl_bo_unreserve(qdev->monitors_config_bo);
1052 
1053 	qxl_bo_kmap(qdev->monitors_config_bo, NULL);
1054 
1055 	qdev->monitors_config = qdev->monitors_config_bo->kptr;
1056 	qdev->ram_header->monitors_config =
1057 		qxl_bo_physical_address(qdev, qdev->monitors_config_bo, 0);
1058 
1059 	memset(qdev->monitors_config, 0, monitors_config_size);
1060 	qdev->monitors_config->max_allowed = max_allowed;
1061 	return 0;
1062 }
1063 
1064 int qxl_destroy_monitors_object(struct qxl_device *qdev)
1065 {
1066 	int ret;
1067 
1068 	qdev->monitors_config = NULL;
1069 	qdev->ram_header->monitors_config = 0;
1070 
1071 	qxl_bo_kunmap(qdev->monitors_config_bo);
1072 	ret = qxl_bo_reserve(qdev->monitors_config_bo, false);
1073 	if (ret)
1074 		return ret;
1075 
1076 	qxl_bo_unpin(qdev->monitors_config_bo);
1077 	qxl_bo_unreserve(qdev->monitors_config_bo);
1078 
1079 	qxl_bo_unref(&qdev->monitors_config_bo);
1080 	return 0;
1081 }
1082 
1083 int qxl_modeset_init(struct qxl_device *qdev)
1084 {
1085 	int i;
1086 	int ret;
1087 
1088 	drm_mode_config_init(qdev->ddev);
1089 
1090 	ret = qxl_create_monitors_object(qdev);
1091 	if (ret)
1092 		return ret;
1093 
1094 	qdev->ddev->mode_config.funcs = (void *)&qxl_mode_funcs;
1095 
1096 	/* modes will be validated against the framebuffer size */
1097 	qdev->ddev->mode_config.min_width = 320;
1098 	qdev->ddev->mode_config.min_height = 200;
1099 	qdev->ddev->mode_config.max_width = 8192;
1100 	qdev->ddev->mode_config.max_height = 8192;
1101 
1102 	qdev->ddev->mode_config.fb_base = qdev->vram_base;
1103 
1104 	drm_mode_create_suggested_offset_properties(qdev->ddev);
1105 	qxl_mode_create_hotplug_mode_update_property(qdev);
1106 
1107 	for (i = 0 ; i < qxl_num_crtc; ++i) {
1108 		qdev_crtc_init(qdev->ddev, i);
1109 		qdev_output_init(qdev->ddev, i);
1110 	}
1111 
1112 	qdev->mode_info.mode_config_initialized = true;
1113 
1114 	/* primary surface must be created by this point, to allow
1115 	 * issuing command queue commands and having them read by
1116 	 * spice server. */
1117 	qxl_fbdev_init(qdev);
1118 	return 0;
1119 }
1120 
1121 void qxl_modeset_fini(struct qxl_device *qdev)
1122 {
1123 	qxl_fbdev_fini(qdev);
1124 
1125 	qxl_destroy_monitors_object(qdev);
1126 	if (qdev->mode_info.mode_config_initialized) {
1127 		drm_mode_config_cleanup(qdev->ddev);
1128 		qdev->mode_info.mode_config_initialized = false;
1129 	}
1130 }
1131