| /* |
| * Copyright (c) 2011 Intel Corporation. All Rights Reserved. |
| * Copyright (c) Imagination Technologies Limited, UK |
| * |
| * 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 PRECISION INSIGHT 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. |
| * |
| * Authors: |
| * Waldo Bastian <waldo.bastian@intel.com> |
| * Zeng Li <zeng.li@intel.com> |
| * Edward Lin <edward.lin@intel.com> |
| * |
| */ |
| |
| #include <unistd.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <errno.h> |
| #include <string.h> |
| #include <wsbm/wsbm_manager.h> |
| #include "psb_buffer.h" |
| #include "tng_cmdbuf.h" |
| #include "psb_def.h" |
| #include "psb_drv_debug.h" |
| #include "tng_hostcode.h" |
| #include "psb_ws_driver.h" |
| |
| #ifdef ANDROID |
| #include <linux/psb_drm.h> |
| #else |
| #include "psb_drm.h" |
| #endif |
| |
| #include "tng_trace.h" |
| |
| /* |
| * Buffer layout: |
| * cmd_base <= cmd_idx < CMD_END() == reloc_base |
| * reloc_base <= reloc_idx < RELOC_END() == (reloc_size) |
| */ |
| |
| #define RELOC_END(cmdbuf) (cmdbuf->cmd_base + cmdbuf->size) |
| #define CMD_END(cmdbuf) (cmdbuf->reloc_base) |
| #define RELOC_SIZE (0x3000) |
| #define CMD_SIZE (0x3000) |
| #define RELOC_MARGIN (0x0800) |
| #define CMD_MARGIN (0x0400) |
| #define MAX_CMD_COUNT 12 |
| #define MTX_SEG_SIZE (0x0800) |
| |
| /*! |
| ***************************************************************************** |
| * |
| * @Name Command word format |
| * |
| * @details Mask and shift values for command word |
| * |
| ****************************************************************************/ |
| |
| /* |
| * clear buffer |
| */ |
| void tng_cmdbuf_mem_unmap(tng_cmdbuf_p cmdbuf) |
| { |
| psb_buffer_unmap(&cmdbuf->frame_mem); |
| psb_buffer_unmap(&cmdbuf->jpeg_pic_params); |
| psb_buffer_unmap(&cmdbuf->jpeg_header_mem); |
| psb_buffer_unmap(&cmdbuf->jpeg_header_interface_mem); |
| return ; |
| } |
| |
| /* |
| * clear buffer |
| */ |
| static void tng_cmdbuf_clear(tng_cmdbuf_p cmdbuf, int flag) |
| { |
| switch (flag) { |
| default: |
| case 4: |
| psb_buffer_destroy(&cmdbuf->jpeg_header_mem); |
| case 3: |
| psb_buffer_destroy(&cmdbuf->jpeg_pic_params); |
| case 2: |
| case 1: |
| psb_buffer_destroy(&cmdbuf->frame_mem); |
| break; |
| } |
| |
| if (cmdbuf->size) { |
| psb_buffer_destroy(&cmdbuf->buf); |
| cmdbuf->size = 0; |
| } |
| if (cmdbuf->buffer_refs_allocated) { |
| free(cmdbuf->buffer_refs); |
| cmdbuf->buffer_refs = NULL; |
| cmdbuf->buffer_refs_allocated = 0; |
| } |
| } |
| |
| |
| /* |
| * Create command buffer |
| */ |
| |
| VAStatus tng_cmdbuf_create( |
| object_context_p obj_context, |
| psb_driver_data_p driver_data, |
| tng_cmdbuf_p cmdbuf) |
| { |
| context_ENC_p ctx = (context_ENC_p) obj_context->format_data; |
| |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| unsigned int size = CMD_SIZE + RELOC_SIZE; |
| |
| cmdbuf->size = 0; |
| cmdbuf->cmd_base = NULL; |
| cmdbuf->cmd_idx = NULL; |
| cmdbuf->reloc_base = NULL; |
| cmdbuf->reloc_idx = NULL; |
| cmdbuf->buffer_refs_count = 0; |
| cmdbuf->buffer_refs_allocated = 10; |
| cmdbuf->buffer_refs = (psb_buffer_p *) calloc(1, sizeof(psb_buffer_p) * cmdbuf->buffer_refs_allocated); |
| if (NULL == cmdbuf->buffer_refs) { |
| cmdbuf->buffer_refs_allocated = 0; |
| vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| |
| if (VA_STATUS_SUCCESS == vaStatus) { |
| vaStatus = psb_buffer_create(driver_data, size, psb_bt_cpu_only, &cmdbuf->buf); |
| cmdbuf->size = size; |
| } |
| |
| if (VA_STATUS_SUCCESS != vaStatus) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "psb buffer create 0 \n", __FUNCTION__); |
| tng_cmdbuf_clear(cmdbuf, 1); |
| free(cmdbuf->buffer_refs); |
| cmdbuf->buffer_refs = NULL; |
| cmdbuf->buffer_refs_allocated = 0; |
| return vaStatus; |
| } |
| |
| cmdbuf->mem_size = tng_align_KB(TNG_HEADER_SIZE); |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, "mem size %d\n", __FUNCTION__, cmdbuf->mem_size); |
| /* create buffer information buffer */ |
| //DEBUG-FIXME |
| //tng__alloc_init_buffer(driver_data, COMM_CMD_FRAME_BUF_NUM * cmdbuf->mem_size, psb_bt_cpu_vpu, &cmdbuf->frame_mem); |
| |
| vaStatus = psb_buffer_create(driver_data, COMM_CMD_FRAME_BUF_NUM * cmdbuf->mem_size, psb_bt_cpu_vpu, &cmdbuf->frame_mem); |
| if (VA_STATUS_SUCCESS != vaStatus) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "psb buffer create xx \n", __FUNCTION__); |
| free(cmdbuf->buffer_refs); |
| cmdbuf->buffer_refs = NULL; |
| cmdbuf->buffer_refs_allocated = 0; |
| return vaStatus; |
| } |
| /* all cmdbuf share one MTX_CURRENT_IN_PARAMS since every MB has a MTX_CURRENT_IN_PARAMS structure |
| * and filling this structure for all MB is very time-consuming |
| */ |
| |
| /* create JPEG quantization buffer */ |
| vaStatus = psb_buffer_create(driver_data, ctx->jpeg_pic_params_size, psb_bt_cpu_vpu, &cmdbuf->jpeg_pic_params); |
| if (VA_STATUS_SUCCESS != vaStatus) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "psb buffer create 1 \n", __FUNCTION__); |
| tng_cmdbuf_clear(cmdbuf, 2); |
| return vaStatus; |
| } |
| |
| /* create JPEG MTX setup buffer */ |
| vaStatus = psb_buffer_create(driver_data, ctx->jpeg_header_mem_size, psb_bt_cpu_vpu, &cmdbuf->jpeg_header_mem); |
| if (VA_STATUS_SUCCESS != vaStatus) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "psb buffer create 2 \n", __FUNCTION__); |
| tng_cmdbuf_clear(cmdbuf, 3); |
| return vaStatus; |
| } |
| |
| /* create JPEG MTX setup interface buffer */ |
| vaStatus = psb_buffer_create(driver_data, ctx->jpeg_header_interface_mem_size, psb_bt_cpu_vpu, &cmdbuf->jpeg_header_interface_mem); |
| if (VA_STATUS_SUCCESS != vaStatus) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "psb buffer create 3 \n", __FUNCTION__); |
| tng_cmdbuf_clear(cmdbuf, 4); |
| return vaStatus; |
| } |
| |
| return vaStatus; |
| } |
| |
| /* |
| * Destroy buffer |
| */ |
| void tng_cmdbuf_destroy(tng_cmdbuf_p cmdbuf) |
| { |
| psb_buffer_destroy(&cmdbuf->frame_mem); |
| psb_buffer_destroy(&cmdbuf->jpeg_header_mem); |
| psb_buffer_destroy(&cmdbuf->jpeg_pic_params); |
| psb_buffer_destroy(&cmdbuf->jpeg_header_interface_mem); |
| |
| if (cmdbuf->size) { |
| psb_buffer_destroy(&cmdbuf->buf); |
| cmdbuf->size = 0; |
| } |
| if (cmdbuf->buffer_refs_allocated) { |
| free(cmdbuf->buffer_refs); |
| cmdbuf->buffer_refs = NULL; |
| cmdbuf->buffer_refs_allocated = 0; |
| } |
| return ; |
| } |
| |
| /* |
| * Reset buffer & map |
| * |
| * Returns 0 on success |
| */ |
| int tng_cmdbuf_reset(tng_cmdbuf_p cmdbuf) |
| { |
| int ret; |
| cmdbuf->cmd_base = NULL; |
| cmdbuf->cmd_idx = NULL; |
| cmdbuf->reloc_base = NULL; |
| cmdbuf->reloc_idx = NULL; |
| |
| cmdbuf->buffer_refs_count = 0; |
| cmdbuf->frame_mem_index = 0; |
| cmdbuf->cmd_count = 0; |
| cmdbuf->mem_size = tng_align_KB(TNG_HEADER_SIZE); |
| |
| ret = psb_buffer_map(&cmdbuf->buf, &cmdbuf->cmd_base); |
| if (ret) { |
| return ret; |
| } |
| |
| cmdbuf->cmd_start = cmdbuf->cmd_base; |
| cmdbuf->cmd_idx = (IMG_UINT32 *) cmdbuf->cmd_base; |
| |
| cmdbuf->reloc_base = cmdbuf->cmd_base + CMD_SIZE; |
| cmdbuf->reloc_idx = (struct drm_psb_reloc *) cmdbuf->reloc_base; |
| |
| /* Add ourselves to the buffer list */ |
| tng_cmdbuf_buffer_ref(cmdbuf, &cmdbuf->buf); /* cmd buf == 0 */ |
| return ret; |
| } |
| |
| /* |
| * Unmap buffer |
| * |
| * Returns 0 on success |
| */ |
| int tng_cmdbuf_unmap(tng_cmdbuf_p cmdbuf) |
| { |
| cmdbuf->cmd_base = NULL; |
| cmdbuf->cmd_start = NULL; |
| cmdbuf->cmd_idx = NULL; |
| cmdbuf->reloc_base = NULL; |
| cmdbuf->reloc_idx = NULL; |
| cmdbuf->cmd_count = 0; |
| psb_buffer_unmap(&cmdbuf->buf); |
| return 0; |
| } |
| |
| |
| /* |
| * Reference an addtional buffer "buf" in the command stream |
| * Returns a reference index that can be used to refer to "buf" in |
| * relocation records, -1 on error |
| */ |
| int tng_cmdbuf_buffer_ref(tng_cmdbuf_p cmdbuf, psb_buffer_p buf) |
| { |
| int item_loc = 0; |
| |
| /*Reserve the same TTM BO twice will cause kernel lock up*/ |
| while ((item_loc < cmdbuf->buffer_refs_count) |
| && (wsbmKBufHandle(wsbmKBuf(cmdbuf->buffer_refs[item_loc]->drm_buf)) |
| != wsbmKBufHandle(wsbmKBuf(buf->drm_buf)))) |
| //while( (item_loc < cmdbuf->buffer_refs_count) && (cmdbuf->buffer_refs[item_loc] != buf) ) |
| { |
| item_loc++; |
| } |
| if (item_loc == cmdbuf->buffer_refs_count) { |
| /* Add new entry */ |
| if (item_loc >= cmdbuf->buffer_refs_allocated) { |
| /* Allocate more entries */ |
| int new_size = cmdbuf->buffer_refs_allocated + 10; |
| psb_buffer_p *new_array; |
| new_array = (psb_buffer_p *) calloc(1, sizeof(psb_buffer_p) * new_size); |
| if (NULL == new_array) { |
| return -1; /* Allocation failure */ |
| } |
| memcpy(new_array, cmdbuf->buffer_refs, sizeof(psb_buffer_p) * cmdbuf->buffer_refs_allocated); |
| free(cmdbuf->buffer_refs); |
| cmdbuf->buffer_refs_allocated = new_size; |
| cmdbuf->buffer_refs = new_array; |
| } |
| cmdbuf->buffer_refs[item_loc] = buf; |
| cmdbuf->buffer_refs_count++; |
| buf->status = psb_bs_queued; |
| } |
| return item_loc; |
| } |
| |
| /* Creates a relocation record for a DWORD in the mapped "cmdbuf" at address |
| * "addr_in_cmdbuf" |
| * The relocation is based on the device virtual address of "ref_buffer" |
| * "buf_offset" is be added to the device virtual address, and the sum is then |
| * right shifted with "align_shift". |
| * "mask" determines which bits of the target DWORD will be updated with the so |
| * constructed address. The remaining bits will be filled with bits from "background". |
| */ |
| void tng_cmdbuf_add_relocation(tng_cmdbuf_p cmdbuf, |
| IMG_UINT32 *addr_in_dst_buffer,/*addr of dst_buffer for the DWORD*/ |
| psb_buffer_p ref_buffer, |
| IMG_UINT32 buf_offset, |
| IMG_UINT32 mask, |
| IMG_UINT32 background, |
| IMG_UINT32 align_shift, |
| IMG_UINT32 dst_buffer, |
| IMG_UINT32 *start_of_dst_buffer) /*Index of the list refered by cmdbuf->buffer_refs */ |
| { |
| struct drm_psb_reloc *reloc = cmdbuf->reloc_idx; |
| uint64_t presumed_offset = wsbmBOOffsetHint(ref_buffer->drm_buf); |
| |
| reloc->where = addr_in_dst_buffer - start_of_dst_buffer; /* Offset in DWORDs */ |
| |
| reloc->buffer = tng_cmdbuf_buffer_ref(cmdbuf, ref_buffer); |
| ASSERT(reloc->buffer != -1); |
| |
| reloc->reloc_op = PSB_RELOC_OP_OFFSET; |
| #ifndef VA_EMULATOR |
| if (presumed_offset) { |
| IMG_UINT32 new_val = presumed_offset + buf_offset; |
| |
| new_val = ((new_val >> align_shift) << (align_shift << PSB_RELOC_ALSHIFT_SHIFT)); |
| new_val = (background & ~mask) | (new_val & mask); |
| *addr_in_dst_buffer = new_val; |
| } else { |
| *addr_in_dst_buffer = PSB_RELOC_MAGIC; |
| } |
| #else |
| /* indicate subscript of relocation buffer */ |
| *addr_in_dst_buffer = reloc - (struct drm_psb_reloc *)cmdbuf->reloc_base; |
| #endif |
| reloc->mask = mask; |
| reloc->shift = align_shift << PSB_RELOC_ALSHIFT_SHIFT; |
| reloc->pre_add = buf_offset; |
| reloc->background = background; |
| reloc->dst_buffer = dst_buffer; |
| cmdbuf->reloc_idx++; |
| |
| ASSERT(((void *)(cmdbuf->reloc_idx)) < RELOC_END(cmdbuf)); |
| } |
| |
| /* Prepare one command package */ |
| void tng_cmdbuf_insert_command( |
| object_context_p obj_context, |
| IMG_UINT32 stream_id, |
| IMG_UINT32 cmd_id, |
| IMG_UINT32 cmd_data, |
| psb_buffer_p data_addr, |
| IMG_UINT32 offset) |
| { |
| IMG_UINT32 cmd_word; |
| context_ENC_p ctx = (context_ENC_p) obj_context->format_data; |
| context_ENC_cmdbuf *ps_cmd = &(ctx->ctx_cmdbuf[stream_id]); |
| context_ENC_mem *ps_mem = &(ctx->ctx_mem[stream_id]); |
| tng_cmdbuf_p cmdbuf = obj_context->tng_cmdbuf; |
| psb_driver_data_p driver_data = ctx->obj_context->driver_data; |
| int interrupt_flags; |
| |
| //CMD composed by user space does not generate Interrupt |
| interrupt_flags = 0; |
| |
| assert(stream_id <= TOPAZHP_MAX_NUM_STREAMS); |
| |
| /* Write command to FIFO */ |
| { |
| cmd_word = F_ENCODE(stream_id, MTX_MSG_CORE) | |
| F_ENCODE(cmd_id, MTX_MSG_CMD_ID); |
| |
| if (cmd_id & MTX_CMDID_PRIORITY) { |
| /* increment the command counter */ |
| ps_cmd->ui32HighCmdCount++; |
| |
| /* Prepare high priority command */ |
| cmd_word |= F_ENCODE(1, MTX_MSG_PRIORITY) | |
| F_ENCODE(((ps_cmd->ui32LowCmdCount - 1) & 0xff) |(ps_cmd->ui32HighCmdCount << 8), MTX_MSG_COUNT); |
| } else { |
| /* Prepare low priority command */ |
| cmd_word |= |
| F_ENCODE(ps_cmd->ui32LowCmdCount & 0xff, MTX_MSG_COUNT); |
| ++(ps_cmd->ui32LowCmdCount); |
| } |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, |
| "%s: cmd_id = 0x%08x\n", |
| __FUNCTION__, cmd_word); |
| *cmdbuf->cmd_idx++ = cmd_word; |
| } |
| |
| /* write command word into cmdbuf */ |
| *cmdbuf->cmd_idx++ = cmd_data; |
| /* Command data address */ |
| if (data_addr) { |
| if (cmd_id == MTX_CMDID_RC_UPDATE) { |
| *cmdbuf->cmd_idx++ = (IMG_UINT32)data_addr; |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, |
| "%s: data_addr = 0x%08x\n", |
| __FUNCTION__, *(cmdbuf->cmd_idx)); |
| } else { |
| if ((cmd_id >= MTX_CMDID_SETQUANT) && (cmd_id <= MTX_CMDID_SETUP)) { |
| if (cmd_id == MTX_CMDID_ISSUEBUFF) |
| TNG_RELOC_CMDBUF_START(cmdbuf->cmd_idx, offset, data_addr); |
| else |
| tng_cmdbuf_set_phys(cmdbuf->cmd_idx, 0, data_addr, offset, 0); |
| } else { |
| #ifdef _TNG_RELOC_ |
| TNG_RELOC_CMDBUF_START(cmdbuf->cmd_idx, offset, data_addr); |
| #else |
| tng_cmdbuf_set_phys(cmdbuf->cmd_idx, 0, data_addr, offset, 0); |
| #endif |
| } |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, |
| "%s: data_addr = 0x%08x\n", |
| __FUNCTION__, *(cmdbuf->cmd_idx)); |
| cmdbuf->cmd_idx++; |
| } |
| } else { |
| *cmdbuf->cmd_idx++ = 0; |
| } |
| |
| if (cmd_id == MTX_CMDID_SW_FILL_INPUT_CTRL) { |
| *cmdbuf->cmd_idx++ = ctx->ui16IntraRefresh; |
| *cmdbuf->cmd_idx++ = ctx->sRCParams.ui32InitialQp; |
| *cmdbuf->cmd_idx++ = ctx->sRCParams.iMinQP; |
| *cmdbuf->cmd_idx++ = ctx->ctx_mem_size.mb_ctrl_in_params; |
| *cmdbuf->cmd_idx++ = ctx->ui32pseudo_rand_seed; |
| } |
| |
| if (cmd_id == MTX_CMDID_SW_UPDATE_AIR_SEND) { |
| *cmdbuf->cmd_idx++ = ctx->sAirInfo.i16AIRSkipCnt; |
| *cmdbuf->cmd_idx++ = ctx->sAirInfo.i32NumAIRSPerFrame; |
| *cmdbuf->cmd_idx++ = ctx->ctx_mem_size.mb_ctrl_in_params; |
| *cmdbuf->cmd_idx++ = ctx->ui32FrameCount[0]; |
| } |
| |
| if (cmd_id == MTX_CMDID_SW_UPDATE_AIR_CALC) { |
| *cmdbuf->cmd_idx++ = ctx->ctx_mem_size.first_pass_out_best_multipass_param; |
| *cmdbuf->cmd_idx++ = ctx->sAirInfo.i32SAD_Threshold; |
| *cmdbuf->cmd_idx++ = ctx->ui8EnableSelStatsFlags; |
| } |
| |
| /* Command data address */ |
| if (cmd_id == MTX_CMDID_SETVIDEO) { |
| *(cmdbuf->cmd_idx)++ = wsbmKBufHandle(wsbmKBuf(ctx->bufs_writeback.drm_buf)); |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, |
| "%s: cmd_param = 0x%08x\n", |
| __FUNCTION__, *(cmdbuf->cmd_idx - 1)); |
| |
| if (data_addr) |
| *(cmdbuf->cmd_idx)++ = wsbmKBufHandle(wsbmKBuf(data_addr->drm_buf)); |
| |
| *(cmdbuf->cmd_idx)++ = wsbmKBufHandle(wsbmKBuf(ps_mem->bufs_mb_ctrl_in_params.drm_buf)); |
| *(cmdbuf->cmd_idx)++ = wsbmKBufHandle(wsbmKBuf(ps_mem->bufs_first_pass_out_params.drm_buf)); |
| *(cmdbuf->cmd_idx)++ = wsbmKBufHandle(wsbmKBuf(ps_mem->bufs_first_pass_out_best_multipass_param.drm_buf)); |
| } |
| |
| if (cmd_id == MTX_CMDID_SETUP_INTERFACE) { |
| *(cmdbuf->cmd_idx)++ = wsbmKBufHandle(wsbmKBuf(ctx->bufs_writeback.drm_buf)); |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, |
| "%s: cmd_param = 0x%08x\n", |
| __FUNCTION__, *(cmdbuf->cmd_idx - 1)); |
| } |
| |
| if (cmd_id == MTX_CMDID_SHUTDOWN) { |
| *(cmdbuf->cmd_idx)++ = ctx->eCodec; |
| |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, |
| "%s: cmd_param = 0x%08x\n", |
| __FUNCTION__, *(cmdbuf->cmd_idx - 1)); |
| } |
| |
| return ; |
| } |
| |
| |
| /* |
| * Advances "obj_context" to the next cmdbuf |
| * |
| * Returns 0 on success |
| */ |
| int tng_context_get_next_cmdbuf(object_context_p obj_context) |
| { |
| tng_cmdbuf_p cmdbuf; |
| int ret; |
| |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: start obj_context->tng_cmdbuf = %x\n", __FUNCTION__, obj_context->tng_cmdbuf); |
| |
| if (obj_context->tng_cmdbuf) { |
| return 0; |
| } |
| |
| obj_context->cmdbuf_current++; |
| if (obj_context->cmdbuf_current >= TNG_MAX_CMDBUFS_ENCODE) { |
| obj_context->cmdbuf_current = 0; |
| } |
| |
| cmdbuf = obj_context->tng_cmdbuf_list[obj_context->cmdbuf_current]; |
| ret = tng_cmdbuf_reset(cmdbuf); |
| if (!ret) { |
| /* Success */ |
| obj_context->tng_cmdbuf = cmdbuf; |
| } |
| |
| // tng_cmdbuf_buffer_ref(cmdbuf, &cmdbuf->pic_params); |
| // tng_cmdbuf_buffer_ref(cmdbuf, &cmdbuf->slice_mem); |
| return ret; |
| } |
| |
| /* |
| * This is the user-space do-it-all interface to the drm cmdbuf ioctl. |
| * It allows different buffers as command- and reloc buffer. A list of |
| * cliprects to apply and whether to copy the clipRect content to all |
| * scanout buffers (damage = 1). |
| */ |
| /* |
| * Don't add debug statements in this function, it gets called with the |
| * DRM lock held and output to an X terminal can cause X to deadlock |
| */ |
| static int |
| ptgDRMCmdBuf(int fd, int ioctl_offset, psb_buffer_p *buffer_list, int buffer_count, unsigned cmdBufHandle, |
| unsigned cmdBufOffset, unsigned cmdBufSize, |
| unsigned relocBufHandle, unsigned relocBufOffset, |
| unsigned numRelocs, int __maybe_unused damage, |
| unsigned engine, unsigned fence_flags, struct psb_ttm_fence_rep *fence_rep) |
| { |
| drm_psb_cmdbuf_arg_t ca; |
| struct psb_validate_arg *arg_list; |
| int i, ret; |
| unsigned int retry = 0; |
| uint64_t mask = PSB_GPU_ACCESS_MASK; |
| |
| arg_list = (struct psb_validate_arg *) calloc(1, sizeof(struct psb_validate_arg) * buffer_count); |
| if (arg_list == NULL) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "Allocate memory failed\n"); |
| return -ENOMEM; |
| } |
| |
| for (i = 0; i < buffer_count; i++) { |
| struct psb_validate_arg *arg = &(arg_list[i]); |
| struct psb_validate_req *req = &arg->d.req; |
| |
| //memset(arg, 0, sizeof(*arg)); |
| req->next = (unsigned long) & (arg_list[i+1]); |
| |
| req->buffer_handle = wsbmKBufHandle(wsbmKBuf(buffer_list[i]->drm_buf)); |
| //req->group = 0; |
| req->set_flags = (PSB_GPU_ACCESS_READ | PSB_GPU_ACCESS_WRITE) & mask; |
| req->clear_flags = (~(PSB_GPU_ACCESS_READ | PSB_GPU_ACCESS_WRITE)) & mask; |
| #if 1 |
| req->presumed_gpu_offset = (uint64_t)wsbmBOOffsetHint(buffer_list[i]->drm_buf); |
| req->presumed_flags = PSB_USE_PRESUMED; |
| #else |
| req->presumed_flags = 0; |
| #endif |
| req->pad64 = (IMG_UINT32)buffer_list[i]->pl_flags; |
| #ifndef BAYTRAIL |
| req->unfence_flag = buffer_list[i]->unfence_flag; |
| #endif |
| } |
| arg_list[buffer_count-1].d.req.next = 0; |
| |
| memset(&ca, 0, sizeof(ca)); |
| |
| ca.buffer_list = (uint64_t)((unsigned long)arg_list); |
| ca.cmdbuf_handle = cmdBufHandle; |
| ca.cmdbuf_offset = cmdBufOffset; |
| ca.cmdbuf_size = cmdBufSize; |
| ca.reloc_handle = relocBufHandle; |
| ca.reloc_offset = relocBufOffset; |
| ca.num_relocs = numRelocs; |
| ca.engine = engine; |
| ca.fence_flags = fence_flags; |
| ca.fence_arg = (uint64_t)((unsigned long)fence_rep); |
| //ca.damage = damage; |
| |
| |
| do { |
| ret = drmCommandWrite(fd, ioctl_offset, &ca, sizeof(ca)); |
| if (ret == -EAGAIN || ret == -EBUSY) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "drmCommandWrite returns with %s, retry\n", |
| ret==-EAGAIN?"EAGAIN":"EBUSY"); |
| retry++; |
| } |
| } while (ret == -EAGAIN || ret == -EBUSY); |
| |
| if (retry > 0) |
| drv_debug_msg(VIDEO_DEBUG_ERROR,"drmCommandWrite tries %d time, finally %s with ret=%d\n", |
| retry, ret==0?"okay":"failed!", ret); |
| |
| if (ret) |
| goto out; |
| |
| for (i = 0; i < buffer_count; i++) { |
| struct psb_validate_arg *arg = &(arg_list[i]); |
| struct psb_validate_rep *rep = &arg->d.rep; |
| |
| if (!arg->handled) { |
| ret = -EFAULT; |
| goto out; |
| } |
| if (arg->ret != 0) { |
| ret = arg->ret; |
| goto out; |
| } |
| wsbmUpdateKBuf(wsbmKBuf(buffer_list[i]->drm_buf), |
| rep->gpu_offset, rep->placement, rep->fence_type_mask); |
| } |
| out: |
| free(arg_list); |
| for (i = 0; i < buffer_count; i++) { |
| /* |
| * Buffer no longer queued in userspace |
| */ |
| switch (buffer_list[i]->status) { |
| case psb_bs_queued: |
| buffer_list[i]->status = psb_bs_ready; |
| break; |
| |
| case psb_bs_abandoned: |
| psb_buffer_destroy(buffer_list[i]); |
| free(buffer_list[i]); |
| break; |
| |
| default: |
| /* Not supposed to happen */ |
| ASSERT(0); |
| } |
| } |
| |
| return ret; |
| } |
| |
| #if 0 |
| static struct _WsbmFenceObject * |
| lnc_fence_wait(psb_driver_data_p driver_data, |
| struct psb_ttm_fence_rep *fence_rep, int *status) |
| |
| { |
| struct _WsbmFenceObject *fence = NULL; |
| int ret = -1; |
| |
| /* copy fence information */ |
| if (fence_rep->error != 0) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "drm failed to create a fence" |
| " and has idled the HW\n"); |
| DEBUG_FAILURE_RET; |
| return NULL; |
| } |
| |
| fence = wsbmFenceCreate(driver_data->fence_mgr, fence_rep->fence_class, |
| fence_rep->fence_type, |
| (void *)fence_rep->handle, |
| 0); |
| if (fence) |
| *status = wsbmFenceFinish(fence, fence_rep->fence_type, 0); |
| |
| return fence; |
| } |
| #endif |
| |
| /* |
| * Submits the current cmdbuf |
| * |
| * Returns 0 on success |
| */ |
| int tng_context_submit_cmdbuf(object_context_p __maybe_unused obj_context) |
| { |
| return 0; |
| } |
| |
| |
| |
| /* |
| * FrameSkip is only meaningful for RC enabled mode |
| * Topaz raises this flag after surface N encoding is finished (vaSyncSurface gets back) |
| * then for the next encode surface N+1 (ctx->src_surface) frameskip flag is cleared in vaBeginPicuture |
| * and is always set in vaEndPicture:lnc_PatchRCMode |
| * vaQuerySurfaceStatus is supposed only to be called after vaEndPicture/vaSyncSurface, |
| * The caller should ensure the surface pertains to an encode context |
| */ |
| int tng_surface_get_frameskip(psb_driver_data_p __maybe_unused driver_data, |
| psb_surface_p surface, |
| int *frame_skip) |
| { |
| /* bit31 indicate if frameskip is already settled, it is used to record the frame skip flag for old surfaces |
| * bit31 is cleared when the surface is used as encode render target or reference/reconstrucure target |
| */ |
| if (GET_SURFACE_INFO_skipped_flag(surface) & SURFACE_INFO_SKIP_FLAG_SETTLED) { |
| *frame_skip = GET_SURFACE_INFO_skipped_flag(surface) & 1; |
| } else |
| *frame_skip = 0; |
| |
| return 0; |
| } |
| |
| VAStatus tng_set_frame_skip_flag(object_context_p obj_context) |
| { |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| context_ENC_p ctx = (context_ENC_p) obj_context->format_data; |
| context_ENC_frame_buf *ps_buf = &(ctx->ctx_frame_buf); |
| |
| if (ctx && ps_buf->previous_src_surface) { |
| SET_SURFACE_INFO_skipped_flag(ps_buf->previous_src_surface->psb_surface, 1); |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, "Detected a skipped frame for surface 0x%08x.\n", |
| ps_buf->previous_src_surface->psb_surface); |
| } |
| |
| return vaStatus; |
| } |
| |
| |
| /* |
| * Flushes all cmdbufs |
| */ |
| int tng_context_flush_cmdbuf(object_context_p obj_context) |
| { |
| tng_cmdbuf_p cmdbuf = obj_context->tng_cmdbuf; |
| psb_driver_data_p driver_data = obj_context->driver_data; |
| unsigned int fence_flags; |
| struct psb_ttm_fence_rep fence_rep; |
| unsigned int reloc_offset; |
| unsigned int num_relocs; |
| int ret; |
| unsigned int cmdbuffer_size = (unsigned int) (((unsigned char *)(cmdbuf->cmd_idx)) - cmdbuf->cmd_start); /* In bytes */ |
| |
| ASSERT(cmdbuffer_size < CMD_SIZE); |
| ASSERT((void *) cmdbuf->cmd_idx < CMD_END(cmdbuf)); |
| /* LOCK */ |
| ret = LOCK_HARDWARE(driver_data); |
| if (ret) { |
| UNLOCK_HARDWARE(driver_data); |
| DEBUG_FAILURE_RET; |
| return ret; |
| } |
| |
| /* Now calculate the total number of relocations */ |
| reloc_offset = cmdbuf->reloc_base - cmdbuf->cmd_base; |
| num_relocs = (((unsigned char *) (cmdbuf->reloc_idx)) - cmdbuf->reloc_base) / sizeof(struct drm_psb_reloc); |
| |
| tng_cmdbuf_unmap(cmdbuf); |
| |
| ASSERT(NULL == cmdbuf->reloc_base); |
| |
| #ifdef DEBUG_TRACE |
| fence_flags = 0; |
| #else |
| fence_flags = DRM_PSB_FENCE_NO_USER; |
| #endif |
| |
| |
| wsbmWriteLockKernelBO(); |
| #if 1 //_PO_DEBUG_ |
| ret = ptgDRMCmdBuf(driver_data->drm_fd, driver_data->execIoctlOffset, /* FIXME Still use ioctl cmd? */ |
| cmdbuf->buffer_refs, cmdbuf->buffer_refs_count, wsbmKBufHandle(wsbmKBuf(cmdbuf->buf.drm_buf)), |
| 0, cmdbuffer_size,/*unsigned cmdBufSize*/ |
| wsbmKBufHandle(wsbmKBuf(cmdbuf->buf.drm_buf)), reloc_offset, num_relocs, |
| 0, LNC_ENGINE_ENCODE, fence_flags, &fence_rep); /* FIXME use LNC_ENGINE_ENCODE */ |
| #endif |
| wsbmWriteUnlockKernelBO(); |
| |
| UNLOCK_HARDWARE(driver_data); |
| |
| if (ret) { |
| obj_context->tng_cmdbuf = NULL; |
| |
| DEBUG_FAILURE_RET; |
| return ret; |
| } |
| |
| #if 0 /*DEBUG_TRACE*/ |
| int status = -1; |
| struct _WsbmFenceObject *fence = NULL; |
| |
| fence = lnc_fence_wait(driver_data, &fence_rep, &status); |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, "psb_fence_wait returns: %d (fence=0x%08x)\n", status, fence); |
| |
| if (fence) |
| wsbmFenceUnreference(fence); |
| #endif |
| |
| obj_context->tng_cmdbuf = NULL; |
| |
| return 0; |
| } |
| |
| |
| void tng_cmdbuf_set_phys(IMG_UINT32 *dest_buf, int dest_num, |
| psb_buffer_p ref_buf, unsigned int ref_ofs, unsigned int ref_len) |
| { |
| int i = 0; |
| IMG_UINT32 addr_phys = (IMG_UINT32)wsbmBOOffsetHint(ref_buf->drm_buf) + ref_ofs; |
| |
| // drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: drm_buf 0x%08x, addr_phys 0x%08x, virt addr 0x%08x\n", __FUNCTION__, ref_buf->drm_buf, addr_phys, ref_buf->virtual_addr ); |
| |
| do { |
| dest_buf[i] = addr_phys; |
| ++i; |
| addr_phys += ref_len; |
| } while(i < dest_num); |
| return ; |
| } |
| |
| |
| int tng_get_pipe_number(object_context_p obj_context) |
| { |
| |
| context_ENC_p ctx = (context_ENC_p)(obj_context->format_data); |
| return ctx->ui8PipesToUse; |
| |
| } |
| |
