drivers/gpu/drm/vmwgfx/vmwgfx_overlay.c

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