#ifndef __CMDQ_CORE_H__ #define __CMDQ_CORE_H__ #include #include /* #include */ #include #include #include "cmdqSecTl_Api.h" #include "cmdq_def.h" #include "cmdq_core_idv.h" #include #include #ifdef CMDQ_SECURE_PATH_SUPPORT #include "cmdq_iwc_sec.h" #endif #define CMDQ_LONGSTRING_MAX (512) #define CMDQ_LOG(string, args...) do { \ if (cmdq_core_should_print_msg(LOG_LEVEL_LOG)) {\ pr_err("[CMDQ][LOG]"string, ##args); \ } \ } while (0) #define CMDQ_MSG(string, args...) do { \ if (cmdq_core_should_print_msg(LOG_LEVEL_MSG)) { \ pr_warn("[CMDQ][MSG]"string, ##args); \ } \ } while (0) #define CMDQ_VERBOSE(string, args...) do { \ if (cmdq_core_should_print_msg(LOG_LEVEL_MSG)) { \ pr_debug("[CMDQ][INFO]"string, ##args); \ } \ } while (0) #define CMDQ_ERR(string, args...) do { \ if (cmdq_core_should_print_msg(LOG_LEVEL_ERR)) {\ pr_err("[CMDQ][ERR]"string, ##args); \ } \ } while (0) #define CMDQ_DBG(string, args...) do { \ if (1) { \ pr_err("[CMDQ][DBG]"string, ##args); \ } \ } while (0) #ifdef CMDQ_AEE_READY #define CMDQ_AEE(tag, string, args...) \ do { \ pr_err("[CMDQ][AEE]"string, ##args); \ aee_kernel_warning_api(__FILE__, __LINE__, DB_OPT_DEFAULT |\ DB_OPT_PROC_CMDQ_INFO | DB_OPT_MMPROFILE_BUFFER, tag, "error: "string, ##args); \ } while (0) #else #define CMDQ_AEE(tag, string, args...) \ do { \ pr_err("[CMDQ][AEE] AEE not READY!!!"); \ pr_err("[CMDQ][AEE]"string, ##args); \ } while (0) #endif /* #define CMDQ_PROFILE */ typedef unsigned long long CMDQ_TIME; #ifdef CMDQ_PROFILE #define CMDQ_PROF_INIT() do { \ if (cmdq_core_profile_enabled()) { \ int a; \ a = met_tag_init(); \ } \ } while (0) #define CMDQ_PROF_START(args...) do { \ if (cmdq_core_profile_enabled()) { \ int a; \ a = met_tag_start(args); \ } \ } while (0) #define CMDQ_PROF_END(args...) do { \ if (cmdq_core_profile_enabled()) { \ int a; \ a = met_tag_end(args); \ } \ } while (0) #define CMDQ_PROF_ONESHOT(args...) do { \ if (cmdq_core_profile_enabled()) { \ int a; \ a = met_tag_oneshot(args); \ } \ } while (0) #define CMDQ_PROF_MMP(args...) do { \ if (1) { \ MMProfileLogEx(args); \ } \ } while (0) #else #define CMDQ_PROF_INIT() #define CMDQ_PROF_START(args...) #define CMDQ_PROF_END(args...) #define CMDQ_PROF_ONESHOT(args...) #define CMDQ_PROF_MMP(args...) #endif #define CMDQ_GET_TIME_IN_MS(start, \ end, \ duration) \ { \ CMDQ_TIME _duration = end - start; \ do_div(_duration, 1000000); \ duration = (int32_t)_duration; \ } #define CMDQ_GET_TIME_IN_US_PART(start, \ end, \ duration) \ { \ CMDQ_TIME _duration = end - start; \ do_div(_duration, 1000); \ duration = (int32_t)_duration; \ } /* */ /* address conversion for 4GB ram support: */ /* .address register: 32 bit */ /* .physical address: 32 bit, or 64 bit for CONFIG_ARCH_DMA_ADDR_T_64BIT enabled */ /* */ /* when 33 bit enabled(4GB ram), 0x_0_xxxx_xxxx and 0x_1_xxxx_xxxx access is same for CPU */ /* */ /* */ /* 0x0 0x0_4000_0000 0x1_0000_0000 0x1_4000_0000 */ /* |---1GB HW addr---|------3GB DRAM------|----1GB DRAM(new)----|-----3GB DRAM(same)------| */ /* | | */ /* |<--------------4GB RAM support---------------->| */ /* */ #define CMDQ_PHYS_TO_AREG(addr) ((addr) & 0xFFFFFFFF) /* truncate directly */ #define CMDQ_AREG_TO_PHYS(addr) ((addr) | 0L) #define CMDQ_ENG_ISP_GROUP_BITS ((1LL << CMDQ_ENG_ISP_IMGI) | \ (1LL << CMDQ_ENG_ISP_IMGO) | \ (1LL << CMDQ_ENG_ISP_IMG2O)) #define CMDQ_ENG_DISP_GROUP_BITS ((1LL << CMDQ_ENG_DISP_UFOE) | \ (1LL << CMDQ_ENG_DISP_AAL) | \ (1LL << CMDQ_ENG_DISP_COLOR0) | \ (1LL << CMDQ_ENG_DISP_COLOR1) | \ (1LL << CMDQ_ENG_DISP_RDMA0) | \ (1LL << CMDQ_ENG_DISP_RDMA1) | \ (1LL << CMDQ_ENG_DISP_RDMA2) | \ (1LL << CMDQ_ENG_DISP_WDMA0) | \ (1LL << CMDQ_ENG_DISP_WDMA1) | \ (1LL << CMDQ_ENG_DISP_OVL0) | \ (1LL << CMDQ_ENG_DISP_OVL1) | \ (1LL << CMDQ_ENG_DISP_GAMMA) | \ (1LL << CMDQ_ENG_DISP_MERGE) | \ (1LL << CMDQ_ENG_DISP_SPLIT0) | \ (1LL << CMDQ_ENG_DISP_SPLIT1) | \ (1LL << CMDQ_ENG_DISP_DSI0_VDO) | \ (1LL << CMDQ_ENG_DISP_DSI1_VDO) | \ (1LL << CMDQ_ENG_DISP_DSI0_CMD) | \ (1LL << CMDQ_ENG_DISP_DSI1_CMD) | \ (1LL << CMDQ_ENG_DISP_DSI0) | \ (1LL << CMDQ_ENG_DISP_DSI1) | \ (1LL << CMDQ_ENG_DISP_DPI)) #define CMDQ_ENG_VENC_GROUP_BITS ((1LL << CMDQ_ENG_VIDEO_ENC)) #define CMDQ_ENG_JPEG_GROUP_BITS ((1LL << CMDQ_ENG_JPEG_ENC) | \ (1LL << CMDQ_ENG_JPEG_REMDC) | \ (1LL << CMDQ_ENG_JPEG_DEC)) #define CMDQ_ENG_ISP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_ISP_GROUP_BITS)) #define CMDQ_ENG_MDP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_MDP_GROUP_BITS)) #define CMDQ_ENG_DISP_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_DISP_GROUP_BITS)) #define CMDQ_ENG_JPEG_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_JPEG_GROUP_BITS)) #define CMDQ_ENG_VENC_GROUP_FLAG(flag) ((flag) & (CMDQ_ENG_VENC_GROUP_BITS)) #define GENERATE_ENUM(_enum, _string) _enum, #define GENERATE_STRING(_enum, _string) (#_string), #define CMDQ_FOREACH_GROUP(ACTION)\ ACTION(CMDQ_GROUP_ISP, ISP) \ ACTION(CMDQ_GROUP_MDP, MDP) \ ACTION(CMDQ_GROUP_DISP, DISP) \ ACTION(CMDQ_GROUP_JPEG, JPEG) \ ACTION(CMDQ_GROUP_VENC, VENC) enum CMDQ_GROUP_ENUM { CMDQ_FOREACH_GROUP(GENERATE_ENUM) CMDQ_MAX_GROUP_COUNT, /* ALWAYS keep at the end */ }; /* engineFlag are bit fields defined in enum CMDQ_ENG_ENUM */ typedef int32_t(*CmdqClockOnCB) (uint64_t engineFlag); /* engineFlag are bit fields defined in enum CMDQ_ENG_ENUM */ typedef int32_t(*CmdqDumpInfoCB) (uint64_t engineFlag, int level); /* engineFlag are bit fields defined in enum CMDQ_ENG_ENUM */ typedef int32_t(*CmdqResetEngCB) (uint64_t engineFlag); /* engineFlag are bit fields defined in enum CMDQ_ENG_ENUM */ typedef int32_t(*CmdqClockOffCB) (uint64_t engineFlag); /* data are user data passed to APIs */ typedef int32_t(*CmdqInterruptCB) (unsigned long data); /* data are user data passed to APIs */ typedef int32_t(*CmdqAsyncFlushCB) (unsigned long data); /* TaskID is passed down from IOCTL */ /* client should fill "regCount" and "regAddress" */ /* the buffer pointed by (*regAddress) must be valid until */ /* CmdqDebugRegDumpEndCB() is called. */ typedef int32_t(*CmdqDebugRegDumpBeginCB) (uint32_t taskID, uint32_t *regCount, uint32_t **regAddress); typedef int32_t(*CmdqDebugRegDumpEndCB) (uint32_t taskID, uint32_t regCount, uint32_t *regValues); struct CmdqCBkStruct { CmdqClockOnCB clockOn; CmdqDumpInfoCB dumpInfo; CmdqResetEngCB resetEng; CmdqClockOffCB clockOff; }; struct CmdqDebugCBkStruct { /* Debug Register Dump */ CmdqDebugRegDumpBeginCB beginDebugRegDump; CmdqDebugRegDumpEndCB endDebugRegDump; }; enum CMDQ_CODE_ENUM { /* these are actual HW op code */ CMDQ_CODE_READ = 0x01, CMDQ_CODE_MOVE = 0x02, CMDQ_CODE_WRITE = 0x04, CMDQ_CODE_POLL = 0x08, CMDQ_CODE_JUMP = 0x10, CMDQ_CODE_WFE = 0x20, /* wait for event and clear */ CMDQ_CODE_EOC = 0x40, /* end of command */ /* these are pseudo op code defined by SW */ /* for instruction generation */ CMDQ_CODE_SET_TOKEN = 0x21, /* set event */ CMDQ_CODE_WAIT_NO_CLEAR = 0x22, /* wait event, but don't clear it */ CMDQ_CODE_CLEAR_TOKEN = 0x23, /* clear event */ CMDQ_CODE_RAW = 0x24, /* allow entirely custom argA/argB */ }; enum TASK_STATE_ENUM { TASK_STATE_IDLE, /* free task */ TASK_STATE_BUSY, /* task running on a thread */ TASK_STATE_KILLED, /* task process being killed */ TASK_STATE_ERROR, /* task execution error */ TASK_STATE_DONE, /* task finished */ TASK_STATE_WAITING, /* allocated but waiting for available thread */ }; struct TaskStruct { struct list_head listEntry; /* For buffer state */ enum TASK_STATE_ENUM taskState; /* task life cycle */ uint32_t *pVABase; /* virtual address of command buffer */ dma_addr_t MVABase; /* physical address of command buffer */ uint32_t bufferSize; /* size of allocated command buffer */ bool useEmergencyBuf; /* is the command buffer emergency buffer? */ /* For execution */ int32_t scenario; int32_t priority; uint64_t engineFlag; int32_t commandSize; uint32_t *pCMDEnd; int32_t reorder; int32_t thread; /* ASYNC: CMDQ_INVALID_THREAD if not running */ int32_t irqFlag; /* ASYNC: flag of IRQ received */ CmdqInterruptCB loopCallback; /* LOOP execution */ unsigned long loopData; /* LOOP execution */ CmdqAsyncFlushCB flushCallback; /* Callback on AsyncFlush (fire-and-forget) tasks */ unsigned long flushData; /* for callbacks & error handling */ struct work_struct autoReleaseWork; /* Work item when auto release is used */ /* Output section for "read from reg to mem" */ uint32_t regCount; uint32_t *regResults; dma_addr_t regResultsMVA; /* For register backup */ uint32_t regCountUserSpace; /* this is to separate backup request from user space and kernel space. */ uint32_t regUserToken; /* user data store for callback beginDebugRegDump / endDebugRegDump */ /* For seucre execution */ cmdqSecDataStruct secData; /* For statistics & debug */ CMDQ_TIME submit; /* ASYNC: task submit time (as soon as task acquired) */ CMDQ_TIME trigger; CMDQ_TIME beginWait; CMDQ_TIME gotIRQ; CMDQ_TIME wakedUp; CMDQ_TIME entrySec; /* time stamp of entry secure world */ CMDQ_TIME exitSec; /* time stamp of exit secure world */ uint32_t *profileData; /* store GPT counter when it starts and ends */ dma_addr_t profileDataPA; cmdqU32Ptr_t privateData; /* this is used to track associated file handle */ pid_t callerPid; char callerName[TASK_COMM_LEN]; }; struct EngineStruct { int32_t userCount; int32_t currOwner; int32_t resetCount; int32_t failCount; }; struct ThreadStruct { uint32_t taskCount; uint32_t waitCookie; uint32_t nextCookie; CmdqInterruptCB loopCallback; /* LOOP execution */ unsigned long loopData; /* LOOP execution */ struct TaskStruct *pCurTask[CMDQ_MAX_TASK_IN_THREAD]; /* 1 to describe thread is available to dispatch a task. 0: not available */ /* .note thread's taskCount increase when attatch a task to it. */ /* used it to prevent 2 tasks, which uses different engines, */ /* acquire same HW thread when dispatching happened before attaches task to thread */ /* .note it is align task attachment, so use cmdqExecLock to ensure atomic access */ uint32_t allowDispatching; }; struct RecordStruct { pid_t user; /* calling SW thread tid */ int32_t scenario; /* task scenario */ int32_t priority; /* task priority (not thread priority) */ int32_t thread; /* allocated thread */ int32_t reorder; uint32_t writeTimeNS; /* if profile enabled, the time of command execution */ uint64_t engineFlag; /* task engine flag */ bool isSecure; /* true for secure task */ CMDQ_TIME submit; /* epoch time of IOCTL/Kernel API call */ CMDQ_TIME trigger; /* epoch time of enable HW thread */ CMDQ_TIME beginWait; /* epoch time of start waiting for task completion */ CMDQ_TIME gotIRQ; /* epoch time of IRQ event */ CMDQ_TIME wakedUp; /* epoch time of SW thread leaving wait state */ CMDQ_TIME done; /* epoch time of task finish */ unsigned long long writeTimeNSBegin; unsigned long long writeTimeNSEnd; }; struct ErrorStruct { struct RecordStruct errorRec; /* the record of the error task */ u64 ts_nsec; /* kernel time of attach_error_task */ }; struct WriteAddrStruct { struct list_head list_node; uint32_t count; void *va; dma_addr_t pa; pid_t user; }; struct EmergencyBufferStruct { bool used; uint32_t size; void *va; dma_addr_t pa; }; struct ErrorTaskItemStruct { const struct TaskStruct *pTask; int32_t commandSize; CMDQ_TIME trigger; uint32_t *pVABase; }; struct ErrorTaskStruct { struct ErrorTaskItemStruct errorTaskBuffer[CMDQ_MAX_ERROR_COUNT]; int errTaskCount; }; struct ContextStruct { /* Task information */ struct kmem_cache *taskCache; /* struct TaskStruct object cache */ struct list_head taskFreeList; /* Unused free tasks */ struct list_head taskActiveList; /* Active tasks */ struct list_head taskWaitList; /* Tasks waiting for available thread */ struct work_struct taskConsumeWaitQueueItem; struct workqueue_struct *taskAutoReleaseWQ; /* auto-release workqueue */ struct workqueue_struct *taskConsumeWQ; /* task consumption workqueue (for queued tasks) */ /* Write Address management */ struct list_head writeAddrList; /* Basic information */ struct EngineStruct engine[CMDQ_MAX_ENGINE_COUNT]; struct ThreadStruct thread[CMDQ_MAX_THREAD_COUNT]; /* Secure path shared information */ #ifdef CMDQ_SECURE_PATH_SUPPORT cmdqSecSharedMemoryHandle hSecSharedMem; #endif void *hNotifyLoop; /* Profile information */ int32_t enableProfile; int32_t lastID; int32_t recNum; struct RecordStruct record[CMDQ_MAX_RECORD_COUNT]; struct ErrorTaskStruct errorTask; /* Error information */ enum LOG_LEVEL logLevel; int32_t errNum; struct ErrorStruct error[CMDQ_MAX_ERROR_COUNT]; }; struct PrintStruct { struct work_struct CmdqPrintWork; struct workqueue_struct *CmdqPrintWQ; bool enablePrint; }; #ifdef __cplusplus extern "C" { #endif /* log control related */ void cmdq_core_set_log_level(const enum LOG_LEVEL value); enum LOG_LEVEL cmdq_core_get_log_level(void); bool cmdq_core_should_print_msg(const enum LOG_LEVEL log_level); void cmdq_core_set_sec_print_count(uint32_t count); uint32_t cmdq_core_get_sec_print_count(void); /* extern void mt_irq_dump_status(int irq); */ extern int primary_display_check_path(char *stringbuf, int buf_len); int32_t cmdqCoreInitialize(void); void cmdqCoreInitGroupCB(void); void cmdqCoreDeinitGroupCB(void); int32_t cmdqCoreRegisterCB(enum CMDQ_GROUP_ENUM engGroup, CmdqClockOnCB clockOn, CmdqDumpInfoCB dumpInfo, CmdqResetEngCB resetEng, CmdqClockOffCB clockOff); int32_t cmdqCoreRegisterDebugRegDumpCB(CmdqDebugRegDumpBeginCB beginCB, CmdqDebugRegDumpEndCB endCB); int32_t cmdqCoreSuspend(void); int32_t cmdqCoreResume(void); int32_t cmdqCoreResumedNotifier(void); int32_t cmdqCoreEarlySuspend(void); int32_t cmdqCoreLateResume(void); bool cmdqCoreIsEarlySuspended(void); void cmdqCoreHandleIRQ(int32_t index); /** * Wait for completion of the given CmdQ task * * Parameter: * scenario: The Scnerio enumeration * priority: Desied task priority * engineFlag: HW engine involved in the CMDs * pCMDBlock: The command buffer * blockSize: Size of the command buffer * ppTaskOut: output pointer to a pTask for the resulting task * if fail, this gives NULL * loopCB: Assign this CB if your command loops itself. * since this disables thread completion handling, do not set this CB * if it is not intended to be a HW looping thread. * loopData: The user data passed to loopCB * * Return: * >=0 for success; else the error code is returned */ int32_t cmdqCoreSubmitTaskAsync(struct cmdqCommandStruct *pCommandDesc, CmdqInterruptCB loopCB, unsigned long loopData, struct TaskStruct **ppTaskOut); /** * Wait for completion of the given CmdQ task * * Parameter: * pTask: Task returned from successful cmdqCoreSubmitTaskAsync * additional cleanup will be performed. * * timeout: SW timeout error will be generated after this threshold * Return: * >=0 for success; else the error code is returned */ int32_t cmdqCoreWaitAndReleaseTask(struct TaskStruct *pTask, long timeout_jiffies); /** * Wait for completion of the given CmdQ task, and retrieve * read register result. * * Parameter: * pTask: Task returned from successful cmdqCoreSubmitTaskAsync * additional cleanup will be performed. * * timeout: SW timeout error will be generated after this threshold * Return: * >=0 for success; else the error code is returned */ int32_t cmdqCoreWaitResultAndReleaseTask(struct TaskStruct *pTask, struct cmdqRegValueStruct *pResult, long timeout_jiffies); /** * Stop task and release it immediately * * Parameter: * pTask: Task returned from successful cmdqCoreSubmitTaskAsync * additional cleanup will be performed. * * Return: * >=0 for success; else the error code is returned */ int32_t cmdqCoreReleaseTask(struct TaskStruct *pTask); /** * Register the task in the auto-release queue. It will be released * upon finishing. You MUST NOT perform further operations on this task. * * Parameter: * pTask: Task returned from successful cmdqCoreSubmitTaskAsync. * additional cleanup will be performed. * Return: * >=0 for success; else the error code is returned */ int32_t cmdqCoreAutoReleaseTask(struct TaskStruct *pTask); /** * Create CMDQ Task and block wait for its completion * * Return: * >=0 for success; else the error code is returned */ int32_t cmdqCoreSubmitTask(struct cmdqCommandStruct *pCommandDesc); /** * Helper function checking validity of a task pointer * * Return: * false if NOT a valid pointer * true if valid */ bool cmdqIsValidTaskPtr(void *pTask); /** * Immediately set CMDQ event to 1 with CPU * */ void cmdqCoreSetEvent(enum CMDQ_EVENT_ENUM event); /** * Get event value with CPU. This is for debug purpose only * since it does not guarantee atomicity. * */ uint32_t cmdqCoreGetEvent(enum CMDQ_EVENT_ENUM event); int cmdqCoreAllocWriteAddress(uint32_t count, dma_addr_t *paStart); int cmdqCoreFreeWriteAddress(dma_addr_t paStart); uint32_t cmdqCoreReadWriteAddress(dma_addr_t pa); uint32_t cmdqCoreWriteWriteAddress(dma_addr_t pa, uint32_t value); void cmdqCoreDeInitialize(void); /** * Allocate/Free HW use buffer, e.g. command buffer forCMDQ HW */ void *cmdq_core_alloc_hw_buffer(struct device *dev, size_t size, dma_addr_t *dma_handle, const gfp_t flag); void cmdq_core_free_hw_buffer(struct device *dev, size_t size, void *cpu_addr, dma_addr_t dma_handle); /** * Set a given value to CMDQ secure HW thread's THR executed count to secShareMemory * Parameter: * thread: [IN] CMDQ thread id * cookie: [IN] the desired value, which should copy from CMDQ_THR_EXEC_CMDS_CNT of secure thread * Return: * = 0 for successfully, < 0 for access failed */ int32_t cmdq_core_set_secure_thread_exec_counter(const int32_t thread, const uint32_t cookie); /** * Get CMDQ secure HW thread's THR executed count to secShareMemory * Parameter: * thread: [IN] CMDQ thread id * pCookie: [out] pointer to the cookie value * Return: * = 0 for successfully, < 0 for access failed */ int32_t cmdq_core_get_secure_thread_exec_counter(const int32_t thread, uint32_t *pCookie); #ifdef CMDQ_SECURE_PATH_SUPPORT cmdqSecSharedMemoryHandle cmdq_core_get_secure_shared_memory(void); #endif /** * Utilities */ ssize_t cmdqCorePrintRecord(struct device *dev, struct device_attribute *attr, char *buf); ssize_t cmdqCorePrintError(struct device *dev, struct device_attribute *attr, char *buf); ssize_t cmdqCorePrintStatus(struct device *dev, struct device_attribute *attr, char *buf); ssize_t cmdqCorePrintLogLevel(struct device *dev, struct device_attribute *attr, char *buf); ssize_t cmdqCoreWriteLogLevel(struct device *dev, struct device_attribute *attr, const char *buf, size_t size); ssize_t cmdqCorePrintProfileEnable(struct device *dev, struct device_attribute *attr, char *buf); ssize_t cmdqCoreWriteProfileEnable(struct device *dev, struct device_attribute *attr, const char *buf, size_t size); int32_t cmdqCoreDebugRegDumpBegin(uint32_t taskID, uint32_t *regCount, uint32_t **regAddress); int32_t cmdqCoreDebugRegDumpEnd(uint32_t taskID, uint32_t regCount, uint32_t *regValues); int32_t cmdqCoreDebugDumpCommand(struct TaskStruct *pTask); int32_t cmdqCoreQueryUsage(int32_t *pCount); int cmdqCorePrintRecordSeq(struct seq_file *m, void *v); int cmdqCorePrintErrorSeq(struct seq_file *m, void *v); int cmdqCorePrintStatusSeq(struct seq_file *m, void *v); ssize_t cmdq_read_debug_level_proc(struct file *file, char __user *pPage, size_t Count, loff_t *ppos); ssize_t cmdq_write_debug_level_proc(struct file *file, const char __user *buf, size_t count, loff_t *ppos); int32_t cmdq_subsys_from_phys_addr(uint32_t physAddr); unsigned long long cmdq_core_get_GPR64(const enum CMDQ_DATA_REGISTER_ENUM regID); void cmdq_core_set_GPR64(const enum CMDQ_DATA_REGISTER_ENUM regID, const unsigned long long value); uint32_t cmdqCoreReadDataRegister(enum CMDQ_DATA_REGISTER_ENUM regID); bool cmdq_core_profile_enabled(void); int32_t cmdq_core_enable_emergency_buffer_test(const bool enable); int32_t cmdq_core_parse_instruction(const uint32_t *pCmd, char *textBuf, int bufLen); void cmdq_core_dump_instructions(uint64_t *pInstrBuffer, uint32_t bufferSize); void cmdq_core_add_consume_task(void); const char *cmdq_core_get_event_name(enum CMDQ_EVENT_ENUM event); /* file_node is a pointer to struct cmdqFileNodeStruct that is */ /* created when opening the device file. */ void cmdq_core_release_task_by_file_node(void *file_node); void cmdqCoreLongString(bool forceLog, char *buf, uint32_t *offset, int32_t *maxSize, const char *string, ...); /* dump GIC */ void cmdq_core_dump_GIC(void); bool cmdq_core_verfiy_command_end(const struct TaskStruct *pTask); int32_t cmdq_core_set_secure_IRQ_status(uint32_t value); int32_t cmdq_core_get_secure_IRQ_status(void); #ifdef __cplusplus } #endif #ifdef CMDQ_OF_SUPPORT char *cmdq_core_get_clk_name(CMDQ_CLK_ENUM clk_enum); void cmdq_core_get_clk_map(struct platform_device *pDevice); int cmdq_core_enable_ccf_clk(CMDQ_CLK_ENUM clk_enum); int cmdq_core_disable_ccf_clk(CMDQ_CLK_ENUM clk_enum); /* int cmdq_core_enable_mtcmos_clock(bool enable); */ bool cmdq_core_clock_is_on(CMDQ_CLK_ENUM clk_enum); /* bool cmdq_core_subsys_is_on(CMDQ_SUBSYS_ENUM clk_enum); */ #endif int32_t cmdq_core_alloc_sec_metadata(struct cmdqCommandStruct *pCommandDesc, struct TaskStruct *pTask); int32_t cmdq_core_release_sec_metadata(struct TaskStruct *pTask); #if 1 bool cmdq_core_verfiy_command_end(const struct TaskStruct *pTask); bool cmdq_core_verfiy_command_desc_end(struct cmdqCommandStruct *pCommandDesc); struct ThreadStruct *cmdq_core_getThreadStruct(int threadID); #endif void cmdq_core_invalidate_hw_fetched_buffer(int32_t thread); #endif /* __CMDQ_CORE_H__ */