path: root/src/psb_cmdbuf.h

/*
 * INTEL CONFIDENTIAL
 * Copyright 2007 Intel Corporation. All Rights Reserved.
 *
 * The source code contained or described herein and all documents related to
 * the source code ("Material") are owned by Intel Corporation or its suppliers
 * or licensors. Title to the Material remains with Intel Corporation or its
 * suppliers and licensors. The Material may contain trade secrets and
 * proprietary and confidential information of Intel Corporation and its
 * suppliers and licensors, and is protected by worldwide copyright and trade
 * secret laws and treaty provisions. No part of the Material may be used,
 * copied, reproduced, modified, published, uploaded, posted, transmitted,
 * distributed, or disclosed in any way without Intel's prior express written
 * permission. 
 * 
 * No license under any patent, copyright, trade secret or other intellectual
 * property right is granted to or conferred upon you by disclosure or delivery
 * of the Materials, either expressly, by implication, inducement, estoppel or
 * otherwise. Any license under such intellectual property rights must be
 * express and approved by Intel in writing.
 */

#ifndef _PSB_CMDBUF_H_
#define _PSB_CMDBUF_H_

#include "psb_drv_video.h"
#include "psb_buffer.h"
//#include "xf86mm.h"
#include "psb_drm.h"

#include "hwdefs/lldma_defs.h"

#include <stdint.h>


#ifdef ANDROID
#define Bool int
#endif

typedef struct psb_cmdbuf_s *psb_cmdbuf_p;

struct psb_cmdbuf_s {
    struct psb_buffer_s buf;
    unsigned int size;
    struct psb_buffer_s reloc_buf;
    unsigned int reloc_size;

    struct psb_buffer_s regio_buf;
    unsigned int regio_size;
    void * regio_base;
    uint32_t *regio_idx;

    /* MTX msg */
    void *MTX_msg;
    /* Relocation records */
    void *reloc_base;
    struct drm_psb_reloc *reloc_idx;

    /* CMD stream data */
    int cmd_count;
    int deblock_count;
    int oold_count;
    void *cmd_base;
    void *cmd_start;
    uint32_t *cmd_idx;
    uint32_t *cmd_bitstream_size; /* Pointer to bitstream size field in last SR_SETUP */
    /* LLDMA records */
    void *lldma_base;
    void *lldma_idx;
    void *lldma_last; /* Pointer to last LLDMA record */

	/* Referenced buffers */	
    psb_buffer_p *buffer_refs;

    int buffer_refs_count;
    int buffer_refs_allocated;
    /* Pointer for Register commands */
    uint32_t *reg_start;
    /* Pointer for Rendec Block commands */
    uint32_t *rendec_block_start;
    uint32_t *rendec_chunk_start;
    /* Pointer for Segment commands */
    uint32_t *last_next_segment_cmd;
    uint32_t first_segment_size;
    /* Pointer for Skip block commands */
    uint32_t *skip_block_start;
    uint32_t skip_condition;
};

/*
 * Create command buffer
 */
VAStatus psb_cmdbuf_create(
    object_context_p obj_context,
    psb_driver_data_p driver_data,
    psb_cmdbuf_p cmdbuf);

/*
 * Destroy buffer
 */   
void psb_cmdbuf_destroy( psb_cmdbuf_p cmdbuf );

/*
 * Reset buffer & map
 *
 * Returns 0 on success
 */
int psb_cmdbuf_reset( psb_cmdbuf_p cmdbuf );

/*
 * Unmap buffer
 *
 * Returns 0 on success
 */
int psb_cmdbuf_unmap( psb_cmdbuf_p cmdbuf );

/*
 * Reference an addtional buffer "buf" in the command stream
 * Returns a reference index that can be used to refer to "buf" in
 * relocation records, on error -1 is returned.
 */
int psb_cmdbuf_buffer_ref( psb_cmdbuf_p cmdbuf, psb_buffer_p buf );

