1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28#include "vmwgfx_kms.h"
29
30
31#define vmw_crtc_to_sou(x) \
32 container_of(x, struct vmw_screen_object_unit, base.crtc)
33#define vmw_encoder_to_sou(x) \
34 container_of(x, struct vmw_screen_object_unit, base.encoder)
35#define vmw_connector_to_sou(x) \
36 container_of(x, struct vmw_screen_object_unit, base.connector)
37
38struct vmw_screen_object_display {
39 unsigned num_implicit;
40
41 struct vmw_framebuffer *implicit_fb;
42};
43
44
45
46
47struct vmw_screen_object_unit {
48 struct vmw_display_unit base;
49
50 unsigned long buffer_size;
51 struct vmw_dma_buffer *buffer;
52
53 bool defined;
54 bool active_implicit;
55};
56
57static void vmw_sou_destroy(struct vmw_screen_object_unit *sou)
58{
59 vmw_display_unit_cleanup(&sou->base);
60 kfree(sou);
61}
62
63
64
65
66
67
68static void vmw_sou_crtc_destroy(struct drm_crtc *crtc)
69{
70 vmw_sou_destroy(vmw_crtc_to_sou(crtc));
71}
72
73static void vmw_sou_del_active(struct vmw_private *vmw_priv,
74 struct vmw_screen_object_unit *sou)
75{
76 struct vmw_screen_object_display *ld = vmw_priv->sou_priv;
77
78 if (sou->active_implicit) {
79 if (--(ld->num_implicit) == 0)
80 ld->implicit_fb = NULL;
81 sou->active_implicit = false;
82 }
83}
84
85static void vmw_sou_add_active(struct vmw_private *vmw_priv,
86 struct vmw_screen_object_unit *sou,
87 struct vmw_framebuffer *vfb)
88{
89 struct vmw_screen_object_display *ld = vmw_priv->sou_priv;
90
91 BUG_ON(!ld->num_implicit && ld->implicit_fb);
92
93 if (!sou->active_implicit && sou->base.is_implicit) {
94 ld->implicit_fb = vfb;
95 sou->active_implicit = true;
96 ld->num_implicit++;
97 }
98}
99
100
101
102
103static int vmw_sou_fifo_create(struct vmw_private *dev_priv,
104 struct vmw_screen_object_unit *sou,
105 uint32_t x, uint32_t y,
106 struct drm_display_mode *mode)
107{
108 size_t fifo_size;
109
110 struct {
111 struct {
112 uint32_t cmdType;
113 } header;
114 SVGAScreenObject obj;
115 } *cmd;
116
117 BUG_ON(!sou->buffer);
118
119 fifo_size = sizeof(*cmd);
120 cmd = vmw_fifo_reserve(dev_priv, fifo_size);
121
122 if (unlikely(cmd == NULL)) {
123 DRM_ERROR("Fifo reserve failed.\n");
124 return -ENOMEM;
125 }
126
127 memset(cmd, 0, fifo_size);
128 cmd->header.cmdType = SVGA_CMD_DEFINE_SCREEN;
129 cmd->obj.structSize = sizeof(SVGAScreenObject);
130 cmd->obj.id = sou->base.unit;
131 cmd->obj.flags = SVGA_SCREEN_HAS_ROOT |
132 (sou->base.unit == 0 ? SVGA_SCREEN_IS_PRIMARY : 0);
133 cmd->obj.size.width = mode->hdisplay;
134 cmd->obj.size.height = mode->vdisplay;
135 if (sou->base.is_implicit) {
136 cmd->obj.root.x = x;
137 cmd->obj.root.y = y;
138 } else {
139 cmd->obj.root.x = sou->base.gui_x;
140 cmd->obj.root.y = sou->base.gui_y;
141 }
142
143
144 vmw_bo_get_guest_ptr(&sou->buffer->base, &cmd->obj.backingStore.ptr);
145 cmd->obj.backingStore.pitch = mode->hdisplay * 4;
146
147 vmw_fifo_commit(dev_priv, fifo_size);
148
149 sou->defined = true;
150
151 return 0;
152}
153
154
155
156
157static int vmw_sou_fifo_destroy(struct vmw_private *dev_priv,
158 struct vmw_screen_object_unit *sou)
159{
160 size_t fifo_size;
161 int ret;
162
163 struct {
164 struct {
165 uint32_t cmdType;
166 } header;
167 SVGAFifoCmdDestroyScreen body;
168 } *cmd;
169
170
171 if (unlikely(!sou->defined))
172 return 0;
173
174 fifo_size = sizeof(*cmd);
175 cmd = vmw_fifo_reserve(dev_priv, fifo_size);
176
177 if (unlikely(cmd == NULL)) {
178 DRM_ERROR("Fifo reserve failed.\n");
179 return -ENOMEM;
180 }
181
182 memset(cmd, 0, fifo_size);
183 cmd->header.cmdType = SVGA_CMD_DESTROY_SCREEN;
184 cmd->body.screenId = sou->base.unit;
185
186 vmw_fifo_commit(dev_priv, fifo_size);
187
188
189 ret = vmw_fallback_wait(dev_priv, false, true, 0, false, 3*HZ);
190 if (unlikely(ret != 0))
191 DRM_ERROR("Failed to sync with HW");
192 else
193 sou->defined = false;
194
195 return ret;
196}
197
198
199
200
201static void vmw_sou_backing_free(struct vmw_private *dev_priv,
202 struct vmw_screen_object_unit *sou)
203{
204 struct ttm_buffer_object *bo;
205
206 if (unlikely(sou->buffer == NULL))
207 return;
208
209 bo = &sou->buffer->base;
210 ttm_bo_unref(&bo);
211 sou->buffer = NULL;
212 sou->buffer_size = 0;
213}
214
215
216
217
218static int vmw_sou_backing_alloc(struct vmw_private *dev_priv,
219 struct vmw_screen_object_unit *sou,
220 unsigned long size)
221{
222 int ret;
223
224 if (sou->buffer_size == size)
225 return 0;
226
227 if (sou->buffer)
228 vmw_sou_backing_free(dev_priv, sou);
229
230 sou->buffer = kzalloc(sizeof(*sou->buffer), GFP_KERNEL);
231 if (unlikely(sou->buffer == NULL))
232 return -ENOMEM;
233
234
235
236
237 vmw_overlay_pause_all(dev_priv);
238 ret = vmw_dmabuf_init(dev_priv, sou->buffer, size,
239 &vmw_vram_ne_placement,
240 false, &vmw_dmabuf_bo_free);
241 vmw_overlay_resume_all(dev_priv);
242
243 if (unlikely(ret != 0))
244 sou->buffer = NULL;
245 else
246 sou->buffer_size = size;
247
248 return ret;
249}
250
251static int vmw_sou_crtc_set_config(struct drm_mode_set *set)
252{
253 struct vmw_private *dev_priv;
254 struct vmw_screen_object_unit *sou;
255 struct drm_connector *connector;
256 struct drm_display_mode *mode;
257 struct drm_encoder *encoder;
258 struct vmw_framebuffer *vfb;
259 struct drm_framebuffer *fb;
260 struct drm_crtc *crtc;
261 int ret = 0;
262
263 if (!set)
264 return -EINVAL;
265
266 if (!set->crtc)
267 return -EINVAL;
268
269
270 crtc = set->crtc;
271 sou = vmw_crtc_to_sou(crtc);
272 vfb = set->fb ? vmw_framebuffer_to_vfb(set->fb) : NULL;
273 dev_priv = vmw_priv(crtc->dev);
274
275 if (set->num_connectors > 1) {
276 DRM_ERROR("to many connectors\n");
277 return -EINVAL;
278 }
279
280 if (set->num_connectors == 1 &&
281 set->connectors[0] != &sou->base.connector) {
282 DRM_ERROR("connector doesn't match %p %p\n",
283 set->connectors[0], &sou->base.connector);
284 return -EINVAL;
285 }
286
287
288 if (sou->base.is_implicit &&
289 dev_priv->sou_priv->implicit_fb && vfb &&
290 !(dev_priv->sou_priv->num_implicit == 1 &&
291 sou->active_implicit) &&
292 dev_priv->sou_priv->implicit_fb != vfb) {
293 DRM_ERROR("Multiple framebuffers not supported\n");
294 return -EINVAL;
295 }
296
297
298 connector = &sou->base.connector;
299 encoder = &sou->base.encoder;
300
301
302 if (set->num_connectors == 0 || !set->mode || !set->fb) {
303 ret = vmw_sou_fifo_destroy(dev_priv, sou);
304
305 if (unlikely(ret != 0))
306 return ret;
307
308 connector->encoder = NULL;
309 encoder->crtc = NULL;
310 crtc->fb = NULL;
311 crtc->x = 0;
312 crtc->y = 0;
313 crtc->enabled = false;
314
315 vmw_sou_del_active(dev_priv, sou);
316
317 vmw_sou_backing_free(dev_priv, sou);
318
319 return 0;
320 }
321
322
323
324 mode = set->mode;
325 fb = set->fb;
326
327 if (set->x + mode->hdisplay > fb->width ||
328 set->y + mode->vdisplay > fb->height) {
329 DRM_ERROR("set outside of framebuffer\n");
330 return -EINVAL;
331 }
332
333 vmw_fb_off(dev_priv);
334
335 if (mode->hdisplay != crtc->mode.hdisplay ||
336 mode->vdisplay != crtc->mode.vdisplay) {
337
338
339
340
341 ret = vmw_sou_fifo_destroy(dev_priv, sou);
342
343 if (unlikely(ret != 0))
344 return ret;
345
346 vmw_sou_backing_free(dev_priv, sou);
347 }
348
349 if (!sou->buffer) {
350
351 size_t size = mode->hdisplay * mode->vdisplay * 4;
352 ret = vmw_sou_backing_alloc(dev_priv, sou, size);
353 if (unlikely(ret != 0))
354 return ret;
355 }
356
357 ret = vmw_sou_fifo_create(dev_priv, sou, set->x, set->y, mode);
358 if (unlikely(ret != 0)) {
359
360
361
362
363
364
365
366 if (sou->defined)
367 return ret;
368
369 connector->encoder = NULL;
370 encoder->crtc = NULL;
371 crtc->fb = NULL;
372 crtc->x = 0;
373 crtc->y = 0;
374 crtc->enabled = false;
375
376 return ret;
377 }
378
379 vmw_sou_add_active(dev_priv, sou, vfb);
380
381 connector->encoder = encoder;
382 encoder->crtc = crtc;
383 crtc->mode = *mode;
384 crtc->fb = fb;
385 crtc->x = set->x;
386 crtc->y = set->y;
387 crtc->enabled = true;
388
389 return 0;
390}
391
392static struct drm_crtc_funcs vmw_screen_object_crtc_funcs = {
393 .save = vmw_du_crtc_save,
394 .restore = vmw_du_crtc_restore,
395 .cursor_set = vmw_du_crtc_cursor_set,
396 .cursor_move = vmw_du_crtc_cursor_move,
397 .gamma_set = vmw_du_crtc_gamma_set,
398 .destroy = vmw_sou_crtc_destroy,
399 .set_config = vmw_sou_crtc_set_config,
400 .page_flip = vmw_du_page_flip,
401};
402
403
404
405
406
407static void vmw_sou_encoder_destroy(struct drm_encoder *encoder)
408{
409 vmw_sou_destroy(vmw_encoder_to_sou(encoder));
410}
411
412static struct drm_encoder_funcs vmw_screen_object_encoder_funcs = {
413 .destroy = vmw_sou_encoder_destroy,
414};
415
416
417
418
419
420static void vmw_sou_connector_destroy(struct drm_connector *connector)
421{
422 vmw_sou_destroy(vmw_connector_to_sou(connector));
423}
424
425static struct drm_connector_funcs vmw_legacy_connector_funcs = {
426 .dpms = vmw_du_connector_dpms,
427 .save = vmw_du_connector_save,
428 .restore = vmw_du_connector_restore,
429 .detect = vmw_du_connector_detect,
430 .fill_modes = vmw_du_connector_fill_modes,
431 .set_property = vmw_du_connector_set_property,
432 .destroy = vmw_sou_connector_destroy,
433};
434
435static int vmw_sou_init(struct vmw_private *dev_priv, unsigned unit)
436{
437 struct vmw_screen_object_unit *sou;
438 struct drm_device *dev = dev_priv->dev;
439 struct drm_connector *connector;
440 struct drm_encoder *encoder;
441 struct drm_crtc *crtc;
442
443 sou = kzalloc(sizeof(*sou), GFP_KERNEL);
444 if (!sou)
445 return -ENOMEM;
446
447 sou->base.unit = unit;
448 crtc = &sou->base.crtc;
449 encoder = &sou->base.encoder;
450 connector = &sou->base.connector;
451
452 sou->active_implicit = false;
453
454 sou->base.pref_active = (unit == 0);
455 sou->base.pref_width = dev_priv->initial_width;
456 sou->base.pref_height = dev_priv->initial_height;
457 sou->base.pref_mode = NULL;
458 sou->base.is_implicit = true;
459
460 drm_connector_init(dev, connector, &vmw_legacy_connector_funcs,
461 DRM_MODE_CONNECTOR_VIRTUAL);
462 connector->status = vmw_du_connector_detect(connector, true);
463
464 drm_encoder_init(dev, encoder, &vmw_screen_object_encoder_funcs,
465 DRM_MODE_ENCODER_VIRTUAL);
466 drm_mode_connector_attach_encoder(connector, encoder);
467 encoder->possible_crtcs = (1 << unit);
468 encoder->possible_clones = 0;
469
470 (void) drm_sysfs_connector_add(connector);
471
472 drm_crtc_init(dev, crtc, &vmw_screen_object_crtc_funcs);
473
474 drm_mode_crtc_set_gamma_size(crtc, 256);
475
476 drm_object_attach_property(&connector->base,
477 dev->mode_config.dirty_info_property,
478 1);
479
480 return 0;
481}
482
483int vmw_kms_init_screen_object_display(struct vmw_private *dev_priv)
484{
485 struct drm_device *dev = dev_priv->dev;
486 int i, ret;
487
488 if (dev_priv->sou_priv) {
489 DRM_INFO("sou system already on\n");
490 return -EINVAL;
491 }
492
493 if (!(dev_priv->capabilities & SVGA_CAP_SCREEN_OBJECT_2)) {
494 DRM_INFO("Not using screen objects,"
495 " missing cap SCREEN_OBJECT_2\n");
496 return -ENOSYS;
497 }
498
499 ret = -ENOMEM;
500 dev_priv->sou_priv = kmalloc(sizeof(*dev_priv->sou_priv), GFP_KERNEL);
501 if (unlikely(!dev_priv->sou_priv))
502 goto err_no_mem;
503
504 dev_priv->sou_priv->num_implicit = 0;
505 dev_priv->sou_priv->implicit_fb = NULL;
506
507 ret = drm_vblank_init(dev, VMWGFX_NUM_DISPLAY_UNITS);
508 if (unlikely(ret != 0))
509 goto err_free;
510
511 ret = drm_mode_create_dirty_info_property(dev);
512 if (unlikely(ret != 0))
513 goto err_vblank_cleanup;
514
515 for (i = 0; i < VMWGFX_NUM_DISPLAY_UNITS; ++i)
516 vmw_sou_init(dev_priv, i);
517
518 DRM_INFO("Screen objects system initialized\n");
519
520 return 0;
521
522err_vblank_cleanup:
523 drm_vblank_cleanup(dev);
524err_free:
525 kfree(dev_priv->sou_priv);
526 dev_priv->sou_priv = NULL;
527err_no_mem:
528 return ret;
529}
530
531int vmw_kms_close_screen_object_display(struct vmw_private *dev_priv)
532{
533 struct drm_device *dev = dev_priv->dev;
534
535 if (!dev_priv->sou_priv)
536 return -ENOSYS;
537
538 drm_vblank_cleanup(dev);
539
540 kfree(dev_priv->sou_priv);
541
542 return 0;
543}
544
545
546
547
548
549bool vmw_kms_screen_object_flippable(struct vmw_private *dev_priv,
550 struct drm_crtc *crtc)
551{
552 struct vmw_screen_object_unit *sou = vmw_crtc_to_sou(crtc);
553
554 if (!sou->base.is_implicit)
555 return true;
556
557 if (dev_priv->sou_priv->num_implicit != 1)
558 return false;
559
560 return true;
561}
562
563
564
565
566
567void vmw_kms_screen_object_update_implicit_fb(struct vmw_private *dev_priv,
568 struct drm_crtc *crtc)
569{
570 struct vmw_screen_object_unit *sou = vmw_crtc_to_sou(crtc);
571
572 BUG_ON(!sou->base.is_implicit);
573
574 dev_priv->sou_priv->implicit_fb =
575 vmw_framebuffer_to_vfb(sou->base.crtc.fb);
576}
577