mesa/src/gallium/winsys/common/intel_drm/intel_be_device.c

/*
 * Authors: Keith Whitwell <keithw-at-tungstengraphics-dot-com>
 *			 Jakob Bornecrantz <jakob-at-tungstengraphics-dot-com>
 */

#include "intel_be_device.h"
#include "ws_dri_bufmgr.h"
#include "ws_dri_bufpool.h"
#include "ws_dri_fencemgr.h"

#include "pipe/p_winsys.h"
#include "pipe/p_defines.h"
#include "pipe/p_state.h"
#include "pipe/p_util.h"
#include "pipe/p_inlines.h"

/* Turn a pipe winsys into an intel/pipe winsys:
 */
static INLINE struct intel_be_device *
intel_be_device( struct pipe_winsys *winsys )
{
	return (struct intel_be_device *)winsys;
}


/*
 * Buffer functions.
 *
 * Most callbacks map direcly onto dri_bufmgr operations:
 */

static void *intel_be_buffer_map(struct pipe_winsys *winsys,
					struct pipe_buffer *buf,
					unsigned flags )
{
	unsigned drm_flags = 0;
	
	if (flags & PIPE_BUFFER_USAGE_CPU_WRITE)
		drm_flags |= DRM_BO_FLAG_WRITE;

	if (flags & PIPE_BUFFER_USAGE_CPU_READ)
		drm_flags |= DRM_BO_FLAG_READ;

	return driBOMap( dri_bo(buf), drm_flags, 0 );
}

static void intel_be_buffer_unmap(struct pipe_winsys *winsys,
					 struct pipe_buffer *buf)
{
	driBOUnmap( dri_bo(buf) );
}

static void
intel_be_buffer_destroy(struct pipe_winsys *winsys,
			  struct pipe_buffer *buf)
{
	driBOUnReference( dri_bo(buf) );
	FREE(buf);
}

static struct pipe_buffer *
intel_be_buffer_create(struct pipe_winsys *winsys,
						  unsigned alignment,
						  unsigned usage,
						  unsigned size )
{
	struct intel_be_buffer *buffer = CALLOC_STRUCT( intel_be_buffer );
	struct intel_be_device *iws = intel_be_device(winsys);
	unsigned flags = 0;
	struct _DriBufferPool *pool;

	buffer->base.refcount = 1;
	buffer->base.alignment = alignment;
	buffer->base.usage = usage;
	buffer->base.size = size;

	if (usage & (PIPE_BUFFER_USAGE_VERTEX | PIPE_BUFFER_USAGE_CONSTANT)) {
		flags |= DRM_BO_FLAG_MEM_LOCAL | DRM_BO_FLAG_CACHED;
		pool = iws->mallocPool;
	} else if (usage & PIPE_BUFFER_USAGE_CUSTOM) {
		/* For vertex buffers */
		flags |= DRM_BO_FLAG_MEM_VRAM | DRM_BO_FLAG_MEM_TT;
		pool = iws->vertexPool;
	} else {
		flags |= DRM_BO_FLAG_MEM_VRAM | DRM_BO_FLAG_MEM_TT;
		pool = iws->regionPool;
	}

	if (usage & PIPE_BUFFER_USAGE_GPU_READ)
		flags |= DRM_BO_FLAG_READ;

	if (usage & PIPE_BUFFER_USAGE_GPU_WRITE)
		flags |= DRM_BO_FLAG_WRITE;

	/* drm complains if we don't set any read/write flags.
	 */
	if ((flags & (DRM_BO_FLAG_READ | DRM_BO_FLAG_WRITE)) == 0)
		flags |= DRM_BO_FLAG_READ | DRM_BO_FLAG_WRITE;

	buffer->pool = pool;
	driGenBuffers( buffer->pool,
		"pipe buffer", 1, &buffer->driBO, alignment, flags, 0 );

	driBOData( buffer->driBO, size, NULL, buffer->pool, 0 );

	return &buffer->base;
}


static struct pipe_buffer *
intel_be_user_buffer_create(struct pipe_winsys *winsys, void *ptr, unsigned bytes)
{
	struct intel_be_buffer *buffer = CALLOC_STRUCT( intel_be_buffer );
	struct intel_be_device *iws = intel_be_device(winsys);

	driGenUserBuffer( iws->regionPool,
			  "pipe user buffer", &buffer->driBO, ptr, bytes );

	buffer->base.refcount = 1;

	return &buffer->base;
}


