Subversion Repositories Kolibri OS

/*

 * Mesa 3-D graphics library

 *

 * Copyright (C) 2012-2013 LunarG, Inc.

 *

 * 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, sublicense,

 * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS 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.

 *

 * Authors:

 *    Chia-I Wu 

 */

#include "intel_reg.h" /* for MI_xxx */

#include "intel_winsys.h"

#include "ilo_cp.h"

/* the size of the private space */

static const int ilo_cp_private = 2;

/**

 * Dump the contents of the parser bo.  This can only be called in the flush

 * callback.

 */

void

ilo_cp_dump(struct ilo_cp *cp)

{

   ilo_printf("dumping %d bytes\n", cp->used * 4);

//   if (cp->used)

//      intel_winsys_decode_commands(cp->winsys, cp->bo, cp->used * 4);

}

/**

 * Save the command parser state for rewind.

 *

 * Note that this cannot rewind a flush, and the caller must make sure

 * that does not happend.

 */

void

ilo_cp_setjmp(struct ilo_cp *cp, struct ilo_cp_jmp_buf *jmp)

{

   jmp->id = pointer_to_intptr(cp->bo);

   jmp->size = cp->size;

   jmp->used = cp->used;

   jmp->stolen = cp->stolen;

   /* save reloc count to rewind ilo_cp_write_bo() */

   jmp->reloc_count = intel_bo_get_reloc_count(cp->bo);

}

/**

 * Rewind to the saved state.

 */

void

ilo_cp_longjmp(struct ilo_cp *cp, const struct ilo_cp_jmp_buf *jmp)

{

   if (jmp->id != pointer_to_intptr(cp->bo)) {

      assert(!"invalid use of CP longjmp");

      return;

   }

   cp->size = jmp->size;

   cp->used = jmp->used;

   cp->stolen = jmp->stolen;

   intel_bo_clear_relocs(cp->bo, jmp->reloc_count);

}

/**

 * Clear the parser buffer.

 */

static void

ilo_cp_clear_buffer(struct ilo_cp *cp)

{

   cp->cmd_cur = 0;

   cp->cmd_end = 0;

   cp->used = 0;

   cp->stolen = 0;

   /*

    * Recalculate cp->size.  This is needed not only because cp->stolen is

    * reset above, but also that ilo_cp_private are added to cp->size in

    * ilo_cp_end_buffer().

    */

   cp->size = cp->bo_size - ilo_cp_private;

}

/**

 * Add MI_BATCH_BUFFER_END to the private space of the parser buffer.

 */

static void

ilo_cp_end_buffer(struct ilo_cp *cp)

{

   /* make the private space available */

   cp->size += ilo_cp_private;

   assert(cp->used + 2 <= cp->size);

   cp->ptr[cp->used++] = MI_BATCH_BUFFER_END;

   /*

    * From the Sandy Bridge PRM, volume 1 part 1, page 107:

    *

    *     "The batch buffer must be QWord aligned and a multiple of QWords in

    *      length."

    */

   if (cp->used & 1)

      cp->ptr[cp->used++] = MI_NOOP;

}

/**

 * Upload the parser buffer to the bo.

 */

static int

ilo_cp_upload_buffer(struct ilo_cp *cp)

{

   int err;

   if (!cp->sys) {

      intel_bo_unmap(cp->bo);

      return 0;

   }

   err = intel_bo_pwrite(cp->bo, 0, cp->used * 4, cp->ptr);

   if (likely(!err && cp->stolen)) {

      const int offset = cp->bo_size - cp->stolen;

      err = intel_bo_pwrite(cp->bo, offset * 4,

            cp->stolen * 4, &cp->ptr[offset]);

   }

   return err;

}

/**

 * Reallocate the parser bo.

 */

static void

ilo_cp_realloc_bo(struct ilo_cp *cp)

{

   struct intel_bo *bo;

   /*

    * allocate the new bo before unreferencing the old one so that they

    * won't point at the same address, which is needed for jmpbuf

    */

   bo = intel_winsys_alloc_buffer(cp->winsys,

         "batch buffer", cp->bo_size * 4, 0);

   if (unlikely(!bo)) {

      /* reuse the old one */

      bo = cp->bo;

      intel_bo_reference(bo);

   }

   if (cp->bo)

      intel_bo_unreference(cp->bo);

   cp->bo = bo;

   if (!cp->sys) {

      intel_bo_map(cp->bo, true);

      cp->ptr = intel_bo_get_virtual(cp->bo);

   }

}

/**

 * Execute the parser bo.

 */

static int

ilo_cp_exec_bo(struct ilo_cp *cp)

{

   const bool do_exec = !(ilo_debug & ILO_DEBUG_NOHW);

   struct intel_context *ctx;

   unsigned long flags;

   int err;

   switch (cp->ring) {

   case ILO_CP_RING_RENDER:

      ctx = cp->render_ctx;

      flags = INTEL_EXEC_RENDER;

      break;

   case ILO_CP_RING_BLT:

      ctx = NULL;

      flags = INTEL_EXEC_BLT;

      break;

   default:

      ctx = NULL;

      flags = 0;

      break;

   }

   flags |= cp->one_off_flags;

   if (likely(do_exec))

      err = intel_bo_exec(cp->bo, cp->used * 4, ctx, flags);

   else

      err = 0;

   cp->one_off_flags = 0;

   return err;

}

/**

 * Flush the command parser and execute the commands.  When the parser buffer

 * is empty, the callback is not invoked.

 */

void

ilo_cp_flush(struct ilo_cp *cp)

{

   int err;

   ilo_cp_set_owner(cp, NULL, 0);

   /* sanity check */

   assert(cp->bo_size == cp->size + cp->stolen + ilo_cp_private);

   if (!cp->used) {

      /* return the space stolen and etc. */

      ilo_cp_clear_buffer(cp);

      return;

   }

   ilo_cp_end_buffer(cp);

   /* upload and execute */

   err = ilo_cp_upload_buffer(cp);

   if (likely(!err))

      err = ilo_cp_exec_bo(cp);

   if (likely(!err && cp->flush_callback))

      cp->flush_callback(cp, cp->flush_callback_data);

   ilo_cp_clear_buffer(cp);

   ilo_cp_realloc_bo(cp);

}

/**

 * Destroy the command parser.

 */

void

ilo_cp_destroy(struct ilo_cp *cp)

{

   if (cp->bo) {

      if (!cp->sys)

         intel_bo_unmap(cp->bo);

      intel_bo_unreference(cp->bo);

   }

   if (cp->render_ctx)

      intel_winsys_destroy_context(cp->winsys, cp->render_ctx);

   FREE(cp->sys);

   FREE(cp);

}

/**

 * Create a command parser.

 */

struct ilo_cp *

ilo_cp_create(struct intel_winsys *winsys, bool direct_map)

{

   struct ilo_cp *cp;

   cp = CALLOC_STRUCT(ilo_cp);

   if (!cp)

      return NULL;

   cp->winsys = winsys;

   cp->render_ctx = intel_winsys_create_context(winsys);

   cp->ring = ILO_CP_RING_RENDER;

   cp->no_implicit_flush = false;

   cp->bo_size = 8192;

   if (!direct_map) {

      cp->sys = MALLOC(cp->bo_size * 4);

      if (!cp->sys) {

         FREE(cp);

         return NULL;

      }

      cp->ptr = cp->sys;

   }

   ilo_cp_realloc_bo(cp);

   if (!cp->bo) {

      FREE(cp->sys);

      FREE(cp);

      return NULL;

   }

   ilo_cp_clear_buffer(cp);

   return cp;

}