/* 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 psb_cmdbuf_add_relocation( psb_cmdbuf_p cmdbuf,
                                uint32_t *addr_in_cmdbuf,
                                psb_buffer_p ref_buffer,
                                uint32_t buf_offset,
                                uint32_t mask,
                                uint32_t background,
                                uint32_t align_shift,
                                uint32_t dst_buffer);

#define RELOC(dest, offset, buf)	psb_cmdbuf_add_relocation(cmdbuf, (uint32_t*) &dest, buf, offset, 0XFFFFFFFF, 0, 0, 1)
#define RELOC_MSG(dest, offset, buf)	psb_cmdbuf_add_relocation(cmdbuf, (uint32_t*) &dest, buf, offset, 0XFFFFFFFF, 0, 0, 0)
#define RELOC_SHIFT4(dest, offset, background, buf)	psb_cmdbuf_add_relocation(cmdbuf, (uint32_t*) &dest, buf, offset, 0X0FFFFFFF, background, 4, 1)
#define RELOC_REGIO(dest, offset, buf, dst)	psb_cmdbuf_add_relocation(cmdbuf, (uint32_t*) &dest, buf, offset, 0XFFFFFFFF, 0, 0, dst)

/*
 * Advances "obj_context" to the next cmdbuf
 *
 * Returns 0 on success
 */
int psb_context_get_next_cmdbuf( object_context_p obj_context );

int psb_context_submit_deblock( object_context_p obj_context );

int psb_context_submit_oold( object_context_p obj_context,
                               psb_buffer_p src_buf,
                               psb_buffer_p dst_buf,
                               psb_buffer_p colocate_buffer,
                               uint32_t picture_width_in_mb,
                               uint32_t frame_height_in_mb,
                               uint32_t field_type,
                               uint32_t chroma_offset );

int psb_context_submit_hw_deblock(object_context_p obj_context,
                                  psb_buffer_p buf_a,
                                  psb_buffer_p buf_b,
                                  psb_buffer_p colocate_buffer,
                                  uint32_t picture_widht_mb,
                                  uint32_t frame_height_mb,
                                  uint32_t rotation_flags,
				  uint32_t field_type,
				  uint32_t ext_stride_a,
                                  uint32_t chroma_offset_a,
                                  uint32_t chroma_offset_b,
                                  uint32_t is_oold);

/*
 * Submits the current cmdbuf
 *
 * Returns 0 on success
 */
int psb_context_submit_cmdbuf( object_context_p obj_context );

/*
 * Flushes the pending cmdbuf
 *
 * Return 0 on success
 */
int psb_context_flush_cmdbuf( object_context_p obj_context );

/*
 * Write a SR_SETUP_CMD referencing a bitstream buffer to the command buffer
 *
 * The slice data runs from buffer_offset_in_bytes to buffer_offset_in_bytes + size_in_bytes
 * The first bit to be processed is buffer_offset_in_bytes + offset_in_bits
 *
 * TODO: Return something
 */
void psb_cmdbuf_lldma_write_bitstream( psb_cmdbuf_p cmdbuf,
                                      psb_buffer_p bitstream_buf,
                                      uint32_t buffer_offset,
                                      uint32_t size_in_bytes,
                                      uint32_t offset_in_bits,
                                      uint32_t flags);

/* Chain a bitstream buffer to the last one */
void psb_cmdbuf_lldma_write_bitstream_chained( psb_cmdbuf_p cmdbuf,
                                      psb_buffer_p bitstream_buf,
                                      uint32_t size_in_bytes);


/* Write a LLDMA_CMD to the cmdbuf */
void psb_cmdbuf_lldma_write_cmdbuf( psb_cmdbuf_p cmdbuf,
                                 psb_buffer_p bitstream_buf,
                                 uint32_t buffer_offset,
                                 uint32_t size,
                                 uint32_t dest_offset,
                                 LLDMA_TYPE cmd);

/* Create a LLDMA record and return the offset to LLDMA record in bytes relative to the start of cmdbuf */
uint32_t psb_cmdbuf_lldma_create( psb_cmdbuf_p cmdbuf,
                                 psb_buffer_p bitstream_buf,
                                 uint32_t buffer_offset,
                                 uint32_t size,
                                 uint32_t dest_offset,
                                 LLDMA_TYPE cmd);

