intel_be_batchbuffer.h File Reference

Include dependency graph for intel_be_batchbuffer.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	intel_be_batchbuffer
Defines
#define	BATCH_RESERVED   16
#define	INTEL_DEFAULT_RELOCS   100
#define	INTEL_MAX_RELOCS   400
#define	INTEL_BATCH_NO_CLIPRECTS   0x1
#define	INTEL_BATCH_CLIPRECTS   0x2
Functions
struct intel_be_batchbuffer *	intel_be_batchbuffer_alloc (struct intel_be_context *intel)
void	intel_be_batchbuffer_free (struct intel_be_batchbuffer *batch)
void	intel_be_batchbuffer_finish (struct intel_be_batchbuffer *batch)
struct _DriFenceObject *	intel_be_batchbuffer_flush (struct intel_be_batchbuffer *batch)
void	intel_be_batchbuffer_reset (struct intel_be_batchbuffer *batch)
void	intel_be_offset_relocation (struct intel_be_batchbuffer *batch, unsigned pre_add, struct _DriBufferObject *driBO, uint64_t val_flags, uint64_t val_mask)

---

Define Documentation

#define BATCH_RESERVED   16

Definition at line 9 of file intel_be_batchbuffer.h.

#define INTEL_BATCH_CLIPRECTS   0x2

Definition at line 15 of file intel_be_batchbuffer.h.

#define INTEL_BATCH_NO_CLIPRECTS   0x1

Definition at line 14 of file intel_be_batchbuffer.h.

#define INTEL_DEFAULT_RELOCS   100

Definition at line 11 of file intel_be_batchbuffer.h.

#define INTEL_MAX_RELOCS   400

Definition at line 12 of file intel_be_batchbuffer.h.

---

Function Documentation

struct intel_be_batchbuffer* intel_be_batchbuffer_alloc

(

struct intel_be_context *

intel

)

[read]

Definition at line 87 of file intel_be_batchbuffer.c.

References intel_be_device::batchPool, intel_be_batchbuffer::buffer, intel_be_context::device, intel_be_batchbuffer::device, driBOCreateList(), driGenBuffers(), intel_be_batchbuffer::intel, intel_be_batchbuffer_reset(), intel_be_batchbuffer::last_fence, intel_be_batchbuffer::list, and intel_be_batchbuffer::reloc.

{
   struct intel_be_batchbuffer *batch = calloc(sizeof(*batch), 1);

   batch->intel = intel;
   batch->device = intel->device;

   driGenBuffers(intel->device->batchPool, "batchbuffer", 1,
                 &batch->buffer, 4096,
                 DRM_BO_FLAG_MEM_TT | DRM_BO_FLAG_EXE, 0);
   batch->last_fence = NULL;
   batch->list = driBOCreateList(20);
   batch->reloc = NULL;
   intel_be_batchbuffer_reset(batch);
   return batch;
}

void intel_be_batchbuffer_finish

(

struct intel_be_batchbuffer *

batch

)

Definition at line 412 of file intel_be_batchbuffer.c.

References driFenceFinish(), driFenceType(), driFenceUnReference(), FALSE, and intel_be_batchbuffer_flush().

{
   struct _DriFenceObject *fence = intel_be_batchbuffer_flush(batch);
   driFenceFinish(fence, driFenceType(fence), FALSE);
   driFenceUnReference(&fence);
}

struct _DriFenceObject* intel_be_batchbuffer_flush

(

struct intel_be_batchbuffer *

batch

)

[read]

Definition at line 349 of file intel_be_batchbuffer.c.

References intel_be_batchbuffer::base, intel_be_batchbuffer::buffer, do_flush_locked(), driBOUnmap(), driFenceReference(), FALSE, intel_be_batchbuffer::flags, intel_be_context::hardware_lock, intel_be_context::hardware_locked, intel_be_context::hardware_unlock, intel_be_batchbuffer::intel, INTEL_BATCH_CLIPRECTS, intel_be_batchbuffer_reset(), intel_be_batchbuffer::last_fence, i915_batchbuffer::map, MI_BATCH_BUFFER_END, and i915_batchbuffer::ptr.

