851 lines
30 KiB
C
851 lines
30 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
/*
|
|
* Copyright (c) 2015 MediaTek Inc.
|
|
*/
|
|
|
|
#ifndef __CMDQ_RECORD_H__
|
|
#define __CMDQ_RECORD_H__
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/soc/mediatek/mtk-cmdq-ext.h>
|
|
|
|
#include "mdp_def.h"
|
|
#include "cmdq_helper_ext.h"
|
|
|
|
enum CMDQ_STACK_TYPE_ENUM {
|
|
CMDQ_STACK_NULL = -1,
|
|
CMDQ_STACK_TYPE_IF = 0,
|
|
CMDQ_STACK_TYPE_ELSE = 1,
|
|
CMDQ_STACK_TYPE_WHILE = 2,
|
|
CMDQ_STACK_TYPE_BREAK = 3,
|
|
CMDQ_STACK_TYPE_CONTINUE = 4,
|
|
CMDQ_STACK_TYPE_DO_WHILE = 5,
|
|
};
|
|
|
|
#define CMDQ_DATA_BIT (62)
|
|
#define CMDQ_BIT_VALUE (0LL)
|
|
#define CMDQ_BIT_VAR (1LL)
|
|
#define CMDQ_TASK_CPR_INITIAL_VALUE (0)
|
|
#define CMDQ_REC_DEFAULT_PRIORITY (100)
|
|
#define CMDQ_REC_MAX_PRIORITY (0x7FFFFFFF)
|
|
|
|
struct cmdq_stack_node {
|
|
u32 position;
|
|
enum CMDQ_STACK_TYPE_ENUM stack_type;
|
|
struct cmdq_stack_node *next;
|
|
};
|
|
|
|
struct cmdq_user_req {
|
|
u32 reg_count;
|
|
u32 user_token;
|
|
};
|
|
|
|
#define cmdqBackupSlotHandle dma_addr_t
|
|
|
|
/* Create command queue recorder handle
|
|
* Parameter:
|
|
* pHandle: pointer to retrieve the handle
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_task_create(enum CMDQ_SCENARIO_ENUM scenario,
|
|
struct cmdqRecStruct **pHandle);
|
|
s32 cmdqRecCreate(enum CMDQ_SCENARIO_ENUM scenario,
|
|
struct cmdqRecStruct **pHandle);
|
|
s32 cmdq_task_duplicate(struct cmdqRecStruct *handle,
|
|
struct cmdqRecStruct **handle_out);
|
|
|
|
/* Set engine flag for command queue picking HW thread
|
|
* Parameter:
|
|
* pHandle: pointer to retrieve the handle
|
|
* engineFlag: Flag use to identify which HW module can be accessed
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_task_set_engine(struct cmdqRecStruct *handle,
|
|
u64 engineFlag);
|
|
s32 cmdqRecSetEngine(struct cmdqRecStruct *handle,
|
|
u64 engineFlag);
|
|
|
|
/* Reset command queue recorder commands
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_task_reset(struct cmdqRecStruct *handle);
|
|
s32 cmdqRecReset(struct cmdqRecStruct *handle);
|
|
|
|
void cmdq_task_set_timeout(struct cmdqRecStruct *handle, u32 timeout);
|
|
|
|
/* Configure as secure task
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* is_secure: true, execute the command in secure world
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*
|
|
* Note:
|
|
* a. Secure CMDQ support when t-base enabled only
|
|
* b. By default struct cmdqRecStruct records a normal command,
|
|
* please call cmdq_task_set_secure to set command as SECURE
|
|
* after cmdq_task_reset
|
|
*/
|
|
s32 cmdq_task_set_secure(struct cmdqRecStruct *handle, const bool is_secure);
|
|
s32 cmdqRecSetSecure(struct cmdqRecStruct *handle, const bool is_secure);
|
|
|
|
/* query handle is secure task or not
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* Return:
|
|
* 0 for false (not secure) and 1 for true (is secure)
|
|
*/
|
|
s32 cmdq_task_is_secure(struct cmdqRecStruct *handle);
|
|
s32 cmdqRecIsSecure(struct cmdqRecStruct *handle);
|
|
|
|
/* Add DPAC protection flag
|
|
* Parameter:
|
|
* Note:
|
|
* a. Secure CMDQ support when t-base enabled only
|
|
* b. after reset handle, user have to specify protection flag again
|
|
*/
|
|
s32 cmdq_task_secure_enable_dapc(struct cmdqRecStruct *handle,
|
|
const u64 engineFlag);
|
|
s32 cmdqRecSecureEnableDAPC(struct cmdqRecStruct *handle,
|
|
const u64 engineFlag);
|
|
|
|
/* Add flag for M4U security ports
|
|
* Parameter:
|
|
* Note:
|
|
* a. Secure CMDQ support when t-base enabled only
|
|
* b. after reset handle, user have to specify protection flag again
|
|
*/
|
|
s32 cmdq_task_secure_enable_port_security(struct cmdqRecStruct *handle,
|
|
const u64 engineFlag);
|
|
s32 cmdqRecSecureEnablePortSecurity(struct cmdqRecStruct *handle,
|
|
const u64 engineFlag);
|
|
|
|
/* Assign secure metadata for client driver */
|
|
s32 cmdq_task_set_secure_meta(struct cmdqRecStruct *handle,
|
|
enum cmdq_sec_rec_meta_type type, void *meta, u32 size);
|
|
|
|
/* Append write command to the recorder
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* addr: the specified target register physical address
|
|
* argument / value: the specified target register value
|
|
* mask: the specified target register mask
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_write_reg(struct cmdqRecStruct *handle, u32 addr,
|
|
CMDQ_VARIABLE argument, u32 mask);
|
|
s32 cmdqRecWrite(struct cmdqRecStruct *handle, u32 addr, u32 value, u32 mask);
|
|
|
|
/* Append write command to the update secure buffer address in secure path
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* addr: the specified register physical address about module src/dst
|
|
* buffer address
|
|
* type: base handle type
|
|
* base handle: secure handle of a secure mememory
|
|
* offset: offset related to base handle
|
|
* (secure buffer = addr(base_handle) + offset)
|
|
* size: secure buffer size
|
|
* mask: 0xFFFF_FFFF
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
* Note:
|
|
* support only when secure OS enabled
|
|
*/
|
|
s32 cmdq_op_write_reg_secure(struct cmdqRecStruct *handle, u32 addr,
|
|
enum CMDQ_SEC_ADDR_METADATA_TYPE type, u64 baseHandle,
|
|
u32 offset, u32 size, u32 port);
|
|
s32 cmdqRecWriteSecure(struct cmdqRecStruct *handle,
|
|
u32 addr, enum CMDQ_SEC_ADDR_METADATA_TYPE type,
|
|
u64 baseHandle, u32 offset, u32 size, u32 port);
|
|
|
|
/* Append poll command to the recorder
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* addr: the specified register physical address
|
|
* value: the required register value
|
|
* mask: the required register mask
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_poll(struct cmdqRecStruct *handle, u32 addr, u32 value, u32 mask);
|
|
s32 cmdqRecPoll(struct cmdqRecStruct *handle, u32 addr, u32 value, u32 mask);
|
|
|
|
/* Append wait command to the recorder
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* event: the desired event type to "wait and CLEAR"
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_wait(struct cmdqRecStruct *handle, enum cmdq_event event);
|
|
s32 cmdqRecWait(struct cmdqRecStruct *handle, enum cmdq_event event);
|
|
|
|
/* like cmdq_op_wait, but won't clear the event after
|
|
* leaving wait state.
|
|
*
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* event: the desired event type wait for
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_wait_no_clear(struct cmdqRecStruct *handle,
|
|
enum cmdq_event event);
|
|
s32 cmdqRecWaitNoClear(struct cmdqRecStruct *handle,
|
|
enum cmdq_event event);
|
|
|
|
/* Unconditionally set to given event to 0.
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* event: the desired event type to set
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_clear_event(struct cmdqRecStruct *handle,
|
|
enum cmdq_event event);
|
|
s32 cmdqRecClearEventToken(struct cmdqRecStruct *handle,
|
|
enum cmdq_event event);
|
|
|
|
/* Unconditionally set to given event to 1.
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* event: the desired event type to set
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_set_event(struct cmdqRecStruct *handle,
|
|
enum cmdq_event event);
|
|
s32 cmdqRecSetEventToken(struct cmdqRecStruct *handle,
|
|
enum cmdq_event event);
|
|
|
|
/* Replace overwite CPR parameters of arg_a.
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* index: the index of instruction to replace
|
|
* new_arg_a: the desired cpr value to overwrite arg_a
|
|
* new_arg_b: the desired cpr value to overwrite arg_b
|
|
* new_arg_c: the desired cpr value to overwrite arg_c
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_replace_overwrite_cpr(struct cmdqRecStruct *handle, u32 index,
|
|
s32 new_arg_a, s32 new_arg_b, s32 new_arg_c);
|
|
|
|
/* Read a register value to a CMDQ general purpose register(GPR)
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* hw_addr: register address to read from
|
|
* dst_data_reg: CMDQ GPR to write to
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_read_to_data_register(struct cmdqRecStruct *handle,
|
|
u32 hw_addr, enum cmdq_gpr_reg dst_data_reg);
|
|
s32 cmdqRecReadToDataRegister(struct cmdqRecStruct *handle, u32 hw_addr,
|
|
enum cmdq_gpr_reg dst_data_reg);
|
|
|
|
/* Write a register value from a CMDQ general purpose register(GPR)
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* src_data_reg: CMDQ GPR to read from
|
|
* hw_addr: register address to write to
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_write_from_data_register(struct cmdqRecStruct *handle,
|
|
enum cmdq_gpr_reg src_data_reg, u32 hw_addr);
|
|
s32 cmdqRecWriteFromDataRegister(struct cmdqRecStruct *handle,
|
|
enum cmdq_gpr_reg src_data_reg, u32 hw_addr);
|
|
|
|
s32 cmdq_op_get_event(struct cmdqRecStruct *handle, enum cmdq_event event);
|
|
s32 cmdq_op_set_event_readback(struct cmdqRecStruct *handle, enum cmdq_event event);
|
|
s32 cmdq_op_wait_event_readback(struct cmdqRecStruct *handle, enum cmdq_event event);
|
|
|
|
struct cmdq_command_buffer {
|
|
void *va_base;
|
|
u32 avail_buf_size;
|
|
};
|
|
s32 cmdq_op_poll_ex(struct cmdqRecStruct *handle,
|
|
struct cmdq_command_buffer *cmd_buf, u32 addr,
|
|
CMDQ_VARIABLE value, u32 mask, u32 gpr);
|
|
s32 cmdq_op_assign_reg_idx_ex(struct cmdqRecStruct *handle,
|
|
struct cmdq_command_buffer *cmd_buf, u16 reg_idx, CMDQ_VARIABLE value);
|
|
s32 cmdq_op_read_reg_to_mem_ex(struct cmdqRecStruct *handle,
|
|
struct cmdq_command_buffer *cmd_buf,
|
|
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 addr);
|
|
s32 cmdq_op_write_reg_ex(struct cmdqRecStruct *handle,
|
|
struct cmdq_command_buffer *cmd_buf, u32 addr,
|
|
CMDQ_VARIABLE value, u32 mask);
|
|
s32 cmdq_op_wait_ex(struct cmdqRecStruct *handle,
|
|
struct cmdq_command_buffer *cmd_buf, enum cmdq_event event);
|
|
s32 cmdq_op_wait_no_clear_ex(struct cmdqRecStruct *handle,
|
|
struct cmdq_command_buffer *cmd_buf, enum cmdq_event event);
|
|
s32 cmdq_op_clear_event_ex(struct cmdqRecStruct *handle,
|
|
struct cmdq_command_buffer *cmd_buf, enum cmdq_event event);
|
|
s32 cmdq_op_set_event_ex(struct cmdqRecStruct *handle,
|
|
struct cmdq_command_buffer *cmd_buf, enum cmdq_event event);
|
|
s32 cmdq_op_acquire_ex(struct cmdqRecStruct *handle,
|
|
struct cmdq_command_buffer *cmd_buf, enum cmdq_event event);
|
|
s32 cmdq_op_write_from_reg_ex(struct cmdqRecStruct *handle,
|
|
struct cmdq_command_buffer *cmd_buf, u32 write_reg, u32 from_reg);
|
|
s32 cmdq_handle_flush_cmd_buf(struct cmdqRecStruct *handle,
|
|
struct cmdq_command_buffer *cmd_buf);
|
|
s32 cmdq_alloc_write_addr(u32 count, dma_addr_t *paStart, u32 clt, void *fp);
|
|
s32 cmdq_free_write_addr(dma_addr_t paStart, u32 clt);
|
|
s32 cmdq_free_write_addr_by_node(u32 clt, void *fp);
|
|
|
|
/* Allocate 32-bit register backup slot
|
|
*/
|
|
s32 cmdq_alloc_mem(cmdqBackupSlotHandle *p_h_backup_slot, u32 slotCount);
|
|
s32 cmdqBackupAllocateSlot(cmdqBackupSlotHandle *p_h_backup_slot,
|
|
u32 slotCount);
|
|
|
|
/* Read 32-bit register backup slot by index
|
|
*/
|
|
s32 cmdq_cpu_read_mem(cmdqBackupSlotHandle h_backup_slot, u32 slot_index,
|
|
u32 *value);
|
|
s32 cmdqBackupReadSlot(cmdqBackupSlotHandle h_backup_slot, u32 slot_index,
|
|
u32 *value);
|
|
|
|
/* Use CPU to write value into 32-bit register backup slot by index directly.
|
|
*/
|
|
s32 cmdq_cpu_write_mem(cmdqBackupSlotHandle h_backup_slot,
|
|
u32 slot_index, u32 value);
|
|
s32 cmdqBackupWriteSlot(cmdqBackupSlotHandle h_backup_slot, u32 slot_index,
|
|
u32 value);
|
|
|
|
|
|
/* Free allocated backup slot. DO NOT free them before corresponding
|
|
* task finishes. Becareful on AsyncFlush use cases.
|
|
*/
|
|
s32 cmdq_free_mem(cmdqBackupSlotHandle h_backup_slot);
|
|
s32 cmdqBackupFreeSlot(cmdqBackupSlotHandle h_backup_slot);
|
|
|
|
|
|
/* Insert instructions to backup given 32-bit HW register
|
|
* to a backup slot.
|
|
* You can use cmdq_cpu_read_mem() to retrieve the result
|
|
* AFTER cmdq_task_flush() returns, or INSIDE the callback of
|
|
* cmdq_task_flush_async_callback().
|
|
*/
|
|
s32 cmdq_op_read_reg_to_mem(struct cmdqRecStruct *handle,
|
|
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 addr);
|
|
s32 cmdqRecBackupRegisterToSlot(struct cmdqRecStruct *handle,
|
|
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 addr);
|
|
|
|
/* Insert instructions to write 32-bit HW register
|
|
* from a backup slot.
|
|
* You can use cmdq_cpu_read_mem() to retrieve the result
|
|
* AFTER cmdq_task_flush() returns, or INSIDE the callback of
|
|
* cmdq_task_flush_async_callback().
|
|
*/
|
|
s32 cmdq_op_read_mem_to_reg(struct cmdqRecStruct *handle,
|
|
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 addr);
|
|
s32 cmdqRecBackupWriteRegisterFromSlot(struct cmdqRecStruct *handle,
|
|
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 addr);
|
|
|
|
/* Insert instructions to update slot with given 32-bit value
|
|
* You can use cmdq_cpu_read_mem() to retrieve the result
|
|
* AFTER cmdq_task_flush() returns, or INSIDE the callback of
|
|
* cmdq_task_flush_async_callback().
|
|
*/
|
|
s32 cmdq_op_write_mem(struct cmdqRecStruct *handle,
|
|
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 value);
|
|
s32 cmdqRecBackupUpdateSlot(struct cmdqRecStruct *handle,
|
|
cmdqBackupSlotHandle h_backup_slot, u32 slot_index, u32 value);
|
|
|
|
s32 cmdq_op_finalize_command(struct cmdqRecStruct *handle, bool loop);
|
|
|
|
void cmdq_task_prepare(struct cmdqRecStruct *handle);
|
|
void cmdq_task_unprepare(struct cmdqRecStruct *handle);
|
|
|
|
s32 cmdq_task_update_property(struct cmdqRecStruct *handle,
|
|
void *prop_addr, u32 prop_size);
|
|
|
|
/* Trigger CMDQ to execute the recorded commands
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
* Note:
|
|
* This is a synchronous function. When the function
|
|
* returned, the recorded commands have been done.
|
|
*/
|
|
s32 cmdq_task_flush(struct cmdqRecStruct *handle);
|
|
s32 cmdqRecFlush(struct cmdqRecStruct *handle);
|
|
|
|
/* Flush the command; Also at the end of the command, backup registers
|
|
* appointed by addrArray.
|
|
*/
|
|
s32 cmdq_task_append_backup_reg(struct cmdqRecStruct *handle,
|
|
u32 reg_count, u32 *addrs);
|
|
s32 cmdq_task_flush_and_read_register(struct cmdqRecStruct *handle,
|
|
u32 reg_count, u32 *addrs, u32 *values_out);
|
|
s32 cmdqRecFlushAndReadRegister(struct cmdqRecStruct *handle,
|
|
u32 reg_count, u32 *addrs, u32 *values_out);
|
|
|
|
/* Trigger CMDQ to asynchronously execute the recorded commands
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* Return:
|
|
* 0 for successfully start execution; else the error code is returned
|
|
* Note:
|
|
* This is an ASYNC function. When the function
|
|
* returned, it may or may not be finished. There is no way to retrieve
|
|
* the result.
|
|
*/
|
|
s32 cmdq_task_flush_async(struct cmdqRecStruct *handle);
|
|
s32 cmdqRecFlushAsync(struct cmdqRecStruct *handle);
|
|
|
|
s32 cmdq_task_flush_async_callback(struct cmdqRecStruct *handle,
|
|
CmdqAsyncFlushCB callback, u64 user_data);
|
|
s32 cmdq_task_flush_async_destroy(struct cmdqRecStruct *handle);
|
|
s32 cmdqRecFlushAsyncCallback(struct cmdqRecStruct *handle,
|
|
CmdqAsyncFlushCB callback, u64 user_data);
|
|
|
|
/* Trigger CMDQ to execute the recorded commands in loop.
|
|
* each loop completion generates callback in interrupt context.
|
|
*
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* irqCallback: this CmdqInterruptCB callback is called after each loop
|
|
* completion.
|
|
* data: user data, this will pass back to irqCallback
|
|
* hLoop: output, a handle used to stop this loop.
|
|
*
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*
|
|
* Note:
|
|
* This is an asynchronous function. When the function
|
|
* returned, the thread has started. Return -1 in irqCallback to stop it.
|
|
*/
|
|
s32 cmdq_task_start_loop(struct cmdqRecStruct *handle);
|
|
|
|
/* Unconditionally stops the loop thread.
|
|
* Must call after cmdq_task_start_loop().
|
|
*/
|
|
s32 cmdq_task_stop_loop(struct cmdqRecStruct *handle);
|
|
|
|
/* returns current count of instructions in given handle
|
|
*/
|
|
s32 cmdq_task_get_inst_cnt(struct cmdqRecStruct *handle);
|
|
s32 cmdqRecGetInstructionCount(struct cmdqRecStruct *handle);
|
|
|
|
/* Record timestamp while CMDQ HW executes here
|
|
* This is for prfiling purpose.
|
|
*
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_profile_marker(struct cmdqRecStruct *handle, const char *tag);
|
|
s32 cmdqRecProfileMarker(struct cmdqRecStruct *handle, const char *tag);
|
|
|
|
/* Dump command buffer to kernel log
|
|
* This is for debugging purpose.
|
|
*/
|
|
s32 cmdqRecDumpCommand(struct cmdqRecStruct *handle);
|
|
|
|
/* Destroy command queue recorder handle
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
*/
|
|
void cmdq_ref_init(struct cmdqRecStruct *handle);
|
|
void cmdq_task_use(struct cmdqRecStruct *handle);
|
|
void cmdq_task_destroy(struct cmdqRecStruct *handle);
|
|
void cmdq_task_destroy_handle(struct kref *kref);
|
|
void cmdqRecDestroy(struct cmdqRecStruct *handle);
|
|
|
|
/* Change instruction of index to NOP instruction
|
|
* Current NOP is [JUMP + 8]
|
|
*
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* index: the index of replaced instruction (start from 0)
|
|
* Return:
|
|
* > 0 (index) for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_set_nop(struct cmdqRecStruct *handle, u32 index);
|
|
s32 cmdqRecSetNOP(struct cmdqRecStruct *handle, u32 index);
|
|
|
|
/* Query offset of instruction by instruction name
|
|
*
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* startIndex: Query offset from "startIndex" of instruction (start from 0)
|
|
* opCode: instruction name you can use the following 6 instruction names:
|
|
* CMDQ_CODE_WFE: create via cmdq_op_wait()
|
|
* CMDQ_CODE_SET_TOKEN: create via cmdq_op_set_event()
|
|
* CMDQ_CODE_WAIT_NO_CLEAR: create via cmdq_op_wait_no_clear()
|
|
* CMDQ_CODE_CLEAR_TOKEN: create via cmdq_op_clear_event()
|
|
* event: the desired event type to set, clear, or wait
|
|
* Return:
|
|
* > 0 (index) for offset of instruction; else the error code is returned
|
|
*/
|
|
s32 cmdq_task_query_offset(struct cmdqRecStruct *handle, u32 startIndex,
|
|
const enum cmdq_code opCode, enum cmdq_event event);
|
|
s32 cmdqRecQueryOffset(struct cmdqRecStruct *handle, u32 startIndex,
|
|
const enum cmdq_code opCode, enum cmdq_event event);
|
|
|
|
/* acquire resource by resourceEvent
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* resourceEvent: the event of resource to control in GCE thread
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
* Note:
|
|
* mutex protected, be careful
|
|
*/
|
|
s32 cmdq_resource_acquire(struct cmdqRecStruct *handle,
|
|
enum cmdq_event resourceEvent);
|
|
s32 cmdqRecAcquireResource(struct cmdqRecStruct *handle,
|
|
enum cmdq_event resourceEvent);
|
|
|
|
/* acquire resource by resourceEvent and ALSO ADD write instruction to use
|
|
* resource
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* resourceEvent: the event of resource to control in GCE thread
|
|
* addr, value, mask: same as cmdq_op_write_reg
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
* Note:
|
|
* mutex protected, be careful
|
|
* Order: CPU clear resourceEvent at first, then add write instruction
|
|
*/
|
|
s32 cmdq_resource_acquire_and_write(struct cmdqRecStruct *handle,
|
|
enum cmdq_event resourceEvent, u32 addr, u32 value, u32 mask);
|
|
s32 cmdqRecWriteForResource(struct cmdqRecStruct *handle,
|
|
enum cmdq_event resourceEvent, u32 addr, u32 value, u32 mask);
|
|
|
|
/* Release resource by ADD INSTRUCTION to set event
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* resourceEvent: the event of resource to control in GCE thread
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
* Note:
|
|
* mutex protected, be careful
|
|
* Remember to flush handle after this API to release resource via GCE
|
|
*/
|
|
s32 cmdq_resource_release(struct cmdqRecStruct *handle,
|
|
enum cmdq_event resourceEvent);
|
|
s32 cmdqRecReleaseResource(struct cmdqRecStruct *handle,
|
|
enum cmdq_event resourceEvent);
|
|
|
|
/* Release resource by ADD INSTRUCTION to set event
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* resourceEvent: the event of resource to control in GCE thread
|
|
* addr, value, mask: same as cmdq_op_write_reg
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
* Note:
|
|
* mutex protected, be careful
|
|
* Order: Add add write instruction at first, then set resourceEvent
|
|
* instruction
|
|
* Remember to flush handle after this API to release resource via GCE
|
|
*/
|
|
s32 cmdq_resource_release_and_write(struct cmdqRecStruct *handle,
|
|
enum cmdq_event resourceEvent, u32 addr, u32 value, u32 mask);
|
|
s32 cmdqRecWriteAndReleaseResource(struct cmdqRecStruct *handle,
|
|
enum cmdq_event resourceEvent, u32 addr, u32 value, u32 mask);
|
|
|
|
s32 cmdq_task_create_delay_thread_dram(void **pp_delay_thread_buffer,
|
|
u32 *buffer_size);
|
|
s32 cmdq_task_create_delay_thread_sram(void **pp_delay_thread_buffer,
|
|
u32 *buffer_size, u32 *cpr_offset);
|
|
|
|
|
|
/* Initialize the logical variable
|
|
* Parameter:
|
|
* arg: the variable you want to Initialize
|
|
*/
|
|
void cmdq_op_init_variable(CMDQ_VARIABLE *arg);
|
|
|
|
/* Initialize the logical variable
|
|
* Parameter:
|
|
* arg: the variable you want to Initialize
|
|
* cpr_offset: the cpr offset you want to use
|
|
*/
|
|
void cmdq_op_init_global_cpr_variable(CMDQ_VARIABLE *arg, u32 cpr_offset);
|
|
|
|
/* Append logic command for assign
|
|
* arg_out = arg_b
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* arg_out: the output value save in GCE CPR
|
|
* arg_in: the specified GCE CPR or value
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_assign(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
|
|
CMDQ_VARIABLE arg_in);
|
|
|
|
/* Append logic command for addition
|
|
* arg_out = arg_b + arg_c
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* arg_out: the output value save in GCE CPR
|
|
* arg_b: the value who use to do logical operation
|
|
* arg_c: the value who use to do logical operation
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_add(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
|
|
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
|
|
|
|
/* Append logic command for subtraction
|
|
* arg_out = arg_b - arg_c
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* arg_out: the output value save in GCE CPR
|
|
* arg_b: the value who use to do logical operation
|
|
* arg_c: the value who use to do logical operation
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_subtract(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
|
|
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
|
|
|
|
/* Append logic command for multiplication
|
|
* arg_out = arg_b * arg_c
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* arg_out: the output value save in GCE CPR
|
|
* arg_b: the value who use to do logical operation
|
|
* arg_c: the value who use to do logical operation
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_multiply(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
|
|
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
|
|
|
|
/* Append logic command for exclusive or operation
|
|
* arg_out = arg_b ^ arg_c
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* arg_out: the output value save in GCE CPR
|
|
* arg_b: the value who use to do logical operation
|
|
* arg_c: the value who use to do logical operation
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_xor(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
|
|
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
|
|
|
|
/* Append logic command for not operation
|
|
* arg_out = ~arg_b
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* arg_out: the output value save in GCE CPR
|
|
* arg_b: the value who use to do logical operation
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_not(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
|
|
CMDQ_VARIABLE arg_b);
|
|
|
|
/* Append logic command for or operation
|
|
* arg_out = arg_b | arg_c
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* arg_out: the output value save in GCE CPR
|
|
* arg_b: the value who use to do logical operation
|
|
* arg_c: the value who use to do logical operation
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_or(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
|
|
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
|
|
|
|
/* Append logic command for or operation
|
|
* arg_out = arg_b & arg_c
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* arg_out: the output value save in GCE CPR
|
|
* arg_b: the value who use to do logical operation
|
|
* arg_c: the value who use to do logical operation
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_and(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
|
|
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
|
|
|
|
/* Append logic command for left shift operation
|
|
* arg_out = arg_b << arg_c
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* arg_out: the output value save in GCE CPR
|
|
* arg_b: the value who use to do logical operation
|
|
* arg_c: the value who use to do logical operation
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_left_shift(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
|
|
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
|
|
|
|
/* Append logic command for left right operation
|
|
* arg_out = arg_b >> arg_c
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* arg_out: the output value save in GCE CPR
|
|
* arg_b: the value who use to do logical operation
|
|
* arg_c: the value who use to do logical operation
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_right_shift(struct cmdqRecStruct *handle, CMDQ_VARIABLE *arg_out,
|
|
CMDQ_VARIABLE arg_b, CMDQ_VARIABLE arg_c);
|
|
|
|
/* Append commands for delay (micro second)
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* delay_time: delay time in us
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_delay_us(struct cmdqRecStruct *handle, u32 delay_time);
|
|
s32 cmdq_op_backup_CPR(struct cmdqRecStruct *handle, CMDQ_VARIABLE cpr,
|
|
cmdqBackupSlotHandle h_backup_slot, u32 slot_index);
|
|
s32 cmdq_op_backup_TPR(struct cmdqRecStruct *handle,
|
|
cmdqBackupSlotHandle h_backup_slot, u32 slot_index);
|
|
|
|
/* Append if statement command
|
|
* if (arg_b condition arg_c)
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* arg_b: the value who use to do conditional operation
|
|
* arg_condition: conditional operator
|
|
* arg_c: the value who use to do conditional operation
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_if(struct cmdqRecStruct *handle, CMDQ_VARIABLE arg_b,
|
|
enum CMDQ_CONDITION_ENUM arg_condition, CMDQ_VARIABLE arg_c);
|
|
|
|
/* Append end if statement command
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_end_if(struct cmdqRecStruct *handle);
|
|
|
|
/* Append else statement command
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_else(struct cmdqRecStruct *handle);
|
|
|
|
/* Append if statement command
|
|
* else if (arg_b condition arg_c)
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* arg_b: the value who use to do conditional operation
|
|
* arg_condition: conditional operator
|
|
* arg_c: the value who use to do conditional operation
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_else_if(struct cmdqRecStruct *handle, CMDQ_VARIABLE arg_b,
|
|
enum CMDQ_CONDITION_ENUM arg_condition, CMDQ_VARIABLE arg_c);
|
|
|
|
/* Append while statement command
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* arg_b: the value who use to do conditional operation
|
|
* arg_condition: conditional operator
|
|
* arg_c: the value who use to do conditional operation
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_while(struct cmdqRecStruct *handle, CMDQ_VARIABLE arg_b,
|
|
enum CMDQ_CONDITION_ENUM arg_condition, CMDQ_VARIABLE arg_c);
|
|
|
|
/* Append continue statement command into while loop
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_continue(struct cmdqRecStruct *handle);
|
|
|
|
/* Append break statement command into while loop
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_break(struct cmdqRecStruct *handle);
|
|
|
|
/* Append end while statement command
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_end_while(struct cmdqRecStruct *handle);
|
|
|
|
/* Append do-while statement command
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_do_while(struct cmdqRecStruct *handle);
|
|
|
|
/* Append end do while statement command
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* arg_b: the value who use to do conditional operation
|
|
* arg_condition: conditional operator
|
|
* arg_c: the value who use to do conditional operation
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_end_do_while(struct cmdqRecStruct *handle, CMDQ_VARIABLE arg_b,
|
|
enum CMDQ_CONDITION_ENUM arg_condition, CMDQ_VARIABLE arg_c);
|
|
|
|
/* Linux like wait_event_timeout
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* arg_out, wait result (=0: timeout, >0: wait time when got event)
|
|
* wait_event: GCE event
|
|
* timeout_time: timeout time in us
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_wait_event_timeout(struct cmdqRecStruct *handle,
|
|
CMDQ_VARIABLE *arg_out, enum cmdq_event wait_event,
|
|
u32 timeout_time);
|
|
|
|
/* Append write command to the recorder
|
|
* Parameter:
|
|
* handle: the command queue recorder handle
|
|
* addr: the specified source register physical address
|
|
* arg_out: the value will be save in GCE CPR
|
|
* mask: the specified target register mask
|
|
* Return:
|
|
* 0 for success; else the error code is returned
|
|
*/
|
|
s32 cmdq_op_read_reg(struct cmdqRecStruct *handle, u32 addr,
|
|
CMDQ_VARIABLE *arg_out, u32 mask);
|
|
|
|
/* Insert instructions to write to CMDQ variable
|
|
* from a backup memory.
|
|
*/
|
|
s32 cmdq_op_read_mem(struct cmdqRecStruct *handle,
|
|
cmdqBackupSlotHandle h_backup_slot, u32 slot_index,
|
|
CMDQ_VARIABLE *arg_out);
|
|
|
|
#endif /* __CMDQ_RECORD_H__ */
|