/*
 * Create a command to set registers
 */
void psb_cmdbuf_reg_start_block( psb_cmdbuf_p cmdbuf );

/*
 * Create a command to set registers
 */
void psb_cmdbuf_reg_start_block_flag( psb_cmdbuf_p cmdbuf, uint32_t flags );

#define psb_cmdbuf_reg_set( cmdbuf, reg, val ) \
    do { *cmdbuf->cmd_idx++ = reg; *cmdbuf->cmd_idx++ = val; } while (0)

#define psb_cmdbuf_reg_set_RELOC( cmdbuf, reg, buffer,buffer_offset)             \
    do { *cmdbuf->cmd_idx++ = reg; RELOC(*cmdbuf->cmd_idx++, buffer_offset, buffer); } while (0)

void psb_cmdbuf_reg_set_address( psb_cmdbuf_p cmdbuf, 
                                 uint32_t reg,
                                 psb_buffer_p buffer,
                                 uint32_t buffer_offset );

/*
 * Finish a command to set registers
 */
void psb_cmdbuf_reg_end_block( psb_cmdbuf_p cmdbuf );

/*
 * Create a RENDEC command block
 */
void psb_cmdbuf_rendec_start_block( psb_cmdbuf_p cmdbuf );

/*
 * Create a RENDEC command block
 */
void psb_cmdbuf_rendec_start( psb_cmdbuf_p cmdbuf, uint32_t dest_address );
/*
 * Start a new chunk in a RENDEC command block
 */
void psb_cmdbuf_rendec_start_chunk( psb_cmdbuf_p cmdbuf, uint32_t dest_address );

#define psb_cmdbuf_rendec_write( cmdbuf, val ) \
    do { *cmdbuf->cmd_idx++ = val; } while(0)

void psb_cmdbuf_rendec_write_block( psb_cmdbuf_p cmdbuf, 
                                    unsigned char *block,
                                    uint32_t size );

void psb_cmdbuf_rendec_write_address( psb_cmdbuf_p cmdbuf, 
                                      psb_buffer_p buffer,
                                      uint32_t buffer_offset );

/*
 * Finish a RENDEC chunk
 */
void psb_cmdbuf_rendec_end_chunk( psb_cmdbuf_p cmdbuf );

/*
 * Finish a RENDEC block
 */
void psb_cmdbuf_rendec_end_block( psb_cmdbuf_p cmdbuf );

/*
 * Returns the number of words left in the current segment
 */
uint32_t psb_cmdbuf_segment_space( psb_cmdbuf_p cmdbuf );

/*
 * Forwards the command buffer index to the next segment
 */
void psb_cmdbuf_next_segment( psb_cmdbuf_p cmdbuf );

typedef enum
{
        SKIP_ON_CONTEXT_SWITCH = 1,
} E_SKIP_CONDITION;

/*
 * Create a conditional SKIP block
 */
void psb_cmdbuf_skip_start_block( psb_cmdbuf_p cmdbuf, uint32_t skip_condition );

/*
 * Terminate a conditional SKIP block
 */
void psb_cmdbuf_skip_end_block( psb_cmdbuf_p cmdbuf );

/*
 * Terminate a conditional SKIP block
 */
void psb_cmdbuf_rendec_end( psb_cmdbuf_p cmdbuf );
/*
 * Write RegIO record into buffer
 */
int psb_cmdbuf_second_pass(object_context_p obj_context,
		uint32_t OperatingModeCmd,
		void	* pvParamBase,
		uint32_t PicWidthInMbs,
		uint32_t FrameHeightInMbs,
		psb_buffer_p target_buffer,
		uint32_t chroma_offset
);

#ifdef DEBUG_TRACE
/*
 * Dump contents of buffer object after command submission
 */
void psb__debug_schedule_hexdump(const char *name, psb_buffer_p buf, uint32_t offset, uint32_t size);
#endif

#endif /* _PSB_CMDBUF_H_ */