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