1 // SPDX-License-Identifier: GPL-2.0 OR MIT
2 /**************************************************************************
3  *
4  * Copyright 2009-2014 VMware, Inc., Palo Alto, CA., USA
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a
7  * copy of this software and associated documentation files (the
8  * "Software"), to deal in the Software without restriction, including
9  * without limitation the rights to use, copy, modify, merge, publish,
10  * distribute, sub license, and/or sell copies of the Software, and to
11  * permit persons to whom the Software is furnished to do so, subject to
12  * the following conditions:
13  *
14  * The above copyright notice and this permission notice (including the
15  * next paragraph) shall be included in all copies or substantial portions
16  * of the Software.
17  *
18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
22  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
23  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24  * USE OR OTHER DEALINGS IN THE SOFTWARE.
25  *
26  **************************************************************************/
27 
28 
29 #include <drm/drmP.h>
30 #include "vmwgfx_drv.h"
31 
32 #include <drm/ttm/ttm_placement.h>
33 
34 #include "device_include/svga_overlay.h"
35 #include "device_include/svga_escape.h"
36 
37 #define VMW_MAX_NUM_STREAMS 1
38 #define VMW_OVERLAY_CAP_MASK (SVGA_FIFO_CAP_VIDEO | SVGA_FIFO_CAP_ESCAPE)
39 
40 struct vmw_stream {
41 	struct vmw_buffer_object *buf;
42 	bool claimed;
43 	bool paused;
44 	struct drm_vmw_control_stream_arg saved;
45 };
46 
47 /**
48  * Overlay control
49  */
50 struct vmw_overlay {
51 	/*
52 	 * Each stream is a single overlay. In Xv these are called ports.
53 	 */
54 	struct mutex mutex;
55 	struct vmw_stream stream[VMW_MAX_NUM_STREAMS];
56 };
57 
58 static inline struct vmw_overlay *vmw_overlay(struct drm_device *dev)
59 {
60 	struct vmw_private *dev_priv = vmw_priv(dev);
61 	return dev_priv ? dev_priv->overlay_priv : NULL;
62 }
63 
64 struct vmw_escape_header {
65 	uint32_t cmd;
66 	SVGAFifoCmdEscape body;
67 };
68 
69 struct vmw_escape_video_flush {
70 	struct vmw_escape_header escape;
71 	SVGAEscapeVideoFlush flush;
72 };
73 
74 static inline void fill_escape(struct vmw_escape_header *header,
75 			       uint32_t size)
76 {
77 	header->cmd = SVGA_CMD_ESCAPE;
78 	header->body.nsid = SVGA_ESCAPE_NSID_VMWARE;
79 	header->body.size = size;
80 }
81 
82 static inline void fill_flush(struct vmw_escape_video_flush *cmd,
83 			      uint32_t stream_id)
84 {
85 	fill_escape(&cmd->escape, sizeof(cmd->flush));
86 	cmd->flush.cmdType = SVGA_ESCAPE_VMWARE_VIDEO_FLUSH;
87 	cmd->flush.streamId = stream_id;
88 }
89 
90 /**
91  * Send put command to hw.
92  *
93  * Returns
94  * -ERESTARTSYS if interrupted by a signal.
95  */
96 static int vmw_overlay_send_put(struct vmw_private *dev_priv,
97 				struct vmw_buffer_object *buf,
98 				struct drm_vmw_control_stream_arg *arg,
99 				bool interruptible)
100 {
101 	struct vmw_escape_video_flush *flush;
102 	size_t fifo_size;
103 	bool have_so = (dev_priv->active_display_unit == vmw_du_screen_object);
104 	int i, num_items;
105 	SVGAGuestPtr ptr;
106 
107 	struct {
108 		struct vmw_escape_header escape;
109 		struct {
110 			uint32_t cmdType;
111 			uint32_t streamId;
112 		} header;
113 	} *cmds;
114 	struct {
115 		uint32_t registerId;
116 		uint32_t value;
117 	} *items;
118 
119 	/* defines are a index needs + 1 */
120 	if (have_so)
121 		num_items = SVGA_VIDEO_DST_SCREEN_ID + 1;
122 	else
123 		num_items = SVGA_VIDEO_PITCH_3 + 1;
124 
125 	fifo_size = sizeof(*cmds) + sizeof(*flush) + sizeof(*items) * num_items;
126 
127 	cmds = vmw_fifo_reserve(dev_priv, fifo_size);
128 	/* hardware has hung, can't do anything here */
129 	if (!cmds)
130 		return -ENOMEM;
131 
132 	items = (typeof(items))&cmds[1];
133 	flush = (struct vmw_escape_video_flush *)&items[num_items];
134 
135 	/* the size is header + number of items */
136 	fill_escape(&cmds->escape, sizeof(*items) * (num_items + 1));
137 
138 	cmds->header.cmdType = SVGA_ESCAPE_VMWARE_VIDEO_SET_REGS;
139 	cmds->header.streamId = arg->stream_id;
140 
141 	/* the IDs are neatly numbered */
142 	for (i = 0; i < num_items; i++)
143 		items[i].registerId = i;
144 
145 	vmw_bo_get_guest_ptr(&buf->base, &ptr);
146 	ptr.offset += arg->offset;
147 
148 	items[SVGA_VIDEO_ENABLED].value     = true;
149 	items[SVGA_VIDEO_FLAGS].value       = arg->flags;
150 	items[SVGA_VIDEO_DATA_OFFSET].value = ptr.offset;
151 	items[SVGA_VIDEO_FORMAT].value      = arg->format;
152 	items[SVGA_VIDEO_COLORKEY].value    = arg->color_key;
153 	items[SVGA_VIDEO_SIZE].value        = arg->size;
154 	items[SVGA_VIDEO_WIDTH].value       = arg->width;
155 	items[SVGA_VIDEO_HEIGHT].value      = arg->height;
156 	items[SVGA_VIDEO_SRC_X].value       = arg->src.x;
157 	items[SVGA_VIDEO_SRC_Y].value       = arg->src.y;
158 	items[SVGA_VIDEO_SRC_WIDTH].value   = arg->src.w;
159 	items[SVGA_VIDEO_SRC_HEIGHT].value  = arg->src.h;
160 	items[SVGA_VIDEO_DST_X].value       = arg->dst.x;
161 	items[SVGA_VIDEO_DST_Y].value       = arg->dst.y;
162 	items[SVGA_VIDEO_DST_WIDTH].value   = arg->dst.w;
163 	items[SVGA_VIDEO_DST_HEIGHT].value  = arg->dst.h;
164 	items[SVGA_VIDEO_PITCH_1].value     = arg->pitch[0];
165 	items[SVGA_VIDEO_PITCH_2].value     = arg->pitch[1];
166 	items[SVGA_VIDEO_PITCH_3].value     = arg->pitch[2];
167 	if (have_so) {
168 		items[SVGA_VIDEO_DATA_GMRID].value    = ptr.gmrId;
169 		items[SVGA_VIDEO_DST_SCREEN_ID].value = SVGA_ID_INVALID;
170 	}
171 
172 	fill_flush(flush, arg->stream_id);
173 
174 	vmw_fifo_commit(dev_priv, fifo_size);
175 
176 	return 0;
177 }
178 
179 /**
180  * Send stop command to hw.
181  *
182  * Returns
183  * -ERESTARTSYS if interrupted by a signal.
184  */
185 static int vmw_overlay_send_stop(struct vmw_private *dev_priv,
186 				 uint32_t stream_id,
187 				 bool interruptible)
188 {
189 	struct {
190 		struct vmw_escape_header escape;
191 		SVGAEscapeVideoSetRegs body;
192 		struct vmw_escape_video_flush flush;
193 	} *cmds;
194 	int ret;
195 
196 	for (;;) {
197 		cmds = vmw_fifo_reserve(dev_priv, sizeof(*cmds));
198 		if (cmds)
199 			break;
200 
201 		ret = vmw_fallback_wait(dev_priv, false, true, 0,
202 					interruptible, 3*HZ);
203 		if (interruptible && ret == -ERESTARTSYS)
204 			return ret;
205 		else
206 			BUG_ON(ret != 0);
207 	}
208 
209 	fill_escape(&cmds->escape, sizeof(cmds->body));
210 	cmds->body.header.cmdType = SVGA_ESCAPE_VMWARE_VIDEO_SET_REGS;
211 	cmds->body.header.streamId = stream_id;
212 	cmds->body.items[0].registerId = SVGA_VIDEO_ENABLED;
213 	cmds->body.items[0].value = false;
214 	fill_flush(&cmds->flush, stream_id);
215 
216 	vmw_fifo_commit(dev_priv, sizeof(*cmds));
217 
218 	return 0;
219 }
220 
221 /**
222  * Move a buffer to vram or gmr if @pin is set, else unpin the buffer.
223  *
224  * With the introduction of screen objects buffers could now be
225  * used with GMRs instead of being locked to vram.
226  */
227 static int vmw_overlay_move_buffer(struct vmw_private *dev_priv,
228 				   struct vmw_buffer_object *buf,
229 				   bool pin, bool inter)
230 {
231 	if (!pin)
232 		return vmw_bo_unpin(dev_priv, buf, inter);
233 
234 	if (dev_priv->active_display_unit == vmw_du_legacy)
235 		return vmw_bo_pin_in_vram(dev_priv, buf, inter);
236 
237 	return vmw_bo_pin_in_vram_or_gmr(dev_priv, buf, inter);
238 }
239 
240 /**
241  * Stop or pause a stream.
242  *
243  * If the stream is paused the no evict flag is removed from the buffer
244  * but left in vram. This allows for instance mode_set to evict it
245  * should it need to.
246  *
247  * The caller must hold the overlay lock.
248  *
249  * @stream_id which stream to stop/pause.
250  * @pause true to pause, false to stop completely.
251  */
252 static int vmw_overlay_stop(struct vmw_private *dev_priv,
253 			    uint32_t stream_id, bool pause,
254 			    bool interruptible)
255 {
256 	struct vmw_overlay *overlay = dev_priv->overlay_priv;
257 	struct vmw_stream *stream = &overlay->stream[stream_id];
258 	int ret;
259 
260 	/* no buffer attached the stream is completely stopped */
261 	if (!stream->buf)
262 		return 0;
263 
264 	/* If the stream is paused this is already done */
265 	if (!stream->paused) {
266 		ret = vmw_overlay_send_stop(dev_priv, stream_id,
267 					    interruptible);
268 		if (ret)
269 			return ret;
270 
271 		/* We just remove the NO_EVICT flag so no -ENOMEM */
272 		ret = vmw_overlay_move_buffer(dev_priv, stream->buf, false,
273 					      interruptible);
274 		if (interruptible && ret == -ERESTARTSYS)
275 			return ret;
276 		else
277 			BUG_ON(ret != 0);
278 	}
279 
280 	if (!pause) {
281 		vmw_bo_unreference(&stream->buf);
282 		stream->paused = false;
283 	} else {
284 		stream->paused = true;
285 	}
286 
287 	return 0;
288 }
289 
290 /**
291  * Update a stream and send any put or stop fifo commands needed.
292  *
293  * The caller must hold the overlay lock.
294  *
295  * Returns
296  * -ENOMEM if buffer doesn't fit in vram.
297  * -ERESTARTSYS if interrupted.
298  */
299 static int vmw_overlay_update_stream(struct vmw_private *dev_priv,
300 				     struct vmw_buffer_object *buf,
301 				     struct drm_vmw_control_stream_arg *arg,
302 				     bool interruptible)
303 {
304 	struct vmw_overlay *overlay = dev_priv->overlay_priv;
305 	struct vmw_stream *stream = &overlay->stream[arg->stream_id];
306 	int ret = 0;
307 
308 	if (!buf)
309 		return -EINVAL;
310 
311 	DRM_DEBUG("   %s: old %p, new %p, %spaused\n", __func__,
312 		  stream->buf, buf, stream->paused ? "" : "not ");
313 
314 	if (stream->buf != buf) {
315 		ret = vmw_overlay_stop(dev_priv, arg->stream_id,
316 				       false, interruptible);
317 		if (ret)
318 			return ret;
319 	} else if (!stream->paused) {
320 		/* If the buffers match and not paused then just send
321 		 * the put command, no need to do anything else.
322 		 */
323 		ret = vmw_overlay_send_put(dev_priv, buf, arg, interruptible);
324 		if (ret == 0)
325 			stream->saved = *arg;
326 		else
327 			BUG_ON(!interruptible);
328 
329 		return ret;
330 	}
331 
332 	/* We don't start the old stream if we are interrupted.
333 	 * Might return -ENOMEM if it can't fit the buffer in vram.
334 	 */
335 	ret = vmw_overlay_move_buffer(dev_priv, buf, true, interruptible);
336 	if (ret)
337 		return ret;
338 
339 	ret = vmw_overlay_send_put(dev_priv, buf, arg, interruptible);
340 	if (ret) {
341 		/* This one needs to happen no matter what. We only remove
342 		 * the NO_EVICT flag so this is safe from -ENOMEM.
343 		 */
344 		BUG_ON(vmw_overlay_move_buffer(dev_priv, buf, false, false)
345 		       != 0);
346 		return ret;
347 	}
348 
349 	if (stream->buf != buf)
350 		stream->buf = vmw_bo_reference(buf);
351 	stream->saved = *arg;
352 	/* stream is no longer stopped/paused */
353 	stream->paused = false;
354 
355 	return 0;
356 }
357 
358 /**
359  * Stop all streams.
360  *
361  * Used by the fb code when starting.
362  *
363  * Takes the overlay lock.
364  */
365 int vmw_overlay_stop_all(struct vmw_private *dev_priv)
366 {
367 	struct vmw_overlay *overlay = dev_priv->overlay_priv;
368 	int i, ret;
369 
370 	if (!overlay)
371 		return 0;
372 
373 	mutex_lock(&overlay->mutex);
374 
375 	for (i = 0; i < VMW_MAX_NUM_STREAMS; i++) {
376 		struct vmw_stream *stream = &overlay->stream[i];
377 		if (!stream->buf)
378 			continue;
379 
380 		ret = vmw_overlay_stop(dev_priv, i, false, false);
381 		WARN_ON(ret != 0);
382 	}
383 
384 	mutex_unlock(&overlay->mutex);
385 
386 	return 0;
387 }
388 
389 /**
390  * Try to resume all paused streams.
391  *
392  * Used by the kms code after moving a new scanout buffer to vram.
393  *
394  * Takes the overlay lock.
395  */
396 int vmw_overlay_resume_all(struct vmw_private *dev_priv)
397 {
398 	struct vmw_overlay *overlay = dev_priv->overlay_priv;
399 	int i, ret;
400 
401 	if (!overlay)
402 		return 0;
403 
404 	mutex_lock(&overlay->mutex);
405 
406 	for (i = 0; i < VMW_MAX_NUM_STREAMS; i++) {
407 		struct vmw_stream *stream = &overlay->stream[i];
408 		if (!stream->paused)
409 			continue;
410 
411 		ret = vmw_overlay_update_stream(dev_priv, stream->buf,
412 						&stream->saved, false);
413 		if (ret != 0)
414 			DRM_INFO("%s: *warning* failed to resume stream %i\n",
415 				 __func__, i);
416 	}
417 
418 	mutex_unlock(&overlay->mutex);
419 
420 	return 0;
421 }
422 
423 /**
424  * Pauses all active streams.
425  *
426  * Used by the kms code when moving a new scanout buffer to vram.
427  *
428  * Takes the overlay lock.
429  */
430 int vmw_overlay_pause_all(struct vmw_private *dev_priv)
431 {
432 	struct vmw_overlay *overlay = dev_priv->overlay_priv;
433 	int i, ret;
434 
435 	if (!overlay)
436 		return 0;
437 
438 	mutex_lock(&overlay->mutex);
439 
440 	for (i = 0; i < VMW_MAX_NUM_STREAMS; i++) {
441 		if (overlay->stream[i].paused)
442 			DRM_INFO("%s: *warning* stream %i already paused\n",
443 				 __func__, i);
444 		ret = vmw_overlay_stop(dev_priv, i, true, false);
445 		WARN_ON(ret != 0);
446 	}
447 
448 	mutex_unlock(&overlay->mutex);
449 
450 	return 0;
451 }
452 
453 
454 static bool vmw_overlay_available(const struct vmw_private *dev_priv)
455 {
456 	return (dev_priv->overlay_priv != NULL &&
457 		((dev_priv->fifo.capabilities & VMW_OVERLAY_CAP_MASK) ==
458 		 VMW_OVERLAY_CAP_MASK));
459 }
460 
461 int vmw_overlay_ioctl(struct drm_device *dev, void *data,
462 		      struct drm_file *file_priv)
463 {
464 	struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
465 	struct vmw_private *dev_priv = vmw_priv(dev);
466 	struct vmw_overlay *overlay = dev_priv->overlay_priv;
467 	struct drm_vmw_control_stream_arg *arg =
468 	    (struct drm_vmw_control_stream_arg *)data;
469 	struct vmw_buffer_object *buf;
470 	struct vmw_resource *res;
471 	int ret;
472 
473 	if (!vmw_overlay_available(dev_priv))
474 		return -ENOSYS;
475 
476 	ret = vmw_user_stream_lookup(dev_priv, tfile, &arg->stream_id, &res);
477 	if (ret)
478 		return ret;
479 
480 	mutex_lock(&overlay->mutex);
481 
482 	if (!arg->enabled) {
483 		ret = vmw_overlay_stop(dev_priv, arg->stream_id, false, true);
484 		goto out_unlock;
485 	}
486 
487 	ret = vmw_user_bo_lookup(tfile, arg->handle, &buf, NULL);
488 	if (ret)
489 		goto out_unlock;
490 
491 	ret = vmw_overlay_update_stream(dev_priv, buf, arg, true);
492 
493 	vmw_bo_unreference(&buf);
494 
495 out_unlock:
496 	mutex_unlock(&overlay->mutex);
497 	vmw_resource_unreference(&res);
498 
499 	return ret;
500 }
501 
502 int vmw_overlay_num_overlays(struct vmw_private *dev_priv)
503 {
504 	if (!vmw_overlay_available(dev_priv))
505 		return 0;
506 
507 	return VMW_MAX_NUM_STREAMS;
508 }
509 
510 int vmw_overlay_num_free_overlays(struct vmw_private *dev_priv)
511 {
512 	struct vmw_overlay *overlay = dev_priv->overlay_priv;
513 	int i, k;
514 
515 	if (!vmw_overlay_available(dev_priv))
516 		return 0;
517 
518 	mutex_lock(&overlay->mutex);
519 
520 	for (i = 0, k = 0; i < VMW_MAX_NUM_STREAMS; i++)
521 		if (!overlay->stream[i].claimed)
522 			k++;
523 
524 	mutex_unlock(&overlay->mutex);
525 
526 	return k;
527 }
528 
529 int vmw_overlay_claim(struct vmw_private *dev_priv, uint32_t *out)
530 {
531 	struct vmw_overlay *overlay = dev_priv->overlay_priv;
532 	int i;
533 
534 	if (!overlay)
535 		return -ENOSYS;
536 
537 	mutex_lock(&overlay->mutex);
538 
539 	for (i = 0; i < VMW_MAX_NUM_STREAMS; i++) {
540 
541 		if (overlay->stream[i].claimed)
542 			continue;
543 
544 		overlay->stream[i].claimed = true;
545 		*out = i;
546 		mutex_unlock(&overlay->mutex);
547 		return 0;
548 	}
549 
550 	mutex_unlock(&overlay->mutex);
551 	return -ESRCH;
552 }
553 
554 int vmw_overlay_unref(struct vmw_private *dev_priv, uint32_t stream_id)
555 {
556 	struct vmw_overlay *overlay = dev_priv->overlay_priv;
557 
558 	BUG_ON(stream_id >= VMW_MAX_NUM_STREAMS);
559 
560 	if (!overlay)
561 		return -ENOSYS;
562 
563 	mutex_lock(&overlay->mutex);
564 
565 	WARN_ON(!overlay->stream[stream_id].claimed);
566 	vmw_overlay_stop(dev_priv, stream_id, false, false);
567 	overlay->stream[stream_id].claimed = false;
568 
569 	mutex_unlock(&overlay->mutex);
570 	return 0;
571 }
572 
573 int vmw_overlay_init(struct vmw_private *dev_priv)
574 {
575 	struct vmw_overlay *overlay;
576 	int i;
577 
578 	if (dev_priv->overlay_priv)
579 		return -EINVAL;
580 
581 	overlay = kzalloc(sizeof(*overlay), GFP_KERNEL);
582 	if (!overlay)
583 		return -ENOMEM;
584 
585 	mutex_init(&overlay->mutex);
586 	for (i = 0; i < VMW_MAX_NUM_STREAMS; i++) {
587 		overlay->stream[i].buf = NULL;
588 		overlay->stream[i].paused = false;
589 		overlay->stream[i].claimed = false;
590 	}
591 
592 	dev_priv->overlay_priv = overlay;
593 
594 	return 0;
595 }
596 
597 int vmw_overlay_close(struct vmw_private *dev_priv)
598 {
599 	struct vmw_overlay *overlay = dev_priv->overlay_priv;
600 	bool forgotten_buffer = false;
601 	int i;
602 
603 	if (!overlay)
604 		return -ENOSYS;
605 
606 	for (i = 0; i < VMW_MAX_NUM_STREAMS; i++) {
607 		if (overlay->stream[i].buf) {
608 			forgotten_buffer = true;
609 			vmw_overlay_stop(dev_priv, i, false, false);
610 		}
611 	}
612 
613 	WARN_ON(forgotten_buffer);
614 
615 	dev_priv->overlay_priv = NULL;
616 	kfree(overlay);
617 
618 	return 0;
619 }
620