drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c

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