{
   struct intel_be_context *intel = batch->intel;
   unsigned int used = batch->base.ptr - batch->base.map;
   boolean was_locked = batch->intel->hardware_locked(intel);
   struct _DriFenceObject *fence;

   if (used == 0) {
      driFenceReference(batch->last_fence);
      return batch->last_fence;
   }

   /* Add the MI_BATCH_BUFFER_END.  Always add an MI_FLUSH - this is a
    * performance drain that we would like to avoid.
    */
#if 0 /* ZZZ JB: what should we do here? */
   if (used & 4) {
      ((int *) batch->base.ptr)[0] = intel->vtbl.flush_cmd();
      ((int *) batch->base.ptr)[1] = 0;
      ((int *) batch->base.ptr)[2] = MI_BATCH_BUFFER_END;
      used += 12;
   }
   else {
      ((int *) batch->base.ptr)[0] = intel->vtbl.flush_cmd();
      ((int *) batch->base.ptr)[1] = MI_BATCH_BUFFER_END;
      used += 8;
   }
#else
   if (used & 4) {
      ((int *) batch->base.ptr)[0] = ((0<<29)|(4<<23)); // MI_FLUSH;
      ((int *) batch->base.ptr)[1] = 0;
      ((int *) batch->base.ptr)[2] = (0xA<<23); // MI_BATCH_BUFFER_END;
      used += 12;
   }
   else {
      ((int *) batch->base.ptr)[0] = ((0<<29)|(4<<23)); // MI_FLUSH;
      ((int *) batch->base.ptr)[1] = (0xA<<23); // MI_BATCH_BUFFER_END;
      used += 8;
   }
#endif
   driBOUnmap(batch->buffer);
   batch->base.ptr = NULL;
   batch->base.map = NULL;

   /* TODO: Just pass the relocation list and dma buffer up to the
    * kernel.
    */
   if (!was_locked)
      intel->hardware_lock(intel);

   fence = do_flush_locked(batch, used, !(batch->flags & INTEL_BATCH_CLIPRECTS),
                           FALSE);

   if (!was_locked)
      intel->hardware_unlock(intel);

   /* Reset the buffer:
    */
   intel_be_batchbuffer_reset(batch);
   return fence;
}

void intel_be_batchbuffer_free

(

struct intel_be_batchbuffer *

batch

)

Definition at line 105 of file intel_be_batchbuffer.c.

References intel_be_batchbuffer::base, intel_be_batchbuffer::buffer, driBOFreeList(), driBOUnmap(), driBOUnReference(), driFenceFinish(), driFenceUnReference(), FALSE, intel_be_batchbuffer::last_fence, intel_be_batchbuffer::list, i915_batchbuffer::map, and intel_be_batchbuffer::reloc.

{
   if (batch->last_fence) {
      driFenceFinish(batch->last_fence,
                     DRM_FENCE_TYPE_EXE, FALSE);
      driFenceUnReference(&batch->last_fence);
   }
   if (batch->base.map) {
      driBOUnmap(batch->buffer);
      batch->base.map = NULL;
   }
   driBOUnReference(batch->buffer);
   driBOFreeList(batch->list);
   if (batch->reloc)
       free(batch->reloc);
   batch->buffer = NULL;
   free(batch);
}

void intel_be_batchbuffer_reset

(

struct intel_be_batchbuffer *

batch

)

Definition at line 21 of file intel_be_batchbuffer.c.

References i915_batchbuffer::actual_size, assert, intel_be_batchbuffer::base, BATCH_RESERVED, _drmBONode::bo_arg, intel_be_batchbuffer::buffer, intel_be_batchbuffer::dest_location, intel_be_batchbuffer::device, intel_be_batchbuffer::dirty_state, driBOAddListItem(), driBOData(), driBOKernel(), driBOMap(), driBOPoolOffset(), driBOResetList(), driBOUnrefUserList(), driReadLockKernelBO(), driReadUnlockKernelBO(), intel_be_batchbuffer::drmBOVirtual, intel_be_batchbuffer::flags, intel_be_batchbuffer::id, INTEL_DEFAULT_RELOCS, INTEL_MAX_RELOCS, intel_realloc_relocs(), intel_be_batchbuffer::list, i915_batchbuffer::map, intel_be_device::max_batch_size, intel_be_batchbuffer::node, intel_be_batchbuffer::nr_relocs, intel_be_batchbuffer::poolOffset, i915_batchbuffer::ptr, intel_be_batchbuffer::reloc, intel_be_batchbuffer::reloc_size, and i915_batchbuffer::size.