/*
 * Surface functions.
 *
 * Deprecated!
 */

static struct pipe_surface *
intel_i915_surface_alloc(struct pipe_winsys *winsys)
{
	assert((size_t)"intel_i915_surface_alloc is deprecated" & 0);
	return NULL;
}

static int
intel_i915_surface_alloc_storage(struct pipe_winsys *winsys,
				 struct pipe_surface *surf,
				 unsigned width, unsigned height,
				 enum pipe_format format,
				 unsigned flags,
				 unsigned tex_usage)
{
	assert((size_t)"intel_i915_surface_alloc_storage is deprecated" & 0);
	return -1;
}

static void
intel_i915_surface_release(struct pipe_winsys *winsys, struct pipe_surface **s)
{
	assert((size_t)"intel_i915_surface_release is deprecated" & 0);
}

/*
 * Fence functions
 */

static void
intel_be_fence_reference( struct pipe_winsys *sws,
		       struct pipe_fence_handle **ptr,
		       struct pipe_fence_handle *fence )
{
	if (*ptr)
		driFenceUnReference((struct _DriFenceObject **)ptr);

	if (fence)
		*ptr = (struct pipe_fence_handle *)driFenceReference((struct _DriFenceObject *)fence);
}

static int
intel_be_fence_signalled( struct pipe_winsys *sws,
		       struct pipe_fence_handle *fence,
		       unsigned flag )
{
	return driFenceSignaled((struct _DriFenceObject *)fence, flag);
}

static int
intel_be_fence_finish( struct pipe_winsys *sws,
		    struct pipe_fence_handle *fence,
		    unsigned flag )
{
	return driFenceFinish((struct _DriFenceObject *)fence, flag, 0);
}

/*
 * Misc functions
 */

boolean
intel_be_init_device(struct intel_be_device *dev, int fd)
{
	dev->fd = fd;
	dev->max_batch_size = 16 * 4096;
	dev->max_vertex_size = 128 * 4096;

	dev->base.buffer_create = intel_be_buffer_create;
	dev->base.user_buffer_create = intel_be_user_buffer_create;
	dev->base.buffer_map = intel_be_buffer_map;
	dev->base.buffer_unmap = intel_be_buffer_unmap;
	dev->base.buffer_destroy = intel_be_buffer_destroy;
	dev->base.surface_alloc = intel_i915_surface_alloc;
	dev->base.surface_alloc_storage = intel_i915_surface_alloc_storage;
	dev->base.surface_release = intel_i915_surface_release;
	dev->base.fence_reference = intel_be_fence_reference;
	dev->base.fence_signalled = intel_be_fence_signalled;
	dev->base.fence_finish = intel_be_fence_finish;

#if 0 /* Set by the winsys */
	dev->base.flush_frontbuffer = intel_flush_frontbuffer;
	dev->base.get_name = intel_get_name;
#endif

	dev->fMan = driInitFreeSlabManager(10, 10);
	dev->fenceMgr = driFenceMgrTTMInit(dev->fd);

	dev->mallocPool = driMallocPoolInit();
	dev->staticPool = driDRMPoolInit(dev->fd);
	dev->regionPool = driDRMPoolInit(dev->fd);
	dev->vertexPool = driSlabPoolInit(dev->fd,
					  DRM_BO_FLAG_READ |
					  DRM_BO_FLAG_WRITE |
					  DRM_BO_FLAG_MEM_TT,
					  DRM_BO_FLAG_READ |
					  DRM_BO_FLAG_WRITE |
					  DRM_BO_FLAG_MEM_TT,
					  dev->max_vertex_size,
					  1, 120, dev->max_vertex_size * 4, 0,
					  dev->fMan);

	dev->batchPool = driSlabPoolInit(dev->fd,
					 DRM_BO_FLAG_EXE |
					 DRM_BO_FLAG_MEM_TT,
					 DRM_BO_FLAG_EXE |
					 DRM_BO_FLAG_MEM_TT,
					 dev->max_batch_size,
					 1, 40, dev->max_batch_size * 16, 0,
					 dev->fMan);

	return true;
}

void
intel_be_destroy_device(struct intel_be_device *dev)
{
	driPoolTakeDown(dev->mallocPool);
	driPoolTakeDown(dev->staticPool);
	driPoolTakeDown(dev->regionPool);
	driPoolTakeDown(dev->vertexPool);
	driPoolTakeDown(dev->batchPool);

	/** TODO takedown fenceMgr and fMan */
}