path: root/src/xvmc/intel_batchbuffer.c

/**************************************************************************
 *
 * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
 * All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 **************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <fcntl.h>
#include <dirent.h>
#include <string.h>
#include <assert.h>

#include <sys/ioctl.h>
#include <X11/Xlibint.h>
#include <fourcc.h>
#include <X11/extensions/Xv.h>
#include <X11/extensions/Xvlib.h>
#include <X11/extensions/XvMC.h>
#include <X11/extensions/XvMClib.h>

#include "intel_xvmc.h"
#include "intel_batchbuffer.h"

#define MI_BATCH_BUFFER_END     (0xA << 23)

static int intelEmitIrqLocked(void)
{
   drmI830IrqEmit ie;
   int ret, seq;

   ie.irq_seq = &seq;
   ret = drmCommandWriteRead(xvmc_driver->fd, DRM_I830_IRQ_EMIT,
                             &ie, sizeof(ie));

   if ( ret ) {
      fprintf(stderr, "%s: drmI830IrqEmit: %d\n", __FUNCTION__, ret);
      exit(1);
   }

   return seq;
}

static void intelWaitIrq(int seq)
{
   int ret;
   drmI830IrqWait iw;

   iw.irq_seq = seq;

   do {
      ret = drmCommandWrite(xvmc_driver->fd, DRM_I830_IRQ_WAIT, &iw, sizeof(iw) );
   } while (ret == -EAGAIN || ret == -EINTR);

   if (ret) {
      fprintf(stderr, "%s: drmI830IrqWait: %d\n", __FUNCTION__, ret);
      exit(1);
   }
}

static void intelDestroyBatchBuffer(void)
{
   if (xvmc_driver->alloc.offset) {
       xvmc_driver->alloc.ptr = NULL;
       xvmc_driver->alloc.offset = 0;
   } else if (xvmc_driver->alloc.ptr) {
      free(xvmc_driver->alloc.ptr);
      xvmc_driver->alloc.ptr = NULL;
   }

   memset(&xvmc_driver->batch, 0, sizeof(xvmc_driver->batch));
}


Bool intelInitBatchBuffer(void)
{
    if (drmMap(xvmc_driver->fd,
		xvmc_driver->batchbuffer.handle,
		xvmc_driver->batchbuffer.size,
		(drmAddress *)&xvmc_driver->batchbuffer.map) != 0) {
	XVMC_ERR("fail to map batch buffer\n");
	return False;
    }

    if (xvmc_driver->batchbuffer.map) {
	xvmc_driver->alloc.size = xvmc_driver->batchbuffer.size;
	xvmc_driver->alloc.offset = xvmc_driver->batchbuffer.offset;
	xvmc_driver->alloc.ptr = xvmc_driver->batchbuffer.map;
    } else {
	xvmc_driver->alloc.size = 8 * 1024;
	xvmc_driver->alloc.offset = 0;
	xvmc_driver->alloc.ptr = malloc(xvmc_driver->alloc.size);
    }

    xvmc_driver->alloc.active_buf = 0;
    assert(xvmc_driver->alloc.ptr);
    return True;
}

void intelFiniBatchBuffer(void)
{
    if (xvmc_driver->batchbuffer.map) {
        drmUnmap(xvmc_driver->batchbuffer.map, xvmc_driver->batchbuffer.size);
        xvmc_driver->batchbuffer.map = NULL;
    }
    intelDestroyBatchBuffer();
}

static void intelBatchbufferRequireSpace(unsigned int sz)
{
   if (xvmc_driver->batch.space < sz)
      intelFlushBatch(TRUE);
}

void intelBatchbufferData(const void *data, unsigned bytes, unsigned flags)
{
   assert((bytes & 0x3) == 0);

   intelBatchbufferRequireSpace(bytes);
   memcpy(xvmc_driver->batch.ptr, data, bytes);
   xvmc_driver->batch.ptr += bytes;
   xvmc_driver->batch.space -= bytes;

   assert(xvmc_driver->batch.space >= 0);
}

#define MI_FLUSH                ((0 << 29) | (4 << 23))
#define FLUSH_MAP_CACHE         (1 << 0)
#define FLUSH_RENDER_CACHE      (0 << 2)
#define FLUSH_WRITE_DIRTY_STATE (1 << 4)

static void intelRefillBatchLocked(Bool allow_unlock)
{
   unsigned half = xvmc_driver->alloc.size >> 1;
   unsigned buf = (xvmc_driver->alloc.active_buf ^= 1);
   unsigned dword[2];

   dword[0] = MI_FLUSH | FLUSH_WRITE_DIRTY_STATE | FLUSH_RENDER_CACHE | FLUSH_MAP_CACHE;
   dword[1] = 0;
   intelCmdIoctl((char *)&dword[0], sizeof(dword));

   xvmc_driver->alloc.irq_emitted = intelEmitIrqLocked();

   if (xvmc_driver->alloc.irq_emitted) {
       intelWaitIrq(xvmc_driver->alloc.irq_emitted);
   }

   xvmc_driver->batch.start_offset = xvmc_driver->alloc.offset + buf * half;
   xvmc_driver->batch.ptr = (unsigned char *)xvmc_driver->alloc.ptr + buf * half;
   xvmc_driver->batch.size = half - 8;
   xvmc_driver->batch.space = half - 8;
   assert(xvmc_driver->batch.space >= 0);
}


static void intelFlushBatchLocked(Bool ignore_cliprects,
				  Bool refill,
				  Bool allow_unlock)
{
   drmI830BatchBuffer batch;

   if (xvmc_driver->batch.space != xvmc_driver->batch.size) {

      batch.start = xvmc_driver->batch.start_offset;
      batch.used = xvmc_driver->batch.size - xvmc_driver->batch.space;
      batch.cliprects = 0;
      batch.num_cliprects = 0;
      batch.DR1 = 0;
      batch.DR4 = 0;

      if (xvmc_driver->alloc.offset) {
          if ((batch.used & 0x4) == 0) {
              ((int *)xvmc_driver->batch.ptr)[0] = 0;
              ((int *)xvmc_driver->batch.ptr)[1] = MI_BATCH_BUFFER_END;
              batch.used += 0x8;
              xvmc_driver->batch.ptr += 0x8;
          } else {
              ((int *)xvmc_driver->batch.ptr)[0] = MI_BATCH_BUFFER_END;
              batch.used += 0x4;
              xvmc_driver->batch.ptr += 0x4;
          }
      }

      xvmc_driver->batch.start_offset += batch.used;
      xvmc_driver->batch.size -= batch.used;

      if (xvmc_driver->batch.size < 8) {
         refill = TRUE;
         xvmc_driver->batch.space = xvmc_driver->batch.size = 0;
      }
      else {
         xvmc_driver->batch.size -= 8;
         xvmc_driver->batch.space = xvmc_driver->batch.size;
      }

      assert(xvmc_driver->batch.space >= 0);
      assert(batch.start >= xvmc_driver->alloc.offset);
      assert(batch.start < xvmc_driver->alloc.offset + xvmc_driver->alloc.size);
      assert(batch.start + batch.used > xvmc_driver->alloc.offset);
      assert(batch.start + batch.used <= xvmc_driver->alloc.offset + xvmc_driver->alloc.size);

      if (xvmc_driver->alloc.offset) {
          if (drmCommandWrite(xvmc_driver->fd, DRM_I830_BATCHBUFFER, &batch, sizeof(batch))) {
              fprintf(stderr, "DRM_I830_BATCHBUFFER: %d\n",  -errno);
              exit(1);
          }
      } else {
         drmI830CmdBuffer cmd;
         cmd.buf = (char *)xvmc_driver->alloc.ptr + batch.start;
         cmd.sz = batch.used;
         cmd.DR1 = batch.DR1;
         cmd.DR4 = batch.DR4;
         cmd.num_cliprects = batch.num_cliprects;
         cmd.cliprects = batch.cliprects;

         if (drmCommandWrite(xvmc_driver->fd, DRM_I830_CMDBUFFER, 
                             &cmd, sizeof(cmd))) {
            fprintf(stderr, "DRM_I915_CMDBUFFER: %d\n",  -errno);
            exit(1);
         }
      }
   }

   if (refill)
      intelRefillBatchLocked(allow_unlock);
}

void intelFlushBatch(Bool refill )
{
   intelFlushBatchLocked(FALSE, refill, TRUE);
}

void intelCmdIoctl(char *buf, unsigned used)
{
   drmI830CmdBuffer cmd;

   cmd.buf = buf;
   cmd.sz = used;
   cmd.cliprects = 0;
   cmd.num_cliprects = 0;
   cmd.DR1 = 0;
   cmd.DR4 = 0;

   if (drmCommandWrite(xvmc_driver->fd, DRM_I830_CMDBUFFER, 
                       &cmd, sizeof(cmd))) {
      fprintf(stderr, "DRM_I830_CMDBUFFER: %d\n",  -errno);
      exit(1);
   }
}