{
   /*
    * Get a new, free batchbuffer.
    */
    drmBO *bo;
    struct drm_bo_info_req *req;

   driBOUnrefUserList(batch->list);
   driBOResetList(batch->list);

   /* base.size is the size available to the i915simple driver */
   batch->base.size = batch->device->max_batch_size - BATCH_RESERVED;
   batch->base.actual_size = batch->device->max_batch_size;
   driBOData(batch->buffer, batch->base.actual_size, NULL, NULL, 0);

   /*
    * Add the batchbuffer to the validate list.
    */

   driBOAddListItem(batch->list, batch->buffer,
                    DRM_BO_FLAG_EXE | DRM_BO_FLAG_MEM_TT,
                    DRM_BO_FLAG_EXE | DRM_BO_MASK_MEM,
                    &batch->dest_location, &batch->node);

   req = &batch->node->bo_arg.d.req.bo_req;

   /*
    * Set up information needed for us to make relocations
    * relative to the underlying drm buffer objects.
    */

   driReadLockKernelBO();
   bo = driBOKernel(batch->buffer);
   req->presumed_offset = (uint64_t) bo->offset;
   req->hint = DRM_BO_HINT_PRESUMED_OFFSET;
   batch->drmBOVirtual = (uint8_t *) bo->virtual;
   driReadUnlockKernelBO();

   /*
    * Adjust the relocation buffer size.
    */

   if (batch->reloc_size > INTEL_MAX_RELOCS ||
       batch->reloc == NULL)
     intel_realloc_relocs(batch, INTEL_DEFAULT_RELOCS);

   assert(batch->reloc != NULL);
   batch->reloc[0] = 0; /* No relocs yet. */
   batch->reloc[1] = 1; /* Reloc type 1 */
   batch->reloc[2] = 0; /* Only a single relocation list. */
   batch->reloc[3] = 0; /* Only a single relocation list. */

   batch->base.map = driBOMap(batch->buffer, DRM_BO_FLAG_WRITE, 0);
   batch->poolOffset = driBOPoolOffset(batch->buffer);
   batch->base.ptr = batch->base.map;
   batch->dirty_state = ~0;
   batch->nr_relocs = 0;
   batch->flags = 0;
   batch->id = 0;//batch->intel->intelScreen->batch_id++;
}

void intel_be_offset_relocation	(	struct intel_be_batchbuffer *	batch,
		unsigned	pre_add,
		struct _DriBufferObject *	driBO,
		uint64_t	val_flags,
		uint64_t	val_mask
	)

Definition at line 125 of file intel_be_batchbuffer.c.

References intel_be_batchbuffer::base, _drmBONode::bo_arg, intel_be_batchbuffer::dest_location, driBOAddListItem(), driBOKernel(), driBOPoolOffset(), driReadLockKernelBO(), driReadUnlockKernelBO(), intel_be_batchbuffer::drmBOVirtual, i915_batchbuffer_dword(), intel_realloc_relocs(), intel_be_batchbuffer::list, intel_be_batchbuffer::nr_relocs, i915_batchbuffer::ptr, intel_be_batchbuffer::reloc, and intel_be_batchbuffer::reloc_size.

{
    int itemLoc;
    struct _drmBONode *node;
    uint32_t *reloc;
    struct drm_bo_info_req *req;

    driBOAddListItem(batch->list, driBO, val_flags, val_mask,
                     &itemLoc, &node);
    req = &node->bo_arg.d.req.bo_req;

    if (!(req->hint &  DRM_BO_HINT_PRESUMED_OFFSET)) {

        /*
         * Stop other threads from tampering with the underlying
         * drmBO while we're reading its offset.
         */

        driReadLockKernelBO();
        req->presumed_offset = (uint64_t) driBOKernel(driBO)->offset;
        driReadUnlockKernelBO();
        req->hint = DRM_BO_HINT_PRESUMED_OFFSET;
    }

    pre_add += driBOPoolOffset(driBO);

    if (batch->nr_relocs == batch->reloc_size)
        intel_realloc_relocs(batch, batch->reloc_size * 2);

    reloc = batch->reloc +
        (I915_RELOC_HEADER + batch->nr_relocs * I915_RELOC0_STRIDE);

    reloc[0] = ((uint8_t *)batch->base.ptr - batch->drmBOVirtual);
    i915_batchbuffer_dword(&batch->base, req->presumed_offset + pre_add);
    reloc[1] = pre_add;
    reloc[2] = itemLoc;
    reloc[3] = batch->dest_location;
    batch->nr_relocs++;